gdharness 1.1.21 → 1.1.22

package/build/godot/operations/project_diagnostics.gd

@@ -25,11 +25,9 @@ func get_project_health(params: Dictionary) -> Dictionary:
 
 	# 1. Project Structure Check
 	if "structure" in check_categories:
-		var passed: bool = true
 		var details: Array[String] = []
 
 		if not FileAccess.file_exists("res://project.godot"):
-			passed = false
 			details.append("Missing project.godot file")
 			deductions += 30
 
@@ -43,7 +41,7 @@ func get_project_health(params: Dictionary) -> Dictionary:
 			details.append("Consider organizing with directories: " + ", ".join(missing_dirs))
 			deductions += 2 * missing_dirs.size()
 
-		checks["structure"] = {"name": "Project Structure", "passed": passed, "details": details}
+		checks["structure"] = {"name": "Project Structure", "passed": details.is_empty(), "details": details}
 
 	# 2. Resource Check
 	if "resources" in check_categories:
@@ -64,7 +62,10 @@ func get_project_health(params: Dictionary) -> Dictionary:
 			deductions += missing_imports
 
 		checks["resources"] = {
-			"name": "Resources", "passed": true, "details": details, "total_resources": resources.size()
+			"name": "Resources",
+			"passed": details.is_empty(),
+			"details": details,
+			"total_resources": resources.size()
 		}
 
 	# 3. Scripts Check
@@ -95,7 +96,10 @@ func get_project_health(params: Dictionary) -> Dictionary:
 			deductions += empty_functions
 
 		checks["scripts"] = {
-			"name": "Scripts", "passed": true, "details": details, "total_scripts": script_files.size()
+			"name": "Scripts",
+			"passed": details.is_empty(),
+			"details": details,
+			"total_scripts": script_files.size()
 		}
 
 	# 4. Scenes Check
@@ -108,7 +112,10 @@ func get_project_health(params: Dictionary) -> Dictionary:
 			deductions += 5
 
 		checks["scenes"] = {
-			"name": "Scenes", "passed": true, "details": details, "total_scenes": scene_files.size()
+			"name": "Scenes",
+			"passed": details.is_empty(),
+			"details": details,
+			"total_scenes": scene_files.size()
 		}
 
 	# 5. Configuration Check
@@ -119,8 +126,8 @@ func get_project_health(params: Dictionary) -> Dictionary:
 		if main_scene.is_empty():
 			details.append("No main scene configured")
 			deductions += 10
-		elif not FileAccess.file_exists(main_scene):
-			details.append("Main scene file does not exist: " + main_scene)
+		elif not FileWalk.missing_reason(main_scene).is_empty():
+			details.append("Main scene " + FileWalk.missing_reason(main_scene))
 			deductions += 15
 
 		var project_name: String = str(ProjectSettings.get_setting("application/config/name", ""))
@@ -132,7 +139,7 @@ func get_project_health(params: Dictionary) -> Dictionary:
 			details.append("No export presets configured")
 			deductions += 3
 
-		checks["config"] = {"name": "Configuration", "passed": true, "details": details}
+		checks["config"] = {"name": "Configuration", "passed": details.is_empty(), "details": details}
 
 	var score: int = maxi(0, 100 - deductions)
 
@@ -154,6 +161,14 @@ func get_project_health(params: Dictionary) -> Dictionary:
 		if not FileAccess.file_exists("res://export_presets.cfg"):
 			recommendations.append("Configure export presets for your target platforms")
 
+	# Every detail costs points, so each is an issue; `issues` was always empty beside them, and a
+	# category said passed next to the failure it had just found.
+	var issues: Array[Dictionary] = []
+	for category: String in checks:
+		var check: Dictionary = checks[category]
+		var found: Array[String] = check["details"]
+		for detail: String in found:
+			issues.append({"check": category, "detail": detail})
 	return {
-		"score": score, "grade": grade, "checks": checks, "issues": [], "recommendations": recommendations
+		"score": score, "grade": grade, "checks": checks, "issues": issues, "recommendations": recommendations
 	}

package/build/godot/operations/reading.gd

@@ -52,6 +52,23 @@ static func as_float(value: Variant, fallback: float = 0.0) -> float:
 	if value is String:
 		var text: String = value
 		return text.to_float()
+	if value is Dictionary:
+		var tagged: Dictionary = value
+		if str(tagged.get("_type", "")) == "float":
+			return non_finite(str(tagged.get("value", "")), fallback)
+	return fallback
+
+
+## The float a non-finite tag names, "inf", "-inf" or "nan", or [param fallback] for anything else.
+## JSON has no spelling for these, so the serialiser tags them rather than let them arrive as null.
+static func non_finite(word: String, fallback: float = 0.0) -> float:
+	match word:
+		"inf":
+			return INF
+		"-inf":
+			return -INF
+		"nan":
+			return NAN
 	return fallback
 
 

package/build/godot/operations/resource_files.gd

@@ -1,6 +1,14 @@
 extends RefCounted
 
 const Log = preload("logger.gd")
+const Patterns = preload("patterns.gd")
+
+## Where the engine keeps a file's UID, by what kind of file it is. Measured on 4.7.2: a script or
+## shader has a `.uid` file beside it, an imported file has it in its `.import`, and a text scene or
+## resource has it in its own header. `ResourceLoader.get_resource_uid` answers the first two in a
+## headless run and not the third, so each place is read here rather than asking it.
+const SIDECAR_KINDS: Array[String] = ["gd", "gdshader", "gdshaderinc", "cs"]
+const TEXT_RESOURCE_KINDS: Array[String] = ["tscn", "tres", "escn"]
 
 var _log: Log
 
@@ -9,7 +17,7 @@ func _init(p_log: Log) -> void:
 	_log = p_log
 
 
-# The UID the engine gave a file, from the .uid sidecar it writes beside scripts and shaders.
+# The UID the engine gave a file, read from wherever that kind of file keeps it.
 func get_uid(params: Dictionary) -> Dictionary:
 	var file_path: String = str(params.get("resource_path", ""))
 	if file_path.is_empty():
@@ -23,19 +31,54 @@ func get_uid(params: Dictionary) -> Dictionary:
 	if not FileAccess.file_exists(file_path):
 		return _log.failure("File does not exist: " + file_path)
 
-	var uid_path: String = file_path + ".uid"
-	var f: FileAccess = FileAccess.open(uid_path, FileAccess.READ)
-	if not f:
-		return {
-			"file": file_path,
-			"absolute_path": absolute_path,
-			"exists": false,
-			"message": "No .uid sidecar. refresh_uids writes one for every script and shader."
-		}
-
-	var uid_content: String = f.get_as_text()
-	f.close()
-
-	return {
-		"file": file_path, "absolute_path": absolute_path, "uid": uid_content.strip_edges(), "exists": true
-	}
+	var answer: Dictionary = {"file": file_path, "absolute_path": absolute_path}
+	var found: Dictionary = uid_of(file_path)
+	if found.is_empty():
+		answer["exists"] = false
+		answer["message"] = _why_none(file_path)
+		return answer
+	answer["exists"] = true
+	answer.merge(found)
+	return answer
+
+
+# The UID and where it was read, or empty when the file has none anywhere the engine keeps one.
+static func uid_of(file_path: String) -> Dictionary:
+	var sidecar: String = file_path + ".uid"
+	if FileAccess.file_exists(sidecar):
+		var text: String = FileAccess.get_file_as_string(sidecar).strip_edges()
+		if not text.is_empty():
+			return {"uid": text, "from": sidecar}
+	var import_file: String = file_path + ".import"
+	if FileAccess.file_exists(import_file):
+		var config: ConfigFile = ConfigFile.new()
+		if config.load(import_file) == OK and config.has_section_key("remap", "uid"):
+			return {"uid": str(config.get_value("remap", "uid")), "from": import_file}
+	if file_path.get_extension().to_lower() in TEXT_RESOURCE_KINDS:
+		var file: FileAccess = FileAccess.open(file_path, FileAccess.READ)
+		if file != null:
+			var header: String = file.get_line()
+			file.close()
+			var matched: RegExMatch = Patterns.compiled('\\buid="(uid://[^"]+)"').search(header)
+			if matched != null:
+				return {"uid": matched.get_string(1), "from": "the file's header"}
+	var id: int = ResourceLoader.get_resource_uid(file_path)
+	if id != ResourceUID.INVALID_ID:
+		return {"uid": ResourceUID.id_to_text(id), "from": "the engine"}
+	return {}
+
+
+# Why [param file_path] has no UID, and what gives it one, which depends on what kind of file it is:
+# refresh_uids writes a .uid for scripts and shaders only, and was named for every file.
+func _why_none(file_path: String) -> String:
+	var kind: String = file_path.get_extension().to_lower()
+	if kind in SIDECAR_KINDS:
+		return "No .uid file beside it. refresh_uids writes one for every script and shader."
+	if kind in TEXT_RESOURCE_KINDS:
+		return (
+			"Its header carries no uid. The editor writes one when it saves the file; refresh_uids does not,"
+			+ " and a headless save does not either."
+		)
+	if ResourceLoader.exists(file_path):
+		return "The engine keeps no UID for it."
+	return "It has not been imported, and the import is what gives it a UID: project_import reimport imports it."

