diff-lcs 1.1.3 → 1.5.0

data/spec/sdiff_spec.rb

@@ -1,204 +1,214 @@
-# -*- ruby encoding: utf-8 -*-
+# frozen_string_literal: true
 
 require 'spec_helper'
 
-describe "Diff::LCS.sdiff" do
+describe 'Diff::LCS.sdiff' do
   include Diff::LCS::SpecHelper::Matchers
 
-  shared_examples "compare sequences correctly" do
-    it "should compare s1 -> s2 correctly" do
-      Diff::LCS.sdiff(s1, s2).should == context_diff(result)
+  shared_examples 'compare sequences correctly' do
+    it 'compares s1 -> s2 correctly' do
+      expect(Diff::LCS.sdiff(s1, s2)).to eq(context_diff(result))
     end
 
-    it "should compare s2 -> s1 correctly" do
-      Diff::LCS.sdiff(s2, s1).should == context_diff(reverse_sdiff(result))
+    it 'compares s2 -> s1 correctly' do
+      expect(Diff::LCS.sdiff(s2, s1)).to eq(context_diff(reverse_sdiff(result)))
     end
   end
 
-  describe "using seq1 & seq2" do
+  describe 'using seq1 & seq2' do
     let(:s1) { seq1 }
     let(:s2) { seq2 }
     let(:result) { correct_forward_sdiff }
 
-    it_has_behavior "compare sequences correctly"
+    it_has_behavior 'compare sequences correctly'
   end
 
-  describe "using %w(abc def yyy xxx ghi jkl) & %w(abc dxf xxx ghi jkl)" do
+  describe 'using %w(abc def yyy xxx ghi jkl) & %w(abc dxf xxx ghi jkl)' do
     let(:s1) { %w(abc def yyy xxx ghi jkl) }
     let(:s2) { %w(abc dxf xxx ghi jkl) }
     let(:result) {
       [
-        [ '=', [ 0, 'abc' ], [ 0, 'abc' ] ],
-        [ '!', [ 1, 'def' ], [ 1, 'dxf' ] ],
-        [ '-', [ 2, 'yyy' ], [ 2,  nil  ] ],
-        [ '=', [ 3, 'xxx' ], [ 2, 'xxx' ] ],
-        [ '=', [ 4, 'ghi' ], [ 3, 'ghi' ] ],
-        [ '=', [ 5, 'jkl' ], [ 4, 'jkl' ] ]
+        ['=', [0, 'abc'], [0, 'abc']],
+        ['!', [1, 'def'], [1, 'dxf']],
+        ['-', [2, 'yyy'], [2,  nil]],
+        ['=', [3, 'xxx'], [2, 'xxx']],
+        ['=', [4, 'ghi'], [3, 'ghi']],
+        ['=', [5, 'jkl'], [4, 'jkl']]
       ]
     }
 
-    it_has_behavior "compare sequences correctly"
+    it_has_behavior 'compare sequences correctly'
   end
 
-  describe "using %w(a b c d e) & %w(a e)" do
+  describe 'using %w(a b c d e) & %w(a e)' do
     let(:s1) { %w(a b c d e) }
     let(:s2) { %w(a e) }
     let(:result) {
       [
-        [ '=', [ 0, 'a' ], [ 0, 'a' ] ],
-        [ '-', [ 1, 'b' ], [ 1, nil ] ],
-        [ '-', [ 2, 'c' ], [ 1, nil ] ],
-        [ '-', [ 3, 'd' ], [ 1, nil ] ],
-        [ '=', [ 4, 'e' ], [ 1, 'e' ] ]
+        ['=', [0, 'a'], [0, 'a']],
+        ['-', [1, 'b'], [1, nil]],
+        ['-', [2, 'c'], [1, nil]],
+        ['-', [3, 'd'], [1, nil]],
+        ['=', [4, 'e'], [1, 'e']]
       ]
     }
 
-    it_has_behavior "compare sequences correctly"
+    it_has_behavior 'compare sequences correctly'
   end
 
