evilution 0.27.0 → 0.29.0

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/loop.rb

@@ -36,7 +36,7 @@ module Evilution::Parallel::WorkQueue::Worker::Loop
       result = block.call(item)
       elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - t0
       Evilution::Parallel::WorkQueue::Channel.write(res_io, [index, :ok, result])
-    rescue Exception => e # rubocop:disable Lint/RescueException
+    rescue StandardError, ScriptError, SystemStackError, NoMemoryError, SecurityError => e
       elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - t0
       Evilution::Parallel::WorkQueue::Channel.write(res_io, [index, :error, e])
     end

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/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

@@ -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

data/lib/evilution/reporter/html/baseline_keys.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative "namespace"
+require_relative "../html"
 
 class Evilution::Reporter::HTML::BaselineKeys
   def initialize(baseline)

data/lib/evilution/reporter/html/diff_formatter.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative "namespace"
+require_relative "../html"
 require_relative "escape"
 
 module Evilution::Reporter::HTML::DiffFormatter

data/lib/evilution/reporter/html/escape.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require "cgi"
-require_relative "namespace"
+require_relative "../html"
 
 module Evilution::Reporter::HTML::Escape
   module_function

data/lib/evilution/reporter/html/section.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require "erb"
-require_relative "namespace"
+require_relative "../html"
 require_relative "escape"
 
 class Evilution::Reporter::HTML::Section

data/lib/evilution/reporter/html/sections.rb

@@ -1,4 +1,6 @@
 # frozen_string_literal: true
 
-require_relative "namespace"
-require_relative "section"
+require_relative "../html"
+
+module Evilution::Reporter::HTML::Sections
+end

data/lib/evilution/reporter/html/stylesheet.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative "namespace"
+require_relative "../html"
 
 module Evilution::Reporter::HTML::Stylesheet
   PATH = File.expand_path("assets/style.css", __dir__)

data/lib/evilution/reporter/html.rb

@@ -2,11 +2,16 @@
 
 require_relative "../reporter"
 require_relative "suggestion"
-require_relative "html/escape"
-require_relative "html/baseline_keys"
-require_relative "html/report"
 
 class Evilution::Reporter::HTML
+  autoload :Escape, "evilution/reporter/html/escape"
+  autoload :BaselineKeys, "evilution/reporter/html/baseline_keys"
+  autoload :Section, "evilution/reporter/html/section"
+  autoload :Sections, "evilution/reporter/html/sections"
+  autoload :Stylesheet, "evilution/reporter/html/stylesheet"
+  autoload :DiffFormatter, "evilution/reporter/html/diff_formatter"
+  autoload :Report, "evilution/reporter/html/report"
+
   def initialize(baseline: nil, integration: :rspec)
     @suggestion = Evilution::Reporter::Suggestion.new(integration: integration)
     @baseline = baseline

data/lib/evilution/reporter/json.rb

@@ -22,18 +22,33 @@ class Evilution::Reporter::JSON
       version: Evilution::VERSION,
       timestamp: Time.now.iso8601,
       summary: build_summary(summary),
-      survived: map_details(summary.survived_results),
       coverage_gaps: build_coverage_gaps(summary),
+      **result_categories(summary)
+    }
+    append_disabled_to_report(report, summary)
+    report
+  end
+
+  def result_categories(summary)
+    direct_categories(summary).merge(derived_categories(summary))
+  end
+
+  def direct_categories(summary)
+    {
+      survived: map_details(summary.survived_results),
       killed: map_details(summary.killed_results),
       neutral: map_details(summary.neutral_results),
-      timed_out: map_details(summary.results.select(&:timeout?)),
-      errors: map_details(summary.results.select(&:error?)),
       equivalent: map_details(summary.equivalent_results),
       unresolved: map_details(summary.unresolved_results),
       unparseable: map_details(summary.unparseable_results)
     }
-    append_disabled_to_report(report, summary)
-    report
+  end
+
+  def derived_categories(summary)
+    {
+      timed_out: map_details(summary.results.select(&:timeout?)),
+      errors: map_details(summary.results.select(&:error?))
+    }
   end
 
   def map_details(results)
@@ -47,7 +62,13 @@ class Evilution::Reporter::JSON
   end
 
   def build_summary(summary)
-    data = {
+    data = build_core_summary(summary).merge(build_metrics_summary(summary))
+    append_optional_summary_fields(data, summary)
+    data
+  end
+
+  def build_core_summary(summary)
+    {
       total: summary.total,
       killed: summary.killed,
       survived: summary.survived,
@@ -56,23 +77,39 @@ class Evilution::Reporter::JSON
       neutral: summary.neutral,
       equivalent: summary.equivalent,
       unresolved: summary.unresolved,
-      unparseable: summary.unparseable,
+      unparseable: summary.unparseable
+    }
+  end
+
+  def build_metrics_summary(summary)
+    {
       score: summary.score.round(4),
       duration: summary.duration.round(4),
       killtime: summary.killtime.round(4),
       efficiency: summary.efficiency.round(4),
       mutations_per_second: summary.mutations_per_second.round(2)
     }
+  end
+
+  def append_optional_summary_fields(data, summary)
     data[:truncated] = true if summary.truncated?
     data[:skipped] = summary.skipped if summary.skipped.positive?
     peak = summary.peak_memory_mb
     data[:peak_memory_mb] = peak.round(1) if peak
-    data
   end
 
   def build_mutation_detail(result)
     mutation = result.mutation
-    detail = {
+    detail = base_mutation_fields(mutation, result)
+    append_survived_fields(detail, mutation) if result.status == :survived
+    detail[:test_command] = result.test_command if result.test_command
+    append_memory_fields(detail, result)
+    append_error_fields(detail, result)
+    detail
+  end
+
+  def base_mutation_fields(mutation, result)
+    {
       operator: mutation.operator_name,
       file: mutation.file_path,
       line: mutation.line,
@@ -80,15 +117,12 @@ class Evilution::Reporter::JSON
       duration: result.duration.round(4),
       diff: mutation.diff
     }
-    if result.status == :survived
-      detail[:suggestion] = @suggestion.suggestion_for(mutation)
-      unified = mutation.unified_diff
-      detail[:unified_diff] = unified if unified
-    end
-    detail[:test_command] = result.test_command if result.test_command
-    append_memory_fields(detail, result)
-    append_error_fields(detail, result)
-    detail
+  end
+
+  def append_survived_fields(detail, mutation)
+    detail[:suggestion] = @suggestion.suggestion_for(mutation)
+    unified = mutation.unified_diff
+    detail[:unified_diff] = unified if unified
   end
 
   def append_memory_fields(detail, result)

data/lib/evilution/reporter/suggestion/diff_helpers.rb

@@ -12,17 +12,4 @@ module Evilution::Reporter::Suggestion::DiffHelpers
   def sanitize_method_name(name)
     name.gsub(/[^a-zA-Z0-9_]/, "_").gsub(/_+/, "_").gsub(/\A_|_\z/, "")
   end
-
-  def extract_diff_lines(diff)
-    lines = diff.split("\n")
-    original = lines.find { |l| l.start_with?("- ") }
-    mutated = lines.find { |l| l.start_with?("+ ") }
-    [clean_diff_line(original, "- "), clean_diff_line(mutated, "+ ")]
-  end
-
-  def clean_diff_line(line, prefix)
-    return nil if line.nil?
-
-    line.sub(/^#{Regexp.escape(prefix)}/, "").strip
-  end
 end

data/lib/evilution/reporter/suggestion/diff_lines.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative "../suggestion"
+
+class Evilution::Reporter::Suggestion::DiffLines
+  def self.from_diff(raw_diff)
+    lines = raw_diff.split("\n")
+    new(
+      original: clean(lines.find { |l| l.start_with?("- ") }, "- "),
+      mutated: clean(lines.find { |l| l.start_with?("+ ") }, "+ ")
+    )
+  end
+
+  def self.clean(line, prefix)
+    return nil if line.nil?
+
+    line.sub(/^#{Regexp.escape(prefix)}/, "").strip
+  end
+  private_class_method :clean
+
+  attr_reader :original, :mutated
+
+  def initialize(original:, mutated:)
+    @original = original
+    @mutated = mutated
+    freeze
+  end
+end

data/lib/evilution/reporter/suggestion/registry.rb

@@ -1,13 +1,9 @@
 # frozen_string_literal: true
 
 require_relative "../suggestion"
-
-# rubocop:disable Style/OneClassPerFile
-module Evilution::Reporter::Suggestion::Templates
-end
+require_relative "templates"
 
 class Evilution::Reporter::Suggestion::Registry
-  # rubocop:enable Style/OneClassPerFile
   def self.default
     return @default if @default
 

data/lib/evilution/reporter/suggestion/templates/generic.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative "../registry"
+require_relative "../templates"
 
 module Evilution::Reporter::Suggestion::Templates::Generic
   GENERIC_ENTRIES = {