add Header trait

src/header/common/if_modified_since.rs

@@ -0,0 +1,52 @@
+use http::header;
+
+use header::{Header, HttpDate, IntoHeaderValue};
+use error::ParseError;
+use httpmessage::HttpMessage;
+
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)]
+pub struct IfModifiedSince(pub HttpDate);
+
+impl Header for IfModifiedSince {
+    fn name() -> header::HeaderName {
+        header::IF_MODIFIED_SINCE
+    }
+    
+    fn parse<T: HttpMessage>(msg: &T) -> Result<Self, ParseError> {
+        let val = msg.headers().get(Self::name())
+            .ok_or(ParseError::Header)?.to_str().map_err(|_| ParseError::Header)?;
+        Ok(IfModifiedSince(val.parse()?))
+    }
+}
+
+impl IntoHeaderValue for IfModifiedSince {
+    type Error = header::InvalidHeaderValueBytes;
+
+    fn try_into(self) -> Result<header::HeaderValue, Self::Error> {
+        self.0.try_into()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use time::Tm;
+    use test::TestRequest;
+    use httpmessage::HttpMessage;
+    use super::HttpDate;
+    use super::IfModifiedSince;
+
+    fn date() -> 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}.into()
+    }
+
+    #[test]
+    fn test_if_mod_since() {
+        let req = TestRequest::with_hdr(IfModifiedSince(date())).finish();
+        let h = req.get::<IfModifiedSince>().unwrap();
+        assert_eq!(h.0, date());
+    }
+}

src/header/common/if_unmodified_since.rs

@@ -0,0 +1,52 @@
+use http::header;
+
+use header::{Header, HttpDate, IntoHeaderValue};
+use error::ParseError;
+use httpmessage::HttpMessage;
+
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)]
+pub struct IfUnmodifiedSince(pub HttpDate);
+
+impl Header for IfUnmodifiedSince {
+    fn name() -> header::HeaderName {
+        header::IF_MODIFIED_SINCE
+    }
+    
+    fn parse<T: HttpMessage>(msg: &T) -> Result<Self, ParseError> {
+        let val = msg.headers().get(Self::name())
+            .ok_or(ParseError::Header)?.to_str().map_err(|_| ParseError::Header)?;
+        Ok(IfUnmodifiedSince(val.parse()?))
+    }
+}
+
+impl IntoHeaderValue for IfUnmodifiedSince {
+    type Error = header::InvalidHeaderValueBytes;
+
+    fn try_into(self) -> Result<header::HeaderValue, Self::Error> {
+        self.0.try_into()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use time::Tm;
+    use test::TestRequest;
+    use httpmessage::HttpMessage;
+    use super::HttpDate;
+    use super::IfUnmodifiedSince;
+
+    fn date() -> 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}.into()
+    }
+
+    #[test]
+    fn test_if_mod_since() {
+        let req = TestRequest::with_hdr(IfUnmodifiedSince(date())).finish();
+        let h = req.get::<IfUnmodifiedSince>().unwrap();
+        assert_eq!(h.0, date());
+    }
+}

src/header/common/mod.rs

@@ -0,0 +1,5 @@
+mod if_modified_since;
+mod if_unmodified_since;
+
+pub use self::if_modified_since::IfModifiedSince;
+pub use self::if_unmodified_since::IfUnmodifiedSince;

src/header/httpdate.rs

@@ -0,0 +1,97 @@
+use std::fmt::{self, Display};
+use std::io::Write;
+use std::str::FromStr;
+use std::time::{Duration, SystemTime, UNIX_EPOCH};
+
+use time;
+use bytes::{BytesMut, BufMut};
+use http::header::{HeaderValue, InvalidHeaderValueBytes};
+
+use error::ParseError;
+use super::IntoHeaderValue;
+
+
+/// A timestamp with HTTP formatting and parsing
+#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)]
+pub struct HttpDate(time::Tm);
+
+impl FromStr for HttpDate {
+    type Err = ParseError;
+
+    fn from_str(s: &str) -> Result<HttpDate, ParseError> {
+        match 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")
+        }) {
+            Ok(t) => Ok(HttpDate(t)),
+            Err(_) => Err(ParseError::Header),
+        }
+    }
+}
+
+impl Display for HttpDate {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        fmt::Display::fmt(&self.0.to_utc().rfc822(), f)
+    }
+}
+
+impl From<time::Tm> for HttpDate {
+    fn from(tm: time::Tm) -> HttpDate {
+        HttpDate(tm)
+    }
+}
+
+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 IntoHeaderValue for HttpDate {
+    type Error = InvalidHeaderValueBytes;
+
+    fn try_into(self) -> Result<HeaderValue, Self::Error> {
+        let mut wrt = BytesMut::with_capacity(29).writer();
+        write!(wrt, "{}", self.0.rfc822()).unwrap();
+        unsafe{Ok(HeaderValue::from_shared_unchecked(wrt.get_mut().take().freeze()))}
+    }
+}
+
+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;
+    use super::HttpDate;
+
+    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});
+
+    #[test]
+    fn test_date() {
+        assert_eq!("Sun, 07 Nov 1994 08:48:37 GMT".parse::<HttpDate>().unwrap(), NOV_07);
+        assert_eq!("Sunday, 07-Nov-94 08:48:37 GMT".parse::<HttpDate>().unwrap(), NOV_07);
+        assert_eq!("Sun Nov  7 08:48:37 1994".parse::<HttpDate>().unwrap(), NOV_07);
+        assert!("this-is-no-date".parse::<HttpDate>().is_err());
+    }
+}

src/header/mod.rs

@@ -0,0 +1,135 @@
+//! Various http headers
+// A lot of code is inspired by hyper
+
+use bytes::Bytes;
+use http::{Error as HttpError};
+use http::header::{InvalidHeaderValue, InvalidHeaderValueBytes};
+
+pub use cookie::{Cookie, CookieBuilder};
+pub use http_range::HttpRange;
+pub use http::header::{HeaderName, HeaderValue};
+
+use error::ParseError;
+use httpmessage::HttpMessage;
+pub use httpresponse::ConnectionType;
+
+mod common;
+mod httpdate;
+pub use self::common::*;
+pub use self::httpdate::HttpDate;
+
+
+#[doc(hidden)]
+/// A trait for any object that will represent a header field and value.
+pub trait Header where Self: IntoHeaderValue {
+
+    /// Returns the name of the header field
+    fn name() -> HeaderName;
+
+    /// Parse a header
+    fn parse<T: HttpMessage>(msg: &T) -> Result<Self, ParseError>;
+}
+
+#[doc(hidden)]
+/// A trait for any object that can be Converted to a `HeaderValue`
+pub trait IntoHeaderValue: Sized {
+    /// The type returned in the event of a conversion error.
+    type Error: Into<HttpError>;
+
+    /// Cast from PyObject to a concrete Python object type.
+    fn try_into(self) -> Result<HeaderValue, Self::Error>;
+}
+
+impl IntoHeaderValue for HeaderValue {
+    type Error = InvalidHeaderValue;
+
+    #[inline]
+    fn try_into(self) -> Result<HeaderValue, Self::Error> {
+        Ok(self)
+    }
+}
+
+impl<'a> IntoHeaderValue for &'a str {
+    type Error = InvalidHeaderValue;
+
+    #[inline]
+    fn try_into(self) -> Result<HeaderValue, Self::Error> {
+        self.parse()
+    }
+}
+
+impl<'a> IntoHeaderValue for &'a [u8] {
+    type Error = InvalidHeaderValue;
+
+    #[inline]
+    fn try_into(self) -> Result<HeaderValue, Self::Error> {
+        HeaderValue::from_bytes(self)
+    }
+}
+
+impl IntoHeaderValue for Bytes {
+    type Error = InvalidHeaderValueBytes;
+
+    #[inline]
+    fn try_into(self) -> Result<HeaderValue, Self::Error> {
+        HeaderValue::from_shared(self)
+    }
+}
+
+/// Represents supported types of content encodings
+#[derive(Copy, Clone, PartialEq, Debug)]
+pub enum ContentEncoding {
+    /// Automatically select encoding based on encoding negotiation
+    Auto,
+    /// A format using the Brotli algorithm
+    Br,
+    /// A format using the zlib structure with deflate algorithm
+    Deflate,
+    /// Gzip algorithm
+    Gzip,
+    /// Indicates the identity function (i.e. no compression, nor modification)
+    Identity,
+}
+
+impl ContentEncoding {
+
+    #[inline]
+    pub fn is_compression(&self) -> bool {
+        match *self {
+            ContentEncoding::Identity | ContentEncoding::Auto => false,
+            _ => true
+        }
+    }
+
+    #[inline]
+    pub fn as_str(&self) -> &'static str {
+        match *self {
+            ContentEncoding::Br => "br",
+            ContentEncoding::Gzip => "gzip",
+            ContentEncoding::Deflate => "deflate",
+            ContentEncoding::Identity | ContentEncoding::Auto => "identity",
+        }
+    }
+    /// default quality value
+    pub fn quality(&self) -> f64 {
+        match *self {
+            ContentEncoding::Br => 1.1,
+            ContentEncoding::Gzip => 1.0,
+            ContentEncoding::Deflate => 0.9,
+            ContentEncoding::Identity | ContentEncoding::Auto => 0.1,
+        }
+    }
+}
+
+// TODO: remove memory allocation
+impl<'a> From<&'a str> for ContentEncoding {
+    fn from(s: &'a str) -> ContentEncoding {
+        match s.trim().to_lowercase().as_ref() {
+            "br" => ContentEncoding::Br,
+            "gzip" => ContentEncoding::Gzip,
+            "deflate" => ContentEncoding::Deflate,
+            "identity" => ContentEncoding::Identity,
+            _ => ContentEncoding::Auto,
+        }
+    }
+}