gdharness 1.3.41 → 1.3.43

package/build/godot/operations/resource_files.gd

@@ -3,7 +3,6 @@ extends RefCounted
 const GdhFileWalk = preload("file_walk.gd")
 const GdhLog = preload("logger.gd")
 const GdhPatterns = preload("patterns.gd")
-
 ## Where the engine keeps a file's UID, by what kind of file it is. Measured on 4.7.2: a script or
 ## shader has a `.uid` file beside it, an imported file has it in its `.import`, and a text scene or
 ## resource has it in its own header. `ResourceLoader.get_resource_uid` answers the first two in a
@@ -34,7 +33,7 @@ func get_uid(params: Dictionary) -> Dictionary:
 			GdhFileWalk.new().with_nearest_files("File does not exist: " + file_path, file_path)
 		)
 
-	var answer: Dictionary = {"file": file_path, "absolute_path": absolute_path}
+	var answer: Dictionary = { "file": file_path, "absolute_path": absolute_path }
 	var found: Dictionary = uid_of(file_path)
 	if found.is_empty():
 		answer["exists"] = false
@@ -51,12 +50,12 @@ static func uid_of(file_path: String) -> Dictionary:
 	if FileAccess.file_exists(sidecar):
 		var text: String = FileAccess.get_file_as_string(sidecar).strip_edges()
 		if not text.is_empty():
-			return {"uid": text, "from": sidecar}
+			return { "uid": text, "from": sidecar }
 	var import_file: String = file_path + ".import"
 	if FileAccess.file_exists(import_file):
 		var config: ConfigFile = ConfigFile.new()
 		if config.load(import_file) == OK and config.has_section_key("remap", "uid"):
-			return {"uid": str(config.get_value("remap", "uid")), "from": import_file}
+			return { "uid": str(config.get_value("remap", "uid")), "from": import_file }
 	if file_path.get_extension().to_lower() in TEXT_RESOURCE_KINDS:
 		var file: FileAccess = FileAccess.open(file_path, FileAccess.READ)
 		if file != null:
@@ -64,10 +63,10 @@ static func uid_of(file_path: String) -> Dictionary:
 			file.close()
 			var matched: RegExMatch = GdhPatterns.compiled('\\buid="(uid://[^"]+)"').search(header)
 			if matched != null:
-				return {"uid": matched.get_string(1), "from": "the file's header"}
+				return { "uid": matched.get_string(1), "from": "the file's header" }
 	var id: int = ResourceLoader.get_resource_uid(file_path)
 	if id != ResourceUID.INVALID_ID:
-		return {"uid": ResourceUID.id_to_text(id), "from": "the engine"}
+		return { "uid": ResourceUID.id_to_text(id), "from": "the engine" }
 	return {}
 
 
@@ -79,9 +78,12 @@ func _why_none(file_path: String) -> String:
 		return "No .uid file beside it. refresh_uids writes one for every script and shader."
 	if kind in TEXT_RESOURCE_KINDS:
 		return (
-			"Its header carries no uid. The editor writes one when it saves the file; refresh_uids does not,"
-			+ " and a headless save does not either."
+			"Its header carries no uid. The editor writes one when it saves the file; refresh_uids "
+			+ "does not, and a headless save does not either."
 		)
 	if ResourceLoader.exists(file_path):
 		return "The engine keeps no UID for it."
-	return "It has not been imported, and the import is what gives it a UID: project_import reimport imports it."
+	return (
+		"It has not been imported, and the import is what gives it a UID: project_import reimport "
+		+ "imports it."
+	)

package/build/godot/operations/same_values.gd

@@ -1,12 +1,10 @@
 @tool
 extends RefCounted
-
 ## Whether a value read back is the value that was given, as the tools that write properties judge
 ## what a write kept and what it changed besides.
 
 const GdhRead = preload("reading.gd")
 const GdhSerialisation = preload("serialisation.gd")
