evilution 0.28.0 → 0.29.0

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/templates/minitest.rb

@@ -2,6 +2,7 @@
 
 require_relative "../templates"
 require_relative "../diff_helpers"
+require_relative "../diff_lines"
 
 module Evilution::Reporter::Suggestion::Templates::Minitest
   H = Evilution::Reporter::Suggestion::DiffHelpers
@@ -17,21 +18,26 @@ module Evilution::Reporter::Suggestion::Templates::Minitest
   end
 
   def self.build(test_name:, action: :changed, &body_block)
-    lambda do |mutation|
-      method_name = H.parse_method_name(mutation.subject.name)
-      safe_name = H.sanitize_method_name(method_name)
-      original_line, mutated_line = H.extract_diff_lines(mutation.diff)
-      body = body_block.call(method_name)
-      indented = body.lines.map { |l| "  #{l}" }.join.chomp
+    ->(mutation) { render(test_name, action, body_block, mutation) }
+  end
 
-      <<~MINITEST.strip
-        # Mutation: #{format_header(action, original_line, mutated_line, mutation.subject.name)}
-        # #{mutation.file_path}:#{mutation.line}
-        def test_#{test_name}_#{safe_name}
-        #{indented}
-        end
-      MINITEST
-    end
+  def self.render(test_name, action, body_block, mutation)
+    method_name = H.parse_method_name(mutation.subject.name)
+    safe_name = H.sanitize_method_name(method_name)
+    diff_lines = Evilution::Reporter::Suggestion::DiffLines.from_diff(mutation.diff)
+    indented = indent_body(body_block.call(method_name))
+
+    <<~MINITEST.strip
+      # Mutation: #{format_header(action, diff_lines.original, diff_lines.mutated, mutation.subject.name)}
+      # #{mutation.file_path}:#{mutation.line}
+      def test_#{test_name}_#{safe_name}
+      #{indented}
+      end
+    MINITEST
+  end
+
+  def self.indent_body(body)
+    body.lines.map { |l| "  #{l}" }.join.chomp
   end
 
   MINITEST_ENTRIES = {

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

@@ -2,6 +2,7 @@
 
 require_relative "../templates"
 require_relative "../diff_helpers"
+require_relative "../diff_lines"
 
 module Evilution::Reporter::Suggestion::Templates::Rspec
   H = Evilution::Reporter::Suggestion::DiffHelpers
@@ -17,20 +18,25 @@ module Evilution::Reporter::Suggestion::Templates::Rspec
   end
 
   def self.build(it_desc:, action: :changed, &body_block)
-    lambda do |mutation|
-      method_name = H.parse_method_name(mutation.subject.name)
-      original_line, mutated_line = H.extract_diff_lines(mutation.diff)
-      body = body_block.call(method_name)
-      indented = body.lines.map { |l| "  #{l}" }.join.chomp
+    ->(mutation) { render(it_desc, action, body_block, mutation) }
+  end
 
-      <<~RSPEC.strip
-        # Mutation: #{format_header(action, original_line, mutated_line, mutation.subject.name)}
-        # #{mutation.file_path}:#{mutation.line}
-        it '#{it_desc} ##{method_name}' do
-        #{indented}
-        end
-      RSPEC
-    end
+  def self.render(it_desc, action, body_block, mutation)
+    method_name = H.parse_method_name(mutation.subject.name)
+    diff_lines = Evilution::Reporter::Suggestion::DiffLines.from_diff(mutation.diff)
+    indented = indent_body(body_block.call(method_name))
+
+    <<~RSPEC.strip
+      # Mutation: #{format_header(action, diff_lines.original, diff_lines.mutated, mutation.subject.name)}
+      # #{mutation.file_path}:#{mutation.line}
+      it '#{it_desc} ##{method_name}' do
+      #{indented}
+      end
+    RSPEC
+  end
+
+  def self.indent_body(body)
+    body.lines.map { |l| "  #{l}" }.join.chomp
   end
 
   RSPEC_ENTRIES = {

data/lib/evilution/runner/baseline_runner.rb

@@ -30,18 +30,25 @@ class Evilution::Runner::BaselineRunner
 
   def build_integration
     klass = integration_class
-    test_files = config.spec_files.empty? ? nil : config.spec_files
-    kwargs = {
-      test_files: test_files,
+    kwargs = base_integration_kwargs
+    kwargs.merge!(rspec_integration_kwargs) if klass == Evilution::Integration::RSpec
+    klass.new(**kwargs)
+  end
+
+  def base_integration_kwargs
+    {
+      test_files: config.spec_files.empty? ? nil : config.spec_files,
       hooks: hooks,
       fallback_to_full_suite: config.fallback_to_full_suite?,
       spec_selector: config.spec_selector
     }
-    if klass == Evilution::Integration::RSpec
-      kwargs[:related_specs_heuristic] = config.related_specs_heuristic?
-      kwargs[:example_filter] = build_example_filter
-    end
-    klass.new(**kwargs)
+  end
+
+  def rspec_integration_kwargs
+    {
+      related_specs_heuristic: config.related_specs_heuristic?,
+      example_filter: build_example_filter
+    }
   end
 
   def call(subjects)

data/lib/evilution/runner/diagnostics.rb

@@ -32,19 +32,23 @@ class Evilution::Runner::Diagnostics
   def log_mutation_diagnostics(result)
     return unless verbose?
 
-    parts = []
-    parts << format("child_rss: %<mb>.1f MB", mb: result.child_rss_kb / 1024.0) if result.child_rss_kb
+    parts = mutation_metric_parts(result)
+    stderr.write("[verbose] #{result.mutation}: #{parts.join(", ")}\n") unless parts.empty?
 
-    if result.memory_delta_kb
-      sign = result.memory_delta_kb.negative? ? "" : "+"
-      parts << format("delta: %<sign>s%<mb>.1f MB", sign: sign, mb: result.memory_delta_kb / 1024.0)
-    end
+    log_mutation_error(result) if result.error?
+  end
 
+  def mutation_metric_parts(result)
+    parts = []
+    parts << format("child_rss: %<mb>.1f MB", mb: result.child_rss_kb / 1024.0) if result.child_rss_kb
+    parts << format_memory_delta(result.memory_delta_kb) if result.memory_delta_kb
     parts << gc_stats_string
+    parts
+  end
 
-    stderr.write("[verbose] #{result.mutation}: #{parts.join(", ")}\n") unless parts.empty?
-
-    log_mutation_error(result) if result.error?
+  def format_memory_delta(delta_kb)
+    sign = delta_kb.negative? ? "" : "+"
+    format("delta: %<sign>s%<mb>.1f MB", sign: sign, mb: delta_kb / 1024.0)
   end
 
   def log_worker_stats(stats)

data/lib/evilution/runner/isolation_resolver.rb

@@ -108,16 +108,18 @@ class Evilution::Runner::IsolationResolver
   end
 
   def resolve_preload_path
-    if config.preload.is_a?(String)
-      unless File.file?(config.preload)
-        raise Evilution::ConfigError.new(
-          "preload file not found: #{config.preload.inspect}",
-          file: config.preload
-        )
-      end
-      return config.preload
-    end
+    return resolve_explicit_preload(config.preload) if config.preload.is_a?(String)
+
+    resolve_autodetected_preload
+  end
+
+  def resolve_explicit_preload(path)
+    return path if File.file?(path)
+
+    raise Evilution::ConfigError.new("preload file not found: #{path.inspect}", file: path)
+  end
 
+  def resolve_autodetected_preload
     root = detected_rails_root
     return nil unless root
 

data/lib/evilution/runner/mutation_executor/result_cache.rb

@@ -7,6 +7,8 @@ class Evilution::Runner::MutationExecutor::ResultCache
   CACHEABLE_STATUSES = %i[killed timeout].freeze
   private_constant :CACHEABLE_STATUSES
 
+  Partition = Data.define(:uncached_indices, :cached_results)
+
   def initialize(backend)
     @backend = backend
   end
@@ -56,7 +58,7 @@ class Evilution::Runner::MutationExecutor::ResultCache
       end
     end
 
-    [uncached_indices, cached_results]
+    Partition.new(uncached_indices: uncached_indices, cached_results: cached_results)
   end
 
   private

data/lib/evilution/runner/mutation_executor/strategy/parallel.rb

@@ -18,8 +18,17 @@ class Evilution::Runner::MutationExecutor::Strategy::Parallel
     @notifier.start(mutations.length)
     pool = @pool_factory.call
     state = { results: [], truncated: false, completed: 0 }
-    all_worker_stats = []
+    all_worker_stats = run_batches(mutations, pool, baseline_result, integration, state)
 
+    log_worker_diagnostics(all_worker_stats)
+    @notifier.finish
+    build_result(state)
+  end
+
+  private
+
+  def run_batches(mutations, pool, baseline_result, integration, state)
+    all_worker_stats = []
     mutations.each_slice(@config.jobs) do |batch|
       break if state[:truncated]
 
@@ -27,24 +36,37 @@ class Evilution::Runner::MutationExecutor::Strategy::Parallel
       all_worker_stats.concat(pool.worker_stats)
       process_batch(batch_results, baseline_result, state)
     end
+    all_worker_stats
+  end
 
-    @diagnostics.log_worker_stats(@diagnostics.aggregate_worker_stats(all_worker_stats)) if @diagnostics
-    @notifier.finish
-    [state[:results], state[:truncated]]
+  def log_worker_diagnostics(all_worker_stats)
+    return unless @diagnostics
+
+    @diagnostics.log_worker_stats(@diagnostics.aggregate_worker_stats(all_worker_stats))
   end
 
-  private
+  def build_result(state)
+    Evilution::Runner::MutationExecutor::ExecutionResult.new(results: state[:results], truncated: state[:truncated])
+  end
 
   def run_batch(batch, pool, integration)
-    uncached_indices, cached_results = @cache.partition(batch, packer: @packer)
-    worker_results = run_uncached(batch, uncached_indices, pool, integration)
-    compact_results = merge(batch, uncached_indices, cached_results, worker_results)
-    batch_results = batch.zip(compact_results).map { |m, h| @packer.rebuild(m, h) }
-    uncached_indices.each { |i| @cache.store(batch_results[i].mutation, batch_results[i]) }
+    partition = @cache.partition(batch, packer: @packer)
+    worker_results = run_uncached(batch, partition.uncached_indices, pool, integration)
+    compact_results = merge(batch, partition.uncached_indices, partition.cached_results, worker_results)
+    batch_results = rebuild_results(batch, compact_results)
+    cache_results(batch_results, partition.uncached_indices)
     batch.each(&:strip_sources!)
     batch_results
   end
 
+  def rebuild_results(batch, compact_results)
+    batch.zip(compact_results).map { |m, h| @packer.rebuild(m, h) }
+  end
+
+  def cache_results(batch_results, uncached_indices)
+    uncached_indices.each { |i| @cache.store(batch_results[i].mutation, batch_results[i]) }
+  end
+
   def run_uncached(batch, uncached_indices, pool, integration)
     return [] if uncached_indices.empty?
 

data/lib/evilution/runner/mutation_executor/strategy/sequential.rb

@@ -27,6 +27,6 @@ class Evilution::Runner::MutationExecutor::Strategy::Sequential
     end
 
     @notifier.finish
-    [results, truncated]
+    Evilution::Runner::MutationExecutor::ExecutionResult.new(results: results, truncated: truncated)
   end
 end

data/lib/evilution/runner/mutation_executor.rb

@@ -3,6 +3,8 @@
 require_relative "../runner"
 
 class Evilution::Runner::MutationExecutor
+  ExecutionResult = Data.define(:results, :truncated)
+
   autoload :ResultCache, File.expand_path("mutation_executor/result_cache", __dir__)
   autoload :ResultPacker, File.expand_path("mutation_executor/result_packer", __dir__)
   autoload :ResultNotifier, File.expand_path("mutation_executor/result_notifier", __dir__)

data/lib/evilution/runner/mutation_planner.rb

@@ -9,6 +9,12 @@ require_relative "../equivalent/detector"
 class Evilution::Runner::MutationPlanner
   Plan = Struct.new(:enabled, :equivalent, :skipped_count, :disabled_mutations, keyword_init: true)
 
+  GenerationResult = Data.define(:mutations, :skipped)
+  DisabledFilterResult = Data.define(:enabled, :disabled)
+  SigFilterResult = Data.define(:enabled, :skipped)
+  EquivalentFilterResult = Data.define(:equivalent, :enabled)
+  private_constant :GenerationResult, :DisabledFilterResult, :SigFilterResult, :EquivalentFilterResult
+
   def initialize(config, registry:, disable_detector: Evilution::DisableComment.new,
                  sig_detector: Evilution::AST::SorbetSigDetector.new)
     @config = config
@@ -20,26 +26,39 @@ class Evilution::Runner::MutationPlanner
   end
 
   def call(subjects)
-    mutations, generation_skipped = generate(subjects)
-    mutations, disabled = filter_disabled(mutations)
-    disabled.each(&:strip_sources!) if config.show_disabled?
-    disabled_mutations = config.show_disabled? ? disabled : []
-
-    mutations, sig_skipped = filter_sig_blocks(mutations)
-    equivalent, enabled = filter_equivalent(mutations)
+    generation = generate(subjects)
+    disabled_filter = filter_disabled(generation.mutations)
+    disabled_mutations = compute_disabled_mutations(disabled_filter)
+    sig_filter = filter_sig_blocks(disabled_filter.enabled)
+    equivalent_filter = filter_equivalent(sig_filter.enabled)
 
-    Plan.new(
-      enabled: enabled,
-      equivalent: equivalent,
-      skipped_count: generation_skipped + disabled.length + sig_skipped,
-      disabled_mutations: disabled_mutations
-    )
+    build_plan(equivalent_filter, disabled_mutations, total_skipped(generation, disabled_filter, sig_filter))
   end
 
   private
 
   attr_reader :config, :registry
 
+  def compute_disabled_mutations(disabled_filter)
+    return [] unless config.show_disabled?
+
+    disabled_filter.disabled.each(&:strip_sources!)
+    disabled_filter.disabled
+  end
+
+  def total_skipped(generation, disabled_filter, sig_filter)
+    generation.skipped + disabled_filter.disabled.length + sig_filter.skipped
+  end
+
+  def build_plan(equivalent_filter, disabled_mutations, skipped_count)
+    Plan.new(
+      enabled: equivalent_filter.enabled,
+      equivalent: equivalent_filter.equivalent,
+      skipped_count: skipped_count,
+      disabled_mutations: disabled_mutations
+    )
+  end
+
   def generate(subjects)
     filter = build_ignore_filter
     operator_options = build_operator_options
@@ -47,7 +66,7 @@ class Evilution::Runner::MutationPlanner
       registry.mutations_for(subject, filter: filter, operator_options: operator_options)
     end
     skipped = filter ? filter.skipped_count : 0
-    [mutations, skipped]
+    GenerationResult.new(mutations: mutations, skipped: skipped)
   end
 
   def build_operator_options
@@ -73,7 +92,7 @@ class Evilution::Runner::MutationPlanner
       end
     end
 
-    [enabled, disabled]
+    DisabledFilterResult.new(enabled: enabled, disabled: disabled)
   end
 
   def mutation_disabled?(mutation)
@@ -102,7 +121,7 @@ class Evilution::Runner::MutationPlanner
       end
     end
 
-    [enabled, skipped]
+    SigFilterResult.new(enabled: enabled, skipped: skipped)
   end
 
   def mutation_in_sig_block?(mutation)
@@ -120,6 +139,7 @@ class Evilution::Runner::MutationPlanner
   end
 
   def filter_equivalent(mutations)
-    Evilution::Equivalent::Detector.new.call(mutations)
+    equivalent, enabled = Evilution::Equivalent::Detector.new.call(mutations)
+    EquivalentFilterResult.new(equivalent: equivalent, enabled: enabled)
   end
 end

data/lib/evilution/runner/subject_pipeline.rb

@@ -104,17 +104,27 @@ class Evilution::Runner::SubjectPipeline
 
   def target_matcher
     target = config.target
-    if target.end_with?("*")
-      prefix = target.chomp("*")
-      ->(s) { s.name.split(/[#.]/).first.start_with?(prefix) }
-    elsif target.end_with?("#", ".")
-      prefix = target
-      ->(s) { s.name.start_with?(prefix) }
-    elsif target.include?("#") || target.include?(".")
-      ->(s) { s.name == target }
-    else
-      ->(s) { s.name.start_with?("#{target}#") || s.name.start_with?("#{target}.") }
-    end
+    return wildcard_matcher(target.chomp("*")) if target.end_with?("*")
+    return prefix_matcher(target) if target.end_with?("#", ".")
+    return exact_matcher(target) if target.include?("#") || target.include?(".")
+
+    class_matcher(target)
+  end
+
+  def wildcard_matcher(prefix)
+    ->(s) { s.name.split(/[#.]/).first.start_with?(prefix) }
+  end
+
+  def prefix_matcher(prefix)
+    ->(s) { s.name.start_with?(prefix) }
+  end
+
+  def exact_matcher(target)
+    ->(s) { s.name == target }
+  end
+
+  def class_matcher(target)
+    ->(s) { s.name.start_with?("#{target}#") || s.name.start_with?("#{target}.") }
   end
 
   def filter_by_line_ranges(subjects)

data/lib/evilution/runner.rb

@@ -32,13 +32,13 @@ class Evilution::Runner
     plan = mutation_planner.call(subjects)
     release_subject_nodes(subjects)
     clear_operator_caches
-    results, truncated = run_mutations(plan.enabled, baseline_result)
-    results += equivalent_results(plan.equivalent)
+    execution = run_mutations(plan.enabled, baseline_result)
+    results = execution.results + equivalent_results(plan.equivalent)
     log_memory("after run_mutations", "#{results.length} results")
 
     duration = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time
 
-    summary = Evilution::Result::Summary.new(results: results, duration: duration, truncated: truncated,
+    summary = Evilution::Result::Summary.new(results: results, duration: duration, truncated: execution.truncated,
                                              skipped: plan.skipped_count,
                                              disabled_mutations: plan.disabled_mutations)
     output_report(summary)

data/lib/evilution/session/diff.rb

@@ -38,20 +38,29 @@ class Evilution::Session::Diff
   def call(base_data, head_data)
     base_survivors = base_data["survived"] || []
     head_survivors = head_data["survived"] || []
-
-    base_keys = base_survivors.to_set { |m| mutation_key(m) }
-    head_keys = head_survivors.to_set { |m| mutation_key(m) }
+    fixed, new_survivors, persistent = partition_survivors(base_survivors, head_survivors)
 
     Result.new(
       summary: build_summary_diff(base_data, head_data),
-      fixed: base_survivors.reject { |m| head_keys.include?(mutation_key(m)) },
-      new_survivors: head_survivors.reject { |m| base_keys.include?(mutation_key(m)) },
-      persistent: head_survivors.select { |m| base_keys.include?(mutation_key(m)) }
+      fixed: fixed,
+      new_survivors: new_survivors,
+      persistent: persistent
     )
   end
 
   private
 
+  def partition_survivors(base_survivors, head_survivors)
+    base_keys = base_survivors.to_set { |m| mutation_key(m) }
+    head_keys = head_survivors.to_set { |m| mutation_key(m) }
+
+    [
+      base_survivors.reject { |m| head_keys.include?(mutation_key(m)) },
+      head_survivors.reject { |m| base_keys.include?(mutation_key(m)) },
+      head_survivors.select { |m| base_keys.include?(mutation_key(m)) }
+    ]
+  end
+
   def build_summary_diff(base_data, head_data)
     base = extract_summary_values(base_data)
     head = extract_summary_values(head_data)