spy 0.0.1

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+*.sw*
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in spies.gemspec
+gemspec
+gem 'pry'
+gem 'pry-nav'

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Ryan Ong
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,133 @@
+# Spy
+
+Spy is a lightweight doubles framework that won't let your code mock your intelligence.
+
+Inspired by the spy api of the jasmine javascript testing framework.
+
+## Why use this instead of rspec-mocks, mocha, or etc
+
+* Raise error when you try to stub/spy a method that doesn't exist
+  * when you change your method name your unit tests will break
+* Spy arity matches original method
+  * Your tests will raise an error if you use the wrong arity
+* Spy visibility matches original method
+  * Your tests will raise an error if you try to call the method incorrectly
+* Simple call log api
+  * easier to read tests
+  * less need to look at test framework documentation
+* no expectations
+  * really who thought that was a good idea?
+* absolutely no polution of global object space unless you want to
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'spy'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install spy
+
+## Usage
+
+```ruby
+class Person
+  def first_name
+    "John"
+  end
+
+  def last_name
+    "Smith"
+  end
+
+  def full_name
+    "#{first_name} #{last_name}"
+  end
+
+  def say(words)
+    puts words
+  end
+end
+```
+
+### Standalone
+
+```ruby
+person = Person.new
+
+first_name_spy = Spy.on(person, :first_name)
+person.first_name            #=> nil
+first_name_spy.called?       #=> true
+
+Spy.get(person, :first_name) #=> first_name_spy
+
+Spy.off(person, :first_name)
+person.first_name          #=> "John"
+
+first_name_spy.hook        #=> first_name_spy
+first_name_spy.and_return("Bob")
+person.first_name          #=> "Bob"
+
+Spy.teardown
+person.first_name #=> "John"
+
+say_spy = Spy.on(person, :say)
+person.say("hello") {
+  "everything accepts a block in ruby"
+}
+say_spy.say("world")
+
+say_spy.called_with?("hello") #=> true
+say_spy.calls.count               #=> 1
+say_spy.calls.first.args          #=> ["hello"]
+say_spy.calls.last.args           #=> ["world"]
+
+call_log = say_spy.calls.first
+call_log.object     #=> #<Person:0x00000000b2b858>
+call_log.args       #=> ["hello"]
+call_log.block      #=> #<Proc:0x00000000b1a9e0>
+call_log.block.call #=> "everything accepts a block in ruby"
+```
+
+### MiniTest
+
+```ruby
+require "spy"
+MiniTest::TestCase.add_teardown_hook { Spy.teardown }
+```
+
+### Rspec
+
+In spec\_helper.rb
+
+```ruby
+require "rspec/autorun"
+require "spy"
+RSpec.configure do |c|
+  c.before { Spy.teardown  }
+end
+```
+
+### Test::Unit
+
+```ruby
+require "spy"
+class Test::Unit::TestCase
+  def setup
+    Spy.teardown
+  end
+end
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,8 @@
+require "bundler/gem_tasks"
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList['test/**/test*.rb']
+  t.verbose = true
+end

data/TODO.md

@@ -0,0 +1,8 @@
+# Todo
+
+* and_yield
+* and_raise
+* spy on CONSTANTS
+* argument matchers
+* count matchers
+* watch all calls to an object

data/lib/spy.rb

@@ -0,0 +1,259 @@
+require "spy/version"
+require "spy/double"
+require "spy/dsl"
+
+class Spy
+  CallLog = Struct.new(:object, :args, :block)
+
+  attr_reader :base_object, :method_name, :calls, :original_method
+  def initialize(object, method_name)
+    @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 = {})
+    raise "#{method_name} method has already been hooked" if hooked?
+    raise "#{base_object} method '#{method_name}' has already been hooked" if self.class.get(base_object, method_name)
+    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
+
+    if original_method && original_method.owner == base_object.singleton_class
+      base_object.singleton_class.send(:remove_method, method_name)
+    end
+
+    __method_spy__ = self
+    base_object.define_singleton_method(method_name) do |*__spy_args, &block|
+      if __spy_args.first === __method_spy__.class.__secret_method_key__
+        __method_spy__
+      else
+        __method_spy__.record(self,__spy_args,block)
+      end
+    end
+
+    base_object.singleton_class.send(opts[:visibility], method_name) if opts[:visibility]
+
+    @hooked = true
+    self
+  end
+
+  # unhooks method from object
+  # @return self
+  def unhook
+    raise "#{method_name} method has not been hooked" unless hooked?
+    base_object.singleton_class.send(:remove_method, method_name)
+    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
+    end
+    clear_method!
+    self
+  end
+
+  # is the spy hooked?
+  # @return Boolean
+  def hooked?
+    @hooked
+  end
+
+
+  # sets the return value of given spied method
+  # @params return value
+  # @params return block
+  # @return self
+  def and_return(value = nil, &block)
+    if block_given?
+      raise ArgumentError.new("value and block conflict. Choose one") if !value.nil?
+      @plan = block
+    else
+      @plan = Proc.new { value }
+    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 has_been_called?
+    calls.size > 0
+  end
+
+  # check if the method was called with the exact arguments
+  def has_been_called_with?(*args)
+    calls.any? do |call_log|
+      call_log.args == args
+    end
+  end
+
+  # record that the method has been called. You really shouldn't use this
+  # method.
+  def record(object, args, block)
+    check_arity!(args.size)
+    calls << CallLog.new(object, args, block)
+    @plan.call(*args, &block) if @plan
+  end
+
+  # reset the call log
+  def reset!
+    @calls = []
+    clear_method!
+    true
+  end
+
+  private
+
+  def clear_method!
+    @hooked = false
+    @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)
+    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 arity_range
+    @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
+
+  class << self
+    # create a spy on given object
+    # @params base_object
+    # @params method_names *[Symbol] will spy on these methods
+    # @params method_names [Hash] will spy on these methods and also set default return values
+    # @return [Spy, Array<Spy>]
+    def on(base_object, *method_names)
+      spies = method_names.map do |method_name|
+        create_and_hook_spy(base_object, method_name)
+      end.flatten
+
+      spies.size > 1 ? spies : spies.first
+    end
+
+    # removes the spy from the
+    def off(base_object, *method_names)
+      removed_spies = method_names.map do |method_name|
+        unhook_and_remove_spy(base_object, method_name)
+      end.flatten
+
+      raise "No spies found" if removed_spies.empty?
+      removed_spies.size > 1 ? removed_spies : removed_spies.first
+    end
+
+    # get all hooked methods
+    # @return [Array<Spy>]
+    def all
+      @all ||= []
+    end
+
+    # unhook all methods
+    def teardown
+      all.each(&:unhook)
+      reset
+    end
+
+    # reset all hooked methods
+    def reset
+      @all = nil
+    end
+
+    # (see Double#new)
+    def double(*args)
+      Double.new(*args)
+    end
+
+    # @private
+    def __secret_method_key__
+      @__secret_method_key__ ||= Object.new
+    end
+
+    # retrieve the spy from an object
+    # @params base_object
+    # @method_names *[Symbol, Hash]
+    def get(base_object, *method_names)
+      spies = method_names.map do |method_name|
+        if base_object.singleton_methods.include?(method_name.to_sym) && base_object.method(method_name).parameters == [[:rest, :__spy_args], [:block, :block]]
+          base_object.send(method_name, __secret_method_key__)
+        end
+      end
+
+      spies.size > 1 ? spies : spies.first
+    end
+
+    private
+
+    def create_and_hook_spy(base_object, method_name, opts = {})
+      case method_name
+      when String, Symbol
+        spy = new(base_object, method_name).hook(opts)
+        all << spy
+        spy
+      when Hash
+        method_name.map do |name, result|
+          create_and_hook_spy(base_object, name, opts).and_return(result)
+        end
+      else
+        raise ArgumentError.new "#{method_name.class} is an invalid class, #on only accepts String, Symbol, and Hash"
+      end
+    end
+
+    def unhook_and_remove_spy(base_object, method_name)
+      removed_spies = []
+      all.delete_if do |spy|
+        if spy.base_object == base_object && spy.method_name == method_name
+          removed_spies << spy.unhook
+        end
+      end
+      removed_spies
+    end
+  end
+end