synvert-core 1.4.0 → 1.6.0

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

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-module Synvert::Core::NodeQuery::Compiler
-  # Array represents a ruby array value.
-  class Array
-    include Comparable
-
-    # Initialize an Array.
-    # @param value the first value of the array
-    # @param rest the rest value of the array
-    def initialize(value: nil, rest: nil)
-      @value = value
-      @rest = rest
-    end
-
-    # Get the expected value.
-    # @return [Array]
-    def expected_value
-      expected = []
-      expected.push(@value) if @value
-      expected += @rest.expected_value if @rest
-      expected
-    end
-
-    # Get valid operators.
-    def valid_operators
-      ARRAY_VALID_OPERATORS
-    end
-
-    def to_s
-      [@value, @rest].compact.join(' ')
-    end
-  end
-end

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

@@ -1,39 +0,0 @@
-# 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}#{@operator}#{@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

@@ -1,24 +0,0 @@
-# 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/basic_selector.rb

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

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

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

@@ -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,41 +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
-    # @return [Array<Parser::AST::Node>] matching nodes.
-    def query_nodes(node)
-      matching_nodes = @selector.query_nodes(node)
-      return matching_nodes if @rest.nil?
-
-      matching_nodes.flat_map do |matching_node|
-        @rest.query_nodes(matching_node)
-      end
-    end
-
-    def to_s
-      result = []
-      result << @selector.to_s if @selector
-      result << @rest.to_s if @rest
-      result.join(' ')
-    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,113 +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 basic_selector [Synvert::Core::NodeQuery::Compiler::BasicSelector] the simple selector
-    # @param attribute_list [Synvert::Core::NodeQuery::Compiler::AttributeList] the attribute list
-    # @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, basic_selector: nil, pseudo_class: nil, pseudo_selector: nil)
-      @goto_scope = goto_scope
-      @relationship = relationship
-      @rest = rest
-      @basic_selector = basic_selector
-      @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) && (!@basic_selector || @basic_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
-    # @return [Array<Parser::AST::Node>] matching nodes.
-    def query_nodes(node)
-      return find_nodes_by_relationship(node) if @relationship
-
-      if node.is_a?(::Array)
-        return node.flat_map { |child_node| query_nodes(child_node) }
-      end
-
-      return find_nodes_by_goto_scope(node) if @goto_scope
-
-      nodes = []
-      nodes << node if match?(node)
-      if @basic_selector
-        node.recursive_children do |child_node|
-          nodes << child_node if match?(child_node)
-        end
-      end
-      nodes
-    end
-
-    def to_s
-      result = []
-      result << "#{@goto_scope} " if @goto_scope
-      result << "#{@relationship} " if @relationship
-      result << @rest.to_s if @rest
-      result << @basic_selector.to_s if @basic_selector
-      result << ":#{@pseudo_class}(#{@pseudo_selector})" if @pseudo_class
-      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)
-    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
-      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
-  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