lookout 2.3.0 → 3.0.0

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

@@ -0,0 +1,13 @@
+# -*- coding: utf-8 -*-
+
+Expectations do
+  expect Lookout::Actual::Not do Lookout::Actual.new.not end
+
+  expect Lookout::Actual do Lookout::Actual.new.to end
+
+  expect Lookout::Actual do Lookout::Actual.new.to.be end
+
+  expect Lookout::Actual do Lookout::Actual.new.to.have end
+
+  expect Lookout::Actual::Method do Lookout::Actual.new.to.be.empty? end
+end

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

@@ -0,0 +1,31 @@
+# -*- coding: utf-8 -*-
+
+Expectations do
+  expect 0 do
+    Lookout::Actual::Method::new(:length).call([])
+  end
+
+  expect '#length' do
+    Lookout::Actual::Method::new(:length).to_s
+  end
+
+  expect '#==(0)' do
+    Lookout::Actual::Method::new(:==, 0).to_s
+  end
+
+  expect '#one?{ … }' do
+    Lookout::Actual::Method::new(:one?){ true }.to_s
+  end
+
+  expect '#one?(1){ … }' do
+    Lookout::Actual::Method::new(:one?, 1){ true }.to_s
+  end
+
+  expect '#push(1, 2, 3)' do
+    Lookout::Actual::Method::new(:push, 1, 2, 3).to_s
+  end
+
+  expect Lookout::Expected::Lookout::Actual::Method.new(Lookout::Actual::Method.new(:empty?)) do |o|
+    Lookout::Actual.new.to.be.empty?.to_lookout_expected
+  end
+end

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

@@ -0,0 +1,15 @@
+# -*- coding: utf-8 -*-
+
+Expectations do
+  expect Lookout::Actual do
+    Lookout::Actual::Not.new.not
+  end
+
+  expect Lookout::Actual::Not do Lookout::Actual::Not.new.to end
+
+  expect Lookout::Actual::Not do Lookout::Actual::Not.new.to.be end
+
+  expect Lookout::Actual::Not do Lookout::Actual::Not.new.to.have end
+
+  expect Lookout::Actual::Not::Method do Lookout::Actual::Not.new.to.be.empty? end
+end

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

@@ -0,0 +1,7 @@
+# -*- coding: utf-8 -*-
+
+Expectations do
+  expect Lookout::Expected::Lookout::Actual::Not::Method.new(Lookout::Actual::Not::Method.new(:empty?)) do |o|
+    Lookout::Actual::Not.new.to.be.empty?.to_lookout_expected
+  end
+end

data/test/unit/lookout-3.0/aphonic.rb

@@ -0,0 +1,31 @@
+# -*- coding: utf-8 -*-
+
+Expectations do
+  if RUBY_VERSION < '1.9'
+    expect ['__id__', '__send__', 'object_id'] do
+      Lookout::Aphonic.instance_methods.sort
+    end
+  else
+    expect [:__send__, :object_id] do
+      Lookout::Aphonic.instance_methods.sort
+    end
+  end
+
+  expect true do
+    class Object; def lookout_test_temporary_method() end end
+    begin
+      Object.method_defined? :lookout_test_temporary_method
+    ensure
+      class Object; remove_method :lookout_test_temporary_method end
+    end
+  end
+
+  expect false do
+    class Object; def lookout_test_temporary_method() end end
+    begin
+      Lookout::Aphonic.method_defined? :lookout_test_temporary_method
+    ensure
+      class Object; remove_method :lookout_test_temporary_method end
+    end
+  end
+end

data/test/unit/lookout-3.0/diff/algorithms/difflib.rb

@@ -0,0 +1,56 @@
+# -*- coding: utf-8 -*-
+
+Expectations do
+  expect [Lookout::Diff::Match.new(Lookout::Diff::Slice.new('abxcd', 0..1),
+                                   Lookout::Diff::Slice.new('abcd', 0..1)),
+          Lookout::Diff::Match.new(Lookout::Diff::Slice.new('abxcd', 3..4),
+                                   Lookout::Diff::Slice.new('abcd', 2..3)),
+          Lookout::Diff::Match.new(Lookout::Diff::Slice.new('abxcd', 5...5),
+                                   Lookout::Diff::Slice.new('abcd', 4...4))] do
+    Lookout::Diff::Algorithms::Difflib.new('abxcd', 'abcd').to_a
+  end
+
+  expect [Lookout::Diff::Match.new(Lookout::Diff::Slice.new('acbxcd', 0..0),
+                                   Lookout::Diff::Slice.new('aybcd', 0..0)),
+          Lookout::Diff::Match.new(Lookout::Diff::Slice.new('acbxcd', 2..2),
+                                   Lookout::Diff::Slice.new('aybcd', 2..2)),
+          Lookout::Diff::Match.new(Lookout::Diff::Slice.new('acbxcd', 4..5),
+                                   Lookout::Diff::Slice.new('aybcd', 3..4)),
+          Lookout::Diff::Match.new(Lookout::Diff::Slice.new('acbxcd', 6...6),
+                                   Lookout::Diff::Slice.new('aybcd', 5...5))] do
+    Lookout::Diff::Algorithms::Difflib.new('acbxcd', 'aybcd').to_a
+  end
+
+  expect [Lookout::Diff::Match.new(Lookout::Diff::Slice.new('qabxcd', 1..2),
+                                   Lookout::Diff::Slice.new('abycdf', 0..1)),
+          Lookout::Diff::Match.new(Lookout::Diff::Slice.new('qabxcd', 4..5),
+                                   Lookout::Diff::Slice.new('abycdf', 3..4)),
+          Lookout::Diff::Match.new(Lookout::Diff::Slice.new('qabxcd', 6...6),
+                                   Lookout::Diff::Slice.new('abycdf', 6...6))] do
+    Lookout::Diff::Algorithms::Difflib.new('qabxcd', 'abycdf').to_a
+  end
+
+  expect [Lookout::Diff::Match.new(Lookout::Diff::Slice.new('abxcd', 0..1),
+                                   Lookout::Diff::Slice.new('abcd', 0..1)),
+          Lookout::Diff::Match.new(Lookout::Diff::Slice.new('abxcd', 3..4),
+                                   Lookout::Diff::Slice.new('abcd', 2..3)),
+          Lookout::Diff::Match.new(Lookout::Diff::Slice.new('abxcd', 5...5),
+                                   Lookout::Diff::Slice.new('abcd', 4...4)),] do
+    Lookout::Diff::Algorithms::Difflib.new('abxcd', 'abcd').to_a
+  end
+
+  # 0, 0, 8
+  # 8, 17, 21
+  # 29, 38, 0
+  expect [Lookout::Diff::Match.new(Lookout::Diff::Slice.new('private Thread currentThread;', 0..7),
+                                   Lookout::Diff::Slice.new('private volatile Thread currentThread;', 0..7)),
+          Lookout::Diff::Match.new(Lookout::Diff::Slice.new('private Thread currentThread;', 8..28),
+                                   Lookout::Diff::Slice.new('private volatile Thread currentThread;', 17..37)),
+          Lookout::Diff::Match.new(Lookout::Diff::Slice.new('private Thread currentThread;', 29...29),
+                                   Lookout::Diff::Slice.new('private volatile Thread currentThread;', 38...38))] do
+    Lookout::Diff::Algorithms::Difflib.new('private Thread currentThread;',
+                                           'private volatile Thread currentThread;'){ |c|
+      c == ' '[0]
+    }.to_a
+  end
+end

data/test/unit/lookout-3.0/diff/algorithms/difflib/position.rb

@@ -0,0 +1,92 @@
+# -*- coding: utf-8 -*-
+
+Expectations do
+  expect Lookout::Diff::Match.new(Lookout::Diff::Slice.new('abc', 0...0),
+                                  Lookout::Diff::Slice.new('xyz', 0...0)) do
+    Lookout::Diff::Algorithms::Difflib::Position.origin('abc', 'xyz').match
+  end
+
+  expect Lookout::Diff::Match.new(Lookout::Diff::Slice.new('abc'),
+                                  Lookout::Diff::Slice.new('abc')) do
+    Lookout::Diff::Algorithms::Difflib::Position.origin('abc', 'abc').match
+  end
+
+  expect Lookout::Diff::Match.new(Lookout::Diff::Slice.new('Xabc', 1..3),
+                                  Lookout::Diff::Slice.new('abc')) do
+    Lookout::Diff::Algorithms::Difflib::Position.origin('Xabc', 'abc').match
+  end
+
+  expect Lookout::Diff::Match.new(Lookout::Diff::Slice.new('abcX', 0..2),
+                                  Lookout::Diff::Slice.new('abc')) do
+    Lookout::Diff::Algorithms::Difflib::Position.origin('abcX', 'abc').match
+  end
+
+  expect Lookout::Diff::Match.new(Lookout::Diff::Slice.new('abc'),
+                                  Lookout::Diff::Slice.new('Xabc', 1..3)) do
+    Lookout::Diff::Algorithms::Difflib::Position.origin('abc', 'Xabc').match
+  end
+
+  expect Lookout::Diff::Match.new(Lookout::Diff::Slice.new('abc'),
+                                  Lookout::Diff::Slice.new('abcX', 0..2)) do
+    Lookout::Diff::Algorithms::Difflib::Position.origin('abc', 'abcX').match
+  end
+
+  expect Lookout::Diff::Match.new(Lookout::Diff::Slice.new('ab', 0..1),
+                                  Lookout::Diff::Slice.new('abXabc', 0..1)) do
+    Lookout::Diff::Algorithms::Difflib::Position.origin('ab', 'abXabc').match
+  end
+
+  expect Lookout::Diff::Match.new(Lookout::Diff::Slice.new('abc'),
+                                  Lookout::Diff::Slice.new('abXabc', 3..5)) do
+    Lookout::Diff::Algorithms::Difflib::Position.origin('abc', 'abXabc').match
+  end
+
+  expect Lookout::Diff::Match.new(Lookout::Diff::Slice.new(' abc', 1..3),
+                                  Lookout::Diff::Slice.new('abc abc', 0..2)) do
+    Lookout::Diff::Algorithms::Difflib::Position.origin(' abc', 'abc abc'){ |c| c == ' '[0] }.match
+  end
+
+  # TODO: Need more tests for is_junk.
+
+  expect false do
+    Lookout::Diff::Algorithms::Difflib::Position.origin('abc', 'abc').
+      begin_before? Lookout::Diff::Match.new(Lookout::Diff::Slice.new('abc', 0..0),
+                                             Lookout::Diff::Slice.new('abc', 0..0))
+  end
+
+  expect true do
+    Lookout::Diff::Algorithms::Difflib::Position.origin('abc', 'abc').
+      begin_before? Lookout::Diff::Match.new(Lookout::Diff::Slice.new('abc', 1..1),
+                                             Lookout::Diff::Slice.new('abc', 1..1))
+  end
+
+  expect false do
+    Lookout::Diff::Algorithms::Difflib::Position.origin('abc', 'abc').
+      end_after? Lookout::Diff::Match.new(Lookout::Diff::Slice.new('abc', 3..3),
+                                          Lookout::Diff::Slice.new('abc', 3..3))
+  end
+
+  expect true do
+    Lookout::Diff::Algorithms::Difflib::Position.origin('abc', 'abc').
+      end_after? Lookout::Diff::Match.new(Lookout::Diff::Slice.new('abc', 1..1),
+                                          Lookout::Diff::Slice.new('abc', 1..1))
+  end
+
+  expect Lookout::Diff::Algorithms::Difflib::Position.
+           new(Lookout::Diff::Slice.new('dabcX', 4..4),
+               Lookout::Diff::Algorithms::Difflib::Position::New.new('ddabcY', 5..5),
+               {}) do
+    Lookout::Diff::Algorithms::Difflib::Position.origin('dabcX', 'ddabcY').
+      begin_after(Lookout::Diff::Match.new(Lookout::Diff::Slice.new('dabcX', 0..3),
+                                           Lookout::Diff::Slice.new('ddabcY', 1..4)))
+  end
+
+  expect Lookout::Diff::Algorithms::Difflib::Position.
+           new(Lookout::Diff::Slice.new('dabcX', 0...0),
+               Lookout::Diff::Algorithms::Difflib::Position::New.new('ddabcY', 0..0),
+               {}) do
+    Lookout::Diff::Algorithms::Difflib::Position.origin('dabcX', 'ddabcY').
+      end_before(Lookout::Diff::Match.new(Lookout::Diff::Slice.new('dabcX', 0..3),
+                                          Lookout::Diff::Slice.new('ddabcY', 1..4)))
+  end
+end

data/test/unit/{lookout/diff/algorithms/difflib/position/to.rb → lookout-3.0/diff/algorithms/difflib/position/new.rb}

@@ -3,8 +3,7 @@
 Expectations do
   expect [0, 2] do
     result = []
-    Lookout::Diff::Algorithms::Difflib::Position::To.
-      new(%w[a b a]).each_index('a') do |index|
+    Lookout::Diff::Algorithms::Difflib::Position::New.new(%w[a b a]).each_index('a') do |index|
       result << index
     end
     result

data/test/unit/lookout-3.0/diff/formats/set.rb

@@ -0,0 +1,26 @@
+# -*- coding: utf-8 -*-
+
+Expectations do
+  expect '' do
+    Lookout::Diff::Formats::Set.
+      new(Lookout::Diff::Operations.
+          new(Lookout::Diff::Algorithms::Difflib.
+              new(['a => 1', 'b => 2', 'c => 3'],
+                  ['a => 1', 'b => 2', 'c => 3']))).to_a.join("\n")
+  end
+
+  expect <<EOD.chomp do
+-a => 1
+-b => 2
+-c => 3
++a => 0
++b => 1
++c => 2
+EOD
+    Lookout::Diff::Formats::Set.
+      new(Lookout::Diff::Operations.
+          new(Lookout::Diff::Algorithms::Difflib.
+              new(['a => 1', 'b => 2', 'c => 3', 'd => 4'],
+                  ['a => 0', 'b => 1', 'c => 2', 'd => 4']))).to_a.join("\n")
+  end
+end

