class RuboCop::Cop::Lint::IneffectiveAccessModifier

end
end
end
puts ‘hi’
def method
private
class << self
class C
# good
@example
end
private_class_method :method
end
puts ‘hi’
def self.method
class C
# good
@example
end
end
puts ‘hi’
def self.method
private
class C
# bad
@example
used for that.
singleton methods private/protected. ‘private_class_method` can be
applied to a singleton method. These access modifiers do not make
This cop checks for `private` or `protected` access modifiers which are

def access_modifier?(node) 

def access_modifier?(node)
  node.bare_access_modifier? && !node.method?(:module_function)
end

def check_node(node) 

def check_node(node)
  return unless node && node.begin_type?
  ignored_methods = private_class_method_names(node)
  ineffective_modifier(node, ignored_methods) do |defs_node, modifier|
    add_offense(defs_node,
                location: :keyword,
                message: format_message(modifier))
  end
end

def correct_visibility?(node, modifier, ignored_methods) 

def correct_visibility?(node, modifier, ignored_methods)
  return true if modifier.nil? || modifier.method_name == :public
  ignored_methods.include?(node.method_name)
end

def format_message(modifier) 

def format_message(modifier)
  visibility = modifier.method_name
  alternative = if visibility == :private
                  ALTERNATIVE_PRIVATE
                else
                  ALTERNATIVE_PROTECTED
                end
  format(MSG, modifier: visibility,
              line: modifier.location.expression.line,
              alternative: alternative)
end

def ineffective_modifier(node, ignored_methods, modifier = nil, &block) 

def ineffective_modifier(node, ignored_methods, modifier = nil, &block)
  node.each_child_node do |child|
    case child.type
    when :send
      modifier = child if access_modifier?(child)
    when :defs
      next if correct_visibility?(child, modifier, ignored_methods)
      yield child, modifier
    when :kwbegin
      ineffective_modifier(child, ignored_methods, modifier, &block)
    end
  end
end

def on_class(node) 

def on_class(node)
  check_node(node.children[2]) # class body
end

def on_module(node) 

def on_module(node)
  check_node(node.children[1]) # module body
end

def private_class_method_names(node) 

def private_class_method_names(node)
  private_class_methods(node).to_a.flatten
                             .select(&:basic_literal?)
                             .map(&:value)
end