def recipe_lang():
this_folder = dirname(abspath(__file__))
mm = metamodel_from_file(join(this_folder, "grammar", "Recipe.tx"),
classes=[Ingredient])
config_provider = scoping_providers.PlainNameGlobalRepo(
"**/*.config", glob_args={"recursive": True})
ingredient_type_provider = scoping_providers.PlainNameGlobalRepo(
"**/*.ingredient", glob_args={"recursive": True})
mm.register_scope_providers({
"Recipe.persons": config_provider,
"Ingredient.type": ingredient_type_provider,
"Ingredient.unit": scoping_providers.ExtRelativeName("type", "units", "extends"),
})
return mm
def test_issue78_quickcheck_no_obj_processors_called_for_references():
"""
This test represents just a plausibility check.
"""
grammarA = """
Model: a+=A | b+=B;
A:'A' name=ID;
B:'B' name=ID '->' a=[A];
"""
mm = textx.metamodel_from_str(grammarA)
import textx.scoping.providers as scoping_providers
global_repo_provider = scoping_providers.PlainNameGlobalRepo()
mm.register_scope_providers({"*.*": global_repo_provider})
test_list=[]
mm.register_obj_processors({
'A': lambda o: test_list.append(o.name),
})
# no references to A: --> obj proc called
m1 = mm.model_from_str('''
A a1 A a2 A a3
''')
assert ['a1','a2','a3'] == test_list
# only references to A: --> obj proc not called
global_repo_provider.add_model(m1)
m2 = mm.model_from_str('''
B b1 -> a1 B b2 -> a2 B b3 -> a3
''')
assert ['a1','a2','a3'] == test_list # unchanged...
def register_languages():
clear_language_registrations()
global_repo = scoping.GlobalModelRepository()
global_repo_provider = scoping_providers.PlainNameGlobalRepo()
def get_A_mm():
mm_A = metamodel_from_str(grammarA, global_repository=global_repo)
mm_A.register_scope_providers({"*.*": global_repo_provider})
return mm_A
def get_B_mm():
mm_B = metamodel_from_str(grammarB, global_repository=global_repo)
mm_B.register_scope_providers({"*.*": global_repo_provider})
return mm_B
def get_BwithImport_mm():
mm_B = metamodel_from_str(grammarBWithImport,
global_repository=global_repo)
# define a default scope provider supporting the importURI feature
mm_B.register_scope_providers(
{"*.*": scoping_providers.FQNImportURI()})
return mm_B
register_language('A', pattern="*.a", metamodel=get_A_mm)
register_language('B', pattern="*.b", metamodel=get_B_mm)
register_language('BwithImport',
pattern="*.b",
metamodel=get_BwithImport_mm)
return global_repo_provider
def register_languages():
clear_language_registrations()
global_repo = scoping.GlobalModelRepository()
global_repo_provider = scoping_providers.PlainNameGlobalRepo()
class A(object):
def __init__(self, **kwargs):
super(A, self).__init__()
for k, v in kwargs.items():
self.__dict__[k] = v
def __setattr__(self, name, value):
raise Exception("test: this is not allowed.")
def get_A_mm():
mm_A = metamodel_from_str(grammarA,
global_repository=global_repo,
classes=[A])
mm_A.register_scope_providers({"*.*": global_repo_provider})
return mm_A
def get_B_mm():
mm_B = metamodel_from_str(grammarB, global_repository=global_repo)
mm_B.register_scope_providers({"*.*": global_repo_provider})
return mm_B
def get_BwithImport_mm():
mm_B = metamodel_from_str(grammarBWithImport,
global_repository=global_repo)
# define a default scope provider supporting the importURI feature
mm_B.register_scope_providers(
{"*.*": scoping_providers.FQNImportURI()})
return mm_B
register_language('A', pattern="*.a", metamodel=get_A_mm)
register_language('B', pattern="*.b", metamodel=get_B_mm)
register_language('BwithImport',
pattern="*.b",
metamodel=get_BwithImport_mm)
return global_repo_provider
def test_multi_metamodel_references2():
mm_A = metamodel_from_str(grammarA)
mm_B = metamodel_from_str(grammarB)
global_repo_provider = scoping_providers.PlainNameGlobalRepo()
mm_B.register_scope_providers({"*.*": global_repo_provider})
mA = mm_A.model_from_str('''
A a1 A a2 A a3
''')
global_repo_provider.add_model(mA)
mm_B.model_from_str('''
B b1 -> a1 B b2 -> a2 B b3 -> a3
''')
with raises(textx.exceptions.TextXSemanticError, match=r'.*UNKNOWN.*'):
mm_B.model_from_str('''
B b1 -> a1 B b2 -> a2 B b3 -> UNKNOWN
''')
def test_metamodel_provider_advanced_test():
"""
Advanced test for ExtRelativeName and PlainNameGlobalRepo.
Here we have a global model repository shared between
different meta models.
The meta models interact (refer to each other; one direction).
"""
#################################
# META MODEL DEF
#################################
this_folder = dirname(abspath(__file__))
def get_meta_model(global_repo, grammar_file_name):
mm = metamodel_from_file(join(this_folder, grammar_file_name),
debug=False)
mm.register_scope_providers({
"*.*":
global_repo,
"Ingredient.unit":
scoping_providers.ExtRelativeName("type", "units", "extends")
})
return mm
global_repo = scoping_providers.PlainNameGlobalRepo()
global_repo.register_models(
join(this_folder, "metamodel_provider2", "*.recipe"))
global_repo.register_models(
join(this_folder, "metamodel_provider2", "*.ingredient"))
i_mm = get_meta_model(
global_repo, join(this_folder, "metamodel_provider2", "Ingredient.tx"))
r_mm = get_meta_model(
global_repo, join(this_folder, "metamodel_provider2", "Recipe.tx"))
clear_language_registrations()
register_language(
'recipe-dsl',
pattern='*.recipe',
description='demo',
metamodel=r_mm # or a factory
)
register_language(
'ingredient-dsl',
pattern='*.ingredient',
description='demo',
metamodel=i_mm # or a factory
)
#################################
# MODEL PARSING
#################################
model_repo = global_repo.load_models_in_model_repo().all_models
#################################
# TEST MODEL
#################################
def get_all(model_repo, what):
lst = []
for m in model_repo:
lst = lst + get_children_of_type(what, m)
return lst
lst_i = get_all(model_repo, "IngredientType")
lst_r = get_all(model_repo, "Recipe")
assert len(lst_i) == 2
assert len(lst_r) == 2
# check some references to be resolved (!=None)
assert lst_r[0].ingredients[0].type
assert lst_r[0].ingredients[0].unit
def test_metamodel_provider_advanced_test3_global():
"""
Advanced test for ExtRelativeName and PlainNameGlobalRepo.
Here we have a global model repository shared between
different meta models.
The meta models interact (refer to each other, different directions).
"""
#################################
# META MODEL DEF
#################################
this_folder = dirname(abspath(__file__))
def get_meta_model(global_repo, grammar_file_name):
mm = metamodel_from_file(join(this_folder, grammar_file_name),
debug=False, classes=[Cls, Obj])
mm.register_scope_providers({
"*.*": global_repo,
})
return mm
global_repo_provider = scoping_providers.PlainNameGlobalRepo()
global_repo_provider.register_models(
join(this_folder, "metamodel_provider3", "circular", "*.a"))
global_repo_provider.register_models(
join(this_folder, "metamodel_provider3", "circular", "*.b"))
global_repo_provider.register_models(
join(this_folder, "metamodel_provider3", "circular", "*.c"))
a_mm = get_meta_model(
global_repo_provider, join(this_folder,
"metamodel_provider3", "A.tx"))
b_mm = get_meta_model(
global_repo_provider, join(this_folder,
"metamodel_provider3", "B.tx"))
c_mm = get_meta_model(
global_repo_provider, join(this_folder,
"metamodel_provider3", "C.tx"))
clear_language_registrations()
register_language(
'a-dsl',
pattern='*.a',
description='Test Lang A',
metamodel=a_mm)
register_language(
'b-dsl',
pattern='*.b',
description='Test Lang B',
metamodel=b_mm)
register_language(
'c-dsl',
pattern='*.c',
description='Test Lang C',
metamodel=c_mm)
#################################
# MODEL PARSING
#################################
model_repo = global_repo_provider.load_models_in_model_repo().all_models
#################################
# TEST MODEL
#################################
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
lst = get_all(model_repo, "Obj")
# print(lst)
assert len(lst) == 3
# check some references to be resolved (!=None)
for a in lst:
assert a.ref
# check meta classes
assert a_mm["Cls"]._tx_fqn == b_mm["Cls"]._tx_fqn
# more checks
from textx import textx_isinstance
for a in lst:
assert textx_isinstance(a, a_mm["Obj"])
assert textx_isinstance(a, b_mm["Obj"])
assert textx_isinstance(a, c_mm["Obj"])
#################################
# END
#################################
clear_language_registrations()
def test_metamodel_provider_advanced_test3_global_single_metamodel():
"""
simplified test with only one meta model
"""
#################################
# META MODEL DEF
#################################
this_folder = dirname(abspath(__file__))
def get_meta_model(global_repo, grammar_file_name):
mm = metamodel_from_file(join(this_folder, grammar_file_name),
debug=False, classes=[Cls, Obj])
mm.register_scope_providers({
"*.*": global_repo,
})
return mm
global_repo_provider = scoping_providers.PlainNameGlobalRepo()
global_repo_provider.register_models(
join(this_folder, "metamodel_provider3", "single", "*.a"))
a_mm = get_meta_model(
global_repo_provider, join(this_folder,
"metamodel_provider3", "A.tx"))
clear_language_registrations()
register_language(
'a-dsl',
pattern='*.a',
description='Test Lang A',
metamodel=a_mm)
#################################
# MODEL PARSING
#################################
model_repo = global_repo_provider.load_models_in_model_repo().all_models
#################################
# TEST MODEL
#################################
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
lst = get_all(model_repo, "Obj")
# print(lst)
assert len(lst) == 3
# check some references to be resolved (!=None)
for a in lst:
assert a.ref
# check meta classes
assert a_mm["Cls"]._tx_fqn == a_mm["Cls"]._tx_fqn
# more checks
from textx import textx_isinstance
for a in lst:
assert textx_isinstance(a, a_mm["Obj"])
assert textx_isinstance(a, a_mm["Obj"])
assert textx_isinstance(a, a_mm["Obj"])
#################################
# END
#################################
clear_language_registrations()
def test_metamodel_provider_advanced_test():
"""
Advanced test for ExtRelativeName and PlainNameGlobalRepo.
Here we have a global model repository shared between
different meta models.
The meta models interact (refer to each other; one direction).
"""
#################################
# META MODEL DEF
#################################
this_folder = dirname(abspath(__file__))
def get_meta_model(global_repo, grammar_file_name):
mm = metamodel_from_file(join(this_folder, grammar_file_name),
debug=False)
mm.register_scope_providers({
"*.*": global_repo,
"Ingredient.unit": scoping_providers.ExtRelativeName("type",
"units",
"extends")
})
return mm
global_repo = scoping_providers.PlainNameGlobalRepo()
global_repo.register_models(
this_folder + "/metamodel_provider2/*.recipe")
global_repo.register_models(
this_folder + "/metamodel_provider2/*.ingredient")
i_mm = get_meta_model(
global_repo, this_folder + "/metamodel_provider2/Ingredient.tx")
r_mm = get_meta_model(
global_repo, this_folder + "/metamodel_provider2/Recipe.tx")
scoping.MetaModelProvider.add_metamodel("*.recipe", r_mm)
scoping.MetaModelProvider.add_metamodel("*.ingredient", i_mm)
#################################
# MODEL PARSING
#################################
model_repo = global_repo.load_models_in_model_repo().all_models
#################################
# TEST MODEL
#################################
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
lst_i = get_all(model_repo, "IngredientType")
lst_r = get_all(model_repo, "Recipe")
assert len(lst_i) == 2
assert len(lst_r) == 2
# check some references to be resolved (!=None)
assert lst_r[0].ingredients[0].type
assert lst_r[0].ingredients[0].unit
def test_metamodel_provider_advanced_test3_global():
"""
Advanced test for ExtRelativeName and PlainNameGlobalRepo.
Here we have a global model repository shared between
different meta models.
The meta models interact (refer to each other, different directions).
"""
#################################
# META MODEL DEF
#################################
this_folder = dirname(abspath(__file__))
def get_meta_model(global_repo, grammar_file_name):
mm = metamodel_from_file(join(this_folder, grammar_file_name),
debug=False)
mm.register_scope_providers({
"*.*": global_repo,
})
return mm
global_repo_provider = scoping_providers.PlainNameGlobalRepo()
global_repo_provider.register_models(
this_folder + "/metamodel_provider3/circular/*.a")
global_repo_provider.register_models(
this_folder + "/metamodel_provider3/circular/*.b")
global_repo_provider.register_models(
this_folder + "/metamodel_provider3/circular/*.c")
a_mm = get_meta_model(
global_repo_provider, this_folder + "/metamodel_provider3/A.tx")
b_mm = get_meta_model(
global_repo_provider, this_folder + "/metamodel_provider3/B.tx")
c_mm = get_meta_model(
global_repo_provider, this_folder + "/metamodel_provider3/C.tx")
scoping.MetaModelProvider.clear()
scoping.MetaModelProvider.add_metamodel("*.a", a_mm)
scoping.MetaModelProvider.add_metamodel("*.b", b_mm)
scoping.MetaModelProvider.add_metamodel("*.c", c_mm)
#################################
# MODEL PARSING
#################################
model_repo = global_repo_provider.load_models_in_model_repo().all_models
#################################
# TEST MODEL
#################################
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
lst = get_all(model_repo, "Obj")
# print(lst)
assert len(lst) == 3
# check some references to be resolved (!=None)
for a in lst:
assert a.ref
#################################
# END
#################################
scoping.MetaModelProvider.clear()
