diff-lcs 1.3 → 1.6.2

data/spec/fixtures/new-chef2

@@ -0,0 +1,17 @@
+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]

data/spec/fixtures/old-chef

@@ -0,0 +1,4 @@
+{
+  "name": "x",
+  "description": "hi"
+}

data/spec/fixtures/old-chef2

@@ -0,0 +1,14 @@
+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]

data/spec/hunk_spec.rb

@@ -1,69 +1,80 @@
-# -*- ruby encoding: utf-8 -*-
+# frozen_string_literal: true
 
-require 'spec_helper'
+require "spec_helper"
 
 if String.method_defined?(:encoding)
-  require 'diff/lcs/hunk'
+  require "diff/lcs/hunk"
 
   describe Diff::LCS::Hunk do
-    let(:old_data) { ["Tu avec carté {count} itém has".encode('UTF-16LE')] }
-    let(:new_data) { ["Tu avec carte {count} item has".encode('UTF-16LE')] }
-    let(:pieces)   { Diff::LCS.diff old_data, new_data }
-    let(:hunk)     { Diff::LCS::Hunk.new(old_data, new_data, pieces[0], 3, 0) }
-
-    it 'produces a unified diff from the two pieces' do
-      expected = (<<-EOD.gsub(/^\s+/,'').encode('UTF-16LE').chomp)
-        @@ -1,2 +1,2 @@
-        -Tu avec carté {count} itém has
-        +Tu avec carte {count} item has
-      EOD
+    let(:old_data) { ["Tu a un carté avec {count} itéms".encode("UTF-16LE")] }
+    let(:new_data) { ["Tu a un carte avec {count} items".encode("UTF-16LE")] }
+    let(:pieces) { Diff::LCS.diff old_data, new_data }
+    let(:hunk) { Diff::LCS::Hunk.new(old_data, new_data, pieces[0], 3, 0) }
+
+    it "produces a unified diff from the two pieces" do
+      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
 
       expect(hunk.diff(:unified)).to eq(expected)
     end
 
-    it 'produces a context diff from the two pieces' do
-      expected = (<<-EOD.gsub(/^\s+/,'').encode('UTF-16LE').chomp)
+    it "produces a unified diff from the two pieces (last entry)" do
+      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
+
+      expect(hunk.diff(:unified, true)).to eq(expected)
+    end
+
+    it "produces a context diff from the two pieces" do
+      expected = <<-EXPECTED.gsub(/^\s+/, "").encode("UTF-16LE").chomp
         ***************
-        *** 1,2 ****
-        !Tu avec carté {count} itém has
-        --- 1,2 ----
-        !Tu avec carte {count} item has
-      EOD
+        *** 1 ****
+        ! Tu a un carté avec {count} itéms
+        --- 1 ----
+        ! Tu a un carte avec {count} items
+      EXPECTED
 
       expect(hunk.diff(:context)).to eq(expected)
     end
 
-    it 'produces an old diff from the two pieces' do
-      expected = (<<-EOD.gsub(/^ +/,'').encode('UTF-16LE').chomp)
-        1,2c1,2
-        < Tu avec carté {count} itém has
+    it "produces an old diff from the two pieces" do
+      expected = <<-EXPECTED.gsub(/^ +/, "").encode("UTF-16LE").chomp
+        1c1
+        < Tu a un carté avec {count} itéms
         ---
-        > Tu avec carte {count} item has
+        > Tu a un carte avec {count} items
 
-      EOD
+      EXPECTED
 
       expect(hunk.diff(:old)).to eq(expected)
     end
 
-    it 'produces a reverse ed diff from the two pieces' do
-      expected = (<<-EOD.gsub(/^ +/,'').encode('UTF-16LE').chomp)
-        c1,2
-        Tu avec carte {count} item has
+    it "produces a reverse ed diff from the two pieces" do
+      expected = <<-EXPECTED.gsub(/^ +/, "").encode("UTF-16LE").chomp
+        c1
+        Tu a un carte avec {count} items
         .
 
-      EOD
+      EXPECTED
 
       expect(hunk.diff(:reverse_ed)).to eq(expected)
     end
 
-    context 'with empty first data set' do
+    context "with empty first data set" do
       let(:old_data) { [] }
 
-      it 'produces a unified diff' do
-        expected = (<<-EOD.gsub(/^\s+/,'').encode('UTF-16LE').chomp)
-          @@ -1 +1,2 @@
-          +Tu avec carte {count} item has
-        EOD
+      it "produces a unified diff" do
+        expected = <<-EXPECTED.gsub(/^\s+/, "").encode("UTF-16LE").chomp
+          @@ -0,0 +1 @@
+          +Tu a un carte avec {count} items
+        EXPECTED
 
         expect(hunk.diff(:unified)).to eq(expected)
       end

data/spec/issues_spec.rb

@@ -1,49 +1,160 @@
-# -*- ruby encoding: utf-8 -*-
+# frozen_string_literal: true
 
-require 'spec_helper'
+require "spec_helper"
+require "diff/lcs/hunk"
 
 describe "Diff::LCS Issues" do
   include Diff::LCS::SpecHelper::Matchers
 
-  describe 'issue #1' do
-    shared_examples 'handles simple diffs' do |s1, s2, forward_diff|
+  describe "issue #1" do
+    shared_examples "handles simple diffs" do |s1, s2, forward_diff|
       before do
         @diff_s1_s2 = Diff::LCS.diff(s1, s2)
       end
 
-      it 'creates the correct diff' do
+      it "creates the correct diff" do
         expect(change_diff(forward_diff)).to eq(@diff_s1_s2)
       end
 
-      it 'creates the correct patch s1->s2' do
+      it "creates the correct patch s1->s2" do
         expect(Diff::LCS.patch(s1, @diff_s1_s2)).to eq(s2)
       end
 
-      it 'creates the correct patch s2->s1' do
+      it "creates the correct patch s2->s1" do
         expect(Diff::LCS.patch(s2, @diff_s1_s2)).to eq(s1)
       end
     end
 
-    describe 'string' do
-      it_has_behavior 'handles simple diffs', 'aX', 'bXaX', [
-        [ [ '+', 0, 'b' ],
-          [ '+', 1, 'X' ] ],
+    describe "string" do
+      it_has_behavior "handles simple diffs", "aX", "bXaX", [
+        [
+          ["+", 0, "b"],
+          ["+", 1, "X"]
+        ]
       ]
-      it_has_behavior 'handles simple diffs', 'bXaX', 'aX', [
-        [ [ '-', 0, 'b' ],
-          [ '-', 1, 'X' ] ],
+      it_has_behavior "handles simple diffs", "bXaX", "aX", [
+        [
+          ["-", 0, "b"],
+          ["-", 1, "X"]
+        ]
       ]
     end
 
-    describe 'array' do
-      it_has_behavior 'handles simple diffs', %w(a X), %w(b X a X), [
-        [ [ '+', 0, 'b' ],
-          [ '+', 1, 'X' ] ],
+    describe "array" do
+      it_has_behavior "handles simple diffs", %w[a X], %w[b X a X], [
+        [
+          ["+", 0, "b"],
+          ["+", 1, "X"]
+        ]
       ]
-      it_has_behavior 'handles simple diffs', %w(b X a X), %w(a X), [
-        [ [ '-', 0, 'b' ],
-          [ '-', 1, 'X' ] ],
+      it_has_behavior "handles simple diffs", %w[b X a X], %w[a X], [
+        [
+          ["-", 0, "b"],
+          ["-", 1, "X"]
+        ]
       ]
     end
   end
+
+  describe "issue #57" do
+    it "should fail with a correct error" do
+      # standard:disable Style/HashSyntax
+      expect {
+        actual = {:category => "app.rack.request"}
+        expected = {:category => "rack.middleware", :title => "Anonymous Middleware"}
+        expect(actual).to eq(expected)
+      }.to raise_error(RSpec::Expectations::ExpectationNotMetError)
+      # standard:enable Style/HashSyntax
+    end
+  end
+
+  describe "issue #65" do
+    def diff_lines(old_lines, new_lines)
+      file_length_difference = 0
+      previous_hunk = nil
+      output = []
+
+      Diff::LCS.diff(old_lines, new_lines).each do |piece|
+        hunk = Diff::LCS::Hunk.new(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
+
+    it "should not misplace the new chunk" do
+      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]"
+      ]
+
+      # standard:disable Layout/HeredocIndentation
+      expect(diff_lines(old_data, new_data)).to eq(<<-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
+      # standard:enable Layout/HeredocIndentation
+    end
+  end
+
+  describe "issue #107 (replaces issue #60)" do
+    it "should produce unified output with correct context" do
+      # standard:disable Layout/HeredocIndentation
+      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::LCS.diff(old_data, new_data)
+      hunk = ::Diff::LCS::Hunk.new(old_data, new_data, diff.first, 3, 0)
+
+      expect(hunk.diff(:unified)).to eq(<<-EXPECTED.chomp)
+@@ -1,4 +1,4 @@
+ {
+   "name": "x",
+-  "description": "hi"
++  "description": "lo"
+ }
+      EXPECTED
+      # standard:enable Layout/HeredocIndentation
+    end
+  end
 end

data/spec/lcs_spec.rb

@@ -1,6 +1,6 @@
-# -*- ruby encoding: utf-8 -*-
+# frozen_string_literal: true
 
-require 'spec_helper'
+require "spec_helper"
 
 describe Diff::LCS::Internals, ".lcs" do
   include Diff::LCS::SpecHelper::Matchers
@@ -47,7 +47,7 @@ describe Diff::LCS, ".LCS" do
   end
 
   it "returns %W(h e l l o) with (hello, hello)" do
-    expect(Diff::LCS.LCS(hello, hello)).to eq(hello.split(//))
+    expect(Diff::LCS.LCS(hello, hello)).to eq(hello.chars)
   end
 
   it "returns hello_ary with (hello_ary, hello_ary)" do

data/spec/ldiff_spec.rb

@@ -1,47 +1,100 @@
-# -*- ruby encoding: utf-8 -*-
+# frozen_string_literal: true
 
-require 'spec_helper'
+require "spec_helper"
 
-describe "Diff::LCS.diff" do
-  include Diff::LCS::SpecHelper::Matchers
+RSpec.describe "bin/ldiff" do
+  include CaptureSubprocessIO
 
-  it 'correctly diffs seq1 to seq2' do
-    diff_s1_s2 = Diff::LCS.diff(seq1, seq2)
-    expect(change_diff(correct_forward_diff)).to eq(diff_s1_s2)
+  # standard:disable Style/HashSyntax
+  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, "-e", "-f", "-c", "-u"]).map { |(fixture, flag)|
+    fixture = fixture.dup
+    fixture[:flag] = flag
+    fixture
+  }
+  # standard:enable Style/HashSyntax
+
+  def self.test_ldiff(fixture)
+    desc = [
+      fixture[:flag],
+      "spec/fixtures/#{fixture[:left]}",
+      "spec/fixtures/#{fixture[:right]}",
+      "#",
+      "=>",
+      "spec/fixtures/ldiff/output.#{fixture[:name]}#{fixture[:flag]}"
+    ].join(" ")
+
+    it desc do
+      stdout, stderr, status = run_ldiff(fixture)
+      expect(status).to eq(fixture[:diff])
+      expect(stderr).to eq(read_fixture(fixture, mode: "error", allow_missing: true))
+      expect(stdout).to eq(read_fixture(fixture, mode: "output", allow_missing: false))
+    end
   end
 
-  it 'correctly diffs seq2 to seq1' do
-    diff_s2_s1 = Diff::LCS.diff(seq2, seq1)
-    expect(change_diff(correct_backward_diff)).to eq(diff_s2_s1)
+  fixtures.each do |fixture|
+    test_ldiff(fixture)
   end
 
-  it 'correctly diffs against an empty sequence' do
-    diff = Diff::LCS.diff(word_sequence, [])
-    correct_diff = [
-      [ [ '-', 0, 'abcd'           ],
-        [ '-', 1, 'efgh'           ],
-        [ '-', 2, 'ijkl'           ],
-        [ '-', 3, 'mnopqrstuvwxyz' ] ]
-    ]
+  def read_fixture(options, mode: "output", allow_missing: false)
+    fixture = options.fetch(:name)
+    flag = options.fetch(:flag)
+    name = "spec/fixtures/ldiff/#{mode}.#{fixture}#{flag}"
 
-    expect(change_diff(correct_diff)).to eq(diff)
+    return "" if !::File.exist?(name) && allow_missing
 
-    diff = Diff::LCS.diff([], word_sequence)
-    correct_diff.each { |hunk| hunk.each { |change| change[0] = '+' } }
-    expect(change_diff(correct_diff)).to eq(diff)
+    data = IO.__send__(IO.respond_to?(:binread) ? :binread : :read, name)
+    clean_data(data, flag)
   end
 
-  it "correctly diffs 'xx' and 'xaxb'" do
-    left = 'xx'
-    right = 'xaxb'
-    expect(Diff::LCS.patch(left, Diff::LCS.diff(left, right))).to eq(right)
+  def clean_data(data, flag)
+    data =
+      case flag
+      when "-c", "-u"
+        clean_output_timestamp(data)
+      else
+        data
+      end
+    data.gsub(/\r\n?/, "\n")
   end
 
-  it "returns an empty diff with (hello, hello)" do
-    expect(Diff::LCS.diff(hello, hello)).to eq([])
+  def clean_output_timestamp(data)
+    data.gsub(
+      %r{
+        ^
+        [-+*]{3}
+        \s*
+        spec/fixtures/(\S+)
+        \s*
+        \d{4}-\d\d-\d\d
+        \s*
+        \d\d:\d\d:\d\d(?:\.\d+)
+        \s*
+        (?:[-+]\d{4}|Z)
+      }x,
+      '*** spec/fixtures/\1	0000-00-00 :00 =>:00 =>00.000000000 -0000'
+    )
   end
 
-  it "returns an empty diff with (hello_ary, hello_ary)" do
-    expect(Diff::LCS.diff(hello_ary, hello_ary)).to eq([])
+  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} spec/fixtures/#{left} spec/fixtures/#{right}")
+    end
+
+    [clean_data(stdout, flag), stderr, $?.exitstatus]
   end
 end

data/spec/patch_spec.rb

@@ -1,6 +1,6 @@
-# -*- ruby encoding: utf-8 -*-
+# frozen_string_literal: true
 
-require 'spec_helper'
+require "spec_helper"
 
 describe "Diff::LCS.patch" do
   include Diff::LCS::SpecHelper::Matchers
@@ -29,12 +29,12 @@ describe "Diff::LCS.patch" do
     describe "an empty patchset returns the source" do
       it "works on a string (hello)" do
         diff = Diff::LCS.diff(hello, hello)
-        expect(Diff::LCS::patch(hello, diff)).to eq(hello)
+        expect(Diff::LCS.patch(hello, diff)).to eq(hello)
       end
 
       it "works on an array %W(h e l l o)" do
         diff = Diff::LCS.diff(hello_ary, hello_ary)
-        expect(Diff::LCS::patch(hello_ary, diff)).to eq(hello_ary)
+        expect(Diff::LCS.patch(hello_ary, diff)).to eq(hello_ary)
       end
     end
 
@@ -104,11 +104,11 @@ describe "Diff::LCS.patch" do
   describe "using a Diff::LCS.sdiff patchset" do
     describe "an empty patchset returns the source" do
       it "works on a string (hello)" do
-        expect(Diff::LCS::patch(hello, Diff::LCS.sdiff(hello, hello))).to eq(hello)
+        expect(Diff::LCS.patch(hello, Diff::LCS.sdiff(hello, hello))).to eq(hello)
       end
 
       it "works on an array %W(h e l l o)" do
-        expect(Diff::LCS::patch(hello_ary, Diff::LCS.sdiff(hello_ary, hello_ary))).to eq(hello_ary)
+        expect(Diff::LCS.patch(hello_ary, Diff::LCS.sdiff(hello_ary, hello_ary))).to eq(hello_ary)
       end
     end
 
@@ -181,8 +181,8 @@ describe "Diff::LCS.patch" do
   # above.
   describe "fix bug 891: patchsets do not contain the last equal part" do
     before :each do
-      @s1 = %w(a b c d   e f g h i j k)
-      @s2 = %w(a b c d D e f g h i j k)
+      @s1 = %w[a b c d   e f g h i j k] # standard:disable Layout/SpaceInsideArrayPercentLiteral
+      @s2 = %w[a b c d D e f g h i j k]
     end
 
     describe "using Diff::LCS.diff with default diff callbacks" do
@@ -225,10 +225,8 @@ describe "Diff::LCS.patch" do
 
     describe "using Diff::LCS.diff with context diff callbacks" do
       before :each do
-        @patch_set_s1_s2 = Diff::LCS.diff(@s1, @s2,
-                                          Diff::LCS::ContextDiffCallbacks)
-        @patch_set_s2_s1 = Diff::LCS.diff(@s2, @s1,
-                                          Diff::LCS::ContextDiffCallbacks)
+        @patch_set_s1_s2 = Diff::LCS.diff(@s1, @s2, Diff::LCS::ContextDiffCallbacks)
+        @patch_set_s2_s1 = Diff::LCS.diff(@s2, @s1, Diff::LCS::ContextDiffCallbacks)
       end
 
       it "autodiscovers s1 to s2 patches" do
@@ -265,10 +263,8 @@ describe "Diff::LCS.patch" do
 
     describe "using Diff::LCS.diff with sdiff callbacks" do
       before(:each) do
-        @patch_set_s1_s2 = Diff::LCS.diff(@s1, @s2,
-                                          Diff::LCS::SDiffCallbacks)
-        @patch_set_s2_s1 = Diff::LCS.diff(@s2, @s1,
-                                          Diff::LCS::SDiffCallbacks)
+        @patch_set_s1_s2 = Diff::LCS.diff(@s1, @s2, Diff::LCS::SDiffCallbacks)
+        @patch_set_s2_s1 = Diff::LCS.diff(@s2, @s1, Diff::LCS::SDiffCallbacks)
       end
 
       it "autodiscovers s1 to s2 patches" do
@@ -343,10 +339,8 @@ describe "Diff::LCS.patch" do
 
     describe "using Diff::LCS.sdiff with context diff callbacks" do
       before(:each) do
-        @patch_set_s1_s2 = Diff::LCS.sdiff(@s1, @s2,
-                                           Diff::LCS::ContextDiffCallbacks)
-        @patch_set_s2_s1 = Diff::LCS.sdiff(@s2, @s1,
-                                           Diff::LCS::ContextDiffCallbacks)
+        @patch_set_s1_s2 = Diff::LCS.sdiff(@s1, @s2, Diff::LCS::ContextDiffCallbacks)
+        @patch_set_s2_s1 = Diff::LCS.sdiff(@s2, @s1, Diff::LCS::ContextDiffCallbacks)
       end
 
       it "autodiscovers s1 to s2 patches" do