This is an archive of the discontinued Mercurial Phabricator instance.

Differential D8255

cleanup: run pyupgrade on our source tree to clean up varying things
ClosedPublic

Authored by durin42 on Mar 6 2020, 2:04 PM.

Details

Reviewers
indygreg
martinvonz
Group Reviewers
hg-reviewers
Commits
rHG9d2b2df2c2ba: cleanup: run pyupgrade on our source tree to clean up varying things
Summary

Built with:

hg files 'set:**.py - mercurial/thirdparty/** - "contrib/python-zstandard/**" - hgext/fsmonitor/pywatchman/**' | xargs pyupgrade --keep-percent-format --keep-extraneous-parens

and then blackened. pyupgrade comes from
https://github.com/asottile/pyupgrade with a patch to let me preserve
extraneous parens (which we use for marking strings that shouldn't be
translated), and lets us clean up a bunch of idioms that have cruftily
accumulated over the years.

  1. skip-blame no-op automated code cleanups

Diff Detail

Repository
rHG Mercurial
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

Event Timeline

durin42 created this revision.Mar 6 2020, 2:04 PM
martinvonz accepted this revision.Mar 6 2020, 2:19 PM
This revision is now accepted and ready to land.Mar 6 2020, 2:19 PM

Revision Contents
Changeset List

PathPackages
Mcontrib/benchmarks/__init__.py (2 lines)
Mcontrib/check-py3-compat.py (2 lines)
Mcontrib/perf.py (4 lines)
Mhgext/absorb.py (8 lines)
Mhgext/closehead.py (2 lines)
Mhgext/convert/hg.py (10 lines)
Mhgext/convert/subversion.py (6 lines)
Mhgext/eol.py (2 lines)
Mhgext/fastannotate/commands.py (2 lines)
Mhgext/fsmonitor/__init__.py (26 lines)
Mhgext/histedit.py (6 lines)
Mhgext/largefiles/basestore.py (2 lines)
Mhgext/largefiles/overrides.py (4 lines)
Mhgext/largefiles/remotestore.py (6 lines)
Mhgext/mq.py (4 lines)
Mhgext/phabricator.py (10 lines)
Mhgext/rebase.py (4 lines)
Mhgext/remotefilelog/__init__.py (2 lines)
Mhgext/remotefilelog/basepack.py (4 lines)
Mhgext/remotefilelog/contentstore.py (2 lines)
Mhgext/remotefilelog/datapack.py (4 lines)
Mhgext/remotefilelog/historypack.py (8 lines)
Mhgext/remotefilelog/remotefilelog.py (4 lines)
Mhgext/remotefilelog/repack.py (2 lines)
Mhgext/schemes.py (2 lines)
Mhgext/sparse.py (2 lines)
Mhgext/strip.py (2 lines)
Mhgext/transplant.py (4 lines)
Mhgext/uncommit.py (8 lines)
Mi18n/polib.py (10 lines)
Mmercurial/ancestor.py (2 lines)
Mmercurial/branchmap.py (4 lines)
Mmercurial/changegroup.py (6 lines)
Mmercurial/cmdutil.py (4 lines)
Mmercurial/commands.py (6 lines)
Mmercurial/debugcommands.py (8 lines)
Mmercurial/discovery.py (6 lines)
Mmercurial/dispatch.py (2 lines)
Mmercurial/encoding.py (12 lines)
Mmercurial/exchange.py (4 lines)
Mmercurial/extensions.py (6 lines)
Mmercurial/fancyopts.py (2 lines)
Mmercurial/graphmod.py (6 lines)
Mmercurial/hbisect.py (2 lines)
Mmercurial/localrepo.py (12 lines)
Mmercurial/match.py (2 lines)
Mmercurial/mdiff.py (2 lines)
Mmercurial/merge.py (8 lines)
Mmercurial/obsolete.py (4 lines)
Mmercurial/obsutil.py (14 lines)
Mmercurial/patch.py (2 lines)
Mmercurial/phases.py (10 lines)
Mmercurial/pycompat.py (4 lines)
Mmercurial/repair.py (2 lines)
Mmercurial/revlog.py (2 lines)
Mmercurial/revset.py (4 lines)
Mmercurial/scmutil.py (6 lines)
Mmercurial/store.py (4 lines)
Mmercurial/upgrade.py (2 lines)
Mmercurial/url.py (12 lines)
Mmercurial/util.py (2 lines)
Mmercurial/utils/storageutil.py (2 lines)
Mmercurial/windows.py (12 lines)
Mmercurial/wireprototypes.py (4 lines)
Msetup.py (6 lines)
Mtests/run-tests.py (8 lines)
Mtests/simplestorerepo.py (2 lines)
Mtests/test-fastannotate-revmap.py (2 lines)
Mtests/test-hgweb-auth.py (2 lines)
Mtests/test-revlog-raw.py (2 lines)
Mtests/wireprotosimplecache.py (2 lines)

Diff 20571

contrib/benchmarks/__init__.py

ui, 'perfext', os.path.join(basedir, 'contrib', 'perf.py') ui, 'perfext', os.path.join(basedir, 'contrib', 'perf.py')
) )
cmd = getattr(perfext, command) cmd = getattr(perfext, command)
ui.pushbuffer() ui.pushbuffer()
cmd(ui, repo, *args, **kwargs) cmd(ui, repo, *args, **kwargs)
output = ui.popbuffer() output = ui.popbuffer()
match = outputre.search(output) match = outputre.search(output)
if not match: if not match:
raise ValueError("Invalid output {0}".format(output)) raise ValueError("Invalid output {}".format(output))
return float(match.group(1)) return float(match.group(1))
def perfbench(repos=reposnames, name=None, params=None): def perfbench(repos=reposnames, name=None, params=None):
"""decorator to declare ASV benchmark based on contrib/perf.py extension """decorator to declare ASV benchmark based on contrib/perf.py extension
An ASV benchmark is a python function with the given attributes: An ASV benchmark is a python function with the given attributes:

contrib/check-py3-compat.py

if not root.body: if not root.body:
return return
futures = set() futures = set()
haveprint = False haveprint = False
for node in ast.walk(root): for node in ast.walk(root):
if isinstance(node, ast.ImportFrom): if isinstance(node, ast.ImportFrom):
if node.module == '__future__': if node.module == '__future__':
futures |= set(n.name for n in node.names) futures |= {n.name for n in node.names}
elif isinstance(node, ast.Print): elif isinstance(node, ast.Print):
haveprint = True haveprint = True
if 'absolute_import' not in futures: if 'absolute_import' not in futures:
print('%s not using absolute_import' % f) print('%s not using absolute_import' % f)
if haveprint and 'print_function' not in futures: if haveprint and 'print_function' not in futures:
print('%s requires print_function' % f) print('%s requires print_function' % f)

contrib/perf.py

timer, fm = gettimer(ui, opts) timer, fm = gettimer(ui, opts)
options = { options = {
'w': 'ignore_all_space', 'w': 'ignore_all_space',
'b': 'ignore_space_change', 'b': 'ignore_space_change',
'B': 'ignore_blank_lines', 'B': 'ignore_blank_lines',
} }
for diffopt in ('', 'w', 'b', 'B', 'wB'): for diffopt in ('', 'w', 'b', 'B', 'wB'):
opts = dict((options[c], b'1') for c in diffopt) opts = {options[c]: b'1' for c in diffopt}
def d(): def d():
ui.pushbuffer() ui.pushbuffer()
commands.diff(ui, repo, **opts) commands.diff(ui, repo, **opts)
ui.popbuffer() ui.popbuffer()
diffopt = diffopt.encode('ascii') diffopt = diffopt.encode('ascii')
title = b'diffopts: %s' % (diffopt and (b'-' + diffopt) or b'none') title = b'diffopts: %s' % (diffopt and (b'-' + diffopt) or b'none')
# _chunkraw was renamed to _getsegmentforrevs. # _chunkraw was renamed to _getsegmentforrevs.
try: try:
segmentforrevs = rl._getsegmentforrevs segmentforrevs = rl._getsegmentforrevs
except AttributeError: except AttributeError:
segmentforrevs = rl._chunkraw segmentforrevs = rl._chunkraw
# Verify engines argument. # Verify engines argument.
if engines: if engines:
engines = set(e.strip() for e in engines.split(b',')) engines = {e.strip() for e in engines.split(b',')}
for engine in engines: for engine in engines:
try: try:
util.compressionengines[engine] util.compressionengines[engine]
except KeyError: except KeyError:
raise error.Abort(b'unknown compression engine: %s' % engine) raise error.Abort(b'unknown compression engine: %s' % engine)
else: else:
engines = [] engines = []
for e in util.compengines: for e in util.compengines:

hgext/absorb.py

involved = annotated[a1:a2] involved = annotated[a1:a2]
if not involved and annotated: # a1 == a2 and a is not empty if not involved and annotated: # a1 == a2 and a is not empty
# pure insertion, check nearby lines. ignore lines belong # pure insertion, check nearby lines. ignore lines belong
# to the public (first) changeset (i.e. annotated[i][0] == 1) # to the public (first) changeset (i.e. annotated[i][0] == 1)
nearbylinenums = {a2, max(0, a1 - 1)} nearbylinenums = {a2, max(0, a1 - 1)}
involved = [ involved = [
annotated[i] for i in nearbylinenums if annotated[i][0] != 1 annotated[i] for i in nearbylinenums if annotated[i][0] != 1
] ]
involvedrevs = list(set(r for r, l in involved)) involvedrevs = list({r for r, l in involved})
newfixups = [] newfixups = []
if len(involvedrevs) == 1 and self._iscontinuous(a1, a2 - 1, True): if len(involvedrevs) == 1 and self._iscontinuous(a1, a2 - 1, True):
# chunk belongs to a single revision # chunk belongs to a single revision
rev = involvedrevs[0] rev = involvedrevs[0]
if rev > 1: if rev > 1:
fixuprev = rev + 1 fixuprev = rev + 1
newfixups.append((fixuprev, a1, a2, b1, b2)) newfixups.append((fixuprev, a1, a2, b1, b2))
elif a2 - a1 == b2 - b1 or b1 == b2: elif a2 - a1 == b2 - b1 or b1 == b2:
for path, state in pycompat.iteritems(self.fixupmap): for path, state in pycompat.iteritems(self.fixupmap):
if self.ui.debugflag: if self.ui.debugflag:
self.ui.write(_(b'applying fixups to %s\n') % path) self.ui.write(_(b'applying fixups to %s\n') % path)
state.apply() state.apply()
@property @property
def chunkstats(self): def chunkstats(self):
"""-> {path: chunkstats}. collect chunkstats from filefixupstates""" """-> {path: chunkstats}. collect chunkstats from filefixupstates"""
return dict( return {
(path, state.chunkstats) path: state.chunkstats
for path, state in pycompat.iteritems(self.fixupmap) for path, state in pycompat.iteritems(self.fixupmap)
) }
def commit(self): def commit(self):
"""commit changes. update self.finalnode, self.replacemap""" """commit changes. update self.finalnode, self.replacemap"""
with self.repo.transaction(b'absorb') as tr: with self.repo.transaction(b'absorb') as tr:
self._commitstack() self._commitstack()
self._movebookmarks(tr) self._movebookmarks(tr)
if self.repo[b'.'].node() in self.replacemap: if self.repo[b'.'].node() in self.replacemap:
self._moveworkingdirectoryparent() self._moveworkingdirectoryparent()

hgext/closehead.py

revs = scmutil.revrange(repo, revs) revs = scmutil.revrange(repo, revs)
if not revs: if not revs:
raise error.Abort(_(b'no revisions specified')) raise error.Abort(_(b'no revisions specified'))
heads = [] heads = []
for branch in repo.branchmap(): for branch in repo.branchmap():
heads.extend(repo.branchheads(branch)) heads.extend(repo.branchheads(branch))
heads = set(repo[h].rev() for h in heads) heads = {repo[h].rev() for h in heads}
for rev in revs: for rev in revs:
if rev not in heads: if rev not in heads:
raise error.Abort(_(b'revision is not an open head: %d') % rev) raise error.Abort(_(b'revision is not an open head: %d') % rev)
message = cmdutil.logmessage(ui, opts) message = cmdutil.logmessage(ui, opts)
if not message: if not message:
raise error.Abort(_(b"no commit message specified with -l or -m")) raise error.Abort(_(b"no commit message specified with -l or -m"))
extra = {b'close': b'1'} extra = {b'close': b'1'}
with repo.wlock(), repo.lock(): with repo.wlock(), repo.lock():
for rev in revs: for rev in revs:
r = repo[rev] r = repo[rev]
branch = r.branch() branch = r.branch()
extra[b'branch'] = branch extra[b'branch'] = branch
docommit(r) docommit(r)
return 0 return 0

hgext/convert/hg.py

def gettags(self): def gettags(self):
# This will get written to .hgtags, filter non global tags out. # This will get written to .hgtags, filter non global tags out.
tags = [ tags = [
t t
for t in self.repo.tagslist() for t in self.repo.tagslist()
if self.repo.tagtype(t[0]) == b'global' if self.repo.tagtype(t[0]) == b'global'
] ]
return dict( return {
[ name: nodemod.hex(node) for name, node in tags if self.keep(node)
(name, nodemod.hex(node)) }
for name, node in tags
if self.keep(node)
]
)
def getchangedfiles(self, rev, i): def getchangedfiles(self, rev, i):
ctx = self._changectx(rev) ctx = self._changectx(rev)
parents = self._parents(ctx) parents = self._parents(ctx)
if not parents and i is None: if not parents and i is None:
i = 0 i = 0
ma, r = ctx.manifest().keys(), [] ma, r = ctx.manifest().keys(), []
else: else:

hgext/convert/subversion.py

# Filter out tags with children coming from different # Filter out tags with children coming from different
# parts of the repository like: # parts of the repository like:
# /tags/tag.1 (from /trunk:10) # /tags/tag.1 (from /trunk:10)
# /tags/tag.1/foo (from /branches/foo:12) # /tags/tag.1/foo (from /branches/foo:12)
# Here/tags/tag.1 discarded as well as its children. # Here/tags/tag.1 discarded as well as its children.
# It happens with tools like cvs2svn. Such tags cannot # It happens with tools like cvs2svn. Such tags cannot
# be represented in mercurial. # be represented in mercurial.
addeds = dict( addeds = {
(p, e.copyfrom_path) p: e.copyfrom_path
for p, e in pycompat.iteritems(origpaths) for p, e in pycompat.iteritems(origpaths)
if e.action == b'A' and e.copyfrom_path if e.action == b'A' and e.copyfrom_path
) }
badroots = set() badroots = set()
for destroot in addeds: for destroot in addeds:
for source, sourcerev, dest in pendings: for source, sourcerev, dest in pendings:
if not dest.startswith( if not dest.startswith(
destroot + b'/' destroot + b'/'
) or source.startswith(addeds[destroot] + b'/'): ) or source.startswith(addeds[destroot] + b'/'):
continue continue
badroots.add(destroot) badroots.add(destroot)

hgext/eol.py

