Module: T::Utils

Defined in:
lib/types/utils.rb

Overview

typed: true

Defined Under Namespace

Modules: Nilable, Private

Class Method Summary collapse

Class Method Details

.arity(method) ⇒ Object

Returns the arity of a method, unwrapping the sig if needed



110
111
112
113
114
115
 
# File 'lib/types/utils.rb', line 110

def self.arity(method)
  arity = method.arity
  return arity if arity != -1 || method.is_a?(Proc)
  sig = T::Private::Methods.signature_for_method(method)
  sig ? sig.method.arity : arity
end

.check_type_recursive!(value, type) ⇒ Object

Dynamically confirm that ‘value` is recursively a valid value of type `type`, including recursively through collections. Note that in some cases this runtime check can be very expensive, especially with large collections of objects.



48
49
50
 
# File 'lib/types/utils.rb', line 48

def self.check_type_recursive!(value, type)
  T::Private::Casts.cast_recursive(value, type, "T.check_type_recursive!")
end

.coerce(val) ⇒ Object

Used to convert from a type specification to a ‘T::Types::Base`.



40
41
42
 
# File 'lib/types/utils.rb', line 40

def self.coerce(val)
  Private.coerce_and_check_module_types(val, nil, false)
end

.lift_enum(enum) ⇒ Object 



153
154
155
156
157
158
159
160
161
162
163
164
165
166
 
# File 'lib/types/utils.rb', line 153

def self.lift_enum(enum)
  unless enum.is_a?(T::Types::Enum)
    raise ArgumentError.new("#{enum.inspect} is not a T.deprecated_enum")
  end

  classes = T.unsafe(enum.values).map(&:class).uniq
  if classes.empty?
    T.untyped
  elsif classes.length > 1
    T::Types::Union.new(classes)
  else
    T::Types::Simple::Private::Pool.type_for_module(classes.first)
  end
end

.methods_excluding_object(mod) ⇒ Object

Returns the set of all methods (public, protected, private) defined on a module or its ancestors, excluding Object and its ancestors. Overrides of methods from Object (and its ancestors) are included.



55
56
57
58
59
60
61
62
63
 
# File 'lib/types/utils.rb', line 55

def self.methods_excluding_object(mod)
  # We can't just do mod.instance_methods - Object.instance_methods, because that would leave out
  # any methods from Object that are overridden in mod.
  mod.ancestors.flat_map do |ancestor|
    # equivalent to checking Object.ancestors.include?(ancestor)
    next [] if Object <= ancestor
    ancestor.instance_methods(false) + ancestor.private_instance_methods(false)
  end.uniq
end

.resolve_alias(type) ⇒ Object

Return the underlying type for a type alias. Otherwise returns type.



89
90
91
92
93
94
95
96
 
# File 'lib/types/utils.rb', line 89

def self.resolve_alias(type)
  case type
  when T::Private::Types::TypeAlias
    type.aliased_type
  else
    type
  end
end

.run_all_sig_blocks(force_type_init: true) ⇒ Object

Unwraps all the sigs.



84
85
86
 
# File 'lib/types/utils.rb', line 84

def self.run_all_sig_blocks(force_type_init: true)
  T::Private::Methods.run_all_sig_blocks(force_type_init: force_type_init)
end

.signature_for_instance_method(mod, method_name) ⇒ Object

Returns the signature for the instance method on the supplied module, or nil if it’s not found or not typed.

Examples:

T::Utils.signature_for_instance_method(MyClass, :my_method)



75
76
77
 
# File 'lib/types/utils.rb', line 75

def self.signature_for_instance_method(mod, method_name)
  T::Private::Methods.signature_for_method(mod.instance_method(method_name))
end

.signature_for_method(method) ⇒ Object

Returns the signature for the ‘UnboundMethod`, or nil if it’s not sig’d

Examples:

T::Utils.signature_for_method(x.method(:foo))



68
69
70
 
# File 'lib/types/utils.rb', line 68

def self.signature_for_method(method)
  T::Private::Methods.signature_for_method(method)
end

.string_truncate_middle(str, start_len, end_len, ellipsis = '...') ⇒ String

Elide the middle of a string as needed and replace it with an ellipsis. Keep the given number of characters at the start and end of the string.

This method operates on string length, not byte length.

If the string is shorter than the requested truncation length, return it without adding an ellipsis. This method may return a longer string than the original if the characters removed are shorter than the ellipsis.

Parameters:

  • str (String)
  • start_len (Fixnum) —

    The length of string before the ellipsis

  • end_len (Fixnum) —

    The length of string after the ellipsis

  • ellipsis (String) (defaults to: '...') —

    The string to add in place of the elided text

Returns:

  • (String)

Raises:

  • (ArgumentError) 


135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
 
# File 'lib/types/utils.rb', line 135

def self.string_truncate_middle(str, start_len, end_len, ellipsis='...')
  return unless str

  raise ArgumentError.new('must provide start_len') unless start_len
  raise ArgumentError.new('must provide end_len') unless end_len

  raise ArgumentError.new('start_len must be >= 0') if start_len < 0
  raise ArgumentError.new('end_len must be >= 0') if end_len < 0

  str = str.to_s
  return str if str.length <= start_len + end_len

  start_part = str[0...start_len - ellipsis.length]
  end_part = end_len == 0 ? '' : str[-end_len..-1]

  "#{start_part}#{ellipsis}#{end_part}"
end

.unwrap_nilable(type) ⇒ Object

Give a type which is a subclass of T::Types::Base, determines if the type is a simple nilable type (union of NilClass and something else). If so, returns the T::Types::Base of the something else. Otherwise, returns nil.



100
101
102
103
104
105
106
107
 
# File 'lib/types/utils.rb', line 100

def self.unwrap_nilable(type)
  case type
  when T::Types::Union
    type.unwrap_nilable
  else
    nil
  end
end

.wrap_method_with_call_validation_if_needed(mod, method_sig, original_method) ⇒ Object 



79
80
81
 
# File 'lib/types/utils.rb', line 79

def self.wrap_method_with_call_validation_if_needed(mod, method_sig, original_method)
  T::Private::Methods::CallValidation.wrap_method_if_needed(mod, method_sig, original_method)
end