mocha 1.1.0 → 1.13.0

data/Rakefile

@@ -1,15 +1,15 @@
-require "bundler"
+require 'bundler'
 Bundler::GemHelper.install_tasks
-require "bundler/setup"
+require 'bundler/setup'
 
 require 'rake/testtask'
 
-desc "Run all tests"
+desc 'Run all tests'
 task 'default' => ['test', 'test:performance']
 
-desc "Run tests"
+desc 'Run tests'
 task 'test' do
-  if test_library = ENV['MOCHA_RUN_INTEGRATION_TESTS']
+  if (test_library = ENV['MOCHA_RUN_INTEGRATION_TESTS'])
     Rake::Task["test:integration:#{test_library}"].invoke
   else
     Rake::Task['test:units'].invoke
@@ -17,14 +17,13 @@ task 'test' do
   end
 end
 
-namespace 'test' do
-
+namespace 'test' do # rubocop:disable Metrics/BlockLength
   unit_tests = FileList['test/unit/**/*_test.rb']
   all_acceptance_tests = FileList['test/acceptance/*_test.rb']
   ruby186_incompatible_acceptance_tests = FileList['test/acceptance/stub_class_method_defined_on_*_test.rb'] + FileList['test/acceptance/stub_instance_method_defined_on_*_test.rb']
   ruby186_compatible_acceptance_tests = all_acceptance_tests - ruby186_incompatible_acceptance_tests
 
-  desc "Run unit tests"
+  desc 'Run unit tests'
   Rake::TestTask.new('units') do |t|
     t.libs << 'test'
     t.test_files = unit_tests
@@ -32,20 +31,20 @@ namespace 'test' do
     t.warning = true
   end
 
-  desc "Run acceptance tests"
+  desc 'Run acceptance tests'
   Rake::TestTask.new('acceptance') do |t|
     t.libs << 'test'
-    if defined?(RUBY_VERSION) && (RUBY_VERSION >= "1.8.7")
-      t.test_files = all_acceptance_tests
-    else
-      t.test_files = ruby186_compatible_acceptance_tests
-    end
+    t.test_files = if defined?(RUBY_VERSION) && (RUBY_VERSION >= '1.8.7')
+                     all_acceptance_tests
+                   else
+                     ruby186_compatible_acceptance_tests
+                   end
     t.verbose = true
     t.warning = true
   end
 
   namespace 'integration' do
-    desc "Run MiniTest integration tests (intended to be run in its own process)"
+    desc 'Run MiniTest integration tests (intended to be run in its own process)'
     Rake::TestTask.new('minitest') do |t|
       t.libs << 'test'
       t.test_files = FileList['test/integration/mini_test_test.rb']
@@ -53,7 +52,7 @@ namespace 'test' do
       t.warning = true
     end
 
-    desc "Run Test::Unit integration tests (intended to be run in its own process)"
+    desc 'Run Test::Unit integration tests (intended to be run in its own process)'
     Rake::TestTask.new('test-unit') do |t|
       t.libs << 'test'
       t.test_files = FileList['test/integration/test_unit_test.rb']
@@ -72,7 +71,7 @@ namespace 'test' do
   #   t.rcov_opts << '--xref'
   # end
 
-  desc "Run performance tests"
+  desc 'Run performance tests'
   task 'performance' do
     require File.join(File.dirname(__FILE__), 'test', 'acceptance', 'stubba_example_test')
     require File.join(File.dirname(__FILE__), 'test', 'acceptance', 'mocha_example_test')
@@ -82,35 +81,53 @@ namespace 'test' do
       puts "#{test_case}: #{benchmark_test_case(test_case, iterations)} seconds."
     end
   end
+end
 
+begin
+  require 'rubocop/rake_task'
+  if RUBY_VERSION >= '2.2.0' && (defined?(RUBY_ENGINE) && RUBY_ENGINE == 'ruby') && ENV['MOCHA_RUN_INTEGRATION_TESTS'].nil?
+    RuboCop::RakeTask.new
+    task 'test' => 'rubocop'
+  end
+rescue LoadError # rubocop:disable Lint/HandleExceptions
 end
 
+# rubocop:disable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
 def benchmark_test_case(klass, iterations)
   require 'benchmark'
+  require 'mocha/detection/mini_test'
 
   if defined?(MiniTest)
-    MiniTest::Unit.output = StringIO.new
-    Benchmark.realtime { iterations.times { |i| MiniTest::Unit.new.run([klass]) } }
+    minitest_version = Gem::Version.new(Mocha::Detection::MiniTest.version)
+    if Gem::Requirement.new('>= 5.0.0').satisfied_by?(minitest_version)
+      result = Benchmark.realtime { iterations.times { |_i| klass.run(MiniTest::CompositeReporter.new) } }
+      MiniTest::Runnable.runnables.delete(klass)
+      result
+    else
+      MiniTest::Unit.output = StringIO.new
+      Benchmark.realtime { iterations.times { |_i| MiniTest::Unit.new.run([klass]) } }
+    end
   else
     load 'test/unit/ui/console/testrunner.rb' unless defined?(Test::Unit::UI::Console::TestRunner)
-    unless $silent_option
+    unless @silent_option
       begin
         load 'test/unit/ui/console/outputlevel.rb' unless defined?(Test::Unit::UI::Console::OutputLevel::SILENT)
-        $silent_option = { :output_level => Test::Unit::UI::Console::OutputLevel::SILENT }
+        @silent_option = { :output_level => Test::Unit::UI::Console::OutputLevel::SILENT }
       rescue LoadError
-        $silent_option = Test::Unit::UI::SILENT
+        @silent_option = Test::Unit::UI::SILENT
       end
     end
-    Benchmark.realtime { iterations.times { Test::Unit::UI::Console::TestRunner.run(klass, $silent_option) } }
+    Benchmark.realtime { iterations.times { Test::Unit::UI::Console::TestRunner.run(klass, @silent_option) } }
   end
 end
+# rubocop:enable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
 
-unless ENV["MOCHA_NO_DOCS"]
+if ENV['MOCHA_GENERATE_DOCS']
   require 'yard'
 
   desc 'Remove generated documentation'
   task 'clobber_yardoc' do
-    `rm -rf ./doc`
+    `rm -rf ./docs`
   end
 
   task 'docs_environment' do
@@ -121,19 +138,20 @@ unless ENV["MOCHA_NO_DOCS"]
 
   desc 'Generate documentation'
   YARD::Rake::YardocTask.new('yardoc' => 'docs_environment') do |task|
-    task.options = ["--title", "Mocha #{Mocha::VERSION}"]
+    task.options = ['--title', "Mocha #{Mocha::VERSION}", '--fail-on-warning']
   end
 
-  desc "Generate documentation"
-  task 'generate_docs' => ['clobber_yardoc', 'yardoc']
+  task 'checkout_docs_cname' do
+    `git checkout docs/CNAME`
+  end
 
-  desc "Publish docs to gofreerange.com/docs/mocha"
-  task 'publish_docs' => 'generate_docs' do
-    path = "/home/freerange/docs/mocha"
-    system %{ssh gofreerange.com "sudo rm -fr #{path} && mkdir -p #{path}" && scp -r doc/* gofreerange.com:#{path}}
+  task 'checkout_docs_js' do
+    `git checkout docs/js/app.js`
+    `git checkout docs/js/jquery.js`
   end
-end
 
-task 'release' => 'default' do
-  Rake::Task['publish_docs'].invoke
+  desc 'Generate documentation'
+  task 'generate_docs' => %w[clobber_yardoc yardoc checkout_docs_cname checkout_docs_js]
 end
+
+task 'release' => 'default'

data/gemfiles/Gemfile.test-unit.latest

@@ -3,5 +3,9 @@ source 'https://rubygems.org'
 gemspec :path=>"../"
 
 group :development do
-  gem "test-unit"
+  if RUBY_VERSION < '1.9'
+    gem "test-unit", "~> 2"
+  else
+    gem "test-unit"
+  end
 end

data/init.rb

@@ -1,3 +1 @@
-# Mocha should no longer be loaded at plugin load time
-# You should explicitly load Mocha *after* Test::Unit or MiniTest have been loaded
-# e.g. by adding "require 'mocha'" at the bottom of test/test_helper.rb
+warn 'Mocha deprecation warning: The old-style Rails plugin will not be supported in future versions of Mocha.'

data/lib/mocha/any_instance_method.rb

@@ -1,84 +1,24 @@
-require 'mocha/class_method'
+require 'mocha/ruby_version'
+require 'mocha/stubbed_method'
 
 module Mocha
+  class AnyInstanceMethod < StubbedMethod
+    private
 
-  class AnyInstanceMethod < ClassMethod
-
-    def mock
-      stubbee.any_instance.mocha
-    end
-
-    def reset_mocha
-      stubbee.any_instance.reset_mocha
-    end
-
-    def hide_original_method
-      if method_exists?(method)
-        begin
-          @original_method = stubbee.instance_method(method)
-          if @original_method && @original_method.owner == stubbee
-            @original_visibility = :public
-            if stubbee.protected_instance_methods.include?(method)
-              @original_visibility = :protected
-            elsif stubbee.private_instance_methods.include?(method)
-              @original_visibility = :private
-            end
-            stubbee.send(:remove_method, method)
-          end
-
-          include_prepended_module if RUBY_VERSION >= '2.0'
-        rescue NameError
-          # deal with nasties like ActiveRecord::Associations::AssociationProxy
-        end
-      end
-    end
-
-    def define_new_method
-      definition_target.class_eval(<<-CODE, __FILE__, __LINE__ + 1)
-        def #{method}(*args, &block)
-          self.class.any_instance.mocha.method_missing(:#{method}, *args, &block)
-        end
-      CODE
-      if @original_visibility
-        Module.instance_method(@original_visibility).bind(definition_target).call(method)
-      end
-    end
-
-    def remove_new_method
-      definition_target.send(:remove_method, method)
+    def mock_owner
+      stubbee.any_instance
     end
 
-    def restore_original_method
-      if @original_method && @original_method.owner == stubbee
-        stubbee.send(:define_method, method, @original_method)
-        Module.instance_method(@original_visibility).bind(stubbee).call(method)
-      end
+    def method_body(method)
+      method
     end
 
-    def method_exists?(method)
-      return true if stubbee.public_instance_methods(false).include?(method)
-      return true if stubbee.protected_instance_methods(false).include?(method)
-      return true if stubbee.private_instance_methods(false).include?(method)
-      return false
+    def stubbee_method(method_name)
+      stubbee.instance_method(method_name)
     end
 
-    private
-
-    def include_prepended_module
-      possible_prepended_modules = stubbee.ancestors.take_while do |mod|
-        !(Class === mod)
-      end
-
-      if possible_prepended_modules.any?
-        @definition_target = PrependedModule.new
-        stubbee.__send__ :prepend, @definition_target
-      end
+    def original_method_owner
+      stubbee
     end
-
-    def definition_target
-      @definition_target ||= stubbee
-    end
-
   end
-
 end

data/lib/mocha/api.rb

@@ -3,34 +3,60 @@ require 'mocha/hooks'
 require 'mocha/mockery'
 require 'mocha/sequence'
 require 'mocha/object_methods'
-require 'mocha/module_methods'
 require 'mocha/class_methods'
 
 module Mocha
-
   # Methods added to +Test::Unit::TestCase+, +MiniTest::Unit::TestCase+ or equivalent.
+  # The mock creation methods are {#mock}, {#stub} and {#stub_everything}, all of which return a #{Mock}
+  # which can be further modified by {Mock#responds_like} and {Mock#responds_like_instance_of} methods,
+  # both of which return a {Mock}, too, and can therefore, be chained to the original creation methods.
+  #
+  # {Mock#responds_like} and {Mock#responds_like_instance_of} force the mock to indicate what it is
+  # supposed to be mocking, thus making it a safer verifying mock. They check that the underlying +responder+
+  # will actually respond to the methods being stubbed, throwing a +NoMethodError+ upon invocation otherwise.
+  #
+  # @example Verifying mock using {Mock#responds_like_instance_of}
+  #   class Sheep
+  #     def initialize
+  #       raise "some awkward code we don't want to call"
+  #     end
+  #     def chew(grass); end
+  #   end
+  #
+  #   sheep = mock('sheep').responds_like_instance_of(Sheep)
+  #   sheep.expects(:chew)
+  #   sheep.expects(:foo)
+  #   sheep.respond_to?(:chew) # => true
+  #   sheep.respond_to?(:foo) # => false
+  #   sheep.chew
+  #   sheep.foo # => raises NoMethodError exception
   module API
-
     include ParameterMatchers
     include Hooks
 
     # @private
-    def self.included(mod)
+    def self.included(_mod)
       Object.send(:include, Mocha::ObjectMethods)
-      Module.send(:include, Mocha::ModuleMethods)
       Class.send(:include, Mocha::ClassMethods)
     end
 
+    # @private
+    def self.extended(mod)
+      included(mod)
+    end
+
     # Builds a new mock object
     #
-    # @param [String] name identifies mock object in error messages.
-    # @param [Hash] expected_methods_vs_return_values expected method name symbols as keys and corresponding return values as values - these expectations are setup as if {Mock#expects} were called multiple times.
-    # @yield optional block to be evaluated against the mock object instance, giving an alternative way to setup expectations.
     # @return [Mock] a new mock object
     #
-    # @overload def mock(name, &block)
-    # @overload def mock(expected_methods_vs_return_values = {}, &block)
-    # @overload def mock(name, expected_methods_vs_return_values = {}, &block)
+    # @overload def mock(name)
+    #   @param [String, Symbol] name identifies mock object in error messages.
+    #   @note Prior to v1.10.0 when +name+ was a +Symbol+, this method returned an unnamed +Mock+ that expected the method identified by +name+. This was undocumented behaviour and it will be removed in the future, but for the moment it can be reinstated using {Configuration#reinstate_undocumented_behaviour_from_v1_9=}.
+    # @overload def mock(expected_methods_vs_return_values = {})
+    #   @param [Hash] expected_methods_vs_return_values expected method name symbols as keys and corresponding return values as values - these expectations are setup as if {Mock#expects} were called multiple times.
+    # @overload def mock(name, expected_methods_vs_return_values = {})
+    #   @param [String, Symbol] name identifies mock object in error messages.
+    #   @param [Hash] expected_methods_vs_return_values expected method name symbols as keys and corresponding return values as values - these expectations are setup as if {Mock#expects} were called multiple times.
     #
     # @example Using expected_methods_vs_return_values Hash to setup expectations.
     #   def test_motor_starts_and_stops
@@ -39,71 +65,92 @@ module Mocha
     #     assert motor.stop
     #     # an error will be raised unless both Motor#start and Motor#stop have been called
     #   end
-    # @example Using the optional block to setup expectations & stubbed methods.
-    #   def test_motor_starts_and_stops
-    #     motor = mock('motor') do
-    #       expects(:start).with(100.rpm).returns(true)
-    #       stubs(:stop).returns(true)
-    #     end
-    #     assert motor.start(100.rpm)
-    #     assert motor.stop
-    #     # an error will only be raised if Motor#start(100.rpm) has not been called
-    #   end
-    def mock(*arguments, &block)
-      name = arguments.shift if arguments.first.is_a?(String)
+    #
+    def mock(*arguments) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+      if Mocha.configuration.reinstate_undocumented_behaviour_from_v1_9?
+        if arguments.first.is_a?(Symbol)
+          method_name = arguments[0]
+          Deprecation.warning(
+            "Explicitly include `#{method_name}` in Hash of expected methods vs return values,",
+            " e.g. `mock(:#{method_name} => nil)`."
+          )
+          if arguments[1]
+            Deprecation.warning(
+              "In this case the 2nd argument for `mock(:##{method_name}, ...)` is ignored,",
+              ' but in the future a Hash of expected methods vs return values will be respected.'
+            )
+          end
+        elsif arguments.first.is_a?(String)
+          name = arguments.shift
+        end
+      elsif arguments.first.is_a?(String) || arguments.first.is_a?(Symbol)
+        name = arguments.shift
+      end
       expectations = arguments.shift || {}
-      mock = name ? Mockery.instance.named_mock(name, &block) : Mockery.instance.unnamed_mock(&block)
+      mock = name ? Mockery.instance.named_mock(name) : Mockery.instance.unnamed_mock
       mock.expects(expectations)
       mock
     end
 
     # Builds a new mock object
     #
-    # @param [String] name identifies mock object in error messages.
-    # @param [Hash] stubbed_methods_vs_return_values stubbed method name symbols as keys and corresponding return values as values - these stubbed methods are setup as if {Mock#stubs} were called multiple times.
-    # @yield optional block to be evaluated against the mock object instance, giving an alternative way to setup stubbed methods.
     # @return [Mock] a new mock object
     #
-    # @overload def stub(name, &block)
-    # @overload def stub(stubbed_methods_vs_return_values = {}, &block)
-    # @overload def stub(name, stubbed_methods_vs_return_values = {}, &block)
+    # @overload def stub(name)
+    #   @param [String, Symbol] name identifies mock object in error messages.
+    #   @note Prior to v1.10.0 when +name+ was a +Symbol+, this method returned an unnamed +Mock+ that stubbed the method identified by +name+. This was undocumented behaviour and it will be removed in the future, but for the moment it can be reinstated using {Configuration#reinstate_undocumented_behaviour_from_v1_9=}.
+    # @overload def stub(stubbed_methods_vs_return_values = {})
+    #   @param [Hash] stubbed_methods_vs_return_values stubbed method name symbols as keys and corresponding return values as values - these stubbed methods are setup as if {Mock#stubs} were called multiple times.
+    # @overload def stub(name, stubbed_methods_vs_return_values = {})
+    #   @param [String, Symbol] name identifies mock object in error messages.
     #
     # @example Using stubbed_methods_vs_return_values Hash to setup stubbed methods.
     #   def test_motor_starts_and_stops
-    #     motor = mock('motor', :start => true, :stop => true)
+    #     motor = stub('motor', :start => true, :stop => true)
     #     assert motor.start
     #     assert motor.stop
     #     # an error will not be raised even if either Motor#start or Motor#stop has not been called
     #   end
-    #
-    # @example Using the optional block to setup expectations & stubbed methods.
-    #   def test_motor_starts_and_stops
-    #     motor = mock('motor') do
-    #       expects(:start).with(100.rpm).returns(true)
-    #       stubs(:stop).returns(true)
-    #     end
-    #     assert motor.start(100.rpm)
-    #     assert motor.stop
-    #     # an error will only be raised if Motor#start(100.rpm) has not been called
-    #   end
-    def stub(*arguments, &block)
-      name = arguments.shift if arguments.first.is_a?(String)
+    # rubocop:disable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+    def stub(*arguments)
+      if Mocha.configuration.reinstate_undocumented_behaviour_from_v1_9?
+        if arguments.first.is_a?(Symbol)
+          method_name = arguments[0]
+          Deprecation.warning(
+            "Explicitly include `#{method_name}` in Hash of stubbed methods vs return values,",
+            " e.g. `stub(:#{method_name} => nil)`."
+          )
+          if arguments[1]
+            Deprecation.warning(
+              "In this case the 2nd argument for `stub(:##{method_name}, ...)` is ignored,",
+              ' but in the future a Hash of stubbed methods vs return values will be respected.'
+            )
+          end
+        elsif arguments.first.is_a?(String)
+          name = arguments.shift
+        end
+      elsif arguments.first.is_a?(String) || arguments.first.is_a?(Symbol)
+        name = arguments.shift
+      end
       expectations = arguments.shift || {}
-      stub = name ? Mockery.instance.named_mock(name, &block) : Mockery.instance.unnamed_mock(&block)
+      stub = name ? Mockery.instance.named_mock(name) : Mockery.instance.unnamed_mock
       stub.stubs(expectations)
       stub
     end
+    # rubocop:enable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
 
     # Builds a mock object that accepts calls to any method. By default it will return +nil+ for any method call.
     #
-    # @param [String] name identifies mock object in error messages.
-    # @param [Hash] stubbed_methods_vs_return_values stubbed method name symbols as keys and corresponding return values as values - these stubbed methods are setup as if {Mock#stubs} were called multiple times.
-    # @yield optional block to be evaluated against the mock object instance, giving an alternative way to setup stubbed methods.
     # @return [Mock] a new mock object
     #
-    # @overload def stub_everything(name, &block)
-    # @overload def stub_everything(stubbed_methods_vs_return_values = {}, &block)
-    # @overload def stub_everything(name, stubbed_methods_vs_return_values = {}, &block)
+    # @overload def stub_everything(name)
+    #   @param [String, Symbol] name identifies mock object in error messages.
+    #   @note Prior to v1.10.0 when +name+ was a +Symbol+, this method returned an unnamed +Mock+ that stubbed the method identified by +name+. This was undocumented behaviour and it will be removed in the future, but for the moment it can be reinstated using {Configuration#reinstate_undocumented_behaviour_from_v1_9=}.
+    # @overload def stub_everything(stubbed_methods_vs_return_values = {})
+    #   @param [Hash] stubbed_methods_vs_return_values stubbed method name symbols as keys and corresponding return values as values - these stubbed methods are setup as if {Mock#stubs} were called multiple times.
+    # @overload def stub_everything(name, stubbed_methods_vs_return_values = {})
+    #   @param [String, Symbol] name identifies mock object in error messages.
+    #   @param [Hash] stubbed_methods_vs_return_values stubbed method name symbols as keys and corresponding return values as values - these stubbed methods are setup as if {Mock#stubs} were called multiple times.
     #
     # @example Ignore invocations of irrelevant methods.
     #   def test_motor_stops
@@ -112,14 +159,34 @@ module Mocha
     #     assert_nil motor.irrelevant_method_2 # => no error raised
     #     assert motor.stop
     #   end
-    def stub_everything(*arguments, &block)
-      name = arguments.shift if arguments.first.is_a?(String)
+    # rubocop:disable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+    def stub_everything(*arguments)
+      if Mocha.configuration.reinstate_undocumented_behaviour_from_v1_9?
+        if arguments.first.is_a?(Symbol)
+          method_name = arguments[0]
+          Deprecation.warning(
+            "Explicitly include `#{method_name}` in Hash of stubbed methods vs return values,",
+            " e.g. `stub_everything(:#{method_name} => nil)`."
+          )
+          if arguments[1]
+            Deprecation.warning(
+              "In this case the 2nd argument for `stub_everything(:##{method_name}, ...)` is ignored,",
+              ' but in the future a Hash of stubbed methods vs return values will be respected.'
+            )
+          end
+        elsif arguments.first.is_a?(String)
+          name = arguments.shift
+        end
+      elsif arguments.first.is_a?(String) || arguments.first.is_a?(Symbol)
+        name = arguments.shift
+      end
       expectations = arguments.shift || {}
-      stub = name ? Mockery.instance.named_mock(name, &block) : Mockery.instance.unnamed_mock(&block)
+      stub = name ? Mockery.instance.named_mock(name) : Mockery.instance.unnamed_mock
       stub.stub_everything
       stub.stubs(expectations)
       stub
     end
+    # rubocop:enable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
 
     # Builds a new sequence which can be used to constrain the order in which expectations can occur.
     #
@@ -170,7 +237,5 @@ module Mocha
     def states(name)
       Mockery.instance.new_state_machine(name)
     end
-
   end
-
 end

data/lib/mocha/argument_iterator.rb

@@ -1,21 +1,17 @@
 module Mocha
-
   class ArgumentIterator
-
     def initialize(argument)
       @argument = argument
     end
 
-    def each(&block)
-      if @argument.is_a?(Hash) then
+    def each
+      if @argument.is_a?(Hash)
         @argument.each do |method_name, return_value|
-          block.call(method_name, return_value)
+          yield method_name, return_value
         end
       else
-        block.call(@argument)
+        yield @argument
       end
     end
-
   end
-
 end

data/lib/mocha/backtrace_filter.rb

@@ -1,8 +1,6 @@
 module Mocha
-
   class BacktraceFilter
-
-    LIB_DIRECTORY = File.expand_path(File.join(File.dirname(__FILE__), "..")) + File::SEPARATOR
+    LIB_DIRECTORY = File.expand_path(File.join(File.dirname(__FILE__), '..')) + File::SEPARATOR
 
     def initialize(lib_directory = LIB_DIRECTORY)
       @path_pattern = Regexp.new(lib_directory)
@@ -11,7 +9,5 @@ module Mocha
     def filtered(backtrace)
       backtrace.reject { |location| @path_pattern.match(File.expand_path(location)) }
     end
-
   end
-
 end

data/lib/mocha/block_matcher.rb

@@ -0,0 +1,31 @@
+module Mocha
+  module BlockMatchers
+    class OptionalBlock
+      def match?(_actual_block)
+        true
+      end
+
+      def mocha_inspect; end
+    end
+
+    class BlockGiven
+      def match?(actual_block)
+        !actual_block.nil?
+      end
+
+      def mocha_inspect
+        'with block given'
+      end
+    end
+
+    class NoBlockGiven
+      def match?(actual_block)
+        actual_block.nil?
+      end
+
+      def mocha_inspect
+        'with no block given'
+      end
+    end
+  end
+end