state: created new class statecheck to handle unfinishedstates
authorTaapas Agrawal <taapas2897@gmail.com>
Sun, 09 Jun 2019 00:43:36 +0530
changeset 42530 dc3fdd1b5af4
parent 42529 5f2f6912c9e6
child 42531 5bddd2244814
state: created new class statecheck to handle unfinishedstates For the purpose of handling states for various multistep operations like `hg graft`, `hg histedit`, `hg bisect` et al a new class called statecheck is created .This will help in having a unified approach towards these commands and handle them with ease. The class takes in 4 basic arguments which include the name of the command, the name of the state file associated with it , clearable flag , allowcommit flag. This also also adds the support of`checkunfinished()` and `clearunfinished()` to the class. Tests remain unchanged. Differential Revision: https://phab.mercurial-scm.org/D6501
hgext/histedit.py
hgext/rebase.py
hgext/shelve.py
hgext/transplant.py
mercurial/cmdutil.py
mercurial/state.py
--- a/hgext/histedit.py	Sat Jun 08 23:43:53 2019 +0530
+++ b/hgext/histedit.py	Sun Jun 09 00:43:36 2019 +0530
@@ -2313,8 +2313,6 @@
 
 def extsetup(ui):
     cmdutil.summaryhooks.add('histedit', summaryhook)
-    statemod.unfinishedstates.append(
-        ['histedit-state', False, True, _('histedit in progress'),
-         _("use 'hg histedit --continue' or 'hg histedit --abort'")])
+    statemod.addunfinished('histedit', fname='histedit-state', allowcommit=True)
     cmdutil.afterresolvedstates.append(
         ['histedit-state', _('hg histedit --continue')])
--- a/hgext/rebase.py	Sat Jun 08 23:43:53 2019 +0530
+++ b/hgext/rebase.py	Sun Jun 09 00:43:36 2019 +0530
@@ -1950,8 +1950,6 @@
     entry[1].append(('t', 'tool', '',
                      _("specify merge tool for rebase")))
     cmdutil.summaryhooks.add('rebase', summaryhook)
-    statemod.unfinishedstates.append(
-        ['rebasestate', False, False, _('rebase in progress'),
-         _("use 'hg rebase --continue' or 'hg rebase --abort'")])
+    statemod.addunfinished('rebase', fname='rebasestate')
     cmdutil.afterresolvedstates.append(
         ['rebasestate', _('hg rebase --continue')])
--- a/hgext/shelve.py	Sat Jun 08 23:43:53 2019 +0530
+++ b/hgext/shelve.py	Sun Jun 09 00:43:36 2019 +0530
@@ -1140,10 +1140,9 @@
         return createcmd(ui, repo, pats, opts)
 
 def extsetup(ui):
-    statemod.unfinishedstates.append(
-        [shelvedstate._filename, False, False,
-         _('unshelve already in progress'),
-         _("use 'hg unshelve --continue' or 'hg unshelve --abort'")])
+    statemod.addunfinished(
+        'unshelve', fname=shelvedstate._filename,
+        cmdmsg=_('unshelve already in progress')
+    )
     cmdutil.afterresolvedstates.append(
         [shelvedstate._filename, _('hg unshelve --continue')])
-
--- a/hgext/transplant.py	Sat Jun 08 23:43:53 2019 +0530
+++ b/hgext/transplant.py	Sun Jun 09 00:43:36 2019 +0530
@@ -758,9 +758,10 @@
     return n and nodemod.hex(n) or ''
 
 def extsetup(ui):
-    statemod.unfinishedstates.append(
-        ['transplant/journal', True, False, _('transplant in progress'),
-         _("use 'hg transplant --continue' or 'hg update' to abort")])
+    statemod.addunfinished (
+        'transplant', fname='transplant/journal', clearable=True,
+        cmdhint=_("use 'hg transplant --continue' or 'hg update' to abort")
+    )
 
 # tell hggettext to extract docstrings from these functions:
 i18nfunctions = [revsettransplanted, kwtransplanted]
--- a/mercurial/cmdutil.py	Sat Jun 08 23:43:53 2019 +0530
+++ b/mercurial/cmdutil.py	Sun Jun 09 00:43:36 2019 +0530
@@ -3314,6 +3314,7 @@
 #  - (desturl,   destbranch,   destpeer,   outgoing)
 summaryremotehooks = util.hooks()
 
+
 def checkunfinished(repo, commit=False):
     '''Look for an unfinished multistep operation, like graft, and abort
     if found. It's probably good to check this right before
@@ -3321,28 +3322,29 @@
     '''
     # Check for non-clearable states first, so things like rebase will take
     # precedence over update.
-    for f, clearable, allowcommit, msg, hint in statemod.unfinishedstates:
-        if clearable or (commit and allowcommit):
+    for state in statemod._unfinishedstates:
+        if state._clearable or (commit and state._allowcommit):
             continue
-        if repo.vfs.exists(f):
-            raise error.Abort(msg, hint=hint)
-
-    for f, clearable, allowcommit, msg, hint in statemod.unfinishedstates:
-        if not clearable or (commit and allowcommit):
+        if state.isunfinished(repo):
+            raise error.Abort(state.msg(), hint=state.hint())
+
+    for s in statemod._unfinishedstates:
+        if not s._clearable or (commit and s._allowcommit):
             continue
-        if repo.vfs.exists(f):
-            raise error.Abort(msg, hint=hint)
+        if s.isunfinished(repo):
+            raise error.Abort(s.msg(), hint=s.hint())
 
 def clearunfinished(repo):
     '''Check for unfinished operations (as above), and clear the ones
     that are clearable.
     '''
-    for f, clearable, allowcommit, msg, hint in statemod.unfinishedstates:
-        if not clearable and repo.vfs.exists(f):
-            raise error.Abort(msg, hint=hint)
-    for f, clearable, allowcommit, msg, hint in statemod.unfinishedstates:
-        if clearable and repo.vfs.exists(f):
-            util.unlink(repo.vfs.join(f))
+    for state in statemod._unfinishedstates:
+        if not state._clearable and state.isunfinished(repo):
+            raise error.Abort(state.msg(), hint=state.hint())
+
+    for s in statemod._unfinishedstates:
+        if s._clearable and s.isunfinished(repo):
+            util.unlink(repo.vfs.join(s._fname))
 
 afterresolvedstates = [
     ('graftstate',
--- a/mercurial/state.py	Sat Jun 08 23:43:53 2019 +0530
+++ b/mercurial/state.py	Sun Jun 09 00:43:36 2019 +0530
@@ -88,13 +88,70 @@
         """check whether the state file exists or not"""
         return self._repo.vfs.exists(self.fname)
 
-# A list of state files kept by multistep operations like graft.
-# Since graft cannot be aborted, it is considered 'clearable' by update.
-# note: bisect is intentionally excluded
-# (state file, clearable, allowcommit, error, hint)
-unfinishedstates = [
-    ('graftstate', True, False, _('graft in progress'),
-     _("use 'hg graft --continue' or 'hg graft --stop' to stop")),
-    ('updatestate', True, False, _('last update was interrupted'),
-     _("use 'hg update' to get a consistent checkout"))
-    ]
+class _statecheck(object):
+    """a utility class that deals with multistep operations like graft,
+       histedit, bisect, update etc and check whether such commands
+       are in an unfinished conditition or not and return appropriate message
+       and hint.
+       It also has the ability to register and determine the states of any new
+       multistep operation or multistep command extension.
+    """
+
+    def __init__(self, opname, fname, clearable=False, allowcommit=False,
+                 cmdmsg="", cmdhint=""):
+        """opname is the name the command or operation
+        fname is the file name in which data should be stored in .hg directory.
+        It is None for merge command.
+        clearable boolean determines whether or not interrupted states can be
+        cleared by running `hg update -C .` which in turn deletes the
+        state file.
+        allowcommit boolean decides whether commit is allowed during interrupted
+        state or not.
+        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
+        message of the format use 'hg cmdname --continue' or
+        'hg cmdname --abort'" is not desired.
+        """
+        self._opname = opname
+        self._fname = fname
+        self._clearable = clearable
+        self._allowcommit = allowcommit
+        self._cmdhint = cmdhint
+        self._cmdmsg = cmdmsg
+
+    def hint(self):
+        """returns the hint message corresponding to the command"""
+        if not self._cmdhint:
+                return (_("use 'hg %s --continue' or 'hg %s --abort'") %
+                        (self._opname, self._opname))
+        return self._cmdhint
+
+    def msg(self):
+        """returns the status message corresponding to the command"""
+        if not self._cmdmsg:
+            return _('%s in progress') % (self._opname)
+        return self._cmdmsg
+
+    def isunfinished(self, repo):
+        """determines whether a multi-step operation is in progress or not"""
+        return repo.vfs.exists(self._fname)
+
+# A list of statecheck objects for multistep operations like graft.
+_unfinishedstates = []
+
+def addunfinished(opname, **kwargs):
+    """this registers a new command or operation to unfinishedstates
+    """
+    statecheckobj = _statecheck(opname, **kwargs)
+    _unfinishedstates.append(statecheckobj)
+
+addunfinished(
+    'graft', fname='graftstate', clearable=True,
+    cmdhint=_("use 'hg graft --continue' or 'hg graft --stop' to stop")
+)
+addunfinished(
+    'update', fname='updatestate', clearable=True,
+    cmdmsg=_('last update was interrupted'),
+    cmdhint=_("use 'hg update' to get a consistent checkout")
+)