archimate 1.1.1 → 1.2.1

data/lib/archimate/diff/change.rb

@@ -1,49 +0,0 @@
-# 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

@@ -1,31 +0,0 @@
-# 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.rb

@@ -1,89 +0,0 @@
-# frozen_string_literal: true
-
-require 'forwardable'
-require 'parallel'
-require 'archimate/diff/conflicts/base_conflict'
-require 'archimate/diff/conflicts/deleted_items_child_updated_conflict'
-require 'archimate/diff/conflicts/deleted_items_referenced_conflict'
-require 'archimate/diff/conflicts/path_conflict'
-
-module Archimate
-  module Diff
-    class Conflicts
-      extend Forwardable
-
-      attr_reader :base_local_diffs
-      attr_reader :base_remote_diffs
-
-      def_delegator :@conflicts, :empty?
-      def_delegator :@conflicts, :size
-      def_delegator :@conflicts, :first
-      def_delegator :@conflicts, :map
-      def_delegator :@conflicts, :each
-
-      include Archimate::Logging
-
-      def initialize(base_local_diffs, base_remote_diffs)
-        @base_local_diffs = base_local_diffs
-        @base_remote_diffs = base_remote_diffs
-        @conflict_finders = [PathConflict, DeletedItemsChildUpdatedConflict, DeletedItemsReferencedConflict]
-        @conflicts = nil
-        @conflicting_diffs = nil
-        @unconflicted_diffs = nil
-        # TODO: consider making this an argument
-        @conflict_resolver = Cli::ConflictResolver.new
-      end
-
-      # TODO: refactor this method elsewhere
-      # resolve iterates through the set of conflicting diffs asking the user
-      # (if running interactively) and return the set of diffs that can be applied.
-      #
-      # To keep diffs reasonably human readable in logs, the local diffs should
-      # be applied first followed by the remote diffs.
-      def resolve
-        debug do
-          <<~MSG
-            Filtering out #{conflicts.size} conflicts from #{base_local_diffs.size + base_remote_diffs.size} diffs
-            Remaining diffs #{unconflicted_diffs.size}
-          MSG
-        end
-
-        conflicts.each_with_object(unconflicted_diffs) do |conflict, diffs|
-          # TODO: this will result in diffs being out of order from their
-          # original order. diffs should be flagged as conflicted and
-          # this method should instead remove the conflicted flag.
-          diffs.concat(@conflict_resolver.resolve(conflict))
-          # TODO: if the conflict is resolved, it should be removed from the
-          # @conflicts array.
-        end
-      end
-
-      def conflicts
-        @conflicts ||= find_conflicts
-      end
-
-      def conflicting_diffs
-        @conflicting_diffs ||= conflicts.map(&:diffs).flatten
-      end
-
-      def unconflicted_diffs
-        @unconflicted_diffs ||=
-          (base_local_diffs + base_remote_diffs) - conflicting_diffs
-      end
-
-      def to_s
-        "Conflicts:\n\n#{conflicts.map(&:to_s).join("\n\n")}\n"
-      end
-
-      private
-
-      def find_conflicts
-        # TODO: Running this in parallel breaks currently.
-        # @conflicts = Parallel.map(@conflict_finders, in_processes: 3) { |cf_class|
-        @conflicts = @conflict_finders.map { |cf_class|
-          cf_class.new(base_local_diffs, base_remote_diffs).conflicts
-        }.flatten
-      end
-    end
-  end
-end

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

@@ -1,53 +0,0 @@
-# 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

@@ -1,30 +0,0 @@
-# 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

@@ -1,63 +0,0 @@
-# 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

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

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-module Archimate
-  module Diff
-    class Conflicts
-      class PathConflict < BaseConflict
-        def initialize(base_local_diffs, base_remote_diffs)
-          super
-          @associative = true
-        end
-
-        def describe
-          "Checking for Differences in one change set that conflict with changes in other change set at the same path"
-        end
-
-        def diff_conflicts(diff1, diff2)
-          same_path_but_diff(diff1, diff2) && in_conflict?(diff1, diff2)
-        end
-
-        private
-
-        def same_path_but_diff(a, b)
-          a.path == b.path && a != b
-        end
-
-        # I'm in conflict if:
-        # 1. ld and rd are both changes to the same path (but not the same change)
-        # 2. one is a change, the other a delete and changed_from is the same
-        # 3. both are inserts of the different identifyable nodes with the same id
-        #
-        # If I'm not an identifyable node and my parent is an array, then two inserts are ok
-        def in_conflict?(local_diff, remote_diff)
-          return true if
-            local_diff.target.parent.is_a?(Array) &&
-            local_diff.target.value.is_a?(DataModel::Referenceable) &&
-            local_diff.target.value.id == remote_diff.target.value.id &&
-            local_diff != remote_diff
-
-          case [local_diff, remote_diff].map { |d| d.class.name.split('::').last }.sort
-          when %w(Change Change)
-            local_diff.changed_from.value == remote_diff.changed_from.value &&
-              local_diff.target.value != remote_diff.target.value
-          when %w(Change Delete)
-            true
-          else
-            false
-          end
-        end
-      end
-    end
-  end
-end

