gdharness 1.3.66 → 1.3.68

package/build/godot/addons/gdharness_editor/tools/filesystem_tools.gd

@@ -55,7 +55,7 @@ func rescan_filesystem(args: Dictionary) -> Dictionary:
 	# Not over a scan or an import the editor is already running: a scan asked for then starts a
 	# second reimport over the first, and the editor logs "Task 'reimport' already exists" and two
 	# conditions from its progress dialog. Declined and said, so the caller waits and asks again.
-	var busy: bool = filesystem.is_scanning() or filesystem.is_importing()
+	var busy: bool = GdhSceneFile.scan_unfinished(filesystem) or filesystem.is_importing()
 	var started: bool = false
 	var completed_before: int = _scans_completed
 	var uids: Dictionary = { "reread": [], "duplicated": [] }
@@ -71,13 +71,9 @@ func rescan_filesystem(args: Dictionary) -> Dictionary:
 			for path: Variant in paths:
 				filesystem.update_file(str(path))
 		filesystem.scan()
-		# Whether the scan ran, read off the editor rather than assumed. `scan()` returns without
-		# a word while the thread of the scan before is still to be joined, which is a frame or
-		# more after that scan stops reporting itself, and that scan then signals as it is joined.
-		# Taken as started, the answer came from a scan begun before the files were written:
-		# downstream, a rescan after 698 files were rewritten answered finished in 1.5s and the
-		# one changed file stayed on its old import. A threaded scan reports itself from inside
-		# the call, and one run on this thread has finished and signalled before it returns.
+		# Whether the scan ran, read off the editor rather than assumed. A threaded scan reports
+		# itself from inside the call, and one run on this thread has finished and signalled before
+		# it returns.
 		started = filesystem.is_scanning() or _scans_completed != completed_before
 
 	# Importing is reported separately from scanning, and a class is not registered until
@@ -87,7 +83,7 @@ func rescan_filesystem(args: Dictionary) -> Dictionary:
 	return {
 		"ok": true,
 		"started": started,
-		"scanning": filesystem.is_scanning(),
+		"scanning": GdhSceneFile.scan_unfinished(filesystem),
 		"importing": filesystem.is_importing(),
 		"scansCompletedBefore": completed_before,
 		"scansCompleted": _scans_completed,
@@ -179,7 +175,7 @@ func scan_status(_args: Dictionary) -> Dictionary:
 		"openScenes": open,
 		"editedScene": "" if shown == null else shown.scene_file_path,
 		"unsavedScenes": unsaved,
-		"scanning": filesystem.is_scanning(),
+		"scanning": GdhSceneFile.scan_unfinished(filesystem),
 		"importing": filesystem.is_importing(),
 		"pending": GdhSceneFile.scan_due,
 		"sinceScanFinishedMs":
@@ -210,13 +206,13 @@ func reimport_files(args: Dictionary) -> Dictionary:
 	if paths.is_empty():
 		return { "ok": false, "error": "reimport_files needs paths" }
 	var filesystem: EditorFileSystem = EditorInterface.get_resource_filesystem()
-	var busy: bool = filesystem.is_scanning() or filesystem.is_importing()
+	var busy: bool = GdhSceneFile.scan_unfinished(filesystem) or filesystem.is_importing()
 	if not busy:
 		_reimport.call_deferred(PackedStringArray(paths))
 	return {
 		"ok": true,
 		"started": not busy,
-		"scanning": filesystem.is_scanning(),
+		"scanning": GdhSceneFile.scan_unfinished(filesystem),
 		"importing": filesystem.is_importing(),
 		"reimportsCompletedBefore": _reimports_completed,
 	}
@@ -290,7 +286,7 @@ func files_moved(args: Dictionary) -> Dictionary:
 func _reimport(paths: PackedStringArray) -> void:
 	var filesystem: EditorFileSystem = EditorInterface.get_resource_filesystem()
 	# A scan can begin between the answer and this frame, and its import would refuse this one.
-	while filesystem.is_scanning() or filesystem.is_importing():
+	while GdhSceneFile.scan_unfinished(filesystem) or filesystem.is_importing():
 		await get_tree().process_frame
 	filesystem.reimport_files(paths)
 	_reimports_completed += 1

package/build/godot/addons/gdharness_editor/tools/scene_kin.gd

@@ -180,19 +180,7 @@ static func follow(
 ) -> Dictionary:
 	var texts: Dictionary = {}
 	_read_scenes("res://", texts)
-	var kin: Array[String] = [changed]
-	var grew: bool = true
-	while grew:
-		grew = false
-		for scene_path: String in texts:
-			if kin.has(scene_path):
-				continue
-			var text: String = texts[scene_path]
-			for one: String in kin:
-				if text.contains(' path="%s"' % one):
-					kin.append(scene_path)
-					grew = true
-					break
+	var kin: Array[String] = _kin_of(changed, texts)
 	var followed: Array[String] = []
 	var not_followed: Array[Dictionary] = []
 	for scene_path: String in kin:
@@ -247,6 +235,92 @@ static func follow(
 	return answer
 
 
+## Marks the instance a branch at [param at] in [param changed] became editable in every other
+## .tscn that instances or inherits [param changed] at any depth, wherever that scene keeps values
+## on a node inside it or adds one below it. Those still load, and the next save of that scene
+## dropped them, since the packer skips every node under an instance whose children are not
+## editable. Answers followed, the scenes marked, and notFollowed, each left with why, each only
+## when it names any.
+static func enclose(changed: String, at: String) -> Dictionary:
+	var texts: Dictionary = {}
+	_read_scenes("res://", texts)
+	var followed: Array[String] = []
+	var not_followed: Array[Dictionary] = []
+	for scene_path: String in _kin_of(changed, texts):
+		if scene_path == changed:
+			continue
+		var moves: Dictionary = {}
+		if _inherits(scene_path, changed, texts):
+			moves[at] = at
+		var read: Dictionary = GdhFileReads.scene_tree(scene_path, -1, false, false)
+		if not read.get("ok", false):
+			not_followed.append({ "scenePath": scene_path, "reason": str(read.get("error", "")) })
+			continue
+		var tree: Dictionary = read["tree"]
+		_instances_of(tree, changed, at, at, moves)
+		var text: String = texts[scene_path]
+		var marks: PackedStringArray = []
+		for path: String in moves:
+			var mark: String = '[editable path="%s"]' % path
+			if not text.contains(mark) and _holds_below(text, path):
+				var _marked: bool = marks.append(mark)
+		if marks.is_empty():
+			continue
+		var unsaved: String = GdhSceneFile.unsaved_in_editor(scene_path)
+		if not unsaved.is_empty():
+			not_followed.append({ "scenePath": scene_path, "reason": unsaved })
+			continue
+		var file: FileAccess = FileAccess.open(scene_path, FileAccess.WRITE)
+		if (file == null
+				or not file.store_string(text.rstrip("\n") + "\n\n" + "\n".join(marks) + "\n")):
+			not_followed.append(
+				{ "scenePath": scene_path, "reason": error_string(FileAccess.get_open_error()) }
+			)
+			continue
+		file.close()
+		GdhSceneFile.refresh(scene_path)
+		followed.append(scene_path)
+	var answer: Dictionary = {}
+	if not followed.is_empty():
+		answer["followed"] = followed
+	if not not_followed.is_empty():
+		answer["notFollowed"] = not_followed
+	return answer
+
+
+## Whether [param text], a scene's file, has a node entry below [param path], one setting values on
+## a node there or adding one.
+static func _holds_below(text: String, path: String) -> bool:
+	for line: String in text.split("\n"):
+		if not line.begins_with("[node "):
+			continue
+		var parent: String = _attribute(line, "parent")
+		if parent.is_empty():
+			continue
+		var full: String = _under(parent, _attribute(line, "name"))
+		if full.begins_with(path + "/"):
+			return true
+	return false
+
+
+## [param changed] and every scene in [param texts] that instances or inherits it at any depth.
+static func _kin_of(changed: String, texts: Dictionary) -> Array[String]:
+	var kin: Array[String] = [changed]
+	var grew: bool = true
+	while grew:
+		grew = false
+		for scene_path: String in texts:
+			if kin.has(scene_path):
+				continue
+			var text: String = texts[scene_path]
+			for one: String in kin:
+				if text.contains(' path="%s"' % one):
+					kin.append(scene_path)
+					grew = true
+					break
+	return kin
+
+
 ## The text of every .tscn under [param directory] into [param texts], keyed by res:// path, leaving
 ## out the engine's own folder and hidden ones.
 static func _read_scenes(directory: String, texts: Dictionary) -> void:

package/build/godot/addons/gdharness_editor/tools/scene_paths.gd

@@ -44,6 +44,9 @@ var _homes: Dictionary = {}
 ## rewrite that is not saved is put back.
 var _outside: Array[Array] = []
 var _scene: GdhSceneFile = null
+## Each unique name a node of this scene had that is unique only inside an instance now, to the
+## node's path from the root, for a %unique path through it to be written as the plain path.
+var _enclosed: Dictionary = {}
 var _moves: Dictionary = {}
 var _back: Dictionary = {}
 var _seen: Dictionary = {}
@@ -64,7 +67,7 @@ static func moved(given: String, moves: Dictionary) -> String:
 ## Carries [param moves], from the root of [param scene], into the paths it holds. Called after the
 ## move and before the write. Answers how many paths it rewrote.
 func carry(scene: GdhSceneFile, moves: Dictionary) -> int:
-	if moves.is_empty():
+	if moves.is_empty() and _enclosed.is_empty():
 		return 0
 	_scene = scene
 	_moves = moves
@@ -110,6 +113,14 @@ func carry(scene: GdhSceneFile, moves: Dictionary) -> int:
 	return retargeted.size() - before
 
 
+## Carries into [param scene] a branch saved as a scene of its own and instanced in its place, as
+## [method carry] does: each %unique path through one of [param enclosed], a unique name to its
+## node's path from the root, is written as the plain path. Answers how many paths it rewrote.
+func carry_enclosed(scene: GdhSceneFile, enclosed: Dictionary) -> int:
+	_enclosed = enclosed
+	return carry(scene, {})
+
+
 ## Opens [param scene_path], carries [param moves] into it, and writes it when that rewrote a path.
 ## Answers "" or why it was left as it was.
 func carry_into(scene_path: String, moves: Dictionary) -> String:
@@ -389,8 +400,12 @@ func _after(path: NodePath, was: String, now: String) -> Array:
 		var _named: bool = names.append(str(path.get_name(index)))
 	var start: String = was
 	var unique: bool = names[0].begins_with("%")
+	var enclosed: bool = false
 	if unique:
 		start = _unique_was(names[0].substr(1), now)
+		if start.is_empty() and _enclosed.has(names[0].substr(1)):
+			start = _enclosed[names[0].substr(1)]
+			enclosed = true
 		if start.is_empty():
 			return [UNCHANGED, ""]
 		names = names.slice(1)
@@ -398,7 +413,7 @@ func _after(path: NodePath, was: String, now: String) -> Array:
 	if target_was.is_empty():
 		return [UNCHANGED, ""]
 	var target_now: String = moved(target_was, _moves)
-	if target_now == target_was and now == was:
+	if target_now == target_was and now == was and not enclosed:
 		return [UNCHANGED, ""]
 	if target_now.is_empty():
 		return [DELETED, ""]
@@ -408,8 +423,9 @@ func _after(path: NodePath, was: String, now: String) -> Array:
 		return [UNCHANGED, ""]
 	if holder.get_node_or_null(NodePath(path.get_concatenated_names())) == target:
 		return [UNCHANGED, ""]
-	var to: String = str(holder.get_path_to(target, unique))
-	if unique:
+	var through_unique: bool = unique and not enclosed
+	var to: String = str(holder.get_path_to(target, through_unique))
+	if through_unique:
 		to = _unique_to(start, target, to)
 	if path.get_subname_count() > 0:
 		to += ":" + path.get_concatenated_subnames()

package/build/godot/addons/gdharness_editor/tools/scene_placing.gd

@@ -6,6 +6,9 @@ extends RefCounted
 const GdhFileWalk = preload("../file_walk.gd")
 const GdhRead = preload("../reading.gd")
 const GdhSame = preload("../same_values.gd")
+## Control's layout modes, which the engine does not expose to scripts.
+const POSITION_MODE: int = 0
+const ANCHORS_MODE: int = 1
 
 
 ## The scene to instance for an add, or null for a node of a class, beside why neither can be made
@@ -142,18 +145,10 @@ static func reconnect(copies: Dictionary, top: Node) -> void:
 					and (target == top or top.is_ancestor_of(target as Node))
 				):
 					continue
-				# Unbound and then bound again as Node.duplicate does: a callable made
-				# from the method alone would save the copy without the arguments the
-				# original passes.
-				var aimed: Callable = Callable(to, callable.get_method())
-				var unbound: int = callable.get_unbound_arguments_count()
-				if unbound > 0:
-					aimed = aimed.unbind(unbound)
-				if callable.get_bound_arguments_count() > 0:
-					aimed = aimed.bindv(callable.get_bound_arguments())
+				var joined: Callable = aimed(callable, to)
 				if (
-					not copy.is_connected(signal_name, aimed)
-					and copy.connect(signal_name, aimed, flags) != OK
+					not copy.is_connected(signal_name, joined)
+					and copy.connect(signal_name, joined, flags) != OK
 				):
 					push_error(
 						(
@@ -163,14 +158,29 @@ static func reconnect(copies: Dictionary, top: Node) -> void:
 					)
 
 
-## Owns [param node] and the nodes under it to [param root], except those an instanced scene
-## inside it owns: giving those to the root made the pack write the instance's own nodes into this
-## scene as overrides.
-static func own(node: Node, root: Node) -> void:
+## [param callable] aimed at [param to], unbound and then bound again as Node.duplicate does: a
+## callable made from the method alone would save the connection without the arguments the original
+## passes.
+static func aimed(callable: Callable, to: Object) -> Callable:
+	var aimed_at: Callable = Callable(to, callable.get_method())
+	var unbound: int = callable.get_unbound_arguments_count()
+	if unbound > 0:
+		aimed_at = aimed_at.unbind(unbound)
+	if callable.get_bound_arguments_count() > 0:
+		aimed_at = aimed_at.bindv(callable.get_bound_arguments())
+	return aimed_at
+
+
+## Owns [param node] to [param root], and under it the nodes the root owns already and those of
+## [param placed], the copies a duplicate placed. A node nothing owns is not the scene's: a script's
+## _init made it, which a headless engine runs and the editor does not, and owning it saved it into
+## the scene, where the script makes it again at run time. An instanced scene's own nodes stay its
+## own: giving those to the root made the pack write them into this scene as overrides.
+static func own(node: Node, root: Node, placed: Dictionary = {}) -> void:
 	node.owner = root
 	for child: Node in node.get_children():
-		if child.owner == null or child.owner == root:
-			own(child, root)
+		if child.owner == root or placed.has(child):
+			own(child, root, placed)
 
 
 ## Why [param asked] is not a position [param node] can take among [param parent]'s children, or ""
@@ -195,6 +205,30 @@ static func unplaceable(parent: Node, node: Node, asked: Variant) -> String:
 	return ""
 
 
+## Whether [param node], an instance of [param packed] just added, would load at its parent's
+## top-left corner rather than where its own scene places it. A Control its scene stores as
+## uncontrolled takes position mode under a Control that is not a Container, so the file stores
+## layout_mode 0 and leaves out the offsets, which are the scene's own. Setting position mode moves
+## a Control to the corner, so the node loads there. Anchors mode with the same anchors places it
+## the same and leaves its offsets as they load.
+static func cornered(node: Node, packed: PackedScene) -> bool:
+	var control: Control = node as Control
+	if control == null or packed == null:
+		return false
+	if GdhRead.as_int(control.get("layout_mode")) != POSITION_MODE:
+		return false
+	if control.offset_left == 0.0 and control.offset_top == 0.0:
+		return false
+	var state: SceneState = packed.get_state()
+	while state != null:
+		for property: int in state.get_node_property_count(0):
+			if str(state.get_node_property_name(0, property)) == "layout_mode":
+				var stored: int = GdhRead.as_int(state.get_node_property_value(0, property))
+				return stored != POSITION_MODE and stored != ANCHORS_MODE
+		state = state.get_base_scene_state()
+	return false
+
+
 ## Moves [param node] to [param asked] among its siblings, when a place was asked for.
 static func place(node: Node, asked: Variant) -> void:
 	if asked != null: