Skip to main content

shacl_structural_model/
language_tag.rs

1//! Validated `sh:languageIn` members.
2
3use std::cmp::Ordering;
4use std::fmt;
5use std::hash::{Hash, Hasher};
6
7use serde::{Deserialize, Deserializer, Serialize, Serializer};
8
9use crate::{LexicalRole, StructuralModelError};
10
11/// A well-formed BCP 47 language tag, as listed by `sh:languageIn`.
12///
13/// The check is syntactic (RFC 5646 well-formedness, including unique variants
14/// and extension singletons); the IANA registry is not consulted. Spelling is
15/// preserved, while equality, hashing and ordering are ASCII case-insensitive.
16/// Serde decoding applies the same check as [`LanguageTag::try_new`].
17#[derive(Debug, Clone)]
18pub struct LanguageTag(String);
19
20impl LanguageTag {
21    /// Validate a language tag.
22    ///
23    /// # Errors
24    ///
25    /// Returns [`StructuralModelError::InvalidSyntax`] with
26    /// [`LexicalRole::LanguageTag`] for a malformed tag.
27    pub fn try_new(lexical: impl Into<String>) -> Result<Self, StructuralModelError> {
28        let lexical = lexical.into();
29        if rdf_structural_model::LanguageTag::try_new(lexical.as_str()).is_err() {
30            return Err(StructuralModelError::InvalidSyntax {
31                lexical,
32                expected: LexicalRole::LanguageTag,
33            });
34        }
35        Ok(Self(lexical))
36    }
37
38    /// The original spelling.
39    #[must_use]
40    pub fn as_str(&self) -> &str {
41        &self.0
42    }
43
44    fn folded(&self) -> impl Iterator<Item = u8> + '_ {
45        self.as_str().bytes().map(|byte| byte.to_ascii_lowercase())
46    }
47}
48
49impl PartialEq for LanguageTag {
50    fn eq(&self, other: &Self) -> bool {
51        self.as_str().eq_ignore_ascii_case(other.as_str())
52    }
53}
54
55impl Eq for LanguageTag {}
56
57impl Hash for LanguageTag {
58    fn hash<H: Hasher>(&self, state: &mut H) {
59        for byte in self.folded() {
60            state.write_u8(byte);
61        }
62        state.write_u8(0xff);
63    }
64}
65
66impl PartialOrd for LanguageTag {
67    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
68        Some(self.cmp(other))
69    }
70}
71
72impl Ord for LanguageTag {
73    fn cmp(&self, other: &Self) -> Ordering {
74        self.folded().cmp(other.folded())
75    }
76}
77
78impl fmt::Display for LanguageTag {
79    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
80        formatter.write_str(self.as_str())
81    }
82}
83
84impl Serialize for LanguageTag {
85    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
86        serializer.serialize_str(self.as_str())
87    }
88}
89
90impl<'de> Deserialize<'de> for LanguageTag {
91    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
92        Self::try_new(String::deserialize(deserializer)?).map_err(serde::de::Error::custom)
93    }
94}
95
96#[cfg(test)]
97mod tests {
98    use super::*;
99
100    #[test]
101    fn tags_compare_case_insensitively_and_keep_spelling() {
102        let upper = LanguageTag::try_new("EN-gb").unwrap();
103        let lower = LanguageTag::try_new("en-GB").unwrap();
104        assert_eq!(upper, lower);
105        assert_eq!(upper.cmp(&lower), Ordering::Equal);
106        assert_eq!(upper.as_str(), "EN-gb");
107        assert!(LanguageTag::try_new("de").unwrap() < upper);
108    }
109
110    #[test]
111    fn malformed_tags_report_the_lexical_value_and_role() {
112        assert_eq!(
113            LanguageTag::try_new("en--gb"),
114            Err(StructuralModelError::InvalidSyntax {
115                lexical: "en--gb".to_owned(),
116                expected: LexicalRole::LanguageTag,
117            })
118        );
119        assert!(LanguageTag::try_new("de-1996-1996").is_err());
120    }
121}