rspec-expectations 2.0.0.beta.22 → 2.6.0

data/lib/rspec/matchers/change.rb

@@ -1,23 +1,21 @@
 module RSpec
   module Matchers
-    
-    #Based on patch from Wilson Bilkovich
     class Change #:nodoc:
       def initialize(receiver=nil, message=nil, &block)
         @message = message
         @value_proc = block || lambda {receiver.__send__(message)}
-        @to = @from = @minimum = @maximum = @amount = nil
-        @given_from = @given_to = false
+        @expected_after = @expected_before = @minimum = @maximum = @expected_delta = nil
+        @eval_before = @eval_after = false
       end
       
       def matches?(event_proc)
         raise_block_syntax_error if block_given?
         
-        @before = evaluate_value_proc
+        @actual_before = evaluate_value_proc
         event_proc.call
-        @after = evaluate_value_proc
-        
-        changed? && matches_before? && matches_after? && matches_amount? && matches_min? && matches_max?
+        @actual_after = evaluate_value_proc
+      
+        (!change_expected? || changed?) && matches_before? && matches_after? && matches_expected_delta? && matches_min? && matches_max?
       end
 
       def raise_block_syntax_error
@@ -28,35 +26,40 @@ MESSAGE
       end
       
       def evaluate_value_proc
-        @value_proc.call
+        case val = @value_proc.call
+        when Array, Hash
+          val.dup
+        else
+          val
+        end
       end
       
       def failure_message_for_should
-        if @given_from && @before != @from
-          "#{message} should have initially been #{@from.inspect}, but was #{@before.inspect}"
-        elsif @given_to && @to != @after
-          "#{message} should have been changed to #{@to.inspect}, but is now #{@after.inspect}"
-        elsif @amount
-          "#{message} should have been changed by #{@amount.inspect}, but was changed by #{actual_delta.inspect}"
+        if @eval_before && !expected_matches_actual?(@expected_before, @actual_before)
+          "#{message} should have initially been #{@expected_before.inspect}, but was #{@actual_before.inspect}"
+        elsif @eval_after && !expected_matches_actual?(@expected_after, @actual_after)
+          "#{message} should have been changed to #{@expected_after.inspect}, but is now #{@actual_after.inspect}"
+        elsif @expected_delta
+          "#{message} should have been changed by #{@expected_delta.inspect}, but was changed by #{actual_delta.inspect}"
         elsif @minimum
           "#{message} should have been changed by at least #{@minimum.inspect}, but was changed by #{actual_delta.inspect}"
         elsif @maximum
           "#{message} should have been changed by at most #{@maximum.inspect}, but was changed by #{actual_delta.inspect}"
         else
-          "#{message} should have changed, but is still #{@before.inspect}"
+          "#{message} should have changed, but is still #{@actual_before.inspect}"
         end
       end
       
       def actual_delta
-        @after - @before
+        @actual_after - @actual_before
       end
       
       def failure_message_for_should_not
-        "#{message} should not have changed, but did change from #{@before.inspect} to #{@after.inspect}"
+        "#{message} should not have changed, but did change from #{@actual_before.inspect} to #{@actual_after.inspect}"
       end
       
-      def by(amount)
-        @amount = amount
+      def by(expected_delta)
+        @expected_delta = expected_delta
         self
       end
       
@@ -71,14 +74,14 @@ MESSAGE
       end      
       
       def to(to)
-        @given_to = true
-        @to = to
+        @eval_after = true
+        @expected_after = to
         self
       end
       
-      def from (from)
-        @given_from = true
-        @from = from
+      def from (before)
+        @eval_before = true
+        @expected_before = before
         self
       end
       
@@ -92,39 +95,59 @@ MESSAGE
         @message || "result"
       end
 
+      def change_expected?
+        @expected_delta != 0
+      end
+
       def changed?
-        @before != @after
+        @actual_before != @actual_after
       end
 
       def matches_before?
-        @given_from ? @from == @before : true
+        @eval_before ? expected_matches_actual?(@expected_before, @actual_before) : true
       end
 
       def matches_after?
