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 test_elements_ns_1():
w = Writer()
xml_w = XMLWriter(w)
xml_w.startDocument()
xml_w.startPrefixMapping("g", "http://gaphor.devjavu.com/schema")
xml_w.startElementNS(("http://gaphor.devjavu.com/schema", "foo"), "qn", {})
xml_w.endElementNS(("http://gaphor.devjavu.com/schema", "foo"), "qn")
xml = (
"""<?xml version="1.0" encoding="%s"?>\n<g:foo xmlns:g="http://gaphor.devjavu.com/schema"/>"""
% sys.getdefaultencoding())
assert w.s == xml, w.s
def test_elements_ns_1(self):
w = Writer()
xml_w = XMLWriter(w)
xml_w.startDocument()
xml_w.startPrefixMapping('g', 'http://gaphor.devjavu.com/schema')
xml_w.startElementNS(('http://gaphor.devjavu.com/schema', 'foo'), 'qn',
{})
xml_w.endElementNS(('http://gaphor.devjavu.com/schema', 'foo'), 'qn')
xml = """<?xml version="1.0" encoding="%s"?>\n<g:foo xmlns:g="http://gaphor.devjavu.com/schema"/>""" % sys.getdefaultencoding(
)
assert w.s == xml, w.s
def test_elements_test(self):
w = Writer()
xml_w = XMLWriter(w)
xml_w.startDocument()
xml_w.startElement('foo', {})
xml_w.startElement('bar', {})
xml_w.characters('hello')
xml_w.endElement('bar')
xml_w.endElement('foo')
xml = """<?xml version="1.0" encoding="%s"?>\n<foo>\n<bar>hello</bar>\n</foo>""" % sys.getdefaultencoding(
)
assert w.s == xml, w.s
def test_elements_ns_1(self):
w = Writer()
xml_w = XMLWriter(w)
xml_w.startDocument()
xml_w.startPrefixMapping('g', 'http://gaphor.devjavu.com/schema')
xml_w.startElementNS(('http://gaphor.devjavu.com/schema', 'foo'), 'qn', {})
xml_w.endElementNS(('http://gaphor.devjavu.com/schema', 'foo'), 'qn')
xml = """<?xml version="1.0" encoding="%s"?>\n<g:foo xmlns:g="http://gaphor.devjavu.com/schema"/>""" % sys.getdefaultencoding()
assert w.s == xml, w.s
def test_elements_test():
w = Writer()
xml_w = XMLWriter(w)
xml_w.startDocument()
xml_w.startElement("foo", {})
xml_w.startElement("bar", {})
xml_w.characters("hello")
xml_w.endElement("bar")
xml_w.endElement("foo")
xml = (
"""<?xml version="1.0" encoding="%s"?>\n<foo>\n<bar>hello</bar>\n</foo>"""
% sys.getdefaultencoding())
assert w.s == xml, w.s
def test_elements_test(self):
w = Writer()
xml_w = XMLWriter(w)
xml_w.startDocument()
xml_w.startElement('foo', {})
xml_w.startElement('bar', {})
xml_w.characters('hello')
xml_w.endElement('bar')
xml_w.endElement('foo')
xml = """<?xml version="1.0" encoding="%s"?>\n<foo>\n<bar>hello</bar>\n</foo>""" % sys.getdefaultencoding()
assert w.s == xml, w.s
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 = 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 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_elements_ns_1(self):
w = Writer()
xml_w = XMLWriter(w)
xml_w.startDocument()
xml_w.startPrefixMapping("g", "http://gaphor.devjavu.com/schema")
xml_w.startElementNS(("http://gaphor.devjavu.com/schema", "foo"), "qn", {})
xml_w.endElementNS(("http://gaphor.devjavu.com/schema", "foo"), "qn")
xml = (
"""<?xml version="1.0" encoding="%s"?>\n<g:foo xmlns:g="http://gaphor.devjavu.com/schema"/>"""
% sys.getdefaultencoding()
)
assert w.s == xml, w.s
def test_elements_1(self):
w = Writer()
xml_w = XMLWriter(w)
xml_w.startDocument()
xml_w.startElement('foo', {})
xml_w.endElement('foo')
xml = """<?xml version="1.0" encoding="%s"?>\n<foo/>""" % sys.getdefaultencoding(
)
assert w.s == xml, w.s + ' != ' + xml
def test_elements_1(self):
w = Writer()
xml_w = XMLWriter(w)
xml_w.startDocument()
xml_w.startElement('foo', {})
xml_w.endElement('foo')
xml = """<?xml version="1.0" encoding="%s"?>\n<foo/>""" % sys.getdefaultencoding()
assert w.s == xml, w.s + ' != ' + xml
def save():
"""
Save diagram into string.
"""
f = StringIO()
storage.save(XMLWriter(f), element_factory)
data = f.getvalue()
f.close()
return data
def export(self, filename):
out = open(filename, "w")
xmi = XMLWriter(out)
attributes = dict()
attributes["xmi.version"] = self.XMI_VERSION
attributes["xmlns:xmi"] = self.XMI_NAMESPACE
attributes["xmlns:UML"] = self.UML_NAMESPACE
xmi.startElement("XMI", attrs=attributes)
for package in self.element_factory.select(self.select_package):
self.handle(xmi, package)
for generalization in self.element_factory.select(
self.select_generalization):
self.handle(xmi, generalization)
for realization in self.element_factory.select(
self.select_realization):
self.handle(xmi, realization)
xmi.endElement("XMI")
logger.debug(self.handled_ids)
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 test_save_item(self):
"""Save a diagranm item too.
"""
diagram = self.element_factory.create(UML.Diagram)
diagram.create(CommentItem, subject=self.element_factory.create(UML.Comment))
out = PseudoFile()
storage.save(XMLWriter(out), factory=self.element_factory)
out.close()
assert "<Diagram " in out.data
assert "<Comment " in out.data
assert "<canvas>" in out.data
assert ' type="CommentItem"' in out.data, out.data
def save(self):
"""
Save diagram into string.
"""
from gaphor.storage import storage
from gaphor.misc.xmlwriter import XMLWriter
f = StringIO()
storage.save(XMLWriter(f), factory=self.element_factory)
data = f.getvalue()
f.close()
self.element_factory.flush()
assert not list(self.element_factory.select())
assert not list(self.element_factory.lselect())
return data
def export(self, filename):
out = open(filename, "w")
xmi = XMLWriter(out)
attributes = dict()
attributes["xmi.version"] = self.XMI_VERSION
attributes["xmlns:xmi"] = self.XMI_NAMESPACE
attributes["xmlns:UML"] = self.UML_NAMESPACE
xmi.startElement("XMI", attrs=attributes)
for package in self.element_factory.select(self.select_package):
self.handle(xmi, package)
for generalization in self.element_factory.select(self.select_generalization):
self.handle(xmi, generalization)
for realization in self.element_factory.select(self.select_realization):
self.handle(xmi, realization)
xmi.endElement("XMI")
logger.debug(self.handled_ids)
def test_save_uml(self):
"""Saving gaphor.UML model elements.
"""
self.element_factory.create(UML.Package)
self.element_factory.create(UML.Diagram)
self.element_factory.create(UML.Comment)
self.element_factory.create(UML.Class)
out = PseudoFile()
storage.save(XMLWriter(out), factory=self.element_factory)
out.close()
assert "<Package " in out.data
assert "<Diagram " in out.data
assert "<Comment " in out.data
assert "<Class " in out.data
def test_elements_2(self):
w = Writer()
xml_w = XMLWriter(w)
xml_w.startDocument()
xml_w.startElement("foo", {})
xml_w.startElement("bar", {})
xml_w.endElement("bar")
xml_w.endElement("foo")
xml = (
"""<?xml version="1.0" encoding="%s"?>\n<foo>\n<bar/>\n</foo>"""
% sys.getdefaultencoding()
)
assert w.s == xml, w.s
def test_save_uml(self):
"""Saving gaphor.uml2 model elements.
"""
self.element_factory.create(uml2.Package)
self.element_factory.create(uml2.Diagram)
self.element_factory.create(uml2.Comment)
self.element_factory.create(uml2.Class)
out = PseudoFile()
storage.save(XMLWriter(out), factory=self.element_factory)
out.close()
assert '<Package ' in out.data
assert '<Diagram ' in out.data
assert '<Comment ' in out.data
assert '<Class ' in out.data
def save(self, filename):
"""Save the current UML model to the specified file name. Before
writing the model file, this will verify that there are no orphan
references. It will also verify that the filename has the correct
extension. A status window is displayed while the GIdleThread
is executed. This thread actually saves the model."""
log.info("Saving file")
log.debug("File name is %s" % filename)
if not filename or not len(filename):
return
self.verify_orphans()
filename = self.verify_filename(filename)
main_window = self.main_window
queue = Queue()
status_window = StatusWindow(
_("Saving..."),
_("Saving model to %s") % filename,
parent=main_window.window,
queue=queue,
)
try:
with open(filename.encode("utf-8"), "w") as out:
saver = storage.save_generator(XMLWriter(out),
self.element_factory)
worker = GIdleThread(saver, queue)
worker.start()
worker.wait()
if worker.error:
worker.reraise()
self.filename = filename
except:
error_handler(message=_("Error while saving model to file %s") %
filename)
raise
finally:
status_window.destroy()
def save(self, filename):
"""Save the current UML model to the specified file name. Before
writing the model file, this will verify that there are no orphan
references. It will also verify that the filename has the correct
extension. A status window is displayed while the GIdleThread
is executed. This thread actually saves the model."""
if not filename or not len(filename):
return
self.verify_orphans()
filename = self.verify_filename(filename)
main_window = self.main_window
queue = Queue()
status_window = StatusWindow(
gettext("Saving..."),
gettext("Saving model to {filename}").format(filename=filename),
parent=main_window.window,
queue=queue,
)
try:
with open(filename.encode("utf-8"), "w") as out:
saver = storage.save_generator(XMLWriter(out),
self.element_factory)
worker = GIdleThread(saver, queue)
worker.start()
worker.wait()
if worker.error:
worker.reraise()
self.filename = filename
self.event_manager.handle(FileSaved(self, filename))
except (OSError, QueueEmpty, QueueFull):
error_handler(message=gettext(
"Error while saving model to file {filename}").format(
filename=filename))
raise
finally:
status_window.destroy()
def export(self, filename):
writer = XMLWriter(filename, "utf-8")
writer.startDocument()
writer.startElement("Zaakspecificatie", {})
# TODO: Header stuff
writer.startElement("Toestandsverloop", {})
self._export_toestanden(writer)
writer.endElement("Toestandsverloop")
writer.endElement("Zaakspecificatie")
writer.endDocument()
