archimate 1.1.0

data/lib/archimate/data_model/diffable_array.rb

@@ -0,0 +1,213 @@
+# frozen_string_literal: true
+module Archimate
+  module DataModel
+    module DiffableArray
+      using DiffablePrimitive
+
+      refine Array do
+        using DiffablePrimitive
+
+        attr_writer :parent_attribute_name
+
+        def in_model
+          @in_model if defined?(@in_model)
+        end
+
+        def parent
+          @parent if defined?(@parent)
+        end
+
+        def id
+          object_id.to_s
+        end
+
+        def ancestors
+          result = [self]
+          p = self
+          result << p until (p = p.parent).nil?
+          result
+        end
+
+        def primitive?
+          false
+        end
+
+        def diff(other)
+          raise TypeError, "Expected other #{other.class} to be of type #{self.class}" unless other.is_a?(self.class)
+          raise "Well Hell other #{other.path} in_model is nil" if other.in_model.nil?
+          raise "Well Hell my path `#{path}` in_model is nil" if in_model.nil?
+
+          result = []
+          remaining_content = Array.new(self) # TODO: I want a copy of the array, not a deep clone
+          other_enum = other.each_with_index
+
+          loop do
+            if other_enum.peek[0] == remaining_content[0]
+              other_enum.next
+              remaining_content.shift
+            elsif items_are_changed?(other, other_enum, remaining_content)
+              result.concat(compute_item_changes(other, other_enum, self, remaining_content[0]))
+              remaining_content.shift
+              other_enum.next
+            elsif !remaining_content.empty? && !other.smart_include?(remaining_content[0])
+              result << Diff::Delete.new(Diff::ArchimateArrayReference.new(self, smart_find(remaining_content[0])))
+              remaining_content.shift
+            elsif !smart_include?(other_enum.peek[0])
+              result << Diff::Insert.new(Diff::ArchimateArrayReference.new(other, other_enum.next[1]))
+            elsif smart_include?(other_enum.peek[0])
+              result << Diff::Move.new(
+                Diff::ArchimateArrayReference.new(other, other_enum.peek[1]),
+                Diff::ArchimateArrayReference.new(self, smart_find(other_enum.peek[0]))
+              )
+              remaining_item_idx = remaining_content.smart_find(other_enum.peek[0])
+              if remaining_item_idx
+                result.concat(compute_item_changes(other, other_enum, self, remaining_content[remaining_item_idx]))
+                remaining_content.delete_at(remaining_item_idx) if remaining_content.smart_include?(other_enum.peek[0])
+              end
+              other_enum.next
+            else
+              raise "Unhandled diff case for remaining_content: #{remaining_content[0]} and #{other_enum.peek[0]}"
+            end
+          end
+
+          result.concat(
+            remaining_content
+              .reject { |item| other.include?(item) }
+              .map do |item|
+                Diff::Delete.new(Diff::ArchimateArrayReference.new(self, find_index(item)))
+              end
+          )
+        end
+
+        # TODO: This may not continue to live here. Only used by testing.
+        def patch(diffs)
+          # TODO: Beware, order of diffs could break patching at the moment.
+          Array(diffs).each do |diff|
+            case diff
+            when Diff::Delete
+              delete_at(smart_find(diff.target.value))
+            when Diff::Insert
+              insert(diff.target.array_index, diff.target.value)
+            when Diff::Change
+              self[smart_find(diff.changed_from.value)] = diff.target.value
+            when Diff::Move
+              insert(diff.target.array_index, delete_at(smart_find(diff.target.value)))
+            else
+              raise "Unexpected diff type: #{diff.class}"
+            end
+          end
+          self
+        end
+
+        def items_are_changed?(other, other_enum, remaining)
+          !remaining.empty? &&
+            case remaining[0]
+            when DataModel::Referenceable
+              remaining[0].id == other_enum.peek[0].id
+            when String, DataModel::ArchimateNode
+              !other.include?(remaining[0]) && !include?(other_enum.peek[0])
+            else
+              raise "Unhandled type for #{remaining[0].class}"
+            end
+        end
+
+        def compute_item_changes(other, other_enum, _myself, my_item)
+          case my_item
+          when DataModel::ArchimateNode
+            my_item.diff(other_enum.peek[0])
+          else
+            my_item.diff(other_enum.peek[0], self, other, other_enum.peek[1], find_index(my_item))
+          end
+        end
+
+        def in_model=(model)
+          puts "#{self.inspect} is frozen" if self.frozen?
+          @in_model = model
+          each { |item| item.in_model = model }
+        end
+
+        def parent=(par)
+          @parent = par
+          each { |i| i.parent = self }
+        end
+
+        def parent_attribute_name
+          @parent_attribute_name if defined?(@parent_attribute_name)
+        end
+
+        def build_index(hash_index = {})
+          reduce(hash_index) { |hi, array_item| array_item.build_index(hi) }
+        end
+
+        def path(options = {})
+          [
+            parent&.path(options),
+            parent_attribute_name
+          ].compact.reject(&:empty?).join("/")
+        end
+
+        def clone
+          map(&:clone)
+        end
+
+        def dup
+          map(&:dup)
+        end
+
+        def to_s
+          "#{parent}/#{parent_attribute_name}"
+        end
+
+        def referenced_identified_nodes
+          reduce([]) do |a, e|
+            a.concat(e.referenced_identified_nodes)
+          end
+        end
+
+        def find_by_id(an_id)
+          find { |el| el.id == an_id }
+        end
+
+        def smart_find(val = nil)
+          case val
+          when Referenceable
+            lazy.map(&:id).find_index(val.id)
+          else
+            find_index(val)
+          end
+        end
+
+        def smart_include?(val)
+          case val
+          when Referenceable
+            lazy.map(&:id).include?(val.id)
+          else
+            include?(val)
+          end
+        end
+
+        def smart_intersection(ary)
+          select { |item| ary.smart_include?(item) }
+        end
+
+        def after(idx)
+          return [] if idx >= size - 1
+          self[idx + 1..-1]
+        end
+
+        # Given a node in self and ary,
+        # return the idx of first node p in self that exists in both self and ary
+        # and is previous to node in self
+        def previous_item_index(ary, node)
+          return -1 unless ary.smart_include?(node)
+          initial_idx = smart_find(node)
+          return -1 if initial_idx.nil?
+
+          (initial_idx - 1).downto(0).find(-> { -1 }) do |idx|
+            ary.smart_include?(at(idx))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/archimate/data_model/diffable_primitive.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+module Archimate
+  module DataModel
+    module DiffablePrimitive
+      module DiffablePrimitiveMethods
+        def diff(other, from_parent, to_parent, attribute, from_attribute = nil)
+          from_attribute = attribute if from_attribute.nil?
+          if other.nil?
+            return [Diff::Delete.new(
+              Diff::ArchimateNodeAttributeReference.new(from_parent, attribute)
+            )]
+          end
+          raise TypeError, "Expected other #{other.class} to be of type #{self.class}" unless other.is_a?(self.class)
+          unless self == other
+            return [Diff::Change.new(
+              Diff::ArchimateNodeReference.for_node(to_parent, attribute),
+              Diff::ArchimateNodeReference.for_node(from_parent, from_attribute)
+            )]
+          end
+          []
+        end
+
+        def in_model=(_m); end
+
+        def parent=(_p); end
+
+        def parent_attribute_name=(_attr_name); end
+
+        def build_index(index_hash)
+          index_hash
+        end
+
+        def primitive?
+          true
+        end
+
+        def id
+          object_id.to_s
+        end
+
+        def clone
+          self
+        end
+
+        def dup
+          self
+        end
+
+        def compact!
+          self
+        end
+
+        def referenced_identified_nodes
+          []
+        end
+      end
+
+      refine Symbol do
+        include DiffablePrimitiveMethods
+      end
+
+      refine String do
+        include DiffablePrimitiveMethods
+      end
+
+      refine Hash do
+        include DiffablePrimitiveMethods
+      end
+
+      refine Integer do
+        include DiffablePrimitiveMethods
+      end
+
+      refine Float do
+        include DiffablePrimitiveMethods
+      end
+
+      refine NilClass do
+        include DiffablePrimitiveMethods
+      end
+    end
+  end
+end

