def unshelveabort(ui, repo, state, opts):
"""subcommand that abort an in-progress unshelve"""
wlock = repo.wlock()
lock = None
try:
checkparents(repo, state)
util.rename(repo.join('unshelverebasestate'),
repo.join('rebasestate'))
try:
rebase.rebase(ui, repo, **{
'abort' : True
})
except Exception:
util.rename(repo.join('rebasestate'),
repo.join('unshelverebasestate'))
raise
lock = repo.lock()
mergefiles(ui, repo, state.wctx, state.pendingctx)
repair.strip(ui, repo, state.stripnodes, backup='none', topic='shelve')
shelvedstate.clear(repo)
ui.warn(_("unshelve of '%s' aborted\n") % state.name)
finally:
lockmod.release(lock, wlock)
def unshelvecontinue(ui, repo, state, opts):
"""subcommand to continue an in-progress unshelve"""
# We're finishing off a merge. First parent is our original
# parent, second is the temporary "fake" commit we're unshelving.
with repo.lock():
checkparents(repo, state)
ms = merge.mergestate.read(repo)
if [f for f in ms if ms[f] == 'u']:
raise error.Abort(
_("unresolved conflicts, can't continue"),
hint=_("see 'hg resolve', then 'hg unshelve --continue'"))
util.rename(repo.join('unshelverebasestate'), repo.join('rebasestate'))
try:
rebase.rebase(ui, repo, **{'continue': True})
except Exception:
util.rename(repo.join('rebasestate'),
repo.join('unshelverebasestate'))
raise
shelvectx = repo['tip']
if not shelvectx in state.pendingctx.children():
# rebase was a no-op, so it produced no child commit
shelvectx = state.pendingctx
else:
# only strip the shelvectx if the rebase produced it
state.stripnodes.append(shelvectx.node())
mergefiles(ui, repo, state.wctx, shelvectx)
repair.strip(ui, repo, state.stripnodes, backup=False, topic='shelve')
shelvedstate.clear(repo)
unshelvecleanup(ui, repo, state.name, opts)
ui.status(_("unshelve of '%s' complete\n") % state.name)
def unshelveabort(ui, repo, state, opts):
"""subcommand that abort an in-progress unshelve"""
wlock = repo.wlock()
lock = None
try:
checkparents(repo, state)
util.rename(repo.join('unshelverebasestate'),
repo.join('rebasestate'))
try:
rebase.rebase(ui, repo, **{
'abort' : True
})
except Exception:
util.rename(repo.join('rebasestate'),
repo.join('unshelverebasestate'))
raise
lock = repo.lock()
mergefiles(ui, repo, state.wctx, state.pendingctx)
repair.strip(ui, repo, state.stripnodes, backup=False, topic='shelve')
shelvedstate.clear(repo)
ui.warn(_("unshelve of '%s' aborted\n") % state.name)
finally:
lockmod.release(lock, wlock)
def _rebaserestoredcommit(ui, repo, opts, tr, oldtiprev, basename, pctx,
tmpwctx, shelvectx, branchtorestore,
activebookmark, obsshelve):
"""Rebase restored commit from its original location to a destination"""
# 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():
# shelvectx is immediately on top of the tmpwctx
return shelvectx
# we need a new commit extra every time we perform a rebase to ensure
# that "nothing to rebase" does not happen with obs-based shelve
# "nothing to rebase" means that tip does not point to a "successor"
# commit after a rebase and we have no way to learn which commit
# should be a "shelvectx". this is a dirty hack until we implement
# some way to learn the results of rebase operation, other than
# text output and return code
def extrafn(ctx, extra):
extra['unshelve_time'] = str(time.time())
ui.status(_('rebasing shelved changes\n'))
try:
# we only want keep to be true if shelve is traditional, since
# for obs-based shelve, rebase will also be obs-based and
# markers created help us track the relationship between shelvectx
# and its new version
rebase.rebase(ui, repo, **{
'rev': [shelvectx.rev()],
'dest': str(tmpwctx.rev()),
'keep': not obsshelve,
'tool': opts.get('tool', ''),
'extrafn': extrafn if obsshelve else None
})
except error.InterventionRequired:
tr.close()
nodestoremove = [repo.changelog.node(rev)
for rev in xrange(oldtiprev, len(repo))]
shelvedstate.save(repo, basename, pctx, tmpwctx, nodestoremove,
branchtorestore, opts.get('keep'), activebookmark,
obsshelve)
repo.vfs.rename('rebasestate', '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
return shelvectx
def debugbruterebase(ui, repo, source, dest):
"""for every non-empty subset of source, run rebase -r subset -d dest
Print one line summary for each subset. Assume obsstore is enabled.
"""
srevs = list(repo.revs(source))
with repo.wlock(), repo.lock():
repolen = len(repo)
cl = repo.changelog
def getdesc(rev):
result = cl.changelogrevision(rev).description
if rev >= repolen:
result += b"'"
return result
for i in xrange(1, 2**len(srevs)):
subset = [rev for j, rev in enumerate(srevs) if i & (1 << j) != 0]
spec = revsetlang.formatspec(b'%ld', subset)
tr = repo.transaction(b'rebase')
tr.report = lambda x: 0 # hide "transaction abort"
ui.pushbuffer()
try:
rebase.rebase(ui, repo, dest=dest, rev=[spec])
except error.Abort as ex:
summary = b'ABORT: %s' % ex
except Exception as ex:
summary = b'CRASH: %s' % ex
else:
# short summary about new nodes
cl = repo.changelog
descs = []
for rev in xrange(repolen, len(repo)):
desc = b'%s:' % getdesc(rev)
for prev in cl.parentrevs(rev):
if prev > -1:
desc += getdesc(prev)
descs.append(desc)
descs.sort()
summary = b' '.join(descs)
ui.popbuffer()
repo.vfs.tryunlink(b'rebasestate')
subsetdesc = b''.join(getdesc(rev) for rev in subset)
ui.write((b'%s: %s\n') % (subsetdesc.rjust(len(srevs)), summary))
tr.abort()
def override_pull(orig, ui, repo, source=None, **opts):
if opts.get('rebase', False):
repo._isrebasing = True
try:
if opts.get('update'):
del opts['update']
ui.debug('--update and --rebase are not compatible, ignoring '
'the update flag\n')
del opts['rebase']
cmdutil.bailifchanged(repo)
revsprepull = len(repo)
origpostincoming = commands.postincoming
def _dummy(*args, **kwargs):
pass
commands.postincoming = _dummy
repo.lfpullsource = source
if not source:
source = 'default'
try:
result = commands.pull(ui, repo, source, **opts)
finally:
commands.postincoming = origpostincoming
revspostpull = len(repo)
if revspostpull > revsprepull:
result = result or rebase.rebase(ui, repo)
finally:
repo._isrebasing = False
else:
repo.lfpullsource = source
if not source:
source = 'default'
result = orig(ui, repo, source, **opts)
return result
def override_pull(orig, ui, repo, source=None, **opts):
if opts.get('rebase', False):
repo._isrebasing = True
try:
if opts.get('update'):
del opts['update']
ui.debug('--update and --rebase are not compatible, ignoring '
'the update flag\n')
del opts['rebase']
cmdutil.bailifchanged(repo)
revsprepull = len(repo)
origpostincoming = commands.postincoming
def _dummy(*args, **kwargs):
pass
commands.postincoming = _dummy
repo.lfpullsource = source
if not source:
source = 'default'
try:
result = commands.pull(ui, repo, source, **opts)
finally:
commands.postincoming = origpostincoming
revspostpull = len(repo)
if revspostpull > revsprepull:
result = result or rebase.rebase(ui, repo)
finally:
repo._isrebasing = False
else:
repo.lfpullsource = source
if not source:
source = 'default'
result = orig(ui, repo, source, **opts)
return result
def restack(ui, repo, rebaseopts=None):
"""Repair a situation in which one or more changesets in a stack
have been obsoleted (thereby leaving their descendants in the stack
unstable) by finding any such changesets and rebasing their descendants
onto the latest version of each respective changeset.
"""
rebaseopts = (rebaseopts or {}).copy()
# TODO: Remove config override after https://phab.mercurial-scm.org/D1063
config = {('experimental', 'rebase.multidest'): True}
with ui.configoverride(config), repo.wlock(), repo.lock():
# Find drafts connected to the current stack via either changelog or
# obsolete graph. Note: "draft() & ::." is optimized by D441.
# 1. Connect drafts via changelog
revs = list(repo.revs('(draft() & ::.)::'))
if not revs:
# "." is probably public. Check its direct children.
revs = repo.revs('draft() & children(.)')
if not revs:
ui.status(_('nothing to restack\n'))
return 1
# 2. Connect revs via obsolete graph
revs = list(repo.revs('successors(%ld)+allpredecessors(%ld)',
revs, revs))
# 3. Connect revs via changelog again to cover missing revs
revs = list(repo.revs('(draft() & ::%ld)::', revs))
rebaseopts['rev'] = [revsetlang.formatspec('%ld', revs)]
rebaseopts['dest'] = '_destrestack(SRC)'
rebase.rebase(ui, repo, **rebaseopts)
# Ensure that we always end up on the latest version of the
# current changeset. Usually, this will be taken care of
# by the rebase operation. However, in some cases (such as
# if we are on the precursor of the base changeset) the
# rebase will not update to the latest version, so we need
# to do this manually.
successor = repo.revs('allsuccessors(.)').last()
if successor is not None:
commands.update(ui, repo, rev=successor)
def unshelvecontinue(ui, repo, state, opts):
"""subcommand to continue an in-progress unshelve"""
# We're finishing off a merge. First parent is our original
# parent, second is the temporary "fake" commit we're unshelving.
wlock = repo.wlock()
lock = None
try:
checkparents(repo, state)
ms = merge.mergestate(repo)
if [f for f in ms if ms[f] == 'u']:
raise error.Abort(
_("unresolved conflicts, can't continue"),
hint=_("see 'hg resolve', then 'hg unshelve --continue'"))
lock = repo.lock()
util.rename(repo.join('unshelverebasestate'),
repo.join('rebasestate'))
try:
rebase.rebase(ui, repo, **{
'continue' : True
})
except Exception:
util.rename(repo.join('rebasestate'),
repo.join('unshelverebasestate'))
raise
shelvectx = repo['tip']
if not shelvectx in state.pendingctx.children():
# rebase was a no-op, so it produced no child commit
shelvectx = state.pendingctx
else:
# only strip the shelvectx if the rebase produced it
state.stripnodes.append(shelvectx.node())
mergefiles(ui, repo, state.wctx, shelvectx)
repair.strip(ui, repo, state.stripnodes, backup=False, topic='shelve')
shelvedstate.clear(repo)
unshelvecleanup(ui, repo, state.name, opts)
ui.status(_("unshelve of '%s' complete\n") % state.name)
finally:
lockmod.release(lock, wlock)
def unshelvecontinue(ui, repo, state, opts):
"""subcommand to continue an in-progress unshelve"""
# We're finishing off a merge. First parent is our original
# parent, second is the temporary "fake" commit we're unshelving.
with repo.lock():
checkparents(repo, state)
ms = merge.mergestate.read(repo)
if [f for f in ms if ms[f] == 'u']:
raise error.Abort(
_("unresolved conflicts, can't continue"),
hint=_("see 'hg resolve', then 'hg unshelve --continue'"))
repo.vfs.rename('unshelverebasestate', 'rebasestate')
try:
# if shelve is obs-based, we want rebase to be able
# to create markers to already-obsoleted commits
_repo = repo.unfiltered() if state.obsshelve else repo
with ui.configoverride({('experimental', 'rebaseskipobsolete'):
'off'}, 'unshelve'):
rebase.rebase(ui, _repo, **{
'continue' : True,
})
except Exception:
repo.vfs.rename('rebasestate', 'unshelverebasestate')
raise
shelvectx = repo['tip']
if not shelvectx in state.pendingctx.children():
# rebase was a no-op, so it produced no child commit
shelvectx = state.pendingctx
else:
# only strip the shelvectx if the rebase produced it
state.nodestoremove.append(shelvectx.node())
mergefiles(ui, repo, state.wctx, shelvectx)
restorebranch(ui, repo, state.branchtorestore)
state.removenodes(ui, repo)
_restoreactivebookmark(repo, state.activebookmark)
shelvedstate.clear(repo)
unshelvecleanup(ui, repo, state.name, opts)
ui.status(_("unshelve of '%s' complete\n") % state.name)
def unshelveabort(ui, repo, state, opts):
"""subcommand that abort an in-progress unshelve"""
with repo.lock():
try:
checkparents(repo, state)
repo.vfs.rename('unshelverebasestate', 'rebasestate')
try:
rebase.rebase(ui, repo, **{
'abort' : True
})
except Exception:
repo.vfs.rename('rebasestate', 'unshelverebasestate')
raise
mergefiles(ui, repo, state.wctx, state.pendingctx)
state.removenodes(ui, repo)
finally:
shelvedstate.clear(repo)
ui.warn(_("unshelve of '%s' aborted\n") % state.name)
def restackonce(ui, repo, rev, rebaseopts=None, childrenonly=False):
"""Rebase all descendants of precursors of rev onto rev, thereby
stabilzing any non-obsolete descendants of those precursors.
Takes in an optional dict of options for the rebase command.
If childrenonly is True, only rebases direct children of precursors
of rev rather than all descendants of those precursors.
"""
# Get visible descendants of precusors of rev.
# Excluding obsoleted changesets avoids divergence issues.
allpredecessors = repo.revs('allpredecessors(%d)', rev)
fmt = ('%s(%%ld) - %%ld - obsolete()'
% ('children' if childrenonly else 'descendants'))
descendants = repo.revs(fmt, allpredecessors, allpredecessors)
# Nothing to do if there are no descendants.
if not descendants:
return
# Overwrite source and destination, leave all other options.
if rebaseopts is None:
rebaseopts = {}
rebaseopts['rev'] = descendants
rebaseopts['dest'] = rev
# We need to ensure that the 'operation' field in the obsmarker metadata
# is always set to 'rebase', regardless of the current command so that
# the restacked commits will appear as 'rebased' in smartlog.
overrides = {}
try:
tweakdefaults = extensions.find('tweakdefaults')
except KeyError:
# No tweakdefaults extension -- skip this since there is no wrapper
# to set the metadata.
pass
else:
overrides[(tweakdefaults.globaldata,
tweakdefaults.createmarkersoperation)] = 'rebase'
# Perform rebase.
with repo.ui.configoverride(overrides, 'restack'):
rebase.rebase(ui, repo, **rebaseopts)
def override_pull(orig, ui, repo, source=None, **opts):
if opts.get('rebase', False):
repo._isrebasing = True
try:
if opts.get('update'):
del opts['update']
ui.debug('--update and --rebase are not compatible, ignoring '
'the update flag\n')
del opts['rebase']
cmdutil.bailifchanged(repo)
revsprepull = len(repo)
origpostincoming = commands.postincoming
def _dummy(*args, **kwargs):
pass
commands.postincoming = _dummy
repo.lfpullsource = source
if not source:
source = 'default'
try:
result = commands.pull(ui, repo, source, **opts)
finally:
commands.postincoming = origpostincoming
revspostpull = len(repo)
if revspostpull > revsprepull:
result = result or rebase.rebase(ui, repo)
finally:
repo._isrebasing = False
else:
repo.lfpullsource = source
if not source:
source = 'default'
oldheads = lfutil.getcurrentheads(repo)
result = orig(ui, repo, source, **opts)
# If we do not have the new largefiles for any new heads we pulled, we
# will run into a problem later if we try to merge or rebase with one of
# these heads, so cache the largefiles now direclty into the system
# cache.
ui.status(_("caching new largefiles\n"))
numcached = 0
heads = lfutil.getcurrentheads(repo)
newheads = set(heads).difference(set(oldheads))
for head in newheads:
(cached, missing) = lfcommands.cachelfiles(ui, repo, head)
numcached += len(cached)
ui.status(_("%d largefiles cached\n") % numcached)
return result
def override_pull(orig, ui, repo, source=None, **opts):
if opts.get("rebase", False):
repo._isrebasing = True
try:
if opts.get("update"):
del opts["update"]
ui.debug("--update and --rebase are not compatible, ignoring " "the update flag\n")
del opts["rebase"]
cmdutil.bailifchanged(repo)
revsprepull = len(repo)
origpostincoming = commands.postincoming
def _dummy(*args, **kwargs):
pass
commands.postincoming = _dummy
repo.lfpullsource = source
if not source:
source = "default"
try:
result = commands.pull(ui, repo, source, **opts)
finally:
commands.postincoming = origpostincoming
revspostpull = len(repo)
if revspostpull > revsprepull:
result = result or rebase.rebase(ui, repo)
finally:
repo._isrebasing = False
else:
repo.lfpullsource = source
if not source:
source = "default"
oldheads = lfutil.getcurrentheads(repo)
result = orig(ui, repo, source, **opts)
# If we do not have the new largefiles for any new heads we pulled, we
# will run into a problem later if we try to merge or rebase with one of
# these heads, so cache the largefiles now direclty into the system
# cache.
ui.status(_("caching new largefiles\n"))
numcached = 0
heads = lfutil.getcurrentheads(repo)
newheads = set(heads).difference(set(oldheads))
for head in newheads:
(cached, missing) = lfcommands.cachelfiles(ui, repo, head)
numcached += len(cached)
ui.status(_("%d largefiles cached\n") % numcached)
return result
def overridepull(orig, ui, repo, source=None, **opts):
revsprepull = len(repo)
if not source:
source = 'default'
repo.lfpullsource = source
if opts.get('rebase', False):
repo._isrebasing = True
try:
if opts.get('update'):
del opts['update']
ui.debug('--update and --rebase are not compatible, ignoring '
'the update flag\n')
del opts['rebase']
cmdutil.bailifchanged(repo)
origpostincoming = commands.postincoming
def _dummy(*args, **kwargs):
pass
commands.postincoming = _dummy
try:
result = commands.pull(ui, repo, source, **opts)
finally:
commands.postincoming = origpostincoming
revspostpull = len(repo)
if revspostpull > revsprepull:
result = result or rebase.rebase(ui, repo)
finally:
repo._isrebasing = False
else:
result = orig(ui, repo, source, **opts)
revspostpull = len(repo)
lfrevs = opts.get('lfrev', [])
if opts.get('all_largefiles'):
lfrevs.append('pulled()')
if lfrevs and revspostpull > revsprepull:
numcached = 0
repo.firstpulled = revsprepull # for pulled() revset expression
try:
for rev in scmutil.revrange(repo, lfrevs):
ui.note(_('pulling largefiles for revision %s\n') % rev)
(cached, missing) = lfcommands.cachelfiles(ui, repo, rev)
numcached += len(cached)
finally:
del repo.firstpulled
ui.status(_("%d largefiles cached\n") % numcached)
return result
def override_pull(orig, ui, repo, source=None, **opts):
if opts.get('rebase', False):
repo._isrebasing = True
try:
if opts.get('update'):
del opts['update']
ui.debug('--update and --rebase are not compatible, ignoring '
'the update flag\n')
del opts['rebase']
cmdutil.bailifchanged(repo)
revsprepull = len(repo)
origpostincoming = commands.postincoming
def _dummy(*args, **kwargs):
pass
commands.postincoming = _dummy
repo.lfpullsource = source
if not source:
source = 'default'
try:
result = commands.pull(ui, repo, source, **opts)
finally:
commands.postincoming = origpostincoming
revspostpull = len(repo)
if revspostpull > revsprepull:
result = result or rebase.rebase(ui, repo)
finally:
repo._isrebasing = False
else:
repo.lfpullsource = source
if not source:
source = 'default'
result = orig(ui, repo, source, **opts)
# If we do not have the new largefiles for any new heads we pulled, we
# will run into a problem later if we try to merge or rebase with one of
# these heads, so cache the largefiles now direclty into the system
# cache.
ui.status(_("caching new largefiles\n"))
numcached = 0
branches = repo.branchmap()
for branch in branches:
heads = repo.branchheads(branch)
for head in heads:
(cached, missing) = lfcommands.cachelfiles(ui, repo, head)
numcached += len(cached)
ui.status(_("%d largefiles cached\n" % numcached))
return result
def overridepull(orig, ui, repo, source=None, **opts):
revsprepull = len(repo)
if not source:
source = 'default'
repo.lfpullsource = source
if opts.get('rebase', False):
repo._isrebasing = True
try:
if opts.get('update'):
del opts['update']
ui.debug('--update and --rebase are not compatible, ignoring '
'the update flag\n')
del opts['rebase']
cmdutil.bailifchanged(repo)
origpostincoming = commands.postincoming
def _dummy(*args, **kwargs):
pass
commands.postincoming = _dummy
try:
result = commands.pull(ui, repo, source, **opts)
finally:
commands.postincoming = origpostincoming
revspostpull = len(repo)
if revspostpull > revsprepull:
result = result or rebase.rebase(ui, repo)
finally:
repo._isrebasing = False
else:
result = orig(ui, repo, source, **opts)
revspostpull = len(repo)
lfrevs = opts.get('lfrev', [])
if opts.get('all_largefiles'):
lfrevs.append('pulled()')
if lfrevs and revspostpull > revsprepull:
numcached = 0
repo.firstpulled = revsprepull # for pulled() revset expression
try:
for rev in scmutil.revrange(repo, lfrevs):
ui.note(_('pulling largefiles for revision %s\n') % rev)
(cached, missing) = lfcommands.cachelfiles(ui, repo, rev)
numcached += len(cached)
finally:
del repo.firstpulled
ui.status(_("%d largefiles cached\n") % numcached)
return result
def push(repo, dest, force, revs):
"""push revisions starting at a specified head back to Subversion.
"""
assert not revs, 'designated revisions for push remains unimplemented.'
cmdutil.bailifchanged(repo)
checkpush = getattr(repo, 'checkpush', None)
if checkpush:
try:
# The checkpush function changed as of e10000369b47 (first
# in 3.0) in mercurial
from mercurial.exchange import pushoperation
pushop = pushoperation(repo, dest, force, revs, False)
checkpush(pushop)
except (ImportError, TypeError):
checkpush(force, revs)
ui = repo.ui
old_encoding = util.swap_out_encoding()
try:
hasobsolete = (obsolete._enabled or
obsolete.isenabled(repo, obsolete.createmarkersopt))
except:
hasobsolete = False
temporary_commits = []
obsmarkers = []
try:
# TODO: implement --rev/#rev support
# TODO: do credentials specified in the URL still work?
svn = dest.svn
meta = repo.svnmeta(svn.uuid, svn.subdir)
# Strategy:
# 1. Find all outgoing commits from this head
if len(repo[None].parents()) != 1:
ui.status('Cowardly refusing to push branch merge\n')
return 0 # results in nonzero exit status, see hg's commands.py
workingrev = repo[None].parents()[0]
workingbranch = workingrev.branch()
ui.status('searching for changes\n')
hashes = meta.revmap.hashes()
outgoing = util.outgoing_revisions(repo, hashes, workingrev.node())
if not (outgoing and len(outgoing)):
ui.status('no changes found\n')
return 1 # so we get a sane exit status, see hg's commands.push
tip_ctx = repo[outgoing[-1]].p1()
svnbranch = tip_ctx.branch()
modified_files = {}
for i in range(len(outgoing) - 1, -1, -1):
# 2. Pick the oldest changeset that needs to be pushed
current_ctx = repo[outgoing[i]]
original_ctx = current_ctx
if len(current_ctx.parents()) != 1:
ui.status('Found a branch merge, this needs discussion and '
'implementation.\n')
# results in nonzero exit status, see hg's commands.py
return 0
# 3. Move the changeset to the tip of the branch if necessary
conflicts = False
for file in current_ctx.files():
if file in modified_files:
conflicts = True
break
if conflicts or current_ctx.branch() != svnbranch:
util.swap_out_encoding(old_encoding)
try:
def extrafn(ctx, extra):
extra['branch'] = ctx.branch()
ui.note('rebasing %s onto %s \n' % (current_ctx, tip_ctx))
hgrebase.rebase(ui, repo,
dest=node.hex(tip_ctx.node()),
rev=[node.hex(current_ctx.node())],
extrafn=extrafn, keep=True)
finally:
util.swap_out_encoding()
# Don't trust the pre-rebase repo and context.
repo = getlocalpeer(ui, {}, meta.path)
meta = repo.svnmeta(svn.uuid, svn.subdir)
hashes = meta.revmap.hashes()
tip_ctx = repo[tip_ctx.node()]
for c in tip_ctx.descendants():
rebasesrc = c.extra().get('rebase_source')
if rebasesrc and node.bin(rebasesrc) == current_ctx.node():
current_ctx = c
temporary_commits.append(c.node())
break
# 4. Push the changeset to subversion
tip_hash = hashes[tip_ctx.node()][0]
try:
ui.status('committing %s\n' % current_ctx)
pushedrev = pushmod.commit(ui, repo, current_ctx, meta,
tip_hash, svn)
except pushmod.NoFilesException:
ui.warn("Could not push revision %s because it had no changes "
"in svn.\n" % current_ctx)
return
# This hook is here purely for testing. It allows us to
# onsistently trigger hit the race condition between
# pushing and pulling here. In particular, we use it to
# trigger another revision landing between the time we
# push a revision and pull it back.
repo.hook('debug-hgsubversion-between-push-and-pull-for-tests')
# 5. Pull the latest changesets from subversion, which will
# include the one we just committed (and possibly others).
r = pull(repo, dest, force=force, meta=meta)
assert not r or r == 0
# 6. Move our tip to the latest pulled tip
for c in tip_ctx.descendants():
if c.node() in hashes and c.branch() == svnbranch:
if meta.get_source_rev(ctx=c)[0] == pushedrev.revnum:
# This is corresponds to the changeset we just pushed
if hasobsolete:
obsmarkers.append([(original_ctx, [c])])
tip_ctx = c
# Remember what files have been modified since the
# whole push started.
for file in c.files():
modified_files[file] = True
# 7. Rebase any children of the commit we just pushed
# that are not in the outgoing set
for c in original_ctx.children():
if not c.node() in hashes and not c.node() in outgoing:
util.swap_out_encoding(old_encoding)
try:
# Path changed as subdirectories were getting
# deleted during push.
saved_path = os.getcwd()
os.chdir(repo.root)
def extrafn(ctx, extra):
extra['branch'] = ctx.branch()
ui.status('rebasing non-outgoing %s onto %s\n' % (c, tip_ctx))
needs_rebase_set = "%s::" % node.hex(c.node())
hgrebase.rebase(ui, repo,
dest=node.hex(tip_ctx.node()),
rev=[needs_rebase_set],
extrafn=extrafn,
keep=not hasobsolete)
finally:
os.chdir(saved_path)
util.swap_out_encoding()
util.swap_out_encoding(old_encoding)
try:
hg.update(repo, repo.branchtip(workingbranch))
finally:
util.swap_out_encoding()
with repo.wlock():
with repo.lock():
if hasobsolete:
for marker in obsmarkers:
obsolete.createmarkers(repo, marker)
beforepush = marker[0][0]
afterpush = marker[0][1][0]
ui.note('marking %s as obsoleted by %s\n' %
(beforepush.hex(), afterpush.hex()))
else:
# strip the original changesets since the push was
# successful and changeset obsolescence is unavailable
util.strip(ui, repo, outgoing, "all")
finally:
try:
# It's always safe to delete the temporary commits.
# The originals are not deleted unless the push
# completely succeeded.
if temporary_commits:
# If the repo is on a temporary commit, get off before
# the strip.
parent = repo[None].p1()
if parent.node() in temporary_commits:
hg.update(repo, parent.p1().node())
with repo.wlock():
with repo.lock():
if hasobsolete:
relations = (
(repo[n], ()) for n in temporary_commits)
obsolete.createmarkers(repo, relations)
else:
util.strip(
ui, repo, temporary_commits, backup=None)
finally:
util.swap_out_encoding(old_encoding)
return 1 # so we get a sane exit status, see hg's commands.push
def fixupamend(ui, repo):
"""rebases any children found on the preamend changset and strips the
preamend changset
"""
wlock = None
lock = None
tr = None
try:
wlock = repo.wlock()
lock = repo.lock()
current = repo['.']
# Use obsolescence information to fix up the amend instead of relying
# on the preamend bookmark if the user enables this feature.
if ui.configbool('fbamend', 'userestack'):
with repo.transaction('fixupamend') as tr:
try:
common.restackonce(ui, repo, current.rev())
except error.InterventionRequired:
tr.close()
raise
return
preamendname = _preamendname(repo, current.node())
if not preamendname in repo._bookmarks:
raise error.Abort(_('no bookmark %s') % preamendname,
hint=_('check if your bookmark is active'))
old = repo[preamendname]
if old == current:
hint = _('please examine smartlog and rebase your changsets '
'manually')
err = _('cannot automatically determine what to rebase '
'because bookmark "%s" points to the current changset') % \
preamendname
raise error.Abort(err, hint=hint)
oldbookmarks = old.bookmarks()
ui.status(_("rebasing the children of %s\n") % (preamendname))
active = bmactive(repo)
opts = {
'rev' : [str(c.rev()) for c in old.descendants()],
'dest' : current.rev()
}
if opts['rev'] and opts['rev'][0]:
rebasemod.rebase(ui, repo, **opts)
changes = []
for bookmark in oldbookmarks:
changes.append((bookmark, None)) # delete the bookmark
tr = repo.transaction('fixupamend')
repo._bookmarks.applychanges(repo, tr, changes)
if obsolete.isenabled(repo, obsolete.createmarkersopt):
tr.close()
else:
tr.close()
repair.strip(ui, repo, old.node(), topic='preamend-backup')
merge.update(repo, current.node(), False, True, False)
if active:
bmactivate(repo, active)
finally:
lockmod.release(wlock, lock, tr)
shelvedfile(repo, basename, 'hg').applybundle()
nodes = [ctx.node() for ctx in repo.set('%d:', oldtiprev)]
phases.retractboundary(repo, phases.secret, nodes)
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')"))
shelvedfile(repo, basename, 'hg').applybundle()
nodes = [ctx.node() for ctx in repo.set('%d:', oldtiprev)]
phases.retractboundary(repo, phases.secret, nodes)
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 "
def push(repo, dest, force, revs):
"""push revisions starting at a specified head back to Subversion.
"""
assert not revs, 'designated revisions for push remains unimplemented.'
cmdutil.bailifchanged(repo)
checkpush = getattr(repo, 'checkpush', None)
if checkpush:
try:
# The checkpush function changed as of e10000369b47 (first
# in 3.0) in mercurial
from mercurial.exchange import pushoperation
pushop = pushoperation(repo, dest, force, revs, False)
checkpush(pushop)
except (ImportError, TypeError):
checkpush(force, revs)
ui = repo.ui
old_encoding = util.swap_out_encoding()
try:
hasobsolete = obsolete._enabled
except:
hasobsolete = False
temporary_commits = []
obsmarkers = []
try:
# TODO: implement --rev/#rev support
# TODO: do credentials specified in the URL still work?
svn = dest.svn
meta = repo.svnmeta(svn.uuid, svn.subdir)
# Strategy:
# 1. Find all outgoing commits from this head
if len(repo[None].parents()) != 1:
ui.status('Cowardly refusing to push branch merge\n')
return 0 # results in nonzero exit status, see hg's commands.py
workingrev = repo[None].parents()[0]
workingbranch = workingrev.branch()
ui.status('searching for changes\n')
hashes = meta.revmap.hashes()
outgoing = util.outgoing_revisions(repo, hashes, workingrev.node())
if not (outgoing and len(outgoing)):
ui.status('no changes found\n')
return 1 # so we get a sane exit status, see hg's commands.push
tip_ctx = repo[outgoing[-1]].p1()
svnbranch = tip_ctx.branch()
modified_files = {}
for i in range(len(outgoing) - 1, -1, -1):
# 2. Pick the oldest changeset that needs to be pushed
current_ctx = repo[outgoing[i]]
original_ctx = current_ctx
if len(current_ctx.parents()) != 1:
ui.status('Found a branch merge, this needs discussion and '
'implementation.\n')
# results in nonzero exit status, see hg's commands.py
return 0
# 3. Move the changeset to the tip of the branch if necessary
conflicts = False
for file in current_ctx.files():
if file in modified_files:
conflicts = True
break
if conflicts or current_ctx.branch() != svnbranch:
util.swap_out_encoding(old_encoding)
try:
def extrafn(ctx, extra):
extra['branch'] = ctx.branch()
ui.note('rebasing %s onto %s \n' % (current_ctx, tip_ctx))
hgrebase.rebase(ui, repo,
dest=node.hex(tip_ctx.node()),
rev=[node.hex(current_ctx.node())],
extrafn=extrafn, keep=True)
finally:
util.swap_out_encoding()
# Don't trust the pre-rebase repo and context.
repo = getlocalpeer(ui, {}, meta.path)
meta = repo.svnmeta(svn.uuid, svn.subdir)
hashes = meta.revmap.hashes()
tip_ctx = repo[tip_ctx.node()]
for c in tip_ctx.descendants():
rebasesrc = c.extra().get('rebase_source')
if rebasesrc and node.bin(rebasesrc) == current_ctx.node():
current_ctx = c
temporary_commits.append(c.node())
break
# 4. Push the changeset to subversion
tip_hash = hashes[tip_ctx.node()][0]
try:
ui.status('committing %s\n' % current_ctx)
pushedrev = pushmod.commit(ui, repo, current_ctx, meta,
tip_hash, svn)
except pushmod.NoFilesException:
ui.warn("Could not push revision %s because it had no changes "
"in svn.\n" % current_ctx)
return
# This hook is here purely for testing. It allows us to
# onsistently trigger hit the race condition between
# pushing and pulling here. In particular, we use it to
# trigger another revision landing between the time we
# push a revision and pull it back.
repo.hook('debug-hgsubversion-between-push-and-pull-for-tests')
# 5. Pull the latest changesets from subversion, which will
# include the one we just committed (and possibly others).
r = pull(repo, dest, force=force, meta=meta)
assert not r or r == 0
# 6. Move our tip to the latest pulled tip
for c in tip_ctx.descendants():
if c.node() in hashes and c.branch() == svnbranch:
if meta.get_source_rev(ctx=c)[0] == pushedrev.revnum:
# This is corresponds to the changeset we just pushed
if hasobsolete:
obsmarkers.append([(original_ctx, [c])])
tip_ctx = c
# Remember what files have been modified since the
# whole push started.
for file in c.files():
modified_files[file] = True
# 7. Rebase any children of the commit we just pushed
# that are not in the outgoing set
for c in original_ctx.children():
if not c.node() in hashes and not c.node() in outgoing:
util.swap_out_encoding(old_encoding)
try:
# Path changed as subdirectories were getting
# deleted during push.
saved_path = os.getcwd()
os.chdir(repo.root)
def extrafn(ctx, extra):
extra['branch'] = ctx.branch()
ui.status('rebasing non-outgoing %s onto %s\n' % (c, tip_ctx))
needs_rebase_set = "%s::" % node.hex(c.node())
hgrebase.rebase(ui, repo,
dest=node.hex(tip_ctx.node()),
rev=[needs_rebase_set],
extrafn=extrafn,
keep=not hasobsolete)
finally:
os.chdir(saved_path)
util.swap_out_encoding()
util.swap_out_encoding(old_encoding)
try:
hg.update(repo, repo.branchtip(workingbranch))
finally:
util.swap_out_encoding()
if hasobsolete:
for marker in obsmarkers:
obsolete.createmarkers(repo, marker)
beforepush = marker[0][0]
afterpush = marker[0][1][0]
ui.note('marking %s as obsoleted by %s\n' %
(beforepush.hex(), afterpush.hex()))
else:
# strip the original changesets since the push was
# successful and changeset obsolescence is unavailable
util.strip(ui, repo, outgoing, "all")
finally:
try:
# It's always safe to delete the temporary commits.
# The originals are not deleted unless the push
# completely succeeded.
if temporary_commits:
# If the repo is on a temporary commit, get off before
# the strip.
parent = repo[None].p1()
if parent.node() in temporary_commits:
hg.update(repo, parent.p1().node())
if hasobsolete:
relations = ((repo[n], ()) for n in temporary_commits)
obsolete.createmarkers(repo, relations)
else:
util.strip(ui, repo, temporary_commits, backup=None)
finally:
util.swap_out_encoding(old_encoding)
return 1 # so we get a sane exit status, see hg's commands.push
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 _dounshelve(ui, repo, *shelved, **opts):
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'))
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
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
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
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,
'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)
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)
ui.restoreconfig(forcemerge)
def _dounshelve(ui, repo, *shelved, **opts):
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'))
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
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
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']
# 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)
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)
# 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 rebase(self, wire, source=None, dest=None, abort=False):
repo = self._factory.repo(wire)
baseui = self._factory._create_config(wire['config'])
repo.ui.setconfig('ui', 'merge', 'internal:dump')
rebase.rebase(
baseui, repo, base=source, dest=dest, abort=abort, keep=not abort)
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)
