mercurial: comparison hgext/rebase.py

equal deleted inserted replaced

-:ba9d5d48bf95
+:af609bb3487f
 import errno
 import os
 from mercurial.i18n import _
 from mercurial.node import (
-hex,
 nullid,
 nullrev,
 short,
 )
 from mercurial import (
 # The following constants are used throughout the rebase module. The ordering of
 # their values must be maintained.
 # Indicates that a revision needs to be rebased
 revtodo = -1
+revtodostr = '-1'
 # legacy revstates no longer needed in current code
 # -2: nullmerge, -3: revignored, -4: revprecursor, -5: revpruned
 legacystates = {'-2', '-3', '-4', '-5'}
 # 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
-self.dest = None
+self.destmap = {}
 self.skipped = set()
 self.collapsef = opts.get('collapse', False)
 self.collapsemsg = cmdutil.logmessage(ui, opts)
 self.date = opts.get('date', None)
 self._writestatus(f)
 def _writestatus(self, f):
 repo = self.repo.unfiltered()
 f.write(repo[self.originalwd].hex() + '\n')
-f.write(repo[self.dest].hex() + '\n')
+# was "dest". we now write dest per src root below.
+f.write('\n')
 f.write(repo[self.external].hex() + '\n')
 f.write('%d\n' % int(self.collapsef))
 f.write('%d\n' % int(self.keepf))
 f.write('%d\n' % int(self.keepbranchesf))
 f.write('%s\n' % (self.activebookmark or ''))
+destmap = self.destmap
 for d, v in self.state.iteritems():
 oldrev = repo[d].hex()
 if v >= 0:
 newrev = repo[v].hex()
-elif v == revtodo:
-# To maintain format compatibility, we have to use nullid.
-# Please do remove this special case when upgrading the format.
-newrev = hex(nullid)
 else:
 newrev = v
-f.write("%s:%s\n" % (oldrev, newrev))
+destnode = repo[destmap[d]].hex()
+f.write("%s:%s:%s\n" % (oldrev, newrev, destnode))
 repo.ui.debug('rebase status stored\n')
 def restorestatus(self):
 """Restore a previously stored status"""
 repo = self.repo
 keepbranches = None
-dest = None
+legacydest = None
 collapse = False
 external = nullrev
 activebookmark = None
 state = {}
+destmap = {}
 try:
 f = repo.vfs("rebasestate")
 for i, l in enumerate(f.read().splitlines()):
 if i == 0:
 originalwd = repo[l].rev()
 elif i == 1:
-dest = repo[l].rev()
+# this line should be empty in newer version. but legacy
+# clients may still use it
+if l:
+legacydest = repo[l].rev()
 elif i == 2:
 external = repo[l].rev()
 elif i == 3:
 collapse = bool(int(l))
 elif i == 4:
 # line 6 is a recent addition, so for backwards
 # compatibility check that the line doesn't look like the
 # oldrev:newrev lines
 activebookmark = l
 else:
-oldrev, newrev = l.split(':')
+args = l.split(':')
+oldrev = args[0]
+newrev = args[1]
 if newrev in legacystates:
 continue
-elif newrev == nullid:
+if len(args) > 2:
+destnode = args[2]
+else:
+destnode = legacydest
+destmap[repo[oldrev].rev()] = repo[destnode].rev()
+if newrev in (nullid, revtodostr):
 state[repo[oldrev].rev()] = revtodo
 # Legacy compat special case
 else:
 state[repo[oldrev].rev()] = repo[newrev].rev()
 raise error.Abort(_('.hg/rebasestate is incomplete'))
 skipped = set()
 # recompute the set of skipped revs
 if not collapse:
-seen = {dest}
+seen = set(destmap.values())
 for old, new in sorted(state.items()):
 if new != revtodo and new in seen:
 skipped.add(old)
 seen.add(new)
 repo.ui.debug('computed skipped revs: %s\n' %
 (' '.join(str(r) for r in sorted(skipped)) or None))
 repo.ui.debug('rebase status resumed\n')
 _setrebasesetvisibility(repo, set(state.keys()) | {originalwd})
 self.originalwd = originalwd
-self.dest = dest
+self.destmap = destmap
 self.state = state
 self.skipped = skipped
 self.collapsef = collapse
 self.keepf = keep
 self.keepbranchesf = keepbranches
 self.external = external
 self.activebookmark = activebookmark
-def _handleskippingobsolete(self, rebaserevs, obsoleterevs, dest):
+def _handleskippingobsolete(self, obsoleterevs, destmap):
 """Compute structures necessary for skipping obsolete revisions
-rebaserevs:     iterable of all revisions that are to be rebased
 obsoleterevs:   iterable of all obsolete revisions in rebaseset
-dest:           a destination revision for the rebase operation
+destmap:        {srcrev: destrev} destination revisions
 """
 self.obsoletenotrebased = {}
 if not self.ui.configbool('experimental', 'rebaseskipobsolete',
 default=True):
 return
 obsoleteset = set(obsoleterevs)
 self.obsoletenotrebased = _computeobsoletenotrebased(self.repo,
-obsoleteset, dest)
+obsoleteset, destmap)
 skippedset = set(self.obsoletenotrebased)
 _checkobsrebase(self.repo, self.ui, obsoleteset, skippedset)
 def _prepareabortorcontinue(self, isabort):
 try:
 else:
 msg = _('cannot continue inconsistent rebase')
 hint = _('use "hg rebase --abort" to clear broken state')
 raise error.Abort(msg, hint=hint)
 if isabort:
