|
|
# rebase.py - rebasing feature for mercurial
|
|
|
#
|
|
|
# Copyright 2008 Stefano Tortarolo <stefano.tortarolo at gmail dot com>
|
|
|
#
|
|
|
# This software may be used and distributed according to the terms of the
|
|
|
# GNU General Public License version 2 or any later version.
|
|
|
|
|
|
'''command to move sets of revisions to a different ancestor
|
|
|
|
|
|
This extension lets you rebase changesets in an existing Mercurial
|
|
|
repository.
|
|
|
|
|
|
For more information:
|
|
|
http://mercurial.selenic.com/wiki/RebaseExtension
|
|
|
'''
|
|
|
|
|
|
from mercurial import hg, util, repair, merge, cmdutil, commands, bookmarks
|
|
|
from mercurial import extensions, patch, scmutil, phases, obsolete, error
|
|
|
from mercurial.commands import templateopts
|
|
|
from mercurial.node import nullrev
|
|
|
from mercurial.lock import release
|
|
|
from mercurial.i18n import _
|
|
|
import os, errno
|
|
|
|
|
|
nullmerge = -2
|
|
|
revignored = -3
|
|
|
|
|
|
cmdtable = {}
|
|
|
command = cmdutil.command(cmdtable)
|
|
|
testedwith = 'internal'
|
|
|
|
|
|
@command('rebase',
|
|
|
[('s', 'source', '',
|
|
|
_('rebase from the specified changeset'), _('REV')),
|
|
|
('b', 'base', '',
|
|
|
_('rebase from the base of the specified changeset '
|
|
|
'(up to greatest common ancestor of base and dest)'),
|
|
|
_('REV')),
|
|
|
('r', 'rev', [],
|
|
|
_('rebase these revisions'),
|
|
|
_('REV')),
|
|
|
('d', 'dest', '',
|
|
|
_('rebase onto the specified changeset'), _('REV')),
|
|
|
('', 'collapse', False, _('collapse the rebased changesets')),
|
|
|
('m', 'message', '',
|
|
|
_('use text as collapse commit message'), _('TEXT')),
|
|
|
('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, _('(DEPRECATED)')),
|
|
|
('t', 'tool', '', _('specify merge tool')),
|
|
|
('c', 'continue', False, _('continue an interrupted rebase')),
|
|
|
('a', 'abort', False, _('abort an interrupted rebase'))] +
|
|
|
templateopts,
|
|
|
_('[-s REV | -b REV] [-d REV] [OPTION]'))
|
|
|
def rebase(ui, repo, **opts):
|
|
|
"""move changeset (and descendants) to a different branch
|
|
|
|
|
|
Rebase uses repeated merging to graft changesets from one part of
|
|
|
history (the source) onto another (the destination). This can be
|
|
|
useful for linearizing *local* changes relative to a master
|
|
|
development tree.
|
|
|
|
|
|
You should not rebase changesets that have already been shared
|
|
|
with others. Doing so will force everybody else to perform the
|
|
|
same rebase or they will end up with duplicated changesets after
|
|
|
pulling in your rebased changesets.
|
|
|
|
|
|
In its default configuration, Mercurial will prevent you from
|
|
|
rebasing published changes. See :hg:`help phases` for details.
|
|
|
|
|
|
If you don't specify a destination changeset (``-d/--dest``),
|
|
|
rebase uses the current branch tip as the destination. (The
|
|
|
destination changeset is not modified by rebasing, but new
|
|
|
changesets are added as its descendants.)
|
|
|
|
|
|
You can specify which changesets to rebase in two ways: as a
|
|
|
"source" changeset or as a "base" changeset. Both are shorthand
|
|
|
for a topologically related set of changesets (the "source
|
|
|
branch"). If you specify source (``-s/--source``), rebase will
|
|
|
rebase that changeset and all of its descendants onto dest. If you
|
|
|
specify base (``-b/--base``), rebase will select ancestors of base
|
|
|
back to but not including the common ancestor with dest. Thus,
|
|
|
``-b`` is less precise but more convenient than ``-s``: you can
|
|
|
specify any changeset in the source branch, and rebase will select
|
|
|
the whole branch. If you specify neither ``-s`` nor ``-b``, rebase
|
|
|
uses the parent of the working directory as the base.
|
|
|
|
|
|
For advanced usage, a third way is available through the ``--rev``
|
|
|
option. It allows you to specify an arbitrary set of changesets to
|
|
|
rebase. Descendants of revs you specify with this option are not
|
|
|
automatically included in the rebase.
|
|
|
|
|
|
By default, rebase recreates the changesets in the source branch
|
|
|
as descendants of dest and then destroys the originals. Use
|
|
|
``--keep`` to preserve the original source changesets. Some
|
|
|
changesets in the source branch (e.g. merges from the destination
|
|
|
branch) may be dropped if they no longer contribute any change.
|
|
|
|
|
|
One result of the rules for selecting the destination changeset
|
|
|
and source branch is that, unlike ``merge``, rebase will do
|
|
|
nothing if you are at the branch tip of a named branch
|
|
|
with two heads. You need to explicitly specify source and/or
|
|
|
destination (or ``update`` to the other head, if it's the head of
|
|
|
the intended source branch).
|
|
|
|
|
|
If a rebase is interrupted to manually resolve a merge, it can be
|
|
|
continued with --continue/-c or aborted with --abort/-a.
|
|
|
|
|
|
Returns 0 on success, 1 if nothing to rebase.
|
|
|
"""
|
|
|
originalwd = target = None
|
|
|
activebookmark = None
|
|
|
external = nullrev
|
|
|
state = {}
|
|
|
skipped = set()
|
|
|
targetancestors = set()
|
|
|
|
|
|
editor = None
|
|
|
if opts.get('edit'):
|
|
|
editor = cmdutil.commitforceeditor
|
|
|
|
|
|
lock = wlock = None
|
|
|
try:
|
|
|
wlock = repo.wlock()
|
|
|
lock = repo.lock()
|
|
|
|
|
|
# Validate input and define rebasing points
|
|
|
destf = opts.get('dest', None)
|
|
|
srcf = opts.get('source', None)
|
|
|
basef = opts.get('base', None)
|
|
|
revf = opts.get('rev', [])
|
|
|
contf = opts.get('continue')
|
|
|
abortf = opts.get('abort')
|
|
|
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)
|
|
|
# keepopen is not meant for use on the command line, but by
|
|
|
# other extensions
|
|
|
keepopen = opts.get('keepopen', False)
|
|
|
|
|
|
if collapsemsg and not collapsef:
|
|
|
raise util.Abort(
|
|
|
_('message can only be specified with collapse'))
|
|
|
|
|
|
if contf or abortf:
|
|
|
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 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'))
|
|
|
|
|
|
try:
|
|
|
(originalwd, target, state, skipped, collapsef, keepf,
|
|
|
keepbranchesf, external, activebookmark) = restorestatus(repo)
|
|
|
except error.RepoLookupError:
|
|
|
if abortf:
|
|
|
clearstatus(repo)
|
|
|
repo.ui.warn(_('rebase aborted (no revision is removed,'
|
|
|
' only broken state is cleared)\n'))
|
|
|
return 0
|
|
|
else:
|
|
|
msg = _('cannot continue inconsistent rebase')
|
|
|
hint = _('use "hg rebase --abort" to clear borken state')
|
|
|
raise util.Abort(msg, hint=hint)
|
|
|
if abortf:
|
|
|
return abort(repo, originalwd, target, state)
|
|
|
else:
|
|
|
if srcf and basef:
|
|
|
raise util.Abort(_('cannot specify both a '
|
|
|
'source and a base'))
|
|
|
if revf and basef:
|
|
|
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'))
|
|
|
|
|
|
cmdutil.checkunfinished(repo)
|
|
|
cmdutil.bailifchanged(repo)
|
|
|
|
|
|
if not destf:
|
|
|
# Destination defaults to the latest revision in the
|
|
|
# current branch
|
|
|
branch = repo[None].branch()
|
|
|
dest = repo[branch]
|
|
|
else:
|
|
|
dest = scmutil.revsingle(repo, destf)
|
|
|
|
|
|
if revf:
|
|
|
rebaseset = scmutil.revrange(repo, revf)
|
|
|
elif srcf:
|
|
|
src = scmutil.revrange(repo, [srcf])
|
|
|
rebaseset = repo.revs('(%ld)::', src)
|
|
|
else:
|
|
|
base = scmutil.revrange(repo, [basef or '.'])
|
|
|
rebaseset = repo.revs(
|
|
|
'(children(ancestor(%ld, %d)) and ::(%ld))::',
|
|
|
base, dest, base)
|
|
|
if rebaseset:
|
|
|
root = min(rebaseset)
|
|
|
else:
|
|
|
root = None
|
|
|
|
|
|
if not rebaseset:
|
|
|
repo.ui.debug('base is ancestor of destination\n')
|
|
|
result = None
|
|
|
elif (not (keepf or obsolete._enabled)
|
|
|
and repo.revs('first(children(%ld) - %ld)',
|
|
|
rebaseset, rebaseset)):
|
|
|
raise util.Abort(
|
|
|
_("can't remove original changesets with"
|
|
|
" unrebased descendants"),
|
|
|
hint=_('use --keep to keep original changesets'))
|
|
|
else:
|
|
|
result = buildstate(repo, dest, rebaseset, collapsef)
|
|
|
|
|
|
if not result:
|
|
|
# Empty state built, nothing to rebase
|
|
|
ui.status(_('nothing to rebase\n'))
|
|
|
return 1
|
|
|
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:
|
|
|
originalwd, target, state = result
|
|
|
if collapsef:
|
|
|
targetancestors = repo.changelog.ancestors([target],
|
|
|
inclusive=True)
|
|
|
external = checkexternal(repo, state, targetancestors)
|
|
|
|
|
|
if keepbranchesf:
|
|
|
assert not extrafn, 'cannot use both keepbranches and extrafn'
|
|
|
def extrafn(ctx, extra):
|
|
|
extra['branch'] = ctx.branch()
|
|
|
if collapsef:
|
|
|
branches = set()
|
|
|
for rev in state:
|
|
|
branches.add(repo[rev].branch())
|
|
|
if len(branches) > 1:
|
|
|
raise util.Abort(_('cannot collapse multiple named '
|
|
|
'branches'))
|
|
|
|
|
|
|
|
|
# Rebase
|
|
|
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._bookmarkcurrent
|
|
|
if activebookmark:
|
|
|
bookmarks.unsetcurrent(repo)
|
|
|
|
|
|
sortedstate = sorted(state)
|
|
|
total = len(sortedstate)
|
|
|
pos = 0
|
|
|
for rev in sortedstate:
|
|
|
pos += 1
|
|
|
if state[rev] == -1:
|
|
|
ui.progress(_("rebasing"), pos, ("%d:%s" % (rev, repo[rev])),
|
|
|
_('changesets'), total)
|
|
|
p1, p2 = defineparents(repo, rev, target, state,
|
|
|
targetancestors)
|
|
|
storestatus(repo, originalwd, target, state, collapsef, keepf,
|
|
|
keepbranchesf, external, activebookmark)
|
|
|
if len(repo.parents()) == 2:
|
|
|
repo.ui.debug('resuming interrupted rebase\n')
|
|
|
else:
|
|
|
try:
|
|
|
ui.setconfig('ui', 'forcemerge', opts.get('tool', ''))
|
|
|
stats = rebasenode(repo, rev, p1, state, collapsef)
|
|
|
if stats and stats[3] > 0:
|
|
|
raise error.InterventionRequired(
|
|
|
_('unresolved conflicts (see hg '
|
|
|
'resolve, then hg rebase --continue)'))
|
|
|
finally:
|
|
|
ui.setconfig('ui', 'forcemerge', '')
|
|
|
cmdutil.duplicatecopies(repo, rev, target)
|
|
|
if not collapsef:
|
|
|
newrev = concludenode(repo, rev, p1, p2, extrafn=extrafn,
|
|
|
editor=editor)
|
|
|
else:
|
|
|
# Skip commit if we are collapsing
|
|
|
repo.setparents(repo[p1].node())
|
|
|
newrev = None
|
|
|
# Update the state
|
|
|
if newrev is not None:
|
|
|
state[rev] = repo[newrev].rev()
|
|
|
else:
|
|
|
if not collapsef:
|
|
|
ui.note(_('no changes, revision %d skipped\n') % rev)
|
|
|
ui.debug('next revision set to %s\n' % p1)
|
|
|
skipped.add(rev)
|
|
|
state[rev] = p1
|
|
|
|
|
|
ui.progress(_('rebasing'), None)
|
|
|
ui.note(_('rebase merging completed\n'))
|
|
|
|
|
|
if collapsef and not keepopen:
|
|
|
p1, p2 = defineparents(repo, min(state), target,
|
|
|
state, targetancestors)
|
|
|
if collapsemsg:
|
|
|
commitmsg = collapsemsg
|
|
|
else:
|
|
|
commitmsg = 'Collapsed revision'
|
|
|
for rebased in state:
|
|
|
if rebased not in skipped and state[rebased] > nullmerge:
|
|
|
commitmsg += '\n* %s' % repo[rebased].description()
|
|
|
commitmsg = ui.edit(commitmsg, repo.ui.username())
|
|
|
newrev = concludenode(repo, rev, p1, external, commitmsg=commitmsg,
|
|
|
extrafn=extrafn, editor=editor)
|
|
|
|
|
|
if 'qtip' in repo.tags():
|
|
|
updatemq(repo, state, skipped, **opts)
|
|
|
|
|
|
if currentbookmarks:
|
|
|
# Nodeids are needed to reset bookmarks
|
|
|
nstate = {}
|
|
|
for k, v in 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()
|
|
|
|
|
|
if not keepf:
|
|
|
collapsedas = None
|
|
|
if collapsef:
|
|
|
collapsedas = newrev
|
|
|
clearrebased(ui, repo, state, skipped, collapsedas)
|
|
|
|
|
|
if currentbookmarks:
|
|
|
updatebookmarks(repo, targetnode, nstate, currentbookmarks)
|
|
|
|
|
|
clearstatus(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
|
|
|
repo['tip'].node() == repo._bookmarks[activebookmark]):
|
|
|
bookmarks.setcurrent(repo, activebookmark)
|
|
|
|
|
|
finally:
|
|
|
release(lock, wlock)
|
|
|
|
|
|
def checkexternal(repo, state, targetancestors):
|
|
|
"""Check whether one or more external revisions need to be taken in
|
|
|
consideration. In the latter case, abort.
|
|
|
"""
|
|
|
external = nullrev
|
|
|
source = min(state)
|
|
|
for rev in state:
|
|
|
if rev == source:
|
|
|
continue
|
|
|
# Check externals and fail if there are more than one
|
|
|
for p in repo[rev].parents():
|
|
|
if (p.rev() not in state
|
|
|
and p.rev() not in targetancestors):
|
|
|
if external != nullrev:
|
|
|
raise util.Abort(_('unable to collapse, there is more '
|
|
|
'than one external parent'))
|
|
|
external = p.rev()
|
|
|
return external
|
|
|
|
|
|
def concludenode(repo, rev, p1, p2, commitmsg=None, editor=None, extrafn=None):
|
|
|
'Commit the changes and store useful information in extra'
|
|
|
try:
|
|
|
repo.setparents(repo[p1].node(), repo[p2].node())
|
|
|
ctx = repo[rev]
|
|
|
if commitmsg is None:
|
|
|
commitmsg = ctx.description()
|
|
|
extra = {'rebase_source': ctx.hex()}
|
|
|
if extrafn:
|
|
|
extrafn(ctx, extra)
|
|
|
# Commit might fail if unresolved files exist
|
|
|
newrev = repo.commit(text=commitmsg, user=ctx.user(),
|
|
|
date=ctx.date(), extra=extra, editor=editor)
|
|
|
repo.dirstate.setbranch(repo[newrev].branch())
|
|
|
targetphase = max(ctx.phase(), phases.draft)
|
|
|
# retractboundary doesn't overwrite upper phase inherited from parent
|
|
|
newnode = repo[newrev].node()
|
|
|
if newnode:
|
|
|
phases.retractboundary(repo, targetphase, [newnode])
|
|
|
return newrev
|
|
|
except util.Abort:
|
|
|
# Invalidate the previous setparents
|
|
|
repo.dirstate.invalidate()
|
|
|
raise
|
|
|
|
|
|
def rebasenode(repo, rev, p1, state, collapse):
|
|
|
'Rebase a single revision'
|
|
|
# Merge phase
|
|
|
# Update to target and merge it with local
|
|
|
if repo['.'].rev() != repo[p1].rev():
|
|
|
repo.ui.debug(" update to %d:%s\n" % (repo[p1].rev(), repo[p1]))
|
|
|
merge.update(repo, p1, False, True, False)
|
|
|
else:
|
|
|
repo.ui.debug(" already in target\n")
|
|
|
repo.dirstate.write()
|
|
|
repo.ui.debug(" merge against %d:%s\n" % (repo[rev].rev(), repo[rev]))
|
|
|
base = None
|
|
|
if repo[rev].rev() != repo[min(state)].rev():
|
|
|
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
|
|
|
|
|
|
P1n = parents[0].rev()
|
|
|
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
|
|
|
|
|
|
if len(parents) == 2 and parents[1].rev() not in targetancestors:
|
|
|
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 '
|
|
|
'would have 3 parents') % rev)
|
|
|
p2 = P2n
|
|
|
repo.ui.debug(" future parents are %d and %d\n" %
|
|
|
(repo[p1].rev(), repo[p2].rev()))
|
|
|
return p1, p2
|
|
|
|
|
|
def isagitpatch(repo, patchname):
|
|
|
'Return true if the given patch is in git format'
|
|
|
mqpatch = os.path.join(repo.mq.path, patchname)
|
|
|
for line in patch.linereader(file(mqpatch, 'rb')):
|
|
|
if line.startswith('diff --git'):
|
|
|
return True
|
|
|
return False
|
|
|
|
|
|
def updatemq(repo, state, skipped, **opts):
|
|
|
'Update rebased mq patches - finalize and then import them'
|
|
|
mqrebase = {}
|
|
|
mq = repo.mq
|
|
|
original_series = mq.fullseries[:]
|
|
|
skippedpatches = set()
|
|
|
|
|
|
for p in mq.applied:
|
|
|
rev = repo[p.node].rev()
|
|
|
if rev in state:
|
|
|
repo.ui.debug('revision %d is an mq patch (%s), finalize it.\n' %
|
|
|
(rev, p.name))
|
|
|
mqrebase[rev] = (p.name, isagitpatch(repo, p.name))
|
|
|
else:
|
|
|
# Applied but not rebased, not sure this should happen
|
|
|
skippedpatches.add(p.name)
|
|
|
|
|
|
if mqrebase:
|
|
|
mq.finish(repo, mqrebase.keys())
|
|
|
|
|
|
# We must start import from the newest revision
|
|
|
for rev in sorted(mqrebase, reverse=True):
|
|
|
if rev not in skipped:
|
|
|
name, isgit = mqrebase[rev]
|
|
|
repo.ui.debug('import mq patch %d (%s)\n' % (state[rev], name))
|
|
|
mq.qimport(repo, (), patchname=name, git=isgit,
|
|
|
rev=[str(state[rev])])
|
|
|
else:
|
|
|
# Rebased and skipped
|
|
|
skippedpatches.add(mqrebase[rev][0])
|
|
|
|
|
|
# Patches were either applied and rebased and imported in
|
|
|
# order, applied and removed or unapplied. Discard the removed
|
|
|
# ones while preserving the original series order and guards.
|
|
|
newseries = [s for s in original_series
|
|
|
if mq.guard_re.split(s, 1)[0] not in skippedpatches]
|
|
|
mq.fullseries[:] = newseries
|
|
|
mq.seriesdirty = True
|
|
|
mq.savedirty()
|
|
|
|
|
|
def updatebookmarks(repo, targetnode, nstate, originalbookmarks):
|
|
|
'Move bookmarks to their correct changesets, and delete divergent ones'
|
|
|
marks = repo._bookmarks
|
|
|
for k, v in originalbookmarks.iteritems():
|
|
|
if v in nstate:
|
|
|
# update the bookmarks for revs that have moved
|
|
|
marks[k] = nstate[v]
|
|
|
bookmarks.deletedivergent(repo, [targetnode], k)
|
|
|
|
|
|
marks.write()
|
|
|
|
|
|
def storestatus(repo, originalwd, target, state, collapse, keep, keepbranches,
|
|
|
external, activebookmark):
|
|
|
'Store the current status to allow recovery'
|
|
|
f = repo.opener("rebasestate", "w")
|
|
|
f.write(repo[originalwd].hex() + '\n')
|
|
|
f.write(repo[target].hex() + '\n')
|
|
|
f.write(repo[external].hex() + '\n')
|
|
|
f.write('%d\n' % int(collapse))
|
|
|
f.write('%d\n' % int(keep))
|
|
|
f.write('%d\n' % int(keepbranches))
|
|
|
f.write('%s\n' % (activebookmark or ''))
|
|
|
for d, v in state.iteritems():
|
|
|
oldrev = repo[d].hex()
|
|
|
if v > nullmerge:
|
|
|
newrev = repo[v].hex()
|
|
|
else:
|
|
|
newrev = v
|
|
|
f.write("%s:%s\n" % (oldrev, newrev))
|
|
|
f.close()
|
|
|
repo.ui.debug('rebase status stored\n')
|
|
|
|
|
|
def clearstatus(repo):
|
|
|
'Remove the status files'
|
|
|
util.unlinkpath(repo.join("rebasestate"), ignoremissing=True)
|
|
|
|
|
|
def restorestatus(repo):
|
|
|
'Restore a previously stored status'
|
|
|
try:
|
|
|
target = None
|
|
|
collapse = False
|
|
|
external = nullrev
|
|
|
activebookmark = None
|
|
|
state = {}
|
|
|
f = repo.opener("rebasestate")
|
|
|
for i, l in enumerate(f.read().splitlines()):
|
|
|
if i == 0:
|
|
|
originalwd = repo[l].rev()
|
|
|
elif i == 1:
|
|
|
target = repo[l].rev()
|
|
|
elif i == 2:
|
|
|
external = repo[l].rev()
|
|
|
elif i == 3:
|
|
|
collapse = bool(int(l))
|
|
|
elif i == 4:
|
|
|
keep = bool(int(l))
|
|
|
elif i == 5:
|
|
|
keepbranches = bool(int(l))
|
|
|
elif i == 6 and not (len(l) == 81 and ':' in l):
|
|
|
# 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(':')
|
|
|
if newrev in (str(nullmerge), str(revignored)):
|
|
|
state[repo[oldrev].rev()] = int(newrev)
|
|
|
else:
|
|
|
state[repo[oldrev].rev()] = repo[newrev].rev()
|
|
|
skipped = set()
|
|
|
# recompute the set of skipped revs
|
|
|
if not collapse:
|
|
|
seen = set([target])
|
|
|
for old, new in sorted(state.items()):
|
|
|
if new != nullrev and new in seen:
|
|
|
skipped.add(old)
|
|
|
seen.add(new)
|
|
|
repo.ui.debug('computed skipped revs: %s\n' % skipped)
|
|
|
repo.ui.debug('rebase status resumed\n')
|
|
|
return (originalwd, target, state, skipped,
|
|
|
collapse, keep, keepbranches, external, activebookmark)
|
|
|
except IOError, err:
|
|
|
if err.errno != errno.ENOENT:
|
|
|
raise
|
|
|
raise util.Abort(_('no rebase in progress'))
|
|
|
|
|
|
def inrebase(repo, originalwd, state):
|
|
|
'''check whether the workdir is in an interrupted rebase'''
|
|
|
parents = [p.rev() for p in repo.parents()]
|
|
|
if originalwd in parents:
|
|
|
return True
|
|
|
|
|
|
for newrev in state.itervalues():
|
|
|
if newrev in parents:
|
|
|
return True
|
|
|
|
|
|
return False
|
|
|
|
|
|
def abort(repo, originalwd, target, state):
|
|
|
'Restore the repository to its original state'
|
|
|
dstates = [s for s in state.values() if s != nullrev]
|
|
|
immutable = [d for d in dstates if not repo[d].mutable()]
|
|
|
cleanup = True
|
|
|
if immutable:
|
|
|
repo.ui.warn(_("warning: can't clean up immutable changesets %s\n")
|
|
|
% ', '.join(str(repo[r]) for r in immutable),
|
|
|
hint=_('see hg help phases for details'))
|
|
|
cleanup = False
|
|
|
|
|
|
descendants = set()
|
|
|
if dstates:
|
|
|
descendants = set(repo.changelog.descendants(dstates))
|
|
|
if descendants - set(dstates):
|
|
|
repo.ui.warn(_("warning: new changesets detected on target branch, "
|
|
|
"can't strip\n"))
|
|
|
cleanup = False
|
|
|
|
|
|
if cleanup:
|
|
|
# Update away from the rebase if necessary
|
|
|
if inrebase(repo, originalwd, state):
|
|
|
merge.update(repo, repo[originalwd].rev(), False, True, False)
|
|
|
|
|
|
# Strip from the first rebased revision
|
|
|
rebased = filter(lambda x: x > -1 and x != target, state.values())
|
|
|
if rebased:
|
|
|
strippoints = [c.node() for c in repo.set('roots(%ld)', rebased)]
|
|
|
# no backup of rebased cset versions needed
|
|
|
repair.strip(repo.ui, repo, strippoints)
|
|
|
|
|
|
clearstatus(repo)
|
|
|
repo.ui.warn(_('rebase aborted\n'))
|
|
|
return 0
|
|
|
|
|
|
def buildstate(repo, dest, rebaseset, collapse):
|
|
|
'''Define which revisions are going to be rebased and where
|
|
|
|
|
|
repo: repo
|
|
|
dest: context
|
|
|
rebaseset: set of rev
|
|
|
'''
|
|
|
|
|
|
# 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'))
|
|
|
|
|
|
roots = list(repo.set('roots(%ld)', rebaseset))
|
|
|
if not roots:
|
|
|
raise util.Abort(_('no matching revisions'))
|
|
|
roots.sort()
|
|
|
state = {}
|
|
|
detachset = set()
|
|
|
for root in roots:
|
|
|
commonbase = root.ancestor(dest)
|
|
|
if commonbase == root:
|
|
|
raise util.Abort(_('source is ancestor of destination'))
|
|
|
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
|
|
|
|
|
|
repo.ui.debug('rebase onto %d starting from %s\n' % (dest, roots))
|
|
|
state.update(dict.fromkeys(rebaseset, nullrev))
|
|
|
# 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 | new parent is <dest> | parents in ::<dest> are |
|
|
|
# | ::<dest> | | remapped to <dest> |
|
|
|
# +------------------+----------------------+-------------------------+
|
|
|
# | unrelated source | new parent is <dest> | ambiguous, abort |
|
|
|
# +------------------+----------------------+-------------------------+
|
|
|
#
|
|
|
# The actual abort is handled by `defineparents`
|
|
|
if len(root.parents()) <= 1:
|
|
|
# ancestors of <root> not ancestors of <dest>
|
|
|
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 `defineparents` should search
|
|
|
# a rebase destination that make sense regarding rebased 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
|
|
|
|
|
|
If `collapsedas` is not None, the rebase was a collapse whose result if the
|
|
|
`collapsedas` node."""
|
|
|
if obsolete._enabled:
|
|
|
markers = []
|
|
|
for rev, newrev in sorted(state.items()):
|
|
|
if newrev >= 0:
|
|
|
if rev in skipped:
|
|
|
succs = ()
|
|
|
elif collapsedas is not None:
|
|
|
succs = (repo[collapsedas],)
|
|
|
else:
|
|
|
succs = (repo[newrev],)
|
|
|
markers.append((repo[rev], succs))
|
|
|
if markers:
|
|
|
obsolete.createmarkers(repo, markers)
|
|
|
else:
|
|
|
rebased = [rev for rev in state if state[rev] > nullmerge]
|
|
|
if rebased:
|
|
|
stripped = []
|
|
|
for root in repo.set('roots(%ld)', rebased):
|
|
|
if set(repo.changelog.descendants([root.rev()])) - set(state):
|
|
|
ui.warn(_("warning: new changesets detected "
|
|
|
"on source branch, not stripping\n"))
|
|
|
else:
|
|
|
stripped.append(root.node())
|
|
|
if stripped:
|
|
|
# backup the old csets by default
|
|
|
repair.strip(ui, repo, stripped, "all")
|
|
|
|
|
|
|
|
|
def pullrebase(orig, ui, repo, *args, **opts):
|
|
|
'Call rebase after pull if the latter has been invoked with --rebase'
|
|
|
if opts.get('rebase'):
|
|
|
if opts.get('update'):
|
|
|
del opts['update']
|
|
|
ui.debug('--update and --rebase are not compatible, ignoring '
|
|
|
'the update flag\n')
|
|
|
|
|
|
movemarkfrom = repo['.'].node()
|
|
|
cmdutil.bailifchanged(repo)
|
|
|
revsprepull = len(repo)
|
|
|
origpostincoming = commands.postincoming
|
|
|
def _dummy(*args, **kwargs):
|
|
|
pass
|
|
|
commands.postincoming = _dummy
|
|
|
try:
|
|
|
orig(ui, repo, *args, **opts)
|
|
|
finally:
|
|
|
commands.postincoming = origpostincoming
|
|
|
revspostpull = len(repo)
|
|
|
if revspostpull > revsprepull:
|
|
|
# --rev option from pull conflict with rebase own --rev
|
|
|
# dropping it
|
|
|
if 'rev' in opts:
|
|
|
del opts['rev']
|
|
|
rebase(ui, repo, **opts)
|
|
|
branch = repo[None].branch()
|
|
|
dest = repo[branch].rev()
|
|
|
if dest != repo['.'].rev():
|
|
|
# there was nothing to rebase we force an update
|
|
|
hg.update(repo, dest)
|
|
|
if bookmarks.update(repo, [movemarkfrom], repo['.'].node()):
|
|
|
ui.status(_("updating bookmark %s\n")
|
|
|
% repo._bookmarkcurrent)
|
|
|
else:
|
|
|
if opts.get('tool'):
|
|
|
raise util.Abort(_('--tool can only be used with --rebase'))
|
|
|
orig(ui, repo, *args, **opts)
|
|
|
|
|
|
def summaryhook(ui, repo):
|
|
|
if not os.path.exists(repo.join('rebasestate')):
|
|
|
return
|
|
|
try:
|
|
|
state = restorestatus(repo)[2]
|
|
|
except error.RepoLookupError:
|
|
|
# i18n: column positioning for "hg summary"
|
|
|
msg = _('rebase: (use "hg rebase --abort" to clear broken state)\n')
|
|
|
ui.write(msg)
|
|
|
return
|
|
|
numrebased = len([i for i in state.itervalues() if i != -1])
|
|
|
# i18n: column positioning for "hg summary"
|
|
|
ui.write(_('rebase: %s, %s (rebase --continue)\n') %
|
|
|
(ui.label(_('%d rebased'), 'rebase.rebased') % numrebased,
|
|
|
ui.label(_('%d remaining'), 'rebase.remaining') %
|
|
|
(len(state) - numrebased)))
|
|
|
|
|
|
def uisetup(ui):
|
|
|
'Replace pull with a decorator to provide --rebase option'
|
|
|
entry = extensions.wrapcommand(commands.table, 'pull', pullrebase)
|
|
|
entry[1].append(('', 'rebase', None,
|
|
|
_("rebase working directory to branch head")))
|
|
|
entry[1].append(('t', 'tool', '',
|
|
|
_("specify merge tool for rebase")))
|
|
|
cmdutil.summaryhooks.add('rebase', summaryhook)
|
|
|
cmdutil.unfinishedstates.append(
|
|
|
['rebasestate', False, False, _('rebase in progress'),
|
|
|
_("use 'hg rebase --continue' or 'hg rebase --abort'")])
|
|
|
|
