mercurial: comparison hgext/shelve.py

equal deleted inserted replaced

-:f33c9a5e81cd
+:1cbeefa59343
 import errno
 import itertools
 from mercurial.i18n import _
 from mercurial import (
+bookmarks,
 bundle2,
 bundlerepo,
 changegroup,
 cmdutil,
 commands,
 """
 _version = 1
 _filename = 'shelvedstate'
 _keep = 'keep'
 _nokeep = 'nokeep'
+# colon is essential to differentiate from a real bookmark name
+_noactivebook = ':no-active-bookmark'
 @classmethod
 def load(cls, repo):
 fp = repo.vfs(cls._filename)
 try:
 pendingctx = nodemod.bin(fp.readline().strip())
 parents = [nodemod.bin(h) for h in fp.readline().split()]
 nodestoprune = [nodemod.bin(h) for h in fp.readline().split()]
 branchtorestore = fp.readline().strip()
 keep = fp.readline().strip() == cls._keep
+activebook = fp.readline().strip()
 except (ValueError, TypeError) as err:
 raise error.CorruptedState(str(err))
 finally:
 fp.close()
 obj.pendingctx = repo[pendingctx]
 obj.parents = parents
 obj.nodestoprune = nodestoprune
 obj.branchtorestore = branchtorestore
 obj.keep = keep
+obj.activebookmark = ''
+if activebook != cls._noactivebook:
+obj.activebookmark = activebook
 except error.RepoLookupError as err:
 raise error.CorruptedState(str(err))
 return obj
 @classmethod
 def save(cls, repo, name, originalwctx, pendingctx, nodestoprune,
-branchtorestore, keep=False):
+branchtorestore, keep=False, activebook=''):
 fp = repo.vfs(cls._filename, 'wb')
 fp.write('%i\n' % cls._version)
 fp.write('%s\n' % name)
 fp.write('%s\n' % nodemod.hex(originalwctx.node()))
 fp.write('%s\n' % nodemod.hex(pendingctx.node()))
 ' '.join([nodemod.hex(p) for p in repo.dirstate.parents()]))
 fp.write('%s\n' %
 ' '.join([nodemod.hex(n) for n in nodestoprune]))
 fp.write('%s\n' % branchtorestore)
 fp.write('%s\n' % (cls._keep if keep else cls._nokeep))
+fp.write('%s\n' % (activebook or cls._noactivebook))
 fp.close()
 @classmethod
 def clear(cls, repo):
 repo.vfs.unlinkpath(cls._filename, ignoremissing=True)
 continue
 base = f[:-(1 + len(patchextension))]
 for ext in shelvefileextensions:
 vfs.tryunlink(base + '.' + ext)
+def _backupactivebookmark(repo):
+activebookmark = repo._activebookmark
+if activebookmark:
+bookmarks.deactivate(repo)
+return activebookmark
+def _restoreactivebookmark(repo, mark):
+if mark:
+bookmarks.activate(repo, mark)
 def _aborttransaction(repo):
 '''Abort current transaction for shelve/unshelve, but keep dirstate
 '''
 tr = repo.currenttransaction()
 repo.dirstate.savebackup(tr, suffix='.shelve')
 desc = '(changes in empty repository)'
 if not opts.get('message'):
 opts['message'] = desc
-lock = tr = None
+lock = tr = activebookmark = None
 try:
 lock = repo.lock()
 # use an uncommitted transaction to generate the bundle to avoid
 # pull races. ensure we don't print the abort message to stderr.
 interactive = opts.get('interactive', False)
 includeunknown = (opts.get('unknown', False) and
 not opts.get('addremove', False))
 name = getshelvename(repo, parent, opts)
+activebookmark = _backupactivebookmark(repo)
 extra = {}
 if includeunknown:
 _includeunknownfiles(repo, pats, opts, extra)
 if _iswctxonnewbranch(repo) and not _isbareshelve(pats, opts):
 commitfunc = getcommitfunc(extra, interactive, editor=True)
 if not interactive:
 node = cmdutil.commit(ui, repo, commitfunc, pats, opts)
 else:
 node = cmdutil.dorecord(ui, repo, commitfunc, None,
-False, cmdutil.recordfilter, *pats, **opts)
+False, cmdutil.recordfilter, *pats,
+**opts)
 if not node:
 _nothingtoshelvemessaging(ui, repo, pats, opts)
 return 1
 _shelvecreatedcommit(repo, node, name)
 if origbranch != repo['.'].branch() and not _isbareshelve(pats, opts):
 repo.dirstate.setbranch(origbranch)
 _finishshelve(repo)
 finally:
+_restoreactivebookmark(repo, activebookmark)
 lockmod.release(tr, lock)
 def _isbareshelve(pats, opts):
 return (not pats
 and not opts.get('interactive', False)
 mergefiles(ui, repo, state.wctx, shelvectx)
 restorebranch(ui, repo, state.branchtorestore)
 repair.strip(ui, repo, state.nodestoprune, backup=False, topic='shelve')
+_restoreactivebookmark(repo, state.activebookmark)
 shelvedstate.clear(repo)
 unshelvecleanup(ui, repo, state.name, opts)
 ui.status(_("unshelve of '%s' complete\n") % state.name)
 def _commitworkingcopychanges(ui, repo, opts, tmpwctx):
 shelvectx = repo['tip']
 ui.quiet = oldquiet
 return repo, shelvectx
 def _rebaserestoredcommit(ui, repo, opts, tr, oldtiprev, basename, pctx,
-tmpwctx, shelvectx, branchtorestore):
+tmpwctx, shelvectx, branchtorestore,
+activebookmark):
 """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():
 return shelvectx
 tr.close()
 nodestoprune = [repo.changelog.node(rev)
 for rev in xrange(oldtiprev, len(repo))]
 shelvedstate.save(repo, basename, pctx, tmpwctx, nodestoprune,
-branchtorestore, opts.get('keep'))
+branchtorestore, opts.get('keep'), activebookmark)
 repo.vfs.rename('rebasestate', 'unshelverebasestate')
 raise error.InterventionRequired(
 _("unresolved conflicts (see 'hg resolve', then "
 "'hg unshelve --continue')"))
 shelveunknown = frozenset(shelveunknown.split('\0'))
 addedafter = frozenset(repo.status().added)
 toforget = (addedafter & shelveunknown) - addedbefore
 repo[None].forget(toforget)
-def _finishunshelve(repo, oldtiprev, tr):
+def _finishunshelve(repo, oldtiprev, tr, activebookmark):
+_restoreactivebookmark(repo, activebookmark)
 # 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)
 # ...-> 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)
 if shelvectx.branch() != shelvectx.p1().branch():
 branchtorestore = shelvectx.branch()
 shelvectx = _rebaserestoredcommit(ui, repo, opts, tr, oldtiprev,
 basename, pctx, tmpwctx,
-shelvectx, branchtorestore)
+shelvectx, branchtorestore,
+activebookmark)
 mergefiles(ui, repo, pctx, shelvectx)
 restorebranch(ui, repo, branchtorestore)
 _forgetunknownfiles(repo, shelvectx, addedbefore)
 shelvedstate.clear(repo)
-_finishunshelve(repo, oldtiprev, tr)
+_finishunshelve(repo, oldtiprev, tr, activebookmark)
 unshelvecleanup(ui, repo, basename, opts)
 finally:
 ui.quiet = oldquiet
 if tr:
 tr.release()

changeset 31664	1cbeefa59343
parent 31555	7c7d3ad7ca5c
child 31757	473f2fcc7629