rspec 0.7.5.1 → 0.8.0

data/lib/spec/expectations/should/not.rb

@@ -1,76 +1,74 @@
 module Spec
   module Expectations
     module Should
-      class Not < Base
-    
+      
+      class Not < Base #:nodoc:
         def initialize(target)
           @target = target
           @be_seen = false
         end
 
-        def have(expected_number=nil)
-          NotHave.new(@target, :exactly, expected_number)
-        end
-
-        def change(receiver, message)
-          NotChange.new(@target, receiver, message)
-        end
-  
-        def satisfy
-          fail_with_message "Supplied expectation was satisfied, but should not have been" if (yield @target)
-        end
-        
-        def be(expected = :no_arg)
-          @be_seen = true
-          return self if (expected == :no_arg)
-          fail_with_message(default_message("should not be", expected)) if (@target.equal?(expected))
-        end
+        deprecated do
+          #Gone for 0.9
+          def be(expected = :___no_arg)
+            @be_seen = true
+            return self if (expected == :___no_arg)
+            fail_with_message(default_message("should not be", expected)) if (@target.equal?(expected))
+          end
 
-        def an_instance_of expected_class
-          fail_with_message(default_message("should not be an instance of", expected_class)) if @target.instance_of? expected_class
-        end
-    
-        def a_kind_of expected_class
-          fail_with_message(default_message("should not be a kind of", expected_class)) if @target.kind_of? expected_class
-        end
+          #Gone for 0.9
+          def have(expected_number=nil)
+            NotHave.new(@target, :exactly, expected_number)
+          end
 
-        def respond_to message
-          fail_with_message(default_message("should not respond to", message)) if @target.respond_to? message
-        end
-    
-        def match(expected)
-          fail_with_message(default_message("should not match", expected)) if (@target =~ expected)
-        end
-    
-        def raise(exception=Exception, message=nil)
-          begin
-            @target.call
-          rescue exception => e
-            return unless message.nil? || e.message == message || (message.is_a?(Regexp) && e.message =~ message)
-            fail_with_message("#{default_message("should not raise", exception)}") if e.instance_of? exception
-            fail_with_message("#{default_message("should not raise", exception)} but raised #{e.inspect}") unless e.instance_of? exception
-          rescue
-            true
+          #Gone for 0.9
+          def change(receiver, message)
+            NotChange.new(@target, receiver, message)
           end
-        end
-    
-        def throw(symbol=:___this_is_a_symbol_that_will_likely_never_occur___)
-          begin
-            catch symbol do
+  
+          #Gone for 0.9
+          def raise(exception=Exception, message=nil)
+            begin
               @target.call
-              return true
+            rescue exception => e
+              return unless message.nil? || e.message == message || (message.is_a?(Regexp) && e.message =~ message)
+              if e.kind_of?(exception)
+                failure_message = "expected no "
+                failure_message << exception.to_s
+                unless message.nil?
+                  failure_message << " with "
+                  failure_message << "message matching " if message.is_a?(Regexp)
+                  failure_message << message.inspect
+                end
+                failure_message << ", got " << e.inspect
+                fail_with_message(failure_message)
+              end
+            rescue
+              true
+            end
+          end
+    
+          #Gone for 0.9
+          def throw(symbol=:___this_is_a_symbol_that_will_likely_never_occur___)
+            begin
+              catch symbol do
+                @target.call
+                return true
+              end
+              fail_with_message("expected #{symbol.inspect} not to be thrown, but it was")
+            rescue NameError
+              true
             end
-            fail_with_message(default_message("should not throw", symbol.inspect))
-          rescue NameError
-            true
           end
-        end
 
-        def __delegate_method_missing_to_target original_sym, actual_sym, *args
-          return unless @target.__send__(actual_sym, *args)
-          fail_with_message(default_message("should not#{@be_seen ? ' be' : ''} #{original_sym}" + (args.empty? ? '' : ' ' + args[0].inspect)))
+          def __delegate_method_missing_to_target original_sym, actual_sym, *args
+            ::Spec::Matchers.generated_description = "should not #{original_sym} #{args[0].inspect}"
+            return unless @target.__send__(actual_sym, *args)
+            fail_with_message(default_message("not #{original_sym}", args[0]))
+          end
         end
       end
+
     end
   end
 end

data/lib/spec/expectations/should/should.rb

@@ -1,87 +1,81 @@
 module Spec
   module Expectations
     module Should # :nodoc:
+
       class Should < Base
 
-        def initialize(target)
+        def initialize(target, expectation=nil)
           @target = target
           @be_seen = false
         end
         
-        def have(expected_number=nil)
-          Have.new(@target, :exactly, expected_number)
-        end
-
-        def change(receiver=nil, message=nil, &block)
-          Change.new(@target, receiver, message, &block)
-        end
-
-        def not
-          Not.new(@target)
-        end
-      
-        def satisfy
-          return if yield(@target)
-          fail_with_message "Supplied expectation was not satisfied"
-        end
-      
-        def be(expected = :___no_arg)
-          @be_seen = true
-          return self if (expected == :___no_arg)
-          fail_with_message(default_message("should be", expected)) unless (@target.equal?(expected))
-        end
-
-        def an_instance_of(expected_class)
-          fail_with_message(default_message("should be an instance of", expected_class)) unless @target.instance_of? expected_class
-        end
-  
-        def a_kind_of(expected_class)
-          fail_with_message(default_message("should be a kind of", expected_class)) unless @target.kind_of? expected_class
-        end
-  
-        def respond_to(message)
-          fail_with_message(default_message("should respond to", message)) unless @target.respond_to? message
-        end
-  
-        def __delegate_method_missing_to_target(original_sym, actual_sym, *args)
-          return if @target.send(actual_sym, *args)
-          message = default_message("should#{@be_seen ? ' be' : ''} #{original_sym}", args[0])
-          fail_with_message(message)
-        end
+        deprecated do
+          #Gone for 0.9
+          def not
+            Not.new(@target)
+          end
+            
+          #Gone for 0.9
+          def be(expected = :___no_arg)
+            @be_seen = true
+            return self if (expected == :___no_arg)
+            if Symbol === expected
+              fail_with_message(default_message("should be", expected)) unless (@target.equal?(expected))
+            else
+              fail_with_message("expected #{expected}, got #{@target} (using .equal?)") unless (@target.equal?(expected))
+            end
+          end
+        
+          #Gone for 0.9
+          def have(expected_number=nil)
+            Have.new(@target, :exactly, expected_number)
+          end
 
-        def match(expected)
-           fail_with_message(default_message("should match", expected)) unless (@target =~ expected)
-        end
+          #Gone for 0.9
+          def change(receiver=nil, message=nil, &block)
+            Change.new(@target, receiver, message, &block)
+          end
 
-        def raise(exception=Exception, message=nil)
-          begin
-            @target.call
-          rescue exception => e
-            unless message.nil?
-              if message.is_a?(Regexp)
-                e.message.should =~ message
-              else
-                e.message.should == message
+          #Gone for 0.9
+          def raise(exception=Exception, message=nil)
+            begin
+              @target.call
+            rescue exception => e
+              unless message.nil?
+                if message.is_a?(Regexp)
+                  e.message.should =~ message
+                else
+                  e.message.should == message
+                end
               end
+              return
+            rescue => e
+              fail_with_message("expected #{exception}#{message.nil? ? "" : " with #{message.inspect}"}, got #{e.inspect}")
             end
-            return
-          rescue => e
-            fail_with_message("#{default_message("should raise", exception)} but raised #{e.inspect}")
+            fail_with_message("expected #{exception}#{message.nil? ? "" : " with #{message.inspect}"} but nothing was raised")
           end
-          fail_with_message("#{default_message("should raise", exception)} but raised nothing")
-        end
   
-        def throw(symbol)
-          begin
-            catch symbol do
-              @target.call
-              fail_with_message(default_message("should throw", symbol.inspect))
+          #Gone for 0.9
+          def throw(symbol)
+            begin
+              catch symbol do
+                @target.call
+                fail_with_message("expected #{symbol.inspect} to be thrown, but nothing was thrown")
+              end
+            rescue NameError => e
+              fail_with_message("expected #{symbol.inspect} to be thrown, got #{e.inspect}")
             end
-          rescue NameError
-            fail_with_message(default_message("should throw", symbol.inspect))
           end
         end
+
+        private
+        def __delegate_method_missing_to_target(original_sym, actual_sym, *args)
+          ::Spec::Matchers.generated_description = "should #{original_sym} #{args[0].inspect}"
+          return if @target.send(actual_sym, *args)
+          fail_with_message(default_message(original_sym, args[0]), args[0], @target)
+        end
       end
+
     end
   end
 end

data/lib/spec/expectations/sugar.rb

@@ -1,8 +1,9 @@
+deprecated do
 module Spec
   module Expectations
     # This module adds syntactic sugar that allows usage of should_* instead of should.*
-    module UnderscoreSugar # :nodoc:
-      def handle_underscores_for_rspec!
+    module UnderscoreSugar
+      def handle_underscores_for_rspec!  # :nodoc:
         original_method_missing = instance_method(:method_missing)
         class_eval do
           def method_missing(sym, *args, &block)
@@ -11,14 +12,36 @@ module Spec
 
           define_method :_method_missing do |sym, args, block|
             return original_method_missing.bind(self).call(sym, *args, &block) unless sym.to_s =~ /^should_/
-            return Spec::Expectations::Should::Should.new(self).__send__(__strip_should(sym), *args, &block)
+            if sym.to_s =~ /^should_not_/
+              if __matcher.respond_to?(__strip_should_not(sym))
+                return should_not(__matcher.__send__(__strip_should_not(sym), *args, &block))
+              else
+                return Spec::Expectations::Should::Not.new(self).__send__(__strip_should_not(sym), *args, &block) if sym.to_s =~ /^should_not_/
+              end
+            else
+              if __matcher.respond_to?(__strip_should(sym))
+                return should(__matcher.__send__(__strip_should(sym), *args, &block))
+              else
+                return Spec::Expectations::Should::Should.new(self).__send__(__strip_should(sym), *args, &block)
+              end
+            end
           end
           
-          def __strip_should(sym) # :nodoc 
+          def __strip_should(sym) # :nodoc
             sym.to_s[7..-1]
           end
+          
+          def __strip_should_not(sym) # :nodoc
+            sym.to_s[11..-1]
+          end
+          
+          def __matcher
+            @matcher ||= Spec::Matchers::Matcher.new
+          end
         end
       end
     end
   end
+end
+
 end

data/lib/spec/matchers.rb

@@ -0,0 +1,160 @@
+require 'spec/deprecated'
+require 'spec/callback'
+require 'spec/matchers/be'
+require 'spec/matchers/be_close'
+require 'spec/matchers/change'
+require 'spec/matchers/eql'
+require 'spec/matchers/equal'
+require 'spec/matchers/has'
+require 'spec/matchers/have'
+require 'spec/matchers/include'
+require 'spec/matchers/match'
+require 'spec/matchers/raise_error'
+require 'spec/matchers/respond_to'
+require 'spec/matchers/satisfy'
+require 'spec/matchers/throw_symbol'
+
+module Spec
+
+  # RSpec ships with a number of useful Expression Matchers. An Expression Matcher
+  # is any object that responds to the following methods:
+  #
+  #   matches?(actual)
+  #   failure_message
+  #   negative_failure_message #optional
+  #   description #optional
+  #
+  # See Spec::Expectations to learn how to use these as Expectation Matchers.
+  # See Spec::Mocks to learn how to use them as Mock Argument Constraints.
+  #
+  # == Predicates
+  #
+  # In addition to those Expression Matchers that are defined explicitly, RSpec will
+  # create custom Matchers on the fly for any arbitrary predicate, giving your specs
+  # a much more natural language feel. 
+  #
+  # A Ruby predicate is a method that ends with a "?" and returns true or false.
+  # Common examples are +empty?+, +nil?+, and +instance_of?+.
+  #
+  # All you need to do is write +should be_+ followed by the predicate without
+  # the question mark, and RSpec will figure it out from there. For example:
+  #
+  #   [].should be_empty => [].empty? #passes
+  #   [].should_not be_empty => [].empty? #fails
+  #
+  # In addtion to prefixing the predicate matchers with "be_", you can also use "be_a_"
+  # and "be_an_", making your specs read much more naturally:
+  #
+  #   "a string".should be_an_instance_of(String) =>"a string".instance_of?(String) #passes
+  #
+  #   3.should be_a_kind_of(Fixnum) => 3.kind_of?(Numeric) #passes
+  #   3.should be_a_kind_of(Numeric) => 3.kind_of?(Numeric) #passes
+  #   3.should be_an_instance_of(Fixnum) => 3.instance_of?(Fixnum) #passes
+  #   3.should_not be_instance_of(Numeric) => 3.instance_of?(Numeric) #fails
+  #
+  # RSpec will also create custom matchers for predicates like +has_key?+. To
+  # use this feature, just state that the object should have_key(:key) and RSpec will
+  # call has_key?(:key) on the target. For example:
+  #
+  #   {:a => "A"}.should have_key(:a) => {:a => "A"}.has_key?(:a) #passes
+  #   {:a => "A"}.should have_key(:b) => {:a => "A"}.has_key?(:b) #fails
+  #
+  # You can use this feature to invoke any predicate that begins with "has_", whether it is
+  # part of the Ruby libraries (like +Hash#has_key?+) or a method you wrote on your own class.
+  #
+  # == Custom Expression Matchers
+  #
+  # When you find that none of the stock Expression Matchers provide a natural
+  # feeling expectation, you can very easily write your own.
+  #
+  # For example, imagine that you are writing a game in which players can
+  # be in various zones on a virtual board. To specify that bob should
+  # be in zone 4, you could say:
+  #
+  #   bob.current_zone.should eql(Zone.new("4"))
+  #
+  # But you might find it more expressive to say:
+  #
+  #   bob.should be_in_zone("4")
+  #
+  # and/or
+  #
+  #   bob.should_not be_in_zone("3")
+  #
+  # To do this, you would need to write a class like this:
+  #
+  #   class BeInZone
+  #     def initialize(expected)
+  #       @expected = expected
+  #     end
+  #     def matches?(actual)
+  #       @actual = actual
+  #       bob.current_zone.eql?(Zone.new(@expected))
+  #     end
+  #     def failure_message
+  #       "expected #{@actual.inspect} to be in Zone #{@expected}"
+  #     end
+  #     def negative_failure_message
+  #       "expected #{@actual.inspect} not to be in Zone #{@expected}"
+  #     end
+  #   end
+  #
+  # ... and a method like this:
+  #
+  #   def be_in_zone(expected)
+  #     BeInZone.new(expected)
+  #   end
+  #
+  # And then expose the method to your specs. This is normally done
+  # by including the method and the class in a module, which is then
+  # included in your spec:
+  #
+  #   module CustomGameMatchers
+  #     class BeInZone
+  #       ...
+  #     end
+  #
+  #     def be_in_zone(expected)
+  #       ...
+  #     end
+  #   end
+  #
+  #   context "Player behaviour" do
+  #     include CustomGameMatchers
+  #     ...
+  #   end
+  module Matchers
+    
+    class << self
+      callback_events :description_generated
+      def generated_description=(name)
+        notify_callbacks(:description_generated, name)
+      end
+    end
+    
+    def method_missing(sym, *args, &block) # :nodoc:
+      return Matchers::Be.new(sym, *args) if sym.starts_with?("be_")
+      return Matchers::Has.new(sym, *args) if sym.starts_with?("have_")
+      super
+    end
+
+    deprecated do
+      # This supports sugar delegating to Matchers
+      class Matcher #:nodoc:
+        include Matchers
+
+        def respond_to?(sym)
+          if sym.to_s[0..2] == "be_"
+            return true
+          else
+            super
+          end
+        end
+      end
+    end
+    
+    class MatcherError < StandardError
+    end
+    
+  end
+end