lookout 2.0.1

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

@@ -0,0 +1,4 @@
+# -*- coding: utf-8 -*-
+
+Expectations do
+end

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

@@ -0,0 +1,102 @@
+# -*- coding: utf-8 -*-
+
+Expectations do
+  expect [] do
+    Lookout::Diff::Groups.
+      new(Lookout::Diff::Operations.
+            new(Lookout::Diff::Algorithms::Difflib.new('', ''))).to_a
+  end
+
+  expect [Lookout::Diff::Group.new(Lookout::Diff::Operations::Equal.new(Lookout::Diff::Range.new('abc', 0..2),
+                                                                        Lookout::Diff::Range.new('abc', 0..2)))] do
+    Lookout::Diff::Groups.
+      new(Lookout::Diff::Operations.
+            new(Lookout::Diff::Algorithms::Difflib.new('abc', 'abc'))).to_a
+  end
+
+  expect [Lookout::Diff::Group.new(Lookout::Diff::Operations::Equal.new(Lookout::Diff::Range.new('abcdefg', 4..6),
+                                                                        Lookout::Diff::Range.new('abcdefg', 4..6)))] do
+    Lookout::Diff::Groups.
+      new(Lookout::Diff::Operations.
+            new(Lookout::Diff::Algorithms::Difflib.
+                  new('abcdefg',
+                      'abcdefg'))).to_a
+  end
+
+  expect [Lookout::Diff::Group.new(Lookout::Diff::Operations::Replace.new(Lookout::Diff::Range.new('Abcdefg', 0..0),
+                                                                          Lookout::Diff::Range.new('abcdefg', 0..0)),
+                                   Lookout::Diff::Operations::Equal.new(Lookout::Diff::Range.new('Abcdefg', 1..3),
+                                                                        Lookout::Diff::Range.new('abcdefg', 1..3)))] do
+    Lookout::Diff::Groups.
+      new(Lookout::Diff::Operations.
+            new(Lookout::Diff::Algorithms::Difflib.
+                  new('Abcdefg',
+                      'abcdefg'))).to_a
+  end
+
+  expect [Lookout::Diff::Group.new(Lookout::Diff::Operations::Replace.new(Lookout::Diff::Range.new('Abcdefgh', 0..0),
+                                                                          Lookout::Diff::Range.new('abcdefgh', 0..0)),
+                                   Lookout::Diff::Operations::Equal.new(Lookout::Diff::Range.new('Abcdefgh', 1..3),
+                                                                        Lookout::Diff::Range.new('abcdefgh', 1..3)))] do
+    Lookout::Diff::Groups.
+      new(Lookout::Diff::Operations.
+            new(Lookout::Diff::Algorithms::Difflib.
+                  new('Abcdefgh',
+                      'abcdefgh'))).to_a
+  end
+
+  expect [Lookout::Diff::Group.new(Lookout::Diff::Operations::Equal.new(Lookout::Diff::Range.new('abcdefgHijklmno', 4..6),
+                                                                        Lookout::Diff::Range.new('abcdefghijklmno', 4..6)),
+                                   Lookout::Diff::Operations::Replace.new(Lookout::Diff::Range.new('abcdefgHijklmno', 7..7),
+                                                                          Lookout::Diff::Range.new('abcdefghijklmno', 7..7)),
+                                   Lookout::Diff::Operations::Equal.new(Lookout::Diff::Range.new('abcdefgHijklmno', 8..10),
+                                                                        Lookout::Diff::Range.new('abcdefghijklmno', 8..10)))] do
+    Lookout::Diff::Groups.
+      new(Lookout::Diff::Operations.
+            new(Lookout::Diff::Algorithms::Difflib.
+                  new('abcdefgHijklmno',
+                      'abcdefghijklmno'))).to_a
+  end
+
+  expect [Lookout::Diff::Group.new(Lookout::Diff::Operations::Equal.new(Lookout::Diff::Range.new('123456789abcdefghijk', 0..0),
+                                                                        Lookout::Diff::Range.new('1i3456789abXdhYjk', 0..0)),
+                                   Lookout::Diff::Operations::Replace.new(Lookout::Diff::Range.new('123456789abcdefghijk', 1..1),
+                                                                          Lookout::Diff::Range.new('1i3456789abXdhYjk', 1..1)),
+                                   Lookout::Diff::Operations::Equal.new(Lookout::Diff::Range.new('123456789abcdefghijk', 2..4),
+                                                                        Lookout::Diff::Range.new('1i3456789abXdhYjk', 2..4))),
+          Lookout::Diff::Group.new(Lookout::Diff::Operations::Equal.new(Lookout::Diff::Range.new('123456789abcdefghijk', 8..10),
+                                                                        Lookout::Diff::Range.new('1i3456789abXdhYjk', 8..10)),
+                                   Lookout::Diff::Operations::Replace.new(Lookout::Diff::Range.new('123456789abcdefghijk', 11..11),
+                                                                          Lookout::Diff::Range.new('1i3456789abXdhYjk', 11..11)),
+                                   Lookout::Diff::Operations::Equal.new(Lookout::Diff::Range.new('123456789abcdefghijk', 12..12),
+                                                                        Lookout::Diff::Range.new('1i3456789abXdhYjk', 12..12)),
+                                   Lookout::Diff::Operations::Delete.new(Lookout::Diff::Range.new('123456789abcdefghijk', 13..15),
+                                                                         Lookout::Diff::Range.new('1i3456789abXdhYjk', 13...13)),
+                                   Lookout::Diff::Operations::Equal.new(Lookout::Diff::Range.new('123456789abcdefghijk', 16..16),
+                                                                        Lookout::Diff::Range.new('1i3456789abXdhYjk', 13..13)),
+                                   Lookout::Diff::Operations::Replace.new(Lookout::Diff::Range.new('123456789abcdefghijk', 17..17),
+                                                                          Lookout::Diff::Range.new('1i3456789abXdhYjk', 14..14)),
+                                   Lookout::Diff::Operations::Equal.new(Lookout::Diff::Range.new('123456789abcdefghijk', 18..19),
+                                                                        Lookout::Diff::Range.new('1i3456789abXdhYjk', 15..16)))] do
+    Lookout::Diff::Groups.
+      new(Lookout::Diff::Operations.
+            new(Lookout::Diff::Algorithms::Difflib.
+                  new('123456789abcdefghijk',
+                      '1i3456789abXdhYjk'))).to_a
+  end
+
+  expect [Lookout::Diff::Group.new(Lookout::Diff::Operations::Insert.new(Lookout::Diff::Range.new(%w[one two three four], 0...0),
+                                                                         Lookout::Diff::Range.new(%w[zero one tree four], 0..0)),
+                                   Lookout::Diff::Operations::Equal.new(Lookout::Diff::Range.new(%w[one two three four], 0..0),
+                                                                        Lookout::Diff::Range.new(%w[zero one tree four], 1..1)),
+                                   Lookout::Diff::Operations::Replace.new(Lookout::Diff::Range.new(%w[one two three four], 1..2),
+                                                                          Lookout::Diff::Range.new(%w[zero one tree four], 2..2)),
+                                   Lookout::Diff::Operations::Equal.new(Lookout::Diff::Range.new(%w[one two three four], 3..3),
+                                                                        Lookout::Diff::Range.new(%w[zero one tree four], 3..3)))] do
+    Lookout::Diff::Groups.
+      new(Lookout::Diff::Operations.
+            new(Lookout::Diff::Algorithms::Difflib.
+                  new(%w[one two three four],
+                      %w[zero one tree four]))).to_a
+  end
+end

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

@@ -0,0 +1,5 @@
+# -*- coding: utf-8 -*-
+
+Expectations do
+
+end

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

@@ -0,0 +1,22 @@
+# -*- 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

@@ -0,0 +1,45 @@
+# -*- 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

@@ -0,0 +1,45 @@
+# -*- 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

@@ -0,0 +1,45 @@
+# -*- 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

@@ -0,0 +1,45 @@
+# -*- 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

@@ -0,0 +1,50 @@
+# -*- 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

@@ -0,0 +1,113 @@
+# -*- 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