diff-lcs 1.5.0 → 1.6.0

data/spec/hunk_spec.rb

@@ -1,18 +1,18 @@
 # 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 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) }
+    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
+    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
@@ -21,8 +21,8 @@ if String.method_defined?(:encoding)
       expect(hunk.diff(:unified)).to eq(expected)
     end
 
-    it 'produces a unified diff from the two pieces (last entry)' do
-      expected = <<-EXPECTED.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
@@ -32,8 +32,8 @@ if String.method_defined?(:encoding)
       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
+    it "produces a context diff from the two pieces" do
+      expected = <<-EXPECTED.gsub(/^\s+/, "").encode("UTF-16LE").chomp
         ***************
         *** 1 ****
         ! Tu a un carté avec {count} itéms
@@ -44,8 +44,8 @@ if String.method_defined?(:encoding)
       expect(hunk.diff(:context)).to eq(expected)
     end
 
-    it 'produces an old diff from the two pieces' do
-      expected = <<-EXPECTED.gsub(/^ +/, '').encode('UTF-16LE').chomp
+    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
         ---
@@ -56,8 +56,8 @@ if String.method_defined?(:encoding)
       expect(hunk.diff(:old)).to eq(expected)
     end
 
-    it 'produces a reverse ed diff from the two pieces' do
-      expected = <<-EXPECTED.gsub(/^ +/, '').encode('UTF-16LE').chomp
+    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
         .
@@ -67,12 +67,12 @@ if String.method_defined?(:encoding)
       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 = <<-EXPECTED.gsub(/^\s+/, '').encode('UTF-16LE').chomp
-          @@ -1 +1,2 @@
+      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
 

data/spec/issues_spec.rb

@@ -1,102 +1,74 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
-require 'diff/lcs/hunk'
+require "spec_helper"
+require "diff/lcs/hunk"
 
-describe 'Diff::LCS Issues' do
+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', [
+    describe "string" do
+      it_has_behavior "handles simple diffs", "aX", "bXaX", [
         [
-          ['+', 0, 'b'],
-          ['+', 1, 'X']
+          ["+", 0, "b"],
+          ["+", 1, "X"]
         ]
       ]
-      it_has_behavior 'handles simple diffs', 'bXaX', 'aX', [
+      it_has_behavior "handles simple diffs", "bXaX", "aX", [
         [
-          ['-', 0, 'b'],
-          ['-', 1, 'X']
+          ["-", 0, "b"],
+          ["-", 1, "X"]
         ]
       ]
     end
 
-    describe 'array' do
-      it_has_behavior 'handles simple diffs', %w(a X), %w(b X a X), [
+    describe "array" do
+      it_has_behavior "handles simple diffs", %w[a X], %w[b X a X], [
         [
-          ['+', 0, 'b'],
-          ['+', 1, 'X']
+          ["+", 0, "b"],
+          ["+", 1, "X"]
         ]
       ]
-      it_has_behavior 'handles simple diffs', %w(b X a X), %w(a X), [
+      it_has_behavior "handles simple diffs", %w[b X a X], %w[a X], [
         [
-          ['-', 0, 'b'],
-          ['-', 1, 'X']
+          ["-", 0, "b"],
+          ["-", 1, "X"]
         ]
       ]
     end
   end
 
-  describe 'issue #57' do
-    it 'should fail with a correct error' do
+  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' }
+        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 #60' do
-    it 'should produce unified output with correct context' do
-      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,5 +1,5 @@
- {
-   "name": "x",
--  "description": "hi"
-+  "description": "lo"
- }
-      EXPECTED
-    end
-  end
-
-  describe 'issue #65' do
+  describe "issue #65" do
     def diff_lines(old_lines, new_lines)
       file_length_difference = 0
       previous_hunk = nil
@@ -105,7 +77,7 @@ describe 'Diff::LCS Issues' do
       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))
+        maybe_contiguous_hunks = previous_hunk.nil? || hunk.merge(previous_hunk)
 
         output << "#{previous_hunk.diff(:unified)}\n" unless maybe_contiguous_hunks
 
@@ -115,24 +87,25 @@ describe 'Diff::LCS Issues' do
       output.join
     end
 
-    it 'should not misplace the new chunk' do
+    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]'
+        "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]'
+        "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]
@@ -149,6 +122,39 @@ describe 'Diff::LCS Issues' do
 +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,11 +1,11 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
+require "spec_helper"
 
-describe Diff::LCS::Internals, '.lcs' do
+describe Diff::LCS::Internals, ".lcs" do
   include Diff::LCS::SpecHelper::Matchers
 
-  it 'returns a meaningful LCS array with (seq1, seq2)' do
+  it "returns a meaningful LCS array with (seq1, seq2)" do
     res = Diff::LCS::Internals.lcs(seq1, seq2)
     # The result of the LCS (less the +nil+ values) must be as long as the
     # correct result.
@@ -20,37 +20,37 @@ describe Diff::LCS::Internals, '.lcs' do
     expect(x_seq2).to eq(correct_lcs)
   end
 
-  it 'returns all indexes with (hello, hello)' do
+  it "returns all indexes with (hello, hello)" do
     expect(Diff::LCS::Internals.lcs(hello, hello)).to \
       eq((0...hello.size).to_a)
   end
 
-  it 'returns all indexes with (hello_ary, hello_ary)' do
+  it "returns all indexes with (hello_ary, hello_ary)" do
     expect(Diff::LCS::Internals.lcs(hello_ary, hello_ary)).to \
       eq((0...hello_ary.size).to_a)
   end
 end
 
-describe Diff::LCS, '.LCS' do
+describe Diff::LCS, ".LCS" do
   include Diff::LCS::SpecHelper::Matchers
 
-  it 'returns the correct compacted values from Diff::LCS.LCS' do
+  it "returns the correct compacted values from Diff::LCS.LCS" do
     res = Diff::LCS.LCS(seq1, seq2)
     expect(res).to eq(correct_lcs)
     expect(res.compact).to eq(res)
   end
 
-  it 'is transitive' do
+  it "is transitive" do
     res = Diff::LCS.LCS(seq2, seq1)
     expect(res).to eq(correct_lcs)
     expect(res.compact).to eq(res)
   end
 
-  it 'returns %W(h e l l o) with (hello, hello)' do
-    expect(Diff::LCS.LCS(hello, hello)).to eq(hello.split(//))
+  it "returns %W(h e l l o) with (hello, hello)" do
+    expect(Diff::LCS.LCS(hello, hello)).to eq(hello.chars)
   end
 
-  it 'returns hello_ary with (hello_ary, hello_ary)' do
+  it "returns hello_ary with (hello_ary, hello_ary)" do
     expect(Diff::LCS.LCS(hello_ary, hello_ary)).to eq(hello_ary)
   end
 end

data/spec/ldiff_spec.rb

@@ -1,32 +1,44 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
+require "spec_helper"
 
-RSpec.describe 'bin/ldiff' do
+RSpec.describe "bin/ldiff" do
   include CaptureSubprocessIO
 
+  # standard:disable Style/HashSyntax
   fixtures = [
-    { :name => 'output.diff', :left => 'aX', :right => 'bXaX' },
-    { :name => 'output.diff.chef', :left => 'old-chef', :right => 'new-chef' },
-    { :name => 'output.diff.chef2', :left => 'old-chef2', :right => 'new-chef2' }
-  ].product([nil, '-e', '-f', '-c', '-u']).map { |(fixture, flag)|
+    {: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/#{fixture[:name]}#{fixture[:flag]}"
-    ].join(' ')
+      "#",
+      "=>",
+      "spec/fixtures/ldiff/output.#{fixture[:name]}#{fixture[:flag]}"
+    ].join(" ")
 
     it desc do
-      expect(run_ldiff(fixture)).to eq(read_fixture(fixture))
+      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
 
@@ -34,10 +46,13 @@ RSpec.describe 'bin/ldiff' do
     test_ldiff(fixture)
   end
 
-  def read_fixture(options)
+  def read_fixture(options, mode: "output", allow_missing: false)
     fixture = options.fetch(:name)
     flag = options.fetch(:flag)
-    name = "spec/fixtures/ldiff/#{fixture}#{flag}"
+    name = "spec/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
@@ -45,7 +60,7 @@ RSpec.describe 'bin/ldiff' do
   def clean_data(data, flag)
     data =
       case flag
-      when '-c', '-u'
+      when "-c", "-u"
         clean_output_timestamp(data)
       else
         data
@@ -80,8 +95,6 @@ RSpec.describe 'bin/ldiff' do
       system("ruby -Ilib bin/ldiff #{flag} spec/fixtures/#{left} spec/fixtures/#{right}")
     end
 
-    expect(stderr).to be_empty if RUBY_VERSION >= '1.9'
-    expect(stdout).not_to be_empty
-    clean_data(stdout, flag)
+    [clean_data(stdout, flag), stderr, $?.exitstatus]
   end
 end