much-stub 0.1.6 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a6dc9e4397c7c270a2678eac9f4761adb80bdd842e6708417844855639c6acfa
-  data.tar.gz: 57f89b55ddaf3b17a2444f7bbd40d2e8f9b1ad3046d1634021412f8847df605b
+  metadata.gz: 15204360d9518246e4abaa703670f75489b26364a262f61397956bcd6292bb91
+  data.tar.gz: e53db7a648e52be63ea31d6dc930d7c009e65604d05a4e1e447edcfb3ef7b296
 SHA512:
-  metadata.gz: b57f84be1092bba24dfd51ace398e8116941a16e17f8698436158309305672e55076b46bb4b5695763c97530f7cbfce6f974de6b331432336d7b0aad8a2ecfe0
-  data.tar.gz: 4705afaee215d93ed0a998949dd70dd2d13f03aa5fac9a31093940be16799ad43b2878df7870a046b79a1a4e2c9625bb0f5195896c371c24728600445c18c55a
+  metadata.gz: 5892e22dc64f46400a115d42fb7b7da3d5b82387fda5b8c2ec5f807d6a9b47e4dca5a92d86a3a97898d5f6e85885808065d591e53aba7d78303afc1396fce4a4
+  data.tar.gz: 4476a777e7ee869f59080f5c0bc40d2d8736d77d01588f193ea6e826f424d3abf110ca49a60437267e7e16d5578c2f6f74bb24ce810940af82154ce0e08e7199

data/.l.yml

@@ -0,0 +1,8 @@
+# https://github.com/redding/l.rb
+
+linters:
+  - name: "Rubocop"
+    cmd: "bundle exec rubocop"
+    extensions:
+      - ".rb"
+    cli_abbrev: "u"

data/.rubocop.yml

@@ -0,0 +1,3 @@
+inherit_gem:
+  much-style-guide:
+    - "lib/much-style-guide/rubocop.yml"

data/.ruby-version

@@ -0,0 +1 @@
+2.5.8

data/.t.yml

@@ -0,0 +1,6 @@
+# https://github.com/redding/t.rb
+
+default_cmd: bundle exec assert
+test_dir: test
+test_file_suffixes:
+  - "_tests.rb"

data/Gemfile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 source "https://rubygems.org"
 
 ruby "~> 2.5"

data/lib/much-stub.rb

@@ -15,66 +15,69 @@ module MuchStub
   end
 
   def self.arity_matches?(method, args)
-    return true if method.arity == args.size # mandatory args
-    return true if method.arity < 0 && args.size >= (method.arity+1).abs # variable args
-    return false
+    # mandatory args
+    return true if method.arity == args.size
+    # variable args
+    return true if method.arity < 0 && args.size >= (method.arity + 1).abs
+
+    false
   end
 
   def self.stub(obj, meth, &block)
-    key = self.stub_key(obj, meth)
-    self.stubs[key] ||= MuchStub::Stub.new(obj, meth, caller_locations)
-    self.stubs[key].tap{ |s| s.do = block }
+    key = stub_key(obj, meth)
+    stubs[key] ||= MuchStub::Stub.new(obj, meth, caller_locations)
+    stubs[key].tap{ |s| s.do = block }
   end
 
   def self.call(*args, &block)
-    self.stub(*args, &block)
+    stub(*args, &block)
   end
 
   def self.stub_on_call(*args, &on_call_block)
-    self.stub(*args).on_call(&on_call_block)
+    stub(*args).on_call(&on_call_block)
   end
 
   def self.on_call(*args, &on_call_block)
-    self.stub_on_call(*args, &on_call_block)
+    stub_on_call(*args, &on_call_block)
   end
 
   def self.unstub(obj, meth)
-    key = self.stub_key(obj, meth)
-    (self.stubs.delete(key) || MuchStub::NullStub.new).teardown
+    key = stub_key(obj, meth)
+    (stubs.delete(key) || MuchStub::NullStub.new).teardown
   end
 
   def self.unstub!
-    self.stubs.keys.each{ |key| self.stubs.delete(key).teardown }
+    stubs.keys.each{ |key| stubs.delete(key).teardown }
   end
 
   def self.stub_send(obj, meth, *args, &block)
     orig_caller = caller_locations
-    stub = self.stubs.fetch(MuchStub::Stub.key(obj, meth)) do
+    stub = stubs.fetch(MuchStub::Stub.key(obj, meth)) do
       raise NotStubbedError, "`#{meth}` not stubbed.", orig_caller.map(&:to_s)
     end
     stub.call_method(args, &block)
   end
 
   def self.tap(obj, meth, &tap_block)
-    self.stub(obj, meth) { |*args, &block|
-      self.stub_send(obj, meth, *args, &block).tap { |value|
-        tap_block.call(value, *args, &block) if tap_block
-      }
-    }
+    stub(obj, meth) do |*args, &block|
+      stub_send(obj, meth, *args, &block).tap do |value|
+        tap_block&.call(value, *args, &block)
+      end
+    end
   end
 
   def self.tap_on_call(obj, meth, &on_call_block)
-    self.tap(obj, meth) { |value, *args, &block|
-      on_call_block.call(value, MuchStub::Call.new(*args, &block)) if on_call_block
-    }
+    tap(obj, meth) do |value, *args, &block|
+      on_call_block&.call(value, MuchStub::Call.new(*args, &block))
+    end
   end
 
   def self.spy(obj, *meths, **return_values)
     MuchStub::CallSpy.new(**return_values).call_spy_tap do |spy|
       meths.each do |meth|
-        self.stub(obj, meth) { |*args, &block|
+        stub(obj, meth) do |*args, &block|
           spy.__send__(meth, *args, &block)
-        }
+        end
       end
     end
   end
@@ -116,7 +119,9 @@ module MuchStub
             @method,
             args,
             method_name: @method_name,
-            backtrace: orig_caller))
+            backtrace: orig_caller,
+          ),
+        )
       end
       lookup(args, orig_caller).call(*args, &block)
     rescue NotStubbedError
@@ -132,7 +137,9 @@ module MuchStub
             @method,
             args,
             method_name: @method_name,
-            backtrace: orig_caller))
+            backtrace: orig_caller,
+          ),
+        )
       end
       @lookup[args] = block
       self
@@ -140,12 +147,12 @@ module MuchStub
 
     def on_call(&on_call_block)
       stub_block =
