rework based on feedback

Author: rmorshea

idom_router/__init__.py

@@ -1,16 +1,17 @@
 # the version is statically loaded by setup.py
 __version__ = "0.0.1"
 
-from idom_router.types import Route, RouteCompiler, RoutePattern
+from idom_router.types import Route, RouteCompiler, RouteResolver
 
-from .router import link, router, use_params, use_query
+from .core import link, create_router, router_component, use_params, use_query
 
 __all__ = [
+    "create_router",
     "link",
     "Route",
     "RouteCompiler",
-    "RoutePattern",
-    "router",
+    "router_component",
+    "RouteResolver",
     "use_location",
     "use_params",
     "use_query",

idom_router/router.py renamed to idom_router/core.py

@@ -19,19 +19,32 @@
 from idom.types import ComponentType, Context, Location
 from idom.web.module import export, module_from_file
 
-from idom_router.compilers import compile_starlette_route
-from idom_router.types import Route, RouteCompiler, RoutePattern
+from idom_router.types import Route, RouteCompiler, RouteResolver, Router
 
 R = TypeVar("R", bound=Route)
 
 
+def create_router(compiler: RouteCompiler[R]) -> Router[R]:
+    """A decorator that turns a route compiler into a router"""
+
+    def wrapper(*routes: R) -> ComponentType:
+        return router_component(*routes, compiler=compiler)
+
+    return wrapper
+
+
 @component
-def router(
+def router_component(
     *routes: R,
-    compiler: RouteCompiler[R] = compile_starlette_route,
+    compiler: RouteCompiler[R],
 ) -> ComponentType | None:
     old_conn = use_connection()
     location, set_location = use_state(old_conn.location)
+    router_state = use_context(_route_state_context)
+
+
+    if router_state is not None:
+        raise RuntimeError("Another router is already active in this context")
 
     # Memoize the compiled routes and the match separately so that we don't
     # recompile the routes on renders where only the location has changed
@@ -87,7 +100,7 @@ def use_query(
 
 def _compile_routes(
     routes: Sequence[R], compiler: RouteCompiler[R]
-) -> list[tuple[Any, RoutePattern]]:
+) -> list[tuple[Any, RouteResolver]]:
     return [(r, compiler(r)) for r in _iter_routes(routes)]
 
 
@@ -99,7 +112,7 @@ def _iter_routes(routes: Sequence[R]) -> Iterator[R]:
 
 
 def _match_route(
-    compiled_routes: list[tuple[R, RoutePattern]], location: Location
+    compiled_routes: list[tuple[R, RouteResolver]], location: Location
 ) -> tuple[R, dict[str, Any]] | None:
     for route, pattern in compiled_routes:
         params = pattern.match(location.pathname)

idom_router/routers/__init__.py

@@ -1,19 +1,20 @@
 from __future__ import annotations
 
 import re
+from uuid import UUID
 from typing import Any, Callable
 
 from idom_router import Route
 
 
-def compile_simple_regex_route(route: Route) -> RegexRoutePattern:
+def compile_regex_route(route: Route) -> RegexRoutePattern:
     """Compile simple regex route.
 
     Named regex groups can end with a `__type` suffix to specify a type converter
 
     For example, `(?P<id__int>[0-9]+)` will convert the `id` parameter to an `int`.
 
-    Supported types are `int`, `float`, and `list` where `list` will split on `,`.
+    Supported types are `int`, `float`, and `uuid`.
     """
     pattern = re.compile(route.path)
     return RegexRoutePattern(pattern)
@@ -41,7 +42,7 @@ def match(self, path: str) -> dict[str, str] | None:
 CONVERTERS: dict[str, Callable[[str], Any]] = {
     "int": int,
     "float": float,
-    "list": lambda s: s.split(","),
+    "uuid": UUID,
 }
 
 

tests/utils.py renamed to idom_router/routers/regex.py

@@ -4,17 +4,18 @@
 from typing import Any
 
 from starlette.convertors import Convertor
-from starlette.routing import compile_path as _compile_starlette_path
+from starlette.routing import compile_path
 
 from idom_router.types import Route
+from idom_router.core import create_router
 
 
-def compile_starlette_route(route: Route) -> StarletteRoutePattern:
-    pattern, _, converters = _compile_starlette_path(route.path)
-    return StarletteRoutePattern(pattern, converters)
+def compile_starlette_route(route: Route) -> StarletteRouteResolver:
+    pattern, _, converters = compile_path(route.path)
+    return StarletteRouteResolver(pattern, converters)
 
 
-class StarletteRoutePattern:
+class StarletteRouteResolver:
     def __init__(
         self,
         pattern: re.Pattern[str],
@@ -32,3 +33,6 @@ def match(self, path: str) -> dict[str, Any] | None:
                 for k, v in match.groupdict().items()
             }
         return None
+
+
+starlette_router = create_router(compile_starlette_route)

idom_router/compilers.py renamed to idom_router/routers/starlette.py

@@ -3,7 +3,7 @@
 from dataclasses import dataclass
 from typing import Any, Sequence, TypeVar
 
-from idom.types import Key
+from idom.types import Key, ComponentType
 from typing_extensions import Protocol, Self
 
 
@@ -26,18 +26,25 @@ def __init__(
         self.routes = (*routes_, *routes)
 
 
+class Router(Protocol):
+    def __call__(self, *routes: Route) -> ComponentType:
+        """Return a component that renders the first matching route"""
+
+
 R = TypeVar("R", bound=Route, contravariant=True)
 
 
 class RouteCompiler(Protocol[R]):
-    def __call__(self, route: R) -> RoutePattern:
-        """Compile a route into a pattern that can be matched against a path"""
+    def __call__(self, route: R) -> RouteResolver:
+        """Compile a route into a resolver that can be matched against a path"""
+
 
+class RouteResolver(Protocol):
+    """A compiled route that can be matched against a path"""
 
-class RoutePattern(Protocol):
     @property
     def key(self) -> Key:
-        """Uniquely identified this pattern"""
+        """Uniquely identified this resolver"""
 
-    def match(self, path: str) -> dict[str, Any] | None:
-        """Returns otherwise a dict of path parameters if the path matches, else None"""
+    def resolve(self, path: str) -> tuple[Any, dict[str, Any]] | None:
+        """Return the path's associated element and path params or None"""