mocha 1.16.1 → 2.7.1

data/lib/mocha/mock.rb

@@ -1,3 +1,4 @@
+require 'ruby2_keywords'
 require 'mocha/expectation'
 require 'mocha/expectation_list'
 require 'mocha/invocation'
@@ -7,6 +8,7 @@ require 'mocha/method_matcher'
 require 'mocha/parameters_matcher'
 require 'mocha/argument_iterator'
 require 'mocha/expectation_error_factory'
+require 'mocha/deprecation'
 
 module Mocha
   # Traditional mock object.
@@ -33,6 +35,9 @@ module Mocha
   # while an +expects(:foo).at_least_once+ expectation will always be matched
   # against invocations.
   #
+  # However, note that if the expectation that matches the invocation has a
+  # cardinality of "never", then an unexpected invocation error is reported.
+  #
   # This scheme allows you to:
   #
   # - Set up default stubs in your the +setup+ method of your test class and
@@ -99,7 +104,7 @@ module Mocha
     #
     # @example Setup multiple expectations using +expected_methods_vs_return_values+.
     #   object = mock()
-    #   object.expects(:expected_method_one => :result_one, :expected_method_two => :result_two)
+    #   object.expects(expected_method_one: :result_one, expected_method_two: :result_two)
     #
     #   # is exactly equivalent to
     #
@@ -113,6 +118,7 @@ module Mocha
         method_name = args.shift
         ensure_method_not_already_defined(method_name)
         expectation = Expectation.new(self, method_name, backtrace)
+        expectation.in_sequence(@mockery.sequences.last) if @mockery.sequences.any?
         expectation.returns(args.shift) unless args.empty?
         @expectations.add(expectation)
       end
@@ -137,7 +143,7 @@ module Mocha
     #
     # @example Setup multiple expectations using +stubbed_methods_vs_return_values+.
     #   object = mock()
-    #   object.stubs(:stubbed_method_one => :result_one, :stubbed_method_two => :result_two)
+    #   object.stubs(stubbed_method_one: :result_one, stubbed_method_two: :result_two)
     #
     #   # is exactly equivalent to
     #
@@ -152,6 +158,7 @@ module Mocha
         ensure_method_not_already_defined(method_name)
         expectation = Expectation.new(self, method_name, backtrace)
         expectation.at_least(0)
+        expectation.in_sequence(@mockery.sequences.last) if @mockery.sequences.any?
         expectation.returns(args.shift) unless args.empty?
         @expectations.add(expectation)
       end
@@ -311,16 +318,30 @@ module Mocha
     def method_missing(symbol, *arguments, &block) # rubocop:disable Style/MethodMissingSuper
       handle_method_call(symbol, arguments, block)
     end
+    ruby2_keywords(:method_missing)
 
     # @private
-    def handle_method_call(symbol, arguments, block)
+    def handle_method_call(symbol, arguments, block) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
       check_expiry
       check_responder_responds_to(symbol)
       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)
-        raise_unexpected_invocation_error(invocation, matching_expectation)
+
+      matching_expectations = all_expectations.matching_expectations(invocation)
+
+      index = 0
+      while index < matching_expectations.length
+        matching_expectation = matching_expectations[index]
+        if matching_expectation.invocations_never_allowed?
+          raise_unexpected_invocation_error(invocation, matching_expectation)
+        elsif matching_expectation.invocations_allowed?
+          return matching_expectation.invoke(invocation)
+        end
+        index += 1
+      end
+
+      matching_expectation_ignoring_order = all_expectations.match(invocation, ignoring_order: true)
+      if matching_expectation_ignoring_order || (!matching_expectation_ignoring_order && !@everything_stubbed) # rubocop:disable Style/GuardClause
+        raise_unexpected_invocation_error(invocation, matching_expectation_ignoring_order)
       end
     end
 
@@ -339,8 +360,8 @@ module Mocha
     end
 
     # @private
-    def __expire__
-      @expired = true
+    def __expire__(origin)
+      @expired = origin || true
     end
 
     # @private
@@ -369,7 +390,11 @@ module Mocha
       if @unexpected_invocation.nil?
         @unexpected_invocation = invocation
         matching_expectation.invoke(invocation) if matching_expectation
-        message = "#{@unexpected_invocation.call_description}\n#{@mockery.mocha_inspect}"
+        call_description = @unexpected_invocation.call_description
+        if matching_expectation && !matching_expectation.in_correct_order?
+          call_description += ' invoked out of order'
+        end
+        message = "#{call_description}\n#{@mockery.mocha_inspect}"
       else
         message = @unexpected_invocation.short_call_description
       end
@@ -383,14 +408,16 @@ 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
+
+      origin = @expired == true ? 'one test' : @expired
+
+      sentences = [
+        "#{mocha_inspect} was instantiated in #{origin} 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

@@ -48,8 +48,8 @@ module Mocha
         instance.verify(*args)
       end
 
-      def teardown
-        instance.teardown
+      def teardown(origin = nil)
+        instance.teardown(origin)
       ensure
         @instances.pop
       end
@@ -91,9 +91,9 @@ module Mocha
       end
     end
 
-    def teardown
+    def teardown(origin = nil)
       stubba.unstub_all
-      mocks.each(&:__expire__)
+      mocks.each { |m| m.__expire__(origin) }
       reset
     end
 
@@ -109,12 +109,16 @@ module Mocha
       @state_machines ||= []
     end
 
+    def sequences
+      @sequences ||= []
+    end
+
     def mocha_inspect
-      message = ''
-      message << "unsatisfied expectations:\n- #{unsatisfied_expectations.map(&:mocha_inspect).join("\n- ")}\n" if unsatisfied_expectations.any?
-      message << "satisfied expectations:\n- #{satisfied_expectations.map(&:mocha_inspect).join("\n- ")}\n" if satisfied_expectations.any?
-      message << "states:\n- #{state_machines.map(&:mocha_inspect).join("\n- ")}\n" if state_machines.any?
-      message
+      lines = []
+      lines << "unsatisfied expectations:\n- #{unsatisfied_expectations.map(&:mocha_inspect).join("\n- ")}\n" if unsatisfied_expectations.any?
+      lines << "satisfied expectations:\n- #{satisfied_expectations.map(&:mocha_inspect).join("\n- ")}\n" if satisfied_expectations.any?
+      lines << "states:\n- #{state_machines.map(&:mocha_inspect).join("\n- ")}\n" if state_machines.any?
+      lines.join
     end
 
     def on_stubbing(object, method)

data/lib/mocha/names.rb

@@ -37,7 +37,7 @@ module Mocha
     def mocha_inspect
       address = @mock.__id__ * 2
       address += 0x100000000 if address < 0
-      "#<Mock:0x#{format('%x', address)}>"
+      "#<Mock:0x#{format('%<address>x', address: address)}>"
     end
   end
 end

data/lib/mocha/object_methods.rb

@@ -59,7 +59,7 @@ module Mocha
     #
     # @example Setting up multiple expectations on a non-mock object.
     #   product = Product.new
-    #   product.expects(:valid? => true, :save => true)
+    #   product.expects(valid?: true, save: true)
     #
     #   # exactly equivalent to
     #
@@ -108,7 +108,7 @@ module Mocha
     #
     # @example Setting up multiple stubbed methods on a non-mock object.
     #   product = Product.new
-    #   product.stubs(:valid? => true, :save => true)
+    #   product.stubs(valid?: true, save: true)
     #
     #   # exactly equivalent to
     #

data/lib/mocha/parameter_matchers/base.rb

@@ -2,11 +2,6 @@ module Mocha
   module ParameterMatchers
     # @abstract Subclass and implement +#matches?+ and +#mocha_inspect+ to define a custom matcher. Also add a suitably named instance method to {ParameterMatchers} to build an instance of the new matcher c.f. {#equals}.
     class Base
-      # @private
-      def to_matcher
-        self
-      end
-
       # A shorthand way of combining two matchers when both must match.
       #
       # Returns a new {AllOf} parameter matcher combining two matchers using a logical AND.
@@ -21,12 +16,12 @@ module Mocha
       # @example Alternative ways to combine matchers with a logical AND.
       #   object = mock()
       #   object.expects(:run).with(all_of(has_key(:foo), has_key(:bar)))
-      #   object.run(:foo => 'foovalue', :bar => 'barvalue')
+      #   object.run(foo: 'foovalue', bar: 'barvalue')
       #
       #   # is exactly equivalent to
       #
       #   object.expects(:run).with(has_key(:foo) & has_key(:bar))
-      #   object.run(:foo => 'foovalue', :bar => 'barvalue)
+      #   object.run(foo: 'foovalue', bar: 'barvalue)
       def &(other)
         AllOf.new(self, other)
       end
@@ -45,12 +40,12 @@ module Mocha
       # @example Alternative ways to combine matchers with a logical OR.
       #   object = mock()
       #   object.expects(:run).with(any_of(has_key(:foo), has_key(:bar)))
-      #   object.run(:foo => 'foovalue')
+      #   object.run(foo: 'foovalue')
       #
       #   # is exactly equivalent to
       #
       #   object.expects(:run).with(has_key(:foo) | has_key(:bar))
-      #   object.run(:foo => 'foovalue')
+      #   object.run(foo: 'foovalue')
       #
       # @example Using an explicit {Equals} matcher in combination with {#|}.
       #   object.expects(:run).with(equals(1) | equals(2))

data/lib/mocha/parameter_matchers/equivalent_uri.rb

@@ -1,4 +1,3 @@
-require 'mocha/deprecation'
 require 'mocha/parameter_matchers/base'
 require 'uri'
 require 'cgi'
@@ -51,7 +50,7 @@ module Mocha
       # @private
       def explode(uri)
         query_hash = CGI.parse(uri.query || '')
-        URI::Generic::COMPONENT.inject({}) { |h, k| h.merge(k => uri.__send__(k)) }.merge(:query => query_hash)
+        URI::Generic::COMPONENT.inject({}) { |h, k| h.merge(k => uri.__send__(k)) }.merge(query: query_hash)
       end
     end
   end

data/lib/mocha/parameter_matchers/has_entries.rb

@@ -30,20 +30,25 @@ module Mocha
     # Parameter matcher which matches when actual parameter contains all expected +Hash+ entries.
     class HasEntries < Base
       # @private
-      def initialize(entries)
+      def initialize(entries, exact: false)
         @entries = entries
+        @exact = exact
       end
 
       # @private
       def matches?(available_parameters)
         parameter = available_parameters.shift
+        return false unless parameter
+        return false unless parameter.respond_to?(:keys)
+        return false if @exact && @entries.length != parameter.keys.length
+
         has_entry_matchers = @entries.map { |key, value| HasEntry.new(key, value) }
         AllOf.new(*has_entry_matchers).matches?([parameter])
       end
 
       # @private
       def mocha_inspect
-        "has_entries(#{@entries.mocha_inspect})"
+        @exact ? @entries.mocha_inspect : "has_entries(#{@entries.mocha_inspect})"
       end
     end
   end

data/lib/mocha/parameter_matchers/includes.rb

@@ -24,7 +24,7 @@ module Mocha
     # @example Actual parameter includes item which matches nested matcher.
     #   object = mock()
     #   object.expects(:method_1).with(includes(has_key(:key)))
-    #   object.method_1(['foo', 'bar', {:key => 'baz'}])
+    #   object.method_1(['foo', 'bar', {key: 'baz'}])
     #   # no error raised
     #
     # @example Actual parameter does not include item matching nested matcher.
@@ -44,11 +44,11 @@ module Mocha
     # @example Actual parameter is a Hash including the given key.
     #   object = mock()
     #   object.expects(:method_1).with(includes(:bar))
-    #   object.method_1({:foo => 1, :bar => 2})
+    #   object.method_1({foo: 1, bar: 2})
     #   # no error raised
     #
     # @example Actual parameter is a Hash without the given key.
-    #   object.method_1({:foo => 1, :baz => 2})
+    #   object.method_1({foo: 1, baz: 2})
     #   # error raised, because hash does not include key 'bar'
     #
     # @example Actual parameter is a Hash with a key matching the given matcher.

data/lib/mocha/parameter_matchers/instance_methods.rb

@@ -1,12 +1,20 @@
+require 'mocha/parameter_matchers/base'
 require 'mocha/parameter_matchers/equals'
+require 'mocha/parameter_matchers/positional_or_keyword_hash'
 
 module Mocha
   module ParameterMatchers
     # @private
     module InstanceMethods
       # @private
-      def to_matcher
-        Mocha::ParameterMatchers::Equals.new(self)
+      def to_matcher(expectation: nil, top_level: false)
+        if Base === self
+          self
+        elsif Hash === self && top_level
+          Mocha::ParameterMatchers::PositionalOrKeywordHash.new(self, expectation)
+        else
+          Mocha::ParameterMatchers::Equals.new(self)
+        end
       end
     end
   end

data/lib/mocha/parameter_matchers/positional_or_keyword_hash.rb

@@ -0,0 +1,66 @@
+require 'mocha/configuration'
+require 'mocha/deprecation'
+require 'mocha/parameter_matchers/base'
+require 'mocha/parameter_matchers/has_entries'
+
+module Mocha
+  module ParameterMatchers
+    # @private
+    class PositionalOrKeywordHash < Base
+      def initialize(value, expectation)
+        @value = value
+        @expectation = expectation
+      end
+
+      def matches?(available_parameters)
+        parameter, is_last_parameter = extract_parameter(available_parameters)
+
+        return false unless HasEntries.new(@value, exact: true).matches?([parameter])
+
+        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)
+        details1 = "Expectation #{expectation_definition} expected #{hash_type(expected)} (#{expected.mocha_inspect}),".squeeze(' ')
+        details2 = "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([details1, details2, 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
+
+      def expectation_definition
+        return nil unless @expectation
+
+        "defined at #{@expectation.definition_location}"
+      end
+    end
+  end
+end

