archimate 1.2.1 → 2.0.0

data/lib/archimate/data_model/{documentation.rb → preserved_lang_string.rb}

@@ -2,13 +2,9 @@
 
 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
+    class PreservedLangString < LangString
     end
-
-    Dry::Types.register_class(Documentation)
-    DocumentationGroup = Strict::Array.member(Documentation).default([])
   end
 end

data/lib/archimate/data_model/property.rb

@@ -1,10 +1,23 @@
 # frozen_string_literal: true
+
 module Archimate
   module DataModel
-    # A Property instance type declaring the reference to a Property definition and containing the Property value.
-    class Property < ArchimateNode
-      attribute :values, Strict::Array.member(LangString).default([]) # .constrained(min_size: 1)
-      attribute :property_definition, PropertyDefinition
+    # A Property instance type declaring the reference to a [PropertyDefinition]
+    # and containing the property value.
+    class Property
+      include Comparison
+
+      # @!attribute [r] value
+      #   @return [LangString, NilClass] value of the property, default +nil+
+      model_attr :value
+      # @!attribute [rw] property_definition
+      #   @return [PropertyDefinition] property definition of the property
+      model_attr :property_definition, writable: true
+
+      def initialize(property_definition:, value: nil)
+        @property_definition = property_definition
+        @value = value
+      end
 
       def to_s
         "Property(key: #{property_definition.name}, value: #{value || 'no value'})"
@@ -13,13 +26,6 @@ module Archimate
       def key
         property_definition.name
       end
-
-      def value
-        values.first
-      end
     end
-
-    Dry::Types.register_class(Property)
-    PropertiesList = Strict::Array.member(Property).default([])
   end
 end

data/lib/archimate/data_model/property_definition.rb

@@ -2,15 +2,45 @@
 
 module Archimate
   module DataModel
+    # An enumeration of data types.
+    # @todo consider making this an enumeration
+    PROPERTY_DEFINITION_TYPES = %w[string boolean currency date time number].freeze
+
     # A Property definition type containing its unique identifier, name, and data type.
-    class PropertyDefinition < NamedReferenceable
-      attribute :value_type, DataType
+    class PropertyDefinition
+      include Comparison
+
+      # @!attribute [r] id
+      #   @return [String]
+      model_attr :id
+      # @!attribute [r] name
+      #   @return [LangString]
+      model_attr :name
+      # @!attribute [r] documentation
+      #   @return [PreservedLangString, NilClass]
+      model_attr :documentation
+      # # @!attribute [r] other_elements
+      #   @return [Array<AnyElement>]
+      model_attr :other_elements
+      # # @!attribute [r] other_attributes
+      #   @return [Array<AnyAttribute>]
+      model_attr :other_attributes
+      # @!attribute [r] type
+      #   @note if +type+ is nil, then type "string" is assumed
+      #   @see Archimate::DataModel::PROPERTY_DEFINITION_TYPES
+      #   @return [String, NilClass]
+      model_attr :type
 
       def self.identifier_for_key(key)
         (self.class.hash ^ key.hash).to_s(16)
       end
-    end
 
-    Dry::Types.register_class(PropertyDefinition)
+      def initialize(id:, name:, documentation: nil, type: nil)
+        @id = id
+        @name = name
+        @documentation = documentation
+        @type = type
+      end
+    end
   end
 end

data/lib/archimate/data_model/referenceable.rb

@@ -4,15 +4,6 @@ module Archimate
   module DataModel
     # Something that can be referenced in the model.
     class Referenceable < ArchimateNode
-      attribute :id, Identifier
-      attribute :name, LangString.optional # TODO: Strict::Array.member(LangString).constrained(min_size: 1)
-
-      attribute :documentation, DocumentationGroup
-      # attribute :grp_any, Strict::Array.member(AnyNode).default([])
-      # attribute :other_attributes, Strict::Array.member(AnyAttribute).default([])
-      # attribute :properties, PropertiesList # Note: Referenceable doesn't have properties in the spec
-      attribute :type, Strict::String.optional # Note: type here was used for the Element/Relationship/Diagram type
-
       private
 
       def find_my_index

data/lib/archimate/data_model/referenceable_collection.rb

@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+module Archimate
+  module DataModel
+    # This class represents a collection of referenceable objects (i.e. have an `id`)
+    class ReferenceableCollection
+      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 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

data/lib/archimate/data_model/relationship.rb

@@ -2,34 +2,60 @@
 
 module Archimate
   module DataModel
-    RelationshipTypeEnum = %w[
-      Composition
-      Aggregation
-      Assignment
-      Realization
-      Serving
-      Access
-      Influence
-      Triggering
-      Flow
-      Specialization
-      Association
-    ].freeze
-    RelationshipType = Strict::String.enum(*RelationshipTypeEnum)
-    AllowedRelationshipTypes = Strict::Array.member(RelationshipType).default([])
-
-    AccessType = %w[Access Read Write ReadWrite]
-    AccessTypeEnum = Strict::String.enum(*AccessType)
+    ACCESS_TYPE = %w[Access Read Write ReadWrite].freeze
+    AccessTypeEnum = String #String.enum(*ACCESS_TYPE)
 
     # A base relationship type that can be extended by concrete ArchiMate types.
     #
     # Note that RelationshipType is abstract, so one must have derived types of this type. this is indicated in xml
     # by having a tag name of "relationship" and an attribute of xsi:type="AccessRelationship" where AccessRelationship is
     # a derived type from RelationshipType.
-    class Relationship < Concept
-      attribute :source, Identifier
-      attribute :target, Identifier
-      attribute :access_type, AccessTypeEnum.optional
+    class Relationship
+      include Comparison
+
+      # @!attribute [r] id
+      #   @return [String]
+      model_attr :id
+      # @!attribute [r] name
+      #   @return [LangString, NilClass]
+      model_attr :name
+      # @!attribute [r] documentation
+      #   @return [PreservedLangString, NilClass]
+      model_attr :documentation
+      # # @return [Array<AnyElement>]
+      # model_attr :other_elements
+      # # @return [Array<AnyAttribute>]
+      # model_attr :other_attributes
+      # @note type here was used for the Element/Relationship/Diagram type
+      # @!attribute [r] type
+      #   @return [String, NilClass]
+      model_attr :type
+      # @!attribute [r] properties
+      #   @return [Array<Property>]
+      model_attr :properties
+      # @todo is this optional?
+      # @!attribute [rw] source
+      #   @return [Element, Relationship]
+      model_attr :source, comparison_attr: :id, writable: true
+      # @todo is this optional?
+      # @!attribute [rw] target
+      #   @return [Element, Relationship]
+      model_attr :target, comparison_attr: :id, writable: true
+      # @!attribute [r] access_type
+      #   @return [AccessTypeEnum, NilClass]
+      model_attr :access_type
+
+      def initialize(id:, name: nil, documentation: nil, type: nil,
+                     properties: [], source:, target:, access_type: nil)
+        @id = id
+        @name = name
+        @documentation = documentation
+        @type = type
+        @properties = properties
+        @source = source
+        @target = target
+        @access_type = access_type
+      end
 
       def replace(entity, with_entity)
         @source = with_entity.id if source == entity.id
@@ -40,28 +66,22 @@ module Archimate
         Archimate::Color.color(
           "#{Archimate::Color.data_model(type)}<#{id}>[#{Archimate::Color.color(name&.strip || '', %i[black underline])}]",
           :on_light_magenta
-        ) + " #{source_element} -> #{target_element}"
+        ) + " #{source} -> #{target}"
       end
 
       def description
         [
           name.nil? ? nil : "#{name}:",
-          FileFormats::ArchimateV2::RELATION_VERBS.fetch(type, nil)
+          RELATION_VERBS.fetch(type, nil)
         ].compact.join(" ")
       end
 
+      # @todo remove when it doesn't break diff merge conflicts
+      # @deprecated
       def referenced_identified_nodes
         [@source, @target].compact
       end
 
-      def source_element
-        element_by_id(source)
-      end
-
-      def target_element
-        element_by_id(target)
-      end
-
       # Diagrams that this element is referenced in.
       def diagrams
         @diagrams ||= in_model.diagrams.select do |diagram|
@@ -80,6 +100,5 @@ module Archimate
         access_type ||= relationship.access_type
       end
     end
-    Dry::Types.register_class(Relationship)
   end
 end