diff-lcs 2.0.0.beta.1 → 2.0.0

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

data/test/test_issues.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "diff/lcs/hunk"
+
+class TestIssues < Minitest::Test
+  def test_issue_1_string_forward_diff
+    s1 = "aX"
+    s2 = "bXaX"
+    forward_diff = [
+      [
+        ["+", 0, "b"],
+        ["+", 1, "X"]
+      ]
+    ]
+
+    diff_s1_s2 = diff(s1, s2)
+
+    assert_equal change_diff(forward_diff), diff_s1_s2
+    assert_equal s2, patch(s1, diff_s1_s2)
+    assert_equal s1, patch(s2, diff_s1_s2)
+  end
+
+  def test_issue_1_string_reverse_diff
+    s1 = "bXaX"
+    s2 = "aX"
+    forward_diff = [
+      [
+        ["-", 0, "b"],
+        ["-", 1, "X"]
+      ]
+    ]
+
+    diff_s1_s2 = diff(s1, s2)
+
+    assert_equal change_diff(forward_diff), diff_s1_s2
+    assert_equal s2, patch(s1, diff_s1_s2)
+    assert_equal s1, patch(s2, diff_s1_s2)
+  end
+
+  def test_issue_1_array_forward_diff
+    s1 = %w[a X]
+    s2 = %w[b X a X]
+    forward_diff = [
+      [
+        ["+", 0, "b"],
+        ["+", 1, "X"]
+      ]
+    ]
+
+    diff_s1_s2 = diff(s1, s2)
+
+    assert_equal change_diff(forward_diff), diff_s1_s2
+    assert_equal s2, patch(s1, diff_s1_s2)
+    assert_equal s1, patch(s2, diff_s1_s2)
+  end
+
+  def test_issue_1_array_reverse_diff
+    s1 = %w[b X a X]
+    s2 = %w[a X]
+    forward_diff = [
+      [
+        ["-", 0, "b"],
+        ["-", 1, "X"]
+      ]
+    ]
+
+    diff_s1_s2 = diff(s1, s2)
+
+    assert_equal change_diff(forward_diff), diff_s1_s2
+    assert_equal s2, patch(s1, diff_s1_s2)
+    assert_equal s1, patch(s2, diff_s1_s2)
+  end
+
+  def test_issue_57_should_fail_with_correct_error
+    assert_raises(Minitest::Assertion) do
+      actual = {category: "app.rack.request"}
+      expected = {category: "rack.middleware", title: "Anonymous Middleware"}
+      assert_equal expected, actual
+    end
+  end
+
+  def diff_lines(old_lines, new_lines)
+    file_length_difference = 0
+    previous_hunk = nil
+    output = []
+
+    diff(old_lines, new_lines).each do |piece|
+      hunk = hunk(old_lines, new_lines, piece, 3, file_length_difference)
+      file_length_difference = hunk.file_length_difference
+      maybe_contiguous_hunks = previous_hunk.nil? || hunk.merge(previous_hunk)
+
+      output << "#{previous_hunk.diff(:unified)}\n" unless maybe_contiguous_hunks
+
+      previous_hunk = hunk
+    end
+    output << "#{previous_hunk.diff(:unified, true)}\n" unless previous_hunk.nil?
+    output.join
+  end
+
+  def test_issue_65_should_not_misplace_new_chunk
+    old_data = [
+      "recipe[a::default]", "recipe[b::default]", "recipe[c::default]",
+      "recipe[d::default]", "recipe[e::default]", "recipe[f::default]",
+      "recipe[g::default]", "recipe[h::default]", "recipe[i::default]",
+      "recipe[j::default]", "recipe[k::default]", "recipe[l::default]",
+      "recipe[m::default]", "recipe[n::default]"
+    ]
+
+    new_data = [
+      "recipe[a::default]", "recipe[c::default]", "recipe[d::default]",
+      "recipe[e::default]", "recipe[f::default]", "recipe[g::default]",
+      "recipe[h::default]", "recipe[i::default]", "recipe[j::default]",
+      "recipe[k::default]", "recipe[l::default]", "recipe[m::default]",
+      "recipe[n::default]", "recipe[o::new]", "recipe[p::new]",
+      "recipe[q::new]", "recipe[r::new]"
+    ]
+
+    expected = <<~EODIFF
+      @@ -1,5 +1,4 @@
+       recipe[a::default]
+      -recipe[b::default]
+       recipe[c::default]
+       recipe[d::default]
+       recipe[e::default]
+      @@ -12,3 +11,7 @@
+       recipe[l::default]
+       recipe[m::default]
+       recipe[n::default]
+      +recipe[o::new]
+      +recipe[p::new]
+      +recipe[q::new]
+      +recipe[r::new]
+    EODIFF
+
+    assert_equal expected, diff_lines(old_data, new_data)
+  end
+
+  def test_issue_107_should_produce_unified_output_with_correct_context
+    old_data = <<~DATA_OLD.strip.split("\n").map(&:chomp)
+      {
+        "name": "x",
+        "description": "hi"
+      }
+    DATA_OLD
+
+    new_data = <<~DATA_NEW.strip.split("\n").map(&:chomp)
+      {
+        "name": "x",
+        "description": "lo"
+      }
+    DATA_NEW
+
+    diff = diff(old_data, new_data)
+    hunk = hunk(old_data, new_data, diff.first, 3, 0)
+
+    expected = <<~EXPECTED.chomp
+      @@ -1,4 +1,4 @@
+       {
+         "name": "x",
+      -  "description": "hi"
+      +  "description": "lo"
+       }
+    EXPECTED
+
+    assert_equal expected, hunk.diff(:unified)
+  end
+end

