This is an archive of the discontinued Mercurial Phabricator instance.

Differential D7014

py3: define and use pycompat.iteritems() for hgext/
ClosedPublic

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

Details

Reviewers
durin42
martinvonz
Group Reviewers
hg-reviewers
Commits
rHG649d3ac37a12: py3: define and use pycompat.iteritems() for hgext/
Summary

.iteritems() -> .items() is the last source transform being performed.
But it is also the most widely used.

This commit adds a pycompat.iteritems symbol and imports it in place
of .iteritems() for usage in hgext/. I chose to stop at just hgext/
because the patch will be large and it is an easy boundary to stop at
since we can disable source transformation on a per-package basis.

There are places where the type does implement items() and we could
call items() directly. However, this would require critical thought
and I thought it would be easier to just blindly change the code. We
know which call sites need to be audited in the future because they
have "pycompat.iteritems."

With this change, we no longer perform source transformation on
hgext!

Diff Detail

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

Event Timeline

indygreg created this revision.Oct 7 2019, 4:05 PM
indygreg added a commit: rHG649d3ac37a12: py3: define and use pycompat.iteritems() for hgext/.Oct 8 2019, 2:17 PM
This revision was not accepted when it landed; it landed in state Needs Review.
Closed by commit rHG649d3ac37a12: py3: define and use pycompat.iteritems() for hgext/ (authored by indygreg). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mhgext/absorb.py (14 lines)
Mhgext/convert/bzr.py (8 lines)
Mhgext/convert/common.py (2 lines)
Mhgext/convert/convcmd.py (2 lines)
Mhgext/convert/cvs.py (3 lines)
Mhgext/convert/cvsps.py (2 lines)
Mhgext/convert/filemap.py (2 lines)
Mhgext/convert/hg.py (11 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 (6 lines)
Mhgext/githelp.py (4 lines)
Mhgext/hgk.py (4 lines)
Mhgext/histedit.py (8 lines)
Mhgext/infinitepush/__init__.py (18 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/largefiles/remotestore.py (5 lines)
Mhgext/lfs/__init__.py (2 lines)
Mhgext/lfs/pointer.py (4 lines)
Mhgext/lfs/wrapper.py (3 lines)
Mhgext/mq.py (4 lines)
Mhgext/rebase.py (12 lines)
Mhgext/releasenotes.py (2 lines)
Mhgext/remotefilelog/__init__.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 (10 lines)
Mhgext/remotenames.py (10 lines)
Mhgext/strip.py (2 lines)
Mhgext/uncommit.py (4 lines)
Mhgext/win32text.py (2 lines)
Mmercurial/__init__.py (7 lines)
Mmercurial/pycompat.py (2 lines)

Diff 16965

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 self.fixupmap.iteritems(): for path, state in pycompat.iteritems(self.fixupmap):
if self.ui.debugflag: if self.ui.debugflag:
self.ui.write(_(b'applying fixups to %s\n') % path) self.ui.write(_(b'applying fixups to %s\n') % path)
state.apply() state.apply()
@property @property
def chunkstats(self): def chunkstats(self):
"""-> {path: chunkstats}. collect chunkstats from filefixupstates""" """-> {path: chunkstats}. collect chunkstats from filefixupstates"""
return dict( return dict(
(path, state.chunkstats) (path, state.chunkstats)
for path, state in self.fixupmap.iteritems() 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 chunkstats.iteritems(): for path, stat in pycompat.iteritems(chunkstats):
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 repo._bookmarks.iteritems() for name, hsh in pycompat.iteritems(repo._bookmarks)
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(
if not pctx: if not pctx:
parents = ctx.parents() parents = ctx.parents()
if len(parents) != 1: if len(parents) != 1:
return False return False
pctx = parents[0] pctx = parents[0]
# 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 memworkingcopy.iteritems(): for path, content in pycompat.iteritems(memworkingcopy):
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 self.replacemap.iteritems() for k, v in pycompat.iteritems(self.replacemap)
} }
if replacements: if replacements:
scmutil.cleanupnodes( scmutil.cleanupnodes(
self.repo, replacements, operation=b'absorb', fixphase=True self.repo, replacements, operation=b'absorb', fixphase=True
) )
def _parsechunk(hunk): def _parsechunk(hunk):
# 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 patchmap.iteritems(): for path, patches in pycompat.iteritems(patchmap):
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

# bzr.py - bzr support for the convert extension # bzr.py - bzr support for the convert extension
# #
# Copyright 2008, 2009 Marek Kubica <marek@xivilization.net> and others # Copyright 2008, 2009 Marek Kubica <marek@xivilization.net> and others
# #
# 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.
# This module is for handling 'bzr', that was formerly known as Bazaar-NG; # This module is for handling 'bzr', that was formerly known as Bazaar-NG;
# it cannot access 'bar' repositories, but they were never used very much # it cannot access 'bar' repositories, but they were never used very much
from __future__ import absolute_import from __future__ import absolute_import
import os import os
from mercurial.i18n import _ from mercurial.i18n import _
from mercurial import demandimport, error from mercurial import (
demandimport,
error,
pycompat,
)
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(
[b'bzrlib.transactions', b'bzrlib.urlutils', b'ElementPath',] [b'bzrlib.transactions', b'bzrlib.urlutils', b'ElementPath',]
) )
try: try:
) )
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 tagdict.iteritems(): for name, rev in pycompat.iteritems(tagdict):
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 kwargs.iteritems(): for k, v in pycompat.iteritems(kwargs):
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

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.iteritems() for e in pycompat.iteritems(self.map)
if e[1] == tagsparent 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:

hgext/convert/cvs.py

from mercurial.i18n import _ from mercurial.i18n import _
from mercurial.pycompat import ( from mercurial.pycompat import (
getattr, getattr,
open, open,
) )
from mercurial import ( from mercurial import (
encoding, encoding,
error, error,
pycompat,
util, util,
) )
from mercurial.utils import ( from mercurial.utils import (
dateutil, dateutil,
procutil, procutil,
) )
from . import ( from . import (
self.readp.readline() self.readp.readline()
else: else:
raise error.Abort(_(b"unknown CVS response: %s") % line) raise error.Abort(_(b"unknown CVS response: %s") % line)
def getchanges(self, rev, full): def getchanges(self, rev, full):
if full: if full:
raise error.Abort(_(b"convert from cvs does not support --full")) raise error.Abort(_(b"convert from cvs does not support --full"))
self._parse() self._parse()
return sorted(self.files[rev].iteritems()), {}, set() return sorted(pycompat.iteritems(self.files[rev])), {}, set()
def getcommit(self, rev): def getcommit(self, rev):
self._parse() self._parse()
return self.changeset[rev] return self.changeset[rev]
def gettags(self): def gettags(self):
self._parse() self._parse()
return self.tags return self.tags
def getchangedfiles(self, rev, i): def getchangedfiles(self, rev, i):
self._parse() self._parse()
return sorted(self.files[rev]) return sorted(self.files[rev])

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 branchmap.iteritems(): for branch, revision in pycompat.iteritems(branchmap):
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 self.rename.iteritems(): for before, after in pycompat.iteritems(self.rename):
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

context, context,
error, error,
exchange, exchange,
hg, hg,
lock as lockmod, lock as lockmod,
merge as mergemod, merge as mergemod,
node as nodemod, node as nodemod,
phases, phases,
pycompat,
scmutil, scmutil,
util, util,
) )
from mercurial.utils import dateutil from mercurial.utils import dateutil
stringio = util.stringio stringio = util.stringio
from . import common from . import common
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(missings.iteritems()): for pbranch, heads in sorted(pycompat.iteritems(missings)):
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, [prepo.lookup(h) for h in heads] self.repo, prepo, [prepo.lookup(h) for h in heads]
) )
p2ctx, p2ctx,
anc, anc,
branchmerge=True, branchmerge=True,
force=True, force=True,
acceptremote=False, acceptremote=False,
followcopies=False, followcopies=False,
) )
for file, (action, info, msg) in actions.iteritems(): for file, (action, info, msg) in pycompat.iteritems(actions):
if source.targetfilebelongstosource(file): if source.targetfilebelongstosource(file):
# If the file belongs to the source repo, ignore the p2 # If the file belongs to the source repo, ignore the p2
# since it will be covered by the existing fileset. # since it will be covered by the existing fileset.
continue continue
# If the file requires actual merging, abort. We don't have enough # If the file requires actual merging, abort. We don't have enough
# context to resolve merges correctly. # context to resolve merges correctly.
if action in [b'm', b'dm', b'cd', b'dc']: if action in [b'm', b'dm', b'cd', b'dc']:
return parent return parent
return p2 return p2
def puttags(self, tags): def puttags(self, tags):
tagparent = self.repo.branchtip(self.tagsbranch, ignoremissing=True) tagparent = self.repo.branchtip(self.tagsbranch, ignoremissing=True)
tagparent = tagparent or nodemod.nullid tagparent = tagparent or nodemod.nullid
oldlines = set() oldlines = set()
for branch, heads in self.repo.branchmap().iteritems(): for branch, heads in pycompat.iteritems(self.repo.branchmap()):
for h in heads: for h in heads:
if b'.hgtags' in self.repo[h]: if b'.hgtags' in self.repo[h]:
oldlines.update( oldlines.update(
set(self.repo[h][b'.hgtags'].data().splitlines(True)) set(self.repo[h][b'.hgtags'].data().splitlines(True))
) )
oldlines = sorted(list(oldlines)) oldlines = sorted(list(oldlines))
newlines = sorted([(b"%s %s\n" % (tags[tag], tag)) for tag in tags]) newlines = sorted([(b"%s %s\n" % (tags[tag], tag)) for tag in tags])
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 d.iteritems(): for f, ((node1, flag1), (node2, flag2)) in pycompat.iteritems(d):
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 d.iteritems(): for f, value in pycompat.iteritems(d):
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[r'd'] = self.path kwargs[r'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 kwargs.iteritems(): for k, v in pycompat.iteritems(kwargs):
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 orig_paths.iteritems(): for k, v in pycompat.iteritems(orig_paths):
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 orig_paths.iteritems(): for k, v in pycompat.iteritems(orig_paths):
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 entries.iteritems() for n, e in pycompat.iteritems(entries)
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 = zip(files, [rev] * len(files)) files = zip(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 origpaths.iteritems() for p, e in pycompat.iteritems(origpaths)
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 = dict( addeds = dict(
(p, e.copyfrom_path) (p, e.copyfrom_path)
for p, e in origpaths.iteritems() for p, e in pycompat.iteritems(origpaths)
if e.action == b'A' and e.copyfrom_path if e.action == b'A' and e.copyfrom_path
) )
badroots = set() badroots = set()
for destroot in addeds: for destroot in addeds:
for source, sourcerev, dest in pendings: for source, sourcerev, dest in pendings:
if not dest.startswith( if not dest.startswith(
destroot + b'/' destroot + b'/'
) or source.startswith(addeds[destroot] + b'/'): ) or source.startswith(addeds[destroot] + b'/'):
# 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(orig_paths.iteritems()) orig_paths = sorted(pycompat.iteritems(orig_paths))
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 entries.iteritems() for p, e in pycompat.iteritems(entries)
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 filters.iteritems(): for name, fn in pycompat.iteritems(filters):
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 self.defaults.iteritems(): for k, v in pycompat.iteritems(self.defaults):
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 key2idxs.iteritems(): for (rev, _linenum), idxs in pycompat.iteritems(key2idxs):
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 key2idxs.iteritems(): for (rev, linenum), idxs in pycompat.iteritems(key2idxs):
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'
% (node.short(hsh), linenum, idxs) % (node.short(hsh), linenum, idxs)
) )