data/lib/archimate/data_model/documentation.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Archimate
+  module DataModel
+    # An element that holds documentation.
+    # A base string type for multi-language strings that preserves whitespace.
+    # PreservedLangStringType in ArchiMate 3 schema
+    class Documentation < LangString
+    end
+
+    Dry::Types.register_class(Documentation)
+    DocumentationGroup = Strict::Array.member(Documentation).default([])
+  end
+end

data/lib/archimate/data_model/element.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Archimate
+  module DataModel
+    ElementTypeEnum = %w[BusinessActor BusinessRole BusinessCollaboration BusinessInterface
+                         BusinessProcess BusinessFunction BusinessInteraction BusinessEvent BusinessService
+                         BusinessObject Contract Representation Product
+                         ApplicationComponent ApplicationCollaboration ApplicationInterface ApplicationFunction
+                         ApplicationInteraction ApplicationProcess ApplicationEvent ApplicationService DataObject
+                         Node Device SystemSoftware TechnologyCollaboration TechnologyInterface Path
+                         CommunicationNetwork TechnologyFunction TechnologyProcess TechnologyInteraction
+                         TechnologyEvent TechnologyService Artifact Equipment Facility DistributionNetwork Material
+                         Stakeholder Driver Assessment Goal Outcome
+                         Principle Requirement Constraint Meaning Value
+                         Resource Capability CourseOfAction
+                         WorkPackage Deliverable ImplementationEvent Plateau Gap
+                         Grouping Location
+                         AndJunction OrJunction].freeze
+
+    CompositeTypeEnum = %w[Grouping Location].freeze
+
+    RelationshipConnectorEnum = %w[AndJunction OrJunction].freeze
+
+    ElementEnumType = [].concat([ElementTypeEnum, CompositeTypeEnum, RelationshipConnectorEnum]).freeze
+
+    ElementType = Strict::String.enum(*ElementEnumType)
+
+    AllowedElementTypes = Strict::Array.member(ElementType).default([])
+
+    # A base element type that can be extended by concrete ArchiMate types.
+    #
+    # Note that ElementType is abstract, so one must have derived types of this type. this is indicated in xml
+    # by having a tag name of "element" and an attribute of xsi:type="BusinessRole" where BusinessRole is
+    # a derived type from ElementType.
+    class Element < Concept
+      def to_s
+        Archimate::Color.layer_color(layer, "#{type}<#{id}>[#{name}]")
+      end
+
+      def layer
+        Constants::ELEMENT_LAYER.fetch(type, "None")
+      end
+
+      # TODO: move to dynamic method creation
+      def composed_by
+        in_model
+          .relationships.select { |r| r.type == "CompositionRelationship" && r.target == id }
+          .map { |r| in_model.lookup(r.source) }
+      end
+
+      # TODO: move to dynamic method creation
+      def composes
+        in_model
+          .relationships
+          .select { |r| r.type == "CompositionRelationship" && r.source == id }
+          .map { |r| in_model.lookup(r.target) }
+      end
+
+      # Diagrams that this element is referenced in.
+      def diagrams
+        @diagrams ||= in_model.diagrams.select do |diagram|
+          diagram.element_ids.include?(id)
+        end
+      end
+
+      # Relationships that this element is referenced in.
+      def relationships
+        @relationships ||= in_model.relationships.select do |relationship|
+          relationship.source == id || relationship.target == id
+        end
+      end
+
+      # Copy any attributes/docs, etc. from each of the others into the original.
+      #     1. Child `label`s with different `xml:lang` attribute values
+      #     2. Child `documentation` (and different `xml:lang` attribute values)
+      #     3. Child `properties`
+      #     4. Any other elements
+      def merge(element)
+        super
+        element.diagrams.each { |diagram| diagram.replace(element, self) }
+        element.relationships.each { |relationship| relationship.replace(element, self) }
+        element.organization.remove(element.id)
+      end
+    end
+    Dry::Types.register_class(Element)
+  end
+end

data/lib/archimate/data_model/font.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+module Archimate
+  module DataModel
+    class Font < ArchimateNode
+      attribute :name, Strict::String.optional
+      attribute :size, Coercible::Float.constrained(gt: 0.0).optional
+      attribute :style, Coercible::Int.optional # TODO: make this an enum
+      attribute :font_data, Strict::String.optional
+
+      # Archi font strings look like this:
+      #  "1|Arial            |14.0|0|WINDOWS|1|0  |0|0|0|0  |0 |0|0|1|0|0|0|0 |Arial"
+      #  "1|Arial            |8.0 |0|WINDOWS|1|0  |0|0|0|0  |0 |0|0|1|0|0|0|0 |Arial"
+      #  "1|Segoe UI Semibold|12.0|2|WINDOWS|1|-16|0|0|0|600|-1|0|0|0|3|2|1|34|Segoe UI Semibold"
+      #  "1|Times New Roman  |12.0|3|WINDOWS|1|-16|0|0|0|700|-1|0|0|0|3|2|1|18|Times New Roman"
+      def self.archi_font_string(str)
+        return nil if str.nil?
+        font_parts = str.split("|")
+        DataModel::Font.new(
+          name: font_parts[1],
+          size: font_parts[2],
+          style: font_parts[3],
+          font_data: str
+        )
+      end
+
+      def to_s
+        "Font(name: #{name}, size: #{size}, style: #{style})"
+      end
+
+      def to_archi_font
+        font_data ||
+          [
+            1, font.name, font.size, font.style, "WINDOWS", 1, 0, 0, 0, 0, 0, 0,
+            0, 0, 1, 0, 0, 0, 0, font.name
+          ].map(&:to_s).join("|")
+      end
+
+      # TODO: this isn't standard
+      # Move to file format
+      def style_string
+        case style
+        when 1
+          "italic"
+        when 2
+          "bold"
+        when 3
+          "bold|italic"
+        end
+      end
+    end
+
+    Dry::Types.register_class(Font)
+  end
+end

