gdharness 1.3.0 → 1.3.2

package/build/godot/operations/project_config.gd

@@ -1,15 +1,17 @@
 extends RefCounted
 
-const Read = preload("reading.gd")
-const Log = preload("logger.gd")
-const ProjectFile = preload("project_file.gd")
-const Serialisation = preload("serialisation.gd")
+const GdhFileWalk = preload("file_walk.gd")
+const GdhRead = preload("reading.gd")
+const GdhLog = preload("logger.gd")
+const GdhProjectFile = preload("project_file.gd")
+const GdhSerialisation = preload("serialisation.gd")
+const GdhShapes = preload("value_shapes.gd")
 
-var _log: Log
-var _values: Serialisation = Serialisation.new()
+var _log: GdhLog
+var _values: GdhSerialisation = GdhSerialisation.new()
 
 
-func _init(p_log: Log) -> void:
+func _init(p_log: GdhLog) -> void:
 	_log = p_log
 
 
@@ -76,7 +78,7 @@ func _settings_under(prefix: String) -> Dictionary:
 		var name: String = str(property.get("name", ""))
 		if not name.begins_with(prefix):
 			continue
-		var kind: int = Read.as_int(property.get("type", TYPE_NIL), TYPE_NIL)
+		var kind: int = GdhRead.as_int(property.get("type", TYPE_NIL), TYPE_NIL)
 		var value: Variant = ProjectSettings.get_setting(name)
 		var described: Dictionary = {
 			"setting": name,
@@ -113,12 +115,23 @@ func set_project_setting(params: Dictionary) -> Dictionary:
 	var default_value: Variant = ProjectSettings.property_get_revert(setting_path)
 	var was_default: bool = had_value and default_value != null and old_value == default_value
 
-	var final_value: Variant = _values.deserialize_value(value)
 	var wanted: int = _wanted_type(setting_path, old_value if had_value else null)
+	# A value of fields or a colour's html code is fitted as a property write fits it, so a value one
+	# of them takes the other takes too. A number is left to the check below, which refuses one the
+	# setting would cut where fitting it would cut it.
+	var final_value: Variant = _values.deserialize_value(value)
+	if final_value is Dictionary or (wanted == TYPE_COLOR and final_value is String):
+		final_value = _values.fitted(value, wanted)
 	if wanted > TYPE_NIL and final_value != null and typeof(final_value) != wanted:
 		if not _converts_faithfully(final_value, wanted):
 			return _log.failure(_cannot_hold(setting_path, wanted, final_value))
 		final_value = type_convert(final_value, wanted)
+	# JSON carries every number as a float and a new setting has no declared type to fit one to, so a
+	# whole number was saved as 800.0 beside an answer saying 800.
+	if not had_value and wanted == TYPE_NIL and final_value is float:
+		var number: float = final_value
+		if number == floorf(number) and absf(number) < 9.0e15:
+			final_value = int(number)
 
 	var answer: Dictionary = {
 		"setting_path": setting_path,
@@ -135,13 +148,36 @@ func set_project_setting(params: Dictionary) -> Dictionary:
 		answer["unchanged"] = true
 		return answer
 
+	var near: PackedStringArray = []
+	if not had_value:
+		near = _settings_near(setting_path)
+	if not near.is_empty():
+		answer["note"] = (
+			(
+				"No setting %s existed, so this wrote a new one, which the engine reads only where"
+				+ " something asks for it by that name. The nearest %s %s."
+			)
+			% [setting_path, "setting is" if near.size() == 1 else "settings are", ", ".join(near)]
+		)
 	ProjectSettings.set_setting(setting_path, final_value)
-	var err: Error = ProjectFile.save()
+	var err: Error = GdhProjectFile.save()
 	if err != OK:
 		return _log.failure("Failed to save project.godot: " + error_string(err))
 	return answer
 
 
+# The settings in the same section as [param setting_path] named nearest it, for a new one that is
+# likely a misspelt one: a setting nothing declares is written all the same, and is never read.
+static func _settings_near(setting_path: String) -> PackedStringArray:
+	var section: String = setting_path.get_slice("/", 0) + "/"
+	var names: PackedStringArray = []
+	for info: Dictionary in ProjectSettings.get_property_list():
+		var name: String = str(info.get("name", ""))
+		if name.begins_with(section) and name != setting_path:
+			var _added: bool = names.append(name)
+	return GdhRead.nearest(setting_path, names)
+
+
 # The type a setting wants, or TYPE_NIL where the engine names none and there is nothing to go on.
 #
 # JSON carries one number type, so every number arrives as a float and an int setting was written
@@ -157,7 +193,7 @@ func set_project_setting(params: Dictionary) -> Dictionary:
 func _wanted_type(setting_path: String, current: Variant) -> int:
 	for info: Dictionary in ProjectSettings.get_property_list():
 		if str(info.get("name", "")) == setting_path:
-			return Read.as_int(info.get("type", TYPE_NIL), TYPE_NIL)
+			return GdhRead.as_int(info.get("type", TYPE_NIL), TYPE_NIL)
 	return typeof(current)
 
 
@@ -181,19 +217,20 @@ static func _cannot_hold(setting_path: String, wanted: int, value: Variant) -> S
 	if wanted in numbers and typeof(value) in numbers:
 		return "%s, and %s is not the same number as one.%s" % [declared, str(value), cost]
 	var given: String = type_string(typeof(value))
-	return "%s, and %s (%s) cannot become one." % [declared, JSON.stringify(value), given]
+	var remedy: String = GdhShapes.remedy(value, wanted)
+	return "%s, and %s (%s) cannot become one.%s" % [declared, JSON.stringify(value), given, remedy]
 
 
 # Add an autoload singleton
 func add_autoload(params: Dictionary) -> Dictionary:
 	var name: String = str(params.get("name", ""))
 	var path: String = str(params.get("path", ""))
-	var global: bool = Read.as_bool(params.get("global", true), true)
+	var global: bool = GdhRead.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):
+	if not GdhRead.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"
@@ -208,7 +245,9 @@ func add_autoload(params: Dictionary) -> Dictionary:
 	_log.info("Adding autoload: " + name + " -> " + path)
 
 	if not FileAccess.file_exists(path):
-		return _log.failure("Autoload file does not exist: " + path)
+		return _log.failure(
+			GdhFileWalk.new().with_nearest_files("Autoload file does not exist: " + path, path)
+		)
 
 	# Through ProjectSettings so the file is saved the way the editor saves it, which includes
 	# putting Godot's header back and dropping any comment somebody wrote into the file by hand.
@@ -218,8 +257,18 @@ func add_autoload(params: Dictionary) -> Dictionary:
 	# 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 = ProjectFile.save()
+	var entry: String = ("*" if global else "") + path
+	if was_updated and str(ProjectSettings.get_setting(setting)) == entry:
+		return {
+			"name": name,
+			"path": path,
+			"enabled": true,
+			"global": global,
+			"action": "unchanged",
+			"saved": false
+		}
+	ProjectSettings.set_setting(setting, entry)
+	var err: Error = GdhProjectFile.save()
 	if err != OK:
 		return _log.failure("Failed to save project.godot: " + error_string(err))
 
@@ -229,6 +278,7 @@ func add_autoload(params: Dictionary) -> Dictionary:
 		"enabled": true,
 		"global": global,
 		"action": "updated" if was_updated else "added",
+		"saved": true,
 	}
 
 
@@ -244,7 +294,7 @@ func remove_autoload(params: Dictionary) -> Dictionary:
 
 	var old_value: String = str(ProjectSettings.get_setting(setting))
 	ProjectSettings.set_setting(setting, null)
-	var err: Error = ProjectFile.save()
+	var err: Error = GdhProjectFile.save()
 	if err != OK:
 		return _log.failure("Failed to save project.godot: " + error_string(err))
 
@@ -288,12 +338,25 @@ func set_main_scene(params: Dictionary) -> Dictionary:
 	_log.info("Setting main scene: " + scene_path)
 
 	if not FileAccess.file_exists(scene_path):
-		return _log.failure("Scene file does not exist: " + scene_path)
+		return _log.failure(
+			GdhFileWalk.new().with_nearest_files("Scene file does not exist: " + scene_path, scene_path)
+		)
+
+	# The engine starts the game by instancing the main scene, so a script or any other resource set
+	# there was saved and answered as set, and the game then would not start.
+	if not ResourceLoader.exists(scene_path, "PackedScene"):
+		var loaded: Resource = ResourceLoader.load(scene_path, "", ResourceLoader.CACHE_MODE_IGNORE)
+		var kind: String = loaded.get_class() if loaded != null else ""
+		var said: String = (
+			"%s is %s, not a scene, and the main scene has to be one"
+			% [scene_path, "a " + kind if not kind.is_empty() else "no resource the engine loads"]
+		)
+		return _log.failure(GdhFileWalk.new().with_nearest_files(said, scene_path.get_basename() + ".tscn"))
 
 	var old_main_scene: String = str(ProjectSettings.get_setting("application/run/main_scene", ""))
 
 	ProjectSettings.set_setting("application/run/main_scene", scene_path)
-	var err: Error = ProjectFile.save()
+	var err: Error = GdhProjectFile.save()
 
 	if err != OK:
 		return _log.failure("Failed to save project settings: " + str(err))

package/build/godot/operations/project_diagnostics.gd

@@ -1,21 +1,24 @@
 extends RefCounted
 
-const FileWalk = preload("file_walk.gd")
-const ImportPipeline = preload("import_pipeline.gd")
-const Log = preload("logger.gd")
+const GdhDependencies = preload("dependencies.gd")
+const GdhFileWalk = preload("file_walk.gd")
+const GdhImportPipeline = preload("import_pipeline.gd")
+const GdhLog = preload("logger.gd")
+const GdhRead = preload("reading.gd")
+const GdhScriptCheck = preload("script_check.gd")
 
-var _log: Log
-var _files: FileWalk = FileWalk.new()
+var _log: GdhLog
+var _files: GdhFileWalk = GdhFileWalk.new()
 
 
-func _init(p_log: Log) -> void:
+func _init(p_log: GdhLog) -> void:
 	_log = p_log
 
 
 # Get comprehensive project health check with scoring
 func get_project_health(params: Dictionary) -> Dictionary:
 	var check_categories: Array = params.get(
-		"categories", ["structure", "resources", "scripts", "scenes", "config"]
+		"categories", ["structure", "resources", "scripts", "references", "scenes", "config"]
 	)
 
 	_log.info("Performing project health check")
@@ -44,7 +47,7 @@ func get_project_health(params: Dictionary) -> Dictionary:
 		# Every format the engine imports, the list the import status reads: five of them were checked
 		# here, so a project of glTF models, fonts and WebP textures had nothing to reimport.
 		var resources: Array[String] = _files.find_files_with_extensions(
-			"res://", ImportPipeline.IMPORTABLE_EXTENSIONS
+			"res://", GdhImportPipeline.IMPORTABLE_EXTENSIONS
 		)
 
 		var missing_imports: int = 0
@@ -87,12 +90,34 @@ func get_project_health(params: Dictionary) -> Dictionary:
 		if todo_count > 0:
 			recommendations.append("%d scripts have TODO or FIXME comments to look at" % todo_count)
 
-		checks["scripts"] = {
+		# Compiled by the server before this runs, since an engine stops at the first script that
+		# fails, and handed in. Without it the check read only comments and said "passed" beside
+		# scripts the engine refused.
+		var compiled: Dictionary = params.get("compiled", {})
+		var failures: Array = compiled.get("failures", [])
+		for failure: Dictionary in failures:
+			details.append(GdhScriptCheck.failure_line(failure))
+			deductions += 10
+
+		var scripts: Dictionary = {
 			"name": "Scripts",
 			"passed": details.is_empty(),
 			"details": details,
 			"total_scripts": script_files.size()
 		}
+		if compiled.has("checked"):
+			scripts["compiled"] = GdhRead.as_int(compiled["checked"])
+		else:
+			scripts["not_compiled"] = str(compiled.get("not_checked", "no compile was asked for"))
+		checks["scripts"] = scripts
+
+	# 3b. References
+	if "references" in check_categories:
+		var details: Array[String] = []
+		for entry: Dictionary in GdhDependencies.new(_log).missing_references():
+			details.append(GdhDependencies.missing_line(entry))
+			deductions += 5
+		checks["references"] = {"name": "References", "passed": details.is_empty(), "details": details}
 
 	# 4. Scenes Check
 	if "scenes" in check_categories:
@@ -119,8 +144,8 @@ func get_project_health(params: Dictionary) -> Dictionary:
 		if main_scene.is_empty():
 			details.append("No main scene configured")
 			deductions += 10
-		elif not FileWalk.missing_reason(main_scene).is_empty():
-			details.append("Main scene " + FileWalk.missing_reason(main_scene))
+		elif not GdhFileWalk.missing_reason(main_scene).is_empty():
+			details.append("Main scene " + GdhFileWalk.missing_reason(main_scene))
 			deductions += 15
 
 		var project_name: String = str(ProjectSettings.get_setting("application/config/name", ""))