gimme 0.1.6

data/.bundle/config

@@ -0,0 +1,2 @@
+--- 
+BUNDLE_DISABLE_SHARED_GEMS: "1"

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/Gemfile

@@ -0,0 +1,11 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.5.2"
+  gem "rspec", ">= 1.3.1"
+  gem "cucumber", ">= 0.10.0"
+end

data/Gemfile.lock

@@ -0,0 +1,38 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    builder (3.0.0)
+    cucumber (0.10.0)
+      builder (>= 2.1.2)
+      diff-lcs (~> 1.1.2)
+      gherkin (~> 2.3.2)
+      json (~> 1.4.6)
+      term-ansicolor (~> 1.0.5)
+    diff-lcs (1.1.2)
+    gherkin (2.3.3)
+      json (~> 1.4.6)
+    git (1.2.5)
+    jeweler (1.5.2)
+      bundler (~> 1.0.0)
+      git (>= 1.2.5)
+      rake
+    json (1.4.6)
+    rake (0.8.7)
+    rspec (2.4.0)
+      rspec-core (~> 2.4.0)
+      rspec-expectations (~> 2.4.0)
+      rspec-mocks (~> 2.4.0)
+    rspec-core (2.4.0)
+    rspec-expectations (2.4.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.4.0)
+    term-ansicolor (1.0.5)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.0.0)
+  cucumber (>= 0.10.0)
+  jeweler (~> 1.5.2)
+  rspec (>= 1.3.1)

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Justin Searls
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.markdown

