evilution 0.28.0 → 0.29.0

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/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/parallel/work_queue/dispatcher.rb

@@ -4,6 +4,8 @@ require_relative "../work_queue"
 require_relative "collection_state"
 
 class Evilution::Parallel::WorkQueue::Dispatcher
+  RunResult = Data.define(:results, :retired)
+
   attr_reader :first_error
 
   def initialize(workers:, items:, prefetch:, item_timeout:, worker_max_items:, recycle_factory:)
@@ -21,7 +23,7 @@ class Evilution::Parallel::WorkQueue::Dispatcher
     seed
     collect
     @first_error = @state.first_error
-    [@state.results, @retired]
+    RunResult.new(results: @state.results, retired: @retired)
   end
 
   private
@@ -42,20 +44,25 @@ class Evilution::Parallel::WorkQueue::Dispatcher
 
     while @state.in_flight.positive?
       readable, = IO.select(result_ios, nil, nil, @item_timeout)
-
       if readable.nil?
-        terminate_stuck
-        @state.first_error ||= Evilution::Error.new("worker timed out after #{@item_timeout}s")
+        record_timeout
         break
       end
 
-      readable.each do |io|
-        alive = handle(io_to_worker[io], io_to_worker, result_ios)
-        result_ios.delete(io) unless alive
-      end
+      readable.each { |io| process_readable(io, io_to_worker, result_ios) }
     end
   end
 
+  def record_timeout
+    terminate_stuck
+    @state.first_error ||= Evilution::Error.new("worker timed out after #{@item_timeout}s")
+  end
+
+  def process_readable(io, io_to_worker, result_ios)
+    alive = handle(io_to_worker[io], io_to_worker, result_ios)
+    result_ios.delete(io) unless alive
+  end
+
   def handle(worker, io_to_worker, result_ios)
     message = worker.read_result
     return handle_dead(worker) if message.nil?

data/lib/evilution/parallel/work_queue/worker.rb

@@ -6,6 +6,8 @@ require_relative "channel"
 require_relative "channel/frame"
 
 class Evilution::Parallel::WorkQueue::Worker
+  Timing = Data.define(:busy, :wall)
+
   attr_reader :pid, :worker_index
   attr_accessor :items_completed, :pending, :busy_time, :wall_time
 
@@ -84,11 +86,11 @@ class Evilution::Parallel::WorkQueue::Worker
 
   def retire
     shutdown
-    busy, wall = drain_stats
+    timing = drain_stats
     close_pipes
     reap
-    @busy_time = busy
-    @wall_time = wall
+    @busy_time = timing.busy
+    @wall_time = timing.wall
     to_stat
   end
 
@@ -101,14 +103,15 @@ class Evilution::Parallel::WorkQueue::Worker
   private
 
   def drain_stats
-    return [0.0, 0.0] unless @res_read.wait_readable(Evilution::Parallel::WorkQueue::TIMING_GRACE_PERIOD)
+    zero = Timing.new(busy: 0.0, wall: 0.0)
+    return zero unless @res_read.wait_readable(Evilution::Parallel::WorkQueue::TIMING_GRACE_PERIOD)
 
     message = read_result
-    return [0.0, 0.0] if message.nil?
+    return zero if message.nil?
 
     tag, busy, wall = message
-    return [0.0, 0.0] unless tag == Evilution::Parallel::WorkQueue::STATS
+    return zero unless tag == Evilution::Parallel::WorkQueue::STATS
 
-    [busy, wall]
+    Timing.new(busy: busy, wall: wall)
   end
 end

data/lib/evilution/parallel/work_queue.rb

@@ -27,24 +27,17 @@ class Evilution::Parallel::WorkQueue
     return [] if items.empty?
 
     workers = (0...[@size, items.length].min).map { |i| spawn_one(i, &block) }
-    dispatcher = Dispatcher.new(
-      workers: workers, items: items, prefetch: @prefetch,
-      item_timeout: @item_timeout, worker_max_items: @worker_max_items,
-      recycle_factory: ->(old) { spawn_one(old.worker_index, &block) }
-    )
+    dispatcher = build_dispatcher(workers, items, &block)
 
     retired = []
     begin
-      results, retired = dispatcher.run
+      run_result = dispatcher.run
+      retired = run_result.retired
       raise dispatcher.first_error if dispatcher.first_error
 
-      results
+      run_result.results
     ensure
-      workers.each(&:shutdown)
-      collect_final_timings(workers)
-      workers.each(&:close_pipes)
-      workers.each(&:reap)
-      @worker_stats = retired + workers.map(&:to_stat)
+      cleanup_workers(workers, retired)
     end
   end
 
@@ -58,19 +51,43 @@ class Evilution::Parallel::WorkQueue
     Worker.spawn(worker_index: worker_index, hooks: @hooks, &)
   end
 
+  def build_dispatcher(workers, items, &block)
+    Dispatcher.new(
+      workers: workers, items: items, prefetch: @prefetch,
+      item_timeout: @item_timeout, worker_max_items: @worker_max_items,
+      recycle_factory: ->(old) { spawn_one(old.worker_index, &block) }
+    )
+  end
+
+  def cleanup_workers(workers, retired)
+    workers.each(&:shutdown)
+    collect_final_timings(workers)
+    workers.each(&:close_pipes)
+    workers.each(&:reap)
+    @worker_stats = retired + workers.map(&:to_stat)
+  end
+
   def collect_final_timings(workers)
     io_to_worker = workers.reject { |w| w.res_io.closed? }.to_h { |w| [w.res_io, w] }
-    deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + TIMING_GRACE_PERIOD
+    deadline = monotonic_now + TIMING_GRACE_PERIOD
 
     until io_to_worker.empty?
-      remaining = deadline - Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      remaining = deadline - monotonic_now
       break if remaining <= 0
+      break unless poll_and_apply(io_to_worker, remaining)
+    end
+  end
 
-      readable, = IO.select(io_to_worker.keys, nil, nil, remaining)
-      break unless readable
+  def poll_and_apply(io_to_worker, remaining)
+    readable, = IO.select(io_to_worker.keys, nil, nil, remaining)
+    return false unless readable
 
-      readable.each { |io| apply_final_timing(io_to_worker.delete(io), io) }
-    end
+    readable.each { |io| apply_final_timing(io_to_worker.delete(io), io) }
+    true
+  end
+
+  def monotonic_now
+    Process.clock_gettime(Process::CLOCK_MONOTONIC)
   end
 
   def apply_final_timing(worker, io)

data/lib/evilution/reporter/cli/item_formatters/coverage_gap.rb

@@ -5,14 +5,19 @@ require_relative "../item_formatters"
 class Evilution::Reporter::CLI::ItemFormatters::CoverageGap
   def format(gap)
     location = "#{gap.file_path}:#{gap.line}"
-    header = if gap.single?
-               "  #{gap.primary_operator}: #{location} (#{gap.subject_name})"
-             else
-               operators = gap.operator_names.join(", ")
-               "  #{location} (#{gap.subject_name}) [#{gap.count} mutations: #{operators}]"
-             end
+    "#{format_header(gap, location)}\n#{format_body(gap)}"
+  end
+
+  private
+
+  def format_header(gap, location)
+    return "  #{gap.primary_operator}: #{location} (#{gap.subject_name})" if gap.single?
+
+    "  #{location} (#{gap.subject_name}) [#{gap.count} mutations: #{gap.operator_names.join(", ")}]"
+  end
+
+  def format_body(gap)
     body = gap.mutation_results.first.mutation.unified_diff || gap.primary_diff
-    indented = body.split("\n").map { |l| "    #{l}" }.join("\n")
-    "#{header}\n#{indented}"
+    body.split("\n").map { |l| "    #{l}" }.join("\n")
   end
 end

data/lib/evilution/reporter/cli/line_formatters/mutations.rb

@@ -3,14 +3,23 @@
 require_relative "../line_formatters"
 
 class Evilution::Reporter::CLI::LineFormatters::Mutations
+  OPTIONAL_FIELDS = %i[neutral equivalent unresolved unparseable skipped].freeze
+
   def format(summary)
-    parts = "Mutations: #{summary.total} total, #{summary.killed} killed, " \
-            "#{summary.survived} survived, #{summary.timed_out} timed out"
-    parts += ", #{summary.neutral} neutral" if summary.neutral.positive?
-    parts += ", #{summary.equivalent} equivalent" if summary.equivalent.positive?
-    parts += ", #{summary.unresolved} unresolved" if summary.unresolved.positive?
-    parts += ", #{summary.unparseable} unparseable" if summary.unparseable.positive?
-    parts += ", #{summary.skipped} skipped" if summary.skipped.positive?
-    parts
+    base_line(summary) + optional_sections(summary)
+  end
+
+  private
+
+  def base_line(summary)
+    "Mutations: #{summary.total} total, #{summary.killed} killed, " \
+      "#{summary.survived} survived, #{summary.timed_out} timed out"
+  end
+
+  def optional_sections(summary)
+    OPTIONAL_FIELDS.filter_map do |field|
+      count = summary.public_send(field)
+      ", #{count} #{field}" if count.positive?
+    end.join
   end
 end