data/lib/mocha/parameter_matchers/responds_with.rb

@@ -1,12 +1,18 @@
 require 'mocha/parameter_matchers/base'
+require 'mocha/parameter_matchers/all_of'
 require 'yaml'
 
 module Mocha
   module ParameterMatchers
-    # Matches any object that responds to +message+ with +result+. To put it another way, it tests the quack, not the duck.
+    # @overload def responds_with(message, result)
+    #   Matches any object that responds to +message+ with +result+. To put it another way, it tests the quack, not the duck.
+    #   @param [Symbol] message method to invoke.
+    #   @param [Object] result expected result of sending +message+.
+    # @overload def responds_with(messages_vs_results)
+    #   Matches any object that responds to all the messages with the corresponding results as specified by +messages_vs_results+.
+    #   @param [Hash<Symbol,Object>] messages_vs_results +Hash+ of messages vs results.
+    #   @raise [ArgumentError] if +messages_vs_results+ does not contain at least one entry.
     #
-    # @param [Symbol] message method to invoke.
-    # @param [Object] result expected result of sending +message+.
     # @return [RespondsWith] parameter matcher.
     #
     # @see Expectation#with
@@ -22,8 +28,29 @@ module Mocha
     #   object.expects(:method_1).with(responds_with(:upcase, "BAR"))
     #   object.method_1("foo")
     #   # error raised, because "foo".upcase != "BAR"
