gdharness 0.13.2 → 0.13.4

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

@@ -4,12 +4,31 @@ extends Node
 ## Scenes and their nodes, edited in the open editor and read back from what it holds.
 
 const Read = preload("../reading.gd")
+const Serialisation = preload("../serialisation.gd")
 
 var _editor_plugin: EditorPlugin = null
+var _values: Serialisation = Serialisation.new()
+
+## How many scans the editor has finished, counted off its own signal, and what the count was when
+## a scan was last asked for. A queued scan has not started, so the flags the engine offers read
+## the same as one that is over; the count is what tells the two apart.
+var _scans_finished: int = 0
+var _scans_finished_at_request: int = 0
+var _scan_pending: bool = false
 
 
 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 watched != OK:
+			push_error("gdharness could not watch for finished scans: %d" % watched)
+
+
+func _scan_finished() -> void:
+	_scans_finished += 1
+	_scan_pending = false
 
 
 func _refresh_and_reload(scene_path: String) -> void:
@@ -110,66 +129,23 @@ func _parse_value(value: Variant, expected_type: int = TYPE_NIL) -> Variant:
 ## that names a type but lacks the keys to build it is left unhandled on purpose, so the caller
 ## can still read it against the type the property declares.
 func _parse_tagged_dictionary(value: Dictionary) -> Array:
-	var type_tag: String = ""
-	if value.has("type"):
-		type_tag = str(value["type"])
-	elif value.has("_type"):
-		type_tag = str(value["_type"])
-
-	match type_tag:
-		"Vector2":
-			return [true, Vector2(Read.as_float(value.get("x", 0)), Read.as_float(value.get("y", 0)))]
-		"Vector3":
-			return [
-				true,
-				Vector3(
-					Read.as_float(value.get("x", 0)),
-					Read.as_float(value.get("y", 0)),
-					Read.as_float(value.get("z", 0))
-				)
-			]
-		"Color":
-			return [
-				true,
-				Color(
-					Read.as_float(value.get("r", 1), 1.0),
-					Read.as_float(value.get("g", 1), 1.0),
-					Read.as_float(value.get("b", 1), 1.0),
-					Read.as_float(value.get("a", 1), 1.0)
-				)
-			]
-		"Vector2i":
-			return [true, Vector2i(Read.as_int(value.get("x", 0)), Read.as_int(value.get("y", 0)))]
-		"Vector3i":
-			return [
-				true,
-				Vector3i(
-					Read.as_int(value.get("x", 0)),
-					Read.as_int(value.get("y", 0)),
-					Read.as_int(value.get("z", 0))
-				)
-			]
-		"Rect2":
-			return [
-				true,
-				Rect2(
-					Read.as_float(value.get("x", 0)),
-					Read.as_float(value.get("y", 0)),
-					Read.as_float(value.get("width", 0)),
-					Read.as_float(value.get("height", 0))
-				)
-			]
-		"Transform2D":
-			return _parse_transform2d(value)
-		"Transform3D":
-			return _parse_transform3d(value)
-		"NodePath":
-			return [true, NodePath(str(value.get("path", "")))]
-		"Resource":
-			var resource_path: String = str(value.get("path", ""))
-			return [true, null if resource_path.is_empty() else load(resource_path)]
-		_:
-			return _parse_new_resource(type_tag, value)
+	var type_tag: String = str(value.get("_type", value.get("type", "")))
+	if type_tag == "Resource":
+		var resource_path: String = str(value.get("path", ""))
+		return [true, null if resource_path.is_empty() else load(resource_path)]
+
+	# The shared builder is the same one the answer was written by, so every shape it writes comes
+	# back as itself. `type` as the tag is read as `_type`: it is what this tool answered with
+	# before the serialisers were made one, and a caller who kept an answer can still send it.
+	var tagged: Dictionary = value
+	if not value.has("_type") and not type_tag.is_empty():
+		tagged = value.duplicate()
+		tagged["_type"] = type_tag
+	var rebuilt: Variant = _values.deserialize_value(tagged)
+	if not rebuilt is Dictionary:
+		return [true, rebuilt]
+
+	return _parse_new_resource(type_tag, value)
 
 
 ## A tag naming a Resource class builds a fresh one, its other keys set as properties, so a
@@ -193,47 +169,6 @@ func _parse_new_resource(type_tag: String, value: Dictionary) -> Array:
 	return [true, built]
 
 
-func _parse_transform2d(value: Dictionary) -> Array:
-	if not (value.has("x") and value.has("y") and value.has("origin")):
-		return [false, null]
-
-	var basis_x: Dictionary = value["x"]
-	var basis_y: Dictionary = value["y"]
-	var origin: Dictionary = value["origin"]
-	return [
-		true,
-		Transform2D(
-			Vector2(Read.as_float(basis_x.get("x", 1), 1.0), Read.as_float(basis_x.get("y", 0))),
-			Vector2(Read.as_float(basis_y.get("x", 0)), Read.as_float(basis_y.get("y", 1), 1.0)),
-			Vector2(Read.as_float(origin.get("x", 0)), Read.as_float(origin.get("y", 0)))
-		)
-	]
-
-
-func _parse_transform3d(value: Dictionary) -> Array:
-	if not (value.has("basis") and value.has("origin")):
-		return [false, null]
-
-	var b: Dictionary = value["basis"]
-	var o: Dictionary = value["origin"]
-	var x: Dictionary = b.get("x", {})
-	var y: Dictionary = b.get("y", {})
-	var z: Dictionary = b.get("z", {})
-	var basis: Basis = Basis(
-		Vector3(
-			Read.as_float(x.get("x", 1), 1.0), Read.as_float(x.get("y", 0)), Read.as_float(x.get("z", 0))
-		),
-		Vector3(
-			Read.as_float(y.get("x", 0)), Read.as_float(y.get("y", 1), 1.0), Read.as_float(y.get("z", 0))
-		),
-		Vector3(Read.as_float(z.get("x", 0)), Read.as_float(z.get("y", 0)), Read.as_float(z.get("z", 1), 1.0))
-	)
-	var origin: Vector3 = Vector3(
-		Read.as_float(o.get("x", 0)), Read.as_float(o.get("y", 0)), Read.as_float(o.get("z", 0))
-	)
-	return [true, Transform3D(basis, origin)]
-
-
 ## A dictionary with no tag, read against the type the property declares. Falls back to the
 ## dictionary itself, since a property may genuinely want one.
 func _parse_shaped_dictionary(value: Dictionary, expected_type: int) -> Variant:
@@ -299,54 +234,6 @@ func _get_property_type(node: Node, prop_name: String) -> int:
 	return TYPE_NIL
 
 
-func _serialize_value(value: Variant) -> Variant:
-	match typeof(value):
-		TYPE_VECTOR2:
-			return {"type": "Vector2", "x": value.x, "y": value.y}
-		TYPE_VECTOR3:
-			return {"type": "Vector3", "x": value.x, "y": value.y, "z": value.z}
-		TYPE_COLOR:
-			return {"type": "Color", "r": value.r, "g": value.g, "b": value.b, "a": value.a}
-		TYPE_VECTOR2I:
-			return {"type": "Vector2i", "x": value.x, "y": value.y}
-		TYPE_VECTOR3I:
-			return {"type": "Vector3i", "x": value.x, "y": value.y, "z": value.z}
-		TYPE_RECT2:
-			return {
-				"type": "Rect2",
-				"x": value.position.x,
-				"y": value.position.y,
-				"width": value.size.x,
-				"height": value.size.y
-			}
-		TYPE_NODE_PATH:
-			return {"type": "NodePath", "path": str(value)}
-		TYPE_TRANSFORM2D:
-			return {
-				"type": "Transform2D",
-				"x": {"x": value.x.x, "y": value.x.y},
-				"y": {"x": value.y.x, "y": value.y.y},
-				"origin": {"x": value.origin.x, "y": value.origin.y}
-			}
-		TYPE_TRANSFORM3D:
-			return {
-				"type": "Transform3D",
-				"basis":
-				{
-					"x": {"x": value.basis.x.x, "y": value.basis.x.y, "z": value.basis.x.z},
-					"y": {"x": value.basis.y.x, "y": value.basis.y.y, "z": value.basis.y.z},
-					"z": {"x": value.basis.z.x, "y": value.basis.z.y, "z": value.basis.z.z}
-				},
-				"origin": {"x": value.origin.x, "y": value.origin.y, "z": value.origin.z}
-			}
-		TYPE_OBJECT:
-			if value and value is Resource and value.resource_path:
-				return {"type": "Resource", "path": value.resource_path}
-			return null
-		_:
-			return value
-
-
 ## Set each property, answering with what went wrong or "" when nothing did.
 ##
 ## A property the node does not have, and a resource path nothing is at, are both refused: Object
