mercurial: comparison hgext/transplant.py

equal deleted inserted replaced

-:d6afa9c149c3
+:59fa3890d40a
 import os
 from mercurial.i18n import _
 from mercurial.pycompat import open
+from mercurial.node import (
+bin,
+hex,
+nullid,
+short,
+)
 from mercurial import (
 bundlerepo,
 cmdutil,
 error,
 exchange,
 hg,
 logcmdutil,
 match,
 merge,
-node as nodemod,
 patch,
 pycompat,
 registrar,
-revlog,
 revset,
 scmutil,
 smartset,
 state as statemod,
 util,
 def read(self):
 abspath = os.path.join(self.path, self.transplantfile)
 if self.transplantfile and os.path.exists(abspath):
 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.append(transplantentry(lnode, rnode))
 def write(self):
 if self.dirty and self.transplantfile:
 if not os.path.isdir(self.path):
 os.mkdir(self.path)
 fp = self.opener(self.transplantfile, b'w')
 for list in pycompat.itervalues(self.transplants):
 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.close()
 self.dirty = False
 def get(self, rnode):
 try:
 lock = repo.lock()
 tr = repo.transaction(b'transplant')
 for rev in revs:
 node = revmap[rev]
-revstr = b'%d:%s' % (rev, nodemod.short(node))
+revstr = b'%d:%s' % (rev, short(node))
 if self.applied(repo, node, p1):
 self.ui.warn(
 _(b'skipping already applied revision %s\n') % revstr
 )
 domerge = True
 if not hasnode(repo, node):
 exchange.pull(repo, source.peer(), heads=[node])
 skipmerge = False
-if parents[1] != revlog.nullid:
+if parents[1] != nullid:
 if not opts.get(b'parent'):
 self.ui.note(
 _(b'skipping merge changeset %d:%s\n')
-% (rev, nodemod.short(node))
+% (rev, short(node))
 )
 skipmerge = True
 else:
 parent = source.lookup(opts[b'parent'])
 if parent not in parents:
 raise error.Abort(
 _(b'%s is not a parent of %s')
-% (nodemod.short(parent), nodemod.short(node))
+% (short(parent), short(node))
 )
 else:
 parent = parents[0]
 if skipmerge:
 # fix the merge or cancel everything
 tr.close()
 raise
 if n and domerge:
 self.ui.status(
-_(b'%s merged at %s\n')
+_(b'%s merged at %s\n') % (revstr, short(n))
-% (revstr, nodemod.short(n))
 )
 elif n:
 self.ui.status(
 _(b'%s transplanted to %s\n')
-% (nodemod.short(node), nodemod.short(n))
+% (short(node), short(n))
 )
 finally:
 if patchfile:
 os.unlink(patchfile)
 tr.close()
 procutil.shellquote(headerfile),
 procutil.shellquote(patchfile),
 ),
 environ={
 b'HGUSER': changelog[1],
-b'HGREVISION': nodemod.hex(node),
+b'HGREVISION': hex(node),
 },
 onerr=error.Abort,
 errprefix=_(b'filter failed'),
 blockedtag=b'transplant_filter',
 )
 if filter:
 (user, date, message) = self.filter(filter, node, cl, patchfile)
 if log:
 # 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))
 if not patchfile and not merge:
 raise error.Abort(_(b'can only omit patchfile if merging'))
 if patchfile:
 extra=extra,
 match=m,
 editor=self.getcommiteditor(),
 )
 if not n:
