gdharness 1.3.41 → 1.3.43

package/build/godot/loader/loader.gd

@@ -14,15 +14,6 @@ const RUNTIME: String = "res://addons/gdharness_runtime/runtime_autoload.gd"
 var _runtime: Node
 
 
-## Whether gdharness's runtime is listening in this engine: false in a release build, a script run
-## and an engine without the addon, though this node is in every one of them.
-func serving() -> bool:
-	if not is_instance_valid(_runtime) or not _runtime.has_method("serving"):
-		return false
-	var answered: Variant = _runtime.call("serving")
-	return answered is bool and answered
-
-
 func _ready() -> void:
 	if not OS.is_debug_build() or not ResourceLoader.exists(RUNTIME):
 		return
@@ -38,3 +29,12 @@ func _ready() -> void:
 	# Added now, it announces before the main scene runs, as it does when an entry names it.
 	add_child(runtime)
 	_runtime = runtime
+
+
+## Whether gdharness's runtime is listening in this engine: false in a release build, a script run
+## and an engine without the addon, though this node is in every one of them.
+func serving() -> bool:
+	if not is_instance_valid(_runtime) or not _runtime.has_method("serving"):
+		return false
+	var answered: Variant = _runtime.call("serving")
+	return answered is bool and answered

package/build/godot/operations/animation_reads.gd

@@ -1,13 +1,11 @@
 extends RefCounted
-
-## Animations and state machines read off their nodes: by the editor's tools from the scene it holds,
-## and by a headless engine with none connected from a bare node of the class given what the file
-## stores, which runs no script of the scene's, so a read answers the same either way.
+## Animations and state machines read off their nodes: by the editor's tools from the scene it
+## holds, and by a headless engine with none connected from a bare node of the class given what the
+## file stores, which runs no script of the scene's, so a read answers the same either way.
 
 const GdhFileReads = preload("file_reads.gd")
 const GdhRead = preload("reading.gd")
 const GdhSerialisation = preload("serialisation.gd")
-
 const LOOP_MODE_NAMES: Dictionary[int, String] = {
 	Animation.LOOP_NONE: "none",
 	Animation.LOOP_LINEAR: "linear",
@@ -37,7 +35,9 @@ const ADVANCE_MODE_NAMES: Dictionary[int, String] = {
 
 
 ## [method animations] of the AnimationPlayer at [param player_path] in the file [param scene_path].
-static func scene_animations(scene_path: String, player_path: String, animation_name: String) -> Dictionary:
+static func scene_animations(
+	scene_path: String, player_path: String, animation_name: String
+) -> Dictionary:
 	var made: Array = _bare(scene_path, player_path, "AnimationPlayer")
 	if made[0] == null:
 		return made[1]
@@ -48,7 +48,9 @@ static func scene_animations(scene_path: String, player_path: String, animation_
 
 
 ## [method states] of the AnimationTree at [param tree_path] in the file [param scene_path].
-static func scene_states(scene_path: String, tree_path: String, state_machine_path: String) -> Dictionary:
+static func scene_states(
+	scene_path: String, tree_path: String, state_machine_path: String
+) -> Dictionary:
 	var made: Array = _bare(scene_path, tree_path, "AnimationTree")
 	if made[0] == null:
 		return made[1]
@@ -64,7 +66,13 @@ static func scene_states(scene_path: String, tree_path: String, state_machine_pa
 			player_path = "."
 		var found: Array = _bare(scene_path, player_path, "AnimationPlayer")
 		player = found[0]
-	var answer: Dictionary = states(tree, state_machine_path, player, player_path)
+	var reached: Node = null
+	if player == null and not player_path.is_empty():
+		reached = _bare(scene_path, player_path, "Node")[0]
+	var unplayed: String = no_player(str(tree.anim_player), reached)
+	if reached != null:
+		reached.free()
+	var answer: Dictionary = states(tree, state_machine_path, player, player_path, unplayed)
 	tree.free()
 	if player != null:
 		player.free()
@@ -98,9 +106,9 @@ static func animations(player: AnimationPlayer, animation_name: String) -> Dicti
 			summary["animationName"] = called
 			summary["tracks"] = listed_one.get_track_count()
 			listed.append(summary)
-		return {"ok": true, "animations": listed}
+		return { "ok": true, "animations": listed }
 	if not player.has_animation(StringName(animation_name)):
-		return {"ok": false, "error": no_animation(player, str(player.name), animation_name)}
+		return { "ok": false, "error": no_animation(player, str(player.name), animation_name) }
 	var anim: Animation = player.get_animation(StringName(animation_name))
 	var answer: Dictionary = _summary(anim)
 	answer["ok"] = true
@@ -152,7 +160,8 @@ static func _track(anim: Animation, track: int, values: GdhSerialisation) -> Dic
 	var kind: int = anim.track_get_type(track)
 	var path: NodePath = anim.track_get_path(track)
 	var shaped: Dictionary = {
-		"type": TRACK_TYPE_NAMES.get(kind, str(kind)), "nodePath": str(path.get_concatenated_names())
+		"type": TRACK_TYPE_NAMES.get(kind, str(kind)),
+		"nodePath": str(path.get_concatenated_names()),
 	}
 	var property: String = str(path.get_concatenated_subnames())
 	if not property.is_empty():
@@ -160,7 +169,7 @@ static func _track(anim: Animation, track: int, values: GdhSerialisation) -> Dic
 	var keyframes: Array[Dictionary] = []
 	var methods: Dictionary = {}
 	for key: int in anim.track_get_key_count(track):
-		var keyframe: Dictionary = {"time": held_seconds(anim.track_get_key_time(track, key))}
+		var keyframe: Dictionary = { "time": held_seconds(anim.track_get_key_time(track, key)) }
 		if kind == Animation.TYPE_METHOD:
 			var method: String = str(anim.method_track_get_name(track, key))
 			methods[method] = true
@@ -182,7 +191,9 @@ static func _track(anim: Animation, track: int, values: GdhSerialisation) -> Dic
 ## The state machine at a slash-separated path of nested state machine names in [param tree], or
 ## null when any step of the path is not one. Every node in a tree of state machines is a state
 ## machine itself, so the walk asks each step for the child by name and refuses anything else.
-static func state_machine(tree: AnimationTree, state_machine_path: String) -> AnimationNodeStateMachine:
+static func state_machine(
+	tree: AnimationTree, state_machine_path: String
+) -> AnimationNodeStateMachine:
 	if tree == null:
 		return null
 	var current: AnimationNodeStateMachine = tree.tree_root as AnimationNodeStateMachine
@@ -201,8 +212,8 @@ static func no_machine(tree: AnimationTree, state_machine_path: String) -> Strin
 	if tree == null or tree.tree_root == null:
 		return (
 			"The AnimationTree has no tree_root. Give it one with scene_node set: tree_root "
-			+ '{"_type": "AnimationNodeStateMachine"} builds one into the scene, and the res:// path '
-			+ "of one made with resource_edit create keeps it in a file of its own."
+			+ '{"_type": "AnimationNodeStateMachine"} builds one into the scene, and the res:// '
+			+ "path of one made with resource_edit create keeps it in a file of its own."
 		)
 	var current: AnimationNodeStateMachine = tree.tree_root as AnimationNodeStateMachine
 	if current == null:
@@ -236,42 +247,74 @@ static func no_machine(tree: AnimationTree, state_machine_path: String) -> Strin
 	return "No state machine at " + state_machine_path
 
 
+## Why no state finds its animation when [param anim_player], an AnimationTree's path to its player,
+## reaches no AnimationPlayer: [param reached] is the node it reaches instead, null for none.
+static func no_player(anim_player: String, reached: Node) -> String:
+	var until: String = "so no state plays anything until scene_node set points anim_player at one."
+	if anim_player.is_empty():
+		return "The AnimationTree has no anim_player, " + until
+	if reached == null:
+		return "The AnimationTree's anim_player %s reaches no node, %s" % [anim_player, until]
+	return (
+		"The AnimationTree's anim_player %s reaches %s, a %s rather than an AnimationPlayer, %s"
+		% [anim_player, reached.name, reached.get_class(), until]
+	)
+
+
 ## Why a state playing [param animation_name] from [param player], at [param player_path] from the
 ## scene root as playerNodePath takes it, plays nothing yet. anim_player is relative to the tree
 ## ("../Anim"), which no argument takes.
-static func missing_animation(player: AnimationPlayer, player_path: String, animation_name: String) -> String:
+static func missing_animation(
+	player: AnimationPlayer, player_path: String, animation_name: String
+) -> String:
 	var said: String = (
-		"The AnimationPlayer at %s has no animation %s yet, so the state plays nothing until it has one."
+		(
+			"The AnimationPlayer at %s has no animation %s yet, so the state plays nothing until "
+			+ "it has one."
+		)
 		% [player_path, animation_name]
 	)
 	var close: PackedStringArray = GdhRead.nearest(animation_name, player.get_animation_list())
 	if close.is_empty():
 		return said
 	return (
-		said + " The nearest %s %s." % ["it has is" if close.size() == 1 else "it has are", ", ".join(close)]
+		said
+		+ (
+			" The nearest %s %s."
+			% ["it has is" if close.size() == 1 else "it has are", ", ".join(close)]
+		)
 	)
 
 
 ## The states and transitions of the state machine at [param state_machine_path] in [param tree].
 ## A state playing an animation says whether [param player], at [param player_path], has it, as
-## add_state answers: a state naming one it lacks plays nothing, and says so only in a log.
+## add_state answers: a state naming one it lacks plays nothing, and says so only in a log. With no
+## player, each says [param unplayed], what [method no_player] made of the tree's path.
 static func states(
-	tree: AnimationTree, state_machine_path: String, player: AnimationPlayer, player_path: String
+	tree: AnimationTree,
+	state_machine_path: String,
+	player: AnimationPlayer,
+	player_path: String,
+	unplayed: String
 ) -> Dictionary:
 	var sm: AnimationNodeStateMachine = state_machine(tree, state_machine_path)
 	if sm == null:
-		return {"ok": false, "error": no_machine(tree, state_machine_path)}
+		return { "ok": false, "error": no_machine(tree, state_machine_path) }
 	var listed: Array[Dictionary] = []
 	for state: StringName in sm.get_node_list():
 		var node: AnimationNode = sm.get_node(state)
-		var entry: Dictionary = {"stateName": str(state), "type": node.get_class()}
+		var entry: Dictionary = { "stateName": str(state), "type": node.get_class() }
 		if node is AnimationNodeAnimation:
 			var plays: AnimationNodeAnimation = node
 			entry["animationName"] = str(plays.animation)
 			var found: bool = player != null and player.has_animation(plays.animation)
 			entry["animationFound"] = found
-			if player != null and not found:
-				entry["animationMissing"] = missing_animation(player, player_path, str(plays.animation))
+			if player == null:
+				entry["animationMissing"] = unplayed
+			elif not found:
+				entry["animationMissing"] = missing_animation(
+					player, player_path, str(plays.animation)
+				)
 		listed.append(entry)
 	var transitions: Array[Dictionary] = []
 	for index: int in sm.get_transition_count():
@@ -279,8 +322,10 @@ static func states(
 		var shaped: Dictionary = {
 			"from": str(sm.get_transition_from(index)),
 			"to": str(sm.get_transition_to(index)),
-			"transitionType": SWITCH_MODE_NAMES.get(transition.switch_mode, str(transition.switch_mode)),
-			"advanceMode": ADVANCE_MODE_NAMES.get(transition.advance_mode, str(transition.advance_mode)),
+			"transitionType":
+			SWITCH_MODE_NAMES.get(transition.switch_mode, str(transition.switch_mode)),
+			"advanceMode":
+			ADVANCE_MODE_NAMES.get(transition.advance_mode, str(transition.advance_mode)),
 		}
 		var condition: String = str(transition.advance_condition)
 		if not condition.is_empty():
@@ -290,9 +335,9 @@ static func states(
 		if not condition.is_empty() and transition.advance_mode != transition.ADVANCE_MODE_AUTO:
 			shaped["conditionNote"] = (
 				(
-					"advanceMode is %s, so %s never advances it: the engine checks a condition only on an"
-					+ " auto transition%s. disconnect_states and connect_states again with the condition"
-					+ " write it as auto"
+					"advanceMode is %s, so %s never advances it: the engine checks a condition "
+					+ "only on an auto transition%s. disconnect_states and connect_states again "
+					+ "with the condition write it as auto"
 				)
 				% [
 					shaped["advanceMode"],
@@ -301,16 +346,16 @@ static func states(
 						", and travel() still takes this one"
 						if transition.advance_mode == transition.ADVANCE_MODE_ENABLED
 						else ""
-					)
+					),
 				]
 			)
 		transitions.append(shaped)
-	return {"ok": true, "states": listed, "transitions": transitions}
+	return { "ok": true, "states": listed, "transitions": transitions }
 
 
 ## The states of the AnimationTrees under [param root] that play [param animation_name] from
-## [param player], as [[node, {animTreePath, state}]], a state named by the path of the nodes leading
-## to it.
+## [param player], as [[node, {animTreePath, state}]], a state named by the path of the nodes
+## leading to it.
 static func states_playing(root: Node, player: AnimationPlayer, animation_name: String) -> Array:
 	var found: Array = []
 	var trees: Array[Node] = root.find_children("*", "AnimationTree", true, false)
@@ -331,7 +376,9 @@ static func _collect_playing(
 	if node is AnimationNodeAnimation:
 		var plays: AnimationNodeAnimation = node
 		if plays.animation == StringName(animation_name):
-			found.append([plays, {"animTreePath": tree_path, "state": "." if at.is_empty() else at}])
+			found.append(
+				[plays, { "animTreePath": tree_path, "state": "." if at.is_empty() else at }]
+			)
 		return
 	var children: Dictionary = {}
 	if node is AnimationNodeStateMachine:
@@ -352,4 +399,6 @@ static func _collect_playing(
 			children[str(point)] = plane.get_blend_point_node(point)
 	for step: String in children:
 		var child: AnimationNode = children[step]
-		_collect_playing(child, step if at.is_empty() else at + "/" + step, tree_path, animation_name, found)
+		_collect_playing(
+			child, step if at.is_empty() else at + "/" + step, tree_path, animation_name, found
+		)

package/build/godot/operations/audio_buses.gd

@@ -23,7 +23,9 @@ func create_audio_bus(params: Dictionary) -> Dictionary:
 	# Sends are by name, so a second bus with one would leave every send to it meaning either.
 	var existing: int = AudioServer.get_bus_index(bus_name)
 	if existing != -1:
-		return _log.failure("A bus named " + bus_name + " already exists, at index " + str(existing))
+		return _log.failure(
+			"A bus named " + bus_name + " already exists, at index " + str(existing)
+		)
 
 	# Right after the bus it sends to, because a bus can only send to one before it. The engine
 	# inserts there and moves every later bus down one, so the new bus is at that index: taking the
@@ -41,7 +43,7 @@ func create_audio_bus(params: Dictionary) -> Dictionary:
 	var buses: Array[Dictionary] = []
 	for i: int in range(AudioServer.bus_count):
 		buses.append(_bus(i))
-	return {"bus": _bus(new_idx), "buses": buses, "layout": layout}
+	return { "bus": _bus(new_idx), "buses": buses, "layout": layout }
 
 
 func remove_audio_bus(params: Dictionary) -> Dictionary:
@@ -52,7 +54,9 @@ func remove_audio_bus(params: Dictionary) -> Dictionary:
 	if index == -1:
 		return _log.failure("No bus named %s. The buses are %s." % [bus_name, ", ".join(_names())])
 	if index == 0:
-		return _log.failure("%s is the bus every other ends in, so it cannot be removed." % bus_name)
+		return _log.failure(
+			"%s is the bus every other ends in, so it cannot be removed." % bus_name
+		)
 
 	# A bus sending to this one would be left sending to a name nothing has, which the engine reads
 	# as Master; sent on to where this one went instead, the chain it was part of keeps its shape.
@@ -70,9 +74,9 @@ func remove_audio_bus(params: Dictionary) -> Dictionary:
 	var buses: Array[Dictionary] = []
 	for i: int in range(AudioServer.bus_count):
 		buses.append(_bus(i))
-	var answer: Dictionary = {"removed": bus_name, "buses": buses, "layout": layout}
+	var answer: Dictionary = { "removed": bus_name, "buses": buses, "layout": layout }
 	if not resent.is_empty():
-		answer["resent"] = {"buses": resent, "to": onward}
+		answer["resent"] = { "buses": resent, "to": onward }
 	return answer
 
 
@@ -81,15 +85,19 @@ func get_audio_buses(_params: Dictionary) -> Dictionary:
 	for i: int in range(AudioServer.bus_count):
 		buses.append(_bus(i))
 	var layout: String = _layout_path()
-	var answer: Dictionary = {"bus_count": AudioServer.bus_count, "buses": buses, "layout": layout}
+	var answer: Dictionary = {
+		"bus_count": AudioServer.bus_count,
+		"buses": buses,
+		"layout": layout,
+	}
 	# The setting names a path whether or not anything is there, and a project that never changed a
 	# bus has no file: the path alone read as a layout the project keeps.
 	if not FileAccess.file_exists(layout):
 		answer["layout_on_disk"] = false
 		answer["note"] = (
 			(
-				"Nothing is at %s, so these are the engine's default buses; the first change to a bus "
-				+ "writes the layout there."
+				"Nothing is at %s, so these are the engine's default buses; the first change to a "
+				+ "bus writes the layout there."
 			)
 			% layout
 		)
@@ -139,7 +147,10 @@ func set_audio_bus_effect(params: Dictionary) -> Dictionary:
 	if layout.is_empty():
 		return {}
 	var answer: Dictionary = {
-		"bus": _bus(bus_idx), "effect_index": effect_idx, "effect_type": effect.get_class(), "layout": layout
+		"bus": _bus(bus_idx),
+		"effect_index": effect_idx,
+		"effect_type": effect.get_class(),
+		"layout": layout,
 	}
 	if not replaced.is_empty():
 		answer["replaced"] = replaced
@@ -157,7 +168,7 @@ func set_audio_bus_volume(params: Dictionary) -> Dictionary:
 	var layout: String = _save_layout()
 	if layout.is_empty():
 		return {}
-	return {"bus": _bus(bus_idx), "layout": layout}
+	return { "bus": _bus(bus_idx), "layout": layout }
 
 
 ## Renames a bus, and every send to it with it: the engine renames the one bus and leaves a bus that
@@ -177,7 +188,9 @@ func rename_audio_bus(params: Dictionary) -> Dictionary:
 		)
 	var existing: int = AudioServer.get_bus_index(new_name)
 	if existing != -1:
-		return _log.failure("A bus named " + new_name + " already exists, at index " + str(existing))
+		return _log.failure(
+			"A bus named " + new_name + " already exists, at index " + str(existing)
+		)
 	AudioServer.set_bus_name(index, new_name)
 	var resent: Array[String] = []
 	for i: int in range(AudioServer.bus_count):
@@ -189,7 +202,7 @@ func rename_audio_bus(params: Dictionary) -> Dictionary:
 	if layout.is_empty():
 		return {}
 	var answer: Dictionary = {
-		"renamed": {"from": bus_name, "to": new_name}, "bus": _bus(index), "layout": layout
+		"renamed": { "from": bus_name, "to": new_name }, "bus": _bus(index), "layout": layout,
 	}
 	if not resent.is_empty():
 		answer["resent"] = resent
@@ -211,7 +224,10 @@ func set_audio_bus_send(params: Dictionary) -> Dictionary:
 		return _log.failure("No bus named %s. The buses are %s." % [send, ", ".join(_names())])
 	if target == bus_idx:
 		return _log.failure(
-			"%s cannot send to itself; it can send to %s." % [bus_name, ", ".join(_names().slice(0, bus_idx))]
+			(
+				"%s cannot send to itself; it can send to %s."
+				% [bus_name, ", ".join(_names().slice(0, bus_idx))]
+			)
 		)
 	if target > bus_idx:
 		return (
@@ -219,10 +235,17 @@ func set_audio_bus_send(params: Dictionary) -> Dictionary:
 			. failure(
 				(
 					(
-						"%s is bus %d and %s is bus %d: a bus sends only to one before it, which keeps sound from "
-						+ "going round in a loop, so %s can send to %s."
+						"%s is bus %d and %s is bus %d: a bus sends only to one before it, which "
+						+ "keeps sound from going round in a loop, so %s can send to %s."
 					)
-					% [bus_name, bus_idx, send, target, bus_name, ", ".join(_names().slice(0, bus_idx))]
+					% [
+						bus_name,
+						bus_idx,
+						send,
+						target,
+						bus_name,
+						", ".join(_names().slice(0, bus_idx)),
+					]
 				)
 			)
 		)
@@ -231,7 +254,7 @@ func set_audio_bus_send(params: Dictionary) -> Dictionary:
 	var layout: String = _save_layout()
 	if layout.is_empty():
 		return {}
-	return {"bus": _bus(bus_idx), "layout": layout}
+	return { "bus": _bus(bus_idx), "layout": layout }
 
 
 func _names() -> Array[String]:
@@ -270,7 +293,11 @@ func _bus(index: int) -> Dictionary:
 
 
 func _layout_path() -> String:
-	return str(ProjectSettings.get_setting("audio/buses/default_bus_layout", "res://default_bus_layout.tres"))
+	return str(
+		ProjectSettings.get_setting(
+			"audio/buses/default_bus_layout", "res://default_bus_layout.tres"
+		)
+	)
 
 
 # The path the layout was written to, or empty with the reason on stderr.
@@ -285,7 +312,9 @@ func _save_layout() -> String:
 
 # Any effect class the engine has, by its class name or the part after "AudioEffect".
 func _effect_named(effect_type: String) -> AudioEffect:
-	var cls: String = effect_type if effect_type.begins_with("AudioEffect") else "AudioEffect" + effect_type
+	var cls: String = (
+		effect_type if effect_type.begins_with("AudioEffect") else "AudioEffect" + effect_type
+	)
 	if not ClassDB.class_exists(cls) or not ClassDB.is_parent_class(cls, "AudioEffect"):
 		return null
 	if not ClassDB.can_instantiate(cls):

package/build/godot/operations/class_cache.gd

@@ -9,7 +9,6 @@ const GdhPatterns = preload("patterns.gd")
 const GdhRead = preload("reading.gd")
 const GdhFileWalk = preload("file_walk.gd")
 const GdhLog = preload("logger.gd")
-
 const CACHE_PATH: String = "res://.godot/global_script_class_cache.cfg"
 
 var _log: GdhLog
@@ -30,9 +29,9 @@ func refresh_class_cache(_params: Dictionary) -> Dictionary:
 		var entry: Dictionary = _entry_for(path, skipped)
 		if not entry.is_empty():
 			entries.append(entry)
-	# Another language's classes are kept while their files are there. Only GDScript is read here and
-	# the list is written whole, so a C# project's global classes were dropped from it and answered as
-	# removed, and nothing started next could resolve them.
+	# Another language's classes are kept while their files are there. Only GDScript is read here
+	# and the list is written whole, so a C# project's global classes were dropped from it and
+	# answered as removed, and nothing started next could resolve them.
 	var carried: Array[String] = []
 	for entry: Variant in cached:
 		if not entry is Dictionary:
@@ -43,7 +42,9 @@ func refresh_class_cache(_params: Dictionary) -> Dictionary:
 			entries.append(listed)
 			carried.append(str(listed.get("class", "")))
 	# By name as text: StringName's own order is by identity, not by spelling.
-	entries.sort_custom(func(a: Dictionary, b: Dictionary) -> bool: return str(a["class"]) < str(b["class"]))
+	entries.sort_custom(
+		func(a: Dictionary, b: Dictionary) -> bool: return str(a["class"]) < str(b["class"])
+	)
 
 	var after: Dictionary = _entries_by_class(entries)
 	var config: ConfigFile = ConfigFile.new()
@@ -52,7 +53,9 @@ func refresh_class_cache(_params: Dictionary) -> Dictionary:
 		ProjectSettings.globalize_path(CACHE_PATH.get_base_dir())
 	)
 	if made != OK and made != ERR_ALREADY_EXISTS:
-		return _log.failure("Could not make " + CACHE_PATH.get_base_dir() + ": " + error_string(made))
+		return _log.failure(
+			"Could not make " + CACHE_PATH.get_base_dir() + ": " + error_string(made)
+		)
 	var err: Error = config.save(CACHE_PATH)
 	if err != OK:
 		return _log.failure("Failed to write " + CACHE_PATH + ": " + error_string(err))
@@ -139,7 +142,7 @@ func _base_of(path: String, header: Dictionary, skipped: Array[Dictionary]) -> V
 			return ""
 		var reached: String = opened + ":" + ".".join(PackedStringArray(names))
 		if reached in visited:
-			skipped.append({"path": path, "reason": "extends itself through " + parent_path})
+			skipped.append({ "path": path, "reason": "extends itself through " + parent_path })
 			return null
 		visited.append(reached)
 		var lines: PackedStringArray = FileAccess.get_file_as_string(opened).split("\n")
@@ -162,7 +165,7 @@ static func _extends_parts(text: String) -> Dictionary:
 	if rest.begins_with('"') or rest.begins_with("'"):
 		var closing: int = rest.find(rest[0], 1)
 		if closing == -1:
-			return {"path": "", "names": [] as Array[String]}
+			return { "path": "", "names": [] as Array[String] }
 		path = rest.substr(1, closing - 1)
 		rest = rest.substr(closing + 1)
 	var names: Array[String] = []
@@ -179,7 +182,7 @@ static func _extends_parts(text: String) -> Dictionary:
 			break
 		names.append(found.get_string(1))
 		rest = rest.substr(found.get_end())
-	return {"path": path, "names": names}
+	return { "path": path, "names": names }
 
 
 # The file the engine's class scan reads for an `extends` path. It opens the path as written, and
@@ -203,7 +206,7 @@ func _inner_class(lines: PackedStringArray, names: Array[String]) -> Dictionary:
 	var found: Dictionary = {}
 	for name: String in names:
 		var at: int = -1
-		found = {"found": true}
+		found = { "found": true }
 		for index: int in range(start, end):
 			var text: String = lines[index].strip_edges()
 			if text.is_empty() or text.begins_with("#") or _indent(lines[index]) != depth:
@@ -255,7 +258,9 @@ func _header_of(path: String) -> Dictionary:
 # which is where the body begins.
 func _header_in(lines: PackedStringArray) -> Dictionary:
 	var header: Dictionary = {}
-	var annotation: RegEx = GdhPatterns.compiled('^@([a-z_]+)(?:\\(\\s*(?:"([^"]*)")?[^)]*\\))?\\s*')
+	var annotation: RegEx = GdhPatterns.compiled(
+		'^@([a-z_]+)(?:\\(\\s*(?:"([^"]*)")?[^)]*\\))?\\s*'
+	)
 	var extends_line: RegEx = GdhPatterns.compiled("^extends\\s+(.*)$")
 	var same_line: RegEx = GdhPatterns.compiled("^\\s+extends\\s+(.*)$")
 	for line: String in lines: