sublimetheme 1.0.0

data/path/gems/rspec-mocks-3.3.2/lib/rspec/mocks/method_double.rb

@@ -0,0 +1,287 @@
+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_implementation_callable
+        # 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_implementation_callable ||= original_method ||
+          Proc.new do |*args, &block|
+            @object.__send__(:method_missing, @method_name, *args, &block)
+          end
+      end
+
+      alias_method :save_original_implementation_callable!, :original_implementation_callable
+
+      def original_method
+        @original_method ||=
+          @method_stasher.original_method ||
+          @proxy.original_method_handle_for(method_name)
+      end
+
+      # @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_stasher.stash unless @method_is_proxied
+        define_proxy_method
+      end
+
+      # @private
+      def define_proxy_method
+        return if @method_is_proxied
+
+        save_original_implementation_callable!
+        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
+
+        remove_method_from_definition_target
+        @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, method_name)
+      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
+        RSpec::Mocks.error_generator.raise_method_not_stubbed_error(method_name)
+      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
+
+    private
+
+      def remove_method_from_definition_target
+        definition_target.__send__(:remove_method, @method_name)
+      rescue NameError
+        # This can happen when the method has been monkeyed with by
+        # something outside RSpec. This happens, for example, when
+        # `file.write` has been stubbed, and then `file.reopen(other_io)`
+        # is later called, as `File#reopen` appears to redefine `write`.
+        #
+        # Note: we could avoid rescuing this by checking
+        # `definition_target.instance_method(@method_name).owner == definition_target`,
+        # saving us from the cost of the expensive exception, but this error is
+        # extremely rare (it was discovered on 2014-12-30, only happens on
+        # RUBY_VERSION < 2.0 and our spec suite only hits this condition once),
+        # so we'd rather avoid the cost of that check for every method double,
+        # and risk the rare situation where this exception will get raised.
+        RSpec.warn_with(
+          "WARNING: RSpec could not fully restore #{@object.inspect}." \
+          "#{@method_name}, possibly because the method has been redefined " \
+          "by something outside of RSpec."
+        )
+      end
+    end
+  end
+end

data/path/gems/rspec-mocks-3.3.2/lib/rspec/mocks/method_reference.rb

@@ -0,0 +1,192 @@
+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 self.for(object_reference, method_name)
+        new(object_reference, method_name)
+      end
+
+      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
+      def self.for(object_reference, method_name)
+        if ClassNewMethodReference.applies_to?(method_name) { object_reference.when_loaded { |o| o } }
+          ClassNewMethodReference.new(object_reference, method_name)
+        else
+          super
+        end
+      end
+
+    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
+
+    # When a class's `.new` method is stubbed, we want to use the method
+    # signature from `#initialize` because `.new`'s signature is a generic
+    # `def new(*args)` and it simply delegates to `#initialize` and forwards
+    # all args...so the method with the actually used signature is `#initialize`.
+    #
+    # This method reference implementation handles that specific case.
+    # @private
+    class ClassNewMethodReference < ObjectMethodReference
+      def self.applies_to?(method_name)
+        return false unless method_name == :new
+        klass = yield
+        return false unless klass.respond_to?(:new, true)
+
+        # We only want to apply our special logic to normal `new` methods.
+        # Methods that the user has monkeyed with should be left as-is.
+        klass.method(:new).owner == ::Class
+      end
+
+      def with_signature
+        @object_reference.when_loaded do |klass|
+          yield Support::MethodSignature.new(klass.instance_method(:initialize))
+        end
+      end
+    end
+  end
+end