def test_rrel_repetitions():
"""
This is a basic extra test to demonstrate `()*`
in RREL expressions.
"""
my_metamodel = metamodel_from_str(r'''
Model: entries*=Entry;
Entry: name=ID (':' ref=[Entry])?;
''')
my_model = my_metamodel.model_from_str(r'''
a: b
c
b: a
''')
a = find(my_model, "a", "entries.ref*")
assert a.name == 'a'
b = find(my_model, "b", "entries.ref*")
assert b.name == 'b'
c = find(my_model, "c", "entries.ref*")
assert c.name == 'c'
a2 = find(my_model, "a.b.a", "entries.ref*")
assert a2 == a
b2 = find(my_model, "b.a.b", "entries.ref*")
assert b2 == b
a2 = find(my_model, "b.a.b.a", "entries.ref*")
assert a2 == a
a2 = find(my_model, "b.a.b.a.b.a.b.a.b.a", "entries.ref*")
assert a2 == a
def get_property_set(model_obj):
res = find(
model_obj,
"",
"+m:^~property_set",
obj_cls=get_metamodel(model_obj)["PropertySet"],
)
if res is None:
res = get_default_property_set(get_metamodel(model_obj))
return res
def get_default_property_set(mm):
res = None
for m in mm.builtin_models:
res = find(
m,
"built_in.default_properties",
"+m:package.property_sets",
obj_cls=mm["PropertySet"],
)
if res is not None:
break
assert res is not None
return res
def test_rrel_repetitions():
"""
This is a basic extra test to demonstrate `()*`
in RREL expressions.
"""
my_metamodel = metamodel_from_str(r'''
Model: entries*=Entry;
Entry: name=ID (':' ref=[Entry])?;
''')
my_model = my_metamodel.model_from_str(r'''
a: b
c
b: a
''')
a = find(my_model, "a", "entries.ref*")
assert a.name == 'a'
b = find(my_model, "b", "entries.ref*")
assert b.name == 'b'
c = find(my_model, "c", "entries.ref*")
assert c.name == 'c'
a2 = find(my_model, "a.b.a", "entries.ref*")
assert a2 == a
b2 = find(my_model, "b.a.b", "entries.ref*")
assert b2 == b
res, objpath = find_object_with_path(my_model, "b.a.b", "entries.ref*")
assert res == b
assert len(objpath) == 3
assert objpath[-1] == res
assert ".".join(map(lambda x: x.name, objpath)) == 'b.a.b'
a2 = find(my_model, "b.a.b.a", "entries.ref*")
assert a2 == a
res, objpath = find_object_with_path(my_model, "b.a.b.a", "entries.ref*")
assert res == a
assert len(objpath) == 4
assert objpath[-1] == res
assert ".".join(map(lambda x: x.name, objpath)) == 'b.a.b.a'
a2 = find(my_model, "b.a.b.a.b.a.b.a.b.a", "entries.ref*")
assert a2 == a
def find_builtin(obj, lookup_list, rrel_tree, obj_cls=None):
"""
Find a object from the buildin_models
:param obj: an object of the model to get the metamodel from
:param lookup_list: search path (FQN)
:param rrel_tree: search path (in the abstract syntax tree)
:param obj_cls: class to be searched for (optional)
:return: the object or None
"""
from textx.scoping.rrel import find
from textx import get_metamodel
res = None
mm = get_metamodel(obj)
for m in mm.builtin_models:
res = find(m, lookup_list, rrel_tree, obj_cls)
if res is not None:
break
return res
def test_rrel_basic_lookup():
"""
This is a basic test for the find function:
we use a model with some structure
and query this structure with RREL expressions.
"""
#################################
# META MODEL DEF
#################################
my_metamodel = metamodel_from_str(metamodel_str)
#################################
# MODEL PARSING
#################################
my_model = my_metamodel.model_from_str(modeltext)
#################################
# TEST
#################################
P2 = find(my_model, "P2", "packages")
assert P2.name == "P2"
Part2 = find(my_model, "P2.Part2", "packages.classes")
assert Part2.name == "Part2"
rec = find(my_model, "P2.Part2.rec", "packages.classes.attributes")
rec_with_fixed_name = find(my_model, "P2.rec",
"packages.'Part2'~classes.attributes")
assert rec_with_fixed_name is rec
assert rec.name == "rec"
assert rec.parent == Part2
P2 = find(my_model, "P2", "(packages)")
assert P2.name == "P2"
from textx import get_model
assert get_model(my_model) is my_model
P2 = find(my_model, "P2", "packages*")
assert P2.name == "P2"
Part2 = find(my_model, "P2.Part2", "packages*.classes")
assert Part2.name == "Part2"
rec = find(my_model, "P2.Part2.rec", "packages*.classes.attributes")
assert rec.name == "rec"
assert rec.parent == Part2
Part2_tst = find(rec, "", "..")
assert Part2_tst is Part2
P2_from_inner_node = find(rec, "P2", "(packages)")
assert P2_from_inner_node is P2
P2_tst = find(rec, "", "parent(Package)")
assert P2_tst is P2
P2_tst = find(rec, "", "...")
assert P2_tst is P2
P2_tst = find(rec, "", ".(..).(..)")
assert P2_tst is P2
P2_tst = find(rec, "", "(..).(..)")
assert P2_tst is P2
P2_tst = find(rec, "", "...(.).(.)")
assert P2_tst is P2
P2_tst = find(rec, "", "..(.).(..)")
assert P2_tst is P2
P2_tst = find(rec, "", "..((.)*)*.(..)")
assert P2_tst is P2
none = find(my_model, "", "..")
assert none is None
m = find(my_model, "", ".") # '.' references the current element
assert m is my_model
inner = find(my_model, "inner", "~packages.~packages.~classes.attributes")
assert inner.name == "inner"
package_Inner = find(inner, "Inner", "parent(OBJECT)*.packages")
assert textx_isinstance(package_Inner, my_metamodel["Package"])
assert not textx_isinstance(package_Inner, my_metamodel["Class"])
assert None is find(inner, "P2", "parent(Class)*.packages")
# expensive version of a "Plain Name" scope provider:
inner = find(my_model, "inner", "~packages*.~classes.attributes")
assert inner.name == "inner"
rec2 = find(my_model, "P2.Part2.rec",
"other1,other2,packages*.classes.attributes")
assert rec2 is rec
rec2 = find(my_model, "P2.Part2.rec",
"other1,packages*.classes.attributes,other2")
assert rec2 is rec
rec2 = find(my_model,
"P2::Part2::rec",
"other1,packages*.classes.attributes,other2",
split_string="::")
assert rec2 is rec
rec2 = find(my_model, "P2.Part2.rec", "other1,other2,other3")
assert rec2 is None
rec2 = find(my_model, "P2.Part2.rec", "(packages,classes,attributes)*")
assert rec2 is rec
rec2 = find(my_model, "P2.Part2.rec",
"(packages,(classes,attributes)*)*.attributes")
assert rec2 is rec
rec2 = find(my_model, "rec", "(~packages,~classes,attributes,classes)*")
assert rec2.name == "rec"
rec2 = find(my_model, "rec", "(~packages,~classes,attributes,classes)*",
my_metamodel["OBJECT"])
assert rec2.name == "rec"
rec2 = find(my_model, "rec", "(~packages,~classes,attributes,classes)*",
my_metamodel["Attribute"])
assert rec2 is rec
rec2 = find(my_model, "rec", "(~packages,~classes,attributes,classes)*",
my_metamodel["Package"])
assert rec2 is None
rec2 = find(my_model, "rec", "(~packages,classes,attributes,~classes)*",
my_metamodel["Class"])
assert rec2.name == "rec"
assert rec2 is not rec # it is the class...
rec2 = find(my_model, "rec", "(~packages,~classes,attributes,classes)*",
my_metamodel["Class"])
assert rec2.name == "rec"
assert rec2 is not rec # it is the class...
t = find(my_model, "", ".")
assert t is my_model
t = find(my_model, "", "(.)")
assert t is my_model
t = find(my_model, "", "(.)*")
assert t is my_model
t = find(my_model, "", "(.)*.no_existent") # inifite recursion stopper
assert t is None
rec2 = find(my_model, "rec",
"(.)*.(~packages,~classes,attributes,classes)*",
my_metamodel["Class"])
assert rec2.name == "rec"
assert rec2 is not rec # it is the class...
# Here, we test the start_from_root/start_locally logic:
P2t = find(rec, "P2", "(.)*.packages")
assert P2t is None
P2t = find(rec, "P2", "(.,not_existent_but_root)*.packages")
assert P2t is P2
rect = find(rec, "rec", "(~packages)*.(..).attributes")
assert rect is None
rect = find(rec, "rec", "(.,~packages)*.(..).attributes")
assert rect is rec