data/lib/archimate/data_model/label.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Archimate
+  module DataModel
+    # Node type to allow a Label in a Artifact. the "label" element holds the info for the Note.
+    class Label < ViewNode
+      # conceptRef is a reference to an concept for this particular label, along with the attributeRef
+      # which references the particular concept's part which this label represents.
+      attribute :concept_ref, Identifier
+      # conceptRef is a reference to an concept for this particular label, along with the partRef
+      # which references the particular concept's part which this label represents. If this attribute
+      # is set, then there is no need to add a label tag in the Label parent (since it is contained in the model).
+      # the XPATH statement is meant to be interpreted in the context of what the conceptRef points to.
+      attribute :xpath_path, Strict::String.optional
+    end
+
+    Dry::Types.register_class(Label)
+  end
+end

data/lib/archimate/data_model/lang_string.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+require "forwardable"
+
+module Archimate
+  module DataModel
+    # A base string type for multi-language strings.
+    class LangString < ArchimateNode
+      # include Comparable
+      extend Forwardable
+      def_delegators :@text, :to_s, :strip, :strip!, :tr, :+, :gsub, :gsub!, :sub!, :downcase!, :empty?, :split
+
+      attribute :text, Strict::String
+      attribute :lang, Strict::String.optional
+
+      # @param [Hash{Symbol => Object},Dry::Struct, String] attributes
+      # @raise [Struct::Error] if the given attributes don't conform {#schema}
+      #   with given {#constructor_type}
+      def self.new(attributes)
+        if attributes.instance_of?(String)
+          super(text: attributes.strip)
+        else
+          super
+        end
+      end
+
+      def to_str
+        @text
+      end
+
+      def =~(other)
+        if other.is_a?(Regexp)
+          other =~ @text
+        else
+          Regexp.new(Regexp.escape(@text)) =~ other
+        end
+      end
+    end
+
+    Dry::Types.register_class(LangString)
+  end
+end

data/lib/archimate/data_model/location.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Archimate
+  module DataModel
+    # TODO: x & y Defined like this in the XSD
+    NonNegativeInteger = Coercible::Int.constrained(gteq: 0)
+    NonNegativeFloat = Coercible::Float # .constrained(gteq: 0)
+
+    # Graphical node type. It can contain child node types.
+    # This is LocationType/LocationGroup in the XSD.
+    class Location < ArchimateNode
+      # The x (towards the right, associated with width) attribute from the Top,Left (i.e. 0,0)
+      # corner of the diagram to the Top, Left corner of the bounding box of the concept.
+      attribute :x, NonNegativeFloat # Note the XSD has this as an Int, NonNegativeInteger
+      # The y (towards the bottom, associated with height) attribute from the Top,Left (i.e. 0,0)
+      # corner of the diagram to the Top, Left corner of the bounding box of the concept.
+      attribute :y, NonNegativeFloat # Note the XSD has this as an Int, NonNegativeInteger
+
+      # These are holdovers from the archi file format and are only maintained for compatability
+      attribute :end_x, Coercible::Int.optional
+      attribute :end_y, Coercible::Int.optional
+
+      def to_s
+        "Location(x: #{x}, y: #{y})"
+      end
+    end
+
+    Dry::Types.register_class(Location)
+    LocationList = Strict::Array.member(Location).default([])
+  end
+end

data/lib/archimate/data_model/metadata.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Archimate
+  module DataModel
+    # An instance of the meta-data element contains data structures that declare descriptive information
+    # about a meta-data element's parent only.
+    #
+    # One or more different meta-data models may be declared as child extensions of a meta-data element.
+    class Metadata < ArchimateNode
+      attribute :schema_infos, Strict::Array.member(SchemaInfo).default([])
+    end
+    Dry::Types.register_class(Metadata)
+  end
+end