synvert-core 1.1.1 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b3972bef6a4c4b41b4211e2f45d889c6e3c71b08b1b2b039ca3511a620f79ccf
-  data.tar.gz: 7ddecb20188351e72e59b4a72c67a45d395638ae7a20d3c4d46f3fef0184de3c
+  metadata.gz: e5bf36b2f9e986dd2baf0bbddf53f4671a3bf98af0db830c270960eb583b47ce
+  data.tar.gz: 7e8693858d73d11c09652076ee03d49fe69662386caff67cbd0a3cc37e47d0a2
 SHA512:
-  metadata.gz: b89480e5d9d05fe0651b5cd9edd1a4408a52364d449d0632baf062dd40251670b8c7d98370fa831f6961454498e9fbfffa67011a4fabb45f21e6031933643c36
-  data.tar.gz: c23844951b2938268289099f852f01d554e46a7aa80ad301011d05cc40a022864dd872a8097c71575a42e8770730dbfea2deea8d867af0412022506751cf2671
+  metadata.gz: ad0eb6125d82241c60f7f0e229b9735f7c253280f1e56d586dfd24e8afb9c25b2cf574ca9c21e252c485f529b1bdf5f6b26c2b59805781cdefd3bc07a76072d8
+  data.tar.gz: 37bd754087a17d55577a10338fef9da3c60733d8634e9c394666a826fe205dc7f895121570f1e9cca4e7e1284f0b3b11c16e532e197afe2cd0ce61424c5d1557

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 # CHANGELOG
 
+## 1.2.0 (2022-04-29)
+
+* Remove comma in NQL array value
+* Parse pseduo class without selector in NQL
+* Parse multiple goto scope in NQL
+* Parse `nil?` in NQL
+
 ## 1.1.1 (2022-04-27)
 
 * Parse empty string properly in node query language

data/lib/synvert/core/array_ext.rb

@@ -13,7 +13,7 @@ class Array
     return child_direct_child_node if child_direct_child_node
 
     raise Synvert::Core::MethodNotSupported,
-          "child_node_by_name is not handled for #{map(&:debug_info).join("\n")}, child_name: #{child_name}"
+          "child_node_by_name is not handled for #{debug_info}, child_name: #{child_name}"
   end
 
   # Get the source range of child node.
@@ -35,7 +35,14 @@ class Array
       )
     else
       raise Synvert::Core::MethodNotSupported,
-            "child_node_range is not handled for #{map(&:debug_info).join("\n")}, child_name: #{child_name}"
+            "child_node_range is not handled for #{debug_info}, child_name: #{child_name}"
     end
   end
+
+  # Return the debug info.
+  #
+  # @return [String] file, line, source and node.
+  def debug_info
+    map(&:debug_info).join("\n")
+  end
 end

data/lib/synvert/core/node_query/compiler/array.rb

@@ -28,7 +28,7 @@ module Synvert::Core::NodeQuery::Compiler
     end
 
     def to_s
-      [@value, @rest].compact.join(', ')
+      [@value, @rest].compact.join(' ')
     end
   end
 end

data/lib/synvert/core/node_query/compiler/expression.rb

@@ -5,10 +5,12 @@ module Synvert::Core::NodeQuery::Compiler
   class Expression
     # Initialize a Expression.
     # @param selector [Synvert::Core::NodeQuery::Compiler::Selector] the selector
+    # @param goto_scope [String] goto scope
     # @param rest [Synvert::Core::NodeQuery::Compiler::Expression] the rest expression
     # @param relationship [Symbol] the relationship between the selector and rest expression, it can be <code>:descendant</code>, <code>:child</code>, <code>:next_sibling</code>, <code>:subsequent_sibling</code> or <code>nil</code>.
-    def initialize(selector: nil, rest: nil, relationship: nil)
+    def initialize(selector: nil, goto_scope: nil, rest: nil, relationship: nil)
       @selector = selector
+      @goto_scope = goto_scope
       @rest = rest
       @relationship = relationship
     end
@@ -30,49 +32,85 @@ module Synvert::Core::NodeQuery::Compiler
     # @param node [Parser::AST::Node] node to match
     # @param descendant_match [Boolean] whether to match in descendant node
     # @return [Array<Parser::AST::Node>] matching nodes.
-    def query_nodes(node, descendant_match: true)
-      matching_nodes = find_nodes_without_relationship(node, descendant_match: descendant_match)
-      if @relationship.nil?
-        return matching_nodes
-      end
+    def query_nodes(node, descendant_match = true)
+      return find_nodes_by_goto_scope(node) if @goto_scope
 
