much-stub 0.1.5 → 0.1.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f4801d3a180d37bd01d02a52d1c524d38f432e4bb287a87d1e7753825efb180a
-  data.tar.gz: 422762b6602a2f05725fd61561e745bced7430b3e459ee7198a670ce86e922bd
+  metadata.gz: bc032b1684e0734a374eb6b4a5df50d2980cc9a7cbf7e1149af37e1a4937a5f9
+  data.tar.gz: 35b88afbbc8c997dacc497e71b5469a4a5062e59259385533b63387a2865180e
 SHA512:
-  metadata.gz: 3eb227fd853591c057e7869a6331cbd36ba0a308eb4a0a3a32313ea779ec740f89e32a297160fb40bd3400222af83693830c260df3c461d79d40e72d45d1df24
-  data.tar.gz: 8b7ab33cb886b60f4242bdaa6a1bcf9a5d1666c2b37a335eb01ab032d59841ff648b5bed5ffded02dfd40f2fe4451e1649ae45488a133c6773ef00670ae760d7
+  metadata.gz: 615eaeb52480305c353204c4a1a27653a84d4f855f323356bcd09f55baf421998ccd35ad8b9c80ef1d431dd700db754be51ed05f7734644e452b2ebe16d3e828
+  data.tar.gz: 4f7f4fc3666baca6bed52dec567fccca5fa6248946182c84d1a3325f2e7a8eaab88ffad4287b7c7a8f242e6b523c63f0ac60605c42ed16ae6ea8a331a19be09d

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 @@
+3.0.2

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,5 +1,9 @@
+# frozen_string_literal: true
+
 source "https://rubygems.org"
 
+ruby ">= 2.5"
+
 gemspec
 
-gem "pry", "~> 0.12.2"
+gem "pry"

data/README.md

@@ -16,15 +16,16 @@ Note: this was originally implemented in and extracted from [Assert](https://git
 ```ruby
 # Given this object/API
 
-my_class = Class.new do
-  def my_method
-    "my-method"
+my_class =
+  Class.new do
+    def my_method
+      "my-method"
+    end
+
+    def my_value(value)
+      value
+    end
   end
-
-  def my_value(value)
-    value
-  end
-end
 my_object = my_class.new
 
 my_object.my_method
@@ -95,15 +96,16 @@ my_object.my_value(456)
 ```ruby
 # Given this object/API
 
-my_class = Class.new do
-  def basic_method(value)
-    value
-  end
+my_class =
+  Class.new do
+    def basic_method(value)
+      value
+    end
 
-  def iterator_method(items, &block)
-    items.each(&block)
+    def iterator_method(items, &block)
+      items.each(&block)
+    end
   end
-end
 my_object = my_class.new
 
 # Store method call arguments/blocks for spying.
@@ -189,11 +191,12 @@ basic_method_calls.first.args
 ```ruby
 # Given this object/API ...
 
-my_class = Class.new do
-  def build_thing(thing_value);
-    Thing.new(value)
+my_class =
+  Class.new do
+    def build_thing(thing_value);
+      Thing.new(value)
+    end
   end
-end
 my_object = my_class.new
 
 # ... and this Test Double.
@@ -223,11 +226,12 @@ Use the `.tap` method to spy on method calls while preserving the original metho
 ```ruby
 # Given this object/API
 
-my_class = Class.new do
-  def basic_method(value)
-    value.to_s
+my_class =
+  Class.new do
+    def basic_method(value)
+      value.to_s
+    end
   end
-end
 my_object = my_class.new
 
 # Normal stubs override the original behavior and return value...
@@ -275,11 +279,12 @@ class Thing
   end
 end
 
-my_class = Class.new do
-  def thing(value)
-    Thing.new(value)
+my_class =
+  Class.new do
+    def thing(value)
+      Thing.new(value)
+    end
   end
-end
 my_object = my_class.new
 
 # Use `MuchStub.tap` to stub any thing instances created by `my_object.thing`
@@ -306,16 +311,16 @@ Use the `.spy` method to spy on method calls. This is especially helpful for spy
 ```ruby
 # Given this object/API
 
-myclass = Class.new do
-  def one; self; end
-  def two(val); self; end
-  def three; self; end
-  def ready?; false; end
-end
+myclass =
+  Class.new do
+    def one; self; end
+    def two(val); self; end
+    def three; self; end
+    def ready?; false; end
+  end
 myobj = myclass.new
 
-spy =
-  MuchStub.spy(myobj :one, :two, :three, ready?: true)
+spy = MuchStub.spy(myobj :one, :two, :three, ready?: true)
 
 assert_equal spy, myobj.one
 assert_equal spy, myobj.two("a")

data/lib/much-stub/call.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module MuchStub
   class Call
     attr_reader :pargs, :kargs, :block

data/lib/much-stub/call_spy.rb

@@ -1,17 +1,19 @@
+# frozen_string_literal: true
+
 require "much-stub/call"
 
 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
@@ -20,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?(*)
@@ -44,7 +46,7 @@ module MuchStub
     end
 
     def inspect
-      "#<MuchStub::CallSpy:#{"0x0%x" % (self.__id__ << 1)}>"
+      "#<MuchStub::CallSpy:#{"0x0%x" % (__id__ << 1)}>"
     end
 
     private
@@ -54,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)
@@ -77,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
@@ -87,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,3 +1,5 @@
+# frozen_string_literal: true
+
 module MuchStub
-  VERSION = "0.1.5"
+  VERSION = "0.1.9"
 end

data/lib/much-stub.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "much-stub/version"
 
 require "much-stub/call"
@@ -13,66 +15,70 @@ 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)
+  def self.stub_send(obj, meth, *pargs, **kargs, &block)
     orig_caller = caller_locations
-    stub = self.stubs.fetch(MuchStub::Stub.key(obj, meth)) do
-      raise NotStubbedError, "`#{meth}` not stubbed.", orig_caller.map(&:to_s)
-    end
-    stub.call_method(args, &block)
+    stub =
+      stubs.fetch(MuchStub::Stub.key(obj, meth)) do
+        raise NotStubbedError, "`#{meth}` not stubbed.", orig_caller.map(&:to_s)
+      end
+    stub.call_method(*pargs, **kargs, &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 |*pargs, **kargs, &block|
+      stub_send(obj, meth, *pargs, **kargs, &block).tap do |value|
+        tap_block&.call(value, *pargs, **kargs, &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, *pargs, **kargs, &block|
+      on_call_block&.call(value, MuchStub::Call.new(*pargs, **kargs, &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|
-          spy.__send__(meth, *args, &block)
-        }
+        stub(obj, meth) do |*pargs, **kargs, &block|
+          spy.__send__(meth, *pargs, **kargs, &block)
+        end
       end
     end
   end
@@ -102,35 +108,41 @@ module MuchStub
       @do = block || @do
     end
 
-    def call_method(args, &block)
-      @method.call(*args, &block)
+    def call_method(*pargs, **kargs, &block)
+      @method.call(*pargs, **kargs, &block)
     end
 
-    def call(args, orig_caller = nil, &block)
+    def call(*pargs, orig_caller: nil, **kargs, &block)
       orig_caller ||= caller_locations
+      args = combined_args(pargs, kargs)
       unless MuchStub.arity_matches?(@method, args)
         raise(
           StubArityError.new(
             @method,
             args,
             method_name: @method_name,
-            backtrace: orig_caller))
+            backtrace: orig_caller,
+          ),
+        )
       end
-      lookup(args, orig_caller).call(*args, &block)
+      lookup(pargs, kargs, orig_caller).call(*pargs, **kargs, &block)
     rescue NotStubbedError
       @lookup.rehash
-      lookup(args, orig_caller).call(*args, &block)
+      lookup(pargs, kargs, orig_caller).call(*pargs, **kargs, &block)
     end
 
-    def with(*args, &block)
+    def with(*pargs, **kargs, &block)
       orig_caller = caller_locations
+      args = combined_args(pargs, kargs)
       unless MuchStub.arity_matches?(@method, args)
         raise(
           StubArityError.new(
             @method,
             args,
             method_name: @method_name,
-            backtrace: orig_caller))
+            backtrace: orig_caller,
+          ),
+        )
       end
       @lookup[args] = block
       self
