gdharness 1.1.21 → 1.1.23

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

@@ -49,9 +49,10 @@ func set_editor_plugin(plugin: EditorPlugin) -> void:
 ## returned OK and compiled nothing is exactly the failure worth catching, and the members it now
 ## has are the only thing that can tell those apart.
 func reload_script(args: Dictionary) -> Dictionary:
-	var path: String = str(args.get("scriptPath", ""))
-	if path.is_empty():
+	var asked: String = str(args.get("scriptPath", ""))
+	if asked.is_empty():
 		return {"ok": false, "error": "scriptPath is required"}
+	var path: String = _spelled_as_on_disk(asked)
 	if not ResourceLoader.exists(path):
 		return {"ok": false, "error": "No script at " + path}
 
@@ -80,21 +81,58 @@ func reload_script(args: Dictionary) -> Dictionary:
 
 	# A reload that fails is still answered as a call that ran, because the readings are what a
 	# caller needs then: a failure travels back as its message alone, and a project met one and
-	# could not tell whether the copy had been damaged by it or before it. The old text goes back
-	# into the object, so what it holds and the source it says it was built from still agree.
+	# could not tell whether the copy had been damaged by it or before it.
+	#
+	# And the old text is compiled again. A failed reload leaves the object unusable while its member
+	# lists read as before, measured on 4.7.2: it can make no instance, and an instance it already made
+	# has lost its methods, and the old text put back uncompiled leaves it that way. Compiling the text
+	# it was built from puts it back, and whether that worked is said, since the text may no longer
+	# compile against what it names.
 	var failed: Error = script.reload(true)
