archimate 1.2.1 → 2.0.0

data/lib/archimate/file_formats/sax/model_exchange_file/connection.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Archimate
+  module FileFormats
+    module Sax
+      module ModelExchangeFile
+        class Connection < FileFormats::Sax::Handler
+          include Sax::CaptureDocumentation
+          include Sax::CaptureProperties
+
+          def initialize(name, attrs, parent_handler)
+            super
+            @bendpoints = []
+            @connection_name = nil
+            @style = nil
+            @connection = nil
+          end
+
+          def complete
+            [
+              event(:on_connection, connection),
+              event(:on_referenceable, connection),
+              event(:on_future,
+                    Sax::FutureReference.new(connection, :source, attrs["source"])),
+              event(:on_future,
+                    Sax::FutureReference.new(connection, :target, attrs["target"])),
+              event(:on_future,
+                    Sax::FutureReference.new(connection,
+                                             :relationship,
+                                             attrs["relationshipRef"] || attrs["relationshipref"]))
+            ]
+          end
+
+          def on_location(location, _source)
+            @bendpoints << location
+            false
+          end
+
+          def on_style(style, _source)
+            @style = style
+            false
+          end
+
+          def on_lang_string(name, _source)
+            @connection_name = name
+            false
+          end
+
+          private
+
+          def connection
+            @connection ||= DataModel::Connection.new(id: attrs["identifier"],
+                                                      type: attrs["xsi:type"] || attrs["type"],
+                                                      source: nil,
+                                                      target: nil,
+                                                      relationship: nil,
+                                                      name: @connection_name,
+                                                      style: @style,
+                                                      bendpoints: @bendpoints,
+                                                      documentation: documentation,
+                                                      properties: properties)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/archimate/file_formats/sax/model_exchange_file/diagram.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Archimate
+  module FileFormats
+    module Sax
+      module ModelExchangeFile
+        class Diagram < FileFormats::Sax::Handler
+          include Sax::CaptureDocumentation
+          include Sax::CaptureProperties
+
+          def initialize(name, attrs, parent_handler)
+            super
+            @view_nodes = []
+            @connections = []
+            @diagram_name = nil
+            @diagram = nil
+          end
+
+          def complete
+            diagram.name = @diagram_name
+            diagram.documentation = documentation
+            diagram.properties = properties
+            diagram.nodes = @view_nodes
+            diagram.connections = @connections
+            [
+              event(:on_diagram, diagram),
+              event(:on_referenceable, diagram)
+            ]
+          end
+
+          def diagram
+            @diagram ||= DataModel::Diagram.new(
+              id: @attrs["identifier"],
+              viewpoint_type: @attrs["viewpoint"],
+              viewpoint: nil,
+              connection_router_type: @attrs["connectionRouterType"],
+              type: @attrs["xsi:type"],
+              background: @attrs["background"]
+            )
+          end
+
+          def on_lang_string(name, _source)
+            @diagram_name = name
+            false
+          end
+
+          def on_view_node(view_node, source)
+            @view_nodes << view_node if source.parent_handler == self
+            false
+          end
+
+          def on_connection(connection, _source)
+            @connections << connection
+            false
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Archimate
+  module FileFormats
+    module Sax
+      module ModelExchangeFile
+        class Element < FileFormats::Sax::Handler
+          include Sax::CaptureDocumentation
+          include Sax::CaptureProperties
+
+          def initialize(name, attrs, parent_handler)
+            super
+            @name = nil
+          end
+
+          def complete
+            [
+              event(:on_element, element),
+              event(:on_referenceable, element)
+            ]
+          end
+
+          def on_lang_string(str, _source)
+            @name = str
+            false
+          end
+
+          private
+
+          def element
+            @element ||= DataModel::Element.new(
+              id: attrs["identifier"],
+              name: name,
+              type: element_type,
+              documentation: documentation,
+              properties: properties
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/archimate/file_formats/sax/model_exchange_file/font.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Archimate
+  module FileFormats
+    module Sax
+      module ModelExchangeFile
+        class Font < FileFormats::Sax::Handler
+          def initialize(name, attrs, parent_handler)
+            super
+          end
+
+          def complete
+            [
+              event(:on_font,
+                    DataModel::Font.new(
+                      name: attrs["name"],
+                      size: attrs["size"],
+                      style: style_to_int(attrs["style"]),
+                      font_data: nil
+                    ))
+            ]
+          end
+
+          private
+
+          def style_to_int(str)
+            case str
+            when nil
+              0
+            when "italic"
+              1
+            when "bold"
+              2
+            when "bold|italic", "bold italic"
+              3
+            else
+              raise "Broken for value: #{str}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/archimate/file_formats/sax/model_exchange_file/item.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Archimate
+  module FileFormats
+    module Sax
+      module ModelExchangeFile
+        class Item < FileFormats::Sax::Handler
+          include Sax::CaptureDocumentation
+
+          def initialize(name, attrs, parent_handler)
+            super
+            @item_name = nil
+            @child_items = []
+            @child_organizations = []
+            @identifier_ref = nil
+            @organization = nil
+          end
+
+          def complete
+            return [event(:on_item_reference, identifier_ref)] if identifier_ref
+
+            [
+              event(:on_organization, organization),
+              event(:on_referenceable, organization),
+              event(:on_future, Sax::FutureReference.new(organization, :items, @child_items))
+            ]
+          end
+
+          def on_organization(organization, _source)
+            @child_organizations << organization
+            false
+          end
+
+          def on_item_reference(ref, _source)
+            @child_items << ref
+            false
+          end
+
+          def on_lang_string(name, _source)
+            @item_name = name
+            false
+          end
+
+          private
+
+          def organization
+            @organization ||= DataModel::Organization.new(
+              id: attrs["identifier"], # TODO: model exchange doesn't assign ids to organization items
+              name: @item_name,
+              type: attrs["type"],
+              documentation: documentation,
+              items: nil,
+              organizations: @child_organizations
+            )
+          end
+
+          def identifier_ref
+            @identifier_ref ||= attrs["identifierRef"] || attrs["identifierref"]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Archimate
+  module FileFormats
+    module Sax
+      module ModelExchangeFile
+        class Location < FileFormats::Sax::Handler
+          def initialize(name, attrs, parent_handler)
+            super
+            @location = DataModel::Location.new(
+              x: @attrs["x"] || 0,
+              y: @attrs["y"] || 0
+            )
+          end
+
+          def complete
+            [event(:on_location, @location)]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/archimate/file_formats/sax/model_exchange_file/metadata.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Archimate
+  module FileFormats
+    module Sax
+      module ModelExchangeFile
+        class Metadata < FileFormats::Sax::Handler
+          def initialize(name, attrs, parent_handler)
+            super
+            @schema_infos = []
+            @schema = nil
+            @schema_version = nil
+            @elements = []
+            @metadata = nil
+            @lone_schema_info = nil
+          end
+
+          def complete
+            [
+              event(:on_metadata, metadata)
+            ]
+          end
+
+          def on_schema(string, _source)
+            @schema = string
+            false
+          end
+
+          def on_schemaversion(string, _source)
+            @schema_version = string
+            false
+          end
+
+          def on_any_element(any_element, _source)
+            @elements << any_element
+            false
+          end
+
+          def on_schema_info(schema_info, _source)
+            @schema_infos << schema_info
+            false
+          end
+
+          private
+
+          def metadata
+            return @metadata if @metadata
+            @schema_infos << lone_schema_info if @schema
+            @metadata = DataModel::Metadata.new(
+              schema_infos: @schema_infos
+            )
+          end
+
+          def lone_schema_info
+            return nil unless @schema
+            @lone_schema_info = DataModel::SchemaInfo.new(
+              schema: @schema,
+              schemaversion: @schema_version,
+              elements: @elements
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/archimate/file_formats/sax/model_exchange_file/model.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module Archimate
+  module FileFormats
+    module Sax
+      module ModelExchangeFile
+        class Model < FileFormats::Sax::Handler
+          include Sax::CaptureDocumentation
+          include Sax::CaptureProperties
+
+          attr_reader :property_definitions
+
+          def initialize(name, attrs, parent_handler)
+            super
+            @property_definitions = {}
+            @elements = []
+            @organizations = []
+            @relationships = []
+            @diagrams = []
+            @viewpoints = []
+            @futures = []
+            @metadata = nil
+            @index = {}
+            @model = nil
+          end
+
+          def complete
+            process_futures
+            [event(:on_model, model)]
+          end
+
+          def on_element(element, _source)
+            @elements << element
+            false
+          end
+
+          def on_organization(organization, _source)
+            @organizations << organization
+            false
+          end
+
+          def on_relationship(relationship, _source)
+            @relationships << relationship
+            false
+          end
+
+          def on_diagram(diagram, _source)
+            @diagrams << diagram
+            false
+          end
+
+          def on_viewpoint(viewpoint, _source)
+            @viewpoints << viewpoint
+            false
+          end
+
+          def on_metadata(metadata, _source)
+            @metadata = metadata
+            false
+          end
+
+          def on_property_definition(property_definition, _source)
+            @property_definitions[property_definition.id] = property_definition
+            false
+          end
+
+          def on_future(future, _source)
+            @futures << future
+          end
+
+          def on_referenceable(referenceable, _source)
+            return unless referenceable.id
+            @index[referenceable.id] = referenceable
+          end
+
+          def on_any_element(any_element, _source)
+            raise "Unexpected: #{any_element.inspect}"
+          end
+
+          def on_lang_string(lang_string, _source)
+            @name = lang_string
+            false
+          end
+
+          private
+
+          def process_futures
+            @futures.each do |future|
+              next unless future.id
+              future.obj.send(
+                "#{future.attr}=".to_sym,
+                if future.id.is_a?(Array)
+                  future.id.map do |id|
+                    raise "Error processing futures for array. id was nil" unless id
+                    @index[id]
+                  end
+                else
+                  future.id ? @index[future.id] : nil
+                end
+              )
+            end
+          end
+
+          def model
+            @model ||= DataModel::Model.new(id: attrs["identifier"],
+                                            name: name,
+                                            metadata: @metadata,
+                                            documentation: documentation,
+                                            properties: properties,
+                                            elements: @elements,
+                                            organizations: @organizations,
+                                            relationships: @relationships,
+                                            diagrams: @diagrams,
+                                            viewpoints: @viewpoints,
+                                            property_definitions: @property_definitions.values,
+                                            schema_locations: attrs["xsi:schemaLocation"].split(" "),
+                                            namespaces: attrs.select { |k, _v| k.start_with?("xmlns") },
+                                            version: @attrs["version"])
+          end
+        end
+      end
+    end
+  end
+end