class RuboCop::Cop::Lint::MissingSuper


end
end
do_something
super
def self.inherited(base)
class Parent
# good
end
end
do_something
def self.inherited(base)
class Parent
# bad
end
end
@salary = salary
super(name)
def initialize(name, salary)
class Employee < Person
# good
end
end
@salary = salary
def initialize(name, salary)
class Employee < Person
# bad
@example
challenging or verbose for no actual gain.
missing method. In other cases, the theoretical ideal handling could be
because in some cases it makes sense to overtake what is considered a
This cop does not consider ‘method_missing` (and `respond_to_missing?`)
without calls to `super`.
This cop checks for the presence of constructors and lifecycle callbacks

def callback_method_def?(node) 

def callback_method_def?(node)
  return unless CALLBACKS.include?(node.method_name)
  node.each_ancestor(:class, :sclass, :module).first
end

def contains_super?(node) 

def contains_super?(node)
  node.each_descendant(:super, :zsuper).any?
end

def inside_class_with_stateful_parent?(node) 

def inside_class_with_stateful_parent?(node)
  class_node = node.each_ancestor(:class).first
  class_node&.parent_class && !stateless_class?(class_node.parent_class)
end

def offender?(node) 

def offender?(node)
  (node.method?(:initialize) || callback_method_def?(node)) && !contains_super?(node)
end

def on_def(node) 

def on_def(node)
  return unless offender?(node)
  if node.method?(:initialize) && inside_class_with_stateful_parent?(node)
    add_offense(node, message: CONSTRUCTOR_MSG)
  elsif callback_method_def?(node)
    add_offense(node, message: CALLBACK_MSG)
  end
end

def on_defs(node) 

def on_defs(node)
  return if !callback_method_def?(node) || contains_super?(node)
  add_offense(node, message: CALLBACK_MSG)
end

def stateless_class?(node) 

def stateless_class?(node)
  STATELESS_CLASSES.include?(node.const_name)
end