class RuboCop::Cop::RSpec::LeadingSubject


it { expect_something_else }
it { expect_something }
subject { described_class.new(params) }
# good
before { do_something }
subject { described_class.new(params) }
# good
let(:params) { blah }
subject { described_class.new(params) }
# good
it { expect_something_else }
subject { described_class.new(params) }
it { expect_something }
subject { described_class.new(params) }
before { do_something }
subject { described_class.new(params) }
let(:params) { blah }
# bad
@example
Enforce that subject is the first definition in the test.

def autocorrect(corrector, node, sibling) 

def autocorrect(corrector, node, sibling)
  RuboCop::RSpec::Corrector::MoveNode.new(
    node, corrector, processed_source
  ).move_before(sibling)
end

def check_previous_nodes(node) 

def check_previous_nodes(node)
  offending_node(node) do |offender|
    msg = format(MSG, offending: offender.method_name)
    add_offense(node, message: msg) do |corrector|
      autocorrect(corrector, node, offender)
    end
  end
end

def in_spec_block?(node) 

def in_spec_block?(node)
  node.each_ancestor(:block).any? do |ancestor|
    example?(ancestor)
  end
end

def offending?(node) 

def offending?(node)
  let?(node) ||
    hook?(node) ||
    example?(node) ||
    spec_group?(node) ||
    include?(node)
end

def offending_node(node) 

def offending_node(node)
  parent(node).each_child_node.find do |sibling|
    break if sibling.equal?(node)
    yield sibling if offending?(sibling)
  end
end

def on_block(node) 

def on_block(node)
  return unless subject?(node) && !in_spec_block?(node)
  check_previous_nodes(node)
end

def parent(node) 

def parent(node)
  node.each_ancestor(:block).first.body
end