evilution 0.26.0 → 0.28.0

data/lib/evilution/parallel/work_queue.rb

@@ -9,20 +9,12 @@ class Evilution::Parallel::WorkQueue
 
   TIMING_GRACE_PERIOD = 5
 
-  WorkerStat = Struct.new(:pid, :items_completed, :busy_time, :wall_time) do
-    def idle_time
-      wall_time - busy_time
-    end
-
-    def utilization
-      return 0.0 if wall_time.nil? || wall_time.zero?
-
-      busy_time / wall_time
-    end
-  end
-
   def initialize(size:, hooks: nil, prefetch: 1, item_timeout: nil, worker_max_items: nil)
-    validate_init_args(size, prefetch, item_timeout, worker_max_items)
+    Validators::PositiveInt.call!(:size, size)
+    Validators::PositiveInt.call!(:prefetch, prefetch)
+    Validators::OptionalPositiveNumber.call!(:item_timeout, item_timeout)
+    Validators::OptionalPositiveInt.call!(:worker_max_items, worker_max_items)
+
     @size = size
     @hooks = hooks
     @prefetch = prefetch
@@ -34,18 +26,25 @@ class Evilution::Parallel::WorkQueue
   def map(items, &block)
     return [] if items.empty?
 
-    @block = block
-    @retired_workers = []
-    worker_count = [@size, items.length].min
-    workers = spawn_workers(worker_count, &block)
+    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) }
+    )
 
+    retired = []
     begin
-      distribute_and_collect(items, workers)
+      results, retired = dispatcher.run
+      raise dispatcher.first_error if dispatcher.first_error
+
+      results
     ensure
-      shutdown_workers(workers)
-      @worker_stats = @retired_workers + build_worker_stats(workers)
-      @block = nil
-      @retired_workers = nil
+      workers.each(&:shutdown)
+      collect_final_timings(workers)
+      workers.each(&:close_pipes)
+      workers.each(&:reap)
+      @worker_stats = retired + workers.map(&:to_stat)
     end
   end
 
@@ -55,272 +54,12 @@ class Evilution::Parallel::WorkQueue
 
   private
 
-  def validate_init_args(size, prefetch, item_timeout, worker_max_items)
-    validate_positive_int!(:size, size)
-    validate_positive_int!(:prefetch, prefetch)
-    validate_optional_positive_number!(:item_timeout, item_timeout)
-    validate_optional_positive_int!(:worker_max_items, worker_max_items)
-  end
-
-  def validate_positive_int!(name, value)
-    return if value.is_a?(Integer) && value >= 1
-
-    raise ArgumentError, "#{name} must be a positive integer, got #{value.inspect}"
-  end
-
-  def validate_optional_positive_int!(name, value)
-    return if value.nil? || (value.is_a?(Integer) && value.positive?)
-
-    raise ArgumentError, "#{name} must be nil or a positive integer, got #{value.inspect}"
+  def spawn_one(worker_index, &)
+    Worker.spawn(worker_index: worker_index, hooks: @hooks, &)
   end
 
-  def validate_optional_positive_number!(name, value)
-    return if value.nil? || (value.is_a?(Numeric) && value.positive?)
-
-    raise ArgumentError, "#{name} must be nil or a positive number, got #{value.inspect}"
-  end
-
-  def spawn_workers(count, &block)
-    count.times.map { |slot| spawn_one_worker(worker_index: slot, &block) }
-  end
-
-  # EV-kdns / GH #817: translate 0-based worker slot to parallel_tests'
-  # TEST_ENV_NUMBER convention ("" for slot 0, "2" for slot 1, ...). Rails
-  # apps interpolating TEST_ENV_NUMBER into database.yml get per-worker
-  # SQLite files, avoiding lock contention under jobs > 1.
-  def test_env_number_for(worker_index)
-    worker_index.zero? ? "" : (worker_index + 1).to_s
-  end
-
-  def spawn_one_worker(worker_index:, &block)
-    cmd_read, cmd_write = IO.pipe
-    res_read, res_write = IO.pipe
-    # Marshal payloads are ASCII-8BIT; pipes default to text mode and may
-    # transcode according to their external/internal encodings (influenced by
-    # Encoding.default_external and/or Encoding.default_internal — Rails sets
-    # the latter to UTF-8), failing on bytes with no mapping. Force binmode on
-    # all four ends.
-    [cmd_read, cmd_write, res_read, res_write].each(&:binmode)
-
-    pid = Process.fork do
-      cmd_write.close
-      res_read.close
-      ENV["TEST_ENV_NUMBER"] = test_env_number_for(worker_index)
-      worker_loop(cmd_read, res_write, &block)
-    end
-
-    cmd_read.close
-    res_write.close
-
-    { pid: pid, cmd_write: cmd_write, res_read: res_read, items_completed: 0, pending: 0, worker_index: worker_index }
-  end
-
-  def worker_loop(cmd_read, res_write, &block)
-    @hooks.fire(:worker_process_start) if @hooks
-    start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-    busy_time = 0.0
-
-    loop do
-      data = read_command(cmd_read)
-      break if data == SHUTDOWN
-
-      index, item = data
-      begin
-        t0 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-        result = block.call(item)
-        busy_time += Process.clock_gettime(Process::CLOCK_MONOTONIC) - t0
-        write_message(res_write, [index, :ok, result])
-      rescue Exception => e # rubocop:disable Lint/RescueException
-        busy_time += Process.clock_gettime(Process::CLOCK_MONOTONIC) - t0
-        write_message(res_write, [index, :error, e])
-      end
-    end
-
-    wall_time = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time
-    write_message(res_write, [STATS, busy_time, wall_time])
-  ensure
-    cmd_read.close
-    res_write.close
-    exit!
-  end
-
-  def distribute_and_collect(items, workers)
-    state = CollectionState.new(items.length)
-    seed_workers(items, workers, state)
-    collect_results(items, workers, state)
-    raise state.first_error if state.first_error
-
-    state.results
-  end
-
-  def seed_workers(items, workers, state)
-    @prefetch.times do
-      workers.each do |worker|
-        break unless state.next_index < items.length
-
-        send_item(worker, items, state)
-      end
-    end
-  end
-
-  def collect_results(items, workers, state)
-    io_to_worker = workers.to_h { |w| [w[:res_read], w] }
-    result_ios = io_to_worker.keys
-
-    while state.in_flight.positive?
-      readable, = IO.select(result_ios, nil, nil, @item_timeout)
-
-      if readable.nil?
-        terminate_stuck_workers(workers)
-        state.first_error = Evilution::Error.new("worker timed out after #{@item_timeout}s") if state.first_error.nil?
-        break
-      end
-
-      readable.each do |io|
-        alive = handle_result(io, io_to_worker[io], items, state, workers, io_to_worker, result_ios)
-        result_ios.delete(io) unless alive
-      end
-    end
-  end
-
-  def handle_result(io, worker, items, state, workers, io_to_worker, result_ios)
-    message = read_result(io)
-    return handle_dead_worker(worker, state) if message.nil?
-
-    record_result(message, worker, state)
-    return false if recycle_and_dispatch(worker, items, state, workers, io_to_worker, result_ios)
-    return true if draining_for_recycle?(worker)
-
-    send_item(worker, items, state) if state.next_index < items.length && state.first_error.nil?
-    true
-  end
-
-  # Once worker hits K, stop dispatching so pending drains to 0; recycle fires
-  # on the next result. Prevents prefetch > 1 from refilling pending forever.
-  def draining_for_recycle?(worker)
-    @worker_max_items && worker[:items_completed] >= @worker_max_items && worker[:pending].positive?
-  end
-
-  def handle_dead_worker(worker, state)
-    state.first_error = Evilution::Error.new("worker process exited unexpectedly") if state.first_error.nil?
-    state.in_flight -= worker[:pending]
-    worker[:pending] = 0
-    false
-  end
-
-  def record_result(message, worker, state)
-    index, status, value = message
-    state.first_error = value if status == :error && state.first_error.nil?
-    state.results[index] = value if status == :ok
-    state.in_flight -= 1
-    worker[:pending] -= 1
-    worker[:items_completed] += 1
-  end
-
-  def recycle_and_dispatch(worker, items, state, workers, io_to_worker, result_ios)
-    return false unless should_recycle?(worker, state, items)
-
-    new_worker = recycle_worker(worker, workers, io_to_worker, result_ios)
-    send_item(new_worker, items, state) if state.next_index < items.length && state.first_error.nil?
-    true
-  end
-
-  def should_recycle?(worker, state, items)
-    return false unless @worker_max_items
-    return false if worker[:items_completed] < @worker_max_items
-    return false unless worker[:pending].zero?
-    return false unless state.next_index < items.length
-    return false unless state.first_error.nil?
-
-    true
-  end
-
-  def recycle_worker(old_worker, workers, io_to_worker, result_ios)
-    io_to_worker.delete(old_worker[:res_read])
-    result_ios.delete(old_worker[:res_read])
-    retire_worker(old_worker)
-
-    new_worker = spawn_one_worker(worker_index: old_worker[:worker_index], &@block)
-    workers[workers.index(old_worker)] = new_worker
-    io_to_worker[new_worker[:res_read]] = new_worker
-    result_ios << new_worker[:res_read]
-
-    new_worker
-  end
-
-  def retire_worker(worker)
-    begin
-      write_message(worker[:cmd_write], SHUTDOWN)
-    rescue Errno::EPIPE
-      nil
-    end
-
-    busy, wall = drain_worker_stats(worker)
-
-    worker[:cmd_write].close unless worker[:cmd_write].closed?
-    worker[:res_read].close unless worker[:res_read].closed?
-    begin
-      Process.wait(worker[:pid])
-    rescue Errno::ECHILD
-      nil
-    end
-
-    @retired_workers << WorkerStat.new(worker[:pid], worker[:items_completed], busy, wall)
-  end
-
-  def drain_worker_stats(worker)
-    return [0.0, 0.0] unless worker[:res_read].wait_readable(TIMING_GRACE_PERIOD)
-
-    message = read_result(worker[:res_read])
-    return [0.0, 0.0] if message.nil?
-
-    tag, busy_time, wall_time = message
-    return [0.0, 0.0] unless tag == STATS
-
-    [busy_time, wall_time]
-  end
-
-  def send_item(worker, items, state)
-    write_message(worker[:cmd_write], [state.next_index, items[state.next_index]])
-    state.next_index += 1
-    state.in_flight += 1
-    worker[:pending] += 1
-  end
-
-  def build_worker_stats(workers)
-    workers.map do |worker|
-      WorkerStat.new(worker[:pid], worker[:items_completed], worker[:busy_time] || 0.0, worker[:wall_time] || 0.0)
-    end
-  end
-
-  def terminate_stuck_workers(workers)
-    workers.each do |worker|
-      Process.kill("KILL", worker[:pid])
-    rescue Errno::ESRCH
-      nil # Already exited
-    end
-  end
-
-  def shutdown_workers(workers)
-    workers.each do |worker|
-      write_message(worker[:cmd_write], SHUTDOWN)
-    rescue Errno::EPIPE
-      # Worker already exited
-    end
-
-    collect_worker_timing(workers)
-
-    workers.each do |worker|
-      worker[:cmd_write].close unless worker[:cmd_write].closed?
-      worker[:res_read].close unless worker[:res_read].closed?
-      Process.wait(worker[:pid])
-    rescue Errno::ECHILD
-      # Already reaped
-    end
-  end
-
-  def collect_worker_timing(workers)
-    io_to_worker = workers.reject { |w| w[:res_read].closed? }.to_h { |w| [w[:res_read], w] }
+  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
 
     until io_to_worker.empty?
@@ -330,54 +69,30 @@ class Evilution::Parallel::WorkQueue
       readable, = IO.select(io_to_worker.keys, nil, nil, remaining)
       break unless readable
 
-      readable.each { |io| apply_worker_timing(io_to_worker.delete(io), io) }
+      readable.each { |io| apply_final_timing(io_to_worker.delete(io), io) }
     end
   end
 
-  def apply_worker_timing(worker, io)
-    message = read_result(io)
+  def apply_final_timing(worker, io)
+    message = Evilution::Parallel::WorkQueue::Channel.read(io)
     return if message.nil?
 
     tag, busy_time, wall_time = message
     return unless tag == STATS
 
-    worker[:busy_time] = busy_time
-    worker[:wall_time] = wall_time
+    worker.busy_time = busy_time
+    worker.wall_time = wall_time
   end
-
-  def write_message(io, data)
-    payload = Marshal.dump(data)
-    io.write([payload.bytesize].pack("N"))
-    io.write(payload)
-    io.flush
-  end
-
-  def read_command(io)
-    header = io.read(4)
-    return SHUTDOWN if header.nil? || header.bytesize < 4
-
-    length = header.unpack1("N")
-    payload = io.read(length)
-    return SHUTDOWN if payload.nil? || payload.bytesize < length
-
-    Marshal.load(payload) # rubocop:disable Security/MarshalLoad
-  end
-
-  def read_result(io)
-    header = io.read(4)
-    return nil if header.nil? || header.bytesize < 4
-
-    length = header.unpack1("N")
-    payload = io.read(length)
-    return nil if payload.nil? || payload.bytesize < length
-
-    Marshal.load(payload) # rubocop:disable Security/MarshalLoad
-  end
-
-  CollectionState = Struct.new(:results, :in_flight, :next_index, :first_error) do
-    def initialize(item_count)
-      super(Array.new(item_count), 0, 0, nil)
-    end
-  end
-  private_constant :CollectionState
 end
+
+require_relative "work_queue/worker_stat"
+require_relative "work_queue/validators"
+require_relative "work_queue/validators/positive_int"
+require_relative "work_queue/validators/optional_positive_int"
+require_relative "work_queue/validators/optional_positive_number"
+require_relative "work_queue/channel"
+require_relative "work_queue/channel/frame"
+require_relative "work_queue/worker"
+require_relative "work_queue/worker/loop"
+require_relative "work_queue/collection_state"
+require_relative "work_queue/dispatcher"

data/lib/evilution/process_cleanup.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative "version"
+
+module Evilution::ProcessCleanup
+  module_function
+
+  def safe_kill(signal, pid)
+    ::Process.kill(signal, pid)
+  rescue Errno::ESRCH
+    nil
+  end
+
+  def safe_wait(pid)
+    ::Process.wait(pid)
+  rescue Errno::ECHILD
+    nil
+  end
+end

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+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
+    body = gap.mutation_results.first.mutation.unified_diff || gap.primary_diff
+    indented = body.split("\n").map { |l| "    #{l}" }.join("\n")
+    "#{header}\n#{indented}"
+  end
+end

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

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require_relative "../item_formatters"
+
+class Evilution::Reporter::CLI::ItemFormatters::Disabled
+  def format(mutation)
+    "  #{mutation.operator_name}: #{mutation.file_path}:#{mutation.line}"
+  end
+end

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

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative "../item_formatters"
+
+class Evilution::Reporter::CLI::ItemFormatters::Error
+  def format(result)
+    mutation = result.mutation
+    header = "  #{mutation.operator_name}: #{mutation.file_path}:#{mutation.line}"
+    return header unless result.error_message
+
+    indented = result.error_message.lines.map { |line| "    #{line.chomp}" }.join("\n")
+    "#{header}\n#{indented}"
+  end
+end

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

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative "../item_formatters"
+
+class Evilution::Reporter::CLI::ItemFormatters::ResultLocation
+  def format(result)
+    mutation = result.mutation
+    "  #{mutation.operator_name}: #{mutation.file_path}:#{mutation.line}"
+  end
+end

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

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require_relative "../cli"
+
+module Evilution::Reporter::CLI::ItemFormatters
+end

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

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require_relative "../line_formatters"
+
+class Evilution::Reporter::CLI::LineFormatters::Duration
+  def format(summary)
+    "Duration: #{Kernel.format("%.2f", summary.duration)}s"
+  end
+end

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative "../line_formatters"
+require_relative "../pct"
+
+class Evilution::Reporter::CLI::LineFormatters::Efficiency
+  def initialize(pct: Evilution::Reporter::CLI::Pct.new)
+    @pct = pct
+  end
+
+  def format(summary)
+    return nil unless summary.duration.positive?
+
+    pct = @pct.format(summary.efficiency)
+    rate = Kernel.format("%.2f", summary.mutations_per_second)
+    "Efficiency: #{pct} killtime, #{rate} mutations/s"
+  end
+end

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

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative "../line_formatters"
+require_relative "../../../feedback/detector"
+require_relative "../../../feedback/messages"
+
+class Evilution::Reporter::CLI::LineFormatters::FeedbackFooter
+  def format(summary)
+    return nil unless Evilution::Feedback::Detector.friction?(summary)
+
+    Evilution::Feedback::Messages.cli_footer
+  end
+end

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

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative "../line_formatters"
+require_relative "../../../version"
+
+class Evilution::Reporter::CLI::LineFormatters::Header
+  def format(_summary)
+    "Evilution v#{Evilution::VERSION} — Mutation Testing Results"
+  end
+end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative "../line_formatters"
+
+class Evilution::Reporter::CLI::LineFormatters::Mutations
+  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
+  end
+end

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

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require_relative "../line_formatters"
+
+class Evilution::Reporter::CLI::LineFormatters::PeakMemory
+  def format(summary)
+    peak = summary.peak_memory_mb
+    return nil unless peak
+
+    Kernel.format("Peak memory: %<mb>.1f MB", mb: peak)
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative "../line_formatters"
+require_relative "../pct"
+
+class Evilution::Reporter::CLI::LineFormatters::ResultLine
+  DEFAULT_MIN_SCORE = 0.8
+
+  def initialize(pct: Evilution::Reporter::CLI::Pct.new, min_score: DEFAULT_MIN_SCORE)
+    @pct = pct
+    @min_score = min_score
+  end
+
+  def format(summary)
+    pass_fail = summary.success?(min_score: @min_score) ? "PASS" : "FAIL"
+    score_pct = @pct.format(summary.score)
+    threshold_pct = @pct.format(@min_score)
+    "Result: #{pass_fail} (score #{score_pct} #{pass_fail == "PASS" ? ">=" : "<"} #{threshold_pct})"
+  end
+end

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

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative "../line_formatters"
+require_relative "../pct"
+
+class Evilution::Reporter::CLI::LineFormatters::Score
+  def initialize(pct: Evilution::Reporter::CLI::Pct.new)
+    @pct = pct
+  end
+
+  def format(summary)
+    "Score: #{@pct.format(summary.score)} (#{summary.killed}/#{summary.score_denominator})"
+  end
+end

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

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative "../line_formatters"
+
+class Evilution::Reporter::CLI::LineFormatters::TruncationNotice
+  def format(summary)
+    return nil unless summary.truncated?
+
+    "[TRUNCATED] Stopped early due to --fail-fast"
+  end
+end

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

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require_relative "../cli"
+
+module Evilution::Reporter::CLI::LineFormatters
+end

data/lib/evilution/reporter/cli/metrics_block.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative "../cli"
+require_relative "line_formatters/mutations"
+require_relative "line_formatters/score"
+require_relative "line_formatters/duration"
+require_relative "line_formatters/efficiency"
+require_relative "line_formatters/peak_memory"
+
+class Evilution::Reporter::CLI::MetricsBlock
+  DEFAULT_LINES = [
+    Evilution::Reporter::CLI::LineFormatters::Mutations.new,
+    Evilution::Reporter::CLI::LineFormatters::Score.new,
+    Evilution::Reporter::CLI::LineFormatters::Duration.new,
+    Evilution::Reporter::CLI::LineFormatters::Efficiency.new,
+    Evilution::Reporter::CLI::LineFormatters::PeakMemory.new
+  ].freeze
+
+  def initialize(lines: DEFAULT_LINES)
+    @lines = lines
+  end
+
+  def call(summary)
+    @lines.filter_map { |line| line.format(summary) }
+  end
+end

data/lib/evilution/reporter/cli/pct.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require_relative "../cli"
+
+class Evilution::Reporter::CLI::Pct
+  def format(value)
+    Kernel.format("%.2f%%", value * 100)
+  end
+end