thread_weaver 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.
- checksums.yaml +7 -0
- data/.github/workflows/main.yml +19 -0
- data/.gitignore +59 -0
- data/.rspec +3 -0
- data/.vscode/settings.json +14 -0
- data/CHANGELOG.md +7 -0
- data/Gemfile +17 -0
- data/LICENSE +21 -0
- data/README.md +37 -0
- data/Rakefile +13 -0
- data/bin/console +15 -0
- data/bin/gem_smoke_test +10 -0
- data/bin/setup +8 -0
- data/examples/always_deadlocks.rb +15 -0
- data/examples/takes_a_while.rb +7 -0
- data/examples/thread_safe_nonblocking_run_at_most_once.rb +23 -0
- data/examples/thread_safe_run_at_most_once.rb +19 -0
- data/examples/thread_unsafe_run_at_most_once.rb +17 -0
- data/lib/thread_weaver.rb +15 -0
- data/lib/thread_weaver/controllable_thread.rb +177 -0
- data/lib/thread_weaver/iterative_race_detector.rb +178 -0
- data/lib/thread_weaver/thread_instruction.rb +68 -0
- data/lib/thread_weaver/version.rb +6 -0
- data/sorbet/config +2 -0
- data/sorbet/rbi/gems/ast.rbi +48 -0
- data/sorbet/rbi/gems/coderay.rbi +285 -0
- data/sorbet/rbi/gems/method_source.rbi +64 -0
- data/sorbet/rbi/gems/parallel.rbi +83 -0
- data/sorbet/rbi/gems/parser.rbi +1510 -0
- data/sorbet/rbi/gems/pry-nav.rbi +29 -0
- data/sorbet/rbi/gems/pry.rbi +1965 -0
- data/sorbet/rbi/gems/rainbow.rbi +118 -0
- data/sorbet/rbi/gems/rake.rbi +645 -0
- data/sorbet/rbi/gems/regexp_parser.rbi +920 -0
- data/sorbet/rbi/gems/rexml.rbi +589 -0
- data/sorbet/rbi/gems/rspec-core.rbi +1893 -0
- data/sorbet/rbi/gems/rspec-expectations.rbi +1148 -0
- data/sorbet/rbi/gems/rspec-mocks.rbi +1091 -0
- data/sorbet/rbi/gems/rspec-support.rbi +280 -0
- data/sorbet/rbi/gems/rspec.rbi +15 -0
- data/sorbet/rbi/gems/rubocop-ast.rbi +1351 -0
- data/sorbet/rbi/gems/rubocop-performance.rbi +471 -0
- data/sorbet/rbi/gems/rubocop.rbi +7510 -0
- data/sorbet/rbi/gems/ruby-progressbar.rbi +305 -0
- data/sorbet/rbi/gems/standard.rbi +141 -0
- data/sorbet/rbi/gems/unicode-display_width.rbi +17 -0
- data/sorbet/rbi/hidden-definitions/errors.txt +4309 -0
- data/sorbet/rbi/hidden-definitions/hidden.rbi +8622 -0
- data/sorbet/rbi/sorbet-typed/lib/rainbow/all/rainbow.rbi +276 -0
- data/sorbet/rbi/sorbet-typed/lib/rubocop-performance/~>1.6/rubocop-performance.rbi +149 -0
- data/sorbet/rbi/todo.rbi +6 -0
- data/thread_weaver.gemspec +34 -0
- metadata +111 -0
@@ -0,0 +1,471 @@
|
|
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-performance/all/rubocop-performance.rbi
|
9
|
+
#
|
10
|
+
# rubocop-performance-1.9.1
|
11
|
+
|
12
|
+
module RuboCop
|
13
|
+
end
|
14
|
+
module RuboCop::Performance
|
15
|
+
end
|
16
|
+
module RuboCop::Performance::Version
|
17
|
+
def self.document_version; end
|
18
|
+
end
|
19
|
+
module RuboCop::Performance::Inject
|
20
|
+
def self.defaults!; end
|
21
|
+
end
|
22
|
+
module RuboCop::Cop
|
23
|
+
end
|
24
|
+
module RuboCop::Cop::RegexpMetacharacter
|
25
|
+
def drop_end_metacharacter(regexp_string); end
|
26
|
+
def drop_start_metacharacter(regexp_string); end
|
27
|
+
def literal_at_end?(regexp); end
|
28
|
+
def literal_at_end_with_backslash_z?(regex_str); end
|
29
|
+
def literal_at_end_with_dollar?(regex_str); end
|
30
|
+
def literal_at_start?(regexp); end
|
31
|
+
def literal_at_start_with_backslash_a?(regex_str); end
|
32
|
+
def literal_at_start_with_caret?(regex_str); end
|
33
|
+
def safe_multiline?; end
|
34
|
+
end
|
35
|
+
module RuboCop::Cop::SortBlock
|
36
|
+
def replaceable_body?(param0 = nil, param1, param2); end
|
37
|
+
def sort_range(send, node); end
|
38
|
+
def sort_with_block?(param0 = nil); end
|
39
|
+
extend RuboCop::AST::NodePattern::Macros
|
40
|
+
include RuboCop::Cop::RangeHelp
|
41
|
+
end
|
42
|
+
module RuboCop::Cop::Performance
|
43
|
+
end
|
44
|
+
class RuboCop::Cop::Performance::AncestorsInclude < RuboCop::Cop::Base
|
45
|
+
def ancestors_include_candidate?(param0 = nil); end
|
46
|
+
def on_send(node); end
|
47
|
+
def range(node); end
|
48
|
+
extend RuboCop::Cop::AutoCorrector
|
49
|
+
include RuboCop::Cop::RangeHelp
|
50
|
+
end
|
51
|
+
class RuboCop::Cop::Performance::ArraySemiInfiniteRangeSlice < RuboCop::Cop::Base
|
52
|
+
def correction(receiver, range_node); end
|
53
|
+
def endless_range?(param0 = nil); end
|
54
|
+
def endless_range_slice?(param0 = nil); end
|
55
|
+
def on_send(node); end
|
56
|
+
extend RuboCop::Cop::AutoCorrector
|
57
|
+
extend RuboCop::Cop::TargetRubyVersion
|
58
|
+
include RuboCop::Cop::RangeHelp
|
59
|
+
end
|
60
|
+
class RuboCop::Cop::Performance::BigDecimalWithNumericArgument < RuboCop::Cop::Base
|
61
|
+
def big_decimal_with_numeric_argument?(param0 = nil); end
|
62
|
+
def on_send(node); end
|
63
|
+
def specifies_precision?(node); end
|
64
|
+
extend RuboCop::Cop::AutoCorrector
|
65
|
+
end
|
66
|
+
class RuboCop::Cop::Performance::BindCall < RuboCop::Cop::Base
|
67
|
+
def bind_with_call_method?(param0 = nil); end
|
68
|
+
def build_call_args(call_args_node); end
|
69
|
+
def correction_range(receiver, node); end
|
70
|
+
def message(bind_arg, call_args); end
|
71
|
+
def on_send(node); end
|
72
|
+
extend RuboCop::Cop::AutoCorrector
|
73
|
+
extend RuboCop::Cop::TargetRubyVersion
|
74
|
+
include RuboCop::Cop::RangeHelp
|
75
|
+
end
|
76
|
+
class RuboCop::Cop::Performance::BlockGivenWithExplicitBlock < RuboCop::Cop::Base
|
77
|
+
def on_send(node); end
|
78
|
+
def reassigns_block_arg?(param0 = nil, param1); end
|
79
|
+
extend RuboCop::Cop::AutoCorrector
|
80
|
+
end
|
81
|
+
class RuboCop::Cop::Performance::Caller < RuboCop::Cop::Base
|
82
|
+
def caller_with_scope_method?(param0 = nil); end
|
83
|
+
def int_value(node); end
|
84
|
+
def on_send(node); end
|
85
|
+
def slow_caller?(param0 = nil); end
|
86
|
+
extend RuboCop::Cop::AutoCorrector
|
87
|
+
end
|
88
|
+
class RuboCop::Cop::Performance::CaseWhenSplat < RuboCop::Cop::Base
|
89
|
+
def autocorrect(corrector, when_node); end
|
90
|
+
def indent_for(node); end
|
91
|
+
def inline_fix_branch(corrector, when_node); end
|
92
|
+
def needs_reorder?(when_node); end
|
93
|
+
def new_branch_without_then(node, new_condition); end
|
94
|
+
def new_condition_with_then(node, new_condition); end
|
95
|
+
def non_splat?(condition); end
|
96
|
+
def on_case(case_node); end
|
97
|
+
def range(node); end
|
98
|
+
def reorder_condition(corrector, when_node); end
|
99
|
+
def reordering_correction(when_node); end
|
100
|
+
def replacement(conditions); end
|
101
|
+
def splat_offenses(when_conditions); end
|
102
|
+
def when_branch_range(when_node); end
|
103
|
+
extend RuboCop::Cop::AutoCorrector
|
104
|
+
include RuboCop::Cop::Alignment
|
105
|
+
include RuboCop::Cop::RangeHelp
|
106
|
+
end
|
107
|
+
class RuboCop::Cop::Performance::Casecmp < RuboCop::Cop::Base
|
108
|
+
def build_good_method(arg, variable); end
|
109
|
+
def correction(corrector, node, method, arg, variable); end
|
110
|
+
def downcase_downcase(param0 = nil); end
|
111
|
+
def downcase_eq(param0 = nil); end
|
112
|
+
def eq_downcase(param0 = nil); end
|
113
|
+
def on_send(node); end
|
114
|
+
def take_method_apart(node); end
|
115
|
+
extend RuboCop::Cop::AutoCorrector
|
116
|
+
end
|
117
|
+
class RuboCop::Cop::Performance::CollectionLiteralInLoop < RuboCop::Cop::Base
|
118
|
+
def check_literal?(node, method); end
|
119
|
+
def enumerable_loop?(param0 = nil); end
|
120
|
+
def enumerable_method?(method_name); end
|
121
|
+
def kernel_loop?(param0 = nil); end
|
122
|
+
def keyword_loop?(type); end
|
123
|
+
def literal_class(node); end
|
124
|
+
def loop?(ancestor, node); end
|
125
|
+
def min_size; end
|
126
|
+
def node_within_enumerable_loop?(node, ancestor); end
|
127
|
+
def nonmutable_method_of_array_or_hash?(node, method); end
|
128
|
+
def on_send(node); end
|
129
|
+
def parent_is_loop?(node); end
|
130
|
+
end
|
131
|
+
class RuboCop::Cop::Performance::CompareWithBlock < RuboCop::Cop::Base
|
132
|
+
def compare?(param0 = nil); end
|
133
|
+
def compare_range(send, node); end
|
134
|
+
def message(send, method, var_a, var_b, args); end
|
135
|
+
def on_block(node); end
|
136
|
+
def replaceable_body?(param0 = nil, param1, param2); end
|
137
|
+
def slow_compare?(method, args_a, args_b); end
|
138
|
+
extend RuboCop::Cop::AutoCorrector
|
139
|
+
include RuboCop::Cop::RangeHelp
|
140
|
+
end
|
141
|
+
class RuboCop::Cop::Performance::ConstantRegexp < RuboCop::Cop::Base
|
142
|
+
def include_interpolated_const?(node); end
|
143
|
+
def on_regexp(node); end
|
144
|
+
def regexp_escape?(param0 = nil); end
|
145
|
+
def within_const_assignment?(node); end
|
146
|
+
extend RuboCop::Cop::AutoCorrector
|
147
|
+
end
|
148
|
+
class RuboCop::Cop::Performance::Count < RuboCop::Cop::Base
|
149
|
+
def autocorrect(corrector, node, selector_node, selector); end
|
150
|
+
def count_candidate?(param0 = nil); end
|
151
|
+
def eligible_node?(node); end
|
152
|
+
def on_send(node); end
|
153
|
+
def source_starting_at(node); end
|
154
|
+
extend RuboCop::Cop::AutoCorrector
|
155
|
+
include RuboCop::Cop::RangeHelp
|
156
|
+
end
|
157
|
+
class RuboCop::Cop::Performance::DeletePrefix < RuboCop::Cop::Base
|
158
|
+
def delete_prefix_candidate?(param0 = nil); end
|
159
|
+
def on_send(node); end
|
160
|
+
extend RuboCop::Cop::AutoCorrector
|
161
|
+
extend RuboCop::Cop::TargetRubyVersion
|
162
|
+
include RuboCop::Cop::RegexpMetacharacter
|
163
|
+
end
|
164
|
+
class RuboCop::Cop::Performance::DeleteSuffix < RuboCop::Cop::Base
|
165
|
+
def delete_suffix_candidate?(param0 = nil); end
|
166
|
+
def on_send(node); end
|
167
|
+
extend RuboCop::Cop::AutoCorrector
|
168
|
+
extend RuboCop::Cop::TargetRubyVersion
|
169
|
+
include RuboCop::Cop::RegexpMetacharacter
|
170
|
+
end
|
171
|
+
class RuboCop::Cop::Performance::Detect < RuboCop::Cop::Base
|
172
|
+
def accept_first_call?(receiver, body); end
|
173
|
+
def autocorrect(corrector, node, replacement); end
|
174
|
+
def detect_candidate?(param0 = nil); end
|
175
|
+
def lazy?(node); end
|
176
|
+
def message_for_method(method, index); end
|
177
|
+
def on_send(node); end
|
178
|
+
def preferred_method; end
|
179
|
+
def register_offense(node, receiver, second_method, index); end
|
180
|
+
def replacement(method, index); end
|
181
|
+
extend RuboCop::Cop::AutoCorrector
|
182
|
+
end
|
183
|
+
class RuboCop::Cop::Performance::DoubleStartEndWith < RuboCop::Cop::Base
|
184
|
+
def autocorrect(corrector, first_call_args, second_call_args, combined_args); end
|
185
|
+
def check_for_active_support_aliases?; end
|
186
|
+
def check_with_active_support_aliases(param0 = nil); end
|
187
|
+
def combine_args(first_call_args, second_call_args); end
|
188
|
+
def message(node, receiver, method, combined_args); end
|
189
|
+
def on_or(node); end
|
190
|
+
def process_source(node); end
|
191
|
+
def two_start_end_with_calls(param0 = nil); end
|
192
|
+
extend RuboCop::Cop::AutoCorrector
|
193
|
+
end
|
194
|
+
class RuboCop::Cop::Performance::EndWith < RuboCop::Cop::Base
|
195
|
+
def on_match_with_lvasgn(node); end
|
196
|
+
def on_send(node); end
|
197
|
+
def redundant_regex?(param0 = nil); end
|
198
|
+
extend RuboCop::Cop::AutoCorrector
|
199
|
+
include RuboCop::Cop::RegexpMetacharacter
|
200
|
+
end
|
201
|
+
class RuboCop::Cop::Performance::FixedSize < RuboCop::Cop::Base
|
202
|
+
def allowed_argument?(arg); end
|
203
|
+
def allowed_parent?(node); end
|
204
|
+
def allowed_variable?(var); end
|
205
|
+
def contains_double_splat?(node); end
|
206
|
+
def contains_splat?(node); end
|
207
|
+
def counter(param0 = nil); end
|
208
|
+
def non_string_argument?(node); end
|
209
|
+
def on_send(node); end
|
210
|
+
end
|
211
|
+
class RuboCop::Cop::Performance::FlatMap < RuboCop::Cop::Base
|
212
|
+
def autocorrect(corrector, node); end
|
213
|
+
def flat_map_candidate?(param0 = nil); end
|
214
|
+
def offense_for_levels(node, map_node, first_method, flatten); end
|
215
|
+
def offense_for_method(node, map_node, first_method, flatten); end
|
216
|
+
def on_send(node); end
|
217
|
+
def register_offense(node, map_node, first_method, flatten, message); end
|
218
|
+
extend RuboCop::Cop::AutoCorrector
|
219
|
+
include RuboCop::Cop::RangeHelp
|
220
|
+
end
|
221
|
+
class RuboCop::Cop::Performance::InefficientHashSearch < RuboCop::Cop::Base
|
222
|
+
def autocorrect_argument(node); end
|
223
|
+
def autocorrect_hash_expression(node); end
|
224
|
+
def autocorrect_method(node); end
|
225
|
+
def current_method(node); end
|
226
|
+
def inefficient_include?(param0 = nil); end
|
227
|
+
def message(node); end
|
228
|
+
def on_send(node); end
|
229
|
+
def use_long_method; end
|
230
|
+
extend RuboCop::Cop::AutoCorrector
|
231
|
+
end
|
232
|
+
class RuboCop::Cop::Performance::MethodObjectAsBlock < RuboCop::Cop::Base
|
233
|
+
def method_object_as_argument?(param0 = nil); end
|
234
|
+
def on_block_pass(node); end
|
235
|
+
end
|
236
|
+
class RuboCop::Cop::Performance::OpenStruct < RuboCop::Cop::Base
|
237
|
+
def on_send(node); end
|
238
|
+
def open_struct(param0 = nil); end
|
239
|
+
end
|
240
|
+
class RuboCop::Cop::Performance::RangeInclude < RuboCop::Cop::Base
|
241
|
+
def on_send(node); end
|
242
|
+
def range_include(param0 = nil); end
|
243
|
+
extend RuboCop::Cop::AutoCorrector
|
244
|
+
end
|
245
|
+
class RuboCop::Cop::Performance::IoReadlines < RuboCop::Cop::Base
|
246
|
+
def autocorrect(corrector, enumerable_call, readlines_call, receiver); end
|
247
|
+
def build_bad_method(enumerable_call); end
|
248
|
+
def build_call_args(call_args_node); end
|
249
|
+
def build_good_method(enumerable_call); end
|
250
|
+
def correction_range(enumerable_call, readlines_call); end
|
251
|
+
def offense_range(enumerable_call, readlines_call); end
|
252
|
+
def on_send(node); end
|
253
|
+
def readlines_on_class?(param0 = nil); end
|
254
|
+
def readlines_on_instance?(param0 = nil); end
|
255
|
+
extend RuboCop::Cop::AutoCorrector
|
256
|
+
include RuboCop::Cop::RangeHelp
|
257
|
+
end
|
258
|
+
class RuboCop::Cop::Performance::RedundantBlockCall < RuboCop::Cop::Base
|
259
|
+
def args_include_block_pass?(blockcall); end
|
260
|
+
def autocorrect(corrector, node); end
|
261
|
+
def blockarg_assigned?(param0, param1); end
|
262
|
+
def blockarg_calls(param0, param1); end
|
263
|
+
def blockarg_def(param0 = nil); end
|
264
|
+
def calls_to_report(argname, body); end
|
265
|
+
def on_def(node); end
|
266
|
+
extend RuboCop::Cop::AutoCorrector
|
267
|
+
end
|
268
|
+
class RuboCop::Cop::Performance::RedundantMatch < RuboCop::Cop::Base
|
269
|
+
def autocorrect(corrector, node); end
|
270
|
+
def match_call?(param0 = nil); end
|
271
|
+
def on_send(node); end
|
272
|
+
def only_truthiness_matters?(param0 = nil); end
|
273
|
+
extend RuboCop::Cop::AutoCorrector
|
274
|
+
end
|
275
|
+
class RuboCop::Cop::Performance::RedundantMerge < RuboCop::Cop::Base
|
276
|
+
def correct_multiple_elements(corrector, node, parent, new_source); end
|
277
|
+
def correct_single_element(corrector, node, new_source); end
|
278
|
+
def each_redundant_merge(node); end
|
279
|
+
def indent_width; end
|
280
|
+
def kwsplat_used?(pairs); end
|
281
|
+
def leading_spaces(node); end
|
282
|
+
def max_key_value_pairs; end
|
283
|
+
def message(node); end
|
284
|
+
def modifier_flow_control?(param0 = nil); end
|
285
|
+
def non_redundant_merge?(node, receiver, pairs); end
|
286
|
+
def non_redundant_pairs?(receiver, pairs); end
|
287
|
+
def non_redundant_value_used?(receiver, node); end
|
288
|
+
def on_send(node); end
|
289
|
+
def redundant_merge_candidate(param0 = nil); end
|
290
|
+
def rewrite_with_modifier(node, parent, new_source); end
|
291
|
+
def to_assignments(receiver, pairs); end
|
292
|
+
extend RuboCop::Cop::AutoCorrector
|
293
|
+
end
|
294
|
+
class RuboCop::Cop::Performance::RedundantMerge::EachWithObjectInspector
|
295
|
+
def each_with_object_node(param0 = nil); end
|
296
|
+
def eligible_receiver?; end
|
297
|
+
def initialize(node, receiver); end
|
298
|
+
def node; end
|
299
|
+
def receiver; end
|
300
|
+
def second_argument; end
|
301
|
+
def unwind(receiver); end
|
302
|
+
def value_used?; end
|
303
|
+
extend RuboCop::AST::NodePattern::Macros
|
304
|
+
end
|
305
|
+
class RuboCop::Cop::Performance::RedundantSortBlock < RuboCop::Cop::Base
|
306
|
+
def message(var_a, var_b); end
|
307
|
+
def on_block(node); end
|
308
|
+
extend RuboCop::Cop::AutoCorrector
|
309
|
+
include RuboCop::Cop::SortBlock
|
310
|
+
end
|
311
|
+
class RuboCop::Cop::Performance::RedundantStringChars < RuboCop::Cop::Base
|
312
|
+
def build_bad_method(method, args); end
|
313
|
+
def build_call_args(call_args_node); end
|
314
|
+
def build_good_method(method, args); end
|
315
|
+
def build_message(method, args); end
|
316
|
+
def correction_range(receiver, node); end
|
317
|
+
def offense_range(receiver, node); end
|
318
|
+
def on_send(node); end
|
319
|
+
def redundant_chars_call?(param0 = nil); end
|
320
|
+
extend RuboCop::Cop::AutoCorrector
|
321
|
+
include RuboCop::Cop::RangeHelp
|
322
|
+
end
|
323
|
+
class RuboCop::Cop::Performance::RegexpMatch < RuboCop::Cop::Base
|
324
|
+
def autocorrect(corrector, node); end
|
325
|
+
def check_condition(cond); end
|
326
|
+
def correct_operator(corrector, recv, arg, oper = nil); end
|
327
|
+
def correction_range(recv, arg); end
|
328
|
+
def find_last_match(body, range, scope_root); end
|
329
|
+
def last_match_used?(match_node); end
|
330
|
+
def last_matches(param0); end
|
331
|
+
def match_gvar?(sym); end
|
332
|
+
def match_method?(param0 = nil); end
|
333
|
+
def match_node?(param0 = nil); end
|
334
|
+
def match_operator?(param0 = nil); end
|
335
|
+
def match_threequals?(param0 = nil); end
|
336
|
+
def match_with_int_arg_method?(param0 = nil); end
|
337
|
+
def match_with_lvasgn?(node); end
|
338
|
+
def message(node); end
|
339
|
+
def modifier_form?(match_node); end
|
340
|
+
def next_match_pos(body, match_node_pos, scope_root); end
|
341
|
+
def on_case(node); end
|
342
|
+
def on_if(node); end
|
343
|
+
def range_to_search_for_last_matches(match_node, body, scope_root); end
|
344
|
+
def replace_with_match_predicate_method(corrector, recv, arg, op_range); end
|
345
|
+
def scope_body(node); end
|
346
|
+
def scope_root(node); end
|
347
|
+
def search_match_nodes(param0); end
|
348
|
+
def swap_receiver_and_arg(corrector, recv, arg); end
|
349
|
+
extend RuboCop::Cop::AutoCorrector
|
350
|
+
end
|
351
|
+
class RuboCop::Cop::Performance::ReverseEach < RuboCop::Cop::Base
|
352
|
+
def on_send(node); end
|
353
|
+
def replacement_range(node); end
|
354
|
+
def reverse_each?(param0 = nil); end
|
355
|
+
extend RuboCop::Cop::AutoCorrector
|
356
|
+
include RuboCop::Cop::RangeHelp
|
357
|
+
end
|
358
|
+
class RuboCop::Cop::Performance::ReverseFirst < RuboCop::Cop::Base
|
359
|
+
def build_bad_method(node); end
|
360
|
+
def build_good_method(node); end
|
361
|
+
def build_message(node); end
|
362
|
+
def correction_range(receiver, node); end
|
363
|
+
def on_send(node); end
|
364
|
+
def reverse_first_candidate?(param0 = nil); end
|
365
|
+
extend RuboCop::Cop::AutoCorrector
|
366
|
+
include RuboCop::Cop::RangeHelp
|
367
|
+
end
|
368
|
+
class RuboCop::Cop::Performance::Size < RuboCop::Cop::Base
|
369
|
+
def array?(param0 = nil); end
|
370
|
+
def count?(param0 = nil); end
|
371
|
+
def hash?(param0 = nil); end
|
372
|
+
def on_send(node); end
|
373
|
+
extend RuboCop::Cop::AutoCorrector
|
374
|
+
end
|
375
|
+
class RuboCop::Cop::Performance::SortReverse < RuboCop::Cop::Base
|
376
|
+
def message(var_a, var_b); end
|
377
|
+
def on_block(node); end
|
378
|
+
extend RuboCop::Cop::AutoCorrector
|
379
|
+
include RuboCop::Cop::SortBlock
|
380
|
+
end
|
381
|
+
class RuboCop::Cop::Performance::Squeeze < RuboCop::Cop::Base
|
382
|
+
def on_send(node); end
|
383
|
+
def repeating_literal?(regex_str); end
|
384
|
+
def squeeze_candidate?(param0 = nil); end
|
385
|
+
extend RuboCop::Cop::AutoCorrector
|
386
|
+
end
|
387
|
+
class RuboCop::Cop::Performance::StartWith < RuboCop::Cop::Base
|
388
|
+
def on_match_with_lvasgn(node); end
|
389
|
+
def on_send(node); end
|
390
|
+
def redundant_regex?(param0 = nil); end
|
391
|
+
extend RuboCop::Cop::AutoCorrector
|
392
|
+
include RuboCop::Cop::RegexpMetacharacter
|
393
|
+
end
|
394
|
+
class RuboCop::Cop::Performance::StringInclude < RuboCop::Cop::Base
|
395
|
+
def literal?(regex_str); end
|
396
|
+
def on_match_with_lvasgn(node); end
|
397
|
+
def on_send(node); end
|
398
|
+
def redundant_regex?(param0 = nil); end
|
399
|
+
extend RuboCop::Cop::AutoCorrector
|
400
|
+
end
|
401
|
+
class RuboCop::Cop::Performance::StringReplacement < RuboCop::Cop::Base
|
402
|
+
def accept_first_param?(first_param); end
|
403
|
+
def accept_second_param?(second_param); end
|
404
|
+
def autocorrect(corrector, node); end
|
405
|
+
def first_source(first_param); end
|
406
|
+
def message(node, first_source, second_source); end
|
407
|
+
def method_suffix(node); end
|
408
|
+
def offense(node, first_param, second_param); end
|
409
|
+
def on_send(node); end
|
410
|
+
def range(node); end
|
411
|
+
def remove_second_param(corrector, node, first_param); end
|
412
|
+
def replace_method(corrector, node, first_source, second_source, first_param); end
|
413
|
+
def replacement_method(node, first_source, second_source); end
|
414
|
+
def source_from_regex_constructor(node); end
|
415
|
+
def source_from_regex_literal(node); end
|
416
|
+
def string_replacement?(param0 = nil); end
|
417
|
+
extend RuboCop::Cop::AutoCorrector
|
418
|
+
include RuboCop::Cop::RangeHelp
|
419
|
+
end
|
420
|
+
class RuboCop::Cop::Performance::Sum < RuboCop::Cop::Base
|
421
|
+
def acc_plus_elem?(param0 = nil, param1, param2); end
|
422
|
+
def array_literal?(node); end
|
423
|
+
def autocorrect(corrector, init, range); end
|
424
|
+
def autocorrect_sum_map(corrector, sum, map, init); end
|
425
|
+
def build_block_bad_method(method, init, var_acc, var_elem, body); end
|
426
|
+
def build_block_message(send, init, var_acc, var_elem, body); end
|
427
|
+
def build_good_method(init, block_pass = nil); end
|
428
|
+
def build_method_bad_method(init, method, operation); end
|
429
|
+
def build_method_message(node, method, init, operation); end
|
430
|
+
def build_sum_map_message(method, init); end
|
431
|
+
def elem_plus_acc?(param0 = nil, param1, param2); end
|
432
|
+
def empty_array_literal?(node); end
|
433
|
+
def handle_sum_candidate(node); end
|
434
|
+
def handle_sum_map_candidate(node); end
|
435
|
+
def method_call_with_args_range(node); end
|
436
|
+
def on_block(node); end
|
437
|
+
def on_send(node); end
|
438
|
+
def sum_block_range(send, node); end
|
439
|
+
def sum_candidate?(param0 = nil); end
|
440
|
+
def sum_map_candidate?(param0 = nil); end
|
441
|
+
def sum_map_range(map, sum); end
|
442
|
+
def sum_method_range(node); end
|
443
|
+
def sum_with_block_candidate?(param0 = nil); end
|
444
|
+
extend RuboCop::Cop::AutoCorrector
|
445
|
+
include RuboCop::Cop::RangeHelp
|
446
|
+
end
|
447
|
+
class RuboCop::Cop::Performance::TimesMap < RuboCop::Cop::Base
|
448
|
+
def check(node); end
|
449
|
+
def message(map_or_collect, count); end
|
450
|
+
def on_block(node); end
|
451
|
+
def on_send(node); end
|
452
|
+
def times_map_call(param0 = nil); end
|
453
|
+
extend RuboCop::Cop::AutoCorrector
|
454
|
+
end
|
455
|
+
class RuboCop::Cop::Performance::UnfreezeString < RuboCop::Cop::Base
|
456
|
+
def dup_string?(param0 = nil); end
|
457
|
+
def on_send(node); end
|
458
|
+
def string_new?(param0 = nil); end
|
459
|
+
def string_value(node); end
|
460
|
+
extend RuboCop::Cop::AutoCorrector
|
461
|
+
end
|
462
|
+
class RuboCop::Cop::Performance::UriDefaultParser < RuboCop::Cop::Base
|
463
|
+
def on_send(node); end
|
464
|
+
def uri_parser_new?(param0 = nil); end
|
465
|
+
extend RuboCop::Cop::AutoCorrector
|
466
|
+
end
|
467
|
+
class RuboCop::Cop::Performance::ChainArrayAllocation < RuboCop::Cop::Base
|
468
|
+
def chain_array_allocation?(param0 = nil); end
|
469
|
+
def on_send(node); end
|
470
|
+
include RuboCop::Cop::RangeHelp
|
471
|
+
end
|