node_mutation 1.19.3 → 1.20.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8089525a411cf3e7400148cba0d3cd21b763d6ec034dd5a627c0faf2419d8ec3
-  data.tar.gz: c5e0137f1da08ac49ffa45124cc39cb095543e5b5d5cc788e32093c581de2e2d
+  metadata.gz: fd49bceca35429738e6137151b99634e0ef83801214ba58e80c5e1d67b299b07
+  data.tar.gz: ef1f95f7edcf89b73b3eeb11137e374c813460cd4c5c8c67b970a5b29acc4e47
 SHA512:
-  metadata.gz: 0ecd574ae42a8cabdee2bdae86a14b905fdb4df3205af93753de47e9eb86f595371332f7b9dc5c560c3cd0b48db45d41680784b44fa4be9fba7ef36eefa8d9a7
-  data.tar.gz: c67d25471f221f0c9d7bd1bd6c40c95c2dfc995154dd9264ce4268eb4990c380ca38c7732a5da6c1b75518c68aeb8e3ea32c644259de12ce01559abac722d63a
+  metadata.gz: 71f84423b7cc2edd182ce760c984c1fef78f17ca267c72fb02f2eea9674dad5cf7c284180e03dbb888b5872e1157110e656d1f3587df17fe72140110594f0665
+  data.tar.gz: 951e9c6ba7afb239dab12428b40509e7d66178fe4776a317ebe5757a8d142e4fabe59ed1e75c5bedc4fe6a08e531c5176112cd48131b91422d1366e9d36af89a

data/CHANGELOG.md

@@ -1,5 +1,15 @@
 # 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`
+
 ## 1.19.3 (2023-07-01)
 
 * Rewrite `SyntaxTreeAdapter#child_node_range` to support Binary operator

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    node_mutation (1.19.3)
+    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/adapter/parser.rb

@@ -15,53 +15,53 @@ class NodeMutation::ParserAdapter < NodeMutation::Adapter
     end
   end
 
-  # It gets the new source code after evaluating the node.
+  # Gets the new source code after evaluating the node.
   # @param node [Parser::AST::Node] The node to evaluate.
   # @param code [String] The code to evaluate.
   # @return [String] The new source code.
   # @example
   #     node = Parser::CurrentRuby.parse('Factory.define :user do; end')
-  #     rewritten_source(node, '{{call.receiver}}').to eq 'Factory'
+  #     rewritten_source(node, '{{call.receiver}}') # 'Factory'
   #
   #     # index for node array
   #     node = Parser::CurrentRuby.parse("test(foo, bar)")
-  #     rewritten_source(node, '{{arguments.0}}')).to eq 'foo'
+  #     rewritten_source(node, '{{arguments.0}}')) # 'foo'
   #
   #     # {key}_pair for hash node
   #     node = Parser::CurrentRuby.parse("after_commit :do_index, on: :create, if: :indexable?")
-  #     rewritten_source(node, '{{arguments.-1.on_pair}}')).to eq 'on: :create'
+  #     rewritten_source(node, '{{arguments.-1.on_pair}}')) # 'on: :create'
   #
   #     # {key}_value for hash node
   #     node = Parser::CurrentRuby.parse("after_commit :do_index, on: :create, if: :indexable?")
-  #     rewritten_source(node, '{{arguments.-1.on_value}}')).to eq ':create'
+  #     rewritten_source(node, '{{arguments.-1.on_value}}')) # ':create'
   #
   #     # to_single_quote for str node
   #     node = Parser::CurrentRuby.parse('"foo"')
-  #     rewritten_source(node, 'to_single_quote') => "'foo'"
+  #     rewritten_source(node, 'to_single_quote') # "'foo'"
   #
   #     # to_double_quote for str node
   #     node = Parser::CurrentRuby.parse("'foo'")
-  #     rewritten_source(node, 'to_double_quote') => '"foo"'
+  #     rewritten_source(node, 'to_double_quote') # '"foo"'
   #
   #     # to_symbol for str node
   #     node = Parser::CurrentRuby.parse("'foo'")
-  #     rewritten_source(node, 'to_symbol') => ':foo'
+  #     rewritten_source(node, 'to_symbol') # ':foo'
   #
   #     # to_string for sym node
   #     node = Parser::CurrentRuby.parse(":foo")
-  #     rewritten_source(node, 'to_string') => 'foo'
+  #     rewritten_source(node, 'to_string') # 'foo'
   #
   #     # to_lambda_literal for block node
   #     node = Parser::CurrentRuby.parse('lambda { foobar }')
-  #     rewritten_source(node, 'to_lambda_literal') => '-> { foobar }'
+  #     rewritten_source(node, 'to_lambda_literal') # '-> { foobar }'
   #
   #     # strip_curly_braces for hash node
   #     node = Parser::CurrentRuby.parse("{ foo: 'bar' }")
-  #     rewritten_source(node, 'strip_curly_braces') => "foo: 'bar'"
+  #     rewritten_source(node, 'strip_curly_braces') # "foo: 'bar'"
   #
   #     # wrap_curly_braces for hash node
   #     node = Parser::CurrentRuby.parse("test(foo: 'bar')")
-  #     rewritten_source(node.arguments.first, 'wrap_curly_braces') => "{ foo: 'bar' }"
+  #     rewritten_source(node.arguments.first, 'wrap_curly_braces') # "{ foo: 'bar' }"
   def rewritten_source(node, code)
     code.gsub(/{{(.+?)}}/m) do
       old_code = Regexp.last_match(1)
@@ -82,7 +82,7 @@ class NodeMutation::ParserAdapter < NodeMutation::Adapter
           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[NodeMutation.adapter.get_indent(evaluated.first) - NodeMutation.tab_width..-1])
             }
             new_code.join("\n")
           else
@@ -109,40 +109,40 @@ class NodeMutation::ParserAdapter < NodeMutation::Adapter
   # @return {NodeMutation::Struct::Range} The range of the child node.
   # @example
   #     node = Parser::CurrentRuby.parse('Factory.define :user do; end')
-  #     child_node_range(node, 'caller.receiver') => { start: 0, end: 'Factory'.length }
+  #     child_node_range(node, 'caller.receiver') # { start: 0, end: 'Factory'.length }
   #
   #     # node array
   #     node = Parser::CurrentRuby.parse('foobar arg1, arg2)')
-  #     child_node_range(node, 'arguments') => { start: 'foobar '.length, end: 'foobar arg1, arg2'.length }
+  #     child_node_range(node, 'arguments') # { start: 'foobar '.length, end: 'foobar arg1, arg2'.length }
   #
   #     # index for node array
   #     node = Parser::CurrentRuby.parse('foobar(arg1, arg2)')
-  #     child_node_range(node, 'arguments.-1') => { start: 'foobar(arg1, '.length, end: 'foobar(arg1, arg2'.length }
+  #     child_node_range(node, 'arguments.-1') # { start: 'foobar(arg1, '.length, end: 'foobar(arg1, arg2'.length }
   #
   #     # pips for block node
   #     node = Parser::CurrentRuby.parse('Factory.define :user do |user|; end')
-  #     child_node_range(node, 'pipes') => { start: 'Factory.deine :user do '.length, end: 'Factory.define :user do |user|'.length }
+  #     child_node_range(node, 'pipes') # { start: 'Factory.deine :user do '.length, end: 'Factory.define :user do |user|'.length }
   #
   #     # parentheses for def and defs node
   #     node = Parser::CurrentRuby.parse('def foo(bar); end')
-  #     child_node_range(node, 'parentheses') => { start: 'def foo'.length, end: 'def foo(bar)'.length }
+  #     child_node_range(node, 'parentheses') # { start: 'def foo'.length, end: 'def foo(bar)'.length }
   #
   #     # double_colon for const node
   #     node = Parser::CurrentRuby.parse('Foo::Bar')