-  describe "using %w(a e) & %w(a b c d e)" do
+  describe 'using %w(a e) & %w(a b c d e)' do
     let(:s1) { %w(a e) }
     let(:s2) { %w(a b c d e) }
     let(:result) {
       [
-        [ '=', [ 0, 'a' ], [ 0, 'a' ] ],
-        [ '+', [ 1, nil ], [ 1, 'b' ] ],
-        [ '+', [ 1, nil ], [ 2, 'c' ] ],
-        [ '+', [ 1, nil ], [ 3, 'd' ] ],
-        [ '=', [ 1, 'e' ], [ 4, 'e' ] ]
+        ['=', [0, 'a'], [0, 'a']],
+        ['+', [1, nil], [1, 'b']],
+        ['+', [1, nil], [2, 'c']],
+        ['+', [1, nil], [3, 'd']],
+        ['=', [1, 'e'], [4, 'e']]
       ]
     }
 
-    it_has_behavior "compare sequences correctly"
+    it_has_behavior 'compare sequences correctly'
   end
 
-  describe "using %w(v x a e) & %w(w y a b c d e)" do
+  describe 'using %w(v x a e) & %w(w y a b c d e)' do
     let(:s1) { %w(v x a e) }
     let(:s2) { %w(w y a b c d e) }
     let(:result) {
       [
-        [ '!', [ 0, 'v' ], [ 0, 'w' ] ],
-        [ '!', [ 1, 'x' ], [ 1, 'y' ] ],
-        [ '=', [ 2, 'a' ], [ 2, 'a' ] ],
-        [ '+', [ 3, nil ], [ 3, 'b' ] ],
-        [ '+', [ 3, nil ], [ 4, 'c' ] ],
-        [ '+', [ 3, nil ], [ 5, 'd' ] ],
-        [ '=', [ 3, 'e' ], [ 6, 'e' ] ]
+        ['!', [0, 'v'], [0, 'w']],
+        ['!', [1, 'x'], [1, 'y']],
+        ['=', [2, 'a'], [2, 'a']],
+        ['+', [3, nil], [3, 'b']],
+        ['+', [3, nil], [4, 'c']],
+        ['+', [3, nil], [5, 'd']],
+        ['=', [3, 'e'], [6, 'e']]
       ]
     }
 
-    it_has_behavior "compare sequences correctly"
+    it_has_behavior 'compare sequences correctly'
   end
 
-  describe "using %w(x a e) & %w(a b c d e)" do
+  describe 'using %w(x a e) & %w(a b c d e)' do
     let(:s1) { %w(x a e) }
     let(:s2) { %w(a b c d e) }
     let(:result) {
       [
-        [ '-', [ 0, 'x' ], [ 0, nil ] ],
-        [ '=', [ 1, 'a' ], [ 0, 'a' ] ],
-        [ '+', [ 2, nil ], [ 1, 'b' ] ],
-        [ '+', [ 2, nil ], [ 2, 'c' ] ],
-        [ '+', [ 2, nil ], [ 3, 'd' ] ],
-        [ '=', [ 2, 'e' ], [ 4, 'e' ] ]
+        ['-', [0, 'x'], [0, nil]],
+        ['=', [1, 'a'], [0, 'a']],
+        ['+', [2, nil], [1, 'b']],
+        ['+', [2, nil], [2, 'c']],
+        ['+', [2, nil], [3, 'd']],
+        ['=', [2, 'e'], [4, 'e']]
       ]
     }
 
-    it_has_behavior "compare sequences correctly"
+    it_has_behavior 'compare sequences correctly'
   end
 
-  describe "using %w(a e) & %w(x a b c d e)" do
+  describe 'using %w(a e) & %w(x a b c d e)' do
     let(:s1) { %w(a e) }
     let(:s2) { %w(x a b c d e) }
     let(:result) {
       [
-        [ '+', [ 0, nil ], [ 0, 'x' ] ],
-        [ '=', [ 0, 'a' ], [ 1, 'a' ] ],
-        [ '+', [ 1, nil ], [ 2, 'b' ] ],
-        [ '+', [ 1, nil ], [ 3, 'c' ] ],
-        [ '+', [ 1, nil ], [ 4, 'd' ] ],
-        [ '=', [ 1, 'e' ], [ 5, 'e' ] ]
+        ['+', [0, nil], [0, 'x']],
+        ['=', [0, 'a'], [1, 'a']],
+        ['+', [1, nil], [2, 'b']],
+        ['+', [1, nil], [3, 'c']],
+        ['+', [1, nil], [4, 'd']],
+        ['=', [1, 'e'], [5, 'e']]
       ]
     }
 
-    it_has_behavior "compare sequences correctly"
+    it_has_behavior 'compare sequences correctly'
   end
 
-  describe "using %w(a e v) & %w(x a b c d e w x)" do
+  describe 'using %w(a e v) & %w(x a b c d e w x)' do
     let(:s1) { %w(a e v) }
     let(:s2) { %w(x a b c d e w x) }
     let(:result) {
       [
-        [ '+', [ 0, nil ], [ 0, 'x' ] ],
-        [ '=', [ 0, 'a' ], [ 1, 'a' ] ],
-        [ '+', [ 1, nil ], [ 2, 'b' ] ],
-        [ '+', [ 1, nil ], [ 3, 'c' ] ],
-        [ '+', [ 1, nil ], [ 4, 'd' ] ],
-        [ '=', [ 1, 'e' ], [ 5, 'e' ] ],
-        [ '!', [ 2, 'v' ], [ 6, 'w' ] ],
-        [ '+', [ 3, nil ], [ 7, 'x' ] ]
+        ['+', [0, nil], [0, 'x']],
+        ['=', [0, 'a'], [1, 'a']],
+        ['+', [1, nil], [2, 'b']],
+        ['+', [1, nil], [3, 'c']],
+        ['+', [1, nil], [4, 'd']],
+        ['=', [1, 'e'], [5, 'e']],
+        ['!', [2, 'v'], [6, 'w']],
+        ['+', [3, nil], [7, 'x']]
       ]
     }
 
-    it_has_behavior "compare sequences correctly"
+    it_has_behavior 'compare sequences correctly'
   end
 
-  describe "using %w() & %w(a b c)" do
+  describe 'using %w() & %w(a b c)' do
     let(:s1) { %w() }
     let(:s2) { %w(a b c) }
     let(:result) {
       [
-        [ '+', [ 0, nil ], [ 0, 'a' ] ],
-        [ '+', [ 0, nil ], [ 1, 'b' ] ],
-        [ '+', [ 0, nil ], [ 2, 'c' ] ]
+        ['+', [0, nil], [0, 'a']],
+        ['+', [0, nil], [1, 'b']],
+        ['+', [0, nil], [2, 'c']]
       ]
     }
 
-    it_has_behavior "compare sequences correctly"
+    it_has_behavior 'compare sequences correctly'
   end
 
-  describe "using %w(a b c) & %w(1)" do
+  describe 'using %w(a b c) & %w(1)' do
     let(:s1) { %w(a b c) }
     let(:s2) { %w(1) }
     let(:result) {
       [
-        [ '!', [ 0, 'a' ], [ 0, '1' ] ],
-        [ '-', [ 1, 'b' ], [ 1, nil ] ],
-        [ '-', [ 2, 'c' ], [ 1, nil ] ]
+        ['!', [0, 'a'], [0, '1']],
+        ['-', [1, 'b'], [1, nil]],
+        ['-', [2, 'c'], [1, nil]]
       ]
     }
 
-    it_has_behavior "compare sequences correctly"
+    it_has_behavior 'compare sequences correctly'
   end
 
-  describe "using %w(a b c) & %w(c)" do
+  describe 'using %w(a b c) & %w(c)' do
     let(:s1) { %w(a b c) }
     let(:s2) { %w(c) }
     let(:result) {
       [
-        [ '-', [ 0, 'a' ], [ 0, nil ] ],
-        [ '-', [ 1, 'b' ], [ 0, nil ] ],
-        [ '=', [ 2, 'c' ], [ 0, 'c' ] ]
+        ['-', [0, 'a'], [0, nil]],
+        ['-', [1, 'b'], [0, nil]],
+        ['=', [2, 'c'], [0, 'c']]
       ]
     }
 
-    it_has_behavior "compare sequences correctly"
+    it_has_behavior 'compare sequences correctly'
   end
 
-  describe "using %w(abcd efgh ijkl mnop) & []" do
+  describe 'using %w(abcd efgh ijkl mnop) & []' do
     let(:s1) { %w(abcd efgh ijkl mnop) }
     let(:s2) { [] }
     let(:result) {
       [
-        [ '-', [ 0, 'abcd' ], [ 0, nil ] ],
-        [ '-', [ 1, 'efgh' ], [ 0, nil ] ],
-        [ '-', [ 2, 'ijkl' ], [ 0, nil ] ],
-        [ '-', [ 3, 'mnop' ], [ 0, nil ] ]
+        ['-', [0, 'abcd'], [0, nil]],
+        ['-', [1, 'efgh'], [0, nil]],
+        ['-', [2, 'ijkl'], [0, nil]],
+        ['-', [3, 'mnop'], [0, nil]]
       ]
     }
 
-    it_has_behavior "compare sequences correctly"
+    it_has_behavior 'compare sequences correctly'
   end
-end
 
-# vim: ft=ruby
+  describe 'using [[1,2]] & []' do
+    let(:s1) { [[1, 2]] }
+    let(:s2) { [] }
+    let(:result) {
+      [
+        ['-', [0, [1, 2]], [0, nil]]
+      ]
+    }
+
+    it_has_behavior 'compare sequences correctly'
+  end
+end

data/spec/spec_helper.rb

@@ -1,17 +1,87 @@
-# -*- ruby encoding: utf-8 -*-
+# frozen_string_literal: true
 
 require 'rubygems'
 require 'pathname'
 
+require 'psych' if RUBY_VERSION >= '1.9'
+
+if ENV['COVERAGE']
+  require 'simplecov'
+
+  def require_do(resource)
+    require resource
+    yield if block_given?
+  rescue LoadError
+    nil
+  end
+
+  formatters = [SimpleCov::Formatter::HTMLFormatter]
+
+  require_do('simplecov-rcov') {
+    formatters << SimpleCov::Formatter::RcovFormatter
+  }
+  require_do('simplecov-vim/formatter') {
+    formatters << SimpleCov::Formatter::VimFormatter
+  }
+  require_do('simplecov-sublime-ruby-coverage') {
+    formatters << SimpleCov::Formatter::SublimeRubyCoverageFormatter
+  }
+
+  SimpleCov.start do
+    formatter SimpleCov::Formatter::MultiFormatter.new(formatters)
+  end
+end
+
 file   = Pathname.new(__FILE__).expand_path
 path   = file.parent
 parent = path.parent
 
 $:.unshift parent.join('lib')
 
+module CaptureSubprocessIO
+  def _synchronize
+    yield
+  end
+
+  def capture_subprocess_io
+    _synchronize { _capture_subprocess_io { yield } }
+  end
+
+  def _capture_subprocess_io
+    require 'tempfile'
+
+    captured_stdout, captured_stderr = Tempfile.new('out'), Tempfile.new('err')
+
+    orig_stdout, orig_stderr = $stdout.dup, $stderr.dup
+    $stdout.reopen captured_stdout
+    $stderr.reopen captured_stderr
+
+    yield
+
+    $stdout.rewind
+    $stderr.rewind
+
+    [captured_stdout.read, captured_stderr.read]
+  ensure
+    captured_stdout.unlink
+    captured_stderr.unlink
+    $stdout.reopen orig_stdout
+    $stderr.reopen orig_stderr
+  end
+  private :_capture_subprocess_io
+end
+
 require 'diff-lcs'
 
 module Diff::LCS::SpecHelper
+  def hello
+    'hello'
+  end
+
+  def hello_ary
+    %w(h e l l o)
+  end
+
   def seq1
     %w(a b c e h j l m n p)
   end
@@ -38,50 +108,69 @@ module Diff::LCS::SpecHelper
 
   def correct_forward_diff
     [
-      [ [ '-',  0, 'a' ] ],
-      [ [ '+',  2, 'd' ] ],
-      [ [ '-',  4, 'h' ],
-        [ '+',  4, 'f' ] ],
-      [ [ '+',  6, 'k' ] ],
-      [ [ '-',  8, 'n' ],
-        [ '-',  9, 'p' ],
-        [ '+',  9, 'r' ],
-        [ '+', 10, 's' ],
-        [ '+', 11, 't' ] ]
+      [
+        ['-',  0, 'a']
+      ],
+      [
+        ['+',  2, 'd']
+      ],
+      [
+        ['-',  4, 'h'],
+        ['+',  4, 'f']
+      ],
+      [
+        ['+',  6, 'k']
+      ],
+      [
+        ['-',  8, 'n'],
+        ['+',  9, 'r'],
+        ['-',  9, 'p'],
+        ['+', 10, 's'],
+        ['+', 11, 't']
+      ]
     ]
   end
 
   def correct_backward_diff
     [
-      [ [ '+',  0, 'a' ] ],
-      [ [ '-',  2, 'd' ] ],
-      [ [ '-',  4, 'f' ],
-        [ '+',  4, 'h' ] ],
-      [ [ '-',  6, 'k' ] ],
       [
-        [ '-',  9, 'r' ],
-        [ '-', 10, 's' ],
-        [ '+',  8, 'n' ],
-        [ '-', 11, 't' ],
-        [ '+',  9, 'p' ] ]
+        ['+',  0, 'a']
+      ],
+      [
+        ['-',  2, 'd']
+      ],
+      [
+        ['-',  4, 'f'],
+        ['+',  4, 'h']
+      ],
+      [
+        ['-',  6, 'k']
+      ],
+      [
+        ['-',  9, 'r'],
+        ['+',  8, 'n'],
+        ['-', 10, 's'],
+        ['+',  9, 'p'],
+        ['-', 11, 't']
+      ]
     ]
   end
 
   def correct_forward_sdiff
     [
-      [ '-', [  0, 'a' ], [  0, nil ] ],
-      [ '=', [  1, 'b' ], [  0, 'b' ] ],
-      [ '=', [  2, 'c' ], [  1, 'c' ] ],
-      [ '+', [  3, nil ], [  2, 'd' ] ],
-      [ '=', [  3, 'e' ], [  3, 'e' ] ],
-      [ '!', [  4, 'h' ], [  4, 'f' ] ],
-      [ '=', [  5, 'j' ], [  5, 'j' ] ],
-      [ '+', [  6, nil ], [  6, 'k' ] ],
-      [ '=', [  6, 'l' ], [  7, 'l' ] ],
-      [ '=', [  7, 'm' ], [  8, 'm' ] ],
-      [ '!', [  8, 'n' ], [  9, 'r' ] ],
-      [ '!', [  9, 'p' ], [ 10, 's' ] ],
-      [ '+', [ 10, nil ], [ 11, 't' ] ]
+      ['-', [0, 'a'], [0, nil]],
+      ['=', [1, 'b'], [0, 'b']],
+      ['=', [2, 'c'], [1, 'c']],
+      ['+', [3, nil], [2, 'd']],
+      ['=', [3, 'e'], [3, 'e']],
+      ['!', [4, 'h'], [4, 'f']],
+      ['=', [5, 'j'], [5, 'j']],
+      ['+', [6, nil], [6, 'k']],
+      ['=', [6, 'l'], [7, 'l']],
+      ['=', [7, 'm'], [8, 'm']],
+      ['!', [8, 'n'], [9, 'r']],
+      ['!', [9, 'p'], [10, 's']],
+      ['+', [10, nil], [11, 't']]
     ]
   end
 
@@ -105,13 +194,13 @@ module Diff::LCS::SpecHelper
   end
 
   def format_diffs(diffs)
-    diffs.map do |e|
+    diffs.map { |e|
       if e.kind_of?(Array)
-        e.map { |f| f.to_a.join }.join(", ")
+        e.map { |f| f.to_a.join }.join(', ')
       else
         e.to_a.join
       end
-    end.join("\n")
+    }.join("\n")
   end
 
   def map_diffs(diffs, klass = Diff::LCS::ContextChange)
@@ -132,8 +221,8 @@ module Diff::LCS::SpecHelper
 
   def balanced_reverse(change_result)
     new_result = []
-    change_result.each { |line|
-      line = [ line[0], line[2], line[1] ]
+    change_result.each do |line|
+      line = [line[0], line[2], line[1]]
       case line[0]
       when '<'
         line[0] = '>'
@@ -141,25 +230,24 @@ module Diff::LCS::SpecHelper
         line[0] = '<'
       end
       new_result << line
-    }
-    new_result.sort_by { |line| [ line[1], line[2] ] }
+    end
+    new_result.sort_by { |line| [line[1], line[2]] }
   end
 
   def map_to_no_change(change_result)
     new_result = []
-    change_result.each { |line|
+    change_result.each do |line|
       case line[0]
       when '!'
-        new_result << [ '<', line[1], line[2] ]
-        new_result << [ '>', line[1] + 1, line[2] ]
+        new_result << ['<', line[1], line[2]]
+        new_result << ['>', line[1] + 1, line[2]]
       else
         new_result << line
       end
-    }
+    end
     new_result
   end
 
-
   def simple_callback
     callbacks = Object.new
     class << callbacks
@@ -193,14 +281,17 @@ module Diff::LCS::SpecHelper
       end
 
       def finished_a(event)
-        @done_a << [event.old_element, event.old_position,
-          event.new_element, event.new_position]
+        @done_a << [
+          event.old_element, event.old_position,
+          event.new_element, event.new_position
+        ]
       end
 
       def finished_b(event)
-        p "called #finished_b"
-        @done_b << [event.old_element, event.old_position,
-          event.new_element, event.new_position]
+        @done_b << [
+          event.old_element, event.old_position,
+          event.new_element, event.new_position
+        ]
       end
     end
     callbacks.reset
@@ -226,19 +317,19 @@ module Diff::LCS::SpecHelper
       end
 
       def match(event)
-        @result << [ "=", event.old_position, event.new_position ]
+        @result << ['=', event.old_position, event.new_position]
       end
 
       def discard_a(event)
-        @result << [ "<", event.old_position, event.new_position ]
+        @result << ['<', event.old_position, event.new_position]
       end
 
       def discard_b(event)
-        @result << [ ">", event.old_position, event.new_position ]
+        @result << ['>', event.old_position, event.new_position]
       end
 
       def change(event)
-        @result << [ "!", event.old_position, event.new_position ]
+        @result << ['!', event.old_position, event.new_position]
       end
     end
     cb.reset
@@ -258,14 +349,14 @@ module Diff::LCS::SpecHelper
 
     matcher :be_nil_or_match_values do |ii, s1, s2|
       match do |ee|
-        ee.should satisfy { |vee| vee.nil? || s1[ii] == s2[ee] }
+        expect(ee).to(satisfy { |vee| vee.nil? || s1[ii] == s2[ee] })
       end
     end
 
     matcher :correctly_map_sequence do |s1|
       match do |actual|
         actual.each_with_index { |ee, ii|
-          ee.should be_nil_or_match_values(ii, s1, @s2)
+          expect(ee).to be_nil_or_match_values(ii, s1, @s2)
         }
       end
 
@@ -279,6 +370,5 @@ end
 RSpec.configure do |conf|
   conf.include Diff::LCS::SpecHelper
   conf.alias_it_should_behave_like_to :it_has_behavior, 'has behavior:'
+  conf.filter_run_excluding :broken => true
 end
-
-# vim: ft=ruby