rspec 0.7.5.1 → 0.8.0

data/examples/custom_expectation_matchers.rb

@@ -0,0 +1,53 @@
+module AnimalSpecHelper
+  class Eat
+    def initialize(food)
+      @food = food
+    end
+    
+    def matches?(animal)
+      @animal = animal
+      @animal.eats?(@food)
+    end
+    
+    def failure_message
+      "expected #{@animal} to eat #{@food}, but it does not"
+    end
+    
+    def negative_failure_message
+      "expected #{@animal} not to eat #{@food}, but it does"
+    end
+  end
+    
+  def eat(food)
+    Eat.new(food)
+  end
+end
+
+module Animals
+  class Animal
+    def eats?(food)
+      return foods_i_eat.include?(food)
+    end
+  end
+  
+  class Mouse < Animal
+    def foods_i_eat
+      [:cheese]
+    end
+  end
+end
+
+context "A mouse" do
+  include AnimalSpecHelper
+  setup do
+    @mouse = Animals::Mouse.new
+  end
+  
+  specify "should eat cheese" do
+    @mouse.should eat(:cheese)
+  end
+  
+  specify "should not eat cat" do
+    @mouse.should_not eat(:cat)
+  end
+end

data/examples/dynamic_spec.rb

@@ -0,0 +1,9 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+context "The month march" do
+  (1..10).each do |n|
+    specify "The root of #{n} square should be #{n}" do
+      Math.sqrt(n*n).should == n
+    end
+  end
+end

data/examples/io_processor_spec.rb

@@ -10,12 +10,12 @@ context "An IoProcessor" do
   specify "should raise nothing when the file is exactly 32 bytes" do
     lambda {
       @processor.process(StringIO.new("z"*32))
-    }.should_not_raise
+    }.should_not raise_error
   end
 
   specify "should raise an exception when the file length is less than 32 bytes" do
     lambda {
       @processor.process(StringIO.new("z"*31))
-    }.should_raise(DataTooShort)
+    }.should raise_error(DataTooShort)
   end
 end

data/examples/mocking_example.rb

@@ -13,15 +13,15 @@ context "a mock" do
     mock = mock("mock")
     mock.should_receive(:msg).with(:arg1).and_return(:val1)
     mock.should_receive(:msg).with(:arg2).and_return(:val2)
-    mock.msg(:arg1).should_eql(:val1)
-    mock.msg(:arg2).should_eql(:val2)
+    mock.msg(:arg1).should eql(:val1)
+    mock.msg(:arg2).should eql(:val2)
   end
 
   specify "should be able to mock the same message twice w/ different args in reverse order" do
     mock = mock("mock")
     mock.should_receive(:msg).with(:arg1).and_return(:val1)
     mock.should_receive(:msg).with(:arg2).and_return(:val2)
-    mock.msg(:arg2).should_eql(:val2)
-    mock.msg(:arg1).should_eql(:val1)
+    mock.msg(:arg2).should eql(:val2)
+    mock.msg(:arg1).should eql(:val1)
   end
 end

data/examples/partial_mock_example.rb

@@ -10,11 +10,11 @@ context "A partial mock" do
 
   specify "should work at the class level" do
     MockableClass.should_receive(:find).with(1).and_return {:stub_return}
-    MockableClass.find(1).should_equal :stub_return
+    MockableClass.find(1).should equal(:stub_return)
   end
 
   specify "should revert to the original after each spec" do
-    MockableClass.find(1).should_equal :original_return
+    MockableClass.find(1).should equal(:original_return)
   end
 
   specify "can be mocked w/ ordering" do

data/examples/predicate_example.rb

@@ -17,11 +17,11 @@ context "BDD framework" do
   end
 
   specify "should be adopted quickly" do
-    @bdd_framework.should_be_adopted_quickly
+    @bdd_framework.should be_adopted_quickly
   end
   
   specify "should be intuitive" do
-    @bdd_framework.should_be_intuitive
+    @bdd_framework.should be_intuitive
   end
 
 end

data/examples/stack_spec.rb

@@ -1,31 +1,31 @@
 require File.dirname(__FILE__) + '/spec_helper'
 require File.dirname(__FILE__) + "/stack"
 
-context "A stack which is neither empty nor full" do
+context "A Stack" do
   setup do
     @stack = Stack.new
     ["a","b","c"].each { |x| @stack.push x }
   end
   
