| 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)) |
