node_mutation 1.10.0 → 1.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: da3db727f8adbdcb8e54c74e8bcb2625a3d3969af1c166734d644aeb00c33d51
-  data.tar.gz: ad17f467d8cd3edfd1b9ba59656a2b457cfb5c9ebcb4f4df3a10c35bef93b0d7
+  metadata.gz: d41515d4be39619d95802e531496159773a1202de61c8fa3c3d269d2a72926da
+  data.tar.gz: 2bd0415eec90cb45cdc2dcfacce1cf6529fcdf9f12e6fcd44054aa273e4c4b0b
 SHA512:
-  metadata.gz: 3848188fda27a5d4f9663e664ac82e70d55bc643ddf89468925e01c29449d4015ca459b27203c0891e8052ce6ea4a134b70d2438d8f6d41c4fb89ed357bec24d
-  data.tar.gz: 5198f02dae89f72183a3863f2cf6f1ffa9738bdc931d8a2bd3c45d6d982f98840b047998fd2e89dc9afce00c535c98bc60a850c616d551b9e6f8a309777ea278
+  metadata.gz: 656c00012eac7a7b6d2229933fb7e08fd7f0f9a986e90f7db69cc5129097702a2850cdf5494c6f1dae3d6f7da9d0ba642ffd7eb4362517a5c0f465a0d49a52d3
+  data.tar.gz: 4faced52fd71462a10c54970afb4412858c355c96bf8713e132f886535d3a1309aa792bc1f4e946c0549492c351c9750fa3ab1d05c3ecd0fda0d58f84c98427f

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 # NodeMutation
 
+## 1.11.0 (2023-03-20)
+
+* Calculate position properly for `add_comma`
+* Add `and_comma` param to `insert` dsl
+
+## 1.10.1 (2023-03-13)
+
+* Remove `OpenStruct`, use `Struct` instead
+
 ## 1.10.0 (2023-03-01)
 
 * Support `variable` of `lvasgn`, `ivasgn`, `cvasgn`, and `gvasgn` node in `child_node_range`

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    node_mutation (1.10.0)
+    node_mutation (1.11.0)
       erubis
 
 GEM

data/lib/node_mutation/action/delete_action.rb

@@ -23,10 +23,10 @@ class NodeMutation::DeleteAction < NodeMutation::Action
   # Calculate the begin and end positions.
   def calculate_position
     @start = @selectors.map { |selector| NodeMutation.adapter.child_node_range(@node, selector) }
-                            .compact.map(&:start).min
+                       .compact.map(&:start).min
     @end = @selectors.map { |selector| NodeMutation.adapter.child_node_range(@node, selector) }
-                          .compact.map(&:end).max
-    squeeze_spaces
+                     .compact.map(&:end).max
     remove_comma if @and_comma
+    remove_whitespace
   end
 end

data/lib/node_mutation/action/insert_action.rb

@@ -8,17 +8,23 @@ class NodeMutation::InsertAction < NodeMutation::Action
   # @param code [String] to be inserted
   # @param at [String] position to insert, beginning or end
   # @param to [<nil|String>] name of child node
-  def initialize(node, code, at: 'end', to: nil)
+  # @param and_comma [Boolean] insert extra comma.
+  def initialize(node, code, at: 'end', to: nil, and_comma: false)
     super(node, code)
     @at = at
     @to = to
+    @and_comma = and_comma
   end
 
   # The rewritten source code.
   #
   # @return [String] rewritten code.
   def new_code
-    rewritten_source
+    if @and_comma
+      @at == 'end' ? ", #{rewritten_source}" : "#{rewritten_source}, "
+    else
+      rewritten_source
+    end
   end
 
   private

data/lib/node_mutation/action/remove_action.rb

@@ -21,15 +21,13 @@ class NodeMutation::RemoveAction < NodeMutation::Action
 
   # Calculate the begin the end positions.
   def calculate_position
+    @start = NodeMutation.adapter.get_start(@node)
+    @end = NodeMutation.adapter.get_end(@node)
+    remove_comma if @and_comma
+    remove_whitespace
     if take_whole_line?
-      @start = start_index
-      @end = end_index
+      remove_newline
       squeeze_lines
-    else
-      @start = NodeMutation.adapter.get_start(@node)
-      @end = NodeMutation.adapter.get_end(@node)
-      squeeze_spaces
-      remove_comma if @and_command
     end
   end
 
@@ -37,18 +35,50 @@ class NodeMutation::RemoveAction < NodeMutation::Action
   #
   # @return [Boolean]
   def take_whole_line?
-    NodeMutation.adapter.get_source(@node) == file_source[start_index...end_index].strip
+    NodeMutation.adapter.get_source(@node) == file_source[@start...@end].strip.chomp(',')
   end
 
-  # Get the start position of the line
-  def start_index
-    index = file_source[0..NodeMutation.adapter.get_start(@node)].rindex("\n")
-    index ? index + "\n".length : NodeMutation.adapter.get_start(@node)
+  def remove_newline
+    leading_count = 1
+    loop do
+      if file_source[@start - leading_count] == "\n"
+        break
+      elsif ["\t", ' '].include?(file_source[@start - leading_count])
+        leading_count += 1
+      else
+        break
+      end
+    end
+
+    trailing_count = 0
+    loop do
+      if file_source[@end + trailing_count] == "\n"
+        break
+      elsif ["\t", ' '].include?(file_source[@end + trailing_count])
+        trailing_count += 1
+      else
+        break
+      end
+    end
+
+    if file_source[@end + trailing_count] == "\n"
+      @end += trailing_count + 1
+    end
+
+    if file_source[@start - leading_count] == "\n"
+      @start -= leading_count - 1
+    end
   end
 
-  # Get the end position of the line
-  def end_index
-    index = file_source[NodeMutation.adapter.get_end(@node)..-1].index("\n")
-    index ? NodeMutation.adapter.get_end(@node) + index + "\n".length : NodeMutation.adapter.get_end(@node)
+  def squeeze_lines
+    lines = file_source.split("\n")
+    begin_line = NodeMutation.adapter.get_start_loc(@node).line
+    end_line = NodeMutation.adapter.get_end_loc(@node).line
+    before_line_is_blank = begin_line == 1 || lines[begin_line - 2] == ''
+    after_line_is_blank = lines[end_line] == ''
+
+    if lines.length > 1 && before_line_is_blank && after_line_is_blank
+      @end += "\n".length
+    end
   end
 end

data/lib/node_mutation/action/replace_action.rb

@@ -23,7 +23,9 @@ class NodeMutation::ReplaceAction < NodeMutation::Action
 
   # Calculate the begin the end positions.
   def calculate_position
-    @start = @selectors.map { |selector| NodeMutation.adapter.child_node_range(@node, selector).start }.min
-    @end = @selectors.map { |selector| NodeMutation.adapter.child_node_range(@node, selector).end }.max
+    @start = @selectors.map { |selector| NodeMutation.adapter.child_node_range(@node, selector).start }
+                       .min
+    @end = @selectors.map { |selector| NodeMutation.adapter.child_node_range(@node, selector).end }
+                     .max
   end
 end

data/lib/node_mutation/action/wrap_action.rb

@@ -20,7 +20,7 @@ class NodeMutation::WrapAction < NodeMutation::Action
   def new_code
     "#{@code}\n#{' ' * @indent}" +
       NodeMutation.adapter.get_source(@node).split("\n").map { |line| "  #{line}" }
-            .join("\n") +
+                  .join("\n") +
       "\n#{' ' * @indent}end"
   end
 

data/lib/node_mutation/action.rb

@@ -30,7 +30,8 @@ class NodeMutation::Action
   # @return [String] rewritten code.
   def new_code
     if rewritten_source.split("\n").length > 1
-      "\n\n" + rewritten_source.split("\n").map { |line| indent(@node) + line }.join("\n")
+      "\n\n" + rewritten_source.split("\n").map { |line| indent(@node) + line }
+                               .join("\n")
     else
       "\n" + indent(@node) + rewritten_source
     end
@@ -52,23 +53,14 @@ class NodeMutation::Action
     @rewritten_source ||= NodeMutation.adapter.rewritten_source(@node, @code)
   end
 
