synvert-core 1.4.0 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 741ca9c2f6f29e5bbafbc5b63d94b3cd9a56aa20e8a00f3f70830b73b1fb697e
-  data.tar.gz: a8bbf6e0c48a4af42578abb20807f3d86359fc069dc85ff90e12cf011f076998
+  metadata.gz: 71ae91a324677995dbfd9b1251ebf2a0a01e7c25289dcebcf86abb07599b1db8
+  data.tar.gz: 4370235d14aee70f57b6b02313637e9d24b13ca2aee61b71e4fa4022f78bc3f8
 SHA512:
-  metadata.gz: 7fcadf632c863b1f3ba410b65f63c741b594255567f337ebc86c51ae45e681484653b45eec01fc5c3e3a4ea170a6bd38e899bdf22f65b2e980d58cac8c11cfcd
-  data.tar.gz: 80ebe8f07ef9679c6921233d52b46979a6bfb895e4b63b974672dec193ef52ce08c40454d2a92fd509f12b8f3567065bb7d2dbee33af7bca37a96246e6373381
+  metadata.gz: 8bcd68a69575a6cd5c5c0bc7a91f82d09d2f438ab06988c01ad14c7d97c863bc2556f5c3ad7d054e35cfcb830cb778ec10a9797952a56a9391062b4bf3ce2a3f
+  data.tar.gz: be7b4c9fda8428c0d2a8c29350f6d2c60c40577c0f990ed5d8f4d2742fc2545fc8ddbd139298aaf39a9e69e9e9bf83fe29385745ac7ef10459da836572df9327

data/.gitignore

@@ -15,7 +15,3 @@ spec/reports
 test/tmp
 test/version_tmp
 tmp
-
-lib/synvert/core/node_query/lexer.rex.rb
-lib/synvert/core/node_query/parser.racc.rb
-lib/synvert/core/node_query/parser.output

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 # CHANGELOG
 
+## 1.5.0 (2022-07-02)
+
+* Abstract `node_query`
+* Abstract `node_mutation`
+* Abstract `parser_node_ext`
+
 ## 1.4.0 (2022-05-21)
 
 * Drop support `:first-child` and `:last-child`

data/Gemfile

@@ -7,9 +7,6 @@ gemspec
 
 gem "guard"
 gem "guard-rspec"
-gem "guard-rake"
-gem "oedipus_lex"
-gem "racc"
 gem "rake"
 gem "rspec"
 gem "rspec-mocks"

data/Guardfile

@@ -3,14 +3,5 @@
 guard :rspec, cmd: 'bundle exec rspec' do
   watch(%r{^spec/.+_spec\.rb$})
   watch(%r{^lib/(.+)\.rb$}) { |m| "spec/#{m[1]}_spec.rb" }
-  watch('lib/synvert/core/node_query/lexer.rex.rb') { 'spec/synvert/core/node_query/lexer_spec.rb'  }
-  watch('lib/synvert/core/node_query/compiler.rb') { 'spec/synvert/core/node_query/parser_spec.rb'  }
-  watch(%r{^lib/synvert/core/node_query/compiler/.*\.rb$}) { 'spec/synvert/core/node_query/parser_spec.rb' }
-  watch('lib/synvert/core/node_query/parser.racc.rb') { 'spec/synvert/core/node_query/parser_spec.rb' }
   watch('spec/spec_helper.rb') { "spec" }
 end
-
-guard :rake, task: 'generate' do
-  watch('lib/synvert/core/node_query/lexer.rex')
-  watch('lib/synvert/core/node_query/parser.y')
-end

data/README.md

@@ -8,29 +8,46 @@
 Synvert core provides a set of DSLs to rewrite ruby code. e.g.
 
 ```ruby
-Synvert::Rewriter.new 'ruby', 'map_and_flatten_to_flat_map' do
+Synvert::Rewriter.new 'factory_bot', 'convert_factory_girl_to_factory_bot' do
   description <<~EOS
-    It converts `map` and `flatten` to `flat_map`
+    It converts FactoryGirl to FactoryBot
 
     ```ruby
