refactor(coverage,reports): share three copy-pasted parsers by Chemaclass · Pull Request #971 · TypedDevs/bashunit

Chemaclass · 2026-08-02T12:04:41Z

🤔 Background

Three fragments that had to change together but were maintained separately.

None was findable by hashing whole function bodies — each lives inside a larger function that differs around it, which is exactly the shape that survives an exact-duplicate scan. (An earlier pass over all 577 functions found zero identical bodies; that was true and also not the whole picture.)

💡 Changes

get_file_stats / precompute_file_stats each parsed compute_file_coverage's "executable:hit" output and re-derived pct and class, in byte-identical five-line runs → one _compute_file_stats behind return slots.
The "executable:hit:pct:class" string returned by get_cached_stats was taken apart independently in report_text.sh, html_file.sh, and a near-identical variant in report_html.sh. Three separate opinions about a four-field format is the bug(parallel): same-named test files in different directories silently lose results #959 shape: nothing fails until someone adds a field → one fork-free split_stats.
The ANSI CSI regex was byte-identical in four report writers (junit, json, gha, tap) → one __strip_ansi in collect.sh.

The writers keep their own escape functions — only the strip step is shared. They read different field subsets and are allowed to diverge, so merging the loops would fail the very test this refactor is applied on: must the two copies change together?

✅ Behaviour checked, not asserted

junit, tap and json reports generated before and after are byte-identical once timings are normalised
a run with coloured failures emits zero ESC bytes into junit
the shared helper standardises on printf '%s' where two writers used echo, which also drops echo's trailing newline — immaterial because every caller captures through $(), and the final bytes of all three report files are unchanged

🚫 Left alone deliberately

Unifying this regex with the narrower m/K-only stripper in util/str.sh and assert/snapshot.sh. That's a real behaviour difference, not duplication, and belongs to whoever owns the decision.

make sa · make lint · bash build.sh bin -v → ✅ Build verified ✅ · 1650 sequential / 1609 parallel-simple-strict — baseline + 4 regression pins.

Three fragments that had to change together but were maintained separately. None was findable by hashing whole function bodies -- each lives inside a larger function that differs around it, which is exactly the shape that survives an exact-duplicate scan. 1. get_file_stats and precompute_file_stats each parsed compute_file_coverage's "executable:hit" output and re-derived pct and class, in byte-identical five-line runs. Now one _compute_file_stats behind return slots. 2. The "executable:hit:pct:class" string that get_cached_stats returns was taken apart independently in report_text.sh, html_file.sh and (in a near-identical variant) report_html.sh. Three separate opinions about a four-field format is the #959 shape: nothing fails until someone adds a field. Now one split_stats, fork-free. 3. The ANSI CSI regex was byte-identical in four report writers (junit, json, gha, tap). Now one __strip_ansi in collect.sh, so "what counts as an escape sequence" for report output is defined once. The writers keep their own escape functions -- only the strip step is shared. They read different field subsets and are allowed to diverge, so merging the loops would fail the test this refactor is applied on: must the two copies change together? Behaviour is unchanged, and checked rather than asserted: junit, tap and json reports generated before and after are byte-identical once timings are normalised, and a run with coloured failures emits zero ESC bytes into junit. The shared helper standardises on `printf '%s'` where two writers used `echo`, which also drops echo's trailing newline -- immaterial here because every caller captures through $(), and the final bytes of all three report files are unchanged. Left alone deliberately: unifying this regex with the narrower m/K-only stripper in util/str.sh and assert/snapshot.sh. That is a real behaviour difference, not duplication, and belongs to whoever owns the decision. 1650 sequential / 1609 parallel; baseline + 4 regression pins.

Chemaclass · 2026-08-02T12:04:41Z

🤔 Background

Three fragments that had to change together but were maintained separately.

None was findable by hashing whole function bodies — each lives inside a larger function that differs around it, which is exactly the shape that survives an exact-duplicate scan. (An earlier pass over all 577 functions found zero identical bodies; that was true and also not the whole picture.)

💡 Changes

get_file_stats / precompute_file_stats each parsed compute_file_coverage's "executable:hit" output and re-derived pct and class, in byte-identical five-line runs → one _compute_file_stats behind return slots.
The "executable:hit:pct:class" string returned by get_cached_stats was taken apart independently in report_text.sh, html_file.sh, and a near-identical variant in report_html.sh. Three separate opinions about a four-field format is the bug(parallel): same-named test files in different directories silently lose results #959 shape: nothing fails until someone adds a field → one fork-free split_stats.
The ANSI CSI regex was byte-identical in four report writers (junit, json, gha, tap) → one __strip_ansi in collect.sh.

The writers keep their own escape functions — only the strip step is shared. They read different field subsets and are allowed to diverge, so merging the loops would fail the very test this refactor is applied on: must the two copies change together?

✅ Behaviour checked, not asserted

junit, tap and json reports generated before and after are byte-identical once timings are normalised
a run with coloured failures emits zero ESC bytes into junit
the shared helper standardises on printf '%s' where two writers used echo, which also drops echo's trailing newline — immaterial because every caller captures through $(), and the final bytes of all three report files are unchanged

🚫 Left alone deliberately

Unifying this regex with the narrower m/K-only stripper in util/str.sh and assert/snapshot.sh. That's a real behaviour difference, not duplication, and belongs to whoever owns the decision.

make sa · make lint · bash build.sh bin -v → ✅ Build verified ✅ · 1650 sequential / 1609 parallel-simple-strict — baseline + 4 regression pins.

Three fragments that had to change together but were maintained separately. None was findable by hashing whole function bodies -- each lives inside a larger function that differs around it, which is exactly the shape that survives an exact-duplicate scan. 1. get_file_stats and precompute_file_stats each parsed compute_file_coverage's "executable:hit" output and re-derived pct and class, in byte-identical five-line runs. Now one _compute_file_stats behind return slots. 2. The "executable:hit:pct:class" string that get_cached_stats returns was taken apart independently in report_text.sh, html_file.sh and (in a near-identical variant) report_html.sh. Three separate opinions about a four-field format is the #959 shape: nothing fails until someone adds a field. Now one split_stats, fork-free. 3. The ANSI CSI regex was byte-identical in four report writers (junit, json, gha, tap). Now one __strip_ansi in collect.sh, so "what counts as an escape sequence" for report output is defined once. The writers keep their own escape functions -- only the strip step is shared. They read different field subsets and are allowed to diverge, so merging the loops would fail the test this refactor is applied on: must the two copies change together? Behaviour is unchanged, and checked rather than asserted: junit, tap and json reports generated before and after are byte-identical once timings are normalised, and a run with coloured failures emits zero ESC bytes into junit. The shared helper standardises on `printf '%s'` where two writers used `echo`, which also drops echo's trailing newline -- immaterial here because every caller captures through $(), and the final bytes of all three report files are unchanged. Left alone deliberately: unifying this regex with the narrower m/K-only stripper in util/str.sh and assert/snapshot.sh. That is a real behaviour difference, not duplication, and belongs to whoever owns the decision. 1650 sequential / 1609 parallel; baseline + 4 regression pins.

Chemaclass · 2026-08-02T12:04:41Z

🤔 Background

Three fragments that had to change together but were maintained separately.

None was findable by hashing whole function bodies — each lives inside a larger function that differs around it, which is exactly the shape that survives an exact-duplicate scan. (An earlier pass over all 577 functions found zero identical bodies; that was true and also not the whole picture.)

💡 Changes

get_file_stats / precompute_file_stats each parsed compute_file_coverage's "executable:hit" output and re-derived pct and class, in byte-identical five-line runs → one _compute_file_stats behind return slots.
The "executable:hit:pct:class" string returned by get_cached_stats was taken apart independently in report_text.sh, html_file.sh, and a near-identical variant in report_html.sh. Three separate opinions about a four-field format is the bug(parallel): same-named test files in different directories silently lose results #959 shape: nothing fails until someone adds a field → one fork-free split_stats.
The ANSI CSI regex was byte-identical in four report writers (junit, json, gha, tap) → one __strip_ansi in collect.sh.

