node_mutation 1.18.2 → 1.19.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 66c10f74e41d63887a03af240cdfe99086395505ef43e14dab21f9d7ece562ac
-  data.tar.gz: 73728f0f84e095b7f97b65511cbd75fc01bcb7b8e9f2a56965dda31bfb7da622
+  metadata.gz: f0f3e24e2bcc4c8de744080aeccf3b82741534b6d5681c582d4ea91318b156b5
+  data.tar.gz: 33a39316e45592619c5ad3d520c6cb42411e41b6704bc1c52d840e0414c46322
 SHA512:
-  metadata.gz: 030fff9b3477f6c8f35454f01cf24f430b1bcabd9f2002c97ebb6f7579db777432e3cddd40bb2c188bcedfab408c255b8aa554a03410df375b51e0ad498d6240
-  data.tar.gz: 34078dd910cacc649c23334d13dea818d728cef40d7b130325b204bfb34ec46a07691bb98c94c6223c5d40cf808db1e83002473907ca94dededc661652b0bf85
+  metadata.gz: 0064ba628586533f3687a2af1cdbfbd0af32a274bc127e7da97d72c5b4d7517c1f0a8658fba363762ede790b3ee1071fed6b702e75932f5e57719ff0a6f7c023
+  data.tar.gz: 231809db15865e3c260b2aa67edf5335968968299b5e5135571a12631bb90ed563fdd1a9cd59996d909acee42b4770b1ca98c58734fcee26ea1255a2eb525371

data/CHANGELOG.md

@@ -1,5 +1,20 @@
 # NodeMutation
 
+## 1.19.0 (2023-06-22)
+
+* Drop support for function in `child_node_by_name`
+* Add `to_symbol` function
+* Add `to_single_quote` function
+* Add `to_double_quote` function
+* Add `to_lambda_literal` function
+* Add `strip_curly_braces` function
+* Add `wrap_curly_braces` function
+* Add more comments
+
+## 1.18.3 (2023-06-03)
+
+* Fix rbs syntax
+
 ## 1.18.2 (2023-05-21)
 
 * Use `rindex` to calculate "do" index

data/Gemfile.lock

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

data/README.md

@@ -65,6 +65,19 @@ result.conflicted
 result.new_source
 ```
 
+## Evaluated Value
+
+NodeMutation supports to evaluate the value of the node, and use the evaluated value to rewrite the source code.
+
+```ruby
+source = 'after_commit :do_index, on: :create, if: :indexable?'
+node = Parser::CurrentRuby.parse(source)
+mutation.replace node, '{{arguments.-1.on_value}}', with: ':update'
+source # after_commit :do_index, on: :update, if: :indexable?
+```
+
+See more in [ParserAdapter](https://xinminlabs.github.io/node-mutation-ruby/NodeMutation/ParserAdapter.html) and [SyntaxTreeAdapter](https://xinminlabs.github.io/node-mutation-ruby/NodeMutation/SyntaxTreeAdapter.html)
+
 ## Configuration
 
 ### adapter

data/lib/node_mutation/action/indent_action.rb

@@ -17,7 +17,8 @@ class NodeMutation::IndentAction < NodeMutation::Action
   # @return [String] rewritten code.
   def new_code
     source = NodeMutation.adapter.get_source(@node)
-    source.each_line.map { |line| ' ' * NodeMutation.tab_width * @tab_size + line }.join
+    source.each_line.map { |line| (' ' * NodeMutation.tab_width * @tab_size) + line }
+          .join
   end
 
   private

data/lib/node_mutation/adapter/parser.rb

@@ -15,6 +15,49 @@ class NodeMutation::ParserAdapter < NodeMutation::Adapter
     end
   end
 
+  # It 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'
+  #
+  #     # index for node array
+  #     node = Parser::CurrentRuby.parse("test(foo, bar)")
+  #     rewritten_source(node, '{{arguments.0}}')).to eq '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'
+  #
+  #     # {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'
+  #
+  #     # to_single_quote for str node
+  #     node = Parser::CurrentRuby.parse('"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"'
+  #
+  #     # to_symbol for str node
+  #     node = Parser::CurrentRuby.parse("'foo'")
+  #     rewritten_source(node, 'to_symbol') => ':foo'
+  #
+  #     # to_lambda_literal for block node
+  #     node = Parser::CurrentRuby.parse('lambda { 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'"
+  #
+  #     # wrap_curly_braces for hash node
+  #     node = Parser::CurrentRuby.parse("test(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)
@@ -56,6 +99,46 @@ class NodeMutation::ParserAdapter < NodeMutation::Adapter
     node.loc.expression.source_buffer.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 = Parser::CurrentRuby.parse('Factory.define :user do; end')
+  #     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 }
+  #
+  #     # 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 }
+  #
+  #     # 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 }
+  #
+  #     # 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 }
+  #
+  #     # double_colon for const node
+  #     node = Parser::CurrentRuby.parse('Foo::Bar')
+  #     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 }
+  #
+  #     # dot for send and csend node
+  #     node = Parser::CurrentRuby.parse('foo.bar(test)')
+  #     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 }
   def child_node_range(node, child_name)
     direct_child_name, nested_child_name = child_name.to_s.split('.', 2)
 
@@ -88,25 +171,8 @@ class NodeMutation::ParserAdapter < NodeMutation::Adapter
           node.arguments.last.loc.expression.end_pos + 1
         )
       end
-    when %i[block arguments], %i[def arguments], %i[defs arguments]
-      if node.arguments.empty?
-        nil
-      else
-        NodeMutation::Struct::Range.new(
-          node.arguments.first.loc.expression.begin_pos,
-          node.arguments.last.loc.expression.end_pos
-        )
-      end
-    when %i[block body], %i[class body], %i[def body], %i[defs body], %i[module body]
-      if node.body.empty?
-        nil
-      else
-        NodeMutation::Struct::Range.new(
-          node.body.first.loc.expression.begin_pos,
-          node.body.last.loc.expression.end_pos
-        )
-      end
-    when %i[class name], %i[const name], %i[cvar name], %i[def name], %i[defs name], %i[gvar name], %i[ivar name], %i[lvar name]
+    when %i[class name], %i[const name], %i[cvar name], %i[def name], %i[defs name],
+         %i[gvar name], %i[ivar name], %i[lvar name]
       NodeMutation::Struct::Range.new(node.loc.name.begin_pos, node.loc.name.end_pos)
     when %i[const double_colon]
       NodeMutation::Struct::Range.new(node.loc.double_colon.begin_pos, node.loc.double_colon.end_pos)
@@ -208,8 +274,25 @@ class NodeMutation::ParserAdapter < NodeMutation::Adapter
 
     if node.respond_to?(direct_child_name)
       child_node = node.send(direct_child_name)
-    elsif direct_child_name.include?('(') && direct_child_name.include?(')')
-      child_node = node.instance_eval(direct_child_name)
+    elsif direct_child_name == 'to_symbol' && node.type == :str
+      child_node = ":#{node.to_value}"
+    elsif direct_child_name == 'to_single_quote' && node.type == :str
+      child_node = "'#{node.to_value}'"
+    elsif direct_child_name == 'to_double_quote' && node.type == :str
+      child_node = "\"#{node.to_value}\""
+    elsif direct_child_name == 'to_lambda_literal' && node.type == :block && node.caller.type == :send && node.caller.receiver.nil? && node.caller.message == :lambda
+      new_source = node.to_source
+      if node.arguments.size > 1
+        new_source = new_source[0...node.arguments.first.loc.expression.begin_pos - 2] + new_source[node.arguments.last.loc.expression.end_pos + 1..-1]
+        new_source = new_source.sub('lambda', "->(#{node.arguments.map(&:to_source).join(', ')})")
+      else
+        new_source = new_source.sub('lambda', '->')
+      end
+      child_node = new_source
+    elsif direct_child_name == 'strip_curly_braces' && node.type == :hash
+      child_node = node.to_source.sub(/^{(.*)}$/) { Regexp.last_match(1).strip }
+    elsif direct_child_name == 'wrap_curly_braces' && node.type == :hash
+      child_node = "{ #{node.to_source} }"
     else
       raise NodeMutation::MethodNotSupported, "#{direct_child_name} is not supported for #{get_source(node)}"
     end

data/lib/node_mutation/adapter/syntax_tree.rb

@@ -12,6 +12,49 @@ class NodeMutation::SyntaxTreeAdapter < NodeMutation::Adapter
     node.source[node.location.start_char...node.location.end_char]
   end
 
+  # It gets the new source code after evaluating the node.
+  # @param node [SyntaxTree::Node] The node to evaluate.
+  # @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
+  #     rewritten_source(node, '{{constant}}').to eq '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'
+  #
+  #     # {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'
+  #
+  #     # {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'
+  #
+  #     # to_single_quote for StringLiteral node
+  #     node = SyntaxTree::Parser.new('"foo"').parse.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
+  #     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'
+  #
+  #     # to_lambda_literal for MethodAddBlock node
+  #     node = SyntaxTree::Parser.new('lambda { foobar }').parse.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
+  #     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' }"
   def rewritten_source(node, code)
     code.gsub(/{{(.+?)}}/m) do
       old_code = Regexp.last_match(1)
@@ -48,6 +91,19 @@ class NodeMutation::SyntaxTreeAdapter < NodeMutation::Adapter
     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 = SyntaxTree::Parser.new('foo.bar(test)').parse.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
+  #     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 }
   def child_node_range(node, child_name)
     child_node = child_node_by_name(node, child_name)
     return nil if child_node.nil?
@@ -109,8 +165,22 @@ class NodeMutation::SyntaxTreeAdapter < NodeMutation::Adapter
 
     if node.respond_to?(direct_child_name)
       child_node = node.send(direct_child_name)
-    elsif direct_child_name.include?('(') && direct_child_name.include?(')')
-      child_node = node.instance_eval(direct_child_name)
+    elsif direct_child_name == 'to_symbol' && node.is_a?(SyntaxTree::StringLiteral)
+      child_node = ":#{node.to_value}"
+    elsif direct_child_name == 'to_single_quote' && node.is_a?(SyntaxTree::StringLiteral)
+      child_node = "'#{node.to_value}'"
+    elsif direct_child_name == 'to_double_quote' && node.is_a?(SyntaxTree::StringLiteral)
+      child_node = "\"#{node.to_value}\""
+    elsif direct_child_name == 'to_lambda_literal' && node.is_a?(SyntaxTree::MethodAddBlock) && node.call.message.value == 'lambda'
+      if node.block.block_var
+        child_node = "->(#{node.block.block_var.params.to_source}) {#{node.block.bodystmt.to_source}}"
+      else
+        child_node = "-> {#{node.block.bodystmt.to_source }}"
+      end
+    elsif direct_child_name == 'strip_curly_braces' && node.is_a?(SyntaxTree::HashLiteral)
+      child_node = node.to_source.sub(/^{(.*)}$/) { Regexp.last_match(1).strip }
+    elsif direct_child_name == 'wrap_curly_braces' && node.is_a?(SyntaxTree::BareAssocHash)
+      child_node = "{ #{node.to_source} }"
     else
       raise NodeMutation::MethodNotSupported, "#{direct_child_name} is not supported for #{get_source(node)}"
     end

data/lib/node_mutation/result.rb

@@ -19,7 +19,10 @@ class NodeMutation::Result
   end
 
   def actions=(actions)
-    @actions = actions.map { |action| NodeMutation::Struct::Action.new(action.type, action.start, action.end, action.new_code) }
+    @actions =
+      actions.map { |action|
+        NodeMutation::Struct::Action.new(action.type, action.start, action.end, action.new_code)
+      }
   end
 
   def to_json(*args)

data/lib/node_mutation/version.rb

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

data/lib/node_mutation.rb

@@ -208,8 +208,8 @@ 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 << InsertAction.new(node, prefix + "\n" + (' ' * indentation), at: 'beginning').process
+      @actions << InsertAction.new(node, "\n" + (' ' * indentation) + suffix, at: 'end').process
       @actions << IndentAction.new(node).process
     else
       @actions << InsertAction.new(node, prefix, at: 'beginning').process

data/sig/node_mutation/struct.rbs

@@ -1,18 +1,18 @@
 class NodeMutation::Struct
   class Action < ::Struct
-    prop :type, Symbol
-    prop :start, Integer
-    prop :end, Integer
-    prop :new_code, String
+    atr_accessor type (): Symbol
+    atr_accessor start (): Integer
+    atr_accessor end (): Integer
+    atr_accessor new_code (): String
   end
 
   class Location < ::Struct
-    prop :line, Integer
-    prop :column, Integer
+    atr_accessor line (): Integer
+    atr_accessor column (): Integer
   end
 
   class Range < ::Struct
-    prop :start, Integer
-    prop :end, Integer
+    atr_accessor start (): Integer
+    atr_accessor end (): Integer
   end
 end

data/sig/node_mutation.rbs

@@ -21,7 +21,7 @@ module NodeMutation[T]
 
   def append: (node: T, code: String) -> void
 
-  def delete: (node: T, *selectors: Array[String], **options: { and_comma: bool }) -> void
+  def delete: (node: T, selectors: Array[String], and_comma: bool) -> void
 
   def indent: (node: T, ?tab_size: Integer) -> void
 
@@ -29,9 +29,9 @@ module NodeMutation[T]
 
   def prepend: (node: T, code: String) -> void
 
-  def remove: (node: T, **options: { and_comma: bool }) -> void
+  def remove: (node: T, and_comma: bool) -> void
 
-  def replace: (node: T, *selectors: Array[String], with: String) -> void
+  def replace: (node: T, selectors: Array[String], with: String) -> void
 
   def replace_with: (node: T, code: String) -> void
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: node_mutation
 version: !ruby/object:Gem::Version
-  version: 1.18.2
+  version: 1.19.0
 platform: ruby
 authors:
 - Richard Huang
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-05-21 00:00:00.000000000 Z
+date: 2023-06-22 00:00:00.000000000 Z
 dependencies: []
 description: ast node mutation apis
 email:
@@ -70,7 +70,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.10
+rubygems_version: 3.4.13
 signing_key:
 specification_version: 4
 summary: ast node mutation apis