lookout 2.3.0 → 3.0.0

data/test/unit/lookout/diff/operations.rb

@@ -1,22 +0,0 @@
-# -*- coding: utf-8 -*-
-
-Expectations do
-  expect [] do
-    Lookout::Diff::Operations.new(Lookout::Diff::Algorithms::Difflib.new('',
-                                                                         '')).to_a
-  end
-
-  expect [Lookout::Diff::Operations::Delete.new(Lookout::Diff::Range.new('qabxcd', 0..0),
-                                                Lookout::Diff::Range.new('abycdf', 0...0)),
-          Lookout::Diff::Operations::Equal.new(Lookout::Diff::Range.new('qabxcd', 1..2),
-                                               Lookout::Diff::Range.new('abycdf', 0..1)),
-          Lookout::Diff::Operations::Replace.new(Lookout::Diff::Range.new('qabxcd', 3..3),
-                                                 Lookout::Diff::Range.new('abycdf', 2..2)),
-          Lookout::Diff::Operations::Equal.new(Lookout::Diff::Range.new('qabxcd', 4..5),
-                                               Lookout::Diff::Range.new('abycdf', 3..4)),
-          Lookout::Diff::Operations::Insert.new(Lookout::Diff::Range.new('qabxcd', 6...6),
-                                                Lookout::Diff::Range.new('abycdf', 5..5))] do
-    Lookout::Diff::Operations.new(Lookout::Diff::Algorithms::Difflib.new('qabxcd',
-                                                                         'abycdf')).to_a
-  end
-end

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

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

data/test/unit/lookout/diff/operations/equal.rb

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

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

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

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

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

data/test/unit/lookout/diff/range.rb

@@ -1,50 +0,0 @@
-# -*- coding: utf-8 -*-
-
-Expectations do
-  expect Lookout::Diff::Range.new('').to.be.empty?
-  expect Lookout::Diff::Range.new('a', 0..-1).to.be.empty?
-  expect Lookout::Diff::Range.new('a', 0...0).to.be.empty?
-  expect Lookout::Diff::Range.new('a', 0..0).not.to.be.empty?
-
-  expect Lookout::Diff::Range.new('').to.have.size.equal?(0)
-  expect Lookout::Diff::Range.new('a', 0...0).to.have.size.equal?(0)
-  expect Lookout::Diff::Range.new('a', 0..0).to.have.size.equal?(1)
-
-  expect Lookout::Diff::Range.new('a', 0..0).not.to.be.
-    begins_before?(Lookout::Diff::Range.new('a', 0..1))
-  expect Lookout::Diff::Range.new('a', 0..0).to.be.
-    begins_before?(Lookout::Diff::Range.new('a', 1..1))
-
-  expect Lookout::Diff::Range.new('a', 0..0).not.to.be.
-    ends_after?(Lookout::Diff::Range.new('a', 0..1))
-  expect Lookout::Diff::Range.new('a', 1..1).to.be.
-    ends_after?(Lookout::Diff::Range.new('a', 0..0))
-
-  expect Lookout::Diff::Range.new('abc', 2..2) do
-    Lookout::Diff::Range.new('abc').begin_after(Lookout::Diff::Range.new('abc', 0..1))
-  end
-
-  expect Lookout::Diff::Range.new('abc', 0..0) do
-    Lookout::Diff::Range.new('abc').end_before(Lookout::Diff::Range.new('abc', 1..2))
-  end
-
-  expect Lookout::Diff::Range.new('abc', 1..2) do
-    Lookout::Diff::Range.new('abc').at(1..2)
-  end
-
-  expect 'a' do
-    Lookout::Diff::Range.new(%w[a b c])[0]
-  end
-
-  expect 'b' do
-    Lookout::Diff::Range.new(%w[a b c], 2..2)[1]
-  end
-
-  expect ['b', 1] do
-    result = []
-    Lookout::Diff::Range.new(%w[a b c], 1..1).each_with_index do |c, i|
-      result = [c, i]
-    end
-    result
-  end
-end

data/test/unit/lookout/equality.rb

@@ -1,113 +0,0 @@
-# -*- coding: utf-8 -*-
-
-Expectations do
-  expect nil do
-    Lookout::Equality.diff('abc', 1)
-  end
-
-  expect '[-A-]{+a+}bc' do
-    Lookout::Equality.diff('abc', 'Abc')
-  end
-
-  expect 'a[-B-]{+b+}c' do
-    Lookout::Equality.diff('abc', 'aBc')
-  end
-
-  expect 'ab[-C-]{+c+}' do
-    Lookout::Equality.diff('abc', 'abC')
-  end
-
-  expect <<EOD.chomp do
-@@ -1,2 +1,2 @@
--def
-+abc
- ghi
-EOD
-    Lookout::Equality.diff("abc\nghi", "def\nghi")
-  end
-
-  expect nil do
-    Lookout::Equality.diff(%w[abc], 'def')
-  end
-
-  expect nil do
-    Lookout::Equality.diff(%w[abc], %w[def])
-  end
-
-  expect <<EOD.chomp do
-@@ -1,2 +1,2 @@
--def
-+abc
- ghi
-EOD
-    Lookout::Equality.diff(%w[abc ghi], %w[def ghi])
-  end
-
-  expect nil do
-    Lookout::Equality.diff({'abc' => 1}, 'def')
-  end
-
-  expect nil do
-    Lookout::Equality.diff({'abc' => 1}, {'def' => 1})
-  end
-
-  expect <<EOD.chomp do
--"def" => 1
-+"abc" => 1
-EOD
-    Lookout::Equality.diff({'abc' => 1, 'ghi' => 2}, {'def' => 1, 'ghi' => 2})
-  end
-
-  expect true do
-    Lookout::Equality.equal? String, 'foo'
-  end
-
-  expect true do
-    Lookout::Equality.equal? 'foo', 'foo'
-  end
-
-  expect true do
-    Lookout::Equality.equal? String, String
-  end
-
-  expect false do
-    Lookout::Equality.equal? String, 0
-  end
-
-  expect true do
-    object = Object.new
-    Lookout::Equality.equal? object, object
-  end
-
-  expect false do
-    Lookout::Equality.equal? Object.new, Object.new
-  end
-
-  expect true do
-    Lookout::Equality.equal? 1..5, 3
-  end
-
-  expect true do
-    Lookout::Equality.equal? 1..5, (1..5)
-  end
-
-  expect false do
-    Lookout::Equality.equal? 1..5, 6
-  end
-
-  expect true do
-    Lookout::Equality.equal?(/foo/, 'foo')
-  end
-
-  expect true do
-    Lookout::Equality.equal?(/foo/, /foo/)
-  end
-
-  expect false do
-    Lookout::Equality.equal?(/foo/, 'bar')
-  end
-
-  expect false do
-    Lookout::Equality.equal?(/foo/, /bar/)
-  end
-end

data/test/unit/lookout/expectation.rb

@@ -1,47 +0,0 @@
-# -*- coding: utf-8 -*-
-
-Expectations do
-  expect Lookout::Results::Failures::State do
-    Lookout::Expectation.on(1, nil, nil){ 2 }.evaluate
-  end
-
-  expect Lookout::Results::Fulfilled do
-    Lookout::Expectation.on(1, nil, nil){ 1 }.evaluate
-  end
-
-  expect Lookout::Results::Error do
-    Lookout::Expectation.on(1, nil, nil){ raise }.evaluate
-  end
-
-  expect "undefined method `no_method' for Object:Class (NoMethodError)" do
-    Lookout::Expectation.on(ArgumentError, nil, nil){ Object.no_method }.evaluate.exception.message
-  end
-
-  expect Lookout::Results::Fulfilled do
-    Lookout::Expectation.on(NoMethodError, nil, nil){ Object.no_method }.evaluate
-  end
-
-  expect Lookout::Recorders::State do
-    ''.to.have.to_s == ''
-  end
-
-  expect Lookout::Results::Failures::State do
-    Lookout::Expectation.on('foo'.to.have.to_s == 'bar', nil, nil).evaluate
-  end
-
-  expect Lookout::Results::Fulfilled do
-    Lookout::Expectation.on('foo'.to.have.to_s == 'foo', nil, nil).evaluate
-  end
-
-  expect Lookout::Results::Fulfilled do
-    Lookout::Expectation.on([1, 2, 3].to.include?(1), nil, nil).evaluate
-  end
-
-  expect Lookout::Results::Fulfilled do
-    Lookout::Expectation.on(1, nil, nil){ stub(:a => 1).a }.evaluate
-  end
-
-  expect Lookout::Results::Fulfilled do
-    Lookout::Expectation.on(1, nil, nil){ stub(:a => proc{ 1 }).a }.evaluate
-  end
-end

data/test/unit/lookout/expectations.rb

@@ -1,36 +0,0 @@
-# -*- coding: utf-8 -*-
-
-Expectations do
-  expect 3 do
-    Lookout::Results::Unsuccessful.new.tap{ |results|
-      Lookout::Expectations.new(results).
-        expect(1){ 2 }.
-        expect(1){ 2 }.
-        expect(1){ 2 }
-    }.count
-  end
-
-  expect __LINE__ + 2 do
-    Lookout::Results::Unsuccessful.new.tap{ |results|
-      Lookout::Expectations.new(results).expect(1){ 2 }
-    }.first.line
-  end
-
-  expect __LINE__ + 2 do
-    Lookout::Results::Unsuccessful.new.tap{ |results|
-      Lookout::Expectations.new(results).expect(1){ raise }
-    }.first.line
-  end
-
-  expect __FILE__ do
-    Lookout::Results::Unsuccessful.new.tap{ |results|
-      Lookout::Expectations.new(results).expect(1){ 2 }
-    }.first.file
-  end
-
-  expect __FILE__ do
-    Lookout::Results::Unsuccessful.new.tap{ |results|
-      Lookout::Expectations.new(results).expect(1){ raise }
-    }.first.file
-  end
-end