gdharness 0.9.1 → 0.9.3

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

@@ -125,6 +125,33 @@ func restart_editor(_args: Dictionary) -> Dictionary:
 	return {"ok": true, "restarting": true, "saved": true}
 
 
+## 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
+## such an editor was given, for the reason above: the engine consumes the arguments and hands none
+## of them back. So the server starts it again itself, and this is the part only the editor can do.
+##
+## 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()
+
+	# Deferred so this answer is on its way out before the editor goes.
+	_leave.call_deferred()
+
+	return {"ok": true, "quitting": true, "saved": true}
+
+
+## Asked of the tree the editor's own window is in, because this object is not in one.
+static func _leave() -> void:
+	var base: Control = EditorInterface.get_base_control()
+	if base != null and base.get_tree() != null:
+		base.get_tree().quit()
+
+
 func playing_status(_args: Dictionary) -> Dictionary:
 	var playing: bool = EditorInterface.is_playing_scene()
 	# The debugger's port with it, read now rather than remembered: it is taken again before every

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

@@ -2,6 +2,8 @@ extends RefCounted
 
 ## A picture of the running game, as a PNG written where the server asked for it.
 
+const Values = preload("runtime_values.gd")
+
 var _host: Node
 
 
@@ -18,9 +20,10 @@ func capture_viewport(params: Dictionary) -> Dictionary:
 	if viewport_path.is_empty():
 		return capture_screenshot(params)
 
-	var node: Node = _host.get_tree().root.get_node_or_null(viewport_path)
-	if node == null:
-		return {"type": "error", "message": "Viewport not found: " + viewport_path}
+	var standing: Dictionary = Values.node_at(_host.get_tree().root, viewport_path)
+	if standing.has("message"):
+		return standing
+	var node: Node = standing["node"]
 	if not node is Viewport:
 		return {"type": "error", "message": "Node is not a Viewport: " + viewport_path}
 	return _capture(node, params)

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

@@ -440,9 +440,10 @@ func click(params: Dictionary) -> Dictionary:
 	if node_path.is_empty():
 		return {"type": "error", "message": "Node path required"}
 
-	var node: Node = _host.get_tree().root.get_node_or_null(node_path)
-	if node == null:
-		return {"type": "error", "message": "Node not found: " + node_path}
+	var standing: Dictionary = Values.node_at(_host.get_tree().root, node_path)
+	if standing.has("message"):
+		return standing
+	var node: Node = standing["node"]
 	if node is Node3D:
 		return await _click_in_the_world(node_path, node, params)
 	if not node is Control:
@@ -580,9 +581,10 @@ func choose(params: Dictionary) -> Dictionary:
 	var node_path: String = str(params.get("path", ""))
 	if node_path.is_empty():
 		return {"type": "error", "message": "Node path required"}
-	var node: Node = _host.get_tree().root.get_node_or_null(node_path)
-	if node == null:
-		return {"type": "error", "message": "Node not found: " + node_path}
+	var standing: Dictionary = Values.node_at(_host.get_tree().root, node_path)
+	if standing.has("message"):
+		return standing
+	var node: Node = standing["node"]
 
 	var menu: PopupMenu = _menu_of(node)
 	if menu == null:

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

@@ -34,9 +34,10 @@ func get_tree(params: Dictionary) -> Dictionary:
 	var max_depth: int = int(params.get("depth", 3))
 	var include_properties: bool = bool(params.get("include_properties", false))
 
-	var root: Node = _host.get_tree().root.get_node_or_null(root_path)
-	if root == null:
-		return {"type": "error", "message": "Node not found: " + root_path}
+	var reached: Dictionary = Values.node_at(_host.get_tree().root, root_path)
+	if reached.has("message"):
+		return reached
+	var root: Node = reached["node"]
 
 	return {"type": "tree", "root": _serialize_node_tree(root, 0, max_depth, include_properties)}
 
@@ -64,9 +65,10 @@ func find_nodes(params: Dictionary) -> Dictionary:
 	if not wanted["script"].is_empty() and not wanted["script"].begins_with("res://"):
 		wanted["script"] = "res://" + wanted["script"]
 
-	var root: Node = _host.get_tree().root.get_node_or_null(root_path)
-	if root == null:
-		return {"type": "error", "message": "Node not found: " + root_path}
+	var reached: Dictionary = Values.node_at(_host.get_tree().root, root_path)
+	if reached.has("message"):
+		return reached
+	var root: Node = reached["node"]
 
 	var found: Array[Dictionary] = []
 	var pending: Array[Node] = [root]
@@ -128,7 +130,7 @@ func _found(node: Node, wanted_property: String) -> Dictionary:
 		entry["has_property"] = false
 		return entry
 	var holder: Object = reached["holder"]
-	var named: String = reached["property"]
+	var named: String = reached["name"]
 	var has: bool = _has_property(holder, named)
 	entry["has_property"] = has
 	if has:
@@ -208,9 +210,10 @@ func read_text(params: Dictionary) -> Dictionary:
 	var include_hidden: bool = bool(params.get("include_hidden", false))
 	var limit: int = clampi(int(params.get("limit", READ_LIMIT)), 1, READ_LIMIT)
 
-	var root: Node = _host.get_tree().root.get_node_or_null(root_path)
-	if root == null:
-		return {"type": "error", "message": "Node not found: " + root_path}
+	var reached: Dictionary = Values.node_at(_host.get_tree().root, root_path)
+	if reached.has("message"):
+		return reached
+	var root: Node = reached["node"]
 
 	# One line further than asked for, so that whether anything was left behind is read off the
 	# walk rather than guessed at from the count: a panel of exactly as many lines as the caller
@@ -275,9 +278,10 @@ func get_rect(params: Dictionary) -> Dictionary:
 	if node_path.is_empty():
 		return {"type": "error", "message": "Node path required"}
 
-	var node: Node = _host.get_tree().root.get_node_or_null(node_path)
-	if node == null:
-		return {"type": "error", "message": "Node not found: " + node_path}
+	var standing: Dictionary = Values.node_at(_host.get_tree().root, node_path)
+	if standing.has("message"):
+		return standing
+	var node: Node = standing["node"]
 
 	if node is Control:
 		var control: Control = node
@@ -426,16 +430,17 @@ func get_property(params: Dictionary) -> Dictionary:
 	if node_path.is_empty() or property.is_empty():
 		return {"type": "error", "message": "Node path and property required"}
 
-	var node: Node = _host.get_tree().root.get_node_or_null(node_path)
-	if node == null:
-		return {"type": "error", "message": "Node not found: " + node_path}
+	var standing: Dictionary = Values.node_at(_host.get_tree().root, node_path)
+	if standing.has("message"):
+		return standing
+	var node: Node = standing["node"]
 
 	var reached: Dictionary = _reached(node, node_path, property)
 	if reached.has("message"):
 		return reached
 
 	var holder: Object = reached["holder"]
-	var named: String = reached["property"]
+	var named: String = reached["name"]
 	# Asked of the property list rather than read and compared to null, because a property the
 	# holder does not have and a property that is null both read as null.
 	if not _has_property(holder, named):
@@ -449,11 +454,14 @@ func get_property(params: Dictionary) -> Dictionary:
 	}
 
 
-## What [param property] is a property of, which is the node itself until the name has a colon in
-## it, and the last name along that path.
+## What [param reaching] names something on, which is the node itself until the name has a colon
+## in it, and the last name along that path.
 ##
 ## A game's state does not sit on nodes, it hangs off them: the speed of the clock is a property of
 ## a [RefCounted] held by a [RefCounted] held by the root, and that is what an agent asks about.
+## What a game does hangs off them the same way, so the last name is a property to read, a property
+## to write or a method to call, and the walk to it is one walk.
+##
 ## Colons, because that is the separator [method Object.get_indexed] already takes. Walked a step
 ## at a time rather than handed to that method, which answers null for a path that goes wrong
 ## halfway along and for one that ends on null.
@@ -461,8 +469,8 @@ func get_property(params: Dictionary) -> Dictionary:
 ## Answers with a `message` instead when a step along the way is not there or holds something that
 ## is not an object, naming the step rather than the whole path: "/root/Main:_game has no property
 ## clocks" is a typo found, and "no property _game:clocks:speed" is a puzzle.
-func _reached(node: Node, node_path: String, property: String) -> Dictionary:
-	var parts: PackedStringArray = property.split(":")
+func _reached(node: Node, node_path: String, reaching: String) -> Dictionary:
+	var parts: PackedStringArray = reaching.split(":")
 	var holder: Object = node
 	var called: String = node_path
 	for step: int in parts.size() - 1:
@@ -475,7 +483,7 @@ func _reached(node: Node, node_path: String, property: String) -> Dictionary:
 			var wanted: String = parts[step + 1]
 			return {"type": "error", "message": "%s holds no object to read %s off" % [called, wanted]}
 		holder = next
-	return {"holder": holder, "property": parts[parts.size() - 1], "called": called}
+	return {"holder": holder, "name": parts[parts.size() - 1], "called": called}
 
 
 ## Whether [param holder] declares [param named]. Its own function because three ops ask it and a
@@ -495,9 +503,10 @@ func set_property(params: Dictionary) -> Dictionary:
 	if node_path.is_empty() or property.is_empty():
 		return {"type": "error", "message": "Node path and property required"}
 
-	var node: Node = _host.get_tree().root.get_node_or_null(node_path)
-	if node == null:
-		return {"type": "error", "message": "Node not found: " + node_path}
+	var standing: Dictionary = Values.node_at(_host.get_tree().root, node_path)
+	if standing.has("message"):
+		return standing
+	var node: Node = standing["node"]
 
 	# Through a path as well, for the reason [method _reached] gives, and read back off the same
 	# holder afterwards: a set that does not take says so by answering with the old value, which is
@@ -507,7 +516,7 @@ func set_property(params: Dictionary) -> Dictionary:
 		return reached
 
 	var holder: Object = reached["holder"]
-	var named: String = reached["property"]
+	var named: String = reached["name"]
 	var old_value: Variant = holder.get(named)
 	holder.set(named, _values.fitted(value, typeof(old_value)))
 
