Debian Codegraph @

Lib/test/test_pyrepl/test_reader.py

raw
1 import itertools
2 import functools
3 import rlcompleter
4 from textwrap import dedent
5 from unittest import TestCase
6 from unittest.mock import MagicMock
7 from test.support import force_colorized_test_class, force_not_colorized_test_class
8
9 from .support import handle_all_events, handle_events_narrow_console
10 from .support import ScreenEqualMixin, code_to_events
11 from .support import prepare_reader, prepare_console
12 from _pyrepl.console import Event
13 from _pyrepl.reader import Reader
14 from _colorize import default_theme
15
16
17 overrides = {"reset": "z", "soft_keyword": "K"}
18 colors = {overrides.get(k, k[0].lower()): v for k, v in default_theme.syntax.items()}
19
20
21 @force_not_colorized_test_class
22 class TestReader(ScreenEqualMixin, TestCase):
23 def test_calc_screen_wrap_simple(self):
24 events = code_to_events(10 * "a")
25 reader, _ = handle_events_narrow_console(events)
26 self.assert_screen_equal(reader, f"{9*"a"}\\\na")
27
28 def test_calc_screen_wrap_wide_characters(self):
29 events = code_to_events(8 * "a" + "樂")
30 reader, _ = handle_events_narrow_console(events)
31 self.assert_screen_equal(reader, f"{8*"a"}\\\n樂")
32
33 def test_calc_screen_wrap_three_lines(self):
34 events = code_to_events(20 * "a")
35 reader, _ = handle_events_narrow_console(events)
36 self.assert_screen_equal(reader, f"{9*"a"}\\\n{9*"a"}\\\naa")
37
38 def test_calc_screen_prompt_handling(self):
39 def prepare_reader_keep_prompts(*args, **kwargs):
40 reader = prepare_reader(*args, **kwargs)
41 del reader.get_prompt
42 reader.ps1 = ">>> "
43 reader.ps2 = ">>> "
44 reader.ps3 = "... "
45 reader.ps4 = ""
46 reader.can_colorize = False
47 reader.paste_mode = False
48 return reader
49
50 events = code_to_events("if some_condition:\nsome_function()")
51 reader, _ = handle_events_narrow_console(
52 events,
53 prepare_reader=prepare_reader_keep_prompts,
54 )
55 # fmt: off
56 self.assert_screen_equal(
57 reader,
58 (
59 ">>> if so\\\n"
60 "me_condit\\\n"
61 "ion:\n"
62 "... s\\\n"
63 "ome_funct\\\n"
64 "ion()"
65 )
66 )
67 # fmt: on
68
69 def test_calc_screen_wrap_three_lines_mixed_character(self):
70 # fmt: off
71 code = (
72 "def f():\n"
73 f" {8*"a"}\n"
74 f" {5*"樂"}"
75 )
76 # fmt: on
77
78 events = code_to_events(code)
79 reader, _ = handle_events_narrow_console(events)
80
81 # fmt: off
82 self.assert_screen_equal(
83 reader,
84 (
85 "def f():\n"
86 f" {7*"a"}\\\n"
87 "a\n"
88 f" {3*"樂"}\\\n"
89 "樂樂"
90 ),
91 clean=True,
92 )
93 # fmt: on
94
95 def test_calc_screen_backspace(self):
96 events = itertools.chain(
97 code_to_events("aaa"),
98 [
99 Event(evt="key", data="backspace", raw=bytearray(b"\x7f")),
100 ],
101 )
102 reader, _ = handle_all_events(events)
103 self.assert_screen_equal(reader, "aa")
104
105 def test_calc_screen_wrap_removes_after_backspace(self):
106 events = itertools.chain(
107 code_to_events(10 * "a"),
108 [
109 Event(evt="key", data="backspace", raw=bytearray(b"\x7f")),
110 ],
111 )
112 reader, _ = handle_events_narrow_console(events)
113 self.assert_screen_equal(reader, 9 * "a")
114
115 def test_calc_screen_backspace_in_second_line_after_wrap(self):
116 events = itertools.chain(
117 code_to_events(11 * "a"),
118 [
119 Event(evt="key", data="backspace", raw=bytearray(b"\x7f")),
120 ],
121 )
122 reader, _ = handle_events_narrow_console(events)
123 self.assert_screen_equal(reader, f"{9*"a"}\\\na")
124
125 def test_setpos_for_xy_simple(self):
126 events = code_to_events("11+11")
127 reader, _ = handle_all_events(events)
128 reader.setpos_from_xy(0, 0)
129 self.assertEqual(reader.pos, 0)
130
131 def test_setpos_from_xy_multiple_lines(self):
132 # fmt: off
133 code = (
134 "def foo():\n"
135 " return 1"
136 )
137 # fmt: on
138
139 events = code_to_events(code)
140 reader, _ = handle_all_events(events)
141 reader.setpos_from_xy(2, 1)
142 self.assertEqual(reader.pos, 13)
143
144 def test_setpos_from_xy_after_wrap(self):
145 # fmt: off
146 code = (
147 "def foo():\n"
148 " hello"
149 )
150 # fmt: on
151
152 events = code_to_events(code)
153 reader, _ = handle_events_narrow_console(events)
154 reader.setpos_from_xy(2, 2)
155 self.assertEqual(reader.pos, 13)
156
157 def test_setpos_fromxy_in_wrapped_line(self):
158 # fmt: off
159 code = (
160 "def foo():\n"
161 " hello"
162 )
163 # fmt: on
164
165 events = code_to_events(code)
166 reader, _ = handle_events_narrow_console(events)
167 reader.setpos_from_xy(0, 1)
168 self.assertEqual(reader.pos, 9)
169
170 def test_up_arrow_after_ctrl_r(self):
171 events = iter(
172 [
173 Event(evt="key", data="\x12", raw=bytearray(b"\x12")),
174 Event(evt="key", data="up", raw=bytearray(b"\x1bOA")),
175 ]
176 )
177
178 reader, _ = handle_all_events(events)
179 self.assert_screen_equal(reader, "")
180
181 def test_newline_within_block_trailing_whitespace(self):
182 # fmt: off
183 code = (
184 "def foo():\n"
185 "a = 1\n"
186 )
187 # fmt: on
188
189 events = itertools.chain(
190 code_to_events(code),
191 [
192 # go to the end of the first line
193 Event(evt="key", data="up", raw=bytearray(b"\x1bOA")),
194 Event(evt="key", data="up", raw=bytearray(b"\x1bOA")),
195 Event(evt="key", data="\x05", raw=bytearray(b"\x1bO5")),
196 # new lines in-block shouldn't terminate the block
197 Event(evt="key", data="\n", raw=bytearray(b"\n")),
198 Event(evt="key", data="\n", raw=bytearray(b"\n")),
199 # end of line 2
200 Event(evt="key", data="down", raw=bytearray(b"\x1bOB")),
201 Event(evt="key", data="\x05", raw=bytearray(b"\x1bO5")),
202 # a double new line in-block should terminate the block
203 # even if its followed by whitespace
204 Event(evt="key", data="\n", raw=bytearray(b"\n")),
205 Event(evt="key", data="\n", raw=bytearray(b"\n")),
206 ],
207 )
208
209 no_paste_reader = functools.partial(prepare_reader, paste_mode=False)
210 reader, _ = handle_all_events(events, prepare_reader=no_paste_reader)
211
212 expected = (
213 "def foo():\n"
214 " \n"
215 " \n"
216 " a = 1\n"
217 " \n"
218 " " # HistoricalReader will trim trailing whitespace
219 )
220 self.assert_screen_equal(reader, expected, clean=True)
221 self.assertTrue(reader.finished)
222
223 def test_input_hook_is_called_if_set(self):
224 input_hook = MagicMock()
225
226 def _prepare_console(events):
227 console = MagicMock()
228 console.get_event.side_effect = events
229 console.height = 100
230 console.width = 80
231 console.getheightwidth = MagicMock(side_effect=lambda: (console.height, console.width))
232 console.input_hook = input_hook
233 return console
234
235 events = code_to_events("a")
236 reader, _ = handle_all_events(events, prepare_console=_prepare_console)
237
238 self.assertEqual(len(input_hook.mock_calls), 4)
239
240 def test_keyboard_interrupt_clears_screen(self):
241 namespace = {"itertools": itertools}
242 code = "import itertools\nitertools."
243 events = itertools.chain(
244 code_to_events(code),
245 [
246 # Two tabs for completion
247 Event(evt="key", data="\t", raw=bytearray(b"\t")),
248 Event(evt="key", data="\t", raw=bytearray(b"\t")),
249 Event(evt="key", data="\x03", raw=bytearray(b"\x03")), # Ctrl-C
250 ],
251 )
252 console = prepare_console(events)
253 reader = prepare_reader(
254 console,
255 readline_completer=rlcompleter.Completer(namespace).complete,
256 )
257 try:
258 # we're not using handle_all_events() here to be able to
259 # follow the KeyboardInterrupt sequence of events. Normally this
260 # happens in simple_interact.run_multiline_interactive_console.
261 while True:
262 reader.handle1()
263 except KeyboardInterrupt:
264 # at this point the completions are still visible
265 self.assertTrue(len(reader.screen) > 2)
266 reader.refresh()
267 # after the refresh, they are gone
268 self.assertEqual(len(reader.screen), 2)
269 self.assert_screen_equal(reader, code, clean=True)
270 else:
271 self.fail("KeyboardInterrupt not raised.")
272
273 def test_prompt_length(self):
274 # Handles simple ASCII prompt
275 ps1 = ">>> "
276 prompt, l = Reader.process_prompt(ps1)
277 self.assertEqual(prompt, ps1)
278 self.assertEqual(l, 4)
279
280 # Handles ANSI escape sequences
281 ps1 = "\033[0;32m>>> \033[0m"
282 prompt, l = Reader.process_prompt(ps1)
283 self.assertEqual(prompt, "\033[0;32m>>> \033[0m")
284 self.assertEqual(l, 4)
285
286 # Handles ANSI escape sequences bracketed in \001 .. \002
287 ps1 = "\001\033[0;32m\002>>> \001\033[0m\002"
288 prompt, l = Reader.process_prompt(ps1)
289 self.assertEqual(prompt, "\033[0;32m>>> \033[0m")
290 self.assertEqual(l, 4)
291
292 # Handles wide characters in prompt
293 ps1 = "樂>> "
294 prompt, l = Reader.process_prompt(ps1)
295 self.assertEqual(prompt, ps1)
296 self.assertEqual(l, 5)
297
298 # Handles wide characters AND ANSI sequences together
299 ps1 = "\001\033[0;32m\002樂>\001\033[0m\002> "
300 prompt, l = Reader.process_prompt(ps1)
301 self.assertEqual(prompt, "\033[0;32m樂>\033[0m> ")
302 self.assertEqual(l, 5)
303
304 def test_completions_updated_on_key_press(self):
305 namespace = {"itertools": itertools}
306 code = "itertools."
307 events = itertools.chain(
308 code_to_events(code),
309 [
310 # Two tabs for completion
311 Event(evt="key", data="\t", raw=bytearray(b"\t")),
312 Event(evt="key", data="\t", raw=bytearray(b"\t")),
313 ],
314 code_to_events("a"),
315 )
316
317 completing_reader = functools.partial(
318 prepare_reader,
319 readline_completer=rlcompleter.Completer(namespace).complete,
320 )
321 reader, _ = handle_all_events(events, prepare_reader=completing_reader)
322
323 actual = reader.screen
324 self.assertEqual(len(actual), 2)
325 self.assertEqual(actual[0], f"{code}a")
326 self.assertEqual(actual[1].rstrip(), "itertools.accumulate(")
327
328 def test_key_press_on_tab_press_once(self):
329 namespace = {"itertools": itertools}
330 code = "itertools."
331 events = itertools.chain(
332 code_to_events(code),
333 [
334 Event(evt="key", data="\t", raw=bytearray(b"\t")),
335 ],
336 code_to_events("a"),
337 )
338
339 completing_reader = functools.partial(
340 prepare_reader,
341 readline_completer=rlcompleter.Completer(namespace).complete,
342 )
343 reader, _ = handle_all_events(events, prepare_reader=completing_reader)
344
345 self.assert_screen_equal(reader, f"{code}a")
346
347 def test_pos2xy_with_no_columns(self):
348 console = prepare_console([])
349 reader = prepare_reader(console)
350 # Simulate a resize to 0 columns
351 reader.screeninfo = []
352 self.assertEqual(reader.pos2xy(), (0, 0))
353
354 def test_setpos_from_xy_for_non_printing_char(self):
355 code = "# non \u200c printing character"
356 events = code_to_events(code)
357
358 reader, _ = handle_all_events(events)
359 reader.setpos_from_xy(8, 0)
360 self.assertEqual(reader.pos, 7)
361
362 @force_colorized_test_class
363 class TestReaderInColor(ScreenEqualMixin, TestCase):
364 def test_syntax_highlighting_basic(self):
365 code = dedent(
366 """\
367 import re, sys
368 def funct(case: str = sys.platform) -> None:
369 match = re.search(
370 "(me)",
371 '''
372 Come on
373 Come on now
374 You know that it's time to emerge
375 ''',
376 )
377 match case:
378 case "emscripten": print("on the web")
379 case "ios" | "android":
380 print("on the phone")
381 case _: print('arms around', match.group(1))
382 type type = type[type]
383 """
384 )
385 expected = dedent(
386 """\
387 {k}import{z} re{o},{z} sys
388 {a}{k}def{z} {d}funct{z}{o}({z}case{o}:{z} {b}str{z} {o}={z} sys{o}.{z}platform{o}){z} {o}->{z} {k}None{z}{o}:{z}
389 match {o}={z} re{o}.{z}search{o}({z}
390 {s}"(me)"{z}{o},{z}
391 {s}'''{z}
392 {s} Come on{z}
393 {s} Come on now{z}
394 {s} You know that it's time to emerge{z}
395 {s} '''{z}{o},{z}
396 {o}){z}
397 {K}match{z} case{o}:{z}
398 {K}case{z} {s}"emscripten"{z}{o}:{z} {b}print{z}{o}({z}{s}"on the web"{z}{o}){z}
399 {K}case{z} {s}"ios"{z} {o}|{z} {s}"android"{z}{o}:{z}
400 {b}print{z}{o}({z}{s}"on the phone"{z}{o}){z}
401 {K}case{z} {K}_{z}{o}:{z} {b}print{z}{o}({z}{s}'arms around'{z}{o},{z} match{o}.{z}group{o}({z}{n}1{z}{o}){z}{o}){z}
402 {K}type{z} {b}type{z} {o}={z} {b}type{z}{o}[{z}{b}type{z}{o}]{z}
403 """
404 )
405 expected_sync = expected.format(a="", **colors)
406 events = code_to_events(code)
407 reader, _ = handle_all_events(events)
408 self.assert_screen_equal(reader, code, clean=True)
409 self.assert_screen_equal(reader, expected_sync)
410 self.assertEqual(reader.pos, 419)
411 self.assertEqual(reader.cxy, (0, 16))
412
413 async_msg = "{k}async{z} ".format(**colors)
414 expected_async = expected.format(a=async_msg, **colors)
415 more_events = itertools.chain(
416 code_to_events(code),
417 [Event(evt="key", data="up", raw=bytearray(b"\x1bOA"))] * 15,
418 code_to_events("async "),
419 )
420 reader, _ = handle_all_events(more_events)
421 self.assert_screen_equal(reader, expected_async)
422 self.assertEqual(reader.pos, 21)
423 self.assertEqual(reader.cxy, (6, 1))
424
425 def test_syntax_highlighting_incomplete_string_first_line(self):
426 code = dedent(
427 """\
428 def unfinished_function(arg: str = "still typing
429 """
430 )
431 expected = dedent(
432 """\
433 {k}def{z} {d}unfinished_function{z}{o}({z}arg{o}:{z} {b}str{z} {o}={z} {s}"still typing{z}
434 """
435 ).format(**colors)
436 events = code_to_events(code)
437 reader, _ = handle_all_events(events)
438 self.assert_screen_equal(reader, code, clean=True)
439 self.assert_screen_equal(reader, expected)
440
441 def test_syntax_highlighting_incomplete_string_another_line(self):
442 code = dedent(
443 """\
444 def unfinished_function(
445 arg: str = "still typing
446 """
447 )
448 expected = dedent(
449 """\
450 {k}def{z} {d}unfinished_function{z}{o}({z}
451 arg{o}:{z} {b}str{z} {o}={z} {s}"still typing{z}
452 """
453 ).format(**colors)
454 events = code_to_events(code)
455 reader, _ = handle_all_events(events)
456 self.assert_screen_equal(reader, code, clean=True)
457 self.assert_screen_equal(reader, expected)
458
459 def test_syntax_highlighting_incomplete_multiline_string(self):
460 code = dedent(
461 """\
462 def unfinished_function():
463 '''Still writing
464 the docstring
465 """
466 )
467 expected = dedent(
468 """\
469 {k}def{z} {d}unfinished_function{z}{o}({z}{o}){z}{o}:{z}
470 {s}'''Still writing{z}
471 {s} the docstring{z}
472 """
473 ).format(**colors)
474 events = code_to_events(code)
475 reader, _ = handle_all_events(events)
476 self.assert_screen_equal(reader, code, clean=True)
477 self.assert_screen_equal(reader, expected)
478
479 def test_syntax_highlighting_incomplete_fstring(self):
480 code = dedent(
481 """\
482 def unfinished_function():
483 var = f"Single-quote but {
484 1
485 +
486 1
487 } multi-line!
488 """
489 )
490 expected = dedent(
491 """\
492 {k}def{z} {d}unfinished_function{z}{o}({z}{o}){z}{o}:{z}
493 var {o}={z} {s}f"{z}{s}Single-quote but {z}{o}{OB}{z}
494 {n}1{z}
495 {o}+{z}
496 {n}1{z}
497 {o}{CB}{z}{s} multi-line!{z}
498 """
499 ).format(OB="{", CB="}", **colors)
500 events = code_to_events(code)
501 reader, _ = handle_all_events(events)
502 self.assert_screen_equal(reader, code, clean=True)
503 self.assert_screen_equal(reader, expected)
504
505 def test_syntax_highlighting_indentation_error(self):
506 code = dedent(
507 """\
508 def unfinished_function():
509 var = 1
510 oops
511 """
512 )
513 expected = dedent(
514 """\
515 {k}def{z} {d}unfinished_function{z}{o}({z}{o}){z}{o}:{z}
516 var {o}={z} {n}1{z}
517 oops
518 """
519 ).format(**colors)
520 events = code_to_events(code)
521 reader, _ = handle_all_events(events)
522 self.assert_screen_equal(reader, code, clean=True)
523 self.assert_screen_equal(reader, expected)
524
525 def test_syntax_highlighting_literal_brace_in_fstring_or_tstring(self):
526 code = dedent(
527 """\
528 f"{{"
529 f"}}"
530 f"a{{b"
531 f"a}}b"
532 f"a{{b}}c"
533 t"a{{b}}c"
534 f"{{{0}}}"
535 f"{ {0} }"
536 """
537 )
538 expected = dedent(
539 """\
540 {s}f"{z}{s}<<{z}{s}"{z}
541 {s}f"{z}{s}>>{z}{s}"{z}
542 {s}f"{z}{s}a<<{z}{s}b{z}{s}"{z}
543 {s}f"{z}{s}a>>{z}{s}b{z}{s}"{z}
544 {s}f"{z}{s}a<<{z}{s}b>>{z}{s}c{z}{s}"{z}
545 {s}t"{z}{s}a<<{z}{s}b>>{z}{s}c{z}{s}"{z}
546 {s}f"{z}{s}<<{z}{o}<{z}{n}0{z}{o}>{z}{s}>>{z}{s}"{z}
547 {s}f"{z}{o}<{z} {o}<{z}{n}0{z}{o}>{z} {o}>{z}{s}"{z}
548 """
549 ).format(**colors).replace("<", "{").replace(">", "}")
550 events = code_to_events(code)
551 reader, _ = handle_all_events(events)
552 self.assert_screen_equal(reader, code, clean=True)
553 self.maxDiff=None
554 self.assert_screen_equal(reader, expected)
555
556 def test_control_characters(self):
557 code = 'flag = "🏳️‍🌈"'
558 events = code_to_events(code)
559 reader, _ = handle_all_events(events)
560 self.assert_screen_equal(reader, 'flag = "🏳️\\u200d🌈"', clean=True)
561 self.assert_screen_equal(reader, 'flag {o}={z} {s}"🏳️\\u200d🌈"{z}'.format(**colors))