spy 0.2.1 → 0.2.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 25f96e1254110c34d4b25ace27db39cf4933cc2a
+  data.tar.gz: 84320005a4c47158b70dc86fca661f6ae95f6ad6
+SHA512:
+  metadata.gz: 340277d830dfb87085d61fb443b834cb6636e8dda7b5d2af0166aab6835918747343849efed3b56032071d5d44b49cebaca0edb04df0c7997c10006cdb6cc897
+  data.tar.gz: 2b147cc08e3612270d8f18789bc4116621334e6da864bb3299b79ce857247513c467e4bf7f27e8c0354b064801445b392856489758fd6456015d44000dad987d

data/.travis.yml

@@ -1,5 +1,5 @@
 language: ruby
 rvm:
   - "1.9.3"
+  - "2.0.0"
   - jruby-19mode
-  - rbx-19mode

data/Gemfile

@@ -5,5 +5,5 @@ gemspec
 gem 'pry'
 gem 'pry-nav'
 gem 'yard'
-gem 'redcarpet'
+gem 'redcarpet', platforms: :mri
 gem 'rake'

data/lib/spy/constant.rb

@@ -19,9 +19,7 @@ module Spy
       raise "#{base_module.inspect} is not a kind of Module" unless base_module.is_a? Module
       raise "#{constant_name.inspect} is not a kind of Symbol" unless constant_name.is_a? Symbol
       @base_module, @constant_name = base_module, constant_name.to_sym
-      @original_value = nil
-      @new_value = nil
-      @previously_defined = nil
+      @original_value = @new_value = @previously_defined = nil
     end
 
     # full name of spied constant
@@ -33,11 +31,12 @@ module Spy
     # @param opts [Hash{force => false}] set :force => true if you want it to ignore if the constant exists
     # @return [self]
     def hook(opts = {})
+      opts[:force] ||= false
       Nest.fetch(base_module).add(self)
       Agency.instance.recruit(self)
-      opts[:force] ||= false
+
       @previously_defined = currently_defined?
-      if @previously_defined || !opts[:force]
+      if previously_defined? || !opts[:force]
         @original_value = base_module.const_get(constant_name, false)
       end
       and_return(@new_value)
@@ -50,10 +49,9 @@ module Spy
       Nest.get(base_module).remove(self)
       Agency.instance.retire(self)
 
-      if @previously_defined
-        and_return(@original_value)
-      end
-      @original_value = nil
+      and_return(@original_value) if previously_defined?
+
+      @original_value = @previously_defined = nil
       self
     end
 

data/lib/spy/nest.rb

@@ -35,6 +35,8 @@ module Spy
     def remove(spy)
       if @hooked_constants[spy.constant_name] == spy
         @hooked_constants.delete(spy.constant_name)
+      else
+        raise "#{spy.constant_name} was never added"
       end
       self
     end

data/lib/spy/subroutine.rb

@@ -38,10 +38,11 @@ module Spy
       raise "#{base_object} method '#{method_name}' has already been hooked" if hooked?
 
       hook_opts[:force] ||= base_object.is_a?(Double)
-      if (base_object_respond_to?(method_name, true)) || !hook_opts[:force]
+      hook_opts[:visibility] ||= original_method_visibility
+
+      if original_method_visibility || !hook_opts[:force]
         @original_method = current_method
       end
-      hook_opts[:visibility] ||= method_visibility
 
       base_object.send(define_method_with, method_name, override_method)
 
@@ -61,7 +62,7 @@ module Spy
 
       if original_method && method_owner == original_method.owner
         original_method.owner.send(:define_method, method_name, original_method)
-        original_method.owner.send(method_visibility, method_name) if method_visibility
+        original_method.owner.send(original_method_visibility, method_name) if original_method_visibility
       else
         method_owner.send(:remove_method, method_name)
       end
@@ -83,18 +84,10 @@ module Spy
     #
     # @return [self]
     def and_return(value = nil)
+      raise ArgumentError.new("value and block conflict. Choose one") if !(value.nil? || value.is_a?(Hash) && value.has_key?(:force)) && block_given?
       if block_given?
         @plan = Proc.new
-        if value.nil? || value.is_a?(Hash) && value.has_key?(:force)
-          if !(value.is_a?(Hash) && value[:force]) &&
-              original_method &&
-              original_method.arity >=0 &&
-              @plan.arity > original_method.arity
-            raise ArgumentError.new "The original method only has an arity of #{original_method.arity} you have an arity of #{@plan.arity}"
-          end
-        else
-          raise ArgumentError.new("value and block conflict. Choose one") if !value.nil?
-        end
+        check_for_too_many_arguments!(@plan)
       else
         @plan = Proc.new { value }
       end
@@ -114,11 +107,10 @@ module Spy
     # tells the spy to call the original method
     # @return [self]
     def and_call_through
-      raise "can only call through if original method is set" unless method_visibility
-      if original_method
-        @plan = original_method
-      else
-        @plan = Proc.new do |*args, &block|
+      @plan = Proc.new do |*args, &block|
+        if original_method
+          original_method.call(*args, &block)
+        else
           base_object.send(:method_missing, method_name, *args, &block)
         end
       end
@@ -182,9 +174,12 @@ module Spy
     # method.
     def invoke(object, args, block, called_from)
       check_arity!(args.size)
-      result = @plan ? @plan.call(*args, &block) : nil
+      result = if @plan
+                 check_for_too_many_arguments!(@plan)
+                 @plan.call(*args, &block)
+               end
     ensure
-      calls << CallLog.new(object,called_from, args, block, result)
+      calls << CallLog.new(object, called_from, args, block, result)
     end
 
     # reset the call log
@@ -206,43 +201,32 @@ module Spy
       METHOD
     end
 
-    def call_with_yield(&block)
-      raise "no block sent" unless block
-      value = nil
-      @args_to_yield.each do |args|
-        if block.arity > -1 && args.length != block.arity
-          @error_generator.raise_wrong_arity_error args, block.arity
-        end
-        value = @eval_context ? @eval_context.instance_exec(*args, &block) : block.call(*args)
-      end
-      value
-    end
-
     def clear_method!
       @hooked = false
-      @hook_opts = @original_method = @arity_range = @method_visibility = @method_owner= nil
+      @hook_opts = @original_method = @arity_range = @original_method_visibility = @method_owner= nil
     end
 
-    def method_visibility
-      @method_visibility ||=
-        if base_object_respond_to?(method_name)
-          if original_method && original_method.owner.protected_method_defined?(method_name)
-            :protected
-          else
-            :public
-          end
-        elsif base_object_respond_to?(method_name, true)
-          :private
-        end
+    def original_method_visibility
+      @original_method_visibility ||= method_visibility_of(method_name)
     end
 
-    def base_object_respond_to?(method_name, include_private = false)
+    def method_visibility_of(method_name, all = true)
       if @singleton_method
-        base_object.respond_to?(method_name, include_private)
+        if base_object.public_methods(all).include?(method_name)
+          :public
+        elsif base_object.protected_methods(all).include?(method_name)
+          :protected
+        elsif base_object.private_methods(all).include?(method_name)
+          :private
+        end
       else
-        base_object.instance_methods.include?(method_name) || (
-          include_private && base_object.private_instance_methods.include?(method_name)
-        )
+        if base_object.public_instance_methods(all).include?(method_name)
+          :public
+        elsif base_object.protected_instance_methods(all).include?(method_name)
+          :protected
+        elsif base_object.private_instance_methods(all).include?(method_name)
+          :private
+        end
       end
     end
 
@@ -251,11 +235,41 @@ module Spy
     end
 
     def check_arity!(arity)
-      self.class.check_arity_against_range!(arity_range, arity)
+      return unless arity_range
+      if arity < arity_range.min
+        raise ArgumentError.new("wrong number of arguments (#{arity} for #{arity_range.min})")
+      elsif arity > arity_range.max
+        raise ArgumentError.new("wrong number of arguments (#{arity} for #{arity_range.max})")
+      end
+    end
+
+    def check_for_too_many_arguments!(block)
+      return unless arity_range
+      min_arity = block.arity
+      min_arity = min_arity.abs - 1 if min_arity < 0
+
+      if min_arity > arity_range.max
+        raise ArgumentError.new("block requires #{min_arity} arguments while original_method require a maximum of #{arity_range.max}")
+      end
     end
 
     def arity_range
-      @arity_range ||= self.class.arity_range_of(original_method) if original_method
+      @arity_range ||=
+        if original_method
+          min = max = 0
+          original_method.parameters.each do |type,_|
+            case type
+            when :req
+              min += 1
+              max += 1
+            when :opt
+              max += 1
+            when :rest
+              max = Float::INFINITY
+            end
+          end
+          (min..max)
+        end
     end
 
     def current_method
@@ -267,34 +281,6 @@ module Spy
     end
 
     class << self
-      # @private
-      def arity_range_of(block)
-        raise "#{block.inspect} does not respond to :parameters" unless block.respond_to?(:parameters)
-        min = max = 0
-        block.parameters.each do |type,_|
-          case type
-          when :req
-            min += 1
-            max += 1
-          when :opt
-            max += 1
-          when :rest
-            max = Float::INFINITY
-          end
-        end
-        (min..max)
-      end
-
-      # @private
-      def check_arity_against_range!(arity_range, arity)
-        return unless arity_range
-        if arity < arity_range.min
-          raise ArgumentError.new("wrong number of arguments (#{arity} for #{arity_range.min})")
-        elsif arity > arity_range.max
-          raise ArgumentError.new("wrong number of arguments (#{arity} for #{arity_range.max})")
-        end
-      end
-
       # retrieve the method spy from an object
       # @param base_object
       # @param method_name [Symbol]