@@ -431,7 +318,7 @@ func _build_node_tree(
 			var pn: String = str(p.get("name", ""))
 			if pn.is_empty():
 				continue
-			props[pn] = _serialize_value(node.get(pn))
+			props[pn] = _values.serialize_value(node.get(pn))
 		data["properties"] = props
 
 	if depth >= 0 and current_depth >= depth:
@@ -732,7 +619,7 @@ func get_node_properties(args: Dictionary) -> Dictionary:
 			var default_val: Variant = defaults.get(prop_name)
 			if current_val == default_val:
 				continue
-		props[prop_name] = _serialize_value(current_val)
+		props[prop_name] = _values.serialize_value(current_val)
 
 	if defaults:
 		defaults.queue_free()
@@ -928,8 +815,28 @@ func rescan_filesystem(args: Dictionary) -> Dictionary:
 
 	var filesystem: EditorFileSystem = EditorInterface.get_resource_filesystem()
 	if not Read.as_bool(args.get("statusOnly", false)):
+		_scans_finished_at_request = _scans_finished
+		_scan_pending = true
 		filesystem.scan()
 
 	# 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.
-	return {"ok": true, "scanning": filesystem.is_scanning(), "importing": filesystem.is_importing()}
+	#
+	# `pending` is the third state, and it is the one that was missing. A scan is queued rather
+	# than run, so for the first frames after asking, both flags are false and the editor has not
+	# started: a caller polling them reads "finished" off a scan that has not begun. Measured, a
+	# headless editor of 400 scripts takes 1619ms and answered honestly, while a downstream editor
+	# of 376 classes answered finished 296ms in and then wrote its own stale class list over the
+	# cache that had just been corrected. Whoever reads this is waiting for the scan to have
+	# landed, so "not yet" and "over" must not be spelled the same.
+	var scanning: bool = filesystem.is_scanning()
+	var importing: bool = filesystem.is_importing()
+	if scanning or importing or _scans_finished != _scans_finished_at_request:
+		_scan_pending = false
+	return {
+		"ok": true,
+		"scanning": scanning,
+		"importing": importing,
+		"pending": _scan_pending,
+		"scansFinished": _scans_finished,
+	}

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

@@ -0,0 +1,58 @@
+@tool
+extends Node
+
+## Project settings read from the open editor, for a caller that asked for the editor's answer.
+##
+## 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
+## same thing: an editor holds what it has been told, including changes nobody has saved yet. Which
+## of the two a caller wants is theirs to say, so the server only comes here when asked, and the
+## difference is the reason the argument exists rather than an inconvenience to paper over.
+##
+## Every value goes through the same serialiser the headless answer uses, because the two are one
+## question asked of two places: a value spelled differently here would read as the editor and the
+## file disagreeing about something they agree about.
+
+const Read = preload("../reading.gd")
+const Serialisation = preload("../serialisation.gd")
+
+var _values: Serialisation = Serialisation.new()
+
+
+func get_project_setting(args: Dictionary) -> Dictionary:
+	var prefix: String = str(args.get("prefix", ""))
+	if not prefix.is_empty():
+		return _settings_under(prefix)
+
+	var setting: String = str(args.get("setting", ""))
+	if setting.is_empty():
+		return {"ok": false, "error": "setting is required, or prefix to read every setting under one"}
+
+	var exists: bool = ProjectSettings.has_setting(setting)
+	var result: Dictionary = {"ok": true, "setting_path": setting, "exists": exists, "value": null}
+	if exists:
+		result["value"] = _values.serialize_value(ProjectSettings.get_setting(setting))
+	else:
+		result["message"] = "Setting does not exist"
+	return result
+
+
+## Every setting under [prefix] with the type the engine registers for each, which is the half a
+## name hides: a family of levels can hold a setting that is a bool, and writing a level over it
+## looks like it worked.
+func _settings_under(prefix: String) -> Dictionary:
+	var found: Array[Dictionary] = []
+	for property: Dictionary in ProjectSettings.get_property_list():
+		var setting: String = str(property.get("name", ""))
+		if not setting.begins_with(prefix):
+			continue
+		var kind: int = Read.as_int(property.get("type", TYPE_NIL), TYPE_NIL)
+		var described: Dictionary = {
+			"setting": setting,
+			"type": type_string(kind),
+			"value": _values.serialize_value(ProjectSettings.get_setting(setting)),
+		}
+		found.append(described)
+
+	found.sort_custom(func(a: Dictionary, b: Dictionary) -> bool: return a["setting"] < b["setting"])
+	return {"ok": true, "prefix": prefix, "count": found.size(), "settings": found}

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

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

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

@@ -1,15 +1,22 @@
 extends RefCounted
 
-# A value out of a request that arrived as JSON, as the type the caller wants.
+# A value out of a dictionary that came from JSON, as the type the caller wants.
+#
+# This file is the one beside the operations, and `bun run sync:gd` copies it into each addon,
+# because an addon is installed as a directory and cannot preload out of one. The runtime addon's
+# copy ships inside exported games and the editor addon's does not, which is the other reason
+# neither of them reaches into the other.
 #
 # `int(value)`, `float(value)` and `bool(value)` take a Variant, and a project holding
-# `unsafe_call_argument` at error level will not compile a script that hands one over. The
-# conversion is the same; what changes is that the type is established first, on a typed local, and
-# the conversion happens from that.
+# `unsafe_call_argument` at error level will not compile a script that hands one over. These
+# scripts are compiled under the target project's warning levels rather than under this package's,
+# because `--path` makes that project the loaded one and the file's living in the npm cache
+# changes nothing: one project turning that warning on lost every headless operation at once.
 #
-# A copy rather than a preload of the one beside the operations, because an addon is installed as a
-# directory and has to hold everything it uses. This one ships inside exported games, so it must not
-# reach into the editor addon, which does not.
+# The conversion itself is the same. What changes is that the type is established first, on a
+# typed local, and the conversion happens from that. Here rather than at each of the thirty-one
+# places that read a parameter, because thirty-one is how many chances there are to write the old
+# form again, and the error does not appear until somebody sets the warning.
 #
 # `fallback` answers a value that is there and is null, which is a caller sending JSON null where a
 # number was expected. Absent keys never reach here: the callers pass their own default to

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

@@ -734,9 +734,24 @@ func call_method(params: Dictionary) -> Dictionary:
 	if not holder.has_method(named):
 		return {"type": "error", "message": "%s has no method %s" % [reached["called"], named]}
 
+	# Checked before the call rather than left to it. `callv` raises inside the game when an
+	# argument cannot be converted, and an error raised in a game somebody is playing holds it at a
+	# debugger break: every later call then reports a game that is not responding, which points
+	# nowhere near the argument. A wrong argument costs a refusal, never the session's game.
 	var deserialized_args: Array = []
 	for index: int in args.size():
-		deserialized_args.append(_values.fitted(args[index], _values.parameter_type(holder, named, index)))
+		var wants: int = _values.parameter_type(holder, named, index)
+		var given: Variant = _values.fitted(args[index], wants)
+		if not Values.acceptable(given, wants):
+			return {
+				"type": "error",
+				"message":
+				(
+					"%s.%s takes %s as argument %d and was given %s, which cannot be converted."
+					% [reached["called"], named, type_string(wants), index + 1, type_string(typeof(given))]
+				)
+			}
+		deserialized_args.append(given)
 
 	var result: Variant = holder.callv(named, deserialized_args)