class RuboCop::Cop::Style::HashSyntax

A separate offense is registered for each problematic pair.
the use of the newer Ruby 1.9 syntax (when applicable).
It can enforce either the use of the class hash rocket syntax or
This cop checks hash literal syntax.

def autocorrect(node) 

def autocorrect(node)
  key = node.children.first.loc.expression
  op = node.loc.operator
  @corrections << lambda do |corrector|
    if style == :ruby19
      range = Parser::Source::Range.new(key.source_buffer,
                                        key.begin_pos, op.end_pos)
      range = range_with_surrounding_space(range, :right)
      corrector.replace(range,
                        range.source.sub(/^:(.*\S)\s*=>\s*$/, '\1: '))
    else
      corrector.insert_after(key, ' => ')
      corrector.insert_before(key, ':')
      corrector.remove(range_with_surrounding_space(op))
    end
  end
end

def check(pairs, delim, msg) 

def check(pairs, delim, msg)
  pairs.each do |pair|
    if pair.loc.operator && pair.loc.operator.is?(delim)
      add_offense(pair,
                  pair.loc.expression.begin.join(pair.loc.operator),
                  msg) do
        opposite_style_detected
      end
    else
      correct_style_detected
    end
  end
end

def hash_rockets_check(node) 

def hash_rockets_check(node)
  pairs = *node
  check(pairs, ':', MSG_HASH_ROCKETS)
end

def on_hash(node) 

def on_hash(node)
  style == :ruby19 ? ruby19_check(node) : hash_rockets_check(node)
end

def ruby19_check(node) 

def ruby19_check(node)
  pairs = *node
  sym_indices = pairs.all? { |p| word_symbol_pair?(p) }
  check(pairs, '=>', MSG_19) if sym_indices
end

def space_before_operator?(op, key) 

def space_before_operator?(op, key)
  op.begin_pos - key.begin_pos - key.source.length > 0
end

def word_symbol_pair?(pair) 

def word_symbol_pair?(pair)
  key, _value = *pair
  if key.type == :sym
    sym_name = key.to_a[0]
    sym_name =~ /\A[A-Za-z_]\w*\z/
  else
    false
  end
end