This is an archive of the discontinued Mercurial Phabricator instance.

Differential D9744

shelve: move listshelves() to new ShelfDir class, so caller need not pass vfs
ClosedPublic

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

Details

Reviewers
pulkit
Group Reviewers
hg-reviewers
Commits
rHG82edad33fd81: shelve: move listshelves() to new ShelfDir class, so caller need not pass vfs
rHG648d44736bd0: shelve: move listshelves() to new ShelfDir class, so caller need not pass vfs
rHG9182177ab0bc: shelve: move listshelves() to new ShelfDir class, so caller need not pass vfs

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 (68 lines)

Diff 24959

mercurial/shelve.py

if for_backups: if for_backups:
self.vfs = vfsmod.vfs(repo.vfs.join(backupdir)) self.vfs = vfsmod.vfs(repo.vfs.join(backupdir))
else: else:
self.vfs = vfsmod.vfs(repo.vfs.join(shelvedir)) self.vfs = vfsmod.vfs(repo.vfs.join(shelvedir))
def get(self, name): def get(self, name):
return Shelf(self.vfs, 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 OSError as err:
if err.errno != errno.ENOENT:
raise
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(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.
""" """
) )
@classmethod @classmethod
def clear(cls, repo): def clear(cls, repo):
repo.vfs.unlinkpath(cls._filename, ignoremissing=True) repo.vfs.unlinkpath(cls._filename, ignoremissing=True)
def cleanupoldbackups(repo): def cleanupoldbackups(repo):
vfs = vfsmod.vfs(repo.vfs.join(backupdir))
maxbackups = repo.ui.configint(b'shelve', b'maxbackups') maxbackups = repo.ui.configint(b'shelve', b'maxbackups')
hgfiles = listshelves(vfs) backup_dir = ShelfDir(repo, for_backups=True)
hgfiles = backup_dir.listshelves()
if maxbackups > 0 and maxbackups < len(hgfiles): if maxbackups > 0 and maxbackups < len(hgfiles):
bordermtime = hgfiles[maxbackups - 1][0] bordermtime = hgfiles[maxbackups - 1][0]
else: else:
bordermtime = None bordermtime = None
for mtime, name in hgfiles[maxbackups:]: for mtime, name in hgfiles[maxbackups:]:
if mtime == bordermtime: if mtime == bordermtime:
# keep it, because timestamp can't decide exact order of backups # keep it, because timestamp can't decide exact order of backups
continue continue
Shelf.open_backup(repo, name).delete() backup_dir.get(name).delete()
def _backupactivebookmark(repo): def _backupactivebookmark(repo):
activebookmark = repo._activebookmark activebookmark = repo._activebookmark
if activebookmark: if activebookmark:
bookmarks.deactivate(repo) bookmarks.deactivate(repo)
return activebookmark return activebookmark
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():
vfs = vfsmod.vfs(repo.vfs.join(shelvedir)) shelf_dir = ShelfDir(repo)
backupvfs = vfsmod.vfs(repo.vfs.join(backupdir)) backupvfs = vfsmod.vfs(repo.vfs.join(backupdir))
for _mtime, name in listshelves(vfs): for _mtime, name in shelf_dir.listshelves():
Shelf(vfs, name).movetobackup(backupvfs) shelf_dir.get(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)) backupvfs = vfsmod.vfs(repo.vfs.join(backupdir))
for name in pats: for name in pats:
shelf = ShelfDir(repo).get(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)
def listshelves(vfs):
"""return all shelves in repo as list of (time, name)"""
try:
names = vfs.listdir()
except OSError as err:
if err.errno != errno.ENOENT:
raise
return []
info = []
seen = set()
for filename in names:
name = filename.rsplit(b'.', 1)[0]
if name in seen:
continue
seen.add(name)
shelf = Shelf(vfs, name)
if not shelf.exists():
continue
mtime = shelf.mtime()
info.append((mtime, name))
return sorted(info, reverse=True)
def listcmd(ui, repo, pats, opts): def listcmd(ui, repo, pats, opts):
"""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))
shelf_dir = ShelfDir(repo) shelf_dir = ShelfDir(repo)
for mtime, name in listshelves(vfs): for mtime, name in shelf_dir.listshelves():
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)))
ui.write(chunk, label=label) ui.write(chunk, label=label)
if opts[b'stat']: if opts[b'stat']:
for chunk, label in patch.diffstatui(difflines, width=width): for chunk, label in patch.diffstatui(difflines, width=width):
ui.write(chunk, label=label) ui.write(chunk, label=label)
def patchcmds(ui, repo, pats, opts): def patchcmds(ui, repo, pats, opts):
"""subcommand that displays shelves""" """subcommand that displays shelves"""
shelf_dir = ShelfDir(repo)
if len(pats) == 0: if len(pats) == 0:
vfs = vfsmod.vfs(repo.vfs.join(shelvedir)) shelves = shelf_dir.listshelves()
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_dir.get(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):
raise error.InputError( raise error.InputError(
_(b'cannot use both continue and interactive') _(b'cannot use both continue and interactive')
) )
elif continuef: elif continuef:
return unshelvecontinue(ui, repo, state, opts) return unshelvecontinue(ui, repo, state, opts)
elif len(shelved) > 1: elif len(shelved) > 1:
raise error.InputError(_(b'can only unshelve one change at a time')) raise error.InputError(_(b'can only unshelve one change at a time'))
elif not shelved: elif not shelved:
vfs = vfsmod.vfs(repo.vfs.join(shelvedir)) shelved = ShelfDir(repo).listshelves()
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 ShelfDir(repo).get(basename).exists(): if not ShelfDir(repo).get(basename).exists():