Debian Codegraph @

cross-project-tests/debuginfo-tests/dexter/dex/utils/PrettyOutputBase.py

raw
1 # DExTer : Debugging Experience Tester
2 # ~~~~~~ ~ ~~ ~ ~~
3 #
4 # Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
5 # See https://llvm.org/LICENSE.txt for license information.
6 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7 """Provides formatted/colored console output on both Windows and Linux.
8
9 Do not use this module directly, but instead use via the appropriate platform-
10 specific module.
11 """
12
13 import abc
14 import re
15 import sys
16 import threading
17 import unittest
18
19 from io import StringIO
20
21 from dex.utils.Exceptions import Error
22
23
24 class _NullLock(object):
25 def __enter__(self):
26 return None
27
28 def __exit__(self, *params):
29 pass
30
31
32 _lock = threading.Lock()
33 _null_lock = _NullLock()
34
35
36 class PreserveAutoColors(object):
37 def __init__(self, pretty_output):
38 self.pretty_output = pretty_output
39 self.orig_values = {}
40 self.properties = ["auto_reds", "auto_yellows", "auto_greens", "auto_blues"]
41
42 def __enter__(self):
43 for p in self.properties:
44 self.orig_values[p] = getattr(self.pretty_output, p)[:]
45 return self
46
47 def __exit__(self, *args):
48 for p in self.properties:
49 setattr(self.pretty_output, p, self.orig_values[p])
50
51
52 class Stream(object):
53 def __init__(self, py_, os_=None):
54 self.py = py_
55 self.os = os_
56 self.orig_color = None
57 self.color_enabled = self.py.isatty()
58
59
60 class PrettyOutputBase(object, metaclass=abc.ABCMeta):
61 stdout = Stream(sys.stdout)
62 stderr = Stream(sys.stderr)
63
64 def __init__(self):
65 self.auto_reds = []
66 self.auto_yellows = []
67 self.auto_greens = []
68 self.auto_blues = []
69 self._stack = []
70
71 def __enter__(self):
72 return self
73
74 def __exit__(self, *args):
75 pass
76
77 def _set_valid_stream(self, stream):
78 if stream is None:
79 return self.__class__.stdout
80 return stream
81
82 def _write(self, text, stream):
83 text = str(text)
84
85 # Users can embed color control tags in their output
86 # (e.g. <r>hello</> <y>world</> would write the word 'hello' in red and
87 # 'world' in yellow).
88 # This function parses these tags using a very simple recursive
89 # descent.
90 colors = {
91 "r": self.red,
92 "y": self.yellow,
93 "g": self.green,
94 "b": self.blue,
95 "d": self.default,
96 "a": self.auto,
97 }
98
99 # Find all tags (whether open or close)
100 tags = [t for t in re.finditer("<([{}/])>".format("".join(colors)), text)]
101
102 if not tags:
103 # No tags. Just write the text to the current stream and return.
104 # 'unmangling' any tags that have been mangled so that they won't
105 # render as colors (for example in error output from this
106 # function).
107 stream = self._set_valid_stream(stream)
108 stream.py.write(text.replace(r"\>", ">"))
109 return
110
111 open_tags = [i for i in tags if i.group(1) != "/"]
112 close_tags = [i for i in tags if i.group(1) == "/"]
113
114 if len(open_tags) != len(close_tags) or any(
115 o.start() >= c.start() for (o, c) in zip(open_tags, close_tags)
116 ):
117 raise Error(
118 'open/close tag mismatch in "{}"'.format(text.rstrip()).replace(
119 ">", r"\>"
120 )
121 )
122
123 open_tag = open_tags.pop(0)
124
125 # We know that the tags balance correctly, so figure out where the
126 # corresponding close tag is to the current open tag.
127 tag_nesting = 1
128 close_tag = None
129 for tag in tags[1:]:
130 if tag.group(1) == "/":
131 tag_nesting -= 1
132 else:
133 tag_nesting += 1
134 if tag_nesting == 0:
135 close_tag = tag
136 break
137 else:
138 assert False, text
139
140 # Use the method on the top of the stack for text prior to the open
141 # tag.
142 before = text[: open_tag.start()]
143 if before:
144 self._stack[-1](before, lock=_null_lock, stream=stream)
145
146 # Use the specified color for the tag itself.
147 color = open_tag.group(1)
148 within = text[open_tag.end() : close_tag.start()]
149 if within:
150 colors[color](within, lock=_null_lock, stream=stream)
151
152 # Use the method on the top of the stack for text after the close tag.
153 after = text[close_tag.end() :]
154 if after:
155 self._stack[-1](after, lock=_null_lock, stream=stream)
156
157 def flush(self, stream):
158 stream = self._set_valid_stream(stream)
159 stream.py.flush()
160
161 def auto(self, text, stream=None, lock=_lock):
162 text = str(text)
163 stream = self._set_valid_stream(stream)
164 lines = text.splitlines(True)
165
166 with lock:
167 for line in lines:
168 # This is just being cute for the sake of cuteness, but why
169 # not?
170 line = line.replace("DExTer", "<r>D<y>E<g>x<b>T</></>e</>r</>")
171
172 # Apply the appropriate color method if the expression matches
173 # any of
174 # the patterns we have set up.
175 for fn, regexs in (
176 (self.red, self.auto_reds),
177 (self.yellow, self.auto_yellows),
178 (self.green, self.auto_greens),
179 (self.blue, self.auto_blues),
180 ):
181 if any(re.search(regex, line) for regex in regexs):
182 fn(line, stream=stream, lock=_null_lock)
183 break
184 else:
185 self.default(line, stream=stream, lock=_null_lock)
186
187 def _call_color_impl(self, fn, impl, text, *args, **kwargs):
188 try:
189 self._stack.append(fn)
190 return impl(text, *args, **kwargs)
191 finally:
192 fn = self._stack.pop()
193
194 @abc.abstractmethod
195 def red_impl(self, text, stream=None, **kwargs):
196 pass
197
198 def red(self, *args, **kwargs):
199 return self._call_color_impl(self.red, self.red_impl, *args, **kwargs)
200
201 @abc.abstractmethod
202 def yellow_impl(self, text, stream=None, **kwargs):
203 pass
204
205 def yellow(self, *args, **kwargs):
206 return self._call_color_impl(self.yellow, self.yellow_impl, *args, **kwargs)
207
208 @abc.abstractmethod
209 def green_impl(self, text, stream=None, **kwargs):
210 pass
211
212 def green(self, *args, **kwargs):
213 return self._call_color_impl(self.green, self.green_impl, *args, **kwargs)
214
215 @abc.abstractmethod
216 def blue_impl(self, text, stream=None, **kwargs):
217 pass
218
219 def blue(self, *args, **kwargs):
220 return self._call_color_impl(self.blue, self.blue_impl, *args, **kwargs)
221
222 @abc.abstractmethod
223 def default_impl(self, text, stream=None, **kwargs):
224 pass
225
226 def default(self, *args, **kwargs):
227 return self._call_color_impl(self.default, self.default_impl, *args, **kwargs)
228
229 def colortest(self):
230 from itertools import combinations, permutations
231
232 fns = (
233 (self.red, "rrr"),
234 (self.yellow, "yyy"),
235 (self.green, "ggg"),
236 (self.blue, "bbb"),
237 (self.default, "ddd"),
238 )
239
240 for l in range(1, len(fns) + 1):
241 for comb in combinations(fns, l):
242 for perm in permutations(comb):
243 for stream in (None, self.__class__.stderr):
244 perm[0][0]("stdout " if stream is None else "stderr ", stream)
245 for fn, string in perm:
246 fn(string, stream)
247 self.default("\n", stream)
248
249 tests = [
250 (self.auto, "default1<r>red2</>default3"),
251 (self.red, "red1<r>red2</>red3"),
252 (self.blue, "blue1<r>red2</>blue3"),
253 (self.red, "red1<y>yellow2</>red3"),
254 (self.auto, "default1<y>yellow2<r>red3</></>"),
255 (self.auto, "default1<g>green2<r>red3</></>"),
256 (self.auto, "default1<g>green2<r>red3</>green4</>default5"),
257 (self.auto, "default1<g>green2</>default3<g>green4</>default5"),
258 (self.auto, "<r>red1<g>green2</>red3<g>green4</>red5</>"),
259 (self.auto, "<r>red1<y><g>green2</>yellow3</>green4</>default5"),
260 (self.auto, "<r><y><g><b><d>default1</></><r></></></>red2</>"),
261 (self.auto, "<r>red1</>default2<r>red3</><g>green4</>default5"),
262 (self.blue, "<r>red1</>blue2<r><r>red3</><g><g>green</></></>"),
263 (self.blue, "<r>r<r>r<y>y<r><r><r><r>r</></></></></></></>b"),
264 ]
265
266 for fn, text in tests:
267 for stream in (None, self.__class__.stderr):
268 stream_name = "stdout" if stream is None else "stderr"
269 fn("{} {}\n".format(stream_name, text), stream)
270
271
272 class TestPrettyOutput(unittest.TestCase):
273 class MockPrettyOutput(PrettyOutputBase):
274 def red_impl(self, text, stream=None, **kwargs):
275 self._write("[R]{}[/R]".format(text), stream)
276
277 def yellow_impl(self, text, stream=None, **kwargs):
278 self._write("[Y]{}[/Y]".format(text), stream)
279
280 def green_impl(self, text, stream=None, **kwargs):
281 self._write("[G]{}[/G]".format(text), stream)
282
283 def blue_impl(self, text, stream=None, **kwargs):
284 self._write("[B]{}[/B]".format(text), stream)
285
286 def default_impl(self, text, stream=None, **kwargs):
287 self._write("[D]{}[/D]".format(text), stream)
288
289 def test_red(self):
290 with TestPrettyOutput.MockPrettyOutput() as o:
291 stream = Stream(StringIO())
292 o.red("hello", stream)
293 self.assertEqual(stream.py.getvalue(), "[R]hello[/R]")
294
295 def test_yellow(self):
296 with TestPrettyOutput.MockPrettyOutput() as o:
297 stream = Stream(StringIO())
298 o.yellow("hello", stream)
299 self.assertEqual(stream.py.getvalue(), "[Y]hello[/Y]")
300
301 def test_green(self):
302 with TestPrettyOutput.MockPrettyOutput() as o:
303 stream = Stream(StringIO())
304 o.green("hello", stream)
305 self.assertEqual(stream.py.getvalue(), "[G]hello[/G]")
306
307 def test_blue(self):
308 with TestPrettyOutput.MockPrettyOutput() as o:
309 stream = Stream(StringIO())
310 o.blue("hello", stream)
311 self.assertEqual(stream.py.getvalue(), "[B]hello[/B]")
312
313 def test_default(self):
314 with TestPrettyOutput.MockPrettyOutput() as o:
315 stream = Stream(StringIO())
316 o.default("hello", stream)
317 self.assertEqual(stream.py.getvalue(), "[D]hello[/D]")
318
319 def test_auto(self):
320 with TestPrettyOutput.MockPrettyOutput() as o:
321 stream = Stream(StringIO())
322 o.auto_reds.append("foo")
323 o.auto("bar\n", stream)
324 o.auto("foo\n", stream)
325 o.auto("baz\n", stream)
326 self.assertEqual(
327 stream.py.getvalue(), "[D]bar\n[/D][R]foo\n[/R][D]baz\n[/D]"
328 )
329
330 stream = Stream(StringIO())
331 o.auto("bar\nfoo\nbaz\n", stream)
332 self.assertEqual(
333 stream.py.getvalue(), "[D]bar\n[/D][R]foo\n[/R][D]baz\n[/D]"
334 )
335
336 stream = Stream(StringIO())
337 o.auto("barfoobaz\nbardoobaz\n", stream)
338 self.assertEqual(
339 stream.py.getvalue(), "[R]barfoobaz\n[/R][D]bardoobaz\n[/D]"
340 )
341
342 o.auto_greens.append("doo")
343 stream = Stream(StringIO())
344 o.auto("barfoobaz\nbardoobaz\n", stream)
345 self.assertEqual(
346 stream.py.getvalue(), "[R]barfoobaz\n[/R][G]bardoobaz\n[/G]"
347 )
348
349 def test_PreserveAutoColors(self):
350 with TestPrettyOutput.MockPrettyOutput() as o:
351 o.auto_reds.append("foo")
352 with PreserveAutoColors(o):
353 o.auto_greens.append("bar")
354 stream = Stream(StringIO())
355 o.auto("foo\nbar\nbaz\n", stream)
356 self.assertEqual(
357 stream.py.getvalue(), "[R]foo\n[/R][G]bar\n[/G][D]baz\n[/D]"
358 )
359
360 stream = Stream(StringIO())
361 o.auto("foo\nbar\nbaz\n", stream)
362 self.assertEqual(
363 stream.py.getvalue(), "[R]foo\n[/R][D]bar\n[/D][D]baz\n[/D]"
364 )
365
366 stream = Stream(StringIO())
367 o.yellow("<a>foo</>bar<a>baz</>", stream)
368 self.assertEqual(
369 stream.py.getvalue(),
370 "[Y][Y][/Y][R]foo[/R][Y][Y]bar[/Y][D]baz[/D][Y][/Y][/Y][/Y]",
371 )
372
373 def test_tags(self):
374 with TestPrettyOutput.MockPrettyOutput() as o:
375 stream = Stream(StringIO())
376 o.auto("<r>hi</>", stream)
377 self.assertEqual(stream.py.getvalue(), "[D][D][/D][R]hi[/R][D][/D][/D]")
378
379 stream = Stream(StringIO())
380 o.auto("<r><y>a</>b</>c", stream)
381 self.assertEqual(
382 stream.py.getvalue(),
383 "[D][D][/D][R][R][/R][Y]a[/Y][R]b[/R][/R][D]c[/D][/D]",
384 )
385
386 with self.assertRaisesRegex(Error, "tag mismatch"):
387 o.auto("<r>hi", stream)
388
389 with self.assertRaisesRegex(Error, "tag mismatch"):
390 o.auto("hi</>", stream)
391
392 with self.assertRaisesRegex(Error, "tag mismatch"):
393 o.auto("<r><y>hi</>", stream)
394
395 with self.assertRaisesRegex(Error, "tag mismatch"):
396 o.auto("<r><y>hi</><r></>", stream)
397
398 with self.assertRaisesRegex(Error, "tag mismatch"):
399 o.auto("</>hi<r>", stream)