SimpleResolver -> Resolver, CONVERSION_TYPES -> CONVERTERS, file refactoring, and better resolver base class

Author: Archmonger

src/reactpy_router/__init__.py

@@ -1,22 +1,25 @@
 # the version is statically loaded by setup.py
 __version__ = "0.1.1"
 
-from . import routers
+
+from .converters import CONVERTERS
 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
 
 __all__ = (
     "create_router",
     "link",
     "route",
-    "route",
-    "Route",
     "routers",
+    "Route",
     "RouteCompiler",
     "router_component",
     "RouteResolver",
     "browser_router",
     "use_params",
     "use_search_params",
+    "Resolver",
+    "CONVERTERS",
 )

src/reactpy_router/converters.py

@@ -0,0 +1,33 @@
+import uuid
+
+from reactpy_router.types import ConversionInfo
+
+__all__ = ["CONVERTERS"]
+
+CONVERTERS: dict[str, ConversionInfo] = {
+    "int": {
+        "regex": r"\d+",
+        "func": int,
+    },
+    "str": {
+        "regex": r"[^/]+",
+        "func": str,
+    },
+    "uuid": {
+        "regex": r"[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}",
+        "func": uuid.UUID,
+    },
+    "slug": {
+        "regex": r"[-a-zA-Z0-9_]+",
+        "func": str,
+    },
+    "path": {
+        "regex": r".+",
+        "func": str,
+    },
+    "float": {
+        "regex": r"\d+(\.\d+)?",
+        "func": float,
+    },
+}
+"""The conversion types supported by the default Resolver. You can add more types if needed."""

src/reactpy_router/resolvers.py

@@ -0,0 +1,55 @@
+import re
+from typing import Any
+
+from reactpy_router.converters import CONVERTERS
+from reactpy_router.types import ConversionInfo, ConverterMapping, Route
+
+__all__ = ["Resolver"]
+
+
+class Resolver:
+    """A simple route resolver that uses regex to match paths"""
+
+    def __init__(
+        self,
+        route: Route,
+        param_pattern=r"{(?P<name>\w+)(?P<type>:\w+)?}",
+        converters: dict[str, ConversionInfo] | None = None,
+    ) -> None:
+        self.element = route.element
+        self.pattern, self.converter_mapping = self.parse_path(route.path)
+        self.converters = converters or CONVERTERS
+        self.key = self.pattern.pattern
+        self.param_regex = re.compile(param_pattern)
+
+    def parse_path(self, path: str) -> tuple[re.Pattern[str], ConverterMapping]:
+        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]
+            except KeyError as 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"]
+            last_match_end = match.end()
+        pattern += f"{re.escape(path[last_match_end:])}$"
+
+        # Replace literal `*` with "match anything" regex pattern, if it's at the end of the path
+        if pattern.endswith(r"\*$"):
+            pattern = f"{pattern[:-3]}.*$"
+
+        return re.compile(pattern), converter_mapping
+
+    def resolve(self, path: str) -> tuple[Any, dict[str, Any]] | None:
+        match = self.pattern.match(path)
+        if match:
+            return (
+                self.element,
+                {k: self.converter_mapping[k](v) for k, v in match.groupdict().items()},
+            )
+        return None

src/reactpy_router/routers.py

@@ -2,103 +2,13 @@
 
 from __future__ import annotations
 
-import re
-import uuid
-from typing import Any, Callable
-
-from typing_extensions import TypeAlias, TypedDict
-
 from reactpy_router.core import create_router
-from reactpy_router.types import Route
+from reactpy_router.resolvers import Resolver
 
 __all__ = ["browser_router"]
 
-ConversionFunc: TypeAlias = "Callable[[str], Any]"
-ConverterMapping: TypeAlias = "dict[str, ConversionFunc]"
-
-STAR_PATTERN = re.compile("^.*$")
-PARAM_PATTERN = re.compile(r"{(?P<name>\w+)(?P<type>:\w+)?}")
-
-
-class SimpleResolver:
-    """A simple route resolver that uses regex to match paths"""
-
-    def __init__(self, route: Route) -> None:
-        self.element = route.element
-        self.pattern, self.converters = parse_path(route.path)
-        self.key = self.pattern.pattern
-
-    def resolve(self, path: str) -> tuple[Any, dict[str, Any]] | None:
-        match = self.pattern.match(path)
-        if match:
-            return (
-                self.element,
-                {k: self.converters[k](v) for k, v in match.groupdict().items()},
-            )
-        return None
-
-
-def parse_path(path: str) -> tuple[re.Pattern[str], ConverterMapping]:
-    if path == "*":
-        return STAR_PATTERN, {}
-
-    pattern = "^"
-    last_match_end = 0
-    converters: ConverterMapping = {}
-    for match in PARAM_PATTERN.finditer(path):
-        param_name = match.group("name")
-        param_type = (match.group("type") or "str").lstrip(":")
-        try:
-            param_conv = CONVERSION_TYPES[param_type]
-        except KeyError:
-            raise ValueError(f"Unknown conversion type {param_type!r} in {path!r}")
-        pattern += re.escape(path[last_match_end : match.start()])
-        pattern += f"(?P<{param_name}>{param_conv['regex']})"
-        converters[param_name] = param_conv["func"]
-        last_match_end = match.end()
-    pattern += re.escape(path[last_match_end:]) + "$"
-    return re.compile(pattern), converters
-
-
-class ConversionInfo(TypedDict):
-    """Information about a conversion type"""
-
-    regex: str
-    """The regex to match the conversion type"""
-    func: ConversionFunc
-    """The function to convert the matched string to the expected type"""
-
-
-CONVERSION_TYPES: dict[str, ConversionInfo] = {
-    "int": {
-        "regex": r"\d+",
-        "func": int,
-    },
-    "str": {
-        "regex": r"[^/]+",
-        "func": str,
-    },
-    "uuid": {
-        "regex": r"[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}",
-        "func": uuid.UUID,
-    },
-    "slug": {
-        "regex": r"[-a-zA-Z0-9_]+",
-        "func": str,
-    },
-    "path": {
-        "regex": r".+",
-        "func": str,
-    },
-    "float": {
-        "regex": r"\d+(\.\d+)?",
-        "func": float,
-    },
-}
-"""The conversion types supported by the default Resolver. You can add more types if needed."""
-
 
-browser_router = create_router(SimpleResolver)
+browser_router = create_router(Resolver)
 """This is the recommended router for all ReactPy Router web projects.
 It uses the DOM History API to update the URL and manage the history stack."""
 # TODO: Check if this is true. If not, make it true.

src/reactpy_router/types.py

@@ -3,12 +3,15 @@
 from __future__ import annotations
 
 from dataclasses import dataclass, field
-from typing import Any, Literal, Sequence, TypeVar
+from typing import Any, Callable, Literal, Sequence, TypeAlias, TypedDict, TypeVar
 
 from reactpy.core.vdom import is_vdom
 from reactpy.types import ComponentType, Key
 from typing_extensions import Protocol, Self
 
+ConversionFunc: TypeAlias = Callable[[str], Any]
+ConverterMapping: TypeAlias = dict[str, ConversionFunc]
+
 
 @dataclass(frozen=True)
 class Route:
@@ -29,20 +32,20 @@ def __hash__(self) -> int:
         return hash((self.path, key, self.routes))
 
 
-R = TypeVar("R", bound=Route, contravariant=True)
+R_contra = TypeVar("R_contra", bound=Route, contravariant=True)
 
 
-class Router(Protocol[R]):
+class Router(Protocol[R_contra]):
     """Return a component that renders the first matching route"""
 
-    def __call__(self, *routes: R, select: Literal["first", "all"]) -> ComponentType:
+    def __call__(self, *routes: R_contra, select: Literal["first", "all"]) -> ComponentType:
         ...
 
 
-class RouteCompiler(Protocol[R]):
+class RouteCompiler(Protocol[R_contra]):
     """Compile a route into a resolver that can be matched against a path"""
 
-    def __call__(self, route: R) -> RouteResolver:
+    def __call__(self, route: R_contra) -> RouteResolver:
         ...
 
 
@@ -55,3 +58,12 @@ def key(self) -> Key:
 
     def resolve(self, path: str) -> tuple[Any, dict[str, Any]] | None:
         """Return the path's associated element and path params or None"""
+
+
+class ConversionInfo(TypedDict):
+    """Information about a conversion type"""
+
+    regex: str
+    """The regex to match the conversion type"""
+    func: ConversionFunc
+    """The function to convert the matched string to the expected type"""