node_query 1.0.0 → 1.3.0

data/lib/node_query_lexer.rex.rb

@@ -0,0 +1,287 @@
+# frozen_string_literal: true
+# encoding: UTF-8
+#--
+# This file is automatically generated. Do not modify it.
+# Generated by: oedipus_lex version 2.6.0.
+# Source: lib/node_query_lexer.rex
+#++
+
+
+##
+# The generated lexer NodeQueryLexer
+
+class NodeQueryLexer
+  require 'strscan'
+
+  # :stopdoc:
+  OPEN_ATTRIBUTE      = /\[/
+  CLOSE_ATTRIBUTE     = /\]/
+  OPEN_ARRAY          = /\(/
+  CLOSE_ARRAY         = /\)/
+  OPEN_SELECTOR       = /\(/
+  CLOSE_SELECTOR      = /\)/
+  NODE_TYPE           = /\.[a-z]+/
+  IDENTIFIER          = /[@\*\.\w]*\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 = /".*?"/
+  # :startdoc:
+  # :stopdoc:
+  class LexerError < StandardError ; end
+  class ScanError < LexerError ; end
+  # :startdoc:
+
+  ##
+  # The file name / path
+
+  attr_accessor :filename
+
+  ##
+  # The StringScanner for this lexer.
+
+  attr_accessor :ss
+
+  ##
+  # The current lexical state.
+
+  attr_accessor :state
+
+  alias :match :ss
+
+  ##
+  # The match groups for the current scan.
+
+  def matches
+    m = (1..9).map { |i| ss[i] }
+    m.pop until m[-1] or m.empty?
+    m
+  end
+
+  ##
+  # Yields on the current action.
+
+  def action
+    yield
+  end
+
+
+  ##
+  # The current scanner class. Must be overridden in subclasses.
+
+  def scanner_class
+    StringScanner
+  end unless instance_methods(false).map(&:to_s).include?("scanner_class")
+
+  ##
+  # Parse the given string.
+
+  def parse str
+    self.ss     = scanner_class.new str
+    self.state  ||= nil
+
+    do_parse
+  end
+
+  ##
+  # Read in and parse the file at +path+.
+
+  def parse_file path
+    self.filename = path
+    open path do |f|
+      parse f.read
+    end
+  end
+
+  ##
+  # The current location in the parse.
+
+  def location
+    [
+      (filename || "<input>"),
+    ].compact.join(":")
+  end
+
+  ##
+  # Lex the next token.
+
+  def next_token
+
+    token = nil
+
+    until ss.eos? or token do
+      token =
+        case state
+        when nil then
+          case
+          when ss.skip(/\s+/) then
+            # do nothing
+          when text = ss.scan(/,/) then
+            action { [:tCOMMA, text] }
+          when text = ss.scan(/:has/) then
+            action { [:tPSEUDO_CLASS, text[1..-1]] }
+          when text = ss.scan(/:not_has/) then
+            action { [:tPSEUDO_CLASS, text[1..-1]] }
+          when text = ss.scan(/#{NODE_TYPE}/) then
+            action { [:tNODE_TYPE, text[1..]] }
+          when text = ss.scan(/#{IDENTIFIER}/) then
+            action { [:tGOTO_SCOPE, text] }
+          when text = ss.scan(/>/) then
+            action { [:tRELATIONSHIP, text] }
+          when text = ss.scan(/~/) then
+            action { [:tRELATIONSHIP, text] }
+          when text = ss.scan(/\+/) then
+            action { [:tRELATIONSHIP, text] }
+          when text = ss.scan(/#{OPEN_SELECTOR}/) then
+            action { [:tOPEN_SELECTOR, text] }
+          when text = ss.scan(/#{CLOSE_SELECTOR}/) then
+            action { [:tCLOSE_SELECTOR, text] }
+          when text = ss.scan(/#{OPEN_ATTRIBUTE}/) then
+            action { @nested_count += 1; @state = :KEY; [:tOPEN_ATTRIBUTE, text] }
+          else
+            text = ss.string[ss.pos .. -1]
+            raise ScanError, "can not match (#{state.inspect}) at #{location}: '#{text}'"
+          end
+        when :KEY then
+          case
+          when ss.skip(/\s+/) then
+            # do nothing
+          when ss.skip(/\^=/) then
+            action { @state = :VALUE; [:tOPERATOR, '^='] }
+          when ss.skip(/\$=/) then
+            action { @state = :VALUE; [:tOPERATOR, '$='] }
+          when ss.skip(/\*=/) then
+            action { @state = :VALUE; [:tOPERATOR, '*='] }
+          when ss.skip(/!=/) then
+            action { @state = :VALUE; [:tOPERATOR, '!='] }
+          when ss.skip(/=~/) then
+            action { @state = :VALUE; [:tOPERATOR, '=~'] }
+          when ss.skip(/!~/) then
+            action { @state = :VALUE; [:tOPERATOR, '!~'] }
+          when ss.skip(/>=/) then
+            action { @state = :VALUE; [:tOPERATOR, '>='] }
+          when ss.skip(/<=/) then
+            action { @state = :VALUE; [:tOPERATOR, '<='] }
+          when ss.skip(/>/) then
+            action { @state = :VALUE; [:tOPERATOR, '>'] }
+          when ss.skip(/</) then
+            action { @state = :VALUE; [:tOPERATOR, '<'] }
+          when ss.skip(/=/) then
+            action { @state = :VALUE; [:tOPERATOR, '=='] }
+          when ss.skip(/includes/i) then
+            action { @state = :VALUE; [:tOPERATOR, 'includes'] }
+          when ss.skip(/not in/i) then
+            action { @state = :VALUE; [:tOPERATOR, 'not_in'] }
+          when ss.skip(/in/i) then
+            action { @state = :VALUE; [:tOPERATOR, 'in'] }
+          when text = ss.scan(/#{IDENTIFIER}/) then
+            action { [:tKEY, text] }
+          else
+            text = ss.string[ss.pos .. -1]
+            raise ScanError, "can not match (#{state.inspect}) at #{location}: '#{text}'"
+          end
+        when :VALUE then
+          case
+          when ss.skip(/\s+/) then
+            # do nothing
+          when text = ss.scan(/\[\]=/) then
+            action { [:tIDENTIFIER_VALUE, text] }
+          when text = ss.scan(/\[\]/) then
+            action { [:tIDENTIFIER_VALUE, text] }
+          when text = ss.scan(/:\[\]=/) then
+            action { [:tSYMBOL, text[1..-1].to_sym] }
+          when text = ss.scan(/:\[\]/) then
+            action { [:tSYMBOL, text[1..-1].to_sym] }
+          when text = ss.scan(/#{OPEN_ARRAY}/) then
+            action { @state = :ARRAY_VALUE; [:tOPEN_ARRAY, text] }
+          when text = ss.scan(/#{CLOSE_ATTRIBUTE}/) then
+            action { @nested_count -= 1; @state = @nested_count == 0 ? nil : :VALUE; [:tCLOSE_ATTRIBUTE, text] }
+          when text = ss.scan(/#{NIL}\?/) then
+            action { [:tIDENTIFIER_VALUE, text] }
+          when ss.skip(/#{NIL}/) then
+            action { [:tNIL, nil] }
+          when ss.skip(/#{TRUE}/) then
+            action { [:tBOOLEAN, true] }
+          when ss.skip(/#{FALSE}/) then
+            action { [:tBOOLEAN, false] }
+          when text = ss.scan(/#{SYMBOL}/) then
+            action { [:tSYMBOL, text[1..-1].to_sym] }
+          when text = ss.scan(/#{FLOAT}/) then
+            action { [:tFLOAT, text.to_f] }
+          when text = ss.scan(/#{INTEGER}/) then
+            action { [:tINTEGER, text.to_i] }
+          when text = ss.scan(/#{REGEXP}/) then
+            action { [:tREGEXP, eval(text)] }
+          when text = ss.scan(/#{DOUBLE_QUOTE_STRING}/) then
+            action { [:tSTRING, text[1...-1]] }
+          when text = ss.scan(/#{SINGLE_QUOTE_STRING}/) then
+            action { [:tSTRING, text[1...-1]] }
+          when text = ss.scan(/#{NODE_TYPE}/) then
+            action { [:tNODE_TYPE, text[1..]] }
+          when text = ss.scan(/#{OPEN_ATTRIBUTE}/) then
+            action { @nested_count += 1; @state = :KEY; [:tOPEN_ATTRIBUTE, text] }
+          when text = ss.scan(/#{IDENTIFIER_VALUE}/) then
+            action { [:tIDENTIFIER_VALUE, text] }
+          else
+            text = ss.string[ss.pos .. -1]
+            raise ScanError, "can not match (#{state.inspect}) at #{location}: '#{text}'"
+          end
+        when :ARRAY_VALUE then
+          case
+          when ss.skip(/\s+/) then
+            # do nothing
+          when text = ss.scan(/#{CLOSE_ARRAY}/) then
+            action { @state = :VALUE; [:tCLOSE_ARRAY, text] }
+          when text = ss.scan(/#{NIL}\?/) then
+            action { [:tIDENTIFIER_VALUE, text] }
+          when ss.skip(/#{NIL}/) then
+            action { [:tNIL, nil] }
+          when ss.skip(/#{TRUE}/) then
+            action { [:tBOOLEAN, true] }
+          when ss.skip(/#{FALSE}/) then
+            action { [:tBOOLEAN, false] }
+          when text = ss.scan(/#{SYMBOL}/) then
+            action { [:tSYMBOL, text[1..-1].to_sym] }
+          when text = ss.scan(/#{FLOAT}/) then
+            action { [:tFLOAT, text.to_f] }
+          when text = ss.scan(/#{INTEGER}/) then
+            action { [:tINTEGER, text.to_i] }
+          when text = ss.scan(/#{REGEXP}/) then
+            action { [:tREGEXP, eval(text)] }
+          when text = ss.scan(/#{DOUBLE_QUOTE_STRING}/) then
+            action { [:tSTRING, text[1...-1]] }
+          when text = ss.scan(/#{SINGLE_QUOTE_STRING}/) then
+            action { [:tSTRING, text[1...-1]] }
+          when text = ss.scan(/#{IDENTIFIER_VALUE}/) then
+            action { [:tIDENTIFIER_VALUE, text] }
+          else
+            text = ss.string[ss.pos .. -1]
+            raise ScanError, "can not match (#{state.inspect}) at #{location}: '#{text}'"
+          end
+        else
+          raise ScanError, "undefined state at #{location}: '#{state}'"
+        end # token = case state
+
+      next unless token # allow functions to trigger redo w/ nil
+    end # while
+
+    raise LexerError, "bad lexical result at #{location}: #{token.inspect}" unless
+      token.nil? || (Array === token && token.size >= 2)
+
+    # auto-switch state
+    self.state = token.last if token && token.first == :state
+
+    token
+  end # def next_token
+    def initialize
+      @nested_count = 0
+    end
+    def do_parse; end
+end # class

data/lib/node_query_parser.racc.rb

@@ -0,0 +1,302 @@
+#
+# DO NOT MODIFY!!!!
+# This file is automatically generated by Racc 1.6.0
+# from Racc grammar file "".
+#
+
+require 'racc/parser.rb'
+class NodeQueryParser < Racc::Parser
+
+    def initialize
+      @lexer = NodeQueryLexer.new
+    end
+
+    def parse string
+      @lexer.parse string
+      do_parse
+    end
+
+    def next_token
+      @lexer.next_token
+    end
+##### State transition tables begin ###
+
+racc_action_table = [
+     8,     8,     7,     9,    10,    36,    12,     5,     6,    16,
+    27,    17,    21,    22,    23,    24,    29,    30,    31,    32,
+    33,    34,    35,     8,    16,     8,     7,    40,    36,   nil,
+     8,     5,     6,   nil,    37,    36,   nil,   nil,   nil,    29,
+    30,    31,    32,    33,    34,    35,    29,    30,    31,    32,
+    33,    34,    35,     8,     7,     8,     7,     8,     7,     5,
+     6,     5,     6,     5,     6,     8,     7,   nil,   nil,   nil,
+   nil,     5,     6 ]
+
+racc_action_check = [
+    24,     0,     0,     1,     2,    24,     5,     0,     0,     8,
+    24,     9,    16,    19,    20,    21,    24,    24,    24,    24,
+    24,    24,    24,    27,    23,     3,     3,    38,    27,   nil,
+    39,     3,     3,   nil,    27,    39,   nil,   nil,   nil,    27,
+    27,    27,    27,    27,    27,    27,    39,    39,    39,    39,
+    39,    39,    39,     6,     6,     7,     7,    10,    10,     6,
+     6,     7,     7,    10,    10,    12,    12,   nil,   nil,   nil,
+   nil,    12,    12 ]
+
+racc_action_pointer = [
+    -2,     3,     2,    22,   nil,    -9,    50,    52,    -2,    11,
+    54,   nil,    62,   nil,   nil,   nil,     6,   nil,   nil,    -3,
+     2,    -2,   nil,    13,    -3,   nil,   nil,    20,   nil,   nil,
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,    13,    27,
+   nil,   nil ]
+
+racc_action_default = [
+   -27,   -27,    -2,    -4,    -5,   -27,   -27,   -27,    -9,   -27,
+   -27,    -3,   -27,    -7,    -8,   -10,   -27,    42,    -1,   -27,
+   -27,   -27,    -6,   -12,   -27,   -11,   -13,   -27,   -18,   -19,
+   -20,   -21,   -22,   -23,   -24,   -25,   -26,   -14,   -27,   -17,
+   -15,   -16 ]
+
+racc_goto_table = [
+    28,    15,    38,    28,    13,    14,    11,     1,    20,    26,
+    19,   nil,   nil,   nil,    41,    28,    25,    18 ]
+
+racc_goto_check = [
+     4,     5,     8,     4,     3,     3,     2,     1,     6,     7,
+     3,   nil,   nil,   nil,     8,     4,     5,     1 ]
+
+racc_goto_pointer = [
+   nil,     7,     3,    -2,   -24,    -7,    -8,   -15,   -25 ]
+
+racc_goto_default = [
+   nil,   nil,     2,     3,     4,   nil,   nil,    39,   nil ]
+
+racc_reduce_table = [
+  0, 0, :racc_error,
+  3, 27, :_reduce_1,
+  1, 27, :_reduce_2,
+  2, 28, :_reduce_3,
+  1, 28, :_reduce_4,
+  1, 29, :_reduce_5,
+  4, 29, :_reduce_6,
+  2, 29, :_reduce_7,
+  2, 29, :_reduce_8,
+  1, 30, :_reduce_9,
+  2, 30, :_reduce_10,
+  4, 31, :_reduce_11,
+  3, 31, :_reduce_12,
+  3, 32, :_reduce_13,
+  4, 32, :_reduce_14,
+  5, 32, :_reduce_15,
+  2, 34, :_reduce_16,
+  1, 34, :_reduce_17,
+  1, 33, :_reduce_none,
+  1, 33, :_reduce_19,
+  1, 33, :_reduce_20,
+  1, 33, :_reduce_21,
+  1, 33, :_reduce_22,
+  1, 33, :_reduce_23,
+  1, 33, :_reduce_24,
+  1, 33, :_reduce_25,
+  1, 33, :_reduce_26 ]
+
+racc_reduce_n = 27
+
+racc_shift_n = 42
+
+racc_token_table = {
+  false => 0,
+  :error => 1,
+  :tCOMMA => 2,
+  :tNODE_TYPE => 3,
+  :tGOTO_SCOPE => 4,
+  :tATTRIBUTE => 5,
+  :tKEY => 6,
+  :tIDENTIFIER => 7,
+  :tIDENTIFIER_VALUE => 8,
+  :tPSEUDO_CLASS => 9,
+  :tRELATIONSHIP => 10,
+  :tOPEN_ATTRIBUTE => 11,
+  :tCLOSE_ATTRIBUTE => 12,
+  :tOPEN_ARRAY => 13,
+  :tCLOSE_ARRAY => 14,
+  :tOPEN_SELECTOR => 15,
+  :tCLOSE_SELECTOR => 16,
+  :tOPERATOR => 17,
+  :tARRAY_VALUE => 18,
+  :tBOOLEAN => 19,
+  :tFLOAT => 20,
+  :tINTEGER => 21,
+  :tNIL => 22,
+  :tREGEXP => 23,
+  :tSTRING => 24,
+  :tSYMBOL => 25 }
+
+racc_nt_base = 26
+
+racc_use_result_var = false
+
+Racc_arg = [
+  racc_action_table,
+  racc_action_check,
+  racc_action_default,
+  racc_action_pointer,
+  racc_goto_table,
+  racc_goto_check,
+  racc_goto_default,
+  racc_goto_pointer,
+  racc_nt_base,
+  racc_reduce_table,
+  racc_token_table,
+  racc_shift_n,
+  racc_reduce_n,
+  racc_use_result_var ]
+
+Racc_token_to_s_table = [
+  "$end",
+  "error",
+  "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",
+  "tBOOLEAN",
+  "tFLOAT",
+  "tINTEGER",
+  "tNIL",
+  "tREGEXP",
+  "tSTRING",
+  "tSYMBOL",
+  "$start",
+  "expression_list",
+  "expression",
+  "selector",
+  "basic_selector",
+  "attribute_list",
+  "attribute",
+  "value",
+  "array_value" ]
+
+Racc_debug_parser = false
+
+##### State transition tables end #####
+
+# reduce 0 omitted
+
+def _reduce_1(val, _values)
+ NodeQuery::Compiler::ExpressionList.new(expression: val[0], rest: val[2])
+end
+
+def _reduce_2(val, _values)
+ NodeQuery::Compiler::ExpressionList.new(expression: val[0])
+end
+
+def _reduce_3(val, _values)
+ NodeQuery::Compiler::Expression.new(selector: val[0], rest: val[1])
+end
+
+def _reduce_4(val, _values)
+ NodeQuery::Compiler::Expression.new(selector: val[0])
+end
+
+def _reduce_5(val, _values)
+ NodeQuery::Compiler::Selector.new(basic_selector: val[0])
+end
+
+def _reduce_6(val, _values)
+ NodeQuery::Compiler::Selector.new(pseudo_class: val[0], pseudo_selector: val[2])
+end
+
+def _reduce_7(val, _values)
+ NodeQuery::Compiler::Selector.new(relationship: val[0], rest: val[1])
+end
+
+def _reduce_8(val, _values)
+ NodeQuery::Compiler::Selector.new(goto_scope: val[0], rest: val[1])
+end
+
+def _reduce_9(val, _values)
+ NodeQuery::Compiler::BasicSelector.new(node_type: val[0])
+end
+
+def _reduce_10(val, _values)
+ NodeQuery::Compiler::BasicSelector.new(node_type: val[0], attribute_list: val[1])
+end
+
+def _reduce_11(val, _values)
+ NodeQuery::Compiler::AttributeList.new(attribute: val[1], rest: val[3])
+end
+
+def _reduce_12(val, _values)
+ NodeQuery::Compiler::AttributeList.new(attribute: val[1])
+end
+
+def _reduce_13(val, _values)
+ NodeQuery::Compiler::Attribute.new(key: val[0], value: val[2], operator: val[1])
+end
+
+def _reduce_14(val, _values)
+ NodeQuery::Compiler::Attribute.new(key: val[0], value: NodeQuery::Compiler::ArrayValue.new, operator: val[1])
+end
+
+def _reduce_15(val, _values)
+ NodeQuery::Compiler::Attribute.new(key: val[0], value: val[3], operator: val[1])
+end
+
+def _reduce_16(val, _values)
+ NodeQuery::Compiler::ArrayValue.new(value: val[0], rest: val[1])
+end
+
+def _reduce_17(val, _values)
+ NodeQuery::Compiler::ArrayValue.new(value: val[0])
+end
+
+# reduce 18 omitted
+
+def _reduce_19(val, _values)
+ NodeQuery::Compiler::Boolean.new(value: val[0])
+end
+
+def _reduce_20(val, _values)
+ NodeQuery::Compiler::Float.new(value: val[0])
+end
+
+def _reduce_21(val, _values)
+ NodeQuery::Compiler::Integer.new(value: val[0])
+end
+
+def _reduce_22(val, _values)
+ NodeQuery::Compiler::Nil.new(value: val[0])
+end
+
+def _reduce_23(val, _values)
+ NodeQuery::Compiler::Regexp.new(value: val[0])
+end
+
+def _reduce_24(val, _values)
+ NodeQuery::Compiler::String.new(value: val[0])
+end
+
+def _reduce_25(val, _values)
+ NodeQuery::Compiler::Symbol.new(value: val[0])
+end
+
+def _reduce_26(val, _values)
+ NodeQuery::Compiler::Identifier.new(value: val[0])
+end
+
+def _reduce_none(val, _values)
+  val[0]
+end
+
+end   # class NodeQueryParser

data/lib/node_query_parser.y

@@ -2,7 +2,7 @@ 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
+      tOPERATOR tARRAY_VALUE tBOOLEAN tFLOAT tINTEGER tNIL tREGEXP tSTRING tSYMBOL
 rule
   expression_list
     : expression tCOMMA expression_list { NodeQuery::Compiler::ExpressionList.new(expression: val[0], rest: val[2]) }
@@ -28,7 +28,7 @@ rule
 
   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 tCLOSE_ARRAY { NodeQuery::Compiler::Attribute.new(key: val[0], value: NodeQuery::Compiler::ArrayValue.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
@@ -37,7 +37,6 @@ rule
 
   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])}
@@ -60,4 +59,4 @@ end
 
     def next_token
       @lexer.next_token
-    end
+    end

data/node_query.gemspec

@@ -15,7 +15,7 @@ Gem::Specification.new do |spec|
 
   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"
+  spec.metadata["changelog_uri"] = "https://github.com/xinminlabs/node-query-ruby/blob/master/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.
@@ -23,13 +23,13 @@ Gem::Specification.new do |spec|
     `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
+  end + %w[lib/node_query_lexer.rex.rb lib/node_query_parser.racc.rb]
   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"
+  spec.add_dependency "activesupport", "< 7.0.0"
 
   # For more information and examples about making a new gem, check out our
   # guide at: https://bundler.io/guides/creating_gem.html

data/sig/node_query/adapter.rbs

@@ -0,0 +1,11 @@
+class NodeQuery::Adapter[T]
+  def is_node?: (node: T) -> bool
+
+  def get_node_type: (node: T) -> String
+
+  def get_source: (node: T) -> String
+
+  def get_children: (node: T) -> Array[T]
+
+  def get_siblings: (node: T) -> Array[T]
+end

data/sig/node_query.rbs

@@ -1,11 +1,13 @@
-class NodeQuery
+class NodeQuery[T]
   VERSION: String
 
   def self.configure: (options: { adapter: NodeQuery::Adapter }) -> void
 
-  def self.get_adapter: () -> NodeQuery::Adapter
+  def self.adapter: () -> NodeQuery::Adapter
 
-  def initialize: (nql: String) -> NodeQuery
+  def initialize: (nqlOrRues: String | Hash) -> NodeQuery
 
-  def parse: (node: Node) -> Array[Node]
+  def query_nodes: (node: T, including_self: boolean) -> Array[T]
+
+  def match_node?: (node: T) -> boolean
 end