evilution 0.24.0 → 0.26.0

data/lib/evilution/mutation.rb

@@ -1,27 +1,44 @@
 # frozen_string_literal: true
 
 require "diff/lcs"
-require "diff/lcs/hunk"
 
 class Evilution::Mutation
   attr_reader :subject, :operator_name, :original_source,
-              :mutated_source, :file_path, :line, :column
+              :mutated_source, :original_slice, :mutated_slice,
+              :file_path, :line, :column, :parse_status
 
-  def initialize(subject:, operator_name:, original_source:, mutated_source:, file_path:, line:, column: 0)
+  # rubocop:disable Metrics/ParameterLists
+  def initialize(subject:, operator_name:, original_source:, mutated_source:,
+                 file_path:, line:, column: 0, original_slice: nil, mutated_slice: nil,
+                 parse_status: :ok)
+    # rubocop:enable Metrics/ParameterLists
     @subject = subject
     @operator_name = operator_name
     @original_source = original_source
     @mutated_source = mutated_source
+    @original_slice = original_slice
+    @mutated_slice = mutated_slice
     @file_path = file_path
     @line = line
     @column = column
+    @parse_status = parse_status
     @diff = nil
   end
 
+  def unparseable?
+    @parse_status == :unparseable
+  end
+
   def diff
     @diff ||= compute_diff
   end
 
+  def unified_diff
+    return @unified_diff if defined?(@unified_diff)
+
+    @unified_diff = compute_unified_diff
+  end
+
   def strip_sources!
     diff # ensure diff is cached before clearing sources
     @original_source = nil
@@ -49,6 +66,29 @@ class Evilution::Mutation
     result.join("\n")
   end
 
+  def compute_unified_diff
+    return nil if @original_slice.nil? || @mutated_slice.nil?
+
+    original_lines = @original_slice.lines
+    mutated_lines = @mutated_slice.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
+    ].reject(&:empty?).join("\n")
+  end
+
+  def format_sdiff_change(change)
+    case change.action
+    when "=" then " #{change.old_element.chomp}"
+    when "-" then "-#{change.old_element.chomp}"
+    when "+" then "+#{change.new_element.chomp}"
+    when "!" then "-#{change.old_element.chomp}\n+#{change.new_element.chomp}"
+    end
+  end
+
   public
 
   def to_s

data/lib/evilution/mutator/base.rb

@@ -27,24 +27,62 @@ class Evilution::Mutator::Base < Prism::Visitor
   def add_mutation(offset:, length:, replacement:, node:)
     return if @filter && @filter.skip?(node)
 
-    mutated_source = Evilution::AST::SourceSurgeon.apply(
+    surgery = Evilution::AST::SourceSurgeon.apply(
       @file_source,
       offset: offset,
       length: length,
       replacement: replacement
     )
+    mutated_source = surgery.source
+
+    original_slice, mutated_slice = slice_affected_lines(
+      mutated_source: mutated_source,
+      offset: offset,
+      length: length,
+      replacement_bytesize: replacement.bytesize
+    )
 
     @mutations << Evilution::Mutation.new(
       subject: @subject,
       operator_name: self.class.operator_name,
       original_source: @file_source,
       mutated_source: mutated_source,
+      original_slice: original_slice,
+      mutated_slice: mutated_slice,
+      parse_status: surgery.status,
       file_path: @subject.file_path,
       line: node.location.start_line,
       column: node.location.start_column
     )
   end
 
+  NEWLINE_BYTE = 10
+  private_constant :NEWLINE_BYTE
+
+  def slice_affected_lines(mutated_source:, offset:, length:, replacement_bytesize:)
+    line_start = line_start_byte(@file_source, offset)
+    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)
+    ]
+  end
+
+  def line_start_byte(source, offset)
+    i = offset - 1
+    i -= 1 while i >= 0 && source.getbyte(i) != NEWLINE_BYTE
+    i + 1
+  end
+
+  def line_end_byte(source, from)
+    limit = source.bytesize
+    i = from
+    i += 1 while i < limit && source.getbyte(i) != NEWLINE_BYTE
+    i < limit ? i + 1 : limit
+  end
+
   def byteslice_source(offset, length)
     @file_source.byteslice(offset, length).force_encoding(@file_source.encoding)
   end

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

@@ -13,7 +13,7 @@ class Evilution::Mutator::Operator::ArgumentNilSubstitution < Evilution::Mutator
   def visit_call_node(node)
     args = node.arguments&.arguments
 
-    if args && args.length >= 1 && positional_only?(args)
+    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(", ")
@@ -32,6 +32,10 @@ class Evilution::Mutator::Operator::ArgumentNilSubstitution < Evilution::Mutator
 
   private
 
+  def mutable?(node, args)
+    args && args.length >= 1 && positional_only?(args) && node.name != :[]=
+  end
+
   def positional_only?(args)
     args.none? { |arg| SKIP_TYPES.any? { |type| arg.is_a?(type) } }
   end

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

@@ -13,7 +13,7 @@ class Evilution::Mutator::Operator::ArgumentRemoval < Evilution::Mutator::Base
   def visit_call_node(node)
     args = node.arguments&.arguments
 
-    if args && args.length >= 2 && positional_only?(args)
+    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(", ")
@@ -32,6 +32,10 @@ class Evilution::Mutator::Operator::ArgumentRemoval < Evilution::Mutator::Base
 
   private
 
+  def mutable?(node, args)
+    args && args.length >= 2 && positional_only?(args) && node.name != :[]=
+  end
+
   def positional_only?(args)
     args.none? { |arg| SKIP_TYPES.any? { |type| arg.is_a?(type) } }
   end

data/lib/evilution/parallel/work_queue.rb

@@ -21,31 +21,31 @@ class Evilution::Parallel::WorkQueue
     end
   end
 
-  def initialize(size:, hooks: nil, prefetch: 1, item_timeout: nil)
-    raise ArgumentError, "pool size must be a positive integer, got #{size.inspect}" unless size.is_a?(Integer) && size >= 1
-    raise ArgumentError, "prefetch must be a positive integer, got #{prefetch.inspect}" unless prefetch.is_a?(Integer) && prefetch >= 1
-    unless item_timeout.nil? || (item_timeout.is_a?(Numeric) && item_timeout.positive?)
-      raise ArgumentError, "item_timeout must be nil or a positive number, got #{item_timeout.inspect}"
-    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)
     @size = size
     @hooks = hooks
     @prefetch = prefetch
     @item_timeout = item_timeout
+    @worker_max_items = worker_max_items
     @worker_stats = []
   end
 
-  def map(items, &)
+  def map(items, &block)
     return [] if items.empty?
 
+    @block = block
+    @retired_workers = []
     worker_count = [@size, items.length].min
-    workers = spawn_workers(worker_count, &)
+    workers = spawn_workers(worker_count, &block)
 
     begin
       distribute_and_collect(items, workers)
     ensure
       shutdown_workers(workers)
-      @worker_stats = build_worker_stats(workers)
+      @worker_stats = @retired_workers + build_worker_stats(workers)
+      @block = nil
+      @retired_workers = nil
     end
   end
 
@@ -55,22 +55,64 @@ class Evilution::Parallel::WorkQueue
 
   private
 
-  def spawn_workers(count, &)
-    count.times.map do
-      cmd_read, cmd_write = IO.pipe
-      res_read, res_write = IO.pipe
+  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
 
-      pid = Process.fork do
-        cmd_write.close
-        res_read.close
-        worker_loop(cmd_read, res_write, &)
-      end
+  def validate_positive_int!(name, value)
+    return if value.is_a?(Integer) && value >= 1
 
-      cmd_read.close
-      res_write.close
+    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}"
+  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
 
-      { pid: pid, cmd_write: cmd_write, res_read: res_read, items_completed: 0, pending: 0 }
+  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)
@@ -135,33 +177,109 @@ class Evilution::Parallel::WorkQueue
       end
 
       readable.each do |io|
-        alive = handle_result(io, io_to_worker[io], items, state)
+        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)
+  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?
 
-    if message.nil?
-      state.first_error = Evilution::Error.new("worker process exited unexpectedly") if state.first_error.nil?
-      state.in_flight -= worker[:pending]
-      worker[:pending] = 0
-      return false
-    end
+    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?
 
-    send_item(worker, items, state) if state.next_index < items.length && 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

