forked from rubocop/rubocop
/
number_conversion.rb
161 lines (142 loc) · 5.15 KB
/
number_conversion.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
# frozen_string_literal: true
module RuboCop
module Cop
module Lint
# This cop warns the usage of unsafe number conversions. Unsafe
# number conversion can cause unexpected error if auto type conversion
# fails. Cop prefer parsing with number class instead.
#
# Conversion with `Integer`, `Float`, etc. will raise an `ArgumentError`
# if given input that is not numeric (eg. an empty string), whereas
# `to_i`, etc. will try to convert regardless of input (`''.to_i => 0`).
# As such, this cop is disabled by default because it's not necessarily
# always correct to raise if a value is not numeric.
#
# NOTE: Some values cannot be converted properly using one of the `Kernel`
# method (for instance, `Time` and `DateTime` values are allowed by this
# cop by default). Similarly, Rails' duration methods do not work well
# with `Integer()` and can be ignored with `IgnoredMethods`.
#
# @example
#
# # bad
#
# '10'.to_i
# '10.2'.to_f
# '10'.to_c
# ['1', '2', '3'].map(&:to_i)
# foo.try(:to_f)
# bar.send(:to_c)
#
# # good
#
# Integer('10', 10)
# Float('10.2')
# Complex('10')
# ['1', '2', '3'].map { |i| Integer(i, 10) }
# foo.try { |i| Float(i) }
# bar.send { |i| Complex(i) }
#
# @example IgnoredMethods: [minutes]
#
# # good
# 10.minutes.to_i
#
# @example IgnoredClasses: [Time, DateTime] (default)
#
# # good
# Time.now.to_datetime.to_i
class NumberConversion < Base
extend AutoCorrector
include IgnoredMethods
CONVERSION_METHOD_CLASS_MAPPING = {
to_i: "#{Integer.name}(%<number_object>s, 10)",
to_f: "#{Float.name}(%<number_object>s)",
to_c: "#{Complex.name}(%<number_object>s)"
}.freeze
MSG = 'Replace unsafe number conversion with number '\
'class parsing, instead of using '\
'`%<current>s`, use stricter '\
'`%<corrected_method>s`.'
CONVERSION_METHODS = %i[Integer Float Complex to_i to_f to_c].freeze
METHODS = CONVERSION_METHOD_CLASS_MAPPING.keys.map(&:inspect).join(' ')
# @!method to_method(node)
def_node_matcher :to_method, <<~PATTERN
(send $_ ${#{METHODS}})
PATTERN
# @!method to_method_symbol(node)
def_node_matcher :to_method_symbol, <<~PATTERN
{(send _ $_ ${(sym ${#{METHODS}})} ...)
(send _ $_ ${(block_pass (sym ${#{METHODS}}))} ...)}
PATTERN
def on_send(node)
handle_conversion_method(node)
handle_as_symbol(node)
end
private
def handle_conversion_method(node)
to_method(node) do |receiver, to_method|
next if receiver.nil? || ignore_receiver?(receiver)
message = format(
MSG,
current: "#{receiver.source}.#{to_method}",
corrected_method: correct_method(node, receiver)
)
add_offense(node, message: message) do |corrector|
corrector.replace(node, correct_method(node, node.receiver))
end
end
end
def handle_as_symbol(node)
to_method_symbol(node) do |receiver, sym_node, to_method|
next if receiver.nil? || !node.arguments.one?
message = format(
MSG,
current: sym_node.source,
corrected_method: correct_sym_method(to_method)
)
add_offense(node, message: message) do |corrector|
remove_parentheses(corrector, node) if node.parenthesized?
corrector.replace(sym_node, correct_sym_method(to_method))
end
end
end
def correct_method(node, receiver)
format(CONVERSION_METHOD_CLASS_MAPPING[node.method_name], number_object: receiver.source)
end
def correct_sym_method(to_method)
body = format(CONVERSION_METHOD_CLASS_MAPPING[to_method], number_object: 'i')
"{ |i| #{body} }"
end
def remove_parentheses(corrector, node)
corrector.replace(node.loc.begin, ' ')
corrector.remove(node.loc.end)
end
def ignore_receiver?(receiver)
if receiver.numeric_type? || (receiver.send_type? &&
(conversion_method?(receiver.method_name) || ignored_method?(receiver.method_name)))
true
elsif (receiver = top_receiver(receiver))
receiver.const_type? && ignored_class?(receiver.const_name)
else
false
end
end
def top_receiver(node)
receiver = node
receiver = receiver.receiver until receiver.receiver.nil?
receiver
end
def conversion_method?(method_name)
CONVERSION_METHODS.include?(method_name)
end
def ignored_classes
cop_config.fetch('IgnoredClasses', [])
end
def ignored_class?(name)
ignored_classes.include?(name.to_s)
end
end
end
end
end