gdharness 1.1.21 → 1.1.23

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

@@ -52,6 +52,23 @@ static func as_float(value: Variant, fallback: float = 0.0) -> float:
 	if value is String:
 		var text: String = value
 		return text.to_float()
+	if value is Dictionary:
+		var tagged: Dictionary = value
+		if str(tagged.get("_type", "")) == "float":
+			return non_finite(str(tagged.get("value", "")), fallback)
+	return fallback
+
+
+## The float a non-finite tag names, "inf", "-inf" or "nan", or [param fallback] for anything else.
+## JSON has no spelling for these, so the serialiser tags them rather than let them arrive as null.
+static func non_finite(word: String, fallback: float = 0.0) -> float:
+	match word:
+		"inf":
+			return INF
+		"-inf":
+			return -INF
+		"nan":
+			return NAN
 	return fallback
 
 

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

@@ -0,0 +1,229 @@
+@tool
+extends RefCounted
+
+## One scene file opened for a tool, read past the resource cache and written back only once what
+## would be saved has been checked.
+##
+## Every scene tool edits a copy of the file rather than the editor's open scene, so three things
+## the editor does for its own copy have to be done here. Measured on 4.7.2:
+##
+## - [code]load[/code] answers from the resource cache, and a write saves a new PackedScene without
+##   touching the cached one. While anything held the scene (a preload, an exported PackedScene), a
+##   second write started from the cached copy and saved over the first.
+## - [code]instantiate()[/code] without an edit state keeps no record of which nodes came from
+##   another scene, so the pack wrote an inherited scene out as a standalone copy of its base and
+##   froze the root properties of every instanced scene into the instancing one.
+## - [code]pack[/code] keeps only what the scene itself owns, so a property set on a node inside an
+##   instance, a node deleted from one and a node moved out of one were answered as done and were
+##   not in the file.
+
+const PropertyValues = preload("property_values.gd")
+
+var root: Node = null
+var path: String = ""
+var _base_paths: Dictionary = {}
+var _state: SceneState = null
+
+
+## Opens [param scene_path], answering a refusal, or {} with [member root] set.
+##
+## A write is refused while the editor holds unsaved changes to the scene: the file is reloaded
+## into the editor after a write, which discards them without a prompt, and the editor saving its
+## copy later would discard the write instead.
+func open(scene_path: String, for_writing: bool) -> Dictionary:
+	path = scene_path
+	if not FileAccess.file_exists(path):
+		return {"ok": false, "error": "Scene not found: " + path}
+	if for_writing:
+		var held_back: String = unsaved_in_editor(path)
+		if not held_back.is_empty():
+			return {"ok": false, "error": held_back}
+	var packed: PackedScene = (
+		ResourceLoader.load(path, "PackedScene", ResourceLoader.CACHE_MODE_IGNORE) as PackedScene
+	)
+	if packed == null:
+		return {"ok": false, "error": "Failed to load %s as a scene" % path}
+	root = packed.instantiate(PackedScene.GEN_EDIT_STATE_MAIN)
+	if root == null:
+		return {"ok": false, "error": "Failed to instantiate " + path}
+	_state = packed.get_state()
+	var base: SceneState = _state.get_base_scene_state()
+	while base != null:
+		for index: int in base.get_node_count():
+			_base_paths[_relative(str(base.get_node_path(index)))] = true
+		base = base.get_base_scene_state()
+	return {}
+
+
+## Why [param scene_path] cannot be written while the editor has it open, or "".
+static func unsaved_in_editor(scene_path: String) -> String:
+	if not EditorInterface.get_unsaved_scenes().has(scene_path):
+		return ""
+	return (
+		(
+			"%s has unsaved changes in the editor, and writing the file would discard them when the "
+			+ "editor reloads it. Save it first (scene_create op=save) or close it without saving."
+		)
+		% scene_path
+	)
+
+
+## Frees [member root] and answers [param error] as a refusal.
+func refuse(error: String) -> Dictionary:
+	close()
+	return {"ok": false, "error": error}
+
+
+func close() -> void:
+	if root != null:
+		root.free()
+		root = null
+
+
+## The path of [param node] as a tool names it: "." for the root.
+func path_of(node: Node) -> String:
+	return str(root.get_path_to(node))
+
+
+## Why [param node]'s own properties and connections cannot be written, or "". A node inside an
+## instanced scene belongs to that scene's file unless its children were made editable here.
+func foreign(node: Node) -> String:
+	if node == root or node.owner == root:
+		return ""
+	if node.owner != null and root.is_editable_instance(node.owner):
+		return ""
+	var owner_path: String = path_of(node.owner) if node.owner != null else "?"
+	return (
+		(
+			"%s belongs to the scene instanced at %s (%s), and this scene saves nothing about it. Edit "
+			+ "that scene instead."
+		)
+		% [path_of(node), owner_path, node.owner.scene_file_path if node.owner != null else "?"]
+	)
+
+
+## Why [param node] cannot be moved, renamed, copied or deleted, or "": the scene may only
+## restructure nodes it declares itself, not ones its base scene or an instance creates.
+func fixed(node: Node) -> String:
+	if node == root:
+		return "The root of %s cannot be moved, renamed, copied or deleted." % path
+	if node.owner != root:
+		var why: String = foreign(node)
+		if why.is_empty():
+			why = "%s is inside an instanced scene, which creates it again on load." % path_of(node)
+		return why
+	var at: String = path_of(node)
+	if _base_paths.has(at):
+		return (
+			(
+				"%s comes from the scene %s inherits from, which creates it again on load. Edit that "
+				+ "scene instead."
+			)
+			% [at, path]
+		)
+	return ""
+
+
+## Why [param child_name] cannot be given to a child of [param parent], or "". Godot renames a node
+## whose name is taken or holds a character a path cannot, and the next call naming it would then
+## reach another node.
+func unusable_name(parent: Node, child_name: String, moving: Node = null) -> String:
+	if child_name.is_empty():
+		return "A node needs a name."
+	var valid: String = child_name.validate_node_name()
+	if valid != child_name:
+		return (
+			(
+				"%s is not a name a node can have; Godot would save it as %s. The characters "
+				+ '. : @ / " %% cannot be in a node name.'
+			)
+			% [child_name, valid]
+		)
+	var taken: Node = parent.get_node_or_null(NodePath(child_name))
+	if taken != null and taken != moving and taken.get_parent() == parent:
+		return "%s already has a child named %s." % [path_of(parent), child_name]
+	return ""
+
+
+## The names of the properties this scene's own file sets on [param node], whatever their values.
+func set_here(node: Node) -> Dictionary:
+	var names: Dictionary = {}
+	if _state == null:
+		return names
+	var at: String = path_of(node)
+	for index: int in _state.get_node_count():
+		if _relative(str(_state.get_node_path(index))) != at:
+			continue
+		for property: int in _state.get_node_property_count(index):
+			names[str(_state.get_node_property_name(index, property))] = true
+	return names
+
+
+## Whether [param loaded], read off [param saved] (a copy instantiated from the pack), is
+## [param given], held by the node in [member root]. A node is compared by where it sits in each.
+func kept(saved: Node, loaded: Variant, given: Variant) -> bool:
+	if loaded is Node and given is Node:
+		var loaded_node: Node = loaded
+		var given_node: Node = given
+		return str(saved.get_path_to(loaded_node)) == str(root.get_path_to(given_node))
+	return PropertyValues.same(loaded, given)
+
+
+## Packs [member root], has [param check] read the result as the file will hold it, and writes the
+## file only if the check answers "". Frees [member root] either way.
+##
+## The check reads a scene instantiated from the pack, which is what loading the file gives, so
+## anything the pack leaves out (a property with no storage, a node the scene does not own) is seen
+## as missing before the file is touched.
+func write(check: Callable = Callable()) -> Dictionary:
+	var packed: PackedScene = PackedScene.new()
+	var packing: Error = packed.pack(root)
+	if packing != OK:
+		return refuse("Failed to pack %s: %s" % [path, error_string(packing)])
+	if check.is_valid():
+		var saved: Node = packed.instantiate(PackedScene.GEN_EDIT_STATE_MAIN)
+		if saved == null:
+			return refuse("The packed copy of %s did not instantiate, so nothing was written." % path)
+		var missing: String = str(check.call(saved))
+		saved.free()
+		if not missing.is_empty():
+			return refuse("Nothing was written: " + missing)
+	close()
+	return save_packed(packed, path)
+
+
+## Writes [param packed] to [param scene_path], making its directory, and brings the editor up to
+## date with it. Answers a refusal, or {}.
+static func save_packed(packed: PackedScene, scene_path: String) -> Dictionary:
+	var directory: String = scene_path.get_base_dir()
+	if not DirAccess.dir_exists_absolute(directory):
+		var made: Error = DirAccess.make_dir_recursive_absolute(directory)
+		if made != OK:
+			return {"ok": false, "error": "Could not create %s: %s" % [directory, error_string(made)]}
+	var saving: Error = ResourceSaver.save(packed, scene_path)
+	if saving != OK:
+		return {"ok": false, "error": "Failed to save %s: %s" % [scene_path, error_string(saving)]}
+	refresh(scene_path)
+	return {}
+
+
+## Brings the editor up to date with a scene file written under it: the cached copy anything holds,
+## the editor's file list, and the tab showing it, whether current or not.
+static func refresh(scene_path: String) -> void:
+	if ResourceLoader.has_cached(scene_path):
+		var _replaced: Resource = ResourceLoader.load(scene_path, "", ResourceLoader.CACHE_MODE_REPLACE)
+	EditorInterface.get_resource_filesystem().scan()
+	if EditorInterface.get_open_scenes().has(scene_path):
+		EditorInterface.reload_scene_from_path(scene_path)
+
+
+## Whether the editor holds unsaved changes to [param scene_path], for a read to say that the file
+## it answers from is not what the editor shows.
+static func unsaved(scene_path: String) -> bool:
+	return EditorInterface.get_unsaved_scenes().has(scene_path)
+
+
+func _relative(node_path: String) -> String:
+	if node_path == ".":
+		return node_path
+	return node_path.trim_prefix("./")

