( )⚙ D12318 global: bulk replace simple pycompat.iteritems(x) with x.items()

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D12318

global: bulk replace simple pycompat.iteritems(x) with x.items()
ClosedPublic

Authored by indygreg on Mar 3 2022, 4:21 PM.

Details

Reviewers
durin42
martinvonz
Alphare
Group Reviewers
hg-reviewers
Commits
rHGf254fc73d956: global: bulk replace simple pycompat.iteritems(x) with x.items()
Summary

pycompat.iteritems() just calls .items().

This commit applies a regular expression search and replace to convert
simple instances of pycompat.iteritems() with .items(). There are still
a handful of calls to pycompat.iteritems() remaining. But these all have
more complicated expressions that I wasn't comfortable performing an
automated replace on. In addition, some simple replacements were withheld
because they broke pytype. These will be handled by their own changesets.

Diff Detail

Repository
rHG Mercurial
Branch
default
Lint
No Linters Available
Unit
No Unit Test Coverage

Event Timeline

indygreg created this revision.Mar 3 2022, 4:21 PM
indygreg edited the summary of this revision. (Show Details)Mar 3 2022, 9:31 PM
indygreg updated this revision to Diff 32549.
Alphare accepted this revision.Mar 8 2022, 4:24 AM
This revision is now accepted and ready to land.Mar 8 2022, 4:24 AM

Revision Contents
Changeset List

