node_mutation 1.19.4 → 1.20.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9058cbdb6c979c921d77499277354922b7488da6315b85b368c8f0c14b7bf27e
-  data.tar.gz: 9f64d3bdb87aa025cf6362127a1170a014f28ec2ec7e04d88756bcd50744429e
+  metadata.gz: fd49bceca35429738e6137151b99634e0ef83801214ba58e80c5e1d67b299b07
+  data.tar.gz: ef1f95f7edcf89b73b3eeb11137e374c813460cd4c5c8c67b970a5b29acc4e47
 SHA512:
-  metadata.gz: c3d8f491d11179cd203167ef7a76b87ea16fdfb0f2454afeb0600d4fb97147a9e237d2f1b86f8432643971b4a00016b1d143813572c49eba0e1d58b58f7c6f81
-  data.tar.gz: e1c15e3f180186f28486cc14f3d4ebd0ee132c22d9128058e709d545b2c7bb7dae13529c7b74163427e3bfc3f0bb80eb3b73e74b34e4847ae3c0d0dd955d40e1
+  metadata.gz: 71f84423b7cc2edd182ce760c984c1fef78f17ca267c72fb02f2eea9674dad5cf7c284180e03dbb888b5872e1157110e656d1f3587df17fe72140110594f0665
+  data.tar.gz: 951e9c6ba7afb239dab12428b40509e7d66178fe4776a317ebe5757a8d142e4fabe59ed1e75c5bedc4fe6a08e531c5176112cd48131b91422d1366e9d36af89a

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 # NodeMutation
 
+## 1.20.0 (2023-09-24)
+
+* Add `CombinedAction` to combine multiple actions.
+* Add `combine` dsl to combine multiple actions.
+* Add `NodeMutation::Helper.iterate_actions`
+
 ## 1.19.4 (2023-08-17)
 
 * Use `NodeMutation.adapter.get_indent`

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    node_mutation (1.19.4)
+    node_mutation (1.20.0)
 
 GEM
   remote: https://rubygems.org/

data/lib/node_mutation/action/combined_action.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+# CombinedAction combines multiple actions.
+class NodeMutation::CombinedAction < NodeMutation::Action
+  DEFAULT_START = 2**30
+
+  attr_accessor :actions
+
+  def initialize
+    @actions = []
+    @type = :combined
+  end
+
+  def new_code
+    nil
+  end
+
+  private
+
+  # Calculate the begin and end positions.
+  def calculate_position
+    @start = DEFAULT_START
+    @end = 0
+    NodeMutation::Helper.iterate_actions(@actions) do |action|
+      @start = [action.start, @start].min
+      @end = [action.end, @end].max
+    end
+  end
+end

data/lib/node_mutation/helper.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+class NodeMutation::Helper
+  # It iterates over all actions, and calls the given block with each action.
+  def self.iterate_actions(actions, &block)
+    actions.each do |action|
+      if action.is_a?(NodeMutation::CombinedAction)
+        iterate_actions(action.actions, &block)
+      else
+        block.call(action)
+      end
+    end
+  end
+end

data/lib/node_mutation/version.rb

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

data/lib/node_mutation.rb

@@ -11,6 +11,7 @@ class NodeMutation
   autoload :SyntaxTreeAdapter, "node_mutation/adapter/syntax_tree"
   autoload :Action, 'node_mutation/action'
   autoload :AppendAction, 'node_mutation/action/append_action'
+  autoload :CombinedAction, 'node_mutation/action/combined_action'
   autoload :DeleteAction, 'node_mutation/action/delete_action'
   autoload :IndentAction, 'node_mutation/action/indent_action'
   autoload :InsertAction, 'node_mutation/action/insert_action'
@@ -22,6 +23,7 @@ class NodeMutation
   autoload :Result, 'node_mutation/result'
   autoload :Strategy, 'node_mutation/strategy'
   autoload :Struct, 'node_mutation/struct'
+  autoload :Helper, 'node_mutation/helper'
 
   # @!attribute [r] actions
   #   @return [Array<NodeMutation::Struct::Action>]
@@ -208,21 +210,50 @@ class NodeMutation
   def wrap(node, prefix:, suffix:, newline: false)
     if newline
       indentation = NodeMutation.adapter.get_start_loc(node).column
-      @actions << InsertAction.new(node, prefix + "\n" + (' ' * indentation), at: 'beginning').process
-      @actions << InsertAction.new(node, "\n" + (' ' * indentation) + suffix, at: 'end').process
-      @actions << IndentAction.new(node).process
+      combine do
+        insert node, prefix + "\n" + (' ' * indentation), at: 'beginning'
+        insert node, "\n" + (' ' * indentation) + suffix, at: 'end'
+        indent node
+      end
     else
-      @actions << InsertAction.new(node, prefix, at: 'beginning').process
-      @actions << InsertAction.new(node, suffix, at: 'end').process
+      combine do
+        insert node, prefix, at: 'beginning'
+        insert node, suffix, at: 'end'
+      end
     end
   end
 
+  # Indent source code of the ast node
+  # @param node [Node] ast node
+  # @example
+  # source code of ast node is
+  #     class Foobar
+  #     end
+  # then we call
+  #     indent(node)
+  # the source code will be rewritten to
+  #       class Foobar
+  #       end
+  def indent(node)
+    @actions << IndentAction.new(node).process
+  end
+
   # No operation.
   # @param node [Node] ast node
   def noop(node)
     @actions << NoopAction.new(node).process
   end
 
+  # Combine multiple actions
+  def combine
+    current_actions = @actions
+    combined_action = CombinedAction.new
+    @actions = combined_action.actions
+    yield
+    @actions = current_actions
+    @actions << combined_action.process
+  end
+
   # Process actions and return the new source.
   #
   # If there's an action range conflict,
@@ -231,23 +262,22 @@ class NodeMutation
   # if strategy is set to KEEP_RUNNING.
   # @return {NodeMutation::Result}
   def process
+    @actions = flatten_actions(@actions)
     if @actions.length == 0
       return NodeMutation::Result.new(affected: false, conflicted: false)
     end
 
     source = +@source
     @transform_proc.call(@actions) if @transform_proc
-    @actions.sort_by! { |action| [action.start, action.end] }
-    conflict_actions = get_conflict_actions
+    sort_actions!(@actions)
+    conflict_actions = get_conflict_actions(@actions)
     if conflict_actions.size > 0 && strategy?(Strategy::THROW_ERROR)
       raise ConflictActionError, "mutation actions are conflicted"
     end
 
-    @actions.reverse_each do |action|
-      source[action.start...action.end] = action.new_code if action.new_code
-    end
+    new_source = rewrite_source(source, @actions)
     result = NodeMutation::Result.new(affected: true, conflicted: !conflict_actions.empty?)
-    result.new_source = source
+    result.new_source = new_source
     result
   end
 
@@ -259,13 +289,14 @@ class NodeMutation
   # if strategy is set to KEEP_RUNNING.
   # @return {NodeMutation::Result}
   def test
+    @actions = flatten_actions(@actions)
     if @actions.length == 0
       return NodeMutation::Result.new(affected: false, conflicted: false)
     end
 
     @transform_proc.call(@actions) if @transform_proc
-    @actions.sort_by! { |action| [action.start, action.end] }
-    conflict_actions = get_conflict_actions
+    sort_actions!(@actions)
+    conflict_actions = get_conflict_actions(@actions)
     if conflict_actions.size > 0 && strategy?(Strategy::THROW_ERROR)
       raise ConflictActionError, "mutation actions are conflicted"
     end
@@ -277,27 +308,85 @@ class NodeMutation
 
   private
 
+  # It flattens a series of actions by removing any CombinedAction
+  # objects that contain only a single action. This is done recursively.
+  def flatten_actions(actions)
+    new_actions = []
+    actions.each do |action|
+      if action.is_a?(CombinedAction)
+        new_actions << flatten_combined_action(action)
+      else
+        new_actions << action
+      end
+    end
+    new_actions.compact
+  end
+
+  # It flattens a combined action.
+  def flatten_combined_action(action)
+    if action.actions.empty?
+      nil
+    elsif action.actions.size == 1
+      if action.actions.first.is_a?(CombinedAction)
+        flatten_combined_action(action.actions.first)
+      else
+        action.actions.first
+      end
+    else
+      action.actions = flatten_actions(action.actions)
+      action
+    end
+  end
+
+  # Sort actions by start position and end position.
+  # @param actions [Array<NodeMutation::Action>]
+  # @return [Array<NodeMutation::Action>] sorted actions
+  def sort_actions!(actions)
+    actions.sort_by! { |action| [action.start, action.end] }
+    actions.each do |action|
+      sort_actions!(action.actions) if action.is_a?(CombinedAction)
+    end
+  end
+
+  # Rewrite source code with actions.
+  # @param source [String] source code
+  # @param actions [Array<NodeMutation::Action>] actions
+  # @return [String] new source code
+  def rewrite_source(source, actions)
+    actions.reverse_each do |action|
+      if action.is_a?(CombinedAction)
+        source = rewrite_source(source, action.actions)
+      else
+        source[action.start...action.end] = action.new_code if action.new_code
+      end
+    end
+    source
+  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
-    i = @actions.length - 1
+  def get_conflict_actions(actions)
+    i = actions.length - 1
     j = i - 1
     conflict_actions = []
     return [] if i < 0
 
-    begin_pos = @actions[i].start
-    end_pos = @actions[i].end
+    begin_pos = actions[i].start
+    end_pos = actions[i].end
     while j > -1
       # if we have two actions with overlapped range.
-      if begin_pos < @actions[j].end
-        conflict_actions << @actions.delete_at(j)
+      if begin_pos < actions[j].end
+        conflict_actions << actions.delete_at(j)
       else
         i = j
-        begin_pos = @actions[i].start
-        end_pos = @actions[i].end
+        begin_pos = actions[i].start
+        end_pos = actions[i].end
       end
       j -= 1
     end
+    actions.each do |action|
+      conflict_actions.concat(get_conflict_actions(action.actions)) if action.is_a?(CombinedAction)
+    end
     conflict_actions
   end
 

data/sig/node_mutation/helper.rbs

@@ -0,0 +1,3 @@
+class NodeMutation::Helper
+  def self.iterate_actions: (actions: Array[NodeMutation::Action]) { (action: NodeMutation::Action) -> void } -> void
+end

data/sig/node_mutation.rbs

@@ -1,4 +1,4 @@
-module NodeMutation[T]
+class NodeMutation[T]
   VERSION: String
 
   class MethodNotSupported < StandardError
@@ -39,6 +39,8 @@ module NodeMutation[T]
 
   def noop: (node: T) -> void
 
+  def combine: () { () -> void } -> void
+
   def process: () -> NodeMutation::Result
 
   def test: () -> NodeMutation::Result

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: node_mutation
 version: !ruby/object:Gem::Version
-  version: 1.19.4
+  version: 1.20.0
 platform: ruby
 authors:
 - Richard Huang
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-08-17 00:00:00.000000000 Z
+date: 2023-09-24 00:00:00.000000000 Z
 dependencies: []
 description: ast node mutation apis
 email:
@@ -28,6 +28,7 @@ files:
 - lib/node_mutation.rb
 - lib/node_mutation/action.rb
 - lib/node_mutation/action/append_action.rb
+- lib/node_mutation/action/combined_action.rb
 - lib/node_mutation/action/delete_action.rb
 - lib/node_mutation/action/indent_action.rb
 - lib/node_mutation/action/insert_action.rb
@@ -39,6 +40,7 @@ files:
 - lib/node_mutation/adapter.rb
 - lib/node_mutation/adapter/parser.rb
 - lib/node_mutation/adapter/syntax_tree.rb
+- lib/node_mutation/helper.rb
 - lib/node_mutation/result.rb
 - lib/node_mutation/strategy.rb
 - lib/node_mutation/struct.rb
@@ -46,6 +48,7 @@ files:
 - node_mutation.gemspec
 - sig/node_mutation.rbs
 - sig/node_mutation/adapter.rbs
+- sig/node_mutation/helper.rbs
 - sig/node_mutation/result.rbs
 - sig/node_mutation/strategy.rbs
 - sig/node_mutation/struct.rbs