class RuboCop::Cop::RSpec::HookArgument

end
# …
before(:example) do
# good
end
# …
before do
# bad
end
# …
before(:each) do
# bad
@example when configuration is ‘EnforcedStyle: example`
end
# …
before(:each) do
# good
end
# …
before do
# good
end
# …
before(:example) do
# bad
@example when configuration is `EnforcedStyle: each`
end
# …
before do
# good
end
# …
before(:example) do
# bad
end
# …
before(:each) do
# bad
@example when configuration is `EnforcedStyle: implicit`
the same behavior.
styles: “implicit”, “each”, and “example.” All styles have
hooks which run for each example. There are three supported
This cop checks for consistent style when specifying RSpec
Checks the arguments passed to `before`, `around`, and `after`.

def argument_range(send_node) 

def argument_range(send_node)
  range_between(
    send_node.loc.selector.end_pos,
    send_node.loc.expression.end_pos
  )
end

def autocorrect(node) 

def autocorrect(node)
  scope = implicit_style? ? '' : "(#{style.inspect})"
  lambda do |corrector|
    corrector.replace(argument_range(node), scope)
  end
end

def check_implicit(method_send) 

def check_implicit(method_send)
  style_detected(:implicit)
  return if implicit_style?
  add_offense(
    method_send,
    location: :selector,
    message: format(EXPLICIT_MSG, scope: style)
  )
end

def explicit_message(scope) 

def explicit_message(scope)
  if implicit_style?
    format(IMPLICIT_MSG, scope: scope)
  else
    format(EXPLICIT_MSG, scope: style)
  end
end

def hook(node, &block) 

def hook(node, &block)
  scoped_hook(node, &block) || unscoped_hook(node, &block)
end

def implicit_style? 

def implicit_style?
  style.equal?(:implicit)
end

def on_block(node) 

def on_block(node)
  hook(node) do |method_send, scope_name|
    return correct_style_detected if scope_name.equal?(style)
    return check_implicit(method_send) unless scope_name
    style_detected(scope_name)
    add_offense(
      method_send,
      location: :expression,
      message: explicit_message(scope_name)
    )
  end
end