Merge 973d098bc7 into ac5d645ce5

Cargo.toml

@@ -1,12 +1,18 @@
 [package]
 name = "http-types"
-version = "4.0.0"
+version = "3.0.0"
 license = "MIT OR Apache-2.0"
 repository = "https://github.com/http-rs/http-types"
 documentation = "https://docs.rs/http-types"
 description = "Common types for HTTP operations."
 keywords = ["http", "types", "request", "response", "h2"]
-categories = ["asynchronous", "web-programming", "web-programming::http-client", "web-programming::http-server", "web-programming::websocket"]
+categories = [
+    "asynchronous",
+    "web-programming",
+    "web-programming::http-client",
+    "web-programming::http-server",
+    "web-programming::websocket",
+]
 authors = ["Yoshua Wuyts <yoshuawuyts@gmail.com>"]
 readme = "README.md"
 edition = "2018"
@@ -19,12 +25,20 @@ rustdoc-args = ["--cfg", "feature=\"docs\""]
 default = ["fs", "cookie-secure", "serde"]
 docs = ["unstable"]
 unstable = []
-hyperium_http = ["http"]
+hyperium_http = ["hyperium_http_02"]
+hyperium_http_02 = ["http02"]
+hyperium_http_1 = ["http1"]
 async_std = ["fs"]
 cookies = ["cookie"]
 cookie-secure = ["cookies", "cookie/secure"]
 fs = ["async-std"]
-serde = ["serde_qs", "serde_crate", "serde_json", "serde_urlencoded", "url/serde"]
+serde = [
+    "serde_qs",
+    "serde_crate",
+    "serde_json",
+    "serde_urlencoded",
+    "url/serde",
+]
 
 [dependencies]
 fastrand = "2.0.1"
@@ -39,19 +53,22 @@ anyhow = "1.0.79"
 # features: async_std
 async-std = { version = "1.12.0", optional = true }
 
-# features: hyperium/http
-http = { version = "1.0.0", optional = true }
+# features: hyperium_http or hyperium_http_02
+http02 = { package = "http", version = "0.2.0", optional = true }
+# features: hyperium_http_1
+http1 = { package = "http", version = "1.0.0", optional = true }
 
 # features: cookies
 cookie = { version = "0.18.0", features = ["percent-encode"], optional = true }
 
 # features: serde
 serde_json = { version = "1.0.111", optional = true }
-serde_crate = { version = "1.0.195", features = ["derive"], optional = true, package = "serde" }
-serde_urlencoded = { version = "0.7.1", optional = true}
+serde_crate = { version = "1.0.195", features = [
+    "derive",
+], optional = true, package = "serde" }
+serde_urlencoded = { version = "0.7.1", optional = true }
 serde_qs = { version = "0.12.0", optional = true }
 
 
 [dev-dependencies]
-http = "1.0.0"
 async-std = { version = "1.12.0", features = ["attributes"] }

src/hyperium_http.rs

@@ -5,95 +5,95 @@ use crate::{Body, Error, Method, Request, Response, StatusCode, Url, Version};
 use std::convert::{TryFrom, TryInto};
 use std::str::FromStr;
 
