cloudsmith-api 0.54.15 → 0.57.1

data/vendor/bundle/ruby/2.6.0/gems/rspec-mocks-3.10.2/lib/rspec/mocks/mutate_const.rb

@@ -0,0 +1,339 @@
+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
+        @valid_name = true
+        yield self if block_given?
+      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, :valid_name
+
+      # @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
+
+      # @return [Boolean] Whether or not the provided constant name
+      #   is a valid Ruby constant name.
+      def valid_name?
+        @valid_name
+      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)
+        previously_defined = !!recursive_const_defined?(name)
+      rescue NameError
+        new(name) do |c|
+          c.valid_name = false
+        end
+      else
+        new(name) do |const|
+          const.previously_defined = previously_defined
+          const.original_value = recursive_const_get(name) if previously_defined
+        end
+      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={})
+        unless String === constant_name
+          raise ArgumentError, "`stub_const` requires a String, but you provided a #{constant_name.class.name}"
+        end
+
+        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

data/vendor/bundle/ruby/2.6.0/gems/rspec-mocks-3.10.2/lib/rspec/mocks/proxy.rb

@@ -0,0 +1,519 @@
+module RSpec
+  module Mocks
+    # @private
+    class Proxy
+      # @private
+      SpecificMessage = Struct.new(:object, :message, :args) do
+        def ==(expectation)
+          expectation.orig_object == object && expectation.matches?(message, *args)
+        end
+      end
+
+      unless defined?(Mutex)
+        Support.require_rspec_support 'mutex'
+        Mutex = Support::Mutex
+      end
+
+      # @private
+      def ensure_implemented(*_args)
+        # noop for basic proxies, see VerifyingProxy for behaviour.
+      end
+
+      # @private
+      def initialize(object, order_group, options={})
+        ensure_can_be_proxied!(object)
+
+        @object = object
+        @order_group = order_group
+        @error_generator = ErrorGenerator.new(object)
+        @messages_received = []
+        @messages_received_mutex = Mutex.new
+        @options = options
+        @null_object = false
+        @method_doubles = Hash.new { |h, k| h[k] = MethodDouble.new(@object, k, self) }
+      end
+
+      # @private
+      def ensure_can_be_proxied!(object)
+        return unless object.is_a?(Symbol) || object.frozen?
+        return if object.nil?
+
+        msg = "Cannot proxy frozen objects"
+        if Symbol === object
+          msg << ". Symbols such as #{object} cannot be mocked or stubbed."
+        else
+          msg << ", rspec-mocks relies on proxies for method stubbing and expectations."
+        end
+        raise ArgumentError, msg
+      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 original_method_handle_for(_message)
+        nil
+      end
+
+      DEFAULT_MESSAGE_EXPECTATION_OPTS = {}.freeze
+
+      # @private
+      def add_message_expectation(method_name, opts=DEFAULT_MESSAGE_EXPECTATION_OPTS, &block)
+        location = opts.fetch(:expected_from) { CallerFilter.first_non_rspec_line }
+        meth_double = method_double_for(method_name)
+
+        if null_object? && !block
+          meth_double.add_default_stub(@error_generator, @order_group, location, opts) do
+            @object
+          end
+        end
+
+        meth_double.add_expectation @error_generator, @order_group, 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,
+          @order_group
+        )
+      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_mutex.synchronize do
+          @messages_received.each do |(actual_method_name, args, received_block)|
+            next unless expectation.matches?(actual_method_name, *args)
+
+            expectation.safe_invoke(nil)
+            block.call(*args, &received_block) if block
+          end
+        end
+      end
+
+      # @private
+      def check_for_unexpected_arguments(expectation)
+        @messages_received_mutex.synchronize do
+          return if @messages_received.empty?
+
+          return if @messages_received.any? { |method_name, args, _| expectation.matches?(method_name, *args) }
+
+          name_but_not_args, others = @messages_received.partition do |(method_name, args, _)|
+            expectation.matches_name_but_not_args(method_name, *args)
+          end
+
+          return if name_but_not_args.empty? && !others.empty?
+
+          expectation.raise_unexpected_message_args_error(name_but_not_args.map { |args| args[1] })
+        end
+      end
+
+      # @private
+      def add_stub(method_name, opts={}, &implementation)
+        location = opts.fetch(:expected_from) { CallerFilter.first_non_rspec_line }
+        method_double_for(method_name).add_stub @error_generator, @order_group, 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_stub_if_present(method_name)
+        method_double_for(method_name).remove_stub_if_present
+      end
+
+      # @private
+      def verify
+        @method_doubles.each_value { |d| d.verify }
+      end
+
+      # @private
+      def reset
+        @messages_received_mutex.synchronize do
+          @messages_received.clear
+        end
+      end
+
+      # @private
+      def received_message?(method_name, *args, &block)
+        @messages_received_mutex.synchronize do
+          @messages_received.any? { |array| array == [method_name, args, block] }
+        end
+      end
+
+      # @private
+      def messages_arg_list
+        @messages_received_mutex.synchronize do
+          @messages_received.map { |_, args, _| args }
+        end
+      end
+
+      # @private
+      def has_negative_expectation?(message)
+        method_double_for(message).expectations.find { |expectation| expectation.negative_expectation_for?(message) }
+      end
+
+      # @private
+      def record_message_received(message, *args, &block)
+        @order_group.invoked SpecificMessage.new(object, message, args)
+        @messages_received_mutex.synchronize do
+          @messages_received << [message, args, block]
+        end
+      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.unadvise(messages_arg_list)
+          expectation.invoke(stub, *args, &block)
+        elsif (expectation = find_almost_matching_expectation(message, *args))
+          expectation.advise(*args) if null_object? unless expectation.expected_messages_received?
+
+          if null_object? || !has_negative_expectation?(message)
+            expectation.raise_unexpected_message_args_error([args])
+          end
+        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_missing_default_stub_error(expectation, args_for_multiple_calls)
+        @error_generator.raise_missing_default_stub_error(expectation, args_for_multiple_calls)
+      end
+
+      # @private
+      def visibility_for(_method_name)
+        # This is the default (for test doubles). Subclasses override this.
+        :public
+      end
+
+      if Support::RubyFeatures.module_prepends_supported?
+        def self.prepended_modules_of(klass)
+          ancestors = klass.ancestors
+
+          # `|| 0` is necessary for Ruby 2.0, where the singleton class
+          # is only in the ancestor list when there are prepended modules.
+          singleton_index = ancestors.index(klass) || 0
+
+          ancestors[0, singleton_index]
+        end
+
+        def prepended_modules_of_singleton_class
+          @prepended_modules_of_singleton_class ||= RSpec::Mocks::Proxy.prepended_modules_of(@object.singleton_class)
+        end
+      end
+
+      # @private
+      def method_double_if_exists_for_message(message)
+        method_double_for(message) if @method_doubles.key?(message.to_sym)
+      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
+
+    # @private
+    class TestDoubleProxy < Proxy
+      def reset
+        @method_doubles.clear
+        object.__disallow_further_usage!
+        super
+      end
+    end
+
+    # @private
+    class PartialDoubleProxy < Proxy
+      def original_method_handle_for(message)
+        if any_instance_class_recorder_observing_method?(@object.class, message)
+          message = ::RSpec::Mocks.space.
+            any_instance_recorder_for(@object.class).
+            build_alias_method_name(message)
+        end
+
+        ::RSpec::Support.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 visibility_for(method_name)
+        # We fall back to :public because by default we allow undefined methods
+        # to be stubbed, and when we do so, we make them public.
+        MethodReference.method_visibility_for(@object, method_name) || :public
+      end
+
+      def reset
+        @method_doubles.each_value { |d| d.reset }
+        super
+      end
+
+      def message_received(message, *args, &block)
+        RSpec::Mocks.space.any_instance_recorders_from_ancestry_of(object).each do |subscriber|
+          subscriber.notify_received_message(object, message, args, block)
+        end
+        super
+      end
+
+    private
+
+      def any_instance_class_recorder_observing_method?(klass, method_name)
+        only_return_existing = true
+        recorder = ::RSpec::Mocks.space.any_instance_recorder_for(klass, only_return_existing)
+        return true if recorder && recorder.already_observing?(method_name)
+
+        superklass = klass.superclass
+        return false if superklass.nil?
+        any_instance_class_recorder_observing_method?(superklass, method_name)
+      end
+    end
+
+    # @private
+    # When we mock or stub a method on a class, we have to treat it a bit different,
+    # because normally singleton method definitions only affect the object on which
+    # they are defined, but on classes they affect subclasses, too. As a result,
+    # we need some special handling to get the original method.
+    module PartialClassDoubleProxyMethods
+      def initialize(source_space, *args)
+        @source_space = source_space
+        super(*args)
+      end
+
+      # Consider this situation:
+      #
+      #   class A; end
+      #   class B < A; end
+      #
+      #   allow(A).to receive(:new)
+      #   expect(B).to receive(:new).and_call_original
+      #
+      # When getting the original definition for `B.new`, we cannot rely purely on
+      # using `B.method(:new)` before our redefinition is defined on `B`, because
+      # `B.method(:new)` will return a method that will execute the stubbed version
+      # of the method on `A` since singleton methods on classes are in the lookup
+      # hierarchy.
+      #
+      # To do it properly, we need to find the original definition of `new` from `A`
+      # from _before_ `A` was stubbed, and we need to rebind it to `B` so that it will
+      # run with the proper `self`.
+      #
+      # That's what this method (together with `original_unbound_method_handle_from_ancestor_for`)
+      # does.
+      def original_method_handle_for(message)
+        unbound_method = superclass_proxy &&
+          superclass_proxy.original_unbound_method_handle_from_ancestor_for(message.to_sym)
+
+        return super unless unbound_method
+        unbound_method.bind(object)
+        # :nocov:
+      rescue TypeError
+        if RUBY_VERSION == '1.8.7'
+          # In MRI 1.8.7, a singleton method on a class cannot be rebound to its subclass
+          if unbound_method && unbound_method.owner.ancestors.first != unbound_method.owner
+            # This is a singleton method; we can't do anything with it
+            # But we can work around this using a different implementation
+            double = method_double_from_ancestor_for(message)
+            return object.method(double.method_stasher.stashed_method_name)
+          end
+        end
+        raise
+        # :nocov:
+      end
+
+    protected
+
+      def original_unbound_method_handle_from_ancestor_for(message)
+        double = method_double_from_ancestor_for(message)
+        double && double.original_method.unbind
+      end
+
+      def method_double_from_ancestor_for(message)
+        @method_doubles.fetch(message) do
+          # The fact that there is no method double for this message indicates
+          # that it has not been redefined by rspec-mocks. We need to continue
+          # looking up the ancestor chain.
+          return superclass_proxy &&
+            superclass_proxy.method_double_from_ancestor_for(message)
+        end
+      end
+
+      def superclass_proxy
+        return @superclass_proxy if defined?(@superclass_proxy)
+
+        if (superclass = object.superclass)
+          @superclass_proxy = @source_space.superclass_proxy_for(superclass)
+        else
+          @superclass_proxy = nil
+        end
+      end
+    end
+
+    # @private
+    class PartialClassDoubleProxy < PartialDoubleProxy
+      include PartialClassDoubleProxyMethods
+    end
+
+    # @private
+    class ProxyForNil < PartialDoubleProxy
+      def initialize(order_group)
+        set_expectation_behavior
+        super(nil, order_group)
+      end
+
+      attr_accessor :disallow_expectations
+      attr_accessor :warn_about_expectations
+
+      def add_message_expectation(method_name, opts={}, &block)
+        warn_or_raise!(method_name)
+        super
+      end
+
+      def add_stub(method_name, opts={}, &implementation)
+        warn_or_raise!(method_name)
+        super
+      end
+
+    private
+
+      def set_expectation_behavior
+        case RSpec::Mocks.configuration.allow_message_expectations_on_nil
+        when false
+          @warn_about_expectations = false
+          @disallow_expectations = true
+        when true
+          @warn_about_expectations = false
+          @disallow_expectations = false
+        else
+          @warn_about_expectations = true
+          @disallow_expectations = false
+        end
+      end
+
+      def warn_or_raise!(method_name)
+        # This method intentionally swallows the message when
+        # neither disallow_expectations nor warn_about_expectations
+        # are set to true.
+        if disallow_expectations
+          raise_error(method_name)
+        elsif warn_about_expectations
+          warn(method_name)
+        end
+      end
+
+      def warn(method_name)
+        warning_msg = @error_generator.expectation_on_nil_message(method_name)
+        RSpec.warning(warning_msg)
+      end
+
+      def raise_error(method_name)
+        @error_generator.raise_expectation_on_nil_error(method_name)
+      end
+    end
+  end
+end