AstBuilder.build('1 + 1')

AstBuilder.build { s(:node_type, s(:child_node, '...')) }
=> #<AstBuilder::Builder:0x00007fe2fba18390 @ast=s(:node_type, s(:child_node, "..."))>

puts AstBuilder.build('A::B::C = 1')
(casgn
  (const
    (const nil :A) :B) :C
  (int 1))
=> nil

puts AstBuilder.build('A::B::C = ...')
AstBuilder::InvalidCode: The following node is invalid:
  'A::B::C = ...'
from /Users/baweaver/Development/ast_builder/lib/ast_builder/builder.rb:189:in 'parse'

puts AstBuilder.build { s(:casgn, expand('A::B'), :C, expand('1')) }
(casgn
  (const
    (const nil :A) :B) :C
  (int 1))
=> nil

puts AstBuilder.build { s(:casgn, expand('A::B'), :C, literal('...')) }
(casgn
  (const
    (const nil :A) :B) :C ...)
=> nil

puts AstBuilder.build { s(:casgn, expand('A::B'), :C, capture(literal('...'))) }
(casgn
  (const
    (const nil :A) :B) :C $...)
=> nil

puts AstBuilder.build { s(:casgn, expand('A::B'), :C, capture_children) }
(casgn
  (const
    (const nil :A) :B) :C $(...))
=> nil

# Matching with a block
builder = AstBuilder.build {
  assigns(:value, s(:str, capture_matching { |s| s.length > 3 }))
}

builder.match('value = "abc123"')
=> "abc123"

# Non-matching block
builder = AstBuilder.build {
  assigns(:value, s(:str, capture_matching { |s| s.length > 6 }))
}

builder.match('value = "abc123"')
=> nil

# Matching with something that responds to `===`:
builder = AstBuilder.build {
  assigns(:value, s(:str, capture_matching(/^abc/)))
}

builder.match('value = "abc123"')
=> "abc123"

AstBuilder.build { s(:casgn, expand('A::B'), :C, capture_children) }.to_cop
=> #<RuboCop::NodePattern:0x00007fe2fca004d8>

ast_builder_build = AstBuilder.build { s(:casgn, expand('A::B'), :C, capture_children) }

# Using AstBuilder to build a quick AST mock:
match_data = ast_builder_build.match(AstBuilder.build('A::B::C = 1').to_ast)
=> s(:int, 1)

# Against a string:
ast_builder_build.match('A::B::C = 1')
=> s(:int, 1)

module RuboCop
  module Cop
    # Grouping name of the Cop
    module Deprecations
      # Name of the check
      class AbcDeprecation < RuboCop::Cop::Cop

        # RuboCop takes a default message for errors
        MSG = '`A::B::C` is deprecated, use `D::E::F` instead.'

        # Saving the matcher as a constant allows for easier reuse if you use
        # autocorrect later, as well as giving a consistent theme across your
        # matchers.
        AST_MATCH = AstBuilder.build { s(:casgn, expand('A::B'), :C, capture_children) }

        # [...]

        # Node matches work with the node type you're planning to capture. In this
        # case we're trying to capture a `casgn` from the top type of the expression:
        #
        #     (casgn
        #       (const
        #         (const nil :A) :B) :C
        #       (int 1))
        #
        # RuboCop matchers are all on_(type of node) for method names.
        def on_casgn(node)
          # Unless our node matches that expression, bail out.
          return false unless AST_MATCH.match(node)

          # If it did, add an offense so RuboCop knows it's bad.
          add_offense(node)
        end

        def autocorrect(node)
          # RuboCop passes this function to a batch that runs all the given
          # correctors for the code, hence returning a lambda here.
          -> corrector {
            matches = AST_MATCH.match(node)

            # 1. Matches are wrapped in an Enumerator, as there can be multiple
            # 2. Then the value you want may be in an S-Expression
            # 3. An S-Expression can have multiple children, so it's returned as an Array
            # 4. Getting the first value specifically gives us 1, the set value
            #
            #       [s()] -> s() -> [1]  ->  1
            value = matches.first.children.first

            # Now we could always use the actual s-expression from step 2 here
            # with `matches.first.location.source`, which is handy when we're
            # not dealing with only one integer.
            new_code = "D::E::F = #{value}"

            # You can use a few things here, like `insert_before` or after or
            # other expressions. See the corrector source for more ideas:
            #
            #   https://github.com/rubocop-hq/rubocop/blob/master/lib/rubocop/cop/corrector.rb
            #
            # In this case we're replacing the entire node where it's expression is,
            # or rather the entire thing, with our new code.
            corrector.replace(node.location.expression, new_code)
          }
        end
      end
    end
  end
end

gem 'ast_builder'