mercurial: comparison hgext/histedit.py

equal deleted inserted replaced

-:d6afa9c149c3
+:59fa3890d40a
 from mercurial.i18n import _
 from mercurial.pycompat import (
 getattr,
 open,
 )
+from mercurial.node import (
+bin,
+hex,
+short,
+)
 from mercurial import (
 bundle2,
 cmdutil,
 context,
 copies,
 hg,
 logcmdutil,
 merge as mergemod,
 mergestate as mergestatemod,
 mergeutil,
-node,
 obsolete,
 pycompat,
 registrar,
 repair,
 rewriteutil,
 with self.repo.vfs(b"histedit-state", b"w") as f:
 self._write(f)
 def _write(self, fp):
 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'%d\n' % len(self.actions))
 for action in self.actions:
 fp.write(b'%s\n' % action.tostate())
 fp.write(b'%d\n' % len(self.replacements))
 for replacement in self.replacements:
 fp.write(
 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
 if not backupfile:
 backupfile = b''
 index = 0
 lines[index]  # version number
 index += 1
-parentctxnode = node.bin(lines[index])
+parentctxnode = bin(lines[index])
 index += 1
-topmost = node.bin(lines[index])
+topmost = bin(lines[index])
 index += 1
 keep = lines[index] == b'True'
 index += 1
 replacements = []
 replacementlen = int(lines[index])
 index += 1
 for i in pycompat.xrange(replacementlen):
 replacement = lines[index]
-original = node.bin(replacement[:40])
+original = bin(replacement[:40])
 succ = [
-node.bin(replacement[i : i + 40])
+bin(replacement[i : i + 40])
 for i in range(40, len(replacement), 40)
 ]
 replacements.append((original, succ))
 index += 1
 """Parses the given rule, returning an instance of the histeditaction."""
 ruleid = rule.strip().split(b' ', 1)[0]
 # ruleid can be anything from rev numbers, hashes, "bookmarks" etc
 # Check for validation of rule ids and get the rulehash
 try:
-rev = node.bin(ruleid)
+rev = bin(ruleid)
 except TypeError:
 try:
 _ctx = scmutil.revsingle(state.repo, ruleid)
 rulehash = _ctx.hex()
-rev = node.bin(rulehash)
+rev = bin(rulehash)
 except error.RepoLookupError:
 raise error.ParseError(_(b"invalid changeset %s") % ruleid)
 return cls(state, rev)
 def verify(self, prev, expected, seen):
 """ Verifies semantic correctness of the rule"""
 repo = self.repo
-ha = node.hex(self.node)
+ha = hex(self.node)
 self.node = scmutil.resolvehexnodeidprefix(repo, ha)
 if self.node is None:
 raise error.ParseError(_(b'unknown changeset %s listed') % ha[:12])
 self._verifynodeconstraints(prev, expected, seen)
 def _verifynodeconstraints(self, prev, expected, seen):
 # by default command need a node in the edited list
 if self.node not in expected:
 raise error.ParseError(
 _(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'),
 )
 # and only one command per node
 if self.node in seen:
 raise error.ParseError(
-_(b'duplicated command for changeset %s')
+_(b'duplicated command for changeset %s') % short(self.node)
-% node.short(self.node)
 )
 def torule(self):
 """build a histedit rule line for an action
 def tostate(self):
 """Print an action in format used by histedit state files
 (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):
 """Runs the action. The default behavior is simply apply the action's
 rulectx onto the current parentctx."""
 self.applychange()
 repo.ui.popbuffer()
 stats = applychanges(repo.ui, repo, rulectx, {})
 repo.dirstate.setbranch(rulectx.branch())
 if stats.unresolvedcount:
 raise error.InterventionRequired(
-_(b'Fix up the change (%s %s)')
+_(b'Fix up the change (%s %s)') % (self.verb, short(self.node)),
-% (self.verb, node.short(self.node)),
 hint=_(b'hg histedit --continue to resume'),
 )
 def continuedirty(self):
 """Continues the action when changes have been applied to the working
 behavior is to accept the current commit as the new version of the
 rulectx."""
 ctx = self.repo[b'.']
 if ctx.node() == self.state.parentctxnode:
 self.repo.ui.warn(
-_(b'%s: skipping changeset (no changes)\n')
+_(b'%s: skipping changeset (no changes)\n') % short(self.node)
-% node.short(self.node)
 )
 return ctx, [(self.node, tuple())]
 if ctx.node() == self.node:
 # Nothing changed
 return ctx, []
 if not ctxs:
 return None
 for c in ctxs:
 if not c.mutable():
 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()
 # commit a new version of the old changeset, including the update
 # collect all files which might be affected
 @action([b'pick', b'p'], _(b'use commit'), priority=True)
 class pick(histeditaction):
 def run(self):
 rulectx = self.repo[self.node]
 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 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):
 def run(self):
 repo = self.repo
 rulectx = repo[self.node]
 hg.update(repo, self.state.parentctxnode, quietempty=True)
 applychanges(repo.ui, repo, rulectx, {})
 hint = _(b'to edit %s, `hg histedit --continue` after making changes')
 raise error.InterventionRequired(
 _(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):
 return cmdutil.getcommiteditor(edit=True, editform=b'histedit.edit')
 return
 else:
 c = repo[prev.node]
 if not c.mutable():
 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):
 repo = self.repo
 rulectx = repo[self.node]
 commit = commitfuncfor(repo, rulectx)
 commit(
-text=b'fold-temp-revision %s' % node.short(self.node),
+text=b'fold-temp-revision %s' % short(self.node),
 user=rulectx.user(),
 date=rulectx.date(),
 extra=rulectx.extra(),
 )
 repo = self.repo
 ctx = repo[b'.']
 rulectx = repo[self.node]
 parentctxnode = self.state.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,))]
 parentctx = repo[parentctxnode]
 newcommits = {
 c.node()
 repo.ui.warn(
 _(
 b'%s: cannot fold - working copy is not a '
 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(),))]
 middlecommits = newcommits.copy()
 middlecommits.discard(ctx.node())
 def _verifynodeconstraints(self, prev, expected, seen):
 # base can only be use with a node not in the edited set
 if self.node in expected:
 msg = _(b'%s "%s" changeset was an edited list candidate')
 raise error.ParseError(
-msg % (self.verb, node.short(self.node)),
+msg % (self.verb, short(self.node)),
 hint=_(b'base must only use unlisted changesets'),
 )
 @action(
 topmost = repo.dirstate.p1()
 revs = between(repo, root, topmost, keep)
 if not revs:
 raise error.Abort(
-_(b'%s is not an ancestor of working directory')
+_(b'%s is not an ancestor of working directory') % short(root)
-% node.short(root)
 )
 ctxs = []
 for i, r in enumerate(revs):
 ctxs.append(histeditrule(ui, repo[r], i))
 mapping, tmpnodes, created, ntm = processreplacement(state)
 if mapping:
 for prec, succs in pycompat.iteritems(mapping):
 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:
 ui.debug(
 b'histedit: %s is replaced by %s\n'
-% (node.short(prec), node.short(succs[0]))
+% (short(prec), short(succs[0]))
 )
 if len(succs) > 1:
 m = b'histedit:                            %s'
 for n in succs[1:]:
-ui.debug(m % node.short(n))
+ui.debug(m % short(n))
 if not state.keep:
 if mapping:
 movetopmostbookmarks(repo, state.topmost, ntm)
 # TODO update mq state
 def _aborthistedit(ui, repo, state, nobackup=False):
 try:
 state.read()
 __, 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
 if not state.topmost in repo and state.backupfile:
 backupfile = repo.vfs.join(state.backupfile)
 f = hg.openpath(ui, backupfile)
 def _edithisteditplan(ui, repo, state, rules):
 state.read()
 if not rules:
 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)
 else:
 rules = _readfile(ui, rules)
 actions = parserules(rules, state)
 root = rr[0].node()
 revs = between(repo, root, topmost, state.keep)
 if not revs:
 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]
 wctx = repo[None]
 )
 % c
 )
 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]
 rules = ruleeditor(repo, ui, actions, comment)
 else:
 rules = _readfile(ui, rules)
 actions = parserules(rules, state)
 # put the in the beginning so they execute immediately and
 # don't show in the edit-plan in the future
 actions[:0] = drops
 elif missing:
 raise error.ParseError(
-_(b'missing rules for changeset %s') % node.short(missing[0]),
+_(b'missing rules for changeset %s') % short(missing[0]),
 hint=_(
 b'use "drop %s" to discard, see also: '
 b"'hg help -e histedit.config'"
 )
-% node.short(missing[0]),
+% short(missing[0]),
 )
 def adjustreplacementsfrommarkers(repo, oldreplacements):
 """Adjust replacements from obsolescence markers
 }
 common_nodes = histedit_nodes & set(nodelist)
 if common_nodes:
 raise error.Abort(
 _(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)
 extensions.wrapfunction(repair, b'strip', stripwrapper)

changeset 46113	59fa3890d40a
parent 46104	6f8a94bbfba1
child 46394	8477c91b5e8e