dyph 0.6.0

data/lib/dyph/outcome.rb

@@ -0,0 +1,12 @@
+module Dyph
+  class Outcome
+    def resolved?
+      self.class == Outcome::Resolved
+    end
+
+    def conflicted?
+      self.class == Outcome::Conflicted
+    end
+
+  end
+end

data/lib/dyph/outcome/conflicted.rb

@@ -0,0 +1,27 @@
+module Dyph
+  class Outcome::Conflicted < Outcome
+    attr_reader :left, :right, :base
+    def initialize(left:, base:, right:)
+      @left   = left
+      @base   = base
+      @right  = right
+    end
+
+    def ==(other)
+      self.class == other.class &&
+      self.left == other.left &&
+      self.base == other.base &&
+      self.right == other.right
+    end
+
+    alias_method :eql?, :==
+
+    def hash
+      self.left.hash ^ self.base.hash ^ self.right.hash
+    end
+
+    def apply(fun)
+       self.class.new(left: fun[@left], base: fun[@base], right: fun[@right])
+    end
+  end
+end

data/lib/dyph/outcome/resolved.rb

@@ -0,0 +1,33 @@
+module Dyph
+  class Outcome::Resolved < Outcome
+    attr_reader :result
+    def initialize(result)
+      @result = result
+      @combiner = ->(x, y) { x + y }
+    end
+
+    def set_combiner(lambda)
+      @combiner = lambda
+    end
+
+    def ==(other)
+      self.class == other.class &&
+      self.result == other.result
+    end
+
+    alias_method :eql?, :==
+
+    def hash
+      self.result.hash
+    end
+
+    def combine(other)
+       @result = @combiner[@result, other.result]
+       self
+    end
+
+    def apply(fun)
+       Outcome::Resolved.new(fun[result])
+    end
+  end
+end

data/lib/dyph/support/assign_action.rb

@@ -0,0 +1,18 @@
+module Dyph
+  module Support
+    module AssignAction
+      extend self
+      def self.get_action(lo_a:, lo_b:, hi_a:, hi_b:)
+        if lo_a <= hi_a && lo_b <= hi_b # for this change, the bounds are both 'normal'.  the beginning of the change is before the end.
+          [:change, lo_a + 1, hi_a + 1, lo_b + 1, hi_b + 1]
+        elsif lo_a <= hi_a
+          [:delete, lo_a + 1, hi_a + 1, lo_b + 1, lo_b]
+        elsif lo_b <= hi_b
+          [:add, lo_a + 1, lo_a, lo_b + 1, hi_b + 1]
+        else
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/dyph/support/collater.rb

@@ -0,0 +1,33 @@
+module Dyph
+  module Support
+    module Collater
+      extend self
+      def collate_merge(merge_result, join_function, conflict_handler)
+        if merge_result.empty?
+          Dyph::MergeResult.new([Outcome::Resolved.new([])], join_function)
+        else
+          merge_result = combine_non_conflicts(merge_result)
+          if (merge_result.length == 1 && merge_result.first.resolved?)
+            Dyph::MergeResult.new(merge_result, join_function)
+          else
+            Dyph::MergeResult.new(merge_result, join_function, conflict: true, conflict_handler: conflict_handler)
+          end
+        end
+      end
+
+      private
+        # @param [in] results
+        # @return the list of conflicts with contiguous parts merged if they are non_conflicts
+        def combine_non_conflicts(results)
+          results.reduce([]) do |rs, r|
+            if rs.any? && rs.last.resolved? && r.resolved?
+              rs.last.combine(r)
+            else
+              rs << r
+            end
+            rs
+          end
+        end
+    end
+  end
+end

data/lib/dyph/support/diff3.rb