hgext/fastannotate/protocol.py

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 . import context from . import context
# common # common
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 r.iteritems()} r = {util.pconvert(p): v for p, v in pycompat.iteritems(r)}
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 = {prec: [succ] for prec, succ in replacements.iteritems()} replacements = {
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 the list of files to be fixed at specific revisions """"Constructs the list of files to be fixed at specific revisions
It is up to the caller how to consume the work items, and the only It is up to the caller how to consume the work items, and the only
dependence between them is that replacement revisions must be committed in dependence between them is that replacement revisions must be committed in
(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 fixers.iteritems(): for fixername, fixer in pycompat.iteritems(fixers):
if fixer.affects(opts, fixctx, path): if fixer.affects(opts, fixctx, path):
ranges = lineranges(opts, path, basectxs, fixctx, newdata) ranges = lineranges(opts, path, 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,))
proc = subprocess.Popen( proc = subprocess.Popen(
procutil.tonativestr(command), procutil.tonativestr(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 filedata.iteritems(): for path, data in pycompat.iteritems(filedata):
fctx = ctx[path] fctx = ctx[path]
fctx.write(data, fctx.flags()) fctx.write(data, fctx.flags())
if repo.dirstate[path] == b'n': if repo.dirstate[path] == b'n':
repo.dirstate.normallookup(path) repo.dirstate.normallookup(path)
oldparentnodes = repo.dirstate.parents() oldparentnodes = repo.dirstate.parents()
newparentnodes = [replacements.get(n, n) for n in oldparentnodes] newparentnodes = [replacements.get(n, n) for n in oldparentnodes]
if newparentnodes != oldparentnodes: if newparentnodes != oldparentnodes:

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(f for f, st in dmap.iteritems() if f not in results) visit.update(
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.iteritems() for f, st in pycompat.iteritems(dmap)
if f not in results and matchfn(f) 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)

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, str) else (k, v) (k, convert(v)) if isinstance(v, str) else (k, v)
for k, v in opts.iteritems() for k, v in pycompat.iteritems(opts)
] ]
) )
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(self.opts.iteritems()): for k, values in sorted(pycompat.iteritems(self.opts)):
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):
b"start interactive history viewer" b"start interactive history viewer"
opts = pycompat.byteskwargs(opts) opts = pycompat.byteskwargs(opts)
os.chdir(repo.root) os.chdir(repo.root)
optstr = b' '.join([b'--%s %s' % (k, v) for k, v in opts.iteritems() if v]) optstr = b' '.join(
[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"""
hg.updaterepo(repo, state.parentctxnode, overwrite=False) hg.updaterepo(repo, state.parentctxnode, overwrite=False)
mapping, tmpnodes, created, ntm = processreplacement(state) mapping, tmpnodes, created, ntm = processreplacement(state)
if mapping: if mapping:
for prec, succs in mapping.iteritems(): for prec, succs in pycompat.iteritems(mapping):
if not succs: if not succs:
ui.debug(b'histedit: %s is dropped\n' % node.short(prec)) ui.debug(b'histedit: %s is dropped\n' % node.short(prec))
else: else:
ui.debug( ui.debug(
b'histedit: %s is replaced by %s\n' b'histedit: %s is replaced by %s\n'
% (node.short(prec), node.short(succs[0])) % (node.short(prec), node.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 mapping.iteritems() for oldn, newn in pycompat.iteritems(mapping)
}, },
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(newact.iteritems())): for na, l in reversed(list(pycompat.iteritems(newact))):
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 newact.iteritems(): for na, l in pycompat.iteritems(newact):
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

def _checkheads(orig, pushop): def _checkheads(orig, pushop):
if pushop.ui.configbool(experimental, configscratchpush, False): if pushop.ui.configbool(experimental, configscratchpush, False):
return return
return orig(pushop) return orig(pushop)
def wireprotolistkeyspatterns(repo, proto, namespace, patterns): def wireprotolistkeyspatterns(repo, proto, namespace, patterns):
patterns = wireprototypes.decodelist(patterns) patterns = wireprototypes.decodelist(patterns)
d = repo.listkeys(encoding.tolocal(namespace), patterns).iteritems() d = pycompat.iteritems(repo.listkeys(encoding.tolocal(namespace), patterns))
return pushkey.encodekeys(d) return pushkey.encodekeys(d)
def localrepolistkeys(orig, self, namespace, patterns=None): def localrepolistkeys(orig, self, namespace, patterns=None):
if namespace == b'bookmarks' and patterns: if namespace == b'bookmarks' and patterns:
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 bookmarks.iteritems(): for bookmark, node in pycompat.iteritems(bookmarks):
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 part.params.iteritems(): for key, value in pycompat.iteritems(part.params):
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 newbookmarks.iteritems(): for bookmark, hexnode in pycompat.iteritems(newbookmarks):
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 bookmarks.iteritems(): for scratchbook, node in pycompat.iteritems(bookmarks):
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 part.params.iteritems(): for key, value in pycompat.iteritems(part.params):
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 part.params.iteritems(): for key, value in pycompat.iteritems(part.params):
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(b'pushkey', mandatoryparams=params.iteritems()) op.reply.newpart(
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 __future__ import absolute_import from __future__ import absolute_import
from mercurial.i18n import _ from mercurial.i18n import _
from mercurial import ( from mercurial import (
bundle2, bundle2,
changegroup, changegroup,
error, error,
extensions, extensions,
node as nodemod, node as nodemod,
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=params.iteritems(), advisoryparams=pycompat.iteritems(params),
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.
from __future__ import absolute_import from __future__ import absolute_import
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 bookmarks.iteritems(): for bookmark, node in pycompat.iteritems(bookmarks):
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, b'journal'): if util.safehasattr(repo, b'journal'):
oldmarks = bookmarks.bmstore(repo) oldmarks = bookmarks.bmstore(repo)
for mark, value in store.iteritems(): for mark, value in pycompat.iteritems(store):
oldvalue = oldmarks.get(mark, node.nullid) oldvalue = oldmarks.get(mark, node.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(r'default'): elif opts.get(r'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 kwmaps.iteritems(): for k, v in pycompat.iteritems(kwmaps):
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', kwmaps.iteritems()) demoitems(b'keywordmaps', pycompat.iteritems(kwmaps))
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 True, 0, False return True, 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 copies.iteritems(): for k, v in pycompat.iteritems(copies):
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/largefiles/remotestore.py

# Copyright 2010-2011 Fog Creek Software # Copyright 2010-2011 Fog Creek Software
# Copyright 2010-2011 Unity Technologies # Copyright 2010-2011 Unity Technologies
# #
# 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.
'''remote largefile store; the base class for wirestore''' '''remote largefile store; the base class for wirestore'''
from __future__ import absolute_import from __future__ import absolute_import
from mercurial.i18n import _ from mercurial.i18n import _
from mercurial import ( from mercurial import (
error, error,
pycompat,
util, util,
) )
from mercurial.utils import stringutil from mercurial.utils import stringutil
from . import ( from . import (
basestore, basestore,
lfutil, lfutil,
self.ui.debug( self.ui.debug(
_(b'remotestore: put %s to remote store %s\n') _(b'remotestore: put %s to remote store %s\n')
% (source, util.hidepassword(self.url)) % (source, util.hidepassword(self.url))
) )
def exists(self, hashes): def exists(self, hashes):
return dict( return dict(
(h, s == 0) (h, s == 0)
for (h, s) in self._stat(hashes).iteritems() # dict-from-generator for (h, s) in pycompat.iteritems(
self._stat(hashes)
) # dict-from-generator
) )
def sendfile(self, filename, hash): def sendfile(self, filename, hash):
self.ui.debug(b'remotestore: sendfile(%s, %s)\n' % (filename, hash)) self.ui.debug(b'remotestore: sendfile(%s, %s)\n' % (filename, hash))
try: try:
with lfutil.httpsendfile(self.ui, filename) as fd: with lfutil.httpsendfile(self.ui, filename) as fd:
return self._put(hash, fd) return self._put(hash, fd)
except IOError as e: except IOError as e:

hgext/lfs/__init__.py

ctx = context.resource(mapping, b'ctx') ctx = context.resource(mapping, b'ctx')
pointers = wrapper.pointersfromctx(ctx, removed=True) # {path: pointer} pointers = wrapper.pointersfromctx(ctx, removed=True) # {path: pointer}
files = sorted(pointers.keys()) files = sorted(pointers.keys())
def pointer(v): def pointer(v):
# In the file spec, version is first and the other keys are sorted. # In the file spec, version is first and the other keys are sorted.
sortkeyfunc = lambda x: (x[0] != b'version', x) sortkeyfunc = lambda x: (x[0] != b'version', x)
items = sorted(pointers[v].iteritems(), key=sortkeyfunc) items = sorted(pycompat.iteritems(pointers[v]), key=sortkeyfunc)
return util.sortdict(items) return util.sortdict(items)
makemap = lambda v: { makemap = lambda v: {
b'file': v, b'file': v,
b'lfsoid': pointers[v].oid() if pointers[v] else None, b'lfsoid': pointers[v].oid() if pointers[v] else None,
b'lfspointer': templateutil.hybriddict(pointer(v)), b'lfspointer': templateutil.hybriddict(pointer(v)),
} }

hgext/lfs/pointer.py

return cls(l.split(b' ', 1) for l in text.splitlines()).validate() return cls(l.split(b' ', 1) for l in text.splitlines()).validate()
except ValueError: # l.split returns 1 item instead of 2 except ValueError: # l.split returns 1 item instead of 2
raise InvalidPointer( raise InvalidPointer(
_(b'cannot parse git-lfs text: %s') % stringutil.pprint(text) _(b'cannot parse git-lfs text: %s') % stringutil.pprint(text)
) )
def serialize(self): def serialize(self):
sortkeyfunc = lambda x: (x[0] != b'version', x) sortkeyfunc = lambda x: (x[0] != b'version', x)
items = sorted(self.validate().iteritems(), key=sortkeyfunc) items = sorted(pycompat.iteritems(self.validate()), key=sortkeyfunc)
return b''.join(b'%s %s\n' % (k, v) for k, v in items) return b''.join(b'%s %s\n' % (k, v) for k, v in items)
def oid(self): def oid(self):
return self[b'oid'].split(b':')[-1] return self[b'oid'].split(b':')[-1]
def size(self): def size(self):
return int(self[b'size']) return int(self[b'size'])
# regular expressions used by _validate # regular expressions used by _validate
# see https://github.com/git-lfs/git-lfs/blob/master/docs/spec.md # see https://github.com/git-lfs/git-lfs/blob/master/docs/spec.md
_keyre = re.compile(br'\A[a-z0-9.-]+\Z') _keyre = re.compile(br'\A[a-z0-9.-]+\Z')
_valuere = re.compile(br'\A[^\n]*\Z') _valuere = re.compile(br'\A[^\n]*\Z')
_requiredre = { _requiredre = {
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 self.iteritems(): for k, v in pycompat.iteritems(self):
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,
upgrade, upgrade,
util, util,
vfs as vfsmod, vfs as vfsmod,
wireprotov1server, wireprotov1server,
) )
# 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 hgmeta.iteritems(): for k, v in pycompat.iteritems(hgmeta):
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 copies.iteritems(): for src, dsts in pycompat.iteritems(copies):
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.add(dst) repo.dirstate.add(dst)
# Drop useless copy information # Drop useless copy information
for f in list(repo.dirstate.copies()): for f in list(repo.dirstate.copies()):
repo.dirstate.copy(None, f) repo.dirstate.copy(None, f)
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 cmdtable.iteritems(): for cmd, entry in pycompat.iteritems(cmdtable):
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/rebase.py

"""short description for a context""" """short description for a context"""
desc = b'%d:%s "%s"' % ( desc = b'%d:%s "%s"' % (
ctx.rev(), ctx.rev(),
ctx, ctx,
ctx.description().split(b'\n', 1)[0], ctx.description().split(b'\n', 1)[0],
) )
repo = ctx.repo() repo = ctx.repo()
names = [] names = []
for nsname, ns in repo.names.iteritems(): for nsname, ns in pycompat.iteritems(repo.names):
if nsname == b'branches': if nsname == b'branches':
continue continue
names.extend(ns.names(repo, ctx.node())) names.extend(ns.names(repo, ctx.node()))
if names: if names:
desc += b' (%s)' % b' '.join(names) desc += b' (%s)' % b' '.join(names)
return desc return desc
# 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 self.state.iteritems(): for d, v in pycompat.iteritems(self.state):
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 self.state.iteritems() if v == revtodo] cands = [k for k, v in pycompat.iteritems(self.state) 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)))
allowdivergence = self.ui.configbool( allowdivergence = self.ui.configbool(
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 bpbase.iteritems(): # calculate roots for bp, bs in pycompat.iteritems(bpbase): # 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.
parents = [p.rev() for p in repo[None].parents()] parents = [p.rev() for p in repo[None].parents()]
# Are we in a merge state at all? # Are we in a merge state at all?
if len(parents) < 2: if len(parents) < 2:
return False return False
# We should be standing on the first as-of-yet unrebased commit. # We should be standing on the first as-of-yet unrebased commit.
firstunrebased = min( firstunrebased = min(
[old for old, new in state.iteritems() if new == nullrev] [old for old, new in pycompat.iteritems(state) if new == nullrev]
) )
if firstunrebased in parents: if firstunrebased in parents:
return True return True
return False return False
def sortsource(destmap): def sortsource(destmap):
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 replacements.iteritems(): for oldns, newn in pycompat.iteritems(replacements):
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(sections.iteritems()) self._sections = list(pycompat.iteritems(sections))
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/__init__.py

) )
# Prefetch merge checkunknownfiles # Prefetch merge checkunknownfiles
def checkunknownfiles(orig, repo, wctx, mctx, force, actions, *args, **kwargs): def checkunknownfiles(orig, repo, wctx, mctx, force, actions, *args, **kwargs):
if isenabled(repo): if isenabled(repo):
files = [] files = []
sparsematch = repo.maybesparsematch(mctx.rev()) sparsematch = repo.maybesparsematch(mctx.rev())
for f, (m, actionargs, msg) in actions.iteritems(): for f, (m, actionargs, msg) in pycompat.iteritems(actions):
if sparsematch and not sparsematch(f): if sparsematch and not sparsematch(f):
continue continue
if m in (b'c', b'dc', b'cm'): if m in (b'c', b'dc', b'cm'):
files.append((f, hex(mctx.filenode(f)))) files.append((f, hex(mctx.filenode(f))))
elif m == b'dg': elif m == b'dg':
f2 = actionargs[0] f2 = actionargs[0]
files.append((f2, hex(mctx.filenode(f2)))) files.append((f2, hex(mctx.filenode(f2))))
# batch fetch the needed files from the server # batch fetch the needed files from the server

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 filenamemap.iteritems(): for filename, sha in pycompat.iteritems(filenamemap):
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 self.entries.iteritems() (n, db, o, s) for n, (db, o, s) in pycompat.iteritems(self.entries)
) )
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 == nullid: if deltabase == 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 = (
(hashlib.sha1(filename).digest(), filename, offset, size) (hashlib.sha1(filename).digest(), filename, offset, size)
for filename, (offset, size) in self.files.iteritems() for filename, (offset, size) in pycompat.iteritems(self.files)
) )
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(nodelocations.iteritems()): for node, location in sorted(pycompat.iteritems(nodelocations)):
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

