Change star pattern to {NAME:any}

Author: Archmonger

.gitignore

@@ -4,7 +4,7 @@ docs/site
 
 # --- JAVASCRIPT BUNDLES ---
 
-src/reactpy_router/bundle.js
+src/reactpy_router/static/bundle.js
 
 # --- PYTHON IGNORE FILES ----
 

docs/examples/python/basic-routing-more-routes.py

@@ -7,7 +7,7 @@ def root():
     return browser_router(
         route("/", html.h1("Home Page 🏠")),
         route("/messages", html.h1("Messages 💬")),
-        route("*", html.h1("Missing Link 🔗‍💥")),
+        route("{404:any}", html.h1("Missing Link 🔗‍💥")),
     )
 
 

docs/examples/python/basic-routing.py

@@ -6,7 +6,7 @@
 def root():
     return browser_router(
         route("/", html.h1("Home Page 🏠")),
-        route("*", html.h1("Missing Link 🔗‍💥")),
+        route("{404:any}", html.h1("Missing Link 🔗‍💥")),
     )
 
 

docs/examples/python/nested-routes.py

@@ -26,7 +26,7 @@ def root():
             route("/with/Alice", messages_with("Alice")),
             route("/with/Alice-Bob", messages_with("Alice", "Bob")),
         ),
-        route("*", html.h1("Missing Link 🔗‍💥")),
+        route("{404:any}", html.h1("Missing Link 🔗‍💥")),
     )
 
 

docs/examples/python/route-links.py

@@ -7,7 +7,7 @@ def root():
     return browser_router(
         route("/", home()),
         route("/messages", html.h1("Messages 💬")),
-        route("*", html.h1("Missing Link 🔗‍💥")),
+        route("{404:any}", html.h1("Missing Link 🔗‍💥")),
     )
 
 

docs/examples/python/route-parameters.py

@@ -25,7 +25,7 @@ def root():
             all_messages(),
             route("/with/{names}", messages_with()),  # note the path param
         ),
-        route("*", html.h1("Missing Link 🔗‍💥")),
+        route("{404:any}", html.h1("Missing Link 🔗‍💥")),
     )
 
 

docs/src/learn/routers-routes-and-links.md

@@ -19,7 +19,7 @@ Here's a basic example showing how to use `#!python browser_router` with two rou
     {% include "../../examples/python/basic-routing.py" %}
     ```
 
-Here we'll note some special syntax in the route path for the second route. The `#!python "*"` is a wildcard that will match any path. This is useful for creating a "404" page that will be shown when no other route matches.
+Here we'll note some special syntax in the route path for the second route. The `#!python "any"` type is a wildcard that will match any path. This is useful for creating a default page or error page such as "404 NOT FOUND".
 
 ### Browser Router
 
@@ -34,11 +34,13 @@ In this case, `#!python param` is the name of the route parameter and the option
 
 | Type | Pattern |
 | --- | --- |
-| `#!python str` (default) | `#!python [^/]+` |
 | `#!python int` | `#!python \d+` |
-| `#!python float` | `#!python \d+(\.\d+)?` |
+| `#!python str` (default) | `#!python [^/]+` |
 | `#!python uuid` | `#!python [0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}` |
+| `#!python slug` | `#!python [-a-zA-Z0-9_]+` |
 | `#!python path` | `#!python .+` |
+| `#!python float` | `#!python \d+(\.\d+)?` |
+| `#!python any` | `#!python .*` |
 
 So in practice these each might look like:
 

src/reactpy_router/converters.py

@@ -29,5 +29,9 @@
         "regex": r"\d+(\.\d+)?",
         "func": float,
     },
+    "any": {
+        "regex": r".*",
+        "func": str,
+    },
 }
 """The conversion types supported by the default Resolver. You can add more types if needed."""

src/reactpy_router/core.py

@@ -65,10 +65,7 @@ def router_component(
     if match:
         route_elements = [
             _route_state_context(
-                html.div(
-                    element,  # type: ignore
-                    key=f"{location.pathname}{select}{params}{element}{id(element)}",
-                ),
+                element,
                 value=_RouteState(set_location, params),
             )
             for element, params in match

src/reactpy_router/resolvers.py

@@ -16,47 +16,63 @@ def __init__(
         self,
         route: Route,
         param_pattern=r"{(?P<name>\w+)(?P<type>:\w+)?}",
-        match_any_identifier=r"\*$",
         converters: dict[str, ConversionInfo] | None = None,
     ) -> None:
         self.element = route.element
-        self.pattern, self.converter_mapping = self.parse_path(route.path)
         self.registered_converters = converters or CONVERTERS
-        self.key = self.pattern.pattern
+        self.converter_mapping: ConverterMapping = {}
+        # self.match_any_indentifier = match_any_identifier
         self.param_regex = re.compile(param_pattern)
-        self.match_any = match_any_identifier
+        self.pattern = self.parse_path(route.path)
+        self.key = self.pattern.pattern  # Unique identifier for ReactPy rendering
 
-    def parse_path(self, path: str) -> tuple[re.Pattern[str], ConverterMapping]:
+    def parse_path(self, path: str) -> re.Pattern[str]:
         # Convert path to regex pattern, then interpret using registered converters
         pattern = "^"
         last_match_end = 0
-        converter_mapping: ConverterMapping = {}
+
+        # Iterate through matches of the parameter pattern
         for match in self.param_regex.finditer(path):
-            param_name = match.group("name")
+            # Extract parameter name and type
+            name = match.group("name")
+            if name[0].isnumeric():
+                name = f"_numeric_{name}"
             param_type = (match.group("type") or "str").strip(":")
+
+            # Check if a converter exists for the type
             try:
-                param_conv = self.registered_converters[param_type]
+                conversion_info = self.registered_converters[param_type]
             except KeyError as e:
                 raise ValueError(
                     f"Unknown conversion type {param_type!r} in {path!r}"
                 ) from e
+
+            # Add the string before the match to the pattern
             pattern += re.escape(path[last_match_end : match.start()])
-            pattern += f"(?P<{param_name}>{param_conv['regex']})"
-            converter_mapping[param_name] = param_conv["func"]
+
+            # Add the match to the pattern
+            pattern += f"(?P<{name}>{conversion_info['regex']})"
+
+            # Keep a local mapping of parameter names to conversion functions.
+            self.converter_mapping[name] = conversion_info["func"]
+
+            # Update the last match end
             last_match_end = match.end()
-        pattern += f"{re.escape(path[last_match_end:])}$"
 
-        # Replace "match anything" pattern with regex, if it's at the end of the path
-        if pattern.endswith(self.match_any):
-            pattern = f"{pattern[:-3]}.*$"
+        # Add the string after the last match
+        pattern += f"{re.escape(path[last_match_end:])}$"
 
-        return re.compile(pattern), converter_mapping
+        return re.compile(pattern)
 
     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()},
-            )
+            # Convert the matched groups to the correct types
+            params = {
+                parameter_name.strip("_numeric_"): self.converter_mapping[
+                    parameter_name
+                ](value)
+                for parameter_name, value in match.groupdict().items()
+            }
+            return (self.element, params)
         return None

tests/test_core.py

@@ -84,7 +84,7 @@ def sample():
             route("/a", link("A", to="/b", id="a")),
             route("/b", link("B", to="/c", id="b")),
             route("/c", link("C", to="/default", id="c")),
-            route("*", html.h1({"id": "default"}, "Default")),
+            route("{default:any}", html.h1({"id": "default"}, "Default")),
         )
 
     await display.show(sample)
@@ -163,7 +163,7 @@ def sample():
             route("/a", link("A", to="/b", id="a")),
             route("/b", link("B", to="/c", id="b")),
             route("/c", link("C", to="/default", id="c")),
-            route("*", html.h1({"id": "default"}, "Default")),
+            route("{default:any}", html.h1({"id": "default"}, "Default")),
         )
 
     await display.show(sample)
@@ -197,7 +197,7 @@ def sample():
             route("/a/b/c", link("C", to="../d", id="c")),
             route("/a/d", link("D", to="e", id="d")),
             route("/a/e", link("E", to="../default", id="e")),
-            route("*", html.h1({"id": "default"}, "Default")),
+            route("{default:any}", html.h1({"id": "default"}, "Default")),
         )
 
     await display.show(sample)

tests/test_resolver.py

@@ -5,35 +5,45 @@
 from reactpy_router import Resolver, route
 
 
+def test_resolve_any():
+    resolver = Resolver(route("{404:any}", "Hello World"))
+    assert resolver.parse_path("{404:any}") == re.compile("^(?P<_numeric_404>.*)$")
+    assert resolver.converter_mapping == {"_numeric_404": str}
+    assert resolver.resolve("/hello/world") == ("Hello World", {"404": "/hello/world"})
+
+
 def test_parse_path():
     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 resolver.parse_path("/a/{b:int}/c") == (
-        re.compile(r"^/a/(?P<b>\d+)/c$"),
-        {"b": int},
-    )
-    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 resolver.parse_path("/a/b/c") == re.compile("^/a/b/c$")
+    assert resolver.converter_mapping == {}
+
+    assert resolver.parse_path("/a/{b}/c") == re.compile(r"^/a/(?P<b>[^/]+)/c$")
+    assert resolver.converter_mapping == {"b": str}
+
+    assert resolver.parse_path("/a/{b:int}/c") == re.compile(r"^/a/(?P<b>\d+)/c$")
+    assert resolver.converter_mapping == {"b": int}
+
+    assert resolver.parse_path("/a/{b:int}/{c:float}/c") == re.compile(
+        r"^/a/(?P<b>\d+)/(?P<c>\d+(\.\d+)?)/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 resolver.converter_mapping == {"b": int, "c": float}
+
+    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}-[0-9a-f]{4}-[0-9a-f]{12})/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$"
-        ),
-        {"b": int, "c": float, "d": uuid.UUID, "e": str},
+    assert resolver.converter_mapping == {"b": int, "c": float, "d": uuid.UUID}
+
+    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}-[0-9a-f]{4}-[0-9a-f]{12})/(?P<e>.+)/c$"
     )
+    assert resolver.converter_mapping == {
+        "b": int,
+        "c": float,
+        "d": uuid.UUID,
+        "e": str,
+    }
 
 
 def test_parse_path_unkown_conversion():
@@ -45,13 +55,5 @@ def test_parse_path_unkown_conversion():
 def test_parse_path_re_escape():
     """Check that we escape regex characters in the path"""
     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():
-    resolver = Resolver(route("/", None))
-    assert resolver.parse_path("*") == (re.compile("^.*$"), {})
+    assert resolver.parse_path("/a/{b:int}/c.d") == re.compile(r"^/a/(?P<b>\d+)/c\.d$")
+    assert resolver.converter_mapping == {"b": int}