data/test/unit/lookout-3.0/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::Copy.new(Lookout::Diff::Slice.new('abc', 0..2),
+                                                                       Lookout::Diff::Slice.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::Copy.new(Lookout::Diff::Slice.new('abcdefg', 4..6),
+                                                                       Lookout::Diff::Slice.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::Slice.new('Abcdefg', 0..0),
+                                                                          Lookout::Diff::Slice.new('abcdefg', 0..0)),
+                                   Lookout::Diff::Operations::Copy.new(Lookout::Diff::Slice.new('Abcdefg', 1..3),
+                                                                       Lookout::Diff::Slice.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::Slice.new('Abcdefgh', 0..0),
+                                                                          Lookout::Diff::Slice.new('abcdefgh', 0..0)),
+                                   Lookout::Diff::Operations::Copy.new(Lookout::Diff::Slice.new('Abcdefgh', 1..3),
+                                                                       Lookout::Diff::Slice.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::Copy.new(Lookout::Diff::Slice.new('abcdefgHijklmno', 4..6),
+                                                                       Lookout::Diff::Slice.new('abcdefghijklmno', 4..6)),
+                                   Lookout::Diff::Operations::Replace.new(Lookout::Diff::Slice.new('abcdefgHijklmno', 7..7),
+                                                                          Lookout::Diff::Slice.new('abcdefghijklmno', 7..7)),
+                                   Lookout::Diff::Operations::Copy.new(Lookout::Diff::Slice.new('abcdefgHijklmno', 8..10),
+                                                                       Lookout::Diff::Slice.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::Copy.new(Lookout::Diff::Slice.new('123456789abcdefghijk', 0..0),
+                                                                       Lookout::Diff::Slice.new('1i3456789abXdhYjk', 0..0)),
+                                   Lookout::Diff::Operations::Replace.new(Lookout::Diff::Slice.new('123456789abcdefghijk', 1..1),
+                                                                          Lookout::Diff::Slice.new('1i3456789abXdhYjk', 1..1)),
+                                   Lookout::Diff::Operations::Copy.new(Lookout::Diff::Slice.new('123456789abcdefghijk', 2..4),
+                                                                       Lookout::Diff::Slice.new('1i3456789abXdhYjk', 2..4))),
+          Lookout::Diff::Group.new(Lookout::Diff::Operations::Copy.new(Lookout::Diff::Slice.new('123456789abcdefghijk', 8..10),
+                                                                       Lookout::Diff::Slice.new('1i3456789abXdhYjk', 8..10)),
+                                   Lookout::Diff::Operations::Replace.new(Lookout::Diff::Slice.new('123456789abcdefghijk', 11..11),
+                                                                          Lookout::Diff::Slice.new('1i3456789abXdhYjk', 11..11)),
+                                   Lookout::Diff::Operations::Copy.new(Lookout::Diff::Slice.new('123456789abcdefghijk', 12..12),
+                                                                       Lookout::Diff::Slice.new('1i3456789abXdhYjk', 12..12)),
+                                   Lookout::Diff::Operations::Delete.new(Lookout::Diff::Slice.new('123456789abcdefghijk', 13..15),
+                                                                         Lookout::Diff::Slice.new('1i3456789abXdhYjk', 13...13)),
+                                   Lookout::Diff::Operations::Copy.new(Lookout::Diff::Slice.new('123456789abcdefghijk', 16..16),
+                                                                       Lookout::Diff::Slice.new('1i3456789abXdhYjk', 13..13)),
+                                   Lookout::Diff::Operations::Replace.new(Lookout::Diff::Slice.new('123456789abcdefghijk', 17..17),
+                                                                          Lookout::Diff::Slice.new('1i3456789abXdhYjk', 14..14)),
+                                   Lookout::Diff::Operations::Copy.new(Lookout::Diff::Slice.new('123456789abcdefghijk', 18..19),
+                                                                       Lookout::Diff::Slice.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::Slice.new(%w[one two three four], 0...0),
+                                                                         Lookout::Diff::Slice.new(%w[zero one tree four], 0..0)),
+                                   Lookout::Diff::Operations::Copy.new(Lookout::Diff::Slice.new(%w[one two three four], 0..0),
+                                                                       Lookout::Diff::Slice.new(%w[zero one tree four], 1..1)),
+                                   Lookout::Diff::Operations::Replace.new(Lookout::Diff::Slice.new(%w[one two three four], 1..2),
+                                                                          Lookout::Diff::Slice.new(%w[zero one tree four], 2..2)),
+                                   Lookout::Diff::Operations::Copy.new(Lookout::Diff::Slice.new(%w[one two three four], 3..3),
+                                                                       Lookout::Diff::Slice.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-3.0/diff/operation.rb

@@ -0,0 +1,17 @@
+# -*- coding: utf-8 -*-
+
+Expectations do
+  expect true do
+    Lookout::Diff::Operation.new(Lookout::Diff::Slice.new('', 0...0),
+                                 Lookout::Diff::Slice.new('', 0...0)) ==
+    Lookout::Diff::Operation.new(Lookout::Diff::Slice.new('', 0...0),
+                                 Lookout::Diff::Slice.new('', 0...0))
+  end
+
+  expect false do
+    Lookout::Diff::Operation.new(Lookout::Diff::Slice.new('', 0...0),
+                                 Lookout::Diff::Slice.new('', 0...0)) ==
+    Lookout::Diff::Operation.new(Lookout::Diff::Slice.new('', 0...1),
+                                 Lookout::Diff::Slice.new('', 0...3))
+  end
+end

data/test/unit/lookout-3.0/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::Slice.new('qabxcd', 0..0),
+                                                Lookout::Diff::Slice.new('abycdf', 0...0)),
+          Lookout::Diff::Operations::Copy.new(Lookout::Diff::Slice.new('qabxcd', 1..2),
+                                              Lookout::Diff::Slice.new('abycdf', 0..1)),
+          Lookout::Diff::Operations::Replace.new(Lookout::Diff::Slice.new('qabxcd', 3..3),
+                                                 Lookout::Diff::Slice.new('abycdf', 2..2)),
+          Lookout::Diff::Operations::Copy.new(Lookout::Diff::Slice.new('qabxcd', 4..5),
+                                              Lookout::Diff::Slice.new('abycdf', 3..4)),
+          Lookout::Diff::Operations::Insert.new(Lookout::Diff::Slice.new('qabxcd', 6...6),
+                                                Lookout::Diff::Slice.new('abycdf', 5..5))] do
+    Lookout::Diff::Operations.new(Lookout::Diff::Algorithms::Difflib.new('qabxcd',
+                                                                         'abycdf')).to_a
+  end
+end