opal-rspec 0.4.3 → 0.5.0.beta1

data/vendor_lib/rspec/mocks/method_reference.rb

@@ -1,95 +0,0 @@
-module RSpec
-  module Mocks
-    # Represents a method on a module that may or may not be defined.
-    #
-    # @private
-    class MethodReference
-      def initialize(module_reference, method_name)
-        @module_reference = module_reference
-        @method_name = method_name
-      end
-
-      # A method is implemented if sending the message does not result in
-      # a `NoMethodError`. It might be dynamically implemented by
-      # `method_missing`.
-      def implemented?
-        @module_reference.when_loaded do |m|
-          method_implemented?(m)
-        end
-      end
-
-      # A method is defined if we are able to get a `Method` object for it.
-      # In that case, we can assert against metadata like the arity.
-      def defined?
-        @module_reference.when_loaded do |m|
-          method_defined?(m)
-        end
-      end
-
-      def when_defined
-        if original = original_method
-          yield original
-        end
-      end
-
-      # Yields to the block if the method is not implemented.
-      def when_unimplemented
-        yield unless implemented?
-      end
-
-      private
-      def original_method
-        @module_reference.when_loaded do |m|
-          self.defined? && find_method(m)
-        end
-      end
-    end
-
-    # @private
-    class InstanceMethodReference < MethodReference
-      private
-      def method_implemented?(m)
-        m.method_defined?(@method_name)
-      end
-
-      # Ideally, we'd use `respond_to?` for `method_implemented?` but we need a
-      # reference to an instance to do that and we don't have one.  Note that
-      # we may get false negatives: if the method is implemented via
-      # `method_missing`, we'll return `false` even though it meets our
-      # definition of "implemented". However, it's the best we can do.
-      alias method_defined? method_implemented?
-
-      # works around the fact that repeated calls for method parameters will
-      # falsely return empty arrays on JRuby in certain circumstances, this
-      # is necessary here because we can't dup/clone UnboundMethods.
-      #
-      # This is necessary due to a bug in JRuby prior to 1.7.5 fixed in:
-      # https://github.com/jruby/jruby/commit/99a0613fe29935150d76a9a1ee4cf2b4f63f4a27
-      if RUBY_PLATFORM == 'java' && JRUBY_VERSION.split('.')[-1].to_i < 5
-        def find_method(m)
-          m.dup.instance_method(@method_name)
-        end
-      else
-        def find_method(m)
-          m.instance_method(@method_name)
-        end
-      end
-    end
-
-    # @private
-    class ObjectMethodReference < MethodReference
-      private
-      def method_implemented?(m)
-        m.respond_to?(@method_name)
-      end
-
-      def method_defined?(m)
-        (class << m; self; end).method_defined?(@method_name)
-      end
-
-      def find_method(m)
-        m.method(@method_name)
-      end
-    end
-  end
-end

data/vendor_lib/rspec/mocks/mock.rb

@@ -1,7 +0,0 @@
-module RSpec
-  module Mocks
-    class Mock
-      include TestDouble
-    end
-  end
-end

data/vendor_lib/rspec/mocks/proxy.rb

@@ -1,269 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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

data/vendor_lib/rspec/mocks/space.rb

@@ -1,95 +0,0 @@
-module RSpec
-  module Mocks
-    # @api private
-    class Space
-      attr_reader :proxies, :any_instance_recorders
-
-      def initialize
-        @proxies                 = {}
-        @any_instance_recorders  = {}
-      end
-
-      def verify_all
-        proxies.each_value do |object|
-          object.verify
-        end
-
-        any_instance_recorders.each_value do |recorder|
-          recorder.verify
-        end
-      end
-
-      def reset_all
-        ConstantMutator.reset_all
-
-        proxies.each_value do |object|
-          object.reset
-        end
-
-        proxies.clear
-        any_instance_recorders.clear
-        expectation_ordering.clear
-      end
-
-      def expectation_ordering
-        @expectation_ordering ||= OrderGroup.new
-      end
-
-      def any_instance_recorder_for(klass)
-        id = klass.__id__
-        any_instance_recorders.fetch(id) do
-          any_instance_recorders[id] = AnyInstance::Recorder.new(klass)
-        end
-      end
-
-      def remove_any_instance_recorder_for(klass)
-        any_instance_recorders.delete(klass.__id__)
-      end
-
-      def proxies_of(klass)
-        proxies.values.select { |proxy| klass === proxy.object }
-      end
-
-      def proxy_for(object)
-        id = id_for(object)
-        proxies.fetch(id) do
-          proxies[id] = case object
-                        when NilClass   then ProxyForNil.new(expectation_ordering)
-                        when TestDouble then object.__build_mock_proxy(expectation_ordering)
-                        else
-                          if RSpec::Mocks.configuration.verify_partial_doubles?
-                            VerifyingPartialMockProxy.new(object, expectation_ordering)
-                          else
-                            PartialMockProxy.new(object, expectation_ordering)
-                          end
-                        end
-        end
-      end
-
-      alias ensure_registered proxy_for
-
-      def registered?(object)
-        proxies.has_key?(id_for object)
-      end
-
-      if defined?(::BasicObject) && !::BasicObject.method_defined?(:__id__) # for 1.9.2
-        require 'securerandom'
-
-        def id_for(object)
-          id = object.__id__
-
-          return id if object.equal?(::ObjectSpace._id2ref(id))
-          # this suggests that object.__id__ is proxying through to some wrapped object
-
-          object.instance_exec do
-            @__id_for_rspec_mocks_space ||= ::SecureRandom.uuid
-          end
-        end
-      else
-        def id_for(object)
-          object.__id__
-        end
-      end
-    end
-  end
-end

data/vendor_lib/rspec/mocks/standalone.rb

@@ -1,3 +0,0 @@
-require 'rspec/mocks'
-
-RSpec::Mocks.setup(self)

data/vendor_lib/rspec/mocks/stub_chain.rb

@@ -1,51 +0,0 @@
-module RSpec
-  module Mocks
-    # @private
-    class StubChain
-      def self.stub_chain_on(object, *chain, &blk)
-        new(object, *chain, &blk).stub_chain
-      end
-
-      attr_reader :object, :chain, :block
-
-      def initialize(object, *chain, &blk)
-        @object = object
-        @chain, @block = format_chain(*chain, &blk)
-      end
-
-      def stub_chain
-        if chain.length > 1
-          if matching_stub = find_matching_stub
-            chain.shift
-            matching_stub.invoke(nil).stub_chain(*chain, &block)
-          else
-            next_in_chain = Mock.new
-            object.stub(chain.shift) { next_in_chain }
-            StubChain.stub_chain_on(next_in_chain, *chain, &block)
-          end
-        else
-          object.stub(chain.shift, &block)
-        end
-      end
-
-    private
-
-      def format_chain(*chain, &blk)
-        if Hash === chain.last
-          hash = chain.pop
-          hash.each do |k,v|
-            chain << k
-            blk = lambda { v }
-          end
-        end
-        return chain.join('.').split('.'), blk
-      end
-
-      def find_matching_stub
-        ::RSpec::Mocks.proxy_for(object).
-          __send__(:find_matching_method_stub, chain.first.to_sym)
-      end
-    end
-  end
-end
-