evilution 0.28.0 → 0.29.0

data/lib/evilution/mutation.rb

@@ -74,22 +74,17 @@ class Evilution::Mutation
   private
 
   def compute_diff
-    original_lines = original_source.lines
-    mutated_lines = mutated_source.lines
-    diffs = ::Diff::LCS.diff(original_lines, mutated_lines)
-
+    diffs = ::Diff::LCS.diff(original_source.lines, mutated_source.lines)
     return "" if diffs.empty?
 
-    result = []
-    diffs.flatten(1).each do |change|
-      case change.action
-      when "-"
-        result << "- #{change.element.chomp}"
-      when "+"
-        result << "+ #{change.element.chomp}"
-      end
+    diffs.flatten(1).filter_map { |change| format_diff_change(change) }.join("\n")
+  end
+
+  def format_diff_change(change)
+    case change.action
+    when "-" then "- #{change.element.chomp}"
+    when "+" then "+ #{change.element.chomp}"
     end
-    result.join("\n")
   end
 
   def compute_unified_diff
@@ -97,15 +92,18 @@ class Evilution::Mutation
 
     original_lines = @slice.original.lines
     mutated_lines = @slice.mutated.lines
-    body = ::Diff::LCS.sdiff(original_lines, mutated_lines).map { |c| format_sdiff_change(c) }.join("\n")
     [
       "--- a/#{file_path}",
       "+++ b/#{file_path}",
       "@@ -#{line},#{original_lines.length} +#{line},#{mutated_lines.length} @@",
-      body
+      unified_diff_body(original_lines, mutated_lines)
     ].reject(&:empty?).join("\n")
   end
 
+  def unified_diff_body(original_lines, mutated_lines)
+    ::Diff::LCS.sdiff(original_lines, mutated_lines).map { |c| format_sdiff_change(c) }.join("\n")
+  end
+
   def format_sdiff_change(change)
     case change.action
     when "=" then " #{change.old_element.chomp}"

data/lib/evilution/mutator/base.rb

@@ -5,6 +5,9 @@ require "prism"
 require_relative "../mutator"
 
 class Evilution::Mutator::Base < Prism::Visitor
+  AffectedSlices = Data.define(:original, :mutated)
+  private_constant :AffectedSlices
+
   attr_reader :mutations
 
   def initialize(**_options)
@@ -28,25 +31,24 @@ class Evilution::Mutator::Base < Prism::Visitor
     return if @filter && @filter.skip?(node)
 
     surgery = Evilution::AST::SourceSurgeon.apply(
-      @file_source,
-      offset: offset,
-      length: length,
-      replacement: replacement
+      @file_source, offset: offset, length: length, replacement: replacement
     )
