archimate 1.2.1 → 2.0.0

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Archimate
+  module FileFormats
+    module Sax
+      module Archi
+        class Bounds < FileFormats::Sax::Handler
+          def initialize(name, attrs, parent_handler)
+            super
+            @bounds = DataModel::Bounds.new(
+              x: @attrs["x"],
+              y: @attrs["y"],
+              width: @attrs["width"],
+              height: @attrs["height"]
+            )
+          end
+
+          def complete
+            [event(:on_bounds, @bounds)]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Archimate
+  module FileFormats
+    module Sax
+      module Archi
+        class Connection < FileFormats::Sax::Handler
+          include Style
+          include Sax::CaptureDocumentation
+          include Sax::CaptureProperties
+
+          def initialize(name, attrs, parent_handler)
+            super
+            @bendpoints = []
+          end
+
+          def complete
+            connection = DataModel::Connection.new(
+              id: @attrs["id"],
+              type: @attrs["xsi:type"],
+              source: nil,
+              target: nil,
+              relationship: nil,
+              name: @attrs["name"],
+              style: style,
+              bendpoints: @bendpoints,
+              documentation: documentation,
+              properties: properties
+            )
+            [
+              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["relationship"]))
+            ]
+          end
+
+          def on_location(location, _source)
+            @bendpoints << location
+            false
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Archimate
+  module FileFormats
+    module Sax
+      module Archi
+        class Content < FileFormats::Sax::Handler
+          def initialize(name, attrs, parent_handler)
+            super
+            @characters = []
+          end
+
+          def characters(string)
+            @characters << string
+          end
+
+          def complete
+            content = @characters.join("").strip
+            return [] if content.empty?
+            [
+              event(:on_content, content)
+            ]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+require "scanf"
+
+module Archimate
+  module FileFormats
+    module Sax
+      module Archi
+        class Diagram < FileFormats::Sax::Handler
+          include Sax::CaptureDocumentation
+          include Sax::CaptureProperties
+
+          def initialize(name, attrs, parent_handler)
+            super
+            @view_nodes = []
+            @connections = []
+            @diagram = nil
+          end
+
+          def complete
+            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["id"],
+              name: DataModel::LangString.string(process_text(@attrs["name"])),
+              viewpoint_type: parse_viewpoint_type(@attrs["viewpoint"]),
+              viewpoint: nil,
+              connection_router_type: @attrs["connectionRouterType"],
+              type: @attrs["xsi:type"],
+              background: @attrs["background"]
+            )
+          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
+
+          def parse_viewpoint_type(viewpoint_idx)
+            case viewpoint_idx
+            when String
+              idx = viewpoint_idx.scanf("%d").first
+              return nil unless idx
+              Serializer::Archi::ViewpointType.values[idx]
+            else
+              nil
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

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

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

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module Archimate
+  module FileFormats
+    module Sax
+      module Archi
+        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 = []
+            @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_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)
+            @index[referenceable.id] = referenceable
+          end
+
+          private
+
+          def process_futures
+            @futures.each do |future|
+              future.obj.send(
+                "#{future.attr}=".to_sym,
+                if future.id.is_a?(Array)
+                  future.id.map { |id| @index[id] }
+                else
+                  @index[future.id]
+                end
+              )
+            end
+          end
+
+          # def process_futures_using_fibers
+          #   @futures.each do |future|
+          #     future.resume(@index)
+          #   end
+          # end
+
+          def model
+            @model ||= DataModel::Model.new(id: @attrs["id"],
+                                            name: DataModel::LangString.string(process_text(@attrs["name"])),
+                                            documentation: documentation,
+                                            properties: properties,
+                                            elements: @elements,
+                                            organizations: @organizations,
+                                            relationships: @relationships,
+                                            diagrams: @diagrams,
+                                            viewpoints: @viewpoints,
+                                            property_definitions: @property_definitions.values,
+                                            namespaces: {},
+                                            schema_locations: [],
+                                            version: @attrs["version"])
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Archimate
+  module FileFormats
+    module Sax
+      module Archi
+        class Organization < FileFormats::Sax::Handler
+          include Sax::CaptureDocumentation
+
+          def initialize(name, attrs, parent_handler)
+            super
+            @child_items = []
+            @child_organizations = []
+            @organization = nil
+          end
+
+          def complete
+            [
+              event(:on_organization, organization),
+              event(:on_referenceable, organization)
+            ]
+          end
+
+          def on_diagram(diagram, source)
+            @child_items << diagram if source.parent_handler == self
+            diagram
+          end
+
+          def on_element(element, source)
+            @child_items << element if source.parent_handler == self
+            element
+          end
+
+          def on_organization(organization, _source)
+            @child_organizations << organization
+            false
+          end
+
+          def on_relationship(relationship, source)
+            @child_items << relationship if source.parent_handler == self
+            relationship
+          end
+
+          private
+
+          def organization
+            @organization ||= DataModel::Organization.new(id: @attrs["id"],
+                                                          name: DataModel::LangString.string(
+                                                            process_text(@attrs["name"])
+                                                          ),
+                                                          type: @attrs["type"],
+                                                          documentation: documentation,
+                                                          items: @child_items,
+                                                          organizations: @child_organizations)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Archimate
+  module FileFormats
+    module Sax
+      module Archi
+        class Property < FileFormats::Sax::Handler
+          def initialize(name, attrs, parent_handler)
+            super
+            @property = nil
+            @property_def = nil
+            @key = nil
+            @events = []
+          end
+
+          def complete
+            return [] unless key
+            @events << event(
+              :on_property,
+              DataModel::Property.new(
+                value: DataModel::LangString.string(process_text(attrs["value"])),
+                property_definition: prop_def
+              )
+            )
+          end
+
+          private
+
+          def key
+            @key ||= attrs["key"]
+          end
+
+          def prop_def
+            return property_definitions[key] if property_definitions.key?(key)
+
+            prop_def = make_prop_def
+            @events << event(:on_property_definition, prop_def)
+            @events << event(:on_referenceable, prop_def)
+            prop_def
+          end
+
+          def make_prop_def
+            DataModel::PropertyDefinition.new(
+              id: DataModel::PropertyDefinition.identifier_for_key(key),
+              name: DataModel::LangString.string(process_text(key)),
+              documentation: nil,
+              type: "string"
+            )
+          end
+        end
+      end
+    end
+  end
+end