feat: add router merge

Author: dancixx

src/main.rs

@@ -140,6 +140,10 @@ async fn main() {
         .realm("Admin Area")
         .into_middleware();
 
+    let mut r2 = tako::router::Router::new();
+    r2.route(Method::GET, "/compression", compression);
+    r.merge(r2);
+
     r.route(Method::GET, "/compression", compression)
         .middleware(basic);
 

src/route.rs

@@ -4,7 +4,7 @@
 /// HTTP method, handler, and any associated middleware. It also provides utilities for
 /// matching paths and extracting parameters from dynamic segments.
 use std::{
-    collections::HashMap,
+    collections::{HashMap, VecDeque},
     sync::{Arc, RwLock},
 };
 
@@ -39,7 +39,7 @@ pub struct Route {
     pub param_names: Vec<String>,
     pub method: Method,
     pub handler: BoxHandler,
-    pub middlewares: RwLock<Vec<BoxMiddleware>>,
+    pub middlewares: RwLock<VecDeque<BoxMiddleware>>,
     pub tsr: bool,
 }
 
@@ -65,7 +65,7 @@ impl Route {
             param_names,
             method,
             handler,
-            middlewares: RwLock::new(Vec::new()),
+            middlewares: RwLock::new(VecDeque::new()),
             tsr: tsr.unwrap_or(false),
         }
     }
@@ -92,7 +92,7 @@ impl Route {
             Box::pin(async move { fut.await.into_response() })
         });
 
-        self.middlewares.write().unwrap().push(mw);
+        self.middlewares.write().unwrap().push_back(mw);
         self
     }
 

src/router.rs

@@ -298,13 +298,50 @@ impl Router {
         self.plugins.iter().map(|plugin| plugin.as_ref()).collect()
     }
 
+    /// Merges another `Router` into the current `Router`.
+    ///
+    /// This method combines the routes and middlewares of the provided `Router`
+    /// into the current `Router`. Routes from the other `Router` are added to
+    /// the current one, and its middlewares are prepended to the route-level
+    /// middlewares of the merged routes.
+    ///
+    /// # Arguments
+    ///
+    /// * `other` - The `Router` instance to merge into the current `Router`.
+    ///
+    /// # Behavior
+    ///
+    /// - Routes from the `other` router are added to the current router.
+    /// - Middlewares defined at the router level in the `other` router are
+    ///   prepended to the route-level middlewares of the merged routes.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use tako::router::Router;
+    /// use http::Method;
+    ///
+    /// let mut router1 = Router::new();
+    /// router1.route(Method::GET, "/example1", |req| async move {
+    ///     Ok(req)
+    /// });
+    ///
+    /// let mut router2 = Router::new();
+    /// router2.route(Method::POST, "/example2", |req| async move {
+    ///     Ok(req)
+    /// });
+    ///
+    /// router1.merge(router2);
+    /// ```
     pub fn merge(&mut self, other: Router) {
-        other.routes.into_iter().for_each(|route| {});
-        other
-            .middlewares
-            .read()
-            .unwrap()
-            .iter()
-            .for_each(|middleware| {});
+        other.routes.iter_mut().for_each(|mut entry| {
+            let (key, route) = entry.pair_mut();
+            // add router level middlewares at the beginning of the middlewares on route level
+            for mw in other.middlewares.read().unwrap().iter().rev() {
+                route.middlewares.write().unwrap().push_front(mw.clone());
+            }
+
+            self.routes.insert(key.to_owned(), route.to_owned());
+        });
     }
 }