much-stub 0.1.1 → 0.1.6

data/lib/much-stub/call.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module MuchStub
+  class Call
+    attr_reader :pargs, :kargs, :block
+
+    def initialize(*pargs, **kargs, &block)
+      @pargs = pargs.empty? ? nil : pargs
+      @kargs = kargs.empty? ? nil : kargs
+      @block = block
+    end
+
+    def args
+      @args ||= [*pargs, kargs].compact
+    end
+  end
+end

data/lib/much-stub/call_spy.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require "much-stub/call"
+
+module MuchStub
+  class CallSpy < ::BasicObject
+    METHOD_NAME_REPLACEMENTS = {
+      "!" => "_bang",
+      "?" => "_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_method_return_values =
+        ::Hash.new { |hash, key| hash[key] = call_spy_return_value_proc(key) }
+    end
+
+    def call_spy_tap
+      yield self
+      self
+    end
+
+    def ==(other)
+      self.equal?(other)
+    end
+
+    def ===(other)
+      self.equal?(other)
+    end
+
+    def eql?(other)
+      self.equal?(other)
+    end
+
+    def equal?(other)
+      self.__id__ == other.__id__
+    end
+
+    def hash
+      self.__id__
+    end
+
+    def respond_to?(*)
+      true
+    end
+
+    def inspect
+      "#<MuchStub::CallSpy:#{"0x0%x" % (self.__id__ << 1)}>"
+    end
+
+    private
+
+    def call_spy_method_return_value(method_name, much_stub_call)
+      @call_spy_method_return_values[method_name.to_s].call(much_stub_call)
+    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 }
+    end
+
+    def call_spy_normalize_method_name(name)
+      METHOD_NAME_REPLACEMENTS.reduce(name.to_s) { |acc, (source, replacement)|
+        acc.gsub(source, replacement)
+      }
+    end
+
+    def call_spy_define_spied_method(name)
+      method_name = call_spy_normalize_method_name(name)
+      call_spy_define_metaclass_method(name) do |*args, &block|
+        call = ::MuchStub::Call.new(*args, &block)
+        @call_spy_method_calls[method_name] << call
+        call_spy_method_return_value(name, call)
+      end
+    end
+
+    def call_spy_define_query_method(query_method_match)
+      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
+        yield(method_name) if ::Kernel.block_given?
+      end
+    end
+
+    def call_spy_define_metaclass_method(name, &block)
+      metaclass = class << self; self; end
+      metaclass.define_method(name, &block)
+    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
+        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")
+        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
+        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
+        end
+        self.__send__(name, *args, &block)
+      else
+        call_spy_define_spied_method(name)
+        self.__send__(name, *args, &block)
+      end
+    end
+  end
+end

data/lib/much-stub/version.rb

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

data/much-stub.gemspec

@@ -1,5 +1,5 @@
 # -*- encoding: utf-8 -*-
