much-stub 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 405abaae599baf274c0eea900413f3c534c3acf1a19b4a83a356f5c61640025b
-  data.tar.gz: e68b22427ea8c78b87023576611a94c750a9d4ed75989cc72b7cdc96a56ebf2d
+  metadata.gz: 948b3a6fa21e50a2a221b167fe768a5d65c7a61c135622fe6ced882a5e406b03
+  data.tar.gz: 700d700fab285da4620cb4fbd3b521a58a9ffeaf8d50afdcc96780810091e301
 SHA512:
-  metadata.gz: d1cafda498eceb26c4d41a4b4867c0376dc36d34149454350e3ac4ef8a04623ee747a6d28639e417cac93eeb1f4950c1fda696153be860c61e9fef8be8f36a3e
-  data.tar.gz: 416559df2f95b8faa18fac713e924e5af8ac128b2b385a91623f32939396488f9f2a0ecef01649c3099b076e385270cbae2f5f79a84e0e26d54c689c193e7e7e
+  metadata.gz: fecb7b76d76bc9ff338461c7ec6a48ac3bf1833bd77f4f248c9d4a145fa0b0177b3ce9d99d01add632266d7f9c5731441f0ad553f14775e7cf704aaffc80099a
+  data.tar.gz: 55308114a2f7aac2294ba44aac2adf84152cc2213a40a9ff0118b3fe2e8d43738cbc617fb19855c63515e915bc46754fc915d86b568d7a9c97356fb619420156

data/Gemfile

@@ -2,4 +2,4 @@ source "https://rubygems.org"
 
 gemspec
 
-gem 'pry', "~> 0.9.0"
+gem "pry", "~> 0.12.2"

data/README.md

@@ -16,69 +16,253 @@ Note: this was originally implemented in and extracted from [Assert](https://git
 ```ruby
 # Given this object/API
 
-myclass = Class.new do
-  def mymeth; 'meth'; end
-  def myval(val); val; end
+my_class = Class.new do
+  def my_method
+    "my-method"
+  end
+
+  def my_value(value)
+    value
+  end
 end
-myobj = myclass.new
+my_object = my_class.new
 
-myobj.mymeth
-  # => 'meth'
-myobj.myval(123)
+my_object.my_method
+  # => "my-method"
+my_object.my_value(123)
   # => 123
-myobj.myval(456)
+my_object.my_value(456)
   # => 456
 
-# Create a new stub for the :mymeth method
+# Create a new stub for the :my_method method
 
-MuchStub.(myobj, :mymeth)
-myobj.mymeth
-  # => StubError: `mymeth` not stubbed.
-MuchStub.(myobj, :mymeth){ 'stub-meth' }
-myobj.mymeth
-  # => 'stub-meth'
-myobj.mymeth(123)
+MuchStub.(my_object, :my_method)
+my_object.my_method
+  # => StubError: `my_method` not stubbed.
+MuchStub.(my_object, :my_method){ "stubbed-method" }
+my_object.my_method
+  # => "stubbed-method"
+my_object.my_method(123)
   # => StubError: arity mismatch
-MuchStub.(myobj, :mymeth).with(123){ 'stub-meth' }
+MuchStub.(my_object, :my_method).with(123){ "stubbed-method" }
   # => StubError: arity mismatch
-MuchStub.stub_send(myobj, :mymeth) # call to the original method post-stub
-  # => 'meth'
 
-# Create a new stub for the :myval method
+# Call the original method after it has been stubbed.
+
+MuchStub.stub_send(my_object, :my_method)
+  # => "my-method"
 
-MuchStub.(myobj, :myval){ 'stub-meth' }
+# Create a new stub for the :my_value method
+
+MuchStub.(my_object, :my_value){ "stubbed-method" }
   # => StubError: arity mismatch
-MuchStub.(myobj, :myval).with(123){ |val| val.to_s }
-myobj.myval
+MuchStub.(my_object, :my_value).with(123){ |val| val.to_s }
+my_object.my_value
   # => StubError: arity mismatch
-myobj.myval(123)
-  # => '123'
-myobj.myval(456)
-  # => StubError: `myval(456)` not stubbed.
+my_object.my_value(123)
+  # => "123"
+my_object.my_value(456)
+  # => StubError: `my_value(456)` not stubbed.
 
-# Call to the original method post-stub
+# Call the original method after it has been stubbed.
 
-MuchStub.stub_send(myobj, :myval, 123)
+MuchStub.stub_send(my_object, :my_value, 123)
   # => 123
-MuchStub.stub_send(myobj, :myval, 456)
+MuchStub.stub_send(my_object, :my_value, 456)
   # => 456
 
 # Unstub individual stubs
 
-MuchStub.unstub(myobj, :mymeth)
-MuchStub.unstub(myobj, :myval)
+MuchStub.unstub(my_object, :my_method)
+MuchStub.unstub(my_object, :my_value)
 
 # OR blanket unstub all stubs
 
 MuchStub.unstub!
 
-# Original API is preserved after unstubbing
+# The original API/behavior is preserved after unstubbing
 
-myobj.mymeth
-  # => 'meth'
-myobj.myval(123)
+my_object.my_method
+  # => "my-method"
+my_object.my_value(123)
   # => 123
-myobj.myval(456)
+my_object.my_value(456)
+  # => 456
+```
+
+### Stubs for spying
+
+```ruby
+# Given this object/API
+
+my_class = Class.new do
+  def basic_method(value)
+    value
+  end
+
+  def iterator_method(items, &block)
+    items.each(&block)
+  end
+end
+my_object = my_class.new
+
+# Store method call arguments/blocks for spying.
+
+basic_method_called_with = nil
+MuchStub.(my_object, :basic_method) { |*args|
+  basic_method_called_with = args
+}
+
+my_object.basic_method(123)
+basic_method_called_with
+  # => [123]
+
+iterator_method_call_args = nil
+iterator_method_call_block = nil
+MuchStub.(my_object, :iterator_method) { |*args, &block|
+  iterator_method_call_args = args
+  iterator_method_call_block = block
+}
+
+my_object.iterator_method([1, 2, 3], &:to_s)
+iterator_method_call_args
+  # => [[1, 2, 3]]
+iterator_method_call_block
+  # => #<Proc:0x00007fb083a6feb0(&:to_s)>
+
+# Count method calls for spying.
+
+basic_method_call_count = 0
+MuchStub.(my_object, :basic_method) {
+  basic_method_call_count += 1
+}
+
+my_object.basic_method(123)
+basic_method_call_count
+  # => 1
+
+# Count method calls and store arguments for spying.
+
+basic_method_calls = []
+MuchStub.(my_object, :basic_method) { |*args|
+  basic_method_calls << args
+}
+
+my_object.basic_method(123)
+basic_method_calls.size
+  # => 1
+basic_method_calls.first
+  # => [123]
+```
+
+### Stubs for test doubles.
+
+```ruby
+# Given this object/API ...
+
+my_class = Class.new do
+  def build_thing(thing_value);
+    Thing.new(value)
+  end
+end
+my_object = my_class.new
+
+# ... and this Test Double.
+class FakeThing
+  attr_reader :built_with
+
+  def initialize(*args)
+    @built_with = args
+  end
+end
+
+# Stub in the test double.
+
+MuchStub.(my_object, :build_thing) { |*args|
+  FakeThing.new(*args)
+}
+
+thing = my_object.build_thing(123)
+thing.built_with
+  # => [123]
+```
+
+### `MuchStub.tap`
+
+Use the `.tap` method to spy on method calls while preserving the original method return value and behavior.
+
+```ruby
+# Given this object/API
+
+my_class = Class.new do
+  def basic_method(value)
+    value.to_s
+  end
+end
+my_object = my_class.new
+
+# Normal stubs override the original behavior and return value...
+basic_method_called_with = nil
+MuchStub.(my_object, :basic_method) { |*args|
+  basic_method_called_with = args
+}
+
+# ... in this case not converting the value to a String and returning it and
+# instead returning the arguments passed to the method.
+my_object.basic_method(123)
+  # => [123]
+basic_method_called_with
+  # => [123]
+
+# Use `MuchStub.tap` to preserve the methods behavior and also spy.
+
+basic_method_called_with = nil
+MuchStub.tap(my_object, :basic_method) { |value, *args|
+  basic_method_called_with = args
+}
+
+my_object.basic_method(123)
+  # => "123"
+basic_method_called_with
+  # => [123]
+```
+
+#### Late-bound stubs using `MuchStub.tap`
+
+Use the `.tap` method to stub any return values of method calls.
+
+```ruby
+# Given:
+
+class Thing
+  attr_reader :value
+
+  def initialize(value)
+    @value = value
+  end
+end
+
+my_class = Class.new do
+  def thing(value)
+    Thing.new(value)
+  end
+end
+my_object = my_class.new
+
+# Use `MuchStub.tap` to stub any thing instances created by `my_object.thing`
+# (and also spy on the call arguments)
+
+thing_built_with = nil
+MuchStub.tap(my_object, :thing) { |thing, *args|
+  thing_built_with = args
+  MuchStub.(thing, :value) { 456 }
+}
+
+thing = my_object.thing(123)
+  # => #<Thing:0x00007fd5ca9df510 @value=123>
+thing_built_with
+  # => [123]
+thing.value
   # => 456
 ```
 
@@ -86,7 +270,7 @@ myobj.myval(456)
 
 Add this line to your application's Gemfile:
 
-    gem 'much-stub'
+    gem "much-stub"
 
 And then execute:
 
@@ -100,6 +284,6 @@ Or install it yourself as:
 
 1. Fork it
 2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Commit your changes (`git commit -am 'Added some feature'`)
+3. Commit your changes (`git commit -am "Added some feature"`)
 4. Push to the branch (`git push origin my-new-feature`)
 5. Create new Pull Request

data/lib/much-stub.rb

@@ -1,7 +1,6 @@
 require "much-stub/version"
 
 module MuchStub
-
   def self.stubs
     @stubs ||= {}
   end
@@ -37,8 +36,15 @@ module MuchStub
     stub.call_method(args, &block)
   end
 
-  class Stub
+  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
+      }
+    }
+  end
 
