diff-lcs 2.0.0.beta.1 → 2.0.0.beta.2

data/test/test_change.rb

@@ -0,0 +1,234 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class TestChange < Minitest::Test
+  def test_invalid_change
+    assert_raises RuntimeError, /Invalid CHange Action/ do
+      change("~", 0, "element")
+    end
+
+    assert_raises RuntimeError, /Invalid Position Type/ do
+      change("+", 3.5, "element")
+    end
+  end
+
+  def test_from_a
+    assert_kind_of Diff::LCS::Change, change_from_a(["+", 0, "element"])
+    assert_kind_of Diff::LCS::Change, change_from_a(["+", 0, "element"], Diff::LCS::ContextChange)
+    assert_kind_of Diff::LCS::ContextChange,
+      change_from_a(["!", [1, "old_element"], [2, "new_element"]])
+    assert_kind_of Diff::LCS::ContextChange,
+      change_from_a(["!", [1, "old_element"], [2, "new_element"]], Diff::LCS::ContextChange)
+
+    assert_raises RuntimeError, "Invalid change array format provided." do
+      change_from_a(["+", 0])
+    end
+
+    assert_raises RuntimeError, "Invalid change array format provided." do
+      change_from_a(["+", 0], Diff::LCS::ContextChange)
+    end
+  end
+
+  def test_spaceship_reflexive
+    c1 = change("=", 5, "x")
+    c2 = change("=", 5, "x")
+    assert_equal 0, c1 <=> c2
+  end
+
+  def test_spaceship_position_precedence
+    c1 = change("=", 5, "x")
+    c2 = change("=", 10, "x")
+
+    assert_equal(-1, c1 <=> c2)
+    assert_equal 1, c2 <=> c1
+  end
+
+  def test_spaceship_action_precedence
+    valid_actions.each_cons(2) do |a1, a2|
+      c1 = change(a1, 5, "x")
+      c2 = change(a2, 5, "x")
+
+      assert_equal(-1, c1 <=> c2, "#{a1} should sort before #{a2}")
+      assert_equal 1, c2 <=> c1
+    end
+  end
+
+  def test_spaceship_element_precedence
+    c1 = change("=", 5, "a")
+    c2 = change("=", 5, "z")
+
+    assert_equal(-1, c1 <=> c2)
+    assert_equal 1, c2 <=> c1
+    assert_equal 0, c1 <=> change("=", 5, "a")
+  end
+
+  def test_add
+    change = change("+", 0, "element")
+
+    assert change.adding?
+
+    refute change.deleting?
+    refute change.unchanged?
+    refute change.changed?
+    refute change.finished_a?
+    refute change.finished_b?
+  end
+
+  def test_delete
+    change = change("-", 0, "element")
+
+    assert change.deleting?
+
+    refute change.adding?
+    refute change.unchanged?
+    refute change.changed?
+    refute change.finished_a?
+    refute change.finished_b?
+  end
+
+  def test_unchanged
+    change = change("=", 0, "element")
+
+    assert change.unchanged?
+
+    refute change.deleting?
+    refute change.adding?
+    refute change.changed?
+    refute change.finished_a?
+    refute change.finished_b?
+  end
+
+  def test_changed
+    change = change("!", 0, "element")
+
+    assert change.changed?
+
+    refute change.deleting?
+    refute change.adding?
+    refute change.unchanged?
+    refute change.finished_a?
+    refute change.finished_b?
+  end
+
+  def test_finished_a
+    change = change(">", 0, "element")
+
+    assert change.finished_a?
+
+    refute change.deleting?
+    refute change.adding?
+    refute change.unchanged?
+    refute change.changed?
+    refute change.finished_b?
+  end
+
+  def test_finished_b
+    change = change("<", 0, "element")
+
+    assert change.finished_b?
+
+    refute change.deleting?
+    refute change.adding?
+    refute change.unchanged?
+    refute change.changed?
+    refute change.finished_a?
+  end
+
+  def test_as_array
+    action, position, element = change("!", 0, "element")
+    assert_equal "!", action
+    assert_equal 0, position
+    assert_equal "element", element
+  end
+end
+
+class TestContextChange < Minitest::Test
+  private def change(...) = Diff::LCS::ContextChange.new(...)
+  private def simplify(...) = Diff::LCS::ContextChange.simplify(change(...))
+
+  def test_invalid_change
+    assert_raises RuntimeError, /Invalid CHange Action/ do
+      change("~", 0, "old", 0, "new")
+    end
+
+    assert_raises RuntimeError, /Invalid Position Type/ do
+      change("+", 3.5, "old", 0, "new")
+    end
+
+    assert_raises RuntimeError, /Invalid Position Type/ do
+      change("+", 0, "old", 3.5, "new")
+    end
+  end
+
+  def test_as_array
+    action, old, new = change("!", 1, "old_element", 2, "new_element")
+
+    assert_equal "!", action
+    assert_equal [1, "old_element"], old
+    assert_equal [2, "new_element"], new
+  end
+
+  def test_spaceship_reflexive
+    c1 = change("=", 5, "x", 10, "y")
+    c2 = change("=", 5, "x", 10, "y")
+    assert_equal 0, c1 <=> c2
+  end
+
+  def test_spaceship_position_precedence
+    c1 = change("=", 5, "x", 10, "y")
+    c2 = change("=", 15, "x", 10, "y")
+
+    assert_equal(-1, c1 <=> c2)
+    assert_equal 1, c2 <=> c1
+
+    c1 = change("=", 5, "x", 10, "y")
+    c2 = change("=", 5, "x", 20, "y")
+
+    assert_equal(-1, c1 <=> c2)
+    assert_equal 1, c2 <=> c1
+  end
+
+  def test_spaceship_action_precedence
+    valid_actions.each_cons(2) do |a1, a2|
+      c1 = change(a1, 5, "x", 10, "y")
+      c2 = change(a2, 5, "x", 10, "y")
+
+      assert_equal(-1, c1 <=> c2, "#{a1} should sort before #{a2}")
+      assert_equal 1, c2 <=> c1
+    end
+  end
+
+  def test_spaceship_element_precedence
+    c1 = change("=", 5, "a", 10, "y")
+    c2 = change("=", 5, "z", 10, "y")
+
+    assert_equal(-1, c1 <=> c2, "old_element precedence")
+    assert_equal 1, c2 <=> c1
+
+    c3 = change("=", 5, "x", 10, "a")
+    c4 = change("=", 5, "x", 10, "z")
+
+    assert_equal(-1, c3 <=> c4, "new_element precedence")
+    assert_equal 1, c4 <=> c3
+    assert_equal 0, c3 <=> Diff::LCS::ContextChange.new("=", 5, "x", 10, "a")
+  end
+
+  def test_simplify
+    simplify("-", 5, "old", 10, "new") => {action:, new_element:}
+    assert_equal action, "-"
+    assert_nil new_element
+
+    simplify("<", 5, "old", 10, "new") => {action:, new_element:}
+    assert_equal action, "-"
+    assert_nil new_element
+
+    simplify("+", 5, "old", 10, "new") => {action:, old_element:}
+    assert_equal action, "+"
+    assert_nil old_element
+
+    simplify(">", 5, "old", 10, "new") => {action:, old_element:}
+    assert_equal action, "+"
+    assert_nil old_element
+  end
+end

