rspec-expectations 2.99.2 → 3.0.0.beta1

data/features/step_definitions/additional_cli_steps.rb

@@ -20,13 +20,3 @@ Then /^the example should fail$/ do
   step %q{the output should contain "1 failure"}
   step %q{the exit status should not be 0}
 end
-
-deprecation_message = /rspec-expectations' built-in integration with (Test::Unit|minitest < 5.x) is deprecated/
-
-Then /^the output should contain a deprecation warning about rspec\-expecations' built\-in integration$/ do
-  expect(all_output).to match(deprecation_message)
-end
-
-Then /^the output should not contain a deprecation warning about rspec\-expecations' built\-in integration$/ do
-  expect(all_output).not_to match(deprecation_message)
-end

data/features/support/env.rb

@@ -1,9 +1,11 @@
 require 'aruba/cucumber'
 
-timeouts = { 'java' => 60 }
-
 Before do
-  @aruba_timeout_seconds = timeouts.fetch(RUBY_PLATFORM) { 15 }
+  if RUBY_PLATFORM =~ /java/ || defined?(Rubinius)
+    @aruba_timeout_seconds = 60
+  else
+    @aruba_timeout_seconds = 10
+  end
 end
 
 Aruba.configure do |config|
@@ -12,3 +14,8 @@ Aruba.configure do |config|
   end
 end if RUBY_PLATFORM == 'java'
 
+Aruba.configure do |config|
+  config.before_cmd do |cmd|
+    set_env('RBXOPT', "-Xint=true #{ENV['RBXOPT']}") # disable JIT since these processes are so short lived
+  end
+end if defined?(Rubinius)

data/features/test_frameworks/test_unit.feature

@@ -42,43 +42,3 @@ Feature: Test::Unit integration
      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"
-      And the output should contain a deprecation warning about rspec-expecations' built-in integration
-
-  Scenario: use rspec/expectations with Test::Unit
-    Given a file named "rspec_expectations_with_manual_integration_test.rb" with:
-      """
-      require 'test/unit'
-      require "rspec/expectations"
-
-      class RSpecExpectationsTest < Test::Unit::TestCase
-        include ::RSpec::Matchers
-
-        RSpec::Matchers.define :be_an_integer do
-          match { |actual| Integer === actual }
-        end
-
-        def be_an_int
-          # 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
-          expect(1 + 3).to eq 4
-        end
-
-        def test_failing_expectation
-          expect([1,2]).to be_empty
-        end
-
-        def test_custom_matcher_with_deprecation_warning
-          expect(1).to be_an_int
-        end
-      end
-      """
-     When I run `ruby rspec_expectations_with_manual_integration_test.rb`
-     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 not contain a deprecation warning about rspec-expecations' built-in integration
-

data/lib/rspec-expectations.rb

@@ -1,6 +1 @@
 require "rspec/expectations"
-
-RSpec.deprecate("`require 'rspec-expectations'`",
-                :replacement => "`require 'rspec/expectations'`",
-                # we explcitly pass a caller because CallerFilter ignores this file
-                :call_site => caller[RUBY_PLATFORM == 'java' ? 2 : 0])

data/lib/rspec/expectations.rb

@@ -1,10 +1,12 @@
+require 'rspec/support/caller_filter'
+require 'rspec/support/warnings'
+
 require 'rspec/expectations/extensions'
 require 'rspec/matchers'
 require 'rspec/expectations/expectation_target'
-require 'rspec/expectations/configuration'
+require 'rspec/matchers/configuration'
 require 'rspec/expectations/fail_with'
 require 'rspec/expectations/errors'
-require 'rspec/expectations/deprecation'
 require 'rspec/expectations/handler'
 require 'rspec/expectations/version'
 require 'rspec/expectations/differ'
@@ -59,14 +61,6 @@ module RSpec
     if RUBY_VERSION.to_i >= 2
       def self.method_handle_for(object, method_name)
         KERNEL_METHOD_METHOD.bind(object).call(method_name)
-      rescue NameError => original
-        begin
-          handle = object.method(method_name)
-          raise original unless handle.is_a? Method
-          handle
-        rescue Exception
-          raise original
-        end
       end
     else
       def self.method_handle_for(object, method_name)
@@ -75,14 +69,6 @@ module RSpec
         else
           object.method(method_name)
         end
-      rescue NameError => original
-        begin
-          handle = object.method(method_name)
-          raise original unless handle.is_a? Method
-          handle
-        rescue Exception
-          raise original
-        end
       end
     end
   end

data/lib/rspec/expectations/expectation_target.rb

@@ -1,48 +1,23 @@
 module RSpec
   module Expectations
     # Wraps the target of an expectation.
-    #
     # @example
-    #   expect(something)       # => ExpectationTarget wrapping something
-    #   expect { do_something } # => ExpectationTarget wrapping the block
+    #   expect(something) # => ExpectationTarget wrapping something
     #
     #   # used with `to`
     #   expect(actual).to eq(3)
     #
     #   # with `not_to`
     #   expect(actual).not_to eq(3)
-    #
-    # @note `ExpectationTarget` is not intended to be instantiated
-    #   directly by users. Use `expect` instead.
     class ExpectationTarget
       class << self
         attr_accessor :deprecated_should_enabled
         alias deprecated_should_enabled? deprecated_should_enabled
       end
 
-      # @private
-      # Used as a sentinel value to be able to tell when the user
-      # did not pass an argument. We can't use `nil` for that because
-      # `nil` is a valid value to pass.
-      UndefinedValue = Module.new
-
       # @api private
-      def initialize(value)
-        @target = value
-      end
-
-      # @private
-      def self.for(value, block)
-        if UndefinedValue.equal?(value)
-          unless block
-            raise ArgumentError, "You must pass either an argument or a block to `expect`."
-          end
-          BlockExpectationTarget.new(block)
-        elsif block
-          raise ArgumentError, "You cannot pass both an argument and a block to `expect`."
-        else
-          new(value)
-        end
+      def initialize(target)
+        @target = target
       end
 
       # Runs the given expectation, passing if `matcher` returns true.
@@ -51,11 +26,11 @@ module RSpec
       #   expect { perform }.to raise_error
       # @param [Matcher]
       #   matcher
-      # @param [String] message optional message to display when the expectation fails
+      # @param [String or Proc] message optional message to display when the expectation fails
       # @return [Boolean] true if the expectation succeeds (else raises)
       # @see RSpec::Matchers
       def to(matcher=nil, message=nil, &block)
-        prevent_operator_matchers(:to) unless matcher
+        prevent_operator_matchers(:to, matcher)
         RSpec::Expectations::PositiveExpectationHandler.handle_matcher(@target, matcher, message, &block)
       end
 
@@ -64,11 +39,11 @@ module RSpec
       #   expect(value).not_to eq(5)
       # @param [Matcher]
       #   matcher
-      # @param [String] message optional message to display when the expectation fails
+      # @param [String or Proc] message optional message to display when the expectation fails
       # @return [Boolean] false if the negative expectation succeeds (else raises)
       # @see RSpec::Matchers
       def not_to(matcher=nil, message=nil, &block)
-        prevent_operator_matchers(:not_to) unless matcher
+        prevent_operator_matchers(:not_to, matcher)
         RSpec::Expectations::NegativeExpectationHandler.handle_matcher(@target, matcher, message, &block)
       end
       alias to_not not_to
@@ -100,55 +75,13 @@ module RSpec
 
     private
 
-      def prevent_operator_matchers(verb)
+      def prevent_operator_matchers(verb, matcher)
+        return if matcher
+
         raise ArgumentError, "The expect syntax does not support operator matchers, " +
                              "so you must pass a matcher to `##{verb}`."
       end
     end
-
-    # @private
-    # Validates the provided matcher to ensure it supports block
-    # expectations, in order to avoid user confusion when they
-    # use a block thinking the expectation will be on the return
-    # value of the block rather than the block itself.
-    class BlockExpectationTarget < ExpectationTarget
-      def to(matcher, message=nil, &block)
-        enforce_block_expectation(matcher)
-        super
-      end
-
-      def not_to(matcher, message=nil, &block)
-        enforce_block_expectation(matcher)
-        super
-      end
-      alias to_not not_to
-
-    private
-
-      def enforce_block_expectation(matcher)
-        return if supports_block_expectations?(matcher)
-
-        RSpec.deprecate("Using a matcher in a block expectation expression " +
-                        "(e.g. `expect { }.to matcher`) that does not implement " +
-                        "`supports_block_expectations?`",
-                        :replacement => "a value expectation expression " +
-                        "(e.g. `expect(value).to matcher`) or implement " +
-                        "`supports_block_expectations?` on the provided matcher " +
-                        "(#{description_of matcher})")
-      end
-
-      def supports_block_expectations?(matcher)
-        matcher.supports_block_expectations?
-      rescue NoMethodError
-        false
-      end
-
-      def description_of(matcher)
-        matcher.description
-      rescue NoMethodError
-        matcher.inspect
-      end
-    end
   end
 end
 

