refactor: split the Header trait into three traits

headers-core/src/lib.rs

@@ -15,10 +15,36 @@ pub use http::header::{self, HeaderName, HeaderValue};
 use std::error;
 use std::fmt::{self, Display, Formatter};
 
+/// Associates a header name with a Rust type.
+pub trait Named {
+    /// The name of this header.
+    fn name() -> &'static HeaderName;
+}
+
+/// Decodes a header into a Rust type.
+pub trait Decodable: Named {
+    /// Decode this type from an iterator of `HeaderValue`s.
+    fn decode<'i, I>(values: &mut I) -> Result<Self, Error>
+    where
+        Self: Sized,
+        I: Iterator<Item = &'i HeaderValue>;
+}
+
+/// Encodes a header into a Rust type.
+pub trait Encodable: Named {
+    /// Encode this type to a `HeaderMap`.
+    ///
+    /// This function should be infallible. Any errors converting to a
+    /// `HeaderValue` should have been caught when parsing or constructing
+    /// this value.
+    fn encode<E: Extend<HeaderValue>>(&self, values: &mut E);
+}
+
 /// A trait for any object that will represent a header field and value.
 ///
 /// This trait represents the construction and identification of headers,
 /// and contains trait-object unsafe methods.
+#[deprecated]
 pub trait Header {
     /// The name of this header.
     fn name() -> &'static HeaderName;
@@ -37,6 +63,31 @@ pub trait Header {
     fn encode<E: Extend<HeaderValue>>(&self, values: &mut E);
 }
 
+#[allow(deprecated)]
+impl<T: Header> Named for T {
+    fn name() -> &'static HeaderName {
+        T::name()
+    }
+}
+
+#[allow(deprecated)]
+impl<T: Header> Decodable for T {
+    fn decode<'i, I>(values: &mut I) -> Result<Self, Error>
+    where
+        Self: Sized,
+        I: Iterator<Item = &'i HeaderValue>,
+    {
+        T::decode(values)
+    }
+}
+
+#[allow(deprecated)]
+impl<T: Header> Encodable for T {
+    fn encode<E: Extend<HeaderValue>>(&self, values: &mut E) {
+        self.encode(values)
+    }
+}
+
 /// Errors trying to decode a header.
 #[derive(Debug)]
 pub struct Error {

src/common/access_control_allow_credentials.rs

@@ -1,4 +1,5 @@
-use {Header, HeaderName, HeaderValue};
+use crate::core::{Decodable, Encodable, Named};
+use crate::{HeaderName, HeaderValue};
 
 /// `Access-Control-Allow-Credentials` header, part of
 /// [CORS](http://www.w3.org/TR/cors/#access-control-allow-headers-response-header)
@@ -33,11 +34,13 @@ use {Header, HeaderName, HeaderValue};
 #[derive(Clone, PartialEq, Eq, Debug)]
 pub struct AccessControlAllowCredentials;
 
-impl Header for AccessControlAllowCredentials {
+impl Named for AccessControlAllowCredentials {
     fn name() -> &'static HeaderName {
         &::http::header::ACCESS_CONTROL_ALLOW_CREDENTIALS
     }
+}
 
+impl Decodable for AccessControlAllowCredentials {
     fn decode<'i, I: Iterator<Item = &'i HeaderValue>>(values: &mut I) -> Result<Self, ::Error> {
         values
             .next()
@@ -50,7 +53,9 @@ impl Header for AccessControlAllowCredentials {
             })
             .ok_or_else(::Error::invalid)
     }
+}
 
+impl Encodable for AccessControlAllowCredentials {
     fn encode<E: Extend<::HeaderValue>>(&self, values: &mut E) {
         values.extend(::std::iter::once(HeaderValue::from_static("true")));
     }

src/common/access_control_request_method.rs

@@ -1,5 +1,7 @@
+use crate::core::{Decodable, Encodable, Named};
+use crate::{HeaderName, HeaderValue};
+
 use http::Method;
-use {Header, HeaderName, HeaderValue};
 
 /// `Access-Control-Request-Method` header, part of
 /// [CORS](http://www.w3.org/TR/cors/#access-control-request-method-request-header)
@@ -28,19 +30,23 @@ use {Header, HeaderName, HeaderValue};
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub struct AccessControlRequestMethod(Method);
 
-impl Header for AccessControlRequestMethod {
+impl Named for AccessControlRequestMethod {
     fn name() -> &'static HeaderName {
         &::http::header::ACCESS_CONTROL_REQUEST_METHOD
     }
+}
 
+impl Decodable for AccessControlRequestMethod {
     fn decode<'i, I: Iterator<Item = &'i HeaderValue>>(values: &mut I) -> Result<Self, ::Error> {
         values
             .next()
             .and_then(|value| Method::from_bytes(value.as_bytes()).ok())
             .map(AccessControlRequestMethod)
             .ok_or_else(::Error::invalid)
     }
+}
 
+impl Encodable for AccessControlRequestMethod {
     fn encode<E: Extend<::HeaderValue>>(&self, values: &mut E) {
         // For the more common methods, try to use a static string.
         let s = match self.0 {

src/common/authorization.rs

@@ -1,5 +1,7 @@
 //! Authorization header and types.
 
+use crate::core::{Decodable, Encodable, Named};
+
 use base64;
 use bytes::Bytes;
 
@@ -71,11 +73,13 @@ impl Authorization<Bearer> {
     }
 }
 
-impl<C: Credentials> ::Header for Authorization<C> {
+impl<C: Credentials> Named for Authorization<C> {
     fn name() -> &'static ::HeaderName {
         &::http::header::AUTHORIZATION
     }
+}
 
+impl<C: Credentials> Decodable for Authorization<C> {
     fn decode<'i, I: Iterator<Item = &'i HeaderValue>>(values: &mut I) -> Result<Self, ::Error> {
         values
             .next()
@@ -92,7 +96,9 @@ impl<C: Credentials> ::Header for Authorization<C> {
             })
             .ok_or_else(::Error::invalid)
     }
+}
 
+impl<C: Credentials> Encodable for Authorization<C> {
     fn encode<E: Extend<::HeaderValue>>(&self, values: &mut E) {
         let value = self.0.encode();
         debug_assert!(
@@ -171,7 +177,8 @@ impl Credentials for Basic {
         base64::encode_config_buf(&self.decoded, base64::STANDARD, &mut encoded);
 
         let bytes = Bytes::from(encoded);
-        HeaderValue::from_maybe_shared(bytes).expect("base64 encoding is always a valid HeaderValue")
+        HeaderValue::from_maybe_shared(bytes)
+            .expect("base64 encoding is always a valid HeaderValue")
     }
 }
 

src/common/cache_control.rs

@@ -3,6 +3,8 @@ use std::iter::FromIterator;
 use std::str::FromStr;
 use std::time::Duration;
 
+use crate::core::{Decodable, Encodable, Named};
+
 use util::{self, csv, Seconds};
 use HeaderValue;
 
@@ -183,15 +185,19 @@ impl CacheControl {
     }
 }
 
-impl ::Header for CacheControl {
+impl Named for CacheControl {
     fn name() -> &'static ::HeaderName {
         &::http::header::CACHE_CONTROL
     }
+}
 
+impl Decodable for CacheControl {
     fn decode<'i, I: Iterator<Item = &'i HeaderValue>>(values: &mut I) -> Result<Self, ::Error> {
         csv::from_comma_delimited(values).map(|FromIter(cc)| cc)
     }
+}
 
+impl Encodable for CacheControl {
     fn encode<E: Extend<::HeaderValue>>(&self, values: &mut E) {
         values.extend(::std::iter::once(util::fmt(Fmt(self))));
     }

src/common/content_disposition.rs

@@ -6,6 +6,8 @@
 // Browser conformance tests at: http://greenbytes.de/tech/tc2231/
 // IANA assignment: http://www.iana.org/assignments/cont-disp/cont-disp.xhtml
 
+use crate::core::{Decodable, Encodable, Named};
+
 /// A `Content-Disposition` header, (re)defined in [RFC6266](https://tools.ietf.org/html/rfc6266).
 ///
 /// The Content-Disposition response header field is used to convey
@@ -89,11 +91,13 @@ impl ContentDisposition {
     }
 }
 
-impl ::Header for ContentDisposition {
+impl Named for ContentDisposition {
     fn name() -> &'static ::HeaderName {
         &::http::header::CONTENT_DISPOSITION
     }
+}
 
+impl Decodable for ContentDisposition {
     fn decode<'i, I: Iterator<Item = &'i ::HeaderValue>>(values: &mut I) -> Result<Self, ::Error> {
         //TODO: parse harder
         values
@@ -102,7 +106,9 @@ impl ::Header for ContentDisposition {
             .map(ContentDisposition)
             .ok_or_else(::Error::invalid)
     }
+}
 
+impl Encodable for ContentDisposition {
     fn encode<E: Extend<::HeaderValue>>(&self, values: &mut E) {
         values.extend(::std::iter::once(self.0.clone()));
     }

src/common/content_length.rs

@@ -1,4 +1,5 @@
-use {Header, HeaderValue};
+use crate::core::{Decodable, Encodable, Named};
+use crate::HeaderValue;
 
 /// `Content-Length` header, defined in
 /// [RFC7230](http://tools.ietf.org/html/rfc7230#section-3.3.2)
@@ -40,11 +41,13 @@ use {Header, HeaderValue};
 #[derive(Clone, Copy, Debug, PartialEq)]
 pub struct ContentLength(pub u64);
 
-impl Header for ContentLength {
+impl Named for ContentLength {
     fn name() -> &'static ::http::header::HeaderName {
         &::http::header::CONTENT_LENGTH
     }
+}
 
+impl Decodable for ContentLength {
     fn decode<'i, I: Iterator<Item = &'i HeaderValue>>(values: &mut I) -> Result<Self, ::Error> {
         // If multiple Content-Length headers were sent, everything can still
         // be alright if they all contain the same value, and all parse
@@ -68,7 +71,9 @@ impl Header for ContentLength {
 
         len.map(ContentLength).ok_or_else(::Error::invalid)
     }
+}
 
+impl Encodable for ContentLength {
     fn encode<E: Extend<::HeaderValue>>(&self, values: &mut E) {
         values.extend(::std::iter::once(self.0.into()));
     }

src/common/content_range.rs

@@ -1,7 +1,8 @@
 use std::fmt;
 use std::ops::{Bound, RangeBounds};
 
-use {util, HeaderValue};
+use crate::core::{Decodable, Encodable, Named};
+use crate::{util, HeaderValue};
 
 /// Content-Range, described in [RFC7233](https://tools.ietf.org/html/rfc7233#section-4.2)
 ///
@@ -98,11 +99,13 @@ impl ContentRange {
     }
 }
 
-impl ::Header for ContentRange {
+impl Named for ContentRange {
     fn name() -> &'static ::HeaderName {
         &::http::header::CONTENT_RANGE
     }
+}
 
+impl Decodable for ContentRange {
     fn decode<'i, I: Iterator<Item = &'i HeaderValue>>(values: &mut I) -> Result<Self, ::Error> {
         values
             .next()
@@ -141,7 +144,9 @@ impl ::Header for ContentRange {
             })
             .ok_or_else(::Error::invalid)
     }
+}
 
+impl Encodable for ContentRange {
     fn encode<E: Extend<::HeaderValue>>(&self, values: &mut E) {
         struct Adapter<'a>(&'a ContentRange);
 
@@ -178,22 +183,23 @@ fn split_in_two(s: &str, separator: char) -> Option<(&str, &str)> {
 }
 
 /*
-        test_header!(test_bytes,
-            vec![b"bytes 0-499/500"],
-            Some(ContentRange(ContentRangeSpec::Bytes {
-                range: Some((0, 499)),
-                complete_length: Some(500)
-            })));
-
-        test_header!(test_bytes_unknown_len,
-            vec![b"bytes 0-499/*"],
-            Some(ContentRange(ContentRangeSpec::Bytes {
-                range: Some((0, 499)),
-                complete_length: None
-            })));
-
-        test_header!(test_bytes_unknown_range,
-            vec![b"bytes */500"],
+test_header!(test_bytes,
+    vec![b"bytes 0-499/500"],
+    Some(ContentRange(ContentRangeSpec::Bytes {
+        range: Some((0, 499)),
+        complete_length: Some(500)
+    })));
+
+test_header!(test_bytes_unknown_len,
+    vec![b"bytes 0-499/*"],
+    Some(ContentRange(ContentRangeSpec::Bytes {
+        range: Some((0, 499)),
+        complete_length: None
+    })));
+
+test_header!(test_bytes_unknown_range,
+    vec![b"bytes */
+500"],
             Some(ContentRange(ContentRangeSpec::Bytes {
                 range: None,
                 complete_length: Some(500)

src/common/content_type.rs

@@ -1,5 +1,7 @@
 use std::fmt;
 
+use crate::core::{Decodable, Encodable, Named};
+
 use mime::{self, Mime};
 
 /// `Content-Type` header, defined in
@@ -94,19 +96,23 @@ impl ContentType {
     }
 }
 
-impl ::Header for ContentType {
+impl Named for ContentType {
     fn name() -> &'static ::HeaderName {
         &::http::header::CONTENT_TYPE
     }
+}
 
+impl Decodable for ContentType {
     fn decode<'i, I: Iterator<Item = &'i ::HeaderValue>>(values: &mut I) -> Result<Self, ::Error> {
         values
             .next()
             .and_then(|v| v.to_str().ok()?.parse().ok())
             .map(ContentType)
             .ok_or_else(::Error::invalid)
     }
+}
 
+impl Encodable for ContentType {
     fn encode<E: Extend<::HeaderValue>>(&self, values: &mut E) {
         let value = self
             .0