Class: RuboCop::Cop::Lint::UnusedPrivateMethod

# File 'lib/rubocop/cop/lint/unused_private_method.rb', line 126

def checkable_declaration(node)
  return nil if IMPLICITLY_INVOKED_METHODS.include?(node.method_name)
  return nil if allowed_name?(node.method_name)
  return nil if node.each_ancestor(:any_def, :any_block, :sclass).any?
  return nil unless (namespace_node = node.each_ancestor(:class, :module).first)

  declaration = method_declaration(node, namespace_node)
  declaration if declaration&.private?
end

# File 'lib/rubocop/cop/lint/unused_private_method.rb', line 165

def compute_referenced_names
  project_index.method_references
               .to_set { |reference| reference.name.delete_suffix('()') }
end

# File 'lib/rubocop/cop/lint/unused_private_method.rb', line 203

def interpolation_prefix(node)
  return nil if node.children.all?(&:str_type?)

  leading_fragment = node.children.first
  return nil unless leading_fragment&.str_type?

  leading_fragment.value[NAME_PREFIX_PATTERN]
end

# File 'lib/rubocop/cop/lint/unused_private_method.rb', line 194

def literal_name_prefixes
  @literal_name_prefixes ||=
    processed_source.ast.each_descendant(:dsym, :dstr)
                    .with_object(Set.new) do |literal, prefixes|
      prefix = interpolation_prefix(literal)
      prefixes << prefix if prefix
    end
end

# File 'lib/rubocop/cop/lint/unused_private_method.rb', line 174

def literal_names
  @literal_names ||=
    processed_source.ast.each_descendant(:sym, :str)
                    .with_object(Set.new) do |literal, names|
      if literal.sym_type?
        names << literal.value.to_s
      else
        # `scan` raises on binary string literals with invalid byte sequences.
        value = literal.value
        value = value.scrub unless value.valid_encoding?
        value.scan(IDENTIFIER_PATTERN) { |token| names << token }
      end
    end
end

# File 'lib/rubocop/cop/lint/unused_private_method.rb', line 142

def method_declaration(node, namespace_node)
  namespace = resolve_constant_in_index(namespace_node.identifier)
  return nil unless namespace.is_a?(Rubydex::Namespace)

  namespace.member("#{node.method_name}()")
end

# File 'lib/rubocop/cop/lint/unused_private_method.rb', line 112

def on_def(node)
  return unless project_index

  declaration = checkable_declaration(node)
  return unless declaration
  return if referenced?(node.method_name)
  return if owner_with_descendants?(declaration) || override?(declaration, node.method_name)

  message = format(MSG, method: node.method_name)
  add_offense(node.loc.keyword.join(node.loc.name), message: message)
end

# File 'lib/rubocop/cop/lint/unused_private_method.rb', line 106

def on_new_investigation
  @literal_names = nil
  @literal_name_prefixes = nil
  super
end

# File 'lib/rubocop/cop/lint/unused_private_method.rb', line 223

def override?(declaration, method_name)
  owner = declaration.owner
  return false unless owner.is_a?(Rubydex::Namespace)

  owner.ancestors.any? do |ancestor|
    ancestor.name != owner.name && ancestor.member("#{method_name}()")
  end
end

# File 'lib/rubocop/cop/lint/unused_private_method.rb', line 214

def owner_with_descendants?(declaration)
  owner = declaration.owner
  return false unless owner.is_a?(Rubydex::Namespace)

  owner.descendants.any? { |descendant| descendant.name != owner.name }
end

# File 'lib/rubocop/cop/lint/unused_private_method.rb', line 149

def referenced?(method_name)
  name = method_name.to_s

  referenced_names.include?(name) || literal_names.include?(name) ||
    literal_name_prefixes.any? { |prefix| name.start_with?(prefix) }
end

# File 'lib/rubocop/cop/lint/unused_private_method.rb', line 156

def referenced_names
  index, names = self.class.cached_reference_names
  return names if index.equal?(project_index)

  compute_referenced_names.tap do |computed|
    self.class.cached_reference_names = [project_index, computed]
  end
end