package/build/godot/operations/serialisation.gd

@@ -53,6 +53,9 @@ const LIST_TYPES: Array[int] = [
 # type it wanted.
 const SERIALISERS: Dictionary = {
 	TYPE_NIL: "_serialize_nil",
+	TYPE_FLOAT: "_serialize_float",
+	TYPE_PACKED_FLOAT32_ARRAY: "_serialize_floats",
+	TYPE_PACKED_FLOAT64_ARRAY: "_serialize_floats",
 	TYPE_VECTOR2: "_serialize_vector2",
 	TYPE_VECTOR2I: "_serialize_vector2i",
 	TYPE_VECTOR3: "_serialize_vector3",
@@ -105,6 +108,8 @@ const BUILDERS: Dictionary = {
 	"Color": "_build_color",
 	"NodePath": "_build_node_path",
 	"PackedByteArray": "_build_bytes",
+	"float": "_build_float",
+	"Dictionary": "_build_dictionary",
 }
 
 # What each tag has to carry before it is built. A tag naming a type whose keys are not there is a
@@ -130,6 +135,8 @@ const REQUIRED: Dictionary = {
 	"Color": [["r", "g", "b"]],
 	"NodePath": [["path"]],
 	"PackedByteArray": [["base64"]],
+	"float": [["value"]],
+	"Dictionary": [["entries"]],
 }
 
 
@@ -145,7 +152,58 @@ func serialize_value(value: Variant) -> Variant:
 	if typeof(value) == TYPE_OBJECT and not is_instance_valid(value):
 		return null
 	var serialiser: String = SERIALISERS.get(typeof(value), "")
-	return call(serialiser, value) if not serialiser.is_empty() else value
+	if serialiser.is_empty():
+		return value
+	var carried: Variant = call(serialiser, value)
+	# The fixed shapes carry their components as bare floats, so an infinite one in a Vector2 is
+	# tagged here; containers reach their members through this function already.
+	return carried if typeof(value) in [TYPE_ARRAY, TYPE_DICTIONARY] else _finite(carried)
+
+
+# [param carried] with every non-finite float in it tagged. JSON has no spelling for infinity or
+# NaN: the engine writes 1e99999 and null, and the server, reading 1e99999 as Infinity, writes it
+# back out as null, so a property holding INF was answered as holding nothing.
+func _finite(carried: Variant) -> Variant:
+	if carried is float:
+		var number: float = carried
+		return _serialize_float(number)
+	if carried is Dictionary:
+		var fields: Dictionary = carried
+		var tagged: Dictionary = {}
+		for key: Variant in fields:
+			tagged[key] = _finite(fields[key])
+		return tagged
+	if carried is Array:
+		var items: Array = carried
+		var tagged_items: Array = []
+		for item: Variant in items:
+			tagged_items.append(_finite(item))
+		return tagged_items
+	return carried
+
+
+func _serialize_float(value: float) -> Variant:
+	if is_finite(value):
+		return value
+	return {"_type": "float", "value": "nan" if is_nan(value) else ("inf" if value > 0 else "-inf")}
+
+
+# A packed float array stays the JSON list it is unless something in it has no JSON spelling.
+func _serialize_floats(value: Variant) -> Variant:
+	var numbers: Array = []
+	if value is PackedFloat32Array:
+		var single: PackedFloat32Array = value
+		numbers = Array(single)
+	else:
+		var double: PackedFloat64Array = value
+		numbers = Array(double)
+	for number: float in numbers:
+		if not is_finite(number):
+			var items: Array = []
+			for each: float in numbers:
+				items.append(_serialize_float(each))
+			return items
+	return value
 
 
 # Rebuilds a Godot value from the shape serialize_value gave it.
@@ -181,9 +239,27 @@ func deserialize_value(value: Variant) -> Variant:
 	var needed: Array = REQUIRED.get(tag, [])
 	if builder.is_empty() or not _carries(fields, needed):
 		return fields
+	if tag == "float" and str(fields["value"]) not in ["inf", "-inf", "nan"]:
+		return fields
+	if tag == "Dictionary" and not pairs(fields["entries"]):
+		return fields
 	return call(builder, fields)
 
 
+## Whether [param entries] is a list of [key, value] pairs, as a Dictionary tag carries them.
+static func pairs(entries: Variant) -> bool:
+	if not entries is Array:
+		return false
+	var listed: Array = entries
+	for entry: Variant in listed:
+		if not entry is Array:
+			return false
+		var pair: Array = entry
+		if pair.size() != 2:
+			return false
+	return true
+
+
 ## Whether two values can be compared without the comparison itself failing.
 ##
 ## GDScript's `==` is not total. An Object against a String is a hard error rather than false, and
@@ -193,16 +269,19 @@ func deserialize_value(value: Variant) -> Variant:
 ## nothing anywhere naming the argument that did it. A wrong argument costs a refusal, never the
 ## session's game.
 ##
-## Only an object is special. Every other pair the engine answers, false where they differ, and
-## refusing those would refuse calls that work: an int against a float is the same number to a
-## caller waiting for 1 on a property holding 1.0.
+## Measured on 4.7.2 over every pair of built-in types: two values of different types compare only
+## as an int against a float, a String against a StringName, or anything against null. Every other
+## pair is that error, a word against a number as much as an object against a word, and so is a bool
+## against an int and a NodePath against a String. An int against a float is kept because it is the
+## same number to a caller waiting for 1 on a property holding 1.0.
 static func comparable(one: Variant, other: Variant) -> bool:
 	var left: int = typeof(one)
 	var right: int = typeof(other)
-	if left != TYPE_OBJECT and right != TYPE_OBJECT:
+	if left == right or left == TYPE_NIL or right == TYPE_NIL:
 		return true
-	# An object compares with another object and with null. Anything else is the error above.
-	return (left == TYPE_OBJECT or left == TYPE_NIL) and (right == TYPE_OBJECT or right == TYPE_NIL)
+	var numbers: Array[int] = [TYPE_INT, TYPE_FLOAT]
+	var texts: Array[int] = [TYPE_STRING, TYPE_STRING_NAME]
+	return (left in numbers and right in numbers) or (left in texts and right in texts)
 
 
 ## Whether [param value] can be given to something declared as [param type] without damage.
@@ -400,7 +479,16 @@ func _serialize_signal(value: Signal) -> Dictionary:
 	return described
 
 
+## A dictionary keyed by text as itself, and any other as its entries. JSON keys are text, so an
+## int or Vector2 key was answered as its text, and a dictionary read and written back had its keys
+## replaced by words: `{1: "a"}` came back as `{"1": "a"}`.
 func _serialize_dictionary(value: Dictionary) -> Dictionary:
+	var texts: bool = value.keys().all(func(key: Variant) -> bool: return key is String or key is StringName)
+	if not texts:
+		var entries: Array = []
+		for key: Variant in value:
+			entries.append([serialize_value(key), serialize_value(value[key])])
+		return {"_type": "Dictionary", "entries": entries}
 	var serialised: Dictionary = {}
 	for key: Variant in value:
 		serialised[str(key)] = serialize_value(value[key])
@@ -621,6 +709,27 @@ func _build_bytes(fields: Dictionary) -> PackedByteArray:
 	return Marshalls.base64_to_raw(str(fields.get("base64", "")))
 
 
+func _build_float(fields: Dictionary) -> float:
+	return Read.as_float(fields)
+
+
+## The entries of a dictionary whose keys are not all text. JSON carries every number as a float,
+## and a dictionary keys 1.0 apart from 1, so a whole-number key is built as an int: the key a
+## game uses far more often, and one JSON cannot tell from the float.
+func _build_dictionary(fields: Dictionary) -> Dictionary:
+	var built: Dictionary = {}
+	var entries: Array = fields["entries"]
+	for entry: Variant in entries:
+		var pair: Array = entry
+		var key: Variant = deserialize_value(pair[0])
+		if key is float:
+			var number: float = key
+			if is_finite(number) and number == floorf(number):
+				key = int(number)
+		built[key] = deserialize_value(pair[1])
+	return built
+
+
 ## One component of a compound value, as the type its constructor wants.
 ##
 ## Their own functions because a constructor refuses a Variant under `unsafe_call_argument`, and