fix a handful of test errors

Author: Archmonger

MANIFEST.in

@@ -1,2 +1,2 @@
-include src/reactpy_router/bundle.js
+recursive-include src/reactpy_router/static *
 include src/reactpy_router/py.typed

docs/examples/python/nested-routes.py

@@ -40,7 +40,10 @@ def home():
 
 @component
 def all_messages():
-    last_messages = {", ".join(msg["with"]): msg for msg in sorted(message_data, key=lambda m: m["id"])}
+    last_messages = {
+        ", ".join(msg["with"]): msg
+        for msg in sorted(message_data, key=lambda m: m["id"])
+    }
     return html.div(
         html.h1("All Messages 💬"),
         html.ul(

docs/examples/python/route-parameters.py

@@ -39,7 +39,10 @@ def home():
 
 @component
 def all_messages():
-    last_messages = {", ".join(msg["with"]): msg for msg in sorted(message_data, key=lambda m: m["id"])}
+    last_messages = {
+        ", ".join(msg["with"]): msg
+        for msg in sorted(message_data, key=lambda m: m["id"])
+    }
     return html.div(
         html.h1("All Messages 💬"),
         html.ul(

src/js/src/index.js

@@ -13,7 +13,7 @@ export function bind(node) {
 }
 
 export function History({ onChange }) {
-    // capture changes to the browser's history
+    // Capture changes to the browser's history
     React.useEffect(() => {
         const listener = () => {
             onChange({

src/reactpy_router/__init__.py

@@ -3,7 +3,14 @@
 
 
 from .converters import CONVERTERS
-from .core import create_router, link, route, router_component, use_params, use_search_params
+from .core import (
+    create_router,
+    link,
+    route,
+    router_component,
+    use_params,
+    use_search_params,
+)
 from .resolvers import Resolver
 from .routers import browser_router
 from .types import Route, RouteCompiler, RouteResolver

src/reactpy_router/core.py

@@ -62,15 +62,23 @@ def router_component(
 
     match = use_memo(lambda: _match_route(resolvers, location, select))
 
-    if match is not None:
-        element, params = match
-        return html.div(
-            ConnectionContext(
-                _route_state_context(element, value=_RouteState(set_location, params)),
-                value=Connection(old_conn.scope, location, old_conn.carrier),
+    if match:
+        route_elements = [
+            _route_state_context(
+                html.div(
+                    element,  # type: ignore
+                    key=f"{location.pathname}{select}{params}{element}{id(element)}",
+                ),
+                value=_RouteState(set_location, params),
+            )
+            for element, params in match
+        ]
+        return ConnectionContext(
+            History(  # type: ignore
+                {"on_change": lambda event: set_location(Location(**event))}
             ),
-            History({"on_change": lambda event: set_location(Location(**event))}),
-            key=location.pathname + select,
+            route_elements,
+            value=Connection(old_conn.scope, location, old_conn.carrier),
         )
 
     return None
@@ -87,7 +95,9 @@ def link(*children: VdomChild, to: str, **attributes: Any) -> VdomDict:
         "onClick": lambda event: set_location(Location(**event)),
         "id": uuid,
     }
-    return html._(html.a(attrs, *children), html.script(link_js_content.replace("UUID", uuid)))
+    return html._(
+        html.a(attrs, *children), html.script(link_js_content.replace("UUID", uuid))
+    )
 
 
 def use_params() -> dict[str, Any]:
@@ -136,28 +146,34 @@ def _iter_routes(routes: Sequence[R]) -> Iterator[R]:
 
 
 def _match_route(
-    compiled_routes: Sequence[RouteResolver], location: Location, select: Literal["first", "all"]
-) -> tuple[Any, dict[str, Any]] | None:
+    compiled_routes: Sequence[RouteResolver],
+    location: Location,
+    select: Literal["first", "all"],
+) -> list[tuple[Any, dict[str, Any]]]:
     matches = []
 
     for resolver in compiled_routes:
         match = resolver.resolve(location.pathname)
         if match is not None:
             if select == "first":
-                return match
+                return [match]
             matches.append(match)
 
     if not matches:
         _logger.debug("No matching route found for %s", location.pathname)
 
-    return matches or None
+    return matches
 
 
 History = export(
-    module_from_file("reactpy-router", file=Path(__file__).parent / "bundle.js"),
+    module_from_file(
+        "reactpy-router", file=Path(__file__).parent / "static" / "bundle.js"
+    ),
     ("History"),
 )
-link_js_content = (Path(__file__).parent / "js" / "Link.js").read_text(encoding="utf-8")
+link_js_content = (Path(__file__).parent / "static" / "link.js").read_text(
+    encoding="utf-8"
+)
 
 
 @dataclass

src/reactpy_router/resolvers.py

@@ -19,22 +19,25 @@ def __init__(
     ) -> None:
         self.element = route.element
         self.pattern, self.converter_mapping = self.parse_path(route.path)
-        self.converters = converters or CONVERTERS
+        self.registered_converters = converters or CONVERTERS
         self.key = self.pattern.pattern
         self.param_regex = re.compile(param_pattern)
         self.match_any = match_any_identifier
 
     def parse_path(self, path: str) -> tuple[re.Pattern[str], ConverterMapping]:
+        # Convert path to regex pattern, then interpret using registered converters
         pattern = "^"
         last_match_end = 0
         converter_mapping: ConverterMapping = {}
         for match in self.param_regex.finditer(path):
             param_name = match.group("name")
             param_type = (match.group("type") or "str").strip(":")
             try:
-                param_conv = self.converter_mapping[param_type]
+                param_conv = self.registered_converters[param_type]
             except KeyError as e:
-                raise ValueError(f"Unknown conversion type {param_type!r} in {path!r}") from e
+                raise ValueError(
+                    f"Unknown conversion type {param_type!r} in {path!r}"
+                ) from e
             pattern += re.escape(path[last_match_end : match.start()])
             pattern += f"(?P<{param_name}>{param_conv['regex']})"
             converter_mapping[param_name] = param_conv["func"]

src/reactpy_router/js/Link.js renamed to src/reactpy_router/static/link.js

@@ -38,7 +38,9 @@ def __hash__(self) -> int:
 class Router(Protocol[R_contra]):
     """Return a component that renders the first matching route"""
 
-    def __call__(self, *routes: R_contra, select: Literal["first", "all"]) -> ComponentType:
+    def __call__(
+        self, *routes: R_contra, select: Literal["first", "all"] = "first"
+    ) -> ComponentType:
         ...
 
 

src/reactpy_router/types.py

@@ -2,7 +2,7 @@
 
 from reactpy import Ref, component, html, use_location
 from reactpy.testing import DisplayFixture
-from reactpy_router import link, route, routers, use_params, use_search_params
+from reactpy_router import browser_router, link, route, use_params, use_search_params
 
 
 async def test_simple_router(display: DisplayFixture):
@@ -18,7 +18,7 @@ def check_location():
 
     @component
     def sample():
-        return routers.browser_router(
+        return browser_router(
             make_location_check("/a"),
             make_location_check("/b"),
             make_location_check("/c"),
@@ -40,8 +40,8 @@ def sample():
         root_element = await display.root_element()
     except AttributeError:
         root_element = await display.page.wait_for_selector(
-            f"#display-{display._next_view_id}",
-            state="attached",  # type: ignore
+            f"#display-{display._next_view_id}",  # type: ignore
+            state="attached",
         )
 
     assert not await root_element.inner_html()
@@ -50,7 +50,7 @@ def sample():
 async def test_nested_routes(display: DisplayFixture):
     @component
     def sample():
-        return routers.browser_router(
+        return browser_router(
             route(
                 "/a",
                 html.h1({"id": "a"}, "A"),
@@ -79,7 +79,7 @@ async def test_navigate_with_link(display: DisplayFixture):
     @component
     def sample():
         render_count.current += 1
-        return routers.browser_router(
+        return browser_router(
             route("/", link("Root", to="/a", id="root")),
             route("/a", link("A", to="/b", id="a")),
             route("/b", link("B", to="/c", id="b")),
@@ -110,7 +110,7 @@ def check_params():
 
     @component
     def sample():
-        return routers.browser_router(
+        return browser_router(
             route(
                 "/first/{first:str}",
                 check_params(),
@@ -146,7 +146,7 @@ def check_query():
 
     @component
     def sample():
-        return routers.browser_router(route("/", check_query()))
+        return browser_router(route("/", check_query()))
 
     await display.show(sample)
 
@@ -158,7 +158,7 @@ def sample():
 async def test_browser_popstate(display: DisplayFixture):
     @component
     def sample():
-        return routers.browser_router(
+        return browser_router(
             route("/", link("Root", to="/a", id="root")),
             route("/a", link("A", to="/b", id="a")),
             route("/b", link("B", to="/c", id="b")),
@@ -190,7 +190,7 @@ def sample():
 async def test_relative_links(display: DisplayFixture):
     @component
     def sample():
-        return routers.browser_router(
+        return browser_router(
             route("/", link("Root", to="/a", id="root")),
             route("/a", link("A", to="/a/b", id="a")),
             route("/a/b", link("B", to="../a/b/c", id="b")),

tests/test_core.py

@@ -2,31 +2,32 @@
 import uuid
 
 import pytest
-from reactpy_router.routers import parse_path
+from reactpy_router import Resolver, route
 
 
 def test_parse_path():
-    assert parse_path("/a/b/c") == (re.compile("^/a/b/c$"), {})
-    assert parse_path("/a/{b}/c") == (
+    resolver = Resolver(route("/", None))
+    assert resolver.parse_path("/a/b/c") == (re.compile("^/a/b/c$"), {})
+    assert resolver.parse_path("/a/{b}/c") == (
         re.compile(r"^/a/(?P<b>[^/]+)/c$"),
         {"b": str},
     )
-    assert parse_path("/a/{b:int}/c") == (
+    assert resolver.parse_path("/a/{b:int}/c") == (
         re.compile(r"^/a/(?P<b>\d+)/c$"),
         {"b": int},
     )
-    assert parse_path("/a/{b:int}/{c:float}/c") == (
+    assert resolver.parse_path("/a/{b:int}/{c:float}/c") == (
         re.compile(r"^/a/(?P<b>\d+)/(?P<c>\d+(\.\d+)?)/c$"),
         {"b": int, "c": float},
     )
-    assert parse_path("/a/{b:int}/{c:float}/{d:uuid}/c") == (
+    assert resolver.parse_path("/a/{b:int}/{c:float}/{d:uuid}/c") == (
         re.compile(
             r"^/a/(?P<b>\d+)/(?P<c>\d+(\.\d+)?)/(?P<d>[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-["
             r"0-9a-f]{4}-[0-9a-f]{12})/c$"
         ),
         {"b": int, "c": float, "d": uuid.UUID},
     )
-    assert parse_path("/a/{b:int}/{c:float}/{d:uuid}/{e:path}/c") == (
+    assert resolver.parse_path("/a/{b:int}/{c:float}/{d:uuid}/{e:path}/c") == (
         re.compile(
             r"^/a/(?P<b>\d+)/(?P<c>\d+(\.\d+)?)/(?P<d>[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-["
             r"0-9a-f]{4}-[0-9a-f]{12})/(?P<e>.+)/c$"
@@ -36,18 +37,21 @@ def test_parse_path():
 
 
 def test_parse_path_unkown_conversion():
+    resolver = Resolver(route("/", None))
     with pytest.raises(ValueError):
-        parse_path("/a/{b:unknown}/c")
+        resolver.parse_path("/a/{b:unknown}/c")
 
 
 def test_parse_path_re_escape():
     """Check that we escape regex characters in the path"""
-    assert parse_path("/a/{b:int}/c.d") == (
+    resolver = Resolver(route("/", None))
+    assert resolver.parse_path("/a/{b:int}/c.d") == (
         #                          ^ regex character
         re.compile(r"^/a/(?P<b>\d+)/c\.d$"),
         {"b": int},
     )
 
 
 def test_match_star_path():
-    assert parse_path("*") == (re.compile("^.*$"), {})
+    resolver = Resolver(route("/", None))
+    assert resolver.parse_path("*") == (re.compile("^.*$"), {})