gdharness 1.2.37 → 1.2.39

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

@@ -90,10 +90,41 @@ static func default_of(object: Object, name: String) -> Variant:
 	if script != null:
 		for declared: Dictionary in script.get_script_property_list():
 			if str(declared.get("name", "")) == name:
-				return script.get_property_default_value(name)
+				var given: Variant = script.get_property_default_value(name)
+				if given != null:
+					return given
+				return _initialised(script, name, Read.as_int(declared.get("type", TYPE_NIL)))
 	return ClassDB.class_get_property_default_value(object.get_class(), name)
 
 
+## What the declaration of [param name] in [param script] or a script it extends initialises it to,
+## when that is a value written out, such as [code]PackedStringArray()[/code], or null. The engine
+## reports a default only for an initializer it folded into a constant, and it folds no constructor
+## call, so it gives none for such a property; the saver then writes it whatever it holds, and the
+## line read as a change some script had made.
+static func _initialised(script: Script, name: String, type: int) -> Variant:
+	var declaration: RegEx = RegEx.create_from_string(
+		"(?m)^[ \\t]*(?:@[^\\n]*?\\s)?var\\s+" + name + "\\b[^=\\n]*?=\\s*(.+?)\\s*:?[ \\t]*$"
+	)
+	var holder: Script = script
+	while holder != null:
+		var found: RegExMatch = declaration.search(holder.source_code)
+		if found != null:
+			var value: Variant = str_to_var(found.get_string(1))
+			if value == null or type == TYPE_NIL or typeof(value) == type:
+				return value
+			return type_convert(value, type)
+		holder = holder.get_base_script()
+	return null
+
+
+## Whether [param object] holds its default for [param name], so a file that newly writes it says
+## nothing a script did: the saver writes a property whose default the engine cannot report whatever
+## it holds, the editor's save as well.
+static func at_default(object: Object, name: String) -> bool:
+	return PropertyValues.same(object.get(name), default_of(object, name))
+
+
 ## The ids, in the file, of the embedded resources [param property] reaches into on [param object],
 ## such as the material of [code]material:albedo_color[/code], as a set.
 static func reached(object: Object, property: String) -> Dictionary:
@@ -295,17 +326,23 @@ static func settle_saved(
 ) -> String:
 	for attempt: int in 2:
 		var after: String = FileAccess.get_file_as_string(path)
-		var embedded: Array[Array] = embedded_changes(before, after, reached_ids)
+		var by_id: Dictionary = embedded_in(values, {})
+		var embedded: Array[Array] = []
+		for found: Array in embedded_changes(before, after, reached_ids):
+			var holder: Resource = by_id.get(found[0])
+			if found[2] or holder == null or not at_default(holder, str(found[1])):
+				embedded.append(found)
 		var top: Array[Array] = []
 		if main != null:
-			top = main_changes(before, after, asked)
+			for found: Array in main_changes(before, after, asked):
+				if found[1] or not at_default(main, str(found[0])):
+					top.append(found)
 		if embedded.is_empty() and top.is_empty():
 			return ""
 		if attempt == 1:
 			if not embedded.is_empty():
 				return unasked("The embedded resource " + str(embedded[0][0]), str(embedded[0][1]))
 			return unasked(path, str(top[0][0]))
-		var by_id: Dictionary = embedded_in(values, {})
 		for found: Array in embedded:
 			var id: String = found[0]
 			var name: String = found[1]

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

@@ -26,6 +26,9 @@ extends RefCounted
 ## anything is saved, and a write is refused when that does not hold. See [HeadlessCheck].
 
 const HeadlessCheck = preload("headless_check.gd")
+
+## How many times what scripts changed is put back before a write is refused for it.
+const PUTTING_BACK_PASSES: int = 4
 const PropertyValues = preload("property_values.gd")
 
 ## Whether a scan asked for through [method scan_later] is still to start, which a caller waiting
@@ -235,6 +238,60 @@ static func uncompiled(script: Script, script_path: String) -> String:
 	)
 
 
+## The script a project declares [param type_name] in with class_name, as {"script", "path",
+## "base"} with base the engine class its objects are made as, or {"error"} when that script cannot
+## make one, or an empty dictionary when no script declares it. The editor's create dialogs offer
+## these classes beside the engine's, and ClassDB knows only the engine's.
+static func script_class(type_name: String, kind: String) -> Dictionary:
+	for entry: Dictionary in ProjectSettings.get_global_class_list():
+		if str(entry.get("class", "")) != type_name:
+			continue
+		var declaring: String = str(entry.get("path", ""))
+		if entry.get("is_abstract", false) == true:
+			return {
+				"error":
+				"%s, declared in %s, is abstract, so nothing can be made of it." % [type_name, declaring]
+			}
+		var script: Script = load(declaring) as Script
+		if script == null:
+			return {"error": "%s is declared in %s, which does not load." % [type_name, declaring]}
+		var failed: String = uncompiled(script, declaring)
+		if not failed.is_empty():
+			return {"error": failed}
+		var base: String = str(script.get_instance_base_type())
+		if not ClassDB.is_parent_class(base, kind):
+			return {
+				"error":
+				"%s, declared in %s, extends %s, which is not a %s." % [type_name, declaring, base, kind]
+			}
+		return {"script": script, "path": declaring, "base": base}
+	return {}
+
+
+## The engine class and the script a create makes for [param type_name] and [param given], the
+## res:// path of the script the call named or "", as {"type", "script"}, or {"error"}. A class_name
+## a project script declares is that script on its engine class; [param argument] names the
+## argument the type came in, for the refusal when the call also named another script.
+static func made_as(type_name: String, given: String, kind: String, argument: String) -> Dictionary:
+	if ClassDB.class_exists(type_name):
+		return {"type": type_name, "script": given}
+	var declared: Dictionary = script_class(type_name, kind)
+	if declared.has("error"):
+		return declared
+	if declared.is_empty():
+		return {"type": type_name, "script": given}
+	var declaring: String = str(declared["path"])
+	if not given.is_empty() and given != declaring:
+		return {
+			"error":
+			(
+				"%s %s is the class %s declares, and script names %s: pass one of them."
+				% [argument, type_name, declaring, given]
+			)
+		}
+	return {"type": str(declared["base"]), "script": declaring}
+
+
 ## Why no node can be called [param node_name], wherever it sits, or "".
 static func unfit_name(node_name: String) -> String:
 	if node_name.is_empty():
@@ -459,30 +516,34 @@ static func unsaved(scene_path: String) -> bool:
 ## On a node the tool did not ask to change, a difference is put back to what the file holds, or, for
 ## a property the file does not set, to what the node would load with without it. On a node it did
 ## ask to change, through a script that is not a tool, every property it did not name is put back to
-## what it held before. Packed again afterwards, since a setter can change one property through
-## another, and refused if anything is still different.
+## what it held before. Packed again afterwards and put back again until nothing differs, since
+## putting one property back can run a setter that changes another already put back (a script
+## setting speed in _init, whose setter tints modulate), and refused if something still does.
 func _settled(packed: PackedScene) -> Array:
-	var stray: Array[Array] = _strays(packed.get_state())
-	var moved: Array[Array] = _moved_by_scripts()
-	if stray.is_empty() and moved.is_empty():
-		return [packed, ""]
-	for found: Array in stray:
-		var node: Node = found[0]
-		var name: String = found[1]
-		node.set(name, found[3] if found[2] else _unset_value(node, name))
-	for found: Array in moved:
-		var node: Node = found[0]
-		var before: Dictionary = _before[node.get_instance_id()]
-		for name: String in found[1]:
-			node.set(name, before.get(name, HeadlessCheck.default_of(node, name)))
-	var again: PackedScene = PackedScene.new()
-	var packing: Error = again.pack(root)
-	if packing != OK:
-		return [null, "Failed to pack %s: %s" % [path, error_string(packing)]]
-	var left: Array[Array] = _strays(again.get_state())
-	left.append_array(_moved_by_scripts())
-	if left.is_empty():
-		return [again, ""]
+	var current: PackedScene = packed
+	var left: Array[Array] = []
+	for put_back: int in PUTTING_BACK_PASSES + 1:
+		var stray: Array[Array] = _strays(current.get_state())
+		var moved: Array[Array] = _moved_by_scripts()
+		if stray.is_empty() and moved.is_empty():
+			return [current, ""]
+		if put_back == PUTTING_BACK_PASSES:
+			left = stray
+			left.append_array(moved)
+			break
+		for found: Array in stray:
+			var node: Node = found[0]
+			var name: String = found[1]
+			node.set(name, found[3] if found[2] else _unset_value(node, name))
+		for found: Array in moved:
+			var node: Node = found[0]
+			var before: Dictionary = _before[node.get_instance_id()]
+			for name: String in found[1]:
+				node.set(name, before.get(name, HeadlessCheck.default_of(node, name)))
+		current = PackedScene.new()
+		var packing: Error = current.pack(root)
+		if packing != OK:
+			return [null, "Failed to pack %s: %s" % [path, error_string(packing)]]
 	var first: Array = left[0]
 	var stray_node: Node = first[0]
 	var named: String = str(first[1])
@@ -538,6 +599,8 @@ func _strays(state: SceneState) -> Array[Array]:
 			var held: bool = filed.has(name)
 			if held == stored.has(name) and (not held or PropertyValues.same(stored[name], filed[name])):
 				continue
+			if not held and HeadlessCheck.at_default(node, name):
+				continue
 			stray.append([node, name, held, filed.get(name)])
 	return stray
 

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

@@ -194,23 +194,36 @@ func _unkept_headless(resource: Resource, path: String, names: Array, previous:
 func create_resource(args: Dictionary) -> Dictionary:
 	var res_path: String = _ensure_res_path(str(args.get("resourcePath", "")))
 	var resource_type: String = str(args.get("resourceType", "Resource"))
+	var asked_type: String = resource_type
 	if res_path == "res://":
 		return {"ok": false, "error": "resourcePath is required"}
 	var taken: String = _taken(res_path, "resource_edit op=create")
 	if not taken.is_empty():
 		return {"ok": false, "error": taken}
 
-	if (
-		not ClassDB.class_exists(resource_type)
-		or not ClassDB.is_parent_class(resource_type, "Resource")
-		or not ClassDB.can_instantiate(resource_type)
-	):
+	var script_path: String = str(args.get("script", ""))
+	var made: Dictionary = SceneFile.made_as(
+		resource_type, "" if script_path == "" else _ensure_res_path(script_path), "Resource", "resourceType"
+	)
+	if made.has("error"):
+		return {"ok": false, "error": made["error"]}
+	resource_type = str(made["type"])
+	script_path = str(made["script"])
+	if not ClassDB.class_exists(resource_type):
+		return {
+			"ok": false,
+			"error":
+			(
+				"%s is neither an engine class nor a class_name a script in this project declares."
+				% resource_type
+			)
+		}
+	if not ClassDB.is_parent_class(resource_type, "Resource") or not ClassDB.can_instantiate(resource_type):
 		return {"ok": false, "error": "%s is not a resource class that can be created." % resource_type}
 	var resource: Resource = ClassDB.instantiate(resource_type)
 
 	# A script that did not load was skipped, and a plain resource was saved in place of the custom
 	# one asked for.
-	var script_path: String = str(args.get("script", ""))
 	if script_path != "":
 		var script_file: String = _ensure_res_path(script_path)
 		var script: Script = load(script_file) as Script
@@ -238,7 +251,7 @@ func create_resource(args: Dictionary) -> Dictionary:
 	var failed: String = _save_checked(resource, res_path, properties.keys(), null)
 	if not failed.is_empty():
 		return {"ok": false, "error": failed}
-	return {"ok": true, "resourcePath": res_path, "resourceType": resource.get_class()}
+	return {"ok": true, "resourcePath": res_path, "resourceType": asked_type}
 
 
 func modify_resource(args: Dictionary) -> Dictionary:

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

@@ -186,6 +186,17 @@ func create_scene(args: Dictionary) -> Dictionary:
 		return {"ok": false, "error": "Missing scenePath"}
 	if not scene_path.ends_with(".tscn"):
 		scene_path += ".tscn"
+	var asked_type: String = root_node_type
+	var made: Dictionary = SceneFile.made_as(
+		root_node_type,
+		"" if script_path.is_empty() else _to_scene_res_path(project_path, script_path),
+		"Node",
+		"rootNodeType"
+	)
+	if made.has("error"):
+		return {"ok": false, "error": made["error"]}
+	root_node_type = str(made["type"])
+	script_path = str(made["script"])
 	# A class that is not a node went into a Node variable, which is a runtime error the caller
 	# heard about only as "Invalid tool result".
 	if not ClassDB.class_exists(root_node_type) or not ClassDB.is_parent_class(root_node_type, "Node"):
@@ -237,6 +248,9 @@ func create_scene(args: Dictionary) -> Dictionary:
 				"%s extends %s, so it cannot be on a %s root." % [full_script_path, base, root_node_type]
 			}
 		root.set_script(script)
+		# Named again, since a headless engine runs the script's _init as it is attached, and a node's
+		# name is no property the write compares.
+		root.name = root_node_name
 
 	var folder: String = SceneFile.make_folder_for(scene_path)
 	if not folder.is_empty():
@@ -246,9 +260,7 @@ func create_scene(args: Dictionary) -> Dictionary:
 	if not written.is_empty():
 		return written
 
