typo 5.1.3 → 5.1.98

data/vendor/plugins/rspec/lib/spec/matchers/has.rb

@@ -7,25 +7,15 @@ module Spec
         @args = args
       end
       
-      def matches?(target)
-        @target = target
-        begin
-          return target.send(predicate, *@args)
-        rescue => @error
-          # This clause should be empty, but rcov will not report it as covered
-          # unless something (anything) is executed within the clause
-          rcov_error_report = "http://eigenclass.org/hiki.rb?rcov-0.8.0"
-        end
-        return false
+      def matches?(given)
+        given.__send__(predicate, *@args)
       end
       
       def failure_message
-        raise @error if @error
         "expected ##{predicate}(#{@args[0].inspect}) to return true, got false"
       end
       
       def negative_failure_message
-        raise @error if @error
         "expected ##{predicate}(#{@args[0].inspect}) to return false, got true"
       end
       

data/vendor/plugins/rspec/lib/spec/matchers/have.rb

@@ -1,6 +1,5 @@
 module Spec
   module Matchers
-    
     class Have #:nodoc:
       def initialize(expected, relativity=:exactly)
         @expected = (expected == :no ? 0 : expected)
@@ -15,30 +14,22 @@ module Spec
         }
       end
     
-      def method_missing(sym, *args, &block)
-        @collection_name = sym
-        @plural_collection_name = Inflector.pluralize(sym.to_s) if Object.const_defined?(:Inflector)
-        @args = args
-        @block = block
-        self
-      end
-    
       def matches?(collection_owner)
         if collection_owner.respond_to?(@collection_name)
-          collection = collection_owner.send(@collection_name, *@args, &@block)
+          collection = collection_owner.__send__(@collection_name, *@args, &@block)
         elsif (@plural_collection_name && collection_owner.respond_to?(@plural_collection_name))
-          collection = collection_owner.send(@plural_collection_name, *@args, &@block)
+          collection = collection_owner.__send__(@plural_collection_name, *@args, &@block)
         elsif (collection_owner.respond_to?(:length) || collection_owner.respond_to?(:size))
           collection = collection_owner
         else
-          collection_owner.send(@collection_name, *@args, &@block)
+          collection_owner.__send__(@collection_name, *@args, &@block)
         end
-        @actual = collection.size if collection.respond_to?(:size)
-        @actual = collection.length if collection.respond_to?(:length)
-        raise not_a_collection if @actual.nil?
-        return @actual >= @expected if @relativity == :at_least
-        return @actual <= @expected if @relativity == :at_most
-        return @actual == @expected
+        @given = collection.size if collection.respond_to?(:size)
+        @given = collection.length if collection.respond_to?(:length)
+        raise not_a_collection if @given.nil?
+        return @given >= @expected if @relativity == :at_least
+        return @given <= @expected if @relativity == :at_most
+        return @given == @expected
       end
       
       def not_a_collection
@@ -46,12 +37,12 @@ module Spec
       end
     
       def failure_message
-        "expected #{relative_expectation} #{@collection_name}, got #{@actual}"
+        "expected #{relative_expectation} #{@collection_name}, got #{@given}"
       end
 
       def negative_failure_message
         if @relativity == :exactly
-          return "expected target not to have #{@expected} #{@collection_name}, got #{@actual}"
+          return "expected target not to have #{@expected} #{@collection_name}, got #{@given}"
         elsif @relativity == :at_most
           return <<-EOF
 Isn't life confusing enough?
@@ -75,8 +66,22 @@ EOF
         "have #{relative_expectation} #{@collection_name}"
       end
       
+      def respond_to?(sym)
+        @expected.respond_to?(sym) || super
+      end
+    
       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)
+        end
+        @args = args
+        @block = block
+        self
+      end
+      
       def relative_expectation
         "#{relativities[@relativity]}#{@expected}"
       end

data/vendor/plugins/rspec/lib/spec/matchers/include.rb

@@ -7,10 +7,17 @@ module Spec
         @expecteds = expecteds
       end
       
-      def matches?(actual)
-        @actual = actual
+      def matches?(given)
+        @given = given
         @expecteds.each do |expected|
-          return false unless actual.include?(expected)
+          case given
+          when Hash
+            expected.each_pair do |k,v|
+              return false unless given[k] == v
+            end
+          else
+            return false unless given.include?(expected)
+          end
         end
         true
       end
@@ -29,7 +36,7 @@ module Spec
       
       private
         def _message(maybe_not="")
-          "expected #{@actual.inspect} #{maybe_not}to include #{_pretty_print(@expecteds)}"
+          "expected #{@given.inspect} #{maybe_not}to include #{_pretty_print(@expecteds)}"
         end
         
         def _pretty_print(array)
@@ -51,7 +58,7 @@ module Spec
     #   should include(expected)
     #   should_not include(expected)
     #
-    # Passes if actual includes expected. This works for
+    # Passes if given includes expected. This works for
     # collections and Strings. You can also pass in multiple args
     # and it will only pass if all args are found in collection.
     #

data/vendor/plugins/rspec/lib/spec/matchers/match.rb

@@ -2,26 +2,26 @@ module Spec
   module Matchers
     
     class Match #:nodoc:
-      def initialize(expected)
-        @expected = expected
+      def initialize(regexp)
+        @regexp = regexp
       end
       
-      def matches?(actual)
-        @actual = actual
-        return true if actual =~ @expected
+      def matches?(given)
+        @given = given
+        return true if given =~ @regexp
         return false
       end
       
       def failure_message
-        return "expected #{@actual.inspect} to match #{@expected.inspect}", @expected, @actual
+        return "expected #{@given.inspect} to match #{@regexp.inspect}", @regexp, @given
       end
       
       def negative_failure_message
-        return "expected #{@actual.inspect} not to match #{@expected.inspect}", @expected, @actual
+        return "expected #{@given.inspect} not to match #{@regexp.inspect}", @regexp, @given
       end
       
       def description
-        "match #{@expected.inspect}"
+        "match #{@regexp.inspect}"
       end
     end
     
@@ -29,7 +29,7 @@ module Spec
     #   should match(regexp)
     #   should_not match(regexp)
     #
-    # Given a Regexp, passes if actual =~ regexp
+    # Given a Regexp, passes if given =~ regexp
     #
     # == Examples
     #

data/vendor/plugins/rspec/lib/spec/matchers/operator_matcher.rb

@@ -3,68 +3,74 @@ module Spec
     class BaseOperatorMatcher
       attr_reader :generated_description
       
-      def initialize(target)
-        @target = target
+      def initialize(given)
+        @given = given
       end
 
       def ==(expected)
         @expected = expected
-        __delegate_method_missing_to_target("==", expected)
+        __delegate_method_missing_to_given("==", expected)
       end
 
       def ===(expected)
         @expected = expected
-        __delegate_method_missing_to_target("===", expected)
+        __delegate_method_missing_to_given("===", expected)
       end
 
       def =~(expected)
         @expected = expected
-        __delegate_method_missing_to_target("=~", expected)
+        __delegate_method_missing_to_given("=~", expected)
       end
 
       def >(expected)
         @expected = expected
-        __delegate_method_missing_to_target(">", expected)
+        __delegate_method_missing_to_given(">", expected)
       end
 
       def >=(expected)
         @expected = expected
-        __delegate_method_missing_to_target(">=", expected)
+        __delegate_method_missing_to_given(">=", expected)
       end
 
       def <(expected)
         @expected = expected
-        __delegate_method_missing_to_target("<", expected)
+        __delegate_method_missing_to_given("<", expected)
       end
 
       def <=(expected)
         @expected = expected
-        __delegate_method_missing_to_target("<=", expected)
+        __delegate_method_missing_to_given("<=", expected)
       end
 
       def fail_with_message(message)
-        Spec::Expectations.fail_with(message, @expected, @target)
+        Spec::Expectations.fail_with(message, @expected, @given)
+      end
+      
+      def description
+        "#{@operator} #{@expected.inspect}"
       end
 
     end
 
     class PositiveOperatorMatcher < BaseOperatorMatcher #:nodoc:
 
-      def __delegate_method_missing_to_target(operator, expected)
-        ::Spec::Matchers.generated_description = "should #{operator} #{expected.inspect}"
-        return if @target.send(operator, expected)
-        return fail_with_message("expected: #{expected.inspect},\n     got: #{@target.inspect} (using #{operator})") if ['==','===', '=~'].include?(operator)
-        return fail_with_message("expected: #{operator} #{expected.inspect},\n     got: #{operator.gsub(/./, ' ')} #{@target.inspect}")
+      def __delegate_method_missing_to_given(operator, expected)
+        @operator = operator
+        ::Spec::Matchers.last_matcher = self
+        return true if @given.__send__(operator, expected)
+        return fail_with_message("expected: #{expected.inspect},\n     got: #{@given.inspect} (using #{operator})") if ['==','===', '=~'].include?(operator)
+        return fail_with_message("expected: #{operator} #{expected.inspect},\n     got: #{operator.gsub(/./, ' ')} #{@given.inspect}")
       end
 
     end
 
     class NegativeOperatorMatcher < BaseOperatorMatcher #:nodoc:
 
-      def __delegate_method_missing_to_target(operator, expected)
-        ::Spec::Matchers.generated_description = "should not #{operator} #{expected.inspect}"
-        return unless @target.send(operator, expected)
-        return fail_with_message("expected not: #{operator} #{expected.inspect},\n         got: #{operator.gsub(/./, ' ')} #{@target.inspect}")
+      def __delegate_method_missing_to_given(operator, expected)
+        @operator = operator
+        ::Spec::Matchers.last_matcher = self
+        return true unless @given.__send__(operator, expected)
+        return fail_with_message("expected not: #{operator} #{expected.inspect},\n         got: #{operator.gsub(/./, ' ')} #{@given.inspect}")
       end
 
     end

data/vendor/plugins/rspec/lib/spec/matchers/raise_error.rb

@@ -1,58 +1,70 @@
 module Spec
   module Matchers
-    
     class RaiseError #:nodoc:
-      def initialize(error_or_message=Exception, message=nil)
-        if String === error_or_message
-          @expected_error = Exception
-          @expected_message = error_or_message
+      def initialize(expected_error_or_message=Exception, expected_message=nil, &block)
+        @block = block
+        case expected_error_or_message
+        when String, Regexp
+          @expected_error, @expected_message = Exception, expected_error_or_message
         else
-          @expected_error = error_or_message
-          @expected_message = message
+          @expected_error, @expected_message = expected_error_or_message, expected_message
         end
       end
-      
-      def matches?(proc)
+
+      def matches?(given_proc)
         @raised_expected_error = false
-        @raised_other = false
+        @with_expected_message = false
+        @eval_block = false
+        @eval_block_passed = false
         begin
-          proc.call
-        rescue @expected_error => @actual_error
-          if @expected_message.nil?
-            @raised_expected_error = true
-          else
-            verify_message
-          end
-        rescue Exception => @actual_error
-          @raised_other = true
-        ensure
-          return @raised_expected_error
+          given_proc.call
+        rescue @expected_error => @given_error
+          @raised_expected_error = true
+          @with_expected_message = verify_message
+        rescue Exception => @given_error
+          # This clause should be empty, but rcov will not report it as covered
+          # unless something (anything) is executed within the clause
+          rcov_error_report = "http://eigenclass.org/hiki.rb?rcov-0.8.0"
+        end
+
+        unless negative_expectation?
+          eval_block if @raised_expected_error && @with_expected_message && @block
+        end
+      ensure
+        return (@raised_expected_error && @with_expected_message) ? (@eval_block ? @eval_block_passed : true) : false
+      end
+      
+      def eval_block
+        @eval_block = true
+        begin
+          @block[@given_error]
+          @eval_block_passed = true
+        rescue Exception => err
+          @given_error = err
         end
       end
 
       def verify_message
         case @expected_message
+        when nil
+          return true
         when Regexp
-          if @expected_message =~ @actual_error.message
-            @raised_expected_error = true
-          else
-            @raised_other = true
-          end
+          return @expected_message =~ @given_error.message
         else
-          if @expected_message == @actual_error.message
-            @raised_expected_error = true
-          else
-            @raised_other = true
-          end
+          return @expected_message == @given_error.message
         end
       end
       
       def failure_message
-        return "expected #{expected_error}#{actual_error}" if @raised_other || !@raised_expected_error
+        if @eval_block
+          return @given_error.message
+        else
+          return "expected #{expected_error}#{given_error}"
+        end
       end
 
       def negative_failure_message
-        "expected no #{expected_error}#{actual_error}"
+        "expected no #{expected_error}#{given_error}"
       end
       
       def description
@@ -71,8 +83,13 @@ module Spec
           end
         end
 
-        def actual_error
-          @actual_error.nil? ? " but nothing was raised" : ", got #{@actual_error.inspect}"
+        def given_error
+          @given_error.nil? ? " but nothing was raised" : ", got #{@given_error.inspect}"
+        end
+        
+        def negative_expectation?
+          # YES - I'm a bad person... help me find a better way - ryand
+          caller.first(3).find { |s| s =~ /should_not/ }
         end
     end
     
@@ -81,6 +98,10 @@ module Spec
     #   should raise_error(NamedError)
     #   should raise_error(NamedError, String)
     #   should raise_error(NamedError, Regexp)
+    #   should raise_error() { |error| ... }
+    #   should raise_error(NamedError) { |error| ... }
+    #   should raise_error(NamedError, String) { |error| ... }
+    #   should raise_error(NamedError, Regexp) { |error| ... }
     #   should_not raise_error()
     #   should_not raise_error(NamedError)
     #   should_not raise_error(NamedError, String)
@@ -90,11 +111,13 @@ module Spec
     # With a named error, matches only if that specific error is raised.
     # With a named error and messsage specified as a String, matches only if both match.
     # With a named error and messsage specified as a Regexp, matches only if both match.
+    # Pass an optional block to perform extra verifications on the exception matched
     #
     # == Examples
     #
     #   lambda { do_something_risky }.should raise_error
     #   lambda { do_something_risky }.should raise_error(PoorRiskDecisionError)
+    #   lambda { do_something_risky }.should raise_error(PoorRiskDecisionError) { |error| error.data.should == 42 }
     #   lambda { do_something_risky }.should raise_error(PoorRiskDecisionError, "that was too risky")
     #   lambda { do_something_risky }.should raise_error(PoorRiskDecisionError, /oo ri/)
     #
@@ -102,8 +125,8 @@ module Spec
     #   lambda { do_something_risky }.should_not raise_error(PoorRiskDecisionError)
     #   lambda { do_something_risky }.should_not raise_error(PoorRiskDecisionError, "that was too risky")
     #   lambda { do_something_risky }.should_not raise_error(PoorRiskDecisionError, /oo ri/)
-    def raise_error(error=Exception, message=nil)
-      Matchers::RaiseError.new(error, message)
+    def raise_error(error=Exception, message=nil, &block)
+      Matchers::RaiseError.new(error, message, &block)
     end
   end
 end

data/vendor/plugins/rspec/lib/spec/matchers/respond_to.rb

@@ -7,9 +7,10 @@ module Spec
         @names_not_responded_to = []
       end
       
-      def matches?(target)
+      def matches?(given)
+        @given = given
         @names.each do |name|
-          unless target.respond_to?(name)
+          unless given.respond_to?(name)
             @names_not_responded_to << name
           end
         end
@@ -17,11 +18,11 @@ module Spec
       end
       
       def failure_message
-        "expected target to respond to #{@names_not_responded_to.collect {|name| name.inspect }.join(', ')}"
+        "expected #{@given.inspect} to respond to #{@names_not_responded_to.collect {|name| name.inspect }.join(', ')}"
       end
       
       def negative_failure_message
-        "expected target not to respond to #{@names.collect {|name| name.inspect }.join(', ')}"
+        "expected #{@given.inspect} not to respond to #{@names.collect {|name| name.inspect }.join(', ')}"
       end
       
       def description

data/vendor/plugins/rspec/lib/spec/matchers/satisfy.rb

@@ -6,18 +6,18 @@ module Spec
         @block = block
       end
       
-      def matches?(actual, &block)
+      def matches?(given, &block)
         @block = block if block
-        @actual = actual
-        @block.call(actual)
+        @given = given
+        @block.call(given)
       end
       
       def failure_message
-        "expected #{@actual} to satisfy block"
+        "expected #{@given} to satisfy block"
       end
 
       def negative_failure_message
-        "expected #{@actual} not to satisfy block"
+        "expected #{@given} not to satisfy block"
       end
     end
     

data/vendor/plugins/rspec/lib/spec/matchers/simple_matcher.rb

@@ -1,29 +1,132 @@
 module Spec
   module Matchers
     class SimpleMatcher
-      attr_reader :description
+      attr_writer :failure_message, :negative_failure_message, :description
       
       def initialize(description, &match_block)
         @description = description
         @match_block = match_block
       end
 
-      def matches?(actual)
-        @actual = actual
-        return @match_block.call(@actual)
+      def matches?(given)
+        @given = given
+        case @match_block.arity
+        when 2
+          @match_block.call(@given, self)
+        else
+          @match_block.call(@given)
+        end
+      end
+      
+      def description
+        @description || explanation
       end
 
-      def failure_message()
-        return %[expected #{@description.inspect} but got #{@actual.inspect}]
+      def failure_message
+        @failure_message || (@description.nil? ? explanation : %[expected #{@description.inspect} but got #{@given.inspect}])
       end
-        
-      def negative_failure_message()
-        return %[expected not to get #{@description.inspect}, but got #{@actual.inspect}]
+
+      def negative_failure_message
+        @negative_failure_message || (@description.nil? ? explanation : %[expected not to get #{@description.inspect}, but got #{@given.inspect}])
+      end
+
+      def explanation
+        "No description provided. See RDoc for simple_matcher()"
       end
     end
-    
-    def simple_matcher(message, &match_block)
-      SimpleMatcher.new(message, &match_block)
+  
+    # simple_matcher makes it easy for you to create your own custom matchers
+    # in just a few lines of code when you don't need all the power of a
+    # completely custom matcher object.
+    #
+    # The <tt>description</tt> argument will appear as part of any failure
+    # message, and is also the source for auto-generated descriptions.
+    #
+    # The <tt>match_block</tt> can have an arity of 1 or 2. The first block
+    # argument will be the given value. The second, if the block accepts it
+    # will be the matcher itself, giving you access to set custom failure
+    # messages in favor of the defaults.
+    #
+    # The <tt>match_block</tt> should return a boolean: <tt>true</tt>
+    # indicates a match, which will pass if you use <tt>should</tt> and fail
+    # if you use <tt>should_not</tt>. false (or nil) indicates no match,
+    # which will do the reverse: fail if you use <tt>should</tt> and pass if
+    # you use <tt>should_not</tt>.
+    #
+    # An error in the <tt>match_block</tt> will bubble up, resulting in a
+    # failure.
+    #
+    # == Example with default messages
+    #
+    #   def be_even
+    #     simple_matcher("an even number") { |given| given % 2 == 0 }
+    #   end
+    #                    
+    #   describe 2 do
+    #     it "should be even" do
+    #       2.should be_even
+    #     end
+    #   end
+    #
+    # Given an odd number, this example would produce an error message stating:
+    # expected "an even number", got 3.
+    #
+    # Unfortunately, if you're a fan of auto-generated descriptions, this will
+    # produce "should an even number." Not the most desirable result. You can
+    # control that using custom messages:
+    #
+    # == Example with custom messages
+    #
+    #   def rhyme_with(expected)
+    #     simple_matcher("rhyme with #{expected.inspect}") do |given, matcher|
+    #       matcher.failure_message = "expected #{given.inspect} to rhyme with #{expected.inspect}"
+    #       matcher.negative_failure_message = "expected #{given.inspect} not to rhyme with #{expected.inspect}"
+    #       given.rhymes_with? expected
+    #     end
+    #   end
+    #
+    #   # OR
+    #
+    #   def rhyme_with(expected)
+    #     simple_matcher do |given, matcher|
+    #       matcher.description = "rhyme with #{expected.inspect}"
+    #       matcher.failure_message = "expected #{given.inspect} to rhyme with #{expected.inspect}"
+    #       matcher.negative_failure_message = "expected #{given.inspect} not to rhyme with #{expected.inspect}"
+    #       given.rhymes_with? expected
+    #     end
+    #   end
+    #
+    #   describe "pecan" do
+    #     it "should rhyme with 'be gone'" do
+    #       nut = "pecan"
+    #       nut.extend Rhymer
+    #       nut.should rhyme_with("be gone")
+    #     end
+    #   end
+    #
+    # The resulting messages would be:
+    #   description:              rhyme with "be gone"
+    #   failure_message:          expected "pecan" to rhyme with "be gone"
+    #   negative failure_message: expected "pecan" not to rhyme with "be gone"
+    #
+    # == Wrapped Expectations
+    #
+    # Because errors will bubble up, it is possible to wrap other expectations
+    # in a SimpleMatcher.
+    #
+    #   def be_even
+    #     simple_matcher("an even number") { |given| (given % 2).should == 0 }
+    #   end
+    #
+    # BE VERY CAREFUL when you do this. Only use wrapped expectations for
+    # matchers that will always be used in only the positive
+    # (<tt>should</tt>) or negative (<tt>should_not</tt>), but not both.
+    # The reason is that is you wrap a <tt>should</tt> and call the wrapper
+    # with <tt>should_not</tt>, the correct result (the <tt>should</tt>
+    # failing), will fail when you want it to pass.
+    #
+    def simple_matcher(description=nil, &match_block)
+      SimpleMatcher.new(description, &match_block)
     end
   end
 end

data/vendor/plugins/rspec/lib/spec/matchers/throw_symbol.rb

@@ -7,9 +7,9 @@ module Spec
         @actual = nil
       end
       
-      def matches?(proc)
+      def matches?(given_proc)
         begin
-          proc.call
+          given_proc.call
         rescue NameError => e
           raise e unless e.message =~ /uncaught throw/
           @actual = e.name.to_sym
@@ -56,7 +56,7 @@ module Spec
     #   should_not throw_symbol()
     #   should_not throw_symbol(:sym)
     #
-    # Given a Symbol argument, matches if a proc throws the specified Symbol.
+    # Given a Symbol argument, matches if the given proc throws the specified Symbol.
     #
     # Given no argument, matches if a proc throws any Symbol.
     #