This is an archive of the discontinued Mercurial Phabricator instance.

Differential D7015

py3: finish porting iteritems() to pycompat and remove source transformer
ClosedPublic

Authored by indygreg on Oct 7 2019, 4:06 PM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHGd783f945a701: py3: finish porting iteritems() to pycompat and remove source transformer
Summary

This commit finishes porting .iteritems() to pycompat.iteritems()
for the mercurial package.

The translation of .iteritems() to .items() was the last conversion
performed by the source transformer. With the porting to pycompat
complete, we no longer have a need for the source transformer. So
the source transformer has been removed. Good riddance! The code
base is now compatible with Python 2 and Python 3.

For the record, as the person who introduced the source transformer,
it brings me joy to delete it. It accomplished its goal to facilitate
a port to Python 3 without overly burdening people on some painful
low-level differences between Python 2 and 3. It is unfortunate we
still have to wallpaper over many differences with the pycompat
shim. But it is what it is.

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

indygreg created this revision.Oct 7 2019, 4:06 PM
indygreg added a commit: rHGd783f945a701: py3: finish porting iteritems() to pycompat and remove source transformer.Oct 8 2019, 2:17 PM
This revision was not accepted when it landed; it landed in state Needs Review.
Closed by commit rHGd783f945a701: py3: finish porting iteritems() to pycompat and remove source transformer (authored by indygreg). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mmercurial/__init__.py (192 lines)
Mmercurial/archival.py (2 lines)
Mmercurial/bookmarks.py (10 lines)
Mmercurial/branchmap.py (8 lines)
Mmercurial/changegroup.py (6 lines)
Mmercurial/chgserver.py (4 lines)
Mmercurial/cmdutil.py (2 lines)
Mmercurial/commands.py (12 lines)
Mmercurial/config.py (2 lines)
Mmercurial/context.py (2 lines)
Mmercurial/copies.py (13 lines)
Mmercurial/debugcommands.py (12 lines)
Mmercurial/dirstate.py (24 lines)
Mmercurial/discovery.py (17 lines)
Mmercurial/dispatch.py (2 lines)
Mmercurial/exchange.py (4 lines)
Mmercurial/exchangev2.py (6 lines)
Mmercurial/extensions.py (18 lines)
Mmercurial/exthelper.py (2 lines)
Mmercurial/filemerge.py (2 lines)
Mmercurial/fileset.py (2 lines)
Mmercurial/formatter.py (2 lines)
Mmercurial/help.py (11 lines)
Mmercurial/hgweb/hgweb_mod.py (2 lines)
Mmercurial/hgweb/hgwebdir_mod.py (3 lines)
Mmercurial/hgweb/request.py (8 lines)
Mmercurial/hgweb/webcommands.py (4 lines)
Mmercurial/hgweb/webutil.py (4 lines)
Mmercurial/hgweb/wsgicgi.py (2 lines)
Mmercurial/hook.py (2 lines)
Mmercurial/httpconnection.py (2 lines)
Mmercurial/keepalive.py (2 lines)
Mmercurial/localrepo.py (12 lines)
Mmercurial/logcmdutil.py (4 lines)
Mmercurial/logexchange.py (5 lines)
Mmercurial/lsprof.py (3 lines)
Mmercurial/manifest.py (38 lines)
Mmercurial/match.py (2 lines)
Mmercurial/merge.py (34 lines)
Mmercurial/namespaces.py (5 lines)
Mmercurial/obsolete.py (6 lines)
Mmercurial/obsutil.py (3 lines)
Mmercurial/patch.py (4 lines)
Mmercurial/phases.py (2 lines)
Mmercurial/pure/parsers.py (2 lines)
Mmercurial/pycompat.py (4 lines)
Mmercurial/revlog.py (6 lines)
Mmercurial/revset.py (6 lines)
Mmercurial/revsetlang.py (2 lines)
Mmercurial/scmutil.py (13 lines)
Mmercurial/similar.py (7 lines)
Mmercurial/sparse.py (6 lines)
Mmercurial/sshpeer.py (4 lines)
Mmercurial/statprof.py (8 lines)
Mmercurial/store.py (2 lines)
Mmercurial/subrepo.py (2 lines)
Mmercurial/subrepoutil.py (3 lines)
Mmercurial/tags.py (5 lines)
Mmercurial/templatefilters.py (4 lines)
Mmercurial/templatefuncs.py (4 lines)
Mmercurial/templatekw.py (10 lines)
Mmercurial/templater.py (5 lines)
Mmercurial/templateutil.py (9 lines)
Mmercurial/transaction.py (2 lines)
Mmercurial/ui.py (4 lines)
Mmercurial/url.py (2 lines)
Mmercurial/util.py (4 lines)
Mmercurial/utils/cborutil.py (2 lines)
Mmercurial/utils/procutil.py (4 lines)
Mmercurial/verify.py (6 lines)
Mmercurial/wireprotoframing.py (4 lines)
Mmercurial/wireprotov1peer.py (4 lines)
Mmercurial/wireprotov1server.py (4 lines)
Mmercurial/wireprotov2server.py (9 lines)

Diff 16966

mercurial/__init__.py

# __init__.py - Startup and module loading logic for Mercurial. # __init__.py - Startup and module loading logic for Mercurial.
# #
# Copyright 2015 Gregory Szorc <gregory.szorc@gmail.com> # Copyright 2015 Gregory Szorc <gregory.szorc@gmail.com>
# #
# This software may be used and distributed according to the terms of the # This software may be used and distributed according to the terms of the
# GNU General Public License version 2 or any later version. # GNU General Public License version 2 or any later version.
from __future__ import absolute_import from __future__ import absolute_import
import sys
# Allow 'from mercurial import demandimport' to keep working. # Allow 'from mercurial import demandimport' to keep working.
import hgdemandimport import hgdemandimport
demandimport = hgdemandimport demandimport = hgdemandimport
__all__ = []
# Python 3 uses a custom module loader that transforms source code between
# source file reading and compilation. This is done by registering a custom
# finder that changes the spec for Mercurial modules to use a custom loader.
if sys.version_info[0] >= 3:
import importlib
import importlib.abc
import io
import token
import tokenize
class hgpathentryfinder(importlib.abc.MetaPathFinder):
"""A sys.meta_path finder that uses a custom module loader."""
def find_spec(self, fullname, path, target=None):
# Only handle Mercurial-related modules.
if not fullname.startswith('mercurial.'):
return None
# don't try to parse binary
if fullname.startswith('mercurial.cext.'):
return None
# third-party packages are expected to be dual-version clean
if fullname.startswith('mercurial.thirdparty'):
return None
# zstd is already dual-version clean, don't try and mangle it
if fullname.startswith('mercurial.zstd'):
return None
# rustext is built for the right python version,
# don't try and mangle it
if fullname.startswith('mercurial.rustext'):
return None
# Try to find the module using other registered finders.
spec = None
for finder in sys.meta_path:
if finder == self:
continue
# Originally the API was a `find_module` method, but it was
# renamed to `find_spec` in python 3.4, with a new `target`
# argument.
find_spec_method = getattr(finder, 'find_spec', None)
if find_spec_method:
spec = find_spec_method(fullname, path, target=target)
else:
spec = finder.find_module(fullname)
if spec is not None:
spec = importlib.util.spec_from_loader(fullname, spec)
if spec:
break
# This is a Mercurial-related module but we couldn't find it
# using the previously-registered finders. This likely means
# the module doesn't exist.
if not spec:
return None
# TODO need to support loaders from alternate specs, like zip
# loaders.
loader = hgloader(spec.name, spec.origin)
# Can't use util.safehasattr here because that would require
# importing util, and we're in import code.
if hasattr(spec.loader, 'loader'): # hasattr-py3-only
# This is a nested loader (maybe a lazy loader?)
spec.loader.loader = loader
else:
spec.loader = loader
return spec
def replacetokens(tokens, fullname):
"""Transform a stream of tokens from raw to Python 3.
It is called by the custom module loading machinery to rewrite
source/tokens between source decoding and compilation.
Returns a generator of possibly rewritten tokens.
The input token list may be mutated as part of processing. However,
its changes do not necessarily match the output token stream.
REMEMBER TO CHANGE ``BYTECODEHEADER`` WHEN CHANGING THIS FUNCTION
OR CACHED FILES WON'T GET INVALIDATED PROPERLY.
"""
# The following utility functions access the tokens list and i index of
# the for i, t enumerate(tokens) loop below
def _isop(j, *o):
"""Assert that tokens[j] is an OP with one of the given values"""
try:
return tokens[j].type == token.OP and tokens[j].string in o
except IndexError:
return False
for i, t in enumerate(tokens):
# This looks like a function call.
if t.type == token.NAME and _isop(i + 1, '('):
fn = t.string
# It changes iteritems/values to items/values as they are not
# present in Python 3 world.
if fn == 'iteritems' and not (
tokens[i - 1].type == token.NAME
and tokens[i - 1].string == 'def'
):
yield t._replace(string=fn[4:])
continue
# Emit unmodified token.
yield t
# Header to add to bytecode files. This MUST be changed when
# ``replacetoken`` or any mechanism that changes semantics of module
# loading is changed. Otherwise cached bytecode may get loaded without
# the new transformation mechanisms applied.
BYTECODEHEADER = b'HG\x00\x16'
class hgloader(importlib.machinery.SourceFileLoader):
"""Custom module loader that transforms source code.
When the source code is converted to a code object, we transform
certain patterns to be Python 3 compatible. This allows us to write code
that is natively Python 2 and compatible with Python 3 without
making the code excessively ugly.
We do this by transforming the token stream between parse and compile.
Implementing transformations invalidates caching assumptions made
by the built-in importer. The built-in importer stores a header on
saved bytecode files indicating the Python/bytecode version. If the
version changes, the cached bytecode is ignored. The Mercurial
transformations could change at any time. This means we need to check
that cached bytecode was generated with the current transformation
code or there could be a mismatch between cached bytecode and what
would be generated from this class.
We supplement the bytecode caching layer by wrapping ``get_data``
and ``set_data``. These functions are called when the
``SourceFileLoader`` retrieves and saves bytecode cache files,
respectively. We simply add an additional header on the file. As
long as the version in this file is changed when semantics change,
cached bytecode should be invalidated when transformations change.
The added header has the form ``HG<VERSION>``. That is a literal
``HG`` with 2 binary bytes indicating the transformation version.
"""
def get_data(self, path):
data = super(hgloader, self).get_data(path)
if not path.endswith(tuple(importlib.machinery.BYTECODE_SUFFIXES)):
return data
# There should be a header indicating the Mercurial transformation
# version. If it doesn't exist or doesn't match the current version,
# we raise an OSError because that is what
# ``SourceFileLoader.get_code()`` expects when loading bytecode
# paths to indicate the cached file is "bad."
if data[0:2] != b'HG':
raise OSError('no hg header')
if data[0:4] != BYTECODEHEADER:
raise OSError('hg header version mismatch')
return data[4:]
def set_data(self, path, data, *args, **kwargs):
if path.endswith(tuple(importlib.machinery.BYTECODE_SUFFIXES)):
data = BYTECODEHEADER + data
return super(hgloader, self).set_data(path, data, *args, **kwargs)
def source_to_code(self, data, path):
"""Perform token transformation before compilation."""
buf = io.BytesIO(data)
tokens = tokenize.tokenize(buf.readline)
data = tokenize.untokenize(replacetokens(list(tokens), self.name))
# Python's built-in importer strips frames from exceptions raised
# for this code. Unfortunately, that mechanism isn't extensible
# and our frame will be blamed for the import failure. There
# are extremely hacky ways to do frame stripping. We haven't
# implemented them because they are very ugly.
return super(hgloader, self).source_to_code(data, path)
# We automagically register our custom importer as a side-effect of
# loading. This is necessary to ensure that any entry points are able
# to import mercurial.* modules without having to perform this
# registration themselves.
if not any(isinstance(x, hgpathentryfinder) for x in sys.meta_path):
# meta_path is used before any implicit finders and before sys.path.
sys.meta_path.insert(0, hgpathentryfinder())

mercurial/archival.py

b'tbz2': [b'.tbz2', b'.tar.bz2'], b'tbz2': [b'.tbz2', b'.tar.bz2'],
b'tgz': [b'.tgz', b'.tar.gz'], b'tgz': [b'.tgz', b'.tar.gz'],
b'zip': [b'.zip'], b'zip': [b'.zip'],
b'txz': [b'.txz', b'.tar.xz'], b'txz': [b'.txz', b'.tar.xz'],
} }
def guesskind(dest): def guesskind(dest):
for kind, extensions in exts.iteritems(): for kind, extensions in pycompat.iteritems(exts):
if any(dest.endswith(ext) for ext in extensions): if any(dest.endswith(ext) for ext in extensions):
return kind return kind
return None return None
def _rootctx(repo): def _rootctx(repo):
# repo[0] may be hidden # repo[0] may be hidden
for rev in repo: for rev in repo:

mercurial/bookmarks.py

