gdharness 1.2.31 → 1.2.32

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

@@ -517,6 +517,20 @@ func _handle_message(json_string: String) -> void:
 			pass
 
 
+## Says [param tool_name] was not run because the editor is scanning or importing, for the server to
+## ask again once that is over. An older server reads it as an ordinary refusal.
+func send_busy(request_id: String, tool_name: String) -> void:
+	_send_message(
+		{
+			"type": "tool_result",
+			"id": request_id,
+			"success": false,
+			"busy": true,
+			"error": "The editor is scanning or importing its files, so %s was not run." % tool_name,
+		}
+	)
+
+
 func send_tool_result(request_id: String, success: bool, result: Variant = null, error: String = "") -> void:
 	var response: Dictionary = {"type": "tool_result", "id": request_id, "success": success}
 

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

@@ -0,0 +1,237 @@
+extends RefCounted
+
+## Scenes and resources read from their files, by the editor's tools and by a headless engine with
+## none connected, so a read answers the same either way.
+##
+## A scene is read off its SceneState rather than instantiated. Instantiating outside the editor
+## runs every script's member initialisers and _init (measured on 4.7.2, with or without -e), so a
+## read with no editor would have run the game's code on every node; the editor gets placeholders
+## and runs none. The state holds everything the file says, and the scenes it instances theirs,
+## without making a node. Loading the file still does what loading does in the game: static
+## initialisers run, and a resource with a script is made with it.
+
+const PropertyValues = preload("property_values.gd")
+const Read = preload("reading.gd")
+const Serialisation = preload("serialisation.gd")
+
+
+## The nodes of [param scene_path] as {name, type, path, children}, with instanceOf 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. [param depth] -1 reads every level.
+static func scene_tree(scene_path: String, depth: int, include_properties: bool) -> Dictionary:
+	if not FileAccess.file_exists(scene_path):
+		return {"ok": false, "error": "Scene not found: " + scene_path}
+	# Loaded without naming the type, so a resource handed in by mistake loads as what it is and the
+	# refusal can say so, where asking for a PackedScene printed the loader's error and a backtrace.
+	var loaded: Resource = ResourceLoader.load(scene_path, "", ResourceLoader.CACHE_MODE_IGNORE)
+	if loaded == null:
+		return {"ok": false, "error": "Failed to load %s as a scene" % scene_path}
+	if not loaded is PackedScene:
+		return {
+			"ok": false,
+			"error":
+			(
+				"%s is a %s, not a scene: resource_edit read reads its properties."
+				% [scene_path, loaded.get_class()]
+			)
+		}
+	var packed: PackedScene = loaded
+	var nodes: Dictionary = {}
+	var refused: String = _lay(packed.get_state(), ".", nodes, [scene_path])
+	if not refused.is_empty():
+		return {"ok": false, "error": refused}
+	if not nodes.has("."):
+		return {"ok": false, "error": "%s holds no nodes" % scene_path}
+	return {"ok": true, "tree": _entry(nodes, ".", include_properties, depth, 0)}
+
+
+## Lays the nodes of [param state] into [param nodes] under [param prefix], keyed by their path
+## from the outermost root, each instanced scene laid where it is instanced and the instancing
+## file's own entries for it applied over it. Answers a refusal, or "".
+##
+## [param within] is the files being laid, outermost first, so a scene that instances one of them
+## is refused rather than laid forever; the engine refuses to load such a scene, so this is only
+## reached through a state built some other way.
+static func _lay(state: SceneState, prefix: String, nodes: Dictionary, within: Array) -> String:
+	var base: SceneState = state.get_base_scene_state()
+	if base != null and not nodes.has(prefix):
+		var refused: String = _lay(base, prefix, nodes, within)
+		if not refused.is_empty():
+			return refused
+	for index: int in state.get_node_count():
+		var path: String = _joined(prefix, str(state.get_node_path(index)))
+		var fresh: bool = not nodes.has(path)
+		if fresh:
+			var instance: PackedScene = state.get_node_instance(index)
+			if instance != null:
+				if within.has(instance.resource_path):
+					return "%s instances %s, which holds it" % [within.back(), instance.resource_path]
+				var refused: String = _lay(
+					instance.get_state(), path, nodes, within + [instance.resource_path]
+				)
+				if not refused.is_empty():
+					return refused
+				if not nodes.has(path):
+					return "%s holds no nodes" % instance.resource_path
+				nodes[path]["instanceOf"] = instance.resource_path
+			elif state.is_node_instance_placeholder(index):
+				nodes[path] = _made("InstancePlaceholder")
+				nodes[path]["instanceOf"] = state.get_node_instance_placeholder(index)
+			elif str(state.get_node_type(index)).is_empty():
+				# An entry for a node of an instance that no longer has it, which the engine skips too.
+				continue
+			else:
+				nodes[path] = _made(str(state.get_node_type(index)))
+		# 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.
+		nodes[path]["name"] = str(state.get_node_name(index))
+		if fresh:
+			# The root of what is laid here is placed by whoever instanced it.
+			if path != prefix:
+				_place(
+					nodes,
+					_joined(prefix, str(state.get_node_path(index, true))),
+					path,
+					state.get_node_index(index)
+				)
+		var held: Dictionary = nodes[path]["properties"]
+		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
+			)
+	return ""
+
+
+static func _made(type: String) -> Dictionary:
+	var children: Array[String] = []
+	return {"name": "", "type": type, "properties": {}, "children": children}
+
+
+## Puts [param path] among [param parent]'s children, at [param at] when the file says where (a node
+## added inside an instance) and last when it does not.
+static func _place(nodes: Dictionary, parent: String, path: String, at: int) -> void:
+	if not nodes.has(parent):
+		return
+	var children: Array[String] = nodes[parent]["children"]
+	if at >= 0 and at < children.size():
+		var _placed: int = children.insert(at, path)
+	else:
+		children.append(path)
+
+
+## [param given], a path as a SceneState gives it ("." or "./Body/Tail"), under [param prefix].
+static func _joined(prefix: String, given: String) -> String:
+	var relative: String = given.trim_prefix("./")
+	if relative == "." or relative.is_empty():
+		return prefix
+	if prefix == ".":
+		return relative
+	return prefix + "/" + relative
+
+
+static func _entry(
+	nodes: Dictionary, path: String, include_properties: bool, depth: int, current_depth: int
+) -> Dictionary:
+	var node: Dictionary = nodes[path]
+	var children: Array[Dictionary] = []
+	var data: Dictionary = {"name": node["name"], "type": node["type"], "path": path, "children": children}
+	# The root's file is the scene being read, so only another node's names a second scene.
+	if path != "." and node.has("instanceOf"):
+		data["instanceOf"] = node["instanceOf"]
+	if include_properties:
+		var given: Dictionary = node["properties"]
+		data["properties"] = _stored(str(node["type"]), given)
+	if depth >= 0 and current_depth >= depth:
+		return data
+	for child: String in node["children"]:
+		children.append(_entry(nodes, child, include_properties, depth, current_depth + 1))
+	return data
+
+
+## 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.
+##
+## 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:
+	var attached: Variant = given.get("script")
+	var script: Script = attached if attached is Script else null
+	var scripted: Dictionary = {}
+	if script != null:
+		for declared: Dictionary in script.get_script_property_list():
+			var property: String = str(declared.get("name", ""))
+			if not property.is_empty() and Read.as_int(declared.get("usage", 0)) & PROPERTY_USAGE_STORAGE:
+				scripted[property] = script.get_property_default_value(property)
+	var values: Dictionary = {}
+	if ClassDB.class_exists(type) and ClassDB.can_instantiate(type):
+		var bare: Object = ClassDB.instantiate(type)
+		for property: Variant in given:
+			if property != "script" and not scripted.has(property):
+				bare.set(str(property), given[property])
+		for declared: Dictionary in bare.get_property_list():
+			var property: String = str(declared.get("name", ""))
+			if not property.is_empty() and Read.as_int(declared.get("usage", 0)) & PROPERTY_USAGE_STORAGE:
+				values[property] = bare.get(property)
+		if bare is Node:
+			bare.free()
+	for property: String in scripted:
+		values[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: Serialisation = Serialisation.new()
+	var answered: Dictionary = {}
+	for property: Variant in values:
+		answered[property] = serialiser.serialize_value(values[property])
+	return answered
+
+
+## What a resource file holds, in the form modify takes, so a value read here can be written back.
+## Read from the file rather than a cached copy, since the file is what the writes change and what
+## the project loads.
+static func resource(res_path: String, include_defaults: bool) -> Dictionary:
+	if not FileAccess.file_exists(res_path):
+		return {"ok": false, "error": "No resource at " + res_path}
+	var loaded: Resource = ResourceLoader.load(res_path, "", ResourceLoader.CACHE_MODE_IGNORE)
+	if loaded == null:
+		return {"ok": false, "error": "%s did not load as a resource." % res_path}
+	# A scene's own properties are its packed bundle, which says nothing a caller can use.
+	if loaded is PackedScene:
+		return {
+			"ok": false,
+			"error":
+			"%s is a scene: scene_tree reads its nodes, and scene_node get one node's properties." % res_path
+		}
+
+	var script: Script = loaded.get_script()
+	var scripted: Dictionary = {}
+	if script != null:
+		for declared: Dictionary in script.get_script_property_list():
+			scripted[str(declared.get("name", ""))] = true
+	var serialiser: Serialisation = Serialisation.new()
+	var properties: Dictionary = {}
+	for p: Dictionary in loaded.get_property_list():
+		var property: String = str(p.get("name", ""))
+		if property.is_empty() or property == "script":
+			continue
+		if not (Read.as_int(p.get("usage", 0)) & PROPERTY_USAGE_STORAGE):
+			continue
+		var value: Variant = loaded.get(property)
+		if not include_defaults:
+			var default: Variant = (
+				script.get_property_default_value(property)
+				if scripted.has(property)
+				else ClassDB.class_get_property_default_value(loaded.get_class(), property)
+			)
+			if PropertyValues.same(value, default):
+				continue
+		properties[property] = serialiser.serialize_value(value)
+	var answer: Dictionary = {
+		"ok": true, "resourcePath": res_path, "resourceType": loaded.get_class(), "properties": properties
+	}
+	if script != null:
+		answer["script"] = script.resource_path
+	return answer

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

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

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

@@ -8,6 +8,17 @@ extends EditorPlugin
 const BridgeClient = preload("bridge_client.gd")
 const ToolExecutor = preload("tool_executor.gd")
 
+## The tools answered while the editor scans or imports, because none of them saves a file: the
+## ones a caller waits on a scan with, and the ones that only read or stop a played game.
+const ANSWERED_WHILE_SCANNING: Array[String] = [
+	"scan_status",
+	"rescan_filesystem",
+	"reimport_files",
+	"playing_status",
+	"stop_playing",
+	"profile_read",
+]
+
 var _client: BridgeClient
 var _tool_executor: ToolExecutor
 var _status_label: Label
@@ -85,10 +96,26 @@ func _on_disconnected() -> void:
 		_status_label.add_theme_color_override("font_color", Color.RED)
 
 
+## Whether [param tool_name] waits for the editor to finish scanning or importing. A save during a
+## scan updates the file list the scan's thread is writing out (see SceneFile.scan_later), and an
+## import can run frames of the editor from inside itself, the one handling this call among them.
+func turned_away(tool_name: String) -> bool:
+	var filesystem: EditorFileSystem = EditorInterface.get_resource_filesystem()
+	return (
+		not ANSWERED_WHILE_SCANNING.has(tool_name) and (filesystem.is_scanning() or filesystem.is_importing())
+	)
+
+
 func _on_tool_requested(request_id: String, tool_name: String, args: Dictionary) -> void:
 	if _tool_executor == null or _client == null:
 		return
 
+	# Turned away rather than held, so the server asks again: a call held here could run after the
+	# server had given up on it.
+	if turned_away(tool_name):
+		_client.send_busy(request_id, tool_name)
+		return
+
 	var result: Dictionary = _tool_executor.execute_tool(tool_name, args)
 	var success: bool = result.get("ok", false)
 

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

@@ -19,6 +19,10 @@ extends RefCounted
 
 const PropertyValues = preload("property_values.gd")
 
+## Whether a scan asked for through [method scan_later] is still to start, which a caller waiting
+## for the editor's files to settle has to wait through as well.
+static var scan_due: bool = false
+
 var root: Node = null
 var path: String = ""
 var _base_paths: Dictionary = {}
@@ -249,11 +253,44 @@ static func save_packed(packed: PackedScene, scene_path: String) -> Dictionary:
 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()
+	scan_later()
 	if EditorInterface.get_open_scenes().has(scene_path):
 		EditorInterface.reload_scene_from_path(scene_path)
 
 
+## Has the editor scan its files once the call in hand has answered, rather than now.
+##
+## A scan's thread ends by writing the editor's file list to its cache, walking the list as it goes,
+## while each save made in the editor updates an entry of that list on the main thread and frees
+## what the entry held (4.7.2's [code]_save_filesystem_cache[/code] and
+## [code]EditorNode::_resource_saved[/code]). A scene saved 250 ms after a resource's scan began was
+## followed by garbage decoded as text and a dropped connection. Started at the end of the frame,
+## the scan begins after every save the call makes, and the plugin turns away calls that could save
+## until it is over.
+static func scan_later() -> void:
+	if scan_due:
+		return
+	scan_due = true
+	_start_scan.call_deferred()
+
+
+## [method EditorFileSystem.scan] does nothing, and says nothing, while the thread of the scan
+## before it is still to be joined, which is a frame or two after that scan stops reporting itself,
+## so a scan that leaves the editor not scanning is asked for once more once that is over. Asked of
+## a scan that ended within the call, the second costs one more scan.
+static func _start_scan() -> void:
+	var filesystem: EditorFileSystem = EditorInterface.get_resource_filesystem()
+	var tree: SceneTree = Engine.get_main_loop()
+	while filesystem.is_scanning() or filesystem.is_importing():
+		await tree.process_frame
+	filesystem.scan()
+	if not filesystem.is_scanning():
+		await tree.process_frame
+		await tree.process_frame
+		filesystem.scan()
+	scan_due = false
+
+
 ## 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:

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

@@ -95,6 +95,7 @@ func _init_tools() -> void:
 		"rescan_filesystem": [_filesystem_tools, "rescan_filesystem"],
 		"scan_status": [_filesystem_tools, "scan_status"],
 		"reimport_files": [_filesystem_tools, "reimport_files"],
+		"files_moved": [_filesystem_tools, "files_moved"],
 		"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

package/build/godot/addons/gdharness_editor/tools/class_tools.gd

@@ -117,9 +117,31 @@ func reload_script(args: Dictionary) -> Dictionary:
 			answer["restoredAs"] = error_string(restored)
 	answer["methods"] = _method_names(script)
 	answer["constants"] = _constant_names(script)
+	_reread_open_tabs(path, answer)
 	return answer
 
 
+## Has the script editor's tabs reread what changed on disk, as the editor does when its window takes
+## the focus, which a hidden editor's never does. A tab with unsaved edits is left alone and named:
+## saving it writes its text over the file, and rereading would ask a question nobody can answer in a
+## hidden editor's dialog.
+func _reread_open_tabs(path: String, answer: Dictionary) -> void:
+	# The engine fixtures reload from a script run outside any editor, where there are no tabs and
+	# EditorInterface has none of its methods.
+	if not Engine.is_editor_hint():
+		return
+	var scripts: ScriptEditor = EditorInterface.get_script_editor()
+	var unsaved: PackedStringArray = scripts.get_unsaved_files()
+	if path in unsaved:
+		answer["unsavedInEditor"] = true
+		return
+	var rereads: Variant = EditorInterface.get_editor_settings().get_setting(
+		"text_editor/behavior/files/auto_reload_scripts_on_external_change"
+	)
+	if unsaved.is_empty() and rereads is bool and rereads:
+		scripts.reload_open_files()
+
+
 ## [param path] as the files on disk spell it, a step at a time, or as given where a step is not
 ## there. On a filesystem that ignores case, `res://Core/Rules.gd` opens the file at
 ## `res://core/rules.gd`, but the editor holds its copy under the spelling on disk, and a load by

package/build/godot/addons/gdharness_editor/tools/filesystem_tools.gd

@@ -1,9 +1,11 @@
 @tool
 extends Node
 
-## The editor's view of the files on disk: scans, the reimports asked for, and where each stands.
+## The editor's view of the files on disk: scans, the reimports asked for, where each stands, and
+## files moved under it.
 
 const Read = preload("../reading.gd")
+const SceneFile = preload("../scene_file.gd")
 
 var _editor_plugin: EditorPlugin = null
 
@@ -170,6 +172,7 @@ func scan_status(_args: Dictionary) -> Dictionary:
 		"ok": true,
 		"scanning": filesystem.is_scanning(),
 		"importing": filesystem.is_importing(),
+		"pending": SceneFile.scan_due,
 		"sinceScanFinishedMs":
 		-1 if _scan_finished_at_msec < 0 else Time.get_ticks_msec() - _scan_finished_at_msec,
 		"reimportsCompleted": _reimports_completed,
@@ -206,6 +209,66 @@ func reimport_files(args: Dictionary) -> Dictionary:
 	}
 
 
