archimate 1.2.1 → 2.0.0

data/lib/archimate/file_formats/model_exchange_file_writer_21.rb

@@ -4,131 +4,39 @@ require "nokogiri"
 module Archimate
   module FileFormats
     # Archimate version 2.1 Model Exchange Format Writer
-    class ModelExchangeFileWriter21 < ModelExchangeFileWriter
+    class ModelExchangeFileWriter21 < Serializer::ModelExchangeFile::ModelExchangeFileWriter
+      include Serializer::ModelExchangeFile::V21::Connection
+      include Serializer::ModelExchangeFile::V21::Diagram
+      include Serializer::ModelExchangeFile::Element
+      include Serializer::ModelExchangeFile::V21::Item
+      include Serializer::ModelExchangeFile::V21::Label
+      include Serializer::ModelExchangeFile::Location
+      include Serializer::ModelExchangeFile::V21::Model
+      include Serializer::ModelExchangeFile::Organization
+      include Serializer::ModelExchangeFile::V21::OrganizationBody
+      include Serializer::ModelExchangeFile::V21::Property
+      include Serializer::ModelExchangeFile::Properties
+      include Serializer::ModelExchangeFile::Relationship
+      include Serializer::ModelExchangeFile::Style
+      include Serializer::ModelExchangeFile::V21::ViewNode
+
       def initialize(model)
         super
       end
 
