guard-srb 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (60) hide show
  1. checksums.yaml +7 -0
  2. data/.rubocop.yml +37 -0
  3. data/.tool-versions +1 -0
  4. data/CHANGELOG.md +5 -0
  5. data/CODE_OF_CONDUCT.md +84 -0
  6. data/Gemfile +14 -0
  7. data/Gemfile.lock +125 -0
  8. data/Guardfile +16 -0
  9. data/LICENSE.txt +21 -0
  10. data/README.md +92 -0
  11. data/Rakefile +18 -0
  12. data/lib/guard/srb/runner.rb +70 -0
  13. data/lib/guard/srb/templates/Guardfile +3 -0
  14. data/lib/guard/srb/version.rb +8 -0
  15. data/lib/guard/srb.rb +105 -0
  16. data/sorbet/config +5 -0
  17. data/sorbet/rbi/annotations/rainbow.rbi +269 -0
  18. data/sorbet/rbi/gems/ast@2.4.2.rbi +584 -0
  19. data/sorbet/rbi/gems/coderay@1.1.3.rbi +3437 -0
  20. data/sorbet/rbi/gems/diff-lcs@1.5.0.rbi +1079 -0
  21. data/sorbet/rbi/gems/ffi@1.15.5.rbi +8 -0
  22. data/sorbet/rbi/gems/formatador@1.1.0.rbi +8 -0
  23. data/sorbet/rbi/gems/guard-compat@1.2.1.rbi +103 -0
  24. data/sorbet/rbi/gems/guard-minitest@2.4.6.rbi +299 -0
  25. data/sorbet/rbi/gems/guard@2.16.2.rbi +2286 -0
  26. data/sorbet/rbi/gems/json@2.6.3.rbi +1541 -0
  27. data/sorbet/rbi/gems/listen@3.8.0.rbi +1181 -0
  28. data/sorbet/rbi/gems/lumberjack@1.2.8.rbi +1501 -0
  29. data/sorbet/rbi/gems/method_source@1.0.0.rbi +272 -0
  30. data/sorbet/rbi/gems/minitest@5.18.0.rbi +2354 -0
  31. data/sorbet/rbi/gems/mocha@2.0.2.rbi +3934 -0
  32. data/sorbet/rbi/gems/nenv@0.3.0.rbi +146 -0
  33. data/sorbet/rbi/gems/netrc@0.11.0.rbi +161 -0
  34. data/sorbet/rbi/gems/notiffany@0.1.3.rbi +1078 -0
  35. data/sorbet/rbi/gems/parallel@1.23.0.rbi +273 -0
  36. data/sorbet/rbi/gems/parser@3.2.2.1.rbi +9454 -0
  37. data/sorbet/rbi/gems/pry@0.14.2.rbi +10079 -0
  38. data/sorbet/rbi/gems/rainbow@3.1.1.rbi +402 -0
  39. data/sorbet/rbi/gems/rake@13.0.6.rbi +3119 -0
  40. data/sorbet/rbi/gems/rb-fsevent@0.11.2.rbi +8 -0
  41. data/sorbet/rbi/gems/rb-inotify@0.10.1.rbi +8 -0
  42. data/sorbet/rbi/gems/rbi@0.0.16.rbi +3049 -0
  43. data/sorbet/rbi/gems/regexp_parser@2.8.0.rbi +3765 -0
  44. data/sorbet/rbi/gems/rexml@3.2.5.rbi +4717 -0
  45. data/sorbet/rbi/gems/rubocop-ast@1.28.1.rbi +6967 -0
  46. data/sorbet/rbi/gems/rubocop@1.50.2.rbi +55367 -0
  47. data/sorbet/rbi/gems/ruby-progressbar@1.13.0.rbi +1317 -0
  48. data/sorbet/rbi/gems/ruby2_keywords@0.0.5.rbi +8 -0
  49. data/sorbet/rbi/gems/shellany@0.0.1.rbi +101 -0
  50. data/sorbet/rbi/gems/spoom@1.2.1.rbi +2536 -0
  51. data/sorbet/rbi/gems/tapioca@0.11.6.rbi +3246 -0
  52. data/sorbet/rbi/gems/thor@1.2.2.rbi +3965 -0
  53. data/sorbet/rbi/gems/unicode-display_width@2.4.2.rbi +65 -0
  54. data/sorbet/rbi/gems/unparser@0.6.7.rbi +4515 -0
  55. data/sorbet/rbi/gems/yard-sorbet@0.8.1.rbi +426 -0
  56. data/sorbet/rbi/gems/yard@0.9.34.rbi +17907 -0
  57. data/sorbet/rbi/todo.rbi +7 -0
  58. data/sorbet/tapioca/config.yml +13 -0
  59. data/sorbet/tapioca/require.rb +14 -0
  60. metadata +155 -0
