module T::Configuration

def self.call_validation_error_handler(signature, opts) 

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)

Options Hash: (**opts)
  • :location (Thread::Backtrace::Location) -- Location of the
  • :value (Object) -- Actual param/return value
  • :type (Object) -- Expected param/return value type
  • :name (Symbol) -- Param or block param name (nil for return
  • :kind (String) -- One of:
  • :message (String) -- Error message

Parameters:
  • opts (Hash) -- A hash containing contextual information on the error:
  • signature (T::Private::Methods::Signature) -- Signature that failed
  • value (Lambda, Proc, Object, nil) -- Proc that handles the error 
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) 

def self.call_validation_error_handler_default(signature, opts)
_line = signature.method.source_location
cation]
opts[:kind]}#{opts[:name] ? " '#{opts[:name]}'" : ''}: #{opts[:message]}\n" \
on.path}:#{location.lineno}\n" \
thod_file}:#{method_line}"
(error_message)

def self.enable_checking_for_sigs_marked_checked_tests

it has been called too late.
method MUST be called before any code calls `sig`. This method raises if
Note: Due to the way sigs are evaluated and methods are wrapped, this

back the original method.
checked. In fact, such methods won't even be wrapped--the runtime will put
If this method is not called, sigs marked `.checked(:tests)` will not be

just a normal sig.
should treat any sigs which are marked `.checked(:tests)` as if they were
Announces to Sorbet that we are currently in a test environment, so it 
def self.enable_checking_for_sigs_marked_checked_tests
  T::Private::RuntimeLevels.enable_checking_in_tests
end

def self.hard_assert_handler(str, extra) 

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)

Parameters:
  • extra (Hash) -- A hash containing additional parameters to be passed along to the handler.
  • str (String) -- Assertion message
  • value (Lambda, Proc, Object, nil) -- Proc that handles the error 
def self.hard_assert_handler=(value)
  validate_lambda_given!(value)
  @hard_assert_handler = value
end

def self.hard_assert_handler_default(str, _) 

def self.hard_assert_handler_default(str, _)

def self.inline_type_error_handler(error) 

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)

Parameters:
  • error (TypeError) -- TypeError that was raised
  • value (Lambda, Proc, Object, nil) -- Proc that handles the error (pass 
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.inline_type_error_handler_default(error)

def self.log_info_handler(str, extra) 

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)

Parameters:
  • extra (Hash) -- A hash containing additional parameters to be passed along to the logger.
  • str (String) -- Message to be logged
  • value (Lambda, Proc, Object, nil) -- Proc that handles the error 
def self.log_info_handler=(value)
  validate_lambda_given!(value)
  @log_info_handler = value
end

def self.log_info_handler_default(str, extra) 

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

def self.scalar_types 

def self.scalar_types
  @scalar_types || @default_scalar_types
end

def self.scalar_types=(values)

Parameters:
  • value (String) -- Class name. 
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) 

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)

Parameters:
  • location (Thread::Backtrace::Location) -- Location of the error
  • error (StandardError) -- The error that was raised
  • value (Lambda, Proc, Object, nil) -- Proc that handles the error (pass 
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) 

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

def self.sig_validation_error_handler(error, opts) 

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)

Options Hash: (**opts)
  • :super_signature (T::Private::Methods::Signature, nil) -- Super
  • :signature (T::Private::Methods::Signature, nil) -- Signature
  • :declaration (T::Private::Methods::Declaration) -- Method
  • :method (Method, UnboundMethod) -- Method on which the signature build failed

Parameters:
  • opts (Hash) -- A hash containing contextual information on the error:
  • error (StandardError) -- The error that was raised
  • value (Lambda, Proc, Object, nil) -- Proc that handles the error (pass 
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) 

def self.sig_validation_error_handler_default(error, opts)

def self.soft_assert_handler(str, extra) 

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)

Parameters:
  • extra (Hash) -- A hash containing additional parameters to be passed along to the handler.
  • str (String) -- Assertion message
  • value (Lambda, Proc, Object, nil) -- Proc that handles the error 
def self.soft_assert_handler=(value)
  validate_lambda_given!(value)
  @soft_assert_handler = value
end

def self.soft_assert_handler_default(str, extra) 

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

def self.validate_lambda_given!(value) 

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