@@ -528,18 +537,28 @@ func call_method(params: Dictionary) -> Dictionary:
 	if node_path.is_empty() or method.is_empty():
 		return {"type": "error", "message": "Node path and method required"}
 
-	var node: Node = _host.get_tree().root.get_node_or_null(node_path)
-	if node == null:
-		return {"type": "error", "message": "Node not found: " + node_path}
+	var standing: Dictionary = Values.node_at(_host.get_tree().root, node_path)
+	if standing.has("message"):
+		return standing
+	var node: Node = standing["node"]
 
-	if not node.has_method(method):
-		return {"type": "error", "message": "Method not found: " + method}
+	# Through a path as well, for the reason [method _reached] gives. What a game does hangs off its
+	# nodes as much as its state does, so reading `_game:run:day` while being unable to call
+	# `_game:run:advance` answers half of what a node holds and refuses the other half.
+	var reached: Dictionary = _reached(node, node_path, method)
+	if reached.has("message"):
+		return reached
+
+	var holder: Object = reached["holder"]
+	var named: String = reached["name"]
+	if not holder.has_method(named):
+		return {"type": "error", "message": "%s has no method %s" % [reached["called"], named]}
 
 	var deserialized_args: Array = []
 	for index: int in args.size():
-		deserialized_args.append(_values.fitted(args[index], _values.parameter_type(node, method, index)))
+		deserialized_args.append(_values.fitted(args[index], _values.parameter_type(holder, named, index)))
 
-	var result: Variant = node.callv(method, deserialized_args)
+	var result: Variant = holder.callv(named, deserialized_args)
 
 	return {"type": "method_result", "path": node_path, "method": method, "result": _values.serialize(result)}
 

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

@@ -42,6 +42,37 @@ func serialize(value: Variant) -> Variant:
 	return call(serialiser, value) if not serialiser.is_empty() else value
 
 
+## The node [param path] names under [param root], or a refusal saying why there is not one.
+##
+## The other direction of what a node serialises as, and here for that reason: a node crosses the
+## wire as its path, so a path crossing back is a node or it is nothing. One answer for every op,
+## because each of them read a path for itself and they could disagree about what one means.
+##
+## A colon is the disagreement worth its own sentence. Godot reads everything after the first one
+## as subnames and [method Node.get_node_or_null] drops them, so "/root/Main:_game:run" was quietly
+## answered about "/root/Main", and an op that then said the path had no method `advance` was right
+## about an object nobody had asked for. Colons reach through what a node holds, and the arguments
+## that take them are the property and the method.
+static func node_at(root: Node, path: String) -> Dictionary:
+	if path.is_empty():
+		return {"type": "error", "message": "Node path required"}
+
+	if path.contains(":"):
+		var shape: String = (
+			'"%s" names a node and colons reach past one: "%s" is the node,'
+			+ ' and "%s" goes in the property or the method'
+		)
+		return {
+			"type": "error",
+			"message": shape % [path, path.get_slice(":", 0), path.substr(path.find(":") + 1)],
+		}
+
+	var node: Node = root.get_node_or_null(path)
+	if node == null:
+		return {"type": "error", "message": "Node not found: " + path}
+	return {"node": node}
+
+
 func _serialize_nil(_value: Variant) -> Variant:
 	return null
 

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

@@ -53,9 +53,10 @@ func wait_signal(params: Dictionary) -> Dictionary:
 	if node_path.is_empty() or signal_name.is_empty():
 		return {"type": "error", "message": "Node path and signal name required"}
 
-	var node: Node = _host.get_tree().root.get_node_or_null(node_path)
-	if node == null:
-		return {"type": "error", "message": "Node not found: " + node_path}
+	var standing: Dictionary = Values.node_at(_host.get_tree().root, node_path)
+	if standing.has("message"):
+		return standing
+	var node: Node = standing["node"]
 	if not node.has_signal(signal_name):
 		return {"type": "error", "message": "%s has no signal %s" % [node_path, signal_name]}
 
@@ -90,8 +91,9 @@ func wait_until(params: Dictionary) -> Dictionary:
 		return _out_of_range("timeout_ms", timeout_ms, 1, CEILING_MSEC)
 	if node_path.is_empty():
 		return {"type": "error", "message": "Node path required"}
-	if _host.get_tree().root.get_node_or_null(node_path) == null:
-		return {"type": "error", "message": "Node not found: " + node_path}
+	var standing: Dictionary = Values.node_at(_host.get_tree().root, node_path)
+	if standing.has("message"):
+		return standing
 	if not says.is_empty():
 		return await _wait_until_said(node_path, says, timeout_ms)
 	if property.is_empty():
@@ -99,7 +101,7 @@ func wait_until(params: Dictionary) -> Dictionary:
 	if not params.has("value"):
 		return {"type": "error", "message": "A value to wait for is required"}
 
-	var node: Node = _host.get_tree().root.get_node_or_null(node_path)
+	var node: Node = standing["node"]
 
 	var current: Variant = node.get(property)
 	var wanted: Variant = _values.fitted(params["value"], typeof(current))