gdharness 1.1.30 → 1.1.32

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

@@ -25,6 +25,10 @@ const MAX_RECONNECT_DELAY: float = 30.0
 ## What a server closes with when the editor that said hello belongs to another project. Kept in
 ## step with `OTHER_PROJECT_CLOSE_CODE` in src/godot-bridge.ts.
 const ELSEWHERE_CLOSE_CODE: int = 4001
+## What a server closes with when this process is one job that quits, such as a gate's `--import`,
+## rather than an editor: dialling in again changes nothing for the rest of the run. Kept in step
+## with `ONE_SHOT_CLOSE_CODE` in src/godot-bridge.ts.
+const ONE_SHOT_CLOSE_CODE: int = 4002
 
 ## Where Godot keeps the three ports an editor serves. None of them is per editor: the settings
 ## file is one for every editor of this engine version on the machine, so two open at once want the
@@ -447,6 +451,8 @@ func _read_marker(path: String) -> String:
 func _handle_disconnect() -> void:
 	_is_connected = false
 	_said_elsewhere()
+	if socket.get_close_code() == ONE_SHOT_CLOSE_CODE:
+		_should_reconnect = false
 	disconnected.emit()
 
 	if _should_reconnect:

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

@@ -63,6 +63,15 @@ func rescan_filesystem(args: Dictionary) -> Dictionary:
 	var uids: Dictionary = {"reread": [], "duplicated": []}
 	if not Read.as_bool(args.get("statusOnly", false)) and not busy:
 		uids = _reread_changed_uids(filesystem)
+		# Files the caller has just written, moved or deleted, read again one by one. The scan finds a
+		# script that appeared and leaves the global class of one that has gone in the editor's list,
+		# which it then writes back into the class cache at a path that is not there; reading the gone
+		# path again is what drops it.
+		var named: Variant = args.get("updateFiles", [])
+		if named is Array:
+			var paths: Array = named
+			for path: Variant in paths:
+				filesystem.update_file(str(path))
 		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

package/build/godot/operations/godot_operations.gd

@@ -26,6 +26,7 @@ const Log = preload("logger.gd")
 const Plugins = preload("plugins.gd")
 const ProjectConfig = preload("project_config.gd")
 const ProjectDiagnostics = preload("project_diagnostics.gd")
+const RenameChecks = preload("rename_checks.gd")
 const ResourceFiles = preload("resource_files.gd")
 
 var _log: Log
@@ -171,6 +172,10 @@ func _run(operation: String, params: Dictionary) -> Dictionary:
 			payload = GdscriptAuthoring.new(_log).modify_gdscript(params)
 		"get_script_info":
 			payload = GdscriptAnalysis.new(_log).get_gdscript_info(params)
+		"names_taken":
+			payload = RenameChecks.new(_log).names_taken(params)
+		"check_scripts":
+			payload = RenameChecks.new(_log).check_scripts(params)
 
 		# Plugins and input
 		"list_plugins":

package/build/godot/operations/rename_checks.gd

@@ -0,0 +1,80 @@
+extends RefCounted
+
+const GdscriptAuthoring = preload("gdscript_authoring.gd")
+const Log = preload("logger.gd")
+
+var _log: Log
+
+
+func _init(p_log: Log) -> void:
+	_log = p_log
+
+
+# What each of the names asked about already is to the engine, and which class in the native
+# chain from the base asked about declares it. A file cannot answer either: the native classes, the
+# built-in types and the singletons are compiled into the engine, and a rename onto one of them is
+# a script that no longer compiles, or one that quietly overrides an engine method.
+func names_taken(params: Dictionary) -> Dictionary:
+	var names: Array = params.get("names", [])
+	var base: String = str(params.get("base", ""))
+	var built_in_types: Array[String] = []
+	for type: int in range(TYPE_MAX):
+		built_in_types.append(type_string(type))
+	var singletons: PackedStringArray = Engine.get_singleton_list()
+	var taken: Dictionary = {}
+	for value: Variant in names:
+		var name: String = str(value)
+		var as_what: Array[String] = []
+		if ClassDB.class_exists(name):
+			as_what.append("a native class")
+		if name in built_in_types:
+			as_what.append("a built-in type")
+		if singletons.has(name):
+			as_what.append("an engine singleton")
+		var entry: Dictionary = {"as": as_what, "declaredBy": null}
+		var declared_by: String = _declared_in_chain(base, name)
+		if not declared_by.is_empty():
+			entry["declaredBy"] = declared_by
+		taken[name] = entry
+	return {"taken": taken}
+
+
+# The native class from [param base] upwards that declares [param name] as a method, property,
+# signal, constant or enum, or empty when none does. Methods are read off the method list rather
+# than asked with class_has_method, which answers false for a virtual such as Node._ready: those
+# are the names a script most often overrides and the engine calls by name.
+func _declared_in_chain(base: String, name: String) -> String:
+	var current: String = base
+	while not current.is_empty() and ClassDB.class_exists(current):
+		if (
+			_named(ClassDB.class_get_method_list(current, true), name)
+			or ClassDB.class_has_enum(current, name, true)
+			or _named(ClassDB.class_get_property_list(current, true), name)
+			or _named(ClassDB.class_get_signal_list(current, true), name)
+			or ClassDB.class_get_integer_constant_list(current, true).has(name)
+		):
+			return current
+		current = str(ClassDB.get_parent_class(current))
+	return ""
+
+
+static func _named(entries: Array[Dictionary], name: String) -> bool:
+	for entry: Dictionary in entries:
+		if str(entry.get("name", "")) == name:
+			return true
+	return false
+
+
+# Whether each script compiles in a fresh engine, which reads the class cache as it starts and so
+# resolves every class the cache lists. The engine's reasons go to stderr and come back with the
+# answer.
+func check_scripts(params: Dictionary) -> Dictionary:
+	var paths: Array = params.get("paths", [])
+	var failed: Array[String] = []
+	for value: Variant in paths:
+		var path: String = str(value)
+		var script: Script = ResourceLoader.load(path, "Script", ResourceLoader.CACHE_MODE_IGNORE)
+		if not GdscriptAuthoring._parses(script):
+			_log.error("Does not compile: " + path)
+			failed.append(path)
+	return {"checked": paths.size(), "failed": failed}