rr 0.4.8 → 0.4.9

data/lib/rr/{double_method_proxy.rb → double_definition_creator_proxy.rb}

@@ -1,5 +1,5 @@
 module RR
-  class DoubleMethodProxy
+  class DoubleDefinitionCreatorProxy
     def initialize(creator, object, &block) #:nodoc:
       @creator = creator
       @object = object
@@ -9,7 +9,7 @@ module RR
         end
 
         def method_missing(method_name, *args, &block)
-          @creator.create!(@object, method_name, *args, &block)
+          @creator.create(@object, method_name, *args, &block)
         end
       end
       yield(self) if block_given?

data/lib/rr/double_injection.rb

@@ -10,7 +10,7 @@ module RR
       @object = object
       @method_name = method_name.to_sym
       if object_has_method?(method_name)
-        meta.send(:alias_method, original_method_name, method_name)
+        meta.__send__(:alias_method, original_method_name, method_name)
       end
       @doubles = []
     end
@@ -47,12 +47,12 @@ module RR
     # It binds the original method implementation on the object
     # if one exists.
     def reset
-      meta.send(:remove_method, placeholder_name)
+      meta.__send__(:remove_method, placeholder_name)
       if object_has_original_method?
-        meta.send(:alias_method, @method_name, original_method_name)
-        meta.send(:remove_method, original_method_name)
+        meta.__send__(:alias_method, @method_name, original_method_name)
+        meta.__send__(:remove_method, original_method_name)
       else
-        meta.send(:remove_method, @method_name)
+        meta.__send__(:remove_method, @method_name)
       end
     end
 
@@ -80,7 +80,7 @@ module RR
     end
 
     def find_double_to_attempt(args)
-      matches = DoubleMatches.new(@doubles).find_all_matches!(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

data/lib/rr/double_matches.rb

@@ -1,51 +1,51 @@
 module RR
-class DoubleMatches
-  attr_reader :matching_doubles,
-              :exact_terminal_doubles_to_attempt,
-              :exact_non_terminal_doubles_to_attempt,
-              :wildcard_terminal_doubles_to_attempt,
-              :wildcard_non_terminal_doubles_to_attempt
-  def initialize(doubles) #:nodoc:
-    @doubles = doubles
-    @matching_doubles = []
-    @exact_terminal_doubles_to_attempt = []
-    @exact_non_terminal_doubles_to_attempt = []
-    @wildcard_terminal_doubles_to_attempt = []
-    @wildcard_non_terminal_doubles_to_attempt = []
-  end
+  class DoubleMatches
+    attr_reader :matching_doubles,
+                :exact_terminal_doubles_to_attempt,
+                :exact_non_terminal_doubles_to_attempt,
+                :wildcard_terminal_doubles_to_attempt,
+                :wildcard_non_terminal_doubles_to_attempt
+    def initialize(doubles) #:nodoc:
+      @doubles = doubles
+      @matching_doubles = []
+      @exact_terminal_doubles_to_attempt = []
+      @exact_non_terminal_doubles_to_attempt = []
+      @wildcard_terminal_doubles_to_attempt = []
+      @wildcard_non_terminal_doubles_to_attempt = []
+    end
 
-  def find_all_matches!(args)
-    @doubles.each do |double|
-      if double.exact_match?(*args)
-        matching_doubles << double
-        if double.attempt?
-          exact_double_is_terminal_or_non_terminal double
-        end
-      elsif double.wildcard_match?(*args)
-        matching_doubles << double
-        if double.attempt?
-          wildcard_double_is_terminal_or_non_terminal double
+    def find_all_matches(args)
+      @doubles.each do |double|
+        if double.exact_match?(*args)
+          matching_doubles << double
+          if double.attempt?
+            exact_double_is_terminal_or_non_terminal double
+          end
+        elsif double.wildcard_match?(*args)
+          matching_doubles << double
+          if double.attempt?
+            wildcard_double_is_terminal_or_non_terminal double
+          end
         end
       end
+      self
     end
-    self
-  end
 
-  protected
-  def exact_double_is_terminal_or_non_terminal(double)
-    if double.terminal?
-      exact_terminal_doubles_to_attempt << double
-    else
-      exact_non_terminal_doubles_to_attempt << double
+    protected
+    def exact_double_is_terminal_or_non_terminal(double)
+      if double.terminal?
+        exact_terminal_doubles_to_attempt << double
+      else
+        exact_non_terminal_doubles_to_attempt << double
+      end
     end
-  end
 
-  def wildcard_double_is_terminal_or_non_terminal(double)
-    if double.terminal?
-      wildcard_terminal_doubles_to_attempt << double
-    else
-      wildcard_non_terminal_doubles_to_attempt << double
+    def wildcard_double_is_terminal_or_non_terminal(double)
+      if double.terminal?
+        wildcard_terminal_doubles_to_attempt << double
+      else
+        wildcard_non_terminal_doubles_to_attempt << double
+      end
     end
   end
-end
 end

data/lib/rr/errors/rr_error.rb

@@ -6,7 +6,7 @@ module RR
       attr_writer :backtrace
       def backtrace
         original_backtrace = (@backtrace) ? @backtrace : super
-        return original_backtrace unless RR::Space.trim_backtrace
+        return original_backtrace unless RR.trim_backtrace
 
         return original_backtrace unless original_backtrace.respond_to?(:each)
         new_backtrace = []

data/lib/rr/expectations/times_called_expectation.rb

@@ -15,7 +15,7 @@ module RR
         @matcher.attempt?(@times_called)
       end
 
-      def attempt!
+      def attempt
         @times_called += 1
         verify_input_error unless @matcher.possible_match?(@times_called)
         return

data/lib/rr/space.rb

@@ -1,14 +1,18 @@
 module RR
-  # RR::Space is a Dependency Injection http://en.wikipedia.org/wiki/Dependency_injection
-  # and global state object for the RR framework. The RR::Space.instance
-  # is a singleton that holds the state.
+  # RR::Space.instance is the global state object for the RR framework.
   class Space
+    module Reader
+      def space
+        RR::Space.instance
+      end
+    end
+
     class << self
       def instance
         @instance ||= new
       end
       attr_writer :instance
-      
+
       protected
       def method_missing(method_name, *args, &block)
         instance.__send__(method_name, *args, &block)
@@ -23,32 +27,6 @@ module RR
       @trim_backtrace = false
     end
 
-    def double_method_proxy(creator, object, method_name=nil, &definition)
-      if method_name && definition
-        raise ArgumentError, "Cannot pass in a method name and a block"
-      end
-      proxy = DoubleMethodProxy.new(creator, object, &definition)
-      return proxy unless method_name
-      proxy.__send__(method_name)
-    end
-
-    # Creates a DoubleCreator.
-    def double_creator
-      DoubleCreator.new(self)
-    end
-
-    # Creates and registers a Double to be verified.
-    def double(double_injection, definition = double_definition)
-      double = Double.new(self, double_injection, definition)
-      double.definition.double = double
-      double_injection.register_double double
-      double
-    end
-
-    def double_definition
-      DoubleDefinition.new(self)
-    end
-
     # Reuses or creates, if none exists, a DoubleInjection for the passed
     # in object and method_name.
     # When a DoubleInjection is created, it binds the dispatcher to the
@@ -94,6 +72,7 @@ module RR
         end
       end
     end
+    alias_method :verify, :verify_doubles
 
     # Resets the registered Doubles and ordered Doubles
     def reset

data/spec/high_level_spec.rb

@@ -1,187 +1,184 @@
 dir = File.dirname(__FILE__)
 require "#{dir}/spec_helper"
 
-describe "RR", :shared => true do
+class HighLevelSpec
+end
+
+describe "RR" do
   before(:each) do
     @obj = Object.new
     extend RR::Adapters::RRMethods
   end
 
   after(:each) do
-    RR::Space.instance.reset
-  end
-end
-
-describe "RR mock:" do
-  it_should_behave_like "RR"
-
-  it "mocks via inline call" do
-    mock(@obj).to_s {"a value"}
-    @obj.to_s.should == "a value"
-    proc {@obj.to_s}.should raise_error(RR::Errors::TimesCalledError)
-  end
-
-  it "allows ordering" do
-    mock(@obj).to_s {"value 1"}.ordered
-    mock(@obj).to_s {"value 2"}.twice.ordered
-    @obj.to_s.should == "value 1"
-    @obj.to_s.should == "value 2"
-    @obj.to_s.should == "value 2"
-    proc {@obj.to_s}.should raise_error(RR::Errors::TimesCalledError)
+    RR.reset
   end
 
-  it "mocks via block" do
-    mock @obj do |c|
-      c.to_s {"a value"}
-      c.to_sym {:crazy}
+  describe "RR mock:" do
+    it "mocks via inline call" do
+      mock(@obj).to_s {"a value"}
+      @obj.to_s.should == "a value"
+      lambda {@obj.to_s}.should raise_error(RR::Errors::TimesCalledError)
     end
-    @obj.to_s.should == "a value"
-    @obj.to_sym.should == :crazy
-  end
-  
-  it "has wildcard matchers" do
-    mock(@obj).foobar(
-      is_a(String),
-      anything,
-      numeric,
-      boolean,
-      duck_type(:to_s),
-      /abc/
-    ) {"value 1"}.twice
-    @obj.foobar(
-      'hello',
-      Object.new,
-      99,
-      false,
-      "My String",
-      "Tabcola"
-    ).should == "value 1"
-    proc do
-      @obj.foobar(:failure)
-    end.should raise_error( RR::Errors::DoubleNotFoundError )
-  end
-
-  it "mocks methods without letters" do
-    mock(@obj) == 55
-    
-    @obj == 55
-    proc do
-      @obj == 99
-    end.should raise_error(RR::Errors::DoubleNotFoundError)
-  end
-end
 
-describe "RR proxy:" do
-  it_should_behave_like "RR"
+    it "allows ordering" do
+      mock(@obj).to_s {"value 1"}.ordered
+      mock(@obj).to_s {"value 2"}.twice.ordered
+      @obj.to_s.should == "value 1"
+      @obj.to_s.should == "value 2"
+      @obj.to_s.should == "value 2"
+      lambda {@obj.to_s}.should raise_error(RR::Errors::TimesCalledError)
+    end
 
-  it "proxies via inline call" do
-    expected_to_s_value = @obj.to_s
-    mock.proxy(@obj).to_s
-    @obj.to_s.should == expected_to_s_value
-    proc {@obj.to_s}.should raise_error
-  end
+    it "mocks via block" do
+      mock @obj do |c|
+        c.to_s {"a value"}
+        c.to_sym {:crazy}
+      end
+      @obj.to_s.should == "a value"
+      @obj.to_sym.should == :crazy
+    end
 
-  it "proxy allows ordering" do
-    def @obj.to_s(arg)
-      "Original to_s with arg #{arg}"
+    it "has wildcard matchers" do
+      mock(@obj).foobar(
+        is_a(String),
+        anything,
+        numeric,
+        boolean,
+        duck_type(:to_s),
+        /abc/
+      ) {"value 1"}.twice
+      @obj.foobar(
+        'hello',
+        Object.new,
+        99,
+        false,
+        "My String",
+        "Tabcola"
+      ).should == "value 1"
+      lambda do
+        @obj.foobar(:failure)
+      end.should raise_error( RR::Errors::DoubleNotFoundError )
     end
-    mock.proxy(@obj).to_s(:foo).ordered
-    mock.proxy(@obj).to_s(:bar).twice.ordered
 
-    @obj.to_s(:foo).should == "Original to_s with arg foo"
-    @obj.to_s(:bar).should == "Original to_s with arg bar"
-    @obj.to_s(:bar).should == "Original to_s with arg bar"
-    proc {@obj.to_s(:bar)}.should raise_error(RR::Errors::TimesCalledError)
-  end
+    it "mocks methods without letters" do
+      mock(@obj) == 55
 
-  it "proxy allows ordering" do
-    def @obj.to_s(arg)
-      "Original to_s with arg #{arg}"
+      @obj == 55
+      lambda do
+        @obj == 99
+      end.should raise_error(RR::Errors::DoubleNotFoundError)
     end
-    mock.proxy(@obj).to_s(:foo).ordered
-    mock.proxy(@obj).to_s(:bar).twice.ordered
-
-    @obj.to_s(:foo).should == "Original to_s with arg foo"
-    @obj.to_s(:bar).should == "Original to_s with arg bar"
-    @obj.to_s(:bar).should == "Original to_s with arg bar"
-    proc {@obj.to_s(:bar)}.should raise_error(RR::Errors::TimesCalledError)
   end
 
-  it "proxies via block" do
-    def @obj.foobar_1(*args)
-      :original_value_1
+  describe "RR proxy:" do
+    it "proxies via inline call" do
+      expected_to_s_value = @obj.to_s
+      mock.proxy(@obj).to_s
+      @obj.to_s.should == expected_to_s_value
+      lambda {@obj.to_s}.should raise_error
     end
 
-    def @obj.foobar_2
-      :original_value_2
+    it "proxy allows ordering" do
+      def @obj.to_s(arg)
+        "Original to_s with arg #{arg}"
+      end
+      mock.proxy(@obj).to_s(:foo).ordered
+      mock.proxy(@obj).to_s(:bar).twice.ordered
+
+      @obj.to_s(:foo).should == "Original to_s with arg foo"
+      @obj.to_s(:bar).should == "Original to_s with arg bar"
+      @obj.to_s(:bar).should == "Original to_s with arg bar"
+      lambda {@obj.to_s(:bar)}.should raise_error(RR::Errors::TimesCalledError)
     end
 
-    mock.proxy @obj do |c|
-      c.foobar_1(1)
-      c.foobar_2
+    it "proxy allows ordering" do
+      def @obj.to_s(arg)
+        "Original to_s with arg #{arg}"
+      end
+      mock.proxy(@obj).to_s(:foo).ordered
+      mock.proxy(@obj).to_s(:bar).twice.ordered
+
+      @obj.to_s(:foo).should == "Original to_s with arg foo"
+      @obj.to_s(:bar).should == "Original to_s with arg bar"
+      @obj.to_s(:bar).should == "Original to_s with arg bar"
+      lambda {@obj.to_s(:bar)}.should raise_error(RR::Errors::TimesCalledError)
     end
-    @obj.foobar_1(1).should == :original_value_1
-    proc {@obj.foobar_1(:blah)}.should raise_error
 
-    @obj.foobar_2.should == :original_value_2
-    proc {@obj.foobar_2(:blah)}.should raise_error
-  end
+    it "proxies via block" do
+      def @obj.foobar_1(*args)
+        :original_value_1
+      end
 
-  it "proxies via block" do
-    def @obj.foobar_1(*args)
-      :original_value_1
-    end
+      def @obj.foobar_2
+        :original_value_2
+      end
 
-    def @obj.foobar_2
-      :original_value_2
-    end
+      mock.proxy @obj do |c|
+        c.foobar_1(1)
+        c.foobar_2
+      end
+      @obj.foobar_1(1).should == :original_value_1
+      lambda {@obj.foobar_1(:blah)}.should raise_error
 
-    mock.proxy @obj do |c|
-      c.foobar_1(1)
-      c.foobar_2
+      @obj.foobar_2.should == :original_value_2
+      lambda {@obj.foobar_2(:blah)}.should raise_error
     end
-    @obj.foobar_1(1).should == :original_value_1
-    proc {@obj.foobar_1(:blah)}.should raise_error
 
-    @obj.foobar_2.should == :original_value_2
-    proc {@obj.foobar_2(:blah)}.should raise_error
-  end
-end
+    it "proxies via block" do
+      def @obj.foobar_1(*args)
+        :original_value_1
+      end
+
+      def @obj.foobar_2
+        :original_value_2
+      end
 
-describe "RR stub:" do
-  it_should_behave_like "RR"
+      mock.proxy @obj do |c|
+        c.foobar_1(1)
+        c.foobar_2
+      end
+      @obj.foobar_1(1).should == :original_value_1
+      lambda {@obj.foobar_1(:blah)}.should raise_error
 
-  it "stubs via inline call" do
-    stub(@obj).to_s {"a value"}
-    @obj.to_s.should == "a value"
+      @obj.foobar_2.should == :original_value_2
+      lambda {@obj.foobar_2(:blah)}.should raise_error
+    end
   end
 
-  it "allows ordering" do
-    stub(@obj).to_s {"value 1"}.once.ordered
-    stub(@obj).to_s {"value 2"}.once.ordered
+  describe "RR stub:" do
+    it "stubs via inline call" do
+      stub(@obj).to_s {"a value"}
+      @obj.to_s.should == "a value"
+    end
 
-    @obj.to_s.should == "value 1"
-    @obj.to_s.should == "value 2"
-  end
+    it "allows ordering" do
+      stub(@obj).to_s {"value 1"}.once.ordered
+      stub(@obj).to_s {"value 2"}.once.ordered
 
-  it "stubs via block" do
-    stub @obj do |d|
-      d.to_s {"a value"}
-      d.to_sym {:crazy}
+      @obj.to_s.should == "value 1"
+      @obj.to_s.should == "value 2"
     end
-    @obj.to_s.should == "a value"
-    @obj.to_sym.should == :crazy
-  end
 
-  it "stubs instance_of" do
-    stub.instance_of(Date) do |o|
-      o.to_s {"The Date"}
+    it "stubs via block" do
+      stub @obj do |d|
+        d.to_s {"a value"}
+        d.to_sym {:crazy}
+      end
+      @obj.to_s.should == "a value"
+      @obj.to_sym.should == :crazy
+    end
+
+    it "stubs instance_of" do
+      stub.instance_of(HighLevelSpec) do |o|
+        o.to_s {"High Level Spec"}
+      end
+      HighLevelSpec.new.to_s.should == "High Level Spec"
     end
-    Date.new.to_s.should == "The Date"
-  end
 
-  it "stubs methods without letters" do
-    stub(@obj).__send__(:==) {:equality}
-    (@obj == 55).should == :equality
+    it "stubs methods without letters" do
+      stub(@obj).__send__(:==) {:equality}
+      (@obj == 55).should == :equality
+    end
   end
 end