dyph 0.6.0

data/lib/dyph/support/sanity_check.rb

@@ -0,0 +1,73 @@
+module Dyph
+  module Support
+    module SanityCheck
+      extend self
+
+      # rubocop:disable Metrics/AbcSize
+      def ensure_no_lost_data(left, base, right, final_result)
+        result_word_map = {}
+        final_result.each do |result_block|
+          blocks = case result_block
+            when Outcome::Resolved then result_block.result
+            when Outcome::Conflicted then [result_block.left, result_block.right].flatten
+            else raise "Unknown block type, #{result_block[:type]}"
+          end
+          count_blocks(blocks, result_word_map)
+        end
+
+        left_word_map, base_word_map, right_word_map = [left, base, right].map { |str| count_blocks(str) }
+
+        # new words are words that are in left or right, but not in base
+        new_left_words = subtract_words(left_word_map, base_word_map)
+        new_right_words = subtract_words(right_word_map, base_word_map)
+
+        # now make sure all new words are somewhere in the result
+        missing_new_left_words = subtract_words(new_left_words, result_word_map)
+        missing_new_right_words = subtract_words(new_right_words, result_word_map)
+
+        if missing_new_left_words.any? || missing_new_right_words.any?
+          raise BadMergeException.new(final_result)
+        end
+      end
+      # rubocop:enable Metrics/AbcSize
+
+      private
+        def count_blocks(blocks, hash={})
+          blocks.reduce(hash) do |map, block|
+            map[block] ||= 0
+            map[block] += 1
+            map
+          end
+        end
+
+        def subtract_words(left_map, right_map)
+          remaining_words = {}
+          
+          left_map.each do |word, count|
+            count_in_right = right_map[word] || 0
+            
+            new_count = count - count_in_right
+            remaining_words[word] = new_count if new_count > 0
+          end
+          
+          remaining_words
+        end
+    end
+
+    class BadMergeException < StandardError
+      attr_accessor :merge_result
+
+      def initialize(merge_result)
+        @merge_result = merge_result
+      end
+
+      def inspect
+        "<#{self.class}: #{merge_result}>"
+      end
+
+      def to_s
+        inspect
+      end
+    end
+  end
+end

data/lib/dyph/two_way_differs/heckel_diff.rb

