| from unittest import TestCase | |
| from _pyrepl.render import ( | |
| LineUpdate, | |
| RenderCell, | |
| RenderLine, | |
| RenderedScreen, | |
| ScreenOverlay, | |
| StyleRef, | |
| diff_render_lines, | |
| render_cells, | |
| requires_cursor_resync, | |
| ) | |
| class TestRenderLine(TestCase): | |
| def test_from_rendered_text_parses_style_state(self): | |
| line = RenderLine.from_rendered_text("\x1b[31ma\x1b[0mb") | |
| self.assertEqual(line.width, 2) | |
| self.assertEqual([cell.text for cell in line.cells], ["a", "b"]) | |
| self.assertEqual([cell.style.sgr for cell in line.cells], ["\x1b[31m", ""]) | |
| self.assertEqual([cell.controls for cell in line.cells], [(), ()]) | |
| def test_from_rendered_text_round_trips_trailing_reset(self): | |
| line = RenderLine.from_rendered_text("\x1b[31ma\x1b[0m") | |
| self.assertEqual([cell.text for cell in line.cells], ["a"]) | |
| self.assertEqual([cell.style.sgr for cell in line.cells], ["\x1b[31m"]) | |
| self.assertEqual(line.text, "\x1b[31ma\x1b[0m") | |
| def test_from_parts_accepts_style_refs(self): | |
| line = RenderLine.from_parts( | |
| ["d", "e", "f", " "], | |
| [1, 1, 1, 1], | |
| [StyleRef.from_sgr("\x1b[1;34m")] * 3 + [None], | |
| ) | |
| self.assertEqual([cell.text for cell in line.cells], ["d", "e", "f", " "]) | |
| self.assertEqual( | |
| [cell.style.sgr for cell in line.cells], | |
| ["\x1b[1;34m", "\x1b[1;34m", "\x1b[1;34m", ""], | |
| ) | |
| self.assertEqual(line.text, "\x1b[1;34mdef\x1b[0m ") | |
| def test_from_parts_without_styles(self): | |
| line = RenderLine.from_parts(["a", "b"], [1, 1]) | |
| self.assertEqual(line.text, "ab") | |
| self.assertEqual(line.width, 2) | |
| def test_from_rendered_text_empty_string(self): | |
| line = RenderLine.from_rendered_text("") | |
| self.assertEqual(line.cells, ()) | |
| self.assertEqual(line.text, "") | |
| self.assertEqual(line.width, 0) | |
| def test_from_rendered_text_with_non_sgr_controls(self): | |
| # \x1b[H is a cursor-home control (not SGR since it doesn't end with 'm') | |
| line = RenderLine.from_rendered_text("\x1b[Hx") | |
| self.assertEqual(len(line.cells), 2) | |
| self.assertEqual(line.cells[0].controls, ("\x1b[H",)) | |
| self.assertEqual(line.cells[0].text, "") | |
| self.assertEqual(line.cells[1].text, "x") | |
| def test_from_rendered_text_trailing_non_sgr_control(self): | |
| line = RenderLine.from_rendered_text("a\x1b[K") | |
| self.assertEqual(len(line.cells), 2) | |
| self.assertEqual(line.cells[0].text, "a") | |
| self.assertEqual(line.cells[1].controls, ("\x1b[K",)) | |
| self.assertEqual(line.cells[1].text, "") | |
| def test_from_rendered_text_non_sgr_before_text(self): | |
| # Non-SGR control immediately before text should produce a control cell | |
| # then text cells. | |
| line = RenderLine.from_rendered_text("\x1b[Kab") | |
| texts = [c.text for c in line.cells] | |
| self.assertEqual(texts, ["", "a", "b"]) | |
| self.assertEqual(line.cells[0].controls, ("\x1b[K",)) | |
| class TestLineDiff(TestCase): | |
| def test_diff_render_lines_ignores_unchanged_ansi_prefix(self): | |
| old = RenderLine.from_rendered_text("\x1b[31ma\x1b[0mb") | |
| new = RenderLine.from_rendered_text("\x1b[31ma\x1b[0mc") | |
| diff = diff_render_lines(old, new) | |
| self.assertIsNotNone(diff) | |
| assert diff is not None | |
| self.assertEqual(diff.start_x, 1) | |
| self.assertEqual(diff.old_text, "b") | |
| self.assertEqual(diff.new_text, "c") | |
| def test_diff_render_lines_detects_single_cell_insertion(self): | |
| old = RenderLine.from_rendered_text("ab") | |
| new = RenderLine.from_rendered_text("acb") | |
| diff = diff_render_lines(old, new) | |
| self.assertIsNotNone(diff) | |
| assert diff is not None | |
| self.assertEqual(diff.start_x, 1) | |
| self.assertEqual(diff.old_text, "") | |
| self.assertEqual(diff.new_text, "c") | |
| def test_colored_append_only_emits_new_character_and_reset(self): | |
| old = RenderLine.from_rendered_text("\x1b[1mabc\x1b[0m") | |
| new = RenderLine.from_rendered_text("\x1b[1mabcd\x1b[0m") | |
| diff = diff_render_lines(old, new) | |
| self.assertIsNotNone(diff) | |
| assert diff is not None | |
| self.assertEqual(diff.start_x, 3) | |
| self.assertEqual(render_cells(diff.new_cells), "\x1b[1md\x1b[0m") | |
| def test_keyword_space_inserts_only_space_after_reset(self): | |
| old = RenderLine.from_parts( | |
| ["d", "e", "f"], | |
| [1, 1, 1], | |
| ["keyword", "keyword", "keyword"], | |
| ) | |
| new = RenderLine.from_parts( | |
| ["d", "e", "f", " "], | |
| [1, 1, 1, 1], | |
| ["keyword", "keyword", "keyword", None], | |
| ) | |
| diff = diff_render_lines(old, new) | |
| self.assertIsNotNone(diff) | |
| assert diff is not None | |
| self.assertEqual(diff.start_x, 3) | |
| self.assertEqual(render_cells(diff.new_cells), " ") | |
| def test_diff_render_lines_returns_none_for_identical(self): | |
| line = RenderLine.from_rendered_text("abc") | |
| self.assertIsNone(diff_render_lines(line, line)) | |
| def test_diff_render_lines_breaks_on_controls_in_prefix(self): | |
| old = RenderLine.from_cells([ | |
| RenderCell("a", 1), | |
| RenderCell("", 0, controls=("\x1b[K",)), | |
| RenderCell("b", 1), | |
| ]) | |
| new = RenderLine.from_cells([ | |
| RenderCell("a", 1), | |
| RenderCell("", 0, controls=("\x1b[K",)), | |
| RenderCell("c", 1), | |
| ]) | |
| diff = diff_render_lines(old, new) | |
| self.assertIsNotNone(diff) | |
| assert diff is not None | |
| # Prefix scan stops at control cell, so diff starts at cell 1 | |
| self.assertEqual(diff.start_cell, 1) | |
| self.assertEqual(diff.start_x, 1) | |
| def test_diff_render_lines_extends_past_combining_chars(self): | |
| # \u0301 is a combining acute accent (zero-width) | |
| old = RenderLine.from_parts(["a", "b", "\u0301"], [1, 1, 0]) | |
| new = RenderLine.from_parts(["a", "c", "\u0301"], [1, 1, 0]) | |
| diff = diff_render_lines(old, new) | |
| self.assertIsNotNone(diff) | |
| assert diff is not None | |
| # The combining char is included since it's zero-width | |
| self.assertEqual(len(diff.new_cells), 2) | |
| def test_diff_old_and_new_changed_width(self): | |
| old = RenderLine.from_rendered_text("ab") | |
| new = RenderLine.from_rendered_text("acd") | |
| diff = diff_render_lines(old, new) | |
| self.assertIsNotNone(diff) | |
| assert diff is not None | |
| self.assertEqual(diff.old_changed_width, 1) | |
| self.assertEqual(diff.new_changed_width, 2) | |
| def test_rendered_screen_round_trips_screen_lines(self): | |
| screen = RenderedScreen.from_screen_lines( | |
| ["a", "\x1b[31mb\x1b[0m"], | |
| (0, 1), | |
| ) | |
| self.assertEqual(screen.screen_lines, ("a", "\x1b[31mb\x1b[0m")) | |
| class TestRenderedScreen(TestCase): | |
| def test_empty(self): | |
| screen = RenderedScreen.empty() | |
| self.assertEqual(screen.lines, ()) | |
| self.assertEqual(screen.cursor, (0, 0)) | |
| self.assertEqual(screen.overlays, ()) | |
| self.assertEqual(screen.composed_lines, ()) | |
| def test_with_overlay(self): | |
| screen = RenderedScreen.from_screen_lines(["aaa", "bbb"], (0, 0)) | |
| overlay_line = RenderLine.from_rendered_text("xxx") | |
| result = screen.with_overlay(1, [overlay_line]) | |
| self.assertEqual(len(result.overlays), 1) | |
| self.assertEqual(result.composed_lines[0].text, "aaa") | |
| self.assertEqual(result.composed_lines[1].text, "xxx") | |
| def test_compose_replace_overlay(self): | |
| base = RenderedScreen.from_screen_lines(["aa", "bb", "cc"], (0, 0)) | |
| overlay_line = RenderLine.from_rendered_text("XX") | |
| screen = RenderedScreen( | |
| base.lines, | |
| (0, 0), | |
| (ScreenOverlay(y=1, lines=(overlay_line,)),), | |
| ) | |
| self.assertEqual(screen.composed_lines[0].text, "aa") | |
| self.assertEqual(screen.composed_lines[1].text, "XX") | |
| self.assertEqual(screen.composed_lines[2].text, "cc") | |
| def test_compose_insert_overlay(self): | |
| base = RenderedScreen.from_screen_lines(["aa", "bb"], (0, 0)) | |
| overlay_line = RenderLine.from_rendered_text("INS") | |
| screen = RenderedScreen( | |
| base.lines, | |
| (0, 0), | |
| (ScreenOverlay(y=1, lines=(overlay_line,), insert=True),), | |
| ) | |
| self.assertEqual(len(screen.composed_lines), 3) | |
| self.assertEqual(screen.composed_lines[0].text, "aa") | |
| self.assertEqual(screen.composed_lines[1].text, "INS") | |
| self.assertEqual(screen.composed_lines[2].text, "bb") | |
| def test_compose_replace_extends_beyond_lines(self): | |
| base = RenderedScreen.from_screen_lines(["aa"], (0, 0)) | |
| overlay_line = RenderLine.from_rendered_text("XX") | |
| screen = RenderedScreen( | |
| base.lines, | |
| (0, 0), | |
| (ScreenOverlay(y=1, lines=(overlay_line,)),), | |
| ) | |
| self.assertEqual(len(screen.composed_lines), 2) | |
| self.assertEqual(screen.composed_lines[1].text, "XX") | |
| class TestRenderCell(TestCase): | |
| def test_terminal_text(self): | |
| cell = RenderCell("x", 1, style=StyleRef.from_sgr("\x1b[32m")) | |
| self.assertEqual(cell.terminal_text, "\x1b[32mx\x1b[0m") | |
| def test_terminal_text_plain(self): | |
| cell = RenderCell("y", 1) | |
| self.assertEqual(cell.terminal_text, "y") | |
| class TestRenderCells(TestCase): | |
| def test_render_cells_with_controls(self): | |
| cells = [ | |
| RenderCell("", 0, controls=("\x1b[K",)), | |
| RenderCell("a", 1), | |
| ] | |
| result = render_cells(cells) | |
| self.assertEqual(result, "\x1b[Ka") | |
| def test_render_cells_skips_empty_text(self): | |
| cells = [ | |
| RenderCell("", 0), | |
| RenderCell("a", 1), | |
| ] | |
| result = render_cells(cells) | |
| self.assertEqual(result, "a") | |
| def test_render_cells_with_visual_style(self): | |
| cells = [RenderCell("a", 1)] | |
| result = render_cells(cells, visual_style="\x1b[7m") | |
| self.assertEqual(result, "\x1b[7ma\x1b[0m") | |
| class TestLineUpdate(TestCase): | |
| def test_post_init_renders_text(self): | |
| cells = (RenderCell("a", 1), RenderCell("b", 1)) | |
| update = LineUpdate( | |
| kind="insert_char", | |
| y=0, | |
| start_cell=0, | |
| start_x=0, | |
| cells=cells, | |
| ) | |
| self.assertEqual(update.text, "ab") | |
| class TestRequiresCursorResync(TestCase): | |
| def test_no_controls(self): | |
| cells = [RenderCell("a", 1)] | |
| self.assertFalse(requires_cursor_resync(cells)) | |
| def test_sgr_only_does_not_require_resync(self): | |
| cells = [RenderCell("", 0, controls=("\x1b[31m",))] | |
| self.assertFalse(requires_cursor_resync(cells)) | |
| def test_non_sgr_requires_resync(self): | |
| cells = [RenderCell("", 0, controls=("\x1b[H",))] | |
| self.assertTrue(requires_cursor_resync(cells)) |