Patchwork D6501: state: created new class statecheck to handle unfinishedstates

login
register
mail settings
Submitter phabricator
Date June 9, 2019, 11:08 a.m.
Message ID <d28c32fbeb5b606016b78fc992c4c012@localhost.localdomain>
Download mbox | patch
Permalink /patch/40381/
State Not Applicable
Headers show

Comments

phabricator - June 9, 2019, 11:08 a.m.
taapas1128 updated this revision to Diff 15400.
taapas1128 marked an inline comment as done.

REPOSITORY
  rHG Mercurial

CHANGES SINCE LAST UPDATE
  https://phab.mercurial-scm.org/D6501?vs=15393&id=15400

REVISION DETAIL
  https://phab.mercurial-scm.org/D6501

AFFECTED FILES
  hgext/histedit.py
  hgext/rebase.py
  hgext/shelve.py
  hgext/transplant.py
  mercurial/state.py

CHANGE DETAILS




To: taapas1128, durin42, martinvonz, #hg-reviewers
Cc: mjpieters, mercurial-devel

Patch

diff --git a/mercurial/state.py b/mercurial/state.py
--- a/mercurial/state.py
+++ b/mercurial/state.py
@@ -88,43 +88,99 @@ 
         """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 will to deal with multistep operations
+       like graft, histedit, bisect, update etc and check whether such commands
+       are in an unfinished conditition of 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, cmdname, fname, clearable=False, allowcommit=False,
+                 specialmsg=None, specialhint=None):
+        """cmdname is the name the command
+        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.
+        specialmsg is used to pass a different status message in case standard
+        message of the format "abort: cmdname in progress" is not required.
+        specialhint is used to pass a different hint message in case standard
+        message of the format use 'hg %s --continue' or 'hg %s --abort'"
+        is not required.
+        """
+        self.cmdname = cmdname
+        self.fname = fname
+        self.clearable = clearable
+        self.allowcommit = allowcommit
+        self.specialhint = specialhint
+        self.specialmsg = specialmsg
+
+    def hint(self):
+        """returns the hint message corresponding to the command"""
+        if not self.specialhint:
+            if self.cmdname == 'graft':
+                hint = _("use 'hg graft --continue' or 'hg graft --stop' to stop")
+            elif self.cmdname == 'update':
+                hint = _("use 'hg update' to get a consistent checkout")
+            else:
+                hint = (_("use 'hg %s --continue' or 'hg %s --abort'") %
+                        (self.cmdname,self.cmdname))
+            return hint
+        else:
+            return self.specialhint
+
+    def msg(self):
+        """returns the status message corresponding to the command"""
+        if not self.specialmsg:
+            if self.cmdname == 'update':
+                msg = _('last update was interrupted')
+            else:
+                msg = _('%s in progress') % (self.cmdname)
+            return msg
+        else:
+            return self.specialmsg
+
+    def isunfinished(self, repo, mergecheck=False):
+        """determines whether a multi-step operation is in progress or not"""
+        return repo.vfs.exists(self.fname)
+
+unfinishedstates=[]
+unfinishedstates.append(statecheck('graft','graftstate', clearable=True,
+                                    allowcommit=False))
+unfinishedstates.append(statecheck('update', 'updatestate', clearable=True,
+                                    allowcommit=False))
 
 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
     bailifchanged().
     '''
     # Check for non-clearable states first, so things like rebase will take
     # precedence over update.
-    for f, clearable, allowcommit, msg, hint in unfinishedstates:
-        if clearable or (commit and allowcommit):
+    for state in unfinishedstates:
+        if state.clearable or (commit and state.allowcommit):
             continue
-        if repo.vfs.exists(f):
-            raise error.Abort(msg, hint=hint)
+        if state.isunfinished(repo):
+            raise error.Abort(state.msg(), hint=state.hint())
 
-    for f, clearable, allowcommit, msg, hint in unfinishedstates:
-        if not clearable or (commit and allowcommit):
+    for s in 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 unfinishedstates:
-        if not clearable and repo.vfs.exists(f):
-            raise error.Abort(msg, hint=hint)
-    for f, clearable, allowcommit, msg, hint in unfinishedstates:
-        if clearable and repo.vfs.exists(f):
-            util.unlink(repo.vfs.join(f))
+    for state in unfinishedstates:
+        if not state.clearable and state.isunfinished(repo):
+            raise error.Abort(state.msg(), hint=state.hint())
+
+    for s in unfinishedstates:
+        if s.clearable and s.isunfinished(repo):
+            util.unlink(repo.vfs.join(s.fname))
diff --git a/hgext/transplant.py b/hgext/transplant.py
--- a/hgext/transplant.py
+++ b/hgext/transplant.py
@@ -758,9 +758,9 @@ 
     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.unfinishedstates.append(statemod.statecheck('transplant',
+    'transplant/journal', clearable=True, allowcommit=False ,
+    specialhint=_("use 'hg transplant --continue' or 'hg update' to abort")))
 
 # tell hggettext to extract docstrings from these functions:
 i18nfunctions = [revsettransplanted, kwtransplanted]
diff --git a/hgext/shelve.py b/hgext/shelve.py
--- a/hgext/shelve.py
+++ b/hgext/shelve.py
@@ -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.unfinishedstates.append(statemod.statecheck('unshelve',
+    shelvedstate._filename, clearable=False, allowcommit=False,
+    specialhint=__('unshelve already in progress')))
     cmdutil.afterresolvedstates.append(
         [shelvedstate._filename, _('hg unshelve --continue')])
 
diff --git a/hgext/rebase.py b/hgext/rebase.py
--- a/hgext/rebase.py
+++ b/hgext/rebase.py
@@ -1947,8 +1947,7 @@ 
     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.unfinishedstates.append(statemod.statecheck('rebase',
+    'rebasestate', clearable=False, allowcommit=False))
     cmdutil.afterresolvedstates.append(
         ['rebasestate', _('hg rebase --continue')])
diff --git a/hgext/histedit.py b/hgext/histedit.py
--- a/hgext/histedit.py
+++ b/hgext/histedit.py
@@ -2288,8 +2288,7 @@ 
 
 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.unfinishedstates.append(statemod.statecheck('histedit',
+    'histedit-state', clearable=False, allowcommit=True))
     cmdutil.afterresolvedstates.append(
         ['histedit-state', _('hg histedit --continue')])