@@ -0,0 +1,219 @@
+# Gimme
+
+Gimme is a very lightweight test double library for ruby. Written to be an opinionated (but not noisy) means to facilitate test-driving by enabling the author to specifying only what matters. But if could only feed Google one thing at this point, it would be: "[Mockito](http://mockito.org/) for Ruby"
+
+You can read the (possibly stale) documentation below or the (fresh) [gimme Cucumber features on Relish](http://relishapp.com/searls/gimme)
+
+## Basics (or "What does it Gimme?" ... har.)
+
+Gimme was originally named (well, for the first five hours of its life) "[Tabula Rasa](http://en.wikipedia.org/wiki/Tabula_rasa)," to very clearly indicate that it generates blank slate test doubles that lack any initial coupling with the concepts associated with specific [test double](http://xunitpatterns.com/Test%20Double.html) subtypes like mocks/stubs/fakes/spies/proxies. But in the end, "gimme" was easier to type than "tabula rasa", and I generally wanted to avoid test pattern lingo from leaking into the context and language of everybody's tests (hence no method named "stub"). 
+
+Gimme doubles are most accurately identified as [test spies](http://xunitpatterns.com/Test%20Spy.html) in [this table discriminating the types](http://xunitpatterns.com/Mocks,%20Fakes,%20Stubs%20and%20Dummies.html) over at Gerard Meszaros' helpful xUnit patterns repository.
+
+Gimme aims to enable you to write low-friction, low-specification tests that feel a little more like [Mockito](http://mockito.org/) than existing ruby test double libraries. Gimme should do whatever it can to help you isolate your SUT from its dependencies and then get out of your way. And if gimme can provide some fast-feedback about potential problems, it should try to do that too.
+
+The few things it gives you:
+
+* Many typical test double library features, like: stubbing & verifying methods, argument matchers for determining what gets stubbed and what to verify, and argument captors for inspecting stuff your [SUT](http://xunitpatterns.com/SUT.html) passes its dependencies
+* Natural arrange-act-assert flow — meaning that you can call `verify` after you've interacted with your system under test.
+* No stringy/symbolic representations of methods — similar to [rr](https://github.com/btakita/rr), gimme uses the blank slate pattern and `method_missing` to allow for minimally terse stubs and verifications
+* Sometimes you know the class of a dependency of your SUT; when you do, gimme can try to help out by raising a NoMethodError when you attempt to stub or verify a method that the class doesn't respond to.
+* Gimme won't punish you for not setting up an expectation for every interaction your SUT has with your test double, leaving you to verify exactly what matters to you in the context of what you're building; sometimes specifying the behavior of your SUT on a collaborator is significant, and sometimes it isn't.
+
+
+## The Disclaimer
+
+Gimme is still in early development and a little light on features / hardening. While gimme should be enough to get started writing tests/specs, you'll likely run into edge cases that haven't been handled yet. If you're willing to try out gimme on your next toy project and either submit issues or pull requests when you run into issues, hopefully we can work together to make gimme a first-class test double framework in the Ruby community.
+
+## Getting started
+
+### Setting up
+First, install the gem:
+
+    gem install gimme
+
+Next, wherever you set up your test environment, require gimme:
+
+    require 'gimme'
+
+### Creating a double
+Once you're in your test or spec, to create a test double.
+
+If you know what what class your SUT will be depending on, you can specify it:
+
+    double = gimme(Object)
+    
+Or you could just create a generic double can stub/verify any method you need:
+
+    double = gimme()
+     
+### Stubbing     
+     
+Once you have your double, you can stub methods:
+
+    give(double).to_s { 'Pants' }
+    double.to_s                         #=> 'Pants'
+    
+    give(double).equal?(:ninja) { true }
+    give(double).equal?(:fruit) { false }    
+    double.equal?(:ninja)               #=> true
+    
+You can also stub your double to raise an exception (or really, do anything in the passed block):
+
+    dog = gimme(Dog)
+    give(dog).holler_at(:mail_man) { raise LeashLawError }
+    
+    dog.holler_at(:mail_man) # raises LeashLawError
+
+### Verifying    
+    
+You can also verify interactions with your double    
+
+    double.equal?(:fruit)
+    
+    verify(double).equal?(:fruit)       # passes verification (read: does nothing)
+    verify(double).equal?(:what_the)    # fails verification (raises a Gimme::VerifyFailedError)
+
+You can also specify how many times a specific invocation should have occurred (defaults to 1):
+
+    double.equal?(:fruit)
+    double.equal?(:fruit)
+    
+    verify(double,2).equal?(:fruit)
+    
+### Using Argument Matchers
+
+Gimme includes several argument matchers which can be used to control which invocations will satisfy a particular stubbing or verification.
+
+**anything**
+
+Replacing an argument with `anything` will instantiate a `Gimme::Matchers::Anything` matcher, which always returns true, regardless of what gets passed in.
+
+    give(dog).walk_to(anything,5) { 'Park' }
+    
+    walk_to(3,5)          #=> 'Park'
+    walk_to('pants',5)    #=> 'Park'
+    walk_to(nil,5)        #=> 'Park'        
+    walk_to(3,5.1)        #=> nil
+        
+Matchers can be used when both stubbing and verifying a method. To verify on anything, you could:
+
+    dog.holler_at(true)
+    
+    verify(dog).holler_at(anything) #=> passes verification    
+    
+Other matchers:    
+    
+**is_a(class)** — matches any arguments that are `kind_of?` the provided class
+**any(class)** — same as `is_a`, but also matches nil
+**boolean** — matches true or false arguments
+**numeric** — matches numeric arguments 
+
+See the [cucumber feature for examples using these matchers](http://relishapp.com/searls/gimme/stubbing-with-matchers)
+
+#### Writing Custom Argument Matchers
+
+It's pretty easy to roll your own argument matchers as well. All you really need to do is pass as an argument to a method stubbed by `give` or verified by `verify` an object
+that can respond to `matches?(arg)`. Maybe something like this would work (even though it'd be of questionable utility):
+
+    class Nothing
+      def matches?(arg)
+        false
+      end
+    end
+
+    give(dog).introduce_to(Nothing.new) { :meow }     #b/c Nothing.matches? always returns false, :meow will never returned by the double.
+    
+
+### Using Argument Captors
+
+An instance of an argument `Captor`, when paired with the `capture` matcher, is a valuable way for your test to get at the values that your SUT passes to its collaborators. Often, classes are responsible for building objects to be ingested by their collaborators but for which normal state verification would either be difficult or nonsensical. Argument captors should only be necessary sparingly for most types of applications, but they're a handy tool to have in the toolbox.
+
+In cases like these, a captor can be used to "capture" the real argument value that the system under test passes its collaborator. This pseudocode provides an example:
+
+    #arrange
+    searches_system = gimme(SearchesSystem)
+    sut = QueryExecutor.new(searches_sytem)
+    query_captor = Captor.new
+
+    #act
+    sut.submit_query_for_string("find dogs")
+    
+    #assert
+    verify(searches_system).execute(capture(query_captor))
+    query_captor.value.table_name.should == "Dogs"
+
+    
+### Suppressing NoMethodError
+
+You may be reading this section because you got this message:
+
+    The Test Double of <Class Name> may not know how to respond to the '<Method Name>' method. 
+      If you're confident that a real Kernel will know how to respond to '<Method Name>', then you can
+      invoke give! or verify! to suppress this error.
+    
+Whenever you stub or verify a method against a test double on a class, gimme will first verify that the method can be found on the class being
+doubled. Since the vast majority of methods can be verified in this way, this default behavior is designed to provide fast failure.
+This can be really handy, whether the cause is as simple as a transcription error of a method name from irb or as convoluted as an incorrect version of a dependency that lacks the method you expected. 
+
+However, because classes can be reopened and edited at runtime, often you'll outsmart gimme by knowing that a particular
+method *will* be available on the class being doubled, even though it isn't *right now*.
+
+For these situations, you could either (1) declare your double without a class argument (e.g. `gimme()` instead of `gimme(Dog)`), or (2) use `give!` and `verify!` to suppress the check that triggers the NoMethodError from being raised.
+
+Here's an example where our Dog is again being doubled to facilitate some test, and even though the Dog class lacks a public `meow()` method, we happen to know that at runtime, the newest version of the `bananimals` gem will reopen Dog and add `meow()` to it.
+
+    dog = gimme(Dog)
+    give!(dog).meow { :purr }
+    
+    dog.meow              #=> :purr
+    
+We cam accomplish the same thing using `verify!`:
+
+    dog = gimme(Dog)
+    
+    dog.meow
+    
+    verify!(dog).meow     #=> verification passes, even though gimme can't see the meow method.
+
+### gimme_next
+
+To my knowledge, there isn't an established pattern or name for this next feature. Sometimes you may want your SUT to instantiate its own dependency. However, if you also want to achieve isolation from the implementation details of that dependency, you can use `gimme_next`.
+
+Take this example method from the RSpec book:
+
+    def guess(guess)
+      marker = Marker.new(@secret,guess)  
+      @output.puts '+'*marker.exact_match_count + '-'*marker.number_match_count
+    end
+
+This can be tested with gimme in isolation (meaning that a real Marker object is never instantiated or invoked) like so:
+
+    describe '#guess' do
+      let(:marker) { gimme_next(Marker) }
+      before do
+        give(marker).exact_match_count { 4 }
+        give(marker).number_match_count { 0 }                 
+
+        game.guess('1234')
+      end
+      
+      it 'instantiates a marker with the secret and guess' do
+        verify!(marker).initialize('1234','1234')
+      end
+      
+      it 'outputs the exact matches followed by the number matches' do
+        verify(output).puts('++++')
+      end      
+    end
+
+As you can see above, `gimme_next(Marker)` will create a double just like `gimme()` would have, but it will also temporarily redefine the passed class's `new` method such that the next instantiation of that class (presumably by the SUT) will return the same double.* 
+
+This way we can clearly specify the SUT's interaction with the Marker class while maintaining its isolation.
+
+*Subsequent instantiations of the passed class will continue to return normal instances.
+
+## About
+
+### Maintainers
+* [Justin Searls](http://about.emw/searls), [Pillar Technology](http://pillartechnology.com)

data/README.rdoc

@@ -0,0 +1,22 @@
+= gimme
+
+gimme is a lightweight test double library for ruby
+
+Project site: http://github.com/searls/gimme
+Gimme features: http://relishapp.com/searls/gimme 
+
+== Contributing to gimme
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
+* Fork the project
+* Start a feature/bugfix branch
+* Commit and push until you are happy with your contribution
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+== Copyright
+
+Copyright (c) 2010 Justin Searls. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,45 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "gimme"
+  gem.homepage = "http://github.com/searls/gimme"
+  gem.license = "MIT"
+  gem.summary = %Q{gimme — a low-specification test double library for Ruby}
+  gem.description = %Q{gimme attempts to bring to Ruby a test double workflow akin to Mockito in Java. Major distinctions include preserving arrange-act-assert in tests, fast feedback for methods the double's real counterpart may not know how to respond to, no string/symbolic representations of methods, argument captors, and strong opinions (weakly held). }
+  gem.email = "searls@gmail.com"
+  gem.authors = ["Justin Searls"]
+  # Include your dependencies below. Runtime dependencies are required when using your gem,
+  # and development dependencies are only needed for development (ie running rake tasks, tests, etc)
+  #  gem.add_runtime_dependency 'jabber4r', '> 0.1'
+  gem.add_development_dependency "rspec", ">= 1.3.1"
+  gem.add_development_dependency "cucumber", ">= 0.10.0"
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'cucumber/rake/task'
+Cucumber::Rake::Task.new do |t|
+  t.cucumber_opts = %w{--format pretty}
+end
+
+task :default => :cucumber
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "gimme #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.6

data/features/argument_captors.feature

@@ -0,0 +1,12 @@
+Feature: Capturing Arguments
+
+  As a test author
+  I want to capture the value of an argument passed to my test double
+  So that I can assert things about arguments my system under test passes to its collaborators
+  
+  Scenario: capturing an argument
+    Given a new Dog test double
+    And a new argument captor
+    When I invoke holler_at(:panda)
+    Then I can verify holler_at(capture(@captor)) has been invoked 1 time
+    And the captor's value is :panda

data/features/gimme_next.feature

@@ -0,0 +1,13 @@
+Feature: Gimme Next
+
+  As a test author
+  I want a test double to stand-in for the next new'ing of a given class
+  so that I can isolate my SUT and stub & verify behavior of collaborators instantiated by the SUT
+
+  Scenario:
+    Given I create a double via gimme_next(Turtle)
+    When my SUT tries creating a real Turtle.new(:shell)
+    And I invoke swim
+    Then both the double and real object reference the same object
+    And I can verify! initialize(:shell) has been invoked 1 time
+    And I can verify swim has been invoked 1 time

data/features/step_definitions/gimme_steps.rb

@@ -0,0 +1,118 @@
+include Gimme
+METHOD_PATTERN = /([^\(]*)(\(.*\))?/
+
+# Creating
+
+Given /^a new (.*)\s?test double$/ do | type |
+  @double = type.empty? ? gimme : gimme(eval(type))
+end
+
+Given /^I create a double via gimme_next\((.*)\)$/ do |klass|
+  @double = gimme_next(eval(klass))
+end
+
+
+# Stubbing
+
+When /^I stub #{METHOD_PATTERN} to return (.*)$/ do |method,args,result|
+  send_and_trap_error(NoMethodError,give(@double),method,args,result)
+end
+
+When /^I stub! #{METHOD_PATTERN} to return (.*)$/ do |method,args,result|
+  send_and_trap_error(NoMethodError,give!(@double),method,args,result)
+end
+
+When /^I stub #{METHOD_PATTERN} to raise (.*)$/ do |method,args,error_type|
+  sendish(give(@double),method,args,"raise #{error_type}")
+end
+
+# Invoking
+
+Then /^invoking #{METHOD_PATTERN} returns (.*)$/ do |method,args,result|
+  sendish(@double,method,args).should == eval(result)
+end
+
+When /^I invoke #{METHOD_PATTERN}$/ do |method,args|
+  sendish(@double,method,args)
+end
+
+Given /^I do not invoke #{METHOD_PATTERN}$/ do |method,args|
+end
+
+Then /^invoking (.*) raises a (.*)$/ do |method,error_type|
+  expect_error(eval(error_type)) { sendish(@double,method) }
+end
+
+# Verifying
+
+Then /^verifying #{METHOD_PATTERN} raises a (.*)$/ do |method,args,error_type|
+  expect_error(eval(error_type)) { verify(@double).send(method.to_sym) }
+end
+
+Then /^I can verify #{METHOD_PATTERN} has been invoked$/ do |method,args|
+  sendish(verify(@double),method,args)
+end
+
+Then /^I can verify #{METHOD_PATTERN} has been invoked (\d+) times?$/ do |method,args,times|
+  sendish(verify(@double,times.to_i),method,args)
+end
+
+Then /^I can verify! #{METHOD_PATTERN} has been invoked (\d+) times?$/ do |method,args,times|
+  sendish(verify!(@double,times.to_i),method,args)
+end
+
+#Captors
+
+Given /^a new argument captor$/ do
+  @captor = Captor.new
+end
+
+Then /^the captor's value is (.*)$/ do |value|
+  @captor.value.should == eval(value)
+end
+
+# Exceptions
+Then /^a (.*) is raised$/ do |error_type|
+  @error.should be_a_kind_of eval(error_type)
+  @error = nil
+end
+
+Then /^no error is raised$/ do
+  @error.should be nil
+end
+
+# Gimme Next
+
+When /^my SUT tries creating a real (.*)$/ do |instantiation|
+  @real = eval(instantiation)
+end
+
+Then /^both the double and real object reference the same object$/ do
+  @real.__id__ == @double.__id__
+end
+
+# private
+
+def send_and_trap_error(error_type,target,method,args=nil,result=nil)
+  begin 
+    sendish(target,method,args,result)
+  rescue error_type => e
+    @error = e
+  end
+end
+
+def sendish(target,method,args=nil,result=nil)
+    s = "target.#{method}#{args}"
+    s += "{ #{result} }" if result
+    eval(s)
+end
+
+def expect_error(type,&block)
+  rescued = false
+  begin
+    yield
+  rescue type
+    rescued = true
+  end
+  rescued.should be true
+end

data/features/stub_basic.feature

@@ -0,0 +1,34 @@
+Feature: basic stubbing
+
+  As a test author
+  I want to create a test double
+  so that I can stub method returns
+
+  Scenario Outline: stubbing
+    Given a new Dog test double
+    When I stub <method> to return <gives>
+    Then invoking <invocation> returns <returns>
+  
+  Scenarios: no-arg methods
+    | method    | gives       | invocation | returns     |
+    | to_s      | 'something' | to_s       | 'something' |
+    | purebred? | true        | purebred?  | true        |
+    
+  Scenarios: one-arg methods
+    | method          | gives | invocation        | returns |
+    | holler_at(true) | :ruff | holler_at(true)   | :ruff   |
+    | holler_at(true) | :ruff | holler_at(false)  | nil     |
+    | holler_at(true) | :ruff | holler_at(:panda) | nil     |
+    | holler_at(true) | :ruff | holler_at(nil)    | nil     |
+    
+  Scenarios: two-arg methods
+    | method               | gives | invocation           | returns |
+    | walk_to(1,2)         | :park | walk_to(1,2)         | :park   |
+    | walk_to(1,2)         | :park | walk_to(0.9,2)       | nil     |
+    | walk_to(1,2)         | :park | walk_to(1,2.1)       | nil     |
+    | walk_to([1,5],[2,7]) | :park | walk_to([1],[5,2,7]) | nil     |
+    
+  Scenario:
+    Given a new Dog test double
+    When I stub purebred? to raise StandardError
+    Then invoking purebred? raises a StandardError  

data/features/stub_matchers.feature

@@ -0,0 +1,60 @@
+Feature: stubbing with matchers
+
+  As a test author
+  I want to be able to stub an invocation based on matchers' evaluations of the arguments
+  so that I don't need to redundantly stub things I don't care about
+
+  Scenario Outline: stubbing
+    Given a new Dog test double
+    When I stub <method> to return <gives>
+    Then invoking <invocation> returns <returns>
+  
+  Scenarios: the anything matcher with a one-argument method
+    | method                 | gives        | invocation            | returns      |
+    | introduce_to(anything) | 'Why Hello!' | introduce_to(Cat.new) | 'Why Hello!' |
+    | introduce_to(anything) | 'Why Hello!' | introduce_to(Dog.new) | 'Why Hello!' |
+    | introduce_to(anything) | 'Why Hello!' | introduce_to(nil)     | 'Why Hello!' |
+  
+  Scenarios: the anything matcher with a two-argument method
+    | method                     | gives  | invocation         | returns |
+    | walk_to(anything,5)        | 'Park' | walk_to(5,5)       | 'Park'  |
+    | walk_to(anything,5)        | 'Park' | walk_to('pants',5) | 'Park'  |
+    | walk_to(anything,5)        | 'Park' | walk_to(nil,5)     | 'Park'  |
+    | walk_to(anything,5)        | 'Park' | walk_to(3,5.1)     | nil     |
+    | walk_to(3.123,anything)    | 'Park' | walk_to(3.123,nil) | 'Park'  |
+    | walk_to(anything,anything) | 'Park' | walk_to(3,5.1)     | 'Park'  |
+    
+  Scenarios: the anything matcher with a variable-argument method (argument size must match; but I don't know if I like some of these…)
+    | method                       | gives | invocation              | returns |
+    | eat(anything,:fish,anything) | :yum  | eat(:cat,:fish,:mouse)  | :yum    |
+    | eat(anything,:fish,anything) | :yum  | eat(:cat,:pants,:mouse) | nil     |
+    | eat(anything)                | :yum  | eat(:cat,:pants)        | nil     |
+    | eat(:cat,anything)           | :yum  | eat(:cat)               | nil     |
+    | eat(:cat,anything)           | :yum  | eat(:cat,nil)           | :yum    |
+
+  Scenarios: the is_a matcher
+  | method                     | gives  | invocation               | returns |
+  | introduce_to(is_a(Animal)) | :howdy | introduce_to(Animal.new) | :howdy  |
+  | introduce_to(is_a(Animal)) | :howdy | introduce_to(Cat.new)    | :howdy  |
+  | introduce_to(is_a(Animal)) | :howdy | introduce_to(Object.new) | nil     |
+  | introduce_to(is_a(Animal)) | :howdy | introduce_to(nil)        | nil     |
+
+  Scenarios: the any matcher (like is_a but also matches nil)
+  | method                    | gives  | invocation               | returns |
+  | introduce_to(any(Animal)) | :howdy | introduce_to(Animal.new) | :howdy  |
+  | introduce_to(any(Animal)) | :howdy | introduce_to(Cat.new)    | :howdy  |
+  | introduce_to(any(Animal)) | :howdy | introduce_to(Object.new) | nil     |
+  | introduce_to(any(Animal)) | :howdy | introduce_to(nil)        | :howdy  |
+
+  Scenarios: the numeric matcher
+  | method                   | gives    | invocation              | returns  |
+  | walk_to(numeric,numeric) | :hydrant | walk_to(1.498,8)        | :hydrant |
+  | walk_to(numeric,numeric) | :hydrant | walk_to(1.498,'string') | nil      |
+  | walk_to(numeric,numeric) | :hydrant | walk_to(1.498,nil)      | nil      |
+
+  Scenarios: the boolean matcher
+  | method             | gives | invocation        | returns |
+  | holler_at(boolean) | :ruff | holler_at(true)   | :ruff   |
+  | holler_at(boolean) | :ruff | holler_at(false)  | :ruff   |
+  | holler_at(boolean) | :ruff | holler_at('woof') | nil     |
+  | holler_at(boolean) | :ruff | holler_at(nil)    | nil     |

data/features/stub_sensible_defaults.feature

@@ -0,0 +1,10 @@
+Feature: Default returns
+
+  As a test author
+  I want my test double to have some sensible defaults
+  so that I do not find myself writing redundant/obvious stub code    
+  
+  Scenario: query? methods' default stubbing is false
+    Given a new Dog test double
+    Then invoking purebred? returns false
+     And invoking walk_to(1,1) returns nil