much-stub 0.1.6 → 0.1.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a6dc9e4397c7c270a2678eac9f4761adb80bdd842e6708417844855639c6acfa
-  data.tar.gz: 57f89b55ddaf3b17a2444f7bbd40d2e8f9b1ad3046d1634021412f8847df605b
+  metadata.gz: 4887423991f0a75b904ee6509aba48b42fc38e29917a273f15d63a839b37447f
+  data.tar.gz: 2cb8b33d23ed1b1ecd392edd48ecf39a3e100dfbb717e8f8be9a046882b06904
 SHA512:
-  metadata.gz: b57f84be1092bba24dfd51ace398e8116941a16e17f8698436158309305672e55076b46bb4b5695763c97530f7cbfce6f974de6b331432336d7b0aad8a2ecfe0
-  data.tar.gz: 4705afaee215d93ed0a998949dd70dd2d13f03aa5fac9a31093940be16799ad43b2878df7870a046b79a1a4e2c9625bb0f5195896c371c24728600445c18c55a
+  metadata.gz: 1ba31f8668fbff8601a7ff632067c8e67a5b071fce5df440cf29231b569abca9b98f88c1c2c1578fde4527249d4f7e156be1c1c2f249cc2a659e25aed1cb14a3
+  data.tar.gz: fac22cf5adabf21a7ea87032cd3b8ed6337ad57dacca019a30053798248b265a2e06935863f81a09f729687b265c38a4c976cfa01c6b4a358a5f73e312cb1332

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

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_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.10"
 end

data/lib/much-stub.rb

@@ -15,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
@@ -104,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
@@ -140,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
@@ -159,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
@@ -171,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)) ||
@@ -182,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
@@ -218,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)
@@ -244,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
@@ -254,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.19.0"])
+  gem.add_development_dependency("assert",           ["~> 2.19.7"])
+  gem.add_development_dependency("much-style-guide", ["~> 0.6.7"])
 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