WIP language ranges

Author: vodik

src/language/mod.rs

@@ -0,0 +1,42 @@
+//! RFC 4647 Language Ranges.
+//! 
+//! [Read more](https://datatracker.ietf.org/doc/html/rfc4647)
+
+mod parse;
+
+use crate::headers::HeaderValue;
+use std::{fmt::{self, Display}, borrow::Cow, str::FromStr};
+
+#[derive(Debug)]
+pub struct LanguageRange {
+    pub(crate) tags: Vec<Cow<'static, str>>
+}
+
+impl Display for LanguageRange {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let mut tags = self.tags.iter();
+        if let Some(tag) = tags.next() {
+            write!(f, "{}", tag)?;
+
+            for tag in tags {
+                write!(f, "-{}", tag)?;
+            }
+        }
+        Ok(())
+    }
+}
+
+impl From<LanguageRange> for HeaderValue {
+    fn from(language: LanguageRange) -> Self {
+        let s = language.to_string();
+        unsafe { HeaderValue::from_bytes_unchecked(s.into_bytes()) }
+    }
+}
+
+impl FromStr for LanguageRange {
+    type Err = crate::Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        parse::parse(s)
+    }
+}

src/language/parse.rs

@@ -0,0 +1,68 @@
+use std::borrow::Cow;
+
+use super::LanguageRange;
+
+fn split_tag(input: &str) -> Option<(&str, &str)> {
+    match input.find('-') {
+        Some(pos) if pos <= 8 => {
+            let (tag, rest) = input.split_at(pos);
+            Some((tag, &rest[1..]))
+        }
+        Some(_) => None,
+        None => (input.len() <= 8).then(|| (input, "")),
+    }
+}
+
+// language-range   = (1*8ALPHA *("-" 1*8alphanum)) / "*"
+// alphanum         = ALPHA / DIGIT
+pub(crate) fn parse(input: &str) -> crate::Result<LanguageRange> {
+    let tags = if input == "*" {
+        vec![Cow::from(input.to_string())]
+    } else {
+        let mut tags = Vec::new();
+
+        let (tag, mut input) = split_tag(input).ok_or_else(|| crate::format_err!("WIP error"))?;
+        crate::ensure!(!tag.is_empty(), "Language tag should not be empty");
+        crate::ensure!(
+            tag.bytes()
+                .all(|b| (b'a'..=b'z').contains(&b) || (b'A'..=b'Z').contains(&b)),
+            "Language tag should be alpha"
+        );
+        tags.push(Cow::from(tag.to_string()));
+
+        while !input.is_empty() {
+            let (tag, rest) = split_tag(input).ok_or_else(|| crate::format_err!("WIP error"))?;
+            crate::ensure!(!tag.is_empty(), "Language tag should not be empty");
+            crate::ensure!(
+                tag.bytes().all(|b| (b'a'..=b'z').contains(&b)
+                    || (b'A'..=b'Z').contains(&b)
+                    || (b'0'..=b'9').contains(&b)),
+                "Language tag should be alpha numeric"
+            );
+            tags.push(Cow::from(tag.to_string()));
+            input = rest;
+        }
+
+        tags
+    };
+
+    Ok(LanguageRange { tags })
+}
+
+#[test]
+fn test() {
+    let range = parse("*").unwrap();
+    assert_eq!(&range.tags, &["*"]);
+
+    let range = parse("en").unwrap();
+    assert_eq!(&range.tags, &["en"]);
+
+    let range = parse("en-CA").unwrap();
+    assert_eq!(&range.tags, &["en", "CA"]);
+
+    let range = parse("zh-Hant-CN-x-private1-private2").unwrap();
+    assert_eq!(
+        &range.tags,
+        &["zh", "Hant", "CN", "x", "private1", "private2"]
+    );
+}

src/lib.rs

@@ -123,6 +123,7 @@ pub mod cache;
 pub mod conditional;
 pub mod content;
 pub mod headers;
+pub mod language;
 pub mod mime;
 pub mod other;
 pub mod proxies;