state: support validated declaration of nested unfinished ops
This enables extensions to define commands that delgate to rebase, evolve, etc. one or more times to also have their own unfinished states for the full sequence of operations without monkey-patching _unfinishedstates.
Differential Revision: https://phab.mercurial-scm.org/D8714
--- a/mercurial/state.py Fri Jul 17 20:24:42 2020 +0200
+++ b/mercurial/state.py Tue Jul 14 13:36:57 2020 -0700
@@ -19,6 +19,8 @@
from __future__ import absolute_import
+import contextlib
+
from .i18n import _
from . import (
@@ -119,6 +121,7 @@
reportonly,
continueflag,
stopflag,
+ childopnames,
cmdmsg,
cmdhint,
statushint,
@@ -132,6 +135,8 @@
self._reportonly = reportonly
self._continueflag = continueflag
self._stopflag = stopflag
+ self._childopnames = childopnames
+ self._delegating = False
self._cmdmsg = cmdmsg
self._cmdhint = cmdhint
self._statushint = statushint
@@ -181,12 +186,15 @@
"""
if self._opname == b'merge':
return len(repo[None].parents()) > 1
+ elif self._delegating:
+ return False
else:
return repo.vfs.exists(self._fname)
# A list of statecheck objects for multistep operations like graft.
_unfinishedstates = []
+_unfinishedstatesbyname = {}
def addunfinished(
@@ -197,6 +205,7 @@
reportonly=False,
continueflag=False,
stopflag=False,
+ childopnames=None,
cmdmsg=b"",
cmdhint=b"",
statushint=b"",
@@ -218,6 +227,8 @@
`--continue` option or not.
stopflag is a boolean that determines whether or not a command supports
--stop flag
+ childopnames is a list of other opnames this op uses as sub-steps of its
+ own execution. They must already be added.
cmdmsg is used to pass a different status message in case standard
message of the format "abort: cmdname in progress" is not desired.
cmdhint is used to pass a different hint message in case standard
@@ -230,6 +241,7 @@
continuefunc stores the function required to finish an interrupted
operation.
"""
+ childopnames = childopnames or []
statecheckobj = _statecheck(
opname,
fname,
@@ -238,17 +250,98 @@
reportonly,
continueflag,
stopflag,
+ childopnames,
cmdmsg,
cmdhint,
statushint,
abortfunc,
continuefunc,
)
+
if opname == b'merge':
_unfinishedstates.append(statecheckobj)
else:
+ # This check enforces that for any op 'foo' which depends on op 'bar',
+ # 'foo' comes before 'bar' in _unfinishedstates. This ensures that
+ # getrepostate() always returns the most specific applicable answer.
+ for childopname in childopnames:
+ if childopname not in _unfinishedstatesbyname:
+ raise error.ProgrammingError(
+ _(b'op %s depends on unknown op %s') % (opname, childopname)
+ )
+
_unfinishedstates.insert(0, statecheckobj)
+ if opname in _unfinishedstatesbyname:
+ raise error.ProgrammingError(_(b'op %s registered twice') % opname)
+ _unfinishedstatesbyname[opname] = statecheckobj
+
+
+def _getparentandchild(opname, childopname):
+ p = _unfinishedstatesbyname.get(opname, None)
+ if not p:
+ raise error.ProgrammingError(_(b'unknown op %s') % opname)
+ if childopname not in p._childopnames:
+ raise error.ProgrammingError(
+ _(b'op %s does not delegate to %s') % (opname, childopname)
+ )
+ c = _unfinishedstatesbyname[childopname]
+ return p, c
+
+
+@contextlib.contextmanager
+def delegating(repo, opname, childopname):
+ """context wrapper for delegations from opname to childopname.
+
+ requires that childopname was specified when opname was registered.
+
+ Usage:
+ def my_command_foo_that_uses_rebase(...):
+ ...
+ with state.delegating(repo, 'foo', 'rebase'):
+ _run_rebase(...)
+ ...
+ """
+
+ p, c = _getparentandchild(opname, childopname)
+ if p._delegating:
+ raise error.ProgrammingError(
+ _(b'cannot delegate from op %s recursively') % opname
+ )
+ p._delegating = True
+ try:
+ yield
+ except error.ConflictResolutionRequired as e:
+ # Rewrite conflict resolution advice for the parent opname.
+ if e.opname == childopname:
+ raise error.ConflictResolutionRequired(opname)
+ raise e
+ finally:
+ p._delegating = False
+
+
+def ischildunfinished(repo, opname, childopname):
+ """Returns true if both opname and childopname are unfinished."""
+
+ p, c = _getparentandchild(opname, childopname)
+ return (p._delegating or p.isunfinished(repo)) and c.isunfinished(repo)
+
+
+def continuechild(ui, repo, opname, childopname):
+ """Checks that childopname is in progress, and continues it."""
+
+ p, c = _getparentandchild(opname, childopname)
+ if not ischildunfinished(repo, opname, childopname):
+ raise error.ProgrammingError(
+ _(b'child op %s of parent %s is not unfinished')
+ % (childopname, opname)
+ )
+ if not c.continuefunc:
+ raise error.ProgrammingError(
+ _(b'op %s has no continue function') % childopname
+ )
+ return c.continuefunc(ui, repo)
+
addunfinished(
b'update',
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/tests/test-state-extension.t Tue Jul 14 13:36:57 2020 -0700
@@ -0,0 +1,136 @@
+Test extension of unfinished states support.
+ $ mkdir chainify
+ $ cd chainify
+ $ cat >> chainify.py <<EOF
+ > from mercurial import cmdutil, error, extensions, exthelper, node, scmutil, state
+ > from hgext import rebase
+ >
+ > eh = exthelper.exthelper()
+ >
+ > extsetup = eh.finalextsetup
+ > cmdtable = eh.cmdtable
+ >
+ > # Rebase calls addunfinished in uisetup, so we have to call it in extsetup.
+ > # Ideally there'd by an 'extensions.afteruisetup()' just like
+ > # 'extensions.afterloaded()' to allow nesting multiple commands.
+ > @eh.extsetup
+ > def _extsetup(ui):
+ > state.addunfinished(
+ > b'chainify',
+ > b'chainify.state',
+ > continueflag=True,
+ > childopnames=[b'rebase'])
+ >
+ > def _node(repo, arg):
+ > return node.hex(scmutil.revsingle(repo, arg).node())
+ >
+ > @eh.command(
+ > b'chainify',
+ > [(b'r', b'revs', [], b'revs to chain', b'REV'),
+ > (b'', b'continue', False, b'continue op')],
+ > b'chainify [-r REV] +',
+ > inferrepo=True)
+ > def chainify(ui, repo, **opts):
+ > """Rebases r1, r2, r3, etc. into a chain."""
+ > with repo.wlock(), repo.lock():
+ > cmdstate = state.cmdstate(repo, b'chainify.state')
+ > if opts['continue']:
+ > if not cmdstate.exists():
+ > raise error.Abort(b'no chainify in progress')
+ > else:
+ > cmdutil.checkunfinished(repo)
+ > data = {
+ > b'tip': _node(repo, opts['revs'][0]),
+ > b'revs': b','.join(_node(repo, r) for r in opts['revs'][1:]),
+ > }
+ > cmdstate.save(1, data)
+ >
+ > data = cmdstate.read()
+ > while data[b'revs']:
+ > tip = data[b'tip']
+ > revs = data[b'revs'].split(b',')
+ > with state.delegating(repo, b'chainify', b'rebase'):
+ > ui.status(b'rebasing %s onto %s\n' % (revs[0][:12], tip[:12]))
+ > if state.ischildunfinished(repo, b'chainify', b'rebase'):
+ > rc = state.continuechild(ui, repo, b'chainify', b'rebase')
+ > else:
+ > rc = rebase.rebase(ui, repo, rev=[revs[0]], dest=tip)
+ > if rc and rc != 0:
+ > raise error.Abort(b'rebase failed (rc: %d)' % rc)
+ > data[b'tip'] = _node(repo, b'tip')
+ > data[b'revs'] = b','.join(revs[1:])
+ > cmdstate.save(1, data)
+ > cmdstate.delete()
+ > ui.status(b'done chainifying\n')
+ > EOF
+
+ $ chainifypath=`pwd`/chainify.py
+ $ echo '[extensions]' >> $HGRCPATH
+ $ echo "chainify = $chainifypath" >> $HGRCPATH
+ $ echo "rebase =" >> $HGRCPATH
+
+ $ cd $TESTTMP
+ $ hg init a
+ $ cd a
+ $ echo base > base.txt
+ $ hg commit -Aqm 'base commit'
+ $ echo foo > file1
+ $ hg commit -Aqm 'add file'
+ $ hg co -q ".^"
+ $ echo bar > file2
+ $ hg commit -Aqm 'add other file'
+ $ hg co -q ".^"
+ $ echo foo2 > file1
+ $ hg commit -Aqm 'add conflicting file'
+ $ hg co -q ".^"
+ $ hg log --graph --template '{rev} {files}'
+ o 3 file1
+ |
+ | o 2 file2
+ |/
+ | o 1 file1
+ |/
+ @ 0 base.txt
+
+ $ hg chainify -r 8430cfdf77c2 -r f8596309dff8 -r a858b338b3e9
+ rebasing f8596309dff8 onto 8430cfdf77c2
+ rebasing 2:f8596309dff8 "add other file"
+ saved backup bundle to $TESTTMP/* (glob)
+ rebasing a858b338b3e9 onto 83c722183a8e
+ rebasing 2:a858b338b3e9 "add conflicting file"
+ merging file1
+ warning: conflicts while merging file1! (edit, then use 'hg resolve --mark')
+ unresolved conflicts (see 'hg resolve', then 'hg chainify --continue')
+ [1]
+ $ hg status --config commands.status.verbose=True
+ M file1
+ ? file1.orig
+ # The repository is in an unfinished *chainify* state.
+
+ # Unresolved merge conflicts:
+ #
+ # file1
+ #
+ # To mark files as resolved: hg resolve --mark FILE
+
+ # To continue: hg chainify --continue
+ # To abort: hg chainify --abort
+
+ $ echo foo3 > file1
+ $ hg resolve --mark file1
+ (no more unresolved files)
+ continue: hg chainify --continue
+ $ hg chainify --continue
+ rebasing a858b338b3e9 onto 83c722183a8e
+ rebasing 2:a858b338b3e9 "add conflicting file"
+ saved backup bundle to $TESTTMP/* (glob)
+ done chainifying
+ $ hg log --graph --template '{rev} {files}'
+ o 3 file1
+ |
+ o 2 file2
+ |
+ o 1 file1
+ |
+ @ 0 base.txt
+