gdharness 1.3.1 → 1.3.3

package/build/godot/addons/gdharness_editor/animation_reads.gd

@@ -81,15 +81,7 @@ static func animations(player: AnimationPlayer, animation_name: String) -> Dicti
 			listed.append(summary)
 		return {"ok": true, "animations": listed}
 	if not player.has_animation(StringName(animation_name)):
-		var names: PackedStringArray = player.get_animation_list()
-		return {
-			"ok": false,
-			"error":
-			(
-				"%s has no animation %s. It has: %s."
-				% [player.name, animation_name, ", ".join(names) if not names.is_empty() else "none"]
-			)
-		}
+		return {"ok": false, "error": no_animation(player, str(player.name), animation_name)}
 	var anim: Animation = player.get_animation(StringName(animation_name))
 	var answer: Dictionary = _summary(anim)
 	answer["ok"] = true
@@ -102,6 +94,16 @@ static func animations(player: AnimationPlayer, animation_name: String) -> Dicti
 	return answer
 
 
+## Why [param player], called [param called], cannot be asked for [param animation_name], with the
+## animations it has.
+static func no_animation(player: AnimationPlayer, called: String, animation_name: String) -> String:
+	var names: PackedStringArray = player.get_animation_list()
+	return (
+		"%s has no animation %s. It has: %s."
+		% [called, animation_name, ", ".join(names) if not names.is_empty() else "none"]
+	)
+
+
 static func _summary(anim: Animation) -> Dictionary:
 	return {
 		"length": anim.length,

package/build/godot/addons/gdharness_editor/declared_values.gd

@@ -0,0 +1,116 @@
+@tool
+extends RefCounted
+
+## What a property declares beyond its type: the values of its enum and the range it is exported
+## with, for taking a value by name and for saying when a value written lies outside them.
+
+const GdhRead = preload("reading.gd")
+
+
+## The values an enum hint names, by name, from its hint string: "SWORD:0,SHIELD:1" as a script
+## declares one, or "Add,Subtract" as an engine property does, each name then taking the number
+## after the one before it.
+static func enum_values(hint_string: String) -> Dictionary:
+	var values: Dictionary = {}
+	var next: int = 0
+	for entry: String in hint_string.split(",", false):
+		var name: String = entry.get_slice(":", 0).strip_edges()
+		var number: String = entry.get_slice(":", 1).strip_edges() if ":" in entry else ""
+		var value: int = number.to_int() if number.is_valid_int() else next
+		values[name] = value
+		next = value + 1
+	return values
+
+
+## The values of the enum [param declared] declares, by name, spelt as the script of [param target]
+## spells them when it declares that enum. The engine's hint capitalises each name, "SWORD" as
+## "Sword", and a refusal listing those named values the script never spells.
+static func enum_of(target: Object, declared: Dictionary) -> Dictionary:
+	var hinted: Dictionary = enum_values(str(declared.get("hint_string", "")))
+	var attached: Variant = target.get_script()
+	if not attached is Script:
+		return hinted
+	var script: Script = attached
+	for constant: Variant in script.get_script_constant_map().values():
+		if not constant is Dictionary:
+			continue
+		var values: Dictionary = constant
+		if values.size() != hinted.size():
+			continue
+		var spelt: Dictionary = {}
+		for name: Variant in values:
+			if hinted.get(str(name).capitalize()) == values[name]:
+				spelt[str(name)] = values[name]
+		if spelt.size() == hinted.size():
+			return spelt
+	return hinted
+
+
+## The number [param word] names among [param choices], matched as written and then ignoring case,
+## or null when it names none.
+static func enum_named(choices: Dictionary, word: String) -> Variant:
+	var wanted: String = word.strip_edges()
+	if choices.has(wanted):
+		return choices[wanted]
+	for name: String in choices:
+		if name.to_lower() == wanted.to_lower():
+			return choices[name]
+	return null
+
+
+static func enum_refusal(holder: String, property: String, word: String, choices: Dictionary) -> String:
+	var said: String = (
+		"%s.%s is an enum, and %s is none of its values: send %s by name or by number"
+		% [holder, property, word, _listed(choices)]
+	)
+	var close: PackedStringArray = GdhRead.nearest(word, PackedStringArray(choices.keys()))
+	if close.is_empty():
+		return said + "."
+	return said + ". The nearest %s %s." % ["is" if close.size() == 1 else "are", ", ".join(close)]
+
+
+## Why [param value], shown as [param shown], lies outside what [param declared] allows, an export
+## range or an enum's values, or "" when it does not. A range marked or_greater or or_less is open
+## on that side.
+static func outside(target: Object, declared: Dictionary, value: Variant, shown: String) -> String:
+	var hint: int = GdhRead.as_int(declared.get("hint", PROPERTY_HINT_NONE))
+	var hint_string: String = str(declared.get("hint_string", ""))
+	var property: String = str(declared.get("name", ""))
+	if typeof(value) != TYPE_INT and typeof(value) != TYPE_FLOAT:
+		return ""
+	var number: float = GdhRead.as_float(value)
+	if hint == PROPERTY_HINT_ENUM and typeof(value) == TYPE_INT:
+		var choices: Dictionary = enum_of(target, declared)
+		if choices.is_empty() or choices.values().has(value):
+			return ""
+		return "%d is none of the values %s declares: %s." % [value, property, _listed(choices)]
+	if hint != PROPERTY_HINT_RANGE:
+		return ""
+	var parts: PackedStringArray = []
+	for part: String in hint_string.split(","):
+		var _added: bool = parts.append(part.strip_edges())
+	if parts.size() < 2 or not parts[0].is_valid_float() or not parts[1].is_valid_float():
+		return ""
+	var low: float = parts[0].to_float()
+	var high: float = parts[1].to_float()
+	if (number <= high or parts.has("or_greater")) and (number >= low or parts.has("or_less")):
+		return ""
+	return (
+		(
+			"%s is outside the range %s declares, %s to %s, which the inspector holds it to; the "
+			+ "engine stores it as given."
+		)
+		% [shown, property, _bound(low), _bound(high)]
+	)
+
+
+static func _listed(choices: Dictionary) -> String:
+	var listed: PackedStringArray = []
+	for name: String in choices:
+		var _added: bool = listed.append("%s (%d)" % [name, choices[name]])
+	return ", ".join(listed)
+
+
+## A range's end as the script wrote it: the engine's hint gives @export_range(0, 10) as 0.0 and 10.0.
+static func _bound(end: float) -> String:
+	return str(int(end)) if end == floorf(end) and absf(end) < 1e15 else str(end)

package/build/godot/addons/gdharness_editor/declared_values.gd.uid

@@ -0,0 +1 @@
+uid://c2bcafdf9rzgo

package/build/godot/addons/gdharness_editor/file_reads.gd

@@ -427,6 +427,11 @@ static func resource(res_path: String, include_defaults: bool) -> Dictionary:
 	}
 	if script != null:
 		answer["script"] = script.resource_path
