Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

fix(serde): Support variants #608

Merged
merged 6 commits into from
Sep 13, 2023
Merged

fix(serde): Support variants #608

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
6 commits
Select commit Hold shift + click to select a range
e2a6a1c
test(serde): Verify existing variant behavior
epage Sep 12, 2023
2b7c34c
test(serde): Focus on string serialization first
epage Sep 12, 2023
4ffa44e
test(serde): Make parameter order more consistent
epage Sep 12, 2023
cf06b83
test(serde): Verify both Table and Value serializers
epage Sep 13, 2023
88a4dba
fix(serde): Support tuple variants as table of an array
epage Sep 12, 2023
58a7101
fix(serde): Support struct variants as table of a table
epage Sep 13, 2023
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
103 changes: 95 additions & 8 deletions crates/toml/src/value.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -770,6 +770,13 @@ impl<'de> serde::de::VariantAccess<'de> for MapEnumDeserializer {
fn unit_variant(self) -> Result<(), Self::Error> {
use de::Error;
match self.value {
Value::Array(values) => {
if values.is_empty() {
Ok(())
} else {
Err(Error::custom("expected empty array"))
}
}
Value::Table(values) => {
if values.is_empty() {
Ok(())
Expand Down Expand Up @@ -797,6 +804,13 @@ impl<'de> serde::de::VariantAccess<'de> for MapEnumDeserializer {
{
use de::Error;
match self.value {
Value::Array(values) => {
if values.len() == len {
serde::de::Deserializer::deserialize_seq(values.into_deserializer(), visitor)
} else {
Err(Error::custom(format!("expected tuple with length {}", len)))
}
}
Value::Table(values) => {
let tuple_values = values
.into_iter()
Expand Down Expand Up @@ -870,10 +884,10 @@ impl ser::Serializer for ValueSerializer {
type SerializeSeq = ValueSerializeVec;
type SerializeTuple = ValueSerializeVec;
type SerializeTupleStruct = ValueSerializeVec;
type SerializeTupleVariant = ValueSerializeVec;
type SerializeTupleVariant = ValueSerializeTupleVariant;
type SerializeMap = ValueSerializeMap;
type SerializeStruct = ValueSerializeMap;
type SerializeStructVariant = ser::Impossible<Value, crate::ser::Error>;
type SerializeStructVariant = ValueSerializeStructVariant;

fn serialize_bool(self, value: bool) -> Result<Value, crate::ser::Error> {
Ok(Value::Boolean(value))
Expand Down Expand Up @@ -1015,10 +1029,10 @@ impl ser::Serializer for ValueSerializer {
self,
_name: &'static str,
_variant_index: u32,
_variant: &'static str,
variant: &'static str,
len: usize,
) -> Result<Self::SerializeTupleVariant, crate::ser::Error> {
self.serialize_seq(Some(len))
Ok(ValueSerializeTupleVariant::tuple(variant, len))
}

fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, crate::ser::Error> {
Expand All @@ -1040,12 +1054,12 @@ impl ser::Serializer for ValueSerializer {

fn serialize_struct_variant(
self,
name: &'static str,
_name: &'static str,
_variant_index: u32,
_variant: &'static str,
_len: usize,
variant: &'static str,
len: usize,
) -> Result<Self::SerializeStructVariant, crate::ser::Error> {
Err(crate::ser::Error::unsupported_type(Some(name)))
Ok(ValueSerializeStructVariant::struct_(variant, len))
}
}

Expand Down Expand Up @@ -1453,3 +1467,76 @@ impl<'a, 'de> de::Visitor<'de> for DatetimeOrTable<'a> {
}
}
}

type ValueSerializeTupleVariant = ValueSerializeVariant<ValueSerializeVec>;
type ValueSerializeStructVariant = ValueSerializeVariant<ValueSerializeMap>;

struct ValueSerializeVariant<T> {
variant: &'static str,
inner: T,
}

impl ValueSerializeVariant<ValueSerializeVec> {
pub(crate) fn tuple(variant: &'static str, len: usize) -> Self {
Self {
variant,
inner: ValueSerializeVec {
vec: Vec::with_capacity(len),
},
}
}
}

impl ValueSerializeVariant<ValueSerializeMap> {
pub(crate) fn struct_(variant: &'static str, len: usize) -> Self {
Self {
variant,
inner: ValueSerializeMap {
ser: SerializeMap {
map: Table::with_capacity(len),
next_key: None,
},
},
}
}
}

impl serde::ser::SerializeTupleVariant for ValueSerializeVariant<ValueSerializeVec> {
type Ok = crate::Value;
type Error = crate::ser::Error;

fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
where
T: serde::ser::Serialize,
{
serde::ser::SerializeSeq::serialize_element(&mut self.inner, value)
}

fn end(self) -> Result<Self::Ok, Self::Error> {
let inner = serde::ser::SerializeSeq::end(self.inner)?;
let mut table = Table::new();
table.insert(self.variant.to_owned(), inner);
Ok(Value::Table(table))
}
}

impl serde::ser::SerializeStructVariant for ValueSerializeVariant<ValueSerializeMap> {
type Ok = crate::Value;
type Error = crate::ser::Error;

#[inline]
fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error>
where
T: serde::ser::Serialize + ?Sized,
{
serde::ser::SerializeStruct::serialize_field(&mut self.inner, key, value)
}

#[inline]
fn end(self) -> Result<Self::Ok, Self::Error> {
let inner = serde::ser::SerializeStruct::end(self.inner)?;
let mut table = Table::new();
table.insert(self.variant.to_owned(), inner);
Ok(Value::Table(table))
}
}
125 changes: 116 additions & 9 deletions crates/toml/tests/testsuite/serde.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -21,19 +21,26 @@ macro_rules! equivalent {
let toml = $toml;
let literal = $literal;

// In/out of Value is equivalent
println!("try_from");
assert_eq!(t!(Table::try_from(literal.clone())), toml);
println!("try_into");
assert_eq!(literal, t!(toml.clone().try_into()));

// Through a string equivalent
println!("to_string");
snapbox::assert_eq(t!(toml::to_string(&toml)), t!(toml::to_string(&literal)));
snapbox::assert_eq(t!(toml::to_string(&literal)), t!(toml::to_string(&toml)));
println!("literal, from_str(toml)");
assert_eq!(literal, t!(toml::from_str(&t!(toml::to_string(&toml)))));
println!("toml, from_str(toml)");
assert_eq!(toml, t!(toml::from_str(&t!(toml::to_string(&toml)))));
println!("toml, from_str(literal)");
assert_eq!(toml, t!(toml::from_str(&t!(toml::to_string(&literal)))));

// In/out of Value is equivalent
println!("Table::try_from(literal)");
assert_eq!(toml, t!(Table::try_from(literal.clone())));
println!("Value::try_from(literal)");
assert_eq!(
Value::Table(toml.clone()),
t!(Value::try_from(literal.clone()))
);
println!("toml.try_into()");
assert_eq!(literal, t!(toml.clone().try_into()));
println!("Value::Table(toml).try_into()");
assert_eq!(literal, t!(Value::Table(toml.clone()).try_into()));
}};
}

Expand Down Expand Up @@ -376,6 +383,106 @@ fn parse_enum_string() {
}
}

#[test]
fn parse_tuple_variant() {
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
struct Document {
inner: Vec<Enum>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
enum Enum {
Int(i32, i32),
String(String, String),
}

let input = Document {
inner: vec![
Enum::Int(1, 1),
Enum::String("2".to_owned(), "2".to_owned()),
],
};
let expected = "[[inner]]
Int = [1, 1]

[[inner]]
String = [\"2\", \"2\"]
";
let raw = toml::to_string(&input).unwrap();
snapbox::assert_eq(expected, raw);

equivalent! {
Document {
inner: vec![
Enum::Int(1, 1),
Enum::String("2".to_owned(), "2".to_owned()),
],
},
map! {
inner: vec![
map! { Int: [1, 1] },
map! { String: ["2".to_owned(), "2".to_owned()] },
]
},
}
}

#[test]
fn parse_struct_variant() {
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
struct Document {
inner: Vec<Enum>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
enum Enum {
Int { first: i32, second: i32 },
String { first: String, second: String },
}

let input = Document {
inner: vec![
Enum::Int {
first: 1,
second: 1,
},
Enum::String {
first: "2".to_owned(),
second: "2".to_owned(),
},
],
};
let expected = "[[inner]]

[inner.Int]
first = 1
second = 1

[[inner]]

[inner.String]
first = \"2\"
second = \"2\"
";
let raw = toml::to_string(&input).unwrap();
snapbox::assert_eq(expected, raw);

equivalent! {
Document {
inner: vec![
Enum::Int { first: 1, second: 1 },
Enum::String { first: "2".to_owned(), second: "2".to_owned() },
],
},
map! {
inner: vec![
map! { Int: map! { first: 1, second: 1 } },
map! { String: map! { first: "2".to_owned(), second: "2".to_owned() } },
]
},
}
}

#[test]
#[cfg(feature = "preserve_order")]
fn map_key_unit_variants() {
Expand Down
46 changes: 46 additions & 0 deletions crates/toml_edit/src/de/table_enum.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -16,6 +16,20 @@ impl<'de> serde::de::VariantAccess<'de> for TableEnumDeserializer {

fn unit_variant(self) -> Result<(), Self::Error> {
match self.value {
crate::Item::ArrayOfTables(values) => {
if values.is_empty() {
Ok(())
} else {
Err(Error::custom("expected empty array", values.span()))
}
}
crate::Item::Value(crate::Value::Array(values)) => {
if values.is_empty() {
Ok(())
} else {
Err(Error::custom("expected empty table", values.span()))
}
}
crate::Item::Table(values) => {
if values.is_empty() {
Ok(())
Expand Down Expand Up @@ -49,6 +63,38 @@ impl<'de> serde::de::VariantAccess<'de> for TableEnumDeserializer {
V: serde::de::Visitor<'de>,
{
match self.value {
crate::Item::ArrayOfTables(values) => {
let values_span = values.span();
let tuple_values = values.values.into_iter().collect::<Vec<_>>();

if tuple_values.len() == len {
serde::de::Deserializer::deserialize_seq(
super::ArrayDeserializer::new(tuple_values, values_span),
visitor,
)
} else {
Err(Error::custom(
format!("expected tuple with length {}", len),
values_span,
))
}
}
crate::Item::Value(crate::Value::Array(values)) => {
let values_span = values.span();
let tuple_values = values.values.into_iter().collect::<Vec<_>>();

if tuple_values.len() == len {
serde::de::Deserializer::deserialize_seq(
super::ArrayDeserializer::new(tuple_values, values_span),
visitor,
)
} else {
Err(Error::custom(
format!("expected tuple with length {}", len),
values_span,
))
}
}
crate::Item::Table(values) => {
let values_span = values.span();
let tuple_values = values
Expand Down
Loading
Loading