@@ -316,12 +302,18 @@ module Spy
 
       # retrieve all the spies from a given object
       # @param base_object
+      # @param singleton_method [Boolean] (true) only get singleton_method_spies
       # @return [Array<Subroutine>]
-      def get_spies(base_object)
+      def get_spies(base_object, singleton_methods = true)
+        if singleton_methods
         all_methods = base_object.public_methods(false) +
           base_object.protected_methods(false) +
           base_object.private_methods(false)
-        all_methods += base_object.instance_methods(false) + base_object.private_instance_methods(false) if base_object.respond_to?(:instance_methods)
+        else
+          all_methods = base_object.instance_methods(false) +
+            base_object.private_instance_methods(false)
+        end
+
         all_methods.map do |method_name|
           Agency.instance.find(get_spy_id(base_object.method(method_name)))
         end.compact

data/lib/spy/version.rb

@@ -1,3 +1,3 @@
 module Spy
-  VERSION = "0.2.1"
+  VERSION = "0.2.2"
 end

data/test/spy/test_subroutine.rb

@@ -74,8 +74,7 @@ module Spy
     end
 
     def test_spy_can_hook_a_non_existent_method_if_param_set
-      spy = Subroutine.new(@pen, :no_method).and_return(:yep)
-      spy.hook(force: true)
+      Subroutine.new(@pen, :no_method).hook(force:true).and_return(:yep)
       assert_equal :yep, @pen.no_method
     end
 
@@ -188,24 +187,39 @@ module Spy
     def test_hook_mimics_public_visibility
       spy_on(@pen, :public_method)
       assert @pen.singleton_class.public_method_defined? :public_method
-      refute @pen.singleton_class.protected_method_defined? :public_method
-      refute @pen.singleton_class.private_method_defined? :public_method
     end
 
     def test_hook_mimics_protected_visibility
       spy_on(@pen, :protected_method)
-      refute @pen.singleton_class.public_method_defined? :protected_method
       assert @pen.singleton_class.protected_method_defined? :protected_method
-      refute @pen.singleton_class.private_method_defined? :protected_method
     end
 
     def test_hook_mimics_private_visibility
       spy_on(@pen, :private_method)
-      refute @pen.singleton_class.public_method_defined? :private_method
-      refute @pen.singleton_class.protected_method_defined? :private_method
       assert @pen.singleton_class.private_method_defined? :private_method
     end
 
+    def test_hook_mimics_class_public_visibility
+      spy_on(Pen, :public_method)
+      assert Pen.public_method_defined? :public_method
+      Spy.off(Pen, :public_method)
+      assert Pen.public_method_defined? :public_method
+    end
+
+    def test_hook_mimics_class_protected_visibility
+      spy_on(Pen, :protected_method)
+      assert Pen.protected_method_defined? :protected_method
+      Spy.off(Pen, :protected_method)
+      assert Pen.protected_method_defined? :protected_method
+    end
+
+    def test_hook_mimics_class_private_visibility
+      spy_on(Pen, :private_method)
+      assert Pen.private_method_defined? :private_method
+      Spy.off(Pen, :private_method)
+      assert Pen.private_method_defined? :private_method
+    end
+
     def test_spy_get_can_retrieve_a_spy
       pen_write_spy = spy_on(@pen, :write).and_return(:hello)
       assert_equal :hello, @pen.write(:world)

data/test/support/pen.rb

@@ -50,6 +50,18 @@ class Pen
     def another
       "another"
     end
+
+    def public_method
+    end
+
+    protected
+    def protected_method
+    end
+
+    private
+    def private_method
+    end
+
   end
 end
 

metadata

@@ -1,62 +1,55 @@
 --- !ruby/object:Gem::Specification
 name: spy
 version: !ruby/object:Gem::Version
-  version: 0.2.1
-  prerelease: 
+  version: 0.2.2
 platform: ruby
 authors:
 - Ryan Ong
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-02-25 00:00:00.000000000 Z
+date: 2013-02-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: 4.5.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: 4.5.0
 - !ruby/object:Gem::Dependency
   name: rspec-core
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec-expectations
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 description: A simple mocking library that doesn't spies your intelligence.
@@ -109,27 +102,26 @@ files:
 - test/test_helper.rb
 homepage: ''
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 2.0.0
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: A simple non destructive mocking library.
 test_files:
 - spec/spec_helper.rb