parser.rb in node_mutation-1.19.4

- old
+ new

@@ -13,57 +13,57 @@
     else
       node.loc.expression.source
     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)
       evaluated = child_node_by_name(node, old_code)
       case evaluated
@@ -80,11 +80,11 @@
           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[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
             source
           end
@@ -107,43 +107,43 @@
   # @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 }
+  #     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)
 
     if node.is_a?(Array)
       if direct_child_name =~ INDEX_REGEXP