mercurial: comparison hgext/rebase.py

equal deleted inserted replaced

-:66d41c9e9222
+:6e83f5bbed8d
 sourceset = None
 if x is not None:
 sourceset = revset.getset(repo, revset.fullreposet(repo), x)
 return subset & revset.baseset([_destrebase(repo, sourceset)])
+class rebaseruntime(object):
+"""This class is a container for rebase runtime state"""
+def __init__(self):
+self.originalwd = None
+self.external = nullrev
+# Mapping between the old revision id and either what is the new rebased
+# revision or what needs to be done with the old revision. The state
+# dict will be what contains most of the rebase progress state.
+self.state = {}
+self.activebookmark = None
 @command('rebase',
 [('s', 'source', '',
 _('rebase the specified changeset and descendants'), _('REV')),
 ('b', 'base', '',
 _('rebase everything from branching point of specified changeset'),
 Returns 0 on success, 1 if nothing to rebase or there are
 unresolved conflicts.
 """
-originalwd = target = None
+rbsrt = rebaseruntime()
-activebookmark = None
+target = None
-external = nullrev
-# Mapping between the old revision id and either what is the new rebased
-# revision or what needs to be done with the old revision. The state dict
-# will be what contains most of the rebase progress state.
-state = {}
 skipped = set()
 targetancestors = set()
 lock = wlock = None
 _('abort and continue do not allow specifying revisions'))
 if abortf and opts.get('tool', False):
 ui.warn(_('tool option will be ignored\n'))
 try:
-(originalwd, target, state, skipped, collapsef, keepf,
+(rbsrt.originalwd, target, rbsrt.state, skipped,
-keepbranchesf, external, activebookmark) = restorestatus(repo)
+collapsef, keepf, keepbranchesf, rbsrt.external,
+rbsrt.activebookmark) = restorestatus(repo)
 collapsemsg = restorecollapsemsg(repo)
 except error.RepoLookupError:
 if abortf:
 clearstatus(repo)
 clearcollapsemsg(repo)
 else:
 msg = _('cannot continue inconsistent rebase')
 hint = _('use "hg rebase --abort" to clear broken state')
 raise error.Abort(msg, hint=hint)
 if abortf:
-return abort(repo, originalwd, target, state,
+return abort(repo, rbsrt.originalwd, target, rbsrt.state,
-activebookmark=activebookmark)
+activebookmark=rbsrt.activebookmark)
 obsoletenotrebased = {}
 if ui.configbool('experimental', 'rebaseskipobsolete',
 default=True):
-rebaseobsrevs = set([r for r, status in state.items()
+rebaseobsrevs = set([r for r, st in rbsrt.state.items()
-if status == revprecursor])
+if st == revprecursor])
-rebasesetrevs = set(state.keys())
+rebasesetrevs = set(rbsrt.state.keys())
 obsoletenotrebased = _computeobsoletenotrebased(repo,
-rebaseobsrevs,
+rebaseobsrevs, target)
-target)
 rebaseobsskipped = set(obsoletenotrebased)
 _checkobsrebase(repo, ui, rebaseobsrevs, rebasesetrevs,
 rebaseobsskipped)
 else:
 dest, rebaseset = _definesets(ui, repo, destf, srcf, basef, revf,
 if not keepf and not repo[root].mutable():
 raise error.Abort(_("can't rebase public changeset %s")
 % repo[root],
 hint=_('see "hg help phases" for details'))
-originalwd, target, state = result
+(rbsrt.originalwd, target, rbsrt.state) = result
 if collapsef:
 targetancestors = repo.changelog.ancestors([target],
 inclusive=True)
-external = externalparent(repo, state, targetancestors)
+rbsrt.external = externalparent(repo, rbsrt.state,
+targetancestors)
 if dest.closesbranch() and not keepbranchesf:
 ui.status(_('reopening closed branch head %s\n') % dest)
 if keepbranchesf:
 # there's a user-provided extrafn it can clobber branch if
 # desired
 extrafns.insert(0, _savebranch)
 if collapsef:
 branches = set()
-for rev in state:
+for rev in rbsrt.state:
 branches.add(repo[rev].branch())
 if len(branches) > 1:
 raise error.Abort(_('cannot collapse multiple named '
 'branches'))
 if not targetancestors:
 targetancestors = repo.changelog.ancestors([target], inclusive=True)
 # Keep track of the current bookmarks in order to reset them later
 currentbookmarks = repo._bookmarks.copy()
-activebookmark = activebookmark or repo._activebookmark
+rbsrt.activebookmark = rbsrt.activebookmark or repo._activebookmark
-if activebookmark:
+if rbsrt.activebookmark:
 bookmarks.deactivate(repo)
 extrafn = _makeextrafn(extrafns)
-sortedstate = sorted(state)
+sortedstate = sorted(rbsrt.state)
 total = len(sortedstate)
 pos = 0
 for rev in sortedstate:
 ctx = repo[rev]
 desc = '%d:%s "%s"' % (ctx.rev(), ctx,
 ctx.description().split('\n', 1)[0])
 names = repo.nodetags(ctx.node()) + repo.nodebookmarks(ctx.node())
 if names:
 desc += ' (%s)' % ' '.join(names)
 pos += 1
-if state[rev] == revtodo:
+if rbsrt.state[rev] == revtodo:
 ui.status(_('rebasing %s\n') % desc)
 ui.progress(_("rebasing"), pos, ("%d:%s" % (rev, ctx)),
 _('changesets'), total)
-p1, p2, base = defineparents(repo, rev, target, state,
+p1, p2, base = defineparents(repo, rev, target, rbsrt.state,
 targetancestors,
 obsoletenotrebased)
-storestatus(repo, originalwd, target, state, collapsef, keepf,
+storestatus(repo, rbsrt.originalwd, target, rbsrt.state,
-keepbranchesf, external, activebookmark)
+collapsef, keepf, keepbranchesf,
+rbsrt.external, rbsrt.activebookmark)
 storecollapsemsg(repo, collapsemsg)
 if len(repo[None].parents()) == 2:
 repo.ui.debug('resuming interrupted rebase\n')
 else:
 try:
 ui.setconfig('ui', 'forcemerge', opts.get('tool', ''),
 'rebase')
-stats = rebasenode(repo, rev, p1, base, state,
+stats = rebasenode(repo, rev, p1, base, rbsrt.state,
 collapsef, target)
 if stats and stats[3] > 0:
 raise error.InterventionRequired(
 _('unresolved conflicts (see hg '
 'resolve, then hg rebase --continue)'))
 repo.setparents(repo[p1].node())
 repo.dirstate.endparentchange()
 newnode = None
 # Update the state
 if newnode is not None:
-state[rev] = repo[newnode].rev()
+rbsrt.state[rev] = repo[newnode].rev()
 ui.debug('rebased as %s\n' % short(newnode))
 else:
 if not collapsef:
 ui.warn(_('note: rebase of %d:%s created no changes '
 'to commit\n') % (rev, ctx))
 skipped.add(rev)
-state[rev] = p1
+rbsrt.state[rev] = p1
 ui.debug('next revision set to %s\n' % p1)
-elif state[rev] == nullmerge:
+elif rbsrt.state[rev] == nullmerge:
 ui.debug('ignoring null merge rebase of %s\n' % rev)
-elif state[rev] == revignored:
+elif rbsrt.state[rev] == revignored:
 ui.status(_('not rebasing ignored %s\n') % desc)
-elif state[rev] == revprecursor:
+elif rbsrt.state[rev] == revprecursor:
 targetctx = repo[obsoletenotrebased[rev]]
 desctarget = '%d:%s "%s"' % (targetctx.rev(), targetctx,
 targetctx.description().split('\n', 1)[0])
 msg = _('note: not rebasing %s, already in destination as %s\n')
 ui.status(msg % (desc, desctarget))
-elif state[rev] == revpruned:
+elif rbsrt.state[rev] == revpruned:
 msg = _('note: not rebasing %s, it has no successor\n')
 ui.status(msg % desc)
 else:
 ui.status(_('already rebased %s as %s\n') %
-(desc, repo[state[rev]]))
+(desc, repo[rbsrt.state[rev]]))
 ui.progress(_('rebasing'), None)
 ui.note(_('rebase merging completed\n'))
 if collapsef and not keepopen:
-p1, p2, _base = defineparents(repo, min(state), target,
+p1, p2, _base = defineparents(repo, min(rbsrt.state), target,
-state, targetancestors,
+rbsrt.state, targetancestors,
 obsoletenotrebased)
 editopt = opts.get('edit')
 editform = 'rebase.collapse'
 if collapsemsg:
 commitmsg = collapsemsg
 else:
 commitmsg = 'Collapsed revision'
-for rebased in state:
+for rebased in rbsrt.state:
-if rebased not in skipped and state[rebased] > nullmerge:
+if rebased not in skipped and\
+rbsrt.state[rebased] > nullmerge:
 commitmsg += '\n* %s' % repo[rebased].description()
 editopt = True
 editor = cmdutil.getcommiteditor(edit=editopt, editform=editform)
-newnode = concludenode(repo, rev, p1, external, commitmsg=commitmsg,
+newnode = concludenode(repo, rev, p1, rbsrt.external,
+commitmsg=commitmsg,
 extrafn=extrafn, editor=editor,
 keepbranches=keepbranchesf,
 date=date)
 if newnode is None:
 newrev = target
 else:
 newrev = repo[newnode].rev()
-for oldrev in state.iterkeys():
+for oldrev in rbsrt.state.iterkeys():
-if state[oldrev] > nullmerge:
+if rbsrt.state[oldrev] > nullmerge:
-state[oldrev] = newrev
+rbsrt.state[oldrev] = newrev
 if 'qtip' in repo.tags():
-updatemq(repo, state, skipped, **opts)
+updatemq(repo, rbsrt.state, skipped, **opts)
 if currentbookmarks:
 # Nodeids are needed to reset bookmarks
 nstate = {}
-for k, v in state.iteritems():
+for k, v in rbsrt.state.iteritems():
 if v > nullmerge:
 nstate[repo[k].node()] = repo[v].node()
 # XXX this is the same as dest.node() for the non-continue path --
 # this should probably be cleaned up
 targetnode = repo[target].node()
 # restore original working directory
 # (we do this before stripping)
-newwd = state.get(originalwd, originalwd)
+newwd = rbsrt.state.get(rbsrt.originalwd, rbsrt.originalwd)
 if newwd < 0:
 # original directory is a parent of rebase set root or ignored
-newwd = originalwd
+newwd = rbsrt.originalwd
 if newwd not in [c.rev() for c in repo[None].parents()]:
 ui.note(_("update back to initial working directory parent\n"))
 hg.updaterepo(repo, newwd, False)
 if not keepf:
 collapsedas = None
 if collapsef:
 collapsedas = newnode
-clearrebased(ui, repo, state, skipped, collapsedas)
+clearrebased(ui, repo, rbsrt.state, skipped, collapsedas)
 with repo.transaction('bookmark') as tr:
 if currentbookmarks:
 updatebookmarks(repo, targetnode, nstate, currentbookmarks, tr)
-if activebookmark not in repo._bookmarks:
+if rbsrt.activebookmark not in repo._bookmarks:
 # active bookmark was divergent one and has been deleted
-activebookmark = None
+rbsrt.activebookmark = None
 clearstatus(repo)
 clearcollapsemsg(repo)
 ui.note(_("rebase completed\n"))
 util.unlinkpath(repo.sjoin('undo'), ignoremissing=True)
 if skipped:
 ui.note(_("%d revisions have been skipped\n") % len(skipped))
-if (activebookmark and
+if (rbsrt.activebookmark and
-repo['.'].node() == repo._bookmarks[activebookmark]):
+repo['.'].node() == repo._bookmarks[rbsrt.activebookmark]):
-bookmarks.activate(repo, activebookmark)
+bookmarks.activate(repo, rbsrt.activebookmark)
 finally:
 release(lock, wlock)
 def _definesets(ui, repo, destf=None, srcf=None, basef=None, revf=[],

changeset 29358	6e83f5bbed8d
parent 29205	a0939666b836
child 29359	d2168849539d