evilution 0.6.0 → 0.8.0

data/lib/evilution/runner.rb

@@ -2,8 +2,10 @@
 
 require_relative "config"
 require_relative "ast/parser"
+require_relative "memory"
 require_relative "mutator/registry"
 require_relative "isolation/fork"
+require_relative "isolation/in_process"
 require_relative "integration/rspec"
 require_relative "reporter/json"
 require_relative "reporter/cli"
@@ -13,6 +15,7 @@ require_relative "diff/file_filter"
 require_relative "git/changed_files"
 require_relative "result/mutation_result"
 require_relative "result/summary"
+require_relative "baseline"
 require_relative "parallel/pool"
 
 module Evilution
@@ -23,7 +26,7 @@ module Evilution
       @config = config
       @parser = AST::Parser.new
       @registry = Mutator::Registry.default
-      @isolator = Isolation::Fork.new
+      @isolator = build_isolator
     end
 
     def call
@@ -33,8 +36,14 @@ module Evilution
       subjects = filter_by_target(subjects) if config.target?
       subjects = filter_by_line_ranges(subjects) if config.line_ranges?
       subjects = filter_by_diff(subjects) if config.diff?
+      log_memory("after parse_subjects", "#{subjects.length} subjects")
+
+      baseline_result = run_baseline(subjects)
+
       mutations = generate_mutations(subjects)
-      results, truncated = run_mutations(mutations)
+      results, truncated = run_mutations(mutations, baseline_result)
+      log_memory("after run_mutations", "#{results.length} results")
+
       duration = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time
 
       summary = Result::Summary.new(results: results, duration: duration, truncated: truncated)
@@ -83,19 +92,34 @@ module Evilution
     end
 
     def generate_mutations(subjects)
-      subjects.flat_map { |subject| registry.mutations_for(subject) }
+      subjects.flat_map do |subject|
+        mutations = registry.mutations_for(subject)
+        subject.release_node!
+        mutations
+      end
+    end
+
+    def run_baseline(subjects)
+      return nil unless config.baseline? && subjects.any?
+
+      log_baseline_start
+      baseline = Baseline.new(timeout: config.timeout)
+      result = baseline.call(subjects)
+      log_baseline_complete(result)
+      result
     end
 
-    def run_mutations(mutations)
+    def run_mutations(mutations, baseline_result = nil)
       if config.jobs > 1
-        run_mutations_parallel(mutations)
+        run_mutations_parallel(mutations, baseline_result)
       else
-        run_mutations_sequential(mutations)
+        run_mutations_sequential(mutations, baseline_result)
       end
     end
 
-    def run_mutations_sequential(mutations)
+    def run_mutations_sequential(mutations, baseline_result = nil)
       integration = build_integration
+      spec_resolver = baseline_result&.failed? ? SpecResolver.new : nil
       results = []
       survived_count = 0
       truncated = false
@@ -107,11 +131,14 @@ module Evilution
           test_command: test_command,
           timeout: config.timeout
         )
+        mutation.strip_sources!
+        result = neutralize_if_baseline_failed(result, baseline_result, spec_resolver)
         results << result
         survived_count += 1 if result.survived?
-        log_progress(index + 1, mutations.length, result.status)
+        log_progress(index + 1, result.status)
+        log_mutation_diagnostics(result)
 
-        if config.fail_fast? && survived_count >= config.fail_fast && index < mutations.length - 1
+        if config.fail_fast? && survived_count >= config.fail_fast
           truncated = true
           break
         end
@@ -120,37 +147,105 @@ module Evilution
       [results, truncated]
     end
 
-    def run_mutations_parallel(mutations)
+    def run_mutations_parallel(mutations, baseline_result = nil)
       integration = build_integration
       pool = Parallel::Pool.new(size: config.jobs)
-      results = []
-      survived_count = 0
-      truncated = false
-      completed = 0
+      worker_isolator = Isolation::InProcess.new
+      spec_resolver = baseline_result&.failed? ? SpecResolver.new : nil
+      state = { results: [], survived_count: 0, truncated: false, completed: 0 }
 
       mutations.each_slice(config.jobs) do |batch|
-        break if truncated
+        break if state[:truncated]
 
-        batch_results = pool.map(batch) do |mutation|
+        compact_results = pool.map(batch) do |mutation|
           test_command = ->(m) { integration.call(m) }
-          isolator.call(mutation: mutation, test_command: test_command, timeout: config.timeout)
+          result = worker_isolator.call(mutation: mutation, test_command: test_command, timeout: config.timeout)
+          compact_result(result)
         end
 
-        batch_results.each do |result|
-          results << result
-          survived_count += 1 if result.survived?
-          completed += 1
-          log_progress(completed, mutations.length, result.status)
-        end
+        batch.each(&:strip_sources!)
+        batch_results = rebuild_results(batch, compact_results)
+        process_batch(batch_results, baseline_result, spec_resolver, state)
+      end
+
+      [state[:results], state[:truncated]]
+    end
 
-        truncated = true if should_truncate?(survived_count, completed, mutations.length)
+    def process_batch(batch_results, baseline_result, spec_resolver, state)
+      batch_results.each do |result|
+        result = neutralize_if_baseline_failed(result, baseline_result, spec_resolver)
+        state[:results] << result
+        state[:survived_count] += 1 if result.survived?
+        state[:completed] += 1
+        log_progress(state[:completed], result.status)
+        log_mutation_diagnostics(result)
       end
 
-      [results, truncated]
+      log_memory("after batch", "#{state[:completed]} complete")
+      state[:truncated] = true if should_truncate?(state[:survived_count])
+    end
+
+    def neutralize_if_baseline_failed(result, baseline_result, spec_resolver)
+      return result unless result.survived? && baseline_result && baseline_result.failed?
+
+      if config.spec_files.any?
+        neutralize = true
+      else
+        spec_file = spec_resolver.call(result.mutation.file_path) || "spec"
+        neutralize = baseline_result.failed_spec_files.include?(spec_file)
+      end
+      return result unless neutralize
+
+      Result::MutationResult.new(
+        mutation: result.mutation,
+        status: :neutral,
+        duration: result.duration,
+        test_command: result.test_command,
+        child_rss_kb: result.child_rss_kb,
+        memory_delta_kb: result.memory_delta_kb
+      )
+    end
+
+    def compact_result(result)
+      {
+        status: result.status,
+        duration: result.duration,
+        killing_test: result.killing_test,
+        test_command: result.test_command,
+        child_rss_kb: result.child_rss_kb,
+        memory_delta_kb: result.memory_delta_kb
+      }
     end
 
-    def should_truncate?(survived_count, completed, total)
-      config.fail_fast? && survived_count >= config.fail_fast && completed < total
+    def rebuild_results(batch, compact_results)
+      batch.zip(compact_results).map do |mutation, data|
+        Result::MutationResult.new(
+          mutation: mutation,
+          status: data[:status],
+          duration: data[:duration],
+          killing_test: data[:killing_test],
+          test_command: data[:test_command],
+          child_rss_kb: data[:child_rss_kb],
+          memory_delta_kb: data[:memory_delta_kb]
+        )
+      end
+    end
+
+    def should_truncate?(survived_count)
+      config.fail_fast? && survived_count >= config.fail_fast
+    end
+
+    def build_isolator
+      case resolve_isolation
+      when :fork then Isolation::Fork.new
+      when :in_process then Isolation::InProcess.new
+      end
+    end
+
+    def resolve_isolation
+      return :fork if config.isolation == :fork
+
+      :in_process
     end
 
     def build_integration
@@ -171,10 +266,64 @@ module Evilution
       $stdout.puts(output) unless config.quiet
     end
 
-    def log_progress(current, total, status)
+    def log_baseline_start
+      return if config.quiet || !config.text? || !$stderr.tty?
+
+      $stderr.write("Running baseline test suite...\n")
+    end
+
+    def log_baseline_complete(result)
       return if config.quiet || !config.text? || !$stderr.tty?
 
-      $stderr.write("mutation #{current}/#{total} #{status}\n")
+      count = result.failed_spec_files.size
+      $stderr.write("Baseline complete: #{count} failing spec file#{"s" unless count == 1}\n")
+    end
+
+    def log_progress(current, status)
+      return if config.quiet || !config.text? || !$stderr.tty?
+
+      $stderr.write("mutation #{current} #{status}\n")
+    end
+
+    def log_memory(phase, context = nil)
+      return unless config.verbose && !config.quiet
+
+      rss = Memory.rss_mb
+      return unless rss
+
+      gc = gc_stats_string
+      msg = format("[memory] %<phase>s: %<rss>.1f MB", phase: phase, rss: rss)
+      context = [context, gc].compact.join(", ")
+      msg += " (#{context})" unless context.empty?
+      $stderr.write("#{msg}\n")
+    end
+
+    def log_mutation_diagnostics(result)
+      return unless config.verbose && !config.quiet
+
+      parts = []
+      parts << format("child_rss: %<mb>.1f MB", mb: result.child_rss_kb / 1024.0) if result.child_rss_kb
+
+      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
+
+      parts << gc_stats_string
+
+      return if parts.empty?
+
+      $stderr.write("[verbose] #{result.mutation}: #{parts.join(", ")}\n")
+    end
+
+    def gc_stats_string
+      stats = GC.stat
+      format(
+        "heap_live_slots: %<live>d, allocated: %<alloc>d, freed: %<freed>d",
+        live: stats[:heap_live_slots],
+        alloc: stats[:total_allocated_objects],
+        freed: stats[:total_freed_objects]
+      )
     end
 
     def build_reporter