@@ -0,0 +1,426 @@
1
+ # typed: true
2
+
3
+ # DO NOT EDIT MANUALLY
4
+ # This is an autogenerated file for types exported from the `yard-sorbet` gem.
5
+ # Please instead update this file by running `bin/tapioca gem yard-sorbet`.
6
+
7
+ class YARD::Handlers::Ruby::ClassHandler < ::YARD::Handlers::Ruby::Base
8
+ include ::YARDSorbet::Handlers::StructClassHandler
9
+ end
10
+
11
+ # source://yard-sorbet//lib/yard-sorbet/version.rb#5
12
+ module YARDSorbet; end
13
+
14
+ # Extract & re-add directives to a docstring
15
+ #
16
+ # source://yard-sorbet//lib/yard-sorbet/directives.rb#6
17
+ module YARDSorbet::Directives
18
+ class << self
19
+ # source://yard-sorbet//lib/yard-sorbet/directives.rb#21
20
+ sig { params(docstring: ::String, directives: T::Array[::String]).void }
21
+ def add_directives(docstring, directives); end
22
+
23
+ # source://yard-sorbet//lib/yard-sorbet/directives.rb#10
24
+ sig { params(docstring: T.nilable(::String)).returns([::YARD::Docstring, T::Array[::String]]) }
25
+ def extract_directives(docstring); end
26
+ end
27
+ end
28
+
29
+ # Custom YARD Handlers
30
+ #
31
+ # @see https://rubydoc.info/gems/yard/YARD/Handlers/Base YARD Base Handler documentation
32
+ #
33
+ # source://yard-sorbet//lib/yard-sorbet/handlers.rb#7
34
+ module YARDSorbet::Handlers; end
35
+
36
+ # Apllies an `@abstract` tag to `abstract!`/`interface!` modules (if not alerady present).
37
+ #
38
+ # source://yard-sorbet//lib/yard-sorbet/handlers/abstract_dsl_handler.rb#7
39
+ class YARDSorbet::Handlers::AbstractDSLHandler < ::YARD::Handlers::Ruby::Base
40
+ # source://yard-sorbet//lib/yard-sorbet/handlers/abstract_dsl_handler.rb#21
41
+ sig { void }
42
+ def process; end
43
+ end
44
+
45
+ # Extra text for class namespaces
46
+ #
47
+ # source://yard-sorbet//lib/yard-sorbet/handlers/abstract_dsl_handler.rb#18
48
+ YARDSorbet::Handlers::AbstractDSLHandler::CLASS_TAG_TEXT = T.let(T.unsafe(nil), String)
49
+
50
+ # The text accompanying the `@abstract` tag.
51
+ #
52
+ # @see https://github.com/lsegal/yard/blob/main/templates/default/docstring/html/abstract.erb The `@abstract` tag template
53
+ #
54
+ # source://yard-sorbet//lib/yard-sorbet/handlers/abstract_dsl_handler.rb#16
55
+ YARDSorbet::Handlers::AbstractDSLHandler::TAG_TEXT = T.let(T.unsafe(nil), String)
56
+
57
+ # Handle `enums` calls, registering enum values as constants
58
+ #
59
+ # source://yard-sorbet//lib/yard-sorbet/handlers/enums_handler.rb#7
60
+ class YARDSorbet::Handlers::EnumsHandler < ::YARD::Handlers::Ruby::Base
61
+ # source://yard-sorbet//lib/yard-sorbet/handlers/enums_handler.rb#14
62
+ sig { void }
63
+ def process; end
64
+
65
+ private
66
+
67
+ # source://yard-sorbet//lib/yard-sorbet/handlers/enums_handler.rb#29
68
+ sig { params(node: ::YARD::Parser::Ruby::AstNode).returns(T::Boolean) }
69
+ def const_assign_node?(node); end
70
+ end
71
+
72
+ # Extends any modules included via `mixes_in_class_methods`
73
+ #
74
+ # @see https://sorbet.org/docs/abstract#interfaces-and-the-included-hook Sorbet `mixes_in_class_methods` documentation
75
+ #
76
+ # source://yard-sorbet//lib/yard-sorbet/handlers/include_handler.rb#9
77
+ class YARDSorbet::Handlers::IncludeHandler < ::YARD::Handlers::Ruby::Base
78
+ # source://yard-sorbet//lib/yard-sorbet/handlers/include_handler.rb#16
79
+ sig { void }
80
+ def process; end
81
+
82
+ private
83
+
84
+ # source://yard-sorbet//lib/yard-sorbet/handlers/include_handler.rb#28
85
+ sig { returns(::YARD::CodeObjects::NamespaceObject) }
86
+ def included_in; end
87
+ end
88
+
89
+ # Tracks modules that invoke `mixes_in_class_methods` for use in {IncludeHandler}
90
+ #
91
+ # @see https://sorbet.org/docs/abstract#interfaces-and-the-included-hook Sorbet `mixes_in_class_methods` documentation
92
+ #
93
+ # source://yard-sorbet//lib/yard-sorbet/handlers/mixes_in_class_methods_handler.rb#9
94
+ class YARDSorbet::Handlers::MixesInClassMethodsHandler < ::YARD::Handlers::Ruby::Base
95
+ # source://yard-sorbet//lib/yard-sorbet/handlers/mixes_in_class_methods_handler.rb#23
96
+ sig { void }
97
+ def process; end
98
+
99
+ class << self
100
+ # source://yard-sorbet//lib/yard-sorbet/handlers/mixes_in_class_methods_handler.rb#18
101
+ sig { params(code_obj: ::String).returns(T.nilable(T::Array[::String])) }
102
+ def mixed_in_class_methods(code_obj); end
103
+ end
104
+ end
105
+
106
+ # A YARD Handler for Sorbet type declarations
107
+ #
108
+ # source://yard-sorbet//lib/yard-sorbet/handlers/sig_handler.rb#7
109
+ class YARDSorbet::Handlers::SigHandler < ::YARD::Handlers::Ruby::Base
110
+ # Swap the method definition docstring and the sig docstring.
111
+ # Parse relevant parts of the `sig` and include them as well.
112
+ #
113
+ # source://yard-sorbet//lib/yard-sorbet/handlers/sig_handler.rb#24
114
+ sig { void }
115
+ def process; end
116
+
117
+ private
118
+
119
+ # source://yard-sorbet//lib/yard-sorbet/handlers/sig_handler.rb#73
120
+ sig { params(method_objects: T::Array[::YARD::CodeObjects::MethodObject]).void }
121
+ def document_attr_methods(method_objects); end
122
+
123
+ # An attr* sig can be merged into a previous attr* docstring if it is the only parameter passed to the attr*
124
+ # declaration. This is to avoid needing to rewrite the source code to separate merged and unmerged attr*
125
+ # declarations.
126
+ #
127
+ # source://yard-sorbet//lib/yard-sorbet/handlers/sig_handler.rb#60
128
+ sig { params(attr_node: ::YARD::Parser::Ruby::MethodCallNode).returns(T::Boolean) }
129
+ def merged_into_attr?(attr_node); end
130
+
131
+ # source://yard-sorbet//lib/yard-sorbet/handlers/sig_handler.rb#78
132
+ sig do
133
+ params(
134
+ attach_to: T.any(::YARD::CodeObjects::MethodObject, ::YARD::Parser::Ruby::MethodCallNode, ::YARD::Parser::Ruby::MethodDefinitionNode),
135
+ docstring: T.nilable(::String),
136
+ include_params: T::Boolean
137
+ ).void
138
+ end
139
+ def parse_node(attach_to, docstring, include_params: T.unsafe(nil)); end
140
+
141
+ # source://yard-sorbet//lib/yard-sorbet/handlers/sig_handler.rb#99
142
+ sig { params(node: ::YARD::Parser::Ruby::AstNode, docstring: ::YARD::Docstring).void }
143
+ def parse_params(node, docstring); end
144
+
145
+ # source://yard-sorbet//lib/yard-sorbet/handlers/sig_handler.rb#109
146
+ sig { params(node: ::YARD::Parser::Ruby::AstNode, docstring: ::YARD::Docstring).void }
147
+ def parse_return(node, docstring); end
148
+
149
+ # source://yard-sorbet//lib/yard-sorbet/handlers/sig_handler.rb#87
150
+ sig { params(docstring: ::YARD::Docstring, include_params: T::Boolean).void }
151
+ def parse_sig(docstring, include_params: T.unsafe(nil)); end
152
+
153
+ # source://yard-sorbet//lib/yard-sorbet/handlers/sig_handler.rb#50
154
+ sig { params(attr_node: ::YARD::Parser::Ruby::MethodCallNode).void }
155
+ def process_attr(attr_node); end
156
+
157
+ # source://yard-sorbet//lib/yard-sorbet/handlers/sig_handler.rb#36
158
+ sig { params(def_node: ::YARD::Parser::Ruby::MethodDefinitionNode).void }
159
+ def process_def(def_node); end
160
+ end
161
+
162
+ # YARD types that can have docstrings attached to them
163
+ #
164
+ # source://yard-sorbet//lib/yard-sorbet/handlers/sig_handler.rb#14
165
+ YARDSorbet::Handlers::SigHandler::Documentable = T.type_alias { T.any(::YARD::CodeObjects::MethodObject, ::YARD::Parser::Ruby::MethodCallNode, ::YARD::Parser::Ruby::MethodDefinitionNode) }
166
+
167
+ # Class-level handler that folds all `const` and `prop` declarations into the constructor documentation
168
+ # this needs to be injected as a module otherwise the default Class handler will overwrite documentation
169
+ #
170
+ # @note this module is included in `YARD::Handlers::Ruby::ClassHandler`
171
+ #
172
+ # source://yard-sorbet//lib/yard-sorbet/handlers/struct_class_handler.rb#10
173
+ module YARDSorbet::Handlers::StructClassHandler
174
+ # source://yard-sorbet//lib/yard-sorbet/handlers/struct_class_handler.rb#14
175
+ sig { void }
176
+ def process; end
177
+
178
+ private
179
+
180
+ # source://yard-sorbet//lib/yard-sorbet/handlers/struct_class_handler.rb#50
181
+ sig do
182
+ params(
183
+ object: ::YARD::CodeObjects::MethodObject,
184
+ props: T::Array[::YARDSorbet::TStructProp],
185
+ docstring: ::YARD::Docstring,
186
+ directives: T::Array[::String]
187
+ ).void
188
+ end
189
+ def decorate_t_struct_init(object, props, docstring, directives); end
190
+
191
+ # Create a virtual `initialize` method with all the `prop`/`const` arguments
192
+ #
193
+ # source://yard-sorbet//lib/yard-sorbet/handlers/struct_class_handler.rb#30
194
+ sig { params(props: T::Array[::YARDSorbet::TStructProp], class_ns: ::YARD::CodeObjects::ClassObject).void }
195
+ def process_t_struct_props(props, class_ns); end
196
+
197
+ # source://yard-sorbet//lib/yard-sorbet/handlers/struct_class_handler.rb#60
198
+ sig { params(props: T::Array[::YARDSorbet::TStructProp]).returns(T::Array[[::String, T.nilable(::String)]]) }
199
+ def to_object_parameters(props); end
200
+ end
201
+
202
+ # Handles all `const`/`prop` calls, creating accessor methods, and compiles them for later usage at the class level
203
+ # in creating a constructor
204
+ #
205
+ # source://yard-sorbet//lib/yard-sorbet/handlers/struct_prop_handler.rb#8
206
+ class YARDSorbet::Handlers::StructPropHandler < ::YARD::Handlers::Ruby::Base
207
+ # source://yard-sorbet//lib/yard-sorbet/handlers/struct_prop_handler.rb#15
208
+ sig { void }
209
+ def process; end
210
+
211
+ private
212
+
213
+ # Add the source and docstring to the method object
214
+ #
215
+ # source://yard-sorbet//lib/yard-sorbet/handlers/struct_prop_handler.rb#28
216
+ sig { params(object: ::YARD::CodeObjects::MethodObject, prop: ::YARDSorbet::TStructProp).void }
217
+ def decorate_object(object, prop); end
218
+
219
+ # source://yard-sorbet//lib/yard-sorbet/handlers/struct_prop_handler.rb#38
220
+ sig { returns(T::Boolean) }
221
+ def immutable?; end
222
+
223
+ # source://yard-sorbet//lib/yard-sorbet/handlers/struct_prop_handler.rb#44
224
+ sig { params(kwd: ::String).returns(T.nilable(::String)) }
225
+ def kw_arg(kwd); end
226
+
227
+ # source://yard-sorbet//lib/yard-sorbet/handlers/struct_prop_handler.rb#49
228
+ sig { params(name: ::String).returns(::YARDSorbet::TStructProp) }
229
+ def make_prop(name); end
230
+
231
+ # source://yard-sorbet//lib/yard-sorbet/handlers/struct_prop_handler.rb#60
232
+ sig { returns(T::Array[::YARD::Parser::Ruby::AstNode]) }
233
+ def params; end
234
+
235
+ # Register the field explicitly as an attribute.
236
+ #
237
+ # source://yard-sorbet//lib/yard-sorbet/handlers/struct_prop_handler.rb#66
238
+ sig { params(object: ::YARD::CodeObjects::MethodObject, name: ::String).void }
239
+ def register_attrs(object, name); end
240
+
241
+ # Store the prop for use in the constructor definition
242
+ #
243
+ # source://yard-sorbet//lib/yard-sorbet/handlers/struct_prop_handler.rb#74
244
+ sig { params(prop: ::YARDSorbet::TStructProp).void }
245
+ def update_state(prop); end
246
+ end
247
+
248
+ # Helper methods for working with `YARD` AST Nodes
249
+ #
250
+ # source://yard-sorbet//lib/yard-sorbet/node_utils.rb#6
251
+ module YARDSorbet::NodeUtils
252
+ class << self
253
+ # Traverse AST nodes in breadth-first order
254
+ #
255
+ # @note This will skip over some node types.
256
+ # @yield [YARD::Parser::Ruby::AstNode]
257
+ #
258
+ # source://yard-sorbet//lib/yard-sorbet/node_utils.rb#21
259
+ sig do
260
+ params(
261
+ node: ::YARD::Parser::Ruby::AstNode,
262
+ _blk: T.proc.params(n: ::YARD::Parser::Ruby::AstNode).void
263
+ ).void
264
+ end
265
+ def bfs_traverse(node, &_blk); end
266
+
267
+ # source://yard-sorbet//lib/yard-sorbet/node_utils.rb#32
268
+ sig { params(node: ::YARD::Parser::Ruby::AstNode).void }
269
+ def delete_node(node); end
270
+
271
+ # Gets the node that a sorbet `sig` can be attached do, bypassing visisbility modifiers and the like
272
+ #
273
+ # source://yard-sorbet//lib/yard-sorbet/node_utils.rb#38
274
+ sig do
275
+ params(
276
+ node: ::YARD::Parser::Ruby::AstNode
277
+ ).returns(T.any(::YARD::Parser::Ruby::MethodCallNode, ::YARD::Parser::Ruby::MethodDefinitionNode))
278
+ end
279
+ def get_method_node(node); end
280
+
281
+ # Find and return the adjacent node (ascending)
282
+ #
283
+ # @raise [IndexError] if the node does not have an adjacent sibling (ascending)
284
+ #
285
+ # source://yard-sorbet//lib/yard-sorbet/node_utils.rb#45
286
+ sig { params(node: ::YARD::Parser::Ruby::AstNode).returns(::YARD::Parser::Ruby::AstNode) }
287
+ def sibling_node(node); end
288
+
289
+ # source://yard-sorbet//lib/yard-sorbet/node_utils.rb#52
290
+ sig { params(node: ::YARD::Parser::Ruby::AstNode).returns(T::Boolean) }
291
+ def sigable_node?(node); end
292
+
293
+ # @see https://github.com/lsegal/yard/blob/main/lib/yard/handlers/ruby/attribute_handler.rb YARD::Handlers::Ruby::AttributeHandler.validated_attribute_names
294
+ #
295
+ # source://yard-sorbet//lib/yard-sorbet/node_utils.rb#63
296
+ sig { params(attr_node: ::YARD::Parser::Ruby::MethodCallNode).returns(T::Array[::String]) }
297
+ def validated_attribute_names(attr_node); end
298
+ end
299
+ end
300
+
301
+ # Command node types that can have type signatures
302
+ #
303
+ # source://yard-sorbet//lib/yard-sorbet/node_utils.rb#10
304
+ YARDSorbet::NodeUtils::ATTRIBUTE_METHODS = T.let(T.unsafe(nil), Array)
305
+
306
+ # Skip these method contents during BFS node traversal, they can have their own nested types via `T.Proc`
307
+ #
308
+ # source://yard-sorbet//lib/yard-sorbet/node_utils.rb#12
309
+ YARDSorbet::NodeUtils::SKIP_METHOD_CONTENTS = T.let(T.unsafe(nil), Array)
310
+
311
+ # Node types that can have type signatures
312
+ #
313
+ # source://yard-sorbet//lib/yard-sorbet/node_utils.rb#14
314
+ YARDSorbet::NodeUtils::SigableNode = T.type_alias { T.any(::YARD::Parser::Ruby::MethodCallNode, ::YARD::Parser::Ruby::MethodDefinitionNode) }
315
+
316
+ # Translate `sig` type syntax to `YARD` type syntax.
317
+ #
318
+ # source://yard-sorbet//lib/yard-sorbet/sig_to_yard.rb#6
319
+ module YARDSorbet::SigToYARD
320
+ class << self
321
+ # @see https://yardoc.org/types.html
322
+ #
323
+ # source://yard-sorbet//lib/yard-sorbet/sig_to_yard.rb#23
324
+ sig { params(node: ::YARD::Parser::Ruby::AstNode).returns(T::Array[::String]) }
325
+ def convert(node); end
326
+
327
+ private
328
+
329
+ # source://yard-sorbet//lib/yard-sorbet/sig_to_yard.rb#61
330
+ sig { params(node: ::YARD::Parser::Ruby::AstNode).returns(::String) }
331
+ def build_generic_type(node); end
332
+
333
+ # source://yard-sorbet//lib/yard-sorbet/sig_to_yard.rb#70
334
+ sig { params(node: ::YARD::Parser::Ruby::AstNode).returns(T::Array[::String]) }
335
+ def convert_aref(node); end
336
+
337
+ # source://yard-sorbet//lib/yard-sorbet/sig_to_yard.rb#82
338
+ sig { params(node: ::YARD::Parser::Ruby::AstNode).returns([::String]) }
339
+ def convert_array(node); end
340
+
341
+ # source://yard-sorbet//lib/yard-sorbet/sig_to_yard.rb#90
342
+ sig { params(node: ::YARD::Parser::Ruby::AstNode).returns([::String]) }
343
+ def convert_collection(node); end
344
+
345
+ # source://yard-sorbet//lib/yard-sorbet/sig_to_yard.rb#97
346
+ sig { params(node: ::YARD::Parser::Ruby::AstNode).returns([::String]) }
347
+ def convert_hash(node); end
348
+
349
+ # source://yard-sorbet//lib/yard-sorbet/sig_to_yard.rb#105
350
+ sig { params(node: ::YARD::Parser::Ruby::AstNode).returns(T::Array[::String]) }
351
+ def convert_list(node); end
352
+
353
+ # source://yard-sorbet//lib/yard-sorbet/sig_to_yard.rb#31
354
+ sig { params(node: ::YARD::Parser::Ruby::AstNode).returns(T::Array[::String]) }
355
+ def convert_node(node); end
356
+
357
+ # source://yard-sorbet//lib/yard-sorbet/sig_to_yard.rb#43
358
+ sig { params(node: ::YARD::Parser::Ruby::AstNode).returns(T::Array[::String]) }
359
+ def convert_node_type(node); end
360
+
361
+ # source://yard-sorbet//lib/yard-sorbet/sig_to_yard.rb#110
362
+ sig { params(node: ::YARD::Parser::Ruby::MethodCallNode).returns(T::Array[::String]) }
363
+ def convert_t_method(node); end
364
+
365
+ # source://yard-sorbet//lib/yard-sorbet/sig_to_yard.rb#121
366
+ sig { params(node: ::YARD::Parser::Ruby::AstNode).returns([::String]) }
367
+ def convert_unknown(node); end
368
+ end
369
+ end
370
+
371
+ # Used to store the details of a `T::Struct` `prop` definition
372
+ #
373
+ # source://yard-sorbet//lib/yard-sorbet/t_struct_prop.rb#6
374
+ class YARDSorbet::TStructProp < ::T::Struct
375
+ const :default, T.nilable(::String)
376
+ const :doc, ::String
377
+ const :prop_name, ::String
378
+ const :source, ::String
379
+ const :types, T::Array[::String]
380
+
381
+ class << self
382
+ # source://sorbet-runtime/0.5.10827/lib/types/struct.rb#13
383
+ def inherited(s); end
384
+ end
385
+ end
386
+
387
+ # Helper methods for working with `YARD` tags
388
+ #
389
+ # source://yard-sorbet//lib/yard-sorbet/tag_utils.rb#6
390
+ module YARDSorbet::TagUtils
391
+ class << self
392
+ # source://yard-sorbet//lib/yard-sorbet/tag_utils.rb#16
393
+ sig do
394
+ params(
395
+ docstring: ::YARD::Docstring,
396
+ tag_name: ::String,
397
+ name: T.nilable(::String)
398
+ ).returns(T.nilable(::YARD::Tags::Tag))
399
+ end
400
+ def find_tag(docstring, tag_name, name); end
401
+
402
+ # Create or update a `YARD` tag with type information
403
+ #
404
+ # source://yard-sorbet//lib/yard-sorbet/tag_utils.rb#30
405
+ sig do
406
+ params(
407
+ docstring: ::YARD::Docstring,
408
+ tag_name: ::String,
409
+ types: T.nilable(T::Array[::String]),
410
+ name: T.nilable(::String),
411
+ text: ::String
412
+ ).void
413
+ end
414
+ def upsert_tag(docstring, tag_name, types = T.unsafe(nil), name = T.unsafe(nil), text = T.unsafe(nil)); end
415
+ end
416
+ end
417
+
418
+ # The `void` return type, as a constant to reduce array allocations
419
+ #
420
+ # source://yard-sorbet//lib/yard-sorbet/tag_utils.rb#10
421
+ YARDSorbet::TagUtils::VOID_RETURN_TYPE = T.let(T.unsafe(nil), Array)
422
+
423
+ # {https://rubygems.org/gems/yard-sorbet Version history}
424
+ #
425
+ # source://yard-sorbet//lib/yard-sorbet/version.rb#7
426
+ YARDSorbet::VERSION = T.let(T.unsafe(nil), String)