-    enum.map do
-      # do something
-    end.flatten
+    require 'factory_girl'
+    require 'factory_girl_rails'
     ```
 
     =>
 
     ```ruby
-    enum.flat_map do
-      # do something
-    end
+    require 'factory_bot'
+    require 'factory_bot_rails'
+    ```
+
+    ```ruby
+    FactoryGirl.create(:user)
+    FactoryGirl.build(:user)
+    ```
+
+    =>
+
+    ```ruby
+    FactoryBot.create(:user)
+    FactoryBot.build(:user)
     ```
   EOS
 
-  within_files Synvert::ALL_RUBY_FILES do
-    with_node type: 'send', receiver: { type: 'block', caller: { type: 'send', message: 'map' } }, message: 'flatten', arguments: { size: 0 } do
-      delete :message, :dot
-      replace 'receiver.caller.message', with: 'flat_map'
+  within_files Synvert::RAILS_TEST_FILES do
+    find_node '.const[name=FactoryGirl]' do
+      replace_with 'FactoryBot'
+    end
+
+    find_node ".send[receiver=nil][message=require][arguments.size=1][arguments.first='factory_girl']" do
+      replace :arguments, with: "'factory_bot'"
+    end
+
+    with_node type: 'send', receiver: nil, message: 'require', arguments: { size: 1, first: "'factory_girl_rails'" } do
+      replace :arguments, with: "'factory_bot_rails'"
     end
   end
 end
@@ -56,6 +73,7 @@ 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
 * [goto_node](./Synvert/Core/Rewriter/Instance.html#goto_node-instance_method) - go to a child node

data/Rakefile

@@ -2,21 +2,7 @@
 
 require "bundler/gem_tasks"
 require 'rspec/core/rake_task'
-RSpec::Core::RakeTask.new(:spec)
-require 'oedipus_lex'
-Rake.application.rake_require "oedipus_lex"
-
-file "lib/synvert/core/node_query/lexer.rex.rb" => "lib/synvert/core/node_query/lexer.rex"
-file "lib/synvert/core/node_query/parser.racc.rb" => "lib/synvert/core/node_query/parser.y"
 
-task :lexer  => "lib/synvert/core/node_query/lexer.rex.rb"
-task :parser => "lib/synvert/core/node_query/parser.racc.rb"
-task :generate  => [:lexer, :parser]
-
-rule '.racc.rb' => '.y' do |t|
-  cmd = "bundle exec racc -l -v -o #{t.name} #{t.source}"
-  sh cmd
-end
+RSpec::Core::RakeTask.new(:spec)
 
 task :default => :spec
-task :spec => :generate

data/lib/synvert/core/engine/erb.rb

@@ -7,7 +7,7 @@ module Synvert::Core
     ERUBY_EXPR_SPLITTER = ';  ;'
     ERUBY_STMT_SPLITTER = ';   ;'
 
-    class ERB
+    class Erb
       class << self
         # convert erb to ruby code.
         #

data/lib/synvert/core/engine.rb

@@ -3,6 +3,6 @@
 module Synvert::Core
   # Engine defines how to encode / decode other files (like erb).
   module Engine
-    autoload :ERB, 'synvert/core/engine/erb'
+    autoload :Erb, 'synvert/core/engine/erb'
   end
 end

data/lib/synvert/core/node_ext.rb

@@ -29,311 +29,6 @@ module Parser::AST
   # Source Code to Ast Node
   # {https://synvert-playground.xinminlabs.com/ruby}
   class Node
-    TYPE_CHILDREN = {
-      and: %i[left_value right_value],
-      arg: %i[name],
-      begin: %i[body],
-      block: %i[caller arguments body],
-      blockarg: %i[name],
-      const: %i[parent_const name],
-      class: %i[name parent_class body],
-      csend: %i[receiver message arguments],
-      cvasgn: %i[left_value right_value],
-      cvar: %i[name],
-      def: %i[name arguments body],
-      definded?: %i[arguments],
-      defs: %i[self name arguments body],
-      hash: %i[pairs],
-      ivasgn: %i[left_value right_value],
-      ivar: %i[name],
-      lvar: %i[name],
-      lvasgn: %i[left_value right_value],
-      masgn: %i[left_value right_value],
-      module: %i[name body],
-      or: %i[left_value right_value],
-      or_asgn: %i[left_value right_value],
-      pair: %i[key value],
-      restarg: %i[name],
-      send: %i[receiver message arguments],
-      super: %i[arguments],
-      zsuper: %i[]
-    }
-
-    # Initialize a Node.
-    #
-    # It extends {Parser::AST::Node} and set parent for its child nodes.
-    def initialize(type, children = [], properties = {})
-      @mutable_attributes = {}
-      super
-      # children could be nil for s(:array)
-      Array(children).each do |child_node|
-        if child_node.is_a?(Parser::AST::Node)
-          child_node.parent = self
-        end
-      end
-    end
-
-    # Get the parent node.
-    # @return [Parser::AST::Node] parent node.
-    def parent
-      @mutable_attributes[:parent]
-    end
-
-    # Set the parent node.
-    # @param node [Parser::AST::Node] parent node.
-    def parent=(node)
-      @mutable_attributes[:parent] = node
-    end
-
-    # Get the sibling nodes.
-    # @return [Array<Parser::AST::Node>] sibling nodes.
-    def siblings
-      index = parent.children.index(self)
-      parent.children[index + 1..]
-    end
-
-    # Dyamically defined method
-    # caller, key, left_value, message, name, pairs, parent_class, parent_const, receivr, rgith_value and value.
-    # based on const TYPE_CHILDREN.
-    %i[
-      caller
-      key
-      left_value
-      message
-      name
-      pairs
-      parent_class
-      parent_const
-      receiver
-      right_value
-      value
-    ].each do |method_name|
-      define_method(method_name) do
-        index = TYPE_CHILDREN[type]&.index(method_name)
-        return children[index] if index
-
-        raise Synvert::Core::MethodNotSupported, "#{method_name} is not handled for #{debug_info}"
-      end
-    end
-
-    # Return the left value of node.
-    # It supports :and, :cvagn, :lvasgn, :masgn, :or and :or_asgn nodes.
-    # @example
-    #   node # s(:or_asgn, s(:lvasgn, :a), s(:int, 1))
-    #   node.left_value # :a
-    # @return [Parser::AST::Node] left value of node.
-    # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
-    def left_value
-      return children[0].children[0] if type == :or_asgn
-
-      index = TYPE_CHILDREN[type]&.index(:left_value)
-      return children[index] if index
-
-      raise Synvert::Core::MethodNotSupported, "#{left_value} is not handled for #{debug_info}"
-    end
-
-    # Get arguments of node.
-    # It supports :block, :csend, :def, :defined?, :defs and :send nodes.
-    # @example
-    #   node # s(:send, s(:const, nil, :FactoryGirl), :create, s(:sym, :post), s(:hash, s(:pair, s(:sym, :title), s(:str, "post"))))
-    #   node.arguments # [s(:sym, :post), s(:hash, s(:pair, s(:sym, :title), s(:str, "post")))]
-    # @return [Array<Parser::AST::Node>] arguments of node.
-    # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
-    def arguments
-      case type
-      when :def, :block
-        children[1].children
-      when :defs
-        children[2].children
-      when :send, :csend
-        children[2..-1]
-      when :defined?
-        children
-      else
-        raise Synvert::Core::MethodNotSupported, "arguments is not handled for #{debug_info}"
-      end
-    end
-
-    # Get body of node.
-    # It supports :begin, :block, :class, :def, :defs and :module node.
-    # @example
-    #   node # s(:block, s(:send, s(:const, nil, :RSpec), :configure), s(:args, s(:arg, :config)), s(:send, nil, :include, s(:const, s(:const, nil, :EmailSpec), :Helpers)))
-    #   node.body # [s(:send, nil, :include, s(:const, s(:const, nil, :EmailSpec), :Helpers))]
-    # @return [Array<Parser::AST::Node>] body of node.
-    # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
-    def body
-      case type
-      when :begin
-        children
-      when :def, :block, :class, :module
-        return [] if children[2].nil?
-
-        :begin == children[2].type ? children[2].body : children[2..-1]
-      when :defs
-        return [] if children[3].nil?
-
-        :begin == children[3].type ? children[3].body : children[3..-1]
-      else
-        raise Synvert::Core::MethodNotSupported, "body is not handled for #{debug_info}"
-      end
-    end
-
-    # Get condition of node.
-    # It supports :if node.
-    # @example
-    #   node # s(:if, s(:defined?, s(:const, nil, :Bundler)), nil, nil)
-    #   node.condition # s(:defined?, s(:const, nil, :Bundler))
-    # @return [Parser::AST::Node] condition of node.
-    # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
-    def condition
-      if :if == type
-        children[0]
-      else
-        raise Synvert::Core::MethodNotSupported, "condition is not handled for #{debug_info}"
-      end
-    end
-
-    # Get keys of :hash node.
-    # @example
-    #   node # s(:hash, s(:pair, s(:sym, :foo), s(:sym, :bar)), s(:pair, s(:str, "foo"), s(:str, "bar")))
-    #   node.keys # [s(:sym, :foo), s(:str, "foo")]
-    # @return [Array<Parser::AST::Node>] keys of node.
-    # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
-    def keys
-      if :hash == type
-        children.map { |child| child.children[0] }
-      else
-        raise Synvert::Core::MethodNotSupported, "keys is not handled for #{debug_info}"
-      end
-    end
-
-    # Get values of :hash node.
-    # @example
-    #   node # s(:hash, s(:pair, s(:sym, :foo), s(:sym, :bar)), s(:pair, s(:str, "foo"), s(:str, "bar")))
-    #   node.values # [s(:sym, :bar), s(:str, "bar")]
-    # @return [Array<Parser::AST::Node>] values of node.
-    # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
-    def values
-      if :hash == type
-        children.map { |child| child.children[1] }
-      else
-        raise Synvert::Core::MethodNotSupported, "keys is not handled for #{debug_info}"
-      end
-    end
-
-    # Check if :hash node contains specified key.
-    # @example
-    #   node # s(:hash, s(:pair, s(:sym, :foo), s(:sym, :bar)))
-    #   node.key?(:foo) # true
-    # @param [Symbol, String] key value.
-    # @return [Boolean] true if specified key exists.
-    # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
-    def key?(key)
-      if :hash == type
-        children.any? { |pair_node| pair_node.key.to_value == key }
-      else
-        raise Synvert::Core::MethodNotSupported, "key? is not handled for #{debug_info}"
-      end
-    end
-
-    # Get :hash value node according to specified key.
-    # @example
-    #   node # s(:hash, s(:pair, s(:sym, :foo), s(:sym, :bar)))
-    #   node.hash_value(:foo) # s(:sym, :bar)
-    # @param [Symbol, String] key value.
-    # @return [Parser::AST::Node] hash value of node.
-    # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
-    def hash_value(key)
-      if :hash == type
-        value_node = children.find { |pair_node| pair_node.key.to_value == key }
-        value_node&.value
-      else
-        raise Synvert::Core::MethodNotSupported, "hash_value is not handled for #{debug_info}"
-      end
-    end
-
-    # Return the exact value of node.
-    # It supports :array, :begin, :erange, :false, :float, :irange, :int, :str, :sym and :true nodes.
-    # @example
-    #   node # s(:array, s(:str, "str"), s(:sym, :str))
-    #   node.to_value # ['str', :str]
-    # @return [Object] exact value.
-    # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
-    def to_value
-      case type
-      when :int, :float, :str, :sym
-        children.last
-      when :true
-        true
-      when :false
-        false
-      when :nil
-        nil
-      when :array
-        children.map(&:to_value)
-      when :irange
-        (children.first.to_value..children.last.to_value)
-      when :erange
-        (children.first.to_value...children.last.to_value)
-      when :begin
-        children.first.to_value
-      else
-        self
-      end
-    end
-
-    # Respond key value and source for hash node, e.g.
-    # @example
-    #   node # s(:hash, s(:pair, s(:sym, :foo), s(:sym, :bar)))
-    #   node.foo_value # :bar
-    #   node.foo_source # ":bar"
-    def method_missing(method_name, *args, &block)
-      if :args == type && children.respond_to?(method_name)
-        return children.send(method_name, *args, &block)
-      elsif :hash == type && method_name.to_s.include?('_value')
-        key = method_name.to_s.sub('_value', '')
-        return hash_value(key.to_sym)&.to_value if key?(key.to_sym)
-        return hash_value(key.to_s)&.to_value if key?(key.to_s)
-
-        return nil
-      elsif :hash == type && method_name.to_s.include?('_source')
-        key = method_name.to_s.sub('_source', '')
-        return hash_value(key.to_sym)&.to_source if key?(key.to_sym)
-        return hash_value(key.to_s)&.to_source if key?(key.to_s)
-
-        return nil
-      end
-
-      super
-    end
-
-    def respond_to_missing?(method_name, *args)
-      if :args == type && children.respond_to?(method_name)
-        return true
-      elsif :hash == type && method_name.to_s.include?('_value')
-        key = method_name.to_s.sub('_value', '')
-        return true if key?(key.to_sym) || key?(key.to_s)
-      elsif :hash == type && method_name.to_s.include?('_source')
-        key = method_name.to_s.sub('_source', '')
-        return true if key?(key.to_sym) || key?(key.to_s)
-      end
-
-      super
-    end
-
-    # Return the debug info.
-    #
-    # @return [String] file, line, source and node.
-    def debug_info
-      "\n" +
-        [
-          "file: #{loc.expression.source_buffer.name}",
-          "line: #{loc.expression.line}",
-          "source: #{to_source}",
-          "node: #{inspect}"
-        ].join("\n")
-    end
-
     # Get the file name of node.
     #
     # @return [String] file name.
@@ -341,13 +36,6 @@ module Parser::AST
       loc.expression&.source_buffer.name
     end
 
-    # Get the source code of node.
-    #
-    # @return [String] source code.
-    def to_source
-      loc.expression&.source
-    end
-
     # Get the column of node.
     #
     # @return [Integer] column.
@@ -362,113 +50,6 @@ module Parser::AST
       loc.expression.line
     end
 
-    # Get child node by the name.
-    #
-    # @param child_name [String] name of child node.
-    # @return [Parser::AST::Node] the child node.
-    def child_node_by_name(child_name)
-      direct_child_name, nested_child_name = child_name.to_s.split('.', 2)
-      if respond_to?(direct_child_name)
-        child_node = send(direct_child_name)
-
-        return child_node.child_node_by_name(nested_child_name) if nested_child_name
-
-        return nil if child_node.nil?
-
-        return child_node if child_node.is_a?(Parser::AST::Node)
-
-        return child_node
-      end
-
-      raise Synvert::Core::MethodNotSupported,
-            "child_node_by_name is not handled for #{debug_info}, child_name: #{child_name}"
-    end
-
-    # Get the source range of child node.
-    #
-    # @param child_name [String] name of child node.
-    # @return [Parser::Source::Range] source range of child node.
-    def child_node_range(child_name)
-      case [type, child_name.to_sym]
-      when %i[block pipes], %i[def parentheses], %i[defs parentheses]
-        Parser::Source::Range.new(
-          '(string)',
-          arguments.first.loc.expression.begin_pos - 1,
-          arguments.last.loc.expression.end_pos + 1
-        )
-      when %i[block arguments], %i[def arguments], %i[defs arguments]
-        Parser::Source::Range.new(
-          '(string)',
-          arguments.first.loc.expression.begin_pos,
-          arguments.last.loc.expression.end_pos
-        )
-      when %i[class name], %i[def name], %i[defs name]
-        loc.name
-      when %i[defs dot]
-        loc.operator
-      when %i[defs self]
-        Parser::Source::Range.new('(string)', loc.operator.begin_pos - 'self'.length, loc.operator.begin_pos)
-      when %i[send dot], %i[csend dot]
-        loc.dot
-      when %i[send message], %i[csend message]
-        if loc.operator
-          Parser::Source::Range.new('(string)', loc.selector.begin_pos, loc.operator.end_pos)
-        else
-          loc.selector
-        end
-      when %i[send parentheses], %i[csend parentheses]
-        if loc.begin && loc.end
-          Parser::Source::Range.new('(string)', loc.begin.begin_pos, loc.end.end_pos)
-        end
-      else
-        direct_child_name, nested_child_name = child_name.to_s.split('.', 2)
-        if respond_to?(direct_child_name)
-          child_node = send(direct_child_name)
-
-          return child_node.child_node_range(nested_child_name) if nested_child_name
-
-          return nil if child_node.nil?
-
-          if child_node.is_a?(Parser::AST::Node)
-            return(
-              Parser::Source::Range.new(
-                '(string)',
-                child_node.loc.expression.begin_pos,
-                child_node.loc.expression.end_pos
-              )
-            )
-          end
-
-          # arguments
-          return nil if child_node.empty?
-
-          return(
-            Parser::Source::Range.new(
-              '(string)',
-              child_node.first.loc.expression.begin_pos,
-              child_node.last.loc.expression.end_pos
-            )
-          )
-        end
-
-        raise Synvert::Core::MethodNotSupported,
-              "child_node_range is not handled for #{debug_info}, child_name: #{child_name}"
-      end
-    end
-
-    # Recursively iterate all child nodes of node.
-    #
-    # @yield [child] Gives a child node.
-    # @yieldparam child [Parser::AST::Node] child node
-    def recursive_children(&block)
-      children.each do |child|
-        if child.is_a?(Parser::AST::Node)
-          stop = yield child
-          child.recursive_children(&block) unless stop == :stop
-        end
-      end
-    end
-
     # Match node with rules.
     # It provides some additional keywords to match rules, +any+, +contain+, +not+, +in+, +not_in+, +gt+, +gte+, +lt+, +lte+.
     # @example
@@ -506,53 +87,6 @@ module Parser::AST
       end
     end
 
-    # Get rewritten source code.
-    # @example
-    #   node.rewritten_source("create({{arguments}})") # "create(:post)"
-    # @param code [String] raw code.
-    # @return [String] rewritten code, replace string in block !{{ }} in raw code.
-    # @raise [Synvert::Core::MethodNotSupported] if string in block !{{ }} does not support.
-    def rewritten_source(code)
-      code.gsub(/{{(.*?)}}/m) do
-        old_code = Regexp.last_match(1)
-        if respond_to?(old_code.split('.').first)
-          evaluated = child_node_by_name(old_code)
-          case evaluated
-          when Parser::AST::Node
-            if evaluated.type == :args
-              evaluated.loc.expression.source[1...-1]
-            else
-              evaluated.loc.expression.source
-            end
-          when Array
-            if evaluated.size > 0
-              file_source = evaluated.first.loc.expression.source_buffer.source
-              source = file_source[evaluated.first.loc.expression.begin_pos...evaluated.last.loc.expression.end_pos]
-              lines = source.split "\n"
-              lines_count = lines.length
-              if lines_count > 1 && lines_count == evaluated.size
-                new_code = []
-                lines.each_with_index { |line, index|
-                  new_code << (index == 0 ? line : line[evaluated.first.indent - 2..-1])
-                }
-                new_code.join("\n")
-              else
-                source
-              end
-            end
-          when String, Symbol, Integer, Float
-            evaluated
-          when NilClass
-            'nil'
-          else
-            raise Synvert::Core::MethodNotSupported, "rewritten_source is not handled for #{evaluated.inspect}"
-          end
-        else
-          "{{#{old_code}}}"
-        end
-      end
-    end
-
     # Strip curly braces for hash.
     # @example
     #   node # s(:hash, s(:pair, s(:sym, :foo), s(:str, "bar")))