module T::Configuration

def self.call_validation_error_handler(signature, opts)
  if @call_validation_error_handler
    @call_validation_error_handler.call(signature, opts)
  else
    call_validation_error_handler_default(signature, opts)
  end
end

def self.call_validation_error_handler=(value)
  validate_lambda_given!(value)
  @call_validation_error_handler = value
end

def self.call_validation_error_handler_default(signature, opts)
_line = signature.method.source_location
cation]
{location.path}:#{location.lineno}\n" \
thod_file}:#{method_line}"
opts[:kind]}#{opts[:name] ? " '#{opts[:name]}'" : ''}: #{opts[:message]}\n#{suffix}"
ted
].class
:Enumerable[T.untyped]).describe_obj(opts[:value]) if got < Enumerable
log_info_handler(
ED",
location.path,
location.lineno,
le: method_file,
ne: method_line,
ind],
ame],
s[:type].name,
t_notify
soft_assert_handler(
rror_message}",
ure.soft_notify}
.new(error_message)
=> e # raise into rescue to ensure e.backtrace is populated
orHandler.handle_inline_type_error(e)

def self.hard_assert_handler(str, extra)
  if @hard_assert_handler
    @hard_assert_handler.call(str, extra)
  else
    hard_assert_handler_default(str, extra)
  end
end

def self.hard_assert_handler=(value)
  validate_lambda_given!(value)
  @hard_assert_handler = value
end

def self.hard_assert_handler_default(str, _)

def self.inline_type_error_handler(error)
  if @inline_type_error_handler
    @inline_type_error_handler.call(error)
  else
    inline_type_error_handler_default(error)
  end
end

def self.inline_type_error_handler=(value)
  validate_lambda_given!(value)
  @inline_type_error_handler = value
end

def self.inline_type_error_handler_default(error)

def self.log_info_handler(str, extra)
  if @log_info_handler
    @log_info_handler.call(str, extra)
  else
    log_info_handler_default(str, extra)
  end
end

def self.log_info_handler=(value)
  validate_lambda_given!(value)
  @log_info_handler = value
end

def self.log_info_handler_default(str, extra)
: #{extra}" # rubocop:disable PrisonGuard/NoBarePuts

def self.scalar_types
  @scalar_types || @default_scalar_types
end

def self.scalar_types=(values)
  if values.nil?
    @scalar_tyeps = values
  else
    bad_values = values.select {|v| v.class != String}
    unless bad_values.empty?
      raise ArgumentError.new("Provided values must all be class name strings.")
    end
    @scalar_types = Set.new(values).freeze
  end
end

def self.sig_builder_error_handler(error, location)
  if @sig_builder_error_handler
    @sig_builder_error_handler.call(error, location)
  else
    sig_builder_error_handler_default(error, location)
  end
end

def self.sig_builder_error_handler=(value)
  validate_lambda_given!(value)
  @sig_builder_error_handler = value
end

def self.sig_builder_error_handler_default(error, location)
.sig_error(location, error.message)

def self.sig_validation_error_handler(error, opts)
  if @sig_validation_error_handler
    @sig_validation_error_handler.call(error, opts)
  else
    sig_validation_error_handler_default(error, opts)
  end
end

def self.sig_validation_error_handler=(value)
  validate_lambda_given!(value)
  @sig_validation_error_handler = value
end

def self.sig_validation_error_handler_default(error, opts)
errides a generated signature, report that one instead
method]
on].generated
 opts[:super_signature]
uper_signature&.generated
r_signature.method
_line = bad_method.source_location
g_info_handler(
ED",
: method_file,
: method_line,

message,

def self.soft_assert_handler(str, extra)
  if @soft_assert_handler
    @soft_assert_handler.call(str, extra)
  else
    soft_assert_handler_default(str, extra)
  end
end

def self.soft_assert_handler=(value)
  validate_lambda_given!(value)
  @soft_assert_handler = value
end

def self.soft_assert_handler_default(str, extra)
: #{extra}" # rubocop:disable PrisonGuard/NoBarePuts

def self.validate_lambda_given!(value)
value.respond_to?(:call)
or.new("Provided value must respond to :call")