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
# bad
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)
  send_node.loc.selector.end.with(
    end_pos: send_node.loc.expression.end_pos
  )
end

def check_implicit(method_send) 

def check_implicit(method_send)
  style_detected(:implicit)
  return if implicit_style?
  msg = explicit_message(nil)
  add_offense(method_send.loc.selector, message: msg) do |corrector|
    scope = "(#{style.inspect})"
    corrector.replace(argument_range(method_send), scope)
  end
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)
    msg = explicit_message(scope_name)
    add_offense(method_send, message: msg) do |corrector|
      scope = implicit_style? ? '' : "(#{style.inspect})"
      corrector.replace(argument_range(method_send), scope)
    end
  end
end