Implement Serialize and Deserialize for Locale (#6829)

Fixes #6824

Author: sffc

components/locale_core/src/langid.rs

@@ -40,6 +40,14 @@ use alloc::borrow::Cow;
 /// This operation normalizes syntax to be well-formed. No legacy subtag replacements is performed.
 /// For validation and canonicalization, see `LocaleCanonicalizer`.
 ///
+/// # Serde
+///
+/// This type implements `serde::Serialize` and `serde::Deserialize` if the
+/// `"serde"` Cargo feature is enabled on the crate.
+///
+/// The value will be serialized as a string and parsed when deserialized.
+/// For tips on efficient storage and retrieval of locales, see [`crate::zerovec`].
+///
 /// # Examples
 ///
 /// Simple example:

components/locale_core/src/locale.rs

@@ -46,6 +46,14 @@ use core::str::FromStr;
 /// ICU4X's Locale parsing does not allow for non-BCP-47-compatible locales [allowed by UTS 35 for backwards compatability][tr35-bcp].
 /// Furthermore, it currently does not allow for language tags to have more than three characters.
 ///
+/// # Serde
+///
+/// This type implements `serde::Serialize` and `serde::Deserialize` if the
+/// `"serde"` Cargo feature is enabled on the crate.
+///
+/// The value will be serialized as a string and parsed when deserialized.
+/// For tips on efficient storage and retrieval of locales, see [`crate::zerovec`].
+///
 /// # Examples
 ///
 /// Simple example:

components/locale_core/src/serde.rs

@@ -2,49 +2,72 @@
 // called LICENSE at the top level of the ICU4X source tree
 // (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
 
-use crate::LanguageIdentifier;
+use crate::{LanguageIdentifier, Locale};
+use core::{fmt::Display, marker::PhantomData, str::FromStr};
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
+use writeable::Writeable;
 
 impl Serialize for LanguageIdentifier {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: Serializer,
     {
-        serializer.serialize_str(&self.to_string())
+        serializer.serialize_str(&self.write_to_string())
     }
 }
 
-impl<'de> Deserialize<'de> for LanguageIdentifier {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+impl Serialize for Locale {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
-        D: Deserializer<'de>,
+        S: Serializer,
     {
-        struct LanguageIdentifierVisitor;
+        serializer.serialize_str(&self.write_to_string())
+    }
+}
 
-        impl serde::de::Visitor<'_> for LanguageIdentifierVisitor {
-            type Value = LanguageIdentifier;
+struct ParseVisitor<T>(PhantomData<T>);
 
-            fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-                write!(formatter, "a valid Unicode Language Identifier")
-            }
+impl<T> serde::de::Visitor<'_> for ParseVisitor<T>
+where
+    T: FromStr,
+    <T as FromStr>::Err: Display,
+{
+    type Value = T;
 
-            fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
-            where
-                E: serde::de::Error,
-            {
-                s.parse::<LanguageIdentifier>()
-                    .map_err(serde::de::Error::custom)
-            }
-        }
+    fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        write!(formatter, "a valid Unicode Language or Locale Identifier")
+    }
+
+    fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
+    where
+        E: serde::de::Error,
+    {
+        s.parse::<T>().map_err(serde::de::Error::custom)
+    }
+}
 
-        deserializer.deserialize_string(LanguageIdentifierVisitor)
+impl<'de> Deserialize<'de> for LanguageIdentifier {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        deserializer.deserialize_str(ParseVisitor(PhantomData))
+    }
+}
+
+impl<'de> Deserialize<'de> for Locale {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        deserializer.deserialize_str(ParseVisitor(PhantomData))
     }
 }
 
 #[test]
 fn json() {
-    use crate::langid;
     use crate::subtags::{Language, Region, Script};
+    use crate::{langid, locale};
 
     assert_eq!(
         serde_json::to_string(&langid!("en-US")).unwrap(),
@@ -54,8 +77,26 @@ fn json() {
         serde_json::from_str::<LanguageIdentifier>(r#""en-US""#).unwrap(),
         langid!("en-US")
     );
+    assert_eq!(
+        serde_json::from_reader::<_, LanguageIdentifier>(&br#""en-US""#[..]).unwrap(),
+        langid!("en-US")
+    );
     assert!(serde_json::from_str::<LanguageIdentifier>(r#""2Xs""#).is_err());
 
+    assert_eq!(
+        serde_json::to_string(&locale!("en-US-u-hc-h12")).unwrap(),
+        r#""en-US-u-hc-h12""#
+    );
+    assert_eq!(
+        serde_json::from_str::<Locale>(r#""en-US-u-hc-h12""#).unwrap(),
+        locale!("en-US-u-hc-h12")
+    );
+    assert_eq!(
+        serde_json::from_reader::<_, Locale>(&br#""en-US-u-hc-h12""#[..]).unwrap(),
+        locale!("en-US-u-hc-h12")
+    );
+    assert!(serde_json::from_str::<Locale>(r#""2Xs""#).is_err());
+
     assert_eq!(
         serde_json::to_string(&"fr".parse::<Language>().unwrap()).unwrap(),
         r#""fr""#
@@ -64,6 +105,10 @@ fn json() {
         serde_json::from_str::<Language>(r#""fr""#).unwrap(),
         "fr".parse::<Language>().unwrap()
     );
+    assert_eq!(
+        serde_json::from_reader::<_, Language>(&br#""fr""#[..]).unwrap(),
+        "fr".parse::<Language>().unwrap()
+    );
     assert!(serde_json::from_str::<Language>(r#""2Xs""#).is_err());
 
     assert_eq!(
@@ -74,6 +119,10 @@ fn json() {
         serde_json::from_str::<Script>(r#""Latn""#).unwrap(),
         "Latn".parse::<Script>().unwrap()
     );
+    assert_eq!(
+        serde_json::from_reader::<_, Script>(&br#""Latn""#[..]).unwrap(),
+        "Latn".parse::<Script>().unwrap()
+    );
     assert!(serde_json::from_str::<Script>(r#""2Xs""#).is_err());
 
     assert_eq!(
@@ -84,23 +133,37 @@ fn json() {
         serde_json::from_str::<Region>(r#""US""#).unwrap(),
         "US".parse::<Region>().unwrap()
     );
+    assert_eq!(
+        serde_json::from_reader::<_, Region>(&br#""US""#[..]).unwrap(),
+        "US".parse::<Region>().unwrap()
+    );
     assert!(serde_json::from_str::<Region>(r#""2Xs""#).is_err());
 }
 
 #[test]
 fn postcard() {
-    use crate::langid;
     use crate::subtags::{Language, Region, Script};
+    use crate::{langid, locale};
 
     assert_eq!(
         postcard::to_stdvec(&langid!("en-US")).unwrap(),
-        &[5, b'e', b'n', b'-', b'U', b'S']
+        b"\x05en-US"
     );
     assert_eq!(
-        postcard::from_bytes::<LanguageIdentifier>(&[5, b'e', b'n', b'-', b'U', b'S']).unwrap(),
+        postcard::from_bytes::<LanguageIdentifier>(b"\x05en-US").unwrap(),
         langid!("en-US")
     );
-    assert!(postcard::from_bytes::<LanguageIdentifier>(&[3, b'2', b'X', b's']).is_err());
+    assert!(postcard::from_bytes::<LanguageIdentifier>(b"\x032Xs").is_err());
+
+    assert_eq!(
+        postcard::to_stdvec(&locale!("en-US-u-hc-h12")).unwrap(),
+        b"\x0Een-US-u-hc-h12"
+    );
+    assert_eq!(
+        postcard::from_bytes::<Locale>(b"\x0Een-US-u-hc-h12").unwrap(),
+        locale!("en-US-u-hc-h12")
+    );
+    assert!(postcard::from_bytes::<Locale>(b"\x032Xs").is_err());
 
     assert_eq!(
         postcard::to_stdvec(&"fr".parse::<Language>().unwrap()).unwrap(),