node_mutation 1.19.2 → 1.19.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ec537b5f02531d1a6134c09db1be0d0845226a231da01cbda1e9331103a04fb3
-  data.tar.gz: f5cf6c624b25b08de8ea2f82c46401a3ce530c58720fa47cac11f04445c11894
+  metadata.gz: 9058cbdb6c979c921d77499277354922b7488da6315b85b368c8f0c14b7bf27e
+  data.tar.gz: 9f64d3bdb87aa025cf6362127a1170a014f28ec2ec7e04d88756bcd50744429e
 SHA512:
-  metadata.gz: 7d491e39ed40c9392c0bd4b1ca47cb2d6078756526b85d2ff5a01b9b5c7ec4cf452fe14c502a1066c878a00d532d88152d026e367b67b8c2de6904577e0c3ef0
-  data.tar.gz: d0946badaef12e2bc7701df604d7186174f72cc74d7dc797e38a82f20e05cfd6c07ea6d677c818bc16db583b735f4ae5652c799b7df2d664463977bd524d7b71
+  metadata.gz: c3d8f491d11179cd203167ef7a76b87ea16fdfb0f2454afeb0600d4fb97147a9e237d2f1b86f8432643971b4a00016b1d143813572c49eba0e1d58b58f7c6f81
+  data.tar.gz: e1c15e3f180186f28486cc14f3d4ebd0ee132c22d9128058e709d545b2c7bb7dae13529c7b74163427e3bfc3f0bb80eb3b73e74b34e4847ae3c0d0dd955d40e1

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 # NodeMutation
 
+## 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
+
 ## 1.19.2 (2023-06-30)
 
 * Support `operator` of `Binary` node in `child_node_range`

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    node_mutation (1.19.2)
+    node_mutation (1.19.4)
 
 GEM
   remote: https://rubygems.org/
@@ -34,14 +34,16 @@ GEM
     notiffany (0.1.3)
       nenv (~> 0.1)
       shellany (~> 0.0)
-    parser (3.2.2.1)
+    parser (3.2.2.3)
       ast (~> 2.4.1)
-    parser_node_ext (1.1.0)
+      racc
+    parser_node_ext (1.2.0)
       parser
     prettier_print (1.2.1)
     pry (0.14.1)
       coderay (~> 1.1)
       method_source (~> 1.0)
+    racc (1.7.1)
     rake (13.0.6)
     rb-fsevent (0.11.1)
     rb-inotify (0.10.1)
@@ -62,7 +64,7 @@ GEM
     shellany (0.0.1)
     syntax_tree (6.1.1)
       prettier_print (>= 1.2.0)
-    syntax_tree_ext (0.6.1)
+    syntax_tree_ext (0.6.3)
       syntax_tree
     thor (1.2.1)
 

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)
 
@@ -177,6 +177,7 @@ class NodeMutation::ParserAdapter < NodeMutation::Adapter
       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)
@@ -281,7 +282,7 @@ class NodeMutation::ParserAdapter < NodeMutation::Adapter
     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
+      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

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,28 +101,42 @@ 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)
-    child_node = child_node_by_name(node, child_name)
-    return nil if child_node.nil?
+    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_char, child_node.location.end_char)
+      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
 
-    if child_node.is_a?(Array)
-      return NodeMutation::Struct::Range.new(child_node.first.location.start_char, child_node.last.location.end_char)
+      return NodeMutation::Struct::Range.new(child_node.location.start_char, child_node.location.end_char)
     end
 
-    if node.is_a?(SyntaxTree::Binary) && child_name == 'operator'
+    if node.is_a?(SyntaxTree::Binary) && child_name.to_sym == :operator
       start_char = node.left.location.end_char
       start_char += 1 while node.source[start_char] == ' '
       end_char = node.right.location.start_char
@@ -130,7 +144,24 @@ class NodeMutation::SyntaxTreeAdapter < NodeMutation::Adapter
       return NodeMutation::Struct::Range.new(start_char, end_char)
     end
 
-    return NodeMutation::Struct::Range.new(child_node.location.start_char, child_node.location.end_char)
+    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?(SyntaxTree::Node)
+      return(
+        NodeMutation::Struct::Range.new(child_node.location.start_char, child_node.location.end_char)
+      )
+    end
+
+    return(
+      NodeMutation::Struct::Range.new(child_node.first.location.start_char, child_node.last.location.end_char)
+    )
   end
 
   def get_start(node, child_name = nil)
@@ -195,7 +226,7 @@ class NodeMutation::SyntaxTreeAdapter < NodeMutation::Adapter
       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 }}"
+        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 }

data/lib/node_mutation/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: node_mutation
 version: !ruby/object:Gem::Version
-  version: 1.19.2
+  version: 1.19.4
 platform: ruby
 authors:
 - Richard Huang
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-06-30 00:00:00.000000000 Z
+date: 2023-08-17 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.13
+rubygems_version: 3.4.18
 signing_key:
 specification_version: 4
 summary: ast node mutation apis