diff-lcs 1.3 → 1.4

data/spec/fixtures/aX

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

data/spec/fixtures/bXaX

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

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,4 +1,4 @@
-# -*- ruby encoding: utf-8 -*-
+# frozen_string_literal: true
 
 require 'spec_helper'
 
@@ -6,52 +6,52 @@ if String.method_defined?(:encoding)
   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(: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 @@
+      expected = <<-EXPECTED.gsub(/^\s+/, '').encode('UTF-16LE').chomp
+        @@ -1 +1 @@
         -Tu avec carté {count} itém has
         +Tu avec carte {count} item has
-      EOD
+      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)
+      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 eq(expected)
     end
 
     it 'produces an old diff from the two pieces' do
-      expected = (<<-EOD.gsub(/^ +/,'').encode('UTF-16LE').chomp)
-        1,2c1,2
+      expected = <<-EXPECTED.gsub(/^ +/, '').encode('UTF-16LE').chomp
+        1c1
         < Tu avec carté {count} itém has
         ---
         > Tu avec carte {count} item has
 
-      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
+      expected = <<-EXPECTED.gsub(/^ +/, '').encode('UTF-16LE').chomp
+        c1
         Tu avec carte {count} item has
         .
 
-      EOD
+      EXPECTED
 
       expect(hunk.diff(:reverse_ed)).to eq(expected)
     end
@@ -60,10 +60,10 @@ if String.method_defined?(:encoding)
       let(:old_data) { [] }
 
       it 'produces a unified diff' do
-        expected = (<<-EOD.gsub(/^\s+/,'').encode('UTF-16LE').chomp)
+        expected = <<-EXPECTED.gsub(/^\s+/, '').encode('UTF-16LE').chomp
           @@ -1 +1,2 @@
           +Tu avec carte {count} item has
-        EOD
+        EXPECTED
 
         expect(hunk.diff(:unified)).to eq(expected)
       end

data/spec/issues_spec.rb

@@ -1,8 +1,8 @@
-# -*- ruby encoding: utf-8 -*-
+# frozen_string_literal: true
 
 require 'spec_helper'
 
-describe "Diff::LCS Issues" do
+describe 'Diff::LCS Issues' do
   include Diff::LCS::SpecHelper::Matchers
 
   describe 'issue #1' do
@@ -26,23 +26,31 @@ describe "Diff::LCS Issues" do
 
     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', [
-        [ [ '-', 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), [
-        [ [ '+', 0, 'b' ],
-          [ '+', 1, 'X' ] ],
+        [
+          ['+', 0, 'b'],
+          ['+', 1, '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

data/spec/lcs_spec.rb

@@ -1,11 +1,11 @@
-# -*- 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 "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
+  it 'returns %W(h e l l o) with (hello, hello)' do
     expect(Diff::LCS.LCS(hello, hello)).to eq(hello.split(//))
   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,47 +1,72 @@
-# -*- ruby encoding: utf-8 -*-
+# frozen_string_literal: true
 
 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)
+  let(:output_diff) { read_fixture }
+  let(:output_diff_c) { read_fixture('-c') }
+  let(:output_diff_e) { read_fixture('-e') }
+  let(:output_diff_f) { read_fixture('-f') }
+  let(:output_diff_u) { read_fixture('-u') }
+
+  specify do
+    expect(run_ldiff).to eq(output_diff)
   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)
+  specify do
+    expect(run_ldiff('-c')).to eq(output_diff_c)
   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' ] ]
-    ]
+  specify do
+    expect(run_ldiff('-e')).to eq(output_diff_e)
+  end
 
-    expect(change_diff(correct_diff)).to eq(diff)
+  specify do
+    expect(run_ldiff('-f')).to eq(output_diff_f)
+  end
+
+  specify do
+    expect(run_ldiff('-u')).to eq(output_diff_u)
+  end
 
-    diff = Diff::LCS.diff([], word_sequence)
-    correct_diff.each { |hunk| hunk.each { |change| change[0] = '+' } }
-    expect(change_diff(correct_diff)).to eq(diff)
+  def read_fixture(flag = nil)
+    clean_data(IO.binread("spec/fixtures/ldiff/output.diff#{flag}"), 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)
+    case flag
+    when '-c', '-u'
+      clean_output_timestamp(data)
+    else
+      data
+    end
   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/(\w+)
+        \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(flag = nil, left: 'aX', right: 'bXaX')
+    stdout, stderr = capture_subprocess_io do
+      system("ruby -Ilib bin/ldiff #{flag} spec/fixtures/#{left} spec/fixtures/#{right}")
+    end
+    expect(stderr).to be_empty
+    expect(stdout).not_to be_empty
+    clean_data(stdout, flag)
   end
 end

data/spec/patch_spec.rb

@@ -1,54 +1,54 @@
-# -*- ruby encoding: utf-8 -*-
+# frozen_string_literal: true
 
 require 'spec_helper'
 
-describe "Diff::LCS.patch" do
+describe 'Diff::LCS.patch' do
   include Diff::LCS::SpecHelper::Matchers
 
-  shared_examples "patch sequences correctly" do
-    it "correctly patches left-to-right (patch autodiscovery)" do
+  shared_examples 'patch sequences correctly' do
+    it 'correctly patches left-to-right (patch autodiscovery)' do
       expect(Diff::LCS.patch(s1, patch_set)).to eq(s2)
     end
 
-    it "correctly patches left-to-right (explicit patch)" do
+    it 'correctly patches left-to-right (explicit patch)' do
       expect(Diff::LCS.patch(s1, patch_set, :patch)).to eq(s2)
       expect(Diff::LCS.patch!(s1, patch_set)).to eq(s2)
     end
 
-    it "correctly patches right-to-left (unpatch autodiscovery)" do
+    it 'correctly patches right-to-left (unpatch autodiscovery)' do
       expect(Diff::LCS.patch(s2, patch_set)).to eq(s1)
     end
 
-    it "correctly patches right-to-left (explicit unpatch)" do
+    it 'correctly patches right-to-left (explicit unpatch)' do
       expect(Diff::LCS.patch(s2, patch_set, :unpatch)).to eq(s1)
       expect(Diff::LCS.unpatch!(s2, patch_set)).to eq(s1)
     end
   end
 
-  describe "using a Diff::LCS.diff patchset" do
-    describe "an empty patchset returns the source" do
-      it "works on a string (hello)" do
+  describe 'using a Diff::LCS.diff patchset' 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
+      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
 
-    describe "with default diff callbacks (DiffCallbacks)" do
-      describe "forward (s1 -> s2)" do
-        it_has_behavior "patch sequences correctly" do
+    describe 'with default diff callbacks (DiffCallbacks)' do
+      describe 'forward (s1 -> s2)' do
+        it_has_behavior 'patch sequences correctly' do
           let(:s1) { seq1 }
           let(:s2) { seq2 }
           let(:patch_set) { Diff::LCS.diff(seq1, seq2) }
         end
       end
 
-      describe "reverse (s2 -> s1)" do
-        it_has_behavior "patch sequences correctly" do
+      describe 'reverse (s2 -> s1)' do
+        it_has_behavior 'patch sequences correctly' do
           let(:s1) { seq2 }
           let(:s2) { seq1 }
           let(:patch_set) { Diff::LCS.diff(seq2, seq1) }
@@ -56,9 +56,9 @@ describe "Diff::LCS.patch" do
       end
     end
 
-    describe "with context diff callbacks (ContextDiffCallbacks)" do
-      describe "forward (s1 -> s2)" do
-        it_has_behavior "patch sequences correctly" do
+    describe 'with context diff callbacks (ContextDiffCallbacks)' do
+      describe 'forward (s1 -> s2)' do
+        it_has_behavior 'patch sequences correctly' do
           let(:s1) { seq1 }
           let(:s2) { seq2 }
           let(:patch_set) {
@@ -67,8 +67,8 @@ describe "Diff::LCS.patch" do
         end
       end
 
-      describe "reverse (s2 -> s1)" do
-        it_has_behavior "patch sequences correctly" do
+      describe 'reverse (s2 -> s1)' do
+        it_has_behavior 'patch sequences correctly' do
           let(:s1) { seq2 }
           let(:s2) { seq1 }
           let(:patch_set) {
@@ -78,9 +78,9 @@ describe "Diff::LCS.patch" do
       end
     end
 
-    describe "with sdiff callbacks (SDiffCallbacks)" do
-      describe "forward (s1 -> s2)" do
-        it_has_behavior "patch sequences correctly" do
+    describe 'with sdiff callbacks (SDiffCallbacks)' do
+      describe 'forward (s1 -> s2)' do
+        it_has_behavior 'patch sequences correctly' do
           let(:s1) { seq1 }
           let(:s2) { seq2 }
           let(:patch_set) {
@@ -89,8 +89,8 @@ describe "Diff::LCS.patch" do
         end
       end
 
-      describe "reverse (s2 -> s1)" do
-        it_has_behavior "patch sequences correctly" do
+      describe 'reverse (s2 -> s1)' do
+        it_has_behavior 'patch sequences correctly' do
           let(:s1) { seq2 }
           let(:s2) { seq1 }
           let(:patch_set) {
@@ -101,20 +101,20 @@ describe "Diff::LCS.patch" do
     end
   end
 
-  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)
+  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)
       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)
+      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)
       end
     end
 
-    describe "with default diff callbacks (DiffCallbacks)" do
-      describe "forward (s1 -> s2)" do
-        it_has_behavior "patch sequences correctly" do
+    describe 'with default diff callbacks (DiffCallbacks)' do
+      describe 'forward (s1 -> s2)' do
+        it_has_behavior 'patch sequences correctly' do
           let(:s1) { seq1 }
           let(:s2) { seq2 }
           let(:patch_set) {
@@ -123,8 +123,8 @@ describe "Diff::LCS.patch" do
         end
       end
 
-      describe "reverse (s2 -> s1)" do
-        it_has_behavior "patch sequences correctly" do
+      describe 'reverse (s2 -> s1)' do
+        it_has_behavior 'patch sequences correctly' do
           let(:s1) { seq2 }
           let(:s2) { seq1 }
           let(:patch_set) {
@@ -134,9 +134,9 @@ describe "Diff::LCS.patch" do
       end
     end
 
-    describe "with context diff callbacks (DiffCallbacks)" do
-      describe "forward (s1 -> s2)" do
-        it_has_behavior "patch sequences correctly" do
+    describe 'with context diff callbacks (DiffCallbacks)' do
+      describe 'forward (s1 -> s2)' do
+        it_has_behavior 'patch sequences correctly' do
           let(:s1) { seq1 }
           let(:s2) { seq2 }
           let(:patch_set) {
@@ -145,8 +145,8 @@ describe "Diff::LCS.patch" do
         end
       end
 
-      describe "reverse (s2 -> s1)" do
-        it_has_behavior "patch sequences correctly" do
+      describe 'reverse (s2 -> s1)' do
+        it_has_behavior 'patch sequences correctly' do
           let(:s1) { seq2 }
           let(:s2) { seq1 }
           let(:patch_set) {
@@ -156,17 +156,17 @@ describe "Diff::LCS.patch" do
       end
     end
 
-    describe "with sdiff callbacks (SDiffCallbacks)" do
-      describe "forward (s1 -> s2)" do
-        it_has_behavior "patch sequences correctly" do
+    describe 'with sdiff callbacks (SDiffCallbacks)' do
+      describe 'forward (s1 -> s2)' do
+        it_has_behavior 'patch sequences correctly' do
           let(:s1) { seq1 }
           let(:s2) { seq2 }
           let(:patch_set) { Diff::LCS.sdiff(seq1, seq2) }
         end
       end
 
-      describe "reverse (s2 -> s1)" do
-        it_has_behavior "patch sequences correctly" do
+      describe 'reverse (s2 -> s1)' do
+        it_has_behavior 'patch sequences correctly' do
           let(:s1) { seq2 }
           let(:s2) { seq1 }
           let(:patch_set) { Diff::LCS.sdiff(seq2, seq1) }
@@ -179,43 +179,43 @@ describe "Diff::LCS.patch" do
   # to s2 patches"), this cannot use the "patch sequences correctly" shared
   # set. Once the bug in autodiscovery is fixed, this can be converted as
   # above.
-  describe "fix bug 891: patchsets do not contain the last equal part" do
+  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)
+      @s1 = %w(a b c d   e f g h i j k) # rubocop: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
+    describe 'using Diff::LCS.diff with default diff callbacks' do
       before :each do
         @patch_set_s1_s2 = Diff::LCS.diff(@s1, @s2)
         @patch_set_s2_s1 = Diff::LCS.diff(@s2, @s1)
       end
 
-      it "autodiscovers s1 to s2 patches" do
+      it 'autodiscovers s1 to s2 patches' do
         expect do
           expect(Diff::LCS.patch(@s1, @patch_set_s1_s2)).to eq(@s2)
         end.to_not raise_error
       end
 
-      it "autodiscovers s2 to s1 patches" do
+      it 'autodiscovers s2 to s1 patches' do
         expect do
           expect(Diff::LCS.patch(@s1, @patch_set_s2_s1)).to eq(@s2)
         end.to_not raise_error
       end
 
-      it "autodiscovers s2 to s1 the left-to-right patches" do
+      it 'autodiscovers s2 to s1 the left-to-right patches' do
         expect(Diff::LCS.patch(@s2, @patch_set_s2_s1)).to eq(@s1)
         expect(Diff::LCS.patch(@s2, @patch_set_s1_s2)).to eq(@s1)
       end
 
-      it "correctly patches left-to-right (explicit patch)" do
+      it 'correctly patches left-to-right (explicit patch)' do
         expect(Diff::LCS.patch(@s1, @patch_set_s1_s2, :patch)).to eq(@s2)
         expect(Diff::LCS.patch(@s2, @patch_set_s2_s1, :patch)).to eq(@s1)
         expect(Diff::LCS.patch!(@s1, @patch_set_s1_s2)).to eq(@s2)
         expect(Diff::LCS.patch!(@s2, @patch_set_s2_s1)).to eq(@s1)
       end
 
-      it "correctly patches right-to-left (explicit unpatch)" do
+      it 'correctly patches right-to-left (explicit unpatch)' do
         expect(Diff::LCS.patch(@s2, @patch_set_s1_s2, :unpatch)).to eq(@s1)
         expect(Diff::LCS.patch(@s1, @patch_set_s2_s1, :unpatch)).to eq(@s2)
         expect(Diff::LCS.unpatch!(@s2, @patch_set_s1_s2)).to eq(@s1)
@@ -223,39 +223,37 @@ describe "Diff::LCS.patch" do
       end
     end
 
-    describe "using Diff::LCS.diff with context diff callbacks" 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
+      it 'autodiscovers s1 to s2 patches' do
         expect do
           expect(Diff::LCS.patch(@s1, @patch_set_s1_s2)).to eq(@s2)
         end.to_not raise_error
       end
 
-      it "autodiscovers s2 to s1 patches" do
+      it 'autodiscovers s2 to s1 patches' do
         expect do
           expect(Diff::LCS.patch(@s1, @patch_set_s2_s1)).to eq(@s2)
         end.to_not raise_error
       end
 
-      it "autodiscovers s2 to s1 the left-to-right patches" do
+      it 'autodiscovers s2 to s1 the left-to-right patches' do
         expect(Diff::LCS.patch(@s2, @patch_set_s2_s1)).to eq(@s1)
         expect(Diff::LCS.patch(@s2, @patch_set_s1_s2)).to eq(@s1)
       end
 
-      it "correctly patches left-to-right (explicit patch)" do
+      it 'correctly patches left-to-right (explicit patch)' do
         expect(Diff::LCS.patch(@s1, @patch_set_s1_s2, :patch)).to eq(@s2)
         expect(Diff::LCS.patch(@s2, @patch_set_s2_s1, :patch)).to eq(@s1)
         expect(Diff::LCS.patch!(@s1, @patch_set_s1_s2)).to eq(@s2)
         expect(Diff::LCS.patch!(@s2, @patch_set_s2_s1)).to eq(@s1)
       end
 
-      it "correctly patches right-to-left (explicit unpatch)" do
+      it 'correctly patches right-to-left (explicit unpatch)' do
         expect(Diff::LCS.patch(@s2, @patch_set_s1_s2, :unpatch)).to eq(@s1)
         expect(Diff::LCS.patch(@s1, @patch_set_s2_s1, :unpatch)).to eq(@s2)
         expect(Diff::LCS.unpatch!(@s2, @patch_set_s1_s2)).to eq(@s1)
@@ -263,39 +261,37 @@ describe "Diff::LCS.patch" do
       end
     end
 
-    describe "using Diff::LCS.diff with sdiff callbacks" 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
+      it 'autodiscovers s1 to s2 patches' do
         expect do
           expect(Diff::LCS.patch(@s1, @patch_set_s1_s2)).to eq(@s2)
         end.to_not raise_error
       end
 
-      it "autodiscovers s2 to s1 patches" do
+      it 'autodiscovers s2 to s1 patches' do
         expect do
           expect(Diff::LCS.patch(@s1, @patch_set_s2_s1)).to eq(@s2)
         end.to_not raise_error
       end
 
-      it "autodiscovers s2 to s1 the left-to-right patches" do
+      it 'autodiscovers s2 to s1 the left-to-right patches' do
         expect(Diff::LCS.patch(@s2, @patch_set_s2_s1)).to eq(@s1)
         expect(Diff::LCS.patch(@s2, @patch_set_s1_s2)).to eq(@s1)
       end
 
-      it "correctly patches left-to-right (explicit patch)" do
+      it 'correctly patches left-to-right (explicit patch)' do
         expect(Diff::LCS.patch(@s1, @patch_set_s1_s2, :patch)).to eq(@s2)
         expect(Diff::LCS.patch(@s2, @patch_set_s2_s1, :patch)).to eq(@s1)
         expect(Diff::LCS.patch!(@s1, @patch_set_s1_s2)).to eq(@s2)
         expect(Diff::LCS.patch!(@s2, @patch_set_s2_s1)).to eq(@s1)
       end
 
-      it "correctly patches right-to-left (explicit unpatch)" do
+      it 'correctly patches right-to-left (explicit unpatch)' do
         expect(Diff::LCS.patch(@s2, @patch_set_s1_s2, :unpatch)).to eq(@s1)
         expect(Diff::LCS.patch(@s1, @patch_set_s2_s1, :unpatch)).to eq(@s2)
         expect(Diff::LCS.unpatch!(@s2, @patch_set_s1_s2)).to eq(@s1)
@@ -303,37 +299,37 @@ describe "Diff::LCS.patch" do
       end
     end
 
-    describe "using Diff::LCS.sdiff with default sdiff callbacks" do
+    describe 'using Diff::LCS.sdiff with default sdiff callbacks' do
       before(:each) do
         @patch_set_s1_s2 = Diff::LCS.sdiff(@s1, @s2)
         @patch_set_s2_s1 = Diff::LCS.sdiff(@s2, @s1)
       end
 
-      it "autodiscovers s1 to s2 patches" do
+      it 'autodiscovers s1 to s2 patches' do
         expect do
           expect(Diff::LCS.patch(@s1, @patch_set_s1_s2)).to eq(@s2)
         end.to_not raise_error
       end
 
-      it "autodiscovers s2 to s1 patches" do
+      it 'autodiscovers s2 to s1 patches' do
         expect do
           expect(Diff::LCS.patch(@s1, @patch_set_s2_s1)).to eq(@s2)
         end.to_not raise_error
       end
 
-      it "autodiscovers s2 to s1 the left-to-right patches" do
+      it 'autodiscovers s2 to s1 the left-to-right patches' do
         expect(Diff::LCS.patch(@s2, @patch_set_s2_s1)).to eq(@s1)
         expect(Diff::LCS.patch(@s2, @patch_set_s1_s2)).to eq(@s1)
       end
 
-      it "correctly patches left-to-right (explicit patch)" do
+      it 'correctly patches left-to-right (explicit patch)' do
         expect(Diff::LCS.patch(@s1, @patch_set_s1_s2, :patch)).to eq(@s2)
         expect(Diff::LCS.patch(@s2, @patch_set_s2_s1, :patch)).to eq(@s1)
         expect(Diff::LCS.patch!(@s1, @patch_set_s1_s2)).to eq(@s2)
         expect(Diff::LCS.patch!(@s2, @patch_set_s2_s1)).to eq(@s1)
       end
 
-      it "correctly patches right-to-left (explicit unpatch)" do
+      it 'correctly patches right-to-left (explicit unpatch)' do
         expect(Diff::LCS.patch(@s2, @patch_set_s1_s2, :unpatch)).to eq(@s1)
         expect(Diff::LCS.patch(@s1, @patch_set_s2_s1, :unpatch)).to eq(@s2)
         expect(Diff::LCS.unpatch!(@s2, @patch_set_s1_s2)).to eq(@s1)
@@ -341,39 +337,37 @@ describe "Diff::LCS.patch" do
       end
     end
 
-    describe "using Diff::LCS.sdiff with context diff callbacks" 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
+      it 'autodiscovers s1 to s2 patches' do
         expect do
           expect(Diff::LCS.patch(@s1, @patch_set_s1_s2)).to eq(@s2)
         end.to_not raise_error
       end
 
-      it "autodiscovers s2 to s1 patches" do
+      it 'autodiscovers s2 to s1 patches' do
         expect do
           expect(Diff::LCS.patch(@s1, @patch_set_s2_s1)).to eq(@s2)
         end.to_not raise_error
       end
 
-      it "autodiscovers s2 to s1 the left-to-right patches" do
+      it 'autodiscovers s2 to s1 the left-to-right patches' do
         expect(Diff::LCS.patch(@s2, @patch_set_s2_s1)).to eq(@s1)
         expect(Diff::LCS.patch(@s2, @patch_set_s1_s2)).to eq(@s1)
       end
 
-      it "correctly patches left-to-right (explicit patch)" do
+      it 'correctly patches left-to-right (explicit patch)' do
         expect(Diff::LCS.patch(@s1, @patch_set_s1_s2, :patch)).to eq(@s2)
         expect(Diff::LCS.patch(@s2, @patch_set_s2_s1, :patch)).to eq(@s1)
         expect(Diff::LCS.patch!(@s1, @patch_set_s1_s2)).to eq(@s2)
         expect(Diff::LCS.patch!(@s2, @patch_set_s2_s1)).to eq(@s1)
       end
 
-      it "correctly patches right-to-left (explicit unpatch)" do
+      it 'correctly patches right-to-left (explicit unpatch)' do
         expect(Diff::LCS.patch(@s2, @patch_set_s1_s2, :unpatch)).to eq(@s1)
         expect(Diff::LCS.patch(@s1, @patch_set_s2_s1, :unpatch)).to eq(@s2)
         expect(Diff::LCS.unpatch!(@s2, @patch_set_s1_s2)).to eq(@s1)
@@ -381,37 +375,37 @@ describe "Diff::LCS.patch" do
       end
     end
 
-    describe "using Diff::LCS.sdiff with default diff callbacks" do
+    describe 'using Diff::LCS.sdiff with default diff callbacks' do
       before(:each) do
         @patch_set_s1_s2 = Diff::LCS.sdiff(@s1, @s2, Diff::LCS::DiffCallbacks)
         @patch_set_s2_s1 = Diff::LCS.sdiff(@s2, @s1, Diff::LCS::DiffCallbacks)
       end
 
-      it "autodiscovers s1 to s2 patches" do
+      it 'autodiscovers s1 to s2 patches' do
         expect do
           expect(Diff::LCS.patch(@s1, @patch_set_s1_s2)).to eq(@s2)
         end.to_not raise_error
       end
 
-      it "autodiscovers s2 to s1 patches" do
+      it 'autodiscovers s2 to s1 patches' do
         expect do
           expect(Diff::LCS.patch(@s1, @patch_set_s2_s1)).to eq(@s2)
         end.to_not raise_error
       end
 
-      it "autodiscovers s2 to s1 the left-to-right patches" do
+      it 'autodiscovers s2 to s1 the left-to-right patches' do
         expect(Diff::LCS.patch(@s2, @patch_set_s2_s1)).to eq(@s1)
         expect(Diff::LCS.patch(@s2, @patch_set_s1_s2)).to eq(@s1)
       end
 
-      it "correctly patches left-to-right (explicit patch)" do
+      it 'correctly patches left-to-right (explicit patch)' do
         expect(Diff::LCS.patch(@s1, @patch_set_s1_s2, :patch)).to eq(@s2)
         expect(Diff::LCS.patch(@s2, @patch_set_s2_s1, :patch)).to eq(@s1)
         expect(Diff::LCS.patch!(@s1, @patch_set_s1_s2)).to eq(@s2)
         expect(Diff::LCS.patch!(@s2, @patch_set_s2_s1)).to eq(@s1)
       end
 
-      it "correctly patches right-to-left (explicit unpatch)" do
+      it 'correctly patches right-to-left (explicit unpatch)' do
         expect(Diff::LCS.patch(@s2, @patch_set_s1_s2, :unpatch)).to eq(@s1)
         expect(Diff::LCS.patch(@s1, @patch_set_s2_s1, :unpatch)).to eq(@s2)
         expect(Diff::LCS.unpatch!(@s2, @patch_set_s1_s2)).to eq(@s1)