def __len__(self): def __len__(self):
return len(self._refmap) return len(self._refmap)
def __iter__(self): def __iter__(self):
return iter(self._refmap) return iter(self._refmap)
def iteritems(self): def iteritems(self):
return self._refmap.iteritems() return pycompat.iteritems(self._refmap)
def items(self): def items(self):
return self._refmap.items() return self._refmap.items()
# TODO: maybe rename to allnames()? # TODO: maybe rename to allnames()?
def keys(self): def keys(self):
return self._refmap.keys() return self._refmap.keys()
b'bookmarks.current', b'w', atomictemp=True, checkambig=True b'bookmarks.current', b'w', atomictemp=True, checkambig=True
) as f: ) as f:
f.write(encoding.fromlocal(self._active)) f.write(encoding.fromlocal(self._active))
else: else:
self._repo.vfs.tryunlink(b'bookmarks.current') self._repo.vfs.tryunlink(b'bookmarks.current')
self._aclean = True self._aclean = True
def _write(self, fp): def _write(self, fp):
for name, node in sorted(self._refmap.iteritems()): for name, node in sorted(pycompat.iteritems(self._refmap)):
fp.write(b"%s %s\n" % (hex(node), encoding.fromlocal(name))) fp.write(b"%s %s\n" % (hex(node), encoding.fromlocal(name)))
self._clean = True self._clean = True
self._repo.invalidatevolatilesets() self._repo.invalidatevolatilesets()
def expandname(self, bname): def expandname(self, bname):
if bname == b'.': if bname == b'.':
if self.active: if self.active:
return self.active return self.active
only one entry. only one entry.
""" """
if not repo._activebookmark: if not repo._activebookmark:
raise ValueError( raise ValueError(
b'headsforactive() only makes sense with an active bookmark' b'headsforactive() only makes sense with an active bookmark'
) )
name = repo._activebookmark.split(b'@', 1)[0] name = repo._activebookmark.split(b'@', 1)[0]
heads = [] heads = []
for mark, n in repo._bookmarks.iteritems(): for mark, n in pycompat.iteritems(repo._bookmarks):
if mark.split(b'@', 1)[0] == name: if mark.split(b'@', 1)[0] == name:
heads.append(n) heads.append(n)
return heads return heads
def calculateupdate(ui, repo): def calculateupdate(ui, repo):
'''Return a tuple (activemark, movemarkfrom) indicating the active bookmark '''Return a tuple (activemark, movemarkfrom) indicating the active bookmark
and where to move the active bookmark from, if needed.''' and where to move the active bookmark from, if needed.'''
def listbinbookmarks(repo): def listbinbookmarks(repo):
# We may try to list bookmarks on a repo type that does not # We may try to list bookmarks on a repo type that does not
# support it (e.g., statichttprepository). # support it (e.g., statichttprepository).
marks = getattr(repo, '_bookmarks', {}) marks = getattr(repo, '_bookmarks', {})
hasnode = repo.changelog.hasnode hasnode = repo.changelog.hasnode
for k, v in marks.iteritems(): for k, v in pycompat.iteritems(marks):
# don't expose local divergent bookmarks # don't expose local divergent bookmarks
if hasnode(v) and (b'@' not in k or k.endswith(b'@')): if hasnode(v) and (b'@' not in k or k.endswith(b'@')):
yield k, v yield k, v
def listbookmarks(repo): def listbookmarks(repo):
d = {} d = {}
for book, node in listbinbookmarks(repo): for book, node in listbinbookmarks(repo):
"""private method to print bookmarks """private method to print bookmarks
Provides a way for extensions to control how bookmarks are printed (e.g. Provides a way for extensions to control how bookmarks are printed (e.g.
prepend or postpend names) prepend or postpend names)
""" """
hexfn = fm.hexfunc hexfn = fm.hexfunc
if len(bmarks) == 0 and fm.isplain(): if len(bmarks) == 0 and fm.isplain():
ui.status(_(b"no bookmarks set\n")) ui.status(_(b"no bookmarks set\n"))
for bmark, (n, prefix, label) in sorted(bmarks.iteritems()): for bmark, (n, prefix, label) in sorted(pycompat.iteritems(bmarks)):
fm.startitem() fm.startitem()
fm.context(repo=repo) fm.context(repo=repo)
if not ui.quiet: if not ui.quiet:
fm.plain(b' %s ' % prefix, label=label) fm.plain(b' %s ' % prefix, label=label)
fm.write(b'bookmark', b'%s', bmark, label=label) fm.write(b'bookmark', b'%s', bmark, label=label)
pad = b" " * (25 - encoding.colwidth(bmark)) pad = b" " * (25 - encoding.colwidth(bmark))
fm.condwrite( fm.condwrite(
not ui.quiet, not ui.quiet,

mercurial/branchmap.py

self._verifybranch(key) self._verifybranch(key)
return self._entries[key] return self._entries[key]
def __contains__(self, key): def __contains__(self, key):
self._verifybranch(key) self._verifybranch(key)
return key in self._entries return key in self._entries
def iteritems(self): def iteritems(self):
for k, v in self._entries.iteritems(): for k, v in pycompat.iteritems(self._entries):
self._verifybranch(k) self._verifybranch(k)
yield k, v yield k, v
items = iteritems items = iteritems
def hasbranch(self, label): def hasbranch(self, label):
""" checks whether a branch of this name exists or not """ """ checks whether a branch of this name exists or not """
self._verifybranch(label) self._verifybranch(label)
def branchheads(self, branch, closed=False): def branchheads(self, branch, closed=False):
self._verifybranch(branch) self._verifybranch(branch)
heads = self._entries[branch] heads = self._entries[branch]
if not closed: if not closed:
heads = list(self.iteropen(heads)) heads = list(self.iteropen(heads))
return heads return heads
def iterbranches(self): def iterbranches(self):
for bn, heads in self.iteritems(): for bn, heads in pycompat.iteritems(self):
yield (bn, heads) + self._branchtip(heads) yield (bn, heads) + self._branchtip(heads)
def iterheads(self): def iterheads(self):
""" returns all the heads """ """ returns all the heads """
self._verifyall() self._verifyall()
return pycompat.itervalues(self._entries) return pycompat.itervalues(self._entries)
def copy(self): def copy(self):
def write(self, repo): def write(self, repo):
try: try:
f = repo.cachevfs(self._filename(repo), b"w", atomictemp=True) f = repo.cachevfs(self._filename(repo), b"w", atomictemp=True)
cachekey = [hex(self.tipnode), b'%d' % self.tiprev] cachekey = [hex(self.tipnode), b'%d' % self.tiprev]
if self.filteredhash is not None: if self.filteredhash is not None:
cachekey.append(hex(self.filteredhash)) cachekey.append(hex(self.filteredhash))
f.write(b" ".join(cachekey) + b'\n') f.write(b" ".join(cachekey) + b'\n')
nodecount = 0 nodecount = 0
for label, nodes in sorted(self._entries.iteritems()): for label, nodes in sorted(pycompat.iteritems(self._entries)):
label = encoding.fromlocal(label) label = encoding.fromlocal(label)
for node in nodes: for node in nodes:
nodecount += 1 nodecount += 1
if node in self._closednodes: if node in self._closednodes:
state = b'c' state = b'c'
else: else:
state = b'o' state = b'o'
f.write(b"%s %s %s\n" % (hex(node), state, label)) f.write(b"%s %s %s\n" % (hex(node), state, label))
# new tip revision which we found after iterating items from new # new tip revision which we found after iterating items from new
# 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 newbranches.iteritems(): 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 = set(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)

mercurial/changegroup.py

if repo.ui.configbool(b'server', b'validate'): if repo.ui.configbool(b'server', b'validate'):
cl = repo.changelog cl = repo.changelog
ml = repo.manifestlog ml = repo.manifestlog
# validate incoming csets have their manifests # validate incoming csets have their manifests
for cset in pycompat.xrange(clstart, clend): for cset in pycompat.xrange(clstart, clend):
mfnode = cl.changelogrevision(cset).manifest mfnode = cl.changelogrevision(cset).manifest
mfest = ml[mfnode].readdelta() mfest = ml[mfnode].readdelta()
# store file cgnodes we must see # store file cgnodes we must see
for f, n in mfest.iteritems(): for f, n in pycompat.iteritems(mfest):
needfiles.setdefault(f, set()).add(n) needfiles.setdefault(f, set()).add(n)
# process the files # process the files
repo.ui.status(_(b"adding file changes\n")) repo.ui.status(_(b"adding file changes\n"))
newrevs, newfiles = _addchangegroupfiles( newrevs, newfiles = _addchangegroupfiles(
repo, self, revmap, trp, efiles, needfiles repo, self, revmap, trp, efiles, needfiles
) )
self._verbosenote(_(b'%8.i (manifests)\n') % size) self._verbosenote(_(b'%8.i (manifests)\n') % size)
yield self._manifestsend yield self._manifestsend
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 manifests.iteritems() for (n, lr) in pycompat.iteritems(manifests)
] ]
manifests.clear() manifests.clear()
clrevs = set(cl.rev(x) for x in clnodes) clrevs = set(cl.rev(x) for x in clnodes)
it = self.generatefiles( it = self.generatefiles(
changedfiles, changedfiles,
commonrevs, commonrevs,
if n in needs: if n in needs:
needs.remove(n) needs.remove(n)
else: else:
raise error.Abort(_(b"received spurious file revlog entry")) raise error.Abort(_(b"received spurious file revlog entry"))
if not needs: if not needs:
del needfiles[f] del needfiles[f]
progress.complete() progress.complete()
for f, needs in needfiles.iteritems(): for f, needs in pycompat.iteritems(needfiles):
fl = repo.file(f) fl = repo.file(f)
for n in needs: for n in needs:
try: try:
fl.rev(n) fl.rev(n)
except error.LookupError: except error.LookupError:
raise error.Abort( raise error.Abort(
_(b'missing file data for %s:%s - run hg verify') _(b'missing file data for %s:%s - run hg verify')
% (f, hex(n)) % (f, hex(n))
) )
return revisions, files return revisions, files

mercurial/chgserver.py

sectionhash = _hashlist(sectionitems) sectionhash = _hashlist(sectionitems)
# If $CHGHG is set, the change to $HG should not trigger a new chg server # If $CHGHG is set, the change to $HG should not trigger a new chg server
if b'CHGHG' in encoding.environ: if b'CHGHG' in encoding.environ:
ignored = {b'HG'} ignored = {b'HG'}
else: else:
ignored = set() ignored = set()
envitems = [ envitems = [
(k, v) (k, v)
for k, v in encoding.environ.iteritems() for k, v in pycompat.iteritems(encoding.environ)
if _envre.match(k) and k not in ignored if _envre.match(k) and k not in ignored
] ]
envhash = _hashlist(sorted(envitems)) envhash = _hashlist(sorted(envitems))
return sectionhash[:6] + envhash[:6] return sectionhash[:6] + envhash[:6]
def _getmtimepaths(ui): def _getmtimepaths(ui):
"""get a list of paths that should be checked to detect change """get a list of paths that should be checked to detect change
def __init__(self, in_, out, channel): def __init__(self, in_, out, channel):
self.in_ = in_ self.in_ = in_
self.out = out self.out = out
self.channel = channel self.channel = channel
def __call__(self, cmd, environ, cwd=None, type=b'system', cmdtable=None): def __call__(self, cmd, environ, cwd=None, type=b'system', cmdtable=None):
args = [type, procutil.quotecommand(cmd), os.path.abspath(cwd or b'.')] args = [type, procutil.quotecommand(cmd), os.path.abspath(cwd or b'.')]
args.extend(b'%s=%s' % (k, v) for k, v in environ.iteritems()) args.extend(b'%s=%s' % (k, v) for k, v in pycompat.iteritems(environ))
data = b'\0'.join(args) data = b'\0'.join(args)
self.out.write(struct.pack(b'>cI', self.channel, len(data))) self.out.write(struct.pack(b'>cI', self.channel, len(data)))
self.out.write(data) self.out.write(data)
self.out.flush() self.out.flush()
if type == b'system': if type == b'system':
length = self.in_.read(4) length = self.in_.read(4)
(length,) = struct.unpack(b'>I', length) (length,) = struct.unpack(b'>I', length)

mercurial/cmdutil.py

# Make all of the pathnames absolute. # Make all of the pathnames absolute.
newfiles = [repo.wjoin(nf) for nf in newfiles] newfiles = [repo.wjoin(nf) for nf in newfiles]
return commitfunc(ui, repo, *newfiles, **pycompat.strkwargs(opts)) return commitfunc(ui, repo, *newfiles, **pycompat.strkwargs(opts))
finally: finally:
# 5. finally restore backed-up files # 5. finally restore backed-up files
try: try:
dirstate = repo.dirstate dirstate = repo.dirstate
for realname, tmpname in backups.iteritems(): for realname, tmpname in pycompat.iteritems(backups):
ui.debug(b'restoring %r to %r\n' % (tmpname, realname)) ui.debug(b'restoring %r to %r\n' % (tmpname, realname))
if dirstate[realname] == b'n': if dirstate[realname] == b'n':
# without normallookup, restoring timestamp # without normallookup, restoring timestamp
# may cause partially committed files # may cause partially committed files
# to be treated as unmodified # to be treated as unmodified
dirstate.normallookup(realname) dirstate.normallookup(realname)

mercurial/commands.py

b'debugcommands', b'debugcommands',
[], [],
_(b'[COMMAND]'), _(b'[COMMAND]'),
helpcategory=command.CATEGORY_HELP, helpcategory=command.CATEGORY_HELP,
norepo=True, norepo=True,
) )
def debugcommands(ui, cmd=b'', *args): def debugcommands(ui, cmd=b'', *args):
"""list all available commands and options""" """list all available commands and options"""
for cmd, vals in sorted(table.iteritems()): for cmd, vals in sorted(pycompat.iteritems(table)):
cmd = cmd.split(b'|')[0] cmd = cmd.split(b'|')[0]
opts = b', '.join([i[1] for i in vals[1]]) opts = b', '.join([i[1] for i in vals[1]])
ui.write(b'%s: %s\n' % (cmd, opts)) ui.write(b'%s: %s\n' % (cmd, opts))
@command( @command(
b'debugcomplete', b'debugcomplete',
[(b'o', b'options', None, _(b'show the command options'))], [(b'o', b'options', None, _(b'show the command options'))],
@util.cachefunc @util.cachefunc
def getbms(): def getbms():
bms = [] bms = []
if b'bookmarks' in peer.listkeys(b'namespaces'): if b'bookmarks' in peer.listkeys(b'namespaces'):
hexremoterev = hex(remoterev) hexremoterev = hex(remoterev)
bms = [ bms = [
bm bm
for bm, bmr in peer.listkeys(b'bookmarks').iteritems() for bm, bmr in pycompat.iteritems(
peer.listkeys(b'bookmarks')
)
if bmr == hexremoterev if bmr == hexremoterev
] ]
return sorted(bms) return sorted(bms)
if fm.isplain(): if fm.isplain():
if bookmarks: if bookmarks:
output.extend(getbms()) output.extend(getbms())
Returns 0 on success. Returns 0 on success.
""" """
opts = pycompat.byteskwargs(opts) opts = pycompat.byteskwargs(opts)
ui.pager(b'paths') ui.pager(b'paths')
if search: if search:
pathitems = [ pathitems = [
(name, path) (name, path)
for name, path in ui.paths.iteritems() for name, path in pycompat.iteritems(ui.paths)
if name == search if name == search
] ]
else: else:
pathitems = sorted(ui.paths.iteritems()) pathitems = sorted(pycompat.iteritems(ui.paths))
fm = ui.formatter(b'paths', opts) fm = ui.formatter(b'paths', opts)
if fm.isplain(): if fm.isplain():
hidepassword = util.hidepassword hidepassword = util.hidepassword
else: else:
hidepassword = bytes hidepassword = bytes
if ui.quiet: if ui.quiet:
namefmt = b'%s\n' namefmt = b'%s\n'
for m in marks: for m in marks:
ui.write(b' ' + m, label=b'log.bookmark') ui.write(b' ' + m, label=b'log.bookmark')
ui.write(b'\n', label=b'log.bookmark') ui.write(b'\n', label=b'log.bookmark')
status = repo.status(unknown=True) status = repo.status(unknown=True)
c = repo.dirstate.copies() c = repo.dirstate.copies()
copied, renamed = [], [] copied, renamed = [], []
for d, s in c.iteritems(): for d, s in pycompat.iteritems(c):
if s in status.removed: if s in status.removed:
status.removed.remove(s) status.removed.remove(s)
renamed.append(d) renamed.append(d)
else: else:
copied.append(d) copied.append(d)
if d in status.added: if d in status.added:
status.added.remove(d) status.added.remove(d)

mercurial/config.py

def source(self, section, item): def source(self, section, item):
return self._source.get((section, item), b"") return self._source.get((section, item), b"")
def sections(self): def sections(self):
return sorted(self._data.keys()) return sorted(self._data.keys())
def items(self, section): def items(self, section):
return list(self._data.get(section, {}).iteritems()) return list(pycompat.iteritems(self._data.get(section, {})))
def set(self, section, item, value, source=b""): def set(self, section, item, value, source=b""):
if pycompat.ispy3: if pycompat.ispy3:
assert not isinstance( assert not isinstance(
section, str section, str
), b'config section may not be unicode strings on Python 3' ), b'config section may not be unicode strings on Python 3'
assert not isinstance( assert not isinstance(
item, str item, str

mercurial/context.py

mf2 = self._buildstatusmanifest(s) mf2 = self._buildstatusmanifest(s)
modified, added = [], [] modified, added = [], []
removed = [] removed = []
clean = [] clean = []
deleted, unknown, ignored = s.deleted, s.unknown, s.ignored deleted, unknown, ignored = s.deleted, s.unknown, s.ignored
deletedset = set(deleted) deletedset = set(deleted)
d = mf1.diff(mf2, match=match, clean=listclean) d = mf1.diff(mf2, match=match, clean=listclean)
for fn, value in d.iteritems(): for fn, value in pycompat.iteritems(d):
if fn in deletedset: if fn in deletedset:
continue continue
if value is None: if value is None:
clean.append(fn) clean.append(fn)
continue continue
(node1, flag1), (node2, flag2) = value (node1, flag1), (node2, flag2) = value
if node1 is None: if node1 is None:
added.append(fn) added.append(fn)

mercurial/copies.py

import os import os
from .i18n import _ from .i18n import _
from . import ( from . import (
match as matchmod, match as matchmod,
node, node,
pathutil, pathutil,
pycompat,
util, util,
) )
from .utils import stringutil from .utils import stringutil
def _findlimit(repo, ctxa, ctxb): def _findlimit(repo, ctxa, ctxb):
""" """
Find the last revision that needs to be checked to ensure that a full Find the last revision that needs to be checked to ensure that a full
# remove copies to files that were then removed # remove copies to files that were then removed
elif k not in dst: elif k not in dst:
del t[k] del t[k]
def _chain(a, b): def _chain(a, b):
"""chain two sets of copies 'a' and 'b'""" """chain two sets of copies 'a' and 'b'"""
t = a.copy() t = a.copy()
for k, v in b.iteritems(): for k, v in pycompat.iteritems(b):
if v in t: if v in t:
t[k] = t[v] t[k] = t[v]
else: else:
t[k] = v t[k] = v
return t return t
def _tracefile(fctx, am, basemf, limit): def _tracefile(fctx, am, basemf, limit):
# Even though we're not taking copies into account, 1:n rename situations # Even though we're not taking copies into account, 1:n rename situations
# can still exist (e.g. hg cp a b; hg mv a c). In those cases we # can still exist (e.g. hg cp a b; hg mv a c). In those cases we
# arbitrarily pick one of the renames. # arbitrarily pick one of the renames.
# We don't want to pass in "match" here, since that would filter # We don't want to pass in "match" here, since that would filter
# the destination by it. Since we're reversing the copies, we want # the destination by it. Since we're reversing the copies, we want
# to filter the source instead. # to filter the source instead.
f = _forwardcopies(b, a) f = _forwardcopies(b, a)
r = {} r = {}
for k, v in sorted(f.iteritems()): for k, v in sorted(pycompat.iteritems(f)):
if match and not match(v): if match and not match(v):
continue continue
# remove copies # remove copies
if v in a: if v in a:
continue continue
r[v] = k r[v] = k
return r return r
# generate a directory move map # generate a directory move map
d1, d2 = c1.dirs(), c2.dirs() d1, d2 = c1.dirs(), c2.dirs()
invalid = set() invalid = set()
dirmove = {} dirmove = {}
# examine each file copy for a potential directory move, which is # examine each file copy for a potential directory move, which is
# when all the files in a directory are moved to a new directory # when all the files in a directory are moved to a new directory
for dst, src in fullcopy.iteritems(): for dst, src in pycompat.iteritems(fullcopy):
dsrc, ddst = pathutil.dirname(src), pathutil.dirname(dst) dsrc, ddst = pathutil.dirname(src), pathutil.dirname(dst)
if dsrc in invalid: if dsrc in invalid:
# already seen to be uninteresting # already seen to be uninteresting
continue continue
elif dsrc in d1 and ddst in d1: elif dsrc in d1 and ddst in d1:
# directory wasn't entirely moved locally # directory wasn't entirely moved locally
invalid.add(dsrc) invalid.add(dsrc)
elif dsrc in d2 and ddst in d2: elif dsrc in d2 and ddst in d2:
for i in invalid: for i in invalid:
if i in dirmove: if i in dirmove:
del dirmove[i] del dirmove[i]
del d1, d2, invalid del d1, d2, invalid
if not dirmove: if not dirmove:
return copy, {}, diverge, renamedelete, {} return copy, {}, diverge, renamedelete, {}
dirmove = {k + b"/": v + b"/" for k, v in dirmove.iteritems()} dirmove = {k + b"/": v + b"/" for k, v in pycompat.iteritems(dirmove)}
for d in dirmove: for d in dirmove:
repo.ui.debug( repo.ui.debug(
b" discovered dir src: '%s' -> dst: '%s'\n" % (d, dirmove[d]) b" discovered dir src: '%s' -> dst: '%s'\n" % (d, dirmove[d])
) )
movewithdir = {} movewithdir = {}
# check unaccounted nonoverlapping files against directory moves # check unaccounted nonoverlapping files against directory moves
if len(ctx.parents()) == 2: if len(ctx.parents()) == 2:
# To keep things simple let's not handle merges # To keep things simple let's not handle merges
repo.ui.debug(b"switching to full copytracing because of merges\n") repo.ui.debug(b"switching to full copytracing because of merges\n")
return _fullcopytracing(repo, c1, c2, base) return _fullcopytracing(repo, c1, c2, base)
changedfiles.update(ctx.files()) changedfiles.update(ctx.files())
ctx = ctx.p1() ctx = ctx.p1()
cp = _forwardcopies(base, c2) cp = _forwardcopies(base, c2)
for dst, src in cp.iteritems(): for dst, src in pycompat.iteritems(cp):
if src in m1: if src in m1:
copies[dst] = src copies[dst] = src
# file is missing if it isn't present in the destination, but is present in # file is missing if it isn't present in the destination, but is present in
# the base and present in the source. # the base and present in the source.
# Presence in the base is important to exclude added files, presence in the # Presence in the base is important to exclude added files, presence in the
# source is important to exclude removed files. # source is important to exclude removed files.
filt = lambda f: f not in m1 and f in base and f in c2 filt = lambda f: f not in m1 and f in base and f in c2
if skiprev is not None and ( if skiprev is not None and (
ctraceconfig == b'heuristics' or bctrace or bctrace is None ctraceconfig == b'heuristics' or bctrace or bctrace is None
): ):
# copytrace='off' skips this line, but not the entire function because # copytrace='off' skips this line, but not the entire function because
# the line below is O(size of the repo) during a rebase, while the rest # the line below is O(size of the repo) during a rebase, while the rest
# of the function is much faster (and is required for carrying copy # of the function is much faster (and is required for carrying copy
# metadata across the rebase anyway). # metadata across the rebase anyway).
exclude = pathcopies(repo[fromrev], repo[skiprev]) exclude = pathcopies(repo[fromrev], repo[skiprev])
for dst, src in pathcopies(repo[fromrev], repo[rev]).iteritems(): for dst, src in pycompat.iteritems(pathcopies(repo[fromrev], repo[rev])):
if dst in exclude: if dst in exclude:
continue continue
if dst in wctx: if dst in wctx:
wctx[dst].markcopied(src) wctx[dst].markcopied(src)
def computechangesetcopies(ctx): def computechangesetcopies(ctx):
"""return the copies data for a changeset """return the copies data for a changeset

mercurial/debugcommands.py

peer = hg.peer(ui, opts, path) peer = hg.peer(ui, opts, path)
caps = peer.capabilities() caps = peer.capabilities()
ui.writenoi18n(b'Main capabilities:\n') ui.writenoi18n(b'Main capabilities:\n')
for c in sorted(caps): for c in sorted(caps):
ui.write(b' %s\n' % c) ui.write(b' %s\n' % c)
b2caps = bundle2.bundle2caps(peer) b2caps = bundle2.bundle2caps(peer)
if b2caps: if b2caps:
ui.writenoi18n(b'Bundle2 capabilities:\n') ui.writenoi18n(b'Bundle2 capabilities:\n')
for key, values in sorted(b2caps.iteritems()): for key, values in sorted(pycompat.iteritems(b2caps)):
ui.write(b' %s\n' % key) ui.write(b' %s\n' % key)
for v in values: for v in values:
ui.write(b' %s\n' % v) ui.write(b' %s\n' % v)
@command(b'debugcheckstate', [], b'') @command(b'debugcheckstate', [], b'')
def debugcheckstate(ui, repo): def debugcheckstate(ui, repo):
"""validate the correctness of the current dirstate""" """validate the correctness of the current dirstate"""
if opts.get(r'nodates') is not None: if opts.get(r'nodates') is not None:
nodates = True nodates = True
datesort = opts.get(r'datesort') datesort = opts.get(r'datesort')
if datesort: if datesort:
keyfunc = lambda x: (x[1][3], x[0]) # sort by mtime, then by filename keyfunc = lambda x: (x[1][3], x[0]) # sort by mtime, then by filename
else: else:
keyfunc = None # sort by filename keyfunc = None # sort by filename
for file_, ent in sorted(repo.dirstate.iteritems(), key=keyfunc): for file_, ent in sorted(pycompat.iteritems(repo.dirstate), key=keyfunc):
if ent[3] == -1: if ent[3] == -1:
timestr = b'unset ' timestr = b'unset '
elif nodates: elif nodates:
timestr = b'set ' timestr = b'set '
else: else:
timestr = time.strftime( timestr = time.strftime(
r"%Y-%m-%d %H:%M:%S ", time.localtime(ent[3]) r"%Y-%m-%d %H:%M:%S ", time.localtime(ent[3])
) )
@command(b'debugnamecomplete', [], _(b'NAME...')) @command(b'debugnamecomplete', [], _(b'NAME...'))
def debugnamecomplete(ui, repo, *args): def debugnamecomplete(ui, repo, *args):
'''complete "names" - tags, open branch names, bookmark names''' '''complete "names" - tags, open branch names, bookmark names'''
names = set() names = set()
# since we previously only listed open branches, we will handle that # since we previously only listed open branches, we will handle that
# specially (after this for loop) # specially (after this for loop)
for name, ns in repo.names.iteritems(): for name, ns in pycompat.iteritems(repo.names):
if name != b'branches': if name != b'branches':
names.update(ns.listnames(repo)) names.update(ns.listnames(repo))
names.update( names.update(
tag tag
for (tag, heads, tip, closed) in repo.branchmap().iterbranches() for (tag, heads, tip, closed) in repo.branchmap().iterbranches()
if not closed if not closed
) )
completions = set() completions = set()
spec = spec[len(rootdir) :] spec = spec[len(rootdir) :]
fixpaths = pycompat.ossep != b'/' fixpaths = pycompat.ossep != b'/'
if fixpaths: if fixpaths:
spec = spec.replace(pycompat.ossep, b'/') spec = spec.replace(pycompat.ossep, b'/')
speclen = len(spec) speclen = len(spec)
fullpaths = opts[r'full'] fullpaths = opts[r'full']
files, dirs = set(), set() files, dirs = set(), set()
adddir, addfile = dirs.add, files.add adddir, addfile = dirs.add, files.add
for f, st in dirstate.iteritems(): for f, st in pycompat.iteritems(dirstate):
if f.startswith(spec) and st[0] in acceptable: if f.startswith(spec) and st[0] in acceptable:
if fixpaths: if fixpaths:
f = f.replace(b'/', pycompat.ossep) f = f.replace(b'/', pycompat.ossep)
if fullpaths: if fullpaths:
addfile(f) addfile(f)
continue continue
s = f.find(pycompat.ossep, speclen) s = f.find(pycompat.ossep, speclen)
if s >= 0: if s >= 0:
b'old': old, b'old': old,
b'new': new, b'new': new,
}, },
).result() ).result()
ui.status(pycompat.bytestr(r) + b'\n') ui.status(pycompat.bytestr(r) + b'\n')
return not r return not r
else: else:
for k, v in sorted(target.listkeys(namespace).iteritems()): for k, v in sorted(pycompat.iteritems(target.listkeys(namespace))):
ui.write( ui.write(
b"%s\t%s\n" % (stringutil.escapestr(k), stringutil.escapestr(v)) b"%s\t%s\n" % (stringutil.escapestr(k), stringutil.escapestr(v))
) )
@command(b'debugpvec', [], _(b'A B')) @command(b'debugpvec', [], _(b'A B'))
def debugpvec(ui, repo, a, b=None): def debugpvec(ui, repo, a, b=None):
ca = scmutil.revsingle(repo, a) ca = scmutil.revsingle(repo, a)
norepo=True, norepo=True,
) )
def debugwireargs(ui, repopath, *vals, **opts): def debugwireargs(ui, repopath, *vals, **opts):
opts = pycompat.byteskwargs(opts) opts = pycompat.byteskwargs(opts)
repo = hg.peer(ui, opts, repopath) repo = hg.peer(ui, opts, repopath)
for opt in cmdutil.remoteopts: for opt in cmdutil.remoteopts:
del opts[opt[1]] del opts[opt[1]]
args = {} args = {}
for k, v in opts.iteritems(): for k, v in pycompat.iteritems(opts):
if v: if v:
args[k] = v args[k] = v
args = pycompat.strkwargs(args) args = pycompat.strkwargs(args)
# run twice to check that we don't mess up the stream for the next command # run twice to check that we don't mess up the stream for the next command
res1 = repo.debugwireargs(*vals, **args) res1 = repo.debugwireargs(*vals, **args)
res2 = repo.debugwireargs(*vals, **args) res2 = repo.debugwireargs(*vals, **args)
ui.write(b"%s\n" % res1) ui.write(b"%s\n" % res1)
if res1 != res2: if res1 != res2:

mercurial/dirstate.py

def __contains__(self, key): def __contains__(self, key):
return key in self._map return key in self._map
def __iter__(self): def __iter__(self):
return iter(sorted(self._map)) return iter(sorted(self._map))
def items(self): def items(self):
return self._map.iteritems() return pycompat.iteritems(self._map)
iteritems = items iteritems = items
def parents(self): def parents(self):
return [self._validate(p) for p in self._pl] return [self._validate(p) for p in self._pl]
def p1(self): def p1(self):
return self._validate(self._pl[0]) return self._validate(self._pl[0])
Category is a unique identifier to allow overwriting an old callback Category is a unique identifier to allow overwriting an old callback
with a newer callback. with a newer callback.
""" """
self._plchangecallbacks[category] = callback self._plchangecallbacks[category] = callback
def _writedirstate(self, st): def _writedirstate(self, st):
# notify callbacks about parents change # notify callbacks about parents change
if self._origpl is not None and self._origpl != self._pl: if self._origpl is not None and self._origpl != self._pl:
for c, callback in sorted(self._plchangecallbacks.iteritems()): for c, callback in sorted(
pycompat.iteritems(self._plchangecallbacks)
):
callback(self, self._origpl, self._pl) callback(self, self._origpl, self._pl)
self._origpl = None self._origpl = None
# use the modification time of the newly created temporary file as the # use the modification time of the newly created temporary file as the
# filesystem's notion of 'now' # filesystem's notion of 'now'
now = util.fstat(st)[stat.ST_MTIME] & _rangemask now = util.fstat(st)[stat.ST_MTIME] & _rangemask
# enough 'delaywrite' prevents 'pack_dirstate' from dropping # enough 'delaywrite' prevents 'pack_dirstate' from dropping
# timestamp of each entries in dirstate, because of 'now > mtime' # timestamp of each entries in dirstate, because of 'now > mtime'
delaywrite = self._ui.configint(b'debug', b'dirstate.delaywrite') delaywrite = self._ui.configint(b'debug', b'dirstate.delaywrite')
if delaywrite > 0: if delaywrite > 0:
# do we have any files to delay for? # do we have any files to delay for?
items = self._map.iteritems() items = pycompat.iteritems(self._map)
for f, e in items: for f, e in items:
if e[0] == b'n' and e[3] == now: if e[0] == b'n' and e[3] == now:
import time # to avoid useless import import time # to avoid useless import
# rather than sleep n seconds, sleep until the next # rather than sleep n seconds, sleep until the next
# multiple of n seconds # multiple of n seconds
clock = time.time() clock = time.time()
start = int(clock) - (int(clock) % delaywrite) start = int(clock) - (int(clock) % delaywrite)
# Case insensitive filesystems cannot rely on lstat() failing to detect # Case insensitive filesystems cannot rely on lstat() failing to detect
# a case-only rename. Prune the stat object for any file that does not # a case-only rename. Prune the stat object for any file that does not
# match the case in the filesystem, if there are multiple files that # match the case in the filesystem, if there are multiple files that
# normalize to the same path. # normalize to the same path.
if match.isexact() and self._checkcase: if match.isexact() and self._checkcase:
normed = {} normed = {}
for f, st in results.iteritems(): for f, st in pycompat.iteritems(results):
if st is None: if st is None:
continue continue
nc = util.normcase(f) nc = util.normcase(f)
paths = normed.get(nc) paths = normed.get(nc)
if paths is None: if paths is None:
paths = set() paths = set()
normed[nc] = paths normed[nc] = paths
paths.add(f) paths.add(f)
for norm, paths in normed.iteritems(): for norm, paths in pycompat.iteritems(normed):
if len(paths) > 1: if len(paths) > 1:
for path in paths: for path in paths:
folded = self._discoverpath( folded = self._discoverpath(
path, norm, True, None, self._map.dirfoldmap path, norm, True, None, self._map.dirfoldmap
) )
if path != folded: if path != folded:
results[path] = None results[path] = None
copymap = self._map.copymap copymap = self._map.copymap
lastnormaltime = self._lastnormaltime lastnormaltime = self._lastnormaltime
# We need to do full walks when either # We need to do full walks when either
# - we're listing all clean files, or # - we're listing all clean files, or
# - match.traversedir does something, because match.traversedir should # - match.traversedir does something, because match.traversedir should
# be called for every dir in the working dir # be called for every dir in the working dir
full = listclean or match.traversedir is not None full = listclean or match.traversedir is not None
for fn, st in self.walk( for fn, st in pycompat.iteritems(
match, subrepos, listunknown, listignored, full=full self.walk(match, subrepos, listunknown, listignored, full=full)
).iteritems(): ):
if not dcontains(fn): if not dcontains(fn):
if (listignored or mexact(fn)) and dirignore(fn): if (listignored or mexact(fn)) and dirignore(fn):
if listignored: if listignored:
iadd(fn) iadd(fn)
else: else:
uadd(fn) uadd(fn)
continue continue
util.clearcachedproperty(self, b"_dirs") util.clearcachedproperty(self, b"_dirs")
util.clearcachedproperty(self, b"_alldirs") util.clearcachedproperty(self, b"_alldirs")
util.clearcachedproperty(self, b"filefoldmap") util.clearcachedproperty(self, b"filefoldmap")
util.clearcachedproperty(self, b"dirfoldmap") util.clearcachedproperty(self, b"dirfoldmap")
util.clearcachedproperty(self, b"nonnormalset") util.clearcachedproperty(self, b"nonnormalset")
util.clearcachedproperty(self, b"otherparentset") util.clearcachedproperty(self, b"otherparentset")
def items(self): def items(self):
return self._map.iteritems() return pycompat.iteritems(self._map)
# forward for python2,3 compat # forward for python2,3 compat
iteritems = items iteritems = items
def __len__(self): def __len__(self):
return len(self._map) return len(self._map)
def __iter__(self): def __iter__(self):
def nonnormalentries(self): def nonnormalentries(self):
'''Compute the nonnormal dirstate entries from the dmap''' '''Compute the nonnormal dirstate entries from the dmap'''
try: try:
return parsers.nonnormalotherparententries(self._map) return parsers.nonnormalotherparententries(self._map)
except AttributeError: except AttributeError:
nonnorm = set() nonnorm = set()
otherparent = set() otherparent = set()
for fname, e in self._map.iteritems(): for fname, e in pycompat.iteritems(self._map):
if e[0] != b'n' or e[3] == -1: if e[0] != b'n' or e[3] == -1:
nonnorm.add(fname) nonnorm.add(fname)
if e[0] == b'n' and e[2] == -2: if e[0] == b'n' and e[2] == -2:
otherparent.add(fname) otherparent.add(fname)
return nonnorm, otherparent return nonnorm, otherparent
@propertycache @propertycache
def filefoldmap(self): def filefoldmap(self):
"""Returns a dictionary mapping normalized case paths to their """Returns a dictionary mapping normalized case paths to their
non-normalized versions. non-normalized versions.
""" """
try: try:
makefilefoldmap = parsers.make_file_foldmap makefilefoldmap = parsers.make_file_foldmap
except AttributeError: except AttributeError:
pass pass
else: else:
return makefilefoldmap( return makefilefoldmap(
self._map, util.normcasespec, util.normcasefallback self._map, util.normcasespec, util.normcasefallback
) )
f = {} f = {}
normcase = util.normcase normcase = util.normcase
for name, s in self._map.iteritems(): for name, s in pycompat.iteritems(self._map):
if s[0] != b'r': if s[0] != b'r':
f[normcase(name)] = name f[normcase(name)] = name
f[b'.'] = b'.' # prevents useless util.fspath() invocation f[b'.'] = b'.' # prevents useless util.fspath() invocation
return f return f
def hastrackeddir(self, d): def hastrackeddir(self, d):
""" """
Returns True if the dirstate contains a tracked (not removed) file Returns True if the dirstate contains a tracked (not removed) file

