class RuboCop::Cop::Lint::NumberConversion

Time.now.to_datetime.to_i
# good
@example IgnoredClasses: [Time, DateTime] (default)
10.minutes.to_i
# good
@example AllowedPatterns: [‘min*’]
10.minutes.to_i
# bad
@example AllowedPatterns: [] (default)
10.minutes.to_i
# good
@example AllowedMethods: [minutes]
10.minutes.to_i
# bad
@example AllowedMethods: [] (default)
bar.send { |i| Complex(i) }
foo.try { |i| Float(i) }
[‘1’, ‘2’, ‘3’].map { |i| Integer(i, 10) }
Rational(‘1/3’)
Complex(‘10’)
Float(‘10.2’)
Integer(‘10’, 10)
# good
bar.send(:to_c)
foo.try(:to_f)
[‘1’, ‘2’, ‘3’].map(&:to_i)
‘1/3’.to_r
’10’.to_c
’10.2’.to_f
’10’.to_i
# bad
@example
input if it is not a standard class.
replacement ‘Kernel` methods are able to properly handle the
Autocorrection is unsafe because it is not guaranteed that the
@safety
there are no methods to allowed.
with `Integer()` and can be allowed with `AllowedMethods`. By default,
cop by default). Similarly, Rails’ duration methods do not work well
method (for instance, ‘Time` and `DateTime` values are allowed by this
NOTE: Some values cannot be converted properly using one of the `Kernel`
always correct to raise if a value is not numeric.
As such, this cop is disabled by default because it’s not necessarily
`to_i`, etc. will try to convert regardless of input (‘”.to_i => 0`).
if given input that is not numeric (eg. an empty string), whereas
Conversion with `Integer`, `Float`, etc. will raise an `ArgumentError`
fails. Cop prefer parsing with number class instead.
number conversion can cause unexpected error if auto type conversion
Warns the usage of unsafe number conversions. Unsafe

def allow_receiver?(receiver) 

def allow_receiver?(receiver)
  if receiver.numeric_type? || (receiver.send_type? &&
    (conversion_method?(receiver.method_name) ||
    allowed_method_name?(receiver.method_name)))
    true
  elsif (receiver = top_receiver(receiver))
    receiver.const_type? && ignored_class?(receiver.const_name)
  else
    false
  end
end

def allowed_method_name?(name) 

def allowed_method_name?(name)
  allowed_method?(name) || matches_allowed_pattern?(name)
end

def conversion_method?(method_name) 

def conversion_method?(method_name)
  CONVERSION_METHODS.include?(method_name)
end

def correct_method(node, receiver) 

def correct_method(node, receiver)
  format(CONVERSION_METHOD_CLASS_MAPPING[node.method_name], number_object: receiver.source)
end

def correct_sym_method(to_method) 

def correct_sym_method(to_method)
  body = format(CONVERSION_METHOD_CLASS_MAPPING[to_method], number_object: 'i')
  "{ |i| #{body} }"
end

def handle_as_symbol(node) 

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 handle_conversion_method(node) 

def handle_conversion_method(node)
  to_method(node) do |receiver, to_method|
    next if receiver.nil? || allow_receiver?(receiver)
    message = format(
      MSG,
      current: "#{receiver.source}.#{to_method}",
      corrected_method: correct_method(node, receiver)
    )
    add_offense(node, message: message) do |corrector|
      next if part_of_ignored_node?(node)
      corrector.replace(node, correct_method(node, node.receiver))
      ignore_node(node)
    end
  end
end

def ignored_class?(name) 

def ignored_class?(name)
  ignored_classes.include?(name.to_s)
end

def ignored_classes 

def ignored_classes
  cop_config.fetch('IgnoredClasses', [])
end

def on_send(node) 

def on_send(node)
  handle_conversion_method(node)
  handle_as_symbol(node)
end

def remove_parentheses(corrector, node) 

def remove_parentheses(corrector, node)
  corrector.replace(node.loc.begin, ' ')
  corrector.remove(node.loc.end)
end

def top_receiver(node) 

def top_receiver(node)
  receiver = node
  receiver = receiver.receiver until receiver.receiver.nil?
  receiver
end