rr 1.1.2 → 1.2.0

data/lib/rr/dsl.rb

@@ -0,0 +1,152 @@
+module RR
+  module DSL
+    METHODS_TO_EXCLUDE_FROM_SPYING = [
+      :methods,
+      :==,
+      :__send__,
+      :__id__,
+      :object_id,
+      :class,
+      :respond_to?,
+      :inspect,
+      :to_s,
+      :respond_to_missing?,
+      :instance_eval,
+      :instance_exec
+    ]
+
+    include DoubleDefinitions::Strategies::StrategyMethods
+
+    def mock(subject=DoubleDefinitions::DoubleDefinitionCreate::NO_SUBJECT, method_name=nil, &definition_eval_block)
+      double_definition_create = DoubleDefinitions::DoubleDefinitionCreate.new
+      double_definition_create.mock(subject, method_name, &definition_eval_block)
+    end
+
+    def stub(subject=DoubleDefinitions::DoubleDefinitionCreate::NO_SUBJECT, method_name=nil, &definition_eval_block)
+      double_definition_create = DoubleDefinitions::DoubleDefinitionCreate.new
+      double_definition_create.stub(subject, method_name, &definition_eval_block)
+    end
+
+    def dont_allow(subject=DoubleDefinitions::DoubleDefinitionCreate::NO_SUBJECT, method_name=nil, &definition_eval_block)
+      double_definition_create = DoubleDefinitions::DoubleDefinitionCreate.new
+      double_definition_create.dont_allow(subject, method_name, &definition_eval_block)
+    end
+
+    def proxy(subject=DoubleDefinitions::DoubleDefinitionCreate::NO_SUBJECT, method_name=nil, &definition_eval_block)
+      double_definition_create = DoubleDefinitions::DoubleDefinitionCreate.new
+      double_definition_create.proxy(subject, method_name, &definition_eval_block)
+    end
+
+    def strong(subject=DoubleDefinitions::DoubleDefinitionCreate::NO_SUBJECT, method_name=nil, &definition_eval_block)
+      double_definition_create = DoubleDefinitions::DoubleDefinitionCreate.new
+      double_definition_create.strong(subject, method_name, &definition_eval_block)
+    end
+
+    def instance_of(subject=DoubleDefinitions::DoubleDefinitionCreate::NO_SUBJECT, method_name=nil, &definition_eval_block)
+      double_definition_create = DoubleDefinitions::DoubleDefinitionCreate.new
+      double_definition_create.instance_of(subject, method_name, &definition_eval_block)
+    end
+
+    def any_instance_of(*args, &block)
+      RR::DoubleDefinitions::DoubleInjections::AnyInstanceOf.call(*args, &block)
+    end
+
+    # Verifies all the DoubleInjection objects have met their
+    # TimesCalledExpectations.
+    def verify
+      RR::Space.instance.verify_doubles
+    end
+
+    # Resets the registered Doubles and ordered Doubles
+    def reset
+      RR::Space.instance.reset
+    end
+
+    # Returns a AnyTimesMatcher. This is meant to be passed in as an argument
+    # to Double#times.
+    #
+    #   mock(object).method_name(anything).times(any_times) {return_value}
+    def any_times
+      TimesCalledMatchers::AnyTimesMatcher.new
+    end
+
+    # Sets up an Anything wildcard ArgumentEqualityExpectation
+    # that succeeds when passed any argument.
+    #   mock(object).method_name(anything) {return_value}
+    #   object.method_name("an arbitrary value") # passes
+    def anything
+      RR::WildcardMatchers::Anything.new
+    end
+
+    # Sets up an IsA wildcard ArgumentEqualityExpectation
+    # that succeeds when passed an argument of a certain type.
+    #   mock(object).method_name(is_a(String)) {return_value}
+    #   object.method_name("A String") # passes
+    def is_a(klass)
+      RR::WildcardMatchers::IsA.new(klass)
+    end
+
+    # Sets up an Numeric wildcard ArgumentEqualityExpectation
+    # that succeeds when passed an argument that is ::Numeric.
+    #   mock(object).method_name(numeric) {return_value}
+    #   object.method_name(99) # passes
+    def numeric
+      RR::WildcardMatchers::Numeric.new
+    end
+
+    # Sets up an Boolean wildcard ArgumentEqualityExpectation
+    # that succeeds when passed an argument that is a ::Boolean.
+    #   mock(object).method_name(boolean) {return_value}
+    #   object.method_name(false) # passes
+    def boolean
+      RR::WildcardMatchers::Boolean.new
+    end
+
+    # Sets up a DuckType wildcard ArgumentEqualityExpectation
+    # that succeeds when the passed argument implements the methods.
+    #   arg = Object.new
+    #   def arg.foo; end
+    #   def arg.bar; end
+    #   mock(object).method_name(duck_type(:foo, :bar)) {return_value}
+    #   object.method_name(arg) # passes
+    def duck_type(*args)
+      RR::WildcardMatchers::DuckType.new(*args)
+    end
+
+    # Sets up a HashIncluding wildcard ArgumentEqualityExpectation
+    # that succeeds when the passed argument contains at least those keys
+    # and values of the expectation.
+    #   mock(object).method_name(hash_including(:foo => 1)) {return_value}
+    #   object.method_name({:foo => 1, :bar => 2) # passes
+    def hash_including(expected_hash)
+      RR::WildcardMatchers::HashIncluding.new(expected_hash)
+    end
+
+    # Sets up a Satisfy wildcard ArgumentEqualityExpectation
+    # that succeeds when the passed argument causes the expectation's
+    # proc to return true.
+    #   mock(object).method_name(satisfy {|arg| arg == :foo}) {return_value}
+    #   object.method_name(:foo) # passes
+    def satisfy(expectation_proc=nil, &block)
+      expectation_proc ||= block
+      RR::WildcardMatchers::Satisfy.new(expectation_proc)
+    end
+
+    def spy(subject)
+      subject_methods = subject.public_methods.map {|method_name| method_name.to_sym }
+      methods_to_stub = subject_methods - METHODS_TO_EXCLUDE_FROM_SPYING
+
+      methods_to_stub.each do |method|
+        stub.proxy(subject, method)
+      end
+    end
+
+    def received(subject)
+      RR::SpyVerificationProxy.new(subject)
+    end
+
+    instance_methods.each do |name|
+      alias_method "rr_#{name}", name
+    end
+  end
+end

