gdharness 1.3.0 → 1.3.2

package/build/godot/operations/declared_values.gd

@@ -0,0 +1,116 @@
+@tool
+extends RefCounted
+
+## What a property declares beyond its type: the values of its enum and the range it is exported
+## with, for taking a value by name and for saying when a value written lies outside them.
+
+const GdhRead = preload("reading.gd")
+
+
+## The values an enum hint names, by name, from its hint string: "SWORD:0,SHIELD:1" as a script
+## declares one, or "Add,Subtract" as an engine property does, each name then taking the number
+## after the one before it.
+static func enum_values(hint_string: String) -> Dictionary:
+	var values: Dictionary = {}
+	var next: int = 0
+	for entry: String in hint_string.split(",", false):
+		var name: String = entry.get_slice(":", 0).strip_edges()
+		var number: String = entry.get_slice(":", 1).strip_edges() if ":" in entry else ""
+		var value: int = number.to_int() if number.is_valid_int() else next
+		values[name] = value
+		next = value + 1
+	return values
+
+
+## The values of the enum [param declared] declares, by name, spelt as the script of [param target]
+## spells them when it declares that enum. The engine's hint capitalises each name, "SWORD" as
+## "Sword", and a refusal listing those named values the script never spells.
+static func enum_of(target: Object, declared: Dictionary) -> Dictionary:
+	var hinted: Dictionary = enum_values(str(declared.get("hint_string", "")))
+	var attached: Variant = target.get_script()
+	if not attached is Script:
+		return hinted
+	var script: Script = attached
+	for constant: Variant in script.get_script_constant_map().values():
+		if not constant is Dictionary:
+			continue
+		var values: Dictionary = constant
+		if values.size() != hinted.size():
+			continue
+		var spelt: Dictionary = {}
+		for name: Variant in values:
+			if hinted.get(str(name).capitalize()) == values[name]:
+				spelt[str(name)] = values[name]
+		if spelt.size() == hinted.size():
+			return spelt
+	return hinted
+
+
+## The number [param word] names among [param choices], matched as written and then ignoring case,
+## or null when it names none.
+static func enum_named(choices: Dictionary, word: String) -> Variant:
+	var wanted: String = word.strip_edges()
+	if choices.has(wanted):
+		return choices[wanted]
+	for name: String in choices:
+		if name.to_lower() == wanted.to_lower():
+			return choices[name]
+	return null
+
+
+static func enum_refusal(holder: String, property: String, word: String, choices: Dictionary) -> String:
+	var said: String = (
+		"%s.%s is an enum, and %s is none of its values: send %s by name or by number"
+		% [holder, property, word, _listed(choices)]
+	)
+	var close: PackedStringArray = GdhRead.nearest(word, PackedStringArray(choices.keys()))
+	if close.is_empty():
+		return said + "."
+	return said + ". The nearest %s %s." % ["is" if close.size() == 1 else "are", ", ".join(close)]
+
+
+## Why [param value], shown as [param shown], lies outside what [param declared] allows, an export
+## range or an enum's values, or "" when it does not. A range marked or_greater or or_less is open
+## on that side.
+static func outside(target: Object, declared: Dictionary, value: Variant, shown: String) -> String:
+	var hint: int = GdhRead.as_int(declared.get("hint", PROPERTY_HINT_NONE))
+	var hint_string: String = str(declared.get("hint_string", ""))
+	var property: String = str(declared.get("name", ""))
+	if typeof(value) != TYPE_INT and typeof(value) != TYPE_FLOAT:
+		return ""
+	var number: float = GdhRead.as_float(value)
+	if hint == PROPERTY_HINT_ENUM and typeof(value) == TYPE_INT:
+		var choices: Dictionary = enum_of(target, declared)
+		if choices.is_empty() or choices.values().has(value):
+			return ""
+		return "%d is none of the values %s declares: %s." % [value, property, _listed(choices)]
+	if hint != PROPERTY_HINT_RANGE:
+		return ""
+	var parts: PackedStringArray = []
+	for part: String in hint_string.split(","):
+		var _added: bool = parts.append(part.strip_edges())
+	if parts.size() < 2 or not parts[0].is_valid_float() or not parts[1].is_valid_float():
+		return ""
+	var low: float = parts[0].to_float()
+	var high: float = parts[1].to_float()
+	if (number <= high or parts.has("or_greater")) and (number >= low or parts.has("or_less")):
+		return ""
+	return (
+		(
+			"%s is outside the range %s declares, %s to %s, which the inspector holds it to; the "
+			+ "engine stores it as given."
+		)
+		% [shown, property, _bound(low), _bound(high)]
+	)
+
+
+static func _listed(choices: Dictionary) -> String:
+	var listed: PackedStringArray = []
+	for name: String in choices:
+		var _added: bool = listed.append("%s (%d)" % [name, choices[name]])
+	return ", ".join(listed)
+
+
+## A range's end as the script wrote it: the engine's hint gives @export_range(0, 10) as 0.0 and 10.0.
+static func _bound(end: float) -> String:
+	return str(int(end)) if end == floorf(end) and absf(end) < 1e15 else str(end)

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(
 		(
@@ -75,9 +75,11 @@ func get_dependencies(params: Dictionary) -> Dictionary:
 			full_path = "res://" + full_path
 
 		if not FileAccess.file_exists(full_path):
-			return _log.failure("Resource file does not exist: " + full_path)
+			return _log.failure(
+				_files.with_nearest_files("Resource file does not exist: " + full_path, 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 +91,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
@@ -98,12 +102,19 @@ func get_dependencies(params: Dictionary) -> Dictionary:
 
 	var references: int = 0
 	var distinct: Dictionary = {}
+	var missing: Dictionary = {}
 	for key: String in dependencies:
 		# Through a typed local: what comes out of a Dictionary is Variant, and a project that
 		# errors on handing one to a typed parameter will not compile this script at all.
 		var walked: Array[Dictionary] = dependencies[key]
 		references += _count_recursive(walked)
 		_gather_paths(walked, key, distinct)
+		_gather_missing(walked, key, missing)
+	# Said in the summary as well as in the tree, where a file that is not there was one
+	# `exists: false` among the entries, which a caller reading the summary never met.
+	var missing_files: Array[Dictionary] = []
+	for path: String in missing:
+		missing_files.append({"path": path, "referenced_by": missing[path]})
 
 	return {
 		"dependencies": dependencies,
@@ -115,11 +126,54 @@ func get_dependencies(params: Dictionary) -> Dictionary:
 			# loads it, and counting its entries answered 11 for a scene with six dependencies.
 			"total_dependencies": distinct.size(),
 			"total_references": references,
-			"circular_count": circular_references.size()
+			"circular_count": circular_references.size(),
+			"missing": missing_files
 		}
 	}
 
 
+## Every file a scene or resource of the project loads through an ext_resource that is not there,
+## by its path or its uid, each with the files loading it. Only those: a script naming a path in
+## its code may be asking whether the file exists, and the shipped addons check for files they
+## write, so every project was told its addons referred to files that are missing. A script's
+## preloads are the compile's to judge.
+func missing_references() -> Array[Dictionary]:
+	var missing: Dictionary = {}
+	for file: String in _files.find_files_with_extensions("res://", GdhResourceFiles.TEXT_RESOURCE_KINDS):
+		var content: String = FileAccess.get_file_as_string(file)
+		var moved: Dictionary = _moved_by_uid(content)
+		for line: RegExMatch in GdhPatterns.compiled("\\[ext_resource[^\\]]*\\]").search_all(content):
+			var at: RegExMatch = GdhPatterns.compiled('path="([^"]+)"').search(line.get_string())
+			if at == null or moved.has(at.get_string(1)):
+				continue
+			var path: String = _resolved(at.get_string(1), file)
+			if FileAccess.file_exists(path):
+				continue
+			var naming: Array = missing.get_or_add(path, [])
+			if not file in naming:
+				naming.append(file)
+	# Sorted, since the walk meets files in the order the filesystem lists them, which differs
+	# between platforms.
+	var paths: Array = missing.keys()
+	paths.sort()
+	var found: Array[Dictionary] = []
+	for path: String in paths:
+		var naming: Array = missing[path]
+		naming.sort()
+		found.append({"path": path, "referenced_by": naming})
+	return found
+
+
+## One line for [param entry], one of [method missing_references].
+static func missing_line(entry: Dictionary) -> String:
+	var referring: Array = entry.get("referenced_by", [])
+	var naming: PackedStringArray = PackedStringArray(referring)
+	return (
+		"%s does not exist, and %s %s to it"
+		% [str(entry.get("path", "")), ", ".join(naming), "refers" if naming.size() == 1 else "refer"]
+	)
+
+
 # What refers to a resource, and how: the scenes that instance it, the scripts that extend or
 # preload it, and for a script with a class_name, every use of that name.
 func find_resource_usages(params: Dictionary) -> Dictionary:
@@ -128,17 +182,20 @@ func find_resource_usages(params: Dictionary) -> Dictionary:
 
 	if not resource_path.begins_with("res://"):
 		resource_path = "res://" + resource_path
-	if not FileAccess.file_exists(resource_path):
-		return _log.failure("Resource file does not exist: " + resource_path)
+	# A file that is gone is searched for all the same, since what still refers to it is what a
+	# caller asks about one, and the forward walk of a scene had just named it missing. Refused only
+	# when nothing refers to it either, which is a path written wrong.
+	var exists: bool = FileAccess.file_exists(resource_path)
 
 	_log.info("Finding usages of: " + resource_path)
 
 	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", "")) if exists else ""
 	}
 
 	var all_files: Array[String] = _usage_files(file_types)
@@ -189,10 +246,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
 
@@ -200,11 +259,19 @@ func find_resource_usages(params: Dictionary) -> Dictionary:
 			usages.append({"file": file_path, "references": references})
 			total += references.size()
 
+	if not exists and usages.is_empty():
+		return _log.failure(
+			_files.with_nearest_files(
+				"Resource file does not exist: %s, and nothing in the project refers to it" % resource_path,
+				resource_path
+			)
+		)
 	var declared: Variant = null
 	if not class_name_declared.is_empty():
 		declared = class_name_declared
 	return {
 		"resource_path": resource_path,
+		"exists": exists,
 		"class_name": declared,
 		"usages": usages,
 		"summary":
@@ -229,7 +296,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 +349,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 +366,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 +388,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"):
@@ -353,6 +420,20 @@ func _gather_paths(deps: Array[Dictionary], root: String, into: Dictionary) -> v
 			_gather_paths(deeper, root, into)
 
 
+# Each file in [param deps] that does not exist, into [param into] with the files naming it, once
+# each however often the tree reaches them; [param parent] names the entries of [param deps].
+func _gather_missing(deps: Array[Dictionary], parent: String, into: Dictionary) -> void:
+	for dep: Dictionary in deps:
+		var path: String = str(dep.get("path", ""))
+		if not dep.get("exists", true):
+			var naming: Array = into.get_or_add(path, [])
+			if not parent in naming:
+				naming.append(parent)
+		if dep.has("dependencies"):
+			var deeper: Array[Dictionary] = dep["dependencies"]
+			_gather_missing(deeper, path, into)
+
+
 # A circular entry is not counted: it marks that the entry holding it was reached again, which that
 # entry already counts as one reference.
 func _count_recursive(deps: Array[Dictionary]) -> int:
@@ -366,7 +447,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 +466,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
 
@@ -400,14 +481,20 @@ func _analyze_resource(path: String, current_depth: int, walk: DependencyWalk) -
 		# about `["res://addons/x/plugin.cfg"]` was a dependency of every project with the addon.
 		if path.get_extension() == "gd":
 			content = _code_lines(content)
+		var moved: Dictionary = _moved_by_uid(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)
+				dep_path = str(moved.get(dep_path, dep_path))
 
 				if not dep_path.begins_with("res://"):
 					continue
+				# A literal naming a directory, or the start of a path a script builds as it runs
+				# ("res://levels/" + name), names no file, and walked as one it was a missing dependency.
+				if dep_path.get_extension().is_empty():
+					continue
 
 				# Skip engine-internal resources unless requested. `addons/` is not one of
 				# them: it is ordinary project content, and often shipping content, so
@@ -439,7 +526,7 @@ func _depend(
 	dep_path: String,
 	by_class: String,
 	current_depth: int,
-	walk: DependencyWalk
+	walk: GdhDependencyWalk
 ) -> void:
 	if dep_path == path:
 		return
@@ -474,7 +561,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()
@@ -499,6 +586,27 @@ static func _resolved(written: String, from: String) -> String:
 
 
 # The path inside a preload(), load() or ext_resource match; a bare res:// match is the path.
+# The ext_resource paths in [param content] that nothing is at, each with the file its uid names
+# instead. The engine loads an ext_resource by its uid first, so a file moved outside the editor
+# still loads, and the walk called it missing; every pattern reads the old path, the bare res://
+# one included, so the paths are mapped before any of them runs.
+static func _moved_by_uid(content: String) -> Dictionary:
+	var moved: Dictionary = {}
+	for line: RegExMatch in GdhPatterns.compiled("\\[ext_resource[^\\]]*\\]").search_all(content):
+		var entry: String = line.get_string()
+		var at: RegExMatch = GdhPatterns.compiled('path="([^"]+)"').search(entry)
+		var uid: RegExMatch = GdhPatterns.compiled('uid="(uid://[^"]+)"').search(entry)
+		if at == null or uid == null or FileAccess.file_exists(at.get_string(1)):
+			continue
+		var id: int = ResourceUID.text_to_id(uid.get_string(1))
+		if id == ResourceUID.INVALID_ID or not ResourceUID.has_id(id):
+			continue
+		var found: String = ResourceUID.get_id_path(id)
+		if FileAccess.file_exists(found):
+			moved[at.get_string(1)] = found
+	return moved
+
+
 func _referenced_path(matched: String) -> String:
 	var expression: String = ""
 	if "preload" in matched or "load" in matched:
@@ -507,6 +615,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
@@ -113,17 +113,15 @@ func add_export_preset(params: Dictionary) -> Dictionary:
 	while config.has_section("preset." + str(index)):
 		var held: String = "preset." + str(index)
 		if str(config.get_value(held, "name", "")) == preset_name:
+			var path: String = str(config.get_value(held, "export_path", ""))
+			var to: String = "with no export path set" if path.is_empty() else "exporting to '%s'" % path
 			return _log.failure(
 				(
 					(
-						"There is already an export preset named '%s', for %s, exporting to '%s'. "
+						"There is already an export preset named '%s', for %s, %s. "
 						+ "project_export run exports with it; give another name to add a second."
 					)
-					% [
-						preset_name,
-						config.get_value(held, "platform", ""),
-						config.get_value(held, "export_path", "")
-					]
+					% [preset_name, config.get_value(held, "platform", ""), to]
 				)
 			)
 		index += 1
@@ -188,9 +186,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"