cloudsmith-api 0.54.15 → 0.57.1

data/vendor/bundle/ruby/2.6.0/gems/rspec-mocks-3.10.0/lib/rspec/mocks/any_instance/recorder.rb

@@ -1,294 +0,0 @@
-module RSpec
-  module Mocks
-    module AnyInstance
-      # Given a class `TheClass`, `TheClass.any_instance` returns a `Recorder`,
-      # which records stubs and message expectations for later playback on
-      # instances of `TheClass`.
-      #
-      # Further constraints are stored in instances of [Chain](Chain).
-      #
-      # @see AnyInstance
-      # @see Chain
-      class Recorder
-        # @private
-        attr_reader :message_chains, :stubs, :klass
-
-        def initialize(klass)
-          @message_chains = MessageChains.new
-          @stubs = Hash.new { |hash, key| hash[key] = [] }
-          @observed_methods = []
-          @played_methods = {}
-          @backed_up_method_owner = {}
-          @klass = klass
-          @expectation_set = false
-
-          return unless RSpec::Mocks.configuration.verify_partial_doubles?
-          RSpec::Mocks.configuration.verifying_double_callbacks.each do |block|
-            block.call(ObjectReference.for(klass))
-          end
-        end
-
-        # Initializes the recording a stub to be played back against any
-        # instance of this object that invokes the submitted method.
-        #
-        # @see Methods#stub
-        def stub(method_name, &block)
-          observe!(method_name)
-          message_chains.add(method_name, StubChain.new(self, method_name, &block))
-        end
-
-        # Initializes the recording a stub chain to be played back against any
-        # instance of this object that invokes the method matching the first
-        # argument.
-        #
-        # @see Methods#stub_chain
-        def stub_chain(*method_names_and_optional_return_values, &block)
-          normalize_chain(*method_names_and_optional_return_values) do |method_name, args|
-            observe!(method_name)
-            message_chains.add(method_name, StubChainChain.new(self, *args, &block))
-          end
-        end
-
-        # @private
-        def expect_chain(*method_names_and_optional_return_values, &block)
-          @expectation_set = true
-          normalize_chain(*method_names_and_optional_return_values) do |method_name, args|
-            observe!(method_name)
-            message_chains.add(method_name, ExpectChainChain.new(self, *args, &block))
-          end
-        end
-
-        # Initializes the recording a message expectation to be played back
-        # against any instance of this object that invokes the submitted
-        # method.
-        #
-        # @see Methods#should_receive
-        def should_receive(method_name, &block)
-          @expectation_set = true
-          observe!(method_name)
-          message_chains.add(method_name, PositiveExpectationChain.new(self, method_name, &block))
-        end
-
-        # The opposite of `should_receive`
-        #
-        # @see Methods#should_not_receive
-        def should_not_receive(method_name, &block)
-          should_receive(method_name, &block).never
-        end
-
-        # Removes any previously recorded stubs, stub_chains or message
-        # expectations that use `method_name`.
-        #
-        # @see Methods#unstub
-        def unstub(method_name)
-          unless @observed_methods.include?(method_name.to_sym)
-            AnyInstance.error_generator.raise_method_not_stubbed_error(method_name)
-          end
-          message_chains.remove_stub_chains_for!(method_name)
-          stubs[method_name].clear
-          stop_observing!(method_name) unless message_chains.has_expectation?(method_name)
-        end
-
-        # @api private
-        #
-        # Used internally to verify that message expectations have been
-        # fulfilled.
-        def verify
-          return unless @expectation_set
-          return if message_chains.all_expectations_fulfilled?
-
-          AnyInstance.error_generator.raise_second_instance_received_message_error(message_chains.unfulfilled_expectations)
-        end
-
-        # @private
-        def stop_all_observation!
-          @observed_methods.each { |method_name| restore_method!(method_name) }
-        end
-
-        # @private
-        def playback!(instance, method_name)
-          RSpec::Mocks.space.ensure_registered(instance)
-          message_chains.playback!(instance, method_name)
-          @played_methods[method_name] = instance
-          received_expected_message!(method_name) if message_chains.has_expectation?(method_name)
-        end
-
-        # @private
-        def instance_that_received(method_name)
-          @played_methods[method_name]
-        end
-
-        # @private
-        def build_alias_method_name(method_name)
-          "__#{method_name}_without_any_instance__"
-        end
-
-        # @private
-        def already_observing?(method_name)
-          @observed_methods.include?(method_name) || super_class_observing?(method_name)
-        end
-
-        # @private
-        def notify_received_message(_object, message, args, _blk)
-          has_expectation = false
-
-          message_chains.each_unfulfilled_expectation_matching(message, *args) do |expectation|
-            has_expectation = true
-            expectation.expectation_fulfilled!
-          end
-
-          return unless has_expectation
-
-          restore_method!(message)
-          mark_invoked!(message)
-        end
-
-      protected
-
-        def stop_observing!(method_name)
-          restore_method!(method_name)
-          @observed_methods.delete(method_name)
-          super_class_observers_for(method_name).each do |ancestor|
-            ::RSpec::Mocks.space.
-              any_instance_recorder_for(ancestor).stop_observing!(method_name)
-          end
-        end
-
-      private
-
-        def ancestor_is_an_observer?(method_name)
-          lambda do |ancestor|
-            unless ancestor == @klass
-              ::RSpec::Mocks.space.
-                any_instance_recorder_for(ancestor).already_observing?(method_name)
-            end
-          end
-        end
-
-        def super_class_observers_for(method_name)
-          @klass.ancestors.select(&ancestor_is_an_observer?(method_name))
-        end
-
-        def super_class_observing?(method_name)
-          @klass.ancestors.any?(&ancestor_is_an_observer?(method_name))
-        end
-
-        def normalize_chain(*args)
-          args.shift.to_s.split('.').map { |s| s.to_sym }.reverse.each { |a| args.unshift a }
-          yield args.first, args
-        end
-
-        def received_expected_message!(method_name)
-          message_chains.received_expected_message!(method_name)
-          restore_method!(method_name)
-          mark_invoked!(method_name)
-        end
-
-        def restore_method!(method_name)
-          if public_protected_or_private_method_defined?(build_alias_method_name(method_name))
-            restore_original_method!(method_name)
-          else
-            remove_dummy_method!(method_name)
-          end
-        end
-
-        def restore_original_method!(method_name)
-          return unless @klass.instance_method(method_name).owner == @klass
-
-          alias_method_name = build_alias_method_name(method_name)
-          @klass.class_exec(@backed_up_method_owner) do |backed_up_method_owner|
-            remove_method method_name
-
-            # A @klass can have methods implemented (see Method#owner) in @klass
-            # or inherited from a superclass. In ruby 2.2 and earlier, we can copy
-            # a method regardless of the 'owner' and restore it to @klass after
-            # because a call to 'super' from @klass's copied method would end up
-            # calling the original class's superclass's method.
-            #
-            # With the commit below, available starting in 2.3.0, ruby changed
-            # this behavior and a call to 'super' from the method copied to @klass
-            # will call @klass's superclass method, which is the original
-            # implementer of this method!  This leads to very strange errors
-            # if @klass's copied method calls 'super', since it would end up
-            # calling itself, the original method implemented in @klass's
-            # superclass.
-            #
-            # For ruby 2.3 and above, we need to only restore methods that
-            # @klass originally owned.
-            #
-            # https://github.com/ruby/ruby/commit/c8854d2ca4be9ee6946e6d17b0e17d9ef130ee81
-            if RUBY_VERSION < "2.3" || backed_up_method_owner[method_name.to_sym] == self
-              alias_method method_name, alias_method_name
-            end
-            remove_method alias_method_name
-          end
-        end
-
-        def remove_dummy_method!(method_name)
-          @klass.class_exec do
-            remove_method method_name
-          end
-        end
-
-        def backup_method!(method_name)
-          return unless public_protected_or_private_method_defined?(method_name)
-
-          alias_method_name = build_alias_method_name(method_name)
-          @backed_up_method_owner[method_name.to_sym] ||= @klass.instance_method(method_name).owner
-          @klass.class_exec do
-            alias_method alias_method_name, method_name
-          end
-        end
-
-        def public_protected_or_private_method_defined?(method_name)
-          MethodReference.method_defined_at_any_visibility?(@klass, method_name)
-        end
-
-        def observe!(method_name)
-          allow_no_prepended_module_definition_of(method_name)
-
-          if RSpec::Mocks.configuration.verify_partial_doubles? && !Mocks.configuration.temporarily_suppress_partial_double_verification
-            unless public_protected_or_private_method_defined?(method_name)
-              AnyInstance.error_generator.raise_does_not_implement_error(@klass, method_name)
-            end
-          end
-
-          stop_observing!(method_name) if already_observing?(method_name)
-          @observed_methods << method_name
-          backup_method!(method_name)
-          recorder = self
-          @klass.__send__(:define_method, method_name) do |*args, &blk|
-            recorder.playback!(self, method_name)
-            __send__(method_name, *args, &blk)
-          end
-        end
-
-        def mark_invoked!(method_name)
-          backup_method!(method_name)
-          recorder = self
-          @klass.__send__(:define_method, method_name) do |*_args, &_blk|
-            invoked_instance = recorder.instance_that_received(method_name)
-            inspect = "#<#{self.class}:#{object_id} #{instance_variables.map { |name| "#{name}=#{instance_variable_get name}" }.join(', ')}>"
-            AnyInstance.error_generator.raise_message_already_received_by_other_instance_error(
-              method_name, inspect, invoked_instance
-            )
-          end
-        end
-
-        if Support::RubyFeatures.module_prepends_supported?
-          def allow_no_prepended_module_definition_of(method_name)
-            prepended_modules = RSpec::Mocks::Proxy.prepended_modules_of(@klass)
-            problem_mod = prepended_modules.find { |mod| mod.method_defined?(method_name) }
-            return unless problem_mod
-
-            AnyInstance.error_generator.raise_not_supported_with_prepend_error(method_name, problem_mod)
-          end
-        else
-          def allow_no_prepended_module_definition_of(_method_name)
-            # nothing to do; prepends aren't supported on this version of ruby
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.6.0/gems/rspec-mocks-3.10.0/lib/rspec/mocks/method_double.rb

@@ -1,287 +0,0 @@
-module RSpec
-  module Mocks
-    # @private
-    class MethodDouble
-      # @private
-      attr_reader :method_name, :object, :expectations, :stubs, :method_stasher
-
-      # @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, @original_visibility || 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 its singleton class (as opposed to
-      # its 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