node_mutation 1.19.4 → 1.21.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9058cbdb6c979c921d77499277354922b7488da6315b85b368c8f0c14b7bf27e
-  data.tar.gz: 9f64d3bdb87aa025cf6362127a1170a014f28ec2ec7e04d88756bcd50744429e
+  metadata.gz: 3bac003e717da366c7a0d9e1e0ee939db7173805fa2f9882b9141d089503cf00
+  data.tar.gz: 0e1a8f58718b689cb50bd5177496cc0b782594abff2b90cc532f3770fffce6fe
 SHA512:
-  metadata.gz: c3d8f491d11179cd203167ef7a76b87ea16fdfb0f2454afeb0600d4fb97147a9e237d2f1b86f8432643971b4a00016b1d143813572c49eba0e1d58b58f7c6f81
-  data.tar.gz: e1c15e3f180186f28486cc14f3d4ebd0ee132c22d9128058e709d545b2c7bb7dae13529c7b74163427e3bfc3f0bb80eb3b73e74b34e4847ae3c0d0dd955d40e1
+  metadata.gz: dee5df5d9cc61048b5b16b916527a8a031c80e16ff967bc547d65336a524bfd87e7135ebd72a8ac0aa1f3da6379520949c07d8a7c52baa13ea4a9d2a628c8318
+  data.tar.gz: 3252841fb0ec840591e21bcd28a5ab987271b6900664b7cd25397f7254d93130903d79f328763e67667bd5671101ec449e260a1a54b399939e5fdc9ff90910ff

data/CHANGELOG.md

@@ -1,5 +1,15 @@
 # NodeMutation
 
+## 1.21.0 (2023-09-26)
+
+* Rename `combine` dsl to `group`
+
+## 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.21.0)
 
 GEM
   remote: https://rubygems.org/

data/lib/node_mutation/action/group_action.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+# GroupAction is compose of multiple actions.
+class NodeMutation::GroupAction < NodeMutation::Action
+  DEFAULT_START = 2**30
+
+  attr_accessor :actions
+
+  def initialize
+    @actions = []
+    @type = :group
+  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::GroupAction)
+        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.21.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 :GroupAction, 'node_mutation/action/group_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
+      group 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
+      group 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
 
+  # group multiple actions
+  def group
+    current_actions = @actions
+    group_action = GroupAction.new
+    @actions = group_action.actions
+    yield
+    @actions = current_actions
+    @actions << group_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 GroupAction
+  # 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?(GroupAction)
+        new_actions << flatten_group_action(action)
+      else
+        new_actions << action
+      end
+    end
+    new_actions.compact
+  end
+
+  # It flattens a group action.
+  def flatten_group_action(action)
+    if action.actions.empty?
+      nil
+    elsif action.actions.size == 1
+      if action.actions.first.is_a?(GroupAction)
+        flatten_group_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?(GroupAction)
+    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?(GroupAction)
+        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?(GroupAction)
+    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 group: () { () -> 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.21.0
 platform: ruby
 authors:
 - Richard Huang
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-08-17 00:00:00.000000000 Z
+date: 2023-09-25 00:00:00.000000000 Z
 dependencies: []
 description: ast node mutation apis
 email:
@@ -29,6 +29,7 @@ files:
 - lib/node_mutation/action.rb
 - lib/node_mutation/action/append_action.rb
 - lib/node_mutation/action/delete_action.rb
+- lib/node_mutation/action/group_action.rb
 - lib/node_mutation/action/indent_action.rb
 - lib/node_mutation/action/insert_action.rb
 - lib/node_mutation/action/noop_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