archimate 1.1.0

data/lib/archimate/data_model/viewpoint.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Archimate
+  module DataModel
+    # Basic Viewpoints
+    # Category:Composition Viewpoints that defines internal compositions and aggregations of elements.
+    COMPOSITION_VIEWPOINTS = [
+      "Organization",
+      "Application Platform",
+      "Information Structure",
+      "Technology",
+      "Layered",
+      "Physical"
+    ].freeze
+
+    # Category:Support Viewpoints where you are looking at elements that are supported by other elements. Typically from one layer and upwards to an above layer.
+    SUPPORT_VIEWPOINTS = [
+      "Product",
+      "Application Usage",
+      "Technology Usage"
+    ].freeze
+
+    # Category:Cooperation Towards peer elements which cooperate with each other. Typically across aspects.
+    COOPERATION_VIEWPOINTS = [
+      "Business Process Cooperation",
+      "Application Cooperation"
+    ].freeze
+
+    # Category:Realization Viewpoints where you are looking at elements that realize other elements. Typically from one layer and downwards to a below layer.
+    REALIZATION_VIEWPOINTS = [
+      "Service Realization",
+      "Implementation and Deployment",
+      "Goal Realization",
+      "Goal Contribution",
+      "Principles",
+      "Requirements Realization",
+      "Motivation"
+    ].freeze
+
+    # Strategy Viewpoints
+    STRATEGY_VIEWPOINTS = [
+      "Strategy",
+      "Capability Map",
+      "Outcome Realization",
+      "Resource Map"
+    ].freeze
+
+    # Implementation and Migration Viewpoints
+    IMPLEMENTATION_AND_MIGRATION_VIEWPOINTS = [
+      "Project",
+      "Migration",
+      "Implementation and Migration"
+    ].freeze
+
+    # Other Viewpoints
+    Other_Viewpoints = %w[Stakeholder].freeze
+
+    VIEWPOINTS_ENUM = [].concat(
+                        [COMPOSITION_VIEWPOINTS, SUPPORT_VIEWPOINTS, COOPERATION_VIEWPOINTS,
+                         REALIZATION_VIEWPOINTS, STRATEGY_VIEWPOINTS,
+                         IMPLEMENTATION_AND_MIGRATION_VIEWPOINTS].flatten
+                      )
+
+    ViewpointType = Strict::String.enum(*VIEWPOINTS_ENUM).optional
+
+    ViewpointContentEnum = Strict::String.enum(%w[Details Coherence Overview])
+    ViewpointContent = Strict::Array.member(ViewpointContentEnum).default([])
+
+    ViewpointPurposeEnum = Strict::String.enum(%w[Designing Deciding Informing])
+    ViewpointPurpose = Strict::Array.member(ViewpointPurposeEnum).default([])
+
+    class Viewpoint < NamedReferenceable
+      using DataModel::DiffableArray
+      using DataModel::DiffablePrimitive
+
+      attribute :concern, ConcernList
+      attribute :viewpointPurpose, ViewpointPurpose.optional
+      attribute :viewpointContent, ViewpointContent.optional
+      attribute :allowedElementTypes, AllowedElementTypes
+      attribute :allowedRelationshipTypes, AllowedRelationshipTypes
+      attribute :modelingNotes, Strict::Array.member(ModelingNote).default([])
+    end
+
+    Dry::Types.register_class(Viewpoint)
+    ViewpointList = Strict::Array.member(Viewpoint).default([])
+  end
+end

