This is an archive of the discontinued Mercurial Phabricator instance.

Differential D9480

node: import symbols explicitly
ClosedPublic

Authored by joerg.sonnenberger on Dec 1 2020, 4:06 PM.

Details

Reviewers
durin42
martinvonz
Alphare
Group Reviewers
hg-reviewers
Commits
rHG59fa3890d40a: node: import symbols explicitly
rHGe1417d7c4ff3: node: import symbols explicitly
Summary

There is no point in lazy importing mercurial.node, it is used all over
the place anyway. So consistently import the used symbols directly.
Fix one file using symbols indirectly via mercurial.revlog.

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

Alphare accepted this revision.Dec 14 2020, 5:08 AM
Alphare added a subscriber: Alphare.

Thanks for doing this, that looks tedious.

joerg.sonnenberger added a commit: rHGe1417d7c4ff3: node: import symbols explicitly.Dec 15 2020, 7:42 PM
This revision was not accepted when it landed; it landed in state Needs Review.
Closed by commit rHGe1417d7c4ff3: node: import symbols explicitly (authored by joerg.sonnenberger). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mcontrib/dumprevlog (6 lines)
Mcontrib/undumprevlog (8 lines)
Mhgext/absorb.py (18 lines)
Mhgext/convert/git.py (14 lines)
Mhgext/convert/hg.py (39 lines)
Mhgext/fastannotate/context.py (20 lines)
Mhgext/fastannotate/formatter.py (11 lines)
Mhgext/git/dirstate.py (12 lines)
Mhgext/git/gitlog.py (67 lines)
Mhgext/git/index.py (9 lines)
Mhgext/gpg.py (29 lines)
Mhgext/histedit.py (78 lines)
Mhgext/infinitepush/bundleparts.py (4 lines)
Mhgext/infinitepush/store.py (8 lines)
Mhgext/journal.py (20 lines)
Mhgext/largefiles/lfcommands.py (18 lines)
Mhgext/largefiles/lfutil.py (8 lines)
Mhgext/lfs/__init__.py (7 lines)
Mhgext/lfs/blobstore.py (10 lines)
Mhgext/narrow/narrowcommands.py (18 lines)
Mhgext/patchbomb.py (4 lines)
Mhgext/rebase.py (4 lines)
Mhgext/releasenotes.py (4 lines)
Mhgext/remotefilelog/__init__.py (8 lines)
Mhgext/remotefilelog/basepack.py (4 lines)
Mhgext/remotefilelog/debugcommands.py (12 lines)
Mhgext/remotefilelog/fileserverclient.py (5 lines)
Mhgext/remotefilelog/shallowutil.py (6 lines)
Mhgext/transplant.py (63 lines)
Mhgext/uncommit.py (4 lines)
Mmercurial/bundle2.py (22 lines)
Mmercurial/bundlerepo.py (11 lines)
Mmercurial/chgserver.py (4 lines)
Mmercurial/copies.py (20 lines)
Mmercurial/dagop.py (12 lines)
Mmercurial/hg.py (20 lines)
Mmercurial/keepalive.py (8 lines)
Mmercurial/metadata.py (17 lines)
Mmercurial/obsolete.py (16 lines)
Mmercurial/obsutil.py (11 lines)
Mmercurial/revlogutils/nodemap.py (16 lines)
Mmercurial/revset.py (47 lines)
Mmercurial/revsetlang.py (6 lines)
Mmercurial/rewriteutil.py (9 lines)
Mmercurial/shelve.py (37 lines)
Mmercurial/simplemerge.py (4 lines)
Mmercurial/sslutil.py (8 lines)
Mmercurial/store.py (4 lines)
Mmercurial/strip.py (3 lines)
Mmercurial/subrepo.py (23 lines)
Mmercurial/tagmerge.py (7 lines)
Mmercurial/templatefilters.py (4 lines)
Mmercurial/util.py (4 lines)
Mtests/drawdag.py (6 lines)
Mtests/test-parseindex2.py (7 lines)
Mtests/test-revlog-raw.py (10 lines)
Mtests/test-rust-ancestor.py (8 lines)
Mtests/testlib/ext-sidedata.py (7 lines)

Diff 24288

contrib/dumprevlog

#!/usr/bin/env python3 #!/usr/bin/env python3
# Dump revlogs as raw data stream # Dump revlogs as raw data stream
# $ find .hg/store/ -name "*.i" | xargs dumprevlog > repo.dump # $ find .hg/store/ -name "*.i" | xargs dumprevlog > repo.dump
from __future__ import absolute_import, print_function from __future__ import absolute_import, print_function
import sys import sys
from mercurial.node import hex
from mercurial import ( from mercurial import (
encoding, encoding,
node,
pycompat, pycompat,
revlog, revlog,
) )
from mercurial.utils import procutil from mercurial.utils import procutil
for fp in (sys.stdin, sys.stdout, sys.stderr): for fp in (sys.stdin, sys.stdout, sys.stderr):
procutil.setbinary(fp) procutil.setbinary(fp)
for f in sys.argv[1:]: for f in sys.argv[1:]:
r = revlog.revlog(binopen, encoding.strtolocal(f)) r = revlog.revlog(binopen, encoding.strtolocal(f))
print("file:", f) print("file:", f)
for i in r: for i in r:
n = r.node(i) n = r.node(i)
p = r.parents(n) p = r.parents(n)
d = r.revision(n) d = r.revision(n)
printb(b"node: %s" % node.hex(n)) printb(b"node: %s" % hex(n))
printb(b"linkrev: %d" % r.linkrev(i)) printb(b"linkrev: %d" % r.linkrev(i))
printb(b"parents: %s %s" % (node.hex(p[0]), node.hex(p[1]))) printb(b"parents: %s %s" % (hex(p[0]), hex(p[1])))
printb(b"length: %d" % len(d)) printb(b"length: %d" % len(d))
printb(b"-start-") printb(b"-start-")
printb(d) printb(d)
printb(b"-end-") printb(b"-end-")

contrib/undumprevlog

#!/usr/bin/env python3 #!/usr/bin/env python3
# Undump a dump from dumprevlog # Undump a dump from dumprevlog
# $ hg init # $ hg init
# $ undumprevlog < repo.dump # $ undumprevlog < repo.dump
from __future__ import absolute_import, print_function from __future__ import absolute_import, print_function
import sys import sys
from mercurial.node import bin
from mercurial import ( from mercurial import (
encoding, encoding,
node,
revlog, revlog,
transaction, transaction,
vfs as vfsmod, vfs as vfsmod,
) )
from mercurial.utils import procutil from mercurial.utils import procutil
for fp in (sys.stdin, sys.stdout, sys.stderr): for fp in (sys.stdin, sys.stdout, sys.stderr):
procutil.setbinary(fp) procutil.setbinary(fp)
opener = vfsmod.vfs(b'.', False) opener = vfsmod.vfs(b'.', False)
tr = transaction.transaction( tr = transaction.transaction(
sys.stderr.write, opener, {b'store': opener}, b"undump.journal" sys.stderr.write, opener, {b'store': opener}, b"undump.journal"
) )
while True: while True:
l = sys.stdin.readline() l = sys.stdin.readline()
if not l: if not l:
break break
if l.startswith("file:"): if l.startswith("file:"):
f = encoding.strtolocal(l[6:-1]) f = encoding.strtolocal(l[6:-1])
r = revlog.revlog(opener, f) r = revlog.revlog(opener, f)
procutil.stdout.write(b'%s\n' % f) procutil.stdout.write(b'%s\n' % f)
elif l.startswith("node:"): elif l.startswith("node:"):
n = node.bin(l[6:-1]) n = bin(l[6:-1])
elif l.startswith("linkrev:"): elif l.startswith("linkrev:"):
lr = int(l[9:-1]) lr = int(l[9:-1])
elif l.startswith("parents:"): elif l.startswith("parents:"):
p = l[9:-1].split() p = l[9:-1].split()
p1 = node.bin(p[0]) p1 = bin(p[0])
p2 = node.bin(p[1]) p2 = bin(p[1])
elif l.startswith("length:"): elif l.startswith("length:"):
length = int(l[8:-1]) length = int(l[8:-1])
sys.stdin.readline() # start marker sys.stdin.readline() # start marker
d = encoding.strtolocal(sys.stdin.read(length)) d = encoding.strtolocal(sys.stdin.read(length))
sys.stdin.readline() # end marker sys.stdin.readline() # end marker
r.addrevision(d, tr, lr, p1, p2) r.addrevision(d, tr, lr, p1, p2)
tr.close() tr.close()

hgext/absorb.py

# * Converge getdraftstack() with other code in core # * Converge getdraftstack() with other code in core
# * move many attributes on fixupstate to be private # * move many attributes on fixupstate to be private
from __future__ import absolute_import from __future__ import absolute_import
import collections import collections
from mercurial.i18n import _ from mercurial.i18n import _
from mercurial.node import (
hex,
nullid,
short,
)
from mercurial import ( from mercurial import (
cmdutil, cmdutil,
commands, commands,
context, context,
crecord, crecord,
error, error,
linelog, linelog,
mdiff, mdiff,
node,
obsolete, obsolete,
patch, patch,
phases, phases,
pycompat, pycompat,
registrar, registrar,
rewriteutil, rewriteutil,
scmutil, scmutil,
util, util,
class emptyfilecontext(object): class emptyfilecontext(object):
"""minimal filecontext representing an empty file""" """minimal filecontext representing an empty file"""
def data(self): def data(self):
return b'' return b''
def node(self): def node(self):
return node.nullid return nullid
def uniq(lst): def uniq(lst):
"""list -> list. remove duplicated items without changing the order""" """list -> list. remove duplicated items without changing the order"""
seen = set() seen = set()
result = [] result = []
for x in lst: for x in lst:
if x not in seen: if x not in seen:
# the following is unnecessary, as it's done by "diffwith": # the following is unnecessary, as it's done by "diffwith":
# self.linelog.annotate(self.linelog.maxrev) # self.linelog.annotate(self.linelog.maxrev)
for rev, a1, a2, b1, b2 in reversed(self.fixups): for rev, a1, a2, b1, b2 in reversed(self.fixups):
blines = self.targetlines[b1:b2] blines = self.targetlines[b1:b2]
if self.ui.debugflag: if self.ui.debugflag:
idx = (max(rev - 1, 0)) // 2 idx = (max(rev - 1, 0)) // 2
self.ui.write( self.ui.write(
_(b'%s: chunk %d:%d -> %d lines\n') _(b'%s: chunk %d:%d -> %d lines\n')
% (node.short(self.fctxs[idx].node()), a1, a2, len(blines)) % (short(self.fctxs[idx].node()), a1, a2, len(blines))
) )
self.linelog.replacelines(rev, a1, a2, b1, b2) self.linelog.replacelines(rev, a1, a2, b1, b2)
if self.opts.get(b'edit_lines', False): if self.opts.get(b'edit_lines', False):
self.finalcontents = self._checkoutlinelogwithedits() self.finalcontents = self._checkoutlinelogwithedits()
else: else:
self.finalcontents = self._checkoutlinelog() self.finalcontents = self._checkoutlinelog()
def getfinalcontent(self, fctx): def getfinalcontent(self, fctx):
(i, f) (i, f)
for i, f in enumerate(self.fctxs) for i, f in enumerate(self.fctxs)
if not isinstance(f, emptyfilecontext) if not isinstance(f, emptyfilecontext)
] ]
for i, (j, f) in enumerate(visiblefctxs): for i, (j, f) in enumerate(visiblefctxs):
editortext += _(b'HG: %s/%s %s %s\n') % ( editortext += _(b'HG: %s/%s %s %s\n') % (
b'|' * i, b'|' * i,
b'-' * (len(visiblefctxs) - i + 1), b'-' * (len(visiblefctxs) - i + 1),
node.short(f.node()), short(f.node()),
f.description().split(b'\n', 1)[0], f.description().split(b'\n', 1)[0],
) )
editortext += _(b'HG: %s\n') % (b'|' * len(visiblefctxs)) editortext += _(b'HG: %s\n') % (b'|' * len(visiblefctxs))
# figure out the lifetime of a line, this is relatively inefficient, # figure out the lifetime of a line, this is relatively inefficient,
# but probably fine # but probably fine
lineset = defaultdict(lambda: set()) # {(llrev, linenum): {llrev}} lineset = defaultdict(lambda: set()) # {(llrev, linenum): {llrev}}
for i, f in visiblefctxs: for i, f in visiblefctxs:
self.linelog.annotate((i + 1) * 2) self.linelog.annotate((i + 1) * 2)
if self.ui.verbose and msg: if self.ui.verbose and msg:
self.ui.write(_(b'%s: %s\n') % (self._ctx2str(ctx), msg)) self.ui.write(_(b'%s: %s\n') % (self._ctx2str(ctx), msg))
self.finalnode = lastcommitted and lastcommitted.node() self.finalnode = lastcommitted and lastcommitted.node()
def _ctx2str(self, ctx): def _ctx2str(self, ctx):
if self.ui.debugflag: if self.ui.debugflag:
return b'%d:%s' % (ctx.rev(), ctx.hex()) return b'%d:%s' % (ctx.rev(), ctx.hex())
else: else:
return b'%d:%s' % (ctx.rev(), node.short(ctx.node())) return b'%d:%s' % (ctx.rev(), short(ctx.node()))
def _getnewfilecontents(self, ctx): def _getnewfilecontents(self, ctx):
"""(ctx) -> {path: str} """(ctx) -> {path: str}
fetch file contents from filefixupstates. fetch file contents from filefixupstates.
return the working copy overrides - files different from ctx. return the working copy overrides - files different from ctx.
""" """
result = {} result = {}
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(
_(b'moving bookmark %s to %s\n') % (name, node.hex(hsh)) _(b'moving bookmark %s to %s\n') % (name, hex(hsh))
) )
else: else:
changes.append((name, None)) changes.append((name, None))
if self.ui.verbose: if self.ui.verbose:
self.ui.write(_(b'deleting bookmark %s\n') % name) self.ui.write(_(b'deleting bookmark %s\n') % name)
repo._bookmarks.applychanges(repo, tr, changes) repo._bookmarks.applychanges(repo, tr, changes)
def _moveworkingdirectoryparent(self): def _moveworkingdirectoryparent(self):
return True return True
def _commitsingle(self, memworkingcopy, ctx, p1=None): def _commitsingle(self, memworkingcopy, ctx, p1=None):
"""(ctx, {path: content}, node) -> node. make a single commit """(ctx, {path: content}, node) -> node. make a single commit
the commit is a clone from ctx, with a (optionally) different p1, and the commit is a clone from ctx, with a (optionally) different p1, and
different file contents replaced by memworkingcopy. different file contents replaced by memworkingcopy.
""" """
parents = p1 and (p1, node.nullid) parents = p1 and (p1, nullid)
extra = ctx.extra() extra = ctx.extra()
if self._useobsolete and self.ui.configbool(b'absorb', b'add-noise'): if self._useobsolete and self.ui.configbool(b'absorb', b'add-noise'):
extra[b'absorb_source'] = ctx.hex() extra[b'absorb_source'] = ctx.hex()
desc = rewriteutil.update_hash_refs( desc = rewriteutil.update_hash_refs(
ctx.repo(), ctx.repo(),
ctx.description(), ctx.description(),
{ {

hgext/convert/git.py

# git.py - git support for the convert extension # git.py - git support for the convert extension
# #
# Copyright 2005-2009 Matt Mackall <mpm@selenic.com> and others # Copyright 2005-2009 Matt Mackall <mpm@selenic.com> 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.
from __future__ import absolute_import from __future__ import absolute_import
import os import os
from mercurial.i18n import _ from mercurial.i18n import _
from mercurial.node import nullhex
from mercurial import ( from mercurial import (
config, config,
error, error,
node as nodemod,
pycompat, pycompat,
) )
from . import common from . import common
class submodule(object): class submodule(object):
def __init__(self, path, node, url): def __init__(self, path, node, url):
for rev in self.revs: for rev in self.revs:
rawhead, ret = self.gitrun(b'rev-parse', b'--verify', rev) rawhead, ret = self.gitrun(b'rev-parse', b'--verify', rev)
heads.append(rawhead[:-1]) heads.append(rawhead[:-1])
if ret: if ret:
raise error.Abort(_(b'cannot retrieve git head "%s"') % rev) raise error.Abort(_(b'cannot retrieve git head "%s"') % rev)
return heads return heads
def catfile(self, rev, ftype): def catfile(self, rev, ftype):
if rev == nodemod.nullhex: if rev == nullhex:
raise IOError raise IOError
self.catfilepipe[0].write(rev + b'\n') self.catfilepipe[0].write(rev + b'\n')
self.catfilepipe[0].flush() self.catfilepipe[0].flush()
info = self.catfilepipe[1].readline().split() info = self.catfilepipe[1].readline().split()
if info[1] != ftype: if info[1] != ftype:
raise error.Abort( raise error.Abort(
_(b'cannot read %r object at %s') _(b'cannot read %r object at %s')
% (pycompat.bytestr(ftype), rev) % (pycompat.bytestr(ftype), rev)
) )
size = int(info[2]) size = int(info[2])
data = self.catfilepipe[1].read(size) data = self.catfilepipe[1].read(size)
if len(data) < size: if len(data) < size:
raise error.Abort( raise error.Abort(
_(b'cannot read %r object at %s: unexpected size') _(b'cannot read %r object at %s: unexpected size')
% (ftype, rev) % (ftype, rev)
) )
# read the trailing newline # read the trailing newline
self.catfilepipe[1].read(1) self.catfilepipe[1].read(1)
return data return data
def getfile(self, name, rev): def getfile(self, name, rev):
if rev == nodemod.nullhex: if rev == nullhex:
return None, None return None, None
if name == b'.hgsub': if name == b'.hgsub':
data = b'\n'.join([m.hgsub() for m in self.submoditer()]) data = b'\n'.join([m.hgsub() for m in self.submoditer()])
mode = b'' mode = b''
elif name == b'.hgsubstate': elif name == b'.hgsubstate':
data = b'\n'.join([m.hgsubstate() for m in self.submoditer()]) data = b'\n'.join([m.hgsubstate() for m in self.submoditer()])
mode = b'' mode = b''
else: else:
data = self.catfile(rev, b"blob") data = self.catfile(rev, b"blob")
mode = self.modecache[(name, rev)] mode = self.modecache[(name, rev)]
return data, mode return data, mode
def submoditer(self): def submoditer(self):
null = nodemod.nullhex null = nullhex
for m in sorted(self.submodules, key=lambda p: p.path): for m in sorted(self.submodules, key=lambda p: p.path):
if m.node != null: if m.node != null:
yield m yield m
def parsegitmodules(self, content): def parsegitmodules(self, content):
"""Parse the formatted .gitmodules file, example file format: """Parse the formatted .gitmodules file, example file format:
[submodule "sub"]\n [submodule "sub"]\n
\tpath = sub\n \tpath = sub\n
if f == b'.gitmodules': if f == b'.gitmodules':
if skipsubmodules: if skipsubmodules:
return return
subexists[0] = True subexists[0] = True
if entry[4] == b'D' or renamesource: if entry[4] == b'D' or renamesource:
subdeleted[0] = True subdeleted[0] = True
changes.append((b'.hgsub', nodemod.nullhex)) changes.append((b'.hgsub', nullhex))
else: else:
changes.append((b'.hgsub', b'')) changes.append((b'.hgsub', b''))
elif entry[1] == b'160000' or entry[0] == b':160000': elif entry[1] == b'160000' or entry[0] == b':160000':
if not skipsubmodules: if not skipsubmodules:
subexists[0] = True subexists[0] = True
else: else:
if renamesource: if renamesource:
h = nodemod.nullhex h = nullhex
self.modecache[(f, h)] = (p and b"x") or (s and b"l") or b"" self.modecache[(f, h)] = (p and b"x") or (s and b"l") or b""
changes.append((f, h)) changes.append((f, h))
while i < lcount: while i < lcount:
l = difftree[i] l = difftree[i]
i += 1 i += 1
if not entry: if not entry:
if not l.startswith(b':'): if not l.startswith(b':'):
# .gitmodules isn't imported at all, so it being copied to # .gitmodules isn't imported at all, so it being copied to
# and fro doesn't really make sense # and fro doesn't really make sense
if f != b'.gitmodules' and fdest != b'.gitmodules': if f != b'.gitmodules' and fdest != b'.gitmodules':
copies[fdest] = f copies[fdest] = f
entry = None entry = None
if subexists[0]: if subexists[0]:
if subdeleted[0]: if subdeleted[0]:
changes.append((b'.hgsubstate', nodemod.nullhex)) changes.append((b'.hgsubstate', nullhex))
else: else:
self.retrievegitmodules(version) self.retrievegitmodules(version)
changes.append((b'.hgsubstate', b'')) changes.append((b'.hgsubstate', b''))
return (changes, copies, set()) return (changes, copies, set())
def getcommit(self, version): def getcommit(self, version):
c = self.catfile(version, b"commit") # read the commit hash c = self.catfile(version, b"commit") # read the commit hash
end = c.find(b"\n\n") end = c.find(b"\n\n")

hgext/convert/hg.py

from __future__ import absolute_import from __future__ import absolute_import
import os import os
import re import re
import time import time
from mercurial.i18n import _ from mercurial.i18n import _
from mercurial.pycompat import open from mercurial.pycompat import open
from mercurial.node import (
bin,
hex,
nullhex,
nullid,
)
from mercurial import ( from mercurial import (
bookmarks, bookmarks,
context, context,
error, error,
exchange, exchange,
hg, hg,
lock as lockmod, lock as lockmod,
merge as mergemod, merge as mergemod,
node as nodemod,
phases, phases,
pycompat, pycompat,
scmutil, scmutil,
util, util,
) )
from mercurial.utils import dateutil from mercurial.utils import dateutil
stringio = util.stringio stringio = util.stringio
for line in data.splitlines(): for line in data.splitlines():
s = line.split(b' ', 1) s = line.split(b' ', 1)
if len(s) != 2: if len(s) != 2:
self.ui.warn(_(b'invalid tag entry: "%s"\n') % line) self.ui.warn(_(b'invalid tag entry: "%s"\n') % line)
fp.write(b'%s\n' % line) # Bogus, but keep for hash stability fp.write(b'%s\n' % line) # Bogus, but keep for hash stability
continue continue
revid = revmap.get(source.lookuprev(s[0])) revid = revmap.get(source.lookuprev(s[0]))
if not revid: if not revid:
if s[0] == nodemod.nullhex: if s[0] == nullhex:
revid = s[0] revid = s[0]
else: else:
# missing, but keep for hash stability # missing, but keep for hash stability
self.ui.warn(_(b'missing tag entry: "%s"\n') % line) self.ui.warn(_(b'missing tag entry: "%s"\n') % line)
fp.write(b'%s\n' % line) fp.write(b'%s\n' % line)
continue continue
fp.write(b'%s %s\n' % (revid, s[1])) fp.write(b'%s %s\n' % (revid, s[1]))
return fp.getvalue() return fp.getvalue()
def _rewritesubstate(self, source, data): def _rewritesubstate(self, source, data):
fp = stringio() fp = stringio()
for line in data.splitlines(): for line in data.splitlines():
s = line.split(b' ', 1) s = line.split(b' ', 1)
if len(s) != 2: if len(s) != 2:
continue continue
revid = s[0] revid = s[0]
subpath = s[1] subpath = s[1]
if revid != nodemod.nullhex: if revid != nullhex:
revmap = self.subrevmaps.get(subpath) revmap = self.subrevmaps.get(subpath)
if revmap is None: if revmap is None:
revmap = mapfile( revmap = mapfile(
self.ui, self.repo.wjoin(subpath, b'.hg/shamap') self.ui, self.repo.wjoin(subpath, b'.hg/shamap')
) )
self.subrevmaps[subpath] = revmap self.subrevmaps[subpath] = revmap
# It is reasonable that one or more of the subrepos don't # It is reasonable that one or more of the subrepos don't
pl = [] pl = []
for p in parents: for p in parents:
if p not in pl: if p not in pl:
pl.append(p) pl.append(p)
parents = pl parents = pl
nparents = len(parents) nparents = len(parents)
if self.filemapmode and nparents == 1: if self.filemapmode and nparents == 1:
m1node = self.repo.changelog.read(nodemod.bin(parents[0]))[0] m1node = self.repo.changelog.read(bin(parents[0]))[0]
parent = parents[0] parent = parents[0]
if len(parents) < 2: if len(parents) < 2:
parents.append(nodemod.nullid) parents.append(nullid)
if len(parents) < 2: if len(parents) < 2:
parents.append(nodemod.nullid) parents.append(nullid)
p2 = parents.pop(0) p2 = parents.pop(0)
text = commit.desc text = commit.desc
sha1s = re.findall(sha1re, text) sha1s = re.findall(sha1re, text)
for sha1 in sha1s: for sha1 in sha1s:
oldrev = source.lookuprev(sha1) oldrev = source.lookuprev(sha1)
newrev = revmap.get(oldrev) newrev = revmap.get(oldrev)
): ):
node = extra.get(label) node = extra.get(label)
if node is None: if node is None:
continue continue
# Only transplant stores its reference in binary # Only transplant stores its reference in binary
if label == b'transplant_source': if label == b'transplant_source':
node = nodemod.hex(node) node = hex(node)
newrev = revmap.get(node) newrev = revmap.get(node)
if newrev is not None: if newrev is not None:
if label == b'transplant_source': if label == b'transplant_source':
newrev = nodemod.bin(newrev) newrev = bin(newrev)
extra[label] = newrev extra[label] = newrev
if self.branchnames and commit.branch: if self.branchnames and commit.branch:
extra[b'branch'] = commit.branch extra[b'branch'] = commit.branch
if commit.rev and commit.saverev: if commit.rev and commit.saverev:
extra[b'convert_revision'] = commit.rev extra[b'convert_revision'] = commit.rev
while parents: while parents:
p1 = p2 p1 = p2
p2 = parents.pop(0) p2 = parents.pop(0)
p1ctx = self.repo[p1] p1ctx = self.repo[p1]
p2ctx = None p2ctx = None
if p2 != nodemod.nullid: if p2 != nullid:
p2ctx = self.repo[p2] p2ctx = self.repo[p2]
fileset = set(files) fileset = set(files)
if full: if full:
fileset.update(self.repo[p1]) fileset.update(self.repo[p1])
fileset.update(self.repo[p2]) fileset.update(self.repo[p2])
if p2ctx: if p2ctx:
p2files = set(cleanp2) p2files = set(cleanp2)
b'convert', b'convert',
) )
with self.repo.transaction(b"convert") as tr: with self.repo.transaction(b"convert") as tr:
if self.repo.ui.config(b'convert', b'hg.preserve-hash'): if self.repo.ui.config(b'convert', b'hg.preserve-hash'):
origctx = commit.ctx origctx = commit.ctx
else: else:
origctx = None origctx = None
node = nodemod.hex(self.repo.commitctx(ctx, origctx=origctx)) node = hex(self.repo.commitctx(ctx, origctx=origctx))
# If the node value has changed, but the phase is lower than # If the node value has changed, but the phase is lower than
# draft, set it back to draft since it hasn't been exposed # draft, set it back to draft since it hasn't been exposed
# anywhere. # anywhere.
if commit.rev != node: if commit.rev != node:
ctx = self.repo[node] ctx = self.repo[node]
if ctx.phase() < phases.draft: if ctx.phase() < phases.draft:
phases.registernew( phases.registernew(
self.repo, tr, phases.draft, [ctx.rev()] self.repo, tr, phases.draft, [ctx.rev()]
) )
text = b"(octopus merge fixup)\n" text = b"(octopus merge fixup)\n"
p2 = node p2 = node
if self.filemapmode and nparents == 1: if self.filemapmode and nparents == 1:
man = self.repo.manifestlog.getstorage(b'') man = self.repo.manifestlog.getstorage(b'')
mnode = self.repo.changelog.read(nodemod.bin(p2))[0] mnode = self.repo.changelog.read(bin(p2))[0]
closed = b'close' in commit.extra closed = b'close' in commit.extra
if not closed and not man.cmp(m1node, man.revision(mnode)): if not closed and not man.cmp(m1node, man.revision(mnode)):
self.ui.status(_(b"filtering out empty revision\n")) self.ui.status(_(b"filtering out empty revision\n"))
self.repo.rollback(force=True) self.repo.rollback(force=True)
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 nullid
oldlines = set() oldlines = set()
for branch, heads in pycompat.iteritems(self.repo.branchmap()): 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))
) )
b"update tags", b"update tags",
[b".hgtags"], [b".hgtags"],
getfilectx, getfilectx,
b"convert-repo", b"convert-repo",
date, date,
extra, extra,
) )
node = self.repo.commitctx(ctx) node = self.repo.commitctx(ctx)
return nodemod.hex(node), nodemod.hex(tagparent) return hex(node), hex(tagparent)
def setfilemapmode(self, active): def setfilemapmode(self, active):
self.filemapmode = active self.filemapmode = active
def putbookmarks(self, updatedbookmark): def putbookmarks(self, updatedbookmark):
if not len(updatedbookmark): if not len(updatedbookmark):
return return
wlock = lock = tr = None wlock = lock = tr = None
try: try:
wlock = self.repo.wlock() wlock = self.repo.wlock()
lock = self.repo.lock() lock = self.repo.lock()
tr = self.repo.transaction(b'bookmark') tr = self.repo.transaction(b'bookmark')
self.ui.status(_(b"updating bookmarks\n")) self.ui.status(_(b"updating bookmarks\n"))
destmarks = self.repo._bookmarks destmarks = self.repo._bookmarks
changes = [ changes = [
(bookmark, nodemod.bin(updatedbookmark[bookmark])) (bookmark, bin(updatedbookmark[bookmark]))
for bookmark in updatedbookmark for bookmark in updatedbookmark
] ]
destmarks.applychanges(self.repo, tr, changes) destmarks.applychanges(self.repo, tr, changes)
tr.close() tr.close()
finally: finally:
lockmod.release(lock, wlock, tr) lockmod.release(lock, wlock, tr)
def hascommitfrommap(self, rev): def hascommitfrommap(self, rev):
self.lastctx = self.repo[rev] self.lastctx = self.repo[rev]
self.lastrev = rev self.lastrev = rev
return self.lastctx return self.lastctx
def _parents(self, ctx): def _parents(self, ctx):
return [p for p in ctx.parents() if p and self.keep(p.node())] return [p for p in ctx.parents() if p and self.keep(p.node())]
def getheads(self): def getheads(self):
return [nodemod.hex(h) for h in self._heads if self.keep(h)] return [hex(h) for h in self._heads if self.keep(h)]
def getfile(self, name, rev): def getfile(self, name, rev):
try: try:
fctx = self._changectx(rev)[name] fctx = self._changectx(rev)[name]
return fctx.data(), fctx.flags() return fctx.data(), fctx.flags()
except error.LookupError: except error.LookupError:
return None, None return None, None
def gettags(self): def gettags(self):
# This will get written to .hgtags, filter non global tags out. # This will get written to .hgtags, filter non global tags out.
tags = [ tags = [
t t
for t in self.repo.tagslist() for t in self.repo.tagslist()
if self.repo.tagtype(t[0]) == b'global' if self.repo.tagtype(t[0]) == b'global'
] ]
return { return {
name: nodemod.hex(node) for name, node in tags if self.keep(node) name: hex(node) for name, node in tags if self.keep(node)
} }
def getchangedfiles(self, rev, i): def getchangedfiles(self, rev, i):
ctx = self._changectx(rev) ctx = self._changectx(rev)
parents = self._parents(ctx) parents = self._parents(ctx)
if not parents and i is None: if not parents and i is None:
i = 0 i = 0
ma, r = ctx.manifest().keys(), [] ma, r = ctx.manifest().keys(), []
def hasnativeorder(self): def hasnativeorder(self):
return True return True
def hasnativeclose(self): def hasnativeclose(self):
return True return True
def lookuprev(self, rev): def lookuprev(self, rev):
try: try:
return nodemod.hex(self.repo.lookup(rev)) return hex(self.repo.lookup(rev))
except (error.RepoError, error.LookupError): except (error.RepoError, error.LookupError):
return None return None
def getbookmarks(self): def getbookmarks(self):
return bookmarks.listbookmarks(self.repo) return bookmarks.listbookmarks(self.repo)
def checkrevformat(self, revstr, mapname=b'splicemap'): def checkrevformat(self, revstr, mapname=b'splicemap'):
""" Mercurial, revision string is a 40 byte hex """ """ Mercurial, revision string is a 40 byte hex """
self.checkhexformat(revstr, mapname) self.checkhexformat(revstr, mapname)

hgext/fastannotate/context.py

