obsidian-rs · jk-gan · Feb 3, 2020 · Jan 2, 2020 · Jan 2, 2020 · Jan 2, 2020
diff --git a/Cargo.toml b/Cargo.toml
@@ -10,6 +10,10 @@ path = 'examples/hello.rs'
 name = 'hello_handler'
 path = 'examples/hello_handler.rs'
 
+[[example]]
+name = 'json'
+path = 'examples/json.rs'
+
 [package]
 name = 'obsidian'
 version = '0.1.0-alpha.1'

diff --git a/README.md b/README.md
@@ -58,6 +58,41 @@ async fn main() {
 }
 ```
 
+## JSON Response
+```rust
+use obsidian::{
+    context::Context,
+    router::{Responder, Response},
+    App,
+};
+use serde::*;
+
+async fn get_user(_ctx: Context) -> impl Responder {
+    #[derive(Serialize, Deserialize)]
+    struct User {
+        name: String,
+    };
+
+    let user = User {
+        name: String::from("Obsidian"),
+    };
+    Response::ok().json(user)
+}
+
+#[tokio::main]
+async fn main() {
+    let mut app = App::new();
+    let addr = ([127, 0, 0, 1], 3000).into();
+
+    app.get("/user", get_user);
+
+    app.listen(&addr, || {
+        println!("server is listening to {}", &addr);
+    })
+    .await;
+}
+```
+
 ## Example Files
 
 Example are located in `example/main.rs`.

diff --git a/examples/json.rs b/examples/json.rs
@@ -0,0 +1,31 @@
+use obsidian::{
+    context::Context,
+    router::{Responder, Response},
+    App,
+};
+use serde::*;
+
+async fn get_user(_ctx: Context) -> impl Responder {
+    #[derive(Serialize, Deserialize)]
+    struct User {
+        name: String,
+    };
+
+    let user = User {
+        name: String::from("Obsidian"),
+    };
+    Response::ok().json(user)
+}
+
+#[tokio::main]
+async fn main() {
+    let mut app = App::new();
+    let addr = ([127, 0, 0, 1], 3000).into();
+
+    app.get("/user", get_user);
+
+    app.listen(&addr, || {
+        println!("server is listening to {}", &addr);
+    })
+    .await;
+}
diff --git a/examples/main.rs b/examples/main.rs
@@ -4,7 +4,7 @@ use std::{fmt, fmt::Display};
 use obsidian::{
     context::Context,
     middleware::Logger,
-    router::{response, Responder, Router},
+    router::{header, Responder, Response, Router},
     App, StatusCode,
 };
 
@@ -27,118 +27,180 @@ struct ParamTest {
     test2: String,
 }
 
+#[derive(Serialize, Deserialize, Debug)]
+struct Person {
+    name: String,
+    age: i8,
+}
+
 impl Display for JsonTest {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "{{title: {}, content: {}}}", self.title, self.content)
     }
 }
 
-async fn responder_obsidian_error(mut ctx: Context) -> impl Responder {
-    let json: JsonTest = ctx.json().await?;
-    println!("{}", json);
-    Ok(response::json(json, StatusCode::OK))
-}
+// async fn responder_json(mut ctx: Context) -> impl Responder {
+//     let person: Person = ctx.json().await?;
+
+//     person.age += 1;
+
+//     Ok(response::json(person))
+// }
+
+// async fn responder_obsidian_error(mut ctx: Context) -> impl Responder {
+//     let json: JsonTest = ctx.json().await?;
+//     println!("{}", json);
+//     Ok(response::json(json, StatusCode::OK))
+// }
+
+// fn responder_with_header(_ctx: Context) -> impl Responder {
+//     let headers = vec![
+//         ("X-Custom-Header-4", "custom-value-4"),
+//         ("X-Custom-Header-5", "custom-value-5"),
+//     ];
+
+//     "here"
+//         .header("Content-Type", "application/json")
+//         .header("X-Custom-Header", "custom-value")
+//         .header("X-Custom-Header-2", "custom-value-2")
+//         .header("X-Custom-Header-3", "custom-value-3")
+//         .set_headers(headers)
+//         .status(StatusCode::CREATED)
+// }
 
 #[tokio::main]
 async fn main() {
     let mut app = App::new();
     let addr = ([127, 0, 0, 1], 3000).into();
 
     app.get("/", |_ctx| async {
-"<!DOCTYPE html><html><head><link rel=\"shotcut icon\" href=\"favicon.ico\" type=\"image/x-icon\" sizes=\"32x32\" /></head> <h1>Hello Obsidian</h1></html>"
+Response::ok().html("<!DOCTYPE html><html><head><link rel=\"shotcut icon\" href=\"favicon.ico\" type=\"image/x-icon\" sizes=\"32x32\" /></head> <h1>Hello Obsidian</h1></html>")
     });
 
-    app.get("/json", |_ctx| {
-        async {
-            let point = Point { x: 1, y: 2 };
+    app.get("/json", |_ctx| async {
+        let point = Point { x: 1, y: 2 };
 
-            response::json(point, StatusCode::OK)
-            // res.header(header::CONTENT_TYPE, "application/json")
-            //     .status(StatusCode::OK)
-            //     .json(point)
-        }
+        Response::created()
+            .set_header(header::AUTHORIZATION, "token")
+            .set_header_str("X-Custom-Header", "Custom header value")
+            .json(point)
     });
 
-    app.get("/empty-body", |_ctx| async { StatusCode::OK });
+    app.get("/json-with-headers", |_ctx| async {
+        let point = Point { x: 1, y: 2 };
 
-    app.get("/vec", |_ctx| async { vec![1, 2, 3] });
+        let custom_headers = vec![
+            ("X-Custom-Header-1", "Custom header 1"),
+            ("X-Custom-Header-2", "Custom header 2"),
+            ("X-Custom-Header-3", "Custom header 3"),
+        ];
 
-    app.get("/String", |_ctx| {
-        async { "<h1>This is a String</h1>".to_string() }
-    });
+        let standard_headers = vec![
+            (header::AUTHORIZATION, "token"),
+            (header::ACCEPT_CHARSET, "utf-8"),
+        ];
 
-    app.get("/test/radix", |_ctx| {
-        async { "<h1>Test radix</h1>".to_string() }
+        Response::created()
+            .with_headers(standard_headers)
+            .with_headers_str(custom_headers)
+            .json(point)
     });
 
-    app.get("/team/radix", |_ctx| {
-        async { "<h1>Team radix</h1>".to_string() }
+    app.get("/string-with-headers", |_ctx| async {
+        let custom_headers = vec![
+            ("X-Custom-Header-1", "Custom header 1"),
+            ("X-Custom-Header-2", "Custom header 2"),
+            ("X-Custom-Header-3", "Custom header 3"),
+        ];
+
+        let standard_headers = vec![
+            (header::AUTHORIZATION, "token"),
+            (header::ACCEPT_CHARSET, "utf-8"),
+        ];
+
+        "Hello World"
+            .with_headers(standard_headers)
+            .with_headers_str(custom_headers)
     });
 
-    app.get("/test/radix2", |_ctx| {
-        async { "<h1>Test radix2</h1>".to_string() }
+    app.get("/empty-body", |_ctx| async { StatusCode::OK });
+
+    app.get("/vec", |_ctx| async {
+        vec![1, 2, 3].with_status(StatusCode::CREATED)
     });
 
-    app.get("/jsontest", |_ctx| {
-        async { response::file("./testjson.html").await }
+    app.get("/String", |_ctx| async {
+        "<h1>This is a String</h1>".to_string()
     });
 
-    app.get("/jsan", |_ctx: Context| {
-        async { "<h1>jsan</h1>".to_string() }
+    app.get("/test/radix", |_ctx| async {
+        "<h1>Test radix</h1>".to_string()
     });
 
-    app.post("/jsontestapi", |mut ctx: Context| {
-        async move {
-            let json: serde_json::Value = ctx.json().await?;
+    app.get("/team/radix", |_ctx| async { "Team radix".to_string() });
 
-            println!("{}", json);
+    app.get("/test/radix2", |_ctx| async {
+        "<h1>Test radix2</h1>".to_string()
+    });
+
+    app.get("/jsontest", |_ctx| async {
+        Response::ok().file("./testjson.html").await
+    });
 
-            Ok(response::json(json, StatusCode::OK))
-        }
+    app.get("/jsan", |_ctx: Context| async {
+        "<h1>jsan</h1>".to_string()
     });
 
-    app.post("/jsonteststructapi", responder_obsidian_error);
+    // app.post("/jsontestapi", |mut ctx: Context| {
+    //     async move {
+    //         let json: serde_json::Value = ctx.json().await?;
+
+    //         println!("{}", json);
 
-    app.get("/test/wildcard/*", |ctx: Context| {
-        async move {
-            format!(
-                "{}<br>{}",
-                "<h1>Test wildcard</h1>".to_string(),
-                ctx.uri().path()
-            )
-        }
+    //         Ok(response::json(json, StatusCode::OK))
+    //     }
+    // });
+
+    // app.post("/jsonteststructapi", responder_obsidian_error);
+
+    app.get("/test/wildcard/*", |ctx: Context| async move {
+        format!(
+            "{}<br>{}",
+            "<h1>Test wildcard</h1>".to_string(),
+            ctx.uri().path()
+        )
     });
 
-    app.get("router/test", |ctx: Context| async move{
+    app.get("router/test", |ctx: Context| async move {
         format!(
             "{}<br>{}",
             "<h1>router test get</h1>".to_string(),
             ctx.uri().path()
         )
     });
-    app.post("router/test", |ctx: Context| async move{
+    app.post("router/test", |ctx: Context| async move {
         format!(
             "{}<br>{}",
             "<h1>router test post</h1>".to_string(),
             ctx.uri().path()
         )
     });
-    app.put("router/test", |ctx: Context| async move{
+    app.put("router/test", |ctx: Context| async move {
         format!(
             "{}<br>{}",
             "<h1>router test put</h1>".to_string(),
             ctx.uri().path()
         )
     });
-    app.delete("router/test", |ctx: Context| async move{
+    app.delete("router/test", |ctx: Context| async move {
         format!(
             "{}<br>{}",
             "<h1>router test delete</h1>".to_string(),
             ctx.uri().path()
         )
     });
 
-    app.get("route/diff_route", |ctx: Context| async move{
+    app.get("route/diff_route", |ctx: Context| async move {
         format!(
             "{}<br>{}",
             "<h1>route diff get</h1>".to_string(),
@@ -148,35 +210,36 @@ async fn main() {
 
     let mut form_router = Router::new();
 
-    form_router.get("/formtest", |_ctx| response::file("./test.html"));
+    form_router.get("/formtest", |_ctx| Response::ok().file("./test.html"));
 
-    form_router.post("/formtest", |mut ctx: Context| async move{
-        let param_test: ParamTest = ctx.form().await?;
+    // form_router.post("/formtest", |mut ctx: Context| async move{
+    //     let param_test: ParamTest = ctx.form().await?;
 
-        dbg!(&param_test);
+    //     dbg!(&param_test);
 
-        Ok(response::json(param_test, StatusCode::OK))
-    });
+    //     Ok(response::json(param_test, StatusCode::OK))
+    // });
 
     let mut param_router = Router::new();
     let logger = Logger::new();
     app.use_service(logger);
 
-    param_router.get("/paramtest/:id", |ctx: Context| async move {
-        let param_test: i32 = ctx.param("id")?;
+    // param_router.get("/paramtest/:id", |ctx: Context| async move {
+    //     let param_test: i32 = ctx.param("id")?;
 
-        dbg!(&param_test);
+    //     dbg!(&param_test);
 
-        Ok(response::json(param_test, StatusCode::OK))
-    });
-    param_router.get("/paramtest/:id/test", |ctx: Context| async move {
-        let mut param_test: i32 = ctx.param("id").unwrap();
-        param_test *= 10;
+    //     Ok(response::json(param_test, StatusCode::OK))
+    // });
+    //
+    // param_router.get("/paramtest/:id/test", |ctx: Context| async move {
+    //     let mut param_test: i32 = ctx.param("id").unwrap();
+    //     param_test = param_test * 10;
 
-        dbg!(&param_test);
+    //     dbg!(&param_test);
 
-        Ok(response::json(param_test, StatusCode::OK))
-    });
+    //     Ok(response::json(param_test, StatusCode::OK))
+    // });
 
     param_router.get("/test-next-wild/*", |_ctx| async {
         "<h1>test next wild</h1>".to_string()
@@ -194,5 +257,6 @@ async fn main() {
 
     app.listen(&addr, || {
         println!("server is listening to {}", &addr);
-    }).await;
+    })
+    .await;
 }