kettle-dev 2.2.18 → 2.2.19

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9f361805b0355ac14c6b5a3f5d2555feb722b8c640a2550f46d2a8f7ab0c80c6
-  data.tar.gz: a39ee59b4404715e976240bca10e818f9b2b85e88575bac566ba02cd1116c4c9
+  metadata.gz: 309dfdff5a98f7d5d2f189a3b51a4d0f231d037b61ea37023918a70ec436d997
+  data.tar.gz: 9dff167d60de601c34738beb35c81df5e3c1a8874630ccaebf753507fa205a41
 SHA512:
-  metadata.gz: af5802350e819dcf37618a8cc3eac5c1ee98ad1e8f14f3e724ac1083875746139565ee34ccd697d6dd5c8950d2bf17e58b4b98416014a190cde2e62bd316df09
-  data.tar.gz: 7407dd36a674f8271b645e2bb97c3b84a15461cd14010e870f1036a53ebfb8ba00d959a341694c43ae1d8cf884d97d1a758815080f90fc4e65aebc46579668a2
+  metadata.gz: baf9a43aeac7238588295facc22c7a151c68abeed3b754872d539bc25571ea43e87eaac9ffb81ea4f5133206d1e9f1d0ef7d2fc609b666fa0bfad54df27069d0
+  data.tar.gz: 6f607059c8cd545bad791de6277f40f0b75d956fbc7654677cdcfb53345c2b658e98881e80f694992041e872e96b4e643d69f61a578ca305821fe449fe6c21ae

data/CHANGELOG.md

@@ -30,6 +30,20 @@ Please file a bug if you notice a violation of semantic versioning.
 
 ### Security
 
+## [2.2.19] - 2026-06-26
+
+- TAG: [v2.2.19][2.2.19t]
+- COVERAGE: 91.75% -- 4082/4449 lines in 33 files
+- BRANCH COVERAGE: 72.94% -- 1615/2214 branches in 33 files
+- 61.84% documented
+
+### Changed
+
+- `kettle-release` now runs `bin/rake appraisal:generate` by default when
+  `Appraisals` is present; use `--appraisal-update` or
+  `KETTLE_RELEASE_APPRAISAL_TASK=appraisal:update` for the slower lock-resolving
+  update path.
+
 ## [2.2.18] - 2026-06-24
 
 - TAG: [v2.2.18][2.2.18t]
@@ -2279,7 +2293,9 @@ Please file a bug if you notice a violation of semantic versioning.
   - Selecting will run the selected workflow via `act`
   - This may move to its own gem in the future.
 
-[Unreleased]: https://github.com/kettle-dev/kettle-dev/compare/v2.2.18...HEAD
+[Unreleased]: https://github.com/kettle-dev/kettle-dev/compare/v2.2.19...HEAD
+[2.2.19]: https://github.com/kettle-dev/kettle-dev/compare/v2.2.18...v2.2.19
+[2.2.19t]: https://github.com/kettle-dev/kettle-dev/releases/tag/v2.2.19
 [2.2.18]: https://github.com/kettle-dev/kettle-dev/compare/v2.2.17...v2.2.18
 [2.2.18t]: https://github.com/kettle-dev/kettle-dev/releases/tag/v2.2.18
 [2.2.17]: https://github.com/kettle-dev/kettle-dev/compare/v2.2.16...v2.2.17

data/CONTRIBUTING.md

@@ -131,9 +131,12 @@ toolchain, and it may be higher than the gemspec runtime floor.
 They are created and updated with the commands:
 
 ```console
-bin/rake appraisal:update
+bin/rake appraisal:generate
 ```
 