data/lib/evilution/subject.rb

@@ -10,7 +10,10 @@ module Evilution
       @line_number = line_number
       @source = source
       @node = node
-      freeze
+    end
+
+    def release_node!
+      @node = nil
     end
 
     def to_s

data/lib/evilution/version.rb

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

data/lib/evilution.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "evilution/version"
+require_relative "evilution/memory"
 require_relative "evilution/config"
 require_relative "evilution/subject"
 require_relative "evilution/mutation"
@@ -26,8 +27,14 @@ require_relative "evilution/mutator/operator/method_body_replacement"
 require_relative "evilution/mutator/operator/return_value_removal"
 require_relative "evilution/mutator/operator/collection_replacement"
 require_relative "evilution/mutator/operator/method_call_removal"
+require_relative "evilution/mutator/operator/argument_removal"
+require_relative "evilution/mutator/operator/block_removal"
+require_relative "evilution/mutator/operator/conditional_flip"
+require_relative "evilution/mutator/operator/range_replacement"
+require_relative "evilution/mutator/operator/regexp_mutation"
 require_relative "evilution/mutator/registry"
 require_relative "evilution/isolation/fork"
+require_relative "evilution/isolation/in_process"
 require_relative "evilution/parallel/pool"
 require_relative "evilution/diff/parser"
 require_relative "evilution/diff/file_filter"
@@ -42,6 +49,7 @@ require_relative "evilution/reporter/suggestion"
 require_relative "evilution/coverage/collector"
 require_relative "evilution/coverage/test_map"
 require_relative "evilution/spec_resolver"
+require_relative "evilution/baseline"
 require_relative "evilution/cli"
 require_relative "evilution/runner"
 

data/lib/tasks/memory_check.rake

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+namespace :memory do
+  desc "Run memory leak checks against fixture workload"
+  task :check do
+    script = File.expand_path("../../script/memory_check", __dir__)
+    system("ruby", script) || abort("Memory check failed!")
+  end
+end

data/script/memory_check

@@ -0,0 +1,94 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative "../lib/evilution"
+require_relative "../lib/evilution/memory/leak_check"
+
+FIXTURE = File.expand_path("../spec/support/fixtures/simple_class.rb", __dir__)
+ITERATIONS = Integer(ENV.fetch("MEMORY_CHECK_ITERATIONS", 50))
+MAX_GROWTH_KB = Integer(ENV.fetch("MEMORY_CHECK_MAX_GROWTH_KB", 10_240))
+
+def setup_workload
+  parser = Evilution::AST::Parser.new
+  registry = Evilution::Mutator::Registry.default
+  subjects = parser.call(FIXTURE)
+  mutations = subjects.flat_map { |s| registry.mutations_for(s) }
+  abort("No mutations found in fixture") if mutations.empty?
+  mutations
+end
+
+def run_check(name, iterations: ITERATIONS, max_growth_kb: MAX_GROWTH_KB, &)
+  check = Evilution::Memory::LeakCheck.new(iterations: iterations, max_growth_kb: max_growth_kb)
+  result = check.run(&)
+  report(name, result)
+  result[:passed]
+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(" -> ")
+
+  puts "[#{status}] #{name}"
+  puts "  Growth: #{growth} (max: #{max})"
+  puts "  Samples (MB): #{samples}"
+  puts
+end
+
+abort("RSS measurement unavailable (requires /proc filesystem)") unless Evilution::Memory.rss_kb
+
+mutations = setup_workload
+stub_test_command = ->(_m) { { passed: false } }
+all_passed = true
+
+# 1. InProcess isolation
+all_passed &= run_check("InProcess isolation") do
+  mutation = mutations.sample
+  isolator = Evilution::Isolation::InProcess.new
+  isolator.call(mutation: mutation, test_command: stub_test_command, timeout: 5)
+end
+
+# 2. Fork isolation
+all_passed &= run_check("Fork isolation") do
+  mutation = mutations.sample
+  isolator = Evilution::Isolation::Fork.new
+  isolator.call(mutation: mutation, test_command: stub_test_command, timeout: 5)
+end
+
+# 3. Mutation generation + stripping
+parser = Evilution::AST::Parser.new
+registry = Evilution::Mutator::Registry.default
+
+all_passed &= run_check("Mutation generation + stripping") do
+  subjects = parser.call(FIXTURE)
+  new_mutations = subjects.flat_map { |s| registry.mutations_for(s) }
+  subjects.each(&:release_node!)
+  new_mutations.each(&:strip_sources!)
+end
+
+# 4. Parallel pool with compact serialization
+if mutations.size >= 2
+  all_passed &= run_check("Parallel pool (compact)", iterations: 20) do
+    pool = Evilution::Parallel::Pool.new(size: 2)
+    batch = mutations.first(2)
+    worker_isolator = Evilution::Isolation::InProcess.new
+
+    compact_results = pool.map(batch) do |mutation|
+      result = worker_isolator.call(mutation: mutation, test_command: stub_test_command, timeout: 5)
+      { status: result.status, duration: result.duration,
+        child_rss_kb: result.child_rss_kb, memory_delta_kb: result.memory_delta_kb }
+    end
+
+    batch.each(&:strip_sources!)
+    batch.zip(compact_results).map do |mutation, data|
+      Evilution::Result::MutationResult.new(
+        mutation: mutation, status: data[:status], duration: data[:duration],
+        child_rss_kb: data[:child_rss_kb], memory_delta_kb: data[:memory_delta_kb]
+      )
+    end
+  end
+end
+
+puts all_passed ? "All memory checks passed." : "Some memory checks failed!"
+exit(all_passed ? 0 : 1)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: evilution
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.8.0
 platform: ruby
 authors:
 - Denis Kiselev
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-03-17 00:00:00.000000000 Z
+date: 2026-03-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: diff-lcs
@@ -80,6 +80,7 @@ files:
 - lib/evilution.rb
 - lib/evilution/ast/parser.rb
 - lib/evilution/ast/source_surgeon.rb
+- lib/evilution/baseline.rb
 - lib/evilution/cli.rb
 - lib/evilution/config.rb
 - lib/evilution/coverage/collector.rb
@@ -90,17 +91,23 @@ files:
 - lib/evilution/integration/base.rb
 - lib/evilution/integration/rspec.rb
 - lib/evilution/isolation/fork.rb
+- lib/evilution/isolation/in_process.rb
 - lib/evilution/mcp/mutate_tool.rb
 - lib/evilution/mcp/server.rb
+- lib/evilution/memory.rb
+- lib/evilution/memory/leak_check.rb
 - lib/evilution/mutation.rb
 - lib/evilution/mutator/base.rb
+- lib/evilution/mutator/operator/argument_removal.rb
 - lib/evilution/mutator/operator/arithmetic_replacement.rb
 - lib/evilution/mutator/operator/array_literal.rb
+- lib/evilution/mutator/operator/block_removal.rb
 - lib/evilution/mutator/operator/boolean_literal_replacement.rb
 - lib/evilution/mutator/operator/boolean_operator_replacement.rb
 - lib/evilution/mutator/operator/collection_replacement.rb
 - lib/evilution/mutator/operator/comparison_replacement.rb
 - lib/evilution/mutator/operator/conditional_branch.rb
+- lib/evilution/mutator/operator/conditional_flip.rb
 - lib/evilution/mutator/operator/conditional_negation.rb
 - lib/evilution/mutator/operator/float_literal.rb
 - lib/evilution/mutator/operator/hash_literal.rb
@@ -109,6 +116,8 @@ files:
 - lib/evilution/mutator/operator/method_call_removal.rb
 - lib/evilution/mutator/operator/negation_insertion.rb
 - lib/evilution/mutator/operator/nil_replacement.rb
+- lib/evilution/mutator/operator/range_replacement.rb
+- lib/evilution/mutator/operator/regexp_mutation.rb
 - lib/evilution/mutator/operator/return_value_removal.rb
 - lib/evilution/mutator/operator/statement_deletion.rb
 - lib/evilution/mutator/operator/string_literal.rb
@@ -124,6 +133,8 @@ files:
 - lib/evilution/spec_resolver.rb
 - lib/evilution/subject.rb
 - lib/evilution/version.rb
+- lib/tasks/memory_check.rake
+- script/memory_check
 - sig/evilution.rbs
 homepage: https://github.com/marinazzio/evilution
 licenses: