simplecov-ruby/simplecov

SimpleCov is a code coverage analysis library for Ruby that aggregates and reports execution metrics from test suites. It provides granular tracking of line, branch, and method coverage, including support for Rails view templates and parallel test execution. The system features a modernized CLI for inspecting results, merging parallel data, and enforcing coverage baselines to prevent regressions. It also generates accessible, client-side rendered HTML reports and structured JSON output for integration with CI pipelines.

30 changes.

This period centered on a comprehensive redesign of SimpleCov, introducing a new configuration DSL, a standalone CLI, and a rewritten merging engine that supports granular branch and method coverage. The project significantly expanded its test infrastructure with extensive fixtures for edge cases, parallel execution, and various frameworks to ensure the reliability of these new features. Additionally, development tooling was standardized, and the codebase was updated to support modern Ruby and Rails versions.

48 changes.

The HTML coverage report frontend was completely rewritten in modular TypeScript with client-side rendering, introducing dark mode, accessibility features, and strict test coverage. The project expanded its CLI capabilities with new commands for affected tests, badges, and dead code detection, while adding a pluggable parallel adapter system and per-test coverage tracking.

The SimpleCov CLI Ratchet component now includes a new RBS signature file (output.rbs) that defines the static interface for the Output module. This adds type definitions for methods handling emission, change summaries, reporting of regressed tests, and JSON summary generation, improving type safety and IDE support for this specific CLI output logic.

_sig/internal/simplecov/cli/dead\code, sig/internal/simplecov/cli/history, sig/internal/simplecov/cli/ratchet · high confidence

The SimpleCov CLI now includes RBS signature files for all its subcommands and internal modules, enabling static type checking with Steep. This addition covers the full command surface—including \affected\, \annotations\, \badge\, \clean\, \completions\, \coverage\, \dead\_code\, \diff\, \dotfile\, \git\, \history\, \merge\, \open\, \patch\, \ratchet\, \report\, \run\, \serve\, \show\, \status\, \tests\, \uncovered\, \usage\, and \watch\—as well as shared helpers like \CommandHelpers\ and platform-specific path resolution. These signatures define the expected argument and return types for CLI entry points and internal logic, improving type safety and developer tooling support without altering runtime behavior.

sig/internal/simplecov/cli · high confidence

Ship RBS signature files for the \SimpleCov::Combine\ module, providing type definitions for the \BranchesCombiner\, \CoverageAccumulator\, \IdentityInterner\, \InternedCounts\, \LinesCombiner\, \MethodsCombiner\, and \ResultsCombiner\ components. This enables static type checking via Steep for the internal logic that merges and accumulates coverage results.

sig/internal/simplecov/combine · high confidence

Introduces a new parser module for SimpleCov baselines that converts YAML configuration into internal floor structures. The parser supports flexible input formats, including bare numeric values for line-percentage floors and hashes specifying percent and missed counts, while strictly validating criteria (lines, branches, methods) and raising ConfigurationError for malformed entries to ensure enforcement.

lib/simplecov/baseline · high confidence

A new benchmark suite in \benchmarks/collate\ allows measuring the performance of the coverage result merging process. The suite generates synthetic fixtures that mimic the shape of large parallel CI runs (defined in \Shape\) and runs the merge pipeline, including parallel merging via \SimpleCov::ParallelResultMerger\ when multiple processes are specified. It reports phase timings, memory usage (RSS), and a breakdown of work done during the merge, enabling developers to track performance regressions or improvements in the collation logic.

benchmarks/collate · high confidence

A new man page (man/simplecov.1) has been added to document the SimpleCov command-line interface. This provides users with standard Unix-style documentation for the tool's commands (such as run, coverage, show, report, status, history, badge, uncovered, tests, affected, merge, diff, patch, ratchet, dead-code, open, serve, watch, clean, completions, help, and version) and their associated options, improving discoverability and usability for terminal users.

man · high confidence

A new executable script at exe/simplecov has been added, allowing users to launch the SimpleCov CLI directly from the command line. This script sets up the load path to include the library directory and delegates execution to SimpleCov::CLI.run, enabling features like per-file coverage lookup and auto-instrumentation suites via the command line.

exe · high confidence

This change introduces RBS signature files for the SimpleCov exit-code check classes (BaselineCheck, Check, MaximumCoverageDropCheck, MaximumMissedCheck, MaximumMissedPerFileCheck, MaximumOverallCoverageCheck, MinimumCoverageByFileCheck, MinimumCoverageByGroupCheck, and MinimumOverallCoverageCheck). These signatures define the public and private interfaces of the checks, enabling static type checking via Steep to improve code reliability and developer experience when working with the coverage exit-code logic.

_sig/internal/simplecov/exit\codes · high confidence

This change introduces RBS signature files for the internal \SimpleCov::Result::MissingSourceFilesReporter\ and \SimpleCov::Result::SourceFileBuilder\ classes. These signatures define the structure and method signatures for these internal components, enabling static type checking via Steep to improve code reliability and developer experience during maintenance.

sig/internal/simplecov/result · high confidence

Ship RBS signatures checked by Steep for internal shims including ActionView, Marshal, Minitest, ParallelTests, RSpec, and SimpleCov.

sig/internal · high confidence

A new \test\_projects/rails/view\_demo\ project has been added to demonstrate \cover\_views\ in action. This self-contained Rails application uses RSpec view specs and SimpleCov to generate a coverage report that highlights both rendered and orphaned templates across ERB, Haml, and Slim. It serves as a concrete example of how the tool measures template coverage, including branch coverage and hit counts, and verifies the report structure via a Rake task.

_test\_projects/rails/view\demo · high confidence

A new test project located at test\_projects/parallel\_tests has been added to support parallel test execution. This project includes a set of sample classes (A, B, C, D) and corresponding RSpec specifications that exercise various Ruby control-flow constructs such as conditionals, case statements, and guard clauses. The test suite is configured with an .rspec file requiring spec\_helper and uses RSpec 4-compatible syntax, ensuring compatibility with the latest testing framework standards.

_test\_projects/parallel\tests · high confidence

SimpleCov now reports coverage for individual branches and methods in addition to lines. This change introduces dedicated classes (Branch, Method, Line) and builders to parse and process coverage data, allowing users to see exactly which code paths and functions are covered. It also adds support for \\# simplecov:disable\ and \\# simplecov:enable\ directives to skip specific lines, branches, or methods, and honors the deprecated \:nocov:\ toggle for backward compatibility. The implementation includes a new \RubyDataParser\ to safely parse coverage keys and handles encoding issues by scrubbing invalid UTF-8 bytes during source loading.

_lib/simplecov/source\file · high confidence

SimpleCov now supports a pluggable adapter system for parallel test runners, allowing it to correctly coordinate with runners beyond the historical default. A new \Base\ adapter class provides default no-op behaviors, while specific implementations like \ParallelTestsAdapter\ (for grosser/parallel\_tests) and \GenericAdapter\ (for runners using standard environment variables like \TEST\_ENV\_NUMBER\) enable precise detection and synchronization. This change ensures that SimpleCov honors opt-outs, handles unparseable configuration values safely, and avoids deadlocks by correctly identifying the first worker process for result aggregation.

_lib/simplecov/parallel\adapters · high confidence

The CLI now includes several new commands to enhance test and coverage analysis. The \affected\ command selects test files that touch code changed since a base ref, supporting \--run\ to execute them directly or \--json\ for CI integration. A new \badge\ command generates SVG coverage badges (line, branch, or method) for use in documentation or CI status pages. The \dead-code\ command cross-references test coverage with production coverage data to identify untested production code, dead code, and deletion candidates. Additionally, the \completions\ command generates shell completion scripts for fish, bash, and zsh based on the CLI's usage documentation.

lib/simplecov/cli · high confidence

SimpleCov now ships with several new bundled profiles to simplify configuration. The 'strict' profile enables branch, method, and eval coverage (where supported) and enforces 100% thresholds for lines, branches, and methods. The 'rails' profile provides sensible defaults for Rails applications, including grouping by standard directories, skipping config and db folders, and enabling subprocess merging. Additional profiles include 'test\_frameworks' to skip test/spec directories, 'bundler\_filter' to exclude vendor bundles, 'hidden\_filter' to ignore dotfiles, and 'root\_filter' to limit coverage to the project root.

lib/simplecov/profiles · high confidence

SimpleCov introduces a checked-in coverage baseline feature (\.simplecov ratchet\) that enforces per-file coverage floors using a new \SimpleCov::Baseline\ class, ensuring coverage does not regress over time. The configuration DSL has been redesigned around a \coverage\ method that accepts criteria (lines, branches, methods) and threshold options like \minimum\, \maximum\, and \maximum\_missed\ with scoping via \per:\ (e.g., \:file\, \:group\). A new benchmarking suite under \benchmarks/collate/\ provides performance profiling for resultset collation, including fixture generation and breakdown analysis. Additionally, the library adds a \SimpleCov::Filter\ hierarchy with \StringFilter\, \RegexFilter\, \GlobFilter\, and \ArrayFilter\ for more robust path-based filtering, and a \SimpleCov::Production::FileSink\ for merging production coverage data with exclusive locking.

simplecov · high confidence

SimpleCov now supports per-test coverage tracking, allowing you to see exactly which lines of code are executed by each individual test. This feature is available for RSpec and Minitest suites. When enabled, the framework hooks into your test runner to record coverage deltas for each test case, providing granular insight into test effectiveness and identifying untested code paths within specific tests.

_lib/simplecov/test\tracker · high confidence

The library now includes RBS type signatures (in the \sig/\ directory) for core components such as \SimpleCov\, \SimpleCov::Configuration\, \SimpleCov::Baseline::Parser\, and the Minitest plugin. This enables static type checking with Steep, providing better IDE support and catching type errors during development without changing runtime behavior.

sig · high confidence

This change introduces RBS type signature files for the internal SimpleCov components located in sig/internal/simplecov. The new signatures cover core modules and classes such as AtomicFile, CLI, Color, CommandGuesser, ContextMap, CoverageJSON, CoverageViolations, CurrentRun, Directive, ExitHandling, LinesClassifier, ParallelCoordination, ParallelResultMerger, Process, ReportDeferral, ReportStamp, ResultAdapter, ResultMerger, RunIdentity, SimulateCoverage, StaticCoverageExtractor, TestTracker, UnloadedFileInjector, UselessResultsRemover, and ViewCoverage. These signatures provide static type information for the internal implementation, enabling type checking and better IDE support for developers working with SimpleCov's internal APIs.

sig/internal/simplecov · high confidence

The tool now includes a generated man page (man/simplecov.1) built from the same source used for help text and shell completions, ensuring the documentation stays in sync with available commands and options. This is supported by new internal task modules: ManPage handles the roff generation, MutantShard optimizes mutation testing performance in CI by sharding subjects across runners, and ReleaseNotes extracts changelog sections for GitHub releases.

tasks · high confidence

SimpleCov now recognizes and honors directive comments (such as \simplecov:disable\) inside ERB, Haml, and Slim template files. The directive scanning logic has been extended to parse these template languages, allowing developers to exclude specific lines or blocks from coverage reports directly within their view templates, just as they can in Ruby source files.

lib/simplecov/directive, sig/internal/simplecov/directive · high confidence

SimpleCov now includes a new \TemplateCompiler\ component within the \ViewCoverage\ module that enables the capture of code coverage for Rails view templates (such as ERB, Haml, and Slim). This compiler works by building an ActionView \Template\ object for a given file and defining its method into a throwaway module; this allows the Ruby \Coverage\ library to record execution data for the template's compiled code without actually rendering it. The implementation is compatible with both older Rails versions (using \registered\_template\_handler\) and newer versions (using the \Template::Handlers\ registry), ensuring view coverage data is collected accurately during test runs.

_lib/simplecov/view\coverage · high confidence

This change introduces RBS type signature files for the \SimpleCov::CLI::Patch\ module, specifically defining the interfaces for \ChangedLines\ and \Output\. These signatures document the methods used to parse git diffs, track changed lines, and format/emit coverage reports (including text, JSON, and annotated output) to the terminal, improving static type checking and developer understanding of the patch command's internal structure.

sig/internal/simplecov/cli/patch · high confidence

This change introduces RBS type signature files for the \SimpleCov::CLI::Show::Annotator\ and \SimpleCov::CLI::Show::Sweep\ modules. These signatures define the interfaces for the CLI components responsible for printing annotated source code in the terminal and handling the display of uncovered lines, providing static type checking support for these internal CLI features.

sig/internal/simplecov/cli/show · high confidence