data/lib/archimate/diff/delete.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-module Archimate
-  module Diff
-    class Delete < Difference
-      using DataModel::DiffablePrimitive
-      using DataModel::DiffableArray
-
-      # Create a new Delete difference
-      #
-      # @param target [ArchimateNodeReference] Element that was deleted
-      def initialize(target)
-        super
-      end
-
-      def to_s
-        # Note - the explicit to_s is required to access the DiffableArray
-        #        implementation if the parent is an Array.
-        "#{diff_type} #{target} from #{target.parent.to_s}"
-      end
-
-      def apply(el)
-        target.delete(el)
-        el
-      end
-
-      def delete?
-        true
-      end
-
-      def kind
-        "Delete"
-      end
-
-      private
-
-      def diff_type
-        Color.color('DELETE:', :delete)
-      end
-    end
-  end
-end

data/lib/archimate/diff/difference.rb

@@ -1,113 +0,0 @@
-# frozen_string_literal: true
-
-require "forwardable"
-
-module Archimate
-  module Diff
-    class Difference
-      using DataModel::DiffableArray
-      using DataModel::DiffablePrimitive
-      extend Forwardable
-
-      ARRAY_RE = Regexp.compile(/\[(\d+)\]/)
-      PATH_ROOT_SORT_ORDER = %w[elements relationships diagrams organizations].freeze
-
-      # delete: something responds to parent, child attribute (which is thing deleted - and could be sym for archimate nodes or index for array), value
-      # insert: something responds to parent, child attribute (or index), value, after value (to help with inserts)
-      # change: something responds to parent, child attribute (or index), value, changed from value
-      # move: something responds to parent, child index, value, after value) move after a particular value
-      attr_reader :target
-      attr_reader :changed_from
-
-      def_delegator :@target, :path
-
-      # Re-thinking.
-      #
-      # Requirements:
-      #
-      # 1. User friendly display of what is different in context
-      # 2. Able to apply the diff to another model (which was based on the "base" of the diff)
-      #
-      # Delete:                         example
-      #   ArchimateNode                 child.bounds
-      #   ArchimateNode, attribute      model, "name"
-      #   DiffableArray, ArchimateNode  model.elements, element
-      #   bendpoint attributes under connection
-      #                                 documentation
-      #                                 properties
-      #                                 child/style/fill_color
-      #                                 child/style/font/name
-      #
-      # @param target [Dry::Struct with id attribute] the element operated on (why is array treated as a special case?)
-      # @param changed_from [same class as target] (optional) for change this is the previous value
-      # def initialize(changed_from, target)
-      def initialize(target, changed_from = nil)
-        # raise TypeError, "Expected target to be an ArchimateNodeReference" unless target.is_a?(ArchimateNodeReference)
-        @target = target
-        @changed_from = changed_from
-      end
-
-      def ==(other)
-        other.is_a?(self.class) &&
-          @target == other.target &&
-          @changed_from == other.changed_from
-      end
-
-      # Difference sorting is based on the path.
-      # Top level components are sorted in this order: (elements, relationships, diagrams, organizations)
-      # Array entries are sorted by numeric order
-      # Others are sorted alphabetically
-      # TODO: this isn't complete
-      def <=>(other)
-        a = path_to_array
-        b = other.path_to_array
-
-        part_a = a.shift
-        part_b = b.shift
-        res = PATH_ROOT_SORT_ORDER.index(part_a) <=> PATH_ROOT_SORT_ORDER.index(part_b)
-        return res unless res.zero?
-
-        until a.empty? || b.empty?
-          part_a = a.shift
-          part_b = b.shift
-
-          return part_a <=> part_b unless (part_a <=> part_b).zero?
-        end
-
-        return -1 if a.empty?
-        return 1 if b.empty?
-        part_a <=> part_b
-      end
-
-      def delete?
-        false
-      end
-
-      def change?
-        false
-      end
-
-      def insert?
-        false
-      end
-
-      def move?
-        false
-      end
-
-      def path_to_array
-        path(force_array_index: :index).split("/").map do |p|
-          md = ARRAY_RE.match(p)
-          md ? md[1].to_i : p
-        end
-      end
-
-      def summary_element
-        summary_elements = [DataModel::Element, DataModel::Organization, DataModel::Relationship, DataModel::Diagram, DataModel::Model]
-        se = target.value.primitive? ? target.parent : target.value
-        se = se.parent while summary_elements.none? { |c| se.is_a?(c) }
-        se
-      end
-    end
-  end
-end