finish up Body <-> JSON conversions

Author: yoshuawuyts

src/body.rs

@@ -167,7 +167,7 @@ impl Body {
     /// # Examples
     ///
     /// ```
-    /// use http_types::{Body, serde::json};
+    /// use http_types::{Body, convert::json};
     ///
     /// let body = Body::from_json(json!({ "name": "Chashu" }));
     /// # drop(body);
@@ -250,7 +250,7 @@ impl Body {
     /// ```
     /// # fn main() -> Result<(), http_types::Error> { async_std::task::block_on(async {
     /// use http_types::Body;
-    /// use http_types::serde::{Serialize, Deserialize};
+    /// use http_types::convert::{Serialize, Deserialize};
     ///
     /// #[derive(Debug, Serialize, Deserialize)]
     /// struct Cat { name: String }

src/lib.rs

@@ -173,8 +173,8 @@ mod hyperium_http;
 #[doc(inline)]
 pub use crate::type_map::TypeMap;
 
-/// Generic serialization and deserialization.
-pub mod serde {
+/// Traits for conversions between types.
+pub mod convert {
     pub use serde::{de::DeserializeOwned, Deserialize, Serialize};
     #[doc(inline)]
     pub use serde_json::json;

src/request.rs

@@ -6,6 +6,7 @@ use std::mem;
 use std::pin::Pin;
 use std::task::{Context, Poll};
 
+use crate::convert::DeserializeOwned;
 use crate::headers::{
     self, HeaderName, HeaderValue, HeaderValues, Headers, Names, ToHeaderValues, Values,
     CONTENT_TYPE,
@@ -251,6 +252,35 @@ impl Request {
         self.body.into_bytes().await
     }
 
+    /// Read the body as JSON.
+    ///
+    /// This consumes the request. If you want to read the body without
+    /// consuming the request, consider using the `take_body` method and
+    /// then calling `Body::into_json` or using the Request's AsyncRead
+    /// implementation to read the body.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # fn main() -> Result<(), http_types::Error> { async_std::task::block_on(async {
+    /// use http_types::{Body, Url, Method, Request};
+    /// use http_types::convert::{Serialize, Deserialize};
+    ///
+    /// #[derive(Debug, Serialize, Deserialize)]
+    /// struct Cat { name: String }
+    ///
+    /// let cat = Cat { name: String::from("chashu") };
+    /// let mut req = Request::new(Method::Get, Url::parse("https://example.com").unwrap());
+    /// req.set_body(Body::from_json(cat)?);
+    ///
+    /// let cat: Cat = req.body_json().await?;
+    /// assert_eq!(&cat.name, "chashu");
+    /// # Ok(()) }) }
+    /// ```
+    pub async fn body_json<T: DeserializeOwned>(self) -> crate::Result<T> {
+        self.body.into_json().await
+    }
+
     /// Get an HTTP header.
     pub fn header(&self, name: &HeaderName) -> Option<&HeaderValues> {
         self.headers.get(name)

src/response.rs

@@ -6,6 +6,7 @@ use std::mem;
 use std::pin::Pin;
 use std::task::{Context, Poll};
 
+use crate::convert::DeserializeOwned;
 use crate::headers::{
     self, HeaderName, HeaderValue, HeaderValues, Headers, Names, ToHeaderValues, Values,
     CONTENT_TYPE,
@@ -244,11 +245,11 @@ impl Response {
     /// use http_types::{Body, Url, Method, Response, StatusCode};    
     /// use async_std::io::Cursor;
     ///
-    /// let mut resp = Response::new(StatusCode::Ok);    
+    /// let mut res = Response::new(StatusCode::Ok);    
     /// let cursor = Cursor::new("Hello Nori");
     /// let body = Body::from_reader(cursor, None);
-    /// resp.set_body(body);
-    /// assert_eq!(&resp.body_string().await.unwrap(), "Hello Nori");
+    /// res.set_body(body);
+    /// assert_eq!(&res.body_string().await.unwrap(), "Hello Nori");
     /// # Ok(()) }) }
     /// ```
     pub async fn body_string(self) -> io::Result<String> {
@@ -266,7 +267,6 @@ impl Response {
     ///
     /// ```
     /// # fn main() -> Result<(), http_types::Error> { async_std::task::block_on(async {
-    ///
     /// use http_types::{Body, Url, Method, Response, StatusCode};
     ///
     /// let bytes = vec![1, 2, 3];
@@ -281,6 +281,35 @@ impl Response {
         self.body.into_bytes().await
     }
 
+    /// Read the body as JSON.
+    ///
+    /// This consumes the response. If you want to read the body without
+    /// consuming the request, consider using the `take_body` method and
+    /// then calling `Body::into_json` or using the Response's AsyncRead
+    /// implementation to read the body.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # fn main() -> Result<(), http_types::Error> { async_std::task::block_on(async {
+    /// use http_types::{Body, Url, Method, Response, StatusCode};    
+    /// use http_types::convert::{Serialize, Deserialize};
+    ///
+    /// #[derive(Debug, Serialize, Deserialize)]
+    /// struct Cat { name: String }
+    ///
+    /// let cat = Cat { name: String::from("chashu") };
+    /// let mut res = Response::new(StatusCode::Ok);    
+    /// res.set_body(Body::from_json(cat)?);
+    ///
+    /// let cat: Cat = res.body_json().await?;
+    /// assert_eq!(&cat.name, "chashu");
+    /// # Ok(()) }) }
+    /// ```
+    pub async fn body_json<T: DeserializeOwned>(self) -> crate::Result<T> {
+        self.body.into_json().await
+    }
+
     /// Set the response MIME.
     pub fn set_content_type(&mut self, mime: Mime) -> Option<HeaderValues> {
         let value: HeaderValue = mime.into();