node_query 1.0.0

data/lib/node_query/compiler/identifier.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module NodeQuery::Compiler
+  # Identifier represents a ruby identifier value.
+  # e.g. code is `class Synvert; end`, `Synvert` is an identifier.
+  class Identifier
+    include Comparable
+
+    # Initialize an Identifier.
+    # @param value [String] the identifier value
+    def initialize(value:)
+      @value = value
+    end
+
+    # Get the actual value.
+    # @param node [Node] the node
+    # @return [String|Array]
+    # If the node is a {Node}, return the node source code,
+    # if the node is an Array, return the array of each element's actual value,
+    # otherwise, return the String value.
+    def actual_value(node)
+      if node.is_a?(::Parser::AST::Node)
+        NodeQuery.get_adapter.get_source(node)
+      elsif node.is_a?(::Array)
+        node.map { |n| actual_value(n) }
+      else
+        node.to_s
+      end
+    end
+
+    # Get valid operators.
+    # @return [Array] valid operators
+    def valid_operators
+      STRING_VALID_OPERATORS
+    end
+
+    def to_s
+      @value
+    end
+  end
+end

data/lib/node_query/compiler/integer.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module NodeQuery::Compiler
+  # Integer represents a ruby integer value.
+  class Integer
+    include Comparable
+
+    # Initialize a Integer.
+    # @param value [Integer] the integer value
+    def initialize(value:)
+      @value = value
+    end
+
+    # Get valid operators.
+    # @return [Array] valid operators
+    def valid_operators
+      NUMBER_VALID_OPERATORS
+    end
+
+    def to_s
+      @value.to_s
+    end
+  end
+end

data/lib/node_query/compiler/invalid_operator_error.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module NodeQuery::Compiler
+  # Operator is invalid error.
+  class InvalidOperatorError < StandardError
+  end
+end

data/lib/node_query/compiler/nil.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module NodeQuery::Compiler
+  # Nil represents a ruby nil value.
+  class Nil
+    include Comparable
+
+    # Initialize a Nil.
+    # @param value [nil] the nil value
+    def initialize(value:)
+      @value = value
+    end
+
+    # Get valid operators.
+    # @return [Array] valid operators
+    def valid_operators
+      SIMPLE_VALID_OPERATORS
+    end
+
+    def to_s
+      'nil'
+    end
+  end
+end

data/lib/node_query/compiler/parse_error.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module NodeQuery::Compiler
+  # The parser error.
+  class ParseError < StandardError
+  end
+end

data/lib/node_query/compiler/regexp.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module NodeQuery::Compiler
+  # Regexp represents a ruby regexp value.
+  class Regexp
+    include Comparable
+
+    # Initialize a Regexp.
+    # @param value [Regexp] the regexp value
+    def initialize(value:)
+      @value = value
+    end
+
+    # Check if the regexp value matches the node value.
+    # @param node [Node] the node
+    # @param operator [String] the operator
+    # @return [Boolean] true if the regexp value matches the node value, otherwise, false.
+    def match?(node, operator = '=~')
+      match =
+        if node.is_a?(::Parser::AST::Node)
+          @value.match(NodeQuery.get_adapter.get_source(node))
+        else
+          @value.match(node.to_s)
+        end
+      operator == '=~' ? match : !match
+    end
+
+    # Get valid operators.
+    # @return [Array] valid operators
+    def valid_operators
+      REGEXP_VALID_OPERATORS
+    end
+
+    def to_s
+      @value.to_s
+    end
+  end
+end

data/lib/node_query/compiler/selector.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module NodeQuery::Compiler
+  # Selector used to match nodes, it combines by node type and/or attribute list, plus index or has expression.
+  class Selector
+    # Initialize a Selector.
+    # @param goto_scope [String] goto scope
+    # @param relationship [String] the relationship between the selectors, it can be descendant <code>nil</code>, child <code>></code>, next sibling <code>+</code> or subsequent sibing <code>~</code>.
+    # @param rest [NodeQuery::Compiler::Selector] the rest selector
+    # @param basic_selector [NodeQuery::Compiler::BasicSelector] the simple selector
+    # @param attribute_list [NodeQuery::Compiler::AttributeList] the attribute list
+    # @param pseudo_class [String] the pseudo class, can be <code>has</code> or <code>not_has</code>
+    # @param pseudo_selector [NodeQuery::Compiler::Expression] the pseudo selector
+    def initialize(goto_scope: nil, relationship: nil, rest: nil, basic_selector: nil, pseudo_class: nil, pseudo_selector: nil)
+      @goto_scope = goto_scope
+      @relationship = relationship
+      @rest = rest
+      @basic_selector = basic_selector
+      @pseudo_class = pseudo_class
+      @pseudo_selector = pseudo_selector
+    end
+
+    # Check if node matches the selector.
+    # @param node [Parser::AST::Node] the node
+    def match?(node)
+      node.is_a?(::Parser::AST::Node) && (!@basic_selector || @basic_selector.match?(node)) && match_pseudo_class?(node)
+    end
+
+    # Query nodes by the selector.
+    # * If relationship is nil, it will match in all recursive child nodes and return matching nodes.
+    # * If relationship is decendant, it will match in all recursive child nodes.
+    # * If relationship is child, it will match in direct child nodes.
+    # * If relationship is next sibling, it try to match next sibling node.
+    # * If relationship is subsequent sibling, it will match in all sibling nodes.
+    # @param node [Node] node to match
+    # @return [Array<Node>] matching nodes.
+    def query_nodes(node)
+      return find_nodes_by_relationship(node) if @relationship
+
+      if node.is_a?(::Array)
+        return node.flat_map { |child_node| query_nodes(child_node) }
+      end
+
+      return find_nodes_by_goto_scope(node) if @goto_scope
+
+      nodes = []
+      nodes << node if match?(node)
+      if @basic_selector
+        NodeQuery::Helper.handle_recursive_child(node) do |child_node|
+          nodes << child_node if match?(child_node)
+        end
+      end
+      nodes
+    end
+
+    def to_s
+      result = []
+      result << "#{@goto_scope} " if @goto_scope
+      result << "#{@relationship} " if @relationship
+      result << @rest.to_s if @rest
+      result << @basic_selector.to_s if @basic_selector
+      result << ":#{@pseudo_class}(#{@pseudo_selector})" if @pseudo_class
+      result.join('')
+    end
+
+    private
+
+    # Find nodes by @goto_scope
+    # @param node [Node] node to match
+    # @return [Array<Node>] matching nodes
+    def find_nodes_by_goto_scope(node)
+      @goto_scope.split('.').each { |scope| node = node.send(scope) }
+      @rest.query_nodes(node)
+    end
+
+    # Find nodes by @relationship
+    # @param node [Node] node to match
+    # @return [Array<Node>] matching nodes
+    def find_nodes_by_relationship(node)
+      nodes = []
+      case @relationship
+      when '>'
+        if node.is_a?(::Array)
+          node.each do |child_node|
+            nodes << child_node if @rest.match?(child_node)
+          end
+        else
+          node.children.each do |child_node|
+            nodes << child_node if @rest.match?(child_node)
+          end
+        end
+      when '+'
+        next_sibling = node.siblings.first
+        nodes << next_sibling if @rest.match?(next_sibling)
+      when '~'
+        node.siblings.each do |sibling_node|
+          nodes << sibling_node if @rest.match?(sibling_node)
+        end
+      end
+      nodes
+    end
+
+    # Check if it matches pseudo class.
+    # @param node [Node] node to match
+    # @return [Boolean]
+    def match_pseudo_class?(node)
+      case @pseudo_class
+      when 'has'
+        !@pseudo_selector.query_nodes(node).empty?
+      when 'not_has'
+        @pseudo_selector.query_nodes(node).empty?
+      else
+        true
+      end
+    end
+  end
+end

data/lib/node_query/compiler/string.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module NodeQuery::Compiler
+  # String represents a ruby string value.
+  class String
+    include Comparable
+
+    # Initialize a String.
+    # @param value [String] the string value
+    def initialize(value:)
+      @value = value
+    end
+
+    # Get valid operators.
+    # @return [Array] valid operators
+    def valid_operators
+      STRING_VALID_OPERATORS
+    end
+
+    def to_s
+      "\"#{@value}\""
+    end
+  end
+end

data/lib/node_query/compiler/symbol.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module NodeQuery::Compiler
+  # Symbol represents a ruby symbol value.
+  class Symbol
+    include Comparable
+
+    # Initliaze a Symobol.
+    # @param value [Symbol] the symbol value
+    def initialize(value:)
+      @value = value
+    end
+
+    # Get valid operators.
+    # @return [Array] valid operators
+    def valid_operators
+      SIMPLE_VALID_OPERATORS
+    end
+
+    def to_s
+      ":#{@value}"
+    end
+  end
+end

