synvert-core 1.1.0 → 1.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 603dafd1ddc6f40f8ef1479d359e39e1f4dbe90067bcfe51f721b15e9571c4d0
-  data.tar.gz: e423e49c531e6ba91f490657f34564f781f3313d82dbf9a863ee2c17985500a8
+  metadata.gz: 3c530d34ca0e2db5d9a295cb0cb48c375d13760f09290624805d742328a49103
+  data.tar.gz: 87cc4ef7ab9116bac2cbed78b9f71ab8d4ffa30281554d10319527a9aab94573
 SHA512:
-  metadata.gz: e6177477cdf8c0cdd67d6dc533145017daebee61905b5e48b992261f6f458b8a949796aa86eb0cd8f161ffaa05b9325e1cd671b6d63fd645ece7f2101e67859c
-  data.tar.gz: c1daa4cca1056d9266c01037217cd6570f0b7ee0228491e408d43c7bf8bf753a52b2dbfbf20d6aa568876d7e1d7ee11727db40adbc56e17fc603ae091804475a
+  metadata.gz: 1b864e1e350d3467fe12d2c5e26a5c5a0b685752e21802e3773edfbbb8fca8f7dec60fb545475a630a3f00c09359c66859b228cf7cb3d19aa6bf044df4848408
+  data.tar.gz: c8c5641b85080f03307fed835c05132488d140bb19b694c2b5b0958cb3d6377785ef1447c8b7fec59e7529f2ec610f6c78d72357b60f5fe4285d43d5071750fb

data/CHANGELOG.md

@@ -1,5 +1,22 @@
 # CHANGELOG
 
+## 1.2.1 (2022-05-01)
+
+* Selector always after a node type in NQL
+* Define `pairs` method for `hash` ndoe
+
+## 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
+* Parse `[]` and `[]=` properly in node query language
+
 ## 1.1.0 (2022-04-26)
 
 * Dynamic define Node methods by `TYPE_CHILDREN` const

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_ext.rb

@@ -93,9 +93,21 @@ module Parser::AST
     end
 
     # Dyamically defined method
-    # caller, key, left_value, message, name, parent_class, parent_const, receivr, rgith_value and value.
+    # caller, key, left_value, message, name, pairs, parent_class, parent_const, receivr, rgith_value and value.
     # based on const TYPE_CHILDREN.
-    %i[caller key left_value message name parent_class parent_const receiver right_value value].each do |method_name|
+    %i[
+      caller
+      key
+      left_value
+      message
+      name
+      pairs
+      parent_class
+      parent_const
+      receiver
+      right_value
+      value
+    ].each do |method_name|
       define_method(method_name) do
         index = TYPE_CHILDREN[type]&.index(method_name)
         return children[index] if index

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/compiler/string.rb

@@ -16,17 +16,6 @@ module Synvert::Core::NodeQuery::Compiler
       SIMPLE_VALID_OPERATORS
     end
 
-    # Get the actual value of a node.
-    # @param node [Parser::AST::Node] the node
-    # @return [String] if node is a Parser::AST::Node, return the node source code, otherwise, return the string value.
-    def actual_value(node)
-      if node.is_a?(::Parser::AST::Node)
-        node.to_source
-      else
-        node.to_s
-      end
-    end
-
     def to_s
       "\"#{@value}\""
     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] }
@@ -54,9 +60,14 @@ rules
 :KEY                /in/i                         { @state = :VALUE; [:tIN, text] }
 :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              /#{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] }
@@ -72,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
@@ -191,12 +207,22 @@ class Synvert::Core::NodeQuery::Lexer
           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_DYNAMIC_ATTRIBUTE}/) then
             action { @state = :DYNAMIC_ATTRIBUTE; [:tOPEN_DYNAMIC_ATTRIBUTE, text] }
           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
@@ -239,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