gdharness 1.2.15 → 1.2.16

package/build/godot/addons/gdharness_runtime/runtime_input.gd

@@ -17,10 +17,6 @@ const Targets = preload("runtime_targets.gd")
 ## The distance from a capital letter to its small one in Unicode. A keycode holds the capital.
 const TO_SMALL: int = 32
 
-## What a game started without a window gets whatever the project settings say, and the usual
-## reason a control is out of reach. Only worth telling somebody when it is what they have.
-const HEADLESS_VIEWPORT: Vector2 = Vector2(64, 64)
-
 ## Set, to the desktop's name, for a process gdharness started on a desktop of its own and for
 ## everything that process starts. Kept in step with `DESKTOP_VARIABLE` in src/desktop.ts.
 const DESKTOP_VARIABLE: String = "GDHARNESS_DESKTOP"
@@ -654,20 +650,8 @@ func _out_of_reach(
 	)
 
 
-## What to add to a refusal about a point outside the viewport, when the reason is that nobody
-## gave this game a window. The rect on its own does not say it, and it is the usual reason.
-##
-## The size is only claimed where it is true: the rect is printed beside this, so naming 64 by 64
-## over a viewport somebody has resized says two different things in one sentence.
 func _no_window_note(viewport: Viewport) -> String:
-	if viewport != _host.get_tree().root or _host.get_tree().root.can_draw():
-		return ""
-	if viewport.get_visible_rect().size == HEADLESS_VIEWPORT:
-		return (
-			". This game has no window, and a game with no window has a 64 by 64 viewport whatever "
-			+ "the project settings say: run it with a window to reach this control"
-		)
-	return ". This game has no window: run it with a window to reach this control"
+	return Targets.no_window_note(viewport, _host.get_tree().root)
 
 
 ## Sends a click's press or release into [param viewport], through Input when that is the game's

package/build/godot/addons/gdharness_runtime/runtime_targets.gd

@@ -12,6 +12,10 @@ const Words = preload("runtime_words.gd")
 ## How many of the controls saying the same words a refusal names, with the index for each.
 const LISTED_CANDIDATES: int = 10
 
+## What a game started without a window gets whatever the project settings say, and the usual
+## reason a control is out of reach. Only worth telling somebody when it is what they have.
+const HEADLESS_VIEWPORT: Vector2 = Vector2(64, 64)
+
 ## What a match's rank is made of, one bit each, the highest deciding first.
 const TAKES_POINTER: int = 4
 const ENABLED_BUTTON: int = 2
@@ -139,7 +143,7 @@ static func control_saying(root: Node, root_path: String, wanted: String, which:
 					under,
 					wanted,
 					_hidden_note(hidden),
-					_outside_note(outside),
+					_outside_note(outside, root),
 					_covered_note(covered, cover),
 					_open_menu_note(root, wanted),
 				]
@@ -393,10 +397,32 @@ static func _hidden_note(hidden: int) -> String:
 
 ## What to add to a refusal that found nothing on screen, when words matched controls a click cannot
 ## reach: off the viewport, or clipped away by a container it does not scroll.
-static func _outside_note(outside: int) -> String:
+static func _outside_note(outside: int, root: Node) -> String:
 	if outside == 0:
 		return ""
-	return "; %d control%s it outside what the screen shows" % [outside, " says" if outside == 1 else "s say"]
+	var note: String = (
+		"; %d control%s it outside what the screen shows" % [outside, " says" if outside == 1 else "s say"]
+	)
+	var window: Window = root as Window
+	return note if window == null else note + no_window_note(window, window)
+
+
+## What to add to a refusal about a point outside the viewport, when the reason is that nobody
+## gave this game a window. The rect on its own does not say it, and it is the usual reason: a
+## headless game's button twenty pixels in from the corner was refused as off screen, and the
+## refusal read as though the button were not there.
+##
+## The size is only claimed where it is true: the rect is printed beside this, so naming 64 by 64
+## over a viewport somebody has resized says two different things in one sentence.
+static func no_window_note(viewport: Viewport, root: Window) -> String:
+	if viewport != root or root.can_draw():
+		return ""
+	if viewport.get_visible_rect().size == HEADLESS_VIEWPORT:
+		return (
+			". This game has no window, and a game with no window has a 64 by 64 viewport whatever "
+			+ "the project settings say: run it with a window to reach this control"
+		)
+	return ". This game has no window: run it with a window to reach this control"
 
 
 ## What to add to a refusal that found nothing on screen, when the controls saying it are covered.

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

@@ -540,6 +540,9 @@ func _serialize_colors(value: PackedColorArray) -> Array:
 
 # A pathless Resource says so rather than inventing an empty path for the caller to load.
 func _serialize_object(value: Object) -> Variant:
+	if value is InputEvent:
+		var event: InputEvent = value
+		return _describe_input_event(event)
 	if value is Resource:
 		var resource: Resource = value
 		if resource.resource_path.is_empty():
@@ -552,6 +555,23 @@ func _serialize_object(value: Object) -> Variant:
 	return _describe_object(value)
 
 
+## An input event, by what it is bound to: the engine's own words for it and every field it stores
+## away from its default. As a bare resource it was its class and nothing else, so an input action
+## read back from project.godot could not say whether it was bound to Space or to a joypad button.
+func _describe_input_event(event: InputEvent) -> Dictionary:
+	var described: Dictionary = {"class": event.get_class(), "_type": "Resource", "text": event.as_text()}
+	for property: Dictionary in event.get_property_list():
+		var usage: int = property.get("usage", 0)
+		var name: String = str(property.get("name", ""))
+		if not (usage & PROPERTY_USAGE_STORAGE) or name.begins_with("resource_") or name == "script":
+			continue
+		var held: Variant = event.get(name)
+		if held == ClassDB.class_get_property_default_value(event.get_class(), name):
+			continue
+		described[name] = serialize_value(held)
+	return described
+
+
 ## A plain object, said in enough detail to tell it from the one beside it.
 ##
 ## `{"class": "RefCounted"}` was all of it, so a roster of twelve people came back as the word

package/build/godot/operations/audio_buses.gd

@@ -44,6 +44,41 @@ func create_audio_bus(params: Dictionary) -> Dictionary:
 	return {"bus": _bus(new_idx), "buses": buses, "layout": layout}
 
 
+func remove_audio_bus(params: Dictionary) -> Dictionary:
+	var bus_name: String = str(params.get("bus_name", ""))
+	if bus_name.is_empty():
+		return _log.failure("bus_name is required")
+	var index: int = AudioServer.get_bus_index(bus_name)
+	if index == -1:
+		var names: Array[String] = []
+		for i: int in range(AudioServer.bus_count):
+			names.append(AudioServer.get_bus_name(i))
+		return _log.failure("No bus named %s. The buses are %s." % [bus_name, ", ".join(names)])
+	if index == 0:
+		return _log.failure("%s is the bus every other ends in, so it cannot be removed." % bus_name)
+
+	# A bus sending to this one would be left sending to a name nothing has, which the engine reads
+	# as Master; sent on to where this one went instead, the chain it was part of keeps its shape.
+	var onward: String = AudioServer.get_bus_send(index)
+	var resent: Array[String] = []
+	for i: int in range(AudioServer.bus_count):
+		if i != index and AudioServer.get_bus_send(i) == bus_name:
+			AudioServer.set_bus_send(i, onward)
+			resent.append(AudioServer.get_bus_name(i))
+	AudioServer.remove_bus(index)
+
+	var layout: String = _save_layout()
+	if layout.is_empty():
+		return {}
+	var buses: Array[Dictionary] = []
+	for i: int in range(AudioServer.bus_count):
+		buses.append(_bus(i))
+	var answer: Dictionary = {"removed": bus_name, "buses": buses, "layout": layout}
+	if not resent.is_empty():
+		answer["resent"] = {"buses": resent, "to": onward}
+	return answer
+
+
 func get_audio_buses(_params: Dictionary) -> Dictionary:
 	var buses: Array[Dictionary] = []
 	for i: int in range(AudioServer.bus_count):

package/build/godot/operations/classdb_queries.gd

@@ -101,7 +101,7 @@ func query_class_info(params: Dictionary) -> Dictionary:
 	)
 
 	if not ClassDB.class_exists(class_name_str):
-		return _log.failure("Class not found: " + class_name_str)
+		return _not_found(class_name_str)
 
 	var member: String = str(params.get("member", ""))
 	if not member.is_empty():
@@ -152,6 +152,35 @@ func query_class_info(params: Dictionary) -> Dictionary:
 # is as often an ancestor's as the class's own, so the ancestry is walked without being asked. Each
 # match says which class declares it. Nothing found names the members whose names contain the one
 # asked for, since the usual miss is a spelling.
