archimate 1.2.1 → 2.0.0

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Archimate
+  module FileFormats
+    module Sax
+      module Archi
+        class Relationship < FileFormats::Sax::Handler
+          include Sax::CaptureDocumentation
+          include Sax::CaptureProperties
+
+          def initialize(name, attrs, parent_handler)
+            super
+            @relationship = nil
+          end
+
+          def complete
+            [
+              event(:on_relationship, relationship),
+              event(:on_referenceable, relationship),
+              event(:on_future, Sax::FutureReference.new(relationship, :source, @attrs["source"])),
+              event(:on_future, Sax::FutureReference.new(relationship, :target, @attrs["target"]))
+            ]
+          end
+
+          private
+
+          def relationship
+            @relationship ||= DataModel::Relationship.new(
+              id: @attrs["id"],
+              type: element_type,
+              source: nil,
+              target: nil,
+              name: DataModel::LangString.string(process_text(@attrs["name"])),
+              access_type: parse_access_type(@attrs["accessType"]),
+              documentation: documentation,
+              properties: properties
+            )
+          end
+
+          def parse_access_type(val)
+            return nil unless val && !val.empty?
+            i = val.to_i
+            return nil unless (0..DataModel::ACCESS_TYPE.size - 1).cover?(i)
+            DataModel::ACCESS_TYPE[i]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Archimate
+  module FileFormats
+    module Sax
+      module Archi
+        module Style
+          def initialize(name, attrs, parent_handler)
+            super
+            @style_hash = nil
+          end
+
+          def style
+            return nil if style_hash.empty?
+            DataModel::Style.new(style_hash)
+          end
+
+          private
+
+          def style_hash
+            @style_hash ||= {
+              text_alignment: attrs["textAlignment"],
+              fill_color: DataModel::Color.rgba(attrs["fillColor"]),
+              line_color: DataModel::Color.rgba(attrs["lineColor"]),
+              font_color: DataModel::Color.rgba(attrs["fontColor"]),
+              font: DataModel::Font.archi_font_string(attrs["font"]),
+              line_width: attrs["lineWidth"],
+              text_position: attrs["textPosition"]
+            }.delete_if { |_k, v| v.nil? }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Archimate
+  module FileFormats
+    module Sax
+      module Archi
+        class ViewNode < FileFormats::Sax::Handler
+          include Sax::CaptureDocumentation
+          include Sax::CaptureProperties
+          include Style
+
+          def initialize(name, attrs, parent_handler)
+            super
+            @view_nodes = []
+            @connections = []
+            @bounds = nil
+            @content = nil
+            @view_node = nil
+          end
+
+          def complete
+            [
+              event(:on_future, Sax::FutureReference.new(view_node, :view_refs, attrs["model"])),
+              event(:on_future, Sax::FutureReference.new(view_node, :element, attrs["archimateElement"])),
+              event(:on_referenceable, view_node),
+              event(:on_view_node, view_node)
+            ]
+          end
+
+          def on_view_node(view_node, source)
+            @view_nodes << view_node if source.parent_handler == self
+            view_node
+          end
+
+          def on_connection(connection, source)
+            @connections << connection if source.parent_handler == self
+            connection
+          end
+
+          def on_content(string, _source)
+            @content = string
+            false
+          end
+
+          def on_bounds(bounds, _source)
+            @bounds = bounds
+            false
+          end
+
+          private
+
+          def view_node
+            @view_node ||= DataModel::ViewNode.new(
+              id: attrs["id"],
+              type: attrs["xsi:type"],
+              view_refs: nil,
+              name: DataModel::LangString.string(process_text(attrs["name"])),
+              element: nil,
+              bounds: @bounds,
+              nodes: @view_nodes,
+              connections: @connections,
+              documentation: documentation,
+              properties: properties,
+              style: style,
+              content: @content,
+              child_type: attrs["type"],
+              diagram: diagram
+            )
+            @view_nodes.each { |node| node.parent = @view_node }
+            @view_node
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Archimate
+  module FileFormats
+    module Sax
+      module CaptureContent
+        def characters(string)
+          @content ||= []
+          @content << string
+          false
+        end
+
+        def content
+          return nil unless defined?(@content)
+          @content.join("")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Archimate
+  module FileFormats
+    module Sax
+      module CaptureDocumentation
+        def on_preserved_lang_string(documentation, _source)
+          @documentation = documentation
+          false
+        end
+
+        def documentation
+          return nil unless defined?(@documentation)
+          @documentation
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Archimate
+  module FileFormats
+    module Sax
+      module CaptureProperties
+        def on_property(property, _source)
+          @properties ||= []
+          @properties << property
+          false
+        end
+
+        def properties
+          return [] unless defined?(@properties)
+          @properties || []
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Archimate
+  module FileFormats
+    module Sax
+      class ContentElement < Handler
+        include Sax::CaptureContent
+
+        def initialize(name, attrs, parent_handler)
+          super
+        end
+
+        def complete
+          [event("on_#{@name}".to_sym, content)]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require "nokogiri"
+
+module Archimate
+  module FileFormats
+    module Sax
+      # SaxStack implements a stack like processor to maintain context
+      # during SAX processing of XML documents. It provides the means
+      # for a handler for a SAX event to raise events to handlers
+      # further up the stack and to query ancestor handlers.
+      class Document < Nokogiri::XML::SAX::Document
+        attr_reader :model
+        attr_reader :handler_factory
+
+        def initialize(handler_factory)
+          super()
+          @handler_factory = handler_factory
+          @stack = []
+          @model = nil
+        end
+
+        # Document is done.
+        # def end_document
+        # @model = @sax_stack.model
+        # end
+
+        # Push a handler onto the stack.
+        #
+        # create an instance of the correct builder for this element
+        # push it onto the @stack
+        #
+        # Note: {#unshift} is used here rather than {#push} in the
+        # underlying implementation because I want events to flow from
+        # last-in to first-in when they are fired and this lets be use
+        # {#take_while} without reversing the stack array.
+        #
+        # @param obj [SaxHandler] Handler to push on the stack
+        def start_element(name, attrs = [])
+          cls = handler_factory.handler_for(name, attrs)
+          @stack.unshift(
+            cls.new(name, attrs, @stack.first)
+          )
+        end
+
+        # Handler is completed. Fires any of the handlers events
+        # and pops the handler off of the stack.
+        #
+        # See {#push} regarding why {#shift} is used instead of {#pop}
+        def end_element(_name)
+          fire(@stack.shift.complete)
+        end
+
+        def current_handler
+          @stack.first
+        end
+
+        def characters(string)
+          current_handler.characters(string)
+        end
+
+        # Fire an event up the stack. Events are received at each handler
+        # until a handler returns nil or false.
+        #
+        # @param events [Array<SaxEvent>] zero or more Events to bubble up the stack
+        def fire(events)
+          Array(events).each do |event|
+            if event.sym == :on_model
+              @model = event.args
+            else
+              @stack.take_while do |target|
+                target.send(event.sym, event.args, event.source)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Archimate
+  module FileFormats
+    module Sax
+      class Handler
+        attr_reader :name
+        attr_reader :attrs
+        attr_reader :parent_handler
+        attr_reader :element_type
+
+        def initialize(name, attrs, parent_handler)
+          @name = name
+          @attrs = Hash[attrs]
+          @parent_handler = parent_handler
+          @element_type = @attrs["xsi:type"]&.sub(/archimate:/, '')
+        end
+
+        def characters(string); end
+
+        # @return [Array<Event>] array of events to fire for this handler
+        def complete
+          []
+        end
+
+        def diagram
+          parent_handler&.diagram
+        end
+
+        def event(sym, args)
+          SaxEvent.new(sym, args, self)
+        end
+
+        def method_missing(sym, *args)
+          return args.first if sym.to_s.start_with?("on_")
+          super
+        end
+
+        def respond_to_missing?(symbol, _include_all)
+          symbol.to_s.start_with?("on_")
+        end
+
+        # Returns the property definitions hash for this SaxDocument
+        def property_definitions
+          parent_handler&.property_definitions || []
+        end
+
+        def process_text(str)
+          str&.gsub("&#38;", "&")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Archimate
+  module FileFormats
+    module Sax
+      class LangString < FileFormats::Sax::Handler
+        include Sax::CaptureContent
+
+        def initialize(name, attrs, parent_handler)
+          super
+        end
+
+        def complete
+          doc = DataModel::LangString.string(
+            process_text(content),
+            @attrs["lang"] || @attrs["xml:lang"]
+          )
+          [
+            event(
+              :on_lang_string,
+              doc
+            )
+          ]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Archimate
+  module FileFormats
+    module Sax
+      module ModelExchangeFile
+        class Color < Sax::Handler
+          def initialize(name, attrs, parent_handler)
+            super
+          end
+
+          def complete
+            [
+              event(
+                event_name,
+                DataModel::Color.new(
+                  %w[r g b a].each_with_object({}) { |attr, hash| hash[attr.to_sym] = attrs[attr]&.to_i }
+                )
+              )
+            ]
+          end
+
+          private
+
+          def event_name
+            "on_#{snake_case(@name)}".to_sym
+          end
+
+          def snake_case(str)
+            str.gsub(/([A-Z])/, '_\1').downcase
+          end
+        end
+      end
+    end
+  end
+end