opal-rspec-cj 0.4.4

data/vendor_lib/rspec/mocks/object_reference.rb

@@ -0,0 +1,90 @@
+module RSpec
+  module Mocks
+
+    # @api private
+    class ObjectReference
+      # Returns an appropriate Object or Module reference based
+      # on the given argument.
+      def self.for(object_module_or_name, allow_direct_object_refs = false)
+        case object_module_or_name
+          when Module then DirectModuleReference.new(object_module_or_name)
+          when String then NamedObjectReference.new(object_module_or_name)
+          else
+            if allow_direct_object_refs
+              DirectObjectReference.new(object_module_or_name)
+            else
+              raise ArgumentError,
+                "Module or String expected, got #{object_module_or_name.inspect}"
+            end
+        end
+      end
+    end
+
+    # Used when an object is passed to `object_double`.
+    # Represents a reference to that object.
+    # @api private
+    class DirectObjectReference
+      def initialize(object)
+        @object = object
+      end
+
+      def description
+        @object.inspect
+      end
+
+      def const_to_replace
+        raise ArgumentError,
+          "Can not perform constant replacement with an object."
+      end
+
+      def defined?
+        true
+      end
+
+      def when_loaded
+        yield @object
+      end
+    end
+
+    # Used when a module is passed to `class_double` or `instance_double`.
+    # Represents a reference to that module.
+    # @api private
+    class DirectModuleReference < DirectObjectReference
+      def const_to_replace
+        @object.name
+      end
+      alias description const_to_replace
+    end
+
+    # Used when a string is passed to `class_double`, `instance_double`
+    # or `object_double`.
+    # Represents a reference to the object named (via a constant lookup)
+    # by the string.
+    # @api private
+    class NamedObjectReference
+      def initialize(const_name)
+        @const_name = const_name
+      end
+
+      def defined?
+        !!object
+      end
+
+      def const_to_replace
+        @const_name
+      end
+      alias description const_to_replace
+
+      def when_loaded(&block)
+        yield object if object
+      end
+
+   private
+
+      def object
+        @object ||= Constant.original(@const_name).original_value
+      end
+    end
+  end
+end
+

data/vendor_lib/rspec/mocks/order_group.rb

@@ -0,0 +1,82 @@
+module RSpec
+  module Mocks
+    # @private
+    class OrderGroup
+      def initialize
+        @expectations = []
+        @invocation_order = []
+        @index = 0
+      end
+
+      # @private
+      def register(expectation)
+        @expectations << expectation
+      end
+
+      def invoked(message)
+        @invocation_order << message
+      end
+
+      # @private
+      def ready_for?(expectation)
+        remaining_expectations.find(&:ordered?) == expectation
+      end
+
+      # @private
+      def consume
+        remaining_expectations.each_with_index do |expectation, index|
+          if expectation.ordered?
+            @index += index + 1
+            return expectation
+          end
+        end
+        nil
+      end
+
+      # @private
+      def handle_order_constraint(expectation)
+        return unless expectation.ordered? && remaining_expectations.include?(expectation)
+        return consume if ready_for?(expectation)
+        expectation.raise_out_of_order_error
+      end
+
+      def verify_invocation_order(expectation)
+        expectation.raise_out_of_order_error unless expectations_invoked_in_order?
+        true
+      end
+
+      def clear
+        @index = 0
+        @invocation_order.clear
+        @expectations.clear
+      end
+
+      def empty?
+        @expectations.empty?
+      end
+
+    private
+
+      def remaining_expectations
+        @expectations[@index..-1] || []
+      end
+
+      def expectations_invoked_in_order?
+        invoked_expectations == expected_invocations
+      end
+
+      def invoked_expectations
+        @expectations.select { |e| e.ordered? && @invocation_order.include?(e) }
+      end
+
+      def expected_invocations
+        @invocation_order.map { |invocation| expectation_for(invocation) }.compact
+      end
+
+      def expectation_for(message)
+        @expectations.find { |e| message == e }
+      end
+
+    end
+  end
+end

data/vendor_lib/rspec/mocks/proxy.rb

@@ -0,0 +1,269 @@
+module RSpec
+  module Mocks
+    # @private
+    class Proxy
+      SpecificMessage = Struct.new(:object,:message) do
+        def ==(expectation)
+          expectation.orig_object == object && expectation.message == message
+        end
+      end
+
+      # @private
+      def initialize(object, order_group, name=nil, options={})
+        @object = object
+        @order_group = order_group
+        @name = name
+        @error_generator = ErrorGenerator.new(object, name)
+        @expectation_ordering = RSpec::Mocks::space.expectation_ordering
+        @messages_received = []
+        @options = options
+        @null_object = false
+        @method_doubles = Hash.new { |h, k| h[k] = MethodDouble.new(@object, k, self) }
+      end
+
+      # @private
+      attr_reader :object
+
+      # @private
+      def null_object?
+        @null_object
+      end
+
+      # @private
+      # Tells the object to ignore any messages that aren't explicitly set as
+      # stubs or message expectations.
+      def as_null_object
+        @null_object = true
+        @object
+      end
+
+      # @private
+      def method_handle_for(message)
+        nil
+      end
+
+      # @private
+      def add_message_expectation(location, method_name, opts={}, &block)
+        meth_double = method_double_for(method_name)
+
+        if null_object? && !block
+          meth_double.add_default_stub(@error_generator, @expectation_ordering, location, opts) do
+            @object
+          end
+        end
+
+        meth_double.add_expectation @error_generator, @expectation_ordering, location, opts, &block
+      end
+
+      # @private
+      def add_simple_expectation(method_name, response, location)
+        method_double_for(method_name).add_simple_expectation method_name, response, @error_generator, location
+      end
+
+      # @private
+      def build_expectation(method_name)
+        meth_double = method_double_for(method_name)
+
+        meth_double.build_expectation(
+          @error_generator,
+          @expectation_ordering
+        )
+      end
+
+      # @private
+      def replay_received_message_on(expectation, &block)
+        expected_method_name = expectation.message
+        meth_double = method_double_for(expected_method_name)
+
+        if meth_double.expectations.any?
+          @error_generator.raise_expectation_on_mocked_method(expected_method_name)
+        end
+
+        unless null_object? || meth_double.stubs.any?
+          @error_generator.raise_expectation_on_unstubbed_method(expected_method_name)
+        end
+
+        @messages_received.each do |(actual_method_name, args, _)|
+          if expectation.matches?(actual_method_name, *args)
+            expectation.invoke(nil)
+            block.call(*args) if block
+          end
+        end
+
+      end
+
+      # @private
+      def check_for_unexpected_arguments(expectation)
+        @messages_received.each do |(method_name, args, _)|
+          if expectation.matches_name_but_not_args(method_name, *args)
+            raise_unexpected_message_args_error(expectation, *args)
+          end
+        end
+      end
+
+      # @private
+      def add_stub(location, method_name, opts={}, &implementation)
+        method_double_for(method_name).add_stub @error_generator, @expectation_ordering, location, opts, &implementation
+      end
+
+      # @private
+      def add_simple_stub(method_name, response)
+        method_double_for(method_name).add_simple_stub method_name, response
+      end
+
+      # @private
+      def remove_stub(method_name)
+        method_double_for(method_name).remove_stub
+      end
+
+      # @private
+      def remove_single_stub(method_name, stub)
+        method_double_for(method_name).remove_single_stub(stub)
+      end
+
+      # @private
+      def verify
+        @method_doubles.each_value {|d| d.verify}
+      ensure
+        reset
+      end
+
+      # @private
+      def reset
+        @method_doubles.each_value {|d| d.reset}
+        @messages_received.clear
+      end
+
+      # @private
+      def received_message?(method_name, *args, &block)
+        @messages_received.any? {|array| array == [method_name, args, block]}
+      end
+
+      # @private
+      def has_negative_expectation?(message)
+        method_double_for(message).expectations.detect {|expectation| expectation.negative_expectation_for?(message)}
+      end
+
+      # @private
+      def record_message_received(message, *args, &block)
+        @order_group.invoked SpecificMessage.new(object, message)
+        @messages_received << [message, args, block]
+      end
+
+      # @private
+      def message_received(message, *args, &block)
+        record_message_received message, *args, &block
+        expectation = find_matching_expectation(message, *args)
+        stub = find_matching_method_stub(message, *args)
+
+        if (stub && expectation && expectation.called_max_times?) || (stub && !expectation)
+          expectation.increase_actual_received_count! if expectation && expectation.actual_received_count_matters?
+          if expectation = find_almost_matching_expectation(message, *args)
+            expectation.advise(*args) unless expectation.expected_messages_received?
+          end
+          stub.invoke(nil, *args, &block)
+        elsif expectation
+          expectation.invoke(stub, *args, &block)
+        elsif expectation = find_almost_matching_expectation(message, *args)
+          expectation.advise(*args) if null_object? unless expectation.expected_messages_received?
+          raise_unexpected_message_args_error(expectation, *args) unless (has_negative_expectation?(message) or null_object?)
+        elsif stub = find_almost_matching_stub(message, *args)
+          stub.advise(*args)
+          raise_missing_default_stub_error(stub, *args)
+        elsif Class === @object
+          @object.superclass.__send__(message, *args, &block)
+        else
+          @object.__send__(:method_missing, message, *args, &block)
+        end
+      end
+
+      # @private
+      def raise_unexpected_message_error(method_name, *args)
+        @error_generator.raise_unexpected_message_error method_name, *args
+      end
+
+      # @private
+      def raise_unexpected_message_args_error(expectation, *args)
+        @error_generator.raise_unexpected_message_args_error(expectation, *args)
+      end
+
+      # @private
+      def raise_missing_default_stub_error(expectation, *args)
+        @error_generator.raise_missing_default_stub_error(expectation, *args)
+      end
+
+      private
+
+      def method_double_for(message)
+        @method_doubles[message.to_sym]
+      end
+
+      def find_matching_expectation(method_name, *args)
+        find_best_matching_expectation_for(method_name) do |expectation|
+          expectation.matches?(method_name, *args)
+        end
+      end
+
+      def find_almost_matching_expectation(method_name, *args)
+        find_best_matching_expectation_for(method_name) do |expectation|
+          expectation.matches_name_but_not_args(method_name, *args)
+        end
+      end
+
+      def find_best_matching_expectation_for(method_name)
+        first_match = nil
+
+        method_double_for(method_name).expectations.each do |expectation|
+          next unless yield expectation
+          return expectation unless expectation.called_max_times?
+          first_match ||= expectation
+        end
+
+        first_match
+      end
+
+      def find_matching_method_stub(method_name, *args)
+        method_double_for(method_name).stubs.find {|stub| stub.matches?(method_name, *args)}
+      end
+
+      def find_almost_matching_stub(method_name, *args)
+        method_double_for(method_name).stubs.find {|stub| stub.matches_name_but_not_args(method_name, *args)}
+      end
+    end
+
+    class PartialMockProxy < Proxy
+      def method_handle_for(message)
+        if any_instance_class_recorder_observing_method?(@object.class, message)
+          message = ::RSpec::Mocks.
+            any_instance_recorder_for(@object.class).
+            build_alias_method_name(message)
+        end
+
+        ::RSpec::Mocks.method_handle_for(@object, message)
+      rescue NameError
+        nil
+      end
+
+      # @private
+      def add_simple_expectation(method_name, response, location)
+        method_double_for(method_name).configure_method
+        super
+      end
+
+      # @private
+      def add_simple_stub(method_name, response)
+        method_double_for(method_name).configure_method
+        super
+      end
+
+    private
+
+      def any_instance_class_recorder_observing_method?(klass, method_name)
+        return true if ::RSpec::Mocks.any_instance_recorder_for(klass).already_observing?(method_name)
+        superklass = klass.superclass
+        return false if superklass.nil?
+        any_instance_class_recorder_observing_method?(superklass, method_name)
+      end
+    end
+  end
+end

data/vendor_lib/rspec/mocks/proxy_for_nil.rb

@@ -0,0 +1,37 @@
+module RSpec
+  module Mocks
+    # @private
+    class ProxyForNil < Proxy
+
+      def initialize(order_group)
+        @warn_about_expectations = true
+        super nil, order_group
+      end
+      attr_accessor :warn_about_expectations
+      alias warn_about_expectations? warn_about_expectations
+
+      def add_message_expectation(location, method_name, opts={}, &block)
+        warn(method_name) if warn_about_expectations?
+        super
+      end
+
+      def add_negative_message_expectation(location, method_name, &implementation)
+        warn(method_name) if warn_about_expectations?
+        super
+      end
+
+      def add_stub(location, method_name, opts={}, &implementation)
+        warn(method_name) if warn_about_expectations?
+        super
+      end
+
+      private
+
+      def warn method_name
+        source = CallerFilter.first_non_rspec_line
+        Kernel.warn("An expectation of :#{method_name} was set on nil. Called from #{source}. Use allow_message_expectations_on_nil to disable warnings.")
+      end
+
+    end
+  end
+end