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

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

def bundled_gem_names
  (config.gem_versions_in_target || {}).keys - (config.path_sourced_gems_in_target || [])
end

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

def bundled_gem_namespaces
  @bundled_gem_namespaces ||= bundled_gem_names.to_set { |name| name.delete('-_').downcase }
end

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

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

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

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 155

def complete_index_members?(declaration)
  fully_resolved_index_ancestry?(declaration) && !gem_owned_namespace?(declaration)
end

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

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 138

def constant_typo_suggestion(node)
  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)
  return nil unless complete_index_members?(namespace)
  return nil if literal_names.include?(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 134

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

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

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

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

def gem_owned_namespace?(declaration)
  return false if config.for_all_cops['ProjectIndexIncludesGems']

  root = declaration.name.to_s.split('::').first.to_s
  bundled_gem_namespaces.include?(root.downcase)
end

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

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

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

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 187

def method_typo_suggestion(node)
  setter = setter_call?(node)
  base = setter ? node.method_name.to_s.delete_suffix('=') : node.method_name.to_s

  declaration = unknown_method_owner(node, base)
  return nil unless declaration
  return nil if literal_names.include?(base)

  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 78

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 103

alias on_csend on_send

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

def on_new_investigation
  @literal_names = nil
  super
end

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

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 218

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 214

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

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

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 204

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)
  return nil if gem_owned_namespace?(declaration)

  declaration
end