opal-rspec 0.6.2 → 0.7.0.rc.1

data/rspec-mocks/lib/rspec/mocks/method_double.rb

@@ -1,260 +0,0 @@
-module RSpec
-  module Mocks
-    # @private
-    class MethodDouble
-      # @private
-      attr_reader :method_name, :object, :expectations, :stubs
-
-      # @private
-      def initialize(object, method_name, proxy)
-        @method_name = method_name
-        @object = object
-        @proxy = proxy
-
-        @original_visibility = nil
-        @method_stasher = InstanceMethodStasher.new(object, method_name)
-        @method_is_proxied = false
-        @expectations = []
-        @stubs = []
-      end
-
-      def original_method
-        # If original method is not present, uses the `method_missing`
-        # handler of the object. This accounts for cases where the user has not
-        # correctly defined `respond_to?`, and also 1.8 which does not provide
-        # method handles for missing methods even if `respond_to?` is correct.
-        @original_method ||=
-          @method_stasher.original_method ||
-          @proxy.original_method_handle_for(method_name) ||
-          Proc.new do |*args, &block|
-            @object.__send__(:method_missing, @method_name, *args, &block)
-          end
-      end
-
-      alias_method :save_original_method!, :original_method
-
-      # @private
-      def visibility
-        @proxy.visibility_for(@method_name)
-      end
-
-      # @private
-      def object_singleton_class
-        class << @object; self; end
-      end
-
-      # @private
-      def configure_method
-        @original_visibility = [visibility, method_name]
-        @method_stasher.stash unless @method_is_proxied
-        define_proxy_method
-      end
-
-      # @private
-      def define_proxy_method
-        return if @method_is_proxied
-
-        save_original_method!
-        definition_target.class_exec(self, method_name, visibility) do |method_double, method_name, visibility|
-          define_method(method_name) do |*args, &block|
-            method_double.proxy_method_invoked(self, *args, &block)
-          end
-          __send__(visibility, method_name)
-        end
-
-        @method_is_proxied = true
-      end
-
-      # The implementation of the proxied method. Subclasses may override this
-      # method to perform additional operations.
-      #
-      # @private
-      def proxy_method_invoked(_obj, *args, &block)
-        @proxy.message_received method_name, *args, &block
-      end
-
-      # @private
-      def restore_original_method
-        return show_frozen_warning if object_singleton_class.frozen?
-        return unless @method_is_proxied
-
-        definition_target.__send__(:remove_method, @method_name)
-
-        @method_stasher.restore if @method_stasher.method_is_stashed?
-        restore_original_visibility
-
-        @method_is_proxied = false
-      end
-
-      # @private
-      def show_frozen_warning
-        RSpec.warn_with(
-          "WARNING: rspec-mocks was unable to restore the original `#{@method_name}` " \
-          "method on #{@object.inspect} because it has been frozen.  If you reuse this " \
-          "object, `#{@method_name}` will continue to respond with its stub implementation.",
-          :call_site                      => nil,
-          :use_spec_location_as_call_site => true
-        )
-      end
-
-      # @private
-      def restore_original_visibility
-        return unless @original_visibility &&
-          MethodReference.method_defined_at_any_visibility?(object_singleton_class, @method_name)
-
-        object_singleton_class.__send__(*@original_visibility)
-      end
-
-      # @private
-      def verify
-        expectations.each { |e| e.verify_messages_received }
-      end
-
-      # @private
-      def reset
-        restore_original_method
-        clear
-      end
-
-      # @private
-      def clear
-        expectations.clear
-        stubs.clear
-      end
-
-      # The type of message expectation to create has been extracted to its own
-      # method so that subclasses can override it.
-      #
-      # @private
-      def message_expectation_class
-        MessageExpectation
-      end
-
-      # @private
-      def add_expectation(error_generator, expectation_ordering, expected_from, opts, &implementation)
-        configure_method
-        expectation = message_expectation_class.new(error_generator, expectation_ordering,
-                                                    expected_from, self, :expectation, opts, &implementation)
-        expectations << expectation
-        expectation
-      end
-
-      # @private
-      def build_expectation(error_generator, expectation_ordering)
-        expected_from = IGNORED_BACKTRACE_LINE
-        message_expectation_class.new(error_generator, expectation_ordering, expected_from, self)
-      end
-
-      # @private
-      def add_stub(error_generator, expectation_ordering, expected_from, opts={}, &implementation)
-        configure_method
-        stub = message_expectation_class.new(error_generator, expectation_ordering, expected_from,
-                                             self, :stub, opts, &implementation)
-        stubs.unshift stub
-        stub
-      end
-
-      # A simple stub can only return a concrete value for a message, and
-      # cannot match on arguments. It is used as an optimization over
-      # `add_stub` / `add_expectation` where it is known in advance that this
-      # is all that will be required of a stub, such as when passing attributes
-      # to the `double` example method. They do not stash or restore existing method
-      # definitions.
-      #
-      # @private
-      def add_simple_stub(method_name, response)
-        setup_simple_method_double method_name, response, stubs
-      end
-
-      # @private
-      def add_simple_expectation(method_name, response, error_generator, backtrace_line)
-        setup_simple_method_double method_name, response, expectations, error_generator, backtrace_line
-      end
-
-      # @private
-      def setup_simple_method_double(method_name, response, collection, error_generator=nil, backtrace_line=nil)
-        define_proxy_method
-
-        me = SimpleMessageExpectation.new(method_name, response, error_generator, backtrace_line)
-        collection.unshift me
-        me
-      end
-
-      # @private
-      def add_default_stub(*args, &implementation)
-        return if stubs.any?
-        add_stub(*args, &implementation)
-      end
-
-      # @private
-      def remove_stub
-        raise_method_not_stubbed_error if stubs.empty?
-        remove_stub_if_present
-      end
-
-      # @private
-      def remove_stub_if_present
-        expectations.empty? ? reset : stubs.clear
-      end
-
-      # @private
-      def raise_method_not_stubbed_error
-        raise MockExpectationError, "The method `#{method_name}` was not stubbed or was already unstubbed"
-      end
-
-      # In Ruby 2.0.0 and above prepend will alter the method lookup chain.
-      # We use an object's singleton class to define method doubles upon,
-      # however if the object has had it's singleton class (as opposed to
-      # it's actual class) prepended too then the the method lookup chain
-      # will look in the prepended module first, **before** the singleton
-      # class.
-      #
-      # This code works around that by providing a mock definition target
-      # that is either the singleton class, or if necessary, a prepended module
-      # of our own.
-      #
-      if Support::RubyFeatures.module_prepends_supported?
-
-        private
-
-        # We subclass `Module` in order to be able to easily detect our prepended module.
-        RSpecPrependedModule = Class.new(Module)
-
-        def definition_target
-          @definition_target ||= usable_rspec_prepended_module || object_singleton_class
-        end
-
-        def usable_rspec_prepended_module
-          @proxy.prepended_modules_of_singleton_class.each do |mod|
-            # If we have one of our modules prepended before one of the user's
-            # modules that defines the method, use that, since our module's
-            # definition will take precedence.
-            return mod if RSpecPrependedModule === mod
-
-            # If we hit a user module with the method defined first,
-            # we must create a new prepend module, even if one exists later,
-            # because ours will only take precedence if it comes first.
-            return new_rspec_prepended_module if mod.method_defined?(method_name)
-          end
-
-          nil
-        end
-
-        def new_rspec_prepended_module
-          RSpecPrependedModule.new.tap do |mod|
-            object_singleton_class.__send__ :prepend, mod
-          end
-        end
-
-      else
-
-        private
-
-        def definition_target
-          object_singleton_class
-        end
-
-      end
-    end
-  end
-end

data/rspec-mocks/lib/rspec/mocks/method_reference.rb

@@ -1,155 +0,0 @@
-module RSpec
-  module Mocks
-    # Represents a method on an object that may or may not be defined.
-    # The method may be an instance method on a module or a method on
-    # any object.
-    #
-    # @private
-    class MethodReference
-      def initialize(object_reference, method_name)
-        @object_reference = object_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?
-        @object_reference.when_loaded do |m|
-          method_implemented?(m)
-        end
-      end
-
-      # Returns true if we definitively know that sending the method
-      # will result in a `NoMethodError`.
-      #
-      # This is not simply the inverse of `implemented?`: there are
-      # cases when we don't know if a method is implemented and
-      # both `implemented?` and `unimplemented?` will return false.
-      def unimplemented?
-        @object_reference.when_loaded do |_m|
-          return !implemented?
-        end
-
-        # If it's not loaded, then it may be implemented but we can't check.
-        false
-      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?
-        @object_reference.when_loaded do |m|
-          method_defined?(m)
-        end
-      end
-
-      def with_signature
-        return unless (original = original_method)
-        yield Support::MethodSignature.new(original)
-      end
-
-      def visibility
-        @object_reference.when_loaded do |m|
-          return visibility_from(m)
-        end
-
-        # When it's not loaded, assume it's public. We don't want to
-        # wrongly treat the method as private.
-        :public
-      end
-
-    private
-
-      def original_method
-        @object_reference.when_loaded do |m|
-          self.defined? && find_method(m)
-        end
-      end
-
-      def self.instance_method_visibility_for(klass, method_name)
-        if klass.public_method_defined?(method_name)
-          :public
-        elsif klass.private_method_defined?(method_name)
-          :private
-        elsif klass.protected_method_defined?(method_name)
-          :protected
-        end
-      end
-
-      class << self
-        alias method_defined_at_any_visibility? instance_method_visibility_for
-      end
-
-      def self.method_visibility_for(object, method_name)
-        instance_method_visibility_for(class << object; self; end, method_name).tap do |vis|
-          # If the method is not defined on the class, `instance_method_visibility_for`
-          # returns `nil`. However, it may be handled dynamically by `method_missing`,
-          # so here we check `respond_to` (passing false to not check private methods).
-          #
-          # This only considers the public case, but I don't think it's possible to
-          # write `method_missing` in such a way that it handles a dynamic message
-          # with private or protected visibility. Ruby doesn't provide you with
-          # the caller info.
-          return :public if vis.nil? && object.respond_to?(method_name, false)
-        end
-      end
-    end
-
-    # @private
-    class InstanceMethodReference < MethodReference
-    private
-
-      def method_implemented?(mod)
-        MethodReference.method_defined_at_any_visibility?(mod, @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(mod)
-          mod.dup.instance_method(@method_name)
-        end
-      else
-        def find_method(mod)
-          mod.instance_method(@method_name)
-        end
-      end
-
-      def visibility_from(mod)
-        MethodReference.instance_method_visibility_for(mod, @method_name)
-      end
-    end
-
-    # @private
-    class ObjectMethodReference < MethodReference
-    private
-
-      def method_implemented?(object)
-        object.respond_to?(@method_name, true)
-      end
-
-      def method_defined?(object)
-        (class << object; self; end).method_defined?(@method_name)
-      end
-
-      def find_method(object)
-        object.method(@method_name)
-      end
-
-      def visibility_from(object)
-        MethodReference.method_visibility_for(object, @method_name)
-      end
-    end
-  end
-end

data/rspec-mocks/lib/rspec/mocks/mutate_const.rb

@@ -1,324 +0,0 @@
-RSpec::Support.require_rspec_support 'recursive_const_methods'
-
-module RSpec
-  module Mocks
-    # Provides information about constants that may (or may not)
-    # have been mutated by rspec-mocks.
-    class Constant
-      extend Support::RecursiveConstMethods
-
-      # @api private
-      def initialize(name)
-        @name = name
-        @previously_defined = false
-        @stubbed = false
-        @hidden = false
-      end
-
-      # @return [String] The fully qualified name of the constant.
-      attr_reader :name
-
-      # @return [Object, nil] The original value (e.g. before it
-      #   was mutated by rspec-mocks) of the constant, or
-      #   nil if the constant was not previously defined.
-      attr_accessor :original_value
-
-      # @private
-      attr_writer :previously_defined, :stubbed, :hidden
-
-      # @return [Boolean] Whether or not the constant was defined
-      #   before the current example.
-      def previously_defined?
-        @previously_defined
-      end
-
-      # @return [Boolean] Whether or not rspec-mocks has mutated
-      #   (stubbed or hidden) this constant.
-      def mutated?
-        @stubbed || @hidden
-      end
-
-      # @return [Boolean] Whether or not rspec-mocks has stubbed
-      #   this constant.
-      def stubbed?
-        @stubbed
-      end
-
-      # @return [Boolean] Whether or not rspec-mocks has hidden
-      #   this constant.
-      def hidden?
-        @hidden
-      end
-
-      # The default `to_s` isn't very useful, so a custom version is provided.
-      def to_s
-        "#<#{self.class.name} #{name}>"
-      end
-      alias inspect to_s
-
-      # @private
-      def self.unmutated(name)
-        const = new(name)
-        const.previously_defined = recursive_const_defined?(name)
-        const.stubbed = false
-        const.hidden = false
-        const.original_value = recursive_const_get(name) if const.previously_defined?
-
-        const
-      end
-
-      # Queries rspec-mocks to find out information about the named constant.
-      #
-      # @param [String] name the name of the constant
-      # @return [Constant] an object contaning information about the named
-      #   constant.
-      def self.original(name)
-        mutator = ::RSpec::Mocks.space.constant_mutator_for(name)
-        mutator ? mutator.to_constant : unmutated(name)
-      end
-    end
-
-    # Provides a means to stub constants.
-    class ConstantMutator
-      extend Support::RecursiveConstMethods
-
-      # Stubs a constant.
-      #
-      # @param (see ExampleMethods#stub_const)
-      # @option (see ExampleMethods#stub_const)
-      # @return (see ExampleMethods#stub_const)
-      #
-      # @see ExampleMethods#stub_const
-      # @note It's recommended that you use `stub_const` in your
-      #  examples. This is an alternate public API that is provided
-      #  so you can stub constants in other contexts (e.g. helper
-      #  classes).
-      def self.stub(constant_name, value, options={})
-        mutator = if recursive_const_defined?(constant_name, &raise_on_invalid_const)
-                    DefinedConstantReplacer
-                  else
-                    UndefinedConstantSetter
-                  end
-
-        mutate(mutator.new(constant_name, value, options[:transfer_nested_constants]))
-        value
-      end
-
-      # Hides a constant.
-      #
-      # @param (see ExampleMethods#hide_const)
-      #
-      # @see ExampleMethods#hide_const
-      # @note It's recommended that you use `hide_const` in your
-      #  examples. This is an alternate public API that is provided
-      #  so you can hide constants in other contexts (e.g. helper
-      #  classes).
-      def self.hide(constant_name)
-        mutate(ConstantHider.new(constant_name, nil, {}))
-        nil
-      end
-
-      # Contains common functionality used by all of the constant mutators.
-      #
-      # @private
-      class BaseMutator
-        include Support::RecursiveConstMethods
-
-        attr_reader :original_value, :full_constant_name
-
-        def initialize(full_constant_name, mutated_value, transfer_nested_constants)
-          @full_constant_name        = normalize_const_name(full_constant_name)
-          @mutated_value             = mutated_value
-          @transfer_nested_constants = transfer_nested_constants
-          @context_parts             = @full_constant_name.split('::')
-          @const_name                = @context_parts.pop
-          @reset_performed           = false
-        end
-
-        def to_constant
-          const = Constant.new(full_constant_name)
-          const.original_value = original_value
-
-          const
-        end
-
-        def idempotently_reset
-          reset unless @reset_performed
-          @reset_performed = true
-        end
-      end
-
-      # Hides a defined constant for the duration of an example.
-      #
-      # @private
-      class ConstantHider < BaseMutator
-        def mutate
-          return unless (@defined = recursive_const_defined?(full_constant_name))
-          @context = recursive_const_get(@context_parts.join('::'))
-          @original_value = get_const_defined_on(@context, @const_name)
-
-          @context.__send__(:remove_const, @const_name)
-        end
-
-        def to_constant
-          return Constant.unmutated(full_constant_name) unless @defined
-
-          const = super
-          const.hidden = true
-          const.previously_defined = true
-
-          const
-        end
-
-        def reset
-          return unless @defined
-          @context.const_set(@const_name, @original_value)
-        end
-      end
-
-      # Replaces a defined constant for the duration of an example.
-      #
-      # @private
-      class DefinedConstantReplacer < BaseMutator
-        def initialize(*args)
-          super
-          @constants_to_transfer = []
-        end
-
-        def mutate
-          @context = recursive_const_get(@context_parts.join('::'))
-          @original_value = get_const_defined_on(@context, @const_name)
-
-          @constants_to_transfer = verify_constants_to_transfer!
-
-          @context.__send__(:remove_const, @const_name)
-          @context.const_set(@const_name, @mutated_value)
-
-          transfer_nested_constants
-        end
-
-        def to_constant
-          const = super
-          const.stubbed = true
-          const.previously_defined = true
-
-          const
-        end
-
-        def reset
-          @constants_to_transfer.each do |const|
-            @mutated_value.__send__(:remove_const, const)
-          end
-
-          @context.__send__(:remove_const, @const_name)
-          @context.const_set(@const_name, @original_value)
-        end
-
-        def transfer_nested_constants
-          @constants_to_transfer.each do |const|
-            @mutated_value.const_set(const, get_const_defined_on(original_value, const))
-          end
-        end
-
-        def verify_constants_to_transfer!
-          return [] unless should_transfer_nested_constants?
-
-          { @original_value => "the original value", @mutated_value => "the stubbed value" }.each do |value, description|
-            next if value.respond_to?(:constants)
-
-            raise ArgumentError,
-                  "Cannot transfer nested constants for #{@full_constant_name} " \
-                  "since #{description} is not a class or module and only classes " \
-                  "and modules support nested constants."
-          end
-
-          if Array === @transfer_nested_constants
-            @transfer_nested_constants = @transfer_nested_constants.map(&:to_s) if RUBY_VERSION == '1.8.7'
-            undefined_constants = @transfer_nested_constants - constants_defined_on(@original_value)
-
-            if undefined_constants.any?
-              available_constants = constants_defined_on(@original_value) - @transfer_nested_constants
-              raise ArgumentError,
-                    "Cannot transfer nested constant(s) #{undefined_constants.join(' and ')} " \
-                    "for #{@full_constant_name} since they are not defined. Did you mean " \
-                    "#{available_constants.join(' or ')}?"
-            end
-
-            @transfer_nested_constants
-          else
-            constants_defined_on(@original_value)
-          end
-        end
-
-        def should_transfer_nested_constants?
-          return true  if @transfer_nested_constants
-          return false unless RSpec::Mocks.configuration.transfer_nested_constants?
-          @original_value.respond_to?(:constants) && @mutated_value.respond_to?(:constants)
-        end
-      end
-
-      # Sets an undefined constant for the duration of an example.
-      #
-      # @private
-      class UndefinedConstantSetter < BaseMutator
-        def mutate
-          @parent = @context_parts.inject(Object) do |klass, name|
-            if const_defined_on?(klass, name)
-              get_const_defined_on(klass, name)
-            else
-              ConstantMutator.stub(name_for(klass, name), Module.new)
-            end
-          end
-
-          @parent.const_set(@const_name, @mutated_value)
-        end
-
-        def to_constant
-          const = super
-          const.stubbed = true
-          const.previously_defined = false
-
-          const
-        end
-
-        def reset
-          @parent.__send__(:remove_const, @const_name)
-        end
-
-      private
-
-        def name_for(parent, name)
-          root = if parent == Object
-                   ''
-                 else
-                   parent.name
-                 end
-          root + '::' + name
-        end
-      end
-
-      # Uses the mutator to mutate (stub or hide) a constant. Ensures that
-      # the mutator is correctly registered so it can be backed out at the end
-      # of the test.
-      #
-      # @private
-      def self.mutate(mutator)
-        ::RSpec::Mocks.space.register_constant_mutator(mutator)
-        mutator.mutate
-      end
-
-      # Used internally by the constant stubbing to raise a helpful
-      # error when a constant like "A::B::C" is stubbed and A::B is
-      # not a module (and thus, it's impossible to define "A::B::C"
-      # since only modules can have nested constants).
-      #
-      # @api private
-      def self.raise_on_invalid_const
-        lambda do |const_name, failed_name|
-          raise "Cannot stub constant #{failed_name} on #{const_name} " \
-                "since #{const_name} is not a module."
-        end
-      end
-    end
-  end
-end