gdharness 1.3.51 → 1.3.53

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

@@ -6,6 +6,7 @@ extends EditorPlugin
 
 const GdhBridgeClient = preload("bridge_client.gd")
 const GdhToolExecutor = preload("tool_executor.gd")
+const GdhReleaseExport = preload("release_export.gd")
 ## The tools answered while the editor scans or imports, because none of them saves a file: the
 ## ones a caller waits on a scan with, and the ones that only read or stop a played game.
 const ANSWERED_WHILE_SCANNING: Array[String] = [
@@ -20,9 +21,13 @@ const ANSWERED_WHILE_SCANNING: Array[String] = [
 var _client: GdhBridgeClient
 var _tool_executor: GdhToolExecutor
 var _status_label: Label
+var _release_export: GdhReleaseExport
 
 
 func _enter_tree() -> void:
+	_release_export = GdhReleaseExport.new()
+	add_export_plugin(_release_export)
+
 	_client = GdhBridgeClient.new()
 	_client.name = "GdharnessBridgeClient"
 	add_child(_client)
@@ -41,6 +46,10 @@ func _enter_tree() -> void:
 
 
 func _exit_tree() -> void:
+	if _release_export:
+		remove_export_plugin(_release_export)
+		_release_export = null
+
 	if _client:
 		if _client.connected.is_connected(_on_connected):
 			_client.connected.disconnect(_on_connected)

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

@@ -0,0 +1,66 @@
+@tool
+extends EditorExportPlugin
+## Leaves gdharness out of a release export: the runtime autoload's entry, its loader and the
+## addons, none of which does anything in a release build, so no player's build carries them. A
+## debug export keeps them, since the runtime serves a debug build.
+
+## The loader the runtime autoload's entry names, as `gdharness setup` writes it.
+const LOADER: String = "res://gdharness/loader.gd"
+## The folders a release export leaves out: the loader's and the addons that never run there.
+const LEFT_OUT: Array[String] = [
+	"res://gdharness/",
+	"res://addons/gdharness_runtime/",
+	"res://addons/gdharness_editor/",
+	"res://addons/auto_reload/",
+]
+
+## Each autoload entry taken out for the export, by setting name, with its value and its order.
+var _values: Dictionary[String, Variant] = {}
+var _orders: Dictionary[String, int] = {}
+var _release: bool = false
+
+
+## Before "GDScript", by which the export orders its plugins: a file stops at the first that skips
+## or replaces it, and that one turns every script into tokens, so a later skip leaves them in.
+func _get_name() -> String:
+	return "GDHarness"
+
+
+func _export_begin(
+	_features: PackedStringArray, is_debug: bool, _path: String, _flags: int
+) -> void:
+	_release = not is_debug
+	_values.clear()
+	_orders.clear()
+	if not _release:
+		return
+	# The export writes project.binary from the settings as they stand once this returns, and the
+	# editor saves project.godot only for an edit made in its settings dialog.
+	for property: Dictionary in ProjectSettings.get_property_list():
+		var setting: String = property["name"]
+		if not setting.begins_with("autoload/"):
+			continue
+		var value: Variant = ProjectSettings.get_setting(setting)
+		if value is String and str(value).trim_prefix("*") == LOADER:
+			_values[setting] = value
+			_orders[setting] = ProjectSettings.get_order(setting)
+	for setting: String in _values:
+		ProjectSettings.set_setting(setting, null)
+
+
+func _export_file(path: String, _type: String, _features: PackedStringArray) -> void:
+	if not _release:
+		return
+	for folder: String in LEFT_OUT:
+		if path.begins_with(folder):
+			skip()
+			return
+
+
+func _export_end() -> void:
+	for setting: String in _values:
+		ProjectSettings.set_setting(setting, _values[setting])
+		ProjectSettings.set_order(setting, _orders[setting])
+	_values.clear()
+	_orders.clear()
+	_release = false

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

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

package/build/godot/loader/loader.gd

@@ -31,8 +31,9 @@ func _ready() -> void:
 	_runtime = runtime
 
 
-## Whether gdharness's runtime is listening in this engine: false in a release build, a script run
-## and an engine without the addon, though this node is in every one of them.
+## Whether gdharness's runtime is listening in this engine: false in a script run, an engine without
+## the addon and a release build that still carries this node, though it is in every one of them. A
+## release export made with the editor addon enabled leaves this node out.
 func serving() -> bool:
 	if not is_instance_valid(_runtime) or not _runtime.has_method("serving"):
 		return false

package/build/godot/tests/listed.gd

@@ -7,10 +7,10 @@ extends SceneTree
 ##
 ## Started from outside the project, `-s` with this file's absolute path, so it declares no class of
 ## its own and reaches gdUnit4 through the project's global classes. Besides the file of suites it
-## finds each case by its id in a dictionary ([GdhIndexedSession]), can compile the suites together
-## before gdUnit4 loads them ([constant TOGETHER]), can turn off the reports the caller does
-## not read ([constant REPORTS_OFF]), and writes the errors and warnings each suite declares it
-## prints ([constant EXPECTED_OUT]).
+## finds each case by its id in a dictionary ([GdhIndexedSession]), can turn off the reports the
+## caller does not read ([constant REPORTS_OFF]), writes the errors and warnings each suite declares
+## it prints ([constant EXPECTED_OUT]) and what the run loads ([constant REACHED_OUT]), and in an
+## engine of its own compiles every script together ([constant COMPILE_ONLY]).
 
 const LISTED: String = "--suites-in"
 const SKIPPING: String = "--skipping-in"
@@ -42,11 +42,6 @@ const REPORTS_OFF: Dictionary[String, String] = {
 	"--html-report-off": "res://addons/gdUnit4/src/core/hooks/GdUnitHtmlReporterTestSessionHook.gd",
 	"--junit-report-off": "res://addons/gdUnit4/src/core/hooks/GdUnitXMLReporterTestSessionHook.gd",
 }
-## Compiles the suites together beside every class of the game ([method compiled_together]) before
-## gdUnit4 loads them. A gate asks for it, since it runs every suite and wants every script that
-## does not compile named. project_test does not: its answer is about the scripts its run reached,
-## and the compile names every broken script of the game, then once more as the one script it made.
-const TOGETHER: String = "--compile-together"
 ## The file to write what every suite declares it prints into, as JSON: each key of
 ## [constant EXPECTED] holding the declarations keyed by suite path and then case name.
 const EXPECTED_OUT: String = "--expected-out"
@@ -56,6 +51,20 @@ const EXPECTED: Dictionary[String, String] = {
 	"errors": "GDHARNESS_EXPECTED_ERRORS",
 	"warnings": "GDHARNESS_EXPECTED_WARNINGS",
 }
+## Compiles the engine's own suites together ([method compiled_together]) before gdUnit4 loads them,
+## so they share one reading of what they reach, and no class of the game they do not: what the
+## engine holds is then what its suites reach, which is what [constant REACHED_OUT] records.
+const TOGETHER: String = "--compile-together"
+## The file to write what the run loads into, a line as each suite ends ([GdhReached]).
+const REACHED_OUT: String = "--reached-out"
+## Compiles the suites together beside every class of the game ([method compiled_together]), prints
+## [constant COMPILED] and quits, running no suite: a run's check of every script, made in an engine
+## of its own so the engines running its suites load only what their suites do. `gdharness test`
+## asks for it, since it wants every script that does not compile named. project_test does not: its
+## answer is about the scripts its run reached, and the compile names every broken script of the
+## game, then once more as the one script it made.
+const COMPILE_ONLY: String = "--compile-only"
+const COMPILED: String = "gdharness compiled every script together"
 ## The tool name gdUnit4 reads its options after.
 const TOOL: String = "GdUnitCmdTool.gd"
 ## Ends the runner's own arguments: everything after it is gdUnit4's options, for a run with no
@@ -76,8 +85,23 @@ const WALK_HOLD: StringName = &"gdharness_scripts_held_past_the_shutdown_walk"
 var _runner: GdhRunner = null
 
 
+## Here rather than in [method _initialize]: Godot loads the script given with `-s` and makes its
+## instance before it loads the autoloads, so a load an autoload makes as it is made is recorded
+## too.
+func _init() -> void:
+	var into: String = argument_after(OS.get_cmdline_user_args(), REACHED_OUT)
+	if not into.is_empty():
+		GdhReached.start(into)
+
+
 func _initialize() -> void:
-	_runner = started(OS.get_cmdline_user_args())
+	var given: PackedStringArray = OS.get_cmdline_user_args()
+	if given.has(COMPILE_ONLY):
+		compile_only(given)
+		return
+	if GdhReached.current != null:
+		GdhReached.current.autoloaded()
+	_runner = started(given)
 	_runner.own_path = get_script().resource_path
 	root.add_child(_runner)
 
@@ -86,11 +110,32 @@ func _initialize() -> void:
 ## The runner is not queued for deletion here, as gdUnit4's does: the tree has freed root and the
 ## runner with it before this is called, and queueing a freed node writes into freed memory.
 func _finalize() -> void:
+	GdhReached.stop()
 	if OS.is_stdout_verbose():
 		print("Orphan nodes left as the run ends:")
 		Window.print_orphan_nodes()
 
 
+## Compiles the suites [param given] lists together and quits, holding the scripts past the
+## engine's shutdown walk as a run of suites does ([GdhShutdownWalk]).
+func compile_only(given: PackedStringArray) -> void:
+	var oldest: Array[GDScript] = []
+	if GdhShutdownWalk.guarded():
+		oldest = GdhShutdownWalk.marker(WALK_ENDED)
+	var together: GDScript = compiled_together(listed(given, LISTED), held_classes())
+	print(COMPILED)
+	if GdhShutdownWalk.guarded():
+		var also: Array[GDScript] = oldest.duplicate()
+		also.append_array(GdhShutdownWalk.marker(WALK_BEGAN))
+		also.append(together)
+		var own_path: String = get_script().resource_path
+		var own: GDScript = ResourceLoader.get_cached_ref(own_path) as GDScript
+		if own != null:
+			also.append(own)
+		GdhShutdownWalk.hold(also)
+	quit()
+
+
 ## The runner over the suites [param given] lists, to be added to the tree, which starts it. Shared
 ## by this script and the suites scene of the tests addon, which loads this file from where the
 ## server ships it and calls this, since the addon itself names no gdUnit4 class.
@@ -125,7 +170,7 @@ static func started(given: PackedStringArray) -> GdhRunner:
 	if at >= 0:
 		runner.given = given.slice(at + 1)
 	if asked.has(TOGETHER):
-		runner.together = compiled_together(suites)
+		runner.together = compiled_together(suites, [])
 	var expected_out: String = argument_after(asked, EXPECTED_OUT)
 	if not expected_out.is_empty():
 		write_expected(expected_out, suites)
@@ -162,16 +207,16 @@ static func unread_off(
 ## [param suites] compiled inside one script, answered for the caller to hold so gdUnit4's own loads
 ## find them compiled. The engine keeps what it read of a class only while the compile that asked
 ## for it runs (`GDScriptCache`), so a suite compiled on its own reads again every class it reaches
-## a member of, some seventy milliseconds a suite. As the preloads of one script naming every class
-## of the game's own first, held from that script's compile, they share one reading of each: two
-## hundred suites compiled in a third of the time they took one at a time. The names are public,
+## a member of, some seventy milliseconds a suite. As the preloads of one script, after the
+## [param classes] it names first, held from that script's compile, they share one reading of each:
+## two hundred suites compiled in a third of the time they took one at a time. The names are public,
 ## since a private one unread is a warning and every warning an error, and each a variable, since a
 ## class is no constant expression. A suite that does not compile fails here and again when gdUnit4
 ## loads it, which reports it as it would have. A directory listed is left to gdUnit4 to walk.
-static func compiled_together(suites: PackedStringArray) -> GDScript:
+static func compiled_together(suites: PackedStringArray, classes: PackedStringArray) -> GDScript:
 	var lines: PackedStringArray = ["extends RefCounted"]
 	var at: int = 0
-	for named: String in held_classes():
+	for named: String in classes:
 		var _held: bool = lines.append("var held_%d: Variant = %s" % [at, named])
 		at += 1
 	at = 0
@@ -186,7 +231,7 @@ static func compiled_together(suites: PackedStringArray) -> GDScript:
 	return together
 
 
-## The classes [method compiled_together] names before the suites: the game's own GDScript classes,
+## The classes [constant COMPILE_ONLY] compiles before the suites: the game's own GDScript classes,
 ## none of an addon's or a suite's, then gdUnit4's suite. Only GDScript shares the engine's reading,
 ## and a sandboxed mod's SafeGDScript class would load the sandbox's compiler, some 290 MB and up to
 ## 2.5 s, for nothing.
@@ -455,6 +500,8 @@ class GdhRunner:
 					var _watched: int = tree.process_frame.connect(drawn_window)
 			GdUnitEvent.TESTSUITE_BEFORE:
 				drawn_window()
+				if GdhReached.current != null:
+					GdhReached.current.began(event.resource_path())
 				suite_running = event.resource_path()
 				orphans_at_suite = orphan_ids()
 				orphans_named.clear()
@@ -472,6 +519,8 @@ class GdhRunner:
 		# gdUnit4 minimises the window once the suite's end is reported.
 		if event.type() == GdUnitEvent.TESTSUITE_AFTER:
 			minimise_pending = true
+			if GdhReached.current != null:
+				GdhReached.current.ended(event.resource_path())
 		# After gdUnit4's own report of the case, so the line falls under it.
 		if event.orphan_nodes() == 0:
 			return
@@ -743,3 +792,128 @@ class GdhShutdownWalk:
 				if not inner.begins_with("."):
 					var _inner: bool = pending.append(directory.path_join(inner))
 		ThemeDB.set_meta(WALK_HOLD, held)
+
+
+## What the run loads, written to the file named after [constant REACHED_OUT] a line of JSON at a
+## time, each with every path asked for since the line before: one once the autoloads are loaded,
+## one as each suite begins, which also names the project's files the cache holds then, and one as
+## it ends. The engine answers a load of a resource it holds from its cache without asking any
+## loader, and it holds one only while something refers to it, so what a suite can load unasked is
+## what the cache held as it began. Placed first among the loaders, it is asked about every load and
+## every [method ResourceLoader.exists] and declines each. A script compiled for a preload, a base
+## or a class name is read without a loader, so a suite's last line also has the project's files
+## the cache came to hold that no loader was asked for.
+class GdhReached:
+	extends ResourceFormatLoader
+
+	static var current: GdhReached = null
+
+	var _file: FileAccess = null
+	## Loads on other threads ask too, as a threaded load runs its own.
+	var _mutex: Mutex = Mutex.new()
+	## What the current line holds, since a path freed and loaded again is asked for again.
+	var _seen: Dictionary[String, bool] = {}
+	var _fresh: PackedStringArray = []
+	var _files: PackedStringArray = []
+	var _resident: Dictionary[String, bool] = {}
+
+	static func start(into: String) -> void:
+		var file: FileAccess = FileAccess.open(into, FileAccess.WRITE)
+		if file == null:
+			push_error(
+				(
+					"gdharness test could not write what the run loads to %s: %s"
+					% [into, error_string(FileAccess.get_open_error())]
+				)
+			)
+			return
+		current = GdhReached.new()
+		current._file = file
+		current._files = project_files()
+		ResourceLoader.add_resource_format_loader(current, true)
+
+	static func stop() -> void:
+		if current == null:
+			return
+		ResourceLoader.remove_resource_format_loader(current)
+		current._file.close()
+		current = null
+
+	## Every file under res:// the engine sees, as its file system does: no hidden folder, and no
+	## folder holding a `.gdignore`.
+	static func project_files() -> PackedStringArray:
+		var found: PackedStringArray = []
+		var pending: PackedStringArray = ["res://"]
+		while not pending.is_empty():
+			var directory: String = pending[pending.size() - 1]
+			pending.remove_at(pending.size() - 1)
+			if FileAccess.file_exists(directory.path_join(".gdignore")):
+				continue
+			for file: String in DirAccess.get_files_at(directory):
+				if not file.ends_with(".import") and not file.ends_with(".uid"):
+					var _file_found: bool = found.append(directory.path_join(file))
+			for inner: String in DirAccess.get_directories_at(directory):
+				if not inner.begins_with("."):
+					var _inner: bool = pending.append(directory.path_join(inner))
+		return found
+
+	func _recognize_path(path: String, _type: StringName) -> bool:
+		_mutex.lock()
+		if not _seen.has(path):
+			_seen[path] = true
+			var _asked: bool = _fresh.append(path)
+		_mutex.unlock()
+		return false
+
+	func _get_recognized_extensions() -> PackedStringArray:
+		return []
+
+	func _handles_type(_type: StringName) -> bool:
+		return false
+
+	## Writes the line for the autoloads, which have all been loaded by now.
+	func autoloaded() -> void:
+		written({ "autoloads": true })
+
+	## Writes the line of the suite at [param suite], which is about to begin, with what the cache
+	## holds. The cache is asked outside the lock, since a load on another thread holds the cache's
+	## own lock while it asks this.
+	func began(suite: String) -> void:
+		var resident: PackedStringArray = []
+		_resident.clear()
+		for path: String in _files:
+			if ResourceLoader.has_cached(path):
+				var _held: bool = resident.append(path)
+				_resident[path] = true
+		written({ "began": suite, "resident": resident })
+
+	## Writes the line of the suite at [param suite], which has just ended, with the project's files
+	## the cache came to hold while it ran that no loader was asked for.
+	func ended(suite: String) -> void:
+		_mutex.lock()
+		var unseen: PackedStringArray = []
+		for path: String in _files:
+			if not _seen.has(path) and not _resident.has(path):
+				var _unseen: bool = unseen.append(path)
+		_mutex.unlock()
+		var cached: PackedStringArray = []
+		for path: String in unseen:
+			if ResourceLoader.has_cached(path):
+				var _cached: bool = cached.append(path)
+		_mutex.lock()
+		for path: String in cached:
+			if not _seen.has(path):
+				_seen[path] = true
+				var _held: bool = _fresh.append(path)
+		_mutex.unlock()
+		written({ "suite": suite })
+
+	## Writes [param fields] as a line with every path asked for since the line before.
+	func written(fields: Dictionary) -> void:
+		_mutex.lock()
+		fields["reached"] = _fresh
+		_fresh = []
+		_seen.clear()
+		_mutex.unlock()
+		var _stored: bool = _file.store_line(JSON.stringify(fields))
+		_file.flush()