Merge pull request #33 from tzilist/master

Adding String and Vec Body Types

Author: aturon

examples/body_types.rs

@@ -0,0 +1,42 @@
+#![feature(async_await, futures_api)]
+
+#[macro_use]
+extern crate serde_derive;
+use tide::body;
+
+#[derive(Serialize, Deserialize, Clone, Debug)]
+struct Message {
+    author: Option<String>,
+    contents: String,
+}
+
+async fn echo_string(msg: body::Str) -> String {
+    println!("String: {}", msg.0);
+    format!("{}", msg.0)
+}
+
+async fn echo_string_lossy(msg: body::StrLossy) -> String {
+    println!("String: {}", msg.0);
+    format!("{}", msg.0)
+}
+
+async fn echo_vec(msg: body::Bytes) -> String {
+    println!("Vec<u8>: {:?}", msg.0);
+
+    String::from_utf8(msg.0).unwrap()
+}
+
+async fn echo_json(msg: body::Json<Message>) -> body::Json<Message> {
+    println!("JSON: {:?}", msg.0);
+
+    msg
+}
+
+fn main() {
+    let mut app = tide::App::new(());
+    app.at("/echo/string").post(echo_string);
+    app.at("/echo/string_lossy").post(echo_string_lossy);
+    app.at("/echo/vec").post(echo_vec);
+    app.at("/echo/json").post(echo_json);
+    app.serve("127.0.0.1:8000");
+}

rustfmt.toml

@@ -1 +1,2 @@
 edition = "2018"
+tab_spaces = 4

src/body.rs

@@ -112,6 +112,11 @@ impl Into<hyper::Body> for Body {
     }
 }
 
+// Small utility function to return a stamped error when we cannot parse a request body
+fn mk_err<T>(_: T) -> Response {
+    StatusCode::BAD_REQUEST.into_response()
+}
+
 /// A wrapper for json (de)serialization of bodies.
 ///
 /// This type is usable both as an extractor (argument to an endpoint) and as a response
@@ -126,9 +131,6 @@ impl<T: Send + serde::de::DeserializeOwned + 'static, S: 'static> Extract<S> for
         let mut body = std::mem::replace(req.body_mut(), Body::empty());
         FutureObj::new(Box::new(
             async move {
-                fn mk_err<T>(_: T) -> Response {
-                    StatusCode::BAD_REQUEST.into_response()
-                }
                 let body = await!(body.read_to_vec()).map_err(mk_err)?;
                 let json: T = serde_json::from_slice(&body).map_err(mk_err)?;
                 Ok(Json(json))
@@ -147,3 +149,56 @@ impl<T: 'static + Send + serde::Serialize> IntoResponse for Json<T> {
             .unwrap()
     }
 }
+
+pub struct Str(pub String);
+
+impl<S: 'static> Extract<S> for Str {
+    type Fut = FutureObj<'static, Result<Self, Response>>;
+
+    fn extract(data: &mut S, req: &mut Request, params: &RouteMatch<'_>) -> Self::Fut {
+        let mut body = std::mem::replace(req.body_mut(), Body::empty());
+
+        FutureObj::new(Box::new(
+            async move {
+                let body = await!(body.read_to_vec().map_err(mk_err))?;
+                let string = String::from_utf8(body).map_err(mk_err)?;
+                Ok(Str(string))
+            },
+        ))
+    }
+}
+
+pub struct StrLossy(pub String);
+
+impl<S: 'static> Extract<S> for StrLossy {
+    type Fut = FutureObj<'static, Result<Self, Response>>;
+
+    fn extract(data: &mut S, req: &mut Request, params: &RouteMatch<'_>) -> Self::Fut {
+        let mut body = std::mem::replace(req.body_mut(), Body::empty());
+
+        FutureObj::new(Box::new(
+            async move {
+                let body = await!(body.read_to_vec().map_err(mk_err))?;
+                let string = String::from_utf8_lossy(&body).to_string();
+                Ok(StrLossy(string))
+            },
+        ))
+    }
+}
+
+pub struct Bytes(pub Vec<u8>);
+
+impl<S: 'static> Extract<S> for Bytes {
+    type Fut = FutureObj<'static, Result<Self, Response>>;
+
+    fn extract(data: &mut S, req: &mut Request, params: &RouteMatch<'_>) -> Self::Fut {
+        let mut body = std::mem::replace(req.body_mut(), Body::empty());
+
+        FutureObj::new(Box::new(
+            async move {
+                let body = await!(body.read_to_vec().map_err(mk_err))?;
+                Ok(Bytes(body))
+            },
+        ))
+    }
+}