gdharness 1.3.0 → 1.3.1

package/build/godot/operations/dependencies.gd

@@ -1,10 +1,10 @@
 extends RefCounted
 
-const Patterns = preload("patterns.gd")
-const Read = preload("reading.gd")
-const FileWalk = preload("file_walk.gd")
-const Log = preload("logger.gd")
-const ResourceFiles = preload("resource_files.gd")
+const GdhPatterns = preload("patterns.gd")
+const GdhRead = preload("reading.gd")
+const GdhFileWalk = preload("file_walk.gd")
+const GdhLog = preload("logger.gd")
+const GdhResourceFiles = preload("resource_files.gd")
 
 ## What a reverse search reads unless told otherwise: the resource and code files, and the settings
 ## files that name resources, "godot" for project.godot, "cfg" for plugin.cfg and export_presets.cfg,
@@ -21,8 +21,8 @@ const REFERENCE_PATTERNS: Array[String] = [
 	'ext_resource.*path="([^"]+)"',
 ]
 
-var _log: Log
-var _files: FileWalk = FileWalk.new()
+var _log: GdhLog
+var _files: GdhFileWalk = GdhFileWalk.new()
 ## The project's class names and the scripts declaring them, read the first time a script is walked
 ## and kept for the call: walking every resource starts a walk per root, and each reading every
 ## script again made the whole-project answer quadratic in the number of scripts.
@@ -33,7 +33,7 @@ var _classes_read: bool = false
 # Everything one dependency walk carries: the settings it was started with, and the state it
 # accumulates as it recurses. Kept together so the recursion passes one object rather than
 # six positional arguments that have to stay in the same order at every call site.
-class DependencyWalk:
+class GdhDependencyWalk:
 	var max_depth: int
 	var include_built_in: bool
 	var visited: Dictionary = {}
@@ -46,7 +46,7 @@ class DependencyWalk:
 		circular_references = p_circular_references
 
 
-func _init(p_log: Log) -> void:
+func _init(p_log: GdhLog) -> void:
 	_log = p_log
 
 
@@ -54,9 +54,9 @@ func _init(p_log: Log) -> void:
 func get_dependencies(params: Dictionary) -> Dictionary:
 	var resource_path: String = str(params.get("resource_path", ""))
 	# No depth, or a depth of zero or less, means the whole chain; the walk stops at cycles.
-	var depth: int = Read.as_int(params.get("depth", 0))
+	var depth: int = GdhRead.as_int(params.get("depth", 0))
 	var max_depth: int = depth if depth > 0 else 1000