-        @given_to ? @to == @after : true
+        @eval_after ? expected_matches_actual?(@expected_after, @actual_after) : true
       end
 
-      def matches_amount?
-        @amount ? (@before + @amount == @after) : true
+      def matches_expected_delta?
+        @expected_delta ? (@actual_before + @expected_delta == @actual_after) : true
       end
 
       def matches_min?
-        @minimum ? (@after - @before >= @minimum) : true
+        @minimum ? (@actual_after - @actual_before >= @minimum) : true
       end
 
       def matches_max?
-        @maximum ? (@after - @before <= @maximum) : true
+        @maximum ? (@actual_after - @actual_before <= @maximum) : true
       end
       
+      def expected_matches_actual?(expected, actual)
+        expected === actual
+      end
     end
     
     # :call-seq:
-    #   should change(receiver, message, &block)
-    #   should change(receiver, message, &block).by(value)
-    #   should change(receiver, message, &block).from(old).to(new)
-    #   should_not change(receiver, message, &block)
+    #   should change(receiver, message)
+    #   should change(receiver, message).by(value)
+    #   should change(receiver, message).from(old).to(new)
+    #   should_not change(receiver, message)
     #
-    # Allows you to specify that a Proc will cause some value to change.
+    #   should change {...}
+    #   should change {...}.by(value)
+    #   should change {...}.from(old).to(new)
+    #   should_not change {...}
+    #
+    # Applied to a proc, specifies that its execution will cause some value to
+    # change.
+    #
+    # You can either pass <tt>receiver</tt> and <tt>message</tt>, or a block,
+    # but not both.
+    #
+    # When passing a block, it must use the <tt>{ ... }</tt> format, not
+    # do/end, as <tt>{ ... }</tt> binds to the +change+ method, whereas do/end
+    # would errantly bind to the +should+ or +should_not+ method.
     #
     # == Examples
     #
@@ -157,22 +180,24 @@ MESSAGE
     #     employee.develop_great_new_social_networking_app
     #   }.should change(employee, :title).from("Mail Clerk").to("CEO")
     #
-    # Evaluates <tt>receiver.message</tt> or <tt>block</tt> before and after
-    # it evaluates the c object (generated by the lambdas in the examples
-    # above).
+    #   lambda {
+    #     doctor.leave_office
+    #   }.should change(doctor, :sign).from(/is in/).to(/is out/)
     #
-    # Then compares the values before and after the <tt>receiver.message</tt>
-    # and evaluates the difference compared to the expected difference.
+    #   user = User.new(:type => "admin")
+    #   lambda {
+    #     user.symbolize_type
+    #   }.should change(user, :type).from(String).to(Symbol)
     #
-    # == WARNING
-    # <tt>should_not change</tt> only supports the form with no
-    # subsequent calls to <tt>by</tt>, <tt>by_at_least</tt>,
-    # <tt>by_at_most</tt>, <tt>to</tt> or <tt>from</tt>.
+    # == Notes
     #
-    # blocks passed to <tt>should</tt> <tt>change</tt> and <tt>should_not</tt>
-    # <tt>change</tt> must use the <tt>{}</tt> form (<tt>do/end</tt> is not
-    # supported).
+    # Evaluates <tt>receiver.message</tt> or <tt>block</tt> before and after it
+    # evaluates the proc object (generated by the lambdas in the examples
+    # above).
     #
+    # <tt>should_not change</tt> only supports the form with no subsequent
+    # calls to <tt>by</tt>, <tt>by_at_least</tt>, <tt>by_at_most</tt>,
+    # <tt>to</tt> or <tt>from</tt>.
     def change(receiver=nil, message=nil, &block)
       Matchers::Change.new(receiver, message, &block)
     end

data/lib/rspec/matchers/cover.rb

