-
-
Notifications
You must be signed in to change notification settings - Fork 9.3k
/
helper_functions.rb
404 lines (335 loc) 路 12.9 KB
/
helper_functions.rb
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
# typed: false
# frozen_string_literal: true
require "rubocop"
module RuboCop
module Cop
# Helper functions for cops.
#
# @api private
module HelperFunctions
include RangeHelp
# Checks for regex match of pattern in the node and
# sets the appropriate instance variables to report the match.
def regex_match_group(node, pattern)
string_repr = string_content(node).encode("UTF-8", invalid: :replace)
match_object = string_repr.match(pattern)
return unless match_object
node_begin_pos = start_column(node)
line_begin_pos = line_start_column(node)
@column = if node_begin_pos == line_begin_pos
node_begin_pos + match_object.begin(0) - line_begin_pos
else
node_begin_pos + match_object.begin(0) - line_begin_pos + 1
end
@length = match_object.to_s.length
@line_no = line_number(node)
@source_buf = source_buffer(node)
@offensive_node = node
@offensive_source_range = source_range(@source_buf, @line_no, @column, @length)
match_object
end
# Returns the begin position of the node's line in source code.
def line_start_column(node)
node.source_range.source_buffer.line_range(node.loc.line).begin_pos
end
# Returns the begin position of the node in source code.
def start_column(node)
node.source_range.begin_pos
end
# Returns the line number of the node.
def line_number(node)
node.loc.line
end
# Source buffer is required as an argument to report style violations.
def source_buffer(node)
node.source_range.source_buffer
end
# Returns the string representation if node is of type str(plain) or dstr(interpolated) or const.
def string_content(node, strip_dynamic: false)
case node.type
when :str
node.str_content
when :dstr
content = ""
node.each_child_node(:str, :begin) do |child|
content += if child.begin_type?
strip_dynamic ? "" : child.source
else
child.str_content
end
end
content
when :send
if node.method?(:+) && (node.receiver.str_type? || node.receiver.dstr_type?)
content = string_content(node.receiver)
arg = node.arguments.first
content += string_content(arg) if arg
content
else
""
end
when :const
node.const_name
when :sym
node.children.first.to_s
else
""
end
end
def problem(msg, &block)
add_offense(@offensive_node, message: msg, &block)
end
# Returns all string nodes among the descendants of given node.
def find_strings(node)
return [] if node.nil?
return [node] if node.str_type?
node.each_descendant(:str)
end
# Returns method_node matching method_name.
def find_node_method_by_name(node, method_name)
return if node.nil?
node.each_child_node(:send) do |method_node|
next unless method_node.method_name == method_name
@offensive_node = method_node
return method_node
end
# If not found then, parent node becomes the offensive node
@offensive_node = node.parent
nil
end
# Gets/sets the given node as the offending node when required in custom cops.
def offending_node(node = nil)
return @offensive_node if node.nil?
@offensive_node = node
end
# Returns an array of method call nodes matching method_name inside node with depth first order (child nodes).
def find_method_calls_by_name(node, method_name)
return if node.nil?
nodes = node.each_child_node(:send).select { |method_node| method_name == method_node.method_name }
# The top level node can be a method
nodes << node if node.send_type? && node.method_name == method_name
nodes
end
# Returns an array of method call nodes matching method_name in every descendant of node.
# Returns every method call if no method_name is passed.
def find_every_method_call_by_name(node, method_name = nil)
return if node.nil?
node.each_descendant(:send).select do |method_node|
method_name.nil? ||
method_name == method_node.method_name
end
end
# Returns array of function call nodes matching func_name in every descendant of node.
#
# - matches function call: `foo(*args, **kwargs)`
# - does not match method calls: `foo.bar(*args, **kwargs)`
# - returns every function call if no func_name is passed
def find_every_func_call_by_name(node, func_name = nil)
return if node.nil?
node.each_descendant(:send).select do |func_node|
func_node.receiver.nil? && (func_name.nil? || func_name == func_node.method_name)
end
end
# Given a method_name and arguments, yields to a block with
# matching method passed as a parameter to the block.
def find_method_with_args(node, method_name, *args)
methods = find_every_method_call_by_name(node, method_name)
methods.each do |method|
next unless parameters_passed?(method, *args)
return true unless block_given?
yield method
end
end
# Matches a method with a receiver. Yields to a block with matching method node.
#
# @example to match `Formula.factory(name)`
# find_instance_method_call(node, "Formula", :factory)
# @example to match `build.head?`
# find_instance_method_call(node, :build, :head?)
def find_instance_method_call(node, instance, method_name)
methods = find_every_method_call_by_name(node, method_name)
methods.each do |method|
next if method.receiver.nil?
next if method.receiver.const_name != instance &&
!(method.receiver.send_type? && method.receiver.method_name == instance)
@offensive_node = method
return true unless block_given?
yield method
end
end
# Matches receiver part of method. Yields to a block with parent node of receiver.
#
# @example to match `ARGV.<whatever>()`
# find_instance_call(node, "ARGV")
def find_instance_call(node, name)
node.each_descendant(:send) do |method_node|
next if method_node.receiver.nil?
next if method_node.receiver.const_name != name &&
!(method_node.receiver.send_type? && method_node.receiver.method_name == name)
@offensive_node = method_node.receiver
return true unless block_given?
yield method_node
end
end
# Find CONSTANTs in the source.
# If block given, yield matching nodes.
def find_const(node, const_name)
return if node.nil?
node.each_descendant(:const) do |const_node|
next unless const_node.const_name == const_name
@offensive_node = const_node
yield const_node if block_given?
return true
end
nil
end
# To compare node with appropriate Ruby variable.
def node_equals?(node, var)
node == Parser::CurrentRuby.parse(var.inspect)
end
# Returns a block named block_name inside node.
def find_block(node, block_name)
return if node.nil?
node.each_child_node(:block) do |block_node|
next if block_node.method_name != block_name
@offensive_node = block_node
return block_node
end
# If not found then, parent node becomes the offensive node
@offensive_node = node.parent
nil
end
# Returns an array of block nodes named block_name inside node.
def find_blocks(node, block_name)
return if node.nil?
node.each_child_node(:block).select { |block_node| block_name == block_node.method_name }
end
# Returns an array of block nodes of any depth below node in AST.
# If a block is given then yields matching block node to the block!
def find_all_blocks(node, block_name)
return if node.nil?
blocks = node.each_descendant(:block).select { |block_node| block_name == block_node.method_name }
return blocks unless block_given?
blocks.each do |block_node|
offending_node(block_node)
yield block_node
end
end
# Returns a method definition node with method_name.
# Returns first method def if method_name is nil.
def find_method_def(node, method_name = nil)
return if node.nil?
node.each_child_node(:def) do |def_node|
def_method_name = method_name(def_node)
next if method_name != def_method_name && method_name.present?
@offensive_node = def_node
return def_node
end
return if node.parent.nil?
# If not found then, parent node becomes the offensive node
@offensive_node = node.parent
nil
end
# Check if a method is called inside a block.
def method_called_in_block?(node, method_name)
block_body = node.children[2]
block_body.each_child_node(:send) do |call_node|
next unless call_node.method_name == method_name
@offensive_node = call_node
return true
end
false
end
# Check if method_name is called among the direct children nodes in the given node.
# Check if the node itself is the method.
def method_called?(node, method_name)
if node.send_type? && node.method_name == method_name
offending_node(node)
return true
end
node.each_child_node(:send) do |call_node|
next unless call_node.method_name == method_name
offending_node(call_node)
return true
end
false
end
# Check if method_name is called among every descendant node of given node.
def method_called_ever?(node, method_name)
node.each_descendant(:send) do |call_node|
next unless call_node.method_name == method_name
@offensive_node = call_node
return true
end
false
end
# Checks for precedence; returns the first pair of precedence-violating nodes.
def check_precedence(first_nodes, next_nodes)
next_nodes.each do |each_next_node|
first_nodes.each do |each_first_node|
return [each_first_node, each_next_node] if component_precedes?(each_first_node, each_next_node)
end
end
nil
end
# If first node does not precede next_node, sets appropriate instance variables for reporting.
def component_precedes?(first_node, next_node)
return false if line_number(first_node) < line_number(next_node)
@offensive_node = first_node
true
end
# Check if negation is present in the given node.
def expression_negated?(node)
return false unless node.parent&.send_type?
return false unless node.parent.method_name.equal?(:!)
offending_node(node.parent)
end
# Returns the array of arguments of the method_node.
def parameters(method_node)
method_node.arguments if method_node.send_type? || method_node.block_type?
end
# Returns true if the given parameters are present in method call
# and sets the method call as the offending node.
# Params can be string, symbol, array, hash, matching regex.
def parameters_passed?(method_node, *params)
method_params = parameters(method_node)
@offensive_node = method_node
params.all? do |given_param|
method_params.any? do |method_param|
if given_param.instance_of?(Regexp)
regex_match_group(method_param, given_param)
else
node_equals?(method_param, given_param)
end
end
end
end
# Returns the ending position of the node in source code.
def end_column(node)
node.source_range.end_pos
end
# Returns the class node's name, or nil if not a class node.
def class_name(node)
@offensive_node = node
node.const_name
end
# Returns the method name for a def node.
def method_name(node)
node.children[0] if node.def_type?
end
# Returns the node size in the source code.
def size(node)
node.source_range.size
end
# Returns the block length of the block node.
def block_size(block)
block.loc.end.line - block.loc.begin.line
end
# Returns printable component name.
def format_component(component_node)
return component_node.method_name if component_node.send_type? || component_node.block_type?
method_name(component_node) if component_node.def_type?
end
end
end
end