spy 0.0.1 → 0.1.0

data/lib/spy/agency.rb

@@ -0,0 +1,65 @@
+require 'singleton'
+
+module Spy
+  class Agency
+    include Singleton
+
+    attr_reader :subroutines, :constants, :doubles
+
+    def initialize
+      clear!
+    end
+
+    def recruit(spy)
+      case spy
+      when Subroutine
+        subroutines << spy
+      when Constant
+        constants << spy
+      when Double
+        doubles << spy
+      else
+        raise "Not a spy"
+      end
+      spy
+    end
+
+    def retire(spy)
+      case spy
+      when Subroutine
+        subroutines.delete(spy)
+      when Constant
+        constants.delete(spy)
+      when Double
+        doubles.delete(spy)
+      else
+        raise "Not a spy"
+      end
+      spy
+    end
+
+    def active?(spy)
+      case spy
+      when Subroutine
+        subroutines.include?(spy)
+      when Constant
+        constants.include?(spy)
+      when Double
+        doubles.include?(spy)
+      end
+    end
+
+    def dissolve!
+      subroutines.each(&:unhook)
+      constants.each(&:unhook)
+      clear!
+    end
+
+    def clear!
+      @subroutines = []
+      @constants = []
+      @doubles = []
+      self
+    end
+  end
+end

data/lib/spy/constant.rb

@@ -0,0 +1,67 @@
+module Spy
+  class Constant
+    attr_reader :base_module, :constant_name, :original_value, :new_value
+
+    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
+    end
+
+    def hook(opts = {})
+      opts[:force] ||= false
+      @was_defined = base_module.const_defined?(constant_name, false)
+      if @was_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
+
+    def unhook
+      if @was_defined
+        and_return(@original_value)
+      end
+      @original_value = nil
+
+      Agency.instance.retire(self)
+      Nest.fetch(base_module).remove(self)
+      self
+    end
+
+    def and_hide
+      base_module.send(:remove_const, constant_name)
+      self
+    end
+
+    def and_return(value)
+      @new_value = value
+      base_module.send(:remove_const, constant_name) if base_module.const_defined?(constant_name, false)
+      base_module.const_set(constant_name, @new_value)
+      self
+    end
+
+    def hooked?
+      Nest.get(base_module).hooked?(constant_name)
+    end
+
+    class << self
+      def on(base_module, constant_name)
+        new(base_module, constant_name).hook
+      end
+
+      def off(base_module, constant_name)
+        get(base_module, constant_name).unhook
+      end
+
+      def get(base_module, constant_name)
+        Nest.get(base_module).hooked_constants[constant_name]
+      end
+    end
+  end
+end

data/lib/spy/core_ext/marshal.rb

@@ -0,0 +1,28 @@
+module Marshal
+  class << self
+    def dump_with_mocks(*args)
+      object = args.shift
+      spies = Spy::Subroutine.get_spies(object)
+      if spies.empty?
+        return dump_without_mocks(*args.unshift(object))
+      end
+
+      spy_hook_options = spies.map do |spy|
+        opts = spy.opts
+        [spy.unhook, opts]
+      end
+
+      begin
+        dump_without_mocks(*args.unshift(object.dup))
+      ensure
+        spy_hook_options.each do |spy, opts|
+          spy.hook(opts)
+        end
+      end
+    end
+
+    alias_method :dump_without_mocks, :dump
+    undef_method :dump
+    alias_method :dump, :dump_with_mocks
+  end
+end

data/lib/spy/double.rb

@@ -1,4 +1,4 @@
-class Spy
+module Spy
   class Double
     def initialize(name, *args)
       @name = name

data/lib/spy/nest.rb

@@ -0,0 +1,45 @@
+module Spy
+  class Nest
+    attr_reader :base_module, :hooked_constants
+
+    def initialize(base_module)
+      raise "#{base_module} is not a kind of Module" unless base_module.is_a?(Module)
+      @base_module = base_module
+      @hooked_constants = {}
+    end
+
+    def add(spy)
+      if @hooked_constants[spy.constant_name]
+        raise "#{spy.constant_name} has already been stubbed"
+      else
+        @hooked_constants[spy.constant_name] = spy
+      end
+      self
+    end
+
+    def remove(spy)
+      if @hooked_constants[spy.constant_name] == spy
+        @hooked_constants.delete(spy.constant_name)
+      end
+      self
+    end
+
+    def hooked?(constant_name)
+      !!@hooked_constants[constant_name]
+    end
+
+    class << self
+      def get(base_module)
+        all[base_module.name]
+      end
+
+      def fetch(base_module)
+        all[base_module.name] ||= self.new(base_module)
+      end
+
+      def all
+        @all ||= {}
+      end
+    end
+  end
+end

data/lib/spy/subroutine.rb

