gdharness 1.0.22 → 1.0.24

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

@@ -6,6 +6,51 @@ extends RefCounted
 
 const Values = preload("runtime_values.gd")
 
+## The calls a path makes on a list or a map: those that take no arguments and change nothing.
+##
+## Named rather than asked of the engine, because asking about a method a list does not have logs an
+## error into the game's output, and a typo in a path is not the game's error. The ones that change
+## what they are called on, such as clear(), sort() and pop_back(), are left out: a path is how a
+## read and a wait reach what they read, and a wait asks many times.
+const LIST_CALLS: Array[String] = [
+	"size",
+	"is_empty",
+	"front",
+	"back",
+	"max",
+	"min",
+	"pick_random",
+	"hash",
+	"duplicate",
+	"duplicate_deep",
+	"is_read_only",
+	"is_typed",
+	"get_typed_builtin",
+	"get_typed_class_name",
+	"get_typed_script",
+]
+const MAP_CALLS: Array[String] = [
+	"size",
+	"is_empty",
+	"keys",
+	"values",
+	"hash",
+	"duplicate",
+	"duplicate_deep",
+	"is_read_only",
+	"is_typed",
+	"is_typed_key",
+	"is_typed_value",
+	"get_typed_key_builtin",
+	"get_typed_key_class_name",
+	"get_typed_key_script",
+	"get_typed_value_builtin",
+	"get_typed_value_class_name",
+	"get_typed_value_script",
+]
+## The calls an empty list has nothing to answer, which the engine reports as an error when asked.
+const NEEDS_AN_ELEMENT: Array[String] = ["front", "back", "pick_random"]
+
 
 ## 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.
@@ -23,7 +68,9 @@ const Values = preload("runtime_values.gd")
 ## and walks into what it returned. Some of what hangs off a node is only reachable by asking:
 ## which control holds the focus is a question for the viewport a control is in, and the viewport
 ## is a method's answer rather than a property. Spelled with the brackets so a reader sees a call
-## where one happens, and so a method can never shadow a property of the same name.
+## where one happens, and so a method can never shadow a property of the same name. A list or a map
+## answers the calls that read it, "board:size()" or "inbox:keys()", listed in [constant LIST_CALLS]
+## and [constant MAP_CALLS].
 ##
 ## 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
@@ -117,9 +164,14 @@ static func nothing_under(holder: Variant, named: String, called: String) -> Str
 static func can_read(holder: Variant, named: String) -> bool:
 	if holder is Array:
 		var items: Array = holder
+		var list_call: String = method_of(named)
+		if not list_call.is_empty():
+			return list_call in LIST_CALLS and not (items.is_empty() and list_call in NEEDS_AN_ELEMENT)
 		return _index_in(named, items.size()) != -1
 	if holder is Dictionary:
 		var map: Dictionary = holder
+		if not method_of(named).is_empty():
+			return method_of(named) in MAP_CALLS
 		return map.has(named) or map.has(StringName(named))
 	if holder is Object:
 		var object: Object = holder
@@ -173,6 +225,8 @@ static func write(holder: Variant, named: String, value: Variant) -> void:
 ## What [param holder] holds under [param named], or answers to it when [param named] is a call.
 ## Only ever called once [method can_read] agrees.
 static func read_under(holder: Variant, named: String) -> Variant:
+	if (holder is Array or holder is Dictionary) and not method_of(named).is_empty():
+		return Callable.create(holder, method_of(named)).call()
 	if holder is Array:
 		var items: Array = holder
 		return items[_index_in(named, items.size())]
@@ -207,10 +261,17 @@ static func _index_in(named: String, size: int) -> int:
 ## so a list says how long it is and a map says what it is keyed by. The step is named rather than
 ## the whole path, because the step is the typo.
 static func nothing_there(holder: Variant, named: String, called_as: String) -> String:
+	var container_call: String = method_of(named)
 	if holder is Array:
 		var items: Array = holder
+		if container_call in NEEDS_AN_ELEMENT and items.is_empty():
+			return "%s is an empty list, so it has no %s" % [called_as, named]
+		if not container_call.is_empty():
+			return container_calls_refused(called_as, "a list", container_call)
 		return "%s is a list of %d, so there is no %s in it" % [called_as, items.size(), named]
 	if holder is Dictionary:
+		if not container_call.is_empty():
+			return container_calls_refused(called_as, "a map", container_call)
 		var map: Dictionary = holder
 		var keys: Array = map.keys()
 		# Eight of them, because a map keyed by something unexpected is told by the first few and a
@@ -242,6 +303,19 @@ static func nothing_there(holder: Variant, named: String, called_as: String) ->
 	return "%s has no property %s" % [called_as, named]
 
 
+## Why [param method] is not a call a path makes on [param sort] ("a list" or "a map"), naming
+## the calls it does make.
+static func container_calls_refused(called_as: String, sort: String, method: String) -> String:
+	var calls: Array[String] = LIST_CALLS if sort == "a list" else MAP_CALLS
+	var spelled: Array[String] = []
+	for each: String in calls:
+		spelled.append(each + "()")
+	return (
+		"%s is %s, and %s() is not one of the calls a path makes on one, which read it and take no arguments: %s"
+		% [called_as, sort, method, ", ".join(spelled)]
+	)
+
+
 ## Whether [param holder] declares [param named]. Asked of the list rather than read, because a
 ## property read back as null answers it wrongly.
 static func _has_property(holder: Object, named: String) -> bool:

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

@@ -629,14 +629,49 @@ func set_property(params: Dictionary) -> Dictionary:
 					% [reached["called"], named, type_string(wanted), type_string(typeof(given))]
 				)
 			}
+		var typed: Dictionary = _values.typed_like(given, old_value, _element_object.bind(node, node_path))
+		if typed.has("message"):
+			return {
+				"type": "error",
+				"message":
+				"%s.%s is a typed %s: %s." % [reached["called"], named, _sort_of(old_value), typed["message"]]
+			}
+		given = typed["value"]
 	Paths.write(holder, named, given)
+	var now: Variant = Paths.read_under(holder, named)
+	# Read back rather than trusted. The engine drops a write it will not take without a word, and
+	# the answer then showed the old value as the new one, shaped as a success: a typed container
+	# refusing a plain list did exactly that. A value the property changed on the way in, a setter
+	# clamping it, still changed it, so only a write that left the property as it was is refused.
+	if (
+		Values.comparable(given, old_value)
+		and given != old_value
+		and Values.comparable(now, old_value)
+		and now == old_value
+	):
+		return {
+			"type": "error",
+			"message":
+			(
+				(
+					"%s.%s was given %s and still holds %s: the engine kept what it had,"
+					+ " which a property it will not write does."
+				)
+				% [
+					reached["called"],
+					named,
+					JSON.stringify(_values.serialize(given)),
+					JSON.stringify(_values.serialize(now))
+				]
+			)
+		}
 
 	return {
 		"type": "property_set",
 		"path": node_path,
 		"property": property,
 		"old_value": _values.serialize(old_value),
-		"new_value": _values.serialize(Paths.read_under(holder, named))
+		"new_value": _values.serialize(now)
 	}
 
 
@@ -660,17 +695,33 @@ func call_method(params: Dictionary) -> Dictionary:
 	if reached.has("message"):
 		return reached
 
-	# A list or a map can be stepped through on the way, and is not a thing with methods when the
-	# path stops on one: said in those terms rather than as "has no method", which reads as a
-	# misspelling of a method that was never going to be there.
+	# A list or a map answers the calls a path makes on one, and nothing else: said in those terms
+	# rather than as "has no method", which reads as a misspelling of a method that was never going
+	# to be there, and with the element spelled out, since a method on what it holds is the usual aim.
 	if not reached["holder"] is Object:
 		var sort: String = "a list" if reached["holder"] is Array else "a map"
+		var spelled: String = str(reached["name"])
+		if Paths.method_of(spelled).is_empty():
+			spelled += "()"
+		if args.is_empty() and Paths.can_read(reached["holder"], spelled):
+			var answered: Variant = Paths.read_under(reached["holder"], spelled)
+			return {
+				"type": "method_result",
+				"path": node_path,
+				"method": method,
+				"result": _values.serialize(answered),
+			}
+		var why: String = (
+			"%s:%s takes no arguments" % [reached["called"], spelled]
+			if Paths.can_read(reached["holder"], spelled)
+			else Paths.nothing_there(reached["holder"], spelled, str(reached["called"]))
+		)
 		return {
 			"type": "error",
 			"message":
 			(
-				"%s is %s, which has no methods: name the element to call it on, as in %s:0:%s"
-				% [reached["called"], sort, reached["called"], reached["name"]]
+				"%s. A method of what %s holds is called on the element, as in %s:0:%s"
+				% [why, sort, reached["called"], reached["name"]]
 			)
 		}
 	var holder: Object = reached["holder"]
@@ -711,6 +762,23 @@ func call_method(params: Dictionary) -> Dictionary:
 					% [reached["called"], named, type_string(wants), index + 1, type_string(typeof(given))]
 				)
 			}
+		# A typed list or map is built as one, since a plain one handed to such a parameter raises
+		# inside the game, which is what every check here exists to stop.
+		var container: Variant = _values.parameter_container(holder, named, index)
+		if container != null:
+			var typed: Dictionary = _values.typed_like(
+				given, container, _element_object.bind(node, node_path)
+			)
+			if typed.has("message"):
+				return {
+					"type": "error",
+					"message":
+					(
+						"%s.%s takes a typed %s as argument %d: %s."
+						% [reached["called"], named, _sort_of(container), index + 1, typed["message"]]
+					)
+				}
+			given = typed["value"]
 		deserialized_args.append(given)
 
 	var result: Variant = holder.callv(named, deserialized_args)
@@ -718,6 +786,17 @@ func call_method(params: Dictionary) -> Dictionary:
 	return {"type": "method_result", "path": node_path, "method": method, "result": _values.serialize(result)}
 
 
+## [method _object_named] with the path first, which is the order [method Values.typed_like] calls
+## an element resolver in.
+func _element_object(given: Variant, declared: String, node: Node, node_path: String) -> Dictionary:
+	return _object_named(node, node_path, given, declared)
+
+
+## "list" or "map", for a refusal about a typed container.
+static func _sort_of(container: Variant) -> String:
+	return "list" if container is Array else "map"
+
+
 ## The object [param given] names for a slot or a parameter declared as [param declared], as
 ## `{"object": ...}`, or `{"message": ...}` saying why it names none that fits.
 ##

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

@@ -163,3 +163,149 @@ static func class_of(object: Object) -> String:
 ## A value from the wire fitted to the type a property or parameter declares.
 func fitted(value: Variant, type: int) -> Variant:
 	return _shared.fitted(value, type)