-	return {
-		"ok": true, "scenePath": scene_path, "rootNodeType": root_node_type, "rootNodeName": root_node_name
-	}
+	return {"ok": true, "scenePath": scene_path, "rootNodeType": asked_type, "rootNodeName": root_node_name}
 
 
 func list_scene_nodes(args: Dictionary) -> Dictionary:
@@ -276,6 +288,16 @@ func add_node(args: Dictionary) -> Dictionary:
 
 	if node_name.is_empty():
 		return {"ok": false, "error": "Missing nodeName"}
+	var asked_type: String = node_type
+	var class_script: Script = null
+	if not node_type.is_empty() and not ClassDB.class_exists(node_type):
+		var declared: Dictionary = SceneFile.script_class(node_type, "Node")
+		if declared.has("error"):
+			return {"ok": false, "error": declared["error"]}
+		var held: Variant = declared.get("script")
+		if held is Script:
+			class_script = held
+			node_type = str(declared["base"])
 	var making: Array = Placing.what_to_add(node_type, instance_path, scene_path)
 	var packed: PackedScene = making[0]
 	if not str(making[1]).is_empty():
@@ -304,6 +326,9 @@ func add_node(args: Dictionary) -> Dictionary:
 
 	# In the tree before its properties, so a property holding a node can find it by path.
 	var new_node: Node = Placing.made(packed, node_type)
+	if class_script != null:
+		scene.asked(new_node, ["script"])
+		new_node.set_script(class_script)
 	new_node.name = node_name
 	parent.add_child(new_node)
 	Placing.place(new_node, place)
@@ -321,12 +346,15 @@ func add_node(args: Dictionary) -> Dictionary:
 	var answer: Dictionary = {
 		"ok": true,
 		"nodeName": node_name,
-		"nodeType": new_node.get_class(),
+		"nodeType": asked_type if class_script != null else new_node.get_class(),
 		"nodePath": new_path,
 		"index": new_node.get_index(),
 	}
 	var written: Dictionary = scene.write(
-		func(saved: Node) -> String: return _kept(scene, saved, new_node, properties.keys())
+		func(saved: Node) -> String:
+			return _kept(
+				scene, saved, new_node, properties.keys() + (["script"] if class_script != null else [])
+			)
 	)
 	if not written.is_empty():
 		return written
@@ -342,7 +370,14 @@ func delete_node(args: Dictionary) -> Dictionary:
 	var node_path: String = str(args.get("nodePath", ""))
 
 	if node_path.is_empty() or node_path == ".":
-		return {"ok": false, "error": "Cannot delete root node"}
+		return {
+			"ok": false,
+			"error":
+			(
+				"The root cannot be deleted, since a scene has exactly one. Delete the nodes under it, or "
+				+ "make a scene with another root with scene_create."
+			)
+		}
 
 	var opened: Array = _open(scene_path, true)
 	var scene: SceneFile = opened[0]
@@ -480,6 +515,9 @@ func reparent_node(args: Dictionary) -> Dictionary:
 		return scene.refuse(unplaceable)
 
 	var old_path: String = scene.path_of(node)
+	# Unowned while it moves: a node taken out of the tree keeps its owner, and adding it under the new
+	# parent warned that the owner was not above it. Node.reparent warns the same way.
+	node.owner = null
 	node.get_parent().remove_child(node)
 	new_parent.add_child(node)
 	Placing.place(node, place)

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

@@ -352,11 +352,14 @@ func _process(_delta: float) -> void:
 	_queries.note_frame(Time.get_ticks_usec())
 	_calibrate_the_profiler()
 
-	if _server.is_connection_available():
+	# Every connection waiting rather than one a frame: the engine queues eight a game has not
+	# taken and refuses the rest, so calls sent together would be refused as if the game were not up.
+	while _server.is_connection_available():
 		var client: StreamPeerTCP = _server.take_connection()
-		if client:
-			_clients.append(client)
-			_send_welcome(client)
+		if client == null:
+			break
+		_clients.append(client)
+		_send_welcome(client)
 
 	var gone: Array[StreamPeerTCP] = []
 	for client: StreamPeerTCP in _clients:

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

