synvert-core 1.11.0 → 1.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0663ba61695ae5b47f27e9a23f1edbfe31d3746f9b3e02a79315a827fae6f36c
-  data.tar.gz: 8199c6c8a122555bfbf0df0ef79f6bd96ade0cdfe472d81d6abe4cccde3b6c59
+  metadata.gz: d3d907ab2e51c1861a28d12934cf453f63df79fc23e072c1005013c5f9b137be
+  data.tar.gz: 16e8425a70a74b779b36265eec12aacca4b6073e5911052b0114726a740f6e99
 SHA512:
-  metadata.gz: 3609b9bdb845681c9dd71d9d0eca4985d43203ce28fb1e874e9538322f8205995d77f5b8c2b43fb11caf698a69772c3e7bdd5114a709e4513313339870576a5e
-  data.tar.gz: 952578268a2c8cba6dcd2883141fe5977917594ea01b76e51e93032fc71225c813b9021ec1852c3a93d76f6438f30f9975ac47b36c5da3d7c5805fa15763fa9e
+  metadata.gz: 3a73e71ccb24cbdf40fe515fcb732e242e27e5dbac5b130bc9e88d19b8c3ef315cc7c3e00195d3d4e15f6a24bd4fb89336686ae379451e3fa7433548bd3402c8
+  data.tar.gz: c6e026527d96e8766a330626c330d280c6ab650834e71b56c64c4cf81a4dd7d0911d89919c16e0f651208e0d0ce1c9c3b36f6c08f4c9f5f7d04d0af4849a713d

data/CHANGELOG.md

@@ -1,5 +1,16 @@
 # CHANGELOG
 
+## 1.13.0 (2022-10-17)
+
+* Add `insert_before` dsl
+* Update `insert_after` to reuse `NodeMutation#insert`
+
+## 1.12.0 (2022-10-14)
+
+* Condition accepts both nql and rules
+* Make `find_node` as an alias to `within_node`
+* Remove skip files only once
+
 ## 1.11.0 (2022-10-11)
 
 * Add `Configuration.number_of_workers`

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    synvert-core (1.11.0)
+    synvert-core (1.13.0)
       activesupport (< 7.0.0)
       erubis
       node_mutation
@@ -50,10 +50,10 @@ GEM
     method_source (1.0.0)
     minitest (5.16.3)
     nenv (0.3.0)
-    node_mutation (1.4.4)
+    node_mutation (1.5.0)
       activesupport (< 7.0.0)
       erubis
-    node_query (1.7.0)
+    node_query (1.8.1)
       activesupport (< 7.0.0)
     notiffany (0.1.3)
       nenv (~> 0.1)

data/README.md

@@ -73,16 +73,16 @@ DSLs are as follows
 
 Scopes:
 
-* [find_node](./Synvert/Core/Rewriter/Instance.html#find_node-instance_method) - recursively find matching ast nodes by node query language
 * [within_node](./Synvert/Core/Rewriter/Instance.html#within_node-instance_method) - recursively find matching ast nodes
 * [with_node](./Synvert/Core/Rewriter/Instance.html#with_node-instance_method) - alias to within_node
+* [find_node](./Synvert/Core/Rewriter/Instance.html#find_node-instance_method) - alias to within_node
 * [goto_node](./Synvert/Core/Rewriter/Instance.html#goto_node-instance_method) - go to a child node
 
 Conditions:
 
 * [if_exist_node](./Synvert/Core/Rewriter/Instance.html#if_exist_node-instance_method) - check if matching node exist in the child nodes
 * [unless_exist_node](./Synvert/Core/Rewriter/Instance.html#unless_exist_node-instance_method) - check if matching node doesn't exist in the child nodes
-* [if_only_exist_node](./Synvert/Core/Rewriter/Instance.html#if_only_exist_node-instance_method) - check if current node has only one child node and the child node matches rules
+* [if_only_exist_node](./Synvert/Core/Rewriter/Instance.html#if_only_exist_node-instance_method) - check if current node has only one child node and the child node matches
 
 Actions:
 
@@ -90,6 +90,7 @@ Actions:
 * [prepend](./Synvert/Core/Rewriter/Instance.html#prepend-instance_method) - prepend the code to the bottom of current node body
 * [insert](./Synvert/Core/Rewriter/Instance.html#insert-instance_method) - insert code
 * [insert_after](./Synvert/Core/Rewriter/Instance.html#insert_after-instance_method) - insert the code next to the current node
+* [insert_before](./Synvert/Core/Rewriter/Instance.html#insert_before-instance_method) - insert the code previous to the current node
 * [replace](./Synvert/Core/Rewriter/Instance.html#replace-instance_method) - replace the code of specified child nodes
 * [delete](./Synvert/Core/Rewriter/Instance.html#delete-instance_method) - delete the code specified child nodes
 * [wrap](./Synvert/Core/Rewriter/Instance.html#wrap-instance_method) - wrap the current node with code

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

@@ -5,7 +5,7 @@ module Synvert::Core
   class Rewriter::IfExistCondition < Rewriter::Condition
     private
 
-    # check if any child node matches the rules.
+    # check if any child node matches.
     #
     # @return [Boolean]
     def match?

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

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
 module Synvert::Core
-  # IfOnlyExistCondition checks if node has only one child node and the child node matches rules.
+  # IfOnlyExistCondition checks if node has only one child node and the child node matches.
   class Rewriter::IfOnlyExistCondition < Rewriter::Condition
     private
 
-    # check if only have one child node and the child node matches rules.
+    # check if only have one child node and the child node matches.
     #
     # @return [Boolean]
     def match?

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

@@ -5,7 +5,7 @@ module Synvert::Core
   class Rewriter::UnlessExistCondition < Rewriter::Condition
     private
 
-    # check if none of child node matches the rules.
+    # check if none of child node matches.
     #
     # return [Boolean]
     def match?

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

@@ -1,16 +1,16 @@
 # frozen_string_literal: true
 
 module Synvert::Core
-  # Condition checks if rules matches.
+  # Condition checks if nql or rules matches.
   class Rewriter::Condition
     # Initialize a Condition.
     #
     # @param instance [Synvert::Core::Rewriter::Instance]
-    # @param rules [Hash]
+    # @param nql_or_rules [String|Hash]
     # @yield run when condition matches
-    def initialize(instance, rules, &block)
+    def initialize(instance, nql_or_rules, &block)
       @instance = instance
-      @node_query = NodeQuery.new(rules)
+      @node_query = NodeQuery.new(nql_or_rules)
       @block = block
     end
 

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

@@ -85,38 +85,29 @@ module Synvert::Core
     # DSL #
     #######
 
-    # Parse +find_node+ dsl, it creates {Synvert::Core::Rewriter::QueryScope} to recursively find matching ast nodes,
-    # then continue operating on each matching ast node.
-    # @example
-    #   # matches FactoryBot.create(:user)
-    #   find_node '.send[receiver=FactoryBot][message=create][arguments.size=1]' do
-    #   end
-    # @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(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,
     # then continue operating on each matching ast node.
     # @example
     #   # matches User.find_by_login('test')
     #   with_node type: 'send', message: /^find_by_/ do
     #   end
-    # @param rules [Hash] rules to find mathing ast nodes.
+    #   # matches FactoryBot.create(:user)
+    #   with_node '.send[receiver=FactoryBot][message=create][arguments.size=1]' do
+    #   end
+    # @param nql_or_rules [String|Hash] nql or rules to find mathing ast nodes.
     # @param options [Hash] optional
     # @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)
-      Rewriter::WithinScope.new(self, rules, options, &block).process
+    def within_node(nql_or_rules, options = {}, &block)
+      Rewriter::WithinScope.new(self, nql_or_rules, options, &block).process
+    rescue NodeQueryLexer::ScanError, Racc::ParseError => e
+      raise NodeQuery::Compiler::ParseError, "Invalid query string: #{nql_or_rules}"
     end
 
     alias with_node within_node
+    alias find_node within_node
 
     # Parse +goto_node+ dsl, it creates a {Synvert::Core::Rewriter::GotoScope} to go to a child node,
     # then continue operating on the child node.
@@ -140,10 +131,10 @@ module Synvert::Core
     #     if_exist_node type: 'send', message: 'any_instance' do
     #     end
     #   end
-    # @param rules [Hash] rules to check mathing ast nodes.
+    # @param nql_or_rules [String|Hash] nql or rules to check mathing ast nodes.
     # @param block [Block] block code to continue operating on the matching nodes.
-    def if_exist_node(rules, &block)
-      Rewriter::IfExistCondition.new(self, rules, &block).process
+    def if_exist_node(nql_or_rules, &block)
+      Rewriter::IfExistCondition.new(self, nql_or_rules, &block).process
     end
 
     # Parse +unless_exist_node+ dsl, it creates a {Synvert::Core::Rewriter::UnlessExistCondition} to check
@@ -154,14 +145,14 @@ module Synvert::Core
     #     unless_exist_node type: 'send', message: 'any_instance' do
     #     end
     #   end
-    # @param rules [Hash] rules to check mathing ast nodes.
+    # @param nql_or_rules [String|Hash] nql or rules to check mathing ast nodes.
     # @param block [Block] block code to continue operating on the matching nodes.
-    def unless_exist_node(rules, &block)
-      Rewriter::UnlessExistCondition.new(self, rules, &block).process
+    def unless_exist_node(nql_or_rules, &block)
+      Rewriter::UnlessExistCondition.new(self, nql_or_rules, &block).process
     end
 
     # Parse +if_only_exist_node+ dsl, it creates a {Synvert::Core::Rewriter::IfOnlyExistCondition} to check
-    # if current node has only one child node and the child node matches rules,
+    # if current node has only one child node and the child node matches,
     # if so, then continue operating on each matching ast node.
     # @example
     #   # it { should matcher }
@@ -169,14 +160,13 @@ module Synvert::Core
     #     if_only_exist_node type: 'send', receiver: nil, message: 'should' do
     #     end
     #   end
-    # @param rules [Hash] rules to check mathing ast nodes.
+    # @param nql_or_rules [String|Hash] nql or rules to check mathing ast nodes.
     # @param block [Block] block code to continue operating on the matching nodes.
-    def if_only_exist_node(rules, &block)
-      Rewriter::IfOnlyExistCondition.new(self, rules, &block).process
+    def if_only_exist_node(nql_or_rules, &block)
+      Rewriter::IfOnlyExistCondition.new(self, nql_or_rules, &block).process
     end
 
-    # Parse +append+ dsl, it creates a {Synvert::Core::Rewriter::AppendAction} to
-    # append the code to the bottom of current node body.
+    # Parse +append+ dsl, it appends the code to the bottom of current node body.
     # @example
     #   # def teardown
     #   #   clean_something
@@ -194,8 +184,7 @@ module Synvert::Core
       @current_mutation.append(@current_node, code)
     end
 
-    # Parse +prepend+ dsl, it creates a {Synvert::Core::Rewriter::PrependAction} to
-    # prepend the code to the top of current node body.
+    # Parse +prepend+ dsl, it prepends the code to the top of current node body.
     # @example
     #   # def setup
     #   #   do_something
@@ -213,7 +202,7 @@ module Synvert::Core
       @current_mutation.prepend(@current_node, code)
     end
 
-    # Parse +insert+ dsl, it creates a {Synvert::Core::Rewriter::InsertAction} to insert code.
+    # Parse +insert+ dsl, it inserts code.
     # @example
     #   # open('http://test.com')
     #   # =>
@@ -228,8 +217,7 @@ module Synvert::Core
       @current_mutation.insert(@current_node, code, at: at, to: to)
     end
 
-    # Parse +insert_after+ dsl, it creates a {Synvert::Core::Rewriter::InsertAfterAction} to
-    # insert the code next to the current node.
+    # Parse +insert_after+ dsl, it inserts the code next to the current node.
     # @example
     #   # Synvert::Application.config.secret_token = "0447aa931d42918bfb934750bb78257088fb671186b5d1b6f9fddf126fc8a14d34f1d045cefab3900751c3da121a8dd929aec9bafe975f1cabb48232b4002e4e"
     #   # =>
@@ -240,11 +228,26 @@ module Synvert::Core
     #   end
     # @param code [String] code need to be inserted.
     def insert_after(code)
-      @current_mutation.insert_after(@current_node, code)
+      column = ' ' * NodeMutation.adapter.get_start_loc(@current_node).column
+      @current_mutation.insert(@current_node, "\n#{column}#{code}", { at: 'end' })
     end
 
-    # Parse +replace_erb_stmt_with_expr+ dsl, it creates a {Synvert::Core::Rewriter::ReplaceErbStmtWithExprAction} to
-    # replace erb stmt code to expr code.
+    # Parse +insert_before+ dsl, it inserts the code previous to the current node.
+    # @example
+    #   # Synvert::Application.config.secret_token = "0447aa931d42918bfb934750bb78257088fb671186b5d1b6f9fddf126fc8a14d34f1d045cefab3900751c3da121a8dd929aec9bafe975f1cabb48232b4002e4e"
+    #   # =>
+    #   # Synvert::Application.config.secret_key_base = "bf4f3f46924ecd9adcb6515681c78144545bba454420973a274d7021ff946b8ef043a95ca1a15a9d1b75f9fbdf85d1a3afaf22f4e3c2f3f78e24a0a188b581df"
+    #   # Synvert::Application.config.secret_token = "0447aa931d42918bfb934750bb78257088fb671186b5d1b6f9fddf126fc8a14d34f1d045cefab3900751c3da121a8dd929aec9bafe975f1cabb48232b4002e4e"
+    #   with_node type: 'send', message: 'secret_token=' do
+    #     insert_before "{{receiver}}.secret_key_base = \"#{SecureRandom.hex(64)}\""
+    #   end
+    # @param code [String] code need to be inserted.
+    def insert_before(code)
+      column = ' ' * NodeMutation.adapter.get_start_loc(@current_node).column
+      @current_mutation.insert(@current_node, "#{code}\n#{column}", { at: 'beginning' })
+    end
+
+    # Parse +replace_erb_stmt_with_expr+ dsl, it replaces erb stmt code to expr code.
     # @example
     #   # <% form_for post do |f| %>
     #   # <% end %>
@@ -258,8 +261,7 @@ module Synvert::Core
       @current_mutation.actions << Rewriter::ReplaceErbStmtWithExprAction.new(@current_node).process
     end
 
-    # Parse +replace_with+ dsl, it creates a {Synvert::Core::Rewriter::ReplaceWithAction} to
-    # replace the whole code of current node.
+    # Parse +replace_with+ dsl, it replaces the whole code of current node.
     # @example
     #   # obj.stub(:foo => 1, :bar => 2)
     #   # =>
@@ -272,8 +274,7 @@ module Synvert::Core
       @current_mutation.replace_with(@current_node, code)
     end
 
-    # Parse +replace+ dsl, it creates a {Synvert::Core::Rewriter::ReplaceAction} to
-    # replace the code of specified child nodes.
+    # Parse +replace+ dsl, it replaces the code of specified child nodes.
     # @example
     #   # assert(object.empty?)
     #   # =>
@@ -288,7 +289,7 @@ module Synvert::Core
       @current_mutation.replace(@current_node, *selectors, with: with)
     end
 
-    # Parse +remove+ dsl, it creates a {Synvert::Core::Rewriter::RemoveAction} to remove current node.
+    # Parse +remove+ dsl, it removes current node.
     # @example
     #   with_node type: 'send', message: { in: %w[puts p] } do
     #     remove
@@ -299,7 +300,7 @@ module Synvert::Core
       @current_mutation.remove(@current_node, **options)
     end
 
-    # Parse +delete+ dsl, it creates a {Synvert::Core::Rewriter::DeleteAction} to delete child nodes.
+    # Parse +delete+ dsl, it deletes child nodes.
     # @example
     #   # FactoryBot.create(...)
     #   # =>
@@ -314,8 +315,7 @@ module Synvert::Core
       @current_mutation.delete(@current_node, *selectors, **options)
     end
 
-    # Parse +wrap+ dsl, it creates a {Synvert::Core::Rewriter::WrapAction} to
-    # wrap current node with code.
+    # Parse +wrap+ dsl, it wraps current node with code.
     # @example
     #   # class Foobar
     #   # end
@@ -434,16 +434,16 @@ module Synvert::Core
         only_paths.flat_map do |only_path|
           @file_patterns.flat_map do |file_pattern|
             pattern = only_path == "." ? file_pattern : File.join(only_path, file_pattern)
-            Dir.glob(pattern) - get_skip_files
+            Dir.glob(pattern)
           end
-        end
+        end - get_skip_files
       end
     end
 
     # Get skip files.
     # @return [Array<String>] skip files
     def get_skip_files
-      @skip_files ||= Configuration.skip_paths.flat_map do |skip_path|
+      Configuration.skip_paths.flat_map do |skip_path|
         if File.directory?(skip_path)
           Dir.glob(File.join(skip_path, "**/*"))
         elsif File.file?(skip_path)

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

@@ -1,22 +1,24 @@
 # frozen_string_literal: true
 
 module Synvert::Core
-  # WithinScope finds out nodes which match rules, then changes its scope to matching node.
+  # WithinScope finds out nodes which match nql or rules, then changes its scope to matching node.
   class Rewriter::WithinScope < Rewriter::Scope
     # Initialize a WithinScope.
     #
     # @param instance [Synvert::Core::Rewriter::Instance]
-    # @param rules [Hash]
+    # @param nql_or_rules [String|Hash]
     # @param options [Hash]
     # @yield run on all matching nodes
-    def initialize(instance, rules, options = {}, &block)
+    # @raise [Synvert::Core::NodeQuery::Compiler::ParseError] if the query string is invalid.
+    def initialize(instance, nql_or_rules, options = {}, &block)
       super(instance, &block)
 
       @options = { including_self: true, stop_at_first_match: false, recursive: true }.merge(options)
-      @node_query = NodeQuery.new(rules)
+      @node_query = NodeQuery.new(nql_or_rules)
     end
 
     # Find out the matching nodes.
+    #
     # It checks the current node and iterates all child nodes,
     # then run the block code on each matching node.
     def process

data/lib/synvert/core/rewriter.rb

@@ -17,7 +17,6 @@ module Synvert::Core
     autoload :Instance, 'synvert/core/rewriter/instance'
 
     autoload :Scope, 'synvert/core/rewriter/scope'
-    autoload :QueryScope, 'synvert/core/rewriter/scope/query_scope'
     autoload :WithinScope, 'synvert/core/rewriter/scope/within_scope'
     autoload :GotoScope, 'synvert/core/rewriter/scope/goto_scope'
 

data/lib/synvert/core/version.rb

@@ -2,6 +2,6 @@
 
 module Synvert
   module Core
-    VERSION = '1.11.0'
+    VERSION = '1.13.0'
   end
 end

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

@@ -12,7 +12,7 @@ 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::WithinScope).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
@@ -127,10 +127,19 @@ module Synvert::Core
     it 'parses insert_after' do
       instance.current_mutation = double
       instance.current_node = double
-      expect(instance.current_mutation).to receive(:insert_after).with(instance.current_node, 'Foobar')
+      expect(NodeMutation).to receive_message_chain(:adapter, :get_start_loc, :column).and_return(2)
+      expect(instance.current_mutation).to receive(:insert).with(instance.current_node, "\n  Foobar", at: 'end')
       instance.insert_after 'Foobar'
     end
 
+    it 'parses insert_before' do
+      instance.current_mutation = double
+      instance.current_node = double
+      expect(NodeMutation).to receive_message_chain(:adapter, :get_start_loc, :column).and_return(2)
+      expect(instance.current_mutation).to receive(:insert).with(instance.current_node, "Foobar\n  ", at: 'beginning')
+      instance.insert_before 'Foobar'
+    end
+
     it 'parses replace_erb_stmt_with_expr' do
       instance.current_mutation = double
       instance.current_node = double

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

@@ -23,72 +23,117 @@ module Synvert::Core
     before { instance.current_node = node }
 
     describe '#process' do
-      it 'not call block if no matching node' do
-        run = false
-        scope =
-          Rewriter::WithinScope.new instance, type: 'send', message: 'missing' do
-            run = true
-          end
-        scope.process
-        expect(run).to be_falsey
-      end
+      context 'rules' do
+        it 'not call block if no matching node' do
+          run = false
+          scope =
+            Rewriter::WithinScope.new instance, type: 'send', message: 'missing' do
+              run = true
+            end
+          scope.process
+          expect(run).to be_falsey
+        end
 
-      it 'call block if there is matching node' do
-        run = false
-        type_in_scope = nil
-        scope =
-          Rewriter::WithinScope.new instance,
-                                    type: 'send',
-                                    receiver: 'FactoryGirl',
-                                    message: 'create',
-                                    arguments: [':user'] do
-            run = true
-            type_in_scope = node.type
-          end
-        scope.process
-        expect(run).to be_truthy
-        expect(type_in_scope).to eq :send
-        expect(instance.current_node.type).to eq :block
-      end
+        it 'call block if there is matching node' do
+          run = false
+          type_in_scope = nil
+          scope =
+            Rewriter::WithinScope.new instance,
+                                      type: 'send',
+                                      receiver: 'FactoryGirl',
+                                      message: 'create',
+                                      arguments: [':user'] do
+              run = true
+              type_in_scope = node.type
+            end
+          scope.process
+          expect(run).to be_truthy
+          expect(type_in_scope).to eq :send
+          expect(instance.current_node.type).to eq :block
+        end
 
-      it 'matches multiple block nodes' do
-        block_nodes = []
-        scope =
-          Rewriter::WithinScope.new(instance, { type: 'block' }) do
-            block_nodes << node
-          end
-        scope.process
-        expect(block_nodes.size).to eq 3
-      end
+        it 'matches multiple block nodes' do
+          block_nodes = []
+          scope =
+            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 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 recursive is false' do
-        block_nodes = []
-        scope =
-          Rewriter::WithinScope.new(instance, { type: 'block' }, { recursive: false }) do
-            block_nodes << node
-          end
-        scope.process
-        expect(block_nodes.size).to eq 1
+        it 'matches only one block node if recursive is false' do
+          block_nodes = []
+          scope =
+            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 block node if stop_at_first_match is true' do
+          block_nodes = []
+          scope =
+            Rewriter::WithinScope.new(instance, { type: 'block' }, { stop_at_first_match: true }) do
+              block_nodes << node
+            end
+          scope.process
+          expect(block_nodes.size).to eq 1
+        end
       end
 
-      it 'matches only one block node if stop_at_first_match is true' do
-        block_nodes = []
-        scope =
-          Rewriter::WithinScope.new(instance, { type: 'block' }, { stop_at_first_match: true }) do
-            block_nodes << node
-          end
-        scope.process
-        expect(block_nodes.size).to eq 1
+      context 'nql' do
+        it 'not call block if no matching node' do
+          run = false
+          scope =
+            described_class.new instance, '.send[message=missing]' do
+              run = true
+            end
+          scope.process
+          expect(run).to be_falsey
+        end
+
+        it 'call block if there is matching node' do
+          run = false
+          type_in_scope = nil
+          scope =
+            described_class.new instance, '.send[receiver=FactoryGirl][message=create][arguments=(:user)]' do
+              run = true
+              type_in_scope = node.type
+            end
+          scope.process
+          expect(run).to be_truthy
+          expect(type_in_scope).to eq :send
+          expect(instance.current_node.type).to eq :block
+        end
+
+        it 'matches multiple block nodes' do
+          block_nodes = []
+          scope =
+            described_class.new(instance, '.block') do
+              block_nodes << node
+            end
+          scope.process
+          expect(block_nodes.size).to eq 3
+        end
+
+        it 'raises InvalidOperatorError' do
+          scope = described_class.new(instance, '.send[receiver IN FactoryGirl]') {}
+          expect {
+            scope.process
+          }.to raise_error(NodeQuery::Compiler::InvalidOperatorError)
+        end
       end
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: synvert-core
 version: !ruby/object:Gem::Version
-  version: 1.11.0
+  version: 1.13.0
 platform: ruby
 authors:
 - Richard Huang
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-10-11 00:00:00.000000000 Z
+date: 2022-10-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -144,7 +144,6 @@ files:
 - lib/synvert/core/rewriter/ruby_version.rb
 - lib/synvert/core/rewriter/scope.rb
 - lib/synvert/core/rewriter/scope/goto_scope.rb
-- lib/synvert/core/rewriter/scope/query_scope.rb
 - lib/synvert/core/rewriter/scope/within_scope.rb
 - lib/synvert/core/rewriter/warning.rb
 - lib/synvert/core/utils.rb
@@ -163,7 +162,6 @@ files:
 - spec/synvert/core/rewriter/instance_spec.rb
 - spec/synvert/core/rewriter/ruby_version_spec.rb
 - spec/synvert/core/rewriter/scope/goto_scope_spec.rb
-- spec/synvert/core/rewriter/scope/query_scope_spec.rb
 - spec/synvert/core/rewriter/scope/within_scope_spec.rb
 - spec/synvert/core/rewriter/scope_spec.rb
 - spec/synvert/core/rewriter/warning_spec.rb
@@ -208,7 +206,6 @@ test_files:
 - spec/synvert/core/rewriter/instance_spec.rb
 - spec/synvert/core/rewriter/ruby_version_spec.rb
 - spec/synvert/core/rewriter/scope/goto_scope_spec.rb
-- spec/synvert/core/rewriter/scope/query_scope_spec.rb
 - spec/synvert/core/rewriter/scope/within_scope_spec.rb
 - spec/synvert/core/rewriter/scope_spec.rb
 - spec/synvert/core/rewriter/warning_spec.rb

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

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-module Synvert::Core
-  # QueryScope finds out nodes by using node query language, then changes its scope to matching node.
-  class Rewriter::QueryScope < Rewriter::Scope
-    # Initialize a QueryScope.
-    #
-    # @param instance [Synvert::Core::Rewriter::Instance]
-    # @param nql [String]
-    # @param options [Hash]
-    # @yield run on all matching nodes
-    def initialize(instance, nql, options = {}, &block)
-      super(instance, &block)
-
-      @options = { including_self: true, stop_at_first_match: false, recursive: true }.merge(options)
-      @node_query = NodeQuery.new(nql)
-    end
-
-    # Find out the matching nodes.
-    #
-    # It checks the current node and iterates all child nodes,
-    # then run the block code on each matching node.
-    # @raise [Synvert::Core::NodeQuery::Compiler::ParseError] if the query string is invalid.
-    def process
-      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
-        matching_nodes.each do |node|
-          @instance.process_with_node(node) do
-            @instance.instance_eval(&@block)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,66 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-module Synvert::Core
-  describe Rewriter::QueryScope do
-    let(:instance) {
-      rewriter = Rewriter.new('foo', 'bar')
-      Rewriter::Instance.new(rewriter, 'file pattern')
-    }
-    let(:source) { <<~EOS }
-      describe Post do
-        it 'gets post' do
-          FactoryGirl.create :post
-        end
-      end
-    EOS
-
-    let(:node) { Parser::CurrentRuby.parse(source) }
-
-    before { instance.current_node = node }
-
-    describe '#process' do
-      it 'not call block if no matching node' do
-        run = false
-        scope =
-          described_class.new instance, '.send[message=missing]' do
-            run = true
-          end
-        scope.process
-        expect(run).to be_falsey
-      end
-
-      it 'call block if there is matching node' do
-        run = false
-        type_in_scope = nil
-        scope =
-          described_class.new instance, '.send[receiver=FactoryGirl][message=create][arguments=(:post)]' do
-            run = true
-            type_in_scope = node.type
-          end
-        scope.process
-        expect(run).to be_truthy
-        expect(type_in_scope).to eq :send
-        expect(instance.current_node.type).to eq :block
-      end
-
-      it 'matches multiple block nodes' do
-        block_nodes = []
-        scope =
-          described_class.new(instance, '.block') do
-            block_nodes << node
-          end
-        scope.process
-        expect(block_nodes.size).to eq 2
-      end
-
-      it 'raises InvalidOperatorError' do
-        scope = described_class.new(instance, '.send[receiver IN FactoryGirl]') {}
-        expect {
-          scope.process
-        }.to raise_error(NodeQuery::Compiler::InvalidOperatorError)
-      end
-    end
-  end
-end