def copy_state(element: State):
yield element.id, copy_named_element(element)
if element.entry:
yield from copy(element.entry)
if element.exit:
yield from copy(element.exit)
if element.doActivity:
yield from copy(element.doActivity)
def test_copy_item_with_connection(diagram, element_factory):
gen_cls_item, spc_cls_item, gen_item = two_classes_and_a_generalization(
diagram, element_factory
)
buffer = copy({gen_cls_item, gen_item, spc_cls_item})
new_items = paste(buffer, diagram, element_factory.lookup)
new_gen_item = next(i for i in new_items if isinstance(i, GeneralizationItem))
new_cls_item1 = diagram.connections.get_connection(
new_gen_item.handles()[0]
).connected
new_cls_item2 = diagram.connections.get_connection(
new_gen_item.handles()[1]
).connected
assert new_cls_item1 in diagram.get_all_items()
assert new_cls_item2 in diagram.get_all_items()
assert len(new_items) == 3
assert new_cls_item1 in new_items
assert new_cls_item2 in new_items
# Model elements are not copied
assert new_cls_item1.subject is gen_cls_item.subject
assert new_cls_item2.subject is spc_cls_item.subject
assert new_gen_item.subject is gen_item.subject
def copy_class(element):
yield element.id, copy_named_element(element)
for feature in itertools.chain(
element.ownedAttribute,
element.ownedOperation,
):
yield from copy(feature)
def copy_operation(element: Operation):
yield element.id, copy_named_element(element)
for feature in itertools.chain(
element.formalParameter,
element.returnResult,
):
yield from copy(feature)
def test_copy_item_with_connection(diagram, element_factory):
gen_cls_item, spc_cls_item, gen_item = two_classes_and_a_generalization(
diagram, element_factory)
buffer = copy({gen_cls_item, gen_item, spc_cls_item})
new_items = paste(buffer, diagram, element_factory.lookup)
new_gen_item = next(i for i in new_items
if isinstance(i, GeneralizationItem))
new_cls_item1 = new_gen_item.canvas.get_connection(
new_gen_item.handles()[0]).connected
new_cls_item2 = new_gen_item.canvas.get_connection(
new_gen_item.handles()[1]).connected
assert new_cls_item1 in diagram.canvas.get_root_items()
assert new_cls_item2 in diagram.canvas.get_root_items()
assert len(new_items) == 3
assert new_cls_item1 in new_items
assert new_cls_item2 in new_items
# Model elements are not copied
assert len(
element_factory.lselect(lambda e: isinstance(e, UML.Class))) == 2
assert (len(
element_factory.lselect(lambda e: isinstance(e, UML.Generalization)))
== 1)
def test_copy_paste_of_nested_item(diagram, element_factory, node_with_component):
node_item, comp_item = node_with_component
buffer = copy({comp_item})
(new_comp_item,) = paste(buffer, diagram, element_factory.lookup)
assert new_comp_item.parent is node_item
def test_copy_item_adds_new_item_to_the_diagram(diagram, element_factory):
cls = element_factory.create(UML.Class)
cls_item = diagram.create(ClassItem, subject=cls)
buffer = copy(cls_item)
paste(buffer, diagram, element_factory.lookup)
assert len(diagram.canvas.get_root_items()) == 2
def test_copy_item_adds_new_item_to_the_diagram(diagram, element_factory):
cls = element_factory.create(UML.Class)
cls_item = diagram.create(ClassItem, subject=cls)
_, buffer = next(copy(cls_item))
paster = paste(buffer, diagram, element_factory.lookup)
next(paster)
next(paster, None)
assert len(list(diagram.get_all_items())) == 2
def test_copy_multiple_items(diagram, element_factory):
cls = element_factory.create(UML.Class)
cls_item1 = diagram.create(ClassItem, subject=cls)
cls_item2 = diagram.create(ClassItem, subject=cls)
buffer = copy({cls_item1, cls_item2})
paste(buffer, diagram, element_factory.lookup)
assert len(diagram.canvas.get_root_items()) == 4
assert len(element_factory.lselect(UML.Class)) == 1
def test_copy_to_new_diagram(diagram, element_factory):
new_diagram = element_factory.create(Diagram)
cls = element_factory.create(UML.Class)
cls_item = diagram.create(ClassItem, subject=cls)
buffer = copy({cls_item})
paste(buffer, new_diagram, element_factory.lookup)
assert len(list(new_diagram.get_all_items())) == 1
assert next(new_diagram.get_all_items()).diagram is new_diagram
def test_copy_paste_of_item_with_nested_item(diagram, element_factory,
node_with_component):
node_item, comp_item = node_with_component
buffer = copy(set(node_with_component))
new_items = paste(buffer, diagram, element_factory.lookup)
new_node_item = next(i for i in new_items if isinstance(i, NodeItem))
new_comp_item = next(i for i in new_items if isinstance(i, ComponentItem))
assert diagram.canvas.get_parent(new_comp_item) is new_node_item
def test_copied_item_references_same_model_element(diagram, element_factory):
cls = element_factory.create(UML.Class)
cls_item = diagram.create(ClassItem, subject=cls)
buffer = copy(cls_item)
paste(buffer, diagram, element_factory.lookup)
assert len(diagram.canvas.get_root_items()) == 2
item1, item2 = diagram.canvas.get_root_items()
assert item1.subject is item2.subject
def test_copied_item_references_same_model_element(diagram, element_factory):
cls = element_factory.create(UML.Class)
cls_item = diagram.create(ClassItem, subject=cls)
_, buffer = next(copy(cls_item))
for element in paste(buffer, diagram, element_factory.lookup):
pass
assert len(list(diagram.get_all_items())) == 2
item1, item2 = diagram.get_all_items()
assert item1.subject is item2.subject
def test_copy_item_without_copying_connection(diagram, element_factory):
cls = element_factory.create(UML.Class)
cls_item = diagram.create(ClassItem, subject=cls)
gen_item = diagram.create(GeneralizationItem)
connect(gen_item, gen_item.handles()[0], cls_item)
buffer = copy({cls_item})
new_items = paste(buffer, diagram, element_factory.lookup)
assert len(diagram.canvas.get_root_items()) == 3
assert len(element_factory.lselect(UML.Class)) == 1
assert type(new_items) is set
assert len(new_items) == 1
def test_copy_item_when_subject_has_been_removed(diagram, element_factory):
package = element_factory.create(UML.Package)
cls = element_factory.create(UML.Class)
cls.package = package
orig_cls_id = cls.id
cls_item = diagram.create(ClassItem, subject=cls)
buffer = copy({cls_item})
cls_item.unlink()
cls.unlink() # normally handled by the sanitizer service
assert len(diagram.canvas.get_all_items()) == 0
assert len(element_factory.lselect()) == 3
assert not element_factory.lookup(orig_cls_id)
print(buffer)
paste(buffer, diagram, element_factory.lookup)
new_cls = element_factory.lselect(UML.Class)[0]
assert len(diagram.canvas.get_root_items()) == 1
assert new_cls.package is package
assert element_factory.lookup(orig_cls_id) is new_cls
def copy_transition(element: Transition):
yield element.id, copy_named_element(element)
if element.guard:
yield from copy(element.guard)
def copy(self, items):
if items:
self.copy_buffer = copy(items)
def copy_message(element: Message):
yield element.id, copy_named_element(element)
if element.sendEvent:
yield from copy(element.sendEvent)
if element.receiveEvent:
yield from copy(element.receiveEvent)
def copy_and_paste(items, diagram, element_factory, retain=[]):
buffer = copy(items)
return paste(buffer, diagram, element_factory.lookup)
def copy_association(element: Association):
yield element.id, copy_named_element(element)
for end in element.memberEnd:
yield from copy(end)
def copy_operation(element: Operation):
yield element.id, copy_named_element(element)
for feature in element.ownedParameter:
yield from copy(feature)
def copy_clear_and_paste(items, diagram, element_factory, retain=[]):
buffer = copy(items)
clear_model(diagram, element_factory, retain)
print(buffer)
return paste(buffer, diagram, element_factory.lookup)
def copy_class(element: PartitionItem):
yield element.id, copy_presentation(element)
for partition in element.partition:
yield from copy(partition)
def copy(self, items):
global copy_buffer
if items:
copy_buffer = copy(items)
def copy_execution_specification(element: ExecutionSpecification):
yield element.id, copy_named_element(element)
for occurrence in element.executionOccurrenceSpecification:
yield from copy(occurrence)
def copy_connector(element: Connector):
yield element.id, copy_named_element(element)
for end in element.end:
yield from copy(end)
def copy_connector_end(element: ConnectorEnd):
yield element.id, copy_element(element)
if element.partWithPort:
yield from copy(element.partWithPort)
