rspec-expectations 2.7.0 → 2.8.0.rc1

data/lib/rspec/matchers/equal.rb

@@ -1,27 +1,16 @@
 module RSpec
   module Matchers
-    # Passes if <tt>actual.equal?(expected)</tt> (object identity).
-    #
-    # See http://www.ruby-doc.org/core/classes/Object.html#M001057 for more information about equality in Ruby.
-    #
-    # == Examples
-    #
-    #   5.should equal(5) # Fixnums are equal
-    #   "5".should_not equal("5") # Strings that look the same are not the same object
-    def equal(expected)
-      Matcher.new :equal, expected do |_expected_|
-        match do |actual|
-          actual.equal?(_expected_)
-        end
-        
-        def inspect_object(o)
-          "#<#{o.class}:#{o.object_id}> => #{o.inspect}"
-        end
-        
-        failure_message_for_should do |actual|
-          <<-MESSAGE
-
-expected #{inspect_object(_expected_)}
+    class Equal
+      include BaseMatcher
+
+      def matches?(actual)
+        super(actual).equal?(expected)
+      end
+
+      def failure_message_for_should
+        return <<-MESSAGE
+
+expected #{inspect_object(expected)}
      got #{inspect_object(actual)}
 
 Compared using equal?, which compares object identity,
@@ -30,19 +19,40 @@ but expected and actual are not the same object. Use
 object identity in this example.
 
 MESSAGE
-        end
+      end
 
-        failure_message_for_should_not do |actual|
-          <<-MESSAGE
+      def failure_message_for_should_not
+        return <<-MESSAGE
 
 expected not #{inspect_object(actual)}
-         got #{inspect_object(_expected_)}
+         got #{inspect_object(expected)}
 
 Compared using equal?, which compares object identity.
 
 MESSAGE
-        end
       end
+
+      def diffable?
+        true
+      end
+
+    private
+
+      def inspect_object(o)
+        "#<#{o.class}:#{o.object_id}> => #{o.inspect}"
+      end
+    end
+
+    # Passes if <tt>actual.equal?(expected)</tt> (object identity).
+    #
+    # See http://www.ruby-doc.org/core/classes/Object.html#M001057 for more information about equality in Ruby.
+    #
+    # @example
+    #
+    #   5.should equal(5) # Fixnums are equal
+    #   "5".should_not equal("5") # Strings that look the same are not the same object
+    def equal(expected)
+      Equal.new(expected)
     end
   end
 end

data/lib/rspec/matchers/exist.rb

@@ -1,26 +1,34 @@
 module RSpec
   module Matchers
-    # :call-seq:
-    #   should exist
-    #   should_not exist
-    #
-    # Passes if actual.exist? or actual.exists?
-    def exist(*args)
-      Matcher.new :exist do
-        match do |actual|
-          predicates = [:exist?, :exists?].select { |p| actual.respond_to?(p) }
-          existance_values = predicates.map { |p| actual.send(p, *args) }
-          uniq_truthy_values = existance_values.map { |v| !!v }.uniq
+    class Exist
+      include BaseMatcher
+
+      def initialize(*args)
+        super(args)
+      end
+
+      def matches?(actual)
+        super(actual)
+        predicates = [:exist?, :exists?].select { |p| actual.respond_to?(p) }
+        existance_values = predicates.map { |p| actual.send(p, *expected) }
+        uniq_truthy_values = existance_values.map { |v| !!v }.uniq
 
-          case uniq_truthy_values.size
-            when 0; raise NoMethodError.new("#{actual.inspect} does not respond to either #exist? or #exists?")
-            when 1; existance_values.first
-            else raise "#exist? and #exists? returned different values:\n\n" +
-                       " exist?: #{existance_values.first}\n" +
-                       "exists?: #{existance_values.last}"
-          end
+        case uniq_truthy_values.size
+        when 0; raise NoMethodError.new("#{actual.inspect} does not respond to either #exist? or #exists?")
+        when 1; existance_values.first
+        else raise "#exist? and #exists? returned different values:\n\n" +
+          " exist?: #{existance_values.first}\n" +
+          "exists?: #{existance_values.last}"
         end
       end
     end
+
+    # Passes if `actual.exist?` or `actual.exists?`
+    #
+    # @example
+    #   File.should exist("path/to/file")
+    def exist(*args)
+      Exist.new(*args)
+    end
   end
 end

data/lib/rspec/matchers/have.rb

@@ -102,28 +102,22 @@ EOF
       end
     end
 
-    # :call-seq:
-    #   should have(number).named_collection__or__sugar
-    #   should_not have(number).named_collection__or__sugar
+    # Passes if receiver is a collection with the submitted number of items OR
+    # if the receiver OWNS a collection with the submitted number of items.
     #
-    # Passes if receiver is a collection with the submitted
-    # number of items OR if the receiver OWNS a collection
-    # with the submitted number of items.
+    # If the receiver OWNS the collection, you must use the name of the
+    # collection. So if a `Team` instance has a collection named `#players`,
+    # you must use that name to set the expectation.
     #
-    # If the receiver OWNS the collection, you must use the name
-    # of the collection. So if a <tt>Team</tt> instance has a
-    # collection named <tt>#players</tt>, you must use that name
-    # to set the expectation.
+    # If the receiver IS the collection, you can use any name you like for
+    # `named_collection`. We'd recommend using either "elements", "members", or
+    # "items" as these are all standard ways of describing the things IN a
+    # collection.
     #
-    # If the receiver IS the collection, you can use any name
-    # you like for <tt>named_collection</tt>. We'd recommend using
-    # either "elements", "members", or "items" as these are all
-    # standard ways of describing the things IN a collection.
+    # This also works for Strings, letting you set expectations about their
+    # lengths.
     #
-    # This also works for Strings, letting you set an expectation
-    # about its length
-    #
-    # == Examples
+    # @example
     #
     #   # Passes if team.players.size == 11
     #   team.should have(11).players
@@ -141,26 +135,26 @@ EOF
     end
     alias :have_exactly :have
 
-    # :call-seq:
-    #   should have_at_least(number).items
-    #
     # Exactly like have() with >=.
     #
-    # == Warning
+    # @example
+    #   "this".should have_at_least(3).letters
     #
-    # +should_not+ +have_at_least+ is not supported
+    # ### Warning:
+    #
+    # `should_not have_at_least` is not supported
     def have_at_least(n)
       Matchers::Have.new(n, :at_least)
     end
 
-    # :call-seq:
-    #   should have_at_most(number).items
-    #
     # Exactly like have() with <=.
     #
-    # == Warning
+    # @example
+    #   should have_at_most(number).items
+    #
+    # ### Warning:
     #
-    # +should_not+ +have_at_most+ is not supported
+    # `should_not have_at_most` is not supported
     def have_at_most(n)
       Matchers::Have.new(n, :at_most)
     end

data/lib/rspec/matchers/include.rb

@@ -1,14 +1,53 @@
 module RSpec
   module Matchers
-    # :call-seq:
-    #   should include(expected)
-    #   should_not include(expected)
-    #
+    class Include
+      include BaseMatcher
+
+      def initialize(*expected)
+        super(expected)
+      end
+
+      def matches?(actual)
+        perform_match(:all?, :all?, super(actual), expected)
+      end
+
+      def does_not_match?(actual)
+        @actual = actual
+        perform_match(:none?, :any?, actual, expected)
+      end
+
+      def description
+        "include#{expected_to_sentence}"
+      end
+
+    private
+
+      def perform_match(predicate, hash_predicate, actuals, expecteds)
+        expecteds.send(predicate) do |expected|
+          if comparing_hash_values?(actuals, expected)
+            expected.send(hash_predicate) {|k,v| actuals[k] == v}
+          elsif comparing_hash_keys?(actuals, expected)
+            actuals.has_key?(expected)
+          else
+            actuals.include?(expected)
+          end
+        end
+      end
+
+      def comparing_hash_keys?(actual, expected)
+        actual.is_a?(Hash) && !expected.is_a?(Hash)
+      end
+
+      def comparing_hash_values?(actual, expected)
+        actual.is_a?(Hash) && expected.is_a?(Hash)
+      end
+    end
+
     # 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.
     #
-    # == Examples
+    # @example
     #
     #   [1,2,3].should include(3)
     #   [1,2,3].should include(2,3) #would pass
@@ -17,38 +56,7 @@ module RSpec
     #   "spread".should include("read")
     #   "spread".should_not include("red")
     def include(*expected)
-      Matcher.new :include, *expected do |*_expected|
-
-        diffable
-
-        match_for_should do |actual|
-          perform_match(:all?, :all?, actual, _expected)
-        end
-
-        match_for_should_not do |actual|
-          perform_match(:none?, :any?, actual, _expected)
-        end
-
-        def perform_match(predicate, hash_predicate, actual, _expected)
-          _expected.send(predicate) do |expected|
-            if comparing_hash_values?(actual, expected)
-              expected.send(hash_predicate) {|k,v| actual[k] == v}
-            elsif comparing_hash_keys?(actual, expected)
-              actual.has_key?(expected)
-            else
-              actual.include?(expected)
-            end
-          end
-        end
-
-        def comparing_hash_keys?(actual, expected)
-          actual.is_a?(Hash) && !expected.is_a?(Hash)
-        end
-
-        def comparing_hash_values?(actual, expected)
-          actual.is_a?(Hash) && expected.is_a?(Hash)
-        end
-      end
+      Include.new(*expected)
     end
   end
 end

data/lib/rspec/matchers/match.rb

@@ -1,21 +1,21 @@
 module RSpec
   module Matchers
-    # :call-seq:
-    #   should match(pattern)
-    #   should_not match(pattern)
-    #
+    class Match
+      include BaseMatcher
+
+      def matches?(actual)
+        super(actual).match(expected)
+      end
+    end
+
     # Given a Regexp or String, passes if actual.match(pattern)
     #
-    # == Examples
+    # @example
     #
     #   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
+      Match.new(expected)
     end
   end
 end

data/lib/rspec/matchers/match_array.rb

@@ -1,6 +1,5 @@
 module RSpec
   module Matchers
-
     class MatchArray
       include RSpec::Matchers::Pretty
       
@@ -46,20 +45,15 @@ module RSpec
           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
+    # @example
     #
     #   [1,2,3].should   =~ [1,2,3]   # => would pass
     #   [1,2,3].should   =~ [2,3,1]   # => would pass

data/lib/rspec/matchers/matcher.rb

@@ -147,14 +147,6 @@ module RSpec
         @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
-
       unless method_defined?(:singleton_class)
         def singleton_class
           class << self; self; end

data/lib/rspec/matchers/operator_matcher.rb

@@ -1,6 +1,5 @@
 module RSpec
   module Matchers
-
     class OperatorMatcher
       class << self
         def registry
@@ -82,6 +81,5 @@ module RSpec
       end
 
     end
-
   end
 end

data/lib/rspec/matchers/pretty.rb

@@ -6,7 +6,8 @@ module RSpec
       end
 
       def to_sentence(words)
-        words = words.map{|w| w.inspect}
+        return "" unless words
+        words = Array(words).map{|w| w.inspect}
         case words.length
           when 0
             ""
@@ -32,6 +33,28 @@ module RSpec
         end
         result
       end
+
+      def name_to_sentence
+        split_words(name)
+      end
+
+      def expected_to_sentence
+        to_sentence(@expected) if defined?(@expected)
+      end
+
+      def name
+        defined?(@name) ? @name : underscore(self.class.name.split("::").last)
+      end
+
+      # Borrowed from ActiveSupport
+      def underscore(camel_cased_word)
+        word = camel_cased_word.to_s.dup
+        word.gsub!(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
+        word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+        word.tr!("-", "_")
+        word.downcase!
+        word
+      end
     end
   end
-end
+end

data/lib/rspec/matchers/raise_error.rb

@@ -25,7 +25,7 @@ module RSpec
         rescue Exception => @actual_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"
+          "http://eigenclass.org/hiki.rb?rcov-0.8.0"
         end
 
         unless negative_expectation?
@@ -90,27 +90,13 @@ module RSpec
         end
     end
     
-    # :call-seq:
-    #   should raise_error()
-    #   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)
-    #   should_not raise_error(NamedError, Regexp)
-    #
     # With no args, matches if any error is raised.
     # 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
+    # @example
     #
     #   lambda { do_something_risky }.should raise_error
     #   lambda { do_something_risky }.should raise_error(PoorRiskDecisionError)