archimate 1.1.0

data/lib/archimate/file_formats/model_exchange_file_reader.rb

@@ -0,0 +1,237 @@
+# frozen_string_literal: true
+require "nokogiri"
+
+module Archimate
+  module FileFormats
+    # This class implements common methods for the ArchiMate Model Exchange Format
+    class ModelExchangeFileReader
+      # Parses a Nokogiri document into an Archimate::Model
+      def parse(doc)
+        return unless doc
+        @property_defs = []
+        @viewpoints = []
+        parse_model(doc.root)
+      end
+
+      def parse_model(root)
+        @property_defs = parse_property_defs(root)
+        @viewpoints = parse_viewpoints(root)
+        DataModel::Model.new(
+          index_hash: {},
+          id: identifier_to_id(root["identifier"]),
+          name: ModelExchangeFile::XmlLangString.parse(root.at_css(">name")),
+          version: root["version"],
+          metadata: ModelExchangeFile::XmlMetadata.parse(root.at_css(">metadata")),
+          documentation: parse_documentation(root),
+          properties: parse_properties(root),
+          elements: parse_elements(root),
+          relationships: parse_relationships(root),
+          organizations: parse_organizations(root.css(organizations_root_selector)),
+          diagrams: parse_diagrams(root),
+          viewpoints: @viewpoints,
+          property_definitions: @property_defs,
+          schema_locations: root.attr("xsi:schemaLocation").split(" "),
+          namespaces: root.namespaces,
+          archimate_version: parse_archimate_version(root)
+        )
+      end
+
+      def parse_viewpoints(_node)
+        return []
+      end
+
+      def parse_documentation(node, element_name = "documentation")
+        node.css(">#{element_name}").map do |doc|
+          DataModel::Documentation.new(text: doc.content, lang: doc["xml:lang"])
+        end
+      end
+
+      def parse_properties(node)
+        node.css("> properties > property").map do |i|
+          parse_property(i)
+        end
+      end
+
+      def parse_property(node)
+        property_def = @property_defs.find { |prop_def| prop_def.id == node.attr(property_def_attr_name) }
+        DataModel::Property.new(
+          property_definition: property_def,
+          values: [ModelExchangeFile::XmlLangString.parse(node.at_css("value"))].compact
+        )
+      end
+
+      def parse_property_defs(node)
+        @property_defs = node.css(property_defs_selector).map do |i|
+          DataModel::PropertyDefinition.new(
+            id: i["identifier"],
+            name: property_def_name(i),
+            documentation: parse_documentation(i),
+            value_type: i["type"]
+          )
+        end
+      end
+
+      def parse_elements(model)
+        model.css(">elements>element").map do |i|
+          DataModel::Element.new(
+            id: identifier_to_id(i["identifier"]),
+            name: parse_element_name(i),
+            type: i["xsi:type"],
+            documentation: parse_documentation(i),
+            properties: parse_properties(i)
+          )
+        end
+      end
+
+      def parse_organizations(nodes)
+        nodes.map do |i|
+          child_items = i.css(">item")
+          ref_items = child_items.select { |ci| ci.has_attribute?(identifier_ref_name) }
+          DataModel::Organization.new(
+            id: i["identifier"], # TODO: model exchange doesn't assign ids to organization items
+            name: ModelExchangeFile::XmlLangString.parse(i.at_css(">label")),
+            documentation: parse_documentation(i),
+            items: ref_items.map { |ri| identifier_to_id(ri[identifier_ref_name]) },
+            organizations: parse_organizations(child_items.reject { |ci| ci.has_attribute?(identifier_ref_name) })
+          )
+        end
+      end
+
+      def parse_relationships(model)
+        model.css(">relationships>relationship").map do |i|
+          DataModel::Relationship.new(
+            id: identifier_to_id(i["identifier"]),
+            type: i.attr("xsi:type"),
+            source: identifier_to_id(i.attr("source")),
+            target: identifier_to_id(i.attr("target")),
+            name: parse_element_name(i),
+            access_type: i["accessType"],
+            documentation: parse_documentation(i),
+            properties: parse_properties(i)
+          )
+        end
+      end
+
+      def parse_diagrams(model)
+        model.css(diagrams_path).map do |i|
+          nodes = parse_nodes(i)
+          connections = parse_connections(i)
+          child_id_hash = nodes.each_with_object({}) { |i2, a| a.merge!(i2.child_id_hash) }
+          connections.each do |c|
+            child_id_hash[c.source].connections << c
+          end
+          DataModel::Diagram.new(
+            id: identifier_to_id(i["identifier"]),
+            name: parse_element_name(i),
+            viewpoint_type: i["viewpoint"],
+            viewpoint: nil, # TODO: support this for ArchiMate v3
+            documentation: parse_documentation(i),
+            properties: parse_properties(i),
+            nodes: nodes,
+            connections: connections,
+            connection_router_type: i["connectionRouterType"],
+            type: i.attr("xsi:type"),
+            background: i.attr("background")
+          )
+        end
+      end
+
+      def parse_nodes(node)
+        node.css("> node").map do |i|
+          DataModel::ViewNode.new(
+            id: identifier_to_id(i["identifier"]),
+            type: i.attr(view_node_type_attr),
+            model: nil,
+            name: ModelExchangeFile::XmlLangString.parse(i.at_css(">label")),
+            target_connections: [], # TODO: needed? "targetConnections",
+            archimate_element: identifier_to_id(i[view_node_element_ref]),
+            bounds: parse_bounds(i),
+            nodes: parse_nodes(i),
+            connections: parse_connections(i),
+            documentation: parse_documentation(i),
+            properties: parse_properties(i),
+            style: parse_style(i),
+            content: i.at_css("> content")&.text,
+            child_type: nil
+          )
+        end
+      end
+
+      def parse_style(node)
+        style = node.at_css(">style")
+        return nil unless style
+        DataModel::Style.new(
+          text_alignment: style["textAlignment"],
+          fill_color: parse_color(style, "fillColor"),
+          line_color: parse_color(style, "lineColor"),
+          font_color: parse_color(style.at_css(">font"), "color"),
+          font: parse_font(style),
+          line_width: style["lineWidth"],
+          text_position: style.at_css("textPosition")
+        )
+      end
+
+      def parse_font(node)
+        font_node = node.at_css(">font")
+        return unless font_node && font_node["name"] && font_node["size"]
+        DataModel::Font.new(
+          name: font_node["name"],
+          size: font_node["size"],
+          style: style_to_int(font_node["style"]),
+          font_data: nil
+        )
+      end
+
+      def parse_color(node, el_name)
+        return unless node
+        color_node = node.at_css(el_name)
+        return unless color_node
+        DataModel::Color.new(
+          r: color_node["r"]&.to_i,
+          g: color_node["g"]&.to_i,
+          b: color_node["b"]&.to_i,
+          a: color_node["a"]&.to_i
+        )
+      end
+
+      def parse_bounds(node)
+        DataModel::Bounds.new(
+          x: node.attr("x"),
+          y: node.attr("y"),
+          width: node.attr("w"),
+          height: node.attr("h")
+        )
+      end
+
+      def parse_connections(node)
+        node.css("> connection").map do |i|
+          DataModel::Connection.new(
+            id: identifier_to_id(i["identifier"]),
+            type: i.attr(view_node_type_attr),
+            source: identifier_to_id(i["source"]),
+            target: identifier_to_id(i["target"]),
+            relationship: identifier_to_id(i[connection_relationship_ref]),
+            name: i.at_css("label")&.content,
+            style: parse_style(i),
+            bendpoints: parse_bendpoints(i),
+            documentation: parse_documentation(i),
+            properties: parse_properties(i)
+          )
+        end
+      end
+
+      def parse_bendpoints(node)
+        node.css("bendpoint").map do |i|
+          DataModel::Location.new(
+            x: i.attr("x"), y: i.attr("y")
+          )
+        end
+      end
+
+      def identifier_to_id(str)
+        # str&.sub(/^id-/, "")
+        str
+      end
+    end
+  end
+end

data/lib/archimate/file_formats/model_exchange_file_reader_21.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+require "nokogiri"
+
+module Archimate
+  module FileFormats
+    # This class implements a file reader for ArchiMate 2.1 Model Exchange Format
+    class ModelExchangeFileReader21 < ModelExchangeFileReader
+      def parse_archimate_version(root)
+        case root.namespace.href
+        when "http://www.opengroup.org/xsd/archimate"
+          :archimate_2_1
+        else
+          raise "Unexpected namespace: #{root.namespace.href}"
+        end
+      end
+
+      def organizations_root_selector
+        ">organization>item"
+      end
+
+      def property_defs_selector
+        ">propertydefs>propertydef"
+      end
+
+      def property_def_attr_name
+        "identifierref"
+      end
+
+      def property_def_name(node)
+        node["name"]
+      end
+
+      def parse_element_name(el)
+        ModelExchangeFile::XmlLangString.parse(el.at_css(">label"))
+      end
+
+      def identifier_ref_name
+        "identifierref"
+      end
+
+      def diagrams_path
+        ">views>view"
+      end
+
+      def view_node_element_ref
+        "elementref"
+      end
+
+      def view_node_type_attr
+        "type"
+      end
+
+      def connection_relationship_ref
+        "relationshipref"
+      end
+
+      def style_to_int(str)
+        case str
+        when nil
+          0
+        when "italic"
+          1
+        when "bold"
+          2
+        when "bold|italic"
+          3
+        else
+          raise "Broken for value: #{str}"
+        end
+      end
+    end
+  end
+end

