much-stub 0.1.2 → 0.1.7

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,125 @@
+# 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(&: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)
+      equal?(other)
+    end
+
+    def ===(other)
+      equal?(other)
+    end
+
+    def eql?(other)
+      equal?(other)
+    end
+
+    def equal?(other)
+      __id__ == other.__id__
+    end
+
+    def hash
+      __id__
+    end
+
+    def respond_to?(*)
+      true
+    end
+
+    def inspect
+      "#<MuchStub::CallSpy:#{"0x0%x" % (__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) do |acc, (source, replacement)|
+        acc.gsub(source, replacement)
+      end
+    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 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
+      elsif (match = name.match(/(\w+)(_last_called_with)\z/))
+        call_spy_define_query_method(match) do |method_name|
+          __send__("#{method_name}_calls").last
+        end
+      elsif (match = name.match(/(\w+)(_called_with)\z/))
+        call_spy_define_query_method(match) do |method_name|
+          __send__("#{method_name}_last_called_with")
+        end
+      elsif (match = name.match(/(\w+)(_call_count)\z/))
+        call_spy_define_query_method(match) do |method_name|
+          __send__("#{method_name}_calls").size
+        end
+      elsif (match = name.match(/(\w+)(_called\?)\z/))
+        call_spy_define_query_method(match) do |method_name|
+          __send__("#{method_name}_call_count") > 0
+        end
+      else
+        call_spy_define_spied_method(name)
+      end
+      __send__(name, *args, &block)
+    end
+  end
+end

data/lib/much-stub/version.rb

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

data/much-stub.gemspec

@@ -1,23 +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.add_development_dependency("assert", ["~> 2.18.0"])
+  gem.required_ruby_version = "~> 2.5"
 
+  gem.add_development_dependency("assert",           ["~> 2.19.2"])
+  gem.add_development_dependency("much-style-guide", ["~> 0.6.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
 
@@ -12,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/support/factory.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "assert/factory"
 
 module Factory

data/test/system/much-stub_tests.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "assert"
 require "much-stub"
 
@@ -55,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
@@ -128,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
@@ -201,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
@@ -274,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
@@ -348,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
@@ -421,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
@@ -495,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
@@ -568,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
@@ -641,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
@@ -682,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
 
@@ -724,7 +762,7 @@ module MuchStub
       @delegate = TestClass.new
     end
 
-    def respond_to?(*args)
+    def respond_to_missing?(*args)
       @delegate.respond_to?(*args) || super
     end