improve coverage

Author: rmorshea

idom_router/router.py

@@ -2,19 +2,20 @@
 
 import re
 from dataclasses import dataclass
-from fnmatch import translate as fnmatch_translate
 from pathlib import Path
-from typing import Any, Callable, Iterator, Sequence
+from urllib.parse import parse_qs
+from typing import Any, Callable, Iterator, Sequence, TypeVar, overload
 
-from idom import component, create_context, use_context, use_state
+from idom import component, create_context, use_context, use_state, use_memo
 from idom.core.types import VdomAttributesAndChildren, VdomDict
 from idom.core.vdom import coalesce_attributes_and_children
 from idom.types import BackendImplementation, ComponentType, Context, Location
 from idom.web.module import export, module_from_file
+from starlette.routing import compile_path
 
 try:
     from typing import Protocol
-except ImportError:
+except ImportError:  # pragma: no cover
     from typing_extensions import Protocol
 
 
@@ -32,39 +33,42 @@ def configure(
         use_location = implementation
     else:
         raise TypeError(
-            "Expected a BackendImplementation or "
-            f"`use_location` hook, not {implementation}"
+            "Expected a 'BackendImplementation' or "
+            f"'use_location' hook, not {implementation}"
         )
 
     @component
-    def Router(*routes: Route) -> ComponentType | None:
+    def Router(*routes: Route | Sequence[Route]) -> ComponentType | None:
         initial_location = use_location()
         location, set_location = use_state(initial_location)
-        for p, r in _compile_routes(routes):
-            match = p.match(location.pathname)
+        compiled_routes = use_memo(lambda: _compile_routes(routes), dependencies=routes)
+        for r in compiled_routes:
+            match = r.pattern.match(location.pathname)
             if match:
                 return _LocationStateContext(
                     r.element,
-                    value=_LocationState(location, set_location, match),
-                    key=p.pattern,
+                    value=_LocationState(
+                        location,
+                        set_location,
+                        {r.converters[k](v) for k, v in match.groupdict().items()},
+                    ),
+                    key=r.pattern.pattern,
                 )
         return None
 
     return Router
 
 
-def use_location() -> Location:
-    return _use_location_state().location
-
-
-def use_match() -> re.Match[str]:
-    return _use_location_state().match
-
-
 @dataclass
 class Route:
-    path: str | re.Pattern[str]
+    path: str
     element: Any
+    routes: Sequence[Route]
+
+    def __init__(self, path: str, element: Any | None, *routes: Route) -> None:
+        self.path = path
+        self.element = element
+        self.routes = routes
 
 
 @component
@@ -79,15 +83,54 @@ def Link(*attributes_or_children: VdomAttributesAndChildren, to: str) -> VdomDic
     return _Link(attrs, *children)
 
 
-def _compile_routes(routes: Sequence[Route]) -> Iterator[tuple[re.Pattern[str], Route]]:
+def use_location() -> Location:
+    """Get the current route location"""
+    return _use_location_state().location
+
+
+def use_params() -> dict[str, Any]:
+    """Get parameters from the currently matching route pattern"""
+    return _use_location_state().params
+
+
+def use_query(
+    keep_blank_values: bool = False,
+    strict_parsing: bool = False,
+    errors: str = "replace",
+    max_num_fields: int | None = None,
+    separator: str = "&",
+) -> dict[str, list[str]]:
+    """See :func:`urllib.parse.parse_qs` for parameter info."""
+    return parse_qs(
+        use_location().search,
+        keep_blank_values=keep_blank_values,
+        strict_parsing=strict_parsing,
+        errors=errors,
+        max_num_fields=max_num_fields,
+        separator=separator,
+    )
+
+
+def _compile_routes(routes: Sequence[Route]) -> list[_CompiledRoute]:
+    for path, element in _iter_routes(routes):
+        pattern, _, converters = compile_path(path)
+        yield _CompiledRoute(
+            pattern, {k: v.convert for k, v in converters.items()}, element
+        )
+
+
+def _iter_routes(routes: Sequence[Route]) -> Iterator[tuple[str, Any]]:
     for r in routes:
-        if isinstance(r.path, re.Pattern):
-            yield r.path, r
-            continue
-        if not r.path.startswith("/"):
-            raise ValueError("Path pattern must begin with '/'")
-        pattern = re.compile(fnmatch_translate(r.path))
-        yield pattern, r
+        for path, element in _iter_routes(r.routes):
+            yield r.path + path, element
+        yield r.path, r.element
+
+
+@dataclass
+class _CompiledRoute:
+    pattern: re.Pattern[str]
+    converters: dict[str, Callable[[Any], Any]]
+    element: Any
 
 
 def _use_location_state() -> _LocationState:
@@ -100,7 +143,7 @@ def _use_location_state() -> _LocationState:
 class _LocationState:
     location: Location
     set_location: Callable[[Location], None]
-    match: re.Match[str]
+    params: dict[str, Any]
 
 
 _LocationStateContext: Context[_LocationState | None] = create_context(None)

requirements/pkg-deps.txt

@@ -1,2 +1,3 @@
 idom >=0.40.2,<0.41
 typing_extensions
+starlette

tests/test_router.py

@@ -2,23 +2,30 @@
 from idom import Ref, component, html
 from idom.testing import BackendFixture, DisplayFixture
 
-from idom_router import Link, Route, configure
+from idom_router import Link, Route, configure, use_location
 
 
 @pytest.fixture
 def Routes(backend: BackendFixture):
     return configure(backend.implementation)
 
 
+def test_configure(backend):
+    configure(backend.implementation)
+    configure(backend.implementation.use_location)
+    with pytest.raises(
+        TypeError, match="Expected a 'BackendImplementation' or 'use_location' hook"
+    ):
+        configure(None)
+
+
 async def test_simple_router(display: DisplayFixture, Routes: Routes):
     @component
     def Sample():
         return Routes(
             Route("/a", html.h1({"id": "a"}, "A")),
             Route("/b", html.h1({"id": "b"}, "B")),
             Route("/c", html.h1({"id": "c"}, "C")),
-            Route("/c", html.h1({"id": "c"}, "C")),
-            Route("/*", html.h1({"id": "default"}, "Default")),
         )
 
     await display.show(Sample)
@@ -27,8 +34,43 @@ def Sample():
         ("/a", "#a"),
         ("/b", "#b"),
         ("/c", "#c"),
-        ("/default", "#default"),
-        ("/anything", "#default"),
+    ]:
+        await display.goto(path)
+        await display.page.wait_for_selector(selector)
+
+    await display.goto("/missing")
+
+    try:
+        root_element = display.root_element()
+    except AttributeError:
+        root_element = await display.page.wait_for_selector(
+            f"#display-{display._next_view_id}", state="attached"
+        )
+
+    assert not await root_element.inner_html()
+
+
+async def test_nested_routes(display: DisplayFixture, Routes: Routes):
+    @component
+    def Sample():
+        return Routes(
+            Route(
+                "/a",
+                html.h1({"id": "a"}, "A"),
+                Route(
+                    "/b",
+                    html.h1({"id": "b"}, "B"),
+                    Route("/c", html.h1({"id": "c"}, "C")),
+                ),
+            ),
+        )
+
+    await display.show(Sample)
+
+    for path, selector in [
+        ("/a", "#a"),
+        ("/a/b", "#b"),
+        ("/a/b/c", "#c"),
     ]:
         await display.goto(path)
         await display.page.wait_for_selector(selector)
@@ -45,7 +87,7 @@ def Sample():
             Route("/a", Link({"id": "a"}, "A", to="/b")),
             Route("/b", Link({"id": "b"}, "B", to="/c")),
             Route("/c", Link({"id": "c"}, "C", to="/default")),
-            Route("/*", html.h1({"id": "default"}, "Default")),
+            Route("/{path:path}", html.h1({"id": "default"}, "Default")),
         )
 
     await display.show(Sample)