gdharness 1.1.45 → 1.1.47

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

@@ -41,26 +41,38 @@ static func control_saying(root: Node, root_path: String, wanted: String, which:
 	# The words of the control that matched, which a button pressed on a label's behalf has none of.
 	var said: Array[String] = []
 	var exact: Array[bool] = []
+	# Whether the words are only inside longer words there, "out" in "Scout".
+	var inside: Array[bool] = []
 	var hidden: int = 0
+	# Controls saying exactly the words that a click cannot reach, kept to say what a match on screen
+	# that only says them as part of more stands in for.
+	var exact_out_of_reach: Array[Node] = []
+	var out_of_reach_as: Array[String] = []
 	var pending: Array[Node] = [reached["node"]]
 	while not pending.is_empty():
 		var node: Node = pending.pop_front()
 		if node is Control and Says.says(node, wanted):
 			if not Queries.shown(node):
 				hidden += 1
+				if _says_exactly(Words.said_by(node), wanted):
+					exact_out_of_reach.append(node)
+					out_of_reach_as.append("hidden")
 			else:
 				var control: Control = node
 				var target: Control = _pressed_through(control)
 				var words: String = Words.said_by(node)
 				var whole: bool = _says_exactly(words, wanted)
+				var buried: bool = not whole and _inside_a_word(words, wanted)
 				var at: int = matched.find(target)
 				if at == -1:
 					matched.append(target)
 					said.append(words)
 					exact.append(whole)
-				elif whole and not exact[at]:
+					inside.append(buried)
+				elif (whole and not exact[at]) or (inside[at] and not buried):
 					said[at] = words
-					exact[at] = true
+					exact[at] = whole
+					inside[at] = buried
 		var children: Array[Node] = node.get_children(true)
 		for index: int in range(children.size() - 1, -1, -1):
 			pending.push_front(children[index])
@@ -74,17 +86,27 @@ static func control_saying(root: Node, root_path: String, wanted: String, which:
 	for index: int in matched.size():
 		if _off_screen(matched[index]):
 			outside += 1
+			if exact[index]:
+				exact_out_of_reach.append(matched[index])
+				out_of_reach_as.append("outside what the screen shows")
 			continue
 		var over: Node = _cover_of(matched[index], drawn, areas)
 		if over == null:
 			open.append(index)
 		else:
 			covered += 1
+			if exact[index]:
+				exact_out_of_reach.append(matched[index])
+				out_of_reach_as.append("under %s, which is drawn over it" % over.get_path())
 			if cover == null:
 				cover = over
-	# Stable, so matches of one rank keep the order they are drawn in.
+	# Stable, so matches of one rank keep the order they are drawn in. Words only inside longer words
+	# come after everything else: ranked as a button saying them as part of more, "Scout, 90" was
+	# pressed for "Out" over a control saying exactly "Out", and spent a game's silver.
 	open.sort_custom(
 		func(a: int, b: int) -> bool:
+			if inside[a] != inside[b]:
+				return inside[b]
 			var first: int = _rank(matched[a], exact[a])
 			var second: int = _rank(matched[b], exact[b])
 			return first > second or (first == second and a < b)
@@ -92,10 +114,14 @@ static func control_saying(root: Node, root_path: String, wanted: String, which:
 	var targets: Array[Control] = []
 	var ranks: Array[int] = []
 	var lines: Array[String] = []
+	var wholes: Array[bool] = []
+	var insides: Array[bool] = []
 	for index: int in open:
 		targets.append(matched[index])
 		ranks.append(_rank(matched[index], exact[index]))
 		lines.append(said[index])
+		wholes.append(exact[index])
+		insides.append(inside[index])
 
 	var under: String = "" if root_path == "/root" else " under %s" % root_path
 	if targets.is_empty():
@@ -103,11 +129,21 @@ static func control_saying(root: Node, root_path: String, wanted: String, which:
 			"type": "error",
 			"message":
 			(
-				'no control on screen%s says "%s", so nothing was clicked%s%s%s'
-				% [under, wanted, _hidden_note(hidden), _outside_note(outside), _covered_note(covered, cover)]
+				'no control on screen%s says "%s", so nothing was clicked%s%s%s%s'
+				% [
+					under,
+					wanted,
+					_hidden_note(hidden),
+					_outside_note(outside),
+					_covered_note(covered, cover),
+					_open_menu_note(root, wanted),
+				]
 			)
 		}
-	var best: int = ranks.count(ranks[0])
+	var best: int = 0
+	for at: int in targets.size():
+		if ranks[at] == ranks[0] and insides[at] == insides[0]:
+			best += 1
 	if which == null and best > 1:
 		var order: String = "" if best == targets.size() else ", best matches first"
 		return {
@@ -129,7 +165,77 @@ static func control_saying(root: Node, root_path: String, wanted: String, which:
 				% [str(which), targets.size(), plural, under, wanted, _candidates(targets, lines)]
 			)
 		}
+	# A match saying the words as part of more, while another control says exactly them, is a stand-in
+	# for that one, not the control meant: a tab reading "Out" sat in a collapsed drawer and a dispatch
+	# saying somebody "fell out in the hall" was pressed, and with the tab's own words on screen in a
+	# control that is not a button, a card reading "Scout, 90" was. Pressed only when asked for by
+	# index, which is the caller saying the match is what they meant.
+	var exact_elsewhere: Array[Node] = exact_out_of_reach.duplicate()
+	var elsewhere_as: Array[String] = out_of_reach_as.duplicate()
+	# On screen only when it takes clicks itself: a heading saying exactly "Onward" beside a button
+	# saying "Onward now" is not what a click on "Onward" is for, and the button is pressed.
+	for other: int in targets.size():
+		var taking: bool = targets[other].get_mouse_filter_with_override() != Control.MOUSE_FILTER_IGNORE
+		if other != index and wholes[other] and taking:
+			exact_elsewhere.append(targets[other])
+			elsewhere_as.append("on screen, taking clicks but not an enabled button")
+	var best_one: String = "the one on screen," if targets.size() == 1 else "the best match on screen,"
+	if which == null and not wholes[index] and not exact_elsewhere.is_empty():
+		return {
+			"type": "error",
+			"message":
+			(
+				(
+					'no %s on screen%s says exactly "%s", so nothing was clicked: %s %s says it as part of'
+					+ ' "%s", while %s; pass index %d to press that one anyway'
+				)
+				% [
+					"button" if exact_elsewhere.size() > exact_out_of_reach.size() else "control",
+					under,
+					wanted,
+					best_one,
+					targets[index].get_path(),
+					_shortened(lines[index]),
+					_out_of_reach_exactly(exact_elsewhere, elsewhere_as),
+					index,
+				]
+			)
+		}
+	if which == null and insides[index]:
+		return {
+			"type": "error",
+			"message":
+			(
+				(
+					'no control on screen%s says "%s" as a word of its own, so nothing was clicked: %s %s has'
+					+ ' it only inside a longer word, "%s"; pass index %d to press that one anyway'
+				)
+				% [under, wanted, best_one, targets[index].get_path(), _shortened(lines[index]), index]
+			)
+		}
+	# Words in a sentence on a control that lets the pointer through: the press lands on whatever is
+	# under it, which is nothing the words name. A line saying what "is out there" was the best match
+	# left for "Out" once the cards saying "Scout" were passed over.
+	if (
+		which == null
+		and not wholes[index]
+		and targets[index].get_mouse_filter_with_override() == Control.MOUSE_FILTER_IGNORE
+	):
+		return {
+			"type": "error",
+			"message":
+			(
+				(
+					'no control on screen%s that takes a click says "%s", so nothing was clicked: %s %s says it'
+					+ ' as part of "%s" and lets the pointer through to what is under it; pass index %d to'
+					+ " click there anyway"
+				)
+				% [under, wanted, best_one, targets[index].get_path(), _shortened(lines[index]), index]
+			)
+		}
 	var found: Dictionary = {"says": wanted, "index": index, "of": targets.size()}
+	if not wholes[index]:
+		found["partOf"] = _shortened(lines[index])
 	if which == null and targets.size() > 1:
 		var others: String = (
 			"the other one on screen %s" % _passed_over(ranks[0], true)
@@ -157,7 +263,8 @@ static func _rank(target: Control, whole: bool) -> int:
 ## A line counts because a card is a title over a description: "WARD" over "wards 3" is the card
 ## named WARD, and read as its words run together it said WARD only as part of more, level with
 ## "WARDSPITE" over its own description, and a click on WARD was refused as not clear.
-static func _says_exactly(said: String, wanted: String) -> bool:
+static func _says_exactly(written: String, wanted: String) -> bool:
+	var said: String = Says.spaced(written)
 	for words: String in Says.alternatives(wanted):
 		if not Says.is_plain(words):
 			if said.matchn(words):
@@ -172,6 +279,32 @@ static func _says_exactly(said: String, wanted: String) -> bool:
 	return false
 
 
+## Whether [param written] has the plain words [param wanted] asks for only inside longer words,
+## never starting where a word starts: "out" in "Scout". Words starting a longer one count as said,
+## "Recruit" in "Recruits", and so does anything matched by a pattern.
+static func _inside_a_word(written: String, wanted: String) -> bool:
+	var said: String = Says.spaced(written).to_lower()
+	var found: bool = false
+	for words: String in Says.alternatives(wanted):
+		var looked_for: String = words.to_lower()
+		if not Says.is_plain(words) or not _in_a_word(looked_for.unicode_at(0)):
+			return false
+		var at: int = said.find(looked_for)
+		while at >= 0:
+			found = true
+			if at == 0 or not _in_a_word(said.unicode_at(at - 1)):
+				return false
+			at = said.find(looked_for, at + 1)
+	return found
+
+
+## Whether the character [param code] is part of a word: a letter, a digit or an underscore. A letter
+## is told by having a case, which leaves scripts without one counted as breaks between words.
+static func _in_a_word(code: int) -> bool:
+	var character: String = String.chr(code)
+	return character.to_lower() != character.to_upper() or character.is_valid_int() or character == "_"
+
+
 ## [param count] matches of [param rank], as the start of a sentence.
 static func _described(count: int, rank: int, wanted: String, under: String) -> String:
 	var what: String = "button" if rank >= 2 else "control"
@@ -461,7 +594,7 @@ static func _clipped_away(
 ## words. A line in another font or holding an image measures off from what is drawn, which a wide
 ## line with nothing between the words and its start hardly does.
 static func point_on_words(label: RichTextLabel, wanted: String) -> Dictionary:
-	var text: String = Words.said_by(label)
+	var text: String = Says.spaced(Words.said_by(label))
 	var start: int = -1
 	var length: int = 0
 	for words: String in Says.alternatives(wanted):
@@ -515,10 +648,48 @@ static func _layer_of(control: Control) -> int:
 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])
+		named.append('%d %s ("%s")' % [index, targets[index].get_path(), _shortened(said[index])])
 	if targets.size() > LISTED_CANDIDATES:
 		named.append("and %d more" % (targets.size() - LISTED_CANDIDATES))
 	return "; ".join(named)
+
+
+## What to add to a refusal that found nothing on screen, when an open menu has an item saying the
+## words: a menu draws its items rather than holding a control for each, so a click finds none, while
+## a wait for the words finds the item. A wait met on "Leave the hall" was followed by a click on it
+## refused as nothing on screen saying it, with no word of the call that chooses it.
+static func _open_menu_note(root: Node, wanted: String) -> String:
+	var pending: Array[Node] = [root]
+	while not pending.is_empty():
+		var node: Node = pending.pop_back()
+		var menu: PopupMenu = node as PopupMenu
+		if menu != null and menu.visible:
+			for item: int in menu.item_count:
+				var text: String = menu.get_item_text(item)
+				if Says.matches(text, wanted):
+					var owner: Node = menu.get_parent()
+					var named: Node = owner if owner is MenuButton or owner is OptionButton else menu
+					return (
+						(
+							'; the open menu %s has an item saying it, "%s", which a click cannot reach:'
+							+ ' choose it with runtime_input choose, path %s and text "%s"'
+						)
+						% [menu.get_path(), text, named.get_path(), text]
+					)
+		pending.append_array(node.get_children(true))
+	return ""
+
+
+## [param words] on one line and at most sixty characters, for naming a control by what it says.
+static func _shortened(words: String) -> String:
+	var flat: String = words.replace("\n", " ").strip_edges()
+	return flat if flat.length() <= 60 else flat.substr(0, 57) + "..."
+
+
+## The controls in [param nodes], each saying the words exactly and out of a click's reach for the
+## reason [param why] holds at the same place, as the end of a sentence.
+static func _out_of_reach_exactly(nodes: Array[Node], why: Array[String]) -> String:
+	var first: String = "%s, %s" % [nodes[0].get_path(), why[0]]
+	if nodes.size() == 1:
+		return "1 control says exactly that and cannot be clicked: %s" % first
+	return "%d controls say exactly that and cannot be clicked, such as %s" % [nodes.size(), first]

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

@@ -25,7 +25,14 @@ static func said_by(node: Node) -> String:
 		return _label_says(label)
 	if _draws_a_list(node):
 		return "\n".join(lines_said_by(node))
-	return _text_of(node)
+	var own: String = _text_of(node)
+	# A control showing a picture rather than words is named for a player who cannot see it, and that
+	# name is the one the words a caller asks by are meant for: the rail's "Out" tab is a square with
+	# an icon on it, and a click on "Out" found only the words around it.
+	if own.is_empty() and node is Control:
+		var control: Control = node
+		return control.atr(control.accessibility_name).strip_edges()
+	return own
 
 
 ## Every line [param node] draws for a player to read, one to an entry: a label's one line, or each
@@ -139,12 +146,16 @@ static func _text_of(node: Node) -> String:
 	if not text is String:
 		return ""
 	var words: String = text
-	# What somebody typed is drawn as typed, never translated.
+	# What somebody typed is drawn as typed, never translated. An empty field draws its placeholder
+	# instead, which is what a player reads it by: a search field was found by nothing it showed.
 	if node is LineEdit:
 		var field: LineEdit = node
+		if words.is_empty():
+			return field.atr(field.placeholder_text).strip_edges()
 		return masked(field) if field.secret else words.strip_edges()
 	if node is TextEdit:
-		return words.strip_edges()
+		var area: TextEdit = node
+		return (area.atr(area.placeholder_text) if words.is_empty() else words).strip_edges()
 	words = node.atr(words)
 	if node is Label3D:
 		var sign_text: Label3D = node