rspec 0.7.2 → 0.7.5.1

data/lib/spec/expectations/diff.rb

@@ -9,23 +9,19 @@ module Spec
           @@differ = differ
         end
 
-        unless defined?(RSPEC_TESTING)
-          alias old_default_message default_message
-          def default_message(expectation, expected=:no_expectation_specified)
-            result = old_default_message(expectation, expected)
-
-            if expected != :no_expectation_specified
-              if expected.is_a?(String)
-                result << "\nDiff:" << @@differ.diff_as_string(@target.to_s, expected)
-              elsif ! @target.is_a? Proc
-                result << "\nDiff:" << @@differ.diff_as_object(@target,expected)
-              end
+        alias old_default_message default_message
+        def default_message(expectation, expected=:no_expectation_specified)
+          result = old_default_message(expectation, expected)
+          if expected != :no_expectation_specified
+            if expected.is_a?(String)
+              result << "\nDiff:" << @@differ.diff_as_string(@target.to_s, expected) unless @@differ.nil?
+            elsif ! @target.is_a? Proc
+              result << "\nDiff:" << @@differ.diff_as_object(@target, expected) unless @@differ.nil?
             end
-
-            result
           end
-        end
 
+          result
+        end
       end
     end
   end

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

@@ -1,5 +1,19 @@
-class Numeric
-  def close?(other, precision)
-    (self - other).abs < precision
+module Spec
+  module Expectations
+    module NumericExpectations
+      # Passes if receiver is less than +-delta away from other
+      def should_be_close(other, delta)
+        should.be._close_for_rspec(other, delta)
+      end
+
+      private
+      def _close_for_rspec?(other, delta)
+        (self - other).abs < delta
+      end
+    end
   end
+end
+
+class Numeric
+  include Spec::Expectations::NumericExpectations
 end

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

@@ -1,9 +1,154 @@
 module Spec
   module Expectations
+    # rspec adds all of these expectations 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
+      #
+      # Passes if team.players.size == 40.
+      #
+      # 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:
+      #
+      #   team.should_have_at_least(10).players
+      #
+      # Passes if team.players.size == 10 (or more)
+      #
+      # Fails if team.players.size == 9 (or less)
+      #
+      # Works for collections with size() and/or length() methods.
+      def should_have_at_least(expected)
+        should.have.at_least(expected)
+      end
+
+      # Specify that the receiver should have at most a
+      # specified number of items in a named collection. For example:
+      #
+      #   team.should_have_at_most(10).players
+      #
+      # Passes if team.players.size == 10 (or less)
+      #
+      # Fails if team.players.size == 11 (or more)
+      #
+      # Works for collections with size() and/or length() methods.
+      def should_have_at_most(expected)
+        should.have.at_most(expected)
+      end
+
+      # Passes if receiver.include?(expected)
+      def should_include(expected)
+        should.include(expected)
+      end
+
+      # 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
+      
+      def should_respond_to(message)
+        should.respond_to(message)
+      end
+      
+      def should_not_respond_to(message)
+        should.not.respond_to(message)
+      end
     end
   end
 end

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

@@ -0,0 +1,57 @@
+module Spec
+  module Expectations
+    module ProcExpectations
+      # Given a receiver and a message (Symbol), specifies that the result
+      # of sending that message that receiver should change after
+      # executing the proc.
+      #
+      #   lambda { @team.add player }.should_change(@team.players, :size)
+      #   lambda { @team.add player }.should_change(@team.players, :size).by(1)
+      #   lambda { @team.add player }.should_change(@team.players, :size).to(23)
+      #   lambda { @team.add player }.should_change(@team.players, :size).from(22).to(23)
+      #
+      # You can use a block instead of a message and receiver.
+      #
+      #   lambda { @team.add player }.should_change{@team.players.size}
+      #   lambda { @team.add player }.should_change{@team.players.size}.by(1)
+      #   lambda { @team.add player }.should_change{@team.players.size}.to(23)
+      #   lambda { @team.add player }.should_change{@team.players.size}.from(22).to(23)
+      def should_change(receiver=nil, message=nil, &block)
+        should.change(receiver, message, &block)
+      end
+  
+      # Given a receiver and a message (Symbol), specifies that the result
+      # of sending that message that receiver should NOT change after
+      # executing the proc.
+      #
+      #   lambda { @team.add player }.should_not_change(@team.players, :size)
+      #
+      # You can use a block instead of a message and receiver.
+      #
+      #   lambda { @team.add player }.should_not_change{@team.players.size}
+      def should_not_change(receiver, message)
+        should.not.change(receiver, message)
+      end
+
+      def should_raise(exception=Exception, message=nil)
+        should.raise(exception, message)
+      end
+      
+      def should_not_raise(exception=Exception, message=nil)
+        should.not.raise(exception, message)
+      end
+      
+      def should_throw(symbol)
+        should.throw(symbol)
+      end
+      
+      def should_not_throw(symbol=:___this_is_a_symbol_that_will_likely_never_occur___)
+        should.not.throw(symbol)
+      end
+    end
+  end
+end
+
+class Proc
+  include Spec::Expectations::ProcExpectations
+end

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

