class RuboCop::Cop::Lint::Debugger

end
my_debugger
def some_method
# bad (ok during development)
@example DebuggerMethods: [my_debugger]
end
do_something
def some_method
# good
@example
end
do_something
byebug
def some_method
# using byebug
# bad (ok during development)
@example
end
do_something
binding.pry
def some_method
# using pry
# bad (ok during development)

@example

—-
MyDebugger.debug_this
MyDebugger:
DebuggerMethods:
Lint/Debugger:
—-
[source,yaml]

You can also add your own methods by adding a new category:
—-
WebConsole: ~
Specific default groups can be disabled if necessary:
‘Pry`, `Rails`, `RubyJard`, and `WebConsole`). Additional methods can be added.
debug entrypoints are configured (`Kernel`, `Byebug`, `Capybara`, `debug.rb`,
The cop can be configured using `DebuggerMethods`. By default, a number of gems
not be kept for production code.
Checks for debug calls (such as `debugger` or `binding.pry`) that should

def assumed_usage_context?(node) 

def assumed_usage_context?(node)
  # Basically, debugger methods are not used as a method argument without arguments.
  return false unless node.arguments.empty? && node.each_ancestor(:send, :csend).any?
  node.each_ancestor.none?(&:lambda_or_proc?)
end

def chained_method_name(send_node) 

def chained_method_name(send_node)
  chained_method_name = send_node.method_name.to_s
  receiver = send_node.receiver
  while receiver
    name = receiver.send_type? ? receiver.method_name : receiver.const_name
    chained_method_name = "#{name}.#{chained_method_name}"
    receiver = receiver.receiver
  end
  chained_method_name
end

def debugger_method?(send_node) 

def debugger_method?(send_node)
  return false if send_node.parent&.send_type? && send_node.parent.receiver == send_node
  debugger_methods.include?(chained_method_name(send_node))
end

def debugger_methods 

def debugger_methods
  @debugger_methods ||= begin
    config = cop_config.fetch('DebuggerMethods', [])
    config.is_a?(Array) ? config : config.values.flatten
  end
end

def message(node) 

def message(node)
  format(MSG, source: node.source)
end

def on_send(node) 

def on_send(node)
  return if !debugger_method?(node) || assumed_usage_context?(node)
  add_offense(node)
end