gdharness 1.3.46 → 1.3.48

package/build/godot/operations/export_presets.gd

@@ -121,6 +121,26 @@ static func _runnable(config: ConfigFile, section: String) -> bool:
 	return GdhRead.as_bool(config.get_value(section, "runnable", false))
 
 
+## The name of the preset [param platform] runs, or "" when it has none: the one its section names,
+## or in a file saved before that section, the last preset of the platform keeping the key, which is
+## the one the editor ends up running. Read from the section alone, a file of that age had no
+## runnable preset, so a preset added for its platform took the place of the one it had.
+static func _runnable_name(config: ConfigFile, platform: String) -> String:
+	if config.has_section_key(RUNNABLE_SECTION, platform):
+		return str(config.get_value(RUNNABLE_SECTION, platform))
+	var named: String = ""
+	var at: int = 0
+	while config.has_section("preset." + str(at)):
+		var section: String = "preset." + str(at)
+		if (
+			str(config.get_value(section, "platform", "")) == platform
+			and GdhRead.as_bool(config.get_value(section, "runnable", false))
+		):
+			named = str(config.get_value(section, "name", ""))
+		at += 1
+	return named
+
+
 ## Adds an export preset to export_presets.cfg, written with the keys the editor's Project > Export
 ## writes for a new one, and every option in [code]known_options[/code] (what
 ## [method export_options] answers for the platform) at its default. The editor also writes the
@@ -160,7 +180,7 @@ func add_export_preset(params: Dictionary) -> Dictionary:
 			)
 		index += 1
 	# A platform with no preset to run takes the new one, as the editor's dialog does.
-	var runnable: bool = not config.has_section_key(RUNNABLE_SECTION, platform)
+	var runnable: bool = _runnable_name(config, platform).is_empty()
 	if runnable:
 		config.set_value(RUNNABLE_SECTION, platform, preset_name)
 
@@ -609,6 +629,7 @@ func remove_export_preset(params: Dictionary) -> Dictionary:
 	var index: int = found["index"]
 	var section: String = found["section"]
 	var platform: String = str(config.get_value(section, "platform", ""))
+	var was_runnable: bool = _runnable_name(config, platform) == preset_name
 	var last: int = index
 	while config.has_section("preset." + str(last + 1)):
 		last += 1
@@ -622,11 +643,17 @@ func remove_export_preset(params: Dictionary) -> Dictionary:
 		if keeping != OK:
 			return _log.failure("Failed to save %s: %s" % [CREDENTIALS_FILE, error_string(keeping)])
 		answer["credentials"] = CREDENTIALS_FILE
-	if str(config.get_value(RUNNABLE_SECTION, platform, "")) == preset_name:
-		config.set_value(RUNNABLE_SECTION, platform, null)
-		answer["runnableNow"] = null
+	if was_runnable:
+		if config.has_section_key(RUNNABLE_SECTION, platform):
+			config.set_value(RUNNABLE_SECTION, platform, null)
+		# A file saved before the section can mark another preset of the platform too, which the
+		# editor then runs.
+		var kept: String = _runnable_name(config, platform)
+		answer["runnableNow"] = kept
+		if kept.is_empty():
+			answer["runnableNow"] = null
 		var at: int = 0
-		while config.has_section("preset." + str(at)):
+		while kept.is_empty() and config.has_section("preset." + str(at)):
 			if str(config.get_value("preset." + str(at), "platform", "")) == platform:
 				var next: String = str(config.get_value("preset." + str(at), "name", ""))
 				config.set_value(RUNNABLE_SECTION, platform, next)

package/build/godot/operations/file_reads.gd

