rr 0.3.11 → 0.4.0

data/lib/rr/errors/scenario_definition_error.rb

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

data/lib/rr/errors/scenario_not_found_error.rb

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

data/lib/rr/errors/scenario_order_error.rb

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

data/lib/rr/errors/times_called_error.rb

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

data/lib/rr/expectations/any_argument_expectation.rb

@@ -1,6 +1,6 @@
 module RR
   module Expectations
-    class AnyArgumentExpectation < ArgumentEqualityExpectation
+    class AnyArgumentExpectation < ArgumentEqualityExpectation #:nodoc:
       def initialize
         super
       end

data/lib/rr/expectations/argument_equality_expectation.rb

@@ -1,6 +1,6 @@
 module RR
   module Expectations
-    class ArgumentEqualityExpectation
+    class ArgumentEqualityExpectation #:nodoc:
       attr_reader :expected_arguments
 
       def initialize(*expected_arguments)

data/lib/rr/expectations/times_called_expectation.rb

@@ -1,6 +1,6 @@
 module RR
   module Expectations
-    class TimesCalledExpectation
+    class TimesCalledExpectation #:nodoc:
       attr_reader :scenario, :times_called
       attr_accessor :matcher
 

data/lib/rr/hash_with_object_id_key.rb

@@ -1,5 +1,5 @@
 module RR
-class HashWithObjectIdKey < ::Hash
+class HashWithObjectIdKey < ::Hash #:nodoc:
   def initialize
     @keys = {}
     super do |hash, subject_object|

data/lib/rr/space.rb

@@ -15,10 +15,10 @@ module RR
       end
     end
 
-    attr_reader :doubles, :ordered_scenarios
+    attr_reader :double_insertions, :ordered_scenarios
     attr_accessor :trim_backtrace
     def initialize
-      @doubles = HashWithObjectIdKey.new
+      @double_insertions = HashWithObjectIdKey.new
       @ordered_scenarios = []
       @trim_backtrace = false
     end
@@ -27,103 +27,103 @@ module RR
       if method_name && definition
         raise ArgumentError, "Cannot pass in a method name and a block"
       end
-      proxy = ScenarioMethodProxy.new(self, creator, object, &definition)
+      proxy = DoubleMethodProxy.new(self, creator, object, &definition)
       return proxy unless method_name
       proxy.__send__(method_name)
     end
 
-    # Creates a ScenarioCreator.
+    # Creates a DoubleCreator.
     def scenario_creator
-      ScenarioCreator.new(self)
+      DoubleCreator.new(self)
     end
 
-    # Creates and registers a Scenario to be verified.
-    def scenario(double, definition = scenario_definition)
-      scenario = Scenario.new(self, double, definition)
+    # Creates and registers a Double to be verified.
+    def scenario(double_insertion, definition = scenario_definition)
+      scenario = Double.new(self, double_insertion, definition)
       scenario.definition.scenario = scenario
-      double.register_scenario scenario
+      double_insertion.register_scenario scenario
       scenario
     end
 
     def scenario_definition
-      ScenarioDefinition.new(self)
+      DoubleDefinition.new(self)
     end
 
-    # Reuses or creates, if none exists, a Double for the passed
+    # Reuses or creates, if none exists, a DoubleInsertion for the passed
     # in object and method_name.
-    # When a Double is created, it binds the dispatcher to the
+    # When a DoubleInsertion is created, it binds the dispatcher to the
     # object.
-    def double(object, method_name)
-      double = @doubles[object][method_name.to_sym]
-      return double if double
+    def double_insertion(object, method_name)
+      double_insertion = @double_insertions[object][method_name.to_sym]
+      return double_insertion if double_insertion
 
-      double = Double.new(self, object, method_name.to_sym)
-      @doubles[object][method_name.to_sym] = double
-      double.bind
-      double
+      double_insertion = DoubleInsertion.new(self, object, method_name.to_sym)
+      @double_insertions[object][method_name.to_sym] = double_insertion
+      double_insertion.bind
+      double_insertion
     end
 
-    # Registers the ordered Scenario to be verified.
+    # Registers the ordered Double to be verified.
     def register_ordered_scenario(scenario)
       @ordered_scenarios << scenario
     end
 
-    # Verifies that the passed in ordered Scenario is being called
+    # Verifies that the passed in ordered Double is being called
     # in the correct position.
     def verify_ordered_scenario(scenario)
       unless scenario.terminal?
-        raise Errors::ScenarioOrderError,
-              "Ordered Scenarios cannot have a NonTerminal TimesCalledExpectation"
+        raise Errors::DoubleOrderError,
+              "Ordered Doubles cannot have a NonTerminal TimesCalledExpectation"
       end
       unless @ordered_scenarios.first == scenario
-        message = Scenario.formatted_name(scenario.method_name, scenario.expected_arguments)
+        message = Double.formatted_name(scenario.method_name, scenario.expected_arguments)
         message << " called out of order in list\n"
-        message << Scenario.list_message_part(@ordered_scenarios)
-        raise Errors::ScenarioOrderError, message
+        message << Double.list_message_part(@ordered_scenarios)
+        raise Errors::DoubleOrderError, message
       end
       @ordered_scenarios.shift unless scenario.attempt?
       scenario
     end
 
-    # Verifies all the Double objects have met their
+    # Verifies all the DoubleInsertion objects have met their
     # TimesCalledExpectations.
-    def verify_doubles
-      @doubles.each do |object, method_double_map|
+    def verify_double_insertions
+      @double_insertions.each do |object, method_double_map|
         method_double_map.keys.each do |method_name|
           verify_double(object, method_name)
         end
       end
     end
 
-    # Resets the registered Doubles and ordered Scenarios
+    # Resets the registered Doubles and ordered Doubles
     def reset
       reset_ordered_scenarios
-      reset_doubles
+      reset_double_insertions
     end
 
-    # Verifies the Double for the passed in object and method_name.
+    # Verifies the DoubleInsertion for the passed in object and method_name.
     def verify_double(object, method_name)
-      @doubles[object][method_name].verify
+      @double_insertions[object][method_name].verify
     ensure
       reset_double object, method_name
     end
 
-    # Resets the Double for the passed in object and method_name.
+    # Resets the DoubleInsertion for the passed in object and method_name.
     def reset_double(object, method_name)
-      double = @doubles[object].delete(method_name)
-      @doubles.delete(object) if @doubles[object].empty?
-      double.reset
+      double_insertion = @double_insertions[object].delete(method_name)
+      @double_insertions.delete(object) if @double_insertions[object].empty?
+      double_insertion.reset
     end
 
     protected
-    # Removes the ordered Scenarios from the list
+    # Removes the ordered Doubles from the list
     def reset_ordered_scenarios
       @ordered_scenarios.clear
     end
 
     # Resets the registered Doubles for the next test run.
-    def reset_doubles
-      @doubles.each do |object, method_double_map|
+    def reset_double_insertions
+      @double_insertions.each do |object, method_double_map|
         method_double_map.keys.each do |method_name|
           reset_double(object, method_name)
         end

data/lib/rr/times_called_matchers/any_times_matcher.rb

@@ -1,19 +1,19 @@
 module RR
-module TimesCalledMatchers
-  class AnyTimesMatcher < TimesCalledMatcher
-    include NonTerminal
-    
-    def initialize
-    end
+  module TimesCalledMatchers #:nodoc:
+    class AnyTimesMatcher < TimesCalledMatcher
+      include NonTerminal
 
-    def matches?(times_called)
-      true
-    end
+      def initialize
+      end
+
+      def matches?(times_called)
+        true
+      end
 
-    protected
-    def expected_message_part
-      "Expected any number of times."
+      protected
+      def expected_message_part
+        "Expected any number of times."
+      end
     end
   end
-end
 end

data/lib/rr/times_called_matchers/at_least_matcher.rb

@@ -1,16 +1,16 @@
 module RR
-module TimesCalledMatchers
-  class AtLeastMatcher < TimesCalledMatcher
-    include NonTerminal
-    
-    def matches?(times_called)
-      times_called >= @times
-    end
+  module TimesCalledMatchers #:nodoc:
+    class AtLeastMatcher < TimesCalledMatcher
+      include NonTerminal
+
+      def matches?(times_called)
+        times_called >= @times
+      end
 
-    protected
-    def expected_message_part
-      "Expected at least #{@times.inspect} times."
+      protected
+      def expected_message_part
+        "Expected at least #{@times.inspect} times."
+      end
     end
   end
-end
 end

data/lib/rr/times_called_matchers/at_most_matcher.rb

@@ -1,24 +1,24 @@
 module RR
-module TimesCalledMatchers
-  class AtMostMatcher < TimesCalledMatcher
-    include Terminal
+  module TimesCalledMatchers #:nodoc:
+    class AtMostMatcher < TimesCalledMatcher
+      include Terminal
 
-    def possible_match?(times_called)
-      times_called <= @times
-    end
+      def possible_match?(times_called)
+        times_called <= @times
+      end
 
-    def matches?(times_called)
-      times_called <= @times
-    end
+      def matches?(times_called)
+        times_called <= @times
+      end
 
-    def attempt?(times_called)
-      times_called < @times
-    end
+      def attempt?(times_called)
+        times_called < @times
+      end
 
-    protected
-    def expected_message_part
-      "Expected at most #{@times.inspect} times."
+      protected
+      def expected_message_part
+        "Expected at most #{@times.inspect} times."
+      end
     end
   end
-end
 end

data/lib/rr/times_called_matchers/integer_matcher.rb

@@ -1,19 +1,19 @@
 module RR
-module TimesCalledMatchers
-  class IntegerMatcher < TimesCalledMatcher
-    include Terminal
-    
-    def possible_match?(times_called)
-      times_called <= @times
-    end
+  module TimesCalledMatchers #:nodoc:
+    class IntegerMatcher < TimesCalledMatcher
+      include Terminal
 
-    def matches?(times_called)
-      times_called == @times
-    end
+      def possible_match?(times_called)
+        times_called <= @times
+      end
+
+      def matches?(times_called)
+        times_called == @times
+      end
 
-    def attempt?(times_called)
-      times_called < @times
+      def attempt?(times_called)
+        times_called < @times
+      end
     end
   end
-end
 end

data/lib/rr/times_called_matchers/non_terminal.rb

@@ -1,27 +1,27 @@
 module RR
-module TimesCalledMatchers
-  # Including this module marks the TimesCalledMatcher as NonTerminal.
-  # Being NonTerminal means the Scenario will not "terminate" even when
-  # called infinite times.
-  #
-  # The Scenario that uses a NonTerminal TimesCalledMatcher will
-  # continue using the Scenario when passed the matching arguments.
-  # This is done by the attempt? always returning true.
-  #
-  # This is in opposition to Terminal TimesCalledMatchers, where
-  # attempt? will eventually return false.
-  module NonTerminal
-    def terminal?
-      false
-    end
+  module TimesCalledMatchers
+    # Including this module marks the TimesCalledMatcher as NonTerminal.
+    # Being NonTerminal means the Double will not "terminate" even when
+    # called infinite times.
+    #
+    # The Double that uses a NonTerminal TimesCalledMatcher will
+    # continue using the Double when passed the matching arguments.
+    # This is done by the attempt? always returning true.
+    #
+    # This is in opposition to Terminal TimesCalledMatchers, where
+    # attempt? will eventually return false.
+    module NonTerminal #:nodoc:
+      def terminal?
+        false
+      end
 
-    def possible_match?(times_called)
-      true
-    end
+      def possible_match?(times_called)
+        true
+      end
 
-    def attempt?(times_called)
-      true
+      def attempt?(times_called)
+        true
+      end
     end
   end
-end
 end

data/lib/rr/times_called_matchers/proc_matcher.rb

@@ -1,11 +1,11 @@
 module RR
-module TimesCalledMatchers
-  class ProcMatcher < TimesCalledMatcher
-    include NonTerminal
-    
-    def matches?(times_called)
-      @times.call(times_called)
+  module TimesCalledMatchers
+    class ProcMatcher < TimesCalledMatcher #:nodoc:
+      include NonTerminal
+
+      def matches?(times_called)
+        @times.call(times_called)
+      end
     end
   end
-end
 end

data/lib/rr/times_called_matchers/range_matcher.rb

@@ -1,21 +1,21 @@
 module RR
-module TimesCalledMatchers
-  class RangeMatcher < TimesCalledMatcher
-    include Terminal
+  module TimesCalledMatchers
+    class RangeMatcher < TimesCalledMatcher #:nodoc:
+      include Terminal
 
-    def possible_match?(times_called)
-      return true if times_called < @times.begin
-      return true if @times.include?(times_called)
-      return false
-    end
+      def possible_match?(times_called)
+        return true if times_called < @times.begin
+        return true if @times.include?(times_called)
+        return false
+      end
 
-    def matches?(times_called)
-      @times.include?(times_called)
-    end
+      def matches?(times_called)
+        @times.include?(times_called)
+      end
 
-    def attempt?(times_called)
-      possible_match?(times_called)
+      def attempt?(times_called)
+        possible_match?(times_called)
+      end
     end
   end
-end
 end