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.delete_if { |e| e.nil? }
array.reject { |e| e.nil? }
array.delete_if(&: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? }`
result in false positives as well.
we can’t know the type of the receiver object for sure, which may
`nil` check of block arguments to the receiver object. Additionally,
It is unsafe by default because false positives may occur in the
@safety
and hashes can be replaced with ‘{Array,Hash}#{compact,compact!}`.
Checks for places where custom logic on rejection nils from arrays

def good_method_name(node) 

def good_method_name(node)
  if node.bang_method?
    '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))
  if (target_ruby_version <= 3.0 || node.method?(:delete_if)) && to_enum_method?(node)
    return
  end
  good = good_method_name(node)
  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.source_range.end_pos)
end

def to_enum_method?(node) 

def to_enum_method?(node)
  return false unless node.receiver.send_type?
  TO_ENUM_METHODS.include?(node.receiver.method_name)
end