Module: T::Configuration
- Defined in:
- lib/types/configuration.rb
Overview
typed: true frozen_string_literal: true
Class Method Summary collapse
- .call_validation_error_handler(signature, opts) ⇒ Object
-
.call_validation_error_handler=(value) ⇒ Object
Set a handler for type errors that result from calling a method.
-
.enable_checking_for_sigs_marked_checked_tests ⇒ Object
Announces to Sorbet that we are currently in a test environment, so it should treat any sigs which are marked ‘.checked(:tests)` as if they were just a normal sig.
- .hard_assert_handler(str, extra) ⇒ Object
-
.hard_assert_handler=(value) ⇒ Object
Set a handler for hard assertions.
- .inline_type_error_handler(error) ⇒ Object
-
.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!`.
- .log_info_handler(str, extra) ⇒ Object
-
.log_info_handler=(value) ⇒ Object
Set a handler for logging.
- .scalar_types ⇒ Object
-
.scalar_types=(values) ⇒ Object
Set a list of class strings that are to be considered scalar.
- .sig_builder_error_handler(error, location) ⇒ Object
-
.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.
- .sig_validation_error_handler(error, opts) ⇒ Object
-
.sig_validation_error_handler=(value) ⇒ Object
Set a handler to handle sig validation errors.
- .soft_assert_handler(str, extra) ⇒ Object
-
.soft_assert_handler=(value) ⇒ Object
Set a handler for soft assertions.
Class Method Details
.call_validation_error_handler(signature, opts) ⇒ Object
188 189 190 191 192 193 194 |
# File 'lib/types/configuration.rb', line 188 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. 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:
172 173 174 175 |
# File 'lib/types/configuration.rb', line 172 def self.call_validation_error_handler=(value) validate_lambda_given!(value) @call_validation_error_handler = value end |
.enable_checking_for_sigs_marked_checked_tests ⇒ Object
Announces to Sorbet that we are currently in a test environment, so it should treat any sigs which are marked ‘.checked(:tests)` as if they were just a normal sig.
If this method is not called, sigs marked ‘.checked(:tests)` will not be checked. In fact, such methods won’t even be wrapped–the runtime will put back the original method.
Note: Due to the way sigs are evaluated and methods are wrapped, this method MUST be called before any code calls ‘sig`. This method raises if it has been called too late.
16 17 18 |
# File 'lib/types/configuration.rb', line 16 def self.enable_checking_for_sigs_marked_checked_tests T::Private::RuntimeLevels.enable_checking_in_tests end |
.hard_assert_handler(str, extra) ⇒ Object
287 288 289 290 291 292 293 |
# File 'lib/types/configuration.rb', line 287 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:
278 279 280 281 |
# File 'lib/types/configuration.rb', line 278 def self.hard_assert_handler=(value) validate_lambda_given!(value) @hard_assert_handler = value end |
.inline_type_error_handler(error) ⇒ Object
48 49 50 51 52 53 54 |
# File 'lib/types/configuration.rb', line 48 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:
39 40 41 42 |
# File 'lib/types/configuration.rb', line 39 def self.inline_type_error_handler=(value) validate_lambda_given!(value) @inline_type_error_handler = value end |
.log_info_handler(str, extra) ⇒ Object
219 220 221 222 223 224 225 |
# File 'lib/types/configuration.rb', line 219 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:
210 211 212 213 |
# File 'lib/types/configuration.rb', line 210 def self.log_info_handler=(value) validate_lambda_given!(value) @log_info_handler = value end |
.scalar_types ⇒ Object
326 327 328 |
# File 'lib/types/configuration.rb', line 326 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)
302 303 304 305 306 307 308 309 310 311 312 313 |
# File 'lib/types/configuration.rb', line 302 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
87 88 89 90 91 92 93 |
# File 'lib/types/configuration.rb', line 87 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:
78 79 80 81 |
# File 'lib/types/configuration.rb', line 78 def self.sig_builder_error_handler=(value) validate_lambda_given!(value) @sig_builder_error_handler = value end |
.sig_validation_error_handler(error, opts) ⇒ Object
136 137 138 139 140 141 142 |
# File 'lib/types/configuration.rb', line 136 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. 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:
127 128 129 130 |
# File 'lib/types/configuration.rb', line 127 def self.sig_validation_error_handler=(value) validate_lambda_given!(value) @sig_validation_error_handler = value end |
.soft_assert_handler(str, extra) ⇒ Object
253 254 255 256 257 258 259 |
# File 'lib/types/configuration.rb', line 253 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:
244 245 246 247 |
# File 'lib/types/configuration.rb', line 244 def self.soft_assert_handler=(value) validate_lambda_given!(value) @soft_assert_handler = value end |