-
 # The types made of floats, which a read back compares within float precision: a Vector2 property
 # stores 32-bit components, so 0.1 comes back as 0.100000001.
 const FLOAT_SHAPES: Array[int] = [
@@ -23,7 +21,6 @@ const FLOAT_SHAPES: Array[int] = [
 	TYPE_AABB,
 	TYPE_PROJECTION,
 ]
-
 const PACKED: Array[int] = [
 	TYPE_PACKED_BYTE_ARRAY,
 	TYPE_PACKED_INT32_ARRAY,
@@ -63,7 +60,10 @@ static func same(held: Variant, given: Variant) -> bool:
 			return held_type == given_type and held == given
 		var held_number: float = GdhRead.as_float(held)
 		var given_number: float = GdhRead.as_float(given)
-		return (is_nan(held_number) and is_nan(given_number)) or is_equal_approx(held_number, given_number)
+		return (
+			(is_nan(held_number) and is_nan(given_number))
+			or is_equal_approx(held_number, given_number)
+		)
 	if GdhSerialisation.TEXTS.has(held_type) and GdhSerialisation.TEXTS.has(given_type):
 		return str(held) == str(given)
 	if _listed(held_type) and _listed(given_type):

package/build/godot/operations/scene_connections.gd

@@ -1,5 +1,4 @@
 extends RefCounted
-
 ## The signal connections the project's scenes hold that cannot work: a method the node it calls
 ## does not have, which fails on every emission, or a signal the node it leaves does not have, which
 ## the engine drops as the scene loads. Read from the text of each scene and script, so nothing is
@@ -13,7 +12,6 @@ extends RefCounted
 const GdhDependencies = preload("dependencies.gd")
 const GdhFileWalk = preload("file_walk.gd")
 const GdhLog = preload("logger.gd")
-
 const EXT_RESOURCE: String = '^\\[ext_resource [^\\]]*?path="([^"]+)"[^\\]]*? id="([^"]+)"'
 const NODE: String = "^\\[node ([^\\]]*)\\]"
 const CONNECTION: String = "^\\[connection ([^\\]]*)\\]"
@@ -38,8 +36,8 @@ func _init(p_log: GdhLog) -> void:
 	_globals = GdhDependencies.new(p_log).classes_declared()
 
 
-## Every connection that cannot work, as {scene, from, signal, to, method, missing}, where missing is
-## "method" or "signal".
+## Every connection that cannot work, as {scene, from, signal, to, method, missing}, where missing
+## is "method" or "signal".
 func broken() -> Array[Dictionary]:
 	var found: Array[Dictionary] = []
 	for scene: String in _files.find_files_with_extensions("res://", ["tscn"]):
@@ -76,7 +74,10 @@ static func broken_line(entry: Dictionary) -> String:
 		% [entry["scene"], entry["from"], entry["signal"], entry["to"], entry["method"]]
 	)
 	if entry["missing"] == "signal":
-		return connected + ", a signal that node does not have, so the engine drops it as the scene loads."
+		return (
+			connected
+			+ ", a signal that node does not have, so the engine drops it as the scene loads."
+		)
 	return connected + ", a method that node does not have, so every emission fails to call it."
 
 
@@ -100,11 +101,17 @@ func _nodes_of(content: String, scene: String) -> Dictionary:
 			var attributes: Dictionary = _attributes(heading.get_string(1))
 			var name: String = str(attributes.get("name", ""))
 			var parent: Variant = attributes.get("parent")
-			current = "." if parent == null else (name if parent == "." else "%s/%s" % [parent, name])
-			var node: Dictionary = {"class": str(attributes.get("type", "")), "script": "", "name": name}
+			current = (
+				"." if parent == null else (name if parent == "." else "%s/%s" % [parent, name])
+			)
+			var node: Dictionary = {
+				"class": str(attributes.get("type", "")), "script": "", "name": name,
+			}
 			var instanced: RegExMatch = instance.search(heading.get_string(1))
 			if instanced != null:
-				var root: Dictionary = _root_of(str(resources.get(instanced.get_string(1), "")), scene)
+				var root: Dictionary = _root_of(
+					str(resources.get(instanced.get_string(1), "")), scene
+				)
 				node = root.duplicate()
 				node["name"] = name
 			nodes[current] = node
@@ -118,7 +125,9 @@ func _nodes_of(content: String, scene: String) -> Dictionary:
 			# A built-in script lives in the scene, where this does not read it, so its node is one
 			# nothing here can judge, which a path that is no script file says.
 			var external: bool = scripted.get_string(1) == "Ext"
-			node["script"] = str(resources.get(scripted.get_string(2), "?")) if external else "built-in"
+			node["script"] = (
+				str(resources.get(scripted.get_string(2), "?")) if external else "built-in"
+			)
 	return nodes
 
 
@@ -127,11 +136,16 @@ func _nodes_of(content: String, scene: String) -> Dictionary:
 func _root_of(path: String, from: String) -> Dictionary:
 	if _roots.has(path):
 		return _roots[path]
-	_roots[path] = {"class": "", "script": ""}
-	if path.is_empty() or path == from or not path.ends_with(".tscn") or not FileAccess.file_exists(path):
+	_roots[path] = { "class": "", "script": "" }
+	if (
+		path.is_empty()
+		or path == from
+		or not path.ends_with(".tscn")
+		or not FileAccess.file_exists(path)
+	):
 		return _roots[path]
 	var nodes: Dictionary = _nodes_of(FileAccess.get_file_as_string(path), path)
-	_roots[path] = nodes.get(".", {"class": "", "script": ""})
+	_roots[path] = nodes.get(".", { "class": "", "script": "" })
 	return _roots[path]
 
 
@@ -200,7 +214,7 @@ func _script(path: String, seen: Dictionary) -> Dictionary:
 		methods.merge(inherited_methods)
 		signals.merge(inherited_signals)
 		engine_class = str(inherited["class"])
-	_scripts[path] = {"class": engine_class, "methods": methods, "signals": signals}
+	_scripts[path] = { "class": engine_class, "methods": methods, "signals": signals }
 	return _scripts[path]
 
 

package/build/godot/operations/script_check.gd

@@ -1,28 +1,25 @@
 extends RefCounted
-
 ## Compiles scripts the way the engine does when it loads them, and answers what it raised.
 ##
 ## The engine reports a script that does not compile as errors raised from GDScript::reload, each
 ## naming the file and line, and they reach a Logger as well as stderr. Measured on 4.7.2: a script
-## whose dependency does not compile reports the dependency's errors at the dependency's path and one
-## of its own at line 0, "Compile Error: Failed to compile depended scripts", and is still handed
-## back as a script that can_instantiate() calls instantiable. Warnings are not among them: the engine
-## sends those only to an editor or a debugger.
+## whose dependency does not compile reports the dependency's errors at the dependency's path and
+## one of its own at line 0, "Compile Error: Failed to compile depended scripts", and is still
+## handed back as a script that can_instantiate() calls instantiable. Warnings are not among them:
+## the engine sends those only to an editor or a debugger.
 ##
-## A script that failed stays failed in the engine's script cache, which no ResourceLoader cache mode
-## reaches, and every script loaded after it that depends on it compiles in silence, reload() and all.
-## So a run ends at the first script that raised anything, and the rest go to a fresh engine.
+## A script that failed stays failed in the engine's script cache, which no ResourceLoader cache
+## mode reaches, and every script loaded after it that depends on it compiles in silence, reload()
+## and all. So a run ends at the first script that raised anything, and the rest go to a fresh
+## engine.
 
 const GdhRead = preload("reading.gd")
 const GdhLog = preload("logger.gd")
-
 ## Where the engine raises a script's compile errors from.
 const RELOAD: String = "GDScript::reload"
-
 ## What the engine puts on the end of a warning it raised as an error. Kept in step with
 ## `RAISED_WARNING` in src/server.ts.
 const RAISED: String = " (Warning treated as error.)"
-
 ## Where the project's warning levels are, each 0 to ignore, 1 to warn and 2 to raise as an error.
 const WARNING_LEVELS: String = "debug/gdscript/warnings/"
 const WARN: int = 1
@@ -31,34 +28,6 @@ const ERROR_LEVEL: int = 2
 var _log: GdhLog
 
 
-## Every compile error the engine raises while it is attached, in order.
-class GdhCaught:
-	extends Logger
-
-	var raised: Array[Dictionary] = []
-
-	func _log_message(_message: String, _error: bool) -> void:
-		pass
-
-	# The engine's own signature for a Logger, eight parameters and not this project's to shape.
-	# gdlint:ignore = function-arguments-number
-	func _log_error(
-		function: String,
-		file: String,
-		line: int,
-		code: String,
-		rationale: String,
-		_editor_notify: bool,
-		_error_type: int,
-		_script_backtraces: Array[ScriptBacktrace],
-	) -> void:
-		if function != RELOAD:
-			return
-		raised.append(
-			{"path": file, "line": line, "message": rationale if not rationale.is_empty() else code}
-		)
-
-
 func _init(p_log: GdhLog) -> void:
 	_log = p_log
 
@@ -105,22 +74,24 @@ func check_scripts(params: Dictionary) -> Dictionary:
 				if not at in others:
 					others.append(at)
 				continue
-			var found: Dictionary = {"line": GdhRead.as_int(error["line"]), "message": str(error["message"])}
+			var found: Dictionary = {
+				"line": GdhRead.as_int(error["line"]), "message": str(error["message"]),
+			}
 			if not found in errors:
 				errors.append(found)
 		if loaded == null and errors.is_empty():
-			errors.append({"line": 0, "message": "The engine could not load it as a script."})
+			errors.append({ "line": 0, "message": "The engine could not load it as a script." })
 		if errors.is_empty() and others.is_empty():
 			continue
 		if not errors.is_empty():
 			failed.append(path)
-			var one: Dictionary = {"path": path, "errors": errors}
+			var one: Dictionary = { "path": path, "errors": errors }
 			if not others.is_empty():
 				one["dependencies_with_errors"] = others
 			scripts.append(one)
 		break
 	OS.remove_logger(caught)
-	return {"checked": checked, "failed": failed, "scripts": scripts}
+	return { "checked": checked, "failed": failed, "scripts": scripts }
 
 
 ## Raises every warning the project sets to warn so that the engine reports it as an error, which is
@@ -144,9 +115,9 @@ static func raise_warnings() -> void:
 
 ## The warnings of each script in [code]paths[/code], under the levels [method raise_warnings] left:
 ## [code]scripts[/code] holds each that has any, with its warnings' lines and the engine's messages
-## as raised. The analyser runs before anything is compiled, so a script whose dependency failed on a
-## warning still reports its own, and loading on past a failure loses nothing; only what is raised at
-## the script's own path is its, since a dependency is read on its own entry as well.
+## as raised. The analyser runs before anything is compiled, so a script whose dependency failed on
+## a warning still reports its own, and loading on past a failure loses nothing; only what is raised
+## at the script's own path is its, since a dependency is read on its own entry as well.
 func check_warnings(params: Dictionary) -> Dictionary:
 	var asked: Array = params.get("paths", [])
 	var caught: GdhCaught = GdhCaught.new()
@@ -163,10 +134,42 @@ func check_warnings(params: Dictionary) -> Dictionary:
 			var message: String = str(error["message"])
 			if str(error["path"]) != path or not message.ends_with(RAISED):
 				continue
-			var found: Dictionary = {"line": GdhRead.as_int(error["line"]), "message": message}
+			var found: Dictionary = { "line": GdhRead.as_int(error["line"]), "message": message }
 			if not found in warnings:
 				warnings.append(found)
 		if not warnings.is_empty():
-			scripts.append({"path": path, "warnings": warnings})
+			scripts.append({ "path": path, "warnings": warnings })
 	OS.remove_logger(caught)
-	return {"checked": checked, "scripts": scripts}
+	return { "checked": checked, "scripts": scripts }
+
+
+## Every compile error the engine raises while it is attached, in order.
+class GdhCaught:
+	extends Logger
+
+	var raised: Array[Dictionary] = []
+
+	func _log_message(_message: String, _error: bool) -> void:
+		pass
+
+	# The engine's own signature for a Logger, eight parameters and not this project's to shape.
+	# gdstyle:ignore=quality/max-parameters
+	func _log_error(
+		function: String,
+		file: String,
+		line: int,
+		code: String,
+		rationale: String,
+		_editor_notify: bool,
+		_error_type: int,
+		_script_backtraces: Array[ScriptBacktrace],
+	) -> void:
+		if function != RELOAD:
+			return
+		raised.append(
+			{
+				"path": file,
+				"line": line,
+				"message": rationale if not rationale.is_empty() else code,
+			}
+		)