data/test/test_lcs.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+
+class TestLCSInternals < Minitest::Test
+  def test_returns_meaningful_lcs_array_with_seq1_seq2
+    res = internal_lcs(seq1, seq2)
+    assert_equal correct_lcs.size, res.compact.size
+    assert_correctly_maps_sequence(res, seq1, seq2)
+
+    x_seq1 = (0...res.size).map { |ix| res[ix] ? seq1[ix] : nil }.compact
+    x_seq2 = (0...res.size).map { |ix| res[ix] ? seq2[res[ix]] : nil }.compact
+
+    assert_equal correct_lcs, x_seq1
+    assert_equal correct_lcs, x_seq2
+  end
+
+  def test_returns_all_indexes_with_hello_hello
+    assert_equal (0...hello.size).to_a, internal_lcs(hello, hello)
+  end
+
+  def test_returns_all_indexes_with_hello_ary_hello_ary
+    assert_equal (0...hello_ary.size).to_a, internal_lcs(hello_ary, hello_ary)
+  end
+end
+
+class TestLCS < Minitest::Test
+  def test_returns_correct_compacted_values
+    res = lcs(seq1, seq2)
+    assert_equal correct_lcs, res
+    assert_equal res, res.compact
+  end
+
+  def test_is_transitive
+    res = lcs(seq2, seq1)
+    assert_equal correct_lcs, res
+    assert_equal res, res.compact
+  end
+
+  def test_returns_hello_chars_with_hello_hello
+    assert_equal hello.chars, lcs(hello, hello)
+  end
+
+  def test_returns_hello_ary_with_hello_ary_hello_ary
+    assert_equal hello_ary, lcs(hello_ary, hello_ary)
+  end
+end

data/test/test_ldiff.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class TestLdiff < Minitest::Test
+  FIXTURES = [
+    {name: "diff", left: "aX", right: "bXaX", diff: 1},
+    {name: "diff.missing_new_line1", left: "four_lines", right: "four_lines_with_missing_new_line", diff: 1},
+    {name: "diff.missing_new_line2", left: "four_lines_with_missing_new_line", right: "four_lines", diff: 1},
+    {name: "diff.issue95_trailing_context", left: "123_x", right: "456_x", diff: 1},
+    {name: "diff.four_lines.vs.empty", left: "four_lines", right: "empty", diff: 1},
+    {name: "diff.empty.vs.four_lines", left: "empty", right: "four_lines", diff: 1},
+    {name: "diff.bin1", left: "file1.bin", right: "file1.bin", diff: 0},
+    {name: "diff.bin2", left: "file1.bin", right: "file2.bin", diff: 1},
+    {name: "diff.chef", left: "old-chef", right: "new-chef", diff: 1},
+    {name: "diff.chef2", left: "old-chef2", right: "new-chef2", diff: 1}
+  ].product([nil, "-c", "-u"]).map { |(fixture, flag)|
+    fixture = fixture.dup
+    fixture[:flag] = flag
+    fixture
+  }
+
+  FIXTURES.each do |fixture|
+    test_name = "test_ldiff_#{fixture[:name]}_#{fixture[:flag] || "default"}"
+      .tr(".", "_")
+      .tr("-", "_")
+
+    define_method(test_name) do
+      stdout, stderr, status = run_ldiff(fixture)
+      assert_equal fixture[:diff], status
+      assert_equal read_fixture(fixture, mode: "error", allow_missing: true), stderr
+      assert_equal read_fixture(fixture, mode: "output", allow_missing: false), stdout
+    end
+  end
+
+  private
+
+  def read_fixture(options, mode: "output", allow_missing: false)
+    fixture = options.fetch(:name)
+    flag = options.fetch(:flag)
+    name = "test/fixtures/ldiff/#{mode}.#{fixture}#{flag}"
+
+    return "" if !::File.exist?(name) && allow_missing
+
+    data = IO.__send__(IO.respond_to?(:binread) ? :binread : :read, name)
+    clean_data(data, flag)
+  end
+
+  def clean_data(data, flag)
+    data =
+      case flag
+      when "-c", "-u"
+        clean_output_timestamp(data)
+      else
+        data
+      end
+    data.gsub(/\r\n?/, "\n")
+  end
+
+  def clean_output_timestamp(data)
+    data.gsub(
+      %r{
+        ^
+        [-+*]{3}
+        \s*
+        test/fixtures/(\S+)
+        \s*
+        \d{4}-\d\d-\d\d
+        \s*
+        \d\d:\d\d:\d\d(?:\.\d+)
+        \s*
+        (?:[-+]\d{4}|Z)
+      }x,
+      '*** test/fixtures/\1	0000-00-00 :00 =>:00 =>00.000000000 -0000'
+    )
+  end
+
+  def run_ldiff(options)
+    flag = options.fetch(:flag)
+    left = options.fetch(:left)
+    right = options.fetch(:right)
+
+    stdout, stderr = capture_subprocess_io do
+      system("ruby -Ilib bin/ldiff #{flag} test/fixtures/#{left} test/fixtures/#{right}")
+    end
+
+    [clean_data(stdout, flag), stderr, $?.exitstatus]
+  end
+end