Re-add the Accept header

Author: Markus Westerlind

src/common/accept.rs

@@ -0,0 +1,143 @@
+use http::HttpTryFrom;
+
+use mime::{self, Mime};
+
+use util::QualityValue;
+
+fn qitem(mime: Mime) -> QualityValue<Mime> {
+    QualityValue::new(mime, Default::default())
+}
+
+/// `Accept` header, defined in [RFC7231](http://tools.ietf.org/html/rfc7231#section-5.3.2)
+///
+/// The `Accept` header field can be used by user agents to specify
+/// response media types that are acceptable.  Accept header fields can
+/// be used to indicate that the request is specifically limited to a
+/// small set of desired types, as in the case of a request for an
+/// in-line image
+///
+/// # ABNF
+///
+/// ```text
+/// Accept = #( media-range [ accept-params ] )
+///
+/// media-range    = ( "*/*"
+///                  / ( type "/" "*" )
+///                  / ( type "/" subtype )
+///                  ) *( OWS ";" OWS parameter )
+/// accept-params  = weight *( accept-ext )
+/// accept-ext = OWS ";" OWS token [ "=" ( token / quoted-string ) ]
+/// ```
+///
+/// # Example values
+/// * `audio/*; q=0.2, audio/basic`
+/// * `text/plain; q=0.5, text/html, text/x-dvi; q=0.8, text/x-c`
+///
+/// # Examples
+/// ```
+/// # extern crate headers;
+/// extern crate mime;
+/// extern crate http;
+/// use headers::{Accept, QualityValue, HeaderMapExt};
+///
+/// let mut headers = http::HeaderMap::new();
+///
+/// headers.typed_insert(
+///     Accept(vec![
+///         QualityValue::new(mime::TEXT_HTML, Default::default()),
+///     ])
+/// );
+/// ```
+///
+/// ```
+/// # extern crate headers;
+/// extern crate mime;
+/// use headers::{Accept, QualityValue, HeaderMapExt};
+///
+/// let mut headers = http::HeaderMap::new();
+/// headers.typed_insert(
+///     Accept(vec![
+///         QualityValue::new(mime::APPLICATION_JSON, Default::default()),
+///     ])
+/// );
+/// ```
+/// ```
+/// # extern crate headers;
+/// extern crate mime;
+/// use headers::{Accept, QualityValue, HeaderMapExt};
+///
+/// let mut headers = http::HeaderMap::new();
+///
+/// headers.typed_insert(
+///     Accept(vec![
+///         QualityValue::from(mime::TEXT_HTML),
+///         QualityValue::from("application/xhtml+xml".parse::<mime::Mime>().unwrap()),
+///         QualityValue::new(
+///             mime::TEXT_XML,
+///             900.into()
+///         ),
+///         QualityValue::from("image/webp".parse::<mime::Mime>().unwrap()),
+///         QualityValue::new(
+///             mime::STAR_STAR,
+///             800.into()
+///         ),
+///     ])
+/// );
+/// ```
+#[derive(Debug)]
+pub struct Accept(pub Vec<QualityValue<Mime>>);
+
+impl ::Header for Accept {
+    fn name() -> &'static ::HeaderName {
+        &::http::header::ACCEPT
+    }
+
+    fn decode<'i, I: Iterator<Item = &'i ::HeaderValue>>(values: &mut I) -> Result<Self, ::Error> {
+        ::util::csv::from_comma_delimited(values).map(Accept)
+    }
+
+    fn encode<E: Extend<::HeaderValue>>(&self, values: &mut E) {
+        use std::fmt;
+        struct Format<F>(F);
+        impl<F> fmt::Display for Format<F>
+        where
+            F: Fn(&mut fmt::Formatter<'_>) -> fmt::Result,
+        {
+            fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+                (self.0)(f)
+            }
+        }
+        let s = format!(
+            "{}",
+            Format(
+                |f: &mut fmt::Formatter<'_>| ::util::csv::fmt_comma_delimited(
+                    &mut *f,
+                    self.0.iter()
+                )
+            )
+        );
+        values.extend(Some(::HeaderValue::try_from(s).unwrap()))
+    }
+}
+
+impl Accept {
+    /// A constructor to easily create `Accept: */*`.
+    pub fn star() -> Accept {
+        Accept(vec![qitem(mime::STAR_STAR)])
+    }
+
+    /// A constructor to easily create `Accept: application/json`.
+    pub fn json() -> Accept {
+        Accept(vec![qitem(mime::APPLICATION_JSON)])
+    }
+
+    /// A constructor to easily create `Accept: text/*`.
+    pub fn text() -> Accept {
+        Accept(vec![qitem(mime::TEXT_STAR)])
+    }
+
+    /// A constructor to easily create `Accept: image/*`.
+    pub fn image() -> Accept {
+        Accept(vec![qitem(mime::IMAGE_STAR)])
+    }
+}

src/common/mod.rs

@@ -9,8 +9,8 @@
 //pub use self::accept_charset::AcceptCharset;
 //pub use self::accept_encoding::AcceptEncoding;
 //pub use self::accept_language::AcceptLanguage;
+pub use self::accept::Accept;
 pub use self::accept_ranges::AcceptRanges;
-//pub use self::accept::Accept;
 pub use self::access_control_allow_credentials::AccessControlAllowCredentials;
 pub use self::access_control_allow_headers::AccessControlAllowHeaders;
 pub use self::access_control_allow_methods::AccessControlAllowMethods;
@@ -125,7 +125,7 @@ macro_rules! bench_header {
     };
 }
 
-//mod accept;
+mod accept;
 //mod accept_charset;
 //mod accept_encoding;
 //mod accept_language;

src/disabled/accept.rs

@@ -78,7 +78,7 @@ extern crate bitflags;
 extern crate bytes;
 extern crate headers_core;
 extern crate http;
-extern crate mime;
+pub extern crate mime;
 extern crate sha1;
 #[cfg(all(test, feature = "nightly"))]
 extern crate test;
@@ -99,3 +99,4 @@ mod map_ext;
 
 pub use self::common::*;
 pub use self::map_ext::HeaderMapExt;
+pub use self::util::QualityValue;

src/lib.rs

@@ -8,7 +8,7 @@ pub(crate) use self::fmt::fmt;
 pub(crate) use self::http_date::HttpDate;
 pub(crate) use self::iter::IterExt;
 //pub use language_tags::LanguageTag;
-//pub use self::quality_value::{Quality, QualityValue};
+pub use self::quality_value::{Quality, QualityValue};
 pub(crate) use self::seconds::Seconds;
 pub(crate) use self::value_string::HeaderValueString;
 
@@ -20,7 +20,7 @@ mod flat_csv;
 mod fmt;
 mod http_date;
 mod iter;
-//mod quality_value;
+mod quality_value;
 mod seconds;
 mod value_string;