mercurial-scm/hg: comparison mercurial/dirstate.py

equal deleted inserted replaced

-:57875cf423c9
+:2372284d9457
 parsers = policy.importmod(r'parsers')
 rustmod = policy.importrust(r'dirstate')
 propertycache = util.propertycache
 filecache = scmutil.filecache
-_rangemask = 0x7fffffff
+_rangemask = 0x7FFFFFFF
 dirstatetuple = parsers.dirstatetuple
 class repocache(filecache):
 """filecache for files in .hg/"""
 def join(self, obj, fname):
 return obj._opener.join(fname)
 class rootcache(filecache):
 """filecache for files in the repository root"""
 def join(self, obj, fname):
 return obj._join(fname)
 def _getfsnow(vfs):
 '''Get "now" timestamp on filesystem'''
 tmpfd, tmpname = vfs.mkstemp()
 try:
 return os.fstat(tmpfd)[stat.ST_MTIME]
 finally:
 os.close(tmpfd)
 vfs.unlink(tmpname)
 @interfaceutil.implementer(intdirstate.idirstate)
 class dirstate(object):
 def __init__(self, opener, ui, root, validate, sparsematchfn):
 '''Create a new dirstate object.
 opener is an open()-like callable that can be used to open the
 dirstate file; root is the root of the directory tracked by
 # it's safe because f is always a relative path
 return self._rootdir + f
 def flagfunc(self, buildfallback):
 if self._checklink and self._checkexec:
 def f(x):
 try:
 st = os.lstat(self._join(x))
 if util.statislink(st):
 return 'l'
 if util.statisexec(st):
 return 'x'
 except OSError:
 pass
 return ''
 return f
 fallback = buildfallback()
 if self._checklink:
 def f(x):
 if os.path.islink(self._join(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.isexec(self._join(x)):
 return 'x'
 return ''
 return f
 else:
 return fallback
 @propertycache
 # self._root ends with a path separator if self._root is '/' or 'C:\'
 rootsep = self._root
 if not util.endswithsep(rootsep):
 rootsep += pycompat.ossep
 if cwd.startswith(rootsep):
-return cwd[len(rootsep):]
+return cwd[len(rootsep) :]
 else:
 # we're outside the repo. return an absolute path.
 return cwd
 def pathto(self, f, cwd=None):
 returned by the call.
 See localrepo.setparents()
 """
 if self._parentwriters == 0:
-raise ValueError("cannot set dirstate parent outside of "
+raise ValueError(
-"dirstate.parentchange context manager")
+"cannot set dirstate parent outside of "
+"dirstate.parentchange context manager"
+)
 self._dirty = True
 oldp2 = self._pl[1]
 if self._origpl is None:
 self._origpl = self._pl
 self._map.setparents(p1, p2)
 copies = {}
 if oldp2 != nullid and p2 == nullid:
 candidatefiles = self._map.nonnormalset.union(
-self._map.otherparentset)
+self._map.otherparentset
+)
 for f in candidatefiles:
 s = self._map.get(f)
 if s is None:
 continue
 # make sure filecache has the correct stat info for _branch after
 # replacing the underlying file
 ce = self._filecache['_branch']
 if ce:
 ce.refresh()
-except: # re-raises
+except:  # re-raises
 f.discard()
 raise
 def invalidate(self):
 '''Causes the next access to reread the dirstate.
 def _addpath(self, f, state, mode, size, mtime):
 oldstate = self[f]
 if state == 'a' or oldstate == 'r':
 scmutil.checkfilename(f)
 if self._map.hastrackeddir(f):
-raise error.Abort(_('directory %r already in dirstate') %
+raise error.Abort(
-pycompat.bytestr(f))
+_('directory %r already in dirstate') % pycompat.bytestr(f)
+)
 # shadows
 for d in util.finddirs(f):
 if self._map.hastrackeddir(d):
 break
 entry = self._map.get(d)
 if entry is not None and entry[0] != 'r':
 raise error.Abort(
-_('file %r in dirstate clashes with %r') %
+_('file %r in dirstate clashes with %r')
-(pycompat.bytestr(d), pycompat.bytestr(f)))
+% (pycompat.bytestr(d), pycompat.bytestr(f))
+)
 self._dirty = True
 self._updatedfiles.add(f)
 self._map.addfile(f, oldstate, state, mode, size, mtime)
 def normal(self, f, parentfiledata=None):
 self._map.copymap.pop(f, None)
 def otherparent(self, f):
 '''Mark as coming from the other parent, always dirty.'''
 if self._pl[1] == nullid:
-raise error.Abort(_("setting %r to other parent "
+raise error.Abort(
-"only allowed in merges") % f)
+_("setting %r to other parent " "only allowed in merges") % f
+)
 if f in self and self[f] == 'n':
 # merge-like
 self._addpath(f, 'm', 0, -2, -1)
 else:
 # add-like
 size = 0
 if self._pl[1] != nullid:
 entry = self._map.get(f)
 if entry is not None:
 # backup the previous state
-if entry[0] == 'm': # merge
+if entry[0] == 'm':  # merge
 size = -1
-elif entry[0] == 'n' and entry[2] == -2: # other parent
+elif entry[0] == 'n' and entry[2] == -2:  # other parent
 size = -2
 self._map.otherparentset.add(f)
 self._updatedfiles.add(f)
 self._map.removefile(f, oldstate, size)
 if size == 0:
 folded = self._map.filefoldmap.get(normed, None)
 if folded is None:
 if isknown:
 folded = path
 else:
-folded = self._discoverpath(path, normed, ignoremissing, exists,
+folded = self._discoverpath(
-self._map.filefoldmap)
+path, normed, ignoremissing, exists, self._map.filefoldmap
+)
 return folded
 def _normalize(self, path, isknown, ignoremissing=False, exists=None):
 normed = util.normcase(path)
 folded = self._map.filefoldmap.get(normed, None)
 if isknown:
 folded = path
 else:
 # store discovered result in dirfoldmap so that future
 # normalizefile calls don't start matching directories
-folded = self._discoverpath(path, normed, ignoremissing, exists,
+folded = self._discoverpath(
-self._map.dirfoldmap)
+path, normed, ignoremissing, exists, self._map.dirfoldmap
+)
 return folded
 def normalize(self, path, isknown=False, ignoremissing=False):
 '''
 normalize the case of a pathname when on a casefolding filesystem
 # emulate that all 'dirstate.normal' results are written out
 self._lastnormaltime = 0
 self._updatedfiles.clear()
 # delay writing in-memory changes out
-tr.addfilegenerator('dirstate', (self._filename,),
+tr.addfilegenerator(
-self._writedirstate, location='plain')
+'dirstate',
+(self._filename,),
+self._writedirstate,
+location='plain',
+)
 return
 st = self._opener(filename, "w", atomictemp=True, checkambig=True)
 self._writedirstate(st)
 if delaywrite > 0:
 # do we have any files to delay for?
 items = self._map.iteritems()
 for f, e in items:
 if e[0] == 'n' and e[3] == now:
-import time # to avoid useless import
+import time  # to avoid useless import
 # rather than sleep n seconds, sleep until the next
 # multiple of n seconds
 clock = time.time()
 start = int(clock) - (int(clock) % delaywrite)
 end = start + delaywrite
 time.sleep(end - clock)
-now = end # trust our estimate that the end is near now
+now = end  # trust our estimate that the end is near now
 break
 # since the iterator is potentially not deleted,
 # delete the iterator to release the reference for the Rust
 # implementation.
 # TODO make the Rust implementation behave like Python
 def _ignorefileandline(self, f):
 files = collections.deque(self._ignorefiles())
 visited = set()
 while files:
 i = files.popleft()
-patterns = matchmod.readpatternfile(i, self._ui.warn,
+patterns = matchmod.readpatternfile(
-sourceinfo=True)
+i, self._ui.warn, sourceinfo=True
+)
 for pattern, lineno, line in patterns:
 kind, p = matchmod._patsplit(pattern, 'glob')
 if kind == "subinclude":
 if p not in visited:
 files.append(p)
 continue
-m = matchmod.match(self._root, '', [], [pattern],
+m = matchmod.match(
-warn=self._ui.warn)
+self._root, '', [], [pattern], warn=self._ui.warn
+)
 if m(f):
 return (i, lineno, line)
 visited.add(i)
 return (None, -1, "")
 results[nf] = st
 else:
 badfn(ff, badtype(kind))
 if nf in dmap:
 results[nf] = None
-except OSError as inst: # nf not found on disk - it is dirstate only
+except OSError as inst:  # nf not found on disk - it is dirstate only
-if nf in dmap: # does it exactly match a missing file?
+if nf in dmap:  # does it exactly match a missing file?
 results[nf] = None
-else: # does it match a missing directory?
+else:  # does it match a missing directory?
 if self._map.hasdir(nf):
 if matchedir:
 matchedir(nf)
 notfoundadd(nf)
 else:
 paths.add(f)
 for norm, paths in normed.iteritems():
 if len(paths) > 1:
 for path in paths:
-folded = self._discoverpath(path, norm, True, None,
+folded = self._discoverpath(
-self._map.dirfoldmap)
+path, norm, True, None, self._map.dirfoldmap
+)
 if path != folded:
 results[path] = None
 return results, dirsfound, dirsnotfound
 regkind = stat.S_IFREG
 lnkkind = stat.S_IFLNK
 join = self._join
 exact = skipstep3 = False
-if match.isexact(): # match.exact
+if match.isexact():  # match.exact
 exact = True
-dirignore = util.always # skip step 2
+dirignore = util.always  # skip step 2
-elif match.prefix(): # match.match, no patterns
+elif match.prefix():  # match.match, no patterns
 skipstep3 = True
 if not exact and self._checkcase:
 normalize = self._normalize
 normalizefile = self._normalizefile
 skip = '.hg'
 try:
 entries = listdir(join(nd), stat=True, skip=skip)
 except OSError as inst:
 if inst.errno in (errno.EACCES, errno.ENOENT):
-match.bad(self.pathto(nd),
+match.bad(
-encoding.strtolocal(inst.strerror))
+self.pathto(nd), encoding.strtolocal(inst.strerror)
+)
 continue
 raise
 for f, kind, st in entries:
 # Some matchers may return files in the visitentries set,
 # instead of 'this', if the matcher explicitly mentions them
 continue
 if normalizefile:
 # even though f might be a directory, we're only
 # interested in comparing it to files currently in the
 # dmap -- therefore normalizefile is enough
-nf = normalizefile(nd and (nd + "/" + f) or f, True,
+nf = normalizefile(
-True)
+nd and (nd + "/" + f) or f, True, True
+)
 else:
 nf = nd and (nd + "/" + f) or f
 if nf not in results:
 if kind == dirkind:
 if not ignore(nf):
 results[nf] = None
 elif kind == regkind or kind == lnkkind:
 if nf in dmap:
 if matchalways or matchfn(nf):
 results[nf] = st
-elif ((matchalways or matchfn(nf))
+elif (matchalways or matchfn(nf)) and not ignore(
-and not ignore(nf)):
+nf
+):
 # unknown file -- normalize if necessary
 if not alreadynormed:
 nf = normalize(nf, False, True)
 results[nf] = st
 elif nf in dmap and (matchalways or matchfn(nf)):
 for nf in iter(visit):
 # If a stat for the same file was already added with a
 # different case, don't add one for this, since that would
 # make it appear as if the file exists under both names
 # on disk.
-if (normalizefile and
+if (
-normalizefile(nf, True, True) in results):
+normalizefile
+and normalizefile(nf, True, True) in results
+):
 results[nf] = None
 # Report ignored items in the dmap as long as they are not
 # under a symlink directory.
 elif audit_path.check(nf):
 try:
 dmap = self._map
 dmap.preload()
 dcontains = dmap.__contains__
 dget = dmap.__getitem__
-ladd = lookup.append            # aka "unsure"
+ladd = lookup.append  # aka "unsure"
 madd = modified.append
 aadd = added.append
 uadd = unknown.append
 iadd = ignored.append
 radd = removed.append
 # We need to do full walks when either
 # - we're listing all clean files, or
 # - match.traversedir does something, because match.traversedir should
 #   be called for every dir in the working dir
 full = listclean or match.traversedir is not None
-for fn, st in self.walk(match, subrepos, listunknown, listignored,
+for fn, st in self.walk(
-full=full).iteritems():
+match, subrepos, listunknown, listignored, full=full
+).iteritems():
 if not dcontains(fn):
 if (listignored or mexact(fn)) and dirignore(fn):
 if listignored:
 iadd(fn)
 else:
 time = t[3]
 if not st and state in "nma":
 dadd(fn)
 elif state == 'n':
-if (size >= 0 and
+if (
-((size != st.st_size and size != st.st_size & _rangemask)
+size >= 0
-or ((mode ^ st.st_mode) & 0o100 and checkexec))
+and (
-or size == -2 # other parent
+(size != st.st_size and size != st.st_size & _rangemask)
-or fn in copymap):
+or ((mode ^ st.st_mode) & 0o100 and checkexec)
+)
+or size == -2  # other parent
+or fn in copymap
+):
 madd(fn)
-elif (time != st[stat.ST_MTIME]
+elif (
-and time != st[stat.ST_MTIME] & _rangemask):
+time != st[stat.ST_MTIME]
+and time != st[stat.ST_MTIME] & _rangemask
+):
 ladd(fn)
 elif st[stat.ST_MTIME] == lastnormaltime:
 # fn may have just been marked as normal and it may have
 # changed in the same second without changing its size.
 # This can happen if we quickly do multiple commits.
 elif state == 'a':
 aadd(fn)
 elif state == 'r':
 radd(fn)
-return (lookup, scmutil.status(modified, added, removed, deleted,
+return (
-unknown, ignored, clean))
+lookup,
+scmutil.status(
+modified, added, removed, deleted, unknown, ignored, clean
+),
+)
 def matches(self, match):
 '''
 return files in the dirstate (in whatever state) filtered by match
 '''
 # use '_writedirstate' instead of 'write' to write changes certainly,
 # because the latter omits writing out if transaction is running.
 # output file will be used to create backup of dirstate at this point.
 if self._dirty or not self._opener.exists(filename):
-self._writedirstate(self._opener(filename, "w", atomictemp=True,
+self._writedirstate(
-checkambig=True))
+self._opener(filename, "w", atomictemp=True, checkambig=True)
+)
 if tr:
 # ensure that subsequent tr.writepending returns True for
 # changes written out above, even if dirstate is never
 # changed after this
-tr.addfilegenerator('dirstate', (self._filename,),
+tr.addfilegenerator(
-self._writedirstate, location='plain')
+'dirstate',
+(self._filename,),
+self._writedirstate,
+location='plain',
+)
 # ensure that pending file written above is unlinked at
 # failure, even if tr.writepending isn't invoked until the
 # end of this transaction
 tr.registertmp(filename, location='plain')
 self._opener.tryunlink(backupname)
 # hardlink backup is okay because _writedirstate is always called
 # with an "atomictemp=True" file.
-util.copyfile(self._opener.join(filename),
+util.copyfile(
-self._opener.join(backupname), hardlink=True)
+self._opener.join(filename),
+self._opener.join(backupname),
+hardlink=True,
+)
 def restorebackup(self, tr, backupname):
 '''Restore dirstate by backup file'''
 # this "invalidate()" prevents "wlock.release()" from writing
 # changes of dirstate out after restoring from backup file
 o.rename(backupname, filename, checkambig=True)
 def clearbackup(self, tr, backupname):
 '''Clear backup file'''
 self._opener.unlink(backupname)
 class dirstatemap(object):
 """Map encapsulating the dirstate's contents.
 The dirstate contains the following state:
 try:
 makefilefoldmap = parsers.make_file_foldmap
 except AttributeError:
 pass
 else:
-return makefilefoldmap(self._map, util.normcasespec,
+return makefilefoldmap(
-util.normcasefallback)
+self._map, util.normcasespec, util.normcasefallback
+)
 f = {}
 normcase = util.normcase
 for name, s in self._map.iteritems():
 if s[0] != 'r':
 f[normcase(name)] = name
-f['.'] = '.' # prevents useless util.fspath() invocation
+f['.'] = '.'  # prevents useless util.fspath() invocation
 return f
 def hastrackeddir(self, d):
 """
 Returns True if the dirstate contains a tracked (not removed) file
 def _opendirstatefile(self):
 fp, mode = txnutil.trypending(self._root, self._opener, self._filename)
 if self._pendingmode is not None and self._pendingmode != mode:
 fp.close()
-raise error.Abort(_('working directory state may be '
+raise error.Abort(
-'changed parallelly'))
+_('working directory state may be ' 'changed parallelly')
+)
 self._pendingmode = mode
 return fp
 def parents(self):
 if not self._parents:
 if l == 40:
 self._parents = (st[:20], st[20:40])
 elif l == 0:
 self._parents = (nullid, nullid)
 else:
-raise error.Abort(_('working directory state appears '
+raise error.Abort(
-'damaged!'))
+_('working directory state appears ' 'damaged!')
+)
 return self._parents
 def setparents(self, p1, p2):
 self._parents = (p1, p2)
 self._dirtyparents = True
 def read(self):
 # ignore HG_PENDING because identity is used only for writing
 self.identity = util.filestat.frompath(
-self._opener.join(self._filename))
+self._opener.join(self._filename)
+)
 try:
 fp = self._opendirstatefile()
 try:
 st = fp.read()
 self.__contains__ = self._map.__contains__
 self.__getitem__ = self._map.__getitem__
 self.get = self._map.get
 def write(self, st, now):
-st.write(parsers.pack_dirstate(self._map, self.copymap,
+st.write(
-self.parents(), now))
+parsers.pack_dirstate(self._map, self.copymap, self.parents(), now)
+)
 st.close()
 self._dirtyparents = False
 self.nonnormalset, self.otherparentset = self.nonnormalentries()
 @propertycache
 f[normcase(name)] = name
 return f
 if rustmod is not None:
 class dirstatemap(object):
 def __init__(self, ui, opener, root):
 self._ui = ui
 self._opener = opener
 self._root = root
 # forward for python2,3 compat
 iteritems = items
 def _opendirstatefile(self):
-fp, mode = txnutil.trypending(self._root, self._opener,
+fp, mode = txnutil.trypending(
-self._filename)
+self._root, self._opener, self._filename
+)
 if self._pendingmode is not None and self._pendingmode != mode:
 fp.close()
-raise error.Abort(_('working directory state may be '
+raise error.Abort(
-'changed parallelly'))
+_('working directory state may be ' 'changed parallelly')
+)
 self._pendingmode = mode
 return fp
 def setparents(self, p1, p2):
 self._rustmap.setparents(p1, p2)
 st = ''
 try:
 self._parents = self._rustmap.parents(st)
 except ValueError:
-raise error.Abort(_('working directory state appears '
+raise error.Abort(
-'damaged!'))
+_('working directory state appears ' 'damaged!')
+)
 return self._parents
 def read(self):
 # ignore HG_PENDING because identity is used only for writing
 self.identity = util.filestat.frompath(
-self._opener.join(self._filename))
+self._opener.join(self._filename)
+)
 try:
 fp = self._opendirstatefile()
 try:
 st = fp.read()
 non-normalized versions.
 """
 return self._rustmap.filefoldmapasdict()
 def hastrackeddir(self, d):
-self._dirs # Trigger Python's propertycache
+self._dirs  # Trigger Python's propertycache
 return self._rustmap.hastrackeddir(d)
 def hasdir(self, d):
-self._dirs # Trigger Python's propertycache
+self._dirs  # Trigger Python's propertycache
 return self._rustmap.hasdir(d)
 @propertycache
 def _dirs(self):
 return self._rustmap.getdirs()

changeset 43076	2372284d9457
parent 42927	d459cd8ea42d
child 43077	687b865b95ad