@@ -0,0 +1,190 @@
+module Dyph
+  module TwoWayDiffers
+
+    class HeckelDiff
+      # Algorithm adapted from http://www.rad.upenn.edu/sbia/software/basis/apidoc/v1.2/diff3_8py_source.html
+
+      def self.execute_diff(old_text_array, new_text_array)
+        raise ArgumentError, "Argument is not an array." unless old_text_array.is_a?(Array) && new_text_array.is_a?(Array)
+        diff_result = diff(old_text_array, new_text_array)
+        # convert to typed differ's output (wrapped with change types eg. Add, Delete, Change)
+        HeckelDiffWrapper.new(old_text_array, new_text_array, diff_result).convert_to_typed_ouput
+      end
+
+      # Two-way diff based on the algorithm by P. Heckel.
+      # @param [in] left Array of anything implementing hash and equals
+      # @param [in] right Array of anything implementing hash and equals
+      def self.diff(left, right)
+        differ = HeckelDiff.new(left,right)
+        differ.perform_diff
+      end
+
+      def initialize(left, right)
+        @left = left
+        @right = right
+      end
+
+      def perform_diff
+        unique_positions = identify_unique_postions
+        unique_positions.sort!{ |a, b| a[0] <=> b[0] }    # sort by the line in which the line was found in a
+        left_change_pos, right_change_pos = find_next_change
+        init_changes = ChangeData.new(left_change_pos, right_change_pos, [])
+        final_changes = unique_positions.reduce(init_changes, &method(:get_differences))
+        final_changes.change_ranges
+      end
+
+      ChangeData = Struct.new(:left_change_pos, :right_change_pos, :change_ranges)
+
+      private
+
+        def get_differences(change_data, unique_positions)
+          left_pos, right_pos = change_data.left_change_pos, change_data.right_change_pos
+          left_uniq_pos, right_uniq_pos = unique_positions
+          if left_uniq_pos < left_pos || right_uniq_pos < right_pos
+            change_data
+          else
+            left_lo, left_hi, right_lo, right_hi  = find_prev_change(left_pos, right_pos, left_uniq_pos-1, right_uniq_pos-1)
+            next_left_pos, next_right_pos         = find_next_change(left_uniq_pos+1, right_uniq_pos+1)
+
+            updated_ranges = append_change_range(change_data.change_ranges, left_lo, left_hi, right_lo, right_hi)
+            ChangeData.new(next_left_pos, next_right_pos, updated_ranges)
+          end
+        end
+
+        def find_next_change(left_start_pos=0, right_start_pos=0)
+          l_arr, r_arr = (@left[left_start_pos..-1] || []), (@right[right_start_pos..-1] || [])
+          offset = mismatch_offset l_arr, r_arr
+          [ left_start_pos + offset, right_start_pos + offset]
+        end
+
+
+        def find_prev_change(left_lo, right_lo, left_hi, right_hi)
+          if left_lo > left_hi || right_lo > right_hi
+            [left_lo, left_hi, right_lo, right_hi]
+          else
+            l_arr, r_arr = (@left[left_lo .. left_hi].reverse || []), (@right[right_lo .. right_hi].reverse || [])
+            offset = mismatch_offset l_arr, r_arr
+            [left_lo, left_hi - offset, right_lo, right_hi - offset]
+          end
+        end
+
+        def mismatch_offset(l_arr, r_arr)
+          _ , index  = l_arr.zip(r_arr).each_with_index.detect { |pair, _| pair[0] != pair[1] }
+          index || [l_arr.length, r_arr.length].min
+        end
+
+        def identify_unique_postions
+          left_uniques =   find_unique(@left)
+          right_uniques =  find_unique(@right)
+          shared_keys = left_uniques.keys & right_uniques.keys
+          uniq_ranges = shared_keys.map { |k| [left_uniques[k], right_uniques[k]] }
+          uniq_ranges.unshift([ @left.length, @right.length])
+        end
+
+        def find_unique(array)
+          flagged_uniques = array.each_with_index.reduce({}) do |hash, item_index|
+            item, pos = item_index
+            hash[item] = {pos: pos, unique: hash[item].nil?}
+            hash
+          end
+          flagged_uniques.select { |_, v| v[:unique] }.map { |k, v| [k, v[:pos]] }.to_h
+        end
+
+        # given the calculated bounds of the 2 way diff, create the proper change type and add it to the queue.
+        def append_change_range(changes_ranges, left_lo, left_hi, right_lo, right_hi)
+          if left_lo <= left_hi && right_lo <= right_hi # for this change, the bounds are both 'normal'.  the beginning of the change is before the end.
+            changes_ranges << [:change, left_lo + 1, left_hi + 1, right_lo + 1, right_hi + 1]
+          elsif left_lo <= left_hi
+            changes_ranges << [:delete, left_lo + 1, left_hi + 1, right_lo + 1, right_lo]
+          elsif right_lo <= right_hi
+            changes_ranges << [:add, left_lo + 1, left_lo, right_lo + 1, right_hi + 1]
+          end
+          changes_ranges
+        end
+    end
+
+    class TextNode
+      attr_accessor :text, :row
+
+      def initialize(text:, row:)
+        @text = text
+        @row  = row
+      end
+    end
+
+    class TwoWayChunk
+      attr_reader :action, :left_lo, :left_hi, :right_lo, :right_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]
+      end
+    end
+    class HeckelDiffWrapper
+      def initialize(old_text_array, new_text_array, heckel_diff)
+        @chunks = heckel_diff.map { |block| TwoWayChunk.new(block) }
+        @old_text_array = old_text_array
+        @new_text_array = new_text_array
+        @old_text = []
+        @new_text = []
+      end
+      IndexTracker = Struct.new(:old_index, :new_index)
+
+      def convert_to_typed_ouput()
+        final_indexes = @chunks.reduce(IndexTracker.new(0,0)) do |index_tracker, chunk|
+          old_iteration, new_iteration = set_text_node_indexes(chunk, index_tracker.old_index, index_tracker.new_index)
+          old_index, new_index = append_changes(chunk, index_tracker.old_index + old_iteration, index_tracker.new_index + new_iteration)
+          IndexTracker.new(old_index, new_index)
+        end
+
+        set_the_remaining_text_node_indexes(final_indexes.old_index, final_indexes.new_index)
+        { old_text: @old_text, new_text: @new_text}
+      end
+
+      private
+        def set_text_node_indexes(chunk, old_index, new_index)
+          old_iteration = 0
+          while old_index + old_iteration < chunk.left_lo - 1     # chunk indexes are from 1
+            @old_text << TextNode.new(text: @old_text_array[old_index + old_iteration], row: new_index + old_iteration)
+            old_iteration += 1
+          end
+
+          new_iteration = 0
+          while new_index + new_iteration < chunk.right_lo - 1     # chunk indexes are from 1
+            @new_text << TextNode.new(text: @new_text_array[new_index + new_iteration], row: old_index + new_iteration)
+            new_iteration += 1
+          end
+          [old_iteration, new_iteration]
+        end
+
+        def append_changes(chunk, old_index, new_index)
+          while old_index <= chunk.left_hi - 1     # chunk indexes are from 1
+            @old_text << @old_text_array[old_index]
+            old_index += 1
+          end
+
+          while new_index <= chunk.right_hi - 1     # chunk indexes are from 1
+            @new_text << @new_text_array[new_index]
+            new_index += 1
+          end
+          [old_index, new_index]
+        end
+
+        def set_the_remaining_text_node_indexes(old_index, new_index)
+          iteration = 0
+          while old_index + iteration < @old_text_array.length
+            @old_text << TextNode.new(text: @old_text_array[old_index + iteration], row: new_index + iteration)
+            iteration += 1
+          end
+
+          iteration = 0
+          while new_index + iteration < @new_text_array.length
+            @new_text << TextNode.new(text: @new_text_array[new_index + iteration], row: old_index + iteration)
+            iteration += 1
+          end
+        end
+    end
+  end
+end

