node_mutation 1.18.3 → 1.19.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f841956c32adce81a0124670b81a180dc1a5c607946de843ee4ffb18df46eb59
-  data.tar.gz: 1f962b025780338e39f674d1a130a42ab85b7ed499630e77151ffb8cf8fcfbdc
+  metadata.gz: 07cffea51271875fe053793222f92ba3ed88fb977e90c875d7f6096b969de898
+  data.tar.gz: f532736d3c384703dca1cfa389b4cad86fb810d8b063540ad50774af649786c8
 SHA512:
-  metadata.gz: a67239ac105f6ba64aa52a67c228310e4b13a8b2f0076343f006faf562c0a4cf00d3eb83212fdd75d3c63421c8763a67a1afb2c067dceaf9e1fcd25d8fb935e5
-  data.tar.gz: 0b6c56d6114b997743a33e96c19976ceb9cdc15c0e1b515acf092e1275149c5ddb93359707700cca9b274decf1e73690ed12b23c8280eccda1500e9a5e88ccf4
+  metadata.gz: c900a66575d3c35780bf64f33aa3452a5cd558ba7e55cde46f0c322f5da8cf54f17b052683a71df74c51df7efda8e3626e451f987fd1ea5f3995afd3f72635f4
+  data.tar.gz: f2335ad6e3ad0a5dcd1ec36d0f595c114d703dea847f36d6b1235a4ceb1cc92e6fe27522cd941da0e34e3864ccb9abd169f9f83e02a9306ab6075f8d2ea1c09d

data/CHANGELOG.md

@@ -1,5 +1,20 @@
 # NodeMutation
 
+## 1.19.1 (2023-06-22)
+
+* Add `to_string` function
+
+## 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

data/Gemfile.lock

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

@@ -15,6 +15,53 @@ 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_string for sym node
+  #     node = Parser::CurrentRuby.parse(":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 }'
+  #
+  #     # 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 +103,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,27 +175,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]
-
       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)
@@ -210,8 +278,27 @@ 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_string' && node.type == :sym
+        child_node = node.to_value.to_s
+    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,53 @@ 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_string for SymbolLiteral node
+  #     node = SyntaxTree::Parser.new(":foo").parse.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
+  #     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 +95,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 +169,24 @@ 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_string' && node.is_a?(SyntaxTree::SymbolLiteral)
+      child_node = node.to_value.to_s
+    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/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: node_mutation
 version: !ruby/object:Gem::Version
-  version: 1.18.3
+  version: 1.19.1
 platform: ruby
 authors:
 - Richard Huang
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-06-03 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