def spine_scene(path):
tree = deftree.DefTree()
root = tree.get_root()
root.add_attribute("spine_json", path.as_posix())
root.add_attribute("atlas", "")
root.add_attribute("sample_rate", 30)
tree.write(_fix_path(path, ".spinescene"))
def test_attribute_length(self):
tree = deftree.DefTree()
root = tree.get_root()
my_string = "string_my_long_test_string"
string_test = root.add_attribute("string", my_string)
number_test = root.add_attribute("number", 10)
self.assertTrue(len(string_test) == len(my_string))
def test_attribute_enum_representation(self):
tree = deftree.DefTree()
root = tree.get_root()
d_enum = root.add_attribute("enum", "ENUM")
self.assertTrue(d_enum == "ENUM")
self.assertTrue(d_enum.value == "ENUM")
self.assertTrue(d_enum.string == "ENUM")
def test_attribute_bool_representation(self):
tree = deftree.DefTree()
root = tree.get_root()
d_bool = root.add_attribute("bool", True)
self.assertTrue(d_bool == True)
self.assertTrue(d_bool.value is True)
self.assertTrue(d_bool.string == "true")
def test_asserts(self):
tree = deftree.DefTree()
root = tree.get_root()
attribute = root.add_attribute("attr", 1)
element = root.add_element("element")
with self.assertRaises(TypeError):
deftree.assert_is_element_or_attribute("str")
with self.assertRaises(TypeError):
deftree.assert_is_element(attribute)
with self.assertRaises(TypeError):
deftree.assert_is_attribute(element)
try:
deftree.assert_is_element_or_attribute(element)
deftree.assert_is_element_or_attribute(attribute)
except TypeError:
self.fail()
try:
deftree.assert_is_element(element)
except TypeError:
self.fail()
try:
deftree.assert_is_attribute(attribute)
except TypeError:
self.fail()
def spine_model(path):
tree = deftree.DefTree()
root = tree.get_root()
root.add_attribute("spine_scene", path.as_posix())
root.add_attribute("default_animation", "")
root.add_attribute("skin", "")
tree.write(_fix_path(path, ".spinemodel"))
def test_iterating_attributes(self):
tree = deftree.DefTree()
root = tree.get_root()
parent_element = root.add_element("parent")
child_element = parent_element.add_element("child")
child_attribute = child_element.add_attribute("id", True)
self.assertIn(child_attribute, parent_element.iter_attributes("id"))
def test_iterating_direct_attributes(self):
tree = deftree.DefTree()
root = tree.get_root()
parent_element = root.add_element("parent")
child_attribute = parent_element.add_attribute("id", True)
self.assertIn(child_attribute, parent_element.attributes())
self.assertNotIn(parent_element, root.attributes())
def test_attribute_string_representation(self):
tree = deftree.DefTree()
root = tree.get_root()
d_string = root.add_attribute("string", "deftree")
self.assertTrue(d_string == "deftree")
self.assertTrue(d_string.value == "deftree")
self.assertTrue(d_string.string == '"deftree"')
def test_attribute_number_representation(self):
tree = deftree.DefTree()
root = tree.get_root()
d_number = root.add_attribute("number", 10)
self.assertTrue(d_number == 10)
self.assertTrue(d_number.value == 10)
self.assertTrue(d_number.string == "10")
def test_clear_element(self):
tree = deftree.DefTree()
root = tree.get_root()
parent = root.add_element("parent")
parent.add_attribute("id", "true")
parent.add_attribute("name", "element")
parent.clear()
self.assertIsNone(parent.get_attribute("id"), "Failed clearing element")
def test_attribute_change_value(self):
tree = deftree.DefTree()
root = tree.get_root()
attribute = root.add_attribute("attribute", 1)
self.assertTrue(attribute == 1)
attribute.value = 2
self.assertTrue(attribute == 2)
def test_index_return_value_error(self):
tree = deftree.DefTree()
root = tree.get_root()
attr = root.add_attribute("first", "bah")
parent = root.add_element("parent")
parent.add_attribute("second", "bah")
with self.assertRaises(ValueError):
parent.index(attr)
def test_removing_children(self):
tree = deftree.DefTree()
root = tree.get_root()
parent = root.add_element("parent")
child1 = parent.add_element("child1")
child2 = parent.add_element("child2")
parent.remove(child2)
self.assertIn(child1, parent, "child1 is not found")
self.assertNotIn(child2, root, "Failed deleting child")
def test_getting_stop_iteration_on_next(self):
tree = deftree.DefTree()
root = tree.get_root()
check_against = ["first", "second", "missing"]
root.add_attribute("first", "bah")
root.add_attribute("second", "true")
with self.assertRaises(StopIteration):
for _ in check_against:
next(root)
def test_deftree_attribute_string_comparision(self):
tree = deftree.DefTree()
root = tree.get_root()
the_string = "my_string"
fake_parsed_string = root.add_attribute("Attribute", '"{}"'.format(the_string))
self.assertTrue(fake_parsed_string == the_string, "Comparing strings, fake parsed")
my_string_attribute = root.add_attribute("Attribute2", the_string)
self.assertTrue(my_string_attribute == the_string, "Comparing strings, normally added")
self.assertTrue(isinstance(fake_parsed_string, deftree.DefTreeString))
self.assertTrue(isinstance(my_string_attribute, deftree.DefTreeString))
def test_copy_element(self):
tree = deftree.DefTree()
root = tree.get_root()
parent = root.add_element("parent")
child1 = parent.add_attribute("child", True)
copy_of_parent = parent.copy()
self.assertTrue(parent.get_attribute("child").value == copy_of_parent.get_attribute("child").value)
child1.value = False
self.assertFalse(hex(id(parent.get_attribute("child"))) == hex(id(copy_of_parent.get_attribute("child"))))
self.assertTrue(len(root) == 1)
def test_deftree_attribute_enum_comparision(self):
tree = deftree.DefTree()
root = tree.get_root()
the_enum = "MY_FAKE_ENUM"
not_an_enum = "nOT_AN_ENUM"
my_enum = root.add_attribute("Attribute", the_enum)
self.assertTrue(my_enum == the_enum, "Comparing enums")
not_enum = root.add_attribute("Attribute2", not_an_enum)
self.assertTrue(isinstance(my_enum, deftree.DefTreeEnum))
self.assertFalse(isinstance(not_enum, deftree.DefTreeEnum))
def sound(path):
tree = deftree.DefTree()
root = tree.get_root()
root.add_attribute("sound", path.as_posix())
root.add_attribute("looping", 0)
root.add_attribute("group", "master")
root.add_attribute("gain", 1.0)
root.add_attribute("pan", 0.0)
root.add_attribute("speed", 1.0)
tree.write(_fix_path(path, ".sound"))
def collection(name, gui_scene):
tree = deftree.DefTree()
root = tree.get_root()
root.add_attribute("name", name)
root.add_attribute("scale_along_z", 0)
go = embedded_instance("go")
data = go.get_element("data")
data.append(components(name, gui_scene))
root.append(go)
return tree
def test_getting_the_next_child(self):
tree = deftree.DefTree()
root = tree.get_root()
check_against = ["first", "second", "third", "forth", "fifth"]
root.add_attribute("first", "bah")
root.add_attribute("second", "true")
root.add_attribute("third", "atr")
root.add_attribute("forth", "atr")
root.add_attribute("fifth", "atr")
for name in check_against:
self.assertTrue(next(root).name == name)
def test_deftree_attribute_bool_comparision(self):
tree = deftree.DefTree()
root = tree.get_root()
my_string_true = root.add_attribute("Attribute1", "true")
my_string_false = root.add_attribute("Attribute2", "false")
my_bool_true = root.add_attribute("Attribute3", True)
my_bool_false = root.add_attribute("Attribute4", False)
self.assertTrue(my_string_true == True)
self.assertTrue(my_bool_true == True)
self.assertTrue(my_string_false == False)
self.assertTrue(my_bool_false == False)
self.assertFalse(isinstance(my_string_true.__class__, deftree.DefTreeBool))
def test_attribute_string_manipulation(self):
tree = deftree.DefTree()
root = tree.get_root()
string_test_1 = root.add_attribute("string", "string_my_long_test_string")
string_test_2 = root.add_attribute("string", " string_my_long_test_string ")
self.assertTrue(string_test_1.endswith("string"))
self.assertTrue(string_test_1.startswith("string_my_"))
self.assertTrue(string_test_1.index("string") == 0)
self.assertTrue(string_test_1.rindex("string") == 20)
self.assertTrue(string_test_1.count("_") == 4)
self.assertTrue(string_test_1.replace("long", "cool") == "string_my_cool_test_string")
self.assertTrue(string_test_2.strip() == "string_my_long_test_string")
self.assertTrue(string_test_2.rstrip() == " string_my_long_test_string")
def test_parse_from_string(self):
string_doc = """profiles {\n name: "Landscape"\n qualifiers {\n width: 1280\n height: 720\n }\n}"""
string_tree = deftree.from_string(string_doc)
string_root = string_tree.get_root()
tree = deftree.DefTree()
root = tree.get_root()
profiles = root.add_element("profiles")
profiles.add_attribute("name", '"Landscape"')
qualifiers = profiles.add_element("qualifiers")
qualifiers.add_attribute("width", "1280")
qualifiers.add_attribute("height", "720")
self.assertTrue(deftree.validate(deftree.to_string(string_root), deftree.to_string(root)))
def test_deftree_attribute_numbers_assignment(self):
tree = deftree.DefTree()
root = tree.get_root()
number = root.add_attribute("number", 0)
self.assertTrue(number == 0, "Comparing number to int")
number += 4
self.assertTrue(number == 4, "Number after adding not correct")
number -= 1
self.assertTrue(number == 3, "Comparing number to int")
number *= 3
self.assertTrue(number == 9, "Comparing number to int")
self.assertTrue(isinstance(number, deftree.DefTreeNumber),
"DefTreeNumber after arithmetics are not DefTreeNumber")
def test_deftree_attribute_numbers_comparision(self):
tree = deftree.DefTree()
root = tree.get_root()
number = root.add_attribute("number", 0.0)
science = root.add_attribute("science", "4.1751063E-15")
science2 = root.add_attribute("science2", "4.6049512E-4")
self.assertTrue(science == 4.1751063e-15, "Comparing number to int")
self.assertTrue(science2 == 4.6049512E-4, "Comparing number to int")
self.assertTrue(number == 0, "Comparing number to int")
self.assertTrue(number == 0.0, "Comparing number to float")
self.assertTrue(number < 1.0, "Less than comparision")
self.assertTrue(number > -1.0, "More than comparision")
self.assertTrue(number >= 0, "More or equal to comparision")
self.assertTrue(number <= 0, "More or equal to comparision")
def test_attribute_set_enum(self):
tree = deftree.DefTree()
root = tree.get_root()
the_enum = "MY_FAKE_ENUM"
not_an_enum = "nOT_AN_ENUM"
my_enum = root.add_attribute("Attribute", the_enum)
self.assertTrue(my_enum == the_enum, "Comparing enums")
with self.assertRaises(ValueError):
root.set_attribute("Attribute", not_an_enum)
with self.assertRaises(ValueError):
root.set_attribute("Attribute", 1.0)
with self.assertRaises(ValueError):
root.set_attribute("Attribute", False)
def atlas(paths):
first_path = paths[0]
tree = deftree.DefTree()
root = tree.get_root()
for path in paths:
images = root.add_element("images")
images.add_attribute("image", path.as_posix())
root.add_attribute("margin", 0)
root.add_attribute("extrude_borders", 2)
root.add_attribute("inner_padding", 0)
if first_path.anchor == _anchor:
first_path = Path(str(first_path)[1:])
first_path = Path().cwd() / first_path.with_name("NEW_ATLAS.atlas")
tree.write(first_path)
def test_attribute_set_string(self):
tree = deftree.DefTree()
root = tree.get_root()
the_string = "my_string"
root.add_attribute("Attribute", '"{}"'.format(the_string))
root.set_attribute("Attribute", "str")
self.assertTrue(root.get_attribute("Attribute") == "str")
root.set_attribute("Attribute", '"str"')
self.assertTrue(root.get_attribute("Attribute") == "str")
with self.assertRaises(ValueError):
root.set_attribute("Attribute", False)
with self.assertRaises(ValueError):
root.set_attribute("Attribute", 1.0)
def remove_duplicates(atlas):
"""Remove all duplicated image entries in the atlas"""
tree = deftree.DefTree()
root = tree.parse(atlas)
duplicated_images = []
duplicated_images.extend(list_duplicates(root))
for animation in root.elements("animations"):
duplicated_images.extend(list_duplicates(animation))
for duplicate in duplicated_images:
print(" Removed {}".format(duplicate.value))
image_element = duplicate.get_parent()
image_element.get_parent().remove(image_element)
tree.write(atlas)
