diff --git a/hgext/histedit.py b/hgext/histedit.py --- a/hgext/histedit.py +++ b/hgext/histedit.py @@ -2313,8 +2313,6 @@ def summaryhook(ui, repo): 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')]) diff --git a/hgext/rebase.py b/hgext/rebase.py --- a/hgext/rebase.py +++ b/hgext/rebase.py @@ -1950,8 +1950,6 @@ def uisetup(ui): 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')]) diff --git a/hgext/shelve.py b/hgext/shelve.py --- a/hgext/shelve.py +++ b/hgext/shelve.py @@ -1140,10 +1140,9 @@ def shelvecmd(ui, repo, *pats, **opts): 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')]) - diff --git a/hgext/transplant.py b/hgext/transplant.py --- a/hgext/transplant.py +++ b/hgext/transplant.py @@ -758,9 +758,10 @@ def kwtransplanted(context, mapping): 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] diff --git a/mercurial/cmdutil.py b/mercurial/cmdutil.py --- a/mercurial/cmdutil.py +++ b/mercurial/cmdutil.py @@ -3314,6 +3314,7 @@ summaryhooks = util.hooks() # - (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 @@ def checkunfinished(repo, commit=False): ''' # 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', diff --git a/mercurial/state.py b/mercurial/state.py --- a/mercurial/state.py +++ b/mercurial/state.py @@ -88,13 +88,70 @@ class cmdstate(object): """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") +)