mercurial: comparison mercurial/graphmod.py

equal deleted inserted replaced

-:2372284d9457
+:687b865b95ad
 pycompat,
 smartset,
 util,
 )
-CHANGESET = 'C'
+CHANGESET = b'C'
-PARENT = 'P'
+PARENT = b'P'
-GRANDPARENT = 'G'
+GRANDPARENT = b'G'
-MISSINGPARENT = 'M'
+MISSINGPARENT = b'M'
 # Style of line to draw. None signals a line that ends and is removed at this
 # point. A number prefix means only the last N characters of the current block
 # will use that style, the rest will use the PARENT style. Add a - sign
 # (so making N negative) and all but the first N characters use that style.
-EDGES = {PARENT: '|', GRANDPARENT: ':', MISSINGPARENT: None}
+EDGES = {PARENT: b'|', GRANDPARENT: b':', MISSINGPARENT: None}
 def dagwalker(repo, revs):
 """cset DAG generator yielding (id, CHANGESET, ctx, [parentinfo]) tuples
 seen = []
 colors = {}
 newcolor = 1
 config = {}
-for key, val in repo.ui.configitems('graph'):
+for key, val in repo.ui.configitems(b'graph'):
-if '.' in key:
+if b'.' in key:
-branch, setting = key.rsplit('.', 1)
+branch, setting = key.rsplit(b'.', 1)
 # Validation
-if setting == "width" and val.isdigit():
+if setting == b"width" and val.isdigit():
 config.setdefault(branch, {})[setting] = int(val)
-elif setting == "color" and val.isalnum():
+elif setting == b"color" and val.isalnum():
 config.setdefault(branch, {})[setting] = val
 if config:
 getconf = util.lrucachefunc(
 lambda rev: config.get(repo[rev].branch(), {})
 edges.append(
 (
 ecol,
 next.index(eid),
 colors[eid],
-bconf.get('width', -1),
+bconf.get(b'width', -1),
-bconf.get('color', ''),
+bconf.get(b'color', b''),
 )
 )
 elif eid == cur:
 for ptype, p in parents:
 bconf = getconf(p)
 edges.append(
 (
 ecol,
 next.index(p),
 color,
-bconf.get('width', -1),
+bconf.get(b'width', -1),
-bconf.get('color', ''),
+bconf.get(b'color', b''),
 )
 )
 # Yield and move on
 yield (cur, type, data, (col, color), edges)
 seen = next
 def asciiedges(type, char, state, rev, parents):
 """adds edge info to changelog DAG walk suitable for ascii()"""
-seen = state['seen']
+seen = state[b'seen']
 if rev not in seen:
 seen.append(rev)
 nodeidx = seen.index(rev)
 knownparents = []
 continue
 if parent in seen:
 knownparents.append(parent)
 else:
 newparents.append(parent)
-state['edges'][parent] = state['styles'].get(ptype, '|')
+state[b'edges'][parent] = state[b'styles'].get(ptype, b'|')
 ncols = len(seen)
 width = 1 + ncols * 2
 nextseen = seen[:]
 nextseen[nodeidx : nodeidx + 1] = newparents
 edges.append((nodeidx, nodeidx))
 edges.append((nodeidx, nodeidx + 1))
 nmorecols = 1
 width += 2
 yield (type, char, width, (nodeidx, edges, ncols, nmorecols))
-char = '\\'
+char = b'\\'
 nodeidx += 1
 ncols += 1
 edges = []
 del newparents[0]
 edges.append((nodeidx, nodeidx + 1))
 nmorecols = len(nextseen) - ncols
 if nmorecols > 0:
 width += 2
 # remove current node from edge characters, no longer needed
-state['edges'].pop(rev, None)
+state[b'edges'].pop(rev, None)
 yield (type, char, width, (nodeidx, edges, ncols, nmorecols))
 def _fixlongrightedges(edges):
 for (i, (start, end)) in enumerate(edges):
 if fix_tail and coldiff == pdiff and coldiff != 0:
 # Still going in the same non-vertical direction.
 if coldiff == -1:
 start = max(idx + 1, pidx)
 tail = echars[idx * 2 : (start - 1) * 2]
-tail.extend(["/", " "] * (ncols - start))
+tail.extend([b"/", b" "] * (ncols - start))
 return tail
 else:
-return ["\\", " "] * (ncols - idx - 1)
+return [b"\\", b" "] * (ncols - idx - 1)
 else:
 remainder = ncols - idx - 1
 return echars[-(remainder * 2) :] if remainder > 0 else []
 def _drawedges(echars, edges, nodeline, interline):
 for (start, end) in edges:
 if start == end + 1:
-interline[2 * end + 1] = "/"
+interline[2 * end + 1] = b"/"
 elif start == end - 1:
-interline[2 * start + 1] = "\\"
+interline[2 * start + 1] = b"\\"
 elif start == end:
 interline[2 * start] = echars[2 * start]
 else:
 if 2 * end >= len(nodeline):
 continue
-nodeline[2 * end] = "+"
+nodeline[2 * end] = b"+"
 if start > end:
 (start, end) = (end, start)
 for i in range(2 * start + 1, 2 * end):
-if nodeline[i] != "+":
+if nodeline[i] != b"+":
-nodeline[i] = "-"
+nodeline[i] = b"-"
 def _getpaddingline(echars, idx, ncols, edges):
 # all edges up to the current node
 line = echars[: idx * 2]
 # | | X |           | X | |
 # | |/ /            | |/ /
 # | | |             | | |
 line.extend(echars[idx * 2 : (idx + 1) * 2])
 else:
-line.extend([' ', ' '])
+line.extend([b' ', b' '])
 # all edges to the right of the current node
 remainder = ncols - idx - 1
 if remainder > 0:
 line.extend(echars[-(remainder * 2) :])
 return line
 # We need enough space to draw adjustment lines for these.
 edgechars = extra[::2]
 while edgechars and edgechars[-1] is None:
 edgechars.pop()
 shift_size = max((edgechars.count(None) * 2) - 1, 0)
-minlines = 3 if not state['graphshorten'] else 2
+minlines = 3 if not state[b'graphshorten'] else 2
 while len(lines) < minlines + shift_size:
 lines.append(extra[:])
 if shift_size:
 empties = []
 else:
 toshift.append(i * 2)
 targets = list(range(first_empty, first_empty + len(toshift) * 2, 2))
 positions = toshift[:]
 for line in lines[-shift_size:]:
-line[first_empty:] = [' '] * (len(line) - first_empty)
+line[first_empty:] = [b' '] * (len(line) - first_empty)
 for i in range(len(positions)):
 pos = positions[i] - 1
 positions[i] = max(pos, targets[i])
-line[pos] = '/' if pos > targets[i] else extra[toshift[i]]
+line[pos] = b'/' if pos > targets[i] else extra[toshift[i]]
-map = {1: '|', 2: '~'} if not state['graphshorten'] else {1: '~'}
+map = {1: b'|', 2: b'~'} if not state[b'graphshorten'] else {1: b'~'}
 for i, line in enumerate(lines):
 if None not in line:
 continue
-line[:] = [c or map.get(i, ' ') for c in line]
+line[:] = [c or map.get(i, b' ') for c in line]
 # remove edges that ended
 remove = [p for p, c in edgemap.items() if c is None]
 for parent in remove:
 del edgemap[parent]
 def asciistate():
 """returns the initial value for the "state" argument to ascii()"""
 return {
-'seen': [],
+b'seen': [],
-'edges': {},
+b'edges': {},
-'lastcoldiff': 0,
+b'lastcoldiff': 0,
-'lastindex': 0,
+b'lastindex': 0,
-'styles': EDGES.copy(),
+b'styles': EDGES.copy(),
-'graphshorten': False,
+b'graphshorten': False,
 }
 def outputgraph(ui, graph):
 """outputs an ASCII graph of a DAG
 this function can be monkey-patched by extensions to alter graph display
 without needing to mimic all of the edge-fixup logic in ascii()
 """
 for (ln, logstr) in graph:
-ui.write((ln + logstr).rstrip() + "\n")
+ui.write((ln + logstr).rstrip() + b"\n")
 def ascii(ui, state, type, char, text, coldata):
 """prints an ASCII graph of the DAG
 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']