-  # Squeeze spaces from source code.
-  def squeeze_spaces
-    if file_source[@start - 1] == ' ' && [' ', "\n", ';'].include?(file_source[@end])
-      @start -= 1
-    end
-  end
-
-  # Squeeze empty lines from source code.
-  def squeeze_lines
-    lines = file_source.split("\n")
-    begin_line = NodeMutation.adapter.get_start_loc(@node).line
-    end_line = NodeMutation.adapter.get_end_loc(@node).line
-    before_line_is_blank = begin_line == 1 || lines[begin_line - 2] == ''
-    after_line_is_blank = lines[end_line] == ''
+  # remove unused whitespace.
+  # e.g. `foobar(foo, bar)`, if we remove `foo`, the whitespace should also be removed,
+  # the code should be changed to `foobar(bar)`.
+  def remove_whitespace
+    return unless [' ', '('].include?(file_source[@start - 1])
 
-    if lines.length > 1 && before_line_is_blank && after_line_is_blank
-      @end += "\n".length
+    while file_source[@end] == ' '
+      @end += 1
     end
   end
 
@@ -76,14 +68,28 @@ class NodeMutation::Action
   # e.g. `foobar(foo, bar)`, if we remove `foo`, the comma should also be removed,
   # the code should be changed to `foobar(bar)`.
   def remove_comma
-    if ',' == file_source[@start - 1]
-      @start -= 1
-    elsif ', ' == file_source[@start - 2, 2]
-      @start -= 2
-    elsif ', ' == file_source[@end, 2]
-      @end += 2
-    elsif ',' == file_source[@end]
-      @end += 1
+    leading_count = 1
+    loop do
+      if file_source[@start - leading_count] == ','
+        @start -= leading_count
+        return
+      elsif ["\n", "\r", "\t", ' '].include?(file_source[@start - leading_count])
+        leading_count += 1
+      else
+        break
+      end
+    end
+
+    trailing_count = 0
+    loop do
+      if file_source[@end + trailing_count] == ','
+        @end += trailing_count + 1
+        return
+      elsif file_source[@end + trailing_count] == ' '
+        trailing_count += 1
+      else
+        break
+      end
     end
   end
 

data/lib/node_mutation/location.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+NodeMutation::Location = Struct.new(:line, :column)

data/lib/node_mutation/parser_adapter.rb

@@ -5,6 +5,8 @@ INDEX_REGEXP = /\A-?\d+\z/
 class NodeMutation::ParserAdapter < NodeMutation::Adapter
   def get_source(node)
     if node.is_a?(Array)
+      return "" if node.empty?
+
       source = file_content(node.first)
       source[node.first.loc.expression.begin_pos...node.last.loc.expression.end_pos]
     else
@@ -64,53 +66,50 @@ class NodeMutation::ParserAdapter < NodeMutation::Adapter
     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
+        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 OpenStruct.new(start: child_node.loc.expression.begin_pos, end: child_node.loc.expression.end_pos)
+
+        return NodeMutation::Range.new(child_node.loc.expression.begin_pos, child_node.loc.expression.end_pos)
       end
 
-      raise NodeMutation::MethodNotSupported, "#{direct_child_name} is not supported for #{get_source(node)}" unless node.respond_to?(direct_child_name)
+      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 OpenStruct.new(
-        start: child_node.loc.expression.begin_pos,
-        end: child_node.loc.expression.end_pos
-      )
+
+      return NodeMutation::Range.new(child_node.loc.expression.begin_pos, child_node.loc.expression.end_pos)
     end
 
     case [node.type, child_name.to_sym]
     when %i[block pipes], %i[def parentheses], %i[defs parentheses]
-      OpenStruct.new(
-        start: node.arguments.first.loc.expression.begin_pos - 1,
-        end: node.arguments.last.loc.expression.end_pos + 1
-      )
+      NodeMutation::Range.new(node.arguments.first.loc.expression.begin_pos - 1, node.arguments.last.loc.expression.end_pos + 1)
     when %i[block arguments], %i[def arguments], %i[defs arguments]
-      OpenStruct.new(
-        start: node.arguments.first.loc.expression.begin_pos,
-        end: node.arguments.last.loc.expression.end_pos
-      )
+      NodeMutation::Range.new(node.arguments.first.loc.expression.begin_pos, node.arguments.last.loc.expression.end_pos)
     when %i[class name], %i[const name], %i[def name], %i[defs name]
-      OpenStruct.new(start: node.loc.name.begin_pos, end: node.loc.name.end_pos)
+      NodeMutation::Range.new(node.loc.name.begin_pos, node.loc.name.end_pos)
     when %i[defs dot]
-      OpenStruct.new(start: node.loc.operator.begin_pos, end: node.loc.operator.end_pos) if node.loc.operator
+      NodeMutation::Range.new(node.loc.operator.begin_pos, node.loc.operator.end_pos) if node.loc.operator
     when %i[defs self]
-      OpenStruct.new(start: node.loc.operator.begin_pos - 'self'.length, end: node.loc.operator.begin_pos)
+      NodeMutation::Range.new(node.loc.operator.begin_pos - 'self'.length, node.loc.operator.begin_pos)
     when %i[lvasgn variable], %i[ivasgn variable], %i[cvasgn variable], %i[gvasgn variable]
-      OpenStruct.new(start: node.loc.name.begin_pos, end: node.loc.name.end_pos)
+      NodeMutation::Range.new(node.loc.name.begin_pos, node.loc.name.end_pos)
     when %i[send dot], %i[csend dot]
-      OpenStruct.new(start: node.loc.dot.begin_pos, end: node.loc.dot.end_pos) if node.loc.dot
+      NodeMutation::Range.new(node.loc.dot.begin_pos, node.loc.dot.end_pos) if node.loc.dot
     when %i[send message], %i[csend message]
       if node.loc.operator
-        OpenStruct.new(start: node.loc.selector.begin_pos, end: node.loc.operator.end_pos)
+        NodeMutation::Range.new(node.loc.selector.begin_pos, node.loc.operator.end_pos)
       else
-        OpenStruct.new(start: node.loc.selector.begin_pos, end: node.loc.selector.end_pos)
+        NodeMutation::Range.new(node.loc.selector.begin_pos, node.loc.selector.end_pos)
       end
     when %i[send parentheses], %i[csend parentheses]
       if node.loc.begin && node.loc.end
-        OpenStruct.new(start: node.loc.begin.begin_pos, end: node.loc.end.end_pos)
+        NodeMutation::Range.new(node.loc.begin.begin_pos, node.loc.end.end_pos)
       end
     else
-      raise NodeMutation::MethodNotSupported, "#{direct_child_name} is not supported for #{get_source(node)}" unless node.respond_to?(direct_child_name)
+      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)
 
@@ -120,10 +119,7 @@ class NodeMutation::ParserAdapter < NodeMutation::Adapter
 
       if child_node.is_a?(Parser::AST::Node)
         return(
-          OpenStruct.new(
-            start: child_node.loc.expression.begin_pos,
-            end: child_node.loc.expression.end_pos
-          )
+          NodeMutation::Range.new(child_node.loc.expression.begin_pos, child_node.loc.expression.end_pos)
         )
       end
 
@@ -131,10 +127,7 @@ class NodeMutation::ParserAdapter < NodeMutation::Adapter
       return nil if child_node.empty?
 
       return(
-        OpenStruct.new(
-          start: child_node.first.loc.expression.begin_pos,
-          end: child_node.last.loc.expression.end_pos
-        )
+        NodeMutation::Range.new(child_node.first.loc.expression.begin_pos, child_node.last.loc.expression.end_pos)
       )
     end
   end
@@ -149,12 +142,12 @@ class NodeMutation::ParserAdapter < NodeMutation::Adapter
 
   def get_start_loc(node)
     begin_loc = node.loc.expression.begin
-    OpenStruct.new(line: begin_loc.line, column: begin_loc.column)
+    NodeMutation::Location.new(begin_loc.line, begin_loc.column)
   end
 
   def get_end_loc(node)
     end_loc = node.loc.expression.end
-    OpenStruct.new(line: end_loc.line, column: end_loc.column)
+    NodeMutation::Location.new(end_loc.line, end_loc.column)
   end
 
   def get_indent(node)
@@ -169,21 +162,26 @@ class NodeMutation::ParserAdapter < NodeMutation::Adapter
     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
