lookout 2.0.1

data/lib/lookout/ui/silent.rb

@@ -0,0 +1,12 @@
+# -*- coding: utf-8 -*-
+
+class Lookout::UI::Silent
+  def start
+  end
+
+  def report(result)
+  end
+
+  def summarize(results, time)
+  end
+end

data/lib/lookout/version.rb

@@ -0,0 +1,5 @@
+# -*- coding: utf-8 -*-
+
+module Lookout
+  Version = '2.0.1'
+end

data/lib/lookout/xml.rb

@@ -0,0 +1,17 @@
+# -*- coding: utf-8 -*-
+
+class Lookout::XML < String
+  def ==(other)
+    not normalize(other).index(normalize).nil?
+  end
+
+  def inspect
+    'xml(%s)' % [normalize]
+  end
+
+private
+
+  def normalize(xml = self)
+    xml.strip.gsub(/>\s*</, '><')
+  end
+end

data/test/unit/examples.rb

@@ -0,0 +1,169 @@
+# -*- coding: utf-8 -*-
+
+Expectations do
+  # State-based Expectations
+
+  # Determine if the result equals a value.
+  expect 2 do
+    1 + 1
+  end
+
+  # Determine if the result, retrieved through a stub, equals a value.
+  expect 2 do
+    Object.new.tap{ |o| stub(o).two{ 2 } }.two
+  end
+
+  # Match against a Regexp.  Please note the use of parentheses to silence
+  # warnings.
+  expect(/a string/) do
+    'a string'
+  end
+
+  # Match inside a Range.
+  expect 1..5 do
+    3
+  end
+
+  # Verify that the result is an Enumerable.
+  expect Enumerable do
+    []
+  end
+
+  # Verify that the result is a String.
+  expect String do
+    'a string'
+  end
+
+  # Determine equality of modules.
+  expect Enumerable do
+    Enumerable
+  end
+
+  # Determine equality of classes.
+  expect String do
+    String
+  end
+
+  # Verify that the result is truthful.
+  expect true do
+    1
+  end
+
+  # Verify that the result is “falseful”.
+  expect false do
+    nil
+  end
+
+  # Verify that the result is actually true.
+  expect TrueClass do
+    true
+  end
+
+  # Verify that the result is actually false.
+  expect FalseClass do
+    false
+  end
+
+  # Match XML contents, ignoring whitespace between tags.
+  expect xml('<a><foo>bar</foo></a>') do
+    "<a>\n\t<foo>bar</foo>  \n</a>"
+  end
+
+  # Match XML contents, ignoring whitespace between tags.
+  expect xml(<<-EOX) do
+    <one>
+      <two>
+        <three>4</three>
+        <five> 6 </five>
+      </two>
+    </one>
+  EOX
+    '<one><two><three>4</three>
+     <five> 6 </five>
+     </two></one>'
+  end
+
+  # Verify that the given text is output.
+  expect output("abc\ndef\n") do |io|
+    io.puts 'abc', 'def'
+  end
+
+  # Verify that an exception is raised.
+  expect NoMethodError do
+    Object.no_method
+  end
+
+  # Verify that an exception with a specific message is raised.
+  expect StandardError.new('message') do
+    raise StandardError.new('message')
+  end
+
+  # Verify that an exception with a message matching a given Regexp is raised.
+  expect StandardError.new(/mess/) do
+    raise StandardError.new('message')
+  end
+
+  # State-based Fluent Boolean Expectations
+
+  # Expect an object to “be” something.
+  expect(Class.new{ attr_accessor :running }.new.to.be.running) do |process|
+    process.running = true
+  end
+
+  # Expect an object to “have” something.
+  expect(Class.new{ attr_accessor :finished }.new.to.have.finished) do |process|
+    process.finished = true
+  end
+
+  # Expect nil to respond to #nil?.
+  expect nil.to.respond_to? :nil?
+
+  # Expect nil to be nil.
+  expect nil.to.be.nil?
+
+  # Expect Object not to be nil.
+  expect Object.not.to.be.nil?
+
+  # Behavior-based Expectations
+
+  # Use a mock to verify that a method is called appropriately.
+  expect mock.to.receive.dial('2125551212').twice do |phone|
+    phone.dial('2125551212')
+    phone.dial('2125551212')
+  end
+
+  # Use a stub that ignores all calls to verify that a method is called
+  # appropriately.  Any other calls made are ignored.
+  expect stub.to.receive.dial('2125551212').twice do |phone|
+    phone.dial('2125551212')
+    phone.hangup
+    phone.dial('2125551212')
+  end
+
+  # Use a stub that’s set up with a set of methods.
+  expect 3 do
+    s = stub(:a => 1, :b => 2)
+    s.a + s.b
+  end
+
+  # Use a contrete mock to verify that a method is called.
+  expect Object.to.receive.deal do
+    Object.deal
+  end
+
+  # Expect a new object to receive #deal with any arguments.
+  expect Object.new.to.receive.deal do |o|
+    o.deal(1, 2, 3)
+  end
+
+  # Expect a new object to receive #deal without arguments.
+  expect Object.new.to.receive.deal(without_arguments) do |o|
+    o.deal
+  end
+
+  # Expect a new object to receive #deal with any argument, 1, and any
+  # argument.
+  expect Object.new.to.receive.deal(arg, 1, arg) do |o|
+    o.deal :a, 1, :b
+  end
+end

