spy 0.1.0 → 0.2.1

data/.travis.yml

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

data/Gemfile

@@ -6,3 +6,4 @@ gem 'pry'
 gem 'pry-nav'
 gem 'yard'
 gem 'redcarpet'
+gem 'rake'

data/README.md

@@ -29,11 +29,14 @@ Fail faster, code faster.
 
 ## Why not to use this
 
-* Api is not stable
-* missing these features
-  * Mocking null objects
-  * argument matchers for Spy::Method#has\_been\_called\_with
-  * watch all calls to an object to check order in which they are called
+* mocking null objects is not supported(yet)
+* no argument matchers for Spy::Method#has\_been\_called\_with
+* cannot watch all calls to an object to check order in which they are called
+* cannot transfer nested constants when stubbing a constant
+  * i don't think anybody uses this anyway
+  * nobody on github does
+* #with is not supported yet
+  * this is probably a code smell. You either need to abstract your method more or add separate tests.
 
 ## Installation
 
@@ -56,10 +59,13 @@ Or install it yourself as:
 A method stub overrides a pre-existing method and records all calls to specified method. You can set the spy to return either the original method or your own custom implementation.
 
 Spy support 2 different ways of spying an existing method on an object.
+
 ```ruby
 Spy.on(book, title: "East of Eden")
 Spy.on(book, :title).and_return("East of Eden")
 Spy.on(book, :title).and_return { "East of Eden" }
+
+book.title  #=> "East of Eden"
 ```
 
 Spy will raise an error if you try to stub on a method that doesn't exist.
@@ -69,6 +75,15 @@ You can force the creation of a sstub on method that didn't exist but it really
 Spy.new(book, :flamethrower).hook(force:true).and_return("burnninante")
 ```
 
+You can also stub instance methods of Classes and Modules
+
+```ruby
+Spy.on_instance_method(Book, :title).and_return("Cannery Row")
+
+Book.new(title: "Siddhartha").title   #=> "Cannery Row"
+Book.new(title: "The Big Cheese").title   #=> "Cannery Row"
+```
+
 ### Test Doubles
 
 A test double is an object that stands in for a real object.
@@ -155,7 +170,7 @@ In spec\_helper.rb
 require "rspec/autorun"
 require "spy"
 RSpec.configure do |c|
-  c.before { Spy.teardown  }
+  c.after { Spy.teardown  }
 end
 ```
 
