rspec-expectations 2.8.0 → 2.9.0.rc2

data/lib/rspec/matchers/built_in/respond_to.rb

@@ -0,0 +1,73 @@
+module RSpec
+  module Matchers
+    module BuiltIn
+      class RespondTo
+        def initialize(*names)
+          @names = names
+          @expected_arity = nil
+        end
+
+        def matches?(actual)
+          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 #{@failing_method_names.collect {|name| name.inspect }.join(', ')}#{with_arity}"
+        end
+
+        def failure_message_for_should_not
+          failure_message_for_should.sub(/to respond to/, 'not to respond to')
+        end
+
+        def description
+          "respond to #{pp_names}#{with_arity}"
+        end
+
+        def with(n)
+          @expected_arity = n
+          self
+        end
+
+        def argument
+          self
+        end
+        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)
+          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
+          @expected_arity.nil?? "" :
+            " with #{@expected_arity} argument#{@expected_arity == 1 ? '' : 's'}"
+        end
+
+        def pp_names
+          # Ruby 1.9 returns the same thing for array.to_s as array.inspect, so just use array.inspect here
+          @names.length == 1 ? "##{@names.first}" : @names.inspect
+        end
+      end
+    end
+  end
+end

data/lib/rspec/matchers/built_in/satisfy.rb

@@ -0,0 +1,29 @@
+module RSpec
+  module Matchers
+    module BuiltIn
+      class Satisfy
+        def initialize(&block)
+          @block = block
+        end
+
+        def matches?(actual, &block)
+          @block = block if block
+          @actual = actual
+          @block.call(actual)
+        end
+
+        def failure_message_for_should
+          "expected #{@actual} to satisfy block"
+        end
+
+        def failure_message_for_should_not
+          "expected #{@actual} not to satisfy block"
+        end
+
+        def description
+          "satisfy block"
+        end
+      end
+    end
+  end
+end

data/lib/rspec/matchers/built_in/throw_symbol.rb

@@ -0,0 +1,93 @@
+module RSpec
+  module Matchers
+    module BuiltIn
+      class ThrowSymbol
+        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?
+              given_proc.call
+            else
+              @caught_arg = catch :proc_did_not_throw_anything do
+                catch @expected_symbol do
+                  given_proc.call
+                  throw :proc_did_not_throw_anything, :nothing_thrown
+                end
+              end
+
+              if @caught_arg == :nothing_thrown
+                @caught_arg = nil
+              else
+                @caught_symbol = @expected_symbol
+              end
+            end
+
+            # Ruby 1.8 uses NameError with `symbol'
+            # Ruby 1.9 uses ArgumentError with :symbol
+          rescue NameError, ArgumentError => e
+            unless e.message =~ /uncaught throw (`|\:)([a-zA-Z0-9_]*)(')?/
+              other_exception = e
+              raise
+            end
+            @caught_symbol = $2.to_sym
+          rescue => other_exception
+            raise
+          ensure
+            unless other_exception
+              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
+          end
+        end
+
+        def failure_message_for_should
+          "expected #{expected} to be thrown, got #{caught}"
+        end
+
+        def failure_message_for_should_not
+          "expected #{expected('no Symbol')}#{' not' if @expected_symbol} to be thrown, got #{caught}"
+        end
+
+        def description
+          "throw #{expected}"
+        end
+
+        private
+
+        def expected(symbol_desc = 'a Symbol')
+          throw_description(@expected_symbol || symbol_desc, @expected_arg)
+        end
+
+        def caught
+          throw_description(@caught_symbol || 'nothing', @caught_arg)
+        end
+
+        def throw_description(symbol, arg)
+          symbol_description = symbol.is_a?(String) ? symbol : symbol.inspect
+
+          arg_description = if arg
+                              " with #{arg.inspect}"
+                            elsif @expected_arg && @caught_symbol == @expected_symbol
+                              " with no argument"
+                            else
+                              ""
+                            end
+
+          symbol_description + arg_description
+        end
+      end
+    end
+  end
+end

data/lib/rspec/matchers/dsl.rb

@@ -4,7 +4,7 @@ module RSpec
       # Defines a custom matcher.
       # @see RSpec::Matchers
       def define(name, &declarations)
-        matcher = RSpec::Matchers::Matcher.new(name, &declarations)
+        matcher = RSpec::Matchers::DSL::Matcher.new(name, &declarations)
         define_method name do |*expected|
           $matcher_execution_context = self
           matcher.for_expected(*expected)

data/lib/rspec/matchers/matcher.rb

@@ -1,266 +1,296 @@
+require 'set'
+
 module RSpec
   module Matchers
-    # Provides the context in which the block passed to RSpec::Matchers.define
-    # will be evaluated.
-    class Matcher
-      include RSpec::Matchers::Extensions::InstanceEvalWithArgs
-      include RSpec::Matchers::Pretty
-      include RSpec::Matchers
+    module DSL
+      # Provides the context in which the block passed to RSpec::Matchers.define
+      # will be evaluated.
+      class Matcher
+        include RSpec::Matchers::Extensions::InstanceEvalWithArgs
+        include RSpec::Matchers::Pretty
+        include RSpec::Matchers
 
-      attr_reader :expected, :actual, :rescued_exception
+        attr_reader :expected, :actual, :rescued_exception
 
-      # @api private
-      def initialize(name, &declarations)
-        @name         = name
-        @declarations = declarations
-        @actual       = nil
-        @diffable     = false
-        @expected_exception, @rescued_exception = nil, nil
-        @match_for_should_not_block = nil
+        # @api private
+        def initialize(name, &declarations)
+          @name         = name
+          @declarations = declarations
+          @actual       = nil
+          @diffable     = false
+          @expected_exception, @rescued_exception = nil, nil
+          @match_for_should_not_block = nil
+          @messages = {}
+        end
 
-        @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}"},
-          :failure_message_for_should_not => lambda {|actual| "expected #{actual.inspect} not to #{name_to_sentence}#{expected_to_sentence}"}
-        }
-      end
+        PERSISENT_INSTANCE_VARIABLES = [
+          :@name, :@declarations, :@diffable, :@messages,
+          :@match_block, :@match_for_should_not_block,
+          :@expected_exception
+        ].to_set
 
-      # @api private
-      def for_expected(*expected)
-        @expected = expected
-        making_declared_methods_public do
-          instance_eval_with_args(*@expected, &@declarations)
+        # @api private
+        def for_expected(*expected)
+          @expected = expected
+          dup.instance_eval do
+            instance_variables.map {|ivar| ivar.intern}.each do |ivar|
+              instance_variable_set(ivar, nil) unless (PERSISENT_INSTANCE_VARIABLES + [:@expected]).include?(ivar)
+            end
+            making_declared_methods_public do
+              instance_eval_with_args(*@expected, &@declarations)
+            end
+            self
+          end
         end
-        self
-      end
 
-      # @api private
-      # Used internally by +should+ and +should_not+.
-      def matches?(actual)
-        @actual = actual
-        if @expected_exception
-          begin
-            instance_eval_with_args(actual, &@match_block)
-            true
-          rescue @expected_exception => @rescued_exception
-            false
-          end
-        else
-          begin
-            instance_eval_with_args(actual, &@match_block)
-          rescue RSpec::Expectations::ExpectationNotMetError
-            false
+        # @api private
+        # Used internally by +should+ and +should_not+.
+        def matches?(actual)
+          @actual = actual
+          if @expected_exception
+            begin
+              instance_eval_with_args(actual, &@match_block)
+              true
+            rescue @expected_exception => @rescued_exception
+              false
+            end
+          else
+            begin
+              instance_eval_with_args(actual, &@match_block)
+            rescue RSpec::Expectations::ExpectationNotMetError
+              false
+            end
           end
         end
-      end
 
-      # Stores the block that is used to determine whether this matcher passes
-      # or fails. The block should return a boolean value. When the matcher is
-      # passed to `should` and the block returns `true`, then the expectation
-      # passes. Similarly, when the matcher is passed to `should_not` and the
-      # block returns `false`, then the expectation passes.
-      #
-      # Use `match_for_should` when used in conjuntion with
-      # `match_for_should_not`.
-      #
-      # @example
-      #
-      #     RSpec::Matchers.define :be_even do
-      #       match do |actual|
-      #         actual.even?
-      #       end
-      #     end
-      #
-      #     4.should be_even     # passes
-      #     3.should_not be_even # passes
-      #     3.should be_even     # fails
-      #     4.should_not be_even # fails
-      #
-      # @yield [Object] actual the actual value (or receiver of should)
-      def match(&block)
-        @match_block = block
-      end
+        # Stores the block that is used to determine whether this matcher passes
+        # or fails. The block should return a boolean value. When the matcher is
+        # passed to `should` and the block returns `true`, then the expectation
+        # passes. Similarly, when the matcher is passed to `should_not` and the
+        # block returns `false`, then the expectation passes.
+        #
+        # Use `match_for_should` when used in conjuntion with
+        # `match_for_should_not`.
+        #
+        # @example
+        #
+        #     RSpec::Matchers.define :be_even do
+        #       match do |actual|
+        #         actual.even?
+        #       end
+        #     end
+        #
+        #     4.should be_even     # passes
+        #     3.should_not be_even # passes
+        #     3.should be_even     # fails
+        #     4.should_not be_even # fails
+        #
+        # @yield [Object] actual the actual value (or receiver of should)
+        def match(&block)
+          @match_block = block
+        end
 
-      alias_method :match_for_should, :match
+        alias_method :match_for_should, :match
 
-      # Use this to define the block for a negative expectation (`should_not`)
-      # when the positive and negative forms require different handling. This
-      # is rarely necessary, but can be helpful, for example, when specifying
-      # asynchronous processes that require different timeouts.
-      #
-      # @yield [Object] actual the actual value (or receiver of should)
-      def match_for_should_not(&block)
-        @match_for_should_not_block = block
-      end
+        # Use this to define the block for a negative expectation (`should_not`)
+        # when the positive and negative forms require different handling. This
+        # is rarely necessary, but can be helpful, for example, when specifying
+        # asynchronous processes that require different timeouts.
+        #
+        # @yield [Object] actual the actual value (or receiver of should)
+        def match_for_should_not(&block)
+          @match_for_should_not_block = block
+        end
 
-      # Use this instead of `match` when the block will raise an exception
-      # rather than returning false to indicate a failure.
-      #
-      # @example
-      #
-      #     RSpec::Matchers.define :accept_as_valid do |candidate_address|
-      #       match_unless_raises ValidationException do |validator|
-      #         validator.validate(candidate_address)
-      #       end
-      #     end
-      #
-      #     email_validator.should accept_as_valid("person@company.com")
-      def match_unless_raises(exception=Exception, &block)
-        @expected_exception = exception
-        match(&block)
-      end
+        # Use this instead of `match` when the block will raise an exception
+        # rather than returning false to indicate a failure.
+        #
+        # @example
+        #
+        #     RSpec::Matchers.define :accept_as_valid do |candidate_address|
+        #       match_unless_raises ValidationException do |validator|
+        #         validator.validate(candidate_address)
+        #       end
+        #     end
+        #
+        #     email_validator.should accept_as_valid("person@company.com")
+        def match_unless_raises(exception=Exception, &block)
+          @expected_exception = exception
+          match(&block)
+        end
 
-      # Customize the failure messsage to use when this matcher is invoked with
-      # `should`. Only use this when the message generated by default doesn't
-      # suit your needs.
-      #
-      # @example
-      #
-      #     RSpec::Matchers.define :have_strength do |expected|
-      #       match { ... }
-      #
-      #       failure_message_for_should do |actual|
-      #         "Expected strength of #{expected}, but had #{actual.strength}"
-      #       end
-      #     end
-      #
-      # @yield [Object] actual the actual object
-      def failure_message_for_should(&block)
-        cache_or_call_cached(:failure_message_for_should, &block)
-      end
+        # Customize the failure messsage to use when this matcher is invoked with
+        # `should`. Only use this when the message generated by default doesn't
+        # suit your needs.
+        #
+        # @example
+        #
+        #     RSpec::Matchers.define :have_strength do |expected|
+        #       match { ... }
+        #
+        #       failure_message_for_should do |actual|
+        #         "Expected strength of #{expected}, but had #{actual.strength}"
+        #       end
+        #     end
+        #
+        # @yield [Object] actual the actual object
+        def failure_message_for_should(&block)
+          cache_or_call_cached(:failure_message_for_should, &block)
+        end
 
-      # Customize the failure messsage to use when this matcher is invoked with
-      # `should_not`. Only use this when the message generated by default
-      # doesn't suit your needs.
-      #
-      # @example
-      #
-      #     RSpec::Matchers.define :have_strength do |expected|
-      #       match { ... }
-      #
-      #       failure_message_for_should_not do |actual|
-      #         "Expected not to have strength of #{expected}, but did"
-      #       end
-      #     end
-      #
-      # @yield [Object] actual the actual object
-      # @yield [Object] actual the actual object
-      def failure_message_for_should_not(&block)
-        cache_or_call_cached(:failure_message_for_should_not, &block)
-      end
+        # Customize the failure messsage to use when this matcher is invoked with
+        # `should_not`. Only use this when the message generated by default
+        # doesn't suit your needs.
+        #
+        # @example
+        #
+        #     RSpec::Matchers.define :have_strength do |expected|
+        #       match { ... }
+        #
+        #       failure_message_for_should_not do |actual|
+        #         "Expected not to have strength of #{expected}, but did"
+        #       end
+        #     end
+        #
+        # @yield [Object] actual the actual object
+        # @yield [Object] actual the actual object
+        def failure_message_for_should_not(&block)
+          cache_or_call_cached(:failure_message_for_should_not, &block)
+        end
 
 
-      # Customize the description to use for one-liners.  Only use this when
-      # the description generated by default doesn't suit your needs.
-      #
-      # @example
-      #
-      #     RSpec::Matchers.define :qualify_for do |expected|
-      #       match { ... }
-      #
-      #       description do
-      #         "qualify for #{expected}"
-      #       end
-      #     end
-      def description(&block)
-        cache_or_call_cached(:description, &block)
-      end
+        # Customize the description to use for one-liners.  Only use this when
+        # the description generated by default doesn't suit your needs.
+        #
+        # @example
+        #
+        #     RSpec::Matchers.define :qualify_for do |expected|
+        #       match { ... }
+        #
+        #       description do
+        #         "qualify for #{expected}"
+        #       end
+        #     end
+        def description(&block)
+          cache_or_call_cached(:description, &block)
+        end
 
-      # Tells the matcher to diff the actual and expected values in the failure
-      # message.
-      def diffable
-        @diffable = true
-      end
-      
-      # Convenience for defining methods on this matcher to create a fluent
-      # interface. The trick about fluent interfaces is that each method must
-      # return self in order to chain methods together. `chain` handles that
-      # for you.
-      #
-      # @example
-      #
-      #     RSpec::Matchers.define :have_errors_on do |key|
-      #       chain :with do |message|
-      #         @message = message
-      #       end
-      #
-      #       match do |actual|
-      #         actual.errors[key] == @message
-      #       end
-      #     end
-      #
-      #     minor.should have_errors_on(:age).with("Not old enough to participate")
-      def chain(method, &block)
-        define_method method do |*args|
-          block.call(*args)
-          self
+        # Tells the matcher to diff the actual and expected values in the failure
+        # message.
+        def diffable
+          @diffable = true
         end
-      end
-      
-      # @api private
-      # Used internally by objects returns by +should+ and +should_not+.
-      def diffable?
-        @diffable
-      end
 
-      # @api private
-      # Used internally by +should_not+
-      def does_not_match?(actual)
-        @actual = actual
-        @match_for_should_not_block ?
-          instance_eval_with_args(actual, &@match_for_should_not_block) :
-          !matches?(actual)
-      end
+        # Convenience for defining methods on this matcher to create a fluent
+        # interface. The trick about fluent interfaces is that each method must
+        # return self in order to chain methods together. `chain` handles that
+        # for you.
+        #
+        # @example
+        #
+        #     RSpec::Matchers.define :have_errors_on do |key|
+        #       chain :with do |message|
+        #         @message = message
+        #       end
+        #
+        #       match do |actual|
+        #         actual.errors[key] == @message
+        #       end
+        #     end
+        #
+        #     minor.should have_errors_on(:age).with("Not old enough to participate")
+        def chain(method, &block)
+          define_method method do |*args|
+            block.call(*args)
+            self
+          end
+        end
+
+        # @api private
+        # Used internally by objects returns by +should+ and +should_not+.
+        def diffable?
+          @diffable
+        end
 
-    private
+        # @api private
+        # Used internally by +should_not+
+        def does_not_match?(actual)
+          @actual = actual
+          @match_for_should_not_block ?
+            instance_eval_with_args(actual, &@match_for_should_not_block) :
+            !matches?(actual)
+        end
 
-      def include(*args)
-        singleton_class.__send__(:include, *args)
-      end
+        def respond_to?(method, include_private=false)
+          $matcher_execution_context.respond_to?(method, include_private) || super
+        end
 
-      def define_method(name, &block)
-        singleton_class.__send__(:define_method, name, &block)
-      end
+        private
 
-      def method_missing(method, *args, &block)
-        if $matcher_execution_context.respond_to?(method)
-          $matcher_execution_context.send method, *args, &block
-        else
-          super(method, *args, &block)
+        def method_missing(method, *args, &block)
+          if $matcher_execution_context.respond_to?(method)
+            $matcher_execution_context.send method, *args, &block
+          else
+            super(method, *args, &block)
+          end
         end
-      end
-    
-      def making_declared_methods_public
-        # Our home-grown instance_exec in ruby 1.8.6 results in any methods
-        # declared in the block eval'd by instance_exec in the block to which we
-        # are yielding here are scoped private. This is NOT the case for Ruby
-        # 1.8.7 or 1.9.
-        #
-        # Also, due some crazy scoping that I don't understand, these methods
-        # are actually available in the specs (something about the matcher being
-        # defined in the scope of RSpec::Matchers or within an example), so not
-        # doing the following will not cause specs to fail, but they *will*
-        # cause features to fail and that will make users unhappy. So don't.
-        orig_private_methods = private_methods
-        yield
-        (private_methods - orig_private_methods).each {|m| singleton_class.__send__ :public, m}
-      end
 
-      def cache_or_call_cached(key, &block)
-        block ? cache(key, &block) : call_cached(key)
-      end
+        def include(*args)
+          singleton_class.__send__(:include, *args)
+        end
 
-      def cache(key, &block)
-        @messages[key] = block
-      end
+        def define_method(name, &block)
+          singleton_class.__send__(:define_method, name, &block)
+        end
 
-      def call_cached(key)
-        @messages[key].arity == 1 ? @messages[key].call(@actual) : @messages[key].call
-      end
+        def making_declared_methods_public
+          # Our home-grown instance_exec in ruby 1.8.6 results in any methods
+          # declared in the block eval'd by instance_exec in the block to which we
+          # are yielding here are scoped private. This is NOT the case for Ruby
+          # 1.8.7 or 1.9.
+          #
+          # Also, due some crazy scoping that I don't understand, these methods
+          # are actually available in the specs (something about the matcher being
+          # defined in the scope of RSpec::Matchers or within an example), so not
+          # doing the following will not cause specs to fail, but they *will*
+          # cause features to fail and that will make users unhappy. So don't.
+          orig_private_methods = private_methods
+          yield
+          (private_methods - orig_private_methods).each {|m| singleton_class.__send__ :public, m}
+        end
 
-      unless method_defined?(:singleton_class)
-        def singleton_class
-          class << self; self; end
+        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)
+          if @messages.has_key?(key)
+            @messages[key].arity == 1 ? @messages[key].call(@actual) : @messages[key].call
+          else
+            send("default_#{key}")
+          end
+        end
+
+        def default_description
+          "#{name_to_sentence}#{expected_to_sentence}"
+        end
+
+        def default_failure_message_for_should
+          "expected #{actual.inspect} to #{name_to_sentence}#{expected_to_sentence}"
+        end
+
+        def default_failure_message_for_should_not
+          "expected #{actual.inspect} not to #{name_to_sentence}#{expected_to_sentence}"
+        end
+
+        unless method_defined?(:singleton_class)
+          def singleton_class
+            class << self; self; end
+          end
         end
       end
     end