lookout 2.1.2 → 2.1.3

data/lib/lookout.rb

@@ -2,7 +2,6 @@
 
 module Lookout
   autoload :Aphonic, 'lookout/aphonic'
-  autoload :Benchmark, 'lookout/benchmark'
   autoload :Diff, 'lookout/diff'
   autoload :Equality, 'lookout/equality'
   autoload :Expectation, 'lookout/expectation'

data/lib/lookout/equalities.rb

@@ -0,0 +1,13 @@
+# -*- coding: utf-8 -*-
+
+module Lookout::Equalities
+  require 'lookout/equalities/object'
+  require 'lookout/equalities/array'
+  require 'lookout/equalities/boolean'
+  require 'lookout/equalities/hash'
+  require 'lookout/equalities/include'
+  require 'lookout/equalities/output'
+  require 'lookout/equalities/standarderror'
+  require 'lookout/equalities/string'
+  require 'lookout/equalities/warning'
+end

data/lib/lookout/equalities/array.rb

@@ -0,0 +1,22 @@
+# -*- coding: utf-8 -*-
+
+class Lookout::Equalities::Array < Lookout::Equalities::Object
+  Lookout::Equality.register self, Array
+
+  def equal?(expected, actual)
+    return false unless Array === actual and expected.size == actual.size
+    expected.each_with_index do |v, i|
+      return false unless Lookout::Equality.equal? v, actual[i]
+    end
+    true
+  end
+
+  def diff(expected, actual)
+    return if expected.size == 1 or not Array === actual
+    Lookout::Diff::Formats::Unified.
+      new(Lookout::Diff::Groups.
+            new(Lookout::Diff::Operations.
+                  new(Lookout::Diff::Algorithms::Difflib.
+                        new(actual, expected)))).to_a.join("\n")
+  end
+end

data/lib/lookout/equalities/boolean.rb

@@ -0,0 +1,9 @@
+# -*- coding: utf-8 -*-
+
+class Lookout::Equalities::Boolean < Lookout::Equalities::Object
+  Lookout::Equality.register self, TrueClass, FalseClass
+
+  def equal?(expected, actual)
+    expected == !!actual
+  end
+end

data/lib/lookout/equalities/hash.rb

@@ -0,0 +1,25 @@
+# -*- coding: utf-8 -*-
+
+class Lookout::Equalities::Hash < Lookout::Equalities::Object
+  Lookout::Equality.register self, Hash
+
+  def equal?(expected, actual)
+    return false unless Hash === actual and expected.size == actual.size
+    expected.all?{ |k, v| Lookout::Equality.equal? v, actual[k] }
+  end
+
+  def diff(expected, actual)
+    return if expected.size == 1 or not Hash === actual
+    Lookout::Diff::Formats::Hash.
+      new(Lookout::Diff::Operations.
+            new(Lookout::Diff::Algorithms::Difflib.
+                  new(array(actual), array(expected)))).to_a.join("\n")
+  end
+
+private
+
+  def array(hash)
+    hash.to_a.sort_by{ |k, v| k }.map{ |k, v| '%p => %p' % [k, v] }
+  end
+end
+

data/lib/lookout/equalities/include.rb

@@ -0,0 +1,9 @@
+# -*- coding: utf-8 -*-
+
+class Lookout::Equalities::Includes < Lookout::Equalities::Object
+  Lookout::Equality.register self, Module, Range, Regexp
+
+  def equal?(expected, actual)
+    expected === actual or expected == actual
+  end
+end

data/lib/lookout/equalities/object.rb

@@ -0,0 +1,24 @@
+# -*- coding: utf-8 -*-
+
+class Lookout::Equalities::Object
+  Lookout::Equality.register self, Object
+
+  def equal?(expected, actual)
+    expected == actual
+  end
+
+  def message(expected, actual)
+    format = format(expected, actual)
+    return format unless diff = diff(expected, actual)
+    (diff.include?("\n") ? "%s\n%s" : '%s: %s') % [format, diff]
+  end
+
+  def diff(expected, actual)
+  end
+
+private
+
+  def format(expected, actual)
+    '%p≠%p' % [actual, expected]
+  end
+end

data/lib/lookout/equalities/output.rb

@@ -0,0 +1,19 @@
+# -*- coding: utf-8 -*-
+
+class Lookout::Equalities::Output < Lookout::Equalities::Object
+  Lookout::Equality.register self, Lookout::Output
+
+  def equal?(expected, _actual)
+    expected.expected == expected.actual
+  end
+
+  def diff(expected, _actual)
+    Lookout::Equality.diff(expected.expected, expected.actual)
+  end
+
+private
+
+  def format(expected, _actual)
+    '%p≠%p' % [Lookout::Output.new(expected.actual), expected]
+  end
+end

data/lib/lookout/equalities/standarderror.rb

