Mercurial: comparison hgext/rebase.py

equal deleted inserted replaced

-:a1d86396d8c1
+:50f434510da6
 ('e', 'edit', False, _('invoke editor on commit messages')),
 ('l', 'logfile', '',
 _('read collapse commit message from file'), _('FILE')),
 ('', 'keep', False, _('keep original changesets')),
 ('', 'keepbranches', False, _('keep original branch names')),
-('D', 'detach', False, _('force detaching of source from its original '
+('D', 'detach', False, _('(DEPRECATED)')),
-'branch')),
 ('t', 'tool', '', _('specify merge tool')),
 ('c', 'continue', False, _('continue an interrupted rebase')),
 ('a', 'abort', False, _('abort an interrupted rebase'))] +
 templateopts,
 _('hg rebase [-s REV | -b REV] [-d REV] [options]\n'
 collapsef = opts.get('collapse', False)
 collapsemsg = cmdutil.logmessage(ui, opts)
 extrafn = opts.get('extrafn') # internal, used by e.g. hgsubversion
 keepf = opts.get('keep', False)
 keepbranchesf = opts.get('keepbranches', False)
-detachf = opts.get('detach', False)
 # keepopen is not meant for use on the command line, but by
 # other extensions
 keepopen = opts.get('keepopen', False)
 if collapsemsg and not collapsef:
 if contf and abortf:
 raise util.Abort(_('cannot use both abort and continue'))
 if collapsef:
 raise util.Abort(
 _('cannot use collapse with continue or abort'))
-if detachf:
-raise util.Abort(_('cannot use detach with continue or abort'))
 if srcf or basef or destf:
 raise util.Abort(
 _('abort and continue do not allow specifying revisions'))
 if opts.get('tool', False):
 ui.warn(_('tool option will be ignored\n'))
 raise util.Abort(_('cannot specify both a '
 'revision and a base'))
 if revf and srcf:
 raise util.Abort(_('cannot specify both a '
 'revision and a source'))
-if detachf:
-if not (srcf or revf):
-raise util.Abort(
-_('detach requires a revision to be specified'))
-if basef:
-raise util.Abort(_('cannot specify a base with detach'))
 cmdutil.bailifchanged(repo)
 if not destf:
 # Destination defaults to the latest revision in the
 elif not keepf and not repo[root].mutable():
 raise util.Abort(_("can't rebase immutable changeset %s")
 % repo[root],
 hint=_('see hg help phases for details'))
 else:
-result = buildstate(repo, dest, rebaseset, detachf, collapsef)
+result = buildstate(repo, dest, rebaseset, collapsef)
 if not result:
 # Empty state built, nothing to rebase
 ui.status(_('nothing to rebase\n'))
 return 1
 repair.strip(repo.ui, repo, repo[strippoint].node())
 clearstatus(repo)
 repo.ui.warn(_('rebase aborted\n'))
 return 0
-def buildstate(repo, dest, rebaseset, detach, collapse):
+def buildstate(repo, dest, rebaseset, collapse):
 '''Define which revisions are going to be rebased and where
 repo: repo
 dest: context
 rebaseset: set of rev
-detach: boolean'''
+'''
 # 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
 [s.node for s in repo.mq.applied]):
 raise util.Abort(_('cannot rebase onto an applied mq patch'))
-detachset = set()
 roots = list(repo.set('roots(%ld)', rebaseset))
 if not roots:
 raise util.Abort(_('no matching revisions'))
 if len(roots) > 1:
 raise util.Abort(_("can't rebase multiple roots"))
 if commonbase == dest:
 samebranch = root.branch() == dest.branch()
 if not collapse and samebranch and root in dest.children():
 repo.ui.debug('source is a child of destination\n')
 return None
-# rebase on ancestor, force detach
-detach = True
-if detach:
-detachset = repo.revs('::%d - ::%d - %d', root, commonbase, root)
 repo.ui.debug('rebase onto %d starting from %d\n' % (dest, root))
 state = dict.fromkeys(rebaseset, nullrev)
-state.update(dict.fromkeys(detachset, nullmerge))
+# Rebase tries to turn <dest> into a parent of <root> while
+# preserving the number of parents of rebased changesets:
+#
+# - A changeset with a single parent will always be rebased as a
+#   changeset with a single parent.
+#
+# - A merge will be rebased as merge unless its parents are both
+#   ancestors of <dest> or are themselves in the rebased set and
+#   pruned while rebased.
+#
+# If one parent of <root> is an ancestor of <dest>, the rebased
+# version of this parent will be <dest>. This is always true with
+# --base option.
+#
+# Otherwise, we need to *replace* the original parents with
+# <dest>. This "detaches" the rebased set from its former location
+# and rebases it onto <dest>. Changes introduced by ancestors of
+# <root> not common with <dest> (the detachset, marked as
+# nullmerge) are "removed" from the rebased changesets.
+#
+# - If <root> has a single parent, set it to <dest>.
+#
+# - If <root> is a merge, we cannot decide which parent to
+#   replace, the rebase operation is not clearly defined.
+#
+# The table below sums up this behavior:
+#
+# +--------------------+----------------------+-------------------------+
+# |                    |     one parent       |  merge                  |
+# +--------------------+----------------------+-------------------------+
+# | parent in ::<dest> | new parent is <dest> | parents in ::<dest> are |
+# |                    |                      | remapped to <dest>      |
+# +--------------------+----------------------+-------------------------+
+# | unrelated source   | new parent is <dest> | ambiguous, abort        |
+# +--------------------+----------------------+-------------------------+
+#
+# The actual abort is handled by `defineparents`
+if len(root.parents()) <= 1:
+# (strict) ancestors of <root> not ancestors of <dest>
+detachset = repo.revs('::%d - ::%d - %d', root, commonbase, root)
+state.update(dict.fromkeys(detachset, nullmerge))
 return repo['.'].rev(), dest.rev(), state
 def pullrebase(orig, ui, repo, *args, **opts):
 'Call rebase after pull if the latter has been invoked with --rebase'
 if opts.get('rebase'):

changeset 17005	50f434510da6
parent 16867	1093ad1e8903
child 17028	efd2e14f7235