archimate 1.2.1 → 2.0.0

data/lib/archimate/file_formats/serializer/archi/bounds.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Archimate
+  module FileFormats
+    module Serializer
+      module Archi
+        module Bounds
+          def serialize_bounds(xml, bounds)
+            return unless bounds
+            xml.bounds(
+              remove_nil_values(
+                x: bounds.x&.to_i,
+                y: bounds.y&.to_i,
+                width: bounds.width&.to_i,
+                height: bounds.height&.to_i
+              )
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/archimate/file_formats/serializer/archi/connection.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Archimate
+  module FileFormats
+    module Serializer
+      module Archi
+        module Connection
+          def serialize_connection(xml, connection)
+            xml.sourceConnection(
+              remove_nil_values(
+                {
+                  "xsi:type" => connection.type,
+                  "id" => connection.id,
+                  "name" => connection.name
+                }.merge(
+                  archi_style_hash(connection.style).merge(
+                    "source" => connection.source&.id,
+                    "target" => connection.target&.id,
+                    "relationship" => connection.relationship&.id
+                  )
+                )
+              )
+            ) do
+              serialize(xml, connection.bendpoints)
+              serialize_documentation(xml, connection.documentation)
+              serialize(xml, connection.properties)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/archimate/file_formats/serializer/archi/diagram.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Archimate
+  module FileFormats
+    module Serializer
+      module Archi
+        module Diagram
+          def serialize_diagram(xml, diagram)
+            xml.element(
+              remove_nil_values(
+                "xsi:type" => diagram.type || "archimate:ArchimateDiagramModel",
+                "id" => diagram.id,
+                "name" => diagram.name,
+                "connectionRouterType" => diagram.connection_router_type,
+                "viewpoint" => ViewpointType.values.index(diagram.viewpoint_type)&.to_s,
+                "background" => diagram.background
+              )
+            ) do
+              serialize(xml, diagram.nodes)
+              serialize_documentation(xml, diagram.documentation)
+              serialize(xml, diagram.properties)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/archimate/file_formats/serializer/archi/documentation.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Archimate
+  module FileFormats
+    module Serializer
+      module Archi
+        module Documentation
+          def serialize_documentation(xml, documentation, element_name = "documentation")
+            return unless documentation
+            xml.send(element_name) { xml.text(documentation.text) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/archimate/file_formats/serializer/archi/element.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Archimate
+  module FileFormats
+    module Serializer
+      module Archi
+        module Element
+          def serialize_element(xml, element)
+            xml.element(
+              remove_nil_values(
+                "xsi:type" => "archimate:#{element.type}",
+                "id" => element.id,
+                "name" => element.name
+              )
+            ) do
+              serialize_documentation(xml, element.documentation)
+              serialize(xml, element.properties)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/archimate/file_formats/serializer/archi/location.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Archimate
+  module FileFormats
+    module Serializer
+      module Archi
+        module Location
+          # startX = location.x - source_attachment.x
+          # startY = location.y - source_attachment.y
+          # endX = location.x - target_attachment.x
+          # endY = location.y - source_attachment.y
+          def serialize_location(xml, bendpoint)
+            xml.bendpoint(
+              remove_nil_values(
+                startX: bendpoint.x == 0 ? nil : bendpoint.x&.to_i,
+                startY: bendpoint.y == 0 ? nil : bendpoint.y&.to_i,
+                endX: bendpoint.end_x&.to_i,
+                endY: bendpoint.end_y&.to_i
+              )
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/archimate/file_formats/serializer/archi/model.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Archimate
+  module FileFormats
+    module Serializer
+      module Archi
+        module Model
+          def serialize_model(xml, model)
+            xml["archimate"].model(
+              "xmlns:xsi" => "http://www.w3.org/2001/XMLSchema-instance",
+              "xmlns:archimate" => "http://www.archimatetool.com/archimate",
+              "name" => model.name,
+              "id" => model.id,
+              "version" => @version
+            ) do
+              serialize(xml, model.organizations)
+              serialize(xml, model.properties)
+              serialize_documentation(xml, model.documentation, "purpose")
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/archimate/file_formats/serializer/archi/organization.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Archimate
+  module FileFormats
+    module Serializer
+      module Archi
+        module Organization
+          def serialize_organization(xml, organization)
+            xml.folder(
+              remove_nil_values(name: organization.name, id: organization.id, type: organization.type)
+            ) do
+              serialize(xml, organization.organizations)
+              serialize_documentation(xml, organization.documentation)
+              serialize(xml, organization.items)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/archimate/file_formats/serializer/archi/property.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Archimate
+  module FileFormats
+    module Serializer
+      module Archi
+        module Property
+          def serialize_property(xml, property)
+            xml.property(remove_nil_values(key: property.key, value: property.value))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/archimate/file_formats/serializer/archi/relationship.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Archimate
+  module FileFormats
+    module Serializer
+      module Archi
+        module Relationship
+          def serialize_relationship(xml, rel)
+            xml.element(
+              remove_nil_values(
+                "xsi:type" => "archimate:#{rel.type}",
+                "id" => rel.id,
+                "name" => rel.name,
+                "source" => rel.source.id,
+                "target" => rel.target.id,
+                "accessType" => serialize_access_type(rel.access_type)
+              )
+            ) do
+              serialize_documentation(xml, rel.documentation)
+              serialize(xml, rel.properties)
+            end
+          end
+
+          def serialize_access_type(val)
+            case val
+            when nil
+              nil
+            else
+              DataModel::ACCESS_TYPE.index(val)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/archimate/file_formats/serializer/archi/view_node.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Archimate
+  module FileFormats
+    module Serializer
+      module Archi
+        module ViewNode
+          def serialize_view_node(xml, child)
+            style_hash = archi_style_hash(child.style)
+            fill_color = style_hash.delete("fillColor")
+            xml.child(
+              remove_nil_values(
+                {
+                  "xsi:type" => child.type,
+                  "id" => child.id,
+                  "name" => child.name
+                }.merge(
+                  style_hash.merge(
+                    "targetConnections" => child.target_connections.empty? ? nil : child.target_connections.join(" "),
+                    "fillColor" => fill_color,
+                    "model" => child.view_refs&.id,
+                    "archimateElement" => child.element&.id,
+                    "type" => child.child_type
+                  )
+                )
+              )
+            ) do
+              serialize_bounds(xml, child.bounds)
+              serialize(xml, child.connections)
+              xml.content { xml.text child.content } if child.content
+              serialize(xml, child.nodes)
+              serialize_documentation(xml, child.documentation)
+              serialize(xml, child.properties)
+            end
+          end
+
+          def archi_style_hash(style)
+            {
+              "fillColor" => style&.fill_color&.to_rgba,
+              "font" => style&.font&.to_archi_font,
+              "fontColor" => style&.font_color&.to_rgba,
+              "lineColor" => style&.line_color&.to_rgba,
+              "lineWidth" => style&.line_width&.to_s,
+              "textAlignment" => style&.text_alignment&.to_s,
+              "textPosition" => style&.text_position
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/archimate/file_formats/serializer/archi/viewpoint_type.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+require "ruby-enum"
+
+module Archimate
+  module FileFormats
+    module Serializer
+      module Archi
+        class ViewpointType
+          include Ruby::Enum
+
+          define :None, ""
+          define :Actor_cooperation, "Actor Co-operation"
+          define :Application_behavior, "Application Behavior"
+          define :Application_cooperation, "Application Co-operation"
+          define :Application_structure, "Application Structure"
+          define :Application_usage, "Application Usage"
+          define :Business_function, "Business Function"
+          define :Business_process_cooperation, "Business Process Co-operation"
+          define :Business_process, "Business Process"
+          define :Product, "Product"
+          define :Implementation_and_deployment, "Implementation and Deployment"
+          define :Information_structure, "Information Structure"
+          define :Infrastructure_usage, "Infrastructure Usage"
+          define :Infrastructure, "Infrastructure"
+          define :Layered, "Layered"
+          define :Organization, "Organization"
+          define :Service_realization, "Service Realization"
+          define :Stakeholder, "Stakeholder"
+          define :Goal_realization, "Goal Realization"
+          define :Goal_contribution, "Goal Contribution"
+          define :Principles, "Principles"
+          define :Requirements_realization, "Requirements Realization"
+          define :Motivation, "Motivation"
+          define :Project, "Project"
+          define :Migration, "Migration"
+          define :Implementation_and_migration, "Implementation and Migration"
+
+          def self.[](idx)
+            values[idx]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/archimate/file_formats/serializer/model_exchange_file/element.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Archimate
+  module FileFormats
+    module Serializer
+      module ModelExchangeFile
+        module Element
+          def serialize_element(xml, element)
+            return if element.type == "SketchModel" # TODO: print a warning that data is lost
+            xml.element(identifier: identifier(element.id),
+                        "xsi:type" => meff_type(element.type)) do
+              elementbase(xml, element)
+            end
+          end
+
+          def elementbase(xml, element)
+            serialize_label(xml, element.name)
+            serialize(xml, element.documentation)
+            serialize_properties(xml, element)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/archimate/file_formats/serializer/model_exchange_file/location.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Archimate
+  module FileFormats
+    module Serializer
+      module ModelExchangeFile
+        module Location
+          def serialize_location(xml, location)
+            xml.bendpoint(x: location.x.round, y: location.y.round)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/archimate/file_formats/serializer/model_exchange_file/model_exchange_file_writer.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+require "nokogiri"
+
+module Archimate
+  module FileFormats
+    module Serializer
+      module ModelExchangeFile
+        class ModelExchangeFileWriter < Writer
+          attr_reader :model
+
+          def initialize(model)
+            super
+          end
+
+          def write(output_io)
+            builder = Nokogiri::XML::Builder.new(encoding: 'UTF-8') do |xml|
+              serialize_model(xml, model)
+            end
+            output_io.write(builder.to_xml)
+          end
+
+          # TODO: Archi uses hex numbers for ids which may not be valid for
+          # identifer. If we are converting from Archi, decorate the IDs here.
+          def identifier(str)
+            return "id-#{str}" if str =~ /^\d/
+            str
+          end
+        end
+      end
+    end
+  end
+end

data/lib/archimate/file_formats/serializer/model_exchange_file/organization.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Archimate
+  module FileFormats
+    module Serializer
+      module ModelExchangeFile
+        module Organization
+          def serialize_organization(xml, organization)
+            if organization.items.empty? &&
+              (!organization.documentation || organization.documentation.empty?) &&
+              organization.organizations.empty?
+              return
+            end
+            item_attrs = organization.id.nil? || organization.id.empty? ? {} : {identifier: organization.id}
+            xml.item(item_attrs) do
+              serialize_organization_body(xml, organization)
+            end
+          end
+        end
+      end
+    end
+  end
+end