rr 0.10.2 → 0.10.4

data/spec/spec_helper.rb

@@ -3,6 +3,7 @@ require "#{dir}/environment_fixture_setup"
 require "#{dir}/rr/expectations/times_called_expectation/times_called_expectation_helper"
 require "#{dir}/rr/adapters/rr_methods_spec_helper"
 ARGV.push("--format", "nested") unless ARGV.include?("--format")
+ARGV.push("-b")
 
 Spec::Runner.configure do |config|
   config.mock_with RR::Adapters::Rspec
@@ -105,4 +106,8 @@ class Spec::ExampleGroup
       double_definition
     )
   end
+
+  def eigen(object)
+    class << object; self; end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rr
 version: !ruby/object:Gem::Version 
-  version: 0.10.2
+  version: 0.10.4
 platform: ruby
 authors: 
 - Brian Takita
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-08-30 00:00:00 -07:00
+date: 2009-09-26 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -48,7 +48,6 @@ files:
 - lib/rr/double_definitions/strategies/verification/mock.rb
 - lib/rr/double_definitions/strategies/verification/stub.rb
 - lib/rr/double_definitions/strategies/verification/verification_strategy.rb
-- lib/rr/double_injection.rb
 - lib/rr/double_matches.rb
 - lib/rr/errors/argument_equality_error.rb
 - lib/rr/errors/double_definition_error.rb
@@ -65,6 +64,13 @@ files:
 - lib/rr/expectations/argument_equality_expectation.rb
 - lib/rr/expectations/times_called_expectation.rb
 - lib/rr/hash_with_object_id_key.rb
+- lib/rr/injections/double_injection.rb
+- lib/rr/injections/injection.rb
+- lib/rr/injections/method_missing_injection.rb
+- lib/rr/injections/singleton_method_added_injection.rb
+- lib/rr/method_dispatches/base_method_dispatch.rb
+- lib/rr/method_dispatches/method_dispatch.rb
+- lib/rr/method_dispatches/method_missing_dispatch.rb
 - lib/rr/proc_from_block.rb
 - lib/rr/recorded_calls.rb
 - lib/rr/space.rb
@@ -102,10 +108,6 @@ files:
 - spec/rr/double_definitions/double_definition_creator_proxy_spec.rb
 - spec/rr/double_definitions/double_definition_creator_spec.rb
 - spec/rr/double_definitions/double_definition_spec.rb
-- spec/rr/double_injection/double_injection_bind_spec.rb
-- spec/rr/double_injection/double_injection_dispatching_spec.rb
-- spec/rr/double_injection/double_injection_has_original_method_spec.rb
-- spec/rr/double_injection/double_injection_reset_spec.rb
 - spec/rr/double_injection/double_injection_spec.rb
 - spec/rr/double_injection/double_injection_verify_spec.rb
 - spec/rr/double_spec.rb

data/lib/rr/double_injection.rb

@@ -1,136 +0,0 @@
-module RR
-  # RR::DoubleInjection is the binding of an subject and a method.
-  # A double_injection has 0 to many Double objects. Each Double
-  # has Argument Expectations and Times called Expectations.
-  class DoubleInjection
-    include Space::Reader
-
-    LAZY_METHOD_DEFINITIONS = [
-      (lambda do |subject|
-        subject.respond_to?(:descends_from_active_record?) && subject.descends_from_active_record?
-      end)
-    ]
-
-    MethodArguments = Struct.new(:arguments, :block)
-    attr_reader :subject, :method_name, :doubles, :subject_class
-    
-    def initialize(subject, method_name, subject_class)
-      @subject = subject
-      @subject_class = subject_class
-      @method_name = method_name.to_sym
-      if subject_respond_to_method?(method_name)
-        if LAZY_METHOD_DEFINITIONS.any? {|definition| definition.call(subject)} && !subject.methods.include?(method_name)
-          subject.send(method_name)
-        end
-        subject_class.__send__(:alias_method, original_method_alias_name, method_name)
-      end
-      @doubles = []
-    end
-
-    # RR::DoubleInjection#register_double adds the passed in Double
-    # into this DoubleInjection's list of Double objects.
-    def register_double(double)
-      @doubles << double
-    end
-
-    # RR::DoubleInjection#bind injects a method that acts as a dispatcher
-    # that dispatches to the matching Double when the method
-    # is called.
-    def bind
-      returns_method = <<-METHOD
-        def #{@method_name}(*args, &block)
-          arguments = MethodArguments.new(args, block)
-          RR::Space.double_injection(self, :#{@method_name}).call_method(arguments.arguments, arguments.block)
-        end
-      METHOD
-      subject_class.class_eval(returns_method, __FILE__, __LINE__ - 5)
-      self
-    end
-
-    # RR::DoubleInjection#verify verifies each Double
-    # TimesCalledExpectation are met.
-    def verify
-      @doubles.each do |double|
-        double.verify
-      end
-    end
-
-    # RR::DoubleInjection#reset removes the injected dispatcher method.
-    # It binds the original method implementation on the subject
-    # if one exists.
-    def reset
-      if object_has_original_method?
-        subject_class.__send__(:alias_method, @method_name, original_method_alias_name)
-        subject_class.__send__(:remove_method, original_method_alias_name)
-      else
-        subject_class.__send__(:remove_method, @method_name)
-      end
-    end
-
-    def call_original_method(*args, &block)
-      @subject.__send__(original_method_alias_name, *args, &block)
-    end
-
-    def object_has_original_method?
-      subject_respond_to_method?(original_method_alias_name)
-    end
-
-    def call_method(args, block)
-      space.record_call(subject, method_name, args, block)
-      if double = find_double_to_attempt(args)
-        double.call(self, *args, &block)
-      else
-        double_not_found_error(*args)
-      end
-    end
-    
-    protected
-    def find_double_to_attempt(args)
-      matches = DoubleMatches.new(@doubles).find_all_matches(args)
-
-      unless matches.exact_terminal_doubles_to_attempt.empty?
-        return matches.exact_terminal_doubles_to_attempt.first
-      end
-
-      unless matches.exact_non_terminal_doubles_to_attempt.empty?
-        return matches.exact_non_terminal_doubles_to_attempt.last
-      end
-
-      unless matches.wildcard_terminal_doubles_to_attempt.empty?
-        return matches.wildcard_terminal_doubles_to_attempt.first
-      end
-
-      unless matches.wildcard_non_terminal_doubles_to_attempt.empty?
-        return matches.wildcard_non_terminal_doubles_to_attempt.last
-      end
-
-      unless matches.matching_doubles.empty?
-        return matches.matching_doubles.first # This will raise a TimesCalledError
-      end
-
-      return nil
-    end
-
-    def double_not_found_error(*args)
-      message =
-        "On subject #{subject},\n" <<
-        "unexpected method invocation:\n" <<
-        "  #{Double.formatted_name(@method_name, args)}\n" <<
-        "expected invocations:\n" <<
-        Double.list_message_part(@doubles)
-      raise Errors::DoubleNotFoundError, message
-    end
-
-    def original_method_alias_name
-      "__rr__original_#{@method_name}"
-    end
-
-    def subject_respond_to_method?(method_name)
-      subject_has_method_defined?(method_name) || @subject.respond_to?(method_name)
-    end
-
-    def subject_has_method_defined?(method_name)
-      @subject.methods.include?(method_name.to_s) || @subject.protected_methods.include?(method_name.to_s) || @subject.private_methods.include?(method_name.to_s)
-    end
-  end
-end

data/spec/rr/double_injection/double_injection_bind_spec.rb

@@ -1,99 +0,0 @@
-require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper")
-
-module RR
-  module DoubleDefinitions
-    describe DoubleInjection do
-      attr_reader :subject, :method_name, :double_injection, :original_method
-      describe "#bind" do
-        context "with an existing method" do
-          before do
-            @subject = Object.new
-            @method_name = :foobar
-            def subject.foobar;
-              :original_foobar;
-            end
-            @original_method = @subject.method(method_name)
-            @subject.methods.should include(method_name.to_s)
-
-            subject.method(:foobar).should == original_method
-          end
-
-          context "when the existing method is public" do
-            before do
-              stub(subject, method_name).returns {:new_foobar}
-            end
-
-            it "returns the value of the Double Injection" do
-              subject.foobar.should == :new_foobar
-            end
-
-            it "overrides the original method with the double_injection's dispatching methods" do
-              subject.method(:foobar).should_not == original_method
-            end
-
-            it "stores original method in __rr__original_method_alias_name" do
-              subject.respond_to?(:__rr__original_foobar).should == true
-              subject.method(:__rr__original_foobar).should == original_method
-            end
-          end
-
-          context "when the existing method is private" do
-            before do
-              class << subject
-                private :foobar
-              end
-              @double_injection = RR::Space.double_injection(subject, method_name)
-            end
-
-            it "overrides the original method with the double_injection's dispatching methods" do
-              double_injection.bind
-              subject.method(:foobar).should_not == original_method
-            end
-
-            it "stores original method in __rr__original_method_alias_name" do
-              subject.private_methods.should include('__rr__original_foobar')
-              subject.method(:__rr__original_foobar).should == original_method
-            end
-          end
-        end
-
-        context "without an existing method" do
-          before do
-            @subject = Object.new
-            @method_name = :foobar
-            subject.methods.should_not include(method_name.to_s)
-            RR::Space.double_injection(subject, method_name)
-          end
-
-          it "creates a new method with the double_injection's dispatching methods" do
-            subject.method(method_name).should_not be_nil
-          end
-
-          it "does not create method __rr__original_method_alias_name" do
-            subject.respond_to?(:__rr__original_foobar).should == false
-          end
-        end
-
-        context "with #==" do
-          before do
-            @subject = Object.new
-            @method_name = :'=='
-            subject.should respond_to(method_name)
-            @original_method = subject.method(method_name)
-            subject.methods.should include(method_name.to_s)
-            @double_injection = RR::Space.double_injection(subject, method_name)
-          end
-
-          it "overrides the original method with the double_injection's dispatching methods" do
-            subject.method(method_name).should_not == original_method
-          end
-
-          it "stores original method in __rr__original_method_alias_name" do
-            subject.respond_to?(:"__rr__original_#{method_name}").should == true
-            subject.method(:"__rr__original_#{method_name}").should == original_method
-          end
-        end        
-      end
-    end
-  end
-end

data/spec/rr/double_injection/double_injection_dispatching_spec.rb

@@ -1,244 +0,0 @@
-require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper")
-
-module RR
-  describe DoubleInjection do
-    attr_reader :space, :subject, :double_injection
-    it_should_behave_like "Swapped Space"
-    before do
-      @subject = Object.new
-      subject.methods.should_not include(method_name.to_s)
-      @double_injection = space.double_injection(subject, method_name)
-    end
-
-    def new_double
-      Double.new(
-        double_injection,
-        DoubleDefinitions::DoubleDefinition.new(
-          DoubleDefinitions::DoubleDefinitionCreator.new,
-          subject
-        ).any_number_of_times
-      )
-    end
-
-    describe "methods whose name do not contain ! or ?" do
-      def method_name
-        :foobar
-      end
-
-      context "when the original method uses the passed-in block" do
-        it "executes the passed-in block" do
-          method_fixture = Object.new
-          class << method_fixture
-            def method_with_block(a, b)
-              yield(a, b)
-            end
-          end
-          double = new_double
-          double.definition.with(1, 2).implemented_by(method_fixture.method(:method_with_block))
-          subject.foobar(1, 2) {|a, b| [b, a]}.should == [2, 1]
-        end
-      end
-
-      context "when no other Double with duplicate ArgumentExpectations exists" do
-        it "dispatches to Double that have an exact match" do
-          double1_with_exact_match = new_double
-          double1_with_exact_match.definition.with(:exact_match_1).returns {:return_1}
-          double_with_no_match = new_double
-          double_with_no_match.definition.with("nothing that matches").returns {:no_match}
-          double2_with_exact_match = new_double
-          double2_with_exact_match.definition.with(:exact_match_2).returns {:return_2}
-
-          subject.foobar(:exact_match_1).should == :return_1
-          subject.foobar(:exact_match_2).should == :return_2
-        end
-
-        it "dispatches to Double that have a wildcard match" do
-          double_with_wildcard_match = new_double
-          double_with_wildcard_match.definition.with_any_args.returns {:wild_card_value}
-          double_with_no_match = new_double
-          double_with_no_match.definition.with("nothing that matches").returns {:no_match}
-
-          subject.foobar(:wildcard_match_1).should == :wild_card_value
-          subject.foobar(:wildcard_match_2, 3).should == :wild_card_value
-        end
-      end
-
-      context "when other Doubles exists but none of them match the passed-in arguments" do
-        it "raises DoubleNotFoundError error when arguments do not match a double" do
-          double_1 = new_double
-          double_1.definition.with(1, 2)
-
-          double_2 = new_double
-          double_2.definition.with(3)
-
-          error = nil
-          begin
-            subject.foobar(:arg1, :arg2)
-            viotated "Error should have been raised"
-          rescue Errors::DoubleNotFoundError => e
-            error = e
-          end
-          error.message.should include("On subject #<Object")
-          expected_double_message_part = "unexpected method invocation:\n" <<
-            "  foobar(:arg1, :arg2)\n"
-            "expected invocations:\n"
-            "- foobar(1, 2)\n" <<
-            "- foobar(3)"
-          error.message.should include(expected_double_message_part)
-        end
-      end
-
-      context "when at least one Double with NonTerminal TimesCalledMatchers exits" do
-        it "dispatches to Double with exact match" do
-          double = new_double(1, 2) {:return_value}
-          subject.foobar(1, 2).should == :return_value
-        end
-
-        it "matches to the last Double that was registered with an exact match" do
-          double_1 = new_double(1, 2) {:value_1}
-          double_2 = new_double(1, 2) {:value_2}
-
-          subject.foobar(1, 2).should == :value_2
-        end
-
-        it "dispatches to Double with wildcard match" do
-          new_double(anything) {:return_value}
-          subject.foobar(:dont_care).should == :return_value
-        end
-
-        it "matches to the last Double that was registered with a wildcard match" do
-          new_double(anything) {:value_1}
-          new_double(anything) {:value_2}
-
-          subject.foobar(:dont_care).should == :value_2
-        end
-
-        it "matches to Double with exact match Double even when a Double with wildcard match was registered later" do
-          new_double(1, 2) {:exact_first}
-          new_double(anything, anything) {:wildcard_last}
-
-          subject.foobar(1, 2).should == :exact_first
-        end
-
-        def new_double(*arguments, &return_value)
-          double = super()
-          double.definition.with(*arguments).any_number_of_times.returns(&return_value)
-          double.should_not be_terminal
-          double
-        end
-      end
-
-      context "when two or more Terminal Doubles with duplicate Exact Match ArgumentExpectations exists" do
-        it "dispatches to Double that have an exact match" do
-          new_double(:exact_match) {:return_1}
-
-          subject.foobar(:exact_match).should == :return_1
-        end
-
-        it "dispatches to the first Double that have an exact match" do
-          new_double(:exact_match) {:return_1}
-          new_double(:exact_match) {:return_2}
-
-          subject.foobar(:exact_match).should == :return_1
-        end
-
-        it "dispatches the second Double with an exact match
-          when the first double's Times Called expectation is satisfied" do
-          new_double(:exact_match) {:return_1}
-          new_double(:exact_match) {:return_2}
-
-          subject.foobar(:exact_match)
-          subject.foobar(:exact_match).should == :return_2
-        end
-
-        it "raises TimesCalledError when all of the doubles Times Called expectation is satisfied" do
-          new_double(:exact_match) {:return_1}
-          new_double(:exact_match) {:return_2}
-
-          subject.foobar(:exact_match)
-          subject.foobar(:exact_match)
-          lambda do
-            subject.foobar(:exact_match)
-          end.should raise_error(Errors::TimesCalledError)
-        end
-
-        def new_double(*arguments, &return_value)
-          double = super()
-          double.definition.with(*arguments).once.returns(&return_value)
-          double.should be_terminal
-          double
-        end
-      end
-
-      context "when two or more Doubles with duplicate Wildcard Match ArgumentExpectations exists" do
-        it "dispatches to Double that have a wildcard match" do
-          new_double {:return_1}
-
-          subject.foobar(:anything).should == :return_1
-        end
-
-        it "dispatches to the first Double that has a wildcard match" do
-          new_double {:return_1}
-          new_double {:return_2}
-
-          subject.foobar(:anything).should == :return_1
-        end
-
-        it "dispatches the second Double with a wildcard match
-          when the first double's Times Called expectation is satisfied" do
-          new_double {:return_1}
-          new_double {:return_2}
-
-          subject.foobar(:anything)
-          subject.foobar(:anything).should == :return_2
-        end
-
-        it "raises TimesCalledError when all of the doubles Times Called expectation is satisfied" do
-          new_double {:return_1}
-          new_double {:return_2}
-
-          subject.foobar(:anything)
-          subject.foobar(:anything)
-          lambda do
-            subject.foobar(:anything)
-          end.should raise_error(Errors::TimesCalledError)
-        end
-
-        def new_double(&return_value)
-          double = super
-          double.definition.with_any_args.once.returns(&return_value)
-          double.should be_terminal
-          double
-        end
-      end
-    end
-
-    describe "method names with !" do
-      def method_name
-        :foobar!
-      end
-
-      context "when the original method uses the passed-in block" do
-        it "executes the block" do
-          double = new_double
-          double.definition.with(1, 2) {:return_value}
-          subject.foobar!(1, 2).should == :return_value
-        end
-      end
-    end
-
-    describe "method names with ?" do
-      def method_name
-        :foobar?
-      end
-
-      context "when the original method uses the passed-in block" do
-        it "executes the block" do
-          double = new_double
-          double.definition.with(1, 2) {:return_value}
-          subject.foobar?(1, 2).should == :return_value
-        end
-      end
-    end
-  end
-end