mercurial/discovery.py

short, short,
) )
from . import ( from . import (
bookmarks, bookmarks,
branchmap, branchmap,
error, error,
phases, phases,
pycompat,
scmutil, scmutil,
setdiscovery, setdiscovery,
treediscovery, treediscovery,
util, util,
) )
def findcommonincoming(repo, remote, heads=None, force=False, ancestorsof=None): def findcommonincoming(repo, remote, heads=None, force=False, ancestorsof=None):
missingctx.add(ctx) missingctx.add(ctx)
branches.add(ctx.branch()) branches.add(ctx.branch())
with remote.commandexecutor() as e: with remote.commandexecutor() as e:
remotemap = e.callcommand(b'branchmap', {}).result() remotemap = e.callcommand(b'branchmap', {}).result()
knownnode = cl.hasnode # do not use nodemap until it is filtered knownnode = cl.hasnode # do not use nodemap until it is filtered
# A. register remote heads of branches which are in outgoing set # A. register remote heads of branches which are in outgoing set
for branch, heads in remotemap.iteritems(): for branch, heads in pycompat.iteritems(remotemap):
# don't add head info about branches which we don't have locally # don't add head info about branches which we don't have locally
if branch not in branches: if branch not in branches:
continue continue
known = [] known = []
unsynced = [] unsynced = []
for h in heads: for h in heads:
if knownnode(h): if knownnode(h):
known.append(h) known.append(h)
else: else:
unsynced.append(h) unsynced.append(h)
headssum[branch] = (known, list(known), unsynced) headssum[branch] = (known, list(known), unsynced)
# B. add new branch data # B. add new branch data
for branch in branches: for branch in branches:
if branch not in headssum: if branch not in headssum:
headssum[branch] = (None, [], []) headssum[branch] = (None, [], [])
# C. Update newmap with outgoing changes. # C. Update newmap with outgoing changes.
# This will possibly add new heads and remove existing ones. # This will possibly add new heads and remove existing ones.
newmap = branchmap.remotebranchcache( newmap = branchmap.remotebranchcache(
(branch, heads[1]) (branch, heads[1])
for branch, heads in headssum.iteritems() for branch, heads in pycompat.iteritems(headssum)
if heads[0] is not None if heads[0] is not None
) )
newmap.update(repo, (ctx.rev() for ctx in missingctx)) newmap.update(repo, (ctx.rev() for ctx in missingctx))
for branch, newheads in newmap.iteritems(): for branch, newheads in pycompat.iteritems(newmap):
headssum[branch][1][:] = newheads headssum[branch][1][:] = newheads
for branch, items in headssum.iteritems(): for branch, items in pycompat.iteritems(headssum):
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 = set(torev(h) for h in outgoing.missingheads)
futureheads |= set(torev(h) for h in outgoing.commonheads) futureheads |= set(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(headssum.iteritems()): 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,
sorted(result[1]), sorted(result[1]),
) )
return return
if remote.capable(b'branchmap'): if remote.capable(b'branchmap'):
headssum = _headssummary(pushop) headssum = _headssummary(pushop)
else: else:
headssum = _oldheadssummary(repo, remoteheads, outgoing, inc) headssum = _oldheadssummary(repo, remoteheads, outgoing, inc)
pushop.pushbranchmap = headssum pushop.pushbranchmap = headssum
newbranches = [ newbranches = [
branch for branch, heads in headssum.iteritems() if heads[0] is None branch
for branch, heads in pycompat.iteritems(headssum)
if heads[0] is None
] ]
# 1. Check for new branches on the remote. # 1. Check for new branches on the remote.
if newbranches and not newbranch: # new branch requires --new-branch if newbranches and not newbranch: # new branch requires --new-branch
branchnames = b', '.join(sorted(newbranches)) branchnames = b', '.join(sorted(newbranches))
# Calculate how many of the new branches are closed branches # Calculate how many of the new branches are closed branches
closedbranches = set() closedbranches = set()
for tag, heads, tip, isclosed in repo.branchmap().iterbranches(): for tag, heads, tip, isclosed in repo.branchmap().iterbranches():
if isclosed: if isclosed:
# 2. Find heads that we need not warn about # 2. Find heads that we need not warn about
nowarnheads = _nowarnheads(pushop) nowarnheads = _nowarnheads(pushop)
# 3. Check for new heads. # 3. Check for new heads.
# If there are more heads after the push than before, a suitable # If there are more heads after the push than before, a suitable
# error message, depending on unsynced status, is displayed. # error message, depending on unsynced status, is displayed.
errormsg = None errormsg = None
for branch, heads in sorted(headssum.iteritems()): for branch, heads in sorted(pycompat.iteritems(headssum)):
remoteheads, newheads, unsyncedheads, discardedheads = heads remoteheads, newheads, unsyncedheads, discardedheads = heads
# add unsynced data # add unsynced data
if remoteheads is None: if remoteheads is None:
oldhs = set() oldhs = set()
else: else:
oldhs = set(remoteheads) oldhs = set(remoteheads)
oldhs.update(unsyncedheads) oldhs.update(unsyncedheads)
dhs = None # delta heads, the new heads on branch dhs = None # delta heads, the new heads on branch

mercurial/dispatch.py

self.opts = [] self.opts = []
self.help = b'' self.help = b''
self.badalias = None self.badalias = None
self.unknowncmd = False self.unknowncmd = False
self.source = source self.source = source
try: try:
aliases, entry = cmdutil.findcmd(self.name, cmdtable) aliases, entry = cmdutil.findcmd(self.name, cmdtable)
for alias, e in cmdtable.iteritems(): for alias, e in pycompat.iteritems(cmdtable):
if e is entry: if e is entry:
self.cmd = alias self.cmd = alias
break break
self.shadows = True self.shadows = True
except error.UnknownCommand: except error.UnknownCommand:
self.shadows = False self.shadows = False
if not self.definition: if not self.definition:

mercurial/exchange.py

allowunrelated = b'related' in bundler.capabilities.get( allowunrelated = b'related' in bundler.capabilities.get(
b'checkheads', () b'checkheads', ()
) )
emptyremote = pushop.pushbranchmap is None emptyremote = pushop.pushbranchmap is None
if not allowunrelated or emptyremote: if not allowunrelated or emptyremote:
bundler.newpart(b'check:heads', data=iter(pushop.remoteheads)) bundler.newpart(b'check:heads', data=iter(pushop.remoteheads))
else: else:
affected = set() affected = set()
for branch, heads in pushop.pushbranchmap.iteritems(): for branch, heads in pycompat.iteritems(pushop.pushbranchmap):
remoteheads, newheads, unsyncedheads, discardedheads = heads remoteheads, newheads, unsyncedheads, discardedheads = heads
if remoteheads is not None: if remoteheads is not None:
remote = set(remoteheads) remote = set(remoteheads)
affected |= set(discardedheads) & remote affected |= set(discardedheads) & remote
affected |= remote - set(newheads) affected |= remote - set(newheads)
if affected: if affected:
data = iter(sorted(affected)) data = iter(sorted(affected))
bundler.newpart(b'check:updated-heads', data=data) bundler.newpart(b'check:updated-heads', data=data)
b"'KEY=VALUE' or 'KEY=' format" b"'KEY=VALUE' or 'KEY=' format"
) )
raise error.Abort(msg % raw) raise error.Abort(msg % raw)
k, v = raw.split(b'=', 1) k, v = raw.split(b'=', 1)
shellvars[k] = v shellvars[k] = v
part = bundler.newpart(b'pushvars') part = bundler.newpart(b'pushvars')
for key, value in shellvars.iteritems(): for key, value in pycompat.iteritems(shellvars):
part.addparam(key, value, mandatory=False) part.addparam(key, value, mandatory=False)
def _pushbundle2(pushop): def _pushbundle2(pushop):
"""push data to the remote using bundle2 """push data to the remote using bundle2
The only currently supported type of data is changegroup but this will The only currently supported type of data is changegroup but this will
evolve in the future.""" evolve in the future."""

mercurial/exchangev2.py

rootmanifest = repo.manifestlog.getstorage(b'') rootmanifest = repo.manifestlog.getstorage(b'')
# Some manifests can be shared between changesets. Filter out revisions # Some manifests can be shared between changesets. Filter out revisions
# we already know about. # we already know about.
fetchnodes = [] fetchnodes = []
linkrevs = {} linkrevs = {}
seen = set() seen = set()
for clrev, node in sorted(manifestnodes.iteritems()): for clrev, node in sorted(pycompat.iteritems(manifestnodes)):
if node in seen: if node in seen:
continue continue
try: try:
rootmanifest.rev(node) rootmanifest.rev(node)
except error.LookupError: except error.LookupError:
fetchnodes.append(node) fetchnodes.append(node)
linkrevs[node] = clrev linkrevs[node] = clrev
b'haveparents': True, b'haveparents': True,
}, },
), ),
) )
) )
locallinkrevs[path] = { locallinkrevs[path] = {
node: linkrevs[manifestnode] node: linkrevs[manifestnode]
for node, manifestnode in nodes.iteritems() for node, manifestnode in pycompat.iteritems(nodes)
} }
for path, f in fs: for path, f in fs:
objs = f.result() objs = f.result()
# Chomp off header objects. # Chomp off header objects.
next(objs) next(objs)
for i in pycompat.xrange(overall[b'totalpaths']): for i in pycompat.xrange(overall[b'totalpaths']):
header = next(objs) header = next(objs)
path = header[b'path'] path = header[b'path']
store = repo.file(path) store = repo.file(path)
linkrevs = { linkrevs = {
fnode: manlinkrevs[mnode] fnode: manlinkrevs[mnode]
for fnode, mnode in fnodes[path].iteritems() for fnode, mnode in pycompat.iteritems(fnodes[path])
} }
def getlinkrev(node): def getlinkrev(node):
if node in linkrevs: if node in linkrevs:
return linkrevs[node] return linkrevs[node]
else: else:
return clrev(node) return clrev(node)
store.addgroup( store.addgroup(
iterrevisions(objs, header[b'totalitems'], progress), iterrevisions(objs, header[b'totalitems'], progress),
getlinkrev, getlinkrev,
weakref.proxy(tr), weakref.proxy(tr),
maybemissingparents=shallow, maybemissingparents=shallow,
) )

mercurial/extensions.py

def find(name): def find(name):
'''return module with given extension name''' '''return module with given extension name'''
mod = None mod = None
try: try:
mod = _extensions[name] mod = _extensions[name]
except KeyError: except KeyError:
for k, v in _extensions.iteritems(): for k, v in pycompat.iteritems(_extensions):
if k.endswith(b'.' + name) or k.endswith(b'/' + name): if k.endswith(b'.' + name) or k.endswith(b'/' + name):
mod = v mod = v
break break
if not mod: if not mod:
raise KeyError(name) raise KeyError(name)
return mod return mod
# attributes set by registrar.command # attributes set by registrar.command
_cmdfuncattrs = (b'norepo', b'optionalrepo', b'inferrepo') _cmdfuncattrs = (b'norepo', b'optionalrepo', b'inferrepo')
def _validatecmdtable(ui, cmdtable): def _validatecmdtable(ui, cmdtable):
"""Check if extension commands have required attributes""" """Check if extension commands have required attributes"""
for c, e in cmdtable.iteritems(): for c, e in pycompat.iteritems(cmdtable):
f = e[0] f = e[0]
missing = [a for a in _cmdfuncattrs if not util.safehasattr(f, a)] missing = [a for a in _cmdfuncattrs if not util.safehasattr(f, a)]
if not missing: if not missing:
continue continue
raise error.ProgrammingError( raise error.ProgrammingError(
b'missing attributes: %s' % b', '.join(missing), b'missing attributes: %s' % b', '.join(missing),
hint=b"use @command decorator to register '%s'" % c, hint=b"use @command decorator to register '%s'" % c,
) )
local bookmarks. local bookmarks.
""" """
extensions.wrapcommand(commands.table, 'bookmarks', exbookmarks, extensions.wrapcommand(commands.table, 'bookmarks', exbookmarks,
synopsis, docstring) synopsis, docstring)
''' '''
assert callable(wrapper) assert callable(wrapper)
aliases, entry = cmdutil.findcmd(command, table) aliases, entry = cmdutil.findcmd(command, table)
for alias, e in table.iteritems(): for alias, e in pycompat.iteritems(table):
if e is entry: if e is entry:
key = alias key = alias
break break
origfn = entry[0] origfn = entry[0]
wrap = functools.partial( wrap = functools.partial(
util.checksignature(wrapper), util.checksignature(origfn) util.checksignature(wrapper), util.checksignature(origfn)
) )
else: else:
name = e name = e
path = os.path.join(extpath, e, b'__init__.py') path = os.path.join(extpath, e, b'__init__.py')
if not os.path.exists(path): if not os.path.exists(path):
continue continue
if name in exts or name in _order or name == b'__init__': if name in exts or name in _order or name == b'__init__':
continue continue
exts[name] = path exts[name] = path
for name, path in _disabledextensions.iteritems(): for name, path in pycompat.iteritems(_disabledextensions):
# If no path was provided for a disabled extension (e.g. "color=!"), # If no path was provided for a disabled extension (e.g. "color=!"),
# don't replace the path we already found by the scan above. # don't replace the path we already found by the scan above.
if path: if path:
exts[name] = path exts[name] = path
return exts return exts
def _moduledoc(file): def _moduledoc(file):
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__ from hgext import __index__
return dict( return dict(
(name, gettext(desc)) (name, gettext(desc))
for name, desc in __index__.docs.iteritems() 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 = {}
for name, path in paths.iteritems(): for name, path in pycompat.iteritems(paths):
doc = _disabledhelp(path) doc = _disabledhelp(path)
if doc: if doc:
exts[name] = doc.splitlines()[0] exts[name] = doc.splitlines()[0]
return exts return exts
def disabledext(name): def disabledext(name):
ext = None ext = None
# first, search for an extension with the same name as the command # first, search for an extension with the same name as the command
path = paths.pop(cmd, None) path = paths.pop(cmd, None)
if path: if path:
ext = _finddisabledcmd(ui, cmd, cmd, path, strict=strict) ext = _finddisabledcmd(ui, cmd, cmd, path, strict=strict)
if not ext: if not ext:
# otherwise, interrogate each extension until there's a match # otherwise, interrogate each extension until there's a match
for name, path in paths.iteritems(): for name, path in pycompat.iteritems(paths):
ext = _finddisabledcmd(ui, cmd, name, path, strict=strict) ext = _finddisabledcmd(ui, cmd, name, path, strict=strict)
if ext: if ext:
break break
if ext: if ext:
return ext return ext
raise error.UnknownCommand(cmd) raise error.UnknownCommand(cmd)
def enabled(shortname=True): def enabled(shortname=True):
'''return a dict of {name: desc} of extensions''' '''return a dict of {name: desc} of extensions'''
exts = {} exts = {}
for ename, ext in extensions(): for ename, ext in extensions():
doc = gettext(ext.__doc__) or _(b'(no help text available)') doc = gettext(ext.__doc__) or _(b'(no help text available)')
if shortname: if shortname:
ename = ename.split(b'.')[-1] ename = ename.split(b'.')[-1]
exts[ename] = doc.splitlines()[0].strip() exts[ename] = doc.splitlines()[0].strip()
return exts return exts
def notloaded(): def notloaded():
'''return short names of extensions that failed to load''' '''return short names of extensions that failed to load'''
return [name for name, mod in _extensions.iteritems() if mod is None] return [
name for name, mod in pycompat.iteritems(_extensions) if mod is None
]
def moduleversion(module): def moduleversion(module):
'''return version information from given module as a string''' '''return version information from given module as a string'''
if util.safehasattr(module, b'getversion') and callable(module.getversion): if util.safehasattr(module, b'getversion') and callable(module.getversion):
version = module.getversion() version = module.getversion()
elif util.safehasattr(module, b'__version__'): elif util.safehasattr(module, b'__version__'):
version = module.__version__ version = module.__version__

mercurial/exthelper.py

self._repocallables.extend(other._repocallables) self._repocallables.extend(other._repocallables)
self.filesetpredicate._merge(other.filesetpredicate) self.filesetpredicate._merge(other.filesetpredicate)
self.revsetpredicate._merge(other.revsetpredicate) self.revsetpredicate._merge(other.revsetpredicate)
self.templatekeyword._merge(other.templatekeyword) self.templatekeyword._merge(other.templatekeyword)
self._commandwrappers.extend(other._commandwrappers) self._commandwrappers.extend(other._commandwrappers)
self._extcommandwrappers.extend(other._extcommandwrappers) self._extcommandwrappers.extend(other._extcommandwrappers)
self._functionwrappers.extend(other._functionwrappers) self._functionwrappers.extend(other._functionwrappers)
self.cmdtable.update(other.cmdtable) self.cmdtable.update(other.cmdtable)
for section, items in other.configtable.iteritems(): for section, items in pycompat.iteritems(other.configtable):
if section in self.configtable: if section in self.configtable:
self.configtable[section].update(items) self.configtable[section].update(items)
else: else:
self.configtable[section] = items self.configtable[section] = items
def finaluisetup(self, ui): def finaluisetup(self, ui):
"""Method to be used as the extension uisetup """Method to be used as the extension uisetup

mercurial/filemerge.py

return _filemerge( return _filemerge(
False, repo, wctx, mynode, orig, fcd, fco, fca, labels=labels False, repo, wctx, mynode, orig, fcd, fco, fca, labels=labels
) )
def loadinternalmerge(ui, extname, registrarobj): def loadinternalmerge(ui, extname, registrarobj):
"""Load internal merge tool from specified registrarobj """Load internal merge tool from specified registrarobj
""" """
for name, func in registrarobj._table.iteritems(): for name, func in pycompat.iteritems(registrarobj._table):
fullname = b':' + name fullname = b':' + name
internals[fullname] = func internals[fullname] = func
internals[b'internal:' + name] = func internals[b'internal:' + name] = func
internalsdoc[fullname] = func internalsdoc[fullname] = func
capabilities = sorted([k for k, v in func.capabilities.items() if v]) capabilities = sorted([k for k, v in func.capabilities.items() if v])
if capabilities: if capabilities:
capdesc = b" (actual capabilities: %s)" % b', '.join( capdesc = b" (actual capabilities: %s)" % b', '.join(

mercurial/fileset.py

tree = filesetlang.optimize(tree) tree = filesetlang.optimize(tree)
mctx = matchctx(ctx.p1(), ctx, badfn=badfn) mctx = matchctx(ctx.p1(), ctx, badfn=badfn)
return getmatch(mctx, tree) return getmatch(mctx, tree)
def loadpredicate(ui, extname, registrarobj): def loadpredicate(ui, extname, registrarobj):
"""Load fileset predicates from specified registrarobj """Load fileset predicates from specified registrarobj
""" """
for name, func in registrarobj._table.iteritems(): for name, func in pycompat.iteritems(registrarobj._table):
symbols[name] = func symbols[name] = func
# tell hggettext to extract docstrings from these functions: # tell hggettext to extract docstrings from these functions:
i18nfunctions = symbols.values() i18nfunctions = symbols.values()

mercurial/formatter.py

def _showitem(self): def _showitem(self):
self._data.append(self._item) self._data.append(self._item)
def _iteritems(data): def _iteritems(data):
'''iterate key-value pairs in stable order''' '''iterate key-value pairs in stable order'''
if isinstance(data, dict): if isinstance(data, dict):
return sorted(data.iteritems()) return sorted(pycompat.iteritems(data))
return data return data
class _plainconverter(object): class _plainconverter(object):
'''convert non-primitive data types to text''' '''convert non-primitive data types to text'''
storecontext = False storecontext = False

mercurial/help.py

TOPIC_CATEGORY_NONE: b'Uncategorized topics', TOPIC_CATEGORY_NONE: b'Uncategorized topics',
} }
def listexts(header, exts, indent=1, showdeprecated=False): def listexts(header, exts, indent=1, showdeprecated=False):
'''return a text listing of the given extensions''' '''return a text listing of the given extensions'''
rst = [] rst = []
if exts: if exts:
for name, desc in sorted(exts.iteritems()): for name, desc in sorted(pycompat.iteritems(exts)):
if not showdeprecated and any(w in desc for w in _exclkeywords): if not showdeprecated and any(w in desc for w in _exclkeywords):
continue continue
rst.append(b'%s:%s: %s\n' % (b' ' * indent, name, desc)) rst.append(b'%s:%s: %s\n' % (b' ' * indent, name, desc))
if rst: if rst:
rst.insert(0, b'\n%s\n\n' % header) rst.insert(0, b'\n%s\n\n' % header)
return rst return rst
if ( if (
sum(map(lowercontains, names)) sum(map(lowercontains, names))
or lowercontains(header) or lowercontains(header)
or (callable(doc) and lowercontains(doc(ui))) or (callable(doc) and lowercontains(doc(ui)))
): ):
name = names[0] name = names[0]
if not filtertopic(ui, name): if not filtertopic(ui, name):
results[b'topics'].append((names[0], header)) results[b'topics'].append((names[0], header))
for cmd, entry in commands.table.iteritems(): for cmd, entry in pycompat.iteritems(commands.table):
if len(entry) == 3: if len(entry) == 3:
summary = entry[2] summary = entry[2]
else: else:
summary = b'' summary = b''
# translate docs *before* searching there # translate docs *before* searching there
func = entry[0] func = entry[0]
docs = _(pycompat.getdoc(func)) or b'' docs = _(pycompat.getdoc(func)) or b''
if kw in cmd or lowercontains(summary) or lowercontains(docs): if kw in cmd or lowercontains(summary) or lowercontains(docs):
doclines = docs.splitlines() doclines = docs.splitlines()
if doclines: if doclines:
summary = doclines[0] summary = doclines[0]
cmdname = cmdutil.parsealiases(cmd)[0] cmdname = cmdutil.parsealiases(cmd)[0]
if filtercmd(ui, cmdname, func, kw, docs): if filtercmd(ui, cmdname, func, kw, docs):
continue continue
results[b'commands'].append((cmdname, summary)) results[b'commands'].append((cmdname, summary))
for name, docs in itertools.chain( for name, docs in itertools.chain(
extensions.enabled(False).iteritems(), extensions.disabled().iteritems() pycompat.iteritems(extensions.enabled(False)),
pycompat.iteritems(extensions.disabled()),
): ):
if not docs: if not docs:
continue continue
name = name.rpartition(b'.')[-1] name = name.rpartition(b'.')[-1]
if lowercontains(name) or lowercontains(docs): if lowercontains(name) or lowercontains(docs):
# extension docs are already translated # extension docs are already translated
results[b'extensions'].append((name, docs.splitlines()[0])) results[b'extensions'].append((name, docs.splitlines()[0]))
try: try:
mod = extensions.load(ui, name, b'') mod = extensions.load(ui, name, b'')
except ImportError: except ImportError:
# debug message would be printed in extensions.load() # debug message would be printed in extensions.load()
continue continue
for cmd, entry in getattr(mod, 'cmdtable', {}).iteritems(): for cmd, entry in pycompat.iteritems(getattr(mod, 'cmdtable', {})):
if kw in cmd or (len(entry) > 2 and lowercontains(entry[2])): if kw in cmd or (len(entry) > 2 and lowercontains(entry[2])):
cmdname = cmdutil.parsealiases(cmd)[0] cmdname = cmdutil.parsealiases(cmd)[0]
func = entry[0] func = entry[0]
cmddoc = pycompat.getdoc(func) cmddoc = pycompat.getdoc(func)
if cmddoc: if cmddoc:
cmddoc = gettext(cmddoc).splitlines()[0] cmddoc = gettext(cmddoc).splitlines()[0]
else: else:
cmddoc = _(b'(no help text available)') cmddoc = _(b'(no help text available)')
def helplist(select=None, **opts): def helplist(select=None, **opts):
# Category -> list of commands # Category -> list of commands
cats = {} cats = {}
# Command -> short description # Command -> short description
h = {} h = {}
# Command -> string showing synonyms # Command -> string showing synonyms
syns = {} syns = {}
for c, e in commands.table.iteritems(): for c, e in pycompat.iteritems(commands.table):
fs = cmdutil.parsealiases(c) fs = cmdutil.parsealiases(c)
f = fs[0] f = fs[0]
syns[f] = b', '.join(fs) syns[f] = b', '.join(fs)
func = e[0] func = e[0]
if select and not select(f): if select and not select(f):
continue continue
doc = pycompat.getdoc(func) doc = pycompat.getdoc(func)
if filtercmd(ui, f, func, name, doc): if filtercmd(ui, f, func, name, doc):

mercurial/hgweb/hgweb_mod.py

req.qsparams.add(b'file', a) req.qsparams.add(b'file', a)
ua = req.headers.get(b'User-Agent', b'') ua = req.headers.get(b'User-Agent', b'')
if cmd == b'rev' and b'mercurial' in ua: if cmd == b'rev' and b'mercurial' in ua:
req.qsparams[b'style'] = b'raw' req.qsparams[b'style'] = b'raw'
if cmd == b'archive': if cmd == b'archive':
fn = req.qsparams[b'node'] fn = req.qsparams[b'node']
for type_, spec in webutil.archivespecs.iteritems(): for type_, spec in pycompat.iteritems(webutil.archivespecs):
ext = spec[2] ext = spec[2]
if fn.endswith(ext): if fn.endswith(ext):
req.qsparams[b'node'] = fn[: -len(ext)] req.qsparams[b'node'] = fn[: -len(ext)]
req.qsparams[b'type'] = type_ req.qsparams[b'type'] = type_
else: else:
cmd = req.qsparams.get(b'cmd', b'') cmd = req.qsparams.get(b'cmd', b'')
# process the web interface request # process the web interface request

mercurial/hgweb/hgwebdir_mod.py

for virtualrepo in _virtualdirs(): for virtualrepo in _virtualdirs():
real = repos.get(virtualrepo) real = repos.get(virtualrepo)
if real: if real:
# Re-parse the WSGI environment to take into account our # Re-parse the WSGI environment to take into account our
# repository path component. # repository path component.
uenv = req.rawenv uenv = req.rawenv
if pycompat.ispy3: if pycompat.ispy3:
uenv = { uenv = {
k.decode('latin1'): v for k, v in uenv.iteritems() k.decode('latin1'): v
for k, v in pycompat.iteritems(uenv)
} }
req = requestmod.parserequestfromenv( req = requestmod.parserequestfromenv(
uenv, uenv,
reponame=virtualrepo, reponame=virtualrepo,
altbaseurl=self.ui.config(b'web', b'baseurl'), altbaseurl=self.ui.config(b'web', b'baseurl'),
# Reuse wrapped body file object otherwise state # Reuse wrapped body file object otherwise state
# tracking can get confused. # tracking can get confused.
bodyfh=req.bodyfh, bodyfh=req.bodyfh,

mercurial/hgweb/request.py

vals = self._items[key] vals = self._items[key]
if len(vals) > 1: if len(vals) > 1:
raise KeyError(b'multiple values for %r' % key) raise KeyError(b'multiple values for %r' % key)
return vals[0] return vals[0]
def asdictoflists(self): def asdictoflists(self):
return {k: list(v) for k, v in self._items.iteritems()} return {k: list(v) for k, v in pycompat.iteritems(self._items)}
@attr.s(frozen=True) @attr.s(frozen=True)
class parsedrequest(object): class parsedrequest(object):
"""Represents a parsed WSGI request. """Represents a parsed WSGI request.
Contains both parsed parameters as well as a handle on the input stream. Contains both parsed parameters as well as a handle on the input stream.
""" """
# TODO enable this once we fix internal violations. # TODO enable this once we fix internal violations.
# wsgiref.validate.check_environ(env) # wsgiref.validate.check_environ(env)
# PEP-0333 states that environment keys and values are native strings # PEP-0333 states that environment keys and values are native strings
# (bytes on Python 2 and str on Python 3). The code points for the Unicode # (bytes on Python 2 and str on Python 3). The code points for the Unicode
# strings on Python 3 must be between \00000-\000FF. We deal with bytes # strings on Python 3 must be between \00000-\000FF. We deal with bytes
# in Mercurial, so mass convert string keys and values to bytes. # in Mercurial, so mass convert string keys and values to bytes.
if pycompat.ispy3: if pycompat.ispy3:
env = {k.encode('latin-1'): v for k, v in env.iteritems()} env = {k.encode('latin-1'): v for k, v in pycompat.iteritems(env)}
env = { env = {
k: v.encode('latin-1') if isinstance(v, str) else v k: v.encode('latin-1') if isinstance(v, str) else v
for k, v in env.iteritems() for k, v in pycompat.iteritems(env)
} }
# Some hosting solutions are emulating hgwebdir, and dispatching directly # Some hosting solutions are emulating hgwebdir, and dispatching directly
# to an hgweb instance using this environment variable. This was always # to an hgweb instance using this environment variable. This was always
# checked prior to d7fd203e36cc; keep doing so to avoid breaking them. # checked prior to d7fd203e36cc; keep doing so to avoid breaking them.
if not reponame: if not reponame:
reponame = env.get(b'REPO_NAME') reponame = env.get(b'REPO_NAME')
qsparams = multidict() qsparams = multidict()
for k, v in util.urlreq.parseqsl(querystring, keep_blank_values=True): for k, v in util.urlreq.parseqsl(querystring, keep_blank_values=True):
qsparams.add(k, v) qsparams.add(k, v)
# HTTP_* keys contain HTTP request headers. The Headers structure should # HTTP_* keys contain HTTP request headers. The Headers structure should
# perform case normalization for us. We just rewrite underscore to dash # perform case normalization for us. We just rewrite underscore to dash
# so keys match what likely went over the wire. # so keys match what likely went over the wire.
headers = [] headers = []
for k, v in env.iteritems(): for k, v in pycompat.iteritems(env):
if k.startswith(b'HTTP_'): if k.startswith(b'HTTP_'):
headers.append((k[len(b'HTTP_') :].replace(b'_', b'-'), v)) headers.append((k[len(b'HTTP_') :].replace(b'_', b'-'), v))
from . import wsgiheaders # avoid cycle from . import wsgiheaders # avoid cycle
headers = wsgiheaders.Headers(headers) headers = wsgiheaders.Headers(headers)
# This is kind of a lie because the HTTP header wasn't explicitly # This is kind of a lie because the HTTP header wasn't explicitly

mercurial/hgweb/webcommands.py

dirs = {} dirs = {}
parity = paritygen(web.stripecount) parity = paritygen(web.stripecount)
if path and path[-1:] != b"/": if path and path[-1:] != b"/":
path += b"/" path += b"/"
l = len(path) l = len(path)
abspath = b"/" + path abspath = b"/" + path
for full, n in mf.iteritems(): for full, n in pycompat.iteritems(mf):
# the virtual path (working copy path) used for the full # the virtual path (working copy path) used for the full
# (repository) path # (repository) path
f = decodepath(full) f = decodepath(full)
if f[:l] != path: if f[:l] != path:
continue continue
remain = f[l:] remain = f[l:]
elements = remain.split(b'/') elements = remain.split(b'/')
def topics(context): def topics(context):
for h in helpmod.helptable: for h in helpmod.helptable:
entries, summary, _doc = h[0:3] entries, summary, _doc = h[0:3]
yield {b'topic': entries[0], b'summary': summary} yield {b'topic': entries[0], b'summary': summary}
early, other = [], [] early, other = [], []
primary = lambda s: s.partition(b'|')[0] primary = lambda s: s.partition(b'|')[0]
for c, e in commands.table.iteritems(): for c, e in pycompat.iteritems(commands.table):
doc = _getdoc(e) doc = _getdoc(e)
if b'DEPRECATED' in doc or c.startswith(b'debug'): if b'DEPRECATED' in doc or c.startswith(b'debug'):
continue continue
cmd = primary(c) cmd = primary(c)
if getattr(e[0], 'helpbasic', False): if getattr(e[0], 'helpbasic', False):
early.append((cmd, doc)) early.append((cmd, doc))
else: else:
other.append((cmd, doc)) other.append((cmd, doc))

mercurial/hgweb/webutil.py

) )
) )
def archivelist(ui, nodeid, url=None): def archivelist(ui, nodeid, url=None):
allowed = ui.configlist(b'web', b'allow-archive', untrusted=True) allowed = ui.configlist(b'web', b'allow-archive', untrusted=True)
archives = [] archives = []
for typ, spec in archivespecs.iteritems(): for typ, spec in pycompat.iteritems(archivespecs):
if typ in allowed or ui.configbool( if typ in allowed or ui.configbool(
b'web', b'allow' + typ, untrusted=True b'web', b'allow' + typ, untrusted=True
): ):
archives.append( archives.append(
{ {
b'type': typ, b'type': typ,
b'extension': spec[2], b'extension': spec[2],
b'node': nodeid, b'node': nodeid,
raise error.ParseError(_(b'not comparable')) raise error.ParseError(_(b'not comparable'))
def filter(self, context, mapping, select): def filter(self, context, mapping, select):
# implement if necessary # implement if necessary
raise error.ParseError(_(b'not filterable')) raise error.ParseError(_(b'not filterable'))
def itermaps(self, context): def itermaps(self, context):
separator = self._start separator = self._start
for key, value in sorted(self._vars.iteritems()): for key, value in sorted(pycompat.iteritems(self._vars)):
yield { yield {
b'name': key, b'name': key,
b'value': pycompat.bytestr(value), b'value': pycompat.bytestr(value),
b'separator': separator, b'separator': separator,
} }
separator = b'&' separator = b'&'
def join(self, context, mapping, sep): def join(self, context, mapping, sep):

mercurial/hgweb/wsgicgi.py

from . import common from . import common
def launch(application): def launch(application):
procutil.setbinary(procutil.stdin) procutil.setbinary(procutil.stdin)
procutil.setbinary(procutil.stdout) procutil.setbinary(procutil.stdout)
environ = dict(os.environ.iteritems()) # re-exports environ = dict(pycompat.iteritems(os.environ)) # re-exports
environ.setdefault(r'PATH_INFO', b'') environ.setdefault(r'PATH_INFO', b'')
if environ.get(r'SERVER_SOFTWARE', r'').startswith(r'Microsoft-IIS'): if environ.get(r'SERVER_SOFTWARE', r'').startswith(r'Microsoft-IIS'):
# IIS includes script_name in PATH_INFO # IIS includes script_name in PATH_INFO
scriptname = environ[r'SCRIPT_NAME'] scriptname = environ[r'SCRIPT_NAME']
if environ[r'PATH_INFO'].startswith(scriptname): if environ[r'PATH_INFO'].startswith(scriptname):
environ[r'PATH_INFO'] = environ[r'PATH_INFO'][len(scriptname) :] environ[r'PATH_INFO'] = environ[r'PATH_INFO'][len(scriptname) :]
stdin = procutil.stdin stdin = procutil.stdin

mercurial/hook.py

if repo is not None: if repo is not None:
tr = repo.currenttransaction() tr = repo.currenttransaction()
repo.dirstate.write(tr) repo.dirstate.write(tr)
if tr and tr.writepending(): if tr and tr.writepending():
env[b'HG_PENDING'] = repo.root env[b'HG_PENDING'] = repo.root
env[b'HG_HOOKTYPE'] = htype env[b'HG_HOOKTYPE'] = htype
env[b'HG_HOOKNAME'] = name env[b'HG_HOOKNAME'] = name
for k, v in args.iteritems(): for k, v in pycompat.iteritems(args):
if callable(v): if callable(v):
v = v() v = v()
if isinstance(v, (dict, list)): if isinstance(v, (dict, list)):
v = stringutil.pprint(v) v = stringutil.pprint(v)
env[b'HG_' + k.upper()] = v env[b'HG_' + k.upper()] = v
if ui.configbool(b'hooks', b'tonative.%s' % name, False): if ui.configbool(b'hooks', b'tonative.%s' % name, False):
oldcmd = cmd oldcmd = cmd

mercurial/httpconnection.py

val = util.expandpath(val) val = util.expandpath(val)
gdict[setting] = val gdict[setting] = val
# Find the best match # Find the best match
scheme, hostpath = uri.split(b'://', 1) scheme, hostpath = uri.split(b'://', 1)
bestuser = None bestuser = None
bestlen = 0 bestlen = 0
bestauth = None bestauth = None
for group, auth in groups.iteritems(): for group, auth in pycompat.iteritems(groups):
if user and user != auth.get(b'username', user): if user and user != auth.get(b'username', user):
# If a username was set in the URI, the entry username # If a username was set in the URI, the entry username
# must either match it or be unset # must either match it or be unset
continue continue
prefix = auth.get(b'prefix') prefix = auth.get(b'prefix')
if not prefix: if not prefix:
continue continue

mercurial/keepalive.py

host is the host:port spec, as in 'www.cnn.com:8080' as passed in. host is the host:port spec, as in 'www.cnn.com:8080' as passed in.
no error occurs if there is no connection to that host.""" no error occurs if there is no connection to that host."""
for h in self._cm.get_all(host): for h in self._cm.get_all(host):
self._cm.remove(h) self._cm.remove(h)
h.close() h.close()
def close_all(self): def close_all(self):
"""close all open connections""" """close all open connections"""
for host, conns in self._cm.get_all().iteritems(): for host, conns in pycompat.iteritems(self._cm.get_all()):
for h in conns: for h in conns:
self._cm.remove(h) self._cm.remove(h)
h.close() h.close()
def _request_closed(self, request, host, connection): def _request_closed(self, request, host, connection):
"""tells us that this request is now closed and that the """tells us that this request is now closed and that the
connection is ready for another request""" connection is ready for another request"""
self._cm.set_ready(connection, True) self._cm.set_ready(connection, True)

mercurial/localrepo.py

def tags(self): def tags(self):
'''return a mapping of tag to node''' '''return a mapping of tag to node'''
t = {} t = {}
if self.changelog.filteredrevs: if self.changelog.filteredrevs:
tags, tt = self._findtags() tags, tt = self._findtags()
else: else:
tags = self._tagscache.tags tags = self._tagscache.tags
rev = self.changelog.rev rev = self.changelog.rev
for k, v in tags.iteritems(): for k, v in pycompat.iteritems(tags):
try: try:
# ignore tags to unknown nodes # ignore tags to unknown nodes
rev(v) rev(v)
t[k] = v t[k] = v
except (error.LookupError, ValueError): except (error.LookupError, ValueError):
pass pass
return t return t
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 alltags.iteritems(): 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 = dict(
[ [
(encoding.tolocal(name), value) (encoding.tolocal(name), value)
for (name, value) in tagtypes.iteritems() 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
None : tag does not exist None : tag does not exist
''' '''
return self._tagscache.tagtypes.get(tagname) return self._tagscache.tagtypes.get(tagname)
def tagslist(self): def tagslist(self):
'''return a list of tags ordered by revision''' '''return a list of tags ordered by revision'''
if not self._tagscache.tagslist: if not self._tagscache.tagslist:
l = [] l = []
for t, n in self.tags().iteritems(): for t, n in pycompat.iteritems(self.tags()):
l.append((self.changelog.rev(n), t, n)) l.append((self.changelog.rev(n), t, n))
self._tagscache.tagslist = [(t, n) for r, t, n in sorted(l)] self._tagscache.tagslist = [(t, n) for r, t, n in sorted(l)]
return self._tagscache.tagslist return self._tagscache.tagslist
def nodetags(self, node): def nodetags(self, node):
'''return the tags associated with a node''' '''return the tags associated with a node'''
if not self._tagscache.nodetagscache: if not self._tagscache.nodetagscache:
nodetagscache = {} nodetagscache = {}
for t, n in self._tagscache.tags.iteritems(): for t, n in pycompat.iteritems(self._tagscache.tags):
nodetagscache.setdefault(n, []).append(t) nodetagscache.setdefault(n, []).append(t)
for tags in pycompat.itervalues(nodetagscache): for tags in pycompat.itervalues(nodetagscache):
tags.sort() tags.sort()
self._tagscache.nodetagscache = nodetagscache self._tagscache.nodetagscache = nodetagscache
return self._tagscache.nodetagscache.get(node, []) return self._tagscache.nodetagscache.get(node, [])
def nodebookmarks(self, node): def nodebookmarks(self, node):
"""return the list of bookmarks pointing to the specified node""" """return the list of bookmarks pointing to the specified node"""
if filter not in self._filterpats: if filter not in self._filterpats:
l = [] l = []
for pat, cmd in self.ui.configitems(filter): for pat, cmd in self.ui.configitems(filter):
if cmd == b'!': if cmd == b'!':
continue continue
mf = matchmod.match(self.root, b'', [pat]) mf = matchmod.match(self.root, b'', [pat])
fn = None fn = None
params = cmd params = cmd
for name, filterfn in self._datafilters.iteritems(): for name, filterfn in pycompat.iteritems(self._datafilters):
if cmd.startswith(name): if cmd.startswith(name):
fn = filterfn fn = filterfn
params = cmd[len(name) :].lstrip() params = cmd[len(name) :].lstrip()
break break
if not fn: if not fn:
fn = lambda s, c, **kwargs: procutil.filter(s, c) fn = lambda s, c, **kwargs: procutil.filter(s, c)
# Wrap old filters not supporting keyword arguments # Wrap old filters not supporting keyword arguments
if not pycompat.getargspec(fn)[2]: if not pycompat.getargspec(fn)[2]:

mercurial/logcmdutil.py

# branches are shown first before any other names due to backwards # branches are shown first before any other names due to backwards
# compatibility # compatibility
branch = ctx.branch() branch = ctx.branch()
# don't show the default branch name # don't show the default branch name
if branch != b'default': if branch != b'default':
self.ui.write(columns[b'branch'] % branch, label=b'log.branch') self.ui.write(columns[b'branch'] % branch, label=b'log.branch')
for nsname, ns in self.repo.names.iteritems(): for nsname, ns in pycompat.iteritems(self.repo.names):
# branches has special logic already handled above, so here we just # branches has special logic already handled above, so here we just
# skip it # skip it
if nsname == b'branches': if nsname == b'branches':
continue continue
# we will use the templatename as the color name since those two # we will use the templatename as the color name since those two
# should be the same # should be the same
for name in ns.names(self.repo, changenode): for name in ns.names(self.repo, changenode):
self.ui.write(ns.logfmt % name, label=b'log.%s' % ns.colorname) self.ui.write(ns.logfmt % name, label=b'log.%s' % ns.colorname)
matchargs.append(b'i:' + p) matchargs.append(b'i:' + p)
for p in opts.get(b'exclude', []): for p in opts.get(b'exclude', []):
matchargs.append(b'x:' + p) matchargs.append(b'x:' + p)
opts[b'_matchfiles'] = matchargs opts[b'_matchfiles'] = matchargs
elif not follow: elif not follow:
opts[b'_patslog'] = list(pats) opts[b'_patslog'] = list(pats)
expr = [] expr = []
for op, val in sorted(opts.iteritems()): for op, val in sorted(pycompat.iteritems(opts)):
if not val: if not val:
continue continue
if op not in _opt2logrevset: if op not in _opt2logrevset:
continue continue
revop, listop = _opt2logrevset[op] revop, listop = _opt2logrevset[op]
if revop and b'%' not in revop: if revop and b'%' not in revop:
expr.append(revop) expr.append(revop)
elif not listop: elif not listop:

mercurial/logexchange.py

# logexchange.py # logexchange.py
# #
# Copyright 2017 Augie Fackler <raf@durin42.com> # Copyright 2017 Augie Fackler <raf@durin42.com>
# Copyright 2017 Sean Farley <sean@farley.io> # Copyright 2017 Sean Farley <sean@farley.io>
# #
# This software may be used and distributed according to the terms of the # This software may be used and distributed according to the terms of the
# GNU General Public License version 2 or any later version. # GNU General Public License version 2 or any later version.
from __future__ import absolute_import from __future__ import absolute_import
from .node import hex from .node import hex
from . import ( from . import (
pycompat,
util, util,
vfs as vfsmod, vfs as vfsmod,
) )
# directory name in .hg/ in which remotenames files will be present # directory name in .hg/ in which remotenames files will be present
remotenamedir = b'logexchange' remotenamedir = b'logexchange'
f.write(b'0\n\n') f.write(b'0\n\n')
olddata = set(readremotenamefile(repo, nametype)) olddata = set(readremotenamefile(repo, nametype))
# re-save the data from a different remote than this one. # re-save the data from a different remote than this one.
for node, oldpath, rname in sorted(olddata): for node, oldpath, rname in sorted(olddata):
if oldpath != remotepath: if oldpath != remotepath:
f.write(b'%s\0%s\0%s\n' % (node, oldpath, rname)) f.write(b'%s\0%s\0%s\n' % (node, oldpath, rname))
for name, node in sorted(names.iteritems()): for name, node in sorted(pycompat.iteritems(names)):
if nametype == b"branches": if nametype == b"branches":
for n in node: for n in node:
f.write(b'%s\0%s\0%s\n' % (n, remotepath, name)) f.write(b'%s\0%s\0%s\n' % (n, remotepath, name))
elif nametype == b"bookmarks": elif nametype == b"bookmarks":
if node: if node:
f.write(b'%s\0%s\0%s\n' % (node, remotepath, name)) f.write(b'%s\0%s\0%s\n' % (node, remotepath, name))
f.close() f.close()
# remove them here otherwise we would require the user # remove them here otherwise we would require the user
# to issue a pull to refresh the storage # to issue a pull to refresh the storage
bmap = {} bmap = {}
repo = localrepo.unfiltered() repo = localrepo.unfiltered()
with remoterepo.commandexecutor() as e: with remoterepo.commandexecutor() as e:
branchmap = e.callcommand(b'branchmap', {}).result() branchmap = e.callcommand(b'branchmap', {}).result()
for branch, nodes in branchmap.iteritems(): for branch, nodes in pycompat.iteritems(branchmap):
bmap[branch] = [] bmap[branch] = []
for node in nodes: for node in nodes:
if node in repo and not repo[node].obsolete(): if node in repo and not repo[node].obsolete():
bmap[branch].append(hex(node)) bmap[branch].append(hex(node))
saveremotenames(localrepo, remotepath, bmap, bookmarks) saveremotenames(localrepo, remotepath, bmap, bookmarks)

mercurial/lsprof.py

from __future__ import absolute_import, print_function from __future__ import absolute_import, print_function
import _lsprof import _lsprof
import sys import sys
from .pycompat import getattr from .pycompat import getattr
from . import pycompat
Profiler = _lsprof.Profiler Profiler = _lsprof.Profiler
# PyPy doesn't expose profiler_entry from the module. # PyPy doesn't expose profiler_entry from the module.
profiler_entry = getattr(_lsprof, 'profiler_entry', None) profiler_entry = getattr(_lsprof, 'profiler_entry', None)
__all__ = [b'profile', b'Stats'] __all__ = [b'profile', b'Stats']
def label(code): def label(code):
if isinstance(code, str): if isinstance(code, str):
if sys.version_info.major >= 3: if sys.version_info.major >= 3:
code = code.encode('latin-1') code = code.encode('latin-1')
return code return code
try: try:
mname = _fn2mod[code.co_filename] mname = _fn2mod[code.co_filename]
except KeyError: except KeyError:
for k, v in list(sys.modules.iteritems()): for k, v in list(pycompat.iteritems(sys.modules)):
if v is None: if v is None:
continue continue
if not isinstance(getattr(v, '__file__', None), str): if not isinstance(getattr(v, '__file__', None), str):
continue continue
if v.__file__.startswith(code.co_filename): if v.__file__.startswith(code.co_filename):
mname = _fn2mod[code.co_filename] = k mname = _fn2mod[code.co_filename] = k
break break
else: else:

mercurial/manifest.py

'''Set of files in this manifest that are not in the other''' '''Set of files in this manifest that are not in the other'''
if match: if match:
m1 = self.matches(match) m1 = self.matches(match)
m2 = m2.matches(match) m2 = m2.matches(match)
return m1.filesnotin(m2) return m1.filesnotin(m2)
diff = self.diff(m2) diff = self.diff(m2)
files = set( files = set(
filepath filepath
for filepath, hashflags in diff.iteritems() for filepath, hashflags in pycompat.iteritems(diff)
if hashflags[1][0] is None if hashflags[1][0] is None
) )
return files return files
@propertycache @propertycache
def _dirs(self): def _dirs(self):
return util.dirs(self) return util.dirs(self)
self.parse(text, readsubtree) self.parse(text, readsubtree)
self._dirty = True # Mark flat manifest dirty after parsing self._dirty = True # Mark flat manifest dirty after parsing
def _subpath(self, path): def _subpath(self, path):
return self._dir + path return self._dir + path
def _loadalllazy(self): def _loadalllazy(self):
selfdirs = self._dirs selfdirs = self._dirs
for d, (path, node, readsubtree, docopy) in self._lazydirs.iteritems(): for d, (path, node, readsubtree, docopy) in pycompat.iteritems(
self._lazydirs
):
if docopy: if docopy:
selfdirs[d] = readsubtree(path, node).copy() selfdirs[d] = readsubtree(path, node).copy()
else: else:
selfdirs[d] = readsubtree(path, node) selfdirs[d] = readsubtree(path, node)
self._lazydirs = {} self._lazydirs = {}
def _loadlazy(self, d): def _loadlazy(self, d):
v = self._lazydirs.get(d) v = self._lazydirs.get(d)
The criteria currently is: The criteria currently is:
- if it's not present in _lazydirs in either t1 or t2, load it in the - if it's not present in _lazydirs in either t1 or t2, load it in the
other (it may already be loaded or it may not exist, doesn't matter) other (it may already be loaded or it may not exist, doesn't matter)
- if it's present in _lazydirs in both, compare the nodeid; if it - if it's present in _lazydirs in both, compare the nodeid; if it
differs, load it in both differs, load it in both
""" """
toloadlazy = [] toloadlazy = []
for d, v1 in t1._lazydirs.iteritems(): for d, v1 in pycompat.iteritems(t1._lazydirs):
v2 = t2._lazydirs.get(d) v2 = t2._lazydirs.get(d)
if not v2 or v2[1] != v1[1]: if not v2 or v2[1] != v1[1]:
toloadlazy.append(d) toloadlazy.append(d)
for d, v1 in t2._lazydirs.iteritems(): for d, v1 in pycompat.iteritems(t2._lazydirs):
if d not in t1._lazydirs: if d not in t1._lazydirs:
toloadlazy.append(d) toloadlazy.append(d)
for d in toloadlazy: for d in toloadlazy:
t1._loadlazy(d) t1._loadlazy(d)
t2._loadlazy(d) t2._loadlazy(d)
def __len__(self): def __len__(self):
self._load() self._load()
self._loadalllazy() self._loadalllazy()
for p, n in sorted( for p, n in sorted(
itertools.chain(self._dirs.items(), self._files.items()) itertools.chain(self._dirs.items(), self._files.items())
): ):
if p in self._files: if p in self._files:
yield self._subpath(p), n yield self._subpath(p), n
else: else:
for f, sn in n.iteritems(): for f, sn in pycompat.iteritems(n):
yield f, sn yield f, sn
iteritems = items iteritems = items
def iterkeys(self): def iterkeys(self):
self._load() self._load()
self._loadalllazy() self._loadalllazy()
for p in sorted(itertools.chain(self._dirs, self._files)): for p in sorted(itertools.chain(self._dirs, self._files)):
copy._node = self._node copy._node = self._node
copy._dirty = self._dirty copy._dirty = self._dirty
if self._copyfunc is _noop: if self._copyfunc is _noop:
def _copyfunc(s): def _copyfunc(s):
self._load() self._load()
s._lazydirs = { s._lazydirs = {
d: (p, n, r, True) d: (p, n, r, True)
for d, (p, n, r, c) in self._lazydirs.iteritems() for d, (p, n, r, c) in pycompat.iteritems(self._lazydirs)
} }
sdirs = s._dirs sdirs = s._dirs
for d, v in self._dirs.iteritems(): for d, v in pycompat.iteritems(self._dirs):
sdirs[d] = v.copy() sdirs[d] = v.copy()
s._files = dict.copy(self._files) s._files = dict.copy(self._files)
s._flags = dict.copy(self._flags) s._flags = dict.copy(self._flags)
if self._loadfunc is _noop: if self._loadfunc is _noop:
_copyfunc(copy) _copyfunc(copy)
else: else:
copy._copyfunc = _copyfunc copy._copyfunc = _copyfunc
files = set() files = set()
def _filesnotin(t1, t2): def _filesnotin(t1, t2):
if t1._node == t2._node and not t1._dirty and not t2._dirty: if t1._node == t2._node and not t1._dirty and not t2._dirty:
return return
t1._load() t1._load()
t2._load() t2._load()
self._loaddifflazy(t1, t2) self._loaddifflazy(t1, t2)
for d, m1 in t1._dirs.iteritems(): for d, m1 in pycompat.iteritems(t1._dirs):
if d in t2._dirs: if d in t2._dirs:
m2 = t2._dirs[d] m2 = t2._dirs[d]
_filesnotin(m1, m2) _filesnotin(m1, m2)
else: else:
files.update(m1.iterkeys()) files.update(m1.iterkeys())
for fn in t1._files: for fn in t1._files:
if fn not in t2._files: if fn not in t2._files:
# matcher code to further filter results. # matcher code to further filter results.
if not match(fullp): if not match(fullp):
continue continue
ret._files[fn] = self._files[fn] ret._files[fn] = self._files[fn]
if fn in self._flags: if fn in self._flags:
ret._flags[fn] = self._flags[fn] ret._flags[fn] = self._flags[fn]
visit = self._loadchildrensetlazy(visit) visit = self._loadchildrensetlazy(visit)
for dir, subm in self._dirs.iteritems(): for dir, subm in pycompat.iteritems(self._dirs):
if visit and dir[:-1] not in visit: if visit and dir[:-1] not in visit:
continue continue
m = subm._matches(match) m = subm._matches(match)
if not m._isempty(): if not m._isempty():
ret._dirs[dir] = m ret._dirs[dir] = m
if not ret._isempty(): if not ret._isempty():
ret._dirty = True ret._dirty = True
"""compares two tree manifests and append new tree-manifests which """compares two tree manifests and append new tree-manifests which
needs to be compared to stack""" needs to be compared to stack"""
if t1._node == t2._node and not t1._dirty and not t2._dirty: if t1._node == t2._node and not t1._dirty and not t2._dirty:
return return
t1._load() t1._load()
t2._load() t2._load()
self._loaddifflazy(t1, t2) self._loaddifflazy(t1, t2)
for d, m1 in t1._dirs.iteritems(): for d, m1 in pycompat.iteritems(t1._dirs):
m2 = t2._dirs.get(d, emptytree) m2 = t2._dirs.get(d, emptytree)
stack.append((m1, m2)) stack.append((m1, m2))
for d, m2 in t2._dirs.iteritems(): for d, m2 in pycompat.iteritems(t2._dirs):
if d not in t1._dirs: if d not in t1._dirs:
stack.append((emptytree, m2)) stack.append((emptytree, m2))
for fn, n1 in t1._files.iteritems(): for fn, n1 in pycompat.iteritems(t1._files):
fl1 = t1._flags.get(fn, b'') fl1 = t1._flags.get(fn, b'')
n2 = t2._files.get(fn, None) n2 = t2._files.get(fn, None)
fl2 = t2._flags.get(fn, b'') fl2 = t2._flags.get(fn, b'')
if n1 != n2 or fl1 != fl2: if n1 != n2 or fl1 != fl2:
result[t1._subpath(fn)] = ((n1, fl1), (n2, fl2)) result[t1._subpath(fn)] = ((n1, fl1), (n2, fl2))
elif clean: elif clean:
result[t1._subpath(fn)] = None result[t1._subpath(fn)] = None
for fn, n2 in t2._files.iteritems(): for fn, n2 in pycompat.iteritems(t2._files):
if fn not in t1._files: if fn not in t1._files:
fl2 = t2._flags.get(fn, b'') fl2 = t2._flags.get(fn, b'')
result[t2._subpath(fn)] = ((None, b''), (n2, fl2)) result[t2._subpath(fn)] = ((None, b''), (n2, fl2))
stackls = [] stackls = []
_iterativediff(self, m2, stackls) _iterativediff(self, m2, stackls)
while stackls: while stackls:
t1, t2 = stackls.pop() t1, t2 = stackls.pop()
return _text(self.iterentries()) return _text(self.iterentries())
def dirtext(self): def dirtext(self):
"""Get the full data of this directory as a bytestring. Make sure that """Get the full data of this directory as a bytestring. Make sure that
any submanifests have been written first, so their nodeids are correct. any submanifests have been written first, so their nodeids are correct.
""" """
self._load() self._load()
flags = self.flags flags = self.flags
lazydirs = [(d[:-1], v[1], b't') for d, v in self._lazydirs.iteritems()] lazydirs = [
(d[:-1], v[1], b't') for d, v in pycompat.iteritems(self._lazydirs)
]
dirs = [(d[:-1], self._dirs[d]._node, b't') for d in self._dirs] dirs = [(d[:-1], self._dirs[d]._node, b't') for d in self._dirs]
files = [(f, self._files[f], flags(f)) for f in self._files] files = [(f, self._files[f], flags(f)) for f in self._files]
return _text(sorted(dirs + files + lazydirs)) return _text(sorted(dirs + files + lazydirs))
def read(self, gettext, readsubtree): def read(self, gettext, readsubtree):
def _load_for_read(s): def _load_for_read(s):
s.parse(gettext(), readsubtree) s.parse(gettext(), readsubtree)
s._dirty = False s._dirty = False
return ld[1] return ld[1]
return m._dirs.get(d, emptytree)._node return m._dirs.get(d, emptytree)._node
# let's skip investigating things that `match` says we do not need. # let's skip investigating things that `match` says we do not need.
visit = match.visitchildrenset(self._dir[:-1]) visit = match.visitchildrenset(self._dir[:-1])
visit = self._loadchildrensetlazy(visit) visit = self._loadchildrensetlazy(visit)
if visit == b'this' or visit == b'all': if visit == b'this' or visit == b'all':
visit = None visit = None
for d, subm in self._dirs.iteritems(): for d, subm in pycompat.iteritems(self._dirs):
if visit and d[:-1] not in visit: if visit and d[:-1] not in visit:
continue continue
subp1 = getnode(m1, d) subp1 = getnode(m1, d)
subp2 = getnode(m2, d) subp2 = getnode(m2, d)
if subp1 == nullid: if subp1 == nullid:
subp1, subp2 = subp2, subp1 subp1, subp2 = subp2, subp1
writesubtree(subm, subp1, subp2, match) writesubtree(subm, subp1, subp2, match)
def walksubtrees(self, matcher=None): def walksubtrees(self, matcher=None):
"""Returns an iterator of the subtrees of this manifest, including this """Returns an iterator of the subtrees of this manifest, including this
manifest itself. manifest itself.
If `matcher` is provided, it only returns subtrees that match. If `matcher` is provided, it only returns subtrees that match.
""" """
if matcher and not matcher.visitdir(self._dir[:-1]): if matcher and not matcher.visitdir(self._dir[:-1]):
return return
if not matcher or matcher(self._dir[:-1]): if not matcher or matcher(self._dir[:-1]):
yield self yield self
self._load() self._load()
# OPT: use visitchildrenset to avoid loading everything. # OPT: use visitchildrenset to avoid loading everything.
self._loadalllazy() self._loadalllazy()
for d, subm in self._dirs.iteritems(): for d, subm in pycompat.iteritems(self._dirs):
for subtree in subm.walksubtrees(matcher=matcher): for subtree in subm.walksubtrees(matcher=matcher):
yield subtree yield subtree
class manifestfulltextcache(util.lrucachedict): class manifestfulltextcache(util.lrucachedict):
"""File-backed LRU cache for the manifest cache """File-backed LRU cache for the manifest cache
File consists of entries, up to EOF: File consists of entries, up to EOF:
d = mdiff.patchtext(store.revdiff(store.deltaparent(r), r)) d = mdiff.patchtext(store.revdiff(store.deltaparent(r), r))
return manifestdict(d) return manifestdict(d)
else: else:
# Need to perform a slow delta # Need to perform a slow delta
r0 = store.deltaparent(store.rev(self._node)) r0 = store.deltaparent(store.rev(self._node))
m0 = self._manifestlog.get(self._dir, store.node(r0)).read() m0 = self._manifestlog.get(self._dir, store.node(r0)).read()
m1 = self.read() m1 = self.read()
md = treemanifest(dir=self._dir) md = treemanifest(dir=self._dir)
for f, ((n0, fl0), (n1, fl1)) in m0.diff(m1).iteritems(): for f, ((n0, fl0), (n1, fl1)) in pycompat.iteritems(m0.diff(m1)):
if n1: if n1:
md[f] = n1 md[f] = n1
if fl1: if fl1:
md.setflag(f, fl1) md.setflag(f, fl1)
return md return md
def readfast(self, shallow=False): def readfast(self, shallow=False):
'''Calls either readdelta or read, based on which would be less work. '''Calls either readdelta or read, based on which would be less work.

mercurial/match.py

except KeyError: except KeyError:
if warn: if warn:
warn( warn(
_(b"%s: ignoring invalid syntax '%s'\n") % (filepath, s) _(b"%s: ignoring invalid syntax '%s'\n") % (filepath, s)
) )
continue continue
linesyntax = syntax linesyntax = syntax
for s, rels in syntaxes.iteritems(): for s, rels in pycompat.iteritems(syntaxes):
if line.startswith(rels): if line.startswith(rels):
linesyntax = rels linesyntax = rels
line = line[len(rels) :] line = line[len(rels) :]
break break
elif line.startswith(s + b':'): elif line.startswith(s + b':'):
linesyntax = rels linesyntax = rels
line = line[len(s) + 1 :] line = line[len(s) + 1 :]
break break
if sourceinfo: if sourceinfo:
patterns.append((linesyntax + line, lineno, line)) patterns.append((linesyntax + line, lineno, line))
else: else:
patterns.append(linesyntax + line) patterns.append(linesyntax + line)
fp.close() fp.close()
return patterns return patterns

mercurial/merge.py

b'\0'.join([self.mergedriver, self._mdstate]), b'\0'.join([self.mergedriver, self._mdstate]),
) )
) )
# Write out state items. In all cases, the value of the state map entry # Write out state items. In all cases, the value of the state map entry
# is written as the contents of the record. The record type depends on # is written as the contents of the record. The record type depends on
# the type of state that is stored, and capital-letter records are used # the type of state that is stored, and capital-letter records are used
# to prevent older versions of Mercurial that do not support the feature # to prevent older versions of Mercurial that do not support the feature
# from loading them. # from loading them.
for filename, v in self._state.iteritems(): for filename, v in pycompat.iteritems(self._state):
if v[0] == MERGE_RECORD_DRIVER_RESOLVED: if v[0] == MERGE_RECORD_DRIVER_RESOLVED:
# Driver-resolved merge. These are stored in 'D' records. # Driver-resolved merge. These are stored in 'D' records.
records.append( records.append(
(RECORD_MERGE_DRIVER_MERGE, b'\0'.join([filename] + v)) (RECORD_MERGE_DRIVER_MERGE, b'\0'.join([filename] + v))
) )
elif v[0] in ( elif v[0] in (
MERGE_RECORD_UNRESOLVED_PATH, MERGE_RECORD_UNRESOLVED_PATH,
MERGE_RECORD_RESOLVED_PATH, MERGE_RECORD_RESOLVED_PATH,
# file is deleted locally ('dc'). v[6] is the remote file, and # file is deleted locally ('dc'). v[6] is the remote file, and
# is nullhex when the file is deleted remotely ('cd'). # is nullhex when the file is deleted remotely ('cd').
records.append( records.append(
(RECORD_CHANGEDELETE_CONFLICT, b'\0'.join([filename] + v)) (RECORD_CHANGEDELETE_CONFLICT, b'\0'.join([filename] + v))
) )
else: else:
# Normal files. These are stored in 'F' records. # Normal files. These are stored in 'F' records.
records.append((RECORD_MERGED, b'\0'.join([filename] + v))) records.append((RECORD_MERGED, b'\0'.join([filename] + v)))
for filename, extras in sorted(self._stateextras.iteritems()): for filename, extras in sorted(pycompat.iteritems(self._stateextras)):
rawextras = b'\0'.join( rawextras = b'\0'.join(
b'%s\0%s' % (k, v) for k, v in extras.iteritems() b'%s\0%s' % (k, v) for k, v in pycompat.iteritems(extras)
) )
records.append( records.append(
(RECORD_FILE_VALUES, b'%s\0%s' % (filename, rawextras)) (RECORD_FILE_VALUES, b'%s\0%s' % (filename, rawextras))
) )
if self._labels is not None: if self._labels is not None:
labels = b'\0'.join(self._labels) labels = b'\0'.join(self._labels)
records.append((RECORD_LABELS, labels)) records.append((RECORD_LABELS, labels))
return records return records
self._dirty = True self._dirty = True
def mdstate(self): def mdstate(self):
return self._mdstate return self._mdstate
def unresolved(self): def unresolved(self):
"""Obtain the paths of unresolved files.""" """Obtain the paths of unresolved files."""
for f, entry in self._state.iteritems(): for f, entry in pycompat.iteritems(self._state):
if entry[0] in ( if entry[0] in (
MERGE_RECORD_UNRESOLVED, MERGE_RECORD_UNRESOLVED,
MERGE_RECORD_UNRESOLVED_PATH, MERGE_RECORD_UNRESOLVED_PATH,
): ):
yield f yield f
def driverresolved(self): def driverresolved(self):
"""Obtain the paths of driver-resolved files.""" """Obtain the paths of driver-resolved files."""
"""return lists of actions to perform on the dirstate""" """return lists of actions to perform on the dirstate"""
actions = { actions = {
ACTION_REMOVE: [], ACTION_REMOVE: [],
ACTION_FORGET: [], ACTION_FORGET: [],
ACTION_ADD: [], ACTION_ADD: [],
ACTION_ADD_MODIFIED: [], ACTION_ADD_MODIFIED: [],
ACTION_GET: [], ACTION_GET: [],
} }
for f, (r, action) in self._results.iteritems(): for f, (r, action) in pycompat.iteritems(self._results):
if action is not None: if action is not None:
actions[action].append((f, None, b"merge result")) actions[action].append((f, None, b"merge result"))
return actions return actions
def recordactions(self): def recordactions(self):
"""record remove/add/get actions in the dirstate""" """record remove/add/get actions in the dirstate"""
branchmerge = self._repo.dirstate.p2() != nullid branchmerge = self._repo.dirstate.p2() != nullid
recordupdates(self._repo, self.actions(), branchmerge, None) recordupdates(self._repo, self.actions(), branchmerge, None)
def collectconflicts(conflicts, config): def collectconflicts(conflicts, config):
if config == b'abort': if config == b'abort':
abortconflicts.update(conflicts) abortconflicts.update(conflicts)
elif config == b'warn': elif config == b'warn':
warnconflicts.update(conflicts) warnconflicts.update(conflicts)
checkunknowndirs = _unknowndirschecker() checkunknowndirs = _unknowndirschecker()
for f, (m, args, msg) in actions.iteritems(): for f, (m, args, msg) in pycompat.iteritems(actions):
if m in (ACTION_CREATED, ACTION_DELETED_CHANGED): if m in (ACTION_CREATED, ACTION_DELETED_CHANGED):
if _checkunknownfile(repo, wctx, mctx, f): if _checkunknownfile(repo, wctx, mctx, f):
fileconflicts.add(f) fileconflicts.add(f)
elif pathconfig and f not in wctx: elif pathconfig and f not in wctx:
path = checkunknowndirs(repo, wctx, f) path = checkunknowndirs(repo, wctx, f)
if path is not None: if path is not None:
pathconflicts.add(path) pathconflicts.add(path)
elif m == ACTION_LOCAL_DIR_RENAME_GET: elif m == ACTION_LOCAL_DIR_RENAME_GET:
if _checkunknownfile(repo, wctx, mctx, f, args[0]): if _checkunknownfile(repo, wctx, mctx, f, args[0]):
fileconflicts.add(f) fileconflicts.add(f)
allconflicts = fileconflicts | pathconflicts allconflicts = fileconflicts | pathconflicts
ignoredconflicts = {c for c in allconflicts if repo.dirstate._ignore(c)} ignoredconflicts = {c for c in allconflicts if repo.dirstate._ignore(c)}
unknownconflicts = allconflicts - ignoredconflicts unknownconflicts = allconflicts - ignoredconflicts
collectconflicts(ignoredconflicts, ignoredconfig) collectconflicts(ignoredconflicts, ignoredconfig)
collectconflicts(unknownconflicts, unknownconfig) collectconflicts(unknownconflicts, unknownconfig)
else: else:
for f, (m, args, msg) in actions.iteritems(): for f, (m, args, msg) in pycompat.iteritems(actions):
if m == ACTION_CREATED_MERGE: if m == ACTION_CREATED_MERGE:
fl2, anc = args fl2, anc = args
different = _checkunknownfile(repo, wctx, mctx, f) different = _checkunknownfile(repo, wctx, mctx, f)
if repo.dirstate._ignore(f): if repo.dirstate._ignore(f):
config = ignoredconfig config = ignoredconfig
else: else:
config = unknownconfig config = unknownconfig
) )
for f in sorted(warnconflicts): for f in sorted(warnconflicts):
if repo.wvfs.isfileorlink(f): if repo.wvfs.isfileorlink(f):
repo.ui.warn(_(b"%s: replacing untracked file\n") % f) repo.ui.warn(_(b"%s: replacing untracked file\n") % f)
else: else:
repo.ui.warn(_(b"%s: replacing untracked files in directory\n") % f) repo.ui.warn(_(b"%s: replacing untracked files in directory\n") % f)
for f, (m, args, msg) in actions.iteritems(): for f, (m, args, msg) in pycompat.iteritems(actions):
if m == ACTION_CREATED: if m == ACTION_CREATED:
backup = ( backup = (
f in fileconflicts f in fileconflicts
or f in pathconflicts or f in pathconflicts
or any(p in pathconflicts for p in util.finddirs(f)) or any(p in pathconflicts for p in util.finddirs(f))
) )
(flags,) = args (flags,) = args
actions[f] = (ACTION_GET, (flags, backup), msg) actions[f] = (ACTION_GET, (flags, backup), msg)
""" """
# If the repo is narrowed, filter out files outside the narrowspec. # If the repo is narrowed, filter out files outside the narrowspec.
narrowmatch = repo.narrowmatch() narrowmatch = repo.narrowmatch()
if not narrowmatch.always(): if not narrowmatch.always():
wmf = wmf.matches(narrowmatch) wmf = wmf.matches(narrowmatch)
if actions: if actions:
narrowactions = {} narrowactions = {}
for m, actionsfortype in actions.iteritems(): for m, actionsfortype in pycompat.iteritems(actions):
narrowactions[m] = [] narrowactions[m] = []
for (f, args, msg) in actionsfortype: for (f, args, msg) in actionsfortype:
if narrowmatch(f): if narrowmatch(f):
narrowactions[m].append((f, args, msg)) narrowactions[m].append((f, args, msg))
actions = narrowactions actions = narrowactions
# build provisional merged manifest up # build provisional merged manifest up
pmmf = set(wmf) pmmf = set(wmf)
# merge. # merge.
if pa not in ([wctx, p2] + wctx.parents()) and not forcefulldiff: if pa not in ([wctx, p2] + wctx.parents()) and not forcefulldiff:
# Identify which files are relevant to the merge, so we can limit the # Identify which files are relevant to the merge, so we can limit the
# total m1-vs-m2 diff to just those files. This has significant # total m1-vs-m2 diff to just those files. This has significant
# performance benefits in large repositories. # performance benefits in large repositories.
relevantfiles = set(ma.diff(m2).keys()) relevantfiles = set(ma.diff(m2).keys())
# For copied and moved files, we need to add the source file too. # For copied and moved files, we need to add the source file too.
for copykey, copyvalue in copy.iteritems(): for copykey, copyvalue in pycompat.iteritems(copy):
if copyvalue in relevantfiles: if copyvalue in relevantfiles:
relevantfiles.add(copykey) relevantfiles.add(copykey)
for movedirkey in movewithdir: for movedirkey in movewithdir:
relevantfiles.add(movedirkey) relevantfiles.add(movedirkey)
filesmatcher = scmutil.matchfiles(repo, relevantfiles) filesmatcher = scmutil.matchfiles(repo, relevantfiles)
matcher = matchmod.intersectmatchers(matcher, filesmatcher) matcher = matchmod.intersectmatchers(matcher, filesmatcher)
diff = m1.diff(m2, match=matcher) diff = m1.diff(m2, match=matcher)
actions = {} actions = {}
for f, ((n1, fl1), (n2, fl2)) in diff.iteritems(): for f, ((n1, fl1), (n2, fl2)) in pycompat.iteritems(diff):
if n1 and n2: # file exists on both local and remote side if n1 and n2: # file exists on both local and remote side
if f not in ma: if f not in ma:
fa = copy.get(f, None) fa = copy.get(f, None)
if fa is not None: if fa is not None:
actions[f] = ( actions[f] = (
ACTION_MERGE, ACTION_MERGE,
(f, f, fa, False, pa.node()), (f, f, fa, False, pa.node()),
b'both renamed from %s' % fa, b'both renamed from %s' % fa,
# Track the shortest set of warning on the theory that bid # Track the shortest set of warning on the theory that bid
# merge will correctly incorporate more information # merge will correctly incorporate more information
if diverge is None or len(diverge1) < len(diverge): if diverge is None or len(diverge1) < len(diverge):
diverge = diverge1 diverge = diverge1
if renamedelete is None or len(renamedelete) < len(renamedelete1): if renamedelete is None or len(renamedelete) < len(renamedelete1):
renamedelete = renamedelete1 renamedelete = renamedelete1
for f, a in sorted(actions.iteritems()): for f, a in sorted(pycompat.iteritems(actions)):
m, args, msg = a m, args, msg = a
repo.ui.debug(b' %s: %s -> %s\n' % (f, msg, m)) repo.ui.debug(b' %s: %s -> %s\n' % (f, msg, m))
if f in fbids: if f in fbids:
d = fbids[f] d = fbids[f]
if m in d: if m in d:
d[m].append(a) d[m].append(a)
else: else:
d[m] = [a] d[m] = [a]
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 = set(a[0] for a in actions[ACTION_MERGE])
for k, acts in extraactions.iteritems(): 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]
# are processed after files in other actions, and the merge driver # are processed after files in other actions, and the merge driver
force, force,
mergeancestor, mergeancestor,
followcopies, followcopies,
matcher=matcher, matcher=matcher,
mergeforce=mergeforce, mergeforce=mergeforce,
) )
if updatecheck == UPDATECHECK_NO_CONFLICT: if updatecheck == UPDATECHECK_NO_CONFLICT:
for f, (m, args, msg) in actionbyfile.iteritems(): for f, (m, args, msg) in pycompat.iteritems(actionbyfile):
if m not in ( if m not in (
ACTION_GET, ACTION_GET,
ACTION_KEEP, ACTION_KEEP,
ACTION_EXEC, ACTION_EXEC,
ACTION_REMOVE, ACTION_REMOVE,
ACTION_PATH_CONFLICT_RESOLVE, ACTION_PATH_CONFLICT_RESOLVE,
): ):
msg = _(b"conflicting changes") msg = _(b"conflicting changes")
(flags, False), (flags, False),
b'prompt recreating', b'prompt recreating',
) )
else: else:
del actionbyfile[f] del actionbyfile[f]
# Convert to dictionary-of-lists format # Convert to dictionary-of-lists format
actions = emptyactions() actions = emptyactions()
for f, (m, args, msg) in actionbyfile.iteritems(): for f, (m, args, msg) in pycompat.iteritems(actionbyfile):
if m not in actions: if m not in actions:
actions[m] = [] actions[m] = []
actions[m].append((f, args, msg)) actions[m].append((f, args, msg))
if not util.fscasesensitive(repo.path): if not util.fscasesensitive(repo.path):
# check collision between files only in p2 for clean update # check collision between files only in p2 for clean update
if not branchmerge and ( if not branchmerge and (
force or not wc.dirty(missing=True, branch=False) force or not wc.dirty(missing=True, branch=False)
): ):
_checkcollision(repo, p2.manifest(), None) _checkcollision(repo, p2.manifest(), None)
else: else:
_checkcollision(repo, wc.manifest(), actions) _checkcollision(repo, wc.manifest(), actions)
# divergent renames # divergent renames
for f, fl in sorted(diverge.iteritems()): for f, fl in sorted(pycompat.iteritems(diverge)):
repo.ui.warn( repo.ui.warn(
_( _(
b"note: possible conflict - %s was renamed " b"note: possible conflict - %s was renamed "
b"multiple times to:\n" b"multiple times to:\n"
) )
% f % f
) )
for nf in sorted(fl): for nf in sorted(fl):
repo.ui.warn(b" %s\n" % nf) repo.ui.warn(b" %s\n" % nf)
# rename and delete # rename and delete
for f, fl in sorted(renamedelete.iteritems()): for f, fl in sorted(pycompat.iteritems(renamedelete)):
repo.ui.warn( repo.ui.warn(
_( _(
b"note: possible conflict - %s was deleted " b"note: possible conflict - %s was deleted "
b"and renamed to:\n" b"and renamed to:\n"
) )
% f % f
) )
for nf in sorted(fl): for nf in sorted(fl):

