1 | #!/usr/bin/env python
|
---|
2 |
|
---|
3 | # Copyright (c) 2012 Google Inc. All rights reserved.
|
---|
4 | # Use of this source code is governed by a BSD-style license that can be
|
---|
5 | # found in the LICENSE file.
|
---|
6 |
|
---|
7 | """Pretty-prints the contents of a GYP file."""
|
---|
8 |
|
---|
9 | from __future__ import print_function
|
---|
10 |
|
---|
11 | import sys
|
---|
12 | import re
|
---|
13 |
|
---|
14 |
|
---|
15 | # Regex to remove comments when we're counting braces.
|
---|
16 | COMMENT_RE = re.compile(r"\s*#.*")
|
---|
17 |
|
---|
18 | # Regex to remove quoted strings when we're counting braces.
|
---|
19 | # It takes into account quoted quotes, and makes sure that the quotes match.
|
---|
20 | # NOTE: It does not handle quotes that span more than one line, or
|
---|
21 | # cases where an escaped quote is preceded by an escaped backslash.
|
---|
22 | QUOTE_RE_STR = r'(?P<q>[\'"])(.*?)(?<![^\\][\\])(?P=q)'
|
---|
23 | QUOTE_RE = re.compile(QUOTE_RE_STR)
|
---|
24 |
|
---|
25 |
|
---|
26 | def comment_replace(matchobj):
|
---|
27 | return matchobj.group(1) + matchobj.group(2) + "#" * len(matchobj.group(3))
|
---|
28 |
|
---|
29 |
|
---|
30 | def mask_comments(input):
|
---|
31 | """Mask the quoted strings so we skip braces inside quoted strings."""
|
---|
32 | search_re = re.compile(r"(.*?)(#)(.*)")
|
---|
33 | return [search_re.sub(comment_replace, line) for line in input]
|
---|
34 |
|
---|
35 |
|
---|
36 | def quote_replace(matchobj):
|
---|
37 | return "%s%s%s%s" % (
|
---|
38 | matchobj.group(1),
|
---|
39 | matchobj.group(2),
|
---|
40 | "x" * len(matchobj.group(3)),
|
---|
41 | matchobj.group(2),
|
---|
42 | )
|
---|
43 |
|
---|
44 |
|
---|
45 | def mask_quotes(input):
|
---|
46 | """Mask the quoted strings so we skip braces inside quoted strings."""
|
---|
47 | search_re = re.compile(r"(.*?)" + QUOTE_RE_STR)
|
---|
48 | return [search_re.sub(quote_replace, line) for line in input]
|
---|
49 |
|
---|
50 |
|
---|
51 | def do_split(input, masked_input, search_re):
|
---|
52 | output = []
|
---|
53 | mask_output = []
|
---|
54 | for (line, masked_line) in zip(input, masked_input):
|
---|
55 | m = search_re.match(masked_line)
|
---|
56 | while m:
|
---|
57 | split = len(m.group(1))
|
---|
58 | line = line[:split] + r"\n" + line[split:]
|
---|
59 | masked_line = masked_line[:split] + r"\n" + masked_line[split:]
|
---|
60 | m = search_re.match(masked_line)
|
---|
61 | output.extend(line.split(r"\n"))
|
---|
62 | mask_output.extend(masked_line.split(r"\n"))
|
---|
63 | return (output, mask_output)
|
---|
64 |
|
---|
65 |
|
---|
66 | def split_double_braces(input):
|
---|
67 | """Masks out the quotes and comments, and then splits appropriate
|
---|
68 | lines (lines that matche the double_*_brace re's above) before
|
---|
69 | indenting them below.
|
---|
70 |
|
---|
71 | These are used to split lines which have multiple braces on them, so
|
---|
72 | that the indentation looks prettier when all laid out (e.g. closing
|
---|
73 | braces make a nice diagonal line).
|
---|
74 | """
|
---|
75 | double_open_brace_re = re.compile(r"(.*?[\[\{\(,])(\s*)([\[\{\(])")
|
---|
76 | double_close_brace_re = re.compile(r"(.*?[\]\}\)],?)(\s*)([\]\}\)])")
|
---|
77 |
|
---|
78 | masked_input = mask_quotes(input)
|
---|
79 | masked_input = mask_comments(masked_input)
|
---|
80 |
|
---|
81 | (output, mask_output) = do_split(input, masked_input, double_open_brace_re)
|
---|
82 | (output, mask_output) = do_split(output, mask_output, double_close_brace_re)
|
---|
83 |
|
---|
84 | return output
|
---|
85 |
|
---|
86 |
|
---|
87 | def count_braces(line):
|
---|
88 | """keeps track of the number of braces on a given line and returns the result.
|
---|
89 |
|
---|
90 | It starts at zero and subtracts for closed braces, and adds for open braces.
|
---|
91 | """
|
---|
92 | open_braces = ["[", "(", "{"]
|
---|
93 | close_braces = ["]", ")", "}"]
|
---|
94 | closing_prefix_re = re.compile(r"(.*?[^\s\]\}\)]+.*?)([\]\}\)],?)\s*$")
|
---|
95 | cnt = 0
|
---|
96 | stripline = COMMENT_RE.sub(r"", line)
|
---|
97 | stripline = QUOTE_RE.sub(r"''", stripline)
|
---|
98 | for char in stripline:
|
---|
99 | for brace in open_braces:
|
---|
100 | if char == brace:
|
---|
101 | cnt += 1
|
---|
102 | for brace in close_braces:
|
---|
103 | if char == brace:
|
---|
104 | cnt -= 1
|
---|
105 |
|
---|
106 | after = False
|
---|
107 | if cnt > 0:
|
---|
108 | after = True
|
---|
109 |
|
---|
110 | # This catches the special case of a closing brace having something
|
---|
111 | # other than just whitespace ahead of it -- we don't want to
|
---|
112 | # unindent that until after this line is printed so it stays with
|
---|
113 | # the previous indentation level.
|
---|
114 | if cnt < 0 and closing_prefix_re.match(stripline):
|
---|
115 | after = True
|
---|
116 | return (cnt, after)
|
---|
117 |
|
---|
118 |
|
---|
119 | def prettyprint_input(lines):
|
---|
120 | """Does the main work of indenting the input based on the brace counts."""
|
---|
121 | indent = 0
|
---|
122 | basic_offset = 2
|
---|
123 | for line in lines:
|
---|
124 | if COMMENT_RE.match(line):
|
---|
125 | print(line)
|
---|
126 | else:
|
---|
127 | line = line.strip("\r\n\t ") # Otherwise doesn't strip \r on Unix.
|
---|
128 | if len(line) > 0:
|
---|
129 | (brace_diff, after) = count_braces(line)
|
---|
130 | if brace_diff != 0:
|
---|
131 | if after:
|
---|
132 | print(" " * (basic_offset * indent) + line)
|
---|
133 | indent += brace_diff
|
---|
134 | else:
|
---|
135 | indent += brace_diff
|
---|
136 | print(" " * (basic_offset * indent) + line)
|
---|
137 | else:
|
---|
138 | print(" " * (basic_offset * indent) + line)
|
---|
139 | else:
|
---|
140 | print("")
|
---|
141 |
|
---|
142 |
|
---|
143 | def main():
|
---|
144 | if len(sys.argv) > 1:
|
---|
145 | data = open(sys.argv[1]).read().splitlines()
|
---|
146 | else:
|
---|
147 | data = sys.stdin.read().splitlines()
|
---|
148 | # Split up the double braces.
|
---|
149 | lines = split_double_braces(data)
|
---|
150 |
|
---|
151 | # Indent and print the output.
|
---|
152 | prettyprint_input(lines)
|
---|
153 | return 0
|
---|
154 |
|
---|
155 |
|
---|
156 | if __name__ == "__main__":
|
---|
157 | sys.exit(main())
|
---|