class RuboCop::Cop::Style::ArrayIntersect

!array1.intersect?(array2)
array1.intersect?(array2)
# good
(array1 & array2).blank?
(array1 & array2).present?
# bad
@example AllCops:ActiveSupportExtensionsEnabled: true
(array1 & array2).blank?
(array1 & array2).present?
# good
@example AllCops:ActiveSupportExtensionsEnabled: false (default)
!array1.intersect?(array2)
array1.intersect?(array2)
# good
(array1 & array2).empty?
(array1 & array2).any?
# bad
@example
actually arrays while method ‘intersect?` is for arrays only.
This cop cannot guarantee that `array1` and `array2` are
@safety
`(array1 & array2).any?` and is more readable.
The `array1.intersect?(array2)` method is faster than
can be replaced by `array1.intersect?(array2)`.
This cop identifies places where `(array1 & array2).any?`
In Ruby 3.1, `Array#intersect?` has been added.

def bad_intersection_check?(node) 

def bad_intersection_check?(node)
  if active_support_extensions_enabled?
    active_support_bad_intersection_check?(node)
  else
    regular_bad_intersection_check?(node)
  end
end

def message(receiver, argument, method_name) 

def message(receiver, argument, method_name)
  negated = straight?(method_name) ? '' : '!'
  format(
    MSG,
    negated: negated,
    receiver: receiver,
    argument: argument,
    method_name: method_name
  )
end

def on_send(node) 

def on_send(node)
  return unless (receiver, argument, method_name = bad_intersection_check?(node))
  message = message(receiver.source, argument.source, method_name)
  add_offense(node, message: message) do |corrector|
    if straight?(method_name)
      corrector.replace(node, "#{receiver.source}.intersect?(#{argument.source})")
    else
      corrector.replace(node, "!#{receiver.source}.intersect?(#{argument.source})")
    end
  end
end

def straight?(method_name) 

def straight?(method_name)
  STRAIGHT_METHODS.include?(method_name.to_sym)
end