rspec 1.0.0 → 1.3.1

data/lib/spec/matchers/match.rb

@@ -1,41 +1,21 @@
 module Spec
   module Matchers
-    
-    class Match #:nodoc:
-      def initialize(expected)
-        @expected = expected
-      end
-      
-      def matches?(actual)
-        @actual = actual
-        return true if actual =~ @expected
-        return false
-      end
-      
-      def failure_message
-        return "expected #{@actual.inspect} to match #{@expected.inspect}", @expected, @actual
-      end
-      
-      def negative_failure_message
-        return "expected #{@actual.inspect} not to match #{@expected.inspect}", @expected, @actual
-      end
-      
-      def description
-        "match #{@expected.inspect}"
-      end
-    end
-    
     # :call-seq:
-    #   should match(regexp)
-    #   should_not match(regexp)
+    #   should match(pattern)
+    #   should_not match(pattern)
     #
-    # Given a Regexp, passes if actual =~ regexp
+    # Given a Regexp or String, passes if actual.match(pattern)
     #
     # == Examples
     #
-    #   email.should match(/^([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})$/i)
-    def match(regexp)
-      Matchers::Match.new(regexp)
+    #   email.should match(/^([^\s]+)((?:[-a-z0-9]+\.)+[a-z]{2,})$/i)
+    #   email.should match("@example.com")
+    def match(expected)
+      Matcher.new :match, expected do |_expected_|
+        match do |actual|
+          actual.match(_expected_)
+        end
+      end
     end
   end
 end

data/lib/spec/matchers/match_array.rb

@@ -0,0 +1,71 @@
+module Spec
+  module Matchers
+
+    class MatchArray #:nodoc:
+      include Spec::Matchers::Pretty
+      
+      def initialize(expected)
+        @expected = expected
+      end
+
+      def matches?(actual)
+        @actual = actual        
+        @extra_items = difference_between_arrays(@actual, @expected)
+        @missing_items = difference_between_arrays(@expected, @actual)
+        @extra_items.empty? & @missing_items.empty?
+      end
+
+      def failure_message_for_should
+        message =  "expected collection contained:  #{safe_sort(@expected).inspect}\n"
+        message += "actual collection contained:    #{safe_sort(@actual).inspect}\n"
+        message += "the missing elements were:      #{safe_sort(@missing_items).inspect}\n" unless @missing_items.empty?
+        message += "the extra elements were:        #{safe_sort(@extra_items).inspect}\n"   unless @extra_items.empty?
+        message
+      end
+      
+      def failure_message_for_should_not
+        "Matcher does not support should_not"
+      end
+      
+      def description
+        "contain exactly #{_pretty_print(@expected)}"
+      end
+
+      private
+
+        def safe_sort(array)
+          array.all?{|item| item.respond_to?(:<=>)} ? array.sort : array
+        end
+
+        def difference_between_arrays(array_1, array_2)
+          difference = array_1.dup
+          array_2.each do |element|
+            if index = difference.index(element)
+              difference.delete_at(index)
+            end
+          end
+          difference
+        end
+
+
+    end
+
+    # :call-seq:
+    #   should =~ expected
+    #
+    # Passes if actual contains all of the expected regardless of order. 
+    # This works for collections. Pass in multiple args  and it will only 
+    # pass if all args are found in collection.
+    #
+    # NOTE: there is no should_not version of array.should =~ other_array
+    # 
+    # == Examples
+    #
+    #   [1,2,3].should   =~ [1,2,3]   # => would pass
+    #   [1,2,3].should   =~ [2,3,1]   # => would pass
+    #   [1,2,3,4].should =~ [1,2,3]   # => would fail
+    #   [1,2,2,3].should =~ [1,2,3]   # => would fail
+    #   [1,2,3].should   =~ [1,2,3,4] # => would fail
+    OperatorMatcher.register(Array, '=~', Spec::Matchers::MatchArray)
+  end
+end

data/lib/spec/matchers/matcher.rb

@@ -0,0 +1,132 @@
+module Spec
+  module Matchers
+    class Matcher
+      include Spec::Matchers::InstanceExec
+      include Spec::Matchers::Pretty
+      include Spec::Matchers
+
+      attr_reader :expected, :actual
+
+      def initialize(name, *expected, &declarations)
+        @name     = name
+        @expected = expected
+        @actual   = nil
+        @diffable = false
+        @expected_exception = 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}"},
+          :failure_message_for_should_not => lambda {|actual| "expected #{actual.inspect} not to #{name_to_sentence}#{expected_to_sentence}"}
+        }
+        making_declared_methods_public do
+          instance_exec(*@expected, &declarations)
+        end
+      end
+
+      #Used internally by objects returns by +should+ and +should_not+.
+      def matches?(actual)
+        @actual = actual
+        if @expected_exception
+          begin
+            instance_exec(actual, &@match_block)
+            true
+          rescue @expected_exception
+            false
+          end
+        else
+          begin
+            instance_exec(actual, &@match_block)
+          rescue Spec::Expectations::ExpectationNotMetError
+            false
+          end
+        end
+      end
+
+      # See Spec::Matchers
+      def match(&block)
+        @match_block = block
+      end
+
+      # See Spec::Matchers
+      def match_unless_raises(exception=Exception, &block)
+        @expected_exception = exception
+        match(&block)
+      end
+
+      # See Spec::Matchers
+      def failure_message_for_should(&block)
+        cache_or_call_cached(:failure_message_for_should, &block)
+      end
+
+      # See Spec::Matchers
+      def failure_message_for_should_not(&block)
+        cache_or_call_cached(:failure_message_for_should_not, &block)
+      end
+
+      # See Spec::Matchers
+      def description(&block)
+        cache_or_call_cached(:description, &block)
+      end
+
+      #Used internally by objects returns by +should+ and +should_not+.
+      def diffable?
+        @diffable
+      end
+
+      # See Spec::Matchers
+      def diffable
+        @diffable = true
+      end
+      
+      # See Spec::Matchers
+      def chain(method, &block)
+        self.class.class_eval do
+          define_method method do |*args|
+            block.call(*args)
+            self
+          end
+        end
+      end
+
+    private
+
+      def making_declared_methods_public # :nodoc:
+        # 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 Spec::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
+        st = (class << self; self; end)
+        (private_methods - orig_private_methods).each {|m| st.__send__ :public, m}
+      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)
+        @messages[key].arity == 1 ? @messages[key].call(@actual) : @messages[key].call
+      end
+
+      def name_to_sentence
+        split_words(@name)
+      end
+
+      def expected_to_sentence
+        to_sentence(@expected)
+      end
+
+    end
+  end
+end

data/lib/spec/matchers/method_missing.rb

@@ -0,0 +1,9 @@
+module Spec
+  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_/
+      super
+    end
+  end
+end

data/lib/spec/matchers/operator_matcher.rb

@@ -1,69 +1,80 @@
 module Spec
   module Matchers
-    class BaseOperatorMatcher
-      
-      def initialize(target)
-        @target = target
-      end
-
-      def ==(expected)
-        @expected = expected
-        __delegate_method_missing_to_target("==", expected)
-      end
 
-      def ===(expected)
-        @expected = expected
-        __delegate_method_missing_to_target("===", expected)
+    class OperatorMatcher
+      class << self
+        def registry
+          @registry ||= {}
+        end
+
+        def register(klass, operator, matcher)
+          registry[klass] ||= {}
+          registry[klass][operator] = matcher
+        end
+
+        def get(klass, operator)
+          matcher = registry[klass] && registry[klass][operator]
+          unless matcher
+            parent_class = registry.keys.detect {|pc| klass <= pc }
+            matcher = registry[parent_class] && registry[parent_class][operator]
+          end
+          matcher
+        end
       end
 
-      def =~(expected)
-        @expected = expected
-        __delegate_method_missing_to_target("=~", expected)
+      def initialize(actual)
+        @actual = actual
       end
 
-      def >(expected)
-        @expected = expected
-        __delegate_method_missing_to_target(">", expected)
+      def self.use_custom_matcher_or_delegate(operator)
+        define_method(operator) do |expected|
+          if matcher = OperatorMatcher.get(@actual.class, operator)
+            @actual.send(::Spec::Matchers.last_should, matcher.new(expected))
+          else
+            eval_match(@actual, operator, expected)
+          end
+        end
       end
 
-      def >=(expected)
-        @expected = expected
-        __delegate_method_missing_to_target(">=", expected)
+      ['==', '===', '=~', '>', '>=', '<', '<='].each do |operator|
+        use_custom_matcher_or_delegate operator
       end
 
-      def <(expected)
-        @expected = expected
-        __delegate_method_missing_to_target("<", expected)
+      def fail_with_message(message)
+        Spec::Expectations.fail_with(message, @expected, @actual)
       end
 
-      def <=(expected)
-        @expected = expected
-        __delegate_method_missing_to_target("<=", expected)
+      def description
+        "#{@operator} #{@expected.inspect}"
       end
-
-      def fail_with_message(message)
-        Spec::Expectations.fail_with(message, @expected, @target)
+      
+    private
+      
+      def eval_match(actual, operator, expected)
+        ::Spec::Matchers.last_matcher = self
+        @operator, @expected = operator, expected
+        __delegate_operator(actual, operator, expected)
       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}, got #{@target.inspect} (using #{operator})") if ['==','==='].include?(operator)
-        return fail_with_message("expected #{operator} #{expected.inspect}, got #{@target.inspect}")
+    class PositiveOperatorMatcher < OperatorMatcher #:nodoc:
+      def __delegate_operator(actual, operator, expected)
+        if actual.__send__(operator, expected)
+          true
+        elsif ['==','===', '=~'].include?(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}")
+        end
       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}, got #{@target.inspect}")
+    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}")
       end
 
     end

data/lib/spec/matchers/pretty.rb

@@ -0,0 +1,37 @@
+module Spec
+  module Matchers
+    module Pretty
+      def split_words(sym)
+        sym.to_s.gsub(/_/,' ')
+      end
+
+      def to_sentence(words=[])
+        words = words.map{|w| w.inspect}
+        case words.length
+          when 0
+            ""
+          when 1
+            " #{words[0]}"
+          when 2
+            " #{words[0]} and #{words[1]}"
+          else
+            " #{words[0...-1].join(', ')}, and #{words[-1]}"
+        end
+      end
+
+      def _pretty_print(array)
+        result = ""
+        array.each_with_index do |item, index|
+          if index < (array.length - 2)
+            result << "#{item.inspect}, "
+          elsif index < (array.length - 1)
+            result << "#{item.inspect} and "
+          else
+            result << "#{item.inspect}"
+          end
+        end
+        result
+      end
+    end
+  end
+end

data/lib/spec/matchers/raise_exception.rb

@@ -0,0 +1,131 @@
+module Spec
+  module Matchers
+    class RaiseException #:nodoc:
+      def initialize(expected_exception_or_message=Exception, expected_message=nil, &block)
+        @block = block
+        @actual_exception = nil
+        case expected_exception_or_message
+        when String, Regexp
+          @expected_exception, @expected_message = Exception, expected_exception_or_message
+        else
+          @expected_exception, @expected_message = expected_exception_or_message, expected_message
+        end
+      end
+
+      def matches?(given_proc)
+        @raised_expected_exception = false
+        @with_expected_message = false
+        @eval_block = false
+        @eval_block_passed = false
+        begin
+          given_proc.call
+        rescue @expected_exception => @actual_exception
+          @raised_expected_exception = true
+          @with_expected_message = verify_message
+        rescue Exception => @actual_exception
+          # This clause should be empty, but rcov will not report it as covered
+          # unless something (anything) is executed within the clause
+          rcov_exception_report = "http://eigenclass.org/hiki.rb?rcov-0.8.0"
+        end
+
+        unless negative_expectation?
+          eval_block if @raised_expected_exception && @with_expected_message && @block
+        end
+
+        (@raised_expected_exception & @with_expected_message) ? (@eval_block ? @eval_block_passed : true) : false
+      end
+
+      def eval_block
+        @eval_block = true
+        begin
+          @block[@actual_exception]
+          @eval_block_passed = true
+        rescue Exception => err
+          @actual_exception = err
+        end
+      end
+
+      def verify_message
+        case @expected_message
+        when nil
+          true
+        when Regexp
+          @expected_message =~ @actual_exception.message
+        else
+          @expected_message == @actual_exception.message
+        end
+      end
+
+      def failure_message_for_should
+        @eval_block ? @actual_exception.message : "expected #{expected_exception}#{given_exception}"
+      end
+
+      def failure_message_for_should_not
+        "expected no #{expected_exception}#{given_exception}"
+      end
+
+      def description
+        "raise #{expected_exception}"
+      end
+
+      private
+        def expected_exception
+          case @expected_message
+          when nil
+            @expected_exception
+          when Regexp
+            "#{@expected_exception} with message matching #{@expected_message.inspect}"
+          else
+            "#{@expected_exception} with #{@expected_message.inspect}"
+          end
+        end
+
+        def given_exception
+          @actual_exception.nil? ? " but nothing was raised" : ", got #{@actual_exception.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
+
+    # :call-seq:
+    #   should raise_exception()
+    #   should raise_exception(NamedError)
+    #   should raise_exception(NamedError, String)
+    #   should raise_exception(NamedError, Regexp)
+    #   should raise_exception() { |exception| ... }
+    #   should raise_exception(NamedError) { |exception| ... }
+    #   should raise_exception(NamedError, String) { |exception| ... }
+    #   should raise_exception(NamedError, Regexp) { |exception| ... }
+    #   should_not raise_exception()
+    #   should_not raise_exception(NamedError)
+    #   should_not raise_exception(NamedError, String)
+    #   should_not raise_exception(NamedError, Regexp)
+    #
+    # With no args, matches if any exception is raised.
+    # With a named exception, matches only if that specific exception is raised.
+    # With a named exception and messsage specified as a String, matches only if both match.
+    # With a named exception 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_exception
+    #   lambda { do_something_risky }.should raise_exception(PoorRiskDecisionError)
+    #   lambda { do_something_risky }.should raise_exception(PoorRiskDecisionError) { |exception| exception.data.should == 42 }
+    #   lambda { do_something_risky }.should raise_exception(PoorRiskDecisionError, "that was too risky")
+    #   lambda { do_something_risky }.should raise_exception(PoorRiskDecisionError, /oo ri/)
+    #
+    #   lambda { do_something_risky }.should_not raise_exception
+    #   lambda { do_something_risky }.should_not raise_exception(PoorRiskDecisionError)
+    #   lambda { do_something_risky }.should_not raise_exception(PoorRiskDecisionError, "that was too risky")
+    #   lambda { do_something_risky }.should_not raise_exception(PoorRiskDecisionError, /oo ri/)
+    def raise_exception(exception=Exception, message=nil, &block)
+      Matchers::RaiseException.new(exception, message, &block)
+    end
+
+    alias_method :raise_error, :raise_exception
+  end
+end

data/lib/spec/matchers/respond_to.rb

@@ -4,28 +4,54 @@ module Spec
     class RespondTo #:nodoc:
       def initialize(*names)
         @names = names
+        @expected_arity = nil
         @names_not_responded_to = []
       end
       
-      def matches?(target)
+      def matches?(actual)
+        @actual = actual
         @names.each do |name|
-          unless target.respond_to?(name)
-            @names_not_responded_to << name
-          end
+          @names_not_responded_to << name unless actual.respond_to?(name) && matches_arity?(actual, name)
         end
         return @names_not_responded_to.empty?
       end
       
-      def failure_message
-        "expected target to respond to #{@names_not_responded_to.collect {|name| name.inspect }.join(', ')}"
+      def failure_message_for_should
+        "expected #{@actual.inspect} to respond to #{@names_not_responded_to.collect {|name| name.inspect }.join(', ')}#{with_arity}"
       end
       
-      def negative_failure_message
-        "expected target not to respond to #{@names.collect {|name| name.inspect }.join(', ')}"
+      def failure_message_for_should_not
+        "expected #{@actual.inspect} not to respond to #{@names.collect {|name| name.inspect }.join(', ')}"
       end
       
       def description
-        "respond to ##{@names.to_s}"
+        "respond to #{pp_names}#{with_arity}"
+      end
+      
+      def with(n)
+        @expected_arity = n
+        self
+      end
+      
+      def argument
+        self
+      end
+      alias :arguments :argument
+      
+    private
+      
+      def matches_arity?(actual, name)
+        @expected_arity.nil?? true : @expected_arity == actual.method(name).arity 
+      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
     

data/lib/spec/matchers/satisfy.rb

@@ -12,11 +12,11 @@ module Spec
         @block.call(actual)
       end
       
-      def failure_message
+      def failure_message_for_should
         "expected #{@actual} to satisfy block"
       end
 
-      def negative_failure_message
+      def failure_message_for_should_not
         "expected #{@actual} not to satisfy block"
       end
     end