Merge branch 'master' into headers_encoding

Author: joseluisq

.github/workflows/ci.yml

@@ -3,7 +3,7 @@ name: CI
 on: [push, pull_request]
 
 env:
-  minrust: 1.41.0
+  minrust: 1.46.0
 
 jobs:
   test:

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "headers"
-version = "0.3.4" # don't forget to update html_root_url
+version = "0.3.5" # don't forget to update html_root_url
 description = "typed HTTP headers"
 license = "MIT"
 readme = "README.md"
@@ -25,7 +25,7 @@ itertools = "0.9"
 bytes = "1"
 mime = "0.3.14"
 sha-1 = "0.9"
-time = "0.1.34"
+httpdate = "1"
 
 [features]
 nightly = []

src/common/access_control_allow_origin.rs

@@ -1,3 +1,5 @@
+use std::convert::TryFrom;
+
 use super::origin::Origin;
 use util::{IterExt, TryFromValues};
 use HeaderValue;
@@ -25,9 +27,11 @@ use HeaderValue;
 /// ```
 /// # extern crate headers;
 /// use headers::AccessControlAllowOrigin;
+/// use std::convert::TryFrom;
 ///
 /// let any_origin = AccessControlAllowOrigin::ANY;
 /// let null_origin = AccessControlAllowOrigin::NULL;
+/// let origin = AccessControlAllowOrigin::try_from("http://web-platform.test:8000");
 /// ```
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub struct AccessControlAllowOrigin(OriginOrAny);
@@ -60,6 +64,26 @@ impl AccessControlAllowOrigin {
     }
 }
 
+impl TryFrom<&str> for AccessControlAllowOrigin {
+    type Error = ::Error;
+
+    fn try_from(s: &str) -> Result<Self, ::Error> {
+        let header_value = HeaderValue::from_str(s).map_err(|_| ::Error::invalid())?;
+        let origin = OriginOrAny::try_from(&header_value)?;
+        Ok(Self(origin))
+    }
+}
+
+impl TryFrom<&HeaderValue> for OriginOrAny {
+    type Error = ::Error;
+
+    fn try_from(header_value: &HeaderValue) -> Result<Self, ::Error> {
+        Origin::try_from_value(header_value)
+            .map(OriginOrAny::Origin)
+            .ok_or_else(::Error::invalid)
+    }
+}
+
 impl TryFromValues for OriginOrAny {
     fn try_from_values<'i, I>(values: &mut I) -> Result<Self, ::Error>
     where
@@ -89,12 +113,14 @@ impl<'a> From<&'a OriginOrAny> for HeaderValue {
 
 #[cfg(test)]
 mod tests {
+
     use super::super::{test_decode, test_encode};
     use super::*;
 
     #[test]
     fn origin() {
         let s = "http://web-platform.test:8000";
+
         let allow_origin = test_decode::<AccessControlAllowOrigin>(&[s]).unwrap();
         {
             let origin = allow_origin.origin().unwrap();
@@ -107,6 +133,22 @@ mod tests {
         assert_eq!(headers["access-control-allow-origin"], s);
     }
 
+    #[test]
+    fn try_from_origin() {
+        let s = "http://web-platform.test:8000";
+
+        let allow_origin = AccessControlAllowOrigin::try_from(s).unwrap();
+        {
+            let origin = allow_origin.origin().unwrap();
+            assert_eq!(origin.scheme(), "http");
+            assert_eq!(origin.hostname(), "web-platform.test");
+            assert_eq!(origin.port(), Some(8000));
+        }
+
+        let headers = test_encode(allow_origin);
+        assert_eq!(headers["access-control-allow-origin"], s);
+    }
+
     #[test]
     fn any() {
         let allow_origin = test_decode::<AccessControlAllowOrigin>(&["*"]).unwrap();

src/common/origin.rs

@@ -1,5 +1,5 @@
-use std::fmt;
 use std::convert::TryFrom;
+use std::fmt;
 
 use bytes::Bytes;
 use http::uri::{self, Authority, Scheme, Uri};

src/lib.rs

@@ -2,7 +2,7 @@
 #![deny(missing_debug_implementations)]
 #![cfg_attr(test, deny(warnings))]
 #![cfg_attr(all(test, feature = "nightly"), feature(test))]
-#![doc(html_root_url = "https://docs.rs/headers/0.3.4")]
+#![doc(html_root_url = "https://docs.rs/headers/0.3.5")]
 
 //! # Typed HTTP Headers
 //!
@@ -78,12 +78,12 @@ extern crate bitflags;
 extern crate bytes;
 extern crate headers_core;
 extern crate http;
+extern crate httpdate;
 extern crate itertools;
 extern crate mime;
 extern crate sha1;
 #[cfg(all(test, feature = "nightly"))]
 extern crate test;
-extern crate time;
 
 pub use headers_core::{Error, Header};
 

src/util/http_date.rs

@@ -1,10 +1,10 @@
 use std::fmt;
 use std::str::FromStr;
-use std::time::{Duration, SystemTime, UNIX_EPOCH};
+use std::time::SystemTime;
 
 use bytes::Bytes;
 use http::header::HeaderValue;
-use time;
+use httpdate;
 
 use super::IterExt;
 
@@ -32,7 +32,7 @@ use super::IterExt;
 //   HTTP-date, the sender MUST generate those timestamps in the
 //   IMF-fixdate format.
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub(crate) struct HttpDate(time::Tm);
+pub(crate) struct HttpDate(httpdate::HttpDate);
 
 impl HttpDate {
     pub(crate) fn from_val(val: &HeaderValue) -> Option<Self> {
@@ -74,96 +74,74 @@ impl<'a> From<&'a HttpDate> for HeaderValue {
 impl FromStr for HttpDate {
     type Err = Error;
     fn from_str(s: &str) -> Result<HttpDate, Error> {
-        time::strptime(s, "%a, %d %b %Y %T %Z")
-            .or_else(|_| time::strptime(s, "%A, %d-%b-%y %T %Z"))
-            .or_else(|_| time::strptime(s, "%c"))
-            .map(HttpDate)
-            .map_err(|_| Error(()))
+        Ok(HttpDate(s.parse().map_err(|_| Error(()))?))
     }
 }
 
 impl fmt::Debug for HttpDate {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::Display::fmt(&self.0.to_utc().rfc822(), f)
+        fmt::Display::fmt(&self.0, f)
     }
 }
 
 impl fmt::Display for HttpDate {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::Display::fmt(&self.0.to_utc().rfc822(), f)
+        fmt::Display::fmt(&self.0, f)
     }
 }
 
 impl From<SystemTime> for HttpDate {
     fn from(sys: SystemTime) -> HttpDate {
-        let tmspec = match sys.duration_since(UNIX_EPOCH) {
-            Ok(dur) => {
-                // subsec nanos always dropped
-                time::Timespec::new(dur.as_secs() as i64, 0)
-            }
-            Err(err) => {
-                let neg = err.duration();
-                // subsec nanos always dropped
-                time::Timespec::new(-(neg.as_secs() as i64), 0)
-            }
-        };
-        HttpDate(time::at_utc(tmspec))
+        HttpDate(sys.into())
     }
 }
 
 impl From<HttpDate> for SystemTime {
     fn from(date: HttpDate) -> SystemTime {
-        let spec = date.0.to_timespec();
-        if spec.sec >= 0 {
-            UNIX_EPOCH + Duration::new(spec.sec as u64, spec.nsec as u32)
-        } else {
-            UNIX_EPOCH - Duration::new(spec.sec as u64, spec.nsec as u32)
-        }
+        SystemTime::from(date.0)
     }
 }
 
 #[cfg(test)]
 mod tests {
     use super::HttpDate;
-    use time::Tm;
-
-    const NOV_07: HttpDate = HttpDate(Tm {
-        tm_nsec: 0,
-        tm_sec: 37,
-        tm_min: 48,
-        tm_hour: 8,
-        tm_mday: 7,
-        tm_mon: 10,
-        tm_year: 94,
-        tm_wday: 0,
-        tm_isdst: 0,
-        tm_yday: 0,
-        tm_utcoff: 0,
-    });
+
+    use std::time::{Duration, UNIX_EPOCH};
+
+    // The old tests had Sunday, but 1994-11-07 is a Monday.
+    // See https://github.com/pyfisch/httpdate/pull/6#issuecomment-846881001
+    fn nov_07() -> HttpDate {
+        HttpDate((UNIX_EPOCH + Duration::new(784198117, 0)).into())
+    }
+
+    #[test]
+    fn test_display_is_imf_fixdate() {
+        assert_eq!("Mon, 07 Nov 1994 08:48:37 GMT", &nov_07().to_string());
+    }
 
     #[test]
     fn test_imf_fixdate() {
         assert_eq!(
-            "Sun, 07 Nov 1994 08:48:37 GMT".parse::<HttpDate>().unwrap(),
-            NOV_07
+            "Mon, 07 Nov 1994 08:48:37 GMT".parse::<HttpDate>().unwrap(),
+            nov_07()
         );
     }
 
     #[test]
     fn test_rfc_850() {
         assert_eq!(
-            "Sunday, 07-Nov-94 08:48:37 GMT"
+            "Monday, 07-Nov-94 08:48:37 GMT"
                 .parse::<HttpDate>()
                 .unwrap(),
-            NOV_07
+            nov_07()
         );
     }
 
     #[test]
     fn test_asctime() {
         assert_eq!(
-            "Sun Nov  7 08:48:37 1994".parse::<HttpDate>().unwrap(),
-            NOV_07
+            "Mon Nov  7 08:48:37 1994".parse::<HttpDate>().unwrap(),
+            nov_07()
         );
     }