rspec 1.1.11 → 1.1.12

data/lib/spec/matchers/generated_descriptions.rb

@@ -0,0 +1,48 @@
+module Spec
+  module Matchers
+    def self.last_matcher
+      @last_matcher
+    end
+
+    def self.last_matcher=(last_matcher)
+      @last_matcher = last_matcher
+    end
+
+    def self.last_should
+      @last_should
+    end
+
+    def self.last_should=(last_should)
+      @last_should = last_should
+    end
+
+    def self.clear_generated_description
+      self.last_matcher = nil
+      self.last_should = nil
+    end
+
+    def self.generated_description
+      return nil if last_should.nil?
+      "#{last_should.to_s.gsub('_',' ')} #{last_description}"
+    end
+    
+    private
+    
+    def self.last_description
+      last_matcher.respond_to?(:description) ? last_matcher.description : <<-MESSAGE
+When you call a matcher in an example without a String, like this:
+
+specify { object.should matcher }
+
+or this:
+
+it { should matcher }
+
+the runner expects the matcher to have a #describe method. You should either
+add a String to the example this matcher is being used in, or give it a
+description method. Then you won't have to suffer this lengthy warning again.
+MESSAGE
+    end
+  end
+end
+      

data/lib/spec/matchers/has.rb

@@ -1,34 +1,18 @@
 module Spec
   module Matchers
-    
-    class Has #:nodoc:
-      def initialize(sym, *args)
-        @sym = sym
-        @args = args
-      end
-      
-      def matches?(given)
-        given.__send__(predicate, *@args)
-      end
-      
-      def failure_message
-        "expected ##{predicate}(#{@args[0].inspect}) to return true, got false"
-      end
-      
-      def negative_failure_message
-        "expected ##{predicate}(#{@args[0].inspect}) to return false, got true"
+    def has(sym, *args) # :nodoc:
+      simple_matcher do |actual, matcher|
+        matcher.failure_message          = "expected ##{predicate(sym)}(#{args[0].inspect}) to return true, got false"
+        matcher.negative_failure_message = "expected ##{predicate(sym)}(#{args[0].inspect}) to return false, got true"
+        matcher.description              = "have key #{args[0].inspect}"
+        actual.__send__(predicate(sym), *args)
       end
-      
-      def description
-        "have key #{@args[0].inspect}"
-      end
-      
-      private
-        def predicate
-          "#{@sym.to_s.sub("have_","has_")}?".to_sym
-        end
-        
     end
- 
+    
+  private
+    def predicate(sym)
+      "#{sym.to_s.sub("have_","has_")}?".to_sym
+    end
+
   end
 end

data/lib/spec/matchers/include.rb

@@ -7,16 +7,19 @@ module Spec
         @expecteds = expecteds
       end
       
-      def matches?(given)
-        @given = given
+      def matches?(actual)
+        @actual = actual
         @expecteds.each do |expected|
-          case given
-          when Hash
-            expected.each_pair do |k,v|
-              return false unless given[k] == v
+          if actual.is_a?(Hash)
+            if expected.is_a?(Hash)
+              expected.each_pair do |k,v|
+                return false unless actual[k] == v
+              end
+            else
+              return false unless actual.has_key?(expected)
             end
           else
-            return false unless given.include?(expected)
+            return false unless actual.include?(expected)
           end
         end
         true
@@ -36,7 +39,7 @@ module Spec
       
       private
         def _message(maybe_not="")
-          "expected #{@given.inspect} #{maybe_not}to include #{_pretty_print(@expecteds)}"
+          "expected #{@actual.inspect} #{maybe_not}to include #{_pretty_print(@expecteds)}"
         end
         
         def _pretty_print(array)
@@ -58,7 +61,7 @@ module Spec
     #   should include(expected)
     #   should_not include(expected)
     #
-    # Passes if given includes expected. This works for
+    # Passes if actual 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/lib/spec/matchers/match.rb

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

data/lib/spec/matchers/match_array.rb

@@ -0,0 +1,79 @@
+module Spec
+  module Matchers
+
+    class MatchArray #:nodoc:
+
+      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
+        message =  "expected collection contained:  #{@expected.sort.inspect}\n"
+        message += "actual collection contained:    #{@actual.sort.inspect}\n"
+        message += "the missing elements were:      #{@missing_items.sort.inspect}\n" unless @missing_items.empty?
+        message += "the extra elements were:        #{@extra_items.sort.inspect}\n" unless @extra_items.empty?
+        message
+      end
+      
+      def negative_failure_message
+        "Matcher does not support should_not"
+      end
+      
+      def description
+        "contain exactly #{_pretty_print(@expected)}"
+      end
+
+      private
+
+        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
+
+        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
+
+    # :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/method_missing.rb

@@ -0,0 +1,9 @@
+module Spec
+  module Matchers
+    def method_missing(sym, *args, &block) # :nodoc:
+      return Matchers::Be.new(sym, *args) if sym.starts_with?("be_")
+      return has(sym, *args) if sym.starts_with?("have_")
+      super
+    end
+  end
+end

data/lib/spec/matchers/operator_matcher.rb

@@ -1,76 +1,67 @@
 module Spec
   module Matchers
-    class BaseOperatorMatcher
-      attr_reader :generated_description
-      
-      def initialize(given)
-        @given = given
-      end
-
-      def ==(expected)
-        @expected = expected
-        __delegate_method_missing_to_given("==", expected)
-      end
 
-      def ===(expected)
-        @expected = expected
-        __delegate_method_missing_to_given("===", expected)
-      end
+    class OperatorMatcher
+      class << self
+        def registry
+          @registry ||= Hash.new {|h,k| h[k] = {}}
+        end
 
-      def =~(expected)
-        @expected = expected
-        __delegate_method_missing_to_given("=~", expected)
-      end
+        def register(klass, operator, matcher)
+          registry[klass][operator] = matcher
+        end
 
-      def >(expected)
-        @expected = expected
-        __delegate_method_missing_to_given(">", expected)
+        def get(klass, operator)
+          registry[klass][operator]
+        end
       end
 
-      def >=(expected)
-        @expected = expected
-        __delegate_method_missing_to_given(">=", expected)
+      def initialize(actual)
+        @actual = actual
       end
 
-      def <(expected)
-        @expected = expected
-        __delegate_method_missing_to_given("<", 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
+            ::Spec::Matchers.last_matcher = self
+            @operator, @expected = operator, expected
+            __delegate_operator(@actual, operator, expected)
+          end
+        end
       end
 
-      def <=(expected)
-        @expected = expected
-        __delegate_method_missing_to_given("<=", expected)
+      ['==', '===', '=~', '>', '>=', '<', '<='].each do |operator|
+        use_custom_matcher_or_delegate operator
       end
 
       def fail_with_message(message)
-        Spec::Expectations.fail_with(message, @expected, @given)
+        Spec::Expectations.fail_with(message, @expected, @actual)
       end
-      
+
       def description
         "#{@operator} #{@expected.inspect}"
       end
 
     end
 
-    class PositiveOperatorMatcher < BaseOperatorMatcher #:nodoc:
-
-      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}")
+    class PositiveOperatorMatcher < OperatorMatcher #:nodoc:
+      def __delegate_operator(actual, operator, expected)
+        return true if actual.__send__(operator, expected)
+        if ['==','===', '=~'].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_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}")
+    class NegativeOperatorMatcher < OperatorMatcher #:nodoc:
+      def __delegate_operator(actual, operator, expected)
+        return true 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/raise_error.rb

@@ -47,20 +47,16 @@ module Spec
       def verify_message
         case @expected_message
         when nil
-          return true
+          true
         when Regexp
-          return @expected_message =~ @given_error.message
+          @expected_message =~ @given_error.message
         else
-          return @expected_message == @given_error.message
+          @expected_message == @given_error.message
         end
       end
       
       def failure_message
-        if @eval_block
-          return @given_error.message
-        else
-          return "expected #{expected_error}#{given_error}"
-        end
+        @eval_block ? @given_error.message : "expected #{expected_error}#{given_error}"
       end
 
       def negative_failure_message

data/lib/spec/matchers/respond_to.rb

@@ -4,29 +4,54 @@ module Spec
     class RespondTo #:nodoc:
       def initialize(*names)
         @names = names
+        @expected_arity = nil
         @names_not_responded_to = []
       end
       
-      def matches?(given)
-        @given = given
+      def matches?(actual)
+        @actual = actual
         @names.each do |name|
-          unless given.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 #{@given.inspect} to respond to #{@names_not_responded_to.collect {|name| name.inspect }.join(', ')}"
+        "expected #{@actual.inspect} to respond to #{@names_not_responded_to.collect {|name| name.inspect }.join(', ')}#{with_arity}"
       end
       
       def negative_failure_message
-        "expected #{@given.inspect} not to respond to #{@names.collect {|name| name.inspect }.join(', ')}"
+        "expected #{@actual.inspect} not to respond to #{@names.collect {|name| name.inspect }.join(', ')}"
       end
       
       def description
-        "respond to ##{@names.to_s}"
+        # Ruby 1.9 returns the same thing for array.to_s as array.inspect, so just use array.inspect here
+        "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
+        @names.length == 1 ? "##{@names.first}" : @names.inspect
       end
     end