synvert-core 0.17.0 → 0.18.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b73d8898436945c3266c9d0e4eec002491c3b031e1d571f94b3a59443142a9dd
-  data.tar.gz: c8afb1ce36ef5d3e826ebbc7ca10103175661e14f8ea1af1ae5a1a83b8714dbf
+  metadata.gz: a30d3e6c2241ca3fb2d35ead568fb24dc04db2d38a8faebb99eda33b0da7a354
+  data.tar.gz: f5d6ecdbcecbceabdf95ee474253b6e4ed0fc5cc5c52d25a7408d53ab54ccff0
 SHA512:
-  metadata.gz: b7198c44b3696f0c0f640fe378ff3b9923799517998d6be38177096a552b33885bf5df6113d1aa1a0b68432bff79d0322587648d221bd6fbaebcf75ab8b2d32d
-  data.tar.gz: 39b8bf09735971e108b112b96b3377df988b82e891c76d5050fef978aec81bf340ff096463ac9416848fd9b8e412b95537377d0647d11a6028d5ab909cac4fa4
+  metadata.gz: b7a9a026022ba96e5140d3aa6976bdbc8448dffdc8539b946df41016daf5847bf2c75a1458c2b8184d73e2a50a40741be67e8c382b49b1c1df5adf9e7c2e29dd
+  data.tar.gz: 42d7d7249ba0047709013c61a14c3428728967ff701b738eaa261683dfdf44ea899a3235cf1a2adb034034bb0bd006d7ec6ce59c415abfaef263647d15cbeb21

data/CHANGELOG.md

@@ -1,5 +1,9 @@
 # CHANGELOG
 
+## 0.18.0 (2021-02-07)
+
+* Add `Rewriter.execute`
+
 ## 0.17.0 (2021-01-29)
 
 * Ignore `gem_spec` check if `Gemfile.lock` does not eixst

data/lib/synvert/core.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "synvert/core/version"
+require 'synvert/core/version'
 require 'bundler'
 require 'parser'
 require 'parser/current'

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

@@ -4,17 +4,17 @@ require 'erubis'
 
 module Synvert::Core
   module Engine
-    ERUBY_EXPR_SPLITTER = ";  ;"
-    ERUBY_STMT_SPLITTER = ";   ;"
+    ERUBY_EXPR_SPLITTER = ';  ;'
+    ERUBY_STMT_SPLITTER = ';   ;'
 
     class ERB
-      class <<self
+      class << self
         # convert erb to ruby code.
         #
         # @param source [String] erb source code.
         # @return [String] ruby source code.
         def encode(source)
-          Erubis.new(source.gsub("-%>", "%>"), :escape => false, :trim => false).src
+          Erubis.new(source.gsub('-%>', '%>'), escape: false, trim: false).src
         end
 
         # convert ruby code to erb.
@@ -28,25 +28,30 @@ module Synvert::Core
           source = remove_erubis_buf(source)
         end
 