-  #     child_node_range(node, 'double_colon') => { start: 'Foo'.length, end: 'Foo::'.length }
+  #     child_node_range(node, 'double_colon') # { start: 'Foo'.length, end: 'Foo::'.length }
   #
   #     # self and dot for defs node
   #     node = Parser::CurrentRuby.parse('def self.foo(bar); end')
-  #     child_node_range(node, 'self') => { start: 'def '.length, end: 'def self'.length }
-  #     child_node_range(node, 'dot') => { start: 'def self'.length, end: 'def self.'.length }
+  #     child_node_range(node, 'self') # { start: 'def '.length, end: 'def self'.length }
+  #     child_node_range(node, 'dot') # { start: 'def self'.length, end: 'def self.'.length }
   #
   #     # dot for send and csend node
   #     node = Parser::CurrentRuby.parse('foo.bar(test)')
-  #     child_node_range(node, 'self') => { start: 'foo'.length, end: 'foo.'.length }
+  #     child_node_range(node, 'self') # { start: 'foo'.length, end: 'foo.'.length }
   #
   #     # parentheses for send and csend node
   #     node = Parser::CurrentRuby.parse('foo.bar(test)')
-  #     child_node_range(node, 'parentheses') => { start: 'foo.bar'.length, end: 'foo.bar(test)'.length }
+  #     child_node_range(node, 'parentheses') # { start: 'foo.bar'.length, end: 'foo.bar(test)'.length }
   def child_node_range(node, child_name)
     direct_child_name, nested_child_name = child_name.to_s.split('.', 2)
 

data/lib/node_mutation/adapter/syntax_tree.rb

@@ -18,47 +18,47 @@ class NodeMutation::SyntaxTreeAdapter < NodeMutation::Adapter
   # @return [String] The new source code.
   # @example
   #     node = SyntaxTree::Parser.new('class Synvert; end').parse.statements.body.first
-  #     rewritten_source(node, '{{constant}}').to eq 'Synvert'
+  #     rewritten_source(node, '{{constant}}') # 'Synvert'
   #
   #     # index for node array
   #     node = SyntaxTree::Parser.new("foo.bar(a, b)").parse.statements.body.first
-  #     rewritten_source(node, '{{arguments.arguments.parts.-1}}')).to eq 'b'
+  #     rewritten_source(node, '{{arguments.arguments.parts.-1}}')) # 'b'
   #
   #     # {key}_assoc for HashLiteral node
   #     node = SyntaxTree::Parser.new("after_commit :do_index, on: :create, if: :indexable?").parse.statements.body.first
-  #     rewritten_source(node, '{{arguments.parts.-1.on_assoc}}')).to eq 'on: :create'
+  #     rewritten_source(node, '{{arguments.parts.-1.on_assoc}}')) # 'on: :create'
   #
   #     # {key}_value for hash node
   #     node = SyntaxTree::Parser.new("after_commit :do_index, on: :create, if: :indexable?").parse.statements.body.first
-  #     rewritten_source(node, '{{arguments.parts.-1.on_value}}')).to eq ':create'
+  #     rewritten_source(node, '{{arguments.parts.-1.on_value}}')) # ':create'
   #
   #     # to_single_quote for StringLiteral node
   #     node = SyntaxTree::Parser.new('"foo"').parse.statements.body.first
-  #     rewritten_source(node, 'to_single_quote') => "'foo'"
+  #     rewritten_source(node, 'to_single_quote') # "'foo'"
   #
   #     # to_double_quote for StringLiteral node
   #     node = SyntaxTree::Parser.new("'foo'").parse.statements.body.first
-  #     rewritten_source(node, 'to_double_quote') => '"foo"'
+  #     rewritten_source(node, 'to_double_quote') # '"foo"'
   #
   #     # to_symbol for StringLiteral node
   #     node = SyntaxTree::Parser.new("'foo'").parse.statements.body.first
-  #     rewritten_source(node, 'to_symbol') => ':foo'
+  #     rewritten_source(node, 'to_symbol') # ':foo'
   #
   #     # to_string for SymbolLiteral node
   #     node = SyntaxTree::Parser.new(":foo").parse.statements.body.first
-  #     rewritten_source(node, 'to_string') => 'foo'
+  #     rewritten_source(node, 'to_string') # 'foo'
   #
   #     # to_lambda_literal for MethodAddBlock node
   #     node = SyntaxTree::Parser.new('lambda { foobar }').parse.statements.body.first
-  #     rewritten_source(node, 'to_lambda_literal') => '-> { foobar }'
+  #     rewritten_source(node, 'to_lambda_literal') # '-> { foobar }'
   #
   #     # strip_curly_braces for HashLiteral node
   #     node = SyntaxTree::Parser.new("{ foo: 'bar' }").parse.statements.body.first
-  #     rewritten_source(node, 'strip_curly_braces') => "foo: 'bar'"
+  #     rewritten_source(node, 'strip_curly_braces') # "foo: 'bar'"
   #
   #     # wrap_curly_braces for BareAssocHash node
   #     node = SyntaxTree::Parser.new("test(foo: 'bar')").parse.statements.body.first
-  #     rewritten_source(node.arguments.arguments.parts.first, 'wrap_curly_braces') => "{ foo: 'bar' }"
+  #     rewritten_source(node.arguments.arguments.parts.first, 'wrap_curly_braces') # "{ foo: 'bar' }"
   def rewritten_source(node, code)
     code.gsub(/{{(.+?)}}/m) do
       old_code = Regexp.last_match(1)
@@ -74,7 +74,7 @@ class NodeMutation::SyntaxTreeAdapter < NodeMutation::Adapter
           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[NodeMutation.adapter.get_indent(evaluated.first) - NodeMutation.tab_width..-1])
             }
             new_code.join("\n")
           else
@@ -101,19 +101,19 @@ class NodeMutation::SyntaxTreeAdapter < NodeMutation::Adapter
   # @return {NodeMutation::Struct::Range} The range of the child node.
   # @example
   #     node = SyntaxTree::Parser.new('foo.bar(test)').parse.statements.body.first
-  #     child_node_range(node, 'receiver') => { start: 0, end: 'foo'.length }
+  #     child_node_range(node, 'receiver') # { start: 0, end: 'foo'.length }
   #
   #     # node array
   #     node = SyntaxTree::Parser.new('foo.bar(a, b)').parse.statements.body.first
-  #     child_node_range(node, 'arguments.arguments') => { start: 'foo.bar('.length, end: 'foo.bar(a, b'.length }
+  #     child_node_range(node, 'arguments.arguments') # { start: 'foo.bar('.length, end: 'foo.bar(a, b'.length }
   #
   #     # index for node array
   #     node = SyntaxTree::Parser.new('foo.bar(a, b)').parse.statements.body.first
-  #     child_node_range(node, 'arguments.arguments.parts.-1') => { start: 'foo.bar(a, '.length, end: 'foo.bar(a, b'.length }
+  #     child_node_range(node, 'arguments.arguments.parts.-1') # { start: 'foo.bar(a, '.length, end: 'foo.bar(a, b'.length }
   #
   #     # operator of Binary node
   #     node = SyntaxTree::Parser.new('foo | bar').parse.statements.body.first
-  #     child_node_range(node, 'operator') => { start: 'foo '.length, end: 'foo |'.length }
+  #     child_node_range(node, 'operator') # { start: 'foo '.length, end: 'foo |'.length }
   def child_node_range(node, child_name)
     direct_child_name, nested_child_name = child_name.to_s.split('.', 2)
 

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.3"
+  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.3
+  version: 1.20.0
 platform: ruby
 authors:
 - Richard Huang
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-06-30 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
@@ -70,7 +73,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.13
+rubygems_version: 3.4.18
 signing_key:
 specification_version: 4
 summary: ast node mutation apis