simplify json example

examples/json/src/main.rs

@@ -1,17 +1,15 @@
 extern crate actix;
 extern crate actix_web;
-extern crate bytes;
 extern crate futures;
 extern crate env_logger;
 extern crate serde_json;
 #[macro_use] extern crate serde_derive;
 
 use actix_web::*;
-use bytes::BytesMut;
 use futures::Stream;
 use futures::future::{Future, ok, err};
 
-#[derive(Debug, Deserialize)]
+#[derive(Debug, Serialize, Deserialize)]
 struct MyObj {
     name: String,
     number: i32,
@@ -24,22 +22,23 @@ fn index(mut req: HttpRequest) -> Result<Box<Future<Item=HttpResponse, Error=Err
     }
 
     Ok(Box::new(
-        req.payload_mut()      // <- load request body
+        // `concat2` will asynchronously read each chunk of the request body and
-            .readany()
+        // return a single, concatenated, chunk
-            .fold(BytesMut::new(), |mut body, chunk| {
+        req.payload_mut().readany().concat2()
-                body.extend(chunk);
+            // `Future::from_err` acts like `?` in that it coerces the error type from
-                ok::<_, error::PayloadError>(body)
+            // the future into the final error type
-            })
+            .from_err()
-            .map_err(|e| Error::from(e))
+            // `Future::and_then` can be used to merge an asynchronous workflow with a
+            // synchronous workflow
             .and_then(|body| { // <- body is loaded, now we can deserialize json
                 match serde_json::from_slice::<MyObj>(&body) {
                     Ok(obj) => {
                         println!("model: {:?}", obj);    // <- do something with payload
-                        ok(httpcodes::HTTPOk.response()) // <- send response
+                        ok(httpcodes::HTTPOk.build()     // <- send response
+                           .content_type("application/json")
+                           .json(obj).unwrap())
                     },
-                    Err(e) => {
+                    Err(e) => err(error::ErrorBadRequest(e).into())
-                        err(error::ErrorBadRequest(e).into())
-                    }
                 }
             })))
 }

guide/src/qs_7.md

@@ -77,16 +77,20 @@ We need to load request body first and then deserialize json into object.
 
 ```rust,ignore
 fn index(mut req: HttpRequest) -> Future<Item=HttpResponse, Error=Error> {
-   req.payload_mut().readany()
+   // `concat2` will asynchronously read each chunk of the request body and
-     .fold(BytesMut::new(), |mut body, chunk| {   // <- load request body
+   // return a single, concatenated, chunk
-         body.extend(chunk);
+   req.payload_mut().readany().concat2()
-         ok(body)
+      // `Future::from_err` acts like `?` in that it coerces the error type from
-     })
+      // the future into the final error type
-    .and_then(|body| {                   // <- body is loaded, now we can deserialize json
+      .from_err()
-        let obj = serde_json::from_slice::<MyObj>(&body).unwrap();
+      // `Future::and_then` can be used to merge an asynchronous workflow with a
-        println!("MODEL: {:?}", obj);    // <- do something with payload
+      // synchronous workflow
-        ok(httpcodes::HTTPOk.response()) // <- send response
+      .and_then(|body| {                   // <- body is loaded, now we can deserialize json
-    })
+          let obj = serde_json::from_slice::<MyObj>(&body).unwrap();
+          ok(httpcodes::HTTPOk.build()     // <- send response
+                .content_type("application/json")
+                .json(obj).unwrap())
+      })
 }
 ```