mock_proxy 0.2.3 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 418d9ed605b34dd982aeff5551e6447ece2ffe9f
-  data.tar.gz: aa8df9a51b6d698c9828d5a5519648c91156e389
+  metadata.gz: 4be99a98663982f26b85d5b18b0f4b8aeb60a889
+  data.tar.gz: 56eabef1a63825f91c4375960677ed0dc3a0c37c
 SHA512:
-  metadata.gz: 0b4c189c8f36de7bd7fdad795bef7b2116657b68c18bf81caff076492ca627a6f38124450f9af4720bfe0757dd91145f26e80e1ea3112d5a49efea660756ab83
-  data.tar.gz: 4b49efca88282b9f55da569508dd7858c8b4c010c2e63e3efb14fdccf46e1a47b0604376187a7ef6dc71678e296264c4626a521774530897047d283946aa039a
+  metadata.gz: e355f02c7587ab7b2e194db9cb3d170e5baf970bdc620a86501902344440c75d3aa1c0fbd2eac1eacf9074b9fcca90037bf2cb78b2c1ba2f5f1157bcd018d1c6
+  data.tar.gz: 38e6f423b030d606c29e3fc1e524027223032bfd3bb2dff2196a2a9ff33b79e3c8d978b758c37e697bf2e0b8cf6bff682ee9ff0e2b353fb42e58656ded28c1b7

data/lib/mock_proxy.rb

@@ -9,15 +9,15 @@ require 'active_support/core_ext'
 # That would have be 5-6 lines of stubbing. If this sounds like stub_chain, you're on the right track. It was removed in
 # RSpec 3 (or 2?). It's similar to that but it does things differently
 # First, it doesn't require you to use it in a stub
-# Second, it's use of procs means you can define anything, a stub or a mock (expectation) or a spy or whatever you want
+# Second, it's use of callbacks means you can define anything, a stub or a mock (expectation) or a spy or whatever you want
 #
 # To use MockProxy, initialize it with a hash. Each key is a method call. Each call either returns a new proxy or calls
-# the proc. If the value is a proc, it calls it immediately with the args and block. If the value is a hash, it returns
-# a new proxy with the value as the hash. MockProxy will warn if you don't use hashes or procs and will also warn if
+# the callback. If the value is a callback, it calls it immediately with the args and block. If the value is a hash, it returns
+# a new proxy with the value as the hash. MockProxy will warn if you don't use hashes or callbacks and will also warn if
 # you did not define all the method calls (it won't automatically return itself for methods not defined in the hash)
 #
 # Example use:
-#   let(:model_proxy) { MockProxy.new(receive_email: proc {}, generate_email: { validate!: { send: proc { |to| email } } }) }
+#   let(:model_proxy) { MockProxy.new(receive_email: callback {}, generate_email: { validate!: { send: callback { |to| email } } }) }
 #   before { allow(Model).to receive(:new).and_return model_proxy }
 #   # ...
 #   describe 'Model' do
@@ -34,13 +34,13 @@ require 'active_support/core_ext'
 #
 # Example:
 #   let(:model_proxy) do
-#     callback = proc do |type|
-#       MockProxy.merge(generator_proxy, decorate: proc { |*args| method_call(type, *args) })
+#     callback = callback do |type|
+#       MockProxy.merge(generator_proxy, decorate: callback { |*args| method_call(type, *args) })
 #       generator_proxy
 #     end
 #     MockProxy.new(generate_email: callback)
 #   end
-#   let(:generator_proxy) { MockProxy.new(validate!: { send: proc { |to| email } }) }
+#   let(:generator_proxy) { MockProxy.new(validate!: { send: callback { |to| email } }) }
 #
 #
 # @author Geoff Lee
@@ -51,7 +51,7 @@ class MockProxy
   #
   # NOTE: We freeze the hash so you cannot modify it
   #
-  # Use case: Retrieve proc to mock
+  # Use case: Retrieve callback to mock
   #
   # @param [MockProxy] proxy existing proxy
   # @param [String, Symbol, #to_s, Array<String, Symbol, #to_s>] key_path the chain of methods or key path. Can be a
@@ -79,11 +79,11 @@ class MockProxy
     proxy
   end
 
-  # Replaces the proc at the specified key path, but only if there was one there before.
+  # Replaces the callback at the specified key path, but only if there was one there before.
   # Without creating new paths comes validation, including checking that this replaces an
-  # existing proc, sort of like mkdir (without the -p option)
+  # existing callback, sort of like mkdir (without the -p option)
   #
-  # Use case: Replace existing stub with a new proc without creating new method chains
+  # Use case: Replace existing stub with a new callback without creating new method chains
   #
   # @param [MockProxy] proxy existing proxy
   # @param [String, Symbol, #to_s, Array<String, Symbol, #to_s>] key_path the chain of methods or key path. Can be a
@@ -94,7 +94,7 @@ class MockProxy
     proxy
   end
 
-  # Sets the proc at the specified key path, regardless if there was a proc there before.
+  # Sets the callback at the specified key path, regardless if there was a callback there before.
   # No validation comes with automatic path creation, meaning the key path will be defined
   # it it hasn't already, sort of like mkdir -p
   #
@@ -124,7 +124,7 @@ class MockProxy
     # Wrap existing callback, calling the provided block before it
     # Multiple calls to .observe will create a pyramid of callbacks, calling the observers before
     # eventually calling the existing callback
-    new_callback = proc do |*args|
+    new_callback = callback do |*args|
       block.call(*args)
       callback.call(*args)
     end
@@ -134,7 +134,7 @@ class MockProxy
 
   # Wraps the existing callback with your block
   #
-  # Use case: Get full control of the existing proc while running custom code
+  # Use case: Get full control of the existing callback while running custom code
   #
   # @param [MockProxy] proxy existing proxy
   # @param [String, Symbol, #to_s, Array<String, Symbol, #to_s>] key_path the chain of methods or key path. Can be a
@@ -147,7 +147,7 @@ class MockProxy
     # Wrap existing callback, calling the provided block before it
     # Multiple calls to .observe will create a pyramid of callbacks, calling the observers before
     # eventually calling the existing callback
-    new_callback = proc do |*args|
+    new_callback = callback do |*args|
       block.call(*args, &callback)
     end
     set_callback(proxy, key_path, new_callback)
@@ -158,8 +158,8 @@ class MockProxy
   # @param [MockProxy] proxy existing proxy
   # @param [String, Symbol, #to_s, Array<String, Symbol, #to_s>] key_path the chain of methods or key path. Can be a
   #        dot delimited key path or an array of method names as strings or symbols
-  # @return [Proc] if proc found at key path
-  # @raise [ArgumentError] if proc not found or hash found at key path
+  # @return [AnyObject, !Hash] if callback found at key path
+  # @raise [ArgumentError] if callback not found or hash found at key path
   def self.get_callback(proxy, key_path)
     key_paths = key_path.is_a?(Array) ? key_path.map(&:to_s) : key_path.split('.')
     existing_callback_hash = proxy.instance_variable_get('@callback_hash')
@@ -177,12 +177,12 @@ class MockProxy
   # @param [MockProxy] proxy existing proxy
   # @param [String, Symbol, #to_s, Array<String, Symbol, #to_s>] key_path the chain of methods or key path. Can be a
   #        dot delimited key path or an array of method names as strings or symbols
-  # @return [Proc] if proc found at key path
-  # @raise [ArgumentError] if proc not found or hash found at key path
+  # @return [AnyObject, !Hash] if callback found at key path
+  # @raise [ArgumentError] if callback not found or hash found at key path
   def self.get_and_validate_callback(proxy, key_path)
     callback = get_callback(proxy, key_path)
-    return callback if callback.is_a?(Proc)
-    fail ArgumentError, "The existing callback tree contains the full key path you provided but continues going (i.e. no proc at exact key path). If you want to shorten the callback tree, use MockProxy.set_at. The callback tree looks like this: #{proxy.instance_variable_get('@callback_hash')}"
+    return callback if valid_callback?(callback)
+    fail ArgumentError, "The existing callback tree contains the full key path you provided but continues going (i.e. no callback at exact key path). If you want to shorten the callback tree, use MockProxy.set_at. The callback tree looks like this: #{proxy.instance_variable_get('@callback_hash')}"
   end
   private_class_method :get_and_validate_callback
 
@@ -190,15 +190,15 @@ class MockProxy
   # @param [MockProxy] proxy existing proxy
   # @param [String, Symbol, #to_s, Array<String, Symbol, #to_s>] key_path the chain of methods or key path. Can be a
   #        dot delimited key path or an array of method names as strings or symbols
