gdharness 1.1.9 → 1.1.11

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

@@ -243,7 +243,7 @@ func announced_url() -> String:
 	var file: FileAccess = FileAccess.open(ANNOUNCEMENT, FileAccess.READ)
 	if file == null:
 		return ""
-	var said: Variant = JSON.parse_string(file.get_as_text())
+	var said: Variant = Read.json_or_null(file.get_as_text())
 	file.close()
 	if not said is Dictionary:
 		return ""
@@ -481,7 +481,7 @@ func _on_reconnect_timer() -> void:
 
 
 func _handle_message(json_string: String) -> void:
-	var parsed: Variant = JSON.parse_string(json_string)
+	var parsed: Variant = Read.json_or_null(json_string)
 	if not parsed is Dictionary:
 		push_error("[gdharness] The server sent something that is not a message: %s" % json_string)
 		return

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

@@ -69,3 +69,16 @@ static func as_bool(value: Variant, fallback: bool = false) -> bool:
 		var text: String = value
 		return not text.is_empty()
 	return fallback
+
+
+## [param text] read as JSON, or null when it does not parse, without printing anything.
+##
+## [method JSON.parse_string] prints an engine error for text that does not parse, and that error
+## lands in the log of whatever is running it. A caller sending the word "five" where a number was
+## wanted was refused properly, and the game's own log then held an error it never made, so its
+## verdict read `clean: false`. Text that is not JSON is an answer here, not a fault.
+static func json_or_null(text: String) -> Variant:
+	var json: JSON = JSON.new()
+	if json.parse(text) != OK:
+		return null
+	return json.data

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

@@ -256,7 +256,7 @@ func fitted(value: Variant, type: int) -> Variant:
 
 	if rebuilt is String and type != TYPE_STRING:
 		var text: String = rebuilt
-		var parsed: Variant = JSON.parse_string(text)
+		var parsed: Variant = Read.json_or_null(text)
 		# A string that does not read as the type wanted is handed back as the string it is, so
 		# whoever asked can refuse it. type_convert answers 0 for "not an index" and true for any
 		# text at all, and a caller who sent a word got back a number they never sent: get_child

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

@@ -86,7 +86,7 @@ func _parse_json_maybe(value: Variant) -> Variant:
 	if typeof(value) != TYPE_STRING:
 		return value
 	var text: String = value
-	var parsed: Variant = JSON.parse_string(text)
+	var parsed: Variant = Read.json_or_null(text)
 	if parsed == null and text != "null":
 		return value
 	return parsed

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

@@ -127,7 +127,7 @@ func _parse_properties_arg(raw_properties: Variant) -> Dictionary:
 		var text: String = str(raw_properties)
 		if text.strip_edges().is_empty():
 			return {}
-		var parsed: Variant = JSON.parse_string(text)
+		var parsed: Variant = Read.json_or_null(text)
 		if typeof(parsed) == TYPE_DICTIONARY:
 			return parsed
 	return {}

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

@@ -69,3 +69,16 @@ static func as_bool(value: Variant, fallback: bool = false) -> bool:
 		var text: String = value
 		return not text.is_empty()
 	return fallback
+
+
+## [param text] read as JSON, or null when it does not parse, without printing anything.
+##
+## [method JSON.parse_string] prints an engine error for text that does not parse, and that error
+## lands in the log of whatever is running it. A caller sending the word "five" where a number was
+## wanted was refused properly, and the game's own log then held an error it never made, so its
+## verdict read `clean: false`. Text that is not JSON is an answer here, not a fault.
+static func json_or_null(text: String) -> Variant:
+	var json: JSON = JSON.new()
+	if json.parse(text) != OK:
+		return null
+	return json.data

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

@@ -10,6 +10,7 @@ const Values = preload("runtime_values.gd")
 ## reports are the same place by construction rather than by agreement.
 const Queries = preload("runtime_queries.gd")
 const Read = preload("reading.gd")
+const Targets = preload("runtime_targets.gd")
 const Words = preload("runtime_words.gd")
 
 ## The distance from a capital letter to its small one in Unicode. A keycode holds the capital.
@@ -484,10 +485,25 @@ static func _scroll_into_view(control: Control) -> bool:
 ## A control out of sight inside a ScrollContainer is scrolled to first; the answer says so under
 ## `scrolled_into_view`, because the view having moved is a thing that happened to the screen and
 ## the caller is the only one who can tell whether that matters.