+Use `bin/rake appraisal:update` when you intentionally need to resolve fresh
+appraisal locks.
+
 If you need to reset all gemfiles/*.gemfile.lock files:
 
 ```console

data/README.md

@@ -874,7 +874,7 @@ Thanks for RTFM. ☺️
 [📌gitmoji]: https://gitmoji.dev
 [📌gitmoji-img]: https://img.shields.io/badge/gitmoji_commits-%20%F0%9F%98%9C%20%F0%9F%98%8D-34495e.svg?style=flat-square
 [🧮kloc]: https://www.youtube.com/watch?v=dQw4w9WgXcQ
-[🧮kloc-img]: https://img.shields.io/badge/KLOC-4.446-FFDD67.svg?style=for-the-badge&logo=YouTube&logoColor=blue
+[🧮kloc-img]: https://img.shields.io/badge/KLOC-4.449-FFDD67.svg?style=for-the-badge&logo=YouTube&logoColor=blue
 [🔐security]: https://github.com/kettle-dev/kettle-dev/blob/main/SECURITY.md
 [🔐security-img]: https://img.shields.io/badge/security-policy-259D6C.svg?style=flat
 [📄copyright-notice-explainer]: https://opensource.stackexchange.com/questions/5778/why-do-licenses-such-as-the-mit-license-specify-a-single-year

data/exe/kettle-changelog

@@ -52,59 +52,57 @@ rescue LoadError => e
   exit(1)
 end
 
-begin
-  if ARGV.include?("-h") || ARGV.include?("--help")
-    puts <<~USAGE
-      Usage: kettle-changelog [--version VERSION] [--update-prep] [--pending-release] [--release-state] [--add-unreleased-entry --section SECTION --entry TEXT] [--json] [--no-strict] [--no-coverage-threshold]
-
-      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:
-        --version VERSION         Use this version instead of detecting VERSION from lib/**/version.rb
-        --update-prep             Force updating the most recent prepared release section in place
-        --pending-release         Query whether the changelog has release work pending; exits 0 for yes, 1 for no
-        --release-state,
-        --release-status          Print changelog release state, including latest published release and pending sources
-        --add-unreleased-entry    Add one entry to an existing section under ## [Unreleased]
-        --section SECTION         Unreleased section to receive the entry (Added, Changed, Deprecated, Removed, Fixed, Security)
-        --entry TEXT              Changelog entry text; "- " is added when omitted
-        --json                    Print query output as JSON
-        --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_COVERAGE_HARD=false       Disable coverage threshold hard-failure
-        K_CHANGELOG_VERSION_FILE=path         Read VERSION from this file instead of lib/**/version.rb
-
-      Data generation:
-        Strict mode is the default. Release plans remove stale coverage output,
-        run bundle exec kettle-test with JSON coverage enabled, read the resulting
-        coverage/coverage.json, and collect documentation stats from bin/rake yard
-        or bin/yard.
-
-        Strict mode fails if specs fail, coverage JSON is not produced, coverage
-        is below the configured project thresholds, or documentation stats cannot
-        be collected.
-
-        Non-strict mode does not generate missing coverage or documentation data;
-        it warns and leaves unavailable stats blank.
-
-      Runtime requirements:
-        - bundle exec kettle-test available for strict coverage generation
-        - bin/rake yard or bin/yard available for strict documentation stats
-
-      Use --no-strict or K_CHANGELOG_STRICT=false to allow missing data.
-      Use --no-coverage-threshold or K_CHANGELOG_COVERAGE_HARD=false to run fresh
-      coverage without hard-failing below configured thresholds.
-    USAGE
-    exit(0)
-  end
+if ARGV.include?("-h") || ARGV.include?("--help")
+  puts <<~USAGE
+    Usage: kettle-changelog [--version VERSION] [--update-prep] [--pending-release] [--release-state] [--add-unreleased-entry --section SECTION --entry TEXT] [--json] [--no-strict] [--no-coverage-threshold]
+
+    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:
+      --version VERSION         Use this version instead of detecting VERSION from lib/**/version.rb
+      --update-prep             Force updating the most recent prepared release section in place
+      --pending-release         Query whether the changelog has release work pending; exits 0 for yes, 1 for no
+      --release-state,
+      --release-status          Print changelog release state, including latest published release and pending sources
+      --add-unreleased-entry    Add one entry to an existing section under ## [Unreleased]
+      --section SECTION         Unreleased section to receive the entry (Added, Changed, Deprecated, Removed, Fixed, Security)
+      --entry TEXT              Changelog entry text; "- " is added when omitted
+      --json                    Print query output as JSON
+      --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_COVERAGE_HARD=false       Disable coverage threshold hard-failure
+      K_CHANGELOG_VERSION_FILE=path         Read VERSION from this file instead of lib/**/version.rb
+
+    Data generation:
+      Strict mode is the default. Release plans remove stale coverage output,
+      run bundle exec kettle-test with JSON coverage enabled, read the resulting
+      coverage/coverage.json, and collect documentation stats from bin/rake yard
+      or bin/yard.
+
+      Strict mode fails if specs fail, coverage JSON is not produced, coverage
+      is below the configured project thresholds, or documentation stats cannot
+      be collected.
+
+      Non-strict mode does not generate missing coverage or documentation data;
+      it warns and leaves unavailable stats blank.
+
+    Runtime requirements:
+      - bundle exec kettle-test available for strict coverage generation
+      - bin/rake yard or bin/yard available for strict documentation stats
+
+    Use --no-strict or K_CHANGELOG_STRICT=false to allow missing data.
+    Use --no-coverage-threshold or K_CHANGELOG_COVERAGE_HARD=false to run fresh
+    coverage without hard-failing below configured thresholds.
+  USAGE
+  exit(0)
 end
 
 begin

data/exe/kettle-release

@@ -43,7 +43,7 @@ end
 # Do not guard with __FILE__ == $PROGRAM_NAME because binstubs use Kernel.load.
 if ARGV.include?("-h") || ARGV.include?("--help")
   puts <<~USAGE
-    Usage: kettle-release [--version VERSION] [--local-ci] [start_step=<0-19>]
+    Usage: kettle-release [--version VERSION] [--local-ci] [--appraisal-update] [start_step=<0-19>]
 
     Automates the release flow for a Ruby gem in the host project.
 