data/lib/archimate/file_formats/model_exchange_file_reader_30.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+require "nokogiri"
+
+module Archimate
+  module FileFormats
+    class ModelExchangeFileReader30 < ModelExchangeFileReader
+      def parse_archimate_version(root)
+        case root.namespace.href
+        when "http://www.opengroup.org/xsd/archimate/3.0/"
+          :archimate_3_0
+        else
+          raise "Unexpected namespace version: #{root.namespace.href}"
+        end
+      end
+
+      def organizations_root_selector
+        ">organizations"
+      end
+
+      def property_defs_selector
+          ">propertyDefinitions>propertyDefinition"
+      end
+
+      def property_def_attr_name
+        "propertyDefinitionRef"
+      end
+
+      def property_def_name(node)
+        ModelExchangeFile::XmlLangString.parse(node.at_css("name"))
+      end
+
+      def parse_element_name(el)
+        ModelExchangeFile::XmlLangString.parse(el.at_css(">name"))
+      end
+
+      def identifier_ref_name
+        "identifierRef"
+      end
+
+      def diagrams_path
+        ">views>diagrams>view"
+      end
+
+      def view_node_element_ref
+        "elementRef"
+      end
+
+      def view_node_type_attr
+        "xsi:type"
+      end
+
+      def connection_relationship_ref
+        "relationshipRef"
+      end
+
+      def style_to_int(str)
+        case str
+        when nil
+          0
+        when "italic"
+          1
+        when "bold"
+          2
+        when "bold italic"
+          3
+        else
+          raise "Broken for value: #{str}"
+        end
+      end
+
+      # <xs:simpleType name="ViewpointPurposeEnum">
+      #     <xs:restriction base="xs:NMTOKEN">
+      #         <xs:enumeration value="Designing" />
+      #         <xs:enumeration value="Deciding" />
+      #         <xs:enumeration value="Informing" />
+      #     </xs:restriction>
+      # </xs:simpleType>
+
+      # <xs:simpleType name="ViewpointPurposeType">
+      #     <xs:list itemType="ViewpointPurposeEnum" />
+      # </xs:simpleType>
+
+      # <xs:simpleType name="ViewpointContentEnum">
+      #     <xs:restriction base="xs:NMTOKEN">
+      #         <xs:enumeration value="Details" />
+      #         <xs:enumeration value="Coherence" />
+      #         <xs:enumeration value="Overview" />
+      #     </xs:restriction>
+      # </xs:simpleType>
+
+      # <xs:simpleType name="ViewpointContentType">
+      #     <xs:list itemType="ViewpointContentEnum" />
+      # </xs:simpleType>
+
+      # <xs:complexType name="ViewpointType">
+      #     <xs:complexContent>
+      #         <xs:extension base="NamedReferenceableType">
+      #             <xs:sequence>
+      #                 <xs:group ref="PropertiesGroup" />
+      #                 <xs:element name="concern" type="ConcernType" minOccurs="0" maxOccurs="unbounded" />
+      #                 <xs:element name="viewpointPurpose" type="ViewpointPurposeType" minOccurs="0" maxOccurs="1" />
+      #                 <xs:element name="viewpointContent" type="ViewpointContentType" minOccurs="0" maxOccurs="1" />
+      #                 <xs:element name="allowedElementType" type="AllowedElementTypeType" minOccurs="0" maxOccurs="unbounded" />
+      #                 <xs:element name="allowedRelationshipType" type="AllowedRelationshipTypeType" minOccurs="0" maxOccurs="unbounded" />
+      #                 <xs:element name="modelingNote" type="ModelingNoteType" minOccurs="0" maxOccurs="unbounded" />
+      #             </xs:sequence>
+      #         </xs:extension>
+      #     </xs:complexContent>
+      # </xs:complexType>
+      def parse_viewpoints(model)
+        []
+        # model.css("views > viewpoints").map do |i|
+          # attribute :concern, ConcernList
+          # attribute :viewpointPurpose, ViewpointPurpose.optional
+          # attribute :viewpointContent, ViewpointContent.optional
+          # attribute :allowedElementTypes, AllowedElementTypes
+          # attribute :allowedRelationshipTypes, AllowedRelationshipTypes
+          # attribute :modelingNotes, Strict::Array.member(ModelingNote).default([])
+          # DataModel::Viewpoint.new(
+            #     id: identifier_to_id(i["identifier"]),
+            #     name: parse_element_name(i),
+            #     documentation: parse_documentation(i),
+            #     properties: parse_properties(i),
+            #     nodes: nodes,
+            #     connections: connections,
+            #     connection_router_type: i["connectionRouterType"],
+            #     type: i.attr("xsi:type"),
+            #     background: i.attr("background")
+          # )
+        # end
+      end
+    end
+  end
+end

data/lib/archimate/file_formats/model_exchange_file_writer.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+require "nokogiri"
+
+module Archimate
+  module FileFormats
+    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)
+        end
+        output_io.write(builder.to_xml)
+      end
+
+      def serialize_elements(xml)
+        xml.elements { serialize(xml, model.elements) } unless model.elements.empty?
+      end
+
+      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
+
+      def serialize_label(xml, str)
+        return if str.nil? || str.strip.empty?
+        name_attrs = str.lang && !str.lang.empty? ? {"xml:lang" => str.lang} : {}
+        xml.label(name_attrs) { xml.text text_proc(str) }
+      end
+
+      def serialize_relationships(xml)
+        return if model.relationships.empty?
+        xml.relationships { serialize(xml, model.relationships) }
+      end
+
+      def relationship_attributes(relationship)
+        {
+          identifier: identifier(relationship.id),
+          source: identifier(relationship.source),
+          target: identifier(relationship.target),
+          "xsi:type" => meff_type(relationship.type)
+        }
+      end
+
+      def serialize_relationship(xml, relationship)
+        xml.relationship(
+          relationship_attributes(relationship)
+        ) do
+          elementbase(xml, relationship)
+        end
+      end
+
+      def serialize_organization_root(xml, organizations)
+        return unless organizations && organizations.size > 0
+        xml.organization do
+          serialize(xml, organizations)
+        end
+      end
+
+      def serialize_organization(xml, organization)
+        return if organization.items.empty? && organization.documentation.empty? && organization.organizations.empty?
+        item_attrs = organization.id.nil? || organization.id.empty? ? {} : {identifier: organization.id}
+        xml.item(item_attrs) do
+          serialize_organization_body(xml, organization)
+        end
+      end
+
+      def serialize_organization_body(xml, organization)
+        return if organization.items.empty? && organization.documentation.empty? && organization.organizations.empty?
+        str = organization.name
+        label_attrs = organization.name&.lang && !organization.name.lang.empty? ? {"xml:lang" => organization.name.lang} : {}
+        xml.label(label_attrs) { xml.text text_proc(str) } unless str.nil? || str.strip.empty?
+        serialize(xml, organization.documentation)
+        serialize(xml, organization.organizations)
+        organization.items.each { |i| serialize_item(xml, i) }
+      end
+
+      def serialize_properties(xml, element)
+        return if element.properties.empty?
+        xml.properties do
+          serialize(xml, element.properties)
+        end
+      end
+
+      def serialize_style(xml, style)
+        return unless style
+        xml.style(
+          remove_nil_values(
+            lineWidth: style.line_width
+          )
+        ) do
+          serialize_color(xml, style.fill_color, :fillColor)
+          serialize_color(xml, style.line_color, :lineColor)
+          serialize_font(xml, style)
+          # TODO: complete this
+        end
+      end
+
+      def serialize_font(xml, style)
+        return unless style && (style.font || style.font_color)
+        xml.font(
+          remove_nil_values(
+            name: style.font&.name,
+            size: style.font&.size&.round,
+            style: font_style_string(style.font)
+          )
+        ) { serialize_color(xml, style&.font_color, :color) }
+      end
+
+      def serialize_color(xml, color, sym)
+        return if color.nil?
+        h = {
+          r: color.r,
+          g: color.g,
+          b: color.b,
+          a: color.a
+        }
+        h.delete(:a) if color.a.nil? || color.a == 100
+        xml.send(sym, h)
+      end
+
+      def serialize_location(xml, location)
+        xml.bendpoint(x: location.x.round, y: location.y.round)
+      end
+
+      # # Processes text for text elements
+      def text_proc(str)
+        str.strip.tr("\r", "\n")
+      end
+
+      # TODO: this should replace namespaces as appropriate for the desired export version
+      def model_namespaces
+        model.namespaces
+      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