inital commit, added fields to content_encoding, creating a QualityValue util type, creating a basic accept_encoding header that uses QualityValue

Author: ParkMyCar

Cargo.toml

@@ -22,6 +22,7 @@ headers-core = { version = "0.2", path = "./headers-core" }
 base64 = "0.12"
 bitflags = "1.0"
 bytes = "0.5"
+itertools = "0.9"
 mime = "0.3.14"
 sha-1 = "0.8"
 time = "0.1.34"

src/common/accept_encoding.rs

@@ -0,0 +1,14 @@
+use util::QualityValue;
+// use HeaderValue;
+
+
+/// `Accept-Encoding` header, defined in
+/// [RFC7231](https://tools.ietf.org/html/rfc7231#section-5.3.4)
+/// 
+#[derive(Clone, Debug)]
+pub struct AcceptEncoding(QualityValue);
+
+derive_header! {
+    AcceptEncoding(_),
+    name: ACCEPT_ENCODING
+}

src/common/content_encoding.rs

@@ -46,6 +46,30 @@ impl ContentEncoding {
         ContentEncoding(HeaderValue::from_static("gzip").into())
     }
 
+    /// A constructor to easily create a `Content-Encoding: compress` header.
+    #[inline]
+    pub fn compress() -> ContentEncoding {
+        ContentEncoding(HeaderValue::from_static("compress").into())
+    }
+
+    /// A constructor to easily create a `Content-Encoding: deflate` header.
+    #[inline]
+    pub fn deflate() -> ContentEncoding {
+        ContentEncoding(HeaderValue::from_static("deflate").into())
+    }
+
+    /// A constructor to easily create a `Content-Encoding: identity` header.
+    #[inline]
+    pub fn identity() -> ContentEncoding {
+        ContentEncoding(HeaderValue::from_static("identity").into())
+    }
+
+    /// A constructor to easily create a `Content-Encoding: br` header.
+    #[inline]
+    pub fn br() -> ContentEncoding {
+        ContentEncoding(HeaderValue::from_static("br").into())
+    }
+
     /// Check if this header contains a given "coding".
     ///
     /// This can be used with these argument types:

src/common/mod.rs

@@ -7,7 +7,7 @@
 //! is used, such as `ContentType(pub Mime)`.
 
 //pub use self::accept_charset::AcceptCharset;
-//pub use self::accept_encoding::AcceptEncoding;
+pub use self::accept_encoding::AcceptEncoding;
 //pub use self::accept_language::AcceptLanguage;
 pub use self::accept_ranges::AcceptRanges;
 //pub use self::accept::Accept;