-        ->(*args, &block) {
-          on_call_block.call(MuchStub::Call.new(*args, &block)) if on_call_block
+        ->(*args, &block){
+          on_call_block&.call(MuchStub::Call.new(*args, &block))
         }
       if @lookup.empty?
         @do = stub_block
-      elsif @lookup.has_value?(nil)
+      elsif @lookup.value?(nil)
         @lookup.transform_values!{ |value| value.nil? ? stub_block : value }
       end
       self
@@ -159,7 +166,7 @@ module MuchStub
     end
 
     def inspect
-      "#<#{self.class}:#{"0x0%x" % (object_id << 1)}" \
+      "#<#{self.class}:#{format("0x0%x", (object_id << 1))}" \
       " @method_name=#{@method_name.inspect}" \
       ">"
     end
@@ -171,7 +178,7 @@ module MuchStub
         msg = "#{object.inspect} does not respond to `#{@method_name}`"
         raise StubError, msg, orig_caller.map(&:to_s)
       end
-      is_constant          = object.kind_of?(Module)
+      is_constant          = object.is_a?(Module)
       local_object_methods = object.methods(false).map(&:to_s)
       all_object_methods   = object.methods.map(&:to_s)
       if (is_constant && !local_object_methods.include?(@method_name)) ||
@@ -182,7 +189,8 @@ module MuchStub
         method
       end
 
-      if !local_object_methods.include?(@name) # already stubbed
+      # already stubbed
+      unless local_object_methods.include?(@name)
         @metaclass.send(:alias_method, @name, @method_name)
       end
       @method = object.method(@name)
@@ -196,19 +204,21 @@ module MuchStub
     end
 
     def lookup(args, orig_caller)
-      @lookup.fetch(args) {
-        self.do || begin
+      @lookup.fetch(args) do
+        self.do ||
+        begin
           msg = "#{inspect_call(args)} not stubbed."
           inspect_lookup_stubs.tap do |stubs|
-            msg += "\nStubs:\n#{stubs}" if !stubs.empty?
+            msg += "\nStubs:\n#{stubs}" unless stubs.empty?
           end
           raise NotStubbedError, msg, orig_caller.map(&:to_s)
         end
-      } ||
-        raise(
-          StubError,
-          "#{inspect_call(args)} stubbed with no block.",
-          orig_caller.map(&:to_s))
+      end ||
+      raise(
+        StubError,
+        "#{inspect_call(args)} stubbed with no block.",
+        orig_caller.map(&:to_s),
+      )
     end
 
     def inspect_lookup_stubs
@@ -244,9 +254,12 @@ module MuchStub
       end
     end
 
-  NullStub = Class.new do
-    def teardown; end # no-op
-  end
+  NullStub =
+    Class.new do
+      def teardown
+        # no-op
+      end
+    end
 
   module ParameterList
     LETTERS = ("a".."z").to_a.freeze
@@ -259,8 +272,6 @@ module MuchStub
       params.join(", ")
     end
 
-    private
-
     def self.get_arity(object, method_name)
       object.method(method_name).arity
     rescue NameError

data/lib/much-stub/call_spy.rb

@@ -6,14 +6,14 @@ module MuchStub
   class CallSpy < ::BasicObject
     METHOD_NAME_REPLACEMENTS = {
       "!" => "_bang",
-      "?" => "_predicate"
+      "?" => "_predicate",
     }.freeze
 
     def initialize(**return_values)
-      @call_spy_return_values = return_values.transform_keys{ |key| key.to_s }
-      @call_spy_method_calls = ::Hash.new { |hash, key| hash[key] = [] }
+      @call_spy_return_values = return_values.transform_keys(&:to_s)
+      @call_spy_method_calls = ::Hash.new{ |hash, key| hash[key] = [] }
       @call_spy_method_return_values =
-        ::Hash.new { |hash, key| hash[key] = call_spy_return_value_proc(key) }
+        ::Hash.new{ |hash, key| hash[key] = call_spy_return_value_proc(key) }
     end
 
     def call_spy_tap
@@ -22,23 +22,23 @@ module MuchStub
     end
 
     def ==(other)
-      self.equal?(other)
+      equal?(other)
     end
 
     def ===(other)
-      self.equal?(other)
+      equal?(other)
     end
 
     def eql?(other)
-      self.equal?(other)
+      equal?(other)
     end
 
     def equal?(other)
-      self.__id__ == other.__id__
+      __id__ == other.__id__
     end
 
     def hash
-      self.__id__
+      __id__
     end
 
     def respond_to?(*)
@@ -46,7 +46,7 @@ module MuchStub
     end
 
     def inspect
-      "#<MuchStub::CallSpy:#{"0x0%x" % (self.__id__ << 1)}>"
+      "#<MuchStub::CallSpy:#{"0x0%x" % (__id__ << 1)}>"
     end
 
     private
@@ -56,14 +56,14 @@ module MuchStub
     end
 
     def call_spy_return_value_proc(method_name)
-      value = @call_spy_return_values.fetch(method_name, ::Proc.new { self })
-      value.respond_to?(:call) ? value : ::Proc.new { value }
+      value = @call_spy_return_values.fetch(method_name, ::Proc.new{ self })
+      value.respond_to?(:call) ? value : ::Proc.new{ value }
     end
 
     def call_spy_normalize_method_name(name)
-      METHOD_NAME_REPLACEMENTS.reduce(name.to_s) { |acc, (source, replacement)|
+      METHOD_NAME_REPLACEMENTS.reduce(name.to_s) do |acc, (source, replacement)|
         acc.gsub(source, replacement)
-      }
+      end
     end
 
     def call_spy_define_spied_method(name)
@@ -79,7 +79,9 @@ module MuchStub
       spied_method_name = query_method_match[1]
       query_method_suffix = query_method_match[2]
       method_name = call_spy_normalize_method_name(spied_method_name)
-      call_spy_define_metaclass_method("#{method_name}#{query_method_suffix}") do
+      call_spy_define_metaclass_method(
+        "#{method_name}#{query_method_suffix}",
+      ) do
         yield(method_name) if ::Kernel.block_given?
       end
     end
@@ -89,36 +91,35 @@ module MuchStub
       metaclass.define_method(name, &block)
     end
 
+    def respond_to_missing?(_name, *_args)
+      false
+    end
+
     def method_missing(name, *args, &block)
       if (match = name.match(/(\w+)(_calls)\z/))
         call_spy_define_query_method(match) do |method_name|
           @call_spy_method_calls[method_name]
         end
-        self.__send__(name, *args, &block)
       elsif (match = name.match(/(\w+)(_last_called_with)\z/))
         call_spy_define_query_method(match) do |method_name|
-          self.__send__("#{method_name}_calls").last
+          __send__("#{method_name}_calls").last
         end
-        self.__send__(name, *args, &block)
       elsif (match = name.match(/(\w+)(_called_with)\z/))
         call_spy_define_query_method(match) do |method_name|
-          self.__send__("#{method_name}_last_called_with")
+          __send__("#{method_name}_last_called_with")
         end
-        self.__send__(name, *args, &block)
       elsif (match = name.match(/(\w+)(_call_count)\z/))
         call_spy_define_query_method(match) do |method_name|
-          self.__send__("#{method_name}_calls").size
+          __send__("#{method_name}_calls").size
         end
-        self.__send__(name, *args, &block)
       elsif (match = name.match(/(\w+)(_called\?)\z/))
         call_spy_define_query_method(match) do |method_name|
-          self.__send__("#{method_name}_call_count") > 0
+          __send__("#{method_name}_call_count") > 0
         end
-        self.__send__(name, *args, &block)
       else
         call_spy_define_spied_method(name)
-        self.__send__(name, *args, &block)
       end
+      __send__(name, *args, &block)
     end
   end
 end

data/lib/much-stub/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module MuchStub
-  VERSION = "0.1.6"
+  VERSION = "0.1.7"
 end

data/much-stub.gemspec

@@ -1,24 +1,32 @@
 # -*- encoding: utf-8 -*-
+# frozen_string_literal: true
+
 lib = File.expand_path("../lib", __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require "much-stub/version"
 
 Gem::Specification.new do |gem|
-  gem.name        = "much-stub"
-  gem.version     = MuchStub::VERSION
-  gem.authors     = ["Kelly Redding", "Collin Redding"]
-  gem.email       = ["kelly@kellyredding.com", "collin.redding@me.com"]
-  gem.summary     = "Stubbing API for replacing method calls on objects in test runs."
-  gem.description = "Stubbing API for replacing method calls on objects in test runs."
-  gem.homepage    = "https://github.com/redding/much-stub"
-  gem.license     = "MIT"
-
-  gem.files         = `git ls-files`.split($/)
+  gem.name    = "much-stub"
+  gem.version = MuchStub::VERSION
+  gem.authors = ["Kelly Redding", "Collin Redding"]
+  gem.email   = ["kelly@kellyredding.com", "collin.redding@me.com"]
+
+  gem.summary =
+    "Stubbing API for replacing method calls on objects in test runs."
+  gem.description =
+    "Stubbing API for replacing method calls on objects in test runs."
+
+  gem.homepage = "https://github.com/redding/much-stub"
+  gem.license  = "MIT"
+
+  gem.files = `git ls-files`.split($INPUT_RECORD_SEPARATOR)
+
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
 
   gem.required_ruby_version = "~> 2.5"
 
-  gem.add_development_dependency("assert", ["~> 2.19.0"])
+  gem.add_development_dependency("assert",           ["~> 2.19.2"])
+  gem.add_development_dependency("much-style-guide", ["~> 0.6.0"])
 end

data/test/helper.rb

@@ -14,7 +14,7 @@ require "test/support/factory"
 # 1.8.7 backfills
 
 # Array#sample
-if !(a = Array.new).respond_to?(:sample) && a.respond_to?(:choice)
+if !(a = []).respond_to?(:sample) && a.respond_to?(:choice)
   class Array
     alias_method :sample, :choice
   end

data/test/system/much-stub_tests.rb

@@ -57,15 +57,15 @@ module MuchStub
     end
 
     should "not allow stubbing methods with invalid arity" do
-      assert_raises{ MuchStub.stub(subject, :noargs).with(1){ } }
+      assert_raises{ MuchStub.stub(subject, :noargs).with(1){} }
 
-      assert_raises{ MuchStub.stub(subject, :withargs).with{ } }
-      assert_raises{ MuchStub.stub(subject, :withargs).with(1, 2){ } }
+      assert_raises{ MuchStub.stub(subject, :withargs).with{} }
+      assert_raises{ MuchStub.stub(subject, :withargs).with(1, 2){} }
 
-      assert_raises{ MuchStub.stub(subject, :minargs).with{ } }
-      assert_raises{ MuchStub.stub(subject, :minargs).with(1){ } }
+      assert_raises{ MuchStub.stub(subject, :minargs).with{} }
+      assert_raises{ MuchStub.stub(subject, :minargs).with(1){} }
 
-      assert_raises{ MuchStub.stub(subject, :withblock).with(1){ } }
+      assert_raises{ MuchStub.stub(subject, :withblock).with(1){} }
     end
 
     should "not allow calling methods with invalid arity" do
@@ -130,15 +130,15 @@ module MuchStub
     end
 
     should "not allow stubbing methods with invalid arity" do
-      assert_raises{ MuchStub.stub(subject, :noargs).with(1){ } }
+      assert_raises{ MuchStub.stub(subject, :noargs).with(1){} }
 
-      assert_raises{ MuchStub.stub(subject, :withargs).with{ } }
-      assert_raises{ MuchStub.stub(subject, :withargs).with(1, 2){ } }
+      assert_raises{ MuchStub.stub(subject, :withargs).with{} }
+      assert_raises{ MuchStub.stub(subject, :withargs).with(1, 2){} }
 
-      assert_raises{ MuchStub.stub(subject, :minargs).with{ } }
-      assert_raises{ MuchStub.stub(subject, :minargs).with(1){ } }
+      assert_raises{ MuchStub.stub(subject, :minargs).with{} }
+      assert_raises{ MuchStub.stub(subject, :minargs).with(1){} }
 
-      assert_raises{ MuchStub.stub(subject, :withblock).with(1){ } }
+      assert_raises{ MuchStub.stub(subject, :withblock).with(1){} }
     end
 
     should "not allow calling methods with invalid arity" do
@@ -203,15 +203,15 @@ module MuchStub
     end
 
     should "not allow stubbing methods with invalid arity" do
-      assert_raises{ MuchStub.stub(subject, :noargs).with(1){ } }
+      assert_raises{ MuchStub.stub(subject, :noargs).with(1){} }
 
-      assert_raises{ MuchStub.stub(subject, :withargs).with{ } }
-      assert_raises{ MuchStub.stub(subject, :withargs).with(1, 2){ } }
+      assert_raises{ MuchStub.stub(subject, :withargs).with{} }
+      assert_raises{ MuchStub.stub(subject, :withargs).with(1, 2){} }
 
-      assert_raises{ MuchStub.stub(subject, :minargs).with{ } }
-      assert_raises{ MuchStub.stub(subject, :minargs).with(1){ } }
+      assert_raises{ MuchStub.stub(subject, :minargs).with{} }
+      assert_raises{ MuchStub.stub(subject, :minargs).with(1){} }
 
-      assert_raises{ MuchStub.stub(subject, :withblock).with(1){ } }
+      assert_raises{ MuchStub.stub(subject, :withblock).with(1){} }
     end
 
     should "not allow calling methods with invalid arity" do
@@ -276,15 +276,15 @@ module MuchStub
     end
 
     should "not allow stubbing methods with invalid arity" do
-      assert_raises{ MuchStub.stub(subject, :noargs).with(1){ } }
+      assert_raises{ MuchStub.stub(subject, :noargs).with(1){} }
 
-      assert_raises{ MuchStub.stub(subject, :withargs).with{ } }
-      assert_raises{ MuchStub.stub(subject, :withargs).with(1, 2){ } }
+      assert_raises{ MuchStub.stub(subject, :withargs).with{} }
+      assert_raises{ MuchStub.stub(subject, :withargs).with(1, 2){} }
 
-      assert_raises{ MuchStub.stub(subject, :minargs).with{ } }
-      assert_raises{ MuchStub.stub(subject, :minargs).with(1){ } }
+      assert_raises{ MuchStub.stub(subject, :minargs).with{} }
+      assert_raises{ MuchStub.stub(subject, :minargs).with(1){} }
 
-      assert_raises{ MuchStub.stub(subject, :withblock).with(1){ } }
+      assert_raises{ MuchStub.stub(subject, :withblock).with(1){} }
     end
 
     should "not allow calling methods with invalid arity" do
@@ -350,15 +350,15 @@ module MuchStub
     end
 
     should "not allow stubbing methods with invalid arity" do
-      assert_raises{ MuchStub.stub(subject, :noargs).with(1){ } }
+      assert_raises{ MuchStub.stub(subject, :noargs).with(1){} }
 
-      assert_raises{ MuchStub.stub(subject, :withargs).with{ } }
-      assert_raises{ MuchStub.stub(subject, :withargs).with(1, 2){ } }
+      assert_raises{ MuchStub.stub(subject, :withargs).with{} }
+      assert_raises{ MuchStub.stub(subject, :withargs).with(1, 2){} }
 
-      assert_raises{ MuchStub.stub(subject, :minargs).with{ } }
-      assert_raises{ MuchStub.stub(subject, :minargs).with(1){ } }
+      assert_raises{ MuchStub.stub(subject, :minargs).with{} }
+      assert_raises{ MuchStub.stub(subject, :minargs).with(1){} }
 
-      assert_raises{ MuchStub.stub(subject, :withblock).with(1){ } }
+      assert_raises{ MuchStub.stub(subject, :withblock).with(1){} }
     end
 
     should "not allow calling methods with invalid arity" do
@@ -423,15 +423,15 @@ module MuchStub
     end
 
     should "not allow stubbing methods with invalid arity" do
-      assert_raises{ MuchStub.stub(subject, :noargs).with(1){ } }
+      assert_raises{ MuchStub.stub(subject, :noargs).with(1){} }
 
-      assert_raises{ MuchStub.stub(subject, :withargs).with{ } }
-      assert_raises{ MuchStub.stub(subject, :withargs).with(1, 2){ } }
+      assert_raises{ MuchStub.stub(subject, :withargs).with{} }
+      assert_raises{ MuchStub.stub(subject, :withargs).with(1, 2){} }
 
-      assert_raises{ MuchStub.stub(subject, :minargs).with{ } }
-      assert_raises{ MuchStub.stub(subject, :minargs).with(1){ } }
+      assert_raises{ MuchStub.stub(subject, :minargs).with{} }
+      assert_raises{ MuchStub.stub(subject, :minargs).with(1){} }
 
-      assert_raises{ MuchStub.stub(subject, :withblock).with(1){ } }
+      assert_raises{ MuchStub.stub(subject, :withblock).with(1){} }
     end
 
     should "not allow calling methods with invalid arity" do
@@ -497,15 +497,15 @@ module MuchStub
     end
 
     should "not allow stubbing methods with invalid arity" do
-      assert_raises{ MuchStub.stub(subject, :noargs).with(1){ } }
+      assert_raises{ MuchStub.stub(subject, :noargs).with(1){} }
 
-      assert_raises{ MuchStub.stub(subject, :withargs).with{ } }
-      assert_raises{ MuchStub.stub(subject, :withargs).with(1, 2){ } }
+      assert_raises{ MuchStub.stub(subject, :withargs).with{} }
+      assert_raises{ MuchStub.stub(subject, :withargs).with(1, 2){} }
 
-      assert_raises{ MuchStub.stub(subject, :minargs).with{ } }
-      assert_raises{ MuchStub.stub(subject, :minargs).with(1){ } }
+      assert_raises{ MuchStub.stub(subject, :minargs).with{} }
+      assert_raises{ MuchStub.stub(subject, :minargs).with(1){} }
 
-      assert_raises{ MuchStub.stub(subject, :withblock).with(1){ } }
+      assert_raises{ MuchStub.stub(subject, :withblock).with(1){} }
     end
 
     should "not allow calling methods with invalid arity" do
@@ -570,15 +570,15 @@ module MuchStub
     end
 
     should "allow stubbing methods with invalid arity" do
-      assert_nothing_raised{ MuchStub.stub(subject, :noargs).with(1){ } }
+      assert_nothing_raised{ MuchStub.stub(subject, :noargs).with(1){} }
 
-      assert_nothing_raised{ MuchStub.stub(subject, :withargs).with{ } }
-      assert_nothing_raised{ MuchStub.stub(subject, :withargs).with(1, 2){ } }
+      assert_nothing_raised{ MuchStub.stub(subject, :withargs).with{} }
+      assert_nothing_raised{ MuchStub.stub(subject, :withargs).with(1, 2){} }
 
-      assert_nothing_raised{ MuchStub.stub(subject, :minargs).with{ } }
-      assert_nothing_raised{ MuchStub.stub(subject, :minargs).with(1){ } }
+      assert_nothing_raised{ MuchStub.stub(subject, :minargs).with{} }
+      assert_nothing_raised{ MuchStub.stub(subject, :minargs).with(1){} }
 
-      assert_nothing_raised{ MuchStub.stub(subject, :withblock).with(1){ } }
+      assert_nothing_raised{ MuchStub.stub(subject, :withblock).with(1){} }
     end
 
     should "allow calling methods with invalid arity" do
@@ -643,15 +643,15 @@ module MuchStub
     end
 
     should "allow stubbing methods with invalid arity" do
-      assert_nothing_raised{ MuchStub.stub(subject, :noargs).with(1){ } }
+      assert_nothing_raised{ MuchStub.stub(subject, :noargs).with(1){} }
 
-      assert_nothing_raised{ MuchStub.stub(subject, :withargs).with{ } }
-      assert_nothing_raised{ MuchStub.stub(subject, :withargs).with(1, 2){ } }
+      assert_nothing_raised{ MuchStub.stub(subject, :withargs).with{} }
+      assert_nothing_raised{ MuchStub.stub(subject, :withargs).with(1, 2){} }
 
-      assert_nothing_raised{ MuchStub.stub(subject, :minargs).with{ } }
-      assert_nothing_raised{ MuchStub.stub(subject, :minargs).with(1){ } }
+      assert_nothing_raised{ MuchStub.stub(subject, :minargs).with{} }
+      assert_nothing_raised{ MuchStub.stub(subject, :minargs).with(1){} }
 
-      assert_nothing_raised{ MuchStub.stub(subject, :withblock).with(1){ } }
+      assert_nothing_raised{ MuchStub.stub(subject, :withblock).with(1){} }
     end
 
     should "allow calling methods with invalid arity" do
@@ -684,37 +684,73 @@ module MuchStub
   end
 
   class TestClass
-    def self.noargs; end
-    def self.withargs(a); end
-    def self.anyargs(*args); end
-    def self.minargs(a, b, *args); end
-    def self.withblock(&block); end
-
-    def noargs; end
-    def withargs(a); end
-    def anyargs(*args); end
-    def minargs(a, b, *args); end
-    def withblock(&block); end
+    def self.noargs
+    end
+
+    def self.withargs(a)
+    end
+
+    def self.anyargs(*args)
+    end
+
+    def self.minargs(a, b, *args)
+    end
+
+    def self.withblock(&block)
+    end
+
+    def noargs
+    end
+
+    def withargs(a)
+    end
+
+    def anyargs(*args)
+    end
+
+    def minargs(a, b, *args)
+    end
+
+    def withblock(&block)
+    end
   end
 
   module TestModule
-    def self.noargs; end
-    def self.withargs(a); end
-    def self.anyargs(*args); end
-    def self.minargs(a, b, *args); end
-    def self.withblock(&block); end
+    def self.noargs
+    end
+
+    def self.withargs(a)
+    end
+
+    def self.anyargs(*args)
+    end
+
+    def self.minargs(a, b, *args)
+    end
+
+    def self.withblock(&block)
+    end
   end
 
   module TestMixin
-    def noargs; end
-    def withargs(a); end
-    def anyargs(*args); end
-    def minargs(a, b, *args); end
-    def withblock(&block); end
+    def noargs
+    end
+
+    def withargs(a)
+    end
+
+    def anyargs(*args)
+    end
+
+    def minargs(a, b, *args)
+    end
+
+    def withblock(&block)
+    end
   end
 
   class DelegateClass
-    def self.respond_to?(*args)
+    def self.respond_to_missing?(*args)
       TestClass.respond_to?(*args) || super
     end
 
@@ -726,7 +762,7 @@ module MuchStub
       @delegate = TestClass.new
     end
 
-    def respond_to?(*args)
+    def respond_to_missing?(*args)
       @delegate.respond_to?(*args) || super
     end