node_mutation 1.22.3 → 1.23.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 235e331a54f9181d9986ccb6ee62ef172b399a323b697b8090c954e685a117f0
-  data.tar.gz: 11e838f63be7a940176ad6880300aeebde419e3bb923016039a821496648b9ca
+  metadata.gz: 667309a875501329f61441ddc89143500b02d87e83be0a6aa324e78438cfd397
+  data.tar.gz: 565be945f6bbfd0976dafb86bb346be696665bd32a72227cf9a4a2d16e75fa45
 SHA512:
-  metadata.gz: 0cd144acfbcc3db98c407332f3408bde088ad14156bd5a9c07bc1d1042872339cc71b25b5896c76ff720d8efe80add83789f6889125e55dd7bcb39cc0cf43512
-  data.tar.gz: cdd66a6fa04ba9ad54d788e2f5680045b497a94b48875d4a98efb3a57dfc5a864f9f666a12ab687c16f5a2a59013b39b7d5ec8ead6264e63e22b6faf1edf527a
+  metadata.gz: ed08dbed41c4aa8dce675995a19736ce84877fc0334ab448c04019c7e413204ee2e0c6674ea2d779048962bccbf970990d0b72f89fb7bc17845cb0034b6400ce
+  data.tar.gz: 8488422fbcabd15c24c607c1a2b8229bf3a7be810a2d34f0568ceb79a82cc87ebdd06625ab0d76cf68099fd894a067267fc0dde257f5999aa48a8f0ef1c40346

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 # NodeMutation
 
+## 1.23.0 (2024-02-11)
+
+* Support `prism`
+
+## 1.22.4 (2024-01-30)
+
+* Revert "add action methods to GroupAction"
+
 ## 1.22.3 (2024-01-30)
 
 * `child_node_range` supports `arg` `name`

data/Gemfile

@@ -9,8 +9,8 @@ gem "rake", "~> 13.0"
 
 gem "rspec", "~> 3.0"
 
-gem "parser"
 gem "parser_node_ext"
 gem "syntax_tree_ext"
+gem "prism_ext"
 gem "guard"
 gem "guard-rspec"

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    node_mutation (1.22.3)
+    node_mutation (1.23.0)
 
 GEM
   remote: https://rubygems.org/
@@ -34,16 +34,19 @@ GEM
     notiffany (0.1.3)
       nenv (~> 0.1)
       shellany (~> 0.0)
-    parser (3.2.2.3)
+    parser (3.3.0.5)
       ast (~> 2.4.1)
       racc
-    parser_node_ext (1.2.1)
+    parser_node_ext (1.2.2)
       parser
     prettier_print (1.2.1)
+    prism (0.22.0)
+    prism_ext (0.2.1)
+      prism
     pry (0.14.1)
       coderay (~> 1.1)
       method_source (~> 1.0)
-    racc (1.7.1)
+    racc (1.7.3)
     rake (13.0.6)
     rb-fsevent (0.11.1)
     rb-inotify (0.10.1)
@@ -62,7 +65,7 @@ GEM
       rspec-support (~> 3.11.0)
     rspec-support (3.11.0)
     shellany (0.0.1)
-    syntax_tree (6.1.1)
+    syntax_tree (6.2.0)
       prettier_print (>= 1.2.0)
     syntax_tree_ext (0.6.3)
       syntax_tree
@@ -78,8 +81,8 @@ DEPENDENCIES
   guard
   guard-rspec
   node_mutation!
-  parser
   parser_node_ext
+  prism_ext
   rake (~> 13.0)
   rspec (~> 3.0)
   syntax_tree_ext

data/lib/node_mutation/action/group_action.rb

@@ -2,27 +2,18 @@
 
 # GroupAction is compose of multiple actions.
 class NodeMutation::GroupAction < NodeMutation::Action
-  include NodeMutation::Actionable
-
   DEFAULT_START = 2**30
 
   # Initialize a GroupAction.
-  def initialize(adapter:, &block)
+  def initialize
     @actions = []
     @type = :group
-    @adapter = adapter
-    @block = block
   end
 
   def new_code
     nil
   end
 
-  def process
-    instance_eval(&@block)
-    super
-  end
-
   private
 
   # Calculate the begin and end positions.

data/lib/node_mutation/adapter/prism.rb

@@ -0,0 +1,242 @@
+# frozen_string_literal: true
+
+require 'prism'
+require 'prism_ext'
+
+class NodeMutation::PrismAdapter < NodeMutation::Adapter
+  def get_source(node)
+    if node.is_a?(Array)
+      return node.first.source[node.first.location.start_offset...node.last.location.end_offset]
+    end
+
+    node.source[node.location.start_offset...node.location.end_offset]
+  end
+
+  # It gets the new source code after evaluating the node.
+  # @param node [Prism::Node] The node to evaluate.
+  # @param code [String] The code to evaluate.
+  # @return [String] The new source code.
+  # @example
+  #     node = Prism.parse('class Synvert; end').value.statements.body.first
+  #     rewritten_source(node, '{{constant}}') # 'Synvert'
+  #
+  #     # index for node array
+  #     node = Prism.parse("foo.bar(a, b)").value.statements.body.first
+  #     rewritten_source(node, '{{arguments.arguments.parts.-1}}')) # 'b'
+  #
+  #     # {key}_assoc for HashNode node
+  #     node = Prism.parse("after_commit :do_index, on: :create, if: :indexable?").value.statements.body.first
+  #     rewritten_source(node, '{{arguments.parts.-1.on_assoc}}')) # 'on: :create'
+  #
+  #     # {key}_value for hash node
+  #     node = Prism.parse("after_commit :do_index, on: :create, if: :indexable?").value.statements.body.first
+  #     rewritten_source(node, '{{arguments.parts.-1.on_value}}')) # ':create'
+  #
+  #     # to_single_quote for StringNode
+  #     node = Prism.parse('"foo"').value.statements.body.first
+  #     rewritten_source(node, 'to_single_quote') # "'foo'"
+  #
+  #     # to_double_quote for StringNode
+  #     node = Prism.parse("'foo'").value.statements.body.first
+  #     rewritten_source(node, 'to_double_quote') # '"foo"'
+  #
+  #     # to_symbol for StringNode
+  #     node = Prism.parse("'foo'").value.statements.body.first
+  #     rewritten_source(node, 'to_symbol') # ':foo'
+  #
+  #     # to_string for SymbolNode
+  #     node = Prism.parse(":foo").value.statements.body.first
+  #     rewritten_source(node, 'to_string') # 'foo'
+  #
+  #     # to_lambda_literal for CallNode with lambda
+  #     node = Prism.parse('lambda { foobar }').value.statements.body.first
+  #     rewritten_source(node, 'to_lambda_literal') # '-> { foobar }'
+  #
+  #     # strip_curly_braces for HashNode
+  #     node = Prism.parse("{ foo: 'bar' }").value.statements.body.first
+  #     rewritten_source(node, 'strip_curly_braces') # "foo: 'bar'"
+  #
+  #     # wrap_curly_braces for KeywordHashNode
+  #     node = Prism.parse("test(foo: 'bar')").value.statements.body.first
+  #     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)
+      evaluated = child_node_by_name(node, old_code)
+      case evaluated
+      when Prism::Node
+        get_source(evaluated)
+      when Array
+        if evaluated.size > 0
+          source = get_source(evaluated)
+          lines = source.split "\n"
+          lines_count = lines.length
+          if lines_count > 1 && lines_count == evaluated.size
+            new_code = []
+            lines.each_with_index { |line, index|
+              new_code << (index == 0 ? line : line[get_indent(evaluated.first) - NodeMutation.tab_width..-1])
+            }
+            new_code.join("\n")
+          else
+            source
+          end
+        end
+      when String, Symbol, Integer, Float
+        evaluated
+      when NilClass
+        ''
+      else
+        raise "can not parse \"#{code}\""
+      end
+    end
+  end
+
+  def file_source(node)
+    node.source
+  end
+
+  # Get the range of the child node.
+  # @param node [Parser::AST::Node] The node.
+  # @param child_name [String] THe name to find child node.
+  # @return {NodeMutation::Struct::Range} The range of the child node.
+  # @example
+  #     node = Prism.parse('foo.bar(test)').value.statements.body.first
+  #     child_node_range(node, 'receiver') # { start: 0, end: 'foo'.length }
+  #
+  #     # node array
+  #     node = Prism.parse('foo.bar(a, b)').value.statements.body.first
+  #     child_node_range(node, 'arguments.arguments') # { start: 'foo.bar('.length, end: 'foo.bar(a, b'.length }
+  #
+  #     # index for node array
+  #     node = Prism.parse('foo.bar(a, b)').value.statements.body.first
+  #     child_node_range(node, 'arguments.arguments.parts.-1') # { start: 'foo.bar(a, '.length, end: 'foo.bar(a, b'.length }
+  #
+  #     # operator of Binary node
+  #     node = Prism.parse('foo | bar').value.statements.body.first
+  #     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)
+
+    if node.is_a?(Array)
+      if direct_child_name =~ INDEX_REGEXP
+        child_node = node[direct_child_name.to_i]
+        raise NodeMutation::MethodNotSupported,
+              "#{direct_child_name} is not supported for #{get_source(node)}" unless child_node
+        return child_node_range(child_node, nested_child_name) if nested_child_name
+
+        return NodeMutation::Struct::Range.new(child_node.location.start_offset, child_node.location.end_offset)
+      end
+
+      raise NodeMutation::MethodNotSupported,
+            "#{direct_child_name} is not supported for #{get_source(node)}" unless node.respond_to?(direct_child_name)
+
+      child_node = node.send(direct_child_name)
+      return child_node_range(child_node, nested_child_name) if nested_child_name
+
+      return NodeMutation::Struct::Range.new(child_node.location.start_offset, child_node.location.end_offset)
+    end
+
+    if node.respond_to?("#{child_name}_loc")
+      node_loc = node.send("#{child_name}_loc")
+      if node_loc
+        NodeMutation::Struct::Range.new(node_loc.start_offset, node_loc.end_offset)
+      end
+    else
+      raise NodeMutation::MethodNotSupported,
+            "#{direct_child_name} is not supported for #{get_source(node)}" unless node.respond_to?(direct_child_name)
+
+      child_node = node.send(direct_child_name)
+
+      return child_node_range(child_node, nested_child_name) if nested_child_name
+
+      return nil if child_node.nil?
+
+      if child_node.is_a?(Prism::Node)
+        return(
+          NodeMutation::Struct::Range.new(child_node.location.start_offset, child_node.location.end_offset)
+        )
+      end
+
+      return(
+        NodeMutation::Struct::Range.new(child_node.first.location.start_offset, child_node.last.location.end_offset)
+      )
+    end
+  end
+
+  def get_start(node, child_name = nil)
+    node = child_node_by_name(node, child_name) if child_name
+    node.location.start_offset
+  end
+
+  def get_end(node, child_name = nil)
+    node = child_node_by_name(node, child_name) if child_name
+    node.location.end_offset
+  end
+
+  def get_start_loc(node, child_name = nil)
+    node = child_node_by_name(node, child_name) if child_name
+    NodeMutation::Struct::Location.new(node.location.start_line, node.location.start_column)
+  end
+
+  def get_end_loc(node, child_name = nil)
+    node = child_node_by_name(node, child_name) if child_name
+    NodeMutation::Struct::Location.new(node.location.end_line, node.location.end_column)
+  end
+
+  def get_indent(node)
+    node.location.start_column
+  end
+
+  private
+
+  def child_node_by_name(node, child_name)
+    direct_child_name, nested_child_name = child_name.to_s.split('.', 2)
+
+    if node.is_a?(Array)
+      if direct_child_name =~ INDEX_REGEXP
+        child_node = node[direct_child_name.to_i]
+        raise NodeMutation::MethodNotSupported,
+              "#{direct_child_name} is not supported for #{get_source(node)}" unless child_node
+        return child_node_by_name(child_node, nested_child_name) if nested_child_name
+
+        return child_node
+      end
+
+      raise NodeMutation::MethodNotSupported,
+            "#{direct_child_name} is not supported for #{get_source(node)}" unless node.respond_to?(direct_child_name)
+
+      child_node = node.send(direct_child_name)
+      return child_node_by_name(child_node, nested_child_name) if nested_child_name
+
+      return child_node
+    end
+
+    if node.respond_to?(direct_child_name)
+      child_node = node.send(direct_child_name)
+    elsif direct_child_name == 'to_symbol' && node.is_a?(Prism::StringNode)
+      child_node = ":#{node.to_value}"
+    elsif direct_child_name == 'to_string' && node.is_a?(Prism::SymbolNode)
+      child_node = node.to_value.to_s
+    elsif direct_child_name == 'to_single_quote' && node.is_a?(Prism::StringNode)
+      child_node = "'#{node.to_value}'"
+    elsif direct_child_name == 'to_double_quote' && node.is_a?(Prism::StringNode)
+      child_node = "\"#{node.to_value}\""
+    elsif direct_child_name == 'to_lambda_literal' && node.is_a?(Prism::CallNode) && node.name == :lambda
+      if node.block.parameters
+        child_node = "->(#{node.block.parameters.parameters.to_source}) { #{node.block.body.to_source} }"
+      else
+        child_node = "-> #{node.block.to_source}"
+      end
+    elsif direct_child_name == 'strip_curly_braces' && node.is_a?(Prism::HashNode)
+      child_node = node.to_source.sub(/^{(.*)}$/) { Regexp.last_match(1).strip }
+    elsif direct_child_name == 'wrap_curly_braces' && node.is_a?(Prism::KeywordHashNode)
+      child_node = "{ #{node.to_source} }"
+    else
+      raise NodeMutation::MethodNotSupported, "#{direct_child_name} is not supported for #{get_source(node)}"
+    end
+
+    return child_node_by_name(child_node, nested_child_name) if nested_child_name
+
+    child_node
+  end
+end

data/lib/node_mutation/adapter/syntax_tree.rb

@@ -17,47 +17,47 @@ class NodeMutation::SyntaxTreeAdapter < NodeMutation::Adapter
   # @param code [String] The code to evaluate.
   # @return [String] The new source code.
   # @example
-  #     node = SyntaxTree::Parser.new('class Synvert; end').parse.statements.body.first
+  #     node = SyntaxTree.parse('class Synvert; end').statements.body.first
   #     rewritten_source(node, '{{constant}}') # 'Synvert'
   #
   #     # index for node array
-  #     node = SyntaxTree::Parser.new("foo.bar(a, b)").parse.statements.body.first
+  #     node = SyntaxTree.parse("foo.bar(a, b)").statements.body.first
   #     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
+  #     node = SyntaxTree.parse("after_commit :do_index, on: :create, if: :indexable?").statements.body.first
   #     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
+  #     node = SyntaxTree.parse("after_commit :do_index, on: :create, if: :indexable?").statements.body.first
   #     rewritten_source(node, '{{arguments.parts.-1.on_value}}')) # ':create'
   #
   #     # to_single_quote for StringLiteral node
-  #     node = SyntaxTree::Parser.new('"foo"').parse.statements.body.first
+  #     node = SyntaxTree.parse('"foo"').statements.body.first
   #     rewritten_source(node, 'to_single_quote') # "'foo'"
   #
   #     # to_double_quote for StringLiteral node
-  #     node = SyntaxTree::Parser.new("'foo'").parse.statements.body.first
+  #     node = SyntaxTree.parse("'foo'").statements.body.first
   #     rewritten_source(node, 'to_double_quote') # '"foo"'
   #
   #     # to_symbol for StringLiteral node
-  #     node = SyntaxTree::Parser.new("'foo'").parse.statements.body.first
+  #     node = SyntaxTree.parse("'foo'").statements.body.first
   #     rewritten_source(node, 'to_symbol') # ':foo'
   #
   #     # to_string for SymbolLiteral node
-  #     node = SyntaxTree::Parser.new(":foo").parse.statements.body.first
+  #     node = SyntaxTree.parse(":foo").statements.body.first
   #     rewritten_source(node, 'to_string') # 'foo'
   #
   #     # to_lambda_literal for MethodAddBlock node
-  #     node = SyntaxTree::Parser.new('lambda { foobar }').parse.statements.body.first
+  #     node = SyntaxTree.parse('lambda { foobar }').statements.body.first
   #     rewritten_source(node, 'to_lambda_literal') # '-> { foobar }'
   #
   #     # strip_curly_braces for HashLiteral node
-  #     node = SyntaxTree::Parser.new("{ foo: 'bar' }").parse.statements.body.first
+  #     node = SyntaxTree.parse("{ foo: 'bar' }").statements.body.first
   #     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
+  #     node = SyntaxTree.parse("test(foo: 'bar')").statements.body.first
   #     rewritten_source(node.arguments.arguments.parts.first, 'wrap_curly_braces') # "{ foo: 'bar' }"
   def rewritten_source(node, code)
     code.gsub(/{{(.+?)}}/m) do
@@ -100,19 +100,19 @@ class NodeMutation::SyntaxTreeAdapter < NodeMutation::Adapter
   # @param child_name [String] THe name to find child node.
   # @return {NodeMutation::Struct::Range} The range of the child node.
   # @example
-  #     node = SyntaxTree::Parser.new('foo.bar(test)').parse.statements.body.first
+  #     node = SyntaxTree.parse('foo.bar(test)').statements.body.first
   #     child_node_range(node, 'receiver') # { start: 0, end: 'foo'.length }
   #
   #     # node array
-  #     node = SyntaxTree::Parser.new('foo.bar(a, b)').parse.statements.body.first
+  #     node = SyntaxTree.parse('foo.bar(a, b)').statements.body.first
   #     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
+  #     node = SyntaxTree.parse('foo.bar(a, b)').statements.body.first
   #     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
+  #     node = SyntaxTree.parse('foo | bar').statements.body.first
   #     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/version.rb

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

data/lib/node_mutation.rb

@@ -7,9 +7,9 @@ class NodeMutation
   class ConflictActionError < StandardError; end
   class InvalidAdapterError < StandardError; end
 
-  autoload :Actionable, "node_mutation/actionable"
   autoload :Adapter, "node_mutation/adapter"
   autoload :ParserAdapter, "node_mutation/adapter/parser"
+  autoload :PrismAdapter, "node_mutation/adapter/prism"
   autoload :SyntaxTreeAdapter, "node_mutation/adapter/syntax_tree"
   autoload :Action, 'node_mutation/action'
   autoload :AppendAction, 'node_mutation/action/append_action'
@@ -27,8 +27,6 @@ class NodeMutation
   autoload :Struct, 'node_mutation/struct'
   autoload :Helper, 'node_mutation/helper'
 
-  include Actionable
-
   # @!attribute [r] actions
   #   @return [Array<NodeMutation::Struct::Action>]
   attr_reader :actions, :adapter
@@ -74,6 +72,182 @@ class NodeMutation
     @adapter = get_adapter_instance(adapter)
   end
 
+  # Append code to the ast node.
+  # @param node [Node] ast node
+  # @param code [String] new code to append
+  # @example
+  # source code of the ast node is
+  #     def teardown
+  #       clean_something
+  #     end
+  # then we call
+  #     mutation.append(node, 'super')
+  # the source code will be rewritten to
+  #     def teardown
+  #       clean_something
+  #       super
+  #     end
+  def append(node, code)
+    @actions << AppendAction.new(node, code, adapter: @adapter).process
+  end
+
+  # Delete source code of the child ast node.
+  # @param node [Node] ast node
+  # @param selectors [Array<Symbol>] selector names of child node.
+  # @param and_comma [Boolean] delete extra comma.
+  # @example
+  # source code of the ast node is
+  #     FactoryBot.create(...)
+  # then we call
+  #     mutation.delete(node, :receiver, :dot)
+  # the source code will be rewritten to
+  #     create(...)
+  def delete(node, *selectors, and_comma: false)
+    @actions << DeleteAction.new(node, *selectors, and_comma: and_comma, adapter: @adapter).process
+  end
+
+  # Insert code to the ast node.
+  # @param node [Node] ast node
+  # @param code [String] code need to be inserted.
+  # @param at [String] insert position, beginning or end
+  # @param to [String] where to insert, if it is nil, will insert to current node.
+  # @param and_comma [Boolean] insert extra comma.
+  # @example
+  # source code of the ast node is
+  #     open('http://test.com')
+  # then we call
+  #     mutation.insert(node, 'URI.', at: 'beginning')
+  # the source code will be rewritten to
+  #     URI.open('http://test.com')
+  def insert(node, code, at: 'end', to: nil, and_comma: false)
+    @actions << InsertAction.new(node, code, at: at, to: to, and_comma: and_comma, adapter: @adapter).process
+  end
+
+  # Prepend code to the ast node.
+  # @param node [Node] ast node
+  # @param code [String] new code to prepend.
+  # @example
+  # source code of the ast node is
+  #     def setup
+  #       do_something
+  #     end
+  # then we call
+  #     mutation.prepend(node, 'super')
+  # the source code will be rewritten to
+  #     def setup
+  #       super
+  #       do_something
+  #     end
+  def prepend(node, code)
+    @actions << PrependAction.new(node, code, adapter: @adapter).process
+  end
+
+  # Remove source code of the ast node.
+  # @param node [Node] ast node
+  # @param and_comma [Boolean] delete extra comma.
+  # @example
+  # source code of the ast node is
+  #     puts "test"
+  # then we call
+  #     mutation.remove(node)
+  # the source code will be removed
+  def remove(node, and_comma: false)
+    @actions << RemoveAction.new(node, and_comma: and_comma, adapter: @adapter).process
+  end
+
+  # Replace child node of the ast node with new code.
+  # @param node [Node] ast node
+  # @param selectors [Array<Symbol>] selector names of child node.
+  # @param with [String] code need to be replaced with.
+  # @example
+  # source code of the ast node is
+  #     assert(object.empty?)
+  # then we call
+  #     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, adapter: @adapter).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.
+  # @example
+  # source code of the ast node is
+  #     obj.stub(:foo => 1, :bar => 2)
+  # then we call
+  #     replace_with 'allow({{receiver}}).to receive_messages({{arguments}})'
+  # the source code will be rewritten to
+  #     allow(obj).to receive_messages(:foo => 1, :bar => 2)
+  def replace_with(node, code)
+    @actions << ReplaceWithAction.new(node, code, adapter: @adapter).process
+  end
+
+  # Wrap source code of the ast node with prefix and suffix code.
+  # @param node [Node] ast node
+  # @param prefix [String] prefix code need to be wrapped with.
+  # @param suffix [String] suffix code need to be wrapped with.
+  # @param newline [Boolean] add newline after prefix and before suffix.
+  # @example
+  # source code of the ast node is
+  #     class Foobar
+  #     end
+  # then we call
+  #     wrap(node, prefix: 'module Synvert', suffix: 'end', newline: true)
+  # the source code will be rewritten to
+  #     module Synvert
+  #       class Foobar
+  #       end
+  #     end
+  def wrap(node, prefix:, suffix:, newline: false)
+    if newline
+      indentation = @adapter.get_start_loc(node).column
+      group do
+        insert node, prefix + "\n" + (' ' * indentation), at: 'beginning'
+        insert node, "\n" + (' ' * indentation) + suffix, at: 'end'
+        indent node
+      end
+    else
+      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, adapter: @adapter).process
+  end
+
+  # No operation.
+  # @param node [Node] ast node
+  def noop(node)
+    @actions << NoopAction.new(node, adapter: @adapter).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,

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: node_mutation
 version: !ruby/object:Gem::Version
-  version: 1.22.3
+  version: 1.23.0
 platform: ruby
 authors:
 - Richard Huang
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-01-30 00:00:00.000000000 Z
+date: 2024-02-11 00:00:00.000000000 Z
 dependencies: []
 description: ast node mutation apis
 email:
@@ -37,9 +37,9 @@ files:
 - lib/node_mutation/action/remove_action.rb
 - lib/node_mutation/action/replace_action.rb
 - lib/node_mutation/action/replace_with_action.rb
-- lib/node_mutation/actionable.rb
 - lib/node_mutation/adapter.rb
 - lib/node_mutation/adapter/parser.rb
+- lib/node_mutation/adapter/prism.rb
 - lib/node_mutation/adapter/syntax_tree.rb
 - lib/node_mutation/helper.rb
 - lib/node_mutation/result.rb

data/lib/node_mutation/actionable.rb

@@ -1,181 +0,0 @@
-# frozen_string_literal: true
-
-module NodeMutation::Actionable
-  # Append code to the ast node.
-  # @param node [Node] ast node
-  # @param code [String] new code to append
-  # @example
-  # source code of the ast node is
-  #     def teardown
-  #       clean_something
-  #     end
-  # then we call
-  #     mutation.append(node, 'super')
-  # the source code will be rewritten to
-  #     def teardown
-  #       clean_something
-  #       super
-  #     end
-  def append(node, code)
-    @actions << NodeMutation::AppendAction.new(node, code, adapter: @adapter).process
-  end
-
-  # Delete source code of the child ast node.
-  # @param node [Node] ast node
-  # @param selectors [Array<Symbol>] selector names of child node.
-  # @param and_comma [Boolean] delete extra comma.
-  # @example
-  # source code of the ast node is
-  #     FactoryBot.create(...)
-  # then we call
-  #     mutation.delete(node, :receiver, :dot)
-  # the source code will be rewritten to
-  #     create(...)
-  def delete(node, *selectors, and_comma: false)
-    @actions << NodeMutation::DeleteAction.new(node, *selectors, and_comma: and_comma, adapter: @adapter).process
-  end
-
-  # Insert code to the ast node.
-  # @param node [Node] ast node
-  # @param code [String] code need to be inserted.
-  # @param at [String] insert position, beginning or end
-  # @param to [String] where to insert, if it is nil, will insert to current node.
-  # @param and_comma [Boolean] insert extra comma.
-  # @example
-  # source code of the ast node is
-  #     open('http://test.com')
-  # then we call
-  #     mutation.insert(node, 'URI.', at: 'beginning')
-  # the source code will be rewritten to
-  #     URI.open('http://test.com')
-  def insert(node, code, at: 'end', to: nil, and_comma: false)
-    @actions << NodeMutation::InsertAction.new(
-      node,
-      code,
-      at: at,
-      to: to,
-      and_comma: and_comma,
-      adapter: @adapter
-    ).process
-  end
-
-  # Prepend code to the ast node.
-  # @param node [Node] ast node
-  # @param code [String] new code to prepend.
-  # @example
-  # source code of the ast node is
-  #     def setup
-  #       do_something
-  #     end
-  # then we call
-  #     mutation.prepend(node, 'super')
-  # the source code will be rewritten to
-  #     def setup
-  #       super
-  #       do_something
-  #     end
-  def prepend(node, code)
-    @actions << NodeMutation::PrependAction.new(node, code, adapter: @adapter).process
-  end
-
-  # Remove source code of the ast node.
-  # @param node [Node] ast node
-  # @param and_comma [Boolean] delete extra comma.
-  # @example
-  # source code of the ast node is
-  #     puts "test"
-  # then we call
-  #     mutation.remove(node)
-  # the source code will be removed
-  def remove(node, and_comma: false)
-    @actions << NodeMutation::RemoveAction.new(node, and_comma: and_comma, adapter: @adapter).process
-  end
-
-  # Replace child node of the ast node with new code.
-  # @param node [Node] ast node
-  # @param selectors [Array<Symbol>] selector names of child node.
-  # @param with [String] code need to be replaced with.
-  # @example
-  # source code of the ast node is
-  #     assert(object.empty?)
-  # then we call
-  #     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 << NodeMutation::ReplaceAction.new(node, *selectors, with: with, adapter: @adapter).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.
-  # @example
-  # source code of the ast node is
-  #     obj.stub(:foo => 1, :bar => 2)
-  # then we call
-  #     replace_with 'allow({{receiver}}).to receive_messages({{arguments}})'
-  # the source code will be rewritten to
-  #     allow(obj).to receive_messages(:foo => 1, :bar => 2)
-  def replace_with(node, code)
-    @actions << NodeMutation::ReplaceWithAction.new(node, code, adapter: @adapter).process
-  end
-
-  # Wrap source code of the ast node with prefix and suffix code.
-  # @param node [Node] ast node
-  # @param prefix [String] prefix code need to be wrapped with.
-  # @param suffix [String] suffix code need to be wrapped with.
-  # @param newline [Boolean] add newline after prefix and before suffix.
-  # @example
-  # source code of the ast node is
-  #     class Foobar
-  #     end
-  # then we call
-  #     wrap(node, prefix: 'module Synvert', suffix: 'end', newline: true)
-  # the source code will be rewritten to
-  #     module Synvert
-  #       class Foobar
-  #       end
-  #     end
-  def wrap(node, prefix:, suffix:, newline: false)
-    if newline
-      indentation = @adapter.get_start_loc(node).column
-      group do
-        insert node, prefix + "\n" + (' ' * indentation), at: 'beginning'
-        insert node, "\n" + (' ' * indentation) + suffix, at: 'end'
-        indent node
-      end
-    else
-      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 << NodeMutation::IndentAction.new(node, adapter: @adapter).process
-  end
-
-  # No operation.
-  # @param node [Node] ast node
-  def noop(node)
-    @actions << NodeMutation::NoopAction.new(node, adapter: @adapter).process
-  end
-
-  # group multiple actions
-  def group(&block)
-    @actions << NodeMutation::GroupAction.new(adapter: @adapter, &block).process
-  end
-end