@@ -164,7 +179,7 @@ end
 ```ruby
 require "spy"
 class Test::Unit::TestCase
-  def setup
+  def teardown
     Spy.teardown
   end
 end

data/Rakefile

@@ -6,3 +6,5 @@ Rake::TestTask.new do |t|
   t.test_files = FileList['test/**/test*.rb']
   t.verbose = true
 end
+
+task :default => [:test]

data/lib/spy.rb

@@ -1,5 +1,6 @@
 require "spy/core_ext/marshal"
 require "spy/agency"
+require "spy/call_log"
 require "spy/constant"
 require "spy/double"
 require "spy/nest"
@@ -7,7 +8,7 @@ require "spy/subroutine"
 require "spy/version"
 
 module Spy
-  SECRET_SPY_KEY = Object.new
+
   class << self
     # create a spy on given object
     # @param base_object
@@ -38,12 +39,34 @@ module Spy
       removed_spies.size > 1 ? removed_spies : removed_spies.first
     end
 
+    #
+    def on_instance_method(base_class, *method_names)
+      spies = method_names.map do |method_name|
+        create_and_hook_spy(base_class, method_name, false)
+      end.flatten
+
+      spies.size > 1 ? spies : spies.first
+    end
+
+    def off_instance_method(base_object, *method_names)
+      removed_spies = method_names.map do |method_name|
+        spy = Subroutine.get(base_object, method_name, false)
+        if spy
+          spy.unhook
+        else
+          raise "Spy was not found"
+        end
+      end
+
+      removed_spies.size > 1 ? removed_spies : removed_spies.first
+    end
+
     # create a stub for constants on given module
     # @param base_module [Module]
     # @param constant_names *[Symbol, Hash]
     # @return [Constant, Array<Constant>]
     def on_const(base_module, *constant_names)
-      if base_module.is_a? Symbol
+      if base_module.is_a?(Hash) || base_module.is_a?(Symbol)
         constant_names.unshift(base_module)
         base_module = Object
       end
@@ -68,6 +91,11 @@ module Spy
     # @param constant_names *[Symbol]
     # @return [Constant, Array<Constant>]
     def off_const(base_module, *constant_names)
+      if base_module.is_a?(Hash) || base_module.is_a?(Symbol)
+        constant_names.unshift(base_module)
+        base_module = Object
+      end
+
       spies = constant_names.map do |constant_name|
         case constant_name
         when String, Symbol
@@ -112,7 +140,12 @@ module Spy
     # @param constant_names *[Symbol]
     # @return [Constant, Array<Constant>]
     def get_const(base_module, *constant_names)
-      spies = constant_names.map do |method_name|
+      if base_module.is_a?(Hash) || base_module.is_a?(Symbol)
+        constant_names.unshift(base_module)
+        base_module = Object
+      end
+
+      spies = constant_names.map do |constant_name|
         Constant.get(base_module, constant_name)
       end
 
@@ -121,13 +154,13 @@ module Spy
 
     private
 
-    def create_and_hook_spy(base_object, method_name, opts = {})
+    def create_and_hook_spy(base_object, method_name, singleton_method = true, hook_opts = {})
       case method_name
       when String, Symbol
-        Subroutine.new(base_object, method_name).hook(opts)
+        Subroutine.new(base_object, method_name, singleton_method).hook(hook_opts)
       when Hash
         method_name.map do |name, result|
-          create_and_hook_spy(base_object, name, opts).and_return(result)
+          create_and_hook_spy(base_object, name, singleton_method, hook_opts).and_return(result)
         end
       else
         raise ArgumentError.new "#{method_name.class} is an invalid input, #on only accepts String, Symbol, and Hash"

data/lib/spy/agency.rb

@@ -1,65 +1,80 @@
 require 'singleton'
 
 module Spy
+  # Manages all the spies
   class Agency
     include Singleton
 
-    attr_reader :subroutines, :constants, :doubles
-
+    # @private
     def initialize
       clear!
     end
 
+
+    # given a spy ID it will return the associated spy
+    # @param id [Integer] spy object id
+    # @return [Nil, Subroutine, Constant, Double]
+    def find(id)
+      @spies[id]
+    end
+
+    # Record that a spy was initialized and hooked
+    # @param spy [Subroutine, Constant, Double]
+    # @return [spy]
     def recruit(spy)
       case spy
-      when Subroutine
-        subroutines << spy
-      when Constant
-        constants << spy
-      when Double
-        doubles << spy
+      when Subroutine,  Constant, Double
+        @spies[spy.object_id] = spy
       else
         raise "Not a spy"
       end
-      spy
     end
 
+    # remove spy from the records
+    # @param spy [Subroutine, Constant, Double]
+    # @return [spy]
     def retire(spy)
       case spy
-      when Subroutine
-        subroutines.delete(spy)
-      when Constant
-        constants.delete(spy)
-      when Double
-        doubles.delete(spy)
+      when Subroutine,  Constant, Double
+        @spies.delete(spy.object_id)
       else
         raise "Not a spy"
       end
-      spy
     end
 
+    # checks to see if a spy is hooked
+    # @param spy [Subroutine, Constant, Double]
+    # @return [Boolean]
     def active?(spy)
       case spy
-      when Subroutine
-        subroutines.include?(spy)
-      when Constant
-        constants.include?(spy)
-      when Double
-        doubles.include?(spy)
+      when Subroutine,  Constant, Double
+        @spies.has_key?(spy.object_id)
+      else
+        raise "Not a spy"
       end
     end
 
+    # unhooks all spies and clears records
+    # @return [self]
     def dissolve!
-      subroutines.each(&:unhook)
-      constants.each(&:unhook)
+      @spies.values.each do |spy|
+        spy.unhook if spy.respond_to?(:unhook)
+      end
       clear!
     end
 
+    # clears records
+    # @return [self]
     def clear!
-      @subroutines = []
-      @constants = []
-      @doubles = []
+      @spies = {}
       self
     end
+
+    # returns all the spies that have been initialized since the creation of
+    # this agency
+    # @return [Array<Subroutine, Constant, Double>]
+    def spies
+      @spies.values
+    end
   end
 end

data/lib/spy/call_log.rb

@@ -0,0 +1,26 @@
+module Spy
+  class CallLog
+
+    # @!attribute [r] object
+    #   @return [Object] object that the method was called from
+    #
+    # @!attribute [r] called_from
+    #   @return [String] where the method was called from
+    #
+    # @!attribute [r] args
+    #   @return [Array] arguments were sent to the method
+    #
+    # @!attribute [r] block
+    #   @return [Proc] the block that was sent to the method
+    #
+    # @!attribute [r] result
+    #   @return The result of the method of being stubbed, or called through
+
+
+    attr_reader :object, :called_from, :args, :block, :result
+
+    def initialize(object, called_from, args, block, result)
+      @object, @called_from, @args, @block, @result = object, called_from, args, block, result
+    end
+  end
+end

data/lib/spy/constant.rb

@@ -1,66 +1,124 @@
 module Spy
   class Constant
-    attr_reader :base_module, :constant_name, :original_value, :new_value
 
+    # @!attribute [r] base_module
+    #   @return [Module] the module that is being watched
+    #
+    # @!attribute [r] constant_name
+    #   @return [Symbol] the name of the constant that is/will be stubbed
+    #
+    # @!attribute [r] original_value
+    #   @return [Object] the original value that was set when it was hooked
+
+
+    attr_reader :base_module, :constant_name, :original_value
+
+    # @param base_module [Module] the module this spy should be on
+    # @param constant_name [Symbol] the constant this spy is watching
     def initialize(base_module, constant_name)
       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
-      @was_defined = nil
+      @previously_defined = nil
+    end
+
+    # full name of spied constant
+    def name
+      "#{base_module.name}::#{constant_name}"
     end
 
+    # stashes the original constant then overwrites it with nil
+    # @param opts [Hash{force => false}] set :force => true if you want it to ignore if the constant exists
+    # @return [self]
     def hook(opts = {})
+      Nest.fetch(base_module).add(self)
+      Agency.instance.recruit(self)
       opts[:force] ||= false
-      @was_defined = base_module.const_defined?(constant_name, false)
-      if @was_defined || !opts[:force]
+      @previously_defined = currently_defined?
+      if @previously_defined || !opts[:force]
         @original_value = base_module.const_get(constant_name, false)
       end
       and_return(@new_value)
-      Nest.fetch(base_module).add(self)
-      Agency.instance.recruit(self)
       self
     end
 
+    # restores the original value of the constant or unsets it if it was unset
+    # @return [self]
     def unhook
-      if @was_defined
+      Nest.get(base_module).remove(self)
+      Agency.instance.retire(self)
+
+      if @previously_defined
         and_return(@original_value)
       end
       @original_value = nil
-
-      Agency.instance.retire(self)
-      Nest.fetch(base_module).remove(self)
       self
     end
 
+    # unsets the constant
+    # @return [self]
     def and_hide
-      base_module.send(:remove_const, constant_name)
+      base_module.send(:remove_const, constant_name) if currently_defined?
       self
     end
 
+    # sets the constant to the requested value
+    # @param value [Object]
+    # @return [self]
     def and_return(value)
       @new_value = value
-      base_module.send(:remove_const, constant_name) if base_module.const_defined?(constant_name, false)
+      and_hide
       base_module.const_set(constant_name, @new_value)
       self
     end
 
+    # checks to see if this spy is hooked?
+    # @return [Boolean]
     def hooked?
-      Nest.get(base_module).hooked?(constant_name)
+      self.class.get(base_module, constant_name) == self
+    end
+
+    # checks to see if the constant is hidden?
+    # @return [Boolean]
+    def hidden?
+      hooked? && currently_defined?
+    end
+
+    # checks to see if the constant is currently defined?
+    # @return [Boolean]
+    def currently_defined?
+      base_module.const_defined?(constant_name, false)
+    end
+
+    # checks to see if the constant is previously defined?
+    # @return [Boolean]
+    def previously_defined?
+      @previously_defined
     end
 
     class << self
+      # creates a new constant spy and hooks the constant
+      # @return [Constant]
       def on(base_module, constant_name)
         new(base_module, constant_name).hook
       end
 
+      # retrieves the spy for given constant and module and unhooks the constant
+      # from the module
+      # @return [Constant]
       def off(base_module, constant_name)
         get(base_module, constant_name).unhook
       end
 
+      # retrieves the spy for given constnat and module or returns nil
+      # @return [Nil, Constant]
       def get(base_module, constant_name)
-        Nest.get(base_module).hooked_constants[constant_name]
+        nest = Nest.get(base_module)
+        if nest
+          nest.hooked_constants[constant_name]
+        end
       end
     end
   end