package/build/godot/addons/gdharness_editor/scene_file.gd.uid

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

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

@@ -53,6 +53,9 @@ const LIST_TYPES: Array[int] = [
 # type it wanted.
 const SERIALISERS: Dictionary = {
 	TYPE_NIL: "_serialize_nil",
+	TYPE_FLOAT: "_serialize_float",
+	TYPE_PACKED_FLOAT32_ARRAY: "_serialize_floats",
+	TYPE_PACKED_FLOAT64_ARRAY: "_serialize_floats",
 	TYPE_VECTOR2: "_serialize_vector2",
 	TYPE_VECTOR2I: "_serialize_vector2i",
 	TYPE_VECTOR3: "_serialize_vector3",
@@ -105,6 +108,8 @@ const BUILDERS: Dictionary = {
 	"Color": "_build_color",
 	"NodePath": "_build_node_path",
 	"PackedByteArray": "_build_bytes",
+	"float": "_build_float",
+	"Dictionary": "_build_dictionary",
 }
 
 # What each tag has to carry before it is built. A tag naming a type whose keys are not there is a
@@ -130,6 +135,8 @@ const REQUIRED: Dictionary = {
 	"Color": [["r", "g", "b"]],
 	"NodePath": [["path"]],
 	"PackedByteArray": [["base64"]],
+	"float": [["value"]],
+	"Dictionary": [["entries"]],
 }
 
 
@@ -145,7 +152,58 @@ func serialize_value(value: Variant) -> Variant:
 	if typeof(value) == TYPE_OBJECT and not is_instance_valid(value):
 		return null
 	var serialiser: String = SERIALISERS.get(typeof(value), "")
-	return call(serialiser, value) if not serialiser.is_empty() else value
+	if serialiser.is_empty():
+		return value
+	var carried: Variant = call(serialiser, value)
+	# The fixed shapes carry their components as bare floats, so an infinite one in a Vector2 is
+	# tagged here; containers reach their members through this function already.
+	return carried if typeof(value) in [TYPE_ARRAY, TYPE_DICTIONARY] else _finite(carried)
+
+
+# [param carried] with every non-finite float in it tagged. JSON has no spelling for infinity or
+# NaN: the engine writes 1e99999 and null, and the server, reading 1e99999 as Infinity, writes it
+# back out as null, so a property holding INF was answered as holding nothing.
+func _finite(carried: Variant) -> Variant:
+	if carried is float:
+		var number: float = carried
+		return _serialize_float(number)
+	if carried is Dictionary:
+		var fields: Dictionary = carried
+		var tagged: Dictionary = {}
+		for key: Variant in fields:
+			tagged[key] = _finite(fields[key])
+		return tagged
+	if carried is Array:
+		var items: Array = carried
+		var tagged_items: Array = []
+		for item: Variant in items:
+			tagged_items.append(_finite(item))
+		return tagged_items
+	return carried
+
+
+func _serialize_float(value: float) -> Variant:
+	if is_finite(value):
+		return value
+	return {"_type": "float", "value": "nan" if is_nan(value) else ("inf" if value > 0 else "-inf")}
+
+
+# A packed float array stays the JSON list it is unless something in it has no JSON spelling.
+func _serialize_floats(value: Variant) -> Variant:
+	var numbers: Array = []
+	if value is PackedFloat32Array:
+		var single: PackedFloat32Array = value
+		numbers = Array(single)
+	else:
+		var double: PackedFloat64Array = value
+		numbers = Array(double)
+	for number: float in numbers:
+		if not is_finite(number):
+			var items: Array = []
+			for each: float in numbers:
+				items.append(_serialize_float(each))
+			return items
+	return value
 
 
 # Rebuilds a Godot value from the shape serialize_value gave it.
@@ -181,9 +239,27 @@ func deserialize_value(value: Variant) -> Variant:
 	var needed: Array = REQUIRED.get(tag, [])
 	if builder.is_empty() or not _carries(fields, needed):
 		return fields
+	if tag == "float" and str(fields["value"]) not in ["inf", "-inf", "nan"]:
+		return fields
+	if tag == "Dictionary" and not pairs(fields["entries"]):
+		return fields
 	return call(builder, fields)
 
 
+## Whether [param entries] is a list of [key, value] pairs, as a Dictionary tag carries them.
+static func pairs(entries: Variant) -> bool:
+	if not entries is Array:
+		return false
+	var listed: Array = entries
+	for entry: Variant in listed:
+		if not entry is Array:
+			return false
+		var pair: Array = entry
+		if pair.size() != 2:
+			return false
+	return true
+
+
 ## Whether two values can be compared without the comparison itself failing.
 ##
 ## GDScript's `==` is not total. An Object against a String is a hard error rather than false, and
@@ -193,16 +269,19 @@ func deserialize_value(value: Variant) -> Variant:
 ## nothing anywhere naming the argument that did it. A wrong argument costs a refusal, never the
 ## session's game.
 ##
-## Only an object is special. Every other pair the engine answers, false where they differ, and
-## refusing those would refuse calls that work: an int against a float is the same number to a
-## caller waiting for 1 on a property holding 1.0.
+## Measured on 4.7.2 over every pair of built-in types: two values of different types compare only
+## as an int against a float, a String against a StringName, or anything against null. Every other
+## pair is that error, a word against a number as much as an object against a word, and so is a bool
+## against an int and a NodePath against a String. An int against a float is kept because it is the
+## same number to a caller waiting for 1 on a property holding 1.0.
 static func comparable(one: Variant, other: Variant) -> bool:
 	var left: int = typeof(one)
 	var right: int = typeof(other)
-	if left != TYPE_OBJECT and right != TYPE_OBJECT:
+	if left == right or left == TYPE_NIL or right == TYPE_NIL:
 		return true
-	# An object compares with another object and with null. Anything else is the error above.
-	return (left == TYPE_OBJECT or left == TYPE_NIL) and (right == TYPE_OBJECT or right == TYPE_NIL)
+	var numbers: Array[int] = [TYPE_INT, TYPE_FLOAT]
+	var texts: Array[int] = [TYPE_STRING, TYPE_STRING_NAME]
+	return (left in numbers and right in numbers) or (left in texts and right in texts)
 
 
 ## Whether [param value] can be given to something declared as [param type] without damage.
@@ -400,7 +479,16 @@ func _serialize_signal(value: Signal) -> Dictionary:
 	return described
 
 
+## A dictionary keyed by text as itself, and any other as its entries. JSON keys are text, so an
+## int or Vector2 key was answered as its text, and a dictionary read and written back had its keys
+## replaced by words: `{1: "a"}` came back as `{"1": "a"}`.
 func _serialize_dictionary(value: Dictionary) -> Dictionary:
+	var texts: bool = value.keys().all(func(key: Variant) -> bool: return key is String or key is StringName)
+	if not texts:
+		var entries: Array = []
+		for key: Variant in value:
+			entries.append([serialize_value(key), serialize_value(value[key])])
+		return {"_type": "Dictionary", "entries": entries}
 	var serialised: Dictionary = {}
 	for key: Variant in value:
 		serialised[str(key)] = serialize_value(value[key])
@@ -621,6 +709,27 @@ func _build_bytes(fields: Dictionary) -> PackedByteArray:
 	return Marshalls.base64_to_raw(str(fields.get("base64", "")))
 
 
+func _build_float(fields: Dictionary) -> float:
+	return Read.as_float(fields)
+
+
+## The entries of a dictionary whose keys are not all text. JSON carries every number as a float,
+## and a dictionary keys 1.0 apart from 1, so a whole-number key is built as an int: the key a
+## game uses far more often, and one JSON cannot tell from the float.
+func _build_dictionary(fields: Dictionary) -> Dictionary:
+	var built: Dictionary = {}
+	var entries: Array = fields["entries"]
+	for entry: Variant in entries:
+		var pair: Array = entry
+		var key: Variant = deserialize_value(pair[0])
+		if key is float:
+			var number: float = key
+			if is_finite(number) and number == floorf(number):
+				key = int(number)
+		built[key] = deserialize_value(pair[1])
+	return built
+
+
 ## One component of a compound value, as the type its constructor wants.
 ##
 ## Their own functions because a constructor refuses a Variant under `unsafe_call_argument`, and

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

@@ -11,6 +11,7 @@ const AnimationTools = preload("tools/animation_tools.gd")
 const PlayTools = preload("tools/play_tools.gd")
 const ClassTools = preload("tools/class_tools.gd")
 const SettingsTools = preload("tools/settings_tools.gd")
+const FilesystemTools = preload("tools/filesystem_tools.gd")
 
 var _editor_plugin: EditorPlugin = null
 
@@ -20,6 +21,7 @@ var _animation_tools: AnimationTools = null
 var _play_tools: PlayTools = null
 var _class_tools: ClassTools = null
 var _settings_tools: SettingsTools = null
+var _filesystem_tools: FilesystemTools = null
 
 var _tool_map: Dictionary = {}
 var _initialized: bool = false
@@ -33,6 +35,7 @@ func set_editor_plugin(plugin: EditorPlugin) -> void:
 	_animation_tools.set_editor_plugin(plugin)
 	_play_tools.set_editor_plugin(plugin)
 	_class_tools.set_editor_plugin(plugin)
+	_filesystem_tools.set_editor_plugin(plugin)
 
 
 func _init_tools() -> void:
@@ -64,6 +67,10 @@ func _init_tools() -> void:
 	_settings_tools.name = "SettingsTools"
 	add_child(_settings_tools)
 
+	_filesystem_tools = FilesystemTools.new()
+	_filesystem_tools.name = "FilesystemTools"
+	add_child(_filesystem_tools)
+
 	_tool_map = {
 		# Scene tools
 		"create_scene": [_scene_tools, "create_scene"],
@@ -78,9 +85,9 @@ func _init_tools() -> void:
 		"connect_signal": [_scene_tools, "connect_signal"],
 		"disconnect_signal": [_scene_tools, "disconnect_signal"],
 		"list_connections": [_scene_tools, "list_connections"],
-		"rescan_filesystem": [_scene_tools, "rescan_filesystem"],
-		"scan_status": [_scene_tools, "scan_status"],
-		"reimport_files": [_scene_tools, "reimport_files"],
+		"rescan_filesystem": [_filesystem_tools, "rescan_filesystem"],
+		"scan_status": [_filesystem_tools, "scan_status"],
+		"reimport_files": [_filesystem_tools, "reimport_files"],
 		"global_classes": [_class_tools, "global_classes"],
 		"reload_script": [_class_tools, "reload_script"],
 		# Settings, for a caller that asked the editor rather than the file on disk