gdharness 1.1.21 → 1.1.22

package/build/godot/operations/gdscript_analysis.gd

@@ -52,16 +52,30 @@ func get_gdscript_info(params: Dictionary) -> Dictionary:
 		# answer: a `var x: int = 5  # note` carried `5  # note` as its default, and correcting the
 		# end of a parameter list put the comment into the return type, where `rfind(")")` had been
 		# hiding it by stopping inside the comment instead.
-		var stripped: String = _without_comment(lines[i])
-
-		if stripped.is_empty():
+		var raw: String = lines[i]
+		# Inside a string the raw line is counted, because a `#` in it is text and taking it for a
+		# comment would cut off the quotes that close the string.
+		if in_multiline_string:
+			if _triple_quotes(raw) % 2 == 1:
+				in_multiline_string = false
 			continue
+		var stripped: String = _without_comment(raw)
 
-		if '"""' in stripped or "'''" in stripped:
-			in_multiline_string = not in_multiline_string
+		if stripped.is_empty():
 			continue
 
-		if in_multiline_string:
+		# An odd count opens a string that runs on; an even one is a string that closed on the line
+		# it opened on. Toggling on any count lost `const HELP := """Usage"""`, and everything after
+		# it up to the next triple quote, with the state inverted from there to the end of the file.
+		# The line that opens one is still read: it can be the declaration the string belongs to.
+		if _triple_quotes(stripped) % 2 == 1:
+			in_multiline_string = true
+
+		# Only a line at the left margin declares one of the script's own members. Indented, it is a
+		# function's local or an inner class's member, and each was answered as the script's own:
+		# every `var` in every body, and an inner class's `extends` taken for the script's base.
+		if raw.begins_with(" ") or raw.begins_with("\t"):
+			_collect_dependencies(stripped, dependencies)
 			continue
 
 		# Annotations may share the line with anything they annotate, so every branch below decides
@@ -116,14 +130,11 @@ func get_gdscript_info(params: Dictionary) -> Dictionary:
 		elif header.begins_with("class "):
 			inner_classes.append(header.substr(6).split(":")[0].split(" ")[0].strip_edges())
 
-		if "preload(" in stripped or "load(" in stripped:
-			for dep: String in _extract_dependencies(stripped):
-				if dep not in dependencies:
-					dependencies.append(dep)
+		_collect_dependencies(stripped, dependencies)
 
 	# After the loop, because it needs the base the loop reads, and a file that declared one after
 	# its first function would otherwise be judged against the default.