Added RBS type definitions for the SimpleCov::ContextMap::Union class, specifying its internal state (@map, @complete), reader attributes (carrying, entries), and public methods (collector, absorb\_resultset, absorb\_entry, absorb\_union, complete?, map, partial\_map, warn\_about\_partial\_maps). This provides static type checking and documentation for the union context map implementation within the SimpleCov internal API.

_sig/internal/simplecov/context\map · high confidence

SimpleCov now ships RBS type signatures for the internal classes and modules within the SourceFile namespace, including BranchBuilder, LineBuilder, MethodBuilder, RubyDataParser, SkipChunks, and SourceLoader. This addition enables static type checking via Steep for these specific source-file processing components, improving type safety and developer tooling support for the internal parsing and building logic.

_sig/internal/simplecov/source\file · high confidence

Added RBS type signatures for the HTML formatter's viewer data validator, defining the expected structure and validation methods for report data such as metadata, coverage flags, file entries, and production context. This ensures that the data passed to the HTML viewer conforms to the required schema before rendering.

_sig/internal/simplecov/formatter/html\formatter · high confidence

This change introduces RBS type signature files for the \SimpleCov::CLI::Affected\ module, specifically defining the interfaces for \ChangedFiles\, \Runner\ (including \SpawnedRunner\ and \SystemRunner\), and \Selection\. These signatures provide static type information for the internal logic that selects tests touching changed code, run them, and manage the selection state, improving type safety and IDE support for this part of the CLI.

sig/internal/simplecov/cli/affected, sig/internal/simplecov/cli/watch · high confidence

The static coverage extractor now includes RBS signature files (e.g., condition\_folding.rbs, visitor.rbs) that define the types for its internal modules and classes. This enables static type checking via Steep, ensuring that the logic for folding conditions, collecting methods, and emitting branch tuples remains consistent with the Prism AST visitor structure.

_sig/internal/simplecov/static\_coverage\extractor · high confidence

The HTML report frontend has been completely rewritten in TypeScript, splitting the previous monolithic script into focused modules (app, dom, page, dialog, filter, etc.). This change introduces a client-side rendering approach driven by static JSON data, enabling features such as dark mode and colorblind-friendly palettes, keyboard navigation, and improved performance for large file lists. It also adds support for rendering Haml and Slim templates, displaying per-test context data, and showing production coverage history.

_html\frontend/src · high confidence

The JSON formatter has been refactored into dedicated formatters (ErrorsFormatter, ProductionSectionFormatter, ResultHashFormatter, SourceFileFormatter) and now outputs coverage reports conforming to schema version 1.3. This update introduces a new \errors\ section that details violations for minimum/maximum coverage thresholds, baselines, and production coverage floors, organized by file and criterion. The report structure now includes optional \contexts\, \history\, and \production\ sections, records the git commit SHA in metadata, and allows source code inclusion to be toggled. Line statistics now explicitly report \omitted\ lines, and the formatter handles production coverage data from a configured store, warning if the data is unavailable rather than failing.

_lib/simplecov/formatter/json\formatter · high confidence

The HTML frontend has been modernized by upgrading core development dependencies, including TypeScript to 7.0.2, esbuild to 0.28.2, and oxlint to 1.83.0, alongside other package updates visible in the lockfile. To ensure code quality, the project now enforces 100% line and function coverage for all viewer modules during \bun test\ runs and integrates Stryker mutation testing with a strict break threshold, ensuring no surviving mutants are accepted.

_html\frontend · high confidence

The HTML coverage report has been completely rewritten as a single, self-contained \index.html\ file that renders client-side from static JSON data. This update introduces a modern UI with dark mode and a colorblind-friendly palette, improved source file syntax highlighting via an upgraded highlight.js, and better accessibility including distinct visual indicators for production vs. test coverage. The report now supports rendering files with no branches as fully covered, splits line bars by test attribution, and remembers file-list sort order, providing a more robust and accessible viewing experience for coverage data.

_lib/simplecov/formatter/html\formatter/public · high confidence

The HTML frontend assets have been restructured with new stylesheets (reset.css, screen.css, highlight.css) that introduce a modern CSS reset, comprehensive dark mode support via system preferences or manual toggle, and GitHub-style syntax highlighting for source code views. The styling also includes a colorblind-friendly mode that swaps the traditional red/green coverage indicators for blue/orange to improve accessibility, along with updated visual tokens for coverage states (covered, missed, skipped, etc.).

_html\frontend/assets · high confidence

The exit-code validation logic has been restructured into distinct check classes (e.g., BaselineCheck, MinimumOverallCoverageCheck) that are orchestrated by a central handler. This change introduces support for checking coverage against a checked-in baseline, allowing files to fail only if they drop below their specific historical floor. Additionally, the minimum overall coverage check now lists the five worst-coverage files (excluding fully covered ones) in its error output, and all threshold violations are colorized for better readability. The system also now honors the \print\_errors\ configuration when reporting these violations.

_lib/simplecov/exit\codes · high confidence

The formatter system has been restructured to improve reliability and consistency. A new \Formatter::Base\ class now provides shared scaffolding for HTML and JSON formatters, centralizing the logic for emitting status messages to stderr and calculating coverage statistics. To prevent data loss in parallel test environments, all report artifacts (HTML, JSON, and coverage.json) are now written using atomic file operations, and the system includes a new warning when a concurrent process overwrites the coverage.json file. Additionally, the HTML formatter now generates a single, self-contained index.html file with inline data, and the SimpleFormatter has been updated to respect the primary coverage setting.

lib/simplecov/formatter · high confidence

The result merging logic has been restructured into specialized modules to improve reliability and performance. \ResultsetStore\ now handles file I/O with atomic writes and explicit file locking to prevent race conditions during parallel test runs. \ResultsetFile\ adds tolerance for malformed or truncated JSON data, ensuring the merge process doesn't crash on corrupted cache files. \LegacyFormatAdapter\ automatically upgrades pre-0.18 coverage data formats. \UnloadedFiles\ centralizes the injection of untested files at the merge point, using criteria from the merged data to ensure consistent coverage reporting across workers. \ResultsetRunIdentity\ improves worker identification and run tracking to correctly handle concurrent processes.

_lib/simplecov/result\merger · high confidence

The SimpleCov merge logic has been completely rewritten to use a new \CoverageAccumulator\ and specialized combiners for lines, branches, and methods. This change fixes critical bugs where branch and method coverage data was incorrectly merged or lost when resultsets came from different processes (e.g., parallel CI runs) due to mismatched internal IDs; the new engine now matches these by source location instead. It also introduces method coverage support, improves performance by reducing GC pressure and avoiding repeated hashing via identity interning, and ensures that simulated coverage data does not incorrectly mask real uncovered lines.

lib/simplecov/combine · high confidence

Added RBS type signatures for the internal SimpleCov ResultMerger components (Contexts, LegacyFormatAdapter, ResultsetFile, ResultsetRunIdentity, ResultsetStore, and UnloadedFiles). This enables static type checking with Steep for the result merging logic, improving reliability for developers working on parallel run handling, legacy format adaptation, and thread-safe file access.

_sig/internal/simplecov/result\merger · high confidence

SimpleCov 1.4.0 brings a major architectural overhaul to the library. The configuration DSL has been redesigned around \cover\, \skip\, and \group\ methods, replacing the legacy API with a more explicit and composable interface. A new standalone CLI (\simplecov\) is now available, providing commands for coverage inspection, merging parallel results, and serving reports without requiring a full test run. The library now uses atomic file writes to prevent race conditions and data corruption when multiple parallel workers write coverage artifacts simultaneously. Additionally, the internal resultset format has been updated to use JSON with a versioned schema, improving stability and compatibility across different runs and environments.

lib/simplecov · high confidence

The \SimpleCov::Configuration\ module has been restructured into distinct sub-files to support a comprehensive set of new features and behavioral changes. Users can now configure coverage baselines via \baseline\_file\ to enforce per-file coverage floors, and track which specific tests cover each line of code using the new \track\_tests\ setting. The coverage criteria system has been expanded to support \oneshot\_line\ mode and explicit toggling for \eval\ coverage, while the \cover\ and \skip\ filters now use glob-based matching and include unloaded files by default. Reporting capabilities have been enhanced with \cover\_views\ for template coverage, \production\_coverage\ for merging production data, and configurable \history\_limit\ and \drop\_baseline\ modes for tracking coverage trends over time. Additionally, the configuration now supports \maximum\_missed\ caps, explicit color control, and configurable timeouts for parallel test merging.

lib/simplecov/configuration · high confidence

