chore: Improve data serializer (#150)

Author: elementbound

addons/vest/plugin.cfg

@@ -3,5 +3,5 @@
 name="vest"
 description="A unit testing library for Godot"
 author="Tamás Gálffy"
-version="1.3.2"
+version="1.3.3"
 script="plugin.gd"

addons/vest/vest-data-serializer.gd

@@ -14,6 +14,11 @@ static func serialize(data: Variant, max_depth: int = MAX_DEPTH) -> Variant:
 		push_error("Data structure too deep to serialize! Is there a circular reference?")
 		return str(data)
 
+	var depth := max_depth - 1
+
+	if data == null:
+		return null
+
 	match typeof(data):
 		# Numbers
 		TYPE_BOOL, TYPE_INT, TYPE_FLOAT:
@@ -24,35 +29,76 @@ static func serialize(data: Variant, max_depth: int = MAX_DEPTH) -> Variant:
 			return str(data)
 
 		# Linalg
-		TYPE_VECTOR2, TYPE_VECTOR2I, TYPE_RECT2, TYPE_RECT2I, \
-		TYPE_VECTOR3, TYPE_VECTOR3I, TYPE_VECTOR4, TYPE_VECTOR4I, \
-		TYPE_PLANE, TYPE_QUATERNION:
-			return str(data)
+		TYPE_VECTOR2, TYPE_VECTOR2I:
+			return [data.x, data.y]
+
+		TYPE_VECTOR3, TYPE_VECTOR3I:
+			return [data.x, data.y, data.z]
+
+		TYPE_VECTOR4, TYPE_VECTOR4I, TYPE_QUATERNION:
+			return [data.x, data.y, data.z, data.w]
+
+		TYPE_RECT2, TYPE_RECT2I, TYPE_AABB:
+			return [serialize(data.position, depth), serialize(data.size, depth)]
+
+		TYPE_PLANE:
+			var plane := data as Plane
+			return [plane.x, plane.y, plane.z, plane.d, serialize(plane.normal, depth)]
+
+		TYPE_TRANSFORM2D:
+			var xform := data as Transform2D
+			return [
+				serialize(xform.x, depth),
+				serialize(xform.y, depth),
+				serialize(xform.origin, depth)
+			]
+
+		TYPE_TRANSFORM3D:
+			var xform := data as Transform3D
+			return [serialize(xform.basis, depth)] + [serialize(xform.origin, depth)]
+
+		TYPE_BASIS:
+			var basis := data as Basis
+			return [
+				serialize(basis.x, depth),
+				serialize(basis.y, depth),
+				serialize(basis.z, depth)
+			]
 
-		TYPE_TRANSFORM2D, TYPE_TRANSFORM3D, TYPE_AABB, TYPE_BASIS, \
 		TYPE_PROJECTION:
-			return str(data)
+			var projection := data as Projection
+			return [
+				serialize(projection.x, depth),
+				serialize(projection.y, depth),
+				serialize(projection.z, depth),
+				serialize(projection.w, depth)
+			]
 
 		# Other
-		TYPE_COLOR, TYPE_RID, TYPE_CALLABLE, TYPE_SIGNAL:
+		TYPE_COLOR:
+			var color := data as Color
+			return [color.r, color.g, color.b, color.a]
+
+		TYPE_RID, TYPE_CALLABLE, TYPE_SIGNAL:
 			return str(data)
 
 		# Complex
 		TYPE_OBJECT:
 			var object := data as Object
 			if object.has_method("_to_vest"):
-				return serialize(object._to_vest(), max_depth - 1)
-			return str(object) # TODO: Convert to dictionary instead
+				return serialize(object._to_vest(), depth)
+
+			return serialize(_object_to_map(object), depth)
 
 		# Arrays
 		TYPE_PACKED_BYTE_ARRAY, TYPE_PACKED_INT32_ARRAY, TYPE_PACKED_INT64_ARRAY, \
 		TYPE_PACKED_FLOAT32_ARRAY, TYPE_PACKED_FLOAT64_ARRAY, TYPE_PACKED_STRING_ARRAY, \
 		TYPE_PACKED_VECTOR2_ARRAY, TYPE_PACKED_VECTOR3_ARRAY, TYPE_PACKED_COLOR_ARRAY:
-			return serialize(Array(data), max_depth - 1)
+			return serialize(Array(data), depth)
 
 		TYPE_ARRAY:
 			var array := data as Array
-			return array.map(func(it): return serialize(it, max_depth - 1))
+			return array.map(func(it): return serialize(it, depth))
 
 		# Dictionary
 		TYPE_DICTIONARY:
@@ -61,8 +107,22 @@ static func serialize(data: Variant, max_depth: int = MAX_DEPTH) -> Variant:
 
 			for key in dict:
 				var value = dict.get(key)
-				result[serialize(key, max_depth - 1)] = serialize(value, max_depth - 1)
+				result[serialize(key, max_depth - 1)] = serialize(value, depth)
 			return result
 
 		# Default
 		_: return str(data)
+
+static func _object_to_map(object: Object) -> Dictionary:
+	var properties := object.get_property_list().map(func(prop): return prop["name"])
+	var script := object.get_script() as Script
+
+	if script != null:
+		properties = script.get_script_property_list().map(func(prop): return prop["name"])
+
+	var result := {}
+	for property in properties:
+		if property.contains(" "): continue # Skip invalid props
+		result[property] = object.get(property)
+
+	return result

tests/vest-data-serializer.test.gd

@@ -14,28 +14,21 @@ func suite():
 		["float", 78.2, 78.2],
 		["string", "foo", "foo"],
 		["array", ["foo", [1, 2]], ["foo", [1, 2]]],
+		["vector", Vector3.ONE, [1., 1., 1.]],
+		["color", Color.RED, [1., 0., 0., 1.]],
+		["basis", Basis.FLIP_X, [[-1., 0., 0.], [0., 1., 0.], [0., 0., 1.]]],
 		["PackedByteArray", PackedByteArray([1, 75, 3]), [1, 75, 3]],
-		["object", SerializableObject.of(2), { "value": 2 }],
-		["dictionary", { Vector3i.ONE: SerializableObject.of(2) }, { "(1, 1, 1)": { "value": 2 } }],
+		["serializable object", SerializableObject.of(2), { "value": 2 }],
+		["object", UnknownObject.of(2), { "_value": 2 }],
+		["dictionary", { Vector3i.ONE: SerializableObject.of(2) }, { [1, 1, 1]: { "value": 2 } }],
 		["nested",
 			{ "foo": SerializableObject.of([1, SerializableObject.of(2)]) },
 			{ "foo": { "value": [1, { "value": 2 }] } }
 		],
-		["circular reference", ref_a, { "value": { "value": { "value": { "value": "SerializableObject" }}}}]
+		["circular reference", ref_a, { "value": { "value": { "value": { "value": "SerializableObject" }}}}],
+		["null", null, null]
 	]
 
-	# Godot 4.4 stringifies slightly differently, these cases depend on version
-	if Engine.get_version_info().hex >= 0x040400:
-		cases += [
-			["vector", Vector3.ONE, "(1.0, 1.0, 1.0)"],
-			["color", Color.RED, "(1.0, 0.0, 0.0, 1.0)"]
-		]
-	else:
-		cases += [
-			["vector", Vector3.ONE, "(1, 1, 1)"],
-			["color", Color.RED, "(1, 0, 0, 1)"],
-		]
-
 	for case in cases:
 		var name := case[0] as String
 		var to_serialize = case[1]
@@ -59,3 +52,15 @@ class SerializableObject:
 
 	func _to_string() -> String:
 		return "SerializableObject"
+
+class UnknownObject:
+	var _value: Variant
+
+	static func of(p_value: Variant) -> UnknownObject:
+		return UnknownObject.new(p_value)
+
+	func _init(p_value: Variant):
+		_value = p_value
+
+	func _to_string() -> String:
+		return "UnknownObject"