Renew fang util (#113)

* boxize large arrays & fix wrong size tracking in response headers & remove `custom-header` feature and default to support cutom headers & add test case for custom header handling in response headers

* next: some performance tuning

* Update response headers: specialize when insert `&'static str` value

* Update response headers: specialize when insert `&'static str` value

* Add: benches/src/bin/hello

* remove `const LOOP_LIMIT: u8 = 16;` in `Session::manage`

* Update: Taskfile::bench*

* remove `{Back,Fore,Front}Fang` & add `FangAction`; next: update docs

* Update docs & Fix some to pass tasks

Author: kanarus

Diff for: README.md

@@ -146,34 +146,51 @@ ohkami's request handling system is called "**fang**s", and middlewares are impl
 ```rust,no_run
 use ohkami::prelude::*;
 
-struct GreetFang;
-impl<I: FangProc> Fang<I> for GreetFang {
-    type Proc = GreetFangProc<I>;
+
+/* Full impl */
+
+use ohkami::{Fang, FangProc};
+
+struct GreetingFang;
+impl<I: FangProc> Fang<I> for GreetingFang {
+    type Proc = GreetingFangProc<I>;
     fn chain(&self, inner: I) -> Self::Proc {
-        GreetFangProc { inner }
+        GreetingFangProc { inner }
     }
 }
-
-struct GreetFangProc<I: FangProc> {
+struct GreetingFangProc<I: FangProc> {
     inner: I
 }
-impl<I: FangProc> FangProc for GreetFangProc<I> {
+impl<I: FangProc> FangProc for GreetingFangProc<I> {
     async fn bite<'b>(&'b self, req: &'b mut Request) -> Response {
-        println!("Welcome, request!\n{req:?}");
+        println!("Welcome, request!: {req:?}");
         let res = self.inner.bite(req).await;
-        println!("My response: \n{res:?}");
+        println!("Go, response!: {res:?}");
         res
     }
 }
 
+
+/* Easy impl with an utility */
+
+#[derive(Clone)]
+struct GreetingFang2;
+impl FangAction for GreetingFang2 {
+    async fn fore<'a>(&'a self, req: &'a mut Request) -> Result<(), Response> {
+        println!("Welcomm request!: {req:?}");
+        Ok(())
+    }
+    async fn back<'a>(&'a self, res: &'a mut Response) {
+        println!("Go, response!: {res:?}");
+    }
+}
+
+
 #[tokio::main]
 async fn main() {
     Ohkami::with((
-        /* Your `Fang` value */
-        GreetFang,
-
-        /* Inline Fang with utils */
-        ohkami::utils::ForeFang(|req| println!("{}", req.path())),
+        GreetingFang,
+        GreetingFang2,
     ), (
         "/".GET(|| async {"Hello, fangs!"})
     )).howl("localhost:3000").await
@@ -194,9 +211,17 @@ struct User {
     name: String
 }
 
+async fn list_users() -> Vec<User> {
+    vec![
+        User { name: String::from("actix") },
+        User { name: String::from("axum") },
+        User { name: String::from("ohkami") },
+    ]
+}
+
 async fn create_user() -> Created<User> {
     Created(User {
-        name: "ohkami web framework".to_string()
+        name: String::from("ohkami web framework")
     })
 }
 
@@ -209,12 +234,16 @@ async fn main() {
     // ...
 
     let users_ohkami = Ohkami::new((
-        "/".POST(create_user),
+        "/"
+            .GET(list_users)
+            .POST(create_user),
     ));
 
     Ohkami::new((
-        "/healthz"  .GET(health_check),
-        "/api/users".By(users_ohkami), // <-- nest by `By`
+        "/healthz"
+            .GET(health_check),
+        "/api/users"
+            .By(users_ohkami), // nest by `By`
     )).howl("localhost:5000").await
 }
 ```

Diff for: benches/src/bin/hello.rs

@@ -1,27 +1,17 @@
 use ohkami::prelude::*;
 use ohkami::{typed::Payload, builtin::payload::JSON};
 
+#[derive(Clone)]
 struct Logger;
-const _: () = {
-    impl<I: FangProc> Fang<I> for Logger {
-        type Proc = LoggerProc<I>;
-        fn chain(&self, inner: I) -> Self::Proc {
-            LoggerProc { inner }
-        }
+impl FangAction for Logger {
+    async fn fore<'a>(&'a self, req: &'a mut Request) -> Result<(), Response> {
+        tracing::info!("\n{req:?}");
+        Ok(())
     }
-
-    struct LoggerProc<I: FangProc> {
-        inner: I
-    }
-    impl<I: FangProc> FangProc for LoggerProc<I> {
-        async fn bite<'b>(&'b self, req: &'b mut Request) -> Response {
-            tracing::info!("\n{req:?}");
-            let res = self.inner.bite(req).await;
-            tracing::info!("\n{res:?}");
-            res
-        }
+    async fn back<'a>(&'a self, res: &'a mut Response) {
+        tracing::info!("\n{res:?}");
     }
-};
+}
 
 #[Payload(JSON/S)]
 struct Message {

Diff for: examples/form/src/main.rs

@@ -37,28 +37,17 @@ async fn post_submit(form_data: FormData<'_>) -> NoContent {
     NoContent
 }
 
-
-struct Logger; const _: () = {
-    impl<I: FangProc> Fang<I> for Logger {
-        type Proc = LoggerProc<I>;
-        fn chain(&self, inner: I) -> Self::Proc {
-            LoggerProc { inner }
-        }
+#[derive(Clone)]
+struct Logger;
+impl FangAction for Logger {
+    async fn fore<'a>(&'a self, req: &'a mut Request) -> Result<(), Response> {
+        println!("\n[req]\n{req:#?}");
+        Ok(())
     }
-
-    struct LoggerProc<I: FangProc> { inner: I }
-    impl<I: FangProc> FangProc for LoggerProc<I> {
-        async fn bite<'b>(&'b self, req: &'b mut Request) -> Response {
-            println!("\n[req]\n{req:#?}");
-
-            let res = self.inner.bite(req).await;
-
-            println!("\n[res]\n{res:#?}");
-
-            res
-        }
+    async fn back<'a>(&'a self, res: &'a mut Response) {
+        println!("\n[res]\n{res:#?}");
     }
-};
+}
 
 #[tokio::main]
 async fn main() {

Diff for: examples/hello/src/main.rs

@@ -64,10 +64,12 @@ mod hello_handler {
 
 
 mod fangs {
-    pub mod back {
-        use ohkami::Response;
+    use ohkami::prelude::*;
 
-        pub fn set_server(res: &mut Response) {
+    #[derive(Clone)]
+    pub struct SetServer;
+    impl FangAction for SetServer {
+        fn back<'a>(&'a self, res: &'a mut Response) -> impl std::future::Future<Output = ()> + Send {
             res.headers.set()
                 .Server("ohkami");
 
@@ -76,13 +78,15 @@ mod fangs {
                 [current headers]\n\
                 {:?}\n\
             ", res.headers);
+
+            async {}
         }
     }
 
-    pub mod front {
-        use ohkami::Request;
-
-        pub fn log_request(req: &mut Request) {
+    #[derive(Clone)]
+    pub struct LogRequest;
+    impl FangAction for LogRequest {
+        fn fore<'a>(&'a self, req: &'a mut Request) -> impl std::future::Future<Output = Result<(), Response>> + Send {
             let __method__ = req.method();
             let __path__   = req.path();
 
@@ -91,6 +95,8 @@ mod fangs {
                 [ method ] {__method__}\n\
                 [  path  ] {__path__}\n\
             ");
+
+            async {Ok(())}
         }
     }
 }
@@ -99,14 +105,13 @@ mod fangs {
 #[tokio::main]
 async fn main() {
     use ohkami::prelude::*;
-    use ohkami::utils::{BackFang, ForeFang};
 
     tracing_subscriber::fmt()
         .with_max_level(tracing::Level::INFO)
         .init();
 
     let hello_ohkami = Ohkami::with((
-        BackFang(fangs::back::set_server),
+        fangs::SetServer,
     ), (
         "/query".
             GET(hello_handler::hello_by_query),
@@ -117,7 +122,7 @@ async fn main() {
     tracing::info!("Started listening on http://localhost:3000");
 
     Ohkami::with((
-        ForeFang(fangs::front::log_request),
+        fangs::LogRequest,
     ), (
         "/hc" .GET(health_handler::health_check),
         "/api".By(hello_ohkami),

Diff for: examples/realworld/docker-compose.yml

@@ -1,5 +1,3 @@
-version: '3'
-
 services:
   postgres:
     image: postgres:15-alpine

Diff for: examples/realworld/src/fangs.rs

@@ -169,7 +169,7 @@ const _: () = {
         inner: I,
     }
     impl<I: FangProc> FangProc for ConnectionPoolProc<I> {
-        fn bite<'b>(&'b self, req: &'b mut Request) -> impl std::future::Future<Output = Response> + Send + 'b {
+        fn bite<'b>(&'b self, req: &'b mut Request) -> impl std::future::Future<Output = Response> + Send {
             req.memorize(self.pool.clone());
             self.inner.bite(req)
         }

Diff for: ohkami/src/builtin/fang/timeout.rs

@@ -73,7 +73,7 @@ const _: () = {
         time:  Duration,
     }
     impl<Inner: FangProc> FangProc for TimeoutProc<Inner> {
-        fn bite<'b>(&'b self, req: &'b mut Request) -> impl Future<Output = Response> + Send + 'b {
+        fn bite<'b>(&'b self, req: &'b mut Request) -> impl Future<Output = Response> + Send {
             set_timeout(self.time, self.inner.bite(req))
         }
     }

Diff for: ohkami/src/fangs/middleware/mod.rs

@@ -1,4 +1,4 @@
-pub mod utils;
+pub mod util;
 
 use super::{Fang, BoxedFPC};