node_query 1.0.0 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 133039b40806dc003715b5d04f34bbb78d6f3cfe3969e1d10dc920063e8ebe11
-  data.tar.gz: 43d5557d76103476d90c98f2575f0869ed8809abe639ec62d38695cd1131eca7
+  metadata.gz: 8c7363cd71167f293f046d95014611ceb1f695c6639036a3cc0e202ab0ae5b2b
+  data.tar.gz: 161c5784daae011699a1300b0cedc2f18bdc7235f71b7e89e1b1dce41caef71a
 SHA512:
-  metadata.gz: 0cb0b449357c4238ea7d123e16985a82e8fb4a1d2271359616720d0dd2833eac3a07963ff612c7a71a8afdb88ec5014e5f9f35fb22a51acd188e46295d86cae1
-  data.tar.gz: 48ff7474de2c811103c71df2789d81818691e11e8c10303544d15dde4a9362933984ea60b353182fc4b9d16720532756e21c593a15b6a685466275bc880f7de3
+  metadata.gz: 356e94651bf61cb5c244399bbfe0aa353aafe3a3506fc7e6b1efba9cc4c853a0b963850c9d64e9b9de26dd3986f10967b2752a3dc7ec627dfd7466ddcf9a70f8
+  data.tar.gz: 0fdacf2a86292f60968a02054ce43e02a131d3a1da7c528d1e6df2e8279afd5de19afe714a80bd1b9ab17143c433b4e219c7be2cf8b55e3f28e45ff82a25d274

data/CHANGELOG.md

@@ -1,5 +1,26 @@
 # CHANGELOG
 
+## 1.3.0 (2022-09-13)
+
+* Rename `NodeQuery#parse` to `NodeQuery#query_nodes`
+* `NodeQuery#query_ndoes` accepts `including_self` argument
+* `NodeQuery#query_ndoes` supports both nql and rules
+* Add `NodeQuery#match_node?`
+* Add `NdoeRules`
+* Drop `EvaluatedValue`, use `String` instead
+* Write better test cases
+
+## 1.2.0 (2022-07-01)
+
+* Rename `NodeQuery.get_adapter` to `NodeQuery.adapter`
+* Use generic type in rbs
+* Fix `Compiler::Array` to `Compiler::ArrayValue`
+
+## 1.1.0 (2022-06-27)
+
+* Support `*` in attribute key
+* Add new Adapter method `is_node?`
+
 ## 1.0.0 (2022-06-26)
 
 * Abstract from synvert-core

data/Gemfile.lock

@@ -1,17 +1,18 @@
 PATH
   remote: .
   specs:
-    node_query (1.0.0)
-      activesupport
+    node_query (1.3.0)
+      activesupport (< 7.0.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    activesupport (7.0.3)
+    activesupport (6.1.7)
       concurrent-ruby (~> 1.0, >= 1.0.2)
       i18n (>= 1.6, < 2)
       minitest (>= 5.1)
       tzinfo (~> 2.0)
+      zeitwerk (~> 2.3)
     ast (2.4.2)
     coderay (1.1.3)
     concurrent-ruby (1.1.10)
@@ -35,14 +36,14 @@ GEM
       guard (~> 2.1)
       guard-compat (~> 1.1)
       rspec (>= 2.99.0, < 4.0)
-    i18n (1.10.0)
+    i18n (1.12.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)
+    minitest (5.16.3)
     nenv (0.3.0)
     notiffany (0.1.3)
       nenv (~> 0.1)
@@ -50,7 +51,7 @@ GEM
     oedipus_lex (2.6.0)
     parser (3.1.2.0)
       ast (~> 2.4.1)
-    parser_node_ext (0.1.0)
+    parser_node_ext (0.4.0)
       parser
     pry (0.14.1)
       coderay (~> 1.1)
@@ -75,8 +76,9 @@ GEM
     rspec-support (3.11.0)
     shellany (0.0.1)
     thor (1.2.1)
-    tzinfo (2.0.4)
+    tzinfo (2.0.5)
       concurrent-ruby (~> 1.0)
+    zeitwerk (2.6.0)
 
 PLATFORMS
   x86_64-darwin-21

data/README.md

@@ -1,6 +1,44 @@
 # NodeQuery
 
-NodeQuery defines an AST node query language, which is a css like syntax for matching nodes.
+NodeQuery defines an AST node query language, which is a css like syntax for matching nodes,
+it supports other ast parser if it implements `NodeQuery::Adapter`.
+
+## Table of Contents
+
+- [NodeQuery](#nodequery)
+  - [Table of Contents](#table-of-contents)
+  - [Installation](#installation)
+  - [Usage](#usage)
+  - [Node Query Language](#node-query-language)
+    - [nql matches node type](#nql-matches-node-type)
+    - [nql matches attribute](#nql-matches-attribute)
+    - [nql matches nested attribute](#nql-matches-nested-attribute)
+    - [nql matches evaluated value](#nql-matches-evaluated-value)
+    - [nql matches nested selector](#nql-matches-nested-selector)
+    - [nql matches method result](#nql-matches-method-result)
+    - [nql matches operators](#nql-matches-operators)
+    - [nql matches array node attribute](#nql-matches-array-node-attribute)
+    - [nql matches * in attribute key](#nql-matches--in-attribute-key)
+    - [nql matches multiple selectors](#nql-matches-multiple-selectors)
+      - [Descendant combinator](#descendant-combinator)
+      - [Child combinator](#child-combinator)
+      - [Adjacent sibling combinator](#adjacent-sibling-combinator)
+      - [General sibling combinator](#general-sibling-combinator)
+    - [nql matches goto scope](#nql-matches-goto-scope)
+    - [nql matches pseudo selector](#nql-matches-pseudo-selector)
+    - [nql matches multiple expressions](#nql-matches-multiple-expressions)
+  - [Node Rules](#node-rules)
+    - [rules matches node type](#rules-matches-node-type)
+    - [rules matches attribute](#rules-matches-attribute)
+    - [rules matches nested attribute](#rules-matches-nested-attribute)
+    - [rules matches evaluated value](#rules-matches-evaluated-value)
+    - [rules matches nested selector](#rules-matches-nested-selector)
+    - [rules matches method result](#rules-matches-method-result)
+    - [rules matches operators](#rules-matches-operators)
+    - [rules matches array nodes attribute](#rules-matches-array-nodes-attribute)
+  - [Write Adapter](#write-adapter)
+  - [Development](#development)
+  - [Contributing](#contributing)
 
 ## Installation
 
@@ -20,12 +58,408 @@ Or install it yourself as:
 
 ## Usage
 
-It provides only one api:
+It provides two apis: `query_nodes` and `match_node?`
+
+```ruby
+node_query = NodeQuery.new(nqlOrRules: String | Hash) # Initialize NodeQuery
+node_query.query_nodes(node: Node, including_self = true): Node[] # Get the matching nodes.
+node_query.match_node?(node: Node): boolean # Check if the node matches nql or rules.
+```
+
+Here is an example for parser ast node.
+
+```ruby
+source = `
+  class User
+    def initialize(id, name)
+      @id = id
+      @name = name
+    end
+  end
+
+  user = User.new(1, "Murphy")
+`
+node = Parser::CurrentRuby.parse(source)
+
+# It will get the node of initialize.
+NodeQuery.new('.def[name=initialize]').query_nodes(node)
+NodeQuery.new({ nodeType: 'def', name: 'initialize' }).query_nodes(node)
+```
+
+## Node Query Language
+
+### nql matches node type
+
+```
+.class
+```
+
+It matches class node
+
+### nql matches attribute
+
+```
+.class[name=User]
+```
+
+It matches class node whose name is User
+
+### nql matches nested attribute
+
+```
+.class[parent_class.name=Base]
+```
+
+It matches class node whose parent class name is Base
+
+### nql matches evaluated value
+
+```
+.ivasgn[left_value="@{{right_value}}"]
+```
+
+It matches ivasgn node whose left value equals '@' plus the evaluated value of right value.
+
+### nql matches nested selector
+
+```
+.def[body.0=.ivasgn]
+```
+
+It matches def node whose first child node is an ivasgn node.
+
+### nql matches method result
+
+```
+.def[arguments.size=2]
+```
+
+It matches def node whose arguments size is 2.
+
+### nql matches operators
+
+```
+.class[name=User]
+```
+
+Value of name is equal to User
+
+```
+.class[name^=User]
+```
+
+Value of name starts with User
+
+```
+.class[name$=User]
+```
+
+Value of name ends with User
+
+```
+.class[name*=User]
+```
+
+Value of name contains User
+
+```
+.def[arguments.size!=2]
+```
+
+Size of arguments is not equal to 2
+
+```
+.def[arguments.size>=2]
+```
+
+Size of arguments is greater than or equal to 2
+
+```
+.def[arguments.size>2]
+```
+
+Size of arguments is greater than 2
+
+```
+.def[arguments.size<=2]
+```
+
+Size of arguments is less than or equal to 2
+
+```
+.def[arguments.size<2]
+```
+
+Size of arguments is less than 2
+
+```
+.class[name IN (User Account)]
+```
+
+Value of name is either User or Account
+
+```
+.class[name NOT IN (User Account)]
+```
+
+Value of name is neither User nor Account
+
+```
+.def[arguments INCLUDES id]
+```
+
+Value of arguments includes id
+
+```
+.class[name=~/User/]
+```
+
+Value of name matches User
+
+```
+.class[name!~/User/]
+```
+
+Value of name does not match User
+
+```
+.class[name IN (/User/ /Account/)]
+```
+
+Value of name matches either /User/ or /Account/
+
+### nql matches array node attribute
+
+```
+.def[arguments=(id name)]
+```
+
+It matches def node whose arguments are id and name.
+
+### nql matches * in attribute key
+
+```
+.def[arguments.*.name IN (id name)]
+```
+
+It matches def node whose arguments are either id or name.
+
+### nql matches multiple selectors
+
+#### Descendant combinator
+
+```
+.class .send
+```
+
+It matches send node whose ansestor is class node.
+
+#### Child combinator
+
+```
+.def > .send
+```
+
+It matches send node whose parent is def node.
+
+#### Adjacent sibling combinator
+
+```
+.send[left_value=@id] + .send
+```
+
+It matches send node only if it is immediately follows the send node whose left value is @id.
+
+#### General sibling combinator
+
+```
+.send[left_value=@id] ~ .send
+```
+
+It matches send node only if it is follows the send node whose left value is @id.
+
+### nql matches goto scope
+
+```
+.def body .send
+```
+
+It matches send node who is in the body of def node.
+
+### nql matches pseudo selector
+
+```
+.class:has(.def[name=initialize])
+```
+
+It matches class node who has an initialize def node.
+
+```
+.class:not_has(.def[name=initialize])
+```
+
+It matches class node who does not have an initialize def node.
+
+### nql matches multiple expressions
+
+```
+.ivasgn[left_value=@id], .ivasgn[left_value=@name]
+```
+
+It matches ivasgn node whose left value is either @id or @name.
+
+## Node Rules
+
+### rules matches node type
+
+```
+{ nodeType: 'class' }
+```
+
+It matches class node
+
+### rules matches attribute
+
+```
+{ nodeType: 'def', name: 'initialize' }
+```
+
+It matches def node whose name is initialize
+
+```
+{ nodeType: 'def', arguments: { "0": 1, "1": "Murphy" } }
+```
+
+It matches def node whose arguments are 1 and Murphy.
+
+### rules matches nested attribute
+
+```
+{ nodeType: 'class', parent_class: { name: 'Base' } }
+```
+
+It matches class node whose parent class name is Base
+
+### rules matches evaluated value
+
+```
+{ nodeType: 'ivasgn', left_value: '@{{right_value}}' }
+```
+
+It matches ivasgn node whose left value equals '@' plus the evaluated value of right value.
+
+### rules matches nested selector
+
+```
+{ nodeType: 'def', body: { "0": { nodeType: 'ivasgn' } } }
+```
+
+It matches def node whose first child node is an ivasgn node.
+
+### rules matches method result
+
+```
+{ nodeType: 'def', arguments: { size: 2 } }
+```
+
+It matches def node whose arguments size is 2.
+
+### rules matches operators
+
+```
+{ nodeType: 'class', name: 'User' }
+```
+
+Value of name is equal to User
+
+```
+{ nodeType: 'def', arguments: { size { not: 2 } }
+```
+
+Size of arguments is not equal to 2
+
+```
+{ nodeType: 'def', arguments: { size { gte: 2 } }
+```
+
+Size of arguments is greater than or equal to 2
+
+```
+{ nodeType: 'def', arguments: { size { gt: 2 } }
+```
+
+Size of arguments is greater than 2
+
+```
+{ nodeType: 'def', arguments: { size { lte: 2 } }
+```
+
+Size of arguments is less than or equal to 2
+
+```
+{ nodeType: 'def', arguments: { size { lt: 2 } }
+```
+
+Size of arguments is less than 2
+
+```
+{ nodeType: 'class', name: { in: ['User', 'Account'] } }
+```
+
+Value of name is either User or Account
+
+```
+{ nodeType: 'class', name: { not_in: ['User', 'Account'] } }
+```
+
+Value of name is neither User nor Account
+
+```
+{ nodeType: 'def', arguments: { includes: 'id' } }
+```
+
+Value of arguments includes id
+
+```
+{ nodeType: 'class', name: /User/ }
+```
+
+Value of name matches User
+
+```
+{ nodeType: 'class', name: { not: /User/ } }
+```
+
+Value of name does not match User
+
+```
+{ nodeType: 'class', name: { in: [/User/, /Account/] } }
+```
+
+Value of name matches either /User/ or /Account/
+
+### rules matches array nodes attribute
+
+```
+{ nodeType: 'def', arguments: ['id', 'name'] }
+```
+
+It matches def node whose arguments are id and name.
+
+## Write Adapter
+
+Different parser, like parser, will generate different AST nodes, to make NodeQuery work for them all,
+we define an [Adapter](https://github.com/xinminlabs/node-query-ruby/blob/main/lib/node_query/adapter.rb) interface,
+if you implement the Adapter interface, you can set it as NodeQuery's adapter.
 
 ```ruby
-NodeQuery.new(nodeQueryString).parse(node)
+NodeQuery.configure(adapter: ParserAdapter.new)
 ```
 
+Here is the ParserAdapter implementation:
+
+[ParserAdapter](https://github.com/xinminlabs/node-query-ruby/blob/main/lib/node_query/parser_adapter.rb)
+
 ## 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.

data/lib/node_query/adapter.rb

@@ -2,6 +2,12 @@
 
 # Abstract Adapter class
 class NodeQuery::Adapter
+  # Check if it is a node
+  # @return [Boolean]
+  def is_node?(node)
+    raise NotImplementedError, 'get_node_type is not implemented'
+  end
+
   # Get the type of node
   # @param node [Node] ast node
   # @return [Symbol] node type

data/lib/node_query/compiler/attribute.rb

@@ -17,7 +17,7 @@ module NodeQuery::Compiler
     # @param node [Node] the node
     # @return [Boolean]
     def match?(node)
-      @value.base_node = node if @value.is_a?(EvaluatedValue)
+      @value.base_node = node if @value.is_a?(String)
       node && @value.match?(NodeQuery::Helper.get_target_node(node, @key), @operator)
     end
 

data/lib/node_query/compiler/basic_selector.rb

@@ -17,7 +17,7 @@ module NodeQuery::Compiler
     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))
+      @node_type.to_sym == NodeQuery.adapter.get_node_type(node) && (!@attribute_list || @attribute_list.match?(node))
     end
 
     def to_s

data/lib/node_query/compiler/comparable.rb

@@ -25,7 +25,7 @@ module NodeQuery::Compiler
           !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
+          !is_equal?(node)
         end
       when '=~'
         actual_value(node) =~ expected_value
@@ -46,9 +46,17 @@ module NodeQuery::Compiler
       when '<='
         actual_value(node) <= expected_value
       when 'in'
-        expected_value.any? { |expected| expected.match?(node, '==') }
+        if node.is_a?(Array)
+          node.all? { |child| expected_value.any? { |expected| expected.match?(child, '==') } }
+        else
+          expected_value.any? { |expected| expected.match?(node, '==') }
+        end
       when 'not_in'
-        expected_value.all? { |expected| expected.match?(node, '!=') }
+        if node.is_a?(Array)
+          node.all? { |child| expected_value.all? { |expected| expected.match?(child, '!=') } }
+        else
+          expected_value.all? { |expected| expected.match?(node, '!=') }
+        end
       when 'includes'
         actual_value(node).any? { |actual| actual == expected_value }
       else
@@ -57,19 +65,26 @@ module NodeQuery::Compiler
           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
+          is_equal?(node)
         end
       end
     end
 
+    # Check if the actual value equals the node value.
+    # @param node [Node] the node
+    # @return [Boolean] true if the actual value equals the node value.
+    def is_equal?(node)
+      actual_value(node) == expected_value
+    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)
+      if NodeQuery.adapter.is_node?(node)
+        case NodeQuery.adapter.get_node_type(node)
         when :int, :float, :str, :sym
-          NodeQuery.get_adapter.get_children(node).last
+          NodeQuery.adapter.get_children(node).last
         when :true
           true
         when :false
@@ -77,13 +92,13 @@ module NodeQuery::Compiler
         when :nil
           nil
         when :array
-          NodeQuery.get_adapter.get_children(node).map { |child_node| actual_value(child_node) }
+          NodeQuery.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)
+          actual_value(NodeQuery.adapter.get_children(node).first)..actual_value(NodeQuery.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)
+          actual_value(NodeQuery.adapter.get_children(node).first)...actual_value(NodeQuery.adapter.get_children(node).last)
         when :begin
-          actual_value(NodeQuery.get_adapter.get_children(node).first)
+          actual_value(NodeQuery.adapter.get_children(node).first)
         else
           node
         end

data/lib/node_query/compiler/expression.rb

@@ -11,22 +11,16 @@ module NodeQuery::Compiler
       @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
+    # @params including_self [boolean] if query the current node.
     # @return [Array<Node>] matching nodes.
-    def query_nodes(node)
-      matching_nodes = @selector.query_nodes(node)
+    def query_nodes(node, including_self = true)
+      matching_nodes = @selector.query_nodes(node, including_self)
       return matching_nodes if @rest.nil?
 
       matching_nodes.flat_map do |matching_node|
-        @rest.query_nodes(matching_node)
+        @rest.query_nodes(matching_node, including_self)
       end
     end