add /* matching to router.

http/CHANGES.md

@@ -2,3 +2,4 @@
 
 ## Changed
 - `h1::proto::context::Context::encode_headers` does not want `Extensions` type argument anymore. It also wants `&mut HeaderMap` instead of `HeaderMap` to avoid consuming ownership of it.
+- update `xitca-router` to `0.2.0`

http/Cargo.toml

@@ -71,7 +71,7 @@ http_0dot2 = { package = "http", version = "0.2", optional = true }
 tokio = { version = "1.30", features = ["rt", "time"], optional = true }
 
 # util service support
-xitca-router = { version = "0.1", optional = true }
+xitca-router = { version = "0.2", optional = true }
 
 # io-uring support
 tokio-uring = { version = "0.4.0", features = ["bytes"], optional = true }

http/src/util/service/router_priv.rs

@@ -149,7 +149,7 @@ impl<Obj> RouterGen for Router<Obj> {
             })
             .collect();
 
-        path.push_str("/:r");
+        path.push_str("/*");
 
         Cow::Owned(path)
     }

router/CHANGES.md

@@ -0,0 +1,21 @@
+unreleased version 0.2
+
+# Add
+- add catch all matching for `/*`. It will match on `/*p` and `/`. This enables nesting `Router` types and other similar use case where the path matching is break up into separate segments between multiple scopes. 
+
+    Example:
+   ```rust
+    // a scoped router match against relative path of / and /login
+    let mut router_scope = xitca_router::Router::new();
+    router_scope.insert("/", true);
+    router_scope.insert("/login", true);
+
+    // add scoped router to root router where /users is used as
+    // prefix
+    let mut router = xitca_router::Router::new();
+    router.insert("/users/*", router_scope);
+
+    // handling /users as prefix and / and /login as suffix
+    assert!(m.at("/users/").is_ok());
+    assert!(m.at("/users/login").is_ok());
+   ```

router/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "xitca-router"
-version = "0.1.0"
+version = "0.2.0"
 edition = "2021"
 license = "MIT"
 description = "router for xitca"

router/src/tree.rs

@@ -467,6 +467,17 @@ impl<T> Node<T> {
             break;
         }
 
+        // a non aggressive way to handle single * wildcard
+        if current.prefix == path {
+            if let Some(val) = current.children.first() {
+                if val.prefix == "*" {
+                    if let Some(ref val) = val.value {
+                        return Ok((val, params));
+                    }
+                }
+            }
+        }
+
         Err(MatchError)
     }
 
@@ -507,8 +518,8 @@ fn normalize_params(mut path: Vec<u8>) -> Result<(Vec<u8>, ParamRemapping), Inse
             None => return Ok((path, original)),
         };
 
-        // makes sure the param has a valid name
-        if wildcard.len() < 2 {
+        // makes sure the param has a valid name unless it's * catch all
+        if wildcard.len() < 2 && wildcard.first().filter(|w| **w == b'*').is_none() {
             return Err(InsertError::UnnamedParam);
         }
 

router/tests/tree.rs

@@ -615,7 +615,7 @@ insert_tests! {
         "/user:"  => Err(InsertError::UnnamedParam),
         "/user:/" => Err(InsertError::UnnamedParam),
         "/cmd/:/" => Err(InsertError::UnnamedParam),
-        "/src/*"  => Err(InsertError::UnnamedParam),
+        // "/src/*"  => Err(InsertError::UnnamedParam),
     },
     double_params {
         "/:foo:bar"  => Err(InsertError::TooManyParams),