@@ -0,0 +1,35 @@
+module RSpec
+  module Matchers
+    # :call-seq:
+    #   should cover(expected)
+    #   should_not cover(expected)
+    #
+    # Passes if actual covers expected. This works for
+    # Ranges. You can also pass in multiple args
+    # and it will only pass if all args are found in Range.
+    #
+    # == Examples
+    #   (1..10).should cover(5)
+    #   (1..10).should cover(4, 6)
+    #   (1..10).should cover(4, 6, 11) # will fail
+    #   (1..10).should_not cover(11)
+    #   (1..10).should_not cover(5)    # will fail
+    #
+    # == Warning: Ruby >= 1.9 only
+    def cover(*values)
+      Matcher.new :cover, *values do |*_values|
+        match_for_should do |range|
+          _values.all? &covered_by(range)
+        end
+
+        match_for_should_not do |range|
+          _values.none? &covered_by(range)
+        end
+
+        def covered_by(range)
+          lambda {|value| range.cover?(value)}
+        end
+      end
+    end
+  end
+end

data/lib/rspec/matchers/exist.rb

@@ -4,11 +4,21 @@ module RSpec
     #   should exist
     #   should_not exist
     #
-    # Passes if actual.exist?
-    def exist(arg=nil)
+    # Passes if actual.exist? or actual.exists?
+    def exist(*args)
       Matcher.new :exist do
         match do |actual|
-          arg ? actual.exist?(arg) : actual.exist?
+          predicates = [:exist?, :exists?].select { |p| actual.respond_to?(p) }
+          existance_values = predicates.map { |p| actual.send(p, *args) }
+          uniq_truthy_values = existance_values.map { |v| !!v }.uniq
+
+          case uniq_truthy_values.size
+            when 0; raise NoMethodError.new("#{actual.inspect} does not respond to either #exist? or #exists?")
+            when 1; existance_values.first
+            else raise "#exist? and #exists? returned different values:\n\n" +
+                       " exist?: #{existance_values.first}\n" +
+                       "exists?: #{existance_values.last}"
+          end
         end
       end
     end

data/lib/rspec/matchers/has.rb

@@ -1,35 +1,39 @@
 module RSpec
   module Matchers
-    
     class Has
-      
       def initialize(expected, *args)
         @expected, @args = expected, args
       end
-      
+
       def matches?(actual)
         actual.__send__(predicate(@expected), *@args)
       end
-      
+
       def failure_message_for_should
         "expected ##{predicate(@expected)}(#{@args[0].inspect}) to return true, got false"
       end
-      
+
       def failure_message_for_should_not
         "expected ##{predicate(@expected)}(#{@args[0].inspect}) to return false, got true"
       end
-      
+
       def description
-        "have key #{@args[0].inspect}"
+        [method_description(@expected), args_description(@args)].compact.join(' ')
       end
-    
+
     private
-    
       def predicate(sym)
         "#{sym.to_s.sub("have_","has_")}?".to_sym
       end
-      
+
+      def method_description(method)
+        method.to_s.gsub('_', ' ')
+      end
+
+      def args_description(args)
+        return nil if args.empty?
+        args.map { |arg| arg.inspect }.join(', ')
+      end
     end
-    
   end
 end

data/lib/rspec/matchers/have.rb

@@ -4,7 +4,7 @@ module RSpec
       def initialize(expected, relativity=:exactly)
         @expected = (expected == :no ? 0 : expected)
         @relativity = relativity
-        @actual = nil
+        @actual = @collection_name = @plural_collection_name = nil
       end
     
       def relativities
@@ -73,10 +73,10 @@ EOF
     
       private
       
-      def method_missing(sym, *args, &block)
-        @collection_name = sym
-        if inflector = (defined?(ActiveSupport::Inflector) ? ActiveSupport::Inflector : (defined?(Inflector) ? Inflector : nil))
-          @plural_collection_name = inflector.pluralize(sym.to_s)
+      def method_missing(method, *args, &block)
+        @collection_name = method
+        if inflector = (defined?(ActiveSupport::Inflector) && ActiveSupport::Inflector.respond_to?(:pluralize) ? ActiveSupport::Inflector : (defined?(Inflector) ? Inflector : nil))
+          @plural_collection_name = inflector.pluralize(method.to_s)
         end
         @args = args
         @block = block

data/lib/rspec/matchers/include.rb

