synvert-core 1.11.0 → 1.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0663ba61695ae5b47f27e9a23f1edbfe31d3746f9b3e02a79315a827fae6f36c
-  data.tar.gz: 8199c6c8a122555bfbf0df0ef79f6bd96ade0cdfe472d81d6abe4cccde3b6c59
+  metadata.gz: e526dbe6f12418da40df7cb5b945f7ed957820573455b575f2a609c334b58e72
+  data.tar.gz: 1f22528b636b548c9ddb05466d366e62dce813794d173c11b8de11ef522b97a8
 SHA512:
-  metadata.gz: 3609b9bdb845681c9dd71d9d0eca4985d43203ce28fb1e874e9538322f8205995d77f5b8c2b43fb11caf698a69772c3e7bdd5114a709e4513313339870576a5e
-  data.tar.gz: 952578268a2c8cba6dcd2883141fe5977917594ea01b76e51e93032fc71225c813b9021ec1852c3a93d76f6438f30f9975ac47b36c5da3d7c5805fa15763fa9e
+  metadata.gz: 46f29de95717e764a33c0303c20086fb3fc3dcc43c7548c174b4eb46f368e2b0cec6b1ea6ff88eed04654f58cf9dad3066aa679ece8d7a6cfb2a7676095fe4aa
+  data.tar.gz: 7622e84c396751bd49b57464424efee84ba3f45d727c5653528fb11a5da7d26e856c0008ea1dc5967e7ee3afe8f238a8dbb6c67bc5071970312523a426a98dd3

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 # CHANGELOG
 
+## 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.12.0)
       activesupport (< 7.0.0)
       erubis
       node_mutation

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:
 

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,10 +160,10 @@ 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
@@ -434,16 +425,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.12.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

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.12.0
 platform: ruby
 authors:
 - Richard Huang
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-10-11 00:00:00.000000000 Z
+date: 2022-10-14 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