mocha 1.14.0 → 2.0.0.alpha

data/lib/mocha/expectation.rb

@@ -1,3 +1,4 @@
+require 'ruby2_keywords'
 require 'mocha/method_matcher'
 require 'mocha/parameters_matcher'
 require 'mocha/expectation_error'
@@ -187,17 +188,26 @@ module Mocha
       at_most(1)
     end
 
-    # Modifies expectation so that the expected method must be called with +expected_parameters+.
+    # Modifies expectation so that the expected method must be called with +expected_parameters_or_matchers+.
     #
-    # May be used with parameter matchers in {ParameterMatchers}.
+    # May be used with Ruby literals or variables for exact matching or with parameter matchers for less-specific matching, e.g. {ParameterMatchers#includes}, {ParameterMatchers#has_key}, etc. See {ParameterMatchers} for a list of all available parameter matchers.
     #
-    # @param [*Array] expected_parameters parameters expected.
+    # Positional arguments were separated from keyword arguments in Ruby v3 (see {https://www.ruby-lang.org/en/news/2019/12/12/separation-of-positional-and-keyword-arguments-in-ruby-3-0 this article}). In relation to this a new configuration option ({Configuration#strict_keyword_argument_matching=}) is available in Ruby >= 2.7.
+    #
+    # When {Configuration#strict_keyword_argument_matching=} is set to +false+ (which is currently the default), a positional +Hash+ and a set of keyword arguments passed to {#with} are treated the same for the purposes of parameter matching. However, a deprecation warning will be displayed if a positional +Hash+ matches a set of keyword arguments or vice versa. This is because {Configuration#strict_keyword_argument_matching=} will default to +true+ in the future.
+    #
+    # When {Configuration#strict_keyword_argument_matching=} is set to +true+, an actual positional +Hash+ will not match an expected set of keyword arguments; and vice versa, an actual set of keyword arguments will not match an expected positional +Hash+, i.e. the parameter matching is stricter.
+    #
+    # @see ParameterMatchers
+    # @see Configuration#strict_keyword_argument_matching=
+    #
+    # @param [*Array<Object,ParameterMatchers::Base>] expected_parameters_or_matchers expected parameter values or parameter matchers.
     # @yield optional block specifying custom matching.
-    # @yieldparam [*Array] actual_parameters parameters with which expected method was invoked.
+    # @yieldparam [*Array<Object>] actual_parameters parameters with which expected method was invoked.
     # @yieldreturn [Boolean] +true+ if +actual_parameters+ are acceptable.
     # @return [Expectation] the same expectation, thereby allowing invocations of other {Expectation} methods to be chained.
     #
-    # @example Expected method must be called with expected parameters.
+    # @example Expected method must be called with exact parameter values.
     #   object = mock()
     #   object.expects(:expected_method).with(:param1, :param2)
     #   object.expected_method(:param1, :param2)
@@ -208,6 +218,43 @@ module Mocha
     #   object.expected_method(:param3)
     #   # => verify fails
     #
+    # @example Expected method must be called with parameters matching parameter matchers.
+    #   object = mock()
+    #   object.expects(:expected_method).with(includes('string2'), anything)
+    #   object.expected_method(['string1', 'string2'], 'any-old-value')
+    #   # => verify succeeds
+    #
+    #   object = mock()
+    #   object.expects(:expected_method).with(includes('string2'), anything)
+    #   object.expected_method(['string1'], 'any-old-value')
+    #   # => verify fails
+    #
+    # @example Loose keyword argument matching (default)
+    #
+    #   class Example
+    #     def foo(a, bar:); end
+    #   end
+    #
+    #   example = Example.new
+    #   example.expects(:foo).with('a', bar: 'b')
+    #   example.foo('a', { bar: 'b' })
+    #   # This passes the test, but would result in an ArgumentError in practice
+    #
+    # @example Strict keyword argument matching
+    #
+    #   Mocha.configure do |c|
+    #     c.strict_keyword_argument_matching = true
+    #   end
+    #
+    #   class Example
+    #     def foo(a, bar:); end
+    #   end
+    #
+    #   example = Example.new
+    #   example.expects(:foo).with('a', bar: 'b')
+    #   example.foo('a', { bar: 'b' })
+    #   # This now fails as expected
+    #
     # @example Expected method must be called with a value divisible by 4.
     #   object = mock()
     #   object.expects(:expected_method).with() { |value| value % 4 == 0 }