data/lib/evilution/parallel_db_warning.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "erb"
+require "yaml"
+require_relative "../evilution"
+
+# EV-kdns / GH #817: nudge users running parallel jobs against SQLite to adopt
+# the parallel_tests convention. WorkQueue sets TEST_ENV_NUMBER per worker, but
+# that only helps if config/database.yml interpolates it into the database path.
+# Without per-worker DB files, concurrent workers pile up on one SQLite file and
+# surface ActiveRecord::StatementTimeout / SQLite3::BusyException — noise that
+# MutationExecutor demotes to :neutral but still wastes wall-clock time.
+module Evilution::ParallelDbWarning
+  DATABASE_YML = File.join("config", "database.yml")
+  MESSAGE = "[evilution] Parallel run (jobs > 1) detected with SQLite in " \
+            "config/database.yml. Interpolate ENV['TEST_ENV_NUMBER'] into the " \
+            "test database path for per-worker DB isolation. See README."
+
+  @warned_roots = {}
+  @mutex = Mutex.new
+
+  class << self
+    def warn_if_sqlite_parallel(config, output: $stderr, root: Dir.pwd)
+      return unless config.jobs > 1
+      return unless sqlite_in_test_config?(root)
+
+      @mutex.synchronize do
+        return if @warned_roots[root]
+
+        @warned_roots[root] = true
+      end
+
+      output.puts(MESSAGE)
+    end
+
+    def reset!
+      @mutex.synchronize { @warned_roots.clear }
+    end
+
+    private
+
+    # Only the `test` section matters for parallel mutation runs. Scanning the
+    # whole file would false-positive when dev/prod use SQLite but test uses
+    # Postgres/MySQL. Parse failures (ERB errors, custom helpers, anchor
+    # gymnastics) fall back to "no warning" rather than guessing.
+    def sqlite_in_test_config?(root)
+      path = File.join(root, DATABASE_YML)
+      return false unless File.exist?(path)
+
+      parsed = parse_database_yml(path)
+      return false unless parsed.is_a?(Hash)
+
+      test_config = parsed["test"]
+      return false unless test_config.is_a?(Hash)
+
+      adapter = test_config["adapter"]
+      adapter.is_a?(String) && adapter.downcase.include?("sqlite")
+    end
+
+    def parse_database_yml(path)
+      content = File.read(path)
+      rendered = ERB.new(content).result
+      YAML.safe_load(rendered, aliases: true)
+    rescue StandardError, SyntaxError
+      nil
+    end
+  end
+end

data/lib/evilution/reporter/cli.rb

@@ -7,6 +7,17 @@ class Evilution::Reporter::CLI
 
   def call(summary)
     lines = []
+    append_metrics(lines, summary)
+    append_sections(lines, summary)
+    lines << ""
+    lines << "[TRUNCATED] Stopped early due to --fail-fast" if summary.truncated?
+    lines << result_line(summary)
+    lines.join("\n")
+  end
+
+  private
+
+  def append_metrics(lines, summary)
     lines << header
     lines << SEPARATOR
     lines << ""
@@ -16,20 +27,18 @@ class Evilution::Reporter::CLI
     lines << efficiency_line(summary) if summary.duration.positive?
     peak = summary.peak_memory_mb
     lines << peak_memory_line(peak) if peak
+  end
+
+  def append_sections(lines, summary)
     append_survived(lines, summary)
     append_neutral(lines, summary)
     append_equivalent(lines, summary)
+    append_unresolved(lines, summary)
+    append_unparseable(lines, summary)
     append_errors(lines, summary)
     append_disabled(lines, summary)
-    lines << ""
-    lines << "[TRUNCATED] Stopped early due to --fail-fast" if summary.truncated?
-    lines << result_line(summary)
-
-    lines.join("\n")
   end
 
-  private
-
   def append_survived(lines, summary)
     gaps = summary.coverage_gaps
     return unless gaps.any?
@@ -55,6 +64,22 @@ class Evilution::Reporter::CLI
     summary.equivalent_results.each { |result| lines << format_neutral(result) }
   end
 
+  def append_unresolved(lines, summary)
+    return unless summary.unresolved_results.any?
+
+    lines << ""
+    lines << "Unresolved mutations (no test file resolved):"
+    summary.unresolved_results.each { |result| lines << format_neutral(result) }
+  end
+
+  def append_unparseable(lines, summary)
+    return unless summary.unparseable_results.any?
+
+    lines << ""
+    lines << "Unparseable mutations (mutated source did not parse):"
+    summary.unparseable_results.each { |result| lines << format_neutral(result) }
+  end
+
   def append_errors(lines, summary)
     errored = summary.results.select(&:error?)
     return if errored.empty?
@@ -91,14 +116,14 @@ class Evilution::Reporter::CLI
     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
 
   def score_line(summary)
-    denominator = summary.total - summary.errors - summary.neutral - summary.equivalent - summary.unresolved
     score_pct = format_pct(summary.score)
-    "Score: #{score_pct} (#{summary.killed}/#{denominator})"
+    "Score: #{score_pct} (#{summary.killed}/#{summary.score_denominator})"
   end
 
   def duration_line(summary)
@@ -119,8 +144,9 @@ class Evilution::Reporter::CLI
                operators = gap.operator_names.join(", ")
                "  #{location} (#{gap.subject_name}) [#{gap.count} mutations: #{operators}]"
              end
-    diff_lines = gap.primary_diff.split("\n").map { |l| "    #{l}" }.join("\n")
-    "#{header}\n#{diff_lines}"
+    body = gap.mutation_results.first.mutation.unified_diff || gap.primary_diff
+    indented = body.split("\n").map { |l| "    #{l}" }.join("\n")
+    "#{header}\n#{indented}"
   end
 
   def format_neutral(result)

data/lib/evilution/reporter/html/assets/style.css

@@ -26,6 +26,8 @@ h1 { font-size: 1.5rem; color: #f0f6fc; }
 .map-line.error { color: #f85149; }
 .map-line.neutral { color: #8b949e; }
 .map-line.equivalent { color: #8b949e; }
+.map-line.unresolved { color: #8b949e; }
+.map-line.unparseable { color: #8b949e; }
 .line-number { min-width: 60px; color: #8b949e; }
 .operator { flex: 1; }
 .status-badge { font-size: 0.7rem; padding: 0.1rem 0.5rem; border-radius: 10px; text-transform: uppercase; font-weight: bold; }
@@ -34,6 +36,9 @@ h1 { font-size: 1.5rem; color: #f0f6fc; }
 .status-badge.timeout { background: #4a3a10; }
 .status-badge.neutral { background: #21262d; }
 .status-badge.equivalent { background: #21262d; }
+.status-badge.error { background: #4a3a10; }
+.status-badge.unresolved { background: #21262d; }
+.status-badge.unparseable { background: #21262d; }
 .survived-details { border-top: 1px solid #30363d; padding: 1rem; }
 .survived-details h3 { color: #f85149; font-size: 0.9rem; margin-bottom: 0.75rem; }
 .survived-entry { background: #1c1a1a; border: 1px solid #4a1a1a; border-radius: 6px; padding: 0.75rem; margin-bottom: 0.75rem; }
@@ -63,6 +68,18 @@ h1 { font-size: 1.5rem; color: #f0f6fc; }
 .error-header .operator { color: #d29922; font-weight: bold; }
 .error-header .location { color: #8b949e; font-family: monospace; }
 .error-message { background: #0d1117; border-radius: 4px; padding: 0.5rem 0.75rem; font-size: 0.8rem; color: #f85149; margin-top: 0.5rem; white-space: pre-wrap; overflow-x: auto; }
+.unresolved-details { border-top: 1px solid #30363d; padding: 1rem; }
+.unresolved-details h3 { color: #8b949e; font-size: 0.9rem; margin-bottom: 0.75rem; }
+.unresolved-details ul { list-style: none; }
+.unresolved-details li { font-size: 0.85rem; padding: 0.2rem 0; color: #8b949e; }
+.unresolved-details .operator { color: #c9d1d9; font-family: monospace; margin-right: 0.75rem; }
+.unresolved-details .location { font-family: monospace; }
+.unparseable-details { border-top: 1px solid #30363d; padding: 1rem; }
+.unparseable-details h3 { color: #8b949e; font-size: 0.9rem; margin-bottom: 0.75rem; }
+.unparseable-details ul { list-style: none; }
+.unparseable-details li { font-size: 0.85rem; padding: 0.2rem 0; color: #8b949e; }
+.unparseable-details .operator { color: #c9d1d9; font-family: monospace; margin-right: 0.75rem; }
+.unparseable-details .location { font-family: monospace; }
 .survived-entry.regression { border-color: #f85149; background: #2a1010; }
 .regression-badge { background: #da3633; color: #fff; font-size: 0.65rem; padding: 0.1rem 0.4rem; border-radius: 4px; margin-left: 0.5rem; text-transform: uppercase; font-weight: bold; }
 footer { text-align: center; color: #484f58; font-size: 0.75rem; margin-top: 2rem; padding-top: 1rem; border-top: 1px solid #21262d; }

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

@@ -4,6 +4,9 @@ require_relative "../sections"
 require_relative "mutation_map"
 require_relative "survived_details"
 require_relative "error_details"
+require_relative "neutral_details"
+require_relative "unresolved_details"
+require_relative "unparseable_details"
 
 class Evilution::Reporter::HTML::Sections::FileSection < Evilution::Reporter::HTML::Section
   template "file_section"
@@ -44,4 +47,16 @@ class Evilution::Reporter::HTML::Sections::FileSection < Evilution::Reporter::HT
   def error_html
     Evilution::Reporter::HTML::Sections::ErrorDetails.render_if(@results.select(&:error?))
   end
+
+  def neutral_html
+    Evilution::Reporter::HTML::Sections::NeutralDetails.render_if(@results.select(&:neutral?))
+  end
+
+  def unresolved_html
+    Evilution::Reporter::HTML::Sections::UnresolvedDetails.render_if(@results.select(&:unresolved?))
+  end
+
+  def unparseable_html
+    Evilution::Reporter::HTML::Sections::UnparseableDetails.render_if(@results.select(&:unparseable?))
+  end
 end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative "../sections"
+
+class Evilution::Reporter::HTML::Sections::NeutralDetails < Evilution::Reporter::HTML::Section
+  template "neutral_details"
+
+  def self.render_if(neutral)
+    return "" if neutral.empty?
+
+    new(neutral).render
+  end
+
+  def initialize(neutral)
+    @neutral = neutral
+  end
+
+  private
+
+  attr_reader :neutral
+
+  def sorted
+    neutral.sort_by { |r| [r.mutation.operator_name, r.mutation.line] }
+  end
+end