From 23e89633fb1723627e54c667b64ae47684ff18b5 Mon Sep 17 00:00:00 2001 From: Jean-Pierre Martineau Date: Sat, 5 Sep 2026 14:02:59 -0400 Subject: [PATCH] The walk's start is cropped, not given up whole MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The breadcrumb fitted itself with ellipsized(ELIDE_HEAD): the head hop went behind a leading ⋯ and whatever fitted after it snapped right. That mark cost three cells and, worse, the whole hop it was standing in for — a 46-cell lane opened on "⋯ › Repeater-06" when it had room for the tail of Repeater-05 too. The trophy case has always cut its rows the other way: composed at natural length, handed over whole, cracked at the lane's edge in the sheared chip's own fill. Same crop here, mirrored to the end the trail is anchored on — cut_from, cut_to's head-side counterpart, added to the widget so no surface hand-rolls it. The trail draws whole while whole fits and crops its beginning when it doesn't; a crop lands exactly on the width, so the right snap comes free. Each end now carries the mark that is true of it: the head opens on the crack, which says this segment continues, and the scrolled tail keeps the ⋯, which says whole hops are missing — because off that end they really are. Co-Authored-By: Claude Opus 5 (1M context) --- meshterm/ui/pathline.py | 47 +++++++++++++++++++++++++--- meshterm/ui/walk_screen.py | 64 +++++++++++++++++++------------------- tests/test_pathline.py | 36 ++++++++++++++++++++- tests/test_walk.py | 34 ++++++++++++++------ 4 files changed, 134 insertions(+), 47 deletions(-) diff --git a/meshterm/ui/pathline.py b/meshterm/ui/pathline.py index 628b3e6..048e2cd 100644 --- a/meshterm/ui/pathline.py +++ b/meshterm/ui/pathline.py @@ -29,12 +29,13 @@ drawn*, so every surface the survey found can eventually route through it: a recommended font, a glyph-capable renderer, or the user's override) and falls back to arrows everywhere else, so no terminal ever sees tofu. * **Three overflow answers**, matching the three patterns the surfaces already use: - :meth:`PathLine.text` is the full one-liner (for callers that ellipsize or - h-scroll it themselves), :meth:`PathLine.ellipsized` fits a width by eliding + :meth:`PathLine.text` is the full one-liner (for callers that crop or + h-scroll it themselves — :func:`cut_to` anchored on the first hop, :func:`cut_from` + on the last), :meth:`PathLine.ellipsized` fits a width by eliding hops behind a ``⋯`` mark, on whichever side it is told to eat into (:data:`ELIDE_TAIL` by default — both endpoints survive, unlike a plain tail - truncation that amputates the destination; :data:`ELIDE_HEAD` for a breadcrumb - trail, which anchors on where the walk *is*) — and :meth:`PathLine.wrapped` breaks + truncation that amputates the destination; :data:`ELIDE_HEAD` where a surface + wants the head given up whole) — and :meth:`PathLine.wrapped` breaks at hop boundaries under a hanging indent (never mid-name, never mid-chip), folding where the route *means* something: the fewest lines it can take, evened out across them rather than greedily crammed, and preferring the seam where the @@ -365,6 +366,44 @@ def cut_to(line: Text, width: int, *, action: bool = False) -> Text: return with_action_mark(fitted, width) if action else fitted +def cut_from(line: Text, width: int) -> Text: + """Fit a rendered path line to ``width`` by cutting its *head* — cracked, not elided. + + :func:`cut_to`'s mirror, for a line anchored on its **last** hop rather than its + first: a breadcrumb whose news is where the walk got to, a lane whose right edge is + the thing being read. The body keeps the tail cells and the freed cell at the left + carries :func:`cut_mark`, so the chip the crop landed in opens on + :data:`CRACK_HEAD` — half segment, half page, the picture of a path that began off + to the left — while an arrow line opens on the same ``…`` it always did. A line that + already fits comes back untouched, which is what makes "draw it whole until it can't + be" the caller's default rather than a special case it has to write. + + This is a *crop*, deliberately not :meth:`PathLine.ellipsized`: nothing is dropped + behind a ``⋯``, so the reader loses exactly the cells the lane ran out of and not the + whole hop those cells were part of. The two marks stay honest about which happened — + the crack says a segment continues, the ellipsis says whole hops are missing. + + Args: + line: The rendered line to fit. + width: The cell budget. + + Returns: + A line no wider than ``width``, flush against its right edge by construction. + """ + if width <= 0: + return Text() + if line.cell_len <= width: + return line + from .tui.render import crop_cells # deferred: render reads PATH_INK from here + + mark = cut_mark(line, line.cell_len - width + 1, ELIDE_HEAD) + kept = max(0, width - mark.cell_len) + out = Text(style=line.style, no_wrap=True) + out.append_text(mark) + out.append_text(crop_cells(line, line.cell_len - kept, kept)) + return out + + def hops_atom(count: int) -> Text: """The hop count, as the stats line hanging under a path line spells it. diff --git a/meshterm/ui/walk_screen.py b/meshterm/ui/walk_screen.py index 263a76f..2559b1b 100644 --- a/meshterm/ui/walk_screen.py +++ b/meshterm/ui/walk_screen.py @@ -66,7 +66,7 @@ from ..services.topology import Link, MeshTopology from .map_render import _SELF, _UNKNOWN from .mapcanvas import RGB, MapCanvas, parse_hex from .menus import fit_cells -from .pathline import ELIDE_HEAD, SELF_GLYPH, PathHop, PathLine, elision_hop +from .pathline import SELF_GLYPH, PathHop, PathLine, cut_from, elision_hop from .theme import mark_rgb, name_style, snr_style from .trace_screen import snr_bar from .tui.render import query_line, render_to_ansi @@ -136,10 +136,10 @@ _FAN_MIN_SLOTS = 7 #: never collide with a canonical id (those are hex). _MORE = "\x00more" -#: The breadcrumb trail's own hop joiner (``›``, not the app-wide ``→``). The mark it shows -#: on whichever side holds walk that is out of view is -#: :func:`~meshterm.ui.pathline.elision_hop` itself (see :meth:`WalkScreen._trail_text`), so -#: a head the widget hid and a tail the scroll hid read as the same thing. +#: The breadcrumb trail's own hop joiner (``›``, not the app-wide ``→``). Each end that +#: holds walk out of view says so in the mark that is *true* of it (see +#: :meth:`WalkScreen._trail_text`): the head is cropped mid-hop, so it opens on the +#: cut's crack; the tail loses whole hops to the scroll, so it closes on the elision. _TRAIL_SEP = " › " #: How many find matches the list shows at most (the filter narrows it fast). @@ -609,28 +609,33 @@ class WalkScreen(Screen): reserved for keyed identities), so the trail and the rows below it agree on who is who. - The line never wraps. At rest, a walk that outgrows the width eats into its - *head* (:data:`~meshterm.ui.pathline.ELIDE_HEAD`) rather than a route's usual - tail: the oldest steps go behind a leading ``⋯`` and what survives snaps flush - against the **right** edge, so the focus and the steps that just led to it are - what a glance lands on. + The line never wraps, and it is drawn **whole** for as long as whole fits: the + walk hangs flush left, opening on its rounded head chip, exactly as it would in + a lane with cells to spare. Only when it outgrows the width does it give + anything up, and what it gives up is its **beginning** — the trophy case's crop, + mirrored (:func:`~meshterm.ui.pathline.cut_from`, JP, 2026-09-05). The line is + composed at its natural length and *cropped* at the left edge, so the chip the + crop lands in opens on the half-block crack in its own fill and the cells the + reader loses are the cells the lane ran out of — no whole hop is dropped to buy + room for a mark. The focus and the steps that just led to it are what a glance + lands on, and the cropped line fills the width by construction, which is what + puts it flush right without a pad. - Which edge the line hangs off follows one thing only: **whether the walk's start - is on it.** A line that shows its first hop — the rounded head chip, us — sits - flush **left**, where a path that begins at its beginning belongs; the right snap - is what a *cut* head looks like, holding the ``⋯`` against the far edge so the - elision reads as "the line continues off this side" rather than as a gap. So it - is not the resting state that decides, but the fit: a scrolled line whose head - has come back into view is left-aligned like any other complete one. + Which edge the line hangs off therefore follows one thing: **whether the walk's + start is on it.** A line showing its first hop sits left, where a path that + begins at its beginning belongs; a cropped one sits right, holding the crack + against the edge it continues past. It is not the resting state that decides but + the fit, so a scrolled line whose head has come back into view is left-aligned + like any other complete one. ← and → then **scroll it** (JP, 2026-08-09), a hop at a time, off the tail end: - the elided head is a real part of the walk and a long one had no way to be read - at all. A scrolled line grows its own trailing ``⋯`` — the focus is now the part - out of view — so the mark on each side always means the same thing, more walk - that way. Scrolling stops where the head comes into view rather than running the - line off the edge, and any change to the trail itself resets it: a walk, a step - back, a teleport and ^U all end with the focus in view, which is where the next - move is read from. + the cropped head is a real part of the walk and a long one had no way to be read + at all. A scrolled line grows a trailing ``⋯`` — whole hops really are dropped + off that end, which is what that mark means, against the crack's "this segment + continues". Scrolling stops where the head comes into view rather than running + the line off the edge, and any change to the trail itself resets it: a walk, a + step back, a teleport and ^U all end with the focus in view, which is where the + next move is read from. """ hops = [self._trail_hop(node) for node in self._trail] self._trail_width = width @@ -639,14 +644,9 @@ class WalkScreen(Screen): kept = hops[: len(hops) - self._trail_scroll] if self._trail_scroll: kept.append(elision_hop()) # the focus is off to the right - line = PathLine(kept, separator=_TRAIL_SEP) - full = line.text() - if full.cell_len <= width: - return full # the start is in view: the walk reads from where it set out - fitted = line.ellipsized(width, elide=ELIDE_HEAD) - snapped = Text(" " * max(0, width - fitted.cell_len)) # snap the tail to the edge - snapped.append_text(fitted) - return snapped + # Whole while it fits (flush left, from the start), cropped at the head when it + # doesn't — and a crop lands exactly on the width, so the right snap is free. + return cut_from(PathLine(kept, separator=_TRAIL_SEP).text(), width) def _trail_max_scroll(self, width: int) -> int: """How far ← may scroll the trail: the step that first brings its head into view. diff --git a/tests/test_pathline.py b/tests/test_pathline.py index 6f511e6..07f14ed 100644 --- a/tests/test_pathline.py +++ b/tests/test_pathline.py @@ -17,7 +17,7 @@ from meshterm.ui.pathline import ( CRACK_HEAD, CRACK_TAIL, CURSOR_GLYPH, ELIDE_HEAD, ELIDE_TAIL, PATH_INK, POWERLINE_ROUND_CLOSE, POWERLINE_ROUND_OPEN, POWERLINE_SEP, SELF_GLYPH, WRAP_OFFSET, PathHop, PathLine, - _SELF_INK, _YOU_BG, _style_hex, cut_mark, cut_to, elision_hop, hops_atom, + _SELF_INK, _YOU_BG, _style_hex, cut_from, cut_mark, cut_to, elision_hop, hops_atom, path_line, with_action_mark, ) from meshterm.ui.theme import node_style @@ -206,6 +206,40 @@ def test_cut_to_leaves_arrow_lines_on_the_ellipsis() -> None: assert CRACK_TAIL not in fitted.plain +def test_cut_from_crops_the_head_and_keeps_the_line_flush_right() -> None: + """``cut_to``'s mirror, for a line anchored on its last hop: the crop eats the start, + the crack opens the line in the fill of the very chip it sheared, and the result + lands exactly on the width — which is what makes it flush right without a pad.""" + full = _chips().text() + fitted = cut_from(full, 14) + assert fitted.cell_len == 14 + assert fitted.plain.startswith(CRACK_HEAD) + assert fitted.plain.endswith(full.plain[-1]) # the tail is what it is anchored on + assert "…" not in fitted.plain and CRACK_TAIL not in fitted.plain + assert str(fitted.spans[0].style) == _style_hex(node_style("22bb")) # inside BBBB + assert cut_from(full, 200) is full # fits → untouched, no copy, no mark + assert cut_from(full, 0).plain == "" + + +def test_cut_from_leaves_arrow_lines_on_the_ellipsis() -> None: + """Same mode test as the tail cut: no fill to shear, so the classic mark opens it.""" + fitted = cut_from(PathLine(_chips().hops, mode="plain").text(), 10) + assert fitted.cell_len == 10 + assert fitted.plain.startswith("…") + assert CRACK_HEAD not in fitted.plain + + +def test_cut_from_drops_no_whole_hop_the_way_an_elision_does() -> None: + """The crop is not :meth:`PathLine.ellipsized`: what the reader loses is the cells + the lane ran out of, never the whole hop those cells were part of.""" + line = PathLine([PathHop(label) for label in ("AAAA", "BBBB", "CCCC")], mode="plain") + full = line.text() + cropped, elided = cut_from(full, 14), line.ellipsized(14, elide=ELIDE_HEAD) + assert cropped.plain == "…→ BBBB → CCCC" # BBBB survives, minus the cells that ran out + assert elided.plain == "⋯ → CCCC" # where the elision gave up the whole hop + assert cropped.cell_len == 14 and elided.cell_len < 14 # and left cells on the floor + + def test_cut_mark_mirrors_itself_and_reads_the_visible_side() -> None: """The head mark is the tail's mirror, and each takes the fill of the nearest cell still *drawn* — scanning back for a tail cut, forward for a head cut.""" diff --git a/tests/test_walk.py b/tests/test_walk.py index 92cc4e1..3271daf 100644 --- a/tests/test_walk.py +++ b/tests/test_walk.py @@ -11,7 +11,7 @@ from datetime import timedelta from meshterm.core.models import Contact, utcnow from meshterm.services.topology import MeshTopology -from meshterm.ui.pathline import SELF_GLYPH +from meshterm.ui.pathline import CRACK_HEAD, ELIDE_HEAD, SELF_GLYPH, PathLine from meshterm.ui.tui.render import render_to_ansi from meshterm.ui.walk_screen import WalkScreen @@ -287,8 +287,8 @@ def test_walk_walking_to_an_earlier_node_drops_the_loop() -> None: assert screen._trail == [topo.self_id] -def test_walk_trail_drops_the_head_not_the_tail_when_narrow() -> None: - """A trail too long for the line loses its head behind a leading ⋯, snapped right.""" +def test_walk_trail_crops_its_head_not_its_tail_when_narrow() -> None: + """A trail too long for the line is cropped at its *start*, the trophy case's crop.""" screen = _screen(_topo()) us = screen._topo.self_id yul = screen._topo.canonical(YUL.public_key) @@ -296,10 +296,24 @@ def test_walk_trail_drops_the_head_not_the_tail_when_narrow() -> None: screen._trail = [us, yul, alice] width = 20 # too narrow for the whole "Homestead › YUL-Cartierville › Alice" text = screen._trail_text(width).plain - assert text.lstrip().startswith("⋯") + assert text[0] in ("…", CRACK_HEAD) # cut, not elided: no whole hop bought the mark + assert "⋯" not in text assert text.endswith("Alice") # the focus is always kept - assert "Homestead" not in text # the head was dropped, not the tail - assert len(text) == width # the surviving tail snaps flush to the right edge + assert "Homestead" not in text # the start was cropped, not the tail + assert len(text) == width # a crop lands on the width, so it is flush right already + + +def test_walk_trail_crop_keeps_the_cells_an_elision_would_have_spent() -> None: + """The crop's whole point: cells the lane has go to the walk, not to a dropped hop.""" + screen, width = _walked_chain(8) + cropped = screen._trail_text(width) + elided = PathLine( + [screen._trail_hop(node) for node in screen._trail], separator=" › " + ).ellipsized(width, elide=ELIDE_HEAD) + assert cropped.cell_len == width # the crop fills the lane… + assert elided.cell_len < width # …where dropping a whole hop left cells on the floor + # The crop keeps the tail of the hop it landed in; the elision dropped it whole. + assert cropped.plain.startswith("…-05 ") and "-05" not in elided.plain def test_walk_trail_sits_left_until_it_overflows() -> None: @@ -313,10 +327,10 @@ def test_walk_trail_scrolled_back_to_its_head_sits_left_again() -> None: """Alignment follows the head, not the scroll: a visible start hangs the line left.""" screen, width = _walked_chain(8) limit = screen._trail_max_scroll(width) - for step in range(1, limit): # every stop short of the head keeps the right snap + for step in range(1, limit): # every stop short of the head is still cropped screen.handle("left") cut = _plain([render_to_ansi(screen._trail_text(width), width, no_wrap=True)]) - assert cut.startswith(" ") and cut.lstrip().startswith("⋯"), step + assert cut[0] in ("…", CRACK_HEAD) and len(cut) == width, step screen.handle("left") # the step that brings the walk's start back into view assert screen._trail_scroll == limit @@ -661,9 +675,9 @@ def test_walk_trail_scrolls_a_hop_at_a_time_off_its_tail() -> None: screen, width = _walked_chain(8) trail = _plain([render_to_ansi(screen._trail_text(width), width, no_wrap=True)]) - # At rest the walk is flush right: the focus shows, the head is behind a leading ⋯. + # At rest the walk fills the lane: the focus shows, the start is cropped off the left. assert "Repeater-08" in trail and "Homestead" not in trail - assert trail.lstrip().startswith("⋯") + assert trail[0] in ("…", CRACK_HEAD) and len(trail) == width assert screen._trail_scroll == 0 screen.handle("left")