|
|
# 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"))
|
|
|
|
