def handler():
try:
dist = pkg_resources.get_distribution("gaphor")
path = os.path.join(dist.location, "test-diagrams/diagram-#4.gaphor")
load(path, self.element_factory)
finally:
Gtk.main_quit()
def test_load_save(self):
"""Test loading and saving models"""
dist = pkg_resources.get_distribution("gaphor")
path = os.path.join(dist.location, "test-diagrams/simple-items.gaphor")
with io.open(path, "r") as ifile:
storage.load(ifile, factory=self.element_factory)
pf = PseudoFile()
storage.save(XMLWriter(pf), factory=self.element_factory)
with io.open(path, "r") as ifile:
orig = ifile.read()
copy = pf.data
with io.open("tmp.gaphor", "w") as ofile:
ofile.write(copy)
expr = re.compile('gaphor-version="[^"]*"')
orig = expr.sub("%VER%", orig)
copy = expr.sub("%VER%", copy)
self.maxDiff = None
self.assertEqual(copy, orig, "Saved model does not match copy")
def handler():
try:
path = distribution().locate_file(
"test-diagrams/diagram-#4.gaphor")
load(path, self.element_factory)
finally:
Gtk.main_quit()
def element_factory(session):
element_factory = session.get_service("element_factory")
modeling_language = session.get_service("modeling_language")
path = distribution().locate_file("test-models/issue_53.gaphor")
load(path, element_factory, modeling_language)
yield element_factory
element_factory.shutdown()
def save_and_load(self, filename):
factory = self.element_factory
f = open(filename, 'r')
storage.load(f, factory=self.element_factory)
f.close()
self.backup_service.backup()
elements = list(map(factory.lookup, list(factory.keys())))
orig = StringIO()
storage.save(XMLWriter(orig), factory=self.element_factory)
self.backup_service.restore()
restored = list(map(factory.lookup, list(factory.keys())))
assert len(elements) == len(restored)
assert elements != restored
copy = StringIO()
storage.save(XMLWriter(copy), factory=self.element_factory)
orig = orig.getvalue()
copy = copy.getvalue()
assert len(orig) == len(copy)
def load_old_model():
with open(path, "r") as ifile:
storage.load(
ifile,
factory=self.element_factory,
modeling_language=self.modeling_language,
)
def element_factory(session):
element_factory = session.get_service("element_factory")
dist = importlib_metadata.distribution("gaphor")
path = dist.locate_file("test-diagrams/issue_53.gaphor")
load(path, element_factory)
yield element_factory
element_factory.shutdown()
def test_load_and_save_of_a_model(self):
path = distribution().locate_file("test-models/simple-items.gaphor")
with open(path, "r") as ifile:
storage.load(
ifile,
factory=self.element_factory,
modeling_language=self.modeling_language,
)
pf = PseudoFile()
storage.save(XMLWriter(pf), factory=self.element_factory)
with open(path, "r") as ifile:
orig = ifile.read()
copy = pf.data
expr = re.compile('gaphor-version="[^"]*"')
orig = expr.sub("%VER%", orig)
copy = expr.sub("%VER%", copy)
self.maxDiff = None
assert copy == orig, "Saved model does not match copy"
def test_load_save(self):
"""Test loading and saving models"""
dist = pkg_resources.get_distribution("gaphor")
path = os.path.join(dist.location, "test-diagrams/simple-items.gaphor")
with io.open(path, "r") as ifile:
storage.load(ifile, factory=self.element_factory)
pf = PseudoFile()
storage.save(XMLWriter(pf), factory=self.element_factory)
with io.open(path, "r") as ifile:
orig = ifile.read()
copy = pf.data
with io.open("tmp.gaphor", "w") as ofile:
ofile.write(copy)
expr = re.compile('gaphor-version="[^"]*"')
orig = expr.sub("%VER%", orig)
copy = expr.sub("%VER%", copy)
self.maxDiff = None
self.assertEqual(copy, orig, "Saved model does not match copy")
def test_load_save(self):
"""Test loading and saving models"""
dist = importlib_metadata.distribution("gaphor")
path = dist.locate_file("test-diagrams/simple-items.gaphor")
with open(path, "r") as ifile:
storage.load(ifile, factory=self.element_factory)
pf = PseudoFile()
storage.save(XMLWriter(pf), factory=self.element_factory)
with open(path, "r") as ifile:
orig = ifile.read()
copy = pf.data
with open("tmp.gaphor", "w") as ofile:
ofile.write(copy)
expr = re.compile('gaphor-version="[^"]*"')
orig = expr.sub("%VER%", orig)
copy = expr.sub("%VER%", copy)
self.maxDiff = None
assert copy == orig, "Saved model does not match copy"
def save_and_load(self, filename):
factory = self.element_factory
f = open(filename, 'r')
storage.load(f, factory=self.element_factory)
f.close()
self.backup_service.backup()
elements = map(factory.lookup, factory.keys())
orig = StringIO()
storage.save(XMLWriter(orig), factory=self.element_factory)
self.backup_service.restore()
restored = map(factory.lookup, factory.keys())
assert len(elements) == len(restored)
assert elements != restored
copy = StringIO()
storage.save(XMLWriter(copy), factory=self.element_factory)
orig = orig.getvalue()
copy = copy.getvalue()
assert len(orig) == len(copy)
def handler():
try:
path = distribution().locate_file(
"test-models/diagram-#4.gaphor")
load(path, self.element_factory, self.modeling_language)
finally:
Gtk.main_quit()
def handler():
try:
dist = pkg_resources.get_distribution('gaphor')
path = os.path.join(dist.location, 'test-diagrams/diagram-#4.gaphor')
load(path, self.element_factory)
finally:
gtk.main_quit()
def handler():
try:
dist = importlib_metadata.distribution("gaphor")
path = dist.locate_file("test-diagrams/diagram-#4.gaphor")
load(path, self.element_factory)
finally:
Gtk.main_quit()
def test_load_save(self):
"""Test loading and saving models"""
dist = pkg_resources.get_distribution('gaphor')
path = os.path.join(dist.location, 'test-diagrams/simple-items.gaphor')
with open(path, 'r') as ifile:
storage.load(ifile, factory=self.element_factory)
pf = PseudoFile()
storage.save(XMLWriter(pf), factory=self.element_factory)
with open(path, 'r') as ifile:
orig = ifile.read()
copy = pf.data
with open('tmp.gaphor', 'w') as ofile:
ofile.write(copy)
expr = re.compile('gaphor-version="[^"]*"')
orig = expr.sub('%VER%', orig)
copy = expr.sub('%VER%', copy)
self.assertEquals(copy, orig, 'Saved model does not match copy')
def test_load_save(self):
"""Test loading and saving models"""
dist = pkg_resources.get_distribution('gaphor')
path = os.path.join(dist.location, 'test-diagrams/simple-items.gaphor')
with open(path, 'r') as ifile:
storage.load(ifile, factory=self.element_factory)
pf = PseudoFile()
storage.save(XMLWriter(pf), factory=self.element_factory)
with open(path, 'r') as ifile:
orig = ifile.read()
copy = pf.data
with open('tmp.gaphor', 'w') as ofile:
ofile.write(copy)
expr = re.compile('gaphor-version="[^"]*"')
orig = expr.sub('%VER%', orig)
copy = expr.sub('%VER%', copy)
self.assertEquals(copy, orig, 'Saved model does not match copy')
def test_tagged_values_upgrade(self):
"""Test tagged values upgrade in Gaphor 0.15.0
"""
f = open('test-diagrams/taggedvalues-pre015.gaphor')
storage.load(f, factory=self.element_factory)
f.close()
diagrams = list(self.kindof(UML.Diagram))
self.assertEquals(1, len(diagrams))
diagram = diagrams[0]
classes = diagram.canvas.select(lambda e: isinstance(e, items.ClassItem))
profiles = self.element_factory.lselect(lambda e: isinstance(e, UML.Profile))
stereotypes = self.element_factory.lselect(lambda e: isinstance(e, UML.Stereotype))
self.assertEquals(2, len(classes))
c1, c2 = classes
self.assertEquals(1, len(profiles))
profile = profiles[0]
self.assertEquals('version 0.15 conversion', profile.name)
self.assertEquals(1, len(stereotypes))
stereotype = stereotypes[0]
self.assertEquals('Tagged', stereotype.name)
self.assertEquals(profile, stereotype.namespace)
self.assertEquals('c1', c1.subject.name)
self.assertEquals('c2', c2.subject.name)
self.assertEquals(stereotype, c1.subject.appliedStereotype[0].classifier[0])
self.assertEquals(stereotype, c2.subject.appliedStereotype[0].classifier[0])
self.assertEquals('t1', c1.subject.appliedStereotype[0].slot[0].definingFeature.name)
self.assertEquals('t2', c1.subject.appliedStereotype[0].slot[1].definingFeature.name)
self.assertEquals('t5', c2.subject.appliedStereotype[0].slot[0].definingFeature.name)
self.assertEquals('t6', c2.subject.appliedStereotype[0].slot[1].definingFeature.name)
self.assertEquals('t7', c2.subject.appliedStereotype[0].slot[2].definingFeature.name)
def test_bug(self):
"""
Load file.
This does not nearly resemble the error, since the model should
be loaded from within the mainloop (which will delay all updates).
"""
load("test-diagrams/diagram-#4.gaphor", self.element_factory)
def setUp(self):
Application.init()
element_factory = Application.get_service('element_factory')
from gaphor.storage.storage import load
dist = pkg_resources.get_distribution('gaphor')
path = os.path.join(dist.location, 'tests/issue_53.gaphor')
load(path, element_factory)
def test_bug(self):
"""
Load file.
This does not nearly resemble the error, since the model should
be loaded from within the mainloop (which will delay all updates).
"""
load('test-diagrams/diagram-#4.gaphor', self.element_factory)
def setUp(self):
Application.init()
element_factory = Application.get_service("element_factory")
from gaphor.storage.storage import load
dist = pkg_resources.get_distribution("gaphor")
path = os.path.join(dist.location, "test-diagrams/issue_53.gaphor")
load(path, element_factory)
def setUp(self):
Application.init()
element_factory = Application.get_service("element_factory")
from gaphor.storage.storage import load
dist = pkg_resources.get_distribution("gaphor")
path = os.path.join(dist.location, "test-diagrams/issue_53.gaphor")
load(path, element_factory)
def test_export(self):
load("tests/cr2-superstate.gaphor", self.element_factory)
zaakspec = self.get_service("crea-zaakspecificatie-export")
pf = PseudoFile()
zaakspec.export(pf)
expected = ""
assert pf.data == EXPECTED, '"""%s"""' % pf.data
def test_load_uml_metamodel(self):
path = distribution().locate_file("models/UML.gaphor")
with open(path) as ifile:
storage.load(
ifile,
factory=self.element_factory,
modeling_language=self.modeling_language,
)
def test_load_uml_metamodel(self):
"""
Test if the meta model can be loaded.
"""
path = distribution().locate_file("gaphor/UML/uml2.gaphor")
with open(path) as ifile:
storage.load(ifile, factory=self.element_factory)
def test_load_uml_metamodel(self):
"""
Test if the meta model can be loaded.
"""
try:
f = open('gaphor/UML/uml2.gaphor')
storage.load(f, factory=self.element_factory)
finally:
f.close()
def element_factory():
Application.init()
element_factory = Application.get_service("element_factory")
dist = importlib_metadata.distribution("gaphor")
path = dist.locate_file("test-diagrams/issue_53.gaphor")
load(path, element_factory)
yield element_factory
Application.get_service("element_factory").shutdown()
Application.shutdown()
def test_bug(self):
"""
Load file.
This does not nearly resemble the error, since the model should
be loaded from within the mainloop (which will delay all updates).
"""
path = distribution().locate_file("test-diagrams/diagram-#4.gaphor")
load(path, self.element_factory)
def test_association_upgrade(self):
"""Test association navigability upgrade in Gaphor 0.15.0
"""
dist = pkg_resources.get_distribution('gaphor')
path = os.path.join(dist.location,
'test-diagrams/associations-pre015.gaphor')
with open(path) as ifile:
storage.load(ifile, factory=self.element_factory)
diagrams = list(self.kindof(uml2.Diagram))
self.assertEquals(1, len(diagrams))
diagram = diagrams[0]
assocs = diagram.canvas.select(
lambda e: isinstance(e, items.AssociationItem))
assert len(assocs) == 8
a1, a2 = [a for a in assocs if a.subject.name == 'nav']
self.assertTrue(a1.head_end.subject.navigability)
self.assertTrue(a1.tail_end.subject.navigability)
self.assertTrue(a2.head_end.subject.navigability)
self.assertTrue(a2.tail_end.subject.navigability)
self.assertTrue(len(a1.head_end.subject.type.ownedAttribute) == 1)
self.assertTrue(len(a1.tail_end.subject.type.ownedAttribute) ==
2) # association end and an attribute
# use cases and actors - no owned attributes as navigability is realized
# by association's navigable owned ends
self.assertTrue(len(a2.head_end.subject.type.ownedAttribute) == 0)
self.assertTrue(len(a2.tail_end.subject.type.ownedAttribute) == 0)
a1, a2 = [a for a in assocs if a.subject.name == 'nonnav']
self.assertTrue(a1.head_end.subject.navigability is False)
self.assertTrue(a1.tail_end.subject.navigability is False)
self.assertTrue(a2.head_end.subject.navigability is False)
self.assertTrue(a2.tail_end.subject.navigability is False)
a1, a2 = [a for a in assocs if a.subject.name == 'unk']
self.assertTrue(a1.head_end.subject.navigability is None)
self.assertTrue(a1.tail_end.subject.navigability is None)
self.assertTrue(a2.head_end.subject.navigability is None)
self.assertTrue(a2.tail_end.subject.navigability is None)
a, = [a for a in assocs if a.subject.name == 'sided']
assert a.head_end.subject.name == 'cs'
assert a.tail_end.subject.name == 'int'
self.assertTrue(a.head_end.subject.navigability is False)
self.assertTrue(a.tail_end.subject.navigability is True)
a, = [a for a in assocs if a.subject.name == 'sided2']
assert a.head_end.subject.name == 'cs'
assert a.tail_end.subject.name == 'int'
self.assertTrue(a.head_end.subject.navigability is None)
self.assertTrue(a.tail_end.subject.navigability is True)
def test_bug(self):
"""
Load file.
This does not nearly resemble the error, since the model should
be loaded from within the mainloop (which will delay all updates).
"""
dist = pkg_resources.get_distribution("gaphor")
path = os.path.join(dist.location, "test-diagrams/diagram-#4.gaphor")
load(path, self.element_factory)
def test_bug(self):
"""
Load file.
This does not nearly resemble the error, since the model should
be loaded from within the mainloop (which will delay all updates).
"""
dist = pkg_resources.get_distribution('gaphor')
path = os.path.join(dist.location, 'test-diagrams/diagram-#4.gaphor')
load(path, self.element_factory)
def load(data):
"""Load data from specified string."""
element_factory.flush()
assert not list(element_factory.select())
f = StringIO(data)
storage.load(f,
factory=element_factory,
modeling_language=modeling_language)
f.close()
def test_load_uml_metamodel(self):
"""
Test if the meta model can be loaded.
"""
dist = pkg_resources.get_distribution("gaphor")
path = os.path.join(dist.location, "gaphor/UML/uml2.gaphor")
with io.open(path) as ifile:
storage.load(ifile, factory=self.element_factory)
def test_load_uml_metamodel(self):
"""
Test if the meta model can be loaded.
"""
dist = pkg_resources.get_distribution("gaphor")
path = os.path.join(dist.location, "gaphor/UML/uml2.gaphor")
with io.open(path) as ifile:
storage.load(ifile, factory=self.element_factory)
def test_association_upgrade(self):
"""Test association navigability upgrade in Gaphor 0.15.0
"""
dist = pkg_resources.get_distribution('gaphor')
path = os.path.join(dist.location, 'test-diagrams/associations-pre015.gaphor')
with open(path) as ifile:
storage.load(ifile, factory=self.element_factory)
diagrams = list(self.kindof(UML.Diagram))
self.assertEquals(1, len(diagrams))
diagram = diagrams[0]
assocs = diagram.canvas.select(lambda e: isinstance(e, items.AssociationItem))
assert len(assocs) == 8
a1, a2 = [a for a in assocs if a.subject.name == 'nav']
self.assertTrue(a1.head_end.subject.navigability)
self.assertTrue(a1.tail_end.subject.navigability)
self.assertTrue(a2.head_end.subject.navigability)
self.assertTrue(a2.tail_end.subject.navigability)
self.assertTrue(len(a1.head_end.subject.type.ownedAttribute) == 1)
self.assertTrue(len(a1.tail_end.subject.type.ownedAttribute) == 2) # association end and an attribute
# use cases and actors - no owned attributes as navigability is realized
# by association's navigable owned ends
self.assertTrue(len(a2.head_end.subject.type.ownedAttribute) == 0)
self.assertTrue(len(a2.tail_end.subject.type.ownedAttribute) == 0)
a1, a2 = [a for a in assocs if a.subject.name == 'nonnav']
self.assertTrue(a1.head_end.subject.navigability is False)
self.assertTrue(a1.tail_end.subject.navigability is False)
self.assertTrue(a2.head_end.subject.navigability is False)
self.assertTrue(a2.tail_end.subject.navigability is False)
a1, a2 = [a for a in assocs if a.subject.name == 'unk']
self.assertTrue(a1.head_end.subject.navigability is None)
self.assertTrue(a1.tail_end.subject.navigability is None)
self.assertTrue(a2.head_end.subject.navigability is None)
self.assertTrue(a2.tail_end.subject.navigability is None)
a, = [a for a in assocs if a.subject.name == 'sided']
assert a.head_end.subject.name == 'cs'
assert a.tail_end.subject.name == 'int'
self.assertTrue(a.head_end.subject.navigability is False)
self.assertTrue(a.tail_end.subject.navigability is True)
a, = [a for a in assocs if a.subject.name == 'sided2']
assert a.head_end.subject.name == 'cs'
assert a.tail_end.subject.name == 'int'
self.assertTrue(a.head_end.subject.navigability is None)
self.assertTrue(a.tail_end.subject.navigability is True)
def load(self, data):
"""
Load data from specified string. Update ``TestCase.diagram``
attribute to hold new loaded diagram.
"""
from gaphor.storage import storage
f = StringIO(data)
storage.load(f, factory=self.element_factory)
f.close()
self.diagram = self.element_factory.lselect(lambda e: e.isKindOf(UML.Diagram))[0]
def load(self, data):
"""
Load data from specified string. Update ``TestCase.diagram``
attribute to hold new loaded diagram.
"""
from gaphor.storage import storage
f = StringIO(data)
storage.load(f, factory=self.element_factory)
f.close()
self.diagram = self.element_factory.lselect(lambda e: e.isKindOf(uml2.Diagram))[0]
def generate(
filename: PathLike,
outfile: PathLike,
overridesfile: Optional[PathLike] = None,
) -> None:
"""Generates the Python data model.
Opens the Gaphor model, generates the list of classes using the
element factory, and then creates a new Python data model using a
relationship search tree.
"""
element_factory = ElementFactory()
modeling_language = UMLModelingLanguage()
with open(filename):
storage.load(
filename,
element_factory,
modeling_language,
)
classes: List = element_factory.lselect(UML.Class)
classes, enumerations = find_enumerations(classes)
classes = filter_out_gaphor_profile(classes)
# Lambda key sort issue in mypy: https://github.com/python/mypy/issues/9656
classes = sorted(
(cls for cls in classes if cls.name[0] != "~"), key=lambda c: c.name # type: ignore
)
hierarchy = create_class_hierarchy(classes)
uml_classes = filter_uml_classes(classes, modeling_language)
with open(outfile, "w") as f:
f.write(header)
for cls in uml_classes:
f.write(f"from gaphor.UML import {cls.name}\n")
cls_written: Set[Element] = set(uml_classes)
for cls in hierarchy.keys():
cls.attribute.sort(key=lambda a: a.name or "") # type: ignore[attr-defined]
write_class_def(cls, hierarchy, f, cls_written)
f.write("\n\n")
for cls in hierarchy.keys():
write_properties(cls, f, enumerations)
for cls in hierarchy.keys():
write_subsets(cls, f)
element_factory.shutdown()
def test_connection(self):
"""
Test connection loading of an association and two classes.
(Should count for all line-like objects alike if this works).
"""
c1 = self.create(items.ClassItem, UML.Class)
c2 = self.create(items.ClassItem, UML.Class)
c2.matrix.translate(200, 200)
self.diagram.canvas.update_matrix(c2)
assert tuple(self.diagram.canvas.get_matrix_i2c(c2)) == (1, 0, 0, 1,
200, 200)
a = self.create(items.AssociationItem)
self.connect(a, a.head, c1)
head_pos = a.head.pos
self.connect(a, a.tail, c2)
tail_pos = a.tail.pos
self.diagram.canvas.update_now()
assert a.head.pos.y == 0, a.head.pos
assert a.tail.pos.x == 10, a.tail.pos
# assert a.tail.y == 200, a.tail.pos
assert a.subject
fd = StringIO()
storage.save(XMLWriter(fd), factory=self.element_factory)
data = fd.getvalue()
fd.close()
old_a_subject_id = a.subject.id
self.element_factory.flush()
assert not list(self.element_factory.select())
fd = StringIO(data)
storage.load(fd, factory=self.element_factory)
fd.close()
diagrams = list(self.kindof(UML.Diagram))
self.assertEqual(1, len(diagrams))
d = diagrams[0]
a = d.canvas.select(lambda e: isinstance(e, items.AssociationItem))[0]
self.assertTrue(a.subject is not None)
self.assertEqual(old_a_subject_id, a.subject.id)
cinfo_head = a.canvas.get_connection(a.head)
self.assertTrue(cinfo_head.connected is not None)
cinfo_tail = a.canvas.get_connection(a.tail)
self.assertTrue(cinfo_tail.connected is not None)
self.assertTrue(not cinfo_head.connected is cinfo_tail.connected)
def load(self, data):
"""
Load data from specified string. Update ``TestCase.diagram``
attribute to hold new loaded diagram.
"""
from gaphor.storage import storage
f = StringIO(data)
storage.load(f,
factory=self.element_factory,
modeling_language=self.modeling_language)
f.close()
self.diagram = self.element_factory.lselect(UML.Diagram)[0]
def test_connection(self):
"""
Test connection loading of an association and two classes.
(Should count for all line-like objects alike if this works).
"""
c1 = self.create(items.ClassItem, UML.Class)
c2 = self.create(items.ClassItem, UML.Class)
c2.matrix.translate(200, 200)
self.diagram.canvas.update_matrix(c2)
assert tuple(self.diagram.canvas.get_matrix_i2c(c2)) == (1, 0, 0, 1, 200, 200)
a = self.create(items.AssociationItem)
self.connect(a, a.head, c1)
head_pos = a.head.pos
self.connect(a, a.tail, c2)
tail_pos = a.tail.pos
self.diagram.canvas.update_now()
assert a.head.pos.y == 0, a.head.pos
assert a.tail.pos.x == 10, a.tail.pos
#assert a.tail.y == 200, a.tail.pos
assert a.subject
fd = StringIO()
storage.save(XMLWriter(fd), factory=self.element_factory)
data = fd.getvalue()
fd.close()
old_a_subject_id = a.subject.id
self.element_factory.flush()
assert not list(self.element_factory.select())
fd = StringIO(data)
storage.load(fd, factory=self.element_factory)
fd.close()
diagrams = list(self.kindof(UML.Diagram))
self.assertEquals(1, len(diagrams))
d = diagrams[0]
a = d.canvas.select(lambda e: isinstance(e, items.AssociationItem))[0]
self.assertTrue(a.subject is not None)
self.assertEquals(old_a_subject_id, a.subject.id)
cinfo_head = a.canvas.get_connection(a.head)
self.assertTrue(cinfo_head.connected is not None)
cinfo_tail = a.canvas.get_connection(a.tail)
self.assertTrue(cinfo_tail.connected is not None)
self.assertTrue(not cinfo_head.connected is cinfo_tail.connected)
def test_tagged_values_upgrade(self):
"""Test tagged values upgrade in Gaphor 0.15.0
"""
dist = pkg_resources.get_distribution('gaphor')
path = os.path.join(dist.location,
'test-diagrams/taggedvalues-pre015.gaphor')
with open(path) as ifile:
storage.load(ifile, factory=self.element_factory)
diagrams = list(self.kindof(uml2.Diagram))
self.assertEquals(1, len(diagrams))
diagram = diagrams[0]
classes = diagram.canvas.select(
lambda e: isinstance(e, items.ClassItem))
profiles = self.element_factory.lselect(
lambda e: isinstance(e, uml2.Profile))
stereotypes = self.element_factory.lselect(
lambda e: isinstance(e, uml2.Stereotype))
self.assertEquals(2, len(classes))
c1, c2 = classes
self.assertEquals(1, len(profiles))
profile = profiles[0]
self.assertEquals('version 0.15 conversion', profile.name)
self.assertEquals(1, len(stereotypes))
stereotype = stereotypes[0]
self.assertEquals('Tagged', stereotype.name)
self.assertEquals(profile, stereotype.namespace)
self.assertEquals('c1', c1.subject.name)
self.assertEquals('c2', c2.subject.name)
self.assertEquals(stereotype,
c1.subject.appliedStereotype[0].classifier[0])
self.assertEquals(stereotype,
c2.subject.appliedStereotype[0].classifier[0])
self.assertEquals(
't1', c1.subject.appliedStereotype[0].slot[0].definingFeature.name)
self.assertEquals(
't2', c1.subject.appliedStereotype[0].slot[1].definingFeature.name)
self.assertEquals(
't5', c2.subject.appliedStereotype[0].slot[0].definingFeature.name)
self.assertEquals(
't6', c2.subject.appliedStereotype[0].slot[1].definingFeature.name)
self.assertEquals(
't7', c2.subject.appliedStereotype[0].slot[2].definingFeature.name)
def generate(
filename: PathLike,
outfile: PathLike,
overridesfile: Optional[PathLike] = None,
) -> None:
"""Generates the Python data model.
Opens the Gaphor model, generates the list of classes using the element
factory, and then creates a new Python data model using a relationship
search tree.
"""
element_factory = ElementFactory()
modeling_language = UMLModelingLanguage()
with open(filename):
storage.load(
filename,
element_factory,
modeling_language,
)
with open(outfile, "w") as f:
f.write(header)
classes: List = element_factory.lselect(
lambda e: e.isKindOf(UML.Class))
classes, enumerations = find_enumerations(classes)
classes = sorted((cls for cls in classes if cls.name[0] != "~"),
key=lambda c: c.name)
trees = create_class_trees(classes)
create_referenced(classes)
uml_classes = filter_uml_classes(classes, modeling_language)
for cls in uml_classes:
f.write(f"from gaphor.UML import {cls.name}\n")
cls_written: Set[Element] = set(uml_classes)
for cls in trees.keys():
cls.attribute.sort(
key=lambda a: a.name or "") # type: ignore[attr-defined]
write_class_def(cls, trees, f, cls_written)
f.write("\n\n")
for cls in trees.keys():
write_properties(cls, f, enumerations)
element_factory.shutdown()
def test_save_and_load_of_association_with_two_connected_classes(
self, case):
c1 = case.create(ClassItem, UML.Class)
c2 = case.create(ClassItem, UML.Class)
c2.matrix.translate(200, 200)
case.diagram.request_update(c2)
case.diagram.update_now((c1, c2))
assert tuple(c2.matrix_i2c) == (1, 0, 0, 1, 200, 200)
a = case.create(AssociationItem)
case.connect(a, a.head, c1)
case.connect(a, a.tail, c2)
case.diagram.update_now((c1, c2, a))
assert a.head.pos.y == 0, a.head.pos
assert a.tail.pos.x == 200, a.tail.pos
assert a.tail.pos.y == 200, a.tail.pos
assert a.subject
fd = StringIO()
storage.save(XMLWriter(fd), factory=case.element_factory)
data = fd.getvalue()
fd.close()
old_a_subject_id = a.subject.id
case.element_factory.flush()
assert not list(case.element_factory.select())
fd = StringIO(data)
storage.load(fd,
factory=case.element_factory,
modeling_language=case.modeling_language)
fd.close()
diagrams = list(case.kindof(UML.Diagram))
assert len(diagrams) == 1
d = diagrams[0]
a = next(d.select(lambda e: isinstance(e, AssociationItem)))
assert a.subject is not None
assert old_a_subject_id == a.subject.id
cinfo_head = a.diagram.connections.get_connection(a.head)
assert cinfo_head.connected is not None
cinfo_tail = a.diagram.connections.get_connection(a.tail)
assert cinfo_tail.connected is not None
assert cinfo_head.connected is not cinfo_tail.connected
def test_load_save(self):
f = open('test-diagrams/simple-items.gaphor', 'r')
storage.load(f, factory=self.element_factory)
f.close()
pf = PseudoFile()
storage.save(XMLWriter(pf), factory=self.element_factory)
f = open('test-diagrams/simple-items.gaphor', 'r')
orig = f.read()
f.close()
copy = pf.data
expr = re.compile('gaphor-version="[^"]*"')
orig = expr.sub('%VER%', orig)
copy = expr.sub('%VER%', copy)
f = open('tmp.gaphor', 'w')
f.write(copy)
f.close()
self.assertEquals(copy, orig)
if not args:
parser.print_help()
# sys.exit(1)
factory = UML.ElementFactory()
name_re = None
if options.regex:
name_re = re.compile(options.regex, re.I)
# we should have some gaphor files to be processed at this point
for model in args:
message("loading model %s" % model)
storage.load(model, factory)
message("\nready for rendering\n")
for diagram in factory.select(lambda e: e.isKindOf(UML.Diagram)):
odir = pkg2dir(diagram.package)
# just diagram name
dname = diagram.name
# full diagram name including package path
pname = "%s/%s" % (odir, dname)
if options.underscores:
odir = odir.replace(" ", "_")
dname = dname.replace(" ", "_")
if name_re and not name_re.search(pname):
def load_old_model():
with io.open(path, "r") as ifile:
storage.load(ifile, factory=self.element_factory)
def test_lifeline_messages_upgrade(self):
"""Test message occurrence specification upgrade in Gaphor 0.15.0
"""
f = open('test-diagrams/lifelines-pre015.gaphor')
storage.load(f, factory=self.element_factory)
f.close()
diagrams = list(self.kindof(UML.Diagram))
self.assertEquals(1, len(diagrams))
diagram = diagrams[0]
lifelines = diagram.canvas.select(lambda e: isinstance(e, items.LifelineItem))
occurrences = self.kindof(UML.MessageOccurrenceSpecification)
messages = self.kindof(UML.Message)
self.assertEquals(2, len(lifelines))
self.assertEquals(12, len(messages))
# 2 * 12 but there are 4 lost/found messages
self.assertEquals(20, len(set(occurrences)))
l1, l2 = lifelines
if l1.subject.name == 'a2':
l1, l2 = l2, l1
def find(name):
return (m for m in messages if m.name == name).next()
m1 = find('call()')
m2 = find('callx()')
m3 = find('cally()')
# inverted messages
m4 = find('calla()')
m5 = find('callb()')
self.assertTrue(m1.sendEvent.covered is l1.subject)
self.assertTrue(m2.sendEvent.covered is l1.subject)
self.assertTrue(m3.sendEvent.covered is l1.subject)
self.assertTrue(m1.receiveEvent.covered is l2.subject)
self.assertTrue(m2.receiveEvent.covered is l2.subject)
self.assertTrue(m3.receiveEvent.covered is l2.subject)
# test inverted messages
self.assertTrue(m4.sendEvent.covered is l2.subject)
self.assertTrue(m5.sendEvent.covered is l2.subject)
self.assertTrue(m4.receiveEvent.covered is l1.subject)
self.assertTrue(m5.receiveEvent.covered is l1.subject)
m = find('simple()')
self.assertTrue(m.sendEvent.covered is l1.subject)
self.assertTrue(m.receiveEvent.covered is l2.subject)
m = find('found1()')
self.assertTrue(m.sendEvent is None)
self.assertTrue(m.receiveEvent.covered is l1.subject)
m = find('found2()')
self.assertTrue(m.sendEvent is None)
self.assertTrue(m.receiveEvent.covered is l1.subject)
m = find('rfound1()')
self.assertTrue(m.sendEvent.covered is l1.subject)
self.assertTrue(m.receiveEvent is None)
m = find('lost1()')
self.assertTrue(m.sendEvent.covered is l1.subject)
self.assertTrue(m.receiveEvent is None)
m = find('lost2()')
self.assertTrue(m.sendEvent.covered is l1.subject)
self.assertTrue(m.receiveEvent is None)
m = find('rlost1()')
self.assertTrue(m.sendEvent is None)
self.assertTrue(m.receiveEvent.covered is l1.subject)
def test_it(self):
"""
Test an issue when loading a freshly created action diagram.
"""
ef = self.element_factory
storage.load('test-diagrams/action-issue.gaphor', ef)
actions = ef.lselect(lambda e: e.isKindOf(UML.Action))
flows = ef.lselect(lambda e: e.isKindOf(UML.ControlFlow))
self.assertEqual(3, len(actions))
self.assertEqual(3, len(flows))
# Actions live in partitions:
partitions = ef.lselect(lambda e: e.isKindOf(UML.ActivityPartition))
self.assertEquals(2, len(partitions))
# Okay, so far the data model is saved correctly. Now, how do the
# handles behave?
diagrams = ef.lselect(lambda e: e.isKindOf(UML.Diagram))
self.assertEquals(1, len(diagrams))
canvas = diagrams[0].canvas
assert 9 == len(canvas.get_all_items())
# Part, Part, Act, Act, Part, Act, Flow, Flow, Flow
for e in actions + flows:
self.assertEquals(1, len(e.presentation), e)
for i in canvas.select(lambda e: isinstance(e, (FlowItem, ActionItem))):
self.assertTrue(i.subject, i)
# Loaded as:
#
# actions[1] --> flows[0, 1]
# flows[0, 2] --> actions[0]
# flows[1] --> actions[2] --> flows[2]
# start element:
self.assertSame(actions[1].outgoing[0], flows[0])
self.assertSame(actions[1].outgoing[1], flows[1])
self.assertFalse(actions[1].incoming)
cinfo, = canvas.get_connections(handle=flows[0].presentation[0].head)
self.assertSame(cinfo.connected, actions[1].presentation[0])
cinfo, = canvas.get_connections(handle=flows[1].presentation[0].head)
self.assertSame(cinfo.connected, actions[1].presentation[0])
# Intermediate element:
self.assertSame(actions[2].incoming[0], flows[1])
self.assertSame(actions[2].outgoing[0], flows[2])
cinfo, = canvas.get_connections(handle=flows[1].presentation[0].tail)
self.assertSame(cinfo.connected, actions[2].presentation[0])
cinfo, = canvas.get_connections(handle=flows[2].presentation[0].head)
self.assertSame(cinfo.connected, actions[2].presentation[0])
# Final element:
self.assertSame(actions[0].incoming[0], flows[0])
self.assertSame(actions[0].incoming[1], flows[2])
cinfo, = canvas.get_connections(handle=flows[0].presentation[0].tail)
self.assertSame(cinfo.connected, actions[0].presentation[0])
cinfo, = canvas.get_connections(handle=flows[2].presentation[0].tail)
self.assertSame(cinfo.connected, actions[0].presentation[0])
# Test the parent-child connectivity
for a in actions:
p, = a.inPartition
self.assertTrue(p)
self.assertTrue(canvas.get_parent(a.presentation[0]))
self.assertSame(canvas.get_parent(a.presentation[0]), p.presentation[0])
def setUp(self):
Application.init()
element_factory = Application.get_service('element_factory')
from gaphor.storage.storage import load
load('tests/issue_53.gaphor', element_factory)
def handler():
try:
load("test-diagrams/diagram-#4.gaphor", self.element_factory)
finally:
gtk.main_quit()
