gdharness 1.3.8 → 1.3.10

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

@@ -16,15 +16,19 @@ const GdhSerialisation = preload("serialisation.gd")
 
 
 ## The nodes of [param scene_path] as {name, type, path, children}, with instanceOf and
-## editableChildren on a node that instances another scene and every stored property when
-## [param include_properties] is set, the file's value or the default where it sets none.
+## editableChildren on a node that instances another scene and its stored properties when
+## [param include_properties] is set, the file's value or the default where it sets none, and on a
+## node another file makes setHere, the properties this file sets on it. Defaults the file leaves
+## alone are counted as defaultsLeftOut rather than listed unless [param include_defaults] is set.
 ## [param depth] -1 reads every level.
-static func scene_tree(scene_path: String, depth: int, include_properties: bool) -> Dictionary:
+static func scene_tree(
+	scene_path: String, depth: int, include_properties: bool, include_defaults: bool
+) -> Dictionary:
 	var laid: Dictionary = _laid(scene_path)
 	if not laid.get("ok", false):
 		return laid
 	var nodes: Dictionary = laid["nodes"]
-	return {"ok": true, "tree": _entry(nodes, ".", include_properties, depth, 0)}
+	return {"ok": true, "tree": _entry(nodes, ".", include_properties, include_defaults, depth, 0)}
 
 
 ## The node at [param node_path] in [param scene_path] as {ok, name, type, properties}, laid as
@@ -119,6 +123,9 @@ static func _laid(scene_path: String) -> Dictionary:
 		return {"ok": false, "error": refused}
 	if not nodes.has("."):
 		return {"ok": false, "error": "%s holds no nodes" % scene_path}
+	var base: SceneState = packed.get_state().get_base_scene_state()
+	if base != null:
+		nodes["."]["inherits"] = base.get_path()
 	return {"ok": true, "nodes": nodes}
 
 
@@ -173,8 +180,13 @@ static func _lay(
 				continue
 			else:
 				nodes[path] = _made(str(state.get_node_type(index)))
+				nodes[path]["madeHere"] = loaded != null
 			if ids[index] >= 0:
 				nodes[path]["uniqueId"] = ids[index]
+			# Laid at the root with no scene handed in is a scene the one being read inherits, and the
+			# deepest is laid first, so this is the file that makes the node.
+			if prefix == "." and loaded == null:
+				nodes[path]["inheritedFrom"] = state.get_path()
 		# The name is the state's even for an entry laid already, since an inherited scene names its
 		# root itself; a root instanced inside another scene is renamed by that scene once laid.
 		if not recovered:
@@ -195,10 +207,15 @@ static func _lay(
 			if not grouped.has(str(group)):
 				grouped.append(str(group))
 		var held: Dictionary = nodes[path]["properties"]
+		# What the file being read sets, kept apart for a node another file makes, whose values read
+		# the same whether this scene changed them or that one gave them.
+		var laid: Dictionary = nodes[path]
+		var set_here: Array = laid.get_or_add("setHere", [])
 		for property: int in state.get_node_property_count(index):
-			held[str(state.get_node_property_name(index, property))] = state.get_node_property_value(
-				index, property
-			)
+			var named: String = str(state.get_node_property_name(index, property))
+			held[named] = state.get_node_property_value(index, property)
+			if loaded != null and not set_here.has(named):
+				set_here.append(named)
 	# Only the scene being read and the scenes it inherits share its root, the owner whose editable
 	# instances a write here sets; a file instanced below makes its own owner's editable.
 	if prefix == ".":
@@ -314,7 +331,12 @@ static func _joined(prefix: String, given: String) -> String:
 
 
 static func _entry(
-	nodes: Dictionary, path: String, include_properties: bool, depth: int, current_depth: int
+	nodes: Dictionary,
+	path: String,
+	include_properties: bool,
+	include_defaults: bool,
+	depth: int,
+	current_depth: int
 ) -> Dictionary:
 	var node: Dictionary = nodes[path]
 	var children: Array[Dictionary] = []
@@ -324,6 +346,12 @@ static func _entry(
 		data["instanceOf"] = node["instanceOf"]
 		if node.has("editableChildren"):
 			data["editableChildren"] = node["editableChildren"]
+	# An inherited scene's file holds only what it changes, so the read says what it inherits and
+	# which nodes come from there, as the editor greys them.
+	if node.has("inherits"):
+		data["inherits"] = node["inherits"]
+	elif node.has("inheritedFrom"):
+		data["inheritedFrom"] = node["inheritedFrom"]
 	var groups: Array[String] = node["groups"]
 	if not groups.is_empty():
 		var sorted: Array[String] = groups.duplicate()
@@ -331,7 +359,21 @@ static func _entry(
 		data["groups"] = sorted
 	if include_properties:
 		var given: Dictionary = node["properties"]
-		data["properties"] = _stored(str(node["type"]), given)
+		var stored: Dictionary = _stored(str(node["type"]), given, include_defaults)
+		data["properties"] = stored["properties"]
+		if stored["left_out"] > 0:
+			data["defaultsLeftOut"] = stored["left_out"]
+		var cells: int = _cell_count(str(node["type"]), given)
+		if cells >= 0:
+			data["cellCount"] = cells
+			data["cellsListedBy"] = (
+				"scene_node get with nodePath %s, which lists them as set_tilemap_cells takes them" % path
+			)
+		if not node.get("madeHere", false):
+			var kept: Array = node.get("setHere", [])
+			var set_here: Array = kept.duplicate()
+			set_here.sort()
+			data["setHere"] = set_here
 	var below: Array[String] = node["children"]
 	# Counted rather than left as an empty list, which reads as a node with no children.
 	if depth >= 0 and current_depth >= depth:
@@ -339,19 +381,56 @@ static func _entry(
 			data["childrenNotListed"] = below.size()
 		return data
 	for child: String in below:
-		children.append(_entry(nodes, child, include_properties, depth, current_depth + 1))
+		children.append(_entry(nodes, child, include_properties, include_defaults, depth, current_depth + 1))
 	return data
 
 
+## How many cells a TileMapLayer or TileMap of [param type] holds under the values [param given], or
+## -1 when it is another node or the file sets none of its cells. The file keeps them as packed bytes,
+## which a read of the tree answered with alone, so a caller decoded the base64 to learn what was
+## painted. Only cells the file sets are counted: an instance's come from its own scene.
+static func _cell_count(type: String, given: Dictionary) -> int:
+	if not ClassDB.class_exists(type) or not ClassDB.can_instantiate(type):
+		return -1
+	var single: bool = ClassDB.is_parent_class(type, "TileMapLayer")
+	if not single and not ClassDB.is_parent_class(type, "TileMap"):
+		return -1
+	var painted: bool = false
+	for property: Variant in given:
+		var named: String = str(property)
+		if named == "tile_map_data" or (named.begins_with("layer_") and named.ends_with("/tile_data")):
+			painted = true
+	if not painted:
+		return -1
+	var bare: Node = ClassDB.instantiate(type)
+	for property: Variant in given:
+		if property != "script":
+			bare.set(str(property), given[property])
+	var count: int = 0
+	if single:
+		count = (bare as TileMapLayer).get_used_cells().size()
+	else:
+		var layered: TileMap = bare as TileMap
+		for layer: int in layered.get_layers_count():
+			count += layered.get_used_cells(layer).size()
+	bare.free()
+	return count
+
+
 ## Every property a node of [param type] stores, with the value [param given] sets or the default,
-## read as a node holding those values would answer them.
+## read as a node holding those values would answer them, as {properties, left_out}.
 ##
 ## The engine's half is read off a bare node of the class with the file's values set on it, which
 ## runs no script: what a node lists depends on its values (a thread group's settings appear only
 ## once it has one) and some setters set others (a Control's anchors preset sets how it grows), so
 ## the class's defaults and the file's entries alone answered neither. The script's half is its
 ## declared defaults under the file's values.
-static func _stored(type: String, given: Dictionary) -> Dictionary:
+##
+## Without [param include_defaults], properties keeps only what the file sets and what differs from
+## a node of the class holding none of its values, and left_out counts the rest. Every Control
+## carries a hundred properties, and ten of them came to 57 KB of defaults around the few values a
+## menu scene set.
+static func _stored(type: String, given: Dictionary, include_defaults: bool) -> Dictionary:
 	var attached: Variant = given.get("script")
 	var script: Script = attached if attached is Script else null
 	var scripted: Dictionary = {}
@@ -361,8 +440,10 @@ static func _stored(type: String, given: Dictionary) -> Dictionary:
 			if not property.is_empty() and GdhRead.as_int(declared.get("usage", 0)) & PROPERTY_USAGE_STORAGE:
 				scripted[property] = script.get_property_default_value(property)
 	var values: Dictionary = {}
+	var defaults: Dictionary = {}
 	if ClassDB.class_exists(type) and ClassDB.can_instantiate(type):
 		var bare: Object = ClassDB.instantiate(type)
+		var plain: Object = ClassDB.instantiate(type)
 		for property: Variant in given:
 			if property != "script" and not scripted.has(property):
 				bare.set(str(property), given[property])
@@ -370,18 +451,30 @@ static func _stored(type: String, given: Dictionary) -> Dictionary:
 			var property: String = str(declared.get("name", ""))
 			if not property.is_empty() and GdhRead.as_int(declared.get("usage", 0)) & PROPERTY_USAGE_STORAGE:
 				values[property] = bare.get(property)
-		if bare is Node:
-			bare.free()
+				defaults[property] = plain.get(property)
+		for made: Object in [bare, plain]:
+			if made is Node:
+				made.free()
 	for property: String in scripted:
 		values[property] = scripted[property]
+		defaults[property] = scripted[property]
 	# Given last, which keeps what a bare node cannot hold: the script itself, and a path to a node
 	# for a property that holds the node once it is in a tree.
 	values.merge(given, true)
 	var serialiser: GdhSerialisation = GdhSerialisation.new()
 	var answered: Dictionary = {}
+	var left_out: int = 0
 	for property: Variant in values:
+		var as_default: bool = (
+			not given.has(property)
+			and defaults.has(property)
+			and GdhSame.same(values[property], defaults[property])
+		)
+		if as_default and not include_defaults:
+			left_out += 1
+			continue
 		answered[property] = serialiser.serialize_value(values[property])
-	return answered
+	return {"properties": answered, "left_out": left_out}
 
 
 ## What a resource file holds, in the form modify takes, so a value read here can be written back.
@@ -394,12 +487,16 @@ static func resource(res_path: String, include_defaults: bool) -> Dictionary:
 	var file: String = res_path.get_slice("::", 0)
 	if not FileAccess.file_exists(file):
 		return {"ok": false, "error": "No resource at " + file}
-	var loaded: Resource = ResourceLoader.load(file, "", ResourceLoader.CACHE_MODE_IGNORE)
-	if loaded == null:
+	var whole: Resource = ResourceLoader.load(file, "", ResourceLoader.CACHE_MODE_IGNORE)
+	if whole == null:
 		return {"ok": false, "error": "%s did not load as a resource." % file}
+	# The file's resource is held until the read is done, since what it keeps can depend on it: a
+	# TileSet that goes unlinks its sources, and an atlas source with no TileSet lists none of its
+	# tiles' physics, navigation or custom data.
+	var loaded: Resource = whole
 	if file != res_path:
 		var id: String = res_path.trim_prefix(file + "::")
-		var inner: Resource = _kept_in(loaded, file, id, {})
+		var inner: Resource = _kept_in(whole, file, id, {})
 		if inner == null:
 			return {"ok": false, "error": "%s keeps no resource with the id %s." % [file, id]}
 		loaded = inner

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

@@ -68,6 +68,18 @@ static func through_script(object: Object, names: Dictionary) -> bool:
 	return false
 
 
+## Whether [param object] still holds [param held] for [param name] once set to [param wanted]
+## because the engine derives it, as it keeps layout_mode at Container under a container: an engine
+## property, so no script code ran for the set, and an editor saves the same.
+static func kept_by_engine(object: Object, name: String, wanted: Variant, held: Variant) -> bool:
+	return (
+		not GdhSame.same(object.get(name), wanted)
+		and GdhSame.same(object.get(name), held)
+		and name != "script"
+		and not through_script(object, {name: true})
+	)
+
+
 ## The stored properties of [param object] that are not in [param names] and no longer hold what
 ## [param before] recorded. One the object did not have before, which a script set on it declares,
 ## counts once it holds anything but its default; one it no longer has went with the old script.
@@ -366,8 +378,14 @@ static func embedded_changes(before: String, after: String, reached_ids: Diction
 ## Compares the file just saved at [param path] with [param before], what it held, and puts back
 ## what a script that is not a tool changed in it: in its embedded resources, which [param values]
 ## reach, and in [param main], its main resource, unless that is null. [param asked] and
-## [param reached_ids] are what the call changed. Saved again through [param resave], which answers
-## an Error, and answers "" or why the file still does not hold what it should.
+## [param reached_ids] are what the call changed, and [param carried] is [method embedded_in] of
+## [param values] taken before the save. Saved again through [param resave], which answers an Error,
+## and answers "" or why the file still does not hold what it should.
+##
+## An id is compared only where the resource holding it after the save held it before. Each headless
+## engine hands out the ids of one sequence, so a resource the call added can be saved under the id
+## the file had kept for one it dropped. Read as one resource, the new third line of a dialogue was
+## taken for the old first one changed by its script, and given the old one's text back.
 static func settle_saved(
 	path: String,
 	before: String,
@@ -375,6 +393,7 @@ static func settle_saved(
 	main: Object,
 	asked: Dictionary,
 	reached_ids: Dictionary,
+	carried: Dictionary,
 	resave: Callable
 ) -> String:
 	for attempt: int in 2:
@@ -383,6 +402,8 @@ static func settle_saved(
 		var embedded: Array[Array] = []
 		for found: Array in embedded_changes(before, after, reached_ids):
 			var holder: Resource = by_id.get(found[0])
+			if not carried.has(found[0]) or (holder != null and not is_same(holder, carried[found[0]])):
+				continue
 			if holder != null and _unchanged(holder, found.slice(1)):
 				continue
 			if found[2] or holder == null or not at_default(holder, str(found[1])):
@@ -458,6 +479,32 @@ static func put_back_value(object: Object, name: String, was_set: bool, held: St
 	return ""
 
 
+## [param refused], a refusal of [param property] on [param object] for not holding what it was given,
+## with why when a headless engine set it through a script that is not a tool. That setter runs here
+## and in the game, and an editor runs none and saves the value given, so a setter clamping stock to
+## 0 refused -5 here and the same call through an editor wrote it.
+static func setter_ran(object: Object, property: String, refused: String) -> String:
+	if Engine.is_editor_hint() or property.is_empty():
+		return refused
+	if not through_script(object, {property.get_slice(":", 0): true}):
+		return refused
+	var attached: Variant = object.get_script()
+	var named: String = "Its script"
+	if attached is Script:
+		var script: Script = attached
+		named = script.resource_path
+	return (
+		(
+			(
+				"%s %s is not a tool script, so its setter ran in the headless engine writing this as it runs "
+				+ "in the game; an editor runs none and would have saved the value given. "
+			)
+			% [refused, named]
+		)
+		+ REMEDY
+	)
+
+
 ## Why [param name] on [param what] cannot be saved as the file held it.
 static func unasked(what: String, name: String, why: String = "") -> String:
 	return (

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

@@ -26,38 +26,109 @@ static func declared_on(target: Object, property: String) -> Dictionary:
 ## start with the name of one holding a resource built into it, then a slash and a key of that
 ## resource: "sources/0/0:0/0/probability" is the probability of tile 0:0 in the atlas source a
 ## TileSet keeps as sources/0. A colon path cannot reach it, since the tile's own name holds colons.
-## A resource kept in a file of its own is not reached, nor, given the file [param home] that
-## [param target] is saved in, one built into another file, since writing it here would leave that
-## file as it was.
+## A list of resources is stepped into by an element's index: "lines/1/text" is the text of the
+## second resource in lines. A resource kept in a file of its own is not reached, nor, given the
+## file [param home] that [param target] is saved in, one built into another file, since writing it
+## here would leave that file as it was.
 static func holder_of(target: Object, key: String, home: String = "") -> Array:
 	var through: Array[Resource] = []
 	var holder: Object = target
 	var name: String = key
 	while declared_on(holder, name).is_empty():
 		var reached: Resource = null
+		var rest: int = -1
 		var at: int = name.find("/")
 		while at > 0:
-			var held: Resource = built_in_at(holder, name.left(at), home)
-			if held != null:
+			var stepped: Array = _stepped(holder, name, at)
+			var held: Resource = stepped[0]
+			if held != null and _built_into(held, home):
 				reached = held
+				rest = GdhRead.as_int(stepped[1])
 				break
 			at = name.find("/", at + 1)
 		if reached == null:
 			break
 		through.append(reached)
 		holder = reached
-		name = name.substr(at + 1)
+		name = name.substr(rest)
 	return [holder, name, through]
 
 
-## The resource [param target] holds under [param property] when it is built into a file, or null;
-## given [param home], only one built into that file or into none yet.
-static func built_in_at(target: Object, property: String, home: String = "") -> Resource:
-	var held: Resource = held_at(target, property)
-	if held == null or not held.is_built_in():
-		return null
+## The resource the part of [param name] before the slash at [param at] reaches on [param target],
+## as [resource, where the rest of [param name] starts], or [null, -1]: the one held under that key,
+## or the element of the list held there that the step after the slash indexes.
+static func _stepped(target: Object, name: String, at: int) -> Array:
+	var head: String = name.left(at)
+	var held: Resource = held_at(target, head)
+	if held != null:
+		return [held, at + 1]
+	var end: int = name.find("/", at + 1)
+	if end < 0 or declared_on(target, head).is_empty():
+		return [null, -1]
+	var index: String = name.substr(at + 1, end - at - 1)
+	var listed: Variant = target.get(head)
+	if not listed is Array or not index.is_valid_int():
+		return [null, -1]
+	var items: Array = listed
+	var place: int = index.to_int()
+	if place < 0 or place >= items.size() or not items[place] is Resource:
+		return [null, -1]
+	return [items[place], end + 1]
+
+
+## The refusal for [param name], which [param target] does not declare, when a step of it indexes a
+## list [param target] holds and names no resource in it; or "".
+static func unlisted(target: Object, name: String) -> String:
+	var at: int = name.find("/")
+	while at > 0:
+		var head: String = name.left(at)
+		var listed: Variant = null if declared_on(target, head).is_empty() else target.get(head)
+		if listed is Array:
+			var items: Array = listed
+			return _unlisted_in(items, "%s.%s" % [class_called(target), head], name, at)
+		at = name.find("/", at + 1)
+	return ""
+
+
+static func _unlisted_in(items: Array, called: String, name: String, at: int) -> String:
+	var head: String = name.left(at)
+	var end: int = name.find("/", at + 1)
+	var index: String = name.substr(at + 1) if end < 0 else name.substr(at + 1, end - at - 1)
+	if items.is_empty():
+		return "%s holds no elements, so %s names none: give %s a whole list first." % [called, name, head]
+	var last: int = items.size() - 1
+	if not index.is_valid_int():
+		return (
+			"%s is a list, so the step after it is the index of one of its elements, from 0 to %d, not %s."
+			% [called, last, index]
+		)
+	var place: int = index.to_int()
+	if place < 0 or place > last:
+		return (
+			"%s holds %d element%s, so %s names none: an index goes from 0 to %d."
+			% [called, items.size(), "" if items.size() == 1 else "s", name, last]
+		)
+	if not items[place] is Resource:
+		return (
+			"%s/%d holds %s, which has no properties to write: give %s a whole list instead."
+			% [head, place, type_string(typeof(items[place])), head]
+		)
+	if end < 0:
+		return (
+			(
+				"%s/%d is an element of %s, which a path does not replace alone: give %s a whole list, or "
+				+ "write a property of the element, as %s/%d/<property>."
+			)
+			% [head, place, called, head, head, place]
+		)
+	return ""
+
+
+static func _built_into(held: Resource, home: String) -> bool:
+	if not held.is_built_in():
+		return false
 	var file: String = held.resource_path.get_slice("::", 0)
-	return held if home.is_empty() or file.is_empty() or file == home else null
+	return home.is_empty() or file.is_empty() or file == home
 
 
 ## The file [param target] is saved in: its scene's for a node, as the nodes of an instance are
@@ -184,9 +255,11 @@ static func class_called(target: Object) -> String:
 static func held_elsewhere(target: Object, name: String, home: String) -> String:
 	var at: int = name.find("/")
 	while at > 0:
-		var head: String = name.left(at)
-		var rest: String = name.substr(at + 1)
-		var held: Resource = held_at(target, head)
+		var stepped: Array = _stepped(target, name, at)
+		var held: Resource = stepped[0]
+		var past: int = GdhRead.as_int(stepped[1])
+		var head: String = "" if held == null else name.left(past - 1)
+		var rest: String = "" if held == null else name.substr(past)
 		var file: String = "" if held == null else held.resource_path.get_slice("::", 0)
 		if held != null and not held.is_built_in():
 			return (