gdharness 1.3.47 → 1.3.48

package/build/godot/operations/animation_reads.gd

@@ -16,6 +16,22 @@ const UPDATE_MODE_NAMES: Dictionary[int, String] = {
 	Animation.UPDATE_DISCRETE: "discrete",
 	Animation.UPDATE_CAPTURE: "capture",
 }
+const INTERPOLATION_NAMES: Dictionary[int, String] = {
+	Animation.INTERPOLATION_NEAREST: "nearest",
+	Animation.INTERPOLATION_LINEAR: "linear",
+	Animation.INTERPOLATION_CUBIC: "cubic",
+	Animation.INTERPOLATION_LINEAR_ANGLE: "linear_angle",
+	Animation.INTERPOLATION_CUBIC_ANGLE: "cubic_angle",
+}
+## The track types whose keys are blended between, so how they are and whether a looping animation
+## blends its last key into its first say how the track moves.
+const INTERPOLATED_TYPES: Array[int] = [
+	Animation.TYPE_VALUE,
+	Animation.TYPE_POSITION_3D,
+	Animation.TYPE_ROTATION_3D,
+	Animation.TYPE_SCALE_3D,
+	Animation.TYPE_BLEND_SHAPE,
+]
 const TRACK_TYPE_NAMES: Dictionary[int, String] = {
 	Animation.TYPE_VALUE: "property",
 	Animation.TYPE_POSITION_3D: "position_3d",
@@ -174,6 +190,10 @@ static func _track(anim: Animation, track: int, values: GdhSerialisation) -> Dic
 	if kind == Animation.TYPE_VALUE:
 		var mode: int = anim.value_track_get_update_mode(track)
 		shaped["update"] = UPDATE_MODE_NAMES.get(mode, str(mode))
+	if kind in INTERPOLATED_TYPES:
+		var interpolation: int = anim.track_get_interpolation_type(track)
+		shaped["interpolation"] = INTERPOLATION_NAMES.get(interpolation, str(interpolation))
+		shaped["loopWrap"] = anim.track_get_interpolation_loop_wrap(track)
 	var keyframes: Array[Dictionary] = []
 	var methods: Dictionary = {}
 	for key: int in anim.track_get_key_count(track):

package/build/godot/operations/dependencies.gd

@@ -530,6 +530,20 @@ static func _comment_of(line: String) -> String:
 
 # How a line that names the resource by path uses it.
 func _path_reference_kind(line: String, file_path: String) -> String:
+	var placed: String = _placed_kind(line, file_path)
+	if not placed.is_empty():
+		return placed
+	var trimmed: String = GdhPatterns.without_annotations(line)
+	if "preload(" in trimmed:
+		return "preload"
+	if "load(" in trimmed:
+		return "load"
+	return "path"
+
+
+# The kind a reference on [param line] has by the file it is in or by how the line starts, or ""
+# when neither says.
+static func _placed_kind(line: String, file_path: String) -> String:
 	match file_path.get_file():
 		"project.godot":
 			return "setting"
@@ -546,11 +560,31 @@ func _path_reference_kind(line: String, file_path: String) -> String:
 		return "ext_resource"
 	if trimmed.begins_with("#include"):
 		return "include"
-	if "preload(" in trimmed:
+	return ""
+
+
+# The kind of the reference [param found] is in [param content], read from [param path], by the
+# call its path is handed to rather than by the line, which can name a second file another way: a
+# path only written in a string, which nothing in the file may load, read as a load.
+static func _forward_kind(content: String, found: RegExMatch, path: String) -> String:
+	var matched: String = found.get_string()
+	if matched.begins_with("preload("):
 		return "preload"
-	if "load(" in trimmed:
+	if matched.begins_with("load("):
 		return "load"
-	return "path"
+	var start: int = found.get_start()
+	var line_start: int = content.rfind("\n", start) + 1
+	var line_end: int = content.find("\n", start)
+	var line: String = content.substr(
+		line_start, (content.length() if line_end == -1 else line_end) - line_start
+	)
+	var before: String = content.substr(line_start, start - line_start).rstrip("\"'")
+	if before.ends_with("preload("):
+		return "preload"
+	if before.ends_with("load("):
+		return "load"
+	var placed: String = _placed_kind(line, path)
+	return "path" if placed.is_empty() else placed
 
 
 func _regex_escaped(text: String) -> String:
@@ -633,8 +667,14 @@ func _depend(dep_info: Dictionary, current_depth: int, walk: GdhDependencyWalk)
 	# tree answered that file as a dependency of itself.
 	if dep_path in walk.path_stack:
 		var cycle: Array[String] = walk.path_stack.slice(walk.path_stack.find(dep_path))
-		cycle.append(dep_path)
-		if not cycle in walk.circular_references:
+		# Kept by a key that is the same wherever the walk entered the cycle: compared as written,
+		# one cycle met from two of its files was listed twice, and comparing each against every
+		# cycle found so far grew with the square of their number, sixteen thousand on three
+		# hundred scripts typed by each other's class names.
+		var key: String = _cycle_key(cycle)
+		if not walk.cycles_seen.has(key):
+			walk.cycles_seen[key] = true
+			cycle.append(dep_path)
 			walk.circular_references.append(cycle)
 		dep_info["circular"] = true
 		return false
@@ -660,6 +700,16 @@ func _depend(dep_info: Dictionary, current_depth: int, walk: GdhDependencyWalk)
 	return walked["cut"]
 
 
+## [param cycle], the files of one cycle in the order the walk met them, turned to start at the
+## first of them in sorting order, so the cycle met from any of its files keys the same.
+static func _cycle_key(cycle: Array[String]) -> String:
+	var first: int = 0
+	for at: int in cycle.size():
+		if cycle[at] < cycle[first]:
+			first = at
+	return "\n".join(PackedStringArray(cycle.slice(first) + cycle.slice(0, first)))
+
+
 ## What [param path] names, each file once, as the entries the tree lists it by; read once a walk.
 func _references(path: String, walk: GdhDependencyWalk) -> Array[Dictionary]:
 	if walk.references.has(path):
@@ -688,12 +738,13 @@ func _references(path: String, walk: GdhDependencyWalk) -> Array[Dictionary]:
 			for m: RegExMatch in regex.search_all(content):
 				var written: String = _resolved(_referenced_path(m.get_string()), path)
 				var dep_path: String = str(moved.get(written, written))
+				var kind: String = _forward_kind(content, m, path)
 
 				# A uid the project does not know names no file, and loading it fails: passed over
 				# as no res:// path, a script's load of one went unsaid while the game printed
 				# "Unrecognized UID" at that line.
 				if dep_path.begins_with("uid://"):
-					_name(deps, path, dep_path, {})
+					_name(deps, path, dep_path, { "kind": kind })
 					continue
 				if not dep_path.begins_with("res://"):
 					continue
@@ -709,7 +760,9 @@ func _references(path: String, walk: GdhDependencyWalk) -> Array[Dictionary]:
 				if not walk.include_built_in and dep_path.begins_with("res://."):
 					continue
 
-				var named_by: Dictionary = { "stale_path": written } if dep_path != written else {}
+				var named_by: Dictionary = { "kind": kind }
+				if dep_path != written:
+					named_by["stale_path"] = written
 				if unknown.has(dep_path):
 					named_by["unknown_uid"] = unknown[dep_path]
 				_name(deps, path, dep_path, named_by)
@@ -730,8 +783,8 @@ func _references(path: String, walk: GdhDependencyWalk) -> Array[Dictionary]:
 
 # Adds [param dep_path] to [param deps], what [param path] depends on, once however many times it
 # is named. [param named_by] is the class or autoload name it was named by, as by_class or
-# by_autoload, and the path written when the engine loads another, as stale_path; empty for a path
-# that is the file.
+# by_autoload, or for a path its kind, with the path written when the engine loads another as
+# stale_path.
 func _name(deps: Array[Dictionary], path: String, dep_path: String, named_by: Dictionary) -> void:
 	if dep_path == path:
 		return
@@ -962,6 +1015,9 @@ class GdhDependencyWalk:
 
 	var circular_references: Array
 
+	## Each cycle in circular_references, by [method _cycle_key].
+	var cycles_seen: Dictionary[String, bool] = {}
+
 	func _init(p_max_depth: int, p_include_built_in: bool, p_circular_references: Array) -> void:
 		max_depth = p_max_depth
 		include_built_in = p_include_built_in

package/build/godot/operations/file_reads.gd

@@ -356,6 +356,12 @@ static func _entry(
 	var data: Dictionary = {
 		"name": node["name"], "type": node["type"], "path": path, "children": children,
 	}
+	var given_values: Dictionary = node["properties"]
+	var attached: Variant = given_values.get("script")
+	if attached is Script:
+		var script: Script = attached
+		if not str(script.get_global_name()).is_empty():
+			data["scriptClass"] = str(script.get_global_name())
 	# The root's file is the scene being read, so only another node's names a second scene.
 	if path != "." and node.has("instanceOf"):
 		data["instanceOf"] = node["instanceOf"]

package/build/godot/operations/import_pipeline.gd

@@ -212,7 +212,7 @@ func set_import_options(params: Dictionary) -> Dictionary:
 	var refused: Array[String] = []
 	for key: Variant in options:
 		var name: String = str(key)
-		var held: Variant = config.get_value("params", name, null)
+		var held: Variant = _held(config, name)
 		var given: Variant = _values.deserialize_value(options[key])
 		var value: Variant = _as_option(_values.fitted(options[key], typeof(held)), held)
 		if value is Dictionary:
@@ -248,7 +248,7 @@ func set_import_options(params: Dictionary) -> Dictionary:
 	var unchanged_keys: Array[String] = []
 	var changes: Dictionary = {}
 	for name: String in fitted_values:
-		var held: Variant = config.get_value("params", name, null)
+		var held: Variant = _held(config, name)
 		var value: Variant = fitted_values[name]
 		if held != null and typeof(held) == typeof(value) and held == value:
 			unchanged_keys.append(name)
@@ -275,6 +275,14 @@ func set_import_options(params: Dictionary) -> Dictionary:
 	return answer
 
 
+## What the option [param name] holds in [param config]'s params, or null when it holds none. Asked
+## with a default of null, the engine prints an error for a key the file does not have.
+static func _held(config: ConfigFile, name: String) -> Variant:
+	if not config.has_section_key("params", name):
+		return null
+	return config.get_value("params", name)
+
+
 ## [param given] as the option holds it. Every JSON number arrives as a float, and an enum option
 ## such as compress/mode written as 1.0 is kept that way by the import, so a whole number becomes
 ## an int unless the option already holds a float.

package/build/godot/operations/project_config.gd

@@ -413,6 +413,9 @@ func add_autoload(params: Dictionary) -> Dictionary:
 		return _log.failure(
 			GdhFileWalk.new().with_nearest_files("Autoload file does not exist: " + path, path)
 		)
+	var unloadable: String = _not_an_autoload(path)
+	if not unloadable.is_empty():
+		return _log.failure(unloadable)
 
 	# Through ProjectSettings so the file is saved the way the editor saves it, which includes
 	# putting Godot's header back and dropping any comment somebody wrote into the file by hand.
@@ -453,6 +456,38 @@ func add_autoload(params: Dictionary) -> Dictionary:
 	return answer
 
 
+## Why the file at [param path] cannot be an autoload, or empty when it can, as the editor's
+## Autoload
+## tab judges it: a scene, or a script whose instances are nodes. Written anyway, a script extending
+## RefCounted saved fine and every start of the game then failed to instantiate it. A script that
+## does not compile is let through, since it may be one being written, and its errors are its own.
+static func _not_an_autoload(path: String) -> String:
+	var refused: String = "%s is %s, and an autoload is a scene or a script extending Node"
+	if not ResourceLoader.exists(path):
+		return (refused + "; nothing was written.") % [path, "a file Godot does not load"]
+	var loaded: Resource = load(path)
+	if loaded is PackedScene:
+		return ""
+	if not loaded is Script:
+		var kind: String = "nothing Godot could load"
+		if loaded != null:
+			kind = "a " + loaded.get_class()
+		return (refused + "; nothing was written.") % [path, kind]
+	var script: Script = loaded
+	if not script.can_instantiate():
+		return ""
+	var base: StringName = script.get_instance_base_type()
+	if ClassDB.is_parent_class(base, "Node"):
+		return ""
+	return (
+		(
+			"%s extends %s, which is not a Node, and Godot instantiates an autoload under the root "
+			+ "as a node, so every start of the game would fail to load it; nothing was written."
+		)
+		% [path, base]
+	)
+
+
 ## Why [param name] cannot name an autoload, or empty when it can. The editor's Autoload tab refuses
 ## the same names: an autoload named after an engine class or a built-in type takes that name in
 ## every script, so an autoload called Input made every Input.is_action_pressed call the autoload.

package/build/godot/operations/resource_files.gd

@@ -36,10 +36,9 @@ func get_uid(params: Dictionary) -> Dictionary:
 	var answer: Dictionary = { "file": file_path, "absolute_path": absolute_path }
 	var found: Dictionary = uid_of(file_path)
 	if found.is_empty():
-		answer["exists"] = false
+		answer["uid"] = null
 		answer["message"] = _why_none(file_path)
 		return answer
-	answer["exists"] = true
 	answer.merge(found)
 	return answer
 

package/build/godot/tests/listed.gd

@@ -357,6 +357,9 @@ class GdhRunner:
 	var case_began: bool = false
 	## The suite running, which a case's own event does not carry.
 	var suite_running: String = ""
+	## Whether gdUnit4 has minimised the window, or is about to, and it is not back yet: it does as
+	## its runner starts, and after every suite.
+	var minimise_pending: bool = true
 
 	## As the run ends, the marker of the walk's newest end, and every script held past the walk, on
 	## an engine whose walk can stop part way ([GdhShutdownWalk]).
@@ -446,7 +449,11 @@ class GdhRunner:
 			GdUnitEvent.SESSION_START:
 				if not GdhIndexedSession.indexes_itself(_test_session):
 					_test_session = GdhIndexedSession.of(_test_session)
+				var tree: SceneTree = get_tree()
+				if not tree.process_frame.is_connected(drawn_window):
+					var _watched: int = tree.process_frame.connect(drawn_window)
 			GdUnitEvent.TESTSUITE_BEFORE:
+				drawn_window()
 				suite_running = event.resource_path()
 				orphans_at_suite = orphan_ids()
 				orphans_named.clear()
@@ -461,6 +468,9 @@ class GdhRunner:
 			GdUnitEvent.TESTCASE_AFTER:
 				cases_ended += 1
 		super(event)
+		# gdUnit4 minimises the window once the suite's end is reported.
+		if event.type() == GdUnitEvent.TESTSUITE_AFTER:
+			minimise_pending = true
 		# After gdUnit4's own report of the case, so the line falls under it.
 		if event.orphan_nodes() == 0:
 			return
@@ -478,6 +488,21 @@ class GdhRunner:
 				"after", left.filter(func(id: int) -> bool: return not orphans_from_before.has(id))
 			)
 
+	## The window back from minimised, which gdUnit4 makes it as its runner starts and after every
+	## suite, and where Godot draws nothing: a suite given a window to render in waited for a
+	## frame_post_draw that never came. Called as a suite begins, ahead of its before(), and every
+	## frame after, since on macOS the minimise is an animation that reads as windowed until it
+	## ends, and a window not yet minimised cannot be put back. Only once for each minimise of
+	## gdUnit4's, so a suite minimising the window itself keeps it minimised.
+	func drawn_window() -> void:
+		if not minimise_pending or DisplayServer.get_name() == "headless":
+			return
+		if Engine.is_embedded_in_editor():
+			return
+		if DisplayServer.window_get_mode() == DisplayServer.WINDOW_MODE_MINIMIZED:
+			DisplayServer.window_set_mode(DisplayServer.WINDOW_MODE_WINDOWED)
+			minimise_pending = false
+
 	## The orphans now that were not there in [param before] and no line has named yet.
 	func new_orphans(before: Dictionary[int, bool]) -> Array[int]:
 		var found: Array[int] = []