mercurial-scm/hg-stable: mercurial/graphmod.py comparison

comparison mercurial/graphmod.py @ 28600:0d6137891114

author	Martijn Pieters <mjpieters@fb.com>
date	Sat, 19 Mar 2016 16:46:15 -0700
parents	fa2cd0c9a567
children	cd10171d6c71

comparison

equal deleted inserted replaced

-:0e7a929754aa
+:0d6137891114
 CHANGESET = 'C'
 PARENT = 'P'
 GRANDPARENT = 'G'
 MISSINGPARENT = 'M'
+EDGES = {PARENT: '|', GRANDPARENT: '|', MISSINGPARENT: '|'}
 def groupbranchiter(revs, parentsfunc, firstbranch=()):
 """Yield revisions from heads to roots one (topo) branch at a time.
 This function aims to be used by a graph generator that wishes to minimize
 for ptype, parent in parents:
 if parent in seen:
 knownparents.append(parent)
 else:
 newparents.append(parent)
+state['edges'][parent] = state['styles'].get(ptype, '|')
 ncols = len(seen)
 nextseen = seen[:]
 nextseen[nodeidx:nodeidx + 1] = newparents
-edges = [(nodeidx, nextseen.index(p)) for p in knownparents if p != nullrev]
+edges = [(nodeidx, nextseen.index(p))
+for p in knownparents if p != nullrev]
 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
 edges.append((nodeidx, nodeidx))
 if len(newparents) > 1:
 edges.append((nodeidx, nodeidx + 1))
 nmorecols = len(nextseen) - ncols
 seen[:] = nextseen
+# remove current node from edge characters, no longer needed
+state['edges'].pop(rev, None)
 yield (type, char, lines, (nodeidx, edges, ncols, nmorecols))
 def _fixlongrightedges(edges):
 for (i, (start, end)) in enumerate(edges):
 if end > start:
 edges[i] = (start, end + 1)
 def _getnodelineedgestail(
-node_index, p_node_index, n_columns, n_columns_diff, p_diff, fix_tail):
+echars, idx, pidx, ncols, coldiff, pdiff, fix_tail):
-if fix_tail and n_columns_diff == p_diff and n_columns_diff != 0:
+if fix_tail and coldiff == pdiff and coldiff != 0:
 # Still going in the same non-vertical direction.
-if n_columns_diff == -1:
+if coldiff == -1:
-start = max(node_index + 1, p_node_index)
+start = max(idx + 1, pidx)
-tail = ["|", " "] * (start - node_index - 1)
+tail = echars[idx * 2:(start - 1) * 2]
-tail.extend(["/", " "] * (n_columns - start))
+tail.extend(["/", " "] * (ncols - start))
 return tail
 else:
-return ["\\", " "] * (n_columns - node_index - 1)
+return ["\\", " "] * (ncols - idx - 1)
 else:
-return ["|", " "] * (n_columns - node_index - 1)
+remainder = (ncols - idx - 1)
+return echars[-(remainder * 2):] if remainder > 0 else []
-def _drawedges(edges, nodeline, interline):
+def _drawedges(echars, 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] = "|"
+interline[2 * start] = echars[2 * start]
 else:
 if 2 * end >= len(nodeline):
 continue
 nodeline[2 * end] = "+"
 if start > end:
 (start, end) = (end, start)
 for i in range(2 * start + 1, 2 * end):
 if nodeline[i] != "+":
 nodeline[i] = "-"
-def _getpaddingline(ni, n_columns, edges):
+def _getpaddingline(echars, idx, ncols, edges):
-line = []
+# all edges up to the current node
-line.extend(["|", " "] * ni)
+line = echars[:idx * 2]
-if (ni, ni - 1) in edges or (ni, ni) in edges:
+# an edge for the current node, if there is one
-# (ni, ni - 1)      (ni, ni)
+if (idx, idx - 1) in edges or (idx, idx) in edges:
+# (idx, idx - 1)      (idx, idx)
 # | | | |           | | | |
 # +---o |           | o---+
-# | | c |           | c | |
+# | | X |           | X | |
 # | |/ /            | |/ /
 # | | |             | | |
-c = "|"
+line.extend(echars[idx * 2:(idx + 1) * 2])
 else:
-c = " "
+line.extend('  ')
-line.extend([c, " "])
+# all edges to the right of the current node
-line.extend(["|", " "] * (n_columns - ni - 1))
+remainder = ncols - idx - 1
+if remainder > 0:
+line.extend(echars[-(remainder * 2):])
 return line
 def asciistate():
 """returns the initial value for the "state" argument to ascii()"""
-return {'seen': [], 'lastcoldiff': 0, 'lastindex': 0}
+return {
+'seen': [],
+'edges': {},
+'lastcoldiff': 0,
+'lastindex': 0,
+'styles': EDGES.copy(),
+}
 def ascii(ui, state, type, char, text, coldata):
 """prints an ASCII graph of the DAG
 takes the following arguments (one call per node in the graph):
 - 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.
 """
 idx, edges, ncols, coldiff = coldata
 assert -2 < coldiff < 2
+edgemap, seen = state['edges'], state['seen']
+# Be tolerant of history issues; make sure we have at least ncols + coldiff
+# elements to work with. See test-glog.t for broken history test cases.
+echars = [c for p in seen for c in (edgemap.get(p, '|'), ' ')]
+echars.extend(('|', ' ') * max(ncols + coldiff - len(seen), 0))
 if coldiff == -1:
 # Transform
 #
 #     | | |        | | |
 #     o | |  into  o---+
 #     | |/ /           | |/ /
 #     o | |            o | |
 fix_nodeline_tail = len(text) <= 2 and not add_padding_line
 # nodeline is the line containing the node character (typically o)
-nodeline = ["|", " "] * idx
+nodeline = echars[:idx * 2]
 nodeline.extend([char, " "])
 nodeline.extend(
-_getnodelineedgestail(idx, state['lastindex'], ncols, coldiff,
+_getnodelineedgestail(
-state['lastcoldiff'], fix_nodeline_tail))
+echars, idx, state['lastindex'], ncols, coldiff,
+state['lastcoldiff'], fix_nodeline_tail))
 # shift_interline is the line containing the non-vertical
 # edges between this entry and the next
-shift_interline = ["|", " "] * idx
+shift_interline = echars[:idx * 2]
+shift_interline.extend(' ' * (2 + coldiff))
+count = ncols - idx - 1
 if coldiff == -1:
-n_spaces = 1
+shift_interline.extend('/ ' * count)
-edge_ch = "/"
 elif coldiff == 0:
-n_spaces = 2
+shift_interline.extend(echars[(idx + 1) * 2:ncols * 2])
-edge_ch = "|"
 else:
-n_spaces = 3
+shift_interline.extend(r'\ ' * count)
-edge_ch = "\\"
-shift_interline.extend(n_spaces * [" "])
-shift_interline.extend([edge_ch, " "] * (ncols - idx - 1))
 # draw edges from the current node to its parents
-_drawedges(edges, nodeline, shift_interline)
+_drawedges(echars, edges, nodeline, shift_interline)
 # lines is the list of all graph lines to print
 lines = [nodeline]
 if add_padding_line:
-lines.append(_getpaddingline(idx, ncols, edges))
+lines.append(_getpaddingline(echars, idx, ncols, edges))
 lines.append(shift_interline)
 # 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)
+extra_interline = echars[:(ncols + coldiff) * 2]
 while len(lines) < len(text):
 lines.append(extra_interline)
 # print lines
 indentation_level = max(ncols, ncols + coldiff)

Mercurial > public > mercurial-scm > hg-stable

comparison mercurial/graphmod.py @ 28600:0d6137891114