def get_all_referenced_structs(s):
mm = get_metamodel(s)
l = set()
l.add(s)
n = 0
while n != len(l):
n = len(l)
l0 = l.copy()
for s in l0:
c = get_children_of_type("ScalarAttribute", s)
for a in c:
if textx_isinstance(a.type, mm["Struct"]):
l.add(a.type)
# print(f"1added {a.type.name}")
c = get_children_of_type("ArrayAttribute", s)
for a in c:
if textx_isinstance(a.type, mm["Struct"]):
l.add(a.type)
# print(f"2added {a.type.name}")
c = get_children_of_type("VariantMapping", s)
for m in c:
if textx_isinstance(m.type, mm["Struct"]):
l.add(m.type)
# print(f"3added {m.type.name}")
return l
def generate_cpp(metamodel, model, output_path, overwrite, debug):
"Generating c++ code from the item model"
input_file = model._tx_filename
base_dir = output_path if output_path else os.path.dirname(input_file)
structs = get_children_of_type("Struct", model)
enums = get_children_of_type("Enum", model)
constants = get_children_of_type("Constants", model)
for elem in structs:
output_file = create_folder_and_return_output_filename(
elem, base_dir, overwrite
)
generate_cpp_for_struct(elem, output_file, overwrite)
for elem in enums:
output_file = create_folder_and_return_output_filename(
elem, base_dir, overwrite
)
generate_cpp_for_enum(elem, output_file, overwrite)
for elem in constants:
output_file = create_folder_and_return_output_filename(
elem, base_dir, overwrite
)
generate_cpp_for_constants(elem, output_file, overwrite)
def test_children():
"""
This test checks the get_children function
"""
#################################
# META MODEL DEF
#################################
my_metamodel = metamodel_from_str(metamodel_str)
my_metamodel.register_scope_providers({"*.*": scoping_providers.FQN()})
#################################
# MODEL PARSING
#################################
my_model = my_metamodel.model_from_str('''
package P1 {
class Part1 {
}
}
package P2 {
class Part2 {
attr C2 rec;
}
class C2 {
attr P1.Part1 p1;
attr Part2 p2a;
attr P2.Part2 p2b;
}
}
''')
#################################
# TEST
#################################
res = get_children_of_type("Class", my_model)
res.sort(key=lambda x: x.name)
assert len(res) == 3
assert all(map(eq, map(lambda x: x.name, res), ["C2", "Part1", "Part2"]))
assert not all(map(eq, map(lambda x: x.name, res),
["Part1", "Part2", "C2"]))
for x in res:
assert x.__class__.__name__ == "Class"
res = get_children_of_type("Attribute", my_model)
res.sort(key=lambda x: x.name)
assert len(res) == 4
assert all(map(eq, map(lambda x: x.name, res),
["p1", "p2a", "p2b", "rec"]))
for x in res:
assert x.__class__.__name__ == "Attribute"
res = get_children(lambda x: hasattr(x, "name") and re.match(
".*2.*", x.name), my_model)
res.sort(key=lambda x: x.name)
assert len(res) == 5
assert all(map(eq, map(lambda x: x.name, res),
["C2", "P2", "Part2", "p2a", "p2b"]))
def test_big_example():
mm = metamodel_for_language("item")
assert mm is not None
inpath = join(this_folder, "model")
model = mm.model_from_file(join(inpath, "big_example.item"))
assert model is not None
outpath = join(this_folder, "src-gen")
gen = generator_for_language_target("item", "cpp_v2")
if exists(outpath):
rmtree(outpath)
mkdir(outpath)
gen(mm, model, output_path=outpath, overwrite=True, debug=False)
refpath = join(inpath, "ref")
structs = get_children_of_type("Struct", model)
enums = get_children_of_type("Enum", model)
constants = get_children_of_type("Constants", model)
for s in structs + enums + constants:
outputfile = output_filename(refpath, s, "regex_ref")
if exists(outputfile):
check_file(
filename=output_filename(outpath, s),
regex_reference_filename=outputfile,
)
def do_test_diagram_choice(diagram):
transitions = textx.get_children_of_type("TransitionExpression", diagram._model)
assert len(transitions) == 4
pseudo_states = textx.get_children_of_type("PseudoState", diagram._model)
assert len(pseudo_states) == 1
assert pseudo_states[0].type == "<<choice>>"
def test_attr_ref2():
text = r"""
package example
struct Point {
scalar x : built_in.float
scalar y : built_in.float
}
struct Header {
scalar n : built_in.uint32 (.maxValue=100, .defaultValue=1)
scalar nb_bytes: built_in.uint32
}
struct Polygon {
scalar header: Header
array points : Point[header.n]
}
"""
mm = metamodel_for_language("item")
assert mm is not None
model = mm.model_from_str(text)
assert model is not None
items = get_children_of_type("Struct", model)
assert len(items) == 3
assert not items[2].attributes[1].has_fixed_size()
Header = items[1]
Polygon = items[2]
r = get_children_of_type("AttrRef", Polygon.attributes[1])
assert len(r) == 1
assert r[0].ref == Header.attributes[0]
def test_is_dynamic():
mm = metamodel_for_language("item")
assert mm is not None
model = mm.model_from_file(
os.path.join(
os.path.abspath(os.path.dirname(__file__)), "model", "big_example.item"
)
)
assert model is not None
Color = next(
filter(lambda x: x.name == "Color", get_children_of_type("Struct", model))
)
assert Color.name == "Color"
assert not is_dynamic(Color.attributes[0])
assert not is_dynamic(Color)
MultiMessage = next(
filter(
lambda x: x.name == "MultiMessage", get_children_of_type("Struct", model)
)
)
assert MultiMessage.name == "MultiMessage"
assert is_dynamic(MultiMessage)
Polygon = next(
filter(lambda x: x.name == "Polygon", get_children_of_type("Struct", model))
)
assert Polygon.name == "Polygon"
assert not is_dynamic(Polygon.attributes[0])
assert is_dynamic(Polygon.attributes[1])
assert not is_dynamic(Polygon.attributes[2])
assert is_dynamic(Polygon)
def model_export(model, output_file):
import jinja2
plan = get_children_of_type("Plan", model)
assert len(plan) == 1
plan = plan[0]
all_ingredients = {} # ingredientType, count
for e in get_children_of_type("PlanEntry", plan):
for i in get_children_of_type("Ingredient", e.get_recipe()):
all_ingredients[i.get_type()] = \
all_ingredients.get(i.get_type(),0.0) \
+ i.get_count_in_default_units(float(e.person_count))
#print("{} {}".format(i.get_type().name, all_ingredients[i.get_type()]))
config = get_all(model, "Config")
config = config[0]
this_folder = dirname(abspath(__file__))
jinja_env = jinja2.Environment(loader=jinja2.FileSystemLoader(
join(this_folder, "template")),
trim_blocks=True,
lstrip_blocks=True)
template = jinja_env.get_template('plan.template')
with open(output_file, 'w') as f:
f.write(
template.render(plan=plan,
config=config,
all_ingredients=all_ingredients))
def do_test_diagram_long_state_names(diagram):
transitions = textx.get_children_of_type("TransitionExpression", diagram._model)
assert len(transitions) == 11
alias = textx.get_children_of_type("StateAliasExpression", diagram._model)
assert len(alias) == 1
assert alias[0].longname == r"Accumulate Enough Data\nLong State Name"
assert alias[0].name == "long1"
def test_fully_qualified_name_ref():
#################################
# META MODEL DEF
#################################
my_metamodel = metamodel_from_str(metamodel_str)
my_metamodel.register_scope_providers({"*.*": scoping_providers.FQN()})
#################################
# MODEL PARSING
#################################
my_model = my_metamodel.model_from_str('''
package P1 {
class Part1 {
}
}
package P2 {
class Part2 {
attr C2 rec;
}
class C2 {
attr P1.Part1 p1;
attr Part2 p2a;
attr P2.Part2 p2b;
}
}
''')
#################################
# TEST
#################################
res = get_children_of_type("Class", my_model)
res.sort(key=lambda x: x.name)
assert len(res) == 3
assert all(map(eq, map(lambda x: x.name, res), ["C2", "Part1", "Part2"]))
assert not all(
map(eq, map(lambda x: x.name, res), ["Part1", "Part2", "C2"]))
for x in res:
assert x.__class__.__name__ == "Class"
res = get_children_of_type("Attribute", my_model)
res.sort(key=lambda x: x.name)
assert len(res) == 4
assert all(map(eq, map(lambda x: x.name, res),
["p1", "p2a", "p2b", "rec"]))
for x in res:
assert x.__class__.__name__ == "Attribute"
res = get_children(
lambda x: hasattr(x, "name") and re.match(".*2.*", x.name), my_model)
res.sort(key=lambda x: x.name)
assert len(res) == 5
assert all(
map(eq, map(lambda x: x.name, res),
["C2", "P2", "Part2", "p2a", "p2b"]))
def do_test_diagram_fork_join(diagram):
transitions = textx.get_children_of_type("TransitionExpression", diagram._model)
assert len(transitions) == 7
fork_joins = textx.get_children_of_type("PseudoState", diagram._model)
assert len(fork_joins) == 2
assert fork_joins[0].type == "<<fork>>"
assert fork_joins[1].type == "<<join>>"
def do_test_diagram_expansions(diagram):
transitions = textx.get_children_of_type("TransitionExpression", diagram._model)
assert len(transitions) == 7
pseudo_states = textx.get_children_of_type("PseudoState", diagram._model)
assert len(pseudo_states) == 3
assert pseudo_states[0].type == "<<expansionInput>>"
assert pseudo_states[1].type == "<<expansionInput>>"
assert pseudo_states[2].type == "<<expansionOutput>>"
def do_test_diagram_entry_exit_pin(diagram):
transitions = textx.get_children_of_type("TransitionExpression", diagram._model)
assert len(transitions) == 7
pseudo_states = textx.get_children_of_type("PseudoState", diagram._model)
assert len(pseudo_states) == 3
assert pseudo_states[0].type == "<<inputPin>>"
assert pseudo_states[1].type == "<<inputPin>>"
assert pseudo_states[2].type == "<<outputPin>>"
def test_model_with_local_scope_and_circular_ref_via_two_models():
"""
Test for FQNGlobalRepo + circular references.
"""
#################################
# META MODEL DEF
#################################
my_meta_model = metamodel_from_file(
join(abspath(dirname(__file__)),
'components_model1', 'Components.tx'),
global_repository=True)
global_scope = scoping_providers.FQNGlobalRepo(
join(abspath(dirname(__file__)),
"components_model1", "example_?.components"))
my_meta_model.register_scope_providers({
"*.*": global_scope,
"Connection.from_port":
scoping_providers.RelativeName("from_inst.component.slots"),
"Connection.to_port":
scoping_providers.RelativeName("to_inst.component.slots")
})
#################################
# MODEL PARSING
#################################
my_model_a = my_meta_model.model_from_file(
join(abspath(dirname(__file__)),
"components_model1", "example_A.components"))
my_model_b = my_meta_model.model_from_file(
join(abspath(dirname(__file__)),
"components_model1", "example_B.components"))
a_my_a = get_unique_named_object(my_model_a, "mya")
a_my_b = get_unique_named_object(my_model_a, "myb")
b_my_a = get_unique_named_object(my_model_b, "mya")
b_my_b = get_unique_named_object(my_model_b, "myb")
assert a_my_a != b_my_a
assert a_my_b != b_my_b
assert a_my_a.component == b_my_a.component # same component "class"
assert a_my_b.component == b_my_b.component # same component "class"
a_connections = get_children_of_type("Connection", my_model_a)
b_connections = get_children_of_type("Connection", my_model_b)
a_connection = list(filter(
lambda x: x.from_inst == a_my_a and x.to_inst == a_my_b,
a_connections))
b_connection = list(filter(
lambda x: x.from_inst == b_my_a and x.to_inst == b_my_b,
b_connections))
assert len(a_connection) == 1
assert len(b_connection) == 1
def do_test_diagram_pseudostates(diagram):
transitions = textx.get_children_of_type("TransitionExpression", diagram._model)
assert len(transitions) == 9
pseudo_states = textx.get_children_of_type("PseudoState", diagram._model)
assert len(pseudo_states) == 4
assert pseudo_states[0].type == "<<choice>>"
assert pseudo_states[1].type == "<<fork>>"
assert pseudo_states[2].type == "<<join>>"
assert pseudo_states[3].type == "<<end>>"
def do_test_diagram_inline_pseudostate(diagram):
transitions = textx.get_children_of_type("TransitionExpression", diagram._model)
assert len(transitions) == 7
pseudo_states = textx.get_children_of_type("PseudoState", diagram._model)
assert len(pseudo_states) == 3
assert pseudo_states[0].type == "<<entryPoint>>"
assert pseudo_states[1].type == "<<entryPoint>>"
assert pseudo_states[2].type == "<<exitPoint>>"
assert pseudo_states[2].parent.name == "exitA"
assert pseudo_states[2].parent.parent.__class__.__name__ == "TransitionExpression"
def test_get_children_of_type():
metamodel = metamodel_from_str(grammar)
model = metamodel.model_from_str(model_str)
thirds = get_children_of_type('Third', model)
assert len(thirds) == 5
assert set(['first', 'second', 'third', 'one', 'two']) \
== set([a.x for a in thirds])
# Test search in the part of the model
thirds = get_children_of_type("Third", model.a[1])
assert len(thirds) == 1
assert 'two' == list(thirds)[0].x
def test_get_children_of_type():
metamodel = metamodel_from_str(grammar)
model = metamodel.model_from_str(model_str)
thirds = get_children_of_type('Third', model)
assert len(thirds) == 5
assert set(['first', 'second', 'third', 'one', 'two']) \
== set([a.x for a in thirds])
# Test search in the part of the model
thirds = get_children_of_type("Third", model.a[1])
assert len(thirds) == 1
assert 'two' == list(thirds)[0].x
def do_test_diagram_composite_states_1(diagram):
transitions = textx.get_children_of_type("TransitionExpression", diagram._model)
assert len(transitions) == 2
composites = textx.get_children_of_type("CompositeState", diagram._model)
assert len(composites) == 5
names = ["A", "X", "Y", "B", "Z"]
for i, s in enumerate(composites):
assert s.parent.name == names[i]
assert composites[1].parent.parent == composites[0]
assert composites[2].parent.parent == composites[0]
assert composites[4].parent.parent == composites[3]
def test_big_example():
mm = metamodel_for_language("item")
assert mm is not None
inpath = join(this_folder, "../../mdsd_support_library_common/model")
model = mm.model_from_file(join(inpath, "big_example.item"))
assert model is not None
refpath = join(this_folder, "model", "ref")
structs = get_children_of_type("Struct", model)
enums = get_children_of_type("Enum", model)
constants = get_children_of_type("Constants", model)
outpath = join(this_folder, "../src-gen")
def _generate_python_construct_code(idl_model, srcgen_folder, this_folder):
import itemlang.itemc.support_python_construct_code.custom_idl_pyctool as pyctool
jinja_env = jinja2.Environment(
loader=jinja2.FileSystemLoader(this_folder +
"/support_python_construct_code"),
trim_blocks=True,
lstrip_blocks=True)
# Load Java template
template = jinja_env.get_template('python-construct.template')
for struct in get_children_of_type("Struct", idl_model):
# For each entity generate java file
struct_folder = join(srcgen_folder, pyctool.path_to_file_name(struct))
if not exists(struct_folder):
makedirs(struct_folder)
if struct.parent.target_namespace:
parts = struct.parent.target_namespace.name.split(".")
dir = srcgen_folder
for part in parts:
dir = join(dir, part)
init_filename = join(dir, "__init__.py")
with open(init_filename, 'w') as f:
f.write("")
with open(join(srcgen_folder, pyctool.full_path_to_file_name(struct)),
'w') as f:
f.write(template.render(struct=struct, pyctool=pyctool))
def test_attr_formula1():
text = r"""
package example
struct Image {
scalar w: built_in.uint32 (.defaultValue=1, .maxValue=1000)
scalar h: built_in.uint32 (.defaultValue=1, .maxValue=1000)
array pixel : built_in.float[w*h]
}
"""
mm = metamodel_for_language("item")
assert mm is not None
model = mm.model_from_str(text)
assert model is not None
items = get_children_of_type("Struct", model)
assert len(items) == 1
model._tx_filename = "example.item"
path = os.path.join(os.path.abspath(os.path.dirname(__file__)), "src-gen")
gen1 = generator_for_language_target("item", "cpp")
gen2 = generator_for_language_target("item", "python")
if os.path.exists(path):
shutil.rmtree(path)
os.mkdir(path)
gen1(mm, model, output_path=path, overwrite=True, debug=False)
gen2(mm, model, output_path=path, overwrite=True, debug=False)
cpp_code = open(os.path.join(path, "example", "Image.h")).read()
print(cpp_code)
assert "struct Image" in cpp_code
assert "s.w*s.h" in cpp_code
def __init__(self, spec, context=None):
super().__init__(spec)
# Find out if this param is dependent on trial condition variables
test = get_parent_of_type("TestType", self.spec)
cond_var_names = test.table_spec.variables
self.value = spec.value
if isinstance(self.value, String):
# Special handling of strings. If there is a variable reference
# consider it non-constant
self.is_constant = '{{' not in self.value.value
else:
# expressions with variables or messages are considered non-constant
self.is_constant = \
not any([r.name in cond_var_names
for r in unresolvable_refs(self.value)])\
and not get_children_of_type("MessageExpression", self.value)
if not self.is_constant and context is None:
# Use default value
self.value = spec.type.default.eval()
else:
try:
self.value = self.value.eval(context)
except PyFliesException as e:
if 'Undefined variable' in str(e):
# This may happen if expression contains strings with
# interpolated variables which are not available
# Use default value
self.value = spec.type.default.eval()
def test_model_with_multi_import():
"""
Basic test for FQNImportURI + multi imports (import "*.if")
"""
#################################
# META MODEL DEF
#################################
my_meta_model = metamodel_from_file(
join(abspath(dirname(__file__)),
'interface_model1', 'Interface.tx'))
my_meta_model.register_scope_providers(
{"*.*": scoping_providers.FQNImportURI()})
#################################
# MODEL PARSING
#################################
my_model = my_meta_model.model_from_file(
join(abspath(dirname(__file__)),
"interface_model1", "model_c", "A_multi_import.if"))
#################################
# TEST MODEL
#################################
imports = get_children_of_type("Import", my_model)
assert 1 == len(imports)
i = imports[0]
assert 4 == len(i._tx_loaded_models) # 4 files
assert 4 == len(set(i._tx_loaded_models)) # 4 different files
def test_property2():
text = r"""
package example.one (property_set example.one.ProjExt)
property_set ProjExt {
property optional myprop1: STRING
property applicable for rawtype, enum myprop2: ATTRTYPE
}
struct A {
scalar x: built_in.int32 (.description="a", .myprop2=1)
}
"""
mm = metamodel_for_language("item")
assert mm is not None
model = mm.model_from_str(text)
assert model is not None
items = get_children_of_type("Struct", model)
assert len(items) == 1
pdefs = get_all_possible_properties(items[0].attributes[0])
assert len(pdefs) >= 7
assert "minValue" in pdefs
assert "maxValue" in pdefs
assert "defaultValue" in pdefs
assert "description" in pdefs
assert "myprop1" in pdefs
assert "myprop2" in pdefs
pdefs["myprop1"].internaltype == "STRING"
pdefs["myprop2"].internaltype == "ATTRTYPE"
pdefs = get_all_possible_mandatory_properties(items[0].attributes[0])
assert len(pdefs) == 1
assert "myprop2" in pdefs
def _get_referenced_if_attributes(self):
mm = get_metamodel(self)
return list(
filter(
lambda x: textx_isinstance(x.ref, mm["Attribute"]),
get_children_of_type("AttrRef", self.if_attr),
))
def test_example2():
text = r"""
package example
struct Point {
scalar x : built_in.float
scalar y : built_in.float
}
struct Line {
scalar p1 : Point
scalar p2 : Point
}
struct Circle {
scalar center : Point
scalar radius : built_in.float
}
struct VariantExample {
scalar selector: built_in.uint32
variant payload: selector -> {
10: Point
11: Line
12: Circle
}
}
"""
mm = metamodel_for_language("item")
assert mm is not None
model = mm.model_from_str(text)
assert model is not None
items = get_children_of_type("Struct", model)
assert len(items) == 4
refs = get_referenced_elements_of_struct(items[3])
assert len(refs) == 3
def test_inheritance_processor():
"""
Basic test for ExtRelativeName (using an inheritance example)
"""
#################################
# META MODEL DEF
#################################
my_meta_model = metamodel_from_file(
abspath(dirname(__file__)) + '/components_model1/Components.tx')
my_meta_model.register_scope_providers({
"*.*": scoping_providers.FQN(),
"Connection.from_port":
scoping_providers.ExtRelativeName("from_inst.component",
"slots",
"extends"),
"Connection.to_port":
scoping_providers.ExtRelativeName("to_inst.component",
"slots",
"extends"),
})
#################################
# MODEL PARSING
#################################
my_model = my_meta_model.model_from_file(
abspath(dirname(__file__)) +
"/components_model1/example_inherit3.components")
#################################
# TEST MODEL
#################################
components = get_children_of_type("Component", my_model)
expected = """
Start
BaseProc
ExtProc(BaseProc)
Plus
ExtProc2(Plus,ExtProc(BaseProc))
End
End2
"""
def myformatter(compo):
if len(compo.extends) == 0:
return compo.name
else:
return compo.name + "(" + ",".join(map(lambda x: myformatter(x),
compo.extends)) + ")"
res = "\n\n"
# possibly in future version, the order need to be normalized...
for c in components:
res += myformatter(c) + "\n"
print(res)
assert re.sub(r'\s*', "", expected) == re.sub(r'\s*', "", res)
def test_model_with_multi_import():
"""
Basic test for FQNImportURI + multi imports (import "*.if")
"""
#################################
# META MODEL DEF
#################################
my_meta_model = metamodel_from_file(
join(abspath(dirname(__file__)), 'interface_model1', 'Interface.tx'))
my_meta_model.register_scope_providers(
{"*.*": scoping_providers.FQNImportURI()})
#################################
# MODEL PARSING
#################################
my_model = my_meta_model.model_from_file(
join(abspath(dirname(__file__)), "interface_model1", "model_c",
"A_multi_import.if"))
#################################
# TEST MODEL
#################################
imports = get_children_of_type("Import", my_model)
assert 1 == len(imports)
i = imports[0]
assert 4 == len(i._tx_loaded_models) # 4 files
assert 4 == len(set(i._tx_loaded_models)) # 4 different files
def test_example1():
text = r"""
package P1.P2.P3
struct Point {
scalar x : built_in.float
scalar y : built_in.float
}
struct Line {
scalar p1 : Point
scalar p2 : Point
}
struct Circle {
scalar center : Point
scalar radius : built_in.float
}
struct ColoredTriangle {
array color : built_in.float[3]
array points : Point[3]
}
"""
mm = metamodel_for_language("item")
assert mm is not None
model = mm.model_from_str(text)
assert model is not None
items = get_children_of_type("Struct", model)
assert len(items) == 4
def check_array_attribute(array_attribute):
"""
check if array size depends only on attributes defined before it in
the struct
:param array_attribute:
:return: None
throws on error
"""
from itemlang.metamodel_formula import ScalarRef
dependencies = map(
lambda x: x.ref0,
reduce(
lambda l1, l2: l1 + l2,
map(lambda node: get_children_of_type(ScalarRef, node),
array_attribute.array_dimensions), []))
struct = array_attribute.parent
index_of_array = struct.attributes.index(array_attribute)
available_infos_until_this_array = struct.attributes[0:index_of_array]
for d in dependencies:
if not (d in available_infos_until_this_array):
raise Exception(
"array {}.{} depends on {}.{} not defined " +
"before it in {}.".format(struct.name, array_attribute.name,
struct.name, d.name,
get_model(struct)._tx_filename))
def do_test_diagram_history_states(diagram):
transitions = textx.get_children_of_type("TransitionExpression", diagram._model)
assert len(transitions) == 14
assert transitions[8].dest.is_deep is False
assert transitions[10].dest.parent_name == "State3"
assert transitions[10].dest.is_deep is True
def do_test_diagram_concurrent_state_horizontal(diagram):
transitions = textx.get_children_of_type("TransitionExpression", diagram._model)
assert len(transitions) == 10
composites = textx.get_children_of_type("CompositeState", diagram._model)
assert len(composites) == 0
composites = textx.get_children_of_type("ParallelState", diagram._model)
assert len(composites) == 1
comp = composites[0]
regions = comp.regions
assert len(regions) == 3
for r in regions:
transitions = textx.get_children_of_type("TransitionExpression", r)
assert len(transitions) == 3
def test_model_with_circular_imports():
"""
Basic test for FQNImportURI + circular imports
"""
#################################
# META MODEL DEF
#################################
my_meta_model = metamodel_from_file(
join(abspath(dirname(__file__)),
'interface_model1', 'Interface.tx'))
my_meta_model.register_scope_providers(
{"*.*": scoping_providers.FQNImportURI()})
#################################
# MODEL PARSING
#################################
my_model = my_meta_model.model_from_file(
join(abspath(dirname(__file__)),
"interface_model1", "model_c", "A.if"))
#################################
# TEST MODEL
#################################
imports = get_children_of_type("Import", my_model)
assert len(imports) > 0
for i in imports:
assert 1 == len(i._tx_loaded_models) # one file / load import
assert i.importURI in i._tx_loaded_models[0]._tx_filename
check_unique_named_object_has_class(my_model, "A", "Interface")
a = get_unique_named_object(my_model, "A")
a_self = get_children(lambda x: hasattr(x, 'name') and x.name == "self", a)
assert len(a_self) == 1
a_self = a_self[0]
a_other = get_children(
lambda x: hasattr(x, 'name') and x.name == "other", a)
assert len(a_other) == 1
a_other = a_other[0]
a_other_self = get_children(
lambda x: hasattr(x, 'name') and x.name == "self", a_other.ref)
assert len(a_other_self) == 1
a_other_self = a_other_self[0]
a_other_other = get_children(
lambda x: hasattr(x, 'name') and x.name == "other", a_other.ref)
assert len(a_other_other) == 1
a_other_other = a_other_other[0]
assert a_self.ref == a_other_other.ref
assert a_self.ref != a_other.ref
assert a_other.ref == a_other_self.ref
assert a_other.ref != a_other_other.ref
def test_model_with_local_scope():
"""
This is a basic test for the local scope provider (good case).
"""
#################################
# META MODEL DEF
#################################
my_meta_model = metamodel_from_file(
join(abspath(dirname(__file__)), 'components_model1',
'Components.tx'))
my_meta_model.register_scope_providers({
"*.*": scoping_providers.FQN(),
"Connection.from_port":
scoping_providers.RelativeName("from_inst.component.slots"),
"Connection.to_port":
scoping_providers.RelativeName("to_inst.component.slots"),
})
#################################
# MODEL PARSING
#################################
my_model = my_meta_model.model_from_file(
join(abspath(dirname(__file__)), "components_model1",
"example.components"))
#################################
# TEST MODEL
#################################
# test local refs
action2 = get_unique_named_object(my_model, "action2")
action3 = get_unique_named_object(my_model, "action3")
connections = get_children_of_type("Connection", my_model)
selected_connections = list(filter(
lambda x: x.from_inst == action2 and x.to_inst == action3,
connections))
assert len(selected_connections) == 1
# test list of formats
input2 = get_unique_named_object(my_model, "input2")
assert len(input2.formats) == 3
format_names = map(lambda x: x.name, input2.formats)
assert "A" in format_names
assert "B" in format_names
assert "C" in format_names
assert "D" not in format_names
def test_textx_isinstace():
grammar = \
'''
Model: a=A;
A: B;
B: C;
C: x=ID;
'''
my_meta_model = metamodel_from_str(grammar)
A = my_meta_model['A']
B = my_meta_model['B']
C = my_meta_model['C']
my_model = my_meta_model.model_from_str("c")
c = get_children_of_type("C", my_model)
assert len(c) == 1
c = c[0]
assert textx_isinstance(c, C)
assert textx_isinstance(c, B)
assert textx_isinstance(c, A)
def test_model_with_local_scope_and_inheritance2():
"""
This is a more complicated test for the local scope provider.
"""
#################################
# META MODEL DEF
#################################
my_meta_model = metamodel_from_file(
join(abspath(dirname(__file__)), 'components_model1',
'Components.tx'))
my_meta_model.register_scope_providers({
"*.*": scoping_providers.FQN(),
"Connection.from_port":
scoping_providers.ExtRelativeName("from_inst.component",
"slots",
"extends"),
"Connection.to_port":
scoping_providers.ExtRelativeName("to_inst.component",
"slots",
"extends"),
})
#################################
# MODEL PARSING
#################################
my_model = my_meta_model.model_from_file(
join(abspath(dirname(__file__)),
"components_model1", "example_inherit1.components"))
#################################
# TEST MODEL
#################################
# test inherited ports are same (direct inheritance)
action1 = get_unique_named_object(my_model, "action1")
action2 = get_unique_named_object(my_model, "action2")
action3 = get_unique_named_object(my_model, "action3")
end = get_unique_named_object(my_model, "end")
connections = get_children_of_type("Connection", my_model)
selected_connections_12 = list(filter(
lambda x: x.from_inst == action1 and x.to_inst == action2,
connections))
selected_connections_3e = list(filter(
lambda x: x.from_inst == action3 and x.to_inst == end,
connections))
assert len(selected_connections_12) == 1
assert len(selected_connections_3e) == 1
assert selected_connections_12[0].to_port is selected_connections_3e[0].\
to_port # output3 is same
#################################
# MODEL PARSING
#################################
my_model = my_meta_model.model_from_file(
join(abspath(dirname(__file__)),
"components_model1", "example_inherit2.components"))
#################################
# TEST MODEL
#################################
# test inherited ports are same
# (indirect inheritance: Middle -> Start -> End)
action1 = get_unique_named_object(my_model, "action1")
action2 = get_unique_named_object(my_model, "action2")
action3 = get_unique_named_object(my_model, "action3")
end = get_unique_named_object(my_model, "end")
connections = get_children_of_type("Connection", my_model)
selected_connections_12 = list(filter(
lambda x: x.from_inst == action1 and x.to_inst == action2,
connections))
selected_connections_3e = list(filter(
lambda x: x.from_inst == action3 and x.to_inst == end, connections))
assert len(selected_connections_12) == 1
assert len(selected_connections_3e) == 1
assert selected_connections_12[0].to_port is selected_connections_3e[0].\
to_port # output3 is same
def main(debug=False):
from textx import metamodel_from_str, get_children_of_type
grammar = """
Model: commands*=DrawCommand;
DrawCommand: MoveCommand | ShapeCommand;
ShapeCommand: LineTo | Circle;
MoveCommand: MoveTo | MoveBy;
MoveTo: 'move' 'to' position=Point;
MoveBy: 'move' 'by' vector=Point;
Circle: 'circle' radius=INT;
LineTo: 'line' 'to' point=Point;
Point: x=INT ',' y=INT;
"""
# We will provide our class for Point.
# Classes for other rules will be dynamically generated.
class Point(object):
def __init__(self, parent, x, y):
self.parent = parent
self.x = x
self.y = y
def __str__(self):
return "{},{}".format(self.x, self.y)
def __add__(self, other):
return Point(self.parent, self.x + other.x, self.y + other.y)
# Create meta-model from the grammar. Provide `Point` class to be used for
# the rule `Point` from the grammar.
mm = metamodel_from_str(grammar, classes=[Point])
model_str = """
move to 5, 10
line to 10, 10
line to 20, 20
move by 5, -7
circle 10
line to 10, 10
"""
# Meta-model knows how to parse and instantiate models.
model = mm.model_from_str(model_str)
# At this point model is a plain Python object graph with instances of
# dynamically created classes and attributes following the grammar.
def cname(o):
return o.__class__.__name__
# Let's interpret the model
position = Point(None, 0, 0)
for command in model.commands:
if cname(command) == 'MoveTo':
print('Moving to position', command.position)
position = command.position
elif cname(command) == 'MoveBy':
position = position + command.vector
print('Moving by', command.vector, 'to a new position', position)
elif cname(command) == 'Circle':
print('Drawing circle at', position, 'with radius', command.radius)
else:
print('Drawing line from', position, 'to', command.point)
position = command.point
print('End position is', position)
# Output:
# Moving to position 5,10
# Drawing line from 5,10 to 10,10
# Drawing line from 10,10 to 20,20
# Moving by 5,-7 to a new position 25,13
# Drawing circle at 25,13 with radius 10
# Drawing line from 25,13 to 10,10
# Collect all points starting from the root of the model
points = get_children_of_type("Point", model)
for point in points:
print('Point: {}'.format(point))
def get_all(model_repo, what):
lst = []
for m in model_repo.filename_to_model.values():
lst = lst + get_children_of_type(what, m)
return lst
def test_inheritance_processor():
"""
Basic test for ExtRelativeName (using an inheritance example)
"""
#################################
# META MODEL DEF
#################################
my_meta_model = metamodel_from_file(
join(abspath(dirname(__file__)),
'components_model1', 'Components.tx'))
my_meta_model.register_scope_providers({
"*.*": scoping_providers.FQN(),
"Connection.from_port":
scoping_providers.ExtRelativeName("from_inst.component",
"slots",
"extends"),
"Connection.to_port":
scoping_providers.ExtRelativeName("to_inst.component",
"slots",
"extends"),
})
#################################
# MODEL PARSING
#################################
my_model = my_meta_model.model_from_file(
join(abspath(dirname(__file__)),
"components_model1", "example_inherit3.components"))
#################################
# TEST MODEL
#################################
components = get_children_of_type("Component", my_model)
expected = """
Start
BaseProc
ExtProc(BaseProc)
Plus
ExtProc2(Plus,ExtProc(BaseProc))
End
End2
"""
def myformatter(compo):
if len(compo.extends) == 0:
return compo.name
else:
return compo.name + "(" + ",".join(map(lambda x: myformatter(x),
compo.extends)) + ")"
res = "\n\n"
# possibly in future version, the order need to be normalized...
for c in components:
res += myformatter(c) + "\n"
print(res)
assert re.sub(r'\s*', "", expected) == re.sub(r'\s*', "", res)