data/lib/archimate/data_model.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Archimate
+  module DataModel
+    include Dry::Types.module
+
+    Coercible = Archimate::DataModel::Coercible
+    Strict = Archimate::DataModel::Strict
+
+    # Identifiers in the ArchiMate exchange format standard are of
+    Identifier = Strict::String # .constrained(format: /[[[:alpha:]]_][\w\-\.]*/)
+
+    # An enumeration of data types.
+    DataType = Strict::String.default("string").enum("string", "boolean", "currency", "date", "time", "number")
+
+    # Enumeration of Influence Strength types. These are suggestions.
+    InfluenceStrengthEnum = Strict::String.enum(%w[+ ++ - -- 0 1 2 3 4 5 6 7 8 9 10])
+
+    require 'archimate/data_model/diffable_primitive'
+    require 'archimate/data_model/diffable_array'
+    require 'archimate/data_model/constants'
+    require 'archimate/data_model/archimate_node'
+    require 'archimate/data_model/any_attribute'
+    require 'archimate/data_model/any_element'
+    require 'archimate/data_model/lang_string'
+    require 'archimate/data_model/schema_info'
+    require 'archimate/data_model/metadata'
+    require 'archimate/data_model/color'
+    require 'archimate/data_model/font'
+    require 'archimate/data_model/style'
+    require 'archimate/data_model/bounds'
+    require 'archimate/data_model/documentation'
+    require 'archimate/data_model/modeling_note'
+    require 'archimate/data_model/referenceable'
+    require 'archimate/data_model/named_referenceable'
+    require 'archimate/data_model/property_definition'
+    require 'archimate/data_model/property'
+    require 'archimate/data_model/concept'
+    require 'archimate/data_model/organization'
+    require 'archimate/data_model/element'
+    require 'archimate/data_model/relationship'
+    require 'archimate/data_model/concern'
+    require 'archimate/data_model/viewpoint'
+    require 'archimate/data_model/view'
+    require 'archimate/data_model/view_concept'
+    require 'archimate/data_model/location'
+    require 'archimate/data_model/connection'
+    require 'archimate/data_model/view_node'
+    require 'archimate/data_model/container'
+    require 'archimate/data_model/diagram'
+    require 'archimate/data_model/label'
+    require 'archimate/data_model/model'
+  end
+end

data/lib/archimate/diff/archimate_array_reference.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module Archimate
+  module Diff
+    class ArchimateArrayReference < ArchimateNodeReference
+      using DataModel::DiffableArray
+      using DataModel::DiffablePrimitive
+
+      attr_reader :array_index
+
+      def initialize(array, array_index)
+        unless array.is_a?(Array)
+          raise(
+            TypeError,
+            "array argument must be an Array, was #{array.class}"
+          )
+        end
+        unless array_index.is_a?(Integer)
+          raise(
+            TypeError,
+            "array_index argument must be a Integer, was #{array_index.class} #{array_index.inspect}"
+          )
+        end
+        unless array_index >= 0 && array_index < array.size
+          raise(
+            ArgumentError,
+            "array_index argument a valid index for array #{array_index.inspect}"
+          )
+        end
+        super(array)
+        @array_index = array_index
+      end
+
+      def value
+        archimate_node[array_index]
+      end
+
+      def to_s
+        value.to_s
+      end
+
+      def lookup_in_model(model)
+        result = lookup_parent_in_model(model)
+        raise TypeError, "result was #{result.class} expected Array" unless result.is_a?(Array)
+        result[array_index]
+      end
+
+      def path(options = {})
+        @array_ref_path ||= [
+          super,
+          case value
+          when DataModel::Referenceable
+            value.id
+          else
+            array_index
+          end
+        ].map(&:to_s).reject(&:empty?).join("/")
+      end
+
+      # For inserts - we can't be sure of what is available (without an expensive sort)
+      # So lookup the first previous value that exists in to_model and insert it after that
+      # value instead of a fixed index.
+      def find_insert_index_in_ary(ary)
+        return -1 if array_index.zero?
+        my_idx = (array_index - 1).downto(0).find(-1) do |idx|
+          ary.smart_include?(archimate_node[idx])
+        end
+        ary.smart_find(archimate_node[my_idx])
+      end
+
+      def insert(to_model)
+        ary_in_model = lookup_parent_in_model(to_model)
+        insert_idx = find_insert_index_in_ary(ary_in_model) + 1
+        ary_in_model.insert(insert_idx, value)
+      end
+
+      def delete(to_model)
+        ary_in_model = lookup_parent_in_model(to_model)
+        if ary_in_model.nil?
+          $stderr.puts "lookup parent in model failed for path #{path}"
+          return nil
+        end
+        idx = ary_in_model.smart_find(value)
+        if idx
+          ary_in_model.delete_at(idx)
+        else
+          $stderr.puts "Couldn't find item #{value.inspect} in path #{path} to delete in to_model"
+        end
+      end
+
+      def change(to_model, from_value)
+        ary_in_model = lookup_parent_in_model(to_model)
+        idx = ary_in_model.smart_find(from_value)
+        if idx.nil?
+          $stderr.puts "Couldn't find value #{from_value.inspect} in path #{path} to change in to_model, adding to end of list"
+          idx = ary_in_model.size
+        end
+        ary_in_model[idx] = value
+      end
+
+      def move(to_model, _from_ref)
+        ary_in_model = lookup_parent_in_model(to_model)
+        insert_idx = parent.previous_item_index(ary_in_model, value) + 1
+        current_idx = ary_in_model.smart_find(value)
+        deleted_value = ary_in_model.delete_at(current_idx)
+        ary_in_model.insert(
+          insert_idx,
+          deleted_value
+        )
+      end
+    end
+  end
+end

