class RuboCop::Cop::Style::StaticClass


end
def self.class_method; end
def instance_method; end
class SomeClass
# good - has instance method
end
end
# body omitted
def some_other_method
end
# body omitted
def some_method
module_function
module SomeModule
# good
end
end
# body omitted
def self.some_other_method
end
# body omitted
def self.some_method
class SomeClass
# bad
@example
a dummy instance is instantiated from it somewhere.
for some other subclass, monkey-patched with instance methods or
This cop is marked as unsafe, because it is possible that this class is a parent
instances out of them.
replaced with a module. Classes should be used only when it makes sense to create
This cop checks for places where classes with only class methods can be

def class_convertible_to_module?(class_node) 

def class_convertible_to_module?(class_node)
  nodes = class_elements(class_node)
  return false if nodes.empty?
  nodes.all? do |node|
    node_visibility(node) == :public &&
      node.defs_type? ||
      sclass_convertible_to_module?(node) ||
      node.equals_asgn? ||
      extend_call?(node)
  end
end

def class_elements(class_node) 

def class_elements(class_node)
  class_def = class_node.body
  if !class_def
    []
  elsif class_def.begin_type?
    class_def.children
  else
    [class_def]
  end
end

def extend_call?(node) 

def extend_call?(node)
  node.send_type? && node.method?(:extend)
end

def on_class(class_node) 

def on_class(class_node)
  return if class_node.parent_class
  add_offense(class_node) if class_convertible_to_module?(class_node)
end

def sclass_convertible_to_module?(node) 

def sclass_convertible_to_module?(node)
  return false unless node.sclass_type?
  class_elements(node).all? do |child|
    node_visibility(child) == :public && (child.def_type? || child.equals_asgn?)
  end
end