mercurial: comparison mercurial/sparse.py

equal deleted inserted replaced

-:57875cf423c9
+:2372284d9457
 # Whether sparse features are enabled. This variable is intended to be
 # temporary to facilitate porting sparse to core. It should eventually be
 # a per-repo option, possibly a repo requirement.
 enabled = False
 def parseconfig(ui, raw, action):
 """Parse sparse config file content.
 action is the command which is trigerring this read, can be narrow, sparse
 if line:
 profiles.add(line)
 elif line == '[include]':
 if havesection and current != includes:
 # TODO pass filename into this API so we can report it.
-raise error.Abort(_('%(action)s config cannot have includes '
+raise error.Abort(
-'after excludes') % {'action': action})
+_(
+'%(action)s config cannot have includes '
+'after excludes'
+)
+% {'action': action}
+)
 havesection = True
 current = includes
 continue
 elif line == '[exclude]':
 havesection = True
 current = excludes
 elif line:
 if current is None:
-raise error.Abort(_('%(action)s config entry outside of '
+raise error.Abort(
-'section: %(line)s')
+_('%(action)s config entry outside of ' 'section: %(line)s')
 % {'action': action, 'line': line},
-hint=_('add an [include] or [exclude] line '
+hint=_(
-'to declare the entry type'))
+'add an [include] or [exclude] line '
+'to declare the entry type'
+),
+)
 if line.strip().startswith('/'):
-ui.warn(_('warning: %(action)s profile cannot use'
+ui.warn(
-' paths starting with /, ignoring %(line)s\n')
+_(
-% {'action': action, 'line': line})
+'warning: %(action)s profile cannot use'
+' paths starting with /, ignoring %(line)s\n'
+)
+% {'action': action, 'line': line}
+)
 continue
 current.add(line)
 return includes, excludes, profiles
 # Exists as separate function to facilitate monkeypatching.
 def readprofile(repo, profile, changeid):
 """Resolve the raw content of a sparse profile file."""
 # TODO add some kind of cache here because this incurs a manifest
 # resolve and can be slow.
 return repo.filectx(profile, changeid=changeid).data()
 def patternsforrev(repo, rev):
 """Obtain sparse checkout patterns for the given rev.
 Returns a tuple of iterables representing includes, excludes, and
 patterns.
 raw = repo.vfs.tryread('sparse')
 if not raw:
 return set(), set(), set()
 if rev is None:
-raise error.Abort(_('cannot parse sparse patterns from working '
+raise error.Abort(
-'directory'))
+_('cannot parse sparse patterns from working ' 'directory')
+)
 includes, excludes, profiles = parseconfig(repo.ui, raw, 'sparse')
 ctx = repo[rev]
 if profiles:
 try:
 raw = readprofile(repo, profile, rev)
 except error.ManifestLookupError:
 msg = (
 "warning: sparse profile '%s' not found "
-"in rev %s - ignoring it\n" % (profile, ctx))
+"in rev %s - ignoring it\n" % (profile, ctx)
+)
 # experimental config: sparse.missingwarning
-if repo.ui.configbool(
+if repo.ui.configbool('sparse', 'missingwarning'):
-'sparse', 'missingwarning'):
 repo.ui.warn(msg)
 else:
 repo.ui.debug(msg)
 continue
 if includes:
 includes.add('.hg*')
 return includes, excludes, profiles
 def activeconfig(repo):
 """Determine the active sparse config rules.
 Rules are constructed by reading the current sparse config and bringing in
 referenced profiles from parents of the working directory.
 """
-revs = [repo.changelog.rev(node) for node in
+revs = [
-repo.dirstate.parents() if node != nullid]
+repo.changelog.rev(node)
+for node in repo.dirstate.parents()
+if node != nullid
+]
 allincludes = set()
 allexcludes = set()
 allprofiles = set()
 allexcludes |= excludes
 allprofiles |= profiles
 return allincludes, allexcludes, allprofiles
 def configsignature(repo, includetemp=True):
 """Obtain the signature string for the current sparse configuration.
 This is used to construct a cache key for matchers.
 """
 raw = repo.vfs.tryread('tempsparse')
 tempsignature = hex(hashlib.sha1(raw).digest())
 cache['tempsignature'] = tempsignature
 return '%s %s' % (signature, tempsignature)
 def writeconfig(repo, includes, excludes, profiles):
 """Write the sparse config file given a sparse configuration."""
 with repo.vfs('sparse', 'wb') as fh:
 for p in sorted(profiles):
 fh.write(e)
 fh.write('\n')
 repo._sparsesignaturecache.clear()
 def readtemporaryincludes(repo):
 raw = repo.vfs.tryread('tempsparse')
 if not raw:
 return set()
 return set(raw.split('\n'))
 def writetemporaryincludes(repo, includes):
 repo.vfs.write('tempsparse', '\n'.join(sorted(includes)))
 repo._sparsesignaturecache.clear()
 def addtemporaryincludes(repo, additional):
 includes = readtemporaryincludes(repo)
 for i in additional:
 includes.add(i)
 writetemporaryincludes(repo, includes)
 def prunetemporaryincludes(repo):
 if not enabled or not repo.vfs.exists('tempsparse'):
 return
 actions.append((file, None, message))
 dropped.append(file)
 typeactions = mergemod.emptyactions()
 typeactions['r'] = actions
-mergemod.applyupdates(repo, typeactions, repo[None], repo['.'], False,
+mergemod.applyupdates(
-wantfiledata=False)
+repo, typeactions, repo[None], repo['.'], False, wantfiledata=False
+)
 # Fix dirstate
 for file in dropped:
 dirstate.drop(file)
 repo.vfs.unlink('tempsparse')
 repo._sparsesignaturecache.clear()
-msg = _('cleaned up %d temporarily added file(s) from the '
+msg = _(
-'sparse checkout\n')
+'cleaned up %d temporarily added file(s) from the ' 'sparse checkout\n'
+)
 repo.ui.status(msg % len(tempincludes))
 def forceincludematcher(matcher, includes):
 """Returns a matcher that returns true for any of the forced includes
 before testing against the actual matcher."""
 kindpats = [('path', include, '') for include in includes]
 includematcher = matchmod.includematcher('', kindpats)
 return matchmod.unionmatcher([includematcher, matcher])
 def matcher(repo, revs=None, includetemp=True):
 """Obtain a matcher for sparse working directories for the given revs.
 If multiple revisions are specified, the matcher is the union of all
 revs.
 # If sparse isn't enabled, sparse matcher matches everything.
 if not enabled:
 return matchmod.always()
 if not revs or revs == [None]:
-revs = [repo.changelog.rev(node)
+revs = [
-for node in repo.dirstate.parents() if node != nullid]
+repo.changelog.rev(node)
+for node in repo.dirstate.parents()
+if node != nullid
+]
 signature = configsignature(repo, includetemp=includetemp)
 key = '%s %s' % (signature, ' '.join(map(pycompat.bytestr, revs)))
 for rev in revs:
 try:
 includes, excludes, profiles = patternsforrev(repo, rev)
 if includes or excludes:
-matcher = matchmod.match(repo.root, '', [],
+matcher = matchmod.match(
-include=includes, exclude=excludes,
+repo.root,
-default='relpath')
+'',
+[],
+include=includes,
+exclude=excludes,
+default='relpath',
+)
 matchers.append(matcher)
 except IOError:
 pass
 if not matchers:
 result = forceincludematcher(result, tempincludes)
 repo._sparsematchercache[key] = result
 return result
 def filterupdatesactions(repo, wctx, mctx, branchmerge, actions):
 """Filter updates to only lay out files that match the sparse rules."""
 if not enabled:
 return actions
 f1, f2, fa, move, anc = args
 if not sparsematch(f1):
 temporaryfiles.append(f1)
 if len(temporaryfiles) > 0:
-repo.ui.status(_('temporarily included %d file(s) in the sparse '
+repo.ui.status(
-'checkout for merging\n') % len(temporaryfiles))
+_(
+'temporarily included %d file(s) in the sparse '
+'checkout for merging\n'
+)
+% len(temporaryfiles)
+)
 addtemporaryincludes(repo, temporaryfiles)
 # Add the new files to the working copy so they can be merged, etc
 actions = []
 message = 'temporarily adding to sparse checkout'
 fctx = repo[None][file]
 actions.append((file, (fctx.flags(), False), message))
 typeactions = mergemod.emptyactions()
 typeactions['g'] = actions
-mergemod.applyupdates(repo, typeactions, repo[None], repo['.'],
+mergemod.applyupdates(
-False, wantfiledata=False)
+repo, typeactions, repo[None], repo['.'], False, wantfiledata=False
+)
 dirstate = repo.dirstate
 for file, flags, msg in actions:
 dirstate.normal(file)
 elif old and not new:
 prunedactions[file] = ('r', [], '')
 return prunedactions
 def refreshwdir(repo, origstatus, origsparsematch, force=False):
 """Refreshes working directory by taking sparse config into account.
 The old status and sparse matcher is compared against the current sparse
 matcher.
 if not sparsematch(f):
 repo.ui.warn(_("pending changes to '%s'\n") % f)
 abort = not force
 if abort:
-raise error.Abort(_('could not update sparseness due to pending '
+raise error.Abort(
-'changes'))
+_('could not update sparseness due to pending ' 'changes')
+)
 # Calculate actions
 dirstate = repo.dirstate
 ctx = repo['.']
 added = []
 abort = False
 for file in lookup:
 repo.ui.warn(_("pending changes to '%s'\n") % file)
 abort = not force
 if abort:
-raise error.Abort(_('cannot change sparseness due to pending '
+raise error.Abort(
-'changes (delete the files or use '
+_(
-'--force to bring them back dirty)'))
+'cannot change sparseness due to pending '
+'changes (delete the files or use '
+'--force to bring them back dirty)'
+)
+)
 # Check for files that were only in the dirstate.
 for file, state in dirstate.iteritems():
 if not file in files:
 old = origsparsematch(file)
 # Apply changes to disk
 typeactions = mergemod.emptyactions()
 for f, (m, args, msg) in actions.iteritems():
 typeactions[m].append((f, args, msg))
-mergemod.applyupdates(repo, typeactions, repo[None], repo['.'], False,
+mergemod.applyupdates(
-wantfiledata=False)
+repo, typeactions, repo[None], repo['.'], False, wantfiledata=False
+)
 # Fix dirstate
 for file in added:
 dirstate.normal(file)
 for file in lookup:
 # File exists on disk, and we're bringing it back in an unknown state.
 dirstate.normallookup(file)
 return added, dropped, lookup
 def aftercommit(repo, node):
 """Perform actions after a working directory commit."""
 # This function is called unconditionally, even if sparse isn't
 # enabled.
 origsparsematch = matcher(repo)
 refreshwdir(repo, origstatus, origsparsematch, force=True)
 prunetemporaryincludes(repo)
-def _updateconfigandrefreshwdir(repo, includes, excludes, profiles,
-force=False, removing=False):
+def _updateconfigandrefreshwdir(
+repo, includes, excludes, profiles, force=False, removing=False
+):
 """Update the sparse config and working directory state."""
 raw = repo.vfs.tryread('sparse')
 oldincludes, oldexcludes, oldprofiles = parseconfig(repo.ui, raw, 'sparse')
 oldstatus = repo.status()
 repo.requirements |= oldrequires
 scmutil.writerequires(repo.vfs, repo.requirements)
 writeconfig(repo, oldincludes, oldexcludes, oldprofiles)
 raise
 def clearrules(repo, force=False):
 """Clears include/exclude rules from the sparse config.
 The remaining sparse config only has profiles, if defined. The working
 directory is refreshed, as needed.
 if not includes and not excludes:
 return
 _updateconfigandrefreshwdir(repo, set(), set(), profiles, force=force)
 def importfromfiles(repo, opts, paths, force=False):
 """Import sparse config rules from files.
 The updated sparse config is written out and the working directory
 changed = False
 for p in paths:
 with util.posixfile(util.expandpath(p), mode='rb') as fh:
 raw = fh.read()
-iincludes, iexcludes, iprofiles = parseconfig(repo.ui, raw,
+iincludes, iexcludes, iprofiles = parseconfig(
-'sparse')
+repo.ui, raw, 'sparse'
+)
 oldsize = len(includes) + len(excludes) + len(profiles)
 includes.update(iincludes - aincludes)
 excludes.update(iexcludes - aexcludes)
 profiles.update(iprofiles - aprofiles)
 if len(includes) + len(excludes) + len(profiles) > oldsize:
 if changed:
 profilecount = len(profiles - aprofiles)
 includecount = len(includes - aincludes)
 excludecount = len(excludes - aexcludes)
-fcounts = map(len, _updateconfigandrefreshwdir(
+fcounts = map(
-repo, includes, excludes, profiles, force=force))
+len,
+_updateconfigandrefreshwdir(
-printchanges(repo.ui, opts, profilecount, includecount, excludecount,
+repo, includes, excludes, profiles, force=force
-*fcounts)
+),
+)
-def updateconfig(repo, pats, opts, include=False, exclude=False, reset=False,
-delete=False, enableprofile=False, disableprofile=False,
+printchanges(
-force=False, usereporootpaths=False):
+repo.ui, opts, profilecount, includecount, excludecount, *fcounts
+)
+def updateconfig(
+repo,
+pats,
+opts,
+include=False,
+exclude=False,
+reset=False,
+delete=False,
+enableprofile=False,
+disableprofile=False,
+force=False,
+usereporootpaths=False,
+):
 """Perform a sparse config update.
 Only one of the actions may be performed.
 The new config is written out and a working directory refresh is performed.
 """
 with repo.wlock():
 raw = repo.vfs.tryread('sparse')
-oldinclude, oldexclude, oldprofiles = parseconfig(repo.ui, raw,
+oldinclude, oldexclude, oldprofiles = parseconfig(
-'sparse')
+repo.ui, raw, 'sparse'
+)
 if reset:
 newinclude = set()
 newexclude = set()
 newprofiles = set()
 root, cwd = repo.root, repo.getcwd()
 abspats = []
 for kindpat in pats:
 kind, pat = matchmod._patsplit(kindpat, None)
 if kind in matchmod.cwdrelativepatternkinds or kind is None:
-ap = ((kind + ':' if kind else '') +
+ap = (kind + ':' if kind else '') + pathutil.canonpath(
-pathutil.canonpath(root, cwd, pat))
+root, cwd, pat
+)
 abspats.append(ap)
 else:
 abspats.append(kindpat)
 pats = abspats
 newprofiles.difference_update(pats)
 elif delete:
 newinclude.difference_update(pats)
 newexclude.difference_update(pats)
-profilecount = (len(newprofiles - oldprofiles) -
+profilecount = len(newprofiles - oldprofiles) - len(
-len(oldprofiles - newprofiles))
+oldprofiles - newprofiles
-includecount = (len(newinclude - oldinclude) -
+)
-len(oldinclude - newinclude))
+includecount = len(newinclude - oldinclude) - len(
-excludecount = (len(newexclude - oldexclude) -
+oldinclude - newinclude
-len(oldexclude - newexclude))
+)
+excludecount = len(newexclude - oldexclude) - len(
-fcounts = map(len, _updateconfigandrefreshwdir(
+oldexclude - newexclude
-repo, newinclude, newexclude, newprofiles, force=force,
+)
-removing=reset))
+fcounts = map(
-printchanges(repo.ui, opts, profilecount, includecount,
+len,
-excludecount, *fcounts)
+_updateconfigandrefreshwdir(
+repo,
-def printchanges(ui, opts, profilecount=0, includecount=0, excludecount=0,
+newinclude,
-added=0, dropped=0, conflicting=0):
+newexclude,
+newprofiles,
+force=force,
+removing=reset,
+),
+)
+printchanges(
+repo.ui, opts, profilecount, includecount, excludecount, *fcounts
+)
+def printchanges(
+ui,
+opts,
+profilecount=0,
+includecount=0,
+excludecount=0,
+added=0,
+dropped=0,
+conflicting=0,
+):
 """Print output summarizing sparse config changes."""
 with ui.formatter('sparse', opts) as fm:
 fm.startitem()
-fm.condwrite(ui.verbose, 'profiles_added', _('Profiles changed: %d\n'),
+fm.condwrite(
-profilecount)
+ui.verbose,
-fm.condwrite(ui.verbose, 'include_rules_added',
+'profiles_added',
-_('Include rules changed: %d\n'), includecount)
+_('Profiles changed: %d\n'),
-fm.condwrite(ui.verbose, 'exclude_rules_added',
+profilecount,
-_('Exclude rules changed: %d\n'), excludecount)
+)
+fm.condwrite(
+ui.verbose,
+'include_rules_added',
+_('Include rules changed: %d\n'),
+includecount,
+)
+fm.condwrite(
+ui.verbose,
+'exclude_rules_added',
+_('Exclude rules changed: %d\n'),
+excludecount,
+)
 # In 'plain' verbose mode, mergemod.applyupdates already outputs what
 # files are added or removed outside of the templating formatter
 # framework. No point in repeating ourselves in that case.
 if not fm.isplain():
-fm.condwrite(ui.verbose, 'files_added', _('Files added: %d\n'),
+fm.condwrite(
-added)
+ui.verbose, 'files_added', _('Files added: %d\n'), added
-fm.condwrite(ui.verbose, 'files_dropped', _('Files dropped: %d\n'),
+)
-dropped)
+fm.condwrite(
-fm.condwrite(ui.verbose, 'files_conflicting',
+ui.verbose, 'files_dropped', _('Files dropped: %d\n'), dropped
-_('Files conflicting: %d\n'), conflicting)
+)
+fm.condwrite(
+ui.verbose,
+'files_conflicting',
+_('Files conflicting: %d\n'),
+conflicting,
+)

changeset 43076	2372284d9457
parent 42456	87a34c767384
child 43077	687b865b95ad