synvert-core 1.2.1 → 1.4.0

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

@@ -20,8 +20,6 @@ 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]+/
@@ -35,8 +33,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
@@ -127,76 +125,62 @@ class Synvert::Core::NodeQuery::Lexer
           case
           when ss.skip(/\s+/) then
             # do nothing
-          when ss.skip(/:first-child/) then
-            action { [:tINDEX, 0] }
-          when ss.skip(/:last-child/) then
-            action { [:tINDEX, -1] }
-          when text = ss.scan(/:nth-child\(\d+\)/) then
-            action { [:tINDEX, text.sub(':nth-child(', '').to_i - 1] }
-          when text = ss.scan(/:nth-last-child\(\d+\)/) then
-            action { [:tINDEX, -text.sub(':nth-last-child(', '').to_i] }
           when text = ss.scan(/:has/) then
             action { [:tPSEUDO_CLASS, text[1..-1]] }
           when text = ss.scan(/:not_has/) then
             action { [:tPSEUDO_CLASS, text[1..-1]] }
           when text = ss.scan(/#{NODE_TYPE}/) then
             action { [:tNODE_TYPE, text[1..]] }
+          when text = ss.scan(/#{IDENTIFIER}/) then
+            action { [:tGOTO_SCOPE, text] }
           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
             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
             # 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