rspec 0.7.5.1 → 0.8.0

data/lib/spec/expectations/extensions.rb

@@ -1,4 +1,3 @@
 require 'spec/expectations/extensions/object'
 require 'spec/expectations/extensions/proc'
-require 'spec/expectations/extensions/numeric'
-require 'spec/expectations/extensions/string'
+require 'spec/expectations/extensions/string_and_symbol'

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

@@ -1,153 +1,97 @@
 module Spec
   module Expectations
-    # rspec adds all of these expectations to every Object (and,
+    # rspec adds #should and #should_not to every Object (and,
     # implicitly, every Class).
     module ObjectExpectations
-      
-      # Supports the following expectations:
-      #   receiver.should == expected #any value
-      #     Passes if (receiver == expected)
-      #
-      #   receiver.should =~ expected #a regexp
-      #     Passes if (receiver =~ expected), where expected
-      #     is a Regexp.
-      #
-      # NOTE that this does NOT support receiver.should != expected.
-      # Instead, use receiver.should_not == expected
-      def should
-        Should::Should.new self
-      end
-
-      # Supports the following expectations:
-      #   receiver.should_not == expected #any value
-      #     Passes unless (receiver == expected)
-      #
-      #   receiver.should_not =~ expected #a regexp
-      #     Passes unless (receiver =~ expected), where expected
-      #     is a Regexp.
-      def should_not
-        should.not
-      end
-
-      # Passes if receiver.equal?(expected)
-      def should_equal(expected)
-        should.equal(expected)
-      end
-
-      # Passes unless receiver.equal?(expected)
-      def should_not_equal(expected)
-        should.not.equal(expected)
-      end
-
-      # Passes if receiver.eql?(expected)
-      def should_eql(expected)
-        should.eql(expected)
-      end
-
-      # Passes unless receiver.eql?(expected)
-      def should_not_eql(expected)
-        should.not.eql(expected)
-      end
 
-      # Specify that the receiver should have a
-      # specified number of items in a named collection. For example:
-      #
-      #   team.should_have(40).players
+      # :call-seq:
+      #   should(matcher)
+      #   should == expected
+      #   should =~ expected
       #
-      # Passes if team.players.size == 40.
+      #   receiver.should(matcher)
+      #     => Passes if matcher.matches?(receiver)
       #
-      # Works for collections with size() and/or length() methods.
-      def should_have(expected)
-        should.have(expected)
-      end
-      alias_method :should_have_exactly, :should_have
-
-      # Specify that the receiver should have at least a
-      # specified number of items in a named collection. For example:
+      #   receiver.should == expected #any value
+      #     => Passes if (receiver == expected)
       #
-      #   team.should_have_at_least(10).players
+      #   receiver.should =~ regexp
+      #     => Passes if (receiver =~ regexp)
       #
-      # Passes if team.players.size == 10 (or more)
+      # See Spec::Matchers for more information about matchers
       #
-      # Fails if team.players.size == 9 (or less)
+      # == Warning
       #
-      # Works for collections with size() and/or length() methods.
-      def should_have_at_least(expected)
-        should.have.at_least(expected)
+      # NOTE that this does NOT support receiver.should != expected.
+      # Instead, use receiver.should_not == expected
+      def should(matcher=nil, &block)
+        return ExpectationMatcherHandler.handle_matcher(self, matcher, &block) if matcher
+        Should::Should.new(self)
       end
 
-      # Specify that the receiver should have at most a
-      # specified number of items in a named collection. For example:
+      # :call-seq:
+      #   should_not(matcher)
+      #   should_not == expected
+      #   should_not =~ expected
       #
-      #   team.should_have_at_most(10).players
+      #   receiver.should_not(matcher)
+      #     => Passes unless matcher.matches?(receiver)
       #
-      # Passes if team.players.size == 10 (or less)
+      #   receiver.should_not == expected
+      #     => Passes unless (receiver == expected)
       #
