def recordfunc(ui, repo, message, match, opts):
"""This is generic record driver.
Its job is to interactively filter local changes, and
accordingly prepare working directory into a state in which the
job can be delegated to a non-interactive commit command such as
'commit' or 'qrefresh'.
After the actual job is done by non-interactive command, the
working directory is restored to its original state.
In the end we'll record interesting changes, and everything else
will be left in place, so the user can continue working.
"""
cmdutil.checkunfinished(repo, commit=True)
merge = len(repo[None].parents()) > 1
if merge:
raise util.Abort(_("cannot partially commit a merge " '(use "hg commit" instead)'))
status = repo.status(match=match)
diffopts = opts.copy()
diffopts["nodates"] = True
diffopts["git"] = True
diffopts = patch.diffopts(ui, opts=diffopts)
chunks = patch.diff(repo, changes=status, opts=diffopts)
fp = cStringIO.StringIO()
fp.write("".join(chunks))
fp.seek(0)
# 1. filter patch, so we have intending-to apply subset of it
try:
chunks = filterpatch(ui, parsepatch(fp))
except patch.PatchError, err:
raise util.Abort(_("error parsing patch: %s") % err)
def createcmd(ui, repo, pats, opts):
"""subcommand that creates a new shelve"""
wlock = repo.wlock()
try:
cmdutil.checkunfinished(repo)
return _docreatecmd(ui, repo, pats, opts)
finally:
lockmod.release(wlock)
def checklocalchanges(repo, force=False, excsuffix=''):
cmdutil.checkunfinished(repo)
s = repo.status()
if not force:
if s.modified or s.added or s.removed or s.deleted:
_("local changes found") # i18n tool detection
raise util.Abort(_("local changes found" + excsuffix))
if checksubstate(repo):
_("local changed subrepos found") # i18n tool detection
raise util.Abort(_("local changed subrepos found" + excsuffix))
return s
def checklocalchanges(repo, force=False, excsuffix=''):
cmdutil.checkunfinished(repo)
m, a, r, d = repo.status()[:4]
if not force:
if (m or a or r or d):
_("local changes found") # i18n tool detection
raise util.Abort(_("local changes found" + excsuffix))
if checksubstate(repo):
_("local changed subrepos found") # i18n tool detection
raise util.Abort(_("local changed subrepos found" + excsuffix))
return m, a, r, d
def shelvecmd(ui, repo, *pats, **opts):
'''save and set aside changes from the working directory
Shelving takes files that "hg status" reports as not clean, saves
the modifications to a bundle (a shelved change), and reverts the
files so that their state in the working directory becomes clean.
To restore these changes to the working directory, using "hg
unshelve"; this will work even if you switch to a different
commit.
When no files are specified, "hg shelve" saves all not-clean
files. If specific files or directories are named, only changes to
those files are shelved.
Each shelved change has a name that makes it easier to find later.
The name of a shelved change defaults to being based on the active
bookmark, or if there is no active bookmark, the current named
branch. To specify a different name, use ``--name``.
To see a list of existing shelved changes, use the ``--list``
option. For each shelved change, this will print its name, age,
and description; use ``--patch`` or ``--stat`` for more details.
To delete specific shelved changes, use ``--delete``. To delete
all shelved changes, use ``--cleanup``.
'''
cmdutil.checkunfinished(repo)
def checkopt(opt, incompatible):
if opts[opt]:
for i in incompatible.split():
if opts[i]:
raise util.Abort(_("options '--%s' and '--%s' may not be "
"used together") % (opt, i))
return True
if checkopt('cleanup', 'addremove delete list message name patch stat'):
if pats:
raise util.Abort(_("cannot specify names when using '--cleanup'"))
return cleanupcmd(ui, repo)
elif checkopt('delete', 'addremove cleanup list message name patch stat'):
return deletecmd(ui, repo, pats)
elif checkopt('list', 'addremove cleanup delete message name'):
return listcmd(ui, repo, pats, opts)
else:
for i in ('patch', 'stat'):
if opts[i]:
raise util.Abort(_("option '--%s' may not be "
"used when shelving a change") % (i,))
return createcmd(ui, repo, pats, opts)
def unshelve(ui, repo, *shelved, **opts):
"""restore a shelved change to the working directory
This command accepts an optional name of a shelved change to
restore. If none is given, the most recent shelved change is used.
If a shelved change is applied successfully, the bundle that
contains the shelved changes is deleted afterwards.
Since you can restore a shelved change on top of an arbitrary
commit, it is possible that unshelving will result in a conflict
between your changes and the commits you are unshelving onto. If
this occurs, you must resolve the conflict, then use
``--continue`` to complete the unshelve operation. (The bundle
will not be deleted until you successfully complete the unshelve.)
(Alternatively, you can use ``--abort`` to abandon an unshelve
that causes a conflict. This reverts the unshelved changes, and
does not delete the bundle.)
"""
abortf = opts['abort']
continuef = opts['continue']
if not abortf and not continuef:
cmdutil.checkunfinished(repo)
if abortf or continuef:
if abortf and continuef:
raise util.Abort(_('cannot use both abort and continue'))
if shelved:
raise util.Abort(_('cannot combine abort/continue with '
'naming a shelved change'))
try:
state = shelvedstate.load(repo)
except IOError, err:
if err.errno != errno.ENOENT:
raise
raise util.Abort(_('no unshelve operation underway'))
if abortf:
return unshelveabort(ui, repo, state, opts)
elif continuef:
return unshelvecontinue(ui, repo, state, opts)
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 or there are
unresolved conflicts.
"""
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)
e = opts.get('extrafn') # internal, used by e.g. hgsubversion
extrafns = [_savegraft]
if e:
extrafns = [e]
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 = externalparent(repo, state, targetancestors)
if keepbranchesf:
# insert _savebranch at the start of extrafns so if
# there's a user-provided extrafn it can clobber branch if
# desired
extrafns.insert(0, _savebranch)
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)
extrafn = _makeextrafn(extrafns)
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)
for oldrev in state.iterkeys():
if state[oldrev] > nullmerge:
state[oldrev] = newrev
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()
# restore original working directory
# (we do this before stripping)
newwd = state.get(originalwd, 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 = 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['.'].node() == repo._bookmarks[activebookmark]):
bookmarks.setcurrent(repo, activebookmark)
finally:
release(lock, wlock)
def redo(ui, repo, *args, **opts):
""" perform a redo
Rolls back the previous undo.
"""
shiftedindex = _computerelative(repo, 0)
preview = opts.get("preview")
branch = ""
reverseindex = 0
redocount = 0
done = False
while not done:
# we step back the linear undo log
# redoes cancel out undoes, if we have one more undo, we should undo
# there, otherwise we continue looking
# we are careful to not redo past absolute undoes (bc we loose undoredo
# log info)
# if we run into something that isn't undo or redo, we Abort (including
# gaps in the log)
# we extract the --index arguments out of undoes to make sure we update
# the undoredo index correctly
nodedict = _readindex(repo, reverseindex)
commandstr = _readnode(repo, 'command.i', nodedict['command'])
commandlist = commandstr.split("\0")
if 'True' == nodedict['unfinished']:
# don't want to redo to an interupted state
reverseindex += 1
elif commandlist[0] == "undo":
undoopts = {}
fancyopts.fancyopts(commandlist,
cmdtable['undo'][1] + commands.globalopts,
undoopts, gnu=True)
if redocount == 0:
# want to go to state before the undo (not after)
toshift = undoopts['step']
shiftedindex -= toshift
reverseindex += 1
branch = undoopts.get('branch')
done = True
else:
if undoopts['absolute']:
raise error.Abort(_("can't redo past absolute undo"))
reverseindex += 1
redocount -= 1
elif commandlist[0] == "redo":
redocount += 1
reverseindex += 1
else:
raise error.Abort(_("nothing to redo"))
if preview:
_preview(ui, repo, reverseindex)
return
with repo.wlock(), repo.lock(), repo.transaction("redo"):
cmdutil.checkunfinished(repo)
cmdutil.bailifchanged(repo)
repo = repo.unfiltered()
_undoto(ui, repo, reverseindex)
# update undredo by removing what the given undo added
_logundoredoindex(repo, shiftedindex, branch)
def _dounshelve(ui, repo, *shelved, **opts):
abortf = opts.get('abort')
continuef = opts.get('continue')
if not abortf and not continuef:
cmdutil.checkunfinished(repo)
shelved = list(shelved)
if opts.get("name"):
shelved.append(opts["name"])
if abortf or continuef:
if abortf and continuef:
raise error.Abort(_('cannot use both abort and continue'))
if shelved:
raise error.Abort(_('cannot combine abort/continue with '
'naming a shelved change'))
if abortf and opts.get('tool', False):
ui.warn(_('tool option will be ignored\n'))
try:
state = shelvedstate.load(repo)
if opts.get('keep') is None:
opts['keep'] = state.keep
except IOError as err:
if err.errno != errno.ENOENT:
raise
cmdutil.wrongtooltocontinue(repo, _('unshelve'))
except error.CorruptedState as err:
ui.debug(str(err) + '\n')
if continuef:
msg = _('corrupted shelved state file')
hint = _('please run hg unshelve --abort to abort unshelve '
'operation')
raise error.Abort(msg, hint=hint)
elif abortf:
msg = _('could not read shelved state file, your working copy '
'may be in an unexpected state\nplease update to some '
'commit\n')
ui.warn(msg)
shelvedstate.clear(repo)
return
if abortf:
return unshelveabort(ui, repo, state, opts)
elif continuef:
return unshelvecontinue(ui, repo, state, opts)
elif len(shelved) > 1:
raise error.Abort(_('can only unshelve one change at a time'))
elif not shelved:
shelved = listshelves(repo)
if not shelved:
raise error.Abort(_('no shelved changes to apply!'))
basename = util.split(shelved[0][1])[1]
ui.status(_("unshelving change '%s'\n") % basename)
else:
basename = shelved[0]
if not shelvedfile(repo, basename, patchextension).exists():
raise error.Abort(_("shelved change '%s' not found") % basename)
lock = tr = None
obsshelve = True
obsshelvedfile = shelvedfile(repo, basename, 'oshelve')
if not obsshelvedfile.exists():
# although we can unshelve a obs-based shelve technically,
# this particular shelve was created using a traditional way
obsshelve = False
ui.note(_("falling back to traditional unshelve since "
"shelve was traditional"))
try:
lock = repo.lock()
tr = repo.transaction('unshelve', report=lambda x: None)
oldtiprev = len(repo)
pctx = repo['.']
tmpwctx = pctx
# The goal is to have a commit structure like so:
# ...-> pctx -> tmpwctx -> shelvectx
# where tmpwctx is an optional commit with the user's pending changes
# and shelvectx is the unshelved changes. Then we merge it all down
# to the original pctx.
activebookmark = _backupactivebookmark(repo)
tmpwctx, addedbefore = _commitworkingcopychanges(ui, repo, opts,
tmpwctx)
repo, shelvectx = _unshelverestorecommit(ui, repo, basename, obsshelve)
_checkunshelveuntrackedproblems(ui, repo, shelvectx)
branchtorestore = ''
if shelvectx.branch() != shelvectx.p1().branch():
branchtorestore = shelvectx.branch()
rebaseconfigoverrides = {('ui', 'forcemerge'): opts.get('tool', ''),
('experimental', 'rebaseskipobsolete'): 'off'}
with ui.configoverride(rebaseconfigoverrides, 'unshelve'):
shelvectx = _rebaserestoredcommit(ui, repo, opts, tr, oldtiprev,
basename, pctx, tmpwctx,
shelvectx, branchtorestore,
activebookmark, obsshelve)
mergefiles(ui, repo, pctx, shelvectx)
restorebranch(ui, repo, branchtorestore)
_forgetunknownfiles(repo, shelvectx, addedbefore)
if obsshelve:
_obsoleteredundantnodes(repo, tr, pctx, shelvectx, tmpwctx)
shelvedstate.clear(repo)
_finishunshelve(repo, oldtiprev, tr, activebookmark, obsshelve)
unshelvecleanup(ui, repo, basename, opts)
finally:
if tr:
tr.release()
lockmod.release(lock)
def _histedit(ui, repo, state, *freeargs, **opts):
# TODO only abort if we try and histedit mq patches, not just
# blanket if mq patches are applied somewhere
mq = getattr(repo, 'mq', None)
if mq and mq.applied:
raise util.Abort(_('source has mq patches applied'))
# basic argument incompatibility processing
outg = opts.get('outgoing')
cont = opts.get('continue')
editplan = opts.get('edit_plan')
abort = opts.get('abort')
force = opts.get('force')
rules = opts.get('commands', '')
revs = opts.get('rev', [])
goal = 'new' # This invocation goal, in new, continue, abort
if force and not outg:
raise util.Abort(_('--force only allowed with --outgoing'))
if cont:
if util.any((outg, abort, revs, freeargs, rules, editplan)):
raise util.Abort(_('no arguments allowed with --continue'))
goal = 'continue'
elif abort:
if util.any((outg, revs, freeargs, rules, editplan)):
raise util.Abort(_('no arguments allowed with --abort'))
goal = 'abort'
elif editplan:
if util.any((outg, revs, freeargs)):
raise util.Abort(_('only --commands argument allowed with '
'--edit-plan'))
goal = 'edit-plan'
else:
if os.path.exists(os.path.join(repo.path, 'histedit-state')):
raise util.Abort(_('history edit already in progress, try '
'--continue or --abort'))
if outg:
if revs:
raise util.Abort(_('no revisions allowed with --outgoing'))
if len(freeargs) > 1:
raise util.Abort(
_('only one repo argument allowed with --outgoing'))
else:
revs.extend(freeargs)
if len(revs) == 0:
histeditdefault = ui.config('histedit', 'defaultrev')
if histeditdefault:
revs.append(histeditdefault)
if len(revs) != 1:
raise util.Abort(
_('histedit requires exactly one ancestor revision'))
replacements = []
keep = opts.get('keep', False)
# rebuild state
if goal == 'continue':
state.read()
state = bootstrapcontinue(ui, state, opts)
elif goal == 'edit-plan':
state.read()
if not rules:
comment = editcomment % (state.parentctx, node.short(state.topmost))
rules = ruleeditor(repo, ui, state.rules, comment)
else:
if rules == '-':
f = sys.stdin
else:
f = open(rules)
rules = f.read()
f.close()
rules = [l for l in (r.strip() for r in rules.splitlines())
if l and not l.startswith('#')]
rules = verifyrules(rules, repo, [repo[c] for [_a, c] in state.rules])
state.rules = rules
state.write()
return
elif goal == 'abort':
state.read()
mapping, tmpnodes, leafs, _ntm = processreplacement(state)
ui.debug('restore wc to old parent %s\n' % node.short(state.topmost))
# Recover our old commits if necessary
if not state.topmost in repo and state.backupfile:
backupfile = repo.join(state.backupfile)
f = hg.openpath(ui, backupfile)
gen = exchange.readbundle(ui, f, backupfile)
changegroup.addchangegroup(repo, gen, 'histedit',
'bundle:' + backupfile)
os.remove(backupfile)
# check whether we should update away
parentnodes = [c.node() for c in repo[None].parents()]
for n in leafs | set([state.parentctxnode]):
if n in parentnodes:
hg.clean(repo, state.topmost)
break
else:
pass
cleanupnode(ui, repo, 'created', tmpnodes)
cleanupnode(ui, repo, 'temp', leafs)
state.clear()
return
else:
cmdutil.checkunfinished(repo)
cmdutil.bailifchanged(repo)
topmost, empty = repo.dirstate.parents()
if outg:
if freeargs:
remote = freeargs[0]
else:
remote = None
root = findoutgoing(ui, repo, remote, force, opts)
else:
rr = list(repo.set('roots(%ld)', scmutil.revrange(repo, revs)))
if len(rr) != 1:
raise util.Abort(_('The specified revisions must have '
'exactly one common root'))
root = rr[0].node()
revs = between(repo, root, topmost, keep)
if not revs:
raise util.Abort(_('%s is not an ancestor of working directory') %
node.short(root))
ctxs = [repo[r] for r in revs]
if not rules:
comment = editcomment % (node.short(root), node.short(topmost))
rules = ruleeditor(repo, ui, [['pick', c] for c in ctxs], comment)
else:
if rules == '-':
f = sys.stdin
else:
f = open(rules)
rules = f.read()
f.close()
rules = [l for l in (r.strip() for r in rules.splitlines())
if l and not l.startswith('#')]
rules = verifyrules(rules, repo, ctxs)
parentctxnode = repo[root].parents()[0].node()
state.parentctxnode = parentctxnode
state.rules = rules
state.keep = keep
state.topmost = topmost
state.replacements = replacements
# Create a backup so we can always abort completely.
backupfile = None
if not obsolete.isenabled(repo, obsolete.createmarkersopt):
backupfile = repair._bundle(repo, [parentctxnode], [topmost], root,
'histedit')
state.backupfile = backupfile
while state.rules:
state.write()
action, ha = state.rules.pop(0)
ui.debug('histedit: processing %s %s\n' % (action, ha[:12]))
actobj = actiontable[action].fromrule(state, ha)
parentctx, replacement_ = actobj.run()
state.parentctxnode = parentctx.node()
state.replacements.extend(replacement_)
state.write()
hg.update(repo, state.parentctxnode)
mapping, tmpnodes, created, ntm = processreplacement(state)
if mapping:
for prec, succs in mapping.iteritems():
if not succs:
ui.debug('histedit: %s is dropped\n' % node.short(prec))
else:
ui.debug('histedit: %s is replaced by %s\n' % (
node.short(prec), node.short(succs[0])))
if len(succs) > 1:
m = 'histedit: %s'
for n in succs[1:]:
ui.debug(m % node.short(n))
if not keep:
if mapping:
movebookmarks(ui, repo, mapping, state.topmost, ntm)
# TODO update mq state
if obsolete.isenabled(repo, obsolete.createmarkersopt):
markers = []
# sort by revision number because it sound "right"
for prec in sorted(mapping, key=repo.changelog.rev):
succs = mapping[prec]
markers.append((repo[prec],
tuple(repo[s] for s in succs)))
if markers:
obsolete.createmarkers(repo, markers)
else:
cleanupnode(ui, repo, 'replaced', mapping)
cleanupnode(ui, repo, 'temp', tmpnodes)
state.clear()
if os.path.exists(repo.sjoin('undo')):
os.unlink(repo.sjoin('undo'))
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.
.. container:: verbose
Examples:
- move "local changes" (current commit back to branching point)
to the current branch tip after a pull::
hg rebase
- move a single changeset to the stable branch::
hg rebase -r 5f493448 -d stable
- splice a commit and all its descendants onto another part of history::
hg rebase --source c0c3 --dest 4cf9
- rebase everything on a branch marked by a bookmark onto the
default branch::
hg rebase --base myfeature --dest default
- collapse a sequence of changes into a single commit::
hg rebase --collapse -r 1520:1525 -d .
- move a named branch while preserving its name::
hg rebase -r "branch(featureX)" -d 1.3 --keepbranches
Returns 0 on success, 1 if nothing to rebase or there are
unresolved conflicts.
"""
originalwd = target = None
activebookmark = 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
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)
e = opts.get('extrafn') # internal, used by e.g. hgsubversion
extrafns = [_savegraft]
if e:
extrafns = [e]
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 opts.get('interactive'):
try:
if extensions.find('histedit'):
enablehistedit = ''
except KeyError:
enablehistedit = " --config extensions.histedit="
help = "hg%s help -e histedit" % enablehistedit
msg = _("interactive history editing is supported by the "
"'histedit' extension (see \"%s\")") % help
raise error.Abort(msg)
if collapsemsg and not collapsef:
raise error.Abort(
_('message can only be specified with collapse'))
if contf or abortf:
if contf and abortf:
raise error.Abort(_('cannot use both abort and continue'))
if collapsef:
raise error.Abort(
_('cannot use collapse with continue or abort'))
if srcf or basef or destf:
raise error.Abort(
_('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,
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 broken state')
raise error.Abort(msg, hint=hint)
if abortf:
return abort(repo, originalwd, target, state,
activebookmark=activebookmark)
else:
if srcf and basef:
raise error.Abort(_('cannot specify both a '
'source and a base'))
if revf and basef:
raise error.Abort(_('cannot specify both a '
'revision and a base'))
if revf and srcf:
raise error.Abort(_('cannot specify both a '
'revision and a source'))
cmdutil.checkunfinished(repo)
cmdutil.bailifchanged(repo)
if destf:
dest = scmutil.revsingle(repo, destf)
else:
dest = repo[_destrebase(repo)]
destf = str(dest)
if revf:
rebaseset = scmutil.revrange(repo, revf)
if not rebaseset:
ui.status(_('empty "rev" revision set - '
'nothing to rebase\n'))
return _nothingtorebase()
elif srcf:
src = scmutil.revrange(repo, [srcf])
if not src:
ui.status(_('empty "source" revision set - '
'nothing to rebase\n'))
return _nothingtorebase()
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 _nothingtorebase()
commonanc = repo.revs('ancestor(%ld, %d)', base, dest).first()
if commonanc is not None:
rebaseset = repo.revs('(%d::(%ld) - %d)::',
commonanc, base, commonanc)
else:
rebaseset = []
if not rebaseset:
# transform to list because smartsets are not comparable to
# lists. This should be improved to honor laziness of
# smartset.
if list(base) == [dest.rev()]:
if basef:
ui.status(_('nothing to rebase - %s is both "base"'
' and destination\n') % dest)
else:
ui.status(_('nothing to rebase - working directory '
'parent is also destination\n'))
elif not repo.revs('%ld - ::%d', base, dest):
if basef:
ui.status(_('nothing to rebase - "base" %s is '
'already an ancestor of destination '
'%s\n') %
('+'.join(str(repo[r]) for r in base),
dest))
else:
ui.status(_('nothing to rebase - working '
'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 _nothingtorebase()
allowunstable = obsolete.isenabled(repo, obsolete.allowunstableopt)
if (not (keepf or allowunstable)
and 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'))
obsoletenotrebased = {}
if ui.configbool('experimental', 'rebaseskipobsolete'):
rebasesetrevs = set(rebaseset)
obsoletenotrebased = _computeobsoletenotrebased(repo,
rebasesetrevs,
dest)
# - plain prune (no successor) changesets are rebased
# - split changesets are not rebased if at least one of the
# changeset resulting from the split is an ancestor of dest
rebaseset = rebasesetrevs - set(obsoletenotrebased)
result = buildstate(repo, dest, rebaseset, collapsef,
obsoletenotrebased)
if not result:
# Empty state built, nothing to rebase
ui.status(_('nothing to rebase\n'))
return _nothingtorebase()
root = min(rebaseset)
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
if collapsef:
targetancestors = repo.changelog.ancestors([target],
inclusive=True)
external = externalparent(repo, state, targetancestors)
if dest.closesbranch() and not keepbranchesf:
ui.status(_('reopening closed branch head %s\n') % dest)
if keepbranchesf:
# insert _savebranch at the start of extrafns so if
# there's a user-provided extrafn it can clobber branch if
# desired
extrafns.insert(0, _savebranch)
if collapsef:
branches = set()
for rev in state:
branches.add(repo[rev].branch())
if len(branches) > 1:
raise error.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._activebookmark
if activebookmark:
bookmarks.deactivate(repo)
extrafn = _makeextrafn(extrafns)
sortedstate = sorted(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:
ui.status(_('rebasing %s\n') % desc)
ui.progress(_("rebasing"), pos, ("%d:%s" % (rev, ctx)),
_('changesets'), total)
p1, p2, base = 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', ''),
'rebase')
stats = rebasenode(repo, rev, p1, base, state,
collapsef, target)
if stats and stats[3] > 0:
raise error.InterventionRequired(
_('unresolved conflicts (see hg '
'resolve, then hg rebase --continue)'))
finally:
ui.setconfig('ui', 'forcemerge', '', 'rebase')
if not collapsef:
merging = p2 != nullrev
editform = cmdutil.mergeeditform(merging, 'rebase')
editor = cmdutil.getcommiteditor(editform=editform, **opts)
newnode = concludenode(repo, rev, p1, p2, extrafn=extrafn,
editor=editor,
keepbranches=keepbranchesf)
else:
# Skip commit if we are collapsing
repo.dirstate.beginparentchange()
repo.setparents(repo[p1].node())
repo.dirstate.endparentchange()
newnode = None
# Update the state
if newnode is not None:
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
ui.debug('next revision set to %s\n' % p1)
elif state[rev] == nullmerge:
ui.debug('ignoring null merge rebase of %s\n' % rev)
elif state[rev] == revignored:
ui.status(_('not rebasing ignored %s\n') % desc)
elif 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))
else:
ui.status(_('already rebased %s as %s\n') %
(desc, repo[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,
state, targetancestors)
editopt = opts.get('edit')
editform = 'rebase.collapse'
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()
editopt = True
editor = cmdutil.getcommiteditor(edit=editopt, editform=editform)
newnode = concludenode(repo, rev, p1, external, commitmsg=commitmsg,
extrafn=extrafn, editor=editor,
keepbranches=keepbranchesf)
if newnode is None:
newrev = target
else:
newrev = repo[newnode].rev()
for oldrev in state.iterkeys():
if state[oldrev] > nullmerge:
state[oldrev] = newrev
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()
# restore original working directory
# (we do this before stripping)
newwd = state.get(originalwd, originalwd)
if newwd < 0:
# original directory is a parent of rebase set root or ignored
newwd = 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)
if currentbookmarks:
updatebookmarks(repo, targetnode, nstate, currentbookmarks)
if activebookmark not in repo._bookmarks:
# active bookmark was divergent one and has been deleted
activebookmark = None
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['.'].node() == repo._bookmarks[activebookmark]):
bookmarks.activate(repo, activebookmark)
finally:
release(lock, wlock)
def _histedit(ui, repo, *freeargs, **opts):
# TODO only abort if we try and histedit mq patches, not just
# blanket if mq patches are applied somewhere
mq = getattr(repo, 'mq', None)
if mq and mq.applied:
raise util.Abort(_('source has mq patches applied'))
# basic argument incompatibility processing
outg = opts.get('outgoing')
cont = opts.get('continue')
abort = opts.get('abort')
force = opts.get('force')
rules = opts.get('commands', '')
revs = opts.get('rev', [])
goal = 'new' # This invocation goal, in new, continue, abort
if force and not outg:
raise util.Abort(_('--force only allowed with --outgoing'))
if cont:
if util.any((outg, abort, revs, freeargs, rules)):
raise util.Abort(_('no arguments allowed with --continue'))
goal = 'continue'
elif abort:
if util.any((outg, revs, freeargs, rules)):
raise util.Abort(_('no arguments allowed with --abort'))
goal = 'abort'
else:
if os.path.exists(os.path.join(repo.path, 'histedit-state')):
raise util.Abort(_('history edit already in progress, try '
'--continue or --abort'))
if outg:
if revs:
raise util.Abort(_('no revisions allowed with --outgoing'))
if len(freeargs) > 1:
raise util.Abort(
_('only one repo argument allowed with --outgoing'))
else:
revs.extend(freeargs)
if len(revs) != 1:
raise util.Abort(
_('histedit requires exactly one ancestor revision'))
if goal == 'continue':
(parentctxnode, rules, keep, topmost, replacements) = readstate(repo)
parentctx = repo[parentctxnode]
parentctx, repl = bootstrapcontinue(ui, repo, parentctx, rules, opts)
replacements.extend(repl)
elif goal == 'abort':
(parentctxnode, rules, keep, topmost, replacements) = readstate(repo)
mapping, tmpnodes, leafs, _ntm = processreplacement(repo, replacements)
ui.debug('restore wc to old parent %s\n' % node.short(topmost))
# check whether we should update away
parentnodes = [c.node() for c in repo[None].parents()]
for n in leafs | set([parentctxnode]):
if n in parentnodes:
hg.clean(repo, topmost)
break
else:
pass
cleanupnode(ui, repo, 'created', tmpnodes)
cleanupnode(ui, repo, 'temp', leafs)
os.unlink(os.path.join(repo.path, 'histedit-state'))
return
else:
cmdutil.checkunfinished(repo)
cmdutil.bailifchanged(repo)
topmost, empty = repo.dirstate.parents()
if outg:
if freeargs:
remote = freeargs[0]
else:
remote = None
root = findoutgoing(ui, repo, remote, force, opts)
else:
rootrevs = list(repo.set('roots(%lr)', revs))
if len(rootrevs) != 1:
raise util.Abort(_('The specified revisions must have '
'exactly one common root'))
root = rootrevs[0].node()
keep = opts.get('keep', False)
revs = between(repo, root, topmost, keep)
if not revs:
raise util.Abort(_('%s is not an ancestor of working directory') %
node.short(root))
ctxs = [repo[r] for r in revs]
if not rules:
rules = '\n'.join([makedesc(c) for c in ctxs])
rules += '\n\n'
rules += editcomment % (node.short(root), node.short(topmost))
rules = ui.edit(rules, ui.username())
# Save edit rules in .hg/histedit-last-edit.txt in case
# the user needs to ask for help after something
# surprising happens.
f = open(repo.join('histedit-last-edit.txt'), 'w')
f.write(rules)
f.close()
else:
if rules == '-':
f = sys.stdin
else:
f = open(rules)
rules = f.read()
f.close()
rules = [l for l in (r.strip() for r in rules.splitlines())
if l and not l[0] == '#']
rules = verifyrules(rules, repo, ctxs)
parentctx = repo[root].parents()[0]
keep = opts.get('keep', False)
replacements = []
while rules:
writestate(repo, parentctx.node(), rules, keep, topmost, replacements)
action, ha = rules.pop(0)
ui.debug('histedit: processing %s %s\n' % (action, ha))
actfunc = actiontable[action]
parentctx, replacement_ = actfunc(ui, repo, parentctx, ha, opts)
replacements.extend(replacement_)
hg.update(repo, parentctx.node())
mapping, tmpnodes, created, ntm = processreplacement(repo, replacements)
if mapping:
for prec, succs in mapping.iteritems():
if not succs:
ui.debug('histedit: %s is dropped\n' % node.short(prec))
else:
ui.debug('histedit: %s is replaced by %s\n' % (
node.short(prec), node.short(succs[0])))
if len(succs) > 1:
m = 'histedit: %s'
for n in succs[1:]:
ui.debug(m % node.short(n))
if not keep:
if mapping:
movebookmarks(ui, repo, mapping, topmost, ntm)
# TODO update mq state
if obsolete._enabled:
markers = []
# sort by revision number because it sound "right"
for prec in sorted(mapping, key=repo.changelog.rev):
succs = mapping[prec]
markers.append((repo[prec],
tuple(repo[s] for s in succs)))
if markers:
obsolete.createmarkers(repo, markers)
else:
cleanupnode(ui, repo, 'replaced', mapping)
cleanupnode(ui, repo, 'temp', tmpnodes)
os.unlink(os.path.join(repo.path, 'histedit-state'))
if os.path.exists(repo.sjoin('undo')):
os.unlink(repo.sjoin('undo'))
def transplant(ui, repo, *revs, **opts):
'''transplant changesets from another branch
Selected changesets will be applied on top of the current working
directory with the log of the original changeset. The changesets
are copied and will thus appear twice in the history with different
identities.
Consider using the graft command if everything is inside the same
repository - it will use merges and will usually give a better result.
Use the rebase extension if the changesets are unpublished and you want
to move them instead of copying them.
If --log is specified, log messages will have a comment appended
of the form::
(transplanted from CHANGESETHASH)
You can rewrite the changelog message with the --filter option.
Its argument will be invoked with the current changelog message as
$1 and the patch as $2.
--source/-s specifies another repository to use for selecting changesets,
just as if it temporarily had been pulled.
If --branch/-b is specified, these revisions will be used as
heads when deciding which changsets to transplant, just as if only
these revisions had been pulled.
If --all/-a is specified, all the revisions up to the heads specified
with --branch will be transplanted.
Example:
- transplant all changes up to REV on top of your current revision::
hg transplant --branch REV --all
You can optionally mark selected transplanted changesets as merge
changesets. You will not be prompted to transplant any ancestors
of a merged transplant, and you can merge descendants of them
normally instead of transplanting them.
Merge changesets may be transplanted directly by specifying the
proper parent changeset by calling :hg:`transplant --parent`.
If no merges or revisions are provided, :hg:`transplant` will
start an interactive changeset browser.
If a changeset application fails, you can fix the merge by hand
and then resume where you left off by calling :hg:`transplant
--continue/-c`.
'''
def incwalk(repo, csets, match=util.always):
for node in csets:
if match(node):
yield node
def transplantwalk(repo, dest, heads, match=util.always):
'''Yield all nodes that are ancestors of a head but not ancestors
of dest.
If no heads are specified, the heads of repo will be used.'''
if not heads:
heads = repo.heads()
ancestors = []
for head in heads:
ancestors.append(repo.changelog.ancestor(dest, head))
for node in repo.changelog.nodesbetween(ancestors, heads)[0]:
if match(node):
yield node
def checkopts(opts, revs):
if opts.get('continue'):
if opts.get('branch') or opts.get('all') or opts.get('merge'):
raise util.Abort(_('--continue is incompatible with '
'--branch, --all and --merge'))
return
if not (opts.get('source') or revs or
opts.get('merge') or opts.get('branch')):
raise util.Abort(_('no source URL, branch revision or revision '
'list provided'))
if opts.get('all'):
if not opts.get('branch'):
raise util.Abort(_('--all requires a branch revision'))
if revs:
raise util.Abort(_('--all is incompatible with a '
'revision list'))
checkopts(opts, revs)
if not opts.get('log'):
opts['log'] = ui.config('transplant', 'log')
if not opts.get('filter'):
opts['filter'] = ui.config('transplant', 'filter')
tp = transplanter(ui, repo)
if opts.get('edit'):
tp.editor = cmdutil.commitforceeditor
cmdutil.checkunfinished(repo)
p1, p2 = repo.dirstate.parents()
if len(repo) > 0 and p1 == revlog.nullid:
raise util.Abort(_('no revision checked out'))
if not opts.get('continue'):
if p2 != revlog.nullid:
raise util.Abort(_('outstanding uncommitted merges'))
m, a, r, d = repo.status()[:4]
if m or a or r or d:
raise util.Abort(_('outstanding local changes'))
sourcerepo = opts.get('source')
if sourcerepo:
peer = hg.peer(repo, opts, ui.expandpath(sourcerepo))
heads = map(peer.lookup, opts.get('branch', ()))
source, csets, cleanupfn = bundlerepo.getremotechanges(ui, repo, peer,
onlyheads=heads, force=True)
else:
source = repo
heads = map(source.lookup, opts.get('branch', ()))
cleanupfn = None
try:
if opts.get('continue'):
tp.resume(repo, source, opts)
return
tf = tp.transplantfilter(repo, source, p1)
if opts.get('prune'):
prune = set(source.lookup(r)
for r in scmutil.revrange(source, opts.get('prune')))
matchfn = lambda x: tf(x) and x not in prune
else:
matchfn = tf
merges = map(source.lookup, opts.get('merge', ()))
revmap = {}
if revs:
for r in scmutil.revrange(source, revs):
revmap[int(r)] = source.lookup(r)
elif opts.get('all') or not merges:
if source != repo:
alltransplants = incwalk(source, csets, match=matchfn)
else:
alltransplants = transplantwalk(source, p1, heads,
match=matchfn)
if opts.get('all'):
revs = alltransplants
else:
revs, newmerges = browserevs(ui, source, alltransplants, opts)
merges.extend(newmerges)
for r in revs:
revmap[source.changelog.rev(r)] = r
for r in merges:
revmap[source.changelog.rev(r)] = r
tp.apply(repo, source, revmap, merges, opts)
finally:
if cleanupfn:
cleanupfn()
def _dounshelve(ui, repo, *shelved, **opts):
abortf = opts.get('abort')
continuef = opts.get('continue')
if not abortf and not continuef:
cmdutil.checkunfinished(repo)
shelved = list(shelved)
if opts.get("name"):
shelved.append(opts["name"])
if abortf or continuef:
if abortf and continuef:
raise error.Abort(_('cannot use both abort and continue'))
if shelved:
raise error.Abort(
_('cannot combine abort/continue with '
'naming a shelved change'))
if abortf and opts.get('tool', False):
ui.warn(_('tool option will be ignored\n'))
try:
state = shelvedstate.load(repo)
if opts.get('keep') is None:
opts['keep'] = state.keep
except IOError as err:
if err.errno != errno.ENOENT:
raise
cmdutil.wrongtooltocontinue(repo, _('unshelve'))
except error.CorruptedState as err:
ui.debug(str(err) + '\n')
if continuef:
msg = _('corrupted shelved state file')
hint = _('please run hg unshelve --abort to abort unshelve '
'operation')
raise error.Abort(msg, hint=hint)
elif abortf:
msg = _('could not read shelved state file, your working copy '
'may be in an unexpected state\nplease update to some '
'commit\n')
ui.warn(msg)
shelvedstate.clear(repo)
return
if abortf:
return unshelveabort(ui, repo, state, opts)
elif continuef:
return unshelvecontinue(ui, repo, state, opts)
elif len(shelved) > 1:
raise error.Abort(_('can only unshelve one change at a time'))
elif not shelved:
shelved = listshelves(repo)
if not shelved:
raise error.Abort(_('no shelved changes to apply!'))
basename = util.split(shelved[0][1])[1]
ui.status(_("unshelving change '%s'\n") % basename)
else:
basename = shelved[0]
if not shelvedfile(repo, basename, patchextension).exists():
raise error.Abort(_("shelved change '%s' not found") % basename)
lock = tr = None
try:
lock = repo.lock()
tr = repo.transaction('unshelve', report=lambda x: None)
oldtiprev = len(repo)
pctx = repo['.']
tmpwctx = pctx
# The goal is to have a commit structure like so:
# ...-> pctx -> tmpwctx -> shelvectx
# where tmpwctx is an optional commit with the user's pending changes
# and shelvectx is the unshelved changes. Then we merge it all down
# to the original pctx.
activebookmark = _backupactivebookmark(repo)
overrides = {('ui', 'forcemerge'): opts.get('tool', '')}
with ui.configoverride(overrides, 'unshelve'):
tmpwctx, addedbefore = _commitworkingcopychanges(
ui, repo, opts, tmpwctx)
repo, shelvectx = _unshelverestorecommit(ui, repo, basename)
_checkunshelveuntrackedproblems(ui, repo, shelvectx)
branchtorestore = ''
if shelvectx.branch() != shelvectx.p1().branch():
branchtorestore = shelvectx.branch()
shelvectx = _rebaserestoredcommit(ui, repo, opts, tr, oldtiprev,
basename, pctx, tmpwctx,
shelvectx, branchtorestore,
activebookmark)
mergefiles(ui, repo, pctx, shelvectx)
restorebranch(ui, repo, branchtorestore)
_forgetunknownfiles(repo, shelvectx, addedbefore)
shelvedstate.clear(repo)
_finishunshelve(repo, oldtiprev, tr, activebookmark)
unshelvecleanup(ui, repo, basename, opts)
finally:
if tr:
tr.release()
lockmod.release(lock)
def _dounshelve(ui, repo, *shelved, **opts):
abortf = opts.get('abort')
continuef = opts.get('continue')
if not abortf and not continuef:
cmdutil.checkunfinished(repo)
if abortf or continuef:
if abortf and continuef:
raise error.Abort(_('cannot use both abort and continue'))
if shelved:
raise error.Abort(_('cannot combine abort/continue with '
'naming a shelved change'))
if abortf and opts.get('tool', False):
ui.warn(_('tool option will be ignored\n'))
try:
state = shelvedstate.load(repo)
except IOError as err:
if err.errno != errno.ENOENT:
raise
cmdutil.wrongtooltocontinue(repo, _('unshelve'))
except error.CorruptedState as err:
ui.debug(str(err) + '\n')
if continuef:
msg = _('corrupted shelved state file')
hint = _('please run hg unshelve --abort to abort unshelve '
'operation')
raise error.Abort(msg, hint=hint)
elif abortf:
msg = _('could not read shelved state file, your working copy '
'may be in an unexpected state\nplease update to some '
'commit\n')
ui.warn(msg)
shelvedstate.clear(repo)
return
if abortf:
return unshelveabort(ui, repo, state, opts)
elif continuef:
return unshelvecontinue(ui, repo, state, opts)
elif len(shelved) > 1:
raise error.Abort(_('can only unshelve one change at a time'))
elif not shelved:
shelved = listshelves(repo)
if not shelved:
raise error.Abort(_('no shelved changes to apply!'))
basename = util.split(shelved[0][1])[1]
ui.status(_("unshelving change '%s'\n") % basename)
else:
basename = shelved[0]
if not shelvedfile(repo, basename, 'patch').exists():
raise error.Abort(_("shelved change '%s' not found") % basename)
oldquiet = ui.quiet
lock = tr = None
forcemerge = ui.backupconfig('ui', 'forcemerge')
try:
ui.setconfig('ui', 'forcemerge', opts.get('tool', ''), 'unshelve')
lock = repo.lock()
tr = repo.transaction('unshelve', report=lambda x: None)
oldtiprev = len(repo)
pctx = repo['.']
tmpwctx = pctx
# The goal is to have a commit structure like so:
# ...-> pctx -> tmpwctx -> shelvectx
# where tmpwctx is an optional commit with the user's pending changes
# and shelvectx is the unshelved changes. Then we merge it all down
# to the original pctx.
# Store pending changes in a commit and remember added in case a shelve
# contains unknown files that are part of the pending change
s = repo.status()
addedbefore = frozenset(s.added)
if s.modified or s.added or s.removed or s.deleted:
ui.status(_("temporarily committing pending changes "
"(restore with 'hg unshelve --abort')\n"))
def commitfunc(ui, repo, message, match, opts):
hasmq = util.safehasattr(repo, 'mq')
if hasmq:
saved, repo.mq.checkapplied = repo.mq.checkapplied, False
backup = repo.ui.backupconfig('phases', 'new-commit')
try:
repo.ui.setconfig('phases', 'new-commit', phases.secret)
return repo.commit(message, 'shelve@localhost',
opts.get('date'), match)
finally:
repo.ui.restoreconfig(backup)
if hasmq:
repo.mq.checkapplied = saved
tempopts = {}
tempopts['message'] = "pending changes temporary commit"
tempopts['date'] = opts.get('date')
ui.quiet = True
node = cmdutil.commit(ui, repo, commitfunc, [], tempopts)
tmpwctx = repo[node]
ui.quiet = True
shelvedfile(repo, basename, 'hg').applybundle()
ui.quiet = oldquiet
shelvectx = repo['tip']
branchtorestore = ''
if shelvectx.branch() != shelvectx.p1().branch():
branchtorestore = shelvectx.branch()
# If the shelve is not immediately on top of the commit
# we'll be merging with, rebase it to be on top.
if tmpwctx.node() != shelvectx.parents()[0].node():
ui.status(_('rebasing shelved changes\n'))
try:
rebase.rebase(ui, repo, **{
'rev' : [shelvectx.rev()],
'dest' : str(tmpwctx.rev()),
'keep' : True,
'tool' : opts.get('tool', ''),
})
except error.InterventionRequired:
tr.close()
stripnodes = [repo.changelog.node(rev)
for rev in xrange(oldtiprev, len(repo))]
shelvedstate.save(repo, basename, pctx, tmpwctx, stripnodes,
branchtorestore)
util.rename(repo.join('rebasestate'),
repo.join('unshelverebasestate'))
raise error.InterventionRequired(
_("unresolved conflicts (see 'hg resolve', then "
"'hg unshelve --continue')"))
# refresh ctx after rebase completes
shelvectx = repo['tip']
if not shelvectx in tmpwctx.children():
# rebase was a no-op, so it produced no child commit
shelvectx = tmpwctx
mergefiles(ui, repo, pctx, shelvectx)
restorebranch(ui, repo, branchtorestore)
# Forget any files that were unknown before the shelve, unknown before
# unshelve started, but are now added.
shelveunknown = shelvectx.extra().get('shelve_unknown')
if shelveunknown:
shelveunknown = frozenset(shelveunknown.split('\0'))
addedafter = frozenset(repo.status().added)
toforget = (addedafter & shelveunknown) - addedbefore
repo[None].forget(toforget)
shelvedstate.clear(repo)
# The transaction aborting will strip all the commits for us,
# but it doesn't update the inmemory structures, so addchangegroup
# hooks still fire and try to operate on the missing commits.
# Clean up manually to prevent this.
repo.unfiltered().changelog.strip(oldtiprev, tr)
unshelvecleanup(ui, repo, basename, opts)
_aborttransaction(repo)
finally:
ui.quiet = oldquiet
if tr:
tr.release()
lockmod.release(lock)
ui.restoreconfig(forcemerge)
def _histedit(ui, repo, state, *freeargs, **opts):
# TODO only abort if we try and histedit mq patches, not just
# blanket if mq patches are applied somewhere
mq = getattr(repo, 'mq', None)
if mq and mq.applied:
raise util.Abort(_('source has mq patches applied'))
# basic argument incompatibility processing
outg = opts.get('outgoing')
cont = opts.get('continue')
editplan = opts.get('edit_plan')
abort = opts.get('abort')
force = opts.get('force')
rules = opts.get('commands', '')
revs = opts.get('rev', [])
goal = 'new' # This invocation goal, in new, continue, abort
if force and not outg:
raise util.Abort(_('--force only allowed with --outgoing'))
if cont:
if any((outg, abort, revs, freeargs, rules, editplan)):
raise util.Abort(_('no arguments allowed with --continue'))
goal = 'continue'
elif abort:
if any((outg, revs, freeargs, rules, editplan)):
raise util.Abort(_('no arguments allowed with --abort'))
goal = 'abort'
elif editplan:
if any((outg, revs, freeargs)):
raise util.Abort(
_('only --commands argument allowed with '
'--edit-plan'))
goal = 'edit-plan'
else:
if os.path.exists(os.path.join(repo.path, 'histedit-state')):
raise util.Abort(
_('history edit already in progress, try '
'--continue or --abort'))
if outg:
if revs:
raise util.Abort(_('no revisions allowed with --outgoing'))
if len(freeargs) > 1:
raise util.Abort(
_('only one repo argument allowed with --outgoing'))
else:
revs.extend(freeargs)
if len(revs) == 0:
histeditdefault = ui.config('histedit', 'defaultrev')
if histeditdefault:
revs.append(histeditdefault)
if len(revs) != 1:
raise util.Abort(
_('histedit requires exactly one ancestor revision'))
replacements = []
state.keep = opts.get('keep', False)
# rebuild state
if goal == 'continue':
state.read()
state = bootstrapcontinue(ui, state, opts)
elif goal == 'edit-plan':
state.read()
if not rules:
comment = editcomment % (node.short(
state.parentctxnode), node.short(state.topmost))
rules = ruleeditor(repo, ui, state.rules, comment)
else:
if rules == '-':
f = sys.stdin
else:
f = open(rules)
rules = f.read()
f.close()
rules = [
l for l in (r.strip() for r in rules.splitlines())
if l and not l.startswith('#')
]
rules = verifyrules(rules, repo, [repo[c] for [_a, c] in state.rules])
state.rules = rules
state.write()
return
elif goal == 'abort':
state.read()
mapping, tmpnodes, leafs, _ntm = processreplacement(state)
ui.debug('restore wc to old parent %s\n' % node.short(state.topmost))
# Recover our old commits if necessary
if not state.topmost in repo and state.backupfile:
backupfile = repo.join(state.backupfile)
f = hg.openpath(ui, backupfile)
gen = exchange.readbundle(ui, f, backupfile)
changegroup.addchangegroup(repo, gen, 'histedit',
'bundle:' + backupfile)
os.remove(backupfile)
# check whether we should update away
parentnodes = [c.node() for c in repo[None].parents()]
for n in leafs | set([state.parentctxnode]):
if n in parentnodes:
hg.clean(repo, state.topmost)
break
else:
pass
cleanupnode(ui, repo, 'created', tmpnodes)
cleanupnode(ui, repo, 'temp', leafs)
state.clear()
return
else:
cmdutil.checkunfinished(repo)
cmdutil.bailifchanged(repo)
topmost, empty = repo.dirstate.parents()
if outg:
if freeargs:
remote = freeargs[0]
else:
remote = None
root = findoutgoing(ui, repo, remote, force, opts)
else:
rr = list(repo.set('roots(%ld)', scmutil.revrange(repo, revs)))
if len(rr) != 1:
raise util.Abort(
_('The specified revisions must have '
'exactly one common root'))
root = rr[0].node()
revs = between(repo, root, topmost, state.keep)
if not revs:
raise util.Abort(
_('%s is not an ancestor of working directory') %
node.short(root))
ctxs = [repo[r] for r in revs]
if not rules:
comment = editcomment % (node.short(root), node.short(topmost))
rules = ruleeditor(repo, ui, [['pick', c] for c in ctxs], comment)
else:
if rules == '-':
f = sys.stdin
else:
f = open(rules)
rules = f.read()
f.close()
rules = [
l for l in (r.strip() for r in rules.splitlines())
if l and not l.startswith('#')
]
rules = verifyrules(rules, repo, ctxs)
parentctxnode = repo[root].parents()[0].node()
state.parentctxnode = parentctxnode
state.rules = rules
state.topmost = topmost
state.replacements = replacements
# Create a backup so we can always abort completely.
backupfile = None
if not obsolete.isenabled(repo, obsolete.createmarkersopt):
backupfile = repair._bundle(repo, [parentctxnode], [topmost], root,
'histedit')
state.backupfile = backupfile
while state.rules:
state.write()
action, ha = state.rules.pop(0)
ui.debug('histedit: processing %s %s\n' % (action, ha[:12]))
actobj = actiontable[action].fromrule(state, ha)
parentctx, replacement_ = actobj.run()
state.parentctxnode = parentctx.node()
state.replacements.extend(replacement_)
state.write()
hg.update(repo, state.parentctxnode)
mapping, tmpnodes, created, ntm = processreplacement(state)
if mapping:
for prec, succs in mapping.iteritems():
if not succs:
ui.debug('histedit: %s is dropped\n' % node.short(prec))
else:
ui.debug('histedit: %s is replaced by %s\n' %
(node.short(prec), node.short(succs[0])))
if len(succs) > 1:
m = 'histedit: %s'
for n in succs[1:]:
ui.debug(m % node.short(n))
if not state.keep:
if mapping:
movebookmarks(ui, repo, mapping, state.topmost, ntm)
# TODO update mq state
if obsolete.isenabled(repo, obsolete.createmarkersopt):
markers = []
# sort by revision number because it sound "right"
for prec in sorted(mapping, key=repo.changelog.rev):
succs = mapping[prec]
markers.append((repo[prec], tuple(repo[s] for s in succs)))
if markers:
obsolete.createmarkers(repo, markers)
else:
cleanupnode(ui, repo, 'replaced', mapping)
cleanupnode(ui, repo, 'temp', tmpnodes)
state.clear()
if os.path.exists(repo.sjoin('undo')):
os.unlink(repo.sjoin('undo'))
def createcmd(ui, repo, pats, opts):
"""subcommand that creates a new shelve"""
with repo.wlock():
cmdutil.checkunfinished(repo)
return _docreatecmd(ui, repo, pats, opts)
def _dotransplant(ui, repo, *revs, **opts):
def incwalk(repo, csets, match=util.always):
for node in csets:
if match(node):
yield node
def transplantwalk(repo, dest, heads, match=util.always):
'''Yield all nodes that are ancestors of a head but not ancestors
of dest.
If no heads are specified, the heads of repo will be used.'''
if not heads:
heads = repo.heads()
ancestors = []
ctx = repo[dest]
for head in heads:
ancestors.append(ctx.ancestor(repo[head]).node())
for node in repo.changelog.nodesbetween(ancestors, heads)[0]:
if match(node):
yield node
def checkopts(opts, revs):
if opts.get('continue'):
if opts.get('branch') or opts.get('all') or opts.get('merge'):
raise error.Abort(_('--continue is incompatible with '
'--branch, --all and --merge'))
return
if not (opts.get('source') or revs or
opts.get('merge') or opts.get('branch')):
raise error.Abort(_('no source URL, branch revision, or revision '
'list provided'))
if opts.get('all'):
if not opts.get('branch'):
raise error.Abort(_('--all requires a branch revision'))
if revs:
raise error.Abort(_('--all is incompatible with a '
'revision list'))
opts = pycompat.byteskwargs(opts)
checkopts(opts, revs)
if not opts.get('log'):
# deprecated config: transplant.log
opts['log'] = ui.config('transplant', 'log')
if not opts.get('filter'):
# deprecated config: transplant.filter
opts['filter'] = ui.config('transplant', 'filter')
tp = transplanter(ui, repo, opts)
p1, p2 = repo.dirstate.parents()
if len(repo) > 0 and p1 == revlog.nullid:
raise error.Abort(_('no revision checked out'))
if opts.get('continue'):
if not tp.canresume():
raise error.Abort(_('no transplant to continue'))
else:
cmdutil.checkunfinished(repo)
if p2 != revlog.nullid:
raise error.Abort(_('outstanding uncommitted merges'))
m, a, r, d = repo.status()[:4]
if m or a or r or d:
raise error.Abort(_('outstanding local changes'))
sourcerepo = opts.get('source')
if sourcerepo:
peer = hg.peer(repo, opts, ui.expandpath(sourcerepo))
heads = map(peer.lookup, opts.get('branch', ()))
target = set(heads)
for r in revs:
try:
target.add(peer.lookup(r))
except error.RepoError:
pass
source, csets, cleanupfn = bundlerepo.getremotechanges(ui, repo, peer,
onlyheads=sorted(target), force=True)
else:
source = repo
heads = map(source.lookup, opts.get('branch', ()))
cleanupfn = None
try:
if opts.get('continue'):
tp.resume(repo, source, opts)
return
tf = tp.transplantfilter(repo, source, p1)
if opts.get('prune'):
prune = set(source[r].node()
for r in scmutil.revrange(source, opts.get('prune')))
matchfn = lambda x: tf(x) and x not in prune
else:
matchfn = tf
merges = map(source.lookup, opts.get('merge', ()))
revmap = {}
if revs:
for r in scmutil.revrange(source, revs):
revmap[int(r)] = source[r].node()
elif opts.get('all') or not merges:
if source != repo:
alltransplants = incwalk(source, csets, match=matchfn)
else:
alltransplants = transplantwalk(source, p1, heads,
match=matchfn)
if opts.get('all'):
revs = alltransplants
else:
revs, newmerges = browserevs(ui, source, alltransplants, opts)
merges.extend(newmerges)
for r in revs:
revmap[source.changelog.rev(r)] = r
for r in merges:
revmap[source.changelog.rev(r)] = r
tp.apply(repo, source, revmap, merges, opts)
finally:
if cleanupfn:
cleanupfn()
def _dounshelve(ui, repo, *shelved, **opts):
abortf = opts.get('abort')
continuef = opts.get('continue')
if not abortf and not continuef:
cmdutil.checkunfinished(repo)
if abortf or continuef:
if abortf and continuef:
raise error.Abort(_('cannot use both abort and continue'))
if shelved:
raise error.Abort(
_('cannot combine abort/continue with '
'naming a shelved change'))
if abortf and opts.get('tool', False):
ui.warn(_('tool option will be ignored\n'))
try:
state = shelvedstate.load(repo)
except IOError as err:
if err.errno != errno.ENOENT:
raise
cmdutil.wrongtooltocontinue(repo, _('unshelve'))
if abortf:
return unshelveabort(ui, repo, state, opts)
elif continuef:
return unshelvecontinue(ui, repo, state, opts)
elif len(shelved) > 1:
raise error.Abort(_('can only unshelve one change at a time'))
elif not shelved:
shelved = listshelves(repo)
if not shelved:
raise error.Abort(_('no shelved changes to apply!'))
basename = util.split(shelved[0][1])[1]
ui.status(_("unshelving change '%s'\n") % basename)
else:
basename = shelved[0]
if not shelvedfile(repo, basename, 'patch').exists():
raise error.Abort(_("shelved change '%s' not found") % basename)
oldquiet = ui.quiet
lock = tr = None
forcemerge = ui.backupconfig('ui', 'forcemerge')
try:
ui.setconfig('ui', 'forcemerge', opts.get('tool', ''), 'unshelve')
lock = repo.lock()
tr = repo.transaction('unshelve', report=lambda x: None)
oldtiprev = len(repo)
pctx = repo['.']
tmpwctx = pctx
# The goal is to have a commit structure like so:
# ...-> pctx -> tmpwctx -> shelvectx
# where tmpwctx is an optional commit with the user's pending changes
# and shelvectx is the unshelved changes. Then we merge it all down
# to the original pctx.
# Store pending changes in a commit and remember added in case a shelve
# contains unknown files that are part of the pending change
s = repo.status()
addedbefore = frozenset(s.added)
if s.modified or s.added or s.removed or s.deleted:
ui.status(
_("temporarily committing pending changes "
"(restore with 'hg unshelve --abort')\n"))
def commitfunc(ui, repo, message, match, opts):
hasmq = util.safehasattr(repo, 'mq')
if hasmq:
saved, repo.mq.checkapplied = repo.mq.checkapplied, False
backup = repo.ui.backupconfig('phases', 'new-commit')
try:
repo.ui.setconfig('phases', 'new-commit', phases.secret)
return repo.commit(message, 'shelve@localhost',
opts.get('date'), match)
finally:
repo.ui.restoreconfig(backup)
if hasmq:
repo.mq.checkapplied = saved
tempopts = {}
tempopts['message'] = "pending changes temporary commit"
tempopts['date'] = opts.get('date')
ui.quiet = True
node = cmdutil.commit(ui, repo, commitfunc, [], tempopts)
tmpwctx = repo[node]
ui.quiet = True
shelvedfile(repo, basename, 'hg').applybundle()
ui.quiet = oldquiet
shelvectx = repo['tip']
branchtorestore = ''
if shelvectx.branch() != shelvectx.p1().branch():
branchtorestore = shelvectx.branch()
# If the shelve is not immediately on top of the commit
# we'll be merging with, rebase it to be on top.
if tmpwctx.node() != shelvectx.parents()[0].node():
ui.status(_('rebasing shelved changes\n'))
try:
rebase.rebase(
ui, repo, **{
'rev': [shelvectx.rev()],
'dest': str(tmpwctx.rev()),
'keep': True,
'tool': opts.get('tool', ''),
})
except error.InterventionRequired:
tr.close()
stripnodes = [
repo.changelog.node(rev)
for rev in xrange(oldtiprev, len(repo))
]
shelvedstate.save(repo, basename, pctx, tmpwctx, stripnodes,
branchtorestore)
util.rename(repo.join('rebasestate'),
repo.join('unshelverebasestate'))
raise error.InterventionRequired(
_("unresolved conflicts (see 'hg resolve', then "
"'hg unshelve --continue')"))
# refresh ctx after rebase completes
shelvectx = repo['tip']
if not shelvectx in tmpwctx.children():
# rebase was a no-op, so it produced no child commit
shelvectx = tmpwctx
mergefiles(ui, repo, pctx, shelvectx)
restorebranch(ui, repo, branchtorestore)
# Forget any files that were unknown before the shelve, unknown before
# unshelve started, but are now added.
shelveunknown = shelvectx.extra().get('shelve_unknown')
if shelveunknown:
shelveunknown = frozenset(shelveunknown.split('\0'))
addedafter = frozenset(repo.status().added)
toforget = (addedafter & shelveunknown) - addedbefore
repo[None].forget(toforget)
shelvedstate.clear(repo)
# The transaction aborting will strip all the commits for us,
# but it doesn't update the inmemory structures, so addchangegroup
# hooks still fire and try to operate on the missing commits.
# Clean up manually to prevent this.
repo.unfiltered().changelog.strip(oldtiprev, tr)
unshelvecleanup(ui, repo, basename, opts)
_aborttransaction(repo)
finally:
ui.quiet = oldquiet
if tr:
tr.release()
lockmod.release(lock)
ui.restoreconfig(forcemerge)
def shelvecmd(ui, repo, *pats, **opts):
'''save and set aside changes from the working directory
Shelving takes files that "hg status" reports as not clean, saves
the modifications to a bundle (a shelved change), and reverts the
files so that their state in the working directory becomes clean.
To restore these changes to the working directory, using "hg
unshelve"; this will work even if you switch to a different
commit.
When no files are specified, "hg shelve" saves all not-clean
files. If specific files or directories are named, only changes to
those files are shelved.
Each shelved change has a name that makes it easier to find later.
The name of a shelved change defaults to being based on the active
bookmark, or if there is no active bookmark, the current named
branch. To specify a different name, use ``--name``.
To see a list of existing shelved changes, use the ``--list``
option. For each shelved change, this will print its name, age,
and description; use ``--patch`` or ``--stat`` for more details.
To delete specific shelved changes, use ``--delete``. To delete
all shelved changes, use ``--cleanup``.
'''
cmdutil.checkunfinished(repo)
allowables = [
('addremove', 'create'), # 'create' is pseudo action
('cleanup', 'cleanup'),
# ('date', 'create'), # ignored for passing '--date "0 0"' in tests
('delete', 'delete'),
('edit', 'create'),
('list', 'list'),
('message', 'create'),
('name', 'create'),
('patch', 'list'),
('stat', 'list'),
]
def checkopt(opt):
if opts[opt]:
for i, allowable in allowables:
if opts[i] and opt != allowable:
raise util.Abort(_("options '--%s' and '--%s' may not be "
"used together") % (opt, i))
return True
if checkopt('cleanup'):
if pats:
raise util.Abort(_("cannot specify names when using '--cleanup'"))
return cleanupcmd(ui, repo)
elif checkopt('delete'):
return deletecmd(ui, repo, pats)
elif checkopt('list'):
return listcmd(ui, repo, pats, opts)
else:
for i in ('patch', 'stat'):
if opts[i]:
raise util.Abort(_("option '--%s' may not be "
"used when shelving a change") % (i,))
return createcmd(ui, repo, pats, opts)
def unshelve(ui, repo, *shelved, **opts):
"""restore a shelved change to the working directory
This command accepts an optional name of a shelved change to
restore. If none is given, the most recent shelved change is used.
If a shelved change is applied successfully, the bundle that
contains the shelved changes is moved to a backup location
(.hg/shelve-backup).
Since you can restore a shelved change on top of an arbitrary
commit, it is possible that unshelving will result in a conflict
between your changes and the commits you are unshelving onto. If
this occurs, you must resolve the conflict, then use
``--continue`` to complete the unshelve operation. (The bundle
will not be moved until you successfully complete the unshelve.)
(Alternatively, you can use ``--abort`` to abandon an unshelve
that causes a conflict. This reverts the unshelved changes, and
leaves the bundle in place.)
After a successful unshelve, the shelved changes are stored in a
backup directory. Only the N most recent backups are kept. N
defaults to 10 but can be overridden using the ``shelve.maxbackups``
configuration option.
.. container:: verbose
Timestamp in seconds is used to decide order of backups. More
than ``maxbackups`` backups are kept, if same timestamp
prevents from deciding exact order of them, for safety.
"""
abortf = opts['abort']
continuef = opts['continue']
if not abortf and not continuef:
cmdutil.checkunfinished(repo)
if abortf or continuef:
if abortf and continuef:
raise error.Abort(_('cannot use both abort and continue'))
if shelved:
raise error.Abort(_('cannot combine abort/continue with '
'naming a shelved change'))
try:
state = shelvedstate.load(repo)
except IOError as err:
if err.errno != errno.ENOENT:
raise
raise error.Abort(_('no unshelve operation underway'))
if abortf:
return unshelveabort(ui, repo, state, opts)
elif continuef:
return unshelvecontinue(ui, repo, state, opts)
elif len(shelved) > 1:
raise error.Abort(_('can only unshelve one change at a time'))
elif not shelved:
shelved = listshelves(repo)
if not shelved:
raise error.Abort(_('no shelved changes to apply!'))
basename = util.split(shelved[0][1])[1]
ui.status(_("unshelving change '%s'\n") % basename)
else:
basename = shelved[0]
if not shelvedfile(repo, basename, 'patch').exists():
raise error.Abort(_("shelved change '%s' not found") % basename)
oldquiet = ui.quiet
wlock = lock = tr = None
try:
wlock = repo.wlock()
lock = repo.lock()
tr = repo.transaction('unshelve', report=lambda x: None)
oldtiprev = len(repo)
pctx = repo['.']
tmpwctx = pctx
# The goal is to have a commit structure like so:
# ...-> pctx -> tmpwctx -> shelvectx
# where tmpwctx is an optional commit with the user's pending changes
# and shelvectx is the unshelved changes. Then we merge it all down
# to the original pctx.
# Store pending changes in a commit
s = repo.status()
if s.modified or s.added or s.removed or s.deleted:
ui.status(_("temporarily committing pending changes "
"(restore with 'hg unshelve --abort')\n"))
def commitfunc(ui, repo, message, match, opts):
hasmq = util.safehasattr(repo, 'mq')
if hasmq:
saved, repo.mq.checkapplied = repo.mq.checkapplied, False
backup = repo.ui.backupconfig('phases', 'new-commit')
try:
repo.ui. setconfig('phases', 'new-commit', phases.secret)
return repo.commit(message, 'shelve@localhost',
opts.get('date'), match)
finally:
repo.ui.restoreconfig(backup)
if hasmq:
repo.mq.checkapplied = saved
tempopts = {}
tempopts['message'] = "pending changes temporary commit"
tempopts['date'] = opts.get('date')
ui.quiet = True
node = cmdutil.commit(ui, repo, commitfunc, [], tempopts)
tmpwctx = repo[node]
ui.quiet = True
shelvedfile(repo, basename, 'hg').applybundle()
ui.quiet = oldquiet
shelvectx = repo['tip']
# If the shelve is not immediately on top of the commit
# we'll be merging with, rebase it to be on top.
if tmpwctx.node() != shelvectx.parents()[0].node():
ui.status(_('rebasing shelved changes\n'))
try:
rebase.rebase(ui, repo, **{
'rev' : [shelvectx.rev()],
'dest' : str(tmpwctx.rev()),
'keep' : True,
})
except error.InterventionRequired:
tr.close()
stripnodes = [repo.changelog.node(rev)
for rev in xrange(oldtiprev, len(repo))]
shelvedstate.save(repo, basename, pctx, tmpwctx, stripnodes)
util.rename(repo.join('rebasestate'),
repo.join('unshelverebasestate'))
raise error.InterventionRequired(
_("unresolved conflicts (see 'hg resolve', then "
"'hg unshelve --continue')"))
# refresh ctx after rebase completes
shelvectx = repo['tip']
if not shelvectx in tmpwctx.children():
# rebase was a no-op, so it produced no child commit
shelvectx = tmpwctx
mergefiles(ui, repo, pctx, shelvectx)
shelvedstate.clear(repo)
# The transaction aborting will strip all the commits for us,
# but it doesn't update the inmemory structures, so addchangegroup
# hooks still fire and try to operate on the missing commits.
# Clean up manually to prevent this.
repo.unfiltered().changelog.strip(oldtiprev, tr)
unshelvecleanup(ui, repo, basename, opts)
_aborttransaction(repo)
finally:
ui.quiet = oldquiet
if tr:
tr.release()
lockmod.release(lock, wlock)
def _dotransplant(ui, repo, *revs, **opts):
def incwalk(repo, csets, match=util.always):
for node in csets:
if match(node):
yield node
def transplantwalk(repo, dest, heads, match=util.always):
'''Yield all nodes that are ancestors of a head but not ancestors
of dest.
If no heads are specified, the heads of repo will be used.'''
if not heads:
heads = repo.heads()
ancestors = []
ctx = repo[dest]
for head in heads:
ancestors.append(ctx.ancestor(repo[head]).node())
for node in repo.changelog.nodesbetween(ancestors, heads)[0]:
if match(node):
yield node
def checkopts(opts, revs):
if opts.get('continue'):
if opts.get('branch') or opts.get('all') or opts.get('merge'):
raise error.Abort(_('--continue is incompatible with '
'--branch, --all and --merge'))
return
if not (opts.get('source') or revs or
opts.get('merge') or opts.get('branch')):
raise error.Abort(_('no source URL, branch revision, or revision '
'list provided'))
if opts.get('all'):
if not opts.get('branch'):
raise error.Abort(_('--all requires a branch revision'))
if revs:
raise error.Abort(_('--all is incompatible with a '
'revision list'))
checkopts(opts, revs)
if not opts.get('log'):
# deprecated config: transplant.log
opts['log'] = ui.config('transplant', 'log')
if not opts.get('filter'):
# deprecated config: transplant.filter
opts['filter'] = ui.config('transplant', 'filter')
tp = transplanter(ui, repo, opts)
p1, p2 = repo.dirstate.parents()
if len(repo) > 0 and p1 == revlog.nullid:
raise error.Abort(_('no revision checked out'))
if opts.get('continue'):
if not tp.canresume():
raise error.Abort(_('no transplant to continue'))
else:
cmdutil.checkunfinished(repo)
if p2 != revlog.nullid:
raise error.Abort(_('outstanding uncommitted merges'))
m, a, r, d = repo.status()[:4]
if m or a or r or d:
raise error.Abort(_('outstanding local changes'))
sourcerepo = opts.get('source')
if sourcerepo:
peer = hg.peer(repo, opts, ui.expandpath(sourcerepo))
heads = map(peer.lookup, opts.get('branch', ()))
target = set(heads)
for r in revs:
try:
target.add(peer.lookup(r))
except error.RepoError:
pass
source, csets, cleanupfn = bundlerepo.getremotechanges(ui, repo, peer,
onlyheads=sorted(target), force=True)
else:
source = repo
heads = map(source.lookup, opts.get('branch', ()))
cleanupfn = None
try:
if opts.get('continue'):
tp.resume(repo, source, opts)
return
tf = tp.transplantfilter(repo, source, p1)
if opts.get('prune'):
prune = set(source.lookup(r)
for r in scmutil.revrange(source, opts.get('prune')))
matchfn = lambda x: tf(x) and x not in prune
else:
matchfn = tf
merges = map(source.lookup, opts.get('merge', ()))
revmap = {}
if revs:
for r in scmutil.revrange(source, revs):
revmap[int(r)] = source.lookup(r)
elif opts.get('all') or not merges:
if source != repo:
alltransplants = incwalk(source, csets, match=matchfn)
else:
alltransplants = transplantwalk(source, p1, heads,
match=matchfn)
if opts.get('all'):
revs = alltransplants
else:
revs, newmerges = browserevs(ui, source, alltransplants, opts)
merges.extend(newmerges)
for r in revs:
revmap[source.changelog.rev(r)] = r
for r in merges:
revmap[source.changelog.rev(r)] = r
tp.apply(repo, source, revmap, merges, opts)
finally:
if cleanupfn:
cleanupfn()
def shelvecmd(ui, repo, *pats, **opts):
'''save and set aside changes from the working directory
Shelving takes files that "hg status" reports as not clean, saves
the modifications to a bundle (a shelved change), and reverts the
files so that their state in the working directory becomes clean.
To restore these changes to the working directory, using "hg
unshelve"; this will work even if you switch to a different
commit.
When no files are specified, "hg shelve" saves all not-clean
files. If specific files or directories are named, only changes to
those files are shelved.
Each shelved change has a name that makes it easier to find later.
The name of a shelved change defaults to being based on the active
bookmark, or if there is no active bookmark, the current named
branch. To specify a different name, use ``--name``.
To see a list of existing shelved changes, use the ``--list``
option. For each shelved change, this will print its name, age,
and description; use ``--patch`` or ``--stat`` for more details.
To delete specific shelved changes, use ``--delete``. To delete
all shelved changes, use ``--cleanup``.
'''
cmdutil.checkunfinished(repo)
allowables = [
('addremove', set(['create'])), # 'create' is pseudo action
('cleanup', set(['cleanup'])),
# ('date', set(['create'])), # ignored for passing '--date "0 0"' in tests
('delete', set(['delete'])),
('edit', set(['create'])),
('list', set(['list'])),
('message', set(['create'])),
('name', set(['create'])),
('patch', set(['patch', 'list'])),
('stat', set(['stat', 'list'])),
]
def checkopt(opt):
if opts[opt]:
for i, allowable in allowables:
if opts[i] and opt not in allowable:
raise error.Abort(_("options '--%s' and '--%s' may not be "
"used together") % (opt, i))
return True
if checkopt('cleanup'):
if pats:
raise error.Abort(_("cannot specify names when using '--cleanup'"))
return cleanupcmd(ui, repo)
elif checkopt('delete'):
return deletecmd(ui, repo, pats)
elif checkopt('list'):
return listcmd(ui, repo, pats, opts)
elif checkopt('patch'):
return singlepatchcmds(ui, repo, pats, opts, subcommand='patch')
elif checkopt('stat'):
return singlepatchcmds(ui, repo, pats, opts, subcommand='stat')
else:
return createcmd(ui, repo, pats, opts)
def histedit(ui, repo, *freeargs, **opts):
"""interactively edit changeset history
This command edits changesets between ANCESTOR and the parent of
the working directory.
With --outgoing, this edits changesets not found in the
destination repository. If URL of the destination is omitted, the
'default-push' (or 'default') path will be used.
For safety, this command is aborted, also if there are ambiguous
outgoing revisions which may confuse users: for example, there are
multiple branches containing outgoing revisions.
Use "min(outgoing() and ::.)" or similar revset specification
instead of --outgoing to specify edit target revision exactly in
such ambiguous situation. See :hg:`help revsets` for detail about
selecting revisions.
"""
# TODO only abort if we try and histedit mq patches, not just
# blanket if mq patches are applied somewhere
mq = getattr(repo, "mq", None)
if mq and mq.applied:
raise util.Abort(_("source has mq patches applied"))
# basic argument incompatibility processing
outg = opts.get("outgoing")
cont = opts.get("continue")
abort = opts.get("abort")
force = opts.get("force")
rules = opts.get("commands", "")
revs = opts.get("rev", [])
goal = "new" # This invocation goal, in new, continue, abort
if force and not outg:
raise util.Abort(_("--force only allowed with --outgoing"))
if cont:
if util.any((outg, abort, revs, freeargs, rules)):
raise util.Abort(_("no arguments allowed with --continue"))
goal = "continue"
elif abort:
if util.any((outg, revs, freeargs, rules)):
raise util.Abort(_("no arguments allowed with --abort"))
goal = "abort"
else:
if os.path.exists(os.path.join(repo.path, "histedit-state")):
raise util.Abort(_("history edit already in progress, try " "--continue or --abort"))
if outg:
if revs:
raise util.Abort(_("no revisions allowed with --outgoing"))
if len(freeargs) > 1:
raise util.Abort(_("only one repo argument allowed with --outgoing"))
else:
revs.extend(freeargs)
if len(revs) != 1:
raise util.Abort(_("histedit requires exactly one ancestor revision"))
if goal == "continue":
(parentctxnode, rules, keep, topmost, replacements) = readstate(repo)
parentctx = repo[parentctxnode]
parentctx, repl = bootstrapcontinue(ui, repo, parentctx, rules, opts)
replacements.extend(repl)
elif goal == "abort":
(parentctxnode, rules, keep, topmost, replacements) = readstate(repo)
mapping, tmpnodes, leafs, _ntm = processreplacement(repo, replacements)
ui.debug("restore wc to old parent %s\n" % node.short(topmost))
# check whether we should update away
parentnodes = [c.node() for c in repo[None].parents()]
for n in leafs | set([parentctxnode]):
if n in parentnodes:
hg.clean(repo, topmost)
break
else:
pass
cleanupnode(ui, repo, "created", tmpnodes)
cleanupnode(ui, repo, "temp", leafs)
os.unlink(os.path.join(repo.path, "histedit-state"))
return
else:
cmdutil.checkunfinished(repo)
cmdutil.bailifchanged(repo)
topmost, empty = repo.dirstate.parents()
if outg:
if freeargs:
remote = freeargs[0]
else:
remote = None
root = findoutgoing(ui, repo, remote, force, opts)
else:
root = revs[0]
root = scmutil.revsingle(repo, root).node()
keep = opts.get("keep", False)
revs = between(repo, root, topmost, keep)
if not revs:
raise util.Abort(_("%s is not an ancestor of working directory") % node.short(root))
ctxs = [repo[r] for r in revs]
if not rules:
rules = "\n".join([makedesc(c) for c in ctxs])
rules += "\n\n"
rules += editcomment % (node.short(root), node.short(topmost))
rules = ui.edit(rules, ui.username())
# Save edit rules in .hg/histedit-last-edit.txt in case
# the user needs to ask for help after something
# surprising happens.
f = open(repo.join("histedit-last-edit.txt"), "w")
f.write(rules)
f.close()
else:
if rules == "-":
f = sys.stdin
else:
f = open(rules)
rules = f.read()
f.close()
rules = [l for l in (r.strip() for r in rules.splitlines()) if l and not l[0] == "#"]
rules = verifyrules(rules, repo, ctxs)
parentctx = repo[root].parents()[0]
keep = opts.get("keep", False)
replacements = []
while rules:
writestate(repo, parentctx.node(), rules, keep, topmost, replacements)
action, ha = rules.pop(0)
ui.debug("histedit: processing %s %s\n" % (action, ha))
actfunc = actiontable[action]
parentctx, replacement_ = actfunc(ui, repo, parentctx, ha, opts)
replacements.extend(replacement_)
hg.update(repo, parentctx.node())
mapping, tmpnodes, created, ntm = processreplacement(repo, replacements)
if mapping:
for prec, succs in mapping.iteritems():
if not succs:
ui.debug("histedit: %s is dropped\n" % node.short(prec))
else:
ui.debug("histedit: %s is replaced by %s\n" % (node.short(prec), node.short(succs[0])))
if len(succs) > 1:
m = "histedit: %s"
for n in succs[1:]:
ui.debug(m % node.short(n))
if not keep:
if mapping:
movebookmarks(ui, repo, mapping, topmost, ntm)
# TODO update mq state
if obsolete._enabled:
markers = []
# sort by revision number because it sound "right"
for prec in sorted(mapping, key=repo.changelog.rev):
succs = mapping[prec]
markers.append((repo[prec], tuple(repo[s] for s in succs)))
if markers:
obsolete.createmarkers(repo, markers)
else:
cleanupnode(ui, repo, "replaced", mapping)
cleanupnode(ui, repo, "temp", tmpnodes)
os.unlink(os.path.join(repo.path, "histedit-state"))
if os.path.exists(repo.sjoin("undo")):
os.unlink(repo.sjoin("undo"))
def split(ui, repo, *revs, **opts):
"""split a changeset into smaller changesets
By default, split the current revision by prompting for all its hunks to be
redistributed into new changesets.
Use --rev to split a given changeset instead.
"""
tr = wlock = lock = None
newcommits = []
revarg = (list(revs) + opts.get('rev')) or ['.']
if len(revarg) != 1:
msg = _("more than one revset is given")
hnt = _("use either `hg split <rs>` or `hg split --rev <rs>`, not both")
raise error.Abort(msg, hint=hnt)
rev = scmutil.revsingle(repo, revarg[0])
if opts.get('no_rebase'):
torebase = ()
else:
torebase = repo.revs('descendants(%d) - (%d)', rev, rev)
try:
wlock = repo.wlock()
lock = repo.lock()
cmdutil.bailifchanged(repo)
if torebase:
cmdutil.checkunfinished(repo)
tr = repo.transaction('split')
ctx = repo[rev]
r = ctx.rev()
disallowunstable = not obsolete.isenabled(repo,
obsolete.allowunstableopt)
if disallowunstable:
# XXX We should check head revs
if repo.revs("(%d::) - %d", rev, rev):
raise error.Abort(_("cannot split commit: %s not a head") % ctx)
if len(ctx.parents()) > 1:
raise error.Abort(_("cannot split merge commits"))
prev = ctx.p1()
bmupdate = common.bookmarksupdater(repo, ctx.node(), tr)
bookactive = repo._activebookmark
if bookactive is not None:
repo.ui.status(_("(leaving bookmark %s)\n") % repo._activebookmark)
bookmarks.deactivate(repo)
hg.update(repo, prev)
commands.revert(ui, repo, rev=r, all=True)
def haschanges():
modified, added, removed, deleted = repo.status()[:4]
return modified or added or removed or deleted
msg = ("HG: This is the original pre-split commit message. "
"Edit it as appropriate.\n\n")
msg += ctx.description()
opts['message'] = msg
opts['edit'] = True
while haschanges():
pats = ()
cmdutil.dorecord(ui, repo, commands.commit, 'commit', False,
cmdutil.recordfilter, *pats, **opts)
# TODO: Does no seem like the best way to do this
# We should make dorecord return the newly created commit
newcommits.append(repo['.'])
if haschanges():
if ui.prompt('Done splitting? [yN]', default='n') == 'y':
commands.commit(ui, repo, **opts)
newcommits.append(repo['.'])
break
else:
ui.status(_("no more change to split\n"))
if newcommits:
tip = repo[newcommits[-1]]
bmupdate(tip.node())
if bookactive is not None:
bookmarks.activate(repo, bookactive)
obsolete.createmarkers(repo, [(repo[r], newcommits)],
operation='split')
if torebase:
top = repo.revs('allsuccessors(%d)', rev).last()
common.restackonce(ui, repo, top)
tr.close()
finally:
lockmod.release(tr, lock, wlock)
def wrappedpushdiscovery(orig, pushop):
"""Wraps exchange._pushdiscovery to add extra review metadata.
We discover what nodes to review before discovery. This ensures that
errors are discovered and reported quickly, without waiting for
server communication.
"""
pushop.reviewnodes = None
caps = getreviewcaps(pushop.remote)
if 'pushreview' not in caps:
return orig(pushop)
ui = pushop.ui
repo = pushop.repo
if repo.noreviewboardpush:
return orig(pushop)
# If no arguments are specified to push, Mercurial will try to push all
# non-remote changesets by default. This can result in unexpected behavior,
# especially for people doing multi-headed development.
#
# Since we reject pushes with multiple heads anyway, default to pushing
# the working copy.
if not pushop.revs:
pushop.revs = [repo['.'].node()]
tipnode = None
basenode = None
# Our prepushoutgoing hook validates that all pushed changesets are
# part of the same DAG head. If revisions were specified by the user,
# the last is the tip commit to review and the first (if more than 1)
# is the base commit to review.
#
# Note: the revisions are in the order they were specified by the user.
# This may not be DAG order. So we have to explicitly order them here.
revs = sorted(repo[r].rev() for r in pushop.revs)
tipnode = repo[revs[-1]].node()
if len(revs) > 1:
basenode = repo[revs[0]].node()
if repo.pushsingle:
basenode = tipnode
# Given a base and tip node, find all changesets to review.
#
# A solution that works most of the time is to find all non-public
# ancestors of that node. This is our default.
#
# If basenode is specified, we stop the traversal when we encounter it.
#
# Note that we will still refuse to review a public changeset even with
# basenode. This decision is somewhat arbitrary and can be revisited later
# if there is an actual need to review public changesets.
nodes = [tipnode]
# Special case where basenode is the tip node.
if basenode and tipnode == basenode:
pass
else:
for node in repo[tipnode].ancestors():
ctx = repo[node]
if ctx.phase() == phases.public:
break
if basenode and ctx.node() == basenode:
nodes.insert(0, ctx.node())
break
nodes.insert(0, ctx.node())
# Filter out public nodes.
publicnodes = []
for node in nodes:
ctx = repo[node]
if ctx.phase() == phases.public:
publicnodes.append(node)
ui.status(_('(ignoring public changeset %s in review request)\n') %
ctx.hex()[0:12])
nodes = [n for n in nodes if n not in publicnodes]
if not nodes:
raise util.Abort(
_('no non-public changesets left to review'),
hint=_('add or change the -r argument to include draft changesets'))
# We stop completely empty changesets prior to review.
for node in nodes:
ctx = repo[node]
if not ctx.files():
raise util.Abort(
_('cannot review empty changeset %s') % ctx.hex()[:12],
hint=_('add files to or remove changeset'))
run_android_checkstyle(repo, nodes)
# Ensure all reviewed changesets have commit IDs.
replacenodes = []
for node in nodes:
ctx = repo[node]
if not parse_commit_id(encoding.fromlocal(ctx.description())):
replacenodes.append(node)
def makememctx(repo, ctx, revmap, copyfilectxfn):
parents = newparents(repo, ctx, revmap)
# Need to make a copy otherwise modification is made on original,
# which is just plain wrong.
msg = encoding.fromlocal(ctx.description())
new_msg, changed = addcommitid(msg, repo=repo)
memctx = context.memctx(repo, parents,
encoding.tolocal(new_msg), ctx.files(),
copyfilectxfn, user=ctx.user(),
date=ctx.date(), extra=dict(ctx.extra()))
return memctx
if replacenodes:
ui.status(_('(adding commit id to %d changesets)\n') %
(len(replacenodes)))
nodemap = replacechangesets(repo, replacenodes, makememctx,
backuptopic='addcommitid')
# Since we're in the middle of an operation, update references
# to rewritten nodes.
nodes = [nodemap.get(node, node) for node in nodes]
pushop.revs = [nodemap.get(node, node) for node in pushop.revs]
pushop.reviewnodes = nodes
# Since we may rewrite changesets to contain review metadata after
# push, abort immediately if the working directory state is not
# compatible with rewriting. This prevents us from successfully
# pushing and failing to update commit metadata after the push. i.e.
# it prevents potential loss of metadata.
#
# There may be some scenarios where we don't rewrite after push.
# But coding that here would be complicated. And future server changes
# may change things like review request mapping, which may invalidate
# client assumptions. So always assume a rewrite is needed.
impactedrevs = list(repo.revs('%ln::', nodes))
if repo['.'].rev() in impactedrevs:
cmdutil.checkunfinished(repo)
cmdutil.bailifchanged(repo)
return orig(pushop)
def cmd_format_source(ui, repo, tool, *pats, **opts):
"""register a tool to format source files during merges and rebases
Record a mapping from the given file pattern FILES to a source formatting
tool TOOL. Mappings are stored in the version-controlled file
(automatically committed when format-source is used) .hg-format-source in
the root of the checkout. The mapping causes TOOL to be run on FILES during
future merge and rebase operations.
The actual command run for TOOL needs to be registered in the config. See
:hg:`help -e format-source` for details.
"""
if repo.getcwd():
msg = _("format-source must be run from repository root")
hint = _("cd %s") % repo.root
raise error.Abort(msg, hint=hint)
if not pats:
raise error.Abort(_('no files specified'))
# XXX We support glob pattern only for now, the recursive behavior of various others is a bit wonky.
for pattern in pats:
if not pattern.startswith('glob:'):
msg = _("format-source only supports explicit 'glob' patterns "
"for now ('%s')")
msg %= pattern
hint = _('maybe try with "glob:%s"') % pattern
raise error.Abort(msg, hint=hint)
# lock the repo to make sure no content is changed
with repo.wlock():
# formatting tool
if ' ' in tool:
raise error.Abort(_("tool name cannot contain space: '%s'") % tool)
# if tool was not specified in the cfg maybe we can use our mozilla firefox in tree
# clang-format and/or prettier tools
if should_use_default(repo, tool):
shell_tool, tool_config_files, file_ext = return_default_formatter(
repo, tool)
else:
shell_tool = repo.ui.config('format-source', tool)
tool_config_files = repo.ui.configlist('format-source',
'%s:configpaths' % tool)
file_ext = tuple(
repo.ui.configlist('format-source', '%s:fileext' % tool))
if not shell_tool:
msg = _("unknown format tool: %s (no 'format-source.%s' config)")
raise error.Abort(msg.format(tool, tool))
if not file_ext:
msg = _("no {}:fileext present".format(tool))
raise error.Abort(msg.format(tool, tool))
cmdutil.bailifchanged(repo)
cmdutil.checkunfinished(repo, commit=True)
wctx = repo[None]
# files to be formatted
matcher = scmutil.match(wctx, pats, opts)
files = list(wctx.matches(matcher))
if util.versiontuple(n=2) >= (4, 7):
# In 4.7 we have ui.makeprogress
with ui.makeprogress(_('formatting'),
unit=_('files'),
total=len(files)) as progress:
proc = worker.worker(ui, 0.1, batchformat,
(repo, wctx, tool, shell_tool, file_ext),
files)
for filepath in proc:
progress.increment(item=filepath)
else:
proc = worker.worker(ui, 0.1, batchformat,
(repo, wctx, tool, shell_tool, file_ext),
files)
# Wait for everything to finish
for filepath in proc:
pass
# update the storage to mark formatted file as formatted
with repo.wvfs(file_storage_path, mode='ab') as storage:
for pattern in pats:
# XXX if pattern was relative, we need to reroot it from the
# repository root. For now we constrained the command to run
# at the root of the repository.
data = {
'tool': encoding.unifromlocal(tool),
'pattern': encoding.unifromlocal(pattern)
}
if tool_config_files:
data['configpaths'] = [
encoding.unifromlocal(path)
for path in tool_config_files
]
entry = json.dumps(data, sort_keys=True)
assert '\n' not in entry
storage.write('%s\n' % entry)
if file_storage_path not in wctx:
storage_matcher = scmutil.match(wctx,
['path:' + file_storage_path])
cmdutiladd(ui, repo, storage_matcher)
# commit the whole
with repo.lock():
commit_patterns = ['path:' + file_storage_path]
commit_patterns.extend(pats)
return commands._docommit(ui, repo, *commit_patterns, **opts)
def replacechangesets(repo, oldnodes, createfn, backuptopic='replacing'):
"""Replace changesets with new versions.
This is a generic function used to perform history rewriting.
Given an iterable of input nodes, a function will be called which is
expected to produce a new changeset to replace the input node. The
function signature should be:
def createfn(repo, ctx, revmap, copyfilectxfn):
It is passed a repo, the changectx being rewritten, a map of old to new
revisions that have been changed so far, and a function that can be used
as the memctx callback for obtaining memfilectx when no file modifications
are to be performed (a common pattern). The function should return an
*uncommitted* memctx holding the new changeset info.
We currently restrict that the createfn callback must return a new
changeset and that no file changes may occur. Restricting file changes
satisfies the requirements this function was invented for and keeps the
implementation simple.
After the memctx is obtained, it is committed. Children changesets are
rebased automatically after all changesets have been rewritten.
After the old to new mapping is obtained, bookmarks are moved and old
changesets are made obsolete or stripped, depending on what is appropriate
for the repo configuration.
This function handles locking the repository and performing as many actions
in a transaction as possible.
Before any changes are made, we verify the state of the repo is sufficient
for transformation to occur and abort otherwise.
"""
if not oldnodes:
return {}
repo = repo.unfiltered()
# Validate function called properly.
for node in oldnodes:
if len(node) != 20:
raise util.Abort('replacechangesets expects 20 byte nodes')
uoldrevs = [repo[node].rev() for node in oldnodes]
oldrevs = sorted(uoldrevs)
if oldrevs != uoldrevs:
raise util.Abort('must pass oldnodes in changelog order')
# We may perform stripping and stripping inside a nested transaction
# is a recipe for disaster.
# currenttransaction was added in 3.3. Copy the implementation until we
# drop 3.2 compatibility.
if hasattr(repo, 'currenttransaction'):
intrans = repo.currenttransaction()
else:
if repo._transref and repo._transref().running():
intrans = True
else:
intrans = False
if intrans:
raise util.Abort('cannot call replacechangesets when a transaction '
'is active')
# The revisions impacted by the current operation. This is essentially
# all non-hidden children. We don't operate on hidden changesets because
# there is no point - they are hidden and deemed not important.
impactedrevs = list(repo.filtered('visible').revs('%ld::', oldrevs))
# If we'll need to update the working directory, don't do anything if there
# are uncommitted changes, as this could cause a giant mess (merge
# conflicts, etc). Note the comparison against impacted revs, as children
# of rewritten changesets will be rebased below.
dirstaterev = repo[repo.dirstate.p1()].rev()
if dirstaterev in impactedrevs:
cmdutil.checkunfinished(repo)
cmdutil.bailifchanged(repo)
obsenabled = False
if hasattr(obsolete, 'isenabled'):
obsenabled = obsolete.isenabled(repo, 'createmarkers')
else:
obsenabled = obsolete._enabled
def adjustphase(repo, tr, phase, node):
# transaction argument added in Mercurial 3.2.
try:
phases.advanceboundary(repo, tr, phase, [node])
phases.retractboundary(repo, tr, phase, [node])
except TypeError:
phases.advanceboundary(repo, phase, [node])
phases.retractboundary(repo, phase, [node])
nodemap = {}
wlock, lock, tr = None, None, None
try:
wlock = repo.wlock()
lock = repo.lock()
tr = repo.transaction('replacechangesets')
# Create the new changesets.
revmap = OrderedDict()
for oldnode in oldnodes:
oldctx = repo[oldnode]
# Copy revmap out of paranoia.
newctx = createfn(repo, oldctx, dict(revmap),
preservefilectx(oldctx))
if not isinstance(newctx, context.memctx):
raise util.Abort('createfn must return a context.memctx')
if oldctx == newctx:
raise util.Abort('createfn must create a new changeset')
newnode = newctx.commit()
# Needed so .manifestnode() works, which memctx doesn't have.
newctx = repo[newnode]
# This makes the implementation significantly simpler as we don't
# need to worry about merges when we do auto rebasing later.
if oldctx.manifestnode() != newctx.manifestnode():
raise util.Abort('we do not allow replacements to modify files')
revmap[oldctx.rev()] = newctx.rev()
nodemap[oldnode] = newnode
# Do phase adjustment ourselves because we want callbacks to be as
# dumb as possible.
adjustphase(repo, tr, oldctx.phase(), newctx.node())
# Children of rewritten changesets are impacted as well. Rebase as
# needed.
for rev in impactedrevs:
# It was handled by createfn() or by this loop already.
if rev in revmap:
continue
oldctx = repo[rev]
if oldctx.p1().rev() not in revmap:
raise util.Abort('unknown parent of child commit: %s' %
oldctx.hex(),
hint='please report this as a bug')
parents = newparents(repo, oldctx, revmap)
mctx = context.memctx(repo, parents, oldctx.description(),
oldctx.files(), preservefilectx(oldctx),
user=oldctx.user(), date=oldctx.date(),
extra=oldctx.extra())
status = oldctx.p1().status(oldctx)
mctx.modified = lambda: status[0]
mctx.added = lambda: status[1]
mctx.removed = lambda: status[2]
newnode = mctx.commit()
revmap[rev] = repo[newnode].rev()
nodemap[oldctx.node()] = newnode
# Retain phase.
adjustphase(repo, tr, oldctx.phase(), newnode)
ph = repo.ui.config('phases', 'new-commit')
try:
repo.ui.setconfig('phases', 'new-commit', oldctx.phase(),
'rewriting')
newnode = mctx.commit()
revmap[rev] = repo[newnode].rev()
finally:
repo.ui.setconfig('phases', 'new-commit', ph)
# Move bookmarks to new nodes.
bmchanges = []
oldactivebookmark = activebookmark(repo)
for oldrev, newrev in revmap.items():
oldnode = repo[oldrev].node()
for mark, bmnode in repo._bookmarks.items():
if bmnode == oldnode:
bmchanges.append((mark, repo[newrev].node()))
for mark, newnode in bmchanges:
repo._bookmarks[mark] = newnode
if bmchanges:
repo._bookmarks.recordchange(tr)
# Update references to rewritten MQ patches.
if hasattr(repo, 'mq'):
q = repo.mq
for e in q.applied:
if e.node in nodemap:
e.node = nodemap[e.node]
q.applieddirty = True
# This no-ops if nothing is dirty.
q.savedirty()
# If obsolescence is enabled, obsolete the old changesets.
if obsenabled:
markers = []
for oldrev, newrev in revmap.items():
markers.append((repo[oldrev], (repo[newrev],)))
obsolete.createmarkers(repo, markers)
# Move the working directory to the new node, if applicable.
wdirrev = repo['.'].rev()
if wdirrev in revmap:
hg.updaterepo(repo, repo[revmap[wdirrev]].node(), True)
# The active bookmark is tracked by its symbolic name, not its
# changeset. Since we didn't do anything that should change the
# active bookmark, we shouldn't need to adjust it.
if activebookmark(repo) != oldactivebookmark:
raise util.Abort('active bookmark changed; '
'this should not occur!',
hint='please file a bug')
tr.close()
# Unless obsolescence is enabled, strip the old changesets.
if not obsenabled:
stripnodes = [repo[rev].node() for rev in revmap.keys()]
repair.strip(repo.ui, repo, stripnodes, topic=backuptopic)
finally:
if tr:
tr.release()
lockmod.release(wlock, lock)
return nodemap
def wrappedpushdiscovery(orig, pushop):
"""Wraps exchange._pushdiscovery to add extra review metadata.
We discover what nodes to review before discovery. This ensures that
errors are discovered and reported quickly, without waiting for
server communication.
"""
pushop.reviewnodes = None
caps = getreviewcaps(pushop.remote)
if "pushreview" not in caps:
return orig(pushop)
ui = pushop.ui
repo = pushop.repo
if repo.noreviewboardpush:
return orig(pushop)
# If no arguments are specified to push, Mercurial will try to push all
# non-remote changesets by default. This can result in unexpected behavior,
# especially for people doing multi-headed development.
#
# Since we reject pushes with multiple heads anyway, default to pushing
# the working copy.
if not pushop.revs:
pushop.revs = [repo["."].node()]
tipnode = None
basenode = None
# Our prepushoutgoing hook validates that all pushed changesets are
# part of the same DAG head. If revisions were specified by the user,
# the last is the tip commit to review and the first (if more than 1)
# is the base commit to review.
#
# Note: the revisions are in the order they were specified by the user.
# This may not be DAG order. So we have to explicitly order them here.
revs = sorted(repo[r].rev() for r in pushop.revs)
tipnode = repo[revs[-1]].node()
if len(revs) > 1:
basenode = repo[revs[0]].node()
if repo.pushsingle:
basenode = tipnode
# Given a base and tip node, find all changesets to review.
#
# A solution that works most of the time is to find all non-public
# ancestors of that node. This is our default.
#
# If basenode is specified, we stop the traversal when we encounter it.
#
# Note that we will still refuse to review a public changeset even with
# basenode. This decision is somewhat arbitrary and can be revisited later
# if there is an actual need to review public changesets.
nodes = [tipnode]
# Special case where basenode is the tip node.
if basenode and tipnode == basenode:
pass
else:
for node in repo[tipnode].ancestors():
ctx = repo[node]
if ctx.phase() == phases.public:
break
if basenode and ctx.node() == basenode:
nodes.insert(0, ctx.node())
break
nodes.insert(0, ctx.node())
# Filter out public nodes.
publicnodes = []
for node in nodes:
ctx = repo[node]
if ctx.phase() == phases.public:
publicnodes.append(node)
ui.status(_("(ignoring public changeset %s in review request)\n") % ctx.hex()[0:12])
nodes = [n for n in nodes if n not in publicnodes]
if not nodes:
raise util.Abort(
_("no non-public changesets left to review"),
hint=_("add or change the -r argument to include draft changesets"),
)
# We stop completely empty changesets prior to review.
for node in nodes:
ctx = repo[node]
if not ctx.files():
raise util.Abort(
_("cannot review empty changeset %s") % ctx.hex()[:12], hint=_("add files to or remove changeset")
)
# Ensure all reviewed changesets have commit IDs.
replacenodes = []
for node in nodes:
ctx = repo[node]
if "commitid" not in ctx.extra():
replacenodes.append(node)
def addcommitid(repo, ctx, revmap, copyfilectxfn):
parents = newparents(repo, ctx, revmap)
# Need to make a copy otherwise modification is made on original,
# which is just plain wrong.
extra = dict(ctx.extra())
assert "commitid" not in extra
extra["commitid"] = genid(repo)
memctx = context.memctx(
repo, parents, ctx.description(), ctx.files(), copyfilectxfn, user=ctx.user(), date=ctx.date(), extra=extra
)
return memctx
if replacenodes:
ui.status(_("(adding commit id to %d changesets)\n") % (len(replacenodes)))
nodemap = replacechangesets(repo, replacenodes, addcommitid, backuptopic="addcommitid")
# Since we're in the middle of an operation, update references
# to rewritten nodes.
nodes = [nodemap.get(node, node) for node in nodes]
pushop.revs = [nodemap.get(node, node) for node in pushop.revs]
pushop.reviewnodes = nodes
# Since we may rewrite changesets to contain review metadata after
# push, abort immediately if the working directory state is not
# compatible with rewriting. This prevents us from successfully
# pushing and failing to update commit metadata after the push. i.e.
# it prevents potential loss of metadata.
#
# There may be some scenarios where we don't rewrite after push.
# But coding that here would be complicated. And future server changes
# may change things like review request mapping, which may invalidate
# client assumptions. So always assume a rewrite is needed.
impactedrevs = list(repo.revs("%ln::", nodes))
if repo["."].rev() in impactedrevs:
cmdutil.checkunfinished(repo)
cmdutil.bailifchanged(repo)
return orig(pushop)
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.
.. container:: verbose
Examples:
- move "local changes" (current commit back to branching point)
to the current branch tip after a pull::
hg rebase
- move a single changeset to the stable branch::
hg rebase -r 5f493448 -d stable
- splice a commit and all its descendants onto another part of history::
hg rebase --source c0c3 --dest 4cf9
- rebase everything on a branch marked by a bookmark onto the
default branch::
hg rebase --base myfeature --dest default
- collapse a sequence of changes into a single commit::
hg rebase --collapse -r 1520:1525 -d .
- move a named branch while preserving its name::
hg rebase -r "branch(featureX)" -d 1.3 --keepbranches
Returns 0 on success, 1 if nothing to rebase or there are
unresolved conflicts.
"""
originalwd = target = None
activebookmark = None
external = nullrev
state = {}
skipped = set()
targetancestors = set()
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)
e = opts.get('extrafn') # internal, used by e.g. hgsubversion
extrafns = [_savegraft]
if e:
extrafns = [e]
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 opts.get('interactive'):
msg = _("interactive history editing is supported by the "
"'histedit' extension (see \"hg help histedit\")")
raise util.Abort(msg)
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 broken state')
raise util.Abort(msg, hint=hint)
if abortf:
return abort(repo,
originalwd,
target,
state,
activebookmark=activebookmark)
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)
if not rebaseset:
ui.status(
_('empty "rev" revision set - '
'nothing to rebase\n'))
return 1
elif srcf:
src = scmutil.revrange(repo, [srcf])
if not src:
ui.status(
_('empty "source" revision set - '
'nothing to rebase\n'))
return 1
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 1
commonanc = repo.revs('ancestor(%ld, %d)', base, dest).first()
if commonanc is not None:
rebaseset = repo.revs('(%d::(%ld) - %d)::', commonanc,
base, commonanc)
else:
rebaseset = []
if not rebaseset:
# transform to list because smartsets are not comparable to
# lists. This should be improved to honor laziness of
# smartset.
if list(base) == [dest.rev()]:
if basef:
ui.status(
_('nothing to rebase - %s is both "base"'
' and destination\n') % dest)
else:
ui.status(
_('nothing to rebase - working directory '
'parent is also destination\n'))
elif not repo.revs('%ld - ::%d', base, dest):
if basef:
ui.status(
_('nothing to rebase - "base" %s is '
'already an ancestor of destination '
'%s\n') %
('+'.join(str(repo[r]) for r in base), dest))
else:
ui.status(
_('nothing to rebase - working '
'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 1
allowunstable = obsolete.isenabled(repo, obsolete.allowunstableopt)
if (not (keepf or allowunstable) 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'))
result = buildstate(repo, dest, rebaseset, collapsef)
if not result:
# Empty state built, nothing to rebase
ui.status(_('nothing to rebase\n'))
return 1
root = min(rebaseset)
if not keepf and not repo[root].mutable():
raise util.Abort(_("can't rebase public changeset %s") %
repo[root],
hint=_('see "hg help phases" for details'))
originalwd, target, state = result
if collapsef:
targetancestors = repo.changelog.ancestors([target],
inclusive=True)
external = externalparent(repo, state, targetancestors)
if dest.closesbranch() and not keepbranchesf:
ui.status(_('reopening closed branch head %s\n') % dest)
if keepbranchesf:
# insert _savebranch at the start of extrafns so if
# there's a user-provided extrafn it can clobber branch if
# desired
extrafns.insert(0, _savebranch)
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._activebookmark
if activebookmark:
bookmarks.deactivate(repo)
extrafn = _makeextrafn(extrafns)
sortedstate = sorted(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:
ui.status(_('rebasing %s\n') % desc)
ui.progress(_("rebasing"), pos, ("%d:%s" % (rev, ctx)),
_('changesets'), total)
p1, p2, base = 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', ''),
'rebase')
stats = rebasenode(repo, rev, p1, base, state,
collapsef, target)
if stats and stats[3] > 0:
raise error.InterventionRequired(
_('unresolved conflicts (see hg '
'resolve, then hg rebase --continue)'))
finally:
ui.setconfig('ui', 'forcemerge', '', 'rebase')
if not collapsef:
merging = p2 != nullrev
editform = cmdutil.mergeeditform(merging, 'rebase')
editor = cmdutil.getcommiteditor(editform=editform, **opts)
newnode = concludenode(repo,
rev,
p1,
p2,
extrafn=extrafn,
editor=editor)
else:
# Skip commit if we are collapsing
repo.dirstate.beginparentchange()
repo.setparents(repo[p1].node())
repo.dirstate.endparentchange()
newnode = None
# Update the state
if newnode is not None:
state[rev] = repo[newnode].rev()
ui.debug('rebased as %s\n' % short(newnode))
else:
ui.warn(
_('note: rebase of %d:%s created no changes '
'to commit\n') % (rev, ctx))
if not collapsef:
skipped.add(rev)
state[rev] = p1
ui.debug('next revision set to %s\n' % p1)
elif state[rev] == nullmerge:
ui.debug('ignoring null merge rebase of %s\n' % rev)
elif state[rev] == revignored:
ui.status(_('not rebasing ignored %s\n') % desc)
else:
ui.status(
_('already rebased %s as %s\n') % (desc, repo[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, state,
targetancestors)
editopt = opts.get('edit')
editform = 'rebase.collapse'
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()
editopt = True
editor = cmdutil.getcommiteditor(edit=editopt, editform=editform)
newnode = concludenode(repo,
rev,
p1,
external,
commitmsg=commitmsg,
extrafn=extrafn,
editor=editor)
if newnode is None:
newrev = target
else:
newrev = repo[newnode].rev()
for oldrev in state.iterkeys():
if state[oldrev] > nullmerge:
state[oldrev] = newrev
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()
# restore original working directory
# (we do this before stripping)
newwd = state.get(originalwd, originalwd)
if newwd < 0:
# original directory is a parent of rebase set root or ignored
newwd = 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)
if currentbookmarks:
updatebookmarks(repo, targetnode, nstate, currentbookmarks)
if activebookmark not in repo._bookmarks:
# active bookmark was divergent one and has been deleted
activebookmark = None
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['.'].node() == repo._bookmarks[activebookmark]):
bookmarks.activate(repo, activebookmark)
finally:
release(lock, wlock)
def transplant(ui, repo, *revs, **opts):
'''transplant changesets from another branch
Selected changesets will be applied on top of the current working
directory with the log of the original changeset. The changesets
are copied and will thus appear twice in the history with different
identities.
Consider using the graft command if everything is inside the same
repository - it will use merges and will usually give a better result.
Use the rebase extension if the changesets are unpublished and you want
to move them instead of copying them.
If --log is specified, log messages will have a comment appended
of the form::
(transplanted from CHANGESETHASH)
You can rewrite the changelog message with the --filter option.
Its argument will be invoked with the current changelog message as
$1 and the patch as $2.
--source/-s specifies another repository to use for selecting changesets,
just as if it temporarily had been pulled.
If --branch/-b is specified, these revisions will be used as
heads when deciding which changesets to transplant, just as if only
these revisions had been pulled.
If --all/-a is specified, all the revisions up to the heads specified
with --branch will be transplanted.
Example:
- transplant all changes up to REV on top of your current revision::
hg transplant --branch REV --all
You can optionally mark selected transplanted changesets as merge
changesets. You will not be prompted to transplant any ancestors
of a merged transplant, and you can merge descendants of them
normally instead of transplanting them.
Merge changesets may be transplanted directly by specifying the
proper parent changeset by calling :hg:`transplant --parent`.
If no merges or revisions are provided, :hg:`transplant` will
start an interactive changeset browser.
If a changeset application fails, you can fix the merge by hand
and then resume where you left off by calling :hg:`transplant
--continue/-c`.
'''
def incwalk(repo, csets, match=util.always):
for node in csets:
if match(node):
yield node
def transplantwalk(repo, dest, heads, match=util.always):
'''Yield all nodes that are ancestors of a head but not ancestors
of dest.
If no heads are specified, the heads of repo will be used.'''
if not heads:
heads = repo.heads()
ancestors = []
for head in heads:
ancestors.append(repo.changelog.ancestor(dest, head))
for node in repo.changelog.nodesbetween(ancestors, heads)[0]:
if match(node):
yield node
def checkopts(opts, revs):
if opts.get('continue'):
if opts.get('branch') or opts.get('all') or opts.get('merge'):
raise util.Abort(_('--continue is incompatible with '
'--branch, --all and --merge'))
return
if not (opts.get('source') or revs or
opts.get('merge') or opts.get('branch')):
raise util.Abort(_('no source URL, branch revision or revision '
'list provided'))
if opts.get('all'):
if not opts.get('branch'):
raise util.Abort(_('--all requires a branch revision'))
if revs:
raise util.Abort(_('--all is incompatible with a '
'revision list'))
checkopts(opts, revs)
if not opts.get('log'):
opts['log'] = ui.config('transplant', 'log')
if not opts.get('filter'):
opts['filter'] = ui.config('transplant', 'filter')
tp = transplanter(ui, repo)
if opts.get('edit'):
tp.editor = cmdutil.commitforceeditor
cmdutil.checkunfinished(repo)
p1, p2 = repo.dirstate.parents()
if len(repo) > 0 and p1 == revlog.nullid:
raise util.Abort(_('no revision checked out'))
if not opts.get('continue'):
if p2 != revlog.nullid:
raise util.Abort(_('outstanding uncommitted merges'))
m, a, r, d = repo.status()[:4]
if m or a or r or d:
raise util.Abort(_('outstanding local changes'))
sourcerepo = opts.get('source')
if sourcerepo:
peer = hg.peer(repo, opts, ui.expandpath(sourcerepo))
heads = map(peer.lookup, opts.get('branch', ()))
source, csets, cleanupfn = bundlerepo.getremotechanges(ui, repo, peer,
onlyheads=heads, force=True)
else:
source = repo
heads = map(source.lookup, opts.get('branch', ()))
cleanupfn = None
try:
if opts.get('continue'):
tp.resume(repo, source, opts)
return
tf = tp.transplantfilter(repo, source, p1)
if opts.get('prune'):
prune = set(source.lookup(r)
for r in scmutil.revrange(source, opts.get('prune')))
matchfn = lambda x: tf(x) and x not in prune
else:
matchfn = tf
merges = map(source.lookup, opts.get('merge', ()))
revmap = {}
if revs:
for r in scmutil.revrange(source, revs):
revmap[int(r)] = source.lookup(r)
elif opts.get('all') or not merges:
if source != repo:
alltransplants = incwalk(source, csets, match=matchfn)
else:
alltransplants = transplantwalk(source, p1, heads,
match=matchfn)
if opts.get('all'):
revs = alltransplants
else:
revs, newmerges = browserevs(ui, source, alltransplants, opts)
merges.extend(newmerges)
for r in revs:
revmap[source.changelog.rev(r)] = r
for r in merges:
revmap[source.changelog.rev(r)] = r
tp.apply(repo, source, revmap, merges, opts)
finally:
if cleanupfn:
cleanupfn()
def createcmd(ui, repo, pats, opts):
"""subcommand that creates a new shelve"""
with repo.wlock():
cmdutil.checkunfinished(repo)
return _docreatecmd(ui, repo, pats, opts)
def _moverelative(ui, repo, args, opts, reverse=False):
"""Update to a changeset relative to the current changeset.
Implements both `hg previous` and `hg next`.
Takes in a list of positional arguments and a dict of command line
options. (See help for `hg previous` and `hg next` to see which
arguments and flags are supported.)
Moves forward through history by default -- the behavior of `hg next`.
Setting reverse=True will change the behavior to that of `hg previous`.
"""
# Parse positional argument.
try:
n = int(args[0]) if args else 1
except ValueError:
raise error.Abort(_("argument must be an integer"))
if n <= 0:
return
if ui.configbool('fbamend', 'alwaysnewest'):
opts['newest'] = True
# Check that the given combination of arguments is valid.
if args:
if opts.get('bookmark', False):
raise error.Abort(_("cannot use both number and --bookmark"))
if opts.get('top', False):
raise error.Abort(_("cannot use both number and --top"))
if opts.get('bottom', False):
raise error.Abort(_("cannot use both number and --bottom"))
if opts.get('bookmark', False):
if opts.get('top', False):
raise error.Abort(_("cannot use both --top and --bookmark"))
if opts.get('bottom', False):
raise error.Abort(_("cannot use both --bottom and --bookmark"))
if opts.get('towards', False) and opts.get('top', False):
raise error.Abort(_("cannot use both --top and --towards"))
if opts.get('merge', False) and opts.get('rebase', False):
raise error.Abort(_("cannot use both --merge and --rebase"))
# Check if there is an outstanding operation or uncommited changes.
cmdutil.checkunfinished(repo)
if not opts.get('clean', False) and not opts.get('merge', False):
try:
cmdutil.bailifchanged(repo)
except error.Abort as e:
e.hint = _("use --clean to discard uncommitted changes "
"or --merge to bring them along")
raise
# If we have both --clean and --rebase, we need to discard any outstanding
# changes now before we attempt to perform any rebases.
if opts.get('clean') and opts.get('rebase'):
commands.update(ui, repo, rev=repo['.'].rev(), clean=True)
with repo.wlock(), repo.lock():
# Record the active bookmark, if any.
bookmark = repo._activebookmark
noactivate = opts.get('no_activate_bookmark', False)
movebookmark = opts.get('move_bookmark', False)
with repo.transaction('moverelative') as tr:
# Find the desired changeset. May potentially perform rebase.
try:
target = _findtarget(ui, repo, n, opts, reverse)
except error.InterventionRequired:
# Rebase failed. Need to manually close transaction to allow
# `hg rebase --continue` to work correctly.
tr.close()
raise
# Move the active bookmark if neccesary. Needs to happen before
# we update to avoid getting a 'leaving bookmark X' message.
if movebookmark and bookmark is not None:
_setbookmark(repo, tr, bookmark, target)
# Update to the target changeset.
commands.update(ui, repo, rev=target,
clean=opts.get('clean', False))
# Print out the changeset we landed on.
_showchangesets(ui, repo, revs=[target])
# Activate the bookmark on the new changeset.
if not noactivate and not movebookmark:
_activate(ui, repo, target)
def undo(ui, repo, *args, **opts):
"""perform an undo
Undoes an undoable command. An undoable command is one that changed at
least one of the following three: bookmarks, working copy parent or
changesets. Note that this specifically does not include commands like log.
It will include update if update changes the working copy parent (you update
to a changeset that isn't the current one). Note that commands that edit
public repos can't be undone (specifically push).
Undo does not preserve the working copy changes.
Use hg undo --preview for interactive preview. Use your left and right
arrow keys to explore possible states, hit enter to go to a state or q to
quit out of preview.
.. container:: verbose
Without the --absolute flag, your undos will be relative. This means
they will behave how you expect them to. If you run hg undo twice,
you will move back two repo states from where you ran your first hg
undo. You can use this in conjunction with `hg undo -n -1` to move up
and down repo states. Note that as soon as you execute a different
undoable command, which isn't hg undo or hg redo, any new undos or redos
will be relative to the state after this command.
If the undo extension was turned off and on again, you might loose the
ability to undo to certain repo states. Undoing to repo states before
the missing ones can be forced, but isn't advised unless its known how
the before and after states are connected.
Use keep to maintain working copy changes. With keep, undo mimics hg
unamend and hg uncommit. Specifically, files that exist currently that
don't exist at the repo state we are undoing to will remain in your
working copy but not in your changeset. Maintaining your working copy
has primarily two downsides: firstly your new working copy won't be
clean so you can't simply redo without cleaning your working copy.
Secondly, the operation may be slow if your working copy is large. If
unsure, its generally easier try undo without --keep first and redo if
you want to change this.
Branch limits the scope of an undo to a group of local (draft)
changectxs, identified by any one member of this group.
"""
reverseindex = opts.get("step")
relativeundo = not opts.get("absolute")
keep = opts.get("keep")
branch = opts.get("branch")
preview = opts.get("preview")
interactive = opts.get("interactive")
if interactive:
preview = True
repo = repo.unfiltered()
if branch and reverseindex != 1 and reverseindex != -1:
raise error.Abort(_("--branch with --index not supported"))
if relativeundo:
try:
reverseindex = _computerelative(repo, reverseindex,
absolute = not relativeundo,
branch = branch)
except IndexError:
raise error.Abort(_("cannot undo this far - undo extension was not"
" enabled"))
if branch and preview:
raise error.Abort(_("--branch with --preview not supported"))
if interactive:
cmdutil.checkunfinished(repo)
cmdutil.bailifchanged(repo)
class undopreview(interactiveui.viewframe):
def render(self):
ui = self.ui
ui.pushbuffer()
return_code = _preview(ui, self.repo, self.index)
if return_code == 1:
if self.index < 0:
self.index += 1
repo.ui.status(_("Already at newest repo state\a\n"))
elif self.index > 0:
self.index -= 1
repo.ui.status(_("Already at oldest repo state\a\n"))
_preview(ui, self.repo, self.index)
text = ui.config('undo', 'interactivehelptext',
"legend: red - to hide; green - to revive\n")
repo.ui.status(text)
repo.ui.status(_("<-: newer "
"->: older "
"q: abort "
"enter: confirm\n"))
return ui.popbuffer()
def rightarrow(self):
self.index += 1
def leftarrow(self):
self.index -= 1
def enter(self):
del opts["preview"]
del opts["interactive"]
opts["absolute"] = "absolute"
opts["step"] = self.index
undo(ui, repo, *args, **opts)
return
viewobj = undopreview(ui, repo, reverseindex)
interactiveui.view(viewobj)
return
elif preview:
_preview(ui, repo, reverseindex)
return
with repo.wlock(), repo.lock(), repo.transaction("undo"):
cmdutil.checkunfinished(repo)
cmdutil.bailifchanged(repo)
if not (opts.get("force") or _gapcheck(ui, repo, reverseindex)):
raise error.Abort(_("attempted risky undo across"
" missing history"))
_undoto(ui, repo, reverseindex, keep=keep, branch=branch)
# store undo data
# for absolute undos, think of this as a reset
# for relative undos, think of this as an update
_logundoredoindex(repo, reverseindex, branch)
def phabsend(ui, repo, *revs, **opts):
"""upload changesets to Phabricator
If there are multiple revisions specified, they will be send as a stack
with a linear dependencies relationship using the order specified by the
revset.
For the first time uploading changesets, local tags will be created to
maintain the association. After the first time, phabsend will check
obsstore and tags information so it can figure out whether to update an
existing Differential Revision, or create a new one.
If --amend is set, update commit messages so they have the
``Differential Revision`` URL, remove related tags. This is similar to what
arcanist will do, and is more desired in author-push workflows. Otherwise,
use local tags to record the ``Differential Revision`` association.
The --confirm option lets you confirm changesets before sending them. You
can also add following to your configuration file to make it default
behaviour::
[phabsend]
confirm = true
phabsend will check obsstore and the above association to decide whether to
update an existing Differential Revision, or create a new one.
"""
revs = list(revs) + opts.get(b'rev', [])
revs = scmutil.revrange(repo, revs)
if not revs:
raise error.Abort(_(b'phabsend requires at least one changeset'))
if opts.get(b'amend'):
cmdutil.checkunfinished(repo)
# {newnode: (oldnode, olddiff, olddrev}
oldmap = getoldnodedrevmap(repo, [repo[r].node() for r in revs])
confirm = ui.configbool(b'phabsend', b'confirm')
confirm |= bool(opts.get(b'confirm'))
if confirm:
confirmed = _confirmbeforesend(repo, revs, oldmap)
if not confirmed:
raise error.Abort(_(b'phabsend cancelled'))
actions = []
reviewers = opts.get(b'reviewer', [])
if reviewers:
phids = user_group_phids(repo, reviewers)
actions.append({b'type': b'reviewers.add', b'value': phids})
drevids = [] # [int]
diffmap = {} # {newnode: diff}
# Send patches one by one so we know their Differential Revision IDs and
# can provide dependency relationship
lastrevid = None
for rev in revs:
ui.debug(b'sending rev %d\n' % rev)
ctx = repo[rev]
acts = list(actions)
reviewers = list(commitparser.parse_reviewers(ctx.description()))
if reviewers:
phids = user_group_phids(repo, reviewers)
acts.append({b'type': b'reviewers.add', b'value': phids})
bugs = commitparser.parse_bugs(ctx.description())
if bugs:
acts.append({b'type': b'bugzilla.bug-id',
b'value': str(bugs[0]).encode('utf-8')})
# Get Differential Revision ID
oldnode, olddiff, revid = oldmap.get(ctx.node(), (None, None, None))
if oldnode != ctx.node() or opts.get(b'amend'):
# Create or update Differential Revision
revision, diff = createdifferentialrevision(
ctx, revid, lastrevid, oldnode, olddiff, acts)
diffmap[ctx.node()] = diff
newrevid = int(revision[r'object'][r'id'])
if revid:
action = b'updated'
else:
action = b'created'
# Create a local tag to note the association, if commit message
# does not have it already
m = _differentialrevisiondescre.search(ctx.description())
if not m or int(m.group(b'id')) != newrevid:
tagname = b'D%d' % newrevid
tags.tag(repo, tagname, ctx.node(), message=None, user=None,
date=None, local=True)
else:
# Nothing changed. But still set "newrevid" so the next revision
# could depend on this one.
newrevid = revid
action = b'skipped'
actiondesc = ui.label(
{b'created': _(b'created'),
b'skipped': _(b'skipped'),
b'updated': _(b'updated')}[action],
b'phabricator.action.%s' % action)
drevdesc = ui.label(b'D%s' % newrevid, b'phabricator.drev')
nodedesc = ui.label(bytes(ctx), b'phabricator.node')
desc = ui.label(ctx.description().split(b'\n')[0], b'phabricator.desc')
ui.write(_(b'%s - %s - %s: %s\n') % (drevdesc, actiondesc, nodedesc,
desc))
drevids.append(newrevid)
lastrevid = newrevid
# Update commit messages and remove tags
if opts.get(b'amend'):
unfi = repo.unfiltered()
drevs = callconduit(repo, b'differential.query', {b'ids': drevids})
with repo.wlock(), repo.lock(), repo.transaction(b'phabsend'):
wnode = unfi[b'.'].node()
mapping = {} # {oldnode: [newnode]}
for i, rev in enumerate(revs):
old = unfi[rev]
drevid = drevids[i]
drev = [d for d in drevs if int(d[r'id']) == drevid][0]
newdesc = getdescfromdrev(drev)
# Make sure commit message contain "Differential Revision"
if old.description() != newdesc:
parents = [
mapping.get(old.p1().node(), (old.p1(),))[0],
mapping.get(old.p2().node(), (old.p2(),))[0],
]
new = context.metadataonlyctx(
repo, old, parents=parents, text=newdesc,
user=old.user(), date=old.date(), extra=old.extra())
newnode = new.commit()
mapping[old.node()] = [newnode]
# Update diff property
writediffproperties(unfi[newnode], diffmap[old.node()])
# Remove local tags since it's no longer necessary
tagname = b'D%d' % drevid
if tagname in repo.tags():
tags.tag(repo, tagname, nullid, message=None, user=None,
date=None, local=True)
scmutil.cleanupnodes(repo, mapping, b'phabsend')
if wnode in mapping:
unfi.setparents(mapping[wnode][0])
def replacechangesets(repo, oldnodes, createfn, backuptopic='replacing'):
"""Replace changesets with new versions.
This is a generic function used to perform history rewriting.
Given an iterable of input nodes, a function will be called which is
expected to produce a new changeset to replace the input node. The
function signature should be:
def createfn(repo, ctx, revmap, copyfilectxfn):
It is passed a repo, the changectx being rewritten, a map of old to new
revisions that have been changed so far, and a function that can be used
as the memctx callback for obtaining memfilectx when no file modifications
are to be performed (a common pattern). The function should return an
*uncommitted* memctx holding the new changeset info.
We currently restrict that the createfn callback must return a new
changeset and that no file changes may occur. Restricting file changes
satisfies the requirements this function was invented for and keeps the
implementation simple.
After the memctx is obtained, it is committed. Children changesets are
rebased automatically after all changesets have been rewritten.
After the old to new mapping is obtained, bookmarks are moved and old
changesets are made obsolete or stripped, depending on what is appropriate
for the repo configuration.
This function handles locking the repository and performing as many actions
in a transaction as possible.
Before any changes are made, we verify the state of the repo is sufficient
for transformation to occur and abort otherwise.
"""
if not oldnodes:
return {}
repo = repo.unfiltered()
# Validate function called properly.
for node in oldnodes:
if len(node) != 20:
raise error.Abort('replacechangesets expects 20 byte nodes')
uoldrevs = [repo[node].rev() for node in oldnodes]
oldrevs = sorted(uoldrevs)
if oldrevs != uoldrevs:
raise error.Abort('must pass oldnodes in changelog order')
# We may perform stripping and stripping inside a nested transaction
# is a recipe for disaster.
# currenttransaction was added in 3.3. Copy the implementation until we
# drop 3.2 compatibility.
if hasattr(repo, 'currenttransaction'):
intrans = repo.currenttransaction()
else:
if repo._transref and repo._transref().running():
intrans = True
else:
intrans = False
if intrans:
raise error.Abort('cannot call replacechangesets when a transaction '
'is active')
# The revisions impacted by the current operation. This is essentially
# all non-hidden children. We don't operate on hidden changesets because
# there is no point - they are hidden and deemed not important.
impactedrevs = list(repo.filtered('visible').revs('%ld::', oldrevs))
# If we'll need to update the working directory, don't do anything if there
# are uncommitted changes, as this could cause a giant mess (merge
# conflicts, etc). Note the comparison against impacted revs, as children
# of rewritten changesets will be rebased below.
dirstaterev = repo[repo.dirstate.p1()].rev()
if dirstaterev in impactedrevs:
cmdutil.checkunfinished(repo)
cmdutil.bailifchanged(repo)
obsenabled = False
if hasattr(obsolete, 'isenabled'):
obsenabled = obsolete.isenabled(repo, 'createmarkers')
else:
obsenabled = obsolete._enabled
def adjustphase(repo, tr, phase, node):
# transaction argument added in Mercurial 3.2.
try:
phases.advanceboundary(repo, tr, phase, [node])
phases.retractboundary(repo, tr, phase, [node])
except TypeError:
phases.advanceboundary(repo, phase, [node])
phases.retractboundary(repo, phase, [node])
nodemap = {}
wlock, lock, tr = None, None, None
try:
wlock = repo.wlock()
lock = repo.lock()
tr = repo.transaction('replacechangesets')
# Create the new changesets.
revmap = OrderedDict()
for oldnode in oldnodes:
oldctx = repo[oldnode]
# Copy revmap out of paranoia.
newctx = createfn(repo, oldctx, dict(revmap),
preservefilectx(oldctx))
if not isinstance(newctx, context.memctx):
raise error.Abort('createfn must return a context.memctx')
if oldctx == newctx:
raise error.Abort('createfn must create a new changeset')
newnode = newctx.commit()
# Needed so .manifestnode() works, which memctx doesn't have.
newctx = repo[newnode]
# This makes the implementation significantly simpler as we don't
# need to worry about merges when we do auto rebasing later.
if oldctx.manifestnode() != newctx.manifestnode():
raise error.Abort(
'we do not allow replacements to modify files')
revmap[oldctx.rev()] = newctx.rev()
nodemap[oldnode] = newnode
# Do phase adjustment ourselves because we want callbacks to be as
# dumb as possible.
adjustphase(repo, tr, oldctx.phase(), newctx.node())
# Children of rewritten changesets are impacted as well. Rebase as
# needed.
for rev in impactedrevs:
# It was handled by createfn() or by this loop already.
if rev in revmap:
continue
oldctx = repo[rev]
if oldctx.p1().rev() not in revmap:
raise error.Abort('unknown parent of child commit: %s' %
oldctx.hex(),
hint='please report this as a bug')
parents = newparents(repo, oldctx, revmap)
mctx = context.memctx(repo,
parents,
oldctx.description(),
oldctx.files(),
preservefilectx(oldctx),
user=oldctx.user(),
date=oldctx.date(),
extra=oldctx.extra())
status = oldctx.p1().status(oldctx)
mctx.modified = lambda: status[0]
mctx.added = lambda: status[1]
mctx.removed = lambda: status[2]
newnode = mctx.commit()
revmap[rev] = repo[newnode].rev()
nodemap[oldctx.node()] = newnode
# Retain phase.
adjustphase(repo, tr, oldctx.phase(), newnode)
ph = repo.ui.config('phases', 'new-commit')
try:
repo.ui.setconfig('phases', 'new-commit', oldctx.phase(),
'rewriting')
newnode = mctx.commit()
revmap[rev] = repo[newnode].rev()
finally:
repo.ui.setconfig('phases', 'new-commit', ph)
# Move bookmarks to new nodes.
bmchanges = []
oldactivebookmark = activebookmark(repo)
for oldrev, newrev in revmap.items():
oldnode = repo[oldrev].node()
for mark, bmnode in repo._bookmarks.items():
if bmnode == oldnode:
bmchanges.append((mark, repo[newrev].node()))
if bmchanges:
# TODO unconditionally call applychanges() when support for
# Mercurial 4.1 is dropped.
if util.safehasattr(repo._bookmarks, 'applychanges'):
repo._bookmarks.applychanges(repo, tr, bmchanges)
else:
for mark, newnode in bmchanges:
repo._bookmarks[mark] = newnode
repo._bookmarks.recordchange(tr)
# Update references to rewritten MQ patches.
if hasattr(repo, 'mq'):
q = repo.mq
for e in q.applied:
if e.node in nodemap:
e.node = nodemap[e.node]
q.applieddirty = True
# This no-ops if nothing is dirty.
q.savedirty()
# If obsolescence is enabled, obsolete the old changesets.
if obsenabled:
markers = []
for oldrev, newrev in revmap.items():
if repo[oldrev] != repo[newrev]:
markers.append((repo[oldrev], (repo[newrev], )))
if markers:
obsolete.createmarkers(repo, markers)
# Move the working directory to the new node, if applicable.
wdirrev = repo['.'].rev()
if wdirrev in revmap:
hg.updaterepo(repo, repo[revmap[wdirrev]].node(), True)
# The active bookmark is tracked by its symbolic name, not its
# changeset. Since we didn't do anything that should change the
# active bookmark, we shouldn't need to adjust it.
if activebookmark(repo) != oldactivebookmark:
raise error.Abort(
'active bookmark changed; '
'this should not occur!',
hint='please file a bug')
tr.close()
# Unless obsolescence is enabled, strip any obsolete changesets.
if not obsenabled:
stripnodes = []
for oldrev, newrev in revmap.items():
if repo[oldrev] != repo[newrev]:
stripnodes.append(repo[oldrev].node())
if stripnodes:
repair.strip(repo.ui, repo, stripnodes, topic=backuptopic)
finally:
if tr:
tr.release()
lockmod.release(wlock, lock)
return nodemap
