class RuboCop::Cop::Lint::InheritException

C = Class.new(StandardError)
class C < StandardError; end
# good
C = Class.new(Exception)
class C < Exception; end
# bad
@example EnforcedStyle: standard_error
C = Class.new(RuntimeError)
class C < RuntimeError; end
# good
C = Class.new(Exception)
class C < Exception; end
# bad
@example EnforcedStyle: runtime_error (default)
‘RuntimeError` (default) or `StandardError` instead.
`StandardError`. It is configurable to suggest using either
and its standard library subclasses, excluding subclasses of
This cop looks for error classes inheriting from `Exception`

def illegal_class_name?(class_node) 

def illegal_class_name?(class_node)
  ILLEGAL_CLASSES.include?(class_node.const_name)
end

def message(node) 

def message(node)
  format(MSG, prefer: preferred_base_class, current: node.const_name)
end

def on_class(node) 

def on_class(node)
  return unless node.parent_class &&
                illegal_class_name?(node.parent_class)
  message = message(node.parent_class)
  add_offense(node.parent_class, message: message) do |corrector|
    corrector.replace(node.parent_class, preferred_base_class)
  end
end

def on_send(node) 

def on_send(node)
  constant = class_new_call?(node)
  return unless constant && illegal_class_name?(constant)
  message = message(constant)
  add_offense(constant, message: message) do |corrector|
    corrector.replace(constant, preferred_base_class)
  end
end

def preferred_base_class 

def preferred_base_class
  PREFERRED_BASE_CLASS[style]
end