class RuboCop::Cop::Style::FloatDivision

a.fdiv(b)
# good
a.to_f / b.to_f
a.to_f / b
a / b.to_f
# bad
@example EnforcedStyle: fdiv
a / b.to_f
# good
a.to_f / b.to_f
a.to_f / b
# bad
@example EnforcedStyle: right_coerce
a.to_f / b
# good
a.to_f / b.to_f
a / b.to_f
# bad
@example EnforcedStyle: left_coerce
a / b.to_f
a.to_f / b
# good
a.to_f / b.to_f
# bad
@example EnforcedStyle: single_coerce (default)
—-
a.to_f / b.to_f # Both ‘to_f` calls are required here
b = ’3.4’
a = ‘1.2’
—-
[source,ruby]

then ‘.to_f` will be removed and an error will occur.
This cop is unsafe, because if the operand variable is a string object
@safety
This cop also provides other options for code consistency.
It is recommended to either always use `fdiv` or coerce one side only.
Checks for division with integers coerced to floats.

def add_to_f_method(corrector, node) 

def add_to_f_method(corrector, node)
  corrector.insert_after(node, '.to_f') unless node.send_type? && node.method?(:to_f)
end

def correct_from_slash_to_fdiv(corrector, node, receiver, argument) 

def correct_from_slash_to_fdiv(corrector, node, receiver, argument)
  receiver_source = extract_receiver_source(receiver)
  argument_source = extract_receiver_source(argument)
  if argument.respond_to?(:parenthesized?) && !argument.parenthesized?
    argument_source = "(#{argument_source})"
  end
  corrector.replace(node, "#{receiver_source}.fdiv#{argument_source}")
end

def extract_receiver_source(node) 

def extract_receiver_source(node)
  if node.send_type? && node.method?(:to_f)
    node.receiver.source
  else
    node.source
  end
end

def message(_node) 

def message(_node)
  MESSAGES[style]
end

def offense_condition?(node) 

def offense_condition?(node)
  case style
  when :left_coerce
    right_coerce?(node)
  when :right_coerce
    left_coerce?(node)
  when :single_coerce
    both_coerce?(node)
  when :fdiv
    any_coerce?(node)
  else
    false
  end
end

def on_send(node) 

def on_send(node)
  return unless offense_condition?(node)
  add_offense(node) do |corrector|
    case style
    when :left_coerce, :single_coerce
      add_to_f_method(corrector, node.receiver)
      remove_to_f_method(corrector, node.first_argument)
    when :right_coerce
      remove_to_f_method(corrector, node.receiver)
      add_to_f_method(corrector, node.first_argument)
    when :fdiv
      correct_from_slash_to_fdiv(corrector, node, node.receiver, node.first_argument)
    end
  end
end

def remove_to_f_method(corrector, send_node) 

def remove_to_f_method(corrector, send_node)
  corrector.remove(send_node.loc.dot)
  corrector.remove(send_node.loc.selector)
end