-    mutated_source = surgery.source
-
-    original_slice, mutated_slice = slice_affected_lines(
-      mutated_source: mutated_source,
+    slices = slice_affected_lines(
+      mutated_source: surgery.source,
       offset: offset,
       length: length,
       replacement_bytesize: replacement.bytesize
     )
 
-    @mutations << Evilution::Mutation.new(
+    @mutations << build_mutation_record(node, surgery, slices)
+  end
+
+  def build_mutation_record(node, surgery, slices)
+    Evilution::Mutation.new(
       subject: @subject,
       operator_name: self.class.operator_name,
-      sources: Evilution::Mutation::Sources.new(original: @file_source, mutated: mutated_source),
-      slice: Evilution::Mutation::Slice.new(original: original_slice, mutated: mutated_slice),
+      sources: Evilution::Mutation::Sources.new(original: @file_source, mutated: surgery.source),
+      slice: Evilution::Mutation::Slice.new(original: slices.original, mutated: slices.mutated),
       location: Evilution::Mutation::Location.new(
         file_path: @subject.file_path,
         line: node.location.start_line,
@@ -64,10 +66,10 @@ class Evilution::Mutator::Base < Prism::Visitor
     orig_line_end = line_end_byte(@file_source, [offset + length - 1, line_start].max)
     mut_line_end = line_end_byte(mutated_source, [offset + replacement_bytesize - 1, line_start].max)
 
-    [
-      @file_source.byteslice(line_start, orig_line_end - line_start),
-      mutated_source.byteslice(line_start, mut_line_end - line_start)
-    ]
+    AffectedSlices.new(
+      original: @file_source.byteslice(line_start, orig_line_end - line_start),
+      mutated: mutated_source.byteslice(line_start, mut_line_end - line_start)
+    )
   end
 
   def line_start_byte(source, offset)

data/lib/evilution/mutator/operator/argument_nil_substitution.rb

@@ -12,26 +12,23 @@ class Evilution::Mutator::Operator::ArgumentNilSubstitution < Evilution::Mutator
 
   def visit_call_node(node)
     args = node.arguments&.arguments
-
-    if mutable?(node, args)
-      args.each_index do |i|
-        parts = args.each_with_index.map { |a, j| j == i ? "nil" : a.slice }
-        replacement = parts.join(", ")
-
-        add_mutation(
-          offset: node.arguments.location.start_offset,
-          length: node.arguments.location.length,
-          replacement: replacement,
-          node: node
-        )
-      end
-    end
+    args.each_index { |i| emit_nil_substitution(node, args, i) } if mutable?(node, args)
 
     super
   end
 
   private
 
+  def emit_nil_substitution(node, args, i)
+    parts = args.each_with_index.map { |a, j| j == i ? "nil" : a.slice }
+    add_mutation(
+      offset: node.arguments.location.start_offset,
+      length: node.arguments.location.length,
+      replacement: parts.join(", "),
+      node: node
+    )
+  end
+
   def mutable?(node, args)
     args && args.length >= 1 && positional_only?(args) && node.name != :[]=
   end

data/lib/evilution/mutator/operator/argument_removal.rb

@@ -12,26 +12,23 @@ class Evilution::Mutator::Operator::ArgumentRemoval < Evilution::Mutator::Base
 
   def visit_call_node(node)
     args = node.arguments&.arguments
-
-    if mutable?(node, args)
-      args.each_index do |i|
-        remaining = args.each_with_index.filter_map { |a, j| a.slice if j != i }
-        replacement = remaining.join(", ")
-
-        add_mutation(
-          offset: node.arguments.location.start_offset,
-          length: node.arguments.location.length,
-          replacement:,
-          node:
-        )
-      end
-    end
+    args.each_index { |i| emit_argument_removal(node, args, i) } if mutable?(node, args)
 
     super
   end
 
   private
 
+  def emit_argument_removal(node, args, i)
+    remaining = args.each_with_index.filter_map { |a, j| a.slice if j != i }
+    add_mutation(
+      offset: node.arguments.location.start_offset,
+      length: node.arguments.location.length,
+      replacement: remaining.join(", "),
+      node: node
+    )
+  end
+
   def mutable?(node, args)
     args && args.length >= 2 && positional_only?(args) && node.name != :[]=
   end

data/lib/evilution/mutator/operator/begin_unwrap.rb

@@ -4,18 +4,30 @@ require_relative "../operator"
 
 class Evilution::Mutator::Operator::BeginUnwrap < Evilution::Mutator::Base
   def visit_begin_node(node)
-    return super if node.rescue_clause || node.else_clause || node.ensure_clause
-    return super if node.statements.nil?
-    return super if node.begin_keyword_loc.nil?
+    return super unless unwrappable?(node)
 
-    body_text = @file_source.byteslice(node.statements.location.start_offset, node.statements.location.length)
     add_mutation(
       offset: node.location.start_offset,
       length: node.location.length,
-      replacement: body_text,
+      replacement: body_text(node),
       node: node
     )
 
     super
   end
+
+  private
+
+  def unwrappable?(node)
+    return false if node.rescue_clause || node.else_clause || node.ensure_clause
+    return false if node.statements.nil?
+    return false if node.begin_keyword_loc.nil?
+
+    true
+  end
+
+  def body_text(node)
+    loc = node.statements.location
+    @file_source.byteslice(loc.start_offset, loc.length)
+  end
 end

data/lib/evilution/mutator/operator/bitwise_complement.rb

@@ -5,27 +5,34 @@ require_relative "../operator"
 class Evilution::Mutator::Operator::BitwiseComplement < Evilution::Mutator::Base
   def visit_call_node(node)
     if node.name == :~ && node.receiver && node.arguments.nil?
-      loc = node.message_loc
-      receiver_loc = node.receiver.location
-
-      # Remove ~: replace entire ~expr with just the receiver expression
-      receiver_source = byteslice_source(receiver_loc.start_offset, receiver_loc.length)
-      add_mutation(
-        offset: node.location.start_offset,
-        length: node.location.length,
-        replacement: receiver_source,
-        node: node
-      )
-
-      # Swap ~ with unary minus
-      add_mutation(
-        offset: loc.start_offset,
-        length: loc.length,
-        replacement: "-",
-        node: node
-      )
+      emit_remove_complement(node)
+      emit_swap_to_minus(node)
     end
 
     super
   end
+
+  private
+
+  # Replace `~expr` with just `expr`.
+  def emit_remove_complement(node)
+    receiver_loc = node.receiver.location
+    add_mutation(
+      offset: node.location.start_offset,
+      length: node.location.length,
+      replacement: byteslice_source(receiver_loc.start_offset, receiver_loc.length),
+      node: node
+    )
+  end
+
+  # Swap `~` with unary minus.
+  def emit_swap_to_minus(node)
+    loc = node.message_loc
+    add_mutation(
+      offset: loc.start_offset,
+      length: loc.length,
+      replacement: "-",
+      node: node
+    )
+  end
 end

data/lib/evilution/mutator/operator/block_param_removal.rb

@@ -38,14 +38,7 @@ class Evilution::Mutator::Operator::BlockParamRemoval < Evilution::Mutator::Base
   end
 
   def remove_block_param(node)
-    block_loc = node.parameters.block.location
-    params_text = @file_source.byteslice(node.parameters.location.start_offset, node.parameters.location.length)
-    block_rel = block_loc.start_offset - node.parameters.location.start_offset
-
-    # Find the comma before the block param and remove ", &block"
-    comma_pos = params_text.rindex(",", block_rel - 1)
-    remove_start = node.parameters.location.start_offset + comma_pos
-    remove_end = block_loc.start_offset + block_loc.length
+    remove_start, remove_end = block_param_removal_range(node)
 
     add_mutation(
       offset: remove_start,
@@ -54,4 +47,21 @@ class Evilution::Mutator::Operator::BlockParamRemoval < Evilution::Mutator::Base
       node: node
     )
   end
+
+  # Range covering ", &block" — from the comma before the block param to the end of the block param.
+  def block_param_removal_range(node)
+    params_loc = node.parameters.location
+    block_loc = node.parameters.block.location
+    comma_pos = params_text(params_loc).rindex(",", block_loc.start_offset - params_loc.start_offset - 1)
+
+    [params_loc.start_offset + comma_pos, end_offset(block_loc)]
+  end
+
+  def params_text(params_loc)
+    @file_source.byteslice(params_loc.start_offset, params_loc.length)
+  end
+
+  def end_offset(loc)
+    loc.start_offset + loc.length
+  end
 end

data/lib/evilution/mutator/operator/block_pass_removal.rb

@@ -4,27 +4,31 @@ require_relative "../operator"
 
 class Evilution::Mutator::Operator::BlockPassRemoval < Evilution::Mutator::Base
   def visit_call_node(node)
-    if node.block.is_a?(Prism::BlockArgumentNode)
-      block_node = node.block
-      call_start = node.location.start_offset
-      node_end = call_start + node.location.length
-      block_end = block_node.location.start_offset + block_node.location.length
-
-      prefix = @file_source.byteslice(call_start...block_node.location.start_offset).rstrip
-      suffix = @file_source.byteslice(block_end...node_end)
-
-      # Clean up: remove trailing comma from prefix, remove empty parens
-      prefix = prefix.sub(/,\s*\z/, "")
-      replacement = "#{prefix}#{suffix}".sub(/\(\s*\)/, "")
-
+    block_node = node.block
+    if block_node.is_a?(Prism::BlockArgumentNode)
       add_mutation(
-        offset: call_start,
+        offset: node.location.start_offset,
         length: node.location.length,
-        replacement: replacement,
+        replacement: build_replacement(node, block_node),
         node: node
       )
     end
 
     super
   end
+
+  private
+
+  # Drop the block-pass argument plus the trailing comma it leaves behind, and
+  # collapse the resulting `()` if the block-pass was the only argument.
+  def build_replacement(node, block_node)
+    call_start = node.location.start_offset
+    node_end = call_start + node.location.length
+    block_start = block_node.location.start_offset
+    block_end = block_start + block_node.location.length
+
+    prefix = @file_source.byteslice(call_start...block_start).rstrip.sub(/,\s*\z/, "")
+    suffix = @file_source.byteslice(block_end...node_end)
+    "#{prefix}#{suffix}".sub(/\(\s*\)/, "")
+  end
 end

data/lib/evilution/mutator/operator/case_when.rb

@@ -40,16 +40,18 @@ class Evilution::Mutator::Operator::CaseWhen < Evilution::Mutator::Base
   end
 
   def remove_else_branch(node)
-    return if node.else_clause.nil?
-    return if node.else_clause.statements.nil?
+    else_clause = node.else_clause
+    return if else_clause.nil? || else_clause.statements.nil?
+
+    start_offset = else_clause.else_keyword_loc.start_offset
+    stmts_loc = else_clause.statements.location
+    end_offset = stmts_loc.start_offset + stmts_loc.length
 
-    start_offset = node.else_clause.else_keyword_loc.start_offset
-    end_offset = node.else_clause.statements.location.start_offset + node.else_clause.statements.location.length
     add_mutation(
       offset: start_offset,
       length: end_offset - start_offset,
       replacement: "",
-      node: node.else_clause
+      node: else_clause
     )
   end
 end

data/lib/evilution/mutator/operator/conditional_branch.rb

@@ -4,29 +4,29 @@ require_relative "../operator"
 
 class Evilution::Mutator::Operator::ConditionalBranch < Evilution::Mutator::Base
   def visit_if_node(node)
-    if node.statements && node.subsequent.nil?
-      add_mutation(
-        offset: node.statements.location.start_offset,
-        length: node.statements.location.length,
-        replacement: "nil",
-        node: node
-      )
-    elsif node.statements && node.subsequent&.statements
-      add_mutation(
-        offset: node.statements.location.start_offset,
-        length: node.statements.location.length,
-        replacement: "nil",
-        node: node
-      )
-
-      add_mutation(
-        offset: node.subsequent.statements.location.start_offset,
-        length: node.subsequent.statements.location.length,
-        replacement: "nil",
-        node: node
-      )
-    end
+    return super unless node.statements
+
+    add_nil_mutation(node.statements, node)
+    add_nil_mutation_to_else(node.subsequent, node)
 
     super
   end
+
+  private
+
+  def add_nil_mutation_to_else(subsequent, node)
+    return unless subsequent.is_a?(Prism::ElseNode)
+    return if subsequent.statements.nil?
+
+    add_nil_mutation(subsequent.statements, node)
+  end
+
+  def add_nil_mutation(statements, node)
+    add_mutation(
+      offset: statements.location.start_offset,
+      length: statements.location.length,
+      replacement: "nil",
+      node: node
+    )
+  end
 end

data/lib/evilution/mutator/operator/equality_to_identity.rb

@@ -5,9 +5,8 @@ require_relative "../operator"
 class Evilution::Mutator::Operator::EqualityToIdentity < Evilution::Mutator::Base
   def visit_call_node(node)
     if node.name == :== && node.receiver && node.arguments
-      receiver_text = @file_source.byteslice(node.receiver.location.start_offset, node.receiver.location.length)
-      arg = node.arguments.arguments.first
-      arg_text = @file_source.byteslice(arg.location.start_offset, arg.location.length)
+      receiver_text = loc_text(node.receiver.location)
+      arg_text = loc_text(node.arguments.arguments.first.location)
 
       add_mutation(
         offset: node.location.start_offset,
@@ -19,4 +18,10 @@ class Evilution::Mutator::Operator::EqualityToIdentity < Evilution::Mutator::Bas
 
     super
   end
+
+  private
+
+  def loc_text(loc)
+    @file_source.byteslice(loc.start_offset, loc.length)
+  end
 end

data/lib/evilution/mutator/operator/explicit_super_mutation.rb

@@ -23,25 +23,29 @@ class Evilution::Mutator::Operator::ExplicitSuperMutation < Evilution::Mutator::
   end
 
   def mutate_arguments(node, args)
-    # Remove all arguments: super(a, b) -> super()
+    emit_remove_all_args(node)
+    return unless args.length >= 2
+
+    args.each_index { |i| emit_remove_arg_at(node, args, i) }
+  end
+
+  # super(a, b) -> super()
+  def emit_remove_all_args(node)
     add_mutation(
       offset: node.arguments.location.start_offset,
       length: node.arguments.location.length,
       replacement: "",
       node: node
     )
+  end
 
-    return unless args.length >= 2
-
-    # Remove individual arguments
-    args.each_index do |i|
-      remaining = args.each_with_index.filter_map { |a, j| a.slice if j != i }
-      add_mutation(
-        offset: node.arguments.location.start_offset,
-        length: node.arguments.location.length,
-        replacement: remaining.join(", "),
-        node: node
-      )
-    end
+  def emit_remove_arg_at(node, args, i)
+    remaining = args.each_with_index.filter_map { |a, j| a.slice if j != i }
+    add_mutation(
+      offset: node.arguments.location.start_offset,
+      length: node.arguments.location.length,
+      replacement: remaining.join(", "),
+      node: node
+    )
   end
 end

data/lib/evilution/mutator/operator/index_to_at.rb

@@ -5,13 +5,10 @@ require_relative "../operator"
 class Evilution::Mutator::Operator::IndexToAt < Evilution::Mutator::Base
   def visit_call_node(node)
     if indexable?(node)
-      receiver_source = @file_source.byteslice(node.receiver.location.start_offset, node.receiver.location.length)
-      arg_source = @file_source.byteslice(node.arguments.location.start_offset, node.arguments.location.length)
-
       add_mutation(
         offset: node.location.start_offset,
         length: node.location.length,
-        replacement: "#{receiver_source}.at(#{arg_source})",
+        replacement: "#{loc_text(node.receiver.location)}.at(#{loc_text(node.arguments.location)})",
         node: node
       )
     end
@@ -21,6 +18,10 @@ class Evilution::Mutator::Operator::IndexToAt < Evilution::Mutator::Base
 
   private
 
+  def loc_text(loc)
+    @file_source.byteslice(loc.start_offset, loc.length)
+  end
+
   def indexable?(node)
     node.name == :[] &&
       node.receiver &&

data/lib/evilution/mutator/operator/index_to_dig.rb

@@ -3,6 +3,9 @@
 require_relative "../operator"
 
 class Evilution::Mutator::Operator::IndexToDig < Evilution::Mutator::Base
+  Chain = Data.define(:root, :args)
+  private_constant :Chain
+
   def initialize(**options)
     super
     @consumed = Set.new
@@ -10,14 +13,11 @@ class Evilution::Mutator::Operator::IndexToDig < Evilution::Mutator::Base
 
   def visit_call_node(node)
     if chain_head?(node)
-      root, args = collect_chain(node)
-      root_source = byteslice_source(root.location.start_offset, root.location.length)
-      arg_sources = args.map { |a| byteslice_source(a.location.start_offset, a.location.length) }
-
+      chain = collect_chain(node)
       add_mutation(
         offset: node.location.start_offset,
         length: node.location.length,
-        replacement: "#{root_source}.dig(#{arg_sources.join(", ")})",
+        replacement: dig_replacement(chain),
         node: node
       )
     end
@@ -27,6 +27,12 @@ class Evilution::Mutator::Operator::IndexToDig < Evilution::Mutator::Base
 
   private
 
+  def dig_replacement(chain)
+    root_source = byteslice_source(chain.root.location.start_offset, chain.root.location.length)
+    arg_sources = chain.args.map { |a| byteslice_source(a.location.start_offset, a.location.length) }
+    "#{root_source}.dig(#{arg_sources.join(", ")})"
+  end
+
   def chain_head?(node)
     return false if @consumed.include?(node.object_id)
     return false unless single_arg_index?(node)
@@ -53,6 +59,6 @@ class Evilution::Mutator::Operator::IndexToDig < Evilution::Mutator::Base
       current = current.receiver
     end
 
-    [current, args]
+    Chain.new(root: current, args: args)
   end
 end

data/lib/evilution/mutator/operator/index_to_fetch.rb

@@ -5,13 +5,10 @@ require_relative "../operator"
 class Evilution::Mutator::Operator::IndexToFetch < Evilution::Mutator::Base
   def visit_call_node(node)
     if indexable?(node)
-      receiver_source = byteslice_source(node.receiver.location.start_offset, node.receiver.location.length)
-      arg_source = byteslice_source(node.arguments.location.start_offset, node.arguments.location.length)
-
       add_mutation(
         offset: node.location.start_offset,
         length: node.location.length,
-        replacement: "#{receiver_source}.fetch(#{arg_source})",
+        replacement: "#{loc_text(node.receiver.location)}.fetch(#{loc_text(node.arguments.location)})",
         node: node
       )
     end
@@ -21,6 +18,10 @@ class Evilution::Mutator::Operator::IndexToFetch < Evilution::Mutator::Base
 
   private
 
+  def loc_text(loc)
+    byteslice_source(loc.start_offset, loc.length)
+  end
+
   def indexable?(node)
     node.name == :[] &&
       node.receiver &&

data/lib/evilution/mutator/operator/keyword_argument.rb

@@ -56,36 +56,41 @@ class Evilution::Mutator::Operator::KeywordArgument < Evilution::Mutator::Base
     return unless kr.is_a?(Prism::KeywordRestParameterNode)
 
     all_params = collect_all_params(params)
-
     if all_params.length < 2
-      add_mutation(
-        offset: kr.location.start_offset,
-        length: kr.location.length,
-        replacement: "",
-        node: kr
-      )
+      emit_remove_only_kr(kr)
     else
-      remaining = all_params.reject { |p| p.equal?(kr) }
-      replacement = remaining.map(&:slice).join(", ")
-
-      add_mutation(
-        offset: params.location.start_offset,
-        length: params.location.length,
-        replacement: replacement,
-        node: kr
-      )
+      emit_remove_kr_with_remaining(params, all_params, kr)
     end
   end
 
+  def emit_remove_only_kr(kr)
+    add_mutation(
+      offset: kr.location.start_offset,
+      length: kr.location.length,
+      replacement: "",
+      node: kr
+    )
+  end
+
+  def emit_remove_kr_with_remaining(params, all_params, kr)
+    remaining = all_params.reject { |p| p.equal?(kr) }
+    add_mutation(
+      offset: params.location.start_offset,
+      length: params.location.length,
+      replacement: remaining.map(&:slice).join(", "),
+      node: kr
+    )
+  end
+
   def collect_all_params(params)
-    result = []
-    result.concat(params.requireds)
-    result.concat(params.optionals)
-    result << params.rest if params.rest
-    result.concat(params.posts)
-    result.concat(params.keywords)
-    result << params.keyword_rest if params.keyword_rest
-    result << params.block if params.block
-    result
+    [
+      *params.requireds,
+      *params.optionals,
+      params.rest,
+      *params.posts,
+      *params.keywords,
+      params.keyword_rest,
+      params.block
+    ].compact
   end
 end