rspec-expectations 2.12.1 → 2.13.0

data/features/built_in_matchers/satisfy.feature

@@ -3,8 +3,10 @@ Feature: satisfy matcher
   The satisfy matcher is extremely flexible and can handle almost anything
   you want to specify.  It passes if the block you provide returns true:
 
+    ```ruby
     10.should satisfy { |v| v % 5 == 0 }
     7.should_not satisfy { |v| v % 5 == 0 }
+    ```
 
   This flexibility comes at a cost, however: the failure message
   ("expected [actual] to satisfy block") is not very descriptive

data/features/built_in_matchers/start_with.feature

@@ -3,9 +3,11 @@ Feature: start_with matcher
   Use the `start_with` matcher to specify that a string or array starts with 
   the expected characters or elements.
 
+    ```ruby
     "this string".should start_with("this")
     "this string".should_not start_with("that")
     [0,1,2].should start_with(0, 1)
+    ```
 
   Scenario: with a string
     Given a file named "example_spec.rb" with:

data/features/built_in_matchers/throw_symbol.feature

@@ -3,16 +3,22 @@ Feature: throw_symbol matcher
   The throw_symbol matcher is used to specify that a block of code
   throws a symbol.  The most basic form passes if any symbol is thrown:
 
+    ```ruby
     expect { throw :foo }.to throw_symbol
+    ```
 
   You'll often want to specify that a particular symbol is thrown:
 
+    ```ruby
     expect { throw :foo }.to throw_symbol(:foo)
+    ```
 
   If you care about the additional argument given to throw, you can
   specify that as well:
 
+    ```ruby
     expect { throw :foo, 7 }.to throw_symbol(:foo, 7)
+    ```
 
   Scenario: basic usage
     Given a file named "throw_symbol_matcher_spec.rb" with:

data/features/built_in_matchers/types.feature

@@ -2,18 +2,20 @@ Feature: specify types of objects
 
   rspec-expectations includes two matchers to specify types of objects:
 
-    * obj.should be_kind_of(type): calls obj.kind_of?(type), which returns
+    * `obj.should be_kind_of(type)`: calls `obj.kind_of?(type)`, which returns
       true if type is in obj's class hierarchy or is a module and is
       included in a class in obj's class hierarchy.
-    * obj.should be_instance_of(type): calls obj.instance_of?(type), which
+    * `obj.should be_instance_of(type)`: calls `obj.instance_of?(type)`, which
       returns true if and only if type if obj's class.
 
   Both of these matchers have aliases:
 
-    * obj.should be_a_kind_of(type) # same as obj.should be_kind_of(type)
-    * obj.should be_a(type) # same as obj.should be_kind_of(type)
-    * obj.should be_an(type) # same as obj.should be_kind_of(type)
-    * obj.should be_an_instance_of(type) # same as obj.should be_instance_of(type)
+    ```ruby
+    obj.should be_a_kind_of(type)      # same as obj.should be_kind_of(type)
+    obj.should be_a(type)              # same as obj.should be_kind_of(type)
+    obj.should be_an(type)             # same as obj.should be_kind_of(type)
+    obj.should be_an_instance_of(type) # same as obj.should be_instance_of(type)
+    ```
 
   Scenario: be_(a_)kind_of matcher
     Given a file named "be_kind_of_matcher_spec.rb" with:

data/lib/rspec/expectations/deprecation.rb

@@ -31,7 +31,7 @@ ADDITIONAL
       # is also defined in rspec-core, but we can't assume it's loaded since
       # rspec-expectations should be usable w/o rspec-core.
       def warn_deprecation(message)
-        send :warn, message
+        warn(message)
       end
     end
   end

data/lib/rspec/expectations/differ.rb

@@ -25,7 +25,13 @@ module RSpec
             # diff includes lines of context. Otherwise, we might print
             # redundant lines.
             if (context_lines > 0) and hunk.overlaps?(oldhunk)
-              hunk.unshift(oldhunk)
+              if hunk.respond_to?(:merge)
+                # diff-lcs 1.2.x
+                hunk.merge(oldhunk)
+              else
+                # diff-lcs 1.1.3
+                hunk.unshift(oldhunk)
+              end
             else
               output << oldhunk.diff(format)
             end
