refactor(header): change HttpDate to opaque over SystemTime

This removes the need for someone to use the `time` crate to create a
date compatible with HTTP headers. It now works with the `SystemTime`
type from the standard library.

BREAKING CHANGE: `HttpDate` no longer has public fields. Convert between
  `HttpDate` and `SystemTime` as needed.

src/header/common/date.rs

@@ -16,17 +16,11 @@ header! {
     ///
     /// # Example
     /// ```
-    /// # extern crate time;
+    /// use hyper::header::{Headers, Date};
-    /// # extern crate hyper;
+    /// use std::time::SystemTime;
-    /// # fn main() {
-    /// // extern crate time;
-    /// 
-    /// use hyper::header::{Headers, Date, HttpDate};
-    /// use time;
     ///
     /// let mut headers = Headers::new();
-    /// headers.set(Date(HttpDate(time::now())));
+    /// headers.set(Date(SystemTime::now().into()));
-    /// # }
     /// ```
     (Date, "Date") => [HttpDate]
 

src/header/common/expires.rs

@@ -20,17 +20,12 @@ header! {
     ///
     /// # Example
     /// ```
-    /// # extern crate hyper;
+    /// use hyper::header::{Headers, Expires};
-    /// # extern crate time;
+    /// use std::time::{SystemTime, Duration};
-    /// # fn main() {
-    /// // extern crate time;
-    /// 
-    /// use hyper::header::{Headers, Expires, HttpDate};
-    /// use time::{self, Duration};
     ///
     /// let mut headers = Headers::new();
-    /// headers.set(Expires(HttpDate(time::now() + Duration::days(1))));
+    /// let expiration = SystemTime::now() + Duration::from_secs(60 * 60 * 24);
-    /// # }
+    /// headers.set(Expires(expiration.into()));
     /// ```
     (Expires, "Expires") => [HttpDate]
 

src/header/common/if_modified_since.rs

@@ -20,17 +20,12 @@ header! {
     ///
     /// # Example
     /// ```
-    /// # extern crate hyper;
+    /// use hyper::header::{Headers, IfModifiedSince};
-    /// # extern crate time;
+    /// use std::time::{SystemTime, Duration};
-    /// # fn main() {
-    /// // extern crate time;
-    /// 
-    /// use hyper::header::{Headers, IfModifiedSince, HttpDate};
-    /// use time::{self, Duration};
     ///
     /// let mut headers = Headers::new();
-    /// headers.set(IfModifiedSince(HttpDate(time::now() - Duration::days(1))));
+    /// let modified = SystemTime::now() - Duration::from_secs(60 * 60 * 24);
-    /// # }
+    /// headers.set(IfModifiedSince(modified.into()));
     /// ```
     (IfModifiedSince, "If-Modified-Since") => [HttpDate]
 

src/header/common/if_range.rs

@@ -33,17 +33,12 @@ use header::{self, Header, Raw, EntityTag, HttpDate};
 /// headers.set(IfRange::EntityTag(EntityTag::new(false, "xyzzy".to_owned())));
 /// ```
 /// ```
-/// # extern crate hyper;
+/// use hyper::header::{Headers, IfRange};
-/// # extern crate time;
+/// use std::time::{SystemTime, Duration};
-/// # fn main() {
-/// // extern crate time;
-///
-/// use hyper::header::{Headers, IfRange, HttpDate};
-/// use time::{self, Duration};
 ///
 /// let mut headers = Headers::new();
-/// headers.set(IfRange::Date(HttpDate(time::now() - Duration::days(1))));
+/// let fetched = SystemTime::now() - Duration::from_secs(60 * 60 * 24);
-/// # }
+/// headers.set(IfRange::Date(fetched.into()));
 /// ```
 #[derive(Clone, Debug, PartialEq)]
 pub enum IfRange {

src/header/common/if_unmodified_since.rs

@@ -20,17 +20,12 @@ header! {
     ///
     /// # Example
     /// ```
-    /// # extern crate hyper;
+    /// use hyper::header::{Headers, IfUnmodifiedSince};
-    /// # extern crate time;
+    /// use std::time::{SystemTime, Duration};
-    /// # fn main() {
-    /// // extern crate time;
-    /// 
-    /// use hyper::header::{Headers, IfUnmodifiedSince, HttpDate};
-    /// use time::{self, Duration};
     ///
     /// let mut headers = Headers::new();
-    /// headers.set(IfUnmodifiedSince(HttpDate(time::now() - Duration::days(1))));
+    /// let modified = SystemTime::now() - Duration::from_secs(60 * 60 * 24);
-    /// # }
+    /// headers.set(IfUnmodifiedSince(modified.into()));
     /// ```
     (IfUnmodifiedSince, "If-Unmodified-Since") => [HttpDate]
 

src/header/common/last_modified.rs

@@ -19,17 +19,12 @@ header! {
     ///
     /// # Example
     /// ```
-    /// # extern crate hyper;
+    /// use hyper::header::{Headers, LastModified};
-    /// # extern crate time;
+    /// use std::time::{SystemTime, Duration};
-    /// # fn main() {
-    /// // extern crate time;
-    /// 
-    /// use hyper::header::{Headers, LastModified, HttpDate};
-    /// use time::{self, Duration};
     ///
     /// let mut headers = Headers::new();
-    /// headers.set(LastModified(HttpDate(time::now() - Duration::days(1))));
+    /// let modified = SystemTime::now() - Duration::from_secs(60 * 60 * 24);
-    /// # }
+    /// headers.set(LastModified(modified.into()));
     /// ```
     (LastModified, "Last-Modified") => [HttpDate]
 

src/header/common/retry_after.rs

@@ -35,11 +35,11 @@
 // Version 2.0, January 2004
 // http://www.apache.org/licenses/
 
+use std::fmt;
+use std::time::Duration;
+
 use header::{Header, Raw};
 use header::shared::HttpDate;
-use time;
-use time::{Duration, Tm};
-use std::fmt;
 
 /// The `Retry-After` header.
 ///
@@ -53,33 +53,23 @@ use std::fmt;
 ///
 /// # Examples
 /// ```
-/// # extern crate hyper;
+/// use std::time::Duration;
-/// # extern crate time;
-/// # fn main() {
-/// // extern crate time;
-/// use time::{Duration};
 /// use hyper::header::{Headers, RetryAfter};
 ///
 /// let mut headers = Headers::new();
 /// headers.set(
-///     RetryAfter::Delay(Duration::seconds(300))
+///     RetryAfter::Delay(Duration::from_secs(300))
 /// );
-/// # }
 /// ```
 /// ```
-/// # extern crate hyper;
+/// use std::time::{SystemTime, Duration};
-/// # extern crate time;
-/// # fn main() {
-/// // extern crate time;
-/// use time;
-/// use time::{Duration};
 /// use hyper::header::{Headers, RetryAfter};
 ///
 /// let mut headers = Headers::new();
+/// let date = SystemTime::now() + Duration::from_secs(300);
 /// headers.set(
-///     RetryAfter::DateTime(time::now_utc() + Duration::seconds(300))
+///     RetryAfter::DateTime(date.into())
 /// );
-/// # }
 /// ```
 
 /// Retry-After header, defined in [RFC7231](http://tools.ietf.org/html/rfc7231#section-7.1.3)
@@ -91,7 +81,7 @@ pub enum RetryAfter {
     Delay(Duration),
 
     /// Retry after the given DateTime
-    DateTime(Tm),
+    DateTime(HttpDate),
 }
 
 impl Header for RetryAfter {
@@ -108,11 +98,11 @@ impl Header for RetryAfter {
             };
 
             if let Ok(datetime) = utf8_str.parse::<HttpDate>() {
-                return Ok(RetryAfter::DateTime(datetime.0))
+                return Ok(RetryAfter::DateTime(datetime))
             }
 
-            if let Ok(seconds) = utf8_str.parse::<i64>() {
+            if let Ok(seconds) = utf8_str.parse::<u64>() {
-                return Ok(RetryAfter::Delay(Duration::seconds(seconds)));
+                return Ok(RetryAfter::Delay(Duration::from_secs(seconds)));
             }
 
             Err(::Error::Header)
@@ -130,16 +120,10 @@ impl fmt::Display for RetryAfter {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {
             RetryAfter::Delay(ref duration) => {
-                write!(f, "{}", duration.num_seconds())
+                write!(f, "{}", duration.as_secs())
             },
             RetryAfter::DateTime(ref datetime) => {
-                // According to RFC7231, the sender of an HTTP-date must use the RFC1123 format.
+                fmt::Display::fmt(datetime, f)
-                // http://tools.ietf.org/html/rfc7231#section-7.1.1.1
-                if let Ok(date_string) = time::strftime("%a, %d %b %Y %T GMT", datetime) {
-                    write!(f, "{}", date_string)
-                } else {
-                    Err(fmt::Error::default())
-                }
             }
         }
     }
@@ -147,9 +131,9 @@ impl fmt::Display for RetryAfter {
 
 #[cfg(test)]
 mod tests {
+    use std::time::Duration;
     use header::Header;
     use header::shared::HttpDate;
-    use time::{Duration};
 
     use super::RetryAfter;
 
@@ -162,7 +146,7 @@ mod tests {
     fn parse_delay() {
         let retry_after = RetryAfter::parse_header(&vec![b"1234".to_vec()].into()).unwrap();
 
-        assert_eq!(RetryAfter::Delay(Duration::seconds(1234)), retry_after);
+        assert_eq!(RetryAfter::Delay(Duration::from_secs(1234)), retry_after);
     }
 
     macro_rules! test_retry_after_datetime {
@@ -172,7 +156,7 @@ mod tests {
                 let dt = "Sun, 06 Nov 1994 08:49:37 GMT".parse::<HttpDate>().unwrap();
                 let retry_after = RetryAfter::parse_header(&vec![$bytes.to_vec()].into()).expect("parse_header ok");
 
-                assert_eq!(RetryAfter::DateTime(dt.0), retry_after);
+                assert_eq!(RetryAfter::DateTime(dt), retry_after);
             }
         }
     }
@@ -184,7 +168,7 @@ mod tests {
     #[test]
     fn hyper_headers_from_raw_delay() {
         let retry_after = RetryAfter::parse_header(&b"300".to_vec().into()).unwrap();
-        assert_eq!(retry_after, RetryAfter::Delay(Duration::seconds(300)));
+        assert_eq!(retry_after, RetryAfter::Delay(Duration::from_secs(300)));
     }
 
     #[test]
@@ -192,6 +176,6 @@ mod tests {
         let retry_after = RetryAfter::parse_header(&b"Sun, 06 Nov 1994 08:49:37 GMT".to_vec().into()).unwrap();
         let expected = "Sun, 06 Nov 1994 08:49:37 GMT".parse::<HttpDate>().unwrap();
 
-        assert_eq!(retry_after, RetryAfter::DateTime(expected.0));
+        assert_eq!(retry_after, RetryAfter::DateTime(expected));
     }
 }

src/header/common/warning.rs

@@ -58,10 +58,8 @@ use header::parsing::from_one_raw_str;
 /// );
 /// ```
 /// ```
-/// # extern crate hyper;
+/// use std::time::SystemTime;
-/// # extern crate time;
+/// use hyper::header::{Headers, Warning};
-/// # fn main() {
-/// use hyper::header::{Headers, HttpDate, Warning};
 ///
 /// let mut headers = Headers::new();
 /// headers.set(
@@ -69,10 +67,9 @@ use header::parsing::from_one_raw_str;
 ///         code: 199,
 ///         agent: "api.hyper.rs".to_owned(),
 ///         text: "Deprecated".to_owned(),
-///         date: Some(HttpDate(time::now()))
+///         date: Some(SystemTime::now().into())
 ///     }
 /// );
-/// # }
 /// ```
 #[derive(PartialEq, Clone, Debug)]
 pub struct Warning {

src/header/shared/httpdate.rs

@@ -1,10 +1,10 @@
-use std::str::FromStr;
 use std::fmt::{self, Display};
+use std::str::FromStr;
+use std::time::{Duration, SystemTime, UNIX_EPOCH};
 
 use time;
 
-/// A `time::Time` with HTTP formatting and parsing
+/// A timestamp with HTTP formatting and parsing
-///
 //   Prior to 1995, there were three different formats commonly used by
 //   servers to communicate timestamps.  For compatibility with old
 //   implementations, all three are defined here.  The preferred format is
@@ -28,7 +28,7 @@ use time;
 //   HTTP-date, the sender MUST generate those timestamps in the
 //   IMF-fixdate format.
 #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)]
-pub struct HttpDate(pub time::Tm);
+pub struct HttpDate(time::Tm);
 
 impl FromStr for HttpDate {
     type Err = ::Error;
@@ -50,6 +50,32 @@ impl Display for HttpDate {
     }
 }
 
+impl From<SystemTime> for HttpDate {
+    fn from(sys: SystemTime) -> HttpDate {
+        let tmspec = match sys.duration_since(UNIX_EPOCH) {
+            Ok(dur) => {
+                time::Timespec::new(dur.as_secs() as i64, dur.subsec_nanos() as i32)
+            },
+            Err(err) => {
+                let neg = err.duration();
+                time::Timespec::new(-(neg.as_secs() as i64), -(neg.subsec_nanos() as i32))
+            },
+        };
+        HttpDate(time::at_utc(tmspec))
+    }
+}
+
+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)
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use time::Tm;

src/http/h1/parse.rs

@@ -1,5 +1,6 @@
 use std::borrow::Cow;
 use std::fmt::{self, Write};
+use std::time::SystemTime;
 
 use httparse;
 use bytes::{BytesMut, Bytes};
@@ -94,7 +95,7 @@ impl Http1Transaction for ServerTransaction {
         trace!("writing head: {:?}", head);
 
         if !head.headers.has::<header::Date>() {
-            head.headers.set(header::Date(header::HttpDate(::time::now_utc())));
+            head.headers.set(header::Date(SystemTime::now().into()));
         }
 
         let mut is_chunked = true;