+        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)
+      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.include?('(') && direct_child_name.include?(')')
-      child_node = eval("node.#{direct_child_name}")
+      child_node = node.instance_eval(direct_child_name)
     else
       raise NodeMutation::MethodNotSupported, "#{direct_child_name} is not supported for #{get_source(node)}"
     end

data/lib/node_mutation/range.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+NodeMutation::Range = Struct.new(:start, :end)

data/lib/node_mutation/result.rb

@@ -30,8 +30,12 @@ class NodeMutation::Result
   def to_hash
     hash = { file_path: file_path }
     @options.each do |key, value|
-      hash[key] = value.is_a?(Array) ? value.map { |action| action.to_h } : value
+      if key == :actions
+        hash[:actions] = value.map { |action| { start: action.start, end: action.end, new_code: action.new_code } }
+      else
+        hash[key] = value
+      end
     end
     hash
   end
-end
+end

data/lib/node_mutation/version.rb

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

data/lib/node_mutation.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'ostruct'
-
 require_relative "node_mutation/version"
 
 class NodeMutation
@@ -20,12 +18,14 @@ class NodeMutation
   autoload :ReplaceWithAction, 'node_mutation/action/replace_with_action'
   autoload :WrapAction, 'node_mutation/action/wrap_action'
   autoload :NoopAction, 'node_mutation/action/noop_action'
+  autoload :Range, 'node_mutation/range'
+  autoload :Location, 'node_mutation/location'
   autoload :Result, 'node_mutation/result'
   autoload :Strategy, 'node_mutation/strategy'
 
   attr_reader :actions
 
-  class <<self
+  class << self
     # Configure NodeMutation
     # @param [Hash] options options to configure
     # @option options [NodeMutation::Adapter] :adapter the adpater
@@ -92,8 +92,7 @@ class NodeMutation
   # Delete source code of the child ast node.
   # @param node [Node] ast node
   # @param selectors [Array<Symbol>] selector names of child node.
-  # @param options [Hash]
-  # @option and_comma [Boolean] delete extra comma.
+  # @param and_comma [Boolean] delete extra comma.
   # @example
   # source code of the ast node is
   #     FactoryBot.create(...)
@@ -101,8 +100,8 @@ class NodeMutation
   #     mutation.delete(node, :receiver, :dot)
   # the source code will be rewritten to
   #     create(...)
-  def delete(node, *selectors, **options)
-    @actions << DeleteAction.new(node, *selectors, **options).process
+  def delete(node, *selectors, and_comma: false)
+    @actions << DeleteAction.new(node, *selectors, and_comma: and_comma).process
   end
 
   # Insert code to the ast node.
@@ -110,6 +109,7 @@ class NodeMutation
   # @param code [String] code need to be inserted.
   # @param at [String] insert position, beginning or end
   # @param to [String] where to insert, if it is nil, will insert to current node.
+  # @param and_comma [Boolean] insert extra comma.
   # @example
   # source code of the ast node is
   #     open('http://test.com')
@@ -117,8 +117,8 @@ class NodeMutation
   #     mutation.insert(node, 'URI.', at: 'beginning')
   # the source code will be rewritten to
   #     URI.open('http://test.com')
-  def insert(node, code, at: 'end', to: nil)
-    @actions << InsertAction.new(node, code, at: at, to: to).process
+  def insert(node, code, at: 'end', to: nil, and_comma: false)
+    @actions << InsertAction.new(node, code, at: at, to: to, and_comma: and_comma).process
   end
 
   # Prepend code to the ast node.
@@ -142,16 +142,15 @@ class NodeMutation
 
   # Remove source code of the ast node.
   # @param node [Node] ast node
-  # @param options [Hash] options.
-  # @option and_comma [Boolean] delete extra comma.
+  # @param and_comma [Boolean] delete extra comma.
   # @example
   # source code of the ast node is
   #     puts "test"
   # then we call
   #     mutation.remove(node)
   # the source code will be removed
-  def remove(node, **options)
-    @actions << RemoveAction.new(node, **options).process
+  def remove(node, and_comma: false)
+    @actions << RemoveAction.new(node, and_comma: and_comma).process
   end
 
   # Replace child node of the ast node with new code.
@@ -220,21 +219,17 @@ class NodeMutation
       return NodeMutation::Result.new(affected: false, conflicted: false)
     end
 
-    conflict_actions = []
     source = +@source
     @actions.sort_by! { |action| [action.start, action.end] }
     conflict_actions = get_conflict_actions
     if conflict_actions.size > 0 && strategy?(Strategy::THROW_ERROR)
       raise ConflictActionError, "mutation actions are conflicted"
     end
+
     @actions.reverse_each do |action|
       source[action.start...action.end] = action.new_code if action.new_code
     end
-    NodeMutation::Result.new(
-      affected: true,
-      conflicted: !conflict_actions.empty?,
-      new_source: source
-    )
+    NodeMutation::Result.new(affected: true, conflicted: !conflict_actions.empty?, new_source: source)
   end
 
   # Test actions and return the actions.
@@ -249,17 +244,13 @@ class NodeMutation
       return NodeMutation::Result.new(affected: false, conflicted: false, actions: [])
     end
 
-    conflict_actions = []
     @actions.sort_by! { |action| [action.start, action.end] }
     conflict_actions = get_conflict_actions
     if conflict_actions.size > 0 && strategy?(Strategy::THROW_ERROR)
       raise ConflictActionError, "mutation actions are conflicted"
     end
-    NodeMutation::Result.new(
-      affected: true,
-      conflicted: !conflict_actions.empty?,
-      actions: format_actions(@actions)
-    )
+
+    NodeMutation::Result.new(affected: true, conflicted: !conflict_actions.empty?, actions: @actions)
   end
 
   private
@@ -294,8 +285,4 @@ class NodeMutation
   def strategy?(strategy)
     NodeMutation.strategy & strategy == strategy
   end
-
-  def format_actions(actions)
-    actions.map { |action| OpenStruct.new(start: action.start, end: action.end, new_code: action.new_code ) }
-  end
 end

data/node_mutation.gemspec

@@ -19,11 +19,12 @@ Gem::Specification.new do |spec|
 
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
-  spec.files = Dir.chdir(File.expand_path(__dir__)) do
-    `git ls-files -z`.split("\x0").reject do |f|
-      (f == __FILE__) || f.match(%r{\A(?:(?:bin|test|spec|features)/|\.(?:git|travis|circleci)|appveyor)})
+  spec.files =
+    Dir.chdir(File.expand_path(__dir__)) do
+      `git ls-files -z`.split("\x0").reject do |f|
+        (f == __FILE__) || f.match(%r{\A(?:(?:bin|test|spec|features)/|\.(?:git|travis|circleci)|appveyor)})
+      end
     end
-  end
   spec.bindir = "exe"
   spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]

data/sig/node_mutation/adapter.rbs

@@ -5,15 +5,15 @@ class NodeMutation::Adapter[T]
 
   def file_content: (node: T) -> String
 
-  def child_node_range: (node: T, child_name: String) -> OpenStruct
+  def child_node_range: (node: T, child_name: String) -> NodeMutation::Range
 
   def get_start: (node: T) -> Integer
 
   def get_end: (node: T) -> Integer
 
-  def get_start_loc: (node: T) -> OpenStruct
+  def get_start_loc: (node: T) -> NodeMutation::Location
 
-  def get_end_loc: (node: T) -> OpenStruct
+  def get_end_loc: (node: T) -> NodeMutation::Location
 
   def get_indent: (node: T) -> Integer
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: node_mutation
 version: !ruby/object:Gem::Version
-  version: 1.10.0
+  version: 1.11.0
 platform: ruby
 authors:
 - Richard Huang
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-03-01 00:00:00.000000000 Z
+date: 2023-03-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: erubis
@@ -51,7 +51,9 @@ files:
 - lib/node_mutation/action/replace_with_action.rb
 - lib/node_mutation/action/wrap_action.rb
 - lib/node_mutation/adapter.rb
+- lib/node_mutation/location.rb
 - lib/node_mutation/parser_adapter.rb
+- lib/node_mutation/range.rb
 - lib/node_mutation/result.rb
 - lib/node_mutation/strategy.rb
 - lib/node_mutation/version.rb
@@ -80,7 +82,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.1
+rubygems_version: 3.4.6
 signing_key:
 specification_version: 4
 summary: ast node mutation apis