( )⚙ D846 dirstate: use keyword arguments to clarify walk()'s callers

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D846

dirstate: use keyword arguments to clarify walk()'s callers
ClosedPublic

Authored by martinvonz on Sep 29 2017, 5:53 PM.

Details

Reviewers
quark
Group Reviewers
hg-reviewers
Commits
rHG255c761a52db: dirstate: use keyword arguments to clarify walk()'s callers
Summary

The arguments are especially non-obvious because the order is
different from dirstate.status().

Diff Detail

Repository
rHG Mercurial
Lint
Lint Skipped
Unit
Unit Tests Skipped

Revision Contents
Changeset List

Diff 2166

contrib/perf.py

unfi._filecache.pop(attrname, None) unfi._filecache.pop(attrname, None)
# perf commands # perf commands
@command('perfwalk', formatteropts) @command('perfwalk', formatteropts)
def perfwalk(ui, repo, *pats, **opts): def perfwalk(ui, repo, *pats, **opts):
timer, fm = gettimer(ui, opts) timer, fm = gettimer(ui, opts)
m = scmutil.match(repo[None], pats, {}) m = scmutil.match(repo[None], pats, {})
timer(lambda: len(list(repo.dirstate.walk(m, [], True, False)))) timer(lambda: len(list(repo.dirstate.walk(m, subrepos=[], unknown=True,
ignored=False))))
fm.end() fm.end()
@command('perfannotate', formatteropts) @command('perfannotate', formatteropts)
def perfannotate(ui, repo, f, **opts): def perfannotate(ui, repo, f, **opts):
timer, fm = gettimer(ui, opts) timer, fm = gettimer(ui, opts)
fc = repo['.'][f] fc = repo['.'][f]
timer(lambda: len(fc.annotate(True))) timer(lambda: len(fc.annotate(True)))
fm.end() fm.end()

hgext/largefiles/lfutil.py

repo.dirstate._validate, repo.dirstate._validate,
lambda: sparse.matcher(repo)) lambda: sparse.matcher(repo))
# If the largefiles dirstate does not exist, populate and create # If the largefiles dirstate does not exist, populate and create
# it. This ensures that we create it on the first meaningful # it. This ensures that we create it on the first meaningful
# largefiles operation in a new clone. # largefiles operation in a new clone.
if create and not vfs.exists(vfs.join(lfstoredir, 'dirstate')): if create and not vfs.exists(vfs.join(lfstoredir, 'dirstate')):
matcher = getstandinmatcher(repo) matcher = getstandinmatcher(repo)
standins = repo.dirstate.walk(matcher, [], False, False) standins = repo.dirstate.walk(matcher, subrepos=[], unknown=False,
ignored=False)
if len(standins) > 0: if len(standins) > 0:
vfs.makedirs(lfstoredir) vfs.makedirs(lfstoredir)
for standin in standins: for standin in standins:
lfile = splitstandin(standin) lfile = splitstandin(standin)
lfdirstate.normallookup(lfile) lfdirstate.normallookup(lfile)
return lfdirstate return lfdirstate
class storeprotonotcapable(Exception): class storeprotonotcapable(Exception):
def __init__(self, storetypes): def __init__(self, storetypes):
self.storetypes = storetypes self.storetypes = storetypes
def getstandinsstate(repo): def getstandinsstate(repo):
standins = [] standins = []
matcher = getstandinmatcher(repo) matcher = getstandinmatcher(repo)
wctx = repo[None] wctx = repo[None]
for standin in repo.dirstate.walk(matcher, [], False, False): for standin in repo.dirstate.walk(matcher, subrepos=[], unknown=False,
ignored=False):
lfile = splitstandin(standin) lfile = splitstandin(standin)
try: try:
hash = readasstandin(wctx[standin]) hash = readasstandin(wctx[standin])
except IOError: except IOError:
hash = None hash = None
standins.append((lfile, hash)) standins.append((lfile, hash))
return standins return standins
return match return match
lfiles = listlfiles(repo) lfiles = listlfiles(repo)
match._files = repo._subdirlfs(match.files(), lfiles) match._files = repo._subdirlfs(match.files(), lfiles)
# Case 2: user calls commit with specified patterns: refresh # Case 2: user calls commit with specified patterns: refresh
# any matching big files. # any matching big files.
smatcher = composestandinmatcher(repo, match) smatcher = composestandinmatcher(repo, match)
standins = repo.dirstate.walk(smatcher, [], False, False) standins = repo.dirstate.walk(smatcher, subrepos=[], unknown=False,
ignored=False)
# No matching big files: get out of the way and pass control to # No matching big files: get out of the way and pass control to
# the usual commit() method. # the usual commit() method.
if not standins: if not standins:
return match return match
# Refresh all matching big files. It's possible that the # Refresh all matching big files. It's possible that the
# commit will end up failing, in which case the big files will # commit will end up failing, in which case the big files will

