node_mutation 1.21.3 → 1.21.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2db42bf57c1ecb342033989ea018607b34f25647565ad8db86d44cb0f0713b10
-  data.tar.gz: 9ab4cad235711dee0ff3c60a8547a0fa68bff99f47a12b331091a88c03edd08b
+  metadata.gz: f1148a4464a8b1f52500b09be2581a61c0add079b55052ced0e92297885f7082
+  data.tar.gz: c8e779f8ab34b515c7c991a0b16c3a4aa85c280841fa65d021a1d4fd6a49ec25
 SHA512:
-  metadata.gz: 5f9efba9693d6792033c04ef34313f2effed85b0f4f7392a6c669d71e383520420faa258f44dd7e72252785c60bbdb4cfe0e109af3e489a1046174f8370dc8c3
-  data.tar.gz: cd092b7e5babc2bf96f8fbd7b9009ef0b39ba056e68d9db92f4e175568e040465ce3da636a423674ade58a57621f03b86af35ee8ac38d5f82fc9d938956dc70f
+  metadata.gz: 662faf8ca577ab83503429153c5af550a4a3134a8138e4f36400aa6fcfb40b27de367c5a837af6dd6a139fe63627f3343d11d5573e2ae0501d0cfaf25fb8adb3
+  data.tar.gz: deda4075371317fd3c5decfda04bb8752b38f37679c21e1d940f1ebb2ef775f945ee38956ebea0e78717eb386e3dccaf5ff3b76fb50f550e616a246a880e43d6

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 # NodeMutation
 
+## 1.21.5 (2023-11-20)
+
+* Rewrite the process and test methods
+
+## 1.21.4 (2023-10-28)
+
+* Update `Adapter` rbs
+
 ## 1.21.3 (2023-10-03)
 
 * Call `Action#to_struct` explicitly

data/Gemfile.lock

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

data/lib/node_mutation/version.rb

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

data/lib/node_mutation.rb

@@ -262,20 +262,22 @@ class NodeMutation
   # if strategy is set to KEEP_RUNNING.
   # @return {NodeMutation::Result}
   def process
-    @actions = flatten_actions(@actions)
-    if @actions.length == 0
+    @actions = optimize_group_actions(@actions)
+
+    flatten_actions = flat_actions(@actions)
+    if flatten_actions.length == 0
       return NodeMutation::Result.new(affected: false, conflicted: false)
     end
 
     source = +@source
     @transform_proc.call(@actions) if @transform_proc
-    sort_actions!(@actions)
-    conflict_actions = get_conflict_actions(@actions)
+    sorted_actions = sort_flatten_actions(flatten_actions)
+    conflict_actions = get_conflict_actions(sorted_actions)
     if conflict_actions.size > 0 && strategy?(Strategy::THROW_ERROR)
       raise ConflictActionError, "mutation actions are conflicted"
     end
 
-    new_source = rewrite_source(source, @actions)
+    new_source = rewrite_source(source, sort_actions(get_filter_actions(conflict_actions)))
     result = NodeMutation::Result.new(affected: true, conflicted: !conflict_actions.empty?)
     result.new_source = new_source
     result
@@ -289,63 +291,79 @@ class NodeMutation
   # if strategy is set to KEEP_RUNNING.
   # @return {NodeMutation::Result}
   def test
-    @actions = flatten_actions(@actions)
-    if @actions.length == 0
+    @actions = optimize_group_actions(@actions)
+
+    flatten_actions = flat_actions(@actions)
+    if flatten_actions.length == 0
       return NodeMutation::Result.new(affected: false, conflicted: false)
     end
 
     @transform_proc.call(@actions) if @transform_proc
-    sort_actions!(@actions)
-    conflict_actions = get_conflict_actions(@actions)
+    sorted_actions = sort_flatten_actions(flatten_actions)
+    conflict_actions = get_conflict_actions(sorted_actions)
     if conflict_actions.size > 0 && strategy?(Strategy::THROW_ERROR)
       raise ConflictActionError, "mutation actions are conflicted"
     end
 
     result = NodeMutation::Result.new(affected: true, conflicted: !conflict_actions.empty?)
-    result.actions = @actions.map(&:to_struct)
+    actions = sort_actions(get_filter_actions(conflict_actions))
+    result.actions = actions.map(&:to_struct)
     result
   end
 
   private
 
-  # It flattens a series of actions by removing any GroupAction
+  # Optimizes a list of actions, recursively optimizing any nested group actions.
+  # @param actions [Array<NodeMutation::Action>]
+  # @return [Array<NodeMutation::Action>] optimized actions
+  def optimize_group_actions(actions)
+    actions.map do |action|
+      if action.is_a?(GroupAction)
+        # If the group action contains only one action, replace the group action with that action
+        if action.actions.length === 1
+          return optimize_group_actions(action.actions)
+        end
+
+        # If the group action contains more than one action, optimize its sub-actions
+        action.actions = optimize_group_actions(action.actions)
+      end
+      action
+    end
+  end
+
+  # It flats 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 = []
+  # @param actions [Array<NodeMutation::Action>]
+  # @return [Array<NodeMutation::Action>] flatten actions
+  def flat_actions(actions)
+    flatten_actions = []
     actions.each do |action|
       if action.is_a?(GroupAction)
-        new_actions << flatten_group_action(action)
+        flatten_actions += flat_actions(action.actions)
       else
-        new_actions << action
+        flatten_actions << action
       end
     end
-    new_actions.compact
+    flatten_actions
   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
+  # Recusively sort actions by start position and end position.
+  # @param actions [Array<NodeMutation::Action>]
+  # @return [Array<NodeMutation::Action>] sorted actions
+  def sort_actions(actions)
+    actions.each do |action|
+      if action.is_a?(GroupAction)
+        action.actions = sort_actions(action.actions)
       end
-    else
-      action.actions = flatten_actions(action.actions)
-      action
     end
+    actions.sort_by { |action| [action.start, 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
+  def sort_flatten_actions(flatten_actions)
+    flatten_actions.sort_by { |action| [action.start, action.end] }
   end
 
   # Rewrite source code with actions.
@@ -365,6 +383,8 @@ class NodeMutation
 
   # 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.
+  # @param actions [Array<NodeMutation::Action>]
+  # @return [Array<NodeMutation::Action>] conflict actions
   def get_conflict_actions(actions)
     i = actions.length - 1
     j = i - 1
@@ -376,7 +396,7 @@ class NodeMutation
     while j > -1
       # if we have two actions with overlapped range.
       if begin_pos < actions[j].end
-        conflict_actions << actions.delete_at(j)
+        conflict_actions << actions[j]
       else
         i = j
         begin_pos = actions[i].start
@@ -384,12 +404,22 @@ class NodeMutation
       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
 
+  # It filters conflict actions from actions.
+  # @param actions [Array<NodeMutation::Action>]
+  # @return [Array<NodeMutation::Action>] filtered actions
+  def get_filter_actions(conflict_actions)
+    @actions.select do |action|
+      if action.is_a?(GroupAction)
+        action.actions.all? { |child_action| !conflict_actions.include?(child_action) }
+      else
+        !conflict_actions.include?(action)
+      end
+    end
+  end
+
   def strategy?(strategy)
     NodeMutation.strategy & strategy == strategy
   end

data/sig/node_mutation/adapter.rbs

@@ -7,13 +7,13 @@ class NodeMutation::Adapter[T]
 
   def child_node_range: (node: T, child_name: String) -> NodeMutation::Struct::Range
 
-  def get_start: (node: T) -> Integer
+  def get_start: (node: T, ?child_name: String) -> Integer
 
-  def get_end: (node: T) -> Integer
+  def get_end: (node: T, ?child_name: String) -> Integer
 
-  def get_start_loc: (node: T) -> NodeMutation::Struct::Location
+  def get_start_loc: (node: T, ?child_name: String) -> NodeMutation::Struct::Location
 
-  def get_end_loc: (node: T) -> NodeMutation::Struct::Location
+  def get_end_loc: (node: T, ?child_name: String) -> NodeMutation::Struct::Location
 
   def get_indent: (node: T) -> Integer
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: node_mutation
 version: !ruby/object:Gem::Version
-  version: 1.21.3
+  version: 1.21.5
 platform: ruby
 authors:
 - Richard Huang
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-10-02 00:00:00.000000000 Z
+date: 2023-11-19 00:00:00.000000000 Z
 dependencies: []
 description: ast node mutation apis
 email: