class RuboCop::Cop::Performance::RedundantEqualityComparisonBlock


items.all? { |item| item.match?(pattern) }
items.all? { |item| item =~ pattern }
# bad
@example AllowRegexpMatch: false
items.all? { |item| item.match?(pattern) }
items.all? { |item| item =~ pattern }
# good
@example AllowRegexpMatch: true (default)
items.all?(Klass)
items.all?(pattern)
# good
items.all? { |item| item.kind_of?(Klass) }
items.all? { |item| item.is_a?(Klass) }
items.all? { |item| item == other }
items.all? { |item| pattern === item }
# bad
@example
This cop is unsafe because ‘===` and `==` do not always behave the same.<br>@safety<br><br>—-<br>.all?(’pattern’) # => false<br>.all? { |regexp| regexp =~ ‘pattern’ } # => true<br>.all? { |regexp| regexp.match?(‘pattern’) } # => true
—-
[source,ruby]

‘regexp.match?(’string’)‘ often used in block changes to the opposite result:
This cop has `AllowRegexpMatch` option and it is true by default because
`Range#===` returns `true` when argument is within the range.
behavior is appropriately overridden in subclass. For example,
By default, `Object#===` behaves the same as `Object#==`, but this
and `Enumerable#none?` are compared with `===` or similar methods in block.
Checks for uses `Enumerable#all?`, `Enumerable#any?`, `Enumerable#one?`,

def allow_regexp_match? 

def allow_regexp_match?
  cop_config.fetch('AllowRegexpMatch', true)
end

def new_argument(block_argument, block_body) 

def new_argument(block_argument, block_body)
  if block_argument.source == block_body.receiver.source
    rhs = block_body.first_argument
    return if use_block_argument_in_method_argument_of_operand?(block_argument, rhs)
    rhs.source
  elsif block_argument.source == block_body.first_argument.source
    lhs = block_body.receiver
    return if use_block_argument_in_method_argument_of_operand?(block_argument, lhs)
    lhs.source
  end
end

def offense_range(node) 

def offense_range(node)
  node.send_node.loc.selector.join(node.source_range.end)
end

def on_block(node) 

def on_block(node)
  return unless TARGET_METHODS.include?(node.method_name)
  return unless one_block_argument?(node.arguments)
  block_argument = node.first_argument
  return unless (block_body = node.body)
  return unless use_equality_comparison_block?(block_body)
  return if same_block_argument_and_is_a_argument?(block_body, block_argument)
  return unless (new_argument = new_argument(block_argument, block_body))
  range = offense_range(node)
  prefer = "#{node.method_name}(#{new_argument})"
  add_offense(range, message: format(MSG, prefer: prefer)) do |corrector|
    corrector.replace(range, prefer)
  end
end

def one_block_argument?(block_arguments) 

def one_block_argument?(block_arguments)
  block_arguments.one? && !block_arguments.source.include?(',')
end

def same_block_argument_and_is_a_argument?(block_body, block_argument) 

def same_block_argument_and_is_a_argument?(block_body, block_argument)
  if block_body.method?(:===)
    block_argument.source != block_body.children[2].source
  elsif IS_A_METHODS.include?(block_body.method_name)
    block_argument.source == block_body.first_argument.source
  else
    block_body.receiver.source == block_body.first_argument.receiver&.source
  end
end

def use_block_argument_in_method_argument_of_operand?(block_argument, operand) 

def use_block_argument_in_method_argument_of_operand?(block_argument, operand)
  return false unless operand.send_type?
  arguments = operand.arguments
  arguments.inject(arguments.map(&:source)) do |operand_sources, argument|
    operand_sources + argument.each_descendant(:lvar).map(&:source)
  end.any?(block_argument.source)
end

def use_equality_comparison_block?(block_body) 

def use_equality_comparison_block?(block_body)
  return false unless block_body.send_type?
  method_name = block_body.method_name
  COMPARISON_METHODS.include?(method_name) || (!allow_regexp_match? && REGEXP_METHODS.include?(method_name))
end