This is an archive of the discontinued Mercurial Phabricator instance.

Differential D9743

shelve: also create class representing whole directory of shelves
ClosedPublic

Authored by martinvonz on Jan 12 2021, 5:48 PM.

Details

Reviewers
pulkit
Group Reviewers
hg-reviewers
Commits
rHGeec8899407f4: shelve: also create class representing whole directory of shelves
rHG905302072e12: shelve: also create class representing whole directory of shelves
rHG6f3209cd5a38: shelve: also create class representing whole directory of shelves
Summary

It's a little annoying to have to create and pass in a vfs into
listshelves(). This patch attempts to start addressing that by
creating a class that represents a directory containing shelves (the
directory can be either .hg/shelved/ or .hg/shelve-backup/).

Diff Detail

Repository
rHG Mercurial
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

Revision Contents
Changeset List

PathPackages
Mmercurial/shelve.py (40 lines)

Diff 24958

mercurial/shelve.py

shelvedir = b'shelved' shelvedir = b'shelved'
shelvefileextensions = [b'hg', b'patch', b'shelve'] shelvefileextensions = [b'hg', b'patch', b'shelve']
# we never need the user, so we use a # we never need the user, so we use a
# generic user for all shelve operations # generic user for all shelve operations
shelveuser = b'shelve@localhost' shelveuser = b'shelve@localhost'
class ShelfDir(object):
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)
class Shelf(object): class Shelf(object):
"""Represents a shelf, including possibly multiple files storing it. """Represents a shelf, including possibly multiple files storing it.
Old shelves will have a .patch and a .hg file. Newer shelves will 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 also have a .shelve file. This class abstracts away some of the
differences and lets you work with the shelf as a whole. differences and lets you work with the shelf as a whole.
""" """
def __init__(self, vfs, name): def __init__(self, vfs, name):
self.vfs = vfs self.vfs = vfs
self.name = name self.name = name
@staticmethod
def open(repo, name):
return Shelf(vfsmod.vfs(repo.vfs.join(shelvedir)), name)
@staticmethod
def open_backup(repo, name):
return Shelf(vfsmod.vfs(repo.vfs.join(backupdir)), name)
def exists(self): def exists(self):
return self.vfs.exists(self.name + b'.patch') and self.vfs.exists( return self.vfs.exists(self.name + b'.patch') and self.vfs.exists(
self.name + b'.hg' self.name + b'.hg'
) )
def mtime(self): def mtime(self):
return self.vfs.stat(self.name + b'.patch')[stat.ST_MTIME] return self.vfs.stat(self.name + b'.patch')[stat.ST_MTIME]
# slashes aren't allowed in filenames, therefore we rename it # slashes aren't allowed in filenames, therefore we rename it
label = label.replace(b'/', b'_') label = label.replace(b'/', b'_')
label = label.replace(b'\\', b'_') label = label.replace(b'\\', b'_')
# filenames must not start with '.' as it should not be hidden # filenames must not start with '.' as it should not be hidden
if label.startswith(b'.'): if label.startswith(b'.'):
label = label.replace(b'.', b'_', 1) label = label.replace(b'.', b'_', 1)
if name: if name:
if Shelf.open(repo, name).exists(): if ShelfDir(repo).get(name).exists():
e = _(b"a shelved change named '%s' already exists") % name e = _(b"a shelved change named '%s' already exists") % name
raise error.Abort(e) raise error.Abort(e)
# ensure we are not creating a subdirectory or a hidden file # ensure we are not creating a subdirectory or a hidden file
if b'/' in name or b'\\' in name: if b'/' in name or b'\\' in name:
raise error.Abort( raise error.Abort(
_(b'shelved change names can not contain slashes') _(b'shelved change names can not contain slashes')
) )
if name.startswith(b'.'): if name.startswith(b'.'):
raise error.Abort(_(b"shelved change names can not start with '.'")) raise error.Abort(_(b"shelved change names can not start with '.'"))
else: else:
shelf_dir = ShelfDir(repo)
for n in gennames(): for n in gennames():
if not Shelf.open(repo, n).exists(): if not shelf_dir.get(n).exists():
name = n name = n
break break
return name return name
def mutableancestors(ctx): def mutableancestors(ctx):
"""return all mutable ancestors for ctx (included) """return all mutable ancestors for ctx (included)
% len(stat.deleted) % len(stat.deleted)
) )
else: else:
ui.status(_(b"nothing changed\n")) ui.status(_(b"nothing changed\n"))
def _shelvecreatedcommit(repo, node, name, match): def _shelvecreatedcommit(repo, node, name, match):
info = {b'node': hex(node)} info = {b'node': hex(node)}
shelf = Shelf.open(repo, name) shelf = ShelfDir(repo).get(name)
shelf.writeinfo(info) shelf.writeinfo(info)
bases = list(mutableancestors(repo[node])) bases = list(mutableancestors(repo[node]))
shelf.writebundle(repo, bases, node) shelf.writebundle(repo, bases, node)
with shelf.open_patch(b'wb') as fp: with shelf.open_patch(b'wb') as fp:
cmdutil.exportfile( cmdutil.exportfile(
repo, [node], fp, opts=mdiff.diffopts(git=True), match=match repo, [node], fp, opts=mdiff.diffopts(git=True), match=match
) )
def deletecmd(ui, repo, pats): def deletecmd(ui, repo, pats):
"""subcommand that deletes a specific shelve""" """subcommand that deletes a specific shelve"""
if not pats: if not pats:
raise error.InputError(_(b'no shelved changes specified!')) raise error.InputError(_(b'no shelved changes specified!'))
with repo.wlock(): with repo.wlock():
backupvfs = vfsmod.vfs(repo.vfs.join(backupdir)) backupvfs = vfsmod.vfs(repo.vfs.join(backupdir))
for name in pats: for name in pats:
shelf = Shelf.open(repo, name) shelf = ShelfDir(repo).get(name)
if not shelf.exists(): if not shelf.exists():
raise error.InputError( raise error.InputError(
_(b"shelved change '%s' not found") % name _(b"shelved change '%s' not found") % name
) )
shelf.movetobackup(backupvfs) shelf.movetobackup(backupvfs)
cleanupoldbackups(repo) cleanupoldbackups(repo)
"""subcommand that displays the list of shelves""" """subcommand that displays the list of shelves"""
pats = set(pats) pats = set(pats)
width = 80 width = 80
if not ui.plain(): if not ui.plain():
width = ui.termwidth() width = ui.termwidth()
namelabel = b'shelve.newest' namelabel = b'shelve.newest'
ui.pager(b'shelve') ui.pager(b'shelve')
vfs = vfsmod.vfs(repo.vfs.join(shelvedir)) vfs = vfsmod.vfs(repo.vfs.join(shelvedir))
shelf_dir = ShelfDir(repo)
for mtime, name in listshelves(vfs): for mtime, name in listshelves(vfs):
if pats and name not in pats: if pats and name not in pats:
continue continue
ui.write(name, label=namelabel) ui.write(name, label=namelabel)
namelabel = b'shelve.name' namelabel = b'shelve.name'
if ui.quiet: if ui.quiet:
ui.write(b'\n') ui.write(b'\n')
continue continue
ui.write(b' ' * (16 - len(name))) ui.write(b' ' * (16 - len(name)))
used = 16 used = 16
date = dateutil.makedate(mtime) date = dateutil.makedate(mtime)
age = b'(%s)' % templatefilters.age(date, abbrev=True) age = b'(%s)' % templatefilters.age(date, abbrev=True)
ui.write(age, label=b'shelve.age') ui.write(age, label=b'shelve.age')
ui.write(b' ' * (12 - len(age))) ui.write(b' ' * (12 - len(age)))
used += 12 used += 12
with Shelf.open(repo, name).open_patch() as fp: with shelf_dir.get(name).open_patch() as fp:
while True: while True:
line = fp.readline() line = fp.readline()
if not line: if not line:
break break
if not line.startswith(b'#'): if not line.startswith(b'#'):
desc = line.rstrip() desc = line.rstrip()
if ui.formatted(): if ui.formatted():
desc = stringutil.ellipsis(desc, width - used) desc = stringutil.ellipsis(desc, width - used)
if len(pats) == 0: if len(pats) == 0:
vfs = vfsmod.vfs(repo.vfs.join(shelvedir)) vfs = vfsmod.vfs(repo.vfs.join(shelvedir))
shelves = listshelves(vfs) shelves = listshelves(vfs)
if not shelves: if not shelves:
raise error.Abort(_(b"there are no shelves to show")) raise error.Abort(_(b"there are no shelves to show"))
mtime, name = shelves[0] mtime, name = shelves[0]
pats = [name] pats = [name]
shelf_dir = ShelfDir(repo)
for shelfname in pats: for shelfname in pats:
if not Shelf.open(repo, shelfname).exists(): if not shelf_dir.get(shelfname).exists():
raise error.Abort(_(b"cannot find shelf %s") % shelfname) raise error.Abort(_(b"cannot find shelf %s") % shelfname)
listcmd(ui, repo, pats, opts) listcmd(ui, repo, pats, opts)
def checkparents(repo, state): def checkparents(repo, state):
"""check parent while resuming an unshelve""" """check parent while resuming an unshelve"""
if state.parents != repo.dirstate.parents(): if state.parents != repo.dirstate.parents():
_(b'marked working directory as branch %s\n') % branchtorestore _(b'marked working directory as branch %s\n') % branchtorestore
) )
def unshelvecleanup(ui, repo, name, opts): def unshelvecleanup(ui, repo, name, opts):
"""remove related files after an unshelve""" """remove related files after an unshelve"""
if not opts.get(b'keep'): if not opts.get(b'keep'):
backupvfs = vfsmod.vfs(repo.vfs.join(backupdir)) backupvfs = vfsmod.vfs(repo.vfs.join(backupdir))
Shelf.open(repo, name).movetobackup(backupvfs) ShelfDir(repo).get(name).movetobackup(backupvfs)
cleanupoldbackups(repo) cleanupoldbackups(repo)
def unshelvecontinue(ui, repo, state, opts): def unshelvecontinue(ui, repo, state, opts):
"""subcommand to continue an in-progress unshelve""" """subcommand to continue an in-progress unshelve"""
# We're finishing off a merge. First parent is our original # We're finishing off a merge. First parent is our original
# parent, second is the temporary "fake" commit we're unshelving. # parent, second is the temporary "fake" commit we're unshelving.
interactive = state.interactive interactive = state.interactive
tmpwctx = repo[node] tmpwctx = repo[node]
return tmpwctx, addedbefore return tmpwctx, addedbefore
def _unshelverestorecommit(ui, repo, tr, basename): def _unshelverestorecommit(ui, repo, tr, basename):
"""Recreate commit in the repository during the unshelve""" """Recreate commit in the repository during the unshelve"""
repo = repo.unfiltered() repo = repo.unfiltered()
node = None node = None
shelf = Shelf.open(repo, basename) shelf = ShelfDir(repo).get(basename)
if shelf.hasinfo(): if shelf.hasinfo():
node = shelf.readinfo()[b'node'] node = shelf.readinfo()[b'node']
if node is None or node not in repo: if node is None or node not in repo:
with ui.configoverride({(b'ui', b'quiet'): True}): with ui.configoverride({(b'ui', b'quiet'): True}):
shelvectx = shelf.applybundle(repo, tr) shelvectx = shelf.applybundle(repo, tr)
# We might not strip the unbundled changeset, so we should keep track of # 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) # the unshelve node in case we need to reuse it (eg: unshelve --keep)
if node is None: if node is None:
shelved = listshelves(vfs) shelved = listshelves(vfs)
if not shelved: if not shelved:
raise error.StateError(_(b'no shelved changes to apply!')) raise error.StateError(_(b'no shelved changes to apply!'))
basename = shelved[0][1] basename = shelved[0][1]
ui.status(_(b"unshelving change '%s'\n") % basename) ui.status(_(b"unshelving change '%s'\n") % basename)
else: else:
basename = shelved[0] basename = shelved[0]
if not Shelf.open(repo, basename).exists(): if not ShelfDir(repo).get(basename).exists():
raise error.InputError(_(b"shelved change '%s' not found") % basename) raise error.InputError(_(b"shelved change '%s' not found") % basename)
return _dounshelve(ui, repo, basename, opts) return _dounshelve(ui, repo, basename, opts)
def _dounshelve(ui, repo, basename, opts): def _dounshelve(ui, repo, basename, opts):
repo = repo.unfiltered() repo = repo.unfiltered()
lock = tr = None lock = tr = None