shacl_structural_model/
language_tag.rs1use 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#[derive(Debug, Clone)]
18pub struct LanguageTag(String);
19
20impl LanguageTag {
21 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 #[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}