| from unittest import TestCase |
| from _pyrepl.content import ( |
| ContentFragment, |
| ContentLine, |
| PromptContent, |
| SourceLine, |
| ) |
| from _pyrepl.layout import ( |
| LayoutMap, |
| LayoutRow, |
| layout_content_lines, |
| ) |
| |
| |
| def _source(text, lineno=0, start_offset=0, has_newline=True, cursor_index=None): |
| return SourceLine(lineno, text, start_offset, has_newline, cursor_index) |
| |
| |
| def _prompt(text=">>> ", width=4): |
| return PromptContent((), text, width) |
| |
| |
| def _body_from_text(text): |
| return tuple(ContentFragment(ch, 1) for ch in text) |
| |
| |
| def _content_line(text, prompt=None, has_newline=True, start_offset=0): |
| if prompt is None: |
| prompt = _prompt() |
| body = _body_from_text(text) |
| source = _source(text, start_offset=start_offset, has_newline=has_newline) |
| return ContentLine(source, prompt, body) |
| |
| |
| class TestLayoutRow(TestCase): |
| def test_width_basic(self): |
| row = LayoutRow(4, (1, 1, 1)) |
| self.assertEqual(row.width, 7) |
| |
| def test_width_with_suffix(self): |
| row = LayoutRow(4, (1, 1), suffix_width=1) |
| self.assertEqual(row.width, 7) |
| |
| def test_screeninfo_without_suffix(self): |
| row = LayoutRow(4, (1, 1, 1)) |
| prompt_w, widths = row.screeninfo |
| self.assertEqual(prompt_w, 4) |
| self.assertEqual(widths, [1, 1, 1]) |
| |
| def test_screeninfo_with_suffix(self): |
| row = LayoutRow(4, (1, 1), suffix_width=1) |
| prompt_w, widths = row.screeninfo |
| self.assertEqual(prompt_w, 4) |
| self.assertEqual(widths, [1, 1, 1]) |
| |
| |
| class TestLayoutMap(TestCase): |
| def test_empty(self): |
| lm = LayoutMap.empty() |
| self.assertEqual(len(lm.rows), 1) |
| self.assertEqual(lm.max_row(), 0) |
| self.assertEqual(lm.max_column(0), 0) |
| |
| def test_screeninfo(self): |
| lm = LayoutMap(( |
| LayoutRow(4, (1, 1, 1)), |
| LayoutRow(0, (1, 1)), |
| )) |
| info = lm.screeninfo |
| self.assertEqual(len(info), 2) |
| self.assertEqual(info[0], (4, [1, 1, 1])) |
| self.assertEqual(info[1], (0, [1, 1])) |
| |
| def test_max_column(self): |
| lm = LayoutMap((LayoutRow(4, (1, 1, 1)),)) |
| self.assertEqual(lm.max_column(0), 7) |
| |
| def test_max_row(self): |
| lm = LayoutMap((LayoutRow(0, ()), LayoutRow(0, ()))) |
| self.assertEqual(lm.max_row(), 1) |
| |
| def test_pos_to_xy_empty_rows(self): |
| lm = LayoutMap(()) |
| self.assertEqual(lm.pos_to_xy(0), (0, 0)) |
| |
| def test_pos_to_xy_single_row(self): |
| lm = LayoutMap((LayoutRow(4, (1, 1, 1), buffer_advance=3),)) |
| self.assertEqual(lm.pos_to_xy(0), (4, 0)) |
| self.assertEqual(lm.pos_to_xy(1), (5, 0)) |
| self.assertEqual(lm.pos_to_xy(2), (6, 0)) |
| self.assertEqual(lm.pos_to_xy(3), (7, 0)) |
| |
| def test_pos_to_xy_multi_row(self): |
| lm = LayoutMap(( |
| LayoutRow(4, (1, 1, 1), buffer_advance=4), |
| LayoutRow(4, (1, 1), buffer_advance=2), |
| )) |
| # First row: pos 0-3 |
| self.assertEqual(lm.pos_to_xy(0), (4, 0)) |
| self.assertEqual(lm.pos_to_xy(3), (7, 0)) |
| # Second row: pos 4-5 |
| self.assertEqual(lm.pos_to_xy(4), (4, 1)) |
| self.assertEqual(lm.pos_to_xy(5), (5, 1)) |
| |
| def test_pos_to_xy_past_end_clamps(self): |
| lm = LayoutMap((LayoutRow(4, (1, 1), buffer_advance=2),)) |
| self.assertEqual(lm.pos_to_xy(99), (6, 0)) |
| |
| def test_pos_to_xy_skips_prompt_only_leading_rows(self): |
| lm = LayoutMap(( |
| LayoutRow(0, (), buffer_advance=0), # leading prompt-only row |
| LayoutRow(4, (1, 1), buffer_advance=3), |
| )) |
| # pos 0 should skip the leading row and land on the real row |
| self.assertEqual(lm.pos_to_xy(0), (4, 1)) |
| |
| def test_pos_to_xy_with_suffix(self): |
| lm = LayoutMap(( |
| LayoutRow(4, (1, 1), suffix_width=1, buffer_advance=2), |
| LayoutRow(0, (1,), buffer_advance=2), |
| )) |
| # pos=2 fits within first row's char_widths (len=2), cursor at end |
| self.assertEqual(lm.pos_to_xy(2), (6, 0)) |
| # pos=3 exceeds first row, lands on second row |
| self.assertEqual(lm.pos_to_xy(3), (1, 1)) |
| |
| def test_xy_to_pos_empty_rows(self): |
| lm = LayoutMap(()) |
| self.assertEqual(lm.xy_to_pos(0, 0), 0) |
| |
| def test_xy_to_pos_single_row(self): |
| lm = LayoutMap((LayoutRow(4, (1, 1, 1), buffer_advance=3),)) |
| self.assertEqual(lm.xy_to_pos(4, 0), 0) |
| self.assertEqual(lm.xy_to_pos(5, 0), 1) |
| self.assertEqual(lm.xy_to_pos(6, 0), 2) |
| self.assertEqual(lm.xy_to_pos(7, 0), 3) |
| |
| def test_xy_to_pos_multi_row(self): |
| lm = LayoutMap(( |
| LayoutRow(4, (1, 1, 1), buffer_advance=4), |
| LayoutRow(4, (1, 1), buffer_advance=2), |
| )) |
| self.assertEqual(lm.xy_to_pos(4, 0), 0) |
| self.assertEqual(lm.xy_to_pos(4, 1), 4) |
| self.assertEqual(lm.xy_to_pos(5, 1), 5) |
| |
| def test_xy_to_pos_before_prompt_returns_zero(self): |
| lm = LayoutMap((LayoutRow(4, (1, 1), buffer_advance=2),)) |
| self.assertEqual(lm.xy_to_pos(0, 0), 0) |
| |
| def test_xy_to_pos_with_zero_width_chars(self): |
| # Simulates combining characters (zero-width) after a base char |
| lm = LayoutMap((LayoutRow(4, (1, 0, 1), buffer_advance=3),)) |
| # x=5 is past the first char; trailing zero-width combining is included |
| self.assertEqual(lm.xy_to_pos(5, 0), 2) |
| |
| def test_xy_to_pos_zero_width_skipped(self): |
| lm = LayoutMap((LayoutRow(0, (0, 1, 1), buffer_advance=3),)) |
| # x=0: the zero-width char at index 0 is skipped, pos advances |
| self.assertEqual(lm.xy_to_pos(0, 0), 1) |
| |
| def test_xy_to_pos_zero_width_before_target(self): |
| # Zero-width char between two normal chars; target x is past it |
| lm = LayoutMap((LayoutRow(0, (1, 0, 1), buffer_advance=3),)) |
| # x=2: passes char at x=0 (w=1), skips zero-width at x=1, lands at x=2 |
| self.assertEqual(lm.xy_to_pos(2, 0), 3) |
| |
| def test_xy_to_pos_trailing_all_zero_width(self): |
| # All remaining chars from cursor position are zero-width |
| lm = LayoutMap((LayoutRow(0, (1, 0), buffer_advance=2),)) |
| # x=1: past first char, trailing loop exhausts (all remaining are 0-width) |
| self.assertEqual(lm.xy_to_pos(1, 0), 2) |
| |
| |
| class TestLayoutContentLines(TestCase): |
| def test_zero_width_returns_empty(self): |
| result = layout_content_lines((), 0, 0) |
| self.assertEqual(result.wrapped_rows, ()) |
| self.assertEqual(result.layout_map.rows, ()) |
| |
| def test_negative_width_returns_empty(self): |
| result = layout_content_lines((), -1, 0) |
| self.assertEqual(result.wrapped_rows, ()) |
| |
| def test_single_short_line(self): |
| line = _content_line("abc") |
| result = layout_content_lines((line,), 80, 0) |
| |
| self.assertEqual(len(result.wrapped_rows), 1) |
| row = result.wrapped_rows[0] |
| self.assertEqual(row.prompt_text, ">>> ") |
| self.assertEqual(row.prompt_width, 4) |
| self.assertEqual(row.suffix, "") |
| self.assertEqual(row.buffer_advance, 4) # 3 chars + newline |
| |
| def test_single_line_no_newline(self): |
| line = _content_line("ab", has_newline=False) |
| result = layout_content_lines((line,), 80, 0) |
| |
| self.assertEqual(len(result.wrapped_rows), 1) |
| self.assertEqual(result.wrapped_rows[0].buffer_advance, 2) |
| |
| def test_empty_body(self): |
| source = _source("", has_newline=True) |
| prompt = _prompt() |
| line = ContentLine(source, prompt, ()) |
| result = layout_content_lines((line,), 80, 0) |
| |
| self.assertEqual(len(result.wrapped_rows), 1) |
| self.assertEqual(result.wrapped_rows[0].buffer_advance, 1) # just newline |
| |
| def test_line_wraps(self): |
| # prompt ">>> " is 4 wide, terminal is 10 wide, so 6 chars fit per row |
| line = _content_line("abcdefgh") # 8 chars, needs 2 rows |
| result = layout_content_lines((line,), 10, 0) |
| |
| self.assertEqual(len(result.wrapped_rows), 2) |
| first, second = result.wrapped_rows |
| self.assertEqual(first.prompt_text, ">>> ") |
| self.assertEqual(first.suffix, "\\") |
| self.assertEqual(first.suffix_width, 1) |
| # First row: 10 - 4(prompt) - 1(suffix) = 5 chars |
| self.assertEqual(first.buffer_advance, 5) |
| # Second row: continuation with no prompt |
| self.assertEqual(second.prompt_text, "") |
| self.assertEqual(second.prompt_width, 0) |
| self.assertEqual(second.buffer_advance, 4) # remaining 3 + newline |
| self.assertEqual(second.suffix, "") |
| |
| def test_wrapping_forces_progress(self): |
| # When a single character is wider than available space, force 1 char |
| prompt = _prompt("P", 1) |
| body = (ContentFragment("W", 1),) |
| source = _source("W", has_newline=False) |
| line = ContentLine(source, prompt, body) |
| # width=2 means prompt(1) + char(1) = 2, which fits (< width would be |
| # false for width=2 since 1+1 >= 2), so it wraps but forces progress |
| result = layout_content_lines((line,), 2, 0) |
| |
| self.assertEqual(len(result.wrapped_rows), 1) |
| self.assertEqual(result.wrapped_rows[0].buffer_advance, 1) |
| |
| def test_layout_map_matches_wrapped_rows(self): |
| line = _content_line("abc") |
| result = layout_content_lines((line,), 80, 0) |
| |
| self.assertEqual(len(result.layout_map.rows), len(result.wrapped_rows)) |
| self.assertEqual(result.layout_map.rows[0].prompt_width, 4) |
| self.assertEqual(result.layout_map.rows[0].char_widths, (1, 1, 1)) |
| |
| def test_line_end_offsets(self): |
| line1 = _content_line("ab") |
| line2 = _content_line("cd") |
| result = layout_content_lines((line1, line2), 80, 0) |
| |
| self.assertEqual(len(result.line_end_offsets), 2) |
| # line1: 2 chars + 1 newline = offset 3 |
| self.assertEqual(result.line_end_offsets[0], 3) |
| # line2: offset 3 + 2 chars + 1 newline = 6 |
| self.assertEqual(result.line_end_offsets[1], 6) |
| |
| def test_start_offset_shifts_offsets(self): |
| line = _content_line("ab") |
| result = layout_content_lines((line,), 80, 10) |
| |
| self.assertEqual(result.line_end_offsets[0], 13) |
| |
| def test_multiple_lines(self): |
| line1 = _content_line("abc") |
| line2 = _content_line("de") |
| result = layout_content_lines((line1, line2), 80, 0) |
| |
| self.assertEqual(len(result.wrapped_rows), 2) |
| self.assertEqual(result.wrapped_rows[0].buffer_advance, 4) # abc + \n |
| self.assertEqual(result.wrapped_rows[1].buffer_advance, 3) # de + \n |
| |
| def test_leading_prompt_lines(self): |
| leading = (ContentFragment("header", 6),) |
| prompt = PromptContent(leading, ">>> ", 4) |
| body = _body_from_text("x") |
| source = _source("x", has_newline=False) |
| line = ContentLine(source, prompt, body) |
| result = layout_content_lines((line,), 80, 0) |
| |
| # Leading line + body line |
| self.assertEqual(len(result.wrapped_rows), 2) |
| # Leading row has the fragment but no prompt |
| self.assertEqual(result.wrapped_rows[0].fragments, leading) |
| # Body row has prompt and content |
| self.assertEqual(result.wrapped_rows[1].prompt_text, ">>> ") |
| |
| def test_wrapped_line_layout_rows_have_suffix(self): |
| line = _content_line("abcdefgh") |
| result = layout_content_lines((line,), 10, 0) |
| |
| first_layout = result.layout_map.rows[0] |
| self.assertEqual(first_layout.suffix_width, 1) |
| second_layout = result.layout_map.rows[1] |
| self.assertEqual(second_layout.suffix_width, 0) |
| |
| def test_pos_to_xy_through_layout(self): |
| line = _content_line("abc") |
| result = layout_content_lines((line,), 80, 0) |
| lm = result.layout_map |
| |
| self.assertEqual(lm.pos_to_xy(0), (4, 0)) # after prompt |
| self.assertEqual(lm.pos_to_xy(1), (5, 0)) |
| self.assertEqual(lm.pos_to_xy(2), (6, 0)) |
| self.assertEqual(lm.pos_to_xy(3), (7, 0)) # end of line |
