📍 NOTE
RubyGems (the GitHub org, not the website) suffered a hostile takeover in September 2025.
Ultimately 4 maintainers were hard removed and a reason has been given for only 1 of those, while 2 others resigned in protest.
It is a complicated story which is difficult to parse quickly.
Simply put - there was active policy for adding or removing maintainers/owners of rubygems and bundler, and those policies were not followed.
I'm adding notes like this to gems because I don't condone theft of repositories or gems from their rightful owners.
If a similar theft happened with my repos/gems, I'd hope some would stand up for me.
Disenfranchised former-maintainers have started gem.coop.
Once available I will publish there exclusively; unless RubyCentral makes amends with the community.
The "Technology for Humans: Joel Draper" podcast episode by reinteractive is the most cogent summary I'm aware of.
See here, here and here for more info on what comes next.
What I'm doing: A (WIP) proposal for bundler/gem scopes, and a (WIP) proposal for a federated gem server.

🥘 Kettle::Soup::Cover

if ci_badges.map(&:color).detect { it != "green"} ☝️ let me know, as I may have missed the discord notification.

---

if ci_badges.map(&:color).all? { it == "green"} 👇️ send money so I can do more of this. FLOSS maintenance is now my full-time job.

🌻 Synopsis

Four lines of code to get a configured, curated, opinionated, set of dependencies for Test Coverage, and that's including the two lines for require "simplecov", and SimpleCov.start.

Configured for what? To work out of the box on every CI*. Batteries included. For apps and libraries. Any test framework. Many code coverage related GitHub Actions (example configs 1, 2).

Test Framework	Helper	Config
MiniTest	test helper	.simplecov
RSpec	spec helper	.simplecov

📔 DO YOU LIKE PATTERNS?!? 📔

This library's local dev / testing / CI dependency structure serves as an example of a "modular gemfile" pattern enabling a discrete gemfile for each CI workflow.

What is a modular gemfile?

This modular pattern has the following benefits: - All dependencies are DRY, never repeated. - All modular gemfiles are shared between the main `Gemfile`, and the workflow `gemfiles/*.gemfile`s that need them. - All gemfiles source from the `gemspec`. If you like this idea, there is an even better alternative. I've codified it for reuse in my [appraisal2](https://github.com/appraisal-rb/appraisal2/) gem, which is a hard fork of the venerable `appraisal` gem due to that gem's lack of support for modular gemfiles.

📔 ME TOO! 📔

12-factor

One of the major benefits of using this library is not having to figure out how to get multiple coverage output formats working. I did that for you, and I got all of them working, at the same time together, or al la carte. Kum-ba-ya.

A quick shot of 12-factor coverage power, straight to your brain:

export K_SOUP_COV_COMMAND_NAME="RSpec (COVERAGE)" # Display name for the coverage run
export K_SOUP_COV_DEBUG=false # Enable debug output for configuration (true/false)
export K_SOUP_COV_DIR=coverage # Directory where coverage reports are written
export K_SOUP_COV_DO=true # Enable coverage collection (true/false)
export K_SOUP_COV_FILTER_DIRS="bin,docs,vendor" # Comma-separated dirs to filter out of coverage
export K_SOUP_COV_FORMATTERS="html,tty" # Comma-separated list: html,xml,rcov,lcov,json,tty
export K_SOUP_COV_MERGE_TIMEOUT=3600 # Timeout in seconds when merging multiple coverage results
export K_SOUP_COV_MIN_BRANCH=53 # Minimum required branch coverage percentage (integer)
export K_SOUP_COV_MIN_HARD=true # If true, fail the run when coverage thresholds are not met
export K_SOUP_COV_MIN_LINE=69 # Minimum required line coverage percentage (integer)
export K_SOUP_COV_MULTI_FORMATTERS=true # Enable multiple SimpleCov formatters (true/false)
export K_SOUP_COV_PREFIX="K_SOUP_COV_" # Prefix used for the envvars (useful for namespacing)
export K_SOUP_COV_OPEN_BIN=xdg-open # Command to open HTML report in `coverage` rake task (or empty to disable)
export K_SOUP_COV_USE_MERGING=false # Enable merging of results for parallel/test matrix runs (true/false)
export K_SOUP_COV_VERBOSE=false # Enable verbose logging (true/false)
export MAX_ROWS=5 # simplecov-console setting: limits tty output to the worst N rows of uncovered files

I hope I've piqued your interest enough to give it a ⭐️ if the forge you are on supports it.

What does the name mean?

A Covered Kettle of SOUP (Software of Unknown Provenance) The name is derived in part from the medical devices field, where this library is considered a package of [SOUP](https://en.wikipedia.org/wiki/Software_of_unknown_pedigree).

💡 Info you can shake a stick at

Tokens to Remember
Works with JRuby
Works with Truffle Ruby
Works with MRI Ruby 3
Works with MRI Ruby 2
Support & Community
Source
Documentation
Compliance
Style
Maintainer 🎖️
... 💖	🧊 🐙 🛖 🧪

Compatibility

Compatible with MRI Ruby 2.7+, and concordant releases of JRuby, and TruffleRuby.

🚚 Amazing test matrix was brought to you by	🔎 appraisal2 🔎 and the color 💚 green 💚
👟 Check it out!	✨ github.com/appraisal-rb/appraisal2 ✨

Federated DVCS

Find this repo on federated forges (Coming soon!)

| Federated [DVCS][💎d-in-dvcs] Repository | Status | Issues | PRs | Wiki | CI | Discussions | |-------------------------------------------------|-----------------------------------------------------------------------|---------------------------|--------------------------|---------------------------|--------------------------|------------------------------| | 🧪 [kettle-rb/kettle-soup-cover on GitLab][📜src-gl] | The Truth | [💚][🤝gl-issues] | [💚][🤝gl-pulls] | [💚][📜gl-wiki] | 🐭 Tiny Matrix | ➖ | | 🧊 [kettle-rb/kettle-soup-cover on CodeBerg][📜src-cb] | An Ethical Mirror ([Donate][🤝cb-donate]) | [💚][🤝cb-issues] | [💚][🤝cb-pulls] | ➖ | ⭕️ No Matrix | ➖ | | 🐙 [kettle-rb/kettle-soup-cover on GitHub][📜src-gh] | Another Mirror | [💚][🤝gh-issues] | [💚][🤝gh-pulls] | [💚][📜gh-wiki] | 💯 Full Matrix | [💚][gh-discussions] | | 🎮️ [Discord Server][✉️discord-invite] | [![Live Chat on Discord][✉️discord-invite-img-ftb]][✉️discord-invite] | [Let's][✉️discord-invite] | [talk][✉️discord-invite] | [about][✉️discord-invite] | [this][✉️discord-invite] | [library!][✉️discord-invite] |

Enterprise Support

Available as part of the Tidelift Subscription.

Need enterprise-level guarantees?

The maintainers of this and thousands of other packages are working with Tidelift to deliver commercial support and maintenance for the open source packages you use to build your applications. Save time, reduce risk, and improve code health, while paying the maintainers of the exact packages you use. [![Get help from me on Tidelift][🏙️entsup-tidelift-img]][🏙️entsup-tidelift] - 💡Subscribe for support guarantees covering _all_ your FLOSS dependencies - 💡Tidelift is part of [Sonar][🏙️entsup-tidelift-sonar] - 💡Tidelift pays maintainers to maintain the software you depend on!
📊`@`Pointy Haired Boss: An [enterprise support][🏙️entsup-tidelift] subscription is "[never gonna let you down][🧮kloc]", and *supports* open source maintainers Alternatively: - [![Live Chat on Discord][✉️discord-invite-img-ftb]][✉️discord-invite] - [![Get help from me on Upwork][👨🏼‍🏫expsup-upwork-img]][👨🏼‍🏫expsup-upwork] - [![Get help from me on Codementor][👨🏼‍🏫expsup-codementor-img]][👨🏼‍🏫expsup-codementor]

✨ Installation

Install the gem and add to the application's Gemfile by executing:

bundle add kettle-soup-cover

If bundler is not being used to manage dependencies, install the gem by executing:

gem install kettle-soup-cover

🔒 Secure Installation

For Medium or High Security Installations

This gem is cryptographically signed, and has verifiable [SHA-256 and SHA-512][💎SHA_checksums] checksums by [stone_checksums][💎stone_checksums]. Be sure the gem you install hasn’t been tampered with by following the instructions below. Add my public key (if you haven’t already, expires 2045-04-29) as a trusted certificate: ```console gem cert --add <(curl -Ls https://raw.github.com/galtzo-floss/certs/main/pboling.pem) ``` You only need to do that once. Then proceed to install with: ```console gem install kettle-soup-cover -P HighSecurity ``` The `HighSecurity` trust profile will verify signed gems, and not allow the installation of unsigned dependencies. If you want to up your security game full-time: ```console bundle config set --global trust-policy MediumSecurity ``` `MediumSecurity` instead of `HighSecurity` is necessary if not all the gems you use are signed. NOTE: Be prepared to track down certs for signed gems and add them the same way you added mine.

⚙️ Configuration

Merging

Below is some part of the Rakefile pulled from the tree_haver gem which merges the results of various discrete RSpec test suites that are impossible to run at the same time. The pattern should also work for minitest / test unit.

### SPEC TASKS
# Run FFI specs first (before the collision of MRI+FFI backends pollutes the environment),
# then run remaining specs. This ensures FFI tests get a clean environment
# while still validating that BackendConflict protection works.
#
# For coverage aggregation with SimpleCov merging:
# - Each task uses a unique K_SOUP_COV_COMMAND_NAME so SimpleCov tracks them separately
# - K_SOUP_COV_USE_MERGING=true must be set in .envrc for results to merge
# - K_SOUP_COV_MERGE_TIMEOUT should be set long enough for all tasks to complete
begin
  require "rspec/core/rake_task"

  # FFI specs run first in a clean environment
  desc("Run FFI backend specs first (before MRI loads)")
  RSpec::Core::RakeTask.new(:ffi_specs) do |t|
    t.pattern = "./spec/**/*_spec.rb"
    t.rspec_opts = "--tag ffi"
  end
  # Set unique command name at execution time for SimpleCov merging
  desc("Set SimpleCov command name for FFI specs")
  task(:set_ffi_command_name) do
    ENV["K_SOUP_COV_COMMAND_NAME"] = "FFI Specs"
  end
  Rake::Task[:ffi_specs].enhance([:set_ffi_command_name])

  # Matrix checks will run in between FFI and MRI
  desc("Run Backend Matrix Specs")
  RSpec::Core::RakeTask.new(:backend_matrix_specs) do |t|
    t.pattern = "./spec_matrix/**/*_spec.rb"
  end
  desc("Set SimpleCov command name for backend matrix specs")
  task(:set_matrix_command_name) do
    ENV["K_SOUP_COV_COMMAND_NAME"] = "Backend Matrix Specs"
  end
  Rake::Task[:backend_matrix_specs].enhance([:set_matrix_command_name])

  # All other specs run after FFI specs
  desc("Run non-FFI specs (after FFI specs have run)")
  RSpec::Core::RakeTask.new(:remaining_specs) do |t|
    t.pattern = "./spec/**/*_spec.rb"
    t.rspec_opts = "--tag ~ffi"
  end
  desc("Set SimpleCov command name for remaining specs")
  task(:set_remaining_command_name) do
    ENV["K_SOUP_COV_COMMAND_NAME"] = "Remaining Specs"
  end
  Rake::Task[:remaining_specs].enhance([:set_remaining_command_name])

  # Final task to run all specs (for spec task, runs in single process for final coverage merge)
  desc("Run all specs in one process (no FFI isolation)")
  RSpec::Core::RakeTask.new(:all_specs) do |t|
    t.pattern = "spec/**{,/*/**}/*_spec.rb"
  end
  desc("Set SimpleCov command name for all specs")
  task(:set_all_command_name) do
    ENV["K_SOUP_COV_COMMAND_NAME"] = "All Specs"
  end
  Rake::Task[:all_specs].enhance([:set_all_command_name])

  # Override the default spec task to run in sequence
  # NOTE: We do NOT include :all_specs here because ffi_specs + remaining_specs already
  # cover all specs. Including all_specs would cause duplicated test runs.
  Rake::Task[:spec].clear if Rake::Task.task_defined?(:spec)
  desc("Run specs with FFI tests first, then backend matrix, then remaining tests")
  task(spec: [:ffi_specs, :backend_matrix_specs, :remaining_specs]) # rubocop:disable Rake/DuplicateTask:
rescue LoadError
  desc("(stub) spec is unavailable")
  task(:spec) do # rubocop:disable Rake/DuplicateTask:
    warn("NOTE: rspec isn't installed, or is disabled for #{RUBY_VERSION} in the current environment")
  end
end

🔧 Basic Usage

RSpec or MiniTest

In your spec/spec_helper.rb or tests/test_helper.rb, just before loading the library under test, add two lines of code:

With Ruby 2.7+

require "kettle-soup-cover"
require "simplecov" if Kettle::Soup::Cover::DO_COV # `.simplecov` is run here!
# IMPORTANT: If you are using MiniTest instead of RSpec, also do this (and not in .simplecov):
# SimpleCov.external_at_exit = true

Example: Rails & RSpec

In your spec/rails_helper.rb

# External gems
require "kettle-soup-cover"

# This file is copied to spec/ when you run 'rails generate rspec:install'
# We provide a preconfigured version compatible with Rails 8
require "spec_helper"
ENV["RAILS_ENV"] ||= "test"

# Last thing before loading the app-under-test is code coverage.
require "simplecov" if Kettle::Soup::Cover::DO_COV # `.simplecov` is run here!
require File.expand_path("../config/environment", __dir__)

P.S. Ensure that you have require: false on the gem in the Gemfile, and that it is in both :development and :test groups, since it ships a coverage rake task:

group :development, :test do
  gem "kettle-soup-cover", "~> 1.0", ">= 1.0.10", require: false
end

Projects that run tests against older Ruby versions, e.g. with Appraisals

# NOTE: Gemfiles for older rubies won't have kettle-soup-cover.
#       The rescue LoadError handles that scenario.
begin
  require "kettle-soup-cover"

  if Kettle::Soup::Cover::DO_COV
    require "simplecov" # `.simplecov` is run here!

    # IMPORTANT: If you are using MiniTest instead of RSpec, also do this (and not in .simplecov):
    # SimpleCov.external_at_exit = true
  end
rescue LoadError => error
  # check the error message, if you are so inclined, and re-raise if not what is expected
  raise error unless error.message.include?("kettle")
end

All projects

In your .simplecov file, add 2 lines of code:

require "kettle/soup/cover/config" # 12-factor, ENV-based configuration, with good defaults!
# you could do this somewhere else, up to you, but you do have to do it somewhere
SimpleCov.start

See Advanced Usage below for more info, but the simplest thing is to run all the coverage things, which is configured by default on CI. To replicate that locally you could:

CI=true bundle exec rake test # or whatever command you run for tests.

That's it!

Rakefile

You'll need to have your test task defined. If you use spec instead, you can make it a pre-requisite of the test task with:

desc "run spec task with test task"
task test: :spec

This gem provides a coverage task. It runs the test task (see just above about that), and opens the coverage results in a browser.

require "kettle-soup-cover"
Kettle::Soup::Cover.install_tasks

kettle-soup-cover (exe/kettle-soup-cover)

This gem ships a small helper binary kettle-soup-cover under exe/kettle-soup-cover. It consumes a SimpleCov JSON output (coverage/coverage.json) and prints a readable, summarized report of lines and branches. The script will, by default, look for coverage/coverage.json in the directory configured by K_SOUP_COV_DIR (defaults to coverage).

Usage examples:

kettle-soup-cover              # Uses $K_SOUP_COV_DIR/coverage.json (default coverage/coverage.json)
kettle-soup-cover -p path/to/coverage.json  # Read JSON from a custom path
kettle-soup-cover ./coverage/coverage.json  # Positional path is accepted as an alternative to -p/--path
kettle-soup-cover -f kettle/soup           # Show only files matching kettle/soup (partial substring match)
kettle-soup-cover -f "kettle/soup/**/*.rb" # Globbing is supported; -f will treat patterns containing *?[] as globs

Notes:

• The script requires the json formatter to be active in K_SOUP_COV_FORMATTERS if you don't supply an explicit JSON path via -p or a positional arg; otherwise it will abort with an actionable message.
• -f/--file is a file filter (partial path match) and cannot be used to specify the coverage JSON path.
• K_SOUP_COV_DIR controls the default path used by the script (defaults to coverage).

Filters

There are two built-in SimpleCov filters which can be loaded via Kettle::Soup::Cover.load_filters.

You could use them like this:

SimpleCov.add_group("Too Long", Kettle::Soup::Cover::Filters::GtLineFilter.new(1000))

Advanced Usage

There are a number of ENV variables that control things within this gem. All of them can be found, along with their default values, in lib/kettle/soup/cover.rb.

Handy List of ENV Variables

Most are self explanatory. I tried to follow POLS, the principle of least surprise, so they mostly DWTFYT. Want to help improve this documentation? PRs are easy!

Below is a reference for the environment variables used by this gem. Each section documents the variable name, its default value, what it controls, and an example of usage. Variable names are prefixed with the value of K_SOUP_COV_PREFIX (by default K_SOUP_COV_).

K_SOUP_COV_COMMAND_NAME

• Default: RSpec (COVERAGE)
• What it controls: Display name for the coverage run, used in UIs or log output.
• Example: export K_SOUP_COV_COMMAND_NAME="Unit Tests (Coverage)"

K_SOUP_COV_DEBUG

• Default: false (string value read truthily)
• What it controls: Enable debug output for the configuration, prints the prefixes and selected values.
• Example: export K_SOUP_COV_DEBUG=true

K_SOUP_COV_DIR

• Default: coverage
• What it controls: Directory where SimpleCov writes coverage reports. The exe/kettle-soup-cover script and rake tasks will look here for artefacts like coverage.json or index.html.
• Example: export K_SOUP_COV_DIR=my-coverage

K_SOUP_COV_DO

• Default: Uses CI if unset (CI=false default). Setting to true or false enables/disables coverage collection.
• What it controls: Controls whether the gem enables SimpleCov at runtime (DO_COV behavior).
• Example: export K_SOUP_COV_DO=true

K_SOUP_COV_FILTER_DIRS

• Default: bin,certs,checksums,config,coverage,docs,features,gemfiles,pkg,results,sig,spec,src,test,test-results,vendor
• What it controls: A comma-separated list of directory names to filter out from coverage reports.
• Example: export K_SOUP_COV_FILTER_DIRS=vendor,bin,docs

K_SOUP_COV_FORMATTERS

• Default: html,xml,rcov,lcov,json,tty on CI; html,tty locally.
• What it controls: Comma-separated list of formatters that determine the kind of coverage reports generated. Supported values include html, xml, rcov, lcov, json, tty.
• Example: export K_SOUP_COV_FORMATTERS="html,json"

Note: the exe/kettle-soup-cover script requires that the json formatter be enabled so it can read a canonical coverage/coverage.json file. If you plan to use that script, ensure json is included in your K_SOUP_COV_FORMATTERS value as shown in the example above.

K_SOUP_COV_MERGE_TIMEOUT

• Default: nil
• What it controls: When using merging (K_SOUP_COV_USE_MERGING=true), this sets a numeric timeout in seconds for the merge operation.
• Example: export K_SOUP_COV_MERGE_TIMEOUT=3600

K_SOUP_COV_MIN_BRANCH

• Default: 80
• What it controls: Minimum allowed branch coverage percentage. Used to assert that coverage thresholds are met.
• Example: export K_SOUP_COV_MIN_BRANCH=85

K_SOUP_COV_MIN_HARD

• Default: Uses CI if unset (CI=false default). When true the build will fail if thresholds are not met.
• What it controls: Whether failing coverage thresholds should fail the run (hard failure) or only warn.
• Example: export K_SOUP_COV_MIN_HARD=true

K_SOUP_COV_MIN_LINE

• Default: 80
• What it controls: Minimum allowed line coverage percentage.
• Example: export K_SOUP_COV_MIN_LINE=92

K_SOUP_COV_MULTI_FORMATTERS

• Default: If running on CI (true) the default is true, otherwise the default is true if any formatters are present.
• What it controls: Whether to configure SimpleCov to run multiple formatters concurrently or not.
• Example: export K_SOUP_COV_MULTI_FORMATTERS=false

K_SOUP_COV_PREFIX

• Default: K_SOUP_COV_
• What it controls: Prefix used for the environment variables described in this section; useful if you want a custom-namespaced set for tests.
• Example: export K_SOUP_COV_PREFIX="MY_COV_"

K_SOUP_COV_OPEN_BIN

• Default: Uses open on macOS and xdg-open on Linux.
• What it controls: Command used by the Rake coverage task to open the HTML report. Set to an empty value to disable auto-opening and just print report locations.
• Example: export K_SOUP_COV_OPEN_BIN=xdg-open or export K_SOUP_COV_OPEN_BIN= (to only print the path)

K_SOUP_COV_USE_MERGING

• Default: nil (disabled)
• What it controls: When true, enables result merging semantics for multiple test runs (works with merge timeout and other behaviors).
• Example: export K_SOUP_COV_USE_MERGING=true

K_SOUP_COV_VERBOSE

• Default: false
• What it controls: Enables additional verbose logging where supported within tasks and scripts.
• Example: export K_SOUP_COV_VERBOSE=true

Note: Some third-party formatters may also read their own environment variables. For example, the simplecov-console formatter supports MAX_ROWS to limit the tty output. This is not prefixed with K_SOUP_COV_ by design and is passed through to the formatter directly.

Additionally, some of the included gems, like simplecov-console, have their own complete suite of ENV variables you can configure.

Compatible with GitHub Actions for Code Coverage feedback in pull requests

If you don't want to configure a SaaS service to update your pull requests with code coverage there are alternatives.

After the step that runs your test suite use one or more of the following.

irongut/CodeCoverageSummary

Repo: irongut/CodeCoverageSummary

      - name: Code Coverage Summary Report
        uses: irongut/CodeCoverageSummary@v1.3.0
        if: ${{ github.event_name == 'pull_request' }}
        with:
          filename: ./coverage/coverage.xml
          badge: true
          fail_below_min: true
          format: markdown
          hide_branch_rate: false
          hide_complexity: true
          indicators: true
          output: both
          thresholds: '100 100' # '<MIN LINE COVERAGE> <MIN BRANCH COVERAGE>'
        continue-on-error: ${{ matrix.experimental != 'false' }}

marocchino/sticky-pull-request-comment

Repo: marocchino/sticky-pull-request-comment

      - name: Add Coverage PR Comment
        uses: marocchino/sticky-pull-request-comment@v2
        if: ${{ github.event_name == 'pull_request' }}
        with:
          recreate: true
          path: code-coverage-results.md
        continue-on-error: ${{ matrix.experimental != 'false' }}

🦷 FLOSS Funding

While kettle-rb tools are free software and will always be, the project would benefit immensely from some funding. Raising a monthly budget of... "dollars" would make the project more sustainable.

We welcome both individual and corporate sponsors! We also offer a wide array of funding channels to account for your preferences (although currently Open Collective is our preferred funding platform).

If you're working in a company that's making significant use of kettle-rb tools we'd appreciate it if you suggest to your company to become a kettle-rb sponsor.

You can support the development of kettle-rb tools via GitHub Sponsors, Liberapay, PayPal, Open Collective and Tidelift.

📍 NOTE
If doing a sponsorship in the form of donation is problematic for your company from an accounting standpoint, we'd recommend the use of Tidelift, where you can get a support-like subscription instead.

Open Collective for Individuals

Support us with a monthly donation and help us continue our activities. [Become a backer]

NOTE: kettle-readme-backers updates this list every day, automatically.

No backers yet. Be the first!

Open Collective for Organizations

Become a sponsor and get your logo on our README on GitHub with a link to your site. [Become a sponsor]

NOTE: kettle-readme-backers updates this list every day, automatically.

No sponsors yet. Be the first!

Another way to support open-source

I’m driven by a passion to foster a thriving open-source community – a space where people can tackle complex problems, no matter how small. Revitalizing libraries that have fallen into disrepair, and building new libraries focused on solving real-world challenges, are my passions. I was recently affected by layoffs, and the tech jobs market is unwelcoming. I’m reaching out here because your support would significantly aid my efforts to provide for my family, and my farm (11 🐔 chickens, 2 🐶 dogs, 3 🐰 rabbits, 8 🐈‍ cats).

If you work at a company that uses my work, please encourage them to support me as a corporate sponsor. My work on gems you use might show up in bundle fund.

I’m developing a new library, floss_funding, designed to empower open-source developers like myself to get paid for the work we do, in a sustainable way. Please give it a look.

Floss-Funding.dev: 👉️ No network calls. 👉️ No tracking. 👉️ No oversight. 👉️ Minimal crypto hashing. 💡 Easily disabled nags

🔐 Security

See SECURITY.md.

🤝 Contributing

If you need some ideas of where to help, you could work on adding more code coverage, or if it is already 💯 (see below) check reek, issues, or PRs, or use the gem and think about how it could be better.

We so if you make changes, remember to update it.

See CONTRIBUTING.md for more detailed instructions.

🚀 Release Instructions

See CONTRIBUTING.md.

Code Coverage

🪇 Code of Conduct

Everyone interacting with this project's codebases, issue trackers, chat rooms and mailing lists agrees to follow the .

🌈 Contributors

Made with contributors-img.

Also see GitLab Contributors: https://gitlab.com/kettle-rb/kettle-soup-cover/-/graphs/main

⭐️ Star History

📌 Versioning

This Library adheres to . Violations of this scheme should be reported as bugs. Specifically, if a minor or patch version is released that breaks backward compatibility, a new version should be immediately released that restores compatibility. Breaking changes to the public API will only be introduced with new major versions.

dropping support for a platform is both obviously and objectively a breaking change
—Jordan Harband (@ljharb, maintainer of SemVer) in SemVer issue 716

I understand that policy doesn't work universally ("exceptions to every rule!"), but it is the policy here. As such, in many cases it is good to specify a dependency on this library using the Pessimistic Version Constraint with two digits of precision.

For example:

spec.add_dependency("kettle-soup-cover", "~> 1.0")

📌 Is "Platform Support" part of the public API? More details inside.

SemVer should, IMO, but doesn't explicitly, say that dropping support for specific Platforms is a *breaking change* to an API, and for that reason the bike shedding is endless. To get a better understanding of how SemVer is intended to work over a project's lifetime, read this article from the creator of SemVer: - ["Major Version Numbers are Not Sacred"][📌major-versions-not-sacred]

See CHANGELOG.md for a list of releases.

📄 License

The gem is available as open source under the terms of the MIT License . See LICENSE.txt for the official Copyright Notice.

© Copyright

• Copyright (c) 2023 - 2025 Peter H. Boling, of Galtzo.com , and kettle-soup-cover contributors.

🤑 A request for help

Maintainers have teeth and need to pay their dentists. After getting laid off in an RIF in March, and encountering difficulty finding a new one, I began spending most of my time building open source tools. I'm hoping to be able to pay for my kids' health insurance this month, so if you value the work I am doing, I need your support. Please consider sponsoring me or the project.

To join the community or get help 👇️ Join the Discord.

To say "thanks!" ☝️ Join the Discord or 👇️ send money.

💌 💌 💌

Please give the project a star ⭐ ♥.

Thanks for RTFM. ☺️