rr 0.10.10 → 0.10.11

data/CHANGES

@@ -1,3 +1,7 @@
+0.10.11
+- Added RR.blank_slate_whitelist
+- Fixed class_eval method redefinition warning in jruby
+
 0.10.10
 - Suite passes for Ruby 1.9.1
 

data/VERSION.yml

@@ -1,5 +1,5 @@
 --- 
 :build: 
 :minor: 10
-:patch: 10
+:patch: 11
 :major: 0

data/lib/rr.rb

@@ -2,6 +2,8 @@ dir = File.dirname(__FILE__)
 require 'rubygems'
 require 'forwardable'
 
+require "#{dir}/rr/blank_slate"
+
 require "#{dir}/rr/errors/rr_error"
 require "#{dir}/rr/errors/subject_does_not_implement_method_error"
 require "#{dir}/rr/errors/subject_has_different_arity_error"
@@ -26,9 +28,9 @@ require "#{dir}/rr/hash_with_object_id_key"
 require "#{dir}/rr/recorded_calls"
 require "#{dir}/rr/proc_from_block"
 
-require "#{dir}/rr/double_definitions/double_definition_creator_proxy"
-require "#{dir}/rr/double_definitions/double_definition_creator"
-require "#{dir}/rr/double_definitions/child_double_definition_creator"
+require "#{dir}/rr/double_definitions/double_definition_create_blank_slate"
+require "#{dir}/rr/double_definitions/double_definition_create"
+require "#{dir}/rr/double_definitions/child_double_definition_create"
 require "#{dir}/rr/adapters/rr_methods"
 
 require "#{dir}/rr/double"

data/lib/rr/adapters/rr_methods.rb

@@ -4,16 +4,16 @@ module RR
       class << self
         def register_strategy_class(strategy_class, method_name)
           class_eval((<<-CLASS), __FILE__, __LINE__ + 1)
-          def #{method_name}(subject=DoubleDefinitions::DoubleDefinitionCreator::NO_SUBJECT, method_name=nil, &definition_eval_block)
-            creator = DoubleDefinitions::DoubleDefinitionCreator.new
-            creator.#{method_name}(subject, method_name, &definition_eval_block)
+          def #{method_name}(subject=DoubleDefinitions::DoubleDefinitionCreate::NO_SUBJECT, method_name=nil, &definition_eval_block)
+            double_definition_create = DoubleDefinitions::DoubleDefinitionCreate.new
+            double_definition_create.#{method_name}(subject, method_name, &definition_eval_block)
           end
           CLASS
 
           class_eval((<<-CLASS), __FILE__, __LINE__ + 1)
           def #{method_name}!(method_name=nil, &definition_eval_block)
-            creator = DoubleDefinitions::DoubleDefinitionCreator.new
-            creator.#{method_name}!(method_name, &definition_eval_block)
+            double_definition_create = DoubleDefinitions::DoubleDefinitionCreate.new
+            double_definition_create.#{method_name}!(method_name, &definition_eval_block)
           end
           CLASS
         end

data/lib/rr/blank_slate.rb

@@ -0,0 +1,17 @@
+module RR
+  module BlankSlate
+    class << self
+      def call(klass)
+        klass.instance_eval do
+          instance_methods.each do |unformatted_method_name|
+            method_name = unformatted_method_name.to_s
+            unless method_name =~ /^_/ || Space.blank_slate_whitelist.any? {|whitelisted_method_name| method_name == whitelisted_method_name}
+              alias_method "__blank_slated_#{method_name}", method_name
+              undef_method method_name
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rr/double_definitions/{child_double_definition_creator.rb → child_double_definition_create.rb}

@@ -1,6 +1,6 @@
 module RR
   module DoubleDefinitions
-    class ChildDoubleDefinitionCreator < DoubleDefinitionCreator # :nodoc
+    class ChildDoubleDefinitionCreate < DoubleDefinitionCreate # :nodoc
       attr_reader :parent_double_definition
       def initialize(parent_double_definition)
         @parent_double_definition = parent_double_definition

data/lib/rr/double_definitions/double_definition.rb

@@ -4,14 +4,14 @@ module RR
       class << self
         def register_strategy_class(strategy_class, method_name)
           class_eval((<<-CLASS), __FILE__, __LINE__ + 1)
-          def #{method_name}(subject=DoubleDefinitionCreator::NO_SUBJECT, method_name=nil, &definition_eval_block)
-            ChildDoubleDefinitionCreator.new(self).#{method_name}(subject, method_name, &definition_eval_block)
+          def #{method_name}(subject=DoubleDefinitionCreate::NO_SUBJECT, method_name=nil, &definition_eval_block)
+            ChildDoubleDefinitionCreate.new(self).#{method_name}(subject, method_name, &definition_eval_block)
           end
           CLASS
 
           class_eval((<<-CLASS), __FILE__, __LINE__ + 1)
           def #{method_name}!(method_name=nil, &definition_eval_block)
-            ChildDoubleDefinitionCreator.new(self).#{method_name}!(method_name, &definition_eval_block)
+            ChildDoubleDefinitionCreate.new(self).#{method_name}!(method_name, &definition_eval_block)
           end
           CLASS
         end
@@ -25,20 +25,18 @@ module RR
         :after_call_proc,
         :yields_value,
         :double,
-        :double_definition_creator,
-        :subject
+        :double_definition_create
       )
 
       include Space::Reader
 
-      def initialize(double_definition_creator, subject)
+      def initialize(double_definition_create)
         @implementation = nil
         @argument_expectation = nil
         @times_matcher = nil
         @after_call_proc = nil
         @yields_value = nil
-        @double_definition_creator = double_definition_creator
-        @subject = subject
+        @double_definition_create = double_definition_create
         @ordered = false
         @verbose = false
         @verify_method_signature = false
@@ -46,8 +44,12 @@ module RR
       
       attr_reader :argument_expectation
 
+      def subject
+        double_definition_create.subject
+      end
+
       def root_subject
-        double_definition_creator.root_subject
+        double_definition_create.root_subject
       end
       
       module ArgumentDefinitionConstructionMethods
@@ -196,7 +198,7 @@ module RR
           @ordered = true
           space.register_ordered_double(@double)
           install_method_callback return_value_block
-          DoubleDefinitionCreatorProxy.new(double_definition_creator)
+          DoubleDefinitionCreateBlankSlate.new(double_definition_create)
         end
         alias_method :then, :ordered
 
@@ -343,7 +345,7 @@ module RR
 
         protected
         def implementation_strategy
-          double_definition_creator.implementation_strategy
+          double_definition_create.implementation_strategy
         end
       end
       include StateQueryMethods

data/lib/rr/double_definitions/{double_definition_creator.rb → double_definition_create.rb}

@@ -1,60 +1,52 @@
 module RR
   module DoubleDefinitions
-    class DoubleDefinitionCreator # :nodoc
+    class DoubleDefinitionCreate # :nodoc
       class << self
-        def register_verification_strategy_class(strategy_class, method_name)
+        def register_verification_strategy_class(strategy_class, strategy_method_name)
           class_eval((<<-CLASS), __FILE__, __LINE__ + 1)
-          def #{method_name}(subject=NO_SUBJECT, method_name=nil, &definition_eval_block)
-            add_strategy(subject, method_name, definition_eval_block) do
-              self.verification_strategy = #{strategy_class.name}.new(self)
-            end
+          def #{strategy_method_name}(subject=NO_SUBJECT, method_name=nil, &definition_eval_block)
+            self.add_verification_strategy(#{strategy_class.name}, subject, method_name, &definition_eval_block)
           end
           CLASS
 
           class_eval((<<-CLASS), __FILE__, __LINE__ + 1)
-          def #{method_name}!(method_name=nil, &definition_eval_block)
-            #{method_name}(Object.new, method_name, &definition_eval_block)
+          def #{strategy_method_name}!(method_name=nil, &definition_eval_block)
+            #{strategy_method_name}(Object.new, method_name, &definition_eval_block)
           end
           CLASS
         end
         
-        def register_implementation_strategy_class(strategy_class, method_name)
+        def register_implementation_strategy_class(strategy_class, strategy_method_name)
           class_eval((<<-CLASS), __FILE__, __LINE__ + 1)
-          def #{method_name}(subject=NO_SUBJECT, method_name=nil, &definition_eval_block)
-            add_strategy(subject, method_name, definition_eval_block) do
-              self.implementation_strategy = #{strategy_class.name}.new(self)
-            end
+          def #{strategy_method_name}(subject=NO_SUBJECT, method_name=nil, &definition_eval_block)
+            self.add_implementation_strategy(#{strategy_class.name}, subject, method_name, &definition_eval_block)
           end
           CLASS
 
           class_eval((<<-CLASS), __FILE__, __LINE__ + 1)
-          def #{method_name}!(method_name=nil, &definition_eval_block)
-            #{method_name}(Object.new, method_name, &definition_eval_block)
+          def #{strategy_method_name}!(method_name=nil, &definition_eval_block)
+            #{strategy_method_name}(Object.new, method_name, &definition_eval_block)
           end
           CLASS
         end
 
-        def register_scope_strategy_class(strategy_class, method_name)
+        def register_scope_strategy_class(strategy_class, strategy_method_name)
           class_eval((<<-CLASS), __FILE__, __LINE__ + 1)
-          def #{method_name}(subject=NO_SUBJECT, method_name=nil, &definition_eval_block)
-            add_strategy(subject, method_name, definition_eval_block) do
-              self.scope_strategy = #{strategy_class.name}.new(self)
-            end
+          def #{strategy_method_name}(subject=NO_SUBJECT, method_name=nil, &definition_eval_block)
+            self.add_scope_strategy(#{strategy_class.name}, subject, method_name, &definition_eval_block)
           end
           CLASS
 
           class_eval((<<-CLASS), __FILE__, __LINE__ + 1)
-          def #{method_name}!(method_name=nil, &definition_eval_block)
-            #{method_name}(Object.new, method_name, &definition_eval_block)
+          def #{strategy_method_name}!(method_name=nil, &definition_eval_block)
+            #{strategy_method_name}(Object.new, method_name, &definition_eval_block)
           end
           CLASS
         end
       end
 
       attr_reader :subject, 
-                  :args, :handler, 
-                  :definition, 
-                  :verification_strategy, 
+                  :verification_strategy,
                   :implementation_strategy, 
                   :scope_strategy
       NO_SUBJECT = Object.new
@@ -67,9 +59,19 @@ module RR
         @scope_strategy = Strategies::Scope::Instance.new(self)
       end
 
+      def call(method_name, *args, &handler)
+        raise DoubleDefinitionCreateError if no_subject?
+        definition = DoubleDefinition.new(self)
+        verification_strategy || no_strategy_error
+        verification_strategy.call(definition, method_name, args, handler)
+        implementation_strategy.call(definition, method_name, args, handler)
+        scope_strategy.call(definition, method_name, args, handler)
+        definition
+      end
+      
       def root_subject
         subject
-      end      
+      end
       
       def method_name
         @verification_strategy.method_name
@@ -81,18 +83,38 @@ module RR
         end
 
         protected
+        def add_verification_strategy(verification_strategy_class, subject=NO_SUBJECT, method_name=nil, &definition_eval_block)
+          add_strategy(subject, method_name, definition_eval_block) do
+            self.verification_strategy = verification_strategy_class.new(self)
+          end
+        end
+
+        def add_implementation_strategy(implementation_strategy_class, subject=NO_SUBJECT, method_name=nil, &definition_eval_block)
+          add_strategy(subject, method_name, definition_eval_block) do
+            self.implementation_strategy = implementation_strategy_class.new(self)
+          end
+        end
+
+        def add_scope_strategy(scope_strategy_class, subject=NO_SUBJECT, method_name=nil, &definition_eval_block)
+          add_strategy(subject, method_name, definition_eval_block) do
+            self.scope_strategy = scope_strategy_class.new(self)
+          end
+        end
+
         def add_strategy(subject, method_name, definition_eval_block)
           if method_name && definition_eval_block
             raise ArgumentError, "Cannot pass in a method name and a block"
           end
           @subject = subject
           yield
+          # TODO: Allow hash argument to simulate a Struct.
           if no_subject?
             self
           elsif method_name
-            create(method_name)
+            # TODO: Pass in arguments.
+            call(method_name)
           else
-            DoubleDefinitionCreatorProxy.new(self, &definition_eval_block)
+            DoubleDefinitionCreateBlankSlate.new(self, &definition_eval_block)
           end
         end
 
@@ -102,7 +124,7 @@ module RR
           @verification_strategy = verification_strategy
           verification_strategy
         end
-        
+
         def implementation_strategy=(implementation_strategy)
           verify_not_proxy_and_dont_allow(verification_strategy, implementation_strategy)
           @implementation_strategy = implementation_strategy
@@ -146,20 +168,7 @@ module RR
       end
       include StrategySetupMethods
 
-      module StrategyExecutionMethods
-        def create(method_name, *args, &handler)
-          raise DoubleDefinitionCreatorError if no_subject?
-          @method_name, @args, @handler = method_name, args, handler
-          @definition = DoubleDefinition.new(self, subject)
-          verification_strategy ? verification_strategy.call(definition, method_name, args, handler) : no_strategy_error
-          implementation_strategy.call(definition, method_name, args, handler)
-          scope_strategy.call(definition, method_name, args, handler)
-          definition
-        end
-      end
-      include StrategyExecutionMethods
-
-      class DoubleDefinitionCreatorError < Errors::RRError
+      class DoubleDefinitionCreateError < Errors::RRError
       end
     end
   end

data/lib/rr/double_definitions/double_definition_create_blank_slate.rb

@@ -0,0 +1,26 @@
+module RR
+  module DoubleDefinitions
+    class DoubleDefinitionCreateBlankSlate
+      def initialize(double_definition_create, &block) #:nodoc:
+        @double_definition_create = double_definition_create
+        BlankSlate.call(respond_to?(:class) ? self.class : __blank_slated_class)
+
+        if block_given?
+          if block.arity == 1
+            yield(self)
+          else
+            respond_to?(:instance_eval) ? instance_eval(&block) : __blank_slated_instance_eval(&block)
+          end
+        end
+      end
+
+      def method_missing(method_name, *args, &block)
+        @double_definition_create.call(method_name, *args, &block)
+      end
+
+      def __double_definition_create__
+        @double_definition_create
+      end
+    end    
+  end
+end

data/lib/rr/double_definitions/strategies/implementation/implementation_strategy.rb

@@ -4,8 +4,8 @@ module RR
       module Implementation
         class ImplementationStrategy < Strategy
           class << self
-            def register_self_at_double_definition_creator(domain_name)
-              DoubleDefinitionCreator.register_implementation_strategy_class(self, domain_name)
+            def register_self_at_double_definition_create(strategy_method_name)
+              DoubleDefinitionCreate.register_implementation_strategy_class(self, strategy_method_name)
             end
           end
         end

data/lib/rr/double_definitions/strategies/scope/instance.rb

@@ -5,7 +5,7 @@ module RR
         class Instance < ScopeStrategy
           protected
           def do_call
-            double_injection = space.double_injection(subject, method_name)
+            double_injection = Injections::DoubleInjection.create(subject, method_name)
             Double.new(double_injection, definition)
           end
         end

data/lib/rr/double_definitions/strategies/scope/instance_of_class.rb

@@ -19,20 +19,20 @@ module RR
           def initialize(*args)
             super
 
-            if !double_definition_creator.no_subject? && !double_definition_creator.subject.is_a?(Class)
+            if !double_definition_create.no_subject? && !double_definition_create.subject.is_a?(Class)
               raise ArgumentError, "instance_of only accepts class objects"
             end
           end
 
           protected
           def do_call
-            instance_of_subject_creator = DoubleDefinitionCreator.new
-            instance_of_subject_creator.strong if definition.verify_method_signature?
-            instance_of_subject_creator.stub(subject)
-            instance_of_subject_creator.create(:new) do |*args|
+            instance_of_subject_double_definition_create = DoubleDefinitionCreate.new
+            instance_of_subject_double_definition_create.strong if definition.verify_method_signature?
+            instance_of_subject_double_definition_create.stub(subject)
+            instance_of_subject_double_definition_create.call(:new) do |*args|
               #####
               instance = subject.allocate
-              double_injection = space.double_injection(instance, method_name)
+              double_injection = Injections::DoubleInjection.create(instance, method_name)
               Double.new(double_injection, definition)
               #####
               if args.last.is_a?(ProcFromBlock)

data/lib/rr/double_definitions/strategies/scope/scope_strategy.rb

@@ -4,8 +4,8 @@ module RR
       module Scope
         class ScopeStrategy < Strategy
           class << self
-            def register_self_at_double_definition_creator(domain_name)
-              DoubleDefinitionCreator.register_scope_strategy_class(self, domain_name)
+            def register_self_at_double_definition_create(strategy_method_name)
+              DoubleDefinitionCreate.register_scope_strategy_class(self, strategy_method_name)
             end
           end
         end

data/lib/rr/double_definitions/strategies/strategy.rb

@@ -3,33 +3,33 @@ module RR
     module Strategies
       class Strategy
         class << self
-          attr_reader :domain_name
-          def register(domain_name, *alias_method_names)
-            @domain_name = domain_name
-            register_self_at_double_definition_creator(domain_name)
-            DoubleDefinitionCreator.class_eval do
+          attr_reader :strategy_method_name
+          def register(strategy_method_name, *alias_method_names)
+            @strategy_method_name = strategy_method_name
+            register_self_at_double_definition_create(strategy_method_name)
+            DoubleDefinitionCreate.class_eval do
               alias_method_names.each do |alias_method_name|
-                alias_method alias_method_name, domain_name
+                alias_method alias_method_name, strategy_method_name
               end
             end
-            RR::Adapters::RRMethods.register_strategy_class(self, domain_name)
-            DoubleDefinition.register_strategy_class(self, domain_name)
+            RR::Adapters::RRMethods.register_strategy_class(self, strategy_method_name)
+            DoubleDefinition.register_strategy_class(self, strategy_method_name)
             RR::Adapters::RRMethods.class_eval do
               alias_method_names.each do |alias_method_name|
-                alias_method alias_method_name, domain_name
+                alias_method alias_method_name, strategy_method_name
               end
             end
           end
 
-          def register_self_at_double_definition_creator(domain_name)
+          def register_self_at_double_definition_create(strategy_method_name)
           end
         end
 
-        attr_reader :double_definition_creator, :definition, :method_name, :args, :handler
+        attr_reader :double_definition_create, :definition, :method_name, :args, :handler
         include Space::Reader
 
-        def initialize(double_definition_creator)
-          @double_definition_creator = double_definition_creator
+        def initialize(double_definition_create)
+          @double_definition_create = double_definition_create
         end
         
         def call(definition, method_name, args, handler)
@@ -38,7 +38,7 @@ module RR
         end
 
         def name
-          self.class.domain_name
+          self.class.strategy_method_name
         end
 
         def verify_subject(subject)
@@ -58,8 +58,7 @@ module RR
         end
 
         def reimplementation
-          rv = definition.returns(&handler)
-
+          definition.returns(&handler)
         end
 
         def subject