phase-shelve: honor and prefer obs shelves for existence and modified time

mercurial/shelve.py

@@ -1,1210 +1,1217 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".
 """
 
 import collections
 import io
 import itertools
 import stat
 
 from .i18n import _
 from .node import (
     bin,
     hex,
     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']
 
 # we never need the user, so we use a
 # generic user for all shelve operations
 shelveuser = b'shelve@localhost'
 
 
 class ShelfDir:
     def __init__(self, repo, for_backups=False):
         if for_backups:
             self.vfs = vfsmod.vfs(repo.vfs.join(backupdir))
         else:
             self.vfs = vfsmod.vfs(repo.vfs.join(shelvedir))
 
     def get(self, name):
         return Shelf(self.vfs, name)
 
     def listshelves(self):
         """return all shelves in repo as list of (time, name)"""
         try:
             names = self.vfs.listdir()
         except FileNotFoundError:
             return []
         info = []
         seen = set()
         for filename in names:
             name = filename.rsplit(b'.', 1)[0]
             if name in seen:
                 continue
             seen.add(name)
             shelf = self.get(name)
             if not shelf.exists():
                 continue
             mtime = shelf.mtime()
             info.append((mtime, name))
         return sorted(info, reverse=True)
 
 
 class Shelf:
     """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, vfs, name):
         self.vfs = vfs
         self.name = name
 
     def exists(self):
-        return self.vfs.exists(self.name + b'.patch') and self.vfs.exists(
-            self.name + b'.hg'
-        )
+        return self._exists(b'.shelve') or self._exists(b'.patch', b'.hg')
+
+    def _exists(self, *exts):
+        return all(self.vfs.exists(self.name + ext) for ext in exts)
 
     def mtime(self):
-        return self.vfs.stat(self.name + b'.patch')[stat.ST_MTIME]
+        try:
+            return self._stat(b'.shelve')[stat.ST_MTIME]
+        except FileNotFoundError:
+            return self._stat(b'.patch')[stat.ST_MTIME]
+
+    def _stat(self, ext):
+        return self.vfs.stat(self.name + ext)
 
     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, repo, bases, node):
         cgversion = changegroup.safeversion(repo)
         if cgversion == b'01':
             btype = b'HG10BZ'
             compression = None
         else:
             btype = b'HG20'
             compression = b'BZ'
 
         repo = 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(
             repo.ui,
             cg,
             bundle_filename,
             btype,
             self.vfs,
             compression=compression,
         )
 
     def applybundle(self, repo, tr):
         filename = self.name + b'.hg'
         fp = self.vfs(filename)
         try:
             targetphase = phases.internal
             if not phases.supportinternal(repo):
                 targetphase = phases.secret
             gen = exchange.readbundle(repo.ui, fp, filename, self.vfs)
             pretip = repo[b'tip']
             bundle2.applybundle(
                 repo,
                 gen,
                 tr,
                 source=b'unshelve',
                 url=b'bundle:' + self.vfs.join(filename),
                 targetphase=targetphase,
             )
             shelvectx = repo[b'tip']
             if pretip == shelvectx:
                 shelverev = tr.changes[b'revduplicates'][-1]
                 shelvectx = repo[shelverev]
             return shelvectx
         finally:
             fp.close()
 
     def open_patch(self, mode=b'rb'):
         return self.vfs(self.name + b'.patch', mode)
 
     def patch_from_node(self, repo, node):
         repo = repo.unfiltered()
         match = _optimized_match(repo, node)
         fp = io.BytesIO()
         cmdutil.exportfile(
             repo,
             [node],
             fp,
             opts=mdiff.diffopts(git=True),
             match=match,
         )
         fp.seek(0)
         return fp
 
     def load_patch(self, repo):
         try:
             # prefer node-based shelf
             return self.patch_from_node(repo, self.readinfo()[b'node'])
         except (FileNotFoundError, error.RepoLookupError):
             return self.open_patch()
 
     def _backupfilename(self, backupvfs, 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 backupvfs.exists(n):
                 return backupvfs.join(n)
 
     def movetobackup(self, backupvfs):
         if not backupvfs.isdir():
             backupvfs.makedir()
         for suffix in shelvefileextensions:
             filename = self.name + b'.' + suffix
             if self.vfs.exists(filename):
                 util.rename(
                     self.vfs.join(filename),
                     self._backupfilename(backupvfs, filename),
                 )
 
     def delete(self):
         for ext in shelvefileextensions:
             self.vfs.tryunlink(self.name + b'.' + ext)
 
 
 def _optimized_match(repo, node):
     """
     Create a matcher so that prefetch doesn't attempt to fetch
     the entire repository pointlessly, and as an optimisation
     for movedirstate, if needed.
     """
     return scmutil.matchfiles(repo, repo[node].files())
 
 
 class shelvedstate:
     """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, KeyError) as err:
             raise error.CorruptedState(stringutil.forcebytestr(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(stringutil.forcebytestr(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):
     maxbackups = repo.ui.configint(b'shelve', b'maxbackups')
     backup_dir = ShelfDir(repo, for_backups=True)
     hgfiles = backup_dir.listshelves()
     if maxbackups > 0 and maxbackups < len(hgfiles):
         bordermtime = hgfiles[maxbackups - 1][0]
     else:
         bordermtime = None
     for mtime, name in hgfiles[maxbackups:]:
         if mtime == bordermtime:
             # keep it, because timestamp can't decide exact order of backups
             continue
         backup_dir.get(name).delete()
 
 
 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 ShelfDir(repo).get(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:
         shelf_dir = ShelfDir(repo)
         for n in gennames():
             if not shelf_dir.get(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 = ShelfDir(repo).get(name)
     shelf.writeinfo(info)
     bases = list(mutableancestors(repo[node]))
     shelf.writebundle(repo, 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.rev() != nullrev:
         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
 
         match = _optimized_match(repo, node)
         _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():
         shelf_dir = ShelfDir(repo)
         backupvfs = vfsmod.vfs(repo.vfs.join(backupdir))
         for _mtime, name in shelf_dir.listshelves():
             shelf_dir.get(name).movetobackup(backupvfs)
             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():
         backupvfs = vfsmod.vfs(repo.vfs.join(backupdir))
         for name in pats:
             shelf = ShelfDir(repo).get(name)
             if not shelf.exists():
                 raise error.InputError(
                     _(b"shelved change '%s' not found") % name
                 )
             shelf.movetobackup(backupvfs)
             cleanupoldbackups(repo)
 
 
 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')
     shelf_dir = ShelfDir(repo)
     for mtime, name in shelf_dir.listshelves():
         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_dir.get(name).load_patch(repo) 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"""
     shelf_dir = ShelfDir(repo)
     if len(pats) == 0:
         shelves = shelf_dir.listshelves()
         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_dir.get(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 FileNotFoundError:
         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())
         cmdutil.revert(ui, repo, shelvectx)
 
 
 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'):
         backupvfs = vfsmod.vfs(repo.vfs.join(backupdir))
         ShelfDir(repo).get(name).movetobackup(backupvfs)
         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 ms.unresolvedcount():
             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(), repo.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], repo.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 = ShelfDir(repo).get(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(repo, 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 = _optimized_match(repo, snode)
         _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'shelved change',
                 b'parent of shelved change',
             ],
             keepconflictparent=True,
         )
         if stats.unresolvedcount:
             tr.close()
 
             nodestoremove = [
                 repo.changelog.node(rev) for rev in range(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(), repo.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 = ShelfDir(repo).listshelves()
         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 ShelfDir(repo).get(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-shelve.t

@@ -1,1537 +1,1537 b''
 #testcases stripbased phasebased
 
   $ 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
 
   $ hg init repo
   $ cd repo
   $ mkdir a b
   $ echo a > a/a
   $ echo b > b/b
   $ echo c > c
   $ echo d > d
   $ echo x > x
   $ hg addremove -q
 
 shelve has a help message
   $ hg shelve -h
   hg shelve [OPTION]... [FILE]...
   
   save and set aside changes from the working directory
   
       Shelving takes files that "hg status" reports as not clean, saves the
       modifications to a bundle (a shelved change), and reverts the files so
       that their state in the working directory becomes clean.
   
       To restore these changes to the working directory, using "hg unshelve";
       this will work even if you switch to a different commit.
   
       When no files are specified, "hg shelve" saves all not-clean files. If
       specific files or directories are named, only changes to those files are
       shelved.
   
       In bare shelve (when no files are specified, without interactive, include
       and exclude option), shelving remembers information if the working
       directory was on newly created branch, in other words working directory
       was on different branch than its first parent. In this situation
       unshelving restores branch information to the working directory.
   
       Each shelved change has a name that makes it easier to find later. The
       name of a shelved change defaults to being based on the active bookmark,
       or if there is no active bookmark, the current named branch.  To specify a
       different name, use "--name".
   
       To see a list of existing shelved changes, use the "--list" option. For
       each shelved change, this will print its name, age, and description; use "
       --patch" or "--stat" for more details.
   
       To delete specific shelved changes, use "--delete". To delete all shelved
       changes, use "--cleanup".
   
   options ([+] can be repeated):
   
    -A --addremove           mark new/missing files as added/removed before
                             shelving
    -u --unknown             store unknown files in the shelve
       --cleanup             delete all shelved changes
       --date DATE           shelve with the specified commit date
    -d --delete              delete the named shelved change(s)
    -e --edit                invoke editor on commit messages
    -k --keep                shelve, but keep changes in the working directory
    -l --list                list current shelves
    -m --message TEXT        use text as shelve message
    -n --name NAME           use the given name for the shelved commit
    -p --patch               output patches for changes (provide the names of the
                             shelved changes as positional arguments)
    -i --interactive         interactive mode
       --stat                output diffstat-style summary of changes (provide
                             the names of the shelved changes as positional
                             arguments)
    -I --include PATTERN [+] include names matching the given patterns
    -X --exclude PATTERN [+] exclude names matching the given patterns
       --mq                  operate on patch repository
   
   (some details hidden, use --verbose to show complete help)
 
 shelving in an empty repo should be possible
 (this tests also that editor is not invoked, if '--edit' is not
 specified)
 
   $ HGEDITOR=cat hg shelve
   shelved as default
   0 files updated, 0 files merged, 5 files removed, 0 files unresolved
 
   $ hg unshelve
   unshelving change 'default'
 
   $ hg commit -q -m 'initial commit'
 
   $ hg shelve
   nothing changed
   [1]
 
 make sure shelve files were backed up
 
   $ ls .hg/shelve-backup
   default.hg
   default.patch
   default.shelve
 
 checks to make sure we dont create a directory or
 hidden file while choosing a new shelve name
 
 when we are given a name
 
   $ hg shelve -n foo/bar
   abort: shelved change names can not contain slashes
   [255]
   $ hg shelve -n .baz
   abort: shelved change names can not start with '.'
   [255]
   $ hg shelve -n foo\\bar
   abort: shelved change names can not contain slashes
   [255]
 
 when shelve has to choose itself
 
   $ hg branch x/y -q
   $ hg commit -q -m "Branch commit 0"
   $ hg shelve
   nothing changed
   [1]
   $ hg branch .x -q
   $ hg commit -q -m "Branch commit 1"
   $ hg shelve
   nothing changed
   [1]
   $ hg branch x\\y -q
   $ hg commit -q -m "Branch commit 2"
   $ hg shelve
   nothing changed
   [1]
 
 cleaning the branches made for name checking tests
 
   $ hg up default -q
   $ hg strip e9177275307e+6a6d231f43d+882bae7c62c2 -q
 
 create an mq patch - shelving should work fine with a patch applied
 
   $ echo n > n
   $ hg add n
   $ hg commit n -m second
   $ hg qnew second.patch
 
 shelve a change that we will delete later
 
   $ echo a >> a/a
   $ hg shelve
   shelved as default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 set up some more complex changes to shelve
 
   $ echo a >> a/a
   $ hg mv b b.rename
   moving b/b to b.rename/b
   $ hg cp c c.copy
   $ hg mv d ghost
   $ rm ghost
   $ hg status -C
   M a/a
   A b.rename/b
     b/b
   A c.copy
     c
   R b/b
   R d
   ! ghost
     d
 
 the common case - no options or filenames
 
   $ hg shelve
   shelved as default-01
   3 files updated, 0 files merged, 2 files removed, 0 files unresolved
   $ hg status -C
 
 ensure that our shelved changes exist
 
   $ hg shelve -l
   default-01      (*)* changes to: [mq]: second.patch (glob)
   default         (*)* changes to: [mq]: second.patch (glob)
 
   $ hg shelve -l -p default
   default         (*)* changes to: [mq]: second.patch (glob)
   
   diff --git a/a/a b/a/a
   --- a/a/a
   +++ b/a/a
   @@ -1,1 +1,2 @@
    a
   +a
 
   $ hg shelve --list --addremove
   abort: options '--list' and '--addremove' may not be used together
   [10]
 
 delete our older shelved change
 
   $ hg shelve -d default
   $ hg qfinish -a -q
 
 ensure shelve backups aren't overwritten
 
   $ ls .hg/shelve-backup/
   default-1.hg
   default-1.patch
   default-1.shelve
   default.hg
   default.patch
   default.shelve
 
 local edits should not prevent a shelved change from applying
 
   $ printf "z\na\n" > a/a
   $ hg unshelve --keep
   unshelving change 'default-01'
   temporarily committing pending changes (restore with 'hg unshelve --abort')
   rebasing shelved changes
   merging a/a
 
   $ hg revert --all -q
   $ rm a/a.orig b.rename/b c.copy
 
 apply it and make sure our state is as expected
 
 (this also tests that same timestamp prevents backups from being
 removed, even though there are more than 'maxbackups' backups)
 
-  $ f -t .hg/shelve-backup/default.patch
-  .hg/shelve-backup/default.patch: file
-  $ touch -t 200001010000 .hg/shelve-backup/default.patch
-  $ f -t .hg/shelve-backup/default-1.patch
-  .hg/shelve-backup/default-1.patch: file
-  $ touch -t 200001010000 .hg/shelve-backup/default-1.patch
+  $ f -t .hg/shelve-backup/default.shelve
+  .hg/shelve-backup/default.shelve: file
+  $ touch -t 200001010000 .hg/shelve-backup/default.shelve
+  $ f -t .hg/shelve-backup/default-1.shelve
+  .hg/shelve-backup/default-1.shelve: file
+  $ touch -t 200001010000 .hg/shelve-backup/default-1.shelve
 
   $ hg unshelve
   unshelving change 'default-01'
   $ hg status -C
   M a/a
   A b.rename/b
     b/b
   A c.copy
     c
   R b/b
   R d
   $ hg shelve -l
 
 (both of default.hg and default-1.hg should be still kept, because it
 is difficult to decide actual order of them from same timestamp)
 
   $ ls .hg/shelve-backup/
   default-01.hg
   default-01.patch
   default-01.shelve
   default-1.hg
   default-1.patch
   default-1.shelve
   default.hg
   default.patch
   default.shelve
 
   $ hg unshelve
   abort: no shelved changes to apply!
   [20]
   $ hg unshelve foo
   abort: shelved change 'foo' not found
   [10]
 
 named shelves, specific filenames, and "commit messages" should all work
 (this tests also that editor is invoked, if '--edit' is specified)
 
   $ hg status -C
   M a/a
   A b.rename/b
     b/b
   A c.copy
     c
   R b/b
   R d
   $ HGEDITOR=cat hg shelve -q -n wibble -m wat -e a
   wat
   
   
   HG: Enter commit message.  Lines beginning with 'HG:' are removed.
   HG: Leave message empty to abort commit.
   HG: --
   HG: user: shelve@localhost
   HG: branch 'default'
   HG: changed a/a
 
 expect "a" to no longer be present, but status otherwise unchanged
 
   $ hg status -C
   A b.rename/b
     b/b
   A c.copy
     c
   R b/b
   R d
   $ hg shelve -l --stat
   wibble          (*)    wat (glob)
    a/a |  1 +
    1 files changed, 1 insertions(+), 0 deletions(-)
 
 and now "a/a" should reappear
 
   $ cd a
   $ hg unshelve -q wibble
   $ cd ..
   $ hg status -C
   M a/a
   A b.rename/b
     b/b
   A c.copy
     c
   R b/b
   R d
 
 ensure old shelve backups are being deleted automatically
 
   $ ls .hg/shelve-backup/
   default-01.hg
   default-01.patch
   default-01.shelve
   wibble.hg
   wibble.patch
   wibble.shelve
 
 cause unshelving to result in a merge with 'a' conflicting
 
   $ hg shelve -q
   $ echo c>>a/a
   $ hg commit -m second
   $ hg tip --template '{files}\n'
   a/a
 
 add an unrelated change that should be preserved
 
   $ mkdir foo
   $ echo foo > foo/foo
   $ hg add foo/foo
 
 force a conflicted merge to occur
 
   $ hg unshelve
   unshelving change 'default'
   temporarily committing pending changes (restore with 'hg unshelve --abort')
   rebasing shelved changes
   merging a/a
   warning: conflicts while merging a/a! (edit, then use 'hg resolve --mark')
   unresolved conflicts (see 'hg resolve', then 'hg unshelve --continue')
   [240]
   $ hg status -v
   M a/a
   M b.rename/b
   M c.copy
   R b/b
   R d
   ? a/a.orig
   # The repository is in an unfinished *unshelve* state.
   
   # Unresolved merge conflicts:
   # 
   #     a/a
   # 
   # To mark files as resolved:  hg resolve --mark FILE
   
   # To continue:    hg unshelve --continue
   # To abort:       hg unshelve --abort
   
 
 ensure that we have a merge with unresolved conflicts
 
 #if phasebased
   $ hg heads -q --template '{rev}\n'
   8
   5
   $ hg parents -q --template '{rev}\n'
   8
   5
 #endif
 
 #if stripbased
   $ hg heads -q --template '{rev}\n'
   5
   4
   $ hg parents -q --template '{rev}\n'
   4
   5
 #endif
 
   $ hg status
   M a/a
   M b.rename/b
   M c.copy
   R b/b
   R d
   ? a/a.orig
   $ hg diff
   diff --git a/a/a b/a/a
   --- a/a/a
   +++ b/a/a
   @@ -1,2 +1,6 @@
    a
   +<<<<<<< working-copy:   2377350b6337 - shelve: pending changes temporary commit
    c
   +=======
   +a
   +>>>>>>> shelved change: 203c9f771d2b - shelve: changes to: [mq]: second.patch
   diff --git a/b/b b/b.rename/b
   rename from b/b
   rename to b.rename/b
   diff --git a/c b/c.copy
   copy from c
   copy to c.copy
   diff --git a/d b/d
   deleted file mode 100644
   --- a/d
   +++ /dev/null
   @@ -1,1 +0,0 @@
   -d
   $ hg resolve -l
   U a/a
 
   $ hg shelve
   abort: unshelve already in progress
   (use 'hg unshelve --continue' or 'hg unshelve --abort')
   [20]
 
 abort the unshelve and be happy
 
   $ hg status
   M a/a
   M b.rename/b
   M c.copy
   R b/b
   R d
   ? a/a.orig
   $ hg unshelve -a
   unshelve of 'default' aborted
   $ hg heads -q
   [37]:2e69b451d1ea (re)
   $ hg parents
   changeset:   [37]:2e69b451d1ea (re)
   tag:         tip
   parent:      3:509104101065 (?)
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     second
   
   $ hg resolve -l
   $ hg status
   A foo/foo
   ? a/a.orig
 
 try to continue with no unshelve underway
 
   $ hg unshelve -c
   abort: no unshelve in progress
   [20]
   $ hg status
   A foo/foo
   ? a/a.orig
 
 redo the unshelve to get a conflict
 
   $ hg unshelve -q
   warning: conflicts while merging a/a! (edit, then use 'hg resolve --mark')
   unresolved conflicts (see 'hg resolve', then 'hg unshelve --continue')
   [240]
 
 attempt to continue
 
   $ hg unshelve -c
   abort: unresolved conflicts, can't continue
   (see 'hg resolve', then 'hg unshelve --continue')
   [255]
 
   $ hg revert -r . a/a
   $ hg resolve -m a/a
   (no more unresolved files)
   continue: hg unshelve --continue
 
   $ hg commit -m 'commit while unshelve in progress'
   abort: unshelve already in progress
   (use 'hg unshelve --continue' or 'hg unshelve --abort')
   [20]
 
   $ hg graft --continue
   abort: no graft in progress
   (continue: hg unshelve --continue)
   [20]
   $ hg unshelve -c
   unshelve of 'default' complete
 
 ensure the repo is as we hope
 
   $ hg parents
   changeset:   [37]:2e69b451d1ea (re)
   tag:         tip
   parent:      3:509104101065 (?)
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     second
   
   $ hg heads -q
   [37]:2e69b451d1ea (re)
 
   $ hg status -C
   A b.rename/b
     b/b
   A c.copy
     c
   A foo/foo
   R b/b
   R d
   ? a/a.orig
 
 there should be no shelves left
 
   $ hg shelve -l
 
 #if execbit
 
 ensure that metadata-only changes are shelved
 
   $ chmod +x a/a
   $ hg shelve -q -n execbit a/a
   $ hg status a/a
   $ hg unshelve -q execbit
   $ hg status a/a
   M a/a
   $ hg revert a/a
 
 #else
 
 Dummy shelve op, to keep rev numbers aligned
 
   $ echo foo > a/a
   $ hg shelve -q -n dummy a/a
   $ hg unshelve -q dummy
   $ hg revert a/a
 
 #endif
 
 #if symlink
 
   $ rm a/a
   $ ln -s foo a/a
   $ hg shelve -q -n symlink a/a
   $ hg status a/a
   $ hg unshelve -q -n symlink
   $ hg status a/a
   M a/a
   $ hg revert a/a
 
 #else
 
 Dummy shelve op, to keep rev numbers aligned
 
   $ echo bar > a/a
   $ hg shelve -q -n dummy a/a
   $ hg unshelve -q dummy
   $ hg revert a/a
 
 #endif
 
 set up another conflict between a commit and a shelved change
 
   $ hg revert -q -C -a
   $ rm a/a.orig b.rename/b c.copy
   $ echo a >> a/a
   $ hg shelve -q
   $ echo x >> a/a
   $ hg ci -m 'create conflict'
   $ hg add foo/foo
 
 if we resolve a conflict while unshelving, the unshelve should succeed
 
   $ hg unshelve --tool :merge-other --keep
   unshelving change 'default'
   temporarily committing pending changes (restore with 'hg unshelve --abort')
   rebasing shelved changes
   merging a/a
   $ hg parents -q
   (4|13):33f7f61e6c5e (re)
   $ hg shelve -l
   default         (*)* changes to: second (glob)
   $ hg status
   M a/a
   A foo/foo
   $ cat a/a
   a
   c
   a
   $ cat > a/a << EOF
   > a
   > c
   > x
   > EOF
 
   $ HGMERGE=true hg unshelve
   unshelving change 'default'
   temporarily committing pending changes (restore with 'hg unshelve --abort')
   rebasing shelved changes
   merging a/a
   note: unshelved changes already existed in the working copy
   $ hg parents -q
   (4|13):33f7f61e6c5e (re)
   $ hg shelve -l
   $ hg status
   A foo/foo
   $ cat a/a
   a
   c
   x
 
 test keep and cleanup
 
   $ hg shelve
   shelved as default
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg shelve --list
   default         (*)* changes to: create conflict (glob)
   $ hg unshelve -k
   unshelving change 'default'
   $ hg shelve --list
   default         (*)* changes to: create conflict (glob)
   $ hg shelve --cleanup
   $ hg shelve --list
 
   $ hg shelve --cleanup --delete
   abort: options '--cleanup' and '--delete' may not be used together
   [10]
   $ hg shelve --cleanup --patch
   abort: options '--cleanup' and '--patch' may not be used together
   [10]
   $ hg shelve --cleanup --message MESSAGE
   abort: options '--cleanup' and '--message' may not be used together
   [10]
 
 test bookmarks
 
   $ hg bookmark test
   $ hg bookmark
    \* test                      (4|13):33f7f61e6c5e (re)
   $ hg shelve
   shelved as test
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg bookmark
    \* test                      (4|13):33f7f61e6c5e (re)
   $ hg unshelve
   unshelving change 'test'
   $ hg bookmark
    \* test                      (4|13):33f7f61e6c5e (re)
 
 shelve should still work even if mq is disabled
 
   $ hg --config extensions.mq=! shelve
   shelved as test
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg --config extensions.mq=! shelve --list
   test            (*)* changes to: create conflict (glob)
   $ hg bookmark
    \* test                      (4|13):33f7f61e6c5e (re)
   $ hg --config extensions.mq=! unshelve
   unshelving change 'test'
   $ hg bookmark
    \* test                      (4|13):33f7f61e6c5e (re)
 
 Recreate some conflict again
 
   $ hg up -C -r 2e69b451d1ea
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (leaving bookmark test)
   $ echo y >> a/a
   $ hg shelve
   shelved as default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg up test
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (activating bookmark test)
   $ hg bookmark
    \* test                      (4|13):33f7f61e6c5e (re)
   $ hg unshelve
   unshelving change 'default'
   rebasing shelved changes
   merging a/a
   warning: conflicts while merging a/a! (edit, then use 'hg resolve --mark')
   unresolved conflicts (see 'hg resolve', then 'hg unshelve --continue')
   [240]
   $ hg bookmark
      test                      (4|13):33f7f61e6c5e (re)
 
 Test that resolving all conflicts in one direction (so that the rebase
 is a no-op), works (issue4398)
 
   $ hg revert -a -r .
   reverting a/a
   $ hg resolve -m a/a
   (no more unresolved files)
   continue: hg unshelve --continue
   $ hg unshelve -c
   note: unshelved changes already existed in the working copy
   unshelve of 'default' complete
   $ hg bookmark
    \* test                      (4|13):33f7f61e6c5e (re)
   $ hg diff
   $ hg status
   ? a/a.orig
   ? foo/foo
   $ hg summary
   parent: (4|13):33f7f61e6c5e tip (re)
    create conflict
   branch: default
   bookmarks: *test
   commit: 2 unknown (clean)
   update: (current)
   phases: 5 draft
 
   $ hg shelve --delete --stat
   abort: options '--delete' and '--stat' may not be used together
   [10]
   $ hg shelve --delete --name NAME
   abort: options '--delete' and '--name' may not be used together
   [10]
 
 Test interactive shelve
   $ cat <<EOF >> $HGRCPATH
   > [ui]
   > interactive = true
   > EOF
   $ echo 'a' >> a/b
   $ cat a/a >> a/b
   $ echo 'x' >> a/b
   $ mv a/b a/a
   $ echo 'a' >> foo/foo
   $ hg st
   M a/a
   ? a/a.orig
   ? foo/foo
   $ cat a/a
   a
   a
   c
   x
   x
   $ cat foo/foo
   foo
   a
   $ hg shelve --interactive --config ui.interactive=false
   abort: running non-interactively
   [10]
   $ hg shelve --interactive << EOF
   > y
   > y
   > n
   > EOF
   diff --git a/a/a b/a/a
   2 hunks, 2 lines changed
   examine changes to 'a/a'?
   (enter ? for help) [Ynesfdaq?] y
   
   @@ -1,3 +1,4 @@
   +a
    a
    c
    x
   record change 1/2 to 'a/a'?
   (enter ? for help) [Ynesfdaq?] y
   
   @@ -1,3 +2,4 @@
    a
    c
    x
   +x
   record change 2/2 to 'a/a'?
   (enter ? for help) [Ynesfdaq?] n
   
   shelved as test
   merging a/a
   0 files updated, 1 files merged, 0 files removed, 0 files unresolved
   $ cat a/a
   a
   c
   x
   x
   $ cat foo/foo
   foo
   a
   $ hg st
   M a/a
   ? foo/foo
   $ hg bookmark
    \* test                      (4|13):33f7f61e6c5e (re)
 there shouldn't be a merge state
   $ hg resolve -l
   $ hg unshelve
   unshelving change 'test'
   temporarily committing pending changes (restore with 'hg unshelve --abort')
   rebasing shelved changes
   merging a/a
   $ hg bookmark
    \* test                      (4|13):33f7f61e6c5e (re)
   $ cat a/a
   a
   a
   c
   x
   x
 
 shelve --patch and shelve --stat should work with valid shelfnames
 
   $ hg up --clean .
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (leaving bookmark test)
   $ hg shelve --list
   $ echo 'patch a' > shelf-patch-a
   $ hg add shelf-patch-a
   $ hg shelve
   shelved as default
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ echo 'patch b' > shelf-patch-b
   $ hg add shelf-patch-b
   $ hg shelve
   shelved as default-01
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg shelve --patch default default-01
   default-01      (*)* changes to: create conflict (glob)
   
   diff --git a/shelf-patch-b b/shelf-patch-b
   new file mode 100644
   --- /dev/null
   +++ b/shelf-patch-b
   @@ -0,0 +1,1 @@
   +patch b
   default         (*)* changes to: create conflict (glob)
   
   diff --git a/shelf-patch-a b/shelf-patch-a
   new file mode 100644
   --- /dev/null
   +++ b/shelf-patch-a
   @@ -0,0 +1,1 @@
   +patch a
   $ hg shelve --stat default default-01
   default-01      (*)* changes to: create conflict (glob)
    shelf-patch-b |  1 +
    1 files changed, 1 insertions(+), 0 deletions(-)
   default         (*)* changes to: create conflict (glob)
    shelf-patch-a |  1 +
    1 files changed, 1 insertions(+), 0 deletions(-)
   $ hg shelve --patch default
   default         (*)* changes to: create conflict (glob)
   
   diff --git a/shelf-patch-a b/shelf-patch-a
   new file mode 100644
   --- /dev/null
   +++ b/shelf-patch-a
   @@ -0,0 +1,1 @@
   +patch a
   $ hg shelve --stat default
   default         (*)* changes to: create conflict (glob)
    shelf-patch-a |  1 +
    1 files changed, 1 insertions(+), 0 deletions(-)
   $ hg shelve --patch nonexistentshelf
   abort: cannot find shelf nonexistentshelf
   [255]
   $ hg shelve --stat nonexistentshelf
   abort: cannot find shelf nonexistentshelf
   [255]
   $ hg shelve --patch default nonexistentshelf
   abort: cannot find shelf nonexistentshelf
   [255]
 
 when the user asks for a patch, we assume they want the most recent shelve if
 they don't provide a shelve name
 
   $ hg shelve --patch
   default-01      (*)* changes to: create conflict (glob)
   
   diff --git a/shelf-patch-b b/shelf-patch-b
   new file mode 100644
   --- /dev/null
   +++ b/shelf-patch-b
   @@ -0,0 +1,1 @@
   +patch b
 
   $ cd ..
 
 Shelve from general delta repo uses bundle2 on disk
 --------------------------------------------------
 
 no general delta
 
   $ hg clone --pull repo bundle1 --config format.usegeneraldelta=0
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 5 changesets with 8 changes to 6 files
   new changesets cc01e2b0c59f:33f7f61e6c5e
   updating to branch default
   6 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd bundle1
   $ echo babar > jungle
   $ hg add jungle
   $ hg shelve
   shelved as default
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg debugbundle .hg/shelved/*.hg
   330882a04d2ce8487636b1fb292e5beea77fa1e3
   $ cd ..
 
 with general delta
 
   $ hg clone --pull repo bundle2 --config format.usegeneraldelta=1
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 5 changesets with 8 changes to 6 files
   new changesets cc01e2b0c59f:33f7f61e6c5e
   updating to branch default
   6 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd bundle2
   $ echo babar > jungle
   $ hg add jungle
   $ hg shelve
   shelved as default
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg debugbundle .hg/shelved/*.hg
   Stream params: {Compression: BZ}
   changegroup -- {nbchanges: 1, version: 02} (mandatory: True)
       330882a04d2ce8487636b1fb292e5beea77fa1e3
 
 Test shelve --keep
 
   $ hg unshelve
   unshelving change 'default'
   $ hg shelve --keep --list
   abort: options '--list' and '--keep' may not be used together
   [10]
   $ hg shelve --keep --patch
   abort: options '--patch' and '--keep' may not be used together
   [10]
   $ hg shelve --keep --delete
   abort: options '--delete' and '--keep' may not be used together
   [10]
   $ hg shelve --keep
   shelved as default
   $ hg diff
   diff --git a/jungle b/jungle
   new file mode 100644
   --- /dev/null
   +++ b/jungle
   @@ -0,0 +1,1 @@
   +babar
 
 Test shelve --delete
 
   $ hg shelve --list
   default         (*s ago) * changes to: create conflict (glob)
   $ hg shelve --delete doesnotexist
   abort: shelved change 'doesnotexist' not found
   [10]
   $ hg shelve --delete default
 
   $ cd ..
 
 Test visibility of in-memory changes inside transaction to external hook
 ------------------------------------------------------------------------
 
   $ cd repo
 
   $ echo xxxx >> x
   $ hg commit -m "#5: changes to invoke rebase"
 
   $ cat > $TESTTMP/checkvisibility.sh <<EOF
   > echo "==== \$1:"
   > hg parents --template "VISIBLE {rev}:{node|short}\n"
   > # test that pending changes are hidden
   > unset HG_PENDING
   > hg parents --template "ACTUAL  {rev}:{node|short}\n"
   > echo "===="
   > EOF
 
   $ cat >> .hg/hgrc <<EOF
   > [defaults]
   > # to fix hash id of temporary revisions
   > unshelve = --date '0 0'
   > EOF
 
 "hg unshelve" at REV5 implies steps below:
 
 (1) commit changes in the working directory (REV6)
 (2) unbundle shelved revision (REV7)
 (3) rebase: merge REV7 into REV6 (REV6 => REV6, REV7)
 (4) rebase: commit merged revision (REV8)
 (5) rebase: update to REV6 (REV8 => REV6)
 (6) update to REV5 (REV6 => REV5)
 (7) abort transaction
 
 == test visibility to external preupdate hook
 
   $ cat >> .hg/hgrc <<EOF
   > [hooks]
   > preupdate.visibility = sh $TESTTMP/checkvisibility.sh preupdate
   > EOF
 
   $ echo nnnn >> n
 
   $ sh $TESTTMP/checkvisibility.sh before-unshelving
   ==== before-unshelving:
   VISIBLE (5|19):703117a2acfb (re)
   ACTUAL  (5|19):703117a2acfb (re)
   ====
 
   $ hg unshelve --keep default
   temporarily committing pending changes (restore with 'hg unshelve --abort')
   rebasing shelved changes
   ==== preupdate:
   VISIBLE (6|20):54c00d20fb3f (re)
   ACTUAL  (5|19):703117a2acfb (re)
   ====
   ==== preupdate:
   VISIBLE (8|21):8efe6f7537dc (re)
   ACTUAL  (5|19):703117a2acfb (re)
   ====
   ==== preupdate:
   VISIBLE (6|20):54c00d20fb3f (re)
   ACTUAL  (5|19):703117a2acfb (re)
   ====
 
   $ cat >> .hg/hgrc <<EOF
   > [hooks]
   > preupdate.visibility =
   > EOF
 
   $ sh $TESTTMP/checkvisibility.sh after-unshelving
   ==== after-unshelving:
   VISIBLE (5|19):703117a2acfb (re)
   ACTUAL  (5|19):703117a2acfb (re)
   ====
 
 == test visibility to external update hook
 
   $ hg update -q -C 703117a2acfb
 
   $ cat >> .hg/hgrc <<EOF
   > [hooks]
   > update.visibility = sh $TESTTMP/checkvisibility.sh update
   > EOF
 
   $ echo nnnn >> n
 
   $ sh $TESTTMP/checkvisibility.sh before-unshelving
   ==== before-unshelving:
   VISIBLE (5|19):703117a2acfb (re)
   ACTUAL  (5|19):703117a2acfb (re)
   ====
 
   $ hg unshelve --keep default
   temporarily committing pending changes (restore with 'hg unshelve --abort')
   rebasing shelved changes
   ==== update:
   VISIBLE (6|20):54c00d20fb3f (re)
   VISIBLE 1?7:492ed9d705e5 (re)
   ACTUAL  (5|19):703117a2acfb (re)
   ====
   ==== update:
   VISIBLE (6|20):54c00d20fb3f (re)
   ACTUAL  (5|19):703117a2acfb (re)
   ====
   ==== update:
   VISIBLE (5|19):703117a2acfb (re)
   ACTUAL  (5|19):703117a2acfb (re)
   ====
 
   $ cat >> .hg/hgrc <<EOF
   > [hooks]
   > update.visibility =
   > EOF
 
   $ sh $TESTTMP/checkvisibility.sh after-unshelving
   ==== after-unshelving:
   VISIBLE (5|19):703117a2acfb (re)
   ACTUAL  (5|19):703117a2acfb (re)
   ====
 
   $ cd ..
 
 Keep active bookmark while (un)shelving even on shared repo (issue4940)
 -----------------------------------------------------------------------
 
   $ cat <<EOF >> $HGRCPATH
   > [extensions]
   > share =
   > EOF
 
   $ hg bookmarks -R repo
      test                      (4|13):33f7f61e6c5e (re)
   $ hg share -B repo share
   updating working directory
   6 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd share
 
   $ hg bookmarks
      test                      (4|13):33f7f61e6c5e (re)
   $ hg bookmarks foo
   $ hg bookmarks
    \* foo                       (5|19):703117a2acfb (re)
      test                      (4|13):33f7f61e6c5e (re)
   $ echo x >> x
   $ hg shelve
   shelved as foo
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg bookmarks
    \* foo                       (5|19):703117a2acfb (re)
      test                      (4|13):33f7f61e6c5e (re)
 
   $ hg unshelve
   unshelving change 'foo'
   $ hg bookmarks
    \* foo                       (5|19):703117a2acfb (re)
      test                      (4|13):33f7f61e6c5e (re)
 
   $ cd ..
 
 Abort unshelve while merging (issue5123)
 ----------------------------------------
 
   $ hg init issue5123
   $ cd issue5123
   $ echo > a
   $ hg ci -Am a
   adding a
   $ hg co null
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ echo > b
   $ hg ci -Am b
   adding b
   created new head
   $ echo > c
   $ hg add c
   $ hg shelve
   shelved as default
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg co 1
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg merge 0
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
 -- successful merge with two parents
   $ hg log -G
   @  changeset:   1:406bf70c274f
      tag:         tip
      parent:      -1:000000000000
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     b
   
   @  changeset:   0:ada8c9eb8252
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     a
   
 -- trying to pull in the shelve bits
 -- unshelve should abort otherwise, it'll eat my second parent.
   $ hg unshelve
   abort: outstanding uncommitted merge
   (use 'hg commit' or 'hg merge --abort')
   [20]
 
   $ cd ..
 
 -- test for interactive mode on unshelve
 
   $ hg init a
   $ cd a
   $ echo > b
   $ hg ci -Am b
   adding b
   $ echo > c
   $ echo > d
   $ hg add .
   adding c
   adding d
   $ hg shelve
   shelved as default
   0 files updated, 0 files merged, 2 files removed, 0 files unresolved
   $ echo > e
   $ hg add e
   $ hg ci -m e
   $ hg shelve --patch
   default         (*s ago) * changes to: b (glob)
   
   diff --git a/c b/c
   new file mode 100644
   --- /dev/null
   +++ b/c
   @@ -0,0 +1,1 @@
   +
   diff --git a/d b/d
   new file mode 100644
   --- /dev/null
   +++ b/d
   @@ -0,0 +1,1 @@
   +
   $ hg unshelve -i <<EOF
   > y
   > y
   > y
   > n
   > EOF
   unshelving change 'default'
   rebasing shelved changes
   diff --git a/c b/c
   new file mode 100644
   examine changes to 'c'?
   (enter ? for help) [Ynesfdaq?] y
   
   @@ -0,0 +1,1 @@
   +
   record change 1/2 to 'c'?
   (enter ? for help) [Ynesfdaq?] y
   
   diff --git a/d b/d
   new file mode 100644
   examine changes to 'd'?
   (enter ? for help) [Ynesfdaq?] y
   
   @@ -0,0 +1,1 @@
   +
   record change 2/2 to 'd'?
   (enter ? for help) [Ynesfdaq?] n
   
   $ ls -A
   .hg
   b
   c
   e
 -- shelve should not contain `c` now
   $ hg shelve --patch
   default         (*s ago) * changes to: b (glob)
   
   diff --git a/d b/d
   new file mode 100644
   --- /dev/null
   +++ b/d
   @@ -0,0 +1,1 @@
   +
   $ hg unshelve -i <<EOF
   > y
   > y
   > EOF
   unshelving change 'default'
   temporarily committing pending changes (restore with 'hg unshelve --abort')
   rebasing shelved changes
   diff --git a/d b/d
   new file mode 100644
   examine changes to 'd'?
   (enter ? for help) [Ynesfdaq?] y
   
   @@ -0,0 +1,1 @@
   +
   record this change to 'd'?
   (enter ? for help) [Ynesfdaq?] y
   
 
   $ hg status -v
   A c
   A d
   $ ls -A
   .hg
   b
   c
   d
   e
   $ hg shelve --list
 
 -- now, unshelve selected changes from a file
 
   $ echo B > foo
   $ hg add foo
   $ hg ci -m 'add B to foo'
   $ cat > foo <<EOF
   > A
   > B
   > C
   > EOF
   $ echo > garbage
   $ hg st
   M foo
   ? garbage
   $ hg shelve --unknown
   shelved as default
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ cat foo
   B
   $ hg unshelve -i <<EOF
   > y
   > y
   > n
   > y
   > y
   > EOF
   unshelving change 'default'
   rebasing shelved changes
   diff --git a/foo b/foo
   2 hunks, 2 lines changed
   examine changes to 'foo'?
   (enter ? for help) [Ynesfdaq?] y
   
   @@ -1,1 +1,2 @@
   +A
    B
   record change 1/3 to 'foo'?
   (enter ? for help) [Ynesfdaq?] y
   
   @@ -1,1 +2,2 @@
    B
   +C
   record change 2/3 to 'foo'?
   (enter ? for help) [Ynesfdaq?] n
   
   diff --git a/garbage b/garbage
   new file mode 100644
   examine changes to 'garbage'?
   (enter ? for help) [Ynesfdaq?] y
   
   @@ -0,0 +1,1 @@
   +
   record change 3/3 to 'garbage'?
   (enter ? for help) [Ynesfdaq?] y
   
   $ hg st
   M foo
   ? garbage
   $ cat foo
   A
   B
   $ hg shelve --patch
   default         (*s ago) * changes to: add B to foo (glob)
   
   diff --git a/foo b/foo
   --- a/foo
   +++ b/foo
   @@ -1,2 +1,3 @@
    A
    B
   +C
 
 -- unshelve interactive on conflicts
 
   $ echo A >> bar1
   $ echo A >> bar2
   $ hg add bar1 bar2
   $ hg ci -m 'add A to bars'
   $ echo B >> bar1
   $ echo B >> bar2
   $ hg shelve
   shelved as default-01
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo C >> bar1
   $ echo C >> bar2
   $ hg ci -m 'add C to bars'
   $ hg unshelve -i
   unshelving change 'default-01'
   rebasing shelved changes
   merging bar1
   warning: conflicts while merging bar1! (edit, then use 'hg resolve --mark')
   merging bar2
   warning: conflicts while merging bar2! (edit, then use 'hg resolve --mark')
   unresolved conflicts (see 'hg resolve', then 'hg unshelve --continue')
   [240]
 
   $ cat > bar1 <<EOF
   > A
   > B
   > C
   > EOF
   $ cat > bar2 <<EOF
   > A
   > B
   > C
   > EOF
   $ hg resolve -m bar1 bar2
   (no more unresolved files)
   continue: hg unshelve --continue
 
 -- using --continue with --interactive should throw an error
   $ hg unshelve --continue -i
   abort: cannot use both continue and interactive
   [10]
 
   $ cat bar1
   A
   B
   C
 
 #if stripbased
   $ hg log -r 3:: -G
   @  changeset:   5:f1d5f53e397b
   |  tag:         tip
   |  parent:      3:e28fd7fa7938
   |  user:        shelve@localhost
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     changes to: add A to bars
   |
   | @  changeset:   4:fe451a778c81
   |/   user:        test
   |    date:        Thu Jan 01 00:00:00 1970 +0000
   |    summary:     add C to bars
   |
   o  changeset:   3:e28fd7fa7938
   |  user:        test
   ~  date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     add A to bars
   
 #endif
 
   $ hg unshelve --continue <<EOF
   > y
   > y
   > y
   > n
   > EOF
   diff --git a/bar1 b/bar1
   1 hunks, 1 lines changed
   examine changes to 'bar1'?
   (enter ? for help) [Ynesfdaq?] y
   
   @@ -1,2 +1,3 @@
    A
   +B
    C
   record change 1/2 to 'bar1'?
   (enter ? for help) [Ynesfdaq?] y
   
   diff --git a/bar2 b/bar2
   1 hunks, 1 lines changed
   examine changes to 'bar2'?
   (enter ? for help) [Ynesfdaq?] y
   
   @@ -1,2 +1,3 @@
    A
   +B
    C
   record change 2/2 to 'bar2'?
   (enter ? for help) [Ynesfdaq?] n
   
   unshelve of 'default-01' complete
 
 #if stripbased
   $ hg log -r 3:: -G
   @  changeset:   4:fe451a778c81
   |  tag:         tip
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     add C to bars
   |
   o  changeset:   3:e28fd7fa7938
   |  user:        test
   ~  date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     add A to bars
   
 #endif
 
   $ hg unshelve --continue
   abort: no unshelve in progress
   [20]
 
   $ hg shelve --list
   default-01      (*)* changes to: add A to bars (glob)
   default         (*)* changes to: add B to foo (glob)
   $ hg unshelve -n default-01 -i <<EOF
   > y
   > y
   > EOF
   temporarily committing pending changes (restore with 'hg unshelve --abort')
   rebasing shelved changes
   diff --git a/bar2 b/bar2
   1 hunks, 1 lines changed
   examine changes to 'bar2'?
   (enter ? for help) [Ynesfdaq?] y
   
   @@ -1,2 +1,3 @@
    A
   +B
    C
   record this change to 'bar2'?
   (enter ? for help) [Ynesfdaq?] y
   
 -- test for --interactive --keep
   $ hg unshelve -i --keep
   abort: --keep on --interactive is not yet supported
   [10]
 
   $ hg update -q --clean .
 
 Test that we can successfully shelve and unshelve a file with a trailing space
 in the filename. Such filenames are supposedly unsupported on Windows, so we
 wrap it in the no-windows check. Also test `hg patch` of the .patch file
 produced by `hg shelve`.
 #if no-windows
   $ echo hi > 'my filename '
   $ hg add 'my filename '
   warning: filename ends with ' ', which is not allowed on Windows: 'my filename '
   $ hg shelve
   shelved as default-01
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ cp .hg/shelved/default-01.patch test_patch.patch
   $ hg unshelve
   unshelving change 'default-01'
   $ cat 'my filename '
   hi
   $ hg update -q --clean .
   $ hg patch -p1 test_patch.patch
   applying test_patch.patch
 #endif