data/lib/dyph/two_way_differs/output_converter.rb

@@ -0,0 +1,179 @@
+module Dyph
+  module TwoWayDiffers
+    # rubocop:disable Metrics/ModuleLength
+    module OutputConverter
+      extend self
+
+      def convert_to_dyph_output(old_text, new_text)
+        actions =  merge_and_partition(old_text, new_text)
+        selected_actions = extract_add_deletes_changes(actions)
+        correct_offsets(selected_actions)
+      end
+
+      def objectify(merge_results)
+        merge_results.map do |result|
+          action = result[:action]
+          line   = result[:line]
+          old_index = result[:old_index]
+          new_index = result[:new_index]
+
+          case action
+          when :add
+            Dyph::Action::Add.new(value: line, old_index: old_index, new_index: new_index)
+          when :delete
+            Dyph::Action::Delete.new(value: line, old_index: old_index, new_index: new_index)
+          when :no_change
+            Dyph::Action::NoChange.new(value: line.text, old_index: old_index, new_index: new_index)
+          else
+            raise "unhandled action"
+          end
+        end
+      end
+
+      def merge_results(old_text, new_text)
+        merged_text = []
+
+        if (new_text.empty?)
+          no_new_text(old_text, merged_text)
+        else
+          prepend_old_text(old_text, merged_text)
+          gather_up_actions(old_text, new_text, merged_text)
+        end
+        merged_text
+      end
+
+      private
+        def merge_and_partition(old_text, new_text)
+          merged_text = merge_results(old_text, new_text)
+          merge_output_lines = merged_text.map { |x| to_output_format x }
+          partition_into_actions(merge_output_lines)
+        end
+
+        def extract_add_deletes_changes(actions)
+          collapsed_actions = actions.map { |action| collapse_action(action) }
+          paired_results = pair_up_add_deletes collapsed_actions
+          paired_results.reject { |res| res[:action] == :no_change}
+        end
+
+        def correct_offsets(selected_actions)
+          fix_offsets = set_offset(selected_actions)
+          fix_offsets.map { |r| Dyph::Support::AssignAction.get_action(
+            lo_a: r[:old_lo]-1 ,
+            lo_b: r[:new_lo]-1,
+            hi_a: r[:old_hi]-1,
+            hi_b: r[:new_hi]-1
+          )}
+        end
+
+        def gather_up_actions(old_text, new_text, merged_text)
+          prev_no_change_old = - 1
+          new_text.map.with_index.each do |line, i|
+            if !line.is_a?(TextNode)
+              merged_text << {action: :add, line: line, old_index: prev_no_change_old + 1, new_index: i+1}
+            else
+              prev_no_change_old = line.row
+              change_or_delete(old_text, line, prev_no_change_old, merged_text, i)
+            end
+          end
+        end
+
+        def change_or_delete(old_text, line, prev_no_change_old, merged_text, index)
+          merged_text << {action: :no_change, line: line, old_index: line.row, new_index: index}
+
+          ((prev_no_change_old+1) ... old_text.length).each do |n|
+            break if old_text[n].is_a?(TextNode)
+            merged_text << {action: :delete, line: old_text[n], old_index: n+1, new_index: index+1}
+          end
+        end
+
+        def prepend_old_text(old_text, merged_text)
+          if !old_text.first.is_a?(TextNode)
+            old_text.map.with_index.each do |line, i|
+              break if line.is_a?(TextNode)
+              merged_text << {action: :delete, line: line, old_index:i+1, new_index: i}
+            end
+          end
+        end
+
+        def no_new_text(old_text, merged_text)
+          old_text.map.with_index do |line, i|
+            merged_text << { action: :delete, line: line, old_index: i+1, new_index: i}
+          end
+        end
+
+        def set_offset(results)
+          results.map do |result_row|
+            if result_row[:action] == :add
+              result_row[:old_lo] += 1
+              result_row
+            elsif result_row[:action] == :delete
+              result_row[:new_lo] += 1
+              result_row
+            else
+              result_row
+            end
+          end
+        end
+
+        def to_output_format(result_row)
+          {
+            action: result_row[:action],
+            old_lo: result_row[:old_index],
+            old_hi: result_row[:old_index],
+            new_lo: result_row[:new_index],
+            new_hi: result_row[:new_index]
+          }
+        end
+
+        def collapse_action(actions)
+          actions.inject({}) do | hash, action |
+            hash[:action] ||= action[:action]
+            hash[:old_lo] ||= action[:old_lo]
+            hash[:old_hi] =   action[:old_hi]
+            hash[:new_lo] ||= action[:new_lo]
+            hash[:new_hi] =   action[:new_hi]
+            hash
+          end
+        end
+
+        def is_a_pair?(actions, i)
+          action_one =  actions[i-1][:action] if actions[i-1]
+          action_two =  actions[i][:action]   if actions[i]
+          Set.new([action_one, action_two]) == Set.new([:add, :delete])
+        end
+
+        def pair_up_add_deletes(actions)
+          results = []
+          found_change = false
+          (1 .. actions.length).each do |i|
+            if is_a_pair?(actions, i)
+              results << {
+                action: :change,
+                old_lo: actions[i-1][:old_lo],
+                old_hi: actions[i-1][:old_hi],
+                new_lo: actions[i][:new_lo],
+                new_hi: actions[i][:new_hi]
+              }
+              found_change = true
+            elsif found_change
+              found_change = false
+            else
+              results << actions[i-1]
+            end
+          end
+          results
+        end
+
+        def partition_into_actions(array)
+          array.inject([]) do |acc, x|
+            if acc.length == 0 || acc.last.last[:action] != x[:action]
+              acc << [x]
+            else
+              acc.last << x
+            end
+            acc
+          end
+        end
+    end
+  end
+end

