rspec-expectations 2.13.0 → 2.14.0

data/features/support/env.rb

@@ -1,5 +1,14 @@
 require 'aruba/cucumber'
 
+timeouts = { 'java' => 60 }
+
 Before do
-  @aruba_timeout_seconds = 15
+  @aruba_timeout_seconds = timeouts.fetch(RUBY_PLATFORM) { 15 }
 end
+
+Aruba.configure do |config|
+  config.before_cmd do |cmd|
+    set_env('JRUBY_OPTS', "-X-C #{ENV['JRUBY_OPTS']}") # disable JIT since these processes are so short lived
+  end
+end if RUBY_PLATFORM == 'java'
+

data/features/syntax_configuration.feature

@@ -47,6 +47,9 @@ Feature: Syntax Configuration
         config.expect_with :rspec do |c|
           c.syntax = :should
         end
+        config.mock_with :rspec do |c|
+          c.syntax = :should
+        end
       end
       """
     When I run `rspec disable_expect_syntax.rb syntaxes_spec.rb`

data/features/test_frameworks/test_unit.feature

@@ -1,11 +1,12 @@
 Feature: Test::Unit integration
 
-  RSpec-expectations is a stand-alone gem that can be used without
-  the rest of RSpec.  It can easily be used with another test
-  framework such as Test::Unit if you like RSpec's should/should_not
-  syntax but prefer the test organization of another framework.
+  RSpec-expectations is a stand-alone gem that can be used without the rest of
+  RSpec. If you like the way Test::Unit (or MiniTest) organizes tests, but
+  prefer RSpec's approach to expressing expectations, you can have both.
 
-  Scenario: Basic Test::Unit usage
+  The one downside is that failures are reported as errors with MiniTest.
+
+  Scenario: use rspec/expectations with Test::Unit
     Given a file named "rspec_expectations_test.rb" with:
       """ruby
       require 'test/unit'
@@ -17,30 +18,27 @@ Feature: Test::Unit integration
         end
 
         def be_an_int
-          RSpec.deprecate(:be_an_int, :be_an_integer)
+          # This is actually an internal rspec-expectations API, but is used
+          # here to demonstrate that deprecation warnings from within
+          # rspec-expectations work correcty without depending on rspec-core
+          RSpec.deprecate(:be_an_int, :replacement => :be_an_integer)
           be_an_integer
         end
 
         def test_passing_expectation
-          x = 1 + 3
-          x.should == 4
+          expect(1 + 3).to eq 4
         end
 
         def test_failing_expectation
-          array = [1, 2]
-          array.should be_empty
-        end
-
-        def test_expect_matcher
-          expect { @a = 5 }.to change { @a }.from(nil).to(5)
+          expect([1,2]).to be_empty
         end
 
