Experimentation with ron-rs#253 and ron-rs#357

src/de/value.rs

@@ -273,20 +273,27 @@ mod tests {
             ),
             Value::Option(Some(Box::new(Value::Seq(vec![
                 Value::Map(
-                    vec![
-                        (
-                            Value::String("width".to_owned()),
-                            Value::Number(Number::new(20)),
-                        ),
-                        (
-                            Value::String("height".to_owned()),
-                            Value::Number(Number::new(5)),
+                    vec![(
+                        Value::String("Room".to_owned()),
+                        Value::Map(
+                            vec![
+                                (
+                                    Value::String("width".to_owned()),
+                                    Value::Number(Number::new(20)),
+                                ),
+                                (
+                                    Value::String("height".to_owned()),
+                                    Value::Number(Number::new(5)),
+                                ),
+                                (
+                                    Value::String("name".to_owned()),
+                                    Value::String("The Room".to_owned()),
+                                ),
+                            ]
+                            .into_iter()
+                            .collect(),
                         ),
-                        (
-                            Value::String("name".to_owned()),
-                            Value::String("The Room".to_owned()),
-                        ),
-                    ]
+                    )]
                     .into_iter()
                     .collect(),
                 ),

src/parse.rs

@@ -145,7 +145,7 @@ impl<'a> Bytes<'a> {
             }
 
             Ok(num_acc)
-        };
+        }
 
         let res = if sign > 0 {
             calc_num(&*self, s, base, T::checked_add_ext)

tests/117_untagged_tuple_variant.rs

@@ -23,7 +23,7 @@ fn test_ebkalderon_case() {
     flags: [
         "--enable-thing",
         "--enable-other-thing",
-        If("some-conditional", ["--enable-third-thing"]),
+        ("some-conditional", ["--enable-third-thing"]),
     ]
 )
 "#;

tests/357_untagged_roundtrip.rs

@@ -0,0 +1,30 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(untagged)]
+enum MyValue {
+    Int(i64),
+    String(String),
+    Enum(Enum),
+    List(Vec<MyValue>),
+}
+
+#[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
+enum Enum {
+    First(String),
+    Second(i64),
+}
+
+#[test]
+fn test() {
+    let value = MyValue::Enum(Enum::First(String::from("foo")));
+
+    let serialized = ron::to_string(&value).unwrap();
+    assert_eq!(serialized, r#"First("foo")"#);
+
+    let inner_deserialized: Enum = ron::from_str(&serialized).unwrap();
+    assert_eq!(inner_deserialized, Enum::First(String::from("foo")));
+
+    let deserialized: MyValue = ron::from_str(&serialized).unwrap();
+    assert_eq!(deserialized, value);
+}

tests/value.rs

@@ -70,7 +70,7 @@ fn unit() {
     use ron::error::{Error, ErrorCode, Position};
 
     assert_eq!("()".parse(), Ok(Value::Unit));
-    assert_eq!("Foo".parse(), Ok(Value::Unit));
+    assert_eq!("Foo".parse(), Ok(Value::String(String::from("Foo"))));
 
     assert_eq!(
         "".parse::<Value>(),