wdirfilenodeids, wdirfilenodeids,
wdirid, wdirid,
) )
from mercurial.i18n import _ from mercurial.i18n import _
from mercurial import ( from mercurial import (
ancestor, ancestor,
error, error,
mdiff, mdiff,
pycompat,
revlog, revlog,
util, util,
) )
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,
def ancestormap(self, node): def ancestormap(self, node):
return self.repo.metadatastore.getancestors(self.filename, node) return self.repo.metadatastore.getancestors(self.filename, node)
def ancestor(self, a, b): def ancestor(self, a, b):
if a == nullid or b == nullid: if a == nullid or b == nullid:
return nullid return nullid
revmap, parentfunc = self._buildrevgraph(a, b) revmap, parentfunc = self._buildrevgraph(a, b)
nodemap = dict(((v, k) for (k, v) in revmap.iteritems())) nodemap = dict(((v, k) for (k, v) in pycompat.iteritems(revmap)))
ancs = ancestor.ancestors(parentfunc, revmap[a], revmap[b]) ancs = ancestor.ancestors(parentfunc, revmap[a], revmap[b])
if ancs: if ancs:
# choose a consistent winner when there's a tie # choose a consistent winner when there's a tie
return min(map(nodemap.__getitem__, ancs)) return min(map(nodemap.__getitem__, ancs))
return nullid return nullid
def commonancestorsheads(self, a, b): def commonancestorsheads(self, a, b):
"""calculate all the heads of the common ancestors of nodes a and b""" """calculate all the heads of the common ancestors of nodes a and b"""
if a == nullid or b == nullid: if a == nullid or b == nullid:
return nullid return nullid
revmap, parentfunc = self._buildrevgraph(a, b) revmap, parentfunc = self._buildrevgraph(a, b)
nodemap = dict(((v, k) for (k, v) in revmap.iteritems())) nodemap = dict(((v, k) for (k, v) in pycompat.iteritems(revmap)))
ancs = ancestor.commonancestorsheads(parentfunc, revmap[a], revmap[b]) ancs = ancestor.commonancestorsheads(parentfunc, revmap[a], revmap[b])
return map(nodemap.__getitem__, ancs) return map(nodemap.__getitem__, ancs)
def _buildrevgraph(self, a, b): def _buildrevgraph(self, a, b):
"""Builds a numeric revision graph for the given two nodes. """Builds a numeric revision graph for the given two nodes.
Returns a node->rev map and a rev->[revs] parent function. Returns a node->rev map and a rev->[revs] parent function.
""" """
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 mapping.iteritems(): for node, pdata in pycompat.iteritems(mapping):
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 != nullid and not copyfrom: if p1 != nullid and not copyfrom:
parents.append(p1) parents.append(p1)
allparents.add(p1) allparents.add(p1)
if p2 != nullid: if p2 != 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,
store, store,
streamclone, streamclone,
util, util,
wireprotoserver, wireprotoserver,
wireprototypes, wireprototypes,
wireprotov1server, wireprotov1server,
) )
from . import ( from . import (
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 mf.iteritems(): for filename, filenode in pycompat.iteritems(mf):
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 m.iteritems(): for filename, diff in pycompat.iteritems(m):
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 m.iteritems(): for filename, filenode in pycompat.iteritems(m):
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(byfile.iteritems()): for filename, entries in sorted(pycompat.iteritems(byfile)):
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(byfile.iteritems()): for filename, entries in sorted(pycompat.iteritems(byfile)):
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

from mercurial.i18n import _ from mercurial.i18n import _
from mercurial.node import hex, nullid, nullrev from mercurial.node import hex, nullid, 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(mfdict.iteritems()) skip = set(pycompat.iteritems(mfdict))
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 = mfdict.iteritems() diff = pycompat.iteritems(mfdict)
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 dict.iteritems(): for k, v in pycompat.iteritems(dict):
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 dict.iteritems(): for k, v in pycompat.iteritems(dict):
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))
The dict contains raw content - both keys and values are strings. The dict contains raw content - both keys and values are strings.
Upper-level business may want to serialize some of other types (like Upper-level business may want to serialize some of other types (like
integers) to strings before calling this function. integers) to strings before calling this function.
raise ProgrammingError when metadata key is illegal, or ValueError if raise ProgrammingError when metadata key is illegal, or ValueError if
length limit is exceeded length limit is exceeded
""" """
metabuf = b'' metabuf = b''
for k, v in sorted((metadict or {}).iteritems()): for k, v in sorted(pycompat.iteritems((metadict or {}))):
if len(k) != 1: if len(k) != 1:
raise error.ProgrammingError(b'packmeta: illegal key: %s' % k) raise error.ProgrammingError(b'packmeta: illegal key: %s' % k)
if len(v) > 0xFFFE: if len(v) > 0xFFFE:
raise ValueError( raise ValueError(
b'metadata value is too long: 0x%x > 0xfffe' % len(v) b'metadata value is too long: 0x%x > 0xfffe' % len(v)
) )
metabuf += k metabuf += k
metabuf += struct.pack(b'!H', len(v)) metabuf += struct.pack(b'!H', len(v))
def buildpackmeta(metadict): def buildpackmeta(metadict):
"""like _buildpackmeta, but typechecks metadict and normalize it. """like _buildpackmeta, but typechecks metadict and normalize it.
This means, METAKEYSIZE and METAKEYSIZE should have integers as values, This means, METAKEYSIZE and METAKEYSIZE should have integers as values,
and METAKEYFLAG will be dropped if its value is 0. and METAKEYFLAG will be dropped if its value is 0.
""" """
newmeta = {} newmeta = {}
for k, v in (metadict or {}).iteritems(): for k, v in pycompat.iteritems(metadict or {}):
expectedtype = _metaitemtypes.get(k, (bytes,)) expectedtype = _metaitemtypes.get(k, (bytes,))
if not isinstance(v, expectedtype): if not isinstance(v, expectedtype):
raise error.ProgrammingError(b'packmeta: wrong type of key %s' % k) raise error.ProgrammingError(b'packmeta: wrong type of key %s' % k)
# normalize int to binary buffer # normalize int to binary buffer
if int in expectedtype: if int in expectedtype:
# optimization: remove flag if it's 0 to save space # optimization: remove flag if it's 0 to save space
if k == constants.METAKEYFLAG and v == 0: if k == constants.METAKEYFLAG and v == 0:
continue continue
v = int2bin(v) v = int2bin(v)
newmeta[k] = v newmeta[k] = v
return _buildpackmeta(newmeta) return _buildpackmeta(newmeta)
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 metadict.iteritems(): for k, v in pycompat.iteritems(metadict):
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 self.potentialentries.iteritems(): for k, vtup in pycompat.iteritems(self.potentialentries):
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 bmarktonodes.iteritems(): for name, node in pycompat.iteritems(bmarktonodes):
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 branchtonodes.iteritems(): for name, nodes in pycompat.iteritems(branchtonodes):
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 marktonodes.iteritems(): for name, node in pycompat.iteritems(marktonodes):
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 marktonodes.iteritems(): for name, node in pycompat.iteritems(marktonodes):
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/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 repomarks.iteritems(): for mark, node in pycompat.iteritems(repomarks):
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]

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 = dict((dst, src) for dst, src in copied.iteritems() if dst in files) copied = dict(
(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 _filters.iteritems(): for name, fn in pycompat.iteritems(_filters):
repo.adddatafilter(name, fn) repo.adddatafilter(name, fn)
def extsetup(ui): def extsetup(ui):
# deprecated config: win32text.warn # deprecated config: win32text.warn
if ui.configbool(b'win32text', b'warn'): if ui.configbool(b'win32text', b'warn'):
ui.warn( ui.warn(
_( _(
b"win32text is deprecated: " b"win32text is deprecated: "
b"https://mercurial-scm.org/wiki/Win32TextExtension\n" b"https://mercurial-scm.org/wiki/Win32TextExtension\n"
) )
) )

mercurial/__init__.py

import token import token
import tokenize import tokenize
class hgpathentryfinder(importlib.abc.MetaPathFinder): class hgpathentryfinder(importlib.abc.MetaPathFinder):
"""A sys.meta_path finder that uses a custom module loader.""" """A sys.meta_path finder that uses a custom module loader."""
def find_spec(self, fullname, path, target=None): def find_spec(self, fullname, path, target=None):
# Only handle Mercurial-related modules. # Only handle Mercurial-related modules.
if not fullname.startswith(('mercurial.', 'hgext.')): if not fullname.startswith('mercurial.'):
return None return None
# don't try to parse binary # don't try to parse binary
if fullname.startswith('mercurial.cext.'): if fullname.startswith('mercurial.cext.'):
return None return None
# third-party packages are expected to be dual-version clean # third-party packages are expected to be dual-version clean
if fullname.startswith('mercurial.thirdparty'): if fullname.startswith('mercurial.thirdparty'):
return None return None
# zstd is already dual-version clean, don't try and mangle it # zstd is already dual-version clean, don't try and mangle it
if fullname.startswith('mercurial.zstd'): if fullname.startswith('mercurial.zstd'):
return None return None
# rustext is built for the right python version, # rustext is built for the right python version,
# don't try and mangle it # don't try and mangle it
if fullname.startswith('mercurial.rustext'): if fullname.startswith('mercurial.rustext'):
return None return None
# pywatchman is already dual-version clean, don't try and mangle it
if fullname.startswith('hgext.fsmonitor.pywatchman'):
return None
# Try to find the module using other registered finders. # Try to find the module using other registered finders.
spec = None spec = None
for finder in sys.meta_path: for finder in sys.meta_path:
if finder == self: if finder == self:
continue continue
# Originally the API was a `find_module` method, but it was # Originally the API was a `find_module` method, but it was
# Emit unmodified token. # Emit unmodified token.
yield t yield t
# Header to add to bytecode files. This MUST be changed when # Header to add to bytecode files. This MUST be changed when
# ``replacetoken`` or any mechanism that changes semantics of module # ``replacetoken`` or any mechanism that changes semantics of module
# loading is changed. Otherwise cached bytecode may get loaded without # loading is changed. Otherwise cached bytecode may get loaded without
# the new transformation mechanisms applied. # the new transformation mechanisms applied.
BYTECODEHEADER = b'HG\x00\x15' BYTECODEHEADER = b'HG\x00\x16'
class hgloader(importlib.machinery.SourceFileLoader): class hgloader(importlib.machinery.SourceFileLoader):
"""Custom module loader that transforms source code. """Custom module loader that transforms source code.
When the source code is converted to a code object, we transform When the source code is converted to a code object, we transform
certain patterns to be Python 3 compatible. This allows us to write code certain patterns to be Python 3 compatible. This allows us to write code
that is natively Python 2 and compatible with Python 3 without that is natively Python 2 and compatible with Python 3 without
making the code excessively ugly. making the code excessively ugly.

mercurial/pycompat.py

""" """
Takes bytes argument, convert it to str i.e. unicodes, pass that into Takes bytes argument, convert it to str i.e. unicodes, pass that into
shlex.split(), convert the returned value to bytes and return that for shlex.split(), convert the returned value to bytes and return that for
Python 3 compatibility as shelx.split() don't accept bytes on Python 3. Python 3 compatibility as shelx.split() don't accept bytes on Python 3.
""" """
ret = shlex.split(s.decode('latin-1'), comments, posix) ret = shlex.split(s.decode('latin-1'), comments, posix)
return [a.encode('latin-1') for a in ret] return [a.encode('latin-1') for a in ret]
iteritems = lambda x: x.items()
itervalues = lambda x: x.values() itervalues = lambda x: x.values()
else: else:
import cStringIO import cStringIO
xrange = xrange xrange = xrange
unicode = unicode unicode = unicode
bytechr = chr bytechr = chr
shlexsplit = shlex.split shlexsplit = shlex.split
bytesio = cStringIO.StringIO bytesio = cStringIO.StringIO
stringio = bytesio stringio = bytesio
maplist = map maplist = map
rangelist = range rangelist = range
ziplist = zip ziplist = zip
rawinput = raw_input rawinput = raw_input
getargspec = inspect.getargspec getargspec = inspect.getargspec
iteritems = lambda x: x.iteritems()
itervalues = lambda x: x.itervalues() itervalues = lambda x: x.itervalues()
isjython = sysplatform.startswith(b'java') isjython = sysplatform.startswith(b'java')
isdarwin = sysplatform.startswith(b'darwin') isdarwin = sysplatform.startswith(b'darwin')
islinux = sysplatform.startswith(b'linux') islinux = sysplatform.startswith(b'linux')
isposix = osname == b'posix' isposix = osname == b'posix'
iswindows = osname == b'nt' iswindows = osname == b'nt'