rr 1.0.0 → 1.0.1

data/VERSION.yml

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

data/lib/rr.rb

@@ -1,6 +1,7 @@
 dir = File.dirname(__FILE__)
 require 'forwardable'
 
+require "#{dir}/rr/class_instance_method_defined"
 require "#{dir}/rr/blank_slate"
 
 require "#{dir}/rr/errors/rr_error"
@@ -30,11 +31,9 @@ require "#{dir}/rr/double_definitions/strategies/implementation/proxy"
 require "#{dir}/rr/double_definitions/strategies/double_injection/double_injection_strategy"
 require "#{dir}/rr/double_definitions/strategies/double_injection/instance"
 require "#{dir}/rr/double_definitions/strategies/double_injection/any_instance_of"
-require "#{dir}/rr/double_definitions/strategies/double_injection/new_instance_of"
 require "#{dir}/rr/adapters/rr_methods"
 require "#{dir}/rr/double_definitions/double_injections/instance"
 require "#{dir}/rr/double_definitions/double_injections/any_instance_of"
-require "#{dir}/rr/double_definitions/double_injections/new_instance_of"
 require "#{dir}/rr/double_definitions/double_definition"
 
 require "#{dir}/rr/injections/injection"
@@ -47,7 +46,6 @@ require "#{dir}/rr/method_dispatches/method_missing_dispatch"
 require "#{dir}/rr/hash_with_object_id_key"
 require "#{dir}/rr/recorded_calls"
 require "#{dir}/rr/proc_from_block"
-require "#{dir}/rr/class_instance_method_defined"
 
 require "#{dir}/rr/double_definitions/double_definition_create_blank_slate"
 require "#{dir}/rr/double_definitions/double_definition_create"

data/lib/rr/adapters/rr_methods.rb

@@ -27,15 +27,12 @@ module RR
         double_definition_create.strong(subject, method_name, &definition_eval_block)
       end
 
-      def any_instance_of(subject=DoubleDefinitions::DoubleDefinitionCreate::NO_SUBJECT, method_name=nil, &definition_eval_block)
-        double_definition_create = DoubleDefinitions::DoubleDefinitionCreate.new
-        double_definition_create.any_instance_of(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
+      alias_method :any_instance_of, :instance_of
+      alias_method :all_instances_of, :instance_of
 
       # Verifies all the DoubleInjection objects have met their
       # TimesCalledExpectations.

data/lib/rr/class_instance_method_defined.rb

@@ -1,6 +1,6 @@
 module RR
   module ClassInstanceMethodDefined
-    def self.call(klass, instance_method, include_super=true)
+    def class_instance_method_defined(klass, instance_method, include_super=true)
       klass.instance_methods(include_super).detect {|method_name| method_name.to_sym == instance_method.to_sym} ||
         klass.protected_instance_methods(include_super).detect {|method_name| method_name.to_sym == instance_method.to_sym} ||
         klass.private_instance_methods(include_super).detect {|method_name| method_name.to_sym == instance_method.to_sym}

data/lib/rr/double.rb

@@ -116,12 +116,14 @@ module RR
     end
 
     def verify_method_signature
-      raise RR::Errors::SubjectDoesNotImplementMethodError unless definition.subject.respond_to?(double_injection.send(:original_method_alias_name))
+      unless double_injection.subject_has_original_method?
+        raise RR::Errors::SubjectDoesNotImplementMethodError
+      end
       raise RR::Errors::SubjectHasDifferentArityError unless arity_matches?
     end
 
     def subject_arity
-      definition.subject.method(double_injection.send(:original_method_alias_name)).arity
+      double_injection.original_method.arity
     end
 
     def subject_accepts_only_varargs?

data/lib/rr/double_definitions/double_definition_create.rb

@@ -129,13 +129,11 @@ module RR
       end
 
       # DoubleInjection Strategies
-      def any_instance_of(subject=NO_SUBJECT, method_name=nil, &definition_eval_block)
-        self.add_double_injection_strategy(::RR::DoubleDefinitions::Strategies::DoubleInjection::AnyInstanceOf, subject, method_name, &definition_eval_block)
-      end
-
       def instance_of(subject=NO_SUBJECT, method_name=nil, &definition_eval_block)
-        self.add_double_injection_strategy(::RR::DoubleDefinitions::Strategies::DoubleInjection::NewInstanceOf, subject, method_name, &definition_eval_block)
+        self.add_double_injection_strategy(::RR::DoubleDefinitions::Strategies::DoubleInjection::AnyInstanceOf, subject, method_name, &definition_eval_block)
       end
+      alias_method :any_instance_of, :instance_of
+      alias_method :all_instances_of, :instance_of
     end
   end
 end

data/lib/rr/double_definitions/strategies/double_injection/any_instance_of.rb

@@ -20,7 +20,6 @@ module RR
             if !double_definition_create.no_subject? && !double_definition_create.subject.is_a?(Class)
               raise ArgumentError, "instance_of only accepts class objects"
             end
-#            subject, method_name
             double_injection = Injections::DoubleInjection.find_or_create(subject, method_name)
             Double.new(double_injection, definition)
           end

data/lib/rr/injections/double_injection.rb

@@ -33,7 +33,10 @@ module RR
 
         def dispatch_method(subject, subject_class, method_name, arguments, block)
           subject_eigenclass = (class << subject; self; end)
-          if exists?(subject_class, method_name) && (subject_class == subject_eigenclass || subject_eigenclass.superclass != (class << Class; self; end))
+          if (
+            exists?(subject_class, method_name) &&
+            (subject_class == subject_eigenclass) || !subject.is_a?(Class)
+          )
             find(subject_class, method_name.to_sym).dispatch_method(subject, arguments, block)
           else
             new(subject_class, method_name.to_sym).dispatch_original_method(subject, arguments, block)
@@ -83,6 +86,7 @@ module RR
           end
         end
       end)
+      include ClassInstanceMethodDefined
 
       attr_reader :subject_class, :method_name, :doubles
 
@@ -117,25 +121,25 @@ module RR
 
       def bind_method_that_self_destructs_and_delegates_to_method_missing
         subject_class_object_id = subject_class.object_id
-        subject_class.class_eval(<<-METHOD, __FILE__, __LINE__ + 1)
+        subject_class.class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
         def #{method_name}(*args, &block)
           ObjectSpace._id2ref(#{subject_class_object_id}).class_eval do
             remove_method(:#{method_name})
           end
           method_missing(:#{method_name}, *args, &block)
         end
-        METHOD
+        RUBY
         self
       end
 
       def bind_method
         subject_class_object_id = subject_class.object_id
-        subject_class.class_eval(<<-METHOD, __FILE__, __LINE__ + 1)
+        subject_class.class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
         def #{method_name}(*args, &block)
           arguments = MethodArguments.new(args, block)
           RR::Injections::DoubleInjection.dispatch_method(self, ObjectSpace._id2ref(#{subject_class_object_id}), :#{method_name}, arguments.arguments, arguments.block)
         end
-        METHOD
+        RUBY
         self
       end
 
@@ -178,7 +182,7 @@ module RR
       end
 
       def subject_has_original_method_missing?
-        ClassInstanceMethodDefined.call(subject_class, MethodDispatches::MethodMissingDispatch.original_method_missing_alias_name)
+        class_instance_method_defined(subject_class, MethodDispatches::MethodMissingDispatch.original_method_missing_alias_name)
       end
 
       def original_method_alias_name

data/lib/rr/injections/injection.rb

@@ -8,19 +8,24 @@ module RR
       end)
 
       include Space::Reader
+      include ClassInstanceMethodDefined
 
       def subject_has_method_defined?(method_name_in_question)
-        ClassInstanceMethodDefined.call(subject_class, method_name_in_question)
+        class_instance_method_defined(subject_class, method_name_in_question)
       end
 
       def subject_has_original_method?
         subject_has_method_defined?(original_method_alias_name)
       end
 
+      def original_method
+        subject_class.instance_method(original_method_alias_name)
+      end
+
       protected
       def subject_respond_to_method?(subject, method_name)
         subject_has_method_defined?(method_name) ||
-          ClassInstanceMethodDefined.call(subject_class, :respond_to?) &&
+          class_instance_method_defined(subject_class, :respond_to?) &&
           subject.respond_to?(method_name)
       end
     end

data/lib/rr/injections/method_missing_injection.rb

@@ -12,6 +12,7 @@ module RR
           instances.include?(subject)
         end
       end)
+      include ClassInstanceMethodDefined
 
       attr_reader :subject_class
       def initialize(subject_class)
@@ -20,8 +21,8 @@ module RR
       end
 
       def bind
-        unless ClassInstanceMethodDefined.call(subject_class, original_method_alias_name)
-          unless ClassInstanceMethodDefined.call(subject_class, :method_missing)
+        unless class_instance_method_defined(subject_class, original_method_alias_name)
+          unless class_instance_method_defined(subject_class, :method_missing)
             @placeholder_method_defined = true
             subject_class.class_eval do
               def method_missing(method_name, *args, &block)

data/lib/rr/injections/singleton_method_added_injection.rb

@@ -16,6 +16,7 @@ module RR
           instances.include?(subject)
         end
       end)
+      include ClassInstanceMethodDefined
 
       attr_reader :subject_class
       def initialize(subject_class)
@@ -24,8 +25,8 @@ module RR
       end
 
       def bind
-        unless ClassInstanceMethodDefined.call(subject_class, original_method_alias_name, false)
-          unless ClassInstanceMethodDefined.call(subject_class, :singleton_method_added, false)
+        unless class_instance_method_defined(subject_class, original_method_alias_name, false)
+          unless class_instance_method_defined(subject_class, :singleton_method_added, false)
             @placeholder_method_defined = true
             subject_class.class_eval do
               def singleton_method_added(method_name)

data/spec/api/any_instance_of/all_instances_of_spec.rb

@@ -2,13 +2,11 @@ require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper")
 
 describe "all_instances_of" do
   it "applies to instances instantiated before the Double expection was created" do
-    pending("Completion of all_instances_of") do
-      subject_class = Class.new
-      subject = subject_class.new
-      all_instances_of(subject_class) do |o|
-        o.to_s {"Subject is stubbed"}
-      end
-      subject.to_s.should == "Subject is stubbed"
+    subject_class = Class.new
+    subject = subject_class.new
+    all_instances_of(subject_class) do |o|
+      o.to_s {"Subject is stubbed"}
     end
+    subject.to_s.should == "Subject is stubbed"
   end
 end

data/spec/api/{new_instance_of → any_instance_of}/instance_of_spec.rb

@@ -3,13 +3,10 @@ require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper")
 describe "instance_of" do
   it "applies to instances instantiated before the Double expection was created" do
     subject_class = Class.new
-    existing_subject = subject_class.new
-    stub.instance_of(subject_class) do |o|
+    subject = subject_class.new
+    instance_of(subject_class) do |o|
       o.to_s {"Subject is stubbed"}
     end
-    new_subject = subject_class.new
-
-    existing_subject.to_s.should_not == "Subject is stubbed"
-    new_subject.to_s.should == "Subject is stubbed"
+    subject.to_s.should == "Subject is stubbed"
   end
 end

data/spec/core_spec_suite.rb

@@ -8,7 +8,7 @@ class CoreExampleSuite
     files.delete_if {|file| file.include?('test_unit/')}
     puts "Running Rspec Example Suite"
     files.each do |file|
-      require file
+      require File.expand_path(file)
 #      puts "require '#{file}'"
     end
   end

data/spec/rr/double_definitions/double_definition_create_spec.rb

@@ -183,11 +183,11 @@ module RR
             @klass = Class.new
           end
 
-          context "when passed no arguments" do
-            it "returns a DoubleDefinitiondouble_definition_create" do
-              instance_of.instance_of.should be_instance_of(DoubleDefinitionCreate)
-            end
-          end
+#          context "when passed no arguments" do
+#            it "returns a DoubleDefinitiondouble_definition_create" do
+#              instance_of.instance_of.should be_instance_of(DoubleDefinitionCreate)
+#            end
+#          end
 
           context "when passed a method_name argument" do
             it "creates a instance_of Double for method" do
@@ -237,7 +237,7 @@ module RR
                   :baz
                 end
                 mock(subject).foobar(1, 2)
-                
+
                 subject.foobar(1, 2)
                 lambda {subject.foobar(1, 2)}.should raise_error(RR::Errors::TimesCalledError)
                 lambda {RR.verify}.should raise_error(RR::Errors::TimesCalledError)

data/spec/rspec_spec_suite.rb

@@ -7,7 +7,7 @@ class RspecExampleSuite
     dir = File.dirname(__FILE__)
     Dir["#{dir}/rr/rspec/**/*_spec.rb"].each do |file|
 #      puts "require '#{file}'"
-      require file
+      require File.expand_path(file)
     end
   end
 end

data/spec/test_unit_spec_suite.rb

@@ -11,7 +11,7 @@ class TestUnitTestSuite
   def require_tests
     dir = File.dirname(__FILE__)
     Dir["#{dir}/rr/test_unit/**/*_test.rb"].each do |file|
-      require file
+      require File.expand_path(file)
     end
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: rr
 version: !ruby/object:Gem::Version 
-  hash: 23
+  hash: 21
   prerelease: false
   segments: 
   - 1
   - 0
-  - 0
-  version: 1.0.0
+  - 1
+  version: 1.0.1
 platform: ruby
 authors: 
 - Brian Takita
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-08-23 00:00:00 -07:00
+date: 2010-10-30 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -48,11 +48,9 @@ files:
 - lib/rr/double_definitions/double_definition_create_blank_slate.rb
 - lib/rr/double_definitions/double_injections/any_instance_of.rb
 - lib/rr/double_definitions/double_injections/instance.rb
-- lib/rr/double_definitions/double_injections/new_instance_of.rb
 - lib/rr/double_definitions/strategies/double_injection/any_instance_of.rb
 - lib/rr/double_definitions/strategies/double_injection/double_injection_strategy.rb
 - lib/rr/double_definitions/strategies/double_injection/instance.rb
-- lib/rr/double_definitions/strategies/double_injection/new_instance_of.rb
 - lib/rr/double_definitions/strategies/implementation/implementation_strategy.rb
 - lib/rr/double_definitions/strategies/implementation/proxy.rb
 - lib/rr/double_definitions/strategies/implementation/reimplementation.rb
@@ -114,10 +112,9 @@ files:
 - scratch.rb
 - spec/api/any_instance_of/all_instances_of_spec.rb
 - spec/api/any_instance_of/any_instance_of_spec.rb
+- spec/api/any_instance_of/instance_of_spec.rb
 - spec/api/dont_allow/dont_allow_after_stub_spec.rb
 - spec/api/mock/mock_spec.rb
-- spec/api/new_instance_of/instance_of_spec.rb
-- spec/api/new_instance_of/new_instance_of_spec.rb
 - spec/api/proxy/proxy_spec.rb
 - spec/api/spy/spy_spec.rb
 - spec/api/strong/strong_spec.rb

data/lib/rr/double_definitions/double_injections/new_instance_of.rb

@@ -1,53 +0,0 @@
-module RR
-  module DoubleDefinitions
-    module DoubleInjections
-      class NewInstanceOf
-        extend(Module.new do
-          include RR::Adapters::RRMethods
-          def call(subject, stubbed_methods={})
-            double_definition_create = DoubleDefinitionCreate.new.stub
-            stub.proxy(subject).allocate do |instance|
-              add_stubbed_methods(instance, stubbed_methods)
-              add_method_chain_definition(instance, double_definition_create)
-              yield(instance) if block_given?
-              instance
-            end
-            stub(subject).new do |*args|
-              instance = subject.allocate
-              initialize_subject_instance(instance, args)
-            end
-            DoubleDefinitionCreateBlankSlate.new(double_definition_create)
-          end
-
-          protected
-          def add_stubbed_methods(subject_instance, stubbed_methods)
-            stubbed_methods.each do |name, value|
-              value_proc = value.is_a?(Proc) ? value : lambda {value}
-              stub(subject_instance, name).returns(&value_proc)
-            end
-          end
-
-          def add_method_chain_definition(subject_instance, double_definition_create)
-            implementation_strategy = double_definition_create.implementation_strategy
-            if implementation_strategy.method_name
-              stub(subject_instance).method_missing(
-                implementation_strategy.method_name,
-                *implementation_strategy.args,
-                &implementation_strategy.handler
-              )
-            end
-          end
-
-          def initialize_subject_instance(subject_instance, args)
-            if args.last.is_a?(ProcFromBlock)
-              subject_instance.__send__(:initialize, *args[0..(args.length-2)], &args.last)
-            else
-              subject_instance.__send__(:initialize, *args)
-            end
-            subject_instance
-          end
-        end)
-      end
-    end
-  end
-end

data/lib/rr/double_definitions/strategies/double_injection/new_instance_of.rb

@@ -1,37 +0,0 @@
-module RR
-  module DoubleDefinitions
-    module Strategies
-      module DoubleInjection
-        # This class is Deprecated.
-        # Calling instance_of will cause all instances of the passed in Class
-        # to have the Double defined.
-        #
-        # The following example mocks all User's valid? method and return false.
-        #   mock.instance_of(User).valid? {false}
-        #
-        # The following example mocks and proxies User#projects and returns the
-        # first 3 projects.
-        #   mock.instance_of(User).projects do |projects|
-        #     projects[0..2]
-        #   end        
-        class NewInstanceOf < DoubleInjectionStrategy
-          protected
-          def do_call
-            if !double_definition_create.no_subject? && !double_definition_create.subject.is_a?(Class)
-              raise ArgumentError, "instance_of only accepts class objects"
-            end
-            DoubleDefinitions::DoubleInjections::NewInstanceOf.call(subject) do |subject|
-              add_double_to_instance(subject)
-            end
-          end
-          
-          def add_double_to_instance(instance)
-            double_injection = Injections::DoubleInjection.find_or_create((class << instance; self; end), method_name)
-            Double.new(double_injection, definition)
-            instance
-          end
-        end
-      end
-    end
-  end
-end

data/spec/api/new_instance_of/new_instance_of_spec.rb

@@ -1,61 +0,0 @@
-require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper")
-
-describe "new_instance_of" do
-  context "when passed a method chain" do
-    it "stubs the called method name with the given value" do
-      subject_class = Class.new
-      existing_subject = subject_class.new
-      new_instance_of(subject_class).foobar {:baz}
-
-      subject_new = subject_class.new
-      existing_subject.should_not respond_to(:foobar)
-      subject_new.foobar.should == :baz
-
-      subject_allocate = subject_class.allocate
-      existing_subject.should_not respond_to(:foobar)
-      subject_allocate.foobar.should == :baz
-    end
-  end
-
-  context "when passed a block" do
-    it "applies to instances instantiated before the Double expection was created" do
-      subject_class = Class.new
-      existing_subject = subject_class.new
-      class_called = false
-      new_instance_of(subject_class) do |o|
-        stub(o).to_s {"Subject is stubbed"}
-        stub.proxy(o).class {|klass| class_called = true; klass}
-      end
-
-      existing_subject.to_s.should_not == "Subject is stubbed"
-
-      subject_new = subject_class.new
-      subject_new.to_s.should == "Subject is stubbed"
-      subject_new.class.should == subject_class
-      class_called.should be_true
-
-      subject_allocate = subject_class.allocate
-      subject_allocate.to_s.should == "Subject is stubbed"
-      subject_allocate.class.should == subject_class
-    end
-  end
-
-  context "when passed a Hash" do
-    it "stubs methods (key) with the value on instances instantiated before the Double expection was created" do
-      subject_class = Class.new
-      existing_subject = subject_class.new
-      new_instance_of(subject_class, :to_s => "Subject is stubbed", :foobar => lambda {:baz})
-
-      existing_subject.to_s.should_not == "Subject is stubbed"
-      existing_subject.should_not respond_to(:foobar)
-
-      subject_new = subject_class.new
-      subject_new.to_s.should == "Subject is stubbed"
-      subject_new.foobar.should == :baz
-      
-      subject_allocate = subject_class.allocate
-      subject_allocate.to_s.should == "Subject is stubbed"
-      subject_allocate.foobar.should == :baz
-    end
-  end
-end