mercurial/namespaces.py

from __future__ import absolute_import from __future__ import absolute_import
from .i18n import _ from .i18n import _
from . import ( from . import (
pycompat,
registrar, registrar,
templatekw, templatekw,
util, util,
) )
def tolist(val): def tolist(val):
""" """
def __getitem__(self, namespace): def __getitem__(self, namespace):
"""returns the namespace object""" """returns the namespace object"""
return self._names[namespace] return self._names[namespace]
def __iter__(self): def __iter__(self):
return self._names.__iter__() return self._names.__iter__()
def items(self): def items(self):
return self._names.iteritems() return pycompat.iteritems(self._names)
iteritems = items iteritems = items
def addnamespace(self, namespace, order=None): def addnamespace(self, namespace, order=None):
"""register a namespace """register a namespace
namespace: the name to be registered (in plural form) namespace: the name to be registered (in plural form)
order: optional argument to specify the order of namespaces order: optional argument to specify the order of namespaces
def singlenode(self, repo, name): def singlenode(self, repo, name):
""" """
Return the 'best' node for the given name. What's best is defined Return the 'best' node for the given name. What's best is defined
by the namespace's singlenode() function. The first match returned by by the namespace's singlenode() function. The first match returned by
a namespace in the defined precedence order is used. a namespace in the defined precedence order is used.
Raises a KeyError if there is no such node. Raises a KeyError if there is no such node.
""" """
for ns, v in self._names.iteritems(): for ns, v in pycompat.iteritems(self._names):
n = v.singlenode(repo, name) n = v.singlenode(repo, name)
if n: if n:
return n return n
raise KeyError(_(b'no such name: %s') % name) raise KeyError(_(b'no such name: %s') % name)
class namespace(object): class namespace(object):
"""provides an interface to a namespace """provides an interface to a namespace

mercurial/obsolete.py

for p in parents: for p in parents:
if len(p) != 20: if len(p) != 20:
parents = None parents = None
break break
except TypeError: except TypeError:
# if content cannot be translated to nodeid drop the data. # if content cannot be translated to nodeid drop the data.
parents = None parents = None
metadata = tuple(sorted(metadata.iteritems())) metadata = tuple(sorted(pycompat.iteritems(metadata)))
yield (pre, sucs, flags, metadata, date, parents) yield (pre, sucs, flags, metadata, date, parents)
def _fm0encodeonemarker(marker): def _fm0encodeonemarker(marker):
pre, sucs, flags, metadata, date, parents = marker pre, sucs, flags, metadata, date, parents = marker
if flags & usingsha256: if flags & usingsha256:
raise error.Abort(_(b'cannot handle sha256 with old obsstore format')) raise error.Abort(_(b'cannot handle sha256 with old obsstore format'))
data.extend(sucs) data.extend(sucs)
return _pack(format, *data) + metadata return _pack(format, *data) + metadata
def _fm0encodemeta(meta): def _fm0encodemeta(meta):
"""Return encoded metadata string to string mapping. """Return encoded metadata string to string mapping.
Assume no ':' in key and no '\0' in both key and value.""" Assume no ':' in key and no '\0' in both key and value."""
for key, value in meta.iteritems(): for key, value in pycompat.iteritems(meta):
if b':' in key or b'\0' in key: if b':' in key or b'\0' in key:
raise ValueError(b"':' and '\0' are forbidden in metadata key'") raise ValueError(b"':' and '\0' are forbidden in metadata key'")
if b'\0' in value: if b'\0' in value:
raise ValueError(b"':' is forbidden in metadata value'") raise ValueError(b"':' is forbidden in metadata value'")
return b'\0'.join([b'%s:%s' % (k, meta[k]) for k in sorted(meta)]) return b'\0'.join([b'%s:%s' % (k, meta[k]) for k in sorted(meta)])
def _fm0decodemeta(data): def _fm0decodemeta(data):
for succ in succs: for succ in succs:
if len(succ) != 20: if len(succ) != 20:
raise ValueError(succ) raise ValueError(succ)
if prec in succs: if prec in succs:
raise ValueError( raise ValueError(
r'in-marker cycle with %s' % pycompat.sysstr(node.hex(prec)) r'in-marker cycle with %s' % pycompat.sysstr(node.hex(prec))
) )
metadata = tuple(sorted(metadata.iteritems())) metadata = tuple(sorted(pycompat.iteritems(metadata)))
for k, v in metadata: for k, v in metadata:
try: try:
# might be better to reject non-ASCII keys # might be better to reject non-ASCII keys
k.decode('utf-8') k.decode('utf-8')
v.decode('utf-8') v.decode('utf-8')
except UnicodeDecodeError: except UnicodeDecodeError:
raise error.ProgrammingError( raise error.ProgrammingError(
b'obsstore metadata must be valid UTF-8 sequence ' b'obsstore metadata must be valid UTF-8 sequence '

mercurial/obsutil.py

import re import re
from .i18n import _ from .i18n import _
from . import ( from . import (
diffutil, diffutil,
encoding, encoding,
node as nodemod, node as nodemod,
phases, phases,
pycompat,
util, util,
) )
from .utils import dateutil from .utils import dateutil
### obsolescence marker flag ### obsolescence marker flag
## bumpedfix flag ## bumpedfix flag
# #
# we are only interested in *other* successor sets # we are only interested in *other* successor sets
continue continue
if tuple(nsuccset) in base: if tuple(nsuccset) in base:
# we already know the latest base for this divergency # we already know the latest base for this divergency
continue continue
base[tuple(nsuccset)] = n base[tuple(nsuccset)] = n
return [ return [
{b'divergentnodes': divset, b'commonpredecessor': b} {b'divergentnodes': divset, b'commonpredecessor': b}
for divset, b in base.iteritems() for divset, b in pycompat.iteritems(base)
] ]
def whyunstable(repo, ctx): def whyunstable(repo, ctx):
result = [] result = []
if ctx.orphan(): if ctx.orphan():
for parent in ctx.parents(): for parent in ctx.parents():
kind = None kind = None

mercurial/patch.py

copy = {} copy = {}
if opts.git or opts.upgrade: if opts.git or opts.upgrade:
copy = copies.pathcopies(ctx1, ctx2, match=match) copy = copies.pathcopies(ctx1, ctx2, match=match)
if copysourcematch: if copysourcematch:
# filter out copies where source side isn't inside the matcher # filter out copies where source side isn't inside the matcher
# (copies.pathcopies() already filtered out the destination) # (copies.pathcopies() already filtered out the destination)
copy = { copy = {
dst: src for dst, src in copy.iteritems() if copysourcematch(src) dst: src
for dst, src in pycompat.iteritems(copy)
if copysourcematch(src)
} }
modifiedset = set(modified) modifiedset = set(modified)
addedset = set(added) addedset = set(added)
removedset = set(removed) removedset = set(removed)
for f in modified: for f in modified:
if f not in ctx1: if f not in ctx1:
# Fix up added, since merged-in additions appear as # Fix up added, since merged-in additions appear as

mercurial/phases.py

* roots is {<nodeid> => phase} mapping. key and value are string. * roots is {<nodeid> => phase} mapping. key and value are string.
Accept unknown element input Accept unknown element input
""" """
repo = repo.unfiltered() repo = repo.unfiltered()
# build list from dictionary # build list from dictionary
draftroots = [] draftroots = []
nodemap = repo.changelog.nodemap # to filter unknown nodes nodemap = repo.changelog.nodemap # to filter unknown nodes
for nhex, phase in roots.iteritems(): for nhex, phase in pycompat.iteritems(roots):
if nhex == b'publishing': # ignore data related to publish option if nhex == b'publishing': # ignore data related to publish option
continue continue
node = bin(nhex) node = bin(nhex)
phase = int(phase) phase = int(phase)
if phase == public: if phase == public:
if node != nullid: if node != nullid:
repo.ui.warn( repo.ui.warn(
_( _(

mercurial/pure/parsers.py

return parents return parents
def pack_dirstate(dmap, copymap, pl, now): def pack_dirstate(dmap, copymap, pl, now):
now = int(now) now = int(now)
cs = stringio() cs = stringio()
write = cs.write write = cs.write
write(b"".join(pl)) write(b"".join(pl))
for f, e in dmap.iteritems(): for f, e in pycompat.iteritems(dmap):
if e[0] == b'n' and e[3] == now: if e[0] == b'n' and e[3] == now:
# The file was last modified "simultaneously" with the current # The file was last modified "simultaneously" with the current
# write to dirstate (i.e. within the same second for file- # write to dirstate (i.e. within the same second for file-
# systems with a granularity of 1 sec). This commonly happens # systems with a granularity of 1 sec). This commonly happens
# for at least a couple of files on 'update'. # for at least a couple of files on 'update'.
# The user could change the file without changing its size # The user could change the file without changing its size
# within the same second. Invalidate the file's mtime in # within the same second. Invalidate the file's mtime in
# dirstate, forcing future 'status' calls to compare the # dirstate, forcing future 'status' calls to compare the

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.iteritems()) dic = dict((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.iteritems()) dic = dict((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/revlog.py

if b'sparse-read-density-threshold' in opts: if b'sparse-read-density-threshold' in opts:
self._srdensitythreshold = opts[b'sparse-read-density-threshold'] self._srdensitythreshold = opts[b'sparse-read-density-threshold']
if b'sparse-read-min-gap-size' in opts: if b'sparse-read-min-gap-size' in opts:
self._srmingapsize = opts[b'sparse-read-min-gap-size'] self._srmingapsize = opts[b'sparse-read-min-gap-size']
if opts.get(b'enableellipsis'): if opts.get(b'enableellipsis'):
self._flagprocessors[REVIDX_ELLIPSIS] = ellipsisprocessor self._flagprocessors[REVIDX_ELLIPSIS] = ellipsisprocessor
# revlog v0 doesn't have flag processors # revlog v0 doesn't have flag processors
for flag, processor in opts.get(b'flagprocessors', {}).iteritems(): for flag, processor in pycompat.iteritems(
opts.get(b'flagprocessors', {})
):
flagutil.insertflagprocessor(flag, processor, self._flagprocessors) flagutil.insertflagprocessor(flag, processor, self._flagprocessors)
if self._chunkcachesize <= 0: if self._chunkcachesize <= 0:
raise error.RevlogError( raise error.RevlogError(
_(b'revlog chunk cache size %r is not ' b'greater than 0') _(b'revlog chunk cache size %r is not ' b'greater than 0')
% self._chunkcachesize % self._chunkcachesize
) )
elif self._chunkcachesize & (self._chunkcachesize - 1): elif self._chunkcachesize & (self._chunkcachesize - 1):
elif ancestors is None: elif ancestors is None:
# Otherwise, we're trying to discover the heads. # Otherwise, we're trying to discover the heads.
# Assume this is a head because if it isn't, the next step # Assume this is a head because if it isn't, the next step
# will eventually remove it. # will eventually remove it.
heads[n] = True heads[n] = True
# But, obviously its parents aren't. # But, obviously its parents aren't.
for p in self.parents(n): for p in self.parents(n):
heads.pop(p, None) heads.pop(p, None)
heads = [head for head, flag in heads.iteritems() if flag] heads = [head for head, flag in pycompat.iteritems(heads) if flag]
roots = list(roots) roots = list(roots)
assert orderedout assert orderedout
assert roots assert roots
assert heads assert heads
return (orderedout, roots, heads) return (orderedout, roots, heads)
def headrevs(self, revs=None): def headrevs(self, revs=None):
if revs is None: if revs is None:

mercurial/revset.py

bmrev = repo._bookmarks.get(pattern, None) bmrev = repo._bookmarks.get(pattern, None)
if not bmrev: if not bmrev:
raise error.RepoLookupError( raise error.RepoLookupError(
_(b"bookmark '%s' does not exist") % pattern _(b"bookmark '%s' does not exist") % pattern
) )
bms.add(repo[bmrev].rev()) bms.add(repo[bmrev].rev())
else: else:
matchrevs = set() matchrevs = set()
for name, bmrev in repo._bookmarks.iteritems(): for name, bmrev in pycompat.iteritems(repo._bookmarks):
if matcher(name): if matcher(name):
matchrevs.add(bmrev) matchrevs.add(bmrev)
for bmrev in matchrevs: for bmrev in matchrevs:
bms.add(repo[bmrev].rev()) bms.add(repo[bmrev].rev())
else: else:
bms = {repo[r].rev() for r in repo._bookmarks.values()} bms = {repo[r].rev() for r in repo._bookmarks.values()}
bms -= {node.nullrev} bms -= {node.nullrev}
return subset & bms return subset & bms
namespaces = set() namespaces = set()
if kind == b'literal': if kind == b'literal':
if pattern not in repo.names: if pattern not in repo.names:
raise error.RepoLookupError( raise error.RepoLookupError(
_(b"namespace '%s' does not exist") % ns _(b"namespace '%s' does not exist") % ns
) )
namespaces.add(repo.names[pattern]) namespaces.add(repo.names[pattern])
else: else:
for name, ns in repo.names.iteritems(): for name, ns in pycompat.iteritems(repo.names):
if matcher(name): if matcher(name):
namespaces.add(ns) namespaces.add(ns)
names = set() names = set()
for ns in namespaces: for ns in namespaces:
for name in ns.listnames(repo): for name in ns.listnames(repo):
if name not in ns.deprecated: if name not in ns.deprecated:
names.update(repo[n].rev() for n in ns.nodes(repo, name)) names.update(repo[n].rev() for n in ns.nodes(repo, name))
return getset(repo, subset, tree, order) return getset(repo, subset, tree, order)
return mfunc return mfunc
def loadpredicate(ui, extname, registrarobj): def loadpredicate(ui, extname, registrarobj):
"""Load revset predicates from specified registrarobj """Load revset predicates from specified registrarobj
""" """
for name, func in registrarobj._table.iteritems(): for name, func in pycompat.iteritems(registrarobj._table):
symbols[name] = func symbols[name] = func
if func._safe: if func._safe:
safesymbols.add(name) safesymbols.add(name)
# load built-in predicates explicitly to setup safesymbols # load built-in predicates explicitly to setup safesymbols
loadpredicate(None, None, predicate) loadpredicate(None, None, predicate)
# tell hggettext to extract docstrings from these functions: # tell hggettext to extract docstrings from these functions:
i18nfunctions = symbols.values() i18nfunctions = symbols.values()

mercurial/revsetlang.py

def expandaliases(tree, aliases, warn=None): def expandaliases(tree, aliases, warn=None):
"""Expand aliases in a tree, aliases is a list of (name, value) tuples""" """Expand aliases in a tree, aliases is a list of (name, value) tuples"""
aliases = _aliasrules.buildmap(aliases) aliases = _aliasrules.buildmap(aliases)
tree = _aliasrules.expand(aliases, tree) tree = _aliasrules.expand(aliases, tree)
# warn about problematic (but not referred) aliases # warn about problematic (but not referred) aliases
if warn is not None: if warn is not None:
for name, alias in sorted(aliases.iteritems()): for name, alias in sorted(pycompat.iteritems(aliases)):
if alias.error and not alias.warned: if alias.error and not alias.warned:
warn(_(b'warning: %s\n') % (alias.error)) warn(_(b'warning: %s\n') % (alias.error))
alias.warned = True alias.warned = True
return tree return tree
def foldconcat(tree): def foldconcat(tree):
"""Fold elements to be concatenated by `##` """Fold elements to be concatenated by `##`

mercurial/scmutil.py

missing = set() missing = set()
for subpath in ctx2.substate: for subpath in ctx2.substate:
if subpath not in ctx1.substate: if subpath not in ctx1.substate:
del subpaths[subpath] del subpaths[subpath]
missing.add(subpath) missing.add(subpath)
for subpath, ctx in sorted(subpaths.iteritems()): for subpath, ctx in sorted(pycompat.iteritems(subpaths)):
yield subpath, ctx.sub(subpath) yield subpath, ctx.sub(subpath)
# Yield an empty subrepo based on ctx1 for anything only in ctx2. That way, # Yield an empty subrepo based on ctx1 for anything only in ctx2. That way,
# status and diff will have an accurate result when it does # status and diff will have an accurate result when it does
# 'sub.{status|diff}(rev2)'. Otherwise, the ctx2 subrepo is compared # 'sub.{status|diff}(rev2)'. Otherwise, the ctx2 subrepo is compared
# against itself. # against itself.
for subpath in missing: for subpath in missing:
yield subpath, ctx2.nullsub(subpath, ctx1) yield subpath, ctx2.nullsub(subpath, ctx1)
matcher = repo.narrowmatch(matcher, includeexact=True) matcher = repo.narrowmatch(matcher, includeexact=True)
walkresults = dirstate.walk( walkresults = dirstate.walk(
matcher, matcher,
subrepos=sorted(ctx.substate), subrepos=sorted(ctx.substate),
unknown=True, unknown=True,
ignored=False, ignored=False,
full=False, full=False,
) )
for abs, st in walkresults.iteritems(): for abs, st in pycompat.iteritems(walkresults):
dstate = dirstate[abs] dstate = dirstate[abs]
if dstate == b'?' and audit_path.check(abs): if dstate == b'?' and audit_path.check(abs):
unknown.append(abs) unknown.append(abs)
elif dstate != b'r' and not st: elif dstate != b'r' and not st:
deleted.append(abs) deleted.append(abs)
elif dstate == b'r' and st: elif dstate == b'r' and st:
forgotten.append(abs) forgotten.append(abs)
# for finding renames # for finding renames
def _markchanges(repo, unknown, deleted, renames): def _markchanges(repo, unknown, deleted, renames):
'''Marks the files in unknown as added, the files in deleted as removed, '''Marks the files in unknown as added, the files in deleted as removed,
and the files in renames as copied.''' and the files in renames as copied.'''
wctx = repo[None] wctx = repo[None]
with repo.wlock(): with repo.wlock():
wctx.forget(deleted) wctx.forget(deleted)
wctx.add(unknown) wctx.add(unknown)
for new, old in renames.iteritems(): for new, old in pycompat.iteritems(renames):
wctx.copy(old, new) wctx.copy(old, new)
def getrenamedfn(repo, endrev=None): def getrenamedfn(repo, endrev=None):
if copiesmod.usechangesetcentricalgo(repo): if copiesmod.usechangesetcentricalgo(repo):
def getrenamed(fn, rev): def getrenamed(fn, rev):
ctx = repo[rev] ctx = repo[rev]
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 = dict(
(dst, oldcopies.get(src, src)) for dst, src in oldcopies.iteritems() (dst, oldcopies.get(src, src))
for dst, src in pycompat.iteritems(oldcopies)
) )
# Adjust the dirstate copies # Adjust the dirstate copies
for dst, src in copies.iteritems(): 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)
def writerequires(opener, requirements): def writerequires(opener, requirements):
with opener(b'requires', b'w', atomictemp=True) as fp: with opener(b'requires', b'w', atomictemp=True) as fp:
for r in sorted(requirements): for r in sorted(requirements):
pull/unbundle. pull/unbundle.
""" """
origrepolen = tr.changes.get(b'origrepolen', len(repo)) origrepolen = tr.changes.get(b'origrepolen', len(repo))
phasetracking = tr.changes.get(b'phases', {}) phasetracking = tr.changes.get(b'phases', {})
if not phasetracking: if not phasetracking:
return return
published = [ published = [
rev rev
for rev, (old, new) in phasetracking.iteritems() for rev, (old, new) in pycompat.iteritems(phasetracking)
if new == phases.public and rev < origrepolen if new == phases.public and rev < origrepolen
] ]
if not published: if not published:
return return
repo.ui.status( repo.ui.status(
_(b'%d local changesets published\n') % len(published) _(b'%d local changesets published\n') % len(published)
) )

mercurial/similar.py

# similar.py - mechanisms for finding similar files # similar.py - mechanisms for finding similar files
# #
# Copyright 2005-2007 Matt Mackall <mpm@selenic.com> # Copyright 2005-2007 Matt Mackall <mpm@selenic.com>
# #
# This software may be used and distributed according to the terms of the # This software may be used and distributed according to the terms of the
# GNU General Public License version 2 or any later version. # GNU General Public License version 2 or any later version.
from __future__ import absolute_import from __future__ import absolute_import
from .i18n import _ from .i18n import _
from . import mdiff from . import (
mdiff,
pycompat,
)
def _findexactmatches(repo, added, removed): def _findexactmatches(repo, added, removed):
'''find renamed files that have no changes '''find renamed files that have no changes
Takes a list of new filectxs and a list of removed filectxs, and yields Takes a list of new filectxs and a list of removed filectxs, and yields
(before, after) tuples of exact matches. (before, after) tuples of exact matches.
''' '''
bestscore = copies.get(a, (None, threshold))[1] bestscore = copies.get(a, (None, threshold))[1]
if data is None: if data is None:
data = _ctxdata(r) data = _ctxdata(r)
myscore = _score(a, data) myscore = _score(a, data)
if myscore > bestscore: if myscore > bestscore:
copies[a] = (r, myscore) copies[a] = (r, myscore)
progress.complete() progress.complete()
for dest, v in copies.iteritems(): for dest, v in pycompat.iteritems(copies):
source, bscore = v source, bscore = v
yield source, dest, bscore yield source, dest, bscore
def _dropempty(fctxs): def _dropempty(fctxs):
return [x for x in fctxs if x.size() > 0] return [x for x in fctxs if x.size() > 0]

mercurial/sparse.py

# the wctx. # the wctx.
sparsematch = matcher(repo, [wctx.p1().rev()]) sparsematch = matcher(repo, [wctx.p1().rev()])
else: else:
# If we're updating, use the target context's filter, since we're # If we're updating, use the target context's filter, since we're
# moving to the target context. # moving to the target context.
sparsematch = matcher(repo, [mctx.rev()]) sparsematch = matcher(repo, [mctx.rev()])
temporaryfiles = [] temporaryfiles = []
for file, action in actions.iteritems(): for file, action in pycompat.iteritems(actions):
type, args, msg = action type, args, msg = action
files.add(file) files.add(file)
if sparsematch(file): if sparsematch(file):
prunedactions[file] = action prunedactions[file] = action
elif type == b'm': elif type == b'm':
temporaryfiles.append(file) temporaryfiles.append(file)
prunedactions[file] = action prunedactions[file] = action
elif branchmerge: elif branchmerge:
_( _(
b'cannot change sparseness due to pending ' b'cannot change sparseness due to pending '
b'changes (delete the files or use ' b'changes (delete the files or use '
b'--force to bring them back dirty)' b'--force to bring them back dirty)'
) )
) )
# Check for files that were only in the dirstate. # Check for files that were only in the dirstate.
for file, state in dirstate.iteritems(): for file, state in pycompat.iteritems(dirstate):
if not file in files: if not file in files:
old = origsparsematch(file) old = origsparsematch(file)
new = sparsematch(file) new = sparsematch(file)
if old and not new: if old and not new:
dropped.append(file) dropped.append(file)
# Apply changes to disk # Apply changes to disk
typeactions = mergemod.emptyactions() typeactions = mergemod.emptyactions()
for f, (m, args, msg) in actions.iteritems(): for f, (m, args, msg) in pycompat.iteritems(actions):
typeactions[m].append((f, args, msg)) typeactions[m].append((f, args, msg))
mergemod.applyupdates( mergemod.applyupdates(
repo, typeactions, repo[None], repo[b'.'], False, wantfiledata=False repo, typeactions, repo[None], repo[b'.'], False, wantfiledata=False
) )
# Fix dirstate # Fix dirstate
for file in added: for file in added:

mercurial/sshpeer.py

wireargs = {} wireargs = {}
for k in keys: for k in keys:
if k == b'*': if k == b'*':
wireargs[b'*'] = args wireargs[b'*'] = args
break break
else: else:
wireargs[k] = args[k] wireargs[k] = args[k]
del args[k] del args[k]
for k, v in sorted(wireargs.iteritems()): for k, v in sorted(pycompat.iteritems(wireargs)):
self._pipeo.write(b"%s %d\n" % (k, len(v))) self._pipeo.write(b"%s %d\n" % (k, len(v)))
if isinstance(v, dict): if isinstance(v, dict):
for dk, dv in v.iteritems(): for dk, dv in pycompat.iteritems(v):
self._pipeo.write(b"%s %d\n" % (dk, len(dv))) self._pipeo.write(b"%s %d\n" % (dk, len(dv)))
self._pipeo.write(dv) self._pipeo.write(dv)
else: else:
self._pipeo.write(v) self._pipeo.write(v)
self._pipeo.flush() self._pipeo.flush()
# We know exactly how many bytes are in the response. So return a proxy # We know exactly how many bytes are in the response. So return a proxy
# around the raw output stream that allows reading exactly this many # around the raw output stream that allows reading exactly this many

mercurial/statprof.py

stats = SiteStats.buildstats(data.samples) stats = SiteStats.buildstats(data.samples)
grouped = defaultdict(list) grouped = defaultdict(list)
for stat in stats: for stat in stats:
grouped[stat.site.filename() + b":" + stat.site.function].append(stat) grouped[stat.site.filename() + b":" + stat.site.function].append(stat)
# compute sums for each function # compute sums for each function
functiondata = [] functiondata = []
for fname, sitestats in grouped.iteritems(): for fname, sitestats in pycompat.iteritems(grouped):
total_cum_sec = 0 total_cum_sec = 0
total_self_sec = 0 total_self_sec = 0
total_percent = 0 total_percent = 0
for stat in sitestats: for stat in sitestats:
total_cum_sec += stat.totalseconds() total_cum_sec += stat.totalseconds()
total_self_sec += stat.selfseconds() total_self_sec += stat.selfseconds()
total_percent += stat.selfpercent() total_percent += stat.selfpercent()
else: else:
parents[parent] = 1 parents[parent] = 1
if site in children: if site in children:
children[site] = children[site] + 1 children[site] = children[site] + 1
else: else:
children[site] = 1 children[site] = 1
parents = [(parent, count) for parent, count in parents.iteritems()] parents = [(parent, count) for parent, count in pycompat.iteritems(parents)]
parents.sort(reverse=True, key=lambda x: x[1]) parents.sort(reverse=True, key=lambda x: x[1])
for parent, count in parents: for parent, count in parents:
fp.write( fp.write(
b'%6.2f%% %s:%s line %s: %s\n' b'%6.2f%% %s:%s line %s: %s\n'
% ( % (
count / relevant_samples * 100, count / relevant_samples * 100,
pycompat.fsencode(parent.filename()), pycompat.fsencode(parent.filename()),
pycompat.sysbytes(parent.function), pycompat.sysbytes(parent.function),
pycompat.sysbytes(function), pycompat.sysbytes(function),
total_cum_sec, total_cum_sec,
total_cum_percent, total_cum_percent,
total_self_sec, total_self_sec,
total_self_percent, total_self_percent,
) )
) )
children = [(child, count) for child, count in children.iteritems()] children = [(child, count) for child, count in pycompat.iteritems(children)]
children.sort(reverse=True, key=lambda x: x[1]) children.sort(reverse=True, key=lambda x: x[1])
for child, count in children: for child, count in children:
fp.write( fp.write(
b' %6.2f%% line %s: %s\n' b' %6.2f%% line %s: %s\n'
% ( % (
count / relevant_samples * 100, count / relevant_samples * 100,
child.lineno, child.lineno,
pycompat.sysbytes(child.getsource(50)), pycompat.sysbytes(child.getsource(50)),
if line in lines: if line in lines:
lines[line] = lines[line] + 1 lines[line] = lines[line] + 1
else: else:
lines[line] = 1 lines[line] = 1
fd, path = pycompat.mkstemp() fd, path = pycompat.mkstemp()
with open(path, b"w+") as file: with open(path, b"w+") as file:
for line, count in lines.iteritems(): for line, count in pycompat.iteritems(lines):
file.write(b"%s %d\n" % (line, count)) file.write(b"%s %d\n" % (line, count))
if outputfile is None: if outputfile is None:
outputfile = b'~/flamegraph.svg' outputfile = b'~/flamegraph.svg'
os.system(b"perl ~/flamegraph.pl %s > %s" % (path, outputfile)) os.system(b"perl ~/flamegraph.pl %s > %s" % (path, outputfile))
fp.write(b'Written to %s\n' % outputfile) fp.write(b'Written to %s\n' % outputfile)

mercurial/store.py

cmap = dict((x, x) for x in asciistr) cmap = dict((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 cmap.iteritems(): for k, v in pycompat.iteritems(cmap):
dmap[v] = k dmap[v] = k
def decode(s): def decode(s):
i = 0 i = 0
while i < len(s): while i < len(s):
for l in pycompat.xrange(1, 4): for l in pycompat.xrange(1, 4):
try: try:
yield dmap[s[i : i + l]] yield dmap[s[i : i + l]]

mercurial/subrepo.py

if self._gitmissing(): if self._gitmissing():
raise error.Abort(_(b"subrepo %s is missing") % self._relpath) raise error.Abort(_(b"subrepo %s is missing") % self._relpath)
# if a branch in origin contains the revision, nothing to do # if a branch in origin contains the revision, nothing to do
branch2rev, rev2branch = self._gitbranchmap() branch2rev, rev2branch = self._gitbranchmap()
if self._state[1] in rev2branch: if self._state[1] in rev2branch:
for b in rev2branch[self._state[1]]: for b in rev2branch[self._state[1]]:
if b.startswith(b'refs/remotes/origin/'): if b.startswith(b'refs/remotes/origin/'):
return True return True
for b, revision in branch2rev.iteritems(): for b, revision in pycompat.iteritems(branch2rev):
if b.startswith(b'refs/remotes/origin/'): if b.startswith(b'refs/remotes/origin/'):
if self._gitisancestor(self._state[1], revision): if self._gitisancestor(self._state[1], revision):
return True return True
# otherwise, try to push the currently checked out branch # otherwise, try to push the currently checked out branch
cmd = [b'push'] cmd = [b'push']
if force: if force:
cmd.append(b'--force') cmd.append(b'--force')

mercurial/subrepoutil.py

from .i18n import _ from .i18n import _
from .pycompat import getattr from .pycompat import getattr
from . import ( from . import (
config, config,
error, error,
filemerge, filemerge,
pathutil, pathutil,
phases, phases,
pycompat,
util, util,
) )
from .utils import stringutil from .utils import stringutil
nullstate = (b'', b'', b'empty') nullstate = (b'', b'', b'empty')
def state(ctx, ui): def state(ctx, ui):
repo.ui.debug(b"subrepo merge %s %s %s\n" % (wctx, mctx, actx)) repo.ui.debug(b"subrepo merge %s %s %s\n" % (wctx, mctx, actx))
def debug(s, msg, r=b""): def debug(s, msg, r=b""):
if r: if r:
r = b"%s:%s:%s" % r r = b"%s:%s:%s" % r
repo.ui.debug(b" subrepo %s: %s %s\n" % (s, msg, r)) repo.ui.debug(b" subrepo %s: %s %s\n" % (s, msg, r))
promptssrc = filemerge.partextras(labels) promptssrc = filemerge.partextras(labels)
for s, l in sorted(s1.iteritems()): for s, l in sorted(pycompat.iteritems(s1)):
a = sa.get(s, nullstate) a = sa.get(s, nullstate)
ld = l # local state with possible dirty flag for compares ld = l # local state with possible dirty flag for compares
if wctx.sub(s).dirty(): if wctx.sub(s).dirty():
ld = (l[0], l[1] + b"+") ld = (l[0], l[1] + b"+")
if wctx == actx: # overwrite if wctx == actx: # overwrite
a = ld a = ld
prompts = promptssrc.copy() prompts = promptssrc.copy()

mercurial/tags.py

nullrev, nullrev,
short, short,
) )
from .i18n import _ from .i18n import _
from . import ( from . import (
encoding, encoding,
error, error,
match as matchmod, match as matchmod,
pycompat,
scmutil, scmutil,
util, util,
) )
from .utils import stringutil from .utils import stringutil
# Tags computation can be expensive and caches exist to make it fast in # Tags computation can be expensive and caches exist to make it fast in
# the common case. # the common case.
# #
The first one, 'alltags', is a "tagmaps" (see 'findglobaltags' for details). The first one, 'alltags', is a "tagmaps" (see 'findglobaltags' for details).
The second one, 'tagtypes', is optional and will be updated to track the The second one, 'tagtypes', is optional and will be updated to track the
"tagtype" of entries in the tagmaps. When set, the 'tagtype' argument also "tagtype" of entries in the tagmaps. When set, the 'tagtype' argument also
needs to be set.""" needs to be set."""
if tagtype is None: if tagtype is None:
assert tagtypes is None assert tagtypes is None
for name, nodehist in filetags.iteritems(): for name, nodehist in pycompat.iteritems(filetags):
if name not in alltags: if name not in alltags:
alltags[name] = nodehist alltags[name] = nodehist
if tagtype is not None: if tagtype is not None:
tagtypes[name] = tagtype tagtypes[name] = tagtype
continue continue
# we prefer alltags[name] if: # we prefer alltags[name] if:
# it supersedes us OR # it supersedes us OR
) )
else: else:
cachefile.write(b'%d %s\n' % (valid[0], hex(valid[1]))) cachefile.write(b'%d %s\n' % (valid[0], hex(valid[1])))
# Tag names in the cache are in UTF-8 -- which is the whole reason # Tag names in the cache are in UTF-8 -- which is the whole reason
# we keep them in UTF-8 throughout this module. If we converted # we keep them in UTF-8 throughout this module. If we converted
# them local encoding on input, we would lose info writing them to # them local encoding on input, we would lose info writing them to
# the cache. # the cache.
for (name, (node, hist)) in sorted(cachetags.iteritems()): for (name, (node, hist)) in sorted(pycompat.iteritems(cachetags)):
for n in hist: for n in hist:
cachefile.write(b"%s %s\n" % (hex(n), name)) cachefile.write(b"%s %s\n" % (hex(n), name))
cachefile.write(b"%s %s\n" % (hex(node), name)) cachefile.write(b"%s %s\n" % (hex(node), name))
try: try:
cachefile.close() cachefile.close()
except (OSError, IOError): except (OSError, IOError):
pass pass

mercurial/templatefilters.py

elif isinstance(obj, type(u'')): elif isinstance(obj, type(u'')):
raise error.ProgrammingError( raise error.ProgrammingError(
b'Mercurial only does output with bytes: %r' % obj b'Mercurial only does output with bytes: %r' % obj
) )
elif util.safehasattr(obj, b'keys'): elif util.safehasattr(obj, b'keys'):
out = [ out = [
b'"%s": %s' b'"%s": %s'
% (encoding.jsonescape(k, paranoid=paranoid), json(v, paranoid)) % (encoding.jsonescape(k, paranoid=paranoid), json(v, paranoid))
for k, v in sorted(obj.iteritems()) for k, v in sorted(pycompat.iteritems(obj))
] ]
return b'{' + b', '.join(out) + b'}' return b'{' + b', '.join(out) + b'}'
elif util.safehasattr(obj, b'__iter__'): elif util.safehasattr(obj, b'__iter__'):
out = [json(i, paranoid) for i in obj] out = [json(i, paranoid) for i in obj]
return b'[' + b', '.join(out) + b']' return b'[' + b', '.join(out) + b']'
raise error.ProgrammingError(b'cannot encode %r' % obj) raise error.ProgrammingError(b'cannot encode %r' % obj)
for regexp, format in websubtable: for regexp, format in websubtable:
text = regexp.sub(format, text) text = regexp.sub(format, text)
return text return text
def loadfilter(ui, extname, registrarobj): def loadfilter(ui, extname, registrarobj):
"""Load template filter from specified registrarobj """Load template filter from specified registrarobj
""" """
for name, func in registrarobj._table.iteritems(): for name, func in pycompat.iteritems(registrarobj._table):
filters[name] = func filters[name] = func
# tell hggettext to extract docstrings from these functions: # tell hggettext to extract docstrings from these functions:
i18nfunctions = filters.values() i18nfunctions = filters.values()

mercurial/templatefuncs.py

if not k: if not k:
raise error.ParseError(_(b'dict key cannot be inferred')) raise error.ParseError(_(b'dict key cannot be inferred'))
if k in data or k in args[b'kwargs']: if k in data or k in args[b'kwargs']:
raise error.ParseError(_(b"duplicated dict key '%s' inferred") % k) raise error.ParseError(_(b"duplicated dict key '%s' inferred") % k)
data[k] = evalfuncarg(context, mapping, v) data[k] = evalfuncarg(context, mapping, v)
data.update( data.update(
(k, evalfuncarg(context, mapping, v)) (k, evalfuncarg(context, mapping, v))
for k, v in args[b'kwargs'].iteritems() for k, v in pycompat.iteritems(args[b'kwargs'])
) )
return templateutil.hybriddict(data) return templateutil.hybriddict(data)
@templatefunc( @templatefunc(
b'diff([includepattern [, excludepattern]])', requires={b'ctx', b'ui'} b'diff([includepattern [, excludepattern]])', requires={b'ctx', b'ui'}
) )
def diff(context, mapping, args): def diff(context, mapping, args):
return b'' return b''
else: else:
return tokens[num] return tokens[num]
def loadfunction(ui, extname, registrarobj): def loadfunction(ui, extname, registrarobj):
"""Load template function from specified registrarobj """Load template function from specified registrarobj
""" """
for name, func in registrarobj._table.iteritems(): for name, func in pycompat.iteritems(registrarobj._table):
funcs[name] = func funcs[name] = func
# tell hggettext to extract docstrings from these functions: # tell hggettext to extract docstrings from these functions:
i18nfunctions = funcs.values() i18nfunctions = funcs.values()

mercurial/templatekw.py

ctx = context.resource(mapping, b'ctx') ctx = context.resource(mapping, b'ctx')
namespaces = util.sortdict() namespaces = util.sortdict()
def makensmapfn(ns): def makensmapfn(ns):
# 'name' for iterating over namespaces, templatename for local reference # 'name' for iterating over namespaces, templatename for local reference
return lambda v: {b'name': v, ns.templatename: v} return lambda v: {b'name': v, ns.templatename: v}
for k, ns in repo.names.iteritems(): for k, ns in pycompat.iteritems(repo.names):
names = ns.names(repo, ctx.node()) names = ns.names(repo, ctx.node())
f = _showcompatlist(context, mapping, b'name', names) f = _showcompatlist(context, mapping, b'name', names)
namespaces[k] = _hybrid(f, names, makensmapfn(ns), pycompat.identity) namespaces[k] = _hybrid(f, names, makensmapfn(ns), pycompat.identity)
f = _showcompatlist(context, mapping, b'namespace', list(namespaces)) f = _showcompatlist(context, mapping, b'namespace', list(namespaces))
def makemap(ns): def makemap(ns):
return { return {
@templatekeyword(b'peerurls', requires={b'repo'}) @templatekeyword(b'peerurls', requires={b'repo'})
def showpeerurls(context, mapping): def showpeerurls(context, mapping):
"""A dictionary of repository locations defined in the [paths] section """A dictionary of repository locations defined in the [paths] section
of your configuration file.""" of your configuration file."""
repo = context.resource(mapping, b'repo') repo = context.resource(mapping, b'repo')
# see commands.paths() for naming of dictionary keys # see commands.paths() for naming of dictionary keys
paths = repo.ui.paths paths = repo.ui.paths
urls = util.sortdict((k, p.rawloc) for k, p in sorted(paths.iteritems())) urls = util.sortdict(
(k, p.rawloc) for k, p in sorted(pycompat.iteritems(paths))
)
def makemap(k): def makemap(k):
p = paths[k] p = paths[k]
d = {b'name': k, b'url': p.rawloc} d = {b'name': k, b'url': p.rawloc}
d.update((o, v) for o, v in sorted(p.suboptions.iteritems())) d.update((o, v) for o, v in sorted(pycompat.iteritems(p.suboptions)))
return d return d
return _hybrid(None, urls, makemap, lambda k: b'%s=%s' % (k, urls[k])) return _hybrid(None, urls, makemap, lambda k: b'%s=%s' % (k, urls[k]))
@templatekeyword(b"predecessors", requires={b'repo', b'ctx'}) @templatekeyword(b"predecessors", requires={b'repo', b'ctx'})
def showpredecessors(context, mapping): def showpredecessors(context, mapping):
"""Returns the list of the closest visible predecessors. (EXPERIMENTAL)""" """Returns the list of the closest visible predecessors. (EXPERIMENTAL)"""
b'{reason} {node|short}' b'{reason} {node|short}'
) )
return templateutil.mappinglist(entries, tmpl=tmpl, sep=b'\n') return templateutil.mappinglist(entries, tmpl=tmpl, sep=b'\n')
def loadkeyword(ui, extname, registrarobj): def loadkeyword(ui, extname, registrarobj):
"""Load template keyword from specified registrarobj """Load template keyword from specified registrarobj
""" """
for name, func in registrarobj._table.iteritems(): for name, func in pycompat.iteritems(registrarobj._table):
keywords[name] = func keywords[name] = func
# tell hggettext to extract docstrings from these functions: # tell hggettext to extract docstrings from these functions:
i18nfunctions = keywords.values() i18nfunctions = keywords.values()

mercurial/templater.py

['l', 'k'] ['l', 'k']
>>> args = fargs(b'a(opts=1, k=2)', b'**opts') >>> args = fargs(b'a(opts=1, k=2)', b'**opts')
>>> list(args.keys()), list(args[b'opts'].keys()) >>> list(args.keys()), list(args[b'opts'].keys())
(['opts'], ['opts', 'k']) (['opts'], ['opts', 'k'])
""" """
def compiledict(xs): def compiledict(xs):
return util.sortdict( return util.sortdict(
(k, compileexp(x, context, curmethods)) for k, x in xs.iteritems() (k, compileexp(x, context, curmethods))
for k, x in pycompat.iteritems(xs)
) )
def compilelist(xs): def compilelist(xs):
return [compileexp(x, context, curmethods) for x in xs] return [compileexp(x, context, curmethods) for x in xs]
if not argspec: if not argspec:
# filter or function with no argspec: return list of positional args # filter or function with no argspec: return list of positional args
return compilelist(getlist(exp)) return compilelist(getlist(exp))
"""Create combined mapping from the original mapping and partial """Create combined mapping from the original mapping and partial
mapping to override the original""" mapping to override the original"""
# do not copy symbols which overrides the defaults depending on # do not copy symbols which overrides the defaults depending on
# new resources, so the defaults will be re-evaluated (issue5612) # new resources, so the defaults will be re-evaluated (issue5612)
knownres = self._resources.knownkeys() knownres = self._resources.knownkeys()
newres = self._resources.availablekeys(newmapping) newres = self._resources.availablekeys(newmapping)
mapping = { mapping = {
k: v k: v
for k, v in origmapping.iteritems() for k, v in pycompat.iteritems(origmapping)
if ( if (
k in knownres # not a symbol per self.symbol() k in knownres # not a symbol per self.symbol()
or newres.isdisjoint(self._defaultrequires(k)) or newres.isdisjoint(self._defaultrequires(k))
) )
} }
mapping.update(newmapping) mapping.update(newmapping)
mapping.update( mapping.update(
self._resources.populatemap(self, origmapping, newmapping) self._resources.populatemap(self, origmapping, newmapping)

mercurial/templateutil.py

# a nested hybrid list/dict, which has its own way of map operation # a nested hybrid list/dict, which has its own way of map operation
return val return val
return hybriditem(None, key, val, self._makemap) return hybriditem(None, key, val, self._makemap)
def filter(self, context, mapping, select): def filter(self, context, mapping, select):
if util.safehasattr(self._values, b'get'): if util.safehasattr(self._values, b'get'):
values = { values = {
k: v k: v
for k, v in self._values.iteritems() for k, v in pycompat.iteritems(self._values)
if select(self._wrapvalue(k, v)) if select(self._wrapvalue(k, v))
} }
else: else:
values = [v for v in self._values if select(self._wrapvalue(v, v))] values = [v for v in self._values if select(self._wrapvalue(v, v))]
return hybrid(None, values, self._makemap, self._joinfmt, self._keytype) return hybrid(None, values, self._makemap, self._joinfmt, self._keytype)
def itermaps(self, context): def itermaps(self, context):
makemap = self._makemap makemap = self._makemap
def tobool(self, context, mapping): def tobool(self, context, mapping):
return bool(self._values) return bool(self._values)
def tovalue(self, context, mapping): def tovalue(self, context, mapping):
# TODO: make it non-recursive for trivial lists/dicts # TODO: make it non-recursive for trivial lists/dicts
xs = self._values xs = self._values
if util.safehasattr(xs, b'get'): if util.safehasattr(xs, b'get'):
return { return {
k: unwrapvalue(context, mapping, v) for k, v in xs.iteritems() k: unwrapvalue(context, mapping, v)
for k, v in pycompat.iteritems(xs)
} }
return [unwrapvalue(context, mapping, x) for x in xs] return [unwrapvalue(context, mapping, x) for x in xs]
class hybriditem(mappable, wrapped): class hybriditem(mappable, wrapped):
"""Wrapper for non-list/dict object to support map operation """Wrapper for non-list/dict object to support map operation
This class allows us to handle both: This class allows us to handle both:
knownres = context.knownresourcekeys() knownres = context.knownresourcekeys()
items = [] items = []
for nm in self.itermaps(context): for nm in self.itermaps(context):
# drop internal resources (recursively) which shouldn't be displayed # drop internal resources (recursively) which shouldn't be displayed
lm = context.overlaymap(mapping, nm) lm = context.overlaymap(mapping, nm)
items.append( items.append(
{ {
k: unwrapvalue(context, lm, v) k: unwrapvalue(context, lm, v)
for k, v in nm.iteritems() for k, v in pycompat.iteritems(nm)
if k not in knownres if k not in knownres
} }
) )
return items return items
class mappinggenerator(_mappingsequence): class mappinggenerator(_mappingsequence):
"""Wrapper for generator of template mappings """Wrapper for generator of template mappings
plural=None, plural=None,
separator=b' ', separator=b' ',
): ):
"""Wrap data like hybriddict(), but also supports old-style list template """Wrap data like hybriddict(), but also supports old-style list template
This exists for backward compatibility with the old-style template. Use This exists for backward compatibility with the old-style template. Use
hybriddict() for new template keywords. hybriddict() for new template keywords.
""" """
c = [{key: k, value: v} for k, v in data.iteritems()] c = [{key: k, value: v} for k, v in pycompat.iteritems(data)]
f = _showcompatlist(context, mapping, name, c, plural, separator) f = _showcompatlist(context, mapping, name, c, plural, separator)
return hybriddict(data, key=key, value=value, fmt=fmt, gen=f) return hybriddict(data, key=key, value=value, fmt=fmt, gen=f)
def compatlist( def compatlist(
context, context,
mapping, mapping,
name, name,

mercurial/transaction.py

def removefilegenerator(self, genid): def removefilegenerator(self, genid):
"""reverse of addfilegenerator, remove a file generator function""" """reverse of addfilegenerator, remove a file generator function"""
if genid in self._filegenerators: if genid in self._filegenerators:
del self._filegenerators[genid] del self._filegenerators[genid]
def _generatefiles(self, suffix=b'', group=gengroupall): def _generatefiles(self, suffix=b'', group=gengroupall):
# write files registered for generation # write files registered for generation
any = False any = False
for id, entry in sorted(self._filegenerators.iteritems()): for id, entry in sorted(pycompat.iteritems(self._filegenerators)):
any = True any = True
order, filenames, genfunc, location = entry order, filenames, genfunc, location = entry
# for generation at closing, check if it's before or after finalize # for generation at closing, check if it's before or after finalize
postfinalize = group == gengrouppostfinalize postfinalize = group == gengrouppostfinalize
if ( if (
group != gengroupall group != gengroupall
and (id in postfinalizegenerators) != postfinalize and (id in postfinalizegenerators) != postfinalize

mercurial/ui.py

b'repo: %s' % rawloc b'repo: %s' % rawloc
) )
suboptions = suboptions or {} suboptions = suboptions or {}
# Now process the sub-options. If a sub-option is registered, its # Now process the sub-options. If a sub-option is registered, its
# attribute will always be present. The value will be None if there # attribute will always be present. The value will be None if there
# was no valid sub-option. # was no valid sub-option.
for suboption, (attr, func) in _pathsuboptions.iteritems(): for suboption, (attr, func) in pycompat.iteritems(_pathsuboptions):
if suboption not in suboptions: if suboption not in suboptions:
setattr(self, attr, None) setattr(self, attr, None)
continue continue
value = func(ui, self, suboptions[suboption]) value = func(ui, self, suboptions[suboption])
setattr(self, attr, value) setattr(self, attr, value)
def _isvalidlocalpath(self, path): def _isvalidlocalpath(self, path):
@property @property
def suboptions(self): def suboptions(self):
"""Return sub-options and their values for this path. """Return sub-options and their values for this path.
This is intended to be used for presentation purposes. This is intended to be used for presentation purposes.
""" """
d = {} d = {}
for subopt, (attr, _func) in _pathsuboptions.iteritems(): for subopt, (attr, _func) in pycompat.iteritems(_pathsuboptions):
value = getattr(self, attr) value = getattr(self, attr)
if value is not None: if value is not None:
d[subopt] = value d[subopt] = value
return d return d
# we instantiate one globally shared progress bar to avoid # we instantiate one globally shared progress bar to avoid
# competing progress bars when multiple UI objects get created # competing progress bars when multiple UI objects get created

mercurial/url.py

proxyheaders = dict( proxyheaders = dict(
[ [
(x, self.headers[x]) (x, self.headers[x])
for x in self.headers for x in self.headers
if x.lower().startswith(r'proxy-') if x.lower().startswith(r'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 proxyheaders.iteritems(): 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
# strict was removed in Python 3.4. # strict was removed in Python 3.4.
kwargs = {} kwargs = {}

mercurial/util.py

if key in self: if key in self:
del self[key] del self[key]
super(sortdict, self).__setitem__(key, value) super(sortdict, self).__setitem__(key, value)
if pycompat.ispypy: if pycompat.ispypy:
# __setitem__() isn't called as of PyPy 5.8.0 # __setitem__() isn't called as of PyPy 5.8.0
def update(self, src): def update(self, src):
if isinstance(src, dict): if isinstance(src, dict):
src = src.iteritems() src = pycompat.iteritems(src)
for k, v in src: for k, v in src:
self[k] = v self[k] = v
class cowdict(cow, dict): class cowdict(cow, dict):
"""copy-on-write dict """copy-on-write dict
Be sure to call d = d.preparewrite() before writing to d. Be sure to call d = d.preparewrite() before writing to d.
class dirs(object): class dirs(object):
'''a multiset of directory names from a dirstate or manifest''' '''a multiset of directory names from a dirstate or manifest'''
def __init__(self, map, skip=None): def __init__(self, map, skip=None):
self._dirs = {} self._dirs = {}
addpath = self.addpath addpath = self.addpath
if isinstance(map, dict) and skip is not None: if isinstance(map, dict) and skip is not None:
for f, s in map.iteritems(): for f, s in pycompat.iteritems(map):
if s[0] != skip: if s[0] != skip:
addpath(f) addpath(f)
elif skip is not None: elif skip is not None:
raise error.ProgrammingError( raise error.ProgrammingError(
b"skip character is only supported " b"with a dict source" b"skip character is only supported " b"with a dict source"
) )
else: else:
for f in map: for f in map:

mercurial/utils/cborutil.py

def streamencodemap(d): def streamencodemap(d):
"""Encode dictionary to a generator. """Encode dictionary to a generator.
Does not supporting indefinite length dictionaries. Does not supporting indefinite length dictionaries.
""" """
yield encodelength(MAJOR_TYPE_MAP, len(d)) yield encodelength(MAJOR_TYPE_MAP, len(d))
for key, value in sorted( for key, value in sorted(
d.iteritems(), key=lambda x: _mixedtypesortkey(x[0]) pycompat.iteritems(d), key=lambda x: _mixedtypesortkey(x[0])
): ):
for chunk in streamencode(key): for chunk in streamencode(key):
yield chunk yield chunk
for chunk in streamencode(value): for chunk in streamencode(value):
yield chunk yield chunk
def streamencodemapfromiter(it): def streamencodemapfromiter(it):

mercurial/utils/procutil.py

_filtertable = { _filtertable = {
b'tempfile:': tempfilter, b'tempfile:': tempfilter,
b'pipe:': pipefilter, b'pipe:': pipefilter,
} }
def filter(s, cmd): def filter(s, cmd):
b"filter a string through a command that transforms its input to its output" b"filter a string through a command that transforms its input to its output"
for name, fn in _filtertable.iteritems(): for name, fn in pycompat.iteritems(_filtertable):
if cmd.startswith(name): if cmd.startswith(name):
return fn(s, cmd[len(name) :].lstrip()) return fn(s, cmd[len(name) :].lstrip())
return pipefilter(s, cmd) return pipefilter(s, cmd)
def mainfrozen(): def mainfrozen():
"""return True if we are a frozen executable. """return True if we are a frozen executable.
if val is None or val is False: if val is None or val is False:
return b'0' return b'0'
if val is True: if val is True:
return b'1' return b'1'
return pycompat.bytestr(val) return pycompat.bytestr(val)
env = dict(encoding.environ) env = dict(encoding.environ)
if environ: if environ:
env.update((k, py2shell(v)) for k, v in environ.iteritems()) env.update((k, py2shell(v)) for k, v in pycompat.iteritems(environ))
env[b'HG'] = hgexecutable() env[b'HG'] = hgexecutable()
return env return env
if pycompat.iswindows: if pycompat.iswindows:
def shelltonative(cmd, env): def shelltonative(cmd, env):
return platform.shelltocmdexe(cmd, shellenviron(env)) return platform.shelltocmdexe(cmd, shellenviron(env))

mercurial/verify.py

self._err(None, _(b"cannot decode filename '%s'") % f2) self._err(None, _(b"cannot decode filename '%s'") % f2)
elif (size > 0 or not revlogv1) and f.startswith(b'meta/'): elif (size > 0 or not revlogv1) and f.startswith(b'meta/'):
storefiles.add(_normpath(f)) storefiles.add(_normpath(f))
subdirs.add(os.path.dirname(f)) subdirs.add(os.path.dirname(f))
subdirprogress = ui.makeprogress( subdirprogress = ui.makeprogress(
_(b'checking'), unit=_(b'manifests'), total=len(subdirs) _(b'checking'), unit=_(b'manifests'), total=len(subdirs)
) )
for subdir, linkrevs in subdirnodes.iteritems(): for subdir, linkrevs in pycompat.iteritems(subdirnodes):
subdirfilenodes = self._verifymanifest( subdirfilenodes = self._verifymanifest(
linkrevs, subdir, storefiles, subdirprogress linkrevs, subdir, storefiles, subdirprogress
) )
for f, onefilenodes in subdirfilenodes.iteritems(): for f, onefilenodes in pycompat.iteritems(subdirfilenodes):
filenodes.setdefault(f, {}).update(onefilenodes) filenodes.setdefault(f, {}).update(onefilenodes)
if not dir and subdirnodes: if not dir and subdirnodes:
subdirprogress.complete() subdirprogress.complete()
if self.warnorphanstorefiles: if self.warnorphanstorefiles:
for f in sorted(storefiles): for f in sorted(storefiles):
self._warn(_(b"warning: orphan data file '%s'") % f) self._warn(_(b"warning: orphan data file '%s'") % f)
fl2.rev(rp[1]) fl2.rev(rp[1])
except Exception as inst: except Exception as inst:
self._exc( self._exc(
lr, _(b"checking rename of %s") % short(n), inst, f lr, _(b"checking rename of %s") % short(n), inst, f
) )
# cross-check # cross-check
if f in filenodes: if f in filenodes:
fns = [(v, k) for k, v in filenodes[f].iteritems()] fns = [(v, k) for k, v in pycompat.iteritems(filenodes[f])]
for lr, node in sorted(fns): for lr, node in sorted(fns):
self._err( self._err(
lr, lr,
_(b"manifest refers to unknown revision %s") _(b"manifest refers to unknown revision %s")
% short(node), % short(node),
f, f,
) )
progress.complete() progress.complete()
if self.warnorphanstorefiles: if self.warnorphanstorefiles:
for f in sorted(storefiles): for f in sorted(storefiles):
self._warn(_(b"warning: orphan data file '%s'") % f) self._warn(_(b"warning: orphan data file '%s'") % f)
return len(files), revisions return len(files), revisions

mercurial/wireprotoframing.py

FRAME_TYPE_STREAM_SETTINGS: FLAGS_STREAM_ENCODING_SETTINGS, FRAME_TYPE_STREAM_SETTINGS: FLAGS_STREAM_ENCODING_SETTINGS,
} }
ARGUMENT_RECORD_HEADER = struct.Struct(r'<HH') ARGUMENT_RECORD_HEADER = struct.Struct(r'<HH')
def humanflags(mapping, value): def humanflags(mapping, value):
"""Convert a numeric flags value to a human value, using a mapping table.""" """Convert a numeric flags value to a human value, using a mapping table."""
namemap = {v: k for k, v in mapping.iteritems()} namemap = {v: k for k, v in pycompat.iteritems(mapping)}
flags = [] flags = []
val = 1 val = 1
while value >= val: while value >= val:
if value & val: if value & val:
flags.append(namemap.get(val, b'<unknown 0x%02x>' % val)) flags.append(namemap.get(val, b'<unknown 0x%02x>' % val))
val <<= 1 val <<= 1
return b'|'.join(flags) return b'|'.join(flags)
streamflags = attr.ib() streamflags = attr.ib()
typeid = attr.ib() typeid = attr.ib()
flags = attr.ib() flags = attr.ib()
payload = attr.ib() payload = attr.ib()
@encoding.strmethod @encoding.strmethod
def __repr__(self): def __repr__(self):
typename = b'<unknown 0x%02x>' % self.typeid typename = b'<unknown 0x%02x>' % self.typeid
for name, value in FRAME_TYPES.iteritems(): for name, value in pycompat.iteritems(FRAME_TYPES):
if value == self.typeid: if value == self.typeid:
typename = name typename = name
break break
return ( return (
b'frame(size=%d; request=%d; stream=%d; streamflags=%s; ' b'frame(size=%d; request=%d; stream=%d; streamflags=%s; '
b'type=%s; flags=%s)' b'type=%s; flags=%s)'
% ( % (

mercurial/wireprotov1peer.py

for op, argsdict in req: for op, argsdict in req:
# Old servers didn't properly unescape argument names. So prevent # Old servers didn't properly unescape argument names. So prevent
# the sending of argument names that may not be decoded properly by # the sending of argument names that may not be decoded properly by
# servers. # servers.
assert all(escapearg(k) == k for k in argsdict) assert all(escapearg(k) == k for k in argsdict)
args = b','.join( args = b','.join(
b'%s=%s' % (escapearg(k), escapearg(v)) b'%s=%s' % (escapearg(k), escapearg(v))
for k, v in argsdict.iteritems() for k, v in pycompat.iteritems(argsdict)
) )
cmds.append(b'%s %s' % (op, args)) cmds.append(b'%s %s' % (op, args))
return b';'.join(cmds) return b';'.join(cmds)
class unsentfuture(pycompat.futures.Future): class unsentfuture(pycompat.futures.Future):
"""A Future variation to represent an unsent command. """A Future variation to represent an unsent command.
def stream_out(self): def stream_out(self):
return self._callstream(b'stream_out') return self._callstream(b'stream_out')
def getbundle(self, source, **kwargs): def getbundle(self, source, **kwargs):
kwargs = pycompat.byteskwargs(kwargs) kwargs = pycompat.byteskwargs(kwargs)
self.requirecap(b'getbundle', _(b'look up remote changes')) self.requirecap(b'getbundle', _(b'look up remote changes'))
opts = {} opts = {}
bundlecaps = kwargs.get(b'bundlecaps') or set() bundlecaps = kwargs.get(b'bundlecaps') or set()
for key, value in kwargs.iteritems(): for key, value in pycompat.iteritems(kwargs):
if value is None: if value is None:
continue continue
keytype = wireprototypes.GETBUNDLE_ARGUMENTS.get(key) keytype = wireprototypes.GETBUNDLE_ARGUMENTS.get(key)
if keytype is None: if keytype is None:
raise error.ProgrammingError( raise error.ProgrammingError(
b'Unexpectedly None keytype for key %s' % key b'Unexpectedly None keytype for key %s' % key
) )
elif keytype == b'nodes': elif keytype == b'nodes':

mercurial/wireprotov1server.py

return wireprototypes.bytesresponse(b''.join(r)) return wireprototypes.bytesresponse(b''.join(r))
@wireprotocommand(b'branchmap', permission=b'pull') @wireprotocommand(b'branchmap', permission=b'pull')
def branchmap(repo, proto): def branchmap(repo, proto):
branchmap = repo.branchmap() branchmap = repo.branchmap()
heads = [] heads = []
for branch, nodes in branchmap.iteritems(): for branch, nodes in pycompat.iteritems(branchmap):
branchname = urlreq.quote(encoding.fromlocal(branch)) branchname = urlreq.quote(encoding.fromlocal(branch))
branchnodes = wireprototypes.encodelist(nodes) branchnodes = wireprototypes.encodelist(nodes)
heads.append(b'%s %s' % (branchname, branchnodes)) heads.append(b'%s %s' % (branchname, branchnodes))
return wireprototypes.bytesresponse(b'\n'.join(heads)) return wireprototypes.bytesresponse(b'\n'.join(heads))
@wireprotocommand(b'branches', b'nodes', permission=b'pull') @wireprotocommand(b'branches', b'nodes', permission=b'pull')
return None return None
@wireprotocommand(b'getbundle', b'*', permission=b'pull') @wireprotocommand(b'getbundle', b'*', permission=b'pull')
def getbundle(repo, proto, others): def getbundle(repo, proto, others):
opts = options( opts = options(
b'getbundle', wireprototypes.GETBUNDLE_ARGUMENTS.keys(), others b'getbundle', wireprototypes.GETBUNDLE_ARGUMENTS.keys(), others
) )
for k, v in opts.iteritems(): for k, v in pycompat.iteritems(opts):
keytype = wireprototypes.GETBUNDLE_ARGUMENTS[k] keytype = wireprototypes.GETBUNDLE_ARGUMENTS[k]
if keytype == b'nodes': if keytype == b'nodes':
opts[k] = wireprototypes.decodelist(v) opts[k] = wireprototypes.decodelist(v)
elif keytype == b'csv': elif keytype == b'csv':
opts[k] = list(v.split(b',')) opts[k] = list(v.split(b','))
elif keytype == b'scsv': elif keytype == b'scsv':
opts[k] = set(v.split(b',')) opts[k] = set(v.split(b','))
elif keytype == b'boolean': elif keytype == b'boolean':

mercurial/wireprotov2server.py

b'unknown revision specifier type: %s', (typ,) b'unknown revision specifier type: %s', (typ,)
) )
return nodes return nodes
@wireprotocommand(b'branchmap', permission=b'pull') @wireprotocommand(b'branchmap', permission=b'pull')
def branchmapv2(repo, proto): def branchmapv2(repo, proto):
yield {encoding.fromlocal(k): v for k, v in repo.branchmap().iteritems()} yield {
encoding.fromlocal(k): v
for k, v in pycompat.iteritems(repo.branchmap())
}
@wireprotocommand(b'capabilities', permission=b'pull') @wireprotocommand(b'capabilities', permission=b'pull')
def capabilitiesv2(repo, proto): def capabilitiesv2(repo, proto):
yield _capabilitiesv2(repo, proto) yield _capabilitiesv2(repo, proto)
@wireprotocommand( @wireprotocommand(
yield d yield d
for extra in followingdata: for extra in followingdata:
yield extra yield extra
# If requested, send bookmarks from nodes that didn't have revision # If requested, send bookmarks from nodes that didn't have revision
# data sent so receiver is aware of any bookmark updates. # data sent so receiver is aware of any bookmark updates.
if b'bookmarks' in fields: if b'bookmarks' in fields:
for node, marks in sorted(nodebookmarks.iteritems()): for node, marks in sorted(pycompat.iteritems(nodebookmarks)):
yield { yield {
b'node': node, b'node': node,
b'bookmarks': sorted(marks), b'bookmarks': sorted(marks),
} }
class FileAccessError(Exception): class FileAccessError(Exception):
"""Represents an error accessing a specific file.""" """Represents an error accessing a specific file."""
b'listkeys', b'listkeys',
args={b'namespace': {b'type': b'bytes', b'example': b'ns',},}, args={b'namespace': {b'type': b'bytes', b'example': b'ns',},},
permission=b'pull', permission=b'pull',
) )
def listkeysv2(repo, proto, namespace): def listkeysv2(repo, proto, namespace):
keys = repo.listkeys(encoding.tolocal(namespace)) keys = repo.listkeys(encoding.tolocal(namespace))
keys = { keys = {
encoding.fromlocal(k): encoding.fromlocal(v) encoding.fromlocal(k): encoding.fromlocal(v)
for k, v in keys.iteritems() for k, v in pycompat.iteritems(keys)
} }
yield keys yield keys
@wireprotocommand( @wireprotocommand(
b'lookup', b'lookup',
args={b'key': {b'type': b'bytes', b'example': b'foo',},}, args={b'key': {b'type': b'bytes', b'example': b'foo',},},