minitest-distributed 0.2.8 → 0.2.9

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 (36) hide show
  1. checksums.yaml +4 -4
  2. data/.github/workflows/ruby.yml +16 -4
  3. data/Gemfile +1 -0
  4. data/docker-compose.yml +5 -0
  5. data/lib/minitest/distributed/configuration.rb +5 -0
  6. data/lib/minitest/distributed/reporters/test_order_reporter.rb +36 -0
  7. data/lib/minitest/distributed/test_selector.rb +11 -1
  8. data/lib/minitest/distributed/version.rb +1 -1
  9. data/lib/minitest/test_order_plugin.rb +21 -0
  10. data/minitest-distributed.gemspec +1 -1
  11. data/sorbet/config +1 -0
  12. data/sorbet/rbi/gems/ast.rbi +49 -0
  13. data/sorbet/rbi/gems/connection_pool.rbi +55 -0
  14. data/sorbet/rbi/gems/minitest-distributed.rbi +15 -0
  15. data/sorbet/rbi/gems/minitest.rbi +426 -0
  16. data/sorbet/rbi/gems/parallel.rbi +86 -0
  17. data/sorbet/rbi/gems/parser.rbi +1477 -0
  18. data/sorbet/rbi/gems/rainbow.rbi +122 -0
  19. data/sorbet/rbi/gems/rake.rbi +647 -0
  20. data/sorbet/rbi/gems/redis-client.rbi +311 -0
  21. data/sorbet/rbi/gems/redis.rbi +409 -0
  22. data/sorbet/rbi/gems/regexp_parser.rbi +984 -0
  23. data/sorbet/rbi/gems/rexml.rbi +599 -0
  24. data/sorbet/rbi/gems/rubocop-ast.rbi +1398 -0
  25. data/sorbet/rbi/gems/rubocop-minitest.rbi +406 -0
  26. data/sorbet/rbi/gems/rubocop-rake.rbi +85 -0
  27. data/sorbet/rbi/gems/rubocop-sorbet.rbi +218 -0
  28. data/sorbet/rbi/gems/rubocop.rbi +9351 -0
  29. data/sorbet/rbi/gems/ruby-progressbar.rbi +304 -0
  30. data/sorbet/rbi/gems/toxiproxy.rbi +112 -0
  31. data/sorbet/rbi/gems/unicode-display_width.rbi +23 -0
  32. data/sorbet/rbi/minitest.rbi +5 -1
  33. data/sorbet/rbi/rails.rbi +1 -0
  34. data/sorbet/rbi/rbconfig.rbi +1 -1
  35. metadata +26 -5
  36. data/sorbet/rbi/redis.rbi +0 -106
@@ -0,0 +1,406 @@
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-minitest/all/rubocop-minitest.rbi
9
+ #
10
+ # rubocop-minitest-0.25.1
11
+
12
+ module RuboCop
13
+ end
14
+ module RuboCop::Minitest
15
+ end
16
+ module RuboCop::Minitest::Version
17
+ def self.document_version; end
18
+ end
19
+ module RuboCop::Minitest::Inject
20
+ def self.defaults!; end
21
+ end
22
+ module RuboCop::Cop
23
+ end
24
+ module RuboCop::Cop::ArgumentRangeHelper
25
+ def all_arguments_range(node); end
26
+ def first_and_second_arguments_range(node); end
27
+ def first_argument_range(node); end
28
+ include RuboCop::Cop::RangeHelp
29
+ end
30
+ module RuboCop::Cop::InDeltaMixin
31
+ def assertion_method; end
32
+ def build_good_method(expected, actual, message); end
33
+ def on_send(node); end
34
+ end
35
+ module RuboCop::Cop::MinitestCopRule
36
+ def define_rule(assertion_method, target_method:, preferred_method: nil, inverse: nil); end
37
+ end
38
+ module RuboCop::Cop::MinitestExplorationHelpers
39
+ def assertion_method?(node); end
40
+ def assertions(def_node); end
41
+ def class_def_nodes(class_node); end
42
+ def lifecycle_hook_method?(node); end
43
+ def lifecycle_hooks(class_node); end
44
+ def test_case?(node); end
45
+ def test_case_name?(name); end
46
+ def test_cases(class_node); end
47
+ def test_class?(class_node); end
48
+ extend RuboCop::AST::NodePattern::Macros
49
+ end
50
+ module RuboCop::Cop::Minitest
51
+ end
52
+ module RuboCop::Cop::Minitest::NilAssertionHandleable
53
+ def autocorrect(corrector, node, actual); end
54
+ def build_message(node, actual, message); end
55
+ def comparison_or_predicate_assertion_method?(node); end
56
+ def register_offense(node, actual, message); end
57
+ end
58
+ module RuboCop::Cop::Minitest::PredicateAssertionHandleable
59
+ def autocorrect(corrector, node, arguments); end
60
+ def correct_receiver(receiver); end
61
+ def new_arguments(arguments); end
62
+ def offense_message(arguments); end
63
+ def on_send(node); end
64
+ def peel_redundant_parentheses_from(arguments); end
65
+ def predicate_method?(first_argument); end
66
+ end
67
+ class RuboCop::Cop::Minitest::AssertEmpty < RuboCop::Cop::Base
68
+ def autocorrect(corrector, node, arguments); end
69
+ def correct_receiver(receiver); end
70
+ def enclosed_in_redundant_parentheses?(node); end
71
+ def new_arguments(arguments); end
72
+ def offense_message(arguments); end
73
+ def on_send(node); end
74
+ def peel_redundant_parentheses_from(arguments); end
75
+ extend RuboCop::Cop::AutoCorrector
76
+ extend RuboCop::Cop::MinitestCopRule
77
+ include RuboCop::Cop::ArgumentRangeHelper
78
+ end
79
+ class RuboCop::Cop::Minitest::AssertEmptyLiteral < RuboCop::Cop::Base
80
+ def assert_equal_with_empty_literal(param0 = nil); end
81
+ def on_send(node); end
82
+ extend RuboCop::Cop::AutoCorrector
83
+ include RuboCop::Cop::ArgumentRangeHelper
84
+ end
85
+ class RuboCop::Cop::Minitest::AssertEqual < RuboCop::Cop::Base
86
+ def autocorrect(corrector, node, arguments); end
87
+ def correct_receiver(receiver); end
88
+ def enclosed_in_redundant_parentheses?(node); end
89
+ def new_arguments(arguments); end
90
+ def offense_message(arguments); end
91
+ def on_send(node); end
92
+ def peel_redundant_parentheses_from(arguments); end
93
+ extend RuboCop::Cop::AutoCorrector
94
+ extend RuboCop::Cop::MinitestCopRule
95
+ include RuboCop::Cop::ArgumentRangeHelper
96
+ end
97
+ class RuboCop::Cop::Minitest::AssertInDelta < RuboCop::Cop::Base
98
+ def equal_floats_call(param0 = nil); end
99
+ extend RuboCop::Cop::AutoCorrector
100
+ include RuboCop::Cop::InDeltaMixin
101
+ end
102
+ class RuboCop::Cop::Minitest::AssertPredicate < RuboCop::Cop::Base
103
+ def assertion_type; end
104
+ extend RuboCop::Cop::AutoCorrector
105
+ include RuboCop::Cop::ArgumentRangeHelper
106
+ include RuboCop::Cop::Minitest::PredicateAssertionHandleable
107
+ end
108
+ class RuboCop::Cop::Minitest::AssertRaisesCompoundBody < RuboCop::Cop::Base
109
+ def multi_statement_begin?(node); end
110
+ def on_block(node); end
111
+ end
112
+ class RuboCop::Cop::Minitest::AssertRaisesWithRegexpArgument < RuboCop::Cop::Base
113
+ def on_send(node); end
114
+ end
115
+ class RuboCop::Cop::Minitest::AssertWithExpectedArgument < RuboCop::Cop::Base
116
+ def assert_with_two_arguments?(param0 = nil); end
117
+ def on_send(node); end
118
+ end
119
+ class RuboCop::Cop::Minitest::AssertionInLifecycleHook < RuboCop::Cop::Base
120
+ def on_class(class_node); end
121
+ include RuboCop::Cop::MinitestExplorationHelpers
122
+ end
123
+ class RuboCop::Cop::Minitest::AssertKindOf < RuboCop::Cop::Base
124
+ def autocorrect(corrector, node, arguments); end
125
+ def correct_receiver(receiver); end
126
+ def enclosed_in_redundant_parentheses?(node); end
127
+ def new_arguments(arguments); end
128
+ def offense_message(arguments); end
129
+ def on_send(node); end
130
+ def peel_redundant_parentheses_from(arguments); end
131
+ extend RuboCop::Cop::AutoCorrector
132
+ extend RuboCop::Cop::MinitestCopRule
133
+ include RuboCop::Cop::ArgumentRangeHelper
134
+ end
135
+ class RuboCop::Cop::Minitest::AssertNil < RuboCop::Cop::Base
136
+ def assertion_type; end
137
+ def nil_assertion(param0 = nil); end
138
+ def on_send(node); end
139
+ extend RuboCop::Cop::AutoCorrector
140
+ include RuboCop::Cop::ArgumentRangeHelper
141
+ include RuboCop::Cop::Minitest::NilAssertionHandleable
142
+ end
143
+ class RuboCop::Cop::Minitest::AssertIncludes < RuboCop::Cop::Base
144
+ def autocorrect(corrector, node, arguments); end
145
+ def correct_receiver(receiver); end
146
+ def enclosed_in_redundant_parentheses?(node); end
147
+ def new_arguments(arguments); end
148
+ def offense_message(arguments); end
149
+ def on_send(node); end
150
+ def peel_redundant_parentheses_from(arguments); end
151
+ extend RuboCop::Cop::AutoCorrector
152
+ extend RuboCop::Cop::MinitestCopRule
153
+ include RuboCop::Cop::ArgumentRangeHelper
154
+ end
155
+ class RuboCop::Cop::Minitest::AssertInstanceOf < RuboCop::Cop::Base
156
+ def autocorrect(corrector, node, arguments); end
157
+ def correct_receiver(receiver); end
158
+ def enclosed_in_redundant_parentheses?(node); end
159
+ def new_arguments(arguments); end
160
+ def offense_message(arguments); end
161
+ def on_send(node); end
162
+ def peel_redundant_parentheses_from(arguments); end
163
+ extend RuboCop::Cop::AutoCorrector
164
+ extend RuboCop::Cop::MinitestCopRule
165
+ include RuboCop::Cop::ArgumentRangeHelper
166
+ end
167
+ class RuboCop::Cop::Minitest::AssertMatch < RuboCop::Cop::Base
168
+ def autocorrect(corrector, node, arguments); end
169
+ def correct_receiver(receiver); end
170
+ def enclosed_in_redundant_parentheses?(node); end
171
+ def new_arguments(arguments); end
172
+ def offense_message(arguments); end
173
+ def on_send(node); end
174
+ def peel_redundant_parentheses_from(arguments); end
175
+ extend RuboCop::Cop::AutoCorrector
176
+ extend RuboCop::Cop::MinitestCopRule
177
+ include RuboCop::Cop::ArgumentRangeHelper
178
+ end
179
+ class RuboCop::Cop::Minitest::AssertOutput < RuboCop::Cop::Base
180
+ def find_test_case(node); end
181
+ def on_gvasgn(node); end
182
+ def references_gvar?(assertion, gvar_name); end
183
+ include RuboCop::Cop::MinitestExplorationHelpers
184
+ end
185
+ class RuboCop::Cop::Minitest::AssertPathExists < RuboCop::Cop::Base
186
+ def assert_file_exists(param0 = nil); end
187
+ def build_good_method(path, message); end
188
+ def on_send(node); end
189
+ extend RuboCop::Cop::AutoCorrector
190
+ end
191
+ class RuboCop::Cop::Minitest::AssertRespondTo < RuboCop::Cop::Base
192
+ def autocorrect(corrector, node, arguments); end
193
+ def correct_receiver(receiver); end
194
+ def enclosed_in_redundant_parentheses?(node); end
195
+ def new_arguments(arguments); end
196
+ def offense_message(arguments); end
197
+ def on_send(node); end
198
+ def peel_redundant_parentheses_from(arguments); end
199
+ extend RuboCop::Cop::AutoCorrector
200
+ extend RuboCop::Cop::MinitestCopRule
201
+ include RuboCop::Cop::ArgumentRangeHelper
202
+ end
203
+ class RuboCop::Cop::Minitest::AssertSilent < RuboCop::Cop::Base
204
+ def assert_silent_candidate?(param0 = nil); end
205
+ def empty_string?(node); end
206
+ def on_block(node); end
207
+ extend RuboCop::Cop::AutoCorrector
208
+ end
209
+ class RuboCop::Cop::Minitest::AssertTruthy < RuboCop::Cop::Base
210
+ def assert_equal_with_truthy(param0 = nil); end
211
+ def on_send(node); end
212
+ extend RuboCop::Cop::AutoCorrector
213
+ include RuboCop::Cop::ArgumentRangeHelper
214
+ end
215
+ class RuboCop::Cop::Minitest::DuplicateTestRun < RuboCop::Cop::Base
216
+ def on_class(class_node); end
217
+ def parent_class_has_test_methods?(class_node); end
218
+ def test_methods?(class_node); end
219
+ include RuboCop::Cop::MinitestExplorationHelpers
220
+ end
221
+ class RuboCop::Cop::Minitest::EmptyLineBeforeAssertionMethods < RuboCop::Cop::Base
222
+ def accept_previous_line?(previous_line_node, node); end
223
+ def assertion_method(node); end
224
+ def heredoc?(last_argument); end
225
+ def no_empty_line?(previous_line_node, node); end
226
+ def on_send(node); end
227
+ def register_offense(node, previous_line_node); end
228
+ def use_assertion_method_at_last_of_block?(node); end
229
+ def use_heredoc_argument?(node); end
230
+ extend RuboCop::Cop::AutoCorrector
231
+ include RuboCop::Cop::MinitestExplorationHelpers
232
+ include RuboCop::Cop::RangeHelp
233
+ end
234
+ class RuboCop::Cop::Minitest::GlobalExpectations < RuboCop::Cop::Base
235
+ def block_receiver?(param0 = nil); end
236
+ def method_allowed?(method); end
237
+ def on_send(node); end
238
+ def preferred_method; end
239
+ def preferred_receiver(node); end
240
+ def register_offense(node, method); end
241
+ def value_receiver?(param0 = nil); end
242
+ extend RuboCop::Cop::AutoCorrector
243
+ include RuboCop::Cop::ConfigurableEnforcedStyle
244
+ end
245
+ class RuboCop::Cop::Minitest::LiteralAsActualArgument < RuboCop::Cop::Base
246
+ def autocorrect(corrector, node, expected, actual, message); end
247
+ def on_send(node); end
248
+ extend RuboCop::Cop::AutoCorrector
249
+ include RuboCop::Cop::ArgumentRangeHelper
250
+ end
251
+ class RuboCop::Cop::Minitest::MultipleAssertions < RuboCop::Cop::Base
252
+ def assertions_count(node); end
253
+ def max_assertions; end
254
+ def on_class(class_node); end
255
+ include RuboCop::Cop::ConfigurableMax
256
+ include RuboCop::Cop::MinitestExplorationHelpers
257
+ end
258
+ class RuboCop::Cop::Minitest::NoAssertions < RuboCop::Cop::Base
259
+ def assertions_count(node); end
260
+ def on_class(class_node); end
261
+ include RuboCop::Cop::MinitestExplorationHelpers
262
+ end
263
+ class RuboCop::Cop::Minitest::RefuteEmpty < RuboCop::Cop::Base
264
+ def autocorrect(corrector, node, arguments); end
265
+ def correct_receiver(receiver); end
266
+ def enclosed_in_redundant_parentheses?(node); end
267
+ def new_arguments(arguments); end
268
+ def offense_message(arguments); end
269
+ def on_send(node); end
270
+ def peel_redundant_parentheses_from(arguments); end
271
+ extend RuboCop::Cop::AutoCorrector
272
+ extend RuboCop::Cop::MinitestCopRule
273
+ include RuboCop::Cop::ArgumentRangeHelper
274
+ end
275
+ class RuboCop::Cop::Minitest::RefuteFalse < RuboCop::Cop::Base
276
+ def assert_equal_with_false(param0 = nil); end
277
+ def assert_with_bang_argument(param0 = nil); end
278
+ def autocorrect(corrector, node, actual); end
279
+ def on_send(node); end
280
+ extend RuboCop::Cop::AutoCorrector
281
+ include RuboCop::Cop::ArgumentRangeHelper
282
+ end
283
+ class RuboCop::Cop::Minitest::RefuteEqual < RuboCop::Cop::Base
284
+ def assert_not_equal(param0 = nil); end
285
+ def on_send(node); end
286
+ def original_usage(first_part, custom_message); end
287
+ def preferred_usage(first_arg, second_arg, custom_message = nil); end
288
+ def process_not_equal(node); end
289
+ extend RuboCop::Cop::AutoCorrector
290
+ include RuboCop::Cop::ArgumentRangeHelper
291
+ end
292
+ class RuboCop::Cop::Minitest::RefuteInDelta < RuboCop::Cop::Base
293
+ def equal_floats_call(param0 = nil); end
294
+ extend RuboCop::Cop::AutoCorrector
295
+ include RuboCop::Cop::InDeltaMixin
296
+ end
297
+ class RuboCop::Cop::Minitest::RefuteKindOf < RuboCop::Cop::Base
298
+ def autocorrect(corrector, node, arguments); end
299
+ def correct_receiver(receiver); end
300
+ def enclosed_in_redundant_parentheses?(node); end
301
+ def new_arguments(arguments); end
302
+ def offense_message(arguments); end
303
+ def on_send(node); end
304
+ def peel_redundant_parentheses_from(arguments); end
305
+ extend RuboCop::Cop::AutoCorrector
306
+ extend RuboCop::Cop::MinitestCopRule
307
+ include RuboCop::Cop::ArgumentRangeHelper
308
+ end
309
+ class RuboCop::Cop::Minitest::RefuteNil < RuboCop::Cop::Base
310
+ def assertion_type; end
311
+ def nil_refutation(param0 = nil); end
312
+ def on_send(node); end
313
+ extend RuboCop::Cop::AutoCorrector
314
+ include RuboCop::Cop::ArgumentRangeHelper
315
+ include RuboCop::Cop::Minitest::NilAssertionHandleable
316
+ end
317
+ class RuboCop::Cop::Minitest::RefuteIncludes < RuboCop::Cop::Base
318
+ def autocorrect(corrector, node, arguments); end
319
+ def correct_receiver(receiver); end
320
+ def enclosed_in_redundant_parentheses?(node); end
321
+ def new_arguments(arguments); end
322
+ def offense_message(arguments); end
323
+ def on_send(node); end
324
+ def peel_redundant_parentheses_from(arguments); end
325
+ extend RuboCop::Cop::AutoCorrector
326
+ extend RuboCop::Cop::MinitestCopRule
327
+ include RuboCop::Cop::ArgumentRangeHelper
328
+ end
329
+ class RuboCop::Cop::Minitest::RefuteMatch < RuboCop::Cop::Base
330
+ def autocorrect(corrector, node, arguments); end
331
+ def correct_receiver(receiver); end
332
+ def enclosed_in_redundant_parentheses?(node); end
333
+ def new_arguments(arguments); end
334
+ def offense_message(arguments); end
335
+ def on_send(node); end
336
+ def peel_redundant_parentheses_from(arguments); end
337
+ extend RuboCop::Cop::AutoCorrector
338
+ extend RuboCop::Cop::MinitestCopRule
339
+ include RuboCop::Cop::ArgumentRangeHelper
340
+ end
341
+ class RuboCop::Cop::Minitest::RefuteInstanceOf < RuboCop::Cop::Base
342
+ def autocorrect(corrector, node, arguments); end
343
+ def correct_receiver(receiver); end
344
+ def enclosed_in_redundant_parentheses?(node); end
345
+ def new_arguments(arguments); end
346
+ def offense_message(arguments); end
347
+ def on_send(node); end
348
+ def peel_redundant_parentheses_from(arguments); end
349
+ extend RuboCop::Cop::AutoCorrector
350
+ extend RuboCop::Cop::MinitestCopRule
351
+ include RuboCop::Cop::ArgumentRangeHelper
352
+ end
353
+ class RuboCop::Cop::Minitest::RefutePathExists < RuboCop::Cop::Base
354
+ def build_good_method(path, message); end
355
+ def on_send(node); end
356
+ def refute_file_exists(param0 = nil); end
357
+ extend RuboCop::Cop::AutoCorrector
358
+ end
359
+ class RuboCop::Cop::Minitest::RefutePredicate < RuboCop::Cop::Base
360
+ def assertion_type; end
361
+ extend RuboCop::Cop::AutoCorrector
362
+ include RuboCop::Cop::ArgumentRangeHelper
363
+ include RuboCop::Cop::Minitest::PredicateAssertionHandleable
364
+ end
365
+ class RuboCop::Cop::Minitest::RefuteRespondTo < RuboCop::Cop::Base
366
+ def autocorrect(corrector, node, arguments); end
367
+ def correct_receiver(receiver); end
368
+ def enclosed_in_redundant_parentheses?(node); end
369
+ def new_arguments(arguments); end
370
+ def offense_message(arguments); end
371
+ def on_send(node); end
372
+ def peel_redundant_parentheses_from(arguments); end
373
+ extend RuboCop::Cop::AutoCorrector
374
+ extend RuboCop::Cop::MinitestCopRule
375
+ include RuboCop::Cop::ArgumentRangeHelper
376
+ end
377
+ class RuboCop::Cop::Minitest::SkipEnsure < RuboCop::Cop::Base
378
+ def find_skip(node); end
379
+ def on_ensure(node); end
380
+ def use_skip_in_rescue?(skip_method); end
381
+ def valid_conditional_skip?(skip_method, ensure_node); end
382
+ end
383
+ class RuboCop::Cop::Minitest::SkipWithoutReason < RuboCop::Cop::Base
384
+ def blank_argument?(node); end
385
+ def conditional_parent(node); end
386
+ def on_send(node); end
387
+ def only_skip_branches?(node); end
388
+ end
389
+ class RuboCop::Cop::Minitest::TestMethodName < RuboCop::Cop::Base
390
+ def class_elements(class_node); end
391
+ def offense?(node); end
392
+ def on_class(class_node); end
393
+ def public?(node); end
394
+ def test_method_name?(node); end
395
+ extend RuboCop::Cop::AutoCorrector
396
+ include RuboCop::Cop::DefNode
397
+ include RuboCop::Cop::MinitestExplorationHelpers
398
+ end
399
+ class RuboCop::Cop::Minitest::UnreachableAssertion < RuboCop::Cop::Base
400
+ def on_block(node); end
401
+ include RuboCop::Cop::MinitestExplorationHelpers
402
+ end
403
+ class RuboCop::Cop::Minitest::UnspecifiedException < RuboCop::Cop::Base
404
+ def on_block(block_node); end
405
+ def unspecified_exception?(node); end
406
+ end
@@ -0,0 +1,85 @@
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-rake/all/rubocop-rake.rbi
9
+ #
10
+ # rubocop-rake-0.6.0
11
+
12
+ module RuboCop
13
+ end
14
+ module RuboCop::Rake
15
+ end
16
+ class RuboCop::Rake::Error < StandardError
17
+ end
18
+ module RuboCop::Rake::Inject
19
+ def self.defaults!; end
20
+ end
21
+ module RuboCop::Cop
22
+ end
23
+ module RuboCop::Cop::Rake
24
+ end
25
+ module RuboCop::Cop::Rake::Helper
26
+ end
27
+ module RuboCop::Cop::Rake::Helper::ClassDefinition
28
+ def class_definition?(param0 = nil); end
29
+ def in_class_definition?(node); end
30
+ extend RuboCop::AST::NodePattern::Macros
31
+ extend RuboCop::Cop::Rake::Helper::ClassDefinition
32
+ end
33
+ module RuboCop::Cop::Rake::Helper::OnTask
34
+ def on_send(node); end
35
+ def task?(param0 = nil); end
36
+ extend RuboCop::AST::NodePattern::Macros
37
+ end
38
+ module RuboCop::Cop::Rake::Helper::TaskDefinition
39
+ def in_task_or_namespace?(node); end
40
+ def task_or_namespace?(param0 = nil); end
41
+ extend RuboCop::AST::NodePattern::Macros
42
+ extend RuboCop::Cop::Rake::Helper::TaskDefinition
43
+ end
44
+ module RuboCop::Cop::Rake::Helper::TaskName
45
+ def task_name(node); end
46
+ extend RuboCop::Cop::Rake::Helper::TaskName
47
+ end
48
+ module RuboCop::Cop::Rake::Helper::OnNamespace
49
+ def namespace?(param0 = nil); end
50
+ def on_send(node); end
51
+ extend RuboCop::AST::NodePattern::Macros
52
+ end
53
+ class RuboCop::Cop::Rake::ClassDefinitionInTask < RuboCop::Cop::Base
54
+ def on_class(node); end
55
+ def on_module(node); end
56
+ end
57
+ class RuboCop::Cop::Rake::Desc < RuboCop::Cop::Base
58
+ def can_insert_desc_to?(parent); end
59
+ def on_task(node); end
60
+ def parent_and_task(task_node); end
61
+ def prerequisites(param0 = nil); end
62
+ def task_with_desc?(node); end
63
+ extend RuboCop::Cop::AutoCorrector
64
+ include RuboCop::Cop::Rake::Helper::OnTask
65
+ end
66
+ class RuboCop::Cop::Rake::DuplicateTask < RuboCop::Cop::Base
67
+ def initialize(*); end
68
+ def message_for_dup(previous:, current:, task_name:); end
69
+ def namespaces(node); end
70
+ def on_task(node); end
71
+ def source_location(node); end
72
+ include RuboCop::Cop::Rake::Helper::OnTask
73
+ end
74
+ class RuboCop::Cop::Rake::DuplicateNamespace < RuboCop::Cop::Base
75
+ def initialize(*); end
76
+ def message_for_dup(previous:, current:, namespace:); end
77
+ def namespaces(node); end
78
+ def on_namespace(node); end
79
+ def source_location(node); end
80
+ include RuboCop::Cop::Rake::Helper::OnNamespace
81
+ end
82
+ class RuboCop::Cop::Rake::MethodDefinitionInTask < RuboCop::Cop::Base
83
+ def on_def(node); end
84
+ def on_defs(node); end
85
+ end
@@ -0,0 +1,218 @@
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-sorbet/all/rubocop-sorbet.rbi
9
+ #
10
+ # rubocop-sorbet-0.6.11
11
+
12
+ module RuboCop
13
+ end
14
+ module RuboCop::Sorbet
15
+ end
16
+ class RuboCop::Sorbet::Error < StandardError
17
+ end
18
+ module RuboCop::Sorbet::Inject
19
+ def self.defaults!; end
20
+ end
21
+ module RuboCop::Cop
22
+ end
23
+ module RuboCop::Cop::Sorbet
24
+ end
25
+ class RuboCop::Cop::Sorbet::BindingConstantWithoutTypeAlias < RuboCop::Cop::Cop
26
+ def autocorrect(node); end
27
+ def binding_unaliased_type?(param0 = nil); end
28
+ def dynamic_type_creation_with_block?(param0 = nil); end
29
+ def generic_parameter_decl_block_call?(param0 = nil); end
30
+ def generic_parameter_decl_call?(param0 = nil); end
31
+ def method_needing_aliasing_on_t?(param0); end
32
+ def not_dynamic_type_creation_with_block?(node); end
33
+ def not_generic_parameter_decl?(node); end
34
+ def not_nil?(node); end
35
+ def not_t_let?(node); end
36
+ def on_casgn(node); end
37
+ def t_let?(param0 = nil); end
38
+ def using_deprecated_type_alias_syntax?(param0 = nil); end
39
+ def using_type_alias?(param0 = nil); end
40
+ end
41
+ class RuboCop::Cop::Sorbet::ConstantsFromStrings < RuboCop::Cop::Cop
42
+ def constant_from_string?(param0 = nil); end
43
+ def on_send(node); end
44
+ end
45
+ class RuboCop::Cop::Sorbet::ForbidSuperclassConstLiteral < RuboCop::Cop::Cop
46
+ def not_lit_const_superclass?(param0 = nil); end
47
+ def on_class(node); end
48
+ end
49
+ class RuboCop::Cop::Sorbet::ForbidIncludeConstLiteral < RuboCop::Cop::Cop
50
+ def autocorrect(node); end
51
+ def initialize(*); end
52
+ def not_lit_const_include?(param0 = nil); end
53
+ def on_send(node); end
54
+ def used_names; end
55
+ def used_names=(arg0); end
56
+ end
57
+ class RuboCop::Cop::Sorbet::ForbidUntypedStructProps < RuboCop::Cop::Cop
58
+ def on_class(node); end
59
+ def subclass_of_t_struct?(param0 = nil); end
60
+ def t_nilable_untyped(param0 = nil); end
61
+ def t_struct(param0 = nil); end
62
+ def t_untyped(param0 = nil); end
63
+ def untyped_props(param0); end
64
+ end
65
+ class RuboCop::Cop::Sorbet::OneAncestorPerLine < RuboCop::Cop::Cop
66
+ def abstract?(param0); end
67
+ def autocorrect(node); end
68
+ def more_than_one_ancestor(param0 = nil); end
69
+ def new_ra_line(indent_count); end
70
+ def on_class(node); end
71
+ def on_module(node); end
72
+ def process_node(node); end
73
+ def requires_ancestors(param0); end
74
+ end
75
+ class RuboCop::Cop::Sorbet::CallbackConditionalsBinding < RuboCop::Cop::Cop
76
+ def autocorrect(node); end
77
+ def on_send(node); end
78
+ end
79
+ class RuboCop::Cop::Sorbet::ForbidTUnsafe < RuboCop::Cop::Cop
80
+ def on_send(node); end
81
+ def t_unsafe?(param0 = nil); end
82
+ end
83
+ class RuboCop::Cop::Sorbet::ForbidTUntyped < RuboCop::Cop::Cop
84
+ def on_send(node); end
85
+ def t_untyped?(param0 = nil); end
86
+ end
87
+ class RuboCop::Cop::Sorbet::TypeAliasName < RuboCop::Cop::Cop
88
+ def casgn_type_alias?(param0 = nil); end
89
+ def on_casgn(node); end
90
+ end
91
+ class RuboCop::Cop::Sorbet::ForbidExtendTSigHelpersInShims < RuboCop::Cop::Cop
92
+ def autocorrect(node); end
93
+ def extend_t_helpers?(param0 = nil); end
94
+ def extend_t_sig?(param0 = nil); end
95
+ def on_send(node); end
96
+ include RuboCop::Cop::RangeHelp
97
+ end
98
+ class RuboCop::Cop::Sorbet::ForbidRBIOutsideOfAllowedPaths < RuboCop::Cop::Cop
99
+ def allowed_paths; end
100
+ def investigate(processed_source); end
101
+ include RuboCop::Cop::RangeHelp
102
+ end
103
+ class RuboCop::Cop::Sorbet::SingleLineRbiClassModuleDefinitions < RuboCop::Cop::Cop
104
+ def autocorrect(node); end
105
+ def convert_newlines(source); end
106
+ def on_class(node); end
107
+ def on_module(node); end
108
+ def process_node(node); end
109
+ end
110
+ class RuboCop::Cop::Sorbet::AllowIncompatibleOverride < RuboCop::Cop::Cop
111
+ def allow_incompatible?(param0); end
112
+ def allow_incompatible_override?(param0 = nil); end
113
+ def not_nil?(node); end
114
+ def on_send(node); end
115
+ def sig?(param0); end
116
+ end
117
+ class RuboCop::Cop::Sorbet::SignatureCop < RuboCop::Cop::Cop
118
+ def allowed_recv(recv); end
119
+ def on_block(node); end
120
+ def on_signature(_); end
121
+ def signature?(param0 = nil); end
122
+ def with_runtime?(param0 = nil); end
123
+ def without_runtime?(param0 = nil); end
124
+ end
125
+ class RuboCop::Cop::Sorbet::CheckedTrueInSignature < RuboCop::Cop::Sorbet::SignatureCop
126
+ def offending_node(param0); end
127
+ def on_signature(node); end
128
+ include RuboCop::Cop::RangeHelp
129
+ end
130
+ class RuboCop::Cop::Sorbet::KeywordArgumentOrdering < RuboCop::Cop::Sorbet::SignatureCop
131
+ def check_order_for_kwoptargs(parameters); end
132
+ def on_signature(node); end
133
+ end
134
+ class RuboCop::Cop::Sorbet::SignatureBuildOrder < RuboCop::Cop::Sorbet::SignatureCop
135
+ def autocorrect(node); end
136
+ def call_chain(sig_child_node); end
137
+ def can_autocorrect?; end
138
+ def node_reparsed_with_modern_features(node); end
139
+ def on_signature(node); end
140
+ def root_call(param0); end
141
+ end
142
+ class RuboCop::Cop::Sorbet::SignatureBuildOrder::ModernBuilder < RuboCop::AST::Builder
143
+ end
144
+ class RuboCop::Cop::Sorbet::EnforceSignatures < RuboCop::Cop::Sorbet::SignatureCop
145
+ def accessor?(param0 = nil); end
146
+ def autocorrect(node); end
147
+ def check_node(node); end
148
+ def initialize(config = nil, options = nil); end
149
+ def on_def(node); end
150
+ def on_defs(node); end
151
+ def on_send(node); end
152
+ def on_signature(node); end
153
+ def param_type_placeholder; end
154
+ def return_type_placeholder; end
155
+ def scope(node); end
156
+ end
157
+ class RuboCop::Cop::Sorbet::EnforceSignatures::SigSuggestion
158
+ def generate_params; end
159
+ def generate_return; end
160
+ def initialize(indent, param_placeholder, return_placeholder); end
161
+ def params; end
162
+ def params=(arg0); end
163
+ def returns; end
164
+ def returns=(arg0); end
165
+ def to_autocorrect; end
166
+ end
167
+ class RuboCop::Cop::Sorbet::ValidSigil < RuboCop::Cop::Cop
168
+ def autocorrect(_node); end
169
+ def check_sigil_present(sigil); end
170
+ def check_strictness_level(sigil, strictness); end
171
+ def check_strictness_not_empty(sigil, strictness); end
172
+ def check_strictness_valid(sigil, strictness); end
173
+ def extract_sigil(processed_source); end
174
+ def extract_strictness(sigil); end
175
+ def investigate(processed_source); end
176
+ def minimum_strictness; end
177
+ def require_sigil_on_all_files?; end
178
+ def suggested_strictness; end
179
+ def suggested_strictness_level(minimum_strictness, suggested_strictness); end
180
+ end
181
+ class RuboCop::Cop::Sorbet::HasSigil < RuboCop::Cop::Sorbet::ValidSigil
182
+ def require_sigil_on_all_files?; end
183
+ end
184
+ class RuboCop::Cop::Sorbet::IgnoreSigil < RuboCop::Cop::Sorbet::HasSigil
185
+ def minimum_strictness; end
186
+ end
187
+ class RuboCop::Cop::Sorbet::FalseSigil < RuboCop::Cop::Sorbet::HasSigil
188
+ def minimum_strictness; end
189
+ end
190
+ class RuboCop::Cop::Sorbet::TrueSigil < RuboCop::Cop::Sorbet::HasSigil
191
+ def minimum_strictness; end
192
+ end
193
+ class RuboCop::Cop::Sorbet::StrictSigil < RuboCop::Cop::Sorbet::HasSigil
194
+ def minimum_strictness; end
195
+ end
196
+ class RuboCop::Cop::Sorbet::StrongSigil < RuboCop::Cop::Sorbet::HasSigil
197
+ def minimum_strictness; end
198
+ end
199
+ class RuboCop::Cop::Sorbet::EnforceSigilOrder < RuboCop::Cop::Sorbet::ValidSigil
200
+ def autocorrect(_node); end
201
+ def check_magic_comments_order(tokens); end
202
+ def extract_magic_comments(processed_source); end
203
+ def investigate(processed_source); end
204
+ include RuboCop::Cop::RangeHelp
205
+ end
206
+ class RuboCop::Cop::Sorbet::EnforceSingleSigil < RuboCop::Cop::Sorbet::ValidSigil
207
+ def autocorrect(_node); end
208
+ def extract_all_sigils(processed_source); end
209
+ def investigate(processed_source); end
210
+ include RuboCop::Cop::RangeHelp
211
+ end
212
+ module RuboCop::Cop::Sorbet::MutableConstantSorbetAwareBehaviour
213
+ def on_assignment(value); end
214
+ def self.prepended(base); end
215
+ end
216
+ class RuboCop::Cop::Style::MutableConstant < RuboCop::Cop::Base
217
+ def t_let(param0 = nil); end
218
+ end