Add Accept-Encoding negotiation

Author: yoshuawuyts

src/content/accept_encoding.rs

@@ -1,8 +1,9 @@
 //! Client header advertising available compression algorithms.
 
-use crate::content::EncodingProposal;
+use crate::content::{ContentEncoding, Encoding, EncodingProposal};
 use crate::headers::{HeaderName, HeaderValue, Headers, ToHeaderValues, ACCEPT_ENCODING};
 use crate::utils::sort_by_weight;
+use crate::{Error, StatusCode};
 
 use std::fmt::{self, Debug, Write};
 use std::option;
@@ -71,11 +72,43 @@ impl AcceptEncoding {
         self.wildcard = wildcard
     }
 
-    /// Sort the entries in-place.
+    /// Sort the header directives by weight.
+    ///
+    /// Headers with a higher `q=` value will be returned first. If two
+    /// directives have the same weight, the directive that was declared later
+    /// will be returned first.
     pub fn sort(&mut self) {
         sort_by_weight(&mut self.entries);
     }
 
+    /// Determine the most suitable `Content-Type` encoding.
+    ///
+    /// # Errors
+    ///
+    /// If no suitable encoding is found, an error with the status of `406` will be returned.
+    pub fn negotiate(&mut self, encodings: &[Encoding]) -> crate::Result<ContentEncoding> {
+        // Start by ordering the encodings.
+        self.sort();
+
+        // Try and find the first encoding that matches.
+        for encoding in &self.entries {
+            if encodings.contains(&encoding) {
+                return Ok(encoding.into());
+            }
+        }
+
+        // If no encoding matches and wildcard is set, send whichever encoding we got.
+        if self.wildcard {
+            if let Some(encoding) = encodings.iter().next() {
+                return Ok(encoding.into());
+            }
+        }
+
+        let mut err = Error::new_adhoc("No suitable ContentEncoding found");
+        err.set_status(StatusCode::NotAcceptable);
+        Err(err)
+    }
+
     /// Insert a `HeaderName` + `HeaderValue` pair into a `Headers` instance.
     pub fn apply(&self, mut headers: impl AsMut<Headers>) {
         headers.as_mut().insert(ACCEPT_ENCODING, self.value());
@@ -294,7 +327,7 @@ mod test {
     }
 
     #[test]
-    fn reorder_iter_based_on_weight() -> crate::Result<()> {
+    fn reorder_based_on_weight() -> crate::Result<()> {
         let mut accept = AcceptEncoding::new();
         accept.push(EncodingProposal::new(Encoding::Gzip, Some(0.4))?);
         accept.push(EncodingProposal::new(Encoding::Identity, None)?);
@@ -311,4 +344,23 @@ mod test {
         assert_eq!(accept.next().unwrap(), Encoding::Identity);
         Ok(())
     }
+
+    #[test]
+    fn reorder_based_on_weight_and_location() -> crate::Result<()> {
+        let mut accept = AcceptEncoding::new();
+        accept.push(EncodingProposal::new(Encoding::Identity, None)?);
+        accept.push(EncodingProposal::new(Encoding::Gzip, None)?);
+        accept.push(EncodingProposal::new(Encoding::Brotli, Some(0.8))?);
+
+        let mut headers = Response::new(200);
+        accept.apply(&mut headers);
+
+        let mut accept = AcceptEncoding::from_headers(headers)?.unwrap();
+        accept.sort();
+        let mut accept = accept.iter();
+        assert_eq!(accept.next().unwrap(), Encoding::Brotli);
+        assert_eq!(accept.next().unwrap(), Encoding::Gzip);
+        assert_eq!(accept.next().unwrap(), Encoding::Identity);
+        Ok(())
+    }
 }

src/content/content_encoding.rs

@@ -1,6 +1,6 @@
 //! Specify the compression algorithm.
 
-use crate::content::Encoding;
+use crate::content::{Encoding, EncodingProposal};
 use crate::headers::{HeaderName, HeaderValue, Headers, ToHeaderValues, CONTENT_ENCODING};
 
 use std::fmt::{self, Debug, Write};
@@ -207,6 +207,38 @@ impl ToHeaderValues for ContentEncoding {
     }
 }
 
+impl From<Encoding> for ContentEncoding {
+    fn from(encoding: Encoding) -> Self {
+        Self {
+            entries: vec![encoding],
+        }
+    }
+}
+
+impl From<&Encoding> for ContentEncoding {
+    fn from(encoding: &Encoding) -> Self {
+        Self {
+            entries: vec![*encoding],
+        }
+    }
+}
+
+impl From<EncodingProposal> for ContentEncoding {
+    fn from(encoding: EncodingProposal) -> Self {
+        Self {
+            entries: vec![encoding.encoding],
+        }
+    }
+}
+
+impl From<&EncodingProposal> for ContentEncoding {
+    fn from(encoding: &EncodingProposal) -> Self {
+        Self {
+            entries: vec![encoding.encoding],
+        }
+    }
+}
+
 impl Debug for ContentEncoding {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let mut list = f.debug_list();

src/content/encoding_proposal.rs

@@ -4,12 +4,13 @@ use crate::headers::HeaderValue;
 use crate::utils::parse_weight;
 
 use std::cmp::{Ordering, PartialEq};
+use std::ops::{Deref, DerefMut};
 
 /// A proposed `Encoding` in `AcceptEncoding`.
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub struct EncodingProposal {
     /// The proposed encoding.
-    encoding: Encoding,
+    pub(crate) encoding: Encoding,
 
     /// The weight of the proposal.
     ///
@@ -76,6 +77,19 @@ impl PartialEq<Encoding> for &EncodingProposal {
     }
 }
 
+impl Deref for EncodingProposal {
+    type Target = Encoding;
+    fn deref(&self) -> &Self::Target {
+        &self.encoding
+    }
+}
+
+impl DerefMut for EncodingProposal {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.encoding
+    }
+}
+
 // NOTE: Firefox populates Accept-Encoding as `gzip, deflate, br`. This means
 // when parsing encodings we should choose the last value in the list under
 // equal weights. This impl doesn't know which value was passed later, so that