-	if failed != OK:
-		script.source_code = previous
-	return {
+	var answer: Dictionary = {
 		"ok": true,
 		"script": path,
 		"failed": failed,
 		"failedAs": error_string(failed) if failed != OK else "",
 		"heldBefore": held,
-		"methods": _method_names(script),
 		"heldConstantsBefore": held_constants,
-		"constants": _constant_names(script),
 	}
+	if failed != OK:
+		script.source_code = previous
+		var restored: Error = script.reload(true)
+		answer["restored"] = restored == OK
+		if restored != OK:
+			answer["restoredAs"] = error_string(restored)
+	answer["methods"] = _method_names(script)
+	answer["constants"] = _constant_names(script)
+	return answer
+
+
+## [param path] as the files on disk spell it, a step at a time, or as given where a step is not
+## there. On a filesystem that ignores case, `res://Core/Rules.gd` opens the file at
+## `res://core/rules.gd`, but the editor holds its copy under the spelling on disk, and a load by
+## another spelling misses that copy and compiles a new one: reloading that answers with a fresh
+## compile's members and leaves the copy the editor holds as it was.
+static func _spelled_as_on_disk(path: String) -> String:
+	var local: String = ProjectSettings.localize_path(path)
+	if not local.begins_with("res://"):
+		return local
+	var spelled: String = "res://"
+	for step: String in local.trim_prefix("res://").split("/", false):
+		var listing: DirAccess = DirAccess.open(spelled)
+		if listing == null:
+			return local
+		var found: String = ""
+		for entry: String in listing.get_directories() + listing.get_files():
+			if entry == step:
+				found = entry
+				break
+			if found.is_empty() and entry.nocasecmp_to(step) == 0:
+				found = entry
+		if found.is_empty():
+			return local
+		spelled = spelled.path_join(found)
+	return spelled
 
 
 func _method_names(script: GDScript) -> Array[String]:

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

@@ -0,0 +1,206 @@
+@tool
+extends Node
+
+## The editor's view of the files on disk: scans, the reimports asked for, and where each stands.
+
+const Read = preload("../reading.gd")
+
+var _editor_plugin: EditorPlugin = null
+
+## 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.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 completed scans: %d" % watched)
+
+
+func _scan_completed(_sources_exist: bool) -> void:
+	_scans_completed += 1
+	_scan_finished_at_msec = Time.get_ticks_msec()
+
+
+## Rescan the project filesystem, and report whether a scan is still running.
+##
+## The editor rescans when its window regains focus, so a script written by anything other
+## than the editor stays invisible until someone clicks on Godot. Until then its
+## `class_name` is missing from the global class list and the language server reports every
+## use of it as an unknown type, which is godotengine/godot#42786.
+##
+## Returns as soon as the scan is queued rather than awaiting it, because the tool executor
+## takes a Dictionary and not a coroutine. Pass `statusOnly` to poll without starting
+## another scan.
+func rescan_filesystem(args: Dictionary) -> Dictionary:
+	if not _editor_plugin:
+		return {"ok": false, "error": "Editor plugin unavailable"}
+
+	var filesystem: EditorFileSystem = EditorInterface.get_resource_filesystem()
+	# Not over a scan or an import the editor is already running: a scan asked for then starts a
+	# second reimport over the first, and the editor logs "Task 'reimport' already exists" and two
+	# 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
+	var uids: Dictionary = {"reread": [], "duplicated": []}
+	if not Read.as_bool(args.get("statusOnly", false)) and not busy:
+		uids = _reread_changed_uids(filesystem)
+		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
+		# more after that scan stops reporting itself, and that scan then signals as it is joined.
+		# Taken as started, the answer came from a scan begun before the files were written:
+		# 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_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. 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(),
+		"scansCompletedBefore": completed_before,
+		"scansCompleted": _scans_completed,
+		"uidsReread": uids["reread"],
+		"uidsDuplicatedOnDisk": uids["duplicated"],
+	}
+
+
+## Has the editor read again every file whose `.uid` names a UID the editor does not hold for it.
+##
+## The scan re-reads a file when the file changes and not when only the `.uid` beside it does, so a
+## script copied with its `.uid` and then given a fresh one keeps the copied UID in the editor, and
+## every headless engine reading the editor's cache warns of a duplicate. Measured on 4.7.2: a scan
+## after the `.uid` was rewritten left both scripts on one UID in the cache. What the editor holds
+## is read off its UID table, which maps each UID to one path, so a `.uid` whose UID is missing from
+## the table or mapped to another file is one the editor has not taken in.
+##
+## Two files on disk naming one UID are left alone and named: reading them again cannot settle
+## which of them owns it, and doing it on every scan would only move the UID between them.
+func _reread_changed_uids(filesystem: EditorFileSystem) -> Dictionary:
+	var sidecars: Array[String] = []
+	_uid_files("res://", sidecars)
+	var claimed: Dictionary = {}
+	for sidecar: String in sidecars:
+		var id: int = ResourceUID.text_to_id(FileAccess.get_file_as_string(sidecar).strip_edges())
+		var path: String = sidecar.trim_suffix(".uid")
+		if id == ResourceUID.INVALID_ID or not FileAccess.file_exists(path):
+			continue
+		var paths: Array = claimed.get_or_add(id, [])
+		paths.append(path)
+	var reread: Array[String] = []
+	var duplicated: Array[Array] = []
+	for id: int in claimed:
+		var paths: Array = claimed[id]
+		if paths.size() > 1:
+			paths.sort()
+			duplicated.append(paths)
+			continue
+		var path: String = str(paths[0])
+		if ResourceUID.has_id(id) and ResourceUID.get_id_path(id) == path:
+			continue
+		filesystem.update_file(path)
+		reread.append(path)
+	reread.sort()
+	duplicated.sort()
+	return {"reread": reread, "duplicated": duplicated}
+
+
+## Every `.uid` under [param directory], skipping what the editor skips: hidden directories, any
+## holding a `.gdignore`, and any below the project's own that holds a `project.godot` of its own,
+## which the editor passes over as another project. A nested project's UIDs are never in the editor's
+## table, so without that last one its files would be read again on every rescan, and one holding a
+## copy of an outer file's `.uid` named as a duplicate on disk.
+func _uid_files(directory: String, found: Array[String]) -> void:
+	var listing: DirAccess = DirAccess.open(directory)
+	if listing == null or FileAccess.file_exists(directory.path_join(".gdignore")):
+		return
+	if directory != "res://" and FileAccess.file_exists(directory.path_join("project.godot")):
+		return
+	for child: String in listing.get_directories():
+		if not child.begins_with("."):
+			_uid_files(directory.path_join(child), found)
+	for file: String in listing.get_files():
+		if file.ends_with(".uid"):
+			found.append(directory.path_join(file))
+
+
+## Whether the editor is scanning, and how long ago its last scan finished, without asking for one.
+##
+## For a caller about to start a game: the editor rewrites the class cache a frame after a scan
+## stops reporting, so a game booted during the scan or in that frame reads a file being rewritten.
+## Apart from `rescan_filesystem` because asking must not start or count anything.
+func scan_status(_args: Dictionary) -> Dictionary:
+	if not _editor_plugin:
+		return {"ok": false, "error": "Editor plugin unavailable"}
+	var filesystem: EditorFileSystem = EditorInterface.get_resource_filesystem()
+	return {
+		"ok": true,
+		"scanning": filesystem.is_scanning(),
+		"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/filesystem_tools.gd.uid

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

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

@@ -19,32 +19,75 @@ const LOOPBACK: String = "127.0.0.1"
 
 var _editor_plugin: EditorPlugin = null
 
+## Which play this is, counted up for every one the editor starts, whoever starts it. What a server
+## writes about a play is kept on disk after it, and the editor saying it is playing does not say
+## which play: a server picking a play back up read the console of an earlier one as this one's.
+var _play: int = 0
+var _was_playing: bool = false
+## A play asked for here that the editor has not begun yet, as an editor still scanning answers.
+## Counted when it was asked for, so its beginning later is not counted again as a play of its own.
+var _awaited: bool = false
+
 
 func set_editor_plugin(plugin: EditorPlugin) -> void:
 	_editor_plugin = plugin
 
 
+func _process(_delta: float) -> void:
+	var playing: bool = EditorInterface.is_playing_scene()
+	if playing and not _was_playing:
+		if _awaited:
+			_awaited = false
+		else:
+			_play += 1
+	_was_playing = playing
+
+
 func play_scene(args: Dictionary) -> Dictionary:
 	var scene_path: String = str(args.get("scenePath", ""))
 
+	var full_path: String = ""
+	if scene_path.is_empty():
+		# The editor puts up a dialog for a main scene that is not there and plays nothing, and the
+		# play was answered as started.
+		var main: String = str(ProjectSettings.get_setting("application/run/main_scene", ""))
+		if main.is_empty():
+			return {"ok": false, "error": "The project has no main scene to play."}
+		if not ResourceLoader.exists(main, "PackedScene"):
+			return {
+				"ok": false,
+				"error":
+				(
+					"The main scene, %s, is not there, so the editor would ask for another rather than play."
+					% main
+				)
+			}
+	else:
+		full_path = scene_path if scene_path.begins_with("res://") else "res://" + scene_path
+		if not ResourceLoader.exists(full_path, "PackedScene"):
+			return {"ok": false, "error": "No scene at " + full_path}
+
 	if EditorInterface.is_playing_scene():
 		EditorInterface.stop_playing_scene()
 
 	var debugger: int = _a_port_for_the_debugger()
 
-	if scene_path.is_empty():
+	if full_path.is_empty():
 		EditorInterface.play_main_scene()
 	else:
-		var full_path: String = scene_path if scene_path.begins_with("res://") else "res://" + scene_path
-		if not ResourceLoader.exists(full_path, "PackedScene"):
-			return {"ok": false, "error": "No scene at " + full_path}
 		EditorInterface.play_custom_scene(full_path)
 
+	_play += 1
+	_was_playing = EditorInterface.is_playing_scene()
+	_awaited = not _was_playing
+
 	return {
 		"ok": true,
-		"playing": EditorInterface.is_playing_scene(),
+		"playing": _was_playing,
 		"scenePath": EditorInterface.get_playing_scene(),
-		"debugPort": debugger
+		"debugPort": debugger,
+		"play": _play,
+		"editorPid": OS.get_process_id(),
 	}
 
 
@@ -116,10 +159,9 @@ func restart_editor(_args: Dictionary) -> Dictionary:
 			)
 		}
 
-	if EditorInterface.is_playing_scene():
-		EditorInterface.stop_playing_scene()
-
-	EditorInterface.save_all_scenes()
+	var unsaved: Dictionary = _save_everything()
+	if not unsaved.is_empty():
+		return unsaved
 
 	# Deferred so this answer is on its way out before the editor goes.
 	EditorInterface.restart_editor.call_deferred(true)
@@ -127,6 +169,38 @@ func restart_editor(_args: Dictionary) -> Dictionary:
 	return {"ok": true, "restarting": true, "saved": true}
 
 
+## Saves every open scene, answering a refusal naming what is still unsaved, or {}.
+##
+## Read back rather than assumed: save_all_scenes answers nothing and passes over a scene that has
+## never been saved, which has no path to go to, so an untitled scene was lost with the editor while
+## the answer said everything was saved.
+static func _save_everything() -> Dictionary:
+	if EditorInterface.is_playing_scene():
+		EditorInterface.stop_playing_scene()
+	EditorInterface.save_all_scenes()
+	var left: PackedStringArray = EditorInterface.get_unsaved_scenes()
+	if left.is_empty():
+		return {}
+	var named: Array[String] = []
+	for scene: String in left:
+		named.append(scene if not scene.is_empty() else "a scene that has never been saved")
+	return {
+		"ok": false,
+		"error":
+		(
+			(
+				"%s still %s unsaved changes after saving, and ending the editor would lose them. Save "
+				+ "or close %s in the editor first."
+			)
+			% [
+				", ".join(PackedStringArray(named)),
+				"has" if named.size() == 1 else "have",
+				"it" if named.size() == 1 else "them"
+			]
+		)
+	}
+
+
 ## Ends this editor, having saved, so that whoever opened it can open it again.
 ##
 ## The editor's half of restarting one a server started. Godot's own restart cannot carry the ports
@@ -136,10 +210,9 @@ func restart_editor(_args: Dictionary) -> Dictionary:
 ## Saved first, exactly as the restart above saves. The editor is going either way, and unsaved
 ## scenes are not this tool's to lose.
 func quit_editor(_args: Dictionary) -> Dictionary:
-	if EditorInterface.is_playing_scene():
-		EditorInterface.stop_playing_scene()
-
-	EditorInterface.save_all_scenes()
+	var unsaved: Dictionary = _save_everything()
+	if not unsaved.is_empty():
+		return unsaved
 
 	# Deferred so this answer is on its way out before the editor goes.
 	_leave.call_deferred()
@@ -168,5 +241,7 @@ func playing_status(_args: Dictionary) -> Dictionary:
 		"ok": true,
 		"playing": playing,
 		"scenePath": EditorInterface.get_playing_scene() if playing else "",
-		"debugPort": debugger
+		"debugPort": debugger,
+		"play": _play,
+		"editorPid": OS.get_process_id(),
 	}