shelve: don't crash on file with unexpected extension in .hg/shelved/

We assumed that the files in the `.hg/shelved/` directory have an
extension. That's a valid assumption except that users may put garbage
in the directory. This patch fixes the crash by simply not assuming
that the result of splittin a string at '.' yields an extension. We
don't use the extension since the previous patch anyway.

Differential Revision: https://phab.mercurial-scm.org/D9720

mercurial/shelve.py

@@ -1,1173 +1,1173 b''
 # shelve.py - save/restore working directory state
 #
 # Copyright 2013 Facebook, Inc.
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 """save and restore changes to the working directory
 
 The "hg shelve" command saves changes made to the working directory
 and reverts those changes, resetting the working directory to a clean
 state.
 
 Later on, the "hg unshelve" command restores the changes saved by "hg
 shelve". Changes can be restored even after updating to a different
 parent, in which case Mercurial's merge machinery will resolve any
 conflicts if necessary.
 
 You can have more than one shelved change outstanding at a time; each
 shelved change has a distinct name. For details, see the help for "hg
 shelve".
 """
 from __future__ import absolute_import
 
 import collections
 import errno
 import itertools
 import stat
 
 from .i18n import _
 from .node import (
     bin,
     hex,
     nullid,
     nullrev,
 )
 from . import (
     bookmarks,
     bundle2,
     changegroup,
     cmdutil,
     discovery,
     error,
     exchange,
     hg,
     lock as lockmod,
     mdiff,
     merge,
     mergestate as mergestatemod,
     patch,
     phases,
     pycompat,
     repair,
     scmutil,
     templatefilters,
     util,
     vfs as vfsmod,
 )
 from .utils import (
     dateutil,
     stringutil,
 )
 
 backupdir = b'shelve-backup'
 shelvedir = b'shelved'
 shelvefileextensions = [b'hg', b'patch', b'shelve']
 # universal extension is present in all types of shelves
 patchextension = b'patch'
 
 # we never need the user, so we use a
 # generic user for all shelve operations
 shelveuser = b'shelve@localhost'
 
 
 class Shelf(object):
     """Represents a shelf, including possibly multiple files storing it.
 
     Old shelves will have a .patch and a .hg file. Newer shelves will
     also have a .shelve file. This class abstracts away some of the
     differences and lets you work with the shelf as a whole.
     """
 
     def __init__(self, repo, name):
         self.repo = repo
         self.name = name
         self.vfs = vfsmod.vfs(repo.vfs.join(shelvedir))
         self.backupvfs = vfsmod.vfs(repo.vfs.join(backupdir))
 
     def exists(self):
         return self.vfs.exists(
             self.name + b'.' + patchextension
         ) and self.vfs.exists(self.name + b'.hg')
 
     def mtime(self):
         return self.vfs.stat(self.name + b'.' + patchextension)[stat.ST_MTIME]
 
     def writeinfo(self, info):
         scmutil.simplekeyvaluefile(self.vfs, self.name + b'.shelve').write(info)
 
     def hasinfo(self):
         return self.vfs.exists(self.name + b'.shelve')
 
     def readinfo(self):
         return scmutil.simplekeyvaluefile(
             self.vfs, self.name + b'.shelve'
         ).read()
 
     def writebundle(self, bases, node):
         cgversion = changegroup.safeversion(self.repo)
         if cgversion == b'01':
             btype = b'HG10BZ'
             compression = None
         else:
             btype = b'HG20'
             compression = b'BZ'
 
         repo = self.repo.unfiltered()
 
         outgoing = discovery.outgoing(
             repo, missingroots=bases, ancestorsof=[node]
         )
         cg = changegroup.makechangegroup(repo, outgoing, cgversion, b'shelve')
 
         bundle_filename = self.vfs.join(self.name + b'.hg')
         bundle2.writebundle(
             self.repo.ui,
             cg,
             bundle_filename,
             btype,
             self.vfs,
             compression=compression,
         )
 
     def applybundle(self, tr):
         filename = self.name + b'.hg'
         fp = self.vfs(filename)
         try:
             targetphase = phases.internal
             if not phases.supportinternal(self.repo):
                 targetphase = phases.secret
             gen = exchange.readbundle(self.repo.ui, fp, filename, self.vfs)
             pretip = self.repo[b'tip']
             bundle2.applybundle(
                 self.repo,
                 gen,
                 tr,
                 source=b'unshelve',
                 url=b'bundle:' + self.vfs.join(filename),
                 targetphase=targetphase,
             )
             shelvectx = self.repo[b'tip']
             if pretip == shelvectx:
                 shelverev = tr.changes[b'revduplicates'][-1]
                 shelvectx = self.repo[shelverev]
             return shelvectx
         finally:
             fp.close()
 
     def open_patch(self, mode=b'rb'):
         return self.vfs(self.name + b'.patch', mode)
 
     def _backupfilename(self, filename):
         def gennames(base):
             yield base
             base, ext = base.rsplit(b'.', 1)
             for i in itertools.count(1):
                 yield b'%s-%d.%s' % (base, i, ext)
 
         for n in gennames(filename):
             if not self.backupvfs.exists(n):
                 return self.backupvfs.join(n)
 
     def movetobackup(self):
         if not self.backupvfs.isdir():
             self.backupvfs.makedir()
         for suffix in shelvefileextensions:
             filename = self.name + b'.' + suffix
             if self.vfs.exists(filename):
                 util.rename(
                     self.vfs.join(filename), self._backupfilename(filename)
                 )
 
 
 class shelvedstate(object):
     """Handle persistence during unshelving operations.
 
     Handles saving and restoring a shelved state. Ensures that different
     versions of a shelved state are possible and handles them appropriately.
     """
 
     _version = 2
     _filename = b'shelvedstate'
     _keep = b'keep'
     _nokeep = b'nokeep'
     # colon is essential to differentiate from a real bookmark name
     _noactivebook = b':no-active-bookmark'
     _interactive = b'interactive'
 
     @classmethod
     def _verifyandtransform(cls, d):
         """Some basic shelvestate syntactic verification and transformation"""
         try:
             d[b'originalwctx'] = bin(d[b'originalwctx'])
             d[b'pendingctx'] = bin(d[b'pendingctx'])
             d[b'parents'] = [bin(h) for h in d[b'parents'].split(b' ')]
             d[b'nodestoremove'] = [
                 bin(h) for h in d[b'nodestoremove'].split(b' ')
             ]
         except (ValueError, TypeError, KeyError) as err:
             raise error.CorruptedState(pycompat.bytestr(err))
 
     @classmethod
     def _getversion(cls, repo):
         """Read version information from shelvestate file"""
         fp = repo.vfs(cls._filename)
         try:
             version = int(fp.readline().strip())
         except ValueError as err:
             raise error.CorruptedState(pycompat.bytestr(err))
         finally:
             fp.close()
         return version
 
     @classmethod
     def _readold(cls, repo):
         """Read the old position-based version of a shelvestate file"""
         # Order is important, because old shelvestate file uses it
         # to detemine values of fields (i.g. name is on the second line,
         # originalwctx is on the third and so forth). Please do not change.
         keys = [
             b'version',
             b'name',
             b'originalwctx',
             b'pendingctx',
             b'parents',
             b'nodestoremove',
             b'branchtorestore',
             b'keep',
             b'activebook',
         ]
         # this is executed only seldomly, so it is not a big deal
         # that we open this file twice
         fp = repo.vfs(cls._filename)
         d = {}
         try:
             for key in keys:
                 d[key] = fp.readline().strip()
         finally:
             fp.close()
         return d
 
     @classmethod
     def load(cls, repo):
         version = cls._getversion(repo)
         if version < cls._version:
             d = cls._readold(repo)
         elif version == cls._version:
             d = scmutil.simplekeyvaluefile(repo.vfs, cls._filename).read(
                 firstlinenonkeyval=True
             )
         else:
             raise error.Abort(
                 _(
                     b'this version of shelve is incompatible '
                     b'with the version used in this repo'
                 )
             )
 
         cls._verifyandtransform(d)
         try:
             obj = cls()
             obj.name = d[b'name']
             obj.wctx = repo[d[b'originalwctx']]
             obj.pendingctx = repo[d[b'pendingctx']]
             obj.parents = d[b'parents']
             obj.nodestoremove = d[b'nodestoremove']
             obj.branchtorestore = d.get(b'branchtorestore', b'')
             obj.keep = d.get(b'keep') == cls._keep
             obj.activebookmark = b''
             if d.get(b'activebook', b'') != cls._noactivebook:
                 obj.activebookmark = d.get(b'activebook', b'')
             obj.interactive = d.get(b'interactive') == cls._interactive
         except (error.RepoLookupError, KeyError) as err:
             raise error.CorruptedState(pycompat.bytestr(err))
 
         return obj
 
     @classmethod
     def save(
         cls,
         repo,
         name,
         originalwctx,
         pendingctx,
         nodestoremove,
         branchtorestore,
         keep=False,
         activebook=b'',
         interactive=False,
     ):
         info = {
             b"name": name,
             b"originalwctx": hex(originalwctx.node()),
             b"pendingctx": hex(pendingctx.node()),
             b"parents": b' '.join([hex(p) for p in repo.dirstate.parents()]),
             b"nodestoremove": b' '.join([hex(n) for n in nodestoremove]),
             b"branchtorestore": branchtorestore,
             b"keep": cls._keep if keep else cls._nokeep,
             b"activebook": activebook or cls._noactivebook,
         }
         if interactive:
             info[b'interactive'] = cls._interactive
         scmutil.simplekeyvaluefile(repo.vfs, cls._filename).write(
             info, firstline=(b"%d" % cls._version)
         )
 
     @classmethod
     def clear(cls, repo):
         repo.vfs.unlinkpath(cls._filename, ignoremissing=True)
 
 
 def cleanupoldbackups(repo):
     vfs = vfsmod.vfs(repo.vfs.join(backupdir))
     maxbackups = repo.ui.configint(b'shelve', b'maxbackups')
     hgfiles = [f for f in vfs.listdir() if f.endswith(b'.' + patchextension)]
     hgfiles = sorted([(vfs.stat(f)[stat.ST_MTIME], f) for f in hgfiles])
     if maxbackups > 0 and maxbackups < len(hgfiles):
         bordermtime = hgfiles[-maxbackups][0]
     else:
         bordermtime = None
     for mtime, f in hgfiles[: len(hgfiles) - maxbackups]:
         if mtime == bordermtime:
             # keep it, because timestamp can't decide exact order of backups
             continue
         base = f[: -(1 + len(patchextension))]
         for ext in shelvefileextensions:
             vfs.tryunlink(base + b'.' + 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, tr):
     """Abort current transaction for shelve/unshelve, but keep dirstate"""
     dirstatebackupname = b'dirstate.shelve'
     repo.dirstate.savebackup(tr, dirstatebackupname)
     tr.abort()
     repo.dirstate.restorebackup(None, dirstatebackupname)
 
 
 def getshelvename(repo, parent, opts):
     """Decide on the name this shelve is going to have"""
 
     def gennames():
         yield label
         for i in itertools.count(1):
             yield b'%s-%02d' % (label, i)
 
     name = opts.get(b'name')
     label = repo._activebookmark or parent.branch() or b'default'
     # slashes aren't allowed in filenames, therefore we rename it
     label = label.replace(b'/', b'_')
     label = label.replace(b'\\', b'_')
     # filenames must not start with '.' as it should not be hidden
     if label.startswith(b'.'):
         label = label.replace(b'.', b'_', 1)
 
     if name:
         if Shelf(repo, name).exists():
             e = _(b"a shelved change named '%s' already exists") % name
             raise error.Abort(e)
 
         # ensure we are not creating a subdirectory or a hidden file
         if b'/' in name or b'\\' in name:
             raise error.Abort(
                 _(b'shelved change names can not contain slashes')
             )
         if name.startswith(b'.'):
             raise error.Abort(_(b"shelved change names can not start with '.'"))
 
     else:
         for n in gennames():
             if not Shelf(repo, n).exists():
                 name = n
                 break
 
     return name
 
 
 def mutableancestors(ctx):
     """return all mutable ancestors for ctx (included)
 
     Much faster than the revset ancestors(ctx) & draft()"""
     seen = {nullrev}
     visit = collections.deque()
     visit.append(ctx)
     while visit:
         ctx = visit.popleft()
         yield ctx.node()
         for parent in ctx.parents():
             rev = parent.rev()
             if rev not in seen:
                 seen.add(rev)
                 if parent.mutable():
                     visit.append(parent)
 
 
 def getcommitfunc(extra, interactive, editor=False):
     def commitfunc(ui, repo, message, match, opts):
         hasmq = util.safehasattr(repo, b'mq')
         if hasmq:
             saved, repo.mq.checkapplied = repo.mq.checkapplied, False
 
         targetphase = phases.internal
         if not phases.supportinternal(repo):
             targetphase = phases.secret
         overrides = {(b'phases', b'new-commit'): targetphase}
         try:
             editor_ = False
             if editor:
                 editor_ = cmdutil.getcommiteditor(
                     editform=b'shelve.shelve', **pycompat.strkwargs(opts)
                 )
             with repo.ui.configoverride(overrides):
                 return repo.commit(
                     message,
                     shelveuser,
                     opts.get(b'date'),
                     match,
                     editor=editor_,
                     extra=extra,
                 )
         finally:
             if hasmq:
                 repo.mq.checkapplied = saved
 
     def interactivecommitfunc(ui, repo, *pats, **opts):
         opts = pycompat.byteskwargs(opts)
         match = scmutil.match(repo[b'.'], pats, {})
         message = opts[b'message']
         return commitfunc(ui, repo, message, match, opts)
 
     return interactivecommitfunc if interactive else commitfunc
 
 
 def _nothingtoshelvemessaging(ui, repo, pats, opts):
     stat = repo.status(match=scmutil.match(repo[None], pats, opts))
     if stat.deleted:
         ui.status(
             _(b"nothing changed (%d missing files, see 'hg status')\n")
             % len(stat.deleted)
         )
     else:
         ui.status(_(b"nothing changed\n"))
 
 
 def _shelvecreatedcommit(repo, node, name, match):
     info = {b'node': hex(node)}
     shelf = Shelf(repo, name)
     shelf.writeinfo(info)
     bases = list(mutableancestors(repo[node]))
     shelf.writebundle(bases, node)
     with shelf.open_patch(b'wb') as fp:
         cmdutil.exportfile(
             repo, [node], fp, opts=mdiff.diffopts(git=True), match=match
         )
 
 
 def _includeunknownfiles(repo, pats, opts, extra):
     s = repo.status(match=scmutil.match(repo[None], pats, opts), unknown=True)
     if s.unknown:
         extra[b'shelve_unknown'] = b'\0'.join(s.unknown)
         repo[None].add(s.unknown)
 
 
 def _finishshelve(repo, tr):
     if phases.supportinternal(repo):
         tr.close()
     else:
         _aborttransaction(repo, tr)
 
 
 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 _docreatecmd(ui, repo, pats, opts):
     wctx = repo[None]
     parents = wctx.parents()
     parent = parents[0]
     origbranch = wctx.branch()
 
     if parent.node() != nullid:
         desc = b"changes to: %s" % parent.description().split(b'\n', 1)[0]
     else:
         desc = b'(changes in empty repository)'
 
     if not opts.get(b'message'):
         opts[b'message'] = desc
 
     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.
         tr = repo.transaction(b'shelve', report=lambda x: None)
 
         interactive = opts.get(b'interactive', False)
         includeunknown = opts.get(b'unknown', False) and not opts.get(
             b'addremove', False
         )
 
         name = getshelvename(repo, parent, opts)
         activebookmark = _backupactivebookmark(repo)
         extra = {b'internal': b'shelve'}
         if includeunknown:
             _includeunknownfiles(repo, pats, opts, extra)
 
         if _iswctxonnewbranch(repo) and not _isbareshelve(pats, opts):
             # In non-bare shelve we don't store newly created branch
             # at bundled commit
             repo.dirstate.setbranch(repo[b'.'].branch())
 
         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,
                 **pycompat.strkwargs(opts)
             )
         if not node:
             _nothingtoshelvemessaging(ui, repo, pats, opts)
             return 1
 
         # Create a matcher so that prefetch doesn't attempt to fetch
         # the entire repository pointlessly, and as an optimisation
         # for movedirstate, if needed.
         match = scmutil.matchfiles(repo, repo[node].files())
         _shelvecreatedcommit(repo, node, name, match)
 
         ui.status(_(b'shelved as %s\n') % name)
         if opts[b'keep']:
             with repo.dirstate.parentchange():
                 scmutil.movedirstate(repo, parent, match)
         else:
             hg.update(repo, parent.node())
             ms = mergestatemod.mergestate.read(repo)
             if not ms.unresolvedcount():
                 ms.reset()
 
         if origbranch != repo[b'.'].branch() and not _isbareshelve(pats, opts):
             repo.dirstate.setbranch(origbranch)
 
         _finishshelve(repo, tr)
     finally:
         _restoreactivebookmark(repo, activebookmark)
         lockmod.release(tr, lock)
 
 
 def _isbareshelve(pats, opts):
     return (
         not pats
         and not opts.get(b'interactive', False)
         and not opts.get(b'include', False)
         and not opts.get(b'exclude', False)
     )
 
 
 def _iswctxonnewbranch(repo):
     return repo[None].branch() != repo[b'.'].branch()
 
 
 def cleanupcmd(ui, repo):
     """subcommand that deletes all shelves"""
 
     with repo.wlock():
         for _mtime, name in listshelves(repo):
             Shelf(repo, name).movetobackup()
             cleanupoldbackups(repo)
 
 
 def deletecmd(ui, repo, pats):
     """subcommand that deletes a specific shelve"""
     if not pats:
         raise error.InputError(_(b'no shelved changes specified!'))
     with repo.wlock():
         for name in pats:
             shelf = Shelf(repo, name)
             if not shelf.exists():
                 raise error.InputError(
                     _(b"shelved change '%s' not found") % name
                 )
             shelf.movetobackup()
             cleanupoldbackups(repo)
 
 
 def listshelves(repo):
     """return all shelves in repo as list of (time, name)"""
     try:
         names = repo.vfs.readdir(shelvedir)
     except OSError as err:
         if err.errno != errno.ENOENT:
             raise
         return []
     info = []
     seen = set()
     for (filename, _type) in names:
-        name, ext = filename.rsplit(b'.', 1)
+        name = filename.rsplit(b'.', 1)[0]
         if name in seen:
             continue
         seen.add(name)
         shelf = Shelf(repo, name)
         if not shelf.exists():
             continue
         mtime = shelf.mtime()
         info.append((mtime, name))
     return sorted(info, reverse=True)
 
 
 def listcmd(ui, repo, pats, opts):
     """subcommand that displays the list of shelves"""
     pats = set(pats)
     width = 80
     if not ui.plain():
         width = ui.termwidth()
     namelabel = b'shelve.newest'
     ui.pager(b'shelve')
     for mtime, name in listshelves(repo):
         if pats and name not in pats:
             continue
         ui.write(name, label=namelabel)
         namelabel = b'shelve.name'
         if ui.quiet:
             ui.write(b'\n')
             continue
         ui.write(b' ' * (16 - len(name)))
         used = 16
         date = dateutil.makedate(mtime)
         age = b'(%s)' % templatefilters.age(date, abbrev=True)
         ui.write(age, label=b'shelve.age')
         ui.write(b' ' * (12 - len(age)))
         used += 12
         with Shelf(repo, name).open_patch() as fp:
             while True:
                 line = fp.readline()
                 if not line:
                     break
                 if not line.startswith(b'#'):
                     desc = line.rstrip()
                     if ui.formatted():
                         desc = stringutil.ellipsis(desc, width - used)
                     ui.write(desc)
                     break
             ui.write(b'\n')
             if not (opts[b'patch'] or opts[b'stat']):
                 continue
             difflines = fp.readlines()
             if opts[b'patch']:
                 for chunk, label in patch.difflabel(iter, difflines):
                     ui.write(chunk, label=label)
             if opts[b'stat']:
                 for chunk, label in patch.diffstatui(difflines, width=width):
                     ui.write(chunk, label=label)
 
 
 def patchcmds(ui, repo, pats, opts):
     """subcommand that displays shelves"""
     if len(pats) == 0:
         shelves = listshelves(repo)
         if not shelves:
             raise error.Abort(_(b"there are no shelves to show"))
         mtime, name = shelves[0]
         pats = [name]
 
     for shelfname in pats:
         if not Shelf(repo, shelfname).exists():
             raise error.Abort(_(b"cannot find shelf %s") % shelfname)
 
     listcmd(ui, repo, pats, opts)
 
 
 def checkparents(repo, state):
     """check parent while resuming an unshelve"""
     if state.parents != repo.dirstate.parents():
         raise error.Abort(
             _(b'working directory parents do not match unshelve state')
         )
 
 
 def _loadshelvedstate(ui, repo, opts):
     try:
         state = shelvedstate.load(repo)
         if opts.get(b'keep') is None:
             opts[b'keep'] = state.keep
     except IOError as err:
         if err.errno != errno.ENOENT:
             raise
         cmdutil.wrongtooltocontinue(repo, _(b'unshelve'))
     except error.CorruptedState as err:
         ui.debug(pycompat.bytestr(err) + b'\n')
         if opts.get(b'continue'):
             msg = _(b'corrupted shelved state file')
             hint = _(
                 b'please run hg unshelve --abort to abort unshelve '
                 b'operation'
             )
             raise error.Abort(msg, hint=hint)
         elif opts.get(b'abort'):
             shelvedstate.clear(repo)
             raise error.Abort(
                 _(
                     b'could not read shelved state file, your '
                     b'working copy may be in an unexpected state\n'
                     b'please update to some commit\n'
                 )
             )
     return state
 
 
 def unshelveabort(ui, repo, state):
     """subcommand that abort an in-progress unshelve"""
     with repo.lock():
         try:
             checkparents(repo, state)
 
             merge.clean_update(state.pendingctx)
             if state.activebookmark and state.activebookmark in repo._bookmarks:
                 bookmarks.activate(repo, state.activebookmark)
             mergefiles(ui, repo, state.wctx, state.pendingctx)
             if not phases.supportinternal(repo):
                 repair.strip(
                     ui, repo, state.nodestoremove, backup=False, topic=b'shelve'
                 )
         finally:
             shelvedstate.clear(repo)
             ui.warn(_(b"unshelve of '%s' aborted\n") % state.name)
 
 
 def hgabortunshelve(ui, repo):
     """logic to  abort unshelve using 'hg abort"""
     with repo.wlock():
         state = _loadshelvedstate(ui, repo, {b'abort': True})
         return unshelveabort(ui, repo, state)
 
 
 def mergefiles(ui, repo, wctx, shelvectx):
     """updates to wctx and merges the changes from shelvectx into the
     dirstate."""
     with ui.configoverride({(b'ui', b'quiet'): True}):
         hg.update(repo, wctx.node())
         ui.pushbuffer(True)
         cmdutil.revert(ui, repo, shelvectx)
         ui.popbuffer()
 
 
 def restorebranch(ui, repo, branchtorestore):
     if branchtorestore and branchtorestore != repo.dirstate.branch():
         repo.dirstate.setbranch(branchtorestore)
         ui.status(
             _(b'marked working directory as branch %s\n') % branchtorestore
         )
 
 
 def unshelvecleanup(ui, repo, name, opts):
     """remove related files after an unshelve"""
     if not opts.get(b'keep'):
         Shelf(repo, name).movetobackup()
         cleanupoldbackups(repo)
 
 
 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.
     interactive = state.interactive
     basename = state.name
     with repo.lock():
         checkparents(repo, state)
         ms = mergestatemod.mergestate.read(repo)
         if list(ms.unresolved()):
             raise error.Abort(
                 _(b"unresolved conflicts, can't continue"),
                 hint=_(b"see 'hg resolve', then 'hg unshelve --continue'"),
             )
 
         shelvectx = repo[state.parents[1]]
         pendingctx = state.pendingctx
 
         with repo.dirstate.parentchange():
             repo.setparents(state.pendingctx.node(), nullid)
             repo.dirstate.write(repo.currenttransaction())
 
         targetphase = phases.internal
         if not phases.supportinternal(repo):
             targetphase = phases.secret
         overrides = {(b'phases', b'new-commit'): targetphase}
         with repo.ui.configoverride(overrides, b'unshelve'):
             with repo.dirstate.parentchange():
                 repo.setparents(state.parents[0], nullid)
                 newnode, ispartialunshelve = _createunshelvectx(
                     ui, repo, shelvectx, basename, interactive, opts
                 )
 
         if newnode is None:
             shelvectx = state.pendingctx
             msg = _(
                 b'note: unshelved changes already existed '
                 b'in the working copy\n'
             )
             ui.status(msg)
         else:
             # only strip the shelvectx if we produced one
             state.nodestoremove.append(newnode)
             shelvectx = repo[newnode]
 
         merge.update(pendingctx)
         mergefiles(ui, repo, state.wctx, shelvectx)
         restorebranch(ui, repo, state.branchtorestore)
 
         if not phases.supportinternal(repo):
             repair.strip(
                 ui, repo, state.nodestoremove, backup=False, topic=b'shelve'
             )
         shelvedstate.clear(repo)
         if not ispartialunshelve:
             unshelvecleanup(ui, repo, state.name, opts)
         _restoreactivebookmark(repo, state.activebookmark)
         ui.status(_(b"unshelve of '%s' complete\n") % state.name)
 
 
 def hgcontinueunshelve(ui, repo):
     """logic to resume unshelve using 'hg continue'"""
     with repo.wlock():
         state = _loadshelvedstate(ui, repo, {b'continue': True})
         return unshelvecontinue(ui, repo, state, {b'keep': state.keep})
 
 
 def _commitworkingcopychanges(ui, repo, opts, tmpwctx):
     """Temporarily commit working copy changes before moving unshelve commit"""
     # 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 not (s.modified or s.added or s.removed):
         return tmpwctx, addedbefore
     ui.status(
         _(
             b"temporarily committing pending changes "
             b"(restore with 'hg unshelve --abort')\n"
         )
     )
     extra = {b'internal': b'shelve'}
     commitfunc = getcommitfunc(extra=extra, interactive=False, editor=False)
     tempopts = {}
     tempopts[b'message'] = b"pending changes temporary commit"
     tempopts[b'date'] = opts.get(b'date')
     with ui.configoverride({(b'ui', b'quiet'): True}):
         node = cmdutil.commit(ui, repo, commitfunc, [], tempopts)
     tmpwctx = repo[node]
     return tmpwctx, addedbefore
 
 
 def _unshelverestorecommit(ui, repo, tr, basename):
     """Recreate commit in the repository during the unshelve"""
     repo = repo.unfiltered()
     node = None
     shelf = Shelf(repo, basename)
     if shelf.hasinfo():
         node = shelf.readinfo()[b'node']
     if node is None or node not in repo:
         with ui.configoverride({(b'ui', b'quiet'): True}):
             shelvectx = shelf.applybundle(tr)
         # We might not strip the unbundled changeset, so we should keep track of
         # the unshelve node in case we need to reuse it (eg: unshelve --keep)
         if node is None:
             info = {b'node': hex(shelvectx.node())}
             shelf.writeinfo(info)
     else:
         shelvectx = repo[node]
 
     return repo, shelvectx
 
 
 def _createunshelvectx(ui, repo, shelvectx, basename, interactive, opts):
     """Handles the creation of unshelve commit and updates the shelve if it
     was partially unshelved.
 
     If interactive is:
 
       * False: Commits all the changes in the working directory.
       * True: Prompts the user to select changes to unshelve and commit them.
               Update the shelve with remaining changes.
 
     Returns the node of the new commit formed and a bool indicating whether
     the shelve was partially unshelved.Creates a commit ctx to unshelve
     interactively or non-interactively.
 
     The user might want to unshelve certain changes only from the stored
     shelve in interactive. So, we would create two commits. One with requested
     changes to unshelve at that time and the latter is shelved for future.
 
     Here, we return both the newnode which is created interactively and a
     bool to know whether the shelve is partly done or completely done.
     """
     opts[b'message'] = shelvectx.description()
     opts[b'interactive-unshelve'] = True
     pats = []
     if not interactive:
         newnode = repo.commit(
             text=shelvectx.description(),
             extra=shelvectx.extra(),
             user=shelvectx.user(),
             date=shelvectx.date(),
         )
         return newnode, False
 
     commitfunc = getcommitfunc(shelvectx.extra(), interactive=True, editor=True)
     newnode = cmdutil.dorecord(
         ui,
         repo,
         commitfunc,
         None,
         False,
         cmdutil.recordfilter,
         *pats,
         **pycompat.strkwargs(opts)
     )
     snode = repo.commit(
         text=shelvectx.description(),
         extra=shelvectx.extra(),
         user=shelvectx.user(),
     )
     if snode:
         m = scmutil.matchfiles(repo, repo[snode].files())
         _shelvecreatedcommit(repo, snode, basename, m)
 
     return newnode, bool(snode)
 
 
 def _rebaserestoredcommit(
     ui,
     repo,
     opts,
     tr,
     oldtiprev,
     basename,
     pctx,
     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.
     interactive = opts.get(b'interactive')
     if tmpwctx.node() == shelvectx.p1().node() and not interactive:
         # We won't skip on interactive mode because, the user might want to
         # unshelve certain changes only.
         return shelvectx, False
 
     overrides = {
         (b'ui', b'forcemerge'): opts.get(b'tool', b''),
         (b'phases', b'new-commit'): phases.secret,
     }
     with repo.ui.configoverride(overrides, b'unshelve'):
         ui.status(_(b'rebasing shelved changes\n'))
         stats = merge.graft(
             repo,
             shelvectx,
             labels=[b'working-copy', b'shelve'],
             keepconflictparent=True,
         )
         if stats.unresolvedcount:
             tr.close()
 
             nodestoremove = [
                 repo.changelog.node(rev)
                 for rev in pycompat.xrange(oldtiprev, len(repo))
             ]
             shelvedstate.save(
                 repo,
                 basename,
                 pctx,
                 tmpwctx,
                 nodestoremove,
                 branchtorestore,
                 opts.get(b'keep'),
                 activebookmark,
                 interactive,
             )
             raise error.ConflictResolutionRequired(b'unshelve')
 
         with repo.dirstate.parentchange():
             repo.setparents(tmpwctx.node(), nullid)
             newnode, ispartialunshelve = _createunshelvectx(
                 ui, repo, shelvectx, basename, interactive, opts
             )
 
         if newnode is None:
             shelvectx = tmpwctx
             msg = _(
                 b'note: unshelved changes already existed '
                 b'in the working copy\n'
             )
             ui.status(msg)
         else:
             shelvectx = repo[newnode]
             merge.update(tmpwctx)
 
     return shelvectx, ispartialunshelve
 
 
 def _forgetunknownfiles(repo, shelvectx, addedbefore):
     # Forget any files that were unknown before the shelve, unknown before
     # unshelve started, but are now added.
     shelveunknown = shelvectx.extra().get(b'shelve_unknown')
     if not shelveunknown:
         return
     shelveunknown = frozenset(shelveunknown.split(b'\0'))
     addedafter = frozenset(repo.status().added)
     toforget = (addedafter & shelveunknown) - addedbefore
     repo[None].forget(toforget)
 
 
 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)
     _aborttransaction(repo, tr)
 
 
 def _checkunshelveuntrackedproblems(ui, repo, shelvectx):
     """Check potential problems which may result from working
     copy having untracked changes."""
     wcdeleted = set(repo.status().deleted)
     shelvetouched = set(shelvectx.files())
     intersection = wcdeleted.intersection(shelvetouched)
     if intersection:
         m = _(b"shelved change touches missing files")
         hint = _(b"run hg status to see which files are missing")
         raise error.Abort(m, hint=hint)
 
 
 def unshelvecmd(ui, repo, *shelved, **opts):
     opts = pycompat.byteskwargs(opts)
     abortf = opts.get(b'abort')
     continuef = opts.get(b'continue')
     interactive = opts.get(b'interactive')
     if not abortf and not continuef:
         cmdutil.checkunfinished(repo)
     shelved = list(shelved)
     if opts.get(b"name"):
         shelved.append(opts[b"name"])
 
     if interactive and opts.get(b'keep'):
         raise error.InputError(
             _(b'--keep on --interactive is not yet supported')
         )
     if abortf or continuef:
         if abortf and continuef:
             raise error.InputError(_(b'cannot use both abort and continue'))
         if shelved:
             raise error.InputError(
                 _(
                     b'cannot combine abort/continue with '
                     b'naming a shelved change'
                 )
             )
         if abortf and opts.get(b'tool', False):
             ui.warn(_(b'tool option will be ignored\n'))
 
         state = _loadshelvedstate(ui, repo, opts)
         if abortf:
             return unshelveabort(ui, repo, state)
         elif continuef and interactive:
             raise error.InputError(
                 _(b'cannot use both continue and interactive')
             )
         elif continuef:
             return unshelvecontinue(ui, repo, state, opts)
     elif len(shelved) > 1:
         raise error.InputError(_(b'can only unshelve one change at a time'))
     elif not shelved:
         shelved = listshelves(repo)
         if not shelved:
             raise error.StateError(_(b'no shelved changes to apply!'))
         basename = shelved[0][1]
         ui.status(_(b"unshelving change '%s'\n") % basename)
     else:
         basename = shelved[0]
 
     if not Shelf(repo, basename).exists():
         raise error.InputError(_(b"shelved change '%s' not found") % basename)
 
     return _dounshelve(ui, repo, basename, opts)
 
 
 def _dounshelve(ui, repo, basename, opts):
     repo = repo.unfiltered()
     lock = tr = None
     try:
         lock = repo.lock()
         tr = repo.transaction(b'unshelve', report=lambda x: None)
         oldtiprev = len(repo)
 
         pctx = repo[b'.']
         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, tr, basename)
         _checkunshelveuntrackedproblems(ui, repo, shelvectx)
         branchtorestore = b''
         if shelvectx.branch() != shelvectx.p1().branch():
             branchtorestore = shelvectx.branch()
 
         shelvectx, ispartialunshelve = _rebaserestoredcommit(
             ui,
             repo,
             opts,
             tr,
             oldtiprev,
             basename,
             pctx,
             tmpwctx,
             shelvectx,
             branchtorestore,
             activebookmark,
         )
         overrides = {(b'ui', b'forcemerge'): opts.get(b'tool', b'')}
         with ui.configoverride(overrides, b'unshelve'):
             mergefiles(ui, repo, pctx, shelvectx)
         restorebranch(ui, repo, branchtorestore)
         shelvedstate.clear(repo)
         _finishunshelve(repo, oldtiprev, tr, activebookmark)
         _forgetunknownfiles(repo, shelvectx, addedbefore)
         if not ispartialunshelve:
             unshelvecleanup(ui, repo, basename, opts)
     finally:
         if tr:
             tr.release()
         lockmod.release(lock)

tests/test-shelve2.t

@@ -1,994 +1,994 b''
 #testcases stripbased phasebased
 #testcases abortflag abortcommand
 #testcases continueflag continuecommand
 
   $ cat <<EOF >> $HGRCPATH
   > [extensions]
   > mq =
   > [defaults]
   > diff = --nodates --git
   > qnew = --date '0 0'
   > [shelve]
   > maxbackups = 2
   > EOF
 
 #if phasebased
 
   $ cat <<EOF >> $HGRCPATH
   > [format]
   > internal-phase = yes
   > EOF
 
 #endif
 
 #if abortflag
   $ cat >> $HGRCPATH <<EOF
   > [alias]
   > abort = unshelve --abort
   > EOF
 #endif
 
 #if continueflag
   $ cat >> $HGRCPATH <<EOF
   > [alias]
   > continue = unshelve --continue
   > EOF
 #endif
 
 shelve should leave dirstate clean (issue4055)
 
   $ hg init shelverebase
   $ cd shelverebase
   $ printf 'x\ny\n' > x
   $ echo z > z
   $ hg commit -Aqm xy
   $ echo z >> x
   $ hg commit -Aqm z
   $ hg up 5c4c67fb7dce
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ printf 'a\nx\ny\nz\n' > x
   $ hg commit -Aqm xyz
   $ echo c >> z
   $ hg shelve
   shelved as default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ hg rebase -d 6c103be8f4e4 --config extensions.rebase=
   rebasing 2:323bfa07f744( tip)? "xyz" (re)
   merging x
   saved backup bundle to \$TESTTMP/shelverebase/.hg/strip-backup/323bfa07f744-(78114325|7ae538ef)-rebase.hg (re)
   $ hg unshelve
   unshelving change 'default'
   rebasing shelved changes
   $ hg status
   M z
 
   $ cd ..
 
 shelve should only unshelve pending changes (issue4068)
 
   $ hg init onlypendingchanges
   $ cd onlypendingchanges
   $ touch a
   $ hg ci -Aqm a
   $ touch b
   $ hg ci -Aqm b
   $ hg up -q 3903775176ed
   $ touch c
   $ hg ci -Aqm c
 
   $ touch d
   $ hg add d
   $ hg shelve
   shelved as default
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg up -q 0e067c57feba
   $ hg unshelve
   unshelving change 'default'
   rebasing shelved changes
   $ hg status
   A d
 
 unshelve should work on an ancestor of the original commit
 
   $ hg shelve
   shelved as default
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg up 3903775176ed
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg unshelve
   unshelving change 'default'
   rebasing shelved changes
   $ hg status
   A d
 
 test bug 4073 we need to enable obsolete markers for it
 
   $ cat >> $HGRCPATH << EOF
   > [experimental]
   > evolution.createmarkers=True
   > EOF
   $ hg shelve
   shelved as default
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg debugobsolete `hg log -r 0e067c57feba -T '{node}'`
   1 new obsolescence markers
   obsoleted 1 changesets
   $ hg unshelve
   unshelving change 'default'
 
 unshelve should leave unknown files alone (issue4113)
 
   $ echo e > e
   $ hg shelve
   shelved as default
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg status
   ? e
   $ hg unshelve
   unshelving change 'default'
   $ hg status
   A d
   ? e
   $ cat e
   e
 
 unshelve should keep a copy of unknown files
 
   $ hg add e
   $ hg shelve
   shelved as default
   0 files updated, 0 files merged, 2 files removed, 0 files unresolved
   $ echo z > e
   $ hg unshelve
   unshelving change 'default'
   $ cat e
   e
   $ cat e.orig
   z
   $ rm e.orig
 
 restores backup of unknown file to right directory
 
   $ hg shelve
   shelved as default
   0 files updated, 0 files merged, 2 files removed, 0 files unresolved
   $ echo z > e
   $ mkdir dir
   $ hg unshelve --cwd dir
   unshelving change 'default'
   $ rmdir dir
   $ cat e
   e
   $ cat e.orig
   z
 
 unshelve and conflicts with tracked and untracked files
 
  preparing:
 
   $ rm -f *.orig
   $ hg ci -qm 'commit stuff'
   $ hg phase -p null:
 
  no other changes - no merge:
 
   $ echo f > f
   $ hg add f
   $ hg shelve
   shelved as default
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ echo g > f
   $ hg unshelve
   unshelving change 'default'
   $ hg st
   A f
   ? f.orig
   $ cat f
   f
   $ cat f.orig
   g
 
  other uncommitted changes - merge:
 
   $ hg st
   A f
   ? f.orig
   $ hg shelve
   shelved as default
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
 #if repobundlerepo
   $ hg log -G --template '{rev}  {desc|firstline}  {author}' -R bundle://.hg/shelved/default.hg -r 'bundle()' --hidden
   o  [48]  changes to: commit stuff  shelve@localhost (re)
   |
   ~
 #endif
   $ hg log -G --template '{rev}  {desc|firstline}  {author}'
   @  [37]  commit stuff  test (re)
   |
   | o  2  c  test
   |/
   o  0  a  test
   
   $ mv f.orig f
   $ echo 1 > a
   $ hg unshelve --date '1073741824 0'
   unshelving change 'default'
   temporarily committing pending changes (restore with 'hg unshelve --abort')
   rebasing shelved changes
   merging f
   warning: conflicts while merging f! (edit, then use 'hg resolve --mark')
   unresolved conflicts (see 'hg resolve', then 'hg unshelve --continue')
   [240]
 
 #if phasebased
   $ hg log -G --template '{rev}  {desc|firstline}  {author}  {date|isodate}'
   @  9  pending changes temporary commit  shelve@localhost  2004-01-10 13:37 +0000
   |
   | @  8  changes to: commit stuff  shelve@localhost  1970-01-01 00:00 +0000
   |/
   o  7  commit stuff  test  1970-01-01 00:00 +0000
   |
   | o  2  c  test  1970-01-01 00:00 +0000
   |/
   o  0  a  test  1970-01-01 00:00 +0000
   
 #endif
 
 #if stripbased
   $ hg log -G --template '{rev}  {desc|firstline}  {author}  {date|isodate}'
   @  5  changes to: commit stuff  shelve@localhost  1970-01-01 00:00 +0000
   |
   | @  4  pending changes temporary commit  shelve@localhost  2004-01-10 13:37 +0000
   |/
   o  3  commit stuff  test  1970-01-01 00:00 +0000
   |
   | o  2  c  test  1970-01-01 00:00 +0000
   |/
   o  0  a  test  1970-01-01 00:00 +0000
   
 #endif
 
   $ hg st
   M f
   ? f.orig
   $ cat f
   <<<<<<< working-copy: d44eae5c3d33 - shelve: pending changes temporary commit
   g
   =======
   f
   >>>>>>> shelve:       aef214a5229c - shelve: changes to: commit stuff
   $ cat f.orig
   g
   $ hg unshelve --abort -t false
   tool option will be ignored
   unshelve of 'default' aborted
   $ hg st
   M a
   ? f.orig
   $ cat f.orig
   g
   $ hg unshelve
   unshelving change 'default'
   temporarily committing pending changes (restore with 'hg unshelve --abort')
   rebasing shelved changes
   $ hg st
   M a
   A f
   ? f.orig
 
  other committed changes - merge:
 
   $ hg shelve f
   shelved as default
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg ci a -m 'intermediate other change'
   $ mv f.orig f
   $ hg unshelve
   unshelving change 'default'
   rebasing shelved changes
   merging f
   warning: conflicts while merging f! (edit, then use 'hg resolve --mark')
   unresolved conflicts (see 'hg resolve', then 'hg unshelve --continue')
   [240]
   $ hg st
   M f
   ? f.orig
   $ cat f
   <<<<<<< working-copy: 6b563750f973 - test: intermediate other change
   g
   =======
   f
   >>>>>>> shelve:       aef214a5229c - shelve: changes to: commit stuff
   $ cat f.orig
   g
 
 #if abortcommand
 when in dry-run mode
   $ hg abort --dry-run
   unshelve in progress, will be aborted
 #endif
 
   $ hg abort
   unshelve of 'default' aborted
   $ hg st
   ? f.orig
   $ cat f.orig
   g
   $ hg shelve --delete default
   $ cd ..
 
 you shouldn't be able to ask for the patch/stats of the most recent shelve if
 there are no shelves
 
   $ hg init noshelves
   $ cd noshelves
 
   $ hg shelve --patch
   abort: there are no shelves to show
   [255]
   $ hg shelve --stat
   abort: there are no shelves to show
   [255]
 
   $ cd ..
 
 test .orig files go where the user wants them to
 ---------------------------------------------------------------
   $ hg init salvage
   $ cd salvage
   $ echo 'content' > root
   $ hg commit -A -m 'root' -q
   $ echo '' > root
   $ hg shelve -q
   $ echo 'contADDent' > root
   $ hg unshelve -q --config 'ui.origbackuppath=.hg/origbackups'
   warning: conflicts while merging root! (edit, then use 'hg resolve --mark')
   unresolved conflicts (see 'hg resolve', then 'hg unshelve --continue')
   [240]
   $ ls .hg/origbackups
   root
   $ rm -rf .hg/origbackups
 
 test Abort unshelve always gets user out of the unshelved state
 ---------------------------------------------------------------
 
 with a corrupted shelve state file
   $ sed 's/ae8c668541e8/123456789012/' .hg/shelvedstate > ../corrupt-shelvedstate
   $ mv ../corrupt-shelvedstate .hg/shelvestate
   $ hg unshelve --abort 2>&1 | grep 'aborted'
   unshelve of 'default' aborted
   $ hg summary
   parent: 0:ae8c668541e8 tip
    root
   branch: default
   commit: 1 modified
   update: (current)
   phases: 1 draft
   $ hg up -C .
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ cd ..
 
 Shelve and unshelve unknown files. For the purposes of unshelve, a shelved
 unknown file is the same as a shelved added file, except that it will be in
 unknown state after unshelve if and only if it was either absent or unknown
 before the unshelve operation.
 
   $ hg init unknowns
   $ cd unknowns
 
 The simplest case is if I simply have an unknown file that I shelve and unshelve
 
   $ echo unknown > unknown
   $ hg status
   ? unknown
   $ hg shelve --unknown
   shelved as default
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg status
   $ hg unshelve
   unshelving change 'default'
   $ hg status
   ? unknown
   $ rm unknown
 
 If I shelve, add the file, and unshelve, does it stay added?
 
   $ echo unknown > unknown
   $ hg shelve -u
   shelved as default
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg status
   $ touch unknown
   $ hg add unknown
   $ hg status
   A unknown
   $ hg unshelve
   unshelving change 'default'
   temporarily committing pending changes (restore with 'hg unshelve --abort')
   rebasing shelved changes
   merging unknown
   $ hg status
   A unknown
   $ hg forget unknown
   $ rm unknown
 
 And if I shelve, commit, then unshelve, does it become modified?
 
   $ echo unknown > unknown
   $ hg shelve -u
   shelved as default
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg status
   $ touch unknown
   $ hg add unknown
   $ hg commit -qm "Add unknown"
   $ hg status
   $ hg unshelve
   unshelving change 'default'
   rebasing shelved changes
   merging unknown
   $ hg status
   M unknown
   $ hg remove --force unknown
   $ hg commit -qm "Remove unknown"
 
   $ cd ..
 
 We expects that non-bare shelve keeps newly created branch in
 working directory.
 
   $ hg init shelve-preserve-new-branch
   $ cd shelve-preserve-new-branch
   $ echo "a" >> a
   $ hg add a
   $ echo "b" >> b
   $ hg add b
   $ hg commit -m "ab"
   $ echo "aa" >> a
   $ echo "bb" >> b
   $ hg branch new-branch
   marked working directory as branch new-branch
   (branches are permanent and global, did you want a bookmark?)
   $ hg status
   M a
   M b
   $ hg branch
   new-branch
   $ hg shelve a
   shelved as default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg branch
   new-branch
   $ hg status
   M b
   $ touch "c" >> c
   $ hg add c
   $ hg status
   M b
   A c
   $ hg shelve --exclude c
   shelved as default-01
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg branch
   new-branch
   $ hg status
   A c
   $ hg shelve --include c
   shelved as default-02
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg branch
   new-branch
   $ hg status
   $ echo "d" >> d
   $ hg add d
   $ hg status
   A d
 
 We expect that bare-shelve will not keep branch in current working directory.
 
   $ hg shelve
   shelved as default-03
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg branch
   default
   $ cd ..
 
 When i shelve commit on newly created branch i expect
 that after unshelve newly created branch will be preserved.
 
   $ hg init shelve_on_new_branch_simple
   $ cd shelve_on_new_branch_simple
   $ echo "aaa" >> a
   $ hg commit -A -m "a"
   adding a
   $ hg branch
   default
   $ hg branch test
   marked working directory as branch test
   (branches are permanent and global, did you want a bookmark?)
   $ echo "bbb" >> a
   $ hg status
   M a
   $ hg shelve
   shelved as default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg branch
   default
   $ echo "bbb" >> b
   $ hg status
   ? b
   $ hg unshelve
   unshelving change 'default'
   marked working directory as branch test
   $ hg status
   M a
   ? b
   $ hg branch
   test
   $ cd ..
 
 When i shelve commit on newly created branch, make
 some changes, unshelve it and running into merge
 conflicts i expect that after fixing them and
 running unshelve --continue newly created branch
 will be preserved.
 
   $ hg init shelve_on_new_branch_conflict
   $ cd shelve_on_new_branch_conflict
   $ echo "aaa" >> a
   $ hg commit -A -m "a"
   adding a
   $ hg branch
   default
   $ hg branch test
   marked working directory as branch test
   (branches are permanent and global, did you want a bookmark?)
   $ echo "bbb" >> a
   $ hg status
   M a
   $ hg shelve
   shelved as default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg branch
   default
   $ echo "ccc" >> a
   $ hg status
   M a
   $ hg unshelve
   unshelving change 'default'
   temporarily committing pending changes (restore with 'hg unshelve --abort')
   rebasing shelved changes
   merging a
   warning: conflicts while merging a! (edit, then use 'hg resolve --mark')
   unresolved conflicts (see 'hg resolve', then 'hg unshelve --continue')
   [240]
   $ echo "aaabbbccc" > a
   $ rm a.orig
   $ hg resolve --mark a
   (no more unresolved files)
   continue: hg unshelve --continue
   $ hg continue
   marked working directory as branch test
   unshelve of 'default' complete
   $ cat a
   aaabbbccc
   $ hg status
   M a
   $ hg branch
   test
   $ hg commit -m "test-commit"
 
 When i shelve on test branch, update to default branch
 and unshelve i expect that it will not preserve previous
 test branch.
 
   $ echo "xxx" > b
   $ hg add b
   $ hg shelve
   shelved as test
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg update -r 7049e48789d7
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg unshelve
   unshelving change 'test'
   rebasing shelved changes
   $ hg status
   A b
   $ hg branch
   default
   $ cd ..
 
 When i unshelve resulting in merge conflicts and makes saved
 file shelvedstate looks like in previous versions in
 mercurial(without restore branch information in 7th line) i
 expect that after resolving conflicts and successfully
 running 'shelve --continue' the branch information won't be
 restored and branch will be unchanged.
 
 shelve on new branch, conflict with previous shelvedstate
 
   $ hg init conflict
   $ cd conflict
   $ echo "aaa" >> a
   $ hg commit -A -m "a"
   adding a
   $ hg branch
   default
   $ hg branch test
   marked working directory as branch test
   (branches are permanent and global, did you want a bookmark?)
   $ echo "bbb" >> a
   $ hg status
   M a
   $ hg shelve
   shelved as default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg branch
   default
   $ echo "ccc" >> a
   $ hg status
   M a
   $ hg unshelve
   unshelving change 'default'
   temporarily committing pending changes (restore with 'hg unshelve --abort')
   rebasing shelved changes
   merging a
   warning: conflicts while merging a! (edit, then use 'hg resolve --mark')
   unresolved conflicts (see 'hg resolve', then 'hg unshelve --continue')
   [240]
 
 Removing restore branch information from shelvedstate file(making it looks like
 in previous versions) and running unshelve --continue
 
   $ cp .hg/shelvedstate .hg/shelvedstate_old
   $ cat .hg/shelvedstate_old | grep -v 'branchtorestore' > .hg/shelvedstate
 
   $ echo "aaabbbccc" > a
   $ rm a.orig
   $ hg resolve --mark a
   (no more unresolved files)
   continue: hg unshelve --continue
 
 #if continuecommand
   $ hg continue --dry-run
   unshelve in progress, will be resumed
 #endif
 
   $ hg continue
   unshelve of 'default' complete
   $ cat a
   aaabbbccc
   $ hg status
   M a
   $ hg branch
   default
   $ cd ..
 
 On non bare shelve the branch information shouldn't be restored
 
   $ hg init bare_shelve_on_new_branch
   $ cd bare_shelve_on_new_branch
   $ echo "aaa" >> a
   $ hg commit -A -m "a"
   adding a
   $ hg branch
   default
   $ hg branch test
   marked working directory as branch test
   (branches are permanent and global, did you want a bookmark?)
   $ echo "bbb" >> a
   $ hg status
   M a
   $ hg shelve a
   shelved as default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg branch
   test
   $ hg branch default
   marked working directory as branch default
   (branches are permanent and global, did you want a bookmark?)
   $ echo "bbb" >> b
   $ hg status
   ? b
   $ hg unshelve
   unshelving change 'default'
   $ hg status
   M a
   ? b
   $ hg branch
   default
   $ cd ..
 
 Prepare unshelve with a corrupted shelvedstate
   $ hg init r1 && cd r1
   $ echo text1 > file && hg add file
   $ hg shelve
   shelved as default
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ echo text2 > file && hg ci -Am text1
   adding file
   $ hg unshelve
   unshelving change 'default'
   rebasing shelved changes
   merging file
   warning: conflicts while merging file! (edit, then use 'hg resolve --mark')
   unresolved conflicts (see 'hg resolve', then 'hg unshelve --continue')
   [240]
   $ echo somethingsomething > .hg/shelvedstate
 
 Unshelve --continue fails with appropriate message if shelvedstate is corrupted
   $ hg continue
   abort: corrupted shelved state file
   (please run hg unshelve --abort to abort unshelve operation)
   [255]
 
 Unshelve --abort works with a corrupted shelvedstate
   $ hg abort
   abort: could not read shelved state file, your working copy may be in an unexpected state
   please update to some commit
   
   [255]
 
 Unshelve --abort fails with appropriate message if there's no unshelve in
 progress
 
 #if abortflag
   $ hg unshelve --abort
   abort: no unshelve in progress
   [20]
 #else
   $ hg abort
   aborting the merge, updating back to 9451eaa6eee3
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 #endif
   $ cd ..
 
 Test corrupt shelves (in .hg/shelved/, not .hg/shelvestate)
   $ hg init corrupt-shelves
   $ cd corrupt-shelves
   $ mkdir .hg/shelved
 
 # A (corrupt) .patch file without a .hg file
   $ touch .hg/shelved/junk1.patch
   $ hg shelve -l
   $ hg unshelve
   abort: no shelved changes to apply!
   [20]
   $ hg shelve -d junk1
   abort: shelved change 'junk1' not found
   [10]
   $ find .hg/shelve* | sort
   .hg/shelved
   .hg/shelved/junk1.patch
 
 # A .hg file without a .patch file
   $ touch .hg/shelved/junk2.hg
   $ hg shelve -l
   $ hg unshelve
   abort: no shelved changes to apply!
   [20]
   $ hg shelve -d junk2
   abort: shelved change 'junk2' not found
   [10]
   $ find .hg/shelve* | sort
   .hg/shelved
   .hg/shelved/junk1.patch
   .hg/shelved/junk2.hg
 
 # A file with an unexpected extension
   $ touch .hg/shelved/junk3
