feat: route_dyn & fix doc test

Author: shellfly

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "haro"
-version = "0.1.0"
+version = "0.2.0"
 edition = "2021"
 description = "A simple and synchronous web framework written in and for Rust"
 license = "MIT OR Apache-2.0"

Cargo.toml

@@ -0,0 +1,15 @@
+/// Use `route_dyn` to register a handler with closure
+use std::sync::Arc;
+
+use haro::{Application, DynHandler, Response};
+
+fn main() {
+    let mut app = Application::new("0:8080");
+    app.route_dyn("/", hello("Haro"));
+    app.run();
+}
+
+fn hello(name: &str) -> DynHandler {
+    let name = name.to_string();
+    Arc::new(move |_| Response::str(&name))
+}

examples/closure/main.rs

@@ -1,12 +1,9 @@
 use std::sync::Arc;
 
 use cookie::Cookie;
+use haro::{middleware, Application, DynHandler, Request, Response};
 use http::header::SET_COOKIE;
 use serde_json::json;
-use haro::{
-    middleware::{self, DynHandler},
-    Application, Request, Response,
-};
 
 fn main() {
     let mut app = Application::new("0:8080");
@@ -34,7 +31,7 @@ fn hello(req: Request) -> Response {
 fn session_middleware(next: DynHandler) -> DynHandler {
     Arc::new(move |req: Request| -> Response {
         let cookies = req.cookies();
-        println!("get cookies: {:?}", cookies);
+        println!("get cookies: {cookies:?}");
 
         let mut res = next(req);
 

examples/cookie/main.rs

@@ -1,9 +1,6 @@
 use std::sync::Arc;
 
-use haro::{
-    middleware::{self, DynHandler},
-    Application, Request, Response,
-};
+use haro::{middleware, Application, DynHandler, Request, Response};
 use serde_json::json;
 
 fn main() {

examples/middleware/main.rs

@@ -1,7 +1,7 @@
 // NOTE: add `haro` crate with `full` or `template` feature flag to use database utilities.
 
-use tera::Context;
 use haro::{Application, Request, Response};
+use tera::Context;
 
 fn main() {
     let mut app = Application::new("0:8080");

examples/template/main.rs

@@ -7,9 +7,9 @@ use std::{net::TcpListener, thread};
 use log::{debug, info};
 
 use crate::http::conn::Conn;
-use crate::middleware::{make_dyn_handler, Middleware};
+use crate::middleware::Middleware;
 use crate::pool::ThreadPool;
-use crate::router::{Handler, Router};
+use crate::router::{make_dyn_handler, DynHandler, Handler, Router};
 use crate::{Request, Response};
 
 /// A web Application with routes and middlewares
@@ -65,7 +65,7 @@ impl Application {
         self.middlewares.push(Arc::new(middleware));
     }
 
-    /// Add a route into an `Application`
+    /// Add a route using plain `fn` pointer
     /// # Example
     /// ```
     /// use haro::{Application, Request, Response, middleware};
@@ -78,6 +78,24 @@ impl Application {
     /// }
     /// ```
     pub fn route(&mut self, pattern: &'static str, handler: Handler) {
+        self.route_dyn(pattern, make_dyn_handler(handler))
+    }
+
+    /// Add a route using closure
+    /// # Example
+    /// ```
+    /// use std::sync::Arc;
+    /// use haro::{Application, DynHandler, Response};
+    ///
+    /// let mut app = Application::new("0:8080");
+    /// app.route_dyn("/", hello("Haro"));
+    ///
+    /// fn hello(name: &str) -> DynHandler {
+    ///   let name = name.to_string();
+    ///   Arc::new(move |_| Response::str(&name))
+    /// }
+    /// ```
+    pub fn route_dyn(&mut self, pattern: &'static str, handler: DynHandler) {
         self.router.add(pattern, handler);
     }
 
@@ -105,21 +123,20 @@ impl Application {
         body: &[u8],
     ) -> Response {
         let mut req = Request::new(method, uri, headers, body);
-        let (params, handler) = self.router.dispatch(req.path());
+        let (params, mut handler) = self.router.dispatch(req.path());
         req.params = params;
 
         // TODO: how much benefits to move applying middlewares at begging to avoid do it every time in a new request.
-        let mut dyn_handler = make_dyn_handler(handler);
         // apply middleware in reverse order
         for middleware in self.middlewares.iter().rev() {
-            dyn_handler = middleware(dyn_handler);
+            handler = middleware(handler);
         }
-        dyn_handler(req)
+        handler(req)
     }
 
     /// Run the application, start listening on the specify address and start a worker pool to handle requests
     /// # Examples
-    /// ```
+    /// ```no_run
     /// use std::collections::HashMap;
     /// use haro::{Application, Request, Response};
     ///
@@ -156,15 +173,14 @@ impl Application {
 fn handle_connection(router: Router, middlewares: Vec<Arc<Middleware>>, stream: TcpStream) {
     let mut conn = Conn::from(stream);
     let mut req = Request::from(&mut conn);
-    let (params, handler) = router.dispatch(req.path());
+    let (params, mut handler) = router.dispatch(req.path());
     req.params = params;
 
-    let mut dyn_handler = make_dyn_handler(handler);
     // apply middleware in reverse order
     for middleware in middlewares.iter().rev() {
-        dyn_handler = middleware(dyn_handler);
+        handler = middleware(handler);
     }
-    let res = dyn_handler(req);
+    let res = handler(req);
 
     conn.write_all(res.to_string().as_bytes());
     conn.flush();
@@ -176,6 +192,6 @@ mod tests {
 
     #[test]
     fn it_works() {
-        let app = Application::new("0:65530").num_threads(2);
+        Application::new("0:65530").num_threads(2);
     }
 }

src/app.rs

@@ -24,9 +24,9 @@ impl Response {
     /// ```
     /// use std::collections::HashMap;
     /// use http::StatusCode;
-    /// use haro::Resposne;
+    /// use haro::Response;
     ///
-    /// let body = &Vec::new()
+    /// let body = &Vec::new();
     /// let headers = HashMap::new();
     /// let res = Response::new(StatusCode::OK, body, headers);
     /// ```

src/http/response.rs

@@ -20,7 +20,7 @@
 //! The "Hello, World!" of Haro is:
 //!
 //! ```rust,no_run
-//! use haro::{Applicatoin,  Request, Response}
+//! use haro::{Application,  Request, Response};
 //!
 //! fn main() {
 //!     let mut app = Application::new("0:8000");
@@ -64,7 +64,7 @@ mod router;
 pub use crate::app::Application;
 pub use crate::http::request::Request;
 pub use crate::http::response::{redirect, Response};
-
+pub use crate::router::{make_dyn_handler, DynHandler, Handler};
 #[cfg(feature = "template")]
 mod template;
 

src/lib.rs

@@ -6,34 +6,15 @@ use std::time::Instant;
 
 use log::info;
 
-use crate::{router::Handler, Request, Response};
+use crate::{DynHandler, Request, Response};
 
-// pub trait Middleware {
-//     fn process_request(&self, _: &mut Request) -> Option<Response> {
-//         None
-//     }
-//     fn process_response(&self, _: &mut Response) {}
-// }
-
-// pub struct Logging {}
-
-// impl Middleware for Logging {
-//     fn process_request(&self, req: &mut Request) -> Option<Response> {
-//         info!("{} {}", req.method(), req.full_path());
-//         None
-//     }
-// }
-
-/// Closure type of handler in order to capture environment variables, required when writing a middleware
-pub type DynHandler = Arc<dyn Fn(Request) -> Response>;
-
-/// Function type for a middleware to receive a [`DynHandler`] and return a new [`DynHandler`]
+/// Function type for a middleware to receive a [`Handler`] and return a new [`Handler`]
 pub type Middleware = fn(next: DynHandler) -> DynHandler;
 
 /// Logging middleware to log every request and response time
 /// # Example
 /// ```
-/// use haro::{Application, middleware}
+/// use haro::{Application, middleware};
 ///
 /// let mut app = Application::new("0:8080");
 /// app.middleware(middleware::logging);
@@ -52,18 +33,3 @@ pub fn logging(next: DynHandler) -> DynHandler {
         res
     })
 }
-
-/// Change a fn pointer to a closure
-/// # Example
-/// ```
-/// use haro::{Request, Response, middleware};
-///
-/// fn handler(_:Request) -> Response{
-///     Response::str("hello")
-/// }
-///
-/// let dyn_handler = middleware::make_dyn_handler(handler);
-/// ```
-pub fn make_dyn_handler(h: Handler) -> DynHandler {
-    Arc::new(move |req: Request| -> Response { h(req) })
-}

src/middleware.rs

@@ -1,21 +1,25 @@
 use std::collections::HashMap;
 use std::fmt::Display;
+use std::sync::Arc;
 
 use http::StatusCode;
 use regex::Regex;
 
 use crate::http::request::Request;
 use crate::http::response::Response;
 
+/// Handler type that receive a [`Request`] and return a [`Response`]
 pub type Handler = fn(Request) -> Response;
+/// Closure type of handler in order to write a handler to capture environment variables
+pub type DynHandler = Arc<dyn Fn(Request) -> Response + Send + Sync>;
 
 #[derive(Default, Clone)]
 pub struct Router {
-    routes: Vec<(Rule, Handler)>,
+    routes: Vec<(Rule, DynHandler)>,
 }
 
 impl Router {
-    pub fn add(&mut self, pattern: &'static str, handler: Handler) {
+    pub fn add(&mut self, pattern: &'static str, handler: DynHandler) {
         let rule = Rule::from(pattern);
         self.routes.push((rule, handler));
         self.update_order()
@@ -27,13 +31,13 @@ impl Router {
             .sort_by(|a, b| b.0.num_parts.cmp(&a.0.num_parts));
     }
 
-    pub fn dispatch(&self, path: &str) -> (HashMap<String, String>, Handler) {
+    pub fn dispatch(&self, path: &str) -> (HashMap<String, String>, DynHandler) {
         for (rule, handler) in &self.routes {
             if let Some(params) = rule._match(path) {
-                return (params, *handler);
+                return (params, handler.clone());
             }
         }
-        (HashMap::new(), not_found)
+        (HashMap::new(), make_dyn_handler(not_found))
     }
 }
 
@@ -63,7 +67,7 @@ impl From<&'static str> for Rule {
         let mut has_regex = false;
         for part in pattern.split('/') {
             if let Some(stripped) = part.strip_prefix(':') {
-                let regex_part = format!("(?P<{}>.+)", stripped);
+                let regex_part = format!("(?P<{stripped}>.+)");
                 parts.push(regex_part);
                 has_regex = true
             } else if !part.is_empty() {
@@ -114,3 +118,18 @@ fn not_found(_req: Request) -> Response {
         HashMap::new(),
     )
 }
+
+/// Change a fn pointer to a closure
+/// # Example
+/// ```
+/// use haro::{Request, Response, middleware,make_dyn_handler};
+///
+/// fn handler(_:Request) -> Response{
+///     Response::str("hello")
+/// }
+///
+/// let dyn_handler = make_dyn_handler(handler);
+/// ```
+pub fn make_dyn_handler(h: Handler) -> DynHandler {
+    Arc::new(move |req: Request| -> Response { h(req) })
+}

src/router.rs

@@ -5,7 +5,7 @@ pub(crate) static TEMPLATES: Lazy<Tera> = Lazy::new(|| {
     let tera = match Tera::new("templates/**/*") {
         Ok(t) => t,
         Err(e) => {
-            println!("Parsing error(s): {}", e);
+            println!("Parsing error(s): {e}");
             ::std::process::exit(1);
         }
     };

src/template.rs

@@ -1,8 +1,4 @@
-use haro::{
-    db,
-    middleware::{self, DynHandler},
-    Application, Request, Response,
-};
+use haro::{db, middleware, Application, DynHandler, Request, Response};
 use http::StatusCode;
 use serde::{Deserialize, Serialize};
 use serde_json::json;