crispy 0.1.2 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d8c2e227c900fbd250845f513639e9b1815d1d22
-  data.tar.gz: f4bcd6597bb277ad1cbe8227f97ca7f3933d337f
+  metadata.gz: a5a304875b84ee789d83ba6420f4b57a2cd769d3
+  data.tar.gz: 50dddf1394a740c51c7a15dbfd5d4bd3227388b8
 SHA512:
-  metadata.gz: 30f2c2baa3ee316befcc6bde7e6c01663bedaed3ef922c7bcb249b4644723c396e87cd889e70fc72a90a23aedf373101355365f682942d95abed2e23fce01004
-  data.tar.gz: 75edd3b7832f9332111bfc6bfa457729292195f5b3a2629ba8f9b555b073a6321f7afcc02e6324ba2ea4e5f67813ee07fd97fc5a1fa7ad3a0ca35003218eced8
+  metadata.gz: 469caadde79084134b26358634de2830d156233e938b4ad2c1a21dd6653d0bd50d019530e6c5ad80bcf9b5e59526b135572bc8939b5d160b2f4a3f10129d79d8
+  data.tar.gz: 902018025f544c073758117e5072896cb7dbf5b6cbc2a41f52b6116036a485a24ff23090e36718d94fdabe0ca7b9a27c21fa18db2bf61be6e255247029c2c58d

data/.travis.yml

@@ -3,9 +3,23 @@ install:
   - gem install bundler
   - bundle
 rvm:
-  - 2.1.1
+  - ruby-head
+  - 2.2.0-preview1
+  - 2.1.3
   - 2.0.0
-  - rbx-2
 script:
-  - bundle exec ruby test/test_crispy.rb
-  - bundle exec rubydoctest README.md
+  - CODECLIMATE_REPO_TOKEN=fe75ea4329c1e131ef79de66f8ba2f605fa2fd352bbbd61fed5024cb6eaaba73 bundle exec rubydoctest README.md
+  - CODECLIMATE_REPO_TOKEN=fe75ea4329c1e131ef79de66f8ba2f605fa2fd352bbbd61fed5024cb6eaaba73 bundle exec ruby test/test_crispy.rb
+notifications:
+  email:
+    recipients:
+      - whosekiteneverfly@gmail.com
+    on_success: never
+    on_failure: never
+addons:
+  code_climate:
+    repo_token: 4329c1e131ef79de66f8ba2f605fa2fd352bbbd61fed5024cb6eaaba73
+matrix:
+  allow_failures:
+    - rvm: ruby-head
+    - rvm: 2.2.0-preview1

data/ChangeLog.md

@@ -1,3 +1,13 @@
+# 0.2.0 (2014.11.1)
+
+- New Feature: `stub_const`. [#11](https://github.com/igrep/crispy/pull/11)
+- New Feature: `spy_into_instances`, `spy_of_instances`. [#17](https://github.com/igrep/crispy/pull/17)
+- New Feature: `spy().stop`, `spy().restart`. [#17](https://github.com/igrep/crispy/pull/17)
+- Compatibility Change: change module structure. [#11](https://github.com/igrep/crispy/pull/11)
+    - Now public modules are prefixed with `Crispy` instead of `Crispy::`.
+    - Because it seems that we can't refer with `Crispy::World` when including the top level `::Crispy` module.
+    - So now we can refer with `CrispyWorld` by including `::Crispy`
+
 # 0.1.2 (2014.8.24)
 
 - Support Ruby 2.0 correctly.

data/Gemfile

@@ -2,3 +2,5 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in crispy.gemspec
 gemspec
+
+gem 'codeclimate-test-reporter', group: :test, require: nil

data/README.md

@@ -1,5 +1,10 @@
 # Crispy
 
+[![Code Climate](https://codeclimate.com/github/igrep/crispy/badges/gpa.svg)](https://codeclimate.com/github/igrep/crispy)
+[![Test Coverage](https://codeclimate.com/github/igrep/crispy/badges/coverage.svg)](https://codeclimate.com/github/igrep/crispy)
+[![Build Status](https://travis-ci.org/igrep/crispy.svg?branch=master)](https://travis-ci.org/igrep/crispy)
+[![Gem Version](https://badge.fury.io/rb/crispy.svg)](http://badge.fury.io/rb/crispy)
+
 Test Spy for Any Object in Ruby.
 
 ## Features
@@ -30,7 +35,7 @@ Or install it yourself as:
 doctest_require: './test/doctest-fixtures/your_cool_class.rb'
 -->
 
-### Spy on a Object
+### Spy on an Object
 
 ```ruby
 >> require 'crispy'
@@ -96,7 +101,7 @@ Each argument is compared by `==` method.
 #### Get more detailed log
 
 You can check arbitrary received methods with the familliar Array's (and of course including Enumerable's!) methods such as `any?`, `all`, `first`, `[]`, `index`.
-Because `spy(object).received_messages` returns an array of `Crispy::ReceivedMessage` instances.
+Because `spy(object).received_messages` returns an array of `CrispyReceivedMessage` instances.
 **You don't have to remember the tons of matchers for received arguments any more!!**
 
 ```ruby
@@ -113,6 +118,76 @@ Because `spy(object).received_messages` returns an array of `Crispy::ReceivedMes
 => true
 ```
 
+### Spy on Instances of a Class
+
+```ruby
+>> spy_into_instances(YourCoolClass)
+>> instance1 = YourCoolClass.new
+>> instance2 = YourCoolClass.new
+
+>> instance1.your_cool_method 'and', 'args'
+>> instance2.your_lovely_method
+>> instance2.your_lovely_method 'again!'
+>> instance1.your_finalizer 'cleaning up...'
+```
+
+You can check methods called by all instances of a class by the same query methods wth spy.
+
+```ruby
+>> spy_of_instances(YourCoolClass).received? :your_cool_method, 'and', 'args'
+=> true
+
+>> spy_of_instances(YourCoolClass).count_received :your_lovely_method
+=> 2
+
+>> spy_of_instances(YourCoolClass).received_messages.last.method_name == :your_finalizer
+=> true
+```
+
+In addition, you can check which instance calles a method as well as its arguments.
+
+```ruby
+>> spy_of_instances(YourCoolClass).received_with_receiver? instance1, :your_cool_method
+=> true
+>> spy_of_instances(YourCoolClass).received_with_receiver? instance2, :your_cool_method
+=> false
+
+>> spy_of_instances(YourCoolClass).count_received_with_receiver instance1, :your_lovely_method
+=> 0
+>> spy_of_instances(YourCoolClass).count_received_with_receiver instance2, :your_lovely_method
+=> 2
+
+>> spy_of_instances(YourCoolClass).received_messages_with_receiver.last.receiver == instance1
+=> true
+```
+
+Note that `spy_of_instances` stops to spy after called methods with `with_receiver` (or `with_receiver?`) prefix.
+This is to prevent the spy from unexpectedly logging methods used to compare its receiver (such as `==`).
+
+```ruby
+>> spy_into_instances(YourCoolClass::Again)
+>> instance = YourCoolClass::Again.new
+
+>> instance.your_another_method
+>> # Stops spying here.
+>> spy_of_instances(YourCoolClass::Again).received_with_receiver? instance, :your_another_method
+
+>> # Perhaps you don't want to log methods in test code.
+>> instance.some_method_for_testing
+>> spy_of_instances(YourCoolClass::Again).received? :some_method_for_testing
+>> false
+```
+
+If you want to restart spying, use `restart` method literally.
+
+```ruby
+>> spy_into_instances(YourCoolClass::Again).restart
+
+>> instance.some_method_for_testing
+>> spy_of_instances(YourCoolClass::Again).received? :some_method_for_testing
+>> true
+```
+
 ### Stub Methods of a Spy
 
 ```ruby
@@ -141,6 +216,28 @@ Because `spy(object).received_messages` returns an array of `Crispy::ReceivedMes
 => "can be stubbed."
 ```
 
+### Stub Constants
+
+Specify the **fully qualified name of the constant** instead of the constant itself.
+
+```ruby
+>> YourCoolClass::YOUR_COOL_CONST
+=> "value before stubbed"
+
+>> stub_const 'YourCoolClass::YOUR_COOL_CONST', 'more cool value!'
+>> YourCoolClass::YOUR_COOL_CONST
+=> "more cool value!"
+```
+
+Then you can recover the stubbed constant value by `CrispyWorld.reset`.
+
+```ruby
+>> CrispyWorld.reset
+
+>> YourCoolClass::YOUR_COOL_CONST
+=> "value before stubbed"
+```
+
 ## Contributing
 
 1. Fork it ( https://github.com/igrep/crispy/fork )

data/crispy.gemspec

@@ -7,9 +7,9 @@ Gem::Specification.new do |spec|
   spec.version       = Crispy::VERSION
   spec.authors       = ["Yamamoto Yuji"]
   spec.email         = ["whosekiteneverfly@gmail.com"]
-  spec.summary       = %q{Test spy for any object in Ruby.}
+  spec.summary       = %q{Test spy for any object.}
   spec.description   =
-    "Test spy for any object in Ruby.\n" \
+    "Test spy for any object.\n" \
     "It makes mocks obsolete so you don't have to be worried about " \
     "where to put the expectations (i.e. before or after the subject method)."
   spec.homepage      = "https://github.com/igrep/crispy"
@@ -24,6 +24,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rake"
   spec.add_development_dependency "minitest", "~> 5.4"
   spec.add_development_dependency "pry"
+  spec.add_development_dependency "byebug"
   spec.add_development_dependency "rubydoctest"
 
   spec.required_ruby_version = '>= 2.0'

data/lib/crispy/crispy_internal/class_spy.rb

@@ -0,0 +1,104 @@
+require 'crispy/crispy_received_message_with_receiver'
+require 'crispy/crispy_internal/spy_mixin'
+require 'crispy/crispy_internal/with_stubber'
+
+module Crispy
+  module CrispyInternal
+    class ClassSpy < ::Module
+      include SpyMixin
+      #include WithStubber
+
+      @registry = {}
+
+      def initialize klass#, stubs_map = {}
+        spy = self
+        super() do
+          define_method(:__CRISPY_CLASS_SPY__) { spy }
+        end
+
+        @received_messages_with_receiver = []
+        initialize_spy
+
+        #initialize_stubber stubs_map
+        #prepend_stubber klass
+
+        prepend_features klass
+        self.class.register spy: spy, of_class: klass
+      end
+
+      def received_messages
+        @received_messages_with_receiver.map {|m| m.received_message }
+      end
+
+      def received_messages_with_receiver
+        # stop spying in advance to prevent from unexpectedly spying receiver's methods in test code.
+        self.stop
+        @received_messages_with_receiver
+      end
+
+      COMMON_RECEIVED_MESSAGE_METHODS_DEFINITION.each do|method_name, core_definition|
+        method_name_with_receiver = method_name.sub(/\??\z/) do|question_mark|
+          "_with_receiver#{question_mark}"
+        end
+
+        binding.eval(<<-END, __FILE__, (__LINE__ + 1))
+          def #{method_name_with_receiver} receiver, received_method_name, *received_arguments, &received_block
+            assert_symbol! received_method_name
+            if received_arguments.empty? and received_block.nil?
+              recevier_and_received_method_name = [receiver, received_method_name]
+              received_messages_with_receiver.map do|received_message_with_receiver|
+                [received_message_with_receiver.receiver, received_message_with_receiver.method_name]
+              end.#{sprintf(core_definition, 'recevier_and_received_method_name')}
+            else
+              received_message_with_receiver = ::Crispy::CrispyReceivedMessageWithReceiver.new(
+                receiver, received_method_name, *received_arguments, &received_block
+              )
+              received_messages_with_receiver.#{sprintf(core_definition, 'received_message_with_receiver')}
+            end
+          end
+        END
+      end
+
+      def erase_log
+        @received_messages_with_receiver.clear
+      end
+
+      def append_received_message_with_receiver receiver, method_name, *arguments, &attached_block
+        if @spying
+          @received_messages_with_receiver <<
+            ::Crispy::CrispyReceivedMessageWithReceiver.new(receiver, method_name, *arguments, &attached_block)
+        end
+      end
+
+      def define_wrapper method_name
+        define_method method_name do|*arguments, &attached_block|
+          __CRISPY_CLASS_SPY__.append_received_message_with_receiver self, method_name, *arguments, &attached_block
+
+          super(*arguments, &attached_block)
+        end
+        method_name
+      end
+      private :define_wrapper
+
+      def self.new klass#, stubs_map = {}
+        spy = self.of_class(klass)
+        if spy
+          spy.restart
+          spy.erase_log
+          spy
+        else
+          super
+        end
+      end
+
+      def self.register(spy: nil, of_class: nil)
+        @registry[of_class] = spy
+      end
+
+      def self.of_class(klass)
+        @registry[klass]
+      end
+
+    end
+  end
+end

data/lib/crispy/crispy_internal/const_changer.rb

@@ -0,0 +1,42 @@
+module Crispy
+  module CrispyInternal
+    module ConstChanger
+
+      @registry = {}
+
+      class << self
+
+        def change_by_full_name full_const_name, value
+          const_names = full_const_name.split('::'.freeze)
+
+          const_names.shift if const_names.first.empty?
+
+          target_const_name = const_names.pop
+
+          module_containing_target_const =
+            const_names.inject(::Kernel) do|const_value, const_name|
+              const_value.const_get const_name
+            end
+
+          saved_value = module_containing_target_const.module_eval do
+            remove_const target_const_name
+          end
+          module_containing_target_const.const_set target_const_name, value
+
+          saved_value
+        end
+
+        def save full_const_name, value
+          @registry[full_const_name] = value
+        end
+
+        def recover_all
+          @registry.each do|full_const_name, saved_value|
+            self.change_by_full_name(full_const_name, saved_value)
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/crispy/crispy_internal/spy.rb

@@ -1,4 +1,4 @@
-require 'crispy/crispy/received_message'
+require 'crispy/crispy_received_message'
 require 'crispy/crispy_internal/spy_mixin'
 require 'crispy/crispy_internal/with_stubber'
 
@@ -8,9 +8,17 @@ module Crispy
       include SpyMixin
       include WithStubber
 
+      attr_reader :received_messages
+
       def initialize target, stubs_map = {}
-        super()
+        super() do
+          spy = self
+          define_method(:__CRISPY_SPY__) { spy }
+        end
+
         @received_messages = []
+        initialize_spy
+
         singleton_class =
           class << target
             self
@@ -19,29 +27,23 @@ module Crispy
         prepend_stubber singleton_class
 
         prepend_features singleton_class
-        target.__CRISPY_SPY__ = self
       end
 
-      def prepend_features klass
-        super
-        klass.public_instance_methods.each do|method_name|
-          self.module_eval { public define_wrapper(method_name) }
-        end
-        klass.protected_instance_methods.each do|method_name|
-          self.module_eval { protected define_wrapper(method_name) }
-        end
-        klass.private_instance_methods.each do|method_name|
-          self.module_eval { private define_wrapper(method_name) }
-        end
+      def erase_log
+        @received_messages.clear
+      end
 
-        # define accessor after prepending to avoid to spy unexpectedly.
-        module_eval { attr_accessor :__CRISPY_SPY__ }
+      def append_received_message method_name, *arguments, &attached_block
+        if @spying
+          @received_messages <<
+            ::Crispy::CrispyReceivedMessage.new(method_name, *arguments, &attached_block)
+        end
       end
 
       def define_wrapper method_name
         define_method method_name do|*arguments, &attached_block|
-          @__CRISPY_SPY__.received_messages <<
-            ::Crispy::Crispy::ReceivedMessage.new(method_name, *arguments, &attached_block)
+          __CRISPY_SPY__.append_received_message(method_name, *arguments, &attached_block)
+
           super(*arguments, &attached_block)
         end
         method_name

data/lib/crispy/crispy_internal/spy_mixin.rb

@@ -1,34 +1,80 @@
-require 'crispy/crispy/received_message'
+require 'crispy/crispy_received_message'
 
 module Crispy
   module CrispyInternal
     module SpyMixin
 
-      attr_reader :received_messages
+      BLACK_LISTED_METHODS = [
+        :__CRISPY_CLASS_SPY__,
+        :__CRISPY_SPY__,
+      ]
 
-      def received? method_name, *arguments, &attached_block
-        if arguments.empty? and attached_block.nil?
-          @received_messages.map(&:method_name).include? method_name
-        else
-          @received_messages.include? ::Crispy::Crispy::ReceivedMessage.new(method_name, *arguments, &attached_block)
-        end
+      def received_messages
+        raise NotImplementedError
+      end
+
+      def erase_log
+        raise NotImplementedError
+      end
+
+      def stop
+        @spying = false
       end
 
-      def received_once? method_name, *arguments, &attached_block
-        if arguments.empty? and attached_block.nil?
-          @received_messages.map(&:method_name).one? {|self_method_name| self_method_name == method_name }
-        else
-          @received_messages.one? do |self_received_message|
-            self_received_message == ::Crispy::Crispy::ReceivedMessage.new(method_name, *arguments, &attached_block)
+      def restart
+        @spying = true
+      end
+
+      COMMON_RECEIVED_MESSAGE_METHODS_DEFINITION = {
+        'received?'      => 'include? %s',
+        'received_once?' => 'one? {|self_thing| self_thing == %s }',
+        'count_received' => 'count %s',
+      }
+
+      COMMON_RECEIVED_MESSAGE_METHODS_DEFINITION.each do|method_name, core_definition|
+        binding.eval(<<-END, __FILE__, (__LINE__ + 1))
+          def #{method_name} received_method_name, *received_arguments, &received_block
+            assert_symbol! received_method_name
+            if received_arguments.empty? and received_block.nil?
+              received_messages.map(&:method_name).#{sprintf(core_definition, 'received_method_name')}
+            else
+              received_message = ::Crispy::CrispyReceivedMessage.new(
+                received_method_name, *received_arguments, &received_block
+              )
+              received_messages.#{sprintf(core_definition, 'received_message')}
+            end
           end
+        END
+      end
+
+      def prepend_features klass
+        super
+
+        without_black_listed_methods(klass.public_instance_methods).each do|method_name|
+          self.module_eval { define_wrapper(method_name) }
+        end
+        klass.protected_instance_methods.each do|method_name|
+          self.module_eval { protected define_wrapper(method_name) }
+        end
+        klass.private_instance_methods.each do|method_name|
+          self.module_eval { private define_wrapper(method_name) }
         end
       end
+      private :prepend_features
+
+      def without_black_listed_methods method_names
+        method_names.reject {|method_name| BLACK_LISTED_METHODS.include? method_name }
+      end
+      private :without_black_listed_methods
+
+      def initialize_spy
+        @spying = true
+      end
+      private :initialize_spy
 
-      def count_received method_name, *arguments, &attached_block
-        if arguments.empty? and attached_block.nil?
-          @received_messages.map(&:method_name).count method_name
-        else
-          @received_messages.count ::Crispy::Crispy::ReceivedMessage.new(method_name, *arguments, &attached_block)
+      def assert_symbol! maybe_symbol
+        unless maybe_symbol.respond_to?(:to_sym) && maybe_symbol.to_sym.instance_of?(::Symbol)
+          raise TypeError, "TypeError: no implicit conversion from #{maybe_symbol.inspect} to symbol"
         end
       end
 

data/lib/crispy/crispy_received_message.rb

@@ -0,0 +1,52 @@
+module Crispy
+  class CrispyReceivedMessage
+
+    DELEGATABLE_METHODS = [:method_name, :arguments, :attached_block]
+
+    attr_reader(*DELEGATABLE_METHODS)
+
+    class << self
+      alias [] new
+    end
+
+    def initialize method_name, *arguments, &attached_block
+      @method_name = method_name
+      @arguments = arguments
+      @attached_block = attached_block
+    end
+
+    def == other
+      @method_name == other.method_name &&
+      @arguments == other.arguments &&
+      @attached_block == other.attached_block
+    end
+
+    CLASS_NAME = self.name
+
+    def to_s
+      "#<#{CLASS_NAME}[#{(@method_name).inspect}, *#{@arguments.inspect}]>"
+    end
+
+    alias inspect to_s
+
+    PP_HEADER = "#<#{CLASS_NAME}["
+
+    def pretty_print pp
+      pp.group 2, PP_HEADER do
+        pp.pp @method_name
+        pp.text ','.freeze
+        pp.breakable
+        pp.text '*'.freeze
+        pp.pp @arguments
+        pp.text ']>'.freeze
+      end
+    end
+
+    PP_CYCLE = "#{PP_HEADER}...]>"
+
+    def pretty_print_cycle pp
+      pp.text PP_CYCLE
+    end
+
+  end
+end

data/lib/crispy/crispy_received_message_with_receiver.rb

@@ -0,0 +1,61 @@
+require 'crispy/crispy_received_message'
+
+module Crispy
+  class CrispyReceivedMessageWithReceiver
+    attr_reader :receiver, :received_message
+
+    class << self
+      alias [] new
+    end
+
+    CrispyReceivedMessage::DELEGATABLE_METHODS.each do|method_name|
+      binding.eval(<<-END, __FILE__, (__LINE__ + 1))
+        def #{method_name}
+          @received_message.#{method_name}
+        end
+      END
+    end
+
+    def initialize receiver, method_name, *arguments, &attached_block
+      @received_message = CrispyReceivedMessage.new(method_name, *arguments, &attached_block)
+      @receiver = receiver
+    end
+
+    def == other
+      @receiver == other.receiver && @received_message == other.received_message
+    end
+
+    CLASS_NAME = self.name
+
+    def to_s
+      "#<#{CLASS_NAME}[#{@receiver.inspect}, #{(@received_message.method_name).inspect}, *#{@received_message.arguments.inspect}]>"
+    end
+
+    alias inspect to_s
+
+    PP_HEADER = "#<#{CLASS_NAME}["
+
+    def pretty_print pp
+      pp.group 2, PP_HEADER do
+        pp.pp @receiver
+        pp.text ','.freeze
+        pp.breakable
+
+        pp.pp @received_message.method_name
+        pp.text ','.freeze
+        pp.breakable
+
+        pp.text '*'.freeze
+        pp.pp @received_message.arguments
+        pp.text ']>'.freeze
+      end
+    end
+
+    PP_CYCLE = "#{PP_HEADER}...]>"
+
+    def pretty_print_cycle pp
+      pp.text PP_CYCLE
+    end
+
+  end
+end

data/lib/crispy/crispy_world.rb

@@ -0,0 +1,13 @@
+require 'crispy/crispy_internal/const_changer'
+
+module Crispy
+  module CrispyWorld
+    class << self
+
+      def reset
+        ::Crispy::CrispyInternal::ConstChanger.recover_all
+      end
+
+    end
+  end
+end

data/lib/crispy/version.rb

@@ -1,3 +1,3 @@
 module Crispy
-  VERSION = "0.1.2"
+  VERSION = "0.2.0"
 end

data/lib/crispy.rb

@@ -1,6 +1,8 @@
 require "crispy/version"
 require "crispy/crispy_internal/spy"
+require "crispy/crispy_internal/class_spy"
 require "crispy/crispy_internal/double"
+require "crispy/crispy_world"
 
 module Crispy
   # All methods of this module should be module_function.
@@ -16,8 +18,7 @@ module Crispy
   end
 
   # Make and returns a Crispy::ClassSpy's instance to spy all instances of a class.
-  def spy_on_any_instance_of klass
-    raise NotImplementedError, "Sorry, this feature is under construction :("
+  def spy_into_instances klass#, stubs_map = {}
     ::Crispy::CrispyInternal::ClassSpy.new klass
   end
 
@@ -25,17 +26,13 @@ module Crispy
     object.__CRISPY_SPY__
   end
 
-  # Begins to log all instances and its received messages of a class.
-  # _NOTE_: replace the constant containing the class
-  def spy_into_class! klass
-    raise NotImplementedError, "Sorry, this feature is under construction :("
-    spy_class = spy_on_any_instance_of klass
-    stub_const! klass.name, spy_class
-    spy_class
+  def spy_of_instances klass
+    ::Crispy::CrispyInternal::ClassSpy.of_class(klass)
   end
 
-  def stub_const! const_name, value
-    raise NotImplementedError, "Sorry, this feature is under construction :("
+  def stub_const full_const_name, value
+    saved_value = ::Crispy::CrispyInternal::ConstChanger.change_by_full_name full_const_name, value
+    ::Crispy::CrispyInternal::ConstChanger.save full_const_name, saved_value
   end
 
 end

data/test/doctest-fixtures/your_cool_class.rb

@@ -1,4 +1,5 @@
 class YourCoolClass
+  YOUR_COOL_CONST = 'value before stubbed'.freeze
   def your_cool_method *args
   end
   def your_method_without_argument
@@ -7,4 +8,11 @@ class YourCoolClass
   end
   def your_finalizer *args
   end
+
+  class Again < self
+    def your_another_method *args
+    end
+    def some_method_for_testing
+    end
+  end
 end

data/test/test_crispy.rb

@@ -1,6 +1,7 @@
 $VERBOSE = true # enable warnings
 
 require 'crispy'
+require_relative 'test_helper'
 require 'minitest/autorun'
 
 class TestCrispy < MiniTest::Test
@@ -8,6 +9,9 @@ class TestCrispy < MiniTest::Test
 
   # Inherit BasicObject because it has fewer meta-programming methods than Object
   class ObjectClass < BasicObject
+
+    CONSTANT_TO_STUB = ::Crispy.double('value_before_stubbed')
+
     def hoge a, b, c
       private_foo a
       [a, b, c]
@@ -18,6 +22,8 @@ class TestCrispy < MiniTest::Test
     def bar
       []
     end
+    def baz
+    end
     def method_to_stub1
       fail "Not stubbed actually! The test fails."
     end
@@ -32,6 +38,25 @@ class TestCrispy < MiniTest::Test
 
   end
 
+  class TestCrispyStubConst < TestCrispy
+
+    def setup
+      @saved_value = ::TestCrispy::ObjectClass::CONSTANT_TO_STUB
+      @stubbbed_value = double('value_after_stubbed')
+      stub_const '::TestCrispy::ObjectClass::CONSTANT_TO_STUB', @stubbbed_value
+    end
+
+    def test_stubbed_const_value_changes_into_2nd_argument_value
+      assert_same @stubbbed_value, ::TestCrispy::ObjectClass::CONSTANT_TO_STUB
+    end
+
+    def test_stubbed_const_value_changes_back_after_resetting
+      CrispyWorld.reset
+      assert_same @saved_value, ::TestCrispy::ObjectClass::CONSTANT_TO_STUB
+    end
+
+  end
+
   class TestCrispySpyInto < TestCrispy
 
     def setup
@@ -51,11 +76,11 @@ class TestCrispy < MiniTest::Test
     def test_spy_logs_messages_sent_to_an_object
       assert_equal(
         [
-          Crispy::ReceivedMessage[:hoge, 1, 2, 3],
-          Crispy::ReceivedMessage[:private_foo, 1],
-          Crispy::ReceivedMessage[:foo],
-          Crispy::ReceivedMessage[:hoge, 3, 4, 5],
-          Crispy::ReceivedMessage[:private_foo, 3],
+          CrispyReceivedMessage[:hoge, 1, 2, 3],
+          CrispyReceivedMessage[:private_foo, 1],
+          CrispyReceivedMessage[:foo],
+          CrispyReceivedMessage[:hoge, 3, 4, 5],
+          CrispyReceivedMessage[:private_foo, 3],
         ],
         @subject.received_messages
       )
@@ -113,6 +138,311 @@ class TestCrispy < MiniTest::Test
       assert_same @subject, @returned_spy
     end
 
+    def test_spy_raises_error_given_non_symbol_as_method_name
+      assert_raises(::TypeError){ @subject.received_once?(nil) }
+      assert_raises(::TypeError){ @subject.received_once?(nil) }
+      assert_raises(::TypeError){ @subject.count_received(nil) }
+    end
+
+  end
+
+  class TestCrispySpyIntoInstances < TestCrispy
+
+    def object_class
+      raise NotImplementedError
+    end
+
+    def setup
+      @returned_spy = spy_into_instances(
+        object_class#, method_to_stub1: :stubbed_instance_method1, method_to_stub2: :stubbed_instance_method2
+      )
+
+      @subject = spy_of_instances(object_class)
+      @object_instances = Array.new(3){ object_class.new }
+
+      @object_instances[0].hoge 3, 4, 5
+      @object_instances[1].hoge 1, 2, 3
+      @object_instances[0].foo
+      @object_instances[2].hoge 3, 4, 5
+      @object_instances[1].bar
+      @object_instances[2].hoge 7, 8, 9
+      @object_instances[1].bar
+    end
+
+    def teardown
+      CrispyWorld.reset
+    end
+
+    class TestReceivedMessage < self
+
+      def object_class
+        ObjectClass
+      end
+
+      def test_spy_logs_messages_sent_to_instances_of_a_class
+        assert_equal(
+          [
+            CrispyReceivedMessage[:initialize],
+            CrispyReceivedMessage[:initialize],
+            CrispyReceivedMessage[:initialize],
+            CrispyReceivedMessage[:hoge, 3, 4, 5],
+            CrispyReceivedMessage[:private_foo, 3],
+            CrispyReceivedMessage[:hoge, 1, 2, 3],
+            CrispyReceivedMessage[:private_foo, 1],
+            CrispyReceivedMessage[:foo],
+            CrispyReceivedMessage[:hoge, 3, 4, 5],
+            CrispyReceivedMessage[:private_foo, 3],
+            CrispyReceivedMessage[:bar],
+            CrispyReceivedMessage[:hoge, 7, 8, 9],
+            CrispyReceivedMessage[:private_foo, 7],
+            CrispyReceivedMessage[:bar],
+          ],
+          @subject.received_messages_with_receiver
+        )
+      end
+
+      def test_spy_has_received_messages_sent_to_an_object
+        assert @subject.received?(:hoge)
+        assert @subject.received?(:foo)
+        assert not(@subject.received?(:baz))
+        assert @subject.received?(:private_foo)
+      end
+
+      def test_spy_has_received_messages_with_arguments_sent_to_an_object
+        assert @subject.received?(:hoge, 1, 2, 3)
+        assert @subject.received?(:hoge, 3, 4, 5)
+        assert @subject.received?(:private_foo, 1)
+        assert @subject.received?(:private_foo, 3)
+        assert not(@subject.received?(:hoge, 0, 0, 0))
+        assert not(@subject.received?(:private_foo, 0, 0, 0))
+        assert not(@subject.received?(:foo, 1))
+        assert not(@subject.received?(:bar, nil))
+        assert not(@subject.received?(:baz, nil))
+      end
+
+      def test_spy_has_received_messages_once_sent_to_an_object
+        assert not(@subject.received_once?(:hoge))
+        assert not(@subject.received_once?(:private_foo))
+        assert not(@subject.received_once?(:hoge, 3, 4, 5))
+        assert not(@subject.received_once?(:private_foo, 3))
+        assert not(@subject.received_once?(:private_foo, 3, 4))
+        assert @subject.received_once?(:foo)
+        assert not(@subject.received_once?(:bar))
+        assert not(@subject.received_once?(:baz))
+      end
+
+      def test_spy_counts_received_messages_sent_to_an_object
+        assert_equal(1, @subject.count_received(:hoge, 1, 2, 3))
+        assert_equal(2, @subject.count_received(:hoge, 3, 4, 5))
+        assert_equal(0, @subject.count_received(:hoge, 0, 0, 0))
+        assert_equal(4, @subject.count_received(:hoge))
+
+        assert_equal(1, @subject.count_received(:private_foo, 1))
+        assert_equal(2, @subject.count_received(:private_foo, 3))
+        assert_equal(0, @subject.count_received(:private_foo, 0))
+        assert_equal(4, @subject.count_received(:private_foo))
+
+        assert_equal(1, @subject.count_received(:foo))
+        assert_equal(2, @subject.count_received(:bar))
+      end
+
+      def test_spy_raises_error_given_non_symbol_as_method_name
+        assert_raises(::TypeError){ @subject.received_once?(nil) }
+        assert_raises(::TypeError){ @subject.received_once?(nil) }
+        assert_raises(::TypeError){ @subject.count_received(nil) }
+      end
+
+    end
+
+    class TestReceivedMessageWithReceiver < self
+
+      def object_class
+        ObjectClassNonBasic
+      end
+
+      class ObjectClassNonBasic
+
+        def hoge a, b, c
+          private_foo a
+          [a, b, c]
+        end
+        def foo
+          123
+        end
+        def bar
+          []
+        end
+        def baz
+        end
+        def method_to_stub1
+          fail "Not stubbed actually! The test fails."
+        end
+        def method_to_stub2
+          fail "Not stubbed actually! The test fails."
+        end
+
+        def private_foo a
+          :private_foo
+        end
+        private :private_foo
+
+      end
+
+      def test_spy_logs_messages_with_receiver_sent_to_instances_of_a_class
+        assert_equal(
+          [
+            CrispyReceivedMessageWithReceiver[@object_instances[0], :initialize],
+            CrispyReceivedMessageWithReceiver[@object_instances[1], :initialize],
+            CrispyReceivedMessageWithReceiver[@object_instances[2], :initialize],
+            CrispyReceivedMessageWithReceiver[@object_instances[0], :hoge, 3, 4, 5],
+            CrispyReceivedMessageWithReceiver[@object_instances[0], :private_foo, 3],
+            CrispyReceivedMessageWithReceiver[@object_instances[1], :hoge, 1, 2, 3],
+            CrispyReceivedMessageWithReceiver[@object_instances[1], :private_foo, 1],
+            CrispyReceivedMessageWithReceiver[@object_instances[0], :foo],
+            CrispyReceivedMessageWithReceiver[@object_instances[2], :hoge, 3, 4, 5],
+            CrispyReceivedMessageWithReceiver[@object_instances[2], :private_foo, 3],
+            CrispyReceivedMessageWithReceiver[@object_instances[1], :bar],
+            CrispyReceivedMessageWithReceiver[@object_instances[2], :hoge, 7, 8, 9],
+            CrispyReceivedMessageWithReceiver[@object_instances[2], :private_foo, 7],
+            CrispyReceivedMessageWithReceiver[@object_instances[1], :bar],
+          ],
+          @subject.received_messages_with_receiver
+        )
+      end
+
+      def test_spy_has_received_messages_with_receiver_sent_to_an_object
+        assert @subject.received_with_receiver?(@object_instances[0], :hoge)
+        assert @subject.received_with_receiver?(@object_instances[0], :foo)
+        assert not(@subject.received_with_receiver?(@object_instances[0], :baz))
+        assert not(@subject.received_with_receiver?(@object_instances[0], :bar))
+        assert @subject.received_with_receiver?(@object_instances[0], :private_foo)
+
+        assert @subject.received_with_receiver?(@object_instances[1], :hoge)
+        assert not(@subject.received_with_receiver?(@object_instances[1], :foo))
+        assert not(@subject.received_with_receiver?(@object_instances[1], :baz))
+        assert @subject.received_with_receiver?(@object_instances[1], :bar)
+        assert @subject.received_with_receiver?(@object_instances[1], :private_foo)
+
+        assert @subject.received_with_receiver?(@object_instances[2], :hoge)
+        assert not(@subject.received_with_receiver?(@object_instances[2], :foo))
+        assert not(@subject.received_with_receiver?(@object_instances[2], :baz))
+        assert not(@subject.received_with_receiver?(@object_instances[2], :bar))
+        assert @subject.received_with_receiver?(@object_instances[2], :private_foo)
+      end
+
+      def test_spy_has_received_messages_with_receiver_and_arguments_sent_to_an_object
+        assert @subject.received_with_receiver?(@object_instances[0], :hoge, 3, 4, 5)
+        assert @subject.received_with_receiver?(@object_instances[0], :private_foo, 3)
+        assert not(@subject.received_with_receiver?(@object_instances[0], :hoge, 1, 2, 3))
+        assert not(@subject.received_with_receiver?(@object_instances[0], :private_foo, 1))
+        assert not(@subject.received_with_receiver?(@object_instances[0], :foo, 1))
+        assert not(@subject.received_with_receiver?(@object_instances[0], :bar, nil))
+
+        assert @subject.received_with_receiver?(@object_instances[1], :hoge, 1, 2, 3)
+        assert @subject.received_with_receiver?(@object_instances[1], :private_foo, 1)
+        assert not(@subject.received_with_receiver?(@object_instances[1], :hoge, 0, 0, 0))
+        assert not(@subject.received_with_receiver?(@object_instances[1], :private_foo, 0, 0, 0))
+        assert not(@subject.received_with_receiver?(@object_instances[1], :hoge, 3, 4, 5))
+        assert not(@subject.received_with_receiver?(@object_instances[1], :private_foo, 3))
+        assert not(@subject.received_with_receiver?(@object_instances[1], :foo, 1))
+        assert not(@subject.received_with_receiver?(@object_instances[1], :baz, nil))
+
+        assert @subject.received_with_receiver?(@object_instances[2], :hoge, 7, 8, 9)
+        assert @subject.received_with_receiver?(@object_instances[2], :private_foo, 7)
+        assert @subject.received_with_receiver?(@object_instances[2], :hoge, 3, 4, 5)
+        assert @subject.received_with_receiver?(@object_instances[2], :private_foo, 3)
+        assert not(@subject.received_with_receiver?(@object_instances[2], :hoge, 1, 2, 3))
+        assert not(@subject.received_with_receiver?(@object_instances[2], :private_foo, 1))
+        assert not(@subject.received_with_receiver?(@object_instances[2], :hoge, 0, 0, 0))
+        assert not(@subject.received_with_receiver?(@object_instances[2], :private_foo, 0, 0, 0))
+        assert not(@subject.received_with_receiver?(@object_instances[2], :foo, 1))
+        assert not(@subject.received_with_receiver?(@object_instances[2], :bar, nil))
+        assert not(@subject.received_with_receiver?(@object_instances[2], :baz, nil))
+      end
+
+      def test_spy_has_received_messages_with_receiver_once_sent_to_an_object
+        assert @subject.received_once_with_receiver?(@object_instances[0], :hoge)
+        assert @subject.received_once_with_receiver?(@object_instances[0], :private_foo)
+        assert @subject.received_once_with_receiver?(@object_instances[0], :hoge, 3, 4, 5)
+        assert @subject.received_once_with_receiver?(@object_instances[0], :private_foo, 3)
+        assert not(@subject.received_once_with_receiver?(@object_instances[0], :hoge, 1, 2, 3))
+        assert not(@subject.received_once_with_receiver?(@object_instances[0], :private_foo, 1))
+        assert not(@subject.received_once_with_receiver?(@object_instances[0], :private_foo, 3, 4))
+        assert @subject.received_once_with_receiver?(@object_instances[0], :foo)
+        assert @subject.received_once_with_receiver?(@object_instances[0], :initialize)
+        assert not(@subject.received_once_with_receiver?(@object_instances[0], :bar))
+
+        assert @subject.received_once_with_receiver?(@object_instances[1], :hoge)
+        assert @subject.received_once_with_receiver?(@object_instances[1], :private_foo)
+        assert not(@subject.received_once_with_receiver?(@object_instances[1], :hoge, 3, 4, 5))
+        assert not(@subject.received_once_with_receiver?(@object_instances[1], :private_foo, 3))
+        assert @subject.received_once_with_receiver?(@object_instances[1], :hoge, 1, 2, 3)
+        assert @subject.received_once_with_receiver?(@object_instances[1], :private_foo, 1)
+        assert not(@subject.received_once_with_receiver?(@object_instances[1], :private_foo, 1, 2))
+        assert not(@subject.received_once_with_receiver?(@object_instances[1], :foo))
+        assert @subject.received_once_with_receiver?(@object_instances[1], :initialize)
+        assert not(@subject.received_once_with_receiver?(@object_instances[1], :bar))
+        assert not(@subject.received_once_with_receiver?(@object_instances[1], :baz))
+
+        assert not(@subject.received_once_with_receiver?(@object_instances[2], :hoge))
+        assert not(@subject.received_once_with_receiver?(@object_instances[2], :private_foo))
+        assert @subject.received_once_with_receiver?(@object_instances[2], :hoge, 7, 8, 9)
+        assert @subject.received_once_with_receiver?(@object_instances[2], :private_foo, 7)
+        assert not(@subject.received_once_with_receiver?(@object_instances[2], :hoge, 1, 2, 3))
+        assert not(@subject.received_once_with_receiver?(@object_instances[2], :private_foo, 1))
+        assert not(@subject.received_once_with_receiver?(@object_instances[2], :private_foo, 1, 2))
+        assert not(@subject.received_once_with_receiver?(@object_instances[2], :foo))
+        assert @subject.received_once_with_receiver?(@object_instances[2], :initialize)
+        assert not(@subject.received_once_with_receiver?(@object_instances[2], :baz))
+      end
+
+      def test_spy_counts_received_with_receiver_messages_with_receiver_sent_to_an_object
+        assert_equal(1, @subject.count_received_with_receiver(@object_instances[0], :initialize))
+        assert_equal(0, @subject.count_received_with_receiver(@object_instances[0], :initialize, 0))
+        assert_equal(1, @subject.count_received_with_receiver(@object_instances[0], :hoge))
+        assert_equal(1, @subject.count_received_with_receiver(@object_instances[0], :hoge, 3, 4, 5))
+        assert_equal(0, @subject.count_received_with_receiver(@object_instances[0], :hoge, 1, 2, 3))
+        assert_equal(1, @subject.count_received_with_receiver(@object_instances[0], :private_foo))
+        assert_equal(1, @subject.count_received_with_receiver(@object_instances[0], :private_foo, 3))
+        assert_equal(0, @subject.count_received_with_receiver(@object_instances[0], :private_foo, 1))
+        assert_equal(1, @subject.count_received_with_receiver(@object_instances[0], :foo))
+        assert_equal(0, @subject.count_received_with_receiver(@object_instances[0], :bar))
+
+        assert_equal(1, @subject.count_received_with_receiver(@object_instances[1], :initialize))
+        assert_equal(0, @subject.count_received_with_receiver(@object_instances[1], :initialize, 1))
+        assert_equal(1, @subject.count_received_with_receiver(@object_instances[1], :hoge))
+        assert_equal(1, @subject.count_received_with_receiver(@object_instances[1], :hoge, 1, 2, 3))
+        assert_equal(0, @subject.count_received_with_receiver(@object_instances[1], :hoge, 3, 4, 5))
+        assert_equal(1, @subject.count_received_with_receiver(@object_instances[1], :private_foo))
+        assert_equal(1, @subject.count_received_with_receiver(@object_instances[1], :private_foo, 1))
+        assert_equal(0, @subject.count_received_with_receiver(@object_instances[1], :private_foo, 3))
+        assert_equal(0, @subject.count_received_with_receiver(@object_instances[1], :foo))
+        assert_equal(2, @subject.count_received_with_receiver(@object_instances[1], :bar))
+        assert_equal(0, @subject.count_received_with_receiver(@object_instances[1], :bar, 9))
+
+        assert_equal(1, @subject.count_received_with_receiver(@object_instances[2], :initialize))
+        assert_equal(0, @subject.count_received_with_receiver(@object_instances[2], :initialize, 2))
+        assert_equal(2, @subject.count_received_with_receiver(@object_instances[2], :hoge))
+        assert_equal(1, @subject.count_received_with_receiver(@object_instances[2], :hoge, 3, 4, 5))
+        assert_equal(1, @subject.count_received_with_receiver(@object_instances[2], :hoge, 7, 8, 9))
+        assert_equal(0, @subject.count_received_with_receiver(@object_instances[2], :hoge, 1, 2, 3))
+        assert_equal(2, @subject.count_received_with_receiver(@object_instances[2], :private_foo))
+        assert_equal(1, @subject.count_received_with_receiver(@object_instances[2], :private_foo, 3))
+        assert_equal(1, @subject.count_received_with_receiver(@object_instances[2], :private_foo, 7))
+        assert_equal(0, @subject.count_received_with_receiver(@object_instances[2], :private_foo, 1))
+        assert_equal(0, @subject.count_received_with_receiver(@object_instances[2], :foo))
+        assert_equal(0, @subject.count_received_with_receiver(@object_instances[2], :bar))
+        assert_equal(0, @subject.count_received_with_receiver(@object_instances[2], :baz))
+      end
+
+      def test_spy_raises_error_given_non_symbol_as_method_name
+        assert_raises(::TypeError){ @subject.received_once?(@object_instances[0], nil) }
+        assert_raises(::TypeError){ @subject.received_once?(@object_instances[0], nil) }
+        assert_raises(::TypeError){ @subject.count_received(@object_instances[0], nil) }
+      end
+
+    end
+
   end
 
   class TestCrispyDouble < TestCrispy

data/test/test_helper.rb

@@ -0,0 +1,4 @@
+if ENV['CODECLIMATE_REPO_TOKEN']
+  require 'codeclimate-test-reporter'
+  CodeClimate::TestReporter.start
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: crispy
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.0
 platform: ruby
 authors:
 - Yamamoto Yuji
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-24 00:00:00.000000000 Z
+date: 2014-11-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -66,6 +66,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rubydoctest
   requirement: !ruby/object:Gem::Requirement
@@ -81,7 +95,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 description: |-
-  Test spy for any object in Ruby.
+  Test spy for any object.
   It makes mocks obsolete so you don't have to be worried about where to put the expectations (i.e. before or after the subject method).
 email:
 - whosekiteneverfly@gmail.com
@@ -98,15 +112,20 @@ files:
 - Rakefile
 - crispy.gemspec
 - lib/crispy.rb
-- lib/crispy/crispy/received_message.rb
+- lib/crispy/crispy_internal/class_spy.rb
+- lib/crispy/crispy_internal/const_changer.rb
 - lib/crispy/crispy_internal/double.rb
 - lib/crispy/crispy_internal/spy.rb
 - lib/crispy/crispy_internal/spy_mixin.rb
 - lib/crispy/crispy_internal/stubber.rb
 - lib/crispy/crispy_internal/with_stubber.rb
+- lib/crispy/crispy_received_message.rb
+- lib/crispy/crispy_received_message_with_receiver.rb
+- lib/crispy/crispy_world.rb
 - lib/crispy/version.rb
 - test/doctest-fixtures/your_cool_class.rb
 - test/test_crispy.rb
+- test/test_helper.rb
 homepage: https://github.com/igrep/crispy
 licenses:
 - MIT
@@ -130,7 +149,8 @@ rubyforge_project:
 rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
-summary: Test spy for any object in Ruby.
+summary: Test spy for any object.
 test_files:
 - test/doctest-fixtures/your_cool_class.rb
 - test/test_crispy.rb
+- test/test_helper.rb

data/lib/crispy/crispy/received_message.rb

@@ -1,25 +0,0 @@
-module Crispy
-  module Crispy
-    class ReceivedMessage
-
-      attr_reader :method_name, :arguments, :attached_block
-
-      class << self
-        alias [] new
-      end
-
-      def initialize method_name, *arguments, &attached_block
-        @method_name = method_name
-        @arguments = arguments
-        @attached_block = attached_block
-      end
-
-      def == other
-        @method_name == other.method_name &&
-        @arguments == other.arguments &&
-        @attached_block == other.attached_block
-      end
-
-    end
-  end
-end