-      private
+        private
 
         def decode_ruby_stmt(source)
           source.gsub(/#{ERUBY_STMT_SPLITTER}(.+?)#{ERUBY_STMT_SPLITTER}/m) { "<%#{$1}%>" }
         end
 
         def decode_ruby_output(source)
-          source.gsub(/@output_buffer.append=\((.+?)\);#{ERUBY_EXPR_SPLITTER}/m) { "<%=#{$1}%>" }
-            .gsub(/@output_buffer.append= (.+?)\s+(do|\{)(\s*\|[^|]*\|)?\s*#{ERUBY_EXPR_SPLITTER}/m) { |m| "<%=#{m.sub("@output_buffer.append= ", "").sub(ERUBY_EXPR_SPLITTER, "")}%>" }
+          source.gsub(/@output_buffer.append=\((.+?)\);#{ERUBY_EXPR_SPLITTER}/m) { "<%=#{$1}%>" }.gsub(
+            /@output_buffer.append= (.+?)\s+(do|\{)(\s*\|[^|]*\|)?\s*#{ERUBY_EXPR_SPLITTER}/m
+          ) { |m| "<%=#{m.sub('@output_buffer.append= ', '').sub(ERUBY_EXPR_SPLITTER, '')}%>" }
         end
 
         def decode_html_output(source)
-          source.gsub(/@output_buffer.safe_append='(.+?)'.freeze;/m) { reverse_escape_text($1) }
-            .gsub(/@output_buffer.safe_append=\((.+?)\);#{ERUBY_EXPR_SPLITTER}/m) { reverse_escape_text($1) }
-            .gsub(/@output_buffer.safe_append=(.+?)\s+(do|\{)(\s*\|[^|]*\|)?\s*#{ERUBY_EXPR_SPLITTER}/m) { reverse_escape_text($1) }
+          source.gsub(/@output_buffer.safe_append='(.+?)'.freeze;/m) { reverse_escape_text($1) }.gsub(
+            /@output_buffer.safe_append=\((.+?)\);#{ERUBY_EXPR_SPLITTER}/m
+          ) { reverse_escape_text($1) }.gsub(
+            /@output_buffer.safe_append=(.+?)\s+(do|\{)(\s*\|[^|]*\|)?\s*#{ERUBY_EXPR_SPLITTER}/m
+          ) { reverse_escape_text($1) }
         end
 
         def remove_erubis_buf(source)
-          source.sub("@output_buffer = output_buffer || ActionView::OutputBuffer.new;", "").sub("@output_buffer.to_s", "")
+          source
+            .sub('@output_buffer = output_buffer || ActionView::OutputBuffer.new;', '')
+            .sub('@output_buffer.to_s', '')
         end
 
         def reverse_escape_text(source)
@@ -59,7 +64,7 @@ module Synvert::Core
     class Erubis < ::Erubis::Eruby
       def add_preamble(src)
         @newline_pending = 0
-        src << "@output_buffer = output_buffer || ActionView::OutputBuffer.new;"
+        src << '@output_buffer = output_buffer || ActionView::OutputBuffer.new;'
       end
 
       def add_text(src, text)
@@ -102,22 +107,24 @@ module Synvert::Core
       def add_expr_escaped(src, code)
         flush_newline_if_pending(src)
         if code =~ BLOCK_EXPR
-          src << "@output_buffer.safe_append= " << code << ERUBY_EXPR_SPLITTER
+          src << '@output_buffer.safe_append= ' << code << ERUBY_EXPR_SPLITTER
         else
-          src << "@output_buffer.safe_append=(" << code << ");" << ERUBY_EXPR_SPLITTER
+          src << '@output_buffer.safe_append=(' << code << ');' << ERUBY_EXPR_SPLITTER
         end
       end
 
       def add_stmt(src, code)
         flush_newline_if_pending(src)
-        if code != "\n" && code != ""
-          index = if code =~ /\A(\s*)\r?\n/
-                    $1.length
-                  elsif code =~ /\A(\s+)/
-                    $1.end_with?(' ') ? $1.length - 1 : $1.length
-                  else
-                    0
-                  end
+        if code != "\n" && code != ''
+          index =
+            case code
+            when /\A(\s*)\r?\n/
+              $1.length
+            when /\A(\s+)/
+              $1.end_with?(' ') ? $1.length - 1 : $1.length
+            else
+              0
+            end
           code.insert(index, ERUBY_STMT_SPLITTER)
           code.insert(-1, ERUBY_STMT_SPLITTER[0...-1])
         end

data/lib/synvert/core/node_ext.rb

@@ -31,15 +31,15 @@ module Parser::AST
     # @return [Parser::AST::Node] name node.
     # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
     def name
-      case self.type
+      case type
       when :class, :module, :def, :arg, :blockarg, :restarg
-        self.children[0]
+        children[0]
       when :defs, :const
-        self.children[1]
+        children[1]
       when :mlhs
         self
       else
-        raise Synvert::Core::MethodNotSupported.new "name is not handled for #{self.debug_info}"
+        raise Synvert::Core::MethodNotSupported, "name is not handled for #{debug_info}"
       end
     end
 
@@ -48,10 +48,10 @@ module Parser::AST
     # @return [Parser::AST::Node] parent_class node.
     # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
     def parent_class
-      if :class == self.type
-        self.children[1]
+      if :class == type
+        children[1]
       else
-        raise Synvert::Core::MethodNotSupported.new "parent_class is not handled for #{self.debug_info}"
+        raise Synvert::Core::MethodNotSupported, "parent_class is not handled for #{debug_info}"
       end
     end
 
@@ -60,10 +60,10 @@ module Parser::AST
     # @return [Parser::AST::Node] parent const node.
     # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
     def parent_const
-      if :const == self.type
-        self.children[0]
+      if :const == type
+        children[0]
       else
-        raise Synvert::Core::MethodNotSupported.new "parent_const is not handled for #{self.debug_info}"
+        raise Synvert::Core::MethodNotSupported, "parent_const is not handled for #{debug_info}"
       end
     end
 
@@ -72,10 +72,10 @@ module Parser::AST
     # @return [Parser::AST::Node] receiver node.
     # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
     def receiver
-      if :send == self.type
-        self.children[0]
+      if :send == type
+        children[0]
       else
-        raise Synvert::Core::MethodNotSupported.new "receiver is not handled for #{self.debug_info}"
+        raise Synvert::Core::MethodNotSupported, "receiver is not handled for #{debug_info}"
       end
     end
 
@@ -84,13 +84,13 @@ module Parser::AST
     # @return [Parser::AST::Node] mesage node.
     # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
     def message
-      case self.type
+      case type
       when :super, :zsuper
         :super
       when :send
-        self.children[1]
+        children[1]
       else
-        raise Synvert::Core::MethodNotSupported.new "message is not handled for #{self.debug_info}"
+        raise Synvert::Core::MethodNotSupported, "message is not handled for #{debug_info}"
       end
     end
 
@@ -99,17 +99,17 @@ module Parser::AST
     # @return [Array<Parser::AST::Node>] arguments node.
     # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
     def arguments
-      case self.type
+      case type
       when :def, :block
-        ArgumentsNode.new self.children[1]
+        ArgumentsNode.new children[1]
       when :defs
-        ArgumentsNode.new self.children[2]
+        ArgumentsNode.new children[2]
       when :send
-        self.children[2..-1]
+        children[2..-1]
       when :defined?
-        self.children
+        children
       else
-        raise Synvert::Core::MethodNotSupported.new "arguments is not handled for #{self.debug_info}"
+        raise Synvert::Core::MethodNotSupported, "arguments is not handled for #{debug_info}"
       end
     end
 
@@ -118,10 +118,10 @@ module Parser::AST
     # @return [Parser::AST::Node] caller node.
     # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
     def caller
-      if :block == self.type
-        self.children[0]
+      if :block == type
+        children[0]
       else
-        raise Synvert::Core::MethodNotSupported.new "caller is not handled for #{self.debug_info}"
+        raise Synvert::Core::MethodNotSupported, "caller is not handled for #{debug_info}"
       end
     end
 
@@ -130,19 +130,19 @@ module Parser::AST
     # @return [Array<Parser::AST::Node>] body node.
     # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
     def body
-      case self.type
+      case type
       when :begin
-        self.children
+        children
       when :def, :block
-        return [] if self.children[2].nil?
+        return [] if children[2].nil?
 
-        :begin == self.children[2].type ? self.children[2].body : self.children[2..-1]
+        :begin == children[2].type ? children[2].body : children[2..-1]
       when :defs
-        return [] if self.children[3].nil?
+        return [] if children[3].nil?
 
-        :begin == self.children[3].type ? self.children[3].body : self.children[3..-1]
+        :begin == children[3].type ? children[3].body : children[3..-1]
       else
-        raise Synvert::Core::MethodNotSupported.new "body is not handled for #{self.debug_info}"
+        raise Synvert::Core::MethodNotSupported, "body is not handled for #{debug_info}"
       end
     end
 
@@ -151,10 +151,10 @@ module Parser::AST
     # @return [Parser::AST::Node] condition node.
     # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
     def condition
-      if :if == self.type
-        self.children[0]
+      if :if == type
+        children[0]
       else
-        raise Synvert::Core::MethodNotSupported.new "condition is not handled for #{self.debug_info}"
+        raise Synvert::Core::MethodNotSupported, "condition is not handled for #{debug_info}"
       end
     end
 
@@ -163,10 +163,10 @@ module Parser::AST
     # @return [Array<Parser::AST::Node>] keys node.
     # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
     def keys
-      if :hash == self.type
-        self.children.map { |child| child.children[0] }
+      if :hash == type
+        children.map { |child| child.children[0] }
       else
-        raise Synvert::Core::MethodNotSupported.new "keys is not handled for #{self.debug_info}"
+        raise Synvert::Core::MethodNotSupported, "keys is not handled for #{debug_info}"
       end
     end
 
@@ -175,10 +175,10 @@ module Parser::AST
     # @return [Array<Parser::AST::Node>] values node.
     # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
     def values
-      if :hash == self.type
-        self.children.map { |child| child.children[1] }
+      if :hash == type
+        children.map { |child| child.children[1] }
       else
-        raise Synvert::Core::MethodNotSupported.new "keys is not handled for #{self.debug_info}"
+        raise Synvert::Core::MethodNotSupported, "keys is not handled for #{debug_info}"
       end
     end
 
@@ -188,10 +188,10 @@ module Parser::AST
     # @return [Boolean] true if specified key exists.
     # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
     def has_key?(key)
-      if :hash == self.type
-        self.children.any? { |pair_node| pair_node.key.to_value == key }
+      if :hash == type
+        children.any? { |pair_node| pair_node.key.to_value == key }
       else
-        raise Synvert::Core::MethodNotSupported.new "has_key? is not handled for #{self.debug_info}"
+        raise Synvert::Core::MethodNotSupported, "has_key? is not handled for #{debug_info}"
       end
     end
 
@@ -201,11 +201,11 @@ module Parser::AST
     # @return [Parser::AST::Node] value node.
     # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
     def hash_value(key)
-      if :hash == self.type
-        value_node = self.children.find { |pair_node| pair_node.key.to_value == key }
+      if :hash == type
+        value_node = children.find { |pair_node| pair_node.key.to_value == key }
         value_node ? value_node.value : nil
       else
-        raise Synvert::Core::MethodNotSupported.new "has_key? is not handled for #{self.debug_info}"
+        raise Synvert::Core::MethodNotSupported, "has_key? is not handled for #{debug_info}"
       end
     end
 
@@ -214,10 +214,10 @@ module Parser::AST
     # @return [Parser::AST::Node] key node.
     # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
     def key
-      if :pair == self.type
-        self.children.first
+      if :pair == type
+        children.first
       else
-        raise Synvert::Core::MethodNotSupported.new "key is not handled for #{self.debug_info}"
+        raise Synvert::Core::MethodNotSupported, "key is not handled for #{debug_info}"
       end
     end
 
@@ -226,10 +226,10 @@ module Parser::AST
     # @return [Parser::AST::Node] value node.
     # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
     def value
-      if :pair == self.type
-        self.children.last
+      if :pair == type
+        children.last
       else
-        raise Synvert::Core::MethodNotSupported.new "value is not handled for #{self.debug_info}"
+        raise Synvert::Core::MethodNotSupported, "value is not handled for #{debug_info}"
       end
     end
 
@@ -238,10 +238,10 @@ module Parser::AST
     # @return [Parser::AST::Node] variable nodes.
     # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
     def left_value
-      if %i[masgn lvasgn ivasgn].include? self.type
-        self.children[0]
+      if %i[masgn lvasgn ivasgn].include? type
+        children[0]
       else
-        raise Synvert::Core::MethodNotSupported.new "left_value is not handled for #{self.debug_info}"
+        raise Synvert::Core::MethodNotSupported, "left_value is not handled for #{debug_info}"
       end
     end
 
@@ -250,10 +250,10 @@ module Parser::AST
     # @return [Array<Parser::AST::Node>] variable nodes.
     # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
     def right_value
-      if %i[masgn lvasgn ivasgn].include? self.type
-        self.children[1]
+      if %i[masgn lvasgn ivasgn].include? type
+        children[1]
       else
-        raise Synvert::Core::MethodNotSupported.new "right_value is not handled for #{self.debug_info}"
+        raise Synvert::Core::MethodNotSupported, "right_value is not handled for #{debug_info}"
       end
     end
 
@@ -262,60 +262,59 @@ module Parser::AST
     # @return [Object] exact value.
     # @raise [Synvert::Core::MethodNotSupported] if calls on other node.
     def to_value
-      case self.type
+      case type
       when :int, :str, :sym
-        self.children.last
+        children.last
       when :true
         true
       when :false
         false
       when :array
-        self.children.map(&:to_value)
+        children.map(&:to_value)
       when :irange
-        (self.children.first.to_value..self.children.last.to_value)
+        (children.first.to_value..children.last.to_value)
       when :begin
-        self.children.first.to_value
+        children.first.to_value
       else
-        raise Synvert::Core::MethodNotSupported.new "to_value is not handled for #{self.debug_info}"
+        raise Synvert::Core::MethodNotSupported, "to_value is not handled for #{debug_info}"
       end
     end
 
     def to_s
-      if :mlhs == self.type
-        "(#{self.children.map(&:name).join(', ')})"
+      if :mlhs == type
+        "(#{children.map(&:name).join(', ')})"
       end
     end
 
     def debug_info
-      "\n" + [
-        "file: #{self.loc.expression.source_buffer.name}",
-        "line: #{self.loc.expression.line}",
-        "source: #{self.to_source}",
-        "node: #{self.inspect}"
-      ].join("\n")
+      "\n" +
+        [
+          "file: #{loc.expression.source_buffer.name}",
+          "line: #{loc.expression.line}",
+          "source: #{to_source}",
+          "node: #{inspect}"
+        ].join("\n")
     end
 
     # Get the source code of current node.
     #
     # @return [String] source code.
     def to_source
-      if self.loc.expression
-        self.loc.expression.source
-      end
+      loc.expression&.source
     end
 
     # Get the indent of current node.
     #
     # @return [Integer] indent.
     def indent
-      self.loc.expression.column
+      loc.expression.column
     end
 
     # Get the line of current node.
     #
     # @return [Integer] line.
     def line
-      self.loc.expression.line
+      loc.expression.line
     end
 
     # Recursively iterate all child nodes of current node.
@@ -323,7 +322,7 @@ module Parser::AST
     # @yield [child] Gives a child node.
     # @yieldparam child [Parser::AST::Node] child node
     def recursive_children
-      self.children.each do |child|
+      children.each do |child|
         if Parser::AST::Node === child
           yield child
           child.recursive_children { |c| yield c }
@@ -336,21 +335,24 @@ module Parser::AST
     # @param rules [Hash] rules to match.
     # @return true if matches.
     def match?(rules)
-      flat_hash(rules).keys.all? do |multi_keys|
-        if multi_keys.last == :any
-          actual_values = actual_value(self, multi_keys[0...-1])
-          expected = expected_value(rules, multi_keys)
-          actual_values.any? { |actual| match_value?(actual, expected) }
-        elsif multi_keys.last == :not
-          actual = actual_value(self, multi_keys[0...-1])
-          expected = expected_value(rules, multi_keys)
-          !match_value?(actual, expected)
-        else
-          actual = actual_value(self, multi_keys)
-          expected = expected_value(rules, multi_keys)
-          match_value?(actual, expected)
+      flat_hash(rules)
+        .keys
+        .all? do |multi_keys|
+          case multi_keys.last
+          when :any
+            actual_values = actual_value(self, multi_keys[0...-1])
+            expected = expected_value(rules, multi_keys)
+            actual_values.any? { |actual| match_value?(actual, expected) }
+          when :not
+            actual = actual_value(self, multi_keys[0...-1])
+            expected = expected_value(rules, multi_keys)
+            !match_value?(actual, expected)
+          else
+            actual = actual_value(self, multi_keys)
+            expected = expected_value(rules, multi_keys)
+            match_value?(actual, expected)
+          end
         end
-      end
     end
 
     # Get rewritten source code.
@@ -363,8 +365,8 @@ module Parser::AST
     def rewritten_source(code)
       code.gsub(/{{(.*?)}}/m) do
         old_code = $1
-        if self.respond_to? old_code.split(/\.|\[/).first
-          evaluated = self.instance_eval old_code
+        if respond_to? old_code.split(/\.|\[/).first
+          evaluated = instance_eval old_code
           case evaluated
           when Parser::AST::Node
             evaluated.loc.expression.source
@@ -377,7 +379,7 @@ module Parser::AST
               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 << (index == 0 ? line : line[evaluated.first.indent - 2..-1])
                 }
                 new_code.join("\n")
               else
@@ -389,7 +391,7 @@ module Parser::AST
           when NilClass
             'nil'
           else
-            raise Synvert::Core::MethodNotSupported.new "rewritten_source is not handled for #{evaluated.inspect}"
+            raise Synvert::Core::MethodNotSupported, "rewritten_source is not handled for #{evaluated.inspect}"
           end
         else
           "{{#{old_code}}}"
@@ -397,7 +399,7 @@ module Parser::AST
       end
     end
 
-  private
+    private
 
     # Compare actual value with expected value.
     #
@@ -415,8 +417,7 @@ module Parser::AST
         end
       when String
         if Parser::AST::Node === actual
-          actual.to_source == expected ||
-            (actual.to_source[0] == ':' && actual.to_source[1..-1] == expected) ||
+          actual.to_source == expected || (actual.to_source[0] == ':' && actual.to_source[1..-1] == expected) ||
             actual.to_source[1...-1] == expected
         else
           actual.to_s == expected
@@ -446,7 +447,7 @@ module Parser::AST
       when Parser::AST::Node
         actual == expected
       else
-        raise Synvert::Core::MethodNotSupported.new "#{expected.class} is not handled for match_value?"
+        raise Synvert::Core::MethodNotSupported, "#{expected.class} is not handled for match_value?"
       end
     end