def __init__(self, name, conforms_to, language=None, **kwargs):
from morpy import Workspace
super(Mogram, self).__init__(name=name,
meta=Workspace().model,
**kwargs)
if not conforms_to and name == MORP:
# MoRP abstract syntax conforms to MoRP language.
self.conforms_to = Workspace().morp
else:
self.conforms_to = conforms_to
self.language = language
def test_MoRP_models(self):
'''
Tests MoRP models.
'''
# Top-level abstract models
abstract_models = filter(lambda m: m.abstract, Workspace().morp)
abstract_model_names = [x.name for x in abstract_models]
self.assertCountEqual(abstract_model_names,
[NAMED_ELEMENT, MULTIPLICITY])
# Top-level models
toplevel_model_names = [x.name for x in Workspace().morp]
self.assertCountEqual(toplevel_model_names, morp_toplevel_model_names)
def __init__(self, name, type, owner, **kwargs): # @ReservedAssignment
from morpy import Workspace
super(Property, self).__init__(meta=Workspace().prop,
name=name,
**kwargs)
self.type = type
self.owner = owner
def __init__(self,
name,
owner=None,
abstract=False,
super_models=None,
properties=None,
references=None,
**kwargs):
'''
Constructs a Model instance.
'''
# Special case. Model conforms to itself.
if kwargs.get('uuid') == UUID_MODEL:
meta = self
else:
from morpy import Workspace
meta = Workspace().model
super(Model, self).__init__(name=name, meta=meta, **kwargs)
self.owner = None
self.abstract = abstract
if owner:
owner.add_model(self)
self.super_models = []
if super_models:
for super_model in super_models:
self.add_super_model(super_model)
self.inherited_models = []
self.properties = properties or []
self.references = references or []
def __init__(self, meta, uuid=None):
self._meta = meta
if not uuid:
self._uuid = str(uuid4())
else:
self._uuid = uuid
# Register this metaobject by its UUID in the MoRP workspace.
from morpy import Workspace
Workspace().by_uuid[self._uuid] = self
def test_model_iteration(self):
'''
Test that model iteration returns inner models.
'''
for model in Workspace().morp:
self.assertIn(model.name, morp_toplevel_model_names)
if model.name == PRIMITIVE_TYPES:
primitive_types = model
for model in primitive_types:
self.assertIn(model.name, primitive_type_models)
def __init__(self, name, abssyn_uuid=None, **kwargs):
from morpy import Workspace
super(Language, self).__init__(name=name,
meta=Workspace().model,
**kwargs)
# Special case. If this instance represents MoRP language its
# abstract syntax is defined in this language.
# This must be specified in this way because MoRP language is
# not defined at this point yet.
if name == 'MoRP':
abssyn_language = self
else:
# Currently the only language for abstract syntax definition
# is MoRP
abssyn_language = Workspace().morp
self.abstract_syntax = Mogram(name,
conforms_to=abssyn_language,
language=self,
uuid=abssyn_uuid)
self.concrete_syntaxes = []
self.generators = []
def test_find_by_uuid(self):
'''
Find MoRP object in repository by its UUID.
'''
self.assertEqual(Workspace().get_by_uuid(UUID_MODEL),
Workspace().model)
self.assertEqual(Workspace().get_by_uuid(UUID_PROPERTY),
Workspace().prop)
self.assertEqual(Workspace().get_by_uuid(UUID_REFERENCE),
Workspace().reference)
def __init__(
self,
name,
type,
owner,
containment=False,
opposite=None, # @ReservedAssignment @IgnorePep8
**kwargs): # @IgnorePep8
from morpy import Workspace
super(Reference, self).__init__(meta=Workspace().reference,
name=name,
**kwargs)
self.type = type
self.owner = owner
self.containment = containment
self.opposite = opposite
if opposite:
opposite.opposite = self
def test_03_instantiate_model(self):
'''
Tests that model can be instantiated.
'''
mogram = Workspace().create_mogram('Gate', 'MoRP')
mogram.create_model('Machine')
def test_MoRPRepository_is_singleton(self):
self.assertTrue(Workspace() is Workspace())