graphlog.py
399 lines
| 13.1 KiB
| text/x-python
|
PythonLexer
/ hgext / graphlog.py
|
r4344 | # ASCII graph log extension for Mercurial | ||
# | ||||
# Copyright 2007 Joel Rosdahl <joel@rosdahl.net> | ||||
|
r4516 | # | ||
|
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 | |||
|
r8934 | '''command to view revision graphs from a shell | ||
|
r7426 | |||
This extension adds a --graph option to the incoming, outgoing and log | ||||
|
r9259 | commands. When this options is given, an ASCII representation of the | ||
revision graph is also shown. | ||||
|
r7426 | ''' | ||
|
r4344 | |||
from mercurial.cmdutil import revrange, show_changeset | ||||
|
r7873 | from mercurial.commands import templateopts | ||
|
r4344 | from mercurial.i18n import _ | ||
|
r6212 | from mercurial.node import nullrev | ||
|
r12730 | from mercurial import cmdutil, commands, extensions | ||
|
r14139 | from mercurial import hg, util, graphmod | ||
|
r5938 | |||
|
r8840 | ASCIIDATA = 'ASC' | ||
|
r14130 | def asciiedges(type, char, lines, seen, rev, parents): | ||
|
r8840 | """adds edge info to changelog DAG walk suitable for ascii()""" | ||
|
r9369 | if rev not in seen: | ||
seen.append(rev) | ||||
nodeidx = seen.index(rev) | ||||
|
r5938 | |||
|
r9369 | knownparents = [] | ||
newparents = [] | ||||
for parent in parents: | ||||
if parent in seen: | ||||
knownparents.append(parent) | ||||
else: | ||||
newparents.append(parent) | ||||
|
r5938 | |||
|
r9369 | ncols = len(seen) | ||
|
r14130 | nextseen = seen[:] | ||
nextseen[nodeidx:nodeidx + 1] = newparents | ||||
edges = [(nodeidx, nextseen.index(p)) for p in knownparents] | ||||
while len(newparents) > 2: | ||||
# ascii() only knows how to add or remove a single column between two | ||||
# calls. Nodes with more than two parents break this constraint so we | ||||
# introduce intermediate expansion lines to grow the active node list | ||||
# slowly. | ||||
edges.append((nodeidx, nodeidx)) | ||||
edges.append((nodeidx, nodeidx + 1)) | ||||
nmorecols = 1 | ||||
yield (type, char, lines, (nodeidx, edges, ncols, nmorecols)) | ||||
char = '\\' | ||||
lines = [] | ||||
nodeidx += 1 | ||||
ncols += 1 | ||||
edges = [] | ||||
del newparents[0] | ||||
|
r7370 | |||
|
r9369 | if len(newparents) > 0: | ||
edges.append((nodeidx, nodeidx)) | ||||
if len(newparents) > 1: | ||||
edges.append((nodeidx, nodeidx + 1)) | ||||
|
r14130 | nmorecols = len(nextseen) - ncols | ||
seen[:] = nextseen | ||||
yield (type, char, lines, (nodeidx, edges, ncols, nmorecols)) | ||||
|
r5938 | |||
|
r4344 | def fix_long_right_edges(edges): | ||
for (i, (start, end)) in enumerate(edges): | ||||
if end > start: | ||||
edges[i] = (start, end + 1) | ||||
|
r7326 | def get_nodeline_edges_tail( | ||
node_index, p_node_index, n_columns, n_columns_diff, p_diff, fix_tail): | ||||
if fix_tail and n_columns_diff == p_diff and n_columns_diff != 0: | ||||
# Still going in the same non-vertical direction. | ||||
if n_columns_diff == -1: | ||||
start = max(node_index + 1, p_node_index) | ||||
tail = ["|", " "] * (start - node_index - 1) | ||||
tail.extend(["/", " "] * (n_columns - start)) | ||||
return tail | ||||
else: | ||||
return ["\\", " "] * (n_columns - node_index - 1) | ||||
else: | ||||
return ["|", " "] * (n_columns - node_index - 1) | ||||
|
r4344 | def draw_edges(edges, nodeline, interline): | ||
for (start, end) in edges: | ||||
if start == end + 1: | ||||
interline[2 * end + 1] = "/" | ||||
elif start == end - 1: | ||||
interline[2 * start + 1] = "\\" | ||||
elif start == end: | ||||
interline[2 * start] = "|" | ||||
else: | ||||
nodeline[2 * end] = "+" | ||||
if start > end: | ||||
|
r9198 | (start, end) = (end, start) | ||
|
r4344 | for i in range(2 * start + 1, 2 * end): | ||
if nodeline[i] != "+": | ||||
nodeline[i] = "-" | ||||
def get_padding_line(ni, n_columns, edges): | ||||
line = [] | ||||
line.extend(["|", " "] * ni) | ||||
if (ni, ni - 1) in edges or (ni, ni) in edges: | ||||
# (ni, ni - 1) (ni, ni) | ||||
# | | | | | | | | | ||||
# +---o | | o---+ | ||||
# | | c | | c | | | ||||
# | |/ / | |/ / | ||||
# | | | | | | | ||||
c = "|" | ||||
else: | ||||
c = " " | ||||
line.extend([c, " "]) | ||||
line.extend(["|", " "] * (n_columns - ni - 1)) | ||||
return line | ||||
|
r9631 | def asciistate(): | ||
"""returns the initial value for the "state" argument to ascii()""" | ||||
return [0, 0] | ||||
def ascii(ui, state, type, char, text, coldata): | ||||
|
r8839 | """prints an ASCII graph of the DAG | ||
|
r4344 | |||
|
r9371 | takes the following arguments (one call per node in the graph): | ||
|
r4344 | |||
|
r9371 | - ui to write to | ||
|
r9631 | - Somewhere to keep the needed state in (init to asciistate()) | ||
|
r7325 | - Column of the current node in the set of ongoing edges. | ||
|
r8840 | - Type indicator of node data == ASCIIDATA. | ||
- Payload: (char, lines): | ||||
- Character to use as node's symbol. | ||||
- List of lines to display as the node's text. | ||||
|
r7325 | - Edges; a list of (col, next_col) indicating the edges between | ||
the current node and its parents. | ||||
- Number of columns (ongoing edges) in the current revision. | ||||
- The difference between the number of columns (ongoing edges) | ||||
in the next revision and the number of columns (ongoing edges) | ||||
in the current revision. That is: -1 means one column removed; | ||||
0 means no columns added or removed; 1 means one column added. | ||||
""" | ||||
|
r4344 | |||
|
r9371 | idx, edges, ncols, coldiff = coldata | ||
assert -2 < coldiff < 2 | ||||
if coldiff == -1: | ||||
# Transform | ||||
|
r4344 | # | ||
|
r9371 | # | | | | | | | ||
# o | | into o---+ | ||||
# |X / |/ / | ||||
# | | | | | ||||
fix_long_right_edges(edges) | ||||
# add_padding_line says whether to rewrite | ||||
# | ||||
# | | | | | | | | | ||||
# | o---+ into | o---+ | ||||
# | / / | | | # <--- padding line | ||||
# o | | | / / | ||||
# o | | | ||||
add_padding_line = (len(text) > 2 and coldiff == -1 and | ||||
[x for (x, y) in edges if x + 1 < y]) | ||||
|
r4344 | |||
|
r9371 | # fix_nodeline_tail says whether to rewrite | ||
# | ||||
# | | o | | | | o | | | ||||
# | | |/ / | | |/ / | ||||
# | o | | into | o / / # <--- fixed nodeline tail | ||||
# | |/ / | |/ / | ||||
# o | | o | | | ||||
fix_nodeline_tail = len(text) <= 2 and not add_padding_line | ||||
|
r4344 | |||
|
r9371 | # nodeline is the line containing the node character (typically o) | ||
nodeline = ["|", " "] * idx | ||||
nodeline.extend([char, " "]) | ||||
|
r4344 | |||
|
r9371 | nodeline.extend( | ||
|
r9631 | get_nodeline_edges_tail(idx, state[1], ncols, coldiff, | ||
state[0], fix_nodeline_tail)) | ||||
|
r4344 | |||
|
r9371 | # shift_interline is the line containing the non-vertical | ||
# edges between this entry and the next | ||||
shift_interline = ["|", " "] * idx | ||||
if coldiff == -1: | ||||
n_spaces = 1 | ||||
edge_ch = "/" | ||||
elif coldiff == 0: | ||||
n_spaces = 2 | ||||
edge_ch = "|" | ||||
else: | ||||
n_spaces = 3 | ||||
edge_ch = "\\" | ||||
shift_interline.extend(n_spaces * [" "]) | ||||
shift_interline.extend([edge_ch, " "] * (ncols - idx - 1)) | ||||
|
r4344 | |||
|
r9371 | # draw edges from the current node to its parents | ||
draw_edges(edges, nodeline, shift_interline) | ||||
|
r4344 | |||
|
r9371 | # lines is the list of all graph lines to print | ||
lines = [nodeline] | ||||
if add_padding_line: | ||||
lines.append(get_padding_line(idx, ncols, edges)) | ||||
lines.append(shift_interline) | ||||
|
r4344 | |||
|
r9371 | # make sure that there are as many graph lines as there are | ||
# log strings | ||||
while len(text) < len(lines): | ||||
text.append("") | ||||
if len(lines) < len(text): | ||||
extra_interline = ["|", " "] * (ncols + coldiff) | ||||
while len(lines) < len(text): | ||||
lines.append(extra_interline) | ||||
|
r4344 | |||
|
r9371 | # print lines | ||
indentation_level = max(ncols, ncols + coldiff) | ||||
for (line, logstr) in zip(lines, text): | ||||
ln = "%-*s %s" % (2 * indentation_level, "".join(line), logstr) | ||||
ui.write(ln.rstrip() + '\n') | ||||
|
r4344 | |||
|
r9371 | # ... and start over | ||
|
r9631 | state[0] = coldiff | ||
state[1] = idx | ||||
|
r4344 | |||
|
r7326 | def get_revs(repo, rev_opt): | ||
if rev_opt: | ||||
revs = revrange(repo, rev_opt) | ||||
|
r11448 | if len(revs) == 0: | ||
return (nullrev, nullrev) | ||||
|
r7326 | return (max(revs), min(revs)) | ||
else: | ||||
return (len(repo) - 1, 0) | ||||
|
r14086 | def check_unsupported_flags(pats, opts): | ||
|
r14043 | for op in ["follow_first", "copies", "newest_first"]: | ||
|
r7426 | if op in opts and opts[op]: | ||
|
r14043 | raise util.Abort(_("-G/--graph option is incompatible with --%s") | ||
|
r10097 | % op.replace("_", "-")) | ||
|
r14086 | if pats and opts.get('follow'): | ||
raise util.Abort(_("-G/--graph option is incompatible with --follow " | ||||
"with file argument")) | ||||
|
r7426 | |||
|
r14043 | def revset(pats, opts): | ||
"""Return revset str built of revisions, log options and file patterns. | ||||
""" | ||||
|
r14085 | opt2revset = { | ||
'follow': (0, 'follow()'), | ||||
'no_merges': (0, 'not merge()'), | ||||
'only_merges': (0, 'merge()'), | ||||
'removed': (0, 'removes("*")'), | ||||
'date': (1, 'date($)'), | ||||
'branch': (2, 'branch($)'), | ||||
'exclude': (2, 'not file($)'), | ||||
'include': (2, 'file($)'), | ||||
'keyword': (2, 'keyword($)'), | ||||
'only_branch': (2, 'branch($)'), | ||||
'prune': (2, 'not ($ or ancestors($))'), | ||||
'user': (2, 'user($)'), | ||||
} | ||||
|
r14132 | optrevset = [] | ||
|
r14043 | revset = [] | ||
for op, val in opts.iteritems(): | ||||
if not val: | ||||
continue | ||||
|
r14085 | if op == 'rev': | ||
# Already a revset | ||||
revset.extend(val) | ||||
if op not in opt2revset: | ||||
continue | ||||
arity, revop = opt2revset[op] | ||||
revop = revop.replace('$', '%(val)r') | ||||
if arity == 0: | ||||
|
r14132 | optrevset.append(revop) | ||
|
r14085 | elif arity == 1: | ||
|
r14132 | optrevset.append(revop % {'val': val}) | ||
|
r14085 | else: | ||
|
r14043 | for f in val: | ||
|
r14132 | optrevset.append(revop % {'val': f}) | ||
|
r14043 | |||
for path in pats: | ||||
|
r14132 | optrevset.append('file(%r)' % path) | ||
|
r14043 | |||
|
r14132 | if revset or optrevset: | ||
if revset: | ||||
revset = ['(' + ' or '.join(revset) + ')'] | ||||
if optrevset: | ||||
revset.append('(' + ' and '.join(optrevset) + ')') | ||||
revset = ' and '.join(revset) | ||||
else: | ||||
revset = 'all()' | ||||
|
r14043 | return revset | ||
|
r9371 | def generate(ui, dag, displayer, showparents, edgefn): | ||
|
r9631 | seen, state = [], asciistate() | ||
|
r9369 | for rev, type, ctx, parents in dag: | ||
char = ctx.node() in showparents and '@' or 'o' | ||||
displayer.show(ctx) | ||||
lines = displayer.hunk.pop(rev).split('\n')[:-1] | ||||
|
r12579 | displayer.flush(rev) | ||
|
r14130 | edges = edgefn(type, char, lines, seen, rev, parents) | ||
for type, char, lines, coldata in edges: | ||||
ascii(ui, state, type, char, lines, coldata) | ||||
|
r12579 | displayer.close() | ||
|
r9369 | |||
|
r14043 | def graphlog(ui, repo, *pats, **opts): | ||
|
r7325 | """show revision history alongside an ASCII revision graph | ||
|
r9259 | Print a revision history alongside a revision graph drawn with | ||
ASCII characters. | ||||
|
r7325 | |||
|
r9259 | Nodes printed as an @ character are parents of the working | ||
directory. | ||||
|
r7325 | """ | ||
|
r14086 | check_unsupported_flags(pats, opts) | ||
|
r7370 | |||
|
r14133 | revs = sorted(revrange(repo, [revset(pats, opts)]), reverse=1) | ||
limit = cmdutil.loglimit(opts) | ||||
if limit is not None: | ||||
revs = revs[:limit] | ||||
|
r14043 | revdag = graphmod.dagwalker(repo, revs) | ||
|
r7325 | |||
|
r9368 | displayer = show_changeset(ui, repo, opts, buffered=True) | ||
showparents = [ctx.node() for ctx in repo[None].parents()] | ||||
|
r9371 | generate(ui, revdag, displayer, showparents, asciiedges) | ||
|
r7716 | |||
def graphrevs(repo, nodes, opts): | ||||
limit = cmdutil.loglimit(opts) | ||||
|
r8837 | nodes.reverse() | ||
|
r10111 | if limit is not None: | ||
|
r8837 | nodes = nodes[:limit] | ||
return graphmod.nodes(repo, nodes) | ||||
|
r7716 | |||
def goutgoing(ui, repo, dest=None, **opts): | ||||
"""show the outgoing changesets alongside an ASCII revision graph | ||||
|
r7325 | |||
|
r7716 | Print the outgoing changesets alongside a revision graph drawn with | ||
ASCII characters. | ||||
|
r7426 | |||
|
r7716 | Nodes printed as an @ character are parents of the working | ||
directory. | ||||
|
r7426 | """ | ||
|
r7716 | |||
|
r14086 | check_unsupported_flags([], opts) | ||
|
r12735 | o = hg._outgoing(ui, repo, dest, opts) | ||
if o is None: | ||||
|
r7426 | return | ||
|
r7716 | |||
revdag = graphrevs(repo, o, opts) | ||||
|
r9368 | displayer = show_changeset(ui, repo, opts, buffered=True) | ||
showparents = [ctx.node() for ctx in repo[None].parents()] | ||||
|
r9371 | generate(ui, revdag, displayer, showparents, asciiedges) | ||
|
r7426 | |||
def gincoming(ui, repo, source="default", **opts): | ||||
"""show the incoming changesets alongside an ASCII revision graph | ||||
|
r9259 | Print the incoming changesets alongside a revision graph drawn with | ||
ASCII characters. | ||||
|
r7426 | |||
|
r9259 | Nodes printed as an @ character are parents of the working | ||
directory. | ||||
|
r7426 | """ | ||
|
r12730 | def subreporecurse(): | ||
return 1 | ||||
|
r7426 | |||
|
r14086 | check_unsupported_flags([], opts) | ||
|
r12730 | def display(other, chlist, displayer): | ||
|
r7716 | revdag = graphrevs(other, chlist, opts) | ||
|
r9368 | showparents = [ctx.node() for ctx in repo[None].parents()] | ||
|
r9371 | generate(ui, revdag, displayer, showparents, asciiedges) | ||
|
r7426 | |||
|
r12730 | hg._incoming(display, subreporecurse, ui, repo, source, opts, buffered=True) | ||
|
r7426 | |||
def uisetup(ui): | ||||
'''Initialize the extension.''' | ||||
_wrapcmd(ui, 'log', commands.table, graphlog) | ||||
_wrapcmd(ui, 'incoming', commands.table, gincoming) | ||||
_wrapcmd(ui, 'outgoing', commands.table, goutgoing) | ||||
def _wrapcmd(ui, cmd, table, wrapfn): | ||||
'''wrap the command''' | ||||
def graph(orig, *args, **kwargs): | ||||
if kwargs['graph']: | ||||
|
r14043 | return wrapfn(*args, **kwargs) | ||
|
r7426 | return orig(*args, **kwargs) | ||
entry = extensions.wrapcommand(table, cmd, graph) | ||||
|
r7763 | entry[1].append(('G', 'graph', None, _("show the revision DAG"))) | ||
|
r7426 | |||
|
r4344 | cmdtable = { | ||
"glog": | ||||
|
r4730 | (graphlog, | ||
|
r11321 | [('l', 'limit', '', | ||
_('limit number of changes displayed'), _('NUM')), | ||||
|
r4730 | ('p', 'patch', False, _('show patch')), | ||
|
r11321 | ('r', 'rev', [], | ||
_('show the specified revision or range'), _('REV')), | ||||
|
r6192 | ] + templateopts, | ||
|
r5942 | _('hg glog [OPTION]... [FILE]')), | ||
|
r4344 | } | ||