include.append(pattern) include.append(pattern)
m = match.match(root, b'', [pattern]) m = match.match(root, b'', [pattern])
self.patterns.append((pattern, key, m)) self.patterns.append((pattern, key, m))
# This will match the files for which we need to care # This will match the files for which we need to care
# about inconsistent newlines. # about inconsistent newlines.
self.match = match.match(root, b'', [], include, exclude) self.match = match.match(root, b'', [], include, exclude)
def copytoui(self, ui): def copytoui(self, ui):
newpatterns = set(pattern for pattern, key, m in self.patterns) newpatterns = {pattern for pattern, key, m in self.patterns}
for section in (b'decode', b'encode'): for section in (b'decode', b'encode'):
for oldpattern, _filter in ui.configitems(section): for oldpattern, _filter in ui.configitems(section):
if oldpattern not in newpatterns: if oldpattern not in newpatterns:
if ui.configsource(section, oldpattern) == b'eol': if ui.configsource(section, oldpattern) == b'eol':
ui.setconfig(section, oldpattern, b'!', b'eol') ui.setconfig(section, oldpattern, b'!', b'eol')
for pattern, key, m in self.patterns: for pattern, key, m in self.patterns:
try: try:
ui.setconfig(b'decode', pattern, self._decode[key], b'eol') ui.setconfig(b'decode', pattern, self._decode[key], b'eol')

hgext/fastannotate/commands.py

with facontext.annotatecontext(repo, path, aopts, rebuild) as a: with facontext.annotatecontext(repo, path, aopts, rebuild) as a:
result = a.annotate( result = a.annotate(
rev, rev,
master=master, master=master,
showpath=showpath, showpath=showpath,
showlines=(showlines and not showdeleted), showlines=(showlines and not showdeleted),
) )
if showdeleted: if showdeleted:
existinglines = set((l[0], l[1]) for l in result) existinglines = {(l[0], l[1]) for l in result}
result = a.annotatealllines( result = a.annotatealllines(
rev, showpath=showpath, showlines=showlines rev, showpath=showpath, showlines=showlines
) )
break break
except (faerror.CannotReuseError, faerror.CorruptedFileError): except (faerror.CannotReuseError, faerror.CorruptedFileError):
# happens if master moves backwards, or the file was deleted # happens if master moves backwards, or the file was deleted
# and readded, or renamed to an existing name, or corrupted. # and readded, or renamed to an existing name, or corrupted.
if rebuild: # give up since we have tried rebuild already if rebuild: # give up since we have tried rebuild already

hgext/fsmonitor/__init__.py