+edgemap, seen = state[b'edges'], state[b'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 = [c for p in seen for c in (edgemap.get(p, b'|'), b' ')]
-echars.extend(('|', ' ') * max(ncols + coldiff - len(seen), 0))
+echars.extend((b'|', b' ') * max(ncols + coldiff - len(seen), 0))
 if coldiff == -1:
 # Transform
 #
 #     | | |        | | |
 #     o | |            o | |
 fix_nodeline_tail = len(text) <= 2 and not add_padding_line
 # nodeline is the line containing the node character (typically o)
 nodeline = echars[: idx * 2]
-nodeline.extend([char, " "])
+nodeline.extend([char, b" "])
 nodeline.extend(
 _getnodelineedgestail(
 echars,
 idx,
-state['lastindex'],
+state[b'lastindex'],
 ncols,
 coldiff,
-state['lastcoldiff'],
+state[b'lastcoldiff'],
 fix_nodeline_tail,
 )
 )
 # shift_interline is the line containing the non-vertical
 # edges between this entry and the next
 shift_interline = echars[: idx * 2]
 for i in pycompat.xrange(2 + coldiff):
-shift_interline.append(' ')
+shift_interline.append(b' ')
 count = ncols - idx - 1
 if coldiff == -1:
 for i in pycompat.xrange(count):
-shift_interline.extend(['/', ' '])
+shift_interline.extend([b'/', b' '])
 elif coldiff == 0:
 shift_interline.extend(echars[(idx + 1) * 2 : ncols * 2])
 else:
 for i in pycompat.xrange(count):
-shift_interline.extend(['\\', ' '])
+shift_interline.extend([b'\\', b' '])
 # draw edges from the current node to its parents
 _drawedges(echars, edges, nodeline, shift_interline)
 # lines is the list of all graph lines to print
 if add_padding_line:
 lines.append(_getpaddingline(echars, idx, ncols, edges))
 # If 'graphshorten' config, only draw shift_interline
 # when there is any non vertical flow in graph.
-if state['graphshorten']:
+if state[b'graphshorten']:
 if any(c in br'\/' for c in shift_interline if c):
 lines.append(shift_interline)
 # Else, no 'graphshorten' config so draw shift_interline.
 else:
 lines.append(shift_interline)
 lines.append(extra_interline[:])
 _drawendinglines(lines, extra_interline, edgemap, seen, state)
 while len(text) < len(lines):
-text.append("")
+text.append(b"")
 # print lines
 indentation_level = max(ncols, ncols + coldiff)
-lines = ["%-*s " % (2 * indentation_level, "".join(line)) for line in lines]
+lines = [
+b"%-*s " % (2 * indentation_level, b"".join(line)) for line in lines
+]
 outputgraph(ui, zip(lines, text))
 # ... and start over
-state['lastcoldiff'] = coldiff
+state[b'lastcoldiff'] = coldiff
-state['lastindex'] = idx
+state[b'lastindex'] = idx

changeset 43077	687b865b95ad
parent 43076	2372284d9457
child 43776	faa8a59f4a06