rr 0.4.3 → 0.4.4

data/CHANGES

@@ -1,3 +1,7 @@
+* 0.4.4
+- Doc improvements
+- Methods that are not alphabetic, such as ==, can be doubles
+
 * 0.4.3
 - Doc improvements
 - Cleanup

data/README

@@ -186,6 +186,30 @@ Put double scenarios on instances of a Class.
     m.system("rake baz") {true}
   end
 
+=== Wildcard matchers
+==== anything
+  mock(object).foobar(1, anything)
+  object.foobar(1, :my_symbol)
+
+==== is_a
+  mock(object).foobar(is_a(Time))
+  object.foobar(Time.now)
+
+==== numeric
+  mock(object).foobar(numeric)
+  object.foobar(99)
+
+==== numeric
+  mock(object).foobar(boolean)
+  object.foobar(false)
+
+==== duck_type
+  mock(object).foobar(duck_type(:walk, :talk))
+  arg = Object.new
+  def arg.walk; 'waddle'; end
+  def arg.talk; 'quack'; end
+  object.foobar(arg)
+
 == 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.
@@ -193,6 +217,7 @@ to making it possible. We all are standing on the shoulders of giants.
 * Parker Thompson for pairing with me
 * Felix Morio for pairing with me
 * Jeff Whitmire for documentation suggestions
+* 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"

data/Rakefile

@@ -26,7 +26,7 @@ def run_suite
 end
 
 PKG_NAME = "rr"
-PKG_VERSION = "0.4.3"
+PKG_VERSION = "0.4.4"
 PKG_FILES = FileList[
   '[A-Z]*',
   '*.rb',

data/lib/rr/double.rb

@@ -16,11 +16,11 @@ module RR
       end
     end
 
-    attr_reader :times_called, :double_insertion, :definition
+    attr_reader :times_called, :double_injection, :definition
 
-    def initialize(space, double_insertion, definition)
+    def initialize(space, double_injection, definition)
       @space = space
-      @double_insertion = double_insertion
+      @double_injection = double_injection
       @definition = definition
       @times_called = 0
       @times_called_expectation = Expectations::TimesCalledExpectation.new(self)
@@ -216,11 +216,11 @@ module RR
     #
     # A TimesCalledError is raised when the times called
     # exceeds the expected TimesCalledExpectation.
-    def call(double_insertion, *args, &block)
+    def call(double_injection, *args, &block)
       self.times_called_expectation.attempt! if definition.times_matcher
       @space.verify_ordered_double(self) if ordered?
       yields!(block)
-      return_value = call_implementation(double_insertion, *args, &block)
+      return_value = call_implementation(double_injection, *args, &block)
       return return_value unless definition.after_call_value
       definition.after_call_value.call(return_value)
     end
@@ -235,14 +235,14 @@ module RR
     end
     protected :yields!
 
-    def call_implementation(double_insertion, *args, &block)
+    def call_implementation(double_injection, *args, &block)
       return nil unless implementation
 
       if implementation === DoubleDefinition::ORIGINAL_METHOD
-        if double_insertion.object_has_original_method?
-          return double_insertion.call_original_method(*args, &block)
+        if double_injection.object_has_original_method?
+          return double_injection.call_original_method(*args, &block)
         else
-          return double_insertion.object.__send__(
+          return double_injection.object.__send__(
             :method_missing,
             method_name,
             *args,
@@ -295,7 +295,7 @@ module RR
 
     # The method name that this Double is attatched to
     def method_name
-      double_insertion.method_name
+      double_injection.method_name
     end
 
     # The Arguments that this Double expects

data/lib/rr/double_creator.rb

@@ -200,21 +200,21 @@ module RR
     
     protected
     def setup_double(subject, method_name)
-      @double_insertion = @space.double_insertion(subject, method_name)
-      @double = @space.double(@double_insertion)
+      @double_injection = @space.double_injection(subject, method_name)
+      @double = @space.double(@double_injection)
       @definition = @double.definition
     end
 
     def setup_class_probing_instances(subject, method_name)
-      class_double = @space.double_insertion(subject, :new)
+      class_double = @space.double_injection(subject, :new)
       class_double = @space.double(class_double)
 
       instance_method_name = method_name
 
       @definition = @space.double_definition
       class_handler = proc do |return_value|
-        double_insertion = @space.double_insertion(return_value, instance_method_name)
-        @space.double(double_insertion, @definition)
+        double_injection = @space.double_injection(return_value, instance_method_name)
+        @space.double(double_injection, @definition)
         return_value
       end
 

data/lib/rr/double_injection.rb

@@ -1,13 +1,12 @@
 module RR
   # RR::DoubleInjection is the binding of an object and a method.
-  # A double_insertion has 0 to many Double objects. Each Double
+  # A double_injection has 0 to many Double objects. Each Double
   # has Argument Expectations and Times called Expectations.
   class DoubleInjection
     MethodArguments = Struct.new(:arguments, :block)
-    attr_reader :space, :object, :method_name, :doubles
+    attr_reader :object, :method_name, :doubles
 
-    def initialize(space, object, method_name)
-      @space = space
+    def initialize(object, method_name)
       @object = object
       @method_name = method_name.to_sym
       if object_has_method?(method_name)
@@ -30,7 +29,7 @@ module RR
       returns_method = <<-METHOD
         def #{@method_name}(*args, &block)
           arguments = MethodArguments.new(args, block)
-          #{placeholder_name}(arguments)
+          __send__('#{placeholder_name}', arguments)
         end
       METHOD
       meta.class_eval(returns_method, __FILE__, __LINE__ - 5)
@@ -69,7 +68,7 @@ module RR
     def define_implementation_placeholder
       me = self
       meta.send(:define_method, placeholder_name) do |arguments|
-        me.send(:call_method, arguments.arguments, arguments.block)
+        me.__send__(:call_method, arguments.arguments, arguments.block)
       end
     end
 
@@ -108,7 +107,8 @@ module RR
     end
 
     def double_not_found_error(*args)
-      message = "Unexpected method invocation #{Double.formatted_name(@method_name, args)}, expected\n"
+      message = "On object #{object},\n"
+      message << "unexpected method invocation #{Double.formatted_name(@method_name, args)}, expected\n"
       message << Double.list_message_part(@doubles)
       raise Errors::DoubleNotFoundError, message
     end

data/lib/rr/double_method_proxy.rb

@@ -1,7 +1,6 @@
 module RR
   class DoubleMethodProxy
-    def initialize(space, creator, object, &block) #:nodoc:
-      @space = space
+    def initialize(creator, object, &block) #:nodoc:
       @creator = creator
       @object = object
       class << self

data/lib/rr/space.rb

@@ -15,10 +15,10 @@ module RR
       end
     end
 
-    attr_reader :double_insertions, :ordered_doubles
+    attr_reader :double_injections, :ordered_doubles
     attr_accessor :trim_backtrace
     def initialize
-      @double_insertions = HashWithObjectIdKey.new
+      @double_injections = HashWithObjectIdKey.new
       @ordered_doubles = []
       @trim_backtrace = false
     end
@@ -27,7 +27,7 @@ module RR
       if method_name && definition
         raise ArgumentError, "Cannot pass in a method name and a block"
       end
-      proxy = DoubleMethodProxy.new(self, creator, object, &definition)
+      proxy = DoubleMethodProxy.new(creator, object, &definition)
       return proxy unless method_name
       proxy.__send__(method_name)
     end
@@ -38,10 +38,10 @@ module RR
     end
 
     # Creates and registers a Double to be verified.
-    def double(double_insertion, definition = double_definition)
-      double = Double.new(self, double_insertion, definition)
+    def double(double_injection, definition = double_definition)
+      double = Double.new(self, double_injection, definition)
       double.definition.double = double
-      double_insertion.register_double double
+      double_injection.register_double double
       double
     end
 
@@ -53,14 +53,14 @@ module RR
     # in object and method_name.
     # When a DoubleInjection is created, it binds the dispatcher to the
     # object.
-    def double_insertion(object, method_name)
-      double_insertion = @double_insertions[object][method_name.to_sym]
-      return double_insertion if double_insertion
+    def double_injection(object, method_name)
+      double_injection = @double_injections[object][method_name.to_sym]
+      return double_injection if double_injection
 
-      double_insertion = DoubleInjection.new(self, object, method_name.to_sym)
-      @double_insertions[object][method_name.to_sym] = double_insertion
-      double_insertion.bind
-      double_insertion
+      double_injection = DoubleInjection.new(object, method_name.to_sym)
+      @double_injections[object][method_name.to_sym] = double_injection
+      double_injection.bind
+      double_injection
     end
 
     # Registers the ordered Double to be verified.
@@ -88,7 +88,7 @@ module RR
     # Verifies all the DoubleInjection objects have met their
     # TimesCalledExpectations.
     def verify_doubles
-      @double_insertions.each do |object, method_double_map|
+      @double_injections.each do |object, method_double_map|
         method_double_map.keys.each do |method_name|
           verify_double(object, method_name)
         end
@@ -98,21 +98,21 @@ module RR
     # Resets the registered Doubles and ordered Doubles
     def reset
       reset_ordered_doubles
-      reset_double_insertions
+      reset_double_injections
     end
 
     # Verifies the DoubleInjection for the passed in object and method_name.
     def verify_double(object, method_name)
-      @double_insertions[object][method_name].verify
+      @double_injections[object][method_name].verify
     ensure
       reset_double object, method_name
     end
 
     # Resets the DoubleInjection for the passed in object and method_name.
     def reset_double(object, method_name)
-      double_insertion = @double_insertions[object].delete(method_name)
-      @double_insertions.delete(object) if @double_insertions[object].empty?
-      double_insertion.reset
+      double_injection = @double_injections[object].delete(method_name)
+      @double_injections.delete(object) if @double_injections[object].empty?
+      double_injection.reset
     end
 
     protected
@@ -122,8 +122,8 @@ module RR
     end
 
     # Resets the registered Doubles for the next test run.
-    def reset_double_insertions
-      @double_insertions.each do |object, method_double_map|
+    def reset_double_injections
+      @double_injections.each do |object, method_double_map|
         method_double_map.keys.each do |method_name|
           reset_double(object, method_name)
         end

data/lib/rr/wildcard_matchers/anything.rb

@@ -8,6 +8,10 @@ module RR
       def ==(other)
         other.is_a?(self.class)
       end
+
+      def inspect
+        'anything'
+      end
     end
   end
 end

data/lib/rr/wildcard_matchers/boolean.rb

@@ -9,6 +9,10 @@ module RR
         other.is_a?(self.class)
       end
 
+      def inspect
+        'boolean'
+      end
+
       protected
       def is_a_boolean?(subject)
         subject.is_a?(TrueClass) || subject.is_a?(FalseClass)

data/lib/rr/wildcard_matchers/duck_type.rb

@@ -15,6 +15,13 @@ module RR
         return true
       end
 
+      def inspect
+        formatted_required_methods = required_methods.collect do |method_name|
+          method_name.inspect
+        end.join(', ')
+        "duck_type(#{formatted_required_methods})"
+      end
+
       def ==(other)
         return false unless other.is_a?(self.class)
         self.required_methods == other.required_methods

data/lib/rr/wildcard_matchers/is_a.rb

@@ -11,6 +11,10 @@ module RR
         self == other || other.is_a?(klass)
       end
 
+      def inspect
+        "is_a(#{klass})"
+      end
+
       def ==(other)
         return false unless other.is_a?(self.class)
         self.klass == other.klass

data/lib/rr/wildcard_matchers/numeric.rb

@@ -4,6 +4,10 @@ module RR
       def initialize
         @klass = ::Numeric
       end
+
+      def inspect
+        'numeric'
+      end
     end
   end
 end

data/spec/high_level_spec.rb

@@ -60,6 +60,15 @@ describe "RR mock:" 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
@@ -170,4 +179,9 @@ describe "RR stub:" do
     end
     Date.new.to_s.should == "The Date"
   end
+
+  it "stubs methods without letters" do
+    stub(@obj).__send__(:==) {:equality}
+    (@obj == 55).should == :equality
+  end
 end

data/spec/rr/adapters/rr_methods_space_spec.rb

@@ -20,16 +20,16 @@ module RR
         end
         
         describe RRMethods, "#verify" do
-          it "#verify verifies and deletes the double_insertions" do
-            verifies_all_double_insertions {verify}
+          it "#verify verifies and deletes the double_injections" do
+            verifies_all_double_injections {verify}
           end
 
-          it "#rr_verify verifies and deletes the double_insertions" do
-            verifies_all_double_insertions {rr_verify}
+          it "#rr_verify verifies and deletes the double_injections" do
+            verifies_all_double_injections {rr_verify}
           end
 
-          def verifies_all_double_insertions
-            double1 = @space.double_insertion(@object1, @method_name)
+          def verifies_all_double_injections
+            double1 = @space.double_injection(@object1, @method_name)
             double1_verify_calls = 0
             double1_reset_calls = 0
             (
@@ -43,7 +43,7 @@ module RR
                 double1_reset_calls += 1
               end
             end
-            double2 = @space.double_insertion(@object2, @method_name)
+            double2 = @space.double_injection(@object2, @method_name)
             double2_verify_calls = 0
             double2_reset_calls = 0
             (
@@ -75,17 +75,17 @@ module RR
             removes_ordered_doubles {rr_reset}
           end
 
-          it "#reset resets all double_insertions" do
-            resets_all_double_insertions {reset}
+          it "#reset resets all double_injections" do
+            resets_all_double_injections {reset}
           end
 
-          it "#rr_reset resets all double_insertions" do
-            resets_all_double_insertions {rr_reset}
+          it "#rr_reset resets all double_injections" do
+            resets_all_double_injections {rr_reset}
           end
 
           def removes_ordered_doubles
-            double1 = @space.double_insertion(@object1, :foobar1)
-            double2 = @space.double_insertion(@object1, :foobar2)
+            double1 = @space.double_injection(@object1, :foobar1)
+            double2 = @space.double_injection(@object1, :foobar2)
 
             double1 = @space.double(double1)
             double2 = @space.double(double2)
@@ -99,8 +99,8 @@ module RR
             @space.ordered_doubles.should be_empty
           end
 
-          def resets_all_double_insertions
-            double1 = @space.double_insertion(@object1, @method_name)
+          def resets_all_double_injections
+            double1 = @space.double_injection(@object1, @method_name)
             double1_reset_calls = 0
             (
             class << double1;
@@ -110,7 +110,7 @@ module RR
                 double1_reset_calls += 1
               end
             end
-            double2 = @space.double_insertion(@object2, @method_name)
+            double2 = @space.double_injection(@object2, @method_name)
             double2_reset_calls = 0
             (
             class << double2;