Module: T::Configuration

Defined in:
lib/types/configuration.rb

Overview

typed: true frozen_string_literal: true

Class Method Summary collapse

Class Method Details

.call_validation_error_handler(signature, opts) ⇒ Object 



220
221
222
223
224
225
226
 
# File 'lib/types/configuration.rb', line 220

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

.call_validation_error_handler=(value) ⇒ Object

Set a handler for type errors that result from calling a method.

By default, errors from calling a method cause an exception to be raised. One exception is for ‘generated` sigs, for which a message will be logged instead of raising. Setting call_validation_error_handler to an object that implements :call (e.g. proc or lambda) allows users to customize the behavior when a method is called with invalid parameters, or returns an invalid value.

Parameters passed to value.call:

Examples:

T::Configuration.call_validation_error_handler = lambda do |signature, opts|
  puts opts[:message]
end

Parameters:

  • value (Lambda, Proc, Object, nil) —

    Proc that handles the error report (pass nil to reset to default behavior)

  • signature (T::Private::Methods::Signature) —

    Signature that failed

  • opts (Hash) —

    A hash containing contextual information on the error:



177
178
179
180
 
# File 'lib/types/configuration.rb', line 177

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

.hard_assert_handler(str, extra) ⇒ Object 



319
320
321
322
323
324
325
 
# File 'lib/types/configuration.rb', line 319

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

.hard_assert_handler=(value) ⇒ Object

Set a handler for hard assertions

These generally should stop execution of the program, and optionally inform some party of the assertion.

Parameters passed to value.call:

Examples:

T::Configuration.hard_assert_handler = lambda do |str, extra|
  raise "#{str}, context: #{extra}"
end

Parameters:

  • value (Lambda, Proc, Object, nil) —

    Proc that handles the error report (pass nil to reset to default behavior)

  • str (String) —

    Assertion message

  • extra (Hash) —

    A hash containing additional parameters to be passed along to the handler.



310
311
312
313
 
# File 'lib/types/configuration.rb', line 310

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

.inline_type_error_handler(error) ⇒ Object 



33
34
35
36
37
38
39
 
# File 'lib/types/configuration.rb', line 33

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

.inline_type_error_handler=(value) ⇒ Object

Set a handler to handle ‘TypeError`s raised by any in-line type assertions, including `T.must`, `T.let`, `T.cast`, and `T.assert_type!`.

By default, any ‘TypeError`s detected by this gem will be raised. Setting inline_type_error_handler to an object that implements :call (e.g. proc or lambda) allows users to customize the behavior when a `TypeError` is raised on any inline type assertion.

Parameters passed to value.call:

Examples:

T::Configuration.inline_type_error_handler = lambda do |error|
  puts error.message
end

Parameters:

  • value (Lambda, Proc, Object, nil) —

    Proc that handles the error (pass nil to reset to default behavior)

  • error (TypeError) —

    TypeError that was raised



24
25
26
27
 
# File 'lib/types/configuration.rb', line 24

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

.log_info_handler(str, extra) ⇒ Object 



251
252
253
254
255
256
257
 
# File 'lib/types/configuration.rb', line 251

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

.log_info_handler=(value) ⇒ Object

Set a handler for logging

Parameters passed to value.call:

Examples:

T::Configuration.log_info_handler = lambda do |str, extra|
  puts "#{str}, context: #{extra}"
end

Parameters:

  • value (Lambda, Proc, Object, nil) —

    Proc that handles the error report (pass nil to reset to default behavior)

  • str (String) —

    Message to be logged

  • extra (Hash) —

    A hash containing additional parameters to be passed along to the logger.



242
243
244
245
 
# File 'lib/types/configuration.rb', line 242

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

.scalar_types ⇒ Object 



358
359
360
 
# File 'lib/types/configuration.rb', line 358

def self.scalar_types
  @scalar_types || @default_scalar_types
end

.scalar_types=(values) ⇒ Object

Set a list of class strings that are to be considered scalar.

(pass nil to reset to default behavior)

Examples:

T::Configuration.scalar_types = ["NilClass", "TrueClass", "FalseClass", ...]

Parameters:

  • value (String) —

    Class name.



334
335
336
337
338
339
340
341
342
343
344
345
 
# File 'lib/types/configuration.rb', line 334

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

.sig_builder_error_handler(error, location) ⇒ Object 



72
73
74
75
76
77
78
 
# File 'lib/types/configuration.rb', line 72

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

.sig_builder_error_handler=(value) ⇒ Object

Set a handler to handle errors that occur when the builder methods in the body of a sig are executed. The sig builder methods are inside a proc so that they can be lazily evaluated the first time the method being sig’d is called.

By default, improper use of the builder methods within the body of a sig cause an ArgumentError to be raised. Setting sig_builder_error_handler to an object that implements :call (e.g. proc or lambda) allows users to customize the behavior when a sig can’t be built for some reason.

Parameters passed to value.call:

Examples:

T::Configuration.sig_builder_error_handler = lambda do |error, location|
  puts error.message
end

Parameters:

  • value (Lambda, Proc, Object, nil) —

    Proc that handles the error (pass nil to reset to default behavior)

  • error (StandardError) —

    The error that was raised

  • location (Thread::Backtrace::Location) —

    Location of the error



63
64
65
66
 
# File 'lib/types/configuration.rb', line 63

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

.sig_validation_error_handler(error, opts) ⇒ Object 



139
140
141
142
143
144
145
 
# File 'lib/types/configuration.rb', line 139

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

.sig_validation_error_handler=(value) ⇒ Object

Set a handler to handle sig validation errors.

Sig validation errors include things like abstract checks, override checks, and type compatibility of arguments. They happen after a sig has been successfully built, but the built sig is incompatible with other sigs in some way.

By default, sig validation errors cause an exception to be raised. One exception is for ‘generated` sigs, for which a message will be logged instead of raising. Setting sig_validation_error_handler to an object that implements :call (e.g. proc or lambda) allows users to customize the behavior when a method signature’s build fails.

Parameters passed to value.call:

Examples:

T::Configuration.sig_validation_error_handler = lambda do |error, opts|
  puts error.message
end

Parameters:

  • value (Lambda, Proc, Object, nil) —

    Proc that handles the error (pass nil to reset to default behavior)

  • error (StandardError) —

    The error that was raised

  • opts (Hash) —

    A hash containing contextual information on the error:



113
114
115
116
 
# File 'lib/types/configuration.rb', line 113

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

.soft_assert_handler(str, extra) ⇒ Object 



285
286
287
288
289
290
291
 
# File 'lib/types/configuration.rb', line 285

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

.soft_assert_handler=(value) ⇒ Object

Set a handler for soft assertions

These generally shouldn’t stop execution of the program, but rather inform some party of the assertion to action on later.

Parameters passed to value.call:

Examples:

T::Configuration.soft_assert_handler = lambda do |str, extra|
  puts "#{str}, context: #{extra}"
end

Parameters:

  • value (Lambda, Proc, Object, nil) —

    Proc that handles the error report (pass nil to reset to default behavior)

  • str (String) —

    Assertion message

  • extra (Hash) —

    A hash containing additional parameters to be passed along to the handler.



276
277
278
279
 
# File 'lib/types/configuration.rb', line 276

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