@@ -0,0 +1,26 @@
+# -*- coding: utf-8 -*-
+
+class Lookout::Equalities::StandardError < Lookout::Equalities::Object
+  Lookout::Equality.register self, ::StandardError
+
+  def equal?(expected, actual)
+    expected.equal?(actual) or
+      ((actual.respond_to? :message rescue false) and
+       ((Regexp === expected.message and expected.message === actual.message) or
+        expected.message == actual.message))
+  end
+
+  def diff(expected, actual)
+    return super unless String === expected.message and
+      StandardError === actual and (actual.respond_to? :message rescue false)
+    Lookout::Equality.diff(expected.message, actual.message)
+  end
+
+private
+
+  def format(expected, actual)
+    Regexp === expected.message ?
+      '%p≠#<%s: %p>' % [actual, expected.class, expected.message] :
+      super
+  end
+end

data/lib/lookout/equalities/string.rb

@@ -0,0 +1,19 @@
+# -*- coding: utf-8 -*-
+
+class Lookout::Equalities::String < Lookout::Equalities::Object
+  Lookout::Equality.register self, String
+
+  def diff(expected, actual)
+    return unless String === actual
+    (expected.include? "\n" or actual.include? "\n") ?
+     Lookout::Diff::Formats::Unified.
+       new(Lookout::Diff::Groups.
+             new(Lookout::Diff::Operations.
+                   new(Lookout::Diff::Algorithms::Difflib.
+                         new(actual.split("\n"),
+                             expected.split("\n"))))).to_a.join("\n") :
+     Lookout::Diff::Formats::Inline.
+       new(Lookout::Diff::Operations.
+             new(Lookout::Diff::Algorithms::Difflib.new(actual, expected))).to_s
+  end
+end

data/lib/lookout/equalities/warning.rb

@@ -0,0 +1,16 @@
+# -*- coding: utf-8 -*-
+
+class Lookout::Equalities::Warning < Lookout::Equalities::String
+  Lookout::Equality.register self, Lookout::Warning
+
+  def equal?(expected, actual)
+    expected == actual.chomp or
+      actual =~ /\A.*?:\d+: warning: #{Regexp.escape(expected)}\Z/u
+  end
+
+private
+
+  def format(expected, actual)
+    '%p≠%p' % [Lookout::Warning.new(actual), expected]
+  end
+end

data/lib/lookout/equality.rb

@@ -31,163 +31,6 @@ module Lookout::Equality
       @equalities ||= {}
     end
   end
-end
-
-class Lookout::Equality::Object
-  Lookout::Equality.register self, Object
-
-  def equal?(expected, actual)
-    expected == actual
-  end
-
-  def message(expected, actual)
-    format = format(expected, actual)
-    return format unless diff = diff(expected, actual)
-    (diff.include?("\n") ? "%s\n%s" : '%s: %s') % [format, diff]
-  end
-
-  def diff(expected, actual)
-  end
-
-private
-
-  def format(expected, actual)
-    '%p≠%p' % [actual, expected]
-  end
-end
-
-class Lookout::Equality::Includes < Lookout::Equality::Object
-  Lookout::Equality.register self, Module, Range, Regexp
-
-  def equal?(expected, actual)
-    expected === actual or expected == actual
-  end
-end
-
-class Lookout::Equality::Boolean < Lookout::Equality::Object
-  Lookout::Equality.register self, TrueClass, FalseClass
-
-  def equal?(expected, actual)
-    expected == !!actual
-  end
-end
-
-class Lookout::Equality::String < Lookout::Equality::Object
-  Lookout::Equality.register self, String
-
-  def diff(expected, actual)
-    return unless String === actual
-    (expected.include? "\n" or actual.include? "\n") ?
-     Lookout::Diff::Formats::Unified.
-       new(Lookout::Diff::Groups.
-             new(Lookout::Diff::Operations.
-                   new(Lookout::Diff::Algorithms::Difflib.
-                         new(actual.split("\n"),
-                             expected.split("\n"))))).to_a.join("\n") :
-     Lookout::Diff::Formats::Inline.
-       new(Lookout::Diff::Operations.
-             new(Lookout::Diff::Algorithms::Difflib.new(actual, expected))).to_s
-  end
-end
-
-class Lookout::Equality::Array < Lookout::Equality::Object
-  Lookout::Equality.register self, Array
-
-  def equal?(expected, actual)
-    return false unless Array === actual and expected.size == actual.size
-    expected.each_with_index do |v, i|
-      return false unless Lookout::Equality.equal? v, actual[i]
-    end
-    true
-  end
-
-  def diff(expected, actual)
-    return if expected.size == 1 or not Array === actual
-    Lookout::Diff::Formats::Unified.
-      new(Lookout::Diff::Groups.
-            new(Lookout::Diff::Operations.
-                  new(Lookout::Diff::Algorithms::Difflib.
-                        new(actual, expected)))).to_a.join("\n")
-  end
-end
-
-class Lookout::Equality::Hash < Lookout::Equality::Object
-  Lookout::Equality.register self, Hash
 
-  def equal?(expected, actual)
-    return false unless Hash === actual and expected.size == actual.size
-    expected.all?{ |k, v| Lookout::Equality.equal? v, actual[k] }
-  end
-
-  def diff(expected, actual)
-    return if expected.size == 1 or not Hash === actual
-    Lookout::Diff::Formats::Hash.
-      new(Lookout::Diff::Operations.
-            new(Lookout::Diff::Algorithms::Difflib.
-                  new(array(actual), array(expected)))).to_a.join("\n")
-  end
-
-private
-
-  def array(hash)
-    hash.to_a.sort_by{ |k, v| k }.map{ |k, v| '%p => %p' % [k, v] }
-  end
-end
-
-class Lookout::Equality::StandardError < Lookout::Equality::Object
-  Lookout::Equality.register self, ::StandardError
-
-  def equal?(expected, actual)
-    expected.equal?(actual) or
-      ((actual.respond_to? :message rescue false) and
-       ((Regexp === expected.message and expected.message === actual.message) or
-        expected.message == actual.message))
-  end
-
-  def diff(expected, actual)
-    return super unless String === expected.message and
-      StandardError === actual and (actual.respond_to? :message rescue false)
-    Lookout::Equality.diff(expected.message, actual.message)
-  end
-
-private
-
-  def format(expected, actual)
-    Regexp === expected.message ?
-      '%p≠#<%s: %p>' % [actual, expected.class, expected.message] :
-      super
-  end
-end
-
-class Lookout::Equality::Output < Lookout::Equality::Object
-  Lookout::Equality.register self, Lookout::Output
-
-  def equal?(expected, _actual)
-    expected.expected == expected.actual
-  end
-
-  def diff(expected, _actual)
-    Lookout::Equality.diff(expected.expected, expected.actual)
-  end
-
-private
-
-  def format(expected, _actual)
-    '%p≠%p' % [Lookout::Output.new(expected.actual), expected]
-  end
-end
-
-class Lookout::Equality::Warning < Lookout::Equality::String
-  Lookout::Equality.register self, Lookout::Warning
-
-  def equal?(expected, actual)
-    expected == actual.chomp or
-      actual =~ /\A.*?:\d+: warning: #{Regexp.escape(expected)}\Z/u
-  end
-
-private
-
-  def format(expected, actual)
-    '%p≠%p' % [Lookout::Warning.new(actual), expected]
-  end
+  require 'lookout/equalities'
 end

data/lib/lookout/expectations.rb

@@ -4,10 +4,9 @@ class Lookout::Expectations
   autoload :Behavior, 'lookout/expectations/behavior'
   autoload :State, 'lookout/expectations/state'
 
-  include Enumerable
-
-  def initialize
-    @expectations = []
+  def initialize(results = Lookout::Results::Unsuccessful.new, line = nil)
+    @results, @line = results, line
+    @previous = nil
   end
 
   def mock
@@ -40,27 +39,23 @@ class Lookout::Expectations
 
   def expect(expected, &block)
     file, line = /\A(.*):(\d+)(?::in .*)?\z/.match(caller.first)[1..2]
-    @expectations << Lookout::Expectation.on(expected, file, line, &block)
-    expected
-  end
-
-  def evaluate(ui = Lookout::UI::Console.new, results = Lookout::Results.new)
-    ui.start
-    ui.summarize results, Lookout::Benchmark.time{
-      each(ENV['LINE'] ? ENV['LINE'].to_i : nil) do |expectation|
-        results << expectation.evaluate.tap{ |result| ui.report result }
+    expectation = Lookout::Expectation.on(expected, file, line, &block)
+    if @line
+      if @previous and @previous.line <= @line and expectation.line > @line
+        @results << @previous.evaluate
+        @previous = nil
+      else
+        @previous = expectation
       end
-    }
-    results
+    else
+      @results << expectation.evaluate
+    end
+    self
   end
 
-  def each(line = nil)
-    return enum_for(:each, line) unless block_given?
-    (line ?
-     Array(@expectations.reverse.find{ |e| e.line <= line }) :
-     @expectations).each do |expectation|
-      yield expectation
-    end
+  # TODO: It would be great if this method wasn’t necessary.
+  def flush
+    @results << @previous.evaluate if @previous
     self
   end
 end

data/lib/lookout/mock.rb

@@ -10,9 +10,11 @@ module Lookout::Mock
   class << self
     def methods
       methods = Methods.new
-      yield methods
-    ensure
-      methods.undefine if methods
+      begin
+        yield methods
+      ensure
+        methods.undefine
+      end
     end
   end
 end

data/lib/lookout/result.rb

@@ -1,16 +1,6 @@
 # -*- coding: utf-8 -*-
 
-class Lookout::Result
-  class << self
-    def is(is)
-      [:error, :failure, :fulfilled].each do |type|
-        define_method :"#{type}?" do
-          type == is
-        end
-      end
-    end
-  end
-
+module Lookout::Result
   def initialize(file, line)
     @file, @line = file, line
   end

data/lib/lookout/results.rb

@@ -1,46 +1,11 @@
 # -*- coding: utf-8 -*-
 
-class Lookout::Results
+module Lookout::Results
   autoload :Error, 'lookout/results/error'
   autoload :Failure, 'lookout/results/failure'
   autoload :Failures, 'lookout/results/failures'
   autoload :Fulfilled, 'lookout/results/fulfilled'
 
-  include Enumerable
-
-  def initialize
-    @results = []
-  end
-
-  def <<(result)
-    @results << result
-    self
-  end
-
-  def each
-    @results.each do |result|
-      yield result
-    end
-    self
-  end
-
-  def succeeded?
-    all?{ |result| result.fulfilled? }
-  end
-
-  def size
-    @results.size
-  end
-
-  def fulfillments
-    select{ |result| result.fulfilled? }
-  end
-
-  def errors
-    select{ |result| result.error? }
-  end
-
-  def failures
-    select{ |result| result.failure? }
-  end
+  autoload :Instance, 'lookout/results/instance'
+  autoload :Unsuccessful, 'lookout/results/unsuccessful'
 end

data/lib/lookout/results/error.rb

@@ -1,9 +1,9 @@
 # -*- coding: utf-8 -*-
 
-class Lookout::Results::Error < Lookout::Result
-  autoload :Exception, 'lookout/results/error/exception'
+class Lookout::Results::Error
+  include Lookout::Result
 
-  is :error
+  autoload :Exception, 'lookout/results/error/exception'
 
   def initialize(file, line, message, exception)
     super file, line

data/lib/lookout/results/failure.rb

@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 
-class Lookout::Results::Failure < Lookout::Result
-  is :failure
+module Lookout::Results::Failure
+  include Lookout::Result
 
   def initialize(file, line, message)
     super file, line

data/lib/lookout/results/failures/behavior.rb

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*-
 
-class Lookout::Results::Failures::Behavior < Lookout::Results::Failure
+class Lookout::Results::Failures::Behavior
+  include Lookout::Results::Failure
 end

data/lib/lookout/results/failures/state.rb

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*-
 
-class Lookout::Results::Failures::State < Lookout::Results::Failure
+class Lookout::Results::Failures::State
+  include Lookout::Results::Failure
 end

data/lib/lookout/results/fulfilled.rb

@@ -1,9 +1,5 @@
 # -*- coding: utf-8 -*-
 
-class Lookout::Results::Fulfilled < Lookout::Result
-  is :fulfilled
-
-  def initialize(file, line)
-    super file, line
-  end
+class Lookout::Results::Fulfilled
+  include Lookout::Result
 end

data/lib/lookout/results/instance.rb

@@ -0,0 +1,17 @@
+# -*- coding: utf-8 -*-
+
+module Lookout::Results::Instance
+  def initialize
+    @listeners = []
+  end
+
+  def on_new(&block)
+    @listeners << block
+  end
+
+  def <<(result)
+    @listeners.each do |listener|
+      listener.call result
+    end
+  end
+end

data/lib/lookout/results/unsuccessful.rb

@@ -0,0 +1,37 @@
+# -*- coding: utf-8 -*-
+
+class Lookout::Results::Unsuccessful
+  include Lookout::Results::Instance
+
+  include Enumerable
+
+  def initialize
+    super
+    @unsuccessful = []
+  end
+
+  def <<(result)
+    @unsuccessful << result unless Lookout::Results::Fulfilled === result
+    super
+    self
+  end
+
+  def each
+    @unsuccessful.each do |result|
+      yield result
+    end
+    self
+  end
+
+  def succeeded?
+    @unsuccessful.empty?
+  end
+
+  def errors
+    select{ |result| Lookout::Results::Error === result }
+  end
+
+  def failures
+    select{ |result| Lookout::Results::Failure === result }
+  end
+end

data/lib/lookout/runners/console.rb

@@ -1,22 +1,32 @@
 # -*- coding: utf-8 -*-
 
 class Lookout::Runners::Console
-  def initialize(expectations = Lookout::Expectations.new)
-    @expectations = expectations
-    @run = true
+  def initialize(results = Lookout::Results::Unsuccessful.new,
+                 expectations = Lookout::Expectations.new(results,
+                                                          ENV['LINE'] && ENV['LINE'].to_i),
+                 ui = Lookout::UI::Console.new(results))
+    @results, @expectations, @ui = results, expectations, ui
+    @ui.start
   end
 
   def install
     at_exit do
-      exit 1 unless @run and @expectations.evaluate.succeeded?
+      next if $!
+      @expectations.flush
+      @ui.summarize
+      exit 1 unless @results.succeeded?
     end
     self
   end
 
   def expectations_eval(&block)
     @expectations.instance_eval(&block)
-  rescue
-    @run = false
+  rescue Interrupt, NoMemoryError, SignalException, SystemExit
     raise
+  rescue Exception => e
+    raise unless location = Array(e.backtrace).first
+    file, line = /\A(.*):(\d+)(?::in .*)?\z/.match(location)[1..2]
+    raise unless file and line
+    @results << Lookout::Results::Error.new(file, line, nil, e)
   end
 end

data/lib/lookout/stub.rb

@@ -8,9 +8,11 @@ module Lookout::Stub
   class << self
     def methods
       methods = Methods.new
-      yield methods
-    ensure
-      methods.undefine if methods
+      begin
+        yield methods
+      ensure
+        methods.undefine
+      end
     end
   end
 end

data/lib/lookout/ui/console.rb

@@ -1,32 +1,42 @@
 # -*- coding: utf-8 -*-
 
