feat(router): Add chainable routes

Cargo.toml

@@ -84,5 +84,10 @@ path = "examples/chaining.rs"
 
 [[example]]
 
+name = "chainable_router"
+path = "examples/chainable_router.rs"
+
+[[example]]
+
 name = "form_data"
 path = "examples/form_data/form_data.rs"

examples/chainable_router.rs

@@ -0,0 +1,22 @@
+#[macro_use] extern crate nickel;
+extern crate hyper;
+
+use nickel::{Nickel};
+use nickel::router::chainable_router::{ChainablePath, ChainableHandler};
+
+fn main() {
+    let mut server = Nickel::new();
+    server
+        .route("/")
+        .get(middleware!("get"))
+        .post(middleware!("post"))
+        .put(middleware!("put"))
+        .patch(middleware!("patch"))
+        .delete(middleware!("delete"))
+        .route("/chain1")
+        .get(middleware!("chain1"))
+        .route("/chain2")
+        .get(middleware!("chain2"));
+
+    server.listen("127.0.0.1:6767");
+}

src/router/chainable_router.rs

@@ -0,0 +1,71 @@
+use hyper::method::Method;
+use middleware::Middleware;
+use nickel::Nickel;
+use router::http_router::{HttpRouter};
+
+pub struct ChainableRoute<'a, D: Sync + Send + 'static = ()> {
+    path: String,
+    nickel: &'a mut Nickel<D>
+}
+
+pub trait ChainablePath<'a, D> {
+    fn route(&'a mut self, path: &str) -> ChainableRoute<'a, D>;
+}
+
+impl<'a, D: Sync + Send + 'static> ChainablePath<'a, D> for Nickel<D> {
+    fn route(&'a mut self, path: &str) -> ChainableRoute<'a, D> {
+        ChainableRoute {
+            path: path.to_string(),
+            nickel: self
+        }
+    }
+}
+
+pub trait ChainableHandler<'a, D> {
+    fn route(&'a mut self, path: &str) -> ChainableRoute<'a, D>;
+    fn get<H: Middleware<D>>(&mut self, handler: H) -> &mut Self;
+    fn post<H: Middleware<D>>(&mut self, handler: H) -> &mut Self;
+    fn delete<H: Middleware<D>>(&mut self, handler: H) -> &mut Self;
+    fn options<H: Middleware<D>>(&mut self, handler: H) -> &mut Self;
+    fn patch<H: Middleware<D>>(&mut self, handler: H) -> &mut Self;
+    fn put<H: Middleware<D>>(&mut self, handler: H) -> &mut Self;
+}
+
+impl<'a, D: Sync + Send + 'static> ChainableHandler<'a, D> for ChainableRoute<'a, D> {
+    fn route(&'a mut self, path: &str) -> ChainableRoute<'a, D> {
+        ChainableRoute {
+            path: path.to_string(),
+            nickel: self.nickel
+        }
+    }
+    fn get<H: Middleware<D>>(&mut self, handler: H) -> &mut Self {
+        let path = self.path.clone();
+        self.nickel.add_route(Method::Get, &path[..], handler);
+        self
+    }
+    fn post<H: Middleware<D>>(&mut self, handler: H) -> &mut Self {
+        let path = self.path.clone();
+        self.nickel.add_route(Method::Post, &path[..], handler);
+        self
+    }
+    fn delete<H: Middleware<D>>(&mut self, handler: H) -> &mut Self {
+        let path = self.path.clone();
+        self.nickel.add_route(Method::Delete, &path[..], handler);
+        self
+    }
+    fn options<H: Middleware<D>>(&mut self, handler: H) -> &mut Self {
+        let path = self.path.clone();
+        self.nickel.add_route(Method::Options, &path[..], handler);
+        self
+    }
+    fn patch<H: Middleware<D>>(&mut self, handler: H) -> &mut Self {
+        let path = self.path.clone();
+        self.nickel.add_route(Method::Patch, &path[..], handler);
+        self
+    }
+    fn put<H: Middleware<D>>(&mut self, handler: H) -> &mut Self {
+        let path = self.path.clone();
+        self.nickel.add_route(Method::Put, &path[..], handler);
+        self
+    }
+}

src/router/mod.rs

@@ -6,5 +6,6 @@ pub use self::into_matcher::FORMAT_PARAM;
 
 pub mod http_router;
 pub mod router;
+pub mod chainable_router;
 mod matcher;
 mod into_matcher;