# spec/rubocop/cop/my_extension/hash_literal_order_spec.rb
RSpec.describe RuboCop::Cop::MyExtension::HashLiteralOrder, :config do
  it 'autocorrects offense' do
    expect_offense(<<~TEXT)
      { b: 1, c: 1, a: 1 }
      ^^^^^^^^^^^^^^^^^^^^ Sort Hash literal entries by key.
    TEXT

    expect_correction(<<~RUBY)
      { a: 1, b: 1, c: 1 }
    RUBY
  end
end

# lib/rubocop/cop/my_extension/hash_literal_order.rb
module RuboCop
  module Cop
    module MyExtension
      # By convention, we write fairly detailed documentation for each cop
      # using YARD comments. Even official RuboCop cops do so, and the official
      # documentation site is automatically generated from these comments there.
      # e.g. https://docs.rubocop.org/rubocop/cops_layout.html
      #
      #
      # Sort Hash literal entries by key.
      #
      # @example
      #
      #   # bad
      #   {
      #     b: 1,
      #     a: 1,
      #     c: 1
      #   }
      #
      #   # good
      #   {
      #     a: 1,
      #     b: 1,
      #     c: 1
      #   }
      #
      #
      # As I mentioned previously, if you want to create `MyExtenison/HashLiteralOrder` cop,
      # the class name should be `::RuboCop::Cop::MyExtension::HashLiteralOrder`.
      # All cop classes must inherit from RuboCop::Cop::Base,
      # so here we wrote `< Base` as well.
      class HashLiteralOrder < Base

        # To support `--autocorrect` in this cop,
        # we need to extend this module.
        extend AutoCorrector

        # If you define `MSG` constant in cop class,
        # RuboCop will use it as an offense message for this cop.
        MSG = 'Sort Hash literal entries by key.'

        # RuboCop provides `def_node_matcher` to easily define pattern-matching method,
        # which takes a Symbol method name and a String AST pattern,
        # In this case, it defines `#hash_literal_order` method,
        # which takes an AST node as argument and returns a boolean value.
        #
        # For example, this method returns true for `{ a: 1, b: 2 }`,
        # and returns false for `[1, 2]` and `{ a => b }`.
        #
        # @!method hash_literal?(node)
        # @param [RuboCop::AST::HashNode] node
        # @return [Boolean]
        def_node_matcher :hash_literal?, <<~PATTERN
          (hash
            (pair
              {sym | str}
              _
            )+
          )
        PATTERN

        # This is a callback method that is called when RuboCop detects
        # a Hash node. We use this mechanism to implement the registration
        # and autocorrection of offenses when we find a code pattern that
        # we want to detect.
        #
        # The key method is `add_offense`.
        # By calling this, you can tell RuboCop that you've found an offense.
        #
        # In this case, if the keys of the target Hash node are all Symbols
        # or Strings and not sorted by name, we consider it an offense,
        # then replace the entire Hash node with a new code, which is
        # specified by the Ruby code as a String.
        #
        # @param [RuboCop::AST::HashNode] node
        def on_hash(node)
          return unless hash_literal?(node)

          return if sorted?(node)

          add_offense(node) do |corrector|
            corrector.replace(
              node,
              autocorrect(node)
            )
          end
        end

        private

        # ... some internal implementation ...
        # ... such as `#sorted?(node)`,
        # ... `#autocorrect(node)`, and so on ...
      end
    end
  end
end

(hash
  (pair
    {sym | str}
    _
  )+
)

$ gem install parser
$ echo '{ a: 1, b: 1 }' > example.rb
$ ruby-parse example.rb
(hash
  (pair
    (sym :a)
    (int 1))
  (pair
    (sym :b)
    (int 1)))

# lib/my_extension.rb
require 'rubocop/cop/my_extension/hash_literal_order'

# default.yml
MyExtension/HashLiteralOrder:
  Description: |
    Sort Hash literal entries by key.
  Enabled: true
  VersionAdded: '0.1'

$ bundle exec rubocop
Inspecting 1 files
C

Offenses:

example.rb:3:1: C: [Correctable] MyExtension/HashLiteralOrder: Sort Hash literal entries by key.
{ b: 2, a: 1, c: 3 }
^^^^^^^^^^^^^^^^^^^^

1 files inspected, 1 offense detected, 1 offense autocorrectable