Merge pull request #50 from yoshuawuyts/updates

Fixes from integration with tide

Author: yoshuawuyts

Cargo.toml

@@ -12,14 +12,14 @@ readme = "README.md"
 edition = "2018"
 
 [features]
+default = []
 hyperium_http = ["http"]
 
 [dependencies]
-async-std = { version = "0.99.12", default-features = false, features = ["std"] }
+async-std = { version = "1.4.0", default-features = false, features = ["std"] }
 cookie = "0.12.0"
 infer = "0.1.2"
 pin-project-lite = "0.1.0"
-pin-utils = "0.1.0-alpha.4"
 url = "2.1.0"
 omnom = "2.1.1"
 

src/body.rs

@@ -51,7 +51,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 + 'static>,
+        reader: Box<dyn BufRead + Unpin + Send + Sync + 'static>,
         mime: Option<Mime>,
         length: Option<usize>,
     }
@@ -98,7 +98,10 @@ impl Body {
     /// let len = 10;
     /// req.set_body(Body::from_reader(cursor, Some(len)));
     /// ```
-    pub fn from_reader(reader: impl BufRead + Unpin + Send + 'static, len: Option<usize>) -> Self {
+    pub fn from_reader(
+        reader: impl BufRead + Unpin + Send + Sync + 'static,
+        len: Option<usize>,
+    ) -> Self {
         Self {
             reader: Box::new(reader),
             mime: Some(mime::BYTE_STREAM),
@@ -144,12 +147,9 @@ impl Body {
         self.reader
     }
 
-    /// Get the recommended mime type.
-    ///
-    /// This methods exists because Body is instantiated with a MIME type,
-    /// and when passing it to the request / response we don't want to clone it.
+    /// Return the mime type.
     pub(crate) fn take_mime(&mut self) -> Mime {
-        self.mime.take().unwrap()
+        self.mime.take().expect("internal error: missing mime")
     }
 }
 

src/error.rs

@@ -168,13 +168,6 @@ impl fmt::Display for Error {
 }
 
 impl error::Error for Error {
-    fn description(&self) -> &str {
-        match self.repr {
-            Repr::Simple(..) => self.kind().as_str(),
-            Repr::Custom(ref c) => c.error.description(),
-        }
-    }
-
     #[allow(deprecated)]
     fn cause(&self) -> Option<&dyn error::Error> {
         match self.repr {

src/headers/constants.rs

@@ -11,3 +11,6 @@ pub const COOKIE: HeaderName = HeaderName::from_lowercase_str("cookie");
 
 /// The `Set-Cookie` Header
 pub const SET_COOKIE: HeaderName = HeaderName::from_lowercase_str("set-cookie");
+
+/// The `Transfer-Encoding` Header
+pub const TRANSFER_ENCODING: HeaderName = HeaderName::from_lowercase_str("transfer-encoding");

src/headers/header_name.rs

@@ -1,16 +1,12 @@
+use std::borrow::Cow;
 use std::fmt::{self, Debug, Display};
 use std::str::FromStr;
 
 use crate::headers::ParseError;
 
 /// A header name.
-#[derive(Eq, PartialEq, Hash)]
-pub struct HeaderName {
-    /// The inner representation of the string.
-    pub(crate) string: String,
-    /// A const-friendly string. Useful because `String::from` cannot be used in const contexts.
-    pub(crate) static_str: Option<&'static str>,
-}
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub struct HeaderName(Cow<'static, str>);
 
 impl HeaderName {
     /// Create a new `HeaderName`.
@@ -20,10 +16,12 @@ impl HeaderName {
         }
         bytes.make_ascii_lowercase();
         let string = String::from_utf8(bytes).map_err(|_| ParseError::new())?;
-        Ok(Self {
-            string: string,
-            static_str: None,
-        })
+        Ok(HeaderName(Cow::Owned(string)))
+    }
+
+    /// Returns the header name as a `&str`.
+    pub fn as_str(&self) -> &'_ str {
+        &self.0
     }
 
     /// Converts a vector of bytes to a `HeaderName` without checking that the string contains
@@ -38,38 +36,18 @@ impl HeaderName {
     pub unsafe fn from_ascii_unchecked(mut bytes: Vec<u8>) -> Self {
         bytes.make_ascii_lowercase();
         let string = String::from_utf8_unchecked(bytes);
-        Self {
-            string,
-            static_str: None,
-        }
+        HeaderName(Cow::Owned(string))
     }
 
     /// Converts a string assumed to lowercase into a `HeaderName`
     pub(crate) const fn from_lowercase_str(str: &'static str) -> Self {
-        Self {
-            string: String::new(),
-            static_str: Some(str),
-        }
+        HeaderName(Cow::Borrowed(str))
     }
 }
 
 impl Display for HeaderName {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        if let Some(string) = self.static_str {
-            Display::fmt(string, f)
-        } else {
-            Display::fmt(&self.string, f)
-        }
-    }
-}
-
-impl Debug for HeaderName {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        if let Some(string) = self.static_str {
-            Debug::fmt(string, f)
-        } else {
-            Debug::fmt(&self.string, f)
-        }
+        write!(f, "{}", self.0)
     }
 }
 
@@ -83,9 +61,25 @@ impl FromStr for HeaderName {
         if !s.is_ascii() {
             return Err(ParseError::new());
         }
-        Ok(Self {
-            string: s.to_ascii_lowercase(),
-            static_str: None,
-        })
+        Ok(HeaderName(Cow::Owned(s.to_ascii_lowercase())))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_header_name_static_non_static() {
+        let static_header = HeaderName::from_lowercase_str("hello");
+        let non_static_header = HeaderName::from_str("hello").unwrap();
+
+        assert_eq!(&static_header, &non_static_header);
+        assert_eq!(&static_header, &static_header);
+        assert_eq!(&non_static_header, &non_static_header);
+
+        assert_eq!(static_header, non_static_header);
+        assert_eq!(static_header, static_header);
+        assert_eq!(non_static_header, non_static_header);
     }
 }

src/headers/mod.rs

@@ -30,7 +30,7 @@ pub use values::Values;
 /// A collection of HTTP Headers.
 #[derive(Debug)]
 pub struct Headers {
-    headers: HashMap<HeaderName, Vec<HeaderValue>>,
+    pub(crate) headers: HashMap<HeaderName, Vec<HeaderValue>>,
 }
 
 impl Headers {
@@ -143,3 +143,55 @@ impl<'a> IntoIterator for &'a mut Headers {
         self.iter_mut()
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::str::FromStr;
+
+    const STATIC_HEADER: HeaderName = HeaderName::from_lowercase_str("hello");
+
+    #[test]
+    fn test_header_name_static_non_static() {
+        let static_header = HeaderName::from_lowercase_str("hello");
+        let non_static_header = HeaderName::from_str("hello").unwrap();
+
+        let mut headers = Headers::new();
+        headers
+            .append(STATIC_HEADER, &["foo0".parse().unwrap()][..])
+            .unwrap();
+        headers
+            .append(static_header.clone(), &["foo1".parse().unwrap()][..])
+            .unwrap();
+        headers
+            .append(non_static_header.clone(), &["foo2".parse().unwrap()][..])
+            .unwrap();
+
+        assert_eq!(
+            &headers.get(&STATIC_HEADER).unwrap()[..],
+            &[
+                "foo0".parse().unwrap(),
+                "foo1".parse().unwrap(),
+                "foo2".parse().unwrap()
+            ][..]
+        );
+
+        assert_eq!(
+            &headers.get(&static_header).unwrap()[..],
+            &[
+                "foo0".parse().unwrap(),
+                "foo1".parse().unwrap(),
+                "foo2".parse().unwrap()
+            ][..]
+        );
+
+        assert_eq!(
+            &headers.get(&non_static_header).unwrap()[..],
+            &[
+                "foo0".parse().unwrap(),
+                "foo1".parse().unwrap(),
+                "foo2".parse().unwrap()
+            ][..]
+        );
+    }
+}

src/headers/to_header_values.rs

@@ -29,3 +29,14 @@ impl<'a> ToHeaderValues for &'a [HeaderValue] {
         Ok(self.iter().cloned())
     }
 }
+
+impl<'a> ToHeaderValues for &'a str {
+    type Iter = option::IntoIter<HeaderValue>;
+
+    fn to_header_values(&self) -> io::Result<Self::Iter> {
+        let value = self
+            .parse()
+            .map_err(|err| io::Error::new(io::ErrorKind::Other, err))?;
+        Ok(Some(value).into_iter())
+    }
+}

src/hyperium_http.rs

@@ -11,8 +11,8 @@ impl From<http::Method> for Method {
     }
 }
 
-impl From<&Method> for http::Method {
-    fn from(method: &Method) -> Self {
+impl From<Method> for http::Method {
+    fn from(method: Method) -> Self {
         http::Method::from_str(&format!("{}", method)).unwrap()
     }
 }

src/method.rs

@@ -38,6 +38,19 @@ pub enum Method {
     Patch,
 }
 
+impl Method {
+    /// Whether a method is considered "safe", meaning the request is
+    /// essentially read-only.
+    ///
+    /// See [the spec](https://tools.ietf.org/html/rfc7231#section-4.2.1) for more details.
+    pub fn is_safe(&self) -> bool {
+        match self {
+            Method::Get | Method::Head | Method::Options | Method::Trace => true,
+            _ => false,
+        }
+    }
+}
+
 impl Display for Method {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {

src/mime/mod.rs

@@ -20,6 +20,7 @@ use infer::Infer;
 /// An IANA media type.
 // NOTE: we cannot statically initialize Strings with values yet, so we keep dedicated static
 // fields for the static strings.
+#[derive(Clone)]
 pub struct Mime {
     pub(crate) essence: String,
     pub(crate) basetype: String,