class RuboCop::Cop::RSpec::DescribedClass


end
subject { MyClass.do_something }
describe MyClass do
# good
end
subject { described_class.do_something }
describe MyClass do
# bad
@example ‘EnforcedStyle: explicit`
end
subject { described_class.do_something }
describe MyClass do
# good
end
subject { MyClass.do_something }
describe MyClass do
# bad
@example `EnforcedStyle: described_class`
This cop can be configured using the `EnforcedStyle` option
each example via described_class.
If the first argument of describe is a class, the class is exposed to
Checks that tests use `described_class`.

def autocorrect(node) 

def autocorrect(node)
  replacement = if style == :described_class
                  DESCRIBED_CLASS
                else
                  @described_class.const_name
                end
  lambda do |corrector|
    corrector.replace(node.loc.expression, replacement)
  end
end

def find_usage(node, &block) 

def find_usage(node, &block)
  yield(node) if offensive?(node)
  return if scope_change?(node) || node.const_type?
  node.each_child_node do |child|
    find_usage(child, &block)
  end
end

def message(offense) 

def message(offense)
  if style == :described_class
    format(MSG, replacement: DESCRIBED_CLASS, src: offense)
  else
    format(MSG, replacement: @described_class.const_name,
                src: DESCRIBED_CLASS)
  end
end

def offensive?(node) 

def offensive?(node)
  if style == :described_class
    node.eql?(@described_class)
  else
    node.send_type? && node.method_name == :described_class
  end
end

def on_block(node) 

def on_block(node)
  # In case the explicit style is used, we needs to remember what's
  # being described. Thus, we use an ivar for @described_class.
  describe, @described_class, body = described_constant(node)
  return if body.nil?
  return unless top_level_describe?(describe)
  find_usage(body) do |match|
    add_offense(
      match,
      location: :expression,
      message: message(match.const_name)
    )
  end
end

def scope_change?(node) 

def scope_change?(node)
  scope_changing_syntax?(node)          ||
    common_instance_exec_closure?(node) ||
    skippable_block?(node)
end

def skip_blocks? 

def skip_blocks?
  cop_config['SkipBlocks'].equal?(true)
end

def skippable_block?(node) 

def skippable_block?(node)
  node.block_type? && !rspec_block?(node) && skip_blocks?
end