synvert-core 1.1.1 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b3972bef6a4c4b41b4211e2f45d889c6e3c71b08b1b2b039ca3511a620f79ccf
-  data.tar.gz: 7ddecb20188351e72e59b4a72c67a45d395638ae7a20d3c4d46f3fef0184de3c
+  metadata.gz: 56b98032247ef28e548b34dfd8b2b49bad8744227cd61b4f300c7111b701ff91
+  data.tar.gz: ea75a1e4f442041665dbd9babdc2f7e4b55c4c78c87facef856e903f2d8c96d2
 SHA512:
-  metadata.gz: b89480e5d9d05fe0651b5cd9edd1a4408a52364d449d0632baf062dd40251670b8c7d98370fa831f6961454498e9fbfffa67011a4fabb45f21e6031933643c36
-  data.tar.gz: c23844951b2938268289099f852f01d554e46a7aa80ad301011d05cc40a022864dd872a8097c71575a42e8770730dbfea2deea8d867af0412022506751cf2671
+  metadata.gz: 905c1f393a1702df43300432e210784790a30dff9a7bb0c798c742ec372a65ad8487b2097333f57afb1798c566f554ab9096ae92db8cd2541e5bb03769009882
+  data.tar.gz: bd03f1c285c5b5b42628df0b3c8777d6167d980c8c3e3b2f92badfc040b2bef5fe2bef3b848b5a6a166002a5e68f8f4f287ac6ee8fadc72a3ef6706fe191c821

data/CHANGELOG.md

@@ -1,5 +1,23 @@
 # CHANGELOG
 
+## 1.3.0 (2022-05-12)
+
+* Support `*=`, `^=` and `$=` operators
+* Simplify RELATIONSHIP parser
+* Rewrite compiler, let the selector to query nodes
+
+## 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

data/Gemfile

@@ -4,3 +4,12 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in synvert.gemspec
 gemspec
+
+gem "guard"
+gem "guard-rspec"
+gem "guard-rake"
+gem "oedipus_lex"
+gem "racc"
+gem "rake"
+gem "rspec"
+gem "rspec-mocks"

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/attribute.rb

@@ -7,7 +7,7 @@ module Synvert::Core::NodeQuery::Compiler
     # @param key [String] the key
     # @param value the value can be any class implement {Synvert::Core::NodeQuery::Compiler::Comparable}
     # @param operator [Symbol] the operator
-    def initialize(key:, value:, operator: :==)
+    def initialize(key:, value:, operator: '==')
       @key = key
       @value = value
       @operator = operator
@@ -23,25 +23,13 @@ module Synvert::Core::NodeQuery::Compiler
 
     def to_s
       case @operator
-      when :!=
-        "#{@key}!=#{@value}"
-      when :=~
-        "#{@key}=~#{@value}"
-      when :!~
-        "#{@key}!~#{@value}"
-      when :>
-        "#{@key}>#{@value}"
-      when :>=
-        "#{@key}>=#{@value}"
-      when :<
-        "#{@key}<#{@value}"
-      when :<=
-        "#{@key}<=#{@value}"
-      when :in
+      when '^=', '$=', '*=', '!=', '=~', '!~', '>=', '>', '<=', '<'
+        "#{@key}#{@operator}#{@value}"
+      when 'in'
         "#{@key} in (#{@value})"
-      when :not_in
+      when 'not_in'
         "#{@key} not in (#{@value})"
-      when :includes
+      when 'includes'
         "#{@key} includes #{@value}"
       else
         "#{@key}=#{@value}"

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

@@ -3,52 +3,59 @@
 module Synvert::Core::NodeQuery::Compiler
   # Compare acutal value with expected value.
   module Comparable
-    SIMPLE_VALID_OPERATORS = [:==, :!=, :includes]
-    NUMBER_VALID_OPERATORS = [:==, :!=, :>, :>=, :<, :<=, :includes]
-    ARRAY_VALID_OPERATORS = [:==, :!=, :in, :not_in]
-    REGEXP_VALID_OPERATORS = [:=~, :!~]
+    SIMPLE_VALID_OPERATORS = ['==', '!=', 'includes']
+    STRING_VALID_OPERATORS = ['==', '!=', '^=', '$=', '*=', 'includes']
+    NUMBER_VALID_OPERATORS = ['==', '!=', '>', '>=', '<', '<=', 'includes']
+    ARRAY_VALID_OPERATORS = ['==', '!=', 'in', 'not_in']
+    REGEXP_VALID_OPERATORS = ['=~', '!~']
 
     # Check if the actual value matches the expected value.
     #
     # @param node [Parser::AST::Node] node to calculate actual value
-    # @param operator [Symbol] 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 [Symbol] 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 [Synvert::Core::NodeQuery::Compiler::InvalidOperatorError] if operator is invalid
     def match?(node, operator)
       raise InvalidOperatorError, "invalid operator #{operator}" unless valid_operator?(operator)
 
       case operator
-      when :!=
+      when '!='
         if expected_value.is_a?(::Array)
           actual = actual_value(node)
           !actual.is_a?(::Array) || actual.size != expected_value.size ||
-            actual.zip(expected_value).any? { |actual_node, expected_node| expected_node.match?(actual_node, :!=) }
+            actual.zip(expected_value).any? { |actual_node, expected_node| expected_node.match?(actual_node, '!=') }
         else
           actual_value(node) != expected_value
         end
-      when :=~
+      when '=~'
         actual_value(node) =~ expected_value
-      when :!~
+      when '!~'
         actual_value(node) !~ expected_value
-      when :>
+      when '^='
+        actual_value(node).start_with?(expected_value)
+      when '$='
+        actual_value(node).end_with?(expected_value)
+      when '*='
+        actual_value(node).include?(expected_value)
+      when '>'
         actual_value(node) > expected_value
-      when :>=
+      when '>='
         actual_value(node) >= expected_value
-      when :<
+      when '<'
         actual_value(node) < expected_value
-      when :<=
+      when '<='
         actual_value(node) <= expected_value
-      when :in
-        expected_value.any? { |expected| expected.match?(node, :==) }
-      when :not_in
-        expected_value.all? { |expected| expected.match?(node, :!=) }
-      when :includes
+      when 'in'
+        expected_value.any? { |expected| expected.match?(node, '==') }
+      when 'not_in'
+        expected_value.all? { |expected| expected.match?(node, '!=') }
+      when 'includes'
         actual_value(node).any? { |actual| actual == expected_value }
       else
         if expected_value.is_a?(::Array)
           actual = actual_value(node)
           actual.is_a?(::Array) && actual.size == expected_value.size &&
-            actual.zip(expected_value).all? { |actual_node, expected_node| expected_node.match?(actual_node, :==) }
+            actual.zip(expected_value).all? { |actual_node, expected_node| expected_node.match?(actual_node, '==') }
         else
           actual_value(node) == expected_value
         end

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

@@ -6,11 +6,9 @@ module Synvert::Core::NodeQuery::Compiler
     # Initialize a Expression.
     # @param selector [Synvert::Core::NodeQuery::Compiler::Selector] the selector
     # @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, rest: nil)
       @selector = selector
       @rest = rest
-      @relationship = relationship
     end
 
     # Check if the node matches the expression.
@@ -20,69 +18,41 @@ module Synvert::Core::NodeQuery::Compiler
       !query_nodes(node).empty?
     end
 
-    # Query nodes by the expression.
+    # Query nodes by the selector and the rest expression.
     #
-    # * 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 [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)
+      matching_nodes = find_nodes_by_selector(node, descendant_match)
+      return matching_nodes if @rest.nil?
 
-      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
+      matching_nodes.flat_map { |matching_node| find_nodes_by_rest(matching_node, descendant_match) }
     end
 
     def to_s
-      return @selector.to_s unless @rest
-
       result = []
-      result << @selector if @selector
-      case @relationship
-      when :child then result << '>'
-      when :subsequent_sibling then result << '~'
-      when :next_sibling then result << '+'
-      end
-      result << @rest
-      result.map(&:to_s).join(' ')
+      result << @selector.to_s if @selector
+      result << @rest.to_s if @rest
+      result.join(' ')
     end
 
     private
 
-    def find_nodes_without_relationship(node, descendant_match: true)
-      return [node] unless @selector
+    # 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_by_selector(node, descendant_match = true)
+      return Array(node) if !@selector
 
-      nodes = []
-      nodes << node if @selector.match?(node)
-      if descendant_match
-        node.recursive_children do |child_node|
-          nodes << child_node if @selector.match?(child_node)
-        end
-      end
-      @selector.filter(nodes)
+      @selector.query_nodes(node, descendant_match)
     end
   end
 end

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

@@ -31,7 +31,7 @@ module Synvert::Core::NodeQuery::Compiler
 
     # Get valid operators.
     def valid_operators
-      SIMPLE_VALID_OPERATORS
+      STRING_VALID_OPERATORS
     end
 
     def to_s

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

@@ -15,14 +15,14 @@ module Synvert::Core::NodeQuery::Compiler
     # @param node [Parser::AST::Node] the node
     # @param operator [Symbol] the operator
     # @return [Boolean] true if the regexp value matches the node value, otherwise, false.
-    def match?(node, operator = :=~)
+    def match?(node, operator = '=~')
       match =
         if node.is_a?(::Parser::AST::Node)
           @value.match(node.to_source)
         else
           @value.match(node.to_s)
         end
-      operator == :=~ ? match : !match
+      operator == '=~' ? match : !match
     end
 
     # Get valid operators.

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

