lookout 2.3.0 → 3.0.0

data/test/unit/lookout-3.0/diff/operations/copy.rb

@@ -0,0 +1,50 @@
+# -*- coding: utf-8 -*-
+
+Expectations do
+  expect result.not.foldable?(0) do
+    Lookout::Diff::Operations::Copy.new(Lookout::Diff::Slice.new('', 0...0),
+                                        Lookout::Diff::Slice.new('', 0...0))
+  end
+
+  expect result.not.foldable?(1) do
+    Lookout::Diff::Operations::Copy.new(Lookout::Diff::Slice.new('ab', 0..1),
+                                        Lookout::Diff::Slice.new('ab', 0..1))
+  end
+
+  expect result.foldable?(1) do
+    Lookout::Diff::Operations::Copy.new(Lookout::Diff::Slice.new('abc', 0..2),
+                                        Lookout::Diff::Slice.new('abc', 0..2))
+  end
+
+  expect Lookout::Diff::Operations::Copy.new(Lookout::Diff::Slice.new('', 0...0),
+                                              Lookout::Diff::Slice.new('', 0...0)) do
+    Lookout::Diff::Operations::Copy.new(Lookout::Diff::Slice.new('', 0...0),
+                                        Lookout::Diff::Slice.new('', 0...0)) >> 1
+  end
+
+  expect Lookout::Diff::Operations::Copy.new(Lookout::Diff::Slice.new('abc', 2..2),
+                                              Lookout::Diff::Slice.new('abc', 2..2)) do
+    Lookout::Diff::Operations::Copy.new(Lookout::Diff::Slice.new('abc', 0..2),
+                                        Lookout::Diff::Slice.new('abc', 0..2)) >> 1
+  end
+
+  expect Lookout::Diff::Operations::Copy.new(Lookout::Diff::Slice.new('', 0...0),
+                                              Lookout::Diff::Slice.new('', 0...0)) do
+    Lookout::Diff::Operations::Copy.new(Lookout::Diff::Slice.new('', 0...0),
+                                        Lookout::Diff::Slice.new('', 0...0)) << 1
+  end
+
+  expect Lookout::Diff::Operations::Copy.new(Lookout::Diff::Slice.new('abc', 0..0),
+                                             Lookout::Diff::Slice.new('abc', 0..0)) do
+    Lookout::Diff::Operations::Copy.new(Lookout::Diff::Slice.new('abc', 0..2),
+                                        Lookout::Diff::Slice.new('abc', 0..2)) << 1
+  end
+
+  expect mock.to.receive.
+    copy(Lookout::Diff::Operations::Copy.
+         new(Lookout::Diff::Slice.new('a', 0..0),
+             Lookout::Diff::Slice.new('a', 0..0))).once do |o|
+    Lookout::Diff::Operations::Copy.new(Lookout::Diff::Slice.new('a', 0..0),
+                                        Lookout::Diff::Slice.new('a', 0..0)).apply(o)
+  end
+end

data/test/unit/lookout-3.0/diff/operations/delete.rb

@@ -0,0 +1,45 @@
+# -*- coding: utf-8 -*-
+
+Expectations do
+  expect false do
+    Lookout::Diff::Operations::Delete.new(Lookout::Diff::Slice.new('', 0...0),
+                                          Lookout::Diff::Slice.new('', 0...0)).foldable? 0
+  end
+
+  expect false do
+    Lookout::Diff::Operations::Delete.new(Lookout::Diff::Slice.new('ab', 0..1),
+                                          Lookout::Diff::Slice.new('ab', 0..1)).foldable? 1
+  end
+
+  expect Lookout::Diff::Operations::Delete.new(Lookout::Diff::Slice.new('', 0...0),
+                                              Lookout::Diff::Slice.new('', 0...0)) do
+    Lookout::Diff::Operations::Delete.new(Lookout::Diff::Slice.new('', 0...0),
+                                          Lookout::Diff::Slice.new('', 0...0)) >> 1
+  end
+
+  expect Lookout::Diff::Operations::Delete.new(Lookout::Diff::Slice.new('abc', 0..2),
+                                              Lookout::Diff::Slice.new('abc', 0..2)) do
+    Lookout::Diff::Operations::Delete.new(Lookout::Diff::Slice.new('abc', 0..2),
+                                          Lookout::Diff::Slice.new('abc', 0..2)) >> 1
+  end
+
+  expect Lookout::Diff::Operations::Delete.new(Lookout::Diff::Slice.new('', 0...0),
+                                              Lookout::Diff::Slice.new('', 0...0)) do
+    Lookout::Diff::Operations::Delete.new(Lookout::Diff::Slice.new('', 0...0),
+                                          Lookout::Diff::Slice.new('', 0...0)) << 1
+  end
+
+  expect Lookout::Diff::Operations::Delete.new(Lookout::Diff::Slice.new('abc', 0..2),
+                                              Lookout::Diff::Slice.new('abc', 0..2)) do
+    Lookout::Diff::Operations::Delete.new(Lookout::Diff::Slice.new('abc', 0..2),
+                                          Lookout::Diff::Slice.new('abc', 0..2)) << 1
+  end
+
+  expect mock.to.receive.
+    delete(Lookout::Diff::Operations::Delete.
+             new(Lookout::Diff::Slice.new('', 0...0),
+                 Lookout::Diff::Slice.new('a', 0...0))).once do |o|
+    Lookout::Diff::Operations::Delete.new(Lookout::Diff::Slice.new('', 0...0),
+                                         Lookout::Diff::Slice.new('a', 0...0)).apply(o)
+  end
+end

data/test/unit/lookout-3.0/diff/operations/insert.rb

@@ -0,0 +1,45 @@
+# -*- coding: utf-8 -*-
+
+Expectations do
+  expect false do
+    Lookout::Diff::Operations::Insert.new(Lookout::Diff::Slice.new('', 0...0),
+                                          Lookout::Diff::Slice.new('', 0...0)).foldable? 0
+  end
+
+  expect false do
+    Lookout::Diff::Operations::Insert.new(Lookout::Diff::Slice.new('ab', 0..1),
+                                          Lookout::Diff::Slice.new('ab', 0..1)).foldable? 1
+  end
+
+  expect Lookout::Diff::Operations::Insert.new(Lookout::Diff::Slice.new('', 0...0),
+                                               Lookout::Diff::Slice.new('', 0...0)) do
+    Lookout::Diff::Operations::Insert.new(Lookout::Diff::Slice.new('', 0...0),
+                                          Lookout::Diff::Slice.new('', 0...0)) >> 1
+  end
+
+  expect Lookout::Diff::Operations::Insert.new(Lookout::Diff::Slice.new('abc', 0..2),
+                                               Lookout::Diff::Slice.new('abc', 0..2)) do
+    Lookout::Diff::Operations::Insert.new(Lookout::Diff::Slice.new('abc', 0..2),
+                                          Lookout::Diff::Slice.new('abc', 0..2)) >> 1
+  end
+
+  expect Lookout::Diff::Operations::Insert.new(Lookout::Diff::Slice.new('', 0...0),
+                                               Lookout::Diff::Slice.new('', 0...0)) do
+    Lookout::Diff::Operations::Insert.new(Lookout::Diff::Slice.new('', 0...0),
+                                          Lookout::Diff::Slice.new('', 0...0)) << 1
+  end
+
+  expect Lookout::Diff::Operations::Insert.new(Lookout::Diff::Slice.new('abc', 0..2),
+                                               Lookout::Diff::Slice.new('abc', 0..2)) do
+    Lookout::Diff::Operations::Insert.new(Lookout::Diff::Slice.new('abc', 0..2),
+                                          Lookout::Diff::Slice.new('abc', 0..2)) << 1
+  end
+
+  expect mock.to.receive.
+    insert(Lookout::Diff::Operations::Insert.
+             new(Lookout::Diff::Slice.new('', 0...0),
+                 Lookout::Diff::Slice.new('a', 0...0))).once do |o|
+    Lookout::Diff::Operations::Insert.new(Lookout::Diff::Slice.new('', 0...0),
+                                          Lookout::Diff::Slice.new('a', 0...0)).apply(o)
+  end
+end

data/test/unit/lookout-3.0/diff/operations/replace.rb

@@ -0,0 +1,45 @@
+# -*- coding: utf-8 -*-
+
+Expectations do
+  expect false do
+    Lookout::Diff::Operations::Replace.new(Lookout::Diff::Slice.new('', 0...0),
+                                           Lookout::Diff::Slice.new('', 0...0)).foldable? 0
+  end
+
+  expect false do
+    Lookout::Diff::Operations::Replace.new(Lookout::Diff::Slice.new('ab', 0..1),
+                                           Lookout::Diff::Slice.new('ab', 0..1)).foldable? 1
+  end
+
+  expect Lookout::Diff::Operations::Replace.new(Lookout::Diff::Slice.new('', 0...0),
+                                                Lookout::Diff::Slice.new('', 0...0)) do
+    Lookout::Diff::Operations::Replace.new(Lookout::Diff::Slice.new('', 0...0),
+                                           Lookout::Diff::Slice.new('', 0...0)) >> 1
+  end
+
+  expect Lookout::Diff::Operations::Replace.new(Lookout::Diff::Slice.new('abc', 0..2),
+                                                Lookout::Diff::Slice.new('abc', 0..2)) do
+    Lookout::Diff::Operations::Replace.new(Lookout::Diff::Slice.new('abc', 0..2),
+                                           Lookout::Diff::Slice.new('abc', 0..2)) >> 1
+  end
+
+  expect Lookout::Diff::Operations::Replace.new(Lookout::Diff::Slice.new('', 0...0),
+                                                Lookout::Diff::Slice.new('', 0...0)) do
+    Lookout::Diff::Operations::Replace.new(Lookout::Diff::Slice.new('', 0...0),
+                                           Lookout::Diff::Slice.new('', 0...0)) << 1
+  end
+
+  expect Lookout::Diff::Operations::Replace.new(Lookout::Diff::Slice.new('abc', 0..2),
+                                                Lookout::Diff::Slice.new('abc', 0..2)) do
+    Lookout::Diff::Operations::Replace.new(Lookout::Diff::Slice.new('abc', 0..2),
+                                           Lookout::Diff::Slice.new('abc', 0..2)) << 1
+  end
+
+  expect mock.to.receive.
+    replace(Lookout::Diff::Operations::Replace.
+              new(Lookout::Diff::Slice.new('', 0...0),
+                  Lookout::Diff::Slice.new('a', 0...0))).once do |o|
+    Lookout::Diff::Operations::Replace.new(Lookout::Diff::Slice.new('', 0...0),
+                                           Lookout::Diff::Slice.new('a', 0...0)).apply(o)
+  end
+end

data/test/unit/lookout-3.0/diff/slice.rb

@@ -0,0 +1,56 @@
+# -*- coding: utf-8 -*-
+
+Expectations do
+  expect result.empty? do Lookout::Diff::Slice.new('') end
+  expect result.empty? do Lookout::Diff::Slice.new('a', 0..-1) end
+  expect result.empty? do Lookout::Diff::Slice.new('a', 0...0) end
+  expect result.not.empty? do Lookout::Diff::Slice.new('a', 0..0) end
+
+  expect 0 do Lookout::Diff::Slice.new('').size end
+  expect 0 do Lookout::Diff::Slice.new('a', 0...0).size end
+  expect 1 do Lookout::Diff::Slice.new('a', 0..0).size end
+
+  expect false do
+    Lookout::Diff::Slice.new('a', 0..0).begin_before? Lookout::Diff::Slice.new('a', 0..1)
+  end
+
+  expect true do
+    Lookout::Diff::Slice.new('a', 0..0).begin_before? Lookout::Diff::Slice.new('a', 1..1)
+  end
+
+  expect false do
+    Lookout::Diff::Slice.new('a', 0..0).end_after? Lookout::Diff::Slice.new('a', 0..1)
+  end
+
+  expect true do
+    Lookout::Diff::Slice.new('a', 1..1).end_after? Lookout::Diff::Slice.new('a', 0..0)
+  end
+
+  expect Lookout::Diff::Slice.new('abc', 2..2) do
+    Lookout::Diff::Slice.new('abc').begin_after(Lookout::Diff::Slice.new('abc', 0..1))
+  end
+
+  expect Lookout::Diff::Slice.new('abc', 0..0) do
+    Lookout::Diff::Slice.new('abc').end_before(Lookout::Diff::Slice.new('abc', 1..2))
+  end
+
+  expect Lookout::Diff::Slice.new('abc', 1..2) do
+    Lookout::Diff::Slice.new('abc').at(1..2)
+  end
+
+  expect 'a' do
+    Lookout::Diff::Slice.new(%w[a b c])[0]
+  end
+
+  expect 'b' do
+    Lookout::Diff::Slice.new(%w[a b c], 2..2)[1]
+  end
+
+  expect ['b', 1] do
+    result = []
+    Lookout::Diff::Slice.new(%w[a b c], 1..1).each_with_index do |c, i|
+      result = [c, i]
+    end
+    result
+  end
+end

