class RuboCop::Cop::Style::HashSyntax

This cop checks hash literal syntax.

It can enforce either the use of the class hash rocket syntax or the use of the newer Ruby 1.9 syntax (when applicable).

A separate offense is registered for each problematic pair.

The supported styles are:

@example EnforcedStyle: ruby19 (default)

# bad
{:a => 2}
{b: 1, :c => 2}

# good
{a: 2, b: 1}
{:c => 2, 'd' => 2} # acceptable since 'd' isn't a symbol
{d: 1, 'e' => 2} # technically not forbidden

@example EnforcedStyle: hash_rockets

# bad
{a: 1, b: 2}
{c: 1, 'd' => 5}

# good
{:a => 1, :b => 2}

@example EnforcedStyle: no_mixed_keys

# bad
{:a => 1, b: 2}
{c: 1, 'd' => 2}

# good
{:a => 1, :b => 2}
{c: 1, d: 2}

@example EnforcedStyle: ruby19_no_mixed_keys

# bad
{:a => 1, :b => 2}
{c: 2, 'd' => 3} # should just use hash rockets

# good
{a: 1, b: 2}
{:c => 3, 'd' => 4}

Constants

MSG_19
MSG_HASH_ROCKETS
MSG_NO_MIXED_KEYS

Public Instance Methods

alternative_style() click to toggle source
# File lib/rubocop/cop/style/hash_syntax.rb, line 119
def alternative_style
  case style
  when :hash_rockets then
    :ruby19
  when :ruby19, :ruby19_no_mixed_keys then
    :hash_rockets
  end
end
autocorrect(node) click to toggle source
# File lib/rubocop/cop/style/hash_syntax.rb, line 107
def autocorrect(node)
  lambda do |corrector|
    if style == :hash_rockets || force_hash_rockets?(node.parent.pairs)
      autocorrect_hash_rockets(corrector, node)
    elsif style == :ruby19_no_mixed_keys || style == :no_mixed_keys
      autocorrect_no_mixed_keys(corrector, node)
    else
      autocorrect_ruby19(corrector, node)
    end
  end
end
hash_rockets_check(pairs) click to toggle source
# File lib/rubocop/cop/style/hash_syntax.rb, line 85
def hash_rockets_check(pairs)
  check(pairs, ':', MSG_HASH_ROCKETS)
end
no_mixed_keys_check(pairs) click to toggle source
# File lib/rubocop/cop/style/hash_syntax.rb, line 99
def no_mixed_keys_check(pairs)
  if !sym_indices?(pairs)
    check(pairs, ':', MSG_NO_MIXED_KEYS)
  else
    check(pairs, pairs.first.inverse_delimiter, MSG_NO_MIXED_KEYS)
  end
end
on_hash(node) click to toggle source
# File lib/rubocop/cop/style/hash_syntax.rb, line 65
def on_hash(node)
  pairs = node.pairs

  return if pairs.empty?

  if style == :hash_rockets || force_hash_rockets?(pairs)
    hash_rockets_check(pairs)
  elsif style == :ruby19_no_mixed_keys
    ruby19_no_mixed_keys_check(pairs)
  elsif style == :no_mixed_keys
    no_mixed_keys_check(pairs)
  else
    ruby19_check(pairs)
  end
end
ruby19_check(pairs) click to toggle source
# File lib/rubocop/cop/style/hash_syntax.rb, line 81
def ruby19_check(pairs)
  check(pairs, '=>', MSG_19) if sym_indices?(pairs)
end
ruby19_no_mixed_keys_check(pairs) click to toggle source
# File lib/rubocop/cop/style/hash_syntax.rb, line 89
def ruby19_no_mixed_keys_check(pairs)
  if force_hash_rockets?(pairs)
    check(pairs, ':', MSG_HASH_ROCKETS)
  elsif sym_indices?(pairs)
    check(pairs, '=>', MSG_19)
  else
    check(pairs, ':', MSG_NO_MIXED_KEYS)
  end
end

Private Instance Methods

acceptable_19_syntax_symbol?(sym_name) click to toggle source
# File lib/rubocop/cop/style/hash_syntax.rb, line 140
def acceptable_19_syntax_symbol?(sym_name)
  sym_name.sub!(/\A:/, '')

  if cop_config['PreferHashRocketsForNonAlnumEndingSymbols']
    # Prefer { :production? => false } over { production?: false } and
    # similarly for other non-alnum final characters (except quotes,
    # to prefer { "x y": 1 } over { :"x y" => 1 }).
    return false unless sym_name =~ /[\p{Alnum}"']\z/
  end

  # Most hash keys can be matched against a simple regex.
  return true if sym_name =~ /\A[_a-z]\w*[?!]?\z/i

  # For more complicated hash keys, let the parser validate the syntax.
  parse("{ #{sym_name}: :foo }").valid_syntax?
end
argument_without_space?(node) click to toggle source
# File lib/rubocop/cop/style/hash_syntax.rb, line 185
def argument_without_space?(node)
  node.argument? &&
    node.loc.expression.begin_pos == node.parent.loc.selector.end_pos
end
autocorrect_hash_rockets(corrector, pair_node) click to toggle source
# File lib/rubocop/cop/style/hash_syntax.rb, line 190
def autocorrect_hash_rockets(corrector, pair_node)
  key = pair_node.key.source_range
  op = pair_node.loc.operator

  corrector.insert_after(key, pair_node.inverse_delimiter(true))
  corrector.insert_before(key, ':')
  corrector.remove(range_with_surrounding_space(range: op))
end
autocorrect_no_mixed_keys(corrector, pair_node) click to toggle source
# File lib/rubocop/cop/style/hash_syntax.rb, line 199
def autocorrect_no_mixed_keys(corrector, pair_node)
  if pair_node.colon?
    autocorrect_hash_rockets(corrector, pair_node)
  else
    autocorrect_ruby19(corrector, pair_node)
  end
end
autocorrect_ruby19(corrector, pair_node) click to toggle source
# File lib/rubocop/cop/style/hash_syntax.rb, line 170
def autocorrect_ruby19(corrector, pair_node)
  key = pair_node.key
  op = pair_node.loc.operator

  range = range_between(key.source_range.begin_pos, op.end_pos)
  range = range_with_surrounding_space(range: range, side: :right)

  space = argument_without_space?(pair_node.parent) ? ' ' : ''

  corrector.replace(
    range,
    range.source.sub(/^:(.*\S)\s*=>\s*$/, space.to_s + '\1: ')
  )
end
check(pairs, delim, msg) click to toggle source
# File lib/rubocop/cop/style/hash_syntax.rb, line 157
def check(pairs, delim, msg)
  pairs.each do |pair|
    if pair.delimiter == delim
      location = pair.source_range.begin.join(pair.loc.operator)
      add_offense(pair, location: location, message: msg) do
        opposite_style_detected
      end
    else
      correct_style_detected
    end
  end
end
force_hash_rockets?(pairs) click to toggle source
# File lib/rubocop/cop/style/hash_syntax.rb, line 207
def force_hash_rockets?(pairs)
  cop_config['UseHashRocketsWithSymbolValues'] &&
    pairs.map(&:value).any?(&:sym_type?)
end
sym_indices?(pairs) click to toggle source
# File lib/rubocop/cop/style/hash_syntax.rb, line 130
def sym_indices?(pairs)
  pairs.all? { |p| word_symbol_pair?(p) }
end
word_symbol_pair?(pair) click to toggle source
# File lib/rubocop/cop/style/hash_syntax.rb, line 134
def word_symbol_pair?(pair)
  return false unless pair.key.sym_type? || pair.key.dsym_type?

  acceptable_19_syntax_symbol?(pair.key.source)
end