archimate-diff 0.1.0

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

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

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

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

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

data/lib/archimate/diff/insert.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+module Archimate
+  module Diff
+    class Insert < Difference
+      using DataModel::DiffableArray
+
+      # Create a new Insert difference
+      #
+      # @param inserted_element [Archimate::DataModel::ArchimateNode] Element
+      #   that was inserted
+      # @param sub_path [str] Path under inserted_element for primitive values
+      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} into #{target.parent.to_s}"
+      end
+
+      def apply(to_model)
+        throw TypeError, "Expected a Archimate::DataModel::Model, was a #{to_model.class}" unless to_model.is_a?(DataModel::Model)
+        target.insert(to_model)
+        to_model
+      end
+
+      def insert?
+        true
+      end
+
+      def kind
+        "Insert"
+      end
+
+      private
+
+      def diff_type
+        Color.color('INSERT:', :insert)
+      end
+    end
+  end
+end

data/lib/archimate/diff/merge.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require "parallel"
+
+module Archimate
+  module Diff
+    class Merge
+      include Archimate::Logging
+      using DataModel::DiffableArray
+
+      def three_way(base, local, remote)
+        debug { "Computing base:local & base:remote diffs" }
+        base_local_diffs, base_remote_diffs = Parallel.map([[base, local], [base, remote]],
+          in_processes: 2) do |base_model, other_model|
+          base_model.diff(other_model)
+        end
+
+        debug "Finding Conflicts in #{base_local_diffs.size + base_remote_diffs.size} diffs"
+        conflicts = Conflicts.new(base_local_diffs, base_remote_diffs)
+        resolved_diffs = conflicts.resolve
+
+        [apply_diffs(resolved_diffs, base.clone), conflicts]
+      end
+
+      # Applies the set of diffs to the model returning a
+      # new model with the diffs applied.
+      def apply_diffs(diffs, model)
+        debug { "Applying #{diffs.size} diffs" }
+        progressbar = ProgressIndicator.new(total: diffs.size, title: "Applying diffs")
+        diffs
+          .inject(model) do |model_a, diff|
+            progressbar.increment
+            diff.apply(model_a)
+          end
+          .rebuild_index
+          .organize
+      ensure
+        progressbar&.finish
+      end
+
+      # # TODO: not currently used
+      # def find_merged_duplicates
+      #   [@base_local_diffs, @base_remote_diffs].map do |diffs|
+      #     deleted_element_diffs = diffs.select(&:delete?).select(&:element?)
+      #     deleted_element_diffs.each_with_object({}) do |diff, a|
+      #       element = diff.from_model.elements[diff.element_idx]
+      #       found = diff.from_model.elements.select do |el|
+      #         el != element && el.type == element.type && el.name == element.name
+      #       end
+      #       next if found.empty?
+      #       a[diff] = found
+      #       debug { "\nFound potential de-duplication:" }
+      #       debug { "\t#{diff}" }
+      #       debug { "Might be replaced with:\n\t#{found.map(&:to_s).join(" }\n\t")}\n\n"
+      #     end
+      #   end
+      # end
+
+      # # TODO: not currently used
+      # def filter_path_conflicts(diffs)
+      #   diffs.sort { |a, b| a.path_to_array.size <=> b.path_to_array.size }.each_with_object([]) do |i, e|
+      #     diffs.delete(i)
+      #     path_conflicts = diffs.select { |d| d.path.start_with?(i.path) }
+      #     path_conflicts.each { |d| diffs.delete(d) }
+      #     e << i
+      #   end
+      # end
+    end
+  end
+end