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)
(opts[:pretty_message])

def self.default_checked_level=(default_checked_level)

Parameters:
  • default_checked_level (:never, :tests, :always) -- 
def self.default_checked_level=(default_checked_level)
  T::Private::RuntimeLevels.default_checked_level = default_checked_level
end

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.enable_final_checks_on_hooks

```
end
def foo; end
include M
class C
end
def foo; end
sig(:final) {void}
extend T::Sig
module M
```ruby

example will not raise an error.
including and extending modules. Iff this is not called, then the following
Announce to Sorbet that we would like the final checks to be enabled when 
def self.enable_final_checks_on_hooks
  T::Private::Methods.set_final_checks_on_hooks(true)
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.reset_final_checks_on_hooks

`enable_final_checks_on_hooks`.
Undo the effects of a previous call to 
def self.reset_final_checks_on_hooks
  T::Private::Methods.set_final_checks_on_hooks(false)
end

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

def self.without_ruby_warnings

Other tags:
    Yield: - 
def self.without_ruby_warnings
  if $VERBOSE
    begin
      original_verbose = $VERBOSE
      $VERBOSE = false
      yield
    ensure
      $VERBOSE = original_verbose
    end
  else
    yield
  end
end