gdharness 1.3.40 → 1.3.42

package/build/godot/operations/file_walk.gd

@@ -35,8 +35,24 @@ static func missing_reason(path: String) -> String:
 
 ## [param said], the refusal for [param path], a res:// path nothing is at, with the files of its
 ## extension whose names are nearest its own, or every one when there are few and none is near, so
-## the caller has a path to send instead.
+## the caller has a path to send instead. Files of the same name beside it come first, since a
+## misspelt extension has no file of its own extension to be near.
 func with_nearest_files(said: String, path: String) -> String:
+	# One the refusal names is the file it refuses, as a script given for a scene is. Word by word,
+	# since res://brain.gd is inside res://brain.gdd.
+	var named: Array[String] = []
+	for word: String in said.replace("\n", " ").replace(",", " ").replace(";", " ").split(" ", false):
+		named.append(word.rstrip(".:"))
+	var namesakes: Array[String] = []
+	for file: String in _namesakes(path):
+		if not file in named:
+			namesakes.append(file)
+	if not namesakes.is_empty():
+		var alone: bool = namesakes.size() == 1
+		return (
+			"%s. The %s of that name beside it %s %s."
+			% [said, "file" if alone else "files", "is" if alone else "are", ", ".join(namesakes)]
+		)
 	var extension: String = path.get_extension()
 	if extension.is_empty():
 		return said
@@ -65,6 +81,22 @@ func with_nearest_files(said: String, path: String) -> String:
 	return "%s. None of the project's %d .%s files is named like it." % [said, files.size(), extension]
 
 
+# The files in [param path]'s folder named as it is with another extension, leaving out the import
+# and uid files the engine keeps beside a file, which are named after the whole file name.
+static func _namesakes(path: String) -> Array[String]:
+	var found: Array[String] = []
+	var folder: String = path.get_base_dir()
+	if not DirAccess.dir_exists_absolute(folder):
+		return found
+	var stem: String = path.get_file().get_basename()
+	var files: PackedStringArray = DirAccess.get_files_at(folder)
+	files.sort()
+	for file: String in files:
+		if file.get_basename() == stem and file != path.get_file():
+			found.append(folder.path_join(file))
+	return found
+
+
 # A directory the engine steps over, marker file and all.
 func is_stepped_over(path: String) -> bool:
 	return FileAccess.file_exists(path + ".gdignore")

package/build/godot/operations/gdscript_analysis.gd

@@ -249,6 +249,16 @@ func _members(
 				i += 1
 				stripped = (stripped + " " + GdhPatterns.without_comment(lines[i])).strip_edges()
 			header = GdhPatterns.without_annotations(stripped)
+		# A value that opens a triple-quoted string ends where the string does, and read from its
+		# first line alone it was the opening quotes and the text up to the line break.
+		if in_multiline_string and (header.begins_with("const ") or _declares_variable(header)):
+			while i + 1 < lines.size():
+				i += 1
+				stripped += "\n" + lines[i]
+				if _triple_quotes(lines[i]) % 2 == 1:
+					break
+			in_multiline_string = false
+			header = GdhPatterns.without_annotations(stripped)
 		var declaration: RegExMatch = GdhPatterns.declared_class(header)
 		var entry: Dictionary = {}
 		if declaration != null:
@@ -273,7 +283,7 @@ func _members(
 		elif header.begins_with("enum "):
 			entry = _parse_enum(header, at + 1)
 			own.enums.append(entry)
-		elif header.begins_with("var ") or header.begins_with("static var "):
+		elif _declares_variable(header):
 			# The whole line here, not the header: which annotations a variable carries is the
 			# answer rather than noise in front of it, and `@export_range(0, 1)` is the hint.
 			entry = _parse_variable(stripped, at + 1)
@@ -602,6 +612,10 @@ func _parse_variable(line: String, line_num: int) -> Dictionary:
 		return {"name": "", "line": line_num}
 
 	var var_text: String = line.substr(var_pos + 4).strip_edges()
+	# A colon closing the line opens the variable's setter and getter, and was read as the end of
+	# its default: `= Kind.ROUND:`.
+	if var_text.ends_with(":"):
+		var_text = var_text.left(-1).strip_edges()
 	var name: String = ""
 	var type_hint: String = ""
 	var default_value: String = ""
@@ -847,6 +861,10 @@ func _collect_dependencies(line: String, into: Array[String]) -> void:
 
 
 # How many triple quotes of either kind [param line] holds.
+static func _declares_variable(header: String) -> bool:
+	return header.begins_with("var ") or header.begins_with("static var ")
+
+
 static func _triple_quotes(line: String) -> int:
 	return line.count('"""') + line.count("'''")
 

package/build/godot/operations/gdscript_authoring.gd

@@ -100,6 +100,9 @@ func create_gdscript(params: Dictionary) -> Dictionary:
 	file.close()
 	if not stored:
 		return _log.failure("Failed to write to script file: " + full_script_path)
+	# The editor gives a script it makes a .uid beside it. A headless engine writes none until the
+	# project is imported, so a script made here was missing from every check tracking the sidecars.
+	var uid: String = _uid_beside(full_script_path)
 
 	var written: Script = ResourceLoader.load(full_script_path, "Script", ResourceLoader.CACHE_MODE_IGNORE)
 	var parses: bool = _parses(written)
@@ -110,7 +113,10 @@ func create_gdscript(params: Dictionary) -> Dictionary:
 		"absolute_path": ProjectSettings.globalize_path(full_script_path),
 		"template_used": template if not template.is_empty() else "none",
 		"parses": parses,
+		"uid": null,
 	}
+	if not uid.is_empty():
+		answer["uid"] = uid
 	# Read off the file as the engine parsed it rather than off the arguments, which content leaves
 	# out. A script that does not parse tells the engine nothing, and its empty base and name were
 	# answered for a file whose header says otherwise, so those are read off the text instead.
@@ -125,6 +131,22 @@ func create_gdscript(params: Dictionary) -> Dictionary:
 	return answer
 
 
+## The uid in the .uid file beside [param path], written first when there is none, as the editor
+## writes it for a script it makes; empty when it could not be written. A sidecar already there is
+## the one the engine reads the script's uid from, so it is kept.
+static func _uid_beside(path: String) -> String:
+	var sidecar: String = path + ".uid"
+	if FileAccess.file_exists(sidecar):
+		return FileAccess.get_file_as_string(sidecar).strip_edges()
+	var text: String = ResourceUID.id_to_text(ResourceUID.create_id_for_path(path))
+	var file: FileAccess = FileAccess.open(sidecar, FileAccess.WRITE)
+	if file == null:
+		return ""
+	var stored: bool = file.store_string(text + "\n")
+	file.close()
+	return text if stored else ""
+
+
 ## The refusal for [param path], which is no GDScript file, naming what [param doing] it instead:
 ## a shader is made with resource_edit, and once it exists its text is edited as a file's.
 static func _not_gdscript(path: String, doing: String) -> String:
@@ -404,6 +426,14 @@ static func _modification_problems(modifications: Array, declared: Dictionary) -
 			)
 		if mod_type == "add_constant" and str(fields.get("defaultValue", "")).is_empty():
 			problems.append(which + " is a constant with no defaultValue, and a constant needs a value")
+		if (
+			not str(fields.get("exportHint", "")).is_empty()
+			and fields.has("isExport")
+			and not GdhRead.as_bool(fields["isExport"])
+		):
+			problems.append(
+				which + " has an exportHint and isExport false, and a hint is written only on an export"
+			)
 		if mod_name.is_empty():
 			problems.append(which + " has no name")
 			continue
@@ -527,8 +557,9 @@ func _add_variable(lines: Array[String], mod: Dictionary, placed: Array[Dictiona
 	var var_name: String = str(mod.get("name", ""))
 	var var_type: String = str(mod.get("varType", ""))
 	var default_value: String = str(mod.get("defaultValue", ""))
-	var is_export: bool = GdhRead.as_bool(mod.get("isExport", false))
 	var export_hint: String = str(mod.get("exportHint", ""))
+	# A hint can only mean an export, so a hint given alone writes one.
+	var is_export: bool = GdhRead.as_bool(mod.get("isExport", not export_hint.is_empty()))
 	var is_onready: bool = GdhRead.as_bool(mod.get("isOnready", false))
 
 	var var_line: String = ""
@@ -631,9 +662,24 @@ func _add_function(lines: Array[String], mod: Dictionary, placed: Array[Dictiona
 
 	# The body's statements relative to the function, whether or not the caller indented them for
 	# it: a body written with its tab already on came out two levels in. A blank line stays empty,
-	# since an indent alone on it is trailing whitespace to every formatter.
-	for bl: String in body.dedent().split("\n"):
-		func_lines.append("" if bl.strip_edges().is_empty() else "\t" + bl)
+	# since an indent alone on it is trailing whitespace to every formatter. Each level is the
+	# file's own unit, because the engine refuses a file indented with spaces in one place and tabs
+	# in another, so a tab put into a script indented with spaces stopped it parsing.
+	var unit: String = _indent_unit(lines)
+	var body_lines: Array[String] = []
+	body_lines.assign(body.dedent().strip_edges(false, true).split("\n"))
+	var given_unit: String = _indent_unit(body_lines)
+	for bl: String in body_lines:
+		if bl.strip_edges().is_empty():
+			func_lines.append("")
+			continue
+		var stripped: String = bl.lstrip(" \t")
+		var leading: String = bl.substr(0, bl.length() - stripped.length())
+		var levels: int = floori(float(leading.length()) / given_unit.length())
+		if leading != given_unit.repeat(levels):
+			func_lines.append(unit + bl)
+			continue
+		func_lines.append(unit.repeat(levels + 1) + stripped)
 
 	var below: int = _blank_run(lines, insert_line, 1)
 	if insert_line + below < lines.size():
@@ -645,6 +691,21 @@ func _add_function(lines: Array[String], mod: Dictionary, placed: Array[Dictiona
 	return declared_at if _insert(lines, insert_line, func_lines, placed) else -1
 
 
+## One level of indentation in [param lines]: what the first line indented below an unindented
+## line ending a block opens with, or a tab, the engine's default, when no line is.
+static func _indent_unit(lines: Array[String]) -> String:
+	var opener: bool = false
+	for line: String in lines:
+		var stripped: String = line.strip_edges()
+		if stripped.is_empty() or stripped.begins_with("#"):
+			continue
+		var leading: String = line.substr(0, line.length() - line.lstrip(" \t").length())
+		if opener and not leading.is_empty():
+			return leading
+		opener = leading.is_empty() and stripped.ends_with(":")
+	return "\t"
+
+
 # How many blank lines run from [param from] on in the direction of [param step], 1 or -1.
 static func _blank_run(lines: Array[String], from: int, step: int) -> int:
 	var count: int = 0

package/build/godot/operations/import_pipeline.gd

@@ -408,7 +408,7 @@ func _import_status_of(resource_path: String, import_file_path: String) -> Dicti
 # Why [param resource_path] has no import file, with what to do about it where anything can be done.
 func _no_sidecar(resource_path: String) -> String:
 	if not FileAccess.file_exists(resource_path):
-		return resource_path + " is not on disk"
+		return GdhFileWalk.new().with_nearest_files(resource_path + " is not on disk", resource_path)
 	var never: String = _never_imported(resource_path)
 	if not never.is_empty():
 		return resource_path + " has no import options: " + never

package/build/godot/operations/input_actions.gd

@@ -280,6 +280,7 @@ func add_input_action(params: Dictionary) -> Dictionary:
 		"deadzone": deadzone,
 		"events": events_config,
 		"was_new": not ProjectSettings.has_setting(setting),
+		"saved": true,
 	}
 	if not answer["was_new"]:
 		var old_events: Array[Dictionary] = []

package/build/godot/operations/plugins.gd

@@ -107,7 +107,45 @@ func enable_plugin(params: Dictionary) -> Dictionary:
 	if err != OK:
 		return _log.failure("Failed to save project.godot: " + error_string(err))
 
-	return {"plugin_name": plugin_name, "action": "enabled", "enabled_plugins": _names_of(enabled_paths)}
+	var answer: Dictionary = {
+		"plugin_name": plugin_name, "action": "enabled", "enabled_plugins": _names_of(enabled_paths)
+	}
+	var unloadable: String = _why_not_loaded(plugin_cfg_path)
+	if not unloadable.is_empty():
+		answer["note"] = unloadable
+	return answer
+
+
+# What the editor finds wrong with the plugin at [param plugin_cfg_path] when it loads it, the checks
+# EditorNode::set_addon_plugin_enabled makes, or "" when it would load. Written all the same, since
+# the script can be put right before the editor next starts.
+static func _why_not_loaded(plugin_cfg_path: String) -> String:
+	var config: ConfigFile = ConfigFile.new()
+	if config.load(plugin_cfg_path) != OK:
+		return "The editor cannot read %s, so it will not enable the plugin." % plugin_cfg_path
+	if not config.has_section_key("plugin", "script"):
+		return "%s has no script field, so the editor will not enable the plugin." % plugin_cfg_path
+	var script_name: String = str(config.get_value("plugin", "script"))
+	if script_name.is_empty():
+		return ""
+	var script_path: String = plugin_cfg_path.get_base_dir().path_join(script_name)
+	if not FileAccess.file_exists(script_path):
+		return "%s does not exist, so the editor will not enable the plugin." % script_path
+	# Loaded only to learn whether the editor could; what the engine says of a script that does not
+	# parse is about a file the answer does not describe.
+	printerr(GdhLog.ASIDE)
+	var script: Script = ResourceLoader.load(script_path, "Script", ResourceLoader.CACHE_MODE_IGNORE)
+	printerr(GdhLog.RESUMED)
+	if script == null or script.get_instance_base_type() == &"":
+		return (
+			"%s does not compile, so the editor disables the plugin again at its next start." % script_path
+			+ " script_diagnostics names the error."
+		)
+	if not ClassDB.is_parent_class(script.get_instance_base_type(), "EditorPlugin"):
+		return "%s does not extend EditorPlugin, so the editor loads nothing for it." % script_path
+	if not script.is_tool():
+		return "%s is not a @tool script, so the editor loads nothing for it." % script_path
+	return ""
 
 
 # Disable a plugin

package/build/godot/operations/project_config.gd

@@ -7,6 +7,52 @@ const GdhProjectFile = preload("project_file.gd")
 const GdhSerialisation = preload("serialisation.gd")
 const GdhSettingReads = preload("setting_reads.gd")
 const GdhShapes = preload("value_shapes.gd")
+## The words GDScript reserves, which no script could reach an autoload by.
+const GDSCRIPT_KEYWORDS: Array[String] = [
+	"and",
+	"as",
+	"assert",
+	"await",
+	"break",
+	"breakpoint",
+	"class",
+	"class_name",
+	"const",
+	"continue",
+	"elif",
+	"else",
+	"enum",
+	"extends",
+	"false",
+	"for",
+	"func",
+	"if",
+	"in",
+	"INF",
+	"is",
+	"match",
+	"NAN",
+	"namespace",
+	"not",
+	"null",
+	"or",
+	"pass",
+	"PI",
+	"preload",
+	"return",
+	"self",
+	"signal",
+	"static",
+	"super",
+	"TAU",
+	"trait",
+	"true",
+	"var",
+	"void",
+	"when",
+	"while",
+	"yield",
+]
 
 var _log: GdhLog
 var _values: GdhSerialisation = GdhSerialisation.new()
@@ -133,6 +179,23 @@ func set_project_setting(params: Dictionary) -> Dictionary:
 	var err: Error = GdhProjectFile.save([setting_path])
 	if err != OK:
 		return _log.failure("Failed to save project.godot: " + error_string(err))
+	# An override still replaces what was written wherever its feature is, and a write of the base
+	# value read as if it reached every build.
+	var overrides: Dictionary = GdhSettingReads.overrides_of(setting_path, _values)
+	if not overrides.is_empty():
+		answer["overrides"] = overrides
+		var parts: Array[String] = []
+		for feature: Variant in overrides:
+			parts.append(
+				(
+					"one with the feature %s reads %s from %s.%s"
+					% [feature, JSON.stringify(overrides[feature]), setting_path, feature]
+				)
+			)
+		answer["overridesNote"] = (
+			"Not every build reads what was written: %s. Set or unset an override to change what its builds read."
+			% "; ".join(parts)
+		)
 	return answer
 
 
@@ -194,6 +257,12 @@ func unset_project_setting(params: Dictionary) -> Dictionary:
 		answer["removed"] = false
 		answer["saved"] = false
 		answer["note"] = "project.godot does not set %s, so there was nothing to take out." % setting_path
+		var near: PackedStringArray = PackedStringArray() if held else _settings_near(setting_path)
+		if not near.is_empty():
+			answer["note"] += (
+				" Nor does the engine declare it; the nearest %s %s."
+				% ["setting is" if near.size() == 1 else "settings are", ", ".join(near)]
+			)
 		return _with_what_holds(answer, setting_path)
 	answer["old_value"] = _values.serialize_value(value)
 	# The default rather than null for a setting the engine declares: null takes the declaration away
@@ -221,8 +290,12 @@ func _with_what_holds(answer: Dictionary, setting_path: String) -> Dictionary:
 
 
 # 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.
+# likely a misspelt one: a setting nothing declares is written all the same, and is never read. None
+# for an override of a setting the engine has, which its feature's builds read in the base's place.
 static func _settings_near(setting_path: String) -> PackedStringArray:
+	var base: String = GdhSettingReads.override_base(setting_path)
+	if not base.is_empty() and ProjectSettings.has_setting(base):
+		return PackedStringArray()
 	var section: String = setting_path.get_slice("/", 0) + "/"
 	var names: PackedStringArray = []
 	for info: Dictionary in ProjectSettings.get_property_list():
@@ -311,6 +384,10 @@ func add_autoload(params: Dictionary) -> Dictionary:
 			)
 		)
 
+	var clash: String = _autoload_name_refusal(name)
+	if not clash.is_empty():
+		return _log.failure(clash)
+
 	if not path.begins_with("res://"):
 		path = "res://" + path
 
@@ -354,6 +431,32 @@ func add_autoload(params: Dictionary) -> Dictionary:
 	}
 
 
+## Why [param name] cannot name an autoload, or empty when it can. The editor's Autoload tab refuses
+## the same names: an autoload named after an engine class or a built-in type takes that name in
+## every script, so an autoload called Input made every Input.is_action_pressed call the autoload.
+static func _autoload_name_refusal(name: String) -> String:
+	var reason: String = ""
+	if not name.is_valid_ascii_identifier():
+		reason = "it is not an identifier, which a script could name"
+	elif name in GDSCRIPT_KEYWORDS:
+		reason = "it is a GDScript keyword"
+	elif ClassDB.class_exists(name):
+		reason = (
+			"it is the engine class %s, and every script naming %s would reach the autoload instead"
+			% [name, name]
+		)
+	else:
+		for type: int in TYPE_MAX:
+			if type_string(type) == name:
+				reason = "it is the built-in type %s" % name
+	if reason.is_empty():
+		return ""
+	return (
+		"%s cannot name an autoload: %s. Nothing was written; the editor's Autoload tab refuses it too."
+		% [JSON.stringify(name), reason]
+	)
+
+
 # Remove an autoload singleton
 func remove_autoload(params: Dictionary) -> Dictionary:
 	var name: String = str(params.get("name", ""))

package/build/godot/operations/property_values.gd

@@ -383,19 +383,16 @@ func _readable(value: Variant, relative_to: Node) -> Variant:
 	return _values.serialize_value(value)
 
 
-## What [param target] stores, by name, but its script and the properties in [param leave]. A list
-## or a map is copied, since a setter can change the one it holds in place.
+## What [param target] stores, by name, but its script and the properties in [param leave], in the
+## names a read answers with: a Curve's points as point_0/position and the rest rather than the _data
+## list every point write changes. A list or a map is copied, since a setter can change the one it
+## holds in place.
 func _stored(target: Object, leave: Dictionary) -> Dictionary:
 	var held: Dictionary = {}
-	for entry: Dictionary in target.get_property_list():
+	for entry: Dictionary in GdhShapes.read_properties(target):
 		var name: String = str(entry["name"])
 		var usage: int = GdhRead.as_int(entry["usage"])
-		if (
-			usage & PROPERTY_USAGE_STORAGE == 0
-			or usage & HEADINGS != 0
-			or name == "script"
-			or leave.has(name)
-		):
+		if usage & HEADINGS != 0 or name == "script" or leave.has(name):
 			continue
 		var value: Variant = target.get(name)
 		if value is Array:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gdharness",
-  "version": "1.3.40",
+  "version": "1.3.42",
   "mcpName": "io.github.Aureliolo/gdharness",
   "description": "A harness for driving a Godot 4 project from an agent: editor addons, a runtime bridge into the running game, an MCP server in front of them, and a CLI that installs and diagnoses the Godot side.",
   "type": "module",