@@ -218,10 +265,11 @@ module Mocha
     #   object.expects(:expected_method).with() { |value| value % 4 == 0 }
     #   object.expected_method(17)
     #   # => verify fails
-    def with(*expected_parameters, &matching_block)
-      @parameters_matcher = ParametersMatcher.new(expected_parameters, &matching_block)
+    def with(*expected_parameters_or_matchers, &matching_block)
+      @parameters_matcher = ParametersMatcher.new(expected_parameters_or_matchers, &matching_block)
       self
     end
+    ruby2_keywords(:with)
 
     # Modifies expectation so that the expected method must be called with a block.
     #

data/lib/mocha/inspect.rb

@@ -18,9 +18,9 @@ module Mocha
     end
 
     module HashMethods
-      def mocha_inspect(wrapped = true)
+      def mocha_inspect
         unwrapped = collect { |key, value| "#{key.mocha_inspect} => #{value.mocha_inspect}" }.join(', ')
-        wrapped ? "{#{unwrapped}}" : unwrapped
+        Hash.ruby2_keywords_hash?(self) ? unwrapped : "{#{unwrapped}}"
       end
     end
 

data/lib/mocha/instance_method.rb

@@ -8,10 +8,6 @@ module Mocha
       stubbee
     end
 
-    def method_body(method)
-      PRE_RUBY_V19 ? proc { |*args, &block| method.call(*args, &block) } : method
-    end
-
     def stubbee_method(method_name)
       stubbee._method(method_name)
     end

data/lib/mocha/integration/mini_test.rb

@@ -1,54 +1,26 @@
 require 'mocha/debug'
-
 require 'mocha/detection/mini_test'
-
-require 'mocha/integration/mini_test/nothing'
-require 'mocha/integration/mini_test/version_13'
-require 'mocha/integration/mini_test/version_140'
-require 'mocha/integration/mini_test/version_141'
-require 'mocha/integration/mini_test/version_142_to_172'
-require 'mocha/integration/mini_test/version_200'
-require 'mocha/integration/mini_test/version_201_to_222'
-require 'mocha/integration/mini_test/version_230_to_2101'
-require 'mocha/integration/mini_test/version_2110_to_2111'
-require 'mocha/integration/mini_test/version_2112_to_320'
 require 'mocha/integration/mini_test/adapter'
 
-require 'mocha/deprecation'
-
 module Mocha
   module Integration
     module MiniTest
       def self.activate
-        return false unless Detection::MiniTest.testcase
-        mini_test_version = Gem::Version.new(Detection::MiniTest.version)
+        target = Detection::MiniTest.testcase
+        return false unless target
 
+        mini_test_version = Gem::Version.new(Detection::MiniTest.version)
         Debug.puts "Detected MiniTest version: #{mini_test_version}"
 
-        integration_module = [
-          MiniTest::Adapter,
-          MiniTest::Version2112To320,
-          MiniTest::Version2110To2111,
-          MiniTest::Version230To2101,
-          MiniTest::Version201To222,
-          MiniTest::Version200,
-          MiniTest::Version142To172,
-          MiniTest::Version141,
-          MiniTest::Version140,
-          MiniTest::Version13,
-          MiniTest::Nothing
-        ].detect { |m| m.applicable_to?(mini_test_version) }
+        unless MiniTest::Adapter.applicable_to?(mini_test_version)
+          raise 'Versions of minitest earlier than v3.3.0 are not supported.'
+        end
 
