synvert-core 1.5.0 → 1.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 71ae91a324677995dbfd9b1251ebf2a0a01e7c25289dcebcf86abb07599b1db8
-  data.tar.gz: 4370235d14aee70f57b6b02313637e9d24b13ca2aee61b71e4fa4022f78bc3f8
+  metadata.gz: 5d838da042cfdbc68e4a235117a465ca340fa732203f7470684a9279e6797fff
+  data.tar.gz: ad784c3e09faa73a55e0bf0ad51a982230d9a1b2a328c43414e4aa297e38a00e
 SHA512:
-  metadata.gz: 8bcd68a69575a6cd5c5c0bc7a91f82d09d2f438ab06988c01ad14c7d97c863bc2556f5c3ad7d054e35cfcb830cb778ec10a9797952a56a9391062b4bf3ce2a3f
-  data.tar.gz: be7b4c9fda8428c0d2a8c29350f6d2c60c40577c0f990ed5d8f4d2742fc2545fc8ddbd139298aaf39a9e69e9e9bf83fe29385745ac7ef10459da836572df9327
+  metadata.gz: 4b31e94f8071af04f1ae7b1292bb5af91e52ba047949535667cb6765a5ef32c9bbcf855dd92a212aa640b0185f42fbd1bbcf4614f424c596f9c52f62a313a643
+  data.tar.gz: 197318ccffd17c9eb60251731bf49f45198e2b5fb5812c22d4fe6d0d07bac94bff638bc5a125d05be2ccec930b16300ccdb83ffdd53bf8cf0c4cd8ad22a34c94

data/.github/workflows/main.yml

@@ -15,7 +15,6 @@ on:
 
 jobs:
   test:
-
     runs-on: ubuntu-latest
     strategy:
       matrix:

data/.gitignore

@@ -3,7 +3,6 @@
 .bundle
 .config
 .yardoc
-Gemfile.lock
 InstalledFiles
 _yardoc
 coverage

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 # CHANGELOG
 
+## 1.6.0 (2022-09-15)
+
+* Make use of `NodeQuery` to query nodes
+* Remove `Node#to_hash`
+* Downgrade `activesupport` to < 7.0.0
+
 ## 1.5.0 (2022-07-02)
 
 * Abstract `node_query`

data/Gemfile.lock

@@ -0,0 +1,101 @@
+PATH
+  remote: .
+  specs:
+    synvert-core (1.6.0)
+      activesupport (< 7.0.0)
+      erubis
+      node_mutation
+      node_query
+      parser
+      parser_node_ext
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    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)
+    diff-lcs (1.5.0)
+    erubis (2.7.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-rspec (4.7.3)
+      guard (~> 2.1)
+      guard-compat (~> 1.1)
+      rspec (>= 2.99.0, < 4.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.3)
+    nenv (0.3.0)
+    node_mutation (1.2.1)
+      activesupport
+      erubis
+    node_query (1.5.0)
+      activesupport (< 7.0.0)
+    notiffany (0.1.3)
+      nenv (~> 0.1)
+      shellany (~> 0.0)
+    parser (3.1.2.1)
+      ast (~> 2.4.1)
+    parser_node_ext (0.4.0)
+      parser
+    pry (0.14.1)
+      coderay (~> 1.1)
+      method_source (~> 1.0)
+    rake (13.0.6)
+    rb-fsevent (0.11.1)
+    rb-inotify (0.10.1)
+      ffi (~> 1.0)
+    rspec (3.10.0)
+      rspec-core (~> 3.10.0)
+      rspec-expectations (~> 3.10.0)
+      rspec-mocks (~> 3.10.0)
+    rspec-core (3.10.2)
+      rspec-support (~> 3.10.0)
+    rspec-expectations (3.10.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.10.0)
+    rspec-mocks (3.10.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.10.0)
+    rspec-support (3.10.3)
+    shellany (0.0.1)
+    thor (1.2.1)
+    tzinfo (2.0.5)
+      concurrent-ruby (~> 1.0)
+    zeitwerk (2.6.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  guard
+  guard-rspec
+  rake
+  rspec
+  rspec-mocks
+  synvert-core!
+
+BUNDLED WITH
+   2.3.7

data/README.md

@@ -1,6 +1,6 @@
 # synvert-core-ruby
 
-<img src="https://synvert.xinminlabs.com/img/logo_96.png" alt="logo" width="32" height="32" />
+<img src="https://synvert.net/img/logo_96.png" alt="logo" width="32" height="32" />
 
 [![AwesomeCode Status for xinminlabs/synvert-core-ruby](https://awesomecode.io/projects/033f7f02-7b22-41c3-a902-fca37f1ec72a/status)](https://awesomecode.io/repos/xinminlabs/synvert-core-ruby)
 ![Main workflow](https://github.com/xinminlabs/synvert-core-ruby/actions/workflows/main.yml/badge.svg)

data/lib/synvert/core/node_ext.rb

@@ -50,43 +50,6 @@ module Parser::AST
       loc.expression.line
     end
 
-    # Match node with rules.
-    # It provides some additional keywords to match rules, +any+, +contain+, +not+, +in+, +not_in+, +gt+, +gte+, +lt+, +lte+.
-    # @example
-    #   type: 'send', arguments: { any: 'Lifo::ShowExceptions' }
-    #   type: { in: ['send', 'csend'] }
-    #   type: :send, arguments: { length: { gt: 2 } }
-    # @param rules [Hash] rules to match.
-    # @return true if matches.
-    def match?(rules)
-      keywords = %i[any contain not in not_in gt gte lt lte]
-      flat_hash(rules).keys.all? do |multi_keys|
-        last_key = multi_keys.last
-        actual = keywords.include?(last_key) ? actual_value(multi_keys[0...-1]) : actual_value(multi_keys)
-        expected = expected_value(rules, multi_keys)
-        case last_key
-        when :any, :contain
-          actual.any? { |actual_value| match_value?(actual_value, expected) }
-        when :not
-          !match_value?(actual, expected)
-        when :in
-          expected.any? { |expected_value| match_value?(actual, expected_value) }
-        when :not_in
-          expected.all? { |expected_value| !match_value?(actual, expected_value) }
-        when :gt
-          actual > expected
-        when :gte
-          actual >= expected
-        when :lt
-          actual < expected
-        when :lte
-          actual <= expected
-        else
-          match_value?(actual, expected)
-        end
-      end
-    end
-
     # Strip curly braces for hash.
     # @example
     #   node # s(:hash, s(:pair, s(:sym, :foo), s(:str, "bar")))
@@ -161,141 +124,5 @@ module Parser::AST
         to_source
       end
     end
-
-    # Convert node to a hash, so that it can be converted to a json.
-    def to_hash
-      result = { type: type }
-      if TYPE_CHILDREN[type]
-        TYPE_CHILDREN[type].each do |key|
-          value = send(key)
-          result[key] =
-            case value
-            when Array
-              value.map { |v| v.respond_to?(:to_hash) ? v.to_hash : v }
-            when Parser::AST::Node
-              value.to_hash
-            else
-              value
-            end
-        end
-      else
-        result[:children] = children.map { |c| c.respond_to?(:to_hash) ? c.to_hash : c }
-      end
-      result
-    end
-
-    private
-
-    # Compare actual value with expected value.
-    #
-    # @param actual [Object] actual value.
-    # @param expected [Object] expected value.
-    # @return [Boolean]
-    # @raise [Synvert::Core::MethodNotSupported] if expected class is not supported.
-    def match_value?(actual, expected)
-      return true if actual == expected
-
-      case expected
-      when Symbol
-        if actual.is_a?(Parser::AST::Node)
-          actual.to_source == ":#{expected}" || actual.to_source == expected.to_s
-        else
-          actual.to_sym == expected
-        end
-      when String
-        if actual.is_a?(Parser::AST::Node)
-          actual.to_source == expected || actual.to_source == unwrap_quote(expected) ||
-            unwrap_quote(actual.to_source) == expected || unwrap_quote(actual.to_source) == unwrap_quote(expected)
-        else
-          actual.to_s == expected || wrap_quote(actual.to_s) == expected
-        end
-      when Regexp
-        if actual.is_a?(Parser::AST::Node)
-          actual.to_source =~ Regexp.new(expected.to_s, Regexp::MULTILINE)
-        else
-          actual.to_s =~ Regexp.new(expected.to_s, Regexp::MULTILINE)
-        end
-      when Array
-        return false unless expected.length == actual.length
-
-        actual.zip(expected).all? { |a, e| match_value?(a, e) }
-      when NilClass
-        if actual.is_a?(Parser::AST::Node)
-          :nil == actual.type
-        else
-          actual.nil?
-        end
-      when Numeric
-        if actual.is_a?(Parser::AST::Node)
-          actual.children[0] == expected
-        else
-          actual == expected
-        end
-      when TrueClass
-        :true == actual.type
-      when FalseClass
-        :false == actual.type
-      when Parser::AST::Node
-        actual == expected
-      when Synvert::Core::Rewriter::AnyValue
-        !actual.nil?
-      else
-        raise Synvert::Core::MethodNotSupported, "#{expected.class} is not handled for match_value?"
-      end
-    end
-
-    # Convert a hash to flat one.
-    #
-    # @example
-    #   flat_hash(type: 'block', caller: {type: 'send', receiver: 'RSpec'})
-    #     # {[:type] => 'block', [:caller, :type] => 'send', [:caller, :receiver] => 'RSpec'}
-    # @param h [Hash] original hash.
-    # @return flatten hash.
-    def flat_hash(h, k = [])
-      new_hash = {}
-      h.each_pair do |key, val|
-        if val.is_a?(Hash)
-          new_hash.merge!(flat_hash(val, k + [key]))
-        else
-          new_hash[k + [key]] = val
-        end
-      end
-      new_hash
-    end
-
-    # Get actual value from the node.
-    #
-    # @param multi_keys [Array<Symbol, String>]
-    # @return [Object] actual value.
-    def actual_value(multi_keys)
-      multi_keys.inject(self) { |n, key| n.send(key) if n }
-    end
-
-    # Get expected value from rules.
-    #
-    # @param rules [Hash]
-    # @param multi_keys [Array<Symbol>]
-    # @return [Object] expected value.
-    def expected_value(rules, multi_keys)
-      multi_keys.inject(rules) { |o, key| o[key] }
-    end
-
-    # Wrap the string with single or double quote.
-    def wrap_quote(string)
-      if string.include?("'")
-        "\"#{string}\""
-      else
-        "'#{string}'"
-      end
-    end
-
-    # Unwrap the quote from the string.
-    def unwrap_quote(string)
-      if (string[0] == '"' && string[-1] == '"') || (string[0] == "'" && string[-1] == "'")
-        string[1...-1]
-      else
-        string
-      end
-    end
   end
 end

data/lib/synvert/core/rewriter/condition/if_exist_condition.rb

@@ -9,11 +9,7 @@ module Synvert::Core
     #
     # @return [Boolean]
     def match?
-      match = false
-      NodeQuery::Helper.handle_recursive_child(@instance.current_node) do |child_node|
-        match ||= child_node&.match?(@rules)
-      end
-      match
+      @node_query.query_nodes(target_node, including_self: false, stop_at_first_match: true).size > 0
     end
   end
 end

data/lib/synvert/core/rewriter/condition/if_only_exist_condition.rb

@@ -9,7 +9,7 @@ module Synvert::Core
     #
     # @return [Boolean]
     def match?
-      @instance.current_node.body.size == 1 && @instance.current_node.body.first.match?(@rules)
+      target_node.body.size == 1 && @node_query.match_node?(target_node.body.first)
     end
   end
 end

data/lib/synvert/core/rewriter/condition/unless_exist_condition.rb

@@ -9,11 +9,7 @@ module Synvert::Core
     #
     # return [Boolean]
     def match?
-      match = false
-      NodeQuery::Helper.handle_recursive_child(@instance.current_node) do |child_node|
-        match ||= child_node&.match?(@rules)
-      end
-      !match
+      @node_query.query_nodes(target_node, including_self: false, stop_at_first_match: true).size == 0
     end
   end
 end

data/lib/synvert/core/rewriter/condition.rb

@@ -10,7 +10,7 @@ module Synvert::Core
     # @yield run when condition matches
     def initialize(instance, rules, &block)
       @instance = instance
-      @rules = rules
+      @node_query = NodeQuery.new(rules)
       @block = block
     end
 
@@ -27,5 +27,9 @@ module Synvert::Core
     def match?
       raise NotImplementedError, 'must be implemented by subclasses'
     end
+
+    def target_node
+      @instance.current_node
+    end
   end
 end

data/lib/synvert/core/rewriter/instance.rb

@@ -79,11 +79,13 @@ module Synvert::Core
     #   # matches FactoryBot.create(:user)
     #   find_node '.send[receiver=FactoryBot][message=create][arguments.size=1]' do
     #   end
-    # @param query_string [String] query string to find matching ast nodes.
+    # @param nql [String] node query language to find matching ast nodes.
     # @yield run on the matching nodes.
     # @raise [Synvert::Core::NodeQuery::Compiler::ParseError] if query string is invalid.
-    def find_node(query_string, &block)
-      Rewriter::QueryScope.new(self, query_string, &block).process
+    def find_node(nql, options = {}, &block)
+      Rewriter::QueryScope.new(self, nql, options, &block).process
+    rescue NodeQueryLexer::ScanError, Racc::ParseError => e
+      raise NodeQuery::Compiler::ParseError, "Invalid query string: #{nql}"
     end
 
     # Parse +within_node+ dsl, it creates a {Synvert::Core::Rewriter::WithinScope} to recursively find matching ast nodes,
@@ -94,12 +96,11 @@ module Synvert::Core
     #   end
     # @param rules [Hash] rules to find mathing ast nodes.
     # @param options [Hash] optional
-    # @option stop_when_match [Boolean] set if stop when match, default is false
-    # @option direct [Boolean] set if find direct matching ast nodes, default is false
+    # @option including_self [Boolean] set if query the current node, default is true
+    # @option stop_at_first_match [Boolean] set if stop at first match, default is false
+    # @option recursive [Boolean] set if recursively query child nodes, default is true
     # @yield run on the matching nodes.
     def within_node(rules, options = {}, &block)
-      options[:stop_when_match] ||= false
-      options[:direct] ||= false
       Rewriter::WithinScope.new(self, rules, options, &block).process
     end
 

data/lib/synvert/core/rewriter/scope/query_scope.rb

@@ -6,11 +6,14 @@ module Synvert::Core
     # Initialize a QueryScope.
     #
     # @param instance [Synvert::Core::Rewriter::Instance]
-    # @param query_string [String]
+    # @param nql [String]
+    # @param options [Hash]
     # @yield run on all matching nodes
-    def initialize(instance, query_string, &block)
+    def initialize(instance, nql, options = {}, &block)
       super(instance, &block)
-      @query_string = query_string
+
+      @options = { including_self: true, stop_at_first_match: false, recursive: true }.merge(options)
+      @node_query = NodeQuery.new(nql)
     end
 
     # Find out the matching nodes.
@@ -22,15 +25,14 @@ module Synvert::Core
       current_node = @instance.current_node
       return unless current_node
 
+      matching_nodes = @node_query.query_nodes(current_node, @options)
       @instance.process_with_node(current_node) do
-        NodeQuery.new(@query_string).parse(current_node).each do |node|
+        matching_nodes.each do |node|
           @instance.process_with_node(node) do
             @instance.instance_eval(&@block)
           end
         end
       end
-    rescue NodeQueryLexer::ScanError, Racc::ParseError => e
-      raise NodeQuery::Compiler::ParseError, "Invalid query string: #{@query_string}"
     end
   end
 end

data/lib/synvert/core/rewriter/scope/within_scope.rb

@@ -11,8 +11,9 @@ module Synvert::Core
     # @yield run on all matching nodes
     def initialize(instance, rules, options = {}, &block)
       super(instance, &block)
-      @rules = rules
-      @options = options
+
+      @options = { including_self: true, stop_at_first_match: false, recursive: true }.merge(options)
+      @node_query = NodeQuery.new(rules)
     end
 
     # Find out the matching nodes.
@@ -22,14 +23,7 @@ module Synvert::Core
       current_node = @instance.current_node
       return unless current_node
 
-      matching_nodes =
-        if @options[:direct]
-          find_direct_matching_nodes(current_node)
-        elsif @options[:stop_when_match]
-          find_matching_nodes(current_node)
-        else
-          find_recursive_matching_nodes(current_node)
-        end
+      matching_nodes = @node_query.query_nodes(current_node, @options)
       @instance.process_with_node current_node do
         matching_nodes.each do |matching_node|
           @instance.process_with_node matching_node do
@@ -38,82 +32,5 @@ module Synvert::Core
         end
       end
     end
-
-    private
-
-    # Find the matching nodes only in current or direct children.
-    #
-    # @param current_node [Parser::AST::Node]
-    def find_direct_matching_nodes(current_node)
-      matching_nodes = []
-      if current_node.is_a?(Parser::AST::Node)
-        if current_node.type == :begin
-          current_node.children.each do |child_node|
-            matching_nodes << child_node if child_node.match?(@rules)
-          end
-        elsif current_node.match?(@rules)
-          matching_nodes << current_node
-        end
-      else
-        current_node.each do |child_node|
-          matching_nodes << child_node if child_node.match?(@rules)
-        end
-      end
-      matching_nodes
-    end
-
-    # Find matching nodes in all recursive children.
-    #
-    # @param current_node [Parser::AST::Node]
-    def find_recursive_matching_nodes(current_node)
-      matching_nodes = []
-      if current_node.is_a?(Parser::AST::Node)
-        matching_nodes << current_node if current_node.match?(@rules)
-        NodeQuery::Helper.handle_recursive_child(current_node) do |child_node|
-          matching_nodes << child_node if child_node.match?(@rules)
-        end
-      else
-        current_node.each do |node|
-          matching_nodes << node if node.match?(@rules)
-          NodeQuery::Helper.handle_recursive_child(node) do |child_node|
-            matching_nodes << child_node if child_node.match?(@rules)
-          end
-        end
-      end
-      matching_nodes
-    end
-
-    # Find matching nodes in recursive children but do not continue on matching nodes.
-    #
-    # @param current_node [Parser::AST::Node]
-    def find_matching_nodes(current_node)
-      matching_nodes = []
-      if current_node.is_a?(Parser::AST::Node)
-        if current_node.match?(@rules)
-          matching_nodes << current_node
-          return matching_nodes
-        end
-        NodeQuery::Helper.handle_recursive_child(current_node) do |child_node|
-          if child_node.match?(@rules)
-            matching_nodes << child_node
-            next :stop
-          end
-        end
-      else
-        current_node.each do |node|
-          if node.match?(@rules)
-            matching_nodes << node
-            next
-          end
-          NodeQuery::Helper.handle_recursive_child(node) do |child_node|
-            if child_node.match?(@rules)
-              matching_nodes << child_node
-              next :stop
-            end
-          end
-        end
-      end
-      matching_nodes
-    end
   end
 end

data/lib/synvert/core/version.rb

@@ -2,6 +2,6 @@
 
 module Synvert
   module Core
-    VERSION = '1.5.0'
+    VERSION = '1.6.0'
   end
 end

data/spec/synvert/core/node_ext_spec.rb

@@ -3,133 +3,6 @@
 require 'spec_helper'
 
 describe Parser::AST::Node do
-  describe '#match?' do
-    it 'matches class name' do
-      source = 'class Synvert; end'
-      node = parse(source)
-      expect(node).to be_match(type: 'class', name: 'Synvert')
-    end
-
-    it 'matches message with regexp' do
-      source = 'User.find_by_login(login)'
-      node = parse(source)
-      expect(node).to be_match(type: 'send', message: /^find_by_/)
-    end
-
-    it 'matches arguments with symbol' do
-      source = 'params[:user]'
-      node = parse(source)
-      expect(node).to be_match(type: 'send', receiver: 'params', message: '[]', arguments: [:user])
-    end
-
-    it 'matches pair key with symbol' do
-      source = '{ type: :model }'
-      node = parse(source).children[0]
-      expect(node).to be_match(type: 'pair', key: :type)
-    end
-
-    it 'matches assign number' do
-      source = 'at_least(0)'
-      node = parse(source)
-      expect(node).to be_match(type: 'send', arguments: [0])
-    end
-
-    it 'matches assign float' do
-      source = 'at_least(1.5)'
-      node = parse(source)
-      expect(node).to be_match(type: 'send', arguments: [1.5])
-    end
-
-    it 'matches arguments with string' do
-      source = 'params["user"]'
-      node = parse(source)
-      expect(node).to be_match(type: 'send', receiver: 'params', message: '[]', arguments: ['user'])
-    end
-
-    it 'matches arguments with string 2' do
-      source = 'params["user"]'
-      node = parse(source)
-      expect(node).to be_match(type: 'send', receiver: 'params', message: '[]', arguments: ["'user'"])
-    end
-
-    it 'matches arguments with string 3' do
-      source = "{ notice: 'Welcome' }"
-      node = parse(source)
-      expect(node).to be_match(type: 'hash', notice_value: "'Welcome'")
-    end
-
-    it 'matches arguments any' do
-      source = 'config.middleware.insert_after ActiveRecord::QueryCache, Lifo::Cache, page_cache: false'
-      node = parse(source)
-      expect(node).to be_match(type: 'send', arguments: { any: 'Lifo::Cache' })
-    end
-
-    it 'matches arguments with nested hash' do
-      source = '{ user_id: user.id }'
-      node = parse(source)
-      expect(node).to be_match(
-        type: 'hash',
-        user_id_value: {
-          type: 'send',
-          receiver: { type: 'send', message: 'user' },
-          message: 'id'
-        }
-      )
-    end
-
-    it 'matches arguments contain' do
-      source = 'def slow(foo, bar, &block); end'
-      node = parse(source)
-      expect(node).to be_match(type: 'def', arguments: { contain: '&block' })
-    end
-
-    it 'matches not' do
-      source = 'class Synvert; end'
-      node = parse(source)
-      expect(node).not_to be_match(type: 'class', name: { not: 'Synvert' })
-    end
-
-    it 'matches in' do
-      source = 'FactoryBot.create(:user)'
-      node = parse(source)
-      expect(node).to be_match(type: 'send', message: { in: %i[create build] })
-    end
-
-    it 'matches not_in' do
-      source = 'FactoryBot.create(:user)'
-      node = parse(source)
-      expect(node).not_to be_match(type: 'send', message: { not_in: %i[create build] })
-    end
-
-    it 'matches gt' do
-      source = 'foobar(foo, bar)'
-      node = parse(source)
-      expect(node).to be_match(type: 'send', arguments: { size: { gt: 1 } })
-      expect(node).not_to be_match(type: 'send', arguments: { size: { gt: 2 } })
-    end
-
-    it 'matches gte' do
-      source = 'foobar(foo, bar)'
-      node = parse(source)
-      expect(node).to be_match(type: 'send', arguments: { size: { gte: 2 } })
-      expect(node).not_to be_match(type: 'send', arguments: { size: { gte: 3 } })
-    end
-
-    it 'matches lt' do
-      source = 'foobar(foo, bar)'
-      node = parse(source)
-      expect(node).to be_match(type: 'send', arguments: { size: { lt: 3 } })
-      expect(node).not_to be_match(type: 'send', arguments: { size: { lt: 2 } })
-    end
-
-    it 'matches lte' do
-      source = 'foobar(foo, bar)'
-      node = parse(source)
-      expect(node).to be_match(type: 'send', arguments: { size: { lte: 2 } })
-      expect(node).not_to be_match(type: 'send', arguments: { size: { lte: 1 } })
-    end
-  end
-
   describe '#strip_curly_braces' do
     context 'hash node' do
       it 'removes curly braces' do
@@ -232,47 +105,4 @@ describe Parser::AST::Node do
       end
     end
   end
-
-  describe '#to_hash' do
-    it 'gets hash' do
-      node = parse(<<~EOS)
-        class Synvert
-          def foobar(foo, bar)
-            { foo => bar }
-          end
-        end
-      EOS
-      expect(node.to_hash).to eq(
-        {
-          type: :class,
-          parent_class: nil,
-          name: {
-            type: :const,
-            parent_const: nil,
-            name: :Synvert
-          },
-          body: [
-            {
-              type: :def,
-              name: :foobar,
-              arguments: [
-                { type: :arg, name: :foo },
-                { type: :arg, name: :bar }
-              ],
-              body: [
-                {
-                  type: :hash,
-                  pairs: {
-                    type: :pair,
-                    key: { type: :lvar, name: :foo },
-                    value: { type: :lvar, name: :bar }
-                  }
-                }
-              ]
-            }
-          ]
-        }
-      )
-    end
-  end
 end

data/spec/synvert/core/rewriter/instance_spec.rb

@@ -12,16 +12,27 @@ module Synvert::Core
     it 'parses find_node' do
       scope = double
       block = proc {}
-      expect(Rewriter::QueryScope).to receive(:new).with(instance, '.send[message=create]', &block).and_return(scope)
+      expect(Rewriter::QueryScope).to receive(:new).with(instance, '.send[message=create]', {}, &block).and_return(scope)
       expect(scope).to receive(:process)
       instance.find_node('.send[message=create]', &block)
     end
 
+    it 'raises ParseError when parsing invalid nql' do
+      block = proc {}
+      expect {
+        instance.find_node('synvert', &block)
+      }.to raise_error(NodeQuery::Compiler::ParseError)
+
+      expect {
+        instance.find_node('.block <caller.arguments> .hash', &block)
+      }.to raise_error(NodeQuery::Compiler::ParseError)
+    end
+
     it 'parses within_node' do
       scope = double
       block = proc {}
       expect(Rewriter::WithinScope).to receive(:new)
-        .with(instance, { type: 'send', message: 'create' }, { stop_when_match: false, direct: false }, &block)
+        .with(instance, { type: 'send', message: 'create' }, {}, &block)
         .and_return(scope)
       expect(scope).to receive(:process)
       instance.within_node(type: 'send', message: 'create', &block)
@@ -31,30 +42,20 @@ module Synvert::Core
       scope = double
       block = proc {}
       expect(Rewriter::WithinScope).to receive(:new)
-        .with(instance, { type: 'send', message: 'create' }, { stop_when_match: false, direct: false }, &block)
+        .with(instance, { type: 'send', message: 'create' }, {}, &block)
         .and_return(scope)
       expect(scope).to receive(:process)
       instance.with_node(type: 'send', message: 'create', &block)
     end
 
-    it 'parses within_node with stop_when_match true' do
-      scope = double
-      block = proc {}
-      expect(Rewriter::WithinScope).to receive(:new)
-        .with(instance, { type: 'send', message: 'create' }, { stop_when_match: true, direct: false }, &block)
-        .and_return(scope)
-      expect(scope).to receive(:process)
-      instance.within_node({ type: 'send', message: 'create' }, { stop_when_match: true }, &block)
-    end
-
-    it 'parses within_node with direct true' do
+    it 'parses within_node with stop_at_first_match true' do
       scope = double
       block = proc {}
       expect(Rewriter::WithinScope).to receive(:new)
-        .with(instance, { type: 'send', message: 'create' }, { stop_when_match: false, direct: true }, &block)
+        .with(instance, { type: 'send', message: 'create' }, { stop_at_first_match: true }, &block)
         .and_return(scope)
       expect(scope).to receive(:process)
-      instance.within_node({ type: 'send', message: 'create' }, { direct: true }, &block)
+      instance.within_node({ type: 'send', message: 'create' }, { stop_at_first_match: true }, &block)
     end
 
     it 'parses goto_node' do

data/spec/synvert/core/rewriter/scope/query_scope_spec.rb

@@ -55,18 +55,6 @@ module Synvert::Core
         expect(block_nodes.size).to eq 2
       end
 
-      it 'raises ParseError' do
-        scope = described_class.new(instance, 'synvert') {}
-        expect {
-          scope.process
-        }.to raise_error(NodeQuery::Compiler::ParseError)
-
-        scope = described_class.new(instance, '.block <caller.arguments> .hash') {}
-        expect {
-          scope.process
-        }.to raise_error(NodeQuery::Compiler::ParseError)
-      end
-
       it 'raises InvalidOperatorError' do
         scope = described_class.new(instance, '.send[receiver IN FactoryGirl]') {}
         expect {

data/spec/synvert/core/rewriter/scope/within_scope_spec.rb

@@ -9,9 +9,11 @@ module Synvert::Core
       Rewriter::Instance.new(rewriter, 'file pattern')
     }
     let(:source) { <<~EOS }
-      describe Post do
-        it 'gets post' do
-          FactoryGirl.create :post
+      describe User do
+        describe 'create' do
+          it 'creates user' do
+            FactoryGirl.create :user
+          end
         end
       end
     EOS
@@ -39,7 +41,7 @@ module Synvert::Core
                                     type: 'send',
                                     receiver: 'FactoryGirl',
                                     message: 'create',
-                                    arguments: [':post'] do
+                                    arguments: [':user'] do
             run = true
             type_in_scope = node.type
           end
@@ -52,27 +54,37 @@ module Synvert::Core
       it 'matches multiple block nodes' do
         block_nodes = []
         scope =
-          Rewriter::WithinScope.new(instance, { type: 'block' }, { stop_when_match: false }) do
+          Rewriter::WithinScope.new(instance, { type: 'block' }) do
+            block_nodes << node
+          end
+        scope.process
+        expect(block_nodes.size).to eq 3
+      end
+
+      it 'matches only 2 block nodes if including_self is false' do
+        block_nodes = []
+        scope =
+          Rewriter::WithinScope.new(instance, { type: 'block' }, { including_self: false }) do
             block_nodes << node
           end
         scope.process
         expect(block_nodes.size).to eq 2
       end
 
-      it 'matches only one block node if no recursive' do
+      it 'matches only one block node if recursive is false' do
         block_nodes = []
         scope =
-          Rewriter::WithinScope.new(instance, { type: 'block' }, { stop_when_match: true }) do
+          Rewriter::WithinScope.new(instance, { type: 'block' }, { recursive: false }) do
             block_nodes << node
           end
         scope.process
         expect(block_nodes.size).to eq 1
       end
 
-      it 'matches only one direct node' do
+      it 'matches only one block node if stop_at_first_match is true' do
         block_nodes = []
         scope =
-          Rewriter::WithinScope.new(instance, { type: 'block' }, { direct: true }) do
+          Rewriter::WithinScope.new(instance, { type: 'block' }, { stop_at_first_match: true }) do
             block_nodes << node
           end
         scope.process

data/synvert-core-ruby.gemspec

@@ -19,7 +19,7 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_runtime_dependency "activesupport"
+  spec.add_runtime_dependency "activesupport", "< 7.0.0"
   spec.add_runtime_dependency "erubis"
   spec.add_runtime_dependency "node_query"
   spec.add_runtime_dependency "node_mutation"

metadata

@@ -1,29 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: synvert-core
 version: !ruby/object:Gem::Version
-  version: 1.5.0
+  version: 1.6.0
 platform: ruby
 authors:
 - Richard Huang
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-07-02 00:00:00.000000000 Z
+date: 2022-09-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 7.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 7.0.0
 - !ruby/object:Gem::Dependency
   name: erubis
   requirement: !ruby/object:Gem::Requirement
@@ -106,6 +106,7 @@ files:
 - ".rspec"
 - CHANGELOG.md
 - Gemfile
+- Gemfile.lock
 - Guardfile
 - LICENSE.txt
 - README.md