refactor(ariadne): derive Clew AST deserialization

src/ariadne/clew_test.rs

@@ -1,4 +1,4 @@
-use ariadne::clew::{self, DictEntry, Error, Value};
+use ariadne::clew::{self, DictEntry, Error, TaggedValue, Value};
 use serde_json::Number;
 
 fn document_with(roots: &str) -> String {
@@ -56,13 +56,15 @@ fn parses_primitive_values() {
 
     assert_eq!(
         document.roots,
-        Value::List(vec![
-            Value::Null,
-            Value::Bool(true),
-            Value::Number(Number::from(7)),
-            Value::Number(Number::from_f64(1.5).unwrap()),
-            Value::String("text".to_string()),
-        ])
+        Value::Tagged(TaggedValue::List {
+            items: vec![
+                Value::Null,
+                Value::Bool(true),
+                Value::Number(Number::from(7)),
+                Value::Number(Number::from_f64(1.5).unwrap()),
+                Value::String("text".to_string()),
+            ]
+        })
     );
 }
 
@@ -76,13 +78,17 @@ fn parses_tuple_and_dict_values() {
 
     assert_eq!(
         document.roots,
-        Value::Dict(vec![DictEntry {
-            key: Value::String("names".to_string()),
-            value: Value::Tuple(vec![
-                Value::String("a".to_string()),
-                Value::String("b".to_string())
-            ]),
-        }])
+        Value::Tagged(TaggedValue::Dict {
+            items: vec![DictEntry {
+                key: Value::String("names".to_string()),
+                value: Value::Tagged(TaggedValue::Tuple {
+                    items: vec![
+                        Value::String("a".to_string()),
+                        Value::String("b".to_string())
+                    ]
+                }),
+            }]
+        })
     );
 }
 
@@ -96,20 +102,22 @@ fn parses_object_and_reference_values() {
     )
     .unwrap();
 
-    let Value::List(items) = document.roots else {
+    let Value::Tagged(TaggedValue::List { items }) = document.roots else {
         panic!("roots should be a list");
     };
     assert_eq!(items.len(), 2);
-    assert_eq!(items[1], Value::Ref { id: 1 });
-    let Value::Object(object) = &items[0] else {
+    assert_eq!(items[1], Value::Tagged(TaggedValue::Ref { id: 1 }));
+    let Value::Tagged(TaggedValue::Object {
+        id,
+        class_name,
+        attributes,
+    }) = &items[0]
+    else {
         panic!("first item should be an object");
     };
-    assert_eq!(object.id, 1);
-    assert_eq!(object.class_name, "renpy.ast.Label");
-    assert_eq!(
-        object.attributes["name"],
-        Value::String("start".to_string())
-    );
+    assert_eq!(*id, 1);
+    assert_eq!(class_name, "renpy.ast.Label");
+    assert_eq!(attributes["name"], Value::String("start".to_string()));
 }
 
 #[test]
@@ -122,18 +130,39 @@ fn parses_special_tag_values() {
     )
     .unwrap();
 
-    let Value::List(items) = document.roots else {
+    let Value::Tagged(TaggedValue::List { items }) = document.roots else {
         panic!("roots should be a list");
     };
     assert_eq!(items.len(), 8);
-    assert!(matches!(items[0], Value::Function(_)));
-    assert!(matches!(items[1], Value::Method(_)));
-    assert!(matches!(items[2], Value::PythonType(_)));
-    assert!(matches!(items[3], Value::Repr { .. }));
-    assert!(matches!(items[4], Value::Bytes { .. }));
-    assert!(matches!(items[5], Value::Truncated { .. }));
-    assert!(matches!(items[6], Value::Recursion { .. }));
-    assert!(matches!(items[7], Value::AttributeError { .. }));
+    assert!(matches!(
+        items[0],
+        Value::Tagged(TaggedValue::Function(_))
+    ));
+    assert!(matches!(items[1], Value::Tagged(TaggedValue::Method(_))));
+    assert!(matches!(
+        items[2],
+        Value::Tagged(TaggedValue::PythonType(_))
+    ));
+    assert!(matches!(
+        items[3],
+        Value::Tagged(TaggedValue::Repr { .. })
+    ));
+    assert!(matches!(
+        items[4],
+        Value::Tagged(TaggedValue::Bytes { .. })
+    ));
+    assert!(matches!(
+        items[5],
+        Value::Tagged(TaggedValue::Truncated { .. })
+    ));
+    assert!(matches!(
+        items[6],
+        Value::Tagged(TaggedValue::Recursion { .. })
+    ));
+    assert!(matches!(
+        items[7],
+        Value::Tagged(TaggedValue::AttributeError { .. })
+    ));
 }
 
 #[test]
@@ -141,11 +170,7 @@ fn rejects_unknown_tags() {
     let error = clew::from_bytes(document_with(r#"{"type":"future"}"#).as_bytes()).unwrap_err();
 
     match error {
-        Error::Json(error) => assert!(
-            error
-                .to_string()
-                .contains("unknown Clew value type: future")
-        ),
+        Error::Json(error) => assert!(error.to_string().contains("data did not match any variant")),
         Error::SchemaMismatch { .. } => panic!("unknown tags should be JSON shape errors"),
     }
 }