-        target = Detection::MiniTest.testcase
-        unless target < integration_module
-          unless integration_module == MiniTest::Adapter
-            Deprecation.warning(
-              'Versions of minitest earlier than v3.3.0 will not be supported in future versions of Mocha.'
-            )
-          end
-          Debug.puts "Applying #{integration_module.description}"
-          target.send(:include, integration_module)
+        unless target < MiniTest::Adapter
+          Debug.puts "Applying #{MiniTest::Adapter.description}"
+          target.send(:include, MiniTest::Adapter)
         end
+
         true
       end
     end

data/lib/mocha/integration/test_unit/adapter.rb

@@ -12,7 +12,7 @@ module Mocha
         include Mocha::API
 
         # @private
-        def self.applicable_to?(test_unit_version, _ruby_version = nil)
+        def self.applicable_to?(test_unit_version)
           Gem::Requirement.new('>= 2.5.1').satisfied_by?(test_unit_version)
         end
 

data/lib/mocha/integration/test_unit.rb

@@ -1,49 +1,26 @@
 require 'mocha/debug'
-
 require 'mocha/detection/test_unit'
-
-require 'mocha/integration/test_unit/nothing'
-require 'mocha/integration/test_unit/ruby_version_185_and_below'
-require 'mocha/integration/test_unit/ruby_version_186_and_above'
-require 'mocha/integration/test_unit/gem_version_200'
-require 'mocha/integration/test_unit/gem_version_201_to_202'
-require 'mocha/integration/test_unit/gem_version_203_to_220'
-require 'mocha/integration/test_unit/gem_version_230_to_250'
 require 'mocha/integration/test_unit/adapter'
 
-require 'mocha/deprecation'
-
 module Mocha
   module Integration
     module TestUnit
       def self.activate
-        return false unless Detection::TestUnit.testcase
-        test_unit_version = Gem::Version.new(Detection::TestUnit.version)
-        ruby_version = Gem::Version.new(RUBY_VERSION.dup)
+        target = Detection::TestUnit.testcase
+        return false unless target
 
-        Debug.puts "Detected Ruby version: #{ruby_version}"
+        test_unit_version = Gem::Version.new(Detection::TestUnit.version)
         Debug.puts "Detected Test::Unit version: #{test_unit_version}"
 
-        integration_module = [
-          TestUnit::Adapter,
-          TestUnit::GemVersion230To250,
-          TestUnit::GemVersion203To220,
-          TestUnit::GemVersion201To202,
-          TestUnit::GemVersion200,
-          TestUnit::RubyVersion186AndAbove,
-          TestUnit::RubyVersion185AndBelow,
-          TestUnit::Nothing
-        ].detect { |m| m.applicable_to?(test_unit_version, ruby_version) }
+        unless TestUnit::Adapter.applicable_to?(test_unit_version)
+          raise 'Versions of test-unit earlier than v2.5.1 are not supported.'
+        end
 
-        unless ::Test::Unit::TestCase < integration_module
-          unless integration_module == TestUnit::Adapter
-            Deprecation.warning(
-              'Versions of test-unit earlier than v2.5.1 will not be supported in future versions of Mocha.'
-            )
-          end
-          Debug.puts "Applying #{integration_module.description}"
-          ::Test::Unit::TestCase.send(:include, integration_module)
+        unless target < TestUnit::Adapter
+          Debug.puts "Applying #{TestUnit::Adapter.description}"
+          target.send(:include, TestUnit::Adapter)
         end
+
         true
       end
     end

data/lib/mocha/invocation.rb

@@ -3,14 +3,12 @@ require 'mocha/raised_exception'
 require 'mocha/return_values'
 require 'mocha/thrown_object'
 require 'mocha/yield_parameters'
-require 'mocha/configuration'
-require 'mocha/deprecation'
 
 module Mocha
   class Invocation
     attr_reader :method_name, :block
 
-    def initialize(mock, method_name, *arguments, &block)
+    def initialize(mock, method_name, arguments = [], block = nil)
       @mock = mock
       @method_name = method_name
       @arguments = arguments
@@ -22,18 +20,8 @@ module Mocha
     def call(yield_parameters = YieldParameters.new, return_values = ReturnValues.new)
       yield_parameters.next_invocation.each do |yield_args|
         @yields << ParametersMatcher.new(yield_args)
-        if @block
-          @block.call(*yield_args)
-        else
-          raise LocalJumpError unless Mocha.configuration.reinstate_undocumented_behaviour_from_v1_9?
-          yield_args_description = ParametersMatcher.new(yield_args).mocha_inspect
-          Deprecation.warning(
-            "Stubbed method was instructed to yield #{yield_args_description}, but no block was given by invocation: #{call_description}.",
-            ' This will raise a LocalJumpError in the future.',
-            ' Use Expectation#with_block_given to constrain this expectation to match invocations supplying a block.',
-            ' And, if necessary, add another expectation to match invocations not supplying a block.'
-          )
-        end
+        raise LocalJumpError unless @block
+        @block.call(*yield_args)
       end
       return_values.next(self)
     end
@@ -55,7 +43,7 @@ module Mocha
     end
 
     def call_description
-      description = "#{@mock.mocha_inspect}.#{@method_name}#{ParametersMatcher.new(@arguments).mocha_inspect}"
+      description = "#{@mock.mocha_inspect}.#{@method_name}#{argument_description}"
       description << ' { ... }' unless @block.nil?
       description
     end
@@ -73,5 +61,13 @@ module Mocha
     def full_description
       "\n  - #{call_description} #{result_description}"
     end
+
+    private
+
+    def argument_description
+      signature = arguments.mocha_inspect
+      signature = signature.gsub(/^\[|\]$/, '')
+      "(#{signature})"
+    end
   end
 end

data/lib/mocha/minitest.rb

@@ -1,8 +1,6 @@
+require 'mocha/ruby_version'
 require 'mocha/integration/mini_test'
-require 'mocha/deprecation'
 
 unless Mocha::Integration::MiniTest.activate
-  Mocha::Deprecation.warning(
-    "MiniTest must be loaded *before* `require 'mocha/minitest'`."
-  )
+  raise "MiniTest must be loaded *before* `require 'mocha/minitest'`."
 end

data/lib/mocha/mock.rb

@@ -1,4 +1,4 @@
-require 'mocha/singleton_class'
+require 'ruby2_keywords'
 require 'mocha/expectation'
 require 'mocha/expectation_list'
 require 'mocha/invocation'
@@ -8,7 +8,6 @@ require 'mocha/method_matcher'
 require 'mocha/parameters_matcher'
 require 'mocha/argument_iterator'
 require 'mocha/expectation_error_factory'
-require 'mocha/ruby_version'
 
 module Mocha
   # Traditional mock object.
@@ -165,7 +164,7 @@ module Mocha
     # @param [Array<Symbol>] method_names names of methods to unstub.
     #
     # @example Invoking an unstubbed method causes error to be raised
-    #   object = mock('mock') do
+    #   object = mock('mock')
     #   object.stubs(:stubbed_method).returns(:result_one)
     #   object.stubbed_method # => :result_one
     #   object.unstub(:stubbed_method)
@@ -310,10 +309,18 @@ module Mocha
     end
 
     # @private
-    def method_missing(symbol, *arguments, &block) # rubocop:disable Style/MethodMissingSuper
+    # rubocop:disable Style/MethodMissingSuper
+    def method_missing(symbol, *arguments, &block)
+      handle_method_call(symbol, arguments, block)
+    end
+    ruby2_keywords(:method_missing)
+    # rubocop:enable Style/MethodMissingSuper
+
+    # @private
+    def handle_method_call(symbol, arguments, block)
       check_expiry
       check_responder_responds_to(symbol)
-      invocation = Invocation.new(self, symbol, *arguments, &block)
+      invocation = Invocation.new(self, symbol, arguments, block)
       if (matching_expectation_allowing_invocation = all_expectations.match_allowing_invocation(invocation))
         matching_expectation_allowing_invocation.invoke(invocation)
       elsif (matching_expectation = all_expectations.match(invocation)) || (!matching_expectation && !@everything_stubbed)
@@ -322,25 +329,14 @@ module Mocha
     end
 
     # @private
-    def respond_to_missing?(symbol, include_private = false)
+    def respond_to_missing?(symbol, include_all)
       if @responder
-        if @responder.method(:respond_to?).arity > 1
-          @responder.respond_to?(symbol, include_private)
-        else
-          @responder.respond_to?(symbol)
-        end
+        @responder.respond_to?(symbol, include_all)
       else
         @everything_stubbed || all_expectations.matches_method?(symbol)
       end
     end
 
-    if PRE_RUBY_V19
-      # @private
-      def respond_to?(symbol, include_private = false)
-        respond_to_missing?(symbol, include_private)
-      end
-    end
-
     # @private
     def __verified__?(assertion_counter = nil)
       @expectations.verified?(assertion_counter)
@@ -391,14 +387,14 @@ module Mocha
     end
 
     def check_expiry
-      if @expired # rubocop:disable Style/GuardClause
-        Deprecation.warning(
-          "#{mocha_inspect} was instantiated in one test but it is receiving invocations within another test.",
-          ' This can lead to unintended interactions between tests and hence unexpected test failures.',
-          ' Ensure that every test correctly cleans up any state that it introduces.',
-          ' A Mocha::StubbingError will be raised in this scenario in the future.'
-        )
-      end
+      return unless @expired
+
+      sentences = [
+        "#{mocha_inspect} was instantiated in one test but it is receiving invocations within another test.",
+        'This can lead to unintended interactions between tests and hence unexpected test failures.',
+        'Ensure that every test correctly cleans up any state that it introduces.'
+      ]
+      raise StubbingError.new(sentences.join(' '), caller)
     end
   end
 end

data/lib/mocha/mockery.rb

@@ -1,4 +1,3 @@
-require 'mocha/ruby_version'
 require 'mocha/central'
 require 'mocha/mock'
 require 'mocha/names'
@@ -119,10 +118,9 @@ module Mocha
     end
 
     def on_stubbing(object, method)
-      method = PRE_RUBY_V19 ? method.to_s : method.to_sym
       signature_proc = lambda { "#{object.mocha_inspect}.#{method}" }
       check(:stubbing_non_existent_method, 'non-existent method', signature_proc) do
-        !(object.stubba_class.__method_exists__?(method, true) || object.respond_to?(method.to_sym))
+        !(object.stubba_class.__method_exists__?(method, true) || object.respond_to?(method))
       end
       check(:stubbing_non_public_method, 'non-public method', signature_proc) do
         object.stubba_class.__method_exists__?(method, false)

data/lib/mocha/parameter_matchers/equivalent_uri.rb

@@ -1,4 +1,3 @@
-require 'mocha/deprecation'
 require 'mocha/parameter_matchers/base'
 require 'uri'
 require 'cgi'

data/lib/mocha/parameter_matchers/instance_methods.rb

@@ -1,4 +1,5 @@
 require 'mocha/parameter_matchers/equals'
+require 'mocha/parameter_matchers/positional_or_keyword_hash'
 
 module Mocha
   module ParameterMatchers
@@ -16,3 +17,11 @@ end
 class Object
   include Mocha::ParameterMatchers::InstanceMethods
 end
+
+# @private
+class Hash
+  # @private
+  def to_matcher
+    Mocha::ParameterMatchers::PositionalOrKeywordHash.new(self)
+  end
+end

data/lib/mocha/parameter_matchers/positional_or_keyword_hash.rb

@@ -0,0 +1,56 @@
+require 'mocha/configuration'
+require 'mocha/deprecation'
+require 'mocha/parameter_matchers/base'
+
+module Mocha
+  module ParameterMatchers
+    # @private
+    class PositionalOrKeywordHash < Base
+      def initialize(value)
+        @value = value
+      end
+
+      def matches?(available_parameters)
+        parameter, is_last_parameter = extract_parameter(available_parameters)
+        return false unless parameter == @value
+
+        if is_last_parameter && !same_type_of_hash?(parameter, @value)
+          return false if Mocha.configuration.strict_keyword_argument_matching?
+
+          deprecation_warning(parameter, @value) if Mocha::RUBY_V27_PLUS
+        end
+
+        true
+      end
+
+      def mocha_inspect
+        @value.mocha_inspect
+      end
+
+      private
+
+      def extract_parameter(available_parameters)
+        [available_parameters.shift, available_parameters.empty?]
+      end
+
+      def same_type_of_hash?(actual, expected)
+        ruby2_keywords_hash?(actual) == ruby2_keywords_hash?(expected)
+      end
+
+      def deprecation_warning(actual, expected)
+        details = "Expected #{hash_type(expected)} (#{expected.mocha_inspect}), but received #{hash_type(actual)} (#{actual.mocha_inspect})."
+        sentence1 = 'These will stop matching when strict keyword argument matching is enabled.'
+        sentence2 = 'See the documentation for Mocha::Configuration#strict_keyword_argument_matching=.'
+        Deprecation.warning([details, sentence1, sentence2].join(' '))
+      end
+
+      def hash_type(hash)
+        ruby2_keywords_hash?(hash) ? 'keyword arguments' : 'positional hash'
+      end
+
+      def ruby2_keywords_hash?(hash)
+        hash.is_a?(Hash) && ::Hash.ruby2_keywords_hash?(hash)
+      end
+    end
+  end
+end

data/lib/mocha/parameters_matcher.rb

@@ -23,7 +23,6 @@ module Mocha
     def mocha_inspect
       signature = matchers.mocha_inspect
       signature = signature.gsub(/^\[|\]$/, '')
-      signature = signature.gsub(/^\{|\}$/, '') if matchers.length == 1
       "(#{signature})"
     end
 

data/lib/mocha/ruby_version.rb

@@ -1,4 +1,3 @@
 module Mocha
-  PRE_RUBY_V19 = Gem::Version.new(RUBY_VERSION.dup) < Gem::Version.new('1.9')
-  RUBY_V2_PLUS = Gem::Version.new(RUBY_VERSION.dup) >= Gem::Version.new('2')
+  RUBY_V27_PLUS = Gem::Version.new(RUBY_VERSION.dup) >= Gem::Version.new('2.7')
 end

data/lib/mocha/stubbed_method.rb

@@ -1,5 +1,5 @@
+require 'ruby2_keywords'
 require 'mocha/ruby_version'
-require 'mocha/singleton_class'
 
 module Mocha
   class StubbedMethod
@@ -11,7 +11,7 @@ module Mocha
       @stubbee = stubbee
       @original_method = nil
       @original_visibility = nil
-      @method_name = PRE_RUBY_V19 ? method_name.to_s : method_name.to_sym
+      @method_name = method_name.to_sym
     end
 
     def stub
@@ -21,7 +21,6 @@ module Mocha
 
     def unstub
       remove_new_method
-      restore_original_method
       mock.unstub(method_name.to_sym)
       return if mock.any_expectations?
       reset_mocha
@@ -38,28 +37,16 @@ module Mocha
     def hide_original_method
       return unless original_method_owner.__method_exists__?(method_name)
       store_original_method_visibility
-      if use_prepended_module_for_stub_method?
-        use_prepended_module_for_stub_method
-      else
-        begin
-          store_original_method
-        # rubocop:disable Lint/HandleExceptions
-        rescue NameError
-          # deal with nasties like ActiveRecord::Associations::AssociationProxy
-        end
-        # rubocop:enable Lint/HandleExceptions
-        if stub_method_overwrites_original_method?
-          remove_original_method_from_stubbee
-        end
-      end
+      use_prepended_module_for_stub_method
     end
 
     def define_new_method
       self_in_scope = self
       method_name_in_scope = method_name
       stub_method_owner.send(:define_method, method_name) do |*args, &block|
-        self_in_scope.mock.method_missing(method_name_in_scope, *args, &block)
+        self_in_scope.mock.handle_method_call(method_name_in_scope, args, block)
       end
+      stub_method_owner.send(:ruby2_keywords, method_name)
       retain_original_visibility(stub_method_owner)
     end
 
@@ -67,18 +54,6 @@ module Mocha
       stub_method_owner.send(:remove_method, method_name)
     end
 
-    def store_original_method
-      @original_method = stubbee_method(method_name)
-    end
-
-    def restore_original_method
-      return if use_prepended_module_for_stub_method?
-      if stub_method_overwrites_original_method?
-        original_method_owner.send(:define_method, method_name, method_body(@original_method))
-      end
-      retain_original_visibility(original_method_owner)
-    end
-
     def matches?(other)
       return false unless other.class == self.class
       (stubbee.object_id == other.stubbee.object_id) && (method_name == other.method_name)
@@ -101,18 +76,6 @@ module Mocha
       @original_visibility = original_method_owner.__method_visibility__(method_name)
     end
 
-    def stub_method_overwrites_original_method?
-      @original_method && @original_method.owner == original_method_owner
-    end
-
-    def remove_original_method_from_stubbee
-      original_method_owner.send(:remove_method, method_name)
-    end
-
-    def use_prepended_module_for_stub_method?
-      RUBY_V2_PLUS
-    end
-
     def use_prepended_module_for_stub_method
       @stub_method_owner = PrependedModule.new
       original_method_owner.__send__ :prepend, @stub_method_owner

data/lib/mocha/test_unit.rb

@@ -1,8 +1,6 @@
+require 'mocha/ruby_version'
 require 'mocha/integration/test_unit'
-require 'mocha/deprecation'
 
 unless Mocha::Integration::TestUnit.activate
-  Mocha::Deprecation.warning(
-    "Test::Unit must be loaded *before* `require 'mocha/test_unit'`."
-  )
+  raise "Test::Unit must be loaded *before* `require 'mocha/test_unit'`."
 end

data/lib/mocha/version.rb

@@ -1,3 +1,3 @@
 module Mocha
-  VERSION = '1.14.0'.freeze
+  VERSION = '2.0.0.alpha'.freeze
 end

data/lib/mocha.rb

@@ -1,9 +1 @@
 require 'mocha/version'
-require 'mocha/ruby_version'
-require 'mocha/deprecation'
-
-if Mocha::PRE_RUBY_V19
-  Mocha::Deprecation.warning(
-    'Versions of Ruby earlier than v1.9 will not be supported in future versions of Mocha.'
-  )
-end

data/mocha.gemspec

@@ -6,7 +6,7 @@ Gem::Specification.new do |s|
   s.name = 'mocha'
   s.version = Mocha::VERSION
   s.licenses = ['MIT', 'BSD-2-Clause']
-  s.required_ruby_version = '>= 1.8.7'
+  s.required_ruby_version = '>= 2.0'
 
   s.authors = ['James Mead']
   s.description = 'Mocking and stubbing library with JMock/SchMock syntax, which allows mocking and stubbing of methods on real (non-mock) classes.'