synvert-core 1.2.1 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3c530d34ca0e2db5d9a295cb0cb48c375d13760f09290624805d742328a49103
-  data.tar.gz: 87cc4ef7ab9116bac2cbed78b9f71ab8d4ffa30281554d10319527a9aab94573
+  metadata.gz: 56b98032247ef28e548b34dfd8b2b49bad8744227cd61b4f300c7111b701ff91
+  data.tar.gz: ea75a1e4f442041665dbd9babdc2f7e4b55c4c78c87facef856e903f2d8c96d2
 SHA512:
-  metadata.gz: 1b864e1e350d3467fe12d2c5e26a5c5a0b685752e21802e3773edfbbb8fca8f7dec60fb545475a630a3f00c09359c66859b228cf7cb3d19aa6bf044df4848408
-  data.tar.gz: c8c5641b85080f03307fed835c05132488d140bb19b694c2b5b0958cb3d6377785ef1447c8b7fec59e7529f2ec610f6c78d72357b60f5fe4285d43d5071750fb
+  metadata.gz: 905c1f393a1702df43300432e210784790a30dff9a7bb0c798c742ec372a65ad8487b2097333f57afb1798c566f554ab9096ae92db8cd2541e5bb03769009882
+  data.tar.gz: bd03f1c285c5b5b42628df0b3c8777d6167d980c8c3e3b2f92badfc040b2bef5fe2bef3b848b5a6a166002a5e68f8f4f287ac6ee8fadc72a3ef6706fe191c821

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 # 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

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/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

@@ -5,14 +5,10 @@ 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, goto_scope: nil, rest: nil, relationship: nil)
+    def initialize(selector: nil, rest: nil)
       @selector = selector
-      @goto_scope = goto_scope
       @rest = rest
-      @relationship = relationship
     end
 
     # Check if the node matches the expression.
@@ -22,78 +18,27 @@ 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)
-      return find_nodes_by_goto_scope(node) if @goto_scope
-
-      return find_nodes_by_relationship(node) if @relationship
-
-      matching_nodes = find_nodes_without_relationship(node, descendant_match)
+      matching_nodes = find_nodes_by_selector(node, descendant_match)
       return matching_nodes if @rest.nil?
 
-      matching_nodes.map { |matching_node| find_nodes_by_rest(matching_node, descendant_match) }
-                    .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.to_s if @selector
-      result << "<#{@goto_scope}>" if @goto_scope
-      case @relationship
-      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.to_s if @rest
       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)
-      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
@@ -104,23 +49,10 @@ module Synvert::Core::NodeQuery::Compiler
     # 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
+    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,39 +4,68 @@ 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
       result = []
-      result << ".#{@node_type}" if @node_type
-      result << @attribute_list.to_s if @attribute_list
-      result << ":#{@pseudo_class}(#{@pseudo_expression})" if @pseudo_class
+      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
@@ -52,5 +81,58 @@ module Synvert::Core::NodeQuery::Compiler
       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'
 

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

@@ -22,8 +22,8 @@ macros
   REGEXP                   /\/(#{REGEXP_BODY})(?<!\\)\/([imxo]*)/
   SYMBOL                   /:[\w!\?<>=]+/
   TRUE                     /true/
-  SINGLE_QUOTE_STRING      /'(.*?)'/
-  DOUBLE_QUOTE_STRING      /"(.*?)"/
+  SINGLE_QUOTE_STRING      /'.*?'/
+  DOUBLE_QUOTE_STRING      /".*?"/
 
 rules
 
@@ -36,9 +36,9 @@ rules
                     /:has/                        { [:tPSEUDO_CLASS, text[1..-1]] }
                     /:not_has/                    { [:tPSEUDO_CLASS, text[1..-1]] }
                     /#{NODE_TYPE}/                { [:tNODE_TYPE, text[1..]] }
-                    />/                           { [:tCHILD, text] }
-                    /~/                           { [:tSUBSEQUENT_SIBLING, text] }
-                    /\+/                          { [:tNEXT_SIBLING, text] }
+                    />/                           { [:tRELATIONSHIP, text] }
+                    /~/                           { [:tRELATIONSHIP, text] }
+                    /\+/                          { [:tRELATIONSHIP, text] }
                     /#{OPEN_SELECTOR}/            { [:tOPEN_SELECTOR, text] }
                     /#{CLOSE_SELECTOR}/           { [:tCLOSE_SELECTOR, text] }
                     /#{OPEN_GOTO_SCOPE}/          { @state = :GOTO_SCOPE; [:tOPEN_GOTO_SCOPE, text] }
@@ -47,17 +47,20 @@ rules
 :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] }
-:KEY                /!~/                          { @state = :VALUE; [:tNOT_MATCH, text] }
-:KEY                />=/                          { @state = :VALUE; [:tGREATER_THAN_OR_EQUAL, text] }
-:KEY                /<=/                          { @state = :VALUE; [:tLESS_THAN_OR_EQUAL, text] }
-:KEY                />/                           { @state = :VALUE; [:tGREATER_THAN, text] }
-:KEY                /</                           { @state = :VALUE; [:tLESS_THAN, text] }
-:KEY                /=/                           { @state = :VALUE; [:tEQUAL, text] }
-:KEY                /includes/i                   { @state = :VALUE; [:tINCLUDES, text] }
-:KEY                /not in/i                     { @state = :VALUE; [:tNOT_IN, text] }
-:KEY                /in/i                         { @state = :VALUE; [:tIN, text] }
+: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                /includes/i                   { @state = :VALUE; [:tOPERATOR, 'includes'] }
+:KEY                /not in/i                     { @state = :VALUE; [:tOPERATOR, 'not_in'] }
+:KEY                /in/i                         { @state = :VALUE; [:tOPERATOR, 'in'] }
 :KEY                /#{IDENTIFIER}/               { [:tKEY, text] }
 :VALUE              /\s+/
 :VALUE              /\[\]=/                       { [:tIDENTIFIER_VALUE, text] }

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

@@ -35,8 +35,8 @@ class Synvert::Core::NodeQuery::Lexer
   REGEXP                  = /\/(#{REGEXP_BODY})(?<!\\)\/([imxo]*)/
   SYMBOL                  = /:[\w!\?<>=]+/
   TRUE                    = /true/
-  SINGLE_QUOTE_STRING     = /'(.*?)'/
-  DOUBLE_QUOTE_STRING     = /"(.*?)"/
+  SINGLE_QUOTE_STRING     = /'.*?'/
+  DOUBLE_QUOTE_STRING     = /".*?"/
   # :startdoc:
   # :stopdoc:
   class LexerError < StandardError ; end
@@ -142,11 +142,11 @@ class Synvert::Core::NodeQuery::Lexer
           when text = ss.scan(/#{NODE_TYPE}/) then
             action { [:tNODE_TYPE, text[1..]] }
           when text = ss.scan(/>/) then
-            action { [:tCHILD, text] }
+            action { [:tRELATIONSHIP, text] }
           when text = ss.scan(/~/) then
-            action { [:tSUBSEQUENT_SIBLING, text] }
+            action { [:tRELATIONSHIP, text] }
           when text = ss.scan(/\+/) then
-            action { [:tNEXT_SIBLING, text] }
+            action { [:tRELATIONSHIP, text] }
           when text = ss.scan(/#{OPEN_SELECTOR}/) then
             action { [:tOPEN_SELECTOR, text] }
           when text = ss.scan(/#{CLOSE_SELECTOR}/) then
@@ -175,28 +175,34 @@ class Synvert::Core::NodeQuery::Lexer
           case
           when ss.skip(/\s+/) then
             # do nothing
-          when text = ss.scan(/!=/) then
-            action { @state = :VALUE; [:tNOT_EQUAL, text] }
-          when text = ss.scan(/=~/) then
-            action { @state = :VALUE; [:tMATCH, text] }
-          when text = ss.scan(/!~/) then
-            action { @state = :VALUE; [:tNOT_MATCH, text] }
-          when text = ss.scan(/>=/) then
-            action { @state = :VALUE; [:tGREATER_THAN_OR_EQUAL, text] }
-          when text = ss.scan(/<=/) then
-            action { @state = :VALUE; [:tLESS_THAN_OR_EQUAL, text] }
-          when text = ss.scan(/>/) then
-            action { @state = :VALUE; [:tGREATER_THAN, text] }
-          when text = ss.scan(/</) then
-            action { @state = :VALUE; [:tLESS_THAN, text] }
-          when text = ss.scan(/=/) then
-            action { @state = :VALUE; [:tEQUAL, text] }
-          when text = ss.scan(/includes/i) then
-            action { @state = :VALUE; [:tINCLUDES, text] }
-          when text = ss.scan(/not in/i) then
-            action { @state = :VALUE; [:tNOT_IN, text] }
-          when text = ss.scan(/in/i) then
-            action { @state = :VALUE; [:tIN, text] }
+          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