Class: RuboCop::Cop::Lint::NameTypo

# File 'lib/rubocop/cop/lint/name_typo.rb', line 105

def check?(key)
  project_index && defined?(DidYouMean::SpellChecker) && cop_config.fetch(key, true)
end

# File 'lib/rubocop/cop/lint/name_typo.rb', line 109

def checkable_constant?(node)
  node.namespace&.const_type? &&
    !allowed_name?(node.short_name) &&
    !definition_identifier?(node) && !defined_check?(node)
end

# File 'lib/rubocop/cop/lint/name_typo.rb', line 199

def constant_member_names(namespace)
  namespace.members.filter_map do |member|
    name = member.name
    name.split('::').last unless name.include?('#') || name.include?('<')
  end
end

# File 'lib/rubocop/cop/lint/name_typo.rb', line 131

def constant_typo_suggestion(node)
  return nil if literal_names.include?(node.short_name.to_s)

  namespace = resolve_constant_in_index(node.namespace)
  return nil unless namespace.is_a?(Rubydex::Namespace)
  return nil if namespace.find_member(node.short_name.to_s)

  spell_check(node.short_name, constant_member_names(namespace))
rescue StandardError
  nil
end

# File 'lib/rubocop/cop/lint/name_typo.rb', line 127

def defined_check?(node)
  node.each_ancestor(:defined?).any?
end

# File 'lib/rubocop/cop/lint/name_typo.rb', line 121

def definition_identifier?(node)
  node.parent&.defined_module
end

# File 'lib/rubocop/cop/lint/name_typo.rb', line 187

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
        literal.value.scan(LITERAL_IDENTIFIER_PATTERN) { |token| names << token }
      end
    end
end

# File 'lib/rubocop/cop/lint/name_typo.rb', line 206

def method_member_names(declaration)
  scopes = declaration.ancestors.filter_map { |ancestor| indexed_singleton_of(ancestor) }
  scopes << declaration

  scopes.flat_map do |scope|
    scope.members.filter_map { |member| member.name[METHOD_MEMBER_REGEXP, 1] }
  end
end

# File 'lib/rubocop/cop/lint/name_typo.rb', line 145

def method_typo_suggestion(node)
  setter = setter_call?(node)
  base = setter ? node.method_name.to_s.delete_suffix('=') : node.method_name.to_s
  return nil if literal_names.include?(base)

  declaration = unknown_method_owner(node, base)
  return nil unless declaration

  suggestion = spell_check(base, method_member_names(declaration))
  suggestion && setter ? "#{suggestion}=" : suggestion
rescue StandardError
  nil
end

# File 'lib/rubocop/cop/lint/name_typo.rb', line 71

def on_const(node)
  return unless check?('CheckConstants') && checkable_constant?(node)

  suggestion = constant_typo_suggestion(node)
  return unless suggestion

  message = format(CONSTANT_MSG, name: node.short_name,
                                 namespace: node.namespace.const_name,
                                 suggestion: suggestion)
  add_offense(node.loc.name, message: message)
end

# File 'lib/rubocop/cop/lint/name_typo.rb', line 96

alias on_csend on_send

# File 'lib/rubocop/cop/lint/name_typo.rb', line 98

def on_new_investigation
  @literal_names = nil
  super
end

# File 'lib/rubocop/cop/lint/name_typo.rb', line 83

def on_send(node)
  return unless check?('CheckMethods')
  return unless node.receiver&.const_type?
  return if allowed_name?(node.method_name) || defined_check?(node)

  suggestion = method_typo_suggestion(node)
  return unless suggestion

  message = format(METHOD_MSG, receiver: node.receiver.const_name,
                               name: node.method_name,
                               suggestion: suggestion)
  add_offense(node.loc.selector, message: message)
end

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

def responds_in_index?(declaration, name, base)
  # Instance methods of a module are also callable on the module
  # itself when exposed with `module_function`.
  [name, base].uniq.any? do |candidate|
    member_name = "#{candidate}()"
    indexed_singleton_member(declaration, member_name) ||
      declaration.find_member(member_name)
  end
end

# File 'lib/rubocop/cop/lint/name_typo.rb', line 170

def setter_call?(node)
  node.assignment_method? && !node.operator_method?
end

# File 'lib/rubocop/cop/lint/name_typo.rb', line 215

def spell_check(name, dictionary)
  return nil if dictionary.empty?

  DidYouMean::SpellChecker.new(dictionary: dictionary.uniq).correct(name.to_s).first
end

# File 'lib/rubocop/cop/lint/name_typo.rb', line 161

def unknown_method_owner(node, base)
  declaration = resolve_constant_in_index(node.receiver)
  return nil unless declaration.is_a?(Rubydex::Namespace)
  return nil if responds_in_index?(declaration, node.method_name.to_s, base)
  return nil unless fully_resolved_index_ancestry?(declaration)

  declaration
end