class RSpec::Mocks::AnyInstance::Chain

def constrained_to_any_of?(*constraints)
  constraints.any? do |constraint|
    messages.any? do |message|
      message.first.first == constraint
    end
  end
end

def create_message_expectation_on(instance)
  me = yield(::RSpec::Mocks.proxy_for(instance), IGNORED_BACKTRACE_LINE)
  if RSpec::Mocks.configuration.should_warn_about_any_instance_blocks?
    me.warn_about_receiver_passing(@source_line)
    me.display_any_instance_deprecation_warning_if_necessary(@expectation_block)
  elsif RSpec::Mocks.configuration.yield_receiver_to_any_instance_implementation_blocks?
    me.and_yield_receiver_to_implementation
  end
  me
end

def ensure_expectation_block_has_source_location; end

def ensure_expectation_block_has_source_location
  return unless @expectation_block
  source_location = CallerFilter.first_non_rspec_line.split(':')
  @expectation_block.extend Module.new {
    define_method(:source_location) { source_location }
  }
end

def expectation_fulfilled!
  @expectation_fulfilled = true
end

def initialize(recorder, *args, &block)
  @recorder          = recorder
  @expectation_args  = args
  @expectation_block = block
  @source_line       = CallerFilter.first_non_rspec_line
  ensure_expectation_block_has_source_location
end

def last_message
  messages.last.first.first unless messages.empty?
end

def messages
  @messages ||= []
end

def negated?
  messages.any? { |(message, *_), _| message.to_sym == :never }
end

def never
  ErrorGenerator.raise_double_negation_error("expect_any_instance_of(MyClass)") if negated?
  super
end

def playback!(instance)
  message_expectation = create_message_expectation_on(instance)
  messages.inject(message_expectation) do |object, message|
    object.__send__(*message.first, &message.last)
  end
end

def record(rspec_method_name, *args, &block)
  verify_invocation_order(rspec_method_name, *args, &block)
  messages << [args.unshift(rspec_method_name), block]
  self
end