gdharness 1.1.4 → 1.1.6

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

@@ -80,10 +80,13 @@ func _init_tools() -> void:
 		"list_connections": [_scene_tools, "list_connections"],
 		"rescan_filesystem": [_scene_tools, "rescan_filesystem"],
 		"scan_status": [_scene_tools, "scan_status"],
+		"reimport_files": [_scene_tools, "reimport_files"],
 		"global_classes": [_class_tools, "global_classes"],
 		"reload_script": [_class_tools, "reload_script"],
 		# Settings, for a caller that asked the editor rather than the file on disk
 		"get_project_setting": [_settings_tools, "get_project_setting"],
+		"adopt_project_settings": [_settings_tools, "adopt_project_settings"],
+		"adopt_audio_bus_layout": [_settings_tools, "adopt_audio_bus_layout"],
 		# Resource tools
 		"create_resource": [_resource_tools, "create_resource"],
 		"modify_resource": [_resource_tools, "modify_resource"],

package/build/godot/addons/gdharness_editor/tools/scene_tools.gd

@@ -11,29 +11,35 @@ var _editor_plugin: EditorPlugin = null
 var _values: Serialisation = Serialisation.new()
 var _properties: PropertyValues = PropertyValues.new()
 
-## How many times the editor has said its filesystem changed, which a scan run on the main thread
-## does before `scan()` returns: counted so a rescan can tell a scan that ran there from one the
-## editor declined.
-var _scans_finished: int = 0
-
-## When the last scan finished, on the engine's clock, or -1 before the first. The editor writes
+## How many scans the editor has completed, counted off `sources_changed`, which it emits at the end
+## of every scan once the reimport the scan found is done: the one moment a scan is over. Neither
+## flag it offers says so. A threaded scan stops reporting itself when its thread finishes, and its
+## import runs a frame or more later when the thread is joined; an editor in the background took
+## long enough over that frame that a rescan answered before the import of 211 changed scenes began.
+var _scans_completed: int = 0
+
+## When the last scan completed, on the engine's clock, or -1 before the first. The editor writes
 ## the class cache a frame after it stops reporting a scan, measured on 4.7.2, so a game started
 ## in between reads a file being rewritten; how long ago the scan ended is what tells a caller
 ## whether that write can still be coming.
 var _scan_finished_at_msec: int = -1
 
+## How many reimports asked for through [method reimport_files] have finished. Counted here rather
+## than off `resources_reimported`, which a scan's own import emits as well.
+var _reimports_completed: int = 0
+
 
 func set_editor_plugin(plugin: EditorPlugin) -> void:
 	_editor_plugin = plugin
 	var filesystem: EditorFileSystem = EditorInterface.get_resource_filesystem()
-	if not filesystem.filesystem_changed.is_connected(_scan_finished):
-		var watched: int = filesystem.filesystem_changed.connect(_scan_finished)
+	if not filesystem.sources_changed.is_connected(_scan_completed):
+		var watched: int = filesystem.sources_changed.connect(_scan_completed)
 		if watched != OK:
-			push_error("gdharness could not watch for finished scans: %d" % watched)
+			push_error("gdharness could not watch for completed scans: %d" % watched)
 
 
-func _scan_finished() -> void:
-	_scans_finished += 1
+func _scan_completed(_sources_exist: bool) -> void:
+	_scans_completed += 1
 	_scan_finished_at_msec = Time.get_ticks_msec()
 
 
@@ -658,8 +664,8 @@ func rescan_filesystem(args: Dictionary) -> Dictionary:
 	# conditions from its progress dialog. Declined and said, so the caller waits and asks again.
 	var busy: bool = filesystem.is_scanning() or filesystem.is_importing()
 	var started: bool = false
+	var completed_before: int = _scans_completed
 	if not Read.as_bool(args.get("statusOnly", false)) and not busy:
-		var finished_before: int = _scans_finished
 		filesystem.scan()
 		# Whether the scan ran, read off the editor rather than assumed. `scan()` returns without
 		# a word while the thread of the scan before is still to be joined, which is a frame or
@@ -668,16 +674,19 @@ func rescan_filesystem(args: Dictionary) -> Dictionary:
 		# downstream, a rescan after 698 files were rewritten answered finished in 1.5s and the
 		# one changed file stayed on its old import. A threaded scan reports itself from inside
 		# the call, and one run on this thread has finished and signalled before it returns.
-		started = filesystem.is_scanning() or _scans_finished != finished_before
+		started = filesystem.is_scanning() or _scans_completed != completed_before
 
 	# Importing is reported separately from scanning, and a class is not registered until
-	# both are done, so a caller watching only one of them can look too early.
+	# both are done, so a caller watching only one of them can look too early. The two counts are
+	# what a caller waits on: the scan it asked for is over once the count has moved past the one
+	# from before it was asked.
 	return {
 		"ok": true,
 		"started": started,
 		"scanning": filesystem.is_scanning(),
 		"importing": filesystem.is_importing(),
-		"scansFinished": _scans_finished,
+		"scansCompletedBefore": completed_before,
+		"scansCompleted": _scans_completed,
 	}
 
 
@@ -696,4 +705,44 @@ func scan_status(_args: Dictionary) -> Dictionary:
 		"importing": filesystem.is_importing(),
 		"sinceScanFinishedMs":
 		-1 if _scan_finished_at_msec < 0 else Time.get_ticks_msec() - _scan_finished_at_msec,
+		"reimportsCompleted": _reimports_completed,
 	}
+
+
+## Reimport the files named under `paths`, whatever their state, the way the editor's Reimport
+## button does, and report whether the reimport was started.
+##
+## Started on the next frame rather than run here: the editor imports on its main thread, and a
+## reimport of a few hundred scenes outlasts the wait on any one command. The caller waits for
+## `reimportsCompleted` in [method scan_status] to move past `reimportsCompletedBefore`. Declined
+## while the editor scans or imports, since `reimport_files` refuses to run inside an import.
+func reimport_files(args: Dictionary) -> Dictionary:
+	if not _editor_plugin:
+		return {"ok": false, "error": "Editor plugin unavailable"}
+	var paths: Array[String] = []
+	var given: Variant = args.get("paths", [])
+	if given is Array:
+		for path: Variant in given:
+			paths.append(str(path))
+	if paths.is_empty():
+		return {"ok": false, "error": "reimport_files needs paths"}
+	var filesystem: EditorFileSystem = EditorInterface.get_resource_filesystem()
+	var busy: bool = filesystem.is_scanning() or filesystem.is_importing()
+	if not busy:
+		_reimport.call_deferred(PackedStringArray(paths))
+	return {
+		"ok": true,
+		"started": not busy,
+		"scanning": filesystem.is_scanning(),
+		"importing": filesystem.is_importing(),
+		"reimportsCompletedBefore": _reimports_completed,
+	}
+
+
+func _reimport(paths: PackedStringArray) -> void:
+	var filesystem: EditorFileSystem = EditorInterface.get_resource_filesystem()
+	# A scan can begin between the answer and this frame, and its import would refuse this one.
+	while filesystem.is_scanning() or filesystem.is_importing():
+		await get_tree().process_frame
+	filesystem.reimport_files(paths)
+	_reimports_completed += 1

package/build/godot/addons/gdharness_editor/tools/settings_tools.gd

@@ -1,7 +1,8 @@
 @tool
 extends Node
 
-## Project settings read from the open editor, for a caller that asked for the editor's answer.
+## Project settings read from the open editor, for a caller that asked for the editor's answer, and
+## taken up by it after a write to the file.
 ##
 ## The same question answered headless starts an engine, loads project.godot from disk and exits.
 ## This answers from the ProjectSettings the editor already has, which costs nothing and is not the
@@ -56,3 +57,51 @@ func _settings_under(prefix: String) -> Dictionary:
 
 	found.sort_custom(func(a: Dictionary, b: Dictionary) -> bool: return a["setting"] < b["setting"])
 	return {"ok": true, "prefix": prefix, "count": found.size(), "settings": found}
+
+
+## Takes the named settings from project.godot as it is on disk, after something else wrote it.
+##
+## The editor loads the file once, at startup. Written from outside, it goes on holding the old
+## values, answers them when asked, and writes them back over the new ones the next time it saves
+## the project settings. A setting gone from the file goes back to its default, or goes altogether
+## when the engine declares none, as an autoload does once it is removed.
+func adopt_project_settings(args: Dictionary) -> Dictionary:
+	var file: ConfigFile = ConfigFile.new()
+	var loaded: Error = file.load("res://project.godot")
+	if loaded != OK:
+		return {"ok": false, "error": "Could not read project.godot: " + error_string(loaded)}
+	var adopted: Array[String] = []
+	var named: Variant = args.get("settings", [])
+	if not named is Array:
+		return {"ok": false, "error": "settings must be a list of setting names"}
+	var settings: Array = named
+	for entry: Variant in settings:
+		var setting: String = str(entry)
+		var at: int = setting.find("/")
+		if at <= 0:
+			continue
+		var section: String = setting.substr(0, at)
+		var key: String = setting.substr(at + 1)
+		if file.has_section_key(section, key):
+			ProjectSettings.set_setting(setting, file.get_value(section, key))
+		elif ProjectSettings.property_can_revert(setting):
+			ProjectSettings.set_setting(setting, ProjectSettings.property_get_revert(setting))
+		else:
+			ProjectSettings.set_setting(setting, null)
+		adopted.append(setting)
+	return {"ok": true, "adopted": adopted}
+
+
+## Loads the bus layout the project names into the editor's audio server, after something else
+## wrote it: the editor holds the layout it loaded and saves that one when its audio panel changes.
+func adopt_audio_bus_layout(_args: Dictionary) -> Dictionary:
+	var path: String = str(
+		ProjectSettings.get_setting("audio/buses/default_bus_layout", "res://default_bus_layout.tres")
+	)
+	var layout: AudioBusLayout = ResourceLoader.load(
+		path, "AudioBusLayout", ResourceLoader.CACHE_MODE_REPLACE
+	)
+	if layout == null:
+		return {"ok": false, "error": "Could not load the bus layout at " + path}
+	AudioServer.set_bus_layout(layout)
+	return {"ok": true, "layout": path}

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

@@ -13,13 +13,13 @@ func _init(host: Node) -> void:
 
 
 func capture_screenshot(params: Dictionary) -> Dictionary:
-	return _capture(_host.get_tree().root, params)
+	return await _capture(_host.get_tree().root, params)
 
 
 func capture_viewport(params: Dictionary) -> Dictionary:
 	var viewport_path: String = str(params.get("viewportPath", ""))
 	if viewport_path.is_empty():
-		return capture_screenshot(params)
+		return await capture_screenshot(params)
 
 	var standing: Dictionary = Values.node_at(_host.get_tree().root, viewport_path)
 	if standing.has("message"):
@@ -28,7 +28,7 @@ func capture_viewport(params: Dictionary) -> Dictionary:
 	if not node is Viewport:
 		return {"type": "error", "message": "Node is not a Viewport: " + viewport_path}
 	var viewport: Viewport = node
-	return _capture(viewport, params)
+	return await _capture(viewport, params)
 
 
 ## The server names the file, so a game cannot point it at a path of its own choosing; a call
@@ -66,6 +66,13 @@ func _capture(viewport: Viewport, params: Dictionary) -> Dictionary:
 			),
 		}
 
+	# The game announces itself before its first frame, and until a frame has been drawn the texture
+	# holds nothing the game drew: blank on one machine, solid white on another, which a caller took
+	# for the game flashing white on boot. Measured on 4.7.2 with both renderers, only the first
+	# processed frame reads it so; the next one holds the scene.
+	while Engine.get_frames_drawn() == 0:
+		await _host.get_tree().process_frame
+
 	var viewport_texture: ViewportTexture = viewport.get_texture()
 	if viewport_texture == null:
 		return {"type": "error", "message": "No viewport texture available"}

package/build/godot/operations/godot_operations.gd

@@ -118,8 +118,6 @@ func _run(operation: String, params: Dictionary) -> Dictionary:
 			payload = ImportPipeline.new(_log).get_import_options(params)
 		"set_import_options":
 			payload = ImportPipeline.new(_log).set_import_options(params)
-		"reimport_resource":
-			payload = ImportPipeline.new(_log).reimport_resource(params)
 		"list_export_presets":
 			payload = ImportPipeline.new(_log).list_export_presets(params)
 		"validate_project":