diff-lcs 1.5.0 → 1.5.1

data/spec/change_spec.rb

@@ -1,89 +1,89 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
+require "spec_helper"
 
 describe Diff::LCS::Change do
-  describe 'an add' do
-    subject { described_class.new('+', 0, 'element') }
-    it { should_not be_deleting   }
-    it { should     be_adding     }
-    it { should_not be_unchanged  }
-    it { should_not be_changed    }
+  describe "an add" do
+    subject { described_class.new("+", 0, "element") }
+    it { should_not be_deleting }
+    it { should be_adding }
+    it { should_not be_unchanged }
+    it { should_not be_changed }
     it { should_not be_finished_a }
     it { should_not be_finished_b }
   end
 
-  describe 'a delete' do
-    subject { described_class.new('-', 0, 'element') }
-    it { should     be_deleting   }
-    it { should_not be_adding     }
-    it { should_not be_unchanged  }
-    it { should_not be_changed    }
+  describe "a delete" do
+    subject { described_class.new("-", 0, "element") }
+    it { should be_deleting }
+    it { should_not be_adding }
+    it { should_not be_unchanged }
+    it { should_not be_changed }
     it { should_not be_finished_a }
     it { should_not be_finished_b }
   end
 
-  describe 'an unchanged' do
-    subject { described_class.new('=', 0, 'element') }
-    it { should_not be_deleting   }
-    it { should_not be_adding     }
-    it { should     be_unchanged  }
-    it { should_not be_changed    }
+  describe "an unchanged" do
+    subject { described_class.new("=", 0, "element") }
+    it { should_not be_deleting }
+    it { should_not be_adding }
+    it { should be_unchanged }
+    it { should_not be_changed }
     it { should_not be_finished_a }
     it { should_not be_finished_b }
   end
 
-  describe 'a changed' do
-    subject { described_class.new('!', 0, 'element') }
-    it { should_not be_deleting   }
-    it { should_not be_adding     }
-    it { should_not be_unchanged  }
-    it { should     be_changed    }
+  describe "a changed" do
+    subject { described_class.new("!", 0, "element") }
+    it { should_not be_deleting }
+    it { should_not be_adding }
+    it { should_not be_unchanged }
+    it { should be_changed }
     it { should_not be_finished_a }
     it { should_not be_finished_b }
   end
 
-  describe 'a finished_a' do
-    subject { described_class.new('>', 0, 'element') }
-    it { should_not be_deleting   }
-    it { should_not be_adding     }
-    it { should_not be_unchanged  }
-    it { should_not be_changed    }
-    it { should     be_finished_a }
+  describe "a finished_a" do
+    subject { described_class.new(">", 0, "element") }
+    it { should_not be_deleting }
+    it { should_not be_adding }
+    it { should_not be_unchanged }
+    it { should_not be_changed }
+    it { should be_finished_a }
     it { should_not be_finished_b }
   end
 
-  describe 'a finished_b' do
-    subject { described_class.new('<', 0, 'element') }
-    it { should_not be_deleting   }
-    it { should_not be_adding     }
-    it { should_not be_unchanged  }
-    it { should_not be_changed    }
+  describe "a finished_b" do
+    subject { described_class.new("<", 0, "element") }
+    it { should_not be_deleting }
+    it { should_not be_adding }
+    it { should_not be_unchanged }
+    it { should_not be_changed }
     it { should_not be_finished_a }
-    it { should     be_finished_b }
+    it { should be_finished_b }
   end
 
-  describe 'as array' do
-    it 'should be converted' do
-      action, position, element = described_class.new('!', 0, 'element')
-      expect(action).to eq '!'
+  describe "as array" do
+    it "should be converted" do
+      action, position, element = described_class.new("!", 0, "element")
+      expect(action).to eq "!"
       expect(position).to eq 0
-      expect(element).to eq 'element'
+      expect(element).to eq "element"
     end
   end
 end
 
 describe Diff::LCS::ContextChange do
-  describe 'as array' do
-    it 'should be converted' do
+  describe "as array" do
+    it "should be converted" do
       action, (old_position, old_element), (new_position, new_element) =
-        described_class.new('!', 1, 'old_element', 2, 'new_element')
+        described_class.new("!", 1, "old_element", 2, "new_element")
 
-      expect(action).to eq '!'
+      expect(action).to eq "!"
       expect(old_position).to eq 1
-      expect(old_element).to eq 'old_element'
+      expect(old_element).to eq "old_element"
       expect(new_position).to eq 2
-      expect(new_element).to eq 'new_element'
+      expect(new_element).to eq "new_element"
     end
   end
 end

data/spec/diff_spec.rb

@@ -1,28 +1,28 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
+require "spec_helper"
 
-describe Diff::LCS, '.diff' do
+describe Diff::LCS, ".diff" do
   include Diff::LCS::SpecHelper::Matchers
 
-  it 'correctly diffs seq1 to seq2' do
+  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)
   end
 
-  it 'correctly diffs seq2 to seq1' do
+  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)
   end
 
-  it 'correctly diffs 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"]
       ]
     ]
 
@@ -30,22 +30,22 @@ describe Diff::LCS, '.diff' do
 
     diff = Diff::LCS.diff([], word_sequence)
     correct_diff.each do |hunk|
-      hunk.each do |change| change[0] = '+' end
+      hunk.each { |change| change[0] = "+" }
     end
     expect(change_diff(correct_diff)).to eq(diff)
   end
 
   it "correctly diffs 'xx' and 'xaxb'" do
-    left = 'xx'
-    right = 'xaxb'
+    left = "xx"
+    right = "xaxb"
     expect(Diff::LCS.patch(left, Diff::LCS.diff(left, right))).to eq(right)
   end
 
-  it 'returns an empty diff with (hello, hello)' do
+  it "returns an empty diff with (hello, hello)" do
     expect(Diff::LCS.diff(hello, hello)).to be_empty
   end
 
-  it 'returns an empty diff with (hello_ary, hello_ary)' do
+  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/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,11 +67,11 @@ 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
+      it "produces a unified diff" do
+        expected = <<-EXPECTED.gsub(/^\s+/, "").encode("UTF-16LE").chomp
           @@ -1 +1,2 @@
           +Tu a un carte avec {count} items
         EXPECTED

data/spec/issues_spec.rb

@@ -1,73 +1,76 @@
 # 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
+  describe "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",
@@ -93,10 +96,11 @@ describe 'Diff::LCS Issues' do
 +  "description": "lo"
  }
       EXPECTED
+      # standard:enable Layout/HeredocIndentation
     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 +109,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 +119,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 +154,7 @@ describe 'Diff::LCS Issues' do
 +recipe[q::new]
 +recipe[r::new]
       EODIFF
+      # 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,29 +1,31 @@
 # 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 => "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
   }
+  # 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(' ')
+    ].join(" ")
 
     it desc do
       expect(run_ldiff(fixture)).to eq(read_fixture(fixture))
@@ -45,7 +47,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,7 +82,7 @@ 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(stderr).to be_empty if RUBY_VERSION >= "1.9"
     expect(stdout).not_to be_empty
     clean_data(stdout, flag)
   end