@@ -18,10 +18,21 @@ module RSpec
     #   "spread".should_not include("red")
     def include(*expected)
       Matcher.new :include, *expected do |*_expected|
-        match do |actual|
-          _expected.all? do |expected|
+
+        diffable
+
+        match_for_should do |actual|
+          perform_match(:all?, :all?, actual, _expected)
+        end
+
+        match_for_should_not do |actual|
+          perform_match(:none?, :any?, actual, _expected)
+        end
+
+        def perform_match(predicate, hash_predicate, actual, _expected)
+          _expected.send(predicate) do |expected|
             if comparing_hash_values?(actual, expected)
-              expected.all? {|k,v| actual[k] == v}
+              expected.send(hash_predicate) {|k,v| actual[k] == v}
             elsif comparing_hash_keys?(actual, expected)
               actual.has_key?(expected)
             else
@@ -37,9 +48,7 @@ module RSpec
         def comparing_hash_values?(actual, expected) # :nodoc:
           actual.is_a?(Hash) && expected.is_a?(Hash)
         end
-
       end
-
     end
   end
 end

data/lib/rspec/matchers/matcher.rb

@@ -11,7 +11,9 @@ module RSpec
         @expected = expected
         @actual   = nil
         @diffable = false
-        @expected_exception, @rescued_exception = nil
+        @expected_exception, @rescued_exception = nil, nil
+        @match_for_should_not_block = 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,7 +24,7 @@ module RSpec
         end
       end
       
-      #Used internally by objects returns by +should+ and +should_not+.
+      #Used internally by +should+ and +should_not+.
       def matches?(actual)
         @actual = actual
         if @expected_exception
@@ -41,10 +43,32 @@ module RSpec
         end
       end
 
+      # Used internally by +should_not+
+      def does_not_match?(actual)
+        @actual = actual
+        @match_for_should_not_block ?
+          instance_exec(actual, &@match_for_should_not_block) :
+          !matches?(actual)
+      end
+
+      def include(*args)
+        singleton_class.__send__(:include, *args)
+      end
+
+      def define_method(name, &block) # :nodoc:
+        singleton_class.__send__(:define_method, name, &block)
+      end
+
       # See RSpec::Matchers
       def match(&block)
         @match_block = block
       end
+      alias match_for_should match
+
+      # See RSpec::Matchers
+      def match_for_should_not(&block)
+        @match_for_should_not_block = block
+      end
 
       # See RSpec::Matchers
       def match_unless_raises(exception=Exception, &block)
@@ -79,21 +103,19 @@ module RSpec
       
       # See RSpec::Matchers
       def chain(method, &block)
-        self.class.class_eval do
-          define_method method do |*args|
-            block.call(*args)
-            self
-          end
+        define_method method do |*args|
+          block.call(*args)
+          self
         end
       end
       
     private
 
-      def method_missing(name, *args, &block)
-        if $matcher_execution_context.respond_to?(name)
-          $matcher_execution_context.send name, *args, &block
+      def method_missing(method, *args, &block)
+        if $matcher_execution_context.respond_to?(method)
+          $matcher_execution_context.send method, *args, &block
         else
-          super(name, *args, &block)
+          super(method, *args, &block)
         end
       end
     
@@ -110,8 +132,7 @@ module RSpec
         # cause features to fail and that will make users unhappy. So don't.
         orig_private_methods = private_methods
         yield
-        st = (class << self; self; end)
-        (private_methods - orig_private_methods).each {|m| st.__send__ :public, m}
+        (private_methods - orig_private_methods).each {|m| singleton_class.__send__ :public, m}
       end
 
       def cache_or_call_cached(key, &block)
@@ -134,6 +155,11 @@ module RSpec
         to_sentence(@expected)
       end
 
+      unless method_defined?(:singleton_class)
+        def singleton_class
+          class << self; self; end
+        end
+      end
     end
   end
 end

data/lib/rspec/matchers/method_missing.rb

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

data/lib/rspec/matchers/operator_matcher.rb

@@ -29,6 +29,15 @@ module RSpec
             eval_match(@actual, operator, expected)
           end
         end
+
+        negative_operator = operator.sub(/^=/, '!')
+        if negative_operator != operator && respond_to?(negative_operator)
+          define_method(negative_operator) do |expected|
+            opposite_should = ::RSpec::Matchers.last_should == :should ? :should_not : :should
+            raise "RSpec does not support `#{::RSpec::Matchers.last_should} #{negative_operator} expected`.  " +
+                  "Use `#{opposite_should} #{operator} expected` instead."
+          end
+        end
       end
 
       ['==', '===', '=~', '>', '>=', '<', '<='].each do |operator|
@@ -58,9 +67,9 @@ module RSpec
         if actual.__send__(operator, expected)
           true
         elsif ['==','===', '=~'].include?(operator)
-          fail_with_message("expected: #{expected.inspect},\n     got: #{actual.inspect} (using #{operator})") 
+          fail_with_message("expected: #{expected.inspect}\n     got: #{actual.inspect} (using #{operator})") 
         else
-          fail_with_message("expected: #{operator} #{expected.inspect},\n     got: #{operator.gsub(/./, ' ')} #{actual.inspect}")
+          fail_with_message("expected: #{operator} #{expected.inspect}\n     got: #{operator.gsub(/./, ' ')} #{actual.inspect}")
         end
       end
 
@@ -69,7 +78,7 @@ module RSpec
     class NegativeOperatorMatcher < OperatorMatcher #:nodoc:
       def __delegate_operator(actual, operator, expected)
         return false unless actual.__send__(operator, expected)
-        return fail_with_message("expected not: #{operator} #{expected.inspect},\n         got: #{operator.gsub(/./, ' ')} #{actual.inspect}")
+        return fail_with_message("expected not: #{operator} #{expected.inspect}\n         got: #{operator.gsub(/./, ' ')} #{actual.inspect}")
       end
 
     end

data/lib/rspec/matchers/respond_to.rb

@@ -5,23 +5,22 @@ module RSpec
       def initialize(*names)
         @names = names
         @expected_arity = nil
-        @names_not_responded_to = []
       end
       
       def matches?(actual)
-        @actual = actual
-        @names.each do |name|
-          @names_not_responded_to << name unless actual.respond_to?(name) && matches_arity?(actual, name)
-        end
-        return @names_not_responded_to.empty?
+        find_failing_method_names(actual, :reject).empty?
+      end
+
+      def does_not_match?(actual)
+        find_failing_method_names(actual, :select).empty?
       end
       
       def failure_message_for_should
-        "expected #{@actual.inspect} to respond to #{@names_not_responded_to.collect {|name| name.inspect }.join(', ')}#{with_arity}"
+        "expected #{@actual.inspect} to respond to #{@failing_method_names.collect {|name| name.inspect }.join(', ')}#{with_arity}"
       end
       
       def failure_message_for_should_not
-        "expected #{@actual.inspect} not to respond to #{@names.collect {|name| name.inspect }.join(', ')}"
+        failure_message_for_should.sub(/to respond to/, 'not to respond to')
       end
       
       def description
@@ -39,9 +38,24 @@ module RSpec
       alias :arguments :argument
       
     private
+
+      def find_failing_method_names(actual, filter_method)
+        @actual = actual
+        @failing_method_names = @names.send(filter_method) do |name|
+          @actual.respond_to?(name) && matches_arity?(actual, name)
+        end
+      end
       
       def matches_arity?(actual, name)
-        @expected_arity.nil?? true : @expected_arity == actual.method(name).arity 
+        return true unless @expected_arity
+
+        actual_arity = actual.method(name).arity
+        if actual_arity < 0
+          # ~ inverts the one's complement and gives us the number of required args
+          ~actual_arity <= @expected_arity
+        else
+          actual_arity == @expected_arity
+        end
       end
       
       def with_arity

data/lib/rspec/matchers/satisfy.rb

@@ -19,6 +19,10 @@ module RSpec
       def failure_message_for_should_not
         "expected #{@actual} not to satisfy block"
       end
+
+      def description
+        "satisfy block"
+      end
     end
     
     # :call-seq: