class RuboCop::Cop::Style::CollectionCompact


hash.compact!
# good
hash.select! { |k, v| !v.nil? }
hash.reject! { |k, v| v.nil? }
hash.reject!(&:nil?)
# bad
array.compact
# good
array.select { |e| !e.nil? }
array.reject { |e| e.nil? }
array.reject(&:nil?)
# bad
@example
when the receiver is a hash object.
and ‘[[1, 2], [3, nil]].compact` are not compatible. This will work fine
For example, `[[1, 2], [3, nil]].reject { |first, second| second.nil? }`
`nil` check of block arguments to the receiver object.
It is unsafe by default because false positives may occur in the
@safety
and hashes can be replaced with `{Array,Hash}#{compact,compact!}`.
This cop checks for places where custom logic on rejection nils from arrays

def good_method_name(method_name) 

def good_method_name(method_name)
  if method_name.to_s.end_with?('!')
    'compact!'
  else
    'compact'
  end
end

def offense_range(node) 

def offense_range(node)
  if reject_method_with_block_pass?(node)
    range(node, node)
  else
    block_node = node.parent
    return unless block_node&.block_type?
    unless (args, receiver = reject_method?(block_node) || select_method?(block_node))
      return
    end
    return unless args.last.source == receiver.source
    range(node, block_node)
  end
end

def on_send(node) 

def on_send(node)
  return unless (range = offense_range(node))
  good = good_method_name(node.method_name)
  message = format(MSG, good: good, bad: range.source)
  add_offense(range, message: message) { |corrector| corrector.replace(range, good) }
end

def range(begin_pos_node, end_pos_node) 

def range(begin_pos_node, end_pos_node)
  range_between(begin_pos_node.loc.selector.begin_pos, end_pos_node.loc.end.end_pos)
end