class RuboCop::Cop::RSpec::RedundantPredicateMatcher


expect(foo).to all be(bar)
expect(foo).not_to include(bar)
expect(foo).to exist(bar)
# good
expect(foo).to be_all(bar)
expect(foo).not_to be_include(bar)
expect(foo).to be_exist(bar)
# bad
@example
Checks for redundant predicate matcher.

def message(bad_method, good_method) 

def message(bad_method, good_method)
  format(MSG, bad: bad_method, good: good_method)
end

def on_send(node) 

def on_send(node)
  return if node.parent.block_type? || node.arguments.empty?
  return unless replaceable_arguments?(node)
  method_name = node.method_name.to_s
  replaced = replaced_method_name(method_name)
  add_offense(node, message: message(method_name,
                                     replaced)) do |corrector|
    unless node.method?(:be_all)
      corrector.replace(node.loc.selector, replaced)
    end
  end
end

def replaceable_arguments?(node) 

def replaceable_arguments?(node)
  if node.method?(:be_all)
    node.first_argument.send_type?
  else
    true
  end
end

def replaced_method_name(method_name) 

def replaced_method_name(method_name)
  name = method_name.to_s.delete_prefix('be_')
  if name == 'exists'
    'exist'
  else
    name
  end
end