+## Why [param wanted] has no answer here. A class_name a project script declares is not in ClassDB,
+## and "Class not found" for one read as though the project had no such class.
+func _not_found(wanted: String) -> Dictionary:
+	for entry: Dictionary in ProjectSettings.get_global_class_list():
+		if str(entry.get("class", "")) == wanted:
+			return (
+				_log
+				. failure(
+					(
+						(
+							"%s is not an engine class: it is the class_name %s declares, and editor_classes reads "
+							+ "the engine's ClassDB only. script_info structure on that script, with "
+							+ "includeInherited, answers what it declares and what it inherits."
+						)
+						% [wanted, str(entry.get("path", ""))]
+					)
+				)
+			)
+	return _log.failure(
+		(
+			(
+				"Class not found: %s. editor_classes reads the engine's ClassDB, so a class_name a project "
+				+ "script declares is not in it either; script_info structure reads one."
+			)
+			% wanted
+		)
+	)
+
+
 func _member_of(class_name_str: String, member: String) -> Dictionary:
 	var found: Array[Dictionary] = []
 	var current: String = class_name_str
@@ -223,7 +252,7 @@ func inspect_inheritance(params: Dictionary) -> Dictionary:
 	_log.info("Inspecting inheritance for: " + class_name_str)
 
 	if not ClassDB.class_exists(class_name_str):
-		return _log.failure("Class not found: " + class_name_str)
+		return _not_found(class_name_str)
 
 	var ancestors: Array[String] = []
 	var current: String = class_name_str

package/build/godot/operations/file_walk.gd

@@ -35,10 +35,17 @@ 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):
+	if is_stepped_over(path) or is_installed_by_gdharness(path):
 		return files
 
 	var dir: DirAccess = DirAccess.open(path)
@@ -62,7 +69,7 @@ func find_files(path: String, extension: String) -> Array[String]:
 # 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):
+	if is_stepped_over(path) or is_installed_by_gdharness(path):
 		return files
 
 	var dir: DirAccess = DirAccess.open(path)

package/build/godot/operations/gdscript_authoring.gd

@@ -63,12 +63,11 @@ func create_gdscript(params: Dictionary) -> Dictionary:
 	if content.is_empty():
 		if not cls_name_param.is_empty():
 			script_content += "class_name " + cls_name_param + "\n"
-		script_content += "extends " + extends_class + "\n\n"
+		script_content += "extends " + extends_class + "\n"
+		# Only what was asked for: with no template the file was given an empty _ready beside a
+		# template_used of "none", which a caller had then to delete or leave lying in the script.
 		if not template.is_empty():
-			script_content += _script_template(template)
-		else:
-			script_content += "func _ready() -> void:\n"
-			script_content += "\tpass\n"
+			script_content += "\n" + _script_template(template)
 
 	var file: FileAccess = FileAccess.open(full_script_path, FileAccess.WRITE)
 	if not file:

package/build/godot/operations/godot_operations.gd

@@ -186,10 +186,14 @@ func _run(operation: String, params: Dictionary) -> Dictionary:
 			payload = Plugins.new(_log).disable_plugin(params)
 		"add_input_action":
 			payload = InputActions.new(_log).add_input_action(params)
+		"remove_input_action":
+			payload = InputActions.new(_log).remove_input_action(params)
 
 		# Audio
 		"create_audio_bus":
 			payload = AudioBuses.new(_log).create_audio_bus(params)
+		"remove_audio_bus":
+			payload = AudioBuses.new(_log).remove_audio_bus(params)
 		"get_audio_buses":
 			payload = AudioBuses.new(_log).get_audio_buses(params)
 		"set_audio_bus_effect":

package/build/godot/operations/input_actions.gd

@@ -184,6 +184,33 @@ func add_input_action(params: Dictionary) -> Dictionary:
 	}
 
 
+# Remove an input action the project defines, which add_input_action had no way back from.
+func remove_input_action(params: Dictionary) -> Dictionary:
+	var action_name: String = str(params.get("action_name", ""))
+	if action_name.is_empty():
+		return _log.failure("action_name is required")
+	var setting: String = "input/" + action_name
+	if not ProjectSettings.has_setting(setting):
+		return _log.failure("This project has no input action named " + action_name)
+	# The engine registers its own ui_ actions with a default, so clearing one from project.godot
+	# puts the engine's binding back rather than removing the action.
+	if ProjectSettings.property_get_revert(setting) != null:
+		return _log.failure(
+			(
+				(
+					"%s is one of the engine's own actions: removing it from project.godot restores the "
+					+ "engine's binding rather than removing it. Rebind it with add_input_action instead."
+				)
+				% action_name
+			)
+		)
+	ProjectSettings.set_setting(setting, null)
+	var err: Error = ProjectSettings.save()
+	if err != OK:
+		return _log.failure("Failed to save project.godot: " + error_string(err))
+	return {"action_name": action_name, "removed": true}
+
+
 # The value project.godot stores for one input action.
 #
 # It has to be a Dictionary holding real InputEvent objects. The engine writes those as the

package/build/godot/operations/project_config.gd

@@ -29,7 +29,14 @@ func get_project_setting(params: Dictionary) -> Dictionary:
 	}
 
 	if result["exists"]:
-		result["value"] = _values.serialize_value(ProjectSettings.get_setting(setting_path))
+		var value: Variant = ProjectSettings.get_setting(setting_path)
+		result["value"] = _values.serialize_value(value)
+		# A setting the engine registers exists whether or not the project sets it, so exists did
+		# not say whether project.godot has a line for it. At its default it has none: the engine
+		# drops such a key when it saves.
+		var default_value: Variant = ProjectSettings.property_get_revert(setting_path)
+		if default_value != null:
+			result["at_default"] = value == default_value
 	else:
 		result["value"] = null
 		result["message"] = "Setting does not exist"

package/build/godot/operations/project_diagnostics.gd

@@ -1,6 +1,7 @@
 extends RefCounted
 
 const FileWalk = preload("file_walk.gd")
+const ImportPipeline = preload("import_pipeline.gd")
 const Log = preload("logger.gd")
 
 var _log: Log
@@ -40,10 +41,11 @@ func get_project_health(params: Dictionary) -> Dictionary:
 	if "resources" in check_categories:
 		var details: Array[String] = []
 
-		var importable_extensions: Array[String] = ["png", "jpg", "wav", "mp3", "ogg"]
-		var resources: Array[String] = []
-		for ext: String in importable_extensions:
-			resources.append_array(_files.find_files("res://", "." + ext))
+		# 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
+		)
 
 		var missing_imports: int = 0
 		for res: String in resources:
@@ -58,7 +60,9 @@ func get_project_health(params: Dictionary) -> Dictionary:
 			"name": "Resources",
 			"passed": details.is_empty(),
 			"details": details,
-			"total_resources": resources.size()
+			# What the check read: files the engine imports. A .tres is a resource and was counted
+			# under this name as none, beside a project holding one.
+			"importable_files": resources.size()
 		}
 
 	# 3. Scripts Check

package/build/godot/operations/serialisation.gd

@@ -540,6 +540,9 @@ func _serialize_colors(value: PackedColorArray) -> Array:
 
 # A pathless Resource says so rather than inventing an empty path for the caller to load.
 func _serialize_object(value: Object) -> Variant:
+	if value is InputEvent:
+		var event: InputEvent = value
+		return _describe_input_event(event)
 	if value is Resource:
 		var resource: Resource = value
 		if resource.resource_path.is_empty():
@@ -552,6 +555,23 @@ func _serialize_object(value: Object) -> Variant:
 	return _describe_object(value)
 
 
+## An input event, by what it is bound to: the engine's own words for it and every field it stores
+## away from its default. As a bare resource it was its class and nothing else, so an input action
+## read back from project.godot could not say whether it was bound to Space or to a joypad button.
+func _describe_input_event(event: InputEvent) -> Dictionary:
+	var described: Dictionary = {"class": event.get_class(), "_type": "Resource", "text": event.as_text()}
+	for property: Dictionary in event.get_property_list():
+		var usage: int = property.get("usage", 0)
+		var name: String = str(property.get("name", ""))
+		if not (usage & PROPERTY_USAGE_STORAGE) or name.begins_with("resource_") or name == "script":
+			continue
+		var held: Variant = event.get(name)
+		if held == ClassDB.class_get_property_default_value(event.get_class(), name):
+			continue
+		described[name] = serialize_value(held)
+	return described
+
+
 ## A plain object, said in enough detail to tell it from the one beside it.
 ##
 ## `{"class": "RefCounted"}` was all of it, so a roster of twelve people came back as the word