From 538b0a5a693f6a5e5bc4e72d16b5aa978dec0e2c Mon Sep 17 00:00:00 2001 From: Jean-Pierre Martineau Date: Tue, 3 Nov 2026 03:05:06 -0500 Subject: [PATCH] The map's find filter also matches a node's place MapMarker carries a place, open_map reads it for each marker, and both the screen and the renderer match label or place through MapMarker.matches. Co-Authored-By: Claude Haiku 5.5 --- meshterm/core/models.py | 13 +++++++++ meshterm/ui/map_render.py | 4 +-- meshterm/ui/map_screen.py | 27 +++++++++++++++++- tests/test_contact_places.py | 53 ++++++++++++++++++++++++++++++++++++ 4 files changed, 94 insertions(+), 3 deletions(-) diff --git a/meshterm/core/models.py b/meshterm/core/models.py index 58fac3c..b7aad7f 100644 --- a/meshterm/core/models.py +++ b/meshterm/core/models.py @@ -411,6 +411,9 @@ class MapMarker: key: The key of the node in hex (the longest form that the caller has). The hue of the label comes from this key. ``None`` leaves the label in the muted grey for a node with no key. + place: The full label of the place of the node (``Villeray, Montréal``), or ``""`` + when the caller has none. The map does not draw it. The find filter of the map + matches it, in the same way as it matches the label. """ label: str @@ -420,6 +423,16 @@ class MapMarker: is_self: bool = False detail: str = "" key: str | None = None + place: str = "" + + def matches(self, needle: str) -> bool: + """Whether the find filter ``needle`` matches the label or the place of this node. + + Args: + needle: The text that the user typed, already case-folded. An empty ``needle`` + matches each node. + """ + return not needle or needle in self.label.casefold() or needle in self.place.casefold() def _rank(self) -> int: """Draw order: our node above the repeaters, and the repeaters above leaf nodes.""" diff --git a/meshterm/ui/map_render.py b/meshterm/ui/map_render.py index 586d97d..52bccb9 100644 --- a/meshterm/ui/map_render.py +++ b/meshterm/ui/map_render.py @@ -347,7 +347,7 @@ def render_map( markers: The mesh nodes to put on top. max_labels: The maximum number of basemap labels to place, to keep the map readable. - find: A live node-name filter. Markers whose label contains it (case-insensitive) + find: A live node filter. Markers whose label or place contains it (case-insensitive) draw with bright white labels, and the other markers dim to context with no label. When it is empty, each node draws normally. ghost: Ground from an earlier raster to put down first, reprojected onto this @@ -796,7 +796,7 @@ def _draw_nodes( ix, iy = int(round(x)), int(round(y)) if not (0 <= ix < viewport.dot_w and 0 <= iy < viewport.dot_h): continue - matched = not needle or needle in marker.label.casefold() + matched = marker.matches(needle) placed.append((marker, ix, iy, matched)) # Matches draw after (over) the dimmed nodes that do not match, at any rank. Thus the diff --git a/meshterm/ui/map_screen.py b/meshterm/ui/map_screen.py index c421741..1e81375 100644 --- a/meshterm/ui/map_screen.py +++ b/meshterm/ui/map_screen.py @@ -33,6 +33,7 @@ a blank grid. The map still works, but it has no streets. from __future__ import annotations import asyncio +import dataclasses import math from collections import OrderedDict from collections.abc import Callable @@ -51,6 +52,7 @@ from .tui.screen import Screen if TYPE_CHECKING: from ..context import AppContext + from ..core.places import Place #: The fraction of the viewport that one (coarse) pan key press moves. _PAN_STEP = 0.30 @@ -704,7 +706,7 @@ class MapScreen(Screen): needle = self._filter.strip().casefold() if not needle: return self._markers - return [m for m in self._markers if needle in m.label.casefold()] + return [m for m in self._markers if m.matches(needle)] def _title(self, vp: Viewport) -> str: """A compact status title: the zoom, the node count (or the find matches), and the scale. @@ -1462,6 +1464,26 @@ def basemap_source(ctx: AppContext) -> BasemapSource: return ctx.basemap_source +def with_places( + markers: list[MapMarker], place_of: Callable[[str | None], Place | None] +) -> list[MapMarker]: + """Return copies of ``markers`` that carry the place of each node (the find filter reads it). + + Args: + markers: The located nodes. The function does not change them. + place_of: Gives the place of a key or a key prefix, or ``None`` (for example, + :meth:`~meshterm.services.places.PlaceService.get`). + + Returns: + The new markers, in the same order. A node with no place has an empty ``place``. + """ + out = [] + for marker in markers: + place = place_of(marker.key) if marker.key else None + out.append(dataclasses.replace(marker, place=(place.label if place else ""))) + return out + + async def open_map( ctx: AppContext, markers: list[MapMarker], @@ -1499,6 +1521,9 @@ async def open_map( if not isinstance(ctx.ui, TuiUi): # pragma: no cover - guarded by the menu-only caller raise RuntimeError("the interactive map is only available in the menu") session = ctx.ui.session + # The find filter also matches the place of a node. The places are read now, so that a + # place that the finder stored since the caller made the markers is in the filter. + markers = with_places(markers, ctx.places.get) source = basemap_source(ctx) # Resolve the tile template and zoom in a worker thread, so the UI thread never blocks. max_zoom = await asyncio.to_thread(lambda: source.max_zoom) diff --git a/tests/test_contact_places.py b/tests/test_contact_places.py index 4b9ecd7..d8c589b 100644 --- a/tests/test_contact_places.py +++ b/tests/test_contact_places.py @@ -300,3 +300,56 @@ def test_plain_face_has_a_place_column_before_key() -> None: assert "Villeray, Montréal" in alice assert alice.index("Villeray") < alice.index(_ALICE) assert carl.split()[-2] == "-" and carl.split()[-1] == _CARL + + +# -- part 4: the map filter ----------------------------------------------------------- + + +def test_marker_matches_its_label_or_its_place() -> None: + """The find filter of the map matches the label or the place, in any case.""" + from meshterm.core.models import MapMarker + + marker = MapMarker("Alice", 45.5, -73.6, place="Villeray, Montréal") + assert marker.matches("") + assert marker.matches("ali") + assert marker.matches("villeray") + assert marker.matches("montréal") + assert not marker.matches("verdun") + assert not MapMarker("Alice", 45.5, -73.6).matches("villeray") + + +def test_with_places_stamps_a_copy_of_each_marker() -> None: + """``with_places`` reads the place of each key, and does not change the given markers.""" + from meshterm.core.models import MapMarker + from meshterm.ui.map_screen import with_places + + original = [ + MapMarker("Alice", 45.5, -73.6, key=_ALICE), + MapMarker("Carl", 45.6, -73.7, key=_CARL), + MapMarker("Nokey", 45.7, -73.8), + ] + stamped = with_places(original, _places().get) + assert [m.place for m in stamped] == ["Villeray, Montréal", "", ""] + assert [m.place for m in original] == ["", "", ""] + assert [m.label for m in stamped] == ["Alice", "Carl", "Nokey"] + + +def test_map_find_matches_a_place() -> None: + """Typed text narrows the map to the nodes whose place matches it.""" + from meshterm.core.models import MapMarker + from meshterm.ui.map_screen import MapScreen, with_places + from tests.test_map import _StubSession, _StubSource + + markers = with_places( + [ + MapMarker("Alice", 45.5, -73.6, key=_ALICE), + MapMarker("Bob", 45.6, -73.7, key=_BOB), + MapMarker("Carl", 45.7, -73.8, key=_CARL), + ], + _places().get, + ) + screen = MapScreen(_StubSession(80, 24), markers, _StubSource(), 14) + screen.render_body(80) # the first paint makes the viewport that a key needs + for char in "villeray": + screen.handle("text", char) + assert [m.label for m in screen._matches()] == ["Alice"] # noqa: SLF001