polyrun 2.1.3 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4a5cd4e5af5195cb25ca3185b3e828556746f21a6911f8a60f1b43b5b6a316d0
-  data.tar.gz: 67362c68f463339cfd8a66e665b9fb6a5f75cf8ed6276e1a846c68147a27e848
+  metadata.gz: 8b7bedc5bda9c9ee341927dab2ba6aedafaebe4c26ad73750d8ed7ad4845f4e3
+  data.tar.gz: bac9cd71c5ab3372c0ff5dda891dd354a0ceaac3555f5949870ce8611646debc
 SHA512:
-  metadata.gz: b7f7ff8592774bfb1bd173753f5c3cca77d99a392a9dbabdd0bf11c85b510a3dc4cf0c2a66912cf5d48384445e74039a2cfa296d6aeb40b5d008aa575700ef0b
-  data.tar.gz: 05aad7cb17b505112548d072895d56c88f885f07b31e3052ab12e5b4ab0979a555bdf9872380107a60211a8bd54dbd176b98a8970eaba7756fa2e87f8a475a15
+  metadata.gz: fe09eaccf1eaf3fba5a998d49f2f2df9cfd6a1da6b1eef960e6cbe894f2269b05777be459fe394a67c3038d72750a8401ae8e224726901ac4bd437e3d01a93ed
+  data.tar.gz: f8090b77fba080b7ca1996afeec0c2680ca26e0d0a4571453210f421f4921685bd8c5bcfeb79724556e377ff26968a914b52bf24b4a1a433a9500d656aa43f41

data/CHANGELOG.md

@@ -1,6 +1,15 @@
 # CHANGELOG
 
-## Unreleased
+## 2.2.0 (2026-07-13)
+
+- Fix `install_example_rails_logging!` raising `NameError` when example-debug Rails logging runs under `POLYRUN_EXAMPLE_DEBUG=1`.
+- Improve spec-quality per-example coverage diff: sparse scoped snapshots, track-aware diff without a second full blob copy, and optional lazy profile dimensions.
+- Add CSV and Markdown exports for coverage, timing, spec-quality, and failure merge reports.
+- Add `report-junit --format xml|csv|markdown` (XML remains default for CI).
+- Add `Polyrun::Benchmark::Profile` / `report-benchmark` / `polyrun bench`; benchmark runs write JSON sidecars under `tmp/benchmarks/` with optional `POLYRUN_BENCH_FORMATS`.
+- Add optional native coverage merge acceleration (`ext/polyrun_coverage_merge`: `merge_line_arrays`, `merge_two`, `line_counts`) with Ruby fallbacks.
+- Add RSpec performance benchmarks (`rake bench_performance`, `spec/performance/`) with profile logs under `tmp/benchmarks/`.
+- Include `csv` and `markdown` in default post-merge coverage formats (`POLYRUN_MERGE_FORMATS`).
 
 ## 2.1.3 (2026-07-10)
 

data/CONTRIBUTING.md

@@ -17,11 +17,33 @@ bundle exec rake spec
 
 Coverage merge performance (large synthetic payloads):
 
+Native extension (optional; compiles via `bundle install` or `cd ext/polyrun_coverage_merge && ruby extconf.rb && make`):
+
+After pulling changes under `ext/**/*.c` or `ext/**/extconf.rb`, rebuild the extension before running specs or benchmarks:
+
+```bash
+make native-extension
+# or: bundle exec rake native_extension
+```
+
+If merge specs segfault or native acceleration behaves oddly after a pull, run `make clean` in `ext/polyrun_coverage_merge` and `make native-extension` again (or `bundle install` to trigger a full compile).
+
+CI compiles the extension on Linux and macOS (`.github/workflows/native-extension.yml`).
+
 ```bash
 bundle exec rake bench_merge
 # or: ruby benchmark/merge_coverage.rb
 ```
 
+RSpec performance benchmarks (coverage merge + spec-quality peek; writes `tmp/benchmarks/profile_<sha>.log`):
+
+```bash
+bundle exec rake bench_performance
+# optional: STACKPROF=1 or BENCHMARK_IPS=1 for spec/performance/profiling_spec.rb
+# optional: BENCH_MEMORY=1 bundle exec rspec spec/performance/benchmark_merge_spec.rb spec/performance/benchmark_spec.rb --tag benchmark
+# optional env: BENCH_LINE_COUNT_REPS, BENCH_MEMORY_REPS
+```
+
 Run the suite under alternate Ruby constraints (see `Appraisals` and `gemfiles/`):
 
 ```bash

data/docs/SETUP_PROFILE.md

@@ -76,7 +76,7 @@ Orchestration tracing stays on `DEBUG=1` / `POLYRUN_DEBUG=1`. Per-example toolin
 | `DEBUG_LOG_LEVEL` | Rails / ActiveRecord logger severity: `debug`, `info`, `warn`, `error`, `fatal`, or Ruby Logger integers (`0` debug … `4` fatal); default `debug` |
 | `RSPEC_EXAMPLE_TIMEOUT_SEC` | Per-example timeout (disabled while example debug is on) |
 
-In `spec_helper` / `spec/support`: `require "polyrun/rspec"` then `Polyrun::RSpec.install_example_debug!`, `install_example_rails_logging!`, `install_example_timeout!`, and `install_sharded_formatter_compat!` when using Fuubar under `POLYRUN_SHARD_*`. Pair with `install_worker_ping!` for idle timeouts.
+In `spec_helper` / `spec/support`: `require "polyrun/rspec"` then `Polyrun::RSpec.install_sharded_formatter_compat!` (silences per-worker seed/summary/pending under `POLYRUN_SHARD_*`), `install_example_debug!`, `install_example_rails_logging!`, `install_example_timeout!`. Pair with `install_worker_ping!` for idle timeouts.
 
 ## 6. Coverage and CI reports
 

data/ext/polyrun_coverage_merge/coverage_merge.c

@@ -0,0 +1,492 @@
+#include <ruby.h>
+#include <string.h>
+
+static VALUE str_lines;
+static VALUE str_branches;
+static VALUE str_type;
+static VALUE str_start_line;
+static VALUE str_end_line;
+static VALUE str_coverage;
+static ID id_lines;
+static ID id_branches;
+static ID id_type;
+static ID id_start_line;
+static ID id_end_line;
+static ID id_coverage;
+static ID id_relevant;
+static ID id_covered;
+static ID id_sort_branches_for_native;
+
+static VALUE
+ignored_string(void)
+{
+    return rb_str_new_cstr("ignored");
+}
+
+static int
+ignored_hit_p(VALUE value)
+{
+    if (!RB_TYPE_P(value, T_STRING)) {
+        return 0;
+    }
+
+    return strcmp(StringValueCStr(value), "ignored") == 0;
+}
+
+static VALUE
+line_hit_to_i(VALUE value)
+{
+    if (NIL_P(value)) {
+        return Qnil;
+    }
+    if (RB_TYPE_P(value, T_FIXNUM) || RB_TYPE_P(value, T_BIGNUM)) {
+        return value;
+    }
+    if (RB_TYPE_P(value, T_STRING)) {
+        const char *text = StringValueCStr(value);
+        char *end = NULL;
+        long number = strtol(text, &end, 10);
+        if (end != text && *end == '\0') {
+            return LONG2FIX(number);
+        }
+        return Qnil;
+    }
+    if (RB_TYPE_P(value, T_SYMBOL)) {
+        VALUE as_string = rb_sym2str(value);
+        return line_hit_to_i(as_string);
+    }
+
+    return Qnil;
+}
+
+static int
+line_hit_positive_p(VALUE value)
+{
+    VALUE as_int = line_hit_to_i(value);
+    if (NIL_P(as_int)) {
+        return 0;
+    }
+
+    VALUE comparison = rb_funcall(as_int, rb_intern(">"), 1, LONG2FIX(0));
+    return RTEST(comparison);
+}
+
+static VALUE
+coerce_line_array(VALUE value)
+{
+    if (NIL_P(value)) {
+        return rb_ary_new();
+    }
+    if (!RB_TYPE_P(value, T_ARRAY)) {
+        rb_raise(rb_eTypeError, "lines must be an Array");
+    }
+
+    return value;
+}
+
+static VALUE
+line_array_for_count(VALUE value)
+{
+    if (NIL_P(value) || !RB_TYPE_P(value, T_ARRAY)) {
+        return rb_ary_new();
+    }
+
+    return value;
+}
+
+static VALUE
+merge_line_hits(VALUE left, VALUE right)
+{
+    if (NIL_P(left)) {
+        return right;
+    }
+    if (NIL_P(right)) {
+        return left;
+    }
+    if (ignored_hit_p(left) || ignored_hit_p(right)) {
+        return ignored_string();
+    }
+
+    VALUE left_i = line_hit_to_i(left);
+    VALUE right_i = line_hit_to_i(right);
+
+    if (!NIL_P(left_i) && !NIL_P(right_i)) {
+        return rb_funcall(left_i, rb_intern("+"), 1, right_i);
+    }
+    if (NIL_P(left_i) && !NIL_P(right_i)) {
+        return right_i;
+    }
+    if (!NIL_P(left_i) && NIL_P(right_i)) {
+        return left_i;
+    }
+
+    return left;
+}
+
+static VALUE
+merge_line_arrays(VALUE left, VALUE right)
+{
+    left = coerce_line_array(left);
+    right = coerce_line_array(right);
+
+    long left_len = RARRAY_LEN(left);
+    long right_len = RARRAY_LEN(right);
+    long max_len = left_len > right_len ? left_len : right_len;
+    VALUE out = rb_ary_new2(max_len);
+
+    for (long index = 0; index < max_len; index++) {
+        VALUE left_hit = index < left_len ? rb_ary_entry(left, index) : Qnil;
+        VALUE right_hit = index < right_len ? rb_ary_entry(right, index) : Qnil;
+        rb_ary_store(out, index, merge_line_hits(left_hit, right_hit));
+    }
+
+    return out;
+}
+
+static VALUE
+hash_field(VALUE hash, VALUE string_key, ID symbol_key)
+{
+    VALUE value = rb_hash_aref(hash, string_key);
+    if (NIL_P(value)) {
+        value = rb_hash_aref(hash, ID2SYM(symbol_key));
+    }
+
+    return value;
+}
+
+static VALUE
+branch_key(VALUE branch)
+{
+    if (!RB_TYPE_P(branch, T_HASH)) {
+        branch = rb_hash_new();
+    }
+
+    return rb_ary_new3(
+        3,
+        hash_field(branch, str_type, id_type),
+        hash_field(branch, str_start_line, id_start_line),
+        hash_field(branch, str_end_line, id_end_line)
+    );
+}
+
+static VALUE
+coverage_count(VALUE branch)
+{
+    VALUE coverage = hash_field(branch, str_coverage, id_coverage);
+    VALUE as_int = line_hit_to_i(coverage);
+    if (NIL_P(as_int)) {
+        return LONG2FIX(0);
+    }
+
+    return as_int;
+}
+
+static VALUE
+merge_branch_entries(VALUE left, VALUE right)
+{
+    VALUE out = rb_hash_dup(left);
+    VALUE sum = rb_funcall(coverage_count(left), rb_intern("+"), 1, coverage_count(right));
+    rb_hash_aset(out, str_coverage, sum);
+
+    return out;
+}
+
+static VALUE
+merge_module_value(void)
+{
+    VALUE polyrun = rb_const_get(rb_cObject, rb_intern("Polyrun"));
+    VALUE coverage = rb_const_get(polyrun, rb_intern("Coverage"));
+    return rb_const_get(coverage, rb_intern("Merge"));
+}
+
+static VALUE
+hash_keys(VALUE hash)
+{
+    return rb_funcall(hash, rb_intern("keys"), 0);
+}
+
+static VALUE
+sort_branches(VALUE branches)
+{
+    if (!RB_TYPE_P(branches, T_ARRAY)) {
+        return rb_ary_new();
+    }
+    if (RARRAY_LEN(branches) < 2) {
+        return branches;
+    }
+
+    return rb_funcall(merge_module_value(), id_sort_branches_for_native, 1, branches);
+}
+
+static VALUE
+duplicate_branch_side(VALUE value)
+{
+    if (NIL_P(value)) {
+        return Qnil;
+    }
+
+    return rb_obj_dup(value);
+}
+
+static VALUE
+coerce_branch_array(VALUE value)
+{
+    if (NIL_P(value)) {
+        return Qnil;
+    }
+    if (!RB_TYPE_P(value, T_ARRAY)) {
+        rb_raise(rb_eTypeError, "branches must be an Array");
+    }
+
+    return value;
+}
+
+static VALUE
+merge_branch_arrays(VALUE left, VALUE right)
+{
+    if (NIL_P(left) && NIL_P(right)) {
+        return Qnil;
+    }
+    if (NIL_P(left)) {
+        return duplicate_branch_side(right);
+    }
+    if (NIL_P(right)) {
+        return duplicate_branch_side(left);
+    }
+
+    left = coerce_branch_array(left);
+    right = coerce_branch_array(right);
+
+    VALUE index = rb_hash_new();
+    VALUE sides[2] = {left, right};
+
+    for (int side_index = 0; side_index < 2; side_index++) {
+        VALUE array = sides[side_index];
+        long length = RARRAY_LEN(array);
+
+        for (long branch_index = 0; branch_index < length; branch_index++) {
+            VALUE branch = rb_ary_entry(array, branch_index);
+            if (!RB_TYPE_P(branch, T_HASH)) {
+                continue;
+            }
+
+            VALUE key = branch_key(branch);
+            VALUE existing = rb_hash_aref(index, key);
+            VALUE merged = NIL_P(existing) ? rb_hash_dup(branch) : merge_branch_entries(existing, branch);
+            rb_hash_aset(index, key, merged);
+        }
+    }
+
+    VALUE values = rb_ary_new();
+    VALUE branch_keys = hash_keys(index);
+    long branch_count = RARRAY_LEN(branch_keys);
+    for (long branch_index = 0; branch_index < branch_count; branch_index++) {
+        VALUE key = rb_ary_entry(branch_keys, branch_index);
+        rb_ary_push(values, rb_hash_aref(index, key));
+    }
+
+    return sort_branches(values);
+}
+
+static VALUE
+normalize_file_entry(VALUE value)
+{
+    if (NIL_P(value)) {
+        return Qnil;
+    }
+    if (RB_TYPE_P(value, T_ARRAY)) {
+        VALUE entry = rb_hash_new();
+        rb_hash_aset(entry, str_lines, value);
+        return entry;
+    }
+    if (RB_TYPE_P(value, T_HASH)) {
+        return value;
+    }
+
+    return Qnil;
+}
+
+static VALUE
+entry_lines(VALUE entry)
+{
+    VALUE lines = rb_hash_aref(entry, str_lines);
+    if (NIL_P(lines)) {
+        lines = rb_hash_aref(entry, ID2SYM(id_lines));
+    }
+
+    return coerce_line_array(lines);
+}
+
+static VALUE
+entry_lines_for_count(VALUE entry)
+{
+    VALUE lines = rb_hash_aref(entry, str_lines);
+    if (NIL_P(lines)) {
+        lines = rb_hash_aref(entry, ID2SYM(id_lines));
+    }
+
+    return line_array_for_count(lines);
+}
+
+static VALUE
+entry_branches(VALUE entry)
+{
+    VALUE branches = rb_hash_aref(entry, str_branches);
+    if (NIL_P(branches)) {
+        branches = rb_hash_aref(entry, ID2SYM(id_branches));
+    }
+
+    return branches;
+}
+
+static VALUE
+merge_file_entry(VALUE left, VALUE right)
+{
+    left = normalize_file_entry(left);
+    right = normalize_file_entry(right);
+    if (NIL_P(left)) {
+        return right;
+    }
+    if (NIL_P(right)) {
+        return left;
+    }
+
+    VALUE merged_lines = merge_line_arrays(entry_lines(left), entry_lines(right));
+    VALUE entry = rb_hash_new();
+    rb_hash_aset(entry, str_lines, merged_lines);
+
+    VALUE left_branches = entry_branches(left);
+    VALUE right_branches = entry_branches(right);
+    if (!NIL_P(left_branches) || !NIL_P(right_branches)) {
+        VALUE branches = merge_branch_arrays(left_branches, right_branches);
+        if (!NIL_P(branches)) {
+            rb_hash_aset(entry, str_branches, branches);
+        }
+    }
+
+    return entry;
+}
+
+static VALUE
+ensure_hash(VALUE value, const char *name)
+{
+    if (NIL_P(value)) {
+        return rb_hash_new();
+    }
+    if (!RB_TYPE_P(value, T_HASH)) {
+        rb_raise(rb_eTypeError, "%s must be a Hash", name);
+    }
+
+    return value;
+}
+
+static VALUE
+merge_two(VALUE module, VALUE left, VALUE right)
+{
+    (void)module;
+
+    left = ensure_hash(left, "left");
+    right = ensure_hash(right, "right");
+
+    VALUE primary = left;
+    VALUE secondary = right;
+    if (RHASH_SIZE(right) > RHASH_SIZE(left)) {
+        primary = right;
+        secondary = left;
+    }
+
+    VALUE out = rb_hash_new();
+    VALUE primary_keys = hash_keys(primary);
+    long primary_length = RARRAY_LEN(primary_keys);
+
+    for (long index = 0; index < primary_length; index++) {
+        VALUE key = rb_ary_entry(primary_keys, index);
+        VALUE value = rb_hash_aref(primary, key);
+        VALUE right_entry = rb_hash_aref(secondary, key);
+        rb_hash_aset(out, key, merge_file_entry(value, right_entry));
+    }
+
+    VALUE secondary_keys = hash_keys(secondary);
+    long secondary_length = RARRAY_LEN(secondary_keys);
+
+    for (long index = 0; index < secondary_length; index++) {
+        VALUE key = rb_ary_entry(secondary_keys, index);
+        if (NIL_P(rb_hash_aref(out, key))) {
+            rb_hash_aset(out, key, rb_hash_aref(secondary, key));
+        }
+    }
+
+    return out;
+}
+
+static VALUE
+line_counts(VALUE module, VALUE file_entry)
+{
+    (void)module;
+
+    file_entry = normalize_file_entry(file_entry);
+    long relevant = 0;
+    long covered = 0;
+
+    if (!NIL_P(file_entry)) {
+        VALUE lines = entry_lines_for_count(file_entry);
+        long length = RARRAY_LEN(lines);
+
+        for (long index = 0; index < length; index++) {
+            VALUE hit = rb_ary_entry(lines, index);
+            if (NIL_P(hit) || ignored_hit_p(hit)) {
+                continue;
+            }
+
+            relevant += 1;
+            if (line_hit_positive_p(hit)) {
+                covered += 1;
+            }
+        }
+    }
+
+    VALUE counts = rb_hash_new();
+    rb_hash_aset(counts, ID2SYM(id_relevant), LONG2FIX(relevant));
+    rb_hash_aset(counts, ID2SYM(id_covered), LONG2FIX(covered));
+
+    return counts;
+}
+
+static VALUE
+merge_line_arrays_method(VALUE module, VALUE left, VALUE right)
+{
+    (void)module;
+
+    return merge_line_arrays(left, right);
+}
+
+void
+Init_polyrun_coverage_merge(void)
+{
+    id_lines = rb_intern("lines");
+    id_branches = rb_intern("branches");
+    id_type = rb_intern("type");
+    id_start_line = rb_intern("start_line");
+    id_end_line = rb_intern("end_line");
+    id_coverage = rb_intern("coverage");
+    id_relevant = rb_intern("relevant");
+    id_covered = rb_intern("covered");
+    id_sort_branches_for_native = rb_intern("sort_branches_for_native");
+    str_lines = rb_obj_freeze(rb_str_new_cstr("lines"));
+    str_branches = rb_obj_freeze(rb_str_new_cstr("branches"));
+    str_type = rb_obj_freeze(rb_str_new_cstr("type"));
+    str_start_line = rb_obj_freeze(rb_str_new_cstr("start_line"));
+    str_end_line = rb_obj_freeze(rb_str_new_cstr("end_line"));
+    str_coverage = rb_obj_freeze(rb_str_new_cstr("coverage"));
+    rb_global_variable(&str_lines);
+    rb_global_variable(&str_branches);
+    rb_global_variable(&str_type);
+    rb_global_variable(&str_start_line);
+    rb_global_variable(&str_end_line);
+    rb_global_variable(&str_coverage);
+
+    VALUE module = rb_define_module("PolyrunCoverageMerge");
+    rb_define_singleton_method(module, "merge_line_arrays", merge_line_arrays_method, 2);
+    rb_define_singleton_method(module, "merge_two", merge_two, 2);
+    rb_define_singleton_method(module, "line_counts", line_counts, 1);
+}

data/ext/polyrun_coverage_merge/extconf.rb

@@ -0,0 +1,3 @@
+require "mkmf"
+
+create_makefile("polyrun_coverage_merge")