@@ -356,6 +356,12 @@ static func _entry(
 	var data: Dictionary = {
 		"name": node["name"], "type": node["type"], "path": path, "children": children,
 	}
+	var given_values: Dictionary = node["properties"]
+	var attached: Variant = given_values.get("script")
+	if attached is Script:
+		var script: Script = attached
+		if not str(script.get_global_name()).is_empty():
+			data["scriptClass"] = str(script.get_global_name())
 	# The root's file is the scene being read, so only another node's names a second scene.
 	if path != "." and node.has("instanceOf"):
 		data["instanceOf"] = node["instanceOf"]

package/build/godot/operations/import_pipeline.gd

@@ -212,7 +212,7 @@ func set_import_options(params: Dictionary) -> Dictionary:
 	var refused: Array[String] = []
 	for key: Variant in options:
 		var name: String = str(key)
-		var held: Variant = config.get_value("params", name, null)
+		var held: Variant = _held(config, name)
 		var given: Variant = _values.deserialize_value(options[key])
 		var value: Variant = _as_option(_values.fitted(options[key], typeof(held)), held)
 		if value is Dictionary:
@@ -248,7 +248,7 @@ func set_import_options(params: Dictionary) -> Dictionary:
 	var unchanged_keys: Array[String] = []
 	var changes: Dictionary = {}
 	for name: String in fitted_values:
-		var held: Variant = config.get_value("params", name, null)
+		var held: Variant = _held(config, name)
 		var value: Variant = fitted_values[name]
 		if held != null and typeof(held) == typeof(value) and held == value:
 			unchanged_keys.append(name)
@@ -275,6 +275,14 @@ func set_import_options(params: Dictionary) -> Dictionary:
 	return answer
 
 
+## What the option [param name] holds in [param config]'s params, or null when it holds none. Asked
+## with a default of null, the engine prints an error for a key the file does not have.
+static func _held(config: ConfigFile, name: String) -> Variant:
+	if not config.has_section_key("params", name):
+		return null
+	return config.get_value("params", name)
+
+
 ## [param given] as the option holds it. Every JSON number arrives as a float, and an enum option
 ## such as compress/mode written as 1.0 is kept that way by the import, so a whole number becomes
 ## an int unless the option already holds a float.

package/build/godot/operations/project_config.gd

@@ -413,6 +413,9 @@ func add_autoload(params: Dictionary) -> Dictionary:
 		return _log.failure(
 			GdhFileWalk.new().with_nearest_files("Autoload file does not exist: " + path, path)
 		)
+	var unloadable: String = _not_an_autoload(path)
+	if not unloadable.is_empty():
+		return _log.failure(unloadable)
 
 	# 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.
@@ -453,6 +456,38 @@ func add_autoload(params: Dictionary) -> Dictionary:
 	return answer
 
 
+## Why the file at [param path] cannot be an autoload, or empty when it can, as the editor's
+## Autoload
+## tab judges it: a scene, or a script whose instances are nodes. Written anyway, a script extending
+## RefCounted saved fine and every start of the game then failed to instantiate it. A script that
+## does not compile is let through, since it may be one being written, and its errors are its own.
+static func _not_an_autoload(path: String) -> String:
+	var refused: String = "%s is %s, and an autoload is a scene or a script extending Node"
+	if not ResourceLoader.exists(path):
+		return (refused + "; nothing was written.") % [path, "a file Godot does not load"]
+	var loaded: Resource = load(path)
+	if loaded is PackedScene:
+		return ""
+	if not loaded is Script:
+		var kind: String = "nothing Godot could load"
+		if loaded != null:
+			kind = "a " + loaded.get_class()
+		return (refused + "; nothing was written.") % [path, kind]
+	var script: Script = loaded
+	if not script.can_instantiate():
+		return ""
+	var base: StringName = script.get_instance_base_type()
+	if ClassDB.is_parent_class(base, "Node"):
+		return ""
+	return (
+		(
+			"%s extends %s, which is not a Node, and Godot instantiates an autoload under the root "
+			+ "as a node, so every start of the game would fail to load it; nothing was written."
+		)
+		% [path, base]
+	)
+
+
 ## 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.

package/build/godot/operations/resource_files.gd

@@ -36,10 +36,9 @@ func get_uid(params: Dictionary) -> Dictionary:
 	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["uid"] = null
 		answer["message"] = _why_none(file_path)
 		return answer
-	answer["exists"] = true
 	answer.merge(found)
 	return answer
 

package/build/godot/tests/listed.gd

@@ -357,6 +357,9 @@ class GdhRunner:
 	var case_began: bool = false
 	## The suite running, which a case's own event does not carry.
 	var suite_running: String = ""
+	## Whether gdUnit4 has minimised the window, or is about to, and it is not back yet: it does as
+	## its runner starts, and after every suite.
+	var minimise_pending: bool = true
 
 	## As the run ends, the marker of the walk's newest end, and every script held past the walk, on
 	## an engine whose walk can stop part way ([GdhShutdownWalk]).
@@ -446,7 +449,11 @@ class GdhRunner:
 			GdUnitEvent.SESSION_START:
 				if not GdhIndexedSession.indexes_itself(_test_session):
 					_test_session = GdhIndexedSession.of(_test_session)
+				var tree: SceneTree = get_tree()
+				if not tree.process_frame.is_connected(drawn_window):
+					var _watched: int = tree.process_frame.connect(drawn_window)
 			GdUnitEvent.TESTSUITE_BEFORE:
+				drawn_window()
 				suite_running = event.resource_path()
 				orphans_at_suite = orphan_ids()
 				orphans_named.clear()
@@ -461,6 +468,9 @@ class GdhRunner:
 			GdUnitEvent.TESTCASE_AFTER:
 				cases_ended += 1
 		super(event)
+		# gdUnit4 minimises the window once the suite's end is reported.
+		if event.type() == GdUnitEvent.TESTSUITE_AFTER:
+			minimise_pending = true
 		# After gdUnit4's own report of the case, so the line falls under it.
 		if event.orphan_nodes() == 0:
 			return
@@ -478,6 +488,21 @@ class GdhRunner:
 				"after", left.filter(func(id: int) -> bool: return not orphans_from_before.has(id))
 			)
 
+	## The window back from minimised, which gdUnit4 makes it as its runner starts and after every
+	## suite, and where Godot draws nothing: a suite given a window to render in waited for a
+	## frame_post_draw that never came. Called as a suite begins, ahead of its before(), and every
+	## frame after, since on macOS the minimise is an animation that reads as windowed until it
+	## ends, and a window not yet minimised cannot be put back. Only once for each minimise of
+	## gdUnit4's, so a suite minimising the window itself keeps it minimised.
+	func drawn_window() -> void:
+		if not minimise_pending or DisplayServer.get_name() == "headless":
+			return
+		if Engine.is_embedded_in_editor():
+			return
+		if DisplayServer.window_get_mode() == DisplayServer.WINDOW_MODE_MINIMIZED:
+			DisplayServer.window_set_mode(DisplayServer.WINDOW_MODE_WINDOWED)
+			minimise_pending = false
+
 	## The orphans now that were not there in [param before] and no line has named yet.
 	func new_orphans(before: Dictionary[int, bool]) -> Array[int]:
 		var found: Array[int] = []