diff-lcs 1.1.3 → 1.5.0

data/spec/issues_spec.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+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|
+      before do
+        @diff_s1_s2 = Diff::LCS.diff(s1, s2)
+      end
+
+      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
+        expect(Diff::LCS.patch(s1, @diff_s1_s2)).to eq(s2)
+      end
+
+      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']
+        ]
+      ]
+      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']
+        ]
+      ]
+      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
+      expect {
+        actual = { :category => 'app.rack.request' }
+        expected = { :category => 'rack.middleware', :title => 'Anonymous Middleware' }
+        expect(actual).to eq(expected)
+      }.to raise_error(RSpec::Expectations::ExpectationNotMetError)
+    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
+    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]'
+      ]
+
+      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
+    end
+  end
+end

data/spec/lcs_spec.rb

@@ -1,36 +1,56 @@
-# -*- ruby encoding: utf-8 -*-
+# frozen_string_literal: true
 
 require 'spec_helper'
 
-describe "Diff::LCS.LCS and Diff::LCS.__lcs" do
+describe Diff::LCS::Internals, '.lcs' do
   include Diff::LCS::SpecHelper::Matchers
 
-  it "should return the correct raw values from Diff::LCS.__lcs" do
-    res = Diff::LCS.__lcs(seq1, seq2)
+  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.
-    res.compact.size.should == correct_lcs.size
-    res.should correctly_map_sequence(seq1).to_other_sequence(seq2)
+    expect(res.compact.size).to eq(correct_lcs.size)
+    expect(res).to correctly_map_sequence(seq1).to_other_sequence(seq2)
 
     # Compact these transformations and they should be the correct LCS.
     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
 
-    x_seq1.should == correct_lcs
-    x_seq2.should == correct_lcs
+    expect(x_seq1).to eq(correct_lcs)
+    expect(x_seq2).to eq(correct_lcs)
   end
 
-  it "should return the correct compacted values from Diff::LCS.LCS" 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
+    expect(Diff::LCS::Internals.lcs(hello_ary, hello_ary)).to \
+      eq((0...hello_ary.size).to_a)
+  end
+end
+
+describe Diff::LCS, '.LCS' do
+  include Diff::LCS::SpecHelper::Matchers
+
+  it 'returns the correct compacted values from Diff::LCS.LCS' do
     res = Diff::LCS.LCS(seq1, seq2)
-    res.should == correct_lcs
-    res.compact.should == res
+    expect(res).to eq(correct_lcs)
+    expect(res.compact).to eq(res)
   end
 
-  it "should be transitive" do
+  it 'is transitive' do
     res = Diff::LCS.LCS(seq2, seq1)
-    res.should == correct_lcs
-    res.compact.should == res
+    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(//))
   end
-end
 
-# vim: ft=ruby
+  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

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe 'bin/ldiff' do
+  include CaptureSubprocessIO
+
+  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)|
+    fixture = fixture.dup
+    fixture[:flag] = flag
+    fixture
+  }
+
+  def self.test_ldiff(fixture)
+    desc = [
+      fixture[:flag],
+      "spec/fixtures/#{fixture[:left]}",
+      "spec/fixtures/#{fixture[:right]}",
+      '#',
+      '=>',
+      "spec/fixtures/ldiff/#{fixture[:name]}#{fixture[:flag]}"
+    ].join(' ')
+
+    it desc do
+      expect(run_ldiff(fixture)).to eq(read_fixture(fixture))
+    end
+  end
+
+  fixtures.each do |fixture|
+    test_ldiff(fixture)
+  end
+
+  def read_fixture(options)
+    fixture = options.fetch(:name)
+    flag = options.fetch(:flag)
+    name = "spec/fixtures/ldiff/#{fixture}#{flag}"
+    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*
+        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
+
+  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
+
+    expect(stderr).to be_empty if RUBY_VERSION >= '1.9'
+    expect(stdout).not_to be_empty
+    clean_data(stdout, flag)
+  end
+end