+  class Stub
     def self.key(object, method_name)
       "--#{object.object_id}--#{method_name}--"
     end
@@ -100,7 +106,7 @@ module MuchStub
     end
 
     def inspect
-      "#<#{self.class}:#{'0x0%x' % (object_id << 1)}" \
+      "#<#{self.class}:#{"0x0%x" % (object_id << 1)}" \
       " @method_name=#{@method_name.inspect}" \
       ">"
     end
@@ -159,7 +165,7 @@ module MuchStub
     end
 
     def inspect_call(args)
-      "`#{@method_name}(#{args.map(&:inspect).join(',')})`"
+      "`#{@method_name}(#{args.map(&:inspect).join(",")})`"
     end
 
     def number_of_args(arity)
@@ -169,7 +175,6 @@ module MuchStub
         arity
       end
     end
-
   end
 
   StubError       = Class.new(ArgumentError)
@@ -181,15 +186,14 @@ module MuchStub
   end
 
   module ParameterList
-
-    LETTERS = ('a'..'z').to_a.freeze
+    LETTERS = ("a".."z").to_a.freeze
 
     def self.new(object, method_name)
       arity = get_arity(object, method_name)
       params = build_params_from_arity(arity)
-      params << '*args' if arity < 0
-      params << '&block'
-      params.join(', ')
+      params << "*args" if arity < 0
+      params << "&block"
+      params.join(", ")
     end
 
     private
@@ -210,9 +214,7 @@ module MuchStub
       number_of_letters, letter_index = param_index.divmod(LETTERS.size)
       LETTERS[letter_index] * number_of_letters
     end
-
   end
-
 end
 
 # Kernel#caller_locations polyfill for pre ruby 2.0.0

data/lib/much-stub/version.rb

@@ -1,3 +1,3 @@
 module MuchStub
-  VERSION = "0.1.1"
+  VERSION = "0.1.2"
 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,13 @@ 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.add_development_dependency("assert", ["~> 2.18.0"])
 
 end

data/test/helper.rb

@@ -5,9 +5,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 +19,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