node_query 1.13.7 → 1.13.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9d3c978851b309269c480384d94e9df4d8f217c3c277cb26992fda3d52c29a9c
-  data.tar.gz: 88aff1c87c8b0383176b9821baae9997314ceee2993fecba4470614e4b2b48d6
+  metadata.gz: 215ae99bb6d5fddf440256e3982a06f8795ab484008dcc736679151f0b1c963a
+  data.tar.gz: 0e69083c8350bc90058d0b5d62e90046d612a4e26e59141bd7722b8657ec6f06
 SHA512:
-  metadata.gz: 90be84a8b0200d32b5996251a657474053fa95bb265c3b9403334c161a374ba54fd8ac4e64c77d15bccae65a9651539522300ba8a9c0c92fb9fde7d51696625f
-  data.tar.gz: 9fa294dfc8e0f1ab399aa21e6dfffdd3b2356e37674d287ba21d3e4c38ffc52727fd48a2edbcce4ca9b03016df322ac52d46b80518dbffb2022b01bdd0c163a3
+  metadata.gz: 561dff60b719e9596343e4f667939b06ffec1078b0802c1236dba472d7051672e1203d610d0e5b4685fcc936728355b69935f1fdf2d2166f85910afa7f484485
+  data.tar.gz: c08f454ba9300e0401d08cff16f269348e9913a6bb1d5b52d237cd0abe45cbb15f5b7dade4f49bdb0b24c279843f954dbf2b4d5ef200533109c14df8a00a9b35

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 # CHANGELOG
 
+## 1.13.9 (2023-08-02)
+
+* Add `OPERATOR` macro
+* Use operator `=` instead of `==`
+
+## 1.13.8 (2023-06-28)
+
+* Check `.to_value` instead of `.type`
+
 ## 1.13.7 (2023-06-26)
 
 * Revert "Flatten syntax_tree children"

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    node_query (1.13.7)
+    node_query (1.13.9)
 
 GEM
   remote: https://rubygems.org/

data/lib/node_query/compiler/attribute.rb

@@ -7,7 +7,7 @@ module NodeQuery::Compiler
     # @param key [String] the key
     # @param value the value can be any class implement {NodeQuery::Compiler::Comparable}
     # @param operator [String] the operator
-    def initialize(key:, value:, operator: '==')
+    def initialize(key:, value:, operator: '=')
       @key = key
       @value = value
       @operator = operator

data/lib/node_query/compiler/basic_selector.rb

@@ -15,7 +15,7 @@ module NodeQuery::Compiler
     # @param node [Node] the node
     # @param base_node [Node] the base node for evaluated value
     # @return [Boolean]
-    def match?(node, base_node, _operator = '==')
+    def match?(node, base_node, _operator = '=')
       return false unless node
 
       @node_type.to_sym == NodeQuery.adapter.get_node_type(node) && (!@attribute_list || @attribute_list.match?(

data/lib/node_query/compiler/comparable.rb

@@ -3,17 +3,17 @@
 module NodeQuery::Compiler
   # Compare acutal value with expected value.
   module Comparable
-    SIMPLE_VALID_OPERATORS = ['==', '!=', 'includes', 'not_includes']
-    STRING_VALID_OPERATORS = ['==', '!=', '^=', '$=', '*=', 'includes', 'not_includes']
-    NUMBER_VALID_OPERATORS = ['==', '!=', '>', '>=', '<', '<=', 'includes', 'not_includes']
-    ARRAY_VALID_OPERATORS = ['==', '!=', 'in', 'not_in']
+    SIMPLE_VALID_OPERATORS = ['=', '!=', 'includes', 'not_includes']
+    STRING_VALID_OPERATORS = ['=', '!=', '^=', '$=', '*=', 'includes', 'not_includes']
+    NUMBER_VALID_OPERATORS = ['=', '!=', '>', '>=', '<', '<=', 'includes', 'not_includes']
+    ARRAY_VALID_OPERATORS = ['=', '!=', 'in', 'not_in']
     REGEXP_VALID_OPERATORS = ['=~', '!~']
 
     # Check if the actual value matches the expected value.
     #
     # @param node [Node] node to calculate actual value
     # @param base_node [Node] the base node for evaluated value
-    # @param operator [String] operator to compare with expected value, operator can be <code>'=='</code>, <code>'!='</code>, <code>'>'</code>, <code>'>='</code>, <code>'<'</code>, <code>'<='</code>, <code>'includes'</code>, <code>'in'</code>, <code>'not_in'</code>, <code>'=~'</code>, <code>'!~'</code>
+    # @param operator [String] operator to compare with expected value, operator can be <code>'='</code>, <code>'!='</code>, <code>'>'</code>, <code>'>='</code>, <code>'<'</code>, <code>'<='</code>, <code>'includes'</code>, <code>'in'</code>, <code>'not_in'</code>, <code>'=~'</code>, <code>'!~'</code>
     # @return [Boolean] true if actual value matches the expected value
     # @raise [NodeQuery::Compiler::InvalidOperatorError] if operator is invalid
     def match?(node, base_node, operator)
@@ -51,9 +51,9 @@ module NodeQuery::Compiler
         actual <= expected
       when 'in'
         if node.is_a?(Array)
-          node.all? { |child| expected.any? { |expected_child| expected_child.match?(child, base_node, '==') } }
+          node.all? { |child| expected.any? { |expected_child| expected_child.match?(child, base_node, '=') } }
         else
-          expected.any? { |expected_child| expected_child.match?(node, base_node, '==') }
+          expected.any? { |expected_child| expected_child.match?(node, base_node, '=') }
         end
       when 'not_in'
         if node.is_a?(Array)
@@ -69,7 +69,7 @@ module NodeQuery::Compiler
         if expected.is_a?(::Array)
           actual.is_a?(::Array) && actual.size == expected.size &&
             actual.zip(expected).all? { |actual_child, expected_child|
-              expected_child.match?(actual_child, base_node, '==')
+              expected_child.match?(actual_child, base_node, '=')
             }
         else
           is_equal?(actual, expected)

data/lib/node_query/compiler/selector.rb

@@ -33,7 +33,7 @@ module NodeQuery::Compiler
     # Check if node matches the selector.
     # @param node [Node] the node
     # @param base_node [Node] the base node for evaluated node
-    def match?(node, base_node, operator = "==")
+    def match?(node, base_node, operator = "=")
       if node.is_a?(::Array)
         case operator
         when "not_includes"

data/lib/node_query/node_rules.rb

@@ -121,7 +121,7 @@ class NodeQuery::NodeRules
       actual.zip(expected).all? { |a, e| match_value?(a, e) }
     when NilClass
       if NodeQuery.adapter.is_node?(actual)
-        :nil == actual.type
+        actual.to_value.nil?
       else
         actual.nil?
       end
@@ -132,9 +132,9 @@ class NodeQuery::NodeRules
         actual == expected
       end
     when TrueClass
-      :true == actual&.type
+      true == actual&.to_value
     when FalseClass
-      :false == actual&.type
+      false == actual&.to_value
     else
       if NodeQuery.adapter.is_node?(expected)
         actual == expected

data/lib/node_query/version.rb

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

data/lib/node_query_lexer.rex

@@ -10,6 +10,7 @@ macros
   NODE_TYPE                /\.[a-zA-Z]+/
   IDENTIFIER               /[@\*\-\.\w]*\w/
   IDENTIFIER_VALUE         /[@\.\w!&:\?<>=]+/
+  OPERATOR                 /(\^=|\$=|\*=|!=|=~|!~|>=|<=|>|<|=|not includes|includes|not in|in)/i
   FALSE                    /false/
   FLOAT                    /\-?\d+\.\d+/
   INTEGER                  /\-?\d+/
@@ -39,21 +40,7 @@ rules
                     /#{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                /not includes/i               { @state = :VALUE; [:tOPERATOR, 'not_includes'] }
-:KEY                /includes/i                   { @state = :VALUE; [:tOPERATOR, 'includes'] }
-:KEY                /not in/i                     { @state = :VALUE; [:tOPERATOR, 'not_in'] }
-:KEY                /in/i                         { @state = :VALUE; [:tOPERATOR, 'in'] }
+:KEY                /#{OPERATOR}/                 { @state = :VALUE; [:tOPERATOR, text.downcase.sub(' ', '_')] }
 :KEY                /#{IDENTIFIER}/               { [:tKEY, text] }
 :VALUE              /\s+/
 :VALUE              /\[\]=/                       { [:tIDENTIFIER_VALUE, text] }

data/lib/node_query_lexer.rex.rb

@@ -23,6 +23,7 @@ class NodeQueryLexer
   NODE_TYPE           = /\.[a-zA-Z]+/
   IDENTIFIER          = /[@\*\-\.\w]*\w/
   IDENTIFIER_VALUE    = /[@\.\w!&:\?<>=]+/
+  OPERATOR            = /(\^=|\$=|\*=|!=|=~|!~|>=|<=|>|<|=|not includes|includes|not in|in)/i
   FALSE               = /false/
   FLOAT               = /\-?\d+\.\d+/
   INTEGER             = /\-?\d+/
@@ -157,36 +158,8 @@ class NodeQueryLexer
           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(/not includes/i) then
-            action { @state = :VALUE; [:tOPERATOR, 'not_includes'] }
-          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(/#{OPERATOR}/) then
+            action { @state = :VALUE; [:tOPERATOR, text.downcase.sub(' ', '_')] }
           when text = ss.scan(/#{IDENTIFIER}/) then
             action { [:tKEY, text] }
           else

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: node_query
 version: !ruby/object:Gem::Version
-  version: 1.13.7
+  version: 1.13.9
 platform: ruby
 authors:
 - Richard Huang
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-06-26 00:00:00.000000000 Z
+date: 2023-08-02 00:00:00.000000000 Z
 dependencies: []
 description: ast node query language
 email:
@@ -78,7 +78,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.13
+rubygems_version: 3.4.17
 signing_key:
 specification_version: 4
 summary: ast node query language