narrow: extract part of narrowspec backup to core

Just a little preparation for the next patch.

Differential Revision: https://phab.mercurial-scm.org/D4095

hgext/narrow/narrowdirstate.py

@@ -1,99 +1,94 b''
 # narrowdirstate.py - extensions to mercurial dirstate to support narrow clones
 #
 # Copyright 2017 Google, Inc.
 #
 # 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
 
 from mercurial.i18n import _
 from mercurial import (
     error,
     match as matchmod,
     narrowspec,
-    util as hgutil,
 )
 
 def wrapdirstate(repo, dirstate):
     """Add narrow spec dirstate ignore, block changes outside narrow spec."""
 
     def _editfunc(fn):
         def _wrapper(self, *args):
             dirstate = repo.dirstate
             narrowmatch = repo.narrowmatch()
             for f in args:
                 if f is not None and not narrowmatch(f) and f not in dirstate:
                     raise error.Abort(_("cannot track '%s' - it is outside " +
                         "the narrow clone") % f)
             return fn(self, *args)
         return _wrapper
 
     def _narrowbackupname(backupname):
         assert 'dirstate' in backupname
         return backupname.replace('dirstate', narrowspec.FILENAME)
 
     class narrowdirstate(dirstate.__class__):
         def walk(self, match, subrepos, unknown, ignored, full=True,
                  narrowonly=True):
             if narrowonly:
                 # hack to not exclude explicitly-specified paths so that they
                 # can be warned later on e.g. dirstate.add()
                 em = matchmod.exact(match._root, match._cwd, match.files())
                 nm = matchmod.unionmatcher([repo.narrowmatch(), em])
                 match = matchmod.intersectmatchers(match, nm)
             return super(narrowdirstate, self).walk(match, subrepos, unknown,
                                                     ignored, full)
 
         # Prevent adding/editing/copying/deleting files that are outside the
         # sparse checkout
         @_editfunc
         def normal(self, *args):
             return super(narrowdirstate, self).normal(*args)
 
         @_editfunc
         def add(self, *args):
             return super(narrowdirstate, self).add(*args)
 
         @_editfunc
         def normallookup(self, *args):
             return super(narrowdirstate, self).normallookup(*args)
 
         @_editfunc
         def copy(self, *args):
             return super(narrowdirstate, self).copy(*args)
 
         @_editfunc
         def remove(self, *args):
             return super(narrowdirstate, self).remove(*args)
 
         @_editfunc
         def merge(self, *args):
             return super(narrowdirstate, self).merge(*args)
 
         def rebuild(self, parent, allfiles, changedfiles=None):
             if changedfiles is None:
                 # Rebuilding entire dirstate, let's filter allfiles to match the
                 # narrowspec.
                 allfiles = [f for f in allfiles if repo.narrowmatch()(f)]
             super(narrowdirstate, self).rebuild(parent, allfiles, changedfiles)
 
         def restorebackup(self, tr, backupname):
-            self._opener.rename(_narrowbackupname(backupname),
-                                narrowspec.FILENAME, checkambig=True)
+            narrowspec.restorebackup(self._opener,
+                                     _narrowbackupname(backupname))
             super(narrowdirstate, self).restorebackup(tr, backupname)
 
         def savebackup(self, tr, backupname):
             super(narrowdirstate, self).savebackup(tr, backupname)
-
-            narrowbackupname = _narrowbackupname(backupname)
-            self._opener.tryunlink(narrowbackupname)
-            hgutil.copyfile(self._opener.join(narrowspec.FILENAME),
-                            self._opener.join(narrowbackupname), hardlink=True)
+            narrowspec.savebackup(self._opener, _narrowbackupname(backupname))
 
         def clearbackup(self, tr, backupname):
             super(narrowdirstate, self).clearbackup(tr, backupname)
-            self._opener.unlink(_narrowbackupname(backupname))
+            narrowspec.clearbackup(self._opener, _narrowbackupname(backupname))
 
     dirstate.__class__ = narrowdirstate
     return dirstate

mercurial/narrowspec.py

@@ -1,199 +1,209 b''
 # narrowspec.py - methods for working with a narrow view of a repository
 #
 # Copyright 2017 Google, Inc.
 #
 # 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 errno
 
 from .i18n import _
 from . import (
     error,
     match as matchmod,
     util,
 )
 
 FILENAME = 'narrowspec'
 
 def _parsestoredpatterns(text):
     """Parses the narrowspec format that's stored on disk."""
     patlist = None
     includepats = []
     excludepats = []
     for l in text.splitlines():
         if l == '[includes]':
             if patlist is None:
                 patlist = includepats
             else:
                 raise error.Abort(_('narrowspec includes section must appear '
                                     'at most once, before excludes'))
         elif l == '[excludes]':
             if patlist is not excludepats:
                 patlist = excludepats
             else:
                 raise error.Abort(_('narrowspec excludes section must appear '
                                     'at most once'))
         else:
             patlist.append(l)
 
     return set(includepats), set(excludepats)
 
 def parseserverpatterns(text):
     """Parses the narrowspec format that's returned by the server."""
     includepats = set()
     excludepats = set()
 
     # We get one entry per line, in the format "<key> <value>".
     # It's OK for value to contain other spaces.
     for kp in (l.split(' ', 1) for l in text.splitlines()):
         if len(kp) != 2:
             raise error.Abort(_('Invalid narrowspec pattern line: "%s"') % kp)
         key = kp[0]
         pat = kp[1]
         if key == 'include':
             includepats.add(pat)
         elif key == 'exclude':
             excludepats.add(pat)
         else:
             raise error.Abort(_('Invalid key "%s" in server response') % key)
 
     return includepats, excludepats
 
 def normalizesplitpattern(kind, pat):
     """Returns the normalized version of a pattern and kind.
 
     Returns a tuple with the normalized kind and normalized pattern.
     """
     pat = pat.rstrip('/')
     _validatepattern(pat)
     return kind, pat
 
 def _numlines(s):
     """Returns the number of lines in s, including ending empty lines."""
     # We use splitlines because it is Unicode-friendly and thus Python 3
     # compatible. However, it does not count empty lines at the end, so trick
     # it by adding a character at the end.
     return len((s + 'x').splitlines())
 
 def _validatepattern(pat):
     """Validates the pattern and aborts if it is invalid.
 
     Patterns are stored in the narrowspec as newline-separated
     POSIX-style bytestring paths. There's no escaping.
     """
 
     # We use newlines as separators in the narrowspec file, so don't allow them
     # in patterns.
     if _numlines(pat) > 1:
         raise error.Abort(_('newlines are not allowed in narrowspec paths'))
 
     components = pat.split('/')
     if '.' in components or '..' in components:
         raise error.Abort(_('"." and ".." are not allowed in narrowspec paths'))
 
 def normalizepattern(pattern, defaultkind='path'):
     """Returns the normalized version of a text-format pattern.
 
     If the pattern has no kind, the default will be added.
     """
     kind, pat = matchmod._patsplit(pattern, defaultkind)
     return '%s:%s' % normalizesplitpattern(kind, pat)
 
 def parsepatterns(pats):
     """Parses a list of patterns into a typed pattern set."""
     return set(normalizepattern(p) for p in pats)
 
 def format(includes, excludes):
     output = '[includes]\n'
     for i in sorted(includes - excludes):
         output += i + '\n'
     output += '[excludes]\n'
     for e in sorted(excludes):
         output += e + '\n'
     return output
 
 def match(root, include=None, exclude=None):
     if not include:
         # Passing empty include and empty exclude to matchmod.match()
         # gives a matcher that matches everything, so explicitly use
         # the nevermatcher.
         return matchmod.never(root, '')
     return matchmod.match(root, '', [], include=include or [],
                           exclude=exclude or [])
 
 def needsexpansion(includes):
     return [i for i in includes if i.startswith('include:')]
 
 def load(repo):
     try:
         spec = repo.vfs.read(FILENAME)
     except IOError as e:
         # Treat "narrowspec does not exist" the same as "narrowspec file exists
         # and is empty".
         if e.errno == errno.ENOENT:
             # Without this the next call to load will use the cached
             # non-existence of the file, which can cause some odd issues.
             repo.invalidate(clearfilecache=True)
             return set(), set()
         raise
     return _parsestoredpatterns(spec)
 
 def save(repo, includepats, excludepats):
     spec = format(includepats, excludepats)
     repo.vfs.write(FILENAME, spec)
 
+def savebackup(vfs, backupname):
+    vfs.tryunlink(backupname)
+    util.copyfile(vfs.join(FILENAME), vfs.join(backupname), hardlink=True)
+
+def restorebackup(vfs, backupname):
+    vfs.rename(backupname, FILENAME, checkambig=True)
+
+def clearbackup(vfs, backupname):
+    vfs.unlink(backupname)
+
 def restrictpatterns(req_includes, req_excludes, repo_includes, repo_excludes):
     r""" Restricts the patterns according to repo settings,
     results in a logical AND operation
 
     :param req_includes: requested includes
     :param req_excludes: requested excludes
     :param repo_includes: repo includes
     :param repo_excludes: repo excludes
     :return: include patterns, exclude patterns, and invalid include patterns.
 
     >>> restrictpatterns({'f1','f2'}, {}, ['f1'], [])
     (set(['f1']), {}, [])
     >>> restrictpatterns({'f1'}, {}, ['f1','f2'], [])
     (set(['f1']), {}, [])
     >>> restrictpatterns({'f1/fc1', 'f3/fc3'}, {}, ['f1','f2'], [])
     (set(['f1/fc1']), {}, [])
     >>> restrictpatterns({'f1_fc1'}, {}, ['f1','f2'], [])
     ([], set(['path:.']), [])
     >>> restrictpatterns({'f1/../f2/fc2'}, {}, ['f1','f2'], [])
     (set(['f2/fc2']), {}, [])
     >>> restrictpatterns({'f1/../f3/fc3'}, {}, ['f1','f2'], [])
     ([], set(['path:.']), [])
     >>> restrictpatterns({'f1/$non_exitent_var'}, {}, ['f1','f2'], [])
     (set(['f1/$non_exitent_var']), {}, [])
     """
     res_excludes = set(req_excludes)
     res_excludes.update(repo_excludes)
     invalid_includes = []
     if not req_includes:
         res_includes = set(repo_includes)
     elif 'path:.' not in repo_includes:
         res_includes = []
         for req_include in req_includes:
             req_include = util.expandpath(util.normpath(req_include))
             if req_include in repo_includes:
                 res_includes.append(req_include)
                 continue
             valid = False
             for repo_include in repo_includes:
                 if req_include.startswith(repo_include + '/'):
                     valid = True
                     res_includes.append(req_include)
                     break
             if not valid:
                 invalid_includes.append(req_include)
         if len(res_includes) == 0:
             res_excludes = {'path:.'}
         else:
             res_includes = set(res_includes)
     else:
         res_includes = set(req_includes)
     return res_includes, res_excludes, invalid_includes