rspec 1.2.9 → 1.3.1

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/operator_matcher.rb

@@ -13,7 +13,12 @@ module Spec
         end
 
         def get(klass, operator)
-          registry[klass] && registry[klass][operator]
+          matcher = registry[klass] && registry[klass][operator]
+          unless matcher
+            parent_class = registry.keys.detect {|pc| klass <= pc }
+            matcher = registry[parent_class] && registry[parent_class][operator]
+          end
+          matcher
         end
       end
 

data/lib/spec/matchers/pretty.rb

@@ -5,7 +5,7 @@ module Spec
         sym.to_s.gsub(/_/,' ')
       end
 
-      def to_sentence(words)
+      def to_sentence(words=[])
         words = words.map{|w| w.inspect}
         case words.length
           when 0
@@ -34,4 +34,4 @@ module Spec
       end
     end
   end
-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/simple_matcher.rb

@@ -127,7 +127,8 @@ module Spec
     # failing), will fail when you want it to pass.
     #
     def simple_matcher(description=nil, &match_block)
+      Spec.deprecate("simple_matcher", "Matcher DSL (http://rspec.rubyforge.org/rspec/1.3.0/classes/Spec/Matchers.html)")
       SimpleMatcher.new(description, &match_block)
     end
   end
-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)
@@ -97,8 +93,8 @@ module Spec
     #   lambda { do_something_risky }.should_not throw_symbol
     #   lambda { do_something_risky }.should_not throw_symbol(:that_was_risky)
     #   lambda { do_something_risky }.should_not throw_symbol(:that_was_risky, culprit)
-    def throw_symbol(sym=nil)
-      Matchers::ThrowSymbol.new(sym)
+    def throw_symbol(expected_symbol = nil, expected_arg=nil)
+      Matchers::ThrowSymbol.new(expected_symbol, expected_arg)
     end
   end
 end

data/lib/spec/matchers.rb

@@ -1,4 +1,4 @@
-require 'spec/matchers/extensions/instance_exec'
+require 'spec/extensions/instance_exec'
 require 'spec/matchers/pretty'
 require 'spec/matchers/matcher'
 require 'spec/matchers/operator_matcher'
@@ -18,7 +18,7 @@ require 'spec/matchers/include'
 require 'spec/matchers/match'
 require 'spec/matchers/match_array'
 require 'spec/matchers/method_missing'
-require 'spec/matchers/raise_error'
+require 'spec/matchers/raise_exception'
 require 'spec/matchers/respond_to'
 require 'spec/matchers/satisfy'
 require 'spec/matchers/simple_matcher'
@@ -139,6 +139,25 @@ module Spec
   # <tt>failure_message_for_should_not</tt>) are passed the actual value (the
   # receiver of <tt>should</tt> or <tt>should_not</tt>).
   #
+  # You can also create matchers that obey a fluent interface using the
+  # <tt>chain</tt> method:
+  #
+  #   Spec::Matchers.define :tip do |expected_tip|
+  #     chain :on do |bill|
+  #       @bill = bill
+  #     end
+  #
+  #     match do |person|
+  #       person.tip_for(bill) == expected_tip
+  #     end
+  #   end
+  #
+  # This matcher can be used as follows:
+  #
+  #   describe Customer do
+  #     it { should tip(10).on(50) }
+  #   end
+  #
   # === Custom Matcher from scratch
   #
   # You could also write a custom matcher from scratch, as follows: