路由参数匹配异常修复

添加路由参数匹配示例

Author: hubertshelley

examples/path_params/Cargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "path_params"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+silent = { version = "0.1.0", path = "../../silent" }

examples/path_params/src/main.rs

@@ -0,0 +1,29 @@
+use silent::prelude::*;
+
+fn main() {
+    logger::fmt().with_max_level(Level::INFO).init();
+    // 定义路由
+    let route = Route::new("path_params")
+        .append(Route::new("<key:str>/str").get(hello_world))
+        .append(Route::new("<key:int>/int").get(hello_world))
+        .append(Route::new("<key:uuid>/uuid").get(hello_world))
+        .append(Route::new("<key:path>/path").get(hello_world))
+        .append(Route::new("<key:full_path>/full_path").get(hello_world))
+        .append(Route::new("<key:*>/*").get(hello_world))
+        .append(Route::new("<key:**>/**").get(hello_world))
+        .append(Route::new("<key>").get(hello_world))
+        .append(Route::new("<key:other>/other").get(hello_world));
+    println!("{:?}", route);
+    Server::new().bind_route(route).run();
+}
+
+// 定义处理方法
+async fn hello_world(req: Request) -> Result<String, SilentError> {
+    let path_params = req.get_path_params("key").unwrap();
+    match path_params {
+        PathParam::String(str) => Ok(format!("str {}", str)),
+        PathParam::Int(int) => Ok(format!("int {}", int)),
+        PathParam::UUid(uuid) => Ok(format!("uuid {}", uuid)),
+        PathParam::Path(path) => Ok(format!("path {}", path)),
+    }
+}

silent/src/lib.rs

@@ -15,7 +15,7 @@ pub(crate) use handler::{Handler, HandlerWrapper};
 pub use hyper::Method;
 
 pub mod prelude {
-    pub use crate::core::{request::Request, response::Response};
+    pub use crate::core::{path_param::PathParam, request::Request, response::Response};
     pub use crate::error::SilentError;
     pub use crate::log::{logger, Level};
     pub use crate::route::handler_append::HandlerAppend;

silent/src/route/handler_append.rs

@@ -61,6 +61,18 @@ where
     }
 
     fn get_handler_mut(&mut self) -> &mut HashMap<Method, Arc<dyn Handler>> {
-        &mut self.handler
+        if self.path == self.create_path {
+            &mut self.handler
+        } else {
+            let mut iter = self.create_path.splitn(2, '/');
+            let _local_url = iter.next().unwrap_or("");
+            let last_url = iter.next().unwrap_or("");
+            let route = self
+                .children
+                .iter_mut()
+                .find(|c| c.create_path == last_url)
+                .unwrap();
+            <Route as HandlerAppend<F, T, Fut>>::get_handler_mut(route)
+        }
     }
 }

silent/src/route/handler_match.rs

@@ -54,7 +54,6 @@ impl<'a> From<&'a str> for SpecialPath {
 impl Match for Route {
     fn handler_match(&self, req: &mut Request, path: &str) -> RouteMatched {
         let (local_url, last_url) = Self::path_split(path);
-
         if !self.special_match {
             if self.path == local_url {
                 self.last_matched(req, last_url)
@@ -63,10 +62,13 @@ impl Match for Route {
             }
         } else {
             match self.get_path().into() {
-                SpecialPath::String(key) => {
-                    req.set_path_params(key, local_url.to_string().into());
-                    self.last_matched(req, last_url)
-                }
+                SpecialPath::String(key) => match self.last_matched(req, last_url) {
+                    RouteMatched::Matched(route) => {
+                        req.set_path_params(key, local_url.to_string().into());
+                        RouteMatched::Matched(route)
+                    }
+                    RouteMatched::Unmatched => RouteMatched::Unmatched,
+                },
                 SpecialPath::Int(key) => match local_url.parse::<i32>() {
                     Ok(value) => {
                         req.set_path_params(key, value.into());
@@ -89,7 +91,10 @@ impl Match for Route {
                     req.set_path_params(key, PathParam::Path(path.to_string()));
                     match self.last_matched(req, last_url) {
                         RouteMatched::Matched(route) => RouteMatched::Matched(route),
-                        RouteMatched::Unmatched => RouteMatched::Matched(self.clone()),
+                        RouteMatched::Unmatched => match self.handler.is_empty() {
+                            true => RouteMatched::Unmatched,
+                            false => RouteMatched::Matched(self.clone()),
+                        },
                     }
                 }
             }
@@ -103,7 +108,7 @@ impl RouteMatch for Route {
     }
 
     fn last_matched(&self, req: &mut Request, last_url: &str) -> RouteMatched {
-        if last_url.is_empty() {
+        if last_url.is_empty() && !self.handler.is_empty() {
             return RouteMatched::Matched(self.clone());
         } else {
             for route in &self.children {

silent/src/route/mod.rs

@@ -5,7 +5,7 @@ use crate::route::handler_match::{Match, RouteMatched};
 use crate::Method;
 use hyper::StatusCode;
 use std::collections::HashMap;
-use std::fmt::Display;
+use std::fmt;
 use std::sync::Arc;
 
 pub(crate) mod handler_append;
@@ -18,18 +18,31 @@ pub struct Route {
     pub children: Vec<Route>,
     pub middlewares: Vec<Arc<dyn Handler>>,
     special_match: bool,
+    create_path: String,
 }
 
-impl Display for Route {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        let mut path = self.path.clone();
-        if path.is_empty() {
-            path = "/".to_string();
+impl fmt::Debug for Route {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fn get_route_str(pre_fix: String, route: &Route) -> String {
+            let space_pre_fix = format!("    {}", pre_fix);
+            let mut route_strs: Vec<String> = route
+                .children
+                .iter()
+                .filter(|r| !r.handler.is_empty() || !r.children.is_empty())
+                .map(|r| get_route_str(space_pre_fix.clone(), r))
+                .collect();
+            if !route.handler.is_empty() || !route.children.is_empty() {
+                let methods: Vec<String> = route.handler.keys().map(|m| m.to_string()).collect();
+                let methods_str = if methods.is_empty() {
+                    "".to_string()
+                } else {
+                    format!("({})", methods.join(","))
+                };
+                route_strs.insert(0, format!("{}{}{}", pre_fix, route.path, methods_str));
+            }
+            route_strs.join("\n")
         }
-        for route in &self.children {
-            write!(f, "{}", route)?;
-        }
-        write!(f, "{}", path)
+        write!(f, "{}", get_route_str("".to_string(), self))
     }
 }
 
@@ -44,6 +57,7 @@ impl Route {
             children: Vec::new(),
             middlewares: Vec::new(),
             special_match: first_path.starts_with('<') && first_path.ends_with('>'),
+            create_path: path.to_string(),
         };
         if last_path.is_empty() {
             route
@@ -62,12 +76,12 @@ pub struct Routes {
     pub children: Vec<Route>,
 }
 
-impl Display for Routes {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl fmt::Debug for Routes {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let path = self
             .children
             .iter()
-            .map(|route| route.to_string())
+            .map(|route| format!("{:?}", route))
             .collect::<Vec<String>>()
             .join("\n");
         write!(f, "{}", path)