dirstate.py
626 lines
| 19.9 KiB
| text/x-python
|
PythonLexer
/ mercurial / dirstate.py
|
r1089 | """ | ||
dirstate.py - working directory tracking for mercurial | ||||
|
r4635 | Copyright 2005-2007 Matt Mackall <mpm@selenic.com> | ||
|
r1089 | |||
This software may be used and distributed according to the terms | ||||
of the GNU General Public License, incorporated herein by reference. | ||||
""" | ||||
|
r6211 | from node import nullid | ||
|
r3891 | from i18n import _ | ||
|
r6767 | import struct, os, bisect, stat, util, errno, ignore | ||
|
r6326 | import cStringIO, osutil, sys | ||
|
r1089 | |||
|
r4610 | _unknown = ('?', 0, 0, 0) | ||
_format = ">cllll" | ||||
|
r6767 | def _finddirs(path): | ||
pos = len(path) | ||||
while 1: | ||||
pos = path.rfind('/', 0, pos) | ||||
if pos == -1: | ||||
break | ||||
yield path[:pos] | ||||
|
r1559 | class dirstate(object): | ||
|
r2393 | |||
|
r1089 | def __init__(self, opener, ui, root): | ||
|
r4614 | self._opener = opener | ||
self._root = root | ||||
|
r4903 | self._dirty = False | ||
|
r4965 | self._dirtypl = False | ||
|
r4614 | self._ui = ui | ||
|
r1089 | |||
|
r4603 | def __getattr__(self, name): | ||
|
r4614 | if name == '_map': | ||
|
r4615 | self._read() | ||
|
r4614 | return self._map | ||
elif name == '_copymap': | ||||
|
r4615 | self._read() | ||
|
r4614 | return self._copymap | ||
|
r6677 | elif name == '_foldmap': | ||
_foldmap = {} | ||||
for name in self._map: | ||||
norm = os.path.normcase(os.path.normpath(name)) | ||||
_foldmap[norm] = name | ||||
self._foldmap = _foldmap | ||||
return self._foldmap | ||||
|
r4604 | elif name == '_branch': | ||
try: | ||||
|
r4633 | self._branch = (self._opener("branch").read().strip() | ||
or "default") | ||||
|
r4604 | except IOError: | ||
self._branch = "default" | ||||
return self._branch | ||||
|
r4614 | elif name == '_pl': | ||
self._pl = [nullid, nullid] | ||||
|
r4604 | try: | ||
|
r4614 | st = self._opener("dirstate").read(40) | ||
|
r4604 | if len(st) == 40: | ||
|
r4614 | self._pl = st[:20], st[20:40] | ||
|
r4604 | except IOError, err: | ||
if err.errno != errno.ENOENT: raise | ||||
|
r4614 | return self._pl | ||
|
r4615 | elif name == '_dirs': | ||
|
r6767 | dirs = {} | ||
for f,s in self._map.items(): | ||||
if s[0] != 'r': | ||||
for base in _finddirs(f): | ||||
dirs[base] = dirs.get(base, 0) + 1 | ||||
self._dirs = dirs | ||||
|
r4615 | return self._dirs | ||
|
r4609 | elif name == '_ignore': | ||
|
r4905 | files = [self._join('.hgignore')] | ||
|
r4620 | for name, path in self._ui.configitems("ui"): | ||
if name == 'ignore' or name.startswith('ignore.'): | ||||
files.append(os.path.expanduser(path)) | ||||
|
r4614 | self._ignore = ignore.ignore(self._root, files, self._ui.warn) | ||
|
r4609 | return self._ignore | ||
|
r4611 | elif name == '_slash': | ||
|
r4614 | self._slash = self._ui.configbool('ui', 'slash') and os.sep != '/' | ||
|
r4611 | return self._slash | ||
|
r6743 | elif name == '_checklink': | ||
self._checklink = util.checklink(self._root) | ||||
return self._checklink | ||||
|
r6257 | elif name == '_checkexec': | ||
self._checkexec = util.checkexec(self._root) | ||||
return self._checkexec | ||||
|
r6746 | elif name == '_checkcase': | ||
self._checkcase = not util.checkcase(self._join('.hg')) | ||||
return self._checkcase | ||||
|
r6677 | elif name == 'normalize': | ||
|
r6746 | if self._checkcase: | ||
|
r6677 | self.normalize = self._normalize | ||
else: | ||||
self.normalize = lambda x: x | ||||
return self.normalize | ||||
|
r4603 | else: | ||
raise AttributeError, name | ||||
|
r4905 | def _join(self, f): | ||
|
r4614 | return os.path.join(self._root, f) | ||
|
r1089 | |||
|
r6743 | def flagfunc(self, fallback): | ||
if self._checklink: | ||||
if self._checkexec: | ||||
def f(x): | ||||
p = os.path.join(self._root, x) | ||||
if os.path.islink(p): | ||||
return 'l' | ||||
if util.is_exec(p): | ||||
return 'x' | ||||
return '' | ||||
return f | ||||
def f(x): | ||||
if os.path.islink(os.path.join(self._root, x)): | ||||
return 'l' | ||||
if 'x' in fallback(x): | ||||
return 'x' | ||||
return '' | ||||
return f | ||||
if self._checkexec: | ||||
def f(x): | ||||
if 'l' in fallback(x): | ||||
return 'l' | ||||
if util.is_exec(os.path.join(self._root, x)): | ||||
return 'x' | ||||
return '' | ||||
return f | ||||
return fallback | ||||
|
r1089 | def getcwd(self): | ||
cwd = os.getcwd() | ||||
|
r4614 | if cwd == self._root: return '' | ||
# self._root ends with a path separator if self._root is '/' or 'C:\' | ||||
rootsep = self._root | ||||
|
r5843 | if not util.endswithsep(rootsep): | ||
|
r4230 | rootsep += os.sep | ||
if cwd.startswith(rootsep): | ||||
return cwd[len(rootsep):] | ||||
else: | ||||
# we're outside the repo. return an absolute path. | ||||
return cwd | ||||
|
r1089 | |||
|
r4525 | def pathto(self, f, cwd=None): | ||
if cwd is None: | ||||
cwd = self.getcwd() | ||||
|
r4614 | path = util.pathto(self._root, cwd, f) | ||
|
r4527 | if self._slash: | ||
|
r5842 | return util.normpath(path) | ||
|
r4527 | return path | ||
|
r4525 | |||
|
r1089 | def __getitem__(self, key): | ||
|
r4906 | ''' current states: | ||
n normal | ||||
m needs merging | ||||
r marked for removal | ||||
a marked for addition | ||||
? not tracked''' | ||||
return self._map.get(key, ("?",))[0] | ||||
|
r1089 | |||
def __contains__(self, key): | ||||
|
r4614 | return key in self._map | ||
def __iter__(self): | ||||
|
r6762 | for x in util.sort(self._map): | ||
|
r4614 | yield x | ||
|
r1089 | |||
def parents(self): | ||||
|
r4614 | return self._pl | ||
|
r1089 | |||
|
r4179 | def branch(self): | ||
return self._branch | ||||
|
r1089 | def setparents(self, p1, p2=nullid): | ||
|
r4965 | self._dirty = self._dirtypl = True | ||
|
r4614 | self._pl = p1, p2 | ||
|
r1089 | |||
|
r4179 | def setbranch(self, branch): | ||
self._branch = branch | ||||
|
r4614 | self._opener("branch", "w").write(branch + '\n') | ||
|
r4179 | |||
|
r4615 | def _read(self): | ||
|
r4614 | self._map = {} | ||
self._copymap = {} | ||||
|
r4952 | if not self._dirtypl: | ||
self._pl = [nullid, nullid] | ||||
|
r4607 | try: | ||
|
r4614 | st = self._opener("dirstate").read() | ||
|
r4607 | except IOError, err: | ||
if err.errno != errno.ENOENT: raise | ||||
return | ||||
if not st: | ||||
return | ||||
|
r4952 | if not self._dirtypl: | ||
self._pl = [st[:20], st[20: 40]] | ||||
|
r1089 | |||
|
r2427 | # deref fields so they will be local in loop | ||
|
r4614 | dmap = self._map | ||
copymap = self._copymap | ||||
|
r2427 | unpack = struct.unpack | ||
|
r4610 | e_size = struct.calcsize(_format) | ||
|
r5327 | pos1 = 40 | ||
l = len(st) | ||||
|
r2427 | |||
|
r5327 | # the inner loop | ||
while pos1 < l: | ||||
pos2 = pos1 + e_size | ||||
e = unpack(">cllll", st[pos1:pos2]) # a literal here is faster | ||||
pos1 = pos2 + e[4] | ||||
f = st[pos2:pos1] | ||||
|
r1089 | if '\0' in f: | ||
f, c = f.split('\0') | ||||
|
r3154 | copymap[f] = c | ||
|
r5327 | dmap[f] = e # we hold onto e[4] because making a subtuple is slow | ||
|
r1089 | |||
|
r4613 | def invalidate(self): | ||
|
r6677 | for a in "_map _copymap _foldmap _branch _pl _dirs _ignore".split(): | ||
|
r4953 | if a in self.__dict__: | ||
delattr(self, a) | ||||
|
r4903 | self._dirty = False | ||
|
r4375 | |||
|
r1089 | def copy(self, source, dest): | ||
|
r6680 | if source == dest: | ||
return | ||||
|
r4903 | self._dirty = True | ||
|
r4614 | self._copymap[dest] = source | ||
|
r1089 | |||
def copied(self, file): | ||||
|
r4614 | return self._copymap.get(file, None) | ||
|
r3154 | |||
def copies(self): | ||||
|
r4614 | return self._copymap | ||
|
r1089 | |||
|
r6767 | def _droppath(self, f): | ||
if self[f] not in "?r" and "_dirs" in self.__dict__: | ||||
|
r5326 | dirs = self._dirs | ||
|
r6767 | for base in _finddirs(f): | ||
if dirs[base] == 1: | ||||
del dirs[base] | ||||
else: | ||||
dirs[base] -= 1 | ||||
|
r2953 | |||
|
r6767 | def _addpath(self, f, check=False): | ||
|
r5487 | oldstate = self[f] | ||
|
r6767 | if check or oldstate == "r": | ||
if '\r' in f or '\n' in f: | ||||
raise util.Abort( | ||||
_("'\\n' and '\\r' disallowed in filenames: %r") % f) | ||||
if f in self._dirs: | ||||
raise util.Abort(_('directory %r already in dirstate') % f) | ||||
# shadows | ||||
for d in _finddirs(f): | ||||
if d in self._dirs: | ||||
break | ||||
if d in self._map and self[d] != 'r': | ||||
raise util.Abort( | ||||
_('file %r in dirstate clashes with %r') % (d, f)) | ||||
if oldstate in "?r" and "_dirs" in self.__dict__: | ||||
dirs = self._dirs | ||||
for base in _finddirs(f): | ||||
dirs[base] = dirs.get(base, 0) + 1 | ||||
|
r5487 | |||
|
r4904 | def normal(self, f): | ||
|
r5210 | 'mark a file normal and clean' | ||
|
r4904 | self._dirty = True | ||
|
r6767 | self._addpath(f) | ||
|
r4905 | s = os.lstat(self._join(f)) | ||
|
r5327 | self._map[f] = ('n', s.st_mode, s.st_size, s.st_mtime, 0) | ||
|
r5915 | if f in self._copymap: | ||
|
r4904 | del self._copymap[f] | ||
|
r1089 | |||
|
r5210 | def normallookup(self, f): | ||
|
r4904 | 'mark a file normal, but possibly dirty' | ||
|
r6298 | if self._pl[1] != nullid and f in self._map: | ||
# if there is a merge going on and the file was either | ||||
# in state 'm' or dirty before being removed, restore that state. | ||||
entry = self._map[f] | ||||
if entry[0] == 'r' and entry[2] in (-1, -2): | ||||
source = self._copymap.get(f) | ||||
if entry[2] == -1: | ||||
self.merge(f) | ||||
elif entry[2] == -2: | ||||
self.normaldirty(f) | ||||
if source: | ||||
self.copy(source, f) | ||||
return | ||||
if entry[0] == 'm' or entry[0] == 'n' and entry[2] == -2: | ||||
return | ||||
|
r4903 | self._dirty = True | ||
|
r6767 | self._addpath(f) | ||
|
r5327 | self._map[f] = ('n', 0, -1, -1, 0) | ||
|
r5210 | if f in self._copymap: | ||
del self._copymap[f] | ||||
def normaldirty(self, f): | ||||
'mark a file normal, but dirty' | ||||
self._dirty = True | ||||
|
r6767 | self._addpath(f) | ||
|
r5327 | self._map[f] = ('n', 0, -2, -1, 0) | ||
|
r4904 | if f in self._copymap: | ||
del self._copymap[f] | ||||
def add(self, f): | ||||
'mark a file added' | ||||
self._dirty = True | ||||
|
r6767 | self._addpath(f, True) | ||
|
r5327 | self._map[f] = ('a', 0, -1, -1, 0) | ||
|
r4904 | if f in self._copymap: | ||
del self._copymap[f] | ||||
|
r4616 | |||
|
r4904 | def remove(self, f): | ||
'mark a file removed' | ||||
self._dirty = True | ||||
|
r6767 | self._droppath(f) | ||
|
r6297 | size = 0 | ||
if self._pl[1] != nullid and f in self._map: | ||||
entry = self._map[f] | ||||
if entry[0] == 'm': | ||||
size = -1 | ||||
elif entry[0] == 'n' and entry[2] == -2: | ||||
size = -2 | ||||
self._map[f] = ('r', 0, size, 0, 0) | ||||
if size == 0 and f in self._copymap: | ||||
|
r4904 | del self._copymap[f] | ||
|
r1089 | |||
|
r4904 | def merge(self, f): | ||
'mark a file merged' | ||||
|
r4903 | self._dirty = True | ||
|
r4905 | s = os.lstat(self._join(f)) | ||
|
r6767 | self._addpath(f) | ||
|
r5327 | self._map[f] = ('m', s.st_mode, s.st_size, s.st_mtime, 0) | ||
|
r4904 | if f in self._copymap: | ||
del self._copymap[f] | ||||
def forget(self, f): | ||||
'forget a file' | ||||
self._dirty = True | ||||
try: | ||||
|
r6807 | self._droppath(f) | ||
|
r4904 | del self._map[f] | ||
except KeyError: | ||||
|
r6057 | self._ui.warn(_("not in dirstate: %s\n") % f) | ||
|
r1089 | |||
|
r6677 | def _normalize(self, path): | ||
normpath = os.path.normcase(os.path.normpath(path)) | ||||
if normpath in self._foldmap: | ||||
return self._foldmap[normpath] | ||||
elif os.path.exists(path): | ||||
self._foldmap[normpath] = util.fspath(path, self._root) | ||||
return self._foldmap[normpath] | ||||
else: | ||||
return path | ||||
|
r5065 | def clear(self): | ||
self._map = {} | ||||
|
r5487 | if "_dirs" in self.__dict__: | ||
delattr(self, "_dirs"); | ||||
|
r5065 | self._copymap = {} | ||
self._pl = [nullid, nullid] | ||||
|
r5123 | self._dirty = True | ||
|
r5065 | |||
|
r1755 | def rebuild(self, parent, files): | ||
|
r5065 | self.clear() | ||
|
r2832 | for f in files: | ||
|
r6750 | if 'x' in files.flags(f): | ||
|
r5327 | self._map[f] = ('n', 0777, -1, 0, 0) | ||
|
r1755 | else: | ||
|
r5327 | self._map[f] = ('n', 0666, -1, 0, 0) | ||
|
r4614 | self._pl = (parent, nullid) | ||
|
r4903 | self._dirty = True | ||
|
r1089 | |||
def write(self): | ||||
|
r4612 | if not self._dirty: | ||
|
r1794 | return | ||
|
r6326 | st = self._opener("dirstate", "w", atomictemp=True) | ||
|
r6327 | |||
try: | ||||
gran = int(self._ui.config('dirstate', 'granularity', 1)) | ||||
except ValueError: | ||||
gran = 1 | ||||
limit = sys.maxint | ||||
if gran > 0: | ||||
limit = util.fstat(st).st_mtime - gran | ||||
|
r4374 | cs = cStringIO.StringIO() | ||
|
r5327 | copymap = self._copymap | ||
pack = struct.pack | ||||
write = cs.write | ||||
write("".join(self._pl)) | ||||
|
r4614 | for f, e in self._map.iteritems(): | ||
|
r5327 | if f in copymap: | ||
f = "%s\0%s" % (f, copymap[f]) | ||||
|
r6326 | if e[3] > limit and e[0] == 'n': | ||
e = (e[0], 0, -1, -1, 0) | ||||
|
r5327 | e = pack(_format, e[0], e[1], e[2], e[3], len(f)) | ||
write(e) | ||||
write(f) | ||||
|
r4374 | st.write(cs.getvalue()) | ||
|
r4507 | st.rename() | ||
|
r4965 | self._dirty = self._dirtypl = False | ||
|
r1089 | |||
|
r5001 | def _supported(self, f, mode, verbose=False): | ||
if stat.S_ISREG(mode) or stat.S_ISLNK(mode): | ||||
|
r1487 | return True | ||
if verbose: | ||||
kind = 'unknown' | ||||
|
r5001 | if stat.S_ISCHR(mode): kind = _('character device') | ||
elif stat.S_ISBLK(mode): kind = _('block device') | ||||
elif stat.S_ISFIFO(mode): kind = _('fifo') | ||||
elif stat.S_ISSOCK(mode): kind = _('socket') | ||||
elif stat.S_ISDIR(mode): kind = _('directory') | ||||
|
r4614 | self._ui.warn(_('%s: unsupported file type (type is %s)\n') | ||
|
r4633 | % (self.pathto(f), kind)) | ||
|
r1487 | return False | ||
|
r6032 | def _dirignore(self, f): | ||
|
r6479 | if f == '.': | ||
return False | ||||
|
r6032 | if self._ignore(f): | ||
return True | ||||
|
r6767 | for p in _finddirs(f): | ||
if self._ignore(p): | ||||
|
r6032 | return True | ||
return False | ||||
|
r6755 | def walk(self, match, unknown, ignored): | ||
|
r3529 | ''' | ||
walk recursively through the directory tree, finding all files | ||||
matched by the match function | ||||
|
r6818 | results are yielded in a tuple (filename, stat), where stat | ||
|
r3529 | and st is the stat result if the file was found in the directory. | ||
''' | ||||
|
r1089 | |||
|
r6578 | def fwarn(f, msg): | ||
self._ui.warn('%s: %s\n' % (self.pathto(ff), msg)) | ||||
return False | ||||
|
r6589 | badfn = fwarn | ||
if hasattr(match, 'bad'): | ||||
badfn = match.bad | ||||
|
r6578 | |||
|
r6819 | files = util.unique(match.files()) | ||
if not files or '.' in files: | ||||
files = [''] | ||||
|
r6821 | dmap = self._map | ||
|
r1089 | |||
|
r3529 | def imatch(file_): | ||
|
r6821 | if file_ not in dmap and self._ignore(file_): | ||
|
r1183 | return False | ||
|
r1749 | return match(file_) | ||
|
r1224 | |||
|
r6201 | # TODO: don't walk unknown directories if unknown and ignored are False | ||
|
r4609 | ignore = self._ignore | ||
|
r6032 | dirignore = self._dirignore | ||
|
r4193 | if ignored: | ||
imatch = match | ||||
ignore = util.never | ||||
|
r6032 | dirignore = util.never | ||
|
r3534 | |||
|
r4614 | # self._root may end with a path separator when self._root == '/' | ||
common_prefix_len = len(self._root) | ||||
|
r5843 | if not util.endswithsep(self._root): | ||
|
r2671 | common_prefix_len += 1 | ||
|
r5000 | |||
normpath = util.normpath | ||||
|
r5396 | listdir = osutil.listdir | ||
|
r5000 | lstat = os.lstat | ||
bisect_left = bisect.bisect_left | ||||
isdir = os.path.isdir | ||||
pconvert = util.pconvert | ||||
join = os.path.join | ||||
s_isdir = stat.S_ISDIR | ||||
supported = self._supported | ||||
|
r5001 | _join = self._join | ||
|
r6820 | work = [] | ||
wadd = work.append | ||||
found = [] | ||||
add = found.append | ||||
|
r6821 | seen = {'.hg': 1} | ||
|
r5000 | |||
|
r6820 | # step one, find all files that match our criteria | ||
for ff in util.sort(files): | ||||
nf = normpath(ff) | ||||
nn = self.normalize(nf) | ||||
f = _join(ff) | ||||
|
r6821 | if nn in seen: | ||
|
r6820 | continue | ||
try: | ||||
st = lstat(f) | ||||
except OSError, inst: | ||||
keep = False | ||||
|
r6821 | for fn in dmap: | ||
|
r6820 | if nf == fn or (fn.startswith(nf) and fn[len(nf)] == '/'): | ||
keep = True | ||||
break | ||||
if not keep: | ||||
if inst.errno != errno.ENOENT: | ||||
fwarn(ff, inst.strerror) | ||||
elif badfn(ff, inst.strerror) and imatch(nf): | ||||
yield ff, None | ||||
continue | ||||
if not s_isdir(st.st_mode): | ||||
|
r6821 | seen[nn] = 1 | ||
|
r6820 | if supported(ff, st.st_mode, verbose=True): | ||
yield self.normalize(nf), st | ||||
|
r6821 | elif ff in dmap: | ||
|
r6820 | yield nf, None | ||
continue | ||||
if dirignore(nf): | ||||
continue | ||||
|
r6588 | if hasattr(match, 'dir'): | ||
|
r6820 | match.dir(normpath(f[common_prefix_len:])) | ||
wadd(f) | ||||
|
r1183 | while work: | ||
top = work.pop() | ||||
|
r5396 | entries = listdir(top, stat=True) | ||
|
r1183 | # nd is the top of the repository dir tree | ||
|
r5000 | nd = normpath(top[common_prefix_len:]) | ||
|
r2061 | if nd == '.': | ||
nd = '' | ||||
else: | ||||
|
r2063 | # do not recurse into a repo contained in this | ||
# one. use bisect to find .hg directory so speed | ||||
# is good on big directory. | ||||
|
r5396 | names = [e[0] for e in entries] | ||
|
r5000 | hg = bisect_left(names, '.hg') | ||
|
r2061 | if hg < len(names) and names[hg] == '.hg': | ||
|
r5000 | if isdir(join(top, '.hg')): | ||
|
r2061 | continue | ||
|
r5396 | for f, kind, st in entries: | ||
|
r5001 | np = pconvert(join(nd, f)) | ||
|
r6756 | nn = self.normalize(np) | ||
|
r6821 | if np in seen: | ||
|
r1183 | continue | ||
|
r6821 | seen[nn] = 1 | ||
|
r5000 | p = join(top, f) | ||
|
r1228 | # don't trip over symlinks | ||
|
r5396 | if kind == stat.S_IFDIR: | ||
|
r4254 | if not ignore(np): | ||
|
r5002 | wadd(p) | ||
|
r6588 | if hasattr(match, 'dir'): | ||
match.dir(np) | ||||
|
r6821 | if np in dmap and match(np): | ||
|
r6818 | add((nn, None)) | ||
|
r3529 | elif imatch(np): | ||
|
r5001 | if supported(np, st.st_mode): | ||
|
r6818 | add((nn, st)) | ||
|
r6821 | elif np in dmap: | ||
|
r6818 | add((nn, None)) | ||
|
r6820 | for e in util.sort(found): | ||
yield e | ||||
|
r1089 | |||
|
r6821 | # step two run through anything left in the dmap hash and yield | ||
|
r1183 | # if we haven't already seen it | ||
|
r6821 | for f in util.sort(dmap): | ||
if f in seen or not match(f): | ||||
|
r5001 | continue | ||
|
r6821 | seen[f] = 1 | ||
|
r6819 | try: | ||
st = lstat(_join(f)) | ||||
if supported(f, st.st_mode): | ||||
yield f, st | ||||
continue | ||||
except OSError, inst: | ||||
if inst.errno not in (errno.ENOENT, errno.ENOTDIR): | ||||
raise | ||||
yield f, None | ||||
|
r1089 | |||
|
r6753 | def status(self, match, ignored, clean, unknown): | ||
listignored, listclean, listunknown = ignored, clean, unknown | ||||
|
r2022 | lookup, modified, added, unknown, ignored = [], [], [], [], [] | ||
|
r2661 | removed, deleted, clean = [], [], [] | ||
|
r1089 | |||
|
r5003 | _join = self._join | ||
lstat = os.lstat | ||||
cmap = self._copymap | ||||
dmap = self._map | ||||
ladd = lookup.append | ||||
madd = modified.append | ||||
aadd = added.append | ||||
uadd = unknown.append | ||||
iadd = ignored.append | ||||
radd = removed.append | ||||
dadd = deleted.append | ||||
cadd = clean.append | ||||
|
r6818 | for fn, st in self.walk(match, listunknown, listignored): | ||
|
r6591 | if fn not in dmap: | ||
|
r6753 | if (listignored or match.exact(fn)) and self._dirignore(fn): | ||
if listignored: | ||||
|
r6033 | iadd(fn) | ||
|
r6753 | elif listunknown: | ||
|
r5003 | uadd(fn) | ||
|
r1471 | continue | ||
|
r6591 | |||
state, mode, size, time, foo = dmap[fn] | ||||
|
r6818 | if not st and state in "nma": | ||
dadd(fn) | ||||
elif state == 'n': | ||||
|
r6257 | if (size >= 0 and | ||
(size != st.st_size | ||||
or ((mode ^ st.st_mode) & 0100 and self._checkexec)) | ||||
|
r5210 | or size == -2 | ||
|
r4677 | or fn in self._copymap): | ||
|
r5003 | madd(fn) | ||
|
r2962 | elif time != int(st.st_mtime): | ||
|
r5003 | ladd(fn) | ||
|
r6753 | elif listclean: | ||
|
r5003 | cadd(fn) | ||
|
r6590 | elif state == 'm': | ||
|
r5003 | madd(fn) | ||
|
r6590 | elif state == 'a': | ||
|
r5003 | aadd(fn) | ||
|
r6590 | elif state == 'r': | ||
|
r5003 | radd(fn) | ||
|
r1183 | |||
|
r2661 | return (lookup, modified, added, removed, deleted, unknown, ignored, | ||
clean) | ||||