-class Lookout::UI::Console < Lookout::UI::Silent
-  def initialize(io = $stdout)
-    @io = io
+class Lookout::UI::Console
+  def initialize(results, io = $stdout)
+    @results, @io = results, io
+    @count = 0
+    results.on_new do
+      @count += 1
+    end
+  end
+
+  def start
+    @start = Time.now.to_f
   end
 
-  def summarize(results, time)
-    return if results.succeeded?
-    summarize_total results, time
-    summarize_group results, :errors
-    summarize_group results, :failures
+  def summarize
+    return if @results.succeeded?
+    summarize_total
+    summarize_group :errors
+    summarize_group :failures
     @io.flush
   end
 
 private
 
-  def summarize_total(results, time)
+  def summarize_total
     @io.printf "Ran %d expectations in %.3f seconds: %s\n",
-      results.size,
-      time,
-      [:errors, :failures, :fulfillments].inject([]){ |result, type|
-        next result unless (size = results.send(type).size) > 0
-        result << '%d %s' % [size, type]
-      }.join(', ')
+      @count,
+      Time.now.to_f - @start,
+      [['errors', @results.errors.size],
+       ['failures', @results.failures.size]].tap{ |types|
+        types << ['fulfillments', @count - types.reduce(0){ |sum, pair| sum + pair[1] }]
+      }.select{ |type, size| size > 0 }.
+        map{ |type, size| '%d %s' % [size, type] }.
+        join(', ')
   end
 
-  def summarize_group(results, type)
-    group = results.send(type)
+  def summarize_group(type)
+    group = @results.send(type)
     return if group.empty?
     @io.puts '', type.to_s.upcase, ''
     group.each do |item|

data/lib/lookout/ui/silent.rb

@@ -4,9 +4,6 @@ class Lookout::UI::Silent
   def start
   end
 
-  def report(result)
-  end
-
-  def summarize(results, time)
+  def summarize
   end
 end

data/lib/lookout/version.rb

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

data/test/unit/lookout/expectations.rb

@@ -2,57 +2,73 @@
 
 Expectations do
   expect true do
-    expectations = Lookout::Expectations.new
-    expectations.evaluate(Lookout::UI::Silent.new).succeeded?
+    Lookout::Results::Unsuccessful.new.tap{ |results|
+      Lookout::Expectations.new(results)
+    }.succeeded?
   end
 
   expect false do
-    expectations = Lookout::Expectations.new
-    expectations.expect(1){ 2 }
-    expectations.evaluate(Lookout::UI::Silent.new).succeeded?
+    Lookout::Results::Unsuccessful.new.tap{ |results|
+      Lookout::Expectations.new(results).expect(1){ 2 }
+    }.succeeded?
   end
 
   expect 3 do
-    expectations = Lookout::Expectations.new
-    expectations.expect(1){ 2 }
-    expectations.expect(1){ 2 }
-    expectations.expect(1){ 2 }
-    expectations.count
+    Lookout::Results::Unsuccessful.new.tap{ |results|
+      Lookout::Expectations.new(results).
+        expect(1){ 2 }.
+        expect(1){ 2 }.
+        expect(1){ 2 }
+    }.count
   end
 
   expect 1 do
-    expectations = Lookout::Expectations.new
-    expectations.expect(1){ 2 }
-    expectations.expect(1){ 2 }
-    expectations.each(__LINE__ - 1).count
+    Lookout::Results::Unsuccessful.new.tap{ |results|
+      expectations = Lookout::Expectations.new(results, __LINE__ + 1)
+      expectations.expect(1){ 2 }
+      expectations.expect(1){ 2 }
+    }.count
   end
 
-  expect __LINE__ + 2 do
-    expectations = Lookout::Expectations.new
-    expectations.expect(1){ 2 }
-    expectations.first.line
+  expect 1 do
+    Lookout::Results::Unsuccessful.new.tap{ |results|
+      expectations = Lookout::Expectations.new(results, __LINE__ + 1)
+      expectations.expect(1){ 2 }
+      expectations.expect(1){ 2 }
+      expectations.flush
+    }.count
+  end
+
+  expect 1 do
+    Lookout::Results::Unsuccessful.new.tap{ |results|
+      expectations = Lookout::Expectations.new(results, __LINE__ + 2)
+      expectations.expect(1){ 2 }
+      expectations.expect(1){ 2 }
+      expectations.flush
+    }.count
   end
 
   expect __LINE__ + 2 do
-    expectations = Lookout::Expectations.new
-    expectations.expect(1){ raise }
-    expectations.first.line
+    Lookout::Results::Unsuccessful.new.tap{ |results|
+      Lookout::Expectations.new(results).expect(1){ 2 }
+    }.first.line
   end
 
-  expect __FILE__ do
-    expectations = Lookout::Expectations.new
-    expectations.expect(1){ 2 }
-    expectations.first.file
+  expect __LINE__ + 2 do
+    Lookout::Results::Unsuccessful.new.tap{ |results|
+      Lookout::Expectations.new(results).expect(1){ raise }
+    }.first.line
   end
 
   expect __FILE__ do
-    expectations = Lookout::Expectations.new
-    expectations.expect(1){ raise }
-    expectations.first.file
+    Lookout::Results::Unsuccessful.new.tap{ |results|
+      Lookout::Expectations.new(results).expect(1){ 2 }
+    }.first.file
   end
 
-  expect Object.new do |o|
-    expectations = Lookout::Expectations.new
-    expectations.evaluate(Lookout::UI::Silent.new, o)
+  expect __FILE__ do
+    Lookout::Results::Unsuccessful.new.tap{ |results|
+      Lookout::Expectations.new(results).expect(1){ raise }
+    }.first.file
   end
 end

data/test/unit/lookout/expectations/behavior.rb

@@ -2,34 +2,34 @@
 
 Expectations do
   expect [Lookout::Results::Failures::Behavior] do
-    expectations = Lookout::Expectations.new
-    expectations.expect Object.new.to.receive.dial('2125551212').twice do |phone|
-      phone.dial('2125551212')
-    end
-    expectations.evaluate(Lookout::UI::Silent.new).entries
+    Lookout::Results::Unsuccessful.new.tap{ |results|
+      Lookout::Expectations.new(results).expect Object.new.to.receive.dial('2125551212').twice do |phone|
+        phone.dial('2125551212')
+      end
+    }.entries
   end
 
   expect [Lookout::Results::Failures::Behavior] do
-    expectations = Lookout::Expectations.new
-    expectations.expect Object.new.to.receive.dial('2125551212').twice do |phone|
-      phone.dial('2125551212')
-      phone.dial('2125551212')
-      phone.dial('2125551212')
-    end
-    expectations.evaluate(Lookout::UI::Silent.new).entries
+    Lookout::Results::Unsuccessful.new.tap{ |results|
+      Lookout::Expectations.new(results).expect Object.new.to.receive.dial('2125551212').twice do |phone|
+        phone.dial('2125551212')
+        phone.dial('2125551212')
+        phone.dial('2125551212')
+      end
+    }.entries
   end
 
   expect [Lookout::Results::Failures::Behavior] do
-    expectations = Lookout::Expectations.new
-    expectations.expect(Object.new.to.receive.deal){ }
-    expectations.evaluate(Lookout::UI::Silent.new).entries
+    Lookout::Results::Unsuccessful.new.tap{ |results|
+      Lookout::Expectations.new(results).expect(Object.new.to.receive.deal)
+    }.entries
   end
 
   expect [Lookout::Results::Error] do
-    expectations = Lookout::Expectations.new
-    expectations.expect(Object.new.to.receive.foo) do
-      raise StandardError
-    end
-    expectations.evaluate(Lookout::UI::Silent.new).entries
+    Lookout::Results::Unsuccessful.new.tap{ |results|
+      Lookout::Expectations.new(results).expect(Object.new.to.receive.foo) do
+        raise StandardError
+      end
+    }.entries
   end
 end

data/test/unit/lookout/expectations/state.rb

@@ -2,28 +2,28 @@
 
 Expectations do
   expect [Lookout::Results::Failures::State] do
-    expectations = Lookout::Expectations.new
-    expectations.expect(2){ 3 }
-    expectations.evaluate(Lookout::UI::Silent.new).entries
+    Lookout::Results::Unsuccessful.new.tap{ |results|
+      Lookout::Expectations.new(results).expect(2){ 3 }
+    }.entries
   end
 
   expect [Lookout::Results::Error] do
-    expectations = Lookout::Expectations.new
-    expectations.expect(2){ stub(Object.new).two{ 2 }.twos }
-    expectations.evaluate(Lookout::UI::Silent.new).entries
+    Lookout::Results::Unsuccessful.new.tap{ |results|
+      Lookout::Expectations.new(results).expect(2){ stub(Object.new).two{ 2 }.twos }
+    }.entries
   end
 
   expect [Lookout::Results::Error] do
-    expectations = Lookout::Expectations.new
-    expectations.expect(1) do
-      Object.new.tap{ |o| o.expects.give_me_three(3){ 1 } }.give_me_three(stub).threes
-    end
-    expectations.evaluate(Lookout::UI::Silent.new).entries
+    Lookout::Results::Unsuccessful.new.tap{ |results|
+      Lookout::Expectations.new(results).expect 1 do
+        Object.new.tap{ |o| o.expects.give_me_three(3){ 1 } }.give_me_three(stub).threes
+      end
+    }.entries
   end
 
-  expect [Lookout::Results::Fulfilled] do
-    expectations = Lookout::Expectations.new
-    expectations.expect(NoMethodError){ Object.no_method }
-    expectations.evaluate(Lookout::UI::Silent.new).entries
+  expect [] do
+    Lookout::Results::Unsuccessful.new.tap{ |results|
+      Lookout::Expectations.new(results).expect(NoMethodError){ Object.no_method }
+    }.entries
   end
 end

data/test/unit/lookout/results.rb

@@ -1,30 +1,4 @@
 # -*- coding: utf-8 -*-
 
 Expectations do