mercurial/cmdutil.py

abort, warn = scmutil.checkportabilityalert(ui) abort, warn = scmutil.checkportabilityalert(ui)
if abort or warn: if abort or warn:
cca = scmutil.casecollisionauditor(ui, abort, repo.dirstate) cca = scmutil.casecollisionauditor(ui, abort, repo.dirstate)
badmatch = matchmod.badmatch(match, badfn) badmatch = matchmod.badmatch(match, badfn)
dirstate = repo.dirstate dirstate = repo.dirstate
# We don't want to just call wctx.walk here, since it would return a lot of # We don't want to just call wctx.walk here, since it would return a lot of
# clean files, which we aren't interested in and takes time. # clean files, which we aren't interested in and takes time.
for f in sorted(dirstate.walk(badmatch, sorted(wctx.substate), for f in sorted(dirstate.walk(badmatch, subrepos=sorted(wctx.substate),
True, False, full=False)): unknown=True, ignored=False, full=False)):
exact = match.exact(f) exact = match.exact(f)
if exact or not explicitonly and f not in wctx and repo.wvfs.lexists(f): if exact or not explicitonly and f not in wctx and repo.wvfs.lexists(f):
if cca: if cca:
cca(f) cca(f)
names.append(f) names.append(f)
if ui.verbose or not exact: if ui.verbose or not exact:
ui.status(_('adding %s\n') % match.rel(f)) ui.status(_('adding %s\n') % match.rel(f))

mercurial/context.py

return '' return ''
def ancestor(self, c2): def ancestor(self, c2):
"""return the "best" ancestor context of self and c2""" """return the "best" ancestor context of self and c2"""
return self._parents[0].ancestor(c2) # punt on two parents for now return self._parents[0].ancestor(c2) # punt on two parents for now
def walk(self, match): def walk(self, match):
'''Generates matching file names.''' '''Generates matching file names.'''
return sorted(self._repo.dirstate.walk(match, sorted(self.substate), return sorted(self._repo.dirstate.walk(match,
True, False)) subrepos=sorted(self.substate),
unknown=True, ignored=False))
def matches(self, match): def matches(self, match):
return sorted(self._repo.dirstate.matches(match)) return sorted(self._repo.dirstate.matches(match))
def ancestors(self): def ancestors(self):
for p in self._parents: for p in self._parents:
yield p yield p
for a in self._repo.changelog.ancestors( for a in self._repo.changelog.ancestors(

mercurial/scmutil.py

This is different from dirstate.status because it doesn't care about This is different from dirstate.status because it doesn't care about
whether files are modified or clean.''' whether files are modified or clean.'''
added, unknown, deleted, removed, forgotten = [], [], [], [], [] added, unknown, deleted, removed, forgotten = [], [], [], [], []
audit_path = pathutil.pathauditor(repo.root, cached=True) audit_path = pathutil.pathauditor(repo.root, cached=True)
ctx = repo[None] ctx = repo[None]
dirstate = repo.dirstate dirstate = repo.dirstate
walkresults = dirstate.walk(matcher, sorted(ctx.substate), True, False, walkresults = dirstate.walk(matcher, subrepos=sorted(ctx.substate),
full=False) unknown=True, ignored=False, full=False)
for abs, st in walkresults.iteritems(): for abs, st in walkresults.iteritems():
dstate = dirstate[abs] dstate = dirstate[abs]
if dstate == '?' and audit_path.check(abs): if dstate == '?' and audit_path.check(abs):
unknown.append(abs) unknown.append(abs)
elif dstate != 'r' and not st: elif dstate != 'r' and not st:
deleted.append(abs) deleted.append(abs)
elif dstate == 'r' and st: elif dstate == 'r' and st:
forgotten.append(abs) forgotten.append(abs)