-return abort(self.repo, self.originalwd, self.dest,
+return abort(self.repo, self.originalwd, self.destmap,
 self.state, activebookmark=self.activebookmark)
-def _preparenewrebase(self, dest, rebaseset):
+def _preparenewrebase(self, destmap):
-if dest is None:
+if not destmap:
 return _nothingtorebase()
+rebaseset = destmap.keys()
 allowunstable = obsolete.isenabled(self.repo, obsolete.allowunstableopt)
 if (not (self.keepf or allowunstable)
 and self.repo.revs('first(children(%ld) - %ld)',
 rebaseset, rebaseset)):
 raise error.Abort(
 _("can't remove original changesets with"
 " unrebased descendants"),
 hint=_('use --keep to keep original changesets'))
-obsrevs = _filterobsoleterevs(self.repo, set(rebaseset))
+obsrevs = _filterobsoleterevs(self.repo, rebaseset)
-self._handleskippingobsolete(rebaseset, obsrevs, dest.rev())
+self._handleskippingobsolete(obsrevs, destmap)
-result = buildstate(self.repo, dest, rebaseset, self.collapsef,
+result = buildstate(self.repo, destmap, self.collapsef,
 self.obsoletenotrebased)
 if not result:
 # Empty state built, nothing to rebase
 self.ui.status(_('nothing to rebase\n'))
 if not self.keepf and not root.mutable():
 raise error.Abort(_("can't rebase public changeset %s")
 % root,
 hint=_("see 'hg help phases' for details"))
-(self.originalwd, self.dest, self.state) = result
+(self.originalwd, self.destmap, self.state) = result
 if self.collapsef:
-destancestors = self.repo.changelog.ancestors([self.dest],
+dests = set(self.destmap.values())
+if len(dests) != 1:
+raise error.Abort(
+_('--collapse does not work with multiple destinations'))
+destrev = next(iter(dests))
+destancestors = self.repo.changelog.ancestors([destrev],
 inclusive=True)
 self.external = externalparent(self.repo, self.state, destancestors)
-if dest.closesbranch() and not self.keepbranchesf:
+for destrev in sorted(set(destmap.values())):
-self.ui.status(_('reopening closed branch head %s\n') % dest)
+dest = self.repo[destrev]
+if dest.closesbranch() and not self.keepbranchesf:
+self.ui.status(_('reopening closed branch head %s\n') % dest)
 def _performrebase(self, tr):
 repo, ui, opts = self.repo, self.ui, self.opts
 if self.keepbranchesf:
 # insert _savebranch at the start of extrafns so if
 sortedrevs = repo.revs('sort(%ld, -topo)', self.state)
 cands = [k for k, v in self.state.iteritems() if v == revtodo]
 total = len(cands)
 pos = 0
 for rev in sortedrevs:
+dest = self.destmap[rev]
 ctx = repo[rev]
 desc = _ctxdesc(ctx)
 if self.state[rev] == rev:
 ui.status(_('already rebased %s\n') % desc)
 elif self.state[rev] == revtodo:
 pos += 1
 ui.status(_('rebasing %s\n') % desc)
 ui.progress(_("rebasing"), pos, ("%d:%s" % (rev, ctx)),
 _('changesets'), total)
-p1, p2, base = defineparents(repo, rev, self.dest, self.state)
+p1, p2, base = defineparents(repo, rev, self.destmap,
+self.state)
 self.storestatus(tr=tr)
 storecollapsemsg(repo, self.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, self.state,
-self.collapsef, self.dest)
+self.collapsef, dest)
 if stats and stats[3] > 0:
 raise error.InterventionRequired(
 _('unresolved conflicts (see hg '
 'resolve, then hg rebase --continue)'))
 finally:
 ui.note(_('rebase merging completed\n'))
 def _finishrebase(self):
 repo, ui, opts = self.repo, self.ui, self.opts
 if self.collapsef and not self.keepopen:
-p1, p2, _base = defineparents(repo, min(self.state),
+p1, p2, _base = defineparents(repo, min(self.state), self.destmap,
-self.dest, self.state)
+self.state)
 editopt = opts.get('edit')
 editform = 'rebase.collapse'
 if self.collapsemsg:
 commitmsg = self.collapsemsg
 else:
 if not self.keepf:
 collapsedas = None
 if self.collapsef:
 collapsedas = newnode
-clearrebased(ui, repo, self.dest, self.state, self.skipped,
+clearrebased(ui, repo, self.destmap, self.state, self.skipped,
 collapsedas)
 clearstatus(repo)
 clearcollapsemsg(repo)
 retcode = rbsrt._prepareabortorcontinue(abortf)
 if retcode is not None:
 return retcode
 else:
-dest, rebaseset = _definesets(ui, repo, destf, srcf, basef, revf,
+destmap = _definedestmap(ui, repo, destf, srcf, basef, revf,
 destspace=destspace)
-retcode = rbsrt._preparenewrebase(dest, rebaseset)
+retcode = rbsrt._preparenewrebase(destmap)
 if retcode is not None:
 return retcode
 tr = None
 dsguard = None
 with util.acceptintervention(dsguard):
 rbsrt._performrebase(tr)
 rbsrt._finishrebase()
-def _definesets(ui, repo, destf=None, srcf=None, basef=None, revf=None,
+def _definedestmap(ui, repo, destf=None, srcf=None, basef=None, revf=None,
 destspace=None):
-"""use revisions argument to define destination and rebase set
+"""use revisions argument to define destmap {srcrev: destrev}"""
-"""
 if revf is None:
 revf = []
 # destspace is here to work around issues with `hg pull --rebase` see
 # issue5214 for details
 if revf:
 rebaseset = scmutil.revrange(repo, revf)
 if not rebaseset:
 ui.status(_('empty "rev" revision set - nothing to rebase\n'))
-return None, None
+return None
 elif srcf:
 src = scmutil.revrange(repo, [srcf])
 if not src:
 ui.status(_('empty "source" revision set - nothing to rebase\n'))
-return None, None
+return None
 rebaseset = repo.revs('(%ld)::', src)
 assert rebaseset
 else:
 base = scmutil.revrange(repo, [basef or '.'])
 if not base:
 ui.status(_('empty "base" revision set - '
 "can't compute rebase set\n"))
-return None, None
+return None
 if not destf:
 dest = repo[_destrebase(repo, base, destspace=destspace)]
 destf = str(dest)
 roots = [] # selected children of branching points
 'directory parent is already an '
 'ancestor of destination %s\n') % dest)
 else: # can it happen?
 ui.status(_('nothing to rebase from %s to %s\n') %
 ('+'.join(str(repo[r]) for r in base), dest))
-return None, None
+return None
 if not destf:
 dest = repo[_destrebase(repo, rebaseset, destspace=destspace)]
 destf = str(dest)
-return dest, rebaseset
+# assign dest to each rev in rebaseset
+destrev = dest.rev()
+destmap = {r: destrev for r in rebaseset} # {srcrev: destrev}
+return destmap
 def externalparent(repo, state, destancestors):
 """Return the revision that should be used as the second parent
 when the revisions in state is collapsed on top of destancestors.
 Abort if there is more than one parent.
 # performed in the destination.
 p1rev = repo[rev].p1().rev()
 copies.duplicatecopies(repo, rev, p1rev, skiprev=dest)
 return stats
-def adjustdest(repo, rev, dest, state):
+def adjustdest(repo, rev, destmap, state):
 """adjust rebase destination given the current rebase state
 rev is what is being rebased. Return a list of two revs, which are the
 adjusted destinations for rev's p1 and p2, respectively. If a parent is
 nullrev, return dest without adjustment for it.
 | |/        |
 | B         | ...
 |/          |/
 A           A
 """
-# pick already rebased revs from state
+# pick already rebased revs with same dest from state as interesting source
-source = [s for s, d in state.items() if d > 0]
+dest = destmap[rev]
+source = [s for s, d in state.items() if d > 0 and destmap[s] == dest]
 result = []
 for prev in repo.changelog.parentrevs(rev):
 adjusted = dest
 if prev != nullrev:
 nodemap = unfi.changelog.nodemap
 for s in obsutil.allsuccessors(unfi.obsstore, [unfi[rev].node()]):
 if s in nodemap:
 yield nodemap[s]
-def defineparents(repo, rev, dest, state):
+def defineparents(repo, rev, destmap, state):
 """Return new parents and optionally a merge base for rev being rebased
 The destination specified by "dest" cannot always be used directly because
 previously rebase result could affect destination. For example,
 return True
 elif a > b:
 return False
 return cl.isancestor(cl.node(a), cl.node(b))
+dest = destmap[rev]
 oldps = repo.changelog.parentrevs(rev) # old parents
 newps = [nullrev, nullrev] # new parents
-dests = adjustdest(repo, rev, dest, state) # adjusted destinations
+dests = adjustdest(repo, rev, destmap, state) # adjusted destinations
 bases = list(oldps) # merge base candidates, initially just old parents
 if all(r == nullrev for r in oldps[1:]):
 # For non-merge changeset, just move p to adjusted dest as requested.
 newps[0] = dests[0]
 if firstunrebased in parents:
 return True
 return False
-def abort(repo, originalwd, dest, state, activebookmark=None):
+def abort(repo, originalwd, destmap, state, activebookmark=None):
 '''Restore the repository to its original state.  Additional args:
 activebookmark: the name of the bookmark that should be active after the
 restore'''
 try:
 # If the first commits in the rebased set get skipped during the rebase,
 # their values within the state mapping will be the dest rev id. The
 # dstates list must must not contain the dest rev (issue4896)
-dstates = [s for s in state.values() if s >= 0 and s != dest]
+dstates = [s for r, s in state.items() if s >= 0 and s != destmap[r]]
 immutable = [d for d in dstates if not repo[d].mutable()]
 cleanup = True
 if immutable:
 repo.ui.warn(_("warning: can't clean up public changesets %s\n")
 % ', '.join(str(repo[r]) for r in immutable),
 "branch, can't strip\n"))
 cleanup = False
 if cleanup:
 shouldupdate = False
-rebased = filter(lambda x: x >= 0 and x != dest, state.values())
+rebased = [s for r, s in state.items()
+if s >= 0 and s != destmap[r]]
 if rebased:
 strippoints = [
 c.node() for c in repo.set('roots(%ld)', rebased)]
 updateifonnodes = set(rebased)
-updateifonnodes.add(dest)
+updateifonnodes.update(destmap.values())
 updateifonnodes.add(originalwd)
 shouldupdate = repo['.'].rev() in updateifonnodes
 # Update away from the rebase if necessary
 if shouldupdate or needupdate(repo, state):
 clearstatus(repo)
 clearcollapsemsg(repo)
 repo.ui.warn(_('rebase aborted\n'))
 return 0
-def buildstate(repo, dest, rebaseset, collapse, obsoletenotrebased):
+def buildstate(repo, destmap, collapse, obsoletenotrebased):
 '''Define which revisions are going to be rebased and where
 repo: repo
-dest: context
+destmap: {srcrev: destrev}
-rebaseset: set of rev
 '''
+rebaseset = destmap.keys()
 originalwd = repo['.'].rev()
 _setrebasesetvisibility(repo, set(rebaseset) | {originalwd})
 # This check isn't strictly necessary, since mq detects commits over an
 # applied patch. But it prevents messing up the working directory when
 # a partially completed rebase is blocked by mq.
-if 'qtip' in repo.tags() and (dest.node() in
+if 'qtip' in repo.tags():
-[s.node for s in repo.mq.applied]):
+mqapplied = set(repo[s.node].rev() for s in repo.mq.applied)
-raise error.Abort(_('cannot rebase onto an applied mq patch'))
+if set(destmap.values()) & mqapplied:
+raise error.Abort(_('cannot rebase onto an applied mq patch'))
 roots = list(repo.set('roots(%ld)', rebaseset))
 if not roots:
 raise error.Abort(_('no matching revisions'))
 roots.sort()
 state = dict.fromkeys(rebaseset, revtodo)
 emptyrebase = True
 for root in roots:
+dest = repo[destmap[root.rev()]]
 commonbase = root.ancestor(dest)
 if commonbase == root:
 raise error.Abort(_('source is ancestor of destination'))
 if commonbase == dest:
 wctx = repo[None]
 desc = _ctxdesc(unfi[r])
 succ = obsoletenotrebased[r]
 if succ is None:
 msg = _('note: not rebasing %s, it has no successor\n') % desc
 del state[r]
+del destmap[r]
 else:
 destctx = unfi[succ]
 destdesc = '%d:%s "%s"' % (destctx.rev(), destctx,
 destctx.description().split('\n', 1)[0])
 msg = (_('note: not rebasing %s, already in destination as %s\n')
 % (desc, destdesc))
 del state[r]
+del destmap[r]
 repo.ui.status(msg)
-return originalwd, dest.rev(), state
+return originalwd, destmap, state
-def clearrebased(ui, repo, dest, state, skipped, collapsedas=None):
+def clearrebased(ui, repo, destmap, state, skipped, collapsedas=None):
 """dispose of rebased revision at the end of the rebase
 If `collapsedas` is not None, the rebase was a collapse whose result if the
 `collapsedas` node."""
 tonode = repo.changelog.node
 # Move bookmark of skipped nodes to destination. This cannot be handled
 # by scmutil.cleanupnodes since it will treat rev as removed (no successor)
 # and move bookmark backwards.
-bmchanges = [(name, tonode(max(adjustdest(repo, rev, dest, state))))
+bmchanges = [(name, tonode(max(adjustdest(repo, rev, destmap, state))))
 for rev in skipped
 for name in repo.nodebookmarks(tonode(rev))]
 if bmchanges:
 with repo.transaction('rebase') as tr:
 repo._bookmarks.applychanges(repo, tr, bmchanges)
 def _filterobsoleterevs(repo, revs):
 """returns a set of the obsolete revisions in revs"""
 return set(r for r in revs if repo[r].obsolete())
-def _computeobsoletenotrebased(repo, rebaseobsrevs, dest):
+def _computeobsoletenotrebased(repo, rebaseobsrevs, destmap):
 """return a mapping obsolete => successor for all obsolete nodes to be
 rebased that have a successors in the destination
 obsolete => None entries in the mapping indicate nodes with no successor"""
 obsoletenotrebased = {}
 cl = repo.unfiltered().changelog
 nodemap = cl.nodemap
-destnode = cl.node(dest)
 for srcrev in rebaseobsrevs:
 srcnode = cl.node(srcrev)
+destnode = cl.node(destmap[srcrev])
 # XXX: more advanced APIs are required to handle split correctly
 successors = list(obsutil.allsuccessors(repo.obsstore, [srcnode]))
 if len(successors) == 1:
 # obsutil.allsuccessors includes node itself. When the list only
 # contains one element, it means there are no successors.

changeset 34004	af609bb3487f
parent 34003	ba9d5d48bf95
child 34005	5e83a8fe6bc4