kettle-dev 1.2.4 → 2.0.1

data/certs/pboling.pem

@@ -0,0 +1,27 @@
+-----BEGIN CERTIFICATE-----
+MIIEgDCCAuigAwIBAgIBATANBgkqhkiG9w0BAQsFADBDMRUwEwYDVQQDDAxwZXRl
+ci5ib2xpbmcxFTATBgoJkiaJk/IsZAEZFgVnbWFpbDETMBEGCgmSJomT8ixkARkW
+A2NvbTAeFw0yNTA1MDQxNTMzMDlaFw00NTA0MjkxNTMzMDlaMEMxFTATBgNVBAMM
+DHBldGVyLmJvbGluZzEVMBMGCgmSJomT8ixkARkWBWdtYWlsMRMwEQYKCZImiZPy
+LGQBGRYDY29tMIIBojANBgkqhkiG9w0BAQEFAAOCAY8AMIIBigKCAYEAruUoo0WA
+uoNuq6puKWYeRYiZekz/nsDeK5x/0IEirzcCEvaHr3Bmz7rjo1I6On3gGKmiZs61
+LRmQ3oxy77ydmkGTXBjruJB+pQEn7UfLSgQ0xa1/X3kdBZt6RmabFlBxnHkoaGY5
+mZuZ5+Z7walmv6sFD9ajhzj+oIgwWfnEHkXYTR8I6VLN7MRRKGMPoZ/yvOmxb2DN
+coEEHWKO9CvgYpW7asIihl/9GMpKiRkcYPm9dGQzZc6uTwom1COfW0+ZOFrDVBuV
+FMQRPswZcY4Wlq0uEBLPU7hxnCL9nKK6Y9IhdDcz1mY6HZ91WImNslOSI0S8hRpj
+yGOWxQIhBT3fqCBlRIqFQBudrnD9jSNpSGsFvbEijd5ns7Z9ZMehXkXDycpGAUj1
+to/5cuTWWw1JqUWrKJYoifnVhtE1o1DZ+LkPtWxHtz5kjDG/zR3MG0Ula0UOavlD
+qbnbcXPBnwXtTFeZ3C+yrWpE4pGnl3yGkZj9SMTlo9qnTMiPmuWKQDatAgMBAAGj
+fzB9MAkGA1UdEwQCMAAwCwYDVR0PBAQDAgSwMB0GA1UdDgQWBBQE8uWvNbPVNRXZ
+HlgPbc2PCzC4bjAhBgNVHREEGjAYgRZwZXRlci5ib2xpbmdAZ21haWwuY29tMCEG
+A1UdEgQaMBiBFnBldGVyLmJvbGluZ0BnbWFpbC5jb20wDQYJKoZIhvcNAQELBQAD
+ggGBAJbnUwfJQFPkBgH9cL7hoBfRtmWiCvdqdjeTmi04u8zVNCUox0A4gT982DE9
+wmuN12LpdajxZONqbXuzZvc+nb0StFwmFYZG6iDwaf4BPywm2e/Vmq0YG45vZXGR
+L8yMDSK1cQXjmA+ZBKOHKWavxP6Vp7lWvjAhz8RFwqF9GuNIdhv9NpnCAWcMZtpm
+GUPyIWw/Cw/2wZp74QzZj6Npx+LdXoLTF1HMSJXZ7/pkxLCsB8m4EFVdb/IrW/0k
+kNSfjtAfBHO8nLGuqQZVH9IBD1i9K6aSs7pT6TW8itXUIlkIUI2tg5YzW6OFfPzq
+QekSkX3lZfY+HTSp/o+YvKkqWLUV7PQ7xh1ZYDtocpaHwgxe/j3bBqHE+CUPH2vA
+0V/FwdTRWcwsjVoOJTrYcff8pBZ8r2MvtAc54xfnnhGFzeRHfcltobgFxkAXdE6p
+DVjBtqT23eugOqQ73umLcYDZkc36vnqGxUBSsXrzY9pzV5gGr2I8YUxMqf6ATrZt
+L9nRqA==
+-----END CERTIFICATE-----

data/exe/kettle-changelog

@@ -10,14 +10,14 @@
 #   - TAG
 #   - COVERAGE (line coverage)
 #   - BRANCH COVERAGE (branch coverage)
-#   - percent documented (parsed from `bin/yard` output)
+#   - percent documented (parsed from `bin/rake yard` output)
 # - Updates bottom link references to GitHub style, converts any existing
 #   GitLab links to GitHub links, and appends the new [X.Y.Z] and [X.Y.Zt] links.
 #
 # Notes:
-# - Expects a JSON coverage report at coverage/coverage.json. If missing,
-#   it will instruct you to run: K_SOUP_COV_FORMATTERS="json" bin/rspec
-# - Expects bin/yard to be available via Bundler.
+# - Expects a JSON coverage report at coverage/coverage.json. In strict mode,
+#   it will generate one with bundle exec kettle-test.
+# - Expects `bin/rake yard` to be available.
 
 $stdout.sync = true
 
@@ -50,27 +50,35 @@ end
 begin
   if ARGV.include?("-h") || ARGV.include?("--help")
     puts <<~USAGE
-      Usage: kettle-changelog [--no-strict]
+      Usage: kettle-changelog [--update-prep] [--no-strict] [--no-coverage-threshold]
 
-      Generates a new CHANGELOG.md entry for the current version detected from lib/**/version.rb.
-      Moves entries from [Unreleased] into the new section, adds coverage and documentation stats,
-      and updates bottom link references to GitHub style, adding new compare/tag links.
+      Detects the current version from lib/**/version.rb, the latest live release, and
+      the most recent CHANGELOG.md release section, then prompts to confirm the selected plan:
+      create a new release section, update the prepared release section in place, or reformat only.
+
+      Release plans add coverage and documentation stats, move entries from [Unreleased],
+      and update bottom link references to GitHub style.
 
       Options:
+        --update-prep             Force updating the most recent prepared release section in place
         --no-strict               Allow missing coverage and yard data (warnings only, no errors)
+        --no-coverage-threshold   Generate coverage without hard-failing below configured thresholds
 
       Environment:
-        K_CHANGELOG_STRICT=false  Disable strict mode (equivalent to --no-strict flag)
+        K_CHANGELOG_STRICT=false              Disable strict mode (equivalent to --no-strict flag)
+        K_CHANGELOG_COVERAGE_HARD=false       Disable coverage threshold hard-failure
 
       Prerequisites:
-        - coverage/coverage.json present (run: bin/rake coverage to generate)
-        - yard installed and available via bin/yard
+        - coverage/coverage.json present (run: bundle exec kettle-test with K_SOUP_COV_FORMATTERS=json to generate)
+        - yard task available via bin/rake yard
 
       By default (strict mode), if coverage.json or yard stats are missing, the script will:
-        1. Attempt to generate them by running bin/rake coverage and bin/rake yard
+        1. Attempt to generate them by running bundle exec kettle-test and bin/rake yard
         2. Fail with an error if generation fails or data is still unavailable
+        3. Fail if coverage is below the configured project thresholds
 
       Use --no-strict or K_CHANGELOG_STRICT=false to allow missing data (backward compatible behavior).
+      Use --no-coverage-threshold or K_CHANGELOG_COVERAGE_HARD=false to bypass coverage threshold failures.
     USAGE
     exit(0)
   end
@@ -79,8 +87,11 @@ end
 begin
   # Determine if strict mode is enabled (default: true)
   strict_mode = !ARGV.include?("--no-strict") && ENV.fetch("K_CHANGELOG_STRICT", "true").downcase != "false"
+  update_prep = ARGV.include?("--update-prep")
+  coverage_threshold_disabled = ARGV.include?("--no-coverage-threshold") || ARGV.include?("--no-coverage-thresholds")
+  coverage_hard = !coverage_threshold_disabled && ENV.fetch("K_CHANGELOG_COVERAGE_HARD", "true").downcase != "false"
 
-  Kettle::Dev::ChangelogCLI.new(strict: strict_mode).run
+  Kettle::Dev::ChangelogCLI.new(strict: strict_mode, enforce_coverage_thresholds: coverage_hard, update_prep: update_prep).run
 rescue LoadError => e
   warn("#{script_basename}: could not load dependency: #{e.class}: #{e.message}")
   warn(e.backtrace.join("\n")) if ENV["DEBUG"]

data/exe/kettle-check-eof

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+bin_dir = File.expand_path(__dir__)
+bash_script = File.join(bin_dir, "kettle-check-eof.sh")
+
+exec(bash_script, *ARGV)

data/exe/kettle-check-eof.sh

@@ -0,0 +1,118 @@
+#!/usr/bin/env bash
+
+# Finds files without exactly one trailing newline
+# Pass "-f" to also fix those files
+#
+# Always have exactly one newline at the end of every file comprised of text.
+# In a POSIX system a file missing a final newline is technically not a text file.
+# Some tools will not parse them, or parse them in unexpected ways.
+# NOTE: We'll forgive external files, in node_modules, and vendor.
+# See:
+#   Official POSIX Standard: https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap03.html#tag_03_206
+#   Discussion of "why newline at EOF?": https://stackoverflow.com/q/729692/213191
+#   Theory behind `-not \( -path ... \)`: https://stackoverflow.com/a/69830768/213191
+#   Thanks: Gabriel Staples, https://stackoverflow.com/users/4561887/gabriel-staples
+#
+# Author: Peter H Boling
+# Copyright (c) 2026 Peter H Boling. All rights reserved.
+# License MIT (see LICENSE file in repository root for details)
+
+set -euo pipefail
+
+FIX_MODE=false
+if [[ "${1:-}" == "-f" ]]; then
+    FIX_MODE=true
+fi
+
+# Function to check if file has exactly one trailing newline
+check_eof() {
+    local file="$1"
+    # Empty files are OK (nothing to fix)
+    [[ ! -s "$file" ]] && return 0
+
+    # Check last two bytes to detect:
+    # - Missing newline (last byte != newline)
+    # - Multiple trailing newlines (last two bytes == newline newline)
+    local last_bytes
+    last_bytes=$(tail -c 2 "$file" | od -An -tx1 | tr -d ' \n')
+
+    # 0a = newline in hex
+    case "$last_bytes" in
+        *0a0a) return 1 ;;  # Multiple trailing newlines
+        *0a)   return 0 ;;  # Exactly one trailing newline
+        *)     return 1 ;;  # Missing trailing newline
+    esac
+}
+
+# Function to fix file to have exactly one trailing newline
+fix_eof() {
+    local file="$1"
+    # Remove all trailing newlines, then add exactly one
+    # Using perl for portability (sed -i behaves differently on macOS vs Linux)
+    perl -pi -e 'chomp if eof' "$file"
+    echo >> "$file"
+}
+
+# Find all text files, excluding specified patterns
+invalid_files=()
+
+while IFS= read -r -d '' file; do
+    # Skip if not a text file
+    if ! file -b "$file" | grep -q text; then
+        continue
+    fi
+
+    if ! check_eof "$file"; then
+        invalid_files+=("$file")
+        if $FIX_MODE; then
+            fix_eof "$file"
+            echo "Fixed: $file"
+        else
+            echo "$file"
+        fi
+    fi
+done < <(find . \
+    -type f \
+    -not \( -name "*.csv" \) \
+    -not \( -name "*.dio" \) \
+    -not \( -name "*.gem" \) \
+    -not \( -name "*.json" \) \
+    -not \( -name "*.pem" \) \
+    -not \( -name "*.tpl" \) \
+    -not \( -name "VERSION*" \) \
+    -not \( -path "*/.bundle/*" -prune \) \
+    -not \( -path "*/.git/*" -prune \) \
+    -not \( -path "*/.idea/*" -prune \) \
+    -not \( -path "*/.vscode/*" -prune \) \
+    -not \( -path "*/.yardoc/*" -prune \) \
+    -not \( -path "*/angular/*" -prune \) \
+    -not \( -path "*/certs/*" -prune \) \
+    -not \( -path "*/checksums/*" -prune \) \
+    -not \( -path "*/coverage/*" -prune \) \
+    -not \( -path "*/doc/*" -prune \) \
+    -not \( -path "*/docs/*" -prune \) \
+    -not \( -path "*/log/*" -prune \) \
+    -not \( -path "*/node_modules/*" -prune \) \
+    -not \( -path "*/pkg/*" -prune \) \
+    -not \( -path "*/public/*" -prune \) \
+    -not \( -path "*/results/*" -prune \) \
+    -not \( -path "*/test-results/*" -prune \) \
+    -not \( -path "*/tmp/*" -prune \) \
+    -not \( -path "*/vendor/*" -prune \) \
+    -print0)
+
+# Exit with appropriate status
+if [[ ${#invalid_files[@]} -eq 0 ]]; then
+    exit 0
+else
+    if $FIX_MODE; then
+        echo ""
+        echo "Fixed ${#invalid_files[@]} file(s)"
+        exit 0
+    else
+        echo ""
+        echo "Found ${#invalid_files[@]} file(s) with invalid EOF"
+        echo "Run with -f to fix"
+        exit 1
+    fi
+fi

data/exe/kettle-dev-setup

@@ -3,66 +3,15 @@
 
 # vim: set syntax=ruby
 
-# kettle-dev-setup: initialize a target gem repo to use kettle-dev tooling.
-# This script is installed into PATH when the kettle-dev gem is installed.
-# It is designed to be run from inside the target gem's repository working
-# directory. It will not assume kettle-dev is already a dependency.
-
-require "fileutils"
-require "shellwords"
-require "open3"
-require "optparse"
-require "rubygems"
-
-# Ensure output is flushed promptly even if we exit early
-$stdout.sync = true
-$stderr.sync = true
-
-script_basename = File.basename(__FILE__)
-File.basename($PROGRAM_NAME)
-
-begin
-  require "kettle/dev"
-  puts "== #{script_basename} v#{Kettle::Dev::Version::VERSION} begin =="
-rescue StandardError => e
-  # Requiring kettle/dev should generally work since this script ships with the gem.
-  # But if autoloads try to pull optional deps, we should still proceed as most
-  # of this script does not rely on those parts.
-  warn("[kettle-dev-setup] Warning: could not fully load kettle/dev (#{e.class}: #{e.message}). Proceeding with limited features.")
-end
-
-# Always execute when this file is loaded (e.g., via a Bundler binstub).
-# Do not guard with __FILE__ == $PROGRAM_NAME because binstubs use Kernel.load.
-if ARGV.include?("-h") || ARGV.include?("--help")
-  puts <<~USAGE
-    Usage: kettle-dev-setup [options]
-
-    Bootstraps a host gem repository to use kettle-dev tooling.
-
-    Options (passed through to rake kettle:dev:install):
-      --allowed=VAL
-      --force
-      --hook_templates=VAL
-      --only=VAL
-      --include=VAL
-
-    Environment:
-      DEBUG=true                    # print backtraces on errors
-  USAGE
-  exit 0
-end
-
-begin
-  Kettle::Dev::SetupCLI.new(ARGV).run!
-rescue LoadError => e
-  warn("#{script_basename}: could not load dependency: #{e.class}: #{e.message}")
-  warn(e.backtrace.join("\n")) if ENV["DEBUG"]
-  exit(1)
-rescue SystemExit => e
-  warn("#{script_basename}: exited (status=#{e.status}, msg=#{e.message})") if e.status != 0
-  raise
-rescue StandardError => e
-  warn("#{script_basename}: unexpected error: #{e.class}: #{e.message}")
-  warn(e.backtrace.join("\n")) if ENV["DEBUG"]
-  exit(1)
-end
+# kettle-dev-setup has been replaced by kettle-jem-setup.
+# All setup and templating functionality has moved to the kettle-jem gem.
+
+$stderr.puts <<~MSG
+  kettle-dev-setup has been removed.
+  Setup and templating functionality has moved to the kettle-jem gem.
+
+  Please install kettle-jem and use kettle-jem-setup instead:
+    gem install kettle-jem
+    kettle-jem-setup
+MSG
+exit 1

data/exe/kettle-gh-release

@@ -0,0 +1,82 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# vim: set syntax=ruby
+
+# kettle-gh-release: Create a GitHub release for a gem version
+# - Extracted from kettle-release step 18
+# - Useful when the main release succeeded but GitHub release creation failed
+# - Requires GITHUB_TOKEN with repo:public_repo (classic) or contents:write scope
+
+# Immediate, unbuffered output
+$stdout.sync = true
+$stderr.sync = true
+
+# Do not rely on Bundler; allow running in repos that do not depend on kettle-dev
+# Ensure RubyGems is available for 'require' lookups
+begin
+  require "rubygems"
+rescue LoadError
+  # Older Rubies always have rubygems; continue anyway
+end
+
+script_basename = File.basename(__FILE__)
+
+begin
+  require "kettle/dev"
+  puts "== #{script_basename} v#{Kettle::Dev::Version::VERSION} =="
+rescue LoadError => e
+  warn("#{script_basename}: could not load dependency: #{e.class}: #{e.message}")
+  warn("Hint: Ensure the host project has kettle-dev as a dependency and run bundle install.")
+  exit(1)
+end
+
+# Always execute when this file is loaded (e.g., via a Bundler binstub).
+# Do not guard with __FILE__ == $PROGRAM_NAME because binstubs use Kernel.load.
+if ARGV.include?("-h") || ARGV.include?("--help")
+  puts <<~USAGE
+    Usage: #{script_basename} [version=<VERSION>]
+
+    Creates a GitHub release for a gem version.
+
+    This is step 18 of the kettle-release flow, extracted as a standalone script.
+    Useful when the main release to RubyGems succeeded but GitHub release creation
+    failed (e.g., due to token issues or network problems).
+
+    Arguments:
+      version=<VERSION>           # Explicit version (e.g., version=1.2.3)
+                                  # If omitted, auto-detects from lib/**/version.rb
+
+    Environment:
+      GITHUB_TOKEN / GH_TOKEN     # Required; needs repo:public_repo (classic) or contents:write scope
+      DEBUG=true                  # Print backtraces on errors
+
+    Examples:
+      #{script_basename}                    # auto-detect version, create release
+      #{script_basename} version=2.0.0      # create release for specific version
+      GITHUB_TOKEN=ghp_xxx #{script_basename}  # explicit token
+  USAGE
+  exit 0
+end
+
+# Parse version=<v> from ARGV
+version_arg = ARGV.find { |a| a.start_with?("version=") }
+explicit_version = version_arg ? version_arg.split("=", 2)[1].strip : nil
+
+begin
+  cli = Kettle::Dev::ReleaseCLI.new(start_step: 18)
+  version = explicit_version || cli.send(:detect_version)
+  cli.send(:maybe_create_github_release!, version)
+rescue LoadError => e
+  warn("#{script_basename}: could not load dependency: #{e.class}: #{e.message}")
+  warn(Array(e.backtrace).join("\n")) if ENV["DEBUG"]
+  exit(1)
+rescue SystemExit => e
+  # Preserve exit status, but ensure at least a newline so shells don't show an empty line only.
+  warn("#{script_basename}: exited (status=#{e.status}, msg=#{e.message})") if e.status != 0
+  raise
+rescue StandardError => e
+  warn("#{script_basename}: unexpected error: #{e.class}: #{e.message}")
+  warn(Array(e.backtrace).join("\n"))
+  exit(1)
+end