-  # @param [Proc] proc the new proc to replace the existing proc
+  # @param [AnyObject, !Hash] callback the new callback to replace the existing callback
   # @param [Bool] validate true will throw error if nil at any part of key path, false to
   #        create key path if missing (mkdir vs mkdir -p) (Defaults: true)
-  # @return [MockProxy] if proc existed at key path
-  # @raise [ArgumentError] if proc not found or hash found at key path
-  def self.set_callback(proxy, key_path, proc, validate = true)
-    fail ArgumentError, 'proc must be provided' unless proc
-    fail ArgumentError, 'proc must be a proc' unless proc.is_a?(Proc)
-    # Validate by checking if proc exists at key path
+  # @return [MockProxy] if callback existed at key path
+  # @raise [ArgumentError] if callback not found or hash found at key path
+  def self.set_callback(proxy, key_path, callback, validate = true)
+    fail ArgumentError, 'callback must be provided' unless callback
+    fail ArgumentError, 'callback must have a non-hash value' unless valid_callback?(callback)
+    # Validate by checking if callback exists at key path
     get_and_validate_callback(proxy, key_path) if validate
     # Set callback at key path, validating if set
     key_paths = key_path.is_a?(Array) ? key_path.map(&:to_s) : key_path.to_s.split('.')
@@ -208,11 +208,11 @@ class MockProxy
       # Last key
       if key_paths.last == key
         # Type check value, if validate
-        if validate && !callback_hash[key].is_a?(Proc)
-          fail ArgumentError, "The existing callback tree contains the full key path you provided but continues going (i.e. no proc at exact key path). If you want to shorten the callback tree, use MockProxy.set_at. The callback tree looks like this: #{copied_callback_hash}"
+        if validate && !valid_callback?(callback_hash[key])
+          fail ArgumentError, "The existing callback tree contains the full key path you provided but continues going (i.e. no callback at exact key path). If you want to shorten the callback tree, use MockProxy.set_at. The callback tree looks like this: #{copied_callback_hash}"
         else
-          # Assign new proc if pass validations
-          callback_hash[key] = proc
+          # Assign new callback if pass validations
+          callback_hash[key] = callback
         end
       else
         # In-between keys
@@ -230,18 +230,47 @@ class MockProxy
   end
   private_class_method :set_callback
 
+  # @private
+  # Supporting not just callbacks but other values for callbacks. To make the code easier to
+  # read and more reliable, hashes are not a supported callback value. To return one, use
+  # a callback like you would normally
+  #
+  # @param [AnyObject, !Hash] callback
+  # @return [Boolean] true if callback is valid, false if not
+  def self.valid_callback?(callback)
+    callback && !callback.is_a?(Hash)
+  end
+  private_class_method :valid_callback?
+
+  # @private
+  # Supporting not just callbacks but other values for callbacks. To make the code easier to
+  # read and more reliable, hashes are not a supported callback value. To return one, use
+  # a callback like you would normally
+  #
+  # @param [#to_s => AnyObject, !Hash] callback_tree
+  # @return [Boolean] true if callback is valid, false if not
+  def self.valid_callback_tree?(callback_tree)
+    return false unless callback_tree.is_a?(Hash)
+    callback_tree.all? do |key, value|
+      next false unless key.responds_to?(:to_s)
+      value.is_a?(Hash) ? valid_callback_tree?(value) : valid_callback?(value)
+    end
+  end
+  private_class_method :valid_callback_tree?
+
   # @param [Hash] callback_hash the tree of chained method calls
   def initialize(callback_hash)
+    valid_callback_tree?(callback_hash)
     @callback_hash = callback_hash.deep_stringify_keys.freeze
   end
 
   # @private
   def method_missing(name, *args, &block)
     current = @callback_hash[name.to_s]
-    if current.is_a?(Proc)
+    if MockProxy.valid_callback?(current)
       current.call(*args, &block)
     else
-      if !current.is_a?(Proc) && !current.is_a?(Hash)
+      if !current
         fail "Missing method #{name}. Please add this definition to your mock proxy"
       end
       MockProxy.new(current.freeze)

data/lib/mock_proxy/version.rb

@@ -1,4 +1,4 @@
 class MockProxy
   # The version number
-  VERSION = '0.2.3'
+  VERSION = '0.3.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mock_proxy
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.3.0
 platform: ruby
 authors:
 - matrinox