dry-monads-sorbet 1.1.6 → 1.1.7

Sign up to get free protection for your applications and to get access to all the features.
Files changed (111) hide show
  1. checksums.yaml +4 -4
  2. data/.github/workflows/ci.yml +14 -22
  3. data/.gitignore +3 -1
  4. data/CHANGELOG.md +4 -0
  5. data/Gemfile +1 -6
  6. data/bin/tapioca +29 -0
  7. data/dry-monads-sorbet.gemspec +3 -2
  8. data/lib/bundled_rbi/dry-monads.rbi +3 -3
  9. data/lib/dry/monads/sorbet/version.rb +1 -1
  10. data/nix/sources.json +14 -0
  11. data/nix/sources.nix +174 -0
  12. data/run_ci.sh +7 -0
  13. data/shell.nix +20 -0
  14. data/sorbet/config +6 -0
  15. data/sorbet/rbi/gems/{ast.rbi → ast@2.4.2.rbi} +28 -22
  16. data/sorbet/rbi/gems/byebug@11.1.3.rbi +1568 -0
  17. data/sorbet/rbi/gems/coderay@1.1.3.rbi +1005 -0
  18. data/sorbet/rbi/gems/concurrent-ruby@1.1.9.rbi +915 -0
  19. data/sorbet/rbi/gems/diff-lcs@1.4.4.rbi +8 -0
  20. data/sorbet/rbi/gems/docile@1.4.0.rbi +54 -0
  21. data/sorbet/rbi/gems/dry-core@0.7.1.rbi +92 -0
  22. data/sorbet/rbi/gems/dry-equalizer@0.3.0.rbi +28 -0
  23. data/sorbet/rbi/gems/dry-monads@1.4.0.rbi +697 -0
  24. data/sorbet/rbi/gems/ffaker@2.20.0.rbi +3171 -0
  25. data/sorbet/rbi/gems/method_source@1.0.0.rbi +72 -0
  26. data/sorbet/rbi/gems/parallel@1.21.0.rbi +113 -0
  27. data/sorbet/rbi/gems/parser@3.0.2.0.rbi +1189 -0
  28. data/sorbet/rbi/gems/pry-byebug@3.8.0.rbi +458 -0
  29. data/sorbet/rbi/gems/{pry.rbi → pry@0.14.1.rbi} +2264 -1727
  30. data/sorbet/rbi/gems/{rainbow.rbi → rainbow@3.0.0.rbi} +90 -55
  31. data/sorbet/rbi/gems/{rake.rbi → rake@13.0.6.rbi} +578 -431
  32. data/sorbet/rbi/gems/rb-fsevent@0.11.0.rbi +8 -0
  33. data/sorbet/rbi/gems/rb-readline@0.5.5.rbi +884 -0
  34. data/sorbet/rbi/gems/rbi@0.0.6.rbi +1405 -0
  35. data/sorbet/rbi/gems/regexp_parser@2.1.1.rbi +1120 -0
  36. data/sorbet/rbi/gems/{rexml.rbi → rexml@3.2.5.rbi} +564 -497
  37. data/sorbet/rbi/gems/{rspec-core.rbi → rspec-core@3.10.1.rbi} +2345 -1766
  38. data/sorbet/rbi/gems/{rspec-expectations.rbi → rspec-expectations@3.10.1.rbi} +1149 -698
  39. data/sorbet/rbi/gems/{rspec-mocks.rbi → rspec-mocks@3.10.2.rbi} +1299 -936
  40. data/sorbet/rbi/gems/rspec-support@3.10.2.rbi +509 -0
  41. data/sorbet/rbi/gems/rspec@3.10.0.rbi +38 -0
  42. data/sorbet/rbi/gems/rubocop-ast@1.12.0.rbi +1938 -0
  43. data/sorbet/rbi/gems/rubocop-rspec@2.5.0.rbi +1786 -0
  44. data/sorbet/rbi/gems/rubocop@1.22.1.rbi +13252 -0
  45. data/sorbet/rbi/gems/ruby-progressbar@1.11.0.rbi +405 -0
  46. data/sorbet/rbi/gems/simplecov-html@0.12.3.rbi +89 -0
  47. data/sorbet/rbi/gems/simplecov@0.21.2.rbi +577 -0
  48. data/sorbet/rbi/gems/simplecov_json_formatter@0.1.3.rbi +8 -0
  49. data/sorbet/rbi/gems/spoom@1.1.5.rbi +1241 -0
  50. data/sorbet/rbi/gems/stackprof@0.2.17.rbi +98 -0
  51. data/sorbet/rbi/gems/tapioca@0.5.2.rbi +949 -0
  52. data/sorbet/rbi/gems/thor@1.1.0.rbi +839 -0
  53. data/sorbet/rbi/gems/unicode-display_width@2.1.0.rbi +26 -0
  54. data/sorbet/rbi/gems/unparser@0.6.0.rbi +8 -0
  55. data/sorbet/tapioca/require.rb +4 -0
  56. metadata +65 -68
  57. data/.ruby-version +0 -1
  58. data/sorbet/rbi/gems/activesupport.rbi +0 -1722
  59. data/sorbet/rbi/gems/byebug.rbi +0 -1041
  60. data/sorbet/rbi/gems/coderay.rbi +0 -285
  61. data/sorbet/rbi/gems/concurrent-ruby.rbi +0 -1586
  62. data/sorbet/rbi/gems/docile.rbi +0 -32
  63. data/sorbet/rbi/gems/dry-core.rbi +0 -38
  64. data/sorbet/rbi/gems/dry-equalizer.rbi +0 -26
  65. data/sorbet/rbi/gems/dry-monads.rbi +0 -510
  66. data/sorbet/rbi/gems/em-websocket.rbi +0 -225
  67. data/sorbet/rbi/gems/eventmachine.rbi +0 -489
  68. data/sorbet/rbi/gems/ffaker.rbi +0 -60
  69. data/sorbet/rbi/gems/guard.rbi +0 -397
  70. data/sorbet/rbi/gems/http_parser.rb.rbi +0 -37
  71. data/sorbet/rbi/gems/i18n.rbi +0 -133
  72. data/sorbet/rbi/gems/kwalify.rbi +0 -340
  73. data/sorbet/rbi/gems/listen.rbi +0 -324
  74. data/sorbet/rbi/gems/lumberjack.rbi +0 -300
  75. data/sorbet/rbi/gems/method_source.rbi +0 -64
  76. data/sorbet/rbi/gems/multi_json.rbi +0 -62
  77. data/sorbet/rbi/gems/nenv.rbi +0 -60
  78. data/sorbet/rbi/gems/notiffany.rbi +0 -215
  79. data/sorbet/rbi/gems/parallel.rbi +0 -82
  80. data/sorbet/rbi/gems/parser.rbi +0 -1846
  81. data/sorbet/rbi/gems/pry-byebug.rbi +0 -155
  82. data/sorbet/rbi/gems/rb-fsevent.rbi +0 -31
  83. data/sorbet/rbi/gems/rb-readline.rbi +0 -767
  84. data/sorbet/rbi/gems/reek.rbi +0 -1027
  85. data/sorbet/rbi/gems/regexp_parser.rbi +0 -913
  86. data/sorbet/rbi/gems/rspec-support.rbi +0 -280
  87. data/sorbet/rbi/gems/rspec.rbi +0 -15
  88. data/sorbet/rbi/gems/rubocop-ast.rbi +0 -1053
  89. data/sorbet/rbi/gems/rubocop-rspec.rbi +0 -937
  90. data/sorbet/rbi/gems/rubocop.rbi +0 -6841
  91. data/sorbet/rbi/gems/ruby-progressbar.rbi +0 -305
  92. data/sorbet/rbi/gems/shellany.rbi +0 -29
  93. data/sorbet/rbi/gems/shoulda-matchers.rbi +0 -1848
  94. data/sorbet/rbi/gems/simplecov-html.rbi +0 -35
  95. data/sorbet/rbi/gems/simplecov.rbi +0 -361
  96. data/sorbet/rbi/gems/sqlite3.rbi +0 -354
  97. data/sorbet/rbi/gems/stackprof.rbi +0 -52
  98. data/sorbet/rbi/gems/thor.rbi +0 -32
  99. data/sorbet/rbi/gems/thread_safe.rbi +0 -82
  100. data/sorbet/rbi/gems/timecop.rbi +0 -98
  101. data/sorbet/rbi/gems/tzinfo.rbi +0 -406
  102. data/sorbet/rbi/gems/unicode-display_width.rbi +0 -17
  103. data/sorbet/rbi/hidden-definitions/errors.txt +0 -7267
  104. data/sorbet/rbi/hidden-definitions/hidden.rbi +0 -14661
  105. data/sorbet/rbi/sorbet-typed/lib/activesupport/>=6.0.0.rc1/activesupport.rbi +0 -23
  106. data/sorbet/rbi/sorbet-typed/lib/activesupport/all/activesupport.rbi +0 -1431
  107. data/sorbet/rbi/sorbet-typed/lib/minitest/all/minitest.rbi +0 -108
  108. data/sorbet/rbi/sorbet-typed/lib/rainbow/all/rainbow.rbi +0 -276
  109. data/sorbet/rbi/sorbet-typed/lib/rubocop/~>0.85/rubocop.rbi +0 -2072
  110. data/sorbet/rbi/sorbet-typed/lib/rubocop-rspec/~>1.39/rubocop-rspec.rbi +0 -398
  111. data/sorbet/rbi/todo.rbi +0 -8
@@ -1,1053 +0,0 @@
1
- # This file is autogenerated. Do not edit it by hand. Regenerate it with:
2
- # srb rbi gems
3
-
4
- # typed: strict
5
- #
6
- # If you would like to make changes to this file, great! Please create the gem's shim here:
7
- #
8
- # https://github.com/sorbet/sorbet-typed/new/master?filename=lib/rubocop-ast/all/rubocop-ast.rbi
9
- #
10
- # rubocop-ast-0.2.0
11
-
12
- module RuboCop
13
- end
14
- module RuboCop::AST
15
- end
16
- class RuboCop::AST::NodePattern
17
- def ==(other); end
18
- def eql?(other); end
19
- def initialize(str); end
20
- def marshal_dump; end
21
- def marshal_load(pattern); end
22
- def match(*args, **rest); end
23
- def pattern; end
24
- def self.descend(element, &block); end
25
- def to_s; end
26
- end
27
- class RuboCop::AST::NodePattern::Invalid < StandardError
28
- end
29
- class RuboCop::AST::NodePattern::Compiler
30
- def access_unify(name); end
31
- def atom_to_expr(atom); end
32
- def auto_use_temp_node?(code); end
33
- def captures; end
34
- def compile_any_order(capture_all = nil); end
35
- def compile_arg; end
36
- def compile_args; end
37
- def compile_ascend; end
38
- def compile_atom(token); end
39
- def compile_capture; end
40
- def compile_captured_ellipsis; end
41
- def compile_descend; end
42
- def compile_ellipsis; end
43
- def compile_expr(token = nil); end
44
- def compile_funcall(method); end
45
- def compile_guard_clause; end
46
- def compile_intersect; end
47
- def compile_negation; end
48
- def compile_new_wildcard(name); end
49
- def compile_nodetype(type); end
50
- def compile_predicate(predicate); end
51
- def compile_repeated_expr(token); end
52
- def compile_seq; end
53
- def compile_union; end
54
- def def_helper(base, method_name, **defaults); end
55
- def def_node_matcher(base, method_name, **defaults); end
56
- def def_node_search(base, method_name, **defaults); end
57
- def emit_keyword_list(forwarding: nil); end
58
- def emit_method_code; end
59
- def emit_node_search(method_name); end
60
- def emit_node_search_body(method_name, prelude:, on_match:); end
61
- def emit_param_list; end
62
- def emit_params(*first, forwarding: nil); end
63
- def emit_retval; end
64
- def emit_yield_capture(when_no_capture = nil); end
65
- def expr_to_atom(expr); end
66
- def fail_due_to(message); end
67
- def forbid_unification(*names); end
68
- def get_const(const); end
69
- def get_keyword(name); end
70
- def get_param(number); end
71
- def initialize(str, root = nil, node_var = nil); end
72
- def insure_same_captures(enum, what); end
73
- def match_code; end
74
- def next_capture; end
75
- def next_temp_value; end
76
- def next_temp_variable(name); end
77
- def parse_repetition_token; end
78
- def repeated_generator(expr, captured, accumulate); end
79
- def run; end
80
- def self.tokens(pattern); end
81
- def substitute_cur_node(code, cur_node, first_cur_node: nil); end
82
- def tokens; end
83
- def tokens_until(stop, what); end
84
- def unify_in_union(enum); end
85
- def variadic_seq_term; end
86
- def with_child_context(code, child_index); end
87
- def with_context(code, cur_node, use_temp_node: nil); end
88
- def with_seq_head_context(code); end
89
- def with_temp_node(cur_node); end
90
- def with_temp_variables(&block); end
91
- def wrapping_block(method_name, **defaults); end
92
- end
93
- class RuboCop::AST::NodePattern::Compiler::Sequence
94
- def compile; end
95
- def compile_child_nb_guard; end
96
- def compile_first_terms; end
97
- def compile_guard_clause(*args, &block); end
98
- def compile_last_terms; end
99
- def compile_seq_head; end
100
- def compile_terms(index_range, start); end
101
- def compile_variadic_term; end
102
- def fail_due_to(*args, &block); end
103
- def first_terms_arity; end
104
- def first_terms_range; end
105
- def initialize(compiler, *arity_term_list); end
106
- def last_terms_arity; end
107
- def last_terms_range; end
108
- def seq_head?; end
109
- def term(index, range); end
110
- def variadic_arity; end
111
- def variadic_term_min_arity; end
112
- def with_child_context(*args, &block); end
113
- def with_seq_head_context(*args, &block); end
114
- extend Forwardable
115
- end
116
- module RuboCop::AST::NodePattern::Macros
117
- def def_node_matcher(method_name, pattern_str, **keyword_defaults); end
118
- def def_node_search(method_name, pattern_str, **keyword_defaults); end
119
- end
120
- class RuboCop::AST::NodePattern::Matcher
121
- def ===(compare); end
122
- def initialize(&block); end
123
- end
124
- module RuboCop::AST::Sexp
125
- def s(type, *children); end
126
- end
127
- class RuboCop::AST::Node < Parser::AST::Node
128
- def __ENCODING___type?; end
129
- def __FILE___type?; end
130
- def __LINE___type?; end
131
- def alias_type?; end
132
- def ancestors; end
133
- def and_asgn_type?; end
134
- def and_type?; end
135
- def arg_expr_type?; end
136
- def arg_type?; end
137
- def args_type?; end
138
- def argument?; end
139
- def argument_type?; end
140
- def array_pattern_type?; end
141
- def array_pattern_with_tail_type?; end
142
- def array_type?; end
143
- def assignment?; end
144
- def assignment_or_similar?(node = nil); end
145
- def back_ref_type?; end
146
- def basic_conditional?; end
147
- def basic_literal?; end
148
- def begin_type?; end
149
- def begin_value_used?; end
150
- def block_pass_type?; end
151
- def block_type?; end
152
- def blockarg_expr_type?; end
153
- def blockarg_type?; end
154
- def boolean_type?; end
155
- def break_type?; end
156
- def call_type?; end
157
- def case_if_value_used?; end
158
- def case_match_type?; end
159
- def case_type?; end
160
- def casgn_type?; end
161
- def cbase_type?; end
162
- def chained?; end
163
- def child_nodes; end
164
- def class_constructor?(node = nil); end
165
- def class_definition?(node = nil); end
166
- def class_type?; end
167
- def complete!; end
168
- def complete?; end
169
- def complex_type?; end
170
- def conditional?; end
171
- def const_name; end
172
- def const_pattern_type?; end
173
- def const_type?; end
174
- def csend_type?; end
175
- def cvar_type?; end
176
- def cvasgn_type?; end
177
- def def_e_type?; end
178
- def def_type?; end
179
- def defined_module0(node = nil); end
180
- def defined_module; end
181
- def defined_module_name; end
182
- def defined_type?; end
183
- def defs_e_type?; end
184
- def defs_type?; end
185
- def descendants; end
186
- def dstr_type?; end
187
- def dsym_type?; end
188
- def each_ancestor(*types, &block); end
189
- def each_child_node(*types); end
190
- def each_descendant(*types, &block); end
191
- def each_node(*types, &block); end
192
- def eflipflop_type?; end
193
- def empty_else_type?; end
194
- def empty_source?; end
195
- def ensure_type?; end
196
- def equals_asgn?; end
197
- def erange_type?; end
198
- def false_type?; end
199
- def falsey_literal?; end
200
- def find_pattern_type?; end
201
- def first_line; end
202
- def float_type?; end
203
- def for_type?; end
204
- def for_value_used?; end
205
- def forward_arg_type?; end
206
- def forward_args_type?; end
207
- def forwarded_args_type?; end
208
- def global_const?(node = nil, param1); end
209
- def guard_clause?; end
210
- def gvar_type?; end
211
- def gvasgn_type?; end
212
- def hash_pattern_type?; end
213
- def hash_type?; end
214
- def ident_type?; end
215
- def if_guard_type?; end
216
- def if_type?; end
217
- def iflipflop_type?; end
218
- def immutable_literal?; end
219
- def in_match_type?; end
220
- def in_pattern_type?; end
221
- def index_type?; end
222
- def indexasgn_type?; end
223
- def initialize(type, children = nil, properties = nil); end
224
- def int_type?; end
225
- def irange_type?; end
226
- def ivar_type?; end
227
- def ivasgn_type?; end
228
- def keyword?; end
229
- def kwarg_type?; end
230
- def kwbegin_type?; end
231
- def kwnilarg_type?; end
232
- def kwoptarg_type?; end
233
- def kwrestarg_type?; end
234
- def kwsplat_type?; end
235
- def lambda?(node = nil); end
236
- def lambda_or_proc?(node = nil); end
237
- def lambda_type?; end
238
- def last_line; end
239
- def line_count; end
240
- def literal?; end
241
- def loop_keyword?; end
242
- def lvar_type?; end
243
- def lvasgn_type?; end
244
- def masgn_type?; end
245
- def match_alt_type?; end
246
- def match_as_type?; end
247
- def match_current_line_type?; end
248
- def match_guard_clause?(node = nil); end
249
- def match_nil_pattern_type?; end
250
- def match_rest_type?; end
251
- def match_var_type?; end
252
- def match_with_lvasgn_type?; end
253
- def match_with_trailing_comma_type?; end
254
- def mlhs_type?; end
255
- def module_definition?(node = nil); end
256
- def module_type?; end
257
- def mrasgn_type?; end
258
- def multiline?; end
259
- def mutable_literal?; end
260
- def new_class_or_module_block?(node = nil); end
261
- def next_type?; end
262
- def nil_type?; end
263
- def node_parts; end
264
- def nonempty_line_count; end
265
- def not_type?; end
266
- def nth_ref_type?; end
267
- def numargs_type?; end
268
- def numblock_type?; end
269
- def numeric_type?; end
270
- def objc_kwarg_type?; end
271
- def objc_restarg_type?; end
272
- def objc_varargs_type?; end
273
- def op_asgn_type?; end
274
- def operator_keyword?; end
275
- def optarg_type?; end
276
- def or_asgn_type?; end
277
- def or_type?; end
278
- def pair_type?; end
279
- def parent; end
280
- def parent=(node); end
281
- def parent_module_name; end
282
- def parent_module_name_for_block(ancestor); end
283
- def parent_module_name_for_sclass(sclass_node); end
284
- def parent_module_name_part(node); end
285
- def parenthesized_call?; end
286
- def pin_type?; end
287
- def post_condition_loop?; end
288
- def postexe_type?; end
289
- def preexe_type?; end
290
- def proc?(node = nil); end
291
- def procarg0_type?; end
292
- def pure?; end
293
- def range_type?; end
294
- def rasgn_type?; end
295
- def rational_type?; end
296
- def receiver(node = nil); end
297
- def recursive_basic_literal?; end
298
- def recursive_literal?; end
299
- def redo_type?; end
300
- def reference?; end
301
- def regexp_type?; end
302
- def regopt_type?; end
303
- def resbody_type?; end
304
- def rescue_type?; end
305
- def restarg_expr_type?; end
306
- def restarg_type?; end
307
- def retry_type?; end
308
- def return_type?; end
309
- def root_type?; end
310
- def sclass_type?; end
311
- def self_type?; end
312
- def send_type?; end
313
- def shadowarg_type?; end
314
- def shorthand_asgn?; end
315
- def sibling_index; end
316
- def single_line?; end
317
- def source; end
318
- def source_length; end
319
- def source_range; end
320
- def special_keyword?; end
321
- def splat_type?; end
322
- def str_content(node = nil); end
323
- def str_type?; end
324
- def struct_constructor?(node = nil); end
325
- def super_type?; end
326
- def sym_type?; end
327
- def true_type?; end
328
- def truthy_literal?; end
329
- def undef_type?; end
330
- def unless_guard_type?; end
331
- def until_post_type?; end
332
- def until_type?; end
333
- def updated(type = nil, children = nil, properties = nil); end
334
- def value_used?; end
335
- def variable?; end
336
- def visit_ancestors(types); end
337
- def visit_descendants(types, &block); end
338
- def when_type?; end
339
- def while_post_type?; end
340
- def while_type?; end
341
- def while_until_value_used?; end
342
- def xstr_type?; end
343
- def yield_type?; end
344
- def zsuper_type?; end
345
- extend RuboCop::AST::NodePattern::Macros
346
- include RuboCop::AST::Sexp
347
- end
348
- module RuboCop::AST::MethodIdentifierPredicates
349
- def assignment_method?; end
350
- def bang_method?; end
351
- def camel_case_method?; end
352
- def comparison_method?; end
353
- def const_receiver?; end
354
- def enumerable_method?; end
355
- def enumerator_method?; end
356
- def method?(name); end
357
- def negation_method?; end
358
- def nonmutating_array_method?; end
359
- def nonmutating_binary_operator_method?; end
360
- def nonmutating_hash_method?; end
361
- def nonmutating_operator_method?; end
362
- def nonmutating_string_method?; end
363
- def nonmutating_unary_operator_method?; end
364
- def operator_method?; end
365
- def predicate_method?; end
366
- def prefix_bang?; end
367
- def prefix_not?; end
368
- def self_receiver?; end
369
- end
370
- module RuboCop::AST::BinaryOperatorNode
371
- def conditions; end
372
- def lhs; end
373
- def rhs; end
374
- end
375
- module RuboCop::AST::CollectionNode
376
- def &(*args, &block); end
377
- def *(*args, &block); end
378
- def +(*args, &block); end
379
- def -(*args, &block); end
380
- def <<(*args, &block); end
381
- def [](*args, &block); end
382
- def []=(*args, &block); end
383
- def all?(*args, &block); end
384
- def any?(*args, &block); end
385
- def append(*args, &block); end
386
- def assoc(*args, &block); end
387
- def at(*args, &block); end
388
- def bsearch(*args, &block); end
389
- def bsearch_index(*args, &block); end
390
- def chain(*args, &block); end
391
- def chunk(*args, &block); end
392
- def chunk_while(*args, &block); end
393
- def clear(*args, &block); end
394
- def collect!(*args, &block); end
395
- def collect(*args, &block); end
396
- def collect_concat(*args, &block); end
397
- def combination(*args, &block); end
398
- def compact!(*args, &block); end
399
- def compact(*args, &block); end
400
- def concat(*args, &block); end
401
- def count(*args, &block); end
402
- def cycle(*args, &block); end
403
- def delete(*args, &block); end
404
- def delete_at(*args, &block); end
405
- def delete_if(*args, &block); end
406
- def detect(*args, &block); end
407
- def difference(*args, &block); end
408
- def dig(*args, &block); end
409
- def drop(*args, &block); end
410
- def drop_while(*args, &block); end
411
- def each(*args, &block); end
412
- def each_cons(*args, &block); end
413
- def each_entry(*args, &block); end
414
- def each_index(*args, &block); end
415
- def each_slice(*args, &block); end
416
- def each_with_index(*args, &block); end
417
- def each_with_object(*args, &block); end
418
- def empty?(*args, &block); end
419
- def entries(*args, &block); end
420
- def extract_options!(*args, &block); end
421
- def fetch(*args, &block); end
422
- def fill(*args, &block); end
423
- def filter!(*args, &block); end
424
- def filter(*args, &block); end
425
- def find(*args, &block); end
426
- def find_all(*args, &block); end
427
- def find_index(*args, &block); end
428
- def first(*args, &block); end
429
- def flat_map(*args, &block); end
430
- def flatten!(*args, &block); end
431
- def flatten(*args, &block); end
432
- def grep(*args, &block); end
433
- def grep_v(*args, &block); end
434
- def group_by(*args, &block); end
435
- def include?(*args, &block); end
436
- def index(*args, &block); end
437
- def inject(*args, &block); end
438
- def insert(*args, &block); end
439
- def join(*args, &block); end
440
- def keep_if(*args, &block); end
441
- def last(*args, &block); end
442
- def lazy(*args, &block); end
443
- def length(*args, &block); end
444
- def map!(*args, &block); end
445
- def map(*args, &block); end
446
- def max(*args, &block); end
447
- def max_by(*args, &block); end
448
- def member?(*args, &block); end
449
- def min(*args, &block); end
450
- def min_by(*args, &block); end
451
- def minmax(*args, &block); end
452
- def minmax_by(*args, &block); end
453
- def none?(*args, &block); end
454
- def one?(*args, &block); end
455
- def pack(*args, &block); end
456
- def partition(*args, &block); end
457
- def permutation(*args, &block); end
458
- def pop(*args, &block); end
459
- def prepend(*args, &block); end
460
- def product(*args, &block); end
461
- def push(*args, &block); end
462
- def rassoc(*args, &block); end
463
- def reduce(*args, &block); end
464
- def reject!(*args, &block); end
465
- def reject(*args, &block); end
466
- def repeated_combination(*args, &block); end
467
- def repeated_permutation(*args, &block); end
468
- def replace(*args, &block); end
469
- def reverse!(*args, &block); end
470
- def reverse(*args, &block); end
471
- def reverse_each(*args, &block); end
472
- def rindex(*args, &block); end
473
- def rotate!(*args, &block); end
474
- def rotate(*args, &block); end
475
- def sample(*args, &block); end
476
- def select!(*args, &block); end
477
- def select(*args, &block); end
478
- def shelljoin(*args, &block); end
479
- def shift(*args, &block); end
480
- def shuffle!(*args, &block); end
481
- def shuffle(*args, &block); end
482
- def size(*args, &block); end
483
- def slice!(*args, &block); end
484
- def slice(*args, &block); end
485
- def slice_after(*args, &block); end
486
- def slice_before(*args, &block); end
487
- def slice_when(*args, &block); end
488
- def sort!(*args, &block); end
489
- def sort(*args, &block); end
490
- def sort_by!(*args, &block); end
491
- def sort_by(*args, &block); end
492
- def sum(*args, &block); end
493
- def take(*args, &block); end
494
- def take_while(*args, &block); end
495
- def to_ary(*args, &block); end
496
- def to_default_s(*args, &block); end
497
- def to_formatted_s(*args, &block); end
498
- def to_h(*args, &block); end
499
- def to_sentence(*args, &block); end
500
- def to_set(*args, &block); end
501
- def to_xml(*args, &block); end
502
- def transpose(*args, &block); end
503
- def union(*args, &block); end
504
- def uniq!(*args, &block); end
505
- def uniq(*args, &block); end
506
- def unshift(*args, &block); end
507
- def values_at(*args, &block); end
508
- def zip(*args, &block); end
509
- def |(*args, &block); end
510
- extend Forwardable
511
- end
512
- module RuboCop::AST::ConditionalNode
513
- def body; end
514
- def condition; end
515
- def multiline_condition?; end
516
- def single_line_condition?; end
517
- end
518
- module RuboCop::AST::HashElementNode
519
- def delimiter_delta(other); end
520
- def key; end
521
- def key_delta(other, alignment = nil); end
522
- def same_line?(other); end
523
- def value; end
524
- def value_delta(other); end
525
- end
526
- class RuboCop::AST::HashElementNode::HashElementDelta
527
- def delimiter_delta; end
528
- def delta(first, second, alignment = nil); end
529
- def first; end
530
- def initialize(first, second); end
531
- def key_delta(alignment = nil); end
532
- def keyword_splat?; end
533
- def second; end
534
- def valid_argument_types?; end
535
- def value_delta; end
536
- end
537
- module RuboCop::AST::MethodDispatchNode
538
- def access_modifier?; end
539
- def adjacent_def_modifier?(node = nil); end
540
- def arguments; end
541
- def arithmetic_operation?; end
542
- def assignment?; end
543
- def bare_access_modifier?; end
544
- def bare_access_modifier_declaration?(node = nil); end
545
- def binary_operation?; end
546
- def block_literal?; end
547
- def block_node; end
548
- def command?(name); end
549
- def const_receiver?; end
550
- def def_modifier?; end
551
- def dot?; end
552
- def double_colon?; end
553
- def implicit_call?; end
554
- def lambda?; end
555
- def lambda_literal?; end
556
- def macro?; end
557
- def macro_kwbegin_wrapper?(parent); end
558
- def macro_scope?(node = nil); end
559
- def method_name; end
560
- def non_bare_access_modifier?; end
561
- def non_bare_access_modifier_declaration?(node = nil); end
562
- def receiver; end
563
- def root_node?(node); end
564
- def safe_navigation?; end
565
- def self_receiver?; end
566
- def setter_method?; end
567
- def special_modifier?; end
568
- def unary_operation?; end
569
- extend RuboCop::AST::NodePattern::Macros
570
- include RuboCop::AST::MethodIdentifierPredicates
571
- end
572
- module RuboCop::AST::ModifierNode
573
- def modifier_form?; end
574
- end
575
- module RuboCop::AST::NumericNode
576
- def sign?; end
577
- end
578
- module RuboCop::AST::ParameterizedNode
579
- def arguments?; end
580
- def block_argument?; end
581
- def first_argument; end
582
- def last_argument; end
583
- def parenthesized?; end
584
- def rest_argument?; end
585
- def splat_argument?; end
586
- end
587
- module RuboCop::AST::PredicateOperatorNode
588
- def logical_operator?; end
589
- def operator; end
590
- def semantic_operator?; end
591
- end
592
- module RuboCop::AST::BasicLiteralNode
593
- def value; end
594
- end
595
- class RuboCop::AST::AliasNode < RuboCop::AST::Node
596
- def new_identifier; end
597
- def old_identifier; end
598
- end
599
- class RuboCop::AST::AndNode < RuboCop::AST::Node
600
- def alternate_operator; end
601
- def inverse_operator; end
602
- include RuboCop::AST::BinaryOperatorNode
603
- include RuboCop::AST::PredicateOperatorNode
604
- end
605
- class RuboCop::AST::ArgsNode < RuboCop::AST::Node
606
- def empty_and_without_delimiters?; end
607
- include RuboCop::AST::CollectionNode
608
- end
609
- class RuboCop::AST::ArrayNode < RuboCop::AST::Node
610
- def bracketed?; end
611
- def each_value(&block); end
612
- def percent_literal?(type = nil); end
613
- def square_brackets?; end
614
- def values; end
615
- end
616
- class RuboCop::AST::BlockNode < RuboCop::AST::Node
617
- def arguments; end
618
- def arguments?; end
619
- def body; end
620
- def braces?; end
621
- def closing_delimiter; end
622
- def delimiters; end
623
- def keywords?; end
624
- def lambda?; end
625
- def method_name; end
626
- def multiline?; end
627
- def opening_delimiter; end
628
- def send_node; end
629
- def single_line?; end
630
- def void_context?; end
631
- include RuboCop::AST::MethodIdentifierPredicates
632
- end
633
- class RuboCop::AST::BreakNode < RuboCop::AST::Node
634
- def arguments; end
635
- include RuboCop::AST::MethodDispatchNode
636
- include RuboCop::AST::ParameterizedNode
637
- end
638
- class RuboCop::AST::CaseMatchNode < RuboCop::AST::Node
639
- def each_in_pattern; end
640
- def else?; end
641
- def else_branch; end
642
- def in_pattern_branches; end
643
- def keyword; end
644
- include RuboCop::AST::ConditionalNode
645
- end
646
- class RuboCop::AST::CaseNode < RuboCop::AST::Node
647
- def each_when; end
648
- def else?; end
649
- def else_branch; end
650
- def keyword; end
651
- def when_branches; end
652
- include RuboCop::AST::ConditionalNode
653
- end
654
- class RuboCop::AST::ClassNode < RuboCop::AST::Node
655
- def body; end
656
- def identifier; end
657
- def parent_class; end
658
- end
659
- class RuboCop::AST::DefNode < RuboCop::AST::Node
660
- def argument_forwarding?; end
661
- def arguments; end
662
- def body; end
663
- def method_name; end
664
- def receiver; end
665
- def void_context?; end
666
- include RuboCop::AST::MethodIdentifierPredicates
667
- include RuboCop::AST::ParameterizedNode
668
- end
669
- class RuboCop::AST::DefinedNode < RuboCop::AST::Node
670
- def node_parts; end
671
- include RuboCop::AST::MethodDispatchNode
672
- include RuboCop::AST::ParameterizedNode
673
- end
674
- class RuboCop::AST::EnsureNode < RuboCop::AST::Node
675
- def body; end
676
- end
677
- class RuboCop::AST::ForNode < RuboCop::AST::Node
678
- def body; end
679
- def collection; end
680
- def do?; end
681
- def keyword; end
682
- def variable; end
683
- def void_context?; end
684
- end
685
- class RuboCop::AST::ForwardArgsNode < RuboCop::AST::Node
686
- def to_a; end
687
- include RuboCop::AST::CollectionNode
688
- end
689
- class RuboCop::AST::FloatNode < RuboCop::AST::Node
690
- include RuboCop::AST::NumericNode
691
- end
692
- class RuboCop::AST::HashNode < RuboCop::AST::Node
693
- def braces?; end
694
- def each_key; end
695
- def each_pair; end
696
- def each_value; end
697
- def empty?; end
698
- def keys; end
699
- def mixed_delimiters?; end
700
- def pairs; end
701
- def pairs_on_same_line?; end
702
- def values; end
703
- end
704
- class RuboCop::AST::IfNode < RuboCop::AST::Node
705
- def branches; end
706
- def each_branch; end
707
- def else?; end
708
- def else_branch; end
709
- def elsif?; end
710
- def elsif_conditional?; end
711
- def if?; end
712
- def if_branch; end
713
- def inverse_keyword; end
714
- def keyword; end
715
- def modifier_form?; end
716
- def nested_conditional?; end
717
- def node_parts; end
718
- def ternary?; end
719
- def unless?; end
720
- include RuboCop::AST::ConditionalNode
721
- include RuboCop::AST::ModifierNode
722
- end
723
- class RuboCop::AST::IndexNode < RuboCop::AST::Node
724
- def arguments; end
725
- def assignment_method?; end
726
- def attribute_accessor?; end
727
- def method_name; end
728
- include RuboCop::AST::MethodDispatchNode
729
- include RuboCop::AST::ParameterizedNode
730
- end
731
- class RuboCop::AST::IndexasgnNode < RuboCop::AST::Node
732
- def arguments; end
733
- def assignment_method?; end
734
- def attribute_accessor?; end
735
- def method_name; end
736
- include RuboCop::AST::MethodDispatchNode
737
- include RuboCop::AST::ParameterizedNode
738
- end
739
- class RuboCop::AST::IntNode < RuboCop::AST::Node
740
- include RuboCop::AST::NumericNode
741
- end
742
- class RuboCop::AST::KeywordSplatNode < RuboCop::AST::Node
743
- def colon?; end
744
- def hash_rocket?; end
745
- def node_parts; end
746
- def operator; end
747
- include RuboCop::AST::HashElementNode
748
- end
749
- class RuboCop::AST::LambdaNode < RuboCop::AST::Node
750
- def arguments; end
751
- def assignment_method?; end
752
- def attribute_accessor?; end
753
- def lambda?; end
754
- def lambda_literal?; end
755
- def method_name; end
756
- include RuboCop::AST::MethodDispatchNode
757
- include RuboCop::AST::ParameterizedNode
758
- end
759
- class RuboCop::AST::ModuleNode < RuboCop::AST::Node
760
- def body; end
761
- def identifier; end
762
- end
763
- class RuboCop::AST::OrNode < RuboCop::AST::Node
764
- def alternate_operator; end
765
- def inverse_operator; end
766
- include RuboCop::AST::BinaryOperatorNode
767
- include RuboCop::AST::PredicateOperatorNode
768
- end
769
- class RuboCop::AST::PairNode < RuboCop::AST::Node
770
- def colon?; end
771
- def delimiter(with_spacing = nil); end
772
- def hash_rocket?; end
773
- def inverse_delimiter(with_spacing = nil); end
774
- def value_on_new_line?; end
775
- include RuboCop::AST::HashElementNode
776
- end
777
- class RuboCop::AST::RangeNode < RuboCop::AST::Node
778
- def begin; end
779
- def end; end
780
- end
781
- class RuboCop::AST::RegexpNode < RuboCop::AST::Node
782
- def content; end
783
- def delimiter?(char); end
784
- def delimiters; end
785
- def extended?; end
786
- def ignore_case?; end
787
- def interpolation?; end
788
- def multiline_mode?; end
789
- def no_encoding?; end
790
- def percent_r_literal?; end
791
- def regopt; end
792
- def regopt_include?(option); end
793
- def single_interpolation?; end
794
- def slash_literal?; end
795
- def to_regexp; end
796
- end
797
- class RuboCop::AST::ResbodyNode < RuboCop::AST::Node
798
- def body; end
799
- def exception_variable; end
800
- end
801
- class RuboCop::AST::RetryNode < RuboCop::AST::Node
802
- def arguments; end
803
- include RuboCop::AST::MethodDispatchNode
804
- include RuboCop::AST::ParameterizedNode
805
- end
806
- class RuboCop::AST::ReturnNode < RuboCop::AST::Node
807
- def arguments; end
808
- include RuboCop::AST::MethodDispatchNode
809
- include RuboCop::AST::ParameterizedNode
810
- end
811
- class RuboCop::AST::SelfClassNode < RuboCop::AST::Node
812
- def body; end
813
- def identifier; end
814
- end
815
- class RuboCop::AST::SendNode < RuboCop::AST::Node
816
- def attribute_accessor?(node = nil); end
817
- include RuboCop::AST::MethodDispatchNode
818
- include RuboCop::AST::ParameterizedNode
819
- end
820
- class RuboCop::AST::StrNode < RuboCop::AST::Node
821
- def heredoc?; end
822
- include RuboCop::AST::BasicLiteralNode
823
- end
824
- class RuboCop::AST::SuperNode < RuboCop::AST::Node
825
- def node_parts; end
826
- include RuboCop::AST::MethodDispatchNode
827
- include RuboCop::AST::ParameterizedNode
828
- end
829
- class RuboCop::AST::SymbolNode < RuboCop::AST::Node
830
- include RuboCop::AST::BasicLiteralNode
831
- end
832
- class RuboCop::AST::UntilNode < RuboCop::AST::Node
833
- def do?; end
834
- def inverse_keyword; end
835
- def keyword; end
836
- include RuboCop::AST::ConditionalNode
837
- include RuboCop::AST::ModifierNode
838
- end
839
- class RuboCop::AST::WhenNode < RuboCop::AST::Node
840
- def body; end
841
- def branch_index; end
842
- def conditions; end
843
- def each_condition; end
844
- def then?; end
845
- end
846
- class RuboCop::AST::WhileNode < RuboCop::AST::Node
847
- def do?; end
848
- def inverse_keyword; end
849
- def keyword; end
850
- include RuboCop::AST::ConditionalNode
851
- include RuboCop::AST::ModifierNode
852
- end
853
- class RuboCop::AST::YieldNode < RuboCop::AST::Node
854
- def node_parts; end
855
- include RuboCop::AST::MethodDispatchNode
856
- include RuboCop::AST::ParameterizedNode
857
- end
858
- class RuboCop::AST::Builder < Parser::Builders::Default
859
- def n(type, children, source_map); end
860
- def node_klass(type); end
861
- def string_value(token); end
862
- end
863
- class RuboCop::AST::ProcessedSource
864
- def [](*args); end
865
- def ast; end
866
- def ast_with_comments; end
867
- def blank?; end
868
- def buffer; end
869
- def checksum; end
870
- def comment_lines; end
871
- def commented?(source_range); end
872
- def comments; end
873
- def comments_before_line(line); end
874
- def contains_comment?(source_range); end
875
- def create_parser(ruby_version); end
876
- def current_line(token); end
877
- def diagnostics; end
878
- def each_comment; end
879
- def each_token; end
880
- def file_path; end
881
- def find_comment; end
882
- def find_token; end
883
- def following_line(token); end
884
- def initialize(source, ruby_version, path = nil); end
885
- def line_indentation(line_number); end
886
- def line_with_comment?(line); end
887
- def lines; end
888
- def parse(source, ruby_version); end
889
- def parser_class(ruby_version); end
890
- def parser_error; end
891
- def path; end
892
- def preceding_line(token); end
893
- def raw_source; end
894
- def ruby_version; end
895
- def self.from_file(path, ruby_version); end
896
- def start_with?(string); end
897
- def tokenize(parser); end
898
- def tokens; end
899
- def valid_syntax?; end
900
- end
901
- class RuboCop::AST::Token
902
- def begin_pos; end
903
- def column; end
904
- def comma?; end
905
- def comment?; end
906
- def end?; end
907
- def end_pos; end
908
- def equal_sign?; end
909
- def initialize(pos, type, text); end
910
- def left_array_bracket?; end
911
- def left_brace?; end
912
- def left_bracket?; end
913
- def left_curly_brace?; end
914
- def left_parens?; end
915
- def left_ref_bracket?; end
916
- def line; end
917
- def pos; end
918
- def rescue_modifier?; end
919
- def right_bracket?; end
920
- def right_curly_brace?; end
921
- def right_parens?; end
922
- def self.from_parser_token(parser_token); end
923
- def semicolon?; end
924
- def space_after?; end
925
- def space_before?; end
926
- def text; end
927
- def to_s; end
928
- def type; end
929
- end
930
- module RuboCop::AST::Traversal
931
- def on___ENCODING__(node); end
932
- def on_alias(node); end
933
- def on_and(node); end
934
- def on_and_asgn(node); end
935
- def on_arg(node); end
936
- def on_arg_expr(node); end
937
- def on_args(node); end
938
- def on_array(node); end
939
- def on_array_pattern(node); end
940
- def on_array_pattern_with_tail(node); end
941
- def on_back_ref(node); end
942
- def on_begin(node); end
943
- def on_block(node); end
944
- def on_block_pass(node); end
945
- def on_blockarg(node); end
946
- def on_break(node); end
947
- def on_case(node); end
948
- def on_case_match(node); end
949
- def on_casgn(node); end
950
- def on_cbase(node); end
951
- def on_class(node); end
952
- def on_complex(node); end
953
- def on_const(node); end
954
- def on_const_pattern(node); end
955
- def on_csend(node); end
956
- def on_cvar(node); end
957
- def on_cvasgn(node); end
958
- def on_def(node); end
959
- def on_defined?(node); end
960
- def on_defs(node); end
961
- def on_dstr(node); end
962
- def on_dsym(node); end
963
- def on_eflipflop(node); end
964
- def on_empty_else(node); end
965
- def on_ensure(node); end
966
- def on_erange(node); end
967
- def on_false(node); end
968
- def on_find_pattern(node); end
969
- def on_float(node); end
970
- def on_for(node); end
971
- def on_forward_arg(node); end
972
- def on_forward_args(node); end
973
- def on_forwarded_args(node); end
974
- def on_gvar(node); end
975
- def on_gvasgn(node); end
976
- def on_hash(node); end
977
- def on_hash_pattern(node); end
978
- def on_if(node); end
979
- def on_if_guard(node); end
980
- def on_iflipflop(node); end
981
- def on_in_match(node); end
982
- def on_in_pattern(node); end
983
- def on_index(node); end
984
- def on_indexasgn(node); end
985
- def on_int(node); end
986
- def on_irange(node); end
987
- def on_ivar(node); end
988
- def on_ivasgn(node); end
989
- def on_kwarg(node); end
990
- def on_kwbegin(node); end
991
- def on_kwoptarg(node); end
992
- def on_kwrestarg(node); end
993
- def on_kwsplat(node); end
994
- def on_lambda(node); end
995
- def on_lvar(node); end
996
- def on_lvasgn(node); end
997
- def on_masgn(node); end
998
- def on_match_alt(node); end
999
- def on_match_as(node); end
1000
- def on_match_current_line(node); end
1001
- def on_match_nil_pattern(node); end
1002
- def on_match_rest(node); end
1003
- def on_match_var(node); end
1004
- def on_match_with_lvasgn(node); end
1005
- def on_match_with_trailing_comma(node); end
1006
- def on_mlhs(node); end
1007
- def on_module(node); end
1008
- def on_next(node); end
1009
- def on_nil(node); end
1010
- def on_not(node); end
1011
- def on_nth_ref(node); end
1012
- def on_numblock(node); end
1013
- def on_op_asgn(node); end
1014
- def on_optarg(node); end
1015
- def on_or(node); end
1016
- def on_or_asgn(node); end
1017
- def on_pair(node); end
1018
- def on_pin(node); end
1019
- def on_postexe(node); end
1020
- def on_preexe(node); end
1021
- def on_procarg0(node); end
1022
- def on_rational(node); end
1023
- def on_redo(node); end
1024
- def on_regexp(node); end
1025
- def on_regopt(node); end
1026
- def on_resbody(node); end
1027
- def on_rescue(node); end
1028
- def on_restarg(node); end
1029
- def on_retry(node); end
1030
- def on_return(node); end
1031
- def on_sclass(node); end
1032
- def on_self(node); end
1033
- def on_send(node); end
1034
- def on_shadowarg(node); end
1035
- def on_splat(node); end
1036
- def on_str(node); end
1037
- def on_super(node); end
1038
- def on_sym(node); end
1039
- def on_true(node); end
1040
- def on_undef(node); end
1041
- def on_unless_guard(node); end
1042
- def on_until(node); end
1043
- def on_until_post(node); end
1044
- def on_when(node); end
1045
- def on_while(node); end
1046
- def on_while_post(node); end
1047
- def on_xstr(node); end
1048
- def on_yield(node); end
1049
- def on_zsuper(node); end
1050
- def walk(node); end
1051
- end
1052
- module RuboCop::AST::Version
1053
- end