Mercurial > hg
annotate mercurial/dagparser.py @ 36439:02cd2fb6de72
narrow: drop redundant templatekw/revset names from help text
":<name>:" is automatically added by the registrar.
author | Yuya Nishihara <yuya@tcha.org> |
---|---|
date | Sun, 25 Feb 2018 13:42:51 +0900 |
parents | dfd009e5f9f2 |
children | f0b6fbea00cf |
rev | line source |
---|---|
11335
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
1 # dagparser.py - parser and generator for concise description of DAGs |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
2 # |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
3 # Copyright 2010 Peter Arrenbrecht <peter@arrenbrecht.ch> |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
4 # |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
5 # This software may be used and distributed according to the terms of the |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
6 # GNU General Public License version 2 or any later version. |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
7 |
25941
a75cda2dfc19
dagparser: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25170
diff
changeset
|
8 from __future__ import absolute_import |
a75cda2dfc19
dagparser: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25170
diff
changeset
|
9 |
a75cda2dfc19
dagparser: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25170
diff
changeset
|
10 import re |
a75cda2dfc19
dagparser: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25170
diff
changeset
|
11 import string |
a75cda2dfc19
dagparser: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25170
diff
changeset
|
12 |
a75cda2dfc19
dagparser: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25170
diff
changeset
|
13 from .i18n import _ |
34210
8927534cacbc
py3: drop use of str() in dagparser.py
Yuya Nishihara <yuya@tcha.org>
parents:
34209
diff
changeset
|
14 from . import ( |
8927534cacbc
py3: drop use of str() in dagparser.py
Yuya Nishihara <yuya@tcha.org>
parents:
34209
diff
changeset
|
15 error, |
34211
a48ad118c558
py3: wrap string constants in dagparser.py with bytestr()
Yuya Nishihara <yuya@tcha.org>
parents:
34210
diff
changeset
|
16 pycompat, |
34210
8927534cacbc
py3: drop use of str() in dagparser.py
Yuya Nishihara <yuya@tcha.org>
parents:
34209
diff
changeset
|
17 util, |
8927534cacbc
py3: drop use of str() in dagparser.py
Yuya Nishihara <yuya@tcha.org>
parents:
34209
diff
changeset
|
18 ) |
11335
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
19 |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
20 def parsedag(desc): |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
21 '''parses a DAG from a concise textual description; generates events |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
22 |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
23 "+n" is a linear run of n nodes based on the current default parent |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
24 "." is a single node based on the current default parent |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
25 "$" resets the default parent to -1 (implied at the start); |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
26 otherwise the default parent is always the last node created |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
27 "<p" sets the default parent to the backref p |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
28 "*p" is a fork at parent p, where p is a backref |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
29 "*p1/p2/.../pn" is a merge of parents p1..pn, where the pi are backrefs |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
30 "/p2/.../pn" is a merge of the preceding node and p2..pn |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
31 ":name" defines a label for the preceding node; labels can be redefined |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
32 "@text" emits an annotation event for text |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
33 "!command" emits an action event for the current node |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
34 "!!my command\n" is like "!", but to the end of the line |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
35 "#...\n" is a comment up to the end of the line |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
36 |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
37 Whitespace between the above elements is ignored. |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
38 |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
39 A backref is either |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
40 * a number n, which references the node curr-n, where curr is the current |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
41 node, or |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
42 * the name of a label you placed earlier using ":name", or |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
43 * empty to denote the default parent. |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
44 |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
45 All string valued-elements are either strictly alphanumeric, or must |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
46 be enclosed in double quotes ("..."), with "\" as escape character. |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
47 |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
48 Generates sequence of |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
49 |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
50 ('n', (id, [parentids])) for node creation |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
51 ('l', (id, labelname)) for labels on nodes |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
52 ('a', text) for annotations |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
53 ('c', command) for actions (!) |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
54 ('C', command) for line actions (!!) |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
55 |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
56 Examples |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
57 -------- |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
58 |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
59 Example of a complex graph (output not shown for brevity): |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
60 |
34131
0fa781320203
doctest: bulk-replace string literals with b'' for Python 3
Yuya Nishihara <yuya@tcha.org>
parents:
33716
diff
changeset
|
61 >>> len(list(parsedag(b""" |
11335
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
62 ... |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
63 ... +3 # 3 nodes in linear run |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
64 ... :forkhere # a label for the last of the 3 nodes from above |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
65 ... +5 # 5 more nodes on one branch |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
66 ... :mergethis # label again |
17500 | 67 ... <forkhere # set default parent to labeled fork node |
11335
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
68 ... +10 # 10 more nodes on a parallel branch |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
69 ... @stable # following nodes will be annotated as "stable" |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
70 ... +5 # 5 nodes in stable |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
71 ... !addfile # custom command; could trigger new file in next node |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
72 ... +2 # two more nodes |
17500 | 73 ... /mergethis # merge last node with labeled node |
11335
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
74 ... +4 # 4 more nodes descending from merge node |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
75 ... |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
76 ... """))) |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
77 34 |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
78 |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
79 Empty list: |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
80 |
34131
0fa781320203
doctest: bulk-replace string literals with b'' for Python 3
Yuya Nishihara <yuya@tcha.org>
parents:
33716
diff
changeset
|
81 >>> list(parsedag(b"")) |
11335
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
82 [] |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
83 |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
84 A simple linear run: |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
85 |
34131
0fa781320203
doctest: bulk-replace string literals with b'' for Python 3
Yuya Nishihara <yuya@tcha.org>
parents:
33716
diff
changeset
|
86 >>> list(parsedag(b"+3")) |
11335
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
87 [('n', (0, [-1])), ('n', (1, [0])), ('n', (2, [1]))] |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
88 |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
89 Some non-standard ways to define such runs: |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
90 |
34131
0fa781320203
doctest: bulk-replace string literals with b'' for Python 3
Yuya Nishihara <yuya@tcha.org>
parents:
33716
diff
changeset
|
91 >>> list(parsedag(b"+1+2")) |
11335
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
92 [('n', (0, [-1])), ('n', (1, [0])), ('n', (2, [1]))] |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
93 |
34131
0fa781320203
doctest: bulk-replace string literals with b'' for Python 3
Yuya Nishihara <yuya@tcha.org>
parents:
33716
diff
changeset
|
94 >>> list(parsedag(b"+1*1*")) |
11335
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
95 [('n', (0, [-1])), ('n', (1, [0])), ('n', (2, [1]))] |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
96 |
34131
0fa781320203
doctest: bulk-replace string literals with b'' for Python 3
Yuya Nishihara <yuya@tcha.org>
parents:
33716
diff
changeset
|
97 >>> list(parsedag(b"*")) |
11335
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
98 [('n', (0, [-1]))] |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
99 |
34131
0fa781320203
doctest: bulk-replace string literals with b'' for Python 3
Yuya Nishihara <yuya@tcha.org>
parents:
33716
diff
changeset
|
100 >>> list(parsedag(b"...")) |
11335
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
101 [('n', (0, [-1])), ('n', (1, [0])), ('n', (2, [1]))] |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
102 |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
103 A fork and a join, using numeric back references: |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
104 |
34131
0fa781320203
doctest: bulk-replace string literals with b'' for Python 3
Yuya Nishihara <yuya@tcha.org>
parents:
33716
diff
changeset
|
105 >>> list(parsedag(b"+2*2*/2")) |
11335
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
106 [('n', (0, [-1])), ('n', (1, [0])), ('n', (2, [0])), ('n', (3, [2, 1]))] |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
107 |
34131
0fa781320203
doctest: bulk-replace string literals with b'' for Python 3
Yuya Nishihara <yuya@tcha.org>
parents:
33716
diff
changeset
|
108 >>> list(parsedag(b"+2<2+1/2")) |
11335
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
109 [('n', (0, [-1])), ('n', (1, [0])), ('n', (2, [0])), ('n', (3, [2, 1]))] |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
110 |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
111 Placing a label: |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
112 |
34131
0fa781320203
doctest: bulk-replace string literals with b'' for Python 3
Yuya Nishihara <yuya@tcha.org>
parents:
33716
diff
changeset
|
113 >>> list(parsedag(b"+1 :mylabel +1")) |
11335
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
114 [('n', (0, [-1])), ('l', (0, 'mylabel')), ('n', (1, [0]))] |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
115 |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
116 An empty label (silly, really): |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
117 |
34131
0fa781320203
doctest: bulk-replace string literals with b'' for Python 3
Yuya Nishihara <yuya@tcha.org>
parents:
33716
diff
changeset
|
118 >>> list(parsedag(b"+1:+1")) |
11335
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
119 [('n', (0, [-1])), ('l', (0, '')), ('n', (1, [0]))] |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
120 |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
121 Fork and join, but with labels instead of numeric back references: |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
122 |
34131
0fa781320203
doctest: bulk-replace string literals with b'' for Python 3
Yuya Nishihara <yuya@tcha.org>
parents:
33716
diff
changeset
|
123 >>> list(parsedag(b"+1:f +1:p2 *f */p2")) |
11335
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
124 [('n', (0, [-1])), ('l', (0, 'f')), ('n', (1, [0])), ('l', (1, 'p2')), |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
125 ('n', (2, [0])), ('n', (3, [2, 1]))] |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
126 |
34131
0fa781320203
doctest: bulk-replace string literals with b'' for Python 3
Yuya Nishihara <yuya@tcha.org>
parents:
33716
diff
changeset
|
127 >>> list(parsedag(b"+1:f +1:p2 <f +1 /p2")) |
11335
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
128 [('n', (0, [-1])), ('l', (0, 'f')), ('n', (1, [0])), ('l', (1, 'p2')), |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
129 ('n', (2, [0])), ('n', (3, [2, 1]))] |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
130 |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
131 Restarting from the root: |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
132 |
34131
0fa781320203
doctest: bulk-replace string literals with b'' for Python 3
Yuya Nishihara <yuya@tcha.org>
parents:
33716
diff
changeset
|
133 >>> list(parsedag(b"+1 $ +1")) |
11335
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
134 [('n', (0, [-1])), ('n', (1, [-1]))] |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
135 |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
136 Annotations, which are meant to introduce sticky state for subsequent nodes: |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
137 |
34131
0fa781320203
doctest: bulk-replace string literals with b'' for Python 3
Yuya Nishihara <yuya@tcha.org>
parents:
33716
diff
changeset
|
138 >>> list(parsedag(b"+1 @ann +1")) |
11335
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
139 [('n', (0, [-1])), ('a', 'ann'), ('n', (1, [0]))] |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
140 |
34131
0fa781320203
doctest: bulk-replace string literals with b'' for Python 3
Yuya Nishihara <yuya@tcha.org>
parents:
33716
diff
changeset
|
141 >>> list(parsedag(b'+1 @"my annotation" +1')) |
11335
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
142 [('n', (0, [-1])), ('a', 'my annotation'), ('n', (1, [0]))] |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
143 |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
144 Commands, which are meant to operate on the most recently created node: |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
145 |
34131
0fa781320203
doctest: bulk-replace string literals with b'' for Python 3
Yuya Nishihara <yuya@tcha.org>
parents:
33716
diff
changeset
|
146 >>> list(parsedag(b"+1 !cmd +1")) |
11335
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
147 [('n', (0, [-1])), ('c', 'cmd'), ('n', (1, [0]))] |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
148 |
34131
0fa781320203
doctest: bulk-replace string literals with b'' for Python 3
Yuya Nishihara <yuya@tcha.org>
parents:
33716
diff
changeset
|
149 >>> list(parsedag(b'+1 !"my command" +1')) |
11335
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
150 [('n', (0, [-1])), ('c', 'my command'), ('n', (1, [0]))] |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
151 |
34131
0fa781320203
doctest: bulk-replace string literals with b'' for Python 3
Yuya Nishihara <yuya@tcha.org>
parents:
33716
diff
changeset
|
152 >>> list(parsedag(b'+1 !!my command line\\n +1')) |
11335
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
153 [('n', (0, [-1])), ('C', 'my command line'), ('n', (1, [0]))] |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
154 |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
155 Comments, which extend to the end of the line: |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
156 |
34131
0fa781320203
doctest: bulk-replace string literals with b'' for Python 3
Yuya Nishihara <yuya@tcha.org>
parents:
33716
diff
changeset
|
157 >>> list(parsedag(b'+1 # comment\\n+1')) |
11335
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
158 [('n', (0, [-1])), ('n', (1, [0]))] |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
159 |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
160 Error: |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
161 |
34131
0fa781320203
doctest: bulk-replace string literals with b'' for Python 3
Yuya Nishihara <yuya@tcha.org>
parents:
33716
diff
changeset
|
162 >>> try: list(parsedag(b'+1 bad')) |
34138
0f9936d80e01
doctest: upgrade old-style "except" clause
Yuya Nishihara <yuya@tcha.org>
parents:
34137
diff
changeset
|
163 ... except Exception as e: print(pycompat.sysstr(bytes(e))) |
11335
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
164 invalid character in dag description: bad... |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
165 |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
166 ''' |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
167 if not desc: |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
168 return |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
169 |
34211
a48ad118c558
py3: wrap string constants in dagparser.py with bytestr()
Yuya Nishihara <yuya@tcha.org>
parents:
34210
diff
changeset
|
170 wordchars = pycompat.bytestr(string.ascii_letters + string.digits) |
11335
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
171 |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
172 labels = {} |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
173 p1 = -1 |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
174 r = 0 |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
175 |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
176 def resolve(ref): |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
177 if not ref: |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
178 return p1 |
34211
a48ad118c558
py3: wrap string constants in dagparser.py with bytestr()
Yuya Nishihara <yuya@tcha.org>
parents:
34210
diff
changeset
|
179 elif ref[0] in pycompat.bytestr(string.digits): |
11335
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
180 return r - int(ref) |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
181 else: |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
182 return labels[ref] |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
183 |
34212
dfd009e5f9f2
py3: iterate bytes as a byte string in dagparser.py
Yuya Nishihara <yuya@tcha.org>
parents:
34211
diff
changeset
|
184 chiter = pycompat.iterbytestr(desc) |
11335
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
185 |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
186 def nextch(): |
25170
c69f4f7fe01a
dagparser: use 'next' instead of try/except for default value
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
17500
diff
changeset
|
187 return next(chiter, '\0') |
11335
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
188 |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
189 def nextrun(c, allow): |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
190 s = '' |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
191 while c in allow: |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
192 s += c |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
193 c = nextch() |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
194 return c, s |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
195 |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
196 def nextdelimited(c, limit, escape): |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
197 s = '' |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
198 while c != limit: |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
199 if c == escape: |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
200 c = nextch() |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
201 s += c |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
202 c = nextch() |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
203 return nextch(), s |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
204 |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
205 def nextstring(c): |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
206 if c == '"': |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
207 return nextdelimited(nextch(), '"', '\\') |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
208 else: |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
209 return nextrun(c, wordchars) |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
210 |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
211 c = nextch() |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
212 while c != '\0': |
34211
a48ad118c558
py3: wrap string constants in dagparser.py with bytestr()
Yuya Nishihara <yuya@tcha.org>
parents:
34210
diff
changeset
|
213 while c in pycompat.bytestr(string.whitespace): |
11335
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
214 c = nextch() |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
215 if c == '.': |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
216 yield 'n', (r, [p1]) |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
217 p1 = r |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
218 r += 1 |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
219 c = nextch() |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
220 elif c == '+': |
34211
a48ad118c558
py3: wrap string constants in dagparser.py with bytestr()
Yuya Nishihara <yuya@tcha.org>
parents:
34210
diff
changeset
|
221 c, digs = nextrun(nextch(), pycompat.bytestr(string.digits)) |
11335
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
222 n = int(digs) |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
223 for i in xrange(0, n): |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
224 yield 'n', (r, [p1]) |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
225 p1 = r |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
226 r += 1 |
12387
4f8067c94729
cleanup: use x in (a, b) instead of x == a or x == b
Brodie Rao <brodie@bitheap.org>
parents:
12134
diff
changeset
|
227 elif c in '*/': |
11335
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
228 if c == '*': |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
229 c = nextch() |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
230 c, pref = nextstring(c) |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
231 prefs = [pref] |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
232 while c == '/': |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
233 c, pref = nextstring(nextch()) |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
234 prefs.append(pref) |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
235 ps = [resolve(ref) for ref in prefs] |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
236 yield 'n', (r, ps) |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
237 p1 = r |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
238 r += 1 |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
239 elif c == '<': |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
240 c, ref = nextstring(nextch()) |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
241 p1 = resolve(ref) |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
242 elif c == ':': |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
243 c, name = nextstring(nextch()) |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
244 labels[name] = p1 |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
245 yield 'l', (p1, name) |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
246 elif c == '@': |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
247 c, text = nextstring(nextch()) |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
248 yield 'a', text |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
249 elif c == '!': |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
250 c = nextch() |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
251 if c == '!': |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
252 cmd = '' |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
253 c = nextch() |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
254 while c not in '\n\r\0': |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
255 cmd += c |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
256 c = nextch() |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
257 yield 'C', cmd |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
258 else: |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
259 c, cmd = nextstring(c) |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
260 yield 'c', cmd |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
261 elif c == '#': |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
262 while c not in '\n\r\0': |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
263 c = nextch() |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
264 elif c == '$': |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
265 p1 = -1 |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
266 c = nextch() |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
267 elif c == '\0': |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
268 return # in case it was preceded by whitespace |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
269 else: |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
270 s = '' |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
271 i = 0 |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
272 while c != '\0' and i < 10: |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
273 s += c |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
274 i += 1 |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
275 c = nextch() |
26587
56b2bcea2529
error: get Abort from 'error' instead of 'util'
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25941
diff
changeset
|
276 raise error.Abort(_('invalid character in dag description: ' |
16683 | 277 '%s...') % s) |
11335
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
278 |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
279 def dagtextlines(events, |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
280 addspaces=True, |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
281 wraplabels=False, |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
282 wrapannotations=False, |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
283 wrapcommands=False, |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
284 wrapnonlinear=False, |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
285 usedots=False, |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
286 maxlinewidth=70): |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
287 '''generates single lines for dagtext()''' |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
288 |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
289 def wrapstring(text): |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
290 if re.match("^[0-9a-z]*$", text): |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
291 return text |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
292 return '"' + text.replace('\\', '\\\\').replace('"', '\"') + '"' |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
293 |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
294 def gen(): |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
295 labels = {} |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
296 run = 0 |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
297 wantr = 0 |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
298 needroot = False |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
299 for kind, data in events: |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
300 if kind == 'n': |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
301 r, ps = data |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
302 |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
303 # sanity check |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
304 if r != wantr: |
26587
56b2bcea2529
error: get Abort from 'error' instead of 'util'
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25941
diff
changeset
|
305 raise error.Abort(_("expected id %i, got %i") % (wantr, r)) |
11335
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
306 if not ps: |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
307 ps = [-1] |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
308 else: |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
309 for p in ps: |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
310 if p >= r: |
26587
56b2bcea2529
error: get Abort from 'error' instead of 'util'
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25941
diff
changeset
|
311 raise error.Abort(_("parent id %i is larger than " |
12134
26d86a6cf2af
dagparser: translate and lowercase error messages
Martin Geisler <mg@aragost.com>
parents:
11879
diff
changeset
|
312 "current id %i") % (p, r)) |
11335
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
313 wantr += 1 |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
314 |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
315 # new root? |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
316 p1 = r - 1 |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
317 if len(ps) == 1 and ps[0] == -1: |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
318 if needroot: |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
319 if run: |
34210
8927534cacbc
py3: drop use of str() in dagparser.py
Yuya Nishihara <yuya@tcha.org>
parents:
34209
diff
changeset
|
320 yield '+%d' % run |
11335
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
321 run = 0 |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
322 if wrapnonlinear: |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
323 yield '\n' |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
324 yield '$' |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
325 p1 = -1 |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
326 else: |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
327 needroot = True |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
328 if len(ps) == 1 and ps[0] == p1: |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
329 if usedots: |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
330 yield "." |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
331 else: |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
332 run += 1 |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
333 else: |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
334 if run: |
34210
8927534cacbc
py3: drop use of str() in dagparser.py
Yuya Nishihara <yuya@tcha.org>
parents:
34209
diff
changeset
|
335 yield '+%d' % run |
11335
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
336 run = 0 |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
337 if wrapnonlinear: |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
338 yield '\n' |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
339 prefs = [] |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
340 for p in ps: |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
341 if p == p1: |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
342 prefs.append('') |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
343 elif p in labels: |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
344 prefs.append(labels[p]) |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
345 else: |
34210
8927534cacbc
py3: drop use of str() in dagparser.py
Yuya Nishihara <yuya@tcha.org>
parents:
34209
diff
changeset
|
346 prefs.append('%d' % (r - p)) |
11335
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
347 yield '*' + '/'.join(prefs) |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
348 else: |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
349 if run: |
34210
8927534cacbc
py3: drop use of str() in dagparser.py
Yuya Nishihara <yuya@tcha.org>
parents:
34209
diff
changeset
|
350 yield '+%d' % run |
11335
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
351 run = 0 |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
352 if kind == 'l': |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
353 rid, name = data |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
354 labels[rid] = name |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
355 yield ':' + name |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
356 if wraplabels: |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
357 yield '\n' |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
358 elif kind == 'c': |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
359 yield '!' + wrapstring(data) |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
360 if wrapcommands: |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
361 yield '\n' |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
362 elif kind == 'C': |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
363 yield '!!' + data |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
364 yield '\n' |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
365 elif kind == 'a': |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
366 if wrapannotations: |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
367 yield '\n' |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
368 yield '@' + wrapstring(data) |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
369 elif kind == '#': |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
370 yield '#' + data |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
371 yield '\n' |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
372 else: |
34210
8927534cacbc
py3: drop use of str() in dagparser.py
Yuya Nishihara <yuya@tcha.org>
parents:
34209
diff
changeset
|
373 raise error.Abort(_("invalid event type in dag: " |
8927534cacbc
py3: drop use of str() in dagparser.py
Yuya Nishihara <yuya@tcha.org>
parents:
34209
diff
changeset
|
374 "('%s', '%s')") |
8927534cacbc
py3: drop use of str() in dagparser.py
Yuya Nishihara <yuya@tcha.org>
parents:
34209
diff
changeset
|
375 % (util.escapestr(kind), |
8927534cacbc
py3: drop use of str() in dagparser.py
Yuya Nishihara <yuya@tcha.org>
parents:
34209
diff
changeset
|
376 util.escapestr(data))) |
11335
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
377 if run: |
34210
8927534cacbc
py3: drop use of str() in dagparser.py
Yuya Nishihara <yuya@tcha.org>
parents:
34209
diff
changeset
|
378 yield '+%d' % run |
11335
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
379 |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
380 line = '' |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
381 for part in gen(): |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
382 if part == '\n': |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
383 if line: |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
384 yield line |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
385 line = '' |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
386 else: |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
387 if len(line) + len(part) >= maxlinewidth: |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
388 yield line |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
389 line = '' |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
390 elif addspaces and line and part != '.': |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
391 line += ' ' |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
392 line += part |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
393 if line: |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
394 yield line |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
395 |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
396 def dagtext(dag, |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
397 addspaces=True, |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
398 wraplabels=False, |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
399 wrapannotations=False, |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
400 wrapcommands=False, |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
401 wrapnonlinear=False, |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
402 usedots=False, |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
403 maxlinewidth=70): |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
404 '''generates lines of a textual representation for a dag event stream |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
405 |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
406 events should generate what parsedag() does, so: |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
407 |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
408 ('n', (id, [parentids])) for node creation |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
409 ('l', (id, labelname)) for labels on nodes |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
410 ('a', text) for annotations |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
411 ('c', text) for commands |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
412 ('C', text) for line commands ('!!') |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
413 ('#', text) for comment lines |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
414 |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
415 Parent nodes must come before child nodes. |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
416 |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
417 Examples |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
418 -------- |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
419 |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
420 Linear run: |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
421 |
34131
0fa781320203
doctest: bulk-replace string literals with b'' for Python 3
Yuya Nishihara <yuya@tcha.org>
parents:
33716
diff
changeset
|
422 >>> dagtext([(b'n', (0, [-1])), (b'n', (1, [0]))]) |
11335
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
423 '+2' |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
424 |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
425 Two roots: |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
426 |
34131
0fa781320203
doctest: bulk-replace string literals with b'' for Python 3
Yuya Nishihara <yuya@tcha.org>
parents:
33716
diff
changeset
|
427 >>> dagtext([(b'n', (0, [-1])), (b'n', (1, [-1]))]) |
11335
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
428 '+1 $ +1' |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
429 |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
430 Fork and join: |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
431 |
34131
0fa781320203
doctest: bulk-replace string literals with b'' for Python 3
Yuya Nishihara <yuya@tcha.org>
parents:
33716
diff
changeset
|
432 >>> dagtext([(b'n', (0, [-1])), (b'n', (1, [0])), (b'n', (2, [0])), |
0fa781320203
doctest: bulk-replace string literals with b'' for Python 3
Yuya Nishihara <yuya@tcha.org>
parents:
33716
diff
changeset
|
433 ... (b'n', (3, [2, 1]))]) |
11335
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
434 '+2 *2 */2' |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
435 |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
436 Fork and join with labels: |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
437 |
34131
0fa781320203
doctest: bulk-replace string literals with b'' for Python 3
Yuya Nishihara <yuya@tcha.org>
parents:
33716
diff
changeset
|
438 >>> dagtext([(b'n', (0, [-1])), (b'l', (0, b'f')), (b'n', (1, [0])), |
0fa781320203
doctest: bulk-replace string literals with b'' for Python 3
Yuya Nishihara <yuya@tcha.org>
parents:
33716
diff
changeset
|
439 ... (b'l', (1, b'p2')), (b'n', (2, [0])), (b'n', (3, [2, 1]))]) |
11335
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
440 '+1 :f +1 :p2 *f */p2' |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
441 |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
442 Annotations: |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
443 |
34131
0fa781320203
doctest: bulk-replace string literals with b'' for Python 3
Yuya Nishihara <yuya@tcha.org>
parents:
33716
diff
changeset
|
444 >>> dagtext([(b'n', (0, [-1])), (b'a', b'ann'), (b'n', (1, [0]))]) |
11335
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
445 '+1 @ann +1' |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
446 |
34131
0fa781320203
doctest: bulk-replace string literals with b'' for Python 3
Yuya Nishihara <yuya@tcha.org>
parents:
33716
diff
changeset
|
447 >>> dagtext([(b'n', (0, [-1])), |
0fa781320203
doctest: bulk-replace string literals with b'' for Python 3
Yuya Nishihara <yuya@tcha.org>
parents:
33716
diff
changeset
|
448 ... (b'a', b'my annotation'), |
0fa781320203
doctest: bulk-replace string literals with b'' for Python 3
Yuya Nishihara <yuya@tcha.org>
parents:
33716
diff
changeset
|
449 ... (b'n', (1, [0]))]) |
11335
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
450 '+1 @"my annotation" +1' |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
451 |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
452 Commands: |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
453 |
34131
0fa781320203
doctest: bulk-replace string literals with b'' for Python 3
Yuya Nishihara <yuya@tcha.org>
parents:
33716
diff
changeset
|
454 >>> dagtext([(b'n', (0, [-1])), (b'c', b'cmd'), (b'n', (1, [0]))]) |
11335
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
455 '+1 !cmd +1' |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
456 |
34131
0fa781320203
doctest: bulk-replace string literals with b'' for Python 3
Yuya Nishihara <yuya@tcha.org>
parents:
33716
diff
changeset
|
457 >>> dagtext([(b'n', (0, [-1])), |
0fa781320203
doctest: bulk-replace string literals with b'' for Python 3
Yuya Nishihara <yuya@tcha.org>
parents:
33716
diff
changeset
|
458 ... (b'c', b'my command'), |
0fa781320203
doctest: bulk-replace string literals with b'' for Python 3
Yuya Nishihara <yuya@tcha.org>
parents:
33716
diff
changeset
|
459 ... (b'n', (1, [0]))]) |
11335
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
460 '+1 !"my command" +1' |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
461 |
34131
0fa781320203
doctest: bulk-replace string literals with b'' for Python 3
Yuya Nishihara <yuya@tcha.org>
parents:
33716
diff
changeset
|
462 >>> dagtext([(b'n', (0, [-1])), |
0fa781320203
doctest: bulk-replace string literals with b'' for Python 3
Yuya Nishihara <yuya@tcha.org>
parents:
33716
diff
changeset
|
463 ... (b'C', b'my command line'), |
0fa781320203
doctest: bulk-replace string literals with b'' for Python 3
Yuya Nishihara <yuya@tcha.org>
parents:
33716
diff
changeset
|
464 ... (b'n', (1, [0]))]) |
11335
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
465 '+1 !!my command line\\n+1' |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
466 |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
467 Comments: |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
468 |
34131
0fa781320203
doctest: bulk-replace string literals with b'' for Python 3
Yuya Nishihara <yuya@tcha.org>
parents:
33716
diff
changeset
|
469 >>> dagtext([(b'n', (0, [-1])), (b'#', b' comment'), (b'n', (1, [0]))]) |
11335
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
470 '+1 # comment\\n+1' |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
471 |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
472 >>> dagtext([]) |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
473 '' |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
474 |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
475 Combining parsedag and dagtext: |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
476 |
34131
0fa781320203
doctest: bulk-replace string literals with b'' for Python 3
Yuya Nishihara <yuya@tcha.org>
parents:
33716
diff
changeset
|
477 >>> dagtext(parsedag(b'+1 :f +1 :p2 *f */p2')) |
11335
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
478 '+1 :f +1 :p2 *f */p2' |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
479 |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
480 ''' |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
481 return "\n".join(dagtextlines(dag, |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
482 addspaces, |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
483 wraplabels, |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
484 wrapannotations, |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
485 wrapcommands, |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
486 wrapnonlinear, |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
487 usedots, |
3201ff1459dd
dagparser: parses and formats DAGs as concise text
Peter Arrenbrecht <peter.arrenbrecht@gmail.com>
parents:
diff
changeset
|
488 maxlinewidth)) |