evilution 0.28.0 → 0.29.0

data/lib/evilution/spec_ast_cache.rb

@@ -62,18 +62,27 @@ class Evilution::SpecAstCache
     raise Evilution::ParseError.new("file not found: #{path}", file: path) unless File.exist?(path)
 
     source = read_source(path)
+    result = parse_source(path, source)
+    collect_blocks(source, result, extract_comment_ranges(result))
+  end
+
+  def parse_source(path, source)
     result = Prism.parse(source)
+    return result unless result.failure?
 
-    if result.failure?
-      raise Evilution::ParseError.new(
-        "failed to parse #{path}: #{result.errors.map(&:message).join(", ")}",
-        file: path
-      )
-    end
+    raise Evilution::ParseError.new(
+      "failed to parse #{path}: #{result.errors.map(&:message).join(", ")}",
+      file: path
+    )
+  end
 
-    comment_ranges = result.comments
-                           .map { |c| c.location.start_offset...c.location.end_offset }
-                           .sort_by(&:begin)
+  def extract_comment_ranges(result)
+    result.comments
+          .map { |c| c.location.start_offset...c.location.end_offset }
+          .sort_by(&:begin)
+  end
+
+  def collect_blocks(source, result, comment_ranges)
     collector = BlockCollector.new(source, comment_ranges)
     collector.visit(result.value)
     collector.blocks
@@ -133,16 +142,21 @@ class Evilution::SpecAstCache
     def strip_comments(slice, base_offset)
       return slice if @comment_ranges.empty?
 
-      ranges = comment_ranges_within(base_offset, base_offset + slice.bytesize)
+      end_offset = base_offset + slice.bytesize
+      ranges = comment_ranges_within(base_offset, end_offset)
       return slice if ranges.empty?
 
+      splice_excluding_ranges(base_offset, end_offset, ranges)
+    end
+
+    def splice_excluding_ranges(start_off, end_off, ranges)
       result = +""
-      cursor = base_offset
+      cursor = start_off
       ranges.each do |range|
         result << @source.byteslice(cursor, range.begin - cursor)
         cursor = range.end
       end
-      result << @source.byteslice(cursor, base_offset + slice.bytesize - cursor)
+      result << @source.byteslice(cursor, end_off - cursor)
       result
     end
 

data/lib/evilution/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Evilution
-  VERSION = "0.28.0"
+  VERSION = "0.29.0"
 end

data/script/memory_check

@@ -30,16 +30,22 @@ end
 
 def report(name, result)
   status = result[:passed] ? "PASS" : "FAIL"
-  growth = result[:growth_mb] ? format("%.1f MB", result[:growth_mb]) : "N/A"
-  max = format("%.1f MB", result[:max_growth_kb] / 1024.0)
-  samples = result[:samples].map { |s| s ? format("%.1f", s / 1024.0) : "N/A" }.join(" -> ")
+  metrics = format_metrics(result)
 
   puts "[#{status}] #{name}"
-  puts "  Growth: #{growth} (max: #{max})"
-  puts "  Samples (MB): #{samples}"
+  puts "  Growth: #{metrics[:growth]} (max: #{metrics[:max]})"
+  puts "  Samples (MB): #{metrics[:samples]}"
   puts
 end
 
+def format_metrics(result)
+  {
+    growth: result[:growth_mb] ? format("%.1f MB", result[:growth_mb]) : "N/A",
+    max: format("%.1f MB", result[:max_growth_kb] / 1024.0),
+    samples: result[:samples].map { |s| s ? format("%.1f", s / 1024.0) : "N/A" }.join(" -> ")
+  }
+end
+
 abort("RSS measurement unavailable (requires /proc filesystem)") unless Evilution::Memory.rss_kb
 
 mutations = setup_workload

data/scripts/benchmark_density

@@ -155,18 +155,19 @@ module BenchmarkDensity
     def print_table(results)
       puts format(HEADER_FMT, file: "File", evilution: "Evilution", reference: "Reference", ratio: "Ratio")
       puts "-" * 75
-
-      results.each do |r|
-        ratio = compute_ratio(r[:evilution], r[:reference])
-        ratio_str = ratio ? format("%.2fx", ratio) : "N/A"
-        ev_str = r[:evilution]&.to_s || "ERR"
-        ref_str = r[:reference]&.to_s || "ERR"
-        puts format(ROW_FMT, file: r[:path], evilution: ev_str, reference: ref_str, ratio: ratio_str)
-      end
-
+      results.each { |r| puts format_result_row(r) }
       puts "-" * 75
     end
 
+    def format_result_row(result)
+      ratio = compute_ratio(result[:evilution], result[:reference])
+      format(ROW_FMT,
+             file: result[:path],
+             evilution: result[:evilution]&.to_s || "ERR",
+             reference: result[:reference]&.to_s || "ERR",
+             ratio: ratio ? format("%.2fx", ratio) : "N/A")
+    end
+
     def print_summary(results)
       totals = compute_totals(results)
       print_total_line(totals)

data/scripts/compare_mutations

@@ -221,17 +221,25 @@ module CompareMutations
       lines = ["## Extra in reference (#{extra.size})", ""]
 
       catalog.summary.each do |entry|
-        lines << "### #{entry[:operator]} (#{entry[:count]})"
-        catalog.by_operator[entry[:operator]].each do |m|
-          lines << "  Line #{m["line"]}:"
-          m["diff"].to_s.each_line { |l| lines << "    #{l.chomp}" }
-          lines << ""
-        end
+        lines.concat(format_operator_group(entry, catalog.by_operator[entry[:operator]]))
       end
 
       lines
     end
 
+    def format_operator_group(entry, mutations)
+      lines = ["### #{entry[:operator]} (#{entry[:count]})"]
+      mutations.each { |m| lines.concat(format_extra_mutation(m)) }
+      lines
+    end
+
+    def format_extra_mutation(mutation)
+      lines = ["  Line #{mutation["line"]}:"]
+      mutation["diff"].to_s.each_line { |l| lines << "    #{l.chomp}" }
+      lines << ""
+      lines
+    end
+
     def build_extra_evilution_section(comparison)
       ev_extra = comparison.extra_in_evilution
       return [] if ev_extra.empty?
@@ -343,34 +351,43 @@ module CompareMutations
 
     def compare_file(path, _reference_target, reporter)
       full_path = File.join(@config.project_root, path)
-      ev_data = @evilution.collect(path)
-      ref_data = @reference.collect(full_path)
-
-      ev_set = MutationSet.from_json(ev_data)
-      ref_set = MutationSet.from_json(ref_data)
+      ev_set = MutationSet.from_json(@evilution.collect(path))
+      ref_set = MutationSet.from_json(@reference.collect(full_path))
       comparison = Comparison.new(evilution: ev_set, reference: ref_set)
       catalog = Catalog.new(comparison.extra_in_reference)
 
       reporter.write_file_report(path, comparison, catalog)
+      build_file_result(path, comparison, catalog)
+    end
 
-      { file: path, evilution_count: ev_set.size, reference_count: ref_set.size,
+    def build_file_result(path, comparison, catalog)
+      {
+        file: path,
+        evilution_count: comparison.evilution_set.size,
+        reference_count: comparison.reference_set.size,
         density_ratio: comparison.density_ratio.round(2),
         extra_count: comparison.extra_in_reference.size,
-        operator_summary: catalog.summary }
+        operator_summary: catalog.summary
+      }
     end
 
     def print_summary(file_results)
-      ev_total = file_results.sum { |r| r[:evilution_count] }
-      ref_total = file_results.sum { |r| r[:reference_count] }
-      extra_total = file_results.sum { |r| r[:extra_count] }
-      ratio = ev_total.positive? ? (ref_total.to_f / ev_total).round(2) : 0.0
+      totals = compute_totals(file_results)
 
       puts "Comparison complete. Results in #{@config.output_dir}/"
       puts "  Files: #{file_results.size}"
-      puts "  Evilution: #{ev_total} mutations"
-      puts "  Reference: #{ref_total} mutations"
-      puts "  Ratio: #{ratio}x"
-      puts "  Extra in reference: #{extra_total}"
+      puts "  Evilution: #{totals[:ev]} mutations"
+      puts "  Reference: #{totals[:ref]} mutations"
+      puts "  Ratio: #{totals[:ratio]}x"
+      puts "  Extra in reference: #{totals[:extra]}"
+    end
+
+    def compute_totals(file_results)
+      ev = file_results.sum { |r| r[:evilution_count] }
+      ref = file_results.sum { |r| r[:reference_count] }
+      extra = file_results.sum { |r| r[:extra_count] }
+      { ev: ev, ref: ref, extra: extra,
+        ratio: ev.positive? ? (ref.to_f / ev).round(2) : 0.0 }
     end
   end
 end

data/scripts/mutant_json_adapter

@@ -128,14 +128,17 @@ module MutantJsonAdapter
     end
 
     def infer_operator(diff_lines)
-      removed = diff_lines.select { |l| l.start_with?("-") && !l.start_with?("---") }
-                          .map { |l| l[1..].strip }
-      added = diff_lines.select { |l| l.start_with?("+") && !l.start_with?("+++") }
-                        .map { |l| l[1..].strip }
+      removed = extract_diff_side(diff_lines, "-", "---")
+      added = extract_diff_side(diff_lines, "+", "+++")
 
       categorize_mutation(removed, added)
     end
 
+    def extract_diff_side(diff_lines, prefix, header)
+      diff_lines.select { |l| l.start_with?(prefix) && !l.start_with?(header) }
+                .map { |l| l[1..].strip }
+    end
+
     def categorize_mutation(removed, added)
       return "replacement" if removed.empty?
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: evilution
 version: !ruby/object:Gem::Version
-  version: 0.28.0
+  version: 0.29.0
 platform: ruby
 authors:
 - Denis Kiselev
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-05-03 00:00:00.000000000 Z
+date: 2026-05-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: diff-lcs
@@ -423,6 +423,7 @@ files:
 - lib/evilution/reporter/progress_bar.rb
 - lib/evilution/reporter/suggestion.rb
 - lib/evilution/reporter/suggestion/diff_helpers.rb
+- lib/evilution/reporter/suggestion/diff_lines.rb
 - lib/evilution/reporter/suggestion/registry.rb
 - lib/evilution/reporter/suggestion/templates.rb
 - lib/evilution/reporter/suggestion/templates/generic.rb