data/lib/rspec/expectations/extensions.rb

@@ -1,2 +1 @@
-require 'rspec/expectations/extensions/array'
 require 'rspec/expectations/extensions/object'

data/lib/rspec/expectations/handler.rb

@@ -31,11 +31,7 @@ module RSpec
                     matcher.failure_message
 
         if matcher.respond_to?(:diffable?) && matcher.diffable?
-          if RSpec::Matchers::DSL::Matcher === matcher
-            ::RSpec::Expectations.fail_with message, matcher.expected_as_array, matcher.actual
-          else
-            ::RSpec::Expectations.fail_with message, matcher.expected, matcher.actual
-          end
+          ::RSpec::Expectations.fail_with message, matcher.expected, matcher.actual
         else
           ::RSpec::Expectations.fail_with message
         end

data/lib/rspec/expectations/syntax.rb

@@ -43,17 +43,35 @@ module RSpec
         @default_should_host ||= ::Object.ancestors.last
       end
 
+      def self.warn_about_should!
+        @warn_about_should = true
+      end
+
+      def self.warn_about_should_unless_configured(method_name)
+        if @warn_about_should
+          RSpec.deprecate(
+            "Using `#{method_name}` from rspec-expectations' old `:should` syntax without explicitly enabling the syntax",
+            :replacement => "the new `:expect` syntax or explicitly enable `:should`"
+          )
+
+          @warn_about_should = false
+        end
+      end
+
       # @api private
       # Enables the `should` syntax.
       def enable_should(syntax_host = default_should_host)
+        @warn_about_should = false
         return if should_enabled?(syntax_host)
 
-        syntax_host.module_eval do
+        syntax_host.module_exec do
           def should(matcher=nil, message=nil, &block)
+            ::RSpec::Expectations::Syntax.warn_about_should_unless_configured(__method__)
             ::RSpec::Expectations::PositiveExpectationHandler.handle_matcher(self, matcher, message, &block)
           end
 
           def should_not(matcher=nil, message=nil, &block)
+            ::RSpec::Expectations::Syntax.warn_about_should_unless_configured(__method__)
             ::RSpec::Expectations::NegativeExpectationHandler.handle_matcher(self, matcher, message, &block)
           end
         end
@@ -66,7 +84,7 @@ module RSpec
       def disable_should(syntax_host = default_should_host)
         return unless should_enabled?(syntax_host)
 
-        syntax_host.module_eval do
+        syntax_host.module_exec do
           undef should
           undef should_not
         end
@@ -80,8 +98,10 @@ module RSpec
         return if expect_enabled?(syntax_host)
 
         syntax_host.module_exec do
-          def expect(value=::RSpec::Expectations::ExpectationTarget::UndefinedValue, &block)
-            ::RSpec::Expectations::ExpectationTarget.for(value, block)
+          def expect(*target, &target_block)
+            target << target_block if block_given?
+            raise ArgumentError.new("You must pass an argument or a block to #expect but not both.") unless target.size == 1
+            ::RSpec::Expectations::ExpectationTarget.new(target.first)
           end
         end
 
@@ -93,7 +113,7 @@ module RSpec
       def disable_expect(syntax_host = ::RSpec::Matchers)
         return unless expect_enabled?(syntax_host)
 
-        syntax_host.module_eval do
+        syntax_host.module_exec do
           undef expect
         end
 

data/lib/rspec/expectations/version.rb

@@ -2,7 +2,7 @@ module RSpec
   module Expectations
     # @private
     module Version
-      STRING = '2.99.2'
+      STRING = '3.0.0.beta1'
     end
   end
 end

data/lib/rspec/matchers.rb

@@ -1,11 +1,8 @@
-require 'rspec/matchers/extensions/instance_eval_with_args'
 require 'rspec/matchers/pretty'
 
-require 'rspec/matchers/match_aliases'
 require 'rspec/matchers/built_in'
 require 'rspec/matchers/matcher'
 require 'rspec/matchers/operator_matcher'
-require 'rspec/matchers/be_close'
 
 require 'rspec/matchers/generated_descriptions'
 require 'rspec/matchers/method_missing'
@@ -25,7 +22,6 @@ module RSpec
   #     does_not_match?(actual)
   #     failure_message_for_should_not
   #     description
-  #     supports_block_expectations?
   #
   # ## Predicates
   #
@@ -185,22 +181,6 @@ module RSpec
       obj.respond_to?(:failure_message_for_should) || obj.respond_to?(:failure_message)
     end
 
-    def be_true
-      RSpec.deprecate("`be_true`", :replacement =>
-        "`be_truthy` (for Ruby's conditional semantics) or " +
-        "`be true` (for exact `== true` equality)"
-      )
-      BuiltIn::BeTruthy.new
-    end
-
-    def be_false
-      RSpec.deprecate("`be_false`", :replacement =>
-        "`be_falsey` (for Ruby's conditional semantics) or " +
-        "`be false` (for exact `== false` equality)"
-      )
-      BuiltIn::BeFalsey.new
-    end
-
     # Passes if actual is truthy (anything but false or nil)
     def be_truthy
       BuiltIn::BeTruthy.new
@@ -433,63 +413,6 @@ module RSpec
       BuiltIn::Exist.new(*args)
     end
 
-    # 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 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.
-    #
-    # This also works for Strings, letting you set expectations about their
-    # lengths.
-    #
-    # @example
-    #
-    #   # Passes if team.players.size == 11
-    #   expect(team).to have(11).players
-    #
-    #   # Passes if [1,2,3].length == 3
-    #   expect([1,2,3]).to have(3).items #"items" is pure sugar
-    #
-    #   # Passes if ['a', 'b', 'c'].count == 3
-    #   expect([1,2,3]).to have(3).items #"items" is pure sugar
-    #
-    #   # Passes if "this string".length == 11
-    #   expect("this string").to have(11).characters #"characters" is pure sugar
-    def have(n)
-      BuiltIn::Have.new(n)
-    end
-    alias :have_exactly :have
-
-    # Exactly like have() with >=.
-    #
-    # @example
-    #   expect("this").to have_at_least(3).letters
-    #
-    # ### Warning:
-    #
-    # `expect(..).not_to have_at_least` is not supported
-    def have_at_least(n)
-      BuiltIn::Have.new(n, :at_least)
-    end
-
-    # Exactly like have() with <=.
-    #
-    # @example
-    #   expect("this").to have_at_most(4).letters
-    #
-    # ### Warning:
-    #
-    # `expect(..).not_to have_at_most` is not supported
-    def have_at_most(n)
-      BuiltIn::Have.new(n, :at_most)
-    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.
@@ -510,20 +433,16 @@ module RSpec
     #
     # @example
     #
-    #   expect(email).to   match(/^([^\s]+)((?:[-a-z0-9]+\.)+[a-z]{2,})$/i)
-    #   expect(email).to   match("@example.com")
-    #   expect(zipcode).to match_regex(/\A\d{5}(-\d{4})?\z/)
-    #   expect(zipcode).to match_regex("90210")
+    #   expect(email).to match(/^([^\s]+)((?:[-a-z0-9]+\.)+[a-z]{2,})$/i)
+    #   expect(email).to match("@example.com")
     #
-    # @note Due to Ruby's method dispatch mechanism, using the `#match` matcher
-    # within a custom matcher defined via the matcher DSL
-    # (`RSpec::Matcher.define`) will result Ruby calling the wrong `#match`
-    # method and raising an `ArgumentError`. Instead, use the aliased
-    # `#match_regex` method.
+    # @note The `match_regex` alias is deprecated and is not recommended for use.
+    #       It was added in 2.12.1 to facilitate its use from within custom
+    #       matchers (due to how the custom matcher DSL was evaluated in 2.x,
+    #       `match` could not be used there), but is no longer needed in 3.x.
     def match(expected)
       BuiltIn::Match.new(expected)
     end
-
     alias_method :match_regex, :match
 
     # With no args, matches if any error is raised.
@@ -709,20 +628,6 @@ module RSpec
       BuiltIn::MatchArray.new(array)
     end
 
-    BuiltIn::OperatorMatcher.register(Enumerable, '=~', BuiltIn::MatchArray)
-
-    def self.const_missing(name)
-      case name
-        when :OperatorMatcher
-          RSpec.deprecate("`RSpec::Matchers::OperatorMatcher`",
-                          :replacement => "`RSpec::Matchers::BuiltIn::OperatorMatcher`")
-          BuiltIn::OperatorMatcher
-        when :Configuration
-          RSpec.deprecate("`RSpec::Matchers::Configuration`",
-                          :replacement => "`RSpec::Expectations::Configuration`")
-          Expectations::Configuration
-        else super
-      end
-    end
+    OperatorMatcher.register(Enumerable, '=~', BuiltIn::MatchArray)
   end
 end