feat(serde): Support chars as keys

Fixes #626

Author: epage

crates/toml/src/de/deserializer/key.rs

@@ -120,6 +120,14 @@ impl<'de> serde_core::de::Deserializer<'de> for KeyDeserializer<'de> {
         key.into_deserializer().deserialize_u128(visitor)
     }
 
+    fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: serde_core::de::Visitor<'de>,
+    {
+        let key: char = self.key.parse().map_err(serde_core::de::Error::custom)?;
+        key.into_deserializer().deserialize_char(visitor)
+    }
+
     fn deserialize_enum<V>(
         self,
         name: &str,
@@ -165,7 +173,7 @@ impl<'de> serde_core::de::Deserializer<'de> for KeyDeserializer<'de> {
     }
 
     serde_core::forward_to_deserialize_any! {
-        f32 f64 char str string seq
+        f32 f64 str string seq
         bytes byte_buf map option unit
         ignored_any unit_struct tuple_struct tuple identifier
     }

crates/toml/src/ser/value/key.rs

@@ -81,8 +81,11 @@ impl serde_core::ser::Serializer for KeySerializer<'_> {
         Err(Error::key_not_string())
     }
 
-    fn serialize_char(self, _v: char) -> Result<Self::Ok, Self::Error> {
-        Err(Error::key_not_string())
+    fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {
+        let mut b = [0; 4];
+        let result = v.encode_utf8(&mut b);
+        self.dst.key(&*result)?;
+        Ok(())
     }
 
     fn serialize_str(self, value: &str) -> Result<Self::Ok, Self::Error> {

crates/toml/tests/serde/de_key.rs

@@ -273,3 +273,67 @@ Document {
         assert_data_eq!(result.unwrap().to_debug(), expected);
     }
 }
+
+mod char_key {
+    use super::*;
+
+    type Map = super::Map<char>;
+    type Document = super::Document<char>;
+
+    #[test]
+    fn from_str() {
+        let input = "k = 'value'";
+        let expected = str![[r#"
+{
+    'k': "value",
+}
+
+"#]];
+        let result = crate::from_str::<Map>(input);
+        assert_data_eq!(result.unwrap().to_debug(), expected);
+    }
+
+    #[test]
+    fn value_from_inline_table() {
+        let input = "{ k = 'value' }";
+        let expected = str![[r#"
+{
+    'k': "value",
+}
+
+"#]];
+        let result = crate::value_from_str::<Map>(input);
+        assert_data_eq!(result.unwrap().to_debug(), expected);
+    }
+
+    #[test]
+    fn from_inline_table() {
+        let input = "map = { k = 'value' }";
+        let expected = str![[r#"
+Document {
+    map: {
+        'k': "value",
+    },
+}
+
+"#]];
+        let result = crate::from_str::<Document>(input);
+        assert_data_eq!(result.unwrap().to_debug(), expected);
+    }
+
+    #[test]
+    fn from_std_table() {
+        let input = "[map]
+k = 'value'";
+        let expected = str![[r#"
+Document {
+    map: {
+        'k': "value",
+    },
+}
+
+"#]];
+        let result = crate::from_str::<Document>(input);
+        assert_data_eq!(result.unwrap().to_debug(), expected);
+    }
+}

crates/toml/tests/serde/ser_key.rs

@@ -453,3 +453,106 @@ mod i16_key {
         assert_eq!(json, input);
     }
 }
+
+mod char_key {
+    use super::*;
+
+    type Map = super::Map<char>;
+    type Document = super::Document<char>;
+
+    fn key() -> char {
+        'k'
+    }
+
+    #[test]
+    fn to_string_value() {
+        let expected = str![[r#"{ k = "value" }"#]];
+        let input = [(key(), "value".to_owned())].into_iter().collect::<Map>();
+        let toml = t!(crate::to_string_value(&input));
+        assert_data_eq!(&toml, expected);
+        let roundtrip = t!(crate::value_from_str::<Map>(&toml));
+        assert_eq!(roundtrip, input);
+        let json = json_from_toml_value_str::<Map>(&toml);
+        assert_eq!(json, input);
+    }
+
+    #[test]
+    fn to_string() {
+        let expected = str![[r#"
+k = "value"
+
+"#]];
+        let input = [(key(), "value".to_owned())].into_iter().collect::<Map>();
+        let toml = t!(crate::to_string(&input));
+        assert_data_eq!(&toml, expected);
+        let roundtrip = t!(crate::from_str::<Map>(&toml));
+        assert_eq!(roundtrip, input);
+        let json = json_from_toml_str::<Map>(&toml);
+        assert_eq!(json, input);
+    }
+
+    #[test]
+    fn to_string_pretty() {
+        let expected = str![[r#"
+k = "value"
+
+"#]];
+        let input = [(key(), "value".to_owned())].into_iter().collect::<Map>();
+        let toml = t!(crate::to_string_pretty(&input));
+        assert_data_eq!(&toml, expected);
+        let roundtrip = t!(crate::from_str::<Map>(&toml));
+        assert_eq!(roundtrip, input);
+        let json = json_from_toml_str::<Map>(&toml);
+        assert_eq!(json, input);
+    }
+
+    #[test]
+    fn nested_to_string_value() {
+        let expected = str![[r#"{ map = { k = "value" } }"#]];
+        let input = Document {
+            map: [(key(), "value".to_owned())].into_iter().collect::<Map>(),
+        };
+        let toml = t!(crate::to_string_value(&input));
+        assert_data_eq!(&toml, expected);
+        let roundtrip = t!(crate::value_from_str::<Document>(&toml));
+        assert_eq!(roundtrip, input);
+        let json = json_from_toml_value_str::<Document>(&toml);
+        assert_eq!(json, input);
+    }
+
+    #[test]
+    fn nested_to_string() {
+        let expected = str![[r#"
+[map]
+k = "value"
+
+"#]];
+        let input = Document {
+            map: [(key(), "value".to_owned())].into_iter().collect::<Map>(),
+        };
+        let toml = t!(crate::to_string(&input));
+        assert_data_eq!(&toml, expected);
+        let roundtrip = t!(crate::from_str::<Document>(&toml));
+        assert_eq!(roundtrip, input);
+        let json = json_from_toml_str::<Document>(&toml);
+        assert_eq!(json, input);
+    }
+
+    #[test]
+    fn nested_to_string_pretty() {
+        let expected = str![[r#"
+[map]
+k = "value"
+
+"#]];
+        let input = Document {
+            map: [(key(), "value".to_owned())].into_iter().collect::<Map>(),
+        };
+        let toml = t!(crate::to_string_pretty(&input));
+        assert_data_eq!(&toml, expected);
+        let roundtrip = t!(crate::from_str::<Document>(&toml));
+        assert_eq!(roundtrip, input);
+        let json = json_from_toml_str::<Document>(&toml);
+        assert_eq!(json, input);
+    }
+}

crates/toml_edit/src/de/key.rs

@@ -152,6 +152,17 @@ impl<'de> serde_core::de::Deserializer<'de> for KeyDeserializer {
         key.into_deserializer().deserialize_u128(visitor)
     }
 
+    fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: serde_core::de::Visitor<'de>,
+    {
+        let key: char = self
+            .key
+            .parse()
+            .map_err(<Error as serde_core::de::Error>::custom)?;
+        key.into_deserializer().deserialize_char(visitor)
+    }
+
     fn deserialize_enum<V>(
         self,
         name: &str,
@@ -202,7 +213,7 @@ impl<'de> serde_core::de::Deserializer<'de> for KeyDeserializer {
     }
 
     serde_core::forward_to_deserialize_any! {
-        f32 f64 char str string seq
+        f32 f64 str string seq
         bytes byte_buf map option unit
         ignored_any unit_struct tuple_struct tuple identifier
     }

crates/toml_edit/src/ser/key.rs

@@ -67,8 +67,8 @@ impl serde_core::ser::Serializer for KeySerializer {
         Err(Error::key_not_string())
     }
 
-    fn serialize_char(self, _v: char) -> Result<Self::Ok, Self::Error> {
-        Err(Error::key_not_string())
+    fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {
+        Ok(Key::new(v.to_string()))
     }
 
     fn serialize_str(self, value: &str) -> Result<Self::Ok, Self::Error> {