mercurial: comparison mercurial/dirstate.py

equal deleted inserted replaced

-:e8ea403b1c46
+:288de6f5d724
 # Copyright 2005-2007 Olivia Mackall <olivia@selenic.com>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
-from __future__ import absolute_import
 import collections
 import contextlib
-import errno
 import os
 import stat
 import uuid
 from .i18n import _
 node,
 pathutil,
 policy,
 pycompat,
 scmutil,
-sparse,
 util,
 )
 from .dirstateutils import (
 timestamp,
 return wrap
 @interfaceutil.implementer(intdirstate.idirstate)
-class dirstate(object):
+class dirstate:
 def __init__(
 self,
 opener,
 ui,
 root,
 self._use_tracked_hint = use_tracked_hint
 self._nodeconstants = nodeconstants
 self._opener = opener
 self._validate = validate
 self._root = root
+# Either build a sparse-matcher or None if sparse is disabled
 self._sparsematchfn = sparsematchfn
 # ntpath.join(root, '') of Python 2.7.9 does not add sep if root is
 # UNC path pointing to root share (issue4557)
 self._rootdir = pathutil.normasprefix(root)
 # True is any internal state may be different
 """The matcher for the sparse checkout.
 The working directory may not include every file from a manifest. The
 matcher obtained by this property will match a path if it is to be
 included in the working directory.
-"""
+When sparse if disabled, return None.
+"""
+if self._sparsematchfn is None:
+return None
 # TODO there is potential to cache this property. For now, the matcher
 # is resolved on every access. (But the called function does use a
 # cache to keep the lookup fast.)
 return self._sparsematchfn()
 @repocache(b'branch')
 def _branch(self):
 try:
 return self._opener.read(b"branch").strip() or b"default"
-except IOError as inst:
+except FileNotFoundError:
-if inst.errno != errno.ENOENT:
-raise
 return b"default"
 @property
 def _pl(self):
 return self._map.parents()
 def __iter__(self):
 return iter(sorted(self._map))
 def items(self):
-return pycompat.iteritems(self._map)
+return self._map.items()
 iteritems = items
 def parents(self):
 return [self._validate(p) for p in self._pl]
 """Mark dest as a copy of source. Unmark dest if source is None."""
 if source == dest:
 return
 self._dirty = True
 if source is not None:
+self._check_sparse(source)
 self._map.copymap[dest] = source
 else:
 self._map.copymap.pop(dest, None)
 def copied(self, file):
 entry = self._map.get(d)
 if entry is not None and not entry.removed:
 msg = _(b'file %r in dirstate clashes with %r')
 msg %= (pycompat.bytestr(d), pycompat.bytestr(filename))
 raise error.Abort(msg)
+self._check_sparse(filename)
+def _check_sparse(self, filename):
+"""Check that a filename is inside the sparse profile"""
+sparsematch = self._sparsematcher
+if sparsematch is not None and not sparsematch.always():
+if not sparsematch(filename):
+msg = _(b"cannot add '%s' - it is outside the sparse checkout")
+hint = _(
+b'include file with `hg debugsparse --include <pattern>` or use '
+b'`hg add -s <file>` to include file directory while adding'
+)
+raise error.Abort(msg % filename, hint=hint)
 def _discoverpath(self, path, normed, ignoremissing, exists, storemap):
 if exists is None:
 exists = os.path.lexists(os.path.join(self._root, path))
 if not exists:
 def clear(self):
 self._map.clear()
 self._dirty = True
 def rebuild(self, parent, allfiles, changedfiles=None):
+matcher = self._sparsematcher
+if matcher is not None and not matcher.always():
+# should not add non-matching files
+allfiles = [f for f in allfiles if matcher(f)]
+if changedfiles:
+changedfiles = [f for f in changedfiles if matcher(f)]
+if changedfiles is not None:
+# these files will be deleted from the dirstate when they are
+# not found to be in allfiles
+dirstatefilestoremove = {f for f in self if not matcher(f)}
+changedfiles = dirstatefilestoremove.union(changedfiles)
 if changedfiles is None:
 # Rebuild entire dirstate
 to_lookup = allfiles
 to_drop = []
 self.clear()
 self._plchangecallbacks[category] = callback
 def _writedirstate(self, tr, st):
 # notify callbacks about parents change
 if self._origpl is not None and self._origpl != self._pl:
-for c, callback in sorted(
+for c, callback in sorted(self._plchangecallbacks.items()):
-pycompat.iteritems(self._plchangecallbacks)
-):
 callback(self, self._origpl, self._pl)
 self._origpl = None
 self._map.write(tr, st)
 self._dirty = False
 self._dirty_tracked_set = False
 # match the case in the filesystem, if there are multiple files that
 # normalize to the same path.
 if match.isexact() and self._checkcase:
 normed = {}
-for f, st in pycompat.iteritems(results):
+for f, st in results.items():
 if st is None:
 continue
 nc = util.normcase(f)
 paths = normed.get(nc)
 paths = set()
 normed[nc] = paths
 paths.add(f)
-for norm, paths in pycompat.iteritems(normed):
+for norm, paths in normed.items():
 if len(paths) > 1:
 for path in paths:
 folded = self._discoverpath(
 path, norm, True, None, self._map.dirfoldmap
 )
 dirignore = self._dirignore
 else:
 # if not unknown and not ignored, drop dir recursion and step 2
 ignore = util.always
 dirignore = util.always
+if self._sparsematchfn is not None:
+em = matchmod.exact(match.files())
+sm = matchmod.unionmatcher([self._sparsematcher, em])
+match = matchmod.intersectmatchers(match, sm)
 matchfn = match.matchfn
 matchalways = match.always()
 matchtdir = match.traversedir
 dmap = self._map
 if nd != b'':
 skip = b'.hg'
 try:
 with tracing.log('dirstate.walk.traverse listdir %s', nd):
 entries = listdir(join(nd), stat=True, skip=skip)
-except OSError as inst:
+except (PermissionError, FileNotFoundError) as inst:
-if inst.errno in (errno.EACCES, errno.ENOENT):
+match.bad(
-match.bad(
+self.pathto(nd), encoding.strtolocal(inst.strerror)
-self.pathto(nd), encoding.strtolocal(inst.strerror)
+)
-)
+continue
-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
 # and is not an exactmatcher. This is acceptable; we do not
 # make any hard assumptions about file-or-directory below
 for st in util.statfiles([join(i) for i in visit]):
 results[next(iv)] = st
 return results
 def _rust_status(self, matcher, list_clean, list_ignored, list_unknown):
+if self._sparsematchfn is not None:
+em = matchmod.exact(matcher.files())
+sm = matchmod.unionmatcher([self._sparsematcher, em])
+matcher = matchmod.intersectmatchers(matcher, sm)
 # Force Rayon (Rust parallelism library) to respect the number of
 # workers. This is a temporary workaround until Rust code knows
 # how to read the config file.
 numcpus = self._ui.configint(b"worker", b"numcpus")
 if numcpus is not None:
 allowed_matchers = (
 matchmod.alwaysmatcher,
 matchmod.exactmatcher,
 matchmod.includematcher,
+matchmod.intersectionmatcher,
+matchmod.nevermatcher,
+matchmod.unionmatcher,
 )
 if rustmod is None:
 use_rust = False
 elif self._checkcase:
 # Case-insensitive filesystems are not handled yet
 use_rust = False
 elif subrepos:
-use_rust = False
-elif sparse.enabled:
 use_rust = False
 elif not isinstance(match, allowed_matchers):
 # Some matchers have yet to be implemented
 use_rust = False
 # 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 pycompat.iteritems(
+for fn, st in self.walk(
-self.walk(match, subrepos, listunknown, listignored, full=full)
+match, subrepos, listunknown, listignored, full=full
-):
+).items():
 if not dcontains(fn):
 if (listignored or mexact(fn)) and dirignore(fn):
 if listignored:
 iadd(fn)
 else:

branch	stable
changeset 49366	288de6f5d724
parent 49361	c2092612c424
child 49467	0705afae6253