evilution 0.27.0 → 0.29.0

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

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

@@ -13,27 +13,33 @@ class Evilution::Mutator::Operator::MixinRemoval < Evilution::Mutator::Base
     @mutations = []
     @filter = filter
 
-    tree = self.class.parsed_tree_for(subject.file_path, @file_source)
-    enclosing = find_enclosing_scope(tree, subject.line_number)
+    enclosing = find_target_scope(subject)
     return @mutations unless enclosing
 
-    first_method_line = find_first_method_line(enclosing)
-    return @mutations unless first_method_line == subject.line_number
-
-    find_mixin_calls(enclosing).each do |call_node|
-      add_mutation(
-        offset: call_node.location.start_offset,
-        length: call_node.location.length,
-        replacement: "",
-        node: call_node
-      )
-    end
-
+    find_mixin_calls(enclosing).each { |call_node| emit_mixin_removal(call_node) }
     @mutations
   end
 
   private
 
+  def find_target_scope(subject)
+    tree = self.class.parsed_tree_for(subject.file_path, @file_source)
+    enclosing = find_enclosing_scope(tree, subject.line_number)
+    return nil unless enclosing
+    return nil unless find_first_method_line(enclosing) == subject.line_number
+
+    enclosing
+  end
+
+  def emit_mixin_removal(call_node)
+    add_mutation(
+      offset: call_node.location.start_offset,
+      length: call_node.location.length,
+      replacement: "",
+      node: call_node
+    )
+  end
+
   def find_enclosing_scope(tree, target_line)
     finder = ScopeFinder.new(target_line)
     finder.visit(tree)

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

@@ -18,19 +18,18 @@ class Evilution::Mutator::Operator::MultipleAssignment < Evilution::Mutator::Bas
   private
 
   def mutate_target_removal(node, lefts, values)
-    lefts.each_index do |i|
-      remaining_lefts = lefts.each_with_index.filter_map { |l, j| l.slice if j != i }
-      remaining_values = values.each_with_index.filter_map { |v, j| v.slice if j != i }
-
-      replacement = "#{remaining_lefts.join(", ")} = #{remaining_values.join(", ")}"
-
-      add_mutation(
-        offset: node.location.start_offset,
-        length: node.location.length,
-        replacement: replacement,
-        node: node
-      )
-    end
+    lefts.each_index { |i| emit_target_removal_at(node, lefts, values, i) }
+  end
+
+  def emit_target_removal_at(node, lefts, values, i)
+    remaining_lefts = lefts.each_with_index.filter_map { |l, j| l.slice if j != i }
+    remaining_values = values.each_with_index.filter_map { |v, j| v.slice if j != i }
+    add_mutation(
+      offset: node.location.start_offset,
+      length: node.location.length,
+      replacement: "#{remaining_lefts.join(", ")} = #{remaining_values.join(", ")}",
+      node: node
+    )
   end
 
   def mutate_swap(node, lefts, values)

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+class Evilution::Mutator::Operator::PredicateToNil < Evilution::Mutator::Base
+  def visit_call_node(node)
+    if node.name.to_s.end_with?("?")
+      loc = node.location
+
+      add_mutation(
+        offset: loc.start_offset,
+        length: loc.length,
+        replacement: "nil",
+        node: node
+      )
+    end
+
+    super
+  end
+end

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

@@ -5,19 +5,22 @@ require_relative "../operator"
 class Evilution::Mutator::Operator::ReceiverReplacement < Evilution::Mutator::Base
   def visit_call_node(node)
     if node.receiver.is_a?(Prism::SelfNode)
-      call_without_self = @file_source.byteslice(
-        node.message_loc.start_offset,
-        node.location.start_offset + node.location.length - node.message_loc.start_offset
-      )
-
       add_mutation(
         offset: node.location.start_offset,
         length: node.location.length,
-        replacement: call_without_self,
+        replacement: call_without_self_text(node),
         node: node
       )
     end
 
     super
   end
+
+  private
+
+  def call_without_self_text(node)
+    message_start = node.message_loc.start_offset
+    call_end = node.location.start_offset + node.location.length
+    @file_source.byteslice(message_start, call_end - message_start)
+  end
 end

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

@@ -19,31 +19,21 @@ class Evilution::Mutator::Operator::RegexSimplification < Evilution::Mutator::Ba
   private
 
   def remove_quantifiers(node, content, content_offset)
-    i = 0
-    while i < content.length
-      if content[i] == "\\"
-        i += 2
-        next
+    scan_regex_positions(content) do |kind, i|
+      case kind
+      when :backslash then 2
+      when :class_open then class_skip(content, i)
+      when :char then emit_quantifier_at(node, content, content_offset, i)
       end
+    end
+  end
 
-      if content[i] == "["
-        i = skip_character_class(content, i)
-        next
-      end
+  def emit_quantifier_at(node, content, content_offset, i)
+    match = match_quantifier(content, i)
+    return 1 if match.nil?
 
-      match = match_quantifier(content, i)
-      if match
-        add_mutation(
-          offset: content_offset + i,
-          length: match.length,
-          replacement: "",
-          node: node
-        )
-        i += match.length
-      else
-        i += 1
-      end
-    end
+    add_mutation(offset: content_offset + i, length: match.length, replacement: "", node: node)
+    match.length
   end
 
   def match_quantifier(content, pos)
@@ -58,40 +48,29 @@ class Evilution::Mutator::Operator::RegexSimplification < Evilution::Mutator::Ba
   end
 
   def remove_anchors(node, content, content_offset)
-    i = 0
-    while i < content.length
-      if content[i] == "\\"
-        anchor = match_backslash_anchor(content, i)
-        if anchor
-          add_mutation(
-            offset: content_offset + i,
-            length: anchor.length,
-            replacement: "",
-            node: node
-          )
-          i += anchor.length
-        else
-          i += 2
-        end
-        next
+    scan_regex_positions(content) do |kind, i|
+      case kind
+      when :backslash then try_emit_backslash_anchor(node, content, content_offset, i)
+      when :class_open then class_skip(content, i)
+      when :char
+        try_emit_caret_dollar(node, content, content_offset, i)
+        1
       end
+    end
+  end
 
-      if content[i] == "["
-        i = skip_character_class(content, i)
-        next
-      end
+  def try_emit_backslash_anchor(node, content, content_offset, i)
+    anchor = match_backslash_anchor(content, i)
+    return 2 if anchor.nil?
 
-      if %w[^ $].include?(content[i])
-        add_mutation(
-          offset: content_offset + i,
-          length: 1,
-          replacement: "",
-          node: node
-        )
-      end
+    add_mutation(offset: content_offset + i, length: anchor.length, replacement: "", node: node)
+    anchor.length
+  end
 
-      i += 1
-    end
+  def try_emit_caret_dollar(node, content, content_offset, i)
+    return unless %w[^ $].include?(content[i])
+
+    add_mutation(offset: content_offset + i, length: 1, replacement: "", node: node)
   end
 
   def match_backslash_anchor(content, pos)
@@ -104,18 +83,13 @@ class Evilution::Mutator::Operator::RegexSimplification < Evilution::Mutator::Ba
   end
 
   def remove_character_class_ranges(node, content, content_offset)
-    i = 0
-    while i < content.length
-      if content[i] == "\\"
-        i += 2
-        next
-      end
-
-      if content[i] == "["
+    scan_regex_positions(content) do |kind, i|
+      case kind
+      when :backslash then 2
+      when :class_open
         scan_ranges_in_class(node, content, content_offset, i)
-        i = skip_character_class(content, i)
-      else
-        i += 1
+        class_skip(content, i)
+      when :char then 1
       end
     end
   end
@@ -153,17 +127,38 @@ class Evilution::Mutator::Operator::RegexSimplification < Evilution::Mutator::Ba
     )
   end
 
+  # Walks `content` yielding (kind, position) for each significant token:
+  # :backslash for an escape sequence, :class_open for `[`, :char for any
+  # other byte. The block returns the number of characters to advance from
+  # `position` — callers decide how to handle each case (skip, emit a
+  # mutation, descend into a character class, etc.).
+  def scan_regex_positions(content)
+    i = 0
+    while i < content.length
+      advance = case content[i]
+                when "\\" then yield(:backslash, i)
+                when "[" then yield(:class_open, i)
+                else yield(:char, i)
+                end
+      i += advance
+    end
+  end
+
+  def class_skip(content, pos)
+    skip_character_class(content, pos) - pos
+  end
+
   def skip_character_class(content, pos)
-    i = pos + 1
-    i += 1 if i < content.length && content[i] == "^"
-    i += 1 if i < content.length && content[i] == "]"
+    scan_to_class_close(content, skip_class_prefix(content, pos))
+  end
 
+  def scan_to_class_close(content, start)
+    i = start
     while i < content.length
       return i + 1 if content[i] == "]"
 
       i += content[i] == "\\" ? 2 : 1
     end
-
     i
   end
 end

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

@@ -72,14 +72,15 @@ class Evilution::Mutator::Operator::RescueBodyReplacement < Evilution::Mutator::
   end
 
   def rescue_line_end(node)
-    if node.reference
-      node.reference.location.start_offset + node.reference.location.length
-    elsif node.exceptions.any?
-      last_exc = node.exceptions.last
-      last_exc.location.start_offset + last_exc.location.length
-    else
-      node.keyword_loc.start_offset + node.keyword_loc.length
-    end
+    loc = if node.reference
+            node.reference.location
+          elsif node.exceptions.any?
+            node.exceptions.last.location
+          else
+            node.keyword_loc
+          end
+
+    loc.start_offset + loc.length
   end
 
   def indentation_of(offset)

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

@@ -20,13 +20,10 @@ class Evilution::Mutator::Operator::RescueRemoval < Evilution::Mutator::Base
   private
 
   def rescue_end_offset(node)
-    if node.subsequent
-      line_start_before(node.subsequent.keyword_loc.start_offset)
-    elsif node.statements
-      node.statements.location.start_offset + node.statements.location.length
-    else
-      node.keyword_loc.start_offset + node.keyword_loc.length
-    end
+    return line_start_before(node.subsequent.keyword_loc.start_offset) if node.subsequent
+
+    loc = node.statements ? node.statements.location : node.keyword_loc
+    loc.start_offset + loc.length
   end
 
   def line_start_before(offset)

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

@@ -11,29 +11,35 @@ class Evilution::Mutator::Operator::SuperclassRemoval < Evilution::Mutator::Base
     @mutations = []
     @filter = filter
 
-    tree = self.class.parsed_tree_for(subject.file_path, @file_source)
-    enclosing = find_enclosing_class(tree, subject.line_number)
+    enclosing = find_target_class(subject)
     return @mutations unless enclosing
-    return @mutations unless enclosing.superclass
-
-    first_method_line = find_first_method_line(enclosing)
-    return @mutations unless first_method_line == subject.line_number
 
-    name_end = enclosing.constant_path.location.start_offset + enclosing.constant_path.location.length
-    superclass_end = enclosing.superclass.location.start_offset + enclosing.superclass.location.length
-
-    add_mutation(
-      offset: name_end,
-      length: superclass_end - name_end,
-      replacement: "",
-      node: enclosing
-    )
+    offset, length = superclass_range(enclosing)
+    add_mutation(offset: offset, length: length, replacement: "", node: enclosing)
 
     @mutations
   end
 
   private
 
+  def find_target_class(subject)
+    tree = self.class.parsed_tree_for(subject.file_path, @file_source)
+    enclosing = find_enclosing_class(tree, subject.line_number)
+    return nil unless enclosing && enclosing.superclass
+    return nil unless find_first_method_line(enclosing) == subject.line_number
+
+    enclosing
+  end
+
+  def superclass_range(class_node)
+    name_loc = class_node.constant_path.location
+    superclass_loc = class_node.superclass.location
+    name_end = name_loc.start_offset + name_loc.length
+    superclass_end = superclass_loc.start_offset + superclass_loc.length
+
+    [name_end, superclass_end - name_end]
+  end
+
   def find_enclosing_class(tree, target_line)
     finder = ClassFinder.new(target_line)
     finder.visit(tree)

data/lib/evilution/mutator/registry.rb

@@ -3,6 +3,26 @@
 require_relative "../mutator"
 
 class Evilution::Mutator::Registry
+  STRICT_EXTRA_OPERATORS = [
+    Evilution::Mutator::Operator::PredicateToNil
+  ].freeze
+
+  def self.for_profile(profile)
+    unless profile.is_a?(Symbol) || profile.is_a?(String)
+      raise ArgumentError, "unknown profile: #{profile.inspect} (expected :default or :strict)"
+    end
+
+    case profile.to_sym
+    when :default then default
+    when :strict
+      registry = default
+      STRICT_EXTRA_OPERATORS.each { |op| registry.register(op) }
+      registry
+    else
+      raise ArgumentError, "unknown profile: #{profile.inspect} (expected :default or :strict)"
+    end
+  end
+
   def self.default
     registry = new
     [

data/lib/evilution/parallel/work_queue/channel/frame.rb

@@ -10,12 +10,16 @@ module Evilution::Parallel::WorkQueue::Channel::Frame
     [payload.bytesize].pack("N") + payload
   end
 
+  # Marshal.load is safe here: payload originates from a sibling worker the
+  # parent itself forked, transferred over a private pipe inside our process
+  # tree. No external/untrusted input ever reaches this code. See
+  # .rubocop.yml (Security/MarshalLoad) for the full rationale.
   def decode(header, payload)
     return nil if header.nil? || header.bytesize < 4
 
     length = header.unpack1("N")
     return nil if payload.nil? || payload.bytesize < length
 
-    Marshal.load(payload) # rubocop:disable Security/MarshalLoad
+    Marshal.load(payload)
   end
 end