data/lib/rr/injections/method_missing_injection.rb

@@ -73,8 +73,12 @@ module RR
 
         subject_class.class_eval((<<-METHOD), __FILE__, __LINE__ + 1)
           def method_missing(method_name, *args, &block)
-            obj = ::RR::Injections::MethodMissingInjection::BoundObjects[#{id}]
-            MethodDispatches::MethodMissingDispatch.new(self, obj, method_name, args, block).call
+            if respond_to_missing?(method_name, true)
+              super
+            else
+              obj = ::RR::Injections::MethodMissingInjection::BoundObjects[#{id}]
+              MethodDispatches::MethodMissingDispatch.new(self, obj, method_name, args, block).call
+            end
           end
         METHOD
       end

data/lib/rr/integrations/minitest_4.rb

@@ -36,7 +36,7 @@ module RR
       def hook
         assertion_error_class = self.assertion_error_class
         test_case_class.class_eval do
-          include RR::Adapters::RRMethods
+          include RR::DSL
           include Mixin
 
           unless instance_methods.any? { |method_name| method_name.to_sym == :setup_with_rr }

data/lib/rr/integrations/minitest_4_active_support.rb

@@ -20,7 +20,7 @@ module RR
       def hook
         parent_adapter_class = self.parent_adapter_class
         ::ActiveSupport::TestCase.class_eval do
-          include RR::Adapters::RRMethods
+          include RR::DSL
           include parent_adapter_class::Mixin
 
           setup do

data/lib/rr/integrations/rspec/invocation_matcher.rb

@@ -37,11 +37,3 @@ module RR
     end
   end
 end
-
-module RR
-  module Adapters
-    module Rspec
-      InvocationMatcher = RR::Integrations::RSpec::InvocationMatcher
-    end
-  end
-end

data/lib/rr/integrations/rspec_2.rb

@@ -1,6 +1,24 @@
 module RR
   module Integrations
-    class RSpec2 < RSpec1
+    class RSpec2
+      module Mixin
+        def setup_mocks_for_rspec
+          RR.reset
+        end
+
+        def verify_mocks_for_rspec
+          RR.verify
+        end
+
+        def teardown_mocks_for_rspec
+          RR.reset
+        end
+
+        def have_received(method = nil)
+          RSpec::InvocationMatcher.new(method)
+        end
+      end
+
       def name
         'RSpec 2'
       end
@@ -14,7 +32,7 @@ module RR
       def hook
         ::RSpec.configure do |config|
           config.mock_with Mixin
-          config.include RR::Adapters::RRMethods
+          config.include RR::DSL
         end
 
         patterns =

data/lib/rr/recorded_call.rb

@@ -0,0 +1,29 @@
+module RR
+  class RecordedCall < Struct.new(:subject, :method_name, :arguments, :block)
+    def inspect
+      '[%s, %s, %s, %s]' % [
+        subject_to_s,
+        method_name.inspect,
+        arguments.inspect,
+        block.inspect
+      ]
+    end
+
+    def ==(other)
+      other.is_a?(self.class) &&
+        subject == other.subject &&
+        method_name == other.method_name &&
+        arguments == other.arguments
+    end
+
+    private
+
+    def subject_to_s
+      if subject.respond_to?(:__rr__original_to_s, true)
+        subject.__rr__original_to_s
+      else
+        subject.to_s
+      end
+    end
+  end
+end

data/lib/rr/recorded_calls.rb

@@ -9,13 +9,17 @@ module RR
 
     attr_reader :recorded_calls
 
+    def [](index)
+      @recorded_calls[index]
+    end
+
     def clear
       self.ordered_index = 0
       recorded_calls.clear
     end
 
-    def <<(recorded_call)
-      recorded_calls << recorded_call
+    def add(subject, method_name, arguments, block)
+      recorded_calls << RecordedCall.new(subject, method_name, arguments, block)
     end
 
     def any?(&block)
@@ -43,9 +47,9 @@ module RR
       unless Injections::DoubleInjection.exists_by_subject?(spy_verification.subject, spy_verification.method_name)
         RR::Errors.build_error(RR::Errors::SpyVerificationErrors::DoubleInjectionNotFoundError,
           "A Double Injection for the subject and method call:\n" <<
-          "#{spy_verification.subject.inspect}\n" <<
+          "#{spy_verification.subject_inspect}\n" <<
           "#{spy_verification.method_name}\ndoes not exist in:\n" <<
-          "\t#{recorded_calls.map {|call| call.inspect}.join("\n\t")}"
+          "\t#{recorded_calls.map {|call| call.inspect }.join("\n\t")}"
         )
       end
     end

data/lib/rr/space.rb

@@ -80,7 +80,7 @@ module RR
     end
 
     def record_call(subject, method_name, arguments, block)
-      @recorded_calls << [subject, method_name, arguments, block]
+      @recorded_calls.add(subject, method_name, arguments, block)
     end
 
     def blank_slate_whitelist

data/lib/rr/spy_verification.rb

@@ -13,12 +13,12 @@ module RR
 
     include RR::DoubleDefinitions::DoubleDefinition::TimesDefinitionConstructionMethods
     include RR::DoubleDefinitions::DoubleDefinition::ArgumentDefinitionConstructionMethods
-  
+
     def ordered
       @ordered = true
       self
     end
-  
+
     def ordered?
       @ordered
     end
@@ -32,7 +32,15 @@ module RR
         call
       end
     end
-  
+
+    def subject_inspect
+      if subject.respond_to?(:__rr__original_inspect, true)
+        subject.__rr__original_inspect
+      else
+        subject.inspect
+      end
+    end
+
   protected
     attr_writer :times_matcher
 
@@ -40,9 +48,9 @@ module RR
       # with_no_args and with actually set @argument_expectation
       args.empty? ? with_no_args : with(*args)
     end
-  
+
     def install_method_callback(return_value_block)
       # Do nothing. This is to support DefinitionConstructionMethods
     end
   end
-end
+end

data/lib/rr/version.rb

@@ -1,4 +1,4 @@
 module RR
-  VERSION = '1.1.2'.freeze
+  VERSION = '1.2.0'.freeze
   def self.version; VERSION; end
 end

data/lib/rr/wildcard_matchers.rb

@@ -12,7 +12,7 @@ divisible by a certain integer.  In use, it might look like this:
 
   mock(BananaGrabber).bunch_bananas(divisible_by(5))
 
-To implement this, we need a class RR::WildcardMatchers::DivisibleBy with 
+To implement this, we need a class RR::WildcardMatchers::DivisibleBy with
 these instance methods:
 
 * ==(other)
@@ -38,7 +38,7 @@ might look like this:
 DivisibleBy#==(other) should return true if other is a wildcard matcher that
 matches the same things as self, so a natural way to write DivisibleBy#== is:
 
-  
+
   class RR::WildcardMatchers::DivisibleBy
     def ==(other)
       # Ensure that other is actually a DivisibleBy
@@ -86,7 +86,7 @@ false otherwise.  In the case of DivisibleBy, wildcard_matches? reads:
       # If other isn't a number, how can it be divisible by anything?
       return false unless other.is_a?(Numeric)
 
-      # If other is in fact divisible by expected_divisor, then 
+      # If other is in fact divisible by expected_divisor, then
       # other modulo expected_divisor should be 0.
 
       other % expected_divisor == 0
@@ -105,10 +105,10 @@ But that's less expressive than the original:
   mock(BananaGrabber).bunch_bananas(divisible_by(5))
 
 To be able to use the convenient divisible_by matcher rather than the uglier
-DivisibleBy.new version, re-open the module RR::Adapters::RRMethods and
-define divisible_by there as a simple wrapper around DivisibleBy.new:
+DivisibleBy.new version, re-open the module RR::DSL and define divisible_by
+there as a simple wrapper around DivisibleBy.new:
 
-  module RR::Adapters::RRMethods
+  module RR::DSL
     def divisible_by(expected_divisor)
       RR::WildcardMatchers::DivisibleBy.new(expected_divisor)
     end
@@ -134,19 +134,19 @@ Here's all the code for DivisibleBy in one place for easy reference:
     def inspect
       "integer divisible by #{expected.divisor}"
     end
-  
+
     def wildcard_matches?(other)
       # If other isn't a number, how can it be divisible by anything?
       return false unless other.is_a?(Numeric)
 
-      # If other is in fact divisible by expected_divisor, then 
+      # If other is in fact divisible by expected_divisor, then
       # other modulo expected_divisor should be 0.
 
       other % expected_divisor == 0
     end
   end
-  
-  module RR::Adapters::RRMethods
+
+  module RR::DSL
     def divisible_by(expected_divisor)
       RR::WildcardMatchers::DivisibleBy.new(expected_divisor)
     end

data/lib/rr/without_autohook.rb

@@ -36,7 +36,7 @@ require 'rr/double_definitions/strategies/implementation/proxy'
 require 'rr/double_definitions/strategies/double_injection/double_injection_strategy'
 require 'rr/double_definitions/strategies/double_injection/instance'
 require 'rr/double_definitions/strategies/double_injection/any_instance_of'
-require 'rr/adapters/rr_methods'
+require 'rr/dsl'
 require 'rr/double_definitions/double_injections/instance'
 require 'rr/double_definitions/double_injections/any_instance_of'
 require 'rr/double_definitions/double_definition'
@@ -49,6 +49,7 @@ require 'rr/method_dispatches/base_method_dispatch'
 require 'rr/method_dispatches/method_dispatch'
 require 'rr/method_dispatches/method_missing_dispatch'
 require 'rr/hash_with_object_id_key'
+require 'rr/recorded_call'
 require 'rr/recorded_calls'
 require 'rr/proc_from_block'
 
@@ -88,24 +89,19 @@ require 'rr/spy_verification'
 require 'rr/integrations'
 require 'rr/integrations/decorator'
 require 'rr/integrations/rspec/invocation_matcher'
-require 'rr/integrations/rspec_1'
 require 'rr/integrations/rspec_2'
 require 'rr/integrations/minitest_4'
 require 'rr/integrations/minitest_4_active_support'
 require 'rr/integrations/minitest'
 require 'rr/integrations/minitest_active_support'
-require 'rr/integrations/test_unit_1'
-require 'rr/integrations/test_unit_200'
-require 'rr/integrations/test_unit_200_active_support'
-require 'rr/integrations/test_unit_2'
-require 'rr/integrations/test_unit_2_active_support'
-require 'rr/adapters'
+
+require 'rr/deprecations'
 
 require 'rr/version'
 
 module RR
   class << self
-    include Adapters::RRMethods
+    include DSL
 
     (RR::Space.instance_methods - Object.instance_methods).each do |method_name|
       class_eval((<<-METHOD), __FILE__, __LINE__ + 1)
@@ -117,10 +113,6 @@ module RR
 
     attr_accessor :debug
     alias_method :debug?, :debug
-
-    def ruby_18?
-      RUBY_VERSION =~ /^1\.8/
-    end
   end
 end