@@ -58,7 +58,7 @@ if ARGV.include?("-h") || ARGV.include?("--help")
       2. Detect version; RubyGems sanity check; confirm CHANGELOG/version; sync copyright years; update badges/headers
       3. Run bin/setup
       4. Run bin/rake (default task)
-      5. Run bin/rake appraisal:update if Appraisals present
+      5. Run bin/rake appraisal:generate if Appraisals present
       6. Ensure git user configured; commit release prep
       7. Optional local CI with `act` (controlled by K_RELEASE_LOCAL_CI)
       8. Ensure trunk in sync across remotes; rebase feature as needed
@@ -77,6 +77,7 @@ if ARGV.include?("-h") || ARGV.include?("--help")
     Options:
       start_step=<number>         # Begin at the numbered step above (e.g., 10 to resume at CI monitoring)
       --version VERSION           # Use this version instead of detecting VERSION from lib/**/version.rb
+      --appraisal-update          # Use slower appraisal:update instead of default appraisal:generate
       --local-ci                  # Sensitive release mode: run act locally, publish before any git push,
                                   # create the git tag locally, then push commits and tags after publish
 
@@ -85,6 +86,8 @@ if ARGV.include?("-h") || ARGV.include?("--help")
       GEM_CERT_USER=<user>        # Select certs/<user>.pem for signing
       K_RELEASE_LOCAL_CI=ask|1|0  # Use 'act' locally before push; 'ask' prompts, '1' forces, default off
       K_RELEASE_LOCAL_CI_WORKFLOW # Name of workflow (without .yml) for local CI; defaults to locked_deps or first
+      KETTLE_RELEASE_APPRAISAL_TASK=appraisal:update
+                                  # Use slower appraisal:update instead of default appraisal:generate
       GITHUB_TOKEN / GH_TOKEN     # Optional; enables GitHub release creation and API queries
       GITLAB_TOKEN / GL_TOKEN     # Optional; enables GitLab API queries when applicable
       DEBUG=true                  # Print backtraces on errors
@@ -119,12 +122,13 @@ def extract_version_arg!(argv)
 end
 
 local_ci = ARGV.include?("--local-ci")
+appraisal_task = ARGV.delete("--appraisal-update") ? "appraisal:update" : nil
 start_step_arg = ARGV.find { |a| a.start_with?("start_step=") }
 start_step = start_step_arg ? start_step_arg.split("=", 2)[1].to_i : 0
 version_override = extract_version_arg!(ARGV)
 
 begin
-  Kettle::Dev::ReleaseCLI.new(start_step: start_step, local_ci: local_ci, version: version_override).run
+  Kettle::Dev::ReleaseCLI.new(start_step: start_step, local_ci: local_ci, version: version_override, appraisal_task: appraisal_task).run
 rescue LoadError => e
   warn("#{script_basename}: could not load dependency: #{e.class}: #{e.message}")
   warn(Array(e.backtrace).join("\n")) if ENV["DEBUG"]

data/lib/kettle/dev/ci_monitor.rb

@@ -297,13 +297,13 @@ module Kettle
         end
         # Small initial delay to allow GitHub to register the newly pushed commit and enqueue workflows.
         # Configurable via K_RELEASE_CI_INITIAL_SLEEP (seconds); defaults to 3s.
-        begin
-          initial_sleep = begin
-            Integer(ENV["K_RELEASE_CI_INITIAL_SLEEP"])
-          rescue
-            nil
-          end
+
+        initial_sleep = begin
+          Integer(ENV["K_RELEASE_CI_INITIAL_SLEEP"])
+        rescue
+          nil
         end
+
         sleep((initial_sleep && initial_sleep >= 0) ? initial_sleep : 3)
         start_timeout = github_start_timeout
         poll_interval = github_poll_interval

data/lib/kettle/dev/gha_sha_pins_cli.rb

@@ -6,7 +6,6 @@ require "net/http"
 require "open3"
 require "optparse"
 require "pathname"
-require "set"
 require "time"
 require "uri"
 
@@ -265,11 +264,9 @@ module Kettle
             @options[:progress] = bool
           end
           opt.on("--skip-pattern PATTERN", "Skip workflow paths matching pattern (repeatable)") do |pattern|
-            begin
-              @options[:reject_patterns] << Regexp.new(pattern)
-            rescue RegexpError => e
-              Kettle::Dev::ExitAdapter.abort("Invalid --skip-pattern #{pattern.inspect}: #{e.message}")
-            end
+            @options[:reject_patterns] << Regexp.new(pattern)
+          rescue RegexpError => e
+            Kettle::Dev::ExitAdapter.abort("Invalid --skip-pattern #{pattern.inspect}: #{e.message}")
           end
           opt.on("--[no-]validate", "Validate YAML after editing") do |bool|
             @options[:validate] = bool
