archimate 1.2.1 → 2.0.0

data/lib/archimate/file_formats/archi_file_writer.rb

@@ -3,14 +3,24 @@ require "nokogiri"
 
 module Archimate
   module FileFormats
-    class ArchiFileWriter < Writer
-      using DataModel::DiffableArray
-      using DataModel::DiffablePrimitive
+    class ArchiFileWriter < Serializer::Writer
+      include Serializer::Archi::Bounds
+      include Serializer::Archi::Connection
+      include Serializer::Archi::Diagram
+      include Serializer::Archi::Documentation
+      include Serializer::Archi::Element
+      include Serializer::Archi::Location
+      include Serializer::Archi::Model
+      include Serializer::Archi::Organization
+      include Serializer::Archi::Property
+      include Serializer::Archi::Relationship
+      include Serializer::Archi::ViewNode
 
       TEXT_SUBSTITUTIONS = [
         ['&#13;', '&#xD;'],
         ['"', '&quot;'],
-        ['&gt;', '>']
+        ['&gt;', '>'],
+        ['&#38;', '&amp;']
       ].freeze
 
       def initialize(model)
@@ -19,7 +29,7 @@ module Archimate
       end
 
       def process_text(doc_str)
-        %w(documentation content).each do |tag|
+        %w(documentation content name).each do |tag|
           TEXT_SUBSTITUTIONS.each do |from, to|
             doc_str.gsub!(%r{<#{tag}>([^<]*#{from}[^<]*)</#{tag}>}) do |str|
               str.gsub(from, to)
@@ -35,7 +45,7 @@ module Archimate
 
       def write(archifile_io)
         builder = Nokogiri::XML::Builder.new(encoding: 'UTF-8') do |xml|
-          serialize_model(xml)
+          serialize_model(xml, model)
         end
         archifile_io.write(
           process_text(
@@ -43,188 +53,6 @@ module Archimate
           )
         )
       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

data/lib/archimate/file_formats/model_exchange_file_reader.rb

@@ -3,234 +3,16 @@ 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)
+      def initialize(doc)
+        @string_or_io = doc
       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
+      def parse()
+        handler_factory = Sax::ModelExchangeFile::ModelExchangeHandlerFactory.new
+        parser = Nokogiri::XML::SAX::Parser.new(Sax::Document.new(handler_factory))
+        parser.parse(@string_or_io)
+        parser.document.model
       end
     end
   end