+## Brings the editor up to files moved under it, the way its FileSystem dock brings itself up after
+## a move of its own: each cached resource and each open scene named for where it now is, so what
+## holds them saves the new path, the editor's file list told of both ends, and each open scene that
+## moved or that the move rewrote read again from the file. A scene with unsaved edits is left as it
+## is and named, since reading it again would discard them; its root names the new path either way.
+##
+## A moved tab is read again even when its text did not change: the editor keeps each tab's path
+## twice, on the root and in its own list, and a script can set only the first. The second is what
+## [method EditorInterface.get_open_scenes] answers, and reading the scene again is what writes it.
+func files_moved(args: Dictionary) -> Dictionary:
+	var renames: Dictionary[String, String] = {}
+	var given: Variant = args.get("moved", [])
+	if given is Array:
+		var pairs: Array = given
+		for pair: Variant in pairs:
+			if pair is Dictionary:
+				var named: Dictionary = pair
+				renames[str(named.get("from", ""))] = str(named.get("to", ""))
+	for from: String in renames:
+		if ResourceLoader.has_cached(from):
+			var held: Resource = ResourceLoader.get_cached_ref(from)
+			if held != null:
+				held.take_over_path(renames[from])
+	var dirty: Array[String] = []
+	for path: String in EditorInterface.get_unsaved_scenes():
+		dirty.append(renames.get(path, path))
+	var retargeted: Array[String] = []
+	var reread: Array[String] = []
+	for root: Node in EditorInterface.get_open_scene_roots():
+		var path: String = root.scene_file_path
+		if renames.has(path):
+			root.scene_file_path = renames[path]
+			retargeted.append(path)
+			reread.append(renames[path])
+	var filesystem: EditorFileSystem = EditorInterface.get_resource_filesystem()
+	for from: String in renames:
+		filesystem.update_file(from)
+		filesystem.update_file(renames[from])
+	var open: Array[String] = []
+	for root: Node in EditorInterface.get_open_scene_roots():
+		open.append(root.scene_file_path)
+	var changed: Variant = args.get("changed", [])
+	if changed is Array:
+		var paths: Array = changed
+		for path: Variant in paths:
+			if open.has(str(path)) and not reread.has(str(path)):
+				reread.append(str(path))
+	var reloaded: Array[String] = []
+	var unsaved: Array[String] = []
+	for scene: String in reread:
+		if dirty.has(scene):
+			unsaved.append(scene)
+		else:
+			EditorInterface.reload_scene_from_path(scene)
+			reloaded.append(scene)
+	reloaded.sort()
+	unsaved.sort()
+	return {"ok": true, "retargetedTabs": retargeted, "reloadedScenes": reloaded, "unsavedScenes": unsaved}
+
+
 func _reimport(paths: PackedStringArray) -> void:
 	var filesystem: EditorFileSystem = EditorInterface.get_resource_filesystem()
 	# A scan can begin between the answer and this frame, and its import would refuse this one.