data/test/test_diff.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+
+class TestDiff < Minitest::Test
+  def test_correctly_diffs_seq1_to_seq2
+    assert_equal change_diff(correct_forward_diff), diff(seq1, seq2)
+  end
+
+  def test_correctly_diffs_seq2_to_seq1
+    assert_equal change_diff(correct_backward_diff), diff(seq2, seq1)
+  end
+
+  def test_correctly_diffs_against_empty_sequence_forward
+    correct_diff = [
+      [
+        ["-", 0, "abcd"],
+        ["-", 1, "efgh"],
+        ["-", 2, "ijkl"],
+        ["-", 3, "mnopqrstuvwxyz"]
+      ]
+    ]
+
+    assert_equal change_diff(correct_diff), diff(word_sequence, [])
+  end
+
+  def test_correctly_diffs_against_empty_sequence_backward
+    correct_diff = [
+      [
+        ["+", 0, "abcd"],
+        ["+", 1, "efgh"],
+        ["+", 2, "ijkl"],
+        ["+", 3, "mnopqrstuvwxyz"]
+      ]
+    ]
+
+    assert_equal change_diff(correct_diff), diff([], word_sequence)
+  end
+
+  def test_correctly_diffs_xx_and_xaxb
+    left = "xx"
+    right = "xaxb"
+    assert_equal right, patch(left, diff(left, right))
+  end
+
+  def test_returns_empty_diff_with_hello_hello
+    assert_empty diff(hello, hello)
+  end
+
+  def test_returns_empty_diff_with_hello_ary_hello_ary
+    assert_empty diff(hello_ary, hello_ary)
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,225 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift File.expand_path(__dir__, "../lib")
+
+require "minitest/autorun"
+require "simplecov"
+require "simplecov-lcov"
+require "open3"
+
+require "diff/lcs"
+
+module Diff::LCS::TestHelper
+  def hello = "hello"
+  def hello_ary = %w[h e l l o]
+  def seq1 = %w[a b c e h j l m n p]
+  def skipped_seq1 = %w[a h n p]
+  def seq2 = %w[b c d e f j k l m r s t]
+  def skipped_seq2 = %w[d f k r s t]
+  def word_sequence = %w[abcd efgh ijkl mnopqrstuvwxyz]
+  def correct_lcs = %w[b c e j l m]
+
+  private def change(...) = Diff::LCS::Change.new(...)
+  private def change_from_a(array, klass = Diff::LCS::Change) = klass.from_a(array)
+  private def diff(...) = Diff::LCS.diff(...)
+  private def hunk(...) = Diff::LCS::Hunk.new(...)
+  private def internal_lcs(...) = Diff::LCS::Internals.lcs(...)
+  private def lcs(...) = Diff::LCS.lcs(...)
+  private def patch(...) = Diff::LCS.patch(...)
+  private def patch!(...) = Diff::LCS.patch!(...)
+  private def sdiff(...) = Diff::LCS.sdiff(...)
+  private def traverse_balanced(...) = Diff::LCS.traverse_balanced(...)
+  private def traverse_sequences(...) = Diff::LCS.traverse_sequences(...)
+  private def unpatch(...) = Diff::LCS.unpatch(...)
+  private def unpatch!(...) = Diff::LCS.unpatch!(...)
+  private def valid_actions = Diff::LCS::Change::VALID_ACTIONS
+
+  def correct_forward_diff
+    [
+      [["-", 0, "a"]],
+      [["+", 2, "d"]],
+      [["-", 4, "h"], ["+", 4, "f"]],
+      [["+", 6, "k"]],
+      [["-", 8, "n"], ["+", 9, "r"], ["-", 9, "p"], ["+", 10, "s"], ["+", 11, "t"]]
+    ]
+  end
+
+  def correct_backward_diff
+    [
+      [["+", 0, "a"]],
+      [["-", 2, "d"]],
+      [["-", 4, "f"], ["+", 4, "h"]],
+      [["-", 6, "k"]],
+      [["-", 9, "r"], ["+", 8, "n"], ["-", 10, "s"], ["+", 9, "p"], ["-", 11, "t"]]
+    ]
+  end
+
+  def correct_forward_sdiff
+    [
+      ["-", [0, "a"], [0, nil]],
+      ["=", [1, "b"], [0, "b"]],
+      ["=", [2, "c"], [1, "c"]],
+      ["+", [3, nil], [2, "d"]],
+      ["=", [3, "e"], [3, "e"]],
+      ["!", [4, "h"], [4, "f"]],
+      ["=", [5, "j"], [5, "j"]],
+      ["+", [6, nil], [6, "k"]],
+      ["=", [6, "l"], [7, "l"]],
+      ["=", [7, "m"], [8, "m"]],
+      ["!", [8, "n"], [9, "r"]],
+      ["!", [9, "p"], [10, "s"]],
+      ["+", [10, nil], [11, "t"]]
+    ]
+  end
+
+  def reverse_sdiff(forward_sdiff)
+    forward_sdiff.map { |line|
+      line[1], line[2] = line[2], line[1]
+      case line[0]
+      when "-" then line[0] = "+"
+      when "+" then line[0] = "-"
+      end
+      line
+    }
+  end
+
+  def change_diff(diff) = map_diffs(diff, Diff::LCS::Change)
+  def context_diff(diff) = map_diffs(diff, Diff::LCS::ContextChange)
+
+  def map_diffs(diffs, klass = Diff::LCS::ContextChange)
+    diffs.map do |chunks|
+      if klass == Diff::LCS::ContextChange
+        klass.from_a(chunks)
+      else
+        chunks.map { |changes| klass.from_a(changes) }
+      end
+    end
+  end
+
+  def balanced_traversal(s1, s2, callback_type)
+    callback = __send__(callback_type)
+    Diff::LCS.traverse_balanced(s1, s2, callback)
+    callback
+  end
+
+  def balanced_reverse(change_result)
+    new_result = []
+    change_result.each do |line|
+      line = [line[0], line[2], line[1]]
+      case line[0]
+      when "<" then line[0] = ">"
+      when ">" then line[0] = "<"
+      end
+      new_result << line
+    end
+    new_result.sort_by { |line| [line[1], line[2]] }
+  end
+
+  def map_to_no_change(change_result)
+    new_result = []
+    change_result.each do |line|
+      case line[0]
+      when "!"
+        new_result << ["<", line[1], line[2]]
+        new_result << [">", line[1] + 1, line[2]]
+      else
+        new_result << line
+      end
+    end
+    new_result
+  end
+
+  def assert_nil_or_match_values(ee, ii, s1, s2)
+    assert(ee.nil? || s1[ii] == s2[ee])
+  end
+
+  def assert_correctly_maps_sequence(actual, s1, s2)
+    actual.each_index { |ii| assert_nil_or_match_values(actual[ii], ii, s1, s2) }
+  end
+
+  class SimpleCallback
+    attr_reader :matched_a, :matched_b, :discards_a, :discards_b, :done_a, :done_b
+
+    def initialize
+      reset
+    end
+
+    def reset
+      @matched_a = []
+      @matched_b = []
+      @discards_a = []
+      @discards_b = []
+      @done_a = []
+      @done_b = []
+      self
+    end
+
+    def match(event)
+      @matched_a << event.old_element
+      @matched_b << event.new_element
+    end
+
+    def discard_b(event)
+      @discards_b << event.new_element
+    end
+
+    def discard_a(event)
+      @discards_a << event.old_element
+    end
+
+    def finished_a(event)
+      @done_a << [event.old_element, event.old_position, event.new_element, event.new_position]
+    end
+
+    def finished_b(event)
+      @done_b << [event.old_element, event.old_position, event.new_element, event.new_position]
+    end
+  end
+
+  def simple_callback = SimpleCallback.new
+
+  class SimpleCallbackNoFinishers < SimpleCallback
+    undef :finished_a
+    undef :finished_b
+  end
+
+  def simple_callback_no_finishers = SimpleCallbackNoFinishers.new
+
+  class BalancedCallback
+    attr_reader :result
+
+    def initialize
+      reset
+    end
+
+    def reset
+      @result = []
+    end
+
+    def match(event)
+      @result << ["=", event.old_position, event.new_position]
+    end
+
+    def discard_a(event)
+      @result << ["<", event.old_position, event.new_position]
+    end
+
+    def discard_b(event)
+      @result << [">", event.old_position, event.new_position]
+    end
+
+    def change(event)
+      @result << ["!", event.old_position, event.new_position]
+    end
+  end
+
+  def balanced_callback = BalancedCallback.new
+
+  class BalancedCallbackNoChange < BalancedCallback
+    undef :change
+  end
+
+  def balanced_callback_no_change = BalancedCallbackNoChange.new
+
+  Minitest::Test.send(:include, self)
+end

