lookout 2.2.0 → 2.3.0

data/README

@@ -259,7 +259,14 @@
           s.a + s.b
         end
 
-      and we can stub out a specific method on an object:
+      Blocks are also allowed:
+
+        expect 3 do
+          s = stub(:a => proc{ |a, b| a + b })
+          s.a(1, 2)
+        end
+
+      If need be, we can stub out a specific method on an object:
 
         expect 'def' do
           a = 'abc'

data/lib/lookout/expectation.rb

@@ -28,7 +28,11 @@ module Lookout::Expectation
     when Hash
       Lookout::Stub::Object.new.tap{ |stub|
         args[0].each do |name, value|
-          @stubs.define(stub, name){ value }
+          if value.respond_to? :to_proc
+            @stubs.define(stub, name, &value)
+          else
+            @stubs.define(stub, name){ value }
+          end
         end
       }
     else

data/lib/lookout/version.rb

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

data/test/unit/examples.rb

@@ -146,6 +146,12 @@ Expectations do
     s.a + s.b
   end
 
+  # Use a stub that’s set up with a set of procs as methods.
+  expect 3 do
+    s = stub(:a => proc{ |a, b| a + b })
+    s.a(1, 2)
+  end
+
   # Use a contrete mock to verify that a method is called.
   expect Object.to.receive.deal do
     Object.deal

data/test/unit/lookout/expectation.rb

@@ -36,4 +36,12 @@ Expectations do
   expect Lookout::Results::Fulfilled do
     Lookout::Expectation.on([1, 2, 3].to.include?(1), nil, nil).evaluate
   end
+
+  expect Lookout::Results::Fulfilled do
+    Lookout::Expectation.on(1, nil, nil){ stub(:a => 1).a }.evaluate
+  end
+
+  expect Lookout::Results::Fulfilled do
+    Lookout::Expectation.on(1, nil, nil){ stub(:a => proc{ 1 }).a }.evaluate
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lookout
 version: !ruby/object:Gem::Version
-  version: 2.2.0
+  version: 2.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-10-14 00:00:00.000000000 Z
+date: 2011-10-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: yard
-  requirement: &14599272 !ruby/object:Gem::Requirement
+  requirement: &14532168 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,7 +21,7 @@ dependencies:
         version: 0.6.0
   type: :development
   prerelease: false
-  version_requirements: *14599272
+  version_requirements: *14532168
 description: ! "                                Lookout\n\n  Lookout is a lightweight
   unit testing framework. Tests (expectations) can be\n  written as follows\n\n    expect
   2 do\n      1 + 1\n    end\n\n    expect NoMethodError do\n      Object.invalid_method_call\n
@@ -116,21 +116,23 @@ description: ! "                                Lookout\n\n  Lookout is a lightw
   stub.to.receive.dial('2125551212').twice do |phone|\n          phone.dial('2125551212')\n
   \         phone.hangup\n          phone.dial('2125551212')\n        end\n\n      We
   can also use stubs without any expectations on them:\n\n        expect 3 do\n          s
-  = stub(:a => 1, :b => 2)\n          s.a + s.b\n        end\n\n      and we can stub
-  out a specific method on an object:\n\n        expect 'def' do\n          a = 'abc'\n
-  \         stub(a).to_str{ 'def' }\n          a.to_str\n        end\n\n      You
-  don’t have to use a mock object to verify that a method is called:\n\n        expect
-  Object.to.receive.deal do\n          Object.deal\n        end\n\n      As you have
-  figured out by now, the expected method call is set up by\n      calling ‹#receive›
-  after ‹#to›.  ‹#Receive› is followed by a call to the\n      method to expect with
-  any expected arguments.  The body of the mocked\n      method can be given as the
-  block to the method.  Finally, an expected\n      invocation count may follow the
-  method.  Let’s look at this formal\n      specification in more detail.\n\n      The
-  expected method arguments may be given in a variety of ways.  Let’s\n      introduce
-  them by giving some examples:\n\n        expect mock.to.receive.a do |m|\n          …\n
-  \       end\n\n      Here, the method ‹#a› must be called with any number of arguments.
-  \ It\n      may be called any number of times, but it must be called at least once.\n\n
-  \     If a method must receive exactly one argument, you can use ‹arg›:\n\n        expect
+  = stub(:a => 1, :b => 2)\n          s.a + s.b\n        end\n\n      Blocks are also
+  allowed:\n\n        expect 3 do\n          s = stub(:a => proc{ |a, b| a + b })\n
+  \         s.a(1, 2)\n        end\n\n      If need be, we can stub out a specific
+  method on an object:\n\n        expect 'def' do\n          a = 'abc'\n          stub(a).to_str{
+  'def' }\n          a.to_str\n        end\n\n      You don’t have to use a mock object
+  to verify that a method is called:\n\n        expect Object.to.receive.deal do\n
+  \         Object.deal\n        end\n\n      As you have figured out by now, the
+  expected method call is set up by\n      calling ‹#receive› after ‹#to›.  ‹#Receive›
+  is followed by a call to the\n      method to expect with any expected arguments.
+  \ The body of the mocked\n      method can be given as the block to the method.
+  \ Finally, an expected\n      invocation count may follow the method.  Let’s look
+  at this formal\n      specification in more detail.\n\n      The expected method
+  arguments may be given in a variety of ways.  Let’s\n      introduce them by giving
+  some examples:\n\n        expect mock.to.receive.a do |m|\n          …\n        end\n\n
+  \     Here, the method ‹#a› must be called with any number of arguments.  It\n      may
+  be called any number of times, but it must be called at least once.\n\n      If
+  a method must receive exactly one argument, you can use ‹arg›:\n\n        expect
   mock.to.receive.a(arg) do |m|\n          …\n        end\n\n      If a method must
   receive a specific argument, you can use that argument:\n\n        expect mock.to.receive.a(1..2)
   do |m|\n          …\n        end\n\n      The same matching rules apply for arguments