import os import os
from mercurial.i18n import _ from mercurial.i18n import _
from mercurial.pycompat import ( from mercurial.pycompat import (
getattr, getattr,
open, open,
setattr, setattr,
) )
from mercurial.node import (
bin,
hex,
short,
)
from mercurial import ( from mercurial import (
error, error,
linelog as linelogmod, linelog as linelogmod,
lock as lockmod, lock as lockmod,
mdiff, mdiff,
node,
pycompat, pycompat,
scmutil, scmutil,
util, util,
) )
from mercurial.utils import ( from mercurial.utils import (
hashutil, hashutil,
stringutil, stringutil,
) )
.replace(b'.lock/', b'.lock.hg/') .replace(b'.lock/', b'.lock.hg/')
) )
def hashdiffopts(diffopts): def hashdiffopts(diffopts):
diffoptstr = stringutil.pprint( diffoptstr = stringutil.pprint(
sorted((k, getattr(diffopts, k)) for k in mdiff.diffopts.defaults) sorted((k, getattr(diffopts, k)) for k in mdiff.diffopts.defaults)
) )
return node.hex(hashutil.sha1(diffoptstr).digest())[:6] return hex(hashutil.sha1(diffoptstr).digest())[:6]
_defaultdiffopthash = hashdiffopts(mdiff.defaultopts) _defaultdiffopthash = hashdiffopts(mdiff.defaultopts)
class annotateopts(object): class annotateopts(object):
"""like mercurial.mdiff.diffopts, but is for annotate """like mercurial.mdiff.diffopts, but is for annotate
corresponding line contents. corresponding line contents.
""" """
# the fast path test requires commit hash, convert rev number to hash, # the fast path test requires commit hash, convert rev number to hash,
# so it may hit the fast path. note: in the "fctx" mode, the "annotate" # so it may hit the fast path. note: in the "fctx" mode, the "annotate"
# command could give us a revision number even if the user passes a # command could give us a revision number even if the user passes a
# commit hash. # commit hash.
if isinstance(rev, int): if isinstance(rev, int):
rev = node.hex(self.repo.changelog.node(rev)) rev = hex(self.repo.changelog.node(rev))
# fast path: if rev is in the main branch already # fast path: if rev is in the main branch already
directly, revfctx = self.canannotatedirectly(rev) directly, revfctx = self.canannotatedirectly(rev)
if directly: if directly:
if self.ui.debugflag: if self.ui.debugflag:
self.ui.debug( self.ui.debug(
b'fastannotate: %s: using fast path ' b'fastannotate: %s: using fast path '
b'(resolved fctx: %s)\n' b'(resolved fctx: %s)\n'
return (True, f) if we can annotate without updating the linelog, pass return (True, f) if we can annotate without updating the linelog, pass
f to annotatedirectly. f to annotatedirectly.
return (False, f) if we need extra calculation. f is the fctx resolved return (False, f) if we need extra calculation. f is the fctx resolved
from rev. from rev.
""" """
result = True result = True
f = None f = None
if not isinstance(rev, int) and rev is not None: if not isinstance(rev, int) and rev is not None:
hsh = {20: bytes, 40: node.bin}.get(len(rev), lambda x: None)(rev) hsh = {20: bytes, 40: bin}.get(len(rev), lambda x: None)(rev)
if hsh is not None and (hsh, self.path) in self.revmap: if hsh is not None and (hsh, self.path) in self.revmap:
f = hsh f = hsh
if f is None: if f is None:
adjustctx = b'linkrev' if self._perfhack else True adjustctx = b'linkrev' if self._perfhack else True
f = self._resolvefctx(rev, adjustctx=adjustctx, resolverev=True) f = self._resolvefctx(rev, adjustctx=adjustctx, resolverev=True)
result = f in self.revmap result = f in self.revmap
if not result and self._perfhack: if not result and self._perfhack:
# redo the resolution without perfhack - as we are going to # redo the resolution without perfhack - as we are going to
revlines = {} revlines = {}
for (rev, linenum), idxs in pycompat.iteritems(key2idxs): 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) % (short(hsh), linenum, idxs)
) )
fctx = self._resolvefctx(hsh, revmap.rev2path(rev)) fctx = self._resolvefctx(hsh, revmap.rev2path(rev))
lines = mdiff.splitnewlines(fctx.data()) lines = mdiff.splitnewlines(fctx.data())
revlines[rev] = lines revlines[rev] = lines
for idx in idxs: for idx in idxs:
result[idx] = revlines[rev][linenum] result[idx] = revlines[rev][linenum]
assert all(x is not None for x in result) assert all(x is not None for x in result)
return result return result
# run the annotate and the lines should match to the file content # run the annotate and the lines should match to the file content
self.ui.debug( self.ui.debug(
b'fastannotate: annotate %s to resolve lines\n' b'fastannotate: annotate %s to resolve lines\n'
% node.short(hsh) % short(hsh)
) )
linelog.annotate(rev) linelog.annotate(rev)
fctx = self._resolvefctx(hsh, revmap.rev2path(rev)) fctx = self._resolvefctx(hsh, revmap.rev2path(rev))
annotated = linelog.annotateresult annotated = linelog.annotateresult
lines = mdiff.splitnewlines(fctx.data()) lines = mdiff.splitnewlines(fctx.data())
if len(lines) != len(annotated): if len(lines) != len(annotated):
raise faerror.CorruptedFileError(b'unexpected annotated lines') raise faerror.CorruptedFileError(b'unexpected annotated lines')
# resolve lines from the annotate result # resolve lines from the annotate result
""" """
if isinstance(f, bytes): if isinstance(f, bytes):
hsh = f hsh = f
else: else:
hsh = f.node() hsh = f.node()
llrev = self.revmap.hsh2rev(hsh) llrev = self.revmap.hsh2rev(hsh)
if not llrev: if not llrev:
raise faerror.CorruptedFileError( raise faerror.CorruptedFileError(
b'%s is not in revmap' % node.hex(hsh) b'%s is not in revmap' % hex(hsh)
) )
if (self.revmap.rev2flag(llrev) & revmapmod.sidebranchflag) != 0: if (self.revmap.rev2flag(llrev) & revmapmod.sidebranchflag) != 0:
raise faerror.CorruptedFileError( raise faerror.CorruptedFileError(
b'%s is not in revmap mainbranch' % node.hex(hsh) b'%s is not in revmap mainbranch' % hex(hsh)
) )
self.linelog.annotate(llrev) self.linelog.annotate(llrev)
result = [ result = [
(self.revmap.rev2hsh(r), l) for r, l in self.linelog.annotateresult (self.revmap.rev2hsh(r), l) for r, l in self.linelog.annotateresult
] ]
return self._refineannotateresult(result, f, showpath, showlines) return self._refineannotateresult(result, f, showpath, showlines)
def _refineannotateresult(self, result, f, showpath, showlines): def _refineannotateresult(self, result, f, showpath, showlines):

hgext/fastannotate/formatter.py

# Copyright 2016-present Facebook. All Rights Reserved. # Copyright 2016-present Facebook. All Rights Reserved.
# #
# format: defines the format used to output annotate result # format: defines the format used to output annotate result
# #
# 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.node import (
hex,
short,
)
from mercurial import ( from mercurial import (
encoding, encoding,
node,
pycompat, pycompat,
templatefilters, templatefilters,
util, util,
) )
from mercurial.utils import dateutil from mercurial.utils import dateutil
# imitating mercurial.commands.annotate, not using the vanilla formatter since # imitating mercurial.commands.annotate, not using the vanilla formatter since
# the data structures are a bit different, and we have some fast paths. # the data structures are a bit different, and we have some fast paths.
if result[-1:] != b'\n': if result[-1:] != b'\n':
result += b'\n' result += b'\n'
self.ui.write(result) self.ui.write(result)
@util.propertycache @util.propertycache
def _hexfunc(self): def _hexfunc(self):
if self.ui.debugflag or self.opts.get(b'long_hash'): if self.ui.debugflag or self.opts.get(b'long_hash'):
return node.hex return hex
else: else:
return node.short return short
def end(self): def end(self):
pass pass
class jsonformatter(defaultformatter): class jsonformatter(defaultformatter):
def __init__(self, ui, repo, opts): def __init__(self, ui, repo, opts):
super(jsonformatter, self).__init__(ui, repo, opts) super(jsonformatter, self).__init__(ui, repo, opts)
def _writecomma(self): def _writecomma(self):
if self.needcomma: if self.needcomma:
self.ui.write(b',') self.ui.write(b',')
self.needcomma = False self.needcomma = False
@util.propertycache @util.propertycache
def _hexfunc(self): def _hexfunc(self):
return node.hex return hex
def end(self): def end(self):
self.ui.write(b'\n]\n') self.ui.write(b'\n]\n')

hgext/git/dirstate.py

from __future__ import absolute_import from __future__ import absolute_import
import contextlib import contextlib
import errno import errno
import os import os
from mercurial.node import nullid
from mercurial import ( from mercurial import (
error, error,
extensions, extensions,
match as matchmod, match as matchmod,
node as nodemod,
pycompat, pycompat,
scmutil, scmutil,
util, util,
) )
from mercurial.interfaces import ( from mercurial.interfaces import (
dirstate as intdirstate, dirstate as intdirstate,
util as interfaceutil, util as interfaceutil,
) )
self._plchangecallbacks = {} self._plchangecallbacks = {}
def p1(self): def p1(self):
try: try:
return self.git.head.peel().id.raw return self.git.head.peel().id.raw
except pygit2.GitError: except pygit2.GitError:
# Typically happens when peeling HEAD fails, as in an # Typically happens when peeling HEAD fails, as in an
# empty repository. # empty repository.
return nodemod.nullid return nullid
def p2(self): def p2(self):
# TODO: MERGE_HEAD? something like that, right? # TODO: MERGE_HEAD? something like that, right?
return nodemod.nullid return nullid
def setparents(self, p1, p2=nodemod.nullid): def setparents(self, p1, p2=nullid):
assert p2 == nodemod.nullid, b'TODO merging support' assert p2 == nullid, b'TODO merging support'
self.git.head.set_target(gitutil.togitnode(p1)) self.git.head.set_target(gitutil.togitnode(p1))
@util.propertycache @util.propertycache
def identity(self): def identity(self):
return util.filestat.frompath( return util.filestat.frompath(
os.path.join(self._root, b'.git', b'index') os.path.join(self._root, b'.git', b'index')
) )
def branch(self): def branch(self):
return b'default' return b'default'
def parents(self): def parents(self):
# TODO how on earth do we find p2 if a merge is in flight? # TODO how on earth do we find p2 if a merge is in flight?
return self.p1(), nodemod.nullid return self.p1(), nullid
def __iter__(self): def __iter__(self):
return (pycompat.fsencode(f.path) for f in self.git.index) return (pycompat.fsencode(f.path) for f in self.git.index)
def items(self): def items(self):
for ie in self.git.index: for ie in self.git.index:
yield ie.path, None # value should be a dirstatetuple yield ie.path, None # value should be a dirstatetuple

hgext/git/gitlog.py