PathPackages
Mhgext/absorb.py (17 lines)
Mhgext/convert/bzr.py (3 lines)
Mhgext/convert/common.py (2 lines)
Mhgext/convert/convcmd.py (4 lines)
Mhgext/convert/cvsps.py (2 lines)
Mhgext/convert/filemap.py (2 lines)
Mhgext/convert/hg.py (6 lines)
Mhgext/convert/monotone.py (2 lines)
Mhgext/convert/subversion.py (14 lines)
Mhgext/eol.py (2 lines)
Mhgext/fastannotate/context.py (6 lines)
Mhgext/fastannotate/protocol.py (3 lines)
Mhgext/fix.py (8 lines)
Mhgext/fsmonitor/__init__.py (8 lines)
Mhgext/githelp.py (4 lines)
Mhgext/hgk.py (4 lines)
Mhgext/histedit.py (8 lines)
Mhgext/infinitepush/__init__.py (16 lines)
Mhgext/infinitepush/bundleparts.py (3 lines)
Mhgext/infinitepush/sqlindexapi.py (4 lines)
Mhgext/journal.py (2 lines)
Mhgext/keyword.py (4 lines)
Mhgext/largefiles/overrides.py (2 lines)
Mhgext/lfs/pointer.py (2 lines)
Mhgext/lfs/wrapper.py (3 lines)
Mhgext/mq.py (4 lines)
Mhgext/phabricator.py (4 lines)
Mhgext/rebase.py (8 lines)
Mhgext/releasenotes.py (2 lines)
Mhgext/remotefilelog/basestore.py (2 lines)
Mhgext/remotefilelog/datapack.py (2 lines)
Mhgext/remotefilelog/historypack.py (4 lines)
Mhgext/remotefilelog/remotefilelog.py (7 lines)
Mhgext/remotefilelog/remotefilelogserver.py (3 lines)
Mhgext/remotefilelog/repack.py (8 lines)
Mhgext/remotefilelog/shallowrepo.py (5 lines)
Mhgext/remotefilelog/shallowutil.py (6 lines)
Mhgext/remotenames.py (10 lines)
Mhgext/uncommit.py (4 lines)
Mhgext/win32text.py (2 lines)
Mmercurial/archival.py (2 lines)
Mmercurial/bookmarks.py (12 lines)
Mmercurial/branchmap.py (8 lines)
Mmercurial/bundle2.py (2 lines)
Mmercurial/changegroup.py (4 lines)
Mmercurial/chgserver.py (4 lines)
Mmercurial/cmdutil.py (2 lines)
Mmercurial/commands.py (4 lines)
Mmercurial/context.py (2 lines)
Mmercurial/copies.py (17 lines)
Mmercurial/debugcommands.py (10 lines)
Mmercurial/dirstate.py (10 lines)
Mmercurial/dirstatemap.py (7 lines)
Mmercurial/discovery.py (12 lines)
Mmercurial/dispatch.py (2 lines)
Mmercurial/exchange.py (4 lines)
Mmercurial/extensions.py (18 lines)
Mmercurial/exthelper.py (3 lines)
Mmercurial/filemerge.py (2 lines)
Mmercurial/fileset.py (2 lines)
Mmercurial/formatter.py (2 lines)
Mmercurial/help.py (6 lines)
Mmercurial/hgweb/hgweb_mod.py (2 lines)
Mmercurial/hgweb/request.py (6 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/localrepo.py (11 lines)
Mmercurial/logcmdutil.py (4 lines)
Mmercurial/logexchange.py (5 lines)
Mmercurial/lsprof.py (3 lines)
Mmercurial/manifest.py (31 lines)
Mmercurial/match.py (2 lines)
Mmercurial/merge.py (26 lines)
Mmercurial/mergestate.py (10 lines)
Mmercurial/namespaces.py (5 lines)
Mmercurial/obsolete.py (6 lines)
Mmercurial/obsutil.py (3 lines)
Mmercurial/patch.py (6 lines)
Mmercurial/pathutil.py (2 lines)
Mmercurial/phases.py (16 lines)
Mmercurial/pure/parsers.py (3 lines)
Mmercurial/revlog.py (2 lines)
Mmercurial/revset.py (6 lines)
Mmercurial/revsetlang.py (2 lines)
Mmercurial/scmutil.py (13 lines)
Mmercurial/similar.py (3 lines)
Mmercurial/sparse.py (2 lines)
Mmercurial/sshpeer.py (4 lines)
Mmercurial/statprof.py (8 lines)
Mmercurial/store.py (2 lines)
Mmercurial/strip.py (2 lines)
Mmercurial/subrepo.py (2 lines)
Mmercurial/subrepoutil.py (2 lines)
Mmercurial/tags.py (7 lines)
Mmercurial/templatefilters.py (4 lines)
Mmercurial/templatefuncs.py (2 lines)
Mmercurial/templatekw.py (6 lines)
Mmercurial/templater.py (5 lines)
Mmercurial/templateutil.py (11 lines)
Mmercurial/transaction.py (2 lines)
Mmercurial/url.py (2 lines)
Mmercurial/util.py (2 lines)
Mmercurial/utils/cborutil.py (4 lines)
Mmercurial/utils/procutil.py (4 lines)
Mmercurial/utils/urlutil.py (6 lines)
Mmercurial/verify.py (4 lines)
Mmercurial/wireprotoframing.py (4 lines)
Mmercurial/wireprotov1peer.py (5 lines)
Mmercurial/wireprotov1server.py (4 lines)

Diff 32549

hgext/absorb.py

fm.data(linetype=b'path') fm.data(linetype=b'path')
fstate.diffwith(targetfctx, fm) fstate.diffwith(targetfctx, fm)
self.fixupmap[path] = fstate self.fixupmap[path] = fstate
self.paths.append(path) self.paths.append(path)
self.ctxaffected.update(fstate.ctxaffected) self.ctxaffected.update(fstate.ctxaffected)
def apply(self): def apply(self):
"""apply fixups to individual filefixupstates""" """apply fixups to individual filefixupstates"""
for path, state in pycompat.iteritems(self.fixupmap): for path, state in self.fixupmap.items():
if self.ui.debugflag: if self.ui.debugflag:
self.ui.write(_(b'applying fixups to %s\n') % path) self.ui.write(_(b'applying fixups to %s\n') % path)
state.apply() state.apply()
@property @property
def chunkstats(self): def chunkstats(self):
"""-> {path: chunkstats}. collect chunkstats from filefixupstates""" """-> {path: chunkstats}. collect chunkstats from filefixupstates"""
return { return {path: state.chunkstats for path, state in self.fixupmap.items()}
path: state.chunkstats
for path, state in pycompat.iteritems(self.fixupmap)
}
def commit(self): def commit(self):
"""commit changes. update self.finalnode, self.replacemap""" """commit changes. update self.finalnode, self.replacemap"""
with self.repo.transaction(b'absorb') as tr: with self.repo.transaction(b'absorb') as tr:
self._commitstack() self._commitstack()
self._movebookmarks(tr) self._movebookmarks(tr)
if self.repo[b'.'].node() in self.replacemap: if self.repo[b'.'].node() in self.replacemap:
self._moveworkingdirectoryparent() self._moveworkingdirectoryparent()
self._cleanupoldcommits() self._cleanupoldcommits()
return self.finalnode return self.finalnode
def printchunkstats(self): def printchunkstats(self):
"""print things like '1 of 2 chunk(s) applied'""" """print things like '1 of 2 chunk(s) applied'"""
ui = self.ui ui = self.ui
chunkstats = self.chunkstats chunkstats = self.chunkstats
if ui.verbose: if ui.verbose:
# chunkstats for each file # chunkstats for each file
for path, stat in pycompat.iteritems(chunkstats): for path, stat in chunkstats.items():
if stat[0]: if stat[0]:
ui.write( ui.write(
_(b'%s: %d of %d chunk(s) applied\n') _(b'%s: %d of %d chunk(s) applied\n')
% (path, stat[0], stat[1]) % (path, stat[0], stat[1])
) )
elif not ui.quiet: elif not ui.quiet:
# a summary for all files # a summary for all files
stats = chunkstats.values() stats = chunkstats.values()
if content != newcontent: if content != newcontent:
result[fctx.path()] = newcontent result[fctx.path()] = newcontent
return result return result
def _movebookmarks(self, tr): def _movebookmarks(self, tr):
repo = self.repo repo = self.repo
needupdate = [ needupdate = [
(name, self.replacemap[hsh]) (name, self.replacemap[hsh])
for name, hsh in pycompat.iteritems(repo._bookmarks) for name, hsh in repo._bookmarks.items()
if hsh in self.replacemap if hsh in self.replacemap
] ]
changes = [] changes = []
for name, hsh in needupdate: for name, hsh in needupdate:
if hsh: if hsh:
changes.append((name, hsh)) changes.append((name, hsh))
if self.ui.verbose: if self.ui.verbose:
self.ui.write( self.ui.write(
pctx = parents[0] pctx = parents[0]
if ctx.branch() != pctx.branch(): if ctx.branch() != pctx.branch():
return False return False
if ctx.extra().get(b'close'): if ctx.extra().get(b'close'):
return False return False
# ctx changes more files (not a subset of memworkingcopy) # ctx changes more files (not a subset of memworkingcopy)
if not set(ctx.files()).issubset(set(memworkingcopy)): if not set(ctx.files()).issubset(set(memworkingcopy)):
return False return False
for path, content in pycompat.iteritems(memworkingcopy): for path, content in memworkingcopy.items():
if path not in pctx or path not in ctx: if path not in pctx or path not in ctx:
return False return False
fctx = ctx[path] fctx = ctx[path]
pfctx = pctx[path] pfctx = pctx[path]
if pfctx.flags() != fctx.flags(): if pfctx.flags() != fctx.flags():
return False return False
if pfctx.data() != content: if pfctx.data() != content:
return False return False
@util.propertycache @util.propertycache
def _useobsolete(self): def _useobsolete(self):
"""() -> bool""" """() -> bool"""
return obsolete.isenabled(self.repo, obsolete.createmarkersopt) return obsolete.isenabled(self.repo, obsolete.createmarkersopt)
def _cleanupoldcommits(self): def _cleanupoldcommits(self):
replacements = { replacements = {
k: ([v] if v is not None else []) k: ([v] if v is not None else [])
for k, v in pycompat.iteritems(self.replacemap) for k, v in self.replacemap.items()
} }
if replacements: if replacements:
scmutil.cleanupnodes( scmutil.cleanupnodes(
self.repo, replacements, operation=b'absorb', fixphase=True self.repo, replacements, operation=b'absorb', fixphase=True
) )
@util.propertycache @util.propertycache
def skip_empty_successor(self): def skip_empty_successor(self):
# change, no binary diff, and no renames, it's probably okay to # change, no binary diff, and no renames, it's probably okay to
# re-invent the logic using much simpler code here. # re-invent the logic using much simpler code here.
memworkingcopy = {} # {path: content} memworkingcopy = {} # {path: content}
patchmap = defaultdict(lambda: []) # {path: [(a1, a2, [bline])]} patchmap = defaultdict(lambda: []) # {path: [(a1, a2, [bline])]}
for path, info in map(_parsechunk, chunks): for path, info in map(_parsechunk, chunks):
if not path or not info: if not path or not info:
continue continue
patchmap[path].append(info) patchmap[path].append(info)
for path, patches in pycompat.iteritems(patchmap): for path, patches in patchmap.items():
if path not in ctx or not patches: if path not in ctx or not patches:
continue continue
patches.sort(reverse=True) patches.sort(reverse=True)
lines = mdiff.splitnewlines(ctx[path].data()) lines = mdiff.splitnewlines(ctx[path].data())
for a1, a2, blines in patches: for a1, a2, blines in patches:
lines[a1:a2] = blines lines[a1:a2] = blines
memworkingcopy[path] = b''.join(lines) memworkingcopy[path] = b''.join(lines)
return overlaycontext(memworkingcopy, ctx) return overlaycontext(memworkingcopy, ctx)

hgext/convert/bzr.py

# it cannot access `bar` repositories, but they were never used very much. # it cannot access `bar` repositories, but they were never used very much.
import os import os
from mercurial.i18n import _ from mercurial.i18n import _
from mercurial import ( from mercurial import (
demandimport, demandimport,
error, error,
pycompat,
util, util,
) )
from . import common from . import common
# these do not work with demandimport, blacklist # these do not work with demandimport, blacklist
demandimport.IGNORES.update( demandimport.IGNORES.update(
[ [
) )
def gettags(self): def gettags(self):
bytetags = {} bytetags = {}
for branch in self._bzrbranches(): for branch in self._bzrbranches():
if not branch.supports_tags(): if not branch.supports_tags():
return {} return {}
tagdict = branch.tags.get_tag_dict() tagdict = branch.tags.get_tag_dict()
for name, rev in pycompat.iteritems(tagdict): for name, rev in tagdict.items():
bytetags[self.recode(name)] = rev bytetags[self.recode(name)] = rev
return bytetags return bytetags
def getchangedfiles(self, rev, i): def getchangedfiles(self, rev, i):
self._modecache = {} self._modecache = {}
curtree = self.sourcerepo.revision_tree(rev) curtree = self.sourcerepo.revision_tree(rev)
if i is not None: if i is not None:
parentid = self._parentids[rev][i] parentid = self._parentids[rev][i]

hgext/convert/common.py

pass pass
def postrun(self): def postrun(self):
pass pass
def _cmdline(self, cmd, *args, **kwargs): def _cmdline(self, cmd, *args, **kwargs):
kwargs = pycompat.byteskwargs(kwargs) kwargs = pycompat.byteskwargs(kwargs)
cmdline = [self.command, cmd] + list(args) cmdline = [self.command, cmd] + list(args)
for k, v in pycompat.iteritems(kwargs): for k, v in kwargs.items():
if len(k) == 1: if len(k) == 1:
cmdline.append(b'-' + k) cmdline.append(b'-' + k)
else: else:
cmdline.append(b'--' + k.replace(b'_', b'-')) cmdline.append(b'--' + k.replace(b'_', b'-'))
try: try:
if len(k) == 1: if len(k) == 1:
cmdline.append(b'' + v) cmdline.append(b'' + v)
else: else:

hgext/convert/convcmd.py

ctags[k] = self.map[v] ctags[k] = self.map[v]
if c and ctags: if c and ctags:
nrev, tagsparent = self.dest.puttags(ctags) nrev, tagsparent = self.dest.puttags(ctags)
if nrev and tagsparent: if nrev and tagsparent:
# write another hash correspondence to override the # write another hash correspondence to override the
# previous one so we don't end up with extra tag heads # previous one so we don't end up with extra tag heads
tagsparents = [ tagsparents = [
e e for e in self.map.items() if e[1] == tagsparent
for e in pycompat.iteritems(self.map)
if e[1] == tagsparent
] ]
if tagsparents: if tagsparents:
self.map[tagsparents[0][0]] = nrev self.map[tagsparents[0][0]] = nrev
bookmarks = self.source.getbookmarks() bookmarks = self.source.getbookmarks()
cbookmarks = {} cbookmarks = {}
for k in bookmarks: for k in bookmarks:
v = bookmarks[k] v = bookmarks[k]

hgext/convert/cvsps.py

revn = len(e.revision) revn = len(e.revision)
if revn > 3 and (revn % 2) == 0: if revn > 3 and (revn % 2) == 0:
e.branch = tags.get(e.revision[:-1], [None])[0] e.branch = tags.get(e.revision[:-1], [None])[0]
else: else:
e.branch = None e.branch = None
# find the branches starting from this revision # find the branches starting from this revision
branchpoints = set() branchpoints = set()
for branch, revision in pycompat.iteritems(branchmap): for branch, revision in branchmap.items():
revparts = tuple([int(i) for i in revision.split(b'.')]) revparts = tuple([int(i) for i in revision.split(b'.')])
if len(revparts) < 2: # bad tags if len(revparts) < 2: # bad tags
continue continue
if revparts[-2] == 0 and revparts[-1] % 2 == 0: if revparts[-2] == 0 and revparts[-1] % 2 == 0:
# normal branch # normal branch
if revparts[:-2] == e.revision: if revparts[:-2] == e.revision:
branchpoints.add(branch) branchpoints.add(branch)
elif revparts == (1, 1, 1): # vendor branch elif revparts == (1, 1, 1): # vendor branch

hgext/convert/filemap.py

return b'', name, b'' return b'', name, b''
def istargetfile(self, filename): def istargetfile(self, filename):
"""Return true if the given target filename is covered as a destination """Return true if the given target filename is covered as a destination
of the filemap. This is useful for identifying what parts of the target of the filemap. This is useful for identifying what parts of the target
repo belong to the source repo and what parts don't.""" repo belong to the source repo and what parts don't."""
if self.targetprefixes is None: if self.targetprefixes is None:
self.targetprefixes = set() self.targetprefixes = set()
for before, after in pycompat.iteritems(self.rename): for before, after in self.rename.items():
self.targetprefixes.add(after) self.targetprefixes.add(after)
# If "." is a target, then all target files are considered from the # If "." is a target, then all target files are considered from the
# source. # source.
if not self.targetprefixes or b'.' in self.targetprefixes: if not self.targetprefixes or b'.' in self.targetprefixes:
return True return True
filename = normalize(filename) filename = normalize(filename)

hgext/convert/hg.py

for b in pbranches: for b in pbranches:
try: try:
self.repo.lookup(b[0]) self.repo.lookup(b[0])
except Exception: except Exception:
missings.setdefault(b[1], []).append(b[0]) missings.setdefault(b[1], []).append(b[0])
if missings: if missings:
self.after() self.after()
for pbranch, heads in sorted(pycompat.iteritems(missings)): for pbranch, heads in sorted(missings.items()):
pbranchpath = os.path.join(self.path, pbranch) pbranchpath = os.path.join(self.path, pbranch)
prepo = hg.peer(self.ui, {}, pbranchpath) prepo = hg.peer(self.ui, {}, pbranchpath)
self.ui.note( self.ui.note(
_(b'pulling from %s into %s\n') % (pbranch, branch) _(b'pulling from %s into %s\n') % (pbranch, branch)
) )
exchange.pull( exchange.pull(
self.repo, prepo, heads=[prepo.lookup(h) for h in heads] self.repo, prepo, heads=[prepo.lookup(h) for h in heads]
) )
except error.LookupError: except error.LookupError:
return None, None return None, None
def _changedfiles(self, ctx1, ctx2): def _changedfiles(self, ctx1, ctx2):
ma, r = [], [] ma, r = [], []
maappend = ma.append maappend = ma.append
rappend = r.append rappend = r.append
d = ctx1.manifest().diff(ctx2.manifest()) d = ctx1.manifest().diff(ctx2.manifest())
for f, ((node1, flag1), (node2, flag2)) in pycompat.iteritems(d): for f, ((node1, flag1), (node2, flag2)) in d.items():
if node2 is None: if node2 is None:
rappend(f) rappend(f)
else: else:
maappend(f) maappend(f)
return ma, r return ma, r
def getchanges(self, rev, full): def getchanges(self, rev, full):
ctx = self._changectx(rev) ctx = self._changectx(rev)
files = ma + r files = ma + r
copyfiles = ma copyfiles = ma
# _getcopies() is also run for roots and before filtering so missing # _getcopies() is also run for roots and before filtering so missing
# revlogs are detected early # revlogs are detected early
copies = self._getcopies(ctx, parents, copyfiles) copies = self._getcopies(ctx, parents, copyfiles)
cleanp2 = set() cleanp2 = set()
if len(parents) == 2: if len(parents) == 2:
d = parents[1].manifest().diff(ctx.manifest(), clean=True) d = parents[1].manifest().diff(ctx.manifest(), clean=True)
for f, value in pycompat.iteritems(d): for f, value in d.items():
if value is None: if value is None:
cleanp2.add(f) cleanp2.add(f)
changes = [(f, rev) for f in files if f not in self.ignored] changes = [(f, rev) for f in files if f not in self.ignored]
changes.sort() changes.sort()
return changes, copies, cleanp2 return changes, copies, cleanp2
def _getcopies(self, ctx, parents, files): def _getcopies(self, ctx, parents, files):
copies = {} copies = {}

hgext/convert/monotone.py

def mtnrunsingle(self, *args, **kwargs): def mtnrunsingle(self, *args, **kwargs):
kwargs['d'] = self.path kwargs['d'] = self.path
return self.run0(b'automate', *args, **kwargs) return self.run0(b'automate', *args, **kwargs)
def mtnrunstdio(self, *args, **kwargs): def mtnrunstdio(self, *args, **kwargs):
# Prepare the command in automate stdio format # Prepare the command in automate stdio format
kwargs = pycompat.byteskwargs(kwargs) kwargs = pycompat.byteskwargs(kwargs)
command = [] command = []
for k, v in pycompat.iteritems(kwargs): for k, v in kwargs.items():
command.append(b"%d:%s" % (len(k), k)) command.append(b"%d:%s" % (len(k), k))
if v: if v:
command.append(b"%d:%s" % (len(v), v)) command.append(b"%d:%s" % (len(v), v))
if command: if command:
command.insert(0, b'o') command.insert(0, b'o')
command.append(b'e') command.append(b'e')
command.append(b'l') command.append(b'l')

hgext/convert/subversion.py

discover_changed_paths=True, discover_changed_paths=True,
strict_node_history=False, strict_node_history=False,
): ):
protocol = -1 protocol = -1
def receiver(orig_paths, revnum, author, date, message, pool): def receiver(orig_paths, revnum, author, date, message, pool):
paths = {} paths = {}
if orig_paths is not None: if orig_paths is not None:
for k, v in pycompat.iteritems(orig_paths): for k, v in orig_paths.items():
paths[k] = changedpath(v) paths[k] = changedpath(v)
pickle.dump((paths, revnum, author, date, message), fp, protocol) pickle.dump((paths, revnum, author, date, message), fp, protocol)
try: try:
# Use an ra of our own so that our parent can consume # Use an ra of our own so that our parent can consume
# our results without confusing the server. # our results without confusing the server.
t = transport.SvnRaTransport(url=url) t = transport.SvnRaTransport(url=url)
svn.ra.get_log( svn.ra.get_log(
end, end,
limit=0, limit=0,
discover_changed_paths=True, discover_changed_paths=True,
strict_node_history=False, strict_node_history=False,
): ):
def receiver(orig_paths, revnum, author, date, message, pool): def receiver(orig_paths, revnum, author, date, message, pool):
paths = {} paths = {}
if orig_paths is not None: if orig_paths is not None:
for k, v in pycompat.iteritems(orig_paths): for k, v in orig_paths.items():
paths[k] = changedpath(v) paths[k] = changedpath(v)
self.append((paths, revnum, author, date, message)) self.append((paths, revnum, author, date, message))
# Use an ra of our own so that our parent can consume # Use an ra of our own so that our parent can consume
# our results without confusing the server. # our results without confusing the server.
t = transport.SvnRaTransport(url=url) t = transport.SvnRaTransport(url=url)
svn.ra.get_log( svn.ra.get_log(
t.ra, t.ra,
if full or not parents: if full or not parents:
# Perform a full checkout on roots # Perform a full checkout on roots
uuid, module, revnum = revsplit(rev) uuid, module, revnum = revsplit(rev)
entries = svn.client.ls( entries = svn.client.ls(
self.baseurl + quote(module), optrev(revnum), True, self.ctx self.baseurl + quote(module), optrev(revnum), True, self.ctx
) )
files = [ files = [
n n
for n, e in pycompat.iteritems(entries) for n, e in entries.items()
if e.kind == svn.core.svn_node_file if e.kind == svn.core.svn_node_file
] ]
self.removed = set() self.removed = set()
files.sort() files.sort()
files = pycompat.ziplist(files, [rev] * len(files)) files = pycompat.ziplist(files, [rev] * len(files))
return (files, copies) return (files, copies)
stream = self._getlog([self.tags], start, self.startrev) stream = self._getlog([self.tags], start, self.startrev)
try: try:
for entry in stream: for entry in stream:
origpaths, revnum, author, date, message = entry origpaths, revnum, author, date, message = entry
if not origpaths: if not origpaths:
origpaths = [] origpaths = []
copies = [ copies = [
(e.copyfrom_path, e.copyfrom_rev, p) (e.copyfrom_path, e.copyfrom_rev, p)
for p, e in pycompat.iteritems(origpaths) for p, e in origpaths.items()
if e.copyfrom_path if e.copyfrom_path
] ]
# Apply moves/copies from more specific to general # Apply moves/copies from more specific to general
copies.sort(reverse=True) copies.sort(reverse=True)
srctagspath = tagspath srctagspath = tagspath
if copies and copies[-1][2] == tagspath: if copies and copies[-1][2] == tagspath:
# Track tags directory moves # Track tags directory moves
# parts of the repository like: # parts of the repository like:
# /tags/tag.1 (from /trunk:10) # /tags/tag.1 (from /trunk:10)
# /tags/tag.1/foo (from /branches/foo:12) # /tags/tag.1/foo (from /branches/foo:12)
# Here/tags/tag.1 discarded as well as its children. # Here/tags/tag.1 discarded as well as its children.
# It happens with tools like cvs2svn. Such tags cannot # It happens with tools like cvs2svn. Such tags cannot
# be represented in mercurial. # be represented in mercurial.
addeds = { addeds = {
p: e.copyfrom_path p: e.copyfrom_path
for p, e in pycompat.iteritems(origpaths) for p, e in origpaths.items()
if e.action == b'A' and e.copyfrom_path if e.action == b'A' and e.copyfrom_path
} }
badroots = set() badroots = set()
for destroot in addeds: for destroot in addeds:
for source, sourcerev, dest in pendings: for source, sourcerev, dest in pendings:
if not dest.startswith( if not dest.startswith(
destroot + b'/' destroot + b'/'
) or source.startswith(addeds[destroot] + b'/'): ) or source.startswith(addeds[destroot] + b'/'):
# branch log might return entries for a parent we already have # branch log might return entries for a parent we already have
if rev in self.commits or revnum < to_revnum: if rev in self.commits or revnum < to_revnum:
return None, branched return None, branched
parents = [] parents = []
# check whether this revision is the start of a branch or part # check whether this revision is the start of a branch or part
# of a branch renaming # of a branch renaming
orig_paths = sorted(pycompat.iteritems(orig_paths)) orig_paths = sorted(orig_paths.items())
root_paths = [ root_paths = [
(p, e) for p, e in orig_paths if self.module.startswith(p) (p, e) for p, e in orig_paths if self.module.startswith(p)
] ]
if root_paths: if root_paths:
path, ent = root_paths[-1] path, ent = root_paths[-1]
if ent.copyfrom_path: if ent.copyfrom_path:
branched = True branched = True
newpath = ent.copyfrom_path + self.module[len(path) :] newpath = ent.copyfrom_path + self.module[len(path) :]
path = path.strip(b'/') path = path.strip(b'/')
pool = svn.core.Pool() pool = svn.core.Pool()
rpath = b'/'.join([self.baseurl, quote(path)]).strip(b'/') rpath = b'/'.join([self.baseurl, quote(path)]).strip(b'/')
entries = svn.client.ls(rpath, optrev(revnum), True, self.ctx, pool) entries = svn.client.ls(rpath, optrev(revnum), True, self.ctx, pool)
if path: if path:
path += b'/' path += b'/'
return ( return (
(path + p) (path + p)
for p, e in pycompat.iteritems(entries) for p, e in entries.items()
if e.kind == svn.core.svn_node_file if e.kind == svn.core.svn_node_file
) )
def getrelpath(self, path, module=None): def getrelpath(self, path, module=None):
if module is None: if module is None:
module = self.module module = self.module
# Given the repository url of this wc, say # Given the repository url of this wc, say
# "http://server/plone/CMFPlone/branches/Plone-2_0-branch" # "http://server/plone/CMFPlone/branches/Plone-2_0-branch"

hgext/eol.py

pass pass
def reposetup(ui, repo): def reposetup(ui, repo):
uisetup(repo.ui) uisetup(repo.ui)
if not repo.local(): if not repo.local():
return return
for name, fn in pycompat.iteritems(filters): for name, fn in filters.items():
repo.adddatafilter(name, fn) repo.adddatafilter(name, fn)
ui.setconfig(b'patch', b'eol', b'auto', b'eol') ui.setconfig(b'patch', b'eol', b'auto', b'eol')
class eolrepo(repo.__class__): class eolrepo(repo.__class__):
def loadeol(self, nodes): def loadeol(self, nodes):
eol = parseeol(self.ui, self, nodes) eol = parseeol(self.ui, self, nodes)
if eol is None: if eol is None:

hgext/fastannotate/context.py

defaults = { defaults = {
b'diffopts': None, b'diffopts': None,
b'followrename': True, b'followrename': True,
b'followmerge': True, b'followmerge': True,
} }
def __init__(self, **opts): def __init__(self, **opts):
opts = pycompat.byteskwargs(opts) opts = pycompat.byteskwargs(opts)
for k, v in pycompat.iteritems(self.defaults): for k, v in self.defaults.items():
setattr(self, k, opts.get(k, v)) setattr(self, k, opts.get(k, v))
@util.propertycache @util.propertycache
def shortstr(self): def shortstr(self):
"""represent opts in a short string, suitable for a directory name""" """represent opts in a short string, suitable for a directory name"""
result = b'' result = b''
if not self.followrename: if not self.followrename:
result += b'r0' result += b'r0'
# {(rev, linenum): [lineindex]} # {(rev, linenum): [lineindex]}
key2idxs = collections.defaultdict(list) key2idxs = collections.defaultdict(list)
for i in pycompat.xrange(len(result)): for i in pycompat.xrange(len(result)):
key2idxs[(revs[i], annotateresult[i][1])].append(i) key2idxs[(revs[i], annotateresult[i][1])].append(i)
while key2idxs: while key2idxs:
# find an unresolved line and its linelog rev to annotate # find an unresolved line and its linelog rev to annotate
hsh = None hsh = None
try: try:
for (rev, _linenum), idxs in pycompat.iteritems(key2idxs): for (rev, _linenum), idxs in key2idxs.items():
if revmap.rev2flag(rev) & revmapmod.sidebranchflag: if revmap.rev2flag(rev) & revmapmod.sidebranchflag:
continue continue
hsh = annotateresult[idxs[0]][0] hsh = annotateresult[idxs[0]][0]
break break
except StopIteration: # no more unresolved lines except StopIteration: # no more unresolved lines
return result return result
if hsh is None: if hsh is None:
# the remaining key2idxs are not in main branch, resolving them # the remaining key2idxs are not in main branch, resolving them
# using the hard way... # using the hard way...
revlines = {} revlines = {}
for (rev, linenum), idxs in pycompat.iteritems(key2idxs): for (rev, linenum), idxs in key2idxs.items():
if rev not in revlines: if rev not in revlines:
hsh = annotateresult[idxs[0]][0] hsh = annotateresult[idxs[0]][0]
if self.ui.debugflag: if self.ui.debugflag:
self.ui.debug( self.ui.debug(
b'fastannotate: reading %s line #%d ' b'fastannotate: reading %s line #%d '
b'to resolve lines %r\n' b'to resolve lines %r\n'
% (short(hsh), linenum, idxs) % (short(hsh), linenum, idxs)
) )

hgext/fastannotate/protocol.py

# Copyright 2016-present Facebook. All Rights Reserved. # Copyright 2016-present Facebook. All Rights Reserved.
# #
# protocol: logic for a server providing fastannotate support # protocol: logic for a server providing fastannotate support
# #
# 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.
import contextlib import contextlib
import os import os
from mercurial.i18n import _ from mercurial.i18n import _
from mercurial.pycompat import open from mercurial.pycompat import open
from mercurial import ( from mercurial import (
error, error,
extensions, extensions,
hg, hg,
pycompat,
util, util,
wireprotov1peer, wireprotov1peer,
wireprotov1server, wireprotov1server,
) )
from mercurial.utils import ( from mercurial.utils import (
urlutil, urlutil,
) )
from . import context from . import context
b'getannotate', b'getannotate',
{b'path': p, b'lastnode': lastnodemap.get(p)}, {b'path': p, b'lastnode': lastnodemap.get(p)},
) )
) )
for result in results: for result in results:
r = result.result() r = result.result()
# TODO: pconvert these paths on the server? # TODO: pconvert these paths on the server?
r = {util.pconvert(p): v for p, v in pycompat.iteritems(r)} r = {util.pconvert(p): v for p, v in r.items()}
for path in sorted(r): for path in sorted(r):
# ignore malicious paths # ignore malicious paths
if not path.startswith(b'fastannotate/') or b'/../' in ( if not path.startswith(b'fastannotate/') or b'/../' in (
path + b'/' path + b'/'
): ):
ui.debug( ui.debug(
b'fastannotate: ignored malicious path %s\n' % path b'fastannotate: ignored malicious path %s\n' % path
) )

hgext/fix.py

from cleanupnodes(). from cleanupnodes().
"wdirwritten" is a bool which tells whether the working copy was affected by "wdirwritten" is a bool which tells whether the working copy was affected by
fixing, since it has no entry in "replacements". fixing, since it has no entry in "replacements".
Useful as a hook point for extending "hg fix" with output summarizing the Useful as a hook point for extending "hg fix" with output summarizing the
effects of the command, though we choose not to output anything here. effects of the command, though we choose not to output anything here.
""" """
replacements = { replacements = {prec: [succ] for prec, succ in replacements.items()}
prec: [succ] for prec, succ in pycompat.iteritems(replacements)
}
scmutil.cleanupnodes(repo, replacements, b'fix', fixphase=True) scmutil.cleanupnodes(repo, replacements, b'fix', fixphase=True)
def getworkqueue(ui, repo, pats, opts, revstofix, basectxs): def getworkqueue(ui, repo, pats, opts, revstofix, basectxs):
"""Constructs a list of files to fix and which revisions each fix applies to """Constructs a list of files to fix and which revisions each fix applies to
To avoid duplicating work, there is usually only one work item for each file To avoid duplicating work, there is usually only one work item for each file
revision that might need to be fixed. There can be multiple work items per revision that might need to be fixed. There can be multiple work items per
(i.e. they will only avoid lines that are common to all basectxs). (i.e. they will only avoid lines that are common to all basectxs).
A fixer tool's stdout will become the file's new content if and only if it A fixer tool's stdout will become the file's new content if and only if it
exits with code zero. The fixer tool's working directory is the repository's exits with code zero. The fixer tool's working directory is the repository's
root. root.
""" """
metadata = {} metadata = {}
newdata = fixctx[path].data() newdata = fixctx[path].data()
for fixername, fixer in pycompat.iteritems(fixers): for fixername, fixer in fixers.items():
if fixer.affects(opts, fixctx, path): if fixer.affects(opts, fixctx, path):
ranges = lineranges( ranges = lineranges(
opts, path, basepaths, basectxs, fixctx, newdata opts, path, basepaths, basectxs, fixctx, newdata
) )
command = fixer.command(ui, path, ranges) command = fixer.command(ui, path, ranges)
if command is None: if command is None:
continue continue
ui.debug(b'subprocess: %s\n' % (command,)) ui.debug(b'subprocess: %s\n' % (command,))
We check out a new revision if and only if we fixed something in both the We check out a new revision if and only if we fixed something in both the
working directory and its parent revision. This avoids the need for a full working directory and its parent revision. This avoids the need for a full
update/merge, and means that the working directory simply isn't affected update/merge, and means that the working directory simply isn't affected
unless the --working-dir flag is given. unless the --working-dir flag is given.
Directly updates the dirstate for the affected files. Directly updates the dirstate for the affected files.
""" """
for path, data in pycompat.iteritems(filedata): for path, data in filedata.items():
fctx = ctx[path] fctx = ctx[path]
fctx.write(data, fctx.flags()) fctx.write(data, fctx.flags())
oldp1 = repo.dirstate.p1() oldp1 = repo.dirstate.p1()
newp1 = replacements.get(oldp1, oldp1) newp1 = replacements.get(oldp1, oldp1)
if newp1 != oldp1: if newp1 != oldp1:
assert repo.dirstate.p2() == nullid assert repo.dirstate.p2() == nullid
with repo.dirstate.parentchange(): with repo.dirstate.parentchange():

hgext/fsmonitor/__init__.py

visit.update(f for f in copymap if f not in results) visit.update(f for f in copymap if f not in results)
else: else:
visit.update( visit.update(
f for f in nonnormalset if f not in results and matchfn(f) f for f in nonnormalset if f not in results and matchfn(f)
) )
visit.update(f for f in copymap if f not in results and matchfn(f)) visit.update(f for f in copymap if f not in results and matchfn(f))
else: else:
if matchalways: if matchalways:
visit.update( visit.update(f for f, st in dmap.items() if f not in results)
f for f, st in pycompat.iteritems(dmap) if f not in results
)
visit.update(f for f in copymap if f not in results) visit.update(f for f in copymap if f not in results)
else: else:
visit.update( visit.update(
f f for f, st in dmap.items() if f not in results and matchfn(f)
for f, st in pycompat.iteritems(dmap)
if f not in results and matchfn(f)
) )
visit.update(f for f in copymap if f not in results and matchfn(f)) visit.update(f for f in copymap if f not in results and matchfn(f))
audit = pathutil.pathauditor(self._root, cached=True).check audit = pathutil.pathauditor(self._root, cached=True).check
auditpass = [f for f in visit if audit(f)] auditpass = [f for f in visit if audit(f)]
auditpass.sort() auditpass.sort()
auditfail = visit.difference(auditpass) auditfail = visit.difference(auditpass)
for f in auditfail: for f in auditfail:

hgext/githelp.py

) )
ui.warn(_(b"ignoring unknown option %s\n") % flag) ui.warn(_(b"ignoring unknown option %s\n") % flag)
args = list([convert(x) for x in args]) args = list([convert(x) for x in args])
opts = dict( opts = dict(
[ [
(k, convert(v)) if isinstance(v, bytes) else (k, v) (k, convert(v)) if isinstance(v, bytes) else (k, v)
for k, v in pycompat.iteritems(opts) for k, v in opts.items()
] ]
) )
return args, opts return args, opts
class Command(object): class Command(object):
def __init__(self, name): def __init__(self, name):
self.name = name self.name = name
self.args = [] self.args = []
self.opts = {} self.opts = {}
def __bytes__(self): def __bytes__(self):
cmd = b"hg " + self.name cmd = b"hg " + self.name
if self.opts: if self.opts:
for k, values in sorted(pycompat.iteritems(self.opts)): for k, values in sorted(self.opts.items()):
for v in values: for v in values:
if v: if v:
if isinstance(v, int): if isinstance(v, int):
fmt = b' %s %d' fmt = b' %s %d'
else: else:
fmt = b' %s %s' fmt = b' %s %s'
cmd += fmt % (k, v) cmd += fmt % (k, v)

hgext/hgk.py

[(b'l', b'limit', b'', _(b'limit number of changes displayed'), _(b'NUM'))], [(b'l', b'limit', b'', _(b'limit number of changes displayed'), _(b'NUM'))],
_(b'[-l LIMIT] [REVRANGE]'), _(b'[-l LIMIT] [REVRANGE]'),
helpcategory=command.CATEGORY_CHANGE_NAVIGATION, helpcategory=command.CATEGORY_CHANGE_NAVIGATION,
) )
def view(ui, repo, *etc, **opts): def view(ui, repo, *etc, **opts):
"""start interactive history viewer""" """start interactive history viewer"""
opts = pycompat.byteskwargs(opts) opts = pycompat.byteskwargs(opts)
os.chdir(repo.root) os.chdir(repo.root)
optstr = b' '.join( optstr = b' '.join([b'--%s %s' % (k, v) for k, v in opts.items() if v])
[b'--%s %s' % (k, v) for k, v in pycompat.iteritems(opts) if v]
)
if repo.filtername is None: if repo.filtername is None:
optstr += b'--hidden' optstr += b'--hidden'
cmd = ui.config(b"hgk", b"path") + b" %s %s" % (optstr, b" ".join(etc)) cmd = ui.config(b"hgk", b"path") + b" %s %s" % (optstr, b" ".join(etc))
ui.debug(b"running %s\n" % cmd) ui.debug(b"running %s\n" % cmd)
ui.system(cmd, blockedtag=b'hgk_view') ui.system(cmd, blockedtag=b'hgk_view')

hgext/histedit.py

def _finishhistedit(ui, repo, state, fm): def _finishhistedit(ui, repo, state, fm):
"""This action runs when histedit is finishing its session""" """This action runs when histedit is finishing its session"""
mergemod.update(repo[state.parentctxnode]) mergemod.update(repo[state.parentctxnode])
mapping, tmpnodes, created, ntm = processreplacement(state) mapping, tmpnodes, created, ntm = processreplacement(state)
if mapping: if mapping:
for prec, succs in pycompat.iteritems(mapping): for prec, succs in mapping.items():
if not succs: if not succs:
ui.debug(b'histedit: %s is dropped\n' % short(prec)) ui.debug(b'histedit: %s is dropped\n' % short(prec))
else: else:
ui.debug( ui.debug(
b'histedit: %s is replaced by %s\n' b'histedit: %s is replaced by %s\n'
% (short(prec), short(succs[0])) % (short(prec), short(succs[0]))
) )
if len(succs) > 1: if len(succs) > 1:
} }
scmutil.cleanupnodes(repo, mapping, b'histedit') scmutil.cleanupnodes(repo, mapping, b'histedit')
hf = fm.hexfunc hf = fm.hexfunc
fl = fm.formatlist fl = fm.formatlist
fd = fm.formatdict fd = fm.formatdict
nodechanges = fd( nodechanges = fd(
{ {
hf(oldn): fl([hf(n) for n in newn], name=b'node') hf(oldn): fl([hf(n) for n in newn], name=b'node')
for oldn, newn in pycompat.iteritems(mapping) for oldn, newn in mapping.items()
}, },
key=b"oldnode", key=b"oldnode",
value=b"newnodes", value=b"newnodes",
) )
fm.data(nodechanges=nodechanges) fm.data(nodechanges=nodechanges)
state.clear() state.clear()
if os.path.exists(repo.sjoin(b'undo')): if os.path.exists(repo.sjoin(b'undo')):
if fword.endswith(b'!'): if fword.endswith(b'!'):
fword = fword[:-1] fword = fword[:-1]
if fword in primaryactions | secondaryactions | tertiaryactions: if fword in primaryactions | secondaryactions | tertiaryactions:
act.verb = fword act.verb = fword
# get the target summary # get the target summary
tsum = summary[len(fword) + 1 :].lstrip() tsum = summary[len(fword) + 1 :].lstrip()
# safe but slow: reverse iterate over the actions so we # safe but slow: reverse iterate over the actions so we
# don't clash on two commits having the same summary # don't clash on two commits having the same summary
for na, l in reversed(list(pycompat.iteritems(newact))): for na, l in reversed(list(newact.items())):
actx = repo[na.node] actx = repo[na.node]
asum = _getsummary(actx) asum = _getsummary(actx)
if asum == tsum: if asum == tsum:
added = True added = True
l.append(act) l.append(act)
break break
if not added: if not added:
newact[act] = [] newact[act] = []
# copy over and flatten the new list # copy over and flatten the new list
actions = [] actions = []
for na, l in pycompat.iteritems(newact): for na, l in newact.items():
actions.append(na) actions.append(na)
actions += l actions += l
rules = b'\n'.join([act.torule() for act in actions]) rules = b'\n'.join([act.torule() for act in actions])
rules += b'\n\n' rules += b'\n\n'
rules += editcomment rules += editcomment
rules = ui.edit( rules = ui.edit(
rules, rules,

hgext/infinitepush/__init__.py

index = self.bundlestore.index index = self.bundlestore.index
results = {} results = {}
bookmarks = orig(self, namespace) bookmarks = orig(self, namespace)
for pattern in patterns: for pattern in patterns:
results.update(index.getbookmarks(pattern)) results.update(index.getbookmarks(pattern))
if pattern.endswith(b'*'): if pattern.endswith(b'*'):
pattern = b're:^' + pattern[:-1] + b'.*' pattern = b're:^' + pattern[:-1] + b'.*'
kind, pat, matcher = stringutil.stringmatcher(pattern) kind, pat, matcher = stringutil.stringmatcher(pattern)
for bookmark, node in pycompat.iteritems(bookmarks): for bookmark, node in bookmarks.items():
if matcher(bookmark): if matcher(bookmark):
results[bookmark] = node results[bookmark] = node
return results return results
else: else:
return orig(self, namespace) return orig(self, namespace)
@wireprotov1peer.batchable @wireprotov1peer.batchable
part.addparam(b'version', b'01') part.addparam(b'version', b'01')
parts.append(part) parts.append(part)
elif isinstance(unbundler, bundle2.unbundle20): elif isinstance(unbundler, bundle2.unbundle20):
haschangegroup = False haschangegroup = False
for part in unbundler.iterparts(): for part in unbundler.iterparts():
if part.type == b'changegroup': if part.type == b'changegroup':
haschangegroup = True haschangegroup = True
newpart = bundle2.bundlepart(part.type, data=part.read()) newpart = bundle2.bundlepart(part.type, data=part.read())
for key, value in pycompat.iteritems(part.params): for key, value in part.params.items():
newpart.addparam(key, value) newpart.addparam(key, value)
parts.append(newpart) parts.append(newpart)
if not haschangegroup: if not haschangegroup:
raise error.Abort( raise error.Abort(
b'unexpected bundle without changegroup part, ' b'unexpected bundle without changegroup part, '
+ b'head: %s' % hex(head), + b'head: %s' % hex(head),
hint=b'report to administrator', hint=b'report to administrator',
# scratch branch pattern. In this case just use the current # scratch branch pattern. In this case just use the current
# bookmark node # bookmark node
del newbookmarks[rname] del newbookmarks[rname]
bookmarks[rname] = hexnode bookmarks[rname] = hexnode
elif nametype == b'branches': elif nametype == b'branches':
# saveremotenames expects 20 byte binary nodes for branches # saveremotenames expects 20 byte binary nodes for branches
branches[rname].append(bin(hexnode)) branches[rname].append(bin(hexnode))
for bookmark, hexnode in pycompat.iteritems(newbookmarks): for bookmark, hexnode in newbookmarks.items():
bookmarks[bookmark] = hexnode bookmarks[bookmark] = hexnode
remotenamesext.saveremotenames(repo, remotepath, branches, bookmarks) remotenamesext.saveremotenames(repo, remotepath, branches, bookmarks)
def _savelocalbookmarks(repo, bookmarks): def _savelocalbookmarks(repo, bookmarks):
if not bookmarks: if not bookmarks:
return return
with repo.wlock(), repo.lock(), repo.transaction(b'bookmark') as tr: with repo.wlock(), repo.lock(), repo.transaction(b'bookmark') as tr:
changes = [] changes = []
for scratchbook, node in pycompat.iteritems(bookmarks): for scratchbook, node in bookmarks.items():
changectx = repo[node] changectx = repo[node]
changes.append((scratchbook, changectx.node())) changes.append((scratchbook, changectx.node()))
repo._bookmarks.applychanges(repo, tr, changes) repo._bookmarks.applychanges(repo, tr, changes)
def _findcommonincoming(orig, *args, **kwargs): def _findcommonincoming(orig, *args, **kwargs):
common, inc, remoteheads = orig(*args, **kwargs) common, inc, remoteheads = orig(*args, **kwargs)
return common, True, remoteheads return common, True, remoteheads
with bundle2.partiterator(repo, op, unbundler) as parts: with bundle2.partiterator(repo, op, unbundler) as parts:
for part in parts: for part in parts:
bundlepart = None bundlepart = None
if part.type == b'replycaps': if part.type == b'replycaps':
# This configures the current operation to allow reply parts. # This configures the current operation to allow reply parts.
bundle2._processpart(op, part) bundle2._processpart(op, part)
else: else:
bundlepart = bundle2.bundlepart(part.type, data=part.read()) bundlepart = bundle2.bundlepart(part.type, data=part.read())
for key, value in pycompat.iteritems(part.params): for key, value in part.params.items():
bundlepart.addparam(key, value) bundlepart.addparam(key, value)
# Certain parts require a response # Certain parts require a response
if part.type in (b'pushkey', b'changegroup'): if part.type in (b'pushkey', b'changegroup'):
if op.reply is not None: if op.reply is not None:
rpart = op.reply.newpart(b'reply:%s' % part.type) rpart = op.reply.newpart(b'reply:%s' % part.type)
rpart.addparam( rpart.addparam(
b'in-reply-to', b'%d' % part.id, mandatory=False b'in-reply-to', b'%d' % part.id, mandatory=False
) )
else: else:
if handleallparts: if handleallparts:
# Ideally we would not process any parts, and instead just # Ideally we would not process any parts, and instead just
# forward them to the bundle for storage, but since this # forward them to the bundle for storage, but since this
# differs from previous behavior, we need to put it behind a # differs from previous behavior, we need to put it behind a
# config flag for incremental rollout. # config flag for incremental rollout.
bundlepart = bundle2.bundlepart(part.type, data=part.read()) bundlepart = bundle2.bundlepart(part.type, data=part.read())
for key, value in pycompat.iteritems(part.params): for key, value in part.params.items():
bundlepart.addparam(key, value) bundlepart.addparam(key, value)
# Certain parts require a response # Certain parts require a response
if part.type == b'pushkey': if part.type == b'pushkey':
if op.reply is not None: if op.reply is not None:
rpart = op.reply.newpart(b'reply:pushkey') rpart = op.reply.newpart(b'reply:pushkey')
rpart.addparam( rpart.addparam(
b'in-reply-to', str(part.id), mandatory=False b'in-reply-to', str(part.id), mandatory=False
if params.get(b'pushbackbookmarks'): if params.get(b'pushbackbookmarks'):
if op.reply and b'pushback' in op.reply.capabilities: if op.reply and b'pushback' in op.reply.capabilities:
params = { params = {
b'namespace': b'bookmarks', b'namespace': b'bookmarks',
b'key': bookmark, b'key': bookmark,
b'new': newnode, b'new': newnode,
b'old': oldnode, b'old': oldnode,
} }
op.reply.newpart( op.reply.newpart(b'pushkey', mandatoryparams=params.items())
b'pushkey', mandatoryparams=pycompat.iteritems(params)
)
def bundle2pushkey(orig, op, part): def bundle2pushkey(orig, op, part):
"""Wrapper of bundle2.handlepushkey() """Wrapper of bundle2.handlepushkey()
The only goal is to skip calling the original function if flag is set. The only goal is to skip calling the original function if flag is set.
It's set if infinitepush push is happening. It's set if infinitepush push is happening.
""" """

hgext/infinitepush/bundleparts.py

# Copyright 2017 Facebook, Inc. # Copyright 2017 Facebook, Inc.
# #
# 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 mercurial.i18n import _ from mercurial.i18n import _
from mercurial.node import hex from mercurial.node import hex
from mercurial import ( from mercurial import (
bundle2, bundle2,
changegroup, changegroup,
error, error,
extensions, extensions,
pycompat,
revsetlang, revsetlang,
util, util,
) )
from . import common from . import common
isremotebooksenabled = common.isremotebooksenabled isremotebooksenabled = common.isremotebooksenabled
parts = [] parts = []
# .upper() marks this as a mandatory part: server will abort if there's no # .upper() marks this as a mandatory part: server will abort if there's no
# handler # handler
parts.append( parts.append(
bundle2.bundlepart( bundle2.bundlepart(
scratchbranchparttype.upper(), scratchbranchparttype.upper(),
advisoryparams=pycompat.iteritems(params), advisoryparams=params.items(),
data=cg, data=cg,
) )
) )
return parts return parts
def _validaterevset(repo, revset, bookmark): def _validaterevset(repo, revset, bookmark):

hgext/infinitepush/sqlindexapi.py

# Infinite push # Infinite push
# #
# Copyright 2016 Facebook, Inc. # Copyright 2016 Facebook, Inc.
# #
# 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.
import logging import logging
import os import os
import time import time
import warnings import warnings
import mysql.connector import mysql.connector
from mercurial import pycompat
from . import indexapi from . import indexapi
def _convertbookmarkpattern(pattern): def _convertbookmarkpattern(pattern):
pattern = pattern.replace(b'_', b'\\_') pattern = pattern.replace(b'_', b'\\_')
pattern = pattern.replace(b'%', b'\\%') pattern = pattern.replace(b'%', b'\\%')
if pattern.endswith(b'*'): if pattern.endswith(b'*'):
pattern = pattern[:-1] + b'%' pattern = pattern[:-1] + b'%'
params=(bookmark, node, self.reponame), params=(bookmark, node, self.reponame),
) )
def addmanybookmarks(self, bookmarks): def addmanybookmarks(self, bookmarks):
if not self._connected: if not self._connected:
self.sqlconnect() self.sqlconnect()
args = [] args = []
values = [] values = []
for bookmark, node in pycompat.iteritems(bookmarks): for bookmark, node in bookmarks.items():
args.append(b'(%s, %s, %s)') args.append(b'(%s, %s, %s)')
values.extend((bookmark, node, self.reponame)) values.extend((bookmark, node, self.reponame))
args = b','.join(args) args = b','.join(args)
self.sqlcursor.execute( self.sqlcursor.execute(
b"INSERT INTO bookmarkstonode(bookmark, node, reponame) " b"INSERT INTO bookmarkstonode(bookmark, node, reponame) "
b"VALUES %s ON DUPLICATE KEY UPDATE node=VALUES(node)" % args, b"VALUES %s ON DUPLICATE KEY UPDATE node=VALUES(node)" % args,
params=values, params=values,

hgext/journal.py

# hooks to record bookmark changes (both local and remote) # hooks to record bookmark changes (both local and remote)
def recordbookmarks(orig, store, fp): def recordbookmarks(orig, store, fp):
"""Records all bookmark changes in the journal.""" """Records all bookmark changes in the journal."""
repo = store._repo repo = store._repo
if util.safehasattr(repo, 'journal'): if util.safehasattr(repo, 'journal'):
oldmarks = bookmarks.bmstore(repo) oldmarks = bookmarks.bmstore(repo)
for mark, value in pycompat.iteritems(store): for mark, value in store.items():
oldvalue = oldmarks.get(mark, repo.nullid) oldvalue = oldmarks.get(mark, repo.nullid)
if value != oldvalue: if value != oldvalue:
repo.journal.record(bookmarktype, mark, oldvalue, value) repo.journal.record(bookmarktype, mark, oldvalue, value)
return orig(store, fp) return orig(store, fp)
# shared repository support # shared repository support
def _readsharedfeatures(repo): def _readsharedfeatures(repo):

hgext/keyword.py

elif opts.get('default'): elif opts.get('default'):
if svn: if svn:
ui.status(_(b'\n\tconfiguration using default svn keywordset\n')) ui.status(_(b'\n\tconfiguration using default svn keywordset\n'))
else: else:
ui.status(_(b'\n\tconfiguration using default cvs keywordset\n')) ui.status(_(b'\n\tconfiguration using default cvs keywordset\n'))
kwmaps = _defaultkwmaps(ui) kwmaps = _defaultkwmaps(ui)
if uikwmaps: if uikwmaps:
ui.status(_(b'\tdisabling current template maps\n')) ui.status(_(b'\tdisabling current template maps\n'))
for k, v in pycompat.iteritems(kwmaps): for k, v in kwmaps.items():
ui.setconfig(b'keywordmaps', k, v, b'keyword') ui.setconfig(b'keywordmaps', k, v, b'keyword')
else: else:
ui.status(_(b'\n\tconfiguration using current keyword template maps\n')) ui.status(_(b'\n\tconfiguration using current keyword template maps\n'))
if uikwmaps: if uikwmaps:
kwmaps = dict(uikwmaps) kwmaps = dict(uikwmaps)
else: else:
kwmaps = _defaultkwmaps(ui) kwmaps = _defaultkwmaps(ui)
uisetup(ui) uisetup(ui)
reposetup(ui, repo) reposetup(ui, repo)
ui.writenoi18n(b'[extensions]\nkeyword =\n') ui.writenoi18n(b'[extensions]\nkeyword =\n')
demoitems(b'keyword', ui.configitems(b'keyword')) demoitems(b'keyword', ui.configitems(b'keyword'))
demoitems(b'keywordset', ui.configitems(b'keywordset')) demoitems(b'keywordset', ui.configitems(b'keywordset'))
demoitems(b'keywordmaps', pycompat.iteritems(kwmaps)) demoitems(b'keywordmaps', kwmaps.items())
keywords = b'$' + b'$\n$'.join(sorted(kwmaps.keys())) + b'$\n' keywords = b'$' + b'$\n$'.join(sorted(kwmaps.keys())) + b'$\n'
repo.wvfs.write(fn, keywords) repo.wvfs.write(fn, keywords)
repo[None].add([fn]) repo[None].add([fn])
ui.note(_(b'\nkeywords written to %s:\n') % fn) ui.note(_(b'\nkeywords written to %s:\n') % fn)
ui.note(keywords) ui.note(keywords)
with repo.wlock(): with repo.wlock():
repo.dirstate.setbranch(b'demobranch') repo.dirstate.setbranch(b'demobranch')
for name, cmd in ui.configitems(b'hooks'): for name, cmd in ui.configitems(b'hooks'):

hgext/largefiles/overrides.py

return 0, False return 0, False
@eh.wrapfunction(copiesmod, b'pathcopies') @eh.wrapfunction(copiesmod, b'pathcopies')
def copiespathcopies(orig, ctx1, ctx2, match=None): def copiespathcopies(orig, ctx1, ctx2, match=None):
copies = orig(ctx1, ctx2, match=match) copies = orig(ctx1, ctx2, match=match)
updated = {} updated = {}
for k, v in pycompat.iteritems(copies): for k, v in copies.items():
updated[lfutil.splitstandin(k) or k] = lfutil.splitstandin(v) or v updated[lfutil.splitstandin(k) or k] = lfutil.splitstandin(v) or v
return updated return updated
# Copy first changes the matchers to match standins instead of # Copy first changes the matchers to match standins instead of
# largefiles. Then it overrides util.copyfile in that function it # largefiles. Then it overrides util.copyfile in that function it
# checks if the destination largefile already exists. It also keeps a # checks if the destination largefile already exists. It also keeps a

hgext/lfs/pointer.py

b'size': re.compile(br'\A[0-9]+\Z'), b'size': re.compile(br'\A[0-9]+\Z'),
b'oid': re.compile(br'\Asha256:[0-9a-f]{64}\Z'), b'oid': re.compile(br'\Asha256:[0-9a-f]{64}\Z'),
b'version': re.compile(br'\A%s\Z' % stringutil.reescape(VERSION)), b'version': re.compile(br'\A%s\Z' % stringutil.reescape(VERSION)),
} }
def validate(self): def validate(self):
"""raise InvalidPointer on error. return self if there is no error""" """raise InvalidPointer on error. return self if there is no error"""
requiredcount = 0 requiredcount = 0
for k, v in pycompat.iteritems(self): for k, v in self.items():
if k in self._requiredre: if k in self._requiredre:
if not self._requiredre[k].match(v): if not self._requiredre[k].match(v):
raise InvalidPointer( raise InvalidPointer(
_(b'unexpected lfs pointer value: %s=%s') _(b'unexpected lfs pointer value: %s=%s')
% (k, stringutil.pprint(v)) % (k, stringutil.pprint(v))
) )
requiredcount += 1 requiredcount += 1
elif not self._keyre.match(k): elif not self._keyre.match(k):

hgext/lfs/wrapper.py

bundle2, bundle2,
changegroup, changegroup,
cmdutil, cmdutil,
context, context,
error, error,
exchange, exchange,
exthelper, exthelper,
localrepo, localrepo,
pycompat,
revlog, revlog,
scmutil, scmutil,
util, util,
vfs as vfsmod, vfs as vfsmod,
wireprotov1server, wireprotov1server,
) )
from mercurial.upgrade_utils import ( from mercurial.upgrade_utils import (
# be used for non-binary content. add a special entry for non-binary data. # be used for non-binary content. add a special entry for non-binary data.
# this will be used by filectx.isbinary(). # this will be used by filectx.isbinary().
if not stringutil.binary(text): if not stringutil.binary(text):
# not hg filelog metadata (affecting commit hash), no "x-hg-" prefix # not hg filelog metadata (affecting commit hash), no "x-hg-" prefix
metadata[b'x-is-binary'] = b'0' metadata[b'x-is-binary'] = b'0'
# translate hg filelog metadata to lfs metadata with "x-hg-" prefix # translate hg filelog metadata to lfs metadata with "x-hg-" prefix
if hgmeta is not None: if hgmeta is not None:
for k, v in pycompat.iteritems(hgmeta): for k, v in hgmeta.items():
metadata[b'x-hg-%s' % k] = v metadata[b'x-hg-%s' % k] = v
rawtext = metadata.serialize() rawtext = metadata.serialize()
return (rawtext, False) return (rawtext, False)
def _islfs(rlog, node=None, rev=None): def _islfs(rlog, node=None, rev=None):
if rev is None: if rev is None:

hgext/mq.py

copies.setdefault(src, []).extend( copies.setdefault(src, []).extend(
copies.get(dst, []) copies.get(dst, [])
) )
if dst in a: if dst in a:
copies[src].append(dst) copies[src].append(dst)
# we can't copy a file created by the patch itself # we can't copy a file created by the patch itself
if dst in copies: if dst in copies:
del copies[dst] del copies[dst]
for src, dsts in pycompat.iteritems(copies): for src, dsts in copies.items():
for dst in dsts: for dst in dsts:
repo.dirstate.copy(src, dst) repo.dirstate.copy(src, dst)
else: else:
for dst in a: for dst in a:
repo.dirstate.update_file( repo.dirstate.update_file(
dst, p1_tracked=False, wc_tracked=True dst, p1_tracked=False, wc_tracked=True
) )
# Drop useless copy information # Drop useless copy information
extensions.wrapcommand(commands.table, b'import', mqimport) extensions.wrapcommand(commands.table, b'import', mqimport)
cmdutil.summaryhooks.add(b'mq', summaryhook) cmdutil.summaryhooks.add(b'mq', summaryhook)
entry = extensions.wrapcommand(commands.table, b'init', mqinit) entry = extensions.wrapcommand(commands.table, b'init', mqinit)
entry[1].extend(mqopt) entry[1].extend(mqopt)
def dotable(cmdtable): def dotable(cmdtable):
for cmd, entry in pycompat.iteritems(cmdtable): for cmd, entry in cmdtable.items():
cmd = cmdutil.parsealiases(cmd)[0] cmd = cmdutil.parsealiases(cmd)[0]
func = entry[0] func = entry[0]
if func.norepo: if func.norepo:
continue continue
entry = extensions.wrapcommand(cmdtable, cmd, mqcommand) entry = extensions.wrapcommand(cmdtable, cmd, mqcommand)
entry[1].extend(mqopt) entry[1].extend(mqopt)
dotable(commands.table) dotable(commands.table)

hgext/phabricator.py

raise error.InputError(_(b'--rev requires a repository')) raise error.InputError(_(b'--rev requires a repository'))
if specs: if specs:
raise error.InputError(_(b'cannot specify both DREVSPEC and --rev')) raise error.InputError(_(b'cannot specify both DREVSPEC and --rev'))
drevmap = getdrevmap(repo, logcmdutil.revrange(repo, [revs])) drevmap = getdrevmap(repo, logcmdutil.revrange(repo, [revs]))
specs = [] specs = []
unknown = [] unknown = []
for r, d in pycompat.iteritems(drevmap): for r, d in drevmap.items():
if d is None: if d is None:
unknown.append(repo[r]) unknown.append(repo[r])
else: else:
specs.append(b'D%d' % d) specs.append(b'D%d' % d)
if unknown: if unknown:
raise error.InputError( raise error.InputError(
_(b'selected revisions without a Differential: %s') _(b'selected revisions without a Differential: %s')
% scmutil.nodesummaries(repo, unknown) % scmutil.nodesummaries(repo, unknown)
@show.showview(b'phabstatus', csettopic=b'work') @show.showview(b'phabstatus', csettopic=b'work')
def phabstatusshowview(ui, repo, displayer): def phabstatusshowview(ui, repo, displayer):
"""Phabricator differiential status""" """Phabricator differiential status"""
revs = repo.revs('sort(_underway(), topo)') revs = repo.revs('sort(_underway(), topo)')
drevmap = getdrevmap(repo, revs) drevmap = getdrevmap(repo, revs)
unknownrevs, drevids, revsbydrevid = [], set(), {} unknownrevs, drevids, revsbydrevid = [], set(), {}
for rev, drevid in pycompat.iteritems(drevmap): for rev, drevid in drevmap.items():
if drevid is not None: if drevid is not None:
drevids.add(drevid) drevids.add(drevid)
revsbydrevid.setdefault(drevid, set()).add(rev) revsbydrevid.setdefault(drevid, set()).add(rev)
else: else:
unknownrevs.append(rev) unknownrevs.append(rev)
drevs = callconduit(ui, b'differential.query', {b'ids': list(drevids)}) drevs = callconduit(ui, b'differential.query', {b'ids': list(drevids)})
drevsbyrev = {} drevsbyrev = {}

hgext/rebase.py

# was "dest". we now write dest per src root below. # was "dest". we now write dest per src root below.
f.write(b'\n') f.write(b'\n')
f.write(repo[self.external].hex() + b'\n') f.write(repo[self.external].hex() + b'\n')
f.write(b'%d\n' % int(self.collapsef)) f.write(b'%d\n' % int(self.collapsef))
f.write(b'%d\n' % int(self.keepf)) f.write(b'%d\n' % int(self.keepf))
f.write(b'%d\n' % int(self.keepbranchesf)) f.write(b'%d\n' % int(self.keepbranchesf))
f.write(b'%s\n' % (self.activebookmark or b'')) f.write(b'%s\n' % (self.activebookmark or b''))
destmap = self.destmap destmap = self.destmap
for d, v in pycompat.iteritems(self.state): for d, v in self.state.items():
oldrev = repo[d].hex() oldrev = repo[d].hex()
if v >= 0: if v >= 0:
newrev = repo[v].hex() newrev = repo[v].hex()
else: else:
newrev = b"%d" % v newrev = b"%d" % v
destnode = repo[destmap[d]].hex() destnode = repo[destmap[d]].hex()
f.write(b"%s:%s:%s\n" % (oldrev, newrev, destnode)) f.write(b"%s:%s:%s\n" % (oldrev, newrev, destnode))
repo.ui.debug(b'rebase status stored\n') repo.ui.debug(b'rebase status stored\n')
# Store the state before we begin so users can run 'hg rebase --abort' # Store the state before we begin so users can run 'hg rebase --abort'
# if we fail before the transaction closes. # if we fail before the transaction closes.
self.storestatus() self.storestatus()
if tr: if tr:
# When using single transaction, store state when transaction # When using single transaction, store state when transaction
# commits. # commits.
self.storestatus(tr) self.storestatus(tr)
cands = [k for k, v in pycompat.iteritems(self.state) if v == revtodo] cands = [k for k, v in self.state.items() if v == revtodo]
p = repo.ui.makeprogress( p = repo.ui.makeprogress(
_(b"rebasing"), unit=_(b'changesets'), total=len(cands) _(b"rebasing"), unit=_(b'changesets'), total=len(cands)
) )
def progress(ctx): def progress(ctx):
p.increment(item=(b"%d:%s" % (ctx.rev(), ctx))) p.increment(item=(b"%d:%s" % (ctx.rev(), ctx)))
for subset in sortsource(self.destmap): for subset in sortsource(self.destmap):
bpbase = {} # {branchingpoint: [origbase]} bpbase = {} # {branchingpoint: [origbase]}
for b in base: # group bases by branching points for b in base: # group bases by branching points
bp = repo.revs(b'ancestor(%d, %d)', b, dest.rev()).first() bp = repo.revs(b'ancestor(%d, %d)', b, dest.rev()).first()
bpbase[bp] = bpbase.get(bp, []) + [b] bpbase[bp] = bpbase.get(bp, []) + [b]
if None in bpbase: if None in bpbase:
# emulate the old behavior, showing "nothing to rebase" (a better # emulate the old behavior, showing "nothing to rebase" (a better
# behavior may be abort with "cannot find branching point" error) # behavior may be abort with "cannot find branching point" error)
bpbase.clear() bpbase.clear()
for bp, bs in pycompat.iteritems(bpbase): # calculate roots for bp, bs in bpbase.items(): # calculate roots
roots += list(repo.revs(b'children(%d) & ancestors(%ld)', bp, bs)) roots += list(repo.revs(b'children(%d) & ancestors(%ld)', bp, bs))
rebaseset = repo.revs(b'%ld::', roots) rebaseset = repo.revs(b'%ld::', roots)
if not rebaseset: if not rebaseset:
# transform to list because smartsets are not comparable to # transform to list because smartsets are not comparable to
# lists. This should be improved to honor laziness of # lists. This should be improved to honor laziness of
# smartset. # smartset.
replacements[(oldnode,)] = succs replacements[(oldnode,)] = succs
if collapsednodes: if collapsednodes:
replacements[tuple(collapsednodes)] = (collapsedas,) replacements[tuple(collapsednodes)] = (collapsedas,)
if fm: if fm:
hf = fm.hexfunc hf = fm.hexfunc
fl = fm.formatlist fl = fm.formatlist
fd = fm.formatdict fd = fm.formatdict
changes = {} changes = {}
for oldns, newn in pycompat.iteritems(replacements): for oldns, newn in replacements.items():
for oldn in oldns: for oldn in oldns:
changes[hf(oldn)] = fl([hf(n) for n in newn], name=b'node') changes[hf(oldn)] = fl([hf(n) for n in newn], name=b'node')
nodechanges = fd(changes, key=b"oldnode", value=b"newnodes") nodechanges = fd(changes, key=b"oldnode", value=b"newnodes")
fm.data(nodechanges=nodechanges) fm.data(nodechanges=nodechanges)
if keepf: if keepf:
replacements = {} replacements = {}
scmutil.cleanupnodes(repo, replacements, b'rebase', moves, backup=backup) scmutil.cleanupnodes(repo, replacements, b'rebase', moves, backup=backup)

hgext/releasenotes.py

class releasenotessections(object): class releasenotessections(object):
def __init__(self, ui, repo=None): def __init__(self, ui, repo=None):
if repo: if repo:
sections = util.sortdict(DEFAULT_SECTIONS) sections = util.sortdict(DEFAULT_SECTIONS)
custom_sections = getcustomadmonitions(repo) custom_sections = getcustomadmonitions(repo)
if custom_sections: if custom_sections:
sections.update(custom_sections) sections.update(custom_sections)
self._sections = list(pycompat.iteritems(sections)) self._sections = list(sections.items())
else: else:
self._sections = list(DEFAULT_SECTIONS) self._sections = list(DEFAULT_SECTIONS)
def __iter__(self): def __iter__(self):
return iter(self._sections) return iter(self._sections)
def names(self): def names(self):
return [t[0] for t in self._sections] return [t[0] for t in self._sections]

hgext/remotefilelog/basestore.py

name+node keys and not namehash+node keys. name+node keys and not namehash+node keys.
""" """
existing = {} existing = {}
for filenamehash, node in self._listkeys(): for filenamehash, node in self._listkeys():
existing.setdefault(filenamehash, []).append(node) existing.setdefault(filenamehash, []).append(node)
filenamemap = self._resolvefilenames(existing.keys()) filenamemap = self._resolvefilenames(existing.keys())
for filename, sha in pycompat.iteritems(filenamemap): for filename, sha in filenamemap.items():
yield (filename, existing[sha]) yield (filename, existing[sha])
def _resolvefilenames(self, hashes): def _resolvefilenames(self, hashes):
"""Given a list of filename hashes that are present in the """Given a list of filename hashes that are present in the
remotefilelog store, return a mapping from filename->hash. remotefilelog store, return a mapping from filename->hash.
This is useful when converting remotefilelog blobs into other storage This is useful when converting remotefilelog blobs into other storage
formats. formats.

hgext/remotefilelog/datapack.py

size = len(rawdata) size = len(rawdata)
self.entries[node] = (deltabasenode, offset, size) self.entries[node] = (deltabasenode, offset, size)
self.writeraw(rawdata) self.writeraw(rawdata)
def createindex(self, nodelocations, indexoffset): def createindex(self, nodelocations, indexoffset):
entries = sorted( entries = sorted(
(n, db, o, s) for n, (db, o, s) in pycompat.iteritems(self.entries) (n, db, o, s) for n, (db, o, s) in self.entries.items()
) )
rawindex = b'' rawindex = b''
fmt = self.INDEXFORMAT fmt = self.INDEXFORMAT
for node, deltabase, offset, size in entries: for node, deltabase, offset, size in entries:
if deltabase == sha1nodeconstants.nullid: if deltabase == sha1nodeconstants.nullid:
deltabaselocation = FULLTEXTINDEXMARK deltabaselocation = FULLTEXTINDEXMARK
else: else:

hgext/remotefilelog/historypack.py

def createindex(self, nodelocations, indexoffset): def createindex(self, nodelocations, indexoffset):
fileindexformat = self.INDEXFORMAT fileindexformat = self.INDEXFORMAT
fileindexlength = self.INDEXENTRYLENGTH fileindexlength = self.INDEXENTRYLENGTH
nodeindexformat = self.NODEINDEXFORMAT nodeindexformat = self.NODEINDEXFORMAT
nodeindexlength = self.NODEINDEXENTRYLENGTH nodeindexlength = self.NODEINDEXENTRYLENGTH
files = ( files = (
(hashutil.sha1(filename).digest(), filename, offset, size) (hashutil.sha1(filename).digest(), filename, offset, size)
for filename, (offset, size) in pycompat.iteritems(self.files) for filename, (offset, size) in self.files.items()
) )
files = sorted(files) files = sorted(files)
# node index is after file index size, file index, and node index size # node index is after file index size, file index, and node index size
indexlensize = struct.calcsize(b'!Q') indexlensize = struct.calcsize(b'!Q')
nodeindexoffset = ( nodeindexoffset = (
indexoffset indexoffset
+ indexlensize + indexlensize
nodeindexsize, nodeindexsize,
) )
# Node index # Node index
nodeindexentries.append( nodeindexentries.append(
struct.pack(constants.FILENAMESTRUCT, len(filename)) + filename struct.pack(constants.FILENAMESTRUCT, len(filename)) + filename
) )
nodeindexoffset += constants.FILENAMESIZE + len(filename) nodeindexoffset += constants.FILENAMESIZE + len(filename)
for node, location in sorted(pycompat.iteritems(nodelocations)): for node, location in sorted(nodelocations.items()):
nodeindexentries.append( nodeindexentries.append(
struct.pack(nodeindexformat, node, location) struct.pack(nodeindexformat, node, location)
) )
nodecount += 1 nodecount += 1
nodeindexoffset += len(nodelocations) * nodeindexlength nodeindexoffset += len(nodelocations) * nodeindexlength
fileindexentries.append(rawentry) fileindexentries.append(rawentry)
nodecountraw = struct.pack(b'!Q', nodecount) nodecountraw = struct.pack(b'!Q', nodecount)
return ( return (
b''.join(fileindexentries) b''.join(fileindexentries)
+ nodecountraw + nodecountraw
+ b''.join(nodeindexentries) + b''.join(nodeindexentries)
) )

hgext/remotefilelog/remotefilelog.py

import os import os
from mercurial.node import bin from mercurial.node import bin
from mercurial.i18n import _ from mercurial.i18n import _
from mercurial import ( from mercurial import (
ancestor, ancestor,
error, error,
mdiff, mdiff,
pycompat,
revlog, revlog,
) )
from mercurial.utils import storageutil from mercurial.utils import storageutil
from mercurial.revlogutils import flagutil from mercurial.revlogutils import flagutil
from . import ( from . import (
constants, constants,
fileserverclient, fileserverclient,
def ancestormap(self, node): def ancestormap(self, node):
return self.repo.metadatastore.getancestors(self.filename, node) return self.repo.metadatastore.getancestors(self.filename, node)
def ancestor(self, a, b): def ancestor(self, a, b):
if a == self.repo.nullid or b == self.repo.nullid: if a == self.repo.nullid or b == self.repo.nullid:
return self.repo.nullid return self.repo.nullid
revmap, parentfunc = self._buildrevgraph(a, b) revmap, parentfunc = self._buildrevgraph(a, b)
nodemap = {v: k for (k, v) in pycompat.iteritems(revmap)} nodemap = {v: k for (k, v) in revmap.items()}
ancs = ancestor.ancestors(parentfunc, revmap[a], revmap[b]) ancs = ancestor.ancestors(parentfunc, revmap[a], revmap[b])
if ancs: if ancs:
# choose a consistent winner when there's a tie # choose a consistent winner when there's a tie
return min(map(nodemap.__getitem__, ancs)) return min(map(nodemap.__getitem__, ancs))
return self.repo.nullid return self.repo.nullid
def commonancestorsheads(self, a, b): def commonancestorsheads(self, a, b):
"""calculate all the heads of the common ancestors of nodes a and b""" """calculate all the heads of the common ancestors of nodes a and b"""
if a == self.repo.nullid or b == self.repo.nullid: if a == self.repo.nullid or b == self.repo.nullid:
return self.repo.nullid return self.repo.nullid
revmap, parentfunc = self._buildrevgraph(a, b) revmap, parentfunc = self._buildrevgraph(a, b)
nodemap = {v: k for (k, v) in pycompat.iteritems(revmap)} nodemap = {v: k for (k, v) in revmap.items()}
ancs = ancestor.commonancestorsheads(parentfunc, revmap[a], revmap[b]) ancs = ancestor.commonancestorsheads(parentfunc, revmap[a], revmap[b])
return map(nodemap.__getitem__, ancs) return map(nodemap.__getitem__, ancs)
def _buildrevgraph(self, a, b): def _buildrevgraph(self, a, b):
"""Builds a numeric revision graph for the given two nodes. """Builds a numeric revision graph for the given two nodes.
Returns a node->rev map and a rev->[revs] parent function. Returns a node->rev map and a rev->[revs] parent function.
""" """
amap = self.ancestormap(a) amap = self.ancestormap(a)
bmap = self.ancestormap(b) bmap = self.ancestormap(b)
# Union the two maps # Union the two maps
parentsmap = collections.defaultdict(list) parentsmap = collections.defaultdict(list)
allparents = set() allparents = set()
for mapping in (amap, bmap): for mapping in (amap, bmap):
for node, pdata in pycompat.iteritems(mapping): for node, pdata in mapping.items():
parents = parentsmap[node] parents = parentsmap[node]
p1, p2, linknode, copyfrom = pdata p1, p2, linknode, copyfrom = pdata
# Don't follow renames (copyfrom). # Don't follow renames (copyfrom).
# remotefilectx.ancestor does that. # remotefilectx.ancestor does that.
if p1 != self.repo.nullid and not copyfrom: if p1 != self.repo.nullid and not copyfrom:
parents.append(p1) parents.append(p1)
allparents.add(p1) allparents.add(p1)
if p2 != self.repo.nullid: if p2 != self.repo.nullid:

hgext/remotefilelog/remotefilelogserver.py

from mercurial.pycompat import open from mercurial.pycompat import open
from mercurial import ( from mercurial import (
changegroup, changegroup,
changelog, changelog,
context, context,
error, error,
extensions, extensions,
match, match,
pycompat,
scmutil, scmutil,
store, store,
streamclone, streamclone,
util, util,
wireprotoserver, wireprotoserver,
wireprototypes, wireprototypes,
wireprotov1server, wireprotov1server,
) )
return return
neededfiles = set() neededfiles = set()
heads = repo.revs(b"heads(tip~25000:) - null") heads = repo.revs(b"heads(tip~25000:) - null")
cachepath = repo.vfs.join(b"remotefilelogcache") cachepath = repo.vfs.join(b"remotefilelogcache")
for head in heads: for head in heads:
mf = repo[head].manifest() mf = repo[head].manifest()
for filename, filenode in pycompat.iteritems(mf): for filename, filenode in mf.items():
filecachepath = os.path.join(cachepath, filename, hex(filenode)) filecachepath = os.path.join(cachepath, filename, hex(filenode))
neededfiles.add(filecachepath) neededfiles.add(filecachepath)
# delete unneeded older files # delete unneeded older files
days = repo.ui.configint(b"remotefilelog", b"serverexpiration") days = repo.ui.configint(b"remotefilelog", b"serverexpiration")
expiration = time.time() - (days * 24 * 60 * 60) expiration = time.time() - (days * 24 * 60 * 60)
progress = ui.makeprogress(_(b"removing old server cache"), unit=b"files") progress = ui.makeprogress(_(b"removing old server cache"), unit=b"files")

hgext/remotefilelog/repack.py

m = repo[r].manifest() m = repo[r].manifest()
lastmanifest = repo[r].manifest() lastmanifest = repo[r].manifest()
processed.add(r) processed.add(r)
# populate keepkeys with keys from the current manifest # populate keepkeys with keys from the current manifest
if type(m) is dict: if type(m) is dict:
# m is a result of diff of two manifests and is a dictionary that # m is a result of diff of two manifests and is a dictionary that
# maps filename to ((newnode, newflag), (oldnode, oldflag)) tuple # maps filename to ((newnode, newflag), (oldnode, oldflag)) tuple
for filename, diff in pycompat.iteritems(m): for filename, diff in m.items():
if diff[0][0] is not None: if diff[0][0] is not None:
keepkeys.add(keyfn(filename, diff[0][0])) keepkeys.add(keyfn(filename, diff[0][0]))
else: else:
# m is a manifest object # m is a manifest object
for filename, filenode in pycompat.iteritems(m): for filename, filenode in m.items():
keepkeys.add(keyfn(filename, filenode)) keepkeys.add(keyfn(filename, filenode))
return keepkeys return keepkeys
class repacker(object): class repacker(object):
"""Class for orchestrating the repack of data and history information into a """Class for orchestrating the repack of data and history information into a
new format. new format.
for entry in pycompat.itervalues(ledger.entries): for entry in pycompat.itervalues(ledger.entries):
if entry.datasource: if entry.datasource:
byfile.setdefault(entry.filename, {})[entry.node] = entry byfile.setdefault(entry.filename, {})[entry.node] = entry
count = 0 count = 0
repackprogress = ui.makeprogress( repackprogress = ui.makeprogress(
_(b"repacking data"), unit=self.unit, total=len(byfile) _(b"repacking data"), unit=self.unit, total=len(byfile)
) )
for filename, entries in sorted(pycompat.iteritems(byfile)): for filename, entries in sorted(byfile.items()):
repackprogress.update(count) repackprogress.update(count)
ancestors = {} ancestors = {}
nodes = list(node for node in entries) nodes = list(node for node in entries)
nohistory = [] nohistory = []
buildprogress = ui.makeprogress( buildprogress = ui.makeprogress(
_(b"building history"), unit=b'nodes', total=len(nodes) _(b"building history"), unit=b'nodes', total=len(nodes)
) )
byfile = {} byfile = {}
for entry in pycompat.itervalues(ledger.entries): for entry in pycompat.itervalues(ledger.entries):
if entry.historysource: if entry.historysource:
byfile.setdefault(entry.filename, {})[entry.node] = entry byfile.setdefault(entry.filename, {})[entry.node] = entry
progress = ui.makeprogress( progress = ui.makeprogress(
_(b"repacking history"), unit=self.unit, total=len(byfile) _(b"repacking history"), unit=self.unit, total=len(byfile)
) )
for filename, entries in sorted(pycompat.iteritems(byfile)): for filename, entries in sorted(byfile.items()):
ancestors = {} ancestors = {}
nodes = list(node for node in entries) nodes = list(node for node in entries)
for node in nodes: for node in nodes:
if node in ancestors: if node in ancestors:
continue continue
ancestors.update( ancestors.update(
self.history.getancestors(filename, node, known=ancestors) self.history.getancestors(filename, node, known=ancestors)

hgext/remotefilelog/shallowrepo.py

# shallowrepo.py - shallow repository that uses remote filelogs # shallowrepo.py - shallow repository that uses remote filelogs
# #
# Copyright 2013 Facebook, Inc. # Copyright 2013 Facebook, Inc.
# #
# 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.
import os import os
from mercurial.i18n import _ from mercurial.i18n import _
from mercurial.node import hex, nullrev from mercurial.node import hex, nullrev
from mercurial import ( from mercurial import (
encoding, encoding,
error, error,
localrepo, localrepo,
match, match,
pycompat,
scmutil, scmutil,
sparse, sparse,
util, util,
) )
from mercurial.utils import procutil from mercurial.utils import procutil
from . import ( from . import (
connectionpool, connectionpool,
constants, constants,
base = serverbase[0] base = serverbase[0]
else: else:
localrevs = repo localrevs = repo
mfl = repo.manifestlog mfl = repo.manifestlog
mfrevlog = mfl.getstorage(b'') mfrevlog = mfl.getstorage(b'')
if base is not None: if base is not None:
mfdict = mfl[repo[base].manifestnode()].read() mfdict = mfl[repo[base].manifestnode()].read()
skip = set(pycompat.iteritems(mfdict)) skip = set(mfdict.items())
else: else:
skip = set() skip = set()
# Copy the skip set to start large and avoid constant resizing, # Copy the skip set to start large and avoid constant resizing,
# and since it's likely to be very similar to the prefetch set. # and since it's likely to be very similar to the prefetch set.
files = skip.copy() files = skip.copy()
serverfiles = skip.copy() serverfiles = skip.copy()
visited = set() visited = set()
# Decompressing manifests is expensive. # Decompressing manifests is expensive.
# When possible, only read the deltas. # When possible, only read the deltas.
p1, p2 = mfrevlog.parentrevs(mfrev) p1, p2 = mfrevlog.parentrevs(mfrev)
if p1 in visited and p2 in visited: if p1 in visited and p2 in visited:
mfdict = mfl[mfnode].readfast() mfdict = mfl[mfnode].readfast()
else: else:
mfdict = mfl[mfnode].read() mfdict = mfl[mfnode].read()
diff = pycompat.iteritems(mfdict) diff = mfdict.items()
if pats: if pats:
diff = (pf for pf in diff if m(pf[0])) diff = (pf for pf in diff if m(pf[0]))
if sparsematch: if sparsematch:
diff = (pf for pf in diff if sparsematch(pf[0])) diff = (pf for pf in diff if sparsematch(pf[0]))
if rev not in localrevs: if rev not in localrevs:
serverfiles.update(diff) serverfiles.update(diff)
else: else:
files.update(diff) files.update(diff)

hgext/remotefilelog/shallowutil.py

def sumdicts(*dicts): def sumdicts(*dicts):
"""Adds all the values of *dicts together into one dictionary. This assumes """Adds all the values of *dicts together into one dictionary. This assumes
the values in *dicts are all summable. the values in *dicts are all summable.
e.g. [{'a': 4', 'b': 2}, {'b': 3, 'c': 1}] -> {'a': 4, 'b': 5, 'c': 1} e.g. [{'a': 4', 'b': 2}, {'b': 3, 'c': 1}] -> {'a': 4, 'b': 5, 'c': 1}
""" """
result = collections.defaultdict(lambda: 0) result = collections.defaultdict(lambda: 0)
for dict in dicts: for dict in dicts:
for k, v in pycompat.iteritems(dict): for k, v in dict.items():
result[k] += v result[k] += v
return result return result
def prefixkeys(dict, prefix): def prefixkeys(dict, prefix):
"""Returns ``dict`` with ``prefix`` prepended to all its keys.""" """Returns ``dict`` with ``prefix`` prepended to all its keys."""
result = {} result = {}
for k, v in pycompat.iteritems(dict): for k, v in dict.items():
result[prefix + k] = v result[prefix + k] = v
return result return result
def reportpackmetrics(ui, prefix, *stores): def reportpackmetrics(ui, prefix, *stores):
dicts = [s.getmetrics() for s in stores] dicts = [s.getmetrics() for s in stores]
dict = prefixkeys(sumdicts(*dicts), prefix + b'_') dict = prefixkeys(sumdicts(*dicts), prefix + b'_')
ui.log(prefix + b"_packsizes", b"\n", **pycompat.strkwargs(dict)) ui.log(prefix + b"_packsizes", b"\n", **pycompat.strkwargs(dict))
def parsepackmeta(metabuf): def parsepackmeta(metabuf):
"""like _parsepackmeta, but convert fields to desired types automatically. """like _parsepackmeta, but convert fields to desired types automatically.
This means, METAKEYFLAG and METAKEYSIZE fields will be converted to This means, METAKEYFLAG and METAKEYSIZE fields will be converted to
integers. integers.
""" """
metadict = _parsepackmeta(metabuf) metadict = _parsepackmeta(metabuf)
for k, v in pycompat.iteritems(metadict): for k, v in metadict.items():
if k in _metaitemtypes and int in _metaitemtypes[k]: if k in _metaitemtypes and int in _metaitemtypes[k]:
metadict[k] = bin2int(v) metadict[k] = bin2int(v)
return metadict return metadict
def int2bin(n): def int2bin(n):
"""convert a non-negative integer to raw binary buffer""" """convert a non-negative integer to raw binary buffer"""
buf = bytearray() buf = bytearray()

hgext/remotenames.py

return self.potentialentries.keys() return self.potentialentries.keys()
def iteritems(self): def iteritems(self):
"""Iterate over (name, node) tuples""" """Iterate over (name, node) tuples"""
if not self.loaded: if not self.loaded:
self._load() self._load()
for k, vtup in pycompat.iteritems(self.potentialentries): for k, vtup in self.potentialentries.items():
yield (k, [bin(vtup[0])]) yield (k, [bin(vtup[0])])
items = iteritems items = iteritems
class remotenames(object): class remotenames(object):
""" """
This class encapsulates all the remotenames state. It also contains This class encapsulates all the remotenames state. It also contains
def bmarktonodes(self): def bmarktonodes(self):
return self.bookmarks return self.bookmarks
def nodetobmarks(self): def nodetobmarks(self):
if not self._nodetobmarks: if not self._nodetobmarks:
bmarktonodes = self.bmarktonodes() bmarktonodes = self.bmarktonodes()
self._nodetobmarks = {} self._nodetobmarks = {}
for name, node in pycompat.iteritems(bmarktonodes): for name, node in bmarktonodes.items():
self._nodetobmarks.setdefault(node[0], []).append(name) self._nodetobmarks.setdefault(node[0], []).append(name)
return self._nodetobmarks return self._nodetobmarks
def branchtonodes(self): def branchtonodes(self):
return self.branches return self.branches
def nodetobranch(self): def nodetobranch(self):
if not self._nodetobranch: if not self._nodetobranch:
branchtonodes = self.branchtonodes() branchtonodes = self.branchtonodes()
self._nodetobranch = {} self._nodetobranch = {}
for name, nodes in pycompat.iteritems(branchtonodes): for name, nodes in branchtonodes.items():
for node in nodes: for node in nodes:
self._nodetobranch.setdefault(node, []).append(name) self._nodetobranch.setdefault(node, []).append(name)
return self._nodetobranch return self._nodetobranch
def hoisttonodes(self, hoist): def hoisttonodes(self, hoist):
if not self._hoisttonodes: if not self._hoisttonodes:
marktonodes = self.bmarktonodes() marktonodes = self.bmarktonodes()
self._hoisttonodes = {} self._hoisttonodes = {}
hoist += b'/' hoist += b'/'
for name, node in pycompat.iteritems(marktonodes): for name, node in marktonodes.items():
if name.startswith(hoist): if name.startswith(hoist):
name = name[len(hoist) :] name = name[len(hoist) :]
self._hoisttonodes[name] = node self._hoisttonodes[name] = node
return self._hoisttonodes return self._hoisttonodes
def nodetohoists(self, hoist): def nodetohoists(self, hoist):
if not self._nodetohoists: if not self._nodetohoists:
marktonodes = self.bmarktonodes() marktonodes = self.bmarktonodes()
self._nodetohoists = {} self._nodetohoists = {}
hoist += b'/' hoist += b'/'
for name, node in pycompat.iteritems(marktonodes): for name, node in marktonodes.items():
if name.startswith(hoist): if name.startswith(hoist):
name = name[len(hoist) :] name = name[len(hoist) :]
self._nodetohoists.setdefault(node[0], []).append(name) self._nodetohoists.setdefault(node[0], []).append(name)
return self._nodetohoists return self._nodetohoists
def wrapprintbookmarks(orig, ui, repo, fm, bmarks): def wrapprintbookmarks(orig, ui, repo, fm, bmarks):
if b'remotebookmarks' not in repo.names: if b'remotebookmarks' not in repo.names:

hgext/uncommit.py

# return the p1 so that we don't create an obsmarker later # return the p1 so that we don't create an obsmarker later
if not keepcommit: if not keepcommit:
return ctx.p1().node() return ctx.p1().node()
files = initialfiles - exclude files = initialfiles - exclude
# Filter copies # Filter copies
copied = copiesmod.pathcopies(base, ctx) copied = copiesmod.pathcopies(base, ctx)
copied = { copied = {dst: src for dst, src in copied.items() if dst in files}
dst: src for dst, src in pycompat.iteritems(copied) if dst in files
}
def filectxfn(repo, memctx, path, contentctx=ctx, redirect=()): def filectxfn(repo, memctx, path, contentctx=ctx, redirect=()):
if path not in contentctx: if path not in contentctx:
return None return None
fctx = contentctx[path] fctx = contentctx[path]
mctx = context.memfilectx( mctx = context.memfilectx(
repo, repo,
memctx, memctx,

hgext/win32text.py

def forbidcr(ui, repo, hooktype, node, **kwargs): def forbidcr(ui, repo, hooktype, node, **kwargs):
return forbidnewline(ui, repo, hooktype, node, b'\r', **kwargs) return forbidnewline(ui, repo, hooktype, node, b'\r', **kwargs)
def reposetup(ui, repo): def reposetup(ui, repo):
if not repo.local(): if not repo.local():
return return
for name, fn in pycompat.iteritems(_filters): for name, fn in _filters.items():
repo.adddatafilter(name, fn) repo.adddatafilter(name, fn)
def wrap_revert(orig, repo, ctx, names, uipathfn, actions, *args, **kwargs): def wrap_revert(orig, repo, ctx, names, uipathfn, actions, *args, **kwargs):
# reset dirstate cache for file we touch # reset dirstate cache for file we touch
ds = repo.dirstate ds = repo.dirstate
with ds.parentchange(): with ds.parentchange():
for filename in actions[b'revert'][0]: for filename in actions[b'revert'][0]:

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 pycompat.iteritems(exts): for kind, extensions in exts.items():
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 pycompat.iteritems(self._refmap) return self._refmap.items()
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(pycompat.iteritems(self._refmap)): for name, node in sorted(self._refmap.items()):
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 pycompat.iteritems(repo._bookmarks): for mark, n in repo._bookmarks.items():
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 pycompat.iteritems(marks): for k, v in marks.items():
# don't expose local divergent bookmarks # don't expose local divergent bookmarks
if hasnode(v) and not isdivergent(k): if hasnode(v) and not isdivergent(k):
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):
return books return books
def mirroring_remote(ui, repo, remotemarks): def mirroring_remote(ui, repo, remotemarks):
"""computes the bookmark changes that set the local bookmarks to """computes the bookmark changes that set the local bookmarks to
remotemarks""" remotemarks"""
changed = [] changed = []
localmarks = repo._bookmarks localmarks = repo._bookmarks
for (b, id) in pycompat.iteritems(remotemarks): for (b, id) in remotemarks.items():
if id != localmarks.get(b, None) and id in repo: if id != localmarks.get(b, None) and id in repo:
changed.append((b, id, ui.debug, _(b"updating bookmark %s\n") % b)) changed.append((b, id, ui.debug, _(b"updating bookmark %s\n") % b))
for b in localmarks: for b in localmarks:
if b not in remotemarks: if b not in remotemarks:
changed.append( changed.append(
(b, None, ui.debug, _(b"removing bookmark %s\n") % b) (b, None, ui.debug, _(b"removing bookmark %s\n") % b)
) )
return changed return changed
"""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(pycompat.iteritems(bmarks)): for bmark, (n, prefix, label) in sorted(bmarks.items()):
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 pycompat.iteritems(self._entries): for k, v in self._entries.items():
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 pycompat.iteritems(self): for bn, heads in self.items():
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):
return return
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(pycompat.iteritems(self._entries)): for label, nodes in sorted(self._entries.items()):
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))
# If a changeset is visible, its parents must be visible too, so # If a changeset is visible, its parents must be visible too, so
# use the faster unfiltered parent accessor. # use the faster unfiltered parent accessor.
parentrevs = repo.unfiltered().changelog.parentrevs parentrevs = repo.unfiltered().changelog.parentrevs
# Faster than using ctx.obsolete() # Faster than using ctx.obsolete()
obsrevs = obsolete.getrevs(repo, b'obsolete') obsrevs = obsolete.getrevs(repo, b'obsolete')
for branch, newheadrevs in pycompat.iteritems(newbranches): for branch, newheadrevs in newbranches.items():
# For every branch, compute the new branchheads. # For every branch, compute the new branchheads.
# A branchhead is a revision such that no descendant is on # A branchhead is a revision such that no descendant is on
# the same branch. # the same branch.
# #
# The branchheads are computed iteratively in revision order. # The branchheads are computed iteratively in revision order.
# This ensures topological order, i.e. parents are processed # This ensures topological order, i.e. parents are processed
# before their children. Ancestors are inclusive here, i.e. # before their children. Ancestors are inclusive here, i.e.
# any revision is an ancestor of itself. # any revision is an ancestor of itself.

mercurial/bundle2.py

phasetonodes = phases.binarydecode(inpart) phasetonodes = phases.binarydecode(inpart)
unfi = op.repo.unfiltered() unfi = op.repo.unfiltered()
cl = unfi.changelog cl = unfi.changelog
phasecache = unfi._phasecache phasecache = unfi._phasecache
msg = ( msg = (
b'remote repository changed while pushing - please try again ' b'remote repository changed while pushing - please try again '
b'(%s is %s expected %s)' b'(%s is %s expected %s)'
) )
for expectedphase, nodes in pycompat.iteritems(phasetonodes): for expectedphase, nodes in phasetonodes.items():
for n in nodes: for n in nodes:
actualphase = phasecache.phase(unfi, cl.rev(n)) actualphase = phasecache.phase(unfi, cl.rev(n))
if actualphase != expectedphase: if actualphase != expectedphase:
finalmsg = msg % ( finalmsg = msg % (
short(n), short(n),
phases.phasenames[actualphase], phases.phasenames[actualphase],
phases.phasenames[expectedphase], phases.phasenames[expectedphase],
) )

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 nodes we must see # store file nodes we must see
for f, n in pycompat.iteritems(mfest): for f, n in mfest.items():
needfiles.setdefault(f, set()).add(n) needfiles.setdefault(f, set()).add(n)
on_filelog_rev = None on_filelog_rev = None
if sidedata_helpers: if sidedata_helpers:
if revlog_constants.KIND_FILELOG in sidedata_helpers[1]: if revlog_constants.KIND_FILELOG in sidedata_helpers[1]:
def on_filelog_rev(filelog, rev): def on_filelog_rev(filelog, rev):
range = touched_filelogs.get(filelog) range = touched_filelogs.get(filelog)
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 pycompat.iteritems(needfiles): for f, needs in needfiles.items():
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 pycompat.iteritems(encoding.environ) for k, v in encoding.environ.items()
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, cmd, util.abspath(cwd or b'.')] args = [type, cmd, util.abspath(cwd or b'.')]
args.extend(b'%s=%s' % (k, v) for k, v in pycompat.iteritems(environ)) args.extend(b'%s=%s' % (k, v) for k, v in environ.items())
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 pycompat.iteritems(backups): for realname, tmpname in backups.items():
ui.debug(b'restoring %r to %r\n' % (tmpname, realname)) ui.debug(b'restoring %r to %r\n' % (tmpname, realname))
if dirstate.get_entry(realname).maybe_clean: if dirstate.get_entry(realname).maybe_clean:
# 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
# XXX-PENDINGCHANGE: We should clarify the context in # XXX-PENDINGCHANGE: We should clarify the context in

mercurial/commands.py

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
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(pycompat.iteritems(table)): for cmd, vals in sorted(table.items()):
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'))],
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 pycompat.iteritems(c): for d, s in c.items():
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/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 pycompat.iteritems(d): for fn, value in d.items():
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

from .i18n import _ from .i18n import _
from .node import nullrev from .node import nullrev
from . import ( from . import (
match as matchmod, match as matchmod,
pathutil, pathutil,
policy, policy,
pycompat,
util, util,
) )
from .utils import stringutil from .utils import stringutil
from .revlogutils import ( from .revlogutils import (
flagutil, flagutil,
elif k not in dst: # case 1 elif k not in dst: # case 1
# remove copies to files that were then removed # remove copies to files that were then removed
del t[k] del t[k]
def _chain(prefix, suffix): def _chain(prefix, suffix):
"""chain two sets of copies 'prefix' and 'suffix'""" """chain two sets of copies 'prefix' and 'suffix'"""
result = prefix.copy() result = prefix.copy()
for key, value in pycompat.iteritems(suffix): for key, value in suffix.items():
result[key] = prefix.get(value, value) result[key] = prefix.get(value, value)
return result return result
def _tracefile(fctx, am, basemf): def _tracefile(fctx, am, basemf):
"""return file context that is the ancestor of fctx present in ancestor """return file context that is the ancestor of fctx present in ancestor
manifest am manifest am
childcopies = {} childcopies = {}
if parent == 1: if parent == 1:
childcopies = changes.copied_from_p1 childcopies = changes.copied_from_p1
elif parent == 2: elif parent == 2:
childcopies = changes.copied_from_p2 childcopies = changes.copied_from_p2
if childcopies: if childcopies:
newcopies = copies.copy() newcopies = copies.copy()
for dest, source in pycompat.iteritems(childcopies): for dest, source in childcopies.items():
prev = copies.get(source) prev = copies.get(source)
if prev is not None and prev[1] is not None: if prev is not None and prev[1] is not None:
source = prev[1] source = prev[1]
newcopies[dest] = (current_rev, source) newcopies[dest] = (current_rev, source)
assert newcopies is not copies assert newcopies is not copies
if changes.removed: if changes.removed:
for f in changes.removed: for f in changes.removed:
if f in newcopies: if f in newcopies:
childcopies = p2copies childcopies = p2copies
if not alwaysmatch: if not alwaysmatch:
childcopies = { childcopies = {
dst: src for dst, src in childcopies.items() if match(dst) dst: src for dst, src in childcopies.items() if match(dst)
} }
newcopies = copies newcopies = copies
if childcopies: if childcopies:
newcopies = copies.copy() newcopies = copies.copy()
for dest, source in pycompat.iteritems(childcopies): for dest, source in childcopies.items():
prev = copies.get(source) prev = copies.get(source)
if prev is not None and prev[1] is not None: if prev is not None and prev[1] is not None:
source = prev[1] source = prev[1]
newcopies[dest] = (c, source) newcopies[dest] = (c, source)
assert newcopies is not copies assert newcopies is not copies
for f in removed: for f in removed:
if f in newcopies: if f in newcopies:
if newcopies is copies: if newcopies is copies:
def _reverse_renames(copies, dst, match): def _reverse_renames(copies, dst, match):
"""given copies to context 'dst', finds renames from that context""" """given copies to context 'dst', finds renames from that context"""
# 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.
r = {} r = {}
for k, v in sorted(pycompat.iteritems(copies)): for k, v in sorted(copies.items()):
if match and not match(v): if match and not match(v):
continue continue
# remove copies # remove copies
if v in dst: if v in dst:
continue continue
r[v] = k r[v] = k
return r return r
ctx) ctx)
""" """
# generate a directory move map # generate a directory move map
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 pycompat.iteritems(fullcopy): for dst, src in fullcopy.items():
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 ctx.hasdir(dsrc) and ctx.hasdir(ddst): elif ctx.hasdir(dsrc) and ctx.hasdir(ddst):
# directory wasn't entirely moved locally # directory wasn't entirely moved locally
invalid.add(dsrc) invalid.add(dsrc)
elif dsrc in dirmove and dirmove[dsrc] != ddst: elif dsrc in dirmove and dirmove[dsrc] != ddst:
# files from the same directory moved to two different places # files from the same directory moved to two different places
invalid.add(dsrc) invalid.add(dsrc)
else: else:
# looks good so far # looks good so far
dirmove[dsrc] = ddst dirmove[dsrc] = ddst
for i in invalid: for i in invalid:
if i in dirmove: if i in dirmove:
del dirmove[i] del dirmove[i]
del invalid del invalid
if not dirmove: if not dirmove:
return {}, {} return {}, {}
dirmove = {k + b"/": v + b"/" for k, v in pycompat.iteritems(dirmove)} dirmove = {k + b"/": v + b"/" for k, v in dirmove.items()}
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])
) )
# Sort the directories in reverse order, so we find children first # Sort the directories in reverse order, so we find children first
# For example, if dir1/ was renamed to dir2/, and dir1/subdir1/ # For example, if dir1/ was renamed to dir2/, and dir1/subdir1/
# 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()
copies2 = {} copies2 = {}
cp = _forwardcopies(base, c2) cp = _forwardcopies(base, c2)
for dst, src in pycompat.iteritems(cp): for dst, src in cp.items():
if src in m1: if src in m1:
copies2[dst] = src copies2[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
# Extra filtering to drop copy information for files that existed before # Extra filtering to drop copy information for files that existed before
# the graft. This is to handle the case of grafting a rename onto a commit # the graft. This is to handle the case of grafting a rename onto a commit
# that already has the rename. Otherwise the presence of copy information # that already has the rename. Otherwise the presence of copy information
# would result in the creation of an empty commit where we would prefer to # would result in the creation of an empty commit where we would prefer to
# not create one. # not create one.
for dest, __ in list(new_copies.items()): for dest, __ in list(new_copies.items()):
if dest in parent: if dest in parent:
del new_copies[dest] del new_copies[dest]
for dst, src in pycompat.iteritems(new_copies): for dst, src in new_copies.items():
wctx[dst].markcopied(src) wctx[dst].markcopied(src)

mercurial/debugcommands.py

try: try:
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(pycompat.iteritems(b2caps)): for key, values in sorted(b2caps.items()):
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)
finally: finally:
peer.close() peer.close()
@command( @command(
fm_files.end() fm_files.end()
fm_extras = fm.nested(b'extras') fm_extras = fm.nested(b'extras')
for f, d in sorted(pycompat.iteritems(ms.allextras())): for f, d in sorted(pycompat.iteritems(ms.allextras())):
if f in ms: if f in ms:
# If file is in mergestate, we have already processed it's extras # If file is in mergestate, we have already processed it's extras
continue continue
for k, v in pycompat.iteritems(d): for k, v in d.items():
fm_extras.startitem() fm_extras.startitem()
fm_extras.data(file=f) fm_extras.data(file=f)
fm_extras.data(key=k) fm_extras.data(key=k)
fm_extras.data(value=v) fm_extras.data(value=v)
fm_extras.end() fm_extras.end()
fm.end() fm.end()
@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 pycompat.iteritems(repo.names): for name, ns in repo.names.items():
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['full'] fullpaths = opts['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 pycompat.iteritems(dirstate): for f, st in dirstate.items():
if f.startswith(spec) and st.state in acceptable: if f.startswith(spec) and st.state 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:
) )
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)
try: try:
for opt in cmdutil.remoteopts: for opt in cmdutil.remoteopts:
del opts[opt[1]] del opts[opt[1]]
args = {} args = {}
for k, v in pycompat.iteritems(opts): for k, v in opts.items():
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 pycompat.iteritems(self._map) return self._map.items()
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, tr, st): def _writedirstate(self, tr, 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( for c, callback in sorted(self._plchangecallbacks.items()):
pycompat.iteritems(self._plchangecallbacks)
):
callback(self, self._origpl, self._pl) callback(self, self._origpl, self._pl)
self._origpl = None self._origpl = None
self._map.write(tr, st) self._map.write(tr, st)
self._dirty = False self._dirty = False
self._dirty_tracked_set = False self._dirty_tracked_set = False
def _write_tracked_hint(self, tr, f): def _write_tracked_hint(self, tr, f):
key = node.hex(uuid.uuid4().bytes) key = node.hex(uuid.uuid4().bytes)
# 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 pycompat.iteritems(results): for f, st in results.items():
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 pycompat.iteritems(normed): for norm, paths in normed.items():
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

mercurial/dirstatemap.py

# dirstatemap.py # dirstatemap.py
# #
# 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.
import errno import errno
from .i18n import _ from .i18n import _
from . import ( from . import (
error, error,
pathutil, pathutil,
policy, policy,
pycompat,
txnutil, txnutil,
util, util,
) )
from .dirstateutils import ( from .dirstateutils import (
docket as docketmod, docket as docketmod,
v2, v2,
) )
self.copymap.clear() self.copymap.clear()
self.setparents(self._nodeconstants.nullid, self._nodeconstants.nullid) self.setparents(self._nodeconstants.nullid, self._nodeconstants.nullid)
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")
def items(self): def items(self):
return pycompat.iteritems(self._map) return self._map.items()
# forward for python2,3 compat # forward for python2,3 compat
iteritems = items iteritems = items
def debug_iter(self, all): def debug_iter(self, all):
""" """
Return an iterator of (filename, state, mode, size, mtime) tuples Return an iterator of (filename, state, mode, size, mtime) tuples
`all` is unused when Rust is not enabled `all` is unused when Rust is not enabled
""" """
for (filename, item) in self.items(): for (filename, item) in self.items():
yield (filename, item.state, item.mode, item.size, item.mtime) yield (filename, item.state, item.mode, item.size, item.mtime)
def keys(self): def keys(self):
return self._map.keys() return self._map.keys()
### reading/setting parents ### reading/setting parents
def setparents(self, p1, p2, fold_p2=False): def setparents(self, p1, p2, fold_p2=False):
self._parents = (p1, p2) self._parents = (p1, p2)
self._dirtyparents = True self._dirtyparents = True
copies = {} copies = {}
if fold_p2: if fold_p2:
for f, s in pycompat.iteritems(self._map): for f, s in self._map.items():
# Discard "merged" markers when moving away from a merge state # Discard "merged" markers when moving away from a merge state
if s.p2_info: if s.p2_info:
source = self.copymap.pop(f, None) source = self.copymap.pop(f, None)
if source: if source:
copies[f] = source copies[f] = source
s.drop_merge_data() s.drop_merge_data()
return copies return copies
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 pycompat.iteritems(self._map): for name, s in self._map.items():
if not s.removed: if not s.removed:
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
@propertycache @propertycache
def dirfoldmap(self): def dirfoldmap(self):
f = {} f = {}

mercurial/discovery.py

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 pycompat.iteritems(remotemap): for branch, heads in remotemap.items():
# 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(
repo, repo,
( (
(branch, heads[1]) (branch, heads[1])
for branch, heads in pycompat.iteritems(headssum) for branch, heads in headssum.items()
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 pycompat.iteritems(newmap): for branch, newheads in newmap.items():
headssum[branch][1][:] = newheads headssum[branch][1][:] = newheads
for branch, items in pycompat.iteritems(headssum): for branch, items in headssum.items():
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
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 branch for branch, heads in headssum.items() if heads[0] is None
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:

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 pycompat.iteritems(cmdtable): for alias, e in cmdtable.items():
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 pycompat.iteritems(pushop.pushbranchmap): for branch, heads in pushop.pushbranchmap.items():
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 pycompat.iteritems(shellvars): for key, value in shellvars.items():
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/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 pycompat.iteritems(_extensions): for k, v in _extensions.items():
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 pycompat.iteritems(cmdtable): for c, e in cmdtable.items():
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 pycompat.iteritems(table): for alias, e in table.items():
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 pycompat.iteritems(_disabledextensions): for name, path in _disabledextensions.items():
# 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__ # pytype: disable=import-error from hgext import __index__ # pytype: disable=import-error
return { return {
name: gettext(desc) name: gettext(desc)
for name, desc in pycompat.iteritems(__index__.docs) for name, desc in __index__.docs.items()
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 pycompat.iteritems(paths): for name, path in paths.items():
doc = _disabledhelp(path) doc = _disabledhelp(path)
if doc and name != b'__index__': if doc and name != b'__index__':
exts[name] = doc.splitlines()[0] exts[name] = doc.splitlines()[0]
return exts return exts
def disabled_help(name): def disabled_help(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 pycompat.iteritems(paths): for name, path in paths.items():
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)')
assert doc is not None # help pytype assert doc is not None # help pytype
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 [ return [name for name, mod in _extensions.items() if mod is None]
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):
try: try:
version = module.getversion() version = module.getversion()
except Exception: except Exception:

mercurial/exthelper.py

# Copyright 2012 Logilab SA <contact@logilab.fr> # Copyright 2012 Logilab SA <contact@logilab.fr>
# Pierre-Yves David <pierre-yves.david@ens-lyon.org> # Pierre-Yves David <pierre-yves.david@ens-lyon.org>
# Octobus <contact@octobus.net> # Octobus <contact@octobus.net>
# #
# 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.
##################################################################### #####################################################################
### Extension helper ### ### Extension helper ###
##################################################################### #####################################################################
from . import ( from . import (
commands, commands,
error, error,
extensions, extensions,
pycompat,
registrar, registrar,
) )
from hgdemandimport import tracing from hgdemandimport import tracing
class exthelper(object): class exthelper(object):
"""Helper for modular extension setup """Helper for modular extension setup
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 pycompat.iteritems(other.configtable): for section, items in other.configtable.items():
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

def _workingpath(repo, ctx): def _workingpath(repo, ctx):
return repo.wjoin(ctx.path()) return repo.wjoin(ctx.path())
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 pycompat.iteritems(registrarobj._table): for name, func in registrarobj._table.items():
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.analyze(tree) tree = filesetlang.analyze(tree)
tree = filesetlang.optimize(tree) tree = filesetlang.optimize(tree)
mctx = matchctx(ctx.p1(), ctx, cwd, badfn=badfn) mctx = matchctx(ctx.p1(), ctx, cwd, 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 pycompat.iteritems(registrarobj._table): for name, func in registrarobj._table.items():
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(pycompat.iteritems(data)) return sorted(data.items())
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(pycompat.iteritems(exts)): for name, desc in sorted(exts.items()):
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 pycompat.iteritems(commands.table): for cmd, entry in commands.table.items():
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):
def _getcategorizedhelpcmds(ui, cmdtable, name, select=None): def _getcategorizedhelpcmds(ui, cmdtable, name, select=None):
# 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 pycompat.iteritems(cmdtable): for c, e in cmdtable.items():
fs = cmdutil.parsealiases(c) fs = cmdutil.parsealiases(c)
f = fs[0] f = fs[0]
syns[f] = fs syns[f] = 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 pycompat.iteritems(webutil.archivespecs): for type_, spec in webutil.archivespecs.items():
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/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 pycompat.iteritems(self._items)} return {k: list(v) for k, v in self._items.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.
""" """
if pycompat.iswindows: if pycompat.iswindows:
# This is what mercurial.encoding does for os.environ on # This is what mercurial.encoding does for os.environ on
# Windows. # Windows.
return encoding.strtolocal(s) return encoding.strtolocal(s)
else: else:
# This is what is documented to be used for os.environ on Unix. # This is what is documented to be used for os.environ on Unix.
return pycompat.fsencode(s) return pycompat.fsencode(s)
env = {tobytes(k): tobytes(v) for k, v in pycompat.iteritems(env)} env = {tobytes(k): tobytes(v) for k, v in env.items()}
# 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')
if altbaseurl: if altbaseurl:
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 pycompat.iteritems(env): for k, v in env.items():
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 pycompat.iteritems(mf): for full, n in mf.items():
# 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 pycompat.iteritems(commands.table): for c, e in commands.table.items():
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 pycompat.iteritems(archivespecs): for typ, spec in archivespecs.items():
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(pycompat.iteritems(self._vars)): for key, value in sorted(self._vars.items()):
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(pycompat.iteritems(os.environ)) # re-exports environ = dict(os.environ.items()) # re-exports
environ.setdefault('PATH_INFO', '') environ.setdefault('PATH_INFO', '')
if environ.get('SERVER_SOFTWARE', '').startswith('Microsoft-IIS'): if environ.get('SERVER_SOFTWARE', '').startswith('Microsoft-IIS'):
# IIS includes script_name in PATH_INFO # IIS includes script_name in PATH_INFO
scriptname = environ['SCRIPT_NAME'] scriptname = environ['SCRIPT_NAME']
if environ['PATH_INFO'].startswith(scriptname): if environ['PATH_INFO'].startswith(scriptname):
environ['PATH_INFO'] = environ['PATH_INFO'][len(scriptname) :] environ['PATH_INFO'] = environ['PATH_INFO'][len(scriptname) :]
stdin = procutil.stdin stdin = procutil.stdin

mercurial/hook.py

plain = ui.plain() plain = ui.plain()
else: else:
plain = ui.configbool(b'hooks', b'%s:run-with-plain' % name) plain = ui.configbool(b'hooks', b'%s:run-with-plain' % name)
if plain: if plain:
env[b'HGPLAIN'] = b'1' env[b'HGPLAIN'] = b'1'
else: else:
env[b'HGPLAIN'] = b'' env[b'HGPLAIN'] = b''
for k, v in pycompat.iteritems(args): for k, v in args.items():
# transaction changes can accumulate MBs of data, so skip it # transaction changes can accumulate MBs of data, so skip it
# for external hooks # for external hooks
if k == b'changes': if k == b'changes':
continue continue
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)

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 pycompat.iteritems(groups): for group, auth in groups.items():
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/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 pycompat.iteritems(tags): for k, v in tags.items():
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 pycompat.iteritems(alltags): for (name, (node, hist)) in alltags.items():
if node != self.nullid: if node != self.nullid:
tags[encoding.tolocal(name)] = node tags[encoding.tolocal(name)] = node
tags[b'tip'] = self.changelog.tip() tags[b'tip'] = self.changelog.tip()
tagtypes = { tagtypes = {
encoding.tolocal(name): value encoding.tolocal(name): value for (name, value) in tagtypes.items()
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
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 pycompat.iteritems(self._tagscache.tags): for t, n in self._tagscache.tags.items():
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 pycompat.iteritems(self._datafilters): for name, filterfn in self._datafilters.items():
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)
fn.__name__ = 'commandfilter' fn.__name__ = 'commandfilter'
# Wrap old filters not supporting keyword arguments # Wrap old filters not supporting keyword arguments

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 pycompat.iteritems(self.repo.names): for nsname, ns in self.repo.names.items():
# 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 wopts.exclude_pats: for p in wopts.exclude_pats:
matchargs.append(b'x:' + p) matchargs.append(b'x:' + p)
opts[b'_matchfiles'] = matchargs opts[b'_matchfiles'] = matchargs
elif wopts.filter_revisions_by_pats and not wopts.follow: elif wopts.filter_revisions_by_pats and not wopts.follow:
opts[b'_patslog'] = list(wopts.pats) opts[b'_patslog'] = list(wopts.pats)
expr = [] expr = []
for op, val in sorted(pycompat.iteritems(opts)): for op, val in sorted(opts.items()):
if not val: if not val:
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:
expr.append(revsetlang.formatspec(revop, val)) expr.append(revsetlang.formatspec(revop, val))
else: else:

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 .node import hex from .node import hex
from . import ( from . import (
pycompat,
util, util,
vfs as vfsmod, vfs as vfsmod,
) )
from .utils import ( from .utils import (
urlutil, urlutil,
) )
# directory name in .hg/ in which remotenames files will be present # directory name in .hg/ in which remotenames files will be present
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(pycompat.iteritems(names)): for name, node in sorted(names.items()):
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 pycompat.iteritems(branchmap): for branch, nodes in branchmap.items():
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

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(pycompat.iteritems(sys.modules)): for k, v in list(sys.modules.items()):
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:
mname = _fn2mod[code.co_filename] = '<%s>' % code.co_filename mname = _fn2mod[code.co_filename] = '<%s>' % code.co_filename
res = '%s:%d(%s)' % (mname, code.co_firstlineno, code.co_name) res = '%s:%d(%s)' % (mname, code.co_firstlineno, code.co_name)
if sys.version_info.major >= 3: if sys.version_info.major >= 3:
res = res.encode('latin-1') res = res.encode('latin-1')
return res return res

mercurial/manifest.py

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 pycompat.iteritems(t1._lazydirs): for d, v1 in t1._lazydirs.items():
v2 = t2._lazydirs.get(d) v2 = t2._lazydirs.get(d)
if not v2 or v2[0] != v1[0]: if not v2 or v2[0] != v1[0]:
toloadlazy.append(d) toloadlazy.append(d)
for d, v1 in pycompat.iteritems(t2._lazydirs): for d, v1 in t2._lazydirs.items():
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 pycompat.iteritems(n): for f, sn in n.items():
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 = treemanifest(self.nodeconstants, self._dir) copy = treemanifest(self.nodeconstants, self._dir)
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: (n, r, True) d: (n, r, True) for d, (n, r, c) in self._lazydirs.items()
for d, (n, r, c) in pycompat.iteritems(self._lazydirs)
} }
sdirs = s._dirs sdirs = s._dirs
for d, v in pycompat.iteritems(self._dirs): for d, v in self._dirs.items():
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 pycompat.iteritems(t1._dirs): for d, m1 in t1._dirs.items():
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 pycompat.iteritems(self._dirs): for dir, subm in self._dirs.items():
if visit and dir[:-1] not in visit: if visit and dir[:-1] not in visit:
continue continue
m = subm._matches_inner(match) m = subm._matches_inner(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 pycompat.iteritems(t1._dirs): for d, m1 in t1._dirs.items():
m2 = t2._dirs.get(d, emptytree) m2 = t2._dirs.get(d, emptytree)
stack.append((m1, m2)) stack.append((m1, m2))
for d, m2 in pycompat.iteritems(t2._dirs): for d, m2 in t2._dirs.items():
if d not in t1._dirs: if d not in t1._dirs:
stack.append((emptytree, m2)) stack.append((emptytree, m2))
for fn, n1 in pycompat.iteritems(t1._files): for fn, n1 in t1._files.items():
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 pycompat.iteritems(t2._files): for fn, n2 in t2._files.items():
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 = [ lazydirs = [(d[:-1], v[0], b't') for d, v in self._lazydirs.items()]
(d[:-1], v[0], 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[0] return ld[0]
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 pycompat.iteritems(self._dirs): for d, subm in self._dirs.items():
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 == self.nodeconstants.nullid: if subp1 == self.nodeconstants.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 pycompat.iteritems(self._dirs): for d, subm in self._dirs.items():
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:

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 pycompat.iteritems(syntaxes): for s, rels in syntaxes.items():
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

if actions is None: if actions is None:
return len(self._filemapping) return len(self._filemapping)
return sum(len(self._actionmapping[a]) for a in actions) return sum(len(self._actionmapping[a]) for a in actions)
def filemap(self, sort=False): def filemap(self, sort=False):
if sorted: if sorted:
for key, val in sorted(pycompat.iteritems(self._filemapping)): for key, val in sorted(self._filemapping.items()):
yield key, val yield key, val
else: else:
for key, val in pycompat.iteritems(self._filemapping): for key, val in self._filemapping.items():
yield key, val yield key, val
def addcommitinfo(self, filename, key, value): def addcommitinfo(self, filename, key, value):
"""adds key-value information about filename which will be required """adds key-value information about filename which will be required
while committing this merge""" while committing this merge"""
self._commitinfo[filename][key] = value self._commitinfo[filename][key] = value
@property @property
def diverge(self): def diverge(self):
return self._diverge return self._diverge
@property @property
def renamedelete(self): def renamedelete(self):
return self._renamedelete return self._renamedelete
@property @property
def commitinfo(self): def commitinfo(self):
return self._commitinfo return self._commitinfo
@property @property
def actionsdict(self): def actionsdict(self):
"""returns a dictionary of actions to be perfomed with action as key """returns a dictionary of actions to be perfomed with action as key
and a list of files and related arguments as values""" and a list of files and related arguments as values"""
res = collections.defaultdict(list) res = collections.defaultdict(list)
for a, d in pycompat.iteritems(self._actionmapping): for a, d in self._actionmapping.items():
for f, (args, msg) in pycompat.iteritems(d): for f, (args, msg) in d.items():
res[a].append((f, args, msg)) res[a].append((f, args, msg))
return res return res
def setactions(self, actions): def setactions(self, actions):
self._filemapping = actions self._filemapping = actions
self._actionmapping = collections.defaultdict(dict) self._actionmapping = collections.defaultdict(dict)
for f, (act, data, msg) in pycompat.iteritems(self._filemapping): for f, (act, data, msg) in self._filemapping.items():
self._actionmapping[act][f] = data, msg self._actionmapping[act][f] = data, msg
def hasconflicts(self): def hasconflicts(self):
"""tells whether this merge resulted in some actions which can """tells whether this merge resulted in some actions which can
result in conflicts or not""" result in conflicts or not"""
for a in self._actionmapping.keys(): for a in self._actionmapping.keys():
if ( if (
a a
) )
): ):
# 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 pycompat.iteritems(branch_copies1.copy): for copykey, copyvalue in branch_copies1.copy.items():
if copyvalue in relevantfiles: if copyvalue in relevantfiles:
relevantfiles.add(copykey) relevantfiles.add(copykey)
for movedirkey in branch_copies1.movewithdir: for movedirkey in branch_copies1.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)
for f, ((n1, fl1), (n2, fl2)) in pycompat.iteritems(diff): for f, ((n1, fl1), (n2, fl2)) in diff.items():
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:
# TODO: what if they're renamed from different sources? # TODO: what if they're renamed from different sources?
fa = branch_copies1.copy.get( fa = branch_copies1.copy.get(
f, None f, None
) or branch_copies2.copy.get(f, None) ) or branch_copies2.copy.get(f, None)
args, msg = None, None args, msg = None, None
if fa is not None: if fa is not None:
""" """
_prefetchfiles(repo, mctx, mresult) _prefetchfiles(repo, mctx, mresult)
updated, merged, removed = 0, 0, 0 updated, merged, removed = 0, 0, 0
ms = wctx.mergestate(clean=True) ms = wctx.mergestate(clean=True)
ms.start(wctx.p1().node(), mctx.node(), labels) ms.start(wctx.p1().node(), mctx.node(), labels)
for f, op in pycompat.iteritems(mresult.commitinfo): for f, op in mresult.commitinfo.items():
# the other side of filenode was choosen while merging, store this in # the other side of filenode was choosen while merging, store this in
# mergestate so that it can be reused on commit # mergestate so that it can be reused on commit
ms.addcommitinfo(f, op) ms.addcommitinfo(f, op)
num_no_op = mresult.len(mergestatemod.MergeAction.NO_OP_ACTIONS) num_no_op = mresult.len(mergestatemod.MergeAction.NO_OP_ACTIONS)
numupdates = mresult.len() - num_no_op numupdates = mresult.len() - num_no_op
progress = repo.ui.makeprogress( progress = repo.ui.makeprogress(
_(b'updating'), unit=_(b'files'), total=numupdates _(b'updating'), unit=_(b'files'), total=numupdates
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(), mresult) _checkcollision(repo, wc.manifest(), mresult)
# divergent renames # divergent renames
for f, fl in sorted(pycompat.iteritems(mresult.diverge)): for f, fl in sorted(mresult.diverge.items()):
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(pycompat.iteritems(mresult.renamedelete)): for f, fl in sorted(mresult.renamedelete.items()):
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):
p2, p2,
overwrite, overwrite,
wantfiledata, wantfiledata,
labels=labels, labels=labels,
) )
if updatedirstate: if updatedirstate:
if extraactions: if extraactions:
for k, acts in pycompat.iteritems(extraactions): for k, acts in extraactions.items():
for a in acts: for a in acts:
mresult.addfile(a[0], k, *a[1:]) mresult.addfile(a[0], k, *a[1:])
if k == mergestatemod.ACTION_GET and wantfiledata: if k == mergestatemod.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
assert len(getfiledata) == ( assert len(getfiledata) == (
now = timestamp.get_fs_now(repo.vfs) now = timestamp.get_fs_now(repo.vfs)
if now is None: if now is None:
# we can't write to the FS, so we won't actually update # we can't write to the FS, so we won't actually update
# the dirstate content anyway, no need to put cache # the dirstate content anyway, no need to put cache
# information. # information.
getfiledata = None getfiledata = None
else: else:
now_sec = now[0] now_sec = now[0]
for f, m in pycompat.iteritems(getfiledata): for f, m in getfiledata.items():
if m is not None and m[2][0] >= now_sec: if m is not None and m[2][0] >= now_sec:
ambiguous_mtime[f] = (m[0], m[1], None) ambiguous_mtime[f] = (m[0], m[1], None)
for f, m in pycompat.iteritems(ambiguous_mtime): for f, m in ambiguous_mtime.items():
getfiledata[f] = m getfiledata[f] = m
repo.setparents(fp1, fp2) repo.setparents(fp1, fp2)
mergestatemod.recordupdates( mergestatemod.recordupdates(
repo, mresult.actionsdict, branchmerge, getfiledata repo, mresult.actionsdict, branchmerge, getfiledata
) )
# update completed, clear state # update completed, clear state
util.unlink(repo.vfs.join(b'updatestate')) util.unlink(repo.vfs.join(b'updatestate'))

mercurial/mergestate.py

def mark(self, dfile, state): def mark(self, dfile, state):
self._state[dfile][0] = state self._state[dfile][0] = state
self._dirty = True self._dirty = True
def unresolved(self): def unresolved(self):
"""Obtain the paths of unresolved files.""" """Obtain the paths of unresolved files."""
for f, entry in pycompat.iteritems(self._state): for f, entry in self._state.items():
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 allextras(self): def allextras(self):
"""return all extras information stored with the mergestate""" """return all extras information stored with the mergestate"""
"""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 pycompat.iteritems(self._results): for f, (r, action) in self._results.items():
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
class mergestate(_mergestate_base): class mergestate(_mergestate_base):
statepathv1 = b'merge/state' statepathv1 = b'merge/state'
records = [] records = []
records.append((RECORD_LOCAL, hex(self._local))) records.append((RECORD_LOCAL, hex(self._local)))
records.append((RECORD_OTHER, hex(self._other))) records.append((RECORD_OTHER, hex(self._other)))
# 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 pycompat.iteritems(self._state): for filename, v in self._state.items():
if v[0] in ( if v[0] in (
MERGE_RECORD_UNRESOLVED_PATH, MERGE_RECORD_UNRESOLVED_PATH,
MERGE_RECORD_RESOLVED_PATH, MERGE_RECORD_RESOLVED_PATH,
): ):
# Path conflicts. These are stored in 'P' records. The current # Path conflicts. These are stored in 'P' records. The current
# resolution state ('pu' or 'pr') is stored within the record. # resolution state ('pu' or 'pr') is stored within the record.
records.append( records.append(
(RECORD_PATH_CONFLICT, b'\0'.join([filename] + v)) (RECORD_PATH_CONFLICT, b'\0'.join([filename] + v))
) )
elif ( elif (
v[1] == self._repo.nodeconstants.nullhex v[1] == self._repo.nodeconstants.nullhex
or v[6] == self._repo.nodeconstants.nullhex or v[6] == self._repo.nodeconstants.nullhex
): ):
# Change/Delete or Delete/Change conflicts. These are stored in # Change/Delete or Delete/Change conflicts. These are stored in
# 'C' records. v[1] is the local file, and is nullhex when the # 'C' records. v[1] is the local file, and is nullhex when the
# 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(pycompat.iteritems(self._stateextras)): for filename, extras in sorted(self._stateextras.items()):
rawextras = b'\0'.join( rawextras = b'\0'.join(
b'%s\0%s' % (k, v) for k, v in pycompat.iteritems(extras) b'%s\0%s' % (k, v) for k, v in extras.items()
) )
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

mercurial/namespaces.py

from .i18n import _ from .i18n import _
from . import ( from . import (
pycompat,
registrar, registrar,
templatekw, templatekw,
util, util,
) )
def tolist(val): def tolist(val):
""" """
def __iter__(self): def __iter__(self):
return self._names.__iter__() return self._names.__iter__()
def get(self, namespace, default=None): def get(self, namespace, default=None):
return self._names.get(namespace, default) return self._names.get(namespace, default)
def items(self): def items(self):
return pycompat.iteritems(self._names) return self._names.items()
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 pycompat.iteritems(self._names): for ns, v in self._names.items():
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(pycompat.iteritems(metadata))) metadata = tuple(sorted(metadata.items()))
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 pycompat.iteritems(meta): for key, value in meta.items():
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(
'in-marker cycle with %s' % pycompat.sysstr(hex(prec)) 'in-marker cycle with %s' % pycompat.sysstr(hex(prec))
) )
metadata = tuple(sorted(pycompat.iteritems(metadata))) metadata = tuple(sorted(metadata.items()))
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

hex, hex,
short, short,
) )
from . import ( from . import (
diffutil, diffutil,
encoding, encoding,
error, error,
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 pycompat.iteritems(base) for divset, b in base.items()
] ]
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

if copy is None: if copy is None:
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.items() 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
# modifications during merges # modifications during merges

mercurial/pathutil.py

def __init__(self, map, only_tracked=False): def __init__(self, map, only_tracked=False):
""" """
a dict map indicates a dirstate while a list indicates a manifest a dict map indicates a dirstate while a list indicates a manifest
""" """
self._dirs = {} self._dirs = {}
addpath = self.addpath addpath = self.addpath
if isinstance(map, dict) and only_tracked: if isinstance(map, dict) and only_tracked:
for f, s in pycompat.iteritems(map): for f, s in map.items():
if s.state != b'r': if s.state != b'r':
addpath(f) addpath(f)
elif only_tracked: elif only_tracked:
msg = b"`only_tracked` is only supported with a dict source" msg = b"`only_tracked` is only supported with a dict source"
raise error.ProgrammingError(msg) raise error.ProgrammingError(msg)
else: else:
for f in map: for f in map:
addpath(f) addpath(f)

mercurial/phases.py

def binaryencode(phasemapping): def binaryencode(phasemapping):
# type: (Dict[int, List[bytes]]) -> bytes # type: (Dict[int, List[bytes]]) -> bytes
"""encode a 'phase -> nodes' mapping into a binary stream """encode a 'phase -> nodes' mapping into a binary stream
The revision lists are encoded as (phase, root) pairs. The revision lists are encoded as (phase, root) pairs.
""" """
binarydata = [] binarydata = []
for phase, nodes in pycompat.iteritems(phasemapping): for phase, nodes in phasemapping.items():
for head in nodes: for head in nodes:
binarydata.append(_fphasesentry.pack(phase, head)) binarydata.append(_fphasesentry.pack(phase, head))
return b''.join(binarydata) return b''.join(binarydata)
def binarydecode(stream): def binarydecode(stream):
# type: (...) -> Dict[int, List[bytes]] # type: (...) -> Dict[int, List[bytes]]
"""decode a binary stream into a 'phase -> nodes' mapping """decode a binary stream into a 'phase -> nodes' mapping
# type: (localrepo.localrepository) -> bool # type: (localrepo.localrepository) -> bool
"""detect if there are revisions with non-public phase""" """detect if there are revisions with non-public phase"""
repo = repo.unfiltered() repo = repo.unfiltered()
cl = repo.changelog cl = repo.changelog
if len(cl) >= self._loadedrevslen: if len(cl) >= self._loadedrevslen:
self.invalidate() self.invalidate()
self.loadphaserevs(repo) self.loadphaserevs(repo)
return any( return any(
revs revs for phase, revs in self.phaseroots.items() if phase != public
for phase, revs in pycompat.iteritems(self.phaseroots)
if phase != public
) )
def nonpublicphaseroots(self, repo): def nonpublicphaseroots(self, repo):
# type: (localrepo.localrepository) -> Set[bytes] # type: (localrepo.localrepository) -> Set[bytes]
"""returns the roots of all non-public phases """returns the roots of all non-public phases
The roots are not minimized, so if the secret revisions are The roots are not minimized, so if the secret revisions are
descendants of draft revisions, their roots will still be present. descendants of draft revisions, their roots will still be present.
""" """
repo = repo.unfiltered() repo = repo.unfiltered()
cl = repo.changelog cl = repo.changelog
if len(cl) >= self._loadedrevslen: if len(cl) >= self._loadedrevslen:
self.invalidate() self.invalidate()
self.loadphaserevs(repo) self.loadphaserevs(repo)
return set().union( return set().union(
*[ *[
revs revs
for phase, revs in pycompat.iteritems(self.phaseroots) for phase, revs in self.phaseroots.items()
if phase != public if phase != public
] ]
) )
def getrevset(self, repo, phases, subset=None): def getrevset(self, repo, phases, subset=None):
# type: (localrepo.localrepository, Iterable[int], Optional[Any]) -> Any # type: (localrepo.localrepository, Iterable[int], Optional[Any]) -> Any
# TODO: finish typing this # TODO: finish typing this
"""return a smartset for the given phases""" """return a smartset for the given phases"""
return return
f = self.opener(b'phaseroots', b'w', atomictemp=True, checkambig=True) f = self.opener(b'phaseroots', b'w', atomictemp=True, checkambig=True)
try: try:
self._write(f) self._write(f)
finally: finally:
f.close() f.close()
def _write(self, fp): def _write(self, fp):
for phase, roots in pycompat.iteritems(self.phaseroots): for phase, roots in self.phaseroots.items():
for h in sorted(roots): for h in sorted(roots):
fp.write(b'%i %s\n' % (phase, hex(h))) fp.write(b'%i %s\n' % (phase, hex(h)))
self.dirty = False self.dirty = False
def _updateroots(self, phase, newroots, tr): def _updateroots(self, phase, newroots, tr):
self.phaseroots[phase] = newroots self.phaseroots[phase] = newroots
self.invalidate() self.invalidate()
self.dirty = True self.dirty = True
if targetphase != 0: if targetphase != 0:
self._retractboundary(repo, tr, targetphase, delroots) self._retractboundary(repo, tr, targetphase, delroots)
repo.invalidatevolatilesets() repo.invalidatevolatilesets()
return changes return changes
def retractboundary(self, repo, tr, targetphase, nodes): def retractboundary(self, repo, tr, targetphase, nodes):
oldroots = { oldroots = {
phase: revs phase: revs
for phase, revs in pycompat.iteritems(self.phaseroots) for phase, revs in self.phaseroots.items()
if phase <= targetphase if phase <= targetphase
} }
if tr is None: if tr is None:
phasetracking = None phasetracking = None
else: else:
phasetracking = tr.changes.get(b'phases') phasetracking = tr.changes.get(b'phases')
repo = repo.unfiltered() repo = repo.unfiltered()
if ( if (
def filterunknown(self, repo): def filterunknown(self, repo):
# type: (localrepo.localrepository) -> None # type: (localrepo.localrepository) -> None
"""remove unknown nodes from the phase boundary """remove unknown nodes from the phase boundary
Nothing is lost as unknown nodes only hold data for their descendants. Nothing is lost as unknown nodes only hold data for their descendants.
""" """
filtered = False filtered = False
has_node = repo.changelog.index.has_node # to filter unknown nodes has_node = repo.changelog.index.has_node # to filter unknown nodes
for phase, nodes in pycompat.iteritems(self.phaseroots): for phase, nodes in self.phaseroots.items():
missing = sorted(node for node in nodes if not has_node(node)) missing = sorted(node for node in nodes if not has_node(node))
if missing: if missing:
for mnode in missing: for mnode in missing:
repo.ui.debug( repo.ui.debug(
b'removing unknown node %s from %i-phase boundary\n' b'removing unknown node %s from %i-phase boundary\n'
% (short(mnode), phase) % (short(mnode), phase)
) )
nodes.symmetric_difference_update(missing) nodes.symmetric_difference_update(missing)
* 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 = []
has_node = repo.changelog.index.has_node # to filter unknown nodes has_node = repo.changelog.index.has_node # to filter unknown nodes
for nhex, phase in pycompat.iteritems(roots): for nhex, phase in roots.items():
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 != repo.nullid: if node != repo.nullid:
repo.ui.warn( repo.ui.warn(
_( _(

mercurial/pure/parsers.py

from ..node import ( from ..node import (
nullrev, nullrev,
sha1nodeconstants, sha1nodeconstants,
) )
from ..thirdparty import attr from ..thirdparty import attr
from .. import ( from .. import (
error, error,
pycompat,
revlogutils, revlogutils,
util, util,
) )
from ..revlogutils import nodemap as nodemaputil from ..revlogutils import nodemap as nodemaputil
from ..revlogutils import constants as revlog_constants from ..revlogutils import constants as revlog_constants
stringio = io.BytesIO stringio = io.BytesIO
dmap[f] = DirstateItem.from_v1_data(*e[:4]) dmap[f] = DirstateItem.from_v1_data(*e[:4])
return parents return parents
def pack_dirstate(dmap, copymap, pl): def pack_dirstate(dmap, copymap, pl):
cs = stringio() cs = stringio()
write = cs.write write = cs.write
write(b"".join(pl)) write(b"".join(pl))
for f, e in pycompat.iteritems(dmap): for f, e in dmap.items():
if f in copymap: if f in copymap:
f = b"%s\0%s" % (f, copymap[f]) f = b"%s\0%s" % (f, copymap[f])
e = _pack( e = _pack(
b">cllll", b">cllll",
e.v1_state(), e.v1_state(),
e.v1_mode(), e.v1_mode(),
e.v1_size(), e.v1_size(),
e.v1_mtime(), e.v1_mtime(),
len(f), len(f),
) )
write(e) write(e)
write(f) write(f)
return cs.getvalue() return cs.getvalue()

mercurial/revlog.py

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 pycompat.iteritems(heads) if flag] heads = [head for head, flag in heads.items() 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 pycompat.iteritems(repo._bookmarks): for name, bmrev in repo._bookmarks.items():
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 -= {nullrev} bms -= {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 pycompat.iteritems(repo.names): for name, ns in repo.names.items():
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))
subset = fullreposet(repo) subset = fullreposet(repo)
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 pycompat.iteritems(registrarobj._table): for name, func in registrarobj._table.items():
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(pycompat.iteritems(aliases)): for name, alias in sorted(aliases.items()):
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(pycompat.iteritems(subpaths)): for subpath, ctx in sorted(subpaths.items()):
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 pycompat.iteritems(walkresults): for abs, st in walkresults.items():
entry = dirstate.get_entry(abs) entry = dirstate.get_entry(abs)
if (not entry.any_tracked) and audit_path.check(abs): if (not entry.any_tracked) and audit_path.check(abs):
unknown.append(abs) unknown.append(abs)
elif (not entry.removed) and not st: elif (not entry.removed) and not st:
deleted.append(abs) deleted.append(abs)
elif entry.removed and st: elif entry.removed 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 pycompat.iteritems(renames): for new, old in renames.items():
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.update_file_p1(f, p1_tracked=False) ds.update_file_p1(f, p1_tracked=False)
for f in s.removed: for f in s.removed:
ds.update_file_p1(f, p1_tracked=True) ds.update_file_p1(f, p1_tracked=True)
# 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 = { copies = {dst: oldcopies.get(src, src) for dst, src in oldcopies.items()}
dst: oldcopies.get(src, src)
for dst, src in pycompat.iteritems(oldcopies)
}
# Adjust the dirstate copies # Adjust the dirstate copies
for dst, src in pycompat.iteritems(copies): for dst, src in copies.items():
if src not in newctx or dst in newctx or not ds.get_entry(dst).added: if src not in newctx or dst in newctx or not ds.get_entry(dst).added:
src = None src = None
ds.copy(src, dst) ds.copy(src, dst)
repo._quick_access_changeid_invalidate() repo._quick_access_changeid_invalidate()
def filterrequirements(requirements): def filterrequirements(requirements):
"""filters the requirements into two sets: """filters the requirements into two sets:

mercurial/similar.py

# similar.py - mechanisms for finding similar files # similar.py - mechanisms for finding similar files
# #
# Copyright 2005-2007 Olivia Mackall <olivia@selenic.com> # Copyright 2005-2007 Olivia Mackall <olivia@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 .i18n import _ from .i18n import _
from . import ( from . import (
mdiff, 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 pycompat.iteritems(copies): for dest, v in copies.items():
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

_( _(
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 pycompat.iteritems(dirstate): for file, state in dirstate.items():
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)
mergemod.applyupdates( mergemod.applyupdates(
repo, mresult, repo[None], repo[b'.'], False, wantfiledata=False repo, mresult, repo[None], repo[b'.'], False, wantfiledata=False

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(pycompat.iteritems(wireargs)): for k, v in sorted(wireargs.items()):
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 pycompat.iteritems(v): for dk, dv in v.items():
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 pycompat.iteritems(grouped): for fname, sitestats in grouped.items():
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 pycompat.iteritems(parents)] parents = [(parent, count) for parent, count in parents.items()]
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 pycompat.iteritems(children)] children = [(child, count) for child, count in children.items()]
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 pycompat.iteritems(lines): for line, count in lines.items():
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 = {x: x for x in asciistr} cmap = {x: x for x in asciistr}
for x in _reserved(): for x in _reserved():
cmap[xchr(x)] = b"~%02x" % x cmap[xchr(x)] = b"~%02x" % x
for x in capitals + [ord(e)]: for x in capitals + [ord(e)]:
cmap[xchr(x)] = e + xchr(x).lower() cmap[xchr(x)] = e + xchr(x).lower()
dmap = {} dmap = {}
for k, v in pycompat.iteritems(cmap): for k, v in cmap.items():
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/strip.py

_(b"bookmark '%s' not found") _(b"bookmark '%s' not found")
% b','.join(sorted(bookmarks - set(repomarks.keys()))) % b','.join(sorted(bookmarks - set(repomarks.keys())))
) )
# If the requested bookmark is not the only one pointing to a # If the requested bookmark is not the only one pointing to a
# a revision we have to only delete the bookmark and not strip # a revision we have to only delete the bookmark and not strip
# anything. revsets cannot detect that case. # anything. revsets cannot detect that case.
nodetobookmarks = {} nodetobookmarks = {}
for mark, node in pycompat.iteritems(repomarks): for mark, node in repomarks.items():
nodetobookmarks.setdefault(node, []).append(mark) nodetobookmarks.setdefault(node, []).append(mark)
for marks in nodetobookmarks.values(): for marks in nodetobookmarks.values():
if bookmarks.issuperset(marks): if bookmarks.issuperset(marks):
rsrevs = scmutil.bookmarkrevs(repo, marks[0]) rsrevs = scmutil.bookmarkrevs(repo, marks[0])
revs.update(set(rsrevs)) revs.update(set(rsrevs))
if not revs: if not revs:
with repo.lock(), repo.transaction(b'bookmark') as tr: with repo.lock(), repo.transaction(b'bookmark') as tr:
bmchanges = [(b, None) for b in bookmarks] bmchanges = [(b, None) for b in bookmarks]

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 pycompat.iteritems(branch2rev): for b, revision in branch2rev.items():
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

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(pycompat.iteritems(s1)): for s, l in sorted(s1.items()):
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 pycompat.iteritems(filetags): for name, nodehist in filetags.items():
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
if flog.hasnode(fnode): if flog.hasnode(fnode):
validated_fnodes.add(fnode) validated_fnodes.add(fnode)
else: else:
unknown_entries.add(node) unknown_entries.add(node)
cachefnode[node] = fnode cachefnode[node] = fnode
if unknown_entries: if unknown_entries:
fixed_nodemap = fnodescache.refresh_invalid_nodes(unknown_entries) fixed_nodemap = fnodescache.refresh_invalid_nodes(unknown_entries)
for node, fnode in pycompat.iteritems(fixed_nodemap): for node, fnode in fixed_nodemap.items():
if fnode != repo.nullid: if fnode != repo.nullid:
cachefnode[node] = fnode cachefnode[node] = fnode
fnodescache.write() fnodescache.write()
duration = util.timer() - starttime duration = util.timer() - starttime
ui.log( ui.log(
b'tagscache', b'tagscache',
) )
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(pycompat.iteritems(cachetags)): for (name, (node, hist)) in sorted(cachetags.items()):
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(pycompat.iteritems(obj)) for k, v in sorted(obj.items())
] ]
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)
if websubtable: if websubtable:
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 pycompat.iteritems(registrarobj._table): for name, func in registrarobj._table.items():
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 num >= len(tokens) or num < -len(tokens): if num >= len(tokens) or num < -len(tokens):
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 pycompat.iteritems(registrarobj._table): for name, func in registrarobj._table.items():
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 pycompat.iteritems(repo.names): for k, ns in repo.names.items():
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 {
d = {b'name': k} d = {b'name': k}
if len(ps) == 1: if len(ps) == 1:
d[b'url'] = ps[0].rawloc d[b'url'] = ps[0].rawloc
sub_opts = pycompat.iteritems(ps[0].suboptions) sub_opts = pycompat.iteritems(ps[0].suboptions)
sub_opts = util.sortdict(sorted(sub_opts)) sub_opts = util.sortdict(sorted(sub_opts))
d.update(sub_opts) d.update(sub_opts)
path_dict = util.sortdict() path_dict = util.sortdict()
for p in ps: for p in ps:
sub_opts = util.sortdict(sorted(pycompat.iteritems(p.suboptions))) sub_opts = util.sortdict(sorted(p.suboptions.items()))
path_dict[b'url'] = p.rawloc path_dict[b'url'] = p.rawloc
path_dict.update(sub_opts) path_dict.update(sub_opts)
d[b'urls'] = [path_dict] d[b'urls'] = [path_dict]
return d return d
def format_one(k): def format_one(k):
return b'%s=%s' % (k, urls[k]) return b'%s=%s' % (k, urls[k])
b'{instability}:{if(divergentnodes, " ")}{divergentnodes} ' b'{instability}:{if(divergentnodes, " ")}{divergentnodes} '
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 pycompat.iteritems(registrarobj._table): for name, func in registrarobj._table.items():
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)) (k, compileexp(x, context, curmethods)) for k, x in xs.items()
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 pycompat.iteritems(origmapping) for k, v in origmapping.items()
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 pycompat.iteritems(self._values) for k, v in self._values.items()
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.items()}
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:
- "{manifest}" - "{manifest}"
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 pycompat.iteritems(nm) for k, v in nm.items()
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 pycompat.iteritems(data)] c = [{key: k, value: v} for k, v in data.items()]
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

any = False any = False
if group == GEN_GROUP_ALL: if group == GEN_GROUP_ALL:
skip_post = skip_pre = False skip_post = skip_pre = False
else: else:
skip_pre = group == GEN_GROUP_POST_FINALIZE skip_pre = group == GEN_GROUP_POST_FINALIZE
skip_post = group == GEN_GROUP_PRE_FINALIZE skip_post = group == GEN_GROUP_PRE_FINALIZE
for id, entry in sorted(pycompat.iteritems(self._filegenerators)): for id, entry in sorted(self._filegenerators.items()):
any = True any = True
order, filenames, genfunc, location, post_finalize = entry order, filenames, genfunc, location, post_finalize = 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
if skip_post and post_finalize: if skip_post and post_finalize:
continue continue
elif skip_pre and not post_finalize: elif skip_pre and not post_finalize:
continue continue

mercurial/url.py

def _generic_proxytunnel(self): def _generic_proxytunnel(self):
proxyheaders = { proxyheaders = {
pycompat.bytestr(x): pycompat.bytestr(self.headers[x]) pycompat.bytestr(x): pycompat.bytestr(self.headers[x])
for x in self.headers for x in self.headers
if x.lower().startswith('proxy-') if x.lower().startswith('proxy-')
} }
self.send(b'CONNECT %s HTTP/1.0\r\n' % self.realhostport) self.send(b'CONNECT %s HTTP/1.0\r\n' % self.realhostport)
for header in pycompat.iteritems(proxyheaders): for header in proxyheaders.items():
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.
res = self.response_class(self.sock, method=self._method) res = self.response_class(self.sock, method=self._method)

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, **f): def update(self, src, **f):
if isinstance(src, dict): if isinstance(src, dict):
src = pycompat.iteritems(src) src = src.items()
for k, v in src: for k, v in src:
self[k] = v self[k] = v
for k in f: for k in f:
self[k] = f[k] self[k] = f[k]
def insert(self, position, key, value): def insert(self, position, key, value):
for (i, (k, v)) in enumerate(list(self.items())): for (i, (k, v)) in enumerate(list(self.items())):
if i == position: if i == position:

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.items(), 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):
"""Given an iterable of (key, value), encode to an indefinite length map.""" """Given an iterable of (key, value), encode to an indefinite length map."""

mercurial/utils/procutil.py

b'tempfile:': tempfilter, b'tempfile:': tempfilter,
b'pipe:': pipefilter, b'pipe:': pipefilter,
} }
def filter(s, cmd): def filter(s, cmd):
"""filter a string through a command that transforms its input to its """filter a string through a command that transforms its input to its
output""" output"""
for name, fn in pycompat.iteritems(_filtertable): for name, fn in _filtertable.items():
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)
_hgexecutable = None _hgexecutable = None
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 pycompat.iteritems(environ)) env.update((k, py2shell(v)) for k, v in environ.items())
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( # pytype: disable=module-attr return platform.shelltocmdexe( # pytype: disable=module-attr

mercurial/utils/urlutil.py

u.user = u.passwd = None u.user = u.passwd = None
return bytes(u) return bytes(u)
def list_paths(ui, target_path=None): def list_paths(ui, target_path=None):
"""list all the (name, paths) in the passed ui""" """list all the (name, paths) in the passed ui"""
result = [] result = []
if target_path is None: if target_path is None:
for name, paths in sorted(pycompat.iteritems(ui.paths)): for name, paths in sorted(ui.paths.items()):
for p in paths: for p in paths:
result.append((name, p)) result.append((name, p))
else: else:
for path in ui.paths.get(target_path, []): for path in ui.paths.get(target_path, []):
result.append((target_path, path)) result.append((target_path, path))
return result return result
b'location is not a URL or path to a local ' b'location is not a URL or path to a local '
b'repo: %s' % self.rawloc b'repo: %s' % self.rawloc
) )
def _apply_suboptions(self, ui, sub_options): def _apply_suboptions(self, ui, sub_options):
# 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 pycompat.iteritems(_pathsuboptions): for suboption, (attr, func) in _pathsuboptions.items():
if suboption not in sub_options: if suboption not in sub_options:
setattr(self, attr, None) setattr(self, attr, None)
continue continue
value = func(ui, self, sub_options[suboption]) value = func(ui, self, sub_options[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 pycompat.iteritems(_pathsuboptions): for subopt, (attr, _func) in _pathsuboptions.items():
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

mercurial/verify.py

storefiles.add(_normpath(f)) storefiles.add(_normpath(f))
subdirs.add(os.path.dirname(f)) subdirs.add(os.path.dirname(f))
for f in undecodable: for f in undecodable:
self._err(None, _(b"cannot decode filename '%s'") % f) self._err(None, _(b"cannot decode filename '%s'") % 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 pycompat.iteritems(subdirnodes): for subdir, linkrevs in subdirnodes.items():
subdirfilenodes = self._verifymanifest( subdirfilenodes = self._verifymanifest(
linkrevs, subdir, storefiles, subdirprogress linkrevs, subdir, storefiles, subdirprogress
) )
for f, onefilenodes in pycompat.iteritems(subdirfilenodes): for f, onefilenodes in subdirfilenodes.items():
filenodes.setdefault(f, {}).update(onefilenodes) filenodes.setdefault(f, {}).update(onefilenodes)
if not dir and subdirnodes: if not dir and subdirnodes:
assert subdirprogress is not None # help pytype assert subdirprogress is not None # help pytype
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)

mercurial/wireprotoframing.py

FRAME_TYPE_STREAM_SETTINGS: FLAGS_STREAM_ENCODING_SETTINGS, FRAME_TYPE_STREAM_SETTINGS: FLAGS_STREAM_ENCODING_SETTINGS,
} }
ARGUMENT_RECORD_HEADER = struct.Struct('<HH') ARGUMENT_RECORD_HEADER = struct.Struct('<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 pycompat.iteritems(mapping)} namemap = {v: k for k, v in mapping.items()}
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 pycompat.iteritems(FRAME_TYPES): for name, value in FRAME_TYPES.items():
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

cmds = [] cmds = []
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.items()
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(futures.Future): class unsentfuture(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 pycompat.iteritems(kwargs): for key, value in kwargs.items():
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 pycompat.iteritems(branchmap): for branch, nodes in branchmap.items():
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 pycompat.iteritems(opts): for k, v in opts.items():
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':