diff --git a/meshterm/ui/pathline.py b/meshterm/ui/pathline.py index 0387024..5b15258 100644 --- a/meshterm/ui/pathline.py +++ b/meshterm/ui/pathline.py @@ -34,9 +34,10 @@ drawn*, so every surface the survey found can eventually route through it: ``highlighted_hash`` two-tone), the ``dim`` fade for resolved return legs, and an explicit style override for context colourings that outrank identity. Chips keep the exact same words as arrows — only colours and separators change — so a route - reads identically whichever mode drew it. A hop with *no* label is drawn as pure - seam — the arrow alone, no chip, no word — which is how a surface says "this end - is us" without spending cells on saying so (see ``bare_self``). + reads identically whichever mode drew it. A hop with *no* label draws as its seam + and (in chip mode) the padding every chip wears — a bit of arrow and a stub of its + own colour, no word — which is how a surface says "this end is us" without spending + cells on saying so (see ``bare_self``). Existing call sites still render through ``path_text``; migrating them here is a separate, per-surface pass. The composer's insertion cursor is the one deliberate @@ -56,16 +57,13 @@ from ..core.models import LOCAL_DEVICE_LABEL from .termfont import powerline_enabled from .theme import MESH_THEME, node_style -#: The powerline solid right-pointing triangle (U+E0B0) — the male point every chip -#: seam is drawn with, deliberately from the *core* set so every recommended font -#: qualifies (the rounded caps at U+E0B4+ exist only in full Nerd Font patches). +#: The powerline solid right-pointing triangle (U+E0B0) — the only glyph the widget +#: draws, seam and closing edge alike, deliberately from the *core* set so every +#: recommended font qualifies (the rounded caps at U+E0B4+ exist only in full Nerd +#: Font patches). A path only ever flows one way, so the point only ever faces right; +#: what changes is whether it lands on a field (a seam) or on the page (an edge). POWERLINE_SEP = "\ue0b0" -#: Its mirror (U+E0B2, core too): the female point opening a *wrapped* line's first -#: chip, so a continuation never reads as a fresh path. Only the very first chip of the -#: whole line keeps the plain square left edge. -POWERLINE_CAP = "\ue0b2" - #: The plain-mode joining arrow, exactly as ``path_text`` draws it today. _ARROW = " → " @@ -94,9 +92,9 @@ class PathHop: Attributes: label: What is shown — a resolved name, or a hash standing as the node's identity (set ``lit_bytes`` for the two-tone prefix in that case). An - empty label (with no annotation) makes the hop *bare*: it draws as its - seam alone — a bit of arrow, no chip, no word — which is how a route - whose ends are obviously us says so without spending cells on it. + empty label (with no annotation) makes the hop *bare*: its seam and its + padding are all that is drawn — a bit of arrow, no word — which is how a + route whose ends are obviously us says so without spending cells on it. key: Any known prefix of the node's key/hash — picks the hash-derived hue (its first byte, so every prefix agrees). ``None`` renders muted/grey: colour is reserved for keyed identities. @@ -234,10 +232,11 @@ class PathLine: content column is uniformly ``width - indent`` wide. Plain-mode lines that continue end with the separator's own mark — a trailing ``→`` for an arrow-joined path, the bare ``,`` for a comma-joined wire spec — the "path - goes on" cue; chip lines always close with their pointed edge and *open*, from - the second line down, with the female one (:data:`POWERLINE_CAP`), so a - continuation is never mistakable for a path starting over. A single hop wider - than the content column stands alone, truncated with an ellipsis. + goes on" cue; chip lines always close with their pointed edge and, from the + second line down, open by redrawing the seam the break interrupted — the point + arriving out of the previous line's last fill — so a continuation is never + mistakable for a path starting over. A single hop wider than the content column + stands alone, truncated with an ellipsis. Where the breaks fall is chosen for how it *reads* (see :meth:`_flow` and :meth:`_turn_seam`), not by cramming each line full: the fold takes the @@ -274,12 +273,14 @@ class PathLine: lines: list[Text] = [] base = 0 # the global index of the group's first hop, for cursor mapping + carried: Optional[str] = None # the fill a continuation reopens its seam from for i, group in enumerate(groups): local: Optional[int] = None if cursor_arrow is not None and 0 <= cursor_arrow - base < len(group) - 1: local = cursor_arrow - base line = Text() if i == 0 else Text(" " * indent) - body = self._render(group, cursor_arrow=local, force_plain=plain, cap=bool(i)) + body = self._render(group, cursor_arrow=local, force_plain=plain, cap=carried) + carried = None if plain else self._chip_fill(group[-1]) # A lone hop too wide for the column is truncated — leaving room for the # cue it still has to carry, so even that line stays inside the width. A # column too narrow to hold both drops the cue: content wins the cells. @@ -315,18 +316,19 @@ class PathLine: ``(cells, join, tail, lead)`` — each hop's cells, the cells one join between two hops costs, the cells a line always closes with (the chip mode's pointed edge; nothing in arrow mode), and the cells every line *after the first* - opens with (chip mode's female cap). + opens with (chip mode's reopened seam). Note: Joins are measured at their full width even where a bare neighbour trims one - (:meth:`_join`), and the closing edge is charged even to a line ending bare — - an over-estimate of a cell, which packs a hair early and never overflows. + (:meth:`_join`) — an over-estimate of a cell, which packs a hair early and + never overflows. """ if plain: widths = [self._plain_hop(hop).cell_len for hop in hops] return widths, cell_len(self._separator), 0, 0 widths = [self._chip(hop, self._chip_fill(hop)).cell_len for hop in hops] - return widths, cell_len(POWERLINE_SEP), cell_len(POWERLINE_SEP), cell_len(POWERLINE_CAP) + sep = cell_len(POWERLINE_SEP) + return widths, sep, sep, sep @staticmethod def _fill( @@ -349,7 +351,7 @@ class PathLine: last: Cells held back on a line ending at the *final* hop — ``0`` when the path really ends there (nothing follows to cue), ``reserve`` when this is only one leg of a path that goes on. - lead: Cells every line but the first opens with (the female cap). + lead: Cells every line but the first opens with (the reopened seam). Returns: How many hops each line takes; a hop too wide for ``budget`` gets a line of @@ -442,7 +444,7 @@ class PathLine: *, cursor_arrow: Optional[int] = None, force_plain: bool = False, - cap: bool = False, + cap: Optional[str] = None, ) -> Text: """Join ``hops`` in the effective mode (plain whenever a cursor is asked). @@ -505,38 +507,40 @@ class PathLine: text.append(f" ({hop.annotation})", style=note_style) return text - def _render_chips(self, hops: list[PathHop], *, cap: bool = False) -> Text: + def _render_chips(self, hops: list[PathHop], *, cap: Optional[str] = None) -> Text: """Powerline chips: each hop filled with its hue, seams interlocked. Args: hops: The hops of this one line, in order. - cap: Open the line with the female point (:data:`POWERLINE_CAP`) in the - first chip's own fill — the mark of a wrapped continuation, where the - whole line's very first chip instead keeps its square left edge. + cap: The fill of the chip this line continues from — a wrapped line opens + by redrawing the seam the break interrupted, so its first chip is + landed *into* rather than started. ``None`` (the whole line's first + chip) keeps the square left edge. """ fills = [self._chip_fill(hop) for hop in hops] text = Text() - if cap: - text.append(POWERLINE_CAP, style=fills[0]) + if cap is not None: + text.append(POWERLINE_SEP, style=self._seam(cap, fills[0])) for i, hop in enumerate(hops): if i: - # Two ways to draw a seam. Interlocked — the point in the previous - # fill *on* the next one — is the tighter look and the default. But - # two neighbours can land on the same fill (a hue collision, a run of - # dimmed hops, two keyless greys), and then an interlocked seam is - # invisible: one fused block where the route has two nodes. Those get - # the open seam instead — the point over the page, leaving the sliver - # of background that says where one chip ends and the next begins. A - # bare hop takes it too: it has no field for the arrow to land in, so - # that lone arrowhead *is* the endpoint. - fused = _bare(hop) or fills[i - 1] == fills[i] - style = fills[i - 1] if fused else f"{fills[i - 1]} on {fills[i]}" - text.append(POWERLINE_SEP, style=style) + text.append(POWERLINE_SEP, style=self._seam(fills[i - 1], fills[i])) text.append_text(self._chip(hop, fills[i])) - if not _bare(hops[-1]): - text.append(POWERLINE_SEP, style=fills[-1]) # the pointed edge into the page + text.append(POWERLINE_SEP, style=fills[-1]) # the pointed edge into the page return text + @staticmethod + def _seam(before: str, after: str) -> str: + """One seam's style: interlocked into the next fill, or open onto the page. + + Two ways to draw the point. Interlocked — the previous fill *on* the next + one — is the tighter look and the default. But two neighbours can land on the + same fill (a hue collision, a run of dimmed hops, two keyless greys), and then + an interlock is invisible: one fused block where the route has two nodes. + Those open onto the page instead, the taper leaving the sliver of background + that says where one chip ends and the next begins. + """ + return before if before == after else f"{before} on {after}" + def _chip_fill(self, hop: PathHop) -> str: """A chip's fill colour: override, white you, dim slate, hue, keyless grey.""" if hop.style: @@ -554,10 +558,9 @@ class PathLine: def _chip(self, hop: PathHop, fill: str) -> Text: """One chip: same words as arrow mode, dark ink on the identity fill. - A bare hop draws no chip at all — its seam alone carries it (see :meth:`_render_chips`). + A bare hop keeps the padding every chip wears — it just has no words between + them, so it reads as a stub of its own colour rather than as nothing at all. """ - if _bare(hop): - return Text() ink = _DIM_FG if hop.dim else _CHIP_FG soft = _DIM_FG if hop.dim else _CHIP_FG_SOFT text = Text() @@ -603,8 +606,8 @@ def path_line( so a call site swaps builders without changing what it says — a named hop reads ``Name`` (annotated ``Name (3d)`` under ``show_hash``), an unnamed hop its prefix-lit hash (or its muted identity hash under ``hash_as_name``), ``None`` is - our own device in white — or, under ``bare_self``, its bit of arrow and nothing - else — and ``dim_from`` fades a resolved tail. The plain rendering + our own device in white — or, under ``bare_self``, its bit of arrow and no words + at all — and ``dim_from`` fades a resolved tail. The plain rendering is character- and style-identical to ``path_text``; what the swap buys is the :class:`PathLine` shapes (ellipsized / wrapped) and the powerline mode. diff --git a/meshterm/ui/trace_screen.py b/meshterm/ui/trace_screen.py index c610e6c..eae47d4 100644 --- a/meshterm/ui/trace_screen.py +++ b/meshterm/ui/trace_screen.py @@ -1213,13 +1213,16 @@ def _scenario_path( :class:`~meshterm.services.topology.PathScenario` stores), so the row reads as the whole route rather than a fragment the reader has to mentally close. Renders through the shared path widget, so every hop wears its own key hue (an - unnamed hop its prefix-lit hash) instead of the old single-colour smear. + unnamed hop its prefix-lit hash) instead of the old single-colour smear — and, as + in the route lane above it, our own end goes bare: every candidate starts from us, + so the word would be the same on every row and the cells are the candidates'. """ route = path_line( [None, *scenario.hops, target_id], topo.display_name, prefix_bytes=width_bytes, self_name=device_label, + bare_self=True, ) return route.text() diff --git a/tests/test_live_screens.py b/tests/test_live_screens.py index f770cef..0acccbd 100644 --- a/tests/test_live_screens.py +++ b/tests/test_live_screens.py @@ -1147,7 +1147,8 @@ def _scenario_topo() -> object: def test_scenario_path_leads_and_ends_with_us_and_the_target() -> None: - """The pathline names the whole boomerang leg, not just the stored intermediate hops.""" + """The pathline draws the whole boomerang leg, not just the stored intermediate + hops — our own end bare, since every candidate starts from us.""" topo = _scenario_topo() scenario = PathScenario( label="observed path", hops=("3d63c6429436",), source="observed", score=1.0, @@ -1155,17 +1156,17 @@ def test_scenario_path_leads_and_ends_with_us_and_the_target() -> None: text = _scenario_path( scenario, topo, "f2c24f54551e", device_label="YUL-Me", width_bytes=1 ) - assert text.plain == "YUL-Me → Hub → Far" + assert text.plain == "→ Hub → Far" def test_scenario_path_direct_scenario_still_names_both_endpoints() -> None: - """A direct (no-repeaters) scenario's pathline is just us and the target — no gap.""" + """A direct (no-repeaters) scenario's pathline is just our arrow and the target.""" topo = _scenario_topo() scenario = PathScenario(label="direct", hops=(), source="direct", score=0.0) text = _scenario_path( scenario, topo, "f2c24f54551e", device_label="YUL-Me", width_bytes=1 ) - assert text.plain == "YUL-Me → Far" + assert text.plain == "→ Far" def test_scenario_detail_carries_provenance_snr_and_samples() -> None: diff --git a/tests/test_pathline.py b/tests/test_pathline.py index 0cf113f..cd96867 100644 --- a/tests/test_pathline.py +++ b/tests/test_pathline.py @@ -13,9 +13,7 @@ import random import pytest import meshterm.ui.pathline as pathline -from meshterm.ui.pathline import ( - POWERLINE_CAP, POWERLINE_SEP, PathHop, PathLine, _style_hex, path_line, -) +from meshterm.ui.pathline import POWERLINE_SEP, PathHop, PathLine, _style_hex, path_line from meshterm.ui.theme import node_style from meshterm.ui.widgets import path_text @@ -296,15 +294,20 @@ def test_wrapped_carries_the_cursor_even_onto_a_line_break() -> None: assert not any(str(s.style) == "selected" for s in on_break[1].spans) -def test_wrapped_chip_lines_close_male_and_open_female() -> None: +def test_wrapped_chip_lines_reopen_the_seam_the_break_interrupted() -> None: """Chip wrapping never splits a chip; every line ends on the pointed edge, and - every line *but the first* opens on its mirror — the continuation's own mark, so - only the path's very first chip shows a square left edge.""" - hops = [PathHop(label) for label in ("AAAA", "BBBB", "CCCC", "DDDD")] + every line *but the first* opens on the seam the break cut — the point arriving + out of the previous line's last fill, so only the path's very first chip shows a + square left edge. The point always faces the way the path flows.""" + hops = [PathHop(label, key=key) for label, key in + (("AAAA", "aa"), ("BBBB", "77"), ("CCCC", "3d"), ("DDDD", "f2"))] lines = PathLine(hops, mode="powerline").wrapped(18, indent=2) assert len(lines) == 2 assert lines[0].plain.startswith(" AAAA") # the square edge: this is the start - assert lines[1].plain.startswith(" " + POWERLINE_CAP) # …and this is a carry-on + assert lines[1].plain[2] == POWERLINE_SEP # …and this is a carry-on + carried = next(s for s in lines[1].spans if s.start == 2) + assert str(carried.style) == \ + f"{_style_hex(node_style('77'))} on {_style_hex(node_style('3d'))}" assert all(line.plain.endswith(POWERLINE_SEP) for line in lines) assert all(line.cell_len <= 18 for line in lines) @@ -329,24 +332,25 @@ def test_same_fill_neighbours_get_the_open_seam() -> None: assert " on " not in gaps[0] # a dimmed return leg reads as hops, not one bar -def test_bare_hops_draw_as_their_seam_alone() -> None: - """An empty label spends no cells: arrow mode drops the padding it would have sat - in, chip mode gives it no chip at all — the arrow into the page *is* the hop.""" +def test_bare_hops_keep_their_padding_and_spend_no_words() -> None: + """An empty label costs no words: arrow mode drops the padding it would have sat + in, chip mode keeps only the stub of colour every chip is padded with.""" hops = [PathHop("", you=True), PathHop("Alice", key="aa"), PathHop("", you=True)] assert PathLine(hops, mode="plain").text().plain == "→ Alice →" chips = PathLine(hops, mode="powerline").text() - assert chips.plain == POWERLINE_SEP + " Alice " + POWERLINE_SEP + hue = _style_hex(node_style("aa")) + assert chips.plain == f" {POWERLINE_SEP} Alice {POWERLINE_SEP} {POWERLINE_SEP}" styles = [str(span.style) for span in chips.spans] - # The leading seam is us pointing into Alice's field; the trailing one is Alice's - # own point into the page — the closing edge a named tail would have added. - assert styles[0] == f"#ffffff on {_style_hex(node_style('aa'))}" - assert styles[-1] == _style_hex(node_style("aa")) + assert styles[0] == "on #ffffff" # our stub: the you white, two cells of padding + assert f"#ffffff on {hue}" in styles # the seam out of it, into Alice's field + assert f"{hue} on #ffffff" in styles # and back out of Alice, into ours + assert styles[-1] == "#ffffff" # the closing edge, pointing into the page def test_bare_self_endpoints_survive_wrapping() -> None: """``bare_self`` strips our name and hash from a route's ends; a line that wraps - still opens on the female point, and a widowed bare end still draws one.""" + still opens on the seam it broke, and every line still fits its column.""" hops = [None, *(f"{i:02x}aa" for i in range(6)), None] line = path_line(hops, prefix_bytes=2, self_name="Me", show_hash=True, device_hash="a1b2", bare_self=True, mode="plain") @@ -357,5 +361,5 @@ def test_bare_self_endpoints_survive_wrapping() -> None: lines = path_line(hops, prefix_bytes=2, self_name="Me", bare_self=True, mode="powerline").wrapped(28, indent=2) assert len(lines) > 1 - assert all(line.plain.startswith(" " + POWERLINE_CAP) for line in lines[1:]) + assert all(line.plain[2] == POWERLINE_SEP for line in lines[1:]) assert all(line.cell_len <= 28 for line in lines)