+		# resourceType is the engine class under the script, which for a class the project declares
+		# is Resource whatever create was given.
+		var declared_class: String = str(script.get_global_name())
+		if not declared_class.is_empty():
+			answer["scriptClass"] = declared_class
 	return answer
 
 

package/build/godot/addons/gdharness_editor/file_walk.gd

@@ -0,0 +1,134 @@
+@tool
+extends RefCounted
+
+const GdhRead = preload("reading.gd")
+
+# Two walks rather than one because they disagree about hidden entries on purpose: a suffix
+# walk descends into every visible directory and matches whole names, while the extension walk
+# skips anything beginning with a dot, including .import sidecars that would otherwise answer
+# for the resource they belong to.
+#
+# Both stop at a `.gdignore`, because the engine does: nothing under one is imported, so what is
+# in there is not a resource, not a dependency and not a global class. Walking in anyway hands
+# every caller files the engine will never answer for.
+
+
+# Why [param path], a res:// or uid:// path a setting names, is not a file the engine can load, or
+# empty when it is. A uid:// path resolves through the project's uid cache, which the import writes,
+# so one that does not resolve is a file that has gone or a project not imported yet, and saying
+# only that the file does not exist sent a caller looking for a scene that was there.
+static func missing_reason(path: String) -> String:
+	if path.begins_with("uid://"):
+		var id: int = ResourceUID.text_to_id(path)
+		if id == ResourceUID.INVALID_ID or not ResourceUID.has_id(id):
+			return (
+				path
+				+ " does not resolve: no file in the project's uid cache has it, so the file has gone or the"
+				+ " project has not been imported yet (project_import refresh_uids imports it)"
+			)
+		var resolved: String = ResourceUID.get_id_path(id)
+		return (
+			"" if FileAccess.file_exists(resolved) else path + " names " + resolved + ", which does not exist"
+		)
+	return "" if FileAccess.file_exists(path) else path + " does not exist"
+
+
+## [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.
+func with_nearest_files(said: String, path: String) -> String:
+	var extension: String = path.get_extension()
+	if extension.is_empty():
+		return said
+	var files: Array[String] = find_files_with_extensions("res://", [extension])
+	# The walk lists a directory in the order the filesystem keeps it, which differs between
+	# platforms, so the same project was answered with its files in another order on Linux.
+	files.sort()
+	if files.is_empty():
+		return "%s. The project holds no .%s file." % [said, extension]
+	var names: PackedStringArray = []
+	for file: String in files:
+		var _named: bool = names.append(file.get_file().get_basename())
+	var close: PackedStringArray = GdhRead.nearest(path.get_file().get_basename(), names)
+	var offered: PackedStringArray = []
+	for file: String in files:
+		if file.get_file().get_basename() in close:
+			var _offered: bool = offered.append(file)
+	if not offered.is_empty():
+		var one: bool = offered.size() == 1
+		return (
+			"%s. The nearest .%s %s %s."
+			% [said, extension, "file is" if one else "files are", ", ".join(offered)]
+		)
+	if files.size() <= GdhRead.NAMED_CHILDREN:
+		return "%s. The project's .%s files are %s." % [said, extension, ", ".join(files)]
+	return "%s. None of the project's %d .%s files is named like it." % [said, files.size(), extension]
+
+
+# A directory the engine steps over, marker file and all.
+func is_stepped_over(path: String) -> bool:
+	return FileAccess.file_exists(path + ".gdignore")
+
+
+# An addon gdharness installed, told by the marker setup writes into it. The engine loads it, but
+# nobody on the project wrote it: the health check counted its thirty-odd scripts as the project's,
+# 39 beside the 5 project_info's own count gave, which the server's walks already step over.
+func is_installed_by_gdharness(path: String) -> bool:
+	return FileAccess.file_exists(path + ".gdharness-version")
+
+
+# Files under `path` whose name ends with `extension`, which is passed with its dot.
+func find_files(path: String, extension: String) -> Array[String]:
+	var files: Array[String] = []
+	if is_stepped_over(path) or is_installed_by_gdharness(path):
+		return files
+
+	var dir: DirAccess = DirAccess.open(path)
+
+	if dir:
+		if dir.list_dir_begin() != OK:
+			return files
+		var file_name: String = dir.get_next()
+
+		while file_name != "":
+			if dir.current_is_dir() and not file_name.begins_with("."):
+				files.append_array(find_files(path + file_name + "/", extension))
+			elif file_name.ends_with(extension):
+				files.append(path + file_name)
+
+			file_name = dir.get_next()
+
+	return files
+
+
+# Files under `path` whose extension is in `extensions`, which are passed without their dot.
+func find_files_with_extensions(path: String, extensions: Array) -> Array[String]:
+	var files: Array[String] = []
+	if is_stepped_over(path) or is_installed_by_gdharness(path):
+		return files
+
+	var dir: DirAccess = DirAccess.open(path)
+
+	if dir:
+		if dir.list_dir_begin() != OK:
+			return files
+		var file_name: String = dir.get_next()
+
+		while file_name != "":
+			if file_name.begins_with("."):
+				file_name = dir.get_next()
+				continue
+
+			var full_path: String = path + file_name
+			if dir.current_is_dir():
+				files.append_array(find_files_with_extensions(full_path + "/", extensions))
+			else:
+				var ext: String = file_name.get_extension().to_lower()
+				if ext in extensions:
+					files.append(full_path)
+
+			file_name = dir.get_next()
+
+		dir.list_dir_end()
+
+	return files

package/build/godot/addons/gdharness_editor/file_walk.gd.uid

@@ -0,0 +1 @@
+uid://c16785cs9xozr

package/build/godot/addons/gdharness_editor/property_values.gd

@@ -14,6 +14,7 @@ extends RefCounted
 ## write accepts. What is here on top of it is the part only a property knows: the type wanted, so a
 ## dictionary shaped like a vector or a bare pair of numbers can be read as one.
 
+const GdhDeclared = preload("declared_values.gd")
 const GdhRead = preload("reading.gd")
 const GdhSerialisation = preload("serialisation.gd")
 const GdhShapes = preload("value_shapes.gd")
@@ -78,6 +79,11 @@ var _refused: String = ""
 # offsets. An answer naming only what was given leaves the caller to guess the rest.
 var _also_changed: Dictionary = {}
 
+# The values the last write_all wrote outside what their property declares, by name, as a sentence
+# saying so: a number past an export range, or one no enum value has. The engine stores either, and
+# the inspector would not have let it be entered, so a write answered as made said nothing of it.
+var _outside_declared: Dictionary = {}
+
 
 ## Turns what arrived over the wire into the Godot value a property wants.
 ##
@@ -177,25 +183,38 @@ func cannot_hold(
 ## caller returns the refusal instead of saving.
 func write_all(target: Object, properties: Dictionary) -> String:
 	_also_changed = {}
+	_outside_declared = {}
 	var named: Dictionary = {}
 	for key: Variant in properties:
 		named[str(key).get_slice(":", 0)] = true
 	var before: Dictionary = _stored(target, named)
 	var given: Dictionary = {}
+	var declarations: Dictionary = {}
+	# A refusal of one of several leaves the others unwritten too, which a refusal naming only the
+	# one it refused left a caller to guess.
+	var unwritten: String = (
+		"" if properties.size() < 2 else " None of the %d properties given was written." % properties.size()
+	)
 	for key: Variant in properties:
 		var property: String = str(key)
 		var declared: Dictionary = declaration(target, property)
 		if declared.is_empty() and ":" in property:
 			declared = _component_slot(target, property)
 			if declared.has("refused"):
-				return str(declared["refused"])
+				return str(declared["refused"]) + unwritten
+		if declared.is_empty() and target is ShaderMaterial and property.begins_with("shader_parameter/"):
+			return _no_uniform(target as ShaderMaterial, property) + unwritten
 		if declared.is_empty():
-			return "%s has no property %s" % [target.get_class(), property]
+			return "%s has no property %s." % [class_called(target), property] + unwritten
 		var value: Array = value_for(target, declared, properties[key])
 		if not value[0]:
-			return str(value[1])
+			return str(value[1]) + unwritten
+		var outside: String = GdhDeclared.outside(target, declared, value[1], shown(value[1]))
+		if not outside.is_empty():
+			_outside_declared[property] = outside
 		_write(target, property, value[1])
 		given[property] = value[1]
+		declarations[property] = declared
 
 	for property: String in given:
 		if not same(read_at(target, property), given[property]):
@@ -203,13 +222,8 @@ func write_all(target: Object, properties: Dictionary) -> String:
 	for property: String in given:
 		var held: Variant = read_at(target, property)
 		if not same(held, given[property]):
-			return (
-				(
-					"%s.%s was given %s and holds %s after it was set: the engine changed or refused the "
-					+ "value, so nothing was written."
-				)
-				% [target.get_class(), property, shown(given[property]), shown(held)]
-			)
+			var declared: Dictionary = declarations[property]
+			return _not_held(target, property, given[property], held, declared)
 	for property: String in before:
 		var now: Variant = target.get(property)
 		if not same(now, before[property]):
@@ -217,11 +231,83 @@ func write_all(target: Object, properties: Dictionary) -> String:
 	return ""
 
 
+## Why [param property] of [param target], declared as [param declared], holds [param held] after
+## it was given [param value]. A text property with a list of names holds only one of them, and its
+## getter answers its default for any other. A player's bus is one, though the engine fills its list
+## only in the inspector, so the buses are read from the AudioServer, which holds the project's
+## layout; "the engine changed or refused the value" left a caller to guess the bus did not exist.
+func _not_held(
+	target: Object, property: String, value: Variant, held: Variant, declared: Dictionary
+) -> String:
+	var said: String = (
+		"%s.%s was given %s and holds %s after it was set"
+		% [target.get_class(), property, shown(value), shown(held)]
+	)
+	var type: int = GdhRead.as_int(declared.get("type", TYPE_NIL))
+	var hint: int = GdhRead.as_int(declared.get("hint", PROPERTY_HINT_NONE))
+	var names: PackedStringArray = []
+	if hint == PROPERTY_HINT_ENUM and (type == TYPE_STRING or type == TYPE_STRING_NAME):
+		names = PackedStringArray(GdhDeclared.enum_values(str(declared.get("hint_string", ""))).keys())
+	var bus: bool = property == "bus" and target.get_class().begins_with("AudioStreamPlayer")
+	if bus:
+		names = []
+		for index: int in AudioServer.bus_count:
+			var _added: bool = names.append(AudioServer.get_bus_name(index))
+	if names.is_empty() or names.has(str(value)):
+		return said + ": the engine changed or refused the value, so nothing was written."
+	var close: PackedStringArray = GdhRead.nearest(str(value), names)
+	var nearest: String = (
+		"%s %s" % ["is" if close.size() == 1 else "are", ", ".join(close)] if not close.is_empty() else ""
+	)
+	if bus:
+		return (
+			(
+				"%s: it takes the name of one of the project's audio buses, and %s is none of them; %s. "
+				+ "project_info include audio_buses lists them, and project_settings add_audio_bus adds "
+				+ "one. Nothing was written."
+			)
+			% [
+				said,
+				shown(value),
+				"the buses are " + ", ".join(names) if nearest.is_empty() else "the nearest " + nearest
+			]
+		)
+	return (
+		"%s: it takes one of the names it lists, and %s is none of them; %s. Nothing was written."
+		% [
+			said,
+			shown(value),
+			"it lists " + ", ".join(names) if nearest.is_empty() else "the nearest it lists " + nearest
+		]
+	)
+
+
+## Why [param material] has no [param property]: a ShaderMaterial's parameters are its shader's
+## uniforms, so the shader is what lacks one, and "ShaderMaterial has no property" named the
+## material.
+static func _no_uniform(material: ShaderMaterial, property: String) -> String:
+	var uniform: String = property.trim_prefix("shader_parameter/")
+	if material.shader == null:
+		return "The ShaderMaterial has no shader, so it has no parameter %s yet; set shader first." % uniform
+	var shader: String = material.shader.resource_path
+	var named: String = shader if not shader.is_empty() else "Its shader"
+	var uniforms: Array = []
+	for entry: Dictionary in material.shader.get_shader_uniform_list():
+		uniforms.append(str(entry["name"]))
+	var said: String = "%s declares no uniform %s, which %s would set" % [named, uniform, property]
+	if uniforms.is_empty():
+		return said + "; it declares no uniforms."
+	return GdhRead.offered(said, uniform, uniforms) + "."
+
+
 ## Puts under alsoChanged in [param answer] each property the last [method write_all] changed
-## without being given it, as {was, now}, when there are any. A node is named by its path from
-## [param relative_to], as a scene answer names one. Called before the scene is written, since the
-## write frees the nodes these values can hold.
-func note_also_changed(answer: Dictionary, relative_to: Node = null) -> void:
+## without being given it, as {was, now}, and under outsideDeclared each value it wrote outside what
+## its property declares, when there are any. A node is named by its path from [param relative_to],
+## as a scene answer names one. Called before the scene is written, since the write frees the nodes
+## these values can hold.
+func note_write(answer: Dictionary, relative_to: Node = null) -> void:
+	if not _outside_declared.is_empty():
+		answer["outsideDeclared"] = _outside_declared.duplicate()
 	if _also_changed.is_empty():
 		return
 	var noted: Dictionary = {}
@@ -324,6 +410,18 @@ func value_for(target: Object, declared: Dictionary, raw: Variant) -> Array:
 	var hint: int = GdhRead.as_int(declared.get("hint", PROPERTY_HINT_NONE))
 	if expected_type == TYPE_OBJECT and hint == PROPERTY_HINT_NODE_TYPE:
 		return _node_reference(target, property, raw)
+	# An enum is written by the name of a value as well as its number, since the name is what the
+	# script and the inspector show and the number is only where the value happens to sit.
+	if expected_type == TYPE_INT and hint == PROPERTY_HINT_ENUM and typeof(raw) == TYPE_STRING:
+		var choices: Dictionary = GdhDeclared.enum_of(target, declared)
+		var chosen: Variant = GdhDeclared.enum_named(choices, str(raw))
+		if chosen == null:
+			var hinted: Dictionary = GdhDeclared.enum_values(str(declared.get("hint_string", "")))
+			chosen = GdhDeclared.enum_named(hinted, str(raw))
+		if chosen != null:
+			return [true, chosen]
+		if not str(raw).strip_edges().is_valid_int():
+			return [false, GdhDeclared.enum_refusal(class_called(target), property, str(raw), choices)]
 
 	# A resource-valued property takes the path of one, which is how a caller names a TileSet,
 	# a material or a theme: there is no other way to hand a tool a Resource.
@@ -339,12 +437,12 @@ func value_for(target: Object, declared: Dictionary, raw: Variant) -> Array:
 			return [false, _fraction_refusal(target, property, raw)]
 		var rounded: String = GdhSerialisation.inexact(raw, expected_type)
 		if not rounded.is_empty():
-			return [false, "%s.%s holds int: %s." % [target.get_class(), property, rounded]]
+			return [false, "%s.%s holds int: %s." % [class_called(target), property, rounded]]
 		_refused = ""
 		value = parse(raw, expected_type, elements)
 		if not _refused.is_empty():
 			return [false, _refused]
-		var refusal: String = cannot_hold(target.get_class(), property, value, expected_type, elements)
+		var refusal: String = cannot_hold(class_called(target), property, value, expected_type, elements)
 		if not refusal.is_empty():
 			return [false, refusal]
 	if value is Object:
@@ -489,10 +587,43 @@ func _fraction_refusal(target: Object, property: String, raw: Variant) -> String
 			"%s.%s holds whole numbers, and %s would be cut to fit. Setting it would save a different "
 			+ "value than the one asked for."
 		)