-self.ui.warn(
+self.ui.warn(_(b'skipping emptied changeset %s\n') % short(node))
-_(b'skipping emptied changeset %s\n') % nodemod.short(node)
-)
 return None
 if not merge:
 self.transplants.set(n, node)
 return n
 '''recover last transaction and apply remaining changesets'''
 if os.path.exists(os.path.join(self.path, b'journal')):
 n, node = self.recover(repo, source, opts)
 if n:
 self.ui.status(
-_(b'%s transplanted as %s\n')
+_(b'%s transplanted as %s\n') % (short(node), short(n))
-% (nodemod.short(node), nodemod.short(n))
 )
 else:
 self.ui.status(
-_(b'%s skipped due to empty diff\n')
+_(b'%s skipped due to empty diff\n') % (short(node),)
-% (nodemod.short(node),)
 )
 seriespath = os.path.join(self.path, b'series')
 if not os.path.exists(seriespath):
 self.transplants.write()
 return
 if opts.get(b'parent'):
 parent = source.lookup(opts[b'parent'])
 if parent not in parents:
 raise error.Abort(
 _(b'%s is not a parent of %s')
-% (nodemod.short(parent), nodemod.short(node))
+% (short(parent), short(node))
 )
 else:
 merge = True
 extra = {b'transplant_source': node}
 try:
 p1 = repo.dirstate.p1()
 if p1 != parent:
 raise error.Abort(
 _(b'working directory not at transplant parent %s')
-% nodemod.hex(parent)
+% hex(parent)
 )
 if merge:
 repo.setparents(p1, parents[1])
 st = repo.status()
 modified, added, removed, deleted = (
 cur = nodes
 for line in self.opener.read(b'series').splitlines():
 if line.startswith(b'# Merges'):
 cur = merges
 continue
-cur.append(revlog.bin(line))
+cur.append(bin(line))
 return (nodes, merges)
 def saveseries(self, revmap, merges):
 if not revmap:
 if not os.path.isdir(self.path):
 os.mkdir(self.path)
 series = self.opener(b'series', b'w')
 for rev in sorted(revmap):
-series.write(nodemod.hex(revmap[rev]) + b'\n')
+series.write(hex(revmap[rev]) + b'\n')
 if merges:
 series.write(b'# Merges\n')
 for m in merges:
-series.write(nodemod.hex(m) + b'\n')
+series.write(hex(m) + b'\n')
 series.close()
 def parselog(self, fp):
 parents = []
 message = []
-node = revlog.nullid
+node = nullid
 inmsg = False
 user = None
 date = None
 for line in fp.read().splitlines():
 if inmsg:
 elif line.startswith(b'# User '):
 user = line[7:]
 elif line.startswith(b'# Date '):
 date = line[7:]
 elif line.startswith(b'# Node ID '):
-node = revlog.bin(line[10:])
+node = bin(line[10:])
 elif line.startswith(b'# Parent '):
-parents.append(revlog.bin(line[9:]))
+parents.append(bin(line[9:]))
 elif not line.startswith(b'# '):
 inmsg = True
 message.append(line)
 if None in (user, date):
 raise error.Abort(
 if not os.path.isdir(self.path):
 os.mkdir(self.path)
 fp = self.opener(b'journal', b'w')
 fp.write(b'# User %s\n' % user)
 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:
-fp.write(b'# Parent ' + nodemod.hex(p2) + b'\n')
+fp.write(b'# Parent ' + hex(p2) + b'\n')
 fp.write(message.rstrip() + b'\n')
 fp.close()
 def readlog(self):
 return self.parselog(self.opener(b'journal'))
 def transplantfilter(self, repo, source, root):
 def matchfn(node):
 if self.applied(repo, node, root):
 return False
-if source.changelog.parents(node)[1] != revlog.nullid:
+if source.changelog.parents(node)[1] != nullid:
 return False
 extra = source.changelog.read(node)[5]
 cnode = extra.get(b'transplant_source')
 if cnode and self.applied(repo, cnode, root):
 return False
 opts[b'filter'] = ui.config(b'transplant', b'filter')
 tp = transplanter(ui, repo, opts)
 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'))
 if opts.get(b'continue'):
 if not tp.canresume():
 raise error.StateError(_(b'no transplant to continue'))
 elif opts.get(b'stop'):
 def kwtransplanted(context, mapping):
 """String. The node identifier of the transplanted
 changeset if any."""
 ctx = context.resource(mapping, b'ctx')
 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):
 statemod.addunfinished(
 b'transplant',

changeset 46113	59fa3890d40a
parent 45942	89a2afe31e82
child 46944	0428e555acb7