@@ -0,0 +1,239 @@
+module Spy
+  class Subroutine
+    CallLog = Struct.new(:object, :args, :block, :result)
+    attr_reader :base_object, :method_name, :calls, :original_method, :opts
+
+    # set what object and method the spy should watch
+    # @param object
+    # @param method_name <Symbol>
+    def initialize(object, method_name)
+      @was_hooked = false
+      @base_object, @method_name = object, method_name
+      reset!
+    end
+
+    # hooks the method into the object and stashes original method if it exists
+    # @param opts [Hash{force => false, visibility => nil}] set :force => true if you want it to ignore if the method exists, or visibility to [:public, :protected, :private] to overwride current visibility
+    # @return self
+    def hook(opts = {})
+      @opts = opts
+      raise "#{base_object} method '#{method_name}' has already been hooked" if hooked?
+      opts[:force] ||= base_object.is_a?(Double)
+      if base_object.respond_to?(method_name, true) || !opts[:force]
+        @original_method = base_object.method(method_name)
+      end
+
+      opts[:visibility] ||= method_visibility
+
+      __method_spy__ = self
+      base_object.define_singleton_method(method_name) do |*__spy_args, &block|
+        if __spy_args.first === SECRET_SPY_KEY
+          __method_spy__
+        else
+          __method_spy__.invoke(self,__spy_args,block)
+        end
+      end
+
+      base_object.singleton_class.send(opts[:visibility], method_name) if opts[:visibility]
+
+      Agency.instance.recruit(self)
+      @was_hooked = true
+      self
+    end
+
+    # unhooks method from object
+    # @return self
+    def unhook
+      raise "#{method_name} method has not been hooked" unless hooked?
+      if original_method && original_method.owner == base_object.singleton_class
+        base_object.define_singleton_method(method_name, original_method)
+        base_object.singleton_class.send(method_visibility, method_name) if method_visibility
+      else
+        base_object.singleton_class.send(:remove_method, method_name)
+      end
+      clear_method!
+      Agency.instance.retire(self)
+      self
+    end
+
+    # is the spy hooked?
+    # @return Boolean
+    def hooked?
+      self == self.class.get(base_object, method_name)
+    end
+
+    # @overload and_return(value)
+    # @overload and_return(&block)
+    #
+    # Tells the spy to return a value when the method is called.
+    #
+    # @return self
+    def and_return(value = nil)
+      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
+      else
+        @plan = Proc.new { value }
+      end
+      self
+    end
+
+    # Tells the object to yield one or more args to a block when the message is received.
+    def and_yield(*args)
+      yield eval_context = Object.new if block_given?
+      @plan = Proc.new do |&block|
+        eval_context.instance_exec(*args, &block)
+      end
+      self
+    end
+
+    # 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|
+          base_object.send(:method_missing, method_name, *args, &block)
+        end
+      end
+      self
+    end
+
+    def and_raise(exception = RuntimeError, message = nil)
+      if exception.respond_to?(:exception)
+        exception = message ? exception.exception(message) : exception.exception
+      end
+
+      @plan = Proc.new { raise exception }
+    end
+
+    def and_throw(*args)
+      @plan = Proc.new { throw(*args) }
+      self
+    end
+
+    def has_been_called?
+      raise "was never hooked" unless @was_hooked
+      calls.size > 0
+    end
+
+    # check if the method was called with the exact arguments
+    def has_been_called_with?(*args)
+      raise "was never hooked" unless @was_hooked
+      calls.any? do |call_log|
+        call_log.args == args
+      end
+    end
+
+    # invoke that the method has been called. You really shouldn't use this
+    # method.
+    def invoke(object, args, block)
+      check_arity!(args.size)
+      result = @plan ? @plan.call(*args, &block) : nil
+      calls << CallLog.new(object, args, block, result)
+      result
+    end
+
+    # reset the call log
+    def reset!
+      @calls = []
+      clear_method!
+      true
+    end
+
+    private
+
+    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
+      @opts = @original_method = @arity_range = @method_visibility = 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
+    end
+
+    def check_arity!(arity)
+      self.class.check_arity_against_range!(arity_range, arity)
+    end
+
+    def arity_range
+      @arity_range ||= self.class.arity_range_of(original_method) if original_method
+    end
+
+    class << self
+      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
+
+      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
+
+      SPY_METHOD_PARAMS = [[:rest, :__spy_args], [:block, :block]]
+
+      def get(base_object, method_name)
+        if (base_object.singleton_methods + base_object.singleton_class.private_instance_methods(false)).include?(method_name.to_sym) && base_object.method(method_name).parameters == SPY_METHOD_PARAMS
+          base_object.send(method_name, SECRET_SPY_KEY)
+        end
+      end
+
+      def get_spies(base_object)
+        base_object.singleton_methods.map do |method_name|
+          if base_object.method(method_name).parameters == SPY_METHOD_PARAMS
+            base_object.send(method_name, SECRET_SPY_KEY)
+          end
+        end.compact
+      end
+    end
+  end
+end