gdharness 0.4.1

package/build/godot/operations/class_cache.gd

@@ -0,0 +1,180 @@
+extends RefCounted
+
+# The editor keeps the list of global classes it knows in .godot/global_script_class_cache.cfg
+# and refreshes it only on a filesystem scan, which it does not always do (godotengine/godot#42786).
+# A game started from a stale editor then cannot resolve any class_name written since, and the
+# engine reads the same file headless, so the list is rebuilt here from the scripts themselves.
+
+const FileWalk = preload("file_walk.gd")
+const Log = preload("logger.gd")
+
+const CACHE_PATH: String = "res://.godot/global_script_class_cache.cfg"
+
+var _log: Log
+var _files: FileWalk = FileWalk.new()
+
+
+func _init(p_log: Log) -> void:
+	_log = p_log
+
+
+func refresh_class_cache(_params: Dictionary) -> Dictionary:
+	var before: Dictionary = _entries_by_class(_read_cache())
+
+	var entries: Array = []
+	var skipped: Array[Dictionary] = []
+	for path: String in _files.find_files("res://", ".gd"):
+		var entry: Dictionary = _entry_for(path, skipped)
+		if not entry.is_empty():
+			entries.append(entry)
+	# By name as text: StringName's own order is by identity, not by spelling.
+	entries.sort_custom(func(a: Dictionary, b: Dictionary) -> bool: return str(a["class"]) < str(b["class"]))
+
+	var after: Dictionary = _entries_by_class(entries)
+	var config: ConfigFile = ConfigFile.new()
+	config.set_value("", "list", entries)
+	DirAccess.make_dir_recursive_absolute(ProjectSettings.globalize_path(CACHE_PATH.get_base_dir()))
+	var err: Error = config.save(CACHE_PATH)
+	if err != OK:
+		return _log.failure("Failed to write " + CACHE_PATH + ": " + error_string(err))
+
+	var added: Array[String] = []
+	var removed: Array[String] = []
+	var changed: Array[String] = []
+	for name: String in after:
+		if not before.has(name):
+			added.append(name)
+		elif before[name] != after[name]:
+			changed.append(name)
+	for name: String in before:
+		if not after.has(name):
+			removed.append(name)
+
+	return {
+		"path": CACHE_PATH,
+		"classes": entries.size(),
+		"added": added,
+		"removed": removed,
+		"changed": changed,
+		"skipped": skipped,
+	}
+
+
+# The cache entry for one script, or empty for a script with no class_name.
+#
+# Read from the source rather than by loading the script, as the editor does: loading a script
+# that extends a class_name resolves that name through the very list being rebuilt, so a stale
+# list would fail every script written against a newer class and leave the list stale.
+func _entry_for(path: String, skipped: Array[Dictionary]) -> Dictionary:
+	var header: Dictionary = _header_of(path)
+	var declared: String = str(header.get("class_name", ""))
+	if declared.is_empty():
+		return {}
+
+	var base: String = _base_of(path, header, skipped)
+	if base.is_empty():
+		return {}
+
+	# The field order is the editor's, so a rebuilt file reads as one the editor wrote.
+	return {
+		"base": StringName(base),
+		"class": StringName(declared),
+		"icon": str(header.get("icon", "")),
+		"is_abstract": bool(header.get("abstract", false)),
+		"is_tool": bool(header.get("tool", false)),
+		"language": StringName("GDScript"),
+		"path": path,
+	}
+
+
+# What the editor records as the base: the nearest ancestor with a class_name, else the native
+# class at the top of the chain. A script that extends by path is followed to its own header.
+func _base_of(path: String, header: Dictionary, skipped: Array[Dictionary]) -> String:
+	var visited: Array[String] = [path]
+	var current: Dictionary = header
+	while true:
+		var extends_what: String = str(current.get("extends", ""))
+		if extends_what.is_empty():
+			return "RefCounted"
+		if not (extends_what.begins_with('"') or extends_what.begins_with("'")):
+			return extends_what
+		var parent_path: String = extends_what.substr(1, extends_what.length() - 2)
+		if not parent_path.begins_with("res://"):
+			parent_path = visited[visited.size() - 1].get_base_dir().path_join(parent_path)
+		if not FileAccess.file_exists(parent_path):
+			skipped.append({"path": path, "reason": "extends a script that does not exist: " + parent_path})
+			return ""
+		if parent_path in visited:
+			skipped.append({"path": path, "reason": "extends itself through " + parent_path})
+			return ""
+		visited.append(parent_path)
+		current = _header_of(parent_path)
+		var parent_name: String = str(current.get("class_name", ""))
+		if not parent_name.is_empty():
+			return parent_name
+	return ""
+
+
+# The declarations at the top of a script: class_name, what it extends (a class name, or a
+# quoted path), and the @tool, @abstract and @icon annotations. Reading stops at the first
+# statement that is none of those, which is where the body begins.
+func _header_of(path: String) -> Dictionary:
+	var header: Dictionary = {}
+	var file: FileAccess = FileAccess.open(path, FileAccess.READ)
+	if not file:
+		return header
+	var annotation: RegEx = RegEx.new()
+	annotation.compile('^@([a-z_]+)(?:\\(\\s*(?:"([^"]*)")?[^)]*\\))?\\s*')
+	var class_line: RegEx = RegEx.new()
+	class_line.compile("^class_name\\s+([A-Za-z_][A-Za-z0-9_]*)(?:\\s+extends\\s+(\\S+))?")
+	var extends_line: RegEx = RegEx.new()
+	extends_line.compile("^extends\\s+(\\S+)")
+	while not file.eof_reached():
+		var rest: String = file.get_line().strip_edges()
+		# Annotations may share a line with what they annotate, as in `@abstract class_name X`.
+		var annotated: RegExMatch = annotation.search(rest)
+		while annotated != null:
+			var name: String = annotated.get_string(1)
+			if name == "tool":
+				header["tool"] = true
+			elif name == "abstract":
+				header["abstract"] = true
+			elif name == "icon":
+				header["icon"] = annotated.get_string(2)
+			rest = rest.substr(annotated.get_end())
+			annotated = annotation.search(rest)
+		if rest.is_empty() or rest.begins_with("#"):
+			continue
+		if rest.begins_with("class_name"):
+			var declared: RegExMatch = class_line.search(rest)
+			if declared != null:
+				header["class_name"] = declared.get_string(1)
+				if not declared.get_string(2).is_empty():
+					header["extends"] = declared.get_string(2)
+		elif rest.begins_with("extends"):
+			var parent: RegExMatch = extends_line.search(rest)
+			if parent != null:
+				header["extends"] = parent.get_string(1)
+		else:
+			break
+	file.close()
+	return header
+
+
+func _read_cache() -> Array:
+	var config: ConfigFile = ConfigFile.new()
+	if config.load(CACHE_PATH) != OK:
+		return []
+	var list: Variant = config.get_value("", "list", [])
+	if list is Array:
+		return list
+	return []
+
+
+func _entries_by_class(entries: Array) -> Dictionary:
+	var by_class: Dictionary = {}
+	for entry: Variant in entries:
+		if entry is Dictionary:
+			var fields: Dictionary = entry
+			by_class[str(fields.get("class", ""))] = fields
+	return by_class

package/build/godot/operations/classdb_queries.gd

@@ -0,0 +1,252 @@
+extends RefCounted
+
+const Log = preload("logger.gd")
+
+# The base class each category name stands for.
+const CATEGORY_BASES: Dictionary = {
+	"node": "Node",
+	"node2d": "Node2D",
+	"node3d": "Node3D",
+	"control": "Control",
+	"resource": "Resource",
+	"physics": "PhysicsBody3D",
+	"physics2d": "PhysicsBody2D",
+	"audio": "AudioStream",
+	"visual": "VisualInstance3D",
+	"animation": "AnimationMixer",
+}
+
+var _log: Log
+
+
+func _init(p_log: Log) -> void:
+	_log = p_log
+
+
+# Query available classes from ClassDB with optional filtering
+func query_classes(params: Dictionary) -> Dictionary:
+	var filter: String = str(params.get("filter", ""))
+	var category: String = str(params.get("category", ""))
+	var instantiable_only: bool = bool(params.get("instantiable_only", false))
+
+	_log.info(
+		(
+			"Querying ClassDB classes (filter: '"
+			+ filter
+			+ "', category: '"
+			+ category
+			+ "', instantiable_only: "
+			+ str(instantiable_only)
+			+ ")"
+		)
+	)
+
+	var base_class: String = ""
+	if not category.is_empty():
+		base_class = CATEGORY_BASES.get(category.to_lower(), "")
+		if base_class.is_empty():
+			return _log.failure("Unknown category: " + category + ". Valid: " + str(CATEGORY_BASES.keys()))
+
+	var all_classes: PackedStringArray = ClassDB.get_class_list()
+	all_classes.sort()
+
+	var filtered_classes: Array[String] = []
+
+	for class_name_str: String in all_classes:
+		if instantiable_only and not ClassDB.can_instantiate(class_name_str):
+			continue
+
+		if not filter.is_empty() and not class_name_str.to_lower().contains(filter.to_lower()):
+			continue
+
+		if not base_class.is_empty():
+			if not ClassDB.is_parent_class(class_name_str, base_class) and class_name_str != base_class:
+				continue
+
+		filtered_classes.append(class_name_str)
+
+	_log.info(
+		"Found " + str(filtered_classes.size()) + " classes (out of " + str(all_classes.size()) + " total)"
+	)
+
+	return {
+		"total_classes": all_classes.size(),
+		"filtered_count": filtered_classes.size(),
+		"filter": filter,
+		"category": category,
+		"instantiable_only": instantiable_only,
+		"classes": filtered_classes
+	}
+
+
+# Query detailed info about a specific class from ClassDB
+func query_class_info(params: Dictionary) -> Dictionary:
+	var class_name_str: String = str(params.get("class_name", ""))
+	var include_inherited: bool = bool(params.get("include_inherited", false))
+
+	_log.info(
+		"Querying class info for: " + class_name_str + " (include_inherited: " + str(include_inherited) + ")"
+	)
+
+	if not ClassDB.class_exists(class_name_str):
+		return _log.failure("Class not found: " + class_name_str)
+
+	var methods: Array[Dictionary] = _methods_of(class_name_str, include_inherited)
+	var properties: Array[Dictionary] = _properties_of(class_name_str, include_inherited)
+	var signals: Array[Dictionary] = _signals_of(class_name_str, include_inherited)
+
+	var enums: Dictionary = {}
+	for e: String in ClassDB.class_get_enum_list(class_name_str, not include_inherited):
+		var enum_values: Dictionary = {}
+		for c: String in ClassDB.class_get_enum_constants(class_name_str, e, not include_inherited):
+			enum_values[c] = ClassDB.class_get_integer_constant(class_name_str, c)
+		enums[e] = enum_values
+
+	_log.info(
+		(
+			"Class info retrieved: "
+			+ str(methods.size())
+			+ " methods, "
+			+ str(properties.size())
+			+ " properties, "
+			+ str(signals.size())
+			+ " signals"
+		)
+	)
+
+	return {
+		"class_name": class_name_str,
+		"parent_class": ClassDB.get_parent_class(class_name_str),
+		"can_instantiate": ClassDB.can_instantiate(class_name_str),
+		"include_inherited": include_inherited,
+		"methods_count": methods.size(),
+		"methods": methods,
+		"properties_count": properties.size(),
+		"properties": properties,
+		"signals_count": signals.size(),
+		"signals": signals,
+		"enums": enums
+	}
+
+
+# Inspect class inheritance hierarchy
+func inspect_inheritance(params: Dictionary) -> Dictionary:
+	var class_name_str: String = str(params.get("class_name", ""))
+
+	_log.info("Inspecting inheritance for: " + class_name_str)
+
+	if not ClassDB.class_exists(class_name_str):
+		return _log.failure("Class not found: " + class_name_str)
+
+	var ancestors: Array[String] = []
+	var current: String = class_name_str
+	while not current.is_empty():
+		var parent: String = ClassDB.get_parent_class(current)
+		if parent.is_empty():
+			break
+		ancestors.append(parent)
+		current = parent
+
+	var all_classes: PackedStringArray = ClassDB.get_class_list()
+
+	var direct_children: Array[String] = []
+	for c: String in all_classes:
+		if ClassDB.get_parent_class(c) == class_name_str:
+			direct_children.append(c)
+	direct_children.sort()
+
+	var all_descendants: Array[String] = []
+	for c: String in all_classes:
+		if c != class_name_str and ClassDB.is_parent_class(c, class_name_str):
+			all_descendants.append(c)
+	all_descendants.sort()
+
+	_log.info(
+		(
+			"Inheritance: "
+			+ str(ancestors.size())
+			+ " ancestors, "
+			+ str(direct_children.size())
+			+ " direct children, "
+			+ str(all_descendants.size())
+			+ " total descendants"
+		)
+	)
+
+	return {
+		"class_name": class_name_str,
+		"parent_class": ClassDB.get_parent_class(class_name_str),
+		"ancestors": ancestors,
+		"direct_children_count": direct_children.size(),
+		"direct_children": direct_children,
+		"all_descendants_count": all_descendants.size(),
+		"all_descendants": all_descendants,
+		"can_instantiate": ClassDB.can_instantiate(class_name_str)
+	}
+
+
+func _methods_of(class_name_str: String, include_inherited: bool) -> Array[Dictionary]:
+	var methods: Array[Dictionary] = []
+
+	for m: Dictionary in ClassDB.class_get_method_list(class_name_str, not include_inherited):
+		var args: Array[Dictionary] = []
+		var declared_args: Array = m.get("args", [])
+		for a: Dictionary in declared_args:
+			args.append(
+				{
+					"name": a.get("name", ""),
+					"type": a.get("type", 0),
+					"class_name": a.get("class_name", ""),
+					"hint_string": a.get("hint_string", "")
+				}
+			)
+		var return_info: Dictionary = m.get("return", {})
+		methods.append(
+			{
+				"name": m.get("name", ""),
+				"args": args,
+				"return":
+				{"type": return_info.get("type", 0), "class_name": return_info.get("class_name", "")},
+				"flags": m.get("flags", 0),
+				"default_args": m.get("default_args", [])
+			}
+		)
+
+	return methods
+
+
+func _properties_of(class_name_str: String, include_inherited: bool) -> Array[Dictionary]:
+	var properties: Array[Dictionary] = []
+
+	for p: Dictionary in ClassDB.class_get_property_list(class_name_str, not include_inherited):
+		# A category, group or subgroup is an editor heading rather than a property.
+		var usage: int = int(p.get("usage", 0))
+		if usage & PROPERTY_USAGE_CATEGORY or usage & PROPERTY_USAGE_GROUP or usage & PROPERTY_USAGE_SUBGROUP:
+			continue
+		properties.append(
+			{
+				"name": p.get("name", ""),
+				"type": p.get("type", 0),
+				"class_name": p.get("class_name", ""),
+				"hint": p.get("hint", 0),
+				"hint_string": p.get("hint_string", ""),
+				"usage": usage
+			}
+		)
+
+	return properties
+
+
+func _signals_of(class_name_str: String, include_inherited: bool) -> Array[Dictionary]:
+	var signals: Array[Dictionary] = []
+
+	for s: Dictionary in ClassDB.class_get_signal_list(class_name_str, not include_inherited):
+		var sig_args: Array[Dictionary] = []
+		var declared_args: Array = s.get("args", [])
+		for a: Dictionary in declared_args:
+			sig_args.append(
+				{"name": a.get("name", ""), "type": a.get("type", 0), "class_name": a.get("class_name", "")}
+			)
+		signals.append({"name": s.get("name", ""), "args": sig_args})
+
+	return signals