gdharness 1.2.36 → 1.2.38

package/build/godot/operations/editor_tools.gd

@@ -0,0 +1,57 @@
+extends RefCounted
+
+## The editor addon's scene and resource tools, run by a headless engine for a project no editor
+## serves.
+##
+## They are the editor's own scripts, loaded from beside these operations in the package, so a write
+## made here passes the same checks and answers in the same shape. What the engine does that an
+## editor does not, running every script, is put back in scene_file.gd and headless_check.gd.
+
+const ResourceTools = preload("../addons/gdharness_editor/tools/resource_tools.gd")
+const SceneTools = preload("../addons/gdharness_editor/tools/scene_tools.gd")
+
+const SCENE_COMMANDS: Array[String] = [
+	"create_scene",
+	"save_scene",
+	"add_node",
+	"get_node_properties",
+	"set_node_properties",
+	"duplicate_node",
+	"reparent_node",
+	"delete_node",
+	"connect_signal",
+	"disconnect_signal",
+	"list_connections",
+]
+const RESOURCE_COMMANDS: Array[String] = [
+	"set_tilemap_cells",
+	"create_resource",
+	"modify_resource",
+	"create_shader",
+	"create_tileset",
+	"set_theme_color",
+	"set_theme_font_size",
+]
+
+
+## Runs the tool [code]command[/code] names with [code]arguments[/code], answering what it answers.
+static func run(params: Dictionary) -> Dictionary:
+	var command: String = str(params.get("command", ""))
+	var given: Variant = params.get("arguments", {})
+	if not given is Dictionary:
+		return {"ok": false, "error": "arguments must be an object."}
+	var arguments: Dictionary = given
+	var tools: Node = null
+	if command in SCENE_COMMANDS:
+		tools = SceneTools.new()
+	elif command in RESOURCE_COMMANDS:
+		tools = ResourceTools.new()
+	else:
+		return {"ok": false, "error": "No editor tool runs headless as " + command}
+	var answer: Variant = tools.call(command, arguments)
+	tools.free()
+	if answer is Dictionary:
+		return answer
+	return {
+		"ok": false, "error": "%s answered %s rather than an object." % [command, type_string(typeof(answer))]
+	}

package/build/godot/operations/gdscript_analysis.gd

@@ -154,6 +154,21 @@ func get_gdscript_info(params: Dictionary) -> Dictionary:
 		if not declaring in dependencies:
 			dependencies.append(declaring)
 
+	# An autoload is named the way a class is, and its script is one this one needs to compile, but
+	# the project loads it rather than this script, so it is answered apart from dependencies.
+	var global_autoloads: Dictionary = {}
+	for property: Dictionary in ProjectSettings.get_property_list():
+		var setting: String = str(property.get("name", ""))
+		var value: String = (
+			str(ProjectSettings.get_setting(setting)) if setting.begins_with("autoload/") else ""
+		)
+		if value.begins_with("*"):
+			global_autoloads[setting.trim_prefix("autoload/")] = value.trim_prefix("*")
+	var autoloads_used: Array[Dictionary] = []
+	for used: String in Dependencies.classes_used_in(content, global_autoloads):
+		if str(global_autoloads[used]) != full_script_path:
+			autoloads_used.append({"name": used, "path": str(global_autoloads[used])})
+
 	var answer: Dictionary = {
 		"path": script_path,
 		"full_path": full_script_path,
@@ -167,6 +182,7 @@ func get_gdscript_info(params: Dictionary) -> Dictionary:
 		"inner_classes": inner_classes,
 		"dependencies": dependencies,
 		"classes_used": classes_used,
+		"autoloads_used": autoloads_used,
 		"line_count": lines.size()
 	}
 	if Read.as_bool(params.get("include_inherited", false)):
@@ -386,10 +402,15 @@ func _parse_variable(line: String, line_num: int) -> Dictionary:
 	else:
 		name = var_text.split(" ")[0].strip_edges()
 
+	# Null for a declaration with no value, which as an empty string read as `= ""`.
+	var stated_default: Variant = null
+	if "=" in var_text:
+		stated_default = default_value
+
 	return {
 		"name": name,
 		"type": type_hint,
-		"default_value": default_value,
+		"default_value": stated_default,
 		"is_export": is_export,
 		"export_hint": export_hint,
 		"is_onready": is_onready,
@@ -582,7 +603,10 @@ func _parse_param(param_text: String) -> Dictionary:
 	if is_rest:
 		name = name.substr(3).strip_edges()
 
-	return {"name": name, "type": type_hint, "default": default_value, "is_rest": is_rest}
+	var stated_default: Variant = null
+	if "=" in param_text:
+		stated_default = default_value
+	return {"name": name, "type": type_hint, "default": stated_default, "is_rest": is_rest}
 
 
 func _collect_dependencies(line: String, into: Array[String]) -> void:

package/build/godot/operations/gdscript_authoring.gd

@@ -396,8 +396,11 @@ func _add_function(lines: Array[String], mod: Dictionary, placed: Array[Dictiona
 	var declared_at: int = insert_line + func_lines.size()
 	func_lines.append("func " + func_name + "(" + func_params + ") -> " + return_type + ":")
 
-	for bl: String in body.split("\n"):
-		func_lines.append("\t" + bl)
+	# The body's statements relative to the function, whether or not the caller indented them for
+	# it: a body written with its tab already on came out two levels in. A blank line stays empty,
+	# since an indent alone on it is trailing whitespace to every formatter.
+	for bl: String in body.dedent().split("\n"):
+		func_lines.append("" if bl.strip_edges().is_empty() else "\t" + bl)
 
 	var below: int = _blank_run(lines, insert_line, 1)
 	if insert_line + below < lines.size():

package/build/godot/operations/godot_operations.gd

@@ -38,6 +38,27 @@ const ScriptCheck = preload("script_check.gd")
 ## step with `ANSWERED` in src/headless.ts.
 const ANSWERED: String = "[gdharness] answered"
 
+## Printed in `_init` by an operation that runs once the project's autoloads are in the tree, and
+## when it begins there. Kept in step with `WAITING` and `BEGUN` in src/headless.ts, which files
+## what the autoloads print in between as theirs rather than the operation's.
+const WAITING: String = "[gdharness] waiting for the autoloads"
+const BEGUN: String = "[gdharness] begun"
+
+## The operations that compile the project's scripts. The engine knows an autoload's name only once
+## the autoload is in the tree, which is after `_init`, so a script naming one compiled here failed
+## with "Identifier not found" while the game and the editor ran it. A scene tool, and a read of a
+## scene or a resource, loads the scripts of the file it opens.
+const AFTER_THE_AUTOLOADS: Array[String] = [
+	"check_scripts",
+	"create_script",
+	"modify_script",
+	"read_animation_states",
+	"read_animations",
+	"read_resource",
+	"read_scene_tree",
+	"run_editor_tool",
+]
+
 var _log: Log
 
 
@@ -76,12 +97,31 @@ func _init() -> void:
 
 	_log.info("Executing operation: " + operation)
 
+	var answer_path: String = args[answer_index]
+	if operation in AFTER_THE_AUTOLOADS:
+		printerr(WAITING)
+		var waiting: int = process_frame.connect(
+			_answer_after_the_autoloads.bind(operation, params, answer_path), CONNECT_ONE_SHOT
+		)
+		if waiting != OK:
+			_log.error("Could not wait for the project's autoloads: " + error_string(waiting))
+			quit(1)
+		return
+	_answer(operation, params, answer_path)
+
+
+func _answer_after_the_autoloads(operation: String, params: Dictionary, answer_path: String) -> void:
+	printerr(BEGUN)
+	_answer(operation, params, answer_path)
+
+
+## Runs [param operation] and writes its answer to [param answer_path], then quits.
+func _answer(operation: String, params: Dictionary, answer_path: String) -> void:
 	var payload: Dictionary = _run(operation, params)
 	if payload.is_empty():
 		quit(1)
 		return
 
-	var answer_path: String = args[answer_index]
 	var answer: FileAccess = FileAccess.open(answer_path, FileAccess.WRITE)
 	if answer == null:
 		_log.error(
@@ -173,6 +213,9 @@ func _run(operation: String, params: Dictionary) -> Dictionary:
 				)
 			)
 
+		"run_editor_tool":
+			payload = _read(_editor_tool(params))
+
 		# Import and export pipeline
 		"get_import_status":
 			payload = ImportPipeline.new(_log).get_import_status(params)
@@ -259,6 +302,20 @@ func _run(operation: String, params: Dictionary) -> Dictionary:
 	return payload
 
 
+## A scene or resource tool of the editor addon, run as editor_tools.gd runs it. Loaded for this op
+## alone, because the tools bring the editor addon's scene and resource scripts with them: preloaded
+## here, every op compiled them, and an operations directory without the addons beside it lost every
+## op rather than this one.
+func _editor_tool(params: Dictionary) -> Dictionary:
+	var own: Script = get_script()
+	var path: String = own.resource_path.get_base_dir().path_join("editor_tools.gd")
+	var tools: Script = ResourceLoader.load(path, "Script")
+	if tools == null or not tools.can_instantiate():
+		return {"ok": false, "error": "The editor tools did not load from %s." % path}
+	var answer: Dictionary = tools.call("run", params)
+	return answer
+
+
 ## A read the editor answers too, in the shape an operation answers: its refusal as the run's error.
 func _read(read: Dictionary) -> Dictionary:
 	if not read.get("ok", false):

package/build/godot/operations/property_values.gd

@@ -272,6 +272,9 @@ func value_for(target: Object, declared: Dictionary, raw: Variant) -> Array:
 		var elements: Array = elements_of(declared)
 		if _fraction(raw, expected_type, elements):
 			return [false, _fraction_refusal(target, property, raw)]
+		var rounded: String = Serialisation.inexact(raw, expected_type)
+		if not rounded.is_empty():
+			return [false, "%s.%s holds int: %s." % [target.get_class(), property, rounded]]
 		_refused = ""
 		value = parse(raw, expected_type, elements)
 		if not _refused.is_empty():

package/build/godot/operations/serialisation.gd

@@ -16,6 +16,10 @@ const Read = preload("reading.gd")
 const NUMBERS: Array[int] = [TYPE_BOOL, TYPE_INT, TYPE_FLOAT]
 const TEXTS: Array[int] = [TYPE_STRING, TYPE_STRING_NAME, TYPE_NODE_PATH]
 
+# 2^53. A JSON number is a double, and every whole number below this one in size has a double of
+# its own; from here on two or more share each double, so one arriving tells nobody which was sent.
+const EXACT: int = 9007199254740992
+
 # The types that cross as a plain JSON list and have to be built back into themselves. A list is
 # what a caller can write by hand and what the serialiser answers with, and the parameter or
 # property being written is the only thing that knows which of these it wanted.
@@ -53,6 +57,8 @@ const LIST_TYPES: Array[int] = [
 # type it wanted.
 const SERIALISERS: Dictionary = {
 	TYPE_NIL: "_serialize_nil",
+	TYPE_INT: "_serialize_int",
+	TYPE_PACKED_INT64_ARRAY: "_serialize_ints",
 	TYPE_FLOAT: "_serialize_float",
 	TYPE_PACKED_FLOAT32_ARRAY: "_serialize_floats",
 	TYPE_PACKED_FLOAT64_ARRAY: "_serialize_floats",
@@ -109,6 +115,8 @@ const BUILDERS: Dictionary = {
 	"NodePath": "_build_node_path",
 	"PackedByteArray": "_build_bytes",
 	"float": "_build_float",
+	"int": "_build_int",
+	"RID": "_build_rid",
 	"Dictionary": "_build_dictionary",
 }
 
@@ -136,6 +144,8 @@ const REQUIRED: Dictionary = {
 	"NodePath": [["path"]],
 	"PackedByteArray": [["base64"]],
 	"float": [["value"]],
+	"int": [["value"]],
+	"RID": [["id"]],
 	"Dictionary": [["entries"]],
 }
 
@@ -243,9 +253,40 @@ func deserialize_value(value: Variant) -> Variant:
 		return fields
 	if tag == "Dictionary" and not pairs(fields["entries"]):
 		return fields
+	# Digits only: the tag is there to carry what a number cannot, and {"value": 5} meant for some
+	# other shape is not to be read as 5.
+	if tag == "int" and not (fields["value"] is String and _exact_int(fields["value"]) != null):
+		return fields
+	if tag == "RID" and _exact_int(fields["id"]) == null:
+		return fields
 	return call(builder, fields)
 
 
+## [param held] as the whole number it spells exactly, or null: an int, a JSON number that is whole
+## and no larger than a double holds exactly, the digits of one, or the int tag carrying them. A
+## fraction, or a number past 2^53 that arrived as a number and so may already be a neighbour of the
+## one meant, is no id.
+func _exact_int(held: Variant) -> Variant:
+	if held is int:
+		return held
+	if held is float:
+		var number: float = held
+		if is_finite(number) and number == floorf(number) and absf(number) < EXACT:
+			return int(number)
+		return null
+	if held is String:
+		var digits: String = held
+		var parsed: int = digits.to_int()
+		if digits.is_valid_int() and str(parsed) == digits:
+			return parsed
+		return null
+	if held is Dictionary:
+		var tagged: Dictionary = held
+		if str(tagged.get("_type", "")) == "int" and tagged.has("value"):
+			return _exact_int(tagged["value"])
+	return null
+
+
 ## The components a path reads off [param value], by the names GDScript gives them, or none for a
 ## value that has none: a vector's axes, a colour's channels, a rectangle's corners and size, a
 ## transform's basis and origin. A value of one of these is a copy wherever it is read, so a write
@@ -393,6 +434,11 @@ func fitted(value: Variant, type: int) -> Variant:
 	if not simple.has(type) or not simple.has(typeof(rebuilt)):
 		return rebuilt
 
+	# Digits are read as digits, since read as JSON they become a double and one past 2^53 a
+	# neighbour of the number written.
+	if rebuilt is String and type == TYPE_INT and _exact_int(rebuilt) != null:
+		return _exact_int(rebuilt)
+
 	if rebuilt is String and type != TYPE_STRING:
 		var text: String = rebuilt
 		var parsed: Variant = Read.json_or_null(text)
@@ -408,13 +454,33 @@ func fitted(value: Variant, type: int) -> Variant:
 	return type_convert(rebuilt, type)
 
 
+## Why [param given], meant for an int, may not be the number that was sent, or "" when it is. A
+## JSON number is a double wherever it is read, so a whole number from 2^53 on arrives as the nearest
+## double to the one written: 9007199254740993 sent as a number arrives as 9007199254740992, and a
+## seed written that way would be stored as its neighbour with the answer saying it was written.
+static func inexact(given: Variant, type: int) -> String:
+	if type != TYPE_INT or (typeof(given) != TYPE_FLOAT and typeof(given) != TYPE_INT):
+		return ""
+	var number: float = Read.as_float(given)
+	if not is_finite(number) or absf(number) < EXACT:
+		return ""
+	return (
+		(
+			"%s is 2^53 or more, where a JSON number holds a whole number only to the nearest double,"
+			+ ' so it may not be the number sent: send the digits as {"_type": "int", "value": "..."}'
+			+ ", the form a read answers with"
+		)
+		% String.num(number, 0)
+	)
+
+
 ## How a value of [param type] is written to be read as one, for a refusal to name, or empty for a
 ## type that is not built from fields. A refusal naming only the two types left a caller to find
 ## the shape in the description of another op.
 static func written_as(type: int) -> String:
 	var tag: String = type_string(type)
 	var alternatives: Array = REQUIRED.get(tag, [])
-	if alternatives.is_empty() or tag == "float" or tag == "Dictionary":
+	if alternatives.is_empty() or tag in ["float", "int", "Dictionary"]:
 		return ""
 	var keys: Array = alternatives[0]
 	var parts: Array[String] = []
@@ -530,10 +596,32 @@ func _serialize_node_path(value: NodePath) -> Dictionary:
 	return {"path": str(value), "_type": "NodePath"}
 
 
-# An id rather than nothing, because two properties holding the same RID are worth telling apart
-# even though neither can be handed back to the engine.
+# By its id, which is all an RID is from outside the server holding it, and which builds it back:
+# a viewport's RID read off one call is what RenderingServer's render timing takes in the next.
 func _serialize_rid(value: RID) -> Dictionary:
-	return {"id": value.get_id(), "_type": "RID"}
+	return {"id": _serialize_int(value.get_id()), "_type": "RID"}
+
+
+# A whole number from 2^53 on as its digits, because JSON numbers are doubles on the server's side
+# and on the engine's, and from there on neighbouring whole numbers share a double. A RefCounted's
+# instance id is one, with its top bit set, and a resource uid another; read as numbers they came
+# back as a neighbouring id, which named nothing or something else.
+func _serialize_int(value: int) -> Variant:
+	if value > -EXACT and value < EXACT:
+		return value
+	return {"_type": "int", "value": str(value)}
+
+
+# A packed list of 64-bit numbers stays the JSON list it is unless something in it is too large for
+# a double to hold.
+func _serialize_ints(value: PackedInt64Array) -> Variant:
+	for number: int in value:
+		if number <= -EXACT or number >= EXACT:
+			var items: Array = []
+			for each: int in value:
+				items.append(_serialize_int(each))
+			return items
+	return value
 
 
 # A bound method, said in the terms a caller could act on: what it is on, and what it is called.
@@ -672,7 +760,7 @@ func _describe_object(value: Object) -> Dictionary:
 	# in a costume and reads as if the object had been asked and had nothing to say.
 	if value.has_method("_to_string"):
 		described["says"] = value.to_string()
-	described["id"] = value.get_instance_id()
+	described["id"] = _serialize_int(value.get_instance_id())
 	return described
 
 
@@ -808,6 +896,16 @@ func _build_float(fields: Dictionary) -> float:
 	return Read.as_float(fields)
 
 
+func _build_int(fields: Dictionary) -> int:
+	var exact: int = _exact_int(fields["value"])
+	return exact
+
+
+func _build_rid(fields: Dictionary) -> RID:
+	var id: int = _exact_int(fields["id"])
+	return rid_from_int64(id)
+
+
 ## The entries of a dictionary whose keys are not all text. JSON carries every number as a float,
 ## and a dictionary keys 1.0 apart from 1, so a whole-number key is built as an int: the key a
 ## game uses far more often, and one JSON cannot tell from the float.