data/test/unit/lookout.rb

@@ -0,0 +1,7 @@
+# -*- coding: utf-8 -*-
+
+Expectations do
+  expect Lookout.runner.to.receive.expectations_eval do
+    Expectations{ }
+  end
+end

data/test/unit/lookout/diff.rb

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

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

@@ -0,0 +1,56 @@
+# -*- coding: utf-8 -*-
+
+Expectations do
+  expect [Lookout::Diff::Match.new(Lookout::Diff::Range.new('abxcd', 0..1),
+                                   Lookout::Diff::Range.new('abcd', 0..1)),
+          Lookout::Diff::Match.new(Lookout::Diff::Range.new('abxcd', 3..4),
+                                   Lookout::Diff::Range.new('abcd', 2..3)),
+          Lookout::Diff::Match.new(Lookout::Diff::Range.new('abxcd', 5...5),
+                                   Lookout::Diff::Range.new('abcd', 4...4))] do
+    Lookout::Diff::Algorithms::Difflib.new('abxcd', 'abcd').to_a
+  end
+
+  expect [Lookout::Diff::Match.new(Lookout::Diff::Range.new('acbxcd', 0..0),
+                                   Lookout::Diff::Range.new('aybcd', 0..0)),
+          Lookout::Diff::Match.new(Lookout::Diff::Range.new('acbxcd', 2..2),
+                                   Lookout::Diff::Range.new('aybcd', 2..2)),
+          Lookout::Diff::Match.new(Lookout::Diff::Range.new('acbxcd', 4..5),
+                                   Lookout::Diff::Range.new('aybcd', 3..4)),
+          Lookout::Diff::Match.new(Lookout::Diff::Range.new('acbxcd', 6...6),
+                                   Lookout::Diff::Range.new('aybcd', 5...5))] do
+    Lookout::Diff::Algorithms::Difflib.new('acbxcd', 'aybcd').to_a
+  end
+
+  expect [Lookout::Diff::Match.new(Lookout::Diff::Range.new('qabxcd', 1..2),
+                                   Lookout::Diff::Range.new('abycdf', 0..1)),
+          Lookout::Diff::Match.new(Lookout::Diff::Range.new('qabxcd', 4..5),
+                                   Lookout::Diff::Range.new('abycdf', 3..4)),
+          Lookout::Diff::Match.new(Lookout::Diff::Range.new('qabxcd', 6...6),
+                                   Lookout::Diff::Range.new('abycdf', 6...6))] do
+    Lookout::Diff::Algorithms::Difflib.new('qabxcd', 'abycdf').to_a
+  end
+
+  expect [Lookout::Diff::Match.new(Lookout::Diff::Range.new('abxcd', 0..1),
+                                   Lookout::Diff::Range.new('abcd', 0..1)),
+          Lookout::Diff::Match.new(Lookout::Diff::Range.new('abxcd', 3..4),
+                                   Lookout::Diff::Range.new('abcd', 2..3)),
+          Lookout::Diff::Match.new(Lookout::Diff::Range.new('abxcd', 5...5),
+                                   Lookout::Diff::Range.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::Range.new('private Thread currentThread;', 0..7),
+                                   Lookout::Diff::Range.new('private volatile Thread currentThread;', 0..7)),
+          Lookout::Diff::Match.new(Lookout::Diff::Range.new('private Thread currentThread;', 8..28),
+                                   Lookout::Diff::Range.new('private volatile Thread currentThread;', 17..37)),
+          Lookout::Diff::Match.new(Lookout::Diff::Range.new('private Thread currentThread;', 29...29),
+                                   Lookout::Diff::Range.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/diff/algorithms/difflib/position.rb

@@ -0,0 +1,92 @@
+# -*- coding: utf-8 -*-
+
+Expectations do
+  expect Lookout::Diff::Match.new(Lookout::Diff::Range.new('abc', 0...0),
+                                  Lookout::Diff::Range.new('xyz', 0...0)) do
+    Lookout::Diff::Algorithms::Difflib::Position.origin('abc', 'xyz').match
+  end
+
+  expect Lookout::Diff::Match.new(Lookout::Diff::Range.new('abc'),
+                                  Lookout::Diff::Range.new('abc')) do
+    Lookout::Diff::Algorithms::Difflib::Position.origin('abc', 'abc').match
+  end
+
+  expect Lookout::Diff::Match.new(Lookout::Diff::Range.new('Xabc', 1..3),
+                                  Lookout::Diff::Range.new('abc')) do
+    Lookout::Diff::Algorithms::Difflib::Position.origin('Xabc', 'abc').match
+  end
+
+  expect Lookout::Diff::Match.new(Lookout::Diff::Range.new('abcX', 0..2),
+                                  Lookout::Diff::Range.new('abc')) do
+    Lookout::Diff::Algorithms::Difflib::Position.origin('abcX', 'abc').match
+  end
+
+  expect Lookout::Diff::Match.new(Lookout::Diff::Range.new('abc'),
+                                  Lookout::Diff::Range.new('Xabc', 1..3)) do
+    Lookout::Diff::Algorithms::Difflib::Position.origin('abc', 'Xabc').match
+  end
+
+  expect Lookout::Diff::Match.new(Lookout::Diff::Range.new('abc'),
+                                  Lookout::Diff::Range.new('abcX', 0..2)) do
+    Lookout::Diff::Algorithms::Difflib::Position.origin('abc', 'abcX').match
+  end
+
+  expect Lookout::Diff::Match.new(Lookout::Diff::Range.new('ab', 0..1),
+                                  Lookout::Diff::Range.new('abXabc', 0..1)) do
+    Lookout::Diff::Algorithms::Difflib::Position.origin('ab', 'abXabc').match
+  end
+
+  expect Lookout::Diff::Match.new(Lookout::Diff::Range.new('abc'),
+                                  Lookout::Diff::Range.new('abXabc', 3..5)) do
+    Lookout::Diff::Algorithms::Difflib::Position.origin('abc', 'abXabc').match
+  end
+
+  expect Lookout::Diff::Match.new(Lookout::Diff::Range.new(' abc', 1..3),
+                                  Lookout::Diff::Range.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').
+      begins_before? Lookout::Diff::Match.new(Lookout::Diff::Range.new('abc', 0..0),
+                                              Lookout::Diff::Range.new('abc', 0..0))
+  end
+
+  expect true do
+    Lookout::Diff::Algorithms::Difflib::Position.origin('abc', 'abc').
+      begins_before? Lookout::Diff::Match.new(Lookout::Diff::Range.new('abc', 1..1),
+                                              Lookout::Diff::Range.new('abc', 1..1))
+  end
+
+  expect false do
+    Lookout::Diff::Algorithms::Difflib::Position.origin('abc', 'abc').
+      ends_after? Lookout::Diff::Match.new(Lookout::Diff::Range.new('abc', 3..3),
+                                           Lookout::Diff::Range.new('abc', 3..3))
+  end
+
+  expect true do
+    Lookout::Diff::Algorithms::Difflib::Position.origin('abc', 'abc').
+      ends_after? Lookout::Diff::Match.new(Lookout::Diff::Range.new('abc', 1..1),
+                                           Lookout::Diff::Range.new('abc', 1..1))
+  end
+
+  expect Lookout::Diff::Algorithms::Difflib::Position.
+           new(Lookout::Diff::Range.new('dabcX', 4..4),
+               Lookout::Diff::Algorithms::Difflib::Position::To.new('ddabcY', 5..5),
+               {}) do
+    Lookout::Diff::Algorithms::Difflib::Position.origin('dabcX', 'ddabcY').
+      begin_after(Lookout::Diff::Match.new(Lookout::Diff::Range.new('dabcX', 0..3),
+                                           Lookout::Diff::Range.new('ddabcY', 1..4)))
+  end
+
+  expect Lookout::Diff::Algorithms::Difflib::Position.
+           new(Lookout::Diff::Range.new('dabcX', 0...0),
+               Lookout::Diff::Algorithms::Difflib::Position::To.new('ddabcY', 0..0),
+               {}) do
+    Lookout::Diff::Algorithms::Difflib::Position.origin('dabcX', 'ddabcY').
+      end_before(Lookout::Diff::Match.new(Lookout::Diff::Range.new('dabcX', 0..3),
+                                          Lookout::Diff::Range.new('ddabcY', 1..4)))
+  end
+end

data/test/unit/lookout/diff/algorithms/difflib/position/to.rb

@@ -0,0 +1,12 @@
+# -*- coding: utf-8 -*-
+
+Expectations do
+  expect [0, 2] do
+    result = []
+    Lookout::Diff::Algorithms::Difflib::Position::To.
+      new(%w[a b a]).each_index('a') do |index|
+      result << index
+    end
+    result
+  end
+end

data/test/unit/lookout/diff/formats/inline.rb

@@ -0,0 +1,17 @@
+# -*- coding: utf-8 -*-
+
+Expectations do
+  expect 'one two three' do
+    Lookout::Diff::Formats::Inline.
+      new(Lookout::Diff::Operations.
+            new(Lookout::Diff::Algorithms::Difflib.new('one two three',
+                                                       'one two three'))).to_s
+  end
+
+  expect 'one t[-w-]{+o+}o three' do
+    Lookout::Diff::Formats::Inline.
+      new(Lookout::Diff::Operations.
+            new(Lookout::Diff::Algorithms::Difflib.new('one two three',
+                                                       'one too three'))).to_s
+  end
+end

data/test/unit/lookout/diff/formats/unified.rb

@@ -0,0 +1,67 @@
+# -*- coding: utf-8 -*-
+
+Expectations do
+  expect '' do
+    Lookout::Diff::Formats::Unified.
+      new(Lookout::Diff::Groups.
+            new(Lookout::Diff::Operations.
+                  new(Lookout::Diff::Algorithms::Difflib.
+                        new(%w[one two three],
+                            %w[one two three])))).to_a.join("\n")
+  end
+
+  expect <<EOD.chomp do
+@@ -1,4 +1,4 @@
++zero
+ one
+-two
+-three
++tree
+ four
+EOD
+    Lookout::Diff::Formats::Unified.
+      new(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.join("\n")
+  end
+
+  expect <<EOD.chomp do
+@@ -1,4 +1,4 @@
+-two
++too
+ 1
+ 2
+ 3
+EOD
+    Lookout::Diff::Formats::Unified.
+      new(Lookout::Diff::Groups.
+            new(Lookout::Diff::Operations.
+                  new(Lookout::Diff::Algorithms::Difflib.
+                        new(%w[two 1 2 3 4 5 6 7 8],
+                            %w[too 1 2 3 4 5 6 7 8])))).to_a.join("\n")
+  end
+
+  expect <<EOD.chomp do
+@@ -1,4 +1,4 @@
+-two
++too
+ 1
+ 2
+ 3
+@@ -7,4 +7,4 @@
+ 6
+ 7
+ 8
+-one
++tre
+EOD
+    Lookout::Diff::Formats::Unified.
+      new(Lookout::Diff::Groups.
+            new(Lookout::Diff::Operations.
+                  new(Lookout::Diff::Algorithms::Difflib.
+                        new(%w[two 1 2 3 4 5 6 7 8 one],
+                            %w[too 1 2 3 4 5 6 7 8 tre])))).to_a.join("\n")
+  end
+end