-impl From<http::Method> for Method {
-    fn from(method: http::Method) -> Self {
+impl From<http02::Method> for Method {
+    fn from(method: http02::Method) -> Self {
         Method::from_str(method.as_str()).unwrap()
     }
 }
 
-impl From<Method> for http::Method {
+impl From<Method> for http02::Method {
     fn from(method: Method) -> Self {
-        http::Method::from_str(method.as_ref()).unwrap()
+        http02::Method::from_str(method.as_ref()).unwrap()
     }
 }
 
-impl From<http::StatusCode> for StatusCode {
-    fn from(status: http::StatusCode) -> Self {
+impl From<http02::StatusCode> for StatusCode {
+    fn from(status: http02::StatusCode) -> Self {
         StatusCode::try_from(status.as_u16()).unwrap()
     }
 }
 
-impl From<StatusCode> for http::StatusCode {
+impl From<StatusCode> for http02::StatusCode {
     fn from(status: StatusCode) -> Self {
-        http::StatusCode::from_u16(status.into()).unwrap()
+        http02::StatusCode::from_u16(status.into()).unwrap()
     }
 }
 
-impl From<http::Version> for Version {
-    fn from(version: http::Version) -> Self {
+impl From<http02::Version> for Version {
+    fn from(version: http02::Version) -> Self {
         match version {
-            http::Version::HTTP_09 => Version::Http0_9,
-            http::Version::HTTP_10 => Version::Http1_0,
-            http::Version::HTTP_11 => Version::Http1_1,
-            http::Version::HTTP_2 => Version::Http2_0,
-            http::Version::HTTP_3 => Version::Http3_0,
+            http02::Version::HTTP_09 => Version::Http0_9,
+            http02::Version::HTTP_10 => Version::Http1_0,
+            http02::Version::HTTP_11 => Version::Http1_1,
+            http02::Version::HTTP_2 => Version::Http2_0,
+            http02::Version::HTTP_3 => Version::Http3_0,
             _ => panic!("unknown HTTP version conversion"),
         }
     }
 }
 
-impl From<Version> for http::Version {
+impl From<Version> for http02::Version {
     fn from(version: Version) -> Self {
         match version {
-            Version::Http0_9 => http::Version::HTTP_09,
-            Version::Http1_0 => http::Version::HTTP_10,
-            Version::Http1_1 => http::Version::HTTP_11,
-            Version::Http2_0 => http::Version::HTTP_2,
-            Version::Http3_0 => http::Version::HTTP_3,
+            Version::Http0_9 => http02::Version::HTTP_09,
+            Version::Http1_0 => http02::Version::HTTP_10,
+            Version::Http1_1 => http02::Version::HTTP_11,
+            Version::Http2_0 => http02::Version::HTTP_2,
+            Version::Http3_0 => http02::Version::HTTP_3,
         }
     }
 }
 
-impl TryFrom<http::header::HeaderName> for HeaderName {
+impl TryFrom<http02::header::HeaderName> for HeaderName {
     type Error = Error;
 
-    fn try_from(name: http::header::HeaderName) -> Result<Self, Self::Error> {
+    fn try_from(name: http02::header::HeaderName) -> Result<Self, Self::Error> {
         let name = name.as_str().as_bytes().to_owned();
         HeaderName::from_bytes(name)
     }
 }
 
-impl TryFrom<HeaderName> for http::header::HeaderName {
+impl TryFrom<HeaderName> for http02::header::HeaderName {
     type Error = Error;
 
     fn try_from(name: HeaderName) -> Result<Self, Self::Error> {
         let name = name.as_str().as_bytes();
-        http::header::HeaderName::from_bytes(name).map_err(Error::new_adhoc)
+        http02::header::HeaderName::from_bytes(name).map_err(Error::new_adhoc)
     }
 }
 
-impl TryFrom<http::header::HeaderValue> for HeaderValue {
+impl TryFrom<http02::header::HeaderValue> for HeaderValue {
     type Error = Error;
 
-    fn try_from(value: http::header::HeaderValue) -> Result<Self, Self::Error> {
+    fn try_from(value: http02::header::HeaderValue) -> Result<Self, Self::Error> {
         let value = value.as_bytes().to_owned();
         HeaderValue::from_bytes(value)
     }
 }
 
-impl TryFrom<HeaderValue> for http::header::HeaderValue {
+impl TryFrom<HeaderValue> for http02::header::HeaderValue {
     type Error = Error;
 
     fn try_from(value: HeaderValue) -> Result<Self, Self::Error> {
         let value = value.as_str().as_bytes();
-        http::header::HeaderValue::from_bytes(value).map_err(Error::new_adhoc)
+        http02::header::HeaderValue::from_bytes(value).map_err(Error::new_adhoc)
     }
 }
 
-impl TryFrom<http::HeaderMap> for Headers {
+impl TryFrom<http02::HeaderMap> for Headers {
     type Error = Error;
 
-    fn try_from(hyperium_headers: http::HeaderMap) -> Result<Self, Self::Error> {
+    fn try_from(hyperium_headers: http02::HeaderMap) -> Result<Self, Self::Error> {
         let mut headers = Headers::new();
 
         hyperium_headers
@@ -112,21 +112,21 @@ impl TryFrom<http::HeaderMap> for Headers {
     }
 }
 
-impl TryFrom<Headers> for http::HeaderMap {
+impl TryFrom<Headers> for http02::HeaderMap {
     type Error = Error;
 
     fn try_from(headers: Headers) -> Result<Self, Self::Error> {
-        let mut hyperium_headers = http::HeaderMap::new();
+        let mut hyperium_headers = http02::HeaderMap::new();
 
         headers
             .into_iter()
             .map(|(name, values)| {
-                let name: http::header::HeaderName = name.try_into()?;
+                let name: http02::header::HeaderName = name.try_into()?;
 
                 values
                     .into_iter()
                     .map(|value| {
-                        let value: http::header::HeaderValue = value.try_into()?;
+                        let value: http02::header::HeaderValue = value.try_into()?;
                         hyperium_headers.append(&name, value);
                         Ok(())
                     })
@@ -141,7 +141,7 @@ impl TryFrom<Headers> for http::HeaderMap {
 }
 
 fn hyperium_headers_to_headers(
-    hyperium_headers: http::HeaderMap,
+    hyperium_headers: http02::HeaderMap,
     headers: &mut Headers,
 ) -> crate::Result<()> {
     for (name, value) in hyperium_headers {
@@ -156,33 +156,33 @@ fn hyperium_headers_to_headers(
     Ok(())
 }
 
-fn headers_to_hyperium_headers(headers: &mut Headers, hyperium_headers: &mut http::HeaderMap) {
+fn headers_to_hyperium_headers(headers: &mut Headers, hyperium_headers: &mut http02::HeaderMap) {
     for (name, values) in headers {
         let name = format!("{}", name).into_bytes();
-        let name = http::header::HeaderName::from_bytes(&name).unwrap();
+        let name = http02::header::HeaderName::from_bytes(&name).unwrap();
 
         for value in values.iter() {
             let value = format!("{}", value).into_bytes();
-            let value = http::header::HeaderValue::from_bytes(&value).unwrap();
+            let value = http02::header::HeaderValue::from_bytes(&value).unwrap();
             hyperium_headers.append(&name, value);
         }
     }
 }
 
 // Neither type is defined in this lib, so we can't do From/Into impls
-fn from_uri_to_url(uri: http::Uri) -> Result<Url, crate::url::ParseError> {
+fn from_uri_to_url(uri: http02::Uri) -> Result<Url, crate::url::ParseError> {
     format!("{}", uri).parse()
 }
 
 // Neither type is defined in this lib, so we can't do From/Into impls
-fn from_url_to_uri(url: &Url) -> http::Uri {
-    http::Uri::try_from(&format!("{}", url)).unwrap()
+fn from_url_to_uri(url: &Url) -> http02::Uri {
+    http02::Uri::try_from(&format!("{}", url)).unwrap()
 }
 
-impl TryFrom<http::Request<Body>> for Request {
+impl TryFrom<http02::Request<Body>> for Request {
     type Error = crate::Error;
 
-    fn try_from(req: http::Request<Body>) -> Result<Self, Self::Error> {
+    fn try_from(req: http02::Request<Body>) -> Result<Self, Self::Error> {
         let (parts, body) = req.into_parts();
         let method = parts.method.into();
         let url = from_uri_to_url(parts.uri)?;
@@ -194,11 +194,11 @@ impl TryFrom<http::Request<Body>> for Request {
     }
 }
 
-impl From<Request> for http::Request<Body> {
+impl From<Request> for http02::Request<Body> {
     fn from(mut req: Request) -> Self {
-        let method: http::Method = req.method().into();
+        let method: http02::Method = req.method().into();
         let version = req.version().map(|v| v.into()).unwrap_or_default();
-        let mut builder = http::request::Builder::new()
+        let mut builder = http02::request::Builder::new()
             .method(method)
             .uri(from_url_to_uri(req.url()))
             .version(version);
@@ -207,9 +207,9 @@ impl From<Request> for http::Request<Body> {
     }
 }
 
-impl TryFrom<http::Response<Body>> for Response {
+impl TryFrom<http02::Response<Body>> for Response {
     type Error = crate::Error;
-    fn try_from(res: http::Response<Body>) -> Result<Self, Self::Error> {
+    fn try_from(res: http02::Response<Body>) -> Result<Self, Self::Error> {
         let (parts, body) = res.into_parts();
         let mut res = Response::new(parts.status);
         res.set_body(body);
@@ -219,11 +219,11 @@ impl TryFrom<http::Response<Body>> for Response {
     }
 }
 
-impl From<Response> for http::Response<Body> {
+impl From<Response> for http02::Response<Body> {
     fn from(mut res: Response) -> Self {
         let status: u16 = res.status().into();
         let version = res.version().map(|v| v.into()).unwrap_or_default();
-        let mut builder = http::response::Builder::new()
+        let mut builder = http02::response::Builder::new()
             .status(status)
             .version(version);
         headers_to_hyperium_headers(res.as_mut(), builder.headers_mut().unwrap());

src/hyperium_http_1.rs

@@ -0,0 +1,231 @@
+use crate::headers::{HeaderName, HeaderValue, Headers};
+use crate::{Body, Error, Method, Request, Response, StatusCode, Url, Version};
+use std::convert::{TryFrom, TryInto};
+use std::str::FromStr;
+
+impl From<http1::Method> for Method {
+    fn from(method: http1::Method) -> Self {
+        Method::from_str(method.as_str()).unwrap()
+    }
+}
+
+impl From<Method> for http1::Method {
+    fn from(method: Method) -> Self {
+        http1::Method::from_str(method.as_ref()).unwrap()
+    }
+}
+
+impl From<http1::StatusCode> for StatusCode {
+    fn from(status: http1::StatusCode) -> Self {
+        StatusCode::try_from(status.as_u16()).unwrap()
+    }
+}
+
+impl From<StatusCode> for http1::StatusCode {
+    fn from(status: StatusCode) -> Self {
+        http1::StatusCode::from_u16(status.into()).unwrap()
+    }
+}
+
+impl From<http1::Version> for Version {
+    fn from(version: http1::Version) -> Self {
+        match version {
+            http1::Version::HTTP_09 => Version::Http0_9,
+            http1::Version::HTTP_10 => Version::Http1_0,
+            http1::Version::HTTP_11 => Version::Http1_1,
+            http1::Version::HTTP_2 => Version::Http2_0,
+            http1::Version::HTTP_3 => Version::Http3_0,
+            _ => panic!("unknown http1 version conversion"),
+        }
+    }
+}
+
+impl From<Version> for http1::Version {
+    fn from(version: Version) -> Self {
+        match version {
+            Version::Http0_9 => http1::Version::HTTP_09,
+            Version::Http1_0 => http1::Version::HTTP_10,
+            Version::Http1_1 => http1::Version::HTTP_11,
+            Version::Http2_0 => http1::Version::HTTP_2,
+            Version::Http3_0 => http1::Version::HTTP_3,
+        }
+    }
+}
+
+impl TryFrom<http1::header::HeaderName> for HeaderName {
+    type Error = Error;
+
+    fn try_from(name: http1::header::HeaderName) -> Result<Self, Self::Error> {
+        let name = name.as_str().as_bytes().to_owned();
+        HeaderName::from_bytes(name)
+    }
+}
+
+impl TryFrom<HeaderName> for http1::header::HeaderName {
+    type Error = Error;
+
+    fn try_from(name: HeaderName) -> Result<Self, Self::Error> {
+        let name = name.as_str().as_bytes();
+        http1::header::HeaderName::from_bytes(name).map_err(Error::new_adhoc)
+    }
+}
+
+impl TryFrom<http1::header::HeaderValue> for HeaderValue {
+    type Error = Error;
+
+    fn try_from(value: http1::header::HeaderValue) -> Result<Self, Self::Error> {
+        let value = value.as_bytes().to_owned();
+        HeaderValue::from_bytes(value)
+    }
+}
+
+impl TryFrom<HeaderValue> for http1::header::HeaderValue {
+    type Error = Error;
+
+    fn try_from(value: HeaderValue) -> Result<Self, Self::Error> {
+        let value = value.as_str().as_bytes();
+        http1::header::HeaderValue::from_bytes(value).map_err(Error::new_adhoc)
+    }
+}
+
+impl TryFrom<http1::HeaderMap> for Headers {
+    type Error = Error;
+
+    fn try_from(hyperium_headers: http1::HeaderMap) -> Result<Self, Self::Error> {
+        let mut headers = Headers::new();
+
+        hyperium_headers
+            .into_iter()
+            .map(|(name, value)| {
+                if let Some(name) = name {
+                    let value: HeaderValue = value.try_into()?;
+                    let name: HeaderName = name.try_into()?;
+                    headers.append(name, value)?;
+                }
+                Ok(())
+            })
+            .collect::<Result<Vec<()>, Error>>()?;
+
+        Ok(headers)
+    }
+}
+
+impl TryFrom<Headers> for http1::HeaderMap {
+    type Error = Error;
+
+    fn try_from(headers: Headers) -> Result<Self, Self::Error> {
+        let mut hyperium_headers = http1::HeaderMap::new();
+
+        headers
+            .into_iter()
+            .map(|(name, values)| {
+                let name: http1::header::HeaderName = name.try_into()?;
+
+                values
+                    .into_iter()
+                    .map(|value| {
+                        let value: http1::header::HeaderValue = value.try_into()?;
+                        hyperium_headers.append(&name, value);
+                        Ok(())
+                    })
+                    .collect::<Result<Vec<()>, Error>>()?;
+
+                Ok(())
+            })
+            .collect::<Result<Vec<()>, Error>>()?;
+
+        Ok(hyperium_headers)
+    }
+}
+
+fn hyperium_headers_to_headers(
+    hyperium_headers: http1::HeaderMap,
+    headers: &mut Headers,
+) -> crate::Result<()> {
+    for (name, value) in hyperium_headers {
+        let value = value.as_bytes().to_owned();
+        let value = unsafe { HeaderValue::from_bytes_unchecked(value) };
+        if let Some(name) = name {
+            let name = name.as_str().as_bytes().to_owned();
+            let name = unsafe { HeaderName::from_bytes_unchecked(name) };
+            headers.append(name, value)?;
+        }
+    }
+    Ok(())
+}
+
+fn headers_to_hyperium_headers(headers: &mut Headers, hyperium_headers: &mut http1::HeaderMap) {
+    for (name, values) in headers {
+        let name = format!("{}", name).into_bytes();
+        let name = http1::header::HeaderName::from_bytes(&name).unwrap();
+
+        for value in values.iter() {
+            let value = format!("{}", value).into_bytes();
+            let value = http1::header::HeaderValue::from_bytes(&value).unwrap();
+            hyperium_headers.append(&name, value);
+        }
+    }
+}
+
+// Neither type is defined in this lib, so we can't do From/Into impls
+fn from_uri_to_url(uri: http1::Uri) -> Result<Url, crate::url::ParseError> {
+    format!("{}", uri).parse()
+}
+
+// Neither type is defined in this lib, so we can't do From/Into impls
+fn from_url_to_uri(url: &Url) -> http1::Uri {
+    http1::Uri::try_from(&format!("{}", url)).unwrap()
+}
+
+impl TryFrom<http1::Request<Body>> for Request {
+    type Error = crate::Error;
+
+    fn try_from(req: http1::Request<Body>) -> Result<Self, Self::Error> {
+        let (parts, body) = req.into_parts();
+        let method = parts.method.into();
+        let url = from_uri_to_url(parts.uri)?;
+        let mut req = Request::new(method, url);
+        req.set_body(body);
+        req.set_version(Some(parts.version.into()));
+        hyperium_headers_to_headers(parts.headers, req.as_mut())?;
+        Ok(req)
+    }
+}
+
+impl From<Request> for http1::Request<Body> {
+    fn from(mut req: Request) -> Self {
+        let method: http1::Method = req.method().into();
+        let version = req.version().map(|v| v.into()).unwrap_or_default();
+        let mut builder = http1::request::Builder::new()
+            .method(method)
+            .uri(from_url_to_uri(req.url()))
+            .version(version);
+        headers_to_hyperium_headers(req.as_mut(), builder.headers_mut().unwrap());
+        builder.body(req.into()).unwrap()
+    }
+}
+
+impl TryFrom<http1::Response<Body>> for Response {
+    type Error = crate::Error;
+    fn try_from(res: http1::Response<Body>) -> Result<Self, Self::Error> {
+        let (parts, body) = res.into_parts();
+        let mut res = Response::new(parts.status);
+        res.set_body(body);
+        res.set_version(Some(parts.version.into()));
+        hyperium_headers_to_headers(parts.headers, res.as_mut())?;
+        Ok(res)
+    }
+}
+
+impl From<Response> for http1::Response<Body> {
+    fn from(mut res: Response) -> Self {
+        let status: u16 = res.status().into();
+        let version = res.version().map(|v| v.into()).unwrap_or_default();
+        let mut builder = http1::response::Builder::new()
+            .status(status)
+            .version(version);
+        headers_to_hyperium_headers(res.as_mut(), builder.headers_mut().unwrap());
+        let body = res.take_body();
+        builder.body(body).unwrap()
+    }
+}

src/lib.rs

@@ -159,9 +159,12 @@ pub use crate::url::Url;
 pub mod security;
 pub mod trailers;
 
-#[cfg(feature = "hyperium_http")]
+#[cfg(feature = "hyperium_http_02")]
 mod hyperium_http;
 
+#[cfg(feature = "hyperium_http_1")]
+mod hyperium_http_1;
+
 #[doc(inline)]
 pub use crate::extensions::Extensions;