gdharness 1.2.34 → 1.2.36

package/build/godot/operations/export_presets.gd

@@ -0,0 +1,232 @@
+extends RefCounted
+
+## export_presets.cfg, read and written in the format the editor's Project > Export saves it in.
+
+const Read = preload("reading.gd")
+const Log = preload("logger.gd")
+
+const PRESETS_FILE: String = "res://export_presets.cfg"
+## Where the editor names the one preset of each platform it runs on a device.
+const RUNNABLE_SECTION: String = "runnable_presets"
+## The platforms the editor's exporter offers, by the name a preset gives its platform, each with
+## how the names of its files in the export templates directory begin.
+const PLATFORMS: Dictionary[String, String] = {
+	"Windows Desktop": "windows_",
+	"Linux": "linux_",
+	"macOS": "macos",
+	"Android": "android_",
+	"iOS": "ios",
+	"Web": "web_",
+}
+
+var _log: Log
+
+
+func _init(p_log: Log) -> void:
+	_log = p_log
+
+
+## The names of the project's export presets, in the order export_presets.cfg holds them.
+static func names() -> Array[String]:
+	var named: Array[String] = []
+	var config: ConfigFile = ConfigFile.new()
+	if config.load(PRESETS_FILE) != OK:
+		return named
+	var index: int = 0
+	while config.has_section("preset." + str(index)):
+		named.append(str(config.get_value("preset." + str(index), "name", "")))
+		index += 1
+	return named
+
+
+func list_export_presets(_params: Dictionary) -> Dictionary:
+	if not FileAccess.file_exists(PRESETS_FILE):
+		return {
+			"presets": [],
+			"presets_file_exists": false,
+			"note":
+			(
+				"No export_presets.cfg found. project_export add_preset adds a preset, as the editor's "
+				+ "Project > Export does."
+			)
+		}
+	var config: ConfigFile = ConfigFile.new()
+	var err: Error = config.load(PRESETS_FILE)
+	if err != OK:
+		return _log.failure("Failed to parse export_presets.cfg: " + error_string(err))
+
+	var templates: String = _templates_dir()
+	var presets: Array[Dictionary] = []
+	var index: int = 0
+	while config.has_section("preset." + str(index)):
+		var section: String = "preset." + str(index)
+		var platform: String = str(config.get_value(section, "platform", "Unknown"))
+		var preset: Dictionary = {
+			"index": index,
+			"name": config.get_value(section, "name", "Unknown"),
+			"platform": platform,
+			"runnable": _runnable(config, section),
+			"export_path": config.get_value(section, "export_path", ""),
+			"export_filter": config.get_value(section, "export_filter", "all_resources"),
+			"include_filter": config.get_value(section, "include_filter", ""),
+			"exclude_filter": config.get_value(section, "exclude_filter", "")
+		}
+		if config.has_section_key(section, "custom_features"):
+			preset["custom_features"] = config.get_value(section, "custom_features", "")
+		# Left out for a platform this file names and the exporter does not know, which has no
+		# templates to look for.
+		if platform in PLATFORMS:
+			preset["templates_installed"] = _installed(templates, platform)
+		presets.append(preset)
+		index += 1
+	return {"presets": presets, "presets_file_exists": true, "total_presets": index, "templates": templates}
+
+
+## Whether the preset in [param section] is the one its platform runs. The editor names that preset
+## in a section of its own, and kept a key in the preset's section only in files saved before that.
+static func _runnable(config: ConfigFile, section: String) -> bool:
+	var platform: String = str(config.get_value(section, "platform", ""))
+	if config.has_section_key(RUNNABLE_SECTION, platform):
+		return str(config.get_value(RUNNABLE_SECTION, platform)) == str(config.get_value(section, "name", ""))
+	return Read.as_bool(config.get_value(section, "runnable", false))
+
+
+## Adds an export preset to export_presets.cfg, written with the keys the editor's Project > Export
+## writes for a new one. The editor's exporter fills every platform option the file leaves out with
+## its default when it loads the file, which is what a preset fresh from that dialog holds too.
+func add_export_preset(params: Dictionary) -> Dictionary:
+	var preset_name: String = str(params.get("preset", "")).strip_edges()
+	var platform: String = str(params.get("platform", ""))
+	var export_path: String = str(params.get("output_path", "")).trim_prefix("res://")
+	if preset_name.is_empty():
+		return _log.failure("preset is required: the name the preset is exported by")
+	if platform not in PLATFORMS:
+		return _log.failure(
+			"Unknown platform '%s'. The platforms are %s." % [platform, ", ".join(PLATFORMS.keys())]
+		)
+	var config: ConfigFile = ConfigFile.new()
+	if FileAccess.file_exists(PRESETS_FILE):
+		var loading: Error = config.load(PRESETS_FILE)
+		if loading != OK:
+			return _log.failure("Failed to parse export_presets.cfg: " + error_string(loading))
+	var index: int = 0
+	while config.has_section("preset." + str(index)):
+		var held: String = "preset." + str(index)
+		if str(config.get_value(held, "name", "")) == preset_name:
+			return _log.failure(
+				(
+					(
+						"There is already an export preset named '%s', for %s, exporting to '%s'. "
+						+ "project_export run exports with it; give another name to add a second."
+					)
+					% [
+						preset_name,
+						config.get_value(held, "platform", ""),
+						config.get_value(held, "export_path", "")
+					]
+				)
+			)
+		index += 1
+	# A platform with no preset to run takes the new one, as the editor's dialog does.
+	var runnable: bool = not config.has_section_key(RUNNABLE_SECTION, platform)
+	if runnable:
+		config.set_value(RUNNABLE_SECTION, platform, preset_name)
+
+	var section: String = "preset." + str(index)
+	var values: Dictionary = {
+		"name": preset_name,
+		"platform": platform,
+		"dedicated_server": false,
+		"custom_features": "",
+		"export_filter": "all_resources",
+		"include_filter": "",
+		"exclude_filter": "",
+		"export_path": export_path,
+		"patches": PackedStringArray(),
+		"encryption_include_filters": "",
+		"encryption_exclude_filters": "",
+		"seed": 0,
+		"encrypt_pck": false,
+		"encrypt_directory": false,
+		"script_export_mode": 2,
+	}
+	for key: String in values:
+		config.set_value(section, key, values[key])
+	# A section with nothing in it is not written, and the editor's loader reports a missing options
+	# section as an error; these two are options of every platform, empty in a new preset.
+	config.set_value(section + ".options", "custom_template/debug", "")
+	config.set_value(section + ".options", "custom_template/release", "")
+	var saving: Error = config.save(PRESETS_FILE)
+	if saving != OK:
+		return _log.failure("Failed to save export_presets.cfg: " + error_string(saving))
+
+	var templates: String = _templates_dir()
+	var installed: bool = _installed(templates, platform)
+	var answer: Dictionary = {
+		"preset": preset_name,
+		"platform": platform,
+		"index": index,
+		"runnable": runnable,
+		"export_path": export_path,
+		"file": PRESETS_FILE,
+		"templates": templates,
+		"templates_installed": installed,
+	}
+	if not installed:
+		answer["templates_note"] = (
+			(
+				"No %s export templates for this engine are at %s, and an export for %s needs them. The "
+				+ "editor installs them in Editor > Manage Export Templates, or they can be unpacked "
+				+ "there from the export templates archive of this engine's release."
+			)
+			% [platform, templates, platform]
+		)
+	return answer
+
+
+## Where the editor of this engine keeps its export templates: beside the executable for a
+## self-contained one, otherwise in the user's data directory, as the editor's own paths have it.
+static func _templates_dir() -> String:
+	var version: Dictionary = Engine.get_version_info()
+	var named: String = "%d.%d" % [Read.as_int(version.get("major", 0)), Read.as_int(version.get("minor", 0))]
+	if Read.as_int(version.get("patch", 0)) != 0:
+		named += "." + str(Read.as_int(version.get("patch", 0)))
+	named += "." + str(version.get("status", ""))
+	if ClassDB.class_exists("CSharpScript"):
+		named += ".mono"
+	var beside: String = OS.get_executable_path().get_base_dir()
+	var contained: bool = _marks_self_contained(beside)
+	# A macOS bundle is read-only, so its editor looks for the marker beside the bundle too, and keeps
+	# its data there whichever of the two places had it.
+	if (
+		OS.has_feature("macos")
+		and beside.ends_with("MacOS")
+		and beside.path_join("..").simplify_path().ends_with("Contents")
+	):
+		beside = beside.path_join("../../..").simplify_path()
+		contained = contained or _marks_self_contained(beside)
+	if contained:
+		return beside.path_join("editor_data").path_join("export_templates").path_join(named)
+	var home: String = (
+		"godot" if OS.get_name() in ["Linux", "FreeBSD", "NetBSD", "OpenBSD", "BSD"] else "Godot"
+	)
+	return OS.get_data_dir().path_join(home).path_join("export_templates").path_join(named)
+
+
+## Whether [param templates] holds any of [param platform]'s templates. The directory is one per
+## engine version and holds whichever platforms were installed into it, so its being there says
+## nothing about this platform.
+static func _installed(templates: String, platform: String) -> bool:
+	if not DirAccess.dir_exists_absolute(templates):
+		return false
+	for file: String in DirAccess.get_files_at(templates):
+		if file.begins_with(PLATFORMS[platform]):
+			return true
+	return false
+
+
+static func _marks_self_contained(directory: String) -> bool:
+	return (
+		FileAccess.file_exists(directory.path_join("._sc_"))
+		or FileAccess.file_exists(directory.path_join("_sc_"))
+	)

package/build/godot/operations/gdscript_analysis.gd

@@ -1,10 +1,13 @@
 extends RefCounted
 
+const Dependencies = preload("dependencies.gd")
 const Patterns = preload("patterns.gd")
 const Read = preload("reading.gd")
 const Log = preload("logger.gd")
 
 var _log: Log
+## Kept for the call, so the project's class names are read once however many bases are walked.
+var _dependencies: Dependencies = null
 
 
 func _init(p_log: Log) -> void:
@@ -136,6 +139,21 @@ func get_gdscript_info(params: Dictionary) -> Dictionary:
 	# its first function would otherwise be judged against the default.
 	_mark_virtuals(functions, extends_name, full_script_path)
 
+	# A script typed by its class_name is depended on as surely as one preloaded, and the answer
+	# listed only the preloads: a `var stats: Stats` left stats.gd out, while project_dependencies
+	# named it. The same reading as that tool's, so the two agree.
+	var classes_used: Array[Dictionary] = []
+	if _dependencies == null:
+		_dependencies = Dependencies.new(_log)
+	var declared_by: Dictionary = _dependencies.classes_declared()
+	for used: String in Dependencies.classes_used_in(content, declared_by):
+		var declaring: String = str(declared_by[used])
+		if declaring == full_script_path:
+			continue
+		classes_used.append({"name": used, "path": declaring})
+		if not declaring in dependencies:
+			dependencies.append(declaring)
+
 	var answer: Dictionary = {
 		"path": script_path,
 		"full_path": full_script_path,
@@ -148,6 +166,7 @@ func get_gdscript_info(params: Dictionary) -> Dictionary:
 		"enums": enums,
 		"inner_classes": inner_classes,
 		"dependencies": dependencies,
+		"classes_used": classes_used,
 		"line_count": lines.size()
 	}
 	if Read.as_bool(params.get("include_inherited", false)):

package/build/godot/operations/godot_operations.gd

@@ -19,6 +19,7 @@ const AudioBuses = preload("audio_buses.gd")
 const ClassCache = preload("class_cache.gd")
 const ClassDbQueries = preload("classdb_queries.gd")
 const Dependencies = preload("dependencies.gd")
+const ExportPresets = preload("export_presets.gd")
 const FileReads = preload("file_reads.gd")
 const GdscriptAnalysis = preload("gdscript_analysis.gd")
 const GdscriptAuthoring = preload("gdscript_authoring.gd")
@@ -31,6 +32,7 @@ const ProjectDiagnostics = preload("project_diagnostics.gd")
 const Read = preload("reading.gd")
 const RenameChecks = preload("rename_checks.gd")
 const ResourceFiles = preload("resource_files.gd")
+const ScriptCheck = preload("script_check.gd")
 
 ## Printed once the answer is written, after which the engine runs the project's autoloads. Kept in
 ## step with `ANSWERED` in src/headless.ts.
@@ -179,7 +181,9 @@ func _run(operation: String, params: Dictionary) -> Dictionary:
 		"set_import_options":
 			payload = ImportPipeline.new(_log).set_import_options(params)
 		"list_export_presets":
-			payload = ImportPipeline.new(_log).list_export_presets(params)
+			payload = ExportPresets.new(_log).list_export_presets(params)
+		"add_export_preset":
+			payload = ExportPresets.new(_log).add_export_preset(params)
 		"validate_project":
 			payload = ImportPipeline.new(_log).validate_project(params)
 
@@ -215,7 +219,7 @@ func _run(operation: String, params: Dictionary) -> Dictionary:
 		"names_taken":
 			payload = RenameChecks.new(_log).names_taken(params)
 		"check_scripts":
-			payload = RenameChecks.new(_log).check_scripts(params)
+			payload = ScriptCheck.new(_log).check_scripts(params)
 
 		# Plugins and input
 		"list_plugins":

package/build/godot/operations/import_pipeline.gd

@@ -1,5 +1,6 @@
 extends RefCounted
 
+const ExportPresets = preload("export_presets.gd")
 const Read = preload("reading.gd")
 const Serialisation = preload("serialisation.gd")
 const FileWalk = preload("file_walk.gd")
@@ -319,63 +320,6 @@ static func _all_ints(held: Variant, keys: bool) -> bool:
 	return true
 
 
-# The names of the project's export presets, in the order export_presets.cfg holds them.
-static func _preset_names() -> Array[String]:
-	var names: Array[String] = []
-	var config: ConfigFile = ConfigFile.new()
-	if config.load("res://export_presets.cfg") != OK:
-		return names
-	var index: int = 0
-	while config.has_section("preset." + str(index)):
-		names.append(str(config.get_value("preset." + str(index), "name", "")))
-		index += 1
-	return names
-
-
-# List export presets
-func list_export_presets(_params: Dictionary) -> Dictionary:
-	_log.info("Listing export presets")
-
-	var presets_file: String = "res://export_presets.cfg"
-
-	if not FileAccess.file_exists(presets_file):
-		return {
-			"presets": [],
-			"presets_file_exists": false,
-			"note": "No export_presets.cfg found. Configure export presets in the Godot editor."
-		}
-
-	var config: ConfigFile = ConfigFile.new()
-	var err: Error = config.load(presets_file)
-
-	if err != OK:
-		return _log.failure("Failed to parse export_presets.cfg: " + str(err))
-
-	# Export presets are stored as [preset.0], [preset.1], etc.
-	var presets: Array[Dictionary] = []
-	var preset_idx: int = 0
-	while config.has_section("preset." + str(preset_idx)):
-		var section: String = "preset." + str(preset_idx)
-		var preset: Dictionary = {
-			"index": preset_idx,
-			"name": config.get_value(section, "name", "Unknown"),
-			"platform": config.get_value(section, "platform", "Unknown"),
-			"runnable": config.get_value(section, "runnable", false),
-			"export_path": config.get_value(section, "export_path", ""),
-			"export_filter": config.get_value(section, "export_filter", "all_resources"),
-			"include_filter": config.get_value(section, "include_filter", ""),
-			"exclude_filter": config.get_value(section, "exclude_filter", "")
-		}
-
-		if config.has_section_key(section, "custom_features"):
-			preset["custom_features"] = config.get_value(section, "custom_features", "")
-
-		presets.append(preset)
-		preset_idx += 1
-
-	return {"presets": presets, "presets_file_exists": true, "total_presets": preset_idx}
-
-
 # Validate project for export
 func validate_project(params: Dictionary) -> Dictionary:
 	var preset_name: String = str(params.get("preset", ""))
@@ -429,7 +373,7 @@ func validate_project(params: Dictionary) -> Dictionary:
 				"warning",
 				"export_presets",
 				"No export presets configured",
-				"Configure export presets in Godot editor: Project > Export",
+				"Add a preset with project_export add_preset, or in the editor: Project > Export",
 				include_suggestions
 			)
 		)
@@ -438,7 +382,7 @@ func validate_project(params: Dictionary) -> Dictionary:
 	# 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] = _preset_names()
+		var named: Array[String] = ExportPresets.names()
 		if preset_name not in named:
 			issues.append(
 				_finding(
@@ -453,7 +397,7 @@ func validate_project(params: Dictionary) -> Dictionary:
 							else ": the presets are " + ", ".join(named)
 						)
 					),
-					"Pass one of the preset names, or add the preset in the editor: Project > Export",
+					"Pass one of the preset names, or add the preset with project_export add_preset",
 					include_suggestions
 				)
 			)

package/build/godot/operations/project_diagnostics.gd

@@ -148,7 +148,9 @@ func get_project_health(params: Dictionary) -> Dictionary:
 		recommendations.append("Address critical issues to improve project stability")
 	# A project still being made has no presets yet, which is no fault in it.
 	if "config" in check_categories and not FileAccess.file_exists("res://export_presets.cfg"):
-		recommendations.append("No export presets are configured: add them before exporting")
+		recommendations.append(
+			"No export presets are configured: project_export add_preset adds one before exporting"
+		)
 
 	# Every detail costs points, so each is an issue; `issues` was always empty beside them, and a
 	# category said passed next to the failure it had just found.

package/build/godot/operations/rename_checks.gd

@@ -1,6 +1,5 @@
 extends RefCounted
 
-const GdscriptAuthoring = preload("gdscript_authoring.gd")
 const Log = preload("logger.gd")
 
 var _log: Log
@@ -63,21 +62,3 @@ static func _named(entries: Array[Dictionary], name: String) -> bool:
 		if str(entry.get("name", "")) == name:
 			return true
 	return false
-
-
-# Whether each script compiles in a fresh engine, which reads the class cache as it starts and so
-# resolves every class the cache lists. The engine's reasons go to stderr and come back with the
-# answer. It names the scripts it checked rather than counting them, since a caller told one was
-# checked could not say which.
-func check_scripts(params: Dictionary) -> Dictionary:
-	var paths: Array = params.get("paths", [])
-	var checked: Array[String] = []
-	var failed: Array[String] = []
-	for value: Variant in paths:
-		var path: String = str(value)
-		checked.append(path)
-		var script: Script = ResourceLoader.load(path, "Script", ResourceLoader.CACHE_MODE_IGNORE)
-		if not GdscriptAuthoring._parses(script):
-			_log.error("Does not compile: " + path)
-			failed.append(path)
-	return {"checked": checked, "failed": failed}

package/build/godot/operations/script_check.gd

@@ -0,0 +1,98 @@
+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.
+##
+## 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 Read = preload("reading.gd")
+const Log = preload("logger.gd")
+
+## Where the engine raises a script's compile errors from.
+const RELOAD: String = "GDScript::reload"
+
+var _log: Log
+
+
+## Every compile error the engine raises while it is attached, in order.
+class Caught:
+	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: Log) -> void:
+	_log = p_log
+
+
+## Whether the scripts in [code]paths[/code] compile in a fresh engine, which reads the class cache
+## as it starts and so resolves every class the cache lists, up to and including the first that
+## raised an error. [code]checked[/code] names the scripts read, in order, and [code]failed[/code]
+## those that did not compile; [code]scripts[/code] holds each failed one with the errors raised in
+## its own file, and the other scripts that failed to compile while it was loaded. Read past the
+## resource cache, so a script loaded for an earlier one is compiled again for its own entry.
+func check_scripts(params: Dictionary) -> Dictionary:
+	var asked: Array = params.get("paths", [])
+	var caught: Caught = Caught.new()
+	OS.add_logger(caught)
+	var checked: Array[String] = []
+	var failed: Array[String] = []
+	var scripts: Array[Dictionary] = []
+	for entry: Variant in asked:
+		var path: String = str(entry)
+		checked.append(path)
+		caught.raised.clear()
+		var loaded: Resource = ResourceLoader.load(path, "", ResourceLoader.CACHE_MODE_IGNORE)
+		var errors: Array[Dictionary] = []
+		var others: Array[String] = []
+		for error: Dictionary in caught.raised:
+			var at: String = str(error["path"])
+			if at != path:
+				if not at in others:
+					others.append(at)
+				continue
+			var found: Dictionary = {"line": Read.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."})
+		if errors.is_empty() and others.is_empty():
+			continue
+		if not errors.is_empty():
+			failed.append(path)
+			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}