🍲 Kettle::Dev

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.

Run the one-time project bootstrapper:

kettle-dev-setup

This gem integrates tightly with kettle-test.

Add this to your spec/spec_helper.rb:

require "kettle/test/rspec"

Now you have many powerful development and testing tools at your disposal, all fully documented and tested.

If you need to top-up an old setup to get the latest goodies, just re-template:

bundle exec rake kettle:dev:install

Making sure to review the changes, and retain overwritten bits that matter.

Later, when ready to release:

bin/kettle-changelog
bin/kettle-release

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

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

• Script: exe/kettle-dvcs (install binstubs for convenience: bundle binstubs kettle-dev --path bin)
• Purpose: Normalize git remotes across GitHub, GitLab, and Codeberg, and create an all remote that pushes to all and fetches only from your chosen origin.
• Assumptions: org and repo names are identical across forges.

Usage:

kettle-dvcs [options] [ORG] [REPO]

Options:

• --origin [github|gitlab|codeberg] Which forge to use as origin (default: github)
• --protocol [ssh|https] URL style (default: ssh)
• --github-name NAME Remote name for GitHub when not origin (default: gh)
• --gitlab-name NAME Remote name for GitLab (default: gl)
• --codeberg-name NAME Remote name for Codeberg (default: cb)
• --force Non-interactive; accept defaults, and do not prompt for ORG/REPO

Examples:

• Default, interactive (infers ORG/REPO from an existing remote when possible):

  kettle-dvcs

• Non-interactive with explicit org/repo:

  kettle-dvcs --force my-org my-repo

• Use GitLab as origin and HTTPS URLs:

  kettle-dvcs --origin gitlab --protocol https my-org my-repo

What it does:

• Ensures remotes exist and have consistent URLs for each forge.
• Renames existing remotes when their URL already matches the desired target but their name does not (e.g., gitlab -> gl).
• Creates/refreshes an all remote that:
  • fetches only from your chosen origin forge.
  • has pushurls configured for all three forges so git push all <branch> updates all mirrors.
• Prints git remote -v at the end.
• Attempts to git fetch each forge remote to check availability:
  • If all succeed, the README’s federated DVCS summary line has “(Coming soon!)” removed.
  • If any fail, the script prints import links to help you create a mirror on that forge.

Federated DVCS Repository	Status	Issues	PRs	Wiki	CI	Discussions
🧪 kettle-rb/kettle-dev on GitLab	The Truth	💚	💚	💚	🏀 Tiny Matrix	➖
🧊 kettle-rb/kettle-dev on CodeBerg	An Ethical Mirror (Donate)	💚	💚	➖	⭕️ No Matrix	➖
🐙 kettle-rb/kettle-dev on GitHub	Another Mirror	💚	💚	➖	💯 Full Matrix	💚
🎮️ Discord Server		Let's	talk	about	this	library!

Available as part of the Tidelift Subscription.

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.

• 💡Subscribe for support guarantees covering all your FLOSS dependencies
• 💡Tidelift is part of Sonar
• 💡Tidelift pays maintainers to maintain the software you depend on!
  📊@Pointy Haired Boss: An enterprise support subscription is "never gonna let you down", and supports open source maintainers

Alternatively:

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

bundle add kettle-dev

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

gem install kettle-dev

This gem is cryptographically signed, and has verifiable SHA-256 and SHA-512 checksums by 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:

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:

gem install kettle-dev -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:

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.

Note on executables vs Rake tasks

• Executable scripts provided by this gem (exe/* and installed binstubs) work when the gem is installed as a system gem (gem install kettle-dev). They do not require the gem to be in your bundle to run.
• The Rake tasks provided by this gem require kettle-dev to be declared as a development dependency in your Gemfile and loaded in your project's Rakefile. Ensure your Gemfile includes:

  group :development do
    gem "kettle-dev", require: false
  end

  And your Rakefile loads the gem's tasks, e.g.:

  require "kettle/dev"

This gem integrates tightly with kettle-test.

require "kettle/test/rspec"

Add to your Rakefile:

require "kettle/dev"

Then run the one-time project bootstrapper:

kettle-dev-setup
# Or to accept all defaults:
kettle-dev-setup --allowed=true --force

You'll be able to compare the changes with your diff tool, and certainly revert some of them.

For your protection:

• it won't run if git doesn't start out porcelain clean.

After bootstrapping, to update the template to the latest version from a new release of this gem, run:

bundle exec rake kettle:dev:install

If git status is not clean it will abort. It may have some prompts, which can mostly be avoided by running with options:

# DANGER: options to reduce prompts will overwrite files without asking.
bundle exec rake kettle:dev:install allowed=true force=true

Hopefully, all the files that get overwritten are tracked in git! I wrote this for myself, and it fits my patterns of development.

The install task will write a report at the end with:

1. A file list summary of the changes made.
2. Next steps for using the tools.
3. A warning about .env.local (DO NOT COMMIT IT, as it will likely have secrets added)

That’s it. Once installed, kettle-dev:

• Registers RuboCop-LTS tasks and wires your default Rake task to run the gradual linter.
  • Locally: default task prefers rubocop_gradual:autocorrect.
  • On CI (CI=true): default task prefers rubocop_gradual:check.
• Integrates optional coverage tasks via kettle-soup-cover (enabled locally when present).
• Adds gem-shipped Rake tasks from lib/kettle/dev/rakelib, including:
  • ci:act — interactive selector for running GitHub Actions workflows via act.
  • kettle:dev:install — copies this repo’s .github automation, offers to install .git-hooks templates, and overwrites many files in your project.
    • Grapheme syncing: detects the grapheme (e.g., emoji) immediately following the first # H1 in README.md and ensures the same grapheme, followed by a single space, prefixes both spec.summary and spec.description in your gemspec. If the H1 has none, you’ll be prompted to enter one; tests use an input adapter, so runs never hang in CI.
    • option: force: When truthy (1, true, y, yes), treat all y/N prompts as Yes. Useful for non-interactive runs or to accept defaults quickly. Example: bundle exec rake kettle:dev:template force=true
    • option: allowed: When truthy (1, true, y, yes), resume task after you have reviewed .envrc/.env.local and run direnv allow. If either file is created or updated, the task will abort with instructions unless allowed=true is present. Example: bundle exec rake kettle:dev:install allowed=true
    • option: only: A comma-separated list of glob patterns to include in templating. Any destination file whose path+filename does not match one of the patterns is excluded. Patterns are matched relative to your project root. Examples: only="README.md,.github/**", only="docs/**,lib/**/*.rb".
  • kettle:dev:template — templates files from this gem into your project (e.g., .github workflows, .devcontainer, .qlty, modular Gemfiles, README/CONTRIBUTING stubs). You can run this independently to refresh templates without the extra install prompts.
    • option: force: When truthy (1, true, y, yes), treat all y/N prompts as Yes. Useful for non-interactive runs or to accept defaults quickly. Example: bundle exec rake kettle:dev:template force=true
    • option: allowed: When truthy (1, true, y, yes), resume task after you have reviewed .envrc/.env.local and run direnv allow. If either file is created or updated, the task will abort with instructions unless allowed=true is present. Example: bundle exec rake kettle:dev:template allowed=true
    • option: only: Same as for install; limits which destination files are written based on glob patterns relative to the project root.

Recommended one-time setup in your project:

• Install binstubs so kettle-dev executables are available under ./bin:
  • bundle binstubs kettle-dev --path bin
• Use direnv (recommended) so ./bin is on PATH automatically:
  • brew install direnv
  • In your project’s .envrc add:
    • # Run any command in this library's bin/ without the bin/ prefix!
    • PATH_add bin
• Configure shared git hooks path (optional, recommended):
  • git config --global core.hooksPath .git-hooks
• Install project automation and sample hooks/templates:
  • bundle exec rake kettle:dev:install and follow prompts (copies .github and installs .git-hooks templates locally or globally).

See the next section for environment variables that tweak behavior.

Below are the primary environment variables recognized by kettle-dev (and its integrated tools). Unless otherwise noted, set boolean values to the string "true" to enable.

General/runtime

• DEBUG: Enable extra internal logging for this library (default: false)
• REQUIRE_BENCH: Enable require_bench to profile requires (default: false)
• CI: When set to true, adjusts default rake tasks toward CI behavior

Coverage (kettle-soup-cover / SimpleCov)

• K_SOUP_COV_DO: Enable coverage collection (default: true in .envrc)
• K_SOUP_COV_FORMATTERS: Comma-separated list of formatters (html, xml, rcov, lcov, json, tty)
• K_SOUP_COV_MIN_LINE: Minimum line coverage threshold (integer, e.g., 100)
• K_SOUP_COV_MIN_BRANCH: Minimum branch coverage threshold (integer, e.g., 100)
• K_SOUP_COV_MIN_HARD: Fail the run if thresholds are not met (true/false)
• K_SOUP_COV_MULTI_FORMATTERS: Enable multiple formatters at once (true/false)
• K_SOUP_COV_OPEN_BIN: Path to browser opener for HTML (empty disables auto-open)
• MAX_ROWS: Limit console output rows for simplecov-console (e.g., 1) Tip: When running a single spec file locally, you may want K_SOUP_COV_MIN_HARD=false to avoid failing thresholds for a partial run.

GitHub API and CI helpers

• GITHUB_TOKEN or GH_TOKEN: Token used by ci:act and release workflow checks to query GitHub Actions status at higher rate limits
• GITLAB_TOKEN or GL_TOKEN: Token used by ci:act and CI monitor to query GitLab pipeline status

Releasing and signing

• SKIP_GEM_SIGNING: If set, skip gem signing during build/release
• GEM_CERT_USER: Username for selecting your public cert in certs/<USER>.pem (defaults to $USER)
• SOURCE_DATE_EPOCH: Reproducible build timestamp. kettle-release will set this automatically for the session.

Git hooks and commit message helpers (exe/kettle-commit-msg)

• GIT_HOOK_BRANCH_VALIDATE: Branch name validation mode (e.g., jira) or false to disable
• GIT_HOOK_FOOTER_APPEND: Append a footer to commit messages when goalie allows (true/false)
• GIT_HOOK_FOOTER_SENTINEL: Required when footer append is enabled — a unique first-line sentinel to prevent duplicates
• GIT_HOOK_FOOTER_APPEND_DEBUG: Extra debug output in the footer template (true/false)

For a quick starting point, this repository’s .envrc shows sane defaults, and .env.local can override them locally.

Common flows

• Default quality workflow (locally):
  • bundle exec rake — runs the curated default task set (gradual RuboCop autocorrect, coverage if available, and other local tasks). On CI CI=true, the default task is adjusted to be CI-friendly.
• Run specs:
  • bin/rspec or bundle exec rspec
  • To run a subset without failing coverage thresholds: K_SOUP_COV_MIN_HARD=false bin/rspec spec/path/to/file_spec.rb
  • To produce multiple coverage reports: K_SOUP_COV_FORMATTERS="html,xml,rcov,lcov,json,tty" bin/rspec
• Linting (Gradual):
  • bundle exec rake rubocop_gradual:autocorrect
  • bundle exec rake rubocop_gradual:check (CI-friendly)
• Reek and docs:
  • bundle exec rake reek or bundle exec rake reek:update
  • bundle exec rake yard

GitHub Actions local runner helper

• bundle exec rake ci:act — interactive menu shows workflows from .github/workflows with live status and short codes (first 3 letters of file name). Type a number or short code.
• Non-interactive: bundle exec rake ci:act[loc] (short code), or bundle exec rake ci:act[locked_deps.yml] (filename).

Setup tokens for API status (GitHub and GitLab)

• Purpose: ci:act displays the latest status for GitHub Actions runs and (when applicable) the latest GitLab pipeline for the current branch. Unauthenticated requests are rate-limited; private repositories require tokens. Provide tokens to get reliable status.
• GitHub token (recommended: fine-grained):
  • Where to create: https://github.com/settings/personal-access-tokens
    • Fine-grained: “Tokens (fine-grained)” → Generate new token
    • Classic (fallback): “Tokens (classic)” → Generate new token
  • Minimum permissions:
    • Fine-grained: Repository access: Read-only for the target repository (or your org); Permissions → Actions: Read
    • Classic: For public repos, no scopes are strictly required but rate limits are very low; for private repos, include the repo scope
  • Add to environment (.env.local via direnv):
    • GITHUB_TOKEN=your_token_here (or GH_TOKEN=…)
• GitLab token:
  • Where to create (gitlab.com): https://gitlab.com/-/user_settings/personal_access_tokens
  • Minimum scope: read_api (sufficient to read pipelines)
  • Add to environment (.env.local via direnv):
    • GITLAB_TOKEN=your_token_here (or GL_TOKEN=…)
• Load environment:
  • Save tokens in .env.local (never commit this file), then run: direnv allow
• Verify:
  • Run: bundle exec rake ci:act
  • The header will include Repo/Upstream/HEAD; entries will show “Latest GHA …” and “Latest GL … pipeline” with emoji status. On failure to authenticate or rate-limit, you’ll see a brief error/result code.

Project automation bootstrap

• bundle exec rake kettle:dev:install — copies the library’s .github folder into your project and offers to install .git-hooks templates locally or globally.
• bundle exec rake kettle:dev:template — runs only the templating step used by install; useful to re-apply updates to templates (.github workflows, .devcontainer, .qlty, modular Gemfiles, README, and friends) without the install task’s extra prompts.
  • Also copies maintainer certificate certs/pboling.pem into your project when present (used for signed gem builds).
  • README carry-over during templating: when your project’s README.md is replaced by the template, selected sections from your existing README are preserved and merged into the new one. Specifically, the task carries over the following sections (matched case-insensitively):
    • "Synopsis"
    • "Configuration"
    • "Basic Usage"
    • Any section whose heading starts with "Note:" at any heading level (for example: "# NOTE: …", "## Note: …", or "### note: …").
    • Headings are recognized at any level using Markdown hashes (#, ##, ###, …).
• Notes about task options:
  • Non-interactive confirmations: append force=true to accept all y/N prompts as Yes, e.g., bundle exec rake kettle:dev:template force=true.
  • direnv review flow: if .envrc or .env.local is created or updated, the task stops and asks you to run direnv allow. After you review and allow, resume with allowed=true:
    • bundle exec rake kettle:dev:template allowed=true
    • bundle exec rake kettle:dev:install allowed=true
• After that, set up binstubs and direnv for convenience:
  • bundle binstubs kettle-dev --path bin
  • Add to .envrc: PATH_add bin (so bin/ tools run without the prefix)

• The templating step dynamically prefers any *.example file present in this gem’s templates. When a *.example exists alongside the non-example template, the .example content is used, and the destination file is written without the .example suffix.
• This applies across all templated files, including:
  • Root files like .gitlab-ci.yml (copied from .gitlab-ci.yml.example when present).
  • Nested files like .github/workflows/coverage.yml (copied from .github/workflows/coverage.yml.example when present).
• This behavior is automatic for any future *.example files added to the templates.
• Exception: .env.local is handled specially for safety. Regardless of whether the template provides .env.local or .env.local.example, the installer copies it to .env.local.example in your project, and will never create or overwrite .env.local.

• Script: exe/kettle-release (run as kettle-release)
• Purpose: guided release helper that:
  • Runs sanity checks (bin/setup, bin/rake), confirms version/changelog, optionally updates Appraisals, commits “🔖 Prepare release vX.Y.Z”.
  • Optionally runs your CI locally with act before any push:
    • Enable with env: K_RELEASE_LOCAL_CI="true" (run automatically) or K_RELEASE_LOCAL_CI="ask" (prompt [Y/n]).
    • Select workflow with K_RELEASE_LOCAL_CI_WORKFLOW (with or without .yml/.yaml). Defaults to locked_deps.yml if present; otherwise the first workflow discovered.
    • On failure, the release prep commit is soft-rolled-back (git reset --soft HEAD^) and the process aborts.
  • Ensures trunk sync and rebases feature as needed, pushes, monitors GitHub Actions with a progress bar, and merges feature to trunk on success.
  • Exports SOURCE_DATE_EPOCH, builds (optionally signed), creates gem checksums, and runs bundle exec rake release (prompts for signing key + RubyGems MFA OTP as needed).
• Options:
  • start_step map (skip directly to a phase):
    • 1: Ensure Bundler >= 2.7.0 and begin full flow
    • 2: Version detection + sanity checks + prompt to confirm version.rb and CHANGELOG.md
    • 3: Run bin/setup
    • 4: Run bin/rake (default task)
    • 5: Run appraisal:update when Appraisals exists (skip otherwise)
    • 6: Verify git user.name/email and commit release prep "🔖 Prepare release vX.Y.Z"
    • 7: Optionally run local CI with nektos/act before pushing (see K_RELEASE_LOCAL_CI, K_RELEASE_LOCAL_CI_WORKFLOW)
    • 8: Ensure trunk is up-to-date and reconcile with GitHub remote if needed
    • 9: Push current branch to configured remotes (or default), force-pushing on retry when needed
    • 10: Monitor CI after push (GitHub Actions and/or GitLab pipelines); progress bar; aborts on failure
    • 11: Merge feature branch into trunk and push
    • 12: Checkout trunk and pull latest
    • 13: Signing checks and guidance (abort when signing enabled but cert missing); respect SKIP_GEM_SIGNING
    • 14: Build gem (honors SKIP_GEM_SIGNING via env prefix)
    • 15: Generate and validate gem checksums (bin/gem_checksums)
    • 16: Release via bundle exec rake release and validate checksums again
    • 17: Create GitHub release from CHANGELOG when GITHUB_TOKEN present
    • 18: Push git tags to remotes (to "all" remote only when present; otherwise to each remote)
• Examples:
  • After intermittent CI failure, restart from monitoring: bundle exec kettle-release start_step=10
• Tips:
  • The commit message helper exe/kettle-commit-msg prefers project-local .git-hooks (then falls back to ~/.git-hooks).
  • The goalie file commit-subjects-goalie.txt controls when a footer is appended; customize footer-template.erb.txt as you like.

• Script: exe/kettle-changelog (run as kettle-changelog)
• Purpose: Generates a new CHANGELOG.md section for the current version read from lib/**/version.rb, moves notes from the Unreleased section, and updates comparison links.
• Prerequisites:
  • coverage/coverage.json present (generate with: K_SOUP_COV_FORMATTERS="json" bin/rspec).
  • bin/yard available (Bundler-installed), to compute documentation coverage.
• Usage:
  • kettle-changelog
• Behavior:
  • Reads version from the unique lib/**/version.rb in the project.
  • Moves entries from the [Unreleased] section into a new [#.#.#] - YYYY-MM-DD section.
  • Prepends 4 lines with TAG, line coverage, branch coverage, and percent documented.
  • Converts any GitLab-style compare links at the bottom to GitHub style, adds new tag/compare links for the new release and a temporary tag reference [X.Y.Zt].

• Script: exe/kettle-pre-release (run as kettle-pre-release)
• Purpose: Run a suite of pre-release validations to catch avoidable mistakes (resumable by check number).
• Usage:
  • kettle-pre-release [--check-num N]
  • Short option: kettle-pre-release -cN
• Options:
  • --check-num N Start from check number N (default: 1)
• Checks:
  • 1. Validate that all image URLs referenced by Markdown files resolve (HTTP HEAD)

• Script: exe/kettle-commit-msg (run by git as .git/hooks/commit-msg)
• Purpose: Append a standardized footer and optionally enforce branch naming rules when configured.
• Usage:
  • Git invokes this with the path to the commit message file: kettle-commit-msg .git/COMMIT_EDITMSG
  • Install via bundle exec rake kettle:dev:install to copy hook templates into .git-hooks and wire them up.
• Behavior:
  • When GIT_HOOK_BRANCH_VALIDATE=jira, validates the current branch matches the pattern: ^(hotfix|bug|feature|candy)/[0-9]{8,}-….
    • If it matches and the commit message lacks the numeric ID, appends [<type>][<id>].
  • Always invokes Kettle::Dev::GitCommitFooter.render to potentially append a footer if allowed by the goalie.
  • Prefers project-local .git-hooks templates; falls back to ~/.git-hooks.
• Environment:
  • GIT_HOOK_BRANCH_VALIDATE Branch rule (e.g., jira) or false to disable.
  • GIT_HOOK_FOOTER_APPEND Enable footer auto-append when goalie allows (true/false).
  • GIT_HOOK_FOOTER_SENTINEL Required marker to avoid duplicate appends when enabled.
  • GIT_HOOK_FOOTER_APPEND_DEBUG Extra debug output in the footer template (true/false).

• Script: exe/kettle-dev-setup (run as kettle-dev-setup)
• Purpose: Bootstrap a host gem repository to use kettle-dev’s tooling without manual steps.
• Usage:
  • kettle-dev-setup [options] [passthrough args]
• Options (mapped through to rake kettle:dev:install):
  • --allowed=VAL Pass allowed=VAL to acknowledge prior direnv allow, etc.
  • --force Pass force=true to accept prompts non-interactively.
  • --hook_templates=VAL Pass hook_templates=VAL to control git hook templating.
  • --only=VAL Pass only=VAL to restrict install scope.
  • -h, --help Show help.
• Behavior:
  • Verifies a clean git working tree, presence of a Gemfile and a gemspec.
  • Syncs development dependencies from this gem’s example gemspec into the target gemspec (replacing or inserting add_development_dependency lines as needed).
  • Ensures bin/setup exists (copies from gem if missing) and replaces/creates the project’s Rakefile from Rakefile.example.
  • Runs bin/setup, then bundle exec bundle binstubs --all.
  • Stages and commits any bootstrap changes with message: 🎨 Template bootstrap by kettle-dev-setup v<version>.
  • Executes bin/rake kettle:dev:install with the parsed passthrough args.

• Script: exe/kettle-readme-backers (run as kettle-readme-backers)
• Purpose: Updates README sections for Open Collective backers (individuals) and sponsors (organizations) by fetching live data from your collective.
• Tags updated in README.md (first match wins for backers):
  • The default tag prefix is OPENCOLLECTIVE, and it is configurable:
    • ENV: KETTLE_DEV_BACKER_README_OSC_TAG="OPENCOLLECTIVE"
    • YAML (.opencollective.yml): readme-osc-tag: "OPENCOLLECTIVE"
    • The resulting markers become: <!-- <TAG>:START --> … <!-- <TAG>:END -->, <!-- <TAG>-INDIVIDUALS:START --> … <!-- <TAG>-INDIVIDUALS:END -->, and <!-- <TAG>-ORGANIZATIONS:START --> … <!-- <TAG>-ORGANIZATIONS:END -->.
    • ENV overrides YAML.
  • Backers (Individuals): <!-- <TAG>:START --> … <!-- <TAG>:END --> or <!-- <TAG>-INDIVIDUALS:START --> … <!-- <TAG>-INDIVIDUALS:END -->
  • Sponsors (Organizations): <!-- <TAG>-ORGANIZATIONS:START --> … <!-- <TAG>-ORGANIZATIONS:END -->
• Handle resolution:
  1. OPENCOLLECTIVE_HANDLE environment variable, if set
  2. opencollective.yml in the project root (e.g., collective: "kettle-rb" in this repo)
• Usage:
  • exe/kettle-readme-backers
  • OPENCOLLECTIVE_HANDLE=my-collective exe/kettle-readme-backers
• Behavior:
  • Writes to README.md only if content between the tags would change.
  • If neither the backers nor sponsors tags are present, prints a helpful warning and exits with status 2.
  • When there are no entries, inserts a friendly placeholder: "No backers yet. Be the first!" or "No sponsors yet. Be the first!".
  • When updates are written and the repository is a git work tree, the script stages README.md and commits with a message thanking new backers and subscribers, including mentions for any newly added backers and subscribers (GitHub @handles when their website/profile is a github.com URL; otherwise their name).
  • Customize the commit subject via env var: KETTLE_README_BACKERS_COMMIT_SUBJECT="💸 Thanks 🙏 to our new backers 🎒 and subscribers 📜".
    • Or via .opencollective.yml: set readme-backers-commit-subject: "💸 Thanks 🙏 to our new backers 🎒 and subscribers 📜".
    • Precedence: ENV overrides .opencollective.yml; if neither is set, a sensible default is used.
    • Note: When used with the provided .git-hooks, the subject should start with a gitmoji character (see gitmoji).
• Tip:
  • Run this locally before committing to keep your README current, or schedule it in CI to refresh periodically.
  • It runs automatically on a once-a-week schedule by the .github/workflows/opencollective.yml workflow that is part of the kettle-dev template.

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.

No backers yet. Be the first!

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

No sponsors yet. Be the first!

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

How wonderful it is that nobody need wait a single moment before starting to improve the world.
—Anne Frank

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 — totaling 79 hours of FLOSS coding over just the past seven days, a pretty regular week for me. 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

See SECURITY.md.

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.

See CONTRIBUTING.md.

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

Made with contributors-img.

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

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-dev", "~> 1.0")

SemVer should, IMO, but doesn't explicitly, say that dropping support for specific Platforms is a breaking change to an API. It is obvious to many, but not all, and since the spec is silent, 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"

See CHANGELOG.md for a list of releases.

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

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

Maintainers have teeth and need to pay their dentists. After getting laid off in an RIF in March and filled with many dozens of rejections, I'm now spending ~60+ hours a week 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.

💌 💌 💌

Thanks for RTFM. ☺️