fix: actually fix string conversions, allow 'salvage' of number types

Author: arocull

godot/addons/stag_toolkit/plugin/utils.gd

@@ -57,11 +57,40 @@ static func factorial(n: int) -> float:
 ## Fetches the given key out of the dictionary, or null if not found.[br]
 ## If the fetched value does not match the specified Variant type ([code]valuetype[/code]),
 ## the value is forcibly converted to that type (applying default when necessary),
-## unless an [code]override[/code] of the same type is specified, at which point the override is used.
-static func default(dictionary: Dictionary, key: Variant, valuetype: Variant.Type, override: Variant = null) -> Variant:
-	var value: Variant = dictionary.get(key, "") # Fetch value out of dictionary
-	if typeof(value) != valuetype:
-		if typeof(override) == valuetype:
-			return override
-		return type_convert(value, valuetype)
-	return value
+## unless an [code]override[/code] of the same type is specified, at which point the override is used.[br]
+## If [code]salvage[/code] is true, similiar types (such as integers and floats)
+## are converted instead of using the provided override.
+## The override is still applied in cases where types are not similiar (such as string and float).
+static func default(
+	dictionary: Dictionary, key: Variant, valuetype: Variant.Type,
+	override: Variant = null, salvage: bool = true
+) -> Variant:
+	# Fetch value out of dictionary, or use null if nothing was returned
+	var value: Variant = dictionary.get(key, null)
+
+	# If our value was valid, use it!
+	if typeof(value) == valuetype:
+		return value
+
+	if salvage:
+		# Attempt to salvage numbers that are of similiar type
+		match valuetype:
+			TYPE_INT, TYPE_FLOAT:
+				match typeof(value):
+					TYPE_INT, TYPE_FLOAT:
+						return type_convert(value, valuetype)
+
+	# If our override matches our expected type, use it in place of our invalid value.
+	if typeof(override) == valuetype:
+		return override
+
+	# Explicit type checks:
+	# Using type_convert from a null to a string, returns "<null>"
+	# Very nice :)
+	match valuetype:
+		TYPE_STRING:
+			return ""
+		TYPE_STRING_NAME:
+			return &""
+		_: # Otherwise, attempt to convert
+			return type_convert(value, valuetype)

godot/test/scenarios/test_utils.gd

@@ -19,6 +19,8 @@ func _ready():
 		"test": "1.0",
 		"coolness": true,
 		Vector2.ZERO: 5,
+		"dumbness": null,
+		"float": 5.0,
 	}
 
 	StagTest.assert_equal(1.0, StagUtils.default(d, "test", TYPE_FLOAT), "invalid types should be converted when possible")
@@ -27,5 +29,16 @@ func _ready():
 	StagTest.assert_equal(5, StagUtils.default(d, Vector2.ZERO, TYPE_INT), "non-string keys can be used")
 	StagTest.assert_equal(false, StagUtils.default(d, "deer", TYPE_BOOL), "non-existent keys use the corresponding type fallback")
 	StagTest.assert_equal(true, StagUtils.default(d, "deer", TYPE_BOOL, true), "non-existent keys use overrides when provided")
-	StagTest.assert_equal("", StagUtils.default(d, "deer", TYPE_STRING), "non-existent keys keep empty strings")
-	StagTest.assert_true(typeof(&"") == typeof(StagUtils.default(d, "deer", TYPE_STRING_NAME)), "should retain proper type when loading default")
+	StagTest.assert_equal("", StagUtils.default(d, "deer", TYPE_STRING), "non-existent keys return empty strings")
+	StagTest.assert_true(typeof(&"") == typeof(StagUtils.default(d, "deer", TYPE_STRING_NAME)),
+		"should retain proper type when loading default")
+
+	StagTest.assert_equal("", StagUtils.default(d, "dumbness", TYPE_STRING),
+		"fetched null values are returned as empty strings")
+	StagTest.assert_equal(&"", StagUtils.default(d, "dumbness", TYPE_STRING_NAME),
+		"fetched null values are returned as empty string names")
+
+	StagTest.assert_equal(5, StagUtils.default(d, "float", TYPE_INT, 1),
+		"numbers within reason are converted")
+	StagTest.assert_equal(1, StagUtils.default(d, "float", TYPE_INT, 1, false),
+		"numbers within reason are not converted without salvage")