Merge branch 'master' into headers_encoding

Author: joseluisq

Cargo.toml

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

src/common/age.rs

@@ -0,0 +1,69 @@
+use std::time::Duration;
+
+use util::Seconds;
+
+/// `Age` header, defined in [RFC7234](https://tools.ietf.org/html/rfc7234#section-5.1)
+///
+/// The "Age" header field conveys the sender's estimate of the amount of
+/// time since the response was generated or successfully validated at
+/// the origin server.  Age values are calculated as specified in
+/// [Section 4.2.3](https://tools.ietf.org/html/rfc7234#section-4.2.3).
+///
+/// ## ABNF
+///
+/// ```text
+/// Age = delta-seconds
+/// ```
+///
+/// The Age field-value is a non-negative integer, representing time in
+/// seconds (see [Section 1.2.1](https://tools.ietf.org/html/rfc7234#section-1.2.1)).
+///
+/// The presence of an Age header field implies that the response was not
+/// generated or validated by the origin server for this request.
+/// However, lack of an Age header field does not imply the origin was
+/// contacted, since the response might have been received from an
+/// HTTP/1.0 cache that does not implement Age.
+///
+/// ## Example values
+///
+/// * `3600`
+///
+/// # Example
+///
+/// ```
+/// # extern crate headers;
+/// use headers::Age;
+///
+/// let len = Age::from_secs(60);
+/// ```
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct Age(Seconds);
+
+derive_header! {
+  Age(_),
+  name: AGE
+}
+
+impl Age {
+    /// Creates a new `Age` header from the specified number of whole seconds.
+    pub fn from_secs(secs: u64) -> Self {
+        Self(Seconds::from_secs(secs))
+    }
+
+    /// Returns the number of seconds for this `Age` header.
+    pub fn as_secs(&self) -> u64 {
+        self.0.as_u64()
+    }
+}
+
+impl From<Duration> for Age {
+    fn from(dur: Duration) -> Self {
+        Age(Seconds::from(dur))
+    }
+}
+
+impl From<Age> for Duration {
+    fn from(age: Age) -> Self {
+        age.0.into()
+    }
+}

src/common/authorization.rs

@@ -45,6 +45,16 @@ impl Authorization<Basic> {
 
         Authorization(Basic { decoded, colon_pos })
     }
+
+    /// View the decoded username.
+    pub fn username(&self) -> &str {
+        self.0.username()
+    }
+
+    /// View the decoded password.
+    pub fn password(&self) -> &str {
+        self.0.password()
+    }
 }
 
 impl Authorization<Bearer> {
@@ -54,6 +64,11 @@ impl Authorization<Bearer> {
             .map(|val| Authorization(Bearer(val)))
             .ok_or_else(|| InvalidBearerToken { _inner: () })
     }
+
+    /// View the token part as a `&str`.
+    pub fn token(&self) -> &str {
+        self.0.token()
+    }
 }
 
 impl<C: Credentials> ::Header for Authorization<C> {

src/common/mod.rs

@@ -19,6 +19,7 @@ pub use self::access_control_expose_headers::AccessControlExposeHeaders;
 pub use self::access_control_max_age::AccessControlMaxAge;
 pub use self::access_control_request_headers::AccessControlRequestHeaders;
 pub use self::access_control_request_method::AccessControlRequestMethod;
+pub use self::age::Age;
 pub use self::allow::Allow;
 pub use self::authorization::Authorization;
 pub use self::cache_control::CacheControl;
@@ -139,6 +140,7 @@ mod access_control_expose_headers;
 mod access_control_max_age;
 mod access_control_request_headers;
 mod access_control_request_method;
+mod age;
 mod allow;
 pub mod authorization;
 mod cache_control;

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.5")]
+#![doc(html_root_url = "https://docs.rs/headers/0.3.7")]
 
 //! # Typed HTTP Headers
 //!

src/util/seconds.rs

@@ -11,7 +11,11 @@ impl Seconds {
     pub(crate) fn from_val(val: &HeaderValue) -> Option<Self> {
         let secs = val.to_str().ok()?.parse().ok()?;
 
-        Some(Seconds(Duration::from_secs(secs)))
+        Some(Self::from_secs(secs))
+    }
+
+    pub(crate) fn from_secs(secs: u64) -> Self {
+        Self::from(Duration::from_secs(secs))
     }
 
     pub(crate) fn as_u64(&self) -> u64 {