gdharness 1.1.8 → 1.1.10

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/operations/project_config.gd

@@ -149,12 +149,13 @@ func add_autoload(params: Dictionary) -> Dictionary:
 	if not FileAccess.file_exists(path):
 		return _log.failure("Autoload file does not exist: " + path)
 
-	# Through ProjectSettings so the file is saved the way the editor saves it, header and
-	# every other line kept; a ConfigFile of project.godot drops the comments on the way out.
+	# Through ProjectSettings so the file is saved the way the editor saves it, which includes
+	# putting Godot's header back and dropping any comment somebody wrote into the file by hand.
 	var setting: String = "autoload/" + name
 	var was_updated: bool = ProjectSettings.has_setting(setting)
 
-	# An asterisk in front of the path is how project.godot marks an autoload as enabled.
+	# An asterisk in front of the path makes the autoload a global name as well. Without it the
+	# node still comes up under the root; only the name stops resolving.
 	ProjectSettings.set_setting(setting, ("*" if enabled else "") + path)
 	var err: Error = ProjectSettings.save()
 	if err != OK: