rspec 1.1.4 → 1.1.5

data/lib/spec/expectations/handler.rb

@@ -2,38 +2,29 @@ module Spec
   module Expectations
     class InvalidMatcherError < ArgumentError; end        
     
-    module MatcherHandlerHelper
-      def describe_matcher(matcher)
-        matcher.respond_to?(:description) ? matcher.description : "[#{matcher.class.name} does not provide a description]"
-      end
-    end
-    
     class ExpectationMatcherHandler        
       class << self
-        include MatcherHandlerHelper
         def handle_matcher(actual, matcher, &block)
-          if :use_operator_matcher == matcher
-            return Spec::Matchers::PositiveOperatorMatcher.new(actual)
-          end
+          ::Spec::Matchers.last_should = "should"
+          return Spec::Matchers::PositiveOperatorMatcher.new(actual) if matcher.nil?
 
           unless matcher.respond_to?(:matches?)
             raise InvalidMatcherError, "Expected a matcher, got #{matcher.inspect}."
           end
           
           match = matcher.matches?(actual, &block)
-          ::Spec::Matchers.generated_description = "should #{describe_matcher(matcher)}"
+          ::Spec::Matchers.last_matcher = matcher
           Spec::Expectations.fail_with(matcher.failure_message) unless match
+          match
         end
       end
     end
 
     class NegativeExpectationMatcherHandler
       class << self
-        include MatcherHandlerHelper
         def handle_matcher(actual, matcher, &block)
-          if :use_operator_matcher == matcher
-            return Spec::Matchers::NegativeOperatorMatcher.new(actual)
-          end
+          ::Spec::Matchers.last_should = "should not"
+          return Spec::Matchers::NegativeOperatorMatcher.new(actual) if matcher.nil?
           
           unless matcher.respond_to?(:matches?)
             raise InvalidMatcherError, "Expected a matcher, got #{matcher.inspect}."
@@ -49,8 +40,9 @@ EOF
 )
           end
           match = matcher.matches?(actual, &block)
-          ::Spec::Matchers.generated_description = "should not #{describe_matcher(matcher)}"
+          ::Spec::Matchers.last_matcher = matcher
           Spec::Expectations.fail_with(matcher.negative_failure_message) if match
+          match
         end
       end
     end

data/lib/spec/extensions/main.rb

@@ -23,7 +23,7 @@ module Spec
         raise ArgumentError if args.empty?
         raise ArgumentError unless block
         args << {} unless Hash === args.last
-        args.last[:spec_path] = caller(0)[1]
+        args.last[:spec_path] = File.expand_path(caller(0)[1])
         Spec::Example::ExampleGroupFactory.create_example_group(*args, &block)
       end
       alias :context :describe
@@ -80,23 +80,8 @@ module Spec
           raise NameError.new(e.message + "\nThe first argument to share_as must be a legal name for a constant\n")
         end
       end
-
-    private
-    
-      def rspec_options
-        $rspec_options ||= begin; \
-          parser = ::Spec::Runner::OptionParser.new(STDERR, STDOUT); \
-          parser.order!(ARGV); \
-          $rspec_options = parser.options; \
-        end
-        $rspec_options
-      end
-      
-      def init_rspec_options(options)
-        $rspec_options = options if $rspec_options.nil?
-      end
     end
   end
 end
 
-include Spec::Extensions::Main
+include Spec::Extensions::Main

data/lib/spec/matchers.rb

@@ -134,10 +134,16 @@ module Spec
   #
   module Matchers
     module ModuleMethods
-      attr_accessor :generated_description
+      attr_accessor :last_matcher, :last_should
 
       def clear_generated_description
-        self.generated_description = nil
+        self.last_matcher = nil
+        self.last_should = nil
+      end
+      
+      def generated_description
+        last_should.nil? ? nil :
+          "#{last_should} #{last_matcher.respond_to?(:description) ? last_matcher.description : 'NO NAME'}"
       end
     end
 

data/lib/spec/matchers/be.rb

@@ -23,9 +23,6 @@ module Spec
             rcov_error_report = "http://eigenclass.org/hiki.rb?rcov-0.8.0"
           end
 
-          # This supports should_exist > target.exists? in the old world.
-          # We should consider deprecating that ability as in the new world
-          # you can't write "should exist" unless you have your own custom matcher.
           begin
             return @result = actual.__send__(present_tense_predicate, *@args)
           rescue

data/lib/spec/matchers/change.rb

@@ -4,60 +4,60 @@ module Spec
     #Based on patch from Wilson Bilkovich
     class Change #:nodoc:
       def initialize(receiver=nil, message=nil, &block)
-        @receiver = receiver
-        @message = message
-        @block = block
+        @message = message || "result"
+        @value_proc = block || lambda {
+          receiver.__send__(message)
+        }
       end
       
-      def matches?(target, &block)
-        if block
-          raise MatcherError.new(<<-EOF
-block passed to should or should_not change must use {} instead of do/end
-EOF
-)
-        end
-        @target = target
-        execute_change
-        return false if @from && (@from != @before)
-        return false if @to && (@to != @after)
+      def matches?(event_proc)
+        raise_block_syntax_error if block_given?
+        
+        @before = evaluate_value_proc
+        event_proc.call
+        @after = evaluate_value_proc
+        
+        return false if @from unless @from == @before
+        return false if @to unless @to == @after
         return (@before + @amount == @after) if @amount
         return ((@after - @before) >= @minimum) if @minimum
         return ((@after - @before) <= @maximum) if @maximum        
         return @before != @after
       end
       
-      def execute_change
-        @before = @block.nil? ? @receiver.send(@message) : @block.call
-        @target.call
-        @after = @block.nil? ? @receiver.send(@message) : @block.call
+      def raise_block_syntax_error
+        raise MatcherError.new(<<-MESSAGE
+block passed to should or should_not change must use {} instead of do/end
+MESSAGE
+        )
+      end
+      
+      def evaluate_value_proc
+        @value_proc.call
       end
       
       def failure_message
         if @to
-          "#{result} should have been changed to #{@to.inspect}, but is now #{@after.inspect}"
+          "#{@message} should have been changed to #{@to.inspect}, but is now #{@after.inspect}"
         elsif @from
-          "#{result} should have initially been #{@from.inspect}, but was #{@before.inspect}"
+          "#{@message} should have initially been #{@from.inspect}, but was #{@before.inspect}"
         elsif @amount
-          "#{result} should have been changed by #{@amount.inspect}, but was changed by #{actual_delta.inspect}"
+          "#{@message} should have been changed by #{@amount.inspect}, but was changed by #{actual_delta.inspect}"
         elsif @minimum
-          "#{result} should have been changed by at least #{@minimum.inspect}, but was changed by #{actual_delta.inspect}"
+          "#{@message} should have been changed by at least #{@minimum.inspect}, but was changed by #{actual_delta.inspect}"
         elsif @maximum
-          "#{result} should have been changed by at most #{@maximum.inspect}, but was changed by #{actual_delta.inspect}"
+          "#{@message} should have been changed by at most #{@maximum.inspect}, but was changed by #{actual_delta.inspect}"
         else
-          "#{result} should have changed, but is still #{@before.inspect}"
+          "#{@message} should have changed, but is still #{@before.inspect}"
         end
       end
       
-      def result
-        @message || "result"
-      end
-      
       def actual_delta
         @after - @before
       end
       
       def negative_failure_message
-        "#{result} should not have changed, but did change from #{@before.inspect} to #{@after.inspect}"
+        "#{@message} should not have changed, but did change from #{@before.inspect} to #{@after.inspect}"
       end
       
       def by(amount)
@@ -125,20 +125,24 @@ EOF
     #     employee.develop_great_new_social_networking_app
     #   }.should change(employee, :title).from("Mail Clerk").to("CEO")
     #
-    # Evaluates +receiver.message+ or +block+ before and
-    # after it evaluates the c object (generated by the lambdas in the examples above).
+    # 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).
+    #
+    # Then compares the values before and after the <tt>receiver.message</tt>
+    # and evaluates the difference compared to the expected difference.
     #
-    # Then compares the values before and after the +receiver.message+ and
-    # evaluates the difference compared to the expected difference.
+    # == 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>.
     #
-    # == Warning
-    # +should_not+ +change+ only supports the form with no subsequent calls to
-    # +by+, +by_at_least+, +by_at_most+, +to+ or +from+.
+    # 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).
     #
-    # blocks passed to +should+ +change+ and +should_not+ +change+
-    # must use the <tt>{}</tt> form (<tt>do/end</tt> is not supported)
-    def change(target=nil, message=nil, &block)
-      Matchers::Change.new(target, message, &block)
+    def change(receiver=nil, message=nil, &block)
+      Matchers::Change.new(receiver, message, &block)
     end
   end
 end

data/lib/spec/matchers/has.rb

@@ -8,7 +8,7 @@ module Spec
       end
       
       def matches?(target)
-        target.send(predicate, *@args)
+        target.__send__(predicate, *@args)
       end
       
       def failure_message

data/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,23 +14,15 @@ 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)
@@ -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/lib/spec/matchers/operator_matcher.rb

@@ -45,14 +45,19 @@ module Spec
       def fail_with_message(message)
         Spec::Expectations.fail_with(message, @expected, @target)
       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)
+        @operator = operator
+        ::Spec::Matchers.last_matcher = self
+        return true 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}")
       end
@@ -62,8 +67,9 @@ module Spec
     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)
+        @operator = operator
+        ::Spec::Matchers.last_matcher = self
+        return true unless @target.__send__(operator, expected)
         return fail_with_message("expected not: #{operator} #{expected.inspect},\n         got: #{operator.gsub(/./, ' ')} #{@target.inspect}")
       end
 

data/lib/spec/matchers/simple_matcher.rb

@@ -1,7 +1,7 @@
 module Spec
   module Matchers
     class SimpleMatcher
-      attr_reader :description
+      attr_writer :failure_message, :negative_failure_message, :description
       
       def initialize(description, &match_block)
         @description = description
@@ -10,20 +10,123 @@ module Spec
 
       def matches?(actual)
         @actual = actual
-        return @match_block.call(@actual)
+        case @match_block.arity
+        when 2
+          @match_block.call(@actual, self)
+        else
+          @match_block.call(@actual)
+        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 #{@actual.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 #{@actual.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}"
+    #       actual.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}"
+    #       actual.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