class RuboCop::Cop::RSpec::ExpectActual


expect(name).to eq(“John”)
expect(pattern).to eq(/foo/)
expect(price).to eq(5)
# good
expect(“John”).to eq(name)
expect(/foo/).to eq(pattern)
expect(5).to eq(price)
# bad
@example
Checks for ‘expect(…)` calls containing literal values.

def complex_literal?(node) 

def complex_literal?(node)
  COMPLEX_LITERALS.include?(node.type) &&
    node.each_child_node.all?(&method(:literal?))
end

def literal?(node)

to not be able to match against an explicit (nil) sexp
This is not implement using a NodePattern because it seems 
def literal?(node)
  node && (simple_literal?(node) || complex_literal?(node))
end

def on_send(node) 

def on_send(node)
  expect_literal(node) do |actual, matcher, expected|
    add_offense(actual.source_range) do |corrector|
      next unless SUPPORTED_MATCHERS.include?(matcher)
      next if literal?(expected)
      swap(corrector, actual, expected)
    end
  end
end

def simple_literal?(node) 

def simple_literal?(node)
  SIMPLE_LITERALS.include?(node.type)
end

def swap(corrector, actual, expected) 

def swap(corrector, actual, expected)
  corrector.replace(actual.source_range, expected.source)
  corrector.replace(expected.source_range, actual.source)
end