rr 0.4.8 → 0.4.9

data/CHANGES

@@ -1,3 +1,6 @@
+* 0.4.9
+- Proxying from RR module to RR::Space.instance
+
 * 0.4.8
 - Fixed issue with Hash arguments
 

data/{README → README.rdoc}

@@ -42,10 +42,10 @@ Here is RR compared to other mock frameworks:
   User.should_receive(:find).with('42') {jane} # Rspec using return value blocks
   mock(User).find('42') {jane} # RR
 
-=== No mock objects
+=== No "pure" mock object
 RR is an opinionated framework. RR does not create a mock object for you,
 like other frameworks. Instead, RR utilizes a technique known as
-"partial mocking".
+"double injection".
 
   my_object = MyClass.new
   mock(my_object).hello
@@ -54,6 +54,10 @@ Compare this with doing a mock in mocha:
   my_mocked_object = mock()
   my_mocked_object.expects(:hello)
 
+If you wish to use objects for the sole purpose of being a mock, you can
+do so by creating an empty object.
+  mock(my_mock_object = Object.new).hello
+
 === No should_receive or expects method
 RR uses method_missing to set your method expectation. This means you do not
 need to use a method such as should_receive or expects.
@@ -186,7 +190,7 @@ Put double scenarios on instances of a Class.
     m.system("rake baz") {true}
   end
 
-=== Wildcard matchers
+=== Argument Wildcard matchers
 ==== anything
   mock(object).foobar(1, anything)
   object.foobar(1, :my_symbol)
@@ -199,7 +203,7 @@ Put double scenarios on instances of a Class.
   mock(object).foobar(numeric)
   object.foobar(99)
 
-==== numeric
+==== boolean
   mock(object).foobar(boolean)
   object.foobar(false)
 
@@ -210,6 +214,10 @@ Put double scenarios on instances of a Class.
   def arg.talk; 'quack'; end
   object.foobar(arg)
 
+=== Invocation Amount Wildcard Matchers
+==== any_times
+  mock(object).method_name(anything).times(any_times) {return_value}
+
 == Special Thanks To
 With any development effort, there are countless people who have contributed
 to making it possible. We all are standing on the shoulders of giants.
@@ -220,9 +228,9 @@ to making it possible. We all are standing on the shoulders of giants.
 * Nick Kallen for documentation suggestion & bug reports
 * David Chelimsky for encouragement to make the RR framework, for developing
   the Rspec mock framework, and syntax ideas
-* Gerald Meszaros for his excellent book "xUnit Test Patterns"
+* Gerard Meszaros for his excellent book "xUnit Test Patterns"
 * Dan North for syntax ideas
-* Jim Weirich for developing Flexmock, the first Terse ruby mock framework
+* Jim Weirich for developing Flexmock, the first Terse ruby mock framework in Ruby
 * James Mead for developing Mocha
 * Aslak Hellesoy for Developing Rspec
 * Stephen Baker for Developing Rspec

data/Rakefile

@@ -26,7 +26,7 @@ def run_suite
 end
 
 PKG_NAME = "rr"
-PKG_VERSION = "0.4.8"
+PKG_VERSION = "0.4.9"
 PKG_FILES = FileList[
   '[A-Z]*',
   '*.rb',
@@ -47,7 +47,7 @@ spec = Gem::Specification.new do |s|
   s.require_path = 'lib'
 
   s.has_rdoc = true
-  s.extra_rdoc_files = [ "README", "CHANGES" ]
+  s.extra_rdoc_files = [ "README.rdoc", "CHANGES" ]
   s.rdoc_options = ["--main", "README", "--inline-source", "--line-numbers"]
 
   s.test_files = Dir.glob('spec/*_spec.rb')

data/lib/rr.rb

@@ -10,9 +10,9 @@ require "#{dir}/rr/space"
 require "#{dir}/rr/double_injection"
 require "#{dir}/rr/hash_with_object_id_key"
 
-require "#{dir}/rr/double_method_proxy"
+require "#{dir}/rr/double_definition_creator_proxy"
 
-require "#{dir}/rr/double_creator"
+require "#{dir}/rr/double_definition_creator"
 
 require "#{dir}/rr/double"
 require "#{dir}/rr/double_definition"
@@ -44,4 +44,12 @@ require "#{dir}/rr/times_called_matchers/at_most_matcher"
 require "#{dir}/rr/adapters/rr_methods"
 
 require "#{dir}/rr/adapters/rspec"
-require "#{dir}/rr/adapters/test_unit"
+require "#{dir}/rr/adapters/test_unit"
+
+module RR
+  class << self
+    def method_missing(method_name, *args, &block)
+      RR::Space.instance.__send__(method_name, *args, &block)
+    end
+  end  
+end

data/lib/rr/adapters/rr_methods.rb

@@ -22,7 +22,7 @@ module RR
       #   or
       #   proxy.mock(subject).method_name_1
       #
-      # When passed the subject, a DoubleMethodProxy is returned. Passing
+      # When passed the subject, a DoubleDefinitionCreatorProxy is returned. Passing
       # a method with arguments to the proxy will set up expectations that
       # the a call to the subject's method with the arguments will happen,
       # and return the prescribed value.
@@ -40,8 +40,8 @@ module RR
       #     method_name_1 {return_value_1}
       #     method_name_2(arg_1, arg_2) {return_value_2}
       #   end
-      def mock(subject=DoubleCreator::NO_SUBJECT_ARG, method_name=nil, &definition)
-        creator = RR::Space.double_creator
+      def mock(subject=DoubleDefinitionCreator::NO_SUBJECT_ARG, method_name=nil, &definition)
+        creator = DoubleDefinitionCreator.new
         creator.mock(subject, method_name, &definition)
       end
 
@@ -56,7 +56,7 @@ module RR
       #   or
       #   proxy.stub(subject).method_name_1
       #
-      # When passed the subject, a DoubleMethodProxy is returned. Passing
+      # When passed the subject, a DoubleDefinitionCreatorProxy is returned. Passing
       # a method with arguments to the proxy will set up expectations that
       # the a call to the subject's method with the arguments will happen,
       # and return the prescribed value.
@@ -74,8 +74,8 @@ module RR
       #     method_name_1 {return_value_1}
       #     method_name_2(arg_1, arg_2) {return_value_2}
       #   end
-      def stub(subject=DoubleCreator::NO_SUBJECT_ARG, method_name=nil, &definition)
-        creator = RR::Space.double_creator
+      def stub(subject=DoubleDefinitionCreator::NO_SUBJECT_ARG, method_name=nil, &definition)
+        creator = DoubleDefinitionCreator.new
         creator.stub(subject, method_name, &definition)
       end
 
@@ -124,8 +124,8 @@ module RR
       #     html.should include("My socks are wet")
       #     "My new return value"
       #   end
-      def proxy(subject=DoubleCreator::NO_SUBJECT_ARG, method_name=nil, &definition)
-        creator = RR::Space.double_creator
+      def proxy(subject=DoubleDefinitionCreator::NO_SUBJECT_ARG, method_name=nil, &definition)
+        creator = DoubleDefinitionCreator.new
         creator.proxy(subject, method_name, &definition)
       end
 
@@ -145,8 +145,8 @@ module RR
       #      m.method2(arg1, arg2) # Do not allow method2 with arguments arg1 and arg2
       #      m.method3.with_no_args # Do not allow method3 with no arguments
       #    end
-      def dont_allow(subject=DoubleCreator::NO_SUBJECT_ARG, method_name=nil, &definition)
-        creator = RR::Space.double_creator
+      def dont_allow(subject=DoubleDefinitionCreator::NO_SUBJECT_ARG, method_name=nil, &definition)
+        creator = DoubleDefinitionCreator.new
         creator.dont_allow(subject, method_name, &definition)
       end
       alias_method :do_not_allow, :dont_allow
@@ -164,8 +164,8 @@ module RR
       #   mock.instance_of(User).projects do |projects|
       #     projects[0..2]
       #   end
-      def instance_of(subject=DoubleCreator::NO_SUBJECT_ARG, method_name=nil, &definition)
-        creator = RR::Space.double_creator
+      def instance_of(subject=DoubleDefinitionCreator::NO_SUBJECT_ARG, method_name=nil, &definition)
+        creator = DoubleDefinitionCreator.new
         creator.instance_of(subject, method_name, &definition)
       end
 

data/lib/rr/adapters/rspec.rb

@@ -10,13 +10,13 @@ module RR
 
       include RRMethods
       def setup_mocks_for_rspec
-        rr_reset
+        RR.reset
       end
       def verify_mocks_for_rspec
-        rr_verify
+        RR.verify
       end
       def teardown_mocks_for_rspec
-        rr_reset
+        RR.reset
       end
     end
   end

data/lib/rr/adapters/test_unit.rb

@@ -3,18 +3,18 @@ module RR
     module TestUnit
       include RRMethods
       def self.included(mod)
-        RR::Space.trim_backtrace = true
+        RR.trim_backtrace = true
         mod.class_eval do
           alias_method :setup_without_rr, :setup
           def setup_with_rr
             setup_without_rr
-            rr_reset
+            RR.reset
           end
           alias_method :setup, :setup_with_rr
 
           alias_method :teardown_without_rr, :teardown
           def teardown_with_rr
-            rr_verify
+            RR.verify
             teardown_without_rr
           end
           alias_method :teardown, :teardown_with_rr

data/lib/rr/double.rb

@@ -17,13 +17,15 @@ module RR
     end
 
     attr_reader :times_called, :double_injection, :definition
+    include Space::Reader
 
-    def initialize(space, double_injection, definition)
-      @space = space
+    def initialize(double_injection, definition = DoubleDefinition.new)
       @double_injection = double_injection
       @definition = definition
       @times_called = 0
       @times_called_expectation = Expectations::TimesCalledExpectation.new(self)
+      definition.double = self
+      double_injection.register_double self
     end
 
     # Double#with sets the expectation that the Double will receive
@@ -193,8 +195,8 @@ module RR
     # the passed in block.
     #
     # Passing in an argument causes Double to return the argument.
-    def returns(value=nil, &implementation)
-      definition.returns(value, &implementation)
+    def returns(*args, &implementation)
+      definition.returns(*args, &implementation)
     end
 
     # Double#implemented_by sets the implementation of the Double.
@@ -210,7 +212,7 @@ module RR
       definition.implemented_by implementation
     end
 
-    # Double#implemented_by_original_method sets the implementation
+    # Double#proxy sets the implementation
     # of the Double to be the original method.
     # This is primarily used with proxy.
     #
@@ -218,10 +220,10 @@ module RR
     #   def obj.foobar
     #     yield(1)
     #   end
-    #   mock(obj).method_name.implemented_by_original_method
+    #   mock(obj).method_name.proxy
     #   obj.foobar {|arg| puts arg} # puts 1
-    def implemented_by_original_method
-      definition.implemented_by_original_method
+    def proxy
+      definition.proxy
     end
 
     # Double#call calls the Double's implementation. The return
@@ -233,8 +235,8 @@ module RR
       if verbose?
         puts Double.formatted_name(double_injection.method_name, args)
       end
-      self.times_called_expectation.attempt! if definition.times_matcher
-      @space.verify_ordered_double(self) if ordered?
+      self.times_called_expectation.attempt if definition.times_matcher
+      space.verify_ordered_double(self) if ordered?
       yields!(block)
       return_value = call_implementation(double_injection, *args, &block)
       return return_value unless definition.after_call_value

data/lib/rr/double_creator.rb

@@ -1,11 +1,11 @@
 module RR
-  # RR::DoubleCreator provides a strategies to create a Double.
+  # RR::DoubleDefinitionCreator provides a strategies to create a Double.
   # The strategies are:
   # * mock
   # * stub
   # * proxy
   # * dont_allow
-  class DoubleCreator
+  class DoubleDefinitionCreator
     NO_SUBJECT_ARG = Object.new
 
     attr_reader :space
@@ -14,9 +14,8 @@ module RR
     def initialize(space)
       @space = space
       @strategy = nil
-      @proxy = false
-      @instance_of = nil
-      @instance_of_method_name = nil
+      @using_proxy_strategy = false
+      @instance_of_called = nil
     end
     
     # This method sets the Double to have a mock strategy. A mock strategy
@@ -29,7 +28,7 @@ module RR
     #   or
     #   proxy.mock(subject).method_name_1
     #
-    # When passed the subject, a DoubleMethodProxy is returned. Passing
+    # When passed the subject, a DoubleDefinitionCreatorProxy is returned. Passing
     # a method with arguments to the proxy will set up expectations that
     # the a call to the subject's method with the arguments will happen.
     #   mock(subject).method_name_1 {return_value_1}
@@ -47,10 +46,10 @@ module RR
     #     method_name_2(arg_1, arg_2) {return_value_2}
     #   end
     def mock(subject=NO_SUBJECT_ARG, method_name=nil, &definition)
-      strategy_error! if @strategy
+      verify_no_strategy
       @strategy = :mock
       return self if subject.__id__ === NO_SUBJECT_ARG.__id__
-      RR::Space.double_method_proxy(self, subject, method_name, &definition)
+      DoubleDefinitionCreatorProxy.new(self, subject, method_name, &definition)
     end
 
     # This method sets the Double to have a stub strategy. A stub strategy
@@ -63,7 +62,7 @@ module RR
     #   or
     #   proxy.stub(subject).method_name_1
     #
-    # When passed the subject, a DoubleMethodProxy is returned. Passing
+    # When passed the subject, a DoubleDefinitionCreatorProxy is returned. Passing
     # a method with arguments to the proxy will set up expectations that
     # the a call to the subject's method with the arguments will happen,
     # and return the prescribed value.
@@ -82,10 +81,10 @@ module RR
     #     method_name_2(arg_1, arg_2) {return_value_2}
     #   end
     def stub(subject=NO_SUBJECT_ARG, method_name=nil, &definition)
-      strategy_error! if @strategy
+      verify_no_strategy
       @strategy = :stub
       return self if subject.__id__ === NO_SUBJECT_ARG.__id__
-      RR::Space.double_method_proxy(self, subject, method_name, &definition)
+      DoubleDefinitionCreatorProxy.new(self, subject, method_name, &definition)
     end
 
     # This method sets the Double to have a dont_allow strategy.
@@ -105,11 +104,11 @@ module RR
     #      m.method3.with_no_args # Do not allow method3 with no arguments
     #    end
     def dont_allow(subject=NO_SUBJECT_ARG, method_name=nil, &definition)
-      strategy_error! if @strategy
-      proxy_when_dont_allow_error! if @proxy
+      verify_no_strategy
+      proxy_when_dont_allow_error if @using_proxy_strategy
       @strategy = :dont_allow
       return self if subject.__id__ === NO_SUBJECT_ARG.__id__
-      RR::Space.double_method_proxy(self, subject, method_name, &definition)
+      DoubleDefinitionCreatorProxy.new(self, subject, method_name, &definition)
     end
     alias_method :do_not_allow, :dont_allow
     alias_method :dont_call, :dont_allow
@@ -161,10 +160,10 @@ module RR
     #     "My new return value"
     #   end
     def proxy(subject=NO_SUBJECT_ARG, method_name=nil, &definition)
-      proxy_when_dont_allow_error! if @strategy == :dont_allow
-      @proxy = true
+      proxy_when_dont_allow_error if @strategy == :dont_allow
+      @using_proxy_strategy = true
       return self if subject.__id__ === NO_SUBJECT_ARG.__id__
-      RR::Space.double_method_proxy(self, subject, method_name, &definition)
+      DoubleDefinitionCreatorProxy.new(self, subject, method_name, &definition)
     end
     alias_method :probe, :proxy
 
@@ -180,41 +179,41 @@ module RR
     #     projects[0..2]
     #   end
     def instance_of(subject=NO_SUBJECT_ARG, method_name=nil, &definition)
-      @instance_of = true
+      @instance_of_called = true
       return self if subject === NO_SUBJECT_ARG
       raise ArgumentError, "instance_of only accepts class objects" unless subject.is_a?(Class)
-      RR::Space.double_method_proxy(self, subject, method_name, &definition)
+      DoubleDefinitionCreatorProxy.new(self, subject, method_name, &definition)
     end
 
-    def create!(subject, method_name, *args, &handler)
+    def create(subject, method_name, *args, &handler)
       @args = args
       @handler = handler
-      if @instance_of
-        setup_class_probing_instances(subject, method_name)
+      if @instance_of_called
+        setup_doubles_for_class_instances(subject, method_name)
       else
         setup_double(subject, method_name)
       end
-      transform!
+      transform
       @definition
     end
     
     protected
     def setup_double(subject, method_name)
       @double_injection = @space.double_injection(subject, method_name)
-      @double = @space.double(@double_injection)
+      @double = Double.new(@double_injection)
       @definition = @double.definition
     end
 
-    def setup_class_probing_instances(subject, method_name)
+    def setup_doubles_for_class_instances(subject, method_name)
       class_double = @space.double_injection(subject, :new)
-      class_double = @space.double(class_double)
+      class_double = Double.new(class_double)
 
       instance_method_name = method_name
 
-      @definition = @space.double_definition
-      class_handler = proc do |return_value|
+      @definition = DoubleDefinition.new
+      class_handler = lambda do |return_value|
         double_injection = @space.double_injection(return_value, instance_method_name)
-        @space.double(double_injection, @definition)
+        Double.new(double_injection, @definition)
         return_value
       end
 
@@ -223,42 +222,46 @@ module RR
         [],
         class_handler
       )