from __future__ import absolute_import from __future__ import absolute_import
from mercurial.i18n import _ from mercurial.i18n import _
from mercurial.node import (
bin,
hex,
nullhex,
nullid,
nullrev,
wdirhex,
)
from mercurial import ( from mercurial import (
ancestor, ancestor,
changelog as hgchangelog, changelog as hgchangelog,
dagop, dagop,
encoding, encoding,
error, error,
manifest, manifest,
node as nodemod,
pycompat, pycompat,
) )
from mercurial.interfaces import ( from mercurial.interfaces import (
repository, repository,
util as interfaceutil, util as interfaceutil,
) )
from mercurial.utils import stringutil from mercurial.utils import stringutil
from . import ( from . import (
self._db = db self._db = db
def __len__(self): def __len__(self):
return int( return int(
self._db.execute('SELECT COUNT(*) FROM changelog').fetchone()[0] self._db.execute('SELECT COUNT(*) FROM changelog').fetchone()[0]
) )
def rev(self, n): def rev(self, n):
if n == nodemod.nullid: if n == nullid:
return -1 return -1
t = self._db.execute( t = self._db.execute(
'SELECT rev FROM changelog WHERE node = ?', (gitutil.togitnode(n),) 'SELECT rev FROM changelog WHERE node = ?', (gitutil.togitnode(n),)
).fetchone() ).fetchone()
if t is None: if t is None:
raise error.LookupError(n, b'00changelog.i', _(b'no node %d')) raise error.LookupError(n, b'00changelog.i', _(b'no node %d'))
return t[0] return t[0]
def node(self, r): def node(self, r):
if r == nodemod.nullrev: if r == nullrev:
return nodemod.nullid return nullid
t = self._db.execute( t = self._db.execute(
'SELECT node FROM changelog WHERE rev = ?', (r,) 'SELECT node FROM changelog WHERE rev = ?', (r,)
).fetchone() ).fetchone()
if t is None: if t is None:
raise error.LookupError(r, b'00changelog.i', _(b'no node')) raise error.LookupError(r, b'00changelog.i', _(b'no node'))
return nodemod.bin(t[0]) return bin(t[0])
def hasnode(self, n): def hasnode(self, n):
t = self._db.execute( t = self._db.execute(
'SELECT node FROM changelog WHERE node = ?', (n,) 'SELECT node FROM changelog WHERE node = ?', (n,)
).fetchone() ).fetchone()
return t is not None return t is not None
@property @property
def index(self): def index(self):
return baselogindex(self) return baselogindex(self)
@property @property
def nodemap(self): def nodemap(self):
r = { r = {
nodemod.bin(v[0]): v[1] bin(v[0]): v[1]
for v in self._db.execute('SELECT node, rev FROM changelog') for v in self._db.execute('SELECT node, rev FROM changelog')
} }
r[nodemod.nullid] = nodemod.nullrev r[nullid] = nullrev
return r return r
def tip(self): def tip(self):
t = self._db.execute( t = self._db.execute(
'SELECT node FROM changelog ORDER BY rev DESC LIMIT 1' 'SELECT node FROM changelog ORDER BY rev DESC LIMIT 1'
).fetchone() ).fetchone()
if t: if t:
return nodemod.bin(t[0]) return bin(t[0])
return nodemod.nullid return nullid
def revs(self, start=0, stop=None): def revs(self, start=0, stop=None):
if stop is None: if stop is None:
stop = self.tip() stop = self.tip()
t = self._db.execute( t = self._db.execute(
'SELECT rev FROM changelog ' 'SELECT rev FROM changelog '
'WHERE rev >= ? AND rev <= ? ' 'WHERE rev >= ? AND rev <= ? '
'ORDER BY REV ASC', 'ORDER BY REV ASC',
(start, stop), (start, stop),
) )
return (int(r[0]) for r in t) return (int(r[0]) for r in t)
def tiprev(self): def tiprev(self):
t = self._db.execute( t = self._db.execute(
'SELECT rev FROM changelog ' 'ORDER BY REV DESC ' 'LIMIT 1' 'SELECT rev FROM changelog ' 'ORDER BY REV DESC ' 'LIMIT 1'
) )
return next(t) return next(t)
def _partialmatch(self, id): def _partialmatch(self, id):
if nodemod.wdirhex.startswith(id): if wdirhex.startswith(id):
raise error.WdirUnsupported raise error.WdirUnsupported
candidates = [ candidates = [
nodemod.bin(x[0]) bin(x[0])
for x in self._db.execute( for x in self._db.execute(
'SELECT node FROM changelog WHERE node LIKE ?', (id + b'%',) 'SELECT node FROM changelog WHERE node LIKE ?', (id + b'%',)
) )
] ]
if nodemod.nullhex.startswith(id): if nullhex.startswith(id):
candidates.append(nodemod.nullid) candidates.append(nullid)
if len(candidates) > 1: if len(candidates) > 1:
raise error.AmbiguousPrefixLookupError( raise error.AmbiguousPrefixLookupError(
id, b'00changelog.i', _(b'ambiguous identifier') id, b'00changelog.i', _(b'ambiguous identifier')
) )
if candidates: if candidates:
return candidates[0] return candidates[0]
return None return None
def flags(self, rev): def flags(self, rev):
return 0 return 0
def shortest(self, node, minlength=1): def shortest(self, node, minlength=1):
nodehex = nodemod.hex(node) nodehex = hex(node)
for attempt in pycompat.xrange(minlength, len(nodehex) + 1): for attempt in pycompat.xrange(minlength, len(nodehex) + 1):
candidate = nodehex[:attempt] candidate = nodehex[:attempt]
matches = int( matches = int(
self._db.execute( self._db.execute(
'SELECT COUNT(*) FROM changelog WHERE node LIKE ?', 'SELECT COUNT(*) FROM changelog WHERE node LIKE ?',
(pycompat.sysstr(candidate + b'%'),), (pycompat.sysstr(candidate + b'%'),),
).fetchone()[0] ).fetchone()[0]
) )
def changelogrevision(self, nodeorrev): def changelogrevision(self, nodeorrev):
# Ensure we have a node id # Ensure we have a node id
if isinstance(nodeorrev, int): if isinstance(nodeorrev, int):
n = self.node(nodeorrev) n = self.node(nodeorrev)
else: else:
n = nodeorrev n = nodeorrev
# handle looking up nullid # handle looking up nullid
if n == nodemod.nullid: if n == nullid:
return hgchangelog._changelogrevision(extra={}) return hgchangelog._changelogrevision(extra={})
hn = gitutil.togitnode(n) hn = gitutil.togitnode(n)
# We've got a real commit! # We've got a real commit!
files = [ files = [
r[0] r[0]
for r in self._db.execute( for r in self._db.execute(
'SELECT filename FROM changedfiles ' 'SELECT filename FROM changedfiles '
'WHERE node = ? and filenode != ?', 'WHERE node = ? and filenode != ?',
(hn, gitutil.nullgit), (hn, gitutil.nullgit),
) )
] ]
filesremoved = [ filesremoved = [
r[0] r[0]
for r in self._db.execute( for r in self._db.execute(
'SELECT filename FROM changedfiles ' 'SELECT filename FROM changedfiles '
'WHERE node = ? and filenode = ?', 'WHERE node = ? and filenode = ?',
(hn, nodemod.nullhex), (hn, nullhex),
) )
] ]
c = self.gitrepo[hn] c = self.gitrepo[hn]
return hgchangelog._changelogrevision( return hgchangelog._changelogrevision(
manifest=n, # pretend manifest the same as the commit node manifest=n, # pretend manifest the same as the commit node
user=b'%s <%s>' user=b'%s <%s>'
% (c.author.name.encode('utf8'), c.author.email.encode('utf8')), % (c.author.name.encode('utf8'), c.author.email.encode('utf8')),
date=(c.author.time, -c.author.offset * 60), date=(c.author.time, -c.author.offset * 60),
revision numbers of the ancestors of arbitrary sets that are not revision numbers of the ancestors of arbitrary sets that are not
ancestors of common. This is an ancestor.incrementalmissingancestors ancestors of common. This is an ancestor.incrementalmissingancestors
object. object.
'common' is a list of revision numbers. If common is not supplied, uses 'common' is a list of revision numbers. If common is not supplied, uses
nullrev. nullrev.
""" """
if common is None: if common is None:
common = [nodemod.nullrev] common = [nullrev]
return ancestor.incrementalmissingancestors(self.parentrevs, common) return ancestor.incrementalmissingancestors(self.parentrevs, common)
def findmissing(self, common=None, heads=None): def findmissing(self, common=None, heads=None):
"""Return the ancestors of heads that are not ancestors of common. """Return the ancestors of heads that are not ancestors of common.
More specifically, return a list of nodes N such that every N More specifically, return a list of nodes N such that every N
satisfies the following constraints: satisfies the following constraints:
1. N is an ancestor of some node in 'heads' 1. N is an ancestor of some node in 'heads'
2. N is not an ancestor of any node in 'common' 2. N is not an ancestor of any node in 'common'
The list is sorted by revision number, meaning it is The list is sorted by revision number, meaning it is
topologically sorted. topologically sorted.
'heads' and 'common' are both lists of node IDs. If heads is 'heads' and 'common' are both lists of node IDs. If heads is
not supplied, uses all of the revlog's heads. If common is not not supplied, uses all of the revlog's heads. If common is not
supplied, uses nullid.""" supplied, uses nullid."""
if common is None: if common is None:
common = [nodemod.nullid] common = [nullid]
if heads is None: if heads is None:
heads = self.heads() heads = self.heads()
common = [self.rev(n) for n in common] common = [self.rev(n) for n in common]
heads = [self.rev(n) for n in heads] heads = [self.rev(n) for n in heads]
inc = self.incrementalmissingrevs(common=common) inc = self.incrementalmissingrevs(common=common)
return [self.node(r) for r in inc.missingancestors(heads)] return [self.node(r) for r in inc.missingancestors(heads)]
def children(self, node): def children(self, node):
"""find the children of a given node""" """find the children of a given node"""
c = [] c = []
p = self.rev(node) p = self.rev(node)
for r in self.revs(start=p + 1): for r in self.revs(start=p + 1):
prevs = [pr for pr in self.parentrevs(r) if pr != nodemod.nullrev] prevs = [pr for pr in self.parentrevs(r) if pr != nullrev]
if prevs: if prevs:
for pr in prevs: for pr in prevs:
if pr == p: if pr == p:
c.append(self.node(r)) c.append(self.node(r))
elif p == nodemod.nullrev: elif p == nullrev:
c.append(self.node(r)) c.append(self.node(r))
return c return c
def reachableroots(self, minroot, heads, roots, includepath=False): def reachableroots(self, minroot, heads, roots, includepath=False):
return dagop._reachablerootspure( return dagop._reachablerootspure(
self.parentrevs, minroot, roots, heads, includepath self.parentrevs, minroot, roots, heads, includepath
) )
# Cleanup opportunity: this is *identical* to the revlog.py version # Cleanup opportunity: this is *identical* to the revlog.py version
def isancestor(self, a, b): def isancestor(self, a, b):
a, b = self.rev(a), self.rev(b) a, b = self.rev(a), self.rev(b)
return self.isancestorrev(a, b) return self.isancestorrev(a, b)
# Cleanup opportunity: this is *identical* to the revlog.py version # Cleanup opportunity: this is *identical* to the revlog.py version
def isancestorrev(self, a, b): def isancestorrev(self, a, b):
if a == nodemod.nullrev: if a == nullrev:
return True return True
elif a == b: elif a == b:
return True return True
elif a > b: elif a > b:
return False return False
return bool(self.reachableroots(a, [b], [a], includepath=False)) return bool(self.reachableroots(a, [b], [a], includepath=False))
def parentrevs(self, rev): def parentrevs(self, rev):
n = self.node(rev) n = self.node(rev)
hn = gitutil.togitnode(n) hn = gitutil.togitnode(n)
if hn != gitutil.nullgit: if hn != gitutil.nullgit:
c = self.gitrepo[hn] c = self.gitrepo[hn]
else: else:
return nodemod.nullrev, nodemod.nullrev return nullrev, nullrev
p1 = p2 = nodemod.nullrev p1 = p2 = nullrev
if c.parents: if c.parents:
p1 = self.rev(c.parents[0].id.raw) p1 = self.rev(c.parents[0].id.raw)
if len(c.parents) > 2: if len(c.parents) > 2:
raise error.Abort(b'TODO octopus merge handling') raise error.Abort(b'TODO octopus merge handling')
if len(c.parents) == 2: if len(c.parents) == 2:
p2 = self.rev(c.parents[1].id.raw) p2 = self.rev(c.parents[1].id.raw)
return p1, p2 return p1, p2
extra=None, extra=None,
p1copies=None, p1copies=None,
p2copies=None, p2copies=None,
filesadded=None, filesadded=None,
filesremoved=None, filesremoved=None,
): ):
parents = [] parents = []
hp1, hp2 = gitutil.togitnode(p1), gitutil.togitnode(p2) hp1, hp2 = gitutil.togitnode(p1), gitutil.togitnode(p2)
if p1 != nodemod.nullid: if p1 != nullid:
parents.append(hp1) parents.append(hp1)
if p2 and p2 != nodemod.nullid: if p2 and p2 != nullid:
parents.append(hp2) parents.append(hp2)
assert date is not None assert date is not None
timestamp, tz = date timestamp, tz = date
sig = pygit2.Signature( sig = pygit2.Signature(
encoding.unifromlocal(stringutil.person(user)), encoding.unifromlocal(stringutil.person(user)),
encoding.unifromlocal(stringutil.email(user)), encoding.unifromlocal(stringutil.email(user)),
int(timestamp), int(timestamp),
-int(tz // 60), -int(tz // 60),
return oid.raw return oid.raw
class manifestlog(baselog): class manifestlog(baselog):
def __getitem__(self, node): def __getitem__(self, node):
return self.get(b'', node) return self.get(b'', node)
def get(self, relpath, node): def get(self, relpath, node):
if node == nodemod.nullid: if node == nullid:
# TODO: this should almost certainly be a memgittreemanifestctx # TODO: this should almost certainly be a memgittreemanifestctx
return manifest.memtreemanifestctx(self, relpath) return manifest.memtreemanifestctx(self, relpath)
commit = self.gitrepo[gitutil.togitnode(node)] commit = self.gitrepo[gitutil.togitnode(node)]
t = commit.tree t = commit.tree
if relpath: if relpath:
parts = relpath.split(b'/') parts = relpath.split(b'/')
for p in parts: for p in parts:
te = t[p] te = t[p]
t = self.gitrepo[te.id] t = self.gitrepo[te.id]
return gitmanifest.gittreemanifestctx(self.gitrepo, t) return gitmanifest.gittreemanifestctx(self.gitrepo, t)
@interfaceutil.implementer(repository.ifilestorage) @interfaceutil.implementer(repository.ifilestorage)
class filelog(baselog): class filelog(baselog):
def __init__(self, gr, db, path): def __init__(self, gr, db, path):
super(filelog, self).__init__(gr, db) super(filelog, self).__init__(gr, db)
assert isinstance(path, bytes) assert isinstance(path, bytes)
self.path = path self.path = path
def read(self, node): def read(self, node):
if node == nodemod.nullid: if node == nullid:
return b'' return b''
return self.gitrepo[gitutil.togitnode(node)].data return self.gitrepo[gitutil.togitnode(node)].data
def lookup(self, node): def lookup(self, node):
if len(node) not in (20, 40): if len(node) not in (20, 40):
node = int(node) node = int(node)
if isinstance(node, int): if isinstance(node, int):
assert False, b'todo revnums for nodes' assert False, b'todo revnums for nodes'
if len(node) == 40: if len(node) == 40:
node = nodemod.bin(node) node = bin(node)
hnode = gitutil.togitnode(node) hnode = gitutil.togitnode(node)
if hnode in self.gitrepo: if hnode in self.gitrepo:
return node return node
raise error.LookupError(self.path, node, _(b'no match found')) raise error.LookupError(self.path, node, _(b'no match found'))
def cmp(self, node, text): def cmp(self, node, text):
"""Returns True if text is different than content at `node`.""" """Returns True if text is different than content at `node`."""
return self.read(node) != text return self.read(node) != text
'''SELECT filenode FROM changedfiles '''SELECT filenode FROM changedfiles
INNER JOIN changelog ON changelog.node = changedfiles.node INNER JOIN changelog ON changelog.node = changedfiles.node
WHERE changelog.rev = ? AND filename = ? WHERE changelog.rev = ? AND filename = ?
''', ''',
(rev, pycompat.fsdecode(self.path)), (rev, pycompat.fsdecode(self.path)),
).fetchone() ).fetchone()
if maybe is None: if maybe is None:
raise IndexError('gitlog %r out of range %d' % (self.path, rev)) raise IndexError('gitlog %r out of range %d' % (self.path, rev))
return nodemod.bin(maybe[0]) return bin(maybe[0])
def parents(self, node): def parents(self, node):
gn = gitutil.togitnode(node) gn = gitutil.togitnode(node)
gp = pycompat.fsdecode(self.path) gp = pycompat.fsdecode(self.path)
ps = [] ps = []
for p in self._db.execute( for p in self._db.execute(
'''SELECT p1filenode, p2filenode FROM changedfiles '''SELECT p1filenode, p2filenode FROM changedfiles
WHERE filenode = ? AND filename = ? WHERE filenode = ? AND filename = ?
''', ''',
(gn, gp), (gn, gp),
).fetchone(): ).fetchone():
if p is None: if p is None:
commit = self._db.execute( commit = self._db.execute(
"SELECT node FROM changedfiles " "SELECT node FROM changedfiles "
"WHERE filenode = ? AND filename = ?", "WHERE filenode = ? AND filename = ?",
(gn, gp), (gn, gp),
).fetchone()[0] ).fetchone()[0]
# This filelog is missing some data. Build the # This filelog is missing some data. Build the
# filelog, then recurse (which will always find data). # filelog, then recurse (which will always find data).
if pycompat.ispy3: if pycompat.ispy3:
commit = commit.decode('ascii') commit = commit.decode('ascii')
index.fill_in_filelog(self.gitrepo, self._db, commit, gp, gn) index.fill_in_filelog(self.gitrepo, self._db, commit, gp, gn)
return self.parents(node) return self.parents(node)
else: else:
ps.append(nodemod.bin(p)) ps.append(bin(p))
return ps return ps
def renamed(self, node): def renamed(self, node):
# TODO: renames/copies # TODO: renames/copies
return False return False

hgext/git/index.py

from __future__ import absolute_import from __future__ import absolute_import
import collections import collections
import os import os
import sqlite3 import sqlite3
from mercurial.i18n import _ from mercurial.i18n import _
from mercurial.node import (
nullhex,
nullid,
)
from mercurial import ( from mercurial import (
encoding, encoding,
error, error,
node as nodemod,
pycompat, pycompat,
) )
from . import gitutil from . import gitutil
pygit2 = gitutil.get_pygit2() pygit2 = gitutil.get_pygit2()
if prog is not None: if prog is not None:
prog.complete() prog.complete()
prog = progress_factory(b'commits') prog = progress_factory(b'commits')
# This walker is sure to visit all the revisions in history, but # This walker is sure to visit all the revisions in history, but
# only once. # only once.
for pos, commit in enumerate(walker): for pos, commit in enumerate(walker):
if prog is not None: if prog is not None:
prog.update(pos) prog.update(pos)
p1 = p2 = nodemod.nullhex p1 = p2 = nullhex
if len(commit.parents) > 2: if len(commit.parents) > 2:
raise error.ProgrammingError( raise error.ProgrammingError(
( (
b"git support can't handle octopus merges, " b"git support can't handle octopus merges, "
b"found a commit with %d parents :(" b"found a commit with %d parents :("
) )
% len(commit.parents) % len(commit.parents)
) )
else: else:
patchgen = commit.tree.diff_to_tree( patchgen = commit.tree.diff_to_tree(
swap=True, flags=_DIFF_FLAGS swap=True, flags=_DIFF_FLAGS
) )
new_files = (p.delta.new_file for p in patchgen) new_files = (p.delta.new_file for p in patchgen)
files = { files = {
nf.path: nf.id.hex nf.path: nf.id.hex
for nf in new_files for nf in new_files
if nf.id.raw != nodemod.nullid if nf.id.raw != nullid
} }
for p, n in files.items(): for p, n in files.items():
# We intentionally set NULLs for any file parentage # We intentionally set NULLs for any file parentage
# information so it'll get demand-computed later. We # information so it'll get demand-computed later. We
# used to do it right here, and it was _very_ slow. # used to do it right here, and it was _very_ slow.
db.execute( db.execute(
'INSERT INTO changedfiles (' 'INSERT INTO changedfiles ('
'node, filename, filenode, p1node, p1filenode, p2node, ' 'node, filename, filenode, p1node, p1filenode, p2node, '

hgext/gpg.py

# Copyright 2005, 2006 Benoit Boissinot <benoit.boissinot@ens-lyon.org> # Copyright 2005, 2006 Benoit Boissinot <benoit.boissinot@ens-lyon.org>
# #
# 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.
'''commands to sign and verify changesets''' '''commands to sign and verify changesets'''
from __future__ import absolute_import from __future__ import absolute_import
import binascii import binascii
import os import os
from mercurial.i18n import _ from mercurial.i18n import _
from mercurial.node import (
bin,
hex,
nullid,
short,
)
from mercurial import ( from mercurial import (
cmdutil, cmdutil,
error, error,
help, help,
match, match,
node as hgnode,
pycompat, pycompat,
registrar, registrar,
) )
from mercurial.utils import ( from mercurial.utils import (
dateutil, dateutil,
procutil, procutil,
) )
if not l: if not l:
continue continue
yield (l.split(b" ", 2), (context, ln)) yield (l.split(b" ", 2), (context, ln))
ln += 1 ln += 1
# read the heads # read the heads
fl = repo.file(b".hgsigs") fl = repo.file(b".hgsigs")
for r in reversed(fl.heads()): for r in reversed(fl.heads()):
fn = b".hgsigs|%s" % hgnode.short(r) fn = b".hgsigs|%s" % short(r)
for item in parsefile(fl.read(r).splitlines(), fn): for item in parsefile(fl.read(r).splitlines(), fn):
yield item yield item
try: try:
# read local signatures # read local signatures
fn = b"localsigs" fn = b"localsigs"
for item in parsefile(repo.vfs(fn), fn): for item in parsefile(repo.vfs(fn), fn):
yield item yield item
except IOError: except IOError:
pass pass
def getkeys(ui, repo, mygpg, sigdata, context): def getkeys(ui, repo, mygpg, sigdata, context):
"""get the keys who signed a data""" """get the keys who signed a data"""
fn, ln = context fn, ln = context
node, version, sig = sigdata node, version, sig = sigdata
prefix = b"%s:%d" % (fn, ln) prefix = b"%s:%d" % (fn, ln)
node = hgnode.bin(node) node = bin(node)
data = node2txt(repo, node, version) data = node2txt(repo, node, version)
sig = binascii.a2b_base64(sig) sig = binascii.a2b_base64(sig)
keys = mygpg.verify(data, sig) keys = mygpg.verify(data, sig)
validkeys = [] validkeys = []
# warn for expired key and/or sigs # warn for expired key and/or sigs
for key in keys: for key in keys:
r = repo.changelog.rev(n) r = repo.changelog.rev(n)
keys = getkeys(ui, repo, mygpg, data, context) keys = getkeys(ui, repo, mygpg, data, context)
if not keys: if not keys:
continue continue
revs.setdefault(r, []) revs.setdefault(r, [])
revs[r].extend(keys) revs[r].extend(keys)
for rev in sorted(revs, reverse=True): for rev in sorted(revs, reverse=True):
for k in revs[rev]: for k in revs[rev]:
r = b"%5d:%s" % (rev, hgnode.hex(repo.changelog.node(rev))) r = b"%5d:%s" % (rev, hex(repo.changelog.node(rev)))
ui.write(b"%-30s %s\n" % (keystr(ui, k), r)) ui.write(b"%-30s %s\n" % (keystr(ui, k), r))
@command(b"sigcheck", [], _(b'hg sigcheck REV'), helpcategory=_HELP_CATEGORY) @command(b"sigcheck", [], _(b'hg sigcheck REV'), helpcategory=_HELP_CATEGORY)
def sigcheck(ui, repo, rev): def sigcheck(ui, repo, rev):
"""verify all the signatures there may be for a particular revision""" """verify all the signatures there may be for a particular revision"""
mygpg = newgpg(ui) mygpg = newgpg(ui)
rev = repo.lookup(rev) rev = repo.lookup(rev)
hexrev = hgnode.hex(rev) hexrev = hex(rev)
keys = [] keys = []
for data, context in sigwalk(repo): for data, context in sigwalk(repo):
node, version, sig = data node, version, sig = data
if node == hexrev: if node == hexrev:
k = getkeys(ui, repo, mygpg, data, context) k = getkeys(ui, repo, mygpg, data, context)
if k: if k:
keys.extend(k) keys.extend(k)
if not keys: if not keys:
ui.write(_(b"no valid signature for %s\n") % hgnode.short(rev)) ui.write(_(b"no valid signature for %s\n") % short(rev))
return return
# print summary # print summary
ui.write(_(b"%s is signed by:\n") % hgnode.short(rev)) ui.write(_(b"%s is signed by:\n") % short(rev))
for key in keys: for key in keys:
ui.write(b" %s\n" % keystr(ui, key)) ui.write(b" %s\n" % keystr(ui, key))
def keystr(ui, key): def keystr(ui, key):
"""associate a string to a key (username, comment)""" """associate a string to a key (username, comment)"""
keyid, user, fingerprint = key keyid, user, fingerprint = key
comment = ui.config(b"gpg", fingerprint) comment = ui.config(b"gpg", fingerprint)
date = opts.get(b'date') date = opts.get(b'date')
if date: if date:
opts[b'date'] = dateutil.parsedate(date) opts[b'date'] = dateutil.parsedate(date)
if revs: if revs:
nodes = [repo.lookup(n) for n in revs] nodes = [repo.lookup(n) for n in revs]
else: else:
nodes = [ nodes = [
node for node in repo.dirstate.parents() if node != hgnode.nullid node for node in repo.dirstate.parents() if node != nullid
] ]
if len(nodes) > 1: if len(nodes) > 1:
raise error.Abort( raise error.Abort(
_(b'uncommitted merge - please provide a specific revision') _(b'uncommitted merge - please provide a specific revision')
) )
if not nodes: if not nodes:
nodes = [repo.changelog.tip()] nodes = [repo.changelog.tip()]
for n in nodes: for n in nodes:
hexnode = hgnode.hex(n) hexnode = hex(n)
ui.write( ui.write(
_(b"signing %d:%s\n") % (repo.changelog.rev(n), hgnode.short(n)) _(b"signing %d:%s\n") % (repo.changelog.rev(n), short(n))
) )
# build data # build data
data = node2txt(repo, n, sigver) data = node2txt(repo, n, sigver)
sig = mygpg.sign(data) sig = mygpg.sign(data)
if not sig: if not sig:
raise error.Abort(_(b"error while signing")) raise error.Abort(_(b"error while signing"))
sig = binascii.b2a_base64(sig) sig = binascii.b2a_base64(sig)
sig = sig.replace(b"\n", b"") sig = sig.replace(b"\n", b"")
if opts[b"no_commit"]: if opts[b"no_commit"]:
return return
message = opts[b'message'] message = opts[b'message']
if not message: if not message:
# we don't translate commit messages # we don't translate commit messages
message = b"\n".join( message = b"\n".join(
[ [
b"Added signature for changeset %s" % hgnode.short(n) b"Added signature for changeset %s" % short(n)
for n in nodes for n in nodes
] ]
) )
try: try:
editor = cmdutil.getcommiteditor( editor = cmdutil.getcommiteditor(
editform=b'gpg.sign', **pycompat.strkwargs(opts) editform=b'gpg.sign', **pycompat.strkwargs(opts)
) )
repo.commit( repo.commit(
message, opts[b'user'], opts[b'date'], match=msigs, editor=editor message, opts[b'user'], opts[b'date'], match=msigs, editor=editor
) )
except ValueError as inst: except ValueError as inst:
raise error.Abort(pycompat.bytestr(inst)) raise error.Abort(pycompat.bytestr(inst))
def node2txt(repo, node, ver): def node2txt(repo, node, ver):
"""map a manifest into some text""" """map a manifest into some text"""
if ver == b"0": if ver == b"0":
return b"%s\n" % hgnode.hex(node) return b"%s\n" % hex(node)
else: else:
raise error.Abort(_(b"unknown signature version")) raise error.Abort(_(b"unknown signature version"))
def extsetup(ui): def extsetup(ui):
# Add our category before "Repository maintenance". # Add our category before "Repository maintenance".
help.CATEGORY_ORDER.insert( help.CATEGORY_ORDER.insert(
help.CATEGORY_ORDER.index(command.CATEGORY_MAINTENANCE), _HELP_CATEGORY help.CATEGORY_ORDER.index(command.CATEGORY_MAINTENANCE), _HELP_CATEGORY
) )
help.CATEGORY_NAMES[_HELP_CATEGORY] = b'GPG signing' help.CATEGORY_NAMES[_HELP_CATEGORY] = b'GPG signing'

hgext/histedit.py

import os import os
import struct import struct
from mercurial.i18n import _ from mercurial.i18n import _
from mercurial.pycompat import ( from mercurial.pycompat import (
getattr, getattr,
open, open,
) )
from mercurial.node import (
bin,
hex,
short,
)
from mercurial import ( from mercurial import (
bundle2, bundle2,
cmdutil, cmdutil,
context, context,
copies, copies,
destutil, destutil,
discovery, discovery,
encoding, encoding,
error, error,
exchange, exchange,
extensions, extensions,
hg, hg,
logcmdutil, logcmdutil,
merge as mergemod, merge as mergemod,
mergestate as mergestatemod, mergestate as mergestatemod,
mergeutil, mergeutil,
node,
obsolete, obsolete,
pycompat, pycompat,
registrar, registrar,
repair, repair,
rewriteutil, rewriteutil,
scmutil, scmutil,
state as statemod, state as statemod,
util, util,
location=b'plain', location=b'plain',
) )
else: else:
with self.repo.vfs(b"histedit-state", b"w") as f: with self.repo.vfs(b"histedit-state", b"w") as f:
self._write(f) self._write(f)
def _write(self, fp): def _write(self, fp):
fp.write(b'v1\n') fp.write(b'v1\n')
fp.write(b'%s\n' % node.hex(self.parentctxnode)) fp.write(b'%s\n' % hex(self.parentctxnode))
fp.write(b'%s\n' % node.hex(self.topmost)) fp.write(b'%s\n' % hex(self.topmost))
fp.write(b'%s\n' % (b'True' if self.keep else b'False')) fp.write(b'%s\n' % (b'True' if self.keep else b'False'))
fp.write(b'%d\n' % len(self.actions)) fp.write(b'%d\n' % len(self.actions))
for action in self.actions: for action in self.actions:
fp.write(b'%s\n' % action.tostate()) fp.write(b'%s\n' % action.tostate())
fp.write(b'%d\n' % len(self.replacements)) fp.write(b'%d\n' % len(self.replacements))
for replacement in self.replacements: for replacement in self.replacements:
fp.write( fp.write(
b'%s%s\n' b'%s%s\n'
% ( % (
node.hex(replacement[0]), hex(replacement[0]),
b''.join(node.hex(r) for r in replacement[1]), b''.join(hex(r) for r in replacement[1]),
) )
) )
backupfile = self.backupfile backupfile = self.backupfile
if not backupfile: if not backupfile:
backupfile = b'' backupfile = b''
fp.write(b'%s\n' % backupfile) fp.write(b'%s\n' % backupfile)
def _load(self): def _load(self):
fp = self.repo.vfs(b'histedit-state', b'r') fp = self.repo.vfs(b'histedit-state', b'r')
lines = [l[:-1] for l in fp.readlines()] lines = [l[:-1] for l in fp.readlines()]
index = 0 index = 0
lines[index] # version number lines[index] # version number
index += 1 index += 1
parentctxnode = node.bin(lines[index]) parentctxnode = bin(lines[index])
index += 1 index += 1
topmost = node.bin(lines[index]) topmost = bin(lines[index])
index += 1 index += 1
keep = lines[index] == b'True' keep = lines[index] == b'True'
index += 1 index += 1
# Rules # Rules
rules = [] rules = []
rulelen = int(lines[index]) rulelen = int(lines[index])
index += 1 index += 1
for i in pycompat.xrange(rulelen): for i in pycompat.xrange(rulelen):
ruleaction = lines[index] ruleaction = lines[index]
index += 1 index += 1
rule = lines[index] rule = lines[index]
index += 1 index += 1
rules.append((ruleaction, rule)) rules.append((ruleaction, rule))
# Replacements # Replacements
replacements = [] replacements = []
replacementlen = int(lines[index]) replacementlen = int(lines[index])
index += 1 index += 1
for i in pycompat.xrange(replacementlen): for i in pycompat.xrange(replacementlen):
replacement = lines[index] replacement = lines[index]
original = node.bin(replacement[:40]) original = bin(replacement[:40])
succ = [ succ = [
node.bin(replacement[i : i + 40]) bin(replacement[i : i + 40])
for i in range(40, len(replacement), 40) for i in range(40, len(replacement), 40)
] ]
replacements.append((original, succ)) replacements.append((original, succ))
index += 1 index += 1
backupfile = lines[index] backupfile = lines[index]
index += 1 index += 1
@classmethod @classmethod
def fromrule(cls, state, rule): def fromrule(cls, state, rule):
"""Parses the given rule, returning an instance of the histeditaction.""" """Parses the given rule, returning an instance of the histeditaction."""
ruleid = rule.strip().split(b' ', 1)[0] ruleid = rule.strip().split(b' ', 1)[0]
# ruleid can be anything from rev numbers, hashes, "bookmarks" etc # ruleid can be anything from rev numbers, hashes, "bookmarks" etc
# Check for validation of rule ids and get the rulehash # Check for validation of rule ids and get the rulehash
try: try:
rev = node.bin(ruleid) rev = bin(ruleid)
except TypeError: except TypeError:
try: try:
_ctx = scmutil.revsingle(state.repo, ruleid) _ctx = scmutil.revsingle(state.repo, ruleid)
rulehash = _ctx.hex() rulehash = _ctx.hex()
rev = node.bin(rulehash) rev = bin(rulehash)
except error.RepoLookupError: except error.RepoLookupError:
raise error.ParseError(_(b"invalid changeset %s") % ruleid) raise error.ParseError(_(b"invalid changeset %s") % ruleid)
return cls(state, rev) return cls(state, rev)
def verify(self, prev, expected, seen): def verify(self, prev, expected, seen):
""" Verifies semantic correctness of the rule""" """ Verifies semantic correctness of the rule"""
repo = self.repo repo = self.repo
ha = node.hex(self.node) ha = hex(self.node)
self.node = scmutil.resolvehexnodeidprefix(repo, ha) self.node = scmutil.resolvehexnodeidprefix(repo, ha)
if self.node is None: if self.node is None:
raise error.ParseError(_(b'unknown changeset %s listed') % ha[:12]) raise error.ParseError(_(b'unknown changeset %s listed') % ha[:12])
self._verifynodeconstraints(prev, expected, seen) self._verifynodeconstraints(prev, expected, seen)
def _verifynodeconstraints(self, prev, expected, seen): def _verifynodeconstraints(self, prev, expected, seen):
# by default command need a node in the edited list # by default command need a node in the edited list
if self.node not in expected: if self.node not in expected:
raise error.ParseError( raise error.ParseError(
_(b'%s "%s" changeset was not a candidate') _(b'%s "%s" changeset was not a candidate')
% (self.verb, node.short(self.node)), % (self.verb, short(self.node)),
hint=_(b'only use listed changesets'), hint=_(b'only use listed changesets'),
) )
# and only one command per node # and only one command per node
if self.node in seen: if self.node in seen:
raise error.ParseError( raise error.ParseError(
_(b'duplicated command for changeset %s') _(b'duplicated command for changeset %s')
% node.short(self.node) % short(self.node)
) )
def torule(self): def torule(self):
"""build a histedit rule line for an action """build a histedit rule line for an action
by default lines are in the form: by default lines are in the form:
<hash> <rev> <summary> <hash> <rev> <summary>
""" """
maxlen = self.repo.ui.configint(b'histedit', b'linelen') maxlen = self.repo.ui.configint(b'histedit', b'linelen')
maxlen = max(maxlen, 22) # avoid truncating hash maxlen = max(maxlen, 22) # avoid truncating hash
return stringutil.ellipsis(line, maxlen) return stringutil.ellipsis(line, maxlen)
def tostate(self): def tostate(self):
"""Print an action in format used by histedit state files """Print an action in format used by histedit state files
(the first line is a verb, the remainder is the second) (the first line is a verb, the remainder is the second)
""" """
return b"%s\n%s" % (self.verb, node.hex(self.node)) return b"%s\n%s" % (self.verb, hex(self.node))
def run(self): def run(self):
"""Runs the action. The default behavior is simply apply the action's """Runs the action. The default behavior is simply apply the action's
rulectx onto the current parentctx.""" rulectx onto the current parentctx."""
self.applychange() self.applychange()
self.continuedirty() self.continuedirty()
return self.continueclean() return self.continueclean()
def applychange(self): def applychange(self):
"""Applies the changes from this action's rulectx onto the current """Applies the changes from this action's rulectx onto the current
parentctx, but does not commit them.""" parentctx, but does not commit them."""
repo = self.repo repo = self.repo
rulectx = repo[self.node] rulectx = repo[self.node]
repo.ui.pushbuffer(error=True, labeled=True) repo.ui.pushbuffer(error=True, labeled=True)
hg.update(repo, self.state.parentctxnode, quietempty=True) hg.update(repo, self.state.parentctxnode, quietempty=True)
repo.ui.popbuffer() repo.ui.popbuffer()
stats = applychanges(repo.ui, repo, rulectx, {}) stats = applychanges(repo.ui, repo, rulectx, {})
repo.dirstate.setbranch(rulectx.branch()) repo.dirstate.setbranch(rulectx.branch())
if stats.unresolvedcount: if stats.unresolvedcount:
raise error.InterventionRequired( raise error.InterventionRequired(
_(b'Fix up the change (%s %s)') _(b'Fix up the change (%s %s)')
% (self.verb, node.short(self.node)), % (self.verb, short(self.node)),
hint=_(b'hg histedit --continue to resume'), hint=_(b'hg histedit --continue to resume'),
) )
def continuedirty(self): def continuedirty(self):
"""Continues the action when changes have been applied to the working """Continues the action when changes have been applied to the working
copy. The default behavior is to commit the dirty changes.""" copy. The default behavior is to commit the dirty changes."""
repo = self.repo repo = self.repo
rulectx = repo[self.node] rulectx = repo[self.node]
def continueclean(self): def continueclean(self):
"""Continues the action when the working copy is clean. The default """Continues the action when the working copy is clean. The default
behavior is to accept the current commit as the new version of the behavior is to accept the current commit as the new version of the
rulectx.""" rulectx."""
ctx = self.repo[b'.'] ctx = self.repo[b'.']
if ctx.node() == self.state.parentctxnode: if ctx.node() == self.state.parentctxnode:
self.repo.ui.warn( self.repo.ui.warn(
_(b'%s: skipping changeset (no changes)\n') _(b'%s: skipping changeset (no changes)\n')
% node.short(self.node) % short(self.node)
) )
return ctx, [(self.node, tuple())] return ctx, [(self.node, tuple())]
if ctx.node() == self.node: if ctx.node() == self.node:
# Nothing changed # Nothing changed
return ctx, [] return ctx, []
return ctx, [(self.node, (ctx.node(),))] return ctx, [(self.node, (ctx.node(),))]
This function works in memory.""" This function works in memory."""
ctxs = list(repo.set(b'%d::%d', firstctx.rev(), lastctx.rev())) ctxs = list(repo.set(b'%d::%d', firstctx.rev(), lastctx.rev()))
if not ctxs: if not ctxs:
return None return None
for c in ctxs: for c in ctxs:
if not c.mutable(): if not c.mutable():
raise error.ParseError( raise error.ParseError(
_(b"cannot fold into public change %s") % node.short(c.node()) _(b"cannot fold into public change %s") % short(c.node())
) )
base = firstctx.p1() base = firstctx.p1()
# commit a new version of the old changeset, including the update # commit a new version of the old changeset, including the update
# collect all files which might be affected # collect all files which might be affected
files = set() files = set()
for ctx in ctxs: for ctx in ctxs:
files.update(ctx.files()) files.update(ctx.files())
return wrap return wrap
@action([b'pick', b'p'], _(b'use commit'), priority=True) @action([b'pick', b'p'], _(b'use commit'), priority=True)
class pick(histeditaction): class pick(histeditaction):
def run(self): def run(self):
rulectx = self.repo[self.node] rulectx = self.repo[self.node]
if rulectx.p1().node() == self.state.parentctxnode: if rulectx.p1().node() == self.state.parentctxnode:
self.repo.ui.debug(b'node %s unchanged\n' % node.short(self.node)) self.repo.ui.debug(b'node %s unchanged\n' % short(self.node))
return rulectx, [] return rulectx, []
return super(pick, self).run() return super(pick, self).run()
@action([b'edit', b'e'], _(b'use commit, but allow edits before making new commit'), priority=True) @action([b'edit', b'e'], _(b'use commit, but allow edits before making new commit'), priority=True)
class edit(histeditaction): class edit(histeditaction):
def run(self): def run(self):
repo = self.repo repo = self.repo
rulectx = repo[self.node] rulectx = repo[self.node]
hg.update(repo, self.state.parentctxnode, quietempty=True) hg.update(repo, self.state.parentctxnode, quietempty=True)
applychanges(repo.ui, repo, rulectx, {}) applychanges(repo.ui, repo, rulectx, {})
hint = _(b'to edit %s, `hg histedit --continue` after making changes') hint = _(b'to edit %s, `hg histedit --continue` after making changes')
raise error.InterventionRequired( raise error.InterventionRequired(
_(b'Editing (%s), commit as needed now to split the change') _(b'Editing (%s), commit as needed now to split the change')
% node.short(self.node), % short(self.node),
hint=hint % node.short(self.node), hint=hint % short(self.node),
) )
def commiteditor(self): def commiteditor(self):
return cmdutil.getcommiteditor(edit=True, editform=b'histedit.edit') return cmdutil.getcommiteditor(edit=True, editform=b'histedit.edit')
@action([b'fold', b'f'], _(b'use commit, but combine it with the one above')) @action([b'fold', b'f'], _(b'use commit, but combine it with the one above'))
class fold(histeditaction): class fold(histeditaction):
def verify(self, prev, expected, seen): def verify(self, prev, expected, seen):
""" Verifies semantic correctness of the fold rule""" """ Verifies semantic correctness of the fold rule"""
super(fold, self).verify(prev, expected, seen) super(fold, self).verify(prev, expected, seen)
repo = self.repo repo = self.repo
if not prev: if not prev:
c = repo[self.node].p1() c = repo[self.node].p1()
elif not prev.verb in (b'pick', b'base'): elif not prev.verb in (b'pick', b'base'):
return return
else: else:
c = repo[prev.node] c = repo[prev.node]
if not c.mutable(): if not c.mutable():
raise error.ParseError( raise error.ParseError(
_(b"cannot fold into public change %s") % node.short(c.node()) _(b"cannot fold into public change %s") % short(c.node())
) )
def continuedirty(self): def continuedirty(self):
repo = self.repo repo = self.repo
rulectx = repo[self.node] rulectx = repo[self.node]
commit = commitfuncfor(repo, rulectx) commit = commitfuncfor(repo, rulectx)
commit( commit(
text=b'fold-temp-revision %s' % node.short(self.node), text=b'fold-temp-revision %s' % short(self.node),
user=rulectx.user(), user=rulectx.user(),
date=rulectx.date(), date=rulectx.date(),
extra=rulectx.extra(), extra=rulectx.extra(),
) )
def continueclean(self): def continueclean(self):
repo = self.repo repo = self.repo
ctx = repo[b'.'] ctx = repo[b'.']
rulectx = repo[self.node] rulectx = repo[self.node]
parentctxnode = self.state.parentctxnode parentctxnode = self.state.parentctxnode
if ctx.node() == parentctxnode: if ctx.node() == parentctxnode:
repo.ui.warn(_(b'%s: empty changeset\n') % node.short(self.node)) repo.ui.warn(_(b'%s: empty changeset\n') % short(self.node))
return ctx, [(self.node, (parentctxnode,))] return ctx, [(self.node, (parentctxnode,))]
parentctx = repo[parentctxnode] parentctx = repo[parentctxnode]
newcommits = { newcommits = {
c.node() c.node()
for c in repo.set(b'(%d::. - %d)', parentctx.rev(), parentctx.rev()) for c in repo.set(b'(%d::. - %d)', parentctx.rev(), parentctx.rev())
} }
if not newcommits: if not newcommits:
repo.ui.warn( repo.ui.warn(
_( _(
b'%s: cannot fold - working copy is not a ' b'%s: cannot fold - working copy is not a '
b'descendant of previous commit %s\n' b'descendant of previous commit %s\n'
) )
% (node.short(self.node), node.short(parentctxnode)) % (short(self.node), short(parentctxnode))
) )
return ctx, [(self.node, (ctx.node(),))] return ctx, [(self.node, (ctx.node(),))]
middlecommits = newcommits.copy() middlecommits = newcommits.copy()
middlecommits.discard(ctx.node()) middlecommits.discard(ctx.node())
return self.finishfold( return self.finishfold(
repo.ui, repo, parentctx, rulectx, ctx.node(), middlecommits repo.ui, repo, parentctx, rulectx, ctx.node(), middlecommits
basectx = self.repo[b'.'] basectx = self.repo[b'.']
return basectx, [] return basectx, []
def _verifynodeconstraints(self, prev, expected, seen): def _verifynodeconstraints(self, prev, expected, seen):
# base can only be use with a node not in the edited set # base can only be use with a node not in the edited set
if self.node in expected: if self.node in expected:
msg = _(b'%s "%s" changeset was an edited list candidate') msg = _(b'%s "%s" changeset was an edited list candidate')
raise error.ParseError( raise error.ParseError(
msg % (self.verb, node.short(self.node)), msg % (self.verb, short(self.node)),
hint=_(b'base must only use unlisted changesets'), hint=_(b'base must only use unlisted changesets'),
) )
@action( @action(
[b'_multifold'], [b'_multifold'],
_( _(
"""fold subclass used for when multiple folds happen in a row """fold subclass used for when multiple folds happen in a row
) )
root = rr[0].node() root = rr[0].node()
topmost = repo.dirstate.p1() topmost = repo.dirstate.p1()
revs = between(repo, root, topmost, keep) revs = between(repo, root, topmost, keep)
if not revs: if not revs:
raise error.Abort( raise error.Abort(
_(b'%s is not an ancestor of working directory') _(b'%s is not an ancestor of working directory')
% node.short(root) % short(root)
) )
ctxs = [] ctxs = []
for i, r in enumerate(revs): for i, r in enumerate(revs):
ctxs.append(histeditrule(ui, repo[r], i)) ctxs.append(histeditrule(ui, repo[r], i))
with util.with_lc_ctype(): with util.with_lc_ctype():
rc = curses.wrapper(functools.partial(_chisteditmain, repo, ctxs)) rc = curses.wrapper(functools.partial(_chisteditmain, repo, ctxs))
curses.echo() curses.echo()
def _finishhistedit(ui, repo, state, fm): def _finishhistedit(ui, repo, state, fm):
"""This action runs when histedit is finishing its session""" """This action runs when histedit is finishing its session"""
mergemod.update(repo[state.parentctxnode]) mergemod.update(repo[state.parentctxnode])
mapping, tmpnodes, created, ntm = processreplacement(state) mapping, tmpnodes, created, ntm = processreplacement(state)
if mapping: if mapping:
for prec, succs in pycompat.iteritems(mapping): for prec, succs in 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' % 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])) % (short(prec), short(succs[0]))
) )
if len(succs) > 1: if len(succs) > 1:
m = b'histedit: %s' m = b'histedit: %s'
for n in succs[1:]: for n in succs[1:]:
ui.debug(m % node.short(n)) ui.debug(m % short(n))
if not state.keep: if not state.keep:
if mapping: if mapping:
movetopmostbookmarks(repo, state.topmost, ntm) movetopmostbookmarks(repo, state.topmost, ntm)
# TODO update mq state # TODO update mq state
else: else:
mapping = {} mapping = {}
if repo.vfs.exists(b'histedit-last-edit.txt'): if repo.vfs.exists(b'histedit-last-edit.txt'):
repo.vfs.unlink(b'histedit-last-edit.txt') repo.vfs.unlink(b'histedit-last-edit.txt')
def _aborthistedit(ui, repo, state, nobackup=False): def _aborthistedit(ui, repo, state, nobackup=False):
try: try:
state.read() state.read()
__, leafs, tmpnodes, __ = processreplacement(state) __, leafs, tmpnodes, __ = processreplacement(state)
ui.debug(b'restore wc to old parent %s\n' % node.short(state.topmost)) ui.debug(b'restore wc to old parent %s\n' % short(state.topmost))
# Recover our old commits if necessary # Recover our old commits if necessary
if not state.topmost in repo and state.backupfile: if not state.topmost in repo and state.backupfile:
backupfile = repo.vfs.join(state.backupfile) backupfile = repo.vfs.join(state.backupfile)
f = hg.openpath(ui, backupfile) f = hg.openpath(ui, backupfile)
gen = exchange.readbundle(ui, f, backupfile) gen = exchange.readbundle(ui, f, backupfile)
with repo.transaction(b'histedit.abort') as tr: with repo.transaction(b'histedit.abort') as tr:
bundle2.applybundle( bundle2.applybundle(
state.lock = lock state.lock = lock
_aborthistedit(ui, repo, state, nobackup=nobackup) _aborthistedit(ui, repo, state, nobackup=nobackup)
def _edithisteditplan(ui, repo, state, rules): def _edithisteditplan(ui, repo, state, rules):
state.read() state.read()
if not rules: if not rules:
comment = geteditcomment( comment = geteditcomment(
ui, node.short(state.parentctxnode), node.short(state.topmost) ui, short(state.parentctxnode), short(state.topmost)
) )
rules = ruleeditor(repo, ui, state.actions, comment) rules = ruleeditor(repo, ui, state.actions, comment)
else: else:
rules = _readfile(ui, rules) rules = _readfile(ui, rules)
actions = parserules(rules, state) actions = parserules(rules, state)
ctxs = [repo[act.node] for act in state.actions if act.node] ctxs = [repo[act.node] for act in state.actions if act.node]
warnverifyactions(ui, repo, actions, state, ctxs) warnverifyactions(ui, repo, actions, state, ctxs)
state.actions = actions state.actions = actions
b'exactly one common root' b'exactly one common root'
) )
) )
root = rr[0].node() root = rr[0].node()
revs = between(repo, root, topmost, state.keep) revs = between(repo, root, topmost, state.keep)
if not revs: if not revs:
raise error.Abort( raise error.Abort(
_(b'%s is not an ancestor of working directory') % node.short(root) _(b'%s is not an ancestor of working directory') % short(root)
) )
ctxs = [repo[r] for r in revs] ctxs = [repo[r] for r in revs]
wctx = repo[None] wctx = repo[None]
# Please don't ask me why `ancestors` is this value. I figured it # Please don't ask me why `ancestors` is this value. I figured it
# out with print-debugging, not by actually understanding what the # out with print-debugging, not by actually understanding what the
# merge code is doing. :( # merge code is doing. :(
raise error.Abort( raise error.Abort(
_( _(
b"untracked files in working directory conflict with files in %s" b"untracked files in working directory conflict with files in %s"
) )
% c % c
) )
if not rules: if not rules:
comment = geteditcomment(ui, node.short(root), node.short(topmost)) comment = geteditcomment(ui, short(root), short(topmost))
actions = [pick(state, r) for r in revs] actions = [pick(state, r) for r in revs]
rules = ruleeditor(repo, ui, actions, comment) rules = ruleeditor(repo, ui, actions, comment)
else: else:
rules = _readfile(ui, rules) rules = _readfile(ui, rules)
actions = parserules(rules, state) actions = parserules(rules, state)
warnverifyactions(ui, repo, actions, state, ctxs) warnverifyactions(ui, repo, actions, state, ctxs)
parentctxnode = repo[root].p1().node() parentctxnode = repo[root].p1().node()
) )
drops = [drop(state, n) for n in missing] drops = [drop(state, n) for n in missing]
# put the in the beginning so they execute immediately and # put the in the beginning so they execute immediately and
# don't show in the edit-plan in the future # don't show in the edit-plan in the future
actions[:0] = drops actions[:0] = drops
elif missing: elif missing:
raise error.ParseError( raise error.ParseError(
_(b'missing rules for changeset %s') % node.short(missing[0]), _(b'missing rules for changeset %s') % short(missing[0]),
hint=_( hint=_(
b'use "drop %s" to discard, see also: ' b'use "drop %s" to discard, see also: '
b"'hg help -e histedit.config'" b"'hg help -e histedit.config'"
) )
% node.short(missing[0]), % short(missing[0]),
) )
def adjustreplacementsfrommarkers(repo, oldreplacements): def adjustreplacementsfrommarkers(repo, oldreplacements):
"""Adjust replacements from obsolescence markers """Adjust replacements from obsolescence markers
Replacements structure is originally generated based on Replacements structure is originally generated based on
histedit's state and does not account for changes that are histedit's state and does not account for changes that are
state.read() state.read()
histedit_nodes = { histedit_nodes = {
action.node for action in state.actions if action.node action.node for action in state.actions if action.node
} }
common_nodes = histedit_nodes & set(nodelist) common_nodes = histedit_nodes & set(nodelist)
if common_nodes: if common_nodes:
raise error.Abort( raise error.Abort(
_(b"histedit in progress, can't strip %s") _(b"histedit in progress, can't strip %s")
% b', '.join(node.short(x) for x in common_nodes) % b', '.join(short(x) for x in common_nodes)
) )
return orig(ui, repo, nodelist, *args, **kwargs) return orig(ui, repo, nodelist, *args, **kwargs)
extensions.wrapfunction(repair, b'strip', stripwrapper) extensions.wrapfunction(repair, b'strip', stripwrapper)
def summaryhook(ui, repo): def summaryhook(ui, repo):

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.node import hex
from mercurial import ( from mercurial import (
bundle2, bundle2,
changegroup, changegroup,
error, error,
extensions, extensions,
node as nodemod,
pycompat, pycompat,
revsetlang, revsetlang,
util, util,
) )
from . import common from . import common
isremotebooksenabled = common.isremotebooksenabled isremotebooksenabled = common.isremotebooksenabled
params = {} params = {}
params[b'cgversion'] = cgversion params[b'cgversion'] = cgversion
if bookmark: if bookmark:
params[b'bookmark'] = bookmark params[b'bookmark'] = bookmark
# 'prevbooknode' is necessary for pushkey reply part # 'prevbooknode' is necessary for pushkey reply part
params[b'bookprevnode'] = b'' params[b'bookprevnode'] = b''
bookmarks = repo._bookmarks bookmarks = repo._bookmarks
if bookmark in bookmarks: if bookmark in bookmarks:
params[b'bookprevnode'] = nodemod.hex(bookmarks[bookmark]) params[b'bookprevnode'] = hex(bookmarks[bookmark])
# Do not send pushback bundle2 part with bookmarks if remotenames extension # Do not send pushback bundle2 part with bookmarks if remotenames extension
# is enabled. It will be handled manually in `_push()` # is enabled. It will be handled manually in `_push()`
if not isremotebooksenabled(ui): if not isremotebooksenabled(ui):
params[b'pushbackbookmarks'] = b'1' params[b'pushbackbookmarks'] = b'1'
parts = [] parts = []

hgext/infinitepush/store.py

# This software may be used and distributed according to the terms of the # This software may be used and distributed according to the terms of the
# GNU General Public License version 2 or any later version. # GNU General Public License version 2 or any later version.
# based on bundleheads extension by Gregory Szorc <gps@mozilla.com> # based on bundleheads extension by Gregory Szorc <gps@mozilla.com>
from __future__ import absolute_import from __future__ import absolute_import
import abc import abc
import os import os
import subprocess import subprocess
from mercurial.node import hex
from mercurial.pycompat import open from mercurial.pycompat import open
from mercurial import ( from mercurial import pycompat
node,
pycompat,
)
from mercurial.utils import ( from mercurial.utils import (
hashutil, hashutil,
procutil, procutil,
) )
class BundleWriteException(Exception): class BundleWriteException(Exception):
pass pass
level directory, next two bytes are the name of the level directory, next two bytes are the name of the
next level directory""" next level directory"""
return os.path.join(self.storepath, hashvalue[0:2], hashvalue[2:4]) return os.path.join(self.storepath, hashvalue[0:2], hashvalue[2:4])
def _filepath(self, filename): def _filepath(self, filename):
return os.path.join(self._dirpath(filename), filename) return os.path.join(self._dirpath(filename), filename)
def write(self, data): def write(self, data):
filename = node.hex(hashutil.sha1(data).digest()) filename = hex(hashutil.sha1(data).digest())
dirpath = self._dirpath(filename) dirpath = self._dirpath(filename)
if not os.path.exists(dirpath): if not os.path.exists(dirpath):
os.makedirs(dirpath) os.makedirs(dirpath)
with open(self._filepath(filename), b'wb') as f: with open(self._filepath(filename), b'wb') as f:
f.write(data) f.write(data)

hgext/journal.py

from __future__ import absolute_import from __future__ import absolute_import
import collections import collections
import errno import errno
import os import os
import weakref import weakref
from mercurial.i18n import _ from mercurial.i18n import _
from mercurial.node import (
bin,
hex,
nullid,
)
from mercurial import ( from mercurial import (
bookmarks, bookmarks,
cmdutil, cmdutil,
dispatch, dispatch,
encoding, encoding,
error, error,
extensions, extensions,
hg, hg,
localrepo, localrepo,
lock, lock,
logcmdutil, logcmdutil,
node,
pycompat, pycompat,
registrar, registrar,
util, util,
) )
from mercurial.utils import ( from mercurial.utils import (
dateutil, dateutil,
procutil, procutil,
stringutil, stringutil,
def recorddirstateparents(dirstate, old, new): def recorddirstateparents(dirstate, old, new):
"""Records all dirstate parent changes in the journal.""" """Records all dirstate parent changes in the journal."""
old = list(old) old = list(old)
new = list(new) new = list(new)
if util.safehasattr(dirstate, 'journalstorage'): if util.safehasattr(dirstate, 'journalstorage'):
# only record two hashes if there was a merge # only record two hashes if there was a merge
oldhashes = old[:1] if old[1] == node.nullid else old oldhashes = old[:1] if old[1] == nullid else old
newhashes = new[:1] if new[1] == node.nullid else new newhashes = new[:1] if new[1] == nullid else new
dirstate.journalstorage.record( dirstate.journalstorage.record(
wdirparenttype, b'.', oldhashes, newhashes wdirparenttype, b'.', oldhashes, newhashes
) )
# hooks to record bookmark changes (both local and remote) # hooks to record bookmark changes (both local and remote)
def recordbookmarks(orig, store, fp): def recordbookmarks(orig, store, fp):
"""Records all bookmark changes in the journal.""" """Records all bookmark changes in the journal."""
repo = store._repo repo = store._repo
if util.safehasattr(repo, 'journal'): if util.safehasattr(repo, 'journal'):
oldmarks = bookmarks.bmstore(repo) oldmarks = bookmarks.bmstore(repo)
for mark, value in pycompat.iteritems(store): for mark, value in pycompat.iteritems(store):
oldvalue = oldmarks.get(mark, node.nullid) oldvalue = oldmarks.get(mark, 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):
"""A set of shared features for this repository""" """A set of shared features for this repository"""
command, command,
namespace, namespace,
name, name,
oldhashes, oldhashes,
newhashes, newhashes,
) = line.split(b'\n') ) = line.split(b'\n')
timestamp, tz = time.split() timestamp, tz = time.split()
timestamp, tz = float(timestamp), int(tz) timestamp, tz = float(timestamp), int(tz)
oldhashes = tuple(node.bin(hash) for hash in oldhashes.split(b',')) oldhashes = tuple(bin(hash) for hash in oldhashes.split(b','))
newhashes = tuple(node.bin(hash) for hash in newhashes.split(b',')) newhashes = tuple(bin(hash) for hash in newhashes.split(b','))
return cls( return cls(
(timestamp, tz), (timestamp, tz),
user, user,
command, command,
namespace, namespace,
name, name,
oldhashes, oldhashes,
newhashes, newhashes,
) )
def __bytes__(self): def __bytes__(self):
"""bytes representation for storage""" """bytes representation for storage"""
time = b' '.join(map(pycompat.bytestr, self.timestamp)) time = b' '.join(map(pycompat.bytestr, self.timestamp))
oldhashes = b','.join([node.hex(hash) for hash in self.oldhashes]) oldhashes = b','.join([hex(hash) for hash in self.oldhashes])
newhashes = b','.join([node.hex(hash) for hash in self.newhashes]) newhashes = b','.join([hex(hash) for hash in self.newhashes])
return b'\n'.join( return b'\n'.join(
( (
time, time,
self.user, self.user,
self.command, self.command,
self.namespace, self.namespace,
self.name, self.name,
oldhashes, oldhashes,

hgext/largefiles/lfcommands.py

# Copyright 2009-2010 Gregory P. Ward # Copyright 2009-2010 Gregory P. Ward
# Copyright 2009-2010 Intelerad Medical Systems Incorporated # Copyright 2009-2010 Intelerad Medical Systems Incorporated
# 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.
'''High-level command function for lfconvert, plus the cmdtable.''' '''High-level command function for lfconvert, plus the cmdtable.'''
from __future__ import absolute_import from __future__ import absolute_import
import errno import errno
import os import os
import shutil import shutil
from mercurial.i18n import _ from mercurial.i18n import _
from mercurial.node import (
bin,
hex,
nullid,
)
from mercurial import ( from mercurial import (
cmdutil, cmdutil,
context, context,
error, error,
exthelper, exthelper,
hg, hg,
lock, lock,
match as matchmod, match as matchmod,
node,
pycompat, pycompat,
scmutil, scmutil,
util, util,
) )
from mercurial.utils import hashutil from mercurial.utils import hashutil
from ..convert import ( from ..convert import (
convcmd, convcmd,
# Get a list of all changesets in the source. The easy way to do this # Get a list of all changesets in the source. The easy way to do this
# is to simply walk the changelog, using changelog.nodesbetween(). # is to simply walk the changelog, using changelog.nodesbetween().
# Take a look at mercurial/revlog.py:639 for more details. # Take a look at mercurial/revlog.py:639 for more details.
# Use a generator instead of a list to decrease memory usage # Use a generator instead of a list to decrease memory usage
ctxs = ( ctxs = (
rsrc[ctx] rsrc[ctx]
for ctx in rsrc.changelog.nodesbetween(None, rsrc.heads())[0] for ctx in rsrc.changelog.nodesbetween(None, rsrc.heads())[0]
) )
revmap = {node.nullid: node.nullid} revmap = {nullid: nullid}
if tolfile: if tolfile:
# Lock destination to prevent modification while it is converted to. # Lock destination to prevent modification while it is converted to.
# Don't need to lock src because we are just reading from its # Don't need to lock src because we are just reading from its
# history which can't change. # history which can't change.
dstwlock = rdst.wlock() dstwlock = rdst.wlock()
dstlock = rdst.lock() dstlock = rdst.lock()
lfiles = set() lfiles = set()
if renamed and renamed in lfiles: if renamed and renamed in lfiles:
raise error.Abort( raise error.Abort(
_(b'largefile %s becomes symlink') % f _(b'largefile %s becomes symlink') % f
) )
# largefile was modified, update standins # largefile was modified, update standins
m = hashutil.sha1(b'') m = hashutil.sha1(b'')
m.update(ctx[f].data()) m.update(ctx[f].data())
hash = node.hex(m.digest()) hash = hex(m.digest())
if f not in lfiletohash or lfiletohash[f] != hash: if f not in lfiletohash or lfiletohash[f] != hash:
rdst.wwrite(f, ctx[f].data(), ctx[f].flags()) rdst.wwrite(f, ctx[f].data(), ctx[f].flags())
executable = b'x' in ctx[f].flags() executable = b'x' in ctx[f].flags()
lfutil.writestandin(rdst, fstandin, hash, executable) lfutil.writestandin(rdst, fstandin, hash, executable)
lfiletohash[f] = hash lfiletohash[f] = hash
else: else:
# normal file # normal file
dstfiles.append(f) dstfiles.append(f)
lfutil.copyalltostore(rdst, ret) lfutil.copyalltostore(rdst, ret)
rdst.setparents(ret) rdst.setparents(ret)
revmap[ctx.node()] = rdst.changelog.tip() revmap[ctx.node()] = rdst.changelog.tip()
# Generate list of changed files # Generate list of changed files
def _getchangedfiles(ctx, parents): def _getchangedfiles(ctx, parents):
files = set(ctx.files()) files = set(ctx.files())
if node.nullid not in parents: if nullid not in parents:
mc = ctx.manifest() mc = ctx.manifest()
for pctx in ctx.parents(): for pctx in ctx.parents():
for fn in pctx.manifest().diff(mc): for fn in pctx.manifest().diff(mc):
files.add(fn) files.add(fn)
return files return files
# Convert src parents to dst parents # Convert src parents to dst parents
def _convertparents(ctx, revmap): def _convertparents(ctx, revmap):
parents = [] parents = []
for p in ctx.parents(): for p in ctx.parents():
parents.append(revmap[p.node()]) parents.append(revmap[p.node()])
while len(parents) < 2: while len(parents) < 2:
parents.append(node.nullid) parents.append(nullid)
return parents return parents
# Get memfilectx for a normal file # Get memfilectx for a normal file
def _getnormalcontext(repo, ctx, f, revmap): def _getnormalcontext(repo, ctx, f, revmap):
try: try:
fctx = ctx.filectx(f) fctx = ctx.filectx(f)
except error.LookupError: except error.LookupError:
newdata = [] newdata = []
for line in data.splitlines(): for line in data.splitlines():
try: try:
id, name = line.split(b' ', 1) id, name = line.split(b' ', 1)
except ValueError: except ValueError:
ui.warn(_(b'skipping incorrectly formatted tag %s\n') % line) ui.warn(_(b'skipping incorrectly formatted tag %s\n') % line)
continue continue
try: try:
newid = node.bin(id) newid = bin(id)
except TypeError: except TypeError:
ui.warn(_(b'skipping incorrectly formatted id %s\n') % id) ui.warn(_(b'skipping incorrectly formatted id %s\n') % id)
continue continue
try: try:
newdata.append(b'%s %s\n' % (node.hex(revmap[newid]), name)) newdata.append(b'%s %s\n' % (hex(revmap[newid]), name))
except KeyError: except KeyError:
ui.warn(_(b'no mapping for id %s\n') % id) ui.warn(_(b'no mapping for id %s\n') % id)
continue continue
return b''.join(newdata) return b''.join(newdata)
def _islfile(file, ctx, matcher, size): def _islfile(file, ctx, matcher, size):
"""Return true if file should be considered a largefile, i.e. """Return true if file should be considered a largefile, i.e.

hgext/largefiles/lfutil.py

from __future__ import absolute_import from __future__ import absolute_import
import contextlib import contextlib
import copy import copy
import os import os
import stat import stat
from mercurial.i18n import _ from mercurial.i18n import _
from mercurial.node import hex from mercurial.node import (
hex,
nullid,
)
from mercurial.pycompat import open from mercurial.pycompat import open
from mercurial import ( from mercurial import (
dirstate, dirstate,
encoding, encoding,
error, error,
httpconnection, httpconnection,
match as matchmod, match as matchmod,
node,
pycompat, pycompat,
scmutil, scmutil,
sparse, sparse,
util, util,
vfs as vfsmod, vfs as vfsmod,
) )
from mercurial.utils import hashutil from mercurial.utils import hashutil
makeprogress = repo.ui.makeprogress makeprogress = repo.ui.makeprogress
with makeprogress( with makeprogress(
_(b'finding outgoing largefiles'), _(b'finding outgoing largefiles'),
unit=_(b'revisions'), unit=_(b'revisions'),
total=len(missing), total=len(missing),
) as progress: ) as progress:
for i, n in enumerate(missing): for i, n in enumerate(missing):
progress.update(i) progress.update(i)
parents = [p for p in repo[n].parents() if p != node.nullid] parents = [p for p in repo[n].parents() if p != nullid]
with lfstatus(repo, value=False): with lfstatus(repo, value=False):
ctx = repo[n] ctx = repo[n]
files = set(ctx.files()) files = set(ctx.files())
if len(parents) == 2: if len(parents) == 2:
mc = ctx.manifest() mc = ctx.manifest()
mp1 = ctx.p1().manifest() mp1 = ctx.p1().manifest()

hgext/lfs/__init__.py

usercache = /path/to/global/cache usercache = /path/to/global/cache
""" """
from __future__ import absolute_import from __future__ import absolute_import
import sys import sys
from mercurial.i18n import _ from mercurial.i18n import _
from mercurial.node import bin
from mercurial import ( from mercurial import (
bundlecaches, bundlecaches,
config, config,
context, context,
error, error,
extensions, extensions,
exthelper, exthelper,
filelog, filelog,
filesetlang, filesetlang,
localrepo, localrepo,
minifileset, minifileset,
node,
pycompat, pycompat,
revlog, revlog,
scmutil, scmutil,
templateutil, templateutil,
util, util,
) )
from mercurial.interfaces import repository from mercurial.interfaces import repository
if b'lfs' not in repo.requirements: if b'lfs' not in repo.requirements:
def checkrequireslfs(ui, repo, **kwargs): def checkrequireslfs(ui, repo, **kwargs):
if b'lfs' in repo.requirements: if b'lfs' in repo.requirements:
return 0 return 0
last = kwargs.get('node_last') last = kwargs.get('node_last')
_bin = node.bin
if last: if last:
s = repo.set(b'%n:%n', _bin(kwargs['node']), _bin(last)) s = repo.set(b'%n:%n', bin(kwargs['node']), bin(last))
else: else:
s = repo.set(b'%n', _bin(kwargs['node'])) s = repo.set(b'%n', bin(kwargs['node']))
match = repo._storenarrowmatch match = repo._storenarrowmatch
for ctx in s: for ctx in s:
# TODO: is there a way to just walk the files in the commit? # TODO: is there a way to just walk the files in the commit?
if any( if any(
ctx[f].islfs() for f in ctx.files() if f in ctx and match(f) ctx[f].islfs() for f in ctx.files() if f in ctx and match(f)
): ):
repo.requirements.add(b'lfs') repo.requirements.add(b'lfs')
repo.features.add(repository.REPO_FEATURE_LFS) repo.features.add(repository.REPO_FEATURE_LFS)

hgext/lfs/blobstore.py

import hashlib import hashlib
import json import json
import os import os
import re import re
import socket import socket
from mercurial.i18n import _ from mercurial.i18n import _
from mercurial.pycompat import getattr from mercurial.pycompat import getattr
from mercurial.node import hex
from mercurial import ( from mercurial import (
encoding, encoding,
error, error,
httpconnection as httpconnectionmod, httpconnection as httpconnectionmod,
node,
pathutil, pathutil,
pycompat, pycompat,
url as urlmod, url as urlmod,
util, util,
vfs as vfsmod, vfs as vfsmod,
worker, worker,
) )
# the localstore, because it's not going to match the expected. # the localstore, because it's not going to match the expected.
if content_length is not None and int(content_length) != size: if content_length is not None and int(content_length) != size:
msg = ( msg = (
b"Response length (%s) does not match Content-Length " b"Response length (%s) does not match Content-Length "
b"header (%d): likely server-side crash" b"header (%d): likely server-side crash"
) )
raise LfsRemoteError(_(msg) % (size, int(content_length))) raise LfsRemoteError(_(msg) % (size, int(content_length)))
realoid = node.hex(sha256.digest()) realoid = hex(sha256.digest())
if realoid != oid: if realoid != oid:
raise LfsCorruptionError( raise LfsCorruptionError(
_(b'corrupt remote lfs object: %s') % oid _(b'corrupt remote lfs object: %s') % oid
) )
self._linktousercache(oid) self._linktousercache(oid)
def write(self, oid, data): def write(self, oid, data):
if not self.vfs.exists(oid): if not self.vfs.exists(oid):
blob = self._read(self.cachevfs, oid, verify) blob = self._read(self.cachevfs, oid, verify)
# Even if revlog will verify the content, it needs to be verified # Even if revlog will verify the content, it needs to be verified
# now before making the hardlink to avoid propagating corrupt blobs. # now before making the hardlink to avoid propagating corrupt blobs.
# Don't abort if corruption is detected, because `hg verify` will # Don't abort if corruption is detected, because `hg verify` will
# give more useful info about the corruption- simply don't add the # give more useful info about the corruption- simply don't add the
# hardlink. # hardlink.
if verify or node.hex(hashlib.sha256(blob).digest()) == oid: if verify or hex(hashlib.sha256(blob).digest()) == oid:
self.ui.note(_(b'lfs: found %s in the usercache\n') % oid) self.ui.note(_(b'lfs: found %s in the usercache\n') % oid)
lfutil.link(self.cachevfs.join(oid), self.vfs.join(oid)) lfutil.link(self.cachevfs.join(oid), self.vfs.join(oid))
else: else:
self.ui.note(_(b'lfs: found %s in the local lfs store\n') % oid) self.ui.note(_(b'lfs: found %s in the local lfs store\n') % oid)
blob = self._read(self.vfs, oid, verify) blob = self._read(self.vfs, oid, verify)
return blob return blob
def _read(self, vfs, oid, verify): def _read(self, vfs, oid, verify):
"""Read blob (after verifying) from the given store""" """Read blob (after verifying) from the given store"""
blob = vfs.read(oid) blob = vfs.read(oid)
if verify: if verify:
_verify(oid, blob) _verify(oid, blob)
return blob return blob
def verify(self, oid): def verify(self, oid):
"""Indicate whether or not the hash of the underlying file matches its """Indicate whether or not the hash of the underlying file matches its
name.""" name."""
sha256 = hashlib.sha256() sha256 = hashlib.sha256()
with self.open(oid) as fp: with self.open(oid) as fp:
for chunk in util.filechunkiter(fp, size=1048576): for chunk in util.filechunkiter(fp, size=1048576):
sha256.update(chunk) sha256.update(chunk)
return oid == node.hex(sha256.digest()) return oid == hex(sha256.digest())
def has(self, oid): def has(self, oid):
"""Returns True if the local blobstore contains the requested blob, """Returns True if the local blobstore contains the requested blob,
False otherwise.""" False otherwise."""
return self.cachevfs.exists(oid) or self.vfs.exists(oid) return self.cachevfs.exists(oid) or self.vfs.exists(oid)
def _urlerrorreason(urlerror): def _urlerrorreason(urlerror):
"""Remove any duplicate oids that exist in the list""" """Remove any duplicate oids that exist in the list"""
reduced = util.sortdict() reduced = util.sortdict()
for p in pointers: for p in pointers:
reduced[p.oid()] = p reduced[p.oid()] = p
return reduced.values() return reduced.values()
def _verify(oid, content): def _verify(oid, content):
realoid = node.hex(hashlib.sha256(content).digest()) realoid = hex(hashlib.sha256(content).digest())
if realoid != oid: if realoid != oid:
raise LfsCorruptionError( raise LfsCorruptionError(
_(b'detected corrupt lfs object: %s') % oid, _(b'detected corrupt lfs object: %s') % oid,
hint=_(b'run hg verify'), hint=_(b'run hg verify'),
) )
def remote(repo, remote=None): def remote(repo, remote=None):

hgext/narrow/narrowcommands.py

# narrowcommands.py - command modifications for narrowhg extension # narrowcommands.py - command modifications for narrowhg extension
# #
# Copyright 2017 Google, Inc. # Copyright 2017 Google, 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 itertools import itertools
import os import os
from mercurial.i18n import _ from mercurial.i18n import _
from mercurial.node import (
hex,
nullid,
short,
)
from mercurial import ( from mercurial import (
bundle2, bundle2,
cmdutil, cmdutil,
commands, commands,
discovery, discovery,
encoding, encoding,
error, error,
exchange, exchange,
extensions, extensions,
hg, hg,
narrowspec, narrowspec,
node,
pathutil, pathutil,
pycompat, pycompat,
registrar, registrar,
repair, repair,
repoview, repoview,
requirements, requirements,
sparse, sparse,
util, util,
if include: if include:
kwargs[b'includepats'] = include kwargs[b'includepats'] = include
if exclude: if exclude:
kwargs[b'excludepats'] = exclude kwargs[b'excludepats'] = exclude
# calculate known nodes only in ellipses cases because in non-ellipses cases # calculate known nodes only in ellipses cases because in non-ellipses cases
# we have all the nodes # we have all the nodes
if wireprototypes.ELLIPSESCAP1 in pullop.remote.capabilities(): if wireprototypes.ELLIPSESCAP1 in pullop.remote.capabilities():
kwargs[b'known'] = [ kwargs[b'known'] = [
node.hex(ctx.node()) hex(ctx.node())
for ctx in repo.set(b'::%ln', pullop.common) for ctx in repo.set(b'::%ln', pullop.common)
if ctx.node() != node.nullid if ctx.node() != nullid
] ]
if not kwargs[b'known']: if not kwargs[b'known']:
# Mercurial serializes an empty list as '' and deserializes it as # Mercurial serializes an empty list as '' and deserializes it as
# [''], so delete it instead to avoid handling the empty string on # [''], so delete it instead to avoid handling the empty string on
# the server. # the server.
del kwargs[b'known'] del kwargs[b'known']
_( _(
b'The following changeset(s) or their ancestors have ' b'The following changeset(s) or their ancestors have '
b'local changes not on the remote:\n' b'local changes not on the remote:\n'
) )
) )
maxnodes = 10 maxnodes = 10
if ui.verbose or len(visibletostrip) <= maxnodes: if ui.verbose or len(visibletostrip) <= maxnodes:
for n in visibletostrip: for n in visibletostrip:
ui.status(b'%s\n' % node.short(n)) ui.status(b'%s\n' % short(n))
else: else:
for n in visibletostrip[:maxnodes]: for n in visibletostrip[:maxnodes]:
ui.status(b'%s\n' % node.short(n)) ui.status(b'%s\n' % short(n))
ui.status( ui.status(
_(b'...and %d more, use --verbose to list all\n') _(b'...and %d more, use --verbose to list all\n')
% (len(visibletostrip) - maxnodes) % (len(visibletostrip) - maxnodes)
) )
if not force: if not force:
raise error.Abort( raise error.Abort(
_(b'local changes found'), _(b'local changes found'),
hint=_(b'use --force-delete-local-changes to ignore'), hint=_(b'use --force-delete-local-changes to ignore'),
overrides = {(b'devel', b'all-warnings'): False} overrides = {(b'devel', b'all-warnings'): False}
common = commoninc[0] common = commoninc[0]
with ui.uninterruptible(): with ui.uninterruptible():
if ellipsesremote: if ellipsesremote:
ds = repo.dirstate ds = repo.dirstate
p1, p2 = ds.p1(), ds.p2() p1, p2 = ds.p1(), ds.p2()
with ds.parentchange(): with ds.parentchange():
ds.setparents(node.nullid, node.nullid) ds.setparents(nullid, nullid)
if isoldellipses: if isoldellipses:
with wrappedextraprepare: with wrappedextraprepare:
exchange.pull(repo, remote, heads=common) exchange.pull(repo, remote, heads=common)
else: else:
known = [] known = []
if ellipsesremote: if ellipsesremote:
known = [ known = [
ctx.node() ctx.node()
for ctx in repo.set(b'::%ln', common) for ctx in repo.set(b'::%ln', common)
if ctx.node() != node.nullid if ctx.node() != nullid
] ]
with remote.commandexecutor() as e: with remote.commandexecutor() as e:
bundle = e.callcommand( bundle = e.callcommand(
b'narrow_widen', b'narrow_widen',
{ {
b'oldincludes': oldincludes, b'oldincludes': oldincludes,
b'oldexcludes': oldexcludes, b'oldexcludes': oldexcludes,
b'newincludes': newincludes, b'newincludes': newincludes,

hgext/patchbomb.py

import email.mime.multipart as emimemultipart import email.mime.multipart as emimemultipart
import email.utils as eutil import email.utils as eutil
import errno import errno
import os import os
import socket import socket
from mercurial.i18n import _ from mercurial.i18n import _
from mercurial.pycompat import open from mercurial.pycompat import open
from mercurial.node import bin
from mercurial import ( from mercurial import (
cmdutil, cmdutil,
commands, commands,
encoding, encoding,
error, error,
formatter, formatter,
hg, hg,
mail, mail,
node as nodemod,
patch, patch,
pycompat, pycompat,
registrar, registrar,
scmutil, scmutil,
templater, templater,
util, util,
) )
from mercurial.utils import dateutil from mercurial.utils import dateutil
if addattachment: if addattachment:
msg = emimemultipart.MIMEMultipart() msg = emimemultipart.MIMEMultipart()
if body: if body:
msg.attach(mail.mimeencode(ui, body, _charsets, opts.get(b'test'))) msg.attach(mail.mimeencode(ui, body, _charsets, opts.get(b'test')))
p = mail.mimetextpatch( p = mail.mimetextpatch(
b'\n'.join(patchlines), 'x-patch', opts.get(b'test') b'\n'.join(patchlines), 'x-patch', opts.get(b'test')
) )
binnode = nodemod.bin(node) binnode = bin(node)
# if node is mq patch, it will have the patch file's name as a tag # if node is mq patch, it will have the patch file's name as a tag
if not patchname: if not patchname:
patchtags = [ patchtags = [
t t
for t in repo.nodetags(binnode) for t in repo.nodetags(binnode)
if t.endswith(b'.patch') or t.endswith(b'.diff') if t.endswith(b'.patch') or t.endswith(b'.diff')
] ]
if patchtags: if patchtags:

hgext/rebase.py

import errno import errno
import os import os
from mercurial.i18n import _ from mercurial.i18n import _
from mercurial.node import ( from mercurial.node import (
nullrev, nullrev,
short, short,
wdirrev,
) )
from mercurial.pycompat import open from mercurial.pycompat import open
from mercurial import ( from mercurial import (
bookmarks, bookmarks,
cmdutil, cmdutil,
commands, commands,
copies, copies,
destutil, destutil,
dirstateguard, dirstateguard,
error, error,
extensions, extensions,
merge as mergemod, merge as mergemod,
mergestate as mergestatemod, mergestate as mergestatemod,
mergeutil, mergeutil,
node as nodemod,
obsolete, obsolete,
obsutil, obsutil,
patch, patch,
phases, phases,
pycompat, pycompat,
registrar, registrar,
repair, repair,
revset, revset,
) )
else: # can it happen? else: # can it happen?
ui.status( ui.status(
_(b'nothing to rebase from %s to %s\n') _(b'nothing to rebase from %s to %s\n')
% (b'+'.join(bytes(repo[r]) for r in base), dest) % (b'+'.join(bytes(repo[r]) for r in base), dest)
) )
return None return None
if nodemod.wdirrev in rebaseset: if wdirrev in rebaseset:
raise error.Abort(_(b'cannot rebase the working copy')) raise error.Abort(_(b'cannot rebase the working copy'))
rebasingwcp = repo[b'.'].rev() in rebaseset rebasingwcp = repo[b'.'].rev() in rebaseset
ui.log( ui.log(
b"rebase", b"rebase",
b"rebasing working copy parent: %r\n", b"rebasing working copy parent: %r\n",
rebasingwcp, rebasingwcp,
rebase_rebasing_wcp=rebasingwcp, rebase_rebasing_wcp=rebasingwcp,
) )

hgext/releasenotes.py

from __future__ import absolute_import from __future__ import absolute_import
import difflib import difflib
import errno import errno
import re import re
from mercurial.i18n import _ from mercurial.i18n import _
from mercurial.pycompat import open from mercurial.pycompat import open
from mercurial.node import hex
from mercurial import ( from mercurial import (
cmdutil, cmdutil,
config, config,
error, error,
minirst, minirst,
node,
pycompat, pycompat,
registrar, registrar,
scmutil, scmutil,
util, util,
) )
from mercurial.utils import ( from mercurial.utils import (
procutil, procutil,
stringutil, stringutil,
paragraphs.append(pblock[b'lines']) paragraphs.append(pblock[b'lines'])
else: else:
break break
# TODO consider using title as paragraph for more concise notes. # TODO consider using title as paragraph for more concise notes.
if not paragraphs: if not paragraphs:
repo.ui.warn( repo.ui.warn(
_(b"error parsing releasenotes for revision: '%s'\n") _(b"error parsing releasenotes for revision: '%s'\n")
% node.hex(ctx.node()) % hex(ctx.node())
) )
if title: if title:
notes.addtitleditem(directive, title, paragraphs) notes.addtitleditem(directive, title, paragraphs)
else: else:
notes.addnontitleditem(directive, paragraphs) notes.addnontitleditem(directive, paragraphs)
return notes return notes

hgext/remotefilelog/__init__.py

""" """
from __future__ import absolute_import from __future__ import absolute_import
import os import os
import time import time
import traceback import traceback
from mercurial.node import hex from mercurial.node import (
hex,
wdirrev,
)
from mercurial.i18n import _ from mercurial.i18n import _
from mercurial.pycompat import open from mercurial.pycompat import open
from mercurial import ( from mercurial import (
changegroup, changegroup,
changelog, changelog,
commands, commands,
configitems, configitems,
context, context,
copies, copies,
debugcommands as hgdebugcommands, debugcommands as hgdebugcommands,
dispatch, dispatch,
error, error,
exchange, exchange,
extensions, extensions,
hg, hg,
localrepo, localrepo,
match as matchmod, match as matchmod,
merge, merge,
mergestate as mergestatemod, mergestate as mergestatemod,
node as nodemod,
patch, patch,
pycompat, pycompat,
registrar, registrar,
repair, repair,
repoview, repoview,
revset, revset,
scmutil, scmutil,
smartset, smartset,
return orig(repo, remote, *args, **kwargs) return orig(repo, remote, *args, **kwargs)
def _fileprefetchhook(repo, revmatches): def _fileprefetchhook(repo, revmatches):
if isenabled(repo): if isenabled(repo):
allfiles = [] allfiles = []
for rev, match in revmatches: for rev, match in revmatches:
if rev == nodemod.wdirrev or rev is None: if rev == wdirrev or rev is None:
continue continue
ctx = repo[rev] ctx = repo[rev]
mf = ctx.manifest() mf = ctx.manifest()
sparsematch = repo.maybesparsematch(ctx.rev()) sparsematch = repo.maybesparsematch(ctx.rev())
for path in ctx.walk(match): for path in ctx.walk(match):
if (not sparsematch or sparsematch(path)) and path in mf: if (not sparsematch or sparsematch(path)) and path in mf:
allfiles.append((path, hex(mf[path]))) allfiles.append((path, hex(mf[path])))
repo.fileservice.prefetch(allfiles) repo.fileservice.prefetch(allfiles)

hgext/remotefilelog/basepack.py

from __future__ import absolute_import from __future__ import absolute_import
import collections import collections
import errno import errno
import mmap import mmap
import os import os
import struct import struct
import time import time
from mercurial.i18n import _ from mercurial.i18n import _
from mercurial.pycompat import ( from mercurial.pycompat import (
getattr, getattr,
open, open,
) )
from mercurial.node import hex
from mercurial import ( from mercurial import (
node as nodemod,
policy, policy,
pycompat, pycompat,
util, util,
vfs as vfsmod, vfs as vfsmod,
) )
from mercurial.utils import hashutil from mercurial.utils import hashutil
from . import shallowutil from . import shallowutil
self.packfp.write(data) self.packfp.write(data)
self.sha.update(data) self.sha.update(data)
def close(self, ledger=None): def close(self, ledger=None):
if self._closed: if self._closed:
return return
try: try:
sha = nodemod.hex(self.sha.digest()) sha = hex(self.sha.digest())
self.packfp.close() self.packfp.close()
self.writeindex() self.writeindex()
if len(self.entries) == 0: if len(self.entries) == 0:
# Empty pack # Empty pack
self._cleantemppacks() self._cleantemppacks()
self._closed = True self._closed = True
return None return None

hgext/remotefilelog/debugcommands.py

# debugcommands.py - debug logic for remotefilelog # debugcommands.py - debug logic for remotefilelog
# #
# Copyright 2013 Facebook, Inc. # Copyright 2013 Facebook, Inc.
# #
# This software may be used and distributed according to the terms of the # This software may be used and distributed according to the terms of the
# GNU General Public License version 2 or any later version. # GNU General Public License version 2 or any later version.
from __future__ import absolute_import from __future__ import absolute_import
import os import os
import zlib import zlib
from mercurial.node import bin, hex, nullid, short from mercurial.node import (
bin,
hex,
nullid,
short,
)
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,
filelog, filelog,
lock as lockmod, lock as lockmod,
node as nodemod,
pycompat, pycompat,
revlog, revlog,
) )
from mercurial.utils import hashutil from mercurial.utils import hashutil
from . import ( from . import (
constants, constants,
datapack, datapack,
fileserverclient, fileserverclient,
if p1 != nullid: if p1 != nullid:
queue.append(p1) queue.append(p1)
if p2 != nullid: if p2 != nullid:
queue.append(p2) queue.append(p2)
def buildtemprevlog(repo, file): def buildtemprevlog(repo, file):
# get filename key # get filename key
filekey = nodemod.hex(hashutil.sha1(file).digest()) filekey = hex(hashutil.sha1(file).digest())
filedir = os.path.join(repo.path, b'store/data', filekey) filedir = os.path.join(repo.path, b'store/data', filekey)
# sort all entries based on linkrev # sort all entries based on linkrev
fctxs = [] fctxs = []
for filenode in os.listdir(filedir): for filenode in os.listdir(filedir):
if b'_old' not in filenode: if b'_old' not in filenode:
fctxs.append(repo.filectx(file, fileid=bin(filenode))) fctxs.append(repo.filectx(file, fileid=bin(filenode)))
) )
) )
ui.write( ui.write(
b"%s %s %s %d\n" b"%s %s %s %d\n"
% ( % (
hashformatter(node), hashformatter(node),
hashformatter(deltabasenode), hashformatter(deltabasenode),
nodemod.hex(hashutil.sha1(delta).digest()), hex(hashutil.sha1(delta).digest()),
len(delta), len(delta),
) )
) )
def debughistorypack(ui, path): def debughistorypack(ui, path):
if b'.hist' in path: if b'.hist' in path:
path = path[: path.index(b'.hist')] path = path[: path.index(b'.hist')]

hgext/remotefilelog/fileserverclient.py

import threading import threading
import time import time
import zlib import zlib
from mercurial.i18n import _ from mercurial.i18n import _
from mercurial.node import bin, hex, nullid from mercurial.node import bin, hex, nullid
from mercurial import ( from mercurial import (
error, error,
node,
pycompat, pycompat,
revlog, revlog,
sshpeer, sshpeer,
util, util,
wireprotov1peer, wireprotov1peer,
) )
from mercurial.utils import ( from mercurial.utils import (
hashutil, hashutil,
fetches = 0 fetches = 0
fetched = 0 fetched = 0
fetchmisses = 0 fetchmisses = 0
_lfsmod = None _lfsmod = None
def getcachekey(reponame, file, id): def getcachekey(reponame, file, id):
pathhash = node.hex(hashutil.sha1(file).digest()) pathhash = hex(hashutil.sha1(file).digest())
return os.path.join(reponame, pathhash[:2], pathhash[2:], id) return os.path.join(reponame, pathhash[:2], pathhash[2:], id)
def getlocalkey(file, id): def getlocalkey(file, id):
pathhash = node.hex(hashutil.sha1(file).digest()) pathhash = hex(hashutil.sha1(file).digest())
return os.path.join(pathhash, id) return os.path.join(pathhash, id)
def peersetup(ui, peer): def peersetup(ui, peer):
class remotefilepeer(peer.__class__): class remotefilepeer(peer.__class__):
@wireprotov1peer.batchable @wireprotov1peer.batchable
def x_rfl_getfile(self, file, node): def x_rfl_getfile(self, file, node):
if not self.capable(b'x_rfl_getfile'): if not self.capable(b'x_rfl_getfile'):

hgext/remotefilelog/shallowutil.py

import errno import errno
import os import os
import stat import stat
import struct import struct
import tempfile import tempfile
from mercurial.i18n import _ from mercurial.i18n import _
from mercurial.pycompat import open from mercurial.pycompat import open
from mercurial.node import hex
from mercurial import ( from mercurial import (
error, error,
node,
pycompat, pycompat,
revlog, revlog,
util, util,
) )
from mercurial.utils import ( from mercurial.utils import (
hashutil, hashutil,
storageutil, storageutil,
stringutil, stringutil,
) )
from . import constants from . import constants
if not pycompat.iswindows: if not pycompat.iswindows:
import grp import grp
def isenabled(repo): def isenabled(repo):
"""returns whether the repository is remotefilelog enabled or not""" """returns whether the repository is remotefilelog enabled or not"""
return constants.SHALLOWREPO_REQUIREMENT in repo.requirements return constants.SHALLOWREPO_REQUIREMENT in repo.requirements
def getcachekey(reponame, file, id): def getcachekey(reponame, file, id):
pathhash = node.hex(hashutil.sha1(file).digest()) pathhash = hex(hashutil.sha1(file).digest())
return os.path.join(reponame, pathhash[:2], pathhash[2:], id) return os.path.join(reponame, pathhash[:2], pathhash[2:], id)
def getlocalkey(file, id): def getlocalkey(file, id):
pathhash = node.hex(hashutil.sha1(file).digest()) pathhash = hex(hashutil.sha1(file).digest())
return os.path.join(pathhash, id) return os.path.join(pathhash, id)
def getcachepath(ui, allowempty=False): def getcachepath(ui, allowempty=False):
cachepath = ui.config(b"remotefilelog", b"cachepath") cachepath = ui.config(b"remotefilelog", b"cachepath")
if not cachepath: if not cachepath:
if allowempty: if allowempty:
return None return None

hgext/transplant.py

map from a changeset hash to its hash in the source repository. map from a changeset hash to its hash in the source repository.
''' '''
from __future__ import absolute_import from __future__ import absolute_import
import os import os
from mercurial.i18n import _ from mercurial.i18n import _
from mercurial.pycompat import open from mercurial.pycompat import open
from mercurial.node import (
bin,
hex,
nullid,
short,
)
from mercurial import ( from mercurial import (
bundlerepo, bundlerepo,
cmdutil, cmdutil,
error, error,
exchange, exchange,
hg, hg,
logcmdutil, logcmdutil,
match, match,
merge, merge,
node as nodemod,
patch, patch,
pycompat, pycompat,
registrar, registrar,
revlog, revlog,
revset, revset,
scmutil, scmutil,
smartset, smartset,
state as statemod, state as statemod,
self.transplants = {} self.transplants = {}
self.dirty = False self.dirty = False
self.read() self.read()
def read(self): def read(self):
abspath = os.path.join(self.path, self.transplantfile) abspath = os.path.join(self.path, self.transplantfile)
if self.transplantfile and os.path.exists(abspath): if self.transplantfile and os.path.exists(abspath):
for line in self.opener.read(self.transplantfile).splitlines(): for line in self.opener.read(self.transplantfile).splitlines():
lnode, rnode = map(revlog.bin, line.split(b':')) lnode, rnode = map(bin, line.split(b':'))
list = self.transplants.setdefault(rnode, []) list = self.transplants.setdefault(rnode, [])
list.append(transplantentry(lnode, rnode)) list.append(transplantentry(lnode, rnode))
def write(self): def write(self):
if self.dirty and self.transplantfile: if self.dirty and self.transplantfile:
if not os.path.isdir(self.path): if not os.path.isdir(self.path):
os.mkdir(self.path) os.mkdir(self.path)
fp = self.opener(self.transplantfile, b'w') fp = self.opener(self.transplantfile, b'w')
for list in pycompat.itervalues(self.transplants): for list in pycompat.itervalues(self.transplants):
for t in list: for t in list:
l, r = map(nodemod.hex, (t.lnode, t.rnode)) l, r = map(hex, (t.lnode, t.rnode))
fp.write(l + b':' + r + b'\n') fp.write(l + b':' + r + b'\n')
fp.close() fp.close()
self.dirty = False self.dirty = False
def get(self, rnode): def get(self, rnode):
return self.transplants.get(rnode) or [] return self.transplants.get(rnode) or []
def set(self, lnode, rnode): def set(self, lnode, rnode):
diffopts.git = True diffopts.git = True
lock = tr = None lock = tr = None
try: try:
lock = repo.lock() lock = repo.lock()
tr = repo.transaction(b'transplant') tr = repo.transaction(b'transplant')
for rev in revs: for rev in revs:
node = revmap[rev] node = revmap[rev]
revstr = b'%d:%s' % (rev, nodemod.short(node)) revstr = b'%d:%s' % (rev, short(node))
if self.applied(repo, node, p1): if self.applied(repo, node, p1):
self.ui.warn( self.ui.warn(
_(b'skipping already applied revision %s\n') % revstr _(b'skipping already applied revision %s\n') % revstr
) )
continue continue
parents = source.changelog.parents(node) parents = source.changelog.parents(node)
# pulling all the merge revs at once would mean we # pulling all the merge revs at once would mean we
# couldn't transplant after the latest even if # couldn't transplant after the latest even if
# transplants before them fail. # transplants before them fail.
domerge = True domerge = True
if not hasnode(repo, node): if not hasnode(repo, node):
exchange.pull(repo, source.peer(), heads=[node]) exchange.pull(repo, source.peer(), heads=[node])
skipmerge = False skipmerge = False
if parents[1] != revlog.nullid: if parents[1] != nullid:
if not opts.get(b'parent'): if not opts.get(b'parent'):
self.ui.note( self.ui.note(
_(b'skipping merge changeset %d:%s\n') _(b'skipping merge changeset %d:%s\n')
% (rev, nodemod.short(node)) % (rev, short(node))
) )
skipmerge = True skipmerge = True
else: else:
parent = source.lookup(opts[b'parent']) parent = source.lookup(opts[b'parent'])
if parent not in parents: if parent not in parents:
raise error.Abort( raise error.Abort(
_(b'%s is not a parent of %s') _(b'%s is not a parent of %s')
% (nodemod.short(parent), nodemod.short(node)) % (short(parent), short(node))
) )
else: else:
parent = parents[0] parent = parents[0]
if skipmerge: if skipmerge:
patchfile = None patchfile = None
else: else:
fd, patchfile = pycompat.mkstemp(prefix=b'hg-transplant-') fd, patchfile = pycompat.mkstemp(prefix=b'hg-transplant-')
except TransplantError: except TransplantError:
# Do not rollback, it is up to the user to # Do not rollback, it is up to the user to
# fix the merge or cancel everything # fix the merge or cancel everything
tr.close() tr.close()
raise raise
if n and domerge: if n and domerge:
self.ui.status( self.ui.status(
_(b'%s merged at %s\n') _(b'%s merged at %s\n')
% (revstr, nodemod.short(n)) % (revstr, short(n))
) )
elif n: elif n:
self.ui.status( self.ui.status(
_(b'%s transplanted to %s\n') _(b'%s transplanted to %s\n')
% (nodemod.short(node), nodemod.short(n)) % (short(node), short(n))
) )
finally: finally:
if patchfile: if patchfile:
os.unlink(patchfile) os.unlink(patchfile)
tr.close() tr.close()
if pulls: if pulls:
exchange.pull(repo, source.peer(), heads=pulls) exchange.pull(repo, source.peer(), heads=pulls)
merge.update(repo[pulls[-1]]) merge.update(repo[pulls[-1]])
b'%s %s %s' b'%s %s %s'
% ( % (
filter, filter,
procutil.shellquote(headerfile), procutil.shellquote(headerfile),
procutil.shellquote(patchfile), procutil.shellquote(patchfile),
), ),
environ={ environ={
b'HGUSER': changelog[1], b'HGUSER': changelog[1],
b'HGREVISION': nodemod.hex(node), b'HGREVISION': hex(node),
}, },
onerr=error.Abort, onerr=error.Abort,
errprefix=_(b'filter failed'), errprefix=_(b'filter failed'),
blockedtag=b'transplant_filter', blockedtag=b'transplant_filter',
) )
user, date, msg = self.parselog(open(headerfile, b'rb'))[1:4] user, date, msg = self.parselog(open(headerfile, b'rb'))[1:4]
finally: finally:
os.unlink(headerfile) os.unlink(headerfile)
return (user, date, msg) return (user, date, msg)
def applyone( def applyone(
self, repo, node, cl, patchfile, merge=False, log=False, filter=None self, repo, node, cl, patchfile, merge=False, log=False, filter=None
): ):
'''apply the patch in patchfile to the repository as a transplant''' '''apply the patch in patchfile to the repository as a transplant'''
(manifest, user, (time, timezone), files, message) = cl[:5] (manifest, user, (time, timezone), files, message) = cl[:5]
date = b"%d %d" % (time, timezone) date = b"%d %d" % (time, timezone)
extra = {b'transplant_source': node} extra = {b'transplant_source': node}
if filter: if filter:
(user, date, message) = self.filter(filter, node, cl, patchfile) (user, date, message) = self.filter(filter, node, cl, patchfile)
if log: if log:
# we don't translate messages inserted into commits # we don't translate messages inserted into commits
message += b'\n(transplanted from %s)' % nodemod.hex(node) message += b'\n(transplanted from %s)' % hex(node)
self.ui.status(_(b'applying %s\n') % nodemod.short(node)) self.ui.status(_(b'applying %s\n') % short(node))
self.ui.note(b'%s %s\n%s\n' % (user, date, message)) self.ui.note(b'%s %s\n%s\n' % (user, date, message))
if not patchfile and not merge: if not patchfile and not merge:
raise error.Abort(_(b'can only omit patchfile if merging')) raise error.Abort(_(b'can only omit patchfile if merging'))
if patchfile: if patchfile:
try: try:
files = set() files = set()
patch.patch(self.ui, repo, patchfile, files=files, eolmode=None) patch.patch(self.ui, repo, patchfile, files=files, eolmode=None)
user, user,
date, date,
extra=extra, extra=extra,
match=m, match=m,
editor=self.getcommiteditor(), editor=self.getcommiteditor(),
) )
if not n: if not n:
self.ui.warn( self.ui.warn(
_(b'skipping emptied changeset %s\n') % nodemod.short(node) _(b'skipping emptied changeset %s\n') % short(node)
) )
return None return None
if not merge: if not merge:
self.transplants.set(n, node) self.transplants.set(n, node)
return n return n
def canresume(self): def canresume(self):
return os.path.exists(os.path.join(self.path, b'journal')) return os.path.exists(os.path.join(self.path, b'journal'))
def resume(self, repo, source, opts): def resume(self, repo, source, opts):
'''recover last transaction and apply remaining changesets''' '''recover last transaction and apply remaining changesets'''
if os.path.exists(os.path.join(self.path, b'journal')): if os.path.exists(os.path.join(self.path, b'journal')):
n, node = self.recover(repo, source, opts) n, node = self.recover(repo, source, opts)
if n: if n:
self.ui.status( self.ui.status(
_(b'%s transplanted as %s\n') _(b'%s transplanted as %s\n')
% (nodemod.short(node), nodemod.short(n)) % (short(node), short(n))
) )
else: else:
self.ui.status( self.ui.status(
_(b'%s skipped due to empty diff\n') _(b'%s skipped due to empty diff\n')
% (nodemod.short(node),) % (short(node),)
) )
seriespath = os.path.join(self.path, b'series') seriespath = os.path.join(self.path, b'series')
if not os.path.exists(seriespath): if not os.path.exists(seriespath):
self.transplants.write() self.transplants.write()
return return
nodes, merges = self.readseries() nodes, merges = self.readseries()
revmap = {} revmap = {}
for n in nodes: for n in nodes:
parent = parents[0] parent = parents[0]
if len(parents) > 1: if len(parents) > 1:
if opts.get(b'parent'): if opts.get(b'parent'):
parent = source.lookup(opts[b'parent']) parent = source.lookup(opts[b'parent'])
if parent not in parents: if parent not in parents:
raise error.Abort( raise error.Abort(
_(b'%s is not a parent of %s') _(b'%s is not a parent of %s')
% (nodemod.short(parent), nodemod.short(node)) % (short(parent), short(node))
) )
else: else:
merge = True merge = True
extra = {b'transplant_source': node} extra = {b'transplant_source': node}
try: try:
p1 = repo.dirstate.p1() p1 = repo.dirstate.p1()
if p1 != parent: if p1 != parent:
raise error.Abort( raise error.Abort(
_(b'working directory not at transplant parent %s') _(b'working directory not at transplant parent %s')
% nodemod.hex(parent) % hex(parent)
) )
if merge: if merge:
repo.setparents(p1, parents[1]) repo.setparents(p1, parents[1])
st = repo.status() st = repo.status()
modified, added, removed, deleted = ( modified, added, removed, deleted = (
st.modified, st.modified,
st.added, st.added,
st.removed, st.removed,
def readseries(self): def readseries(self):
nodes = [] nodes = []
merges = [] merges = []
cur = nodes cur = nodes
for line in self.opener.read(b'series').splitlines(): for line in self.opener.read(b'series').splitlines():
if line.startswith(b'# Merges'): if line.startswith(b'# Merges'):
cur = merges cur = merges
continue continue
cur.append(revlog.bin(line)) cur.append(bin(line))
return (nodes, merges) return (nodes, merges)
def saveseries(self, revmap, merges): def saveseries(self, revmap, merges):
if not revmap: if not revmap:
return return
if not os.path.isdir(self.path): if not os.path.isdir(self.path):
os.mkdir(self.path) os.mkdir(self.path)
series = self.opener(b'series', b'w') series = self.opener(b'series', b'w')
for rev in sorted(revmap): for rev in sorted(revmap):
series.write(nodemod.hex(revmap[rev]) + b'\n') series.write(hex(revmap[rev]) + b'\n')
if merges: if merges:
series.write(b'# Merges\n') series.write(b'# Merges\n')
for m in merges: for m in merges:
series.write(nodemod.hex(m) + b'\n') series.write(hex(m) + b'\n')
series.close() series.close()
def parselog(self, fp): def parselog(self, fp):
parents = [] parents = []
message = [] message = []
node = revlog.nullid node = nullid
inmsg = False inmsg = False
user = None user = None
date = None date = None
for line in fp.read().splitlines(): for line in fp.read().splitlines():
if inmsg: if inmsg:
message.append(line) message.append(line)
elif line.startswith(b'# User '): elif line.startswith(b'# User '):
user = line[7:] user = line[7:]
elif line.startswith(b'# Date '): elif line.startswith(b'# Date '):
date = line[7:] date = line[7:]
elif line.startswith(b'# Node ID '): elif line.startswith(b'# Node ID '):
node = revlog.bin(line[10:]) node = bin(line[10:])
elif line.startswith(b'# Parent '): elif line.startswith(b'# Parent '):
parents.append(revlog.bin(line[9:])) parents.append(bin(line[9:]))
elif not line.startswith(b'# '): elif not line.startswith(b'# '):
inmsg = True inmsg = True
message.append(line) message.append(line)
if None in (user, date): if None in (user, date):
raise error.Abort( raise error.Abort(
_(b"filter corrupted changeset (no user or date)") _(b"filter corrupted changeset (no user or date)")
) )
return (node, user, date, b'\n'.join(message), parents) return (node, user, date, b'\n'.join(message), parents)
def log(self, user, date, message, p1, p2, merge=False): def log(self, user, date, message, p1, p2, merge=False):
'''journal changelog metadata for later recover''' '''journal changelog metadata for later recover'''
if not os.path.isdir(self.path): if not os.path.isdir(self.path):
os.mkdir(self.path) os.mkdir(self.path)
fp = self.opener(b'journal', b'w') fp = self.opener(b'journal', b'w')
fp.write(b'# User %s\n' % user) fp.write(b'# User %s\n' % user)
fp.write(b'# Date %s\n' % date) fp.write(b'# Date %s\n' % date)
fp.write(b'# Node ID %s\n' % nodemod.hex(p2)) fp.write(b'# Node ID %s\n' % hex(p2))
fp.write(b'# Parent ' + nodemod.hex(p1) + b'\n') fp.write(b'# Parent ' + hex(p1) + b'\n')
if merge: if merge:
fp.write(b'# Parent ' + nodemod.hex(p2) + b'\n') fp.write(b'# Parent ' + hex(p2) + b'\n')
fp.write(message.rstrip() + b'\n') fp.write(message.rstrip() + b'\n')
fp.close() fp.close()
def readlog(self): def readlog(self):
return self.parselog(self.opener(b'journal')) return self.parselog(self.opener(b'journal'))
def unlog(self): def unlog(self):
'''remove changelog journal''' '''remove changelog journal'''
absdst = os.path.join(self.path, b'journal') absdst = os.path.join(self.path, b'journal')
if os.path.exists(absdst): if os.path.exists(absdst):
os.unlink(absdst) os.unlink(absdst)
def transplantfilter(self, repo, source, root): def transplantfilter(self, repo, source, root):
def matchfn(node): def matchfn(node):
if self.applied(repo, node, root): if self.applied(repo, node, root):
return False return False
if source.changelog.parents(node)[1] != revlog.nullid: if source.changelog.parents(node)[1] != nullid:
return False return False
extra = source.changelog.read(node)[5] extra = source.changelog.read(node)[5]
cnode = extra.get(b'transplant_source') cnode = extra.get(b'transplant_source')
if cnode and self.applied(repo, cnode, root): if cnode and self.applied(repo, cnode, root):
return False return False
return True return True
return matchfn return matchfn
opts[b'log'] = ui.config(b'transplant', b'log') opts[b'log'] = ui.config(b'transplant', b'log')
if not opts.get(b'filter'): if not opts.get(b'filter'):
# deprecated config: transplant.filter # deprecated config: transplant.filter
opts[b'filter'] = ui.config(b'transplant', b'filter') opts[b'filter'] = ui.config(b'transplant', b'filter')
tp = transplanter(ui, repo, opts) tp = transplanter(ui, repo, opts)
p1 = repo.dirstate.p1() p1 = repo.dirstate.p1()
if len(repo) > 0 and p1 == revlog.nullid: if len(repo) > 0 and p1 == nullid:
raise error.Abort(_(b'no revision checked out')) raise error.Abort(_(b'no revision checked out'))
if opts.get(b'continue'): if opts.get(b'continue'):
if not tp.canresume(): if not tp.canresume():
raise error.StateError(_(b'no transplant to continue')) raise error.StateError(_(b'no transplant to continue'))
elif opts.get(b'stop'): elif opts.get(b'stop'):
if not tp.canresume(): if not tp.canresume():
raise error.StateError(_(b'no interrupted transplant found')) raise error.StateError(_(b'no interrupted transplant found'))
return tp.stop(ui, repo) return tp.stop(ui, repo)
@templatekeyword(b'transplanted', requires={b'ctx'}) @templatekeyword(b'transplanted', requires={b'ctx'})
def kwtransplanted(context, mapping): def kwtransplanted(context, mapping):
"""String. The node identifier of the transplanted """String. The node identifier of the transplanted
changeset if any.""" changeset if any."""
ctx = context.resource(mapping, b'ctx') ctx = context.resource(mapping, b'ctx')
n = ctx.extra().get(b'transplant_source') n = ctx.extra().get(b'transplant_source')
return n and nodemod.hex(n) or b'' return n and hex(n) or b''
def extsetup(ui): def extsetup(ui):
statemod.addunfinished( statemod.addunfinished(
b'transplant', b'transplant',
fname=b'transplant/journal', fname=b'transplant/journal',
clearable=True, clearable=True,
continuefunc=continuecmd, continuefunc=continuecmd,

hgext/uncommit.py

files to their uncommitted state. This means that files modified, added or files to their uncommitted state. This means that files modified, added or
removed in the changeset will be left unchanged, and so will remain modified, removed in the changeset will be left unchanged, and so will remain modified,
added and removed in the working directory. added and removed in the working directory.
""" """
from __future__ import absolute_import from __future__ import absolute_import
from mercurial.i18n import _ from mercurial.i18n import _
from mercurial.node import nullid
from mercurial import ( from mercurial import (
cmdutil, cmdutil,
commands, commands,
context, context,
copies as copiesmod, copies as copiesmod,
error, error,
node,
obsutil, obsutil,
pathutil, pathutil,
pycompat, pycompat,
registrar, registrar,
rewriteutil, rewriteutil,
scmutil, scmutil,
) )
message = ctx.description() message = ctx.description()
if not user: if not user:
user = ctx.user() user = ctx.user()
if not date: if not date:
date = ctx.date() date = ctx.date()
new = context.memctx( new = context.memctx(
repo, repo,
parents=[base.node(), node.nullid], parents=[base.node(), nullid],
text=message, text=message,
files=files, files=files,
filectxfn=filectxfn, filectxfn=filectxfn,
user=user, user=user,
date=date, date=date,
extra=ctx.extra(), extra=ctx.extra(),
) )
return repo.commitctx(new) return repo.commitctx(new)

mercurial/bundle2.py

import errno import errno
import os import os
import re import re
import string import string
import struct import struct
import sys import sys
from .i18n import _ from .i18n import _
from .node import (
hex,
nullid,
short,
)
from . import ( from . import (
bookmarks, bookmarks,
changegroup, changegroup,
encoding, encoding,
error, error,
node as nodemod,
obsolete, obsolete,
phases, phases,
pushkey, pushkey,
pycompat, pycompat,
requirements, requirements,
scmutil, scmutil,
streamclone, streamclone,
tags, tags,
msgexist = ( msgexist = (
b'remote repository changed while pushing - please try again ' b'remote repository changed while pushing - please try again '
b'(bookmark "%s" set on %s, expected missing)' b'(bookmark "%s" set on %s, expected missing)'
) )
for book, node in bookdata: for book, node in bookdata:
currentnode = op.repo._bookmarks.get(book) currentnode = op.repo._bookmarks.get(book)
if currentnode != node: if currentnode != node:
if node is None: if node is None:
finalmsg = msgexist % (book, nodemod.short(currentnode)) finalmsg = msgexist % (book, short(currentnode))
elif currentnode is None: elif currentnode is None:
finalmsg = msgmissing % (book, nodemod.short(node)) finalmsg = msgmissing % (book, short(node))
else: else:
finalmsg = msgstandard % ( finalmsg = msgstandard % (
book, book,
nodemod.short(node), short(node),
nodemod.short(currentnode), short(currentnode),
) )
raise error.PushRaced(finalmsg) raise error.PushRaced(finalmsg)
@parthandler(b'check:heads') @parthandler(b'check:heads')
def handlecheckheads(op, inpart): def handlecheckheads(op, inpart):
"""check that head of the repo did not change """check that head of the repo did not change
b'remote repository changed while pushing - please try again ' b'remote repository changed while pushing - please try again '
b'(%s is %s expected %s)' b'(%s is %s expected %s)'
) )
for expectedphase, nodes in pycompat.iteritems(phasetonodes): for expectedphase, nodes in pycompat.iteritems(phasetonodes):
for n in nodes: for n in nodes:
actualphase = phasecache.phase(unfi, cl.rev(n)) actualphase = phasecache.phase(unfi, cl.rev(n))
if actualphase != expectedphase: if actualphase != expectedphase:
finalmsg = msg % ( finalmsg = msg % (
nodemod.short(n), short(n),
phases.phasenames[actualphase], phases.phasenames[actualphase],
phases.phasenames[expectedphase], phases.phasenames[expectedphase],
) )
raise error.PushRaced(finalmsg) raise error.PushRaced(finalmsg)
@parthandler(b'output') @parthandler(b'output')
def handleoutput(op, inpart): def handleoutput(op, inpart):
bookstore = op.repo._bookmarks bookstore = op.repo._bookmarks
if pushkeycompat: if pushkeycompat:
allhooks = [] allhooks = []
for book, node in changes: for book, node in changes:
hookargs = tr.hookargs.copy() hookargs = tr.hookargs.copy()
hookargs[b'pushkeycompat'] = b'1' hookargs[b'pushkeycompat'] = b'1'
hookargs[b'namespace'] = b'bookmarks' hookargs[b'namespace'] = b'bookmarks'
hookargs[b'key'] = book hookargs[b'key'] = book
hookargs[b'old'] = nodemod.hex(bookstore.get(book, b'')) hookargs[b'old'] = hex(bookstore.get(book, b''))
hookargs[b'new'] = nodemod.hex( hookargs[b'new'] = hex(
node if node is not None else b'' node if node is not None else b''
) )
allhooks.append(hookargs) allhooks.append(hookargs)
for hookargs in allhooks: for hookargs in allhooks:
op.repo.hook( op.repo.hook(
b'prepushkey', throw=True, **pycompat.strkwargs(hookargs) b'prepushkey', throw=True, **pycompat.strkwargs(hookargs)
) )
packer = changegroup.getbundler( packer = changegroup.getbundler(
cgversion, cgversion,
repo, repo,
oldmatcher=oldmatcher, oldmatcher=oldmatcher,
matcher=newmatcher, matcher=newmatcher,
fullnodes=commonnodes, fullnodes=commonnodes,
) )
cgdata = packer.generate( cgdata = packer.generate(
{nodemod.nullid}, {nullid},
list(commonnodes), list(commonnodes),
False, False,
b'narrow_widen', b'narrow_widen',
changelog=False, changelog=False,
) )
part = bundler.newpart(b'changegroup', data=cgdata) part = bundler.newpart(b'changegroup', data=cgdata)
part.addparam(b'version', cgversion) part.addparam(b'version', cgversion)
if scmutil.istreemanifest(repo): if scmutil.istreemanifest(repo):
part.addparam(b'treemanifest', b'1') part.addparam(b'treemanifest', b'1')
if b'exp-sidedata-flag' in repo.requirements: if b'exp-sidedata-flag' in repo.requirements:
part.addparam(b'exp-sidedata', b'1') part.addparam(b'exp-sidedata', b'1')
return bundler return bundler

mercurial/bundlerepo.py

""" """
from __future__ import absolute_import from __future__ import absolute_import
import os import os
import shutil import shutil
from .i18n import _ from .i18n import _
from .node import nullid, nullrev from .node import (
hex,
nullid,
nullrev,
)
from . import ( from . import (
bundle2, bundle2,
changegroup, changegroup,
changelog, changelog,
cmdutil, cmdutil,
discovery, discovery,
encoding, encoding,
error, error,
exchange, exchange,
filelog, filelog,
localrepo, localrepo,
manifest, manifest,
mdiff, mdiff,
node as nodemod,
pathutil, pathutil,
phases, phases,
pycompat, pycompat,
revlog, revlog,
util, util,
vfs as vfsmod, vfs as vfsmod,
) )
return encoding.getcwd() # always outside the repo return encoding.getcwd() # always outside the repo
# Check if parents exist in localrepo before setting # Check if parents exist in localrepo before setting
def setparents(self, p1, p2=nullid): def setparents(self, p1, p2=nullid):
p1rev = self.changelog.rev(p1) p1rev = self.changelog.rev(p1)
p2rev = self.changelog.rev(p2) p2rev = self.changelog.rev(p2)
msg = _(b"setting parent to node %s that only exists in the bundle\n") msg = _(b"setting parent to node %s that only exists in the bundle\n")
if self.changelog.repotiprev < p1rev: if self.changelog.repotiprev < p1rev:
self.ui.warn(msg % nodemod.hex(p1)) self.ui.warn(msg % hex(p1))
if self.changelog.repotiprev < p2rev: if self.changelog.repotiprev < p2rev:
self.ui.warn(msg % nodemod.hex(p2)) self.ui.warn(msg % hex(p2))
return super(bundlerepository, self).setparents(p1, p2) return super(bundlerepository, self).setparents(p1, p2)
def instance(ui, path, create, intents=None, createopts=None): def instance(ui, path, create, intents=None, createopts=None):
if create: if create:
raise error.Abort(_(b'cannot create new bundle repository')) raise error.Abort(_(b'cannot create new bundle repository'))
# internal config: bundle.mainreporoot # internal config: bundle.mainreporoot
parentpath = ui.config(b"bundle", b"mainreporoot") parentpath = ui.config(b"bundle", b"mainreporoot")

mercurial/chgserver.py

import struct import struct
import time import time
from .i18n import _ from .i18n import _
from .pycompat import ( from .pycompat import (
getattr, getattr,
setattr, setattr,
) )
from .node import hex
from . import ( from . import (
commandserver, commandserver,
encoding, encoding,
error, error,
extensions, extensions,
node,
pycompat, pycompat,
util, util,
) )
from .utils import ( from .utils import (
hashutil, hashutil,
procutil, procutil,
stringutil, stringutil,
) )
def _hashlist(items): def _hashlist(items):
"""return sha1 hexdigest for a list""" """return sha1 hexdigest for a list"""
return node.hex(hashutil.sha1(stringutil.pprint(items)).digest()) return hex(hashutil.sha1(stringutil.pprint(items)).digest())
# sensitive config sections affecting confighash # sensitive config sections affecting confighash
_configsections = [ _configsections = [
b'alias', # affects global state commands.table b'alias', # affects global state commands.table
b'diff-tools', # affects whether gui or not in extdiff's uisetup b'diff-tools', # affects whether gui or not in extdiff's uisetup
b'eol', # uses setconfig('eol', ...) b'eol', # uses setconfig('eol', ...)
b'extdiff', # uisetup will register new commands b'extdiff', # uisetup will register new commands

mercurial/copies.py

# copies.py - copy detection for Mercurial # copies.py - copy detection for Mercurial
# #
# Copyright 2008 Matt Mackall <mpm@selenic.com> # Copyright 2008 Matt Mackall <mpm@selenic.com>
# #
# This software may be used and distributed according to the terms of the # This software may be used and distributed according to the terms of the
# GNU General Public License version 2 or any later version. # GNU General Public License version 2 or any later version.
from __future__ import absolute_import from __future__ import absolute_import
import collections import collections
import os import os
from .i18n import _ from .i18n import _
from .node import (
nullid,
nullrev,
)
from . import ( from . import (
match as matchmod, match as matchmod,
node,
pathutil, pathutil,
policy, policy,
pycompat, pycompat,
util, util,
) )
from .utils import stringutil from .utils import stringutil
# Computing the forward missing is quite expensive on large manifests, since # Computing the forward missing is quite expensive on large manifests, since
# it compares the entire manifests. We can optimize it in the common use # it compares the entire manifests. We can optimize it in the common use
# case of computing what copies are in a commit versus its parent (like # case of computing what copies are in a commit versus its parent (like
# during a rebase or histedit). Note, we exclude merge commits from this # during a rebase or histedit). Note, we exclude merge commits from this
# optimization, since the ctx.files() for a merge commit is not correct for # optimization, since the ctx.files() for a merge commit is not correct for
# this comparison. # this comparison.
forwardmissingmatch = match forwardmissingmatch = match
if b.p1() == a and b.p2().node() == node.nullid: if b.p1() == a and b.p2().node() == nullid:
filesmatcher = matchmod.exact(b.files()) filesmatcher = matchmod.exact(b.files())
forwardmissingmatch = matchmod.intersectmatchers(match, filesmatcher) forwardmissingmatch = matchmod.intersectmatchers(match, filesmatcher)
missing = _computeforwardmissing(a, b, match=forwardmissingmatch) missing = _computeforwardmissing(a, b, match=forwardmissingmatch)
ancestrycontext = a._repo.changelog.ancestors([b.rev()], inclusive=True) ancestrycontext = a._repo.changelog.ancestors([b.rev()], inclusive=True)
if debug: if debug:
dbg(b'debug.copies: missing files to search: %d\n' % len(missing)) dbg(b'debug.copies: missing files to search: %d\n' % len(missing))
e = merge_caches.pop(rev, None) e = merge_caches.pop(rev, None)
if e is not None: if e is not None:
return e return e
if flags(rev) & HASCOPIESINFO: if flags(rev) & HASCOPIESINFO:
raw = changelogrevision(rev)._sidedata.get(sidedatamod.SD_FILES) raw = changelogrevision(rev)._sidedata.get(sidedatamod.SD_FILES)
else: else:
raw = None raw = None
value = (p1, p2, raw) value = (p1, p2, raw)
if p1 != node.nullrev and p2 != node.nullrev: if p1 != nullrev and p2 != nullrev:
# XXX some case we over cache, IGNORE # XXX some case we over cache, IGNORE
merge_caches[rev] = value merge_caches[rev] = value
return value return value
else: else:
def revinfo(rev): def revinfo(rev):
p1, p2 = parents(rev) p1, p2 = parents(rev)
value = None value = None
e = merge_caches.pop(rev, None) e = merge_caches.pop(rev, None)
if e is not None: if e is not None:
return e return e
changes = None changes = None
if flags(rev) & HASCOPIESINFO: if flags(rev) & HASCOPIESINFO:
changes = changelogrevision(rev).changes changes = changelogrevision(rev).changes
value = (p1, p2, changes) value = (p1, p2, changes)
if p1 != node.nullrev and p2 != node.nullrev: if p1 != nullrev and p2 != nullrev:
# XXX some case we over cache, IGNORE # XXX some case we over cache, IGNORE
merge_caches[rev] = value merge_caches[rev] = value
return value return value
return revinfo return revinfo
def cached_is_ancestor(is_ancestor): def cached_is_ancestor(is_ancestor):
if ret is None: if ret is None:
ret = cache[key] = is_ancestor(anc, desc) ret = cache[key] = is_ancestor(anc, desc)
return ret return ret
return _is_ancestor return _is_ancestor
def _changesetforwardcopies(a, b, match): def _changesetforwardcopies(a, b, match):
if a.rev() in (node.nullrev, b.rev()): if a.rev() in (nullrev, b.rev()):
return {} return {}
repo = a.repo().unfiltered() repo = a.repo().unfiltered()
children = {} children = {}
cl = repo.changelog cl = repo.changelog
isancestor = cl.isancestorrev isancestor = cl.isancestorrev
missingrevs = cl.findmissingrevs(common=[a.rev()], heads=[b.rev()]) missingrevs = cl.findmissingrevs(common=[a.rev()], heads=[b.rev()])
mrset = set(missingrevs) mrset = set(missingrevs)
roots = set() roots = set()
for r in missingrevs: for r in missingrevs:
for p in cl.parentrevs(r): for p in cl.parentrevs(r):
if p == node.nullrev: if p == nullrev:
continue continue
if p not in children: if p not in children:
children[p] = [r] children[p] = [r]
else: else:
children[p].append(r) children[p].append(r)
if p not in mrset: if p not in mrset:
roots.add(p) roots.add(p)
if not roots: if not roots:
def ismerged(path): def ismerged(path):
if path not in ctx.files(): if path not in ctx.files():
return False return False
fctx = ctx[path] fctx = ctx[path]
parents = fctx._filelog.parents(fctx._filenode) parents = fctx._filelog.parents(fctx._filenode)
nb_parents = 0 nb_parents = 0
for n in parents: for n in parents:
if n != node.nullid: if n != nullid:
nb_parents += 1 nb_parents += 1
return nb_parents >= 2 return nb_parents >= 2
return ismerged return ismerged
def revinfo(rev): def revinfo(rev):
p1, p2 = parents(rev) p1, p2 = parents(rev)
ctx = repo[rev] ctx = repo[rev]
elif a == y: elif a == y:
if debug: if debug:
repo.ui.debug(b'debug.copies: search mode: backward\n') repo.ui.debug(b'debug.copies: search mode: backward\n')
copies = _backwardrenames(x, y, match=match) copies = _backwardrenames(x, y, match=match)
else: else:
if debug: if debug:
repo.ui.debug(b'debug.copies: search mode: combined\n') repo.ui.debug(b'debug.copies: search mode: combined\n')
base = None base = None
if a.rev() != node.nullrev: if a.rev() != nullrev:
base = x base = x
copies = _chain( copies = _chain(
_backwardrenames(x, a, match=match), _backwardrenames(x, a, match=match),
_forwardcopies(a, y, base, match=match), _forwardcopies(a, y, base, match=match),
) )
_filter(x, y, copies) _filter(x, y, copies)
return copies return copies

mercurial/dagop.py

# dagop.py - graph ancestry and topology algorithm for revset # dagop.py - graph ancestry and topology algorithm for revset
# #
# Copyright 2010 Matt Mackall <mpm@selenic.com> # Copyright 2010 Matt Mackall <mpm@selenic.com>
# #
# This software may be used and distributed according to the terms of the # This software may be used and distributed according to the terms of the
# GNU General Public License version 2 or any later version. # GNU General Public License version 2 or any later version.
from __future__ import absolute_import from __future__ import absolute_import
import heapq import heapq
from .node import nullrev from .node import nullrev
from .thirdparty import attr from .thirdparty import attr
from .node import nullrev
from . import ( from . import (
error, error,
mdiff, mdiff,
node,
patch, patch,
pycompat, pycompat,
scmutil, scmutil,
smartset, smartset,
) )
baseset = smartset.baseset baseset = smartset.baseset
generatorset = smartset.generatorset generatorset = smartset.generatorset
# of the same revision are iterated from the lowest depth # of the same revision are iterated from the lowest depth
foundnew = currev != lastrev foundnew = currev != lastrev
if foundnew and curdepth >= startdepth: if foundnew and curdepth >= startdepth:
lastrev = currev lastrev = currev
yield currev yield currev
pdepth = curdepth + 1 pdepth = curdepth + 1
if foundnew and pdepth < stopdepth: if foundnew and pdepth < stopdepth:
for prev in pfunc(currev): for prev in pfunc(currev):
if prev != node.nullrev: if prev != nullrev:
heapq.heappush(pendingheap, (heapsign * prev, pdepth)) heapq.heappush(pendingheap, (heapsign * prev, pdepth))
def filectxancestors(fctxs, followfirst=False): def filectxancestors(fctxs, followfirst=False):
"""Like filectx.ancestors(), but can walk from multiple files/revisions, """Like filectx.ancestors(), but can walk from multiple files/revisions,
and includes the given fctxs themselves and includes the given fctxs themselves
Yields (rev, {fctx, ...}) pairs in descending order. Yields (rev, {fctx, ...}) pairs in descending order.
def _genrevdescendants(repo, revs, followfirst): def _genrevdescendants(repo, revs, followfirst):
if followfirst: if followfirst:
cut = 1 cut = 1
else: else:
cut = None cut = None
cl = repo.changelog cl = repo.changelog
first = revs.min() first = revs.min()
nullrev = node.nullrev
if first == nullrev: if first == nullrev:
# Are there nodes with a null first parent and a non-null # Are there nodes with a null first parent and a non-null
# second one? Maybe. Do we care? Probably not. # second one? Maybe. Do we care? Probably not.
yield first yield first
for i in cl: for i in cl:
yield i yield i
else: else:
seen = set(revs) seen = set(revs)
for i in cl.revs(first): for i in cl.revs(first):
if i in seen: if i in seen:
yield i yield i
continue continue
for x in cl.parentrevs(i)[:cut]: for x in cl.parentrevs(i)[:cut]:
if x != nullrev and x in seen: if x != nullrev and x in seen:
seen.add(i) seen.add(i)
yield i yield i
break break
def _builddescendantsmap(repo, startrev, followfirst): def _builddescendantsmap(repo, startrev, followfirst):
"""Build map of 'rev -> child revs', offset from startrev""" """Build map of 'rev -> child revs', offset from startrev"""
cl = repo.changelog cl = repo.changelog
nullrev = node.nullrev
descmap = [[] for _rev in pycompat.xrange(startrev, len(cl))] descmap = [[] for _rev in pycompat.xrange(startrev, len(cl))]
for currev in cl.revs(startrev + 1): for currev in cl.revs(startrev + 1):
p1rev, p2rev = cl.parentrevs(currev) p1rev, p2rev = cl.parentrevs(currev)
if p1rev >= startrev: if p1rev >= startrev:
descmap[p1rev - startrev].append(currev) descmap[p1rev - startrev].append(currev)
if not followfirst and p2rev != nullrev and p2rev >= startrev: if not followfirst and p2rev != nullrev and p2rev >= startrev:
descmap[p2rev - startrev].append(currev) descmap[p2rev - startrev].append(currev)
return descmap return descmap
# after the subgroup merging because all elements from a subgroup # after the subgroup merging because all elements from a subgroup
# that relied on this rev must precede it. # that relied on this rev must precede it.
# #
# we also update the <parents> set to include the parents of the # we also update the <parents> set to include the parents of the
# new nodes. # new nodes.
if rev == currentrev: # only display stuff in rev if rev == currentrev: # only display stuff in rev
gr[0].append(rev) gr[0].append(rev)
gr[1].remove(rev) gr[1].remove(rev)
parents = [p for p in parentsfunc(rev) if p > node.nullrev] parents = [p for p in parentsfunc(rev) if p > nullrev]
gr[1].update(parents) gr[1].update(parents)
for p in parents: for p in parents:
if p not in pendingset: if p not in pendingset:
pendingset.add(p) pendingset.add(p)
heappush(pendingheap, -p) heappush(pendingheap, -p)
# Look for a subgroup to display # Look for a subgroup to display
# #
Returns a set of revision numbers that are DAG heads within the passed Returns a set of revision numbers that are DAG heads within the passed
subset. subset.
``nullrev`` is never included in the returned set, even if it is provided in ``nullrev`` is never included in the returned set, even if it is provided in
the input set. the input set.
""" """
headrevs = set(revs) headrevs = set(revs)
parents = {node.nullrev} parents = {nullrev}
up = parents.update up = parents.update
for rev in revs: for rev in revs:
up(parentsfn(rev)) up(parentsfn(rev))
headrevs.difference_update(parents) headrevs.difference_update(parents)
return headrevs return headrevs
if rev not in finished: if rev not in finished:
result.append(rev) result.append(rev)
finished.add(rev) finished.add(rev)
else: else:
visit.append(-rev - 1) visit.append(-rev - 1)
for prev in parentsfn(rev): for prev in parentsfn(rev):
if prev == node.nullrev or prev not in revs or prev in finished: if prev == nullrev or prev not in revs or prev in finished:
continue continue
visit.append(prev) visit.append(prev)
assert len(result) == len(revs) assert len(result) == len(revs)
return result return result

mercurial/hg.py

# hg.py - repository classes for mercurial # hg.py - repository classes for mercurial
# #
# Copyright 2005-2007 Matt Mackall <mpm@selenic.com> # Copyright 2005-2007 Matt Mackall <mpm@selenic.com>
# Copyright 2006 Vadim Gelfer <vadim.gelfer@gmail.com> # Copyright 2006 Vadim Gelfer <vadim.gelfer@gmail.com>
# #
# This software may be used and distributed according to the terms of the # This software may be used and distributed according to the terms of the
# GNU General Public License version 2 or any later version. # GNU General Public License version 2 or any later version.
from __future__ import absolute_import from __future__ import absolute_import
import errno import errno
import os import os
import shutil import shutil
import stat import stat
from .i18n import _ from .i18n import _
from .node import nullid from .node import (
hex,
nullhex,
nullid,
short,
)
from .pycompat import getattr from .pycompat import getattr
from . import ( from . import (
bookmarks, bookmarks,
bundlerepo, bundlerepo,
cacheutil, cacheutil,
cmdutil, cmdutil,
destutil, destutil,
discovery, discovery,
error, error,
exchange, exchange,
extensions, extensions,
httppeer, httppeer,
localrepo, localrepo,
lock, lock,
logcmdutil, logcmdutil,
logexchange, logexchange,
merge as mergemod, merge as mergemod,
mergestate as mergestatemod, mergestate as mergestatemod,
narrowspec, narrowspec,
node,
phases, phases,
pycompat, pycompat,
requirements, requirements,
scmutil, scmutil,
sshpeer, sshpeer,
statichttprepo, statichttprepo,
ui as uimod, ui as uimod,
unionrepo, unionrepo,
branchmap = e.callcommand(b'branchmap', {}).result() branchmap = e.callcommand(b'branchmap', {}).result()
def primary(branch): def primary(branch):
if branch == b'.': if branch == b'.':
if not lrepo: if not lrepo:
raise error.Abort(_(b"dirstate branch not accessible")) raise error.Abort(_(b"dirstate branch not accessible"))
branch = lrepo.dirstate.branch() branch = lrepo.dirstate.branch()
if branch in branchmap: if branch in branchmap:
revs.extend(node.hex(r) for r in reversed(branchmap[branch])) revs.extend(hex(r) for r in reversed(branchmap[branch]))
return True return True
else: else:
return False return False
for branch in branches: for branch in branches:
if not primary(branch): if not primary(branch):
raise error.RepoLookupError(_(b"unknown branch '%s'") % branch) raise error.RepoLookupError(_(b"unknown branch '%s'") % branch)
if hashbranch: if hashbranch:
with srcpeer.commandexecutor() as e: with srcpeer.commandexecutor() as e:
rootnode = e.callcommand( rootnode = e.callcommand(
b'lookup', b'lookup',
{ {
b'key': b'0', b'key': b'0',
}, },
).result() ).result()
if rootnode != node.nullid: if rootnode != nullid:
sharepath = os.path.join(sharepool, node.hex(rootnode)) sharepath = os.path.join(sharepool, hex(rootnode))
else: else:
ui.status( ui.status(
_( _(
b'(not using pooled storage: ' b'(not using pooled storage: '
b'remote appears to be empty)\n' b'remote appears to be empty)\n'
) )
) )
except error.RepoLookupError: except error.RepoLookupError:
ui.status( ui.status(
_( _(
b'(not using pooled storage: ' b'(not using pooled storage: '
b'unable to resolve identity of remote)\n' b'unable to resolve identity of remote)\n'
) )
) )
elif sharenamemode == b'remote': elif sharenamemode == b'remote':
sharepath = os.path.join( sharepath = os.path.join(
sharepool, node.hex(hashutil.sha1(source).digest()) sharepool, hex(hashutil.sha1(source).digest())
) )
else: else:
raise error.Abort( raise error.Abort(
_(b'unknown share naming mode: %s') % sharenamemode _(b'unknown share naming mode: %s') % sharenamemode
) )
# TODO this is a somewhat arbitrary restriction. # TODO this is a somewhat arbitrary restriction.
if narrow: if narrow:
dstcachedir = os.path.join(destpath, b'cache') dstcachedir = os.path.join(destpath, b'cache')
for cache in cacheutil.cachetocopy(srcrepo): for cache in cacheutil.cachetocopy(srcrepo):
_copycache(srcrepo, dstcachedir, cache) _copycache(srcrepo, dstcachedir, cache)
# we need to re-init the repo after manually copying the data # we need to re-init the repo after manually copying the data
# into it # into it
destpeer = peer(srcrepo, peeropts, dest) destpeer = peer(srcrepo, peeropts, dest)
srcrepo.hook( srcrepo.hook(
b'outgoing', source=b'clone', node=node.hex(node.nullid) b'outgoing', source=b'clone', node=nullhex
) )
else: else:
try: try:
# only pass ui when no srcrepo # only pass ui when no srcrepo
destpeer = peer( destpeer = peer(
srcrepo or ui, srcrepo or ui,
peeropts, peeropts,
dest, dest,
ret = ( ret = (
ctx.sub(subpath, allowcreate=False).verify() or ret ctx.sub(subpath, allowcreate=False).verify() or ret
) )
except error.RepoError as e: except error.RepoError as e:
repo.ui.warn(b'%d: %s\n' % (rev, e)) repo.ui.warn(b'%d: %s\n' % (rev, e))
except Exception: except Exception:
repo.ui.warn( repo.ui.warn(
_(b'.hgsubstate is corrupt in revision %s\n') _(b'.hgsubstate is corrupt in revision %s\n')
% node.short(ctx.node()) % short(ctx.node())
) )
return ret return ret
def remoteui(src, opts): def remoteui(src, opts):
"""build a remote ui from ui or repo and opts""" """build a remote ui from ui or repo and opts"""
if util.safehasattr(src, b'baseui'): # looks like a repository if util.safehasattr(src, b'baseui'): # looks like a repository

mercurial/keepalive.py

import errno import errno
import hashlib import hashlib
import socket import socket
import sys import sys
import threading import threading
from .i18n import _ from .i18n import _
from .pycompat import getattr from .pycompat import getattr
from .node import hex
from . import ( from . import (
node,
pycompat, pycompat,
urllibcompat, urllibcompat,
util, util,
) )
from .utils import procutil from .utils import procutil
httplib = util.httplib httplib = util.httplib
urlerr = util.urlerr urlerr = util.urlerr
# first fetch the file with the normal http handler # first fetch the file with the normal http handler
opener = urlreq.buildopener() opener = urlreq.buildopener()
urlreq.installopener(opener) urlreq.installopener(opener)
fo = urlreq.urlopen(url) fo = urlreq.urlopen(url)
foo = fo.read() foo = fo.read()
fo.close() fo.close()
m = md5(foo) m = md5(foo)
print(format % (b'normal urllib', node.hex(m.digest()))) print(format % (b'normal urllib', hex(m.digest())))
# now install the keepalive handler and try again # now install the keepalive handler and try again
opener = urlreq.buildopener(HTTPHandler()) opener = urlreq.buildopener(HTTPHandler())
urlreq.installopener(opener) urlreq.installopener(opener)
fo = urlreq.urlopen(url) fo = urlreq.urlopen(url)
foo = fo.read() foo = fo.read()
fo.close() fo.close()
m = md5(foo) m = md5(foo)
print(format % (b'keepalive read', node.hex(m.digest()))) print(format % (b'keepalive read', hex(m.digest())))
fo = urlreq.urlopen(url) fo = urlreq.urlopen(url)
foo = b'' foo = b''
while True: while True:
f = fo.readline() f = fo.readline()
if f: if f:
foo = foo + f foo = foo + f
else: else:
break break
fo.close() fo.close()
m = md5(foo) m = md5(foo)
print(format % (b'keepalive readline', node.hex(m.digest()))) print(format % (b'keepalive readline', hex(m.digest())))
def comp(N, url): def comp(N, url):
print(b' making %i connections to:\n %s' % (N, url)) print(b' making %i connections to:\n %s' % (N, url))
procutil.stdout.write(b' first using the normal urllib handlers') procutil.stdout.write(b' first using the normal urllib handlers')
# first use normal opener # first use normal opener
opener = urlreq.buildopener() opener = urlreq.buildopener()

mercurial/metadata.py

# coding: utf-8 # coding: utf-8
# metadata.py -- code related to various metadata computation and access. # metadata.py -- code related to various metadata computation and access.
# #
# Copyright 2019 Google, Inc <martinvonz@google.com> # Copyright 2019 Google, Inc <martinvonz@google.com>
# Copyright 2020 Pierre-Yves David <pierre-yves.david@octobus.net> # Copyright 2020 Pierre-Yves David <pierre-yves.david@octobus.net>
# #
# This software may be used and distributed according to the terms of the # This software may be used and distributed according to the terms of the
# GNU General Public License version 2 or any later version. # GNU General Public License version 2 or any later version.
from __future__ import absolute_import, print_function from __future__ import absolute_import, print_function
import multiprocessing import multiprocessing
import struct import struct
from .node import (
nullid,
nullrev,
)
from . import ( from . import (
error, error,
node,
pycompat, pycompat,
util, util,
) )
from .revlogutils import ( from .revlogutils import (
flagutil as sidedataflag, flagutil as sidedataflag,
sidedata as sidedatamod, sidedata as sidedatamod,
) )
for dest, source in copies.items(): for dest, source in copies.items():
self.mark_copied_from_p2(source, dest) self.mark_copied_from_p2(source, dest)
def compute_all_files_changes(ctx): def compute_all_files_changes(ctx):
"""compute the files changed by a revision""" """compute the files changed by a revision"""
p1 = ctx.p1() p1 = ctx.p1()
p2 = ctx.p2() p2 = ctx.p2()
if p1.rev() == node.nullrev and p2.rev() == node.nullrev: if p1.rev() == nullrev and p2.rev() == nullrev:
return _process_root(ctx) return _process_root(ctx)
elif p1.rev() != node.nullrev and p2.rev() == node.nullrev: elif p1.rev() != nullrev and p2.rev() == nullrev:
return _process_linear(p1, ctx) return _process_linear(p1, ctx)
elif p1.rev() == node.nullrev and p2.rev() != node.nullrev: elif p1.rev() == nullrev and p2.rev() != nullrev:
# In the wild, one can encounter changeset where p1 is null but p2 is not # In the wild, one can encounter changeset where p1 is null but p2 is not
return _process_linear(p1, ctx, parent=2) return _process_linear(p1, ctx, parent=2)
elif p1.rev() == p2.rev(): elif p1.rev() == p2.rev():
# In the wild, one can encounter such "non-merge" # In the wild, one can encounter such "non-merge"
return _process_linear(p1, ctx) return _process_linear(p1, ctx)
else: else:
return _process_merge(p1, p2, ctx) return _process_merge(p1, p2, ctx)
p2m = p2_ctx.manifest() p2m = p2_ctx.manifest()
diff_p1 = p1m.diff(m) diff_p1 = p1m.diff(m)
diff_p2 = p2m.diff(m) diff_p2 = p2m.diff(m)
cahs = ctx.repo().changelog.commonancestorsheads( cahs = ctx.repo().changelog.commonancestorsheads(
p1_ctx.node(), p2_ctx.node() p1_ctx.node(), p2_ctx.node()
) )
if not cahs: if not cahs:
cahs = [node.nullrev] cahs = [nullrev]
mas = [ctx.repo()[r].manifest() for r in cahs] mas = [ctx.repo()[r].manifest() for r in cahs]
copy_candidates = [] copy_candidates = []
# Dealing with case 🄰 happens automatically. Since there are no entry in # Dealing with case 🄰 happens automatically. Since there are no entry in
# d1 nor d2, we won't iterate on it ever. # d1 nor d2, we won't iterate on it ever.
# Iteration over d1 content will deal with all cases, but the one in the # Iteration over d1 content will deal with all cases, but the one in the
m2 = p2.manifest() m2 = p2.manifest()
@util.cachefunc @util.cachefunc
def mas(): def mas():
p1n = p1.node() p1n = p1.node()
p2n = p2.node() p2n = p2.node()
cahs = ctx.repo().changelog.commonancestorsheads(p1n, p2n) cahs = ctx.repo().changelog.commonancestorsheads(p1n, p2n)
if not cahs: if not cahs:
cahs = [node.nullrev] cahs = [nullrev]
return [ctx.repo()[r].manifest() for r in cahs] return [ctx.repo()[r].manifest() for r in cahs]
def deletionfromparent(f): def deletionfromparent(f):
if f in m1: if f in m1:
return f not in m2 and all( return f not in m2 and all(
f in ma and ma.find(f) == m1.find(f) for ma in mas() f in ma and ma.find(f) == m1.find(f) for ma in mas()
) )
elif f in m2: elif f in m2:
"""return the list of files merged in a changeset""" """return the list of files merged in a changeset"""
merged = [] merged = []
if len(ctx.parents()) < 2: if len(ctx.parents()) < 2:
return merged return merged
for f in ctx.files(): for f in ctx.files():
if f in ctx: if f in ctx:
fctx = ctx[f] fctx = ctx[f]
parents = fctx._filelog.parents(fctx._filenode) parents = fctx._filelog.parents(fctx._filenode)
if parents[1] != node.nullid: if parents[1] != nullid:
merged.append(f) merged.append(f)
return merged return merged
def computechangesetcopies(ctx): def computechangesetcopies(ctx):
"""return the copies data for a changeset """return the copies data for a changeset
The copies data are returned as a pair of dictionnary (p1copies, p2copies). The copies data are returned as a pair of dictionnary (p1copies, p2copies).

mercurial/obsolete.py

""" """
from __future__ import absolute_import from __future__ import absolute_import
import errno import errno
import struct import struct
from .i18n import _ from .i18n import _
from .pycompat import getattr from .pycompat import getattr
from .node import (
bin,
hex,
nullid,
)
from . import ( from . import (
encoding, encoding,
error, error,
node,
obsutil, obsutil,
phases, phases,
policy, policy,
pycompat, pycompat,
util, util,
) )
from .utils import ( from .utils import (
dateutil, dateutil,
if b'p2' in metadata: if b'p2' in metadata:
parents = (metadata.pop(b'p1', None), metadata.pop(b'p2', None)) parents = (metadata.pop(b'p1', None), metadata.pop(b'p2', None))
elif b'p1' in metadata: elif b'p1' in metadata:
parents = (metadata.pop(b'p1', None),) parents = (metadata.pop(b'p1', None),)
elif b'p0' in metadata: elif b'p0' in metadata:
parents = () parents = ()
if parents is not None: if parents is not None:
try: try:
parents = tuple(node.bin(p) for p in parents) parents = tuple(bin(p) for p in parents)
# if parent content is not a nodeid, drop the data # if parent content is not a nodeid, drop the data
for p in parents: for p in parents:
if len(p) != 20: if len(p) != 20:
parents = None parents = None
break break
except TypeError: except TypeError:
# if content cannot be translated to nodeid drop the data. # if content cannot be translated to nodeid drop the data.
parents = None parents = None
metadata = dict(metadata) metadata = dict(metadata)
time, tz = date time, tz = date
metadata[b'date'] = b'%r %i' % (time, tz) metadata[b'date'] = b'%r %i' % (time, tz)
if parents is not None: if parents is not None:
if not parents: if not parents:
# mark that we explicitly recorded no parents # mark that we explicitly recorded no parents
metadata[b'p0'] = b'' metadata[b'p0'] = b''
for i, p in enumerate(parents, 1): for i, p in enumerate(parents, 1):
metadata[b'p%i' % i] = node.hex(p) metadata[b'p%i' % i] = hex(p)
metadata = _fm0encodemeta(metadata) metadata = _fm0encodemeta(metadata)
numsuc = len(sucs) numsuc = len(sucs)
format = _fm0fixed + (_fm0node * numsuc) format = _fm0fixed + (_fm0node * numsuc)
data = [numsuc, len(metadata), flags, pre] data = [numsuc, len(metadata), flags, pre]
data.extend(sucs) data.extend(sucs)
return _pack(format, *data) + metadata return _pack(format, *data) + metadata
def _checkinvalidmarkers(markers): def _checkinvalidmarkers(markers):
"""search for marker with invalid data and raise error if needed """search for marker with invalid data and raise error if needed
Exist as a separated function to allow the evolve extension for a more Exist as a separated function to allow the evolve extension for a more
subtle handling. subtle handling.
""" """
for mark in markers: for mark in markers:
if node.nullid in mark[1]: if nullid in mark[1]:
raise error.Abort( raise error.Abort(
_( _(
b'bad obsolescence marker detected: ' b'bad obsolescence marker detected: '
b'invalid successors nullid' b'invalid successors nullid'
) )
) )
else: else:
if len(prec) != 20: if len(prec) != 20:
raise ValueError(prec) raise ValueError(prec)
for succ in succs: for succ in succs:
if len(succ) != 20: if len(succ) != 20:
raise ValueError(succ) raise ValueError(succ)
if prec in succs: if prec in succs:
raise ValueError( raise ValueError(
'in-marker cycle with %s' % pycompat.sysstr(node.hex(prec)) 'in-marker cycle with %s' % pycompat.sysstr(hex(prec))
) )
metadata = tuple(sorted(pycompat.iteritems(metadata))) metadata = tuple(sorted(pycompat.iteritems(metadata)))
for k, v in metadata: for k, v in metadata:
try: try:
# might be better to reject non-ASCII keys # might be better to reject non-ASCII keys
k.decode('utf-8') k.decode('utf-8')
v.decode('utf-8') v.decode('utf-8')
def makefoldid(relation, user): def makefoldid(relation, user):
folddigest = hashutil.sha1(user) folddigest = hashutil.sha1(user)
for p in relation[0] + relation[1]: for p in relation[0] + relation[1]:
folddigest.update(b'%d' % p.rev()) folddigest.update(b'%d' % p.rev())
folddigest.update(p.node()) folddigest.update(p.node())
# Since fold only has to compete against fold for the same successors, it # Since fold only has to compete against fold for the same successors, it
# seems fine to use a small ID. Smaller ID save space. # seems fine to use a small ID. Smaller ID save space.
return node.hex(folddigest.digest())[:8] return hex(folddigest.digest())[:8]
def createmarkers( def createmarkers(
repo, relations, flag=0, date=None, metadata=None, operation=None repo, relations, flag=0, date=None, metadata=None, operation=None
): ):
"""Add obsolete markers between changesets in a repo """Add obsolete markers between changesets in a repo
<relations> must be an iterable of ((<old>,...), (<new>, ...)[,{metadata}]) <relations> must be an iterable of ((<old>,...), (<new>, ...)[,{metadata}])

mercurial/obsutil.py

# obsutil.py - utility functions for obsolescence # obsutil.py - utility functions for obsolescence
# #
# Copyright 2017 Boris Feld <boris.feld@octobus.net> # Copyright 2017 Boris Feld <boris.feld@octobus.net>
# #
# This software may be used and distributed according to the terms of the # This software may be used and distributed according to the terms of the
# GNU General Public License version 2 or any later version. # GNU General Public License version 2 or any later version.
from __future__ import absolute_import from __future__ import absolute_import
import re import re
from .i18n import _ from .i18n import _
from .node import (
hex,
short,
)
from . import ( from . import (
diffutil, diffutil,
encoding, encoding,
error, error,
node as nodemod,
phases, phases,
pycompat, pycompat,
util, util,
) )
from .utils import dateutil from .utils import dateutil
### obsolescence marker flag ### obsolescence marker flag
fate = _getobsfate(successors) fate = _getobsfate(successors)
# Be more precise in case the revision is superseded # Be more precise in case the revision is superseded
if fate == b'pruned': if fate == b'pruned':
return filteredmsgtable[b'pruned'] % changeid return filteredmsgtable[b'pruned'] % changeid
elif fate == b'diverged': elif fate == b'diverged':
return filteredmsgtable[b'diverged'] % changeid return filteredmsgtable[b'diverged'] % changeid
elif fate == b'superseded': elif fate == b'superseded':
single_successor = nodemod.short(successors[0][0]) single_successor = short(successors[0][0])
return filteredmsgtable[b'superseded'] % (changeid, single_successor) return filteredmsgtable[b'superseded'] % (changeid, single_successor)
elif fate == b'superseded_split': elif fate == b'superseded_split':
succs = [] succs = []
for node_id in successors[0]: for node_id in successors[0]:
succs.append(nodemod.short(node_id)) succs.append(short(node_id))
if len(succs) <= 2: if len(succs) <= 2:
fmtsuccs = b', '.join(succs) fmtsuccs = b', '.join(succs)
return filteredmsgtable[b'superseded_split'] % (changeid, fmtsuccs) return filteredmsgtable[b'superseded_split'] % (changeid, fmtsuccs)
else: else:
firstsuccessors = b', '.join(succs[:2]) firstsuccessors = b', '.join(succs[:2])
remainingnumber = len(succs) - 2 remainingnumber = len(succs) - 2
dsets = divergentsets(repo, ctx) dsets = divergentsets(repo, ctx)
for dset in dsets: for dset in dsets:
divnodes = [repo[n] for n in dset[b'divergentnodes']] divnodes = [repo[n] for n in dset[b'divergentnodes']]
result.append( result.append(
{ {
b'instability': b'content-divergent', b'instability': b'content-divergent',
b'divergentnodes': divnodes, b'divergentnodes': divnodes,
b'reason': b'predecessor', b'reason': b'predecessor',
b'node': nodemod.hex(dset[b'commonpredecessor']), b'node': hex(dset[b'commonpredecessor']),
} }
) )
return result return result

mercurial/revlogutils/nodemap.py

# nodemap.py - nodemap related code and utilities # nodemap.py - nodemap related code and utilities
# #
# Copyright 2019 Pierre-Yves David <pierre-yves.david@octobus.net> # Copyright 2019 Pierre-Yves David <pierre-yves.david@octobus.net>
# Copyright 2019 George Racinet <georges.racinet@octobus.net> # Copyright 2019 George Racinet <georges.racinet@octobus.net>
# #
# This software may be used and distributed according to the terms of the # This software may be used and distributed according to the terms of the
# GNU General Public License version 2 or any later version. # GNU General Public License version 2 or any later version.
from __future__ import absolute_import from __future__ import absolute_import
import errno import errno
import os import os
import re import re
import struct import struct
from ..i18n import _ from ..i18n import _
from ..node import hex
from .. import ( from .. import (
error, error,
node as nodemod,
util, util,
) )
class NodeMap(dict): class NodeMap(dict):
def __missing__(self, x): def __missing__(self, x):
raise error.RevlogError(b'unknown node: %s' % x) raise error.RevlogError(b'unknown node: %s' % x)
ID_SIZE = 8 ID_SIZE = 8
def _make_uid(): def _make_uid():
"""return a new unique identifier. """return a new unique identifier.
The identifier is random and composed of ascii characters.""" The identifier is random and composed of ascii characters."""
return nodemod.hex(os.urandom(ID_SIZE)) return hex(os.urandom(ID_SIZE))
class NodeMapDocket(object): class NodeMapDocket(object):
"""metadata associated with persistent nodemap data """metadata associated with persistent nodemap data
The persistent data may come from disk or be on their way to disk. The persistent data may come from disk or be on their way to disk.
""" """
The nodemap stores revision number for each unique prefix. The nodemap stores revision number for each unique prefix.
Each block is a dictionary with keys in `[0, 15]`. Values are either Each block is a dictionary with keys in `[0, 15]`. Values are either
another block or a revision number. another block or a revision number.
""" """
root = Block() root = Block()
for rev in range(len(index)): for rev in range(len(index)):
hex = nodemod.hex(index[rev][7]) current_hex = hex(index[rev][7])
_insert_into_block(index, 0, root, rev, hex) _insert_into_block(index, 0, root, rev, current_hex)
return root return root
def _update_trie(index, root, last_rev): def _update_trie(index, root, last_rev):
"""consume""" """consume"""
changed = 0 changed = 0
for rev in range(last_rev + 1, len(index)): for rev in range(last_rev + 1, len(index)):
hex = nodemod.hex(index[rev][7]) current_hex = hex(index[rev][7])
changed += _insert_into_block(index, 0, root, rev, hex) changed += _insert_into_block(index, 0, root, rev, current_hex)
return changed, root return changed, root
def _insert_into_block(index, level, block, current_rev, current_hex): def _insert_into_block(index, level, block, current_rev, current_hex):
"""insert a new revision in a block """insert a new revision in a block
index: the index we are adding revision for index: the index we are adding revision for
level: the depth of the current block in the trie level: the depth of the current block in the trie
elif isinstance(entry, dict): elif isinstance(entry, dict):
# need to recurse to an underlying block # need to recurse to an underlying block
changed += _insert_into_block( changed += _insert_into_block(
index, level + 1, entry, current_rev, current_hex index, level + 1, entry, current_rev, current_hex
) )
else: else:
# collision with a previously unique prefix, inserting new # collision with a previously unique prefix, inserting new
# vertices to fit both entry. # vertices to fit both entry.
other_hex = nodemod.hex(index[entry][7]) other_hex = hex(index[entry][7])
other_rev = entry other_rev = entry
new = Block() new = Block()
block[hex_digit] = new block[hex_digit] = new
_insert_into_block(index, level + 1, new, other_rev, other_hex) _insert_into_block(index, level + 1, new, other_rev, other_hex)
_insert_into_block(index, level + 1, new, current_rev, current_hex) _insert_into_block(index, level + 1, new, current_rev, current_hex)
return changed return changed
ui.status((b"revision in nodemap: %d\n") % len(all_revs)) ui.status((b"revision in nodemap: %d\n") % len(all_revs))
for r in range(len(index)): for r in range(len(index)):
if r not in all_revs: if r not in all_revs:
msg = b" revision missing from nodemap: %d\n" % r msg = b" revision missing from nodemap: %d\n" % r
ui.write_err(msg) ui.write_err(msg)
ret = 1 ret = 1
else: else:
all_revs.remove(r) all_revs.remove(r)
nm_rev = _find_node(root, nodemod.hex(index[r][7])) nm_rev = _find_node(root, hex(index[r][7]))
if nm_rev is None: if nm_rev is None:
msg = b" revision node does not match any entries: %d\n" % r msg = b" revision node does not match any entries: %d\n" % r
ui.write_err(msg) ui.write_err(msg)
ret = 1 ret = 1
elif nm_rev != r: elif nm_rev != r:
msg = ( msg = (
b" revision node does not match the expected revision: " b" revision node does not match the expected revision: "
b"%d != %d\n" % (r, nm_rev) b"%d != %d\n" % (r, nm_rev)

mercurial/revset.py

# revset.py - revision set queries for mercurial # revset.py - revision set queries for mercurial
# #
# Copyright 2010 Matt Mackall <mpm@selenic.com> # Copyright 2010 Matt Mackall <mpm@selenic.com>
# #
# This software may be used and distributed according to the terms of the # This software may be used and distributed according to the terms of the
# GNU General Public License version 2 or any later version. # GNU General Public License version 2 or any later version.
from __future__ import absolute_import from __future__ import absolute_import
import re import re
from .i18n import _ from .i18n import _
from .pycompat import getattr from .pycompat import getattr
from .node import (
bin,
nullrev,
wdirrev,
)
from . import ( from . import (
dagop, dagop,
destutil, destutil,
diffutil, diffutil,
encoding, encoding,
error, error,
grep as grepmod, grep as grepmod,
hbisect, hbisect,
match as matchmod, match as matchmod,
node,
obsolete as obsmod, obsolete as obsmod,
obsutil, obsutil,
pathutil, pathutil,
phases, phases,
pycompat, pycompat,
registrar, registrar,
repoview, repoview,
revsetlang, revsetlang,
getargsdict = revsetlang.getargsdict getargsdict = revsetlang.getargsdict
baseset = smartset.baseset baseset = smartset.baseset
generatorset = smartset.generatorset generatorset = smartset.generatorset
spanset = smartset.spanset spanset = smartset.spanset
fullreposet = smartset.fullreposet fullreposet = smartset.fullreposet
# revisions not included in all(), but populated if specified # revisions not included in all(), but populated if specified
_virtualrevs = (node.nullrev, node.wdirrev) _virtualrevs = (nullrev, wdirrev)
# Constants for ordering requirement, used in getset(): # Constants for ordering requirement, used in getset():
# #
# If 'define', any nested functions and operations MAY change the ordering of # If 'define', any nested functions and operations MAY change the ordering of
# the entries in the set (but if changes the ordering, it MUST ALWAYS change # the entries in the set (but if changes the ordering, it MUST ALWAYS change
# it). If 'follow', any nested functions and operations MUST take the ordering # it). If 'follow', any nested functions and operations MUST take the ordering
# specified by the first operand to the '&' operator. # specified by the first operand to the '&' operator.
# #
return _makerangeset( return _makerangeset(
repo, subset, m.first(), repo.changelog.tiprev(), order repo, subset, m.first(), repo.changelog.tiprev(), order
) )
def _makerangeset(repo, subset, m, n, order): def _makerangeset(repo, subset, m, n, order):
if m == n: if m == n:
r = baseset([m]) r = baseset([m])
elif n == node.wdirrev: elif n == wdirrev:
r = spanset(repo, m, len(repo)) + baseset([n]) r = spanset(repo, m, len(repo)) + baseset([n])
elif m == node.wdirrev: elif m == wdirrev:
r = baseset([m]) + spanset(repo, repo.changelog.tiprev(), n - 1) r = baseset([m]) + spanset(repo, repo.changelog.tiprev(), n - 1)
elif m < n: elif m < n:
r = spanset(repo, m, n + 1) r = spanset(repo, m, n + 1)
else: else:
r = spanset(repo, m, n - 1) r = spanset(repo, m, n - 1)
if order == defineorder: if order == defineorder:
return r & subset return r & subset
matchrevs = set() matchrevs = set()
for name, bmrev in pycompat.iteritems(repo._bookmarks): for name, bmrev in pycompat.iteritems(repo._bookmarks):
if matcher(name): if matcher(name):
matchrevs.add(bmrev) matchrevs.add(bmrev)
for bmrev in matchrevs: for bmrev in matchrevs:
bms.add(repo[bmrev].rev()) bms.add(repo[bmrev].rev())
else: else:
bms = {repo[r].rev() for r in repo._bookmarks.values()} bms = {repo[r].rev() for r in repo._bookmarks.values()}
bms -= {node.nullrev} bms -= {nullrev}
return subset & bms return subset & bms
@predicate(b'branch(string or set)', safe=True, weight=10) @predicate(b'branch(string or set)', safe=True, weight=10)
def branch(repo, subset, x): def branch(repo, subset, x):
""" """
All changesets belonging to the given branch or the branches of the given All changesets belonging to the given branch or the branches of the given
changesets. changesets.
def _children(repo, subset, parentset): def _children(repo, subset, parentset):
if not parentset: if not parentset:
return baseset() return baseset()
cs = set() cs = set()
pr = repo.changelog.parentrevs pr = repo.changelog.parentrevs
minrev = parentset.min() minrev = parentset.min()
nullrev = node.nullrev
for r in subset: for r in subset:
if r <= minrev: if r <= minrev:
continue continue
p1, p2 = pr(r) p1, p2 = pr(r)
if p1 in parentset: if p1 in parentset:
cs.add(r) cs.add(r)
if p2 != nullrev and p2 in parentset: if p2 != nullrev and p2 in parentset:
cs.add(r) cs.add(r)
elif prefix == b'x:': elif prefix == b'x:':
exc.append(value) exc.append(value)
elif prefix == b'r:': elif prefix == b'r:':
if rev is not None: if rev is not None:
raise error.ParseError( raise error.ParseError(
b'_matchfiles expected at most one revision' b'_matchfiles expected at most one revision'
) )
if value == b'': # empty means working directory if value == b'': # empty means working directory
rev = node.wdirrev rev = wdirrev
else: else:
rev = value rev = value
elif prefix == b'd:': elif prefix == b'd:':
if default is not None: if default is not None:
raise error.ParseError( raise error.ParseError(
b'_matchfiles expected at most one default mode' b'_matchfiles expected at most one default mode'
) )
default = value default = value
else: else:
raise error.ParseError(b'invalid _matchfiles prefix: %s' % prefix) raise error.ParseError(b'invalid _matchfiles prefix: %s' % prefix)
if not default: if not default:
default = b'glob' default = b'glob'
hasset = any(matchmod.patkind(p) == b'set' for p in pats + inc + exc) hasset = any(matchmod.patkind(p) == b'set' for p in pats + inc + exc)
mcache = [None] mcache = [None]
# This directly read the changelog data as creating changectx for all # This directly read the changelog data as creating changectx for all
# revisions is quite expensive. # revisions is quite expensive.
getfiles = repo.changelog.readfiles getfiles = repo.changelog.readfiles
wdirrev = node.wdirrev
def matches(x): def matches(x):
if x == wdirrev: if x == wdirrev:
files = repo[x].files() files = repo[x].files()
else: else:
files = getfiles(x) files = getfiles(x)
if not mcache[0] or (hasset and rev is None): if not mcache[0] or (hasset and rev is None):
@predicate(b'heads(set)', safe=True, takeorder=True) @predicate(b'heads(set)', safe=True, takeorder=True)
def heads(repo, subset, x, order): def heads(repo, subset, x, order):
"""Members of set with no children in set.""" """Members of set with no children in set."""
# argument set should never define order # argument set should never define order
if order == defineorder: if order == defineorder:
order = followorder order = followorder
inputset = getset(repo, fullreposet(repo), x, order=order) inputset = getset(repo, fullreposet(repo), x, order=order)
wdirparents = None wdirparents = None
if node.wdirrev in inputset: if wdirrev in inputset:
# a bit slower, but not common so good enough for now # a bit slower, but not common so good enough for now
wdirparents = [p.rev() for p in repo[None].parents()] wdirparents = [p.rev() for p in repo[None].parents()]
inputset = set(inputset) inputset = set(inputset)
inputset.discard(node.wdirrev) inputset.discard(wdirrev)
heads = repo.changelog.headrevs(inputset) heads = repo.changelog.headrevs(inputset)
if wdirparents is not None: if wdirparents is not None:
heads.difference_update(wdirparents) heads.difference_update(wdirparents)
heads.add(node.wdirrev) heads.add(wdirrev)
heads = baseset(heads) heads = baseset(heads)
return subset & heads return subset & heads
@predicate(b'hidden()', safe=True) @predicate(b'hidden()', safe=True)
def hidden(repo, subset, x): def hidden(repo, subset, x):
"""Hidden changesets.""" """Hidden changesets."""
# i18n: "hidden" is a keyword # i18n: "hidden" is a keyword
@predicate(b'merge()', safe=True) @predicate(b'merge()', safe=True)
def merge(repo, subset, x): def merge(repo, subset, x):
"""Changeset is a merge changeset.""" """Changeset is a merge changeset."""
# i18n: "merge" is a keyword # i18n: "merge" is a keyword
getargs(x, 0, 0, _(b"merge takes no arguments")) getargs(x, 0, 0, _(b"merge takes no arguments"))
cl = repo.changelog cl = repo.changelog
nullrev = node.nullrev
def ismerge(r): def ismerge(r):
try: try:
return cl.parentrevs(r)[1] != nullrev return cl.parentrevs(r)[1] != nullrev
except error.WdirUnsupported: except error.WdirUnsupported:
return bool(repo[r].p2()) return bool(repo[r].p2())
return subset.filter(ismerge, condrepr=b'<merge>') return subset.filter(ismerge, condrepr=b'<merge>')
namespaces.add(ns) namespaces.add(ns)
names = set() names = set()
for ns in namespaces: for ns in namespaces:
for name in ns.listnames(repo): for name in ns.listnames(repo):
if name not in ns.deprecated: if name not in ns.deprecated:
names.update(repo[n].rev() for n in ns.nodes(repo, name)) names.update(repo[n].rev() for n in ns.nodes(repo, name))
names -= {node.nullrev} names -= {nullrev}
return subset & names return subset & names
@predicate(b'id(string)', safe=True) @predicate(b'id(string)', safe=True)
def node_(repo, subset, x): def node_(repo, subset, x):
"""Revision non-ambiguously specified by the given hex string prefix.""" """Revision non-ambiguously specified by the given hex string prefix."""
# i18n: "id" is a keyword # i18n: "id" is a keyword
l = getargs(x, 1, 1, _(b"id requires one argument")) l = getargs(x, 1, 1, _(b"id requires one argument"))
# i18n: "id" is a keyword # i18n: "id" is a keyword
n = getstring(l[0], _(b"id requires a string")) n = getstring(l[0], _(b"id requires a string"))
if len(n) == 40: if len(n) == 40:
try: try:
rn = repo.changelog.rev(node.bin(n)) rn = repo.changelog.rev(bin(n))
except error.WdirUnsupported: except error.WdirUnsupported:
rn = node.wdirrev rn = wdirrev
except (LookupError, TypeError): except (LookupError, TypeError):
rn = None rn = None
else: else:
rn = None rn = None
try: try:
pm = scmutil.resolvehexnodeidprefix(repo, n) pm = scmutil.resolvehexnodeidprefix(repo, n)
if pm is not None: if pm is not None:
rn = repo.changelog.rev(pm) rn = repo.changelog.rev(pm)
except LookupError: except LookupError:
pass pass
except error.WdirUnsupported: except error.WdirUnsupported:
rn = node.wdirrev rn = wdirrev
if rn is None: if rn is None:
return baseset() return baseset()
result = baseset([rn]) result = baseset([rn])
return result & subset return result & subset
@predicate(b'none()', safe=True) @predicate(b'none()', safe=True)
ps = set() ps = set()
cl = repo.changelog cl = repo.changelog
for r in getset(repo, fullreposet(repo), x): for r in getset(repo, fullreposet(repo), x):
try: try:
ps.add(cl.parentrevs(r)[0]) ps.add(cl.parentrevs(r)[0])
except error.WdirUnsupported: except error.WdirUnsupported:
ps.add(repo[r].p1().rev()) ps.add(repo[r].p1().rev())
ps -= {node.nullrev} ps -= {nullrev}
# XXX we should turn this into a baseset instead of a set, smartset may do # XXX we should turn this into a baseset instead of a set, smartset may do
# some optimizations from the fact this is a baseset. # some optimizations from the fact this is a baseset.
return subset & ps return subset & ps
@predicate(b'p2([set])', safe=True) @predicate(b'p2([set])', safe=True)
def p2(repo, subset, x): def p2(repo, subset, x):
"""Second parent of changesets in set, or the working directory.""" """Second parent of changesets in set, or the working directory."""
cl = repo.changelog cl = repo.changelog
for r in getset(repo, fullreposet(repo), x): for r in getset(repo, fullreposet(repo), x):
try: try:
ps.add(cl.parentrevs(r)[1]) ps.add(cl.parentrevs(r)[1])
except error.WdirUnsupported: except error.WdirUnsupported:
parents = repo[r].parents() parents = repo[r].parents()
if len(parents) == 2: if len(parents) == 2:
ps.add(parents[1]) ps.add(parents[1])
ps -= {node.nullrev} ps -= {nullrev}
# XXX we should turn this into a baseset instead of a set, smartset may do # XXX we should turn this into a baseset instead of a set, smartset may do
# some optimizations from the fact this is a baseset. # some optimizations from the fact this is a baseset.
return subset & ps return subset & ps
def parentpost(repo, subset, x, order): def parentpost(repo, subset, x, order):
return p1(repo, subset, x) return p1(repo, subset, x)
cl = repo.changelog cl = repo.changelog
up = ps.update up = ps.update
parentrevs = cl.parentrevs parentrevs = cl.parentrevs
for r in getset(repo, fullreposet(repo), x): for r in getset(repo, fullreposet(repo), x):
try: try:
up(parentrevs(r)) up(parentrevs(r))
except error.WdirUnsupported: except error.WdirUnsupported:
up(p.rev() for p in repo[r].parents()) up(p.rev() for p in repo[r].parents())
ps -= {node.nullrev} ps -= {nullrev}
return subset & ps return subset & ps
def _phase(repo, subset, *targets): def _phase(repo, subset, *targets):
"""helper to select all rev in <targets> phases""" """helper to select all rev in <targets> phases"""
return repo._phasecache.getrevset(repo, targets, subset) return repo._phasecache.getrevset(repo, targets, subset)
elif n == 1: elif n == 1:
try: try:
ps.add(cl.parentrevs(r)[0]) ps.add(cl.parentrevs(r)[0])
except error.WdirUnsupported: except error.WdirUnsupported:
ps.add(repo[r].p1().rev()) ps.add(repo[r].p1().rev())
else: else:
try: try:
parents = cl.parentrevs(r) parents = cl.parentrevs(r)
if parents[1] != node.nullrev: if parents[1] != nullrev:
ps.add(parents[1]) ps.add(parents[1])
except error.WdirUnsupported: except error.WdirUnsupported:
parents = repo[r].parents() parents = repo[r].parents()
if len(parents) == 2: if len(parents) == 2:
ps.add(parents[1].rev()) ps.add(parents[1].rev())
return subset & ps return subset & ps
return author(repo, subset, x) return author(repo, subset, x)
@predicate(b'wdir()', safe=True, weight=0) @predicate(b'wdir()', safe=True, weight=0)
def wdir(repo, subset, x): def wdir(repo, subset, x):
"""Working directory. (EXPERIMENTAL)""" """Working directory. (EXPERIMENTAL)"""
# i18n: "wdir" is a keyword # i18n: "wdir" is a keyword
getargs(x, 0, 0, _(b"wdir takes no arguments")) getargs(x, 0, 0, _(b"wdir takes no arguments"))
if node.wdirrev in subset or isinstance(subset, fullreposet): if wdirrev in subset or isinstance(subset, fullreposet):
return baseset([node.wdirrev]) return baseset([wdirrev])
return baseset() return baseset()
def _orderedlist(repo, subset, x): def _orderedlist(repo, subset, x):
s = getstring(x, b"internal error") s = getstring(x, b"internal error")
if not s: if not s:
return baseset() return baseset()
# remove duplicates here. it's difficult for caller to deduplicate sets # remove duplicates here. it's difficult for caller to deduplicate sets
return _orderedintlist(repo, subset, x) return _orderedintlist(repo, subset, x)
def _orderedhexlist(repo, subset, x): def _orderedhexlist(repo, subset, x):
s = getstring(x, b"internal error") s = getstring(x, b"internal error")
if not s: if not s:
return baseset() return baseset()
cl = repo.changelog cl = repo.changelog
ls = [cl.rev(node.bin(r)) for r in s.split(b'\0')] ls = [cl.rev(bin(r)) for r in s.split(b'\0')]
s = subset s = subset
return baseset([r for r in ls if r in s]) return baseset([r for r in ls if r in s])
# for internal use # for internal use
@predicate(b'_hexlist', safe=True, takeorder=True) @predicate(b'_hexlist', safe=True, takeorder=True)
def _hexlist(repo, subset, x, order): def _hexlist(repo, subset, x, order):
if order == followorder: if order == followorder:

mercurial/revsetlang.py

# revsetlang.py - parser, tokenizer and utility for revision set language # revsetlang.py - parser, tokenizer and utility for revision set language
# #
# Copyright 2010 Matt Mackall <mpm@selenic.com> # Copyright 2010 Matt Mackall <mpm@selenic.com>
# #
# This software may be used and distributed according to the terms of the # This software may be used and distributed according to the terms of the
# GNU General Public License version 2 or any later version. # GNU General Public License version 2 or any later version.
from __future__ import absolute_import from __future__ import absolute_import
import string import string
from .i18n import _ from .i18n import _
from .pycompat import getattr from .pycompat import getattr
from .node import hex
from . import ( from . import (
error, error,
node,
parser, parser,
pycompat, pycompat,
smartset, smartset,
util, util,
) )
from .utils import stringutil from .utils import stringutil
elements = { elements = {
elif c == b's': elif c == b's':
return _quote(arg) return _quote(arg)
elif c == b'r': elif c == b'r':
if not isinstance(arg, bytes): if not isinstance(arg, bytes):
raise TypeError raise TypeError
parse(arg) # make sure syntax errors are confined parse(arg) # make sure syntax errors are confined
return b'(%s)' % arg return b'(%s)' % arg
elif c == b'n': elif c == b'n':
return _quote(node.hex(arg)) return _quote(hex(arg))
elif c == b'b': elif c == b'b':
try: try:
return _quote(arg.branch()) return _quote(arg.branch())
except AttributeError: except AttributeError:
raise TypeError raise TypeError
raise error.ParseError(_(b'unexpected revspec format character %s') % c) raise error.ParseError(_(b'unexpected revspec format character %s') % c)
def _formatlistexp(s, t): def _formatlistexp(s, t):
l = len(s) l = len(s)
if l == 0: if l == 0:
return b"_list('')" return b"_list('')"
elif l == 1: elif l == 1:
return _formatargtype(t, s[0]) return _formatargtype(t, s[0])
elif t == b'd': elif t == b'd':
return _formatintlist(s) return _formatintlist(s)
elif t == b's': elif t == b's':
return b"_list(%s)" % _quote(b"\0".join(s)) return b"_list(%s)" % _quote(b"\0".join(s))
elif t == b'n': elif t == b'n':
return b"_hexlist('%s')" % b"\0".join(node.hex(a) for a in s) return b"_hexlist('%s')" % b"\0".join(hex(a) for a in s)
elif t == b'b': elif t == b'b':
try: try:
return b"_list('%s')" % b"\0".join(a.branch() for a in s) return b"_list('%s')" % b"\0".join(a.branch() for a in s)
except AttributeError: except AttributeError:
raise TypeError raise TypeError
m = l // 2 m = l // 2
return b'(%s or %s)' % (_formatlistexp(s[:m], t), _formatlistexp(s[m:], t)) return b'(%s or %s)' % (_formatlistexp(s[:m], t), _formatlistexp(s[m:], t))

mercurial/rewriteutil.py

# rewriteutil.py - utility functions for rewriting changesets # rewriteutil.py - utility functions for rewriting changesets
# #
# Copyright 2017 Octobus <contact@octobus.net> # Copyright 2017 Octobus <contact@octobus.net>
# #
# This software may be used and distributed according to the terms of the # This software may be used and distributed according to the terms of the
# GNU General Public License version 2 or any later version. # GNU General Public License version 2 or any later version.
from __future__ import absolute_import from __future__ import absolute_import
import re import re
from .i18n import _ from .i18n import _
from .node import (
hex,
nullrev,
)
from . import ( from . import (
error, error,
node,
obsolete, obsolete,
obsutil, obsutil,
revset, revset,
scmutil, scmutil,
) )
NODE_RE = re.compile(br'\b[0-9a-f]{6,64}\b') NODE_RE = re.compile(br'\b[0-9a-f]{6,64}\b')
def precheck(repo, revs, action=b'rewrite'): def precheck(repo, revs, action=b'rewrite'):
"""check if revs can be rewritten """check if revs can be rewritten
action is used to control the error message. action is used to control the error message.
Make sure this function is called after taking the lock. Make sure this function is called after taking the lock.
""" """
if node.nullrev in revs: if nullrev in revs:
msg = _(b"cannot %s null changeset") % action msg = _(b"cannot %s null changeset") % action
hint = _(b"no changeset checked out") hint = _(b"no changeset checked out")
raise error.InputError(msg, hint=hint) raise error.InputError(msg, hint=hint)
if len(repo[None].parents()) > 1: if len(repo[None].parents()) > 1:
raise error.StateError(_(b"cannot %s while merging") % action) raise error.StateError(_(b"cannot %s while merging") % action)
publicrevs = repo.revs(b'%ld and public()', revs) publicrevs = repo.revs(b'%ld and public()', revs)
else: else:
successors = obsutil.successorssets(repo, ctx.node(), cache=cache) successors = obsutil.successorssets(repo, ctx.node(), cache=cache)
# We can't make any assumptions about how to update the hash if the # We can't make any assumptions about how to update the hash if the
# cset in question was split or diverged. # cset in question was split or diverged.
if len(successors) == 1 and len(successors[0]) == 1: if len(successors) == 1 and len(successors[0]) == 1:
successor = successors[0][0] successor = successors[0][0]
if successor is not None: if successor is not None:
newhash = node.hex(successor) newhash = hex(successor)
commitmsg = commitmsg.replace(h, newhash[: len(h)]) commitmsg = commitmsg.replace(h, newhash[: len(h)])
else: else:
repo.ui.note( repo.ui.note(
_( _(
b'The stale commit message reference to %s could ' b'The stale commit message reference to %s could '
b'not be updated\n(The referenced commit was dropped)\n' b'not be updated\n(The referenced commit was dropped)\n'
) )
% h % h

mercurial/shelve.py

import collections import collections
import errno import errno
import itertools import itertools
import stat import stat
from .i18n import _ from .i18n import _
from .pycompat import open from .pycompat import open
from .node import (
bin,
hex,
nullid,
nullrev,
)
from . import ( from . import (
bookmarks, bookmarks,
bundle2, bundle2,
bundlerepo, bundlerepo,
changegroup, changegroup,
cmdutil, cmdutil,
discovery, discovery,
error, error,
exchange, exchange,
hg, hg,
lock as lockmod, lock as lockmod,
mdiff, mdiff,
merge, merge,
mergestate as mergestatemod, mergestate as mergestatemod,
node as nodemod,
patch, patch,
phases, phases,
pycompat, pycompat,
repair, repair,
scmutil, scmutil,
templatefilters, templatefilters,
util, util,
vfs as vfsmod, vfs as vfsmod,
# colon is essential to differentiate from a real bookmark name # colon is essential to differentiate from a real bookmark name
_noactivebook = b':no-active-bookmark' _noactivebook = b':no-active-bookmark'
_interactive = b'interactive' _interactive = b'interactive'
@classmethod @classmethod
def _verifyandtransform(cls, d): def _verifyandtransform(cls, d):
"""Some basic shelvestate syntactic verification and transformation""" """Some basic shelvestate syntactic verification and transformation"""
try: try:
d[b'originalwctx'] = nodemod.bin(d[b'originalwctx']) d[b'originalwctx'] = bin(d[b'originalwctx'])
d[b'pendingctx'] = nodemod.bin(d[b'pendingctx']) d[b'pendingctx'] = bin(d[b'pendingctx'])
d[b'parents'] = [nodemod.bin(h) for h in d[b'parents'].split(b' ')] d[b'parents'] = [bin(h) for h in d[b'parents'].split(b' ')]
d[b'nodestoremove'] = [ d[b'nodestoremove'] = [
nodemod.bin(h) for h in d[b'nodestoremove'].split(b' ') bin(h) for h in d[b'nodestoremove'].split(b' ')
] ]
except (ValueError, TypeError, KeyError) as err: except (ValueError, TypeError, KeyError) as err:
raise error.CorruptedState(pycompat.bytestr(err)) raise error.CorruptedState(pycompat.bytestr(err))
@classmethod @classmethod
def _getversion(cls, repo): def _getversion(cls, repo):
"""Read version information from shelvestate file""" """Read version information from shelvestate file"""
fp = repo.vfs(cls._filename) fp = repo.vfs(cls._filename)
nodestoremove, nodestoremove,
branchtorestore, branchtorestore,
keep=False, keep=False,
activebook=b'', activebook=b'',
interactive=False, interactive=False,
): ):
info = { info = {
b"name": name, b"name": name,
b"originalwctx": nodemod.hex(originalwctx.node()), b"originalwctx": hex(originalwctx.node()),
b"pendingctx": nodemod.hex(pendingctx.node()), b"pendingctx": hex(pendingctx.node()),
b"parents": b' '.join( b"parents": b' '.join(
[nodemod.hex(p) for p in repo.dirstate.parents()] [hex(p) for p in repo.dirstate.parents()]
), ),
b"nodestoremove": b' '.join( b"nodestoremove": b' '.join(
[nodemod.hex(n) for n in nodestoremove] [hex(n) for n in nodestoremove]
), ),
b"branchtorestore": branchtorestore, b"branchtorestore": branchtorestore,
b"keep": cls._keep if keep else cls._nokeep, b"keep": cls._keep if keep else cls._nokeep,
b"activebook": activebook or cls._noactivebook, b"activebook": activebook or cls._noactivebook,
} }
if interactive: if interactive:
info[b'interactive'] = cls._interactive info[b'interactive'] = cls._interactive
scmutil.simplekeyvaluefile(repo.vfs, cls._filename).write( scmutil.simplekeyvaluefile(repo.vfs, cls._filename).write(
return name return name
def mutableancestors(ctx): def mutableancestors(ctx):
"""return all mutable ancestors for ctx (included) """return all mutable ancestors for ctx (included)
Much faster than the revset ancestors(ctx) & draft()""" Much faster than the revset ancestors(ctx) & draft()"""
seen = {nodemod.nullrev} seen = {nullrev}
visit = collections.deque() visit = collections.deque()
visit.append(ctx) visit.append(ctx)
while visit: while visit:
ctx = visit.popleft() ctx = visit.popleft()
yield ctx.node() yield ctx.node()
for parent in ctx.parents(): for parent in ctx.parents():
rev = parent.rev() rev = parent.rev()
if rev not in seen: if rev not in seen:
_(b"nothing changed (%d missing files, see 'hg status')\n") _(b"nothing changed (%d missing files, see 'hg status')\n")
% len(stat.deleted) % len(stat.deleted)
) )
else: else:
ui.status(_(b"nothing changed\n")) ui.status(_(b"nothing changed\n"))
def _shelvecreatedcommit(repo, node, name, match): def _shelvecreatedcommit(repo, node, name, match):
info = {b'node': nodemod.hex(node)} info = {b'node': hex(node)}
shelvedfile(repo, name, b'shelve').writeinfo(info) shelvedfile(repo, name, b'shelve').writeinfo(info)
bases = list(mutableancestors(repo[node])) bases = list(mutableancestors(repo[node]))
shelvedfile(repo, name, b'hg').writebundle(bases, node) shelvedfile(repo, name, b'hg').writebundle(bases, node)
with shelvedfile(repo, name, patchextension).opener(b'wb') as fp: with shelvedfile(repo, name, patchextension).opener(b'wb') as fp:
cmdutil.exportfile( cmdutil.exportfile(
repo, [node], fp, opts=mdiff.diffopts(git=True), match=match repo, [node], fp, opts=mdiff.diffopts(git=True), match=match
) )
def _docreatecmd(ui, repo, pats, opts): def _docreatecmd(ui, repo, pats, opts):
wctx = repo[None] wctx = repo[None]
parents = wctx.parents() parents = wctx.parents()
parent = parents[0] parent = parents[0]
origbranch = wctx.branch() origbranch = wctx.branch()
if parent.node() != nodemod.nullid: if parent.node() != nullid:
desc = b"changes to: %s" % parent.description().split(b'\n', 1)[0] desc = b"changes to: %s" % parent.description().split(b'\n', 1)[0]
else: else:
desc = b'(changes in empty repository)' desc = b'(changes in empty repository)'
if not opts.get(b'message'): if not opts.get(b'message'):
opts[b'message'] = desc opts[b'message'] = desc
lock = tr = activebookmark = None lock = tr = activebookmark = None
_(b"unresolved conflicts, can't continue"), _(b"unresolved conflicts, can't continue"),
hint=_(b"see 'hg resolve', then 'hg unshelve --continue'"), hint=_(b"see 'hg resolve', then 'hg unshelve --continue'"),
) )
shelvectx = repo[state.parents[1]] shelvectx = repo[state.parents[1]]
pendingctx = state.pendingctx pendingctx = state.pendingctx
with repo.dirstate.parentchange(): with repo.dirstate.parentchange():
repo.setparents(state.pendingctx.node(), nodemod.nullid) repo.setparents(state.pendingctx.node(), nullid)
repo.dirstate.write(repo.currenttransaction()) repo.dirstate.write(repo.currenttransaction())
targetphase = phases.internal targetphase = phases.internal
if not phases.supportinternal(repo): if not phases.supportinternal(repo):
targetphase = phases.secret targetphase = phases.secret
overrides = {(b'phases', b'new-commit'): targetphase} overrides = {(b'phases', b'new-commit'): targetphase}
with repo.ui.configoverride(overrides, b'unshelve'): with repo.ui.configoverride(overrides, b'unshelve'):
with repo.dirstate.parentchange(): with repo.dirstate.parentchange():
repo.setparents(state.parents[0], nodemod.nullid) repo.setparents(state.parents[0], nullid)
newnode, ispartialunshelve = _createunshelvectx( newnode, ispartialunshelve = _createunshelvectx(
ui, repo, shelvectx, basename, interactive, opts ui, repo, shelvectx, basename, interactive, opts
) )
if newnode is None: if newnode is None:
shelvectx = state.pendingctx shelvectx = state.pendingctx
msg = _( msg = _(
b'note: unshelved changes already existed ' b'note: unshelved changes already existed '
if shelvedfile(repo, basename, b'shelve').exists(): if shelvedfile(repo, basename, b'shelve').exists():
node = shelvedfile(repo, basename, b'shelve').readinfo()[b'node'] node = shelvedfile(repo, basename, b'shelve').readinfo()[b'node']
if node is None or node not in repo: if node is None or node not in repo:
with ui.configoverride({(b'ui', b'quiet'): True}): with ui.configoverride({(b'ui', b'quiet'): True}):
shelvectx = shelvedfile(repo, basename, b'hg').applybundle(tr) shelvectx = shelvedfile(repo, basename, b'hg').applybundle(tr)
# We might not strip the unbundled changeset, so we should keep track of # We might not strip the unbundled changeset, so we should keep track of
# the unshelve node in case we need to reuse it (eg: unshelve --keep) # the unshelve node in case we need to reuse it (eg: unshelve --keep)
if node is None: if node is None:
info = {b'node': nodemod.hex(shelvectx.node())} info = {b'node': hex(shelvectx.node())}
shelvedfile(repo, basename, b'shelve').writeinfo(info) shelvedfile(repo, basename, b'shelve').writeinfo(info)
else: else:
shelvectx = repo[node] shelvectx = repo[node]
return repo, shelvectx return repo, shelvectx
def _createunshelvectx(ui, repo, shelvectx, basename, interactive, opts): def _createunshelvectx(ui, repo, shelvectx, basename, interactive, opts):
branchtorestore, branchtorestore,
opts.get(b'keep'), opts.get(b'keep'),
activebookmark, activebookmark,
interactive, interactive,
) )
raise error.ConflictResolutionRequired(b'unshelve') raise error.ConflictResolutionRequired(b'unshelve')
with repo.dirstate.parentchange(): with repo.dirstate.parentchange():
repo.setparents(tmpwctx.node(), nodemod.nullid) repo.setparents(tmpwctx.node(), nullid)
newnode, ispartialunshelve = _createunshelvectx( newnode, ispartialunshelve = _createunshelvectx(
ui, repo, shelvectx, basename, interactive, opts ui, repo, shelvectx, basename, interactive, opts
) )
if newnode is None: if newnode is None:
shelvectx = tmpwctx shelvectx = tmpwctx
msg = _( msg = _(
b'note: unshelved changes already existed ' b'note: unshelved changes already existed '

mercurial/simplemerge.py

# along with this program; if not, see <http://www.gnu.org/licenses/>. # along with this program; if not, see <http://www.gnu.org/licenses/>.
# mbp: "you know that thing where cvs gives you conflict markers?" # mbp: "you know that thing where cvs gives you conflict markers?"
# s: "i hate that." # s: "i hate that."
from __future__ import absolute_import from __future__ import absolute_import
from .i18n import _ from .i18n import _
from .node import nullid
from . import ( from . import (
error, error,
mdiff, mdiff,
node as nodemod,
pycompat, pycompat,
util, util,
) )
from .utils import stringutil from .utils import stringutil
class CantReprocessAndShowBase(Exception): class CantReprocessAndShowBase(Exception):
pass pass
for i, override in enumerate(overrides): for i, override in enumerate(overrides):
result[i] = override result[i] = override
return result return result
def is_not_null(ctx): def is_not_null(ctx):
if not util.safehasattr(ctx, "node"): if not util.safehasattr(ctx, "node"):
return False return False
return ctx.node() != nodemod.nullid return ctx.node() != nullid
def _mergediff(m3, name_a, name_b, name_base): def _mergediff(m3, name_a, name_b, name_base):
lines = [] lines = []
conflicts = False conflicts = False
for group in m3.merge_groups(): for group in m3.merge_groups():
if group[0] == b'conflict': if group[0] == b'conflict':
base_lines, a_lines, b_lines = group[1:] base_lines, a_lines, b_lines = group[1:]

mercurial/sslutil.py

import hashlib import hashlib
import os import os
import re import re
import ssl import ssl
from .i18n import _ from .i18n import _
from .pycompat import getattr from .pycompat import getattr
from .node import hex
from . import ( from . import (
encoding, encoding,
error, error,
node,
pycompat, pycompat,
util, util,
) )
from .utils import ( from .utils import (
hashutil, hashutil,
resourceutil, resourceutil,
stringutil, stringutil,
) )
) )
% host % host
) )
return return
# If a certificate fingerprint is pinned, use it and only it to # If a certificate fingerprint is pinned, use it and only it to
# validate the remote cert. # validate the remote cert.
peerfingerprints = { peerfingerprints = {
b'sha1': node.hex(hashutil.sha1(peercert).digest()), b'sha1': hex(hashutil.sha1(peercert).digest()),
b'sha256': node.hex(hashlib.sha256(peercert).digest()), b'sha256': hex(hashlib.sha256(peercert).digest()),
b'sha512': node.hex(hashlib.sha512(peercert).digest()), b'sha512': hex(hashlib.sha512(peercert).digest()),
} }
def fmtfingerprint(s): def fmtfingerprint(s):
return b':'.join([s[x : x + 2] for x in range(0, len(s), 2)]) return b':'.join([s[x : x + 2] for x in range(0, len(s), 2)])
nicefingerprint = b'sha256:%s' % fmtfingerprint(peerfingerprints[b'sha256']) nicefingerprint = b'sha256:%s' % fmtfingerprint(peerfingerprints[b'sha256'])
if settings[b'certfingerprints']: if settings[b'certfingerprints']:

mercurial/store.py

# store.py - repository store handling for Mercurial # store.py - repository store handling for Mercurial
# #
# Copyright 2008 Matt Mackall <mpm@selenic.com> # Copyright 2008 Matt Mackall <mpm@selenic.com>
# #
# This software may be used and distributed according to the terms of the # This software may be used and distributed according to the terms of the
# GNU General Public License version 2 or any later version. # GNU General Public License version 2 or any later version.
from __future__ import absolute_import from __future__ import absolute_import
import errno import errno
import functools import functools
import os import os
import stat import stat
from .i18n import _ from .i18n import _
from .pycompat import getattr from .pycompat import getattr
from .node import hex
from . import ( from . import (
changelog, changelog,
error, error,
manifest, manifest,
node,
policy, policy,
pycompat, pycompat,
util, util,
vfs as vfsmod, vfs as vfsmod,
) )
from .utils import hashutil from .utils import hashutil
parsers = policy.importmod('parsers') parsers = policy.importmod('parsers')
_maxstorepathlen = 120 _maxstorepathlen = 120
_dirprefixlen = 8 _dirprefixlen = 8
_maxshortdirslen = 8 * (_dirprefixlen + 1) - 4 _maxshortdirslen = 8 * (_dirprefixlen + 1) - 4
def _hashencode(path, dotencode): def _hashencode(path, dotencode):
digest = node.hex(hashutil.sha1(path).digest()) digest = hex(hashutil.sha1(path).digest())
le = lowerencode(path[5:]).split(b'/') # skips prefix 'data/' or 'meta/' le = lowerencode(path[5:]).split(b'/') # skips prefix 'data/' or 'meta/'
parts = _auxencode(le, dotencode) parts = _auxencode(le, dotencode)
basename = parts[-1] basename = parts[-1]
_root, ext = os.path.splitext(basename) _root, ext = os.path.splitext(basename)
sdirs = [] sdirs = []
sdirslen = 0 sdirslen = 0
for p in parts[:-1]: for p in parts[:-1]:
d = p[:_dirprefixlen] d = p[:_dirprefixlen]

mercurial/strip.py

from __future__ import absolute_import from __future__ import absolute_import
from .i18n import _ from .i18n import _
from .pycompat import getattr from .pycompat import getattr
from .node import nullid
from . import ( from . import (
bookmarks as bookmarksmod, bookmarks as bookmarksmod,
cmdutil, cmdutil,
error, error,
hg, hg,
lock as lockmod, lock as lockmod,
mergestate as mergestatemod, mergestate as mergestatemod,
node as nodemod,
pycompat, pycompat,
registrar, registrar,
repair, repair,
scmutil, scmutil,
util, util,
) )
nullid = nodemod.nullid
release = lockmod.release release = lockmod.release
cmdtable = {} cmdtable = {}
command = registrar.command(cmdtable) command = registrar.command(cmdtable)
def checklocalchanges(repo, force=False): def checklocalchanges(repo, force=False):
s = repo.status() s = repo.status()

mercurial/subrepo.py

import re import re
import stat import stat
import subprocess import subprocess
import sys import sys
import tarfile import tarfile
import xml.dom.minidom import xml.dom.minidom
from .i18n import _ from .i18n import _
from .node import (
bin,
hex,
nullid,
short,
)
from . import ( from . import (
cmdutil, cmdutil,
encoding, encoding,
error, error,
exchange, exchange,
logcmdutil, logcmdutil,
match as matchmod, match as matchmod,
merge as merge, merge as merge,
node,
pathutil, pathutil,
phases, phases,
pycompat, pycompat,
scmutil, scmutil,
subrepoutil, subrepoutil,
util, util,
vfs as vfsmod, vfs as vfsmod,
) )
u = util.url(expandedpath) u = util.url(expandedpath)
if not u.scheme: if not u.scheme:
path = util.normpath(os.path.abspath(u.path)) path = util.normpath(os.path.abspath(u.path))
return path return path
def _getstorehashcachename(remotepath): def _getstorehashcachename(remotepath):
'''get a unique filename for the store hash cache of a remote repository''' '''get a unique filename for the store hash cache of a remote repository'''
return node.hex(hashutil.sha1(_expandedabspath(remotepath)).digest())[0:12] return hex(hashutil.sha1(_expandedabspath(remotepath)).digest())[0:12]
class SubrepoAbort(error.Abort): class SubrepoAbort(error.Abort):
"""Exception class used to avoid handling a subrepo error more than once""" """Exception class used to avoid handling a subrepo error more than once"""
def __init__(self, *args, **kw): def __init__(self, *args, **kw):
self.subrepo = kw.pop('subrepo', None) self.subrepo = kw.pop('subrepo', None)
self.cause = kw.pop('cause', None) self.cause = kw.pop('cause', None)
This method is used to to detect when there are changes that may This method is used to to detect when there are changes that may
require a push to a given remote path.""" require a push to a given remote path."""
# sort the files that will be hashed in increasing (likely) file size # sort the files that will be hashed in increasing (likely) file size
filelist = (b'bookmarks', b'store/phaseroots', b'store/00changelog.i') filelist = (b'bookmarks', b'store/phaseroots', b'store/00changelog.i')
yield b'# %s\n' % _expandedabspath(remotepath) yield b'# %s\n' % _expandedabspath(remotepath)
vfs = self._repo.vfs vfs = self._repo.vfs
for relname in filelist: for relname in filelist:
filehash = node.hex(hashutil.sha1(vfs.tryread(relname)).digest()) filehash = hex(hashutil.sha1(vfs.tryread(relname)).digest())
yield b'%s = %s\n' % (relname, filehash) yield b'%s = %s\n' % (relname, filehash)
@propertycache @propertycache
def _cachestorehashvfs(self): def _cachestorehashvfs(self):
return vfsmod.vfs(self._repo.vfs.join(b'cache/storehash')) return vfsmod.vfs(self._repo.vfs.join(b'cache/storehash'))
def _readstorehashcache(self, remotepath): def _readstorehashcache(self, remotepath):
'''read the store hash cache for a given remote repository''' '''read the store hash cache for a given remote repository'''
_(b'warning: error "%s" in subrepository "%s"\n') _(b'warning: error "%s" in subrepository "%s"\n')
% (inst, subrelpath(self)) % (inst, subrelpath(self))
) )
return scmutil.status([], [], [], [], [], [], []) return scmutil.status([], [], [], [], [], [], [])
@annotatesubrepoerror @annotatesubrepoerror
def diff(self, ui, diffopts, node2, match, prefix, **opts): def diff(self, ui, diffopts, node2, match, prefix, **opts):
try: try:
node1 = node.bin(self._state[1]) node1 = bin(self._state[1])
# We currently expect node2 to come from substate and be # We currently expect node2 to come from substate and be
# in hex format # in hex format
if node2 is not None: if node2 is not None:
node2 = node.bin(node2) node2 = bin(node2)
logcmdutil.diffordiffstat( logcmdutil.diffordiffstat(
ui, ui,
self._repo, self._repo,
diffopts, diffopts,
self._repo[node1], self._repo[node1],
self._repo[node2], self._repo[node2],
match, match,
prefix=prefix, prefix=prefix,
# don't bother committing in the subrepo if it's only been # don't bother committing in the subrepo if it's only been
# updated # updated
if not self.dirty(True): if not self.dirty(True):
return self._repo[b'.'].hex() return self._repo[b'.'].hex()
self.ui.debug(b"committing subrepo %s\n" % subrelpath(self)) self.ui.debug(b"committing subrepo %s\n" % subrelpath(self))
n = self._repo.commit(text, user, date) n = self._repo.commit(text, user, date)
if not n: if not n:
return self._repo[b'.'].hex() # different version checked out return self._repo[b'.'].hex() # different version checked out
return node.hex(n) return hex(n)
@annotatesubrepoerror @annotatesubrepoerror
def phase(self, state): def phase(self, state):
return self._repo[state or b'.'].phase() return self._repo[state or b'.'].phase()
@annotatesubrepoerror @annotatesubrepoerror
def remove(self): def remove(self):
# we can't fully delete the repository as it may contain # we can't fully delete the repository as it may contain
# local-only history # local-only history
self.ui.note(_(b'removing subrepo %s\n') % subrelpath(self)) self.ui.note(_(b'removing subrepo %s\n') % subrelpath(self))
hg.clean(self._repo, node.nullid, False) hg.clean(self._repo, nullid, False)
def _get(self, state): def _get(self, state):
source, revision, kind = state source, revision, kind = state
parentrepo = self._repo._subparent parentrepo = self._repo._subparent
if revision in self._repo.unfiltered(): if revision in self._repo.unfiltered():
# Allow shared subrepos tracked at null to setup the sharedpath # Allow shared subrepos tracked at null to setup the sharedpath
if len(self._repo) != 0 or not parentrepo.shared(): if len(self._repo) != 0 or not parentrepo.shared():
try: try:
rev = self._state[1] rev = self._state[1]
ctx = self._repo.unfiltered()[rev] ctx = self._repo.unfiltered()[rev]
if ctx.hidden(): if ctx.hidden():
# Since hidden revisions aren't pushed/pulled, it seems worth an # Since hidden revisions aren't pushed/pulled, it seems worth an
# explicit warning. # explicit warning.
msg = _(b"subrepo '%s' is hidden in revision %s") % ( msg = _(b"subrepo '%s' is hidden in revision %s") % (
self._relpath, self._relpath,
node.short(self._ctx.node()), short(self._ctx.node()),
) )
if onpush: if onpush:
raise error.Abort(msg) raise error.Abort(msg)
else: else:
self._repo.ui.warn(b'%s\n' % msg) self._repo.ui.warn(b'%s\n' % msg)
return 0 return 0
except error.RepoLookupError: except error.RepoLookupError:
# A missing subrepo revision may be a case of needing to pull it, so # A missing subrepo revision may be a case of needing to pull it, so
# don't treat this as an error for `hg verify`. # don't treat this as an error for `hg verify`.
msg = _(b"subrepo '%s' not found in revision %s") % ( msg = _(b"subrepo '%s' not found in revision %s") % (
self._relpath, self._relpath,
node.short(self._ctx.node()), short(self._ctx.node()),
) )
if onpush: if onpush:
raise error.Abort(msg) raise error.Abort(msg)
else: else:
self._repo.ui.warn(b'%s\n' % msg) self._repo.ui.warn(b'%s\n' % msg)
return 0 return 0

mercurial/tagmerge.py

# - put blocks whose nodes come all from p2 first # - put blocks whose nodes come all from p2 first
# - write the tag blocks in the sorted order # - write the tag blocks in the sorted order
from __future__ import absolute_import from __future__ import absolute_import
from .i18n import _ from .i18n import _
from .node import ( from .node import (
hex, hex,
nullhex,
nullid, nullid,
) )
from . import ( from . import (
tags as tagsmod, tags as tagsmod,
util, util,
) )
hexnullid = hex(nullid)
def readtagsformerge(ui, repo, lines, fn=b'', keeplinenums=False): def readtagsformerge(ui, repo, lines, fn=b'', keeplinenums=False):
"""read the .hgtags file into a structure that is suitable for merging """read the .hgtags file into a structure that is suitable for merging
Depending on the keeplinenums flag, clear the line numbers associated Depending on the keeplinenums flag, clear the line numbers associated
with each tag. This is done because only the line numbers of the first with each tag. This is done because only the line numbers of the first
parent are useful for merging. parent are useful for merging.
""" """
# recover the list of "lost tags" (i.e. those that were found on the base # recover the list of "lost tags" (i.e. those that were found on the base
# revision but not on one of the revisions being merged) # revision but not on one of the revisions being merged)
basetagset = set(basetags) basetagset = set(basetags)
for n, pntags in enumerate((p1tags, p2tags)): for n, pntags in enumerate((p1tags, p2tags)):
pntagset = set(pntags) pntagset = set(pntags)
pnlosttagset = basetagset - pntagset pnlosttagset = basetagset - pntagset
for t in pnlosttagset: for t in pnlosttagset:
pntags[t] = basetags[t] pntags[t] = basetags[t]
if pntags[t][-1][0] != hexnullid: if pntags[t][-1][0] != nullhex:
pntags[t].append([hexnullid, None]) pntags[t].append([nullhex, None])
conflictedtags = [] # for reporting purposes conflictedtags = [] # for reporting purposes
mergedtags = util.sortdict(p1tags) mergedtags = util.sortdict(p1tags)
# sortdict does not implement iteritems() # sortdict does not implement iteritems()
for tname, p2nodes in p2tags.items(): for tname, p2nodes in p2tags.items():
if tname not in mergedtags: if tname not in mergedtags:
mergedtags[tname] = p2nodes mergedtags[tname] = p2nodes
continue continue

mercurial/templatefilters.py

# templatefilters.py - common template expansion filters # templatefilters.py - common template expansion filters
# #
# Copyright 2005-2008 Matt Mackall <mpm@selenic.com> # Copyright 2005-2008 Matt Mackall <mpm@selenic.com>
# #
# This software may be used and distributed according to the terms of the # This software may be used and distributed according to the terms of the
# GNU General Public License version 2 or any later version. # GNU General Public License version 2 or any later version.
from __future__ import absolute_import from __future__ import absolute_import
import os import os
import re import re
import time import time
from .i18n import _ from .i18n import _
from .node import hex
from . import ( from . import (
encoding, encoding,
error, error,
node,
pycompat, pycompat,
registrar, registrar,
smartset, smartset,
templateutil, templateutil,
url, url,
util, util,
) )
from .utils import ( from .utils import (
return b'' return b''
@templatefilter(b'hex', intype=bytes) @templatefilter(b'hex', intype=bytes)
def hexfilter(text): def hexfilter(text):
"""Any text. Convert a binary Mercurial node identifier into """Any text. Convert a binary Mercurial node identifier into
its long hexadecimal representation. its long hexadecimal representation.
""" """
return node.hex(text) return hex(text)
@templatefilter(b'hgdate', intype=templateutil.date) @templatefilter(b'hgdate', intype=templateutil.date)
def hgdate(text): def hgdate(text):
"""Date. Returns the date as a pair of numbers: "1157407993 """Date. Returns the date as a pair of numbers: "1157407993
25200" (Unix timestamp, timezone offset). 25200" (Unix timestamp, timezone offset).
""" """
return b"%d %d" % text return b"%d %d" % text

mercurial/util.py

from .thirdparty import attr from .thirdparty import attr
from .pycompat import ( from .pycompat import (
delattr, delattr,
getattr, getattr,
open, open,
setattr, setattr,
) )
from .node import hex
from hgdemandimport import tracing from hgdemandimport import tracing
from . import ( from . import (
encoding, encoding,
error, error,
i18n, i18n,
node as nodemod,
policy, policy,
pycompat, pycompat,
urllibcompat, urllibcompat,
) )
from .utils import ( from .utils import (
compression, compression,
hashutil, hashutil,
procutil, procutil,
def update(self, data): def update(self, data):
for h in self._hashes.values(): for h in self._hashes.values():
h.update(data) h.update(data)
def __getitem__(self, key): def __getitem__(self, key):
if key not in DIGESTS: if key not in DIGESTS:
raise error.Abort(_(b'unknown digest type: %s') % k) raise error.Abort(_(b'unknown digest type: %s') % k)
return nodemod.hex(self._hashes[key].digest()) return hex(self._hashes[key].digest())
def __iter__(self): def __iter__(self):
return iter(self._hashes) return iter(self._hashes)
@staticmethod @staticmethod
def preferred(supported): def preferred(supported):
"""returns the strongest digest type in both supported and DIGESTS.""" """returns the strongest digest type in both supported and DIGESTS."""

tests/drawdag.py

# prune: A, B, C # many to nothing # prune: A, B, C # many to nothing
""" """
from __future__ import absolute_import, print_function from __future__ import absolute_import, print_function
import collections import collections
import itertools import itertools
import re import re
from mercurial.node import nullid
from mercurial.i18n import _ from mercurial.i18n import _
from mercurial import ( from mercurial import (
context, context,
error, error,
node,
obsolete, obsolete,
pycompat, pycompat,
registrar, registrar,
scmutil, scmutil,
tags as tagsmod, tags as tagsmod,
) )
cmdtable = {} cmdtable = {}
'changes': scmutil.status([], list(added), [], [], [], [], []), 'changes': scmutil.status([], list(added), [], [], [], [], []),
'date': b'0 0', 'date': b'0 0',
'extra': {b'branch': b'default'}, 'extra': {b'branch': b'default'},
} }
super(simplecommitctx, self).__init__(repo, name, **opts) super(simplecommitctx, self).__init__(repo, name, **opts)
self._added = added self._added = added
self._parents = parentctxs self._parents = parentctxs
while len(self._parents) < 2: while len(self._parents) < 2:
self._parents.append(repo[node.nullid]) self._parents.append(repo[nullid])
def filectx(self, key): def filectx(self, key):
return simplefilectx(key, self._added[key]) return simplefilectx(key, self._added[key])
def commit(self): def commit(self):
return self._repo.commitctx(self) return self._repo.commitctx(self)
def p1copies(self): def p1copies(self):
# parse comments to get extra file content instructions # parse comments to get extra file content instructions
files = collections.defaultdict(dict) # {(name, path): content} files = collections.defaultdict(dict) # {(name, path): content}
comments = list(_getcomments(text)) comments = list(_getcomments(text))
filere = re.compile(br'^(\w+)/([\w/]+)\s*=\s*(.*)$', re.M) filere = re.compile(br'^(\w+)/([\w/]+)\s*=\s*(.*)$', re.M)
for name, path, content in filere.findall(b'\n'.join(comments)): for name, path, content in filere.findall(b'\n'.join(comments)):
content = content.replace(br'\n', b'\n').replace(br'\1', b'\1') content = content.replace(br'\n', b'\n').replace(br'\1', b'\1')
files[name][path] = content files[name][path] = content
committed = {None: node.nullid} # {name: node} committed = {None: nullid} # {name: node}
# for leaf nodes, try to find existing nodes in repo # for leaf nodes, try to find existing nodes in repo
for name, parents in edges.items(): for name, parents in edges.items():
if len(parents) == 0: if len(parents) == 0:
try: try:
committed[name] = scmutil.revsingle(repo, name) committed[name] = scmutil.revsingle(repo, name)
except error.RepoLookupError: except error.RepoLookupError:
pass pass

tests/test-parseindex2.py

"""This unit test primarily tests parsers.parse_index2(). """This unit test primarily tests parsers.parse_index2().
It also checks certain aspects of the parsers module as a whole. It also checks certain aspects of the parsers module as a whole.
""" """
from __future__ import absolute_import, print_function from __future__ import absolute_import, print_function
import os import os
import struct import struct
import subprocess import subprocess
import sys import sys
import unittest import unittest
from mercurial.node import ( from mercurial.node import (
bin,
hex,
nullid, nullid,
nullrev, nullrev,
) )
from mercurial import ( from mercurial import (
node as nodemod,
policy, policy,
pycompat, pycompat,
) )
parsers = policy.importmod('parsers') parsers = policy.importmod('parsers')
# original python implementation # original python implementation
def gettype(q): def gettype(q):
ix = parsers.parse_index2(data_inlined, True)[0] ix = parsers.parse_index2(data_inlined, True)[0]
for i, r in enumerate(ix): for i, r in enumerate(ix):
if r[7] == nullid: if r[7] == nullid:
i = -1 i = -1
try: try:
self.assertEqual( self.assertEqual(
ix[r[7]], ix[r[7]],
i, i,
'Reverse lookup inconsistent for %r' % nodemod.hex(r[7]), 'Reverse lookup inconsistent for %r' % hex(r[7]),
) )
except TypeError: except TypeError:
# pure version doesn't support this # pure version doesn't support this
break break
def testminusone(self): def testminusone(self):
want = (0, 0, 0, -1, -1, -1, -1, nullid) want = (0, 0, 0, -1, -1, -1, -1, nullid)
index, junk = parsers.parse_index2(data_inlined, True) index, junk = parsers.parse_index2(data_inlined, True)
got = index[-1] got = index[-1]
self.assertEqual(want, got) # inline data self.assertEqual(want, got) # inline data
index, junk = parsers.parse_index2(data_non_inlined, False) index, junk = parsers.parse_index2(data_non_inlined, False)
got = index[-1] got = index[-1]
self.assertEqual(want, got) # no inline data self.assertEqual(want, got) # no inline data
def testdelitemwithoutnodetree(self): def testdelitemwithoutnodetree(self):
index, _junk = parsers.parse_index2(data_non_inlined, False) index, _junk = parsers.parse_index2(data_non_inlined, False)
def hexrev(rev): def hexrev(rev):
if rev == nullrev: if rev == nullrev:
return b'\xff\xff\xff\xff' return b'\xff\xff\xff\xff'
else: else:
return nodemod.bin('%08x' % rev) return bin('%08x' % rev)
def appendrev(p1, p2=nullrev): def appendrev(p1, p2=nullrev):
# node won't matter for this test, let's just make sure # node won't matter for this test, let's just make sure
# they don't collide. Other data don't matter either. # they don't collide. Other data don't matter either.
node = hexrev(p1) + hexrev(p2) + b'.' * 12 node = hexrev(p1) + hexrev(p2) + b'.' * 12
index.append((0, 0, 12, 1, 34, p1, p2, node)) index.append((0, 0, 12, 1, 34, p1, p2, node))
appendrev(4) appendrev(4)

tests/test-revlog-raw.py

# test revlog interaction about raw data (flagprocessor) # test revlog interaction about raw data (flagprocessor)
from __future__ import absolute_import, print_function from __future__ import absolute_import, print_function
import collections import collections
import hashlib import hashlib
import sys import sys
from mercurial.node import nullid
from mercurial import ( from mercurial import (
encoding, encoding,
node,
revlog, revlog,
transaction, transaction,
vfs, vfs,
) )
from mercurial.revlogutils import ( from mercurial.revlogutils import (
deltas, deltas,
flagutil, flagutil,
def appendrev(rlog, text, tr, isext=False, isdelta=True): def appendrev(rlog, text, tr, isext=False, isdelta=True):
"""Append a revision. If isext is True, set the EXTSTORED flag so flag """Append a revision. If isext is True, set the EXTSTORED flag so flag
processor will be used (and rawtext is different from text). If isdelta is processor will be used (and rawtext is different from text). If isdelta is
True, force the revision to be a delta, otherwise it's full text. True, force the revision to be a delta, otherwise it's full text.
""" """
nextrev = len(rlog) nextrev = len(rlog)
p1 = rlog.node(nextrev - 1) p1 = rlog.node(nextrev - 1)
p2 = node.nullid p2 = nullid
if isext: if isext:
flags = revlog.REVIDX_EXTSTORED flags = revlog.REVIDX_EXTSTORED
else: else:
flags = revlog.REVIDX_DEFAULT_FLAGS flags = revlog.REVIDX_DEFAULT_FLAGS
# Change storedeltachains temporarily, to override revlog's delta decision # Change storedeltachains temporarily, to override revlog's delta decision
rlog._storedeltachains = isdelta rlog._storedeltachains = isdelta
try: try:
rlog.addrevision(text, tr, nextrev, p1, p2, flags=flags) rlog.addrevision(text, tr, nextrev, p1, p2, flags=flags)
This exercises some revlog.addgroup (and revlog._addrevision(text=None)) This exercises some revlog.addgroup (and revlog._addrevision(text=None))
code path, which is not covered by "appendrev" alone. code path, which is not covered by "appendrev" alone.
""" """
class dummychangegroup(object): class dummychangegroup(object):
@staticmethod @staticmethod
def deltachunk(pnode): def deltachunk(pnode):
pnode = pnode or node.nullid pnode = pnode or nullid
parentrev = rlog.rev(pnode) parentrev = rlog.rev(pnode)
r = parentrev + 1 r = parentrev + 1
if r >= len(rlog): if r >= len(rlog):
return {} return {}
if optimaldelta: if optimaldelta:
deltaparent = parentrev deltaparent = parentrev
else: else:
# suboptimal deltaparent # suboptimal deltaparent
deltaparent = min(0, parentrev) deltaparent = min(0, parentrev)
if not rlog.candelta(deltaparent, r): if not rlog.candelta(deltaparent, r):
deltaparent = -1 deltaparent = -1
return { return {
b'node': rlog.node(r), b'node': rlog.node(r),
b'p1': pnode, b'p1': pnode,
b'p2': node.nullid, b'p2': nullid,
b'cs': rlog.node(rlog.linkrev(r)), b'cs': rlog.node(rlog.linkrev(r)),
b'flags': rlog.flags(r), b'flags': rlog.flags(r),
b'deltabase': rlog.node(deltaparent), b'deltabase': rlog.node(deltaparent),
b'delta': rlog.revdiff(deltaparent, r), b'delta': rlog.revdiff(deltaparent, r),
} }
def deltaiter(self): def deltaiter(self):
chain = None chain = None
def lowlevelcopy(rlog, tr, destname=b'_destrevlog.i'): def lowlevelcopy(rlog, tr, destname=b'_destrevlog.i'):
"""Like addgroupcopy, but use the low level revlog._addrevision directly. """Like addgroupcopy, but use the low level revlog._addrevision directly.
It exercises some code paths that are hard to reach easily otherwise. It exercises some code paths that are hard to reach easily otherwise.
""" """
dlog = newrevlog(destname, recreate=True) dlog = newrevlog(destname, recreate=True)
for r in rlog: for r in rlog:
p1 = rlog.node(r - 1) p1 = rlog.node(r - 1)
p2 = node.nullid p2 = nullid
if r == 0 or (rlog.flags(r) & revlog.REVIDX_EXTSTORED): if r == 0 or (rlog.flags(r) & revlog.REVIDX_EXTSTORED):
text = rlog.rawdata(r) text = rlog.rawdata(r)
cachedelta = None cachedelta = None
else: else:
# deltaparent cannot have EXTSTORED flag. # deltaparent cannot have EXTSTORED flag.
deltaparent = max( deltaparent = max(
[-1] [-1]
+ [ + [

tests/test-rust-ancestor.py

from __future__ import absolute_import from __future__ import absolute_import
import sys import sys
import unittest import unittest
from mercurial import ( from mercurial.node import wdirrev
error, from mercurial import error
node,
)
from mercurial.testing import revlog as revlogtesting from mercurial.testing import revlog as revlogtesting
try: try:
from mercurial import rustext from mercurial import rustext
rustext.__name__ # trigger immediate actual import rustext.__name__ # trigger immediate actual import
except ImportError: except ImportError:
# rust-cpython issues appropriate str instances for Python 2 and 3 # rust-cpython issues appropriate str instances for Python 2 and 3
self.assertEqual(exc.args, ('ParentOutOfRange', 1)) self.assertEqual(exc.args, ('ParentOutOfRange', 1))
def testwdirunsupported(self): def testwdirunsupported(self):
# trying to access ancestors of the working directory raises # trying to access ancestors of the working directory raises
# WdirUnsupported directly # WdirUnsupported directly
idx = self.parseindex() idx = self.parseindex()
with self.assertRaises(error.WdirUnsupported): with self.assertRaises(error.WdirUnsupported):
list(AncestorsIterator(idx, [node.wdirrev], -1, False)) list(AncestorsIterator(idx, [wdirrev], -1, False))
def testheadrevs(self): def testheadrevs(self):
idx = self.parseindex() idx = self.parseindex()
self.assertEqual(dagop.headrevs(idx, [1, 2, 3]), {3}) self.assertEqual(dagop.headrevs(idx, [1, 2, 3]), {3})
if __name__ == '__main__': if __name__ == '__main__':
import silenttestrunner import silenttestrunner
silenttestrunner.main(__name__) silenttestrunner.main(__name__)

tests/testlib/ext-sidedata.py

# ext-sidedata.py - small extension to test the sidedata logic # ext-sidedata.py - small extension to test the sidedata logic
# #
# Copyright 2019 Pierre-Yves David <pierre-yves.david@octobus.net) # Copyright 2019 Pierre-Yves David <pierre-yves.david@octobus.net)
# #
# This software may be used and distributed according to the terms of the # This software may be used and distributed according to the terms of the
# GNU General Public License version 2 or any later version. # GNU General Public License version 2 or any later version.
from __future__ import absolute_import from __future__ import absolute_import
import hashlib import hashlib
import struct import struct
from mercurial.node import (
nullid,
nullrev,
)
from mercurial import ( from mercurial import (
extensions, extensions,
node,
requirements, requirements,
revlog, revlog,
) )
from mercurial.upgrade_utils import engine as upgrade_engine from mercurial.upgrade_utils import engine as upgrade_engine
from mercurial.revlogutils import sidedata from mercurial.revlogutils import sidedata
sd[sidedata.SD_TEST2] = struct.pack('>32s', sha256) sd[sidedata.SD_TEST2] = struct.pack('>32s', sha256)
return orig(self, text, transaction, link, p1, p2, *args, **kwargs) return orig(self, text, transaction, link, p1, p2, *args, **kwargs)
def wraprevision(orig, self, nodeorrev, *args, **kwargs): def wraprevision(orig, self, nodeorrev, *args, **kwargs):
text = orig(self, nodeorrev, *args, **kwargs) text = orig(self, nodeorrev, *args, **kwargs)
if getattr(self, 'sidedatanocheck', False): if getattr(self, 'sidedatanocheck', False):
return text return text
if nodeorrev != node.nullrev and nodeorrev != node.nullid: if nodeorrev != nullrev and nodeorrev != nullid:
sd = self.sidedata(nodeorrev) sd = self.sidedata(nodeorrev)
if len(text) != struct.unpack('>I', sd[sidedata.SD_TEST1])[0]: if len(text) != struct.unpack('>I', sd[sidedata.SD_TEST1])[0]:
raise RuntimeError('text size mismatch') raise RuntimeError('text size mismatch')
expected = sd[sidedata.SD_TEST2] expected = sd[sidedata.SD_TEST2]
got = hashlib.sha256(text).digest() got = hashlib.sha256(text).digest()
if got != expected: if got != expected:
raise RuntimeError('sha256 mismatch') raise RuntimeError('sha256 mismatch')
return text return text