Merge branch 'main' into header-content-location

Author: pepoviola

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "http-types"
-version = "2.5.0"
+version = "2.6.0"
 license = "MIT OR Apache-2.0"
 repository = "https://github.com/http-rs/http-types"
 documentation = "https://docs.rs/http-types"
@@ -16,17 +16,19 @@ features = ["docs"]
 rustdoc-args = ["--cfg", "feature=\"docs\""]
 
 [features]
-default = ["async_std", "cookie-secure"]
+default = ["fs", "cookie-secure"]
 docs = ["unstable"]
 unstable = []
 hyperium_http = ["http"]
-async_std = [] # "async-std" when it is not default
+async_std = ["fs"]
 cookie-secure = ["cookie/secure"]
+fs = ["async-std"]
 
 [dependencies]
-# Note(yoshuawuyts): used for async_std's `channel` only; use "core" once possible.
 # features: async_std
-async-std = { version = "1.6.0", features = ["unstable"] }
+async-std = { version = "1.6.0", optional = true }
+futures-lite = "1.11.1"
+async-channel = "1.5.1"
 
 # features: hyperium/http
 http = { version = "0.2.0", optional = true }
@@ -44,4 +46,4 @@ serde_qs = "0.7.0"
 
 [dev-dependencies]
 http = "0.2.0"
-async-std = { version = "1.6.0", features = ["unstable", "attributes"] }
+async-std = { version = "1.6.0", features = ["attributes"] }

src/body.rs

@@ -1,5 +1,4 @@
-use async_std::io::prelude::*;
-use async_std::io::{self, Cursor};
+use futures_lite::{io, prelude::*};
 use serde::{de::DeserializeOwned, Serialize};
 
 use std::fmt::{self, Debug};
