class RuboCop::Cop::Rails::WhereEquals

User.where(users: { name: ‘Gabe’ })
User.where(name: [‘john’, ‘jane’])
User.where(name: nil)
User.where.not(name: ‘Gabe’)
User.where(name: ‘Gabe’)
# good
User.where(‘users.name = :name’, name: ‘Gabe’)
User.where(‘name IN (:names)’, names: [‘john’, ‘jane’])
User.where(‘name IN (?)’, [‘john’, ‘jane’])
User.where(‘name IS NULL’)
User.where(‘name = :name’, name: ‘Gabe’)
User.where.not(‘name = ?’, ‘Gabe’)
User.where(‘name = ?’, ‘Gabe’)
# bad
@example
See: github.com/rubocop/rubocop-rails/issues/403<br>This cop’s autocorrection is unsafe because is may change SQL.
@safety
`where(attribute: value)‘ and `where.not(attribute: value)`.
in `where` and `where.not` can be replaced with
Identifies places where manually constructed SQL

def build_good_method(method_name, column, value) 

def build_good_method(method_name, column, value)
  if column.include?('.')
    table, column = column.split('.')
    "#{method_name}(#{table}: { #{column}: #{value} })"
  else
    "#{method_name}(#{column}: #{value})"
  end
end

def extract_column_and_value(template_node, value_node)

rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength 
def extract_column_and_value(template_node, value_node)
  value =
    case template_node.value
    when EQ_ANONYMOUS_RE, IN_ANONYMOUS_RE
      value_node&.source
    when EQ_NAMED_RE, IN_NAMED_RE
      return unless value_node&.hash_type?
      pair = value_node.pairs.find { |p| p.key.value.to_sym == Regexp.last_match(2).to_sym }
      pair.value.source
    when IS_NULL_RE
      'nil'
    else
      return
    end
  column_qualifier = Regexp.last_match(1)
  return if column_qualifier.count('.') > 1
  [column_qualifier, value]
end

def offense_range(node) 

def offense_range(node)
  range_between(node.loc.selector.begin_pos, node.source_range.end_pos)
end

def on_send(node) 

def on_send(node)
  return if node.method?(:not) && !where_not?(node)
  where_method_call?(node) do |template_node, value_node|
    value_node = value_node.first
    range = offense_range(node)
    column, value = extract_column_and_value(template_node, value_node)
    return unless value
    good_method = build_good_method(node.method_name, column, value)
    message = format(MSG, good_method: good_method)
    add_offense(range, message: message) do |corrector|
      corrector.replace(range, good_method)
    end
  end
end

def where_not?(node) 

def where_not?(node)
  return false unless (receiver = node.receiver)
  receiver.send_type? && receiver.method?(:where)
end