The static coverage extractor has been rewritten to accurately mirror the branch coverage tuples emitted by Ruby's built-in Coverage library. It now correctly handles constant-folding conditions (skipping branches the compiler eliminates), adapts to Prism API changes across Ruby versions, and applies legacy value-position logic for Ruby 3.3 to ensure branch locations match runtime reports.

_lib/simplecov/static\_coverage\extractor · high confidence

A new Minitest plugin (\lib/minitest/simplecov\_plugin.rb\) ensures code coverage works correctly when SimpleCov is started before Minitest (e.g., \SimpleCov.start\ before \require 'minitest/autorun'\). The plugin detects the SimpleCov environment, installs the necessary test tracking hooks, and defers the coverage exit behavior to Minitest's \after\_run\ callback, resolving ordering issues that previously prevented coverage data from being recorded in this specific startup sequence.

lib/minitest · high confidence

The merge process now records which specific test covered each line of code by maintaining a union of context maps from all merged results. This capability is implemented in the new \SimpleCov::ContextMap::Union\ class, which accumulates context data from every result absorbed during a merge. The union only retains this detailed per-test mapping if every merged result contributed a map; otherwise, it drops the map and warns the user if \track\_tests\ was enabled inconsistently across workers. This ensures that the final merged report accurately reflects the test coverage context without silently omitting data from workers that did not record it.

_lib/simplecov/context\map · high confidence

The test dummy application located in test\_projects/rails/rspec\_rails/config has been regenerated to target Rails 7.2.3.1. This update includes new default configuration files for the application, boot process, database (SQLite), and environments (development and test), along with standard initializers for cookies, parameter filtering, and parameter wrapping. The application configuration now explicitly loads Haml and Slim template handlers to support testing of these template languages, and utilizes Rails 7.2 defaults for initialization.

_test\_projects/rails/rspec\rails/config · high confidence

The HTML formatter now validates the structure of the viewer data before rendering the report. A new \ViewerDataValidator\ ensures that required sections (meta, total, coverage, groups) are present and correctly typed, that source files include an array of source strings, and that production coverage data (if present) lists sorted line numbers. This prevents rendering errors caused by malformed or incomplete coverage data.

_lib/simplecov/formatter/html\formatter · high confidence

Corrects a timing issue in the test project's filtering logic where the regular expression used to exclude non-root results was being applied prematurely, ensuring that test execution and result filtering now behave as intended within the monorepo structure.

_test\_projects/monorepo, test\_projects/monorepo/base, test\projects/monorepo/extra · medium confidence

Add RBS type signatures for SimpleCov CLI serve components; Add RBS type signatures for ViewCoverage template compiler; Add Rails 8.1 Minitest integration test fixture; Add encoding edge-case tests for EUC-JP and UTF-8 files; Add faked\_project test fixture for coverage collation; Add subprocess test project with SimpleCov integration; Added Cucumber test suite for faked\_project; Added JSON coverage fixtures for schema v1.3; Added RBS type signatures for the Redundancy test module; Added RSpec test suite for the Rails project; Added a dummy Rails application for testing; Added comprehensive test coverage for CLI subcommands and core utilities; Added coverage fixtures for branch, case, and template directives; Added screenshot coverage fixture for testing report visuals; Added test fixture for old coverage JSON format to reproduce crash \#820; Added test fixtures for RSpec and Test::Unit exit status behavior; Added test fixtures for bad\_spec scenarios; Added test infrastructure for pagination acceptance tests; Added test suite for faked\_project; Added tests for the coverage.json JSON Schema validation; Comprehensive test suite for the HTML frontend; Expanded sandbox test coverage for SimpleCov configuration and integration scenarios; Expanded test fixtures for coverage edge cases; Expanded test infrastructure and support helpers; Expanded test suite for new coverage and tooling capabilities; New benchmark suite for collation, report scaling, and result generation; Removed legacy test-unit test infrastructure.

The HTML and JSON formatters are now included directly in the SimpleCov gem, eliminating the need for separate \simplecov-html\ and \simplecov\_json\_formatter\ dependencies. The previous standalone gem files are replaced with backward-compatibility shims that delegate to the new internal formatter implementations, ensuring existing configurations continue to work without code changes.

lib · high confidence

The repository now includes several configuration files to standardize development workflows and tooling. Line endings are normalized to LF via \.gitattributes\. Code style is enforced using \Standard\ and \RuboCop\ (\.rubocop.yml\, \.standard.yml\). RSpec test execution is configured via \.rspec\ and \.rspec\_parallel\. Mutation testing is set up with \.mutant.yml\. The project's own coverage is configured via \.simplecov\, and a per-file coverage baseline is initialized in \.simplecov\_baseline.yml\. Documentation generation is configured via \.yardopts\.

(repo-wide) · high confidence

The project's development environment has been updated to require Ruby 3.3 or higher, with the main Gemfile now including RuboCop 1.88.2, RSpec 3.13.2, and the Standard linter suite. Test fixtures have been refreshed to use Rails 8.1.3.1, RSpec 3.13.2, and Cucumber 11.1.1, with conditional dependencies added for \bigdecimal\, \mutex\_m\, and \drb\ on Ruby 3.4+ and \benchmark\ on Ruby 4.0. The HTML frontend's \package.json\ has been updated to use esbuild 0.28.2, TypeScript 7.0.2, and oxlint 1.83.0.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 46 → 66 (+20.6)
• Rubric changed (rubric-2026.08.15 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 92 → 98 (+6.2)
• Architecture 97 → 96 (-1.0)
• Maturity 57 → 58 (+0.8)
• Readiness 23 → 74 (+50.5)
• Security 60 → 73 (+12.5)
• Domain Modelling 100 (new)
• Accessibility 67 (new)

• Coverage not measured — test suite did not build
• Dimension evaluation failed
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• LLM evaluation failed
• No build provenance
• No exposed public API
• No tests found
• Scanner failed to run — not a clean result
• Test reliability not included

• Change coupling: maximum_coverage_drop_check.rb ↔ minimum_coverage_by_file_check.rb (lib/simplecov/exit_codes/maximum_coverage_drop_check.rb)
• Change coupling: patch.rb ↔ usage.rb (lib/simplecov/cli/patch.rb)
• Coverage read from a committed report
• Documentation: contradicts the code (docs/CLI.md)
• Documentation: contradicts the code (docs/Commercial_Services.md)
• Documentation: no project overview (README.md)
• Duplicated block (8 lines × 2) (lib/simplecov/exit_codes/minimum_coverage_by_file_check.rb)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• …and 43 more

• 300 commits — 295 feature/other, 5 fixes

• lib/simplecov — 167 commits
• (root) — 33 commits
• html_frontend/src — 15 commits
• .github/workflows — 13 commits
• spec/simple_cov — 12 commits
• html_frontend/bun.lock — 10 commits
• test_projects/rails — 8 commits
• spec/support — 5 commits
• html_frontend/test — 4 commits
• spec/sandbox — 4 commits
• spec/fixtures — 3 commits
• spec/formatter — 3 commits
• docs/Alternate_Formatters.md — 2 commits
• docs/Configuration_Roadmap.md — 2 commits
• html_frontend/assets — 2 commits
• test_projects/rspec_conductor — 2 commits
• .github/ISSUE_TEMPLATE.md — 1 commit
• benchmarks/result.rb — 1 commit
• docs/CLI.md — 1 commit
• docs/Changelog.md — 1 commit

• fix: bump assert to fix ci failure
• fix: fix: apply maintainer review to the patch command
• fix: fix: close patch-coverage gate gaps and slim the CLI module
• fix: fix: gate on cross-multiplied ratio to avoid float-division error
• fix: fix: harden the patch gate against ambiguous paths and hostile git config
• change: Accept the shell's exit status for a missing command on JRuby
• change: Add --annotate github to patch
• change: Add patch command for per-change coverage
• change: Add a bun test suite enforcing 100% coverage of the HTML frontend
• change: Add a colorblind-friendly mode and non-color coverage symbols
• change: Add a version command to the CLI
• change: Add end-to-end coverage for rspec-conductor parallel runs
• change: Add rake tasks for the benchmarks
• change: Add undercover to the alternate formatters catalog
• change: Address review: dark toggle role and print palette
• change: Adopt Standard as the Ruby style, on top of RuboCop
• change: Adopt mutation testing with mutant
• change: Align the legend's swatches into columns
• change: Alphabetize the rails profile's groups by name
• change: Analyse mutations on pushes to main, not only pull requests
• …and 280 more

• Containers 0 added · 0 removed · contexts 1 added · 0 removed · edges 0 added · 0 removed

• simplecov

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

simplecov-ruby/simplecov was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.