archimate 1.1.0

data/lib/archimate/file_formats/archi_file_reader.rb

@@ -0,0 +1,252 @@
+# frozen_string_literal: true
+require "nokogiri"
+
+module Archimate
+  module FileFormats
+    class ArchiFileReader
+      def initialize
+        @progress = nil
+        @random ||= Random.new
+      end
+
+      def parse(doc)
+        @size = 0
+        doc.traverse { |_n| @size += 1 }
+        @progress = ProgressIndicator.new(total: @size, title: "Parsing")
+        @property_defs = {}
+        tick
+        diagrams = parse_diagrams(doc.root)
+        DataModel::Model.new(
+          id: doc.root["id"],
+          name: doc.root["name"],
+          documentation: parse_documentation(doc.root, "purpose"),
+          properties: parse_properties(doc.root),
+          elements: parse_elements(doc.root),
+          organizations: parse_organizations(doc.root),
+          relationships: parse_relationships(doc.root),
+          diagrams: diagrams,
+          viewpoints: [],
+          property_definitions: @property_defs.values,
+          namespaces: {},
+          schema_locations: []
+        )
+      ensure
+        @progress&.finish
+        @progress = nil
+      end
+
+      def parse_documentation(node, element_name = "documentation")
+        node.css(">#{element_name}").each_with_object([]) do |i, a|
+          tick
+          a << DataModel::Documentation.new(text: i.content)
+        end
+      end
+
+      def parse_properties(node)
+        node.css(">property").each_with_object([]) do |i, a|
+          tick
+          key = i["key"]
+          next unless key
+          if @property_defs.key?(key)
+            prop_def = @property_defs[key]
+          else
+            @property_defs[key] = prop_def = DataModel::PropertyDefinition.new(
+              id: DataModel::PropertyDefinition.identifier_for_key(key),
+              name: key,
+              documentation: [],
+              value_type: "string"
+            )
+          end
+          a << DataModel::Property.new(
+            values: [
+              DataModel::LangString.new(text: i["value"] || "en")
+            ],
+            property_definition: prop_def
+          )
+        end
+      end
+
+      def parse_elements(model)
+        model.css(ArchiFileFormat::FOLDER_XPATHS.join(",")).css('element[id]').map do |i|
+          tick
+          DataModel::Element.new(
+            id: i["id"],
+            name: i["name"],
+            organization_id: i.parent["id"],
+            type: i["xsi:type"].sub("archimate:", ""),
+            documentation: parse_documentation(i),
+            properties: parse_properties(i)
+          )
+        end
+      end
+
+      def parse_organizations(node)
+        node.css("> folder").each_with_object([]) do |i, a|
+          tick
+          a << DataModel::Organization.new(
+            id: i.attr("id"),
+            name: i.attr("name"),
+            type: i.attr("type"),
+            documentation: parse_documentation(i),
+            properties: parse_properties(i),
+            items: child_element_ids(i),
+            organizations: parse_organizations(i)
+          )
+        end
+      end
+
+      def child_element_ids(node)
+        node.css(">element[id]").each_with_object([]) do |i, a|
+          tick
+          a << i.attr("id")
+        end
+      end
+
+      def parse_relationships(model)
+        model.css(ArchiFileFormat::RELATION_XPATHS.join(",")).css("element").map do |i|
+          tick
+          DataModel::Relationship.new(
+            id: i["id"],
+            type: i.attr("xsi:type").sub("archimate:", ""),
+            source: i.attr("source"),
+            target: i.attr("target"),
+            name: i["name"],
+            access_type: parse_access_type(i["accessType"]),
+            documentation: parse_documentation(i),
+            properties: parse_properties(i)
+          )
+        end
+      end
+
+      def parse_access_type(val)
+        return nil unless val && val.size > 0
+        i = val.to_i
+        return nil unless i >= 0 && i < DataModel::AccessType.size
+        DataModel::AccessType[i]
+      end
+
+      def parse_diagrams(model)
+        model.css(ArchiFileFormat::DIAGRAM_XPATHS.join(",")).css(
+          'element[xsi|type="archimate:ArchimateDiagramModel"]',
+          'element[xsi|type="archimate:SketchModel"]'
+        ).map do |i|
+          tick
+          viewpoint_idx = i["viewpoint"]
+          viewpoint_idx = viewpoint_idx.to_i unless viewpoint_idx.nil?
+          viewpoint_type = viewpoint_idx.nil? ? nil : ArchiFileFormat::VIEWPOINTS[viewpoint_idx]
+          DataModel::Diagram.new(
+            id: i["id"],
+            name: i["name"],
+            viewpoint_type: viewpoint_type,
+            viewpoint: nil,
+            documentation: parse_documentation(i),
+            properties: parse_properties(i),
+            nodes: parse_nodes(i),
+            connections: parse_all_connections(i),
+            connection_router_type: i["connectionRouterType"],
+            type: i.attr("xsi:type"),
+            background: i.attr("background"),
+            organization_id: nil
+          )
+        end
+      end
+
+      def parse_nodes(node)
+        node.css("> child").each_with_object([]) do |child_node, a|
+          tick
+          a << DataModel::ViewNode.new(
+            id: child_node.attr("id"),
+            type: child_node.attr("xsi:type"),
+            model: child_node.attr("model"),
+            name: child_node.attr("name"),
+            target_connections: parse_target_connections(child_node.attr("targetConnections")),
+            archimate_element: child_node.attr("archimateElement"),
+            bounds: parse_bounds(child_node),
+            nodes: parse_nodes(child_node),
+            connections: parse_connections(child_node),
+            documentation: parse_documentation(child_node),
+            properties: parse_properties(child_node),
+            style: parse_style(child_node),
+            content: child_node.at_css("> content")&.text,
+            child_type: child_node.attr("type")
+          )
+        end
+      end
+
+      def parse_target_connections(str)
+        return [] if str.nil?
+        str.split(" ")
+      end
+
+      def parse_style(style)
+        tick
+        DataModel::Style.new(
+          text_alignment: style["textAlignment"],
+          fill_color: DataModel::Color.rgba(style["fillColor"]),
+          line_color: DataModel::Color.rgba(style["lineColor"]),
+          font_color: DataModel::Color.rgba(style["fontColor"]),
+          font: DataModel::Font.archi_font_string(style["font"]),
+          line_width: style["lineWidth"],
+          text_position: style["textPosition"]
+        )
+      end
+
+      def parse_bounds(node)
+        bounds = node.at_css("> bounds")
+        tick
+        unless bounds.nil?
+          DataModel::Bounds.new(
+            x: bounds.attr("x"),
+            y: bounds.attr("y"),
+            width: bounds.attr("width"),
+            height: bounds.attr("height")
+          )
+        end
+      end
+
+      def parse_all_connections(node)
+        node.css("sourceConnection").each_with_object([]) do |i, a|
+          tick
+          a << parse_connection(i)
+        end
+      end
+
+      def parse_connections(node)
+        node.css("> sourceConnection").each_with_object([]) { |i, a| a << parse_connection(i) }
+      end
+
+      def parse_connection(i)
+        DataModel::Connection.new(
+          id: i["id"],
+          type: i.attr("xsi:type"),
+          source: i["source"],
+          target: i["target"],
+          relationship: i["relationship"] || i["archimateRelationship"],
+          name: i["name"],
+          style: parse_style(i),
+          bendpoints: parse_bendpoints(i),
+          documentation: parse_documentation(i),
+          properties: parse_properties(i)
+          )
+      end
+
+      # 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 parse_bendpoints(node)
+        node.css("bendpoint").each_with_object([]) do |i, a|
+          tick
+          a << DataModel::Location.new(
+            x: i.attr("startX") || 0, y: i.attr("startY") || 0,
+            end_x: i.attr("endX"), end_y: i.attr("endY")
+          )
+        end
+      end
+
+      def tick
+        @progress&.increment
+      end
+    end
+  end
+end

data/lib/archimate/file_formats/archi_file_writer.rb

@@ -0,0 +1,230 @@
+# frozen_string_literal: true
+require "nokogiri"
+
+module Archimate
+  module FileFormats
+    class ArchiFileWriter < Writer
+      using DataModel::DiffableArray
+      using DataModel::DiffablePrimitive
+
+      TEXT_SUBSTITUTIONS = [
+        ['&#13;', '&#xD;'],
+        ['"', '&quot;'],
+        ['&gt;', '>']
+      ].freeze
+
+      def initialize(model)
+        super
+        @version = "3.1.1"
+      end
+
+      def process_text(doc_str)
+        %w(documentation content).each do |tag|
+          TEXT_SUBSTITUTIONS.each do |from, to|
+            doc_str.gsub!(%r{<#{tag}>([^<]*#{from}[^<]*)</#{tag}>}) do |str|
+              str.gsub(from, to)
+            end
+          end
+        end
+        doc_str.gsub(
+          %r{<(/)?archimate:}, "<\\1"
+        ).gsub(
+          %r{<(/)?model}, "<\\1archimate:model"
+        )
+      end
+
+      def write(archifile_io)
+        builder = Nokogiri::XML::Builder.new(encoding: 'UTF-8') do |xml|
+          serialize_model(xml)
+        end
+        archifile_io.write(
+          process_text(
+            builder.to_xml
+          )
+        )
+      end
+
+      def serialize_model(xml)
+        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)
+          model.documentation.each { |d| serialize_documentation(xml, d, "purpose") }
+        end
+      end
+
+      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(xml, organization.documentation)
+          organization.items.each { |i| serialize_item(xml, i) }
+        end
+      end
+
+      def serialize_property(xml, property)
+        xml.property(remove_nil_values(key: property.key, value: property.value))
+      end
+
+      def serialize_documentation(xml, documentation, element_name = "documentation")
+        xml.send(element_name) { xml.text(documentation.text) }
+      end
+
+      def serialize_item(xml, item)
+        item_instance = model.lookup(item)
+        $stderr.puts "serialize_item item `#{item.inspect}` could not found." if item_instance.nil?
+        serialize(xml, item_instance)
+      end
+
+      def serialize_element(xml, element)
+        xml.element(
+          remove_nil_values(
+            "xsi:type" => "archimate:#{element.type}",
+            "id" => element.id,
+            "name" => element.name
+          )
+        ) do
+          serialize(xml, element.documentation)
+          serialize(xml, element.properties)
+        end
+      end
+
+      def serialize_relationship(xml, rel)
+        xml.element(
+          remove_nil_values(
+            "xsi:type" => "archimate:#{rel.type}",
+            "id" => rel.id,
+            "name" => rel.name,
+            "source" => rel.source,
+            "target" => rel.target,
+            "accessType" => serialize_access_type(rel.access_type)
+          )
+        ) do
+          serialize(xml, rel.documentation)
+          serialize(xml, rel.properties)
+        end
+      end
+
+      def serialize_access_type(val)
+        case val
+        when nil
+          nil
+        else
+          DataModel::AccessType.index(val)
+        end
+      end
+
+      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" => ArchiFileFormat::VIEWPOINTS.index(diagram.viewpoint_type)&.to_s,
+            "background" => diagram.background
+          )
+        ) do
+          serialize(xml, diagram.nodes)
+          serialize(xml, diagram.documentation)
+          serialize(xml, diagram.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
+
+      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.model,
+                "archimateElement" => child.archimate_element,
+                "type" => child.child_type
+              )
+            )
+          )
+        ) do
+          serialize(xml, child.bounds) unless child.bounds.nil?
+          serialize(xml, child.connections)
+          xml.content { xml.text child.content } unless child.content.nil?
+          serialize(xml, child.nodes)
+          serialize(xml, child.documentation)
+          serialize(xml, child.properties)
+        end
+      end
+
+      def serialize_bounds(xml, 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
+
+      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,
+                "target" => connection.target,
+                "relationship" => connection.relationship
+              )
+            )
+          )
+        ) do
+          serialize(xml, connection.bendpoints)
+          serialize(xml, connection.documentation)
+          serialize(xml, connection.properties)
+        end
+      end
+
+      # 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