@@ -343,6 +343,16 @@ func _capture(viewport: Viewport, params: Dictionary, with_windows: bool = false
 	var screenshot_path: String = requested_path
 	if screenshot_path.begins_with("user://") or screenshot_path.begins_with("res://"):
 		screenshot_path = ProjectSettings.globalize_path(screenshot_path)
+	# The server makes the folder for each capture and takes it away when it stops waiting for one,
+	# and a server replaced since the capture was asked for took it with it. Saving into a folder that
+	# is gone raises an engine error, which counts against a game that did nothing wrong.
+	if not DirAccess.dir_exists_absolute(screenshot_path.get_base_dir()):
+		return _refused(
+			(
+				"The folder to save the capture in, %s, is gone: the server that asked for it stopped waiting"
+				% screenshot_path.get_base_dir()
+			)
+		)
 	var save_error: Error = image.save_png(screenshot_path)
 	if save_error != OK:
 		return {"type": "error", "message": "Failed to save screenshot as PNG: " + str(save_error)}

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

@@ -164,8 +164,8 @@ func _argument_for(
 			"type": "error",
 			"message":
 			(
-				"%s.%s takes %s as argument %d and was given %s, which it would have to be cut to fit"
-				% [called, named, type_string(wants), index + 1, JSON.stringify(sent)]
+				"%s.%s takes %s as argument %d and was given %s, which %s cannot hold without changing it"
+				% [called, named, type_string(wants), index + 1, JSON.stringify(sent), Values.cut_by(wants)]
 			)
 		}
 	var rounded: String = Values.inexact(sent, wants)
@@ -259,8 +259,8 @@ func _value_for(
 			"type": "error",
 			"message":
 			(
-				"%s.%s holds %s and the value given is %s, which it would have to be cut to fit"
-				% [called, named, type_string(wanted), JSON.stringify(value)]
+				"%s.%s holds %s and the value given is %s, which %s cannot hold without changing it"
+				% [called, named, type_string(wanted), JSON.stringify(value), Values.cut_by(wanted)]
 			)
 		}
 	if declared != TYPE_NIL or (not cut and Values.acceptable(as_sent, wanted)):
@@ -563,6 +563,10 @@ static func _walk_from(object: Object, path: String) -> Dictionary:
 ## null, and the method list says how many a method takes: its parameters less those with defaults,
 ## up to all of them, or any number past that for one taking varargs.
 static func _argument_count_refused(holder: Object, method: String, given: int) -> String:
+	# A node's method list runs to hundreds of entries, and walking it costs a couple of milliseconds
+	# of the game's frame; a call giving exactly the arguments the method declares needs no walk.
+	if given == holder.get_method_argument_count(method):
+		return ""
 	for entry: Dictionary in holder.get_method_list():
 		if str(entry.get("name", "")) != method:
 			continue

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

@@ -156,6 +156,11 @@ static func cuts(given: Variant, type: int) -> bool:
 	return not (whole and (value == 0.0 or value == 1.0))
 
 
+## The slot [method cuts] speaks of, with its article, for a refusal to name: "an int" or "a bool".
+static func cut_by(type: int) -> String:
+	return "an int" if type == TYPE_INT else "a bool"
+
+
 ## Why [param given] may not be the whole number sent, or "": see [method Serialisation.inexact].
 static func inexact(given: Variant, type: int) -> String:
 	return Serialisation.inexact(given, type)

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

@@ -411,10 +411,10 @@ static func _cut_to_fit(given: Variant, type: int, node_path: String, property:
 		return ""
 	return (
 		(
-			"%s.%s holds %s and the value to wait for is %s, which it would have to be cut to fit:"
+			"%s.%s holds %s and the value to wait for is %s, which %s cannot hold without changing it:"
 			+ " waiting on it would answer about a state nobody asked for."
 		)
-		% [node_path, property, type_string(type), str(given)]
+		% [node_path, property, type_string(type), str(given), Values.cut_by(type)]
 	)
 
 

package/build/godot/operations/godot_operations.gd

@@ -46,10 +46,17 @@ const BEGUN: String = "[gdharness] begun"
 
 ## The operations that compile the project's scripts. The engine knows an autoload's name only once
 ## the autoload is in the tree, which is after `_init`, so a script naming one compiled here failed
-## with "Identifier not found" while the game and the editor ran it. A scene tool loads the scripts
-## of the scene it opens.
+## with "Identifier not found" while the game and the editor ran it. A scene tool, and a read of a
+## scene or a resource, loads the scripts of the file it opens.
 const AFTER_THE_AUTOLOADS: Array[String] = [
-	"check_scripts", "create_script", "modify_script", "run_editor_tool"
+	"check_scripts",
+	"create_script",
+	"modify_script",
+	"read_animation_states",
+	"read_animations",
+	"read_resource",
+	"read_scene_tree",
+	"run_editor_tool",
 ]
 
 var _log: Log