data/lib/archimate/diff/archimate_identified_node_reference.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Archimate
+  module Diff
+    class ArchimateReferenceableReference < ArchimateNodeReference
+      using DataModel::DiffableArray
+
+      def initialize(archimate_node)
+        unless archimate_node.is_a?(DataModel::Referenceable)
+          raise(
+            TypeError,
+            "archimate_node is a #{archimate_node.class}, Referenceable was expected"
+          )
+        end
+        super
+      end
+
+      def lookup_in_model(model)
+        raise TypeError unless model.is_a?(DataModel::Model)
+        # There can be only one Model so return the model argument if
+        # this node reference is a Model. This escape is required in case
+        # the Model this is being applied to has a different id than the
+        # model of the attribute this reference refers to.
+        return model if archimate_node.is_a?(DataModel::Model)
+        model.lookup(archimate_node.id)
+      end
+
+      def to_s
+        archimate_node.to_s
+      end
+
+      def value
+        archimate_node
+      end
+
+      def parent
+        archimate_node.parent
+      end
+    end
+  end
+end

data/lib/archimate/diff/archimate_node_attribute_reference.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Archimate
+  module Diff
+    class ArchimateNodeAttributeReference < ArchimateNodeReference
+      attr_reader :attribute
+
+      def initialize(archimate_node, attribute)
+        unless archimate_node.is_a?(DataModel::ArchimateNode)
+          raise(
+            TypeError,
+            "archimate_node must be an ArchimateNode, was #{archimate_node.class}"
+          )
+        end
+        unless attribute.is_a?(Symbol)
+          raise(
+            TypeError,
+            "Node #{archimate_node.class} attribute must be a sym, was a #{attribute.class} value #{attribute.inspect}"
+          )
+        end
+        unless archimate_node.class.schema.keys.include?(attribute)
+          raise(
+            ArgumentError,
+            "Attribute #{attribute} invalid for class #{archimate_node.class}"
+          )
+        end
+        super(archimate_node)
+        @attribute = attribute
+      end
+
+      def ==(other)
+        super && attribute == other.attribute
+      end
+
+      def lookup_in_model(model)
+        recurse_lookup_in_model(archimate_node, model)[attribute]
+      end
+
+      def to_s
+        attribute.to_s
+      end
+
+      def value
+        archimate_node[attribute]
+      end
+
+      def path(options = {})
+        @node_attribute_ref_path ||= [
+          super, @attribute
+        ].map(&:to_s).reject(&:empty?).join("/")
+      end
+
+      def insert(to_model)
+        lookup_parent_in_model(to_model).set(attribute, value)
+      end
+
+      def delete(to_model)
+        lookup_parent_in_model(to_model).delete(attribute)
+      end
+
+      def change(to_model, _from_value)
+        lookup_parent_in_model(to_model).set(attribute, value)
+      end
+
+      def move(_to_model)
+        raise "Move is not valid for ArchimateNodes"
+      end
+    end
+  end
+end

