gdharness 1.2.24 → 1.2.26

package/build/godot/operations/import_pipeline.gd

@@ -46,6 +46,9 @@ const IMPORTER_VERSIONS: Dictionary[String, int] = {"scene": 1, "animation_libra
 ## The VRAM compression formats a project can ask for, each behind its
 ## `rendering/textures/vram_compression/import_<format>` setting.
 const VRAM_FORMATS: Array[String] = ["s3tc_bptc", "etc2_astc"]
+## Options keyed by OpenType tags, by the importer that holds them. The engine keys them by the tag as
+## an int, which a caller can also name, as "liga" for ligatures.
+const OPENTYPE_OPTIONS: Dictionary[String, Array] = {"font_data_dynamic": ["opentype_features"]}
 const EDITOR_DIRECTORY: String = "res://.godot/editor"
 const EDITOR_CACHE_PREFIX: String = "filesystem_cache"
 
@@ -177,6 +180,7 @@ func set_import_options(params: Dictionary) -> Dictionary:
 		return _log.failure("Failed to parse import file: " + str(err))
 
 	# Every option checked before any is written, so a refused one leaves the sidecar as it was.
+	var importer: String = str(config.get_value("remap", "importer", ""))
 	var fitted_values: Dictionary = {}
 	var refused: Array[String] = []
 	for key: Variant in options:
@@ -184,6 +188,13 @@ func set_import_options(params: Dictionary) -> Dictionary:
 		var held: Variant = config.get_value("params", name, null)
 		var given: Variant = _values.deserialize_value(options[key])
 		var value: Variant = _as_option(_values.fitted(options[key], typeof(held)), held)
+		if value is Dictionary:
+			var entries: Dictionary = value
+			var keyed: Dictionary = _keyed_as_option(name, entries, held, importer)
+			if keyed.has("refused"):
+				refused.append(str(keyed["refused"]))
+				continue
+			value = keyed["value"]
 		# A number the option cannot hold whole is refused rather than truncated: 2.5 fitted to an
 		# enum option became 2, which is another setting.
 		var lossy: bool = (
@@ -227,6 +238,87 @@ static func _as_option(given: Variant, held: Variant) -> Variant:
 	return given
 
 
+## [param given] with the keys and values a dictionary option holds as ints made ints again.
+##
+## JSON names every key as a string and every number as a float, so a font's opentype_features was
+## written as {"1818847073": 0.0}. The importer hands that to FontFile.opentype_feature_overrides,
+## which keys features by their tag as an int, so the call reported success and the font kept its
+## ligatures. A key is an int where the importer keys the option by OpenType tags, or where every key
+## the option holds already is one; a value is an int where every value held is, or for a tag.
+## Answers the dictionary under value, or why it cannot be written under refused.
+static func _keyed_as_option(name: String, given: Dictionary, held: Variant, importer: String) -> Dictionary:
+	var tag_options: Array = OPENTYPE_OPTIONS.get(importer, [])
+	var tagged: bool = name in tag_options
+	var numbered_keys: bool = tagged or _all_ints(held, true)
+	var whole_values: bool = tagged or _all_ints(held, false)
+	if not numbered_keys and not whole_values:
+		return {"value": given}
+	var keyed: Dictionary = {}
+	for key: Variant in given:
+		var as_key: Variant = key
+		if numbered_keys:
+			as_key = _int_key(key, tagged)
+			if as_key == null:
+				var wanted: String = (
+					'OpenType tags, by name such as "liga" or as the number TextServer.name_to_tag gives'
+					if tagged
+					else "ints"
+				)
+				return {
+					"refused": "%s is keyed by %s, and %s is not one" % [name, wanted, JSON.stringify(key)]
+				}
+		var value: Variant = given[key]
+		if whole_values and value is float:
+			var number: float = value
+			if number == floorf(number):
+				value = int(number)
+		keyed[as_key] = value
+	return {"value": keyed}
+
+
+## [param key] as an int key, or null when it is not one: a whole number, written as a number or as
+## a string of digits, or where [param tagged], an OpenType tag's four characters.
+static func _int_key(key: Variant, tagged: bool) -> Variant:
+	if key is int:
+		return key
+	if key is float:
+		var number: float = key
+		if number != floorf(number):
+			return null
+		return int(number)
+	if not key is String:
+		return null
+	var text: String = key
+	if text.is_valid_int():
+		return text.to_int()
+	# Exactly four printable characters, since the engine reads a longer name by its first four and
+	# "ligatures" would quietly become "liga".
+	if tagged and text.length() == 4 and _printable(text):
+		return TextServerManager.get_primary_interface().name_to_tag(text)
+	return null
+
+
+static func _printable(text: String) -> bool:
+	for i: int in text.length():
+		var code: int = text.unicode_at(i)
+		if code < 0x20 or code > 0x7e:
+			return false
+	return true
+
+
+## Whether [param held] is a dictionary that is not empty and whose keys, or values, are all ints.
+static func _all_ints(held: Variant, keys: bool) -> bool:
+	if not held is Dictionary:
+		return false
+	var dictionary: Dictionary = held
+	if dictionary.is_empty():
+		return false
+	for item: Variant in dictionary.keys() if keys else dictionary.values():
+		if not item is int:
+			return false
+	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] = []

package/build/godot/operations/input_actions.gd

@@ -2,6 +2,7 @@ extends RefCounted
 
 const Read = preload("reading.gd")
 const Log = preload("logger.gd")
+const ProjectFile = preload("project_file.gd")
 
 # The key names a caller may write, and what the engine calls them.
 const KEY_NAMES: Dictionary = {
@@ -172,7 +173,7 @@ func add_input_action(params: Dictionary) -> Dictionary:
 	# Through ProjectSettings so the file is saved the way the editor saves it, header and
 	# every other line kept; a ConfigFile of project.godot drops the comments on the way out.
 	ProjectSettings.set_setting("input/" + action_name, action)
-	var err: Error = ProjectSettings.save()
+	var err: Error = ProjectFile.save()
 	if err != OK:
 		return _log.failure("Failed to save project.godot: " + error_string(err))
 
@@ -205,7 +206,7 @@ func remove_input_action(params: Dictionary) -> Dictionary:
 			)
 		)
 	ProjectSettings.set_setting(setting, null)
-	var err: Error = ProjectSettings.save()
+	var err: Error = ProjectFile.save()
 	if err != OK:
 		return _log.failure("Failed to save project.godot: " + error_string(err))
 	return {"action_name": action_name, "removed": true}

package/build/godot/operations/plugins.gd

@@ -2,6 +2,7 @@ extends RefCounted
 
 const Patterns = preload("patterns.gd")
 const Log = preload("logger.gd")
+const ProjectFile = preload("project_file.gd")
 
 var _log: Log
 
@@ -171,11 +172,11 @@ static func _names_of(paths: Array[String]) -> Array[String]:
 func _save_enabled_paths(paths: Array[String]) -> Error:
 	if paths.is_empty():
 		ProjectSettings.set_setting("editor_plugins/enabled", null)
-		return ProjectSettings.save()
+		return ProjectFile.save()
 
 	# Kept in an Array[String] and converted here, because appending to a packed array answers with
 	# whether it worked and a project holding return_value_discarded at error level will not compile
 	# a script that drops that answer. The conversion is what matters: an Array[String] handed to
 	# set_setting is written as Array[String]([...]), which the editor does not read as a plugin list.
 	ProjectSettings.set_setting("editor_plugins/enabled", PackedStringArray(paths))
-	return ProjectSettings.save()
+	return ProjectFile.save()

package/build/godot/operations/project_config.gd

@@ -2,6 +2,7 @@ extends RefCounted
 
 const Read = preload("reading.gd")
 const Log = preload("logger.gd")
+const ProjectFile = preload("project_file.gd")
 const Serialisation = preload("serialisation.gd")
 
 var _log: Log
@@ -124,12 +125,7 @@ func set_project_setting(params: Dictionary) -> Dictionary:
 			)
 		final_value = type_convert(final_value, wanted)
 
-	ProjectSettings.set_setting(setting_path, final_value)
-	var err: Error = ProjectSettings.save()
-	if err != OK:
-		return _log.failure("Failed to save project.godot: " + error_string(err))
-
-	return {
+	var answer: Dictionary = {
 		"setting_path": setting_path,
 		"old_value": _values.serialize_value(old_value) if had_value else null,
 		"new_value": _values.serialize_value(final_value),
@@ -137,6 +133,18 @@ func set_project_setting(params: Dictionary) -> Dictionary:
 		"was_default": was_default,
 		"saved": true,
 	}
+	# The same value in the same type is no change, and the file is left alone: a save rewrites it
+	# whole. The type is compared as well, so an int setting the file holds as 50.0 is still put right.
+	if had_value and typeof(old_value) == typeof(final_value) and old_value == final_value:
+		answer["saved"] = false
+		answer["unchanged"] = true
+		return answer
+
+	ProjectSettings.set_setting(setting_path, final_value)
+	var err: Error = ProjectFile.save()
+	if err != OK:
+		return _log.failure("Failed to save project.godot: " + error_string(err))
+	return answer
 
 
 # The type a setting wants, or TYPE_NIL where the engine names none and there is nothing to go on.
@@ -201,7 +209,7 @@ func add_autoload(params: Dictionary) -> Dictionary:
 	# "Global Variable" column. Without it the node still comes up under the root; only the name
 	# stops resolving.
 	ProjectSettings.set_setting(setting, ("*" if global else "") + path)
-	var err: Error = ProjectSettings.save()
+	var err: Error = ProjectFile.save()
 	if err != OK:
 		return _log.failure("Failed to save project.godot: " + error_string(err))
 
@@ -226,7 +234,7 @@ func remove_autoload(params: Dictionary) -> Dictionary:
 
 	var old_value: String = str(ProjectSettings.get_setting(setting))
 	ProjectSettings.set_setting(setting, null)
-	var err: Error = ProjectSettings.save()
+	var err: Error = ProjectFile.save()
 	if err != OK:
 		return _log.failure("Failed to save project.godot: " + error_string(err))
 
@@ -275,7 +283,7 @@ func set_main_scene(params: Dictionary) -> Dictionary:
 	var old_main_scene: String = str(ProjectSettings.get_setting("application/run/main_scene", ""))
 
 	ProjectSettings.set_setting("application/run/main_scene", scene_path)
-	var err: Error = ProjectSettings.save()
+	var err: Error = ProjectFile.save()
 
 	if err != OK:
 		return _log.failure("Failed to save project settings: " + str(err))

package/build/godot/operations/project_file.gd

@@ -0,0 +1,202 @@
+extends RefCounted
+
+## project.godot written through the engine's own save, in the order the file already held.
+##
+## The engine writes each section's keys in the order it registered them, and an engine running a
+## script registers them in another order than the editor does, so a one-setting change moved lines
+## nobody touched across several sections and a commit of it read as a rewrite. The save is still the
+## engine's, for what only it gets right: the header, each value's text and dropping a key that is
+## back at its default. Only the order is taken from the file as it was.
+
+const PATH: String = "res://project.godot"
+
+
+## Saves the project's settings, keeping the sections and keys already in the file where they were.
+## A key or a section new to the file goes where the engine put it relative to its neighbours.
+static func save() -> Error:
+	var before: String = FileAccess.get_file_as_string(PATH)
+	var err: Error = ProjectSettings.save()
+	if err != OK or before.is_empty():
+		return err
+	var written: String = FileAccess.get_file_as_string(PATH)
+	var kept: String = in_order_of(before, written)
+	if kept == written:
+		return OK
+	var file: FileAccess = FileAccess.open(PATH, FileAccess.WRITE)
+	if file == null:
+		return FileAccess.get_open_error()
+	if not file.store_string(kept):
+		return file.get_error()
+	file.close()
+	return OK
+
+
+## [param written] with its sections and their keys put in the order [param before] has them. Every
+## line of the result is a line of [param written], so nothing the engine wrote is lost or changed.
+static func in_order_of(before: String, written: String) -> String:
+	var old: Dictionary = _parsed(before)
+	var fresh: Dictionary = _parsed(written)
+	var old_sections: Array[Dictionary] = old["sections"]
+	var fresh_sections: Array[Dictionary] = fresh["sections"]
+
+	var old_names: Array[String] = []
+	var old_keys: Dictionary[String, Array] = {}
+	for section: Dictionary in old_sections:
+		var name: String = section["name"]
+		old_names.append(name)
+		var keys: Array[String] = []
+		for entry: Dictionary in section["entries"]:
+			keys.append(str(entry["key"]))
+		old_keys[name] = keys
+
+	var by_name: Dictionary[String, Dictionary] = {}
+	var fresh_names: Array[String] = []
+	for section: Dictionary in fresh_sections:
+		var name: String = section["name"]
+		by_name[name] = section
+		fresh_names.append(name)
+
+	var text: String = fresh["preamble"]
+	var at: int = 0
+	for name: String in _merged(old_names, fresh_names):
+		var section: Dictionary = by_name[name]
+		var entries: Array[Dictionary] = section["entries"]
+		var entry_of: Dictionary[String, String] = {}
+		var fresh_keys: Array[String] = []
+		for entry: Dictionary in entries:
+			var key: String = entry["key"]
+			entry_of[key] = str(entry["text"])
+			fresh_keys.append(key)
+		var known: Array = old_keys.get(name, [])
+		var held: Array[String] = []
+		held.assign(known)
+		text += str(section["head"])
+		for key: String in _merged(held, fresh_keys):
+			text += entry_of[key]
+		# The blank lines closing a section belong to its place in the file rather than to the
+		# section, so the last one keeps the ending the engine gave the file wherever it moved from.
+		var placed: Dictionary = fresh_sections[at]
+		text += str(placed["tail"])
+		at += 1
+	return text
+
+
+## The names of [param wanted] in the order [param held] lists them, those [param held] lacks each
+## placed after the name [param wanted] puts before it. Names [param wanted] lacks are left out.
+static func _merged(held: Array[String], wanted: Array[String]) -> Array[String]:
+	var order: Array[String] = []
+	for name: String in held:
+		if name in wanted and not name in order:
+			order.append(name)
+	var after: int = -1
+	for name: String in wanted:
+		var placed: int = order.find(name)
+		if placed == -1:
+			after += 1
+			# Not checked: a position inside the array cannot be refused.
+			var _inserted: int = order.insert(after, name)
+		else:
+			after = placed
+	return order
+
+
+## [param text] as a preamble (the header and anything before the first section) and its sections,
+## each with its header line and the blank lines after it, its entries, and the blank lines closing it.
+static func _parsed(text: String) -> Dictionary:
+	var preamble: String = ""
+	var sections: Array[Dictionary] = []
+	var current: Dictionary = {}
+	var body: Array[String] = []
+	for line: String in _logical_lines(text):
+		var stripped: String = line.strip_edges()
+		if stripped.begins_with("[") and stripped.ends_with("]"):
+			if not current.is_empty():
+				_close(current, body)
+				sections.append(current)
+			current = {"name": stripped.substr(1, stripped.length() - 2), "head": line}
+			body = []
+		elif current.is_empty():
+			preamble += line
+		elif body.is_empty() and stripped.is_empty():
+			current["head"] = str(current["head"]) + line
+		else:
+			body.append(line)
+	if not current.is_empty():
+		_close(current, body)
+		sections.append(current)
+	return {"preamble": preamble, "sections": sections}
+
+
+## Fills in [param section]'s entries and closing blank lines from the lines after its head. A blank
+## or comment line between two entries stays with the entry before it.
+static func _close(section: Dictionary, body: Array[String]) -> void:
+	var tail: String = ""
+	while not body.is_empty() and body[body.size() - 1].strip_edges().is_empty():
+		tail = body[body.size() - 1] + tail
+		body.remove_at(body.size() - 1)
+	var entries: Array[Dictionary] = []
+	for line: String in body:
+		var stripped: String = line.strip_edges()
+		if entries.is_empty() or not (stripped.is_empty() or stripped.begins_with(";")):
+			entries.append({"key": _key_of(line), "text": line})
+		else:
+			var last: Dictionary = entries[entries.size() - 1]
+			last["text"] = str(last["text"]) + line
+	section["entries"] = entries
+	section["tail"] = tail
+
+
+## The key an entry sets: everything before its first `=` outside quotes, since a key with spaces or
+## symbols in it is written quoted.
+static func _key_of(line: String) -> String:
+	var quoted: bool = false
+	for i: int in line.length():
+		var c: String = line[i]
+		if c == '"' and (i == 0 or line[i - 1] != "\\"):
+			quoted = not quoted
+		elif c == "=" and not quoted:
+			return line.substr(0, i).strip_edges()
+	return line.strip_edges()
+
+
+## [param text] split into lines that each end where an entry does: a value holding a dictionary, an
+## array or a string runs over several lines, and splitting it there would sort its halves apart.
+## Each piece keeps its line ending, so joining them gives the text back.
+static func _logical_lines(text: String) -> Array[String]:
+	var lines: Array[String] = []
+	var start: int = 0
+	var depth: int = 0
+	var quoted: bool = false
+	var escaped: bool = false
+	var comment: bool = false
+	for i: int in text.length():
+		var c: String = text[i]
+		if i == start:
+			comment = c == ";"
+		if comment:
+			if c == "\n":
+				lines.append(text.substr(start, i + 1 - start))
+				start = i + 1
+			continue
+		if quoted:
+			if escaped:
+				escaped = false
+			elif c == "\\":
+				escaped = true
+			elif c == '"':
+				quoted = false
+			continue
+		match c:
+			'"':
+				quoted = true
+			"[", "(", "{":
+				depth += 1
+			"]", ")", "}":
+				depth = maxi(depth - 1, 0)
+			"\n":
+				if depth == 0:
+					lines.append(text.substr(start, i + 1 - start))
+					start = i + 1
+	if start < text.length():
+		lines.append(text.substr(start))
+	return lines

package/build/godot/operations/serialisation.gd

@@ -321,11 +321,25 @@ static func acceptable(value: Variant, type: int) -> bool:
 ## The conversion is also what restores a packed array's exact type. Those cross as the plain JSON
 ## lists they fit into, so what comes back from the wire is an Array, and the parameter is what says
 ## it was a PackedStringArray.
+##
+## A dictionary with no tag is read as the type wanted when it carries that type's fields, as
+## scene_node and resource_edit read one: runtime_invoke refused {"x": 140, "y": 300} for a Vector2
+## argument the editor tools took, so one value was right for one tool and wrong for the next. The
+## value as sent is what is tagged, since the builders read a nested vector from its own fields.
 func fitted(value: Variant, type: int) -> Variant:
 	var rebuilt: Variant = deserialize_value(value)
 	if type == TYPE_NIL or typeof(rebuilt) == type:
 		return rebuilt
 
+	if value is Dictionary and type != TYPE_DICTIONARY:
+		var fields: Dictionary = value
+		if not fields.has("_type"):
+			var tagged: Dictionary = fields.duplicate()
+			tagged["_type"] = type_string(type)
+			var built: Variant = deserialize_value(tagged)
+			if typeof(built) == type:
+				return built
+
 	if rebuilt is Array and LIST_TYPES.has(type):
 		return type_convert(rebuilt, type)
 
@@ -348,6 +362,21 @@ func fitted(value: Variant, type: int) -> Variant:
 	return type_convert(rebuilt, type)
 
 
+## 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":
+		return ""
+	var keys: Array = alternatives[0]
+	var parts: Array[String] = []
+	for key: Variant in keys:
+		parts.append('"%s": ...' % key)
+	return "{%s}" % ", ".join(parts)
+
+
 ## Whether [param fields] carries every key of any one of [param alternatives].
 ##
 ## More than one spelling because a rectangle has two: the two corners it is answered with, and the