def test_formal_parameter_to_owned_parameter(loader):
o = element(id="1", type="Operation")
o.references["formalParameter"] = ["2"]
p = element(id="2", type="Parameter")
operation, parameter = loader(o, p)
assert parameter in operation.ownedParameter
assert parameter.operation is operation
def test_implementation_to_interface_realization(loader):
i = element(id="1", type="Implementation")
c = element(id="2", type="Class")
c.references["clientDependency"] = ["1"]
interface_realization, clazz = loader(i, c)
assert interface_realization in clazz.interfaceRealization
assert interface_realization.implementatingClassifier is clazz
def test_owned_classifier_to_owned_type(loader):
p = element(id="1", type="Package")
p.references["ownedClassifier"] = ["2"]
c = element(id="2", type="Class")
package, clazz = loader(p, c)
assert clazz in package.ownedType
assert clazz.package is package
def test_return_result_to_owned_parameter(loader):
o = element(id="1", type="Operation")
o.references["returnResult"] = ["2"]
p = element(id="2", type="Parameter")
p.references["ownerReturnParam"] = ["1"]
operation, parameter = loader(o, p)
assert parameter in operation.ownedParameter
assert parameter.operation is operation
def test_owned_comment_to_comment_upgrade(loader):
c = element(id="1", type="Comment")
c.references["annotatedElement"] = ["2"]
e = element(id="2", type="Element")
e.references["ownedComment"] = ["1"]
comment, elem = loader(c, e)
assert elem in comment.annotatedElement
assert comment in elem.comment
def test_parameters_to_owned_parameter(loader):
o = element(id="1", type="Operation")
o.references["formalParameter"] = ["2"]
o.references["returnResult"] = ["3"]
p = element(id="2", type="Parameter")
r = element(id="3", type="Parameter")
operation, parameter, return_param = loader(o, p, r)
assert parameter in operation.ownedParameter
assert return_param in operation.ownedParameter
assert parameter.operation is operation
assert return_param.operation is operation
def version_0_7_2(elements, factory, gaphor_version):
"""
Before 0.7.2, only Property and Parameter elements had taggedValues.
Since 0.7.2 all NamedElements are able to have taggedValues. However,
the multiplicity of taggedValue has changed from 0..1 to *, so all elements
should be converted to a list.
"""
import uuid
if version_lower_than(gaphor_version, (0, 7, 2)):
for elem in list(elements.values()):
try:
if isinstance(elem, parser.element) \
and elem.type in ('Property', 'Parameter') \
and elem.taggedValue:
tvlist = []
tv = elements[elem.taggedValue]
if tv.value:
for t in map(str.strip, str(tv.value).split(',')):
#log.debug("Tagged value: %s" % t)
newtv = parser.element(str(uuid.uuid1()),
'LiteralSpecification')
newtv.values['value'] = t
elements[newtv.id] = newtv
tvlist.append(newtv.id)
elem.references['taggedValue'] = tvlist
except Exception as e:
log.error('Error while updating taggedValues', exc_info=True)
def version_0_14_0(elements, factory, gaphor_version):
"""
Fix applied stereotypes UML metamodel. Before Gaphor 0.14.0 applied
stereotypes was a collection of stereotypes classes, but now the list
needs to be replaced with collection of stereotypes instances.
This function is called before the actual elements are constructed.
"""
import uuid
if version_lower_than(gaphor_version, (0, 14, 0)):
values = (v for v in list(elements.values())
if isinstance(v, parser.element))
for et in values:
try:
if 'appliedStereotype' in et.references:
data = tuple(et.references['appliedStereotype'])
applied = []
# collect stereotypes instances in `applied` list
for refid in data:
st = elements[refid]
obj = parser.element(str(uuid.uuid1()),
'InstanceSpecification')
obj.references['classifier'] = [st.id]
elements[obj.id] = obj
applied.append(obj.id)
assert obj.id in applied and obj.id in elements
# replace stereotypes with their instances
assert len(applied) == len(data)
et.references['appliedStereotype'] = applied
except Exception as e:
log.error('Error while updating stereotypes', exc_info=True)
def version_0_7_2(elements, factory, gaphor_version):
"""
Before 0.7.2, only Property and Parameter elements had taggedValues.
Since 0.7.2 all NamedElements are able to have taggedValues. However,
the multiplicity of taggedValue has changed from 0..1 to *, so all elements
should be converted to a list.
"""
import uuid
if version_lower_than(gaphor_version, (0, 7, 2)):
for elem in elements.values():
try:
if type(elem) is parser.element \
and elem.type in ('Property', 'Parameter') \
and elem.taggedValue:
tvlist = []
tv = elements[elem.taggedValue]
if tv.value:
for t in map(str.strip, str(tv.value).split(',')):
#log.debug("Tagged value: %s" % t)
newtv = parser.element(str(uuid.uuid1()),
'LiteralSpecification')
newtv.values['value'] = t
elements[newtv.id] = newtv
tvlist.append(newtv.id)
elem.references['taggedValue'] = tvlist
except Exception, e:
log.error('Error while updating taggedValues', exc_info=True)
def version_0_14_0(elements, factory, gaphor_version):
"""
Fix applied stereotypes UML metamodel. Before Gaphor 0.14.0 applied
stereotypes was a collection of stereotypes classes, but now the list
needs to be replaced with collection of stereotypes instances.
This function is called before the actual elements are constructed.
"""
import uuid
if version_lower_than(gaphor_version, (0, 14, 0)):
values = (v for v in elements.values() if type(v) is parser.element)
for et in values:
try:
if 'appliedStereotype' in et.references:
data = tuple(et.references['appliedStereotype'])
applied = []
# collect stereotypes instances in `applied` list
for refid in data:
st = elements[refid]
obj = parser.element(str(uuid.uuid1()),
'InstanceSpecification')
obj.references['classifier'] = [st.id]
elements[obj.id] = obj
applied.append(obj.id)
assert obj.id in applied and obj.id in elements
# replace stereotypes with their instances
assert len(applied) == len(data)
et.references['appliedStereotype'] = applied
except Exception, e:
log.error('Error while updating stereotypes', exc_info=True)
def _loader(*parsed_items):
parsed_data = {
"1": element(
id="1", type="Diagram", canvas=canvas(canvasitems=list(parsed_items))
),
**{p.id: p for p in parsed_items},
}
load_elements(parsed_data, element_factory, modeling_language)
return element_factory.lselect()[0].canvas.get_root_items()[0]
def test_upgrade_subsystem_item_to_class_item(element_factory):
elements = {
"1": element(
id="1",
type="Diagram",
canvas=canvas(canvasitems=[canvasitem(id="2", type="SubsystemItem")]),
)
}
load_elements(elements, element_factory)
item = element_factory.lselect()[0].canvas.get_root_items()[0]
assert type(item) == diagramitems.ComponentItem
def convert_tagged_value(element, elements, factory):
"""
Convert ``element.taggedValue`` to something supported by the
UML 2.2 model (since Gaphor version 0.15).
For each item having a Tagged value a Stereotype is linked. This is done
like this:
item -> InstanceSpecification -> Stereotype
Each tagged value will be replaced by a Slot:
item -> InstanceSpecification -> Slot -> Attribute -> Stereotype
"""
import uuid
diagrams = [e for e in list(elements.values()) if e.type == 'Diagram']
presentation = element.get('presentation') or []
tv = [elements[i] for i in element.references['taggedValue']]
for et in presentation:
et = elements[et]
m = eval(et.values['matrix'])
w = eval(et.values['width'])
tagged = 'upgrade to stereotype attributes' \
' following tagged values:\n%s' % '\n'.join(t.values['value'] for t in tv)
item = parser.canvasitem(str(uuid.uuid1()), 'CommentItem')
comment = parser.element(str(uuid.uuid1()), 'Comment')
item.references['subject'] = comment.id
item.values['matrix'] = str(
(1.0, 0.0, 0.0, 1.0, m[4] + w + 10.0, m[5]))
comment.references['presentation'] = [item.id]
comment.values['body'] = tagged
elements[item.id] = item
elements[comment.id] = comment
# Where to place the comment? How to find the Diagram?
for d in diagrams:
for ci in d.canvas.canvasitems:
if ci.id == et.id:
d.canvas.canvasitems.append(item)
break
def convert_tagged_value(element, elements, factory):
"""
Convert ``element.taggedValue`` to something supported by the
UML 2.2 model (since Gaphor version 0.15).
For each item having a Tagged value a Stereotype is linked. This is done
like this:
item -> InstanceSpecification -> Stereotype
Each tagged value will be replaced by a Slot:
item -> InstanceSpecification -> Slot -> Attribute -> Stereotype
"""
import uuid
diagrams = [e for e in elements.values() if e.type == 'Diagram']
presentation = element.get('presentation') or []
tv = [elements[i] for i in element.references['taggedValue']]
for et in presentation:
et = elements[et]
m = eval(et.values['matrix'])
w = eval(et.values['width'])
tagged = 'upgrade to stereotype attributes' \
' following tagged values:\n%s' % '\n'.join(t.values['value'] for t in tv)
item = parser.canvasitem(str(uuid.uuid1()), 'CommentItem')
comment = parser.element(str(uuid.uuid1()), 'Comment')
item.references['subject'] = comment.id
item.values['matrix'] = str((1.0, 0.0, 0.0, 1.0, m[4] + w + 10.0, m[5]))
comment.references['presentation'] = [item.id]
comment.values['body'] = tagged
elements[item.id] = item
elements[comment.id] = comment
# Where to place the comment? How to find the Diagram?
for d in diagrams:
for ci in d.canvas.canvasitems:
if ci.id == et.id:
d.canvas.canvasitems.append(item)
break
def update_elements(element):
e = elements[element.id] = parser.element(element.id,
element.__class__.__name__)
e.element = element
def update_elements(element):
e = elements[element.id] = parser.element(element.id, element.__class__.__name__)
e.element = element