-        def test_custom_matcher_and_deprecation_warning
-          1.should be_an_int
+        def test_custom_matcher_with_deprecation_warning
+          expect(1).to be_an_int
         end
       end
       """
      When I run `ruby rspec_expectations_test.rb`
-     Then the output should contain "4 tests, 0 assertions, 1 failures, 0 errors" or "4 tests, 0 assertions, 0 failures, 1 errors"
+     Then the output should contain "3 tests, 0 assertions, 0 failures, 1 errors" or "3 tests, 0 assertions, 1 failures, 0 errors"
       And the output should contain "expected empty? to return true, got false"
       And the output should contain "be_an_int is deprecated"

data/lib/rspec/expectations/deprecation.rb

@@ -1,38 +1,17 @@
 module RSpec
-  unless respond_to?(:deprecate)
-    class << self
-      # Used internally by RSpec to display standard deprecation warnings.
-      # This 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 deprecate(method, alternate_method=nil, version=nil)
-        version_string = version ? "rspec-#{version}" : "a future version of RSpec"
-
-        message = <<-NOTICE
-
-*****************************************************************
-DEPRECATION WARNING: you are using deprecated behaviour that will
-be removed from #{version_string}.
-
-#{caller(0)[2]}
-
-* #{method} is deprecated.
-NOTICE
-      if alternate_method
-        message << <<-ADDITIONAL
-* please use #{alternate_method} instead.
-ADDITIONAL
-      end
-
-        message << "*****************************************************************"
-        warn_deprecation(message)
-      end
-
-      # Used internally by RSpec to display custom deprecation warnings.  This
-      # 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)
-        warn(message)
+  module Expectations
+    module Deprecation
+      # @private
+      #
+      # Used internally to print deprecation warnings
+      def deprecate(deprecated, options={})
+        message = "DEPRECATION: #{deprecated} is deprecated."
+        message << " Use #{options[:replacement]} instead." if options[:replacement]
+        message << " Called from #{caller(0)[2]}."
+        warn message
       end
     end
   end
+
+  extend(Expectations::Deprecation) unless respond_to?(:deprecate)
 end

data/lib/rspec/expectations/differ.rb

@@ -6,11 +6,11 @@ module RSpec
   module Expectations
     class Differ
       # This is snagged from diff/lcs/ldiff.rb (which is a commandline tool)
-      def diff_as_string(data_new, data_old)
-        data_old = data_old.split(/\n/).map! { |e| e.chomp }
-        data_new = data_new.split(/\n/).map! { |e| e.chomp }
+      def diff_as_string(input_data_new, input_data_old)
+        output = matching_encoding("", input_data_old)
+        data_old = input_data_old.split(matching_encoding("\n", input_data_old)).map! { |e| e.chomp }
+        data_new = input_data_new.split(matching_encoding("\n", input_data_new)).map! { |e| e.chomp }
         diffs = Diff::LCS.diff(data_old, data_new)
-        output = ""
         return output if diffs.empty?
         oldhunk = hunk = nil
         file_length_difference = 0
@@ -33,16 +33,24 @@ module RSpec
                 hunk.unshift(oldhunk)
               end
             else
-              output << oldhunk.diff(format)
+              output << matching_encoding(oldhunk.diff(format).to_s, output)
             end
           ensure
             oldhunk = hunk
-            output << "\n"
+            output << matching_encoding("\n", output)
           end
         end
         #Handle the last remaining hunk
-        output << oldhunk.diff(format) << "\n"
+        output << matching_encoding(oldhunk.diff(format).to_s,output)
+        output << matching_encoding("\n",output)
         color_diff output
+      rescue Encoding::CompatibilityError
+        if input_data_new.encoding != input_data_old.encoding
+          "Could not produce a diff because the encoding of the actual string (#{input_data_old.encoding}) "+
+          "differs from the encoding of the expected string (#{input_data_new.encoding})"
+        else
+          "Could not produce a diff because of the encoding of the string (#{input_data_old.encoding})"
+        end
       end
 
       def diff_as_object(actual, expected)
@@ -108,6 +116,16 @@ module RSpec
           PP.pp(object,"")
         end
       end
+
+      if String.method_defined?(:encoding)
+        def matching_encoding(string, source)
+          string.encode(source.encoding)
+        end
+      else
+        def matching_encoding(string, source)
+          string
+        end
+      end
     end
 
   end

data/lib/rspec/expectations/expectation_target.rb

@@ -7,8 +7,8 @@ module RSpec
     #   # used with `to`
     #   expect(actual).to eq(3)
     #
-    #   # with `to_not`
-    #   expect(actual).to_not eq(3)
+    #   # with `not_to`
+    #   expect(actual).not_to eq(3)
     class ExpectationTarget
       class << self
         attr_accessor :deprecated_should_enabled
@@ -36,29 +36,28 @@ module RSpec
 
       # Runs the given expectation, passing if `matcher` returns false.
       # @example
-      #   expect(value).to_not eq(5)
       #   expect(value).not_to eq(5)
       # @param [Matcher]
       #   matcher
       # @param [String] message optional message to display when the expectation fails
       # @return [Boolean] false if the negative expectation succeeds (else raises)
       # @see RSpec::Matchers
-      def to_not(matcher=nil, message=nil, &block)
-        prevent_operator_matchers(:to_not, matcher)
+      def not_to(matcher=nil, message=nil, &block)
+        prevent_operator_matchers(:not_to, matcher)
         RSpec::Expectations::NegativeExpectationHandler.handle_matcher(@target, matcher, message, &block)
       end
-      alias not_to to_not
+      alias to_not not_to
 
       def self.enable_deprecated_should
         return if deprecated_should_enabled?
 
         def should(*args)
-          RSpec.deprecate "`expect { }.should`", "`expect { }.to`", 3
+          RSpec.deprecate "`expect { }.should`", :replacement => "`expect { }.to`"
           @target.should(*args)
         end
 
         def should_not(*args)
-          RSpec.deprecate "`expect { }.should_not`", "`expect { }.to_not`", 3
+          RSpec.deprecate "`expect { }.should_not`", :replacement => "`expect { }.not_to`"
           @target.should_not(*args)
         end
 

data/lib/rspec/expectations/extensions/object.rb

@@ -6,17 +6,7 @@ module RSpec
       def const_missing(name)
         case name
         when :Rspec, :Spec
-          RSpec.warn_deprecation <<-WARNING
-*****************************************************************
-DEPRECATION WARNING: you are using a deprecated constant that will
-be removed from a future version of RSpec.
-
-#{caller(0)[2]}
-
-* #{name} is deprecated.
-* RSpec is the new top-level module in RSpec-2
-***************************************************************
-WARNING
+          RSpec.deprecate(name.to_s, :replacement => "RSpec")
           RSpec
         else
           begin
@@ -31,7 +21,7 @@ WARNING
 
     # @deprecated (no replacement)
     def differ=(ignore)
-      RSpec.deprecate("RSpec::Expectations.differ=(differ)", "nothing at all (diffing is now automatic and no longer configurable)")
+      RSpec.deprecate("RSpec::Expectations.differ=(differ)")
     end
   end
 end

data/lib/rspec/expectations/fail_with.rb

@@ -52,7 +52,17 @@ module RSpec
 
       def coerce_to_string(string_or_array)
         return string_or_array unless Array === string_or_array
-        string_or_array.join(',')
+        diffably_stringify(string_or_array).join("\n")
+      end
+
+      def diffably_stringify(array)
+        array.map do |entry|
+          if Array === entry
+            entry.inspect
+          else
+            entry.to_s.gsub("\n", "\\n")
+          end
+        end
       end
 
       if String.method_defined?(:encoding)

data/lib/rspec/expectations/handler.rb

@@ -2,13 +2,14 @@ module RSpec
   module Expectations
 
     class ExpectationHandler
-      def self.message_must_be_string(msg)
-        "WARNING: ignoring the provided expectation message argument " +
-        "(#{msg.inspect}) since it is not a string."
-      end
-
       def self.check_message(msg)
-        ::Kernel.warn message_must_be_string(msg) unless msg.nil? || msg.is_a?(String)
+        unless msg.nil? || msg.respond_to?(:to_str) || msg.respond_to?(:call)
+          ::Kernel.warn [
+            "WARNING: ignoring the provided expectation message argument (",
+            msg.inspect,
+            ") since it is not a string or a proc."
+          ].join
+        end
       end
     end
 
@@ -23,6 +24,8 @@ module RSpec
         match = matcher.matches?(actual, &block)
         return match if match
 
+        message = message.call if message.respond_to?(:call)
+
         message ||= matcher.respond_to?(:failure_message_for_should) ?
                     matcher.failure_message_for_should :
                     matcher.failure_message
@@ -47,6 +50,8 @@ module RSpec
                 matcher.matches?(actual, &block)
         return match unless match
 
+        message = message.call if message.respond_to?(:call)
+
         message ||= matcher.respond_to?(:failure_message_for_should_not) ?
                     matcher.failure_message_for_should_not :
                     matcher.negative_failure_message

data/lib/rspec/expectations/syntax.rb

@@ -32,10 +32,10 @@ module RSpec
       # `ExpectationTarget`.
       # @example
       #   expect(actual).to eq(expected)
-      #   expect(actual).to_not eq(expected)
+      #   expect(actual).not_to eq(expected)
       # @return [ExpectationTarget]
       # @see ExpectationTarget#to
-      # @see ExpectationTarget#to_not
+      # @see ExpectationTarget#not_to
 
       # @api private
       # Determines where we add `should` and `should_not`.

data/lib/rspec/expectations/version.rb

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

data/lib/rspec/expectations.rb

@@ -37,7 +37,7 @@ module RSpec
   # `eq.failure_message_for_should_not`.
   #
   # rspec-expectations ships with a standard set of useful matchers, and writing
-  # your own matchers is quite simple. 
+  # your own matchers is quite simple.
   #
   # See [RSpec::Matchers](../RSpec/Matchers) for more information about the
   # built-in matchers that ship with rspec-expectations, and how to write your

data/lib/rspec/matchers/be_close.rb

@@ -2,7 +2,7 @@ module RSpec
   module Matchers
     # @deprecated use +be_within+ instead.
     def be_close(expected, delta)
-      RSpec.deprecate("be_close(#{expected}, #{delta})", "be_within(#{delta}).of(#{expected})")
+      RSpec.deprecate("be_close(#{expected}, #{delta})", :replacement => "be_within(#{delta}).of(#{expected})")
       be_within(delta).of(expected)
     end
   end

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

@@ -148,6 +148,8 @@ it is a bit confusing.
           end
         end
 
+        alias === matches?
+
         def failure_message_for_should
           "expected #{predicate}#{args_to_s} to return true, got #{@result.inspect}"
         end

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

@@ -23,7 +23,7 @@ module RSpec
 
         def percent_of(expected)
           @expected  = expected
-          @tolerance = @delta * @expected / 100
+          @tolerance = @delta * @expected.abs / 100.0
           @unit      = '%'
           self
         end

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

@@ -39,7 +39,7 @@ MESSAGE
           if @eval_before && !expected_matches_actual?(@expected_before, @actual_before)
             "#{message} should have initially been #{@expected_before.inspect}, but was #{@actual_before.inspect}"
           elsif @eval_after && !expected_matches_actual?(@expected_after, @actual_after)
-            "#{message} should have been changed to #{@expected_after.inspect}, but is now #{@actual_after.inspect}"
+            "#{message} should have been changed to #{failure_message_for_expected_after}, but is now #{@actual_after.inspect}"
           elsif @expected_delta
             "#{message} should have been changed by #{@expected_delta.inspect}, but was changed by #{actual_delta.inspect}"
           elsif @minimum
@@ -92,6 +92,14 @@ MESSAGE
 
         private
 
+        def failure_message_for_expected_after
+          if RSpec::Matchers.is_a_matcher?(@expected_after)
+            @expected_after.description
+          else
+            @expected_after.inspect
+          end
+        end
+
         def message
           @message || "result"
         end

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

@@ -2,6 +2,8 @@ module RSpec
   module Matchers
     module BuiltIn
       class Have
+        QUERY_METHODS = [:size, :length, :count].freeze
+
         def initialize(expected, relativity=:exactly)
           @expected = case expected
                       when :no then 0
@@ -22,9 +24,19 @@ module RSpec
 
         def matches?(collection_or_owner)
           collection = determine_collection(collection_or_owner)
-          query_method = determine_query_method(collection)
-          raise not_a_collection unless query_method
-          @actual = collection.__send__(query_method)
+          case collection
+          when enumerator_class
+            for query_method in QUERY_METHODS
+              next unless collection.respond_to?(query_method)
+              @actual = collection.__send__(query_method)
+              break unless @actual.nil?
+            end
+            raise not_a_collection if @actual.nil?
+          else
+            query_method = determine_query_method(collection)
+            raise not_a_collection unless query_method
+            @actual = collection.__send__(query_method)
+          end
           case @relativity
           when :at_least then @actual >= @expected
           when :at_most  then @actual <= @expected
@@ -46,7 +58,7 @@ module RSpec
         end
 
         def determine_query_method(collection)
-          [:size, :length, :count].detect {|m| collection.respond_to?(m)}
+          QUERY_METHODS.detect {|m| collection.respond_to?(m)}
         end
 
         def not_a_collection
@@ -102,6 +114,10 @@ EOF
         def relative_expectation
           "#{relativities[@relativity]}#{@expected}"
         end
+
+        def enumerator_class
+          RUBY_VERSION < '1.9' ? Enumerable::Enumerator : Enumerator
+        end
       end
     end
   end

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

@@ -23,7 +23,7 @@ module RSpec
         def diffable?
           # 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) }
+          @expected.none? { |e| RSpec::Matchers.is_a_matcher?(e) }
         end
 
         private
@@ -53,15 +53,7 @@ module RSpec
         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?)
+          actual.is_a?(Array) && RSpec::Matchers.is_a_matcher?(expected)
         end
       end
     end

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

@@ -14,19 +14,31 @@ module RSpec
         end
 
         def matches?(given_proc, negative_expectation = false)
+          if negative_expectation && (expecting_specific_exception? || @expected_message)
+            what_to_deprecate = if expecting_specific_exception? && @expected_message
+                                  "`expect { }.not_to raise_error(SpecificErrorClass, message)`"
+                                elsif expecting_specific_exception?
+                                  "`expect { }.not_to raise_error(SpecificErrorClass)`"
+                                elsif @expected_message
+                                  "`expect { }.not_to raise_error(message)`"
+                                end
+            RSpec.deprecate(what_to_deprecate, :replacement => "`expect { }.not_to raise_error()`")
+          end
           @raised_expected_error = false
           @with_expected_message = false
           @eval_block = false
           @eval_block_passed = false
+          unless given_proc.respond_to?(:call)
+            ::Kernel.warn "`raise_error` was called with non-proc object #{given_proc.inspect}"
+            return false
+          end
           begin
             given_proc.call
-          rescue @expected_error => @actual_error
-            @raised_expected_error = true
-            @with_expected_message = verify_message
           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
-            "http://eigenclass.org/hiki.rb?rcov-0.8.0"
+            if @actual_error == @expected_error || @expected_error === @actual_error
+              @raised_expected_error = true
+              @with_expected_message = verify_message
+            end
           end
 
           unless negative_expectation
@@ -79,7 +91,7 @@ module RSpec
         def expected_error
           case @expected_message
           when nil
-            @expected_error
+            @expected_error.inspect
           when Regexp
             "#{@expected_error} with message matching #{@expected_message.inspect}"
           else
@@ -101,6 +113,10 @@ module RSpec
             *backtrace
           ].join("\n  # ")
         end
+
+        def expecting_specific_exception?
+          @expected_error != Exception
+        end
       end
     end
   end

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

@@ -65,17 +65,92 @@ module RSpec
       end
 
       class YieldControl < BaseMatcher
+        def initialize
+          @expectation_type = nil
+          @expected_yields_count = nil
+        end
+
         def matches?(block)
           probe = YieldProbe.probe(block)
-          probe.yielded_once?(:yield_control)
+
+          if @expectation_type
+            probe.num_yields.send(@expectation_type, @expected_yields_count)
+          else
+            probe.yielded_once?(:yield_control)
+          end
+        end
+
+        def once
+          exactly(1)
+          self
+        end
+
+        def twice
+          exactly(2)
+          self
+        end
+
+        def exactly(number)
+          set_expected_yields_count(:==, number)
+          self
+        end
+
+        def at_most(number)
+          set_expected_yields_count(:<=, number)
+          self
+        end
+
+        def at_least(number)
+          set_expected_yields_count(:>=, number)
+          self
+        end
+
+        def times
+          self
         end
 
         def failure_message_for_should
-          "expected given block to yield control"
+          'expected given block to yield control'.tap do |failure_message|
+            failure_message << relativity_failure_message
+          end
         end
 
         def failure_message_for_should_not
-          "expected given block not to yield control"
+          'expected given block not to yield control'.tap do |failure_message|
+            failure_message << relativity_failure_message
+          end
+        end
+
+        private
+
+        def set_expected_yields_count(relativity, n)
+          @expectation_type = relativity
+          @expected_yields_count = case n
+                                   when Numeric then n
+                                   when :once then 1
+                                   when :twice then 2
+                                   end
+        end
+
+        def relativity_failure_message
+          return '' unless @expected_yields_count
+          " #{human_readable_expecation_type}#{human_readable_count}"
+        end
+
+        def human_readable_expecation_type
+          case @expectation_type
+          when :<= then 'at most '
+          when :>= then 'at least '
+          else ''
+          end
+        end
+
+        def human_readable_count
+          case @expected_yields_count
+          when 1 then "once"
+          when 2 then "twice"
+          else "#{@expected_yields_count} times"
+          end
         end
       end
 

data/lib/rspec/matchers/operator_matcher.rb

@@ -91,7 +91,7 @@ module RSpec
           if actual.__send__(operator, expected)
             true
           elsif ['==','===', '=~'].include?(operator)
-            fail_with_message("expected: #{expected.inspect}\n     got: #{actual.inspect} (using #{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