Mercurial > hg
view hgext/journal.py @ 29496:7299370cf304
perf: avoid using formatteropts for Mercurial earlier than 3.2
Before this patch, referring commands.formatteropts prevents perf.py
from being loaded by Mercurial earlier than 3.2 (or 7a7eed5176a4),
because it isn't available in such Mercurial, even though formatting
itself has been available since 2.2 (or ae5f92e154d3).
In addition to it, there are some code paths for Mercurial earlier
than 3.2. For example, setting "_prereadsize" attribute in perfindex()
and perfnodelookup() is effective only with hg earlier than 1.8 (or
61c9bc3da402).
This patch uses empty option list as formatteropts, if it isn't
available in commands module at runtime.
Disabling -T/--template option for earlier Mercurial should be
reasonable, because:
- since 427e80a18ef8, -T/--template for formatter has been available
- since 7a7eed5176a4, commands.formatteropts has been available
- the latter revision is direct child of the former
author | FUJIWARA Katsunori <foozy@lares.dti.ne.jp> |
---|---|
date | Tue, 05 Jul 2016 07:25:51 +0900 |
parents | cf092a3d202a |
children | 8361131b4768 |
line wrap: on
line source
# journal.py # # Copyright 2014-2016 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. """Track previous positions of bookmarks (EXPERIMENTAL) This extension adds a new command: `hg journal`, which shows you where bookmarks were previously located. """ from __future__ import absolute_import import collections import os from mercurial.i18n import _ from mercurial import ( bookmarks, cmdutil, commands, dispatch, error, extensions, node, util, ) cmdtable = {} command = cmdutil.command(cmdtable) # Note for extension authors: ONLY specify testedwith = 'internal' for # extensions which SHIP WITH MERCURIAL. Non-mainline extensions should # be specifying the version(s) of Mercurial they are tested with, or # leave the attribute unspecified. testedwith = 'internal' # storage format version; increment when the format changes storageversion = 0 # namespaces bookmarktype = 'bookmark' # Journal recording, register hooks and storage object def extsetup(ui): extensions.wrapfunction(dispatch, 'runcommand', runcommand) extensions.wrapfunction(bookmarks.bmstore, '_write', recordbookmarks) def reposetup(ui, repo): if repo.local(): repo.journal = journalstorage(repo) def runcommand(orig, lui, repo, cmd, fullargs, *args): """Track the command line options for recording in the journal""" journalstorage.recordcommand(*fullargs) return orig(lui, repo, cmd, fullargs, *args) def recordbookmarks(orig, store, fp): """Records all bookmark changes in the journal.""" repo = store._repo if util.safehasattr(repo, 'journal'): oldmarks = bookmarks.bmstore(repo) for mark, value in store.iteritems(): oldvalue = oldmarks.get(mark, node.nullid) if value != oldvalue: repo.journal.record(bookmarktype, mark, oldvalue, value) return orig(store, fp) class journalentry(collections.namedtuple( 'journalentry', 'timestamp user command namespace name oldhashes newhashes')): """Individual journal entry * timestamp: a mercurial (time, timezone) tuple * user: the username that ran the command * namespace: the entry namespace, an opaque string * name: the name of the changed item, opaque string with meaning in the namespace * command: the hg command that triggered this record * oldhashes: a tuple of one or more binary hashes for the old location * newhashes: a tuple of one or more binary hashes for the new location Handles serialisation from and to the storage format. Fields are separated by newlines, hashes are written out in hex separated by commas, timestamp and timezone are separated by a space. """ @classmethod def fromstorage(cls, line): (time, user, command, namespace, name, oldhashes, newhashes) = line.split('\n') timestamp, tz = time.split() timestamp, tz = float(timestamp), int(tz) oldhashes = tuple(node.bin(hash) for hash in oldhashes.split(',')) newhashes = tuple(node.bin(hash) for hash in newhashes.split(',')) return cls( (timestamp, tz), user, command, namespace, name, oldhashes, newhashes) def __str__(self): """String representation for storage""" time = ' '.join(map(str, self.timestamp)) oldhashes = ','.join([node.hex(hash) for hash in self.oldhashes]) newhashes = ','.join([node.hex(hash) for hash in self.newhashes]) return '\n'.join(( time, self.user, self.command, self.namespace, self.name, oldhashes, newhashes)) class journalstorage(object): """Storage for journal entries Entries are stored with NUL bytes as separators. See the journalentry class for the per-entry structure. The file format starts with an integer version, delimited by a NUL. """ _currentcommand = () def __init__(self, repo): self.repo = repo self.user = util.getuser() self.vfs = repo.vfs # track the current command for recording in journal entries @property def command(self): commandstr = ' '.join( map(util.shellquote, journalstorage._currentcommand)) if '\n' in commandstr: # truncate multi-line commands commandstr = commandstr.partition('\n')[0] + ' ...' return commandstr @classmethod def recordcommand(cls, *fullargs): """Set the current hg arguments, stored with recorded entries""" # Set the current command on the class because we may have started # with a non-local repo (cloning for example). cls._currentcommand = fullargs def record(self, namespace, name, oldhashes, newhashes): """Record a new journal entry * namespace: an opaque string; this can be used to filter on the type of recorded entries. * name: the name defining this entry; for bookmarks, this is the bookmark name. Can be filtered on when retrieving entries. * oldhashes and newhashes: each a single binary hash, or a list of binary hashes. These represent the old and new position of the named item. """ if not isinstance(oldhashes, list): oldhashes = [oldhashes] if not isinstance(newhashes, list): newhashes = [newhashes] entry = journalentry( util.makedate(), self.user, self.command, namespace, name, oldhashes, newhashes) with self.repo.wlock(): version = None # open file in amend mode to ensure it is created if missing with self.vfs('journal', mode='a+b', atomictemp=True) as f: f.seek(0, os.SEEK_SET) # Read just enough bytes to get a version number (up to 2 # digits plus separator) version = f.read(3).partition('\0')[0] if version and version != str(storageversion): # different version of the storage. Exit early (and not # write anything) if this is not a version we can handle or # the file is corrupt. In future, perhaps rotate the file # instead? self.repo.ui.warn( _("unsupported journal file version '%s'\n") % version) return if not version: # empty file, write version first f.write(str(storageversion) + '\0') f.seek(0, os.SEEK_END) f.write(str(entry) + '\0') def filtered(self, namespace=None, name=None): """Yield all journal entries with the given namespace or name Both the namespace and the name are optional; if neither is given all entries in the journal are produced. """ for entry in self: if namespace is not None and entry.namespace != namespace: continue if name is not None and entry.name != name: continue yield entry def __iter__(self): """Iterate over the storage Yields journalentry instances for each contained journal record. """ if not self.vfs.exists('journal'): return with self.vfs('journal') as f: raw = f.read() lines = raw.split('\0') version = lines and lines[0] if version != str(storageversion): version = version or _('not available') raise error.Abort(_("unknown journal file version '%s'") % version) # Skip the first line, it's a version number. Reverse the rest. lines = reversed(lines[1:]) for line in lines: if not line: continue yield journalentry.fromstorage(line) # journal reading # log options that don't make sense for journal _ignoreopts = ('no-merges', 'graph') @command( 'journal', [ ('c', 'commits', None, 'show commit metadata'), ] + [opt for opt in commands.logopts if opt[1] not in _ignoreopts], '[OPTION]... [BOOKMARKNAME]') def journal(ui, repo, *args, **opts): """show the previous position of bookmarks The journal is used to see the previous commits of bookmarks. By default the previous locations for all bookmarks are shown. Passing a bookmark name will show all the previous positions of that bookmark. By default hg journal only shows the commit hash and the command that was running at that time. -v/--verbose will show the prior hash, the user, and the time at which it happened. Use -c/--commits to output log information on each commit hash; at this point you can use the usual `--patch`, `--git`, `--stat` and `--template` switches to alter the log output for these. `hg journal -T json` can be used to produce machine readable output. """ bookmarkname = None if args: bookmarkname = args[0] fm = ui.formatter('journal', opts) if opts.get("template") != "json": if bookmarkname is None: name = _('all bookmarks') else: name = "'%s'" % bookmarkname ui.status(_("previous locations of %s:\n") % name) limit = cmdutil.loglimit(opts) entry = None for count, entry in enumerate(repo.journal.filtered(name=bookmarkname)): if count == limit: break newhashesstr = ','.join([node.short(hash) for hash in entry.newhashes]) oldhashesstr = ','.join([node.short(hash) for hash in entry.oldhashes]) fm.startitem() fm.condwrite(ui.verbose, 'oldhashes', '%s -> ', oldhashesstr) fm.write('newhashes', '%s', newhashesstr) fm.condwrite(ui.verbose, 'user', ' %s', entry.user.ljust(8)) timestring = util.datestr(entry.timestamp, '%Y-%m-%d %H:%M %1%2') fm.condwrite(ui.verbose, 'date', ' %s', timestring) fm.write('command', ' %s\n', entry.command) if opts.get("commits"): displayer = cmdutil.show_changeset(ui, repo, opts, buffered=False) for hash in entry.newhashes: try: ctx = repo[hash] displayer.show(ctx) except error.RepoLookupError as e: fm.write('repolookuperror', "%s\n\n", str(e)) displayer.close() fm.end() if entry is None: ui.status(_("no recorded locations\n"))