synvert-core 1.5.0 → 1.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 71ae91a324677995dbfd9b1251ebf2a0a01e7c25289dcebcf86abb07599b1db8
-  data.tar.gz: 4370235d14aee70f57b6b02313637e9d24b13ca2aee61b71e4fa4022f78bc3f8
+  metadata.gz: 4e0e8e77a7f85aa23300c28aaf44fca1d6b0a7ffad9177bc9925cfd7541f4e65
+  data.tar.gz: eb1b9267dbf8264a9c5978dd019dc0c26fcc6613cf0413b767c8fdf4c763cb00
 SHA512:
-  metadata.gz: 8bcd68a69575a6cd5c5c0bc7a91f82d09d2f438ab06988c01ad14c7d97c863bc2556f5c3ad7d054e35cfcb830cb778ec10a9797952a56a9391062b4bf3ce2a3f
-  data.tar.gz: be7b4c9fda8428c0d2a8c29350f6d2c60c40577c0f990ed5d8f4d2742fc2545fc8ddbd139298aaf39a9e69e9e9bf83fe29385745ac7ef10459da836572df9327
+  metadata.gz: 26a85edf49b07f5afc0688152bf63bf65966e72f15d58da615b8e4b6575e28a74978113a9dbbed78f0cf076e0d0a5d54d486ef83af6a46a0ce7e1b69547b33c1
+  data.tar.gz: 21bb822480bd6ea79725d27eabb48c3306da71dec81fb817c8d94027b7457e5ae1ed3d78d9d5d870c103f173e2a3bc00e8b45273c66bbd4dfcb259e2ada254bc

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,16 @@
 # CHANGELOG
 
+## 1.7.0 (2022-09-16)
+
+* Add `Rewriter#test`
+* Use option `run_instance` instead of `sandbox`
+
+## 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

@@ -5,6 +5,8 @@ source 'https://rubygems.org'
 # Specify your gem's dependencies in synvert.gemspec
 gemspec
 
+require 'pp' # https://github.com/defunkt/fakefs/issues/99
+gem "fakefs", require: "fakefs/safe"
 gem "guard"
 gem "guard-rspec"
 gem "rake"

data/Gemfile.lock