-lib = File.expand_path('../lib', __FILE__)
+lib = File.expand_path("../lib", __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require "much-stub/version"
 
@@ -11,13 +11,14 @@ Gem::Specification.new do |gem|
   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.license     = "MIT"
 
   gem.files         = `git ls-files`.split($/)
   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.add_development_dependency("assert", ["~> 2.17.0"])
+  gem.required_ruby_version = "~> 2.5"
 
+  gem.add_development_dependency("assert", ["~> 2.19.0"])
 end

data/test/helper.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # this file is automatically required when you run `assert`
 # put any test helpers here
 
@@ -5,9 +7,9 @@
 $LOAD_PATH.unshift(File.expand_path("../..", __FILE__))
 
 # require pry for debugging (`binding.pry`)
-require 'pry'
+require "pry"
 
-require 'test/support/factory'
+require "test/support/factory"
 
 # 1.8.7 backfills
 
@@ -19,7 +21,7 @@ if !(a = Array.new).respond_to?(:sample) && a.respond_to?(:choice)
 end
 
 # unstub all test stubs automatically for Assert test suite
-require 'assert'
+require "assert"
 class Assert::Context
   teardown{ MuchStub.unstub! }
 end

data/test/support/factory.rb

@@ -1,6 +1,7 @@
-require 'assert/factory'
+# frozen_string_literal: true
+
+require "assert/factory"
 
 module Factory
   extend Assert::Factory
-
 end

data/test/system/much-stub_tests.rb

@@ -1,59 +1,59 @@
-require 'assert'
-require 'much-stub'
+# frozen_string_literal: true
 
-module MuchStub
+require "assert"
+require "much-stub"
 
+module MuchStub
   class SystemTests < Assert::Context
     desc "MuchStub"
-
   end
 
   class InstanceTests < SystemTests
     desc "for instance methods"
     setup do
       @instance = TestClass.new
-      MuchStub.stub(@instance, :noargs){ 'default' }
-      MuchStub.stub(@instance, :noargs).with{ 'none' }
+      MuchStub.stub(@instance, :noargs){ "default" }
+      MuchStub.stub(@instance, :noargs).with{ "none" }
 
-      MuchStub.stub(@instance, :withargs){ 'default' }
-      MuchStub.stub(@instance, :withargs).with(1){ 'one' }
+      MuchStub.stub(@instance, :withargs){ "default" }
+      MuchStub.stub(@instance, :withargs).with(1){ "one" }
 
-      MuchStub.stub(@instance, :anyargs){ 'default' }
-      MuchStub.stub(@instance, :anyargs).with(1, 2){ 'one-two' }
+      MuchStub.stub(@instance, :anyargs){ "default" }
+      MuchStub.stub(@instance, :anyargs).with(1, 2){ "one-two" }
 
-      MuchStub.stub(@instance, :minargs){ 'default' }
-      MuchStub.stub(@instance, :minargs).with(1, 2){ 'one-two' }
-      MuchStub.stub(@instance, :minargs).with(1, 2, 3){ 'one-two-three' }
+      MuchStub.stub(@instance, :minargs){ "default" }
+      MuchStub.stub(@instance, :minargs).with(1, 2){ "one-two" }
+      MuchStub.stub(@instance, :minargs).with(1, 2, 3){ "one-two-three" }
 
-      MuchStub.stub(@instance, :withblock){ 'default' }
+      MuchStub.stub(@instance, :withblock){ "default" }
     end
     subject{ @instance }
 
     should "allow stubbing a method that doesn't take args" do
-      assert_equal 'none', subject.noargs
+      assert_equal "none", subject.noargs
     end
 
     should "allow stubbing a method that takes args" do
-      assert_equal 'one',     subject.withargs(1)
-      assert_equal 'default', subject.withargs(2)
+      assert_equal "one",     subject.withargs(1)
+      assert_equal "default", subject.withargs(2)
     end
 
     should "allow stubbing a method that takes any args" do
-      assert_equal 'default', subject.anyargs
-      assert_equal 'default', subject.anyargs(1)
-      assert_equal 'one-two', subject.anyargs(1, 2)
+      assert_equal "default", subject.anyargs
+      assert_equal "default", subject.anyargs(1)
+      assert_equal "one-two", subject.anyargs(1, 2)
     end
 
     should "allow stubbing a method that takes a minimum number of args" do
-      assert_equal 'one-two',       subject.minargs(1, 2)
-      assert_equal 'one-two-three', subject.minargs(1, 2, 3)
-      assert_equal 'default',       subject.minargs(1, 2, 4)
-      assert_equal 'default',       subject.minargs(1, 2, 3, 4)
+      assert_equal "one-two",       subject.minargs(1, 2)
+      assert_equal "one-two-three", subject.minargs(1, 2, 3)
+      assert_equal "default",       subject.minargs(1, 2, 4)
+      assert_equal "default",       subject.minargs(1, 2, 3, 4)
     end
 
     should "allow stubbing a method that takes a block" do
-      assert_equal 'default', subject.withblock
-      assert_equal 'default', subject.withblock{ 'my-block' }
+      assert_equal "default", subject.withblock
+      assert_equal "default", subject.withblock{ "my-block" }
     end
 
     should "not allow stubbing methods with invalid arity" do
@@ -79,55 +79,54 @@ module MuchStub
 
       assert_raises{ subject.withblock(1) }
     end
-
   end
 
   class ClassTests < SystemTests
     desc "for singleton methods on a class"
     setup do
       @class = TestClass
-      MuchStub.stub(@class, :noargs){ 'default' }
-      MuchStub.stub(@class, :noargs).with{ 'none' }
+      MuchStub.stub(@class, :noargs){ "default" }
+      MuchStub.stub(@class, :noargs).with{ "none" }
 
-      MuchStub.stub(@class, :withargs){ 'default' }
-      MuchStub.stub(@class, :withargs).with(1){ 'one' }
+      MuchStub.stub(@class, :withargs){ "default" }
+      MuchStub.stub(@class, :withargs).with(1){ "one" }
 
-      MuchStub.stub(@class, :anyargs){ 'default' }
-      MuchStub.stub(@class, :anyargs).with(1, 2){ 'one-two' }
+      MuchStub.stub(@class, :anyargs){ "default" }
+      MuchStub.stub(@class, :anyargs).with(1, 2){ "one-two" }
 
-      MuchStub.stub(@class, :minargs){ 'default' }
-      MuchStub.stub(@class, :minargs).with(1, 2){ 'one-two' }
-      MuchStub.stub(@class, :minargs).with(1, 2, 3){ 'one-two-three' }
+      MuchStub.stub(@class, :minargs){ "default" }
+      MuchStub.stub(@class, :minargs).with(1, 2){ "one-two" }
+      MuchStub.stub(@class, :minargs).with(1, 2, 3){ "one-two-three" }
 
-      MuchStub.stub(@class, :withblock){ 'default' }
+      MuchStub.stub(@class, :withblock){ "default" }
     end
     subject{ @class }
 
     should "allow stubbing a method that doesn't take args" do
-      assert_equal 'none', subject.noargs
+      assert_equal "none", subject.noargs
     end
 
     should "allow stubbing a method that takes args" do
-      assert_equal 'one',     subject.withargs(1)
-      assert_equal 'default', subject.withargs(2)
+      assert_equal "one",     subject.withargs(1)
+      assert_equal "default", subject.withargs(2)
     end
 
     should "allow stubbing a method that takes any args" do
-      assert_equal 'default', subject.anyargs
-      assert_equal 'default', subject.anyargs(1)
-      assert_equal 'one-two', subject.anyargs(1, 2)
+      assert_equal "default", subject.anyargs
+      assert_equal "default", subject.anyargs(1)
+      assert_equal "one-two", subject.anyargs(1, 2)
     end
 
     should "allow stubbing a method that takes a minimum number of args" do
-      assert_equal 'one-two',       subject.minargs(1, 2)
-      assert_equal 'one-two-three', subject.minargs(1, 2, 3)
-      assert_equal 'default',       subject.minargs(1, 2, 4)
-      assert_equal 'default',       subject.minargs(1, 2, 3, 4)
+      assert_equal "one-two",       subject.minargs(1, 2)
+      assert_equal "one-two-three", subject.minargs(1, 2, 3)
+      assert_equal "default",       subject.minargs(1, 2, 4)
+      assert_equal "default",       subject.minargs(1, 2, 3, 4)
     end
 
     should "allow stubbing a method that takes a block" do
-      assert_equal 'default', subject.withblock
-      assert_equal 'default', subject.withblock{ 'my-block' }
+      assert_equal "default", subject.withblock
+      assert_equal "default", subject.withblock{ "my-block" }
     end
 
     should "not allow stubbing methods with invalid arity" do
@@ -153,55 +152,54 @@ module MuchStub
 
       assert_raises{ subject.withblock(1) }
     end
-
   end
 
   class ModuleTests < SystemTests
     desc "for singleton methods on a module"
     setup do
       @module = TestModule
-      MuchStub.stub(@module, :noargs){ 'default' }
-      MuchStub.stub(@module, :noargs).with{ 'none' }
+      MuchStub.stub(@module, :noargs){ "default" }
+      MuchStub.stub(@module, :noargs).with{ "none" }
 
-      MuchStub.stub(@module, :withargs){ 'default' }
-      MuchStub.stub(@module, :withargs).with(1){ 'one' }
+      MuchStub.stub(@module, :withargs){ "default" }
+      MuchStub.stub(@module, :withargs).with(1){ "one" }
 
-      MuchStub.stub(@module, :anyargs){ 'default' }
-      MuchStub.stub(@module, :anyargs).with(1, 2){ 'one-two' }
+      MuchStub.stub(@module, :anyargs){ "default" }
+      MuchStub.stub(@module, :anyargs).with(1, 2){ "one-two" }
 
-      MuchStub.stub(@module, :minargs){ 'default' }
-      MuchStub.stub(@module, :minargs).with(1, 2){ 'one-two' }
-      MuchStub.stub(@module, :minargs).with(1, 2, 3){ 'one-two-three' }
+      MuchStub.stub(@module, :minargs){ "default" }
+      MuchStub.stub(@module, :minargs).with(1, 2){ "one-two" }
+      MuchStub.stub(@module, :minargs).with(1, 2, 3){ "one-two-three" }
 
-      MuchStub.stub(@module, :withblock){ 'default' }
+      MuchStub.stub(@module, :withblock){ "default" }
     end
     subject{ @module }
 
     should "allow stubbing a method that doesn't take args" do
-      assert_equal 'none', subject.noargs
+      assert_equal "none", subject.noargs
     end
 
     should "allow stubbing a method that takes args" do
-      assert_equal 'one',     subject.withargs(1)
-      assert_equal 'default', subject.withargs(2)
+      assert_equal "one",     subject.withargs(1)
+      assert_equal "default", subject.withargs(2)
     end
 
     should "allow stubbing a method that takes any args" do
-      assert_equal 'default', subject.anyargs
-      assert_equal 'default', subject.anyargs(1)
-      assert_equal 'one-two', subject.anyargs(1, 2)
+      assert_equal "default", subject.anyargs
+      assert_equal "default", subject.anyargs(1)
+      assert_equal "one-two", subject.anyargs(1, 2)
     end
 
     should "allow stubbing a method that takes a minimum number of args" do
-      assert_equal 'one-two',       subject.minargs(1, 2)
-      assert_equal 'one-two-three', subject.minargs(1, 2, 3)
-      assert_equal 'default',       subject.minargs(1, 2, 4)
-      assert_equal 'default',       subject.minargs(1, 2, 3, 4)
+      assert_equal "one-two",       subject.minargs(1, 2)
+      assert_equal "one-two-three", subject.minargs(1, 2, 3)
+      assert_equal "default",       subject.minargs(1, 2, 4)
+      assert_equal "default",       subject.minargs(1, 2, 3, 4)
     end
 
     should "allow stubbing a method that takes a block" do
-      assert_equal 'default', subject.withblock
-      assert_equal 'default', subject.withblock{ 'my-block' }
+      assert_equal "default", subject.withblock
+      assert_equal "default", subject.withblock{ "my-block" }
     end
 
     should "not allow stubbing methods with invalid arity" do
@@ -227,55 +225,54 @@ module MuchStub
 
       assert_raises{ subject.withblock(1) }
     end
-
   end
 
   class ExtendedTests < SystemTests
     desc "for extended methods"
     setup do
       @class = Class.new{ extend TestMixin }
-      MuchStub.stub(@class, :noargs){ 'default' }
-      MuchStub.stub(@class, :noargs).with{ 'none' }
+      MuchStub.stub(@class, :noargs){ "default" }
+      MuchStub.stub(@class, :noargs).with{ "none" }
 
-      MuchStub.stub(@class, :withargs){ 'default' }
-      MuchStub.stub(@class, :withargs).with(1){ 'one' }
+      MuchStub.stub(@class, :withargs){ "default" }
+      MuchStub.stub(@class, :withargs).with(1){ "one" }
 
-      MuchStub.stub(@class, :anyargs){ 'default' }
-      MuchStub.stub(@class, :anyargs).with(1, 2){ 'one-two' }
+      MuchStub.stub(@class, :anyargs){ "default" }
+      MuchStub.stub(@class, :anyargs).with(1, 2){ "one-two" }
 
-      MuchStub.stub(@class, :minargs){ 'default' }
-      MuchStub.stub(@class, :minargs).with(1, 2){ 'one-two' }
-      MuchStub.stub(@class, :minargs).with(1, 2, 3){ 'one-two-three' }
+      MuchStub.stub(@class, :minargs){ "default" }
+      MuchStub.stub(@class, :minargs).with(1, 2){ "one-two" }
+      MuchStub.stub(@class, :minargs).with(1, 2, 3){ "one-two-three" }
 
-      MuchStub.stub(@class, :withblock){ 'default' }
+      MuchStub.stub(@class, :withblock){ "default" }
     end
     subject{ @class }
 
     should "allow stubbing a method that doesn't take args" do
-      assert_equal 'none', subject.noargs
+      assert_equal "none", subject.noargs
     end
 
     should "allow stubbing a method that takes args" do
-      assert_equal 'one',     subject.withargs(1)
-      assert_equal 'default', subject.withargs(2)
+      assert_equal "one",     subject.withargs(1)
+      assert_equal "default", subject.withargs(2)
     end
 
     should "allow stubbing a method that takes any args" do
-      assert_equal 'default', subject.anyargs
-      assert_equal 'default', subject.anyargs(1)
-      assert_equal 'one-two', subject.anyargs(1, 2)
+      assert_equal "default", subject.anyargs
+      assert_equal "default", subject.anyargs(1)
+      assert_equal "one-two", subject.anyargs(1, 2)
     end
 
     should "allow stubbing a method that takes a minimum number of args" do
-      assert_equal 'one-two',       subject.minargs(1, 2)
-      assert_equal 'one-two-three', subject.minargs(1, 2, 3)
-      assert_equal 'default',       subject.minargs(1, 2, 4)
-      assert_equal 'default',       subject.minargs(1, 2, 3, 4)
+      assert_equal "one-two",       subject.minargs(1, 2)
+      assert_equal "one-two-three", subject.minargs(1, 2, 3)
+      assert_equal "default",       subject.minargs(1, 2, 4)
+      assert_equal "default",       subject.minargs(1, 2, 3, 4)
     end
 
     should "allow stubbing a method that takes a block" do
-      assert_equal 'default', subject.withblock
-      assert_equal 'default', subject.withblock{ 'my-block' }
+      assert_equal "default", subject.withblock
+      assert_equal "default", subject.withblock{ "my-block" }
     end
 
     should "not allow stubbing methods with invalid arity" do
@@ -301,7 +298,6 @@ module MuchStub
 
       assert_raises{ subject.withblock(1) }
     end
-
   end
 
   class IncludedTests < SystemTests
@@ -309,48 +305,48 @@ module MuchStub
     setup do
       @class = Class.new{ include TestMixin }
       @instance = @class.new
-      MuchStub.stub(@instance, :noargs){ 'default' }
-      MuchStub.stub(@instance, :noargs).with{ 'none' }
+      MuchStub.stub(@instance, :noargs){ "default" }
+      MuchStub.stub(@instance, :noargs).with{ "none" }
 
-      MuchStub.stub(@instance, :withargs){ 'default' }
-      MuchStub.stub(@instance, :withargs).with(1){ 'one' }
+      MuchStub.stub(@instance, :withargs){ "default" }
+      MuchStub.stub(@instance, :withargs).with(1){ "one" }
 
-      MuchStub.stub(@instance, :anyargs){ 'default' }
-      MuchStub.stub(@instance, :anyargs).with(1, 2){ 'one-two' }
+      MuchStub.stub(@instance, :anyargs){ "default" }
+      MuchStub.stub(@instance, :anyargs).with(1, 2){ "one-two" }
 
-      MuchStub.stub(@instance, :minargs){ 'default' }
-      MuchStub.stub(@instance, :minargs).with(1, 2){ 'one-two' }
-      MuchStub.stub(@instance, :minargs).with(1, 2, 3){ 'one-two-three' }
+      MuchStub.stub(@instance, :minargs){ "default" }
+      MuchStub.stub(@instance, :minargs).with(1, 2){ "one-two" }
+      MuchStub.stub(@instance, :minargs).with(1, 2, 3){ "one-two-three" }
 
-      MuchStub.stub(@instance, :withblock){ 'default' }
+      MuchStub.stub(@instance, :withblock){ "default" }
     end
     subject{ @instance }
 
     should "allow stubbing a method that doesn't take args" do
-      assert_equal 'none', subject.noargs
+      assert_equal "none", subject.noargs
     end
 
     should "allow stubbing a method that takes args" do
-      assert_equal 'one',     subject.withargs(1)
-      assert_equal 'default', subject.withargs(2)
+      assert_equal "one",     subject.withargs(1)
+      assert_equal "default", subject.withargs(2)
     end
 
     should "allow stubbing a method that takes any args" do
-      assert_equal 'default', subject.anyargs
-      assert_equal 'default', subject.anyargs(1)
-      assert_equal 'one-two', subject.anyargs(1, 2)
+      assert_equal "default", subject.anyargs
+      assert_equal "default", subject.anyargs(1)
+      assert_equal "one-two", subject.anyargs(1, 2)
     end
 
     should "allow stubbing a method that takes a minimum number of args" do
-      assert_equal 'one-two',       subject.minargs(1, 2)
-      assert_equal 'one-two-three', subject.minargs(1, 2, 3)
-      assert_equal 'default',       subject.minargs(1, 2, 4)
-      assert_equal 'default',       subject.minargs(1, 2, 3, 4)
+      assert_equal "one-two",       subject.minargs(1, 2)
+      assert_equal "one-two-three", subject.minargs(1, 2, 3)
+      assert_equal "default",       subject.minargs(1, 2, 4)
+      assert_equal "default",       subject.minargs(1, 2, 3, 4)
     end
 
     should "allow stubbing a method that takes a block" do
-      assert_equal 'default', subject.withblock
-      assert_equal 'default', subject.withblock{ 'my-block' }
+      assert_equal "default", subject.withblock
+      assert_equal "default", subject.withblock{ "my-block" }
     end
 
     should "not allow stubbing methods with invalid arity" do
@@ -376,55 +372,54 @@ module MuchStub
 
       assert_raises{ subject.withblock(1) }
     end
-
   end
 
   class InheritedClassTests < SystemTests
     desc "for an inherited class method"
     setup do
       @class = Class.new(TestClass)
-      MuchStub.stub(@class, :noargs){ 'default' }
-      MuchStub.stub(@class, :noargs).with{ 'none' }
+      MuchStub.stub(@class, :noargs){ "default" }
+      MuchStub.stub(@class, :noargs).with{ "none" }
 
-      MuchStub.stub(@class, :withargs){ 'default' }
-      MuchStub.stub(@class, :withargs).with(1){ 'one' }
+      MuchStub.stub(@class, :withargs){ "default" }
+      MuchStub.stub(@class, :withargs).with(1){ "one" }
 
-      MuchStub.stub(@class, :anyargs){ 'default' }
-      MuchStub.stub(@class, :anyargs).with(1, 2){ 'one-two' }
+      MuchStub.stub(@class, :anyargs){ "default" }
+      MuchStub.stub(@class, :anyargs).with(1, 2){ "one-two" }
 
-      MuchStub.stub(@class, :minargs){ 'default' }
-      MuchStub.stub(@class, :minargs).with(1, 2){ 'one-two' }
-      MuchStub.stub(@class, :minargs).with(1, 2, 3){ 'one-two-three' }
+      MuchStub.stub(@class, :minargs){ "default" }
+      MuchStub.stub(@class, :minargs).with(1, 2){ "one-two" }
+      MuchStub.stub(@class, :minargs).with(1, 2, 3){ "one-two-three" }
 
-      MuchStub.stub(@class, :withblock){ 'default' }
+      MuchStub.stub(@class, :withblock){ "default" }
     end
     subject{ @class }
 
     should "allow stubbing a method that doesn't take args" do
-      assert_equal 'none', subject.noargs
+      assert_equal "none", subject.noargs
     end
 
     should "allow stubbing a method that takes args" do
-      assert_equal 'one',     subject.withargs(1)
-      assert_equal 'default', subject.withargs(2)
+      assert_equal "one",     subject.withargs(1)
+      assert_equal "default", subject.withargs(2)
     end
 
     should "allow stubbing a method that takes any args" do
-      assert_equal 'default', subject.anyargs
-      assert_equal 'default', subject.anyargs(1)
-      assert_equal 'one-two', subject.anyargs(1, 2)
+      assert_equal "default", subject.anyargs
+      assert_equal "default", subject.anyargs(1)
+      assert_equal "one-two", subject.anyargs(1, 2)
     end
 
     should "allow stubbing a method that takes a minimum number of args" do
-      assert_equal 'one-two',       subject.minargs(1, 2)
-      assert_equal 'one-two-three', subject.minargs(1, 2, 3)
-      assert_equal 'default',       subject.minargs(1, 2, 4)
-      assert_equal 'default',       subject.minargs(1, 2, 3, 4)
+      assert_equal "one-two",       subject.minargs(1, 2)
+      assert_equal "one-two-three", subject.minargs(1, 2, 3)
+      assert_equal "default",       subject.minargs(1, 2, 4)
+      assert_equal "default",       subject.minargs(1, 2, 3, 4)
     end
 
     should "allow stubbing a method that takes a block" do
-      assert_equal 'default', subject.withblock
-      assert_equal 'default', subject.withblock{ 'my-block' }
+      assert_equal "default", subject.withblock
+      assert_equal "default", subject.withblock{ "my-block" }
     end
 
     should "not allow stubbing methods with invalid arity" do
@@ -450,7 +445,6 @@ module MuchStub
 
       assert_raises{ subject.withblock(1) }
     end
-
   end
 
   class InheritedInstanceTests < SystemTests
@@ -458,48 +452,48 @@ module MuchStub
     setup do
       @class = Class.new(TestClass)
       @instance = @class.new
-      MuchStub.stub(@instance, :noargs){ 'default' }
-      MuchStub.stub(@instance, :noargs).with{ 'none' }
+      MuchStub.stub(@instance, :noargs){ "default" }
+      MuchStub.stub(@instance, :noargs).with{ "none" }
 
-      MuchStub.stub(@instance, :withargs){ 'default' }
-      MuchStub.stub(@instance, :withargs).with(1){ 'one' }
+      MuchStub.stub(@instance, :withargs){ "default" }
+      MuchStub.stub(@instance, :withargs).with(1){ "one" }
 
-      MuchStub.stub(@instance, :anyargs){ 'default' }
-      MuchStub.stub(@instance, :anyargs).with(1, 2){ 'one-two' }
+      MuchStub.stub(@instance, :anyargs){ "default" }
+      MuchStub.stub(@instance, :anyargs).with(1, 2){ "one-two" }
 
-      MuchStub.stub(@instance, :minargs){ 'default' }
-      MuchStub.stub(@instance, :minargs).with(1, 2){ 'one-two' }
-      MuchStub.stub(@instance, :minargs).with(1, 2, 3){ 'one-two-three' }
+      MuchStub.stub(@instance, :minargs){ "default" }
+      MuchStub.stub(@instance, :minargs).with(1, 2){ "one-two" }
+      MuchStub.stub(@instance, :minargs).with(1, 2, 3){ "one-two-three" }
 
-      MuchStub.stub(@instance, :withblock){ 'default' }
+      MuchStub.stub(@instance, :withblock){ "default" }
     end
     subject{ @instance }
 
     should "allow stubbing a method that doesn't take args" do
-      assert_equal 'none', subject.noargs
+      assert_equal "none", subject.noargs
     end
 
     should "allow stubbing a method that takes args" do
-      assert_equal 'one',     subject.withargs(1)
-      assert_equal 'default', subject.withargs(2)
+      assert_equal "one",     subject.withargs(1)
+      assert_equal "default", subject.withargs(2)
     end
 
     should "allow stubbing a method that takes any args" do
-      assert_equal 'default', subject.anyargs
-      assert_equal 'default', subject.anyargs(1)
-      assert_equal 'one-two', subject.anyargs(1, 2)
+      assert_equal "default", subject.anyargs
+      assert_equal "default", subject.anyargs(1)
+      assert_equal "one-two", subject.anyargs(1, 2)
     end
 
     should "allow stubbing a method that takes a minimum number of args" do
-      assert_equal 'one-two',       subject.minargs(1, 2)
-      assert_equal 'one-two-three', subject.minargs(1, 2, 3)
-      assert_equal 'default',       subject.minargs(1, 2, 4)
-      assert_equal 'default',       subject.minargs(1, 2, 3, 4)
+      assert_equal "one-two",       subject.minargs(1, 2)
+      assert_equal "one-two-three", subject.minargs(1, 2, 3)
+      assert_equal "default",       subject.minargs(1, 2, 4)
+      assert_equal "default",       subject.minargs(1, 2, 3, 4)
     end
 
     should "allow stubbing a method that takes a block" do
-      assert_equal 'default', subject.withblock
-      assert_equal 'default', subject.withblock{ 'my-block' }
+      assert_equal "default", subject.withblock
+      assert_equal "default", subject.withblock{ "my-block" }
     end
 
     should "not allow stubbing methods with invalid arity" do
@@ -525,55 +519,54 @@ module MuchStub
 
       assert_raises{ subject.withblock(1) }
     end
-
   end
 
   class DelegateClassTests < SystemTests
     desc "a class that delegates another object"
     setup do
       @class = DelegateClass
-      MuchStub.stub(@class, :noargs){ 'default' }
-      MuchStub.stub(@class, :noargs).with{ 'none' }
+      MuchStub.stub(@class, :noargs){ "default" }
+      MuchStub.stub(@class, :noargs).with{ "none" }
 
-      MuchStub.stub(@class, :withargs){ 'default' }
-      MuchStub.stub(@class, :withargs).with(1){ 'one' }
+      MuchStub.stub(@class, :withargs){ "default" }
+      MuchStub.stub(@class, :withargs).with(1){ "one" }
 
-      MuchStub.stub(@class, :anyargs){ 'default' }
-      MuchStub.stub(@class, :anyargs).with(1, 2){ 'one-two' }
+      MuchStub.stub(@class, :anyargs){ "default" }
+      MuchStub.stub(@class, :anyargs).with(1, 2){ "one-two" }
 
-      MuchStub.stub(@class, :minargs){ 'default' }
-      MuchStub.stub(@class, :minargs).with(1, 2){ 'one-two' }
-      MuchStub.stub(@class, :minargs).with(1, 2, 3){ 'one-two-three' }
+      MuchStub.stub(@class, :minargs){ "default" }
+      MuchStub.stub(@class, :minargs).with(1, 2){ "one-two" }
+      MuchStub.stub(@class, :minargs).with(1, 2, 3){ "one-two-three" }
 
-      MuchStub.stub(@class, :withblock){ 'default' }
+      MuchStub.stub(@class, :withblock){ "default" }
     end
     subject{ @class }
 
     should "allow stubbing a method that doesn't take args" do
-      assert_equal 'none', subject.noargs
+      assert_equal "none", subject.noargs
     end
 
     should "allow stubbing a method that takes args" do
-      assert_equal 'one',     subject.withargs(1)
-      assert_equal 'default', subject.withargs(2)
+      assert_equal "one",     subject.withargs(1)
+      assert_equal "default", subject.withargs(2)
     end
 
     should "allow stubbing a method that takes any args" do
-      assert_equal 'default', subject.anyargs
-      assert_equal 'default', subject.anyargs(1)
-      assert_equal 'one-two', subject.anyargs(1, 2)
+      assert_equal "default", subject.anyargs
+      assert_equal "default", subject.anyargs(1)
+      assert_equal "one-two", subject.anyargs(1, 2)
     end
 
     should "allow stubbing a method that takes a minimum number of args" do
-      assert_equal 'one-two',       subject.minargs(1, 2)
-      assert_equal 'one-two-three', subject.minargs(1, 2, 3)
-      assert_equal 'default',       subject.minargs(1, 2, 4)
-      assert_equal 'default',       subject.minargs(1, 2, 3, 4)
+      assert_equal "one-two",       subject.minargs(1, 2)
+      assert_equal "one-two-three", subject.minargs(1, 2, 3)
+      assert_equal "default",       subject.minargs(1, 2, 4)
+      assert_equal "default",       subject.minargs(1, 2, 3, 4)
     end
 
     should "allow stubbing a method that takes a block" do
-      assert_equal 'default', subject.withblock
-      assert_equal 'default', subject.withblock{ 'my-block' }
+      assert_equal "default", subject.withblock
+      assert_equal "default", subject.withblock{ "my-block" }
     end
 
     should "allow stubbing methods with invalid arity" do
@@ -599,55 +592,54 @@ module MuchStub
 
       assert_nothing_raised{ subject.withblock(1) }
     end
-
   end
 
   class DelegateInstanceTests < SystemTests
     desc "an instance that delegates another object"
     setup do
       @instance = DelegateClass.new
-      MuchStub.stub(@instance, :noargs){ 'default' }
-      MuchStub.stub(@instance, :noargs).with{ 'none' }
+      MuchStub.stub(@instance, :noargs){ "default" }
+      MuchStub.stub(@instance, :noargs).with{ "none" }
 
-      MuchStub.stub(@instance, :withargs){ 'default' }
-      MuchStub.stub(@instance, :withargs).with(1){ 'one' }
+      MuchStub.stub(@instance, :withargs){ "default" }
+      MuchStub.stub(@instance, :withargs).with(1){ "one" }
 
-      MuchStub.stub(@instance, :anyargs){ 'default' }
-      MuchStub.stub(@instance, :anyargs).with(1, 2){ 'one-two' }
+      MuchStub.stub(@instance, :anyargs){ "default" }
+      MuchStub.stub(@instance, :anyargs).with(1, 2){ "one-two" }
 
-      MuchStub.stub(@instance, :minargs){ 'default' }
-      MuchStub.stub(@instance, :minargs).with(1, 2){ 'one-two' }
-      MuchStub.stub(@instance, :minargs).with(1, 2, 3){ 'one-two-three' }
+      MuchStub.stub(@instance, :minargs){ "default" }
+      MuchStub.stub(@instance, :minargs).with(1, 2){ "one-two" }
+      MuchStub.stub(@instance, :minargs).with(1, 2, 3){ "one-two-three" }
 
-      MuchStub.stub(@instance, :withblock){ 'default' }
+      MuchStub.stub(@instance, :withblock){ "default" }
     end
     subject{ @instance }
 
     should "allow stubbing a method that doesn't take args" do
-      assert_equal 'none', subject.noargs
+      assert_equal "none", subject.noargs
     end
 
     should "allow stubbing a method that takes args" do
-      assert_equal 'one',     subject.withargs(1)
-      assert_equal 'default', subject.withargs(2)
+      assert_equal "one",     subject.withargs(1)
+      assert_equal "default", subject.withargs(2)
     end
 
     should "allow stubbing a method that takes any args" do
-      assert_equal 'default', subject.anyargs
-      assert_equal 'default', subject.anyargs(1)
-      assert_equal 'one-two', subject.anyargs(1, 2)
+      assert_equal "default", subject.anyargs
+      assert_equal "default", subject.anyargs(1)
+      assert_equal "one-two", subject.anyargs(1, 2)
     end
 
     should "allow stubbing a method that takes a minimum number of args" do
-      assert_equal 'one-two',       subject.minargs(1, 2)
-      assert_equal 'one-two-three', subject.minargs(1, 2, 3)
-      assert_equal 'default',       subject.minargs(1, 2, 4)
-      assert_equal 'default',       subject.minargs(1, 2, 3, 4)
+      assert_equal "one-two",       subject.minargs(1, 2)
+      assert_equal "one-two-three", subject.minargs(1, 2, 3)
+      assert_equal "default",       subject.minargs(1, 2, 4)
+      assert_equal "default",       subject.minargs(1, 2, 3, 4)
     end
 
     should "allow stubbing a method that takes a block" do
-      assert_equal 'default', subject.withblock
-      assert_equal 'default', subject.withblock{ 'my-block' }
+      assert_equal "default", subject.withblock
+      assert_equal "default", subject.withblock{ "my-block" }
     end
 
     should "allow stubbing methods with invalid arity" do
@@ -673,7 +665,6 @@ module MuchStub
 
       assert_nothing_raised{ subject.withblock(1) }
     end
-
   end
 
   class ParentAndChildClassTests < SystemTests
@@ -682,19 +673,17 @@ module MuchStub
       @parent_class = Class.new
       @child_class = Class.new(@parent_class)
 
-      MuchStub.stub(@parent_class, :new){ 'parent' }
-      MuchStub.stub(@child_class, :new){ 'child' }
+      MuchStub.stub(@parent_class, :new){ "parent" }
+      MuchStub.stub(@child_class, :new){ "child" }
     end
 
     should "allow stubbing the methods individually" do
-      assert_equal 'parent', @parent_class.new
-      assert_equal 'child', @child_class.new
+      assert_equal "parent", @parent_class.new
+      assert_equal "child", @child_class.new
     end
-
   end
 
   class TestClass
-
     def self.noargs; end
     def self.withargs(a); end
     def self.anyargs(*args); end
@@ -706,27 +695,22 @@ module MuchStub
     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
-
   end
 
   module TestMixin
-
     def noargs; end
     def withargs(a); end
     def anyargs(*args); end
     def minargs(a, b, *args); end
     def withblock(&block); end
-
   end
 
   class DelegateClass
@@ -750,5 +734,4 @@ module MuchStub
       @delegate.respond_to?(name) ? @delegate.send(name, *args, &block) : super
     end
   end
-
 end