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.
-
.default_checked_level=(default_checked_level) ⇒ Object
Configure the default checked level for a sig with no explicit ‘.checked` builder.
-
.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
194 195 196 197 198 199 200 |
# File 'lib/types/configuration.rb', line 194 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:
185 186 187 188 |
# File 'lib/types/configuration.rb', line 185 def self.call_validation_error_handler=(value) validate_lambda_given!(value) @call_validation_error_handler = value end |
.default_checked_level=(default_checked_level) ⇒ Object
Configure the default checked level for a sig with no explicit ‘.checked` builder. When unset, the default checked level is `:always`.
Note: setting this option is potentially dangerous! Sorbet can’t check all code statically. The runtime checks complement the checks that Sorbet does statically, so that methods don’t have to guard themselves from being called incorrectly by untyped code.
29 30 31 |
# File 'lib/types/configuration.rb', line 29 def self.default_checked_level=(default_checked_level) T::Private::RuntimeLevels.default_checked_level = default_checked_level 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
293 294 295 296 297 298 299 |
# File 'lib/types/configuration.rb', line 293 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:
284 285 286 287 |
# File 'lib/types/configuration.rb', line 284 def self.hard_assert_handler=(value) validate_lambda_given!(value) @hard_assert_handler = value end |
.inline_type_error_handler(error) ⇒ Object
61 62 63 64 65 66 67 |
# File 'lib/types/configuration.rb', line 61 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:
52 53 54 55 |
# File 'lib/types/configuration.rb', line 52 def self.inline_type_error_handler=(value) validate_lambda_given!(value) @inline_type_error_handler = value end |
.log_info_handler(str, extra) ⇒ Object
225 226 227 228 229 230 231 |
# File 'lib/types/configuration.rb', line 225 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:
216 217 218 219 |
# File 'lib/types/configuration.rb', line 216 def self.log_info_handler=(value) validate_lambda_given!(value) @log_info_handler = value end |
.scalar_types ⇒ Object
332 333 334 |
# File 'lib/types/configuration.rb', line 332 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)
308 309 310 311 312 313 314 315 316 317 318 319 |
# File 'lib/types/configuration.rb', line 308 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
100 101 102 103 104 105 106 |
# File 'lib/types/configuration.rb', line 100 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:
91 92 93 94 |
# File 'lib/types/configuration.rb', line 91 def self.sig_builder_error_handler=(value) validate_lambda_given!(value) @sig_builder_error_handler = value end |
.sig_validation_error_handler(error, opts) ⇒ Object
149 150 151 152 153 154 155 |
# File 'lib/types/configuration.rb', line 149 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:
140 141 142 143 |
# File 'lib/types/configuration.rb', line 140 def self.sig_validation_error_handler=(value) validate_lambda_given!(value) @sig_validation_error_handler = value end |
.soft_assert_handler(str, extra) ⇒ Object
259 260 261 262 263 264 265 |
# File 'lib/types/configuration.rb', line 259 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:
250 251 252 253 |
# File 'lib/types/configuration.rb', line 250 def self.soft_assert_handler=(value) validate_lambda_given!(value) @soft_assert_handler = value end |