data/test/test_hunk.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+require "diff/lcs/hunk"
+
+class TestHunk < Minitest::Test
+  def setup
+    @old_data = ["Tu a un carté avec {count} itéms".encode("UTF-16LE")]
+    @new_data = ["Tu a un carte avec {count} items".encode("UTF-16LE")]
+    @pieces = diff(@old_data, @new_data)
+    @hunk = hunk(@old_data, @new_data, @pieces[0], 3, 0)
+  end
+
+  def test_produces_a_unified_diff_from_the_two_pieces
+    expected = <<-EXPECTED.gsub(/^\s+/, "").encode("UTF-16LE").chomp
+        @@ -1 +1 @@
+        -Tu a un carté avec {count} itéms
+        +Tu a un carte avec {count} items
+    EXPECTED
+
+    assert_equal expected, @hunk.diff(:unified)
+  end
+
+  def test_produces_a_unified_diff_from_the_two_pieces_last_entry
+    expected = <<-EXPECTED.gsub(/^\s+/, "").encode("UTF-16LE").chomp
+        @@ -1 +1 @@
+        -Tu a un carté avec {count} itéms
+        +Tu a un carte avec {count} items
+        \
+    EXPECTED
+
+    assert_equal expected, @hunk.diff(:unified, true)
+  end
+
+  def test_produces_a_context_diff_from_the_two_pieces
+    expected = <<-EXPECTED.gsub(/^\s+/, "").encode("UTF-16LE").chomp
+        ***************
+        *** 1 ****
+        ! Tu a un carté avec {count} itéms
+        --- 1 ----
+        ! Tu a un carte avec {count} items
+    EXPECTED
+
+    assert_equal expected, @hunk.diff(:context)
+  end
+
+  def test_produces_an_old_diff_from_the_two_pieces
+    expected = <<-EXPECTED.gsub(/^ +/, "").encode("UTF-16LE").chomp
+        1c1
+        < Tu a un carté avec {count} itéms
+        ---
+        > Tu a un carte avec {count} items
+
+    EXPECTED
+
+    assert_equal expected, @hunk.diff(:old)
+  end
+
+  def test_with_empty_first_data_set_produces_a_unified_diff
+    old_data = []
+    pieces = diff(old_data, @new_data)
+    hunk = hunk(old_data, @new_data, pieces[0], 3, 0)
+
+    expected = <<-EXPECTED.gsub(/^\s+/, "").encode("UTF-16LE").chomp
+        @@ -0,0 +1 @@
+        +Tu a un carte avec {count} items
+    EXPECTED
+
+    assert_equal expected, hunk.diff(:unified)
+  end
+end