-	var include_built_in: bool = Read.as_bool(params.get("include_builtin", false))
+	var include_built_in: bool = GdhRead.as_bool(params.get("include_builtin", false))
 
 	_log.info(
 		(
@@ -77,7 +77,7 @@ func get_dependencies(params: Dictionary) -> Dictionary:
 		if not FileAccess.file_exists(full_path):
 			return _log.failure("Resource file does not exist: " + full_path)
 
-		var walk: DependencyWalk = DependencyWalk.new(max_depth, include_built_in, circular_references)
+		var walk: GdhDependencyWalk = GdhDependencyWalk.new(max_depth, include_built_in, circular_references)
 		dependencies[full_path] = _analyze_resource(full_path, 0, walk)
 		total_resources = 1
 	else:
@@ -89,7 +89,9 @@ func get_dependencies(params: Dictionary) -> Dictionary:
 		# Each root gets a fresh walk so a cycle is reported from every resource it passes
 		# through, rather than only from whichever one happened to be walked first.
 		for res_path: String in all_resources:
-			var walk: DependencyWalk = DependencyWalk.new(max_depth, include_built_in, circular_references)
+			var walk: GdhDependencyWalk = GdhDependencyWalk.new(
+				max_depth, include_built_in, circular_references
+			)
 			var deps: Array[Dictionary] = _analyze_resource(res_path, 0, walk)
 			if deps.size() > 0:
 				dependencies[res_path] = deps
@@ -136,9 +138,9 @@ func find_resource_usages(params: Dictionary) -> Dictionary:
 	var class_name_declared: String = _declared_class_name(resource_path)
 	var by_class: RegEx = null
 	if not class_name_declared.is_empty():
-		by_class = Patterns.compiled("\\b" + _regex_escaped(class_name_declared) + "\\b")
+		by_class = GdhPatterns.compiled("\\b" + _regex_escaped(class_name_declared) + "\\b")
 	var target: Dictionary = {
-		"path": resource_path, "uid": str(ResourceFiles.uid_of(resource_path).get("uid", ""))
+		"path": resource_path, "uid": str(GdhResourceFiles.uid_of(resource_path).get("uid", ""))
 	}
 
 	var all_files: Array[String] = _usage_files(file_types)
@@ -189,10 +191,12 @@ func find_resource_usages(params: Dictionary) -> Dictionary:
 				kind = _path_reference_kind(line, file_path)
 			else:
 				kind = (
-					"extends" if Patterns.without_annotations(line).begins_with("extends ") else "class_name"
+					"extends"
+					if GdhPatterns.without_annotations(line).begins_with("extends ")
+					else "class_name"
 				)
 			references.append({"line": i + 1, "kind": kind, "text": trimmed})
-			by_kind[kind] = Read.as_int(by_kind.get(kind, 0)) + 1
+			by_kind[kind] = GdhRead.as_int(by_kind.get(kind, 0)) + 1
 			if kind != "doc" and kind != "comment":
 				in_code += 1
 
@@ -229,7 +233,7 @@ func _declared_class_name(path: String) -> String:
 		return ""
 	while not file.eof_reached():
 		# Annotations first, since `@abstract class_name X` is one line and this read it as none.
-		var found: RegExMatch = Patterns.declared_class(Patterns.without_annotations(file.get_line()))
+		var found: RegExMatch = GdhPatterns.declared_class(GdhPatterns.without_annotations(file.get_line()))
 		if found != null:
 			file.close()
 			return found.get_string(1)
@@ -282,14 +286,14 @@ func _names_target(line: String, file_path: String, target: Dictionary) -> bool:
 # The contents of each string literal on [param line], of either quote.
 static func _string_literals(line: String) -> Array[String]:
 	var literals: Array[String] = []
-	for m: RegExMatch in Patterns.compiled(STRING_LITERAL).search_all(line):
+	for m: RegExMatch in GdhPatterns.compiled(STRING_LITERAL).search_all(line):
 		literals.append(m.get_string(1) if not m.get_string(1).is_empty() else m.get_string(2))
 	return literals
 
 
 # [param line] with its strings emptied and its comment taken off: the part a class can be used in.
 static func _code_of(line: String) -> String:
-	var bare: String = Patterns.compiled(STRING_LITERAL).sub(line, '""', true)
+	var bare: String = GdhPatterns.compiled(STRING_LITERAL).sub(line, '""', true)
 	var mark: int = bare.find("#")
 	return bare if mark == -1 else bare.substr(0, mark)
 
@@ -299,13 +303,13 @@ static func _code_of(line: String) -> String:
 static func _code_lines(content: String) -> String:
 	var kept: Array[String] = []
 	for line: String in content.split("\n"):
-		kept.append(Patterns.without_comment(line))
+		kept.append(GdhPatterns.without_comment(line))
 	return "\n".join(kept)
 
 
 # The comment on [param line], strings emptied first so a # inside one does not start it.
 static func _comment_of(line: String) -> String:
-	var bare: String = Patterns.compiled(STRING_LITERAL).sub(line, '""', true)
+	var bare: String = GdhPatterns.compiled(STRING_LITERAL).sub(line, '""', true)
 	var mark: int = bare.find("#")
 	return "" if mark == -1 else bare.substr(mark)
 
@@ -321,7 +325,7 @@ func _path_reference_kind(line: String, file_path: String) -> String:
 			return "export_preset"
 	if file_path.ends_with(".import"):
 		return "import"
-	var trimmed: String = Patterns.without_annotations(line)
+	var trimmed: String = GdhPatterns.without_annotations(line)
 	if trimmed.begins_with("extends "):
 		return "extends"
 	if trimmed.begins_with("[ext_resource"):
@@ -366,7 +370,7 @@ func _count_recursive(deps: Array[Dictionary]) -> int:
 	return count
 
 
-func _analyze_resource(path: String, current_depth: int, walk: DependencyWalk) -> Array[Dictionary]:
+func _analyze_resource(path: String, current_depth: int, walk: GdhDependencyWalk) -> Array[Dictionary]:
 	var deps: Array[Dictionary] = []
 
 	if current_depth >= walk.max_depth:
@@ -385,7 +389,7 @@ func _analyze_resource(path: String, current_depth: int, walk: DependencyWalk) -
 	var remaining: int = walk.max_depth - current_depth
 	if walk.visited.has(path):
 		var cached: Dictionary = walk.visited[path]
-		if Read.as_int(cached["remaining"]) == remaining:
+		if GdhRead.as_int(cached["remaining"]) == remaining:
 			var cached_deps: Array[Dictionary] = cached["deps"]
 			return cached_deps
 
@@ -402,7 +406,7 @@ func _analyze_resource(path: String, current_depth: int, walk: DependencyWalk) -
 			content = _code_lines(content)
 
 		for pattern: String in REFERENCE_PATTERNS:
-			var regex: RegEx = Patterns.compiled(pattern)
+			var regex: RegEx = GdhPatterns.compiled(pattern)
 			for m: RegExMatch in regex.search_all(content):
 				var dep_path: String = _resolved(_referenced_path(m.get_string()), path)
 
@@ -439,7 +443,7 @@ func _depend(
 	dep_path: String,
 	by_class: String,
 	current_depth: int,
-	walk: DependencyWalk
+	walk: GdhDependencyWalk
 ) -> void:
 	if dep_path == path:
 		return
@@ -474,7 +478,7 @@ static func classes_used_in(content: String, classes: Dictionary) -> Array[Strin
 	var used: Array[String] = []
 	if classes.is_empty():
 		return used
-	var word: RegEx = Patterns.compiled("[A-Za-z_][A-Za-z0-9_]*")
+	var word: RegEx = GdhPatterns.compiled("[A-Za-z_][A-Za-z0-9_]*")
 	for line: String in content.split("\n"):
 		for m: RegExMatch in word.search_all(_code_of(line)):
 			var name: String = m.get_string()
@@ -507,6 +511,6 @@ func _referenced_path(matched: String) -> String:
 		expression = 'path="([^"]+)"'
 	else:
 		return matched
-	var inner: RegEx = Patterns.compiled(expression)
+	var inner: RegEx = GdhPatterns.compiled(expression)
 	var inner_match: RegExMatch = inner.search(matched)
 	return inner_match.get_string(1) if inner_match else matched

package/build/godot/operations/editor_tools.gd

@@ -7,10 +7,10 @@ extends RefCounted
 ## made here passes the same checks and answers in the same shape. What the engine does that an
 ## editor does not, running every script, is put back in scene_file.gd and headless_check.gd.
 
-const AnimationTools = preload("../addons/gdharness_editor/tools/animation_tools.gd")
-const ResourceTools = preload("../addons/gdharness_editor/tools/resource_tools.gd")
-const SceneTools = preload("../addons/gdharness_editor/tools/scene_tools.gd")
-const SceneFile = preload("../addons/gdharness_editor/scene_file.gd")
+const GdhAnimationTools = preload("../addons/gdharness_editor/tools/animation_tools.gd")
+const GdhResourceTools = preload("../addons/gdharness_editor/tools/resource_tools.gd")
+const GdhSceneTools = preload("../addons/gdharness_editor/tools/scene_tools.gd")
+const GdhSceneFile = preload("../addons/gdharness_editor/scene_file.gd")
 
 const SCENE_COMMANDS: Array[String] = [
 	"create_scene",
@@ -51,18 +51,18 @@ static func run(params: Dictionary) -> Dictionary:
 	var arguments: Dictionary = given
 	var tools: Node = null
 	if command in SCENE_COMMANDS:
-		tools = SceneTools.new()
+		tools = GdhSceneTools.new()
 	elif command in RESOURCE_COMMANDS:
-		tools = ResourceTools.new()
+		tools = GdhResourceTools.new()
 	elif command in ANIMATION_COMMANDS:
-		tools = AnimationTools.new()
+		tools = GdhAnimationTools.new()
 	else:
 		return {"ok": false, "error": "No editor tool runs headless as " + command}
 	var answer: Variant = tools.call(command, arguments)
 	tools.free()
 	if answer is Dictionary:
 		var answered: Dictionary = answer
-		if not SceneFile.by_path.is_empty():
+		if not GdhSceneFile.by_path.is_empty():
 			answered["namedByPath"] = (
 				(
 					"%s %s named by path rather than by uid. A uid in a file's own header is resolved "
@@ -72,10 +72,10 @@ static func run(params: Dictionary) -> Dictionary:
 					+ "it name %s by uid."
 				)
 				% [
-					", ".join(SceneFile.by_path),
-					"is" if SceneFile.by_path.size() == 1 else "are",
-					"it" if SceneFile.by_path.size() == 1 else "them",
-					"it" if SceneFile.by_path.size() == 1 else "them",
+					", ".join(GdhSceneFile.by_path),
+					"is" if GdhSceneFile.by_path.size() == 1 else "are",
+					"it" if GdhSceneFile.by_path.size() == 1 else "them",
+					"it" if GdhSceneFile.by_path.size() == 1 else "them",
 				]
 			)
 		return answered

package/build/godot/operations/export_presets.gd

@@ -2,8 +2,8 @@ extends RefCounted
 
 ## export_presets.cfg, read and written in the format the editor's Project > Export saves it in.
 
-const Read = preload("reading.gd")
-const Log = preload("logger.gd")
+const GdhRead = preload("reading.gd")
+const GdhLog = preload("logger.gd")
 
 const PRESETS_FILE: String = "res://export_presets.cfg"
 ## Where the editor names the one preset of each platform it runs on a device.
@@ -19,10 +19,10 @@ const PLATFORMS: Dictionary[String, String] = {
 	"Web": "web_",
 }
 
-var _log: Log
+var _log: GdhLog
 
 
-func _init(p_log: Log) -> void:
+func _init(p_log: GdhLog) -> void:
 	_log = p_log
 
 
@@ -88,7 +88,7 @@ static func _runnable(config: ConfigFile, section: String) -> bool:
 	var platform: String = str(config.get_value(section, "platform", ""))
 	if config.has_section_key(RUNNABLE_SECTION, platform):
 		return str(config.get_value(RUNNABLE_SECTION, platform)) == str(config.get_value(section, "name", ""))
-	return Read.as_bool(config.get_value(section, "runnable", false))
+	return GdhRead.as_bool(config.get_value(section, "runnable", false))
 
 
 ## Adds an export preset to export_presets.cfg, written with the keys the editor's Project > Export
@@ -188,9 +188,11 @@ func add_export_preset(params: Dictionary) -> Dictionary:
 ## self-contained one, otherwise in the user's data directory, as the editor's own paths have it.
 static func _templates_dir() -> String:
 	var version: Dictionary = Engine.get_version_info()
-	var named: String = "%d.%d" % [Read.as_int(version.get("major", 0)), Read.as_int(version.get("minor", 0))]
-	if Read.as_int(version.get("patch", 0)) != 0:
-		named += "." + str(Read.as_int(version.get("patch", 0)))
+	var named: String = (
+		"%d.%d" % [GdhRead.as_int(version.get("major", 0)), GdhRead.as_int(version.get("minor", 0))]
+	)
+	if GdhRead.as_int(version.get("patch", 0)) != 0:
+		named += "." + str(GdhRead.as_int(version.get("patch", 0)))
 	named += "." + str(version.get("status", ""))
 	if ClassDB.class_exists("CSharpScript"):
 		named += ".mono"

package/build/godot/operations/file_reads.gd

@@ -10,9 +10,9 @@ extends RefCounted
 ## 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")
+const GdhPropertyValues = preload("property_values.gd")
+const GdhRead = preload("reading.gd")
+const GdhSerialisation = preload("serialisation.gd")
 
 
 ## The nodes of [param scene_path] as {name, type, path, children}, with instanceOf and
@@ -42,13 +42,43 @@ static func scene_node(scene_path: String, node_path: String) -> Dictionary:
 	return {"ok": true, "name": found["name"], "type": found["type"], "properties": found["properties"]}
 
 
-## [param said], the refusal for [param node_path], which [param scene_path] does not have, with
-## where the path leaves the scene as [method Read.missing_below] says it.
-static func missing_from(said: String, scene_path: String, node_path: String) -> String:
+## The node at [param node_path] in [param scene_path] as [method scene_node] answers it, when it is
+## a [param kind]; otherwise a refusal saying what the scene has there and where its nodes of that
+## kind are, so the caller has the path to pass. The file is read once, because every load prints
+## the engine's warnings about it again.
+static func scene_node_of_kind(scene_path: String, node_path: String, kind: String) -> Dictionary:
 	var laid: Dictionary = _laid(scene_path)
 	if not laid.get("ok", false):
-		return said
+		return laid
 	var nodes: Dictionary = laid["nodes"]
+	var path: String = _joined(".", node_path)
+	var said: String = "%s not found at: %s" % [kind, node_path]
+	var found: String = ""
+	if nodes.has(path):
+		found = str(nodes[path]["type"])
+		if ClassDB.class_exists(found) and ClassDB.is_parent_class(found, kind):
+			return {
+				"ok": true,
+				"name": nodes[path]["name"],
+				"type": found,
+				"properties": nodes[path]["properties"]
+			}
+	else:
+		var hinted: String = said
+		if not nodes.has(_joined(".", node_path.get_slice("/", 0))):
+			hinted = GdhRead.from_the_root(said, node_path, str(nodes["."]["name"]))
+		said = hinted if hinted != said else _missing_in(nodes, said, node_path)
+	var held: PackedStringArray = []
+	for at: Variant in nodes:
+		var type: String = str(nodes[at]["type"])
+		if ClassDB.class_exists(type) and ClassDB.is_parent_class(type, kind):
+			var _held: bool = held.append(str(at))
+	return {"ok": false, "error": GdhRead.not_of_kind(said, node_path, found, kind, held)}
+
+
+## [param said], the refusal for [param node_path], which the scene laid as [param nodes] does not
+## have, with where the path leaves the scene as [method GdhRead.missing_below] says it.
+static func _missing_in(nodes: Dictionary, said: String, node_path: String) -> String:
 	var parts: PackedStringArray = node_path.trim_prefix("./").split("/", false)
 	var at: String = "."
 	var reached: PackedStringArray = []
@@ -64,7 +94,7 @@ static func missing_from(said: String, scene_path: String, node_path: String) ->
 	var children: Array[String] = nodes[at]["children"]
 	for child: String in children:
 		var _named: bool = names.append(str(nodes[child]["name"]))
-	return Read.missing_below(said, str(nodes["."]["name"]), reached, parts[reached.size()], names)
+	return GdhRead.missing_below(said, str(nodes["."]["name"]), reached, parts[reached.size()], names)
 
 
 ## Every node of [param scene_path] as {ok, nodes}, keyed by path, or a refusal.
@@ -77,15 +107,14 @@ static func _laid(scene_path: String) -> Dictionary:
 	if loaded == null:
 		return {"ok": false, "error": "Failed to load %s as a scene" % scene_path}
 	if not loaded is PackedScene:
-		var kind: String = loaded.get_class()
-		var sort: String = ("an " if kind.left(1).to_upper() in ["A", "E", "I", "O", "U"] else "a ") + kind
+		var sort: String = GdhRead.with_article(loaded.get_class())
 		return {
 			"ok": false,
 			"error": "%s is %s, not a scene: resource_edit read reads its properties." % [scene_path, sort]
 		}
 	var packed: PackedScene = loaded
 	var nodes: Dictionary = {}
-	var refused: String = _lay(packed.get_state(), ".", nodes, [scene_path])
+	var refused: String = _lay(packed.get_state(), ".", nodes, [scene_path], packed)
 	if not refused.is_empty():
 		return {"ok": false, "error": refused}
 	if not nodes.has("."):
@@ -99,8 +128,11 @@ static func _laid(scene_path: String) -> Dictionary:
 ##
 ## [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:
+## reached through a state built some other way. [param loaded] is the scene [param state] is read
+## from, when the caller has it loaded already.
+static func _lay(
+	state: SceneState, prefix: String, nodes: Dictionary, within: Array, loaded: PackedScene = null
+) -> 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)
@@ -164,7 +196,7 @@ static func _lay(state: SceneState, prefix: String, nodes: Dictionary, within: A
 	# 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 == ".":
-		for editable: String in _editable_in(state.get_path()):
+		for editable: String in _editable_in(state.get_path(), loaded):
 			var at: String = _joined(prefix, editable)
 			var marked: Dictionary = nodes.get(at, {})
 			if marked.has("editableChildren"):
@@ -173,10 +205,13 @@ static func _lay(state: SceneState, prefix: String, nodes: Dictionary, within: A
 
 
 ## The paths of the instances [param scene_path] gives editable children, from its root. SceneState
-## does not give them to a script, so they are read off the scene's bundle.
-static func _editable_in(scene_path: String) -> PackedStringArray:
+## does not give them to a script, so they are read off the scene's bundle: [param given_scene]'s,
+## when the caller has the file loaded, since loading it again prints its warnings again.
+static func _editable_in(scene_path: String, given_scene: PackedScene = null) -> PackedStringArray:
 	var found: PackedStringArray = []
-	var loaded: Resource = ResourceLoader.load(scene_path, "", ResourceLoader.CACHE_MODE_IGNORE)
+	var loaded: Resource = given_scene
+	if loaded == null:
+		loaded = ResourceLoader.load(scene_path, "", ResourceLoader.CACHE_MODE_IGNORE)
 	if not loaded is PackedScene:
 		return found
 	var given: Variant = loaded.get("_bundled")
@@ -236,7 +271,7 @@ static func _by_id(nodes: Dictionary, owner: String, id: int) -> String:
 		if path == owner or not (owner == "." or path.begins_with(owner + "/")):
 			continue
 		var entry: Dictionary = nodes[path]
-		if Read.as_int(entry.get("uniqueId", -1), -1) != id:
+		if GdhRead.as_int(entry.get("uniqueId", -1), -1) != id:
 			continue
 		var above: String = "." if not path.contains("/") else path.get_base_dir()
 		if _owner_of(nodes, above, owner) == owner:
@@ -311,7 +346,7 @@ static func _stored(type: String, given: Dictionary) -> 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:
+			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 = {}
 	if ClassDB.class_exists(type) and ClassDB.can_instantiate(type):
@@ -321,7 +356,7 @@ static func _stored(type: String, given: Dictionary) -> Dictionary:
 				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:
+			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()
@@ -330,7 +365,7 @@ static func _stored(type: String, given: Dictionary) -> Dictionary:
 	# 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 serialiser: GdhSerialisation = GdhSerialisation.new()
 	var answered: Dictionary = {}
 	for property: Variant in values:
 		answered[property] = serialiser.serialize_value(values[property])
@@ -369,13 +404,13 @@ static func resource(res_path: String, include_defaults: bool) -> 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 serialiser: GdhSerialisation = GdhSerialisation.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):
+		if not (GdhRead.as_int(p.get("usage", 0)) & PROPERTY_USAGE_STORAGE):
 			continue
 		var value: Variant = loaded.get(property)
 		if not include_defaults:
@@ -384,7 +419,7 @@ static func resource(res_path: String, include_defaults: bool) -> Dictionary:
 				if scripted.has(property)
 				else ClassDB.class_get_property_default_value(loaded.get_class(), property)
 			)
-			if PropertyValues.same(value, default):
+			if GdhPropertyValues.same(value, default):
 				continue
 		properties[property] = serialiser.serialize_value(value)
 	var answer: Dictionary = {
@@ -412,7 +447,7 @@ static func _kept_in(value: Variant, file: String, id: String, seen: Dictionary)
 		if held.resource_scene_unique_id == id:
 			return held
 		for p: Dictionary in held.get_property_list():
-			if Read.as_int(p.get("usage", 0)) & PROPERTY_USAGE_STORAGE:
+			if GdhRead.as_int(p.get("usage", 0)) & PROPERTY_USAGE_STORAGE:
 				var found: Resource = _kept_in(held.get(str(p.get("name", ""))), file, id, seen)
 				if found != null:
 					return found

package/build/godot/operations/gdscript_analysis.gd

@@ -1,16 +1,16 @@
 extends RefCounted
 
-const Dependencies = preload("dependencies.gd")
-const Patterns = preload("patterns.gd")
-const Read = preload("reading.gd")
-const Log = preload("logger.gd")
+const GdhDependencies = preload("dependencies.gd")
+const GdhPatterns = preload("patterns.gd")
+const GdhRead = preload("reading.gd")
+const GdhLog = preload("logger.gd")
 
-var _log: Log
+var _log: GdhLog
 ## Kept for the call, so the project's class names are read once however many bases are walked.
-var _dependencies: Dependencies = null
+var _dependencies: GdhDependencies = null
 
 
-func _init(p_log: Log) -> void:
+func _init(p_log: GdhLog) -> void:
 	_log = p_log
 
 
@@ -62,7 +62,7 @@ func get_gdscript_info(params: Dictionary) -> Dictionary:
 			if _triple_quotes(raw) % 2 == 1:
 				in_multiline_string = false
 			continue
-		var stripped: String = Patterns.without_comment(raw)
+		var stripped: String = GdhPatterns.without_comment(raw)
 
 		if stripped.is_empty():
 			continue
@@ -85,7 +85,7 @@ func get_gdscript_info(params: Dictionary) -> Dictionary:
 		# on the line with them off. `@abstract class_name X` was reported as no declared class,
 		# and `@abstract func x()` and `@warning_ignore("...") func x()` as no function at all:
 		# gdUnit4 alone declares 248 methods that way and this answered with none of them.
-		var header: String = Patterns.without_annotations(stripped)
+		var header: String = GdhPatterns.without_annotations(stripped)
 
 		var at: int = i
 		# A declaration wrapped across lines is one declaration, and reading the first line alone
@@ -104,9 +104,9 @@ func get_gdscript_info(params: Dictionary) -> Dictionary:
 		if _can_wrap(header):
 			while _bracket_depth(stripped) > 0 and i + 1 < lines.size():
 				i += 1
-				stripped = (stripped + " " + Patterns.without_comment(lines[i])).strip_edges()
-			header = Patterns.without_annotations(stripped)
-		var declaration: RegExMatch = Patterns.declared_class(header)
+				stripped = (stripped + " " + GdhPatterns.without_comment(lines[i])).strip_edges()
+			header = GdhPatterns.without_annotations(stripped)
+		var declaration: RegExMatch = GdhPatterns.declared_class(header)
 		if declaration != null:
 			declared_class_name = declaration.get_string(1)
 			# `class_name X extends Y` is also one line, and taking the rest of it as the name
@@ -144,9 +144,9 @@ func get_gdscript_info(params: Dictionary) -> Dictionary:
 	# named it. The same reading as that tool's, so the two agree.
 	var classes_used: Array[Dictionary] = []
 	if _dependencies == null:
-		_dependencies = Dependencies.new(_log)
+		_dependencies = GdhDependencies.new(_log)
 	var declared_by: Dictionary = _dependencies.classes_declared()
-	for used: String in Dependencies.classes_used_in(content, declared_by):
+	for used: String in GdhDependencies.classes_used_in(content, declared_by):
 		var declaring: String = str(declared_by[used])
 		if declaring == full_script_path:
 			continue
@@ -165,7 +165,7 @@ func get_gdscript_info(params: Dictionary) -> Dictionary:
 		if value.begins_with("*"):
 			global_autoloads[setting.trim_prefix("autoload/")] = value.trim_prefix("*")
 	var autoloads_used: Array[Dictionary] = []
-	for used: String in Dependencies.classes_used_in(content, global_autoloads):
+	for used: String in GdhDependencies.classes_used_in(content, global_autoloads):
 		if str(global_autoloads[used]) != full_script_path:
 			autoloads_used.append({"name": used, "path": str(global_autoloads[used])})
 
@@ -185,7 +185,7 @@ func get_gdscript_info(params: Dictionary) -> Dictionary:
 		"autoloads_used": autoloads_used,
 		"line_count": lines.size()
 	}
-	if Read.as_bool(params.get("include_inherited", false)):
+	if GdhRead.as_bool(params.get("include_inherited", false)):
 		_add_inherited(answer, [full_script_path])
 	return answer
 
@@ -202,7 +202,7 @@ func _mark_virtuals(functions: Array[Dictionary], extends_name: String, from_pat
 	var virtuals: Dictionary = {}
 	if not native.is_empty():
 		for m: Dictionary in ClassDB.class_get_method_list(native, false):
-			var flags: int = Read.as_int(m.get("flags", 0))
+			var flags: int = GdhRead.as_int(m.get("flags", 0))
 			if flags & METHOD_FLAG_VIRTUAL:
 				virtuals[str(m.get("name", ""))] = true
 	for one: Dictionary in functions:
@@ -366,7 +366,7 @@ func _parse_variable(line: String, line_num: int) -> Dictionary:
 
 	# From the annotations themselves rather than from where they sit. `@onready @export var x` put
 	# the export second and so read as not exported, and a hint with a space in it was cut at it.
-	for one: String in Patterns.annotations_on(line):
+	for one: String in GdhPatterns.annotations_on(line):
 		if one.begins_with("export"):
 			is_export = true
 			var after: String = one.substr(6)
@@ -457,7 +457,7 @@ func _parse_function(line: String, line_num: int, annotated: String = "") -> Dic
 		"is_static": is_static,
 		# Said rather than left to be inferred: an abstract method has no body, so a caller that
 		# saw only the declaration would otherwise take it for one whose body it failed to read.
-		"is_abstract": "abstract" in Patterns.annotations_on(annotated),
+		"is_abstract": "abstract" in GdhPatterns.annotations_on(annotated),
 		"line": line_num
 	}
 
@@ -624,7 +624,7 @@ static func _triple_quotes(line: String) -> int:
 
 func _extract_dependencies(line: String) -> Array[String]:
 	var deps: Array[String] = []
-	var regex: RegEx = Patterns.compiled("(?:preload|load)\\s*\\(\\s*[\"']([^\"']+)[\"']\\s*\\)")
+	var regex: RegEx = GdhPatterns.compiled("(?:preload|load)\\s*\\(\\s*[\"']([^\"']+)[\"']\\s*\\)")
 
 	for m: RegExMatch in regex.search_all(line):
 		deps.append(m.get_string(1))