@@ -0,0 +1,22 @@
+module Spec
+  module Expectations
+    # rspec adds all of these expectations to every String object.
+    module StringExpectations
+
+      # Passes if receiver =~ expression
+      def should_match(expression)
+        should.match(expression)
+      end
+
+      # Passes unless receiver =~ expression
+      def should_not_match(expression)
+        should.not.match(expression)
+      end
+
+    end
+  end
+end
+
+class String
+  include Spec::Expectations::StringExpectations
+end

data/lib/spec/expectations/extensions.rb

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

data/lib/spec/expectations/message_builder.rb

@@ -0,0 +1,13 @@
+module Spec
+  module Expectations
+    # TODO - DAC - This is mid-refactoring right now - I'd like to get ALL failure messages
+    # for rspec and rspec_on_rails generated by this class so that we can
+    # make any enhancements, improvements in one place. Right now it's pretty
+    # scattered.
+    class MessageBuilder
+      def build_message(actual, expectation, expected)
+        "#{actual.inspect} #{expectation} #{expected.inspect}"
+      end
+    end
+  end
+end

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

@@ -2,26 +2,44 @@ module Spec
   module Expectations
     module Should
       class Base
+        
+        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
+        end
+        
+        def >=(expected)
+          __delegate_method_missing_to_target ">=", ">=", expected
+        end
+        
+        def >(expected)
+          __delegate_method_missing_to_target ">", ">", expected
+        end
 
-        instance_methods.each { |m| undef_method m unless m =~ /^(__|\w)/ }
-
-        def default_message(expectation, expected=:no_expectation_specified)
-          message = "#{@target.inspect_for_expectation_not_met_error} #{expectation}"
-          if (expected != :no_expectation_specified)
-            message << " " << expected.inspect_for_expectation_not_met_error
-          end
-          message
+        def default_message(expectation, expected=nil)
+          Spec::Expectations.build_message(@target, expectation, expected)
          end
 
         def fail_with_message(message)
-          Kernel::raise(Spec::Expectations::ExpectationNotMetError.new(message))
+          Spec::Expectations.fail_with(message)
         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 original_sym.supported_by_rspec? ? original_sym : "#{original_sym}?"
+          return ["<","<=",">=",">","==","=~"].include?(original_sym) ? original_sym : "#{original_sym}?"
         end
 
         def method_missing(original_sym, *args, &block)
@@ -29,6 +47,7 @@ module Spec
             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_/

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

@@ -0,0 +1,69 @@
+module Spec
+  module Expectations
+    module Should
+      class Change < Base
+
+        def initialize(target, receiver=nil, message=nil, &block)
+          @block = block
+          @target = target
+          @receiver = receiver
+          @message = message
+          execute_change
+          evaluate_change
+        end
+
+        def execute_change
+          @before_change = @block.nil? ? @receiver.send(@message) : @block.call
+          @target.call
+          @after_change = @block.nil? ? @receiver.send(@message) : @block.call
+        end
+        
+        def message
+          @message.nil? ? 'result' : @message
+        end
+
+        def evaluate_change
+          if @before_change == @after_change
+            fail_with_message "#{message} should have changed, but is still #{@after_change.inspect}"
+          end
+        end
+
+        def from(value)
+          if @before_change != value
+            fail_with_message "#{message} should have initially been #{value.inspect}, but was #{@before_change.inspect}"
+          end
+          self
+        end
+
+        def to(value)
+          if @after_change != value
+            fail_with_message "#{message} should have been changed to #{value.inspect}, but is now #{@after_change.inspect}"
+          end
+          self
+        end
+
+        def by(expected_delta)
+          if actual_delta != expected_delta
+            fail_with_message "#{message} should have been changed by #{expected_delta}, but was changed by #{actual_delta}"
+          end
+          self
+        end
+        
+        private
+          def actual_delta
+            @after_change - @before_change
+          end
+      end
+      
+      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}"
+          end
+        end
+      end
+
+    end
+  end
+end
+

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

@@ -1,23 +1,46 @@
 module Spec
   module Expectations
     module Should
-      class Have < Base
-
-        def initialize(target, relativity=:exactly, expected=nil, negate=false)
+      class Have
+        def initialize(target, relativity=:exactly, expected=nil)
+          @target = target
+          init_collection_handler(target, relativity, expected)
+          init_item_handler(target)
+        end
+        
+        def init_collection_handler(target, relativity, expected)
+          @collection_handler = CollectionHandler.new(target, relativity, expected)
+        end
+        
+        def init_item_handler(target)
+          @item_handler = PositiveItemHandler.new(target)
+        end
+    
+        def method_missing(sym, *args)
+          if @collection_handler.wants_to_handle(sym)
+            @collection_handler.handle_message(sym, *args)
+          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}?'")
+          end
+        end
+      end
+      
+      class NotHave < Have
+        def init_item_handler(target)
+          @item_handler = NegativeItemHandler.new(target)
+        end
+      end
+      
+      class CollectionHandler
+        def initialize(target, relativity=:exactly, expected=nil)
           @target = target
           @expected = expected == :no ? 0 : expected
           @at_least = (relativity == :at_least)
           @at_most = (relativity == :at_most)
