feat!: Use a radix trie for route matching

Cargo.toml

@@ -115,6 +115,7 @@ insta-cmd = "0.7"
 is_terminal_polyfill = "1.70"
 lettre = { version = "0.11.22", default-features = false }
 libtest-mimic = "0.8"
+matchit = "0.9.2"
 mime = "0.3"
 mime_guess = { version = "2", default-features = false }
 mockall = "0.15"

cot/Cargo.toml

@@ -44,6 +44,7 @@ idna = { workspace = true, optional = true }
 indexmap.workspace = true
 is_terminal_polyfill.workspace = true
 lettre = { workspace = true, features = ["builder", "sendmail-transport", "smtp-transport", "tokio1", "tokio1-rustls", "ring", "rustls-platform-verifier"], optional = true }
+matchit.workspace = true
 mime.workspace = true
 mime_guess.workspace = true
 multer.workspace = true

cot/src/error_page.rs

@@ -8,6 +8,7 @@ use tracing::{Level, error, warn};
 use crate::config::ProjectConfig;
 use crate::error::NotFound;
 use crate::router::Router;
+use crate::router::path::AbsolutePath;
 use crate::{Error, Result, StatusCode, Template};
 
 #[derive(Debug)]
@@ -123,7 +124,12 @@ impl ErrorPageTemplateBuilder {
     fn diagnostics(&mut self, diagnostics: &Diagnostics) -> &mut Self {
         self.project_config = format!("{:#?}", diagnostics.project_config);
         self.route_data.clear();
-        Self::build_route_data(&mut self.route_data, &diagnostics.router, "", "");
+        Self::build_route_data(
+            &mut self.route_data,
+            &diagnostics.router,
+            &AbsolutePath::root(),
+            "",
+        );
         self.request_data = diagnostics
             .request_head
             .as_ref()
@@ -133,14 +139,16 @@ impl ErrorPageTemplateBuilder {
 
     fn build_route_data(
         route_data: &mut Vec<RouteData>,
-        router: &Router,
-        url_prefix: &str,
+        router: &Arc<Router>,
+        url_prefix: &AbsolutePath,
         index_prefix: &str,
     ) {
         for (index, route) in router.routes().iter().enumerate() {
+            let full_path = url_prefix.join(&AbsolutePath::new(route.url()));
+
             route_data.push(RouteData {
                 index: format!("{index_prefix}{index}"),
-                path: format!("{url_prefix}{}", route.url()),
+                path: full_path.to_string(),
                 kind: match route.kind() {
                     crate::router::RouteKind::Router => if route_data.is_empty() {
                         "Root Router"
@@ -151,13 +159,14 @@ impl ErrorPageTemplateBuilder {
                     crate::router::RouteKind::Handler => "View".to_owned(),
                 },
                 name: route.name().unwrap_or_default().to_owned(),
+                app: route.app_name().map(|a| a.0.clone()).unwrap_or_default(),
             });
 
             if let Some(inner_router) = route.router() {
                 Self::build_route_data(
                     route_data,
-                    inner_router,
-                    &format!("{}{}", url_prefix, route.url()),
+                    &inner_router,
+                    &full_path,
                     &format!("{index_prefix}{index}."),
                 );
             }
@@ -242,6 +251,7 @@ struct RouteData {
     path: String,
     kind: String,
     name: String,
+    app: String,
 }
 
 #[derive(Debug, Clone)]
@@ -453,6 +463,10 @@ mod tests {
     use std::panic;
     use std::sync::Arc;
 
+    use cot_core::handler::RequestHandler;
+    use cot_core::html::Html;
+    use cot_core::request::Request;
+    use cot_core::response::{IntoResponse, Response};
     use tracing_test::traced_test;
 
     use super::*;
@@ -468,6 +482,14 @@ mod tests {
         }
     }
 
+    struct MockHandler;
+
+    impl RequestHandler for MockHandler {
+        fn handle(&self, _request: Request) -> impl Future<Output = Result<Response>> {
+            std::future::ready(Html::new("OK").into_response())
+        }
+    }
+
     #[test]
     #[traced_test]
     fn test_log_error() {
@@ -588,9 +610,16 @@ mod tests {
         let mut route_data = Vec::new();
         let sub_sub_router = Router::with_urls(vec![]);
         let sub_router = Router::with_urls(vec![Route::with_router("/bar", sub_sub_router)]);
-        let router = Router::with_urls(vec![Route::with_router("/foo", sub_router)]);
-
-        ErrorPageTemplateBuilder::build_route_data(&mut route_data, &router, "", "");
+        let router = Arc::new(Router::with_urls(vec![Route::with_router(
+            "/foo", sub_router,
+        )]));
+
+        ErrorPageTemplateBuilder::build_route_data(
+            &mut route_data,
+            &router,
+            &AbsolutePath::root(),
+            "",
+        );
 
         assert_eq!(
             route_data,
@@ -599,18 +628,61 @@ mod tests {
                     index: "0".to_string(),
                     path: "/foo".to_string(),
                     kind: "Root Router".to_string(),
-                    name: String::new()
+                    name: String::new(),
+                    app: String::new()
                 },
                 RouteData {
                     index: "0.0".to_string(),
                     path: "/foo/bar".to_string(),
                     kind: "Router".to_string(),
-                    name: String::new()
+                    name: String::new(),
+                    app: String::new()
                 }
             ]
         );
     }
 
+    #[test]
+    fn build_route_data_root_mount_no_double_slash() {
+        let mut route_data = Vec::new();
+        let sub_router = Router::with_urls(vec![Route::with_handler_and_name(
+            "/",
+            MockHandler,
+            "index",
+        )]);
+        let router = Arc::new(Router::with_urls(vec![Route::with_router("/", sub_router)]));
+
+        ErrorPageTemplateBuilder::build_route_data(
+            &mut route_data,
+            &router,
+            &AbsolutePath::root(),
+            "",
+        );
+
+        assert_eq!(route_data[0].path, "/");
+        assert_eq!(route_data[1].path, "/");
+    }
+
+    #[test]
+    fn build_route_data_root_mount_with_nested_static_route() {
+        let mut route_data = Vec::new();
+        let sub_router = Router::with_urls(vec![Route::with_handler_and_name(
+            "/nested",
+            MockHandler,
+            "nested",
+        )]);
+        let router = Arc::new(Router::with_urls(vec![Route::with_router("/", sub_router)]));
+
+        ErrorPageTemplateBuilder::build_route_data(
+            &mut route_data,
+            &router,
+            &AbsolutePath::root(),
+            "",
+        );
+
+        assert_eq!(route_data[1].path, "/nested");
+    }
+
     #[test]
     fn test_build_cot_failure_page() {
         let response = build_cot_failure_page();

cot/src/openapi.rs

@@ -86,7 +86,7 @@
 //!     }
 //!
 //!     fn register_apps(&self, apps: &mut AppBuilder, _context: &RegisterAppsContext) {
-//!         apps.register_with_views(SwaggerUi::new(), "/swagger");
+//!         apps.register_with_views(SwaggerUi::new(), "/swagger/");
 //!         apps.register_with_views(AddApp, "");
 //!     }
 //! }