-		% [target.get_class(), property, shown(raw)]
+		% [class_called(target), property, shown(raw)]
 	)
 
 
+## [param raw] as a colour, read as a property write reads one, as [true, Color] or [false, why]:
+## fields from 0 to 1 with a optional, or an html code. [param named] is what the refusal calls it.
+func colour_from(raw: Variant, named: String) -> Array:
+	_refused = ""
+	var value: Variant = parse(raw, TYPE_COLOR)
+	if not _refused.is_empty():
+		return [false, _refused]
+	if value is Color:
+		return [true, value]
+	return [
+		false,
+		(
+			(
+				'%s is {"r": .., "g": .., "b": .., "a": ..} from 0 to 1, a optional, or an html code such as '
+				+ '"#ff8000" or "#ff800080"; %s is neither.'
+			)
+			% [named, JSON.stringify(raw)]
+		)
+	]
+
+
+## What [param target] is called in a refusal: the class_name its script declares, or else its
+## engine class. A resource made as a project class is a Resource to the engine, and "Resource.kind"
+## named a property no Resource has.
+static func class_called(target: Object) -> String:
+	var attached: Variant = target.get_script()
+	if attached is Script:
+		var script: Script = attached
+		if not str(script.get_global_name()).is_empty():
+			return str(script.get_global_name())
+	return target.get_class()
+
+
 ## The resource [param path] names, as [found, resource or why not].
 ##
 ## The project boundary is enforced here as well as on the server, because only the engine knows
@@ -516,6 +647,19 @@ func _resource_at(path: String, property: String) -> Array:
 			)
 		]
 	if not ResourceLoader.exists(path):
+		# An image or a sound nobody has imported is a file the engine has no loader for, and "No
+		# resource at" sent a caller looking for a file that was there.
+		if path.begins_with("res://") and FileAccess.file_exists(path):
+			return [
+				false,
+				(
+					(
+						"%s is there, but it has never been imported, so the engine has no resource to load"
+						+ " from it for %s. project_import reimport with resourcePath %s imports it."
+					)
+					% [path, property, path]
+				)
+			]
 		return [false, "No resource at %s for %s" % [path, property]]
 	return [true, load(path)]
 

package/build/godot/addons/gdharness_editor/reading.gd

@@ -164,6 +164,43 @@ static func not_of_kind(
 	return told + " The scene's %ss are at %s." % [kind, shown]
 
 
+## Up to three of [param names] closest to [param word], closest first, ignoring case: the names a
+## refusal offers for one that is not there, as a typo usually is one of them.
+static func nearest(word: String, names: PackedStringArray) -> PackedStringArray:
+	var wanted: String = word.to_lower()
+	var close: Array[String] = []
+	for name: String in names:
+		if name.to_lower().similarity(wanted) >= 0.5:
+			close.append(name)
+	close.sort_custom(
+		func(a: String, b: String) -> bool:
+			return a.to_lower().similarity(wanted) > b.to_lower().similarity(wanted)
+	)
+	return PackedStringArray(close.slice(0, 3))
+
+
+## [param said], the refusal for [param word], which is not among [param names], with those nearest
+## it when any are, or else every one of them, so the caller has a name to send instead.
+static func offered(said: String, word: String, names: Array) -> String:
+	var every: PackedStringArray = PackedStringArray(names)
+	var close: PackedStringArray = nearest(word, every)
+	if close.is_empty():
+		return "%s; it has %s" % [said, ", ".join(every)]
+	return "%s; the nearest it has %s %s" % [said, "is" if close.size() == 1 else "are", ", ".join(close)]
+
+
+## The signals [param object] has that a caller can connect, its own class's first: the engine
+## lists them from Object down, which puts a Button's pressed after thirty a Control has, and names
+## starting with an underscore are the engine's own.
+static func signals_of(object: Object) -> Array:
+	var names: Array = []
+	for entry: Dictionary in object.get_signal_list():
+		var name: String = str(entry["name"])
+		if not name.begins_with("_"):
+			names.push_front(name)
+	return names
+
+
 ## [param word] after the article it takes, "an AnimationTree" or "a Node2D".
 static func with_article(word: String) -> String:
 	return ("an " if word.left(1).to_upper() in ["A", "E", "I", "O", "U"] else "a ") + word

package/build/godot/addons/gdharness_editor/scene_file.gd

@@ -437,7 +437,9 @@ func unusable_name(parent: Node, child_name: String, moving: Node = null) -> Str
 		return unfit
 	var taken: Node = parent.get_node_or_null(NodePath(child_name))
 	if taken != null and taken != moving and taken.get_parent() == parent:
-		return "%s already has a child named %s." % [path_of(parent), child_name]
+		# The root by its name, since its path is ".", and ". already has a child" read as a typo.
+		var holder: String = "The root, %s," % parent.name if parent == root else path_of(parent)
+		return "%s already has a child named %s." % [holder, child_name]
 	return ""
 
 

package/build/godot/addons/gdharness_editor/serialisation.gd

@@ -410,6 +410,10 @@ func fitted(value: Variant, type: int) -> Variant:
 	var simple: Array[int] = [TYPE_BOOL, TYPE_INT, TYPE_FLOAT, TYPE_STRING]
 	if not simple.has(type) or not simple.has(typeof(rebuilt)):
 		return rebuilt
+	# A number or a truth value stays as sent where text is wanted, for the refusal to name. Converted,
+	# 1 arrived as the double it is in JSON and was saved as "1.0", which is not the text anyone sends.
+	if type == TYPE_STRING and not rebuilt is String:
+		return rebuilt
 
 	# Digits are read as digits, since read as JSON they become a double and one past 2^53 a
 	# neighbour of the number written.

package/build/godot/addons/gdharness_editor/tool_executor.gd

@@ -124,6 +124,9 @@ func _init_tools() -> void:
 		"read_animation_states": [_animation_tools, "read_animation_states"],
 		"create_animation": [_animation_tools, "create_animation"],
 		"add_animation_track": [_animation_tools, "add_animation_track"],
+		"set_animation": [_animation_tools, "set_animation"],
+		"rename_animation": [_animation_tools, "rename_animation"],
+		"remove_animation": [_animation_tools, "remove_animation"],
 		"add_animation_state": [_animation_tools, "add_animation_state"],
 		"connect_animation_states": [_animation_tools, "connect_animation_states"],
 	}