rspec 1.2.9 → 1.3.0

data/lib/spec/matchers/has.rb

@@ -3,12 +3,12 @@ module Spec
     
     class Has
       
-      def initialize(expected, *args)
-        @expected, @args = expected, args
+      def initialize(expected, *args, &block)
+        @expected, @args, @block = expected, args, block
       end
       
       def matches?(actual)
-        actual.__send__(predicate(@expected), *@args)
+        actual.__send__(predicate(@expected), *@args, &@block)
       end
       
       def failure_message_for_should

data/lib/spec/matchers/have.rb

@@ -5,6 +5,7 @@ module Spec
         @expected = (expected == :no ? 0 : expected)
         @relativity = relativity
         @actual = nil
+        @plural_collection_name = nil
       end
     
       def relativities

data/lib/spec/matchers/matcher.rb

@@ -12,6 +12,7 @@ module Spec
         @expected = expected
         @actual   = nil
         @diffable = false
+        @expected_exception = nil
         @messages = {
           :description => lambda {"#{name_to_sentence}#{expected_to_sentence}"},
           :failure_message_for_should => lambda {|actual| "expected #{actual.inspect} to #{name_to_sentence}#{expected_to_sentence}"},
@@ -22,33 +23,70 @@ module Spec
         end
       end
 
+      #Used internally by objects returns by +should+ and +should_not+.
       def matches?(actual)
-        instance_exec(@actual = actual, &@match_block)
+        @actual = actual
+        if @expected_exception
+          begin
+            instance_exec(actual, &@match_block)
+            true
+          rescue @expected_exception
+            false
+          end
+        else
+          begin
+            instance_exec(actual, &@match_block)
+          rescue Spec::Expectations::ExpectationNotMetError
+            false
+          end
+        end
       end
 
-      def description(&block)
-        cache_or_call_cached(:description, &block)
+      # See Spec::Matchers
+      def match(&block)
+        @match_block = block
       end
 
+      # See Spec::Matchers
+      def match_unless_raises(exception=Exception, &block)
+        @expected_exception = exception
+        match(&block)
+      end
+
+      # See Spec::Matchers
       def failure_message_for_should(&block)
-        cache_or_call_cached(:failure_message_for_should, actual, &block)
+        cache_or_call_cached(:failure_message_for_should, &block)
       end
 
+      # See Spec::Matchers
       def failure_message_for_should_not(&block)
-        cache_or_call_cached(:failure_message_for_should_not, actual, &block)
+        cache_or_call_cached(:failure_message_for_should_not, &block)
       end
 
-      def match(&block)
-        @match_block = block
+      # See Spec::Matchers
+      def description(&block)
+        cache_or_call_cached(:description, &block)
       end
 
+      #Used internally by objects returns by +should+ and +should_not+.
       def diffable?
         @diffable
       end
 
+      # See Spec::Matchers
       def diffable
         @diffable = true
       end
+      
+      # See Spec::Matchers
+      def chain(method, &block)
+        self.class.class_eval do
+          define_method method do |*args|
+            block.call(*args)
+            self
+          end
+        end
+      end
 
     private
 
@@ -69,9 +107,16 @@ module Spec
         (private_methods - orig_private_methods).each {|m| st.__send__ :public, m}
       end
 
-      def cache_or_call_cached(key, actual=nil, &block)
-        block ? @messages[key] = block :
-                actual.nil? ? @messages[key].call : @messages[key].call(actual)
+      def cache_or_call_cached(key, &block)
+        block ? cache(key, &block) : call_cached(key)
+      end
+
+      def cache(key, &block)
+        @messages[key] = block
+      end
+
+      def call_cached(key)
+        @messages[key].arity == 1 ? @messages[key].call(@actual) : @messages[key].call
       end
 
       def name_to_sentence

data/lib/spec/matchers/method_missing.rb

@@ -1,8 +1,8 @@
 module Spec
   module Matchers
     def method_missing(sym, *args, &block) # :nodoc:
-      return Matchers::Be.new(sym, *args) if sym.to_s =~ /^be_/
-      return Matchers::Has.new(sym, *args) if sym.to_s =~ /^have_/
+      return Matchers::BePredicate.new(sym, *args, &block) if sym.to_s =~ /^be_/
+      return Matchers::Has.new(sym, *args, &block) if sym.to_s =~ /^have_/
       super
     end
   end

data/lib/spec/matchers/raise_exception.rb

@@ -0,0 +1,131 @@
+module Spec
+  module Matchers
+    class RaiseException #:nodoc:
+      def initialize(expected_exception_or_message=Exception, expected_message=nil, &block)
+        @block = block
+        @actual_exception = nil
+        case expected_exception_or_message
+        when String, Regexp
+          @expected_exception, @expected_message = Exception, expected_exception_or_message
+        else
+          @expected_exception, @expected_message = expected_exception_or_message, expected_message
+        end
+      end
+
+      def matches?(given_proc)
+        @raised_expected_exception = false
+        @with_expected_message = false
+        @eval_block = false
+        @eval_block_passed = false
+        begin
+          given_proc.call
+        rescue @expected_exception => @actual_exception
+          @raised_expected_exception = true
+          @with_expected_message = verify_message
+        rescue Exception => @actual_exception
+          # This clause should be empty, but rcov will not report it as covered
+          # unless something (anything) is executed within the clause
+          rcov_exception_report = "http://eigenclass.org/hiki.rb?rcov-0.8.0"
+        end
+
+        unless negative_expectation?
+          eval_block if @raised_expected_exception && @with_expected_message && @block
+        end
+
+        (@raised_expected_exception & @with_expected_message) ? (@eval_block ? @eval_block_passed : true) : false
+      end
+
+      def eval_block
+        @eval_block = true
+        begin
+          @block[@actual_exception]
+          @eval_block_passed = true
+        rescue Exception => err
+          @actual_exception = err
+        end
+      end
+
+      def verify_message
+        case @expected_message
+        when nil
+          true
+        when Regexp
+          @expected_message =~ @actual_exception.message
+        else
+          @expected_message == @actual_exception.message
+        end
+      end
+
+      def failure_message_for_should
+        @eval_block ? @actual_exception.message : "expected #{expected_exception}#{given_exception}"
+      end
+
+      def failure_message_for_should_not
+        "expected no #{expected_exception}#{given_exception}"
+      end
+
+      def description
+        "raise #{expected_exception}"
+      end
+
+      private
+        def expected_exception
+          case @expected_message
+          when nil
+            @expected_exception
+          when Regexp
+            "#{@expected_exception} with message matching #{@expected_message.inspect}"
+          else
+            "#{@expected_exception} with #{@expected_message.inspect}"
+          end
+        end
+
+        def given_exception
+          @actual_exception.nil? ? " but nothing was raised" : ", got #{@actual_exception.inspect}"
+        end
+
+        def negative_expectation?
+          # YES - I'm a bad person... help me find a better way - ryand
+          caller.first(3).find { |s| s =~ /should_not/ }
+        end
+    end
+
+    # :call-seq:
+    #   should raise_exception()
+    #   should raise_exception(NamedError)
+    #   should raise_exception(NamedError, String)
+    #   should raise_exception(NamedError, Regexp)
+    #   should raise_exception() { |exception| ... }
+    #   should raise_exception(NamedError) { |exception| ... }
+    #   should raise_exception(NamedError, String) { |exception| ... }
+    #   should raise_exception(NamedError, Regexp) { |exception| ... }
+    #   should_not raise_exception()
+    #   should_not raise_exception(NamedError)
+    #   should_not raise_exception(NamedError, String)
+    #   should_not raise_exception(NamedError, Regexp)
+    #
+    # With no args, matches if any exception is raised.
+    # With a named exception, matches only if that specific exception is raised.
+    # With a named exception and messsage specified as a String, matches only if both match.
+    # With a named exception and messsage specified as a Regexp, matches only if both match.
+    # Pass an optional block to perform extra verifications on the exception matched
+    #
+    # == Examples
+    #
+    #   lambda { do_something_risky }.should raise_exception
+    #   lambda { do_something_risky }.should raise_exception(PoorRiskDecisionError)
+    #   lambda { do_something_risky }.should raise_exception(PoorRiskDecisionError) { |exception| exception.data.should == 42 }
+    #   lambda { do_something_risky }.should raise_exception(PoorRiskDecisionError, "that was too risky")
+    #   lambda { do_something_risky }.should raise_exception(PoorRiskDecisionError, /oo ri/)
+    #
+    #   lambda { do_something_risky }.should_not raise_exception
+    #   lambda { do_something_risky }.should_not raise_exception(PoorRiskDecisionError)
+    #   lambda { do_something_risky }.should_not raise_exception(PoorRiskDecisionError, "that was too risky")
+    #   lambda { do_something_risky }.should_not raise_exception(PoorRiskDecisionError, /oo ri/)
+    def raise_exception(exception=Exception, message=nil, &block)
+      Matchers::RaiseException.new(exception, message, &block)
+    end
+
+    alias_method :raise_error, :raise_exception
+  end
+end

data/lib/spec/matchers/throw_symbol.rb

@@ -1,13 +1,13 @@
 module Spec
   module Matchers
-    
+
     class ThrowSymbol #:nodoc:
       def initialize(expected_symbol = nil, expected_arg=nil)
         @expected_symbol = expected_symbol
         @expected_arg = expected_arg
         @caught_symbol = @caught_arg = nil
       end
-      
+
       def matches?(given_proc)
         begin
           if @expected_symbol.nil?
@@ -27,17 +27,13 @@ module Spec
         rescue NameError, ArgumentError => e
           raise e unless e.message =~ /uncaught throw (`|\:)([a-zA-Z0-9_]*)(')?/
           @caught_symbol = $2.to_sym
-
-        ensure
-          if @expected_symbol.nil?
-            return !@caught_symbol.nil?
-          else
-            if @expected_arg.nil?
-              return @caught_symbol == @expected_symbol
-            else
-              return (@caught_symbol == @expected_symbol) & (@caught_arg == @expected_arg)
-            end
-          end
+        end
+        if @expected_symbol.nil?
+          !@caught_symbol.nil?
+        elsif @expected_arg.nil?
+          @caught_symbol == @expected_symbol
+        else
+          (@caught_symbol == @expected_symbol) & (@caught_arg == @expected_arg)
         end
       end
 
@@ -48,7 +44,7 @@ module Spec
           "expected #{expected} but nothing was thrown"
         end
       end
-      
+
       def failure_message_for_should_not
         if @expected_symbol
           "expected #{expected} not to be thrown"
@@ -56,23 +52,23 @@ module Spec
           "expected no Symbol, got :#{@caught_symbol}"
         end
       end
-      
+
       def description
         "throw #{expected}"
       end
-      
+
       private
-      
+
         def expected
           @expected_symbol.nil? ? "a Symbol" : "#{@expected_symbol.inspect}#{args}"
         end
-        
+
         def args
           @expected_arg.nil? ? "" : " with #{@expected_arg.inspect}"
         end
-      
+
     end
- 
+
     # :call-seq:
     #   should throw_symbol()
     #   should throw_symbol(:sym)

data/lib/spec/mocks/message_expectation.rb

@@ -7,7 +7,7 @@ module Spec
       protected :expected_received_count=, :method_block=, :expected_from=
       attr_accessor :error_generator
       protected :error_generator, :error_generator=
-      
+
       def initialize(error_generator, expectation_ordering, expected_from, sym, method_block, expected_received_count=1, opts={}, &implementation)
         @error_generator = error_generator
         @error_generator.opts = opts
@@ -27,8 +27,9 @@ module Spec
         @failed_fast = nil
         @args_to_yield_were_cloned = false
         @return_block = implementation
+        @eval_context = nil
       end
-      
+
       def build_child(expected_from, method_block, expected_received_count, opts={})
         child = clone
         child.expected_from = expected_from
@@ -41,7 +42,7 @@ module Spec
         child.clone_args_to_yield @args_to_yield
         child
       end
-      
+
       def expected_args
         @args_expectation.args
       end
@@ -59,7 +60,7 @@ module Spec
         end
         @return_block = block_given? ? return_block : lambda { value }
       end
-      
+
       # :call-seq:
       #   and_raise()
       #   and_raise(Exception) #any exception class
@@ -74,47 +75,53 @@ module Spec
       def and_raise(exception=Exception)
         @exception_to_raise = exception
       end
-      
+
       def and_throw(symbol)
         @symbol_to_throw = symbol
       end
-      
-      def and_yield(*args)
+
+      def and_yield(*args, &block)
         if @args_to_yield_were_cloned
           @args_to_yield.clear
           @args_to_yield_were_cloned = false
         end
-        
+
+        if block
+          require 'spec/extensions/instance_exec'
+          @eval_context = Object.new
+          @eval_context.extend Spec::Matchers::InstanceExec
+          yield @eval_context
+        end
         @args_to_yield << args
         self
       end
-      
+
       def matches(sym, args)
         @sym == sym and @args_expectation.args_match?(args)
       end
-      
+
       def invoke(*args, &block)
         if @expected_received_count == 0
           @failed_fast = true
           @actual_received_count += 1
           @error_generator.raise_expectation_error @sym, @expected_received_count, @actual_received_count, *args
         end
-        
+
         @order_group.handle_order_constraint self
 
         begin
           Kernel::raise @exception_to_raise unless @exception_to_raise.nil?
           Kernel::throw @symbol_to_throw unless @symbol_to_throw.nil?
-          
-          
+
+
           if !@method_block.nil?
             default_return_val = invoke_method_block(*args)
-          elsif @args_to_yield.size > 0
+          elsif @args_to_yield.size > 0 || @eval_context
             default_return_val = invoke_with_yield(&block)
           else
             default_return_val = nil
           end
-          
+
           if @consecutive
             return invoke_consecutive_return_block(*args, &block)
           elsif @return_block
@@ -131,7 +138,7 @@ module Spec
         @expected_received_count != :any && @expected_received_count > 0 &&
           @actual_received_count >= @expected_received_count
       end
-      
+
       def invoke_return_block(*args, &block)
         args << block unless block.nil?
         # Ruby 1.9 - when we set @return_block to return values
@@ -139,7 +146,7 @@ module Spec
         # a "wrong number of arguments" error
         @return_block.arity == 0 ? @return_block.call : @return_block.call(*args)
       end
-      
+
       protected
 
       def invoke_method_block(*args)
@@ -149,7 +156,7 @@ module Spec
           @error_generator.raise_block_failed_error @sym, detail.message
         end
       end
-      
+
       def invoke_with_yield(&block)
         if block.nil?
           @error_generator.raise_missing_block_error @args_to_yield
@@ -159,67 +166,75 @@ module Spec
           if block.arity > -1 && args_to_yield_this_time.length != block.arity
             @error_generator.raise_wrong_arity_error args_to_yield_this_time, block.arity
           end
-          value = block.call(*args_to_yield_this_time)
+          value = eval_block(*args_to_yield_this_time, &block)
         end
         value
       end
-      
+
+      def eval_block(*args, &block)
+        if @eval_context
+          @eval_context.instance_exec(*args, &block)
+        else
+          block.call(*args)
+        end
+      end
+
       def invoke_consecutive_return_block(*args, &block)
         value = invoke_return_block(*args, &block)
         index = [@actual_received_count, value.size-1].min
         value[index]
       end
-      
+
       def clone_args_to_yield(args)
         @args_to_yield = args.clone
         @args_to_yield_were_cloned = true
       end
-      
+
       def failed_fast?
         @failed_fast
       end
     end
-    
+
     class MessageExpectation < BaseExpectation
 
       def matches_name?(sym)
         @sym == sym
       end
-      
+
       def matches_name_but_not_args(sym, args)
         matches_name?(sym) and not @args_expectation.args_match?(args)
       end
-       
+
       def verify_messages_received
         return if expected_messages_received? || failed_fast?
-    
+
         generate_error
       rescue Spec::Mocks::MockExpectationError => error
         error.backtrace.insert(0, @expected_from)
         Kernel::raise error
       end
-      
+
       def expected_messages_received?
         ignoring_args? || matches_exact_count? ||
            matches_at_least_count? || matches_at_most_count?
       end
-      
+
       def ignoring_args?
         @expected_received_count == :any
       end
-      
+
       def matches_at_least_count?
         @at_least && @actual_received_count >= @expected_received_count
       end
-      
+
       def matches_at_most_count?
         @at_most && @actual_received_count <= @expected_received_count
       end
-      
+
       def matches_exact_count?
         @expected_received_count == @actual_received_count
       end
-      
+
       def similar_messages
         @similar_messages ||= []
       end
@@ -227,7 +242,7 @@ module Spec
       def advise(args, block)
         similar_messages << args
       end
-      
+
       def generate_error
         if similar_messages.empty?
           @error_generator.raise_expectation_error(@sym, @expected_received_count, @actual_received_count, *@args_expectation.args)
@@ -240,17 +255,17 @@ module Spec
         @args_expectation = ArgumentExpectation.new(args, &block)
         self
       end
-      
+
       def exactly(n)
         set_expected_received_count :exactly, n
         self
       end
-      
+
       def at_least(n)
         set_expected_received_count :at_least, n
         self
       end
-      
+
       def at_most(n)
         set_expected_received_count :at_most, n
         self
@@ -260,41 +275,41 @@ module Spec
         @method_block = block if block
         self
       end
-  
+
       def any_number_of_times(&block)
         @method_block = block if block
         @expected_received_count = :any
         self
       end
-  
+
       def never
         @expected_received_count = 0
         self
       end
-  
+
       def once(&block)
         @method_block = block if block
         @expected_received_count = 1
         self
       end
-  
+
       def twice(&block)
         @method_block = block if block
         @expected_received_count = 2
         self
       end
-  
+
       def ordered(&block)
         @method_block = block if block
         @order_group.register(self)
         @ordered = true
         self
       end
-      
+
       def negative_expectation_for?(sym)
         return false
       end
-      
+
       protected
         def set_expected_received_count(relativity, n)
           @at_least = (relativity == :at_least)
@@ -308,22 +323,22 @@ module Spec
               2
           end
         end
-        
+
         def clear_actual_received_count!
           @actual_received_count = 0
         end
-      
+
     end
-    
+
     class NegativeMessageExpectation < MessageExpectation
       def initialize(message, expectation_ordering, expected_from, sym, method_block)
         super(message, expectation_ordering, expected_from, sym, method_block, 0)
       end
-      
+
       def negative_expectation_for?(sym)
         return @sym == sym
       end
     end
-    
+
   end
 end