@@ -54,7 +53,7 @@ pin_project_lite::pin_project! {
     /// and not rely on the fallback mechanisms. However, they're still there if you need them.
     pub struct Body {
         #[pin]
-        reader: Box<dyn BufRead + Unpin + Send + Sync + 'static>,
+        reader: Box<dyn AsyncBufRead + Unpin + Send + Sync + 'static>,
         mime: Mime,
         length: Option<usize>,
     }
@@ -102,7 +101,7 @@ impl Body {
     /// req.set_body(Body::from_reader(cursor, Some(len)));
     /// ```
     pub fn from_reader(
-        reader: impl BufRead + Unpin + Send + Sync + 'static,
+        reader: impl AsyncBufRead + Unpin + Send + Sync + 'static,
         len: Option<usize>,
     ) -> Self {
         Self {
@@ -125,7 +124,7 @@ impl Body {
     /// let body = Body::from_reader(cursor, None);
     /// let _ = body.into_reader();
     /// ```
-    pub fn into_reader(self) -> Box<dyn BufRead + Unpin + Send + Sync + 'static> {
+    pub fn into_reader(self) -> Box<dyn AsyncBufRead + Unpin + Send + Sync + 'static> {
         self.reader
     }
 
@@ -160,7 +159,7 @@ impl Body {
     /// # Examples
     ///
     /// ```
-    /// # fn main() -> Result<(), http_types::Error> { async_std::task::block_on(async {
+    /// # fn main() -> http_types::Result<()> { async_std::task::block_on(async {
     /// use http_types::Body;
     ///
     /// let bytes = vec![1, 2, 3];
@@ -209,9 +208,7 @@ impl Body {
     /// # Examples
     ///
     /// ```
-    /// # use std::io::prelude::*;
-    /// # fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
-    /// # async_std::task::block_on(async {
+    /// # fn main() -> http_types::Result<()> { async_std::task::block_on(async {
     /// use http_types::Body;
     /// use async_std::io::Cursor;
     ///
@@ -246,7 +243,7 @@ impl Body {
         let bytes = serde_json::to_vec(&json)?;
         let body = Self {
             length: Some(bytes.len()),
-            reader: Box::new(Cursor::new(bytes)),
+            reader: Box::new(io::Cursor::new(bytes)),
             mime: mime::JSON,
         };
         Ok(body)
@@ -257,7 +254,7 @@ impl Body {
     /// # Examples
     ///
     /// ```
-    /// # fn main() -> Result<(), http_types::Error> { async_std::task::block_on(async {
+    /// # fn main() -> http_types::Result<()> { async_std::task::block_on(async {
     /// use http_types::Body;
     /// use http_types::convert::{Serialize, Deserialize};
     ///
@@ -290,7 +287,7 @@ impl Body {
     /// # Examples
     ///
     /// ```
-    /// # fn main() -> Result<(), http_types::Error> { async_std::task::block_on(async {
+    /// # fn main() -> http_types::Result<()> { async_std::task::block_on(async {
     /// use http_types::Body;
     /// use http_types::convert::{Serialize, Deserialize};
     ///
@@ -310,7 +307,7 @@ impl Body {
 
         let body = Self {
             length: Some(bytes.len()),
-            reader: Box::new(Cursor::new(bytes)),
+            reader: Box::new(io::Cursor::new(bytes)),
             mime: mime::FORM,
         };
         Ok(body)
@@ -326,7 +323,7 @@ impl Body {
     /// # Examples
     ///
     /// ```
-    /// # fn main() -> Result<(), http_types::Error> { async_std::task::block_on(async {
+    /// # fn main() -> http_types::Result<()> { async_std::task::block_on(async {
     /// use http_types::Body;
     /// use http_types::convert::{Serialize, Deserialize};
     ///
@@ -353,14 +350,14 @@ impl Body {
     /// # Examples
     ///
     /// ```no_run
-    /// # fn main() -> Result<(), http_types::Error> { async_std::task::block_on(async {
+    /// # fn main() -> http_types::Result<()> { async_std::task::block_on(async {
     /// use http_types::{Body, Response, StatusCode};
     ///
     /// let mut res = Response::new(StatusCode::Ok);
     /// res.set_body(Body::from_file("/path/to/file").await?);
     /// # Ok(()) }) }
     /// ```
-    #[cfg(all(feature = "async_std", not(target_os = "unknown")))]
+    #[cfg(all(feature = "fs", not(target_os = "unknown")))]
     pub async fn from_file<P>(path: P) -> io::Result<Self>
     where
         P: AsRef<std::path::Path>,
@@ -455,7 +452,7 @@ impl<'a> From<&'a [u8]> for Body {
     }
 }
 
-impl Read for Body {
+impl AsyncRead for Body {
     #[allow(missing_doc_code_examples)]
     fn poll_read(
         mut self: Pin<&mut Self>,
@@ -466,7 +463,7 @@ impl Read for Body {
     }
 }
 
-impl BufRead for Body {
+impl AsyncBufRead for Body {
     #[allow(missing_doc_code_examples)]
     fn poll_fill_buf(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<&'_ [u8]>> {
         let this = self.project();
@@ -480,7 +477,7 @@ impl BufRead for Body {
 
 /// Look at first few bytes of a file to determine the mime type.
 /// This is used for various binary formats such as images and videos.
-#[cfg(all(feature = "async_std", not(target_os = "unknown")))]
+#[cfg(all(feature = "fs", not(target_os = "unknown")))]
 async fn peek_mime(file: &mut async_std::fs::File) -> io::Result<Option<Mime>> {
     // We need to read the first 300 bytes to correctly infer formats such as tar.
     let mut buf = [0_u8; 300];
@@ -494,7 +491,7 @@ async fn peek_mime(file: &mut async_std::fs::File) -> io::Result<Option<Mime>> {
 
 /// Look at the extension of a file to determine the mime type.
 /// This is useful for plain-text formats such as HTML and CSS.
-#[cfg(all(feature = "async_std", not(target_os = "unknown")))]
+#[cfg(all(feature = "fs", not(target_os = "unknown")))]
 fn guess_ext(path: &std::path::Path) -> Option<Mime> {
     let ext = path.extension().map(|p| p.to_str()).flatten();
     ext.and_then(Mime::from_extension)

src/content/content_length.rs

@@ -0,0 +1,108 @@
+use crate::headers::{HeaderName, HeaderValue, Headers, CONTENT_LENGTH};
+use crate::Status;
+
+/// The size of the entity-body, in bytes, sent to the recipient.
+///
+/// # Specifications
+///
+/// - [RFC 7230, section 3.3.2: Content-Length](https://tools.ietf.org/html/rfc7230#section-3.3.2)
+///
+/// # Examples
+///
+/// ```
+/// # fn main() -> http_types::Result<()> {
+/// #
+/// use http_types::Response;
+/// use http_types::content::{ContentLength};
+///
+/// let content_len = ContentLength::new(12);
+///
+/// let mut res = Response::new(200);
+/// content_len.apply(&mut res);
+///
+/// let content_len = ContentLength::from_headers(res)?.unwrap();
+/// assert_eq!(content_len.len(), 12);
+/// #
+/// # Ok(()) }
+/// ```
+#[derive(Debug)]
+pub struct ContentLength {
+    length: u64,
+}
+
+#[allow(clippy::len_without_is_empty)]
+impl ContentLength {
+    /// Create a new instance.
+    pub fn new(length: u64) -> Self {
+        Self { length }
+    }
+
+    /// Create a new instance from headers.
+    pub fn from_headers(headers: impl AsRef<Headers>) -> crate::Result<Option<Self>> {
+        let headers = match headers.as_ref().get(CONTENT_LENGTH) {
+            Some(headers) => headers,
+            None => return Ok(None),
+        };
+
+        // If we successfully parsed the header then there's always at least one
+        // entry. We want the last entry.
+        let value = headers.iter().last().unwrap();
+        let length = value.as_str().trim().parse().status(400)?;
+        Ok(Some(Self { length }))
+    }
+
+    /// Sets the header.
+    pub fn apply(&self, mut headers: impl AsMut<Headers>) {
+        headers.as_mut().insert(self.name(), self.value());
+    }
+
+    /// Get the `HeaderName`.
+    pub fn name(&self) -> HeaderName {
+        CONTENT_LENGTH
+    }
+
+    /// Get the `HeaderValue`.
+    pub fn value(&self) -> HeaderValue {
+        let output = format!("{}", self.length);
+
+        // SAFETY: the internal string is validated to be ASCII.
+        unsafe { HeaderValue::from_bytes_unchecked(output.into()) }
+    }
+
+    /// Get the content length.
+    pub fn len(&self) -> u64 {
+        self.length
+    }
+
+    /// Set the content length.
+    pub fn set_len(&mut self, len: u64) {
+        self.length = len;
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use crate::headers::Headers;
+
+    #[test]
+    fn smoke() -> crate::Result<()> {
+        let content_len = ContentLength::new(12);
+
+        let mut headers = Headers::new();
+        content_len.apply(&mut headers);
+
+        let content_len = ContentLength::from_headers(headers)?.unwrap();
+        assert_eq!(content_len.len(), 12);
+        Ok(())
+    }
+
+    #[test]
+    fn bad_request_on_parse_error() -> crate::Result<()> {
+        let mut headers = Headers::new();
+        headers.insert(CONTENT_LENGTH, "<nori ate the tag. yum.>");
+        let err = ContentLength::from_headers(headers).unwrap_err();
+        assert_eq!(err.status(), 400);
+        Ok(())
+    }
+}

src/content/mod.rs

@@ -8,6 +8,7 @@
 pub mod accept_encoding;
 pub mod content_encoding;
 
+mod content_length;
 mod content_location;
 mod encoding;
 mod encoding_proposal;
@@ -16,6 +17,7 @@ mod encoding_proposal;
 pub use accept_encoding::AcceptEncoding;
 #[doc(inline)]
 pub use content_encoding::ContentEncoding;
+pub use content_length::ContentLength;
 pub use content_location::ContentLocation;
 pub use encoding::Encoding;
 pub use encoding_proposal::EncodingProposal;

src/lib.rs

@@ -122,7 +122,9 @@ pub mod conditional;
 pub mod content;
 pub mod headers;
 pub mod mime;
+pub mod other;
 pub mod proxies;
+pub mod server;
 
 mod body;
 mod error;