The writers keep their own escape functions — only the strip step is shared. They read different field subsets and are allowed to diverge, so merging the loops would fail the very test this refactor is applied on: must the two copies change together?

✅ Behaviour checked, not asserted

junit, tap and json reports generated before and after are byte-identical once timings are normalised
a run with coloured failures emits zero ESC bytes into junit
the shared helper standardises on printf '%s' where two writers used echo, which also drops echo's trailing newline — immaterial because every caller captures through $(), and the final bytes of all three report files are unchanged

🚫 Left alone deliberately

Unifying this regex with the narrower m/K-only stripper in util/str.sh and assert/snapshot.sh. That's a real behaviour difference, not duplication, and belongs to whoever owns the decision.

make sa · make lint · bash build.sh bin -v → ✅ Build verified ✅ · 1650 sequential / 1609 parallel-simple-strict — baseline + 4 regression pins.

Three fragments that had to change together but were maintained separately. None was findable by hashing whole function bodies -- each lives inside a larger function that differs around it, which is exactly the shape that survives an exact-duplicate scan. 1. get_file_stats and precompute_file_stats each parsed compute_file_coverage's "executable:hit" output and re-derived pct and class, in byte-identical five-line runs. Now one _compute_file_stats behind return slots. 2. The "executable:hit:pct:class" string that get_cached_stats returns was taken apart independently in report_text.sh, html_file.sh and (in a near-identical variant) report_html.sh. Three separate opinions about a four-field format is the #959 shape: nothing fails until someone adds a field. Now one split_stats, fork-free. 3. The ANSI CSI regex was byte-identical in four report writers (junit, json, gha, tap). Now one __strip_ansi in collect.sh, so "what counts as an escape sequence" for report output is defined once. The writers keep their own escape functions -- only the strip step is shared. They read different field subsets and are allowed to diverge, so merging the loops would fail the test this refactor is applied on: must the two copies change together? Behaviour is unchanged, and checked rather than asserted: junit, tap and json reports generated before and after are byte-identical once timings are normalised, and a run with coloured failures emits zero ESC bytes into junit. The shared helper standardises on `printf '%s'` where two writers used `echo`, which also drops echo's trailing newline -- immaterial here because every caller captures through $(), and the final bytes of all three report files are unchanged. Left alone deliberately: unifying this regex with the narrower m/K-only stripper in util/str.sh and assert/snapshot.sh. That is a real behaviour difference, not duplication, and belongs to whoever owns the decision. 1650 sequential / 1609 parallel; baseline + 4 regression pins.

Chemaclass · 2026-08-02T12:04:41Z

🤔 Background

Three fragments that had to change together but were maintained separately.

None was findable by hashing whole function bodies — each lives inside a larger function that differs around it, which is exactly the shape that survives an exact-duplicate scan. (An earlier pass over all 577 functions found zero identical bodies; that was true and also not the whole picture.)

💡 Changes

get_file_stats / precompute_file_stats each parsed compute_file_coverage's "executable:hit" output and re-derived pct and class, in byte-identical five-line runs → one _compute_file_stats behind return slots.
The "executable:hit:pct:class" string returned by get_cached_stats was taken apart independently in report_text.sh, html_file.sh, and a near-identical variant in report_html.sh. Three separate opinions about a four-field format is the bug(parallel): same-named test files in different directories silently lose results #959 shape: nothing fails until someone adds a field → one fork-free split_stats.
The ANSI CSI regex was byte-identical in four report writers (junit, json, gha, tap) → one __strip_ansi in collect.sh.

The writers keep their own escape functions — only the strip step is shared. They read different field subsets and are allowed to diverge, so merging the loops would fail the very test this refactor is applied on: must the two copies change together?

✅ Behaviour checked, not asserted

junit, tap and json reports generated before and after are byte-identical once timings are normalised
a run with coloured failures emits zero ESC bytes into junit
the shared helper standardises on printf '%s' where two writers used echo, which also drops echo's trailing newline — immaterial because every caller captures through $(), and the final bytes of all three report files are unchanged

🚫 Left alone deliberately

