hgk.py
389 lines
| 11.9 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] | ||||
|
r25793 | path = /location/of/hgk | ||
|
r6666 | |||
|
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 | |||
|
r29125 | from __future__ import absolute_import | ||
|
r5878 | import os | ||
|
r29205 | |||
from mercurial.i18n import _ | ||||
from mercurial.node import ( | ||||
nullid, | ||||
nullrev, | ||||
short, | ||||
) | ||||
|
r29125 | from mercurial import ( | ||
commands, | ||||
obsolete, | ||||
patch, | ||||
|
r34999 | pycompat, | ||
|
r32337 | registrar, | ||
|
r29125 | scmutil, | ||
) | ||||
|
r2432 | |||
|
r21250 | cmdtable = {} | ||
|
r32337 | command = registrar.command(cmdtable) | ||
|
r29841 | # Note for extension authors: ONLY specify testedwith = 'ships-with-hg-core' for | ||
|
r25186 | # 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. | ||||
|
r43347 | testedwith = b'ships-with-hg-core' | ||
|
r16743 | |||
|
r34500 | configtable = {} | ||
configitem = registrar.configitem(configtable) | ||||
|
r43346 | configitem( | ||
|
r46554 | b'hgk', | ||
b'path', | ||||
default=b'hgk', | ||||
|
r34500 | ) | ||
|
r43346 | |||
@command( | ||||
|
r43347 | b'debug-diff-tree', | ||
|
r43346 | [ | ||
|
r43347 | (b'p', b'patch', None, _(b'generate patch')), | ||
(b'r', b'recursive', None, _(b'recursive')), | ||||
(b'P', b'pretty', None, _(b'pretty')), | ||||
(b's', b'stdin', None, _(b'stdin')), | ||||
(b'C', b'copy', None, _(b'detect copies')), | ||||
(b'S', b'search', b"", _(b'search')), | ||||
|
r43346 | ], | ||
|
r43347 | b'[OPTION]... NODE1 NODE2 [FILE]...', | ||
|
r43346 | inferrepo=True, | ||
) | ||||
|
r3063 | def difftree(ui, repo, node1=None, node2=None, *files, **opts): | ||
|
r2432 | """diff trees from two commits""" | ||
|
r34999 | |||
|
r31409 | def __difftree(repo, node1, node2, files=None): | ||
|
r3978 | assert node2 is not None | ||
|
r31409 | if files is None: | ||
files = [] | ||||
|
r6747 | mmap = repo[node1].manifest() | ||
mmap2 = repo[node2].manifest() | ||||
|
r14671 | m = scmutil.match(repo[node1], files) | ||
|
r44038 | st = repo.status(node1, node2, m) | ||
|
r6217 | empty = short(nullid) | ||
|
r2432 | |||
|
r44038 | for f in st.modified: | ||
|
r2432 | # TODO get file permissions | ||
|
r43350 | ui.writenoi18n( | ||
|
r43347 | b":100664 100664 %s %s M\t%s\t%s\n" | ||
|
r43346 | % (short(mmap[f]), short(mmap2[f]), f, f) | ||
) | ||||
|
r44038 | for f in st.added: | ||
|
r43350 | ui.writenoi18n( | ||
|
r43347 | b":000000 100664 %s %s N\t%s\t%s\n" | ||
|
r43346 | % (empty, short(mmap2[f]), f, f) | ||
) | ||||
|
r44038 | for f in st.removed: | ||
|
r43350 | ui.writenoi18n( | ||
|
r43347 | b":100664 000000 %s %s D\t%s\t%s\n" | ||
|
r43346 | % (short(mmap[f]), empty, f, f) | ||
) | ||||
|
r2432 | ## | ||
while True: | ||||
|
r43906 | if opts['stdin']: | ||
|
r36808 | line = ui.fin.readline() | ||
if not line: | ||||
|
r2432 | break | ||
|
r36808 | line = line.rstrip(pycompat.oslinesep).split(b' ') | ||
node1 = line[0] | ||||
if len(line) > 1: | ||||
node2 = line[1] | ||||
else: | ||||
node2 = None | ||||
|
r2432 | node1 = repo.lookup(node1) | ||
if node2: | ||||
node2 = repo.lookup(node2) | ||||
else: | ||||
node2 = node1 | ||||
node1 = repo.changelog.parents(node1)[0] | ||||
|
r43906 | if opts['patch']: | ||
if opts['pretty']: | ||||
|
r43347 | catcommit(ui, repo, node2, b"") | ||
|
r14671 | m = scmutil.match(repo[node1], files) | ||
|
r23451 | diffopts = patch.difffeatureopts(ui) | ||
diffopts.git = True | ||||
|
r43346 | chunks = patch.diff(repo, node1, node2, match=m, opts=diffopts) | ||
|
r7308 | for chunk in chunks: | ||
|
r8615 | ui.write(chunk) | ||
|
r2432 | else: | ||
|
r3063 | __difftree(repo, node1, node2, files=files) | ||
|
r43906 | if not opts['stdin']: | ||
|
r2432 | break | ||
|
r43346 | |||
|
r5878 | def catcommit(ui, repo, n, prefix, ctx=None): | ||
|
r43347 | nlprefix = b'\n' + prefix | ||
|
r3979 | if ctx is None: | ||
|
r6747 | ctx = repo[n] | ||
|
r16683 | # use ctx.node() instead ?? | ||
|
r43347 | ui.write((b"tree %s\n" % short(ctx.changeset()[0]))) | ||
|
r6768 | for p in ctx.parents(): | ||
|
r43347 | ui.write((b"parent %s\n" % p)) | ||
|
r6768 | |||
|
r3979 | date = ctx.date() | ||
|
r43347 | description = ctx.description().replace(b"\0", b"") | ||
ui.write((b"author %s %d %d\n" % (ctx.user(), int(date[0]), date[1]))) | ||||
|
r2432 | |||
|
r43347 | if b'committer' in ctx.extra(): | ||
ui.write((b"committer %s\n" % ctx.extra()[b'committer'])) | ||||
|
r24604 | |||
|
r43347 | ui.write((b"revision %d\n" % ctx.rev())) | ||
ui.write((b"branch %s\n" % ctx.branch())) | ||||
|
r24513 | if obsolete.isenabled(repo, obsolete.createmarkersopt): | ||
if ctx.obsolete(): | ||||
|
r43350 | ui.writenoi18n(b"obsolete\n") | ||
|
r43347 | ui.write((b"phase %s\n\n" % ctx.phasestr())) | ||
|
r5878 | |||
|
r43347 | if prefix != b"": | ||
|
r43346 | ui.write( | ||
|
r43347 | b"%s%s\n" % (prefix, description.replace(b'\n', nlprefix).strip()) | ||
|
r43346 | ) | ||
|
r2432 | else: | ||
|
r43347 | ui.write(description + b"\n") | ||
|
r2432 | if prefix: | ||
|
r43347 | ui.write(b'\0') | ||
|
r2432 | |||
|
r43346 | |||
|
r43347 | @command(b'debug-merge-base', [], _(b'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) | ||||
|
r43347 | ui.write(short(n) + b"\n") | ||
|
r2432 | |||
|
r43346 | |||
@command( | ||||
|
r43347 | b'debug-cat-file', | ||
[(b's', b'stdin', None, _(b'stdin'))], | ||||
_(b'[OPTION]... TYPE FILE'), | ||||
|
r43346 | inferrepo=True, | ||
) | ||||
|
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 | ||||
# | ||||
|
r43347 | prefix = b"" | ||
|
r43906 | if opts['stdin']: | ||
|
r36808 | line = ui.fin.readline() | ||
if not line: | ||||
|
r2432 | return | ||
|
r36808 | (type, r) = line.rstrip(pycompat.oslinesep).split(b' ') | ||
|
r43347 | prefix = b" " | ||
|
r2432 | else: | ||
if not type or not r: | ||||
|
r43347 | ui.warn(_(b"cat-file: type or revision not supplied\n")) | ||
commands.help_(ui, b'cat-file') | ||||
|
r2432 | |||
while r: | ||||
|
r43347 | if type != b"commit": | ||
ui.warn(_(b"aborting hg cat-file only understands commits\n")) | ||||
|
r10394 | return 1 | ||
|
r2432 | n = repo.lookup(r) | ||
|
r5878 | catcommit(ui, repo, n, prefix) | ||
|
r43906 | if opts['stdin']: | ||
|
r36808 | line = ui.fin.readline() | ||
if not line: | ||||
|
r2432 | break | ||
|
r36808 | (type, r) = line.rstrip(pycompat.oslinesep).split(b' ') | ||
|
r2432 | else: | ||
break | ||||
|
r43346 | |||
|
r2432 | # 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 ^ | ||||
|
r43347 | def revtree(ui, args, repo, full=b"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 | ||||
|
r38806 | for x in pycompat.xrange(chunk): | ||
|
r2432 | if i + x >= count: | ||
|
r43346 | l[chunk - x :] = [0] * (chunk - x) | ||
|
r2432 | break | ||
|
r13031 | if full is not None: | ||
|
r22580 | if (i + x) in repo: | ||
l[x] = repo[i + x] | ||||
|
r43346 | l[x].changeset() # force reading | ||
|
r2432 | else: | ||
|
r22580 | if (i + x) in repo: | ||
l[x] = 1 | ||||
|
r38806 | for x in pycompat.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 | ||||
|
r38806 | for i in pycompat.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): | ||
|
r43347 | if arg.startswith(b'^'): | ||
|
r8632 | s = repo.lookup(arg[1:]) | ||
|
r2432 | stop_sha1.append(s) | ||
want_sha1.append(s) | ||||
|
r43347 | elif arg != b'HEAD': | ||
|
r8632 | 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(): | ||
|
r22580 | if i not in repo: | ||
continue | ||||
|
r2432 | n = repo.changelog.node(i) | ||
mask = is_reachable(want_sha1, reachable, n) | ||||
if mask: | ||||
|
r43347 | parentstr = b"" | ||
|
r2432 | if parents: | ||
pp = repo.changelog.parents(n) | ||||
|
r6217 | if pp[0] != nullid: | ||
|
r43347 | parentstr += b" " + short(pp[0]) | ||
|
r6217 | if pp[1] != nullid: | ||
|
r43347 | parentstr += b" " + short(pp[1]) | ||
|
r2432 | if not full: | ||
|
r43347 | ui.write(b"%s%s\n" % (short(n), parentstr)) | ||
elif full == b"commit": | ||||
ui.write(b"%s%s\n" % (short(n), parentstr)) | ||||
catcommit(ui, repo, n, b' ', 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] | ||
|
r43347 | ui.write(b"%s %s:%s" % (date, h, mask)) | ||
|
r2432 | mask = is_reachable(want_sha1, reachable, p1) | ||
|
r6217 | if i1 != nullrev and mask > 0: | ||
|
r43347 | ui.write(b"%s:%s " % (h1, mask)), | ||
|
r2432 | mask = is_reachable(want_sha1, reachable, p2) | ||
|
r6217 | if i2 != nullrev and mask > 0: | ||
|
r43347 | ui.write(b"%s:%s " % (h2, mask)) | ||
ui.write(b"\n") | ||||
|
r2432 | if maxnr and count >= maxnr: | ||
break | ||||
count += 1 | ||||
|
r43346 | |||
|
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 | ||||
|
r43346 | @command( | ||
|
r43347 | b'debug-rev-list', | ||
|
r43346 | [ | ||
|
r43347 | (b'H', b'header', None, _(b'header')), | ||
(b't', b'topo-order', None, _(b'topo-order')), | ||||
(b'p', b'parents', None, _(b'parents')), | ||||
(b'n', b'max-count', 0, _(b'max-count')), | ||||
|
r43346 | ], | ||
|
r43347 | b'[OPTION]... REV...', | ||
|
r43346 | ) | ||
|
r2432 | def revlist(ui, repo, *revs, **opts): | ||
"""print revisions""" | ||||
|
r45167 | if opts['header']: | ||
|
r43347 | full = b"commit" | ||
|
r2432 | else: | ||
full = None | ||||
copy = [x for x in revs] | ||||
|
r43906 | revtree(ui, copy, repo, full, opts['max_count'], opts[r'parents']) | ||
|
r2432 | |||
|
r43346 | |||
@command( | ||||
|
r43347 | b'view', | ||
[(b'l', b'limit', b'', _(b'limit number of changes displayed'), _(b'NUM'))], | ||||
_(b'[-l LIMIT] [REVRANGE]'), | ||||
|
r43346 | helpcategory=command.CATEGORY_CHANGE_NAVIGATION, | ||
) | ||||
|
r3093 | def view(ui, repo, *etc, **opts): | ||
|
r44226 | """start interactive history viewer""" | ||
|
r34999 | opts = pycompat.byteskwargs(opts) | ||
|
r2432 | os.chdir(repo.root) | ||
|
r43375 | optstr = b' '.join( | ||
[b'--%s %s' % (k, v) for k, v in pycompat.iteritems(opts) if v] | ||||
) | ||||
|
r24512 | if repo.filtername is None: | ||
|
r43347 | optstr += b'--hidden' | ||
|
r24512 | |||
|
r43347 | cmd = ui.config(b"hgk", b"path") + b" %s %s" % (optstr, b" ".join(etc)) | ||
ui.debug(b"running %s\n" % cmd) | ||||
ui.system(cmd, blockedtag=b'hgk_view') | ||||