gdharness 1.3.42 → 1.3.44

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

@@ -1,8 +1,7 @@
 @tool
 extends "animation_tools.gd"
-
-## The tracks and keys of an animation, beside the players and libraries the script it extends edits,
-## whose helpers it shares.
+## The tracks and keys of an animation, beside the players and libraries the script it extends
+## edits, whose helpers it shares.
 
 
 # =============================================================================
@@ -15,19 +14,19 @@ func add_animation_track(args: Dictionary) -> Dictionary:
 	var given_track: Variant = args.get("track", {})
 
 	if scene_path.strip_edges() == "res://":
-		return {"ok": false, "error": "Missing scenePath"}
+		return { "ok": false, "error": "Missing scenePath" }
 	if animation_name.strip_edges().is_empty():
-		return {"ok": false, "error": "Missing animationName"}
+		return { "ok": false, "error": "Missing animationName" }
 	var track: Dictionary = given_track if given_track is Dictionary else {}
 	if track.is_empty():
-		return {"ok": false, "error": "Missing track"}
-	# The schema leaves keyframes out of what track requires, since remove_track finds a track without
-	# them.
+		return { "ok": false, "error": "Missing track" }
+	# The schema leaves keyframes out of what track requires, since remove_track finds a track
+	# without them.
 	if not track.has("keyframes"):
-		return {"ok": false, "error": "Missing track.keyframes"}
+		return { "ok": false, "error": "Missing track.keyframes" }
 	var keyed: Array = _keyframes(track)
 	if not keyed[0]:
-		return {"ok": false, "error": keyed[1]}
+		return { "ok": false, "error": keyed[1] }
 
 	# Asked of the player, which knows every library: looking only in the default one refused
 	# "moves/walk" as missing.
@@ -48,13 +47,16 @@ func add_animation_track(args: Dictionary) -> Dictionary:
 		target_path = "."
 	var target: Node = _animated(player, target_path)
 	if target == null:
-		return scene.refuse(
-			(
+		return (
+			scene
+			. refuse(
 				(
-					"No node at %s from the player's root node, %s, which is what the track path is read "
-					+ "against."
+					(
+						"No node at %s from the player's root node, %s, which is what the track "
+						+ "path is read against."
+					)
+					% [target_path, str(player.root_node)]
 				)
-				% [target_path, str(player.root_node)]
 			)
 		)
 	var keyframes: Array = keyed[1]
@@ -120,7 +122,12 @@ func add_animation_track(args: Dictionary) -> Dictionary:
 ## animates: two tracks for one path both play, the later overriding the earlier, and a key meant
 ## to extend the motion was split off where reading the animation showed two halves.
 func _add_track(
-	anim: Animation, track: Dictionary, target: Node, target_path: String, keyframes: Array, replacing: bool
+	anim: Animation,
+	track: Dictionary,
+	target: Node,
+	target_path: String,
+	keyframes: Array,
+	replacing: bool
 ) -> Array:
 	var track_type: String = str(track.get("type", ""))
 	var keys: Array = []
@@ -148,7 +155,7 @@ func _add_track(
 				return _not_added("keyframes[%d].args must be a list." % index)
 			var raw: Array = given
 			var arguments: Array = _fitted(target, method_name, _parse_method_args(raw))
-			keys.append({"method": method_name, "args": arguments})
+			keys.append({ "method": method_name, "args": arguments })
 			if misfit.is_empty():
 				misfit = _key_misfit(target, method_name, arguments, index)
 		method_found = target.has_method(method_name)
@@ -156,7 +163,10 @@ func _add_track(
 	else:
 		return _not_added(
 			(
-				"add_track makes property and method tracks, and track.type is %s; remove_track takes any."
+				(
+					"add_track makes property and method tracks, and track.type is %s; "
+					+ "remove_track takes any."
+				)
 				% track_type
 			)
 		)
@@ -178,14 +188,16 @@ func _add_track(
 				return _not_added(
 					(
 						(
-							"Track %d already animates %s and has a key at %s s, which keyframes[%d] would "
-							+ "replace. Nothing was written; replaceKeys true replaces it."
+							"Track %d already animates %s and has a key at %s s, which "
+							+ "keyframes[%d] would replace. Nothing was written; replaceKeys true "
+							+ "replaces it."
 						)
 						% [track_idx, str(path), _seconds(time), index]
 					)
 				)
-			# A method key's value is its call, {"method": ..., "args": [...]}. The time is as asked:
-			# the key's own, read back from a scene's 32-bit times, puts 0.1 at 0.100000001490116.
+			# A method key's value is its call, {"method": ..., "args": [...]}. The time is as
+			# asked: the key's own, read back from a scene's 32-bit times, puts 0.1 at
+			# 0.100000001490116.
 			(
 				replaced
 				. append(
@@ -228,7 +240,9 @@ static func _fitted(target: Node, method: String, arguments: Array) -> Array:
 			declared = GdhRead.as_int(parameter.get("type", TYPE_NIL))
 		if value is float and declared != TYPE_FLOAT:
 			var number: float = value
-			if is_finite(number) and number == floorf(number) and absf(number) < 9007199254740992.0:
+			if (is_finite(number)
+					and number == floorf(number)
+					and absf(number) < 9_007_199_254_740_992.0):
 				value = int(number)
 		fitted.append(value)
 	return fitted
@@ -256,10 +270,16 @@ static func _key_misfit(target: Node, method: String, arguments: Array, index: i
 		else ("1 argument" if arguments.size() == 1 else "%d arguments" % arguments.size())
 	)
 	if arguments.size() < needed:
-		return "keyframes[%d] calls %s with %s, and it needs %d%s" % [index, method, passed, needed, fails]
+		return (
+			"keyframes[%d] calls %s with %s, and it needs %d%s"
+			% [index, method, passed, needed, fails]
+		)
 	if arguments.size() > parameters.size():
 		var most: String = "none" if parameters.is_empty() else "at most %d" % parameters.size()
-		return "keyframes[%d] calls %s with %s, and it takes %s%s" % [index, method, passed, most, fails]
+		return (
+			"keyframes[%d] calls %s with %s, and it takes %s%s"
+			% [index, method, passed, most, fails]
+		)
 	for at: int in arguments.size():
 		var parameter: Dictionary = parameters[at]
 		var taken_type: int = GdhRead.as_int(parameter.get("type", TYPE_NIL))
@@ -276,7 +296,7 @@ static func _key_misfit(target: Node, method: String, arguments: Array, index: i
 					method,
 					str(parameter.get("name", "")),
 					type_string(taken_type),
-					fails
+					fails,
 				]
 			)
 	return ""
@@ -293,22 +313,22 @@ func remove_animation_track(args: Dictionary) -> Dictionary:
 	var animation_name: String = str(args.get("animationName", ""))
 	var given_track: Variant = args.get("track", {})
 	if scene_path.strip_edges() == "res://":
-		return {"ok": false, "error": "Missing scenePath"}
+		return { "ok": false, "error": "Missing scenePath" }
 	if animation_name.strip_edges().is_empty():
-		return {"ok": false, "error": "Missing animationName"}
+		return { "ok": false, "error": "Missing animationName" }
 	var track: Dictionary = given_track if given_track is Dictionary else {}
 	if track.is_empty():
-		return {"ok": false, "error": "Missing track"}
+		return { "ok": false, "error": "Missing track" }
 	var track_type: String = str(track.get("type", ""))
 	if not track_type in GdhAnimationReads.TRACK_TYPE_NAMES.values():
-		return {"ok": false, "error": "Unsupported track.type: " + track_type}
+		return { "ok": false, "error": "Unsupported track.type: " + track_type }
 	var node_path: String = str(track.get("nodePath", ""))
 	var property: String = str(track.get("property", ""))
 	var shape: Array = [track_type, node_path, property]
 	var method: String = str(track.get("method", "")) if track_type == "method" else ""
 	var read_times: Variant = _times_of(args.get("times"))
 	if read_times is String:
-		return {"ok": false, "error": read_times}
+		return { "ok": false, "error": read_times }
 	var times: Array = read_times
 
 	var found: Array = _animation_at(scene_path, player_node_path, animation_name)
@@ -335,7 +355,7 @@ func remove_animation_track(args: Dictionary) -> Dictionary:
 			% [
 				animation_name,
 				track_type,
-				node_path if property.is_empty() else "%s:%s" % [node_path, property]
+				node_path if property.is_empty() else "%s:%s" % [node_path, property],
 			]
 		)
 		if held.is_empty():
@@ -353,7 +373,9 @@ func remove_animation_track(args: Dictionary) -> Dictionary:
 		var timed: Array = _keys_at(anim, calling, times)
 		if timed[1] != "":
 			var on: String = node_path if property.is_empty() else "%s:%s" % [node_path, property]
-			return scene.refuse("%s's %s track on %s %s" % [animation_name, track_type, on, timed[1]])
+			return scene.refuse(
+				"%s's %s track on %s %s" % [animation_name, track_type, on, timed[1]]
+			)
 		calling = timed[0]
 	var keys: int = 0
 	var tracks_removed: int = 0
@@ -383,7 +405,7 @@ func remove_animation_track(args: Dictionary) -> Dictionary:
 		if loaded.get_track_count() != left or _key_total(loaded) != keys_left:
 			return "the track would still be in %s when the scene loads." % animation_name
 		return ""
-	var removed: Dictionary = {"type": track_type, "nodePath": node_path}
+	var removed: Dictionary = { "type": track_type, "nodePath": node_path }
 	if not property.is_empty():
 		removed["property"] = property
 	if not method.is_empty():
@@ -432,8 +454,8 @@ static func _times_of(given: Variant) -> Variant:
 
 
 ## Of the keys [param calling] names, as [method _keys_calling] answers them, the ones at
-## [param times], as [[[track, key]...], ""], or with the second the words refusing a time none is at.
-## Removing a key took removing its whole track, so moving one key in time rewrote every other.
+## [param times], as [[[track, key]...], ""], or with the second the words refusing a time none is
+## at. Removing a key took removing its whole track, so moving one key in time rewrote every other.
 static func _keys_at(anim: Animation, calling: Array, times: Array) -> Array:
 	var at: Array = []
 	var held: PackedStringArray = []
@@ -457,7 +479,10 @@ static func _keys_at(anim: Animation, calling: Array, times: Array) -> Array:
 		var _named: bool = named.append(str(given))
 	return [
 		at,
-		"has no key at %s s; its keys are at %s s. Nothing was removed." % [", ".join(named), ", ".join(held)]
+		(
+			"has no key at %s s; its keys are at %s s. Nothing was removed."
+			% [", ".join(named), ", ".join(held)]
+		),
 	]
 
 
@@ -483,7 +508,9 @@ static func _key_total(anim: Animation) -> int:
 static func _track_shape(anim: Animation, index: int) -> Array:
 	var path: NodePath = anim.track_get_path(index)
 	return [
-		GdhAnimationReads.TRACK_TYPE_NAMES.get(anim.track_get_type(index), str(anim.track_get_type(index))),
+		GdhAnimationReads.TRACK_TYPE_NAMES.get(
+			anim.track_get_type(index), str(anim.track_get_type(index))
+		),
 		str(path.get_concatenated_names()),
 		str(path.get_concatenated_subnames()),
 	]
@@ -508,7 +535,8 @@ func _keyframes(track: Dictionary) -> Array:
 		var seconds: float = GdhRead.as_float(time)
 		if times.has(seconds):
 			return [
-				false, "keyframes[%d] and [%d] are both at %s seconds." % [times[seconds], index, seconds]
+				false,
+				"keyframes[%d] and [%d] are both at %s seconds." % [times[seconds], index, seconds],
 			]
 		times[seconds] = index
 	return [true, keyframes]
@@ -530,7 +558,9 @@ func _key_values(target: Node, prop_name: String, keyframes: Array) -> Array:
 			# A subname such as position:x keys one component, which is a number.
 			var component: Variant = _properties.parse(raw, TYPE_FLOAT)
 			if not component is float:
-				return [false, "keyframes[%d].value keys %s, which is a number." % [index, prop_name]]
+				return [
+					false, "keyframes[%d].value keys %s, which is a number." % [index, prop_name],
+				]
 			values.append(component)
 			continue
 		var value: Array = _properties.value_for(target, declared, raw)

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

@@ -1,6 +1,5 @@
 @tool
 extends Node
-
 ## The global classes the running editor is holding.
 ##
 ## The editor fixes this list when it starts and adds to it only from a filesystem scan, and
@@ -51,10 +50,10 @@ func set_editor_plugin(plugin: EditorPlugin) -> void:
 func reload_script(args: Dictionary) -> Dictionary:
 	var asked: String = str(args.get("scriptPath", ""))
 	if asked.is_empty():
-		return {"ok": false, "error": "scriptPath is required"}
-	var path: String = _spelled_as_on_disk(asked)
+		return { "ok": false, "error": "scriptPath is required" }
+	var path: String = _spelled_as_on_disk(asked, {})
 	if not ResourceLoader.exists(path):
-		return {"ok": false, "error": "No script at " + path}
+		return { "ok": false, "error": "No script at " + path }
 
 	# The copy the editor holds, when it holds one, and otherwise a load that reads the file, rather
 	# than load(): a load recompiles a script whose base has been reloaded from the text it holds,
@@ -63,11 +62,13 @@ func reload_script(args: Dictionary) -> Dictionary:
 	# the reload below compiled it clean.
 	var cached: Resource = ResourceLoader.get_cached_ref(path)
 	var loaded: Resource = (
-		cached if cached != null else ResourceLoader.load(path, "", ResourceLoader.CACHE_MODE_IGNORE)
+		cached
+		if cached != null
+		else ResourceLoader.load(path, "", ResourceLoader.CACHE_MODE_IGNORE)
 	)
 	var script: GDScript = loaded as GDScript
 	if script == null:
-		return {"ok": false, "error": path + " is not a GDScript"}
+		return { "ok": false, "error": path + " is not a GDScript" }
 
 	# What the copy had before anything touched it, which is the reading that shows the fault rather
 	# than the one that mends it. Without it a caller cannot tell a copy that was already current
@@ -82,7 +83,10 @@ func reload_script(args: Dictionary) -> Dictionary:
 	# method added since is still absent from the method list.
 	var reader: FileAccess = FileAccess.open(path, FileAccess.READ)
 	if reader == null:
-		return {"ok": false, "error": "Could not read " + path + ": " + str(FileAccess.get_open_error())}
+		return {
+			"ok": false,
+			"error": "Could not read " + path + ": " + str(FileAccess.get_open_error()),
+		}
 	var previous: String = script.source_code
 	var text: String = reader.get_as_text()
 	reader.close()
@@ -90,11 +94,11 @@ func reload_script(args: Dictionary) -> Dictionary:
 	# Godot keeps one parse of each script for other scripts to resolve its class through, and a
 	# reload drops that parse only when the text it compiles differs from the text that was parsed.
 	# A parse that failed because a class it names was not yet known has the file's own text, so it
-	# outlived every reload: the class answered with all its methods while each script naming it read
-	# "because of a parser error" until the editor restarted, for as long as anything held the parse,
-	# such as a file open in an editor's language server. Compiling once with a line more makes the
-	# texts differ, which drops that parse and those of the scripts that resolved through it; the
-	# file's own text is compiled below.
+	# outlived every reload: the class answered with all its methods while each script naming it
+	# read "because of a parser error" until the editor restarted, for as long as anything held the
+	# parse, such as a file open in an editor's language server. Compiling once with a line more
+	# makes the texts differ, which drops that parse and those of the scripts that resolved through
+	# it; the file's own text is compiled below.
 	script.source_code = text + "\n"
 	var _dropped: Error = script.reload(true)
 	script.source_code = text
@@ -103,11 +107,11 @@ func reload_script(args: Dictionary) -> Dictionary:
 	# caller needs then: a failure travels back as its message alone, and a project met one and
 	# could not tell whether the copy had been damaged by it or before it.
 	#
-	# And the old text is compiled again. A failed reload leaves the object unusable while its member
-	# lists read as before, measured on 4.7.2: it can make no instance, and an instance it already made
-	# has lost its methods, and the old text put back uncompiled leaves it that way. Compiling the text
-	# it was built from puts it back, and whether that worked is said, since the text may no longer
-	# compile against what it names.
+	# And the old text is compiled again. A failed reload leaves the object unusable while its
+	# member lists read as before, measured on 4.7.2: it can make no instance, and an instance it
+	# already made has lost its methods, and the old text put back uncompiled leaves it that way.
+	# Compiling the text it was built from puts it back, and whether that worked is said, since the
+	# text may no longer compile against what it names.
 	var failed: Error = script.reload(true)
 	var answer: Dictionary = {
 		"ok": true,
@@ -129,8 +133,8 @@ func reload_script(args: Dictionary) -> Dictionary:
 	return answer
 
 
-## Which of [code]scriptPaths[/code] the editor holds a compiled copy of whose text is not the file's,
-## without loading or reloading anything. A script compiled against such a copy fails on the
+## Which of [code]scriptPaths[/code] the editor holds a compiled copy of whose text is not the
+## file's, without loading or reloading anything. A script compiled against such a copy fails on the
 ## members the file has gained, and a reload of it fails the same way until the copy is reloaded
 ## first; the rescan that met this blamed the new classes the script also named, which were fine.
 ##
@@ -140,15 +144,16 @@ func reload_script(args: Dictionary) -> Dictionary:
 func scripts_behind(args: Dictionary) -> Dictionary:
 	var given: Variant = args.get("scriptPaths", [])
 	if not given is Array:
-		return {"ok": false, "error": "scriptPaths must be a list of res:// paths"}
+		return { "ok": false, "error": "scriptPaths must be a list of res:// paths" }
 	var asked: Array = given
 	var unsaved: PackedStringArray = []
 	if Engine.is_editor_hint():
 		unsaved = EditorInterface.get_script_editor().get_unsaved_files()
 	var behind: Array[String] = []
 	var edited: Array[String] = []
+	var listings: Dictionary = {}
 	for entry: Variant in asked:
-		var path: String = _spelled_as_on_disk(str(entry))
+		var path: String = _spelled_as_on_disk(str(entry), listings)
 		var script: GDScript = ResourceLoader.get_cached_ref(path) as GDScript
 		if script == null:
 			continue
@@ -163,13 +168,13 @@ func scripts_behind(args: Dictionary) -> Dictionary:
 			edited.append(path)
 		else:
 			behind.append(path)
-	return {"ok": true, "behind": behind, "unsavedInEditor": edited}
+	return { "ok": true, "behind": behind, "unsavedInEditor": edited }
 
 
-## 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.
+## 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.
@@ -192,28 +197,46 @@ func _reread_open_tabs(path: String, answer: Dictionary) -> void:
 ## `res://core/rules.gd`, but the editor holds its copy under the spelling on disk, and a load by
 ## another spelling misses that copy and compiles a new one: reloading that answers with a fresh
 ## compile's members and leaves the copy the editor holds as it was.
-static func _spelled_as_on_disk(path: String) -> String:
+##
+## [param listings] keeps each directory's entries for the length of one call that spells many
+## paths. Listed again for every path, a check of the 416 classes of one project listed a folder of
+## eight hundred files twice per class, and held an editor's main thread for close to a minute on a
+## CI runner, with every request behind it waiting.
+static func _spelled_as_on_disk(path: String, listings: Dictionary) -> String:
 	var local: String = ProjectSettings.localize_path(path)
 	if not local.begins_with("res://"):
 		return local
 	var spelled: String = "res://"
 	for step: String in local.trim_prefix("res://").split("/", false):
-		var listing: DirAccess = DirAccess.open(spelled)
-		if listing == null:
+		if not listings.has(spelled):
+			listings[spelled] = _entries_by_spelling(spelled)
+		var entries: Variant = listings[spelled]
+		if entries == null:
 			return local
-		var found: String = ""
-		for entry: String in listing.get_directories() + listing.get_files():
-			if entry == step:
-				found = entry
-				break
-			if found.is_empty() and entry.nocasecmp_to(step) == 0:
-				found = entry
+		var exact: Dictionary = entries[0]
+		var folded: Dictionary = entries[1]
+		var found: String = step if exact.has(step) else str(folded.get(step.to_lower(), ""))
 		if found.is_empty():
 			return local
 		spelled = spelled.path_join(found)
 	return spelled
 
 
+## The entries of [param directory] by their own spelling and by their spelling in lower case, the
+## first of those that fold together winning, or null for a directory that cannot be opened.
+static func _entries_by_spelling(directory: String) -> Variant:
+	var listing: DirAccess = DirAccess.open(directory)
+	if listing == null:
+		return null
+	var exact: Dictionary = {}
+	var folded: Dictionary = {}
+	for entry: String in listing.get_directories() + listing.get_files():
+		exact[entry] = true
+		if not folded.has(entry.to_lower()):
+			folded[entry.to_lower()] = entry
+	return [exact, folded]
+
+
 func _method_names(script: GDScript) -> Array[String]:
 	var names: Array[String] = []
 	for entry: Dictionary in script.get_script_method_list():
@@ -223,11 +246,11 @@ func _method_names(script: GDScript) -> Array[String]:
 
 
 ## The script's constants, those of the scripts it extends included as its methods include theirs,
-## and the keys of each one that is a Dictionary as `Kind.SHORT`, which is how the copy holds a named
-## enum: a stale enum member is denied as a member of the enum rather than of the class. A constant
-## Dictionary that is not an enum is listed the same way, since the map does not tell the two apart.
-## The engine's map holds only the script's own, so a script extending a class_name listed every
-## method it inherited and none of the constants.
+## and the keys of each one that is a Dictionary as `Kind.SHORT`, which is how the copy holds a
+## named enum: a stale enum member is denied as a member of the enum rather than of the class. A
+## constant Dictionary that is not an enum is listed the same way, since the map does not tell the
+## two apart. The engine's map holds only the script's own, so a script extending a class_name
+## listed every method it inherited and none of the constants.
 func _constant_names(script: GDScript) -> Array[String]:
 	var names: Array[String] = []
 	var holder: Script = script
@@ -250,7 +273,7 @@ func _constant_names(script: GDScript) -> Array[String]:
 
 func global_classes(_args: Dictionary) -> Dictionary:
 	if not _editor_plugin:
-		return {"ok": false, "error": "Editor plugin unavailable"}
+		return { "ok": false, "error": "Editor plugin unavailable" }
 
 	var filesystem: EditorFileSystem = EditorInterface.get_resource_filesystem()
 	var names: Array[String] = []

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

@@ -1,6 +1,5 @@
 @tool
 extends Node
-
 ## The editor's view of the files on disk: scans, the reimports asked for, where each stands, and
 ## files moved under it.
 
@@ -8,20 +7,17 @@ const GdhRead = preload("../reading.gd")
 const GdhSceneFile = preload("../scene_file.gd")
 
 var _editor_plugin: EditorPlugin = null
-
 ## How many scans the editor has completed, counted off `sources_changed`, which it emits at the end
 ## of every scan once the reimport the scan found is done: the one moment a scan is over. Neither
 ## flag it offers says so. A threaded scan stops reporting itself when its thread finishes, and its
 ## import runs a frame or more later when the thread is joined; an editor in the background took
 ## long enough over that frame that a rescan answered before the import of 211 changed scenes began.
 var _scans_completed: int = 0
-
 ## When the last scan completed, on the engine's clock, or -1 before the first. The editor writes
 ## the class cache a frame after it stops reporting a scan, measured on 4.7.2, so a game started
 ## in between reads a file being rewritten; how long ago the scan ended is what tells a caller
 ## whether that write can still be coming.
 var _scan_finished_at_msec: int = -1
-
 ## How many reimports asked for through [method reimport_files] have finished. Counted here rather
 ## than off `resources_reimported`, which a scan's own import emits as well.
 var _reimports_completed: int = 0
@@ -53,7 +49,7 @@ func _scan_completed(_sources_exist: bool) -> void:
 ## another scan.
 func rescan_filesystem(args: Dictionary) -> Dictionary:
 	if not _editor_plugin:
-		return {"ok": false, "error": "Editor plugin unavailable"}
+		return { "ok": false, "error": "Editor plugin unavailable" }
 
 	var filesystem: EditorFileSystem = EditorInterface.get_resource_filesystem()
 	# Not over a scan or an import the editor is already running: a scan asked for then starts a
@@ -62,13 +58,13 @@ func rescan_filesystem(args: Dictionary) -> Dictionary:
 	var busy: bool = filesystem.is_scanning() or filesystem.is_importing()
 	var started: bool = false
 	var completed_before: int = _scans_completed
-	var uids: Dictionary = {"reread": [], "duplicated": []}
+	var uids: Dictionary = { "reread": [], "duplicated": [] }
 	if not GdhRead.as_bool(args.get("statusOnly", false)) and not busy:
 		uids = _reread_changed_uids(filesystem)
-		# Files the caller has just written, moved or deleted, read again one by one. The scan finds a
-		# script that appeared and leaves the global class of one that has gone in the editor's list,
-		# which it then writes back into the class cache at a path that is not there; reading the gone
-		# path again is what drops it.
+		# Files the caller has just written, moved or deleted, read again one by one. The scan finds
+		# a script that appeared and leaves the global class of one that has gone in the editor's
+		# list, which it then writes back into the class cache at a path that is not there; reading
+		# the gone path again is what drops it.
 		var named: Variant = args.get("updateFiles", [])
 		if named is Array:
 			var paths: Array = named
@@ -137,14 +133,14 @@ func _reread_changed_uids(filesystem: EditorFileSystem) -> Dictionary:
 		reread.append(path)
 	reread.sort()
 	duplicated.sort()
-	return {"reread": reread, "duplicated": duplicated}
+	return { "reread": reread, "duplicated": duplicated }
 
 
 ## Every `.uid` under [param directory], skipping what the editor skips: hidden directories, any
 ## holding a `.gdignore`, and any below the project's own that holds a `project.godot` of its own,
-## which the editor passes over as another project. A nested project's UIDs are never in the editor's
-## table, so without that last one its files would be read again on every rescan, and one holding a
-## copy of an outer file's `.uid` named as a duplicate on disk.
+## which the editor passes over as another project. A nested project's UIDs are never in the
+## editor's table, so without that last one its files would be read again on every rescan, and one
+## holding a copy of an outer file's `.uid` named as a duplicate on disk.
 func _uid_files(directory: String, found: Array[String]) -> void:
 	var listing: DirAccess = DirAccess.open(directory)
 	if listing == null or FileAccess.file_exists(directory.path_join(".gdignore")):
@@ -166,12 +162,13 @@ func _uid_files(directory: String, found: Array[String]) -> void:
 ## Apart from `rescan_filesystem` because asking must not start or count anything.
 func scan_status(_args: Dictionary) -> Dictionary:
 	if not _editor_plugin:
-		return {"ok": false, "error": "Editor plugin unavailable"}
+		return { "ok": false, "error": "Editor plugin unavailable" }
 	var filesystem: EditorFileSystem = EditorInterface.get_resource_filesystem()
-	# The scenes open in tabs, the one shown and the ones holding unsaved edits: a scene edit on disk
-	# meets what the editor holds of it, and nothing said which scenes those were. A tab of a scene
-	# never saved has no path, and a new project's editor opens with an empty one, so it is left out
-	# of the open; one with edits is kept among the unsaved, as the edits a close would lose.
+	# The scenes open in tabs, the one shown and the ones holding unsaved edits: a scene edit on
+	# disk meets what the editor holds of it, and nothing said which scenes those were. A tab of a
+	# scene never saved has no path, and a new project's editor opens with an empty one, so it is
+	# left out of the open; one with edits is kept among the unsaved, as the edits a close would
+	# lose.
 	var shown: Node = EditorInterface.get_edited_scene_root()
 	var open: Array[String] = []
 	open.assign(Array(EditorInterface.get_open_scenes()).filter(_has_path))
@@ -204,14 +201,14 @@ func _has_path(path: String) -> bool:
 ## while the editor scans or imports, since `reimport_files` refuses to run inside an import.
 func reimport_files(args: Dictionary) -> Dictionary:
 	if not _editor_plugin:
-		return {"ok": false, "error": "Editor plugin unavailable"}
+		return { "ok": false, "error": "Editor plugin unavailable" }
 	var paths: Array[String] = []
 	var given: Variant = args.get("paths", [])
 	if given is Array:
 		for path: Variant in given:
 			paths.append(str(path))
 	if paths.is_empty():
-		return {"ok": false, "error": "reimport_files needs paths"}
+		return { "ok": false, "error": "reimport_files needs paths" }
 	var filesystem: EditorFileSystem = EditorInterface.get_resource_filesystem()
 	var busy: bool = filesystem.is_scanning() or filesystem.is_importing()
 	if not busy:
@@ -282,7 +279,12 @@ func files_moved(args: Dictionary) -> Dictionary:
 			reloaded.append(scene)
 	reloaded.sort()
 	unsaved.sort()
-	return {"ok": true, "retargetedTabs": retargeted, "reloadedScenes": reloaded, "unsavedScenes": unsaved}
+	return {
+		"ok": true,
+		"retargetedTabs": retargeted,
+		"reloadedScenes": reloaded,
+		"unsavedScenes": unsaved,
+	}
 
 
 func _reimport(paths: PackedStringArray) -> void: