rr 0.3.11 → 0.4.0

data/lib/rr/{scenario_definition.rb → double_definition.rb}

@@ -1,8 +1,8 @@
 module RR
-  # RR::Scenario is the use case for a method call.
+  # RR::Double is the use case for a method call.
   # It has the ArgumentEqualityExpectation, TimesCalledExpectation,
   # and the implementation.
-  class ScenarioDefinition
+  class DoubleDefinition #:nodoc:
     ORIGINAL_METHOD = Object.new
     attr_accessor :times_called,
                   :argument_expectation,
@@ -23,7 +23,7 @@ module RR
       returns_block_callback_strategy!
     end
 
-    # Scenario#with sets the expectation that the Scenario will receive
+    # Double#with sets the expectation that the Double will receive
     # the passed in arguments.
     #
     # Passing in a block sets the return value.
@@ -35,7 +35,7 @@ module RR
       self
     end
 
-    # Scenario#with_any_args sets the expectation that the Scenario can receive
+    # Double#with_any_args sets the expectation that the Double can receive
     # any arguments.
     #
     # Passing in a block sets the return value.
@@ -47,7 +47,7 @@ module RR
       self
     end
 
-    # Scenario#with_no_args sets the expectation that the Scenario will receive
+    # Double#with_no_args sets the expectation that the Double will receive
     # no arguments.
     #
     # Passing in a block sets the return value.
@@ -59,7 +59,7 @@ module RR
       self
     end
 
-    # Scenario#never sets the expectation that the Scenario will never be
+    # Double#never sets the expectation that the Double will never be
     # called.
     #
     # This method does not accept a block because it will never be called.
@@ -70,7 +70,7 @@ module RR
       self
     end
 
-    # Scenario#once sets the expectation that the Scenario will be called
+    # Double#once sets the expectation that the Double will be called
     # 1 time.
     #
     # Passing in a block sets the return value.
@@ -82,7 +82,7 @@ module RR
       self
     end
 
-    # Scenario#twice sets the expectation that the Scenario will be called
+    # Double#twice sets the expectation that the Double will be called
     # 2 times.
     #
     # Passing in a block sets the return value.
@@ -94,7 +94,7 @@ module RR
       self
     end
 
-    # Scenario#at_least sets the expectation that the Scenario
+    # Double#at_least sets the expectation that the Double
     # will be called at least n times.
     # It works by creating a TimesCalledExpectation.
     #
@@ -107,7 +107,7 @@ module RR
       self
     end
 
-    # Scenario#at_most allows sets the expectation that the Scenario
+    # Double#at_most allows sets the expectation that the Double
     # will be called at most n times.
     # It works by creating a TimesCalledExpectation.
     #
@@ -120,9 +120,9 @@ module RR
       self
     end
 
-    # Scenario#any_number_of_times sets an that the Scenario will be called
+    # Double#any_number_of_times sets an that the Double will be called
     # any number of times. This effectively removes the times called expectation
-    # from the Scenarion
+    # from the Doublen
     #
     # Passing in a block sets the return value.
     #
@@ -133,7 +133,7 @@ module RR
       self
     end
 
-    # Scenario#times creates an TimesCalledExpectation of the passed
+    # Double#times creates an TimesCalledExpectation of the passed
     # in number.
     #
     # Passing in a block sets the return value.
@@ -145,7 +145,7 @@ module RR
       self
     end
 
-    # Scenario#ordered sets the Scenario to have an ordered
+    # Double#ordered sets the Double to have an ordered
     # expectation.
     #
     # Passing in a block sets the return value.
@@ -153,10 +153,10 @@ module RR
     #   mock(subject).method_name.ordered {return_value}
     def ordered(&returns)
       raise(
-        Errors::ScenarioDefinitionError,
-        "Scenario Definitions must have a dedicated Scenario to be ordered. " <<
+        Errors::DoubleDefinitionError,
+        "Double Definitions must have a dedicated Double to be ordered. " <<
         "For example, using instance_of does not allow ordered to be used. " <<
-        "probe the class's #new method instead."
+        "proxy the class's #new method instead."
       ) unless @scenario
       @ordered = true
       @space.ordered_scenarios << @scenario unless @space.ordered_scenarios.include?(@scenario)
@@ -164,17 +164,17 @@ module RR
       self
     end
 
-    # Scenario#ordered? returns true when the Scenario is ordered.
+    # Double#ordered? returns true when the Double is ordered.
     #
     #   mock(subject).method_name.ordered?
     def ordered?
       @ordered
     end
 
-    # Scenario#yields sets the Scenario to invoke a passed in block when
-    # the Scenario is called.
+    # Double#yields sets the Double to invoke a passed in block when
+    # the Double is called.
     # An Expection will be raised if no block is passed in when the
-    # Scenario is called.
+    # Double is called.
     #
     # Passing in a block sets the return value.
     #
@@ -186,29 +186,29 @@ module RR
       self
     end
 
-    # Scenario#after_call creates a callback that occurs after call
+    # Double#after_call creates a callback that occurs after call
     # is called. The passed in block receives the return value of
-    # the Scenario being called.
+    # the Double being called.
     # An Expection will be raised if no block is passed in.
     #
     #   mock(subject).method_name {return_value}.after_call {|return_value|}
     #   subject.method_name # return_value
     #
-    # This feature is built into probes.
-    #   probe(User).find('1') {|user| mock(user).valid? {false}}
+    # This feature is built into proxys.
+    #   mock.proxy(User).find('1') {|user| mock(user).valid? {false}}
     def after_call(&block)
       raise ArgumentError, "after_call expects a block" unless block
       @after_call_value = block
       self
     end
 
-    # Scenario#returns accepts an argument value or a block.
+    # Double#returns accepts an argument value or a block.
     # It will raise an ArgumentError if both are passed in.
     #
-    # Passing in a block causes Scenario to return the return value of
+    # Passing in a block causes Double to return the return value of
     # the passed in block.
     #
-    # Passing in an argument causes Scenario to return the argument.
+    # Passing in an argument causes Double to return the argument.
     def returns(value=nil, &implementation)
       if value && implementation
         raise ArgumentError, "returns cannot accept both an argument and a block"
@@ -221,9 +221,9 @@ module RR
       self
     end
 
-    # Scenario#implemented_by sets the implementation of the Scenario.
+    # Double#implemented_by sets the implementation of the Double.
     # This method takes a Proc or a Method. Passing in a Method allows
-    # the Scenario to accept blocks.
+    # the Double to accept blocks.
     #
     #   obj = Object.new
     #   def obj.foobar
@@ -235,9 +235,9 @@ module RR
       self
     end
 
-    # Scenario#implemented_by_original_method sets the implementation
-    # of the Scenario to be the original method.
-    # This is primarily used with probes.
+    # Double#implemented_by_original_method sets the implementation
+    # of the Double to be the original method.
+    # This is primarily used with proxyies.
     #
     #   obj = Object.new
     #   def obj.foobar
@@ -250,14 +250,14 @@ module RR
       self
     end
 
-    # Scenario#exact_match? returns true when the passed in arguments
+    # Double#exact_match? returns true when the passed in arguments
     # exactly match the ArgumentEqualityExpectation arguments.
     def exact_match?(*arguments)
       return false unless @argument_expectation
       @argument_expectation.exact_match?(*arguments)
     end
 
-    # Scenario#wildcard_match? returns true when the passed in arguments
+    # Double#wildcard_match? returns true when the passed in arguments
     # wildcard match the ArgumentEqualityExpectation arguments.
     def wildcard_match?(*arguments)
       return false unless @argument_expectation
@@ -269,7 +269,7 @@ module RR
       @times_matcher.terminal?
     end
 
-    # The Arguments that this Scenario expects
+    # The Arguments that this Double expects
     def expected_arguments
       return [] unless argument_expectation
       argument_expectation.expected_arguments

data/lib/rr/{scenario_definition_builder.rb → double_definition_builder.rb}

@@ -1,5 +1,5 @@
 module RR
-  class ScenarioDefinitionBuilder
+  class DoubleDefinitionBuilder #:nodoc:
     attr_reader :definition
 
     def initialize(definition, args, handler)
@@ -17,7 +17,7 @@ module RR
       permissive_argument!
     end
 
-    def do_not_call!
+    def dont_allow!
       @definition.never
       permissive_argument!
       reimplementation!
@@ -35,7 +35,7 @@ module RR
       @definition.returns(&@handler)
     end
     
-    def probe!
+    def proxy!
       @definition.after_call_block_callback_strategy!
       @definition.implemented_by_original_method
       @definition.after_call(&@handler) if @handler

data/lib/rr/double_insertion.rb

@@ -0,0 +1,132 @@
+module RR
+  # RR::DoubleInsertion is the binding of an object and a method.
+  # A double_insertion has 0 to many Double objects. Each Double
+  # has Argument Expectations and Times called Expectations.
+  class DoubleInsertion
+    MethodArguments = Struct.new(:arguments, :block)
+    attr_reader :space, :object, :method_name, :scenarios
+
+    def initialize(space, object, method_name)
+      @space = space
+      @object = object
+      @method_name = method_name.to_sym
+      if object_has_method?(method_name)
+        meta.send(:alias_method, original_method_name, method_name)
+      end
+      @scenarios = []
+    end
+
+    # RR::DoubleInsertion#register_scenario adds the passed in Double
+    # into this DoubleInsertion's list of Double objects.
+    def register_scenario(scenario)
+      @scenarios << scenario
+    end
+
+    # RR::DoubleInsertion#bind injects a method that acts as a dispatcher
+    # that dispatches to the matching Double when the method
+    # is called.
+    def bind
+      define_implementation_placeholder
+      returns_method = <<-METHOD
+        def #{@method_name}(*args, &block)
+          arguments = MethodArguments.new(args, block)
+          #{placeholder_name}(arguments)
+        end
+      METHOD
+      meta.class_eval(returns_method, __FILE__, __LINE__ - 5)
+    end
+
+    # RR::DoubleInsertion#verify verifies each Double
+    # TimesCalledExpectation are met.
+    def verify
+      @scenarios.each do |scenario|
+        scenario.verify
+      end
+    end
+
+    # RR::DoubleInsertion#reset removes the injected dispatcher method.
+    # It binds the original method implementation on the object
+    # if one exists.
+    def reset
+      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)
+      else
+        meta.send(:remove_method, @method_name)
+      end
+    end
+
+    def call_original_method(*args, &block)
+      @object.__send__(original_method_name, *args, &block)
+    end
+
+    def object_has_original_method?
+      object_has_method?(original_method_name)
+    end
+
+    protected
+    def define_implementation_placeholder
+      me = self
+      meta.send(:define_method, placeholder_name) do |arguments|
+        me.send(:call_method, arguments.arguments, arguments.block)
+      end
+    end
+
+    def call_method(args, block)
+      if scenario = find_scenario_to_attempt(args)
+        return scenario.call(self, *args, &block)
+      end
+      scenario_not_found_error(*args)
+    end
+
+    def find_scenario_to_attempt(args)
+      matches = DoubleMatches.new(@scenarios).find_all_matches!(args)
+
+      unless matches.exact_terminal_scenarios_to_attempt.empty?
+        return matches.exact_terminal_scenarios_to_attempt.first
+      end
+
+      unless matches.exact_non_terminal_scenarios_to_attempt.empty?
+        return matches.exact_non_terminal_scenarios_to_attempt.last
+      end
+
+      unless matches.wildcard_terminal_scenarios_to_attempt.empty?
+        return matches.wildcard_terminal_scenarios_to_attempt.first
+      end
+
+      unless matches.wildcard_non_terminal_scenarios_to_attempt.empty?
+        return matches.wildcard_non_terminal_scenarios_to_attempt.last
+      end
+
+      unless matches.matching_scenarios.empty?
+        # This will raise a TimesCalledError
+        return matches.matching_scenarios.first
+      end
+
+      return nil
+    end
+
+    def scenario_not_found_error(*args)
+      message = "Unexpected method invocation #{Double.formatted_name(@method_name, args)}, expected\n"
+      message << Double.list_message_part(@scenarios)
+      raise Errors::DoubleNotFoundError, message
+    end
+
+    def placeholder_name
+      "__rr__#{@method_name}"
+    end
+
+    def original_method_name
+      "__rr__original_#{@method_name}"
+    end
+
+    def object_has_method?(method_name)
+      @object.methods.include?(method_name.to_s) || @object.respond_to?(method_name)
+    end
+
+    def meta
+      (class << @object; self; end)
+    end
+  end
+end

data/lib/rr/{scenario_matches.rb → double_matches.rb}

@@ -1,11 +1,11 @@
 module RR
-class ScenarioMatches
+class DoubleMatches
   attr_reader :matching_scenarios,
               :exact_terminal_scenarios_to_attempt,
               :exact_non_terminal_scenarios_to_attempt,
               :wildcard_terminal_scenarios_to_attempt,
               :wildcard_non_terminal_scenarios_to_attempt
-  def initialize(scenarios)
+  def initialize(scenarios) #:nodoc:
     @scenarios = scenarios
     @matching_scenarios = []
     @exact_terminal_scenarios_to_attempt = []

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

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

data/lib/rr/errors/argument_equality_error.rb

@@ -1,6 +1,6 @@
 module RR
-module Errors
-  class ArgumentEqualityError < RRError
+  module Errors
+    class ArgumentEqualityError < RRError
+    end
   end
-end
 end

data/lib/rr/errors/rr_error.rb

@@ -1,20 +1,20 @@
 module RR
-module Errors
-  BACKTRACE_IDENTIFIER = /lib\/rr/
+  module Errors
+    BACKTRACE_IDENTIFIER = /lib\/rr/
 
-  class RRError < RuntimeError
-    attr_writer :backtrace
-    def backtrace
-      original_backtrace = (@backtrace) ? @backtrace : super
-      return original_backtrace unless RR::Space.trim_backtrace
+    class RRError < RuntimeError
+      attr_writer :backtrace
+      def backtrace
+        original_backtrace = (@backtrace) ? @backtrace : super
+        return original_backtrace unless RR::Space.trim_backtrace
 
-      return original_backtrace unless original_backtrace.respond_to?(:each)
-      new_backtrace = []
-      original_backtrace.each do |line|
-        new_backtrace << line unless line =~ BACKTRACE_IDENTIFIER
+        return original_backtrace unless original_backtrace.respond_to?(:each)
+        new_backtrace = []
+        original_backtrace.each do |line|
+          new_backtrace << line unless line =~ BACKTRACE_IDENTIFIER
+        end
+        new_backtrace
       end
-      new_backtrace
     end
   end
-end
 end