node_mutation 1.22.4 → 1.23.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9485dffc945cb3b645d4abecc7f878550685459ccd2007845471651d6893e2f1
-  data.tar.gz: 0ab63429232abd2f357b2c791bb3e5bc66a4762ff4175d6444b8c51dbac99a5d
+  metadata.gz: d39b10154354f3e35da27b09c378c6d518f47e67249b08143bd452dad5c14292
+  data.tar.gz: d3f988104df2610c420c7d5622b3f18775e64f878a2978ebc48ca2dbccd3f783
 SHA512:
-  metadata.gz: fc326b1af7d3f13bdd91f24c59d3be4991c20cc751de9bf0b8d48be98dc44fa78c93b4a5ffc75eac2535437ad478a206d54342195737989c17d7eb4121624c8a
-  data.tar.gz: 92cea72b3327755abb2b789cd704809b46258c3a6cc7f7e9f8bac678e2907e93d7fe59e5abfd33308029bc71dee24a1d8e23cbf976f2a1d7d9648876d6e24b78
+  metadata.gz: d31f713b129027619f955d8fb96c41562a760d1203333ee6f552f3aed99f76350b0e705649428a249fb63db75c871a562199273f8f21f4956439b7391b9f365c
+  data.tar.gz: 16dfcebbf38b0ca70fa02a4e4d5b22ca2915cb2b74e2d77a3b1840ac5bd476bbcbb55d4824e88343fc44f86ee55ed306ea4c6f2e1a022a740660949ccd19a044

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 # NodeMutation
 
+## 1.23.1 (2024-02-16)
+
+* Get `PrismAdapter`
+* Get `CallNode#name` range
+
+## 1.23.0 (2024-02-11)
+
+* Support `prism`
+
 ## 1.22.4 (2024-01-30)
 
 * Revert "add action methods to GroupAction"

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.4)
+    node_mutation (1.23.1)
 
 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/adapter/prism.rb

@@ -0,0 +1,243 @@
+# 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")
+      NodeMutation::Struct::Range.new(node_loc.start_offset, node_loc.end_offset) if node_loc
+    elsif node.is_a?(Prism::CallNode) && child_name.to_sym == :name
+      NodeMutation::Struct::Range.new(node.message_loc.start_offset, node.message_loc.end_offset)
+    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?
+      return nil if child_node == []
+
+      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)
@@ -152,6 +152,7 @@ class NodeMutation::SyntaxTreeAdapter < NodeMutation::Adapter
     return child_node_range(child_node, nested_child_name) if nested_child_name
 
     return nil if child_node.nil?
+    return nil if child_node == []
 
     if child_node.is_a?(SyntaxTree::Node)
       return(

data/lib/node_mutation/version.rb

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

data/lib/node_mutation.rb

@@ -9,6 +9,7 @@ class NodeMutation
 
   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'
@@ -423,6 +424,8 @@ class NodeMutation
       ParserAdapter.new
     when :syntax_tree
       SyntaxTreeAdapter.new
+    when :prism
+      PrismAdapter.new
     else
       raise InvalidAdapterError, "adapter #{adapter} is not supported"
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: node_mutation
 version: !ruby/object:Gem::Version
-  version: 1.22.4
+  version: 1.23.1
 platform: ruby
 authors:
 - Richard Huang
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-01-30 00:00:00.000000000 Z
+date: 2024-02-16 00:00:00.000000000 Z
 dependencies: []
 description: ast node mutation apis
 email:
@@ -39,6 +39,7 @@ files:
 - lib/node_mutation/action/replace_with_action.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