diff-lcs 1.2.4 → 1.4.2

data/spec/diff_spec.rb

@@ -1,47 +1,51 @@
-# -*- ruby encoding: utf-8 -*-
+# frozen_string_literal: true
 
 require 'spec_helper'
 
-describe "Diff::LCS.diff" do
+describe Diff::LCS, '.diff' do
   include Diff::LCS::SpecHelper::Matchers
 
-  it "should correctly diff seq1 to seq2" do
+  it 'correctly diffs seq1 to seq2' do
     diff_s1_s2 = Diff::LCS.diff(seq1, seq2)
-    change_diff(correct_forward_diff).should == diff_s1_s2
+    expect(change_diff(correct_forward_diff)).to eq(diff_s1_s2)
   end
 
-  it "should correctly diff seq2 to seq1" do
+  it 'correctly diffs seq2 to seq1' do
     diff_s2_s1 = Diff::LCS.diff(seq2, seq1)
-    change_diff(correct_backward_diff).should == diff_s2_s1
+    expect(change_diff(correct_backward_diff)).to eq(diff_s2_s1)
   end
 
-  it "should correctly diff against an empty sequence" do
+  it 'correctly diffs against an empty sequence' do
     diff = Diff::LCS.diff(word_sequence, [])
     correct_diff = [
-      [ [ '-', 0, 'abcd'           ],
-        [ '-', 1, 'efgh'           ],
-        [ '-', 2, 'ijkl'           ],
-        [ '-', 3, 'mnopqrstuvwxyz' ] ]
+      [
+        ['-', 0, 'abcd'],
+        ['-', 1, 'efgh'],
+        ['-', 2, 'ijkl'],
+        ['-', 3, 'mnopqrstuvwxyz']
+      ]
     ]
 
-    change_diff(correct_diff).should == diff
+    expect(change_diff(correct_diff)).to eq(diff)
 
     diff = Diff::LCS.diff([], word_sequence)
-    correct_diff.each { |hunk| hunk.each { |change| change[0] = '+' } }
-    change_diff(correct_diff).should == diff
+    correct_diff.each do |hunk|
+      hunk.each do |change| change[0] = '+' end
+    end
+    expect(change_diff(correct_diff)).to eq(diff)
   end
 
-  it "should correctly diff 'xx' and 'xaxb'" do
+  it "correctly diffs 'xx' and 'xaxb'" do
     left = 'xx'
     right = 'xaxb'
-    Diff::LCS.patch(left, Diff::LCS.diff(left, right)).should == right
+    expect(Diff::LCS.patch(left, Diff::LCS.diff(left, right))).to eq(right)
   end
 
-  it "should return an empty diff with (hello, hello)" do
-    Diff::LCS.diff(hello, hello).should == []
+  it 'returns an empty diff with (hello, hello)' do
+    expect(Diff::LCS.diff(hello, hello)).to be_empty
   end
 
-  it "should return an empty diff with (hello_ary, hello_ary)" do
-    Diff::LCS.diff(hello_ary, hello_ary).should == []
+  it 'returns an empty diff with (hello_ary, hello_ary)' do
+    expect(Diff::LCS.diff(hello_ary, hello_ary)).to be_empty
   end
 end

data/spec/fixtures/aX

@@ -0,0 +1 @@
+aX

data/spec/fixtures/bXaX

@@ -0,0 +1 @@
+bXaX

data/spec/fixtures/ds1.csv

@@ -0,0 +1,50 @@
+1,3
+2,7
+3,13
+4,21
+5,31
+6,43
+7,57
+8,73
+9,91
+10,111
+11,133
+12,157
+13,183
+14,211
+15,241
+16,273
+17,307
+18,343
+19,381
+20,421
+21,463
+22,507
+23,553
+24,601
+25,651
+26,703
+27,757
+28,813
+29,871
+30,931
+31,993
+32,1057
+33,1123
+34,1191
+35,1261
+36,1333
+37,1407
+38,1483
+39,1561
+40,1641
+41,1723
+42,1807
+43,1893
+44,1981
+45,2071
+46,2163
+47,2257
+48,2353
+49,2451
+50,2500

data/spec/fixtures/ds2.csv

@@ -0,0 +1,51 @@
+  1,3
+2,7
+3,13
+4,21
+5,31
+6,42
+7,57
+8,73
+9,91
+10,111
+11,133
+12,157
+13,183
+14,211
+15,241
+16,273
+17,307
+18,343
+19,200
+20,421
+21,463
+22,507
+23,553
+24,601
+25,651
+26,703
+27,757
+28,813
+29,871
+30,931
+31,123
+32,1057
+33,1123
+34,1000
+35,1261
+36,1333
+37,1407
+38,1483
+39,1561
+40,1641
+41,1723
+42,1807
+43,1893
+44,1981
+45,2071
+46,2163
+47,1524
+48,2353
+49,2451
+50,2500
+51,2520

data/spec/fixtures/ldiff/output.diff

@@ -0,0 +1,4 @@
+1c1
+< aX
+---
+> bXaX

data/spec/fixtures/ldiff/output.diff-c

@@ -0,0 +1,7 @@
+*** spec/fixtures/aX	2019-02-01 22:29:34.000000000 -0500
+--- spec/fixtures/bXaX	2019-02-01 22:29:43.000000000 -0500
+***************
+*** 1 ****
+! aX
+--- 1 ----
+! bXaX

data/spec/fixtures/ldiff/output.diff-e

@@ -0,0 +1,3 @@
+1c
+bXaX
+.

data/spec/fixtures/ldiff/output.diff-f

@@ -0,0 +1,3 @@
+c1
+bXaX
+.

data/spec/fixtures/ldiff/output.diff-u

@@ -0,0 +1,5 @@
+--- spec/fixtures/aX	2019-02-01 22:29:34.000000000 -0500
++++ spec/fixtures/bXaX	2019-02-01 22:29:43.000000000 -0500
+@@ -1 +1 @@
+-aX
++bXaX

data/spec/hunk_spec.rb

@@ -1,72 +1,72 @@
-# -*- ruby encoding: utf-8 -*-
+# frozen_string_literal: true
 
 require 'spec_helper'
 
-def h(v)
-  v.to_s.bytes.to_a.map { |e| "%02x" % e }.join
-end
-
-describe "Diff::LCS::Hunk" do
-  if String.method_defined?(:encoding)
+if String.method_defined?(:encoding)
+  require 'diff/lcs/hunk'
 
-    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')] }
+  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 'should be able to produce a unified diff from the two pieces' do
-      expected = (<<-EOD.gsub(/^\s+/,'').encode('UTF-16LE').chomp)
-        @@ -1,2 +1,2 @@
+    it 'produces a unified diff from the two pieces' do
+      expected = <<-EXPECTED.gsub(/^\s+/, '').encode('UTF-16LE').chomp
+        @@ -1 +1 @@
         -Tu avec carté {count} itém has
         +Tu avec carte {count} item has
-      EOD
-      expect(hunk.diff(:unified).to_s == expected).to eql true
+      EXPECTED
+
+      expect(hunk.diff(:unified)).to eq(expected)
     end
 
-    it 'should be able to produce a context diff from the two pieces' do
-      expected = (<<-EOD.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,2 ****
-        !Tu avec carté {count} itém has
-        --- 1,2 ----
-        !Tu avec carte {count} item has
-      EOD
+        *** 1 ****
+        ! Tu avec carté {count} itém has
+        --- 1 ----
+        ! Tu avec carte {count} item has
+      EXPECTED
 
-      expect(hunk.diff(:context).to_s == expected).to eql true
+      expect(hunk.diff(:context)).to eq(expected)
     end
 
-    it 'should be able to produce an old diff from the two pieces' do
-      expected = (<<-EOD.gsub(/^ +/,'').encode('UTF-16LE').chomp)
-        1,2c1,2
+    it 'produces an old diff from the two pieces' do
+      expected = <<-EXPECTED.gsub(/^ +/, '').encode('UTF-16LE').chomp
+        1c1
         < Tu avec carté {count} itém has
         ---
         > Tu avec carte {count} item has
 
-      EOD
-      expect(hunk.diff(:old).to_s == expected).to eql true
+      EXPECTED
+
+      expect(hunk.diff(:old)).to eq(expected)
     end
 
-    it 'should be able to produce a reverse ed diff from the two pieces' do
-      expected = (<<-EOD.gsub(/^ +/,'').encode('UTF-16LE').chomp)
-        c1,2
+    it 'produces a reverse ed diff from the two pieces' do
+      expected = <<-EXPECTED.gsub(/^ +/, '').encode('UTF-16LE').chomp
+        c1
         Tu avec carte {count} item has
         .
 
-      EOD
-      expect(hunk.diff(:reverse_ed).to_s == expected).to eql true
+      EXPECTED
+
+      expect(hunk.diff(:reverse_ed)).to eq(expected)
     end
 
     context 'with empty first data set' do
       let(:old_data) { [] }
 
-      it 'should be able to produce a unified diff' do
-        expected = (<<-EOD.gsub(/^\s+/,'').encode('UTF-16LE').chomp)
+      it 'produces a unified diff' do
+        expected = <<-EXPECTED.gsub(/^\s+/, '').encode('UTF-16LE').chomp
           @@ -1 +1,2 @@
           +Tu avec carte {count} item has
-        EOD
-        expect(hunk.diff(:unified).to_s == expected).to eql true
+        EXPECTED
+
+        expect(hunk.diff(:unified)).to eq(expected)
       end
     end
-
   end
 end

data/spec/issues_spec.rb

@@ -1,24 +1,98 @@
-# -*- ruby encoding: utf-8 -*-
+# frozen_string_literal: true
 
 require 'spec_helper'
+require 'diff/lcs/hunk'
 
-describe "Diff::LCS Issues" do
+describe 'Diff::LCS Issues' do
   include Diff::LCS::SpecHelper::Matchers
 
-  it "should not fail to provide a simple patchset (issue 1)" do
-    s1, s2 = *%W(aX bXaX)
-    correct_forward_diff = [
-      [ [ '+', 0, 'b' ],
-        [ '+', 1, 'X' ] ],
-    ]
-
-    diff_s1_s2 = Diff::LCS.diff(s1, s2)
-    change_diff(correct_forward_diff).should == diff_s1_s2
-    expect do
-      Diff::LCS.patch(s1, diff_s1_s2).should == s2
-    end.to_not raise_error(RuntimeError, /provided patchset/)
-    expect do
-      Diff::LCS.patch(s2, diff_s1_s2).should == s1
-    end.to_not raise_error(RuntimeError, /provided patchset/)
+  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
 end

data/spec/lcs_spec.rb

@@ -1,54 +1,56 @@
-# -*- ruby encoding: utf-8 -*-
+# frozen_string_literal: true
 
 require 'spec_helper'
 
-describe "Diff::LCS::Internals.lcs" do
+describe Diff::LCS::Internals, '.lcs' do
   include Diff::LCS::SpecHelper::Matchers
 
-  it "should return 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.
-    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 all indexes with (hello, hello)" do
-    Diff::LCS::Internals.lcs(hello, hello).should == (0...hello.size).to_a
+  it 'returns all indexes with (hello, hello)' do
+    expect(Diff::LCS::Internals.lcs(hello, hello)).to \
+      eq((0...hello.size).to_a)
   end
 
-  it "should return all indexes with (hello_ary, hello_ary)" do
-    Diff::LCS::Internals.lcs(hello_ary, hello_ary).should == (0...hello_ary.size).to_a
+  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 "should return 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)
-    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 "should return %W(h e l l o) with (hello, hello)" do
-    Diff::LCS.LCS(hello, hello).should == hello.split(//)
+  it 'returns %W(h e l l o) with (hello, hello)' do
+    expect(Diff::LCS.LCS(hello, hello)).to eq(hello.split(//))
   end
 
-  it "should return hello_ary with (hello_ary, hello_ary)" do
-    Diff::LCS.LCS(hello_ary, hello_ary).should == hello_ary
+  it 'returns hello_ary with (hello_ary, hello_ary)' do
+    expect(Diff::LCS.LCS(hello_ary, hello_ary)).to eq(hello_ary)
   end
 end