@@ -138,12 +150,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
+        ->(*pargs, **kargs, &block){
+          on_call_block&.call(MuchStub::Call.new(*pargs, **kargs, &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
@@ -157,7 +169,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
@@ -169,7 +181,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)) ||
@@ -180,33 +192,39 @@ 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)
 
       MuchStub.instance_variable_set(@ivar_name, self)
       @metaclass.class_eval <<-stub_method
-        def #{@method_name}(*args, &block)
-          MuchStub.instance_variable_get("#{@ivar_name}").call(args, caller_locations, &block)
+        def #{@method_name}(*pargs, **kargs, &block)
+          MuchStub
+            .instance_variable_get("#{@ivar_name}")
+            .call(*pargs, orig_caller: caller_locations, **kargs, &block)
         end
       stub_method
     end
 
-    def lookup(args, orig_caller)
-      @lookup.fetch(args) {
-        self.do || begin
+    def lookup(pargs, kargs, orig_caller)
+      args = combined_args(pargs, kargs)
+      @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
@@ -216,6 +234,10 @@ module MuchStub
     def inspect_call(args)
       "`#{@method_name}(#{args.map(&:inspect).join(",")})`"
     end
+
+    def combined_args(pargs, kargs)
+      [*pargs, (kargs.empty? ? nil : kargs)].compact
+    end
   end
 
   StubError       = Class.new(ArgumentError)
@@ -242,9 +264,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
@@ -252,13 +277,11 @@ module MuchStub
     def self.new(object, method_name)
       arity = get_arity(object, method_name)
       params = build_params_from_arity(arity)
-      params << "*args" if arity < 0
+      params << "*pargs, **kargs" if arity < 0
       params << "&block"
       params.join(", ")
     end
 
-    private
-
     def self.get_arity(object, method_name)
       object.method(method_name).arity
     rescue NameError

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.required_ruby_version = ">= 2.5"
 
-  gem.add_development_dependency("assert", ["~> 2.18.2"])
+  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