much-stub 0.1.4 → 0.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 21883570fda48199a217f7489b6c45f6d3c2e1d1cb5aa872847e154033754771
-  data.tar.gz: bf63e826137aa1d315d48823c7a11787a09be559b16abc600a168edc19ff9068
+  metadata.gz: c37bcf3b2a355483515be9eabd74c93bd93ccf5f503180409f86d18a183f6f8a
+  data.tar.gz: 20cab69d294b44212ccd23eb068ae17e2458576153e817c30dac08206c294c47
 SHA512:
-  metadata.gz: 7f6c8c294b7f7d006b3c88a3890d24e3ff913110caa11b70642d7ba246449dd3dcb20de0df46e939d90a9b917f0c509144c260fdbfc689f6a89be1f9fb5b942f
-  data.tar.gz: 6a7c16b6b19625ad5b84df6d5413119a921f81425278f5f3b8c0b579895c9a22e8de58da349e56684412d93a74f450ba6e7ed2b53f06ad9185f9cf8ee31ec1a5
+  metadata.gz: 929d09b4df2e8b85496b4a47fe67a23dde700ee751b7fa3d1b074a09db185f01ad3ff54e16a7935cd1db75fc4af58fdb9ff3482fe81d40fcfcca421ae515e265
+  data.tar.gz: dfbfd75bc0edc084c45eee9c62926c7c2baaec32cb28f40d670a6296e1b21c7348ee4f1d6926d02b03a63223e1369b2d0907735c2b8849805862404afffd256f

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,16 +56,14 @@ module MuchStub
     end
 
     def call_spy_return_value_proc(method_name)
-      value = @call_spy_return_values[method_name]
-      return value if value.respond_to?(:call)
-
-      ::Proc.new { value.nil? ? self : 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,3 +1,5 @@
+# frozen_string_literal: true
+
 module MuchStub
-  VERSION = "0.1.4"
+  VERSION = "0.1.8"
 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)
     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 =
+      stubs.fetch(MuchStub::Stub.key(obj, meth)) do
+        raise NotStubbedError, "`#{meth}` not stubbed.", orig_caller.map(&:to_s)
+      end
     stub.call_method(args, &block)
   end
 
   def self.tap(obj, meth, &tap_block)
-    self.stub(obj, meth) { |*args, &block|
-      self.stub_send(obj, meth, *args, &block).tap { |value|
-        tap_block.call(value, *args, &block) if tap_block
-      }
-    }
+    stub(obj, meth) do |*args, &block|
+      stub_send(obj, meth, *args, &block).tap do |value|
+        tap_block&.call(value, *args, &block)
+      end
+    end
   end
 
   def self.tap_on_call(obj, meth, &on_call_block)
-    self.tap(obj, meth) { |value, *args, &block|
-      on_call_block.call(value, MuchStub::Call.new(*args, &block)) if on_call_block
-    }
+    tap(obj, meth) do |value, *args, &block|
+      on_call_block&.call(value, MuchStub::Call.new(*args, &block))
+    end
   end
 
   def self.spy(obj, *meths, **return_values)
     MuchStub::CallSpy.new(**return_values).call_spy_tap do |spy|
       meths.each do |meth|
-        self.stub(obj, meth) { |*args, &block|
+        stub(obj, meth) do |*args, &block|
           spy.__send__(meth, *args, &block)
-        }
+        end
       end
     end
   end
@@ -114,7 +120,9 @@ module MuchStub
             @method,
             args,
             method_name: @method_name,
-            backtrace: orig_caller))
+            backtrace: orig_caller,
+          ),
+        )
       end
       lookup(args, orig_caller).call(*args, &block)
     rescue NotStubbedError
@@ -130,7 +138,9 @@ module MuchStub
             @method,
             args,
             method_name: @method_name,
-            backtrace: orig_caller))
+            backtrace: orig_caller,
+          ),
+        )
       end
       @lookup[args] = block
       self
@@ -138,12 +148,12 @@ module MuchStub
 
     def on_call(&on_call_block)
       stub_block =
-        ->(*args, &block) {
-          on_call_block.call(MuchStub::Call.new(*args, &block)) if on_call_block
+        ->(*args, &block){
+          on_call_block&.call(MuchStub::Call.new(*args, &block))
         }
       if @lookup.empty?
         @do = stub_block
-      elsif @lookup.has_value?(nil)
+      elsif @lookup.value?(nil)
         @lookup.transform_values!{ |value| value.nil? ? stub_block : value }
       end
       self
@@ -157,7 +167,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 +179,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,7 +190,8 @@ module MuchStub
         method
       end
 
-      if !local_object_methods.include?(@name) # already stubbed
+      # already stubbed
+      unless local_object_methods.include?(@name)
         @metaclass.send(:alias_method, @name, @method_name)
       end
       @method = object.method(@name)
@@ -194,19 +205,21 @@ module MuchStub
     end
 
     def lookup(args, orig_caller)
-      @lookup.fetch(args) {
-        self.do || begin
+      @lookup.fetch(args) do
+        self.do ||
+        begin
           msg = "#{inspect_call(args)} not stubbed."
           inspect_lookup_stubs.tap do |stubs|
-            msg += "\nStubs:\n#{stubs}" if !stubs.empty?
+            msg += "\nStubs:\n#{stubs}" unless stubs.empty?
           end
           raise NotStubbedError, msg, orig_caller.map(&:to_s)
         end
-      } ||
-        raise(
-          StubError,
-          "#{inspect_call(args)} stubbed with no block.",
-          orig_caller.map(&:to_s))
+      end ||
+      raise(
+        StubError,
+        "#{inspect_call(args)} stubbed with no block.",
+        orig_caller.map(&:to_s),
+      )
     end
 
     def inspect_lookup_stubs
@@ -242,9 +255,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
@@ -257,8 +273,6 @@ module MuchStub
       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