-      # Fails if team.players.size == 11 (or more)
+      #   receiver.should_not =~ regexp
+      #     => Passes unless (receiver =~ regexp)
       #
-      # Works for collections with size() and/or length() methods.
-      def should_have_at_most(expected)
-        should.have.at_most(expected)
+      # See Spec::Matchers for more information about matchers
+      def should_not(matcher=nil, &block)
+        return NegativeExpectationMatcherHandler.handle_matcher(self, matcher, &block) if matcher
+        should.not
       end
 
-      # Passes if receiver.include?(expected)
-      def should_include(expected)
-        should.include(expected)
-      end
+      deprecated do
+        # Deprecated: use should have(n).items (see Spec::Matchers)
+        # This will be removed in 0.9
+        def should_have(expected)
+          should.have(expected)
+        end
+        alias_method :should_have_exactly, :should_have
 
-      # Passes unless receiver.include?(expected)
-      def should_not_include(expected)
-        should.not.include(expected)
-      end
-    
-      def should_be(expected = :___no_arg)
-        should.be(expected)
-      end
-      
-      def should_not_be(expected = :___no_arg)
-        should.not.be(expected)
-      end
-      
-      # Passes if &block returns true
-      def should_satisfy(&block)
-        should.satisfy(&block)
-      end
-      
-      # Passes unless &block returns true
-      def should_not_satisfy(&block)
-        should.not.satisfy(&block)
-      end
-      
-      # Passes if receiver is an instance of expected_class
-      def should_be_an_instance_of(expected_class)
-        should.be.an_instance_of(expected_class)
-      end
-      alias_method :should_be_instance_of, :should_be_an_instance_of
-      
-      # Passes unless receiver is an instance of expected_class
-      def should_not_be_an_instance_of(expected_class)
-        should.not.be.an_instance_of(expected_class)
-      end
-      
-      # Passes if receiver is an instance of either expected_class
-      # or a subclass of expected_class
-      def should_be_a_kind_of(expected_class)
-        should.be.a_kind_of(expected_class)
-      end
-      alias_method :should_be_kind_of, :should_be_a_kind_of
-      
-      # Passes unless receiver is an instance of either expected_class
-      # or a subclass of expected_class
-      def should_not_be_a_kind_of(expected_class)
-        should.not.be.a_kind_of(expected_class)
-      end
+        # Deprecated: use should have_at_least(n).items (see Spec::Matchers)
+        # This will be removed in 0.9
+        def should_have_at_least(expected)
+          should.have.at_least(expected)
+        end
       
-      def should_respond_to(message)
-        should.respond_to(message)
-      end
+        # Deprecated: use should have_at_most(n).items (see Spec::Matchers)
+        # This will be removed in 0.9
+        def should_have_at_most(expected)
+          should.have.at_most(expected)
+        end
+
+        # Deprecated: use should include(expected) (see Spec::Matchers)
+        # This will be removed in 0.9
+        def should_include(expected)
+          should.include(expected)
+        end
+
+        # Deprecated: use should_not include(expected) (see Spec::Matchers)
+        # This will be removed in 0.9
+        def should_not_include(expected)
+          should.not.include(expected)
+        end
+
+        # Deprecated: use should be(expected) (see Spec::Matchers)
+        # This will be removed in 0.9
+        def should_be(expected = :___no_arg)
+          should.be(expected)
+        end
       
-      def should_not_respond_to(message)
-        should.not.respond_to(message)
+        # Deprecated: use should_not be(expected) (see Spec::Matchers)
+        # This will be removed in 0.9
+        def should_not_be(expected = :___no_arg)
+          should_not.be(expected)
+        end
       end
     end
   end
@@ -155,7 +99,11 @@ end
 
 class Object
   include Spec::Expectations::ObjectExpectations
-  include Spec::Expectations::UnderscoreSugar
+  deprecated do
+    include Spec::Expectations::UnderscoreSugar
+  end
 end
 
-Object.handle_underscores_for_rspec!
+deprecated do
+  Object.handle_underscores_for_rspec!
+end

data/lib/spec/expectations/extensions/string_and_symbol.rb

@@ -0,0 +1,17 @@
+module Spec
+  module Expectations
+    module StringHelpers
+      def starts_with?(prefix)
+        to_s[0..(prefix.length - 1)] == prefix
+      end
+    end
+  end
+end
+
+class String
+  include Spec::Expectations::StringHelpers
+end
+
+class Symbol
+  include Spec::Expectations::StringHelpers
+end

data/lib/spec/expectations/handler.rb

@@ -0,0 +1,47 @@
+module Spec
+  module Expectations
+    
+    module MatcherHandlerHelper
+      def describe(matcher)
+        matcher.respond_to?(:description) ? matcher.description : "[#{matcher.class.name} does not provide a description]"
+      end
+    end
+    
+    class ExpectationMatcherHandler
+      class << self
+        include MatcherHandlerHelper
+        def handle_matcher(actual, matcher, &block)
+          unless matcher.nil?
+            match = matcher.matches?(actual, &block)
+            ::Spec::Matchers.generated_description = "should #{describe(matcher)}"
+            Spec::Expectations.fail_with(matcher.failure_message) unless match
+          end
+        end
+      end
+    end
+
+    class NegativeExpectationMatcherHandler
+      class << self
+        include MatcherHandlerHelper
+        def handle_matcher(actual, matcher, &block)
+          unless matcher.nil?
+            unless matcher.respond_to?(:negative_failure_message)
+              Spec::Expectations.fail_with(
+  <<-EOF
+  Matcher does not support should_not.
+  See Spec::Matchers for more information
+  about matchers.
+  EOF
+  )
+            end
+            match = matcher.matches?(actual, &block)
+            ::Spec::Matchers.generated_description = "should not #{describe(matcher)}"
+            Spec::Expectations.fail_with(matcher.negative_failure_message) if match
+          end
+        end
+      end
+    end
+
+  end
+end
+

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

@@ -3,14 +3,7 @@ module Spec
     module Should
       class Base
         
-        def <(expected)
-          __delegate_method_missing_to_target "<", "<", expected
-        end
-        
-        def <=(expected)
-          __delegate_method_missing_to_target "<=", "<=", expected
-        end
-        
+        #== and =~ will stay after the new syntax
         def ==(expected)
           __delegate_method_missing_to_target "==", "==", expected
         end
@@ -19,41 +12,51 @@ module Spec
           __delegate_method_missing_to_target "=~", "=~", expected
         end
         
-        def >=(expected)
-          __delegate_method_missing_to_target ">=", ">=", expected
-        end
+        #<, <=, >=, > are all implemented in Spec::Matchers::Be
+        # and will be removed with 0.9
+        deprecated do
+          def <(expected)
+            __delegate_method_missing_to_target "<", "<", expected
+          end
+        
+          def <=(expected)
+            __delegate_method_missing_to_target "<=", "<=", expected
+          end
+        
+          def >=(expected)
+            __delegate_method_missing_to_target ">=", ">=", expected
+          end
         
-        def >(expected)
-          __delegate_method_missing_to_target ">", ">", expected
+          def >(expected)
+            __delegate_method_missing_to_target ">", ">", expected
+          end
         end
 
         def default_message(expectation, expected=nil)
-          Spec::Expectations.build_message(@target, expectation, expected)
-         end
+          return "expected #{expected.inspect}, got #{@target.inspect} (using #{expectation})" if expectation == '=='
+          "expected #{expectation} #{expected.inspect}, got #{@target.inspect}" unless expectation == '=='
+        end
 
-        def fail_with_message(message)
-          Spec::Expectations.fail_with(message)
+        def fail_with_message(message, expected=nil, target=nil)
+          Spec::Expectations.fail_with(message, expected, target)
         end
     
         def find_supported_sym(original_sym)
           ["#{original_sym}?", "#{original_sym}s?"].each do |alternate_sym|
             return alternate_sym.to_s if @target.respond_to?(alternate_sym.to_s)
           end
-          return ["<","<=",">=",">","==","=~"].include?(original_sym) ? original_sym : "#{original_sym}?"
         end
 
-        def method_missing(original_sym, *args, &block)
-          if original_sym.to_s =~ /^not_/
-            return Not.new(@target).__send__(original_sym.to_s[4..-1].to_sym, *args, &block)
-          end
-          if original_sym.to_s =~ /^be_/
-            @be_seen = true
-            return __send__(original_sym.to_s[3..-1].to_sym, *args, &block)
-          end
-          if original_sym.to_s =~ /^have_/
-            return have.__send__(original_sym.to_s[5..-1].to_sym, *args, &block)
+        deprecated do
+          def method_missing(original_sym, *args, &block)
+            if original_sym.to_s =~ /^not_/
+              return Not.new(@target).__send__(sym, *args, &block)
+            end
+            if original_sym.to_s =~ /^have_/
+              return have.__send__(original_sym.to_s[5..-1].to_sym, *args, &block)
+            end
+            __delegate_method_missing_to_target original_sym, find_supported_sym(original_sym), *args
           end
-          __delegate_method_missing_to_target original_sym, find_supported_sym(original_sym), *args
         end
       end
     end

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

@@ -58,7 +58,7 @@ module Spec
       class NotChange < Change
         def evaluate_change
           if @before_change != @after_change
-            fail_with_message "#{@message} should not have changed, but is now #{@after_change.inspect}"
+            fail_with_message "#{@message} should not have changed, but did change from #{@before_change.inspect} to #{@after_change.inspect}"
           end
         end
       end

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

@@ -22,7 +22,7 @@ module Spec
           elsif @item_handler.wants_to_handle(sym)
             @item_handler.handle_message(sym, *args)
           else
-            raise NoMethodError.new("#{@target.inspect} does not respond to `#{sym}' or `has_#{sym}?'")
+            Spec::Expectations.fail_with("target does not respond to #has_#{sym}?")
           end
         end
       end
@@ -72,10 +72,10 @@ module Spec
         end
 
         def build_message(sym, args)
-          message = "#{@target.inspect} should have"
+          message = "expected"
           message += " at least" if @at_least
           message += " at most" if @at_most
-          message += " #{@expected} #{sym} (has #{actual_size_of(collection(sym, args))})"
+          message += " #{@expected} #{sym}, got #{actual_size_of(collection(sym, args))}"
         end
 
         def as_specified?(sym, args)
@@ -103,10 +103,6 @@ module Spec
           @target = target
         end
 
-        def build_message(sym, args)
-          "#{@target.inspect} #{item_expectation} #{sym}: #{args.collect{|arg| arg.inspect}.join(', ')}"
-        end
-        
         def fail_with(message)
           Spec::Expectations.fail_with(message)
         end
@@ -114,21 +110,17 @@ module Spec
       
       class PositiveItemHandler < ItemHandler
         def handle_message(sym, *args)
-          fail_with(build_message(sym, args)) unless @target.send("has_#{sym}?", *args)
-        end
-        
-        def item_expectation
-          "should have"
+          fail_with(
+          "expected #has_#{sym}?(#{args.collect{|arg| arg.inspect}.join(', ')}) to return true, got false"
+          ) unless @target.send("has_#{sym}?", *args)
         end
       end
       
       class NegativeItemHandler < ItemHandler
         def handle_message(sym, *args)
-          fail_with(build_message(sym, args)) if @target.send("has_#{sym}?", *args)
-        end
-        
-        def item_expectation
-          "should not have"
+          fail_with(
+          "expected #has_#{sym}?(#{args.collect{|arg| arg.inspect}.join(', ')}) to return false, got true"
+          ) if @target.send("has_#{sym}?", *args)
         end
       end
     end