-    def responds_with(message, result)
-      RespondsWith.new(message, result)
+    #
+    # @example Actual parameter responds with "FOO" when :upcase is invoked and "oof" when :reverse is invoked.
+    #   object = mock()
+    #   object.expects(:method_1).with(responds_with(upcase: "FOO", reverse: "oof"))
+    #   object.method_1("foo")
+    #   # no error raised, because "foo".upcase == "FOO" and "foo".reverse == "oof"
+    def responds_with(*options)
+      case options.length
+      when 0
+        raise ArgumentError, 'No arguments. Expecting at least one.'
+      when 1
+        option = options.first
+        raise ArgumentError, 'Argument is not a Hash.' unless option.is_a?(Hash)
+        raise ArgumentError, 'Argument has no entries.' if option.empty?
+
+        matchers = option.map { |message, result| RespondsWith.new(message, result) }
+        AllOf.new(*matchers)
+      when 2
+        message, result = options
+        RespondsWith.new(message, result)
+      else
+        raise ArgumentError, 'Too many arguments; use either a single argument (must be a Hash) or two arguments (a message and a result).'
+      end
     end
 
     # Parameter matcher which matches if actual parameter returns expected result when specified method is invoked.

data/lib/mocha/parameters_matcher.rb

@@ -3,8 +3,9 @@ require 'mocha/parameter_matchers'
 
 module Mocha
   class ParametersMatcher
