JonShard
360 lines
11 KiB
GDScript
360 lines
11 KiB
GDScript
extends ExampleBase
|
|
|
|
const YAML_FILE = "res://addons/yaml/examples/data/supported_syntax.yaml"
|
|
const STYLE_FILE = "user://supported_syntax.style.yaml"
|
|
|
|
var data
|
|
var style: YAMLStyle
|
|
|
|
func _init() -> void:
|
|
icon = "🎨"
|
|
|
|
func run_examples() -> void:
|
|
run_example("Style Extraction", style_extraction)
|
|
run_example("Stringify with Style", stringify_with_style)
|
|
run_example("Style Cloning", style_cloning)
|
|
run_example("Style Merging", style_merging)
|
|
run_example("Child Styles", child_styles)
|
|
run_example("Path-based Styles", get_at_path)
|
|
run_example("Style Propagation", propagate_scalar_styles)
|
|
run_example("Various Style Combinations", various_style_combinations)
|
|
run_example("Style Serialization", to_from_dictionary)
|
|
|
|
func style_extraction() -> void:
|
|
log_info("Loading YAML file with style detection...")
|
|
|
|
var result = YAML.load_file(YAML_FILE, null, true)
|
|
if result.has_error():
|
|
log_error("Failed to load file: " + result.get_error())
|
|
return
|
|
|
|
data = result.get_data()
|
|
style = result.get_style()
|
|
|
|
if !style:
|
|
log_error("Could not extract style")
|
|
return
|
|
|
|
log_success("Style extracted successfully")
|
|
|
|
if LOG_VERBOSE:
|
|
log_result("Extracted Styles:\n" + style.get_debug_string())
|
|
|
|
log_info("Saving style to file: " + STYLE_FILE)
|
|
var save_result = style.save_file(STYLE_FILE)
|
|
|
|
if save_result.has_error():
|
|
log_error("Failed to save style: " + save_result.get_error())
|
|
return
|
|
|
|
log_success("Style saved to file")
|
|
|
|
func stringify_with_style() -> void:
|
|
log_info("Loading style from file...")
|
|
|
|
var load_result = YAMLStyle.load_file(STYLE_FILE)
|
|
if load_result.has_error():
|
|
log_error("Failed to load style: " + load_result.get_error())
|
|
return
|
|
|
|
var load_style = load_result.get_style()
|
|
|
|
if style && load_style.hash() == style.hash():
|
|
log_success("Loaded style matches the original style")
|
|
else:
|
|
log_warning("Loaded style does not match the original style")
|
|
|
|
if data == null:
|
|
data = {"test": "value"}
|
|
|
|
log_info("Stringifying data with loaded style...")
|
|
var stringify_result = YAML.stringify(data, load_style)
|
|
|
|
if stringify_result.has_error():
|
|
log_error("Stringify failed: " + stringify_result.get_error())
|
|
return
|
|
|
|
log_success("Data stringified with style")
|
|
|
|
if LOG_VERBOSE:
|
|
log_result("Styled YAML output:\n" + stringify_result.get_data())
|
|
|
|
func style_cloning() -> void:
|
|
log_info("Creating and configuring base style...")
|
|
|
|
var style := YAML.create_style()
|
|
style.set_string_style(YAMLStyle.STRING_QUOTE_DOUBLE)
|
|
style.set_flow_style(YAMLStyle.FLOW_NONE)
|
|
|
|
log_info("Cloning style...")
|
|
var cloned_style := style.clone()
|
|
|
|
if style.get_string_style() == cloned_style.get_string_style() && \
|
|
style.get_flow_style() == cloned_style.get_flow_style():
|
|
log_success("Cloned style has same properties as original")
|
|
else:
|
|
log_error("Cloned style properties don't match original")
|
|
|
|
log_info("Modifying the cloned style...")
|
|
cloned_style.set_string_style(YAMLStyle.STRING_QUOTE_SINGLE)
|
|
|
|
if style.get_string_style() != cloned_style.get_string_style():
|
|
log_success("Modifying clone doesn't affect original")
|
|
else:
|
|
log_error("Modifying clone affected original")
|
|
|
|
if LOG_VERBOSE:
|
|
var test_data = {"message": "Hello, World!"}
|
|
|
|
var orig_result = YAML.stringify(test_data, style)
|
|
var clone_result = YAML.stringify(test_data, cloned_style)
|
|
|
|
log_result("Original style output:\n" + orig_result.get_data())
|
|
log_result("Cloned style output:\n" + clone_result.get_data())
|
|
|
|
func style_merging() -> void:
|
|
log_info("Creating two different styles...")
|
|
|
|
var style1 := YAML.create_style()
|
|
style1.set_string_style(YAMLStyle.STRING_QUOTE_DOUBLE)
|
|
|
|
var style2 := YAML.create_style()
|
|
style2.set_flow_style(YAMLStyle.FLOW_SINGLE)
|
|
|
|
log_info("Merging style2 into style1...")
|
|
style1.merge_with(style2)
|
|
|
|
if style1.get_string_style() == YAMLStyle.STRING_QUOTE_DOUBLE:
|
|
log_success("Original style properties preserved")
|
|
else:
|
|
log_error("Original style properties were lost")
|
|
|
|
if style1.get_flow_style() == YAMLStyle.FLOW_SINGLE:
|
|
log_success("Properties from merged style were added")
|
|
else:
|
|
log_error("Properties from merged style were not added")
|
|
|
|
if LOG_VERBOSE:
|
|
var test_data = {
|
|
"message": "Hello, World!",
|
|
"items": ["one", "two", "three"]
|
|
}
|
|
|
|
var result = YAML.stringify(test_data, style1)
|
|
log_result("Merged style output:\n" + result.get_data())
|
|
|
|
func child_styles() -> void:
|
|
log_info("Creating parent style with child styles...")
|
|
|
|
var style := YAML.create_style()
|
|
style.set_string_style(YAMLStyle.STRING_QUOTE_DOUBLE)
|
|
|
|
log_info("Creating child style for 'list' key...")
|
|
var list_style := style.create_child("list")
|
|
list_style.set_flow_style(YAMLStyle.FLOW_SINGLE)
|
|
|
|
if style.get_child("list") == list_style:
|
|
log_success("get_child() retrieves the correct child style")
|
|
else:
|
|
log_error("get_child() failed to retrieve the correct child style")
|
|
|
|
if style.has_child("list"):
|
|
log_success("has_child() correctly identifies existing child")
|
|
else:
|
|
log_error("has_child() failed to identify existing child")
|
|
|
|
var child_keys := style.list_children()
|
|
if child_keys.has("list"):
|
|
log_success("list_children() includes the child key")
|
|
else:
|
|
log_error("list_children() failed to include the child key")
|
|
|
|
if LOG_VERBOSE:
|
|
var test_data = {
|
|
"name": "Example",
|
|
"list": ["one", "two", "three"]
|
|
}
|
|
|
|
var result = YAML.stringify(test_data, style)
|
|
log_result("Output with child styles:\n" + result.get_data())
|
|
|
|
func get_at_path() -> void:
|
|
log_info("Creating nested style structure...")
|
|
|
|
var style := YAML.create_style()
|
|
|
|
# Create a nested style structure
|
|
var maps_style := style.create_child("maps")
|
|
var items_style := maps_style.create_child("items")
|
|
var first_item_style := items_style.create_child("0")
|
|
first_item_style.set_string_style(YAMLStyle.STRING_LITERAL)
|
|
|
|
log_info("Getting style at path 'maps/items/0'...")
|
|
var path_style := style.get_at_path("maps/items/0")
|
|
|
|
if path_style && path_style.get_string_style() == YAMLStyle.STRING_LITERAL:
|
|
log_success("get_at_path() correctly retrieved the style")
|
|
else:
|
|
log_error("get_at_path() failed to retrieve the correct style")
|
|
|
|
log_info("Creating missing path 'maps/items/1/properties'...")
|
|
var new_path_style := style.get_at_path("maps/items/1/properties", true)
|
|
|
|
if new_path_style != null:
|
|
log_success("Successfully created missing path nodes")
|
|
else:
|
|
log_error("Failed to create missing path nodes")
|
|
|
|
log_info("Getting non-existent path without creating...")
|
|
var missing_style := style.get_at_path("non/existent/path", false)
|
|
|
|
if missing_style == null:
|
|
log_success("Correctly returned null for non-existent path")
|
|
else:
|
|
log_error("Incorrectly returned non-null for non-existent path")
|
|
|
|
if LOG_VERBOSE:
|
|
var test_data = {
|
|
"maps": {
|
|
"items": [
|
|
{"name": "Item 1", "description": "Line 1\nLine 2\nLine 3"},
|
|
{"name": "Item 2", "properties": {"a": 1, "b": 2}}
|
|
]
|
|
}
|
|
}
|
|
|
|
var result = YAML.stringify(test_data, style)
|
|
log_result("Output with path-based styles:\n" + result.get_data())
|
|
|
|
func propagate_scalar_styles() -> void:
|
|
log_info("Creating parent style with scalar formats...")
|
|
|
|
var parent_style := YAML.create_style()
|
|
parent_style.set_string_style(YAMLStyle.STRING_QUOTE_DOUBLE)
|
|
parent_style.set_integer_format(YAMLStyle.INT_HEX)
|
|
parent_style.set_float_format(YAMLStyle.FLOAT_SCIENTIFIC)
|
|
|
|
log_info("Creating child style and propagating scalar styles...")
|
|
var child_style := YAML.create_style()
|
|
parent_style.propagate_scalar_styles(child_style)
|
|
|
|
if child_style.get_string_style() == YAMLStyle.STRING_QUOTE_DOUBLE:
|
|
log_success("String style was propagated")
|
|
else:
|
|
log_error("String style was not propagated")
|
|
|
|
if child_style.get_integer_format() == YAMLStyle.INT_HEX:
|
|
log_success("Integer format was propagated")
|
|
else:
|
|
log_error("Integer format was not propagated")
|
|
|
|
if child_style.get_float_format() == YAMLStyle.FLOAT_SCIENTIFIC:
|
|
log_success("Float format was propagated")
|
|
else:
|
|
log_error("Float format was not propagated")
|
|
|
|
if LOG_VERBOSE:
|
|
var test_data = {
|
|
"text": "Hello, World!",
|
|
"number": 255,
|
|
"decimal": 3.14159
|
|
}
|
|
|
|
var result = YAML.stringify(test_data, child_style)
|
|
log_result("Output with propagated styles:\n" + result.get_data())
|
|
|
|
func various_style_combinations() -> void:
|
|
log_info("Creating data with various types...")
|
|
|
|
var data := {
|
|
"string_value": "Test string with \"quotes\" and newlines\nto test",
|
|
"int_value": 255,
|
|
"float_value": 3.14159,
|
|
"list": ["item1", "item2", "item3"],
|
|
"dict": {"key1": "val1", "key2": "val2"}
|
|
}
|
|
|
|
log_info("Creating style with various formatting options...")
|
|
var style := YAML.create_style()
|
|
style.set_string_style(YAMLStyle.STRING_LITERAL)
|
|
style.set_integer_format(YAMLStyle.INT_HEX)
|
|
style.set_float_format(YAMLStyle.FLOAT_SCIENTIFIC)
|
|
|
|
# List should be compact
|
|
var list_style := style.create_child("list")
|
|
list_style.set_flow_style(YAMLStyle.FLOW_SINGLE)
|
|
|
|
# Dict should be expanded
|
|
var dict_style := style.create_child("dict")
|
|
dict_style.set_flow_style(YAMLStyle.FLOW_NONE)
|
|
|
|
log_info("Stringifying with custom styles...")
|
|
var result := YAML.stringify(data, style)
|
|
|
|
if result.has_error():
|
|
log_error("Stringify failed: " + result.get_error())
|
|
return
|
|
|
|
log_success("Data stringified with custom styles")
|
|
|
|
if LOG_VERBOSE:
|
|
log_result("Styled YAML output:\n" + result.get_data())
|
|
|
|
log_info("Parsing styled output with style detection...")
|
|
var parse_result := YAML.parse(result.get_data(), null, true)
|
|
|
|
if parse_result.has_error():
|
|
log_error("Parse failed: " + parse_result.get_error())
|
|
return
|
|
|
|
var detected_style := parse_result.get_style()
|
|
|
|
if detected_style != null:
|
|
log_success("Style was detected during parsing")
|
|
|
|
if LOG_VERBOSE:
|
|
log_result("Detected Style Tree:\n" + detected_style.get_debug_string())
|
|
else:
|
|
log_error("Style was not detected during parsing")
|
|
|
|
func to_from_dictionary() -> void:
|
|
log_info("Creating style for serialization...")
|
|
|
|
var style := YAML.create_style()
|
|
style.set_string_style(YAMLStyle.STRING_QUOTE_DOUBLE)
|
|
|
|
var child := style.create_child("child")
|
|
child.set_flow_style(YAMLStyle.FLOW_SINGLE)
|
|
|
|
log_info("Converting style to dictionary...")
|
|
var dict := style.to_dictionary()
|
|
|
|
if dict.has("string") && dict.has("children"):
|
|
log_success("Dictionary contains style properties and children")
|
|
else:
|
|
log_error("Dictionary missing expected keys")
|
|
|
|
log_info("Rebuilding style from dictionary...")
|
|
var rebuilt_style := YAMLStyle.from_dictionary(dict)
|
|
|
|
if rebuilt_style.get_string_style() == YAMLStyle.STRING_QUOTE_DOUBLE:
|
|
log_success("Rebuilt style maintained properties")
|
|
else:
|
|
log_error("Rebuilt style lost properties")
|
|
|
|
if rebuilt_style.has_child("child"):
|
|
log_success("Rebuilt style maintains children")
|
|
else:
|
|
log_error("Rebuilt style lost children")
|
|
|
|
var rebuilt_hash := rebuilt_style.hash()
|
|
var original_hash := style.hash()
|
|
|
|
if rebuilt_hash == original_hash:
|
|
log_success("Style hashes match")
|
|
else:
|
|
log_error("Style hashes don't match")
|
|
|
|
if LOG_VERBOSE:
|
|
log_result("Style dictionary:\n" + str(dict))
|