synvert-core 1.4.0 → 1.6.0

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

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-module Synvert::Core::NodeQuery::Compiler
-  autoload :InvalidOperatorError, 'synvert/core/node_query/compiler/invalid_operator_error'
-  autoload :ParseError, 'synvert/core/node_query/compiler/parse_error'
-
-  autoload :Comparable, 'synvert/core/node_query/compiler/comparable'
-
-  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'
-
-  autoload :Array, 'synvert/core/node_query/compiler/array'
-  autoload :Boolean, 'synvert/core/node_query/compiler/boolean'
-  autoload :DynamicAttribute, 'synvert/core/node_query/compiler/dynamic_attribute'
-  autoload :Float, 'synvert/core/node_query/compiler/float'
-  autoload :Identifier, 'synvert/core/node_query/compiler/identifier'
-  autoload :Integer, 'synvert/core/node_query/compiler/integer'
-  autoload :Nil, 'synvert/core/node_query/compiler/nil'
-  autoload :Regexp, 'synvert/core/node_query/compiler/regexp'
-  autoload :String, 'synvert/core/node_query/compiler/string'
-  autoload :Symbol, 'synvert/core/node_query/compiler/symbol'
-end

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

@@ -1,99 +0,0 @@
-class Synvert::Core::NodeQuery::Lexer
-
-macros
-  OPEN_ATTRIBUTE           /\[/
-  CLOSE_ATTRIBUTE          /\]/
-  OPEN_ARRAY               /\(/
-  CLOSE_ARRAY              /\)/
-  OPEN_SELECTOR            /\(/
-  CLOSE_SELECTOR           /\)/
-  OPEN_DYNAMIC_ATTRIBUTE   /{{/
-  CLOSE_DYNAMIC_ATTRIBUTE  /}}/
-  NODE_TYPE                /\.[a-z]+/
-  IDENTIFIER               /[\.\w]+/
-  IDENTIFIER_VALUE         /[\.\w!&:\?<>=]+/
-  FALSE                    /false/
-  FLOAT                    /\d+\.\d+/
-  INTEGER                  /\d+/
-  NIL                      /nil/
-  REGEXP_BODY              /(?:[^\/]|\\\/)*/
-  REGEXP                   /\/(#{REGEXP_BODY})(?<!\\)\/([imxo]*)/
-  SYMBOL                   /:[\w!\?<>=]+/
-  TRUE                     /true/
-  SINGLE_QUOTE_STRING      /'.*?'/
-  DOUBLE_QUOTE_STRING      /".*?"/
-
-rules
-
-# [:state]          pattern                       [actions]
-                    /\s+/
-                    /:has/                        { [:tPSEUDO_CLASS, text[1..-1]] }
-                    /:not_has/                    { [:tPSEUDO_CLASS, text[1..-1]] }
-                    /#{NODE_TYPE}/                { [:tNODE_TYPE, text[1..]] }
-                    /#{IDENTIFIER}/               { [:tGOTO_SCOPE, text] }
-                    />/                           { [:tRELATIONSHIP, text] }
-                    /~/                           { [:tRELATIONSHIP, text] }
-                    /\+/                          { [:tRELATIONSHIP, text] }
-                    /#{OPEN_SELECTOR}/            { [:tOPEN_SELECTOR, text] }
-                    /#{CLOSE_SELECTOR}/           { [:tCLOSE_SELECTOR, text] }
-                    /#{OPEN_ATTRIBUTE}/           { @nested_count += 1; @state = :KEY; [:tOPEN_ATTRIBUTE, text] }
-:KEY                /\s+/
-: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] }
-: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] }
-:VALUE              /#{SYMBOL}/                   { [:tSYMBOL, text[1..-1].to_sym] }
-:VALUE              /#{FLOAT}/                    { [:tFLOAT, text.to_f] }
-:VALUE              /#{INTEGER}/                  { [:tINTEGER, text.to_i] }
-:VALUE              /#{REGEXP}/                   { [:tREGEXP, eval(text)] }
-:VALUE              /#{DOUBLE_QUOTE_STRING}/      { [:tSTRING, text[1...-1]] }
-:VALUE              /#{SINGLE_QUOTE_STRING}/      { [:tSTRING, text[1...-1]] }
-:VALUE              /#{NODE_TYPE}/                { [:tNODE_TYPE, text[1..]] }
-:VALUE              /#{OPEN_ATTRIBUTE}/           { @nested_count += 1; @state = :KEY; [:tOPEN_ATTRIBUTE, text] }
-:VALUE              /#{IDENTIFIER_VALUE}/         { [:tIDENTIFIER_VALUE, text] }
-:DYNAMIC_ATTRIBUTE  /#{CLOSE_DYNAMIC_ATTRIBUTE}/  { @state = :VALUE; [:tCLOSE_DYNAMIC_ATTRIBUTE, text] }
-:DYNAMIC_ATTRIBUTE  /#{IDENTIFIER}/               { [:tDYNAMIC_ATTRIBUTE, text] }
-:ARRAY_VALUE        /\s+/
-: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] }
-:ARRAY_VALUE        /#{SYMBOL}/                   { [:tSYMBOL, text[1..-1].to_sym] }
-:ARRAY_VALUE        /#{FLOAT}/                    { [:tFLOAT, text.to_f] }
-:ARRAY_VALUE        /#{INTEGER}/                  { [:tINTEGER, text.to_i] }
-:ARRAY_VALUE        /#{REGEXP}/                   { [:tREGEXP, eval(text)] }
-:ARRAY_VALUE        /#{DOUBLE_QUOTE_STRING}/      { [:tSTRING, text[1...-1]] }
-:ARRAY_VALUE        /#{SINGLE_QUOTE_STRING}/      { [:tSTRING, text[1...-1]] }
-:ARRAY_VALUE        /#{IDENTIFIER_VALUE}/         { [:tIDENTIFIER_VALUE, text] }
-
-inner
-  def initialize
-    @nested_count = 0
-  end
-
-  def do_parse; end
-end

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

@@ -1,299 +0,0 @@
-# frozen_string_literal: true
-# encoding: UTF-8
-#--
-# This file is automatically generated. Do not modify it.
-# Generated by: oedipus_lex version 2.6.0.
-# Source: lib/synvert/core/node_query/lexer.rex
-#++
-
-
-##
-# The generated lexer Synvert::Core::NodeQuery::Lexer
-
-class Synvert::Core::NodeQuery::Lexer
-  require 'strscan'
-
-  # :stopdoc:
-  OPEN_ATTRIBUTE          = /\[/
-  CLOSE_ATTRIBUTE         = /\]/
-  OPEN_ARRAY              = /\(/
-  CLOSE_ARRAY             = /\)/
-  OPEN_SELECTOR           = /\(/
-  CLOSE_SELECTOR          = /\)/
-  OPEN_DYNAMIC_ATTRIBUTE  = /{{/
-  CLOSE_DYNAMIC_ATTRIBUTE = /}}/
-  NODE_TYPE               = /\.[a-z]+/
-  IDENTIFIER              = /[\.\w]+/
-  IDENTIFIER_VALUE        = /[\.\w!&:\?<>=]+/
-  FALSE                   = /false/
-  FLOAT                   = /\d+\.\d+/
-  INTEGER                 = /\d+/
-  NIL                     = /nil/
-  REGEXP_BODY             = /(?:[^\/]|\\\/)*/
-  REGEXP                  = /\/(#{REGEXP_BODY})(?<!\\)\/([imxo]*)/
-  SYMBOL                  = /:[\w!\?<>=]+/
-  TRUE                    = /true/
-  SINGLE_QUOTE_STRING     = /'.*?'/
-  DOUBLE_QUOTE_STRING     = /".*?"/
-  # :startdoc:
-  # :stopdoc:
-  class LexerError < StandardError ; end
-  class ScanError < LexerError ; end
-  # :startdoc:
-
-  ##
-  # The file name / path
-
-  attr_accessor :filename
-
-  ##
-  # The StringScanner for this lexer.
-
-  attr_accessor :ss
-
-  ##
-  # The current lexical state.
-
-  attr_accessor :state
-
-  alias :match :ss
-
-  ##
-  # The match groups for the current scan.
-
-  def matches
-    m = (1..9).map { |i| ss[i] }
-    m.pop until m[-1] or m.empty?
-    m
-  end
-
-  ##
-  # Yields on the current action.
-
-  def action
-    yield
-  end
-
-
-  ##
-  # The current scanner class. Must be overridden in subclasses.
-
-  def scanner_class
-    StringScanner
-  end unless instance_methods(false).map(&:to_s).include?("scanner_class")
-
-  ##
-  # Parse the given string.
-
-  def parse str
-    self.ss     = scanner_class.new str
-    self.state  ||= nil
-
-    do_parse
-  end
-
-  ##
-  # Read in and parse the file at +path+.
-
-  def parse_file path
-    self.filename = path
-    open path do |f|
-      parse f.read
-    end
-  end
-
-  ##
-  # The current location in the parse.
-
-  def location
-    [
-      (filename || "<input>"),
-    ].compact.join(":")
-  end
-
-  ##
-  # Lex the next token.
-
-  def next_token
-
-    token = nil
-
-    until ss.eos? or token do
-      token =
-        case state
-        when nil then
-          case
-          when ss.skip(/\s+/) then
-            # do nothing
-          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 { [:tRELATIONSHIP, text] }
-          when text = ss.scan(/~/) then
-            action { [:tRELATIONSHIP, text] }
-          when text = ss.scan(/\+/) then
-            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_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 :KEY then
-          case
-          when ss.skip(/\s+/) then
-            # do nothing
-          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
-            text = ss.string[ss.pos .. -1]
-            raise ScanError, "can not match (#{state.inspect}) at #{location}: '#{text}'"
-          end
-        when :VALUE then
-          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
-            action { [:tBOOLEAN, true] }
-          when ss.skip(/#{FALSE}/) then
-            action { [:tBOOLEAN, false] }
-          when text = ss.scan(/#{SYMBOL}/) then
-            action { [:tSYMBOL, text[1..-1].to_sym] }
-          when text = ss.scan(/#{FLOAT}/) then
-            action { [:tFLOAT, text.to_f] }
-          when text = ss.scan(/#{INTEGER}/) then
-            action { [:tINTEGER, text.to_i] }
-          when text = ss.scan(/#{REGEXP}/) then
-            action { [:tREGEXP, eval(text)] }
-          when text = ss.scan(/#{DOUBLE_QUOTE_STRING}/) then
-            action { [:tSTRING, text[1...-1]] }
-          when text = ss.scan(/#{SINGLE_QUOTE_STRING}/) then
-            action { [:tSTRING, text[1...-1]] }
-          when text = ss.scan(/#{NODE_TYPE}/) then
-            action { [:tNODE_TYPE, text[1..]] }
-          when text = ss.scan(/#{OPEN_ATTRIBUTE}/) then
-            action { @nested_count += 1; @state = :KEY; [:tOPEN_ATTRIBUTE, text] }
-          when text = ss.scan(/#{IDENTIFIER_VALUE}/) then
-            action { [:tIDENTIFIER_VALUE, text] }
-          else
-            text = ss.string[ss.pos .. -1]
-            raise ScanError, "can not match (#{state.inspect}) at #{location}: '#{text}'"
-          end
-        when :DYNAMIC_ATTRIBUTE then
-          case
-          when text = ss.scan(/#{CLOSE_DYNAMIC_ATTRIBUTE}/) then
-            action { @state = :VALUE; [:tCLOSE_DYNAMIC_ATTRIBUTE, text] }
-          when text = ss.scan(/#{IDENTIFIER}/) then
-            action { [:tDYNAMIC_ATTRIBUTE, text] }
-          else
-            text = ss.string[ss.pos .. -1]
-            raise ScanError, "can not match (#{state.inspect}) at #{location}: '#{text}'"
-          end
-        when :ARRAY_VALUE then
-          case
-          when ss.skip(/\s+/) then
-            # do nothing
-          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
-            action { [:tBOOLEAN, true] }
-          when ss.skip(/#{FALSE}/) then
-            action { [:tBOOLEAN, false] }
-          when text = ss.scan(/#{SYMBOL}/) then
-            action { [:tSYMBOL, text[1..-1].to_sym] }
-          when text = ss.scan(/#{FLOAT}/) then
-            action { [:tFLOAT, text.to_f] }
-          when text = ss.scan(/#{INTEGER}/) then
-            action { [:tINTEGER, text.to_i] }
-          when text = ss.scan(/#{REGEXP}/) then
-            action { [:tREGEXP, eval(text)] }
-          when text = ss.scan(/#{DOUBLE_QUOTE_STRING}/) then
-            action { [:tSTRING, text[1...-1]] }
-          when text = ss.scan(/#{SINGLE_QUOTE_STRING}/) then
-            action { [:tSTRING, text[1...-1]] }
-          when text = ss.scan(/#{IDENTIFIER_VALUE}/) then
-            action { [:tIDENTIFIER_VALUE, text] }
-          else
-            text = ss.string[ss.pos .. -1]
-            raise ScanError, "can not match (#{state.inspect}) at #{location}: '#{text}'"
-          end
-        else
-          raise ScanError, "undefined state at #{location}: '#{state}'"
-        end # token = case state
-
-      next unless token # allow functions to trigger redo w/ nil
-    end # while
-
-    raise LexerError, "bad lexical result at #{location}: #{token.inspect}" unless
-      token.nil? || (Array === token && token.size >= 2)
-
-    # auto-switch state
-    self.state = token.last if token && token.first == :state
-
-    token
-  end # def next_token
-    def initialize
-      @nested_count = 0
-    end
-    def do_parse; end
-end # class