mercurial: comparison hgext/rebase.py

equal deleted inserted replaced

-:c83d36b81df1
+:7159426c8d13
 from mercurial.lock import release
 from mercurial.i18n import _
 import os, errno
 nullmerge = -2
+revignored = -3
 cmdtable = {}
 command = cmdutil.command(cmdtable)
 testedwith = 'internal'
 base = repo[rev].p1().node()
 # When collapsing in-place, the parent is the common ancestor, we
 # have to allow merging with it.
 return merge.update(repo, rev, True, True, False, base, collapse)
+def nearestrebased(repo, rev, state):
+"""return the nearest ancestors of rev in the rebase result"""
+rebased = [r for r in state if state[r] > nullmerge]
+candidates = repo.revs('max(%ld  and (::%d))', rebased, rev)
+if candidates:
+return state[candidates[0]]
+else:
+return None
 def defineparents(repo, rev, target, state, targetancestors):
 'Return the new parent relationship of the revision that will be rebased'
 parents = repo[rev].parents()
 p1 = p2 = nullrev
 if P1n in targetancestors:
 p1 = target
 elif P1n in state:
 if state[P1n] == nullmerge:
 p1 = target
+elif state[P1n] == revignored:
+p1 = nearestrebased(repo, P1n, state)
+if p1 is None:
+p1 = target
 else:
 p1 = state[P1n]
 else: # P1n external
 p1 = target
 p2 = P1n
 P2n = parents[1].rev()
 # interesting second parent
 if P2n in state:
 if p1 == target: # P1n in targetancestors or external
 p1 = state[P2n]
+elif state[P2n] == revignored:
+p2 = nearestrebased(repo, P2n, state)
+if p2 is None:
+# no ancestors rebased yet, detach
+p2 = target
 else:
 p2 = state[P2n]
 else: # P2n external
 if p2 != nullrev: # P1n external too => rev is a merged revision
 raise util.Abort(_('cannot use revision %d as base, result '
 keep = bool(int(l))
 elif i == 5:
 keepbranches = bool(int(l))
 else:
 oldrev, newrev = l.split(':')
-if newrev != str(nullmerge):
+if newrev in (str(nullmerge), str(revignored)):
+state[repo[oldrev].rev()] = int(newrev)
+else:
 state[repo[oldrev].rev()] = repo[newrev].rev()
-else:
-state[repo[oldrev].rev()] = int(newrev)
 skipped = set()
 # recompute the set of skipped revs
 if not collapse:
 seen = set([target])
 for old, new in sorted(state.items()):
 detachset.update(repo.changelog.findmissingrevs([commonbase.rev()],
 [root.rev()]))
 for r in detachset:
 if r not in state:
 state[r] = nullmerge
+if len(roots) > 1:
+# If we have multiple roots, we may have "hole" in the rebase set.
+# Rebase roots that descend from those "hole" should not be detached as
+# other root are. We use the special `revignored` to inform rebase that
+# the revision should be ignored but that `defineparent` should search
+# a rebase destination that make sense regarding rebaset topology.
+rebasedomain = set(repo.revs('%ld::%ld', rebaseset, rebaseset))
+for ignored in set(rebasedomain) - set(rebaseset):
+state[ignored] = revignored
 return repo['.'].rev(), dest.rev(), state
 def clearrebased(ui, repo, state, skipped, collapsedas=None):
 """dispose of rebased revision at the end of the rebase

changeset 18447	7159426c8d13
parent 18446	c83d36b81df1
child 18512	22978b82ab4b