Merge pull request #8 from Turbo87/pattern

Expose the matched route pattern in the request extensions

Author: jtgeibel

src/lib.rs

@@ -11,7 +11,21 @@ use router::{Match, Router};
 
 #[derive(Default)]
 pub struct RouteBuilder {
-    routers: HashMap<Method, Router<Box<dyn Handler>>>,
+    routers: HashMap<Method, Router<WrappedHandler>>,
+}
+
+#[derive(Clone, Copy)]
+pub struct RoutePattern(&'static str);
+
+pub struct WrappedHandler {
+    pattern: RoutePattern,
+    handler: Box<dyn Handler>,
+}
+
+impl conduit::Handler for WrappedHandler {
+    fn call(&self, request: &mut dyn RequestExt) -> HandlerResult {
+        self.handler.call(request)
+    }
 }
 
 #[derive(Debug)]
@@ -29,7 +43,7 @@ impl RouteBuilder {
         &'a self,
         method: &Method,
         path: &str,
-    ) -> Result<Match<&'a Box<dyn Handler>>, RouterError> {
+    ) -> Result<Match<&WrappedHandler>, RouterError> {
         match self.routers.get(method) {
             Some(router) => router.recognize(path),
             None => Err(format!("No router found for {:?}", method)),
@@ -40,36 +54,60 @@ impl RouteBuilder {
     pub fn map<'a, H: Handler>(
         &'a mut self,
         method: Method,
-        pattern: &str,
+        pattern: &'static str,
         handler: H,
     ) -> &'a mut RouteBuilder {
         {
             let router = match self.routers.entry(method) {
                 Entry::Occupied(e) => e.into_mut(),
                 Entry::Vacant(e) => e.insert(Router::new()),
             };
-            router.add(pattern, Box::new(handler));
+            let wrapped_handler = WrappedHandler {
+                pattern: RoutePattern(pattern),
+                handler: Box::new(handler),
+            };
+            router.add(pattern, wrapped_handler);
         }
         self
     }
 
-    pub fn get<'a, H: Handler>(&'a mut self, pattern: &str, handler: H) -> &'a mut RouteBuilder {
+    pub fn get<'a, H: Handler>(
+        &'a mut self,
+        pattern: &'static str,
+        handler: H,
+    ) -> &'a mut RouteBuilder {
         self.map(Method::GET, pattern, handler)
     }
 
-    pub fn post<'a, H: Handler>(&'a mut self, pattern: &str, handler: H) -> &'a mut RouteBuilder {
+    pub fn post<'a, H: Handler>(
+        &'a mut self,
+        pattern: &'static str,
+        handler: H,
+    ) -> &'a mut RouteBuilder {
         self.map(Method::POST, pattern, handler)
     }
 
-    pub fn put<'a, H: Handler>(&'a mut self, pattern: &str, handler: H) -> &'a mut RouteBuilder {
+    pub fn put<'a, H: Handler>(
+        &'a mut self,
+        pattern: &'static str,
+        handler: H,
+    ) -> &'a mut RouteBuilder {
         self.map(Method::PUT, pattern, handler)
     }
 
-    pub fn delete<'a, H: Handler>(&'a mut self, pattern: &str, handler: H) -> &'a mut RouteBuilder {
+    pub fn delete<'a, H: Handler>(
+        &'a mut self,
+        pattern: &'static str,
+        handler: H,
+    ) -> &'a mut RouteBuilder {
         self.map(Method::DELETE, pattern, handler)
     }
 
-    pub fn head<'a, H: Handler>(&'a mut self, pattern: &str, handler: H) -> &'a mut RouteBuilder {
+    pub fn head<'a, H: Handler>(
+        &'a mut self,
+        pattern: &'static str,
+        handler: H,
+    ) -> &'a mut RouteBuilder {
         self.map(Method::HEAD, pattern, handler)
     }
 }
@@ -88,6 +126,7 @@ impl conduit::Handler for RouteBuilder {
 
         {
             let extensions = request.mut_extensions();
+            extensions.insert(m.handler.pattern);
             extensions.insert(m.params.clone());
         }
 
@@ -130,7 +169,7 @@ mod tests {
     use std::io;
     use std::net::SocketAddr;
 
-    use {RequestParams, RouteBuilder};
+    use {RequestParams, RouteBuilder, RoutePattern};
 
     use self::conduit_test::ResponseExt;
     use conduit::{
@@ -206,7 +245,7 @@ mod tests {
         let res = router.call(&mut req).expect("No response");
 
         assert_eq!(res.status(), StatusCode::OK);
-        assert_eq!(*res.into_cow(), b"1, GET"[..]);
+        assert_eq!(*res.into_cow(), b"1, GET, /posts/:id"[..]);
     }
 
     #[test]
@@ -216,7 +255,7 @@ mod tests {
         let res = router.call(&mut req).expect("No response");
 
         assert_eq!(res.status(), StatusCode::OK);
-        assert_eq!(*res.into_cow(), b"10, POST"[..]);
+        assert_eq!(*res.into_cow(), b"10, POST, /posts/:id"[..]);
     }
 
     #[test]
@@ -237,6 +276,13 @@ mod tests {
         let mut res = vec![];
         res.push(req.params()["id"].clone());
         res.push(format!("{:?}", req.method()));
+        res.push(
+            req.extensions()
+                .find::<RoutePattern>()
+                .unwrap()
+                .0
+                .to_string(),
+        );
 
         let bytes = res.join(", ").into_bytes();
         Response::builder().body(Body::from_vec(bytes))