synvert-core 0.64.0 → 1.0.1

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

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Synvert::Core::NodeQuery::Compiler
+  # Expression represents a node query expression.
+  class Expression
+    # 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)
+      @selector = selector
+      @rest = rest
+      @relationship = relationship
+    end
+
+    # Check if the node matches the expression.
+    # @param node [Parser::AST::Node] the node
+    # @return [Boolean]
+    def match?(node)
+      !query_nodes(node).empty?
+    end
+
+    # Query nodes by the 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
+
+      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
+    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(' ')
+    end
+
+    private
+
+    def find_nodes_without_relationship(node, descendant_match: true)
+      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/float.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Synvert::Core::NodeQuery::Compiler
+  # Float represents a ruby float value.
+  class Float
+    include Comparable
+
+    # Initialize a Float.
+    # @param value [Float] the float value
+    def initialize(value:)
+      @value = value
+    end
+
+    # Get valid operators.
+    def valid_operators
+      NUMBER_VALID_OPERATORS
+    end
+
+    def to_s
+      @value.to_s
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Synvert::Core::NodeQuery::Compiler
+  # Identifier represents a ruby identifier value.
+  # e.g. code is `class Synvert; end`, `Synvert` is an identifier.
+  class Identifier
+    include Comparable
+
+    # Initialize an Identifier.
+    # @param value [String] the identifier value
+    def initialize(value:)
+      @value = value
+    end
+
+    # Get the actual value.
+    #
+    # @param node the node
+    # @return [String|Array]
+    # If the node is a {Parser::AST::Node}, return the node source code,
+    # if the node is an Array, return the array of each element's actual value,
+    # otherwise, return the String value.
+    def actual_value(node)
+      if node.is_a?(::Parser::AST::Node)
+        node.to_source
+      elsif node.is_a?(::Array)
+        node.map { |n| actual_value(n) }
+      else
+        node.to_s
+      end
+    end
+
+    # Get valid operators.
+    def valid_operators
+      SIMPLE_VALID_OPERATORS
+    end
+
+    def to_s
+      @value
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Synvert::Core::NodeQuery::Compiler
+  # Integer represents a ruby integer value.
+  class Integer
+    include Comparable
+
+    # Initialize a Integer.
+    # @param value [Integer] the integer value
+    def initialize(value:)
+      @value = value
+    end
+
+    # Get valid operators.
+    def valid_operators
+      NUMBER_VALID_OPERATORS
+    end
+
+    def to_s
+      @value.to_s
+    end
+  end
+end

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

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Synvert::Core::NodeQuery::Compiler
+  # Operator is invalid error.
+  class InvalidOperatorError < StandardError
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Synvert::Core::NodeQuery::Compiler
+  # Nil represents a ruby nil value.
+  class Nil
+    include Comparable
+
+    # Initialize a Nil.
+    # @param value [nil] the nil value
+    def initialize(value:)
+      @value = value
+    end
+
+    # Get valid operators.
+    def valid_operators
+      SIMPLE_VALID_OPERATORS
+    end
+
+    def to_s
+      'nil'
+    end
+  end
+end

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

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Synvert::Core::NodeQuery::Compiler
+  # The parser error.
+  class ParseError < StandardError
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Synvert::Core::NodeQuery::Compiler
+  # Regexp represents a ruby regexp value.
+  class Regexp
+    include Comparable
+
+    # Initialize a Regexp.
+    # @param value [Regexp] the regexp value
+    def initialize(value:)
+      @value = value
+    end
+
+    # Check if the regexp value matches the node value.
+    # @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 = :=~)
+      match =
+        if node.is_a?(::Parser::AST::Node)
+          @value.match(node.to_source)
+        else
+          @value.match(node.to_s)
+        end
+      operator == :=~ ? match : !match
+    end
+
+    # Get valid operators.
+    def valid_operators
+      REGEXP_VALID_OPERATORS
+    end
+
+    def to_s
+      @value.to_s
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+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 attribute_list [Synvert::Core::NodeQuery::Compiler::AttributeList] the attribute list
+    # @param index [Integer] the index
+    # @param has_expression [Synvert::Core::NodeQuery::Compiler::Expression] the has expression
+    def initialize(node_type: nil, attribute_list: nil, index: nil, has_expression: nil)
+      @node_type = node_type
+      @attribute_list = attribute_list
+      @index = index
+      @has_expression = has_expression
+    end
+
+    # Filter nodes by index.
+    def filter(nodes)
+      return nodes if @index.nil?
+
+      nodes[@index] ? [nodes[@index]] : []
+    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)) &&
+        (!@has_expression || @has_expression.match?(node))
+    end
+
+    def to_s
+      str = ".#{@node_type}#{@attribute_list}"
+      return str if !@index && !@has_expression
+
+      return "#{str}:has(#{@has_expression})" if @has_expression
+
+      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})"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Synvert::Core::NodeQuery::Compiler
+  # String represents a ruby string value.
+  class String
+    include Comparable
+
+    # Initialize a String.
+    # @param value [String] the string value
+    def initialize(value:)
+      @value = value
+    end
+
+    # Get valid operators.
+    def valid_operators
+      SIMPLE_VALID_OPERATORS
+    end
+
+    # Get the actual value of a node.
+    # @param node [Parser::AST::Node] the node
+    # @return [String] if node is a Parser::AST::Node, return the node source code, otherwise, return the string value.
+    def actual_value(node)
+      if node.is_a?(::Parser::AST::Node)
+        node.to_source
+      else
+        node.to_s
+      end
+    end
+
+    def to_s
+      "\"#{@value}\""
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Synvert::Core::NodeQuery::Compiler
+  # Symbol represents a ruby symbol value.
+  class Symbol
+    include Comparable
+
+    # Initliaze a Symobol.
+    # @param value [Symbol] the symbol value
+    def initialize(value:)
+      @value = value
+    end
+
+    # Get valid operators.
+    def valid_operators
+      SIMPLE_VALID_OPERATORS
+    end
+
+    def to_s
+      ":#{@value}"
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# 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 :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

@@ -0,0 +1,96 @@
+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+/
+                    /: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/                        { [:tHAS, text[1..-1]] }
+                    /#{NODE_TYPE}/                { [:tNODE_TYPE, text[1..]] }
+                    />/                           { [:tCHILD, text] }
+                    /~/                           { [:tSUBSEQUENT_SIBLING, text] }
+                    /\+/                          { [:tNEXT_SIBLING, 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; [: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                /#{IDENTIFIER}/               { [:tKEY, text] }
+:VALUE              /\s+/
+: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}/                      { [: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              />/                           { [:tCHILD, text] }
+:VALUE              /~/                           { [:tSUBSEQUENT_SIBLING, text] }
+:VALUE              /\+/                          { [:tNEXT_SIBLING, text] }
+: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        /,/                           { [:tCOMMA, text] }
+:ARRAY_VALUE        /#{CLOSE_ARRAY}/              { @state = :VALUE; [:tCLOSE_ARRAY, 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