Add support for language tags

Author: vodik

src/content/language.rs

@@ -0,0 +1,40 @@
+use crate::headers::HeaderValue;
+use std::fmt::{self, Display};
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct Language(Vec<String>);
+
+impl Language {
+    /// Parses a given string into its corresponding language.
+    pub(crate) fn from_str(s: &str) -> Option<Language> {
+        let s = s.trim();
+
+        // We're dealing with an empty string.
+        if s.is_empty() {
+            return None;
+        }
+
+        Some(Self(s.split('-').map(|tag| tag.to_string()).collect()))
+    }
+}
+
+impl Display for Language {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let mut tags = self.0.iter();
+        if let Some(tag) = tags.next() {
+            write!(f, "{}", tag)?;
+
+            for tag in tags {
+                write!(f, "-{}", tag)?;
+            }
+        }
+        Ok(())
+    }
+}
+
+impl From<Language> for HeaderValue {
+    fn from(language: Language) -> Self {
+        let s = language.to_string();
+        unsafe { HeaderValue::from_bytes_unchecked(s.into_bytes()) }
+    }
+}

src/content/language_proposal.rs

@@ -0,0 +1,112 @@
+use crate::content::Language;
+use crate::ensure;
+use crate::headers::HeaderValue;
+use crate::utils::parse_weight;
+
+use std::cmp::{Ordering, PartialEq};
+use std::ops::{Deref, DerefMut};
+
+/// A proposed `Language` in `AcceptLanguage`.
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct LanguageProposal {
+    /// The proposed language.
+    pub(crate) language: Language,
+
+    /// The weight of the proposal.
+    ///
+    /// This is a number between 0.0 and 1.0, and is max 3 decimal points.
+    weight: Option<f32>,
+}
+
+impl LanguageProposal {
+    /// Create a new instance of `LanguageProposal`.
+    pub fn new(language: impl Into<Language>, weight: Option<f32>) -> crate::Result<Self> {
+        if let Some(weight) = weight {
+            ensure!(
+                weight.is_sign_positive() && weight <= 1.0,
+                "LanguageProposal should have a weight between 0.0 and 1.0"
+            )
+        }
+
+        Ok(Self {
+            language: language.into(),
+            weight,
+        })
+    }
+
+    /// Get the proposed language.
+    pub fn language(&self) -> &Language {
+        &self.language
+    }
+
+    /// Get the weight of the proposal.
+    pub fn weight(&self) -> Option<f32> {
+        self.weight
+    }
+
+    pub(crate) fn from_str(s: &str) -> crate::Result<Option<Self>> {
+        let mut parts = s.split(';');
+        let language = match Language::from_str(parts.next().unwrap()) {
+            Some(language) => language,
+            None => return Ok(None),
+        };
+        let weight = parts.next().map(parse_weight).transpose()?;
+
+        Ok(Some(Self::new(language, weight)?))
+    }
+}
+
+impl From<Language> for LanguageProposal {
+    fn from(language: Language) -> Self {
+        Self {
+            language,
+            weight: None,
+        }
+    }
+}
+
+impl PartialEq<Language> for LanguageProposal {
+    fn eq(&self, other: &Language) -> bool {
+        self.language == *other
+    }
+}
+
+impl PartialEq<Language> for &LanguageProposal {
+    fn eq(&self, other: &Language) -> bool {
+        self.language == *other
+    }
+}
+
+impl Deref for LanguageProposal {
+    type Target = Language;
+    fn deref(&self) -> &Self::Target {
+        &self.language
+    }
+}
+
+impl DerefMut for LanguageProposal {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.language
+    }
+}
+
+impl PartialOrd for LanguageProposal {
+    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+        match (self.weight, other.weight) {
+            (Some(left), Some(right)) => left.partial_cmp(&right),
+            (Some(_), None) => Some(Ordering::Greater),
+            (None, Some(_)) => Some(Ordering::Less),
+            (None, None) => None,
+        }
+    }
+}
+
+impl From<LanguageProposal> for HeaderValue {
+    fn from(entry: LanguageProposal) -> HeaderValue {
+        let s = match entry.weight {
+            Some(weight) => format!("{};q={:.3}", entry.language, weight),
+            None => entry.language.to_string(),
+        };
+        unsafe { HeaderValue::from_bytes_unchecked(s.into_bytes()) }
+    }
+}

src/content/mod.rs

@@ -40,6 +40,8 @@ mod content_location;
 mod content_type;
 mod encoding;
 mod encoding_proposal;
+mod language;
+mod language_proposal;
 mod media_type_proposal;
 
 #[doc(inline)]
@@ -53,4 +55,6 @@ pub use content_location::ContentLocation;
 pub use content_type::ContentType;
 pub use encoding::Encoding;
 pub use encoding_proposal::EncodingProposal;
+pub use language::Language;
+pub use language_proposal::LanguageProposal;
 pub use media_type_proposal::MediaTypeProposal;