@@ -42,13 +48,7 @@ module RSpec
       def diff_as_object(actual, expected)
         actual_as_string = object_to_string(actual)
         expected_as_string = object_to_string(expected)
-        diff = diff_as_string(actual_as_string, expected_as_string)
-
-        if diff.empty?
-          "#{actual}.==(#{expected}) returned false even though the diff " \
-          "between #{actual} and #{expected} is empty. Check the " \
-          "implementation of #{actual}.==."
-        else
+        if diff = diff_as_string(actual_as_string, expected_as_string)
           color_diff diff
         end
       end

data/lib/rspec/expectations/fail_with.rb

@@ -22,8 +22,7 @@ module RSpec
         if actual && expected
           if all_strings?(actual, expected)
             if any_multiline_strings?(actual, expected)
-              expected = expected.join(',') if Array === expected
-              message << "\nDiff:" << differ.diff_as_string(actual, expected)
+              message << "\nDiff:" << differ.diff_as_string(coerce_to_string(actual), coerce_to_string(expected))
             end
           elsif no_procs?(actual, expected) && no_numbers?(actual, expected)
             message << "\nDiff:" << differ.diff_as_object(actual, expected)
@@ -44,12 +43,27 @@ module RSpec
       end
 
       def any_multiline_strings?(*args)
-        all_strings?(*args) && args.any? {|a| a =~ /\n/}
+        all_strings?(*args) && args.flatten.any? { |a| multiline?(a) }
       end
 
       def no_numbers?(*args)
         args.flatten.none? {|a| Numeric === a}
       end
+
+      def coerce_to_string(string_or_array)
+        return string_or_array unless Array === string_or_array
+        string_or_array.join(',')
+      end
+
+      if String.method_defined?(:encoding)
+        def multiline?(string)
+          string.include?("\n".encode(string.encoding))
+        end
+      else
+        def multiline?(string)
+          string.include?("\n")
+        end
+      end
     end
   end
 end

data/lib/rspec/expectations/syntax.rb

@@ -113,6 +113,52 @@ module RSpec
       def expect_enabled?(syntax_host = ::RSpec::Matchers)
         syntax_host.method_defined?(:expect)
       end
+
+      # @api private
+      # Generates a positive expectation expression.
+      def positive_expression(target_expression, matcher_expression)
+        expression_generator.positive_expression(target_expression, matcher_expression)
+      end
+
+      # @api private
+      # Generates a negative expectation expression.
+      def negative_expression(target_expression, matcher_expression)
+        expression_generator.negative_expression(target_expression, matcher_expression)
+      end
+
+      # @api private
+      # Selects which expression generator to use based on the configured syntax.
+      def expression_generator
+        if expect_enabled?
+          ExpectExpressionGenerator
+        else
+          ShouldExpressionGenerator
+        end
+      end
+
+      # @api private
+      # Generates expectation expressions for the `should` syntax.
+      module ShouldExpressionGenerator
+        def self.positive_expression(target_expression, matcher_expression)
+          "#{target_expression}.should #{matcher_expression}"
+        end
+
+        def self.negative_expression(target_expression, matcher_expression)
+          "#{target_expression}.should_not #{matcher_expression}"
+        end
+      end
+
+      # @api private
+      # Generates expectation expressions for the `expect` syntax.
+      module ExpectExpressionGenerator
+        def self.positive_expression(target_expression, matcher_expression)
+          "expect(#{target_expression}).to #{matcher_expression}"
+        end
+
+        def self.negative_expression(target_expression, matcher_expression)
+          "expect(#{target_expression}).not_to #{matcher_expression}"
+        end
+      end
     end
   end
 end

data/lib/rspec/expectations/version.rb

@@ -2,7 +2,7 @@ module RSpec
   module Expectations
     # @private
     module Version
-      STRING = '2.12.1'
+      STRING = '2.13.0'
     end
   end
 end

data/lib/rspec/matchers/built_in/be.rb

@@ -62,7 +62,7 @@ module RSpec
           "expected #{@actual.inspect} to evaluate to false"
         end
 
