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

equal deleted inserted replaced

-:57875cf423c9
+:2372284d9457
 # GNU General Public License version 2 or any later version.
 from __future__ import absolute_import
 from .i18n import _
-from .interfaces import (
+from .interfaces import repository
-repository,
-)
 from . import (
 error,
 match as matchmod,
 merge,
 scmutil,
 VALID_PREFIXES = (
 b'path:',
 b'rootfilesin:',
 )
 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.
 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 an iterable of patterns into a typed pattern set.
 Patterns are assumed to be ``path:`` if no prefix is present.
 """
 res = {normalizepattern(orig) for orig in pats}
 validatepatterns(res)
 return res
 def validatepatterns(pats):
 """Validate that patterns are in the expected data structure and format.
 And that is a set of normalized patterns beginning with ``path:`` or
 ``rootfilesin:``.
 This function should be used to validate internal data structures
 and patterns that are loaded from sources that use the internal,
 prefixed pattern representation (but can't necessarily be fully trusted).
 """
 if not isinstance(pats, set):
-raise error.ProgrammingError('narrow patterns should be a set; '
+raise error.ProgrammingError(
-'got %r' % pats)
+'narrow patterns should be a set; ' 'got %r' % pats
+)
 for pat in pats:
 if not pat.startswith(VALID_PREFIXES):
 # Use a Mercurial exception because this can happen due to user
 # bugs (e.g. manually updating spec file).
-raise error.Abort(_('invalid prefix on narrow pattern: %s') % pat,
+raise error.Abort(
-hint=_('narrow patterns must begin with one of '
+_('invalid prefix on narrow pattern: %s') % pat,
-'the following: %s') %
+hint=_(
-', '.join(VALID_PREFIXES))
+'narrow patterns must begin with one of '
+'the following: %s'
+)
+% ', '.join(VALID_PREFIXES),
+)
 def format(includes, excludes):
 output = '[include]\n'
 for i in sorted(includes - excludes):
 output += i + '\n'
 output += '[exclude]\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()
-return matchmod.match(root, '', [], include=include or [],
+return matchmod.match(
-exclude=exclude or [])
+root, '', [], include=include or [], exclude=exclude or []
+)
 def parseconfig(ui, spec):
 # maybe we should care about the profiles returned too
 includepats, excludepats, profiles = sparse.parseconfig(ui, spec, 'narrow')
 if profiles:
-raise error.Abort(_("including other spec files using '%include' is not"
+raise error.Abort(
-" supported in narrowspec"))
+_(
+"including other spec files using '%include' is not"
+" supported in narrowspec"
+)
+)
 validatepatterns(includepats)
 validatepatterns(excludepats)
 return includepats, excludepats
 def load(repo):
 # Treat "narrowspec does not exist" the same as "narrowspec file exists
 # and is empty".
 spec = repo.svfs.tryread(FILENAME)
 return parseconfig(repo.ui, spec)
 def save(repo, includepats, excludepats):
 validatepatterns(includepats)
 validatepatterns(excludepats)
 spec = format(includepats, excludepats)
 repo.svfs.write(FILENAME, spec)
 def copytoworkingcopy(repo):
 spec = repo.svfs.read(FILENAME)
 repo.vfs.write(DIRSTATE_FILENAME, spec)
 def savebackup(repo, backupname):
 if repository.NARROW_REQUIREMENT not in repo.requirements:
 return
 svfs = repo.svfs
 svfs.tryunlink(backupname)
 util.copyfile(svfs.join(FILENAME), svfs.join(backupname), hardlink=True)
 def restorebackup(repo, backupname):
 if repository.NARROW_REQUIREMENT not in repo.requirements:
 return
 util.rename(repo.svfs.join(backupname), repo.svfs.join(FILENAME))
 def savewcbackup(repo, backupname):
 if repository.NARROW_REQUIREMENT not in repo.requirements:
 return
 vfs = repo.vfs
 vfs.tryunlink(backupname)
 # It may not exist in old repos
 if vfs.exists(DIRSTATE_FILENAME):
-util.copyfile(vfs.join(DIRSTATE_FILENAME), vfs.join(backupname),
+util.copyfile(
-hardlink=True)
+vfs.join(DIRSTATE_FILENAME), vfs.join(backupname), hardlink=True
+)
 def restorewcbackup(repo, backupname):
 if repository.NARROW_REQUIREMENT not in repo.requirements:
 return
 # It may not exist in old repos
 if repo.vfs.exists(backupname):
 util.rename(repo.vfs.join(backupname), repo.vfs.join(DIRSTATE_FILENAME))
 def clearwcbackup(repo, backupname):
 if repository.NARROW_REQUIREMENT not in repo.requirements:
 return
 repo.vfs.tryunlink(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
 res_includes = set(res_includes)
 else:
 res_includes = set(req_includes)
 return res_includes, res_excludes, invalid_includes
 # These two are extracted for extensions (specifically for Google's CitC file
 # system)
 def _deletecleanfiles(repo, files):
 for f in files:
 repo.wvfs.unlinkpath(f)
 def _writeaddedfiles(repo, pctx, files):
 actions = merge.emptyactions()
 addgaction = actions[merge.ACTION_GET].append
 mf = repo['.'].manifest()
 for f in files:
 if not repo.wvfs.exists(f):
 addgaction((f, (mf.flags(f), False), "narrowspec updated"))
-merge.applyupdates(repo, actions, wctx=repo[None],
+merge.applyupdates(
-mctx=repo['.'], overwrite=False, wantfiledata=False)
+repo,
+actions,
+wctx=repo[None],
+mctx=repo['.'],
+overwrite=False,
+wantfiledata=False,
+)
 def checkworkingcopynarrowspec(repo):
 # Avoid infinite recursion when updating the working copy
 if getattr(repo, '_updatingnarrowspec', False):
 return
 storespec = repo.svfs.tryread(FILENAME)
 wcspec = repo.vfs.tryread(DIRSTATE_FILENAME)
 if wcspec != storespec:
-raise error.Abort(_("working copy's narrowspec is stale"),
+raise error.Abort(
-hint=_("run 'hg tracked --update-working-copy'"))
+_("working copy's narrowspec is stale"),
+hint=_("run 'hg tracked --update-working-copy'"),
+)
 def updateworkingcopy(repo, assumeclean=False):
 """updates the working copy and dirstate from the store narrowspec
 When assumeclean=True, files that are not known to be clean will also
 newmatch = match(repo.root, include=newincludes, exclude=newexcludes)
 addedmatch = matchmod.differencematcher(newmatch, oldmatch)
 removedmatch = matchmod.differencematcher(oldmatch, newmatch)
 ds = repo.dirstate
-lookup, status = ds.status(removedmatch, subrepos=[], ignored=True,
+lookup, status = ds.status(
-clean=True, unknown=True)
+removedmatch, subrepos=[], ignored=True, clean=True, unknown=True
+)
 trackeddirty = status.modified + status.added
 clean = status.clean
 if assumeclean:
 assert not trackeddirty
 clean.extend(lookup)

changeset 43076	2372284d9457
parent 42813	268662aac075
child 43077	687b865b95ad