-      builder.stub!
-      builder.proxy!
+      builder.stub
+      builder.proxy
     end
 
-    def transform!
+    def transform
       builder = DoubleDefinitionBuilder.new(@definition, @args, @handler)
 
-      case @strategy
-      when :mock; builder.mock!
-      when :stub; builder.stub!
-      when :dont_allow; builder.dont_allow!
-      else no_strategy_error!
-      end
-      
-      if @proxy
-        builder.proxy!
+      verify_strategy
+      builder.__send__(@strategy)
+
+      if @using_proxy_strategy
+        builder.proxy
       else
-        builder.reimplementation!
+        builder.reimplementation
       end
     end
 
-    def strategy_error!
+    def verify_no_strategy
+      strategy_already_defined_error if @strategy
+    end
+
+    def strategy_already_defined_error
       raise(
         DoubleDefinitionError,
         "This Double already has a #{@strategy} strategy"
       )
     end
 
-    def no_strategy_error!
+    def verify_strategy
+      no_strategy_error unless @strategy
+    end
+
+    def no_strategy_error
       raise(
         DoubleDefinitionError,
         "This Double has no strategy"
       )
     end
 
-    def proxy_when_dont_allow_error!
+    def proxy_when_dont_allow_error
       raise(
         DoubleDefinitionError,
         "Doubles cannot be proxied when using dont_allow strategy"