return bail(b'fresh instance') return bail(b'fresh instance')
fresh_instance = True fresh_instance = True
# Ignore any prior noteable files from the state info # Ignore any prior noteable files from the state info
notefiles = [] notefiles = []
# for file paths which require normalization and we encounter a case # for file paths which require normalization and we encounter a case
# collision, we store our own foldmap # collision, we store our own foldmap
if normalize: if normalize:
foldmap = dict((normcase(k), k) for k in results) foldmap = {normcase(k): k for k in results}
switch_slashes = pycompat.ossep == b'\\' switch_slashes = pycompat.ossep == b'\\'
# The order of the results is, strictly speaking, undefined. # The order of the results is, strictly speaking, undefined.
# For case changes on a case insensitive filesystem we may receive # For case changes on a case insensitive filesystem we may receive
# two entries, one with exists=True and another with exists=False. # two entries, one with exists=True and another with exists=False.
# The exists=True entries in the same response should be interpreted # The exists=True entries in the same response should be interpreted
# as being happens-after the exists=False entries due to the way that # as being happens-after the exists=False entries due to the way that
# Watchman tracks files. We use this property to reconcile deletes # Watchman tracks files. We use this property to reconcile deletes
elif fname in dmap and (matchalways or matchfn(fname)): elif fname in dmap and (matchalways or matchfn(fname)):
results[fname] = None results[fname] = None
# step 3: query notable files we don't already know about # step 3: query notable files we don't already know about
# XXX try not to iterate over the entire dmap # XXX try not to iterate over the entire dmap
if normalize: if normalize:
# any notable files that have changed case will already be handled # any notable files that have changed case will already be handled
# above, so just check membership in the foldmap # above, so just check membership in the foldmap
notefiles = set( notefiles = {
(
normalize(f, True, True) normalize(f, True, True)
for f in notefiles for f in notefiles
if normcase(f) not in foldmap if normcase(f) not in foldmap
) }
) visit = {
visit = set(
(
f f
for f in notefiles for f in notefiles
if ( if (f not in results and matchfn(f) and (f in dmap or not ignore(f)))
f not in results and matchfn(f) and (f in dmap or not ignore(f)) }
)
)
)
if not fresh_instance: if not fresh_instance:
if matchalways: if matchalways:
visit.update(f for f in nonnormalset if f not in results) visit.update(f for f in nonnormalset if f not in results)
visit.update(f for f in copymap if f not in results) visit.update(f for f in copymap if f not in results)
else: else:
visit.update( visit.update(
f for f in nonnormalset if f not in results and matchfn(f) f for f in nonnormalset if f not in results and matchfn(f)

hgext/histedit.py

ctx = repo[b'.'] ctx = repo[b'.']
rulectx = repo[self.node] rulectx = repo[self.node]
parentctxnode = self.state.parentctxnode parentctxnode = self.state.parentctxnode
if ctx.node() == parentctxnode: if ctx.node() == parentctxnode:
repo.ui.warn(_(b'%s: empty changeset\n') % node.short(self.node)) repo.ui.warn(_(b'%s: empty changeset\n') % node.short(self.node))
return ctx, [(self.node, (parentctxnode,))] return ctx, [(self.node, (parentctxnode,))]
parentctx = repo[parentctxnode] parentctx = repo[parentctxnode]
newcommits = set( newcommits = {
c.node() c.node()
for c in repo.set(b'(%d::. - %d)', parentctx.rev(), parentctx.rev()) for c in repo.set(b'(%d::. - %d)', parentctx.rev(), parentctx.rev())
) }
if not newcommits: if not newcommits:
repo.ui.warn( repo.ui.warn(
_( _(
b'%s: cannot fold - working copy is not a ' b'%s: cannot fold - working copy is not a '
b'descendant of previous commit %s\n' b'descendant of previous commit %s\n'
) )
% (node.short(self.node), node.short(parentctxnode)) % (node.short(self.node), node.short(parentctxnode))
) )
def verifyactions(actions, state, ctxs): def verifyactions(actions, state, ctxs):
"""Verify that there exists exactly one action per given changeset and """Verify that there exists exactly one action per given changeset and
other constraints. other constraints.
Will abort if there are to many or too few rules, a malformed rule, Will abort if there are to many or too few rules, a malformed rule,
or a rule on a changeset outside of the user-given range. or a rule on a changeset outside of the user-given range.
""" """
expected = set(c.node() for c in ctxs) expected = {c.node() for c in ctxs}
seen = set() seen = set()
prev = None prev = None
if actions and actions[0].verb in [b'roll', b'fold']: if actions and actions[0].verb in [b'roll', b'fold']:
raise error.ParseError( raise error.ParseError(
_(b'first changeset cannot use verb "%s"') % actions[0].verb _(b'first changeset cannot use verb "%s"') % actions[0].verb
) )

hgext/largefiles/basestore.py

we could not get. (The detailed error message will already have we could not get. (The detailed error message will already have
been presented to the user, so missing is just supplied as a been presented to the user, so missing is just supplied as a
summary.)''' summary.)'''
success = [] success = []
missing = [] missing = []
ui = self.ui ui = self.ui
at = 0 at = 0
available = self.exists(set(hash for (_filename, hash) in files)) available = self.exists({hash for (_filename, hash) in files})
with ui.makeprogress( with ui.makeprogress(
_(b'getting largefiles'), unit=_(b'files'), total=len(files) _(b'getting largefiles'), unit=_(b'files'), total=len(files)
) as progress: ) as progress:
for filename, hash in files: for filename, hash in files:
progress.update(at) progress.update(at)
at += 1 at += 1
ui.note(_(b'getting %s:%s\n') % (filename, hash)) ui.note(_(b'getting %s:%s\n') % (filename, hash))

hgext/largefiles/overrides.py

orig(ui, repo, *dirs, **opts) orig(ui, repo, *dirs, **opts)
repo.status = oldstatus repo.status = oldstatus
@eh.wrapcommand(b'rollback') @eh.wrapcommand(b'rollback')
def overriderollback(orig, ui, repo, **opts): def overriderollback(orig, ui, repo, **opts):
with repo.wlock(): with repo.wlock():
before = repo.dirstate.parents() before = repo.dirstate.parents()
orphans = set( orphans = {
f f
for f in repo.dirstate for f in repo.dirstate
if lfutil.isstandin(f) and repo.dirstate[f] != b'r' if lfutil.isstandin(f) and repo.dirstate[f] != b'r'
) }
result = orig(ui, repo, **opts) result = orig(ui, repo, **opts)
after = repo.dirstate.parents() after = repo.dirstate.parents()
if before == after: if before == after:
return result # no need to restore standins return result # no need to restore standins
pctx = repo[b'.'] pctx = repo[b'.']
for f in repo.dirstate: for f in repo.dirstate:
if lfutil.isstandin(f): if lfutil.isstandin(f):

hgext/largefiles/remotestore.py

% (source, util.hidepassword(self.url)) % (source, util.hidepassword(self.url))
) )
self.ui.debug( self.ui.debug(
_(b'remotestore: put %s to remote store %s\n') _(b'remotestore: put %s to remote store %s\n')
% (source, util.hidepassword(self.url)) % (source, util.hidepassword(self.url))
) )
def exists(self, hashes): def exists(self, hashes):
return dict( return {
(h, s == 0) h: s == 0
for (h, s) in pycompat.iteritems( for (h, s) in pycompat.iteritems(
self._stat(hashes) self._stat(hashes)
) # dict-from-generator ) # dict-from-generator
) }
def sendfile(self, filename, hash): def sendfile(self, filename, hash):
self.ui.debug(b'remotestore: sendfile(%s, %s)\n' % (filename, hash)) self.ui.debug(b'remotestore: sendfile(%s, %s)\n' % (filename, hash))
try: try:
with lfutil.httpsendfile(self.ui, filename) as fd: with lfutil.httpsendfile(self.ui, filename) as fd:
return self._put(hash, fd) return self._put(hash, fd)
except IOError as e: except IOError as e:
raise error.Abort( raise error.Abort(

hgext/mq.py

for (i, p) in sortedseries: for (i, p) in sortedseries:
if i != -1: if i != -1:
del self.fullseries[i] del self.fullseries[i]
else: else:
unknown.append(p) unknown.append(p)
if unknown: if unknown:
if numrevs: if numrevs:
rev = dict((entry.name, entry.node) for entry in qfinished) rev = {entry.name: entry.node for entry in qfinished}
for p in unknown: for p in unknown:
msg = _(b'revision %s refers to unknown patches: %s\n') msg = _(b'revision %s refers to unknown patches: %s\n')
self.ui.warn(msg % (short(rev[p]), p)) self.ui.warn(msg % (short(rev[p]), p))
else: else:
msg = _(b'unknown patches: %s\n') msg = _(b'unknown patches: %s\n')
raise error.Abort(b''.join(msg % p for p in unknown)) raise error.Abort(b''.join(msg % p for p in unknown))
self.parseseries() self.parseseries()
ui.write(guard, label=b'qguard.negative') ui.write(guard, label=b'qguard.negative')
else: else:
ui.write(guard, label=b'qguard.unguarded') ui.write(guard, label=b'qguard.unguarded')
if i != len(guards) - 1: if i != len(guards) - 1:
ui.write(b' ') ui.write(b' ')
ui.write(b'\n') ui.write(b'\n')
q = repo.mq q = repo.mq
applied = set(p.name for p in q.applied) applied = {p.name for p in q.applied}
patch = None patch = None
args = list(args) args = list(args)
if opts.get('list'): if opts.get('list'):
if args or opts.get('none'): if args or opts.get('none'):
raise error.Abort( raise error.Abort(
_(b'cannot mix -l/--list with options or arguments') _(b'cannot mix -l/--list with options or arguments')
) )
for i in pycompat.xrange(len(q.series)): for i in pycompat.xrange(len(q.series)):

hgext/phabricator.py

) )
getnode = lambda d: bin(getdiffmeta(d).get(b'node', b'')) or None getnode = lambda d: bin(getdiffmeta(d).get(b'node', b'')) or None
for newnode, (force, precset, drev) in toconfirm.items(): for newnode, (force, precset, drev) in toconfirm.items():
diffs = [ diffs = [
d for d in alldiffs.values() if int(d[b'revisionID']) == drev d for d in alldiffs.values() if int(d[b'revisionID']) == drev
] ]
# "precursors" as known by Phabricator # "precursors" as known by Phabricator
phprecset = set(getnode(d) for d in diffs) phprecset = {getnode(d) for d in diffs}
# Ignore if precursors (Phabricator and local repo) do not overlap, # Ignore if precursors (Phabricator and local repo) do not overlap,
# and force is not set (when commit message says nothing) # and force is not set (when commit message says nothing)
if not force and not bool(phprecset & precset): if not force and not bool(phprecset & precset):
tagname = b'D%d' % drev tagname = b'D%d' % drev
tags.tag( tags.tag(
repo, repo,
tagname, tagname,
def userphids(ui, names): def userphids(ui, names):
"""convert user names to PHIDs""" """convert user names to PHIDs"""
names = [name.lower() for name in names] names = [name.lower() for name in names]
query = {b'constraints': {b'usernames': names}} query = {b'constraints': {b'usernames': names}}
result = callconduit(ui, b'user.search', query) result = callconduit(ui, b'user.search', query)
# username not found is not an error of the API. So check if we have missed # username not found is not an error of the API. So check if we have missed
# some names here. # some names here.
data = result[b'data'] data = result[b'data']
resolved = set(entry[b'fields'][b'username'].lower() for entry in data) resolved = {entry[b'fields'][b'username'].lower() for entry in data}
unresolved = set(names) - resolved unresolved = set(names) - resolved
if unresolved: if unresolved:
raise error.Abort( raise error.Abort(
_(b'unknown username: %s') % b' '.join(sorted(unresolved)) _(b'unknown username: %s') % b' '.join(sorted(unresolved))
) )
return [entry[b'phid'] for entry in data] return [entry[b'phid'] for entry in data]
"""generate plain-text patch readable by 'hg import' """generate plain-text patch readable by 'hg import'
write takes a list of (DREV, bytes), where DREV is the differential number write takes a list of (DREV, bytes), where DREV is the differential number
(as bytes, without the "D" prefix) and the bytes are the text of a patch (as bytes, without the "D" prefix) and the bytes are the text of a patch
to be imported. drevs is what "querydrev" returns, results of to be imported. drevs is what "querydrev" returns, results of
"differential.query". "differential.query".
""" """
# Prefetch hg:meta property for all diffs # Prefetch hg:meta property for all diffs
diffids = sorted(set(max(int(v) for v in drev[b'diffs']) for drev in drevs)) diffids = sorted({max(int(v) for v in drev[b'diffs']) for drev in drevs})
diffs = callconduit(ui, b'differential.querydiffs', {b'ids': diffids}) diffs = callconduit(ui, b'differential.querydiffs', {b'ids': diffids})
patches = [] patches = []
# Generate patch for each drev # Generate patch for each drev
for drev in drevs: for drev in drevs:
ui.note(_(b'reading D%s\n') % drev[b'id']) ui.note(_(b'reading D%s\n') % drev[b'id'])
return None return None
@show.showview(b'phabstatus', csettopic=b'work') @show.showview(b'phabstatus', csettopic=b'work')
def phabstatusshowview(ui, repo, displayer): def phabstatusshowview(ui, repo, displayer):
"""Phabricator differiential status""" """Phabricator differiential status"""
revs = repo.revs('sort(_underway(), topo)') revs = repo.revs('sort(_underway(), topo)')
drevmap = getdrevmap(repo, revs) drevmap = getdrevmap(repo, revs)
unknownrevs, drevids, revsbydrevid = [], set([]), {} unknownrevs, drevids, revsbydrevid = [], set(), {}
for rev, drevid in pycompat.iteritems(drevmap): for rev, drevid in pycompat.iteritems(drevmap):
if drevid is not None: if drevid is not None:
drevids.add(drevid) drevids.add(drevid)
revsbydrevid.setdefault(drevid, set([])).add(rev) revsbydrevid.setdefault(drevid, set()).add(rev)
else: else:
unknownrevs.append(rev) unknownrevs.append(rev)
drevs = callconduit(ui, b'differential.query', {b'ids': list(drevids)}) drevs = callconduit(ui, b'differential.query', {b'ids': list(drevids)})
drevsbyrev = {} drevsbyrev = {}
for drev in drevs: for drev in drevs:
for rev in revsbydrevid[int(drev[b'id'])]: for rev in revsbydrevid[int(drev[b'id'])]:
drevsbyrev[rev] = drev drevsbyrev[rev] = drev

hgext/rebase.py

''' '''
rebaseset = destmap.keys() rebaseset = destmap.keys()
originalwd = repo[b'.'].rev() originalwd = repo[b'.'].rev()
# This check isn't strictly necessary, since mq detects commits over an # This check isn't strictly necessary, since mq detects commits over an
# applied patch. But it prevents messing up the working directory when # applied patch. But it prevents messing up the working directory when
# a partially completed rebase is blocked by mq. # a partially completed rebase is blocked by mq.
if b'qtip' in repo.tags(): if b'qtip' in repo.tags():
mqapplied = set(repo[s.node].rev() for s in repo.mq.applied) mqapplied = {repo[s.node].rev() for s in repo.mq.applied}
if set(destmap.values()) & mqapplied: if set(destmap.values()) & mqapplied:
raise error.Abort(_(b'cannot rebase onto an applied mq patch')) raise error.Abort(_(b'cannot rebase onto an applied mq patch'))
# Get "cycle" error early by exhausting the generator. # Get "cycle" error early by exhausting the generator.
sortedsrc = list(sortsource(destmap)) # a list of sorted revs sortedsrc = list(sortsource(destmap)) # a list of sorted revs
if not sortedsrc: if not sortedsrc:
raise error.Abort(_(b'no matching revisions')) raise error.Abort(_(b'no matching revisions'))
raise error.Abort(_(b'--tool can only be used with --rebase')) raise error.Abort(_(b'--tool can only be used with --rebase'))
ret = orig(ui, repo, *args, **opts) ret = orig(ui, repo, *args, **opts)
return ret return ret
def _filterobsoleterevs(repo, revs): def _filterobsoleterevs(repo, revs):
"""returns a set of the obsolete revisions in revs""" """returns a set of the obsolete revisions in revs"""
return set(r for r in revs if repo[r].obsolete()) return {r for r in revs if repo[r].obsolete()}
def _computeobsoletenotrebased(repo, rebaseobsrevs, destmap): def _computeobsoletenotrebased(repo, rebaseobsrevs, destmap):
"""Return (obsoletenotrebased, obsoletewithoutsuccessorindestination). """Return (obsoletenotrebased, obsoletewithoutsuccessorindestination).
`obsoletenotrebased` is a mapping mapping obsolete => successor for all `obsoletenotrebased` is a mapping mapping obsolete => successor for all
obsolete nodes to be rebased given in `rebaseobsrevs`. obsolete nodes to be rebased given in `rebaseobsrevs`.

hgext/remotefilelog/__init__.py

else: else:
raise error.ProgrammingError( raise error.ProgrammingError(
b'pending multiple integer revisions are not supported' b'pending multiple integer revisions are not supported'
) )
else: else:
# "link" is actually wrong here (it is set to len(changelog)) # "link" is actually wrong here (it is set to len(changelog))
# if changelog remains unchanged, skip writing file revisions # if changelog remains unchanged, skip writing file revisions
# but still do a sanity check about pending multiple revisions # but still do a sanity check about pending multiple revisions
if len(set(x[3] for x in pendingfilecommits)) > 1: if len({x[3] for x in pendingfilecommits}) > 1:
raise error.ProgrammingError( raise error.ProgrammingError(
b'pending multiple integer revisions are not supported' b'pending multiple integer revisions are not supported'
) )
del pendingfilecommits[:] del pendingfilecommits[:]
return node return node
extensions.wrapfunction(changelog.changelog, b'add', changelogadd) extensions.wrapfunction(changelog.changelog, b'add', changelogadd)

hgext/remotefilelog/basepack.py

def __iter__(self): def __iter__(self):
self._registerlastpackusage() self._registerlastpackusage()
# Cache iteration is based on LRU. # Cache iteration is based on LRU.
for pack in self._lrucache: for pack in self._lrucache:
self._lastpack = pack self._lastpack = pack
yield pack yield pack
cachedpacks = set(pack for pack in self._lrucache) cachedpacks = {pack for pack in self._lrucache}
# Yield for paths not in the cache. # Yield for paths not in the cache.
for pack in self._packs - cachedpacks: for pack in self._packs - cachedpacks:
self._lastpack = pack self._lastpack = pack
yield pack yield pack
# Data not found in any pack. # Data not found in any pack.
self._lastpack = None self._lastpack = None
# If we experience a lot of misses (like in the case of getmissing() on # If we experience a lot of misses (like in the case of getmissing() on
# new objects), let's only actually check disk for new stuff every once # new objects), let's only actually check disk for new stuff every once
# in a while. Generally this code path should only ever matter when a # in a while. Generally this code path should only ever matter when a
# repack is going on in the background, and that should be pretty rare # repack is going on in the background, and that should be pretty rare
# to have that happen twice in quick succession. # to have that happen twice in quick succession.
newpacks = [] newpacks = []
if now > self.lastrefresh + REFRESHRATE: if now > self.lastrefresh + REFRESHRATE:
self.lastrefresh = now self.lastrefresh = now
previous = set(p.path for p in self.packs) previous = {p.path for p in self.packs}
for filepath, __, __ in self._getavailablepackfilessorted(): for filepath, __, __ in self._getavailablepackfilessorted():
if filepath not in previous: if filepath not in previous:
newpack = self.getpack(filepath) newpack = self.getpack(filepath)
newpacks.append(newpack) newpacks.append(newpack)
self.packs.add(newpack) self.packs.add(newpack)
return newpacks return newpacks

hgext/remotefilelog/contentstore.py

def getancestors(self, name, node, known=None): def getancestors(self, name, node, known=None):
if known is None: if known is None:
known = set() known = set()
if node in known: if node in known:
return [] return []
rl = self._revlog(name) rl = self._revlog(name)
ancestors = {} ancestors = {}
missing = set((node,)) missing = {node}
for ancrev in rl.ancestors([rl.rev(node)], inclusive=True): for ancrev in rl.ancestors([rl.rev(node)], inclusive=True):
ancnode = rl.node(ancrev) ancnode = rl.node(ancrev)
missing.discard(ancnode) missing.discard(ancnode)
p1, p2 = rl.parents(ancnode) p1, p2 = rl.parents(ancnode)
if p1 != nullid and p1 not in known: if p1 != nullid and p1 not in known:
missing.add(p1) missing.add(p1)
if p2 != nullid and p2 not in known: if p2 != nullid and p2 not in known:

hgext/remotefilelog/datapack.py

def markledger(self, ledger, options=None): def markledger(self, ledger, options=None):
for filename, node in self: for filename, node in self:
ledger.markdataentry(self, filename, node) ledger.markdataentry(self, filename, node)
def cleanup(self, ledger): def cleanup(self, ledger):
entries = ledger.sources.get(self, []) entries = ledger.sources.get(self, [])
allkeys = set(self) allkeys = set(self)
repackedkeys = set( repackedkeys = {
(e.filename, e.node) for e in entries if e.datarepacked or e.gced (e.filename, e.node) for e in entries if e.datarepacked or e.gced
) }
if len(allkeys - repackedkeys) == 0: if len(allkeys - repackedkeys) == 0:
if self.path not in ledger.created: if self.path not in ledger.created:
util.unlinkpath(self.indexpath, ignoremissing=True) util.unlinkpath(self.indexpath, ignoremissing=True)
util.unlinkpath(self.packpath, ignoremissing=True) util.unlinkpath(self.packpath, ignoremissing=True)
def __iter__(self): def __iter__(self):
for f, n, deltabase, deltalen in self.iterentries(): for f, n, deltabase, deltalen in self.iterentries():

hgext/remotefilelog/historypack.py

# just be (p1, p2, linknode, copyfrom) # just be (p1, p2, linknode, copyfrom)
return self._findnode(name, node)[1:] return self._findnode(name, node)[1:]
def _getancestors(self, name, node, known=None): def _getancestors(self, name, node, known=None):
if known is None: if known is None:
known = set() known = set()
section = self._findsection(name) section = self._findsection(name)
filename, offset, size, nodeindexoffset, nodeindexsize = section filename, offset, size, nodeindexoffset, nodeindexsize = section
pending = set((node,)) pending = {node}
o = 0 o = 0
while o < size: while o < size:
if not pending: if not pending:
break break
entry, copyfrom = self._readentry(offset + o) entry, copyfrom = self._readentry(offset + o)
o += PACKENTRYLENGTH o += PACKENTRYLENGTH
if copyfrom: if copyfrom:
o += len(copyfrom) o += len(copyfrom)
def markledger(self, ledger, options=None): def markledger(self, ledger, options=None):
for filename, node in self: for filename, node in self:
ledger.markhistoryentry(self, filename, node) ledger.markhistoryentry(self, filename, node)
def cleanup(self, ledger): def cleanup(self, ledger):
entries = ledger.sources.get(self, []) entries = ledger.sources.get(self, [])
allkeys = set(self) allkeys = set(self)
repackedkeys = set( repackedkeys = {
(e.filename, e.node) for e in entries if e.historyrepacked (e.filename, e.node) for e in entries if e.historyrepacked
) }
if len(allkeys - repackedkeys) == 0: if len(allkeys - repackedkeys) == 0:
if self.path not in ledger.created: if self.path not in ledger.created:
util.unlinkpath(self.indexpath, ignoremissing=True) util.unlinkpath(self.indexpath, ignoremissing=True)
util.unlinkpath(self.packpath, ignoremissing=True) util.unlinkpath(self.packpath, ignoremissing=True)
def __iter__(self): def __iter__(self):
for f, n, x, x, x, x in self.iterentries(): for f, n, x, x, x, x in self.iterentries():
) )
def _write(self): def _write(self):
for filename in sorted(self.fileentries): for filename in sorted(self.fileentries):
entries = self.fileentries[filename] entries = self.fileentries[filename]
sectionstart = self.packfp.tell() sectionstart = self.packfp.tell()
# Write the file section content # Write the file section content
entrymap = dict((e[0], e) for e in entries) entrymap = {e[0]: e for e in entries}
def parentfunc(node): def parentfunc(node):
x, p1, p2, x, x, x = entrymap[node] x, p1, p2, x, x, x = entrymap[node]
parents = [] parents = []
if p1 != nullid: if p1 != nullid:
parents.append(p1) parents.append(p1)
if p2 != nullid: if p2 != nullid:
parents.append(p2) parents.append(p2)

hgext/remotefilelog/remotefilelog.py

def ancestormap(self, node): def ancestormap(self, node):
return self.repo.metadatastore.getancestors(self.filename, node) return self.repo.metadatastore.getancestors(self.filename, node)
def ancestor(self, a, b): def ancestor(self, a, b):
if a == nullid or b == nullid: if a == nullid or b == nullid:
return nullid return nullid
revmap, parentfunc = self._buildrevgraph(a, b) revmap, parentfunc = self._buildrevgraph(a, b)
nodemap = dict(((v, k) for (k, v) in pycompat.iteritems(revmap))) nodemap = {v: k for (k, v) in pycompat.iteritems(revmap)}
ancs = ancestor.ancestors(parentfunc, revmap[a], revmap[b]) ancs = ancestor.ancestors(parentfunc, revmap[a], revmap[b])
if ancs: if ancs:
# choose a consistent winner when there's a tie # choose a consistent winner when there's a tie
return min(map(nodemap.__getitem__, ancs)) return min(map(nodemap.__getitem__, ancs))
return nullid return nullid
def commonancestorsheads(self, a, b): def commonancestorsheads(self, a, b):
"""calculate all the heads of the common ancestors of nodes a and b""" """calculate all the heads of the common ancestors of nodes a and b"""
if a == nullid or b == nullid: if a == nullid or b == nullid:
return nullid return nullid
revmap, parentfunc = self._buildrevgraph(a, b) revmap, parentfunc = self._buildrevgraph(a, b)
nodemap = dict(((v, k) for (k, v) in pycompat.iteritems(revmap))) nodemap = {v: k for (k, v) in pycompat.iteritems(revmap)}
ancs = ancestor.commonancestorsheads(parentfunc, revmap[a], revmap[b]) ancs = ancestor.commonancestorsheads(parentfunc, revmap[a], revmap[b])
return map(nodemap.__getitem__, ancs) return map(nodemap.__getitem__, ancs)
def _buildrevgraph(self, a, b): def _buildrevgraph(self, a, b):
"""Builds a numeric revision graph for the given two nodes. """Builds a numeric revision graph for the given two nodes.
Returns a node->rev map and a rev->[revs] parent function. Returns a node->rev map and a rev->[revs] parent function.
""" """

hgext/remotefilelog/repack.py

packfiles = _allpackfileswithsuffix( packfiles = _allpackfileswithsuffix(
files, historypack.PACKSUFFIX, historypack.INDEXSUFFIX files, historypack.PACKSUFFIX, historypack.INDEXSUFFIX
) )
return _computeincrementalpack(packfiles, opts) return _computeincrementalpack(packfiles, opts)
def _allpackfileswithsuffix(files, packsuffix, indexsuffix): def _allpackfileswithsuffix(files, packsuffix, indexsuffix):
result = [] result = []
fileset = set(fn for fn, mode, stat in files) fileset = {fn for fn, mode, stat in files}
for filename, mode, stat in files: for filename, mode, stat in files:
if not filename.endswith(packsuffix): if not filename.endswith(packsuffix):
continue continue
prefix = filename[: -len(packsuffix)] prefix = filename[: -len(packsuffix)]
# Don't process a pack if it doesn't have an index. # Don't process a pack if it doesn't have an index.
if (prefix + indexsuffix) not in fileset: if (prefix + indexsuffix) not in fileset:

hgext/schemes.py

except IndexError: except IndexError:
raise error.Abort(_(b"no '://' in scheme url '%s'") % url) raise error.Abort(_(b"no '://' in scheme url '%s'") % url)
parts = url.split(b'/', self.parts) parts = url.split(b'/', self.parts)
if len(parts) > self.parts: if len(parts) > self.parts:
tail = parts[-1] tail = parts[-1]
parts = parts[:-1] parts = parts[:-1]
else: else:
tail = b'' tail = b''
context = dict((b'%d' % (i + 1), v) for i, v in enumerate(parts)) context = {b'%d' % (i + 1): v for i, v in enumerate(parts)}
return b''.join(self.templater.process(self.url, context)) + tail return b''.join(self.templater.process(self.url, context)) + tail
def hasdriveletter(orig, path): def hasdriveletter(orig, path):
if path: if path:
for scheme in schemes: for scheme in schemes:
if path.startswith(scheme + b':'): if path.startswith(scheme + b':'):
return False return False

hgext/sparse.py

if not matcher.always(): if not matcher.always():
allfiles = [f for f in allfiles if matcher(f)] allfiles = [f for f in allfiles if matcher(f)]
if changedfiles: if changedfiles:
changedfiles = [f for f in changedfiles if matcher(f)] changedfiles = [f for f in changedfiles if matcher(f)]
if changedfiles is not None: if changedfiles is not None:
# In _rebuild, these files will be deleted from the dirstate # In _rebuild, these files will be deleted from the dirstate
# when they are not found to be in allfiles # when they are not found to be in allfiles
dirstatefilestoremove = set(f for f in self if not matcher(f)) dirstatefilestoremove = {f for f in self if not matcher(f)}
changedfiles = dirstatefilestoremove.union(changedfiles) changedfiles = dirstatefilestoremove.union(changedfiles)
return orig(self, parent, allfiles, changedfiles) return orig(self, parent, allfiles, changedfiles)
extensions.wrapfunction(dirstate.dirstate, b'rebuild', _rebuild) extensions.wrapfunction(dirstate.dirstate, b'rebuild', _rebuild)
# Prevent adding files that are outside the sparse checkout # Prevent adding files that are outside the sparse checkout
editfuncs = [ editfuncs = [

hgext/strip.py

# if one of the wdir parent is stripped we'll need # if one of the wdir parent is stripped we'll need
# to update away to an earlier revision # to update away to an earlier revision
update = any( update = any(
p != nullid and cl.rev(p) in strippedrevs p != nullid and cl.rev(p) in strippedrevs
for p in repo.dirstate.parents() for p in repo.dirstate.parents()
) )
rootnodes = set(cl.node(r) for r in roots) rootnodes = {cl.node(r) for r in roots}
q = getattr(repo, 'mq', None) q = getattr(repo, 'mq', None)
if q is not None and q.applied: if q is not None and q.applied:
# refresh queue state if we're about to strip # refresh queue state if we're about to strip
# applied patches # applied patches
if cl.rev(repo.lookup(b'qtip')) in strippedrevs: if cl.rev(repo.lookup(b'qtip')) in strippedrevs:
q.applieddirty = True q.applieddirty = True
start = 0 start = 0

hgext/transplant.py

try: try:
if opts.get(b'continue'): if opts.get(b'continue'):
tp.resume(repo, source, opts) tp.resume(repo, source, opts)
return return
tf = tp.transplantfilter(repo, source, p1) tf = tp.transplantfilter(repo, source, p1)
if opts.get(b'prune'): if opts.get(b'prune'):
prune = set( prune = {
source[r].node() source[r].node()
for r in scmutil.revrange(source, opts.get(b'prune')) for r in scmutil.revrange(source, opts.get(b'prune'))
) }
matchfn = lambda x: tf(x) and x not in prune matchfn = lambda x: tf(x) and x not in prune
else: else:
matchfn = tf matchfn = tf
merges = pycompat.maplist(source.lookup, opts.get(b'merge', ())) merges = pycompat.maplist(source.lookup, opts.get(b'merge', ()))
revmap = {} revmap = {}
if revs: if revs:
for r in scmutil.revrange(source, revs): for r in scmutil.revrange(source, revs):
revmap[int(r)] = source[r].node() revmap[int(r)] = source[r].node()

hgext/uncommit.py

repo, ctx, match, keepcommit, message=None, user=None, date=None repo, ctx, match, keepcommit, message=None, user=None, date=None
): ):
"""Recommit ctx with changed files not in match. Return the new """Recommit ctx with changed files not in match. Return the new
node identifier, or None if nothing changed. node identifier, or None if nothing changed.
""" """
base = ctx.p1() base = ctx.p1()
# ctx # ctx
initialfiles = set(ctx.files()) initialfiles = set(ctx.files())
exclude = set(f for f in initialfiles if match(f)) exclude = {f for f in initialfiles if match(f)}
# No files matched commit, so nothing excluded # No files matched commit, so nothing excluded
if not exclude: if not exclude:
return None return None
# return the p1 so that we don't create an obsmarker later # return the p1 so that we don't create an obsmarker later
if not keepcommit: if not keepcommit:
return ctx.p1().node() return ctx.p1().node()
files = initialfiles - exclude files = initialfiles - exclude
# Filter copies # Filter copies
copied = copiesmod.pathcopies(base, ctx) copied = copiesmod.pathcopies(base, ctx)
copied = dict( copied = {
(dst, src) for dst, src in pycompat.iteritems(copied) if dst in files dst: src for dst, src in pycompat.iteritems(copied) if dst in files
) }
def filectxfn(repo, memctx, path, contentctx=ctx, redirect=()): def filectxfn(repo, memctx, path, contentctx=ctx, redirect=()):
if path not in contentctx: if path not in contentctx:
return None return None
fctx = contentctx[path] fctx = contentctx[path]
mctx = context.memfilectx( mctx = context.memfilectx(
repo, repo,
memctx, memctx,

i18n/polib.py

* the fuzzy flags are preserved. * the fuzzy flags are preserved.
Keyword argument: Keyword argument:
``refpot`` ``refpot``
object POFile, the reference catalog. object POFile, the reference catalog.
""" """
# Store entries in dict/set for faster access # Store entries in dict/set for faster access
self_entries = dict((entry.msgid, entry) for entry in self) self_entries = {entry.msgid: entry for entry in self}
refpot_msgids = set(entry.msgid for entry in refpot) refpot_msgids = {entry.msgid for entry in refpot}
# Merge entries that are in the refpot # Merge entries that are in the refpot
for entry in refpot: for entry in refpot:
e = self_entries.get(entry.msgid) e = self_entries.get(entry.msgid)
if e is None: if e is None:
e = POEntry() e = POEntry()
self.append(e) self.append(e)
e.merge(entry) e.merge(entry)
# ok, now we must "obsolete" entries that are not in the refpot anymore # ok, now we must "obsolete" entries that are not in the refpot anymore
self.instance.metadata = metadata self.instance.metadata = metadata
continue continue
# test if we have a plural entry # test if we have a plural entry
msgid_tokens = msgid.split(b('\0')) msgid_tokens = msgid.split(b('\0'))
if len(msgid_tokens) > 1: if len(msgid_tokens) > 1:
entry = self._build_entry( entry = self._build_entry(
msgid=msgid_tokens[0], msgid=msgid_tokens[0],
msgid_plural=msgid_tokens[1], msgid_plural=msgid_tokens[1],
msgstr_plural=dict( msgstr_plural={
(k, v) for k, v in enumerate(msgstr.split(b('\0'))) k: v for k, v in enumerate(msgstr.split(b('\0')))
), },
) )
else: else:
entry = self._build_entry(msgid=msgid, msgstr=msgstr) entry = self._build_entry(msgid=msgid, msgstr=msgstr)
self.instance.append(entry) self.instance.append(entry)
# close opened file # close opened file
self.fhandle.close() self.fhandle.close()
return self.instance return self.instance

mercurial/ancestor.py

del interesting[sv] del interesting[sv]
if len(interesting) != 1: if len(interesting) != 1:
return [] return []
k = 0 k = 0
for i in interesting: for i in interesting:
k |= i k |= i
return set(n for (i, n) in mapping if k & i) return {n for (i, n) in mapping if k & i}
gca = commonancestorsheads(pfunc, *orignodes) gca = commonancestorsheads(pfunc, *orignodes)
if len(gca) <= 1: if len(gca) <= 1:
return gca return gca
return deepest(gca) return deepest(gca)

mercurial/branchmap.py

# branches # branches
ntiprev = self.tiprev ntiprev = self.tiprev
# if older branchheads are reachable from new ones, they aren't # if older branchheads are reachable from new ones, they aren't
# really branchheads. Note checking parents is insufficient: # really branchheads. Note checking parents is insufficient:
# 1 (branch a) -> 2 (branch b) -> 3 (branch a) # 1 (branch a) -> 2 (branch b) -> 3 (branch a)
for branch, newheadrevs in pycompat.iteritems(newbranches): for branch, newheadrevs in pycompat.iteritems(newbranches):
bheads = self._entries.setdefault(branch, []) bheads = self._entries.setdefault(branch, [])
bheadset = set(cl.rev(node) for node in bheads) bheadset = {cl.rev(node) for node in bheads}
# This have been tested True on all internal usage of this function. # This have been tested True on all internal usage of this function.
# run it again in case of doubt # run it again in case of doubt
# assert not (set(bheadrevs) & set(newheadrevs)) # assert not (set(bheadrevs) & set(newheadrevs))
bheadset.update(newheadrevs) bheadset.update(newheadrevs)
# This prunes out two kinds of heads - heads that are superseded by # This prunes out two kinds of heads - heads that are superseded by
# a head in newheadrevs, and newheadrevs that are not heads because # a head in newheadrevs, and newheadrevs that are not heads because
del self._names[:] del self._names[:]
self._rbcnamescount = 0 self._rbcnamescount = 0
self._rbcrevslen = len(self._repo.changelog) self._rbcrevslen = len(self._repo.changelog)
self._rbcrevs = bytearray(self._rbcrevslen * _rbcrecsize) self._rbcrevs = bytearray(self._rbcrevslen * _rbcrecsize)
util.clearcachedproperty(self, b'_namesreverse') util.clearcachedproperty(self, b'_namesreverse')
@util.propertycache @util.propertycache
def _namesreverse(self): def _namesreverse(self):
return dict((b, r) for r, b in enumerate(self._names)) return {b: r for r, b in enumerate(self._names)}
def branchinfo(self, rev): def branchinfo(self, rev):
"""Return branch name and close flag for rev, using and updating """Return branch name and close flag for rev, using and updating
persistent cache.""" persistent cache."""
changelog = self._repo.changelog changelog = self._repo.changelog
rbcrevidx = rev * _rbcrecsize rbcrevidx = rev * _rbcrecsize
# avoid negative index, changelog.read(nullrev) is fast without cache # avoid negative index, changelog.read(nullrev) is fast without cache

mercurial/changegroup.py

mfdicts = None mfdicts = None
if self._ellipses and self._isshallow: if self._ellipses and self._isshallow:
mfdicts = [ mfdicts = [
(self._repo.manifestlog[n].read(), lr) (self._repo.manifestlog[n].read(), lr)
for (n, lr) in pycompat.iteritems(manifests) for (n, lr) in pycompat.iteritems(manifests)
] ]
manifests.clear() manifests.clear()
clrevs = set(cl.rev(x) for x in clnodes) clrevs = {cl.rev(x) for x in clnodes}
it = self.generatefiles( it = self.generatefiles(
changedfiles, changedfiles,
commonrevs, commonrevs,
source, source,
mfdicts, mfdicts,
fastpathlinkrev, fastpathlinkrev,
fnodes, fnodes,
else: else:
cln = self._repo.changelog.node cln = self._repo.changelog.node
def normallinknodes(store, fname): def normallinknodes(store, fname):
flinkrev = store.linkrev flinkrev = store.linkrev
fnode = store.node fnode = store.node
revs = ((r, flinkrev(r)) for r in store) revs = ((r, flinkrev(r)) for r in store)
return dict( return {fnode(r): cln(lr) for r, lr in revs if lr in clrevs}
(fnode(r), cln(lr)) for r, lr in revs if lr in clrevs
)
clrevtolocalrev = {} clrevtolocalrev = {}
if self._isshallow: if self._isshallow:
# In a shallow clone, the linknodes callback needs to also include # In a shallow clone, the linknodes callback needs to also include
# those file nodes that are in the manifests we sent but weren't # those file nodes that are in the manifests we sent but weren't
# introduced by those manifests. # introduced by those manifests.
commonctxs = [self._repo[c] for c in commonrevs] commonctxs = [self._repo[c] for c in commonrevs]

mercurial/cmdutil.py

# amend should abort if commitsubrepos is enabled # amend should abort if commitsubrepos is enabled
assert not commitsubs assert not commitsubs
if subs: if subs:
subrepoutil.writestate(repo, newsubstate) subrepoutil.writestate(repo, newsubstate)
ms = mergemod.mergestate.read(repo) ms = mergemod.mergestate.read(repo)
mergeutil.checkunresolved(ms) mergeutil.checkunresolved(ms)
filestoamend = set(f for f in wctx.files() if matcher(f)) filestoamend = {f for f in wctx.files() if matcher(f)}
changes = len(filestoamend) > 0 changes = len(filestoamend) > 0
if changes: if changes:
# Recompute copies (avoid recording a -> b -> a) # Recompute copies (avoid recording a -> b -> a)
copied = copies.pathcopies(base, wctx, matcher) copied = copies.pathcopies(base, wctx, matcher)
if old.p2: if old.p2:
copied.update(copies.pathcopies(old.p2(), wctx, matcher)) copied.update(copies.pathcopies(old.p2(), wctx, matcher))
newlyaddedandmodifiedfiles, unusedalsorestore = newandmodified( newlyaddedandmodifiedfiles, unusedalsorestore = newandmodified(
chunks, originalchunks chunks, originalchunks
) )
if tobackup is None: if tobackup is None:
tobackup = set() tobackup = set()
# Apply changes # Apply changes
fp = stringio() fp = stringio()
# chunks are serialized per file, but files aren't sorted # chunks are serialized per file, but files aren't sorted
for f in sorted(set(c.header.filename() for c in chunks if ishunk(c))): for f in sorted({c.header.filename() for c in chunks if ishunk(c)}):
prntstatusmsg(b'revert', f) prntstatusmsg(b'revert', f)
files = set() files = set()
for c in chunks: for c in chunks:
if ishunk(c): if ishunk(c):
abs = c.header.filename() abs = c.header.filename()
# Create a backup file only if this hunk should be backed up # Create a backup file only if this hunk should be backed up
if c.header.filename() in tobackup: if c.header.filename() in tobackup:
target = repo.wjoin(abs) target = repo.wjoin(abs)

mercurial/commands.py

heads = [repo[h] for h in repo.heads(start)] heads = [repo[h] for h in repo.heads(start)]
else: else:
heads = [] heads = []
for branch in repo.branchmap(): for branch in repo.branchmap():
heads += repo.branchheads(branch, start, opts.get(b'closed')) heads += repo.branchheads(branch, start, opts.get(b'closed'))
heads = [repo[h] for h in heads] heads = [repo[h] for h in heads]
if branchrevs: if branchrevs:
branches = set( branches = {
repo[r].branch() for r in scmutil.revrange(repo, branchrevs) repo[r].branch() for r in scmutil.revrange(repo, branchrevs)
) }
heads = [h for h in heads if h.branch() in branches] heads = [h for h in heads if h.branch() in branches]
if opts.get(b'active') and branchrevs: if opts.get(b'active') and branchrevs:
dagheads = repo.heads(start) dagheads = repo.heads(start)
heads = [h for h in heads if h.node() in dagheads] heads = [h for h in heads if h.node() in dagheads]
if branchrevs: if branchrevs:
haveheads = set(h.branch() for h in heads) haveheads = {h.branch() for h in heads}
if branches - haveheads: if branches - haveheads:
headless = b', '.join(b for b in branches - haveheads) headless = b', '.join(b for b in branches - haveheads)
msg = _(b'no open branch heads found on branches %s') msg = _(b'no open branch heads found on branches %s')
if opts.get(b'rev'): if opts.get(b'rev'):
msg += _(b' (started at %s)') % opts[b'rev'] msg += _(b' (started at %s)') % opts[b'rev']
ui.warn((msg + b'\n') % headless) ui.warn((msg + b'\n') % headless)
if not heads: if not heads:

mercurial/debugcommands.py

revision numbers, they get labeled in the output as rN. revision numbers, they get labeled in the output as rN.
Otherwise, the changelog DAG of the current repo is emitted. Otherwise, the changelog DAG of the current repo is emitted.
""" """
spaces = opts.get('spaces') spaces = opts.get('spaces')
dots = opts.get('dots') dots = opts.get('dots')
if file_: if file_:
rlog = revlog.revlog(vfsmod.vfs(encoding.getcwd(), audit=False), file_) rlog = revlog.revlog(vfsmod.vfs(encoding.getcwd(), audit=False), file_)
revs = set((int(r) for r in revs)) revs = {int(r) for r in revs}
def events(): def events():
for r in rlog: for r in rlog:
yield b'n', (r, list(p for p in rlog.parentrevs(r) if p != -1)) yield b'n', (r, list(p for p in rlog.parentrevs(r) if p != -1))
if r in revs: if r in revs:
yield b'l', (r, b"r%i" % r) yield b'l', (r, b"r%i" % r)
elif repo: elif repo:
opts = pycompat.byteskwargs(opts) opts = pycompat.byteskwargs(opts)
ctx = scmutil.revsingle(repo, opts.get(b'rev'), None) ctx = scmutil.revsingle(repo, opts.get(b'rev'), None)
stages = [ stages = [
(b'parsed', pycompat.identity), (b'parsed', pycompat.identity),
(b'analyzed', filesetlang.analyze), (b'analyzed', filesetlang.analyze),
(b'optimized', filesetlang.optimize), (b'optimized', filesetlang.optimize),
] ]
stagenames = set(n for n, f in stages) stagenames = {n for n, f in stages}
showalways = set() showalways = set()
if ui.verbose and not opts[b'show_stage']: if ui.verbose and not opts[b'show_stage']:
# show parsed tree by --verbose (deprecated) # show parsed tree by --verbose (deprecated)
showalways.add(b'parsed') showalways.add(b'parsed')
if opts[b'show_stage'] == [b'all']: if opts[b'show_stage'] == [b'all']:
showalways.update(stagenames) showalways.update(stagenames)
else: else:
dirstate = repo.dirstate dirstate = repo.dirstate
changedfiles = None changedfiles = None
# See command doc for what minimal does. # See command doc for what minimal does.
if opts.get('minimal'): if opts.get('minimal'):
manifestfiles = set(ctx.manifest().keys()) manifestfiles = set(ctx.manifest().keys())
dirstatefiles = set(dirstate) dirstatefiles = set(dirstate)
manifestonly = manifestfiles - dirstatefiles manifestonly = manifestfiles - dirstatefiles
dsonly = dirstatefiles - manifestfiles dsonly = dirstatefiles - manifestfiles
dsnotadded = set(f for f in dsonly if dirstate[f] != b'a') dsnotadded = {f for f in dsonly if dirstate[f] != b'a'}
changedfiles = manifestonly | dsnotadded changedfiles = manifestonly | dsnotadded
dirstate.rebuild(ctx.node(), ctx.manifest(), changedfiles) dirstate.rebuild(ctx.node(), ctx.manifest(), changedfiles)
@command(b'debugrebuildfncache', [], b'') @command(b'debugrebuildfncache', [], b'')
def debugrebuildfncache(ui, repo): def debugrebuildfncache(ui, repo):
"""rebuild the fncache file""" """rebuild the fncache file"""
(b'optimized', revsetlang.optimize), (b'optimized', revsetlang.optimize),
] ]
if opts[b'no_optimized']: if opts[b'no_optimized']:
stages = stages[:-1] stages = stages[:-1]
if opts[b'verify_optimized'] and opts[b'no_optimized']: if opts[b'verify_optimized'] and opts[b'no_optimized']:
raise error.Abort( raise error.Abort(
_(b'cannot use --verify-optimized with --no-optimized') _(b'cannot use --verify-optimized with --no-optimized')
) )
stagenames = set(n for n, f in stages) stagenames = {n for n, f in stages}
showalways = set() showalways = set()
showchanged = set() showchanged = set()
if ui.verbose and not opts[b'show_stage']: if ui.verbose and not opts[b'show_stage']:
# show parsed tree by --verbose (deprecated) # show parsed tree by --verbose (deprecated)
showalways.add(b'parsed') showalways.add(b'parsed')
showchanged.update([b'expanded', b'concatenated']) showchanged.update([b'expanded', b'concatenated'])
if opts[b'optimize']: if opts[b'optimize']:

mercurial/discovery.py

missingheads = phases.newheads(repo, onlyheads, excluded) missingheads = phases.newheads(repo, onlyheads, excluded)
og.missingheads = missingheads og.missingheads = missingheads
if portable: if portable:
# recompute common and missingheads as if -r<rev> had been given for # recompute common and missingheads as if -r<rev> had been given for
# each head of missing, and --base <rev> for each head of the proper # each head of missing, and --base <rev> for each head of the proper
# ancestors of missing # ancestors of missing
og._computecommonmissing() og._computecommonmissing()
cl = repo.changelog cl = repo.changelog
missingrevs = set(cl.rev(n) for n in og._missing) missingrevs = {cl.rev(n) for n in og._missing}
og._common = set(cl.ancestors(missingrevs)) - missingrevs og._common = set(cl.ancestors(missingrevs)) - missingrevs
commonheads = set(og.commonheads) commonheads = set(og.commonheads)
og.missingheads = [h for h in og.missingheads if h not in commonheads] og.missingheads = [h for h in og.missingheads if h not in commonheads]
return og return og
def _headssummary(pushop): def _headssummary(pushop):
for l in items: for l in items:
if l is not None: if l is not None:
l.sort() l.sort()
headssum[branch] = items + ([],) headssum[branch] = items + ([],)
# If there are no obsstore, no post processing are needed. # If there are no obsstore, no post processing are needed.
if repo.obsstore: if repo.obsstore:
torev = repo.changelog.rev torev = repo.changelog.rev
futureheads = set(torev(h) for h in outgoing.missingheads) futureheads = {torev(h) for h in outgoing.missingheads}
futureheads |= set(torev(h) for h in outgoing.commonheads) futureheads |= {torev(h) for h in outgoing.commonheads}
allfuturecommon = repo.changelog.ancestors(futureheads, inclusive=True) allfuturecommon = repo.changelog.ancestors(futureheads, inclusive=True)
for branch, heads in sorted(pycompat.iteritems(headssum)): for branch, heads in sorted(pycompat.iteritems(headssum)):
remoteheads, newheads, unsyncedheads, placeholder = heads remoteheads, newheads, unsyncedheads, placeholder = heads
result = _postprocessobsolete(pushop, allfuturecommon, newheads) result = _postprocessobsolete(pushop, allfuturecommon, newheads)
headssum[branch] = ( headssum[branch] = (
remoteheads, remoteheads,
sorted(result[0]), sorted(result[0]),
unsyncedheads, unsyncedheads,

mercurial/dispatch.py

def aliasinterpolate(name, args, cmd): def aliasinterpolate(name, args, cmd):
'''interpolate args into cmd for shell aliases '''interpolate args into cmd for shell aliases
This also handles $0, $@ and "$@". This also handles $0, $@ and "$@".
''' '''
# util.interpolate can't deal with "$@" (with quotes) because it's only # util.interpolate can't deal with "$@" (with quotes) because it's only
# built to match prefix + patterns. # built to match prefix + patterns.
replacemap = dict((b'$%d' % (i + 1), arg) for i, arg in enumerate(args)) replacemap = {b'$%d' % (i + 1): arg for i, arg in enumerate(args)}
replacemap[b'$0'] = name replacemap[b'$0'] = name
replacemap[b'$$'] = b'$' replacemap[b'$$'] = b'$'
replacemap[b'$@'] = b' '.join(args) replacemap[b'$@'] = b' '.join(args)
# Typical Unix shells interpolate "$@" (with quotes) as all the positional # Typical Unix shells interpolate "$@" (with quotes) as all the positional
# parameters, separated out into words. Emulate the same behavior here by # parameters, separated out into words. Emulate the same behavior here by
# quoting the arguments individually. POSIX shells will then typically # quoting the arguments individually. POSIX shells will then typically
# tokenize each argument into exactly one word. # tokenize each argument into exactly one word.
replacemap[b'"$@"'] = b' '.join(procutil.shellquote(arg) for arg in args) replacemap[b'"$@"'] = b' '.join(procutil.shellquote(arg) for arg in args)

mercurial/encoding.py

_nativeenviron = not pycompat.ispy3 or os.supports_bytes_environ _nativeenviron = not pycompat.ispy3 or os.supports_bytes_environ
if not pycompat.ispy3: if not pycompat.ispy3:
environ = os.environ # re-exports environ = os.environ # re-exports
elif _nativeenviron: elif _nativeenviron:
environ = os.environb # re-exports environ = os.environb # re-exports
else: else:
# preferred encoding isn't known yet; use utf-8 to avoid unicode error # preferred encoding isn't known yet; use utf-8 to avoid unicode error
# and recreate it once encoding is settled # and recreate it once encoding is settled
environ = dict( environ = {
(k.encode('utf-8'), v.encode('utf-8')) k.encode('utf-8'): v.encode('utf-8')
for k, v in os.environ.items() # re-exports for k, v in os.environ.items() # re-exports
) }
_encodingrewrites = { _encodingrewrites = {
b'646': b'ascii', b'646': b'ascii',
b'ANSI_X3.4-1968': b'ascii', b'ANSI_X3.4-1968': b'ascii',
} }
# cp65001 is a Windows variant of utf-8, which isn't supported on Python 2. # cp65001 is a Windows variant of utf-8, which isn't supported on Python 2.
# No idea if it should be rewritten to the canonical name 'utf-8' on Python 3. # No idea if it should be rewritten to the canonical name 'utf-8' on Python 3.
# https://bugs.python.org/issue13216 # https://bugs.python.org/issue13216
# type: (bytes) -> str # type: (bytes) -> str
return s # pytype: disable=bad-return-type return s # pytype: disable=bad-return-type
strmethod = pycompat.identity strmethod = pycompat.identity
if not _nativeenviron: if not _nativeenviron:
# now encoding and helper functions are available, recreate the environ # now encoding and helper functions are available, recreate the environ
# dict to be exported to other modules # dict to be exported to other modules
environ = dict( environ = {
(tolocal(k.encode('utf-8')), tolocal(v.encode('utf-8'))) tolocal(k.encode('utf-8')): tolocal(v.encode('utf-8'))
for k, v in os.environ.items() # re-exports for k, v in os.environ.items() # re-exports
) }
if pycompat.ispy3: if pycompat.ispy3:
# os.getcwd() on Python 3 returns string, but it has os.getcwdb() which # os.getcwd() on Python 3 returns string, but it has os.getcwdb() which
# returns bytes. # returns bytes.
if pycompat.iswindows: if pycompat.iswindows:
# Python 3 on Windows issues a DeprecationWarning about using the bytes # Python 3 on Windows issues a DeprecationWarning about using the bytes
# API when os.getcwdb() is called. # API when os.getcwdb() is called.
getcwd = lambda: strtolocal(os.getcwd()) # re-exports getcwd = lambda: strtolocal(os.getcwd()) # re-exports

mercurial/exchange.py

# The head check must use the unfiltered view as obsoletion # The head check must use the unfiltered view as obsoletion
# markers can hide heads. # markers can hide heads.
unfi = repo.unfiltered() unfi = repo.unfiltered()
unficl = unfi.changelog unficl = unfi.changelog
def headsofdiff(h1, h2): def headsofdiff(h1, h2):
"""Returns heads(h1 % h2)""" """Returns heads(h1 % h2)"""
res = unfi.set(b'heads(%ln %% %ln)', h1, h2) res = unfi.set(b'heads(%ln %% %ln)', h1, h2)
return set(ctx.node() for ctx in res) return {ctx.node() for ctx in res}
def headsofunion(h1, h2): def headsofunion(h1, h2):
"""Returns heads((h1 + h2) - null)""" """Returns heads((h1 + h2) - null)"""
res = unfi.set(b'heads((%ln + %ln - null))', h1, h2) res = unfi.set(b'heads((%ln + %ln - null))', h1, h2)
return set(ctx.node() for ctx in res) return {ctx.node() for ctx in res}
while True: while True:
old_heads = unficl.heads() old_heads = unficl.heads()
clstart = len(unficl) clstart = len(unficl)
_pullbundle2(pullop) _pullbundle2(pullop)
if repository.NARROW_REQUIREMENT in repo.requirements: if repository.NARROW_REQUIREMENT in repo.requirements:
# XXX narrow clones filter the heads on the server side during # XXX narrow clones filter the heads on the server side during
# XXX getbundle and result in partial replies as well. # XXX getbundle and result in partial replies as well.

mercurial/extensions.py

return _(b'(no help text available)') return _(b'(no help text available)')
def disabled(): def disabled():
'''find disabled extensions from hgext. returns a dict of {name: desc}''' '''find disabled extensions from hgext. returns a dict of {name: desc}'''
try: try:
from hgext import __index__ # pytype: disable=import-error from hgext import __index__ # pytype: disable=import-error
return dict( return {
(name, gettext(desc)) name: gettext(desc)
for name, desc in pycompat.iteritems(__index__.docs) for name, desc in pycompat.iteritems(__index__.docs)
if name not in _order if name not in _order
) }
except (ImportError, AttributeError): except (ImportError, AttributeError):
pass pass
paths = _disabledpaths() paths = _disabledpaths()
if not paths: if not paths:
return {} return {}
exts = {} exts = {}

mercurial/fancyopts.py

""" """
if optaliases is None: if optaliases is None:
optaliases = {} optaliases = {}
namelist = [] namelist = []
shortlist = b'' shortlist = b''
argmap = {} argmap = {}
defmap = {} defmap = {}
negations = {} negations = {}
alllong = set(o[1] for o in options) alllong = {o[1] for o in options}
for option in options: for option in options:
if len(option) == 5: if len(option) == 5:
short, name, default, comment, dummy = option short, name, default, comment, dummy = option
else: else:
short, name, default, comment = option short, name, default, comment = option
# convert opts to getopt format # convert opts to getopt format
onames = [name] onames = [name]

mercurial/graphmod.py

""" """
gpcache = {} gpcache = {}
for rev in revs: for rev in revs:
ctx = repo[rev] ctx = repo[rev]
# partition into parents in the rev set and missing parents, then # partition into parents in the rev set and missing parents, then
# augment the lists with markers, to inform graph drawing code about # augment the lists with markers, to inform graph drawing code about
# what kind of edge to draw between nodes. # what kind of edge to draw between nodes.
pset = set(p.rev() for p in ctx.parents() if p.rev() in revs) pset = {p.rev() for p in ctx.parents() if p.rev() in revs}
mpars = [ mpars = [
p.rev() p.rev()
for p in ctx.parents() for p in ctx.parents()
if p.rev() != nullrev and p.rev() not in pset if p.rev() != nullrev and p.rev() not in pset
] ]
parents = [(PARENT, p) for p in sorted(pset)] parents = [(PARENT, p) for p in sorted(pset)]
for mpar in mpars: for mpar in mpars:
"""cset DAG generator yielding (id, CHANGESET, ctx, [parentids]) tuples """cset DAG generator yielding (id, CHANGESET, ctx, [parentids]) tuples
This generator function walks the given nodes. It only returns parents This generator function walks the given nodes. It only returns parents
that are in nodes, too. that are in nodes, too.
""" """
include = set(nodes) include = set(nodes)
for node in nodes: for node in nodes:
ctx = repo[node] ctx = repo[node]
parents = set( parents = {
(PARENT, p.rev()) for p in ctx.parents() if p.node() in include (PARENT, p.rev()) for p in ctx.parents() if p.node() in include
) }
yield (ctx.rev(), CHANGESET, ctx, sorted(parents)) yield (ctx.rev(), CHANGESET, ctx, sorted(parents))
def colored(dag, repo): def colored(dag, repo):
"""annotates a DAG with colored edge information """annotates a DAG with colored edge information
For each DAG node this function emits tuples:: For each DAG node this function emits tuples::

mercurial/hbisect.py

# bisect is incomplete when it ends on a merge node and # bisect is incomplete when it ends on a merge node and
# one of the parent was not checked. # one of the parent was not checked.
parents = repo[nodes[0]].parents() parents = repo[nodes[0]].parents()
if len(parents) > 1: if len(parents) > 1:
if good: if good:
side = state[b'bad'] side = state[b'bad']
else: else:
side = state[b'good'] side = state[b'good']
num = len(set(i.node() for i in parents) & set(side)) num = len({i.node() for i in parents} & set(side))
if num == 1: if num == 1:
return parents[0].ancestor(parents[1]) return parents[0].ancestor(parents[1])
return None return None
def load_state(repo): def load_state(repo):
state = {b'current': [], b'good': [], b'bad': [], b'skip': []} state = {b'current': [], b'good': [], b'bad': [], b'skip': []}
for l in repo.vfs.tryreadlines(b"bisect.state"): for l in repo.vfs.tryreadlines(b"bisect.state"):

mercurial/localrepo.py

# mq and bookmarks add tags, but do not set the tagtype at all. # mq and bookmarks add tags, but do not set the tagtype at all.
# Should each extension invent its own tag type? Should there # Should each extension invent its own tag type? Should there
# be one tagtype for all such "virtual" tags? Or is the status # be one tagtype for all such "virtual" tags? Or is the status
# quo fine? # quo fine?
# map tag name to (node, hist) # map tag name to (node, hist)
alltags = tagsmod.findglobaltags(self.ui, self) alltags = tagsmod.findglobaltags(self.ui, self)
# map tag name to tag type # map tag name to tag type
tagtypes = dict((tag, b'global') for tag in alltags) tagtypes = {tag: b'global' for tag in alltags}
tagsmod.readlocaltags(self.ui, self, alltags, tagtypes) tagsmod.readlocaltags(self.ui, self, alltags, tagtypes)
# Build the return dicts. Have to re-encode tag names because # Build the return dicts. Have to re-encode tag names because
# the tags module always uses UTF-8 (in order not to lose info # the tags module always uses UTF-8 (in order not to lose info
# writing to the cache), but the rest of Mercurial wants them in # writing to the cache), but the rest of Mercurial wants them in
# local encoding. # local encoding.
tags = {} tags = {}
for (name, (node, hist)) in pycompat.iteritems(alltags): for (name, (node, hist)) in pycompat.iteritems(alltags):
if node != nullid: if node != nullid:
tags[encoding.tolocal(name)] = node tags[encoding.tolocal(name)] = node
tags[b'tip'] = self.changelog.tip() tags[b'tip'] = self.changelog.tip()
tagtypes = dict( tagtypes = {
[ encoding.tolocal(name): value
(encoding.tolocal(name), value)
for (name, value) in pycompat.iteritems(tagtypes) for (name, value) in pycompat.iteritems(tagtypes)
] }
)
return (tags, tagtypes) return (tags, tagtypes)
def tagtype(self, tagname): def tagtype(self, tagname):
''' '''
return the type of the given tag. result can be: return the type of the given tag. result can be:
'local' : a local tag 'local' : a local tag
'global' : a global tag 'global' : a global tag

mercurial/match.py

def visitchildrenset(self, dir): def visitchildrenset(self, dir):
if not self._fileset or dir not in self._dirs: if not self._fileset or dir not in self._dirs:
return set() return set()
candidates = self._fileset | self._dirs - {b''} candidates = self._fileset | self._dirs - {b''}
if dir != b'': if dir != b'':
d = dir + b'/' d = dir + b'/'
candidates = set(c[len(d) :] for c in candidates if c.startswith(d)) candidates = {c[len(d) :] for c in candidates if c.startswith(d)}
# self._dirs includes all of the directories, recursively, so if # self._dirs includes all of the directories, recursively, so if
# we're attempting to match foo/bar/baz.txt, it'll have '', 'foo', # we're attempting to match foo/bar/baz.txt, it'll have '', 'foo',
# 'foo/bar' in it. Thus we can safely ignore a candidate that has a # 'foo/bar' in it. Thus we can safely ignore a candidate that has a
# '/' in it, indicating a it's for a subdir-of-a-subdir; the # '/' in it, indicating a it's for a subdir-of-a-subdir; the
# immediate subdir will be in there without a slash. # immediate subdir will be in there without a slash.
ret = {c for c in candidates if b'/' not in c} ret = {c for c in candidates if b'/' not in c}
# We really do not expect ret to be empty, since that would imply that # We really do not expect ret to be empty, since that would imply that
# there's something in _dirs that didn't have a file in _fileset. # there's something in _dirs that didn't have a file in _fileset.

mercurial/mdiff.py

self.context = int(self.context) self.context = int(self.context)
except ValueError: except ValueError:
raise error.Abort( raise error.Abort(
_(b'diff context lines count must be an integer, not %r') _(b'diff context lines count must be an integer, not %r')
% pycompat.bytestr(self.context) % pycompat.bytestr(self.context)
) )
def copy(self, **kwargs): def copy(self, **kwargs):
opts = dict((k, getattr(self, k)) for k in self.defaults) opts = {k: getattr(self, k) for k in self.defaults}
opts = pycompat.strkwargs(opts) opts = pycompat.strkwargs(opts)
opts.update(kwargs) opts.update(kwargs)
return diffopts(**opts) return diffopts(**opts)
defaultopts = diffopts() defaultopts = diffopts()

mercurial/merge.py

or self.mergedcount or self.mergedcount
or self.removedcount or self.removedcount
or self.unresolvedcount or self.unresolvedcount
) )
def emptyactions(): def emptyactions():
"""create an actions dict, to be populated and passed to applyupdates()""" """create an actions dict, to be populated and passed to applyupdates()"""
return dict( return {
(m, []) m: []
for m in ( for m in (
ACTION_ADD, ACTION_ADD,
ACTION_ADD_MODIFIED, ACTION_ADD_MODIFIED,
ACTION_FORGET, ACTION_FORGET,
ACTION_GET, ACTION_GET,
ACTION_CHANGED_DELETED, ACTION_CHANGED_DELETED,
ACTION_DELETED_CHANGED, ACTION_DELETED_CHANGED,
ACTION_REMOVE, ACTION_REMOVE,
ACTION_DIR_RENAME_MOVE_LOCAL, ACTION_DIR_RENAME_MOVE_LOCAL,
ACTION_LOCAL_DIR_RENAME_GET, ACTION_LOCAL_DIR_RENAME_GET,
ACTION_MERGE, ACTION_MERGE,
ACTION_EXEC, ACTION_EXEC,
ACTION_KEEP, ACTION_KEEP,
ACTION_PATH_CONFLICT, ACTION_PATH_CONFLICT,
ACTION_PATH_CONFLICT_RESOLVE, ACTION_PATH_CONFLICT_RESOLVE,
) )
) }
def applyupdates( def applyupdates(
repo, actions, wctx, mctx, overwrite, wantfiledata, labels=None repo, actions, wctx, mctx, overwrite, wantfiledata, labels=None
): ):
"""apply the merge action list to the working directory """apply the merge action list to the working directory
wctx is the working copy context wctx is the working copy context
msupdated, msmerged, msremoved = ms.counts() msupdated, msmerged, msremoved = ms.counts()
updated += msupdated updated += msupdated
merged += msmerged merged += msmerged
removed += msremoved removed += msremoved
extraactions = ms.actions() extraactions = ms.actions()
if extraactions: if extraactions:
mfiles = set(a[0] for a in actions[ACTION_MERGE]) mfiles = {a[0] for a in actions[ACTION_MERGE]}
for k, acts in pycompat.iteritems(extraactions): for k, acts in pycompat.iteritems(extraactions):
actions[k].extend(acts) actions[k].extend(acts)
if k == ACTION_GET and wantfiledata: if k == ACTION_GET and wantfiledata:
# no filedata until mergestate is updated to provide it # no filedata until mergestate is updated to provide it
for a in acts: for a in acts:
getfiledata[a[0]] = None getfiledata[a[0]] = None
# Remove these files from actions[ACTION_MERGE] as well. This is # Remove these files from actions[ACTION_MERGE] as well. This is
# important because in recordupdates, files in actions[ACTION_MERGE] # important because in recordupdates, files in actions[ACTION_MERGE]

mercurial/obsolete.py

@cachefor(b'obsolete') @cachefor(b'obsolete')
def _computeobsoleteset(repo): def _computeobsoleteset(repo):
"""the set of obsolete revisions""" """the set of obsolete revisions"""
getnode = repo.changelog.node getnode = repo.changelog.node
notpublic = _mutablerevs(repo) notpublic = _mutablerevs(repo)
isobs = repo.obsstore.successors.__contains__ isobs = repo.obsstore.successors.__contains__
obs = set(r for r in notpublic if isobs(getnode(r))) obs = {r for r in notpublic if isobs(getnode(r))}
return obs return obs
@cachefor(b'orphan') @cachefor(b'orphan')
def _computeorphanset(repo): def _computeorphanset(repo):
"""the set of non obsolete revisions with obsolete parents""" """the set of non obsolete revisions with obsolete parents"""
pfunc = repo.changelog.parentrevs pfunc = repo.changelog.parentrevs
mutable = _mutablerevs(repo) mutable = _mutablerevs(repo)
break break
return unstable return unstable
@cachefor(b'suspended') @cachefor(b'suspended')
def _computesuspendedset(repo): def _computesuspendedset(repo):
"""the set of obsolete parents with non obsolete descendants""" """the set of obsolete parents with non obsolete descendants"""
suspended = repo.changelog.ancestors(getrevs(repo, b'orphan')) suspended = repo.changelog.ancestors(getrevs(repo, b'orphan'))
return set(r for r in getrevs(repo, b'obsolete') if r in suspended) return {r for r in getrevs(repo, b'obsolete') if r in suspended}
@cachefor(b'extinct') @cachefor(b'extinct')
def _computeextinctset(repo): def _computeextinctset(repo):
"""the set of obsolete parents without non obsolete descendants""" """the set of obsolete parents without non obsolete descendants"""
return getrevs(repo, b'obsolete') - getrevs(repo, b'suspended') return getrevs(repo, b'obsolete') - getrevs(repo, b'suspended')

mercurial/obsutil.py

for suc in mark[1]: for suc in mark[1]:
if suc not in seen: if suc not in seen:
seen.add(suc) seen.add(suc)
remaining.add(suc) remaining.add(suc)
def _filterprunes(markers): def _filterprunes(markers):
"""return a set with no prune markers""" """return a set with no prune markers"""
return set(m for m in markers if m[1]) return {m for m in markers if m[1]}
def exclusivemarkers(repo, nodes): def exclusivemarkers(repo, nodes):
"""set of markers relevant to "nodes" but no other locally-known nodes """set of markers relevant to "nodes" but no other locally-known nodes
This function compute the set of markers "exclusive" to a locally-known This function compute the set of markers "exclusive" to a locally-known
node. This means we walk the markers starting from <nodes> until we reach a node. This means we walk the markers starting from <nodes> until we reach a
locally-known precursors outside of <nodes>. Element of <nodes> with locally-known precursors outside of <nodes>. Element of <nodes> with
if repo.obsstore: if repo.obsstore:
# We only need this complicated logic if there is obsolescence # We only need this complicated logic if there is obsolescence
# XXX will probably deserve an optimised revset. # XXX will probably deserve an optimised revset.
has_node = repo.changelog.index.has_node has_node = repo.changelog.index.has_node
plen = -1 plen = -1
# compute the whole set of successors or descendants # compute the whole set of successors or descendants
while len(foreground) != plen: while len(foreground) != plen:
plen = len(foreground) plen = len(foreground)
succs = set(c.node() for c in foreground) succs = {c.node() for c in foreground}
mutable = [c.node() for c in foreground if c.mutable()] mutable = [c.node() for c in foreground if c.mutable()]
succs.update(allsuccessors(repo.obsstore, mutable)) succs.update(allsuccessors(repo.obsstore, mutable))
known = (n for n in succs if has_node(n)) known = (n for n in succs if has_node(n))
foreground = set(repo.set(b'%ln::', known)) foreground = set(repo.set(b'%ln::', known))
return set(c.node() for c in foreground) return {c.node() for c in foreground}
# effectflag field # effectflag field
# #
# Effect-flag is a 1-byte bit field used to store what changed between a # Effect-flag is a 1-byte bit field used to store what changed between a
# changeset and its successor(s). # changeset and its successor(s).
# #
# The effect flag is stored in obs-markers metadata while we iterate on the # The effect flag is stored in obs-markers metadata while we iterate on the
""" """
return [m[4] for m in markers] return [m[4] for m in markers]
def markersusers(markers): def markersusers(markers):
""" Returns a sorted list of markers users without duplicates """ Returns a sorted list of markers users without duplicates
""" """
markersmeta = [dict(m[3]) for m in markers] markersmeta = [dict(m[3]) for m in markers]
users = set( users = {
encoding.tolocal(meta[b'user']) encoding.tolocal(meta[b'user'])
for meta in markersmeta for meta in markersmeta
if meta.get(b'user') if meta.get(b'user')
) }
return sorted(users) return sorted(users)
def markersoperations(markers): def markersoperations(markers):
""" Returns a sorted list of markers operations without duplicates """ Returns a sorted list of markers operations without duplicates
""" """
markersmeta = [dict(m[3]) for m in markers] markersmeta = [dict(m[3]) for m in markers]
operations = set( operations = {
meta.get(b'operation') for meta in markersmeta if meta.get(b'operation') meta.get(b'operation') for meta in markersmeta if meta.get(b'operation')
) }
return sorted(operations) return sorted(operations)
def obsfateprinter(ui, repo, successors, markers, formatctx): def obsfateprinter(ui, repo, successors, markers, formatctx):
""" Build a obsfate string for a single successorset using all obsfate """ Build a obsfate string for a single successorset using all obsfate
related function defined in obsutil related function defined in obsutil
""" """

mercurial/patch.py

def _filepairs(modified, added, removed, copy, opts): def _filepairs(modified, added, removed, copy, opts):
'''generates tuples (f1, f2, copyop), where f1 is the name of the file '''generates tuples (f1, f2, copyop), where f1 is the name of the file
before and f2 is the the name after. For added files, f1 will be None, before and f2 is the the name after. For added files, f1 will be None,
and for removed files, f2 will be None. copyop may be set to None, 'copy' and for removed files, f2 will be None. copyop may be set to None, 'copy'
or 'rename' (the latter two only if opts.git is set).''' or 'rename' (the latter two only if opts.git is set).'''
gone = set() gone = set()
copyto = dict([(v, k) for k, v in copy.items()]) copyto = {v: k for k, v in copy.items()}
addedset, removedset = set(added), set(removed) addedset, removedset = set(added), set(removed)
for f in sorted(modified + added + removed): for f in sorted(modified + added + removed):
copyop = None copyop = None
f1, f2 = f, f f1, f2 = f, f
if f in addedset: if f in addedset:
f1 = None f1 = None

mercurial/phases.py

changes.update(affected) changes.update(affected)
if dryrun: if dryrun:
continue continue
for r in affected: for r in affected:
_trackphasechange( _trackphasechange(
phasetracking, r, self.phase(repo, r), targetphase phasetracking, r, self.phase(repo, r), targetphase
) )
roots = set( roots = {
ctx.node() ctx.node()
for ctx in repo.set(b'roots((%ln::) - %ld)', olds, affected) for ctx in repo.set(b'roots((%ln::) - %ld)', olds, affected)
) }
if olds != roots: if olds != roots:
self._updateroots(phase, roots, tr) self._updateroots(phase, roots, tr)
# some roots may need to be declared for lower phases # some roots may need to be declared for lower phases
delroots.extend(olds - roots) delroots.extend(olds - roots)
if not dryrun: if not dryrun:
# declare deleted root in the target phase # declare deleted root in the target phase
if targetphase != 0: if targetphase != 0:
self._retractboundary(repo, tr, targetphase, delroots) self._retractboundary(repo, tr, targetphase, delroots)
# Only compute new roots for revs above the roots that are being # Only compute new roots for revs above the roots that are being
# retracted. # retracted.
minnewroot = min(repo[n].rev() for n in newroots) minnewroot = min(repo[n].rev() for n in newroots)
aboveroots = [ aboveroots = [
n for n in currentroots if repo[n].rev() >= minnewroot n for n in currentroots if repo[n].rev() >= minnewroot
] ]
updatedroots = repo.set(b'roots(%ln::)', aboveroots) updatedroots = repo.set(b'roots(%ln::)', aboveroots)
finalroots = set( finalroots = {n for n in currentroots if repo[n].rev() < minnewroot}
n for n in currentroots if repo[n].rev() < minnewroot
)
finalroots.update(ctx.node() for ctx in updatedroots) finalroots.update(ctx.node() for ctx in updatedroots)
if finalroots != oldroots: if finalroots != oldroots:
self._updateroots(targetphase, finalroots, tr) self._updateroots(targetphase, finalroots, tr)
return True return True
return False return False
def filterunknown(self, repo): def filterunknown(self, repo):
"""remove unknown nodes from the phase boundary """remove unknown nodes from the phase boundary
repo = repo.unfiltered() repo = repo.unfiltered()
cl = repo.changelog cl = repo.changelog
rev = cl.index.get_rev rev = cl.index.get_rev
if not roots: if not roots:
return heads return heads
if not heads or heads == [nullid]: if not heads or heads == [nullid]:
return [] return []
# The logic operated on revisions, convert arguments early for convenience # The logic operated on revisions, convert arguments early for convenience
new_heads = set(rev(n) for n in heads if n != nullid) new_heads = {rev(n) for n in heads if n != nullid}
roots = [rev(n) for n in roots] roots = [rev(n) for n in roots]
# compute the area we need to remove # compute the area we need to remove
affected_zone = repo.revs(b"(%ld::%ld)", roots, new_heads) affected_zone = repo.revs(b"(%ld::%ld)", roots, new_heads)
# heads in the area are no longer heads # heads in the area are no longer heads
new_heads.difference_update(affected_zone) new_heads.difference_update(affected_zone)
# revisions in the area have children outside of it, # revisions in the area have children outside of it,
# They might be new heads # They might be new heads
candidates = repo.revs( candidates = repo.revs(

mercurial/pycompat.py

return opts, args return opts, args
def strkwargs(dic): def strkwargs(dic):
""" """
Converts the keys of a python dictonary to str i.e. unicodes so that Converts the keys of a python dictonary to str i.e. unicodes so that
they can be passed as keyword arguments as dictonaries with bytes keys they can be passed as keyword arguments as dictonaries with bytes keys
can't be passed as keyword arguments to functions on Python 3. can't be passed as keyword arguments to functions on Python 3.
""" """
dic = dict((k.decode('latin-1'), v) for k, v in dic.items()) dic = {k.decode('latin-1'): v for k, v in dic.items()}
return dic return dic
def byteskwargs(dic): def byteskwargs(dic):
""" """
Converts keys of python dictonaries to bytes as they were converted to Converts keys of python dictonaries to bytes as they were converted to
str to pass that dictonary as a keyword argument on Python 3. str to pass that dictonary as a keyword argument on Python 3.
""" """
dic = dict((k.encode('latin-1'), v) for k, v in dic.items()) dic = {k.encode('latin-1'): v for k, v in dic.items()}
return dic return dic
# TODO: handle shlex.shlex(). # TODO: handle shlex.shlex().
def shlexsplit(s, comments=False, posix=True): def shlexsplit(s, comments=False, posix=True):
""" """
Takes bytes argument, convert it to str i.e. unicodes, pass that into Takes bytes argument, convert it to str i.e. unicodes, pass that into
shlex.split(), convert the returned value to bytes and return that for shlex.split(), convert the returned value to bytes and return that for
Python 3 compatibility as shelx.split() don't accept bytes on Python 3. Python 3 compatibility as shelx.split() don't accept bytes on Python 3.

mercurial/repair.py

b"backupbundle", b"saved backup bundle to %s\n", vfs.join(backupfile) b"backupbundle", b"saved backup bundle to %s\n", vfs.join(backupfile)
) )
return backupfile return backupfile
def safestriproots(ui, repo, nodes): def safestriproots(ui, repo, nodes):
"""return list of roots of nodes where descendants are covered by nodes""" """return list of roots of nodes where descendants are covered by nodes"""
torev = repo.unfiltered().changelog.rev torev = repo.unfiltered().changelog.rev
revs = set(torev(n) for n in nodes) revs = {torev(n) for n in nodes}
# tostrip = wanted - unsafe = wanted - ancestors(orphaned) # tostrip = wanted - unsafe = wanted - ancestors(orphaned)
# orphaned = affected - wanted # orphaned = affected - wanted
# affected = descendants(roots(wanted)) # affected = descendants(roots(wanted))
# wanted = revs # wanted = revs
revset = b'%ld - ( ::( (roots(%ld):: and not _phase(%s)) -%ld) )' revset = b'%ld - ( ::( (roots(%ld):: and not _phase(%s)) -%ld) )'
tostrip = set(repo.revs(revset, revs, revs, phases.internal, revs)) tostrip = set(repo.revs(revset, revs, revs, phases.internal, revs))
notstrip = revs - tostrip notstrip = revs - tostrip
if notstrip: if notstrip:

mercurial/revlog.py

return [nullid] return [nullid]
return [self.node(r) for r in self.headrevs()] return [self.node(r) for r in self.headrevs()]
if start is None: if start is None:
start = nullrev start = nullrev
else: else:
start = self.rev(start) start = self.rev(start)
stoprevs = set(self.rev(n) for n in stop or []) stoprevs = {self.rev(n) for n in stop or []}
revs = dagop.headrevssubset( revs = dagop.headrevssubset(
self.revs, self.parentrevs, startrev=start, stoprevs=stoprevs self.revs, self.parentrevs, startrev=start, stoprevs=stoprevs
) )
return [self.node(rev) for rev in revs] return [self.node(rev) for rev in revs]
def children(self, node): def children(self, node):

mercurial/revset.py

@predicate(b'parents([set])', safe=True) @predicate(b'parents([set])', safe=True)
def parents(repo, subset, x): def parents(repo, subset, x):
""" """
The set of all parents for all changesets in set, or the working directory. The set of all parents for all changesets in set, or the working directory.
""" """
if x is None: if x is None:
ps = set(p.rev() for p in repo[x].parents()) ps = {p.rev() for p in repo[x].parents()}
else: else:
ps = set() ps = set()
cl = repo.changelog cl = repo.changelog
up = ps.update up = ps.update
parentrevs = cl.parentrevs parentrevs = cl.parentrevs
for r in getset(repo, fullreposet(repo), x): for r in getset(repo, fullreposet(repo), x):
try: try:
up(parentrevs(r)) up(parentrevs(r))
Helper method to map a smartset to another smartset given a function only Helper method to map a smartset to another smartset given a function only
talking about nodes. Handles converting between rev numbers and nodes, and talking about nodes. Handles converting between rev numbers and nodes, and
filtering. filtering.
""" """
cl = repo.unfiltered().changelog cl = repo.unfiltered().changelog
torev = cl.index.get_rev torev = cl.index.get_rev
tonode = cl.node tonode = cl.node
result = set(torev(n) for n in f(tonode(r) for r in s)) result = {torev(n) for n in f(tonode(r) for r in s)}
result.discard(None) result.discard(None)
return smartset.baseset(result - repo.changelog.filteredrevs) return smartset.baseset(result - repo.changelog.filteredrevs)
@predicate(b'successors(set)', safe=True) @predicate(b'successors(set)', safe=True)
def successors(repo, subset, x): def successors(repo, subset, x):
"""All successors for set, including the given set themselves""" """All successors for set, including the given set themselves"""
s = getset(repo, fullreposet(repo), x) s = getset(repo, fullreposet(repo), x)

mercurial/scmutil.py

# removed + added -> normal # removed + added -> normal
ds.normallookup(f) ds.normallookup(f)
elif ds[f] != b'r': elif ds[f] != b'r':
ds.remove(f) ds.remove(f)
# Merge old parent and old working dir copies # Merge old parent and old working dir copies
oldcopies = copiesmod.pathcopies(newctx, oldctx, match) oldcopies = copiesmod.pathcopies(newctx, oldctx, match)
oldcopies.update(copies) oldcopies.update(copies)
copies = dict( copies = {
(dst, oldcopies.get(src, src)) dst: oldcopies.get(src, src)
for dst, src in pycompat.iteritems(oldcopies) for dst, src in pycompat.iteritems(oldcopies)
) }
# Adjust the dirstate copies # Adjust the dirstate copies
for dst, src in pycompat.iteritems(copies): for dst, src in pycompat.iteritems(copies):
if src not in newctx or dst in newctx or ds[dst] != b'a': if src not in newctx or dst in newctx or ds[dst] != b'a':
src = None src = None
ds.copy(src, dst) ds.copy(src, dst)
repo._quick_access_changeid_invalidate() repo._quick_access_changeid_invalidate()

mercurial/store.py

>>> dec(b'the~07quick~adshot') >>> dec(b'the~07quick~adshot')
'the\\x07quick\\xadshot' 'the\\x07quick\\xadshot'
''' '''
e = b'_' e = b'_'
xchr = pycompat.bytechr xchr = pycompat.bytechr
asciistr = list(map(xchr, range(127))) asciistr = list(map(xchr, range(127)))
capitals = list(range(ord(b"A"), ord(b"Z") + 1)) capitals = list(range(ord(b"A"), ord(b"Z") + 1))
cmap = dict((x, x) for x in asciistr) cmap = {x: x for x in asciistr}
for x in _reserved(): for x in _reserved():
cmap[xchr(x)] = b"~%02x" % x cmap[xchr(x)] = b"~%02x" % x
for x in capitals + [ord(e)]: for x in capitals + [ord(e)]:
cmap[xchr(x)] = e + xchr(x).lower() cmap[xchr(x)] = e + xchr(x).lower()
dmap = {} dmap = {}
for k, v in pycompat.iteritems(cmap): for k, v in pycompat.iteritems(cmap):
dmap[v] = k dmap[v] = k
>>> f(b'HELLO') >>> f(b'HELLO')
'hello' 'hello'
>>> f(b'hello:world?') >>> f(b'hello:world?')
'hello~3aworld~3f' 'hello~3aworld~3f'
>>> f(b'the\\x07quick\\xADshot') >>> f(b'the\\x07quick\\xADshot')
'the~07quick~adshot' 'the~07quick~adshot'
''' '''
xchr = pycompat.bytechr xchr = pycompat.bytechr
cmap = dict([(xchr(x), xchr(x)) for x in pycompat.xrange(127)]) cmap = {xchr(x): xchr(x) for x in pycompat.xrange(127)}
for x in _reserved(): for x in _reserved():
cmap[xchr(x)] = b"~%02x" % x cmap[xchr(x)] = b"~%02x" % x
for x in range(ord(b"A"), ord(b"Z") + 1): for x in range(ord(b"A"), ord(b"Z") + 1):
cmap[xchr(x)] = xchr(x).lower() cmap[xchr(x)] = xchr(x).lower()
def lowerencode(s): def lowerencode(s):
return b"".join([cmap[c] for c in pycompat.iterbytestr(s)]) return b"".join([cmap[c] for c in pycompat.iterbytestr(s)])

mercurial/upgrade.py

optimize=None, optimize=None,
backup=True, backup=True,
manifest=None, manifest=None,
changelog=None, changelog=None,
): ):
"""Upgrade a repository in place.""" """Upgrade a repository in place."""
if optimize is None: if optimize is None:
optimize = [] optimize = []
optimize = set(legacy_opts_map.get(o, o) for o in optimize) optimize = {legacy_opts_map.get(o, o) for o in optimize}
repo = repo.unfiltered() repo = repo.unfiltered()
revlogs = set(UPGRADE_ALL_REVLOGS) revlogs = set(UPGRADE_ALL_REVLOGS)
specentries = ((b'c', changelog), (b'm', manifest)) specentries = ((b'c', changelog), (b'm', manifest))
specified = [(y, x) for (y, x) in specentries if x is not None] specified = [(y, x) for (y, x) in specentries if x is not None]
if specified: if specified:
# we have some limitation on revlogs to be recloned # we have some limitation on revlogs to be recloned
if any(x for y, x in specified): if any(x for y, x in specified):

mercurial/url.py

h.headers.update(handler.parent.addheaders) h.headers.update(handler.parent.addheaders)
return return
h.realhostport = None h.realhostport = None
h.headers = None h.headers = None
def _generic_proxytunnel(self): def _generic_proxytunnel(self):
proxyheaders = dict( proxyheaders = {
[ x: self.headers[x]
(x, self.headers[x])
for x in self.headers for x in self.headers
if x.lower().startswith('proxy-') if x.lower().startswith('proxy-')
] }
)
self.send(b'CONNECT %s HTTP/1.0\r\n' % self.realhostport) self.send(b'CONNECT %s HTTP/1.0\r\n' % self.realhostport)
for header in pycompat.iteritems(proxyheaders): for header in pycompat.iteritems(proxyheaders):
self.send(b'%s: %s\r\n' % header) self.send(b'%s: %s\r\n' % header)
self.send(b'\r\n') self.send(b'\r\n')
# majority of the following code is duplicated from # majority of the following code is duplicated from
# httplib.HTTPConnection as there are no adequate places to # httplib.HTTPConnection as there are no adequate places to
# override functions to provide the needed functionality # override functions to provide the needed functionality

mercurial/util.py

Note that this function is unnecessary, and should not be Note that this function is unnecessary, and should not be
called, for case-sensitive filesystems (simply because it's expensive). called, for case-sensitive filesystems (simply because it's expensive).
The root should be normcase-ed, too. The root should be normcase-ed, too.
''' '''
def _makefspathcacheentry(dir): def _makefspathcacheentry(dir):
return dict((normcase(n), n) for n in os.listdir(dir)) return {normcase(n): n for n in os.listdir(dir)}
seps = pycompat.ossep seps = pycompat.ossep
if pycompat.osaltsep: if pycompat.osaltsep:
seps = seps + pycompat.osaltsep seps = seps + pycompat.osaltsep
# Protect backslashes. This gets silly very quickly. # Protect backslashes. This gets silly very quickly.
seps.replace(b'\\', b'\\\\') seps.replace(b'\\', b'\\\\')
pattern = remod.compile(br'([^%s]+)|([%s]+)' % (seps, seps)) pattern = remod.compile(br'([^%s]+)|([%s]+)' % (seps, seps))
dir = os.path.normpath(root) dir = os.path.normpath(root)

mercurial/utils/storageutil.py

""" """
fnode = store.node fnode = store.node
frev = store.rev frev = store.rev
if nodesorder == b'nodes': if nodesorder == b'nodes':
revs = [frev(n) for n in nodes] revs = [frev(n) for n in nodes]
elif nodesorder == b'linear': elif nodesorder == b'linear':
revs = set(frev(n) for n in nodes) revs = {frev(n) for n in nodes}
revs = dagop.linearize(revs, store.parentrevs) revs = dagop.linearize(revs, store.parentrevs)
else: # storage and default else: # storage and default
revs = sorted(frev(n) for n in nodes) revs = sorted(frev(n) for n in nodes)
prevrev = None prevrev = None
if deltamode == repository.CG_DELTAMODE_PREV or assumehaveparentrevisions: if deltamode == repository.CG_DELTAMODE_PREV or assumehaveparentrevisions:
prevrev = store.parentrevs(revs[0])[0] prevrev = store.parentrevs(revs[0])[0]

mercurial/windows.py

for nf in files: for nf in files:
nf = normcase(nf) nf = normcase(nf)
dir, base = os.path.split(nf) dir, base = os.path.split(nf)
if not dir: if not dir:
dir = b'.' dir = b'.'
cache = dircache.get(dir, None) cache = dircache.get(dir, None)
if cache is None: if cache is None:
try: try:
dmap = dict( dmap = {
[ normcase(n): s
(normcase(n), s)
for n, k, s in listdir(dir, True) for n, k, s in listdir(dir, True)
if getkind(s.st_mode) in _wantedkinds if getkind(s.st_mode) in _wantedkinds
] }
)
except OSError as err: except OSError as err:
# Python >= 2.5 returns ENOENT and adds winerror field # Python >= 2.5 returns ENOENT and adds winerror field
# EINVAL is raised if dir is not a directory. # EINVAL is raised if dir is not a directory.
if err.errno not in (errno.ENOENT, errno.EINVAL, errno.ENOTDIR): if err.errno not in (errno.ENOENT, errno.EINVAL, errno.ENOTDIR):
raise raise
dmap = {} dmap = {}
cache = dircache.setdefault(dir, dmap) cache = dircache.setdefault(dir, dmap)
yield cache.get(base, None) yield cache.get(base, None)

mercurial/wireprototypes.py

return [ return [
e for e in compengines if getattr(e.wireprotosupport(), attr) > 0 e for e in compengines if getattr(e.wireprotosupport(), attr) > 0
] ]
# If compression engines are listed in the config, assume there is a good # If compression engines are listed in the config, assume there is a good
# reason for it (like server operators wanting to achieve specific # reason for it (like server operators wanting to achieve specific
# performance characteristics). So fail fast if the config references # performance characteristics). So fail fast if the config references
# unusable compression engines. # unusable compression engines.
validnames = set(e.name() for e in compengines) validnames = {e.name() for e in compengines}
invalidnames = set(e for e in configengines if e not in validnames) invalidnames = {e for e in configengines if e not in validnames}
if invalidnames: if invalidnames:
raise error.Abort( raise error.Abort(
_(b'invalid compression engine defined in %s: %s') _(b'invalid compression engine defined in %s: %s')
% (config, b', '.join(sorted(invalidnames))) % (config, b', '.join(sorted(invalidnames)))
) )
compengines = [e for e in compengines if e.name() in configengines] compengines = [e for e in compengines if e.name() in configengines]
compengines = sorted( compengines = sorted(

setup.py

if res: if res:
raise SystemExit( raise SystemExit(
'error running runrst: %s' % '\n'.join([out, err]) 'error running runrst: %s' % '\n'.join([out, err])
) )
normalizecrlf('doc/%s.html' % root) normalizecrlf('doc/%s.html' % root)
# This logic is duplicated in doc/Makefile. # This logic is duplicated in doc/Makefile.
sources = set( sources = {
f f
for f in os.listdir('mercurial/helptext') for f in os.listdir('mercurial/helptext')
if re.search(r'[0-9]\.txt$', f) if re.search(r'[0-9]\.txt$', f)
) }
# common.txt is a one-off. # common.txt is a one-off.
gentxt('common') gentxt('common')
for source in sorted(sources): for source in sorted(sources):
assert source[-4:] == '.txt' assert source[-4:] == '.txt'
root = source[:-4] root = source[:-4]
# Also helps setuptools not be sad while we refuse to create eggs. # Also helps setuptools not be sad while we refuse to create eggs.
single_version_externally_managed = True single_version_externally_managed = True
def get_sub_commands(self): def get_sub_commands(self):
# Screen out egg related commands to prevent egg generation. But allow # Screen out egg related commands to prevent egg generation. But allow
# mercurial.egg-info generation, since that is part of modern # mercurial.egg-info generation, since that is part of modern
# packaging. # packaging.
excl = set(['bdist_egg']) excl = {'bdist_egg'}
return filter(lambda x: x not in excl, install.get_sub_commands(self)) return filter(lambda x: x not in excl, install.get_sub_commands(self))
class hginstalllib(install_lib): class hginstalllib(install_lib):
''' '''
This is a specialization of install_lib that replaces the copy_file used This is a specialization of install_lib that replaces the copy_file used
there so that it supports setting the mode of files after copying them, there so that it supports setting the mode of files after copying them,
instead of just preserving the mode that the files originally had. If your instead of just preserving the mode that the files originally had. If your

tests/run-tests.py

class TTest(Test): class TTest(Test):
"""A "t test" is a test backed by a .t file.""" """A "t test" is a test backed by a .t file."""
SKIPPED_PREFIX = b'skipped: ' SKIPPED_PREFIX = b'skipped: '
FAILED_PREFIX = b'hghave check failed: ' FAILED_PREFIX = b'hghave check failed: '
NEEDESCAPE = re.compile(br'[\x00-\x08\x0b-\x1f\x7f-\xff]').search NEEDESCAPE = re.compile(br'[\x00-\x08\x0b-\x1f\x7f-\xff]').search
ESCAPESUB = re.compile(br'[\x00-\x08\x0b-\x1f\\\x7f-\xff]').sub ESCAPESUB = re.compile(br'[\x00-\x08\x0b-\x1f\\\x7f-\xff]').sub
ESCAPEMAP = dict((bchr(i), br'\x%02x' % i) for i in range(256)) ESCAPEMAP = {bchr(i): br'\x%02x' % i for i in range(256)}
ESCAPEMAP.update({b'\\': b'\\\\', b'\r': br'\r'}) ESCAPEMAP.update({b'\\': b'\\\\', b'\r': br'\r'})
def __init__(self, path, *args, **kwds): def __init__(self, path, *args, **kwds):
# accept an extra "case" parameter # accept an extra "case" parameter
case = kwds.pop('case', []) case = kwds.pop('case', [])
self._case = case self._case = case
self._allcases = {x for y in parsettestcases(path) for x in y} self._allcases = {x for y in parsettestcases(path) for x in y}
super(TTest, self).__init__(path, *args, **kwds) super(TTest, self).__init__(path, *args, **kwds)
if err.errno != errno.ENOENT: if err.errno != errno.ENOENT:
raise raise
return times return times
def savetimes(outputdir, result): def savetimes(outputdir, result):
saved = dict(loadtimes(outputdir)) saved = dict(loadtimes(outputdir))
maxruns = 5 maxruns = 5
skipped = set([str(t[0]) for t in result.skipped]) skipped = {str(t[0]) for t in result.skipped}
for tdata in result.times: for tdata in result.times:
test, real = tdata[0], tdata[3] test, real = tdata[0], tdata[3]
if test not in skipped: if test not in skipped:
ts = saved.setdefault(test, []) ts = saved.setdefault(test, [])
ts.append(real) ts.append(real)
ts[:] = ts[-maxruns:] ts[:] = ts[-maxruns:]
fd, tmpname = tempfile.mkstemp( fd, tmpname = tempfile.mkstemp(
for tdata in times: for tdata in times:
test = tdata[0] test = tdata[0]
cuser, csys, real, start, end = tdata[1:6] cuser, csys, real, start, end = tdata[1:6]
self.stream.writeln(cols % (start, end, cuser, csys, real, test)) self.stream.writeln(cols % (start, end, cuser, csys, real, test))
@staticmethod @staticmethod
def _writexunit(result, outf): def _writexunit(result, outf):
# See http://llg.cubic.org/docs/junit/ for a reference. # See http://llg.cubic.org/docs/junit/ for a reference.
timesd = dict((t[0], t[3]) for t in result.times) timesd = {t[0]: t[3] for t in result.times}
doc = minidom.Document() doc = minidom.Document()
s = doc.createElement('testsuite') s = doc.createElement('testsuite')
s.setAttribute('errors', "0") # TODO s.setAttribute('errors', "0") # TODO
s.setAttribute('failures', str(len(result.failures))) s.setAttribute('failures', str(len(result.failures)))
s.setAttribute('name', 'run-tests') s.setAttribute('name', 'run-tests')
s.setAttribute( s.setAttribute(
'skipped', str(len(result.skipped) + len(result.ignored)) 'skipped', str(len(result.skipped) + len(result.ignored))
) )
if lctest.endswith(ext): if lctest.endswith(ext):
testcls = cls testcls = cls
break break
refpath = os.path.join(getcwdb(), path) refpath = os.path.join(getcwdb(), path)
tmpdir = os.path.join(self._hgtmp, b'child%d' % count) tmpdir = os.path.join(self._hgtmp, b'child%d' % count)
# extra keyword parameters. 'case' is used by .t tests # extra keyword parameters. 'case' is used by .t tests
kwds = dict((k, testdesc[k]) for k in ['case'] if k in testdesc) kwds = {k: testdesc[k] for k in ['case'] if k in testdesc}
t = testcls( t = testcls(
refpath, refpath,
self._outputdir, self._outputdir,
tmpdir, tmpdir,
keeptmpdir=self.options.keep_tmpdir, keeptmpdir=self.options.keep_tmpdir,
debug=self.options.debug, debug=self.options.debug,
first=self.options.first, first=self.options.first,

tests/simplestorerepo.py

if not len(self): if not len(self):
return [nullid] return [nullid]
return [self.node(r) for r in self._headrevs()] return [self.node(r) for r in self._headrevs()]
if start is None: if start is None:
start = nullid start = nullid
if stop is None: if stop is None:
stop = [] stop = []
stoprevs = set([self.rev(n) for n in stop]) stoprevs = {self.rev(n) for n in stop}
startrev = self.rev(start) startrev = self.rev(start)
reachable = {startrev} reachable = {startrev}
heads = {startrev} heads = {startrev}
parentrevs = self.parentrevs parentrevs = self.parentrevs
for r in self.revs(start=startrev + 1): for r in self.revs(start=startrev + 1):
for p in parentrevs(r): for p in parentrevs(r):
if p in reachable: if p in reachable:

tests/test-fastannotate-revmap.py

# copy rm to rm2 # copy rm to rm2
rm2 = revmap.revmap() rm2 = revmap.revmap()
rm2.copyfrom(rm) rm2.copyfrom(rm)
path2 = gettemppath() path2 = gettemppath()
rm2.path = path2 rm2.path = path2
rm2.flush() rm2.flush()
# two files should be the same # two files should be the same
ensure(len(set(util.readfile(p) for p in [path, path2])) == 1) ensure(len({util.readfile(p) for p in [path, path2]}) == 1)
os.unlink(path) os.unlink(path)
os.unlink(path2) os.unlink(path2)
class fakefctx(object): class fakefctx(object):
def __init__(self, node, path=None): def __init__(self, node, path=None):
self._node = node self._node = node

tests/test-hgweb-auth.py

print('CFG:', pycompat.sysstr(stringutil.pprint(auth, bprefix=True))) print('CFG:', pycompat.sysstr(stringutil.pprint(auth, bprefix=True)))
prefixes = set() prefixes = set()
for k in auth: for k in auth:
prefixes.add(k.split(b'.', 1)[0]) prefixes.add(k.split(b'.', 1)[0])
for p in prefixes: for p in prefixes:
for name in (b'.username', b'.password'): for name in (b'.username', b'.password'):
if (p + name) not in auth: if (p + name) not in auth:
auth[p + name] = p auth[p + name] = p
auth = dict((k, v) for k, v in auth.items() if v is not None) auth = {k: v for k, v in auth.items() if v is not None}
ui = writeauth(auth) ui = writeauth(auth)
def _test(uri): def _test(uri):
print('URI:', pycompat.strurl(uri)) print('URI:', pycompat.strurl(uri))
try: try:
pm = url.passwordmgr(ui, urlreq.httppasswordmgrwithdefaultrealm()) pm = url.passwordmgr(ui, urlreq.httppasswordmgrwithdefaultrealm())
u, authinfo = util.url(uri).authinfo() u, authinfo = util.url(uri).authinfo()

tests/test-revlog-raw.py

The combination of two adjacent numbers will cover all possible cases. The combination of two adjacent numbers will cover all possible cases.
That is to say, given any x, y where both x, and y are in range(2 ** n), That is to say, given any x, y where both x, and y are in range(2 ** n),
there is an x followed immediately by y in the generated sequence. there is an x followed immediately by y in the generated sequence.
''' '''
m = 2 ** n m = 2 ** n
# Gray Code. See https://en.wikipedia.org/wiki/Gray_code # Gray Code. See https://en.wikipedia.org/wiki/Gray_code
gray = lambda x: x ^ (x >> 1) gray = lambda x: x ^ (x >> 1)
reversegray = dict((gray(i), i) for i in range(m)) reversegray = {gray(i): i for i in range(m)}
# Generate (n * 2) bit gray code, yield lower n bits as X, and look for # Generate (n * 2) bit gray code, yield lower n bits as X, and look for
# the next unused gray code where higher n bits equal to X. # the next unused gray code where higher n bits equal to X.
# For gray codes whose higher bits are X, a[X] of them have been used. # For gray codes whose higher bits are X, a[X] of them have been used.
a = [0] * m a = [0] * m
# Iterate from 0. # Iterate from 0.

tests/wireprotosimplecache.py

redirectable = True redirectable = True
if not self.cacheapi: if not self.cacheapi:
redirectable = False redirectable = False
elif not self.redirecttargets: elif not self.redirecttargets:
redirectable = False redirectable = False
else: else:
clienttargets = set(self.redirecttargets) clienttargets = set(self.redirecttargets)
ourtargets = set(t[b'name'] for t in loadredirecttargets(self.ui)) ourtargets = {t[b'name'] for t in loadredirecttargets(self.ui)}
# We only ever redirect to a single target (for now). So we don't # We only ever redirect to a single target (for now). So we don't
# need to store which target matched. # need to store which target matched.
if not clienttargets & ourtargets: if not clienttargets & ourtargets:
redirectable = False redirectable = False
if redirectable: if redirectable:
paths = self.req.dispatchparts[:-3] paths = self.req.dispatchparts[:-3]