-  specify "should add to the top when sent 'push'" do
+  specify "should add to the top when sent #push" do
     @stack.push "d"
     @stack.peek.should == "d"
   end
   
-  specify "should return the top item when sent 'peek'" do
+  specify "should return the top item when sent #peek" do
     @stack.peek.should == "c"
   end
   
-  specify "should NOT remove the top item when sent 'peek'" do
+  specify "should NOT remove the top item when sent #peek" do
     @stack.peek.should == "c"
     @stack.peek.should == "c"
   end
   
-  specify "should return the top item when sent 'pop'" do
+  specify "should return the top item when sent #pop" do
     @stack.pop.should == "c"
   end
   
-  specify "should remove the top item when sent 'pop'" do
+  specify "should remove the top item when sent #pop" do
     @stack.pop.should == "c"
     @stack.pop.should == "b"
   end
@@ -36,21 +36,20 @@ context "An empty stack" do
     @stack = Stack.new
   end
   
-  specify "should be empty" do
-    @stack.should_be_empty
-  end
+  # NOTE that this one auto-generates the description "should be_empty"
+  specify { @stack.should be_empty }
   
-  specify "should no longer be empty after 'push'" do
+  specify "should no longer be empty after #push" do
     @stack.push "anything"
-    @stack.should_not_be_empty
+    @stack.should_not be_empty
   end
   
-  specify "should complain when sent 'peek'" do
-    lambda { @stack.peek }.should_raise StackUnderflowError
+  specify "should complain when sent #peek" do
+    lambda { @stack.peek }.should raise_error(StackUnderflowError)
   end
   
-  specify "should complain when sent 'pop'" do
-    lambda { @stack.pop }.should_raise StackUnderflowError
+  specify "should complain when sent #pop" do
+    lambda { @stack.pop }.should raise_error(StackUnderflowError)
   end
 end
 
@@ -60,18 +59,17 @@ context "An almost empty stack (with one item)" do
     @stack.push 3
   end
   
-  specify "should not be empty" do
-    @stack.should_not_be_empty
-  end
+  # NOTE that this one auto-generates the description "should not be empty"
+  specify { @stack.should_not be_empty }
   
-  specify "should remain not empty after 'peek'" do
+  specify "should remain not empty after #peek" do
     @stack.peek
-    @stack.should_not_be_empty
+    @stack.should_not be_empty
   end
   
-  specify "should become empty after 'pop'" do
+  specify "should become empty after #pop" do
     @stack.pop
-    @stack.should_be_empty
+    @stack.should be_empty
   end
 end
 
@@ -81,13 +79,12 @@ context "An almost full stack (with one item less than capacity)" do
     (1..9).each { |i| @stack.push i }
   end
   
-  specify "should not be full" do
-    @stack.should_not_be_full
-  end
+  # NOTE that this one auto-generates the description "should not be full"
+  specify { @stack.should_not be_full }
   
-  specify "should become full when sent 'push'" do
+  specify "should become full when sent #push" do
     @stack.push Object.new
-    @stack.should_be_full
+    @stack.should be_full
   end
 end
 
@@ -97,21 +94,20 @@ context "A full stack" do
     (1..10).each { |i| @stack.push i }
   end
   
-  specify "should be full" do
-    @stack.should_be_full
-  end
+  # NOTE that this one auto-generates the description "should be full"
+  specify { @stack.should be_full }
   
-  specify "should remain full after 'peek'" do
+  specify "should remain full after #peek" do
     @stack.peek
-    @stack.should_be_full
+    @stack.should be_full
   end
   
-  specify "should no longer be full after 'pop'" do
+  specify "should no longer be full after #pop" do
     @stack.pop
-    @stack.should_not_be_full
+    @stack.should_not be_full
   end
 
-  specify "should complain on 'push'" do
-    lambda { @stack.push Object.new }.should_raise StackOverflowError
+  specify "should complain on #push" do
+    lambda { @stack.push Object.new }.should raise_error(StackOverflowError)
   end
 end

data/examples/stubbing_example.rb

@@ -4,7 +4,7 @@ context "A consumer of a stub" do
   specify "should be able to stub methods on any Object" do
     obj = Object.new
     obj.stub!(:foobar).and_return {:return_value}
-    obj.foobar.should_equal :return_value
+    obj.foobar.should equal(:return_value)
   end
 end
 
@@ -17,23 +17,23 @@ end
 context "A stubbed method on a class" do
   specify "should return the stubbed value" do
     StubbableClass.stub!(:find).and_return(:stub_return)
-    StubbableClass.find(1).should_equal :stub_return
+    StubbableClass.find(1).should equal(:stub_return)
   end
   
   specify "should revert to the original method after each spec" do
-    StubbableClass.find(1).should_equal :original_return
+    StubbableClass.find(1).should equal(:original_return)
   end
 
   specify "can stub! and mock the same message" do
     StubbableClass.stub!(:msg).and_return(:stub_value)
     StubbableClass.should_receive(:msg).with(:arg).and_return(:mock_value)
 
-    StubbableClass.msg.should_equal :stub_value
-    StubbableClass.msg(:other_arg).should_equal :stub_value
-    StubbableClass.msg(:arg).should_equal :mock_value
-    StubbableClass.msg(:another_arg).should_equal :stub_value
-    StubbableClass.msg(:yet_another_arg).should_equal :stub_value
-    StubbableClass.msg.should_equal :stub_value
+    StubbableClass.msg.should equal(:stub_value)
+    StubbableClass.msg(:other_arg).should equal(:stub_value)
+    StubbableClass.msg(:arg).should equal(:mock_value)
+    StubbableClass.msg(:another_arg).should equal(:stub_value)
+    StubbableClass.msg(:yet_another_arg).should equal(:stub_value)
+    StubbableClass.msg.should equal(:stub_value)
   end
 end
 
@@ -41,28 +41,28 @@ context "A mock" do
   specify "can stub!" do
     mock = mock("stubbing mock")
     mock.stub!(:msg).and_return(:value)
-    (1..10).each {mock.msg.should_equal :value}
+    (1..10).each {mock.msg.should equal(:value)}
   end
   
   specify "can stub! and mock" do
     mock = mock("stubbing mock")
     mock.stub!(:stub_message).and_return(:stub_value)
     mock.should_receive(:mock_message).once.and_return(:mock_value)
-    (1..10).each {mock.stub_message.should_equal :stub_value}
-    mock.mock_message.should_equal :mock_value
-    (1..10).each {mock.stub_message.should_equal :stub_value}
+    (1..10).each {mock.stub_message.should equal(:stub_value)}
+    mock.mock_message.should equal(:mock_value)
+    (1..10).each {mock.stub_message.should equal(:stub_value)}
   end
   
   specify "can stub! and mock the same message" do
     mock = mock("stubbing mock")
     mock.stub!(:msg).and_return(:stub_value)
     mock.should_receive(:msg).with(:arg).and_return(:mock_value)
-    mock.msg.should_equal :stub_value
-    mock.msg(:other_arg).should_equal :stub_value
-    mock.msg(:arg).should_equal :mock_value
-    mock.msg(:another_arg).should_equal :stub_value
-    mock.msg(:yet_another_arg).should_equal :stub_value
-    mock.msg.should_equal :stub_value
+    mock.msg.should equal(:stub_value)
+    mock.msg(:other_arg).should equal(:stub_value)
+    mock.msg(:arg).should equal(:mock_value)
+    mock.msg(:another_arg).should equal(:stub_value)
+    mock.msg(:yet_another_arg).should equal(:stub_value)
+    mock.msg.should equal(:stub_value)
   end
 end
 

data/examples/test_case_spec.rb

@@ -7,7 +7,7 @@ class RSpecIntegrationTest < Test::Unit::TestCase
   end
   
   def self.verify_class_method
-    @@fixtures.should_be true
+    @@fixtures.should == true
   end
   
   def setup
@@ -35,7 +35,7 @@ end
 context "RSpec should integrate with Test::Unit::TestCase" do
   inherit RSpecIntegrationTest
   include RandomHelperModule
-
+  
   fixtures :some_table
 
   setup do
@@ -43,18 +43,18 @@ context "RSpec should integrate with Test::Unit::TestCase" do
   end
 
   specify "TestCase#setup should be called." do
-    @test_case_setup_called.should_be true
-    @rspec_setup_called.should_be true
+    @test_case_setup_called.should be_true
+    @rspec_setup_called.should be_true
   end
 
   specify "RSpec should be able to access TestCase methods" do
     helper_method
-    @helper_method_called.should_be true
+    @helper_method_called.should be_true
   end
 
   specify "RSpec should be able to accept included modules" do
     random_task
-    @random_task_called.should_be true
+    @random_task_called.should be_true
   end
   
   teardown do

data/lib/spec.rb

@@ -1,5 +1,8 @@
+require 'spec/deprecated'
 require 'spec/version'
 require 'spec/callback'
+require 'spec/matchers'
 require 'spec/expectations'
 require 'spec/mocks'
 require 'spec/runner'
+require 'spec/translator'

data/lib/spec/callback.rb

@@ -1,3 +1,11 @@
 require 'spec/callback/callback_container'
 require 'spec/callback/extensions/module'
 require 'spec/callback/extensions/object'
+
+# Callback is a fork of Brian Takita's "callback library" (see http://callback.rubyforge.org),
+# which Brian graciously contributed to RSpec in order to avoid the dependency.
+#
+# RSpec uses Callback internally to create hooks to Spec::Runner events. If you're interested
+# in a simple, powerful API for generating callback events, check out http://callback.rubyforge.org.
+module Callback
+end

data/lib/spec/callback/extensions/object.rb

@@ -21,6 +21,10 @@ module Callback
       callbacks.notify(event, *args, &error_handler)
     end
 
+    def notify_class_callbacks(event, *args, &error_handler)
+      self.class.send(:notify_callbacks, event, *args, &error_handler)      
+    end
+
     # The CallbackContainer for this object.
     def callbacks
       @callbacks ||= CallbackContainer.new

data/lib/spec/deprecated.rb

@@ -0,0 +1,3 @@
+def deprecated(&block)
+  block.call unless ENV['RSPEC_DISABLE_DEPRECATED_FEATURES'] == 'true'
+end

data/lib/spec/expectations.rb

@@ -1,32 +1,59 @@
+require 'spec/deprecated'
+require 'spec/matchers'
 require 'spec/expectations/sugar'
 require 'spec/expectations/errors'
 require 'spec/expectations/extensions'
 require 'spec/expectations/should'
-require 'spec/expectations/message_builder'
+require 'spec/expectations/handler'
 
 module Spec
-  # See Spec::Expectations::ObjectExpectations for expectations that
-  # are available on all objects.
+  
+  # Spec::Expectations lets you set expectations on your objects.
   #
-  # See Spec::Expectations::ProcExpectations for expectations that
-  # are available on Proc objects.
+  #   result.should == 37
+  #   team.should have(11).players_on_the_field
   #
-  # See Spec::Expectations::NumericExpectations for expectations that
-  # are available on Numeric objects.
+  # == How Expectations work.
+  #
+  # Spec::Expectations adds two methods to Object:
+  #
+  #   should(matcher=nil)
+  #   should_not(matcher=nil)
+  #
+  # Both methods take an optional Expression Matcher (See Spec::Matchers).
+  #
+  # When +should+ receives an Expression Matcher, it calls <tt>matches?(self)</tt>. If
+  # it returns +true+, the spec passes and execution continues. If it returns
+  # +false+, then the spec fails with the message returned by <tt>matcher.failure_message</tt>.
+  #
+  # Similarly, when +should_not+ receives a matcher, it calls <tt>matches?(self)</tt>. If
+  # it returns +false+, the spec passes and execution continues. If it returns
+  # +true+, then the spec fails with the message returned by <tt>matcher.negative_failure_message</tt>.
+  #
+  # RSpec ships with a standard set of useful matchers, and writing your own
+  # matchers is quite simple. See Spec::Matchers for details.
   module Expectations
     class << self
-      # raises a Spec::Expectations::ExpecationNotMetError with message
-      def fail_with(message)
+      attr_accessor :differ
+
+      # raises a Spec::Expectations::ExpectationNotMetError with message
+      #
+      # When a differ has been assigned and fail_with is passed
+      # <code>expected</code> and <code>target</code>, passes them
+      # to the differ to append a diff message to the failure message.
+      def fail_with(message, expected=nil, target=nil) # :nodoc:
+        if Array === message && message.length == 3
+          message, expected, target = message[0], message[1], message[2]
+        end
+        unless (differ.nil? || expected.nil? || target.nil?)
+          if expected.is_a?(String)
+            message << "\nDiff:" << self.differ.diff_as_string(target.to_s, expected)
+          elsif !target.is_a?(Proc)
+            message << "\nDiff:" << self.differ.diff_as_object(target, expected)
+          end
+        end
         Kernel::raise(Spec::Expectations::ExpectationNotMetError.new(message))
       end
-      
-      def build_message(actual, expectation, expected)
-        message_builder.build_message(actual, expectation, expected)
-      end
-      
-      def message_builder #:nodoc:
-        @message_builder ||= MessageBuilder.new
-      end
     end
   end
 end