This is an archive of the discontinued Mercurial Phabricator instance.

Differential D9738

shelve: replace repo instance in Shelf class by vfs instance
ClosedPublic

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

Details

Reviewers
pulkit
Group Reviewers
hg-reviewers
Commits
rHGe2713c68b477: shelve: replace repo instance in Shelf class by vfs instance
rHG20b6d76e7f1c: shelve: replace repo instance in Shelf class by vfs instance
rHGba9be8f53c93: shelve: replace repo instance in Shelf class by vfs instance
Summary

I'd like to be able to teach the Shelf class to read shelves from
.hg/shelve-backup/ in addition to .hg/shelved/. That means that
we'll have to pass in a vfs instead of the repo, so this patch does
that preparation.

Diff Detail

Repository
rHG Mercurial
Branch
default
Lint
No Linters Available
Unit
No Unit Test Coverage

Revision Contents
Changeset List

PathPackages
Mmercurial/shelve.py (78 lines)

Diff 24741

mercurial/shelve.py

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, repo, name): def __init__(self, vfs, name):
self.repo = repo self.vfs = vfs
self.name = name self.name = name
self.vfs = vfsmod.vfs(repo.vfs.join(shelvedir))
self.backupvfs = vfsmod.vfs(repo.vfs.join(backupdir)) @staticmethod
def open(repo, name):
return Shelf(vfsmod.vfs(repo.vfs.join(shelvedir)), name)
def exists(self): def exists(self):
return self.vfs.exists( return self.vfs.exists(
self.name + b'.' + patchextension self.name + b'.' + patchextension
) and self.vfs.exists(self.name + b'.hg') ) and self.vfs.exists(self.name + b'.hg')
def mtime(self): def mtime(self):
return self.vfs.stat(self.name + b'.' + patchextension)[stat.ST_MTIME] return self.vfs.stat(self.name + b'.' + patchextension)[stat.ST_MTIME]
def writeinfo(self, info): def writeinfo(self, info):
scmutil.simplekeyvaluefile(self.vfs, self.name + b'.shelve').write(info) scmutil.simplekeyvaluefile(self.vfs, self.name + b'.shelve').write(info)
def hasinfo(self): def hasinfo(self):
return self.vfs.exists(self.name + b'.shelve') return self.vfs.exists(self.name + b'.shelve')
def readinfo(self): def readinfo(self):
return scmutil.simplekeyvaluefile( return scmutil.simplekeyvaluefile(
self.vfs, self.name + b'.shelve' self.vfs, self.name + b'.shelve'
).read() ).read()
def writebundle(self, bases, node): def writebundle(self, repo, bases, node):
cgversion = changegroup.safeversion(self.repo) cgversion = changegroup.safeversion(repo)
if cgversion == b'01': if cgversion == b'01':
btype = b'HG10BZ' btype = b'HG10BZ'
compression = None compression = None
else: else:
btype = b'HG20' btype = b'HG20'
compression = b'BZ' compression = b'BZ'
repo = self.repo.unfiltered() repo = repo.unfiltered()
outgoing = discovery.outgoing( outgoing = discovery.outgoing(
repo, missingroots=bases, ancestorsof=[node] repo, missingroots=bases, ancestorsof=[node]
) )
cg = changegroup.makechangegroup(repo, outgoing, cgversion, b'shelve') cg = changegroup.makechangegroup(repo, outgoing, cgversion, b'shelve')
bundle_filename = self.vfs.join(self.name + b'.hg') bundle_filename = self.vfs.join(self.name + b'.hg')
bundle2.writebundle( bundle2.writebundle(
self.repo.ui, repo.ui,
cg, cg,
bundle_filename, bundle_filename,
btype, btype,
self.vfs, self.vfs,
compression=compression, compression=compression,
) )
def applybundle(self, tr): def applybundle(self, repo, tr):
filename = self.name + b'.hg' filename = self.name + b'.hg'
fp = self.vfs(filename) fp = self.vfs(filename)
try: try:
targetphase = phases.internal targetphase = phases.internal
if not phases.supportinternal(self.repo): if not phases.supportinternal(repo):
targetphase = phases.secret targetphase = phases.secret
gen = exchange.readbundle(self.repo.ui, fp, filename, self.vfs) gen = exchange.readbundle(repo.ui, fp, filename, self.vfs)
pretip = self.repo[b'tip'] pretip = repo[b'tip']
bundle2.applybundle( bundle2.applybundle(
self.repo, repo,
gen, gen,
tr, tr,
source=b'unshelve', source=b'unshelve',
url=b'bundle:' + self.vfs.join(filename), url=b'bundle:' + self.vfs.join(filename),
targetphase=targetphase, targetphase=targetphase,
) )
shelvectx = self.repo[b'tip'] shelvectx = repo[b'tip']
if pretip == shelvectx: if pretip == shelvectx:
shelverev = tr.changes[b'revduplicates'][-1] shelverev = tr.changes[b'revduplicates'][-1]
shelvectx = self.repo[shelverev] shelvectx = repo[shelverev]
return shelvectx return shelvectx
finally: finally:
fp.close() fp.close()
def open_patch(self, mode=b'rb'): def open_patch(self, mode=b'rb'):
return self.vfs(self.name + b'.patch', mode) return self.vfs(self.name + b'.patch', mode)
def _backupfilename(self, filename): def _backupfilename(self, backupvfs, filename):
def gennames(base): def gennames(base):
yield base yield base
base, ext = base.rsplit(b'.', 1) base, ext = base.rsplit(b'.', 1)
for i in itertools.count(1): for i in itertools.count(1):
yield b'%s-%d.%s' % (base, i, ext) yield b'%s-%d.%s' % (base, i, ext)
for n in gennames(filename): for n in gennames(filename):
if not self.backupvfs.exists(n): if not backupvfs.exists(n):
return self.backupvfs.join(n) return backupvfs.join(n)
def movetobackup(self): def movetobackup(self, backupvfs):
if not self.backupvfs.isdir(): if not backupvfs.isdir():
self.backupvfs.makedir() backupvfs.makedir()
for suffix in shelvefileextensions: for suffix in shelvefileextensions:
filename = self.name + b'.' + suffix filename = self.name + b'.' + suffix
if self.vfs.exists(filename): if self.vfs.exists(filename):
util.rename( util.rename(
self.vfs.join(filename), self._backupfilename(filename) self.vfs.join(filename),
self._backupfilename(backupvfs, filename),
) )
class shelvedstate(object): class shelvedstate(object):
"""Handle persistence during unshelving operations. """Handle persistence during unshelving operations.
Handles saving and restoring a shelved state. Ensures that different Handles saving and restoring a shelved state. Ensures that different
versions of a shelved state are possible and handles them appropriately. versions of a shelved state are possible and handles them appropriately.
# 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(repo, name).exists(): if Shelf.open(repo, 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:
for n in gennames(): for n in gennames():
if not Shelf(repo, n).exists(): if not Shelf.open(repo, 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(repo, name) shelf = Shelf.open(repo, name)
shelf.writeinfo(info) shelf.writeinfo(info)
bases = list(mutableancestors(repo[node])) bases = list(mutableancestors(repo[node]))
shelf.writebundle(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 _includeunknownfiles(repo, pats, opts, extra): def _includeunknownfiles(repo, pats, opts, extra):
s = repo.status(match=scmutil.match(repo[None], pats, opts), unknown=True) s = repo.status(match=scmutil.match(repo[None], pats, opts), unknown=True)
def _iswctxonnewbranch(repo): def _iswctxonnewbranch(repo):
return repo[None].branch() != repo[b'.'].branch() return repo[None].branch() != repo[b'.'].branch()
def cleanupcmd(ui, repo): def cleanupcmd(ui, repo):
"""subcommand that deletes all shelves""" """subcommand that deletes all shelves"""
with repo.wlock(): with repo.wlock():
backupvfs = vfsmod.vfs(repo.vfs.join(backupdir))
for _mtime, name in listshelves(repo): for _mtime, name in listshelves(repo):
Shelf(repo, name).movetobackup() Shelf.open(repo, name).movetobackup(backupvfs)
cleanupoldbackups(repo) cleanupoldbackups(repo)
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))
for name in pats: for name in pats:
shelf = Shelf(repo, name) shelf = Shelf.open(repo, 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() shelf.movetobackup(backupvfs)
cleanupoldbackups(repo) cleanupoldbackups(repo)
def listshelves(repo): def listshelves(repo):
"""return all shelves in repo as list of (time, name)""" """return all shelves in repo as list of (time, name)"""
try: try:
names = repo.vfs.listdir(shelvedir) names = repo.vfs.listdir(shelvedir)
except OSError as err: except OSError as err:
if err.errno != errno.ENOENT: if err.errno != errno.ENOENT:
raise raise
return [] return []
info = [] info = []
seen = set() seen = set()
for filename in names: for filename in names:
name = filename.rsplit(b'.', 1)[0] name = filename.rsplit(b'.', 1)[0]
if name in seen: if name in seen:
continue continue
seen.add(name) seen.add(name)
shelf = Shelf(repo, name) shelf = Shelf.open(repo, name)
if not shelf.exists(): if not shelf.exists():
continue continue
mtime = shelf.mtime() mtime = shelf.mtime()
info.append((mtime, name)) info.append((mtime, name))
return sorted(info, reverse=True) return sorted(info, reverse=True)
def listcmd(ui, repo, pats, opts): def listcmd(ui, repo, pats, opts):
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(repo, name).open_patch() as fp: with Shelf.open(repo, 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:
shelves = listshelves(repo) shelves = listshelves(repo)
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]
for shelfname in pats: for shelfname in pats:
if not Shelf(repo, shelfname).exists(): if not Shelf.open(repo, 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():
ui.status( ui.status(
_(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'):
Shelf(repo, name).movetobackup() backupvfs = vfsmod.vfs(repo.vfs.join(backupdir))
Shelf.open(repo, 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(repo, basename) shelf = Shelf.open(repo, 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(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:
info = {b'node': hex(shelvectx.node())} info = {b'node': hex(shelvectx.node())}
shelf.writeinfo(info) shelf.writeinfo(info)
else: else:
shelvectx = repo[node] shelvectx = repo[node]
shelved = listshelves(repo) shelved = listshelves(repo)
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(repo, basename).exists(): if not Shelf.open(repo, 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