Class: Solargraph::ComplexType
- Inherits:
-
Object
- Object
- Solargraph::ComplexType
show all
- Includes:
- Equality
- Defined in:
- lib/solargraph/complex_type.rb,
lib/solargraph/complex_type/unique_type.rb,
lib/solargraph/complex_type/type_methods.rb
Overview
A container for type data based on YARD type tags.
Defined Under Namespace
Modules: TypeMethods
Classes: UniqueType
Constant Summary
collapse
- GENERIC_TAG_NAME =
'generic'.freeze
Instance Attribute Summary collapse
Class Method Summary
collapse
Instance Method Summary
collapse
Methods included from Equality
#==, #eql?, #freeze, #hash
Constructor Details
#initialize(types = [UniqueType::UNDEFINED]) ⇒ ComplexType
Returns a new instance of ComplexType.
16
17
18
19
20
21
22
23
24
25
26
|
# File 'lib/solargraph/complex_type.rb', line 16
def initialize types = [UniqueType::UNDEFINED]
items = types.flat_map(&:items).uniq(&:to_s)
if items.any? { |i| i.name == 'false' } && items.any? { |i| i.name == 'true' }
items.delete_if { |i| i.name == 'false' || i.name == 'true' }
items.unshift(ComplexType::BOOLEAN)
end
items = [UniqueType::UNDEFINED] if items.any?(&:undefined?)
@items = items
end
|
Dynamic Method Handling
This class handles dynamic methods through the method_missing method
#method_missing(name, *args, &block) ⇒ Object?
142
143
144
145
146
|
# File 'lib/solargraph/complex_type.rb', line 142
def method_missing name, *args, &block
return if @items.first.nil?
return @items.first.send(name, *args, &block) if respond_to_missing?(name)
super
end
|
Instance Attribute Details
#items ⇒ Object
Returns the value of attribute items.
262
263
264
|
# File 'lib/solargraph/complex_type.rb', line 262
def items
@items
end
|
Class Method Details
.parse(*strings, partial: false) ⇒ ComplexType
TODO:
To be able to select the right signature above, Chain::Call needs to know the decl type (:arg, :optarg, :kwarg, etc) of the arguments given, instead of just having an array of Chains as the arguments.
Note:
The ‘partial` parameter is used to indicate that the method is receiving a string that will be used inside another ComplexType. It returns arrays of ComplexTypes instead of a single cohesive one. Consumers should not need to use this parameter; it should only be used internally.
Parse type strings into a ComplexType.
# @overload parse(*strings, partial: false) # @todo Need ability to use a literal true as a type below # @param partial [Boolean] True if the string is part of a another type # @return [Array<UniqueType>] @sg-ignore
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
|
# File 'lib/solargraph/complex_type.rb', line 307
def parse *strings, partial: false
@cache ||= {}
unless partial
cached = @cache[strings]
return cached unless cached.nil?
end
types = []
key_types = nil
strings.each do |type_string|
point_stack = 0
curly_stack = 0
paren_stack = 0
base = String.new
subtype_string = String.new
type_string&.each_char do |char|
if char == '='
elsif char == '<'
point_stack += 1
elsif char == '>'
if subtype_string.end_with?('=') && curly_stack > 0
subtype_string += char
elsif base.end_with?('=')
raise ComplexTypeError, "Invalid hash thing" unless key_types.nil?
types.push UniqueType.parse(base[0..-2].strip, subtype_string)
key_types = types
types = []
base.clear
subtype_string.clear
next
else
raise ComplexTypeError, "Invalid close in type #{type_string}" if point_stack == 0
point_stack -= 1
subtype_string += char
end
next
elsif char == '{'
curly_stack += 1
elsif char == '}'
curly_stack -= 1
subtype_string += char
raise ComplexTypeError, "Invalid close in type #{type_string}" if curly_stack < 0
next
elsif char == '('
paren_stack += 1
elsif char == ')'
paren_stack -= 1
subtype_string += char
raise ComplexTypeError, "Invalid close in type #{type_string}" if paren_stack < 0
next
elsif char == ',' && point_stack == 0 && curly_stack == 0 && paren_stack == 0
types.push UniqueType.parse(base.strip, subtype_string.strip)
base.clear
subtype_string.clear
next
end
if point_stack == 0 && curly_stack == 0 && paren_stack == 0
base.concat char
else
subtype_string.concat char
end
end
raise ComplexTypeError, "Unclosed subtype in #{type_string}" if point_stack != 0 || curly_stack != 0 || paren_stack != 0
types.push UniqueType.parse(base.strip, subtype_string.strip)
end
unless key_types.nil?
raise ComplexTypeError, "Invalid use of key/value parameters" unless partial
return key_types if types.empty?
return [key_types, types]
end
result = partial ? types : ComplexType.new(types)
@cache[strings] = result unless partial
result
end
|
.try_parse(*strings) ⇒ ComplexType
391
392
393
394
395
396
|
# File 'lib/solargraph/complex_type.rb', line 391
def try_parse *strings
parse *strings
rescue ComplexTypeError => e
Solargraph.logger.info "Error parsing complex type `#{strings.join(', ')}`: #{e.message}"
ComplexType::UNDEFINED
end
|
Instance Method Details
120
121
122
|
# File 'lib/solargraph/complex_type.rb', line 120
def [](index)
@items[index]
end
|
#all? {|| ... } ⇒ Boolean
184
185
186
|
# File 'lib/solargraph/complex_type.rb', line 184
def all? &block
@items.all? &block
end
|
236
237
238
|
# File 'lib/solargraph/complex_type.rb', line 236
def all_params
@items.first.all_params || []
end
|
#all_rooted? ⇒ Boolean
every type and subtype in this union have been resolved to be fully qualified
252
253
254
|
# File 'lib/solargraph/complex_type.rb', line 252
def all_rooted?
all?(&:all_rooted?)
end
|
#any? {|| ... } ⇒ Boolean
191
192
193
|
# File 'lib/solargraph/complex_type.rb', line 191
def any? &block
@items.compact.any? &block
end
|
#can_assign?(api_map, atype) ⇒ Boolean
104
105
106
|
# File 'lib/solargraph/complex_type.rb', line 104
def can_assign?(api_map, atype)
any? { |ut| ut.can_assign?(api_map, atype) }
end
|
#desc ⇒ Object
175
176
177
|
# File 'lib/solargraph/complex_type.rb', line 175
def desc
rooted_tags
end
|
#downcast_to_literal_if_possible ⇒ ComplexType
171
172
173
|
# File 'lib/solargraph/complex_type.rb', line 171
def downcast_to_literal_if_possible
ComplexType.new(items.map(&:downcast_to_literal_if_possible))
end
|
#each {|| ... } ⇒ Enumerable<UniqueType>
86
87
88
|
# File 'lib/solargraph/complex_type.rb', line 86
def each &block
@items.each &block
end
|
#each_unique_type ⇒ Enumerator<UniqueType>
This method returns an undefined value.
94
95
96
97
98
99
100
|
# File 'lib/solargraph/complex_type.rb', line 94
def each_unique_type &block
return enum_for(__method__) unless block_given?
@items.each do |item|
item.each_unique_type &block
end
end
|
57
58
59
|
# File 'lib/solargraph/complex_type.rb', line 57
def first
@items.first
end
|
#force_rooted ⇒ self
217
218
219
220
221
|
# File 'lib/solargraph/complex_type.rb', line 217
def force_rooted
transform do |t|
t.recreate(make_rooted: true)
end
end
|
#generic? ⇒ Boolean
199
200
201
|
# File 'lib/solargraph/complex_type.rb', line 199
def generic?
any?(&:generic?)
end
|
#length ⇒ Integer
109
110
111
|
# File 'lib/solargraph/complex_type.rb', line 109
def length
@items.length
end
|
#literal? ⇒ Boolean
166
167
168
|
# File 'lib/solargraph/complex_type.rb', line 166
def literal?
@items.any?(&:literal?)
end
|
#map {|| ... } ⇒ Array<UniqueType>
80
81
82
|
# File 'lib/solargraph/complex_type.rb', line 80
def map &block
@items.map &block
end
|
#namespace ⇒ String
130
131
132
133
|
# File 'lib/solargraph/complex_type.rb', line 130
def namespace
@namespace ||= method_missing(:namespace).to_s
end
|
#namespaces ⇒ Array<String>
136
137
138
|
# File 'lib/solargraph/complex_type.rb', line 136
def namespaces
@items.map(&:namespace)
end
|
#nullable? ⇒ Boolean
231
232
233
|
# File 'lib/solargraph/complex_type.rb', line 231
def nullable?
@items.any?(&:nil_type?)
end
|
#qualify(api_map, context = '') ⇒ ComplexType
36
37
38
39
40
41
42
43
44
|
# File 'lib/solargraph/complex_type.rb', line 36
def qualify api_map, context = ''
red = reduce_object
types = red.items.map do |t|
next t if ['nil', 'void', 'undefined'].include?(t.name)
next t if ['::Boolean'].include?(t.rooted_name)
t.qualify api_map, context
end
ComplexType.new(types).reduce_object
end
|
241
242
243
244
245
246
247
248
|
# File 'lib/solargraph/complex_type.rb', line 241
def reduce_class_type
new_items = items.flat_map do |type|
next type unless ['Module', 'Class'].include?(type.name)
type.all_params
end
ComplexType.new(new_items)
end
|
#resolve_generics(definitions, context_type) ⇒ ComplexType
226
227
228
229
|
# File 'lib/solargraph/complex_type.rb', line 226
def resolve_generics definitions, context_type
result = @items.map { |i| i.resolve_generics(definitions, context_type) }
ComplexType.new(result)
end
|
#resolve_generics_from_context(generics_to_resolve, context_type, resolved_generic_values: {}) ⇒ self
50
51
52
53
54
|
# File 'lib/solargraph/complex_type.rb', line 50
def resolve_generics_from_context generics_to_resolve, context_type, resolved_generic_values: {}
return self unless generic?
ComplexType.new(@items.map { |i| i.resolve_generics_from_context(generics_to_resolve, context_type, resolved_generic_values: resolved_generic_values) })
end
|
#respond_to_missing?(name, include_private = false) ⇒ Boolean
150
151
152
|
# File 'lib/solargraph/complex_type.rb', line 150
def respond_to_missing?(name, include_private = false)
TypeMethods.public_instance_methods.include?(name) || super
end
|
#rooted? ⇒ Boolean
every top-level type has resolved to be fully qualified; see #all_rooted? to check their subtypes as well
258
259
260
|
# File 'lib/solargraph/complex_type.rb', line 258
def rooted?
all?(&:rooted?)
end
|
179
180
181
|
# File 'lib/solargraph/complex_type.rb', line 179
def rooted_tags
map(&:rooted_tag).join(', ')
end
|
#select(&block) ⇒ Array<UniqueType>
125
126
127
|
# File 'lib/solargraph/complex_type.rb', line 125
def select &block
@items.select &block
end
|
70
71
72
73
74
75
76
|
# File 'lib/solargraph/complex_type.rb', line 70
def self_to_type dst
object_type_dst = dst.reduce_class_type
transform do |t|
next t if t.name != 'self'
object_type_dst
end
end
|
#selfy? ⇒ Boolean
195
196
197
|
# File 'lib/solargraph/complex_type.rb', line 195
def selfy?
@items.any?(&:selfy?)
end
|
162
163
164
|
# File 'lib/solargraph/complex_type.rb', line 162
def simple_tags
simplify_literals.tags
end
|
#simplify_literals ⇒ Object
203
204
205
|
# File 'lib/solargraph/complex_type.rb', line 203
def simplify_literals
ComplexType.new(map(&:simplify_literals))
end
|
158
159
160
|
# File 'lib/solargraph/complex_type.rb', line 158
def tags
map(&:tag).join(', ')
end
|
114
115
116
|
# File 'lib/solargraph/complex_type.rb', line 114
def to_a
@items
end
|
#to_rbs ⇒ String
62
63
64
65
66
|
# File 'lib/solargraph/complex_type.rb', line 62
def to_rbs
((@items.length > 1 ? '(' : '') +
@items.map(&:to_rbs).join(' | ') +
(@items.length > 1 ? ')' : ''))
end
|
#to_s ⇒ Object
154
155
156
|
# File 'lib/solargraph/complex_type.rb', line 154
def to_s
map(&:tag).join(', ')
end
|
211
212
213
214
|
# File 'lib/solargraph/complex_type.rb', line 211
def transform(new_name = nil, &transform_type)
raise "Please remove leading :: and set rooted with recreate() instead - #{new_name}" if new_name&.start_with?('::')
ComplexType.new(map { |ut| ut.transform(new_name, &transform_type) })
end
|