refactor: add types to body parsing as well as add a lossy interpreter

Author: tzilist

examples/body_types.rs

@@ -6,31 +6,37 @@ use tide::body;
 
 #[derive(Serialize, Deserialize, Clone, Debug)]
 struct Message {
-    author: Option<String>,
-    contents: String,
+  author: Option<String>,
+  contents: String,
 }
 
-async fn echo_string(msg: String) -> String {
-    println!("String: {}", msg);
-    format!("{}", msg)
+async fn echo_string(msg: body::Str) -> String {
+  println!("String: {}", msg.0);
+  format!("{}", msg.0)
 }
 
-async fn echo_vec(msg: Vec<u8>) -> String {
-    println!("Vec<u8>: {:?}", msg);
+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).unwrap()
+  String::from_utf8(msg.0).unwrap()
 }
 
 async fn echo_json(msg: body::Json<Message>) -> body::Json<Message> {
-    println!("JSON: {:?}", msg.0);
+  println!("JSON: {:?}", msg.0);
 
-    msg
+  msg
 }
 
 fn main() {
-    let mut app = tide::App::new(());
-    app.at("/echo/string").post(echo_string);
-    app.at("/echo/vec").post(echo_vec);
-    app.at("/echo/json").post(echo_json);
-    app.serve("127.0.0.1:8000");
+  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

@@ -0,0 +1 @@
+edition = "2018"

src/app.rs

@@ -4,20 +4,20 @@ use futures::{
     prelude::*,
 };
 use hyper::service::Service;
-use std::{sync::Arc, ops::{Deref, DerefMut}};
+use std::{
+    ops::{Deref, DerefMut},
+    sync::Arc,
+};
 
 use crate::{
-    router::{Resource, Router},
-    Request,
-    extract::Extract,
-    RouteMatch, 
-    Response, 
     body::Body,
-    Middleware,
+    extract::Extract,
+    router::{Resource, Router},
+    Middleware, Request, Response, RouteMatch,
 };
 
 /// The top-level type for setting up a Tide application.
-/// 
+///
 /// Apps are equipped with a handle to their own state (`Data`), which is available to all endpoints.
 /// This is a "handle" because it must be `Clone`, and endpoints are invoked with a fresh clone.
 /// They also hold a top-level router.
@@ -57,21 +57,25 @@ impl<Data: Clone + Send + Sync + 'static> App<Data> {
     }
 
     /// Start serving the app at the given address.
-    /// 
+    ///
     /// Blocks the calling thread indefinitely.
     pub fn serve<A: std::net::ToSocketAddrs>(self, addr: A) {
         let server: Server<Data> = self.into_server();
 
         // TODO: be more robust
         let addr = addr.to_socket_addrs().unwrap().next().unwrap();
 
-        let server = hyper::Server::bind(&addr).serve(move || {
-            let res: Result<_, std::io::Error> = Ok(server.clone());            
-            res
-        }).compat().map(|_| {
-            let res: Result<(), ()> = Ok(());
-            res
-        }).compat();
+        let server = hyper::Server::bind(&addr)
+            .serve(move || {
+                let res: Result<_, std::io::Error> = Ok(server.clone());
+                res
+            })
+            .compat()
+            .map(|_| {
+                let res: Result<(), ()> = Ok(());
+                res
+            })
+            .compat();
         hyper::rt::run(server);
     }
 }
@@ -94,35 +98,41 @@ impl<Data: Clone + Send + Sync + 'static> Service for Server<Data> {
         let router = self.router.clone();
         let middleware = self.middleware.clone();
 
-        let mut req = req.map(Body::from);            
+        let mut req = req.map(Body::from);
         let path = req.uri().path().to_owned();
         let method = req.method().to_owned();
 
-        FutureObj::new(Box::new(async move {            
-            if let Some((endpoint, params)) = router.route(&path, &method) {                
-                for m in middleware.iter() {
-                    match await!(m.request(&mut data, req, &params)) {
-                        Ok(new_req) => req = new_req,
-                        Err(resp) => return Ok(resp.map(Into::into)),
-                    }                    
+        FutureObj::new(Box::new(
+            async move {
+                if let Some((endpoint, params)) = router.route(&path, &method) {
+                    for m in middleware.iter() {
+                        match await!(m.request(&mut data, req, &params)) {
+                            Ok(new_req) => req = new_req,
+                            Err(resp) => return Ok(resp.map(Into::into)),
+                        }
+                    }
+
+                    let (head, mut resp) = await!(endpoint.call(data.clone(), req, params));
+
+                    for m in middleware.iter() {
+                        resp = await!(m.response(&mut data, &head, resp))
+                    }
+
+                    Ok(resp.map(Into::into))
+                } else {
+                    Ok(http::Response::builder()
+                        .status(http::status::StatusCode::NOT_FOUND)
+                        .body(hyper::Body::empty())
+                        .unwrap())
                 }
-
-                let (head, mut resp) = await!(endpoint.call(data.clone(), req, params));
-
-                for m in middleware.iter() {
-                    resp = await!(m.response(&mut data, &head, resp))
-                }
-
-                Ok(resp.map(Into::into))
-            } else {
-                Ok(http::Response::builder().status(http::status::StatusCode::NOT_FOUND).body(hyper::Body::empty()).unwrap())
-            }
-        })).compat()
+            },
+        ))
+        .compat()
     }
 }
 
 /// An extractor for accessing app data.
-/// 
+///
 /// Endpoints can use `AppData<T>` to gain a handle to the data (of type `T`) originally injected into their app.
 pub struct AppData<T>(pub T);
 
@@ -140,11 +150,7 @@ impl<T> DerefMut for AppData<T> {
 
 impl<T: Clone + Send + 'static> Extract<T> for AppData<T> {
     type Fut = future::Ready<Result<Self, Response>>;
-    fn extract(
-        data: &mut T,
-        req: &mut Request,
-        params: &RouteMatch<'_>,
-    ) -> Self::Fut {
+    fn extract(data: &mut T, req: &mut Request, params: &RouteMatch<'_>) -> Self::Fut {
         future::ok(AppData(data.clone()))
     }
-}
+}