+##
+## `says` names the control by the words on it instead, under `path` when that is given as well,
+## found and pressed in the same frame. A find and then a click by path was two round trips over a
+## generated path copied whole, and a panel that rebuilt itself between them freed the button, so
+## the click landed on nothing.
 func click(params: Dictionary) -> Dictionary:
 	var node_path: String = str(params.get("path", ""))
+	var wanted: String = str(params.get("says", ""))
+	var found: Variant = null
+	if not wanted.is_empty():
+		var picked: Dictionary = Targets.control_saying(
+			_host.get_tree().root, "/root" if node_path.is_empty() else node_path, wanted, params.get("index")
+		)
+		if picked.has("message"):
+			return picked
+		node_path = picked["path"]
+		found = picked["found"]
 	if node_path.is_empty():
-		return {"type": "error", "message": "Node path required"}
+		return {"type": "error", "message": "click needs a path, or says to find the control by its words"}
 
 	var standing: Dictionary = Values.node_at(_host.get_tree().root, node_path)
 	if standing.has("message"):
@@ -582,7 +598,7 @@ func click(params: Dictionary) -> Dictionary:
 	if is_instance_valid(control):
 		afterwards = "in_tree" if control.is_inside_tree() else "removed"
 
-	return {
+	var answer: Dictionary = {
 		"type": "clicked",
 		"path": node_path,
 		"position": _values.serialize(position),
@@ -593,6 +609,9 @@ func click(params: Dictionary) -> Dictionary:
 		"control_afterwards": afterwards,
 		"scrolled_into_view": scrolled,
 	}
+	if found != null:
+		answer["found"] = found
+	return answer
 
 
 ## What to add to a refusal about a point outside the viewport, when the reason is that nobody

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

@@ -259,6 +259,12 @@ static func _says(said: String, wanted: String) -> bool:
 	return said.containsn(words) if _is_literal(words) else said.matchn(words)
 
 
+## Whether [param node]'s own words are what [param wanted] asks for, by the rules a find uses, so a
+## click that names its control by its words finds the one a find would have answered with.
+static func says(node: Node, wanted: String) -> bool:
+	return _says(Words.said_by(node), wanted)
+
+
 ## [param wanted], a glob, open at both ends so it matches its words anywhere in a text; "" when
 ## it is not a glob, or already open at both ends, and so has nothing to suggest.
 static func _widened(wanted: String) -> String:

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

@@ -0,0 +1,113 @@
+extends RefCounted
+
+## Which control a click means when it names the control by the words on it rather than by path.
+
+const Queries = preload("runtime_queries.gd")
+const Read = preload("reading.gd")
+const Values = preload("runtime_values.gd")
+const Words = preload("runtime_words.gd")
+
+## How many of the controls saying the same words a refusal names, with the index for each.
+const LISTED_CANDIDATES: int = 10
+
+
+## The control a click by [param wanted] words presses, found under [param root_path] in the tree
+## [param root] heads, or the refusal saying why there is none or which of several:
+## {"path", "found"} or {"type", "message"}.
+##
+## Matched the way a find matches `says`, against a control's own words, and only among controls
+## the player can see. A match inside a button presses the button, because the label is what says
+## the words and the button is what takes the click: aimed at the label, the pointer lands on the
+## button and the answer would call the click a miss. Several matches are refused rather than
+## guessed, each named with the [param which] that picks it, counting from 0.
+static func control_saying(root: Node, root_path: String, wanted: String, which: Variant) -> Dictionary:
+	var reached: Dictionary = Values.node_at(root, root_path)
+	if reached.has("message"):
+		return reached
+	var targets: Array[Control] = []
+	# The words of the control that matched, which a button pressed on a label's behalf has none of.
+	var said: Array[String] = []
+	var hidden: int = 0
+	var pending: Array[Node] = [reached["node"]]
+	while not pending.is_empty():
+		var node: Node = pending.pop_front()
+		if node is Control and Queries.says(node, wanted):
+			if not Queries.shown(node):
+				hidden += 1
+			else:
+				var matched: Control = node
+				var target: Control = _pressed_through(matched)
+				if not targets.has(target):
+					targets.append(target)
+					said.append(Words.said_by(node))
+		var children: Array[Node] = node.get_children(true)
+		for index: int in range(children.size() - 1, -1, -1):
+			pending.push_front(children[index])
+
+	var under: String = "" if root_path == "/root" else " under %s" % root_path
+	if targets.is_empty():
+		return {
+			"type": "error",
+			"message":
+			(
+				'no control on screen%s says "%s", so nothing was clicked%s'
+				% [under, wanted, _hidden_note(hidden)]
+			)
+		}
+	if which == null and targets.size() > 1:
+		return {
+			"type": "error",
+			"message":
+			(
+				'%d controls on screen%s say "%s", so which to click is not clear; pass index, counting from 0: %s'
+				% [targets.size(), under, wanted, _candidates(targets, said)]
+			)
+		}
+	var index: int = 0 if which == null else Read.as_int(which, -1)
+	if index < 0 or index >= targets.size():
+		var plural: String = "" if targets.size() == 1 else "s"
+		return {
+			"type": "error",
+			"message":
+			(
+				'index %s is not one of the %d control%s on screen%s saying "%s": %s'
+				% [str(which), targets.size(), plural, under, wanted, _candidates(targets, said)]
+			)
+		}
+	return {
+		"path": str(targets[index].get_path()),
+		"found": {"says": wanted, "index": index, "of": targets.size()},
+	}
+
+
+## What to add to a refusal that found nothing on screen, when words matched controls out of sight.
+static func _hidden_note(hidden: int) -> String:
+	if hidden == 0:
+		return ""
+	return "; %d hidden control%s" % [hidden, " says it" if hidden == 1 else "s say it"]
+
+
+## [param control], or the button holding it when it is not one itself, which is what a click on
+## its words means.
+static func _pressed_through(control: Control) -> Control:
+	var walk: Node = control
+	while walk != null:
+		if walk is BaseButton:
+			var pressed: BaseButton = walk
+			return pressed
+		walk = walk.get_parent()
+	return control
+
+
+## The controls a click by words could mean, each with its index, its path and the words that
+## matched, [param said] holding those in the same order.
+static func _candidates(targets: Array[Control], said: Array[String]) -> String:
+	var named: Array[String] = []
+	for index: int in mini(targets.size(), LISTED_CANDIDATES):
+		var words: String = said[index].replace("\n", " ")
+		if words.length() > 60:
+			words = words.substr(0, 57) + "..."
+		named.append('%d %s ("%s")' % [index, targets[index].get_path(), words])
+	if targets.size() > LISTED_CANDIDATES:
+		named.append("and %d more" % (targets.size() - LISTED_CANDIDATES))
+	return "; ".join(named)

package/build/godot/addons/gdharness_runtime/runtime_targets.gd.uid

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

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

@@ -256,7 +256,7 @@ func fitted(value: Variant, type: int) -> Variant:
 
 	if rebuilt is String and type != TYPE_STRING:
 		var text: String = rebuilt
-		var parsed: Variant = JSON.parse_string(text)
+		var parsed: Variant = Read.json_or_null(text)
 		# A string that does not read as the type wanted is handed back as the string it is, so
 		# whoever asked can refuse it. type_convert answers 0 for "not an index" and true for any
 		# text at all, and a caller who sent a word got back a number they never sent: get_child

package/build/godot/operations/import_pipeline.gd

@@ -645,7 +645,7 @@ static func _images_of(scene_path: String) -> Array[String]:
 				text = bytes.slice(20, mini(20 + length, bytes.size())).get_string_from_utf8()
 	if text.is_empty():
 		return images
-	var parsed: Variant = JSON.parse_string(text)
+	var parsed: Variant = Read.json_or_null(text)
 	if not parsed is Dictionary:
 		return images
 	var document: Dictionary = parsed

package/build/godot/operations/reading.gd

@@ -69,3 +69,16 @@ static func as_bool(value: Variant, fallback: bool = false) -> bool:
 		var text: String = value
 		return not text.is_empty()
 	return fallback
+
+
+## [param text] read as JSON, or null when it does not parse, without printing anything.
+##
+## [method JSON.parse_string] prints an engine error for text that does not parse, and that error
+## lands in the log of whatever is running it. A caller sending the word "five" where a number was
+## wanted was refused properly, and the game's own log then held an error it never made, so its
+## verdict read `clean: false`. Text that is not JSON is an answer here, not a fault.
+static func json_or_null(text: String) -> Variant:
+	var json: JSON = JSON.new()
+	if json.parse(text) != OK:
+		return null
+	return json.data

package/build/godot/operations/serialisation.gd

@@ -256,7 +256,7 @@ func fitted(value: Variant, type: int) -> Variant:
 
 	if rebuilt is String and type != TYPE_STRING:
 		var text: String = rebuilt
-		var parsed: Variant = JSON.parse_string(text)
+		var parsed: Variant = Read.json_or_null(text)
 		# A string that does not read as the type wanted is handed back as the string it is, so
 		# whoever asked can refuse it. type_convert answers 0 for "not an index" and true for any
 		# text at all, and a caller who sent a word got back a number they never sent: get_child