module RSpec::Support

def self.class_of(object)
  object.class
rescue NoMethodError
  singleton_class = class << object; self; end
  singleton_class.ancestors.find { |ancestor| !ancestor.equal?(singleton_class) }
end

def self.define_optimized_require_for_rspec(lib, &require_relative)
  name = "require_rspec_#{lib}"
  if RUBY_PLATFORM == 'java' && !Kernel.respond_to?(:require)
    # JRuby 9.1.17.0 has developed a regression for require
    (class << self; self; end).__send__(:define_method, name) do |f|
      Kernel.send(:require, "rspec/#{lib}/#{f}")
    end
  elsif Kernel.respond_to?(:require_relative)
    (class << self; self; end).__send__(:define_method, name) do |f|
      require_relative.call("#{lib}/#{f}")
    end
  else
    (class << self; self; end).__send__(:define_method, name) do |f|
      require "rspec/#{lib}/#{f}"
    end
  end
end

def self.deregister_matcher_definition(&block)
  matcher_definitions.delete(block)
end

def self.failure_notifier
  thread_local_data[:failure_notifier] || DEFAULT_FAILURE_NOTIFIER
end

def self.failure_notifier=(callable)
  thread_local_data[:failure_notifier] = callable
end

def self.is_a_matcher?(object)
  matcher_definitions.any? { |md| md.call(object) }
end

def self.matcher_definitions
  @matcher_definitions ||= []
end

def self.method_handle_for(object, method_name)
  KERNEL_METHOD_METHOD.bind(object).call(method_name)
rescue NameError => original
  begin
    handle = object.method(method_name)
    raise original unless handle.is_a? Method
    handle
  rescue Support::AllExceptionsExceptOnesWeMustNotRescue
    raise original
  end
end

def self.method_handle_for(object, method_name)
  if ::Kernel === object
    KERNEL_METHOD_METHOD.bind(object).call(method_name)
  else
    object.method(method_name)
  end
rescue NameError => original
  begin
    handle = object.method(method_name)
    raise original unless handle.is_a? Method
    handle
  rescue Support::AllExceptionsExceptOnesWeMustNotRescue
    raise original
  end
end

def self.notify_failure(failure, options={})
  failure_notifier.call(failure, options)
end

def self.register_matcher_definition(&block)
  matcher_definitions << block
end

def self.rspec_description_for_object(object)
  if RSpec::Support.is_a_matcher?(object) && object.respond_to?(:description)
    object.description
  else
    object
  end
end

def self.thread_local_data
  Thread.current.thread_variable_get(:__rspec) || Thread.current.thread_variable_set(:__rspec, {})
end

def self.thread_local_data
  Thread.current[:__rspec] ||= {}
end

def self.warning_notifier
  @warning_notifier ||= DEFAULT_WARNING_NOTIFIER
end

def self.with_failure_notifier(callable)
  orig_notifier = failure_notifier
  self.failure_notifier = callable
  yield
ensure
  self.failure_notifier = orig_notifier
end