Unifying this regex with the narrower m/K-only stripper in util/str.sh and assert/snapshot.sh. That's a real behaviour difference, not duplication, and belongs to whoever owns the decision.

make sa · make lint · bash build.sh bin -v → ✅ Build verified ✅ · 1650 sequential / 1609 parallel-simple-strict — baseline + 4 regression pins.

Three fragments that had to change together but were maintained separately. None was findable by hashing whole function bodies -- each lives inside a larger function that differs around it, which is exactly the shape that survives an exact-duplicate scan. 1. get_file_stats and precompute_file_stats each parsed compute_file_coverage's "executable:hit" output and re-derived pct and class, in byte-identical five-line runs. Now one _compute_file_stats behind return slots. 2. The "executable:hit:pct:class" string that get_cached_stats returns was taken apart independently in report_text.sh, html_file.sh and (in a near-identical variant) report_html.sh. Three separate opinions about a four-field format is the #959 shape: nothing fails until someone adds a field. Now one split_stats, fork-free. 3. The ANSI CSI regex was byte-identical in four report writers (junit, json, gha, tap). Now one __strip_ansi in collect.sh, so "what counts as an escape sequence" for report output is defined once. The writers keep their own escape functions -- only the strip step is shared. They read different field subsets and are allowed to diverge, so merging the loops would fail the test this refactor is applied on: must the two copies change together? Behaviour is unchanged, and checked rather than asserted: junit, tap and json reports generated before and after are byte-identical once timings are normalised, and a run with coloured failures emits zero ESC bytes into junit. The shared helper standardises on `printf '%s'` where two writers used `echo`, which also drops echo's trailing newline -- immaterial here because every caller captures through $(), and the final bytes of all three report files are unchanged. Left alone deliberately: unifying this regex with the narrower m/K-only stripper in util/str.sh and assert/snapshot.sh. That is a real behaviour difference, not duplication, and belongs to whoever owns the decision. 1650 sequential / 1609 parallel; baseline + 4 regression pins.

Chemaclass · 2026-08-02T12:04:41Z

🤔 Background

Three fragments that had to change together but were maintained separately.

None was findable by hashing whole function bodies — each lives inside a larger function that differs around it, which is exactly the shape that survives an exact-duplicate scan. (An earlier pass over all 577 functions found zero identical bodies; that was true and also not the whole picture.)

💡 Changes

get_file_stats / precompute_file_stats each parsed compute_file_coverage's "executable:hit" output and re-derived pct and class, in byte-identical five-line runs → one _compute_file_stats behind return slots.
The "executable:hit:pct:class" string returned by get_cached_stats was taken apart independently in report_text.sh, html_file.sh, and a near-identical variant in report_html.sh. Three separate opinions about a four-field format is the bug(parallel): same-named test files in different directories silently lose results #959 shape: nothing fails until someone adds a field → one fork-free split_stats.
The ANSI CSI regex was byte-identical in four report writers (junit, json, gha, tap) → one __strip_ansi in collect.sh.

The writers keep their own escape functions — only the strip step is shared. They read different field subsets and are allowed to diverge, so merging the loops would fail the very test this refactor is applied on: must the two copies change together?

✅ Behaviour checked, not asserted

junit, tap and json reports generated before and after are byte-identical once timings are normalised
a run with coloured failures emits zero ESC bytes into junit
the shared helper standardises on printf '%s' where two writers used echo, which also drops echo's trailing newline — immaterial because every caller captures through $(), and the final bytes of all three report files are unchanged

🚫 Left alone deliberately

Unifying this regex with the narrower m/K-only stripper in util/str.sh and assert/snapshot.sh. That's a real behaviour difference, not duplication, and belongs to whoever owns the decision.

make sa · make lint · bash build.sh bin -v → ✅ Build verified ✅ · 1650 sequential / 1609 parallel-simple-strict — baseline + 4 regression pins.

Three fragments that had to change together but were maintained separately. None was findable by hashing whole function bodies -- each lives inside a larger function that differs around it, which is exactly the shape that survives an exact-duplicate scan. 1. get_file_stats and precompute_file_stats each parsed compute_file_coverage's "executable:hit" output and re-derived pct and class, in byte-identical five-line runs. Now one _compute_file_stats behind return slots. 2. The "executable:hit:pct:class" string that get_cached_stats returns was taken apart independently in report_text.sh, html_file.sh and (in a near-identical variant) report_html.sh. Three separate opinions about a four-field format is the #959 shape: nothing fails until someone adds a field. Now one split_stats, fork-free. 3. The ANSI CSI regex was byte-identical in four report writers (junit, json, gha, tap). Now one __strip_ansi in collect.sh, so "what counts as an escape sequence" for report output is defined once. The writers keep their own escape functions -- only the strip step is shared. They read different field subsets and are allowed to diverge, so merging the loops would fail the test this refactor is applied on: must the two copies change together? Behaviour is unchanged, and checked rather than asserted: junit, tap and json reports generated before and after are byte-identical once timings are normalised, and a run with coloured failures emits zero ESC bytes into junit. The shared helper standardises on `printf '%s'` where two writers used `echo`, which also drops echo's trailing newline -- immaterial here because every caller captures through $(), and the final bytes of all three report files are unchanged. Left alone deliberately: unifying this regex with the narrower m/K-only stripper in util/str.sh and assert/snapshot.sh. That is a real behaviour difference, not duplication, and belongs to whoever owns the decision. 1650 sequential / 1609 parallel; baseline + 4 regression pins.

Chemaclass · 2026-08-02T12:04:41Z

🤔 Background

Three fragments that had to change together but were maintained separately.

None was findable by hashing whole function bodies — each lives inside a larger function that differs around it, which is exactly the shape that survives an exact-duplicate scan. (An earlier pass over all 577 functions found zero identical bodies; that was true and also not the whole picture.)

💡 Changes

get_file_stats / precompute_file_stats each parsed compute_file_coverage's "executable:hit" output and re-derived pct and class, in byte-identical five-line runs → one _compute_file_stats behind return slots.
The "executable:hit:pct:class" string returned by get_cached_stats was taken apart independently in report_text.sh, html_file.sh, and a near-identical variant in report_html.sh. Three separate opinions about a four-field format is the bug(parallel): same-named test files in different directories silently lose results #959 shape: nothing fails until someone adds a field → one fork-free split_stats.
The ANSI CSI regex was byte-identical in four report writers (junit, json, gha, tap) → one __strip_ansi in collect.sh.

The writers keep their own escape functions — only the strip step is shared. They read different field subsets and are allowed to diverge, so merging the loops would fail the very test this refactor is applied on: must the two copies change together?

✅ Behaviour checked, not asserted

junit, tap and json reports generated before and after are byte-identical once timings are normalised
a run with coloured failures emits zero ESC bytes into junit
the shared helper standardises on printf '%s' where two writers used echo, which also drops echo's trailing newline — immaterial because every caller captures through $(), and the final bytes of all three report files are unchanged

🚫 Left alone deliberately

Unifying this regex with the narrower m/K-only stripper in util/str.sh and assert/snapshot.sh. That's a real behaviour difference, not duplication, and belongs to whoever owns the decision.

make sa · make lint · bash build.sh bin -v → ✅ Build verified ✅ · 1650 sequential / 1609 parallel-simple-strict — baseline + 4 regression pins.

Three fragments that had to change together but were maintained separately. None was findable by hashing whole function bodies -- each lives inside a larger function that differs around it, which is exactly the shape that survives an exact-duplicate scan. 1. get_file_stats and precompute_file_stats each parsed compute_file_coverage's "executable:hit" output and re-derived pct and class, in byte-identical five-line runs. Now one _compute_file_stats behind return slots. 2. The "executable:hit:pct:class" string that get_cached_stats returns was taken apart independently in report_text.sh, html_file.sh and (in a near-identical variant) report_html.sh. Three separate opinions about a four-field format is the #959 shape: nothing fails until someone adds a field. Now one split_stats, fork-free. 3. The ANSI CSI regex was byte-identical in four report writers (junit, json, gha, tap). Now one __strip_ansi in collect.sh, so "what counts as an escape sequence" for report output is defined once. The writers keep their own escape functions -- only the strip step is shared. They read different field subsets and are allowed to diverge, so merging the loops would fail the test this refactor is applied on: must the two copies change together? Behaviour is unchanged, and checked rather than asserted: junit, tap and json reports generated before and after are byte-identical once timings are normalised, and a run with coloured failures emits zero ESC bytes into junit. The shared helper standardises on `printf '%s'` where two writers used `echo`, which also drops echo's trailing newline -- immaterial here because every caller captures through $(), and the final bytes of all three report files are unchanged. Left alone deliberately: unifying this regex with the narrower m/K-only stripper in util/str.sh and assert/snapshot.sh. That is a real behaviour difference, not duplication, and belongs to whoever owns the decision. 1650 sequential / 1609 parallel; baseline + 4 regression pins.

