class RuboCop::Cop::Style::ConstantVisibility


end
MyClass = Struct.new()
class Foo
# good
@example IgnoreModules: true
end
public_constant :MyClass
MyClass = Struct.new()
class Foo
# good
end
MyClass = Struct.new()
class Foo
# bad
@example IgnoreModules: false (default)
end
public_constant :BAZ
BAZ = 43
private_constant :BAR
BAR = 42
class Foo
# good
end
BAZ = 43
BAR = 42
class Foo
# bad
@example
clear, and prevents outside actors from touching private state.
class or module. Explicitly declaring a visibility makes intent more
and module constants public, which litters the public API of the
an explicit visibility declaration. By default, Ruby makes all class-
Checks that constants defined in classes and modules have

def class_or_module_scope?(node) 

def class_or_module_scope?(node)
  return false unless node.parent
  case node.parent.type
  when :begin
    class_or_module_scope?(node.parent)
  when :class, :module
    true
  end
end

def ignore_modules? 

def ignore_modules?
  cop_config.fetch('IgnoreModules', false)
end

def match_name?(name, constant_name) 

def match_name?(name, constant_name)
  name.to_sym == constant_name.to_sym
end

def module?(node) 

def module?(node)
  node.expression.class_constructor?
end

def on_casgn(node) 

def on_casgn(node)
  return unless class_or_module_scope?(node)
  return if visibility_declaration?(node)
  return if ignore_modules? && module?(node)
  add_offense(node, message: format(MSG, constant_name: node.name))
end

def visibility_declaration?(node) 

def visibility_declaration?(node)
  node.parent.each_child_node(:send).any? do |child|
    visibility_declaration_for?(child, node.name)
  end
end