data/lib/dyph/version.rb

@@ -0,0 +1,3 @@
+module Dyph
+  VERSION = "0.6.0"
+end

metadata

@@ -0,0 +1,220 @@
+--- !ruby/object:Gem::Specification
+name: dyph
+version: !ruby/object:Gem::Version
+  version: 0.6.0
+platform: ruby
+authors:
+- Kevin Mook
+- Andrew Montalto
+- Jacob Elder
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2020-09-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-rescue
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-stack_explorer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.3.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.3.0
+- !ruby/object:Gem::Dependency
+  name: awesome_print
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: factory_girl
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec_junit_formatter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: faker
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A library of useful diffing algorithms for Ruby
+email:
+- kevin@kevinmook.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/dyph.rb
+- lib/dyph/action.rb
+- lib/dyph/action/add.rb
+- lib/dyph/action/delete.rb
+- lib/dyph/action/no_change.rb
+- lib/dyph/differ.rb
+- lib/dyph/equatable.rb
+- lib/dyph/merge_result.rb
+- lib/dyph/outcome.rb
+- lib/dyph/outcome/conflicted.rb
+- lib/dyph/outcome/resolved.rb
+- lib/dyph/support/assign_action.rb
+- lib/dyph/support/collater.rb
+- lib/dyph/support/diff3.rb
+- lib/dyph/support/merger.rb
+- lib/dyph/support/sanity_check.rb
+- lib/dyph/two_way_differs/heckel_diff.rb
+- lib/dyph/two_way_differs/output_converter.rb
+- lib/dyph/version.rb
+homepage: https://github.com/kevinmookorg/dyph
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key:
+specification_version: 4
+summary: A library of useful diffing algorithms for Ruby
+test_files: []