-          @negate = negate
-        end
-    
-        def exactly(expected_number=nil)
-          @at_least = false
-          @at_most = false
-          @expected = expected_number == :no ? 0 : expected_number
-          self
         end
-
+        
         def at_least(expected_number=nil)
           @at_least = true
           @at_most = false
@@ -34,45 +57,79 @@ module Spec
 
         def method_missing(sym, *args)
           if @target.respond_to?(sym)
-            fail_with_message(build_message(sym, args)) unless as_specified?(sym, args)
-          elsif @target.respond_to?("has_#{sym}?")
-            if @negate
-              return unless @target.send("has_#{sym}?", *args)
-              fail_with_message msg(sym, args, "should not have")
-            else
-              return if @target.send("has_#{sym}?", *args)
-              fail_with_message msg(sym, args, "should have")
-            end
-          else
-            raise NoMethodError.new("#{@target.inspect} does not respond to `#{sym}' or `has_#{sym}?'")
+            handle_message(sym, *args)
           end
         end
-      
-        def msg(sym, args, text)
-          "#{@target.inspect_for_expectation_not_met_error} #{text} #{sym}: #{args.collect{|arg| arg.inspect_for_expectation_not_met_error}.join(', ')}"
+
+        def wants_to_handle(sym)
+          respond_to?(sym) || @target.respond_to?(sym)
         end
-    
-        def actual_size(collection)
-          return collection.length if collection.respond_to? :length
-          return collection.size if collection.respond_to? :size
+
+        def handle_message(sym, *args)
+          return at_least(args[0]) if sym == :at_least
+          return at_most(args[0]) if sym == :at_most
+          Spec::Expectations.fail_with(build_message(sym, args)) unless as_specified?(sym, args)
         end
-    
+
         def build_message(sym, args)
-          message = "#{@target.inspect_for_expectation_not_met_error} should have"
+          message = "#{@target.inspect} should have"
           message += " at least" if @at_least
           message += " at most" if @at_most
-          message += " #{@expected} #{sym} (has #{actual_size(collection(sym, args))})"
+          message += " #{@expected} #{sym} (has #{actual_size_of(collection(sym, args))})"
         end
-    
+
         def as_specified?(sym, args)
-          return actual_size(collection(sym, args)) >= @expected if @at_least
-          return actual_size(collection(sym, args)) <= @expected if @at_most
-          return actual_size(collection(sym, args)) == @expected
+          return actual_size_of(collection(sym, args)) >= @expected if @at_least
+          return actual_size_of(collection(sym, args)) <= @expected if @at_most
+          return actual_size_of(collection(sym, args)) == @expected
         end
 
         def collection(sym, args)
           @target.send(sym, *args)
         end
+    
+        def actual_size_of(collection)
+          return collection.length if collection.respond_to? :length
+          return collection.size if collection.respond_to? :size
+        end
+      end
+      
+      class ItemHandler
+        def wants_to_handle(sym)
+          @target.respond_to?("has_#{sym}?")
+        end
+
+        def initialize(target)
+          @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
+      end
+      
+      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"
+        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"
+        end
       end
     end
   end

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

@@ -9,7 +9,11 @@ module Spec
         end
 
         def have(expected_number=nil)
-          Have.new(@target, :exactly, expected_number, true)
+          NotHave.new(@target, :exactly, expected_number)
+        end
+
+        def change(receiver, message)
+          NotChange.new(@target, receiver, message)
         end
   
         def satisfy
@@ -64,7 +68,7 @@ module Spec
 
         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.join(', ')))))
+          fail_with_message(default_message("should not#{@be_seen ? ' be' : ''} #{original_sym}" + (args.empty? ? '' : ' ' + args[0].inspect)))
         end
       end
     end

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

@@ -1,17 +1,21 @@
 module Spec
   module Expectations
-    module Should
+    module Should # :nodoc:
       class Should < Base
 
         def initialize(target)
           @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
@@ -55,9 +59,9 @@ module Spec
           rescue exception => e
             unless message.nil?
               if message.is_a?(Regexp)
-                e.message.should_match message
+                e.message.should =~ message
               else
-                e.message.should_eql message
+                e.message.should == message
               end
             end
             return
@@ -80,4 +84,4 @@ module Spec
       end
     end
   end
-end
+end

data/lib/spec/expectations/should.rb

@@ -2,3 +2,4 @@ require 'spec/expectations/should/base'
 require 'spec/expectations/should/have'
 require 'spec/expectations/should/not'
 require 'spec/expectations/should/should'
+require 'spec/expectations/should/change'