add a serde feature that's enabled by default

Author: jbr

Cargo.toml

@@ -16,37 +16,41 @@ features = ["docs"]
 rustdoc-args = ["--cfg", "feature=\"docs\""]
 
 [features]
-default = ["fs", "cookie-secure"]
+default = ["fs", "cookie-secure", "serde"]
 docs = ["unstable"]
 unstable = []
 hyperium_http = ["http"]
 async_std = ["fs"]
 cookies = ["cookie"]
 cookie-secure = ["cookies", "cookie/secure"]
 fs = ["async-std"]
+serde = ["serde_qs", "serde_crate", "serde_json", "serde_urlencoded", "url/serde"]
 
 [dependencies]
-# features: async_std
-async-std = { version = "1.6.0", optional = true }
+rand = "0.7.3"
+base64 = "0.13.0"
 futures-lite = "1.11.1"
 async-channel = "1.5.1"
+infer = "0.2.3"
+pin-project-lite = "0.2.0"
+url = "2.1.1"
+anyhow = "1.0.26"
+
+# features: async_std
+async-std = { version = "1.6.0", optional = true }
 
 # features: hyperium/http
 http = { version = "0.2.0", optional = true }
 
-anyhow = "1.0.26"
-
 # features: cookies
 cookie = { version = "0.14.0", features = ["percent-encode"], optional = true }
-infer = "0.2.3"
-pin-project-lite = "0.2.0"
-url = { version = "2.1.1", features = ["serde"] }
-serde_json = "1.0.51"
-serde = { version = "1.0.106", features = ["derive"] }
-serde_urlencoded = "0.7.0"
-rand = "0.7.3"
-serde_qs = "0.7.0"
-base64 = "0.13.0"
+
+# features: serde
+serde_json = { version = "1.0.51", optional = true }
+serde_crate = { version = "1.0.106", features = ["derive"], optional = true, package = "serde" }
+serde_urlencoded = { version = "0.7.0", optional = true}
+serde_qs = { version = "0.7.0", optional = true }
+
 
 [dev-dependencies]
 http = "0.2.0"

src/body.rs

@@ -1,5 +1,6 @@
 use futures_lite::{io, prelude::*, ready};
-use serde::{de::DeserializeOwned, Serialize};
+#[cfg(feature = "serde")]
+use serde_crate::{de::DeserializeOwned, Serialize};
 
 use std::convert::TryFrom;
 use std::fmt::{self, Debug};
@@ -246,6 +247,7 @@ impl Body {
     /// let body = Body::from_json(&json!({ "name": "Chashu" }));
     /// # drop(body);
     /// ```
+    #[cfg(feature = "serde")]
     pub fn from_json(json: &impl Serialize) -> crate::Result<Self> {
         let bytes = serde_json::to_vec(&json)?;
         let body = Self {
@@ -267,6 +269,7 @@ impl Body {
     /// use http_types::convert::{Serialize, Deserialize};
     ///
     /// #[derive(Debug, Serialize, Deserialize)]
+    /// # #[serde(crate = "serde_crate")]
     /// struct Cat { name: String }
     ///
     /// let cat = Cat { name: String::from("chashu") };
@@ -276,6 +279,7 @@ impl Body {
     /// assert_eq!(&cat.name, "chashu");
     /// # Ok(()) }) }
     /// ```
+    #[cfg(feature = "serde")]
     pub async fn into_json<T: DeserializeOwned>(mut self) -> crate::Result<T> {
         let mut buf = Vec::with_capacity(1024);
         self.read_to_end(&mut buf).await?;
@@ -300,6 +304,7 @@ impl Body {
     /// use http_types::convert::{Serialize, Deserialize};
     ///
     /// #[derive(Debug, Serialize, Deserialize)]
+    /// # #[serde(crate = "serde_crate")]
     /// struct Cat { name: String }
     ///
     /// let cat = Cat { name: String::from("chashu") };
@@ -309,6 +314,7 @@ impl Body {
     /// assert_eq!(&cat.name, "chashu");
     /// # Ok(()) }) }
     /// ```
+    #[cfg(feature = "serde")]
     pub fn from_form(form: &impl Serialize) -> crate::Result<Self> {
         let query = serde_urlencoded::to_string(form)?;
         let bytes = query.into_bytes();
@@ -337,6 +343,7 @@ impl Body {
     /// use http_types::convert::{Serialize, Deserialize};
     ///
     /// #[derive(Debug, Serialize, Deserialize)]
+    /// # #[serde(crate = "serde_crate")]
     /// struct Cat { name: String }
     ///
     /// let cat = Cat { name: String::from("chashu") };
@@ -346,6 +353,7 @@ impl Body {
     /// assert_eq!(&cat.name, "chashu");
     /// # Ok(()) }) }
     /// ```
+    #[cfg(feature = "serde")]
     pub async fn into_form<T: DeserializeOwned>(self) -> crate::Result<T> {
         let s = self.into_string().await?;
         Ok(serde_urlencoded::from_str(&s).status(StatusCode::UnprocessableEntity)?)
@@ -486,6 +494,7 @@ impl Debug for Body {
     }
 }
 
+#[cfg(feature = "serde")]
 impl From<serde_json::Value> for Body {
     fn from(json_value: serde_json::Value) -> Self {
         Self::from_json(&json_value).unwrap()
@@ -577,11 +586,12 @@ fn guess_ext(path: &std::path::Path) -> Option<Mime> {
 mod test {
     use super::*;
     use async_std::io::Cursor;
-    use serde::Deserialize;
+    use serde_crate::Deserialize;
 
     #[async_std::test]
     async fn json_status() {
         #[derive(Debug, Deserialize)]
+        #[serde(crate = "serde_crate")]
         struct Foo {
             inner: String,
         }
@@ -593,6 +603,7 @@ mod test {
     #[async_std::test]
     async fn form_status() {
         #[derive(Debug, Deserialize)]
+        #[serde(crate = "serde_crate")]
         struct Foo {
             inner: String,
         }

src/lib.rs

@@ -164,9 +164,10 @@ mod hyperium_http;
 #[doc(inline)]
 pub use crate::extensions::Extensions;
 
+#[cfg(feature = "serde")]
 /// Traits for conversions between types.
 pub mod convert {
-    pub use serde::{de::DeserializeOwned, Deserialize, Serialize};
+    pub use serde_crate::{de::DeserializeOwned, Deserialize, Serialize};
     #[doc(inline)]
     pub use serde_json::json;
 }

src/method.rs

@@ -1,5 +1,3 @@
-use serde::de::{Error as DeError, Unexpected};
-use serde::{de::Visitor, Deserialize, Deserializer, Serialize, Serializer};
 use std::fmt::{self, Display};
 use std::str::FromStr;
 
@@ -52,41 +50,50 @@ impl Method {
     }
 }
 
-struct MethodVisitor;
+#[cfg(feature = "serde")]
+mod serde {
+    use super::Method;
+    use serde_crate::de::{Error as DeError, Unexpected, Visitor};
+    use serde_crate::{Deserialize, Deserializer, Serialize, Serializer};
+    use std::fmt;
+    use std::str::FromStr;
 
-impl<'de> Visitor<'de> for MethodVisitor {
-    type Value = Method;
+    struct MethodVisitor;
 
-    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        write!(formatter, "a HTTP method &str")
-    }
+    impl<'de> Visitor<'de> for MethodVisitor {
+        type Value = Method;
+
+        fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+            write!(formatter, "a HTTP method &str")
+        }
 
-    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
-    where
-        E: DeError,
-    {
-        match Method::from_str(v) {
-            Ok(method) => Ok(method),
-            Err(_) => Err(DeError::invalid_value(Unexpected::Str(v), &self)),
+        fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+        where
+            E: DeError,
+        {
+            match Method::from_str(v) {
+                Ok(method) => Ok(method),
+                Err(_) => Err(DeError::invalid_value(Unexpected::Str(v), &self)),
+            }
         }
     }
-}
 
-impl<'de> Deserialize<'de> for Method {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        deserializer.deserialize_str(MethodVisitor)
+    impl<'de> Deserialize<'de> for Method {
+        fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+        where
+            D: Deserializer<'de>,
+        {
+            deserializer.deserialize_str(MethodVisitor)
+        }
     }
-}
 
-impl Serialize for Method {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        serializer.serialize_str(&self.to_string())
+    impl Serialize for Method {
+        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+        where
+            S: Serializer,
+        {
+            serializer.serialize_str(&self.to_string())
+        }
     }
 }
 

src/request.rs

@@ -6,14 +6,15 @@ use std::ops::Index;
 use std::pin::Pin;
 use std::task::{Context, Poll};
 
+#[cfg(feature = "serde")]
 use crate::convert::{DeserializeOwned, Serialize};
 use crate::headers::{
     self, HeaderName, HeaderValue, HeaderValues, Headers, Names, ToHeaderValues, Values,
     CONTENT_TYPE,
 };
 use crate::mime::Mime;
 use crate::trailers::{self, Trailers};
-use crate::{Body, Extensions, Method, StatusCode, Url, Version};
+use crate::{Body, Extensions, Method, Url, Version};
 
 pin_project_lite::pin_project! {
     /// An HTTP request.
@@ -349,6 +350,7 @@ impl Request {
     /// use http_types::{Body, Request};
     ///
     /// #[derive(Debug, Serialize, Deserialize)]
+    /// # #[serde(crate = "serde_crate")]
     /// struct Cat {
     ///     name: String,
     /// }
@@ -363,6 +365,7 @@ impl Request {
     /// assert_eq!(&cat.name, "chashu");
     /// # Ok(()) }) }
     /// ```
+    #[cfg(feature = "serde")]
     pub async fn body_json<T: DeserializeOwned>(&mut self) -> crate::Result<T> {
         let body = self.take_body();
         body.into_json().await
@@ -383,6 +386,7 @@ impl Request {
     /// use http_types::{Body, Request};
     ///
     /// #[derive(Debug, Serialize, Deserialize)]
+    /// # #[serde(crate = "serde_crate")]
     /// struct Cat {
     ///     name: String,
     /// }
@@ -397,6 +401,7 @@ impl Request {
     /// assert_eq!(&cat.name, "chashu");
     /// # Ok(()) }) }
     /// ```
+    #[cfg(feature = "serde")]
     pub async fn body_form<T: DeserializeOwned>(&mut self) -> crate::Result<T> {
         let body = self.take_body();
         body.into_form().await
@@ -616,6 +621,7 @@ impl Request {
     /// use std::collections::HashMap;
     ///
     /// #[derive(Deserialize)]
+    /// # #[serde(crate = "serde_crate")]
     /// struct Index {
     ///     page: u32,
     ///     selections: HashMap<String, String>,
@@ -627,15 +633,16 @@ impl Request {
     /// assert_eq!(selections["width"], "narrow");
     /// assert_eq!(selections["height"], "tall");
     /// ```
-    pub fn query<T: serde::de::DeserializeOwned>(&self) -> crate::Result<T> {
+    #[cfg(feature = "serde")]
+    pub fn query<T: serde_crate::de::DeserializeOwned>(&self) -> crate::Result<T> {
         // Default to an empty query string if no query parameter has been specified.
         // This allows successful deserialisation of structs where all fields are optional
         // when none of those fields has actually been passed by the caller.
         let query = self.url().query().unwrap_or("");
         serde_qs::from_str(query).map_err(|e| {
             // Return the displayable version of the deserialisation error to the caller
             // for easier debugging.
-            crate::Error::from_str(StatusCode::BadRequest, format!("{}", e))
+            crate::Error::from_str(crate::StatusCode::BadRequest, format!("{}", e))
         })
     }
 
@@ -649,6 +656,7 @@ impl Request {
     /// use std::collections::HashMap;
     ///
     /// #[derive(Serialize)]
+    /// # #[serde(crate = "serde_crate")]
     /// struct Index {
     ///     page: u32,
     ///     topics: Vec<&'static str>,
@@ -659,9 +667,10 @@ impl Request {
     /// req.set_query(&query).unwrap();
     /// assert_eq!(req.url().query(), Some("page=2&topics[0]=rust&topics[1]=crabs&topics[2]=crustaceans"));
     /// ```
+    #[cfg(feature = "serde")]
     pub fn set_query(&mut self, query: &impl Serialize) -> crate::Result<()> {
         let query = serde_qs::to_string(query)
-            .map_err(|e| crate::Error::from_str(StatusCode::BadRequest, format!("{}", e)))?;
+            .map_err(|e| crate::Error::from_str(crate::StatusCode::BadRequest, format!("{}", e)))?;
         self.url.set_query(Some(&query));
         Ok(())
     }

src/response.rs

@@ -7,6 +7,7 @@ use std::ops::Index;
 use std::pin::Pin;
 use std::task::{Context, Poll};
 
+#[cfg(feature = "serde")]
 use crate::convert::DeserializeOwned;
 use crate::headers::{
     self, HeaderName, HeaderValue, HeaderValues, Headers, Names, ToHeaderValues, Values,
@@ -313,6 +314,7 @@ impl Response {
     /// use http_types::{Body, Method, Response, StatusCode, Url};
     ///
     /// #[derive(Debug, Serialize, Deserialize)]
+    /// # #[serde(crate = "serde_crate")]
     /// struct Cat {
     ///     name: String,
     /// }
@@ -327,6 +329,8 @@ impl Response {
     /// assert_eq!(&cat.name, "chashu");
     /// # Ok(()) }) }
     /// ```
+
+    #[cfg(feature = "serde")]
     pub async fn body_json<T: DeserializeOwned>(&mut self) -> crate::Result<T> {
         let body = self.take_body();
         body.into_json().await
@@ -347,6 +351,7 @@ impl Response {
     /// use http_types::{Body, Method, Response, StatusCode, Url};
     ///
     /// #[derive(Debug, Serialize, Deserialize)]
+    /// # #[serde(crate = "serde_crate")]
     /// struct Cat {
     ///     name: String,
     /// }
@@ -361,6 +366,7 @@ impl Response {
     /// assert_eq!(&cat.name, "chashu");
     /// # Ok(()) }) }
     /// ```
+    #[cfg(feature = "serde")]
     pub async fn body_form<T: DeserializeOwned>(&mut self) -> crate::Result<T> {
         let body = self.take_body();
         body.into_form().await