-	_mark_virtuals(functions, extends_name)
+	_mark_virtuals(functions, extends_name, full_script_path)
 
 	var answer: Dictionary = {
 		"path": script_path,
@@ -151,8 +162,8 @@ func get_gdscript_info(params: Dictionary) -> Dictionary:
 # with a private helper in it. The virtuals are the ones the native ancestor declares with
 # `METHOD_FLAG_VIRTUAL`, which is a question `ClassDB` answers exactly, and `class_has_method` does
 # not: it says false for `_ready` on `Node`, so the method list is what has to be walked.
-func _mark_virtuals(functions: Array[Dictionary], extends_name: String) -> void:
-	var native: String = _native_ancestor(extends_name)
+func _mark_virtuals(functions: Array[Dictionary], extends_name: String, from_path: String) -> void:
+	var native: String = _native_ancestor(extends_name, from_path)
 	var virtuals: Dictionary = {}
 	if not native.is_empty():
 		for m: Dictionary in ClassDB.class_get_method_list(native, false):
@@ -168,11 +179,12 @@ func _mark_virtuals(functions: Array[Dictionary], extends_name: String) -> void:
 # A base named by a script is followed; a base that is neither a script nor a class the engine knows
 # leaves nothing to ask, and then no function is called virtual rather than every underscore being
 # guessed at.
-func _native_ancestor(base: String) -> String:
+func _native_ancestor(base: String, from_path: String) -> String:
 	var seen: Array[String] = []
 	var current: String = base
+	var declared_in: String = from_path
 	while true:
-		var path: String = _script_named(current)
+		var path: String = _script_named(current, declared_in)
 		if path.is_empty():
 			break
 		if path in seen:
@@ -182,6 +194,7 @@ func _native_ancestor(base: String) -> String:
 		if above.is_empty():
 			return ""
 		current = str(above.get("extends", ""))
+		declared_in = path
 	return current if ClassDB.class_exists(current) else ""
 
 
@@ -196,8 +209,9 @@ func _native_ancestor(base: String) -> String:
 func _add_inherited(answer: Dictionary, seen: Array[String]) -> void:
 	var inherits_from: Array[String] = []
 	var base: String = str(answer.get("extends", ""))
+	var declared_in: String = str(answer.get("full_path", ""))
 	while true:
-		var base_path: String = _script_named(base)
+		var base_path: String = _script_named(base, declared_in)
 		if base_path.is_empty() or base_path in seen:
 			break
 		seen.append(base_path)
@@ -216,16 +230,28 @@ func _add_inherited(answer: Dictionary, seen: Array[String]) -> void:
 				carried["inherited_from"] = base_path
 				mine.append(carried)
 		base = str(above.get("extends", ""))
+		declared_in = base_path
 	answer["inherits_from"] = inherits_from
 
 
 # The file a base names, whether it named a path or a class, or empty for a native class.
-func _script_named(base: String) -> String:
+#
+# A quoted path is resolved the way the engine resolves it: `extends "base.gd"` is relative to the
+# script [param declared_in], and asking whether `base.gd` exists asked about nothing, so such a
+# script had no ancestor and none of its engine callbacks were virtual.
+func _script_named(base: String, declared_in: String) -> String:
 	if base.is_empty():
 		return ""
-	if base.begins_with('"') and base.ends_with('"'):
-		var quoted: String = base.substr(1, base.length() - 2)
-		return quoted if FileAccess.file_exists(quoted) else ""
+	var quoted: String = ""
+	if base.length() >= 2 and (base[0] == '"' or base[0] == "'") and base.ends_with(base[0]):
+		quoted = base.substr(1, base.length() - 2)
+	if not quoted.is_empty():
+		if quoted.begins_with("uid://"):
+			var id: int = ResourceUID.text_to_id(quoted)
+			quoted = ResourceUID.get_id_path(id) if ResourceUID.has_id(id) else ""
+		elif not quoted.begins_with("res://"):
+			quoted = declared_in.get_base_dir().path_join(quoted).simplify_path()
+		return quoted if not quoted.is_empty() and FileAccess.file_exists(quoted) else ""
 	for entry: Dictionary in ProjectSettings.get_global_class_list():
 		if str(entry.get("class", "")) == base:
 			var path: String = str(entry.get("path", ""))
@@ -562,6 +588,19 @@ func _parse_param(param_text: String) -> Dictionary:
 	return {"name": name, "type": type_hint, "default": default_value, "is_rest": is_rest}
 
 
+func _collect_dependencies(line: String, into: Array[String]) -> void:
+	if "load(" not in line:
+		return
+	for dep: String in _extract_dependencies(line):
+		if dep not in into:
+			into.append(dep)
+
+
+# How many triple quotes of either kind [param line] holds.
+static func _triple_quotes(line: String) -> int:
+	return line.count('"""') + line.count("'''")
+
+
 func _extract_dependencies(line: String) -> Array[String]:
 	var deps: Array[String] = []
 	var regex: RegEx = Patterns.compiled("(?:preload|load)\\s*\\(\\s*[\"']([^\"']+)[\"']\\s*\\)")

package/build/godot/operations/gdscript_authoring.gd

@@ -23,6 +23,24 @@ func create_gdscript(params: Dictionary) -> Dictionary:
 
 	_log.info("Creating GDScript: " + script_path)
 
+	# Content is the whole file, so a header written above it would be a second one: a content that
+	# starts with its own `extends` did not parse, and one without it was not the file that was sent.
+	if not content.is_empty():
+		var alongside: Array[String] = []
+		for name: String in ["class_name", "extends", "template"]:
+			if not str(params.get(name, "")).is_empty():
+				alongside.append(name)
+		if not alongside.is_empty():
+			return _log.failure(
+				(
+					"content is the whole file, so "
+					+ " and ".join(alongside)
+					+ " cannot be given with it: write "
+					+ ("them" if alongside.size() > 1 else "it")
+					+ " into content instead"
+				)
+			)
+
 	var full_script_path: String = script_path
 	if not full_script_path.begins_with("res://"):
 		full_script_path = "res://" + full_script_path
@@ -41,20 +59,16 @@ func create_gdscript(params: Dictionary) -> Dictionary:
 		if error != OK:
 			return _log.failure("Failed to create directory: " + script_dir + ", error: " + str(error))
 
-	var script_content: String = ""
-
-	if not cls_name_param.is_empty():
-		script_content += "class_name " + cls_name_param + "\n"
-
-	script_content += "extends " + extends_class + "\n\n"
-
-	if not template.is_empty():
-		script_content += _script_template(template)
-	elif not content.is_empty():
-		script_content += content
-	else:
-		script_content += "func _ready() -> void:\n"
-		script_content += "\tpass\n"
+	var script_content: String = content
+	if content.is_empty():
+		if not cls_name_param.is_empty():
+			script_content += "class_name " + cls_name_param + "\n"
+		script_content += "extends " + extends_class + "\n\n"
+		if not template.is_empty():
+			script_content += _script_template(template)
+		else:
+			script_content += "func _ready() -> void:\n"
+			script_content += "\tpass\n"
 
 	var file: FileAccess = FileAccess.open(full_script_path, FileAccess.WRITE)
 	if not file:
@@ -65,21 +79,20 @@ func create_gdscript(params: Dictionary) -> Dictionary:
 	if not stored:
 		return _log.failure("Failed to write to script file: " + full_script_path)
 
-	# Whether the engine accepts what was written, parsed under this project's own warning
-	# settings: a script that does not load is a script the caller wants to hear about now,
-	# and the reason is on stderr, which comes back with the answer.
 	var written: Script = ResourceLoader.load(full_script_path, "Script", ResourceLoader.CACHE_MODE_IGNORE)
-
-	return {
+	var answer: Dictionary = {
 		"success": true,
 		"script_path": script_path,
 		"full_path": full_script_path,
 		"absolute_path": ProjectSettings.globalize_path(full_script_path),
-		"registered": not cls_name_param.is_empty(),
-		"extends": extends_class,
 		"template_used": template if not template.is_empty() else "none",
-		"parses": written != null and written.can_instantiate(),
+		"parses": _parses(written),
 	}
+	# Read off the file as the engine parsed it rather than off the arguments, which content leaves out.
+	if written != null:
+		answer["extends"] = _base_named(written)
+		answer["class_name"] = str(written.get_global_name())
+	return answer
 
 
 # Modify an existing GDScript file by adding functions, variables, or signals
@@ -103,34 +116,40 @@ func modify_gdscript(params: Dictionary) -> Dictionary:
 	var original_content: String = file.get_as_text()
 	file.close()
 
+	# All of them checked before any is made, so a call is made whole or not at all: one skipped for a
+	# missing name used to leave the rest written and the answer saying success over an empty list.
+	var problems: Array[String] = _modification_problems(modifications)
+	if not problems.is_empty():
+		return _log.failure("Nothing was changed: " + "; ".join(problems))
+
 	var lines: Array[String] = []
 	lines.assign(original_content.split("\n"))
-	var modifications_applied: Array[Dictionary] = []
+	# Each placed line as a zero-based index that moves down whenever a later insertion lands above
+	# it, so the numbers answered are where the lines are in the file written, not where each went
+	# at the moment it was placed.
+	var placed: Array[Dictionary] = []
 
 	for mod: Variant in modifications:
-		if not mod is Dictionary:
-			_log.error("Modification must be an object")
-			continue
 		var fields: Dictionary = mod
 		var mod_type: String = str(fields.get("type", ""))
-		var mod_name: String = str(fields.get("name", ""))
-
-		if mod_name.is_empty():
-			_log.error("Modification missing 'name' field")
-			continue
-
+		var at: int = -1
 		match mod_type:
 			"add_variable":
-				var line: int = _add_variable(lines, fields)
-				modifications_applied.append({"type": "add_variable", "name": mod_name, "line": line})
+				at = _add_variable(lines, fields, placed)
 			"add_signal":
-				var line: int = _add_signal(lines, fields)
-				modifications_applied.append({"type": "add_signal", "name": mod_name, "line": line})
+				at = _add_signal(lines, fields, placed)
 			"add_function":
-				var line: int = _add_function(lines, fields)
-				modifications_applied.append({"type": "add_function", "name": mod_name, "line": line})
-			_:
-				_log.error("Unknown modification type: " + mod_type)
+				at = _add_function(lines, fields, placed)
+		if at == -1:
+			return _log.failure(
+				"Nothing was changed: " + mod_type + " " + str(fields.get("name")) + " could not be placed"
+			)
+		placed.append({"type": mod_type, "name": str(fields.get("name")), "index": at})
+
+	var modifications_applied: Array[Dictionary] = []
+	for entry: Dictionary in placed:
+		var index: int = entry["index"]
+		modifications_applied.append({"type": entry["type"], "name": entry["name"], "line": index + 1})
 
 	file = FileAccess.open(full_script_path, FileAccess.WRITE)
 	if not file:
@@ -141,17 +160,75 @@ func modify_gdscript(params: Dictionary) -> Dictionary:
 	if not rewrote:
 		return _log.failure("Failed to write to script file: " + full_script_path)
 
+	var made: Script = ResourceLoader.load(full_script_path, "Script", ResourceLoader.CACHE_MODE_IGNORE)
 	return {
 		"success": true,
 		"script_path": script_path,
 		"modifications_applied": modifications_applied,
-		"total_modifications": modifications_applied.size()
+		"total_modifications": modifications_applied.size(),
+		"parses": _parses(made),
 	}
 
 
-# Inserts the declaration and answers with its one-based line number, or 0 for one that could not
-# be placed, which is a number no line has.
-func _add_variable(lines: Array[String], mod: Dictionary) -> int:
+# Every reason [param modifications] cannot be made as asked, each naming the entry by position.
+static func _modification_problems(modifications: Array) -> Array[String]:
+	var problems: Array[String] = []
+	if modifications.is_empty():
+		problems.append("modifications is empty")
+	for index: int in range(modifications.size()):
+		var mod: Variant = modifications[index]
+		var which: String = "modification " + str(index + 1)
+		if not mod is Dictionary:
+			problems.append(which + " is not an object")
+			continue
+		var fields: Dictionary = mod
+		var mod_type: String = str(fields.get("type", ""))
+		var mod_name: String = str(fields.get("name", ""))
+		if mod_type not in ["add_variable", "add_signal", "add_function"]:
+			problems.append(
+				which + " has type '" + mod_type + "', not add_variable, add_signal or add_function"
+			)
+		if mod_name.is_empty():
+			problems.append(which + " has no name")
+		elif not mod_name.is_valid_unicode_identifier():
+			problems.append(which + " is named '" + mod_name + "', which GDScript does not accept as a name")
+	return problems
+
+
+# Inserts [param new_lines] at [param at] and moves every placed line at or below it down by as many.
+static func _insert(
+	lines: Array[String], at: int, new_lines: Array[String], placed: Array[Dictionary]
+) -> bool:
+	for i: int in range(new_lines.size() - 1, -1, -1):
+		if lines.insert(at, new_lines[i]) != OK:
+			push_error("gdharness: could not place a line at " + str(at))
+			return false
+	for entry: Dictionary in placed:
+		var index: int = entry["index"]
+		if index >= at:
+			entry["index"] = index + new_lines.size()
+	return true
+
+
+# Whether the engine accepts [param script], parsed under this project's own warning settings: a
+# script that does not load is one the caller wants to hear about now, and the reason is on stderr,
+# which comes back with the answer. A script that fails to parse still loads, as one that cannot be
+# instantiated; an abstract one that parses can be, on 4.7.
+static func _parses(script: Script) -> bool:
+	return script != null and script.can_instantiate()
+
+
+# What [param script] extends: the base script by class name or path, or the native class.
+static func _base_named(script: Script) -> String:
+	var base: Script = script.get_base_script()
+	if base == null:
+		return str(script.get_instance_base_type())
+	var named: String = str(base.get_global_name())
+	return named if not named.is_empty() else base.resource_path
+
+
+# Inserts the declaration and answers with its zero-based index, or -1 for one that could not be placed.
+func _add_variable(lines: Array[String], mod: Dictionary, placed: Array[Dictionary]) -> int:
 	var var_name: String = str(mod.get("name", ""))
 	var var_type: String = str(mod.get("varType", ""))
 	var default_value: String = str(mod.get("defaultValue", ""))
@@ -186,10 +263,7 @@ func _add_variable(lines: Array[String], mod: Dictionary) -> int:
 		var_line += ": Variant"
 
 	var insert_line: int = _variable_insertion_point(lines)
-	if lines.insert(insert_line, var_line) != OK:
-		push_error("gdharness: could not place a declaration at line " + str(insert_line))
-		return 0
-	return insert_line + 1
+	return insert_line if _insert(lines, insert_line, [var_line], placed) else -1
 
 
 # The type name a constant expression evaluates to, or Variant when it is not one: a call
@@ -208,7 +282,7 @@ func _type_of_literal(expression: String) -> String:
 	return type_string(typeof(value))
 
 
-func _add_signal(lines: Array[String], mod: Dictionary) -> int:
+func _add_signal(lines: Array[String], mod: Dictionary, placed: Array[Dictionary]) -> int:
 	var signal_name: String = str(mod.get("name", ""))
 	var signal_params: String = str(mod.get("params", ""))
 
@@ -217,13 +291,11 @@ func _add_signal(lines: Array[String], mod: Dictionary) -> int:
 		signal_line += "(" + signal_params + ")"
 
 	var insert_line: int = _signal_insertion_point(lines)
-	if lines.insert(insert_line, signal_line) != OK:
-		push_error("gdharness: could not place a signal at line " + str(insert_line))
-		return 0
-	return insert_line + 1
+	return insert_line if _insert(lines, insert_line, [signal_line], placed) else -1
 
 
-func _add_function(lines: Array[String], mod: Dictionary) -> int:
+# Answers with the zero-based index of the `func` line, below the blank line that separates it.
+func _add_function(lines: Array[String], mod: Dictionary, placed: Array[Dictionary]) -> int:
 	var func_name: String = str(mod.get("name", ""))
 	var func_params: String = str(mod.get("params", ""))
 	# A function that names no return type returns nothing, and says so, for the same reason
@@ -248,12 +320,7 @@ func _add_function(lines: Array[String], mod: Dictionary) -> int:
 	if insert_line < lines.size():
 		func_lines.append("")
 
-	for i: int in range(func_lines.size() - 1, -1, -1):
-		if lines.insert(insert_line, func_lines[i]) != OK:
-			push_error("gdharness: could not place a function at line " + str(insert_line))
-			return 0
-
-	return insert_line + 1
+	return insert_line + 1 if _insert(lines, insert_line, func_lines, placed) else -1
 
 
 func _variable_insertion_point(lines: Array[String]) -> int:

package/build/godot/operations/godot_operations.gd

@@ -2,8 +2,13 @@
 extends SceneTree
 
 # The command line the server runs is `godot --headless --path <project> --script <this>
-# <operation> @file:<params.json>`, and one JSON object on stdout is the answer. Everything an
-# operation does lives in a sibling module; this file is the command table and the wire format.
+# <operation> @file:<params.json> <answer.json>`, and the one JSON object written to the answer
+# file is the answer. Everything an operation does lives in a sibling module; this file is the
+# command table and the wire format.
+#
+# A file rather than a line on stdout, because the project's autoloads run after `_init` and print
+# into the same stream: an autoload printing a dictionary in `_process` was the last JSON line out
+# and was taken as the answer. Nothing the project prints can reach the file.
 #
 # Each module is preloaded by a path relative to this script rather than a res:// one, because
 # the operations directory ships inside the server package and is handed to the engine as an
@@ -39,8 +44,9 @@ func _init() -> void:
 		return
 
 	var params_index: int = script_index + 3
-	if args.size() <= params_index:
-		_log.error("Usage: godot --headless --script godot_operations.gd <operation> <json_params>")
+	var answer_index: int = script_index + 4
+	if args.size() <= answer_index:
+		_log.error("Usage: godot_operations.gd <operation> @file:<params.json> <answer.json>")
 		_log.error("Not enough command-line arguments provided.")
 		quit(1)
 		return
@@ -65,7 +71,20 @@ func _init() -> void:
 		quit(1)
 		return
 
-	print(JSON.stringify(payload))
+	var answer_path: String = args[answer_index]
+	var answer: FileAccess = FileAccess.open(answer_path, FileAccess.WRITE)
+	if answer == null:
+		_log.error(
+			"Could not write the answer to " + answer_path + ": " + error_string(FileAccess.get_open_error())
+		)
+		quit(1)
+		return
+	var written: bool = answer.store_string(JSON.stringify(payload))
+	answer.close()
+	if not written:
+		_log.error("Could not write the answer to " + answer_path)
+		quit(1)
+		return
 	quit()