data/lib/archimate/diff/archimate_node_reference.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Archimate
+  module Diff
+    class ArchimateNodeReference
+      using DataModel::DiffablePrimitive
+      using DataModel::DiffableArray
+
+      attr_reader :archimate_node
+
+      # There should be only a few things that are valid here:
+      # 1. An archimate node and a attribute name sym
+      # 2. An array and index
+      # Produces a NodeReference instance for the given parameters
+      def self.for_node(node, child_node)
+        case node
+        when DataModel::ArchimateNode
+          ArchimateNodeAttributeReference.new(node, child_node)
+        when Array
+          ArchimateArrayReference.new(node, child_node)
+        else
+          raise TypeError, "Node references need to be either an ArchimateNode or an Array"
+        end
+      end
+
+      def initialize(archimate_node)
+        unless archimate_node.is_a?(DataModel::ArchimateNode) || archimate_node.is_a?(Array)
+          raise(
+            TypeError,
+            "archimate_node must be an ArchimateNode or Array, was #{archimate_node.class}"
+          )
+        end
+        raise "new WTF? parent at path #{archimate_node.path} is a #{archimate_node.class} but isn't assigned a model" if archimate_node.in_model.nil? && !archimate_node.is_a?(DataModel::Model)
+        @archimate_node = archimate_node
+      end
+
+      def ==(other)
+        other.is_a?(self.class) &&
+          value == other.value
+      end
+
+      def to_s
+        value.to_s
+      end
+
+      def lookup_in_model(model)
+        recurse_lookup_in_model(archimate_node, model)
+      end
+
+      def recurse_lookup_in_model(node, model)
+        return nil if node.nil?
+        raise TypeError, "node argument must be ArchimateNode or Array, was a #{node.class}" unless node.is_a?(Array) || node.is_a?(DataModel::ArchimateNode)
+        raise TypeError, "model argument must be a Model, was a #{model.class}" unless model.is_a?(DataModel::Model)
+        if node.is_a?(DataModel::Model)
+          return model
+        elsif node.is_a?(DataModel::Referenceable)
+          return model.lookup(node.id)
+        else
+          node_parent_in_model = recurse_lookup_in_model(node.parent, model)
+          node_parent_in_model[node.parent_attribute_name] unless node_parent_in_model.nil?
+        end
+      end
+
+      def lookup_parent_in_model(model)
+        raise "WTF? parent at path #{path} is a #{parent.class} but isn't assigned a model" if parent.in_model.nil? && !parent.is_a?(DataModel::Model)
+        result = recurse_lookup_in_model(parent, model)
+        $stderr.puts "Unable to lookup parent with path #{path}" if result.nil?
+        result
+      end
+
+      def parent
+        archimate_node
+      end
+
+      def path(options = {})
+        @node_ref_path ||= archimate_node.path(options)
+      end
+    end
+  end
+end

data/lib/archimate/diff/change.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+module Archimate
+  module Diff
+    class Change < Difference
+      using DataModel::DiffableArray
+
+      # Create a new Change difference
+      #
+      # @param target [Archimate::Diff::ArchimateNodeReference] reference to
+      #   ArchimateNode that was changed
+      # @param changed_from [Archimate::Diff::ArchimateNodeReference] Element
+      #   that was changed
+      def initialize(target, changed_from)
+        super(target, changed_from)
+      end
+
+      def to_s
+        # Note - the explicit to_s is required to access the DiffableArray
+        #        implementation if the parent is an Array.
+        "#{diff_type} #{changed_from.parent&.to_s} #{Color.color(target.to_s, :change)} changed to #{target.value}"
+      end
+
+      def apply(to_model)
+        unless to_model.is_a?(DataModel::Model)
+          throw(
+            TypeError,
+            "Expected a Archimate::DataModel::Model, was a #{to_model.class}"
+          )
+        end
+        target.change(to_model, changed_from.value)
+        to_model
+      end
+
+      def change?
+        true
+      end
+
+      def kind
+        "Change"
+      end
+
+      private
+
+      def diff_type
+        Color.color('CHANGE:', :change)
+      end
+    end
+  end
+end

data/lib/archimate/diff/conflict.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+module Archimate
+  module Diff
+    class Conflict
+      attr_reader :base_local_diffs
+      attr_reader :base_remote_diffs
+      attr_reader :reason
+      attr_reader :diffs
+
+      def initialize(base_local_diffs, base_remote_diffs, reason)
+        @base_local_diffs = Array(base_local_diffs)
+        @base_remote_diffs = Array(base_remote_diffs)
+        @diffs = @base_local_diffs + @base_remote_diffs
+        @reason = reason
+      end
+
+      def to_s
+        "#{Color.color('CONFLICT:', [:black, :on_red])} #{reason}\n" \
+          "\tBase->Local Diff(s):\n\t\t#{base_local_diffs.map(&:to_s).join("\n\t\t")}" \
+          "\n\tBase->Remote Diffs(s):\n\t\t#{base_remote_diffs.map(&:to_s).join("\n\t\t")}"
+      end
+
+      def ==(other)
+        other.is_a?(self.class) &&
+          base_local_diffs == other.base_local_diffs &&
+          base_remote_diffs == other.base_remote_diffs &&
+          reason == other.reason
+      end
+    end
+  end
+end

data/lib/archimate/diff/conflicts/base_conflict.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+module Archimate
+  module Diff
+    class Conflicts
+      # BaseConflict
+      # @abstract
+      class BaseConflict
+        def initialize(base_local_diffs, base_remote_diffs)
+          @base_local_diffs = base_local_diffs
+          @base_remote_diffs = base_remote_diffs
+          @associative = false
+          @diff_iterations = nil
+        end
+
+        def filter1
+          ->(_diff) { true }
+        end
+
+        def filter2
+          ->(_diff) { true }
+        end
+
+        def conflicts
+          progressbar = ProgressIndicator.new(total: diff_iterations.size, title: "Analyzing Conflicts")
+          diff_iterations.each_with_object([]) do |(md1, md2), conflicts|
+            progressbar.increment
+            conflicts.concat(
+              md1.map { |diff1| [diff1, md2.select(&method(:diff_conflicts).curry[diff1])] }
+                .reject { |_diff1, diff2| diff2.empty? }
+                .map { |diff1, diff2_ary| Conflict.new(diff1, diff2_ary, describe) }
+            )
+          end
+        ensure
+          progressbar.finish
+        end
+
+        def diff_combinations
+          combos = [@base_local_diffs, @base_remote_diffs]
+          @associative ? [combos] : combos.permutation(2)
+        end
+
+        # By default our conflict tests are not associative to we need to run
+        # [local, remote] and [remote, local] through the tests.
+        def diff_iterations
+          @diff_iterations ||=
+            diff_combinations.map do |local_diffs, remote_diffs|
+              [local_diffs.select(&filter1), remote_diffs.select(&filter2)]
+            end
+        end
+      end
+    end
+  end
+end

data/lib/archimate/diff/conflicts/deleted_items_child_updated_conflict.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+module Archimate
+  module Diff
+    class Conflicts
+      class DeletedItemsChildUpdatedConflict < BaseConflict
+        def describe
+          "Checking for Deleted items in one change set have children that are inserted or changed in the other change set"
+        end
+
+        def filter1
+          ->(diff) { diff.delete? }
+        end
+
+        def filter2
+          ->(diff) { !diff.delete? }
+        end
+
+        # TODO: This is simple, but might be slow.
+        def diff_conflicts(diff1, diff2)
+          da1 = diff1.path.split("/")
+          da2 = diff2.path.split("/")
+
+          cmp_size = [da1, da2].map(&:size).min - 1
+          return false if da2.size == cmp_size + 1
+          da1[0..cmp_size] == da2[0..cmp_size]
+        end
+      end
+    end
+  end
+end

data/lib/archimate/diff/conflicts/deleted_items_referenced_conflict.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+module Archimate
+  module Diff
+    class Conflicts
+      # DeletedItemsReferencedConflict
+      #
+      # This sort of conflict occurs when one change set has deleted an element
+      # that is referenced by id in the other change set.
+      #
+      # For example:
+      #
+      # In the local change set, an element with id "abc123" is deleted.
+      # In the remote change set, a child is inserted into a diagram with
+      # archimate_element = "abc123". These two changes are in conflict.
+      class DeletedItemsReferencedConflict < BaseConflict
+        using DataModel::DiffableArray
+        using DataModel::DiffablePrimitive
+
+        def describe
+          "Checking for Deleted items in one change set are referenced in the other change set"
+        end
+
+        # Filters a changeset to potentially conflicting diffs (making the set
+        # of combinations to check smaller)
+        #
+        # @return [lambda] a filter to limit diffs to Delete type
+        def filter1
+          ->(diff) { diff.delete? && diff.target.value.is_a?(DataModel::Referenceable) }
+        end
+
+        # Filters a changeset to potentially conflicting diffs (making the set
+        # of combinations to check smaller)
+        #
+        # @return [lambda] a filter to limit diffs to other
+        #   than Delete type
+        def filter2
+          ->(diff) { !diff.delete? }
+        end
+
+        # Determine the set of conflicts between the given diffs
+        # def conflicts
+        #   progressbar = ProgressIndicator.new(total: diff_iterations.size)
+        #   diff_iterations.each_with_object([]) do |(md1, md2), a|
+        #     progressbar.increment
+        #     a.concat(
+        #       md1.map { |diff1| [diff1, md2.select(&method(:diff_conflicts).curry[diff1])] }
+        #         .reject { |_diff1, diff2| diff2.empty? }
+        #         .map { |diff1, diff2_ary| Conflict.new(diff1, diff2_ary, describe) }
+        #     )
+        #   end
+        # ensure
+        #   progressbar&.finish
+        # end
+
+        # TODO: This is simple, but might be slow. If it is, then override
+        # the conflicts method to prevent calculating referenced_identified_nodes methods
+        def diff_conflicts(diff1, diff2)
+          diff2.target.value.referenced_identified_nodes.include?(diff1.target.value.id)
+        end
+      end
+    end
+  end
+end