synvert-core 1.2.1 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3c530d34ca0e2db5d9a295cb0cb48c375d13760f09290624805d742328a49103
-  data.tar.gz: 87cc4ef7ab9116bac2cbed78b9f71ab8d4ffa30281554d10319527a9aab94573
+  metadata.gz: 741ca9c2f6f29e5bbafbc5b63d94b3cd9a56aa20e8a00f3f70830b73b1fb697e
+  data.tar.gz: a8bbf6e0c48a4af42578abb20807f3d86359fc069dc85ff90e12cf011f076998
 SHA512:
-  metadata.gz: 1b864e1e350d3467fe12d2c5e26a5c5a0b685752e21802e3773edfbbb8fca8f7dec60fb545475a630a3f00c09359c66859b228cf7cb3d19aa6bf044df4848408
-  data.tar.gz: c8c5641b85080f03307fed835c05132488d140bb19b694c2b5b0958cb3d6377785ef1447c8b7fec59e7529f2ec610f6c78d72357b60f5fe4285d43d5071750fb
+  metadata.gz: 7fcadf632c863b1f3ba410b65f63c741b594255567f337ebc86c51ae45e681484653b45eec01fc5c3e3a4ea170a6bd38e899bdf22f65b2e980d58cac8c11cfcd
+  data.tar.gz: 80ebe8f07ef9679c6921233d52b46979a6bfb895e4b63b974672dec193ef52ce08c40454d2a92fd509f12b8f3567065bb7d2dbee33af7bca37a96246e6373381

data/CHANGELOG.md

@@ -1,5 +1,21 @@
 # CHANGELOG
 
+## 1.4.0 (2022-05-21)
+
+* Drop support `:first-child` and `:last-child`
+* Redefine goto scope in nql
+* Fix shift/reduce conflict
+
+## 1.3.1 (2022-05-14)
+
+* Add `add_comma` option to remove extra comma
+
+## 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/basic_selector.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Synvert::Core::NodeQuery::Compiler
+  # BasicSelector used to match nodes, it combines by node type and/or attribute list.
+  class BasicSelector
+    # Initialize a BasicSelector.
+    # @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 = [".#{@node_type}"]
+      result << @attribute_list.to_s if @attribute_list
+      result.join('')
+    end
+  end
+end

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,105 +18,24 @@ 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)
+    def query_nodes(node)
+      matching_nodes = @selector.query_nodes(node)
       return matching_nodes if @rest.nil?
 
-      matching_nodes.map { |matching_node| find_nodes_by_rest(matching_node, descendant_match) }
-                    .flatten
+      matching_nodes.flat_map do |matching_node|
+        @rest.query_nodes(matching_node)
+      end
     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
-    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 = []
-      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)
-    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,53 +4,110 @@ 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 basic_selector [Synvert::Core::NodeQuery::Compiler::BasicSelector] 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
-      @index = index
+    # @param pseudo_selector [Synvert::Core::NodeQuery::Compiler::Expression] the pseudo selector
+    def initialize(goto_scope: nil, relationship: nil, rest: nil, basic_selector: nil, pseudo_class: nil, pseudo_selector: nil)
+      @goto_scope = goto_scope
+      @relationship = relationship
+      @rest = rest
+      @basic_selector = basic_selector
       @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) && (!@basic_selector || @basic_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
+    # @return [Array<Parser::AST::Node>] matching nodes.
+    def query_nodes(node)
+      return find_nodes_by_relationship(node) if @relationship
+
+      if node.is_a?(::Array)
+        return node.flat_map { |child_node| query_nodes(child_node) }
+      end
+
+      return find_nodes_by_goto_scope(node) if @goto_scope
+
+      nodes = []
+      nodes << node if match?(node)
+      if @basic_selector
+        node.recursive_children do |child_node|
+          nodes << child_node if match?(child_node)
+        end
+      end
+      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
-      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})"
+      result << "#{@goto_scope} " if @goto_scope
+      result << "#{@relationship} " if @relationship
+      result << @rest.to_s if @rest
+      result << @basic_selector.to_s if @basic_selector
+      result << ":#{@pseudo_class}(#{@pseudo_selector})" if @pseudo_class
+      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)
+    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
+      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
-      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 :BasicSelector, 'synvert/core/node_query/compiler/basic_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

@@ -7,8 +7,6 @@ macros
   CLOSE_ARRAY              /\)/
   OPEN_SELECTOR            /\(/
   CLOSE_SELECTOR           /\)/
-  OPEN_GOTO_SCOPE          /</
-  CLOSE_GOTO_SCOPE         />/
   OPEN_DYNAMIC_ATTRIBUTE   /{{/
   CLOSE_DYNAMIC_ATTRIBUTE  /}}/
   NODE_TYPE                /\.[a-z]+/
@@ -22,42 +20,38 @@ macros
   REGEXP                   /\/(#{REGEXP_BODY})(?<!\\)\/([imxo]*)/
   SYMBOL                   /:[\w!\?<>=]+/
   TRUE                     /true/
-  SINGLE_QUOTE_STRING      /'(.*?)'/
-  DOUBLE_QUOTE_STRING      /"(.*?)"/
+  SINGLE_QUOTE_STRING      /'.*?'/
+  DOUBLE_QUOTE_STRING      /".*?"/
 
 rules
 
 # [:state]          pattern                       [actions]
                     /\s+/
-                    /:first-child/                { [:tINDEX, 0] }
-                    /:last-child/                 { [:tINDEX, -1] }
-                    /:nth-child\(\d+\)/           { [:tINDEX, text.sub(':nth-child(', '').to_i - 1] }
-                    /:nth-last-child\(\d+\)/      { [:tINDEX, -text.sub(':nth-last-child(', '').to_i] }
                     /: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] }
+                    /#{IDENTIFIER}/               { [:tGOTO_SCOPE, 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] }
                     /#{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] }
-: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] }