Updated dependencies

Cargo.toml

@@ -6,7 +6,13 @@ 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 <[email protected]>"]
 readme = "README.md"
 edition = "2018"
@@ -19,39 +25,50 @@ 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 = "1.4.0"
-base64 = "0.13.0"
-futures-lite = "1.11.1"
-async-channel = "1.5.1"
-infer = "0.7.0"
-pin-project-lite = "0.2.0"
-url = "2.1.1"
-anyhow = "1.0.26"
+fastrand = "2.0.1"
+base64 = "0.21.5"
+futures-lite = "2.2.0"
+async-channel = "2.1.1"
+infer = "0.15.0"
+pin-project-lite = "0.2.13"
+url = "2.5.0"
+anyhow = "1.0.79"
 
 # features: async_std
-async-std = { version = "1.6.0", optional = true }
+async-std = { version = "1.12.0", optional = true }
 
-# features: hyperium/http
-http = { version = "0.2.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.16.0", features = ["percent-encode"], optional = true }
+cookie = { version = "0.18.0", features = ["percent-encode"], optional = true }
 
 # 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.9.1", optional = true }
+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_qs = { version = "0.12.0", optional = true }
 
 
 [dev-dependencies]
-http = "0.2.0"
-async-std = { version = "1.6.0", features = ["attributes"] }
+async-std = { version = "1.12.0", features = ["attributes"] }

rust-toolchain.toml

@@ -0,0 +1,2 @@
+[toolchain]
+channel = "nightly"

src/auth/basic_auth.rs

@@ -1,3 +1,5 @@
+use base64::Engine;
+
 use crate::headers::{HeaderName, HeaderValue, Headers, AUTHORIZATION};
 use crate::Status;
 use crate::{
@@ -71,7 +73,9 @@ impl BasicAuth {
 
     /// Create a new instance from the base64 encoded credentials.
     pub fn from_credentials(credentials: impl AsRef<[u8]>) -> crate::Result<Self> {
-        let bytes = base64::decode(credentials).status(400)?;
+        let bytes = base64::engine::general_purpose::STANDARD
+            .decode(credentials)
+            .status(400)?;
         let credentials = String::from_utf8(bytes).status(400)?;
 
         let mut iter = credentials.splitn(2, ':');
@@ -105,7 +109,13 @@ impl Header for BasicAuth {
 
     fn header_value(&self) -> HeaderValue {
         let scheme = AuthenticationScheme::Basic;
-        let credentials = base64::encode(format!("{}:{}", self.username, self.password));
+
+        let mut credentials = String::new();
+        base64::engine::general_purpose::STANDARD.encode_string(
+            format!("{}:{}", self.username, self.password),
+            &mut credentials,
+        );
+
         let auth = Authorization::new(scheme, credentials);
         auth.header_value()
     }

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());