@@ -0,0 +1,155 @@
+module Dyph
+  module Support
+
+    class Diff3
+      def self.execute_diff(left, base, right, diff2)
+        Diff3.new(left, base, right, diff2).get_differences
+      end
+
+      def initialize(left, base, right, diff2)
+        @left   = left
+        @right  = right
+        @base   = base
+        @diff2 = diff2
+      end
+
+      def get_differences
+        #[[action, base_lo, base_hi, side_lo, side_hi]...]
+        left_diff  = @diff2.diff(@base, @left).map { |r| Diff2Command.new(*r) }
+        right_diff = @diff2.diff(@base, @right).map { |r| Diff2Command.new(*r) }
+        collapse_differences(DiffDoubleQueue.new(left_diff, right_diff))
+      end
+
+      Diff2Command = Struct.new(:code, :base_lo, :base_hi, :side_lo, :side_hi)
+
+      private
+
+        def collapse_differences(diffs_queue, differences=[])
+          if diffs_queue.finished?
+            differences
+          else
+            result_queue   = DiffDoubleQueue.new
+            init_side =  diffs_queue.choose_side
+            top_diff   =  diffs_queue.dequeue
+
+            result_queue.enqueue(init_side, top_diff)
+
+            diffs_queue.switch_sides
+            build_result_queue(diffs_queue, top_diff.base_hi, result_queue)
+
+            differences << determine_differnce(result_queue, init_side, diffs_queue.switch_sides)
+            collapse_differences(diffs_queue, differences)
+          end
+        end
+
+        def build_result_queue(diffs_queue, prev_base_hi, result_queue)
+          #current side can be :left or :right
+          if queue_finished?(diffs_queue.peek, prev_base_hi)
+            result_queue
+          else
+            top_diff = diffs_queue.dequeue
+            result_queue.enqueue(diffs_queue.current_side, top_diff)
+
+            if prev_base_hi < top_diff.base_hi
+              #switch the current side and adjust the base_hi
+              diffs_queue.switch_sides
+              build_result_queue(diffs_queue, top_diff.base_hi, result_queue)
+            else
+              build_result_queue(diffs_queue, prev_base_hi, result_queue)
+            end
+          end
+        end
+
+        def queue_finished?(queue, prev_base_hi)
+          queue.empty? || queue.first.base_lo > prev_base_hi + 1
+        end
+
+        def determine_differnce(diff_diffs_queue, init_side, final_side)
+          base_lo = diff_diffs_queue.get(init_side).first.base_lo
+          base_hi = diff_diffs_queue.get(final_side).last.base_hi
+#          puts "Beta base_lo #{base_lo} base_hi #{base_hi}"
+          left_lo,  left_hi    = diffable_endpoints(diff_diffs_queue.get(:left), base_lo, base_hi)
+          right_lo, right_hi   = diffable_endpoints(diff_diffs_queue.get(:right), base_lo, base_hi)
+
+          #the endpoints are offset one, neet to account for that in getting subsets
+          left_subset = @left[left_lo-1 .. left_hi]
+          right_subset = @right[right_lo-1 .. right_hi]
+          change_type = decide_action(diff_diffs_queue, left_subset, right_subset)
+          [change_type, left_lo, left_hi, right_lo, right_hi, base_lo, base_hi]
+        end
+
+        def diffable_endpoints(command, base_lo, base_hi)
+          if command.any?
+            lo = command.first.side_lo - command.first.base_lo +  base_lo
+            hi = command.last.side_hi  - command.last.base_hi  + base_hi
+            [lo, hi]
+          else
+            [base_lo,  base_hi]
+          end
+        end
+
+        def decide_action(diff_diffs_queue, left_subset, right_subset)
+          #adjust because the ranges are 1 indexed
+
+          if diff_diffs_queue.empty?(:left)
+            :choose_right
+          elsif diff_diffs_queue.empty?(:right)
+            :choose_left
+          else
+            if left_subset != right_subset
+              :possible_conflict
+            else
+              :no_conflict_found
+            end
+          end
+        end
+    end
+
+    class DiffDoubleQueue
+      attr_reader :current_side
+      def initialize(left=[], right=[])
+        @diffs = { left: left, right: right }
+      end
+
+      def dequeue(side=current_side)
+        @diffs[side].shift
+      end
+
+      def peek(side=current_side)
+        @diffs[side]
+      end
+
+      def finished?
+        empty?(:left) && empty?(:right)
+      end
+
+      def enqueue(side=current_side, val)
+        @diffs[side] << val
+      end
+
+      def get(side=current_side)
+        @diffs[side]
+      end
+
+      def empty?(side=current_side)
+        @diffs[side].empty?
+      end
+
+      def switch_sides(side=current_side)
+        @current_side = side == :left ? :right : :left
+      end
+
+      def choose_side
+        if empty? :left
+          @current_side = :right
+        elsif empty? :right
+          @current_side = :left
+        else
+          #choose the lowest side relative to base
+          @current_side = get(:left).first.base_lo <= get(:right).first.base_lo ? :left : :right
+        end
+      end
+    end
+
+  end
+end

data/lib/dyph/support/merger.rb

@@ -0,0 +1,169 @@
+module Dyph
+  module Support
+    class Merger
+      attr_reader :result, :diff2
+      def self.merge(left, base, right, diff2: Dyph::Differ.default_diff2, diff3: Dyph::Differ.default_diff3)
+        merger = Merger.new(left: left, base: base, right: right, diff2: diff2, diff3: diff3)
+        merger.execute_three_way_merge()
+        merger.result
+      end
+
+      def initialize(left:, base:, right:, diff2:, diff3:)
+        @result = []
+        @diff2 = diff2
+        @diff3 = diff3
+        @text3 = Text3.new(left: left, right: right, base: base)
+      end
+
+      # rubocop:disable Metrics/AbcSize
+      def execute_three_way_merge
+        d3 = @diff3.execute_diff(@text3.left, @text3.base, @text3.right, @diff2)
+        chunk_descs = d3.map { |raw_chunk_desc| ChunkDesc.new(raw_chunk_desc) }
+        index = 1
+        chunk_descs.each do |chunk_desc|
+          initial_text = []
+
+          (index ... chunk_desc.base_lo).each do |lineno|                  # exclusive (...)
+            initial_text << @text3.base[lineno - 1]
+          end
+          #initial_text = initial_text.join("\n") + "\n"
+          #
+          @result << Dyph::Outcome::Resolved.new(initial_text) unless initial_text.empty?
+
+          interpret_chunk(chunk_desc)
+          #assign index to be the line in base after the conflict
+          index = chunk_desc.base_hi + 1
+          #
+        end
+
+        #finish by putting all text after the last conflict into the @result body.
+
+        ending_text = accumulate_lines(index, @text3.base.length, @text3.base)
+
+        @result << Dyph::Outcome::Resolved.new(ending_text) unless ending_text.empty?
+      end
+      # rubocop:enable Metrics/AbcSize
+
+      protected
+        def set_conflict(chunk_desc)
+          conflict = Dyph::Outcome::Conflicted.new(
+            left:   accumulate_lines(chunk_desc.left_lo, chunk_desc.left_hi, @text3.left),
+            base:   accumulate_lines(chunk_desc.base_lo, chunk_desc.base_hi, @text3.base),
+            right:  accumulate_lines(chunk_desc.right_lo, chunk_desc.right_hi, @text3.right)
+          )
+          @result << conflict
+        end
+
+        def determine_conflict(d, left, right)
+          ia = 1
+          d.each do |raw_chunk_desc|
+            chunk_desc = ChunkDesc.new(raw_chunk_desc)
+            (ia ... chunk_desc.left_lo).each do |lineno|
+              @result <<  Dyph::Outcome::Resolved.new(accumulate_lines(ia, lineno, right))
+            end
+
+            outcome =  determine_outcome(chunk_desc, left, right)
+            ia = chunk_desc.right_hi + 1
+            @result << outcome if outcome
+          end
+
+          final_text = accumulate_lines(ia, right.length + 1, right)
+          @result <<  Dyph::Outcome::Resolved.new(final_text) unless final_text.empty?
+        end
+
+        def determine_outcome(chunk_desc, left, right)
+          if chunk_desc.action == :change
+            Outcome::Conflicted.new(
+              left: accumulate_lines(chunk_desc.right_lo, chunk_desc.right_hi, left),
+              right: accumulate_lines(chunk_desc.left_lo, chunk_desc.left_hi, right),
+              base: []
+            )
+          elsif chunk_desc.action == :add
+            Outcome::Resolved.new(
+              accumulate_lines(chunk_desc.right_lo, chunk_desc.right_hi, left)
+            )
+          end
+        end
+
+        def set_text(orig_text, lo, hi)
+          text = [] # conflicting lines in right
+          (lo .. hi).each do |i|                   # inclusive(..)
+            text << orig_text[i - 1]
+          end
+          text
+        end
+
+        def _conflict_range(chunk_desc)
+          right = set_text(@text3.right, chunk_desc.right_lo,  chunk_desc.right_hi)
+          left =  set_text(@text3.left , chunk_desc.left_lo,   chunk_desc.left_hi)
+          d = @diff2.diff(right, left)
+          if (_assoc_range(d, :change) || _assoc_range(d, :delete)) && chunk_desc.base_lo <= chunk_desc.base_hi
+            set_conflict(chunk_desc)
+          else
+            determine_conflict(d, left, right)
+          end
+        end
+
+        def interpret_chunk(chunk_desc)
+          if chunk_desc.action == :choose_left
+            # 0 flag means choose left.  put lines chunk_desc[1] .. chunk_desc[2] into the @result body.
+            temp_text = accumulate_lines(chunk_desc.left_lo, chunk_desc.left_hi, @text3.left)
+            # they deleted it, don't use if its only a new line
+            @result <<  Dyph::Outcome::Resolved.new(temp_text) unless temp_text.empty?
+          elsif chunk_desc.action != :possible_conflict
+            # A flag means choose right.  put lines chunk_desc[3] to chunk_desc[4] into the @result body.
+            temp_text = accumulate_lines(chunk_desc.right_lo, chunk_desc.right_hi, @text3.right)
+            @result << Dyph::Outcome::Resolved.new(temp_text) unless temp_text.empty?
+          else
+            _conflict_range(chunk_desc)
+          end
+        end
+
+        # @param [in] diff        conflicts in diff structure
+        # @param [in] diff_type   type of diff looked for in diff
+        # @return diff_type if any conflicts in diff are of type diff_type.  otherwise return nil
+        def _assoc_range(diff, diff_type)
+          diff.each do |d|
+            if d[0] == diff_type
+              return d
+            end
+          end
+          nil
+        end
+
+        # @param [in] lo        indec for beginning of accumulation range
+        # @param [in] hi        index for end of accumulation range
+        # @param [in] text      array of lines of text
+        # @return a string of lines lo to high joined by new lines, with a trailing new line.
+        def accumulate_lines(lo, hi, text)
+          lines = []
+          (lo .. hi).each do |lineno|
+            lines << text[lineno - 1] unless text[lineno - 1].nil?
+          end
+          lines
+        end
+    end
+
+    class Text3
+      attr_reader :left, :right, :base
+      def initialize(left:, right:, base:)
+        @left = left
+        @right = right
+        @base = base
+      end
+    end
+
+    class ChunkDesc
+      attr_reader :action, :left_lo, :left_hi, :right_lo, :right_hi, :base_lo, :base_hi
+      def initialize(raw_chunk)
+        @action   = raw_chunk[0]
+        @left_lo  = raw_chunk[1]
+        @left_hi  = raw_chunk[2]
+        @right_lo = raw_chunk[3]
+        @right_hi = raw_chunk[4]
+        @base_lo  = raw_chunk[5]
+        @base_hi  = raw_chunk[6]
+      end
+    end
+  end
+end