+
+
+## An empty list or map typed the way argument [param index] of [param method] declares, or null
+## when that argument is not a typed container. What [method typed_like] builds against.
+func parameter_container(object: Object, method: String, index: int) -> Variant:
+	for entry: Dictionary in object.get_method_list():
+		if entry.get("name", "") != method:
+			continue
+		var params: Array = entry.get("args", [])
+		if index < 0 or index >= params.size():
+			return null
+		var parameter: Dictionary = params[index]
+		var hint: int = Read.as_int(parameter.get("hint", 0), 0)
+		var named: String = str(parameter.get("hint_string", ""))
+		if hint == PROPERTY_HINT_ARRAY_TYPE:
+			var element: Dictionary = _element_type(named)
+			if element.is_empty():
+				return null
+			var builtin: int = element["builtin"]
+			var engine_class: StringName = element["class"]
+			return Array([], builtin, engine_class, element["script"])
+		if hint == PROPERTY_HINT_DICTIONARY_TYPE and named.contains(";"):
+			var key: Dictionary = _element_type(named.get_slice(";", 0))
+			var entry_type: Dictionary = _element_type(named.get_slice(";", 1))
+			if key.is_empty() or entry_type.is_empty():
+				return null
+			var key_builtin: int = key["builtin"]
+			var key_class: StringName = key["class"]
+			var value_builtin: int = entry_type["builtin"]
+			var value_class: StringName = entry_type["class"]
+			return Dictionary(
+				{}, key_builtin, key_class, key["script"], value_builtin, value_class, entry_type["script"]
+			)
+		return null
+	return null
+
+
+## The type a container hint names, as `{"builtin", "class", "script"}`, or {} for a name this
+## cannot resolve. A built-in type by its name, an engine class, or a script class by its global
+## name, which a typed container holds as the class it extends and the script itself.
+static func _element_type(named: String) -> Dictionary:
+	for type: int in TYPE_MAX:
+		if type != TYPE_OBJECT and type_string(type) == named:
+			return {"builtin": type, "class": &"", "script": null}
+	if ClassDB.class_exists(named):
+		return {"builtin": TYPE_OBJECT, "class": StringName(named), "script": null}
+	for global: Dictionary in ProjectSettings.get_global_class_list():
+		if str(global.get("class", "")) == named:
+			var script: Script = load(str(global.get("path", "")))
+			if script == null:
+				return {}
+			return {"builtin": TYPE_OBJECT, "class": script.get_instance_base_type(), "script": script}
+	return {}
+
+
+## [param given] rebuilt as the typed list or map [param like] is, as `{"value": ...}`, or
+## `{"message": ...}` naming the element that cannot become what the container holds.
+##
+## A typed container refuses a plain one, and the engine says nothing about it: an Array[int]
+## property written with the list JSON carries kept what it held, and the answer showed the write
+## as done. Each element is fitted the way a single value is, and an object element is named by
+## its path through [param resolve], which is called with the path and the class declared and
+## answers the way an object argument does. Anything that is not a typed container comes back as
+## it was given.
+func typed_like(given: Variant, like: Variant, resolve: Callable) -> Dictionary:
+	if like is Array and given is Array:
+		var template: Array = like
+		if not template.is_typed():
+			return {"value": given}
+		var items: Array = given
+		var built: Array = []
+		for index: int in items.size():
+			var element: Dictionary = _element(
+				items[index],
+				template.get_typed_builtin(),
+				_typed_class(template.get_typed_script(), template.get_typed_class_name()),
+				resolve
+			)
+			if element.has("message"):
+				return {"message": "element %d %s" % [index, element["message"]]}
+			built.append(element["value"])
+		return {
+			"value":
+			Array(
+				built,
+				template.get_typed_builtin(),
+				template.get_typed_class_name(),
+				template.get_typed_script()
+			)
+		}
+	if like is Dictionary and given is Dictionary:
+		var map_like: Dictionary = like
+		if not map_like.is_typed():
+			return {"value": given}
+		var entries: Dictionary = given
+		var rebuilt: Dictionary = {}
+		for key: Variant in entries:
+			var key_fitted: Dictionary = _element(
+				key,
+				map_like.get_typed_key_builtin(),
+				_typed_class(map_like.get_typed_key_script(), map_like.get_typed_key_class_name()),
+				resolve
+			)
+			if key_fitted.has("message"):
+				return {"message": "key %s %s" % [str(key), key_fitted["message"]]}
+			var value_fitted: Dictionary = _element(
+				entries[key],
+				map_like.get_typed_value_builtin(),
+				_typed_class(map_like.get_typed_value_script(), map_like.get_typed_value_class_name()),
+				resolve
+			)
+			if value_fitted.has("message"):
+				return {"message": "the value under %s %s" % [str(key), value_fitted["message"]]}
+			rebuilt[key_fitted["value"]] = value_fitted["value"]
+		return {
+			"value":
+			Dictionary(
+				rebuilt,
+				map_like.get_typed_key_builtin(),
+				map_like.get_typed_key_class_name(),
+				map_like.get_typed_key_script(),
+				map_like.get_typed_value_builtin(),
+				map_like.get_typed_value_class_name(),
+				map_like.get_typed_value_script()
+			)
+		}
+	return {"value": given}
+
+
+## One element fitted to a container's element type, as `{"value"}` or `{"message"}` saying what it
+## was and what goes there. The message is the part after "element N".
+func _element(item: Variant, builtin: int, declared: String, resolve: Callable) -> Dictionary:
+	if builtin == TYPE_NIL:
+		return {"value": item}
+	if builtin == TYPE_OBJECT and item is String:
+		var named: Dictionary = resolve.call(item, declared)
+		if named.has("message"):
+			return {"message": str(named["message"])}
+		return {"value": named["object"]}
+	var fitted_item: Variant = fitted(item, builtin)
+	if not acceptable(fitted_item, builtin):
+		# The value as it was sent rather than its engine type: JSON numbers arrive as floats, so a 7
+		# the caller wrote was named "float".
+		var wanted: String = declared if builtin == TYPE_OBJECT else type_string(builtin)
+		return {"message": "is %s, which cannot become %s" % [JSON.stringify(serialize(item)), wanted]}
+	return {"value": fitted_item}