-        [:==, :<, :<=, :>=, :>, :===].each do |operator|
+        [:==, :<, :<=, :>=, :>, :===, :=~].each do |operator|
           define_method operator do |operand|
             BeComparedTo.new(operand, operator)
           end
@@ -99,7 +99,7 @@ module RSpec
 
         def matches?(actual)
           @actual = actual
-          @actual.send @operator, @expected
+          @actual.__send__ @operator, @expected
         end
 
         def failure_message_for_should
@@ -108,7 +108,7 @@ module RSpec
 
         def failure_message_for_should_not
           message = <<-MESSAGE
-'should_not be #{@operator} #{@expected}' not only FAILED,
+`#{negative_expectation_expression}` not only FAILED,
 it is a bit confusing.
           MESSAGE
 
@@ -120,6 +120,10 @@ it is a bit confusing.
         def description
           "be #{@operator} #{expected_to_sentence}#{args_to_sentence}"
         end
+
+        def negative_expectation_expression
+          Expectations::Syntax.negative_expression("actual", "be #{@operator} #{@expected}")
+        end
       end
 
       class BePredicate < Be

data/lib/rspec/matchers/built_in/be_within.rb

@@ -8,14 +8,23 @@ module RSpec
 
         def matches?(actual)
           @actual = actual
-          raise needs_expected     unless defined? @expected 
+          raise needs_expected     unless defined? @expected
           raise needs_subtractable unless @actual.respond_to? :-
-          (@actual - @expected).abs <= @delta
+          (@actual - @expected).abs <= @tolerance
         end
         alias == matches?
 
         def of(expected)
-          @expected = expected
+          @expected  = expected
+          @tolerance = @delta
+          @unit      = ''
+          self
+        end
+
+        def percent_of(expected)
+          @expected  = expected
+          @tolerance = @delta * @expected / 100
+          @unit      = '%'
           self
         end
 
@@ -28,7 +37,7 @@ module RSpec
         end
 
         def description
-          "be within #{@delta} of #{@expected}"
+          "be within #{@delta}#{@unit} of #{@expected}"
         end
 
         private

data/lib/rspec/matchers/built_in/change.rb

@@ -28,7 +28,7 @@ MESSAGE
 
         def evaluate_value_proc
           case val = @value_proc.call
-          when Enumerable
+          when Enumerable, String
             val.dup
           else
             val
@@ -72,7 +72,7 @@ MESSAGE
         def by_at_most(maximum)
           @maximum = maximum
           self
-        end      
+        end
 
         def to(to)
           @eval_after = true

data/lib/rspec/matchers/built_in/equal.rb

@@ -14,7 +14,7 @@ expected #{inspect_object(expected)}
 
 Compared using equal?, which compares object identity,
 but expected and actual are not the same object. Use
-'actual.should eq(expected)' if you don't care about
+`#{eq_expression}` if you don't care about
 object identity in this example.
 
 MESSAGE
@@ -38,6 +38,10 @@ MESSAGE
         def inspect_object(o)
           "#<#{o.class}:#{o.object_id}> => #{o.inspect}"
         end
+
+        def eq_expression
+          Expectations::Syntax.positive_expression("actual", "eq(expected)")
+        end
       end
     end
   end

data/lib/rspec/matchers/built_in/exist.rb

@@ -9,7 +9,7 @@ module RSpec
         def matches?(actual)
           @actual = actual
           predicates = [:exist?, :exists?].select { |p| @actual.respond_to?(p) }
-          existence_values = predicates.map { |p| @actual.send(p, *@expected) }
+          existence_values = predicates.map { |p| @actual.__send__(p, *@expected) }
           uniq_truthy_values = existence_values.map { |v| !!v }.uniq
 
           case uniq_truthy_values.size

data/lib/rspec/matchers/built_in/have.rb

@@ -24,7 +24,7 @@ module RSpec
           collection = determine_collection(collection_or_owner)
           query_method = determine_query_method(collection)
           raise not_a_collection unless query_method
-          @actual = collection.send(query_method)
+          @actual = collection.__send__(query_method)
           case @relativity
           when :at_least then @actual >= @expected
           when :at_most  then @actual <= @expected
@@ -35,13 +35,13 @@ module RSpec
 
         def determine_collection(collection_or_owner)
           if collection_or_owner.respond_to?(@collection_name)
-            collection_or_owner.send(@collection_name, *@args, &@block)
+            collection_or_owner.__send__(@collection_name, *@args, &@block)
           elsif (@plural_collection_name && collection_or_owner.respond_to?(@plural_collection_name))
-            collection_or_owner.send(@plural_collection_name, *@args, &@block)
+            collection_or_owner.__send__(@plural_collection_name, *@args, &@block)
           elsif determine_query_method(collection_or_owner)
             collection_or_owner
           else
-            collection_or_owner.send(@collection_name, *@args, &@block)
+            collection_or_owner.__send__(@collection_name, *@args, &@block)
           end
         end
 
@@ -64,17 +64,17 @@ module RSpec
             return <<-EOF
 Isn't life confusing enough?
 Instead of having to figure out the meaning of this:
-  should_not have_at_most(#{@expected}).#{@collection_name}
+  #{Expectations::Syntax.negative_expression("actual", "have_at_most(#{@expected}).#{@collection_name}")}
 We recommend that you use this instead:
-  should have_at_least(#{@expected + 1}).#{@collection_name}
+  #{Expectations::Syntax.positive_expression("actual", "have_at_least(#{@expected + 1}).#{@collection_name}")}
 EOF
           elsif @relativity == :at_least
             return <<-EOF
 Isn't life confusing enough?
 Instead of having to figure out the meaning of this:
-  should_not have_at_least(#{@expected}).#{@collection_name}
+  #{Expectations::Syntax.negative_expression("actual", "have_at_least(#{@expected}).#{@collection_name}")}
 We recommend that you use this instead:
-  should have_at_most(#{@expected - 1}).#{@collection_name}
+  #{Expectations::Syntax.positive_expression("actual", "have_at_most(#{@expected - 1}).#{@collection_name}")}
 EOF
           end
         end

data/lib/rspec/matchers/built_in/include.rb

@@ -21,19 +21,23 @@ module RSpec
         end
 
         def diffable?
-          true
+          # Matchers do not diff well, since diff uses their inspect
+          # output, which includes their instance variables and such.
+          @expected.none? { |e| is_a_matcher?(e) }
         end
 
         private
 
         def perform_match(predicate, hash_predicate, actuals, expecteds)
-          expecteds.send(predicate) do |expected|
+          expecteds.__send__(predicate) do |expected|
             if comparing_hash_values?(actuals, expected)
-              expected.send(hash_predicate) {|k,v|
+              expected.__send__(hash_predicate) { |k,v|
                 actuals.has_key?(k) && actuals[k] == v
               }
             elsif comparing_hash_keys?(actuals, expected)
               actuals.has_key?(expected)
+            elsif comparing_with_matcher?(actual, expected)
+              actual.any? { |value| expected.matches?(value) }
             else
               actuals.include?(expected)
             end
@@ -47,6 +51,18 @@ module RSpec
         def comparing_hash_values?(actual, expected)
           actual.is_a?(Hash) && expected.is_a?(Hash)
         end
+
+        def comparing_with_matcher?(actual, expected)
+          actual.is_a?(Array) && is_a_matcher?(expected)
+        end
+
+        def is_a_matcher?(object)
+          return false if object.respond_to?(:i_respond_to_everything_so_im_not_really_a_matcher)
+
+          [:failure_message_for_should, :failure_message].any? do |msg|
+            object.respond_to?(msg)
+          end && object.respond_to?(:matches?)
+        end
       end
     end
   end

data/lib/rspec/matchers/built_in/respond_to.rb

@@ -42,7 +42,7 @@ module RSpec
 
         def find_failing_method_names(actual, filter_method)
           @actual = actual
-          @failing_method_names = @names.send(filter_method) do |name|
+          @failing_method_names = @names.__send__(filter_method) do |name|
             @actual.respond_to?(name) && matches_arity?(actual, name)
           end
         end

data/lib/rspec/matchers/extensions/instance_eval_with_args.rb

@@ -28,7 +28,7 @@ module RSpec
             Thread.critical = orig_critical
           end
           begin
-            return send(method_name, *args)
+            return __send__(method_name, *args)
           ensure
             singleton_class.module_eval{ remove_method(method_name) } rescue nil
           end