Chemaclass · 2026-08-02T12:04:41Z

🤔 Background

Three fragments that had to change together but were maintained separately.

None was findable by hashing whole function bodies — each lives inside a larger function that differs around it, which is exactly the shape that survives an exact-duplicate scan. (An earlier pass over all 577 functions found zero identical bodies; that was true and also not the whole picture.)

💡 Changes

get_file_stats / precompute_file_stats each parsed compute_file_coverage's "executable:hit" output and re-derived pct and class, in byte-identical five-line runs → one _compute_file_stats behind return slots.
The "executable:hit:pct:class" string returned by get_cached_stats was taken apart independently in report_text.sh, html_file.sh, and a near-identical variant in report_html.sh. Three separate opinions about a four-field format is the bug(parallel): same-named test files in different directories silently lose results #959 shape: nothing fails until someone adds a field → one fork-free split_stats.
The ANSI CSI regex was byte-identical in four report writers (junit, json, gha, tap) → one __strip_ansi in collect.sh.

The writers keep their own escape functions — only the strip step is shared. They read different field subsets and are allowed to diverge, so merging the loops would fail the very test this refactor is applied on: must the two copies change together?

✅ Behaviour checked, not asserted

junit, tap and json reports generated before and after are byte-identical once timings are normalised
a run with coloured failures emits zero ESC bytes into junit
the shared helper standardises on printf '%s' where two writers used echo, which also drops echo's trailing newline — immaterial because every caller captures through $(), and the final bytes of all three report files are unchanged

🚫 Left alone deliberately

Unifying this regex with the narrower m/K-only stripper in util/str.sh and assert/snapshot.sh. That's a real behaviour difference, not duplication, and belongs to whoever owns the decision.

make sa · make lint · bash build.sh bin -v → ✅ Build verified ✅ · 1650 sequential / 1609 parallel-simple-strict — baseline + 4 regression pins.

Three fragments that had to change together but were maintained separately. None was findable by hashing whole function bodies -- each lives inside a larger function that differs around it, which is exactly the shape that survives an exact-duplicate scan. 1. get_file_stats and precompute_file_stats each parsed compute_file_coverage's "executable:hit" output and re-derived pct and class, in byte-identical five-line runs. Now one _compute_file_stats behind return slots. 2. The "executable:hit:pct:class" string that get_cached_stats returns was taken apart independently in report_text.sh, html_file.sh and (in a near-identical variant) report_html.sh. Three separate opinions about a four-field format is the #959 shape: nothing fails until someone adds a field. Now one split_stats, fork-free. 3. The ANSI CSI regex was byte-identical in four report writers (junit, json, gha, tap). Now one __strip_ansi in collect.sh, so "what counts as an escape sequence" for report output is defined once. The writers keep their own escape functions -- only the strip step is shared. They read different field subsets and are allowed to diverge, so merging the loops would fail the test this refactor is applied on: must the two copies change together? Behaviour is unchanged, and checked rather than asserted: junit, tap and json reports generated before and after are byte-identical once timings are normalised, and a run with coloured failures emits zero ESC bytes into junit. The shared helper standardises on `printf '%s'` where two writers used `echo`, which also drops echo's trailing newline -- immaterial here because every caller captures through $(), and the final bytes of all three report files are unchanged. Left alone deliberately: unifying this regex with the narrower m/K-only stripper in util/str.sh and assert/snapshot.sh. That is a real behaviour difference, not duplication, and belongs to whoever owns the decision. 1650 sequential / 1609 parallel; baseline + 4 regression pins.

Chemaclass · 2026-08-02T12:04:41Z

🤔 Background

Three fragments that had to change together but were maintained separately.

None was findable by hashing whole function bodies — each lives inside a larger function that differs around it, which is exactly the shape that survives an exact-duplicate scan. (An earlier pass over all 577 functions found zero identical bodies; that was true and also not the whole picture.)

💡 Changes

get_file_stats / precompute_file_stats each parsed compute_file_coverage's "executable:hit" output and re-derived pct and class, in byte-identical five-line runs → one _compute_file_stats behind return slots.
The "executable:hit:pct:class" string returned by get_cached_stats was taken apart independently in report_text.sh, html_file.sh, and a near-identical variant in report_html.sh. Three separate opinions about a four-field format is the bug(parallel): same-named test files in different directories silently lose results #959 shape: nothing fails until someone adds a field → one fork-free split_stats.
The ANSI CSI regex was byte-identical in four report writers (junit, json, gha, tap) → one __strip_ansi in collect.sh.

The writers keep their own escape functions — only the strip step is shared. They read different field subsets and are allowed to diverge, so merging the loops would fail the very test this refactor is applied on: must the two copies change together?

✅ Behaviour checked, not asserted

junit, tap and json reports generated before and after are byte-identical once timings are normalised
a run with coloured failures emits zero ESC bytes into junit
the shared helper standardises on printf '%s' where two writers used echo, which also drops echo's trailing newline — immaterial because every caller captures through $(), and the final bytes of all three report files are unchanged

🚫 Left alone deliberately

Unifying this regex with the narrower m/K-only stripper in util/str.sh and assert/snapshot.sh. That's a real behaviour difference, not duplication, and belongs to whoever owns the decision.

make sa · make lint · bash build.sh bin -v → ✅ Build verified ✅ · 1650 sequential / 1609 parallel-simple-strict — baseline + 4 regression pins.

Three fragments that had to change together but were maintained separately. None was findable by hashing whole function bodies -- each lives inside a larger function that differs around it, which is exactly the shape that survives an exact-duplicate scan. 1. get_file_stats and precompute_file_stats each parsed compute_file_coverage's "executable:hit" output and re-derived pct and class, in byte-identical five-line runs. Now one _compute_file_stats behind return slots. 2. The "executable:hit:pct:class" string that get_cached_stats returns was taken apart independently in report_text.sh, html_file.sh and (in a near-identical variant) report_html.sh. Three separate opinions about a four-field format is the #959 shape: nothing fails until someone adds a field. Now one split_stats, fork-free. 3. The ANSI CSI regex was byte-identical in four report writers (junit, json, gha, tap). Now one __strip_ansi in collect.sh, so "what counts as an escape sequence" for report output is defined once. The writers keep their own escape functions -- only the strip step is shared. They read different field subsets and are allowed to diverge, so merging the loops would fail the test this refactor is applied on: must the two copies change together? Behaviour is unchanged, and checked rather than asserted: junit, tap and json reports generated before and after are byte-identical once timings are normalised, and a run with coloured failures emits zero ESC bytes into junit. The shared helper standardises on `printf '%s'` where two writers used `echo`, which also drops echo's trailing newline -- immaterial here because every caller captures through $(), and the final bytes of all three report files are unchanged. Left alone deliberately: unifying this regex with the narrower m/K-only stripper in util/str.sh and assert/snapshot.sh. That is a real behaviour difference, not duplication, and belongs to whoever owns the decision. 1650 sequential / 1609 parallel; baseline + 4 regression pins.

Chemaclass added the refactoring Refactoring or cleaning related label Aug 2, 2026

Chemaclass self-assigned this Aug 2, 2026

Chemaclass merged commit cb067fb into mainAug 2, 2026
37 checks passed

Chemaclass deleted the ref/dedupe-coverage-and-report-parsers branch August 2, 2026 12:13