Class MessageExpectation has 58 methods (exceeds 20 allowed). Consider refactoring.

    class MessageExpectation
      # @!group Configuring Responses

      # @overload and_return(value)
      # @overload and_return(first_value, second_value)

Class ErrorGenerator has 48 methods (exceeds 20 allowed). Consider refactoring.

    class ErrorGenerator
      attr_writer :opts

      def initialize(target=nil)
        @target = target

File message_expectation.rb has 441 lines of code (exceeds 250 allowed). Consider refactoring.

RSpec::Support.require_rspec_support 'mutex'

module RSpec
  module Mocks
    # A message expectation that only allows concrete return values to be set

Class Proxy has 34 methods (exceeds 20 allowed). Consider refactoring.

    class Proxy
      # @private
      SpecificMessage = Struct.new(:object, :message, :args) do
        def ==(expectation)
          expectation.orig_object == object && expectation.matches?(message, *args)

File proxy.rb has 340 lines of code (exceeds 250 allowed). Consider refactoring.

module RSpec
  module Mocks
    # @private
    class Proxy
      # @private

Class MethodDouble has 30 methods (exceeds 20 allowed). Consider refactoring.

    class MethodDouble
      # @private
      attr_reader :method_name, :object, :expectations, :stubs, :method_stasher

      # @private

Class Recorder has 29 methods (exceeds 20 allowed). Consider refactoring.

      class Recorder
        # @private
        attr_reader :message_chains, :stubs, :klass

        def initialize(klass)

Method message_received has a Cognitive Complexity of 23 (exceeds 5 allowed). Consider refactoring.

      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)

• Read up
  Read up

Class HaveReceived has 22 methods (exceeds 20 allowed). Consider refactoring.

      class HaveReceived
        include Matcher

        COUNT_CONSTRAINTS = %w[exactly at_least at_most times time once twice thrice]
        ARGS_CONSTRAINTS = %w[with]

File error_generator.rb has 262 lines of code (exceeds 250 allowed). Consider refactoring.

RSpec::Support.require_rspec_support "object_formatter"

module RSpec
  module Mocks
    # Raised when a message expectation is not satisfied.

Method enable_should has 49 lines of code (exceeds 25 allowed). Consider refactoring.

      def self.enable_should(syntax_host=default_should_syntax_host)
        @warn_about_should = false if syntax_host == default_should_syntax_host
        return if should_enabled?(syntax_host)

        syntax_host.class_exec do

Method replay_received_message_on has a Cognitive Complexity of 12 (exceeds 5 allowed). Consider refactoring.

      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?

• Read up
  Read up

Method verify_constants_to_transfer! has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.

        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)

• Read up
  Read up

Method enable_expect has 28 lines of code (exceeds 25 allowed). Consider refactoring.

      def self.enable_expect(syntax_host=::RSpec::Mocks::ExampleMethods)
        return if expect_enabled?(syntax_host)

        syntax_host.class_exec do
          def receive(method_name, &block)

Method call has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.

      def call(*_args_to_ignore, &block)
        return if @args_to_yield.empty? && @eval_context.nil?

        @error_generator.raise_missing_block_error @args_to_yield unless block
        value = nil

• Read up
  Read up

Method original_method_handle_for has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.

      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

• Read up
  Read up

Method raise_expectation_error has 8 arguments (exceeds 4 allowed). Consider refactoring.

      def raise_expectation_error(message, expected_received_count, argument_list_matcher,
                                  actual_received_count, expectation_count_type, args,
                                  backtrace_line=nil, source_id=nil)

Method initialize has 7 arguments (exceeds 4 allowed). Consider refactoring.

        def initialize(error_generator, expectation_ordering, expected_from, method_double,
                       type=:expectation, opts={}, &implementation_block)

Method find_best_matching_expectation_for has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

      def find_best_matching_expectation_for(method_name)
        first_match = nil

        method_double_for(method_name).expectations.each do |expectation|
          next unless yield expectation

• Read up
  Read up

Method invoke_incrementing_actual_calls_by has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

        def invoke_incrementing_actual_calls_by(increment, allowed_to_fail, parent_stub, *args, &block)
          args.unshift(orig_object) if yield_receiver_to_implementation_block?

          if negative? || (allowed_to_fail && (@exactly || @at_most) && (@actual_received_count == @expected_received_count))
            # args are the args we actually received, @argument_list_matcher is the

• Read up
  Read up

Method setup_simple_method_double has 5 arguments (exceeds 4 allowed). Consider refactoring.

      def setup_simple_method_double(method_name, response, collection, error_generator=nil, backtrace_line=nil)

Method invoke_incrementing_actual_calls_by has 5 arguments (exceeds 4 allowed). Consider refactoring.

        def invoke_incrementing_actual_calls_by(increment, allowed_to_fail, parent_stub, *args, &block)

Method add_stub has 5 arguments (exceeds 4 allowed). Consider refactoring.

      def add_stub(error_generator, expectation_ordering, expected_from, opts={}, &implementation)

Method add_expectation has 5 arguments (exceeds 4 allowed). Consider refactoring.

      def add_expectation(error_generator, expectation_ordering, expected_from, opts, &implementation)

Method describe_expectation has 5 arguments (exceeds 4 allowed). Consider refactoring.

      def describe_expectation(verb, message, expected_received_count, _actual_received_count, args)

Method for has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.

      def self.for(object_module_or_name, allow_direct_object_refs=false)
        case object_module_or_name
        when Module
          if anonymous_module?(object_module_or_name)
            DirectObjectReference.new(object_module_or_name)

• Read up
  Read up

Method raise_unimplemented_error has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.

      def raise_unimplemented_error(doubled_module, method_name, object)
        message = case object
                  when InstanceVerifyingDouble
                    "the %s class does not implement the instance method: %s".dup <<
                      if ObjectMethodReference.for(doubled_module, method_name).implemented?

• Read up
  Read up

Method check_for_unexpected_arguments has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.

      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) }

• Read up
  Read up

Method method_missing has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.

      def method_missing(message, *args, &block)
        proxy = __mock_proxy
        proxy.record_message_received(message, *args, &block)

        if proxy.null_object?

• Read up
  Read up

Method usable_rspec_prepended_module has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.

        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.

• Read up
  Read up

Method default_should_syntax_host has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.

      def self.default_should_syntax_host
        # JRuby 1.7.4 introduces a regression whereby `defined?(::BasicObject) => nil`
        # yet `BasicObject` still exists and patching onto ::Object breaks things
        # e.g. SimpleDelegator expectations won't work
        #

• Read up
  Read up

Method observe! has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.

        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)

• Read up
  Read up

Method setup_chain has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.

      def setup_chain
        if chain.length > 1
          if (matching_stub = find_matching_stub)
            chain.shift
            chain_on(matching_stub.invoke(nil), *chain, &@block)

• Read up
  Read up

Method and_return has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.

      def and_return(first_value, *values)
        raise_already_invoked_error_if_necessary(__method__)
        if negative?
          raise "`and_return` is not supported with negative message expectations"
        end

• Read up
  Read up