Merge pull request #127 from http-rs/arr-compare

Improve usage ergonomics

Author: yoshuawuyts

Cargo.toml

@@ -35,7 +35,7 @@ cookie = "0.12.0"
 infer = "0.1.2"
 omnom = "2.1.1"
 pin-project-lite = "0.1.0"
-url = "2.1.0"
+url = "2.1.1"
 serde_json = "1.0.51"
 serde = { version = "1.0.106", features = ["derive"] }
 serde_urlencoded = "0.6.1"

src/headers/header_name.rs

@@ -63,11 +63,15 @@ impl FromStr for HeaderName {
     }
 }
 
-impl<'a> std::convert::TryFrom<&'a str> for HeaderName {
-    type Error = Error;
+impl From<&HeaderName> for HeaderName {
+    fn from(value: &HeaderName) -> HeaderName {
+        value.clone()
+    }
+}
 
-    fn try_from(value: &'a str) -> Result<Self, Self::Error> {
-        Self::from_str(value)
+impl<'a> From<&'a str> for HeaderName {
+    fn from(value: &'a str) -> Self {
+        Self::from_str(value).expect("String slice should be valid ASCII")
     }
 }
 
@@ -136,4 +140,10 @@ mod tests {
         // Must validate regardless of casing.
         assert_eq!(static_header, &String::from("Hello"));
     }
+
+    #[test]
+    fn pass_name_by_ref() {
+        let mut res = crate::Response::new(200);
+        res.insert_header(&crate::headers::HOST, "127.0.0.1");
+    }
 }

src/headers/header_value.rs

@@ -1,3 +1,4 @@
+use std::convert::TryFrom;
 use std::fmt::{self, Display};
 use std::str::FromStr;
 
@@ -83,7 +84,7 @@ impl FromStr for HeaderValue {
     }
 }
 
