node_query 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 133039b40806dc003715b5d04f34bbb78d6f3cfe3969e1d10dc920063e8ebe11
+  data.tar.gz: 43d5557d76103476d90c98f2575f0869ed8809abe639ec62d38695cd1131eca7
+SHA512:
+  metadata.gz: 0cb0b449357c4238ea7d123e16985a82e8fb4a1d2271359616720d0dd2833eac3a07963ff612c7a71a8afdb88ec5014e5f9f35fb22a51acd188e46295d86cae1
+  data.tar.gz: 48ff7474de2c811103c71df2789d81818691e11e8c10303544d15dde4a9362933984ea60b353182fc4b9d16720532756e21c593a15b6a685466275bc880f7de3

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+# CHANGELOG
+
+## 1.0.0 (2022-06-26)
+
+* Abstract from synvert-core

data/Gemfile

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in node_query.gemspec
+gemspec
+
+gem "rake", "~> 13.0"
+
+gem "rspec", "~> 3.0"
+
+gem "guard"
+gem "guard-rspec"
+gem "guard-rake"
+gem "oedipus_lex"
+gem "racc"
+gem "parser"
+gem "parser_node_ext"

data/Gemfile.lock

@@ -0,0 +1,98 @@
+PATH
+  remote: .
+  specs:
+    node_query (1.0.0)
+      activesupport
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (7.0.3)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 1.6, < 2)
+      minitest (>= 5.1)
+      tzinfo (~> 2.0)
+    ast (2.4.2)
+    coderay (1.1.3)
+    concurrent-ruby (1.1.10)
+    diff-lcs (1.5.0)
+    ffi (1.15.5)
+    formatador (1.1.0)
+    guard (2.18.0)
+      formatador (>= 0.2.4)
+      listen (>= 2.7, < 4.0)
+      lumberjack (>= 1.0.12, < 2.0)
+      nenv (~> 0.1)
+      notiffany (~> 0.0)
+      pry (>= 0.13.0)
+      shellany (~> 0.0)
+      thor (>= 0.18.1)
+    guard-compat (1.2.1)
+    guard-rake (1.0.0)
+      guard
+      rake
+    guard-rspec (4.7.3)
+      guard (~> 2.1)
+      guard-compat (~> 1.1)
+      rspec (>= 2.99.0, < 4.0)
+    i18n (1.10.0)
+      concurrent-ruby (~> 1.0)
+    listen (3.7.1)
+      rb-fsevent (~> 0.10, >= 0.10.3)
+      rb-inotify (~> 0.9, >= 0.9.10)
+    lumberjack (1.2.8)
+    method_source (1.0.0)
+    minitest (5.16.1)
+    nenv (0.3.0)
+    notiffany (0.1.3)
+      nenv (~> 0.1)
+      shellany (~> 0.0)
+    oedipus_lex (2.6.0)
+    parser (3.1.2.0)
+      ast (~> 2.4.1)
+    parser_node_ext (0.1.0)
+      parser
+    pry (0.14.1)
+      coderay (~> 1.1)
+      method_source (~> 1.0)
+    racc (1.6.0)
+    rake (13.0.6)
+    rb-fsevent (0.11.1)
+    rb-inotify (0.10.1)
+      ffi (~> 1.0)
+    rspec (3.11.0)
+      rspec-core (~> 3.11.0)
+      rspec-expectations (~> 3.11.0)
+      rspec-mocks (~> 3.11.0)
+    rspec-core (3.11.0)
+      rspec-support (~> 3.11.0)
+    rspec-expectations (3.11.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.11.0)
+    rspec-mocks (3.11.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.11.0)
+    rspec-support (3.11.0)
+    shellany (0.0.1)
+    thor (1.2.1)
+    tzinfo (2.0.4)
+      concurrent-ruby (~> 1.0)
+
+PLATFORMS
+  x86_64-darwin-21
+  x86_64-linux
+
+DEPENDENCIES
+  guard
+  guard-rake
+  guard-rspec
+  node_query!
+  oedipus_lex
+  parser
+  parser_node_ext
+  racc
+  rake (~> 13.0)
+  rspec (~> 3.0)
+
+BUNDLED WITH
+   2.3.7

data/Guardfile

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+guard :rspec, cmd: 'bundle exec rspec' do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$}) { |m| "spec/#{m[1]}_spec.rb" }
+  watch('lib/node_query_lexer.rex.rb') { 'spec/node_query_lexer_spec.rb'  }
+  watch('lib/node_query_compiler.rb') { 'spec/node_query_parser_spec.rb'  }
+  watch(%r{^lib/node_query/compiler/.*\.rb$}) { 'spec/node_query_parser_spec.rb' }
+  watch('lib/node_query/parser.racc.rb') { 'spec/node_query_parser_spec.rb' }
+  watch('spec/spec_helper.rb') { "spec" }
+end
+
+guard :rake, task: 'generate' do
+  watch('lib/node_query_lexer.rex')
+  watch('lib/node_query_parser.y')
+end

data/README.md

@@ -0,0 +1,37 @@
+# NodeQuery
+
+NodeQuery defines an AST node query language, which is a css like syntax for matching nodes.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'node_query'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install node_query
+
+## Usage
+
+It provides only one api:
+
+```ruby
+NodeQuery.new(nodeQueryString).parse(node)
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/xinminlabs/node-query-ruby.

data/Rakefile

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+require 'oedipus_lex'
+Rake.application.rake_require "oedipus_lex"
+
+file "lib/node_query_lexer.rex.rb" => "lib/node_query_lexer.rex"
+file "lib/node_query_parser.racc.rb" => "lib/node_query_parser.y"
+
+task :lexer  => "lib/node_query_lexer.rex.rb"
+task :parser => "lib/node_query_parser.racc.rb"
+task :generate  => [:lexer, :parser]
+
+rule '.racc.rb' => '.y' do |t|
+  cmd = "bundle exec racc -l -v -o #{t.name} #{t.source}"
+  sh cmd
+end
+
+task :default => :spec
+task :spec => :generate

data/lib/node_query/adapter.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+# Abstract Adapter class
+class NodeQuery::Adapter
+  # Get the type of node
+  # @param node [Node] ast node
+  # @return [Symbol] node type
+  def get_node_type(node)
+    raise NotImplementedError, 'get_node_type is not implemented'
+  end
+
+  # Get the source code of node
+  # @param node [Node] ast node
+  # @return [String] node source code
+  def get_source(node)
+    raise NotImplementedError, 'get_source is not implemented'
+  end
+
+  # Get the children of node
+  # @param node [Node] ast node
+  # @return [Array<Node>] node children
+  def get_children(node)
+    raise NotImplementedError, 'get_children is not implemented'
+  end
+
+  # Get the siblings of node
+  # @param node [Node] ast node
+  # @return [Array<Node>] node siblings
+  def get_siblings(node)
+    raise NotImplementedError, 'get_siblings is not implemented'
+  end
+end

data/lib/node_query/compiler/array_value.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module NodeQuery::Compiler
+  # ArrayValue represents a ruby array value.
+  class ArrayValue
+    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.
+    # @return [Array] valid operators
+    def valid_operators
+      ARRAY_VALID_OPERATORS
+    end
+
+    def to_s
+      [@value, @rest].compact.join(' ')
+    end
+  end
+end

data/lib/node_query/compiler/attribute.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module 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 {NodeQuery::Compiler::Comparable}
+    # @param operator [String] the operator
+    def initialize(key:, value:, operator: '==')
+      @key = key
+      @value = value
+      @operator = operator
+    end
+
+    # Check if the node matches the attribute.
+    # @param node [Node] the node
+    # @return [Boolean]
+    def match?(node)
+      @value.base_node = node if @value.is_a?(EvaluatedValue)
+      node && @value.match?(NodeQuery::Helper.get_target_node(node, @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/node_query/compiler/attribute_list.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module NodeQuery::Compiler
+  # AttributeList contains one or more {NodeQuery::Compiler::Attribute}.
+  class AttributeList
+    # Initialize an AttributeList.
+    # @param attribute [NodeQuery::Compiler::Attribute] the attribute
+    # @param rest [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.
+    # @param node [Node] the node
+    # @return [Boolean]
+    def match?(node)
+      @attribute.match?(node) && (!@rest || @rest.match?(node))
+    end
+
+    def to_s
+      "[#{@attribute}]#{@rest}"
+    end
+  end
+end

data/lib/node_query/compiler/basic_selector.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module 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 [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 [Node] the node
+    # @return [Boolean]
+    def match?(node, _operator = '==')
+      return false unless node
+
+      @node_type.to_sym == NodeQuery.get_adapter.get_node_type(node) && (!@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/node_query/compiler/boolean.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module 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.
+    # @return [Array] valid operators
+    def valid_operators
+      SIMPLE_VALID_OPERATORS
+    end
+
+    def to_s
+      @value.to_s
+    end
+  end
+end

data/lib/node_query/compiler/comparable.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module 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 [Node] node to calculate actual value
+    # @param operator [String] 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 [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.
+    # @param node [Node] ast node
+    # @return the node value, could be integer, float, string, boolean, nil, range, and etc.
+    def actual_value(node)
+      if node.is_a?(::Parser::AST::Node)
+        case NodeQuery.get_adapter.get_node_type(node)
+        when :int, :float, :str, :sym
+          NodeQuery.get_adapter.get_children(node).last
+        when :true
+          true
+        when :false
+          false
+        when :nil
+          nil
+        when :array
+          NodeQuery.get_adapter.get_children(node).map { |child_node| actual_value(child_node) }
+        when :irange
+          actual_value(NodeQuery.get_adapter.get_children(node).first)..actual_value(NodeQuery.get_adapter.get_children(node).last)
+        when :erange
+          actual_value(NodeQuery.get_adapter.get_children(node).first)...actual_value(NodeQuery.get_adapter.get_children(node).last)
+        when :begin
+          actual_value(NodeQuery.get_adapter.get_children(node).first)
+        else
+          node
+        end
+      else
+        node
+      end
+    end
+
+    # Get the expected value
+    # @return expected value, could be integer, float, string, boolean, nil, range, and etc.
+    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/node_query/compiler/evaluated_value.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module NodeQuery::Compiler
+  # EvaluatedValue 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 EvaluatedValue
+    include Comparable
+
+    attr_accessor :base_node
+
+    # Initialize an EvaluatedValue.
+    # @param value [String] the dynamic attribute value
+    def initialize(value:)
+      @value = value
+    end
+
+    # Get the actual value of a node.
+    # @param node [Node] the node
+    # @return [String] if node is a {Node}, return the node source code, otherwise return the node itself.
+    def actual_value(node)
+      if node.is_a?(::Parser::AST::Node)
+        NodeQuery.get_adapter.get_source(node)
+      else
+        node
+      end
+    end
+
+    # Get the expected value.
+    # @return [String] Query the node by @value from base_node, if the node is a {Node}, return the node source code, otherwise return the node itself.
+    def expected_value
+      node = NodeQuery::Helper.get_target_node(base_node, @value)
+      if node.is_a?(::Parser::AST::Node)
+        NodeQuery.get_adapter.get_source(node)
+      else
+        node
+      end
+    end
+
+    # Get valid operators.
+    # @return [Array] valid operators
+    def valid_operators
+      SIMPLE_VALID_OPERATORS
+    end
+
+    def to_s
+      "{{#{@value}}}"
+    end
+  end
+end

data/lib/node_query/compiler/expression.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module NodeQuery::Compiler
+  # Expression represents a node query expression.
+  class Expression
+    # Initialize a Expression.
+    # @param selector [NodeQuery::Compiler::Selector] the selector
+    # @param rest [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 [Node] the node
+    # @return [Boolean]
+    def match?(node)
+      !query_nodes(node).empty?
+    end
+
+    # Query nodes by the selector and the rest expression.
+    # @param node [Node] node to match
+    # @return [Array<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/node_query/compiler/expression_list.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module NodeQuery::Compiler
+  # ExpressionList contains one or more {NodeQuery::Compiler::Expression}.
+  class ExpressionList
+    # Initialize an ExpressionList.
+    # @param expression [NodeQuery::Compiler::Expression] the expression
+    # @param rest [NodeQuery::Compiler::ExpressionList] the rest expression list
+    def initialize(expression:, rest: nil)
+      @expression = expression
+      @rest = rest
+    end
+
+    # Query nodes by the current and the rest expression.
+    # @param node [Node] node to match
+    # @return [Array<Node>] matching nodes.
+    def query_nodes(node)
+      matching_nodes = @expression.query_nodes(node)
+      return matching_nodes if @rest.nil?
+
+      matching_nodes + @rest.query_nodes(node)
+    end
+
+    def to_s
+      [@expression, @rest].compact.join(', ')
+    end
+  end
+end

data/lib/node_query/compiler/float.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module 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.
+    # @return [Array] valid operators
+    def valid_operators
+      NUMBER_VALID_OPERATORS
+    end
+
+    def to_s
+      @value.to_s
+    end
+  end
+end