Class: RuboCop::Cop::Style::SelectByRegexp

Relationships & Source Files
Super Chains via Extension / Inclusion / Inheritance
Class Chain:
self, ::RuboCop::Cop::AutoCorrector, ::RuboCop::Cop::Base, ::RuboCop::ExcludeLimit, NodePattern::Macros, RuboCop::AST::Sexp
Instance Chain:
Inherits: RuboCop::Cop::Base
Defined in: lib/rubocop/cop/style/select_by_regexp.rb


Looks for places where an subset of an Enumerable (array, range, set, etc.; see note below) is calculated based on a Regexp match, and suggests grep or grep_v instead.

Hashes do not behave as you may expect with grep, which means that hash.grep is not equivalent to hash.select. Although RuboCop is limited by static analysis, this cop attempts to avoid registering an offense when the receiver is a hash (hash literal, Hash.new, Hash#[], or to_h/to_hash).
grep and grep_v were optimized when used without a block in Ruby 3.0, but may be slower in previous versions. See https://bugs.ruby-lang.org/issues/17030


# bad (select or find_all)
array.select { |x| x.match? /regexp/ }
array.select { |x| /regexp/.match?(x) }
array.select { |x| x =~ /regexp/ }
array.select { |x| /regexp/ =~ x }

# bad (reject)
array.reject { |x| x.match? /regexp/ }
array.reject { |x| /regexp/.match?(x) }
array.reject { |x| x =~ /regexp/ }
array.reject { |x| /regexp/ =~ x }

# good

Cop Safety Information:

  • Autocorrection is marked as unsafe because MatchData will not be created by grep, but may have previously been relied upon after the match? or =~ call.

    Additionally, the cop cannot guarantee that the receiver of select or reject is actually an array by static analysis, so the correction may not be actually equivalent.

Constant Summary

::RuboCop::Cop::Base - Inherited


::RuboCop::Cop::RangeHelp - Included


Class Attribute Summary

::RuboCop::Cop::AutoCorrector - Extended

::RuboCop::Cop::Base - Inherited

.gem_requirements, .lint?,

Returns if class supports autocorrect.


Override if your cop should be called repeatedly for multiple investigations Between calls to on_new_investigation and on_investigation_end, the result of processed_source will remain constant.

Class Method Summary

::RuboCop::Cop::Base - Inherited


List of cops that should not try to autocorrect at the same time as this cop.



.callbacks_needed, .cop_name, .department,

Returns an url to view this cops documentation online.


Call for abstract Cop classes.


Override and return the Force class(es) you need to join.


Returns true if the cop name or the cop namespace matches any of the given names.


Register a version requirement for the given gem name.


::RuboCop::ExcludeLimit - Extended


Sets up a configuration option to have an exclude limit tracked.


Instance Attribute Summary

Instance Method Summary

::RuboCop::Cop::RangeHelp - Included

#add_range, #column_offset_between,

A range containing only the contents of a literal with delimiters (e.g.


Returns the column attribute of the range, except if the range is on the first line and there’s a byte order mark at the beginning of that line, in which case 1 is subtracted from the column value.

#final_pos, #move_pos, #move_pos_str, #range_between, #range_by_whole_lines, #range_with_comments, #range_with_comments_and_lines, #range_with_surrounding_comma, #range_with_surrounding_space, #source_range

::RuboCop::Cop::Base - Inherited


Adds an offense that has no particular location.


Adds an offense on the specified range (or node with an expression) Unless that offense is disabled for this range, a corrector will be yielded to provide the cop the opportunity to autocorrect the offense.


Called before any investigation.


Configuration Helpers.

#cop_name, #excluded_file?,

This method should be overridden when a cop’s behavior depends on state that lives outside of these locations:


Gets called if no message is specified when calling add_offense or add_global_offense Cops are discouraged to override this; instead pass your message directly.


Alias for Base#cop_name.


Called after all on_…​


Called before all on_…​


Called instead of all on_…​


There should be very limited reasons for a Cop to do it’s own parsing.


Called between investigations.

#relevant_file?, #target_rails_version, #target_ruby_version, #annotate, #apply_correction, #attempt_correction,

Reserved for Cop::Cop.


Called to complete an investigation.

#correct, #current_corrector,

Reserved for Commissioner:

#current_offenses, #currently_disabled_lines, #custom_severity, #default_severity, #disable_uncorrectable, #enabled_line?, #file_name_matches_any?, #find_message, #find_severity, #range_for_original, #range_from_node_or_range,

Actually private methods.


::RuboCop::Cop::AutocorrectLogic - Included

::RuboCop::Cop::IgnoredNode - Included

Constructor Details

This class inherits a constructor from RuboCop::Cop::Base

Instance Method Details

#calls_lvar?(node, name)

[ GitHub ]

# File 'lib/rubocop/cop/style/select_by_regexp.rb', line 79

def_node_matcher :calls_lvar?, <<~PATTERN
    (send (lvar %1) ...)
    (send ... (lvar %1))
    (match-with-lvasgn regexp (lvar %1))


Returns true if a node appears to return a hash

[ GitHub ]

# File 'lib/rubocop/cop/style/select_by_regexp.rb', line 65

def_node_matcher :creates_hash?, <<~PATTERN
    (call (const _ :Hash) {:new :[]} ...)
    (block (call (const _ :Hash) :new ...) ...)
    (call _ { :to_h :to_hash } ...)


[ GitHub ]

# File 'lib/rubocop/cop/style/select_by_regexp.rb', line 74

def_node_matcher :env_const?, <<~PATTERN
  (const {nil? cbase} :ENV)

#extract_send_node(block_node) (private)

[ GitHub ]

# File 'lib/rubocop/cop/style/select_by_regexp.rb', line 133

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)


#find_regexp(node, block) (private)

[ GitHub ]

# File 'lib/rubocop/cop/style/select_by_regexp.rb', line 146

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.first_argument.source)
  elsif node.first_argument.lvar_type?

#match_predicate_without_receiver?(node) ⇒ Boolean (private)

[ GitHub ]

# File 'lib/rubocop/cop/style/select_by_regexp.rb', line 157

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


Alias for #on_send.

[ GitHub ]

# File 'lib/rubocop/cop/style/select_by_regexp.rb', line 103

alias on_csend on_send

#on_send(node) Also known as: #on_csend


[ GitHub ]

# File 'lib/rubocop/cop/style/select_by_regexp.rb', line 88

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)

#opposite?(regexp_method_send_node) ⇒ Boolean (private)

[ GitHub ]

# File 'lib/rubocop/cop/style/select_by_regexp.rb', line 142

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

#receiver_allowed?(node) ⇒ Boolean (private)

[ GitHub ]

# File 'lib/rubocop/cop/style/select_by_regexp.rb', line 107

def receiver_allowed?(node)
  return false unless node

  node.hash_type? || creates_hash?(node) || env_const?(node)


[ GitHub ]

# File 'lib/rubocop/cop/style/select_by_regexp.rb', line 56

def_node_matcher :regexp_match?, <<~PATTERN
    (block call (args (arg $_)) ${(send _ %REGEXP_METHODS _) match-with-lvasgn})
    (numblock call $1 ${(send _ %REGEXP_METHODS _) match-with-lvasgn})

#register_offense(node, block_node, regexp, replacement) (private)

[ GitHub ]

# File 'lib/rubocop/cop/style/select_by_regexp.rb', line 121

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})")

#replacement(regexp_method_send_node, node) (private)

[ GitHub ]

# File 'lib/rubocop/cop/style/select_by_regexp.rb', line 113

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]