-    def initialize(expected_parameters = [ParameterMatchers::AnyParameters.new], &matching_block)
+    def initialize(expected_parameters = [ParameterMatchers::AnyParameters.new], expectation = nil, &matching_block)
       @expected_parameters = expected_parameters
+      @expectation = expectation
       @matching_block = matching_block
     end
 
@@ -21,14 +22,17 @@ module Mocha
     end
 
     def mocha_inspect
-      signature = matchers.mocha_inspect
-      signature = signature.gsub(/^\[|\]$/, '')
-      signature = signature.gsub(/^\{|\}$/, '') if matchers.length == 1
-      "(#{signature})"
+      if @matching_block
+        '(arguments_accepted_by_custom_matching_block)'
+      else
+        signature = matchers.mocha_inspect
+        signature = signature.gsub(/^\[|\]$/, '')
+        "(#{signature})"
+      end
     end
 
     def matchers
-      @expected_parameters.map(&:to_matcher)
+      @expected_parameters.map { |p| p.to_matcher(expectation: @expectation, top_level: true) }
     end
   end
 end

data/lib/mocha/ruby_version.rb

@@ -1,11 +1,4 @@
-require 'mocha/deprecation'
-
 module Mocha
-  RUBY_V2_PLUS = Gem::Version.new(RUBY_VERSION.dup) >= Gem::Version.new('2')
-
-  unless RUBY_V2_PLUS
-    Mocha::Deprecation.warning(
-      'Versions of Ruby earlier than v2.0 will not be supported in future versions of Mocha.'
-    )
-  end
+  RUBY_V27_PLUS = Gem::Version.new(RUBY_VERSION.dup) >= Gem::Version.new('2.7')
+  RUBY_V34_PLUS = Gem::Version.new(RUBY_VERSION.dup) >= Gem::Version.new('3.4')
 end

data/lib/mocha/stubbed_method.rb

@@ -1,3 +1,4 @@
+require 'ruby2_keywords'
 require 'mocha/ruby_version'
 
 module Mocha
@@ -20,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
@@ -37,20 +37,7 @@ 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
@@ -59,6 +46,7 @@ module Mocha
       stub_method_owner.send(:define_method, method_name) do |*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
 
@@ -66,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, @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)
@@ -100,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,9 +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.16.1'.freeze
+  VERSION = '2.7.1'.freeze
 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.9'
+  s.required_ruby_version = '>= 2.1'
 
   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.'
@@ -21,4 +21,14 @@ Gem::Specification.new do |s|
   s.homepage = 'https://mocha.jamesmead.org'
   s.require_paths = ['lib']
   s.summary = 'Mocking and stubbing library'
+  s.metadata = {
+    'bug_tracker_uri' => 'https://github.com/freerange/mocha/issues',
+    'changelog_uri' => 'https://github.com/freerange/mocha/blob/main/RELEASE.md',
+    'documentation_uri' => 'https://mocha.jamesmead.org/',
+    'funding_uri' => 'https://github.com/sponsors/floehopper',
+    'homepage_uri' => s.homepage,
+    'source_code_uri' => 'https://github.com/freerange/mocha'
+  }
+
+  s.add_runtime_dependency 'ruby2_keywords', '>= 0.0.5'
 end