hgk.py
348 lines
| 11.5 KiB
| text/x-python
|
PythonLexer
/ hgext / hgk.py
|
r2432 | # Minimal support for git commands on an hg repository | ||
# | ||||
|
r2859 | # Copyright 2005, 2006 Chris Mason <mason@suse.com> | ||
|
r2432 | # | ||
|
r8225 | # This software may be used and distributed according to the terms of the | ||
|
r10263 | # GNU General Public License version 2 or any later version. | ||
|
r8228 | |||
|
r8894 | '''browse the repository in a graphical way | ||
|
r6666 | |||
|
r9261 | The hgk extension allows browsing the history of a repository in a | ||
graphical way. It requires Tcl/Tk version 8.4 or later. (Tcl/Tk is not | ||||
distributed with Mercurial.) | ||||
|
r6666 | |||
|
r9261 | hgk consists of two parts: a Tcl script that does the displaying and | ||
querying of information, and an extension to Mercurial named hgk.py, | ||||
which provides hooks for hgk to get information. hgk can be found in | ||||
the contrib directory, and the extension is shipped in the hgext | ||||
repository, and needs to be enabled. | ||||
|
r6666 | |||
|
r11193 | The :hg:`view` command will launch the hgk Tcl script. For this command | ||
|
r9261 | to work, hgk must be in your search path. Alternately, you can specify | ||
|
r12083 | the path to hgk in your configuration file:: | ||
|
r6666 | |||
[hgk] | ||||
path=/location/of/hgk | ||||
|
r9261 | hgk can make use of the extdiff extension to visualize revisions. | ||
Assuming you had already configured extdiff vdiff command, just add:: | ||||
|
r6666 | |||
[hgk] | ||||
vdiff=vdiff | ||||
|
r9261 | Revisions context menu will now display additional entries to fire | ||
vdiff on hovered and selected revisions. | ||||
|
r9063 | ''' | ||
|
r2432 | |||
|
r5878 | import os | ||
|
r21250 | from mercurial import cmdutil, commands, util, patch, revlog, scmutil | ||
|
r6217 | from mercurial.node import nullid, nullrev, short | ||
|
r6958 | from mercurial.i18n import _ | ||
|
r2432 | |||
|
r21250 | cmdtable = {} | ||
command = cmdutil.command(cmdtable) | ||||
|
r16743 | testedwith = 'internal' | ||
|
r21250 | @command('debug-diff-tree', | ||
[('p', 'patch', None, _('generate patch')), | ||||
('r', 'recursive', None, _('recursive')), | ||||
('P', 'pretty', None, _('pretty')), | ||||
('s', 'stdin', None, _('stdin')), | ||||
('C', 'copy', None, _('detect copies')), | ||||
('S', 'search', "", _('search'))], | ||||
('hg git-diff-tree [OPTION]... NODE1 NODE2 [FILE]...')) | ||||
|
r3063 | def difftree(ui, repo, node1=None, node2=None, *files, **opts): | ||
|
r2432 | """diff trees from two commits""" | ||
|
r3063 | def __difftree(repo, node1, node2, files=[]): | ||
|
r3978 | assert node2 is not None | ||
|
r6747 | mmap = repo[node1].manifest() | ||
mmap2 = repo[node2].manifest() | ||||
|
r14671 | m = scmutil.match(repo[node1], files) | ||
|
r6760 | modified, added, removed = repo.status(node1, node2, m)[:3] | ||
|
r6217 | empty = short(nullid) | ||
|
r2432 | |||
for f in modified: | ||||
# TODO get file permissions | ||||
|
r5878 | ui.write(":100664 100664 %s %s M\t%s\t%s\n" % | ||
|
r6217 | (short(mmap[f]), short(mmap2[f]), f, f)) | ||
|
r2432 | for f in added: | ||
|
r5878 | ui.write(":000000 100664 %s %s N\t%s\t%s\n" % | ||
|
r6217 | (empty, short(mmap2[f]), f, f)) | ||
|
r2432 | for f in removed: | ||
|
r5878 | ui.write(":100664 000000 %s %s D\t%s\t%s\n" % | ||
|
r6217 | (short(mmap[f]), empty, f, f)) | ||
|
r2432 | ## | ||
while True: | ||||
if opts['stdin']: | ||||
try: | ||||
line = raw_input().split(' ') | ||||
node1 = line[0] | ||||
if len(line) > 1: | ||||
node2 = line[1] | ||||
else: | ||||
node2 = None | ||||
except EOFError: | ||||
break | ||||
node1 = repo.lookup(node1) | ||||
if node2: | ||||
node2 = repo.lookup(node2) | ||||
else: | ||||
node2 = node1 | ||||
node1 = repo.changelog.parents(node1)[0] | ||||
if opts['patch']: | ||||
if opts['pretty']: | ||||
|
r5878 | catcommit(ui, repo, node2, "") | ||
|
r14671 | m = scmutil.match(repo[node1], files) | ||
|
r7308 | chunks = patch.diff(repo, node1, node2, match=m, | ||
opts=patch.diffopts(ui, {'git': True})) | ||||
for chunk in chunks: | ||||
|
r8615 | ui.write(chunk) | ||
|
r2432 | else: | ||
|
r3063 | __difftree(repo, node1, node2, files=files) | ||
|
r2432 | if not opts['stdin']: | ||
break | ||||
|
r5878 | def catcommit(ui, repo, n, prefix, ctx=None): | ||
|
r10394 | nlprefix = '\n' + prefix | ||
|
r3979 | if ctx is None: | ||
|
r6747 | ctx = repo[n] | ||
|
r16683 | # use ctx.node() instead ?? | ||
|
r17956 | ui.write(("tree %s\n" % short(ctx.changeset()[0]))) | ||
|
r6768 | for p in ctx.parents(): | ||
|
r17956 | ui.write(("parent %s\n" % p)) | ||
|
r6768 | |||
|
r3979 | date = ctx.date() | ||
|
r4039 | description = ctx.description().replace("\0", "") | ||
|
r3979 | lines = description.splitlines() | ||
|
r2525 | if lines and lines[-1].startswith('committer:'): | ||
|
r2432 | committer = lines[-1].split(': ')[1].rstrip() | ||
else: | ||||
|
r17959 | committer = "" | ||
|
r2432 | |||
|
r17956 | ui.write(("author %s %s %s\n" % (ctx.user(), int(date[0]), date[1]))) | ||
|
r17959 | if committer != '': | ||
ui.write(("committer %s %s %s\n" % (committer, int(date[0]), date[1]))) | ||||
|
r17956 | ui.write(("revision %d\n" % ctx.rev())) | ||
|
r18807 | ui.write(("branch %s\n" % ctx.branch())) | ||
ui.write(("phase %s\n\n" % ctx.phasestr())) | ||||
|
r5878 | |||
|
r2432 | if prefix != "": | ||
|
r16683 | ui.write("%s%s\n" % (prefix, | ||
description.replace('\n', nlprefix).strip())) | ||||
|
r2432 | else: | ||
|
r5878 | ui.write(description + "\n") | ||
|
r2432 | if prefix: | ||
|
r5878 | ui.write('\0') | ||
|
r2432 | |||
|
r21250 | @command('debug-merge-base', [], _('hg debug-merge-base REV REV')) | ||
|
r2432 | def base(ui, repo, node1, node2): | ||
|
r7598 | """output common ancestor information""" | ||
|
r2432 | node1 = repo.lookup(node1) | ||
node2 = repo.lookup(node2) | ||||
n = repo.changelog.ancestor(node1, node2) | ||||
|
r6217 | ui.write(short(n) + "\n") | ||
|
r2432 | |||
|
r21250 | @command('debug-cat-file', | ||
[('s', 'stdin', None, _('stdin'))], | ||||
_('hg debug-cat-file [OPTION]... TYPE FILE')) | ||||
|
r2432 | def catfile(ui, repo, type=None, r=None, **opts): | ||
"""cat a specific revision""" | ||||
# in stdin mode, every line except the commit is prefixed with two | ||||
# spaces. This way the our caller can find the commit without magic | ||||
# strings | ||||
# | ||||
prefix = "" | ||||
if opts['stdin']: | ||||
try: | ||||
|
r10394 | (type, r) = raw_input().split(' ') | ||
|
r2432 | prefix = " " | ||
except EOFError: | ||||
return | ||||
else: | ||||
if not type or not r: | ||||
|
r6958 | ui.warn(_("cat-file: type or revision not supplied\n")) | ||
|
r2432 | commands.help_(ui, 'cat-file') | ||
while r: | ||||
if type != "commit": | ||||
|
r6958 | ui.warn(_("aborting hg cat-file only understands commits\n")) | ||
|
r10394 | return 1 | ||
|
r2432 | n = repo.lookup(r) | ||
|
r5878 | catcommit(ui, repo, n, prefix) | ||
|
r2432 | if opts['stdin']: | ||
try: | ||||
|
r10394 | (type, r) = raw_input().split(' ') | ||
|
r2432 | except EOFError: | ||
break | ||||
else: | ||||
break | ||||
# git rev-tree is a confusing thing. You can supply a number of | ||||
# commit sha1s on the command line, and it walks the commit history | ||||
# telling you which commits are reachable from the supplied ones via | ||||
# a bitmask based on arg position. | ||||
# you can specify a commit to stop at by starting the sha1 with ^ | ||||
|
r5878 | def revtree(ui, args, repo, full="tree", maxnr=0, parents=False): | ||
|
r2432 | def chlogwalk(): | ||
|
r6750 | count = len(repo) | ||
|
r2432 | i = count | ||
l = [0] * 100 | ||||
chunk = 100 | ||||
while True: | ||||
if chunk > i: | ||||
chunk = i | ||||
i = 0 | ||||
else: | ||||
i -= chunk | ||||
|
r8624 | for x in xrange(chunk): | ||
|
r2432 | if i + x >= count: | ||
l[chunk - x:] = [0] * (chunk - x) | ||||
break | ||||
|
r13031 | if full is not None: | ||
|
r6747 | l[x] = repo[i + x] | ||
|
r3981 | l[x].changeset() # force reading | ||
|
r2432 | else: | ||
l[x] = 1 | ||||
|
r10282 | for x in xrange(chunk - 1, -1, -1): | ||
|
r2432 | if l[x] != 0: | ||
|
r13031 | yield (i + x, full is not None and l[x] or None) | ||
|
r2432 | if i == 0: | ||
break | ||||
# calculate and return the reachability bitmask for sha | ||||
def is_reachable(ar, reachable, sha): | ||||
if len(ar) == 0: | ||||
return 1 | ||||
mask = 0 | ||||
|
r3473 | for i in xrange(len(ar)): | ||
|
r2432 | if sha in reachable[i]: | ||
mask |= 1 << i | ||||
return mask | ||||
reachable = [] | ||||
stop_sha1 = [] | ||||
want_sha1 = [] | ||||
count = 0 | ||||
# figure out which commits they are asking for and which ones they | ||||
# want us to stop on | ||||
|
r8632 | for i, arg in enumerate(args): | ||
if arg.startswith('^'): | ||||
s = repo.lookup(arg[1:]) | ||||
|
r2432 | stop_sha1.append(s) | ||
want_sha1.append(s) | ||||
|
r8632 | elif arg != 'HEAD': | ||
want_sha1.append(repo.lookup(arg)) | ||||
|
r2432 | |||
# calculate the graph for the supplied commits | ||||
|
r8632 | for i, n in enumerate(want_sha1): | ||
|
r10394 | reachable.append(set()) | ||
visit = [n] | ||||
|
r8459 | reachable[i].add(n) | ||
|
r2432 | while visit: | ||
n = visit.pop(0) | ||||
if n in stop_sha1: | ||||
continue | ||||
for p in repo.changelog.parents(n): | ||||
if p not in reachable[i]: | ||||
|
r8459 | reachable[i].add(p) | ||
|
r2432 | visit.append(p) | ||
if p in stop_sha1: | ||||
continue | ||||
# walk the repository looking for commits that are in our | ||||
# reachability graph | ||||
|
r3979 | for i, ctx in chlogwalk(): | ||
|
r2432 | n = repo.changelog.node(i) | ||
mask = is_reachable(want_sha1, reachable, n) | ||||
if mask: | ||||
parentstr = "" | ||||
if parents: | ||||
pp = repo.changelog.parents(n) | ||||
|
r6217 | if pp[0] != nullid: | ||
parentstr += " " + short(pp[0]) | ||||
if pp[1] != nullid: | ||||
parentstr += " " + short(pp[1]) | ||||
|
r2432 | if not full: | ||
|
r6217 | ui.write("%s%s\n" % (short(n), parentstr)) | ||
|
r3064 | elif full == "commit": | ||
|
r6217 | ui.write("%s%s\n" % (short(n), parentstr)) | ||
|
r5878 | catcommit(ui, repo, n, ' ', ctx) | ||
|
r2432 | else: | ||
(p1, p2) = repo.changelog.parents(n) | ||||
|
r6217 | (h, h1, h2) = map(short, (n, p1, p2)) | ||
|
r2432 | (i1, i2) = map(repo.changelog.rev, (p1, p2)) | ||
|
r3979 | date = ctx.date()[0] | ||
|
r5878 | ui.write("%s %s:%s" % (date, h, mask)) | ||
|
r2432 | mask = is_reachable(want_sha1, reachable, p1) | ||
|
r6217 | if i1 != nullrev and mask > 0: | ||
|
r5878 | ui.write("%s:%s " % (h1, mask)), | ||
|
r2432 | mask = is_reachable(want_sha1, reachable, p2) | ||
|
r6217 | if i2 != nullrev and mask > 0: | ||
|
r5878 | ui.write("%s:%s " % (h2, mask)) | ||
ui.write("\n") | ||||
|
r2432 | if maxnr and count >= maxnr: | ||
break | ||||
count += 1 | ||||
|
r21250 | @command('debug-rev-parse', | ||
[('', 'default', '', _('ignored'))], | ||||
_('hg debug-rev-parse REV')) | ||||
|
r3093 | def revparse(ui, repo, *revs, **opts): | ||
|
r7598 | """parse given revisions""" | ||
|
r3093 | def revstr(rev): | ||
if rev == 'HEAD': | ||||
rev = 'tip' | ||||
return revlog.hex(repo.lookup(rev)) | ||||
for r in revs: | ||||
revrange = r.split(':', 1) | ||||
ui.write('%s\n' % revstr(revrange[0])) | ||||
if len(revrange) == 2: | ||||
ui.write('^%s\n' % revstr(revrange[1])) | ||||
|
r2432 | # git rev-list tries to order things by date, and has the ability to stop | ||
# at a given commit without walking the whole repo. TODO add the stop | ||||
# parameter | ||||
|
r21250 | @command('debug-rev-list', | ||
[('H', 'header', None, _('header')), | ||||
('t', 'topo-order', None, _('topo-order')), | ||||
('p', 'parents', None, _('parents')), | ||||
('n', 'max-count', 0, _('max-count'))], | ||||
('hg debug-rev-list [OPTION]... REV...')) | ||||
|
r2432 | def revlist(ui, repo, *revs, **opts): | ||
"""print revisions""" | ||||
if opts['header']: | ||||
full = "commit" | ||||
else: | ||||
full = None | ||||
copy = [x for x in revs] | ||||
|
r5878 | revtree(ui, copy, repo, full, opts['max_count'], opts['parents']) | ||
|
r2432 | |||
|
r21250 | @command('debug-config', [], _('hg debug-config')) | ||
|
r5393 | def config(ui, repo, **opts): | ||
"""print extension options""" | ||||
def writeopt(name, value): | ||||
|
r17956 | ui.write(('k=%s\nv=%s\n' % (name, value))) | ||
|
r5393 | |||
writeopt('vdiff', ui.config('hgk', 'vdiff', '')) | ||||
|
r5760 | |||
|
r5393 | |||
|
r21250 | @command('view', | ||
[('l', 'limit', '', | ||||
_('limit number of changes displayed'), _('NUM'))], | ||||
_('hg view [-l LIMIT] [REVRANGE]')) | ||||
|
r3093 | def view(ui, repo, *etc, **opts): | ||
|
r2432 | "start interactive history viewer" | ||
os.chdir(repo.root) | ||||
|
r3180 | optstr = ' '.join(['--%s %s' % (k, v) for k, v in opts.iteritems() if v]) | ||
cmd = ui.config("hgk", "path", "hgk") + " %s %s" % (optstr, " ".join(etc)) | ||||
|
r9467 | ui.debug("running %s\n" % cmd) | ||
|
r4688 | util.system(cmd) | ||
|
r2432 | |||
|
r17773 | commands.inferrepo += " debug-diff-tree debug-cat-file" | ||