kimera 0.1.2 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 042a730e48edfef4744060425cd10f04e34006025af3f36db3ab17f0be59e0bc
-  data.tar.gz: 97a3914ca3f803f01e68564af89ee07667703aadfa6ec74269bbf37470add0fb
+  metadata.gz: 05af564bc168e88e752fd28c2c623d8fe03b3d02402472819930015ceaff5492
+  data.tar.gz: 1708453bd3e4fb16b5eb054be04e94ff4ab8dc06a2c6297adc257c8e23d5fb9e
 SHA512:
-  metadata.gz: 2c2d774a35384621bca26d92d5c9e77550f3b08ecf1304019b37e695eeacbbc5566622de50fbae65077f61035fa25e241817aa31e917c0455e8ad23b26c00f9b
-  data.tar.gz: 7ebd3017fd0edbd7a2abb3c585ee347dfe0b66a03111ffa9efb322b835b6661d29bd2554f863bc075035f242da3bf66f514f098ebaf2b64339b39b90f8dde558
+  metadata.gz: 98620d29d7d69bdca3fc0bd51b51ee040e7a033627841e41e42860623cfd006d617805b817d428a2d688ca5df4c24ffde65aca0337985d7898ffae03b2f816c0
+  data.tar.gz: e509c0ff5416eb1cb41d8d933190d8e9d63249e010791e07ba5b0c0b0678d7e7d00aef6d2bee28dac103cfa4d8ffe6aea22b8515549b79a0bfe299f58df30d58

data/CHANGELOG.md

@@ -1,5 +1,65 @@
 # Changelog
 
+## 0.1.4 (2026-09-27)
+
+- Guard-style memoization is no longer mutated, just as `@x ||=` never was.
+  In a method that opens with `return @x if @x` (and assigns `@x` later) or
+  `return if @x` then `@x = true`, the guard gets no `condition` mutant and
+  the flag no `true => false`. Removing a memo only recomputes an equal value,
+  so those mutants always survived. A re-entrancy guard of the same shape is
+  skipped too.
+- `--isolated` first runs the unmutated suite once in a fresh mirror. If it
+  isn't green there (for example, a test helper that won't load), the run
+  stops with exit 1 and the error, as a red warm baseline does. Before, every
+  mutant it covered was scored `killed` with no failing test named.
+- An isolated mirror symlinks `vendor/`, `node_modules/` and `.bundle/`
+  instead of leaving them out. It creates `tmp/` and `log/` empty, and still
+  leaves out `.git/` and `coverage/`. A boot that needs frontend tooling or a
+  vendored bundle now loads in the mirror.
+- An isolated kill caused by a test file failing to load now puts the load
+  error (Minitest: message and first backtrace lines; RSpec: its load-error
+  report) in the result's `detail`.
+- Parallel warm workers follow Rails' fork contract more closely. Each sets
+  `ActiveSupport::TestCase.parallel_worker_id` to its slot, so per-worker
+  resources keyed on it (a Redis db, lease or key namespace, a port) no
+  longer collide between workers. `parallelize_before_fork` hooks run once per
+  fleet, not again before every spawn (including replacement workers forked
+  while other workers are mid-test). `parallelize_teardown` hooks get the
+  worker number.
+- A red parallel baseline lists, for each worker that ran a failing test,
+  where each failure fell in that worker's run and which tests ran just
+  before it. A test lost when its worker hit the hard timeout or crashed now
+  says so, instead of showing up as an unexplained failure.
+
+## 0.1.3 (2026-09-27)
+
+- `--isolated` no longer scores a child that crashes before reporting results
+  as a kill. It is `harness_error`, and its `detail` gives the exit status and
+  the ends of the child's stderr. A Minitest child that fails to load a test
+  file still reports that as a kill, as the RSpec child already did.
+- `--isolated` passes test ids and test files to the child in a request file
+  instead of argv, so a mutant covered by thousands of tests no longer fails
+  with `Errno::E2BIG: Argument list too long`.
+- Warm reload-path mutants (for example, statements in a memoized method) run
+  one test at a time and stop at the first failure. Tests covering the
+  mutant's method run first. The hard timeout now applies to each test, not
+  the whole suite, so a mutant a test kills is no longer reported as
+  "reload worker produced no result". A test that overruns the timeout is a
+  `timeout`, and a worker that dies names its exit status or signal.
+- A scope or association declared in a concern's `included do` block is now
+  instrumented in the classes that already included the concern. It used to be
+  reported `no_coverage`, or `survived` when it was covered through another
+  path.
+- An association overlaid on a parent model now also reaches subclasses that
+  declared associations of their own (such as STI children). They used to keep
+  the unguarded reflection, so mutants in the association's scope lambda
+  survived.
+- The red-baseline hint prints a plain Minitest command for a Minitest suite
+  instead of `rspec …`.
+- `kimera report`/`kimera mutant` and incremental sessions read report JSON as
+  UTF-8, so they no longer crash under a non-UTF-8 locale when a report
+  contains non-ASCII text.
+
 ## 0.1.2 (2026-09-26)
 
 - Kimera sets `KIMERA=1` in its own process before loading the suite, and in

data/README.md

@@ -220,7 +220,10 @@ selector and Kimera's own harness-critical files (see below).
 
 An isolated child is judged on its failed tests, not its exit status. A child
 that exits non-zero with no failing test is `harness_error` (unjudged, gated
-by `--max-errors`), not a kill. The usual cause is a coverage floor such as
+by `--max-errors`), not a kill. So is a child that dies before reporting any
+results (a boot error, an exit hook, a crash); its `detail` carries the
+child's exit status and the ends of its stderr. The usual cause of a non-zero
+exit with no failures is a coverage floor such as
 SimpleCov's `minimum_coverage`, which a partial run always trips. Kimera sets
 `KIMERA=1` wherever it loads your suite (the warm process, `--isolated`
 children, and `kimera doctor`'s test commands), so skip the floor there:
@@ -231,6 +234,13 @@ SimpleCov.start { minimum_coverage(line: 100, branch: 100) unless ENV["KIMERA"]
 
 `kimera doctor` warns when it finds an ungated `minimum_coverage`.
 
+Each isolated mirror is a copy of the project root with some exceptions:
+`.git/` and `coverage/` are left out, `tmp/` and `log/` start empty, and
+`vendor/`, `node_modules/` and `.bundle/` are symlinked to the originals. The
+exception is a directory that holds a mutated file, which is always copied.
+Before judging any mutant, `--isolated` runs the unmutated suite once in a
+mirror. If it isn't green there, the run stops with exit 1 and the error.
+
 ### Progress output
 
 During a run, a progress bar tracks each phase on stderr. It shows only when
@@ -303,6 +313,13 @@ The *default* set is small and low-noise:
 - `!x => x`
 - forced `if` conditions
 
+Memoization is not a mutation target. Dropping a memo only recomputes an equal
+value, so that mutant would always survive. `@x ||= …` has no such mutant, and
+neither does a guard that opens a method: `return @x if defined?(@x)`,
+`return @x if @x` (with `@x` assigned later in the method), or `return if @x`
+followed by `@x = true`. Everything the method computes is still mutated. A
+re-entrancy guard with the run-once shape is skipped too.
+
 The extended families are one flag away. Use `--operators all`, or pick from:
 
 | family | mutation |

data/lib/kimera/cli/report_file.rb

@@ -13,7 +13,7 @@ module Kimera::CLI::ReportFile
   module_function
 
   def parse(path)
-    JSON.parse(File.read(path))
+    JSON.parse(File.read(path, encoding: Encoding::UTF_8))
   rescue JSON::ParserError => error
     raise(Kimera::UsageError, "unreadable report #{path}: #{error.message}")
   end

data/lib/kimera/cli/run/pass.rb

@@ -63,7 +63,7 @@ class Kimera::CLI::Run::Pass
   end
 
   def run(remaining)
-    isolated = ->(ids) { isolation.run(ids: ids, label: "mutants (isolated)") }
+    isolated = ->(ids) { judge(ids) }
     return isolated.call(remaining) if @options[:isolated]
     pooled(remaining, isolated)
   end
@@ -74,8 +74,13 @@ class Kimera::CLI::Run::Pass
     harness.run(ids: together, label: "mutants (warm)").merge(isolated.call(apart))
   end
 
+  def judge(ids)
+    isolation.verify!
+    isolation.run(ids: ids, label: "mutants (isolated)")
+  end
+
   def isolation
-    Kimera::Execution::IsolatedExecution.new(**core, **{ hard_timeout: @options[:hard_timeout] }.compact)
+    @_isolation ||= Kimera::Execution::IsolatedExecution.new(**core, **limits)
   end
 
   def core
@@ -84,6 +89,8 @@ class Kimera::CLI::Run::Pass
       .merge(framework: @options[:framework], test_files: files)
   end
 
+  def limits = { hard_timeout: @options[:hard_timeout] }.compact
+
   def split(ids)
     patterns = Array(@options[:isolate_when_covered_by])
     ids.partition do |id|

data/lib/kimera/execution/baseline_failure/breakdown.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+class Kimera::Execution::BaselineFailure::Breakdown
+  MAX_FAILURES = 5
+  PRECEDING = 3
+
+  def initialize(failed, workers)
+    @failed = failed
+    @workers = workers
+  end
+
+  def to_s
+    lines = @workers.sort_by(&:first).filter_map { |slot, ids| worker(slot, ids) }
+    lines.empty? ? "" : "\n  per worker (tests in the order it ran them):\n#{lines.join("\n")}"
+  end
+
+  private
+
+  def worker(slot, ids)
+    hits = ids.each_index.select { |index| @failed.include?(ids[index]) }
+    return if hits.empty?
+    "    worker #{slot}: ran #{ids.size}; failed #{failures(ids, hits)}#{preceding(ids, hits.first)}"
+  end
+
+  def failures(ids, hits)
+    shown = hits.first(MAX_FAILURES).map { |index| "##{index + 1} #{ids[index]}" }
+    extra = hits.size - shown.size
+    shown.join(", ") + (extra.positive? ? " (+#{extra} more)" : "")
+  end
+
+  def preceding(ids, first)
+    before = ids[[first - PRECEDING, 0].max...first]
+    before.empty? ? " (first test on this worker)" : "; just before: #{before.join(", ")}"
+  end
+end

data/lib/kimera/execution/baseline_failure.rb

@@ -10,16 +10,28 @@ end
 class Kimera::Execution::BaselineFailure < Kimera::Error
   MAX_DETAILS = 3
   MAX_MESSAGE = 300
+  LOSSES = { timeout: "its worker was killed at the hard timeout (--hard-timeout) before reporting a result" }.freeze
+  CRASH = "its worker died before reporting a result"
 
   class << self
-    def build(failed, messages)
-      new(summary(failed, messages))
+    def build(failed, messages, command, workers: {})
+      new(summary(failed, messages, command, workers: workers))
     end
 
-    def summary(failed, messages)
+    def lost(reason) = LOSSES.fetch(reason, CRASH)
+
+    def mirrored(reason, hint)
+      new(
+        "isolated baseline is not green: the unmutated suite fails in a mirror of the project\n  " \
+          "#{reason.gsub("\n", "\n    ")}\n#{hint}"
+      )
+    end
+
+    def summary(failed, messages, command, workers: {})
       text = "baseline suite is not green: #{failed.join(", ")}"
       text += appendix(failed, messages)
-      "#{text}\n#{reproduce(failed)}"
+      text += Kimera::Execution::BaselineFailure::Breakdown.new(failed, workers).to_s
+      "#{text}\n  reproduce without kimera: #{command}"
     end
 
     def appendix(failed, messages)
@@ -39,9 +51,7 @@ class Kimera::Execution::BaselineFailure < Kimera::Error
     def truncate(text)
       text.length > MAX_MESSAGE ? "#{text[0, MAX_MESSAGE]}…" : text
     end
-
-    def reproduce(failed)
-      "  reproduce without kimera: rspec #{failed.first(MAX_DETAILS).join(" ")} --order defined"
-    end
   end
 end
+
+require_relative "baseline_failure/breakdown"

data/lib/kimera/execution/baseline_pass.rb

@@ -71,7 +71,13 @@ class Kimera::Execution::BaselinePass
   end
 
   def dispatch
-    yield(resolve: resolve, lost: loss)
+    yield(resolve: resolve, lost: loss, trace: tracer)
+  end
+
+  def journal = @_journal ||= Hash.new { |workers, slot| workers[slot] = [] }
+
+  def tracer
+    ->(slot, test_id) { journal[slot] << test_id }
   end
 
   def resolve
@@ -90,7 +96,8 @@ class Kimera::Execution::BaselinePass
     method(:lost)
   end
 
-  def lost(test_id, _reason)
+  def lost(test_id, reason)
+    @messages[test_id] = Kimera::Execution::BaselineFailure.lost(reason)
     tally.failures << test_id
     @progress.tick
   end
@@ -118,6 +125,7 @@ class Kimera::Execution::BaselinePass
   end
 
   def failure!(failed)
-    raise(Kimera::Execution::BaselineFailure.build(failed, @messages))
+    command = @adapter.reproduce(failed.first(Kimera::Execution::BaselineFailure::MAX_DETAILS))
+    raise(Kimera::Execution::BaselineFailure.build(failed, @messages, command, workers: journal))
   end
 end

data/lib/kimera/execution/harness.rb

@@ -126,8 +126,8 @@ class Kimera::Execution::Harness
   end
 
   def parallel(pass)
-    pass.parallel! do |resolve:, lost:|
-      driver.drive(adapter.test_ids, driver.method(:channel), resolve: resolve, lost: lost)
+    pass.parallel! do |resolve:, lost:, trace:|
+      driver.drive(adapter.test_ids, driver.method(:channel), resolve: resolve, lost: lost, trace: trace)
     end
   end
 

data/lib/kimera/execution/isolated.rb

@@ -5,6 +5,7 @@ require "tmpdir"
 require_relative "../results/result"
 require_relative "../results/run_report"
 require_relative "../synthesis/overlay"
+require_relative "baseline_failure"
 require_relative "isolated_plan"
 require_relative "isolated_scheduling"
 require_relative "isolated_verdict"
@@ -30,6 +31,13 @@ class Kimera::Execution::IsolatedExecution
     @options = options
   end
 
+  def verify!
+    errors.puts("kimera: isolated baseline (unmutated mirror)") unless progress.enabled?
+    outcome = with_mirror { |mirror| verdict(mirror, plan.suite) }
+    return if outcome.status == :survived
+    raise(Kimera::Execution::BaselineFailure.mirrored(outcome.explain(limit), Kimera::Execution::IsolatedPlan::MIRROR_HINT))
+  end
+
   def run(ids: self.ids, label: "mutants")
     progress.start(ids.size, label)
     report(ids)

data/lib/kimera/execution/isolated_child.rb

@@ -9,15 +9,19 @@ begin
 rescue StandardError, ScriptError
   nil
 end
-RSpec.configuration.output_stream = StringIO.new
+output = StringIO.new
+RSpec.configuration.output_stream = output
 RSpec.configuration.error_stream = StringIO.new
 RSpec.configuration.deprecation_stream = StringIO.new
 
-ledger, *locations = ARGV
+ledger, request = ARGV
+locations = JSON.parse(File.read(request, encoding: Encoding::UTF_8)).fetch("tests")
 code = RSpec::Core::Runner.run(locations)
 
 failed = RSpec.world.all_examples.select { |example| example.execution_result.status == :failed }
 outside = RSpec.world.non_example_failure ? 1 : 0
-File.write(ledger, JSON.generate(failures: failed.size + outside, failing: failed.map(&:id)))
+report = { failures: failed.size + outside, failing: failed.map(&:id) }
+report[:load_error] = output.string.strip[0, 4000] if outside.positive?
+File.write(ledger, JSON.generate(report))
 
 exit code

data/lib/kimera/execution/isolated_child_command.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "json"
 require_relative "suite_env"
 
 module Kimera
@@ -19,19 +20,25 @@ class Kimera::Execution::IsolatedPlan::ChildCommand
   end
 
   def command(mirror, locations, ledger:, paths:)
+    File.write(request_path(ledger), JSON.generate(request(locations)))
     includes = paths.flat_map { |path| ["-I", path] }
-    bundled(mirror, Kimera::Execution::SUITE_ENV.dup, ["ruby", *includes, "-I", helpers, *argv(locations, ledger)])
+    bundled(mirror, Kimera::Execution::SUITE_ENV.dup, ["ruby", *includes, "-I", helpers, *argv(ledger)])
   end
 
-  def argv(locations, ledger)
-    return [CHILD, ledger, *locations] unless minitest?
-    [MINITEST_CHILD, ledger, *@test_files, "--", *locations]
+  def argv(ledger)
+    [minitest? ? MINITEST_CHILD : CHILD, ledger, request_path(ledger)]
+  end
+
+  def request(locations)
+    { "tests" => locations, "files" => @test_files }
   end
 
   def helpers
     minitest? ? "test" : "spec"
   end
 
+  def request_path(ledger) = "#{ledger}.request"
+
   private
 
   def bundled(mirror, env, argv)

data/lib/kimera/execution/isolated_child_minitest.rb

@@ -12,13 +12,19 @@ rescue NameError, ArgumentError
   end
 end
 
-ledger, *rest = ARGV
-split = rest.index("--") or abort("usage: <ledger> <test files...> -- <ids...>")
-files = rest[0...split]
-ids = rest[(split + 1)..]
+ledger, request = ARGV
+request = JSON.parse(File.read(request, encoding: Encoding::UTF_8))
+files = request.fetch("files")
+ids = request.fetch("tests")
 ARGV.clear
 
-files.each { |f| require File.expand_path(f) }
+begin
+  files.each { |f| require File.expand_path(f) }
+rescue StandardError, ScriptError => error
+  cause = ["#{error.class}: #{error.message}", *Array(error.backtrace).first(5).map { |line| "  #{line}" }]
+  File.write(ledger, JSON.generate(failures: 1, failing: [], load_error: cause.join("\n")))
+  exit(1)
+end
 
 methods = {}
 Minitest::Runnable.runnables.each do |runnable|

data/lib/kimera/execution/isolated_outcome.rb

@@ -8,6 +8,9 @@ module Kimera
 end
 
 class Kimera::Execution::IsolatedOutcome
+  HEAD_LINES = 5
+  TAIL_LINES = 15
+
   attr_reader :status, :failing, :detail
 
   def initialize(status, failing = nil, detail = nil)
@@ -16,32 +19,56 @@ class Kimera::Execution::IsolatedOutcome
     @detail = detail
   end
 
+  def explain(limit)
+    return "timed out after #{limit}s" if status == :timeout
+    named = Array(failing)
+    return "failing: #{named.join(", ")}" if named.any?
+    detail || "the test child failed without naming a test"
+  end
+
   class << self
-    def judge(exit, path)
+    def judge(exit, path, stderr = "")
       return new(:timeout) if exit == :timeout
       ledger = read(path)
-      return unreported(exit) unless ledger
+      return unreported(exit, stderr) unless ledger
       tally(exit, ledger)
     end
 
     private
 
-    def unreported(exit) = new(exit.success? ? :survived : :killed)
+    def unreported(exit, stderr)
+      new(:harness_error, nil, "test child #{status_of(exit)} without reporting results#{tail(stderr)}")
+    end
+
+    def tail(stderr)
+      lines = stderr.to_s.strip.lines(chomp: true)
+      lines.empty? ? "" : ":\n#{ends(lines).join("\n")}"
+    end
+
+    def ends(lines)
+      return lines if lines.size <= HEAD_LINES + TAIL_LINES
+      [*lines.first(HEAD_LINES), "…", *lines.last(TAIL_LINES)]
+    end
+
+    def status_of(exit)
+      code = exit.exitstatus
+      code ? "exited #{code}" : "died on signal #{exit.termsig}"
+    end
 
     def tally(exit, ledger)
       failing = Array(ledger["failing"])
-      return new(:killed, failing) if ledger["failures"].positive?
+      return new(:killed, failing, ledger["load_error"]) if ledger["failures"].positive?
       return new(:survived) if exit.success?
       new(:harness_error, nil, unexplained(exit))
     end
 
     def unexplained(exit)
-      "suite exited #{exit.exitstatus || "on signal #{exit.termsig}"} with 0 failures " \
+      "suite #{status_of(exit)} with 0 failures " \
         "(a coverage floor or exit hook? skip it when ENV[\"KIMERA\"] is set)"
     end
 
     def read(path)
-      ledger = JSON.parse(File.read(path))
+      ledger = JSON.parse(File.read(path, encoding: Encoding::UTF_8))
       ledger if ledger.is_a?(Hash) && ledger["failures"].is_a?(Integer)
     rescue Errno::ENOENT, JSON::ParserError
       nil

data/lib/kimera/execution/isolated_plan.rb

@@ -10,7 +10,12 @@ module Kimera
 end
 
 class Kimera::Execution::IsolatedPlan
-  MIRROR_SKIP = %w[.git tmp vendor node_modules coverage log .bundle].freeze
+  MIRROR_SKIP = %w[.git coverage].freeze
+  MIRROR_EMPTY = %w[tmp log].freeze
+  MIRROR_LINK = %w[vendor node_modules .bundle].freeze
+  MIRROR_HINT =
+    "  the mirror copies the project except #{MIRROR_SKIP.join(", ")} " \
+      "(#{MIRROR_EMPTY.join(", ")} start empty; #{MIRROR_LINK.join(", ")} are symlinked)".freeze
 
   attr_reader :registry
 
@@ -34,14 +39,17 @@ class Kimera::Execution::IsolatedPlan
     child.command(mirror, locations, ledger: ledger, paths: mutables)
   end
 
+  def suite = selection.all
+
   def mutables
     @registry.files.map { |f| f.split(File::SEPARATOR).first }.uniq
   end
 
-  class << self
-    def mirrors(entries)
-      entries.reject { |entry| MIRROR_SKIP.include?(entry) }
-    end
+  def placement(entry)
+    return :copy if mutables.include?(entry)
+    return :skip if MIRROR_SKIP.include?(entry)
+    return :empty if MIRROR_EMPTY.include?(entry)
+    MIRROR_LINK.include?(entry) ? :link : :copy
   end
 
   private

data/lib/kimera/execution/isolated_verdict.rb

@@ -38,13 +38,16 @@ module Kimera
       def verdict(mirror, locations)
         Dir.mktmpdir("kimera-ledger") do |dir|
           ledger = File.join(dir, "ledger.json")
-          IsolatedOutcome.judge(launch(mirror, locations, ledger), ledger)
+          stderr = File.join(dir, "stderr.log")
+          IsolatedOutcome.judge(launch(mirror, locations, ledger, stderr), ledger, captured(stderr))
         end
       end
 
-      def launch(mirror, locations, ledger)
+      def captured(path) = File.read(path, encoding: Encoding::UTF_8).scrub
+
+      def launch(mirror, locations, ledger, stderr)
         env, cmd = plan.command(mirror, locations, ledger)
-        waitfor(Process.spawn(env, *cmd, chdir: mirror, pgroup: true, out: File::NULL, err: File::NULL))
+        waitfor(Process.spawn(env, *cmd, chdir: mirror, pgroup: true, out: File::NULL, err: stderr))
       end
 
       def with_mirror
@@ -56,8 +59,14 @@ module Kimera
 
       def populate(mirror)
         root = plan.root
-        IsolatedPlan.mirrors(Dir.children(root)).each do |entry|
-          FileUtils.cp_r(File.join(root, entry), File.join(mirror, entry))
+        Dir.children(root).each { |entry| place(File.join(root, entry), File.join(mirror, entry), entry) }
+      end
+
+      def place(source, target, entry)
+        case plan.placement(entry)
+        when :copy then FileUtils.cp_r(source, target)
+        when :link then File.symlink(source, target)
+        when :empty then FileUtils.mkdir_p(target) if File.directory?(source)
         end
       end
 

data/lib/kimera/execution/kinship.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative "../registry/mutation_point"
+
+module Kimera
+  module Execution
+  end
+end
+
+class Kimera::Execution::Kinship
+  def initialize(registry, coverage)
+    @registry = registry
+    @coverage = coverage
+  end
+
+  def order(id, tests)
+    (related(@registry.index.fetch(id, Kimera::MutationPoint::NONE)) & tests) | tests
+  end
+
+  private
+
+  def related(point)
+    siblings = @registry.at(point.file).sort_by { |other| other.method_name == point.method_name ? 0 : 1 }
+    known = @coverage.to_h
+    siblings.flat_map { |other| other.ids.flat_map { |mutant| Array(known[mutant]) } }
+  end
+end

data/lib/kimera/execution/overlay_guard_modules.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "callback"
+require_relative "reflections"
 
 module Kimera
   module Execution
@@ -56,14 +57,30 @@ module Kimera
           define_method(hook) do |base = nil, &block|
             next super(base, &block) unless block && OverlayGuardModules.replacing?(self, stored, base)
             instance_variable_set(stored, block)
+            OverlayGuardModules.reapply(self, block)
           end
         end
       end
 
       def serialization = SERIALIZEGUARD
 
+      def reflection = Reflections::GUARD
+
+      MIXES = Module.instance_method(:include?)
+
       def concern = CONCERNGUARD
 
+      def reapply(concern, block)
+        ObjectSpace.each_object(Class).each { |klass| klass.class_eval(&block) if owner?(klass, concern) }
+      end
+
+      def owner?(klass, concern)
+        return false if klass.singleton_class? || !mixes?(klass, concern)
+        [klass.superclass].compact.none? { |parent| mixes?(parent, concern) }
+      end
+
+      def mixes?(klass, concern) = MIXES.bind_call(klass, concern)
+
       def replacing?(target, stored, base)
         Kimera::Execution::OverlayGuards.overlaying? && !base && target.instance_variable_defined?(stored)
       end

data/lib/kimera/execution/overlay_guards.rb

@@ -26,6 +26,7 @@ module Kimera
         callbacks!
         concern!
         serialize!
+        reflections!
       end
 
       def enum!
@@ -43,6 +44,11 @@ module Kimera
         ActiveRecord::Base.singleton_class.prepend(OverlayGuardModules.serialization)
       end
 
+      def reflections!
+        return unless defined?(ActiveRecord::Reflection)
+        ActiveRecord::Reflection.singleton_class.prepend(OverlayGuardModules.reflection)
+      end
+
       def concern!
         return unless defined?(ActiveSupport::Concern)
         ActiveSupport::Concern.prepend(OverlayGuardModules.concern)

data/lib/kimera/execution/parallel_test_databases.rb

@@ -19,23 +19,31 @@ class Kimera::Execution::ParallelTestDatabases
   end
 
   def after_fork(index)
+    identify(index)
     return unless index && active?
     ActiveSupport::Testing::Parallelization.after_fork_hooks.each { |hook| hook.call(index) }
     @adapter.start
   end
 
   def before_exit(index)
-    Array(index).each { cleanup }
+    Array(index).each { |worker| cleanup(worker) }
   rescue StandardError => error
     errors.puts("kimera: parallelize_teardown failed (#{error.class}: #{error.message})")
   end
 
   private
 
-  def cleanup
+  def cleanup(index)
     return unless active?
     scrub
-    ActiveSupport::Testing::Parallelization.run_cleanup_hooks.each(&:call)
+    ActiveSupport::Testing::Parallelization.run_cleanup_hooks.each { |hook| hook.call(index) }
+  end
+
+  def identify(index)
+    return unless index && @jobs > 1 && defined?(ActiveSupport::TestCase)
+    ActiveSupport::TestCase.parallel_worker_id = index
+  rescue NoMethodError
+    nil
   end
 
   def scrub

data/lib/kimera/execution/pool_driver.rb

@@ -46,10 +46,11 @@ class Kimera::Execution::Pool
     @options[:coverage] = measured
   end
 
-  def drive(queue, spawner, resolve:, lost:)
+  def drive(queue, spawner, resolve:, lost:, trace: nil)
+    database.before_fork
     Kimera::Execution::WorkerPool.new(
       queue: queue, spawner: spawner, jobs: @options.fetch(:jobs),
-      hard_timeout: @options.fetch(:hard), resolve: resolve, lost: lost
+      hard_timeout: @options.fetch(:hard), resolve: resolve, lost: lost, trace: trace
     ).run
   end
 
@@ -66,7 +67,6 @@ class Kimera::Execution::Pool
   def database = @options.fetch(:paralleldb)
 
   def launch(entry, index)
-    database.before_fork
     duty = Duty.new(entry, index, channels)
     [spawn(duty), *duty.pipes.parent!]
   end

data/lib/kimera/execution/reflections.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Kimera
+  module Execution
+    module Reflections
+      module_function
+
+      GUARD =
+        Module.new do
+          def add_reflection(owner, name, reflection)
+            key = Reflections.key(owner, name)
+            stale = OverlayGuards.overlaying? && owner._reflections[key]
+            super
+            Reflections.inherit(owner, key, stale, reflection) if stale
+          end
+        end
+
+      def key(owner, name)
+        text = name.to_s
+        owner._reflections.key?(text) ? text : name.to_sym
+      end
+
+      def inherit(owner, key, stale, reflection)
+        owner.descendants.each { |heir| replace(heir, key, stale, reflection) }
+      end
+
+      def replace(heir, key, stale, reflection)
+        held = heir._reflections
+        return unless held[key].equal?(stale)
+        heir.clear_reflections_cache
+        heir._reflections = held.merge(key => reflection)
+      end
+    end
+  end
+end

data/lib/kimera/execution/reload.rb

@@ -5,38 +5,16 @@ require_relative "../runtime"
 require_relative "../synthesis/overlay"
 require_relative "child_process"
 require_relative "overlay_guards"
+require_relative "reload_errand"
 require_relative "verdicts"
 
 class Kimera::Execution::Reload
+  include Kimera::Execution::ChildProcess
+
   Failure =
     Data.define(:exception) do
       def message = "#{exception.class}: #{exception.message}"
     end
-  include Kimera::Execution::ChildProcess
-
-  Errand =
-    Struct.new(:id, :reader, :writer) do
-      def parent!
-        writer.close
-      end
-
-      def child!
-        reader.close
-      end
-
-      def emit(payload)
-        writer.puts(payload)
-        writer.close
-      end
-
-      def await(deadline, &)
-        return reader.gets if reader.wait_readable(deadline)
-        yield
-        nil
-      ensure
-        reader.close
-      end
-    end
 
   def initialize(registry:, adapter:, isolation:, root:)
     @registry = registry
@@ -45,8 +23,8 @@ class Kimera::Execution::Reload
     @root = root
   end
 
-  def run(id, deadline:)
-    errand = Errand.new(id, *IO.pipe)
+  def run(id, deadline:, tests: @adapter.test_ids)
+    errand = Errand.new(id, tests, *IO.pipe)
     collect(errand, child(errand), deadline)
   end
 
@@ -59,32 +37,42 @@ class Kimera::Execution::Reload
   def work(errand)
     errand.child!
     silence!
-    errand.emit(report(errand.id))
+    errand.emit(report(errand))
     exit!(0)
   end
 
-  def report(id)
-    status, fails = evaluate(id)
-    JSON.generate(id: id, status: status.to_s, fails: fails)
+  def report(errand)
+    status, fails = evaluate(errand)
+    JSON.generate(id: errand.id, status: status.to_s, fails: Array(fails).map { |fail| fail.to_s.scrub })
   end
 
   def collect(errand, pid, deadline)
     line = errand.await(deadline) { kill(pid) }
-    reap(pid)
-    verdict(errand.id, line)
+    verdict(errand.id, line, reap(pid), deadline)
   end
 
-  def evaluate(id)
-    mutate(id).verdict
+  def evaluate(errand)
+    failed = mutate(errand)
+    failed ? failed.verdict : [:survived, []]
   rescue StandardError, ScriptError => error
     [:error, [Failure.new(error).message]]
   end
 
-  def mutate(id)
+  def mutate(errand)
+    id = errand.id
     file = verdicts.point(id).file
     overlay(file, File.join(File.expand_path(@root), file), id)
     Kimera::Runtime.active = nil
-    @isolation.around { @adapter.run(@adapter.test_ids) }
+    @isolation.around { hunt(errand) }
+  end
+
+  def hunt(errand)
+    errand.tests.lazy.map { |test| trial(test, errand) }.reject(&:passed?).first
+  end
+
+  def trial(test, errand)
+    errand.tick
+    @adapter.run([test])
   end
 
   def overlay(file, path, id)
@@ -92,12 +80,18 @@ class Kimera::Execution::Reload
     Kimera::Execution::OverlayGuards.overlay { Kimera::Overlay.evaluate(baked, path) }
   end
 
-  def verdict(id, line)
-    return verdicts.unjudged(id, "reload worker produced no result") unless line
+  def verdict(id, line, status = nil, deadline = nil)
+    return verdicts.timeout(id, deadline) if line == :timeout
+    return verdicts.unjudged(id, "reload worker produced no result#{exited(status)}") unless line
     message = parse(line)
     message ? verdicts.parse(message) : verdicts.unjudged(id, "reload worker output unparseable")
   end
 
+  def exited(status)
+    return "" unless status
+    status.signaled? ? " (died on signal #{status.termsig})" : " (exited #{status.exitstatus})"
+  end
+
   def verdicts
     Kimera::Execution::Verdicts.new(@registry)
   end

data/lib/kimera/execution/reload_errand.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Kimera
+  module Execution
+  end
+end
+
+class Kimera::Execution::Reload; end
+
+Kimera::Execution::Reload::Errand =
+  Struct.new(:id, :tests, :reader, :writer) do
+    tick = "tick\n"
+    def parent!
+      writer.close
+    end
+
+    def child!
+      reader.close
+      writer.sync = true
+    end
+    define_method(:tick) { writer.write(tick) }
+    def emit(payload)
+      writer.puts(payload)
+      writer.close
+    end
+
+    def await(deadline)
+      heard(deadline).tap { |line| yield if line == :timeout }
+    ensure
+      reader.close
+    end
+    define_method(:heard) do |deadline|
+      while reader.wait_readable(deadline)
+        line = reader.gets
+        return line unless line == tick
+      end
+      :timeout
+    end
+  end

data/lib/kimera/execution/schedule.rb

@@ -1,12 +1,13 @@
 # frozen_string_literal: true
 
 require_relative "priority"
+require_relative "kinship"
 require_relative "reload"
 require_relative "verdicts"
 
 class Kimera::Execution::Schedule
   Ledger = Struct.new(:results, :leaks)
-  Batch = Struct.new(:safe, :reloadable, :deferred, :ledger)
+  Batch = Struct.new(:safe, :reloadable, :deferred, :ledger, :coverage)
 
   LOSSES = { timeout: :expired }.freeze
 
@@ -37,14 +38,16 @@ class Kimera::Execution::Schedule
     safe, unsafe = ids.partition { |id| verdicts.safe?(id) }
     reloadable, deferred = unsafe.partition { |id| verdicts.reloadable?(id) }
     progress.start(safe.size + unsafe.size, label)
-    Batch.new(Kimera::Execution::Priority.new(coverage).order(safe), reloadable, deferred, Ledger.new({}, []))
+    Batch.new(prioritized(safe, coverage), reloadable, deferred, Ledger.new({}, []), coverage)
   end
 
+  def prioritized(safe, coverage) = Kimera::Execution::Priority.new(coverage).order(safe)
+
   def process(batch)
-    safe, reloadable, deferred, ledger = batch.to_a
-    pool(safe, ledger)
-    reload(reloadable, ledger)
-    defer(deferred, ledger)
+    ledger = batch.ledger
+    pool(batch.safe, ledger)
+    reload(batch)
+    defer(batch.deferred, ledger)
   end
 
   def finish(ledger)
@@ -58,8 +61,13 @@ class Kimera::Execution::Schedule
     progress.tick(result.status)
   end
 
-  def reload(ids, ledger)
-    ids.each { |id| record(ledger, id, reloader.run(id, deadline: hard)) }
+  def reload(batch)
+    kinship = Kimera::Execution::Kinship.new(@registry, batch.coverage)
+    batch.reloadable.each { |id| record(batch.ledger, id, rerun(id, kinship)) }
+  end
+
+  def rerun(id, kinship)
+    reloader.run(id, deadline: hard, tests: kinship.order(id, @options.fetch(:adapter).test_ids))
   end
 
   def defer(ids, ledger)
@@ -97,7 +105,7 @@ class Kimera::Execution::Schedule
   def crashed(id) = verdicts.unjudged(id, "worker crashed before result")
 
   def reloader
-    Kimera::Execution::Reload.new(
+    @_reloader ||= Kimera::Execution::Reload.new(
       registry: @registry, adapter: @options.fetch(:adapter),
       isolation: @options.fetch(:isolation), root: @options.fetch(:root)
     )

data/lib/kimera/execution/worker_pool/worker.rb

@@ -10,6 +10,11 @@ Kimera::Execution::WorkerPool::Worker =
       self.inflight = id
     end
 
+    def claim(id, limit)
+      busy!(id)
+      renew(limit)
+    end
+
     def renew(limit)
       self.deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + limit
     end

data/lib/kimera/execution/worker_pool.rb

@@ -29,8 +29,8 @@ class Kimera::Execution::WorkerPool
   def assign(worker)
     id = fleet.take
     return close(worker) unless id
-    worker.busy!(id)
-    worker.renew(limit)
+    worker.claim(id, limit)
+    trace(worker.slot, id)
     worker.offer(id)
   end
 
@@ -83,6 +83,8 @@ class Kimera::Execution::WorkerPool
     worker.renew(limit)
   end
 
+  def trace(slot, id) = context.options[:trace]&.call(slot, id)
+
   def close(worker) = shut(worker.retire)
 
   def watch

data/lib/kimera/frameworks/adapter.rb

@@ -42,7 +42,11 @@ class Kimera::Frameworks::Adapter
     id
   end
 
-  @registry = {}
+  def reproduce(ids)
+    "rspec #{(ids & test_ids).join(" ")} --order defined"
+  end
+
+  @registry ||= {}
 
   NO_LOADER = -> {}
   ADAPTER_LOADERS = {

data/lib/kimera/frameworks/minitest_adapter.rb

@@ -51,8 +51,27 @@ class Kimera::Frameworks::MinitestAdapter < Kimera::Frameworks::Adapter
     Kimera::Frameworks::RunOutcome.new(passed: failed.empty?, failed_ids: failed, failures: failures)
   end
 
+  def reproduce(ids)
+    "bundle exec ruby -Itest -rminitest/autorun -e #{quote(loads(ids))} -- -n #{quote(filter(ids))} --seed 1"
+  end
+
   private
 
+  def loads(ids)
+    ids.filter_map { |id| origin(id) }.uniq.map { |file| "require File.expand_path(#{file.dump})" }.join("; ")
+  end
+
+  def filter(ids) = "/^(?:#{ids.map { |id| Regexp.escape(id) }.join("|")})$/"
+
+  def origin(id)
+    klass, name = @methods[id]
+    return unless klass
+    path, = klass.instance_method(name).source_location
+    path.delete_prefix("#{Dir.pwd}#{File::SEPARATOR}")
+  end
+
+  def quote(text) = "'#{text.gsub("'") { "'\\''" }}'"
+
   def record(id, failed, failures)
     klass, name = @methods[id]
     return unless klass

data/lib/kimera/incremental/session.rb

@@ -24,7 +24,7 @@ class Kimera::Incremental::Session
   class << self
     def load(path, registry: nil)
       return new unless path && File.exist?(path)
-      session = decode(JSON.parse(File.read(path)))
+      session = decode(JSON.parse(File.read(path, encoding: Encoding::UTF_8)))
       session.prune!(registry) if registry
       session
     end

data/lib/kimera/memo_guard.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require_relative "support/syntax"
+require_relative "support/syntax_types"
+
+class Kimera::MemoGuard
+  CONDITIONAL = "conditional"
+  BOOLEAN_LITERAL = "boolean_literal"
+  READ = Kimera::SyntaxTypes::InstanceVariableReadNode
+  WRITE = Kimera::SyntaxTypes::InstanceVariableWriteNode
+
+  Exemption = Data.define(:location, :operator)
+
+  class << self
+    def exemptions(source)
+      result = Kimera::Syntax.parse(source)
+      return [] if result.failure?
+      defs(result.value).flat_map { new(statements(it.body)).exemptions }
+    end
+
+    def statements(body) = body.is_a?(Kimera::SyntaxTypes::StatementsNode) ? body.body : []
+
+    def defs(node, found = [])
+      found << node if node.is_a?(Kimera::SyntaxTypes::DefNode)
+      node.compact_child_nodes.each { defs(it, found) }
+      found
+    end
+  end
+
+  def initialize(statements)
+    @guard, @flag, *@rest = statements
+  end
+
+  def exemptions
+    return [] unless name && (value? || flag?)
+    [Exemption.new(@guard.location, CONDITIONAL), *raised]
+  end
+
+  private
+
+  def name
+    predicate = @guard.predicate if guard?
+    predicate.name if predicate.is_a?(READ)
+  end
+
+  def guard? = @guard.is_a?(Kimera::SyntaxTypes::IfNode) && @guard.compact_child_nodes.size == 2 && returns?
+
+  def returns? = @guard.statements.body.size == 1 && returned.is_a?(Kimera::SyntaxTypes::ReturnNode)
+
+  def returned = @guard.statements.body.first
+
+  def value? = caches? && [@flag, *@rest].any? { named?(it, WRITE) }
+
+  def caches?
+    values = returned.arguments&.arguments
+    values&.size == 1 && named?(values.first, READ)
+  end
+
+  def flag? = returned.compact_child_nodes.empty? && raises?
+
+  def raises? = named?(@flag, WRITE) && @flag.value.is_a?(Kimera::SyntaxTypes::TrueNode)
+
+  def raised = flag? ? [Exemption.new(@flag.value.location, BOOLEAN_LITERAL)] : []
+
+  def named?(node, kind) = node.is_a?(kind) && node.name == name
+end

data/lib/kimera/registry/source_file.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "prism"
+require_relative "../memo_guard"
 require_relative "../memoization"
 require_relative "mutation_point"
 require_relative "walking"
@@ -25,6 +26,8 @@ class Kimera::RegistryScan::SourceFile
 
   def tainted = @_tainted ||= Kimera::Memoization.ranges(@source)
 
+  def guards = @_guards ||= Kimera::MemoGuard.exemptions(@source)
+
   def mined(root)
     found = []
     walk(root, origin) { |node, cursor| bank(found, node, cursor) }
@@ -36,7 +39,7 @@ class Kimera::RegistryScan::SourceFile
   end
 
   def bank(found, node, cursor)
-    pairs = harvest(applicable(cursor), node, cursor.position)
+    pairs = harvest(applicable(cursor), node, cursor.position).reject { |key, _| guarded?(node, key) }
     return if pairs.empty?
     found << assemble(node, pairs, cursor).taint!(tainted)
   end
@@ -46,6 +49,8 @@ class Kimera::RegistryScan::SourceFile
     cursor.position ? chosen : chosen.reject(&:statement?)
   end
 
+  def guarded?(node, key) = guards.include?(Kimera::MemoGuard::Exemption.new(node.location, key))
+
   def harvest(operators, node, position)
     operators.flat_map { |operator| operator.pairs(node, position: position) }
   end

data/lib/kimera/support/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Kimera
-  VERSION = "0.1.2"
+  VERSION = "0.1.4"
 end

data/skills/kimera/SKILL.md

@@ -119,7 +119,9 @@ bundle exec kimera run --isolated --jobs 4      # oracle mode (see Strengthen)
   suppress the warm path.
 - `--isolated` judges on failed tests, not the exit status. A child that
   exits non-zero with zero failures (typically a SimpleCov `minimum_coverage`
-  floor tripped by the partial run) is `harness_error`, not a kill. Kimera
+  floor tripped by the partial run) is `harness_error`, not a kill, and so is
+  a child that crashes before reporting (read its `detail` for the stderr).
+  Kimera
   sets `KIMERA=1` wherever it loads the suite (warm, `--isolated`, doctor), so
   gate the floor on it (`minimum_coverage ... unless ENV["KIMERA"]`); `kimera
   doctor` warns when it isn't.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kimera
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.4
 platform: ruby
 authors:
 - Giacomo GK
@@ -99,6 +99,7 @@ files:
 - lib/kimera/cli/workflows.rb
 - lib/kimera/error.rb
 - lib/kimera/execution/baseline_failure.rb
+- lib/kimera/execution/baseline_failure/breakdown.rb
 - lib/kimera/execution/baseline_pass.rb
 - lib/kimera/execution/boot.rb
 - lib/kimera/execution/callback.rb
@@ -116,13 +117,16 @@ files:
 - lib/kimera/execution/isolated_verdict.rb
 - lib/kimera/execution/isolated_watchdog.rb
 - lib/kimera/execution/isolation.rb
+- lib/kimera/execution/kinship.rb
 - lib/kimera/execution/null_progress.rb
 - lib/kimera/execution/overlay_guard_modules.rb
 - lib/kimera/execution/overlay_guards.rb
 - lib/kimera/execution/parallel_test_databases.rb
 - lib/kimera/execution/pool_driver.rb
 - lib/kimera/execution/priority.rb
+- lib/kimera/execution/reflections.rb
 - lib/kimera/execution/reload.rb
+- lib/kimera/execution/reload_errand.rb
 - lib/kimera/execution/rig.rb
 - lib/kimera/execution/schedule.rb
 - lib/kimera/execution/schemata.rb
@@ -147,6 +151,7 @@ files:
 - lib/kimera/incremental/git_diff.rb
 - lib/kimera/incremental/selection.rb
 - lib/kimera/incremental/session.rb
+- lib/kimera/memo_guard.rb
 - lib/kimera/memoization.rb
 - lib/kimera/operators.rb
 - lib/kimera/operators/argument_drop.rb