node_mutation 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f708082625b70a33be17a520d51fab328979f7640f6125f7cec8a4f8c0fa348c
-  data.tar.gz: 71219747c6be37cb7282658c5dc6087f33ac63ed195de48ab29f2aa79347ea85
+  metadata.gz: 181790d29f44cf36742b7666a2b687c0befdd6ff70e30f21a3edcaf6c05ba2d6
+  data.tar.gz: 898ee69b167c2b6b12b2c3ddb196514deac6084c3b3066e7e634c5b9876dc0a8
 SHA512:
-  metadata.gz: 74f6fdb99bec0cd69ae0310ebc728661981ab7e7c41624e2409238426095cfec7576f1905d49f7e9d25393723b9c43dbe6ebf9c72730df38a19308e68682fc49
-  data.tar.gz: d2323af8c25e3a69779848be92594075970eb3c22b6c26fc411bc95710f51c9d37881a32c4196b3330eb28544d05dcbf72ef45521bce2e61025ea1ab5681eaae
+  metadata.gz: 0ad795cc5d87cb7e37d225d503946bb7afcd49a04de356306d3d9424845d98a7223812fc35f38122e954b38b9a446523d05033186ba312a4bccfc8492c131f83
+  data.tar.gz: 1dff8c627b676e4e3b7d333229abb1e1a5eb92871089a9b23c2ee96e872bd47121928d9e6e3b56e7b47b0d97c9bac7104c06991d42c2e414eb7d149c12042203

data/CHANGELOG.md

@@ -1,5 +1,10 @@
 # NodeMutation
 
+## 1.1.0 (2022-07-02)
+
+* Add erb engine
+* Add `ReplaceErbStmtWithExprAction`
+
 ## 1.0.0 (2022-07-01)
 
 * Initial release

data/Gemfile.lock

@@ -1,8 +1,9 @@
 PATH
   remote: .
   specs:
-    node_mutation (1.0.0)
+    node_mutation (1.1.0)
       activesupport
+      erubis
 
 GEM
   remote: https://rubygems.org/
@@ -16,6 +17,7 @@ GEM
     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)

data/README.md

@@ -25,7 +25,7 @@ Or install it yourself as:
 ```ruby
 require 'node_mutation'
 
-mutation = NodeMutation.new(file_path, source)
+mutation = NodeMutation.new(file_path)
 ```
 
 2. call the rewrite apis:
@@ -45,6 +45,8 @@ mutation.prepend node, '{{arguments.first}}.include FactoryGirl::Syntax::Methods
 mutation.remove(node: Node)
 # replace child node of the ast node with new code
 mutation.replace node, :message, with: 'test'
+# replace erb stmt node with expr code
+replace_erb_stmt_with_expr node
 # replace the ast node with new code
 mutation.replace_with node, 'create {{arguments}}'
 # wrap node within a block, class or module

data/lib/node_mutation/action/replace_erb_stmt_with_expr_action.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+# ReplaceErbStmtWithExprAction to replace erb stmt code to expr,
+# @example
+#   e.g. <% form_for ... %> => <%= form_for ... %>.
+class NodeMutation::ReplaceErbStmtWithExprAction < NodeMutation::Action
+  # Initialize a ReplaceErbStmtWithExprAction.
+  #
+  # @param node [Synvert::Core::Rewriter::Node]
+  def initialize(node)
+    super(node, nil)
+  end
+
+  # The new erb expr code.
+  #
+  # @return [String] new code.
+  def new_code
+    NodeMutation.adapter.file_content(@node)[@start...@end]
+      .sub(NodeMutation::Engine::ERUBY_STMT_SPLITTER, '@output_buffer.append= ')
+      .sub(NodeMutation::Engine::ERUBY_STMT_SPLITTER, NodeMutation::Engine::ERUBY_EXPR_SPLITTER)
+  end
+
+  private
+
+  # Calculate the begin the end positions.
+  def calculate_position
+    node_start = NodeMutation.adapter.get_start(@node)
+    node_source = NodeMutation.adapter.get_source(@node)
+    file_content = NodeMutation.adapter.file_content(@node)
+
+    whitespace_index = node_start
+    while file_content[whitespace_index -= 1] == ' '
+    end
+    @start = whitespace_index - NodeMutation::Engine::ERUBY_STMT_SPLITTER.length + 1
+
+    at_index = node_start + node_source.index('do')
+    while file_content[at_index += 1] != '@'
+    end
+    @end = at_index
+  end
+end

data/lib/node_mutation/action/wrap_action.rb

@@ -2,7 +2,7 @@
 
 # WrapAction to wrap node within a block, class or module.
 #
-# Note: if WrapAction is conflicted with another action (begin_pos and end_pos are overlapped),
+# Note: if WrapAction is conflicted with another action (start and end are overlapped),
 # we have to put those 2 actions into 2 within_file scopes.
 class NodeMutation::WrapAction < NodeMutation::Action
   # Initialize a WrapAction.

data/lib/node_mutation/action.rb

@@ -70,7 +70,7 @@ class NodeMutation::Action
     after_line_is_blank = lines[end_line] == ''
 
     if lines.length > 1 && before_line_is_blank && after_line_is_blank
-      @end_pos += "\n".length
+      @end += "\n".length
     end
   end
 

data/lib/node_mutation/engine/erb.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+require 'erubis'
+
+module NodeMutation::Engine
+  ERUBY_EXPR_SPLITTER = ';  ;'
+  ERUBY_STMT_SPLITTER = ';   ;'
+
+  class Erb
+    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
+      end
+
+      # convert ruby code to erb.
+      #
+      # @param source [String] ruby source code.
+      # @return [String] erb source code.
+      def decode(source)
+        source = decode_ruby_stmt(source)
+        source = decode_ruby_output(source)
+        source = decode_html_output(source)
+        source = remove_erubis_buf(source)
+      end
+
+      private
+
+      def decode_ruby_stmt(source)
+        source.gsub(/#{ERUBY_STMT_SPLITTER}(.+?)#{ERUBY_STMT_SPLITTER}/mo) { "<%#{Regexp.last_match(1)}%>" }
+      end
+
+      def decode_ruby_output(source)
+        source.gsub(/@output_buffer.append=\((.+?)\);#{ERUBY_EXPR_SPLITTER}/mo) {
+          "<%=#{Regexp.last_match(1)}%>"
+        }.gsub(/@output_buffer.append= (.+?)\s+(do|\{)(\s*\|[^|]*\|)?\s*#{ERUBY_EXPR_SPLITTER}/mo) { |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(Regexp.last_match(1)) }
+              .gsub(
+                /@output_buffer.safe_append=\((.+?)\);#{ERUBY_EXPR_SPLITTER}/mo
+              ) { reverse_escape_text(Regexp.last_match(1)) }
+              .gsub(
+                /@output_buffer.safe_append=(.+?)\s+(do|\{)(\s*\|[^|]*\|)?\s*#{ERUBY_EXPR_SPLITTER}/mo
+              ) { reverse_escape_text(Regexp.last_match(1)) }
+      end
+
+      def remove_erubis_buf(source)
+        source
+          .sub('@output_buffer = output_buffer || ActionView::OutputBuffer.new;', '')
+          .sub('@output_buffer.to_s', '')
+      end
+
+      def reverse_escape_text(source)
+        source.gsub("\\\\", "\\").gsub("\\'", "'")
+      end
+    end
+  end
+
+  # borrowed from rails
+  class Erubis < ::Erubis::Eruby
+    BLOCK_EXPR = /\s+(do|\{)(\s*\|[^|]*\|)?\s*\Z/
+    def add_preamble(src)
+      @newline_pending = 0
+      src << '@output_buffer = output_buffer || ActionView::OutputBuffer.new;'
+    end
+
+    def add_text(src, text)
+      return if text.empty?
+
+      if text == "\n"
+        @newline_pending += 1
+      else
+        src << "@output_buffer.safe_append='"
+        src << ("\n" * @newline_pending) if @newline_pending > 0
+        src << escape_text(text)
+        src << "'.freeze;"
+
+        @newline_pending = 0
+      end
+    end
+
+    # Erubis toggles <%= and <%== behavior when escaping is enabled.
+    # We override to always treat <%== as escaped.
+    def add_expr(src, code, indicator)
+      case indicator
+      when '=='
+        add_expr_escaped(src, code)
+      else
+        super
+      end
+    end
+
+    def add_expr_literal(src, code)
+      flush_newline_if_pending(src)
+      if BLOCK_EXPR.match?(code)
+        src << '@output_buffer.append= ' << code << ERUBY_EXPR_SPLITTER
+      else
+        src << '@output_buffer.append=(' << code << ');' << ERUBY_EXPR_SPLITTER
+      end
+    end
+
+    def add_expr_escaped(src, code)
+      flush_newline_if_pending(src)
+      if BLOCK_EXPR.match?(code)
+        src << '@output_buffer.safe_append= ' << code << ERUBY_EXPR_SPLITTER
+      else
+        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 =
+          case code
+          when /\A(\s*)\r?\n/
+            Regexp.last_match(1).length
+          when /\A(\s+)/
+            Regexp.last_match(1).end_with?(' ') ? Regexp.last_match(1).length - 1 : Regexp.last_match(1).length
+          else
+            0
+          end
+        code.insert(index, ERUBY_STMT_SPLITTER)
+        code.insert(-1, ERUBY_STMT_SPLITTER[0...-1])
+      end
+      super
+    end
+
+    def add_postamble(src)
+      flush_newline_if_pending(src)
+      src << '@output_buffer.to_s'
+    end
+
+    def flush_newline_if_pending(src)
+      if @newline_pending > 0
+        src << "@output_buffer.safe_append='#{"\n" * @newline_pending}'.freeze;"
+        @newline_pending = 0
+      end
+    end
+  end
+end

data/lib/node_mutation/engine.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module NodeMutation::Engine
+  # Engine defines how to encode / decode other files (like erb).
+  autoload :Erb, 'node_mutation/engine/erb'
+end

data/lib/node_mutation/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class NodeMutation
-  VERSION = "1.0.0"
+  VERSION = "1.1.0"
 end

data/lib/node_mutation.rb

@@ -9,7 +9,7 @@ class NodeMutation
   class MethodNotSupported < StandardError; end
   class ConflictActionError < StandardError; end
 
-  KEEPING_RUNNING = 1
+  KEEP_RUNNING = 1
   THROW_ERROR = 2
 
   autoload :Adapter, "node_mutation/adapter"
@@ -25,6 +25,7 @@ class NodeMutation
   autoload :ReplaceErbStmtWithExprAction, 'node_mutation/action/replace_erb_stmt_with_expr_action'
   autoload :ReplaceWithAction, 'node_mutation/action/replace_with_action'
   autoload :WrapAction, 'node_mutation/action/wrap_action'
+  autoload :Engine, 'node_mutation/engine'
 
   attr_reader :actions
 
@@ -47,18 +48,16 @@ class NodeMutation
   end
 
   # Get the strategy
-  # @return [Integer] current strategy, could be {NodeMutation::KEEPING_RUNNING} or {NodeMutation::THROW_ERROR},
-  # by default is {NodeMutation::KEEPING_RUNNING}
+  # @return [Integer] current strategy, could be {NodeMutation::KEEP_RUNNING} or {NodeMutation::THROW_ERROR},
+  # by default is {NodeMutation::KEEP_RUNNING}
   def self.strategy
     @strategy ||= KEEP_RUNNING
   end
 
   # Initialize a NodeMutation.
   # @param file_path [String] file path
-  # @param source [String] source of the file
-  def initialize(file_path, source)
+  def initialize(file_path)
     @file_path = file_path
-    @source = +source
     @actions = []
   end
 
@@ -169,14 +168,29 @@ class NodeMutation
   # source code of the ast node is
   #     assert(object.empty?)
   # then we call
-  #     replace :message, with: 'assert_empty'
-  #     replace :arguments, with: '{{arguments.first.receiver}}'
+  #     mutation.replace(node, :message, with: 'assert_empty')
+  #     mutation.replace(node, :arguments, with: '{{arguments.first.receiver}}')
   # the source code will be rewritten to
   #     assert_empty(object)
   def replace(node, *selectors, with:)
     @actions << ReplaceAction.new(node, *selectors, with: with).process
   end
 
+  # Replace erb stmt node with expr code.
+  # @param node [Node] ast node
+  # @example
+  # source code of the ast node is
+  #     <% form_for post do |f| %>
+  #     <% end %>
+  # then we call
+  #     replace_erb_stmt_with_expr(node)
+  # the source code will be rewritten to
+  #   # <%= form_for post do |f| %>
+  #   # <% end %>
+  def replace_erb_stmt_with_expr(node)
+    @actions << ReplaceErbStmtWithExprAction.new(node).process
+  end
+
   # Replace source code of the ast node with new code.
   # @param node [Node] ast node
   # @param code [String] code need to be replaced with.
@@ -221,23 +235,41 @@ class NodeMutation
   def process
     conflict_actions = []
     if @actions.length > 0
+      source = +read_source(@file_path)
       @actions.sort_by! { |action| [action.start, action.end] }
       conflict_actions = get_conflict_actions
       if conflict_actions.size > 0 && NodeMutation.strategy == THROW_ERROR
         raise ConflictActionError, "mutation actions are conflicted"
       end
       @actions.reverse_each do |action|
-        @source[action.start...action.end] = action.new_code
+        source[action.start...action.end] = action.new_code
       end
       @actions = []
 
-      File.write(@file_path, @source)
+      write_source(@file_path, source)
     end
     OpenStruct.new(conflict: !conflict_actions.empty?)
   end
 
   private
 
+  # Read file source.
+  # @param file_path [String] file path
+  # @return [String] file source
+  def read_source(file_path)
+    source = File.read(file_path, encoding: 'UTF-8')
+    source = Engine::Erb.encode(source) if /\.erb$/.match?(file_path)
+    source
+  end
+
+  # Write file source to file.
+  # @param file_path [String] file path
+  # @param source [String] file source
+  def write_source(file_path, source)
+    source = Engine::ERB.decode(source) if /\.erb/.match?(file_path)
+    File.write(file_path, source.gsub(/ +\n/, "\n"))
+  end
+
   # It changes source code from bottom to top, and it can change source code twice at the same time,
   # So if there is an overlap between two actions, it removes the conflict actions and operate them in the next loop.
   def get_conflict_actions

data/node_mutation.gemspec

@@ -30,6 +30,7 @@ Gem::Specification.new do |spec|
 
   # Uncomment to register a new dependency of your gem
   spec.add_dependency "activesupport"
+  spec.add_dependency "erubis"
 
   # For more information and examples about making a new gem, check out our
   # guide at: https://bundler.io/guides/creating_gem.html

data/sig/node_mutation.rbs

@@ -7,7 +7,7 @@ module NodeMutation[T]
   class ConflictActionError < StandardError
   end
 
-  KEEPING_RUNNING: Integer
+  KEEP_RUNNING: Integer
 
   THROW_ERROR: Integer
 
@@ -19,7 +19,7 @@ module NodeMutation[T]
 
   def self.strategry: () -> Integer
 
-  def initialize: (file_path: String, source: String) -> NodeMutation
+  def initialize: (file_path: String) -> NodeMutation
 
   def append: (node: T, code: String) -> void
 
@@ -35,6 +35,8 @@ module NodeMutation[T]
 
   def replace: (node: T, *selectors: Array[String], with: String) -> void
 
+  def replace_erb_stmt_with_expr: (node: T) -> void
+
   def replace_with: (node: T, code: String) -> void
 
   def wrap: (node: T, with: String) -> void

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: node_mutation
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Richard Huang
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-07-01 00:00:00.000000000 Z
+date: 2022-07-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -24,6 +24,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: erubis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: ast node mutation apis
 email:
 - flyerhzm@gmail.com
@@ -48,9 +62,12 @@ files:
 - lib/node_mutation/action/prepend_action.rb
 - lib/node_mutation/action/remove_action.rb
 - lib/node_mutation/action/replace_action.rb
+- lib/node_mutation/action/replace_erb_stmt_with_expr_action.rb
 - lib/node_mutation/action/replace_with_action.rb
 - lib/node_mutation/action/wrap_action.rb
 - lib/node_mutation/adapter.rb
+- lib/node_mutation/engine.rb
+- lib/node_mutation/engine/erb.rb
 - lib/node_mutation/parser_adapter.rb
 - lib/node_mutation/version.rb
 - node_mutation.gemspec