data/lib/node_query/compiler.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module NodeQuery::Compiler
+  autoload :InvalidOperatorError, 'node_query/compiler/invalid_operator_error'
+  autoload :ParseError, 'node_query/compiler/parse_error'
+
+  autoload :Comparable, 'node_query/compiler/comparable'
+
+  autoload :ExpressionList, 'node_query/compiler/expression_list'
+  autoload :Expression, 'node_query/compiler/expression'
+  autoload :Selector, 'node_query/compiler/selector'
+  autoload :BasicSelector, 'node_query/compiler/basic_selector'
+  autoload :AttributeList, 'node_query/compiler/attribute_list'
+  autoload :Attribute, 'node_query/compiler/attribute'
+
+  autoload :ArrayValue, 'node_query/compiler/array_value'
+  autoload :Boolean, 'node_query/compiler/boolean'
+  autoload :EvaluatedValue, 'node_query/compiler/evaluated_value'
+  autoload :Float, 'node_query/compiler/float'
+  autoload :Identifier, 'node_query/compiler/identifier'
+  autoload :Integer, 'node_query/compiler/integer'
+  autoload :Nil, 'node_query/compiler/nil'
+  autoload :Regexp, 'node_query/compiler/regexp'
+  autoload :String, 'node_query/compiler/string'
+  autoload :Symbol, 'node_query/compiler/symbol'
+end

data/lib/node_query/helper.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+class NodeQuery::Helper
+  # Get target node by the keys.
+  # @param node [Node] ast node
+  # @param keys [String] keys of child node.
+  # @return [Node|] the target node.
+  def self.get_target_node(node, keys)
+    return unless node
+
+    first_key, rest_keys = keys.to_s.split('.', 2)
+    if (node.is_a?(Array) && first_key === "*")
+      return node.map { |child_node| get_target_node(child_node, rest_keys) }
+    end
+
+    if node.respond_to?(first_key)
+      child_node = node.send(first_key)
+    end
+
+    return child_node unless rest_keys
+
+    return get_target_node(child_node, rest_keys)
+  end
+
+  # Recursively handle child nodes.
+  # @param node [Node] ast node
+  # @yield [child] Gives a child node.
+  # @yieldparam child [Parser::AST::Node] child node
+  def self.handle_recursive_child(node, &block)
+    NodeQuery.get_adapter.get_children(node).each do |child|
+      block.call(child)
+      handle_recursive_child(child, &block)
+    end
+  end
+end

data/lib/node_query/parser_adapter.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+class NodeQuery::ParserAdapter
+  def get_node_type(node)
+    node.type
+  end
+
+  def get_source(node)
+    node.loc.expression.source
+  end
+
+  def get_children(node)
+    node.is_a?(Parser::AST::Node) ? node.children : []
+  end
+
+  def get_siblings(node)
+    index = node.parent.children.index(node)
+    node.parent.children[index + 1..]
+  end
+end

data/lib/node_query/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class NodeQuery
+  VERSION = "1.0.0"
+end

data/lib/node_query.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/array'
+
+require_relative "node_query/version"
+require_relative "node_query/parser_adapter"
+require_relative "node_query/compiler"
+require_relative "node_query/helper"
+require_relative "./node_query_lexer.rex"
+require_relative "./node_query_parser.racc"
+
+class NodeQuery
+  # Configure NodeQuery
+  # @param [Hash] options options to configure
+  # @option options [NodeQuery::Adapter] :adapter the adpater
+  def self.configure(options)
+    @adapter = options.adapter
+  end
+
+  # Get the adapter
+  # @return [NodeQuery::Adapter] current adapter, by default is {NodeQuery::ParserAdapter}
+  def self.get_adapter
+    @adapter ||= ParserAdapter.new
+  end
+
+  # Initialize a NodeQuery.
+  # @param nql [String] node query language
+  def initialize(nql)
+    @expression = NodeQueryParser.new.parse(nql)
+  end
+
+  # Parse ast node.
+  # @param node [Node] ast node
+  # @return [Array<Node>] matching child nodes
+  def parse(node)
+    @expression.query_nodes(node)
+  end
+end

data/lib/node_query_lexer.rex

@@ -0,0 +1,98 @@
+class NodeQueryLexer
+
+macros
+  OPEN_ATTRIBUTE           /\[/
+  CLOSE_ATTRIBUTE          /\]/
+  OPEN_ARRAY               /\(/
+  CLOSE_ARRAY              /\)/
+  OPEN_SELECTOR            /\(/
+  CLOSE_SELECTOR           /\)/
+  OPEN_DYNAMIC_ATTRIBUTE   /{{/
+  CLOSE_DYNAMIC_ATTRIBUTE  /}}/
+  NODE_TYPE                /\.[a-z]+/
+  IDENTIFIER               /[\.\w]+/
+  IDENTIFIER_VALUE         /[\.\w!&:\?<>=]+/
+  FALSE                    /false/
+  FLOAT                    /\d+\.\d+/
+  INTEGER                  /\d+/
+  NIL                      /nil/
+  REGEXP_BODY              /(?:[^\/]|\\\/)*/
+  REGEXP                   /\/(#{REGEXP_BODY})(?<!\\)\/([imxo]*)/
+  SYMBOL                   /:[\w!\?<>=]+/
+  TRUE                     /true/
+  SINGLE_QUOTE_STRING      /'.*?'/
+  DOUBLE_QUOTE_STRING      /".*?"/
+
+rules
+
+# [:state]          pattern                       [actions]
+                    /\s+/
+                    /,/                           { [:tCOMMA, text] }
+                    /:has/                        { [:tPSEUDO_CLASS, text[1..-1]] }
+                    /:not_has/                    { [:tPSEUDO_CLASS, text[1..-1]] }
+                    /#{NODE_TYPE}/                { [:tNODE_TYPE, text[1..]] }
+                    /#{IDENTIFIER}/               { [:tGOTO_SCOPE, text] }
+                    />/                           { [:tRELATIONSHIP, text] }
+                    /~/                           { [:tRELATIONSHIP, text] }
+                    /\+/                          { [:tRELATIONSHIP, text] }
+                    /#{OPEN_SELECTOR}/            { [:tOPEN_SELECTOR, text] }
+                    /#{CLOSE_SELECTOR}/           { [:tCLOSE_SELECTOR, text] }
+                    /#{OPEN_ATTRIBUTE}/           { @nested_count += 1; @state = :KEY; [:tOPEN_ATTRIBUTE, text] }
+:KEY                /\s+/
+:KEY                /\^=/                         { @state = :VALUE; [:tOPERATOR, '^='] }
+:KEY                /\$=/                         { @state = :VALUE; [:tOPERATOR, '$='] }
+:KEY                /\*=/                         { @state = :VALUE; [:tOPERATOR, '*='] }
+:KEY                /!=/                          { @state = :VALUE; [:tOPERATOR, '!='] }
+:KEY                /=~/                          { @state = :VALUE; [:tOPERATOR, '=~'] }
+:KEY                /!~/                          { @state = :VALUE; [:tOPERATOR, '!~'] }
+:KEY                />=/                          { @state = :VALUE; [:tOPERATOR, '>='] }
+:KEY                /<=/                          { @state = :VALUE; [:tOPERATOR, '<='] }
+:KEY                />/                           { @state = :VALUE; [:tOPERATOR, '>'] }
+:KEY                /</                           { @state = :VALUE; [:tOPERATOR, '<'] }
+:KEY                /=/                           { @state = :VALUE; [:tOPERATOR, '=='] }
+:KEY                /includes/i                   { @state = :VALUE; [:tOPERATOR, 'includes'] }
+:KEY                /not in/i                     { @state = :VALUE; [:tOPERATOR, 'not_in'] }
+:KEY                /in/i                         { @state = :VALUE; [:tOPERATOR, 'in'] }
+:KEY                /#{IDENTIFIER}/               { [:tKEY, text] }
+:VALUE              /\s+/
+:VALUE              /\[\]=/                       { [:tIDENTIFIER_VALUE, text] }
+:VALUE              /\[\]/                        { [:tIDENTIFIER_VALUE, text] }
+:VALUE              /:\[\]=/                      { [:tSYMBOL, text[1..-1].to_sym] }
+:VALUE              /:\[\]/                       { [:tSYMBOL, text[1..-1].to_sym] }
+:VALUE              /{{#{IDENTIFIER}}}/           { [:tDYNAMIC_ATTRIBUTE, text[2..-3]] }
+:VALUE              /#{OPEN_ARRAY}/               { @state = :ARRAY_VALUE; [:tOPEN_ARRAY, text] }
+:VALUE              /#{CLOSE_ATTRIBUTE}/          { @nested_count -= 1; @state = @nested_count == 0 ? nil : :VALUE; [:tCLOSE_ATTRIBUTE, text] }
+:VALUE              /#{NIL}\?/                    { [:tIDENTIFIER_VALUE, text] }
+:VALUE              /#{NIL}/                      { [:tNIL, nil] }
+:VALUE              /#{TRUE}/                     { [:tBOOLEAN, true] }
+:VALUE              /#{FALSE}/                    { [:tBOOLEAN, false] }
+:VALUE              /#{SYMBOL}/                   { [:tSYMBOL, text[1..-1].to_sym] }
+:VALUE              /#{FLOAT}/                    { [:tFLOAT, text.to_f] }
+:VALUE              /#{INTEGER}/                  { [:tINTEGER, text.to_i] }
+:VALUE              /#{REGEXP}/                   { [:tREGEXP, eval(text)] }
+:VALUE              /#{DOUBLE_QUOTE_STRING}/      { [:tSTRING, text[1...-1]] }
+:VALUE              /#{SINGLE_QUOTE_STRING}/      { [:tSTRING, text[1...-1]] }
+:VALUE              /#{NODE_TYPE}/                { [:tNODE_TYPE, text[1..]] }
+:VALUE              /#{OPEN_ATTRIBUTE}/           { @nested_count += 1; @state = :KEY; [:tOPEN_ATTRIBUTE, text] }
+:VALUE              /#{IDENTIFIER_VALUE}/         { [:tIDENTIFIER_VALUE, text] }
+:ARRAY_VALUE        /\s+/
+:ARRAY_VALUE        /#{CLOSE_ARRAY}/              { @state = :VALUE; [:tCLOSE_ARRAY, text] }
+:ARRAY_VALUE        /#{NIL}\?/                    { [:tIDENTIFIER_VALUE, text] }
+:ARRAY_VALUE        /#{NIL}/                      { [:tNIL, nil] }
+:ARRAY_VALUE        /#{TRUE}/                     { [:tBOOLEAN, true] }
+:ARRAY_VALUE        /#{FALSE}/                    { [:tBOOLEAN, false] }
+:ARRAY_VALUE        /#{SYMBOL}/                   { [:tSYMBOL, text[1..-1].to_sym] }
+:ARRAY_VALUE        /#{FLOAT}/                    { [:tFLOAT, text.to_f] }
+:ARRAY_VALUE        /#{INTEGER}/                  { [:tINTEGER, text.to_i] }
+:ARRAY_VALUE        /#{REGEXP}/                   { [:tREGEXP, eval(text)] }
+:ARRAY_VALUE        /#{DOUBLE_QUOTE_STRING}/      { [:tSTRING, text[1...-1]] }
+:ARRAY_VALUE        /#{SINGLE_QUOTE_STRING}/      { [:tSTRING, text[1...-1]] }
+:ARRAY_VALUE        /#{IDENTIFIER_VALUE}/         { [:tIDENTIFIER_VALUE, text] }
+
+inner
+  def initialize
+    @nested_count = 0
+  end
+
+  def do_parse; end
+end

data/lib/node_query_parser.y

@@ -0,0 +1,63 @@
+class NodeQueryParser
+options no_result_var
+token tCOMMA tNODE_TYPE tGOTO_SCOPE tATTRIBUTE tKEY tIDENTIFIER tIDENTIFIER_VALUE tPSEUDO_CLASS tRELATIONSHIP
+      tOPEN_ATTRIBUTE tCLOSE_ATTRIBUTE tOPEN_ARRAY tCLOSE_ARRAY tOPEN_SELECTOR tCLOSE_SELECTOR
+      tOPERATOR tARRAY_VALUE tDYNAMIC_ATTRIBUTE tBOOLEAN tFLOAT tINTEGER tNIL tREGEXP tSTRING tSYMBOL
+rule
+  expression_list
+    : expression tCOMMA expression_list { NodeQuery::Compiler::ExpressionList.new(expression: val[0], rest: val[2]) }
+    | expression { NodeQuery::Compiler::ExpressionList.new(expression: val[0]) }
+
+  expression
+    : selector expression { NodeQuery::Compiler::Expression.new(selector: val[0], rest: val[1]) }
+    | selector { NodeQuery::Compiler::Expression.new(selector: val[0]) }
+
+  selector
+    : basic_selector { NodeQuery::Compiler::Selector.new(basic_selector: val[0]) }
+    | tPSEUDO_CLASS tOPEN_SELECTOR selector tCLOSE_SELECTOR { NodeQuery::Compiler::Selector.new(pseudo_class: val[0], pseudo_selector: val[2]) }
+    | tRELATIONSHIP selector { NodeQuery::Compiler::Selector.new(relationship: val[0], rest: val[1]) }
+    | tGOTO_SCOPE selector { NodeQuery::Compiler::Selector.new(goto_scope: val[0], rest: val[1]) }
+
+  basic_selector
+    : tNODE_TYPE { NodeQuery::Compiler::BasicSelector.new(node_type: val[0]) }
+    | tNODE_TYPE attribute_list { NodeQuery::Compiler::BasicSelector.new(node_type: val[0], attribute_list: val[1]) }
+
+  attribute_list
+    : tOPEN_ATTRIBUTE attribute tCLOSE_ATTRIBUTE attribute_list { NodeQuery::Compiler::AttributeList.new(attribute: val[1], rest: val[3]) }
+    | tOPEN_ATTRIBUTE attribute tCLOSE_ATTRIBUTE { NodeQuery::Compiler::AttributeList.new(attribute: val[1]) }
+
+  attribute
+    : tKEY tOPERATOR value { NodeQuery::Compiler::Attribute.new(key: val[0], value: val[2], operator: val[1]) }
+    | tKEY tOPERATOR tOPEN_ARRAY tCLOSE_ARRAY { NodeQuery::Compiler::Attribute.new(key: val[0], value: NodeQuery::Compiler::Array.new, operator: val[1]) }
+    | tKEY tOPERATOR tOPEN_ARRAY array_value tCLOSE_ARRAY { NodeQuery::Compiler::Attribute.new(key: val[0], value: val[3], operator: val[1]) }
+
+  array_value
+    : value array_value { NodeQuery::Compiler::ArrayValue.new(value: val[0], rest: val[1]) }
+    | value { NodeQuery::Compiler::ArrayValue.new(value: val[0]) }
+
+  value
+    : basic_selector
+    | tDYNAMIC_ATTRIBUTE { NodeQuery::Compiler::EvaluatedValue.new(value: val[0]) }
+    | tBOOLEAN { NodeQuery::Compiler::Boolean.new(value: val[0]) }
+    | tFLOAT { NodeQuery::Compiler::Float.new(value: val[0]) }
+    | tINTEGER { NodeQuery::Compiler::Integer.new(value: val[0])}
+    | tNIL { NodeQuery::Compiler::Nil.new(value: val[0]) }
+    | tREGEXP { NodeQuery::Compiler::Regexp.new(value: val[0]) }
+    | tSTRING { NodeQuery::Compiler::String.new(value: val[0]) }
+    | tSYMBOL { NodeQuery::Compiler::Symbol.new(value: val[0]) }
+    | tIDENTIFIER_VALUE { NodeQuery::Compiler::Identifier.new(value: val[0]) }
+end
+
+---- inner
+    def initialize
+      @lexer = NodeQueryLexer.new
+    end
+
+    def parse string
+      @lexer.parse string
+      do_parse
+    end
+
+    def next_token
+      @lexer.next_token
+    end

data/node_query.gemspec

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative "lib/node_query/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "node_query"
+  spec.version = NodeQuery::VERSION
+  spec.authors = ["Richard Huang"]
+  spec.email = ["flyerhzm@gmail.com"]
+
+  spec.summary = "ast node query language"
+  spec.description = "ast node query language"
+  spec.homepage = "https://github.com/xinminlabs/node-query-ruby"
+  spec.required_ruby_version = ">= 2.6.0"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/xinminlabs/node-query-ruby"
+  spec.metadata["changelog_uri"] = "https://github.com/xinminlabs/node-query-ruby/CHANGELOG.md"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (f == __FILE__) || f.match(%r{\A(?:(?:bin|test|spec|features)/|\.(?:git|travis|circleci)|appveyor)})
+    end
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  # Uncomment to register a new dependency of your gem
+  spec.add_dependency "activesupport"
+
+  # For more information and examples about making a new gem, check out our
+  # guide at: https://bundler.io/guides/creating_gem.html
+end

data/sig/node_query.rbs

@@ -0,0 +1,11 @@
+class NodeQuery
+  VERSION: String
+
+  def self.configure: (options: { adapter: NodeQuery::Adapter }) -> void
+
+  def self.get_adapter: () -> NodeQuery::Adapter
+
+  def initialize: (nql: String) -> NodeQuery
+
+  def parse: (node: Node) -> Array[Node]
+end