data/test/unit/lookout-3.0/difference/array.rb

@@ -0,0 +1,32 @@
+# -*- coding: utf-8 -*-
+
+Expectations do
+  expect '1≠[1]' do
+    [1].to_lookout_expected.difference(1).message
+  end
+
+  expect '[1]≠[1, 2]' do
+    [1, 2].to_lookout_expected.difference([1]).message
+  end
+
+  expect '[1, 3]≉[1, 2]' do
+    [1, 2].to_lookout_expected.difference([1, 3]).message
+  end
+
+  expect [] do
+    %w[abc].to_lookout_expected.difference(%w[def]).diff
+  end
+
+  expect [] do
+    %w[abc].to_lookout_expected.difference('def').diff
+  end
+
+  expect [<<EOD.chomp] do
+@@ -1,2 +1,2 @@
+-def
++abc
+ ghi
+EOD
+    %w[abc ghi].to_lookout_expected.difference(%w[def ghi]).diff.to_a
+  end
+end

data/test/unit/lookout-3.0/difference/exception.rb

@@ -0,0 +1,69 @@
+# -*- coding: utf-8 -*-
+
+Expectations do
+  expect [] do
+    RuntimeError.new.to_lookout_expected.difference(ArgumentError.new).diff
+  end
+
+  expect [] do
+    RuntimeError.new(/a/).to_lookout_expected.difference(RuntimeError.new('b')).diff
+  end
+
+  expect [] do
+    stub(RuntimeError.new('b'), :message => proc{ raise }){ |b|
+      RuntimeError.new('a').to_lookout_expected.difference(b).diff
+    }
+  end
+
+  expect [] do
+    stub(RuntimeError.new('b'), :message => nil){ |b|
+      RuntimeError.new('a').to_lookout_expected.difference(b).diff
+    }
+  end
+
+  expect '[-b-]{+a+}' do
+    RuntimeError.new('a').to_lookout_expected.difference(RuntimeError.new('b')).diff.to_s
+  end
+
+  expect '#<RuntimeError: b>≠#<RuntimeError: a>' do
+    RuntimeError.new('a').to_lookout_expected.difference(RuntimeError.new('b')).message
+  end
+
+  expect '(cannot inspect actual result: error)≠#<RuntimeError: a>' do
+    stub(RuntimeError.new('b'), :inspect => proc{ raise 'error' }){ |b|
+      RuntimeError.new('a').to_lookout_expected.difference(b).message
+    }
+  end
+
+  expect '#<RuntimeError: b>≉#<RuntimeError: /a/>' do
+    RuntimeError.new(/a/).to_lookout_expected.difference(RuntimeError.new('b')).message
+  end
+
+  expect '#<RuntimeError: b>≉#<RuntimeError: /a/m>' do
+    RuntimeError.new(/a/m).to_lookout_expected.difference(RuntimeError.new('b')).message
+  end
+
+  expect '#<RuntimeError: b>≉#<RuntimeError: /a/i>' do
+    RuntimeError.new(/a/i).to_lookout_expected.difference(RuntimeError.new('b')).message
+  end
+
+  expect '#<RuntimeError: b>≉#<RuntimeError: /a/x>' do
+    RuntimeError.new(/a/x).to_lookout_expected.difference(RuntimeError.new('b')).message
+  end
+
+  expect '#<RuntimeError: b>≉#<RuntimeError: /a/mix>' do
+    RuntimeError.new(/a/mix).to_lookout_expected.difference(RuntimeError.new('b')).message
+  end
+
+  expect '(cannot inspect actual result: error)≠#<RuntimeError: a>' do
+    stub(RuntimeError.new('b'), :inspect => proc{ raise 'error' }){ |b|
+      RuntimeError.new('a').to_lookout_expected.difference(b).message
+    }
+  end
+
+  expect '(cannot inspect actual result: error)≉#<RuntimeError: /a/>' do
+    stub(RuntimeError.new('b'), :inspect => proc{ raise 'error' }){ |b|
+      RuntimeError.new(/a/).to_lookout_expected.difference(b).message
+    }
+  end
+end

data/test/unit/lookout-3.0/difference/hash.rb

@@ -0,0 +1,30 @@
+# -*- coding: utf-8 -*-
+
+Expectations do
+  expect %r'≠' do
+    {'a' => 1}.to_lookout_expected.difference('b').message
+  end
+
+  expect %r'≠' do
+    {'a' => 1, 'b' => 2}.to_lookout_expected.difference({'a' => 1}).message
+  end
+
+  expect %r'≉' do
+    {'a' => 1, 'b' => 2}.to_lookout_expected.difference({'a' => 1, 'b' => 3}).message
+  end
+
+  expect [] do
+    {'a' => Integer}.to_lookout_expected.difference({'b' => 1}).diff
+  end
+
+  expect [] do
+    {'a' => Integer}.to_lookout_expected.difference('b').diff
+  end
+
+  expect <<EOD.chomp do
+-"g" => 1
++"c" => 1
+EOD
+    {'c' => 1, 'b' => 2}.to_lookout_expected.difference({'g' => 1, 'b' => 2}).diff.to_s
+  end
+end

data/test/unit/lookout-3.0/difference/lookout/actual/method.rb

@@ -0,0 +1,7 @@
+# -*- coding: utf-8 -*-
+
+Expectations do
+  expect '¬[1]#empty?' do
+    Lookout::Difference::Lookout::Actual::Method.new([1], Lookout::Actual::Method.new(:empty?)).message
+  end
+end

data/test/unit/lookout-3.0/difference/lookout/actual/not/method.rb

@@ -0,0 +1,7 @@
+# -*- coding: utf-8 -*-
+
+Expectations do
+  expect '[]#empty?' do
+    Lookout::Difference::Lookout::Actual::Not::Method.new([], Lookout::Actual::Method.new(:empty?)).message
+  end
+end

data/test/unit/lookout-3.0/difference/lookout/output.rb

@@ -0,0 +1,11 @@
+# -*- coding: utf-8 -*-
+
+Expectations do
+  expect 'output("b")≠output("a")' do
+    Lookout::Difference::Lookout::Output.new(Lookout::Output.new('b'), Lookout::Output.new('a')).message
+  end
+
+  expect '[-b-]{+a+}' do
+    Lookout::Difference::Lookout::Output.new(Lookout::Output.new('b'), Lookout::Output.new('a')).diff.to_s
+  end
+end

data/test/unit/lookout-3.0/difference/lookout/reception.rb

@@ -0,0 +1,11 @@
+# -*- coding: utf-8 -*-
+
+Expectations do
+  expect Lookout::Results::Failure.
+    new('test',
+        1,
+        Lookout::Difference::Lookout::Reception.
+          new(0, Lookout::Reception.of(stub, :call).once)) do
+    Lookout::Reception.of(stub, :call).once.to_lookout_expected.expect('test', 1).call
+  end
+end

data/test/unit/lookout-3.0/difference/lookout/warning.rb

@@ -0,0 +1,11 @@
+# -*- coding: utf-8 -*-
+
+Expectations do
+  expect 'warning("b")≉warning("a")' do
+    Lookout::Difference::Lookout::Warning.new(Lookout::Warning.new('b'), Lookout::Warning.new('a')).message
+  end
+
+  expect '[-b-]{+a+}' do
+    Lookout::Difference::Lookout::Warning.new(Lookout::Warning.new('b'), Lookout::Warning.new('a')).diff.to_s
+  end
+end