class RuboCop::Cop::Style::SelectByRegexp

array.grep_v(regexp)
array.grep(regexp)
# good
array.reject { |x| /regexp/ =~ x }
array.reject { |x| x =~ /regexp/ }
array.reject { |x| /regexp/.match?(x) }
array.reject { |x| x.match? /regexp/ }
# bad (reject)
array.select { |x| /regexp/ =~ x }
array.select { |x| x =~ /regexp/ }
array.select { |x| /regexp/.match?(x) }
array.select { |x| x.match? /regexp/ }
# bad (select or find_all)
@example
so the correction may not be actually equivalent.
‘select` or `reject` is actually an array by static analysis,
Additionally, the cop cannot guarantee that the receiver of
upon after the `match?` or `=~` call.
not be created by `grep`, but may have previously been relied
Autocorrection is marked as unsafe because `MatchData` will
@safety
See bugs.ruby-lang.org/issues/17030<br>in Ruby 3.0, but may be slower in previous versions.
NOTE: `grep` and `grep_v` were optimized when used without a block
`Hash.new`, `Hash#[]`, or `to_h`/`to_hash`).
registering an offense when the receiver is a hash (hash literal,
RuboCop is limited by static analysis, this cop attempts to avoid
means that `hash.grep` is not equivalent to `hash.select`. Although
NOTE: Hashes do not behave as you may expect with `grep`, which
match, and suggests `grep` or `grep_v` instead.
range, set, etc.; see note below) is calculated based on a `Regexp`
Looks for places where an subset of an Enumerable (array,

def extract_send_node(block_node) 

def extract_send_node(block_node)
  return unless (block_arg_name, regexp_method_send_node = regexp_match?(block_node))
  block_arg_name = :"_#{block_arg_name}" if block_node.numblock_type?
  return unless calls_lvar?(regexp_method_send_node, block_arg_name)
  regexp_method_send_node
end

def find_regexp(node, block) 

def find_regexp(node, block)
  return node.child_nodes.first if node.match_with_lvasgn_type?
  if node.receiver.lvar_type? &&
     (block.numblock_type? || node.receiver.source == block.arguments.first.source)
    node.first_argument
  elsif node.first_argument.lvar_type?
    node.receiver
  end
end

def match_predicate_without_receiver?(node) 

def match_predicate_without_receiver?(node)
  node.send_type? && node.method?(:match?) && node.receiver.nil?
end

def on_send(node)

rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity 
def on_send(node)
  return unless (block_node = node.block_node)
  return if block_node.body&.begin_type?
  return if receiver_allowed?(block_node.receiver)
  return unless (regexp_method_send_node = extract_send_node(block_node))
  return if match_predicate_without_receiver?(regexp_method_send_node)
  replacement = replacement(regexp_method_send_node, node)
  return if target_ruby_version <= 2.2 && replacement == 'grep_v'
  regexp = find_regexp(regexp_method_send_node, block_node)
  register_offense(node, block_node, regexp, replacement)
end

def opposite?(regexp_method_send_node) 

def opposite?(regexp_method_send_node)
  regexp_method_send_node.send_type? && regexp_method_send_node.method?(:!~)
end

def receiver_allowed?(node) 

def receiver_allowed?(node)
  return false unless node
  node.hash_type? || creates_hash?(node) || env_const?(node)
end

def register_offense(node, block_node, regexp, replacement) 

def register_offense(node, block_node, regexp, replacement)
  message = format(MSG, replacement: replacement, original_method: node.method_name)
  add_offense(block_node, message: message) do |corrector|
    # Only correct if it can be determined what the regexp is
    if regexp
      range = range_between(node.loc.selector.begin_pos, block_node.loc.end.end_pos)
      corrector.replace(range, "#{replacement}(#{regexp.source})")
    end
  end
end

def replacement(regexp_method_send_node, node) 

def replacement(regexp_method_send_node, node)
  opposite = opposite?(regexp_method_send_node)
  method_name = node.method_name
  opposite ? OPPOSITE_REPLACEMENTS[method_name] : REPLACEMENTS[method_name]
end