@@ -285,27 +282,25 @@ module Kettle
       def load_workflows(paths, state)
         file_progress = progress_bar(title: "Files", total: paths.length)
         paths.each_with_object([]) do |path, workflows|
-          begin
-            state[:files_scanned] += 1
-            text = begin
-              File.read(path)
-            rescue Errno::EACCES => e
-              record_failure(state, path: path, error: "read_error: #{e.message}")
-              next
-            end
-
-            parsed = begin
-              Psych.parse_stream(text)
-            rescue Psych::Exception => e
-              record_failure(state, path: path, error: "yaml_parse_error: #{e.message}")
-              next
-            end
+          state[:files_scanned] += 1
+          text = begin
+            File.read(path)
+          rescue Errno::EACCES => e
+            record_failure(state, path: path, error: "read_error: #{e.message}")
+            next
+          end
 
-            uses_nodes = extract_uses_nodes(parsed, text)
-            workflows << {path: path, text: text, uses_nodes: uses_nodes} unless uses_nodes.empty?
-          ensure
-            file_progress&.increment
+          parsed = begin
+            Psych.parse_stream(text)
+          rescue Psych::Exception => e
+            record_failure(state, path: path, error: "yaml_parse_error: #{e.message}")
+            next
           end
+
+          uses_nodes = extract_uses_nodes(parsed, text)
+          workflows << {path: path, text: text, uses_nodes: uses_nodes} unless uses_nodes.empty?
+        ensure
+          file_progress&.increment
         end
       end
 

data/lib/kettle/dev/git_adapter.rb

@@ -53,26 +53,24 @@ module Kettle
       # Create a new adapter rooted at the current working directory.
       # @return [void]
       def initialize
-        begin
-          # Allow users/CI to opt out of using the 'git' gem even when available.
-          # Set KETTLE_DEV_DISABLE_GIT_GEM to a truthy value ("1", "true", "yes") to force CLI backend.
-          env_val = ENV["KETTLE_DEV_DISABLE_GIT_GEM"]
-          # Ruby 2.3 compatibility: String#match? was added in 2.4; use Regexp#=== / =~ instead
-          disable_gem = env_val && !!(/\A(1|true|yes)\z/i =~ env_val)
-          if disable_gem
-            @backend = :cli
-          else
-            Kernel.require "git"
-            @backend = :gem
-            @git = ::Git.open(Dir.pwd)
-          end
-        rescue LoadError => e
-          Kettle::Dev.debug_error(e, __method__, backtrace: false)
-          # Optional dependency: fall back to CLI
+        # Allow users/CI to opt out of using the 'git' gem even when available.
+        # Set KETTLE_DEV_DISABLE_GIT_GEM to a truthy value ("1", "true", "yes") to force CLI backend.
+        env_val = ENV["KETTLE_DEV_DISABLE_GIT_GEM"]
+        # Ruby 2.3 compatibility: String#match? was added in 2.4; use Regexp#=== / =~ instead
+        disable_gem = env_val && !!(/\A(1|true|yes)\z/i =~ env_val)
+        if disable_gem
           @backend = :cli
-        rescue => e
-          raise Kettle::Dev::Error, "Failed to open git repository: #{e.message}"
+        else
+          Kernel.require "git"
+          @backend = :gem
+          @git = ::Git.open(Dir.pwd)
         end
+      rescue LoadError => e
+        Kettle::Dev.debug_error(e, __method__, backtrace: false)
+        # Optional dependency: fall back to CLI
+        @backend = :cli
+      rescue => e
+        raise Kettle::Dev::Error, "Failed to open git repository: #{e.message}"
       end
 
       # Push a branch to a remote.
@@ -200,12 +198,10 @@ module Kettle
       def remotes_with_urls
         if @backend == :gem
           @git.remotes.each_with_object({}) do |r, h|
-            begin
-              h[r.name] = r.url
-            rescue => e
-              Kettle::Dev.debug_error(e, __method__)
-              # ignore
-            end
+            h[r.name] = r.url
+          rescue => e
+            Kettle::Dev.debug_error(e, __method__)
+            # ignore
           end
         else
           out, status = Open3.capture2("git", "remote", "-v")

data/lib/kettle/dev/git_commit_footer.rb

@@ -5,7 +5,7 @@ module Kettle
     class GitCommitFooter
       # Regex to extract `name = "value"` assignments from a gemspec.
       # @return [Regexp]
-      NAME_ASSIGNMENT_REGEX = /\bname\s*=\s*(["'])([^"']+)\1/.freeze
+      NAME_ASSIGNMENT_REGEX = /\bname\s*=\s*(["'])([^"']+)\1/
 
       # Whether footer appending is enabled (via GIT_HOOK_FOOTER_APPEND=true)
       # @return [Boolean]

data/lib/kettle/dev/open_collective_config.rb

@@ -44,14 +44,14 @@ module Kettle
 
         ypath = yaml_path(root)
         if strict
-          yml = YAML.safe_load(File.read(ypath))
+          yml = YAML.safe_load_file(ypath)
           if yml.is_a?(Hash)
             handle = yml["collective"] || yml[:collective] || yml["org"] || yml[:org]
             return handle.to_s unless handle.nil? || handle.to_s.strip.empty? || handle.to_s.match?(/\{KJ\|[^}]+}/)
           end
         elsif File.file?(ypath)
           begin
-            yml = YAML.safe_load(File.read(ypath))
+            yml = YAML.safe_load_file(ypath)
             if yml.is_a?(Hash)
               handle = yml["collective"] || yml[:collective] || yml["org"] || yml[:org]
               return handle.to_s unless handle.nil? || handle.to_s.strip.empty? || handle.to_s.match?(/\{KJ\|[^}]+}/)

data/lib/kettle/dev/pre_release_cli.rb

@@ -253,12 +253,10 @@ module Kettle
               Array(glob_pattern)
             end
           urls = files.flat_map do |f|
-            begin
-              extract_image_urls_from_text(File.read(f))
-            rescue => e
-              warn("[kettle-pre-release] Could not read #{Kettle::Dev.display_path(f)}: #{e.class}: #{e.message}")
-              []
-            end
+            extract_image_urls_from_text(File.read(f))
+          rescue => e
+            warn("[kettle-pre-release] Could not read #{Kettle::Dev.display_path(f)}: #{e.class}: #{e.message}")
+            []
           end
           urls.uniq
         end

data/lib/kettle/dev/rakelib/appraisal.rake

@@ -33,20 +33,18 @@ begin
   end
 
   run_appraisal_task = lambda do |task_name, primary_steps = nil|
-    begin
-      if primary_steps
-        begin
-          primary_steps.call
-        rescue RuntimeError => e
-          warn("[kettle-dev][#{task_name}] #{e.message}; falling back to appraisal:generate")
-          run_generate_steps.call
-        end
-      else
+    if primary_steps
+      begin
+        primary_steps.call
+      rescue RuntimeError => e
+        warn("[kettle-dev][#{task_name}] #{e.message}; falling back to appraisal:generate")
         run_generate_steps.call
       end
-    rescue RuntimeError => e
-      abort(e.message)
+    else
+      run_generate_steps.call
     end
+  rescue RuntimeError => e
+    abort(e.message)
   end
 
   desc("Install Appraisal gemfiles (initial setup for projects that didn't previously use Appraisal)")
@@ -159,13 +157,11 @@ begin
       else
         failures = []
         locks.each do |f|
-          begin
-            File.delete(f)
-          rescue Errno::ENOENT
-            # Ignore if already gone
-          rescue => e
-            failures << [f, e]
-          end
+          File.delete(f)
+        rescue Errno::ENOENT
+          # Ignore if already gone
+        rescue => e
+          failures << [f, e]
         end
 
         unless failures.empty?

data/lib/kettle/dev/readme_backers.rb

@@ -5,7 +5,6 @@ require "yaml"
 require "json"
 require "uri"
 require "net/http"
-require "set"
 
 module Kettle
   module Dev
@@ -244,7 +243,7 @@ module Kettle
 
         if File.file?(OC_YML_PATH)
           begin
-            yml = YAML.safe_load(File.read(OC_YML_PATH))
+            yml = YAML.safe_load_file(OC_YML_PATH)
             if yml.is_a?(Hash)
               from_yml = yml["readme-osc-tag"] || yml[:"readme-osc-tag"]
               from_yml = from_yml.to_s if from_yml
@@ -660,7 +659,7 @@ module Kettle
 
         if File.file?(OC_YML_PATH)
           begin
-            yml = YAML.safe_load(File.read(OC_YML_PATH))
+            yml = YAML.safe_load_file(OC_YML_PATH)
             if yml.is_a?(Hash)
               from_yml = yml["readme-backers-commit-subject"] || yml[:"readme-backers-commit-subject"]
               from_yml = from_yml.to_s if from_yml

data/lib/kettle/dev/release_cli.rb

@@ -72,13 +72,14 @@ module Kettle
 
       public
 
-      def initialize(start_step: 0, local_ci: false, version: nil)
+      def initialize(start_step: 0, local_ci: false, version: nil, appraisal_task: nil)
         @root = Kettle::Dev::CIHelpers.project_root
         @git = Kettle::Dev::GitAdapter.new
         @start_step = (start_step || 0).to_i
         @start_step = 0 if @start_step < 0
         @local_ci = !!local_ci
         @version_override = Kettle::Dev::Versioning.normalize_explicit_version(version)
+        @appraisal_task = normalize_appraisal_task(appraisal_task || ENV["KETTLE_RELEASE_APPRAISAL_TASK"])
       end
 
       def run
@@ -190,14 +191,14 @@ module Kettle
         # 4. bin/rake
         run_cmd!("bin/rake") if @start_step <= 4
 
-        # 5. appraisal:update (optional) + canonical docs build
+        # 5. appraisal:generate (optional) + canonical docs build
         if @start_step <= 5
           appraisals_path = File.join(@root, "Appraisals")
           if File.file?(appraisals_path)
-            puts "Appraisals detected at #{Kettle::Dev.display_path(appraisals_path)}. Running: bin/rake appraisal:update"
-            run_cmd!("bin/rake appraisal:update")
+            puts "Appraisals detected at #{Kettle::Dev.display_path(appraisals_path)}. Running: bin/rake #{@appraisal_task}"
+            run_cmd!("bin/rake #{@appraisal_task}")
           else
-            puts "No Appraisals file found; skipping appraisal:update"
+            puts "No Appraisals file found; skipping #{@appraisal_task}"
           end
 
           puts "Generating docs site via canonical task: bin/rake yard"
@@ -320,6 +321,15 @@ module Kettle
         end
       end
 
+      def normalize_appraisal_task(value)
+        task = value.to_s.strip
+        return "appraisal:generate" if task.empty?
+        return "appraisal:generate" if task == "generate" || task == "appraisal:generate"
+        return "appraisal:update" if task == "update" || task == "appraisal:update"
+
+        abort("Unsupported appraisal task #{value.inspect}; use appraisal:generate or appraisal:update.")
+      end
+
       private
 
       def local_ci?
@@ -405,7 +415,6 @@ module Kettle
       # This helps ensure docs are kept in sync when bumping the years.
       # Aborts with a helpful message when they differ.
       def validate_copyright_years!
-        require "set"
         readme = File.join(@root, "README.md")
         license = File.join(@root, "LICENSE.txt")
         unless File.file?(readme) && File.file?(license)
@@ -446,7 +455,6 @@ module Kettle
       # then parses four-digit years and year ranges like "2012-2015" (hyphen or en dash).
       # Returns Set[Integer].
       def extract_years_from_file(path)
-        require "set"
         years = Set.new
         content = File.read(path)
         # Only consider lines that look like copyright notices to reduce false positives

data/lib/kettle/dev/tasks/ci_task.rb

@@ -91,48 +91,46 @@ module Kettle
 
           # Print GitLab pipeline status (if configured) for the current branch.
           print_gitlab_status = proc do
-            begin
-              branch = Kettle::Dev::CIHelpers.current_branch
-              # Detect any GitLab remote (not just origin), mirroring CIMonitor behavior
-              gl_remotes = Kettle::Dev::CIMonitor.gitlab_remote_candidates
-              if gl_remotes.nil? || gl_remotes.empty? || branch.nil?
-                puts "Latest GL (#{branch || "n/a"}) pipeline: n/a"
-                next
-              end
+            branch = Kettle::Dev::CIHelpers.current_branch
+            # Detect any GitLab remote (not just origin), mirroring CIMonitor behavior
+            gl_remotes = Kettle::Dev::CIMonitor.gitlab_remote_candidates
+            if gl_remotes.nil? || gl_remotes.empty? || branch.nil?
+              puts "Latest GL (#{branch || "n/a"}) pipeline: n/a"
+              next
+            end
 
-              # Parse owner/repo from the first GitLab remote URL
-              gl_url = Kettle::Dev::CIMonitor.remote_url(gl_remotes.first)
-              owner = repo = nil
-              if gl_url =~ %r{git@gitlab.com:(.+?)/(.+?)(\.git)?$}
-                owner = Regexp.last_match(1)
-                repo = Regexp.last_match(2).sub(/\.git\z/, "")
-              elsif gl_url =~ %r{https://gitlab.com/(.+?)/(.+?)(\.git)?$}
-                owner = Regexp.last_match(1)
-                repo = Regexp.last_match(2).sub(/\.git\z/, "")
-              end
+            # Parse owner/repo from the first GitLab remote URL
+            gl_url = Kettle::Dev::CIMonitor.remote_url(gl_remotes.first)
+            owner = repo = nil
+            if gl_url =~ %r{git@gitlab.com:(.+?)/(.+?)(\.git)?$}
+              owner = Regexp.last_match(1)
+              repo = Regexp.last_match(2).sub(/\.git\z/, "")
+            elsif gl_url =~ %r{https://gitlab.com/(.+?)/(.+?)(\.git)?$}
+              owner = Regexp.last_match(1)
+              repo = Regexp.last_match(2).sub(/\.git\z/, "")
+            end
 
-              unless owner && repo
-                puts "Latest GL (#{branch}) pipeline: n/a"
-                next
-              end
+            unless owner && repo
+              puts "Latest GL (#{branch}) pipeline: n/a"
+              next
+            end
 
-              pipe = Kettle::Dev::CIHelpers.gitlab_latest_pipeline(owner: owner, repo: repo, branch: branch)
-              if pipe
-                st = pipe["status"].to_s
-                status = if st == "success"
-                  "success"
-                else
-                  ((st == "failed") ? "failure" : nil)
-                end
-                emoji = Kettle::Dev::CIMonitor.status_emoji(st, status)
-                details = [st, pipe["failure_reason"]].compact.join("/")
-                puts "Latest GL (#{branch}) pipeline: #{emoji} (#{details})"
+            pipe = Kettle::Dev::CIHelpers.gitlab_latest_pipeline(owner: owner, repo: repo, branch: branch)
+            if pipe
+              st = pipe["status"].to_s
+              status = if st == "success"
+                "success"
               else
-                puts "Latest GL (#{branch}) pipeline: none"
+                ((st == "failed") ? "failure" : nil)
               end
-            rescue => e
-              puts "GL status: error #{e.class}: #{e.message}"
+              emoji = Kettle::Dev::CIMonitor.status_emoji(st, status)
+              details = [st, pipe["failure_reason"]].compact.join("/")
+              puts "Latest GL (#{branch}) pipeline: #{emoji} (#{details})"
+            else
+              puts "Latest GL (#{branch}) pipeline: none"
             end
+          rescue => e
+            puts "GL status: error #{e.class}: #{e.message}"
           end
 
           run_act_for = proc do |file_path|
@@ -264,12 +262,10 @@ module Kettle
           selected = nil
           input_thread = nil
           read_input = proc do
-            begin
-              selected = Kettle::Dev::InputAdapter.gets&.strip
-            rescue StandardError, SystemExit, Interrupt => error
-              puts "Error reading input: #{error.class}: #{error.message}" if Kettle::Dev::DEBUGGING
-              selected = :input_error
-            end
+            selected = Kettle::Dev::InputAdapter.gets&.strip
+          rescue StandardError, SystemExit, Interrupt => error
+            puts "Error reading input: #{error.class}: #{error.message}" if Kettle::Dev::DEBUGGING
+            selected = :input_error
           end
           if tty
             input_thread = Thread.new(&read_input) # rubocop:disable ThreadSafety/NewThread
@@ -283,54 +279,52 @@ module Kettle
 
           options.each do |code, file|
             workers << Thread.new(code, file, owner, repo, branch, token, start_at) do |c, f, ow, rp, br, tk, st_at| # rubocop:disable ThreadSafety/NewThread
-              begin
-                now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-                delay = 0.12 - (now - st_at)
-                sleep(delay) if delay && delay > 0
-
-                if ow.nil? || rp.nil? || br.nil?
-                  status_q << [c, f, "n/a"]
-                  Thread.exit
-                end
-                uri = URI("https://api.github.com/repos/#{ow}/#{rp}/actions/workflows/#{f}/runs?branch=#{URI.encode_www_form_component(br)}&per_page=1")
-                poll_interval = Integer(ENV["CI_ACT_POLL_INTERVAL"] || 5)
-                loop do
-                  begin
-                    req = Net::HTTP::Get.new(uri)
-                    req["User-Agent"] = "ci:act rake task"
-                    req["Authorization"] = "token #{tk}" if tk && !tk.empty?
-                    res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
-                    if res.is_a?(Net::HTTPSuccess)
-                      data = JSON.parse(res.body)
-                      run = data["workflow_runs"]&.first
-                      if run
-                        st = run["status"]
-                        con = run["conclusion"]
-                        emoji = Kettle::Dev::CIMonitor.status_emoji(st, con)
-                        details = [st, con].compact.join("/")
-                        status_q << [c, f, "#{emoji} (#{details})"]
-                        break if st == "completed"
-                      else
-                        status_q << [c, f, "none"]
-                        break
-                      end
+              now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+              delay = 0.12 - (now - st_at)
+              sleep(delay) if delay && delay > 0
+
+              if ow.nil? || rp.nil? || br.nil?
+                status_q << [c, f, "n/a"]
+                Thread.exit
+              end
+              uri = URI("https://api.github.com/repos/#{ow}/#{rp}/actions/workflows/#{f}/runs?branch=#{URI.encode_www_form_component(br)}&per_page=1")
+              poll_interval = Integer(ENV["CI_ACT_POLL_INTERVAL"] || 5)
+              loop do
+                begin
+                  req = Net::HTTP::Get.new(uri)
+                  req["User-Agent"] = "ci:act rake task"
+                  req["Authorization"] = "token #{tk}" if tk && !tk.empty?
+                  res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
+                  if res.is_a?(Net::HTTPSuccess)
+                    data = JSON.parse(res.body)
+                    run = data["workflow_runs"]&.first
+                    if run
+                      st = run["status"]
+                      con = run["conclusion"]
+                      emoji = Kettle::Dev::CIMonitor.status_emoji(st, con)
+                      details = [st, con].compact.join("/")
+                      status_q << [c, f, "#{emoji} (#{details})"]
+                      break if st == "completed"
                     else
-                      status_q << [c, f, "fail #{res.code}"]
+                      status_q << [c, f, "none"]
+                      break
                     end
-                  rescue Exception => e # rubocop:disable Lint/RescueException
-                    Kettle::Dev.debug_error(e, __method__)
-                    # Catch all exceptions to prevent crashing the process from a worker thread
-                    status_q << [c, f, "err"]
+                  else
+                    status_q << [c, f, "fail #{res.code}"]
                   end
-                  sleep(poll_interval)
+                rescue Exception => e # rubocop:disable Lint/RescueException
+                  Kettle::Dev.debug_error(e, __method__)
+                  # Catch all exceptions to prevent crashing the process from a worker thread
+                  status_q << [c, f, "err"]
                 end
-              rescue Exception => e # rubocop:disable Lint/RescueException
-                Kettle::Dev.debug_error(e, __method__)
-                # simplecov:disable
-                # Catch all exceptions in the worker thread boundary, including SystemExit
-                status_q << [c, f, "err"]
-                # simplecov:enable
+                sleep(poll_interval)
               end
+            rescue Exception => e # rubocop:disable Lint/RescueException
+              Kettle::Dev.debug_error(e, __method__)
+              # simplecov:disable
+              # Catch all exceptions in the worker thread boundary, including SystemExit
+              status_q << [c, f, "err"]
+              # simplecov:enable
             end
           end
 

data/lib/kettle/dev/version.rb

@@ -3,7 +3,7 @@
 module Kettle
   module Dev
     module Version
-      VERSION = "2.2.18"
+      VERSION = "2.2.19"
     end
     VERSION = Version::VERSION # Traditional Constant Location
   end

data/lib/kettle/dev.rb

@@ -177,38 +177,34 @@ module Kettle
       # Set up rubocop-lts, which cascades to rubocop-rubyX_X => rubocop_gradual)
       # @return [void]
       def linting_tasks
-        begin
-          # Lazy loaded because it won't be installed for Ruby < 2.7
-          require "rubocop/lts"
-
-          Rubocop::Lts.install_tasks
-          if Kettle::Dev::IS_CI
-            Kettle::Dev.register_default("rubocop_gradual:check")
-          else
-            Kettle::Dev.register_default("rubocop_gradual:autocorrect")
-          end
-        rescue LoadError
-          # OK, no styles for you.
+        # Lazy loaded because it won't be installed for Ruby < 2.7
+        require "rubocop/lts"
+
+        Rubocop::Lts.install_tasks
+        if Kettle::Dev::IS_CI
+          Kettle::Dev.register_default("rubocop_gradual:check")
+        else
+          Kettle::Dev.register_default("rubocop_gradual:autocorrect")
         end
+      rescue LoadError
+        # OK, no styles for you.
       end
 
       ### TEST COVERAGE TASKS
       # Set up kettle-soup-cover
       # @return [void]
       def coverage_tasks
-        begin
-          # Lazy loaded because it won't be installed for Ruby < 2.7
-          require "kettle-soup-cover"
-
-          Kettle::Soup::Cover.install_tasks
-          # NOTE: Coverage on CI is configured independent of this task.
-          #       This task is for local development, as it opens results in browser
-          # simplecov:disable
-          Kettle::Dev.register_default("coverage") unless Kettle::Dev::IS_CI
-          # simplecov:enable
-        rescue LoadError
-          # OK, no soup for you.
-        end
+        # Lazy loaded because it won't be installed for Ruby < 2.7
+        require "kettle-soup-cover"
+
+        Kettle::Soup::Cover.install_tasks
+        # NOTE: Coverage on CI is configured independent of this task.
+        #       This task is for local development, as it opens results in browser
+        # simplecov:disable
+        Kettle::Dev.register_default("coverage") unless Kettle::Dev::IS_CI
+        # simplecov:enable
+      rescue LoadError
+        # OK, no soup for you.
       end
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kettle-dev
 version: !ruby/object:Gem::Version
-  version: 2.2.18
+  version: 2.2.19
 platform: ruby
 authors:
 - Peter H. Boling
@@ -339,10 +339,10 @@ licenses:
 - AGPL-3.0-only
 metadata:
   homepage_uri: https://kettle-dev.galtzo.com
-  source_code_uri: https://github.com/kettle-dev/kettle-dev/tree/v2.2.18
-  changelog_uri: https://github.com/kettle-dev/kettle-dev/blob/v2.2.18/CHANGELOG.md
+  source_code_uri: https://github.com/kettle-dev/kettle-dev/tree/v2.2.19
+  changelog_uri: https://github.com/kettle-dev/kettle-dev/blob/v2.2.19/CHANGELOG.md
   bug_tracker_uri: https://github.com/kettle-dev/kettle-dev/issues
-  documentation_uri: https://www.rubydoc.info/gems/kettle-dev/2.2.18
+  documentation_uri: https://www.rubydoc.info/gems/kettle-dev/2.2.19
   funding_uri: https://github.com/sponsors/pboling
   wiki_uri: https://github.com/kettle-dev/kettle-dev/wiki
   news_uri: https://www.railsbling.com/tags/kettle-dev