gdharness 1.3.9 → 1.3.10

package/build/godot/operations/file_reads.gd

@@ -16,15 +16,19 @@ const GdhSerialisation = preload("serialisation.gd")
 
 
 ## The nodes of [param scene_path] as {name, type, path, children}, with instanceOf and
-## editableChildren on a node that instances another scene and every stored property when
-## [param include_properties] is set, the file's value or the default where it sets none.
+## editableChildren on a node that instances another scene and its stored properties when
+## [param include_properties] is set, the file's value or the default where it sets none, and on a
+## node another file makes setHere, the properties this file sets on it. Defaults the file leaves
+## alone are counted as defaultsLeftOut rather than listed unless [param include_defaults] is set.
 ## [param depth] -1 reads every level.
-static func scene_tree(scene_path: String, depth: int, include_properties: bool) -> Dictionary:
+static func scene_tree(
+	scene_path: String, depth: int, include_properties: bool, include_defaults: bool
+) -> Dictionary:
 	var laid: Dictionary = _laid(scene_path)
 	if not laid.get("ok", false):
 		return laid
 	var nodes: Dictionary = laid["nodes"]
-	return {"ok": true, "tree": _entry(nodes, ".", include_properties, depth, 0)}
+	return {"ok": true, "tree": _entry(nodes, ".", include_properties, include_defaults, depth, 0)}
 
 
 ## The node at [param node_path] in [param scene_path] as {ok, name, type, properties}, laid as
@@ -176,6 +180,7 @@ static func _lay(
 				continue
 			else:
 				nodes[path] = _made(str(state.get_node_type(index)))
+				nodes[path]["madeHere"] = loaded != null
 			if ids[index] >= 0:
 				nodes[path]["uniqueId"] = ids[index]
 			# Laid at the root with no scene handed in is a scene the one being read inherits, and the
@@ -202,10 +207,15 @@ static func _lay(
 			if not grouped.has(str(group)):
 				grouped.append(str(group))
 		var held: Dictionary = nodes[path]["properties"]
+		# What the file being read sets, kept apart for a node another file makes, whose values read
+		# the same whether this scene changed them or that one gave them.
+		var laid: Dictionary = nodes[path]
+		var set_here: Array = laid.get_or_add("setHere", [])
 		for property: int in state.get_node_property_count(index):
-			held[str(state.get_node_property_name(index, property))] = state.get_node_property_value(
-				index, property
-			)
+			var named: String = str(state.get_node_property_name(index, property))
+			held[named] = state.get_node_property_value(index, property)
+			if loaded != null and not set_here.has(named):
+				set_here.append(named)
 	# Only the scene being read and the scenes it inherits share its root, the owner whose editable
 	# instances a write here sets; a file instanced below makes its own owner's editable.
 	if prefix == ".":
@@ -321,7 +331,12 @@ static func _joined(prefix: String, given: String) -> String:
 
 
 static func _entry(
-	nodes: Dictionary, path: String, include_properties: bool, depth: int, current_depth: int
+	nodes: Dictionary,
+	path: String,
+	include_properties: bool,
+	include_defaults: bool,
+	depth: int,
+	current_depth: int
 ) -> Dictionary:
 	var node: Dictionary = nodes[path]
 	var children: Array[Dictionary] = []
@@ -344,7 +359,21 @@ static func _entry(
 		data["groups"] = sorted
 	if include_properties:
 		var given: Dictionary = node["properties"]
-		data["properties"] = _stored(str(node["type"]), given)
+		var stored: Dictionary = _stored(str(node["type"]), given, include_defaults)
+		data["properties"] = stored["properties"]
+		if stored["left_out"] > 0:
+			data["defaultsLeftOut"] = stored["left_out"]
+		var cells: int = _cell_count(str(node["type"]), given)
+		if cells >= 0:
+			data["cellCount"] = cells
+			data["cellsListedBy"] = (
+				"scene_node get with nodePath %s, which lists them as set_tilemap_cells takes them" % path
+			)
+		if not node.get("madeHere", false):
+			var kept: Array = node.get("setHere", [])
+			var set_here: Array = kept.duplicate()
+			set_here.sort()
+			data["setHere"] = set_here
 	var below: Array[String] = node["children"]
 	# Counted rather than left as an empty list, which reads as a node with no children.
 	if depth >= 0 and current_depth >= depth:
@@ -352,19 +381,56 @@ static func _entry(
 			data["childrenNotListed"] = below.size()
 		return data
 	for child: String in below:
-		children.append(_entry(nodes, child, include_properties, depth, current_depth + 1))
+		children.append(_entry(nodes, child, include_properties, include_defaults, depth, current_depth + 1))
 	return data
 
 
+## How many cells a TileMapLayer or TileMap of [param type] holds under the values [param given], or
+## -1 when it is another node or the file sets none of its cells. The file keeps them as packed bytes,
+## which a read of the tree answered with alone, so a caller decoded the base64 to learn what was
+## painted. Only cells the file sets are counted: an instance's come from its own scene.
+static func _cell_count(type: String, given: Dictionary) -> int:
+	if not ClassDB.class_exists(type) or not ClassDB.can_instantiate(type):
+		return -1
+	var single: bool = ClassDB.is_parent_class(type, "TileMapLayer")
+	if not single and not ClassDB.is_parent_class(type, "TileMap"):
+		return -1
+	var painted: bool = false
+	for property: Variant in given:
+		var named: String = str(property)
+		if named == "tile_map_data" or (named.begins_with("layer_") and named.ends_with("/tile_data")):
+			painted = true
+	if not painted:
+		return -1
+	var bare: Node = ClassDB.instantiate(type)
+	for property: Variant in given:
+		if property != "script":
+			bare.set(str(property), given[property])
+	var count: int = 0
+	if single:
+		count = (bare as TileMapLayer).get_used_cells().size()
+	else:
+		var layered: TileMap = bare as TileMap
+		for layer: int in layered.get_layers_count():
+			count += layered.get_used_cells(layer).size()
+	bare.free()
+	return count
+
+
 ## Every property a node of [param type] stores, with the value [param given] sets or the default,
-## read as a node holding those values would answer them.
+## read as a node holding those values would answer them, as {properties, left_out}.
 ##
 ## The engine's half is read off a bare node of the class with the file's values set on it, which
 ## runs no script: what a node lists depends on its values (a thread group's settings appear only
 ## once it has one) and some setters set others (a Control's anchors preset sets how it grows), so
 ## the class's defaults and the file's entries alone answered neither. The script's half is its
 ## declared defaults under the file's values.
-static func _stored(type: String, given: Dictionary) -> Dictionary:
+##
+## Without [param include_defaults], properties keeps only what the file sets and what differs from
+## a node of the class holding none of its values, and left_out counts the rest. Every Control
+## carries a hundred properties, and ten of them came to 57 KB of defaults around the few values a
+## menu scene set.
+static func _stored(type: String, given: Dictionary, include_defaults: bool) -> Dictionary:
 	var attached: Variant = given.get("script")
 	var script: Script = attached if attached is Script else null
 	var scripted: Dictionary = {}
@@ -374,8 +440,10 @@ static func _stored(type: String, given: Dictionary) -> Dictionary:
 			if not property.is_empty() and GdhRead.as_int(declared.get("usage", 0)) & PROPERTY_USAGE_STORAGE:
 				scripted[property] = script.get_property_default_value(property)
 	var values: Dictionary = {}
+	var defaults: Dictionary = {}
 	if ClassDB.class_exists(type) and ClassDB.can_instantiate(type):
 		var bare: Object = ClassDB.instantiate(type)
+		var plain: Object = ClassDB.instantiate(type)
 		for property: Variant in given:
 			if property != "script" and not scripted.has(property):
 				bare.set(str(property), given[property])
@@ -383,18 +451,30 @@ static func _stored(type: String, given: Dictionary) -> Dictionary:
 			var property: String = str(declared.get("name", ""))
 			if not property.is_empty() and GdhRead.as_int(declared.get("usage", 0)) & PROPERTY_USAGE_STORAGE:
 				values[property] = bare.get(property)
-		if bare is Node:
-			bare.free()
+				defaults[property] = plain.get(property)
+		for made: Object in [bare, plain]:
+			if made is Node:
+				made.free()
 	for property: String in scripted:
 		values[property] = scripted[property]
+		defaults[property] = scripted[property]
 	# Given last, which keeps what a bare node cannot hold: the script itself, and a path to a node
 	# for a property that holds the node once it is in a tree.
 	values.merge(given, true)
 	var serialiser: GdhSerialisation = GdhSerialisation.new()
 	var answered: Dictionary = {}
+	var left_out: int = 0
 	for property: Variant in values:
+		var as_default: bool = (
+			not given.has(property)
+			and defaults.has(property)
+			and GdhSame.same(values[property], defaults[property])
+		)
+		if as_default and not include_defaults:
+			left_out += 1
+			continue
 		answered[property] = serialiser.serialize_value(values[property])
-	return answered
+	return {"properties": answered, "left_out": left_out}
 
 
 ## What a resource file holds, in the form modify takes, so a value read here can be written back.
@@ -407,12 +487,16 @@ static func resource(res_path: String, include_defaults: bool) -> Dictionary:
 	var file: String = res_path.get_slice("::", 0)
 	if not FileAccess.file_exists(file):
 		return {"ok": false, "error": "No resource at " + file}
-	var loaded: Resource = ResourceLoader.load(file, "", ResourceLoader.CACHE_MODE_IGNORE)
-	if loaded == null:
+	var whole: Resource = ResourceLoader.load(file, "", ResourceLoader.CACHE_MODE_IGNORE)
+	if whole == null:
 		return {"ok": false, "error": "%s did not load as a resource." % file}
+	# The file's resource is held until the read is done, since what it keeps can depend on it: a
+	# TileSet that goes unlinks its sources, and an atlas source with no TileSet lists none of its
+	# tiles' physics, navigation or custom data.
+	var loaded: Resource = whole
 	if file != res_path:
 		var id: String = res_path.trim_prefix(file + "::")
-		var inner: Resource = _kept_in(loaded, file, id, {})
+		var inner: Resource = _kept_in(whole, file, id, {})
 		if inner == null:
 			return {"ok": false, "error": "%s keeps no resource with the id %s." % [file, id]}
 		loaded = inner

package/build/godot/operations/gdscript_authoring.gd

@@ -505,7 +505,17 @@ func _add_constant(lines: Array[String], mod: Dictionary, placed: Array[Dictiona
 			or line.begins_with("class ")
 		):
 			break
-	return after if _insert(lines, after, [const_line], placed) else -1
+	after = _past_class_doc(lines, after)
+	# Set apart from the header or the signals above and from what follows, as the style guide lays
+	# out its groups; one below the constants already there joins them.
+	var block: Array[String] = [const_line]
+	var above: String = lines[after - 1].strip_edges() if after > 0 else ""
+	var below: String = lines[after].strip_edges() if after < lines.size() else ""
+	if not above.is_empty() and not GdhPatterns.without_annotations(above).begins_with("const "):
+		block.push_front("")
+	if not below.is_empty() and not GdhPatterns.without_annotations(below).begins_with("const "):
+		block.push_back("")
+	return after + block.find(const_line) if _insert(lines, after, block, placed) else -1
 
 
 # Inserts the declaration and answers with its zero-based index, or -1 for one that could not be placed.

package/build/godot/operations/godot_operations.gd

@@ -24,6 +24,7 @@ const GdhFileReads = preload("file_reads.gd")
 const GdhGdscriptAnalysis = preload("gdscript_analysis.gd")
 const GdhGdscriptAuthoring = preload("gdscript_authoring.gd")
 const GdhImportPipeline = preload("import_pipeline.gd")
+const GdhProjectValidation = preload("project_validation.gd")
 const GdhInputActions = preload("input_actions.gd")
 const GdhLog = preload("logger.gd")
 const GdhPlugins = preload("plugins.gd")
@@ -51,6 +52,8 @@ const BEGUN: String = "[gdharness] begun"
 const AFTER_THE_AUTOLOADS: Array[String] = [
 	"check_scripts",
 	"create_script",
+	# An exporter made in _init, before an editor's main loop has started, crashed the engine.
+	"export_options",
 	"modify_script",
 	"read_animation_states",
 	"read_animations",
@@ -188,7 +191,8 @@ func _run(operation: String, params: Dictionary) -> Dictionary:
 				GdhFileReads.scene_tree(
 					str(params.get("scene_path", "")),
 					GdhRead.as_int(params.get("depth", -1), -1),
-					GdhRead.as_bool(params.get("include_properties", false))
+					GdhRead.as_bool(params.get("include_properties", false)),
+					GdhRead.as_bool(params.get("include_defaults", false))
 				)
 			)
 		"read_resource":
@@ -229,8 +233,14 @@ func _run(operation: String, params: Dictionary) -> Dictionary:
 			payload = GdhExportPresets.new(_log).list_export_presets(params)
 		"add_export_preset":
 			payload = GdhExportPresets.new(_log).add_export_preset(params)
+		"set_export_preset":
+			payload = GdhExportPresets.new(_log).set_export_preset(params)
+		"remove_export_preset":
+			payload = GdhExportPresets.new(_log).remove_export_preset(params)
+		"export_options":
+			payload = GdhExportPresets.new(_log).export_options(params)
 		"validate_project":
-			payload = GdhImportPipeline.new(_log).validate_project(params)
+			payload = GdhProjectValidation.new(_log).validate_project(params)
 
 		# Dependencies and project inspection
 		"get_dependencies":
@@ -295,6 +305,10 @@ func _run(operation: String, params: Dictionary) -> Dictionary:
 			payload = GdhAudioBuses.new(_log).set_audio_bus_effect(params)
 		"set_audio_bus_volume":
 			payload = GdhAudioBuses.new(_log).set_audio_bus_volume(params)
+		"rename_audio_bus":
+			payload = GdhAudioBuses.new(_log).rename_audio_bus(params)
+		"set_audio_bus_send":
+			payload = GdhAudioBuses.new(_log).set_audio_bus_send(params)
 
 		# ClassDB
 		"query_classes":

package/build/godot/operations/import_pipeline.gd

@@ -1,8 +1,5 @@
 extends RefCounted
 
-const GdhDependencies = preload("dependencies.gd")
-const GdhExportPresets = preload("export_presets.gd")
-const GdhScriptCheck = preload("script_check.gd")
 const GdhRead = preload("reading.gd")
 const GdhSerialisation = preload("serialisation.gd")
 const GdhFileWalk = preload("file_walk.gd")
@@ -40,7 +37,14 @@ const IMPORTABLE_EXTENSIONS: Array[String] = [
 	"fbx",
 	"obj",
 	"dae",
+	"csv",
+	"glsl",
 ]
+## What the engine imports through Blender, which it finds only through an editor setting. With the
+## setting unset, a headless import stops at the first of these and imports nothing after it.
+const BLENDER_EXTENSIONS: Array[String] = ["blend"]
+const BLENDER_SETTING: String = "filesystem/import/blender/blender_path"
+const BLENDER_ENABLED: String = "filesystem/import/blender/enabled"
 ## The format version each importer writes as `importer_version` where it is above 0, which the
 ## editor reimports anything older than. Read off sidecars 4.7.2 writes: scene and animation_library
 ## write 1, and the texture importers write none. A case imports one fresh and compares, so an engine
@@ -348,224 +352,6 @@ static func _all_ints(held: Variant, keys: bool) -> bool:
 	return true
 
 
-# Validate project for export
-func validate_project(params: Dictionary) -> Dictionary:
-	var preset_name: String = str(params.get("preset", ""))
-	var include_suggestions: bool = GdhRead.as_bool(params.get("include_suggestions", true), true)
-
-	_log.info("Validating project" + (" for preset: " + preset_name if not preset_name.is_empty() else ""))
-
-	var issues: Array[Dictionary] = []
-	var warnings: Array[Dictionary] = []
-	var checks_performed: Array[String] = []
-
-	checks_performed.append("project_file")
-	if not FileAccess.file_exists("res://project.godot"):
-		issues.append(
-			_finding(
-				"error",
-				"project_file",
-				"project.godot not found",
-				"Ensure you are running this from a valid Godot project directory",
-				include_suggestions
-			)
-		)
-
-	checks_performed.append("main_scene")
-	var main_scene: String = str(ProjectSettings.get_setting("application/run/main_scene", ""))
-	if main_scene.is_empty():
-		issues.append(
-			_finding(
-				"error",
-				"main_scene",
-				"No main scene set",
-				"Set a main scene in Project Settings > Application > Run > Main Scene",
-				include_suggestions
-			)
-		)
-	elif not GdhFileWalk.missing_reason(main_scene).is_empty():
-		issues.append(
-			_finding(
-				"error",
-				"main_scene",
-				"Main scene " + GdhFileWalk.missing_reason(main_scene),
-				"Update the main scene setting or create the missing scene file",
-				include_suggestions
-			)
-		)
-
-	# A file never imported is on disk, so the reference checks pass it, and still nothing loads it:
-	# a scene using one fails to load in a run or an export.
-	checks_performed.append("imports")
-	var never: Array[String] = []
-	for path: String in _files.find_files_with_extensions("res://", IMPORTABLE_EXTENSIONS):
-		if not FileAccess.file_exists(path + ".import"):
-			never.append(path)
-	if not never.is_empty():
-		never.sort()
-		warnings.append(
-			_finding(
-				"warning",
-				"imports",
-				never_imported_line(never),
-				"Run project_import reimport, or open the project in the editor, whose scan imports them",
-				include_suggestions
-			)
-		)
-
-	checks_performed.append("export_presets")
-	if not FileAccess.file_exists("res://export_presets.cfg"):
-		warnings.append(
-			_finding(
-				"warning",
-				"export_presets",
-				"No export presets configured",
-				"Add a preset with project_export add_preset, or in the editor: Project > Export",
-				include_suggestions
-			)
-		)
-
-	# The preset asked about is looked for rather than only logged: validating "for" a preset that
-	# does not exist answered valid, as though it had been checked.
-	if not preset_name.is_empty():
-		checks_performed.append("export_preset")
-		var named: Array[String] = GdhExportPresets.names()
-		if preset_name not in named:
-			issues.append(
-				_finding(
-					"error",
-					"export_preset",
-					(
-						"No export preset is named "
-						+ preset_name
-						+ (
-							": the project has none"
-							if named.is_empty()
-							else ": the presets are " + ", ".join(named)
-						)
-					),
-					"Pass one of the preset names, or add the preset with project_export add_preset",
-					include_suggestions
-				)
-			)
-
-	checks_performed.append("icon")
-	var icon_path: String = str(ProjectSettings.get_setting("application/config/icon", ""))
-	if icon_path.is_empty():
-		warnings.append(
-			_finding(
-				"warning",
-				"icon",
-				"No application icon set",
-				"Set an icon in Project Settings > Application > Config > Icon",
-				include_suggestions
-			)
-		)
-	elif not FileAccess.file_exists(icon_path):
-		warnings.append(
-			_finding(
-				"warning",
-				"icon",
-				"Icon file does not exist: " + icon_path,
-				"Update the icon path or add the missing icon file",
-				include_suggestions
-			)
-		)
-
-	checks_performed.append("project_name")
-	var project_name: String = str(ProjectSettings.get_setting("application/config/name", ""))
-	if project_name.is_empty():
-		warnings.append(
-			_finding(
-				"warning",
-				"project_name",
-				"No project name set",
-				"Set a project name in Project Settings > Application > Config > Name",
-				include_suggestions
-			)
-		)
-
-	checks_performed.append("scripts")
-	var script_files: Array[String] = _files.find_files_with_extensions("res://", ["gd"])
-	var scripts_checked: int = 0
-	var script_issues: Array[Dictionary] = []
-
-	# A hundred scripts is enough to say whether the project is tidy without a large one
-	# turning validation into a full read of its source tree.
-	for script_path: String in script_files.slice(0, 100):
-		scripts_checked += 1
-		var file: FileAccess = FileAccess.open(script_path, FileAccess.READ)
-		if file:
-			var content: String = file.get_as_text()
-			file.close()
-
-			if "# TODO" in content or "# FIXME" in content:
-				script_issues.append({"path": script_path, "issue": "Contains TODO/FIXME comments"})
-			if "pass # TODO" in content:
-				script_issues.append({"path": script_path, "issue": "Contains unimplemented functions"})
-
-	# Compiled by the server and handed in, as for the health check: a script the engine refuses
-	# stops the export's game at the first scene using it, which the comment check above never saw.
-	var compiled: Dictionary = params.get("compiled", {})
-	if compiled.has("checked"):
-		checks_performed.append("compiles")
-	var failures: Array = compiled.get("failures", [])
-	for failure: Dictionary in failures:
-		issues.append(
-			_finding(
-				"error",
-				"compiles",
-				GdhScriptCheck.failure_line(failure),
-				"script_diagnostics gives every error in it with its line",
-				include_suggestions
-			)
-		)
-
-	checks_performed.append("references")
-	for entry: Dictionary in GdhDependencies.new(_log).missing_references():
-		issues.append(
-			_finding(
-				"error",
-				"references",
-				GdhDependencies.missing_line(entry),
-				"Restore the file, or point the reference at the file that replaced it",
-				include_suggestions
-			)
-		)
-
-	if script_issues.size() > 0:
-		var warning: Dictionary = _finding(
-			"warning",
-			"scripts",
-			str(script_issues.size()) + " script issues found",
-			"Review and resolve TODO/FIXME items before release",
-			include_suggestions
-		)
-		warning["details"] = script_issues.slice(0, 5)
-		warnings.append(warning)
-
-	return {
-		"valid": issues.is_empty(),
-		"issues": issues,
-		"warnings": warnings,
-		"checks_performed": checks_performed,
-		"scripts_checked": scripts_checked,
-		# Said beside the count, so a project of four hundred scripts is not read as checked whole.
-		"scripts_total": script_files.size(),
-		"issue_count": issues.size(),
-		"warning_count": warnings.size()
-	}
-
-
-func _finding(
-	type: String, check: String, message: String, suggestion: String, include_suggestion: bool
-) -> Dictionary:
-	var finding: Dictionary = {"type": type, "check": check, "message": message}
-	if include_suggestion:
-		finding["suggestion"] = suggestion
-	return finding
-
-
 func _tally(summary: Dictionary, status: Dictionary) -> void:
 	summary["total"] += 1
 	var state: String = status["status"]
@@ -662,6 +448,19 @@ func _never_imported(resource_path: String) -> String:
 	var extension: String = resource_path.get_extension().to_lower()
 	if extension in IMPORTABLE_EXTENSIONS:
 		return ""
+	if extension in BLENDER_EXTENSIONS:
+		if not ProjectSettings.get_setting(BLENDER_ENABLED, true):
+			return "the project sets " + BLENDER_ENABLED + " to false, so the engine leaves them unimported"
+		return (
+			"the engine imports ."
+			+ extension
+			+ " files through Blender, which it finds through the editor setting "
+			+ BLENDER_SETTING
+			+ ". An editor with it set imports them on its scan; an import pass with it unset stops at"
+			+ " the first one and imports nothing, and setting "
+			+ BLENDER_ENABLED
+			+ " to false has the engine leave them unimported"
+		)
 	# Loadable without a sidecar is what a scene, a script or a saved resource is: read as it is.
 	if ResourceLoader.exists(resource_path):
 		return "the engine loads ." + extension + " files as they are, without importing them"