synvert-core 1.3.0 → 1.5.0

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

@@ -1,86 +0,0 @@
-# frozen_string_literal: true
-
-module Synvert::Core::NodeQuery::Compiler
-  # Compare acutal value with expected value.
-  module Comparable
-    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>
-    # @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).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 '>='
-        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

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

@@ -1,58 +0,0 @@
-# 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
-    def initialize(selector: nil, rest: nil)
-      @selector = selector
-      @rest = rest
-    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 selector and the rest expression.
-    #
-    # @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_by_selector(node, descendant_match)
-      return matching_nodes if @rest.nil?
-
-      matching_nodes.flat_map { |matching_node| find_nodes_by_rest(matching_node, descendant_match) }
-    end
-
-    def to_s
-      result = []
-      result << @selector.to_s if @selector
-      result << @rest.to_s if @rest
-      result.join(' ')
-    end
-
-    private
-
-    # 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_by_selector(node, descendant_match = true)
-      return Array(node) if !@selector
-
-      @selector.query_nodes(node, descendant_match)
-    end
-  end
-end

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

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

@@ -1,41 +0,0 @@
-# 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
-      STRING_VALID_OPERATORS
-    end
-
-    def to_s
-      @value
-    end
-  end
-end

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

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

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

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

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

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

@@ -1,138 +0,0 @@
-# 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 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 simple_selector [Synvert::Core::NodeQuery::Compiler::SimpleSelector] 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_selector [Synvert::Core::NodeQuery::Compiler::Expression] the pseudo selector
-    def initialize(goto_scope: nil, relationship: nil, rest: nil, simple_selector: nil, index: nil, pseudo_class: nil, pseudo_selector: nil)
-      @goto_scope = goto_scope
-      @relationship = relationship
-      @rest = rest
-      @simple_selector = simple_selector
-      @index = index
-      @pseudo_class = pseudo_class
-      @pseudo_selector = pseudo_selector
-    end
-
-    # Check if node matches the selector.
-    # @param node [Parser::AST::Node] the node
-    def match?(node)
-      node.is_a?(::Parser::AST::Node) &&
-        (!@simple_selector || @simple_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
-    # @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_relationship(node) if @relationship
-
-      if node.is_a?(::Array)
-        return node.flat_map { |child_node| query_nodes(child_node, descendant_match) }
-      end
-
-      return find_nodes_by_goto_scope(node) if @goto_scope
-
-      nodes = []
-      nodes << node if match?(node)
-      if descendant_match && @simple_selector
-        node.recursive_children do |child_node|
-          nodes << child_node if match?(child_node)
-        end
-      end
-      filter(nodes)
-    end
-
-    def to_s
-      result = []
-      result << "<#{@goto_scope}> " if @goto_scope
-      result << "#{@relationship} " if @relationship
-      result << @rest.to_s if @rest
-      result << @simple_selector.to_s if @simple_selector
-      result << ":#{@pseudo_class}(#{@pseudo_selector})" 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})"
-          end
-      end
-      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)
-      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
-      return filter(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
-    end
-
-    # Filter nodes by index.
-    def filter(nodes)
-      return nodes if @index.nil?
-
-      nodes[@index] ? [nodes[@index]] : []
-    end
-  end
-end

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

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

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

@@ -1,23 +0,0 @@
-# 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
-      STRING_VALID_OPERATORS
-    end
-
-    def to_s
-      "\"#{@value}\""
-    end
-  end
-end

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

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

@@ -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 :SimpleSelector, 'synvert/core/node_query/compiler/simple_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