@@ -127,7 +127,7 @@ macro_rules! bench_header {
 
 //mod accept;
 //mod accept_charset;
-//mod accept_encoding;
+mod accept_encoding;
 //mod accept_language;
 mod accept_ranges;
 mod access_control_allow_credentials;

src/lib.rs

@@ -78,6 +78,7 @@ extern crate bitflags;
 extern crate bytes;
 extern crate headers_core;
 extern crate http;
+extern crate itertools;
 extern crate mime;
 extern crate sha1;
 #[cfg(all(test, feature = "nightly"))]

src/util/mod.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(crate) use self::quality_value::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;
 

src/util/quality_value.rs

@@ -0,0 +1,175 @@
+use std::cmp::Ordering;
+use std::convert::TryFrom;
+use std::marker::PhantomData;
+
+use HeaderValue;
+use itertools::Itertools;
+use util::{FlatCsv, TryFromValues};
+
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub(crate) struct QualityValue<QualSep = SemiQ> {
+    csv: FlatCsv,
+    _marker: PhantomData<QualSep>,
+}
+
+pub(crate) trait QualityDelimiter {
+    const STR: &'static str;
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub(crate) enum SemiQ {}
+
+impl QualityDelimiter for SemiQ {
+    const STR: &'static str = ";q=";
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+struct QualityMeta<'a, Sep = SemiQ> {
+    pub data: &'a str,
+    pub quality: u16,
+    _marker: PhantomData<Sep>,
+}
+
+impl<Delm: QualityDelimiter + Ord> Ord for QualityMeta<'_, Delm> {
+    fn cmp(&self, other: &Self) -> Ordering {
+        other.quality.cmp(&self.quality)
+    }
+}
+
+impl<Delm: QualityDelimiter + Ord> PartialOrd for QualityMeta<'_, Delm> {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl<'a, Delm: QualityDelimiter> TryFrom<&'a str> for QualityMeta<'a, Delm> {
+    type Error = ::Error;
+
+    fn try_from(val: &'a str) -> Result<Self, ::Error> {
+        let mut parts: Vec<&str> = val.split(Delm::STR).collect();
+
+        match (parts.pop(), parts.pop()) {
+            (Some(qual), Some(data)) => {
+                let parsed: f32 = qual.parse().map_err(|_| ::Error::invalid())?;
+                let quality = (parsed * 1000_f32) as u16;
+
+                Ok(QualityMeta {
+                    data,
+                    quality,
+                    _marker: PhantomData,
+                })
+            }
+            // No deliter present, assign a quality value of 1
+            (Some(data), None) => Ok(QualityMeta {
+                data,
+                quality: 1000_u16,
+                _marker: PhantomData,
+            }),
+            _ => Err(::Error::invalid()),
+        }
+    }
+}
+
+impl<Delm: QualityDelimiter + Ord> QualityValue<Delm> {
+    pub(crate) fn iter(&self) -> impl Iterator<Item = &str> {
+        self.csv
+            .iter()
+            .map(|v| QualityMeta::<Delm>::try_from(v).unwrap())
+            .into_iter()
+            .sorted()
+            .map(|pair| pair.data)
+            .into_iter()
+    }
+}
+
+impl<Delm: QualityDelimiter> From<FlatCsv> for QualityValue<Delm> {
+    fn from(csv: FlatCsv) -> Self {
+        QualityValue {
+            csv,
+            _marker: PhantomData,
+        }
+    }
+}
+
+impl<Delm> From<HeaderValue> for QualityValue<Delm> {
+    fn from(value: HeaderValue) -> Self {
+        QualityValue {
+            csv: value.into(),
+            _marker: PhantomData,
+        }
+    }
+}
+
+impl<'a, Delm> From<&'a QualityValue<Delm>> for HeaderValue {
+    fn from(qual: &'a QualityValue<Delm>) -> HeaderValue {
+        qual.csv.value.clone()
+    }
+}
+
+impl<Delm: QualityDelimiter> TryFromValues for QualityValue<Delm> {
+    fn try_from_values<'i, I>(values: &mut I) -> Result<Self, ::Error>
+    where 
+        I: Iterator<Item = &'i HeaderValue>,
+    {
+        let flat: FlatCsv = values.collect();
+        Ok(QualityValue::from(flat))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use util::flat_csv::Comma;
+    use HeaderValue;
+
+    #[test]
+    fn multiple_qualities() {
+        let val = HeaderValue::from_static("gzip;q=1, br;q=0.8");
+        let csv = FlatCsv::<Comma>::from(val);
+        let qual = QualityValue::<SemiQ>::from(csv);
+
+        let mut values = qual.iter();
+        assert_eq!(values.next(), Some("gzip"));
+        assert_eq!(values.next(), Some("br"));
+        assert_eq!(values.next(), None);
+    }
+
+    #[test]
+    fn multiple_qualities_wrong_order() {
+        let val = HeaderValue::from_static("br;q=0.8, gzip;q=1");
+        let csv = FlatCsv::<Comma>::from(val);
+        let qual = QualityValue::<SemiQ>::from(csv);
+
+        let mut values = qual.iter();
+        assert_eq!(values.next(), Some("gzip"));
+        assert_eq!(values.next(), Some("br"));
+        assert_eq!(values.next(), None);
+    }
+
+    #[test]
+    fn multiple_values() {
+        let val = HeaderValue::from_static("deflate, gzip;q=1, br;q=0.8");
+        let csv = FlatCsv::<Comma>::from(val);
+        let qual = QualityValue::<SemiQ>::from(csv);
+
+        let mut values = qual.iter();
+        assert_eq!(values.next(), Some("deflate"));
+        assert_eq!(values.next(), Some("gzip"));
+        assert_eq!(values.next(), Some("br"));
+        assert_eq!(values.next(), None);
+    }
+
+    #[test]
+    fn multiple_values_wrong_order() {
+        let val = HeaderValue::from_static("deflate, br;q=0.8, gzip;q=1, *;q=0.1");
+        let csv = FlatCsv::<Comma>::from(val);
+        let qual = QualityValue::<SemiQ>::from(csv);
+
+        let mut values = qual.iter();
+        assert_eq!(values.next(), Some("deflate"));
+        assert_eq!(values.next(), Some("gzip"));
+        assert_eq!(values.next(), Some("br"));
+        assert_eq!(values.next(), Some("*"));
+        assert_eq!(values.next(), None);
+    }
+}