-  expect 1 do
-    results = Lookout::Results.new
-    results << Lookout::Results::Fulfilled.new(nil, 0)
-    results.fulfillments.size
-  end
-
-  expect 0 do
-    results = Lookout::Results.new
-    results << Lookout::Results::Fulfilled.new(nil, 0)
-    results.errors.size
-  end
-
-  expect Lookout::Results.new.not.to.have.succeeded? do |results|
-    results << Lookout::Results::Failures::State.new(nil, 0, nil)
-    results << Lookout::Results::Fulfilled.new(nil, 0)
-  end
-
-  expect Lookout::Results.new.not.to.have.succeeded? do |results|
-    results << Lookout::Results::Failures::Behavior.new(nil, 0, nil)
-    results << Lookout::Results::Fulfilled.new(nil, 0)
-  end
-
-  expect Lookout::Results.new.to.have.succeeded? do |results|
-    results << Lookout::Results::Fulfilled.new(nil, 0)
-    results << Lookout::Results::Fulfilled.new(nil, 0)
-  end
 end

data/test/unit/lookout/results/error.rb

@@ -1,7 +1,4 @@
 # -*- coding: utf-8 -*-
 
 Expectations do
-  expect Lookout::Results::Error.new(nil, 0, nil, nil).to.be.error?
-  expect Lookout::Results::Error.new(nil, 0, nil, nil).not.to.be.failure?
-  expect Lookout::Results::Error.new(nil, 0, nil, nil).not.to.be.fulfilled?
 end

data/test/unit/lookout/results/failures/behavior.rb

@@ -1,7 +1,4 @@
 # -*- coding: utf-8 -*-
 
 Expectations do
-  expect Lookout::Results::Failures::Behavior.new(nil, 0, nil).not.to.be.error?
-  expect Lookout::Results::Failures::Behavior.new(nil, 0, nil).to.be.failure?
-  expect Lookout::Results::Failures::Behavior.new(nil, 0, nil).not.to.be.fulfilled?
 end

data/test/unit/lookout/results/failures/state.rb

@@ -1,7 +1,4 @@
 # -*- coding: utf-8 -*-
 
 Expectations do
-  expect Lookout::Results::Failures::State.new(nil, 0, nil).not.to.be.error?
-  expect Lookout::Results::Failures::State.new(nil, 0, nil).to.be.failure?
-  expect Lookout::Results::Failures::State.new(nil, 0, nil).not.to.be.fulfilled?
 end

data/test/unit/lookout/results/fulfilled.rb

@@ -1,7 +1,4 @@
 # -*- coding: utf-8 -*-
 
 Expectations do
-  expect Lookout::Results::Fulfilled.new(nil, 0).not.to.be.error?
-  expect Lookout::Results::Fulfilled.new(nil, 0).not.to.be.failure?
-  expect Lookout::Results::Fulfilled.new(nil, 0).to.be.fulfilled?
 end

data/test/unit/lookout/results/unsuccessful.rb

@@ -0,0 +1,24 @@
+# -*- coding: utf-8 -*-
+
+Expectations do
+  expect 0 do
+    results = Lookout::Results::Unsuccessful.new
+    results << Lookout::Results::Fulfilled.new(nil, 0)
+    results.count
+  end
+
+  expect Lookout::Results::Unsuccessful.new.not.to.have.succeeded? do |results|
+    results << Lookout::Results::Failures::State.new(nil, 0, nil)
+    results << Lookout::Results::Fulfilled.new(nil, 0)
+  end
+
+  expect Lookout::Results::Unsuccessful.new.not.to.have.succeeded? do |results|
+    results << Lookout::Results::Failures::Behavior.new(nil, 0, nil)
+    results << Lookout::Results::Fulfilled.new(nil, 0)
+  end
+
+  expect Lookout::Results::Unsuccessful.new.to.have.succeeded? do |results|
+    results << Lookout::Results::Fulfilled.new(nil, 0)
+    results << Lookout::Results::Fulfilled.new(nil, 0)
+  end
+end

data/test/unit/lookout/stub/methods.rb

@@ -0,0 +1,19 @@
+# -*- coding: utf-8 -*-
+
+Expectations do
+  expect false do
+    Object.new.nil?
+  end
+
+  expect true do
+    Object.new.tap{ |o|
+      Lookout::Stub::Methods.new.define(o, :nil?){ true }
+    }.nil?
+  end
+
+  expect false do
+    Object.new.tap{ |o|
+      Lookout::Stub::Methods.new.define(o, :nil?){ true }.undefine
+    }.nil?
+  end
+end

data/test/unit/lookout/ui/formatters/exception/backtrace.rb

@@ -2,10 +2,9 @@
 
 Expectations do
   expect [%r{test.*backtrace\.rb}] do
-    expectations = Lookout::Expectations.new
-    expectations.expect(1){ raise }
+    results = Lookout::Results::Unsuccessful.new
+    Lookout::Expectations.new(results).expect(1){ raise }
     Lookout::Results::Error::Exception::Backtrace.
-      new(expectations.evaluate(Lookout::UI::Silent.new).first.exception.exception.backtrace,
-          true).backtrace
+      new(results.first.exception.exception.backtrace, true).backtrace
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: lookout
 version: !ruby/object:Gem::Version 
-  hash: 15
+  hash: 13
   prerelease: false
   segments: 
   - 2
   - 1
-  - 2
-  version: 2.1.2
+  - 3
+  version: 2.1.3
 platform: ruby
 authors: 
 - Nikolai Weibull
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-05-24 00:00:00 +02:00
+date: 2011-07-15 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -341,7 +341,6 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
-- lib/lookout/benchmark.rb
 - lib/lookout/diff.rb
 - lib/lookout/diff/algorithms.rb
 - lib/lookout/diff/algorithms/difflib.rb
@@ -364,7 +363,6 @@ files:
 - lib/lookout/expectations/behavior.rb
 - lib/lookout/expectations/state/warning.rb
 - lib/lookout/expectations/state.rb
-- lib/lookout/mock.rb
 - lib/lookout/mock/method.rb
 - lib/lookout/mock/method/arguments.rb
 - lib/lookout/mock/method/arguments/any.rb
@@ -394,14 +392,15 @@ files:
 - lib/lookout/results/failures.rb
 - lib/lookout/results/failures/behavior.rb
 - lib/lookout/results/failures/state.rb
-- lib/lookout/results/error.rb
 - lib/lookout/results/error/exception.rb
 - lib/lookout/results/error/exception/backtrace.rb
-- lib/lookout/results/failure.rb
+- lib/lookout/results/unsuccessful.rb
+- lib/lookout/results/error.rb
 - lib/lookout/results/fulfilled.rb
+- lib/lookout/results/instance.rb
+- lib/lookout/results/failure.rb
 - lib/lookout/runners.rb
 - lib/lookout/runners/console.rb
-- lib/lookout/stub.rb
 - lib/lookout/stub/method.rb
 - lib/lookout/stub/methods.rb
 - lib/lookout/stub/object.rb
@@ -410,15 +409,27 @@ files:
 - lib/lookout/ui/console.rb
 - lib/lookout/xml.rb
 - lib/lookout/aphonic.rb
-- lib/lookout/result.rb
-- lib/lookout/results.rb
 - lib/lookout/recorder.rb
 - lib/lookout/recorders.rb
-- lib/lookout/expectations.rb
+- lib/lookout/version.rb
 - lib/lookout/expectation.rb
-- lib/lookout/warning.rb
+- lib/lookout/expectations.rb
+- lib/lookout/equalities/object.rb
+- lib/lookout/equalities/include.rb
+- lib/lookout/equalities/boolean.rb
+- lib/lookout/equalities/string.rb
+- lib/lookout/equalities/array.rb
+- lib/lookout/equalities/hash.rb
+- lib/lookout/equalities/standarderror.rb
+- lib/lookout/equalities/output.rb
+- lib/lookout/equalities/warning.rb
 - lib/lookout/equality.rb
-- lib/lookout/version.rb
+- lib/lookout/warning.rb
+- lib/lookout/mock.rb
+- lib/lookout/stub.rb
+- lib/lookout/results.rb
+- lib/lookout/result.rb
+- lib/lookout/equalities.rb
 - lib/lookout.rb
 - test/unit/lookout.rb
 - test/unit/lookout/diff.rb
@@ -438,25 +449,25 @@ files:
 - test/unit/lookout/diff/range.rb
 - test/unit/lookout/equality.rb
 - test/unit/lookout/expectation.rb
-- test/unit/lookout/expectations.rb
-- test/unit/lookout/expectations/behavior.rb
 - test/unit/lookout/expectations/state.rb
-- test/unit/lookout/mock.rb
+- test/unit/lookout/expectations/behavior.rb
 - test/unit/lookout/mock/method.rb
 - test/unit/lookout/mock/method/arguments.rb
 - test/unit/lookout/mock/method/arguments/any.rb
 - test/unit/lookout/recorder.rb
-- test/unit/lookout/results.rb
-- test/unit/lookout/results/error.rb
 - test/unit/lookout/results/failures/behavior.rb
 - test/unit/lookout/results/failures/state.rb
+- test/unit/lookout/results/unsuccessful.rb
+- test/unit/lookout/results/error.rb
 - test/unit/lookout/results/fulfilled.rb
 - test/unit/lookout/runners/console.rb
-- test/unit/lookout/stub.rb
 - test/unit/lookout/stub/method.rb
+- test/unit/lookout/stub/methods.rb
 - test/unit/lookout/ui/formatters/exception.rb
 - test/unit/lookout/ui/formatters/exception/backtrace.rb
 - test/unit/lookout/xml.rb
+- test/unit/lookout/results.rb
+- test/unit/lookout/expectations.rb
 - test/unit/examples.rb
 - README
 - Rakefile

data/lib/lookout/benchmark.rb

@@ -1,11 +0,0 @@
-# -*- coding: utf-8 -*-
-
-module Lookout::Benchmark
-  class << self
-    def time
-      start = Time.now.to_f
-      yield
-      Time.now.to_f - start
-    end
-  end
-end

data/test/unit/lookout/mock.rb

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

data/test/unit/lookout/stub.rb

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