@@ -4,50 +4,135 @@ module Synvert::Core::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 node_type [String] the node type
+    # @param goto_scope [String] goto scope
+    # @param relationship [Symbol] 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 [Synvert::Core::NodeQuery::Compiler::Selector] the rest selector
+    # @param simple_selector [Synvert::Core::NodeQuery::Compiler::SimpleSelector] the simple selector
     # @param attribute_list [Synvert::Core::NodeQuery::Compiler::AttributeList] the attribute list
     # @param index [Integer] the index
     # @param pseudo_class [String] the pseudo class, can be <code>has</code> or <code>not_has</code>
-    # @param pseudo_expression [Synvert::Core::NodeQuery::Compiler::Expression] the pseudo expression
-    def initialize(node_type: nil, attribute_list: nil, index: nil, pseudo_class: nil, pseudo_expression: nil)
-      @node_type = node_type
-      @attribute_list = attribute_list
+    # @param pseudo_selector [Synvert::Core::NodeQuery::Compiler::Expression] the pseudo selector
+    def initialize(goto_scope: nil, relationship: nil, rest: nil, simple_selector: nil, index: nil, pseudo_class: nil, pseudo_selector: nil)
+      @goto_scope = goto_scope
+      @relationship = relationship
+      @rest = rest
+      @simple_selector = simple_selector
       @index = index
       @pseudo_class = pseudo_class
-      @pseudo_expression = pseudo_expression
-    end
-
-    # Filter nodes by index.
-    def filter(nodes)
-      return nodes if @index.nil?
-
-      nodes[@index] ? [nodes[@index]] : []
+      @pseudo_selector = pseudo_selector
     end
 
     # Check if node matches the selector.
     # @param node [Parser::AST::Node] the node
-    def match?(node, _operator = :==)
-      (!@node_type || (node.is_a?(::Parser::AST::Node) && @node_type.to_sym == node.type)) &&
-        (!@attribute_list || @attribute_list.match?(node)) &&
-        (!@pseudo_class || (@pseudo_class == 'has' && @pseudo_expression.match?(node)) || (@pseudo_class == 'not_has' && !@pseudo_expression.match?(node)))
+    def match?(node)
+      node.is_a?(::Parser::AST::Node) &&
+        (!@simple_selector || @simple_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 [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)
+      return find_nodes_by_relationship(node) if @relationship
+
+      if node.is_a?(::Array)
+        return node.flat_map { |child_node| query_nodes(child_node, descendant_match) }
+      end
+
+      return find_nodes_by_goto_scope(node) if @goto_scope
+
+      nodes = []
+      nodes << node if match?(node)
+      if descendant_match && @simple_selector
+        node.recursive_children do |child_node|
+          nodes << child_node if match?(child_node)
+        end
+      end
+      filter(nodes)
     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 << "<#{@goto_scope}> " if @goto_scope
+      result << "#{@relationship} " if @relationship
+      result << @rest.to_s if @rest
+      result << @simple_selector.to_s if @simple_selector
+      result << ":#{@pseudo_class}(#{@pseudo_selector})" 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
+
+    private
+
+    # 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)
+      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
+      return filter(nodes)
+    end
+
+    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
+
+    # Filter nodes by index.
+    def filter(nodes)
+      return nodes if @index.nil?
+
+      nodes[@index] ? [nodes[@index]] : []
+    end
   end
 end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Synvert::Core::NodeQuery::Compiler
+  # SimpleSelector used to match nodes, it combines by node type and/or attribute list.
+  class SimpleSelector
+    # Initialize a SimpleSelector.
+    # @param node_type [String] the node type
+    # @param attribute_list [Synvert::Core::NodeQuery::Compiler::AttributeList] the attribute list
+    def initialize(node_type:, attribute_list: nil)
+      @node_type = node_type
+      @attribute_list = attribute_list
+    end
+
+    # Check if node matches the selector.
+    # @param node [Parser::AST::Node] the node
+    def match?(node, _operator = '==')
+      return false unless node
+
+      @node_type.to_sym == node.type && (!@attribute_list || @attribute_list.match?(node))
+    end
+
+    def to_s
+      result = []
+      result << ".#{@node_type}" if @node_type
+      result << @attribute_list.to_s if @attribute_list
+      result.join('')
+    end
+  end
+end

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

@@ -13,7 +13,7 @@ module Synvert::Core::NodeQuery::Compiler
 
     # Get valid operators.
     def valid_operators
-      SIMPLE_VALID_OPERATORS
+      STRING_VALID_OPERATORS
     end
 
     def to_s

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

@@ -8,6 +8,7 @@ module Synvert::Core::NodeQuery::Compiler
 
   autoload :Expression, 'synvert/core/node_query/compiler/expression'
   autoload :Selector, 'synvert/core/node_query/compiler/selector'
+  autoload :SimpleSelector, 'synvert/core/node_query/compiler/simple_selector'
   autoload :AttributeList, 'synvert/core/node_query/compiler/attribute_list'
   autoload :Attribute, 'synvert/core/node_query/compiler/attribute'