package/build/godot/addons/gdharness_editor/tools/resource_tools.gd

@@ -3,10 +3,10 @@ extends Node
 
 ## Resource files, shaders, tilesets and themes, written through the open editor.
 
+const FileReads = preload("../file_reads.gd")
 const PropertyValues = preload("../property_values.gd")
 const Read = preload("../reading.gd")
 const SceneFile = preload("../scene_file.gd")
-const Serialisation = preload("../serialisation.gd")
 
 # The minimal shader of a type: its declaration and the one function the engine calls for it.
 const SHADER_EMPTY: String = """shader_type %s;
@@ -23,7 +23,6 @@ const CELLS_SHOWN: int = 1000
 
 var _editor_plugin: EditorPlugin = null
 var _properties: PropertyValues = PropertyValues.new()
-var _values: Serialisation = Serialisation.new()
 
 
 func set_editor_plugin(plugin: EditorPlugin) -> void:
@@ -48,7 +47,7 @@ func _written(path: String) -> void:
 	if ResourceLoader.has_cached(path):
 		var _replaced: Resource = ResourceLoader.load(path, "", ResourceLoader.CACHE_MODE_REPLACE)
 	if _editor_plugin:
-		EditorInterface.get_resource_filesystem().scan()
+		SceneFile.scan_later()
 
 
 ## Why a tool that creates [param path] must not write there, or "". Saving over a file that was
@@ -239,48 +238,12 @@ func modify_resource(args: Dictionary) -> Dictionary:
 	return {"ok": true, "resourcePath": res_path}
 
 
-## What a resource file holds, in the form modify takes, so a value read here can be written back.
-## Read from the file rather than the editor's cached copy, since the file is what the other ops
-## write and what the project loads.
+## What a resource file holds, read as a headless engine reads it with no editor connected.
 func read_resource(args: Dictionary) -> Dictionary:
 	var res_path: String = _ensure_res_path(str(args.get("resourcePath", "")))
-	var include_defaults: bool = Read.as_bool(args.get("includeDefaults", false))
 	if res_path == "res://":
 		return {"ok": false, "error": "resourcePath is required"}
-	if not FileAccess.file_exists(res_path):
-		return {"ok": false, "error": "No resource at " + res_path}
-	var resource: Resource = ResourceLoader.load(res_path, "", ResourceLoader.CACHE_MODE_IGNORE)
-	if resource == null:
-		return {"ok": false, "error": "%s did not load as a resource." % res_path}
-
-	var script: Script = resource.get_script()
-	var scripted: Dictionary = {}
-	if script != null:
-		for declared: Dictionary in script.get_script_property_list():
-			scripted[str(declared.get("name", ""))] = true
-	var properties: Dictionary = {}
-	for p: Dictionary in resource.get_property_list():
-		var property: String = str(p.get("name", ""))
-		if property.is_empty() or property == "script":
-			continue
-		if not (Read.as_int(p.get("usage", 0)) & PROPERTY_USAGE_STORAGE):
-			continue
-		var value: Variant = resource.get(property)
-		if not include_defaults:
-			var default: Variant = (
-				script.get_property_default_value(property)
-				if scripted.has(property)
-				else ClassDB.class_get_property_default_value(resource.get_class(), property)
-			)
-			if PropertyValues.same(value, default):
-				continue
-		properties[property] = _values.serialize_value(value)
-	var answer: Dictionary = {
-		"ok": true, "resourcePath": res_path, "resourceType": resource.get_class(), "properties": properties
-	}
-	if script != null:
-		answer["script"] = script.resource_path
-	return answer
+	return FileReads.resource(res_path, Read.as_bool(args.get("includeDefaults", false)))
 
 
 func create_shader(args: Dictionary) -> Dictionary: