class RuboCop::Cop::RSpec::NamedSubject

end
end
expect(subject.valid?).to be(true)
it ‘is valid’ do
subject { described_class.new }
RSpec.describe User do
# acceptable
end
it { is_expected.to be_valid }
subject { described_class.new }
RSpec.describe User do
# also good
end
end
expect(user.valid?).to be(true)
it ‘is valid’ do
subject(:user) { described_class.new }
RSpec.describe User do
# good
end
end
expect(subject.valid?).to be(true)
it ‘is valid’ do
subject(:user) { described_class.new }
RSpec.describe User do
# bad
@example ‘EnforcedStyle: named_only`
end
it { is_expected.to be_valid }
subject(:user) { described_class.new }
RSpec.describe User do
# also good
end
end
expect(user.valid?).to be(true)
it ’is valid’ do
subject(:user) { described_class.new }
RSpec.describe User do
# good
end
end
expect(subject.valid?).to be(true)
it ‘is valid’ do
subject { described_class.new }
RSpec.describe User do
# bad
@example ‘EnforcedStyle: always` (default)
subjects in shared example groups.
and `IgnoreSharedExamples` which will not report offenses for implicit
This cop can be configured in your configuration using `EnforcedStyle`,
a descriptive name.
should be the most important object in your tests so they deserve
name it using `subject(:your_subject_name) { … }`. Your test subjects
If you need to reference your test subject you should explicitly
which allows for tests like `it { is_expected.to be_valid }`.
RSpec lets you declare an “implicit subject” using `subject { … }`
Checks for explicitly referenced test subjects.

def allow_explicit_subject?(node) 

def allow_explicit_subject?(node)
  !always? && !named_only?(node)
end

def always? 

def always?
  style == :always
end

def check_explicit_subject(node) 

def check_explicit_subject(node)
  return if allow_explicit_subject?(node)
  add_offense(node.loc.selector)
end

def find_subject(block_node) 

def find_subject(block_node)
  block_node.body&.child_nodes&.find { |send_node| subject?(send_node) }
end

def ignored_shared_example?(node) 

def ignored_shared_example?(node)
  cop_config['IgnoreSharedExamples'] &&
    node.each_ancestor(:block).any?(&method(:shared_example?))
end

def named_only?(node) 

def named_only?(node)
  style == :named_only &&
    subject_definition_is_named?(node)
end

def nearest_subject(node) 

def nearest_subject(node)
  node
    .each_ancestor(:block)
    .lazy
    .map { |block_node| find_subject(block_node) }
    .find(&:itself)
end

def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler

rubocop:disable InternalAffairs/NumblockHandler 
def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
  if !example_or_hook_block?(node) || ignored_shared_example?(node)
    return
  end
  subject_usage(node) do |subject_node|
    check_explicit_subject(subject_node)
  end
end

def subject_definition_is_named?(node) 

def subject_definition_is_named?(node)
  subject = nearest_subject(node)
  subject&.send_node&.arguments?
end