gdharness 1.1.21 → 1.1.23

package/build/godot/operations/plugins.gd

@@ -24,48 +24,63 @@ func list_plugins(_params: Dictionary) -> Dictionary:
 			"message": "No addons directory found in the project"
 		}
 
-	var enabled_plugins: Array[String] = _enabled_plugin_names()
-	_log.debug("Enabled plugins: " + str(enabled_plugins))
+	var enabled_paths: Array[String] = _enabled_paths()
+	_log.debug("Enabled plugins: " + str(enabled_paths))
 
 	var plugins: Array[Dictionary] = []
 	var enabled_count: int = 0
-
-	var dir: DirAccess = DirAccess.open(addons_path)
-	if dir and dir.list_dir_begin() == OK:
-		var folder_name: String = dir.get_next()
-
-		while folder_name != "":
-			if dir.current_is_dir() and not folder_name.begins_with("."):
-				var plugin_cfg_path: String = addons_path + folder_name + "/plugin.cfg"
-
-				if FileAccess.file_exists(plugin_cfg_path):
-					var enabled: bool = folder_name in enabled_plugins
-					var plugin_info: Dictionary = {
-						"name": folder_name, "path": addons_path + folder_name, "enabled": enabled
-					}
-
-					var plugin_config: ConfigFile = ConfigFile.new()
-					if plugin_config.load(plugin_cfg_path) == OK:
-						plugin_info["display_name"] = plugin_config.get_value("plugin", "name", folder_name)
-						plugin_info["description"] = plugin_config.get_value("plugin", "description", "")
-						plugin_info["author"] = plugin_config.get_value("plugin", "author", "")
-						plugin_info["version"] = plugin_config.get_value("plugin", "version", "")
-						plugin_info["script"] = plugin_config.get_value("plugin", "script", "")
-
-					plugins.append(plugin_info)
-					if enabled:
-						enabled_count += 1
-
-			folder_name = dir.get_next()
-
-		dir.list_dir_end()
-
-	return {
+	for folder: String in _plugin_folders(addons_path):
+		var plugin_cfg_path: String = folder.path_join("plugin.cfg")
+		var name: String = folder.trim_prefix(addons_path)
+		var enabled: bool = plugin_cfg_path in enabled_paths
+		var plugin_info: Dictionary = {"name": name, "path": folder, "enabled": enabled}
+
+		var plugin_config: ConfigFile = ConfigFile.new()
+		if plugin_config.load(plugin_cfg_path) == OK:
+			plugin_info["display_name"] = plugin_config.get_value("plugin", "name", name)
+			plugin_info["description"] = plugin_config.get_value("plugin", "description", "")
+			plugin_info["author"] = plugin_config.get_value("plugin", "author", "")
+			plugin_info["version"] = plugin_config.get_value("plugin", "version", "")
+			plugin_info["script"] = plugin_config.get_value("plugin", "script", "")
+
+		plugins.append(plugin_info)
+		if enabled:
+			enabled_count += 1
+
+	var answer: Dictionary = {
 		"plugins": plugins,
 		"addons_directory_exists": true,
 		"enabled_count": enabled_count,
 		"disabled_count": plugins.size() - enabled_count
 	}
+	# Enabled in the project with no plugin.cfg where the entry points: the editor reports each one
+	# as an error at every start and loads nothing for it.
+	var missing: Array[String] = []
+	for path: String in enabled_paths:
+		if not FileAccess.file_exists(path):
+			missing.append(path)
+	if not missing.is_empty():
+		answer["enabled_but_missing"] = missing
+	return answer
+
+
+# Every folder under [param root] holding a plugin.cfg, at any depth, the way the editor's plugin
+# list finds them: a folder with one is a plugin and is not looked inside, and one without is
+# searched. Only the top level was read, so a plugin one folder down was never listed.
+func _plugin_folders(root: String) -> Array[String]:
+	var found: Array[String] = []
+	var dir: DirAccess = DirAccess.open(root)
+	if dir == null:
+		return found
+	for folder_name: String in dir.get_directories():
+		if folder_name.begins_with("."):
+			continue
+		var folder: String = root.path_join(folder_name)
+		if FileAccess.file_exists(folder.path_join("plugin.cfg")):
+			found.append(folder)
+		else:
+			found.append_array(_plugin_folders(folder))
+	return found
 
 
 # Enable a plugin
@@ -79,19 +94,19 @@ func enable_plugin(params: Dictionary) -> Dictionary:
 		_log.error("Plugin not found: " + plugin_name)
 		return _log.failure("Expected plugin.cfg at: " + plugin_cfg_path)
 
-	var enabled_plugins: Array[String] = _enabled_plugin_names()
+	var enabled_paths: Array[String] = _enabled_paths()
 
-	if plugin_name in enabled_plugins:
+	if plugin_cfg_path in enabled_paths:
 		return {
 			"plugin_name": plugin_name, "action": "already_enabled", "message": "Plugin is already enabled"
 		}
 
-	enabled_plugins.append(plugin_name)
-	var err: Error = _save_enabled_plugins(enabled_plugins)
+	enabled_paths.append(plugin_cfg_path)
+	var err: Error = _save_enabled_paths(enabled_paths)
 	if err != OK:
 		return _log.failure("Failed to save project.godot: " + error_string(err))
 
-	return {"plugin_name": plugin_name, "action": "enabled", "enabled_plugins": enabled_plugins}
+	return {"plugin_name": plugin_name, "action": "enabled", "enabled_plugins": _names_of(enabled_paths)}
 
 
 # Disable a plugin
@@ -100,42 +115,50 @@ func disable_plugin(params: Dictionary) -> Dictionary:
 
 	_log.info("Disabling plugin: " + plugin_name)
 
-	var enabled_plugins: Array[String] = _enabled_plugin_names()
+	var enabled_paths: Array[String] = _enabled_paths()
+	var plugin_cfg_path: String = "res://addons/" + plugin_name + "/plugin.cfg"
 
-	if not plugin_name in enabled_plugins:
+	if not plugin_cfg_path in enabled_paths:
 		return {
 			"plugin_name": plugin_name,
 			"action": "already_disabled",
 			"message": "Plugin is not currently enabled"
 		}
 
-	enabled_plugins.erase(plugin_name)
-	var err: Error = _save_enabled_plugins(enabled_plugins)
+	enabled_paths.erase(plugin_cfg_path)
+	var err: Error = _save_enabled_paths(enabled_paths)
 	if err != OK:
 		return _log.failure("Failed to save project.godot: " + error_string(err))
 
-	return {"plugin_name": plugin_name, "action": "disabled", "enabled_plugins": enabled_plugins}
+	return {"plugin_name": plugin_name, "action": "disabled", "enabled_plugins": _names_of(enabled_paths)}
 
 
-# The addon directory names in [editor_plugins]. The editor stores them as the engine
-# expression PackedStringArray("res://addons/<name>/plugin.cfg", ...), which loads as that
-# type; the String form is what an older hand-edited file can carry.
-func _enabled_plugin_names() -> Array[String]:
-	var names: Array[String] = []
-	var regex: RegEx = Patterns.compiled("res://addons/([^/]+)/plugin.cfg")
-
+# Every entry in [editor_plugins], as the plugin.cfg path the editor stores. Paths rather than
+# folder names, because the list is written back whole: reading names off a pattern for
+# `res://addons/<name>/plugin.cfg` dropped a plugin one folder down, and the next enable or disable
+# wrote the list without it, disabling a plugin nobody named. The editor stores the engine
+# expression PackedStringArray(...), which loads as that type; the String form is what an older
+# hand-edited file can carry.
+func _enabled_paths() -> Array[String]:
+	var paths: Array[String] = []
 	var enabled_value: Variant = ProjectSettings.get_setting("editor_plugins/enabled", PackedStringArray())
 	if enabled_value is PackedStringArray:
-		var paths: PackedStringArray = enabled_value
-		for path: String in paths:
-			var m: RegExMatch = regex.search(path)
-			if m:
-				names.append(m.get_string(1))
+		var packed: PackedStringArray = enabled_value
+		paths.assign(packed)
 	elif enabled_value is String:
 		var listed: String = enabled_value
-		for m: RegExMatch in regex.search_all(listed):
-			names.append(m.get_string(1))
+		for m: RegExMatch in Patterns.compiled("res://[^\"',)]+?plugin\\.cfg").search_all(listed):
+			paths.append(m.get_string())
+	return paths
 
+
+# The names callers use for [param paths]: the folder under addons/, or the path itself for an
+# entry somewhere else.
+static func _names_of(paths: Array[String]) -> Array[String]:
+	var names: Array[String] = []
+	for path: String in paths:
+		var inside: bool = path.begins_with("res://addons/") and path.ends_with("/plugin.cfg")
+		names.append(path.trim_prefix("res://addons/").trim_suffix("/plugin.cfg") if inside else path)
 	return names
 
 
@@ -145,19 +168,14 @@ func _enabled_plugin_names() -> Array[String]:
 # the unquoted expression the editor reads, whereas the same text handed over as a String is
 # written quoted and loads as a String the editor does not recognise as a plugin list. An
 # empty list is the setting removed, which is what the editor writes for no plugins.
-func _save_enabled_plugins(names: Array[String]) -> Error:
-	if names.is_empty():
+func _save_enabled_paths(paths: Array[String]) -> Error:
+	if paths.is_empty():
 		ProjectSettings.set_setting("editor_plugins/enabled", null)
 		return ProjectSettings.save()
 
-	# Gathered in an Array[String] and converted at the end, because appending to a packed array
-	# answers with whether it worked and a project holding return_value_discarded at error level
-	# will not compile a script that drops that answer. The conversion is what matters: an
-	# Array[String] handed to set_setting is written as Array[String]([...]), which the editor does
-	# not read as a plugin list at all.
-	var enabled_paths: Array[String] = []
-	for name: String in names:
-		enabled_paths.append("res://addons/" + name + "/plugin.cfg")
-
-	ProjectSettings.set_setting("editor_plugins/enabled", PackedStringArray(enabled_paths))
+	# Kept in an Array[String] and converted here, because appending to a packed array answers with
+	# whether it worked and a project holding return_value_discarded at error level will not compile
+	# a script that drops that answer. The conversion is what matters: an Array[String] handed to
+	# set_setting is written as Array[String]([...]), which the editor does not read as a plugin list.
+	ProjectSettings.set_setting("editor_plugins/enabled", PackedStringArray(paths))
 	return ProjectSettings.save()

package/build/godot/operations/project_config.gd

@@ -34,6 +34,19 @@ func get_project_setting(params: Dictionary) -> Dictionary:
 		result["value"] = null
 		result["message"] = "Setting does not exist"
 
+	# The value under this name is not the one every build reads: `name.windows` replaces it on
+	# Windows, `name.editor` in the editor. Read alone, a caller saw the plain value and not the one
+	# their game showed.
+	var overrides: Dictionary = {}
+	for info: Dictionary in ProjectSettings.get_property_list():
+		var name: String = str(info.get("name", ""))
+		if name.begins_with(setting_path + "."):
+			overrides[name.substr(setting_path.length() + 1)] = _values.serialize_value(
+				ProjectSettings.get_setting(name)
+			)
+	if not overrides.is_empty():
+		result["overrides"] = overrides
+
 	return result
 
 
@@ -139,7 +152,19 @@ func _converts_faithfully(value: Variant, to: int) -> bool:
 func add_autoload(params: Dictionary) -> Dictionary:
 	var name: String = str(params.get("name", ""))
 	var path: String = str(params.get("path", ""))
-	var enabled: bool = Read.as_bool(params.get("enabled", true), true)
+	var global: bool = Read.as_bool(params.get("global", true), true)
+
+	# There is no disabled autoload in Godot 4: every entry in the list is loaded under the root at
+	# every start. `enabled: false` used to write the entry without its asterisk and answer that it
+	# was disabled, and the autoload ran all the same.
+	if not Read.as_bool(params.get("enabled", true), true):
+		return _log.failure(
+			(
+				"An autoload cannot be added disabled: Godot loads every autoload in the list at every"
+				+ " start. global: false keeps its name out of the global scope and still loads it;"
+				+ " remove_autoload is what stops it loading"
+			)
+		)
 
 	if not path.begins_with("res://"):
 		path = "res://" + path
@@ -154,14 +179,21 @@ func add_autoload(params: Dictionary) -> Dictionary:
 	var setting: String = "autoload/" + name
 	var was_updated: bool = ProjectSettings.has_setting(setting)
 
-	# An asterisk in front of the path makes the autoload a global name as well. Without it the
-	# node still comes up under the root; only the name stops resolving.
-	ProjectSettings.set_setting(setting, ("*" if enabled else "") + path)
+	# An asterisk in front of the path makes the autoload's name a global variable, the editor's
+	# "Global Variable" column. Without it the node still comes up under the root; only the name
+	# stops resolving.
+	ProjectSettings.set_setting(setting, ("*" if global else "") + path)
 	var err: Error = ProjectSettings.save()
 	if err != OK:
 		return _log.failure("Failed to save project.godot: " + error_string(err))
 
-	return {"name": name, "path": path, "enabled": enabled, "action": "updated" if was_updated else "added"}
+	return {
+		"name": name,
+		"path": path,
+		"enabled": true,
+		"global": global,
+		"action": "updated" if was_updated else "added",
+	}
 
 
 # Remove an autoload singleton
@@ -196,10 +228,13 @@ func list_autoloads(_params: Dictionary) -> Dictionary:
 		var value: String = str(ProjectSettings.get_setting(setting))
 		var path: String = value.trim_prefix("*")
 
+		# Enabled whatever the asterisk says, because every autoload listed is loaded; the asterisk
+		# is whether its name is a global variable.
 		var autoload_info: Dictionary = {
 			"name": setting.trim_prefix("autoload/"),
 			"path": path,
-			"enabled": value.begins_with("*"),
+			"enabled": true,
+			"global": value.begins_with("*"),
 			"file_exists": FileAccess.file_exists(path),
 		}
 		autoloads.append(autoload_info)

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,20 +96,27 @@ 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
 	if "scenes" in check_categories:
 		var details: Array[String] = []
 
-		var scene_files: Array[String] = _files.find_files("res://", ".tscn")
+		# Binary scenes too, which a project may save instead and which counted as none.
+		var scene_files: Array[String] = _files.find_files_with_extensions("res://", ["tscn", "scn"])
 		if scene_files.size() == 0:
 			details.append("No scene files found in project")
 			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 +127,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 +140,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 +162,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."