Class: RuboCop::Cop::Lint::SymbolConversion

# File 'lib/rubocop/cop/lint/symbol_conversion.rb', line 166

def correct_inconsistent_hash_keys(keys)
  keys.each do |key|
    ignore_node(key)

    next if requires_quotes?(key)
    next if properly_quoted?(key.source, %("#{key.value}"))

    correction = %("#{key.value}")
    register_offense(
      key,
      correction: correction,
      message: format(MSG_CONSISTENCY, correction: "#{correction}:")
    )
  end
end

# File 'lib/rubocop/cop/lint/symbol_conversion.rb', line 139

def in_alias?(node)
  node.parent&.alias_type?
end

# File 'lib/rubocop/cop/lint/symbol_conversion.rb', line 143

def in_percent_literal_array?(node)
  node.parent&.array_type? && node.parent&.percent_literal?
end

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

def on_hash(node)
  # For `EnforcedStyle: strict`, hash keys are evaluated in `on_sym`
  return unless style == :consistent

  keys = node.keys.select(&:sym_type?)

  if keys.any? { |key| requires_quotes?(key) }
    correct_inconsistent_hash_keys(keys)
  else
    # If there are no symbol keys requiring quoting,
    # treat the hash like `EnforcedStyle: strict`.
    keys.each { |key| correct_hash_key(key) }
  end
end

# File 'lib/rubocop/cop/lint/symbol_conversion.rb', line 78

def on_send(node)
  return unless node.receiver

  if node.receiver.str_type? || node.receiver.sym_type?
    register_offense(node, correction: node.receiver.value.to_sym.inspect)
  elsif node.receiver.dstr_type?
    register_offense(node, correction: ":\"#{node.receiver.value.to_sym}\"")
  end
end

# File 'lib/rubocop/cop/lint/symbol_conversion.rb', line 88

def on_sym(node)
  return if ignored_node?(node) || properly_quoted?(node.source, node.value.inspect)

  # `alias` arguments are symbols but since a symbol that requires
  # being quoted is not a valid method identifier, it can be ignored
  return if in_alias?(node)

  # The `%I[]` and `%i[]` macros are parsed as normal arrays of symbols
  # so they need to be ignored.
  return if in_percent_literal_array?(node)

  # Symbol hash keys have a different format and need to be handled separately
  return correct_hash_key(node) if hash_key?(node)

  register_offense(node, correction: node.value.inspect)
end

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

def properly_quoted?(source, value)
  return true if style == :strict && (!source.match?(/['"]/) || value.end_with?('='))

  source == value ||
    # `Symbol#inspect` uses double quotes, but allow single-quoted
    # symbols to work as well.
    source.gsub('"', '\"').tr("'", '"') == value
end

# File 'lib/rubocop/cop/lint/symbol_conversion.rb', line 122

def register_offense(node, correction:, message: format(MSG, correction: correction))
  add_offense(node, message: message) { |corrector| corrector.replace(node, correction) }
end

# File 'lib/rubocop/cop/lint/symbol_conversion.rb', line 135

def requires_quotes?(sym_node)
  sym_node.value.inspect.match?(/^:".*?"|=$/)
end