split apart router and subrouter

Author: tzilist

examples/simple_nested_router.rs

@@ -4,7 +4,7 @@
 
 use tide::{
     head::{Named, NamedComponent},
-    Router,
+    Router, SubRouter,
 };
 
 struct Number(i32);
@@ -26,12 +26,17 @@ async fn add_two(Named(number): Named<Number>) -> String {
     format!("{} plus two is {}", num, num + 2)
 }
 
-fn build_add_two<Data: Clone + Send + Sync + 'static>(router: &mut Router<Data>) {
+fn build_add_two<Data: Clone + Send + Sync + 'static>(router: &mut SubRouter<Data>) {
     router.at("{num}").get(add_two);
 }
 
 fn main() {
     let mut app = tide::App::new(());
+    app.at("/speech").nest(|router| {
+        router.at("hello").get(async || "hello world");
+        router.at("nice").get(async || "nice!");
+    });
+
     app.at("add_two").nest(build_add_two);
     app.serve("127.0.0.1:8000");
 }

src/app.rs

@@ -14,7 +14,7 @@ use crate::{
     endpoint::Endpoint,
     extract::Extract,
     middleware::{logger::RootLogger, RequestContext},
-    router::{Resource, RouteResult, Router},
+    router::{BaseRouter, Resource, RouteResult, Router},
     Middleware, Request, Response, RouteMatch,
 };
 
@@ -25,7 +25,7 @@ use crate::{
 /// They also hold a top-level router.
 pub struct App<Data> {
     data: Data,
-    router: Router<Data>,
+    router: BaseRouter<Data>,
 }
 
 impl<Data: Clone + Send + Sync + 'static> App<Data> {
@@ -34,7 +34,7 @@ impl<Data: Clone + Send + Sync + 'static> App<Data> {
         let logger = RootLogger::new();
         let mut app = App {
             data,
-            router: Router::new(),
+            router: BaseRouter::new(),
         };
 
         // Add RootLogger as a default middleware
@@ -43,7 +43,7 @@ impl<Data: Clone + Send + Sync + 'static> App<Data> {
     }
 
     /// Get the top-level router.
-    pub fn router(&mut self) -> &mut Router<Data> {
+    pub fn router(&mut self) -> &mut BaseRouter<Data> {
         &mut self.router
     }
 
@@ -99,7 +99,7 @@ impl<Data: Clone + Send + Sync + 'static> App<Data> {
 #[derive(Clone)]
 struct Server<Data> {
     data: Data,
-    router: Arc<Router<Data>>,
+    router: Arc<BaseRouter<Data>>,
 }
 
 impl<Data: Clone + Send + Sync + 'static> Service for Server<Data> {

src/lib.rs

@@ -29,6 +29,6 @@ pub use crate::{
     middleware::Middleware,
     request::Request,
     response::{IntoResponse, Response},
-    router::{Resource, Router},
+    router::{BaseRouter, Resource, Router, SubRouter},
 };
 pub use path_table::RouteMatch;

src/router.rs

@@ -10,19 +10,24 @@ use path_table::{PathTable, RouteMatch};
 /// A core type for routing.
 ///
 /// The `Router` type can be used to set up routes and resources, and to apply middleware.
-pub struct Router<Data> {
+pub struct BaseRouter<Data> {
     table: PathTable<ResourceData<Data>>,
     middleware_base: Vec<Arc<dyn Middleware<Data> + Send + Sync>>,
     default_handler: Arc<BoxedEndpoint<Data>>,
 }
 
+pub struct SubRouter<Data> {
+    table: PathTable<ResourceData<Data>>,
+    middleware_base: Vec<Arc<dyn Middleware<Data> + Send + Sync>>,
+}
+
 pub(crate) struct RouteResult<'a, Data> {
     pub(crate) endpoint: &'a BoxedEndpoint<Data>,
     pub(crate) params: Option<RouteMatch<'a>>,
     pub(crate) middleware: &'a [Arc<dyn Middleware<Data> + Send + Sync>],
 }
 
-pub async fn base_default_handler() -> http::status::StatusCode {
+async fn base_default_handler() -> http::status::StatusCode {
     http::status::StatusCode::NOT_FOUND
 }
 
@@ -59,23 +64,19 @@ fn route_match_failure<'a, Data>(
     }
 }
 
-impl<Data: Clone + Send + Sync + 'static> Router<Data> {
-    /// Create a new top-level router.
-    pub(crate) fn new() -> Router<Data> {
-        Router {
-            table: PathTable::new(),
-            middleware_base: Vec::new(),
-            default_handler: Arc::new(BoxedEndpoint::new(base_default_handler)),
-        }
-    }
+pub trait Router<Data: Clone + Send + Sync + 'static> {
+    fn at<'a>(&'a mut self, path: &'a str) -> Resource<'a, Data>;
+
+    fn middleware(&mut self, middleware: impl Middleware<Data> + 'static) -> &mut Self;
+}
 
+impl<Data: Clone + Send + Sync + 'static> Router<Data> for BaseRouter<Data> {
     /// Add a new resource at `path`, relative to this router.
