synvert-core 0.63.1 → 1.0.1

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Synvert::Core::NodeQuery::Compiler
+  # Attribute is a pair of key, value and operator,
+  class Attribute
+    # Initialize a Attribute.
+    # @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: :==)
+      @key = key
+      @value = value
+      @operator = operator
+    end
+
+    # Check if the node matches the attribute.
+    # @param node [Parser::AST::Node] the node
+    # @return [Boolean]
+    def match?(node)
+      @value.base_node = node if @value.is_a?(DynamicAttribute)
+      node && @value.match?(node.child_node_by_name(@key), @operator)
+    end
+
+    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
+        "#{@key} in (#{@value})"
+      when :not_in
+        "#{@key} not in (#{@value})"
+      when :includes
+        "#{@key} includes #{@value}"
+      else
+        "#{@key}=#{@value}"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Synvert::Core::NodeQuery::Compiler
+  # AttributeList contains one or more {Synvert::Core::NodeQuery::Compiler::Attribute}.
+  class AttributeList
+    # Initialize a AttributeList.
+    # @param attribute [Synvert::Core::NodeQuery::Compiler::Attribute] the attribute
+    # @param rest [Synvert::Core::NodeQuery::Compiler::AttributeList] the rest attribute list
+    def initialize(attribute:, rest: nil)
+      @attribute = attribute
+      @rest = rest
+    end
+
+    # Check if the node matches the attribute list.
+    # @return [Boolean]
+    def match?(node)
+      @attribute.match?(node) && (!@rest || @rest.match?(node))
+    end
+
+    def to_s
+      "[#{@attribute}]#{@rest}"
+    end
+  end
+end

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

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

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

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+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 = [:=~, :!~]
+
+    # 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>
+    # @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 :!=
+        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, :!=) }
+        else
+          actual_value(node) != expected_value
+        end
+      when :=~
+        actual_value(node) =~ expected_value
+      when :!~
+        actual_value(node) !~ expected_value
+      when :>
+        actual_value(node) > expected_value
+      when :>=
+        actual_value(node) >= expected_value
+      when :<
+        actual_value(node) < expected_value
+      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
+        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, :==) }
+        else
+          actual_value(node) == expected_value
+        end
+      end
+    end
+
+    # Get the actual value from ast node.
+    # @return if node is a {Parser::AST::Node}, return the node value, otherwise, return the node itself.
+    def actual_value(node)
+      if node.is_a?(::Parser::AST::Node)
+        node.to_value
+      else
+        node
+      end
+    end
+
+    # Get the expected value
+    def expected_value
+      @value
+    end
+
+    # Check if the operator is valid.
+    # @return [Boolean] true if the operator is valid
+    def valid_operator?(operator)
+      valid_operators.include?(operator)
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Synvert::Core::NodeQuery::Compiler
+  # DynamicAttribute represents a ruby dynamic attribute.
+  # e.g. code is <code>{ a: a }</code>, query is <code>'.hash > .pair[key={{value}}]'</code>,
+  # <code>{{value}}</code> is the dynamic attribute.
+  class DynamicAttribute
+    include Comparable
+
+    attr_accessor :base_node
+
+    # Initialize a DynamicAttribute.
+    # @param value [String] the dynamic attribute value
+    def initialize(value:)
+      @value = value
+    end
+
+    # Get the actual value of a node.
+    #
+    # @param node the node
+    # @return [String] if node is a {Parser::AST::Node}, return the node source code, otherwise return the node itself.
+    def actual_value(node)
+      if node.is_a?(::Parser::AST::Node)
+        node.to_source
+      else
+        node
+      end
+    end
+
+    # Get the expected value.
+    #
+    # @return [String] Query the node by @valud from base_node, if the node is a {Parser::AST::Node}, return the node source code, otherwise return the node itself.
+    def expected_value
+      node = base_node.child_node_by_name(@value)
+      if node.is_a?(::Parser::AST::Node)
+        node.to_source
+      else
+        node
+      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/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