-  $ hg shelve -l 2>&1 | grep ValueError
-  ValueError: * (glob)
-  $ hg unshelve 2>&1 | grep ValueError
-  ValueError: * (glob)
+  $ hg shelve -l
+  $ hg unshelve
+  abort: no shelved changes to apply!
+  [20]
   $ hg shelve -d junk3
   abort: shelved change 'junk3' not found
   [10]
   $ find .hg/shelve* | sort
   .hg/shelved
   .hg/shelved/junk1.patch
   .hg/shelved/junk2.hg
   .hg/shelved/junk3
 
   $ cd ..
 
 Unshelve respects --keep even if user intervention is needed
   $ hg init unshelvekeep && cd unshelvekeep
   $ echo 1 > file && hg ci -Am 1
   adding file
   $ echo 2 >> file
   $ hg shelve
   shelved as default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo 3 >> file && hg ci -Am 13
   $ hg shelve --list
   default         (*s ago) * changes to: 1 (glob)
   $ hg unshelve --keep
   unshelving change 'default'
   rebasing shelved changes
   merging file
   warning: conflicts while merging file! (edit, then use 'hg resolve --mark')
   unresolved conflicts (see 'hg resolve', then 'hg unshelve --continue')
   [240]
   $ hg resolve --mark file
   (no more unresolved files)
   continue: hg unshelve --continue
   $ hg continue
   unshelve of 'default' complete
   $ hg shelve --list
   default         (*s ago) * changes to: 1 (glob)
   $ cd ..
 
 Unshelving when there are deleted files does not crash (issue4176)
   $ hg init unshelve-deleted-file && cd unshelve-deleted-file
   $ echo a > a && echo b > b && hg ci -Am ab
   adding a
   adding b
   $ echo aa > a && hg shelve
   shelved as default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ rm b
   $ hg st
   ! b
   $ hg unshelve
   unshelving change 'default'
   $ hg shelve
   shelved as default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ rm a && echo b > b
   $ hg st
   ! a
   $ hg unshelve
   unshelving change 'default'
   abort: shelved change touches missing files
   (run hg status to see which files are missing)
   [255]
   $ hg st
   ! a
   $ cd ..
 
 New versions of Mercurial know how to read onld shelvedstate files
   $ hg init oldshelvedstate
   $ cd oldshelvedstate
   $ echo root > root && hg ci -Am root
   adding root
   $ echo 1 > a
   $ hg add a
   $ hg shelve --name ashelve
   shelved as ashelve
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ echo 2 > a
   $ hg ci -Am a
   adding a
   $ hg unshelve
   unshelving change 'ashelve'
   rebasing shelved changes
   merging a
   warning: conflicts while merging a! (edit, then use 'hg resolve --mark')
   unresolved conflicts (see 'hg resolve', then 'hg unshelve --continue')
   [240]
 putting v1 shelvedstate file in place of a created v2
   $ cat << EOF > .hg/shelvedstate
   > 1
   > ashelve
   > 8b058dae057a5a78f393f4535d9e363dd5efac9d
   > 8b058dae057a5a78f393f4535d9e363dd5efac9d
   > 8b058dae057a5a78f393f4535d9e363dd5efac9d f543b27db2cdb41737e2e0008dc524c471da1446
   > f543b27db2cdb41737e2e0008dc524c471da1446
   > 
   > nokeep
   > :no-active-bookmark
   > EOF
   $ echo 1 > a
   $ hg resolve --mark a
   (no more unresolved files)
   continue: hg unshelve --continue
 mercurial does not crash
   $ hg continue
   unshelve of 'ashelve' complete
 
 #if phasebased
 
 Unshelve with some metadata file missing
 ----------------------------------------
 
   $ hg shelve
   shelved as default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo 3 > a
 
 Test with the `.shelve` missing, but the changeset still in the repo (non-natural case)
 
   $ rm .hg/shelved/default.shelve
   $ hg unshelve
   unshelving change 'default'
   temporarily committing pending changes (restore with 'hg unshelve --abort')
   rebasing shelved changes
   merging a
   warning: conflicts while merging a! (edit, then use 'hg resolve --mark')
   unresolved conflicts (see 'hg resolve', then 'hg unshelve --continue')
   [240]
   $ hg abort
   unshelve of 'default' aborted
 
 Unshelve without .shelve metadata (can happen when upgrading a repository with old shelve)
 
   $ cat .hg/shelved/default.shelve
   node=82e0cb9893247d12667017593ce1e5655860f1ac
   $ hg strip --hidden --rev 82e0cb989324 --no-backup
   $ rm .hg/shelved/default.shelve
   $ hg unshelve
   unshelving change 'default'
   temporarily committing pending changes (restore with 'hg unshelve --abort')
   rebasing shelved changes
   merging a
   warning: conflicts while merging a! (edit, then use 'hg resolve --mark')
   unresolved conflicts (see 'hg resolve', then 'hg unshelve --continue')
   [240]
   $ cat .hg/shelved/default.shelve
   node=82e0cb9893247d12667017593ce1e5655860f1ac
   $ hg abort
   unshelve of 'default' aborted
 
 #endif
 
   $ cd ..
 
 Block merge abort when unshelve in progress(issue6160)
 ------------------------------------------------------
 
   $ hg init a
   $ cd a
   $ echo foo > a ; hg commit -qAm "initial commit"
   $ echo bar > a
   $ hg shelve
   shelved as default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo foobar > a
   $ hg unshelve
   unshelving change 'default'
   temporarily committing pending changes (restore with 'hg unshelve --abort')
   rebasing shelved changes
   merging a
   warning: conflicts while merging a! (edit, then use 'hg resolve --mark')
   unresolved conflicts (see 'hg resolve', then 'hg unshelve --continue')
   [240]
 
   $ hg log --template '{desc|firstline}  {author}  {date|isodate} \n' -r .
   pending changes temporary commit  shelve@localhost  1970-01-01 00:00 +0000 
   $ hg merge --abort
   abort: cannot abort merge with unshelve in progress
   (use 'hg unshelve --continue' or 'hg unshelve --abort')
   [20]
 
   $ hg unshelve --abort
   unshelve of 'default' aborted
 
   $ hg log -G --template '{desc|firstline}  {author}  {date|isodate} \n' -r .
   @  initial commit  test  1970-01-01 00:00 +0000
   
   $ cd ..
 
 Demonstrate that the labels are correct in the merge conflict
 -------------------------------------------------------------
   $ hg init labels
   $ cd labels
   $ echo r0 > foo
   $ hg ci -qAm r0
   $ echo "this will be shelved" >> foo
   $ hg shelve -q
   $ echo "this is in wdir, conflicts with shelve" >> foo
   $ hg unshelve -q
   warning: conflicts while merging foo! (edit, then use 'hg resolve --mark')
   unresolved conflicts (see 'hg resolve', then 'hg unshelve --continue')
   [240]
   $ cat foo
   r0
   <<<<<<< working-copy: 0b2fcf2a90e9 - shelve: pending changes temporary commit
   this is in wdir, conflicts with shelve
   =======
   this will be shelved
   >>>>>>> shelve:       9c072a2163db - shelve: changes to: r0
   $ cd ..