-impl<'a> std::convert::TryFrom<&'a str> for HeaderValue {
+impl<'a> TryFrom<&'a str> for HeaderValue {
     type Error = Error;
 
     fn try_from(value: &'a str) -> Result<Self, Self::Error> {

src/headers/header_values.rs

@@ -95,6 +95,12 @@ impl<'a> PartialEq<&'a str> for HeaderValues {
     }
 }
 
+impl<'a> PartialEq<[&'a str]> for HeaderValues {
+    fn eq(&self, other: &[&'a str]) -> bool {
+        self.inner.iter().eq(other.iter())
+    }
+}
+
 impl PartialEq<String> for HeaderValues {
     fn eq(&self, other: &String) -> bool {
         self.inner.len() == 1 && &self.inner[0] == other

src/headers/headers.rs

@@ -1,7 +1,7 @@
 //! HTTP headers.
 
 use std::collections::HashMap;
-use std::convert::TryInto;
+use std::convert::Into;
 use std::iter::IntoIterator;
 use std::ops::Index;
 use std::str::FromStr;
@@ -23,7 +23,7 @@ use crate::headers::{
 /// use http_types::{Response, StatusCode};
 ///
 /// let mut res = Response::new(StatusCode::Ok);
-/// res.insert_header("hello", "foo0").unwrap();
+/// res.insert_header("hello", "foo0");
 /// assert_eq!(res["hello"], "foo0");
 /// ```
 #[derive(Debug, Clone)]
@@ -46,14 +46,12 @@ impl Headers {
     /// use `Headers::append`
     pub fn insert(
         &mut self,
-        name: impl TryInto<HeaderName>,
+        name: impl Into<HeaderName>,
         values: impl ToHeaderValues,
-    ) -> crate::Result<Option<HeaderValues>> {
-        let name = name
-            .try_into()
-            .map_err(|_| crate::format_err!("Could not convert into header name"))?;
-        let values: HeaderValues = values.to_header_values()?.collect();
-        Ok(self.headers.insert(name, values))
+    ) -> Option<HeaderValues> {
+        let name = name.into();
+        let values: HeaderValues = values.to_header_values().unwrap().collect();
+        self.headers.insert(name, values)
     }
 
     /// Append a header to the headers.
@@ -62,37 +60,35 @@ impl Headers {
     /// header if there aren't any. Or else append to the existing list of headers.
     pub fn append(
         &mut self,
-        name: impl TryInto<HeaderName>,
+        name: impl Into<HeaderName>,
         values: impl ToHeaderValues,
     ) -> crate::Result<()> {
-        let name = name
-            .try_into()
-            .map_err(|_| crate::format_err!("Could not convert into header name"))?;
-        match self.get_mut(&name) {
+        let name = name.into();
+        match self.get_mut(name.clone()) {
             Some(headers) => {
                 let mut values: HeaderValues = values.to_header_values()?.collect();
                 headers.append(&mut values);
             }
             None => {
-                self.insert(name, values)?;
+                self.insert(name, values);
             }
         }
         Ok(())
     }
 
     /// Get a reference to a header.
-    pub fn get(&self, name: &HeaderName) -> Option<&HeaderValues> {
-        self.headers.get(name)
+    pub fn get(&self, name: impl Into<HeaderName>) -> Option<&HeaderValues> {
+        self.headers.get(&name.into())
     }
 
     /// Get a mutable reference to a header.
-    pub fn get_mut(&mut self, name: &HeaderName) -> Option<&mut HeaderValues> {
-        self.headers.get_mut(name)
+    pub fn get_mut(&mut self, name: impl Into<HeaderName>) -> Option<&mut HeaderValues> {
+        self.headers.get_mut(&name.into())
     }
 
     /// Remove a header.
-    pub fn remove(&mut self, name: &HeaderName) -> Option<HeaderValues> {
-        self.headers.remove(name)
+    pub fn remove(&mut self, name: impl Into<HeaderName>) -> Option<HeaderValues> {
+        self.headers.remove(&name.into())
     }
 
     /// An iterator visiting all header pairs in arbitrary order.
@@ -123,7 +119,7 @@ impl Headers {
     }
 }
 
-impl Index<&HeaderName> for Headers {
+impl Index<HeaderName> for Headers {
     type Output = HeaderValues;
 
     /// Returns a reference to the value corresponding to the supplied name.
@@ -132,7 +128,7 @@ impl Index<&HeaderName> for Headers {
     ///
     /// Panics if the name is not present in `Headers`.
     #[inline]
-    fn index(&self, name: &HeaderName) -> &HeaderValues {
+    fn index(&self, name: HeaderName) -> &HeaderValues {
         self.get(name).expect("no entry found for name")
     }
 }
@@ -148,7 +144,7 @@ impl Index<&str> for Headers {
     #[inline]
     fn index(&self, name: &str) -> &HeaderValues {
         let name = HeaderName::from_str(name).expect("string slice needs to be valid ASCII");
-        self.get(&name).expect("no entry found for name")
+        self.get(name).expect("no entry found for name")
     }
 }
 
@@ -202,28 +198,18 @@ mod tests {
         headers.append(static_header.clone(), "foo1")?;
         headers.append(non_static_header.clone(), "foo2")?;
 
-        assert_eq!(
-            &headers.get(&STATIC_HEADER).unwrap()[..],
-            &["foo0", "foo1", "foo2",][..]
-        );
-
-        assert_eq!(
-            &headers.get(&static_header).unwrap()[..],
-            &["foo0", "foo1", "foo2",][..]
-        );
-
-        assert_eq!(
-            &headers.get(&non_static_header).unwrap()[..],
-            &["foo0", "foo1", "foo2",][..]
-        );
+        assert_eq!(headers[STATIC_HEADER], ["foo0", "foo1", "foo2",][..]);
+        assert_eq!(headers[static_header], ["foo0", "foo1", "foo2",][..]);
+        assert_eq!(headers[non_static_header], ["foo0", "foo1", "foo2",][..]);
 
         Ok(())
     }
 
     #[test]
     fn index_into_headers() {
         let mut headers = Headers::new();
-        headers.insert("hello", "foo0").unwrap();
+        headers.insert("hello", "foo0");
         assert_eq!(headers["hello"], "foo0");
+        assert_eq!(headers.get("hello").unwrap(), "foo0");
     }
 }

src/hyperium_http.rs

@@ -120,8 +120,7 @@ impl From<Request> for http::Request<Body> {
 impl From<http::Response<Body>> for Response {
     fn from(res: http::Response<Body>) -> Self {
         let (parts, body) = res.into_parts();
-        let status = parts.status.into();
-        let mut res = Response::new(status);
+        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());