@@ -0,0 +1,103 @@
+PATH
+  remote: .
+  specs:
+    synvert-core (1.7.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)
+    fakefs (1.8.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.3.3)
+      activesupport (< 7.0.0)
+      erubis
+    node_query (1.6.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
+  fakefs
+  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

@@ -30,7 +30,7 @@ module Synvert::Core
 
     # Process the instance.
     # It finds specified files, for each file, it executes the block code, rewrites the original code,
-    # then write the code back to the original file.
+    # then writes the code back to the original file.
     def process
       @file_patterns.each do |file_pattern|
         Dir.glob(File.join(Configuration.path, file_pattern)).each do |file_path|
@@ -41,6 +41,21 @@ module Synvert::Core
       end
     end
 
+    # Test the instance.
+    # It finds specified files, for each file, it executes the block code, tests the original code,
+    # then returns the actions.
+    def test
+      paths = @file_patterns.flat_map do |file_pattern|
+        Dir.glob(File.join(Configuration.path, file_pattern))
+      end
+
+      paths.uniq.map do |file_path|
+        next if Configuration.skip_files.include?(file_path)
+
+        test_file(file_path)
+      end
+    end
+
     # Gets current node, it allows to get current node in block code.
     #
     # @return [Parser::AST::Node]
@@ -79,11 +94,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 +111,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
 
@@ -377,6 +393,37 @@ module Synvert::Core
       end
     end
 
+    # Test one file.
+    #
+    # @param file_path [String]
+    def test_file(file_path)
+      @current_file = file_path
+      source = read_source(file_path)
+      @current_mutation = NodeMutation.new(source)
+      begin
+        node = parse_code(file_path, source)
+
+        process_with_node(node) do
+          instance_eval(&@block)
+        rescue NoMethodError => e
+          puts [
+            "error: #{e.message}",
+            "file: #{file_path}",
+            "source: #{source}",
+            "line: #{current_node.line}"
+          ].join("\n")
+          raise
+        end
+
+        result = @current_mutation.test
+        result.file_path = file_path
+        result
+      rescue Parser::SyntaxError
+        puts "[Warn] file #{file_path} was not parsed correctly."
+        # do nothing, iterate next file
+      end
+    end
+
     # Read file source.
     # @param file_path [String] file path
     # @return [String] file source

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/rewriter.rb

@@ -72,15 +72,16 @@ module Synvert::Core
       #
       # @param group [String] the rewriter group.
       # @param name [String] the rewriter name.
-      # @param sandbox [Boolean] if run in sandbox mode.
+      # @param options [Hash]
+      # @option options [Boolean] :run_instance (true) process the instance.
       # @return [Synvert::Core::Rewriter] the registered rewriter.
       # @raise [Synvert::Core::RewriterNotFound] if the registered rewriter is not found.
-      def call(group, name, sandbox = false)
+      def call(group, name, options = {})
         rewriter = fetch(group, name)
-        if sandbox
-          rewriter.process_with_sandbox
-        else
+        if options[:run_instance]
           rewriter.process
+        else
+          rewriter.process_with_sandbox
         end
         rewriter
       end
@@ -137,6 +138,8 @@ module Synvert::Core
       @warnings = []
       @affected_files = Set.new
       @redo_until_no_change = false
+      @options = { run_instance: true, write_to_file: true }
+      @test_results = []
       self.class.register(@group, @name, self)
     end
 
@@ -152,14 +155,29 @@ module Synvert::Core
     # Process rewriter with sandbox mode.
     # It will call the block but doesn't change any file.
     def process_with_sandbox
-      @sandbox = true
+      @options[:run_instance] = false
       begin
         process
       ensure
-        @sandbox = false
+        @options[:run_instance] = true
       end
     end
 
+    def test
+      @options[:write_to_file] = false
+      begin
+        @affected_files = Set.new
+        instance_eval(&@block)
+
+        if !@affected_files.empty? && @redo_until_no_change # redo
+          test
+        end
+      ensure
+        @options[:write_to_file] = true
+      end
+      @test_results
+    end
+
     # Add a warning.
     #
     # @param warning [Synvert::Core::Rewriter::Warning]
@@ -225,12 +243,18 @@ module Synvert::Core
     # @param file_patterns [String|Array<String>] string pattern or list of string pattern to find files, e.g. ['spec/**/*_spec.rb']
     # @param block [Block] the block to rewrite code in the matching files.
     def within_files(file_patterns, &block)
-      return if @sandbox
+      return unless @options[:run_instance]
 
       return if @ruby_version && !@ruby_version.match?
       return if @gem_spec && !@gem_spec.match?
 
-      Rewriter::Instance.new(self, Array(file_patterns), &block).process
+      instance = Rewriter::Instance.new(self, Array(file_patterns), &block)
+      if @options[:write_to_file]
+        instance.process
+      else
+        results = instance.test
+        @test_results += results.select { |result| result.affected? }
+      end
     end
 
     # Parse +within_file+ dsl, it finds a specifiled file.
@@ -248,7 +272,7 @@ module Synvert::Core
     # @param filename [String] file name of newly created file.
     # @param content [String] file body of newly created file.
     def add_file(filename, content)
-      return if @sandbox
+      return unless @options[:run_instance]
 
       filepath = File.join(Configuration.path, filename)
       if File.exist?(filepath)
@@ -267,7 +291,7 @@ module Synvert::Core
     #   end
     # @param filename [String] file name.
     def remove_file(filename)
-      return if @sandbox
+      return unless @options[:run_instance]
 
       file_path = File.join(Configuration.path, filename)
       File.delete(file_path) if File.exist?(file_path)
@@ -293,7 +317,7 @@ module Synvert::Core
     # @param group [String] group of another rewriter.
     # @param name [String] name of another rewriter.
     def add_snippet(group, name)
-      @sub_snippets << self.class.call(group.to_s, name.to_s, @sandbox)
+      @sub_snippets << self.class.call(group.to_s, name.to_s, @options)
     end
 
     # Parse +helper_method+ dsl, it defines helper method for {Synvert::Core::Rewriter::Instance}.

data/lib/synvert/core/version.rb

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

data/spec/spec_helper.rb

@@ -3,6 +3,7 @@
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 
 require 'synvert/core'
+require 'fakefs/spec_helpers'
 
 Dir[File.join(File.dirname(__FILE__), 'support', '*')].each do |path|
   require path
@@ -10,6 +11,7 @@ end
 
 RSpec.configure do |config|
   config.include ParserHelper
+  config.include FakeFS::SpecHelpers, fakefs: true
 
   config.run_all_when_everything_filtered = true
   config.filter_run :focus

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
+    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: true, direct: false }, &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' }, { stop_when_match: true }, &block)
-    end
-
-    it 'parses within_node with direct 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)
-        .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
@@ -266,6 +267,55 @@ module Synvert::Core
       end
     end
 
+    describe '#test' do
+      let(:rewriter) { Rewriter.new('foo', 'bar') }
+
+      it 'writes new code to file' do
+        instance =
+          Rewriter::Instance.new rewriter, ['spec/**/*_spec.rb'] do
+            with_node type: 'send', receiver: 'FactoryGirl', message: 'create' do
+              replace_with 'create {{arguments}}'
+            end
+          end
+        input = <<~EOS
+          it 'uses factory_girl' do
+            user = FactoryGirl.create :user
+            post = FactoryGirl.create :post, user: user
+            assert post.valid?
+          end
+        EOS
+        expect(Dir).to receive(:glob).with('./spec/**/*_spec.rb').and_return(['spec/models/post_spec.rb'])
+        expect(File).to receive(:read).with('spec/models/post_spec.rb', encoding: 'UTF-8').and_return(input)
+        results = instance.test
+        expect(results[0].file_path).to eq 'spec/models/post_spec.rb'
+        expect(results[0].actions).to eq [
+          OpenStruct.new(start: 35, end: 59, new_code: 'create :user'),
+          OpenStruct.new(start: 69, end: 105, new_code: 'create :post, user: user')
+        ]
+      end
+
+      it 'does not write if file content is not changed' do
+        instance =
+          Rewriter::Instance.new rewriter, ['spec/spec_helper.rb'] do
+            with_node type: 'block', caller: { receiver: 'RSpec', message: 'configure' } do
+              unless_exist_node type: 'send', message: 'include', arguments: ['FactoryGirl::Syntax::Methods'] do
+                insert '{{arguments.first}}.include FactoryGirl::Syntax::Methods'
+              end
+            end
+          end
+        input = <<~EOS
+          RSpec.configure do |config|
+            config.include FactoryGirl::Syntax::Methods
+          end
+        EOS
+        expect(Dir).to receive(:glob).with('./spec/spec_helper.rb').and_return(['spec/spec_helper.rb'])
+        expect(File).to receive(:read).with('spec/spec_helper.rb', encoding: 'UTF-8').and_return(input)
+        result = instance.test
+        expect(result[0].file_path).to eq 'spec/spec_helper.rb'
+        expect(result[0].actions).to eq []
+      end
+    end
+
     describe '#process_with_node' do
       it 'resets current_node' do
         node1 = double

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/spec/synvert/core/rewriter_spec.rb

@@ -37,6 +37,46 @@ module Synvert::Core
       rewriter.process
     end
 
+    describe '#process' do
+      it 'rewrites the file' do
+        rewriter = Rewriter.new('group', 'name') do
+          within_files '**/*.rb' do
+            with_node node_type: 'class', name: 'Foobar' do
+              replace :name, with: 'Synvert'
+            end
+          end
+        end
+        input = "class Foobar\nend"
+        output = "class Synvert\nend"
+        FakeFS do
+          File.write("code.rb", input)
+          rewriter.process
+          expect(File.read("code.rb")).to eq output
+        end
+      end
+    end
+
+    describe '#test' do
+      it 'gets test results' do
+        rewriter = Rewriter.new('group', 'name') do
+          within_files '**/*.rb' do
+            with_node node_type: 'class', name: 'Foobar' do
+              replace :name, with: 'Synvert'
+            end
+          end
+        end
+        input = "class Foobar\nend"
+        FakeFS do
+          File.write("code.rb", input)
+          results = rewriter.test
+          expect(results[0].file_path).to eq '/code.rb'
+          expect(results[0].affected?).to be_truthy
+          expect(results[0].conflicted?).to be_falsey
+          expect(results[0].actions).to eq [OpenStruct.new(start: 6, end: 12, new_code: 'Synvert')]
+        end
+      end
+    end
+
     describe 'parses within_file' do
       it 'does nothing if if_ruby does not match' do
         expect(File).to receive(:exist?).with('./.ruby-version').and_return(true)
@@ -245,7 +285,7 @@ module Synvert::Core
       it 'registers and calls rewriter in sandbox mode' do
         rewriter = Rewriter.new 'group', 'rewriter'
         expect(rewriter).to receive(:process_with_sandbox)
-        Rewriter.call 'group', 'rewriter', true
+        Rewriter.call 'group', 'rewriter', run_instance: false
       end
 
       it 'raises RewriterNotFound if rewriter not found' do

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.7.0
 platform: ruby
 authors:
 - Richard Huang
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-07-02 00:00:00.000000000 Z
+date: 2022-09-16 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