-    pub fn at<'a>(&'a mut self, path: &'a str) -> Resource<'a, Data> {
+    fn at<'a>(&'a mut self, path: &'a str) -> Resource<'a, Data> {
         let table = self.table.setup_table(path);
         Resource {
             table,
             middleware_base: &self.middleware_base,
-            default_handler: &self.default_handler,
         }
     }
 
@@ -107,14 +108,44 @@ impl<Data: Clone + Send + Sync + 'static> Router<Data> {
     ///     router.at("").get(async || "B then A");
     /// });
     /// ```
-    pub fn middleware(&mut self, middleware: impl Middleware<Data> + 'static) -> &mut Self {
+    fn middleware(&mut self, middleware: impl Middleware<Data> + 'static) -> &mut Self {
+        let middleware = Arc::new(middleware);
+        for resource in self.table.iter_mut() {
+            resource.middleware.push(middleware.clone());
+        }
+        self.middleware_base.push(middleware);
+        self
+    }
+}
+
+impl<Data: Clone + Send + Sync + 'static> Router<Data> for SubRouter<Data> {
+    fn at<'a>(&'a mut self, path: &'a str) -> Resource<'a, Data> {
+        let table = self.table.setup_table(path);
+        Resource {
+            table,
+            middleware_base: &self.middleware_base,
+        }
+    }
+
+    fn middleware(&mut self, middleware: impl Middleware<Data> + 'static) -> &mut Self {
         let middleware = Arc::new(middleware);
         for resource in self.table.iter_mut() {
             resource.middleware.push(middleware.clone());
         }
         self.middleware_base.push(middleware);
         self
     }
+}
+
+impl<Data: Clone + Send + Sync + 'static> BaseRouter<Data> {
+    /// Create a new top-level router.
+    pub(crate) fn new() -> BaseRouter<Data> {
+        BaseRouter {
+            table: PathTable::new(),
+            middleware_base: Vec::new(),
+            default_handler: Arc::new(BoxedEndpoint::new(base_default_handler)),
+        }
+    }
 
     pub fn set_default_handler<T: Endpoint<Data, U>, U>(&mut self, ep: T) -> &mut Self {
         self.default_handler = Arc::new(BoxedEndpoint::new(ep));
@@ -148,7 +179,6 @@ impl<Data: Clone + Send + Sync + 'static> Router<Data> {
 pub struct Resource<'a, Data> {
     table: &'a mut PathTable<ResourceData<Data>>,
     middleware_base: &'a Vec<Arc<dyn Middleware<Data> + Send + Sync>>,
-    default_handler: &'a Arc<BoxedEndpoint<Data>>,
 }
 
 struct ResourceData<Data> {
@@ -164,11 +194,10 @@ impl<'a, Data> Resource<'a, Data> {
     /// the builder will be local to the subrouter and its descendents.
     ///
     /// If resources are already present, they will be discarded.
-    pub fn nest(self, builder: impl FnOnce(&mut Router<Data>)) {
-        let mut subrouter = Router {
+    pub fn nest(self, builder: impl FnOnce(&mut SubRouter<Data>)) {
+        let mut subrouter = SubRouter {
             table: PathTable::new(),
             middleware_base: self.middleware_base.clone(),
-            default_handler: self.default_handler.clone(),
         };
         builder(&mut subrouter);
         *self.table = subrouter.table;
@@ -253,7 +282,7 @@ mod tests {
     }
 
     async fn simulate_request<'a, Data: Default + Clone + Send + Sync + 'static>(
-        router: &'a Router<Data>,
+        router: &'a BaseRouter<Data>,
         path: &'a str,
         method: &'a http::Method,
     ) -> Option<Response> {
@@ -281,7 +310,7 @@ mod tests {
     }
 
     fn route_middleware_count<Data: Clone + Send + Sync + 'static>(
-        router: &Router<Data>,
+        router: &BaseRouter<Data>,
         path: &str,
         method: &http::Method,
     ) -> Option<usize> {
@@ -291,7 +320,7 @@ mod tests {
 
     #[test]
     fn simple_static() {
-        let mut router: Router<()> = Router::new();
+        let mut router: BaseRouter<()> = BaseRouter::new();
         router.at("/").get(async || "/");
         router.at("/foo").get(async || "/foo");
         router.at("/foo/bar").get(async || "/foo/bar");
@@ -311,7 +340,7 @@ mod tests {
 
     #[test]
     fn nested_static() {
-        let mut router: Router<()> = Router::new();
+        let mut router: BaseRouter<()> = BaseRouter::new();
         router.at("/a").get(async || "/a");
         router.at("/b").nest(|router| {
             router.at("/").get(async || "/b");
@@ -357,7 +386,7 @@ mod tests {
 
     #[test]
     fn multiple_methods() {
-        let mut router: Router<()> = Router::new();
+        let mut router: BaseRouter<()> = BaseRouter::new();
         router
             .at("/a")
             .nest(|router| router.at("/b").get(async || "/a/b GET"));
@@ -378,7 +407,7 @@ mod tests {
     #[test]
     #[should_panic]
     fn duplicate_endpoint_fails() {
-        let mut router: Router<()> = Router::new();
+        let mut router: BaseRouter<()> = BaseRouter::new();
         router
             .at("/a")
             .nest(|router| router.at("/b").get(async || "")); // flattened into /a/b
@@ -387,7 +416,7 @@ mod tests {
 
     #[test]
     fn simple_middleware() {
-        let mut router: Router<()> = Router::new();
+        let mut router: BaseRouter<()> = BaseRouter::new();
         router.middleware(passthrough_middleware);
         router.at("/").get(async || "/");
         router.at("/b").nest(|router| {
@@ -423,7 +452,7 @@ mod tests {
 
         // The order of endpoint and middleware does not matter
         // The order of subrouter and middleware DOES matter
-        let mut router: Router<Data> = Router::new();
+        let mut router: BaseRouter<Data> = BaseRouter::new();
         router.middleware(Pusher(0));
         router.at("/").get(async move |data: AppData<Data>| {
             if (data.0).0 == [0, 2] {