-      def model_attrs
-        model_namespaces.merge(
-          "xsi:schemaLocation" => model.schema_locations.join(" "),
-          "identifier" => identifier(model.id)
-        )
-      end
-
-      def serialize_model(xml)
-        xml.model(model_attrs) do
-          ModelExchangeFile::XmlMetadata.new(model.metadata).serialize(xml)
-          ModelExchangeFile::XmlLangString.new(model.name, :name).serialize(xml)
-          ModelExchangeFile::XmlLangString.new(model.documentation, :documentation).serialize(xml)
-          serialize_properties(xml, model)
-          serialize_elements(xml)
-          serialize_relationships(xml)
-          serialize_organization_root(xml, model.organizations)
-          serialize_property_defs(xml)
-          serialize_views(xml)
-        end
-      end
-
-      def serialize_property_defs(xml)
-        return if model.property_definitions.empty?
-        ModelExchangeFile::XmlPropertyDefs.new(model.property_definitions).serialize(xml)
-      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_organization_root(xml, organizations)
-        return unless organizations && organizations.size > 0
-        xml.organization do
-          serialize(xml, organizations)
-        end
-      end
-
-      def serialize_item(xml, item)
-        xml.item(identifierref: identifier(item))
-      end
-
-      def serialize_property(xml, property)
-        xml.property(identifierref: property.property_definition.id) do
-          ModelExchangeFile::XmlLangString.new(property.value, :value).serialize(xml)
-        end
-      end
-
-      def serialize_views(xml)
-        return if model.diagrams.empty?
-        xml.views do
-          serialize(xml, model.diagrams)
-        end
-      end
-
-      def serialize_diagram(xml, diagram)
-        xml.view(
-          remove_nil_values(
-            identifier: identifier(diagram.id),
-            viewpoint: diagram.viewpoint_type,
-            "xsi:type": diagram.type
-          )
-        ) do
-          elementbase(xml, diagram)
-          serialize(xml, diagram.nodes)
-          serialize(xml, diagram.connections)
-        end
-      end
-
-      def view_node_attrs(view_node, x_offset = 0, y_offset = 0)
-        attrs = {
-          identifier: identifier(view_node.id),
-          elementref: nil,
-          x: view_node.bounds ? (view_node.bounds&.x + x_offset).round : nil,
-          y: view_node.bounds ? (view_node.bounds&.y + y_offset).round : nil,
-          w: view_node.bounds&.width&.round,
-          h: view_node.bounds&.height&.round,
-          type: nil
+      def relationship_attributes(relationship)
+        {
+          identifier: identifier(relationship.id),
+          source: identifier(relationship.source.id),
+          target: identifier(relationship.target.id),
+          "xsi:type" => meff_type(relationship.type)
         }
-        if view_node.archimate_element
-          attrs[:elementref] = identifier(view_node.archimate_element)
-        elsif view_node.model
-          # Since it doesn't seem to be forbidden, we just assume we can use
-          # the elementref for views in views
-          attrs[:elementref] = view_node.model
-          attrs[:type] = "model"
-        else
-          attrs[:type] = "group"
-        end
-        remove_nil_values(attrs)
-      end
-
-      def serialize_view_node(xml, view_node, x_offset = 0, y_offset = 0)
-        attrs = view_node_attrs(view_node, x_offset, y_offset)
-        xml.node(attrs) do
-          serialize_label(xml, view_node.name) if attrs[:type] == "group"
-          serialize(xml, view_node.style) if view_node.style
-          view_node.nodes.each do |c|
-            serialize_view_node(xml, c) # , attrs[:x].to_f, attrs[:y].to_f)
-          end
-        end
       end
 
       def font_style_string(font)
         font&.style_string
       end
 
-      def serialize_connection(xml, sc)
-        xml.connection(
-          identifier: identifier(sc.id),
-          relationshipref: identifier(sc.relationship),
-          source: identifier(sc.source),
-          target: identifier(sc.target)
-        ) do
-          serialize(xml, sc.bendpoints)
-          serialize(xml, sc.style)
-        end
-      end
-
       def meff_type(el_type)
         el_type = el_type.sub(/^/, "")
         case el_type

data/lib/archimate/file_formats/model_exchange_file_writer_30.rb

@@ -3,122 +3,35 @@ require "nokogiri"
 
 module Archimate
   module FileFormats
-    class ModelExchangeFileWriter30 < ModelExchangeFileWriter
+    class ModelExchangeFileWriter30 < Serializer::ModelExchangeFile::ModelExchangeFileWriter
+      include Serializer::ModelExchangeFile::V30::Connection
+      include Serializer::ModelExchangeFile::V30::Diagram
+      include Serializer::ModelExchangeFile::Element
+      include Serializer::ModelExchangeFile::V30::Item
+      include Serializer::ModelExchangeFile::V30::Label
+      include Serializer::ModelExchangeFile::Location
+      include Serializer::ModelExchangeFile::V30::Model
+      include Serializer::ModelExchangeFile::Organization
+      include Serializer::ModelExchangeFile::V30::OrganizationBody
+      include Serializer::ModelExchangeFile::V30::Property
+      include Serializer::ModelExchangeFile::Properties
+      include Serializer::ModelExchangeFile::Relationship
+      include Serializer::ModelExchangeFile::Style
+      include Serializer::ModelExchangeFile::V30::ViewNode
+
       def initialize(model)
         super
       end
 
-      def model_attrs
-        remove_nil_values(
-          model_namespaces.merge(
-            "xsi:schemaLocation" => model.schema_locations.join(" "),
-            "identifier" => identifier(model.id),
-            "version" => model.version
-          )
-        )
-      end
-
-      def serialize_model(xml)
-        xml.model(model_attrs) do
-          ModelExchangeFile::XmlLangString.new(model.name, :name).serialize(xml)
-          ModelExchangeFile::XmlLangString.new(model.documentation, :documentation).serialize(xml)
-          ModelExchangeFile::XmlMetadata.new(model.metadata).serialize(xml)
-          serialize_properties(xml, model)
-          serialize_elements(xml)
-          serialize_relationships(xml)
-          serialize_organization_root(xml, model.organizations)
-          serialize_property_defs(xml)
-          serialize_views(xml)
-        end
-      end
-
-      def serialize_property_defs(xml)
-        return if model.property_definitions.empty?
-        ModelExchangeFile::XmlPropertyDefinitions.new(model.property_definitions).serialize(xml)
-      end
-
-      def serialize_label(xml, str, tag = :name)
-        return if str.nil? || str.strip.empty?
-        name_attrs = str.lang && !str.lang.empty? ? {"xml:lang" => str.lang} : {}
-        xml.send(tag, name_attrs) { xml.text text_proc(str) }
-      end
-
       def relationship_attributes(relationship)
-        attrs = super
-        attrs["accessType"] = relationship.access_type if relationship.access_type
-        attrs
-      end
-
-      def serialize_organization_root(xml, organizations)
-        return unless organizations && organizations.size > 0
-        xml.organizations do
-          serialize_organization_body(xml, organizations[0])
-        end
-      end
-
-      def serialize_item(xml, item)
-        xml.item(identifierRef: identifier(item))
-      end
-
-      def serialize_property(xml, property)
-        xml.property("propertyDefinitionRef" => property.property_definition.id) do
-          ModelExchangeFile::XmlLangString.new(property.value, :value).serialize(xml)
-        end
-      end
-
-      def serialize_views(xml)
-        return if model.diagrams.empty?
-        xml.views do
-          xml.diagrams {
-            serialize(xml, model.diagrams)
-          }
-        end
-      end
-
-      def serialize_diagram(xml, diagram)
-        xml.view(
-          remove_nil_values(
-            identifier: identifier(diagram.id),
-            "xsi:type": diagram.type,
-            viewpoint: diagram.viewpoint_type
-          )
-        ) do
-          elementbase(xml, diagram)
-          serialize(xml, diagram.nodes)
-          serialize(xml, diagram.connections)
-        end
-      end
-
-      def view_node_attrs(view_node, x_offset = 0, y_offset = 0)
         attrs = {
-          identifier: identifier(view_node.id),
-          elementRef: nil,
-          "xsi:type" => view_node.type,
-          "x" => view_node.bounds ? (view_node.bounds&.x + x_offset).round : nil,
-          "y" => view_node.bounds ? (view_node.bounds&.y + y_offset).round : nil,
-          "w" => view_node.bounds&.width&.round,
-          "h" => view_node.bounds&.height&.round
+          identifier: identifier(relationship.id),
+          source: identifier(relationship.source.id),
+          target: identifier(relationship.target.id),
+          "xsi:type" => meff_type(relationship.type)
         }
-        if view_node.archimate_element
-          attrs[:elementRef] = identifier(view_node.archimate_element)
-        elsif view_node.model
-          # Since it doesn't seem to be forbidden, we just assume we can use
-          # the elementref for views in views
-          attrs[:elementRef] = view_node.model
-          attrs[:type] = "model"
-        end
-        remove_nil_values(attrs)
-      end
-
-      def serialize_view_node(xml, view_node, x_offset = 0, y_offset = 0)
-        attrs = view_node_attrs(view_node, x_offset, y_offset)
-        xml.node(attrs) do
-          serialize_label(xml, view_node.name, :label)
-          serialize(xml, view_node.style) if view_node.style
-          view_node.nodes.each do |c|
-            serialize_view_node(xml, c) # , view_node_attrs[:x].to_f, view_node_attrs[:y].to_f)
-          end
-        end
+        attrs["accessType"] = relationship.access_type if relationship.access_type
+        attrs
       end
 
       def font_style_string(font)
@@ -132,19 +45,6 @@ module Archimate
         end
       end
 
-      def serialize_connection(xml, sc)
-        xml.connection(
-          identifier: identifier(sc.id),
-          relationshipRef: identifier(sc.relationship),
-          "xsi:type": sc.type,
-          source: identifier(sc.source),
-          target: identifier(sc.target)
-        ) do
-          serialize(xml, sc.style)
-          serialize(xml, sc.bendpoints)
-        end
-      end
-
       def meff_type(el_type)
         el_type.sub(/^/, "")
       end

data/lib/archimate/file_formats/sax.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+module Archimate
+  module FileFormats
+    module Sax
+      SaxEvent = Struct.new(:sym, :args, :source)
+      FutureReference = Struct.new(:obj, :attr, :id)
+
+      autoload :AnyElement, 'archimate/file_formats/sax/any_element'
+      autoload :CaptureContent, 'archimate/file_formats/sax/capture_content'
+      autoload :CaptureDocumentation, 'archimate/file_formats/sax/capture_documentation'
+      autoload :CaptureProperties, 'archimate/file_formats/sax/capture_properties'
+      autoload :ContentElement, 'archimate/file_formats/sax/content_element'
+      autoload :Document, 'archimate/file_formats/sax/document'
+      autoload :Handler, 'archimate/file_formats/sax/handler'
+      autoload :LangString, 'archimate/file_formats/sax/lang_string'
+      autoload :NoOp, 'archimate/file_formats/sax/no_op'
+      autoload :PreservedLangString, 'archimate/file_formats/sax/preserved_lang_string'
+      module Archi
+        autoload :ArchiHandlerFactory, 'archimate/file_formats/sax/archi/archi_handler_factory'
+        autoload :Bounds, 'archimate/file_formats/sax/archi/bounds'
+        autoload :Connection, 'archimate/file_formats/sax/archi/connection'
+        autoload :Content, 'archimate/file_formats/sax/archi/content'
+        autoload :Diagram, 'archimate/file_formats/sax/archi/diagram'
+        autoload :Element, 'archimate/file_formats/sax/archi/element'
+        autoload :Location, 'archimate/file_formats/sax/archi/location'
+        autoload :Model, 'archimate/file_formats/sax/archi/model'
+        autoload :Organization, 'archimate/file_formats/sax/archi/organization'
+        autoload :PreservedLangString, 'archimate/file_formats/sax/archi/preserved_lang_string'
+        autoload :Property, 'archimate/file_formats/sax/archi/property'
+        autoload :Relationship, 'archimate/file_formats/sax/archi/relationship'
+        autoload :Style, 'archimate/file_formats/sax/archi/style'
+        autoload :ViewNode, 'archimate/file_formats/sax/archi/view_node'
+      end
+      module ModelExchangeFile
+        autoload :Color, 'archimate/file_formats/sax/model_exchange_file/color'
+        autoload :Connection, 'archimate/file_formats/sax/model_exchange_file/connection'
+        autoload :Diagram, 'archimate/file_formats/sax/model_exchange_file/diagram'
+        autoload :Element, 'archimate/file_formats/sax/model_exchange_file/element'
+        autoload :Font, 'archimate/file_formats/sax/model_exchange_file/font'
+        autoload :Item, 'archimate/file_formats/sax/model_exchange_file/item'
+        autoload :Location, 'archimate/file_formats/sax/model_exchange_file/location'
+        autoload :Metadata, 'archimate/file_formats/sax/model_exchange_file/metadata'
+        autoload :ModelExchangeHandlerFactory, 'archimate/file_formats/sax/model_exchange_file/model_exchange_handler_factory'
+        autoload :Model, 'archimate/file_formats/sax/model_exchange_file/model'
+        autoload :Property, 'archimate/file_formats/sax/model_exchange_file/property'
+        autoload :PropertyDefinition, 'archimate/file_formats/sax/model_exchange_file/property_definition'
+        autoload :Relationship, 'archimate/file_formats/sax/model_exchange_file/relationship'
+        autoload :Schema, 'archimate/file_formats/sax/model_exchange_file/schema'
+        autoload :SchemaInfo, 'archimate/file_formats/sax/model_exchange_file/schema_info'
+        autoload :Style, 'archimate/file_formats/sax/model_exchange_file/style'
+        autoload :ViewNode, 'archimate/file_formats/sax/model_exchange_file/view_node'
+      end
+    end
+  end
+end

data/lib/archimate/file_formats/sax/any_element.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Archimate
+  module FileFormats
+    module Sax
+      class AnyElement < Handler
+        include Sax::CaptureContent
+
+        def initialize(name, attrs, parent_handler)
+          super
+          @children = []
+          @el_name = nil
+          @prefix = nil
+        end
+
+        def complete
+          [event(
+            :on_any_element,
+            DataModel::AnyElement.new(
+              element: el_name,
+              prefix: prefix,
+              attributes: any_attributes,
+              content: content,
+              children: @children
+            )
+          )]
+        end
+
+        def on_any_element(any_element, _source)
+          @children << any_element
+          false
+        end
+
+        private
+
+        def el_name
+          parse_name unless @el_name
+          @el_name
+        end
+
+        def prefix
+          parse_name unless @el_name
+          @prefix
+        end
+
+        def parse_name
+          name_parts = name.split(":")
+          @prefix = name_parts.size > 1 ? name_parts.first : nil
+          @el_name = name_parts.last
+        end
+
+        def any_attributes
+          attrs.map do |attr_name, attr_val|
+            DataModel::AnyAttribute.new(
+              attr_name,
+              attr_val,
+              prefix: attr_name.split(":").first
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/archimate/file_formats/sax/archi/archi_handler_factory.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Archimate
+  module FileFormats
+    module Sax
+      module Archi
+        class ArchiHandlerFactory
+          def handler_for(name, attrs)
+            case name
+            when "model", "archimate:model"
+              Model
+            when "documentation", "purpose"
+              Sax::PreservedLangString
+            when "element"
+              element_type = Hash[attrs]["xsi:type"].sub(/archimate:/, '')
+              case element_type
+              when DataModel::ElementType, DataModel::ConnectorType
+                Element
+              when DataModel::DiagramType
+                Diagram
+              when DataModel::RelationshipType
+                Relationship
+              else
+                raise "Unexpected element_type #{element_type}"
+              end
+            when "property"
+              Property
+            when "folder"
+              Organization
+            when "child"
+              ViewNode
+            when "bounds"
+              Bounds
+            when "sourceConnection"
+              Connection
+            when "bendpoint"
+              Location
+            when "content"
+              Content
+            else
+              raise "Unhandled element name #{name}"
+            end
+          end
+        end
+      end
+    end
+  end
+end