-      expression_nodes = matching_nodes.map do |matching_node|
-        case @relationship
-        when :descendant
-          nodes = []
-          matching_node.recursive_children { |child_node|
-            nodes += @rest.query_nodes(child_node, descendant_match: false)
-          }
-          nodes
-        when :child
-          matching_node.children.map { |child_node| @rest.query_nodes(child_node, descendant_match: false) }
-                       .flatten
-        when :next_sibling
-          @rest.query_nodes(matching_node.siblings.first, descendant_match: false)
-        when :subsequent_sibling
-          matching_node.siblings.map { |sibling_node| @rest.query_nodes(sibling_node, descendant_match: false) }
-                       .flatten
-        end
-      end.flatten
+      return find_nodes_by_relationship(node) if @relationship
+
+      matching_nodes = find_nodes_without_relationship(node, descendant_match)
+      return matching_nodes if @rest.nil?
+
+      matching_nodes.map { |matching_node| find_nodes_by_rest(matching_node, descendant_match) }
+                    .flatten
     end
 
     def to_s
       return @selector.to_s unless @rest
 
       result = []
-      result << @selector if @selector
+      result << @selector.to_s if @selector
+      result << "<#{@goto_scope}>" if @goto_scope
       case @relationship
-      when :child then result << '>'
-      when :subsequent_sibling then result << '~'
-      when :next_sibling then result << '+'
+      when :child then result << "> #{@rest}"
+      when :subsequent_sibling then result << "~ #{@rest}"
+      when :next_sibling then result << "+ #{@rest}"
+      when :has then result << ":has(#{@rest})"
+      when :not_has then result << ":not_has(#{@rest})"
+      else result << @rest.to_s
       end
-      result << @rest
-      result.map(&:to_s).join(' ')
+      result.join(' ')
     end
 
     private
 
-    def find_nodes_without_relationship(node, descendant_match: true)
+    # Find nodes by @goto_scope
+    # @param node [Parser::AST::Node] node to match
+    def find_nodes_by_goto_scope(node)
+      @goto_scope.split('.').each { |scope| node = node.send(scope) }
+      @rest.query_nodes(node, false)
+    end
+
+    # Find ndoes by @relationship
+    # @param node [Parser::AST::Node] node to match
+    def find_nodes_by_relationship(node)
+      case @relationship
+      when :child
+        if node.is_a?(::Array)
+          return node.map { |each_node| find_nodes_by_rest(each_node) }
+                     .flatten
+        else
+          return node.children.map { |each_node| find_nodes_by_rest(each_node) }
+                     .flatten
+        end
+      when :next_sibling
+        return find_nodes_by_rest(node.siblings.first)
+      when :subsequent_sibling
+        return node.siblings.map { |each_node| find_nodes_by_rest(each_node) }
+                   .flatten
+      when :has
+        return @rest.match?(node) ? [node] : []
+      when :not_has
+        return !@rest.match?(node) ? [node] : []
+      end
+    end
+
+    # Find nodes by @rest
+    # @param node [Parser::AST::Node] node to match
+    # @param descendant_match [Boolean] whether to match in descendant node
+    def find_nodes_by_rest(node, descendant_match = false)
+      @rest.query_nodes(node, descendant_match)
+    end
+
+    # Find nodes with nil relationship.
+    # @param node [Parser::AST::Node] node to match
+    # @param descendant_match [Boolean] whether to match in descendant node
+    def find_nodes_without_relationship(node, descendant_match = true)
+      if node.is_a?(::Array)
+        return node.map { |each_node|
+          find_nodes_without_relationship(each_node, descendant_match)
+        }.flatten
+      end
+
       return [node] unless @selector
 
       nodes = []

data/lib/synvert/core/node_query/compiler/selector.rb

@@ -33,21 +33,24 @@ module Synvert::Core::NodeQuery::Compiler
     end
 
     def to_s
-      str = ".#{@node_type}#{@attribute_list}"
-      return str if !@index && !@pseudo_class
-
-      return "#{str}:#{@pseudo_class}(#{@pseudo_expression})" if @pseudo_class
-
-      case @index
-      when 0
-        str + ':first-child'
-      when -1
-        str + ':last-child'
-      when (1..)
-        str + ":nth-child(#{@index + 1})"
-      else # ...-1
-        str + ":nth-last-child(#{-@index})"
+      result = []
+      result << ".#{@node_type}" if @node_type
+      result << @attribute_list.to_s if @attribute_list
+      result << ":#{@pseudo_class}(#{@pseudo_expression})" if @pseudo_class
+      if @index
+        result <<
+          case @index
+          when 0
+            ':first-child'
+          when -1
+            ':last-child'
+          when (1..)
+            ":nth-child(#{@index + 1})"
+          else # ...-1
+            ":nth-last-child(#{-@index})"
+          end
       end
+      result.join('')
     end
   end
 end

data/lib/synvert/core/node_query/lexer.rex

@@ -7,6 +7,8 @@ macros
   CLOSE_ARRAY              /\)/
   OPEN_SELECTOR            /\(/
   CLOSE_SELECTOR           /\)/
+  OPEN_GOTO_SCOPE          /</
+  CLOSE_GOTO_SCOPE         />/
   OPEN_DYNAMIC_ATTRIBUTE   /{{/
   CLOSE_DYNAMIC_ATTRIBUTE  /}}/
   NODE_TYPE                /\.[a-z]+/
@@ -39,7 +41,11 @@ rules
                     /\+/                          { [:tNEXT_SIBLING, text] }
                     /#{OPEN_SELECTOR}/            { [:tOPEN_SELECTOR, text] }
                     /#{CLOSE_SELECTOR}/           { [:tCLOSE_SELECTOR, text] }
+                    /#{OPEN_GOTO_SCOPE}/          { @state = :GOTO_SCOPE; [:tOPEN_GOTO_SCOPE, text] }
                     /#{OPEN_ATTRIBUTE}/           { @nested_count += 1; @state = :KEY; [:tOPEN_ATTRIBUTE, text] }
+:GOTO_SCOPE         /\s+/
+:GOTO_SCOPE         /#{IDENTIFIER}/               { [:tIDENTIFIER, text] }
+:GOTO_SCOPE         /#{CLOSE_GOTO_SCOPE}/         { @state = nil; [:tCLOSE_GOTO_SCOPE, text] }
 :KEY                /\s+/
 :KEY                /!=/                          { @state = :VALUE; [:tNOT_EQUAL, text] }
 :KEY                /=~/                          { @state = :VALUE; [:tMATCH, text] }
@@ -61,6 +67,7 @@ rules
 :VALUE              /#{OPEN_DYNAMIC_ATTRIBUTE}/   { @state = :DYNAMIC_ATTRIBUTE; [:tOPEN_DYNAMIC_ATTRIBUTE, text] }
 :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] }
@@ -76,8 +83,8 @@ rules
 :DYNAMIC_ATTRIBUTE  /#{CLOSE_DYNAMIC_ATTRIBUTE}/  { @state = :VALUE; [:tCLOSE_DYNAMIC_ATTRIBUTE, text] }
 :DYNAMIC_ATTRIBUTE  /#{IDENTIFIER}/               { [:tDYNAMIC_ATTRIBUTE, text] }
 :ARRAY_VALUE        /\s+/
-:ARRAY_VALUE        /,/                           { [:tCOMMA, text] }
 :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] }

data/lib/synvert/core/node_query/lexer.rex.rb

@@ -20,6 +20,8 @@ class Synvert::Core::NodeQuery::Lexer
   CLOSE_ARRAY             = /\)/
   OPEN_SELECTOR           = /\(/
   CLOSE_SELECTOR          = /\)/
+  OPEN_GOTO_SCOPE         = /</
+  CLOSE_GOTO_SCOPE        = />/
   OPEN_DYNAMIC_ATTRIBUTE  = /{{/
   CLOSE_DYNAMIC_ATTRIBUTE = /}}/
   NODE_TYPE               = /\.[a-z]+/
@@ -149,12 +151,26 @@ class Synvert::Core::NodeQuery::Lexer
             action { [:tOPEN_SELECTOR, text] }
           when text = ss.scan(/#{CLOSE_SELECTOR}/) then
             action { [:tCLOSE_SELECTOR, text] }
+          when text = ss.scan(/#{OPEN_GOTO_SCOPE}/) then
+            action { @state = :GOTO_SCOPE; [:tOPEN_GOTO_SCOPE, 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 :GOTO_SCOPE then
+          case
+          when ss.skip(/\s+/) then
+            # do nothing
+          when text = ss.scan(/#{IDENTIFIER}/) then
+            action { [:tIDENTIFIER, text] }
+          when text = ss.scan(/#{CLOSE_GOTO_SCOPE}/) then
+            action { @state = nil; [:tCLOSE_GOTO_SCOPE, 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
@@ -205,6 +221,8 @@ class Synvert::Core::NodeQuery::Lexer
             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
@@ -247,10 +265,10 @@ class Synvert::Core::NodeQuery::Lexer
           case
           when ss.skip(/\s+/) then
             # do nothing
-          when text = ss.scan(/,/) then
-            action { [:tCOMMA, text] }
           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