kettle-dev 2.2.19 → 2.2.21

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 309dfdff5a98f7d5d2f189a3b51a4d0f231d037b61ea37023918a70ec436d997
-  data.tar.gz: 9dff167d60de601c34738beb35c81df5e3c1a8874630ccaebf753507fa205a41
+  metadata.gz: 5c84739dfdebb3ae9c5c6fd438c7cc1db6e5707d9cecfe7a3e2e754e41390301
+  data.tar.gz: 9e1f2b9e2f3c842c218977027c6cf69c1a753072f2d281e39239dc3e7097e9ee
 SHA512:
-  metadata.gz: baf9a43aeac7238588295facc22c7a151c68abeed3b754872d539bc25571ea43e87eaac9ffb81ea4f5133206d1e9f1d0ef7d2fc609b666fa0bfad54df27069d0
-  data.tar.gz: 6f607059c8cd545bad791de6277f40f0b75d956fbc7654677cdcfb53345c2b658e98881e80f694992041e872e96b4e643d69f61a578ca305821fe449fe6c21ae
+  metadata.gz: 287be3949983f25366e89ec2de3058bc63cf14dee7ff5b45a5da6a49a09d524493e91318788a370bb6ff92d4bed313771596368638f5026802850523be74f4df
+  data.tar.gz: 20bf852b21d4fa605b151e9ee4fe91b50921fa7320ded4ec937951e3cfcc4177ae653246448139ede0188d4741d70f0b5d1b7afce04ed042442d31cbbbb4f98b

data/CHANGELOG.md

@@ -30,6 +30,47 @@ Please file a bug if you notice a violation of semantic versioning.
 
 ### Security
 
+## [2.2.21] - 2026-06-28
+
+- TAG: [v2.2.21][2.2.21t]
+- COVERAGE: 92.34% -- 4182/4529 lines in 33 files
+- BRANCH COVERAGE: 73.34% -- 1659/2262 branches in 33 files
+- 61.04% documented
+
+### Fixed
+
+- `kettle-release` now detects local `.kettle-family.yml` branch-stack release
+  targets and skips trunk sync, trunk merge, and trunk checkout for those release
+  branches.
+
+## [2.2.20] - 2026-06-27
+
+- TAG: [v2.2.20][2.2.20t]
+- COVERAGE: 91.82% -- 4131/4499 lines in 33 files
+- BRANCH COVERAGE: 72.73% -- 1632/2244 branches in 33 files
+- 61.04% documented
+
+### Added
+
+- `kettle-release` now accepts `skip_steps=...` / `--skip-steps ...` to skip
+  selected numbered release steps while running the rest of the release flow.
+
+### Fixed
+
+- `kettle-release` now suppresses inherited Bundler/debug verbosity when running
+  release child commands and Appraisal bundle installs.
+
+- `kettle-release` now switches a local `RUBOCOP_LTS_LOCAL` checkout to the
+  branch matching the project's selected `rubocop-rubyN_N` style gem before
+  running setup and default rake tasks.
+
+- Restored Ruby 2.4 parser compatibility for recent release and CI helper code.
+
+### Changed
+
+- `kettle-release` now reads RuboCop LTS branch selection from
+  `Kettle::Rb::CompatMatrix`.
+
 ## [2.2.19] - 2026-06-26
 
 - TAG: [v2.2.19][2.2.19t]
@@ -2293,7 +2334,11 @@ 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.19...HEAD
+[Unreleased]: https://github.com/kettle-dev/kettle-dev/compare/v2.2.21...HEAD
+[2.2.21]: https://github.com/kettle-dev/kettle-dev/compare/v2.2.20...v2.2.21
+[2.2.21t]: https://github.com/kettle-dev/kettle-dev/releases/tag/v2.2.21
+[2.2.20]: https://github.com/kettle-dev/kettle-dev/compare/v2.2.19...v2.2.20
+[2.2.20t]: https://github.com/kettle-dev/kettle-dev/releases/tag/v2.2.20
 [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

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.449-FFDD67.svg?style=for-the-badge&logo=YouTube&logoColor=blue
+[🧮kloc-img]: https://img.shields.io/badge/KLOC-4.529-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-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] [--appraisal-update] [start_step=<0-19>]
+    Usage: kettle-release [--version VERSION] [--local-ci] [--appraisal-update] [--skip-steps STEPS] [start_step=<0-19>]
 
     Automates the release flow for a Ruby gem in the host project.
 
@@ -76,6 +76,8 @@ 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)
+      skip_steps=<numbers>        # Comma-separated numbered steps to skip while running the rest
+      --skip-steps NUMBERS        # Alias for skip_steps=NUMBERS (e.g., --skip-steps 10 or --skip-steps 10,18)
       --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,
@@ -97,12 +99,13 @@ if ARGV.include?("-h") || ARGV.include?("--help")
       kettle-release --local-ci            # run local act CI, publish gem, then push commits/tags
       kettle-release start_step=1          # skip pre-release checks and start numbered release steps
       kettle-release start_step=10         # resume by monitoring CI for the current branch
+      kettle-release skip_steps=10         # run the release but skip remote CI monitoring
       SKIP_GEM_SIGNING=true kettle-release start_step=14  # build+release without signing
   USAGE
   exit 0
 end
 
-# Parse start_step=<n> from ARGV
+# Parse release options from ARGV
 def extract_version_arg!(argv)
   version = nil
   if (idx = argv.index("--version"))
@@ -121,14 +124,33 @@ def extract_version_arg!(argv)
   Kettle::Dev::Versioning.normalize_explicit_version(version)
 end
 
+def extract_skip_steps_arg!(argv)
+  skip_steps = nil
+  if (idx = argv.index("--skip-steps"))
+    skip_steps = argv[idx + 1]
+    Kettle::Dev::ExitAdapter.abort("--skip-steps requires a comma-separated step list") if skip_steps.to_s.empty?
+    argv.slice!(idx, 2)
+  end
+  argv.delete_if do |arg|
+    if arg.start_with?("--skip-steps=", "skip_steps=")
+      skip_steps = arg.split("=", 2)[1]
+      true
+    else
+      false
+    end
+  end
+  skip_steps
+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)
+skip_steps = extract_skip_steps_arg!(ARGV)
 
 begin
-  Kettle::Dev::ReleaseCLI.new(start_step: start_step, local_ci: local_ci, version: version_override, appraisal_task: appraisal_task).run
+  Kettle::Dev::ReleaseCLI.new(start_step: start_step, local_ci: local_ci, version: version_override, appraisal_task: appraisal_task, skip_steps: skip_steps).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/gem_spec_reader.rb

@@ -196,7 +196,7 @@ module Kettle
         end
 
         def declared_version_file_path(root)
-          gemspec_path = Dir.glob(File.join(root.to_s, "*.gemspec")).sort.first
+          gemspec_path = Dir.glob(File.join(root.to_s, "*.gemspec")).min
           return unless gemspec_path && File.file?(gemspec_path)
 
           gemspec_source = File.read(gemspec_path)

data/lib/kettle/dev/gha_sha_pins_cli.rb

@@ -264,9 +264,11 @@ module Kettle
             @options[:progress] = bool
           end
           opt.on("--skip-pattern PATTERN", "Skip workflow paths matching pattern (repeatable)") do |pattern|
-            @options[:reject_patterns] << Regexp.new(pattern)
-          rescue RegexpError => e
-            Kettle::Dev::ExitAdapter.abort("Invalid --skip-pattern #{pattern.inspect}: #{e.message}")
+            begin
+              @options[:reject_patterns] << Regexp.new(pattern)
+            rescue RegexpError => e
+              Kettle::Dev::ExitAdapter.abort("Invalid --skip-pattern #{pattern.inspect}: #{e.message}")
+            end
           end
           opt.on("--[no-]validate", "Validate YAML after editing") do |bool|
             @options[:validate] = bool
@@ -282,25 +284,27 @@ module Kettle
       def load_workflows(paths, state)
         file_progress = progress_bar(title: "Files", total: paths.length)
         paths.each_with_object([]) do |path, workflows|
-          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
+          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
+            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
+            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
       end
 

data/lib/kettle/dev/git_adapter.rb

@@ -198,10 +198,12 @@ module Kettle
       def remotes_with_urls
         if @backend == :gem
           @git.remotes.each_with_object({}) do |r, h|
-            h[r.name] = r.url
-          rescue => e
-            Kettle::Dev.debug_error(e, __method__)
-            # ignore
+            begin
+              h[r.name] = r.url
+            rescue => e
+              Kettle::Dev.debug_error(e, __method__)
+              # ignore
+            end
           end
         else
           out, status = Open3.capture2("git", "remote", "-v")

data/lib/kettle/dev/pre_release_cli.rb

@@ -253,10 +253,12 @@ module Kettle
               Array(glob_pattern)
             end
           urls = files.flat_map do |f|
-            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}")
-            []
+            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
           end
           urls.uniq
         end

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

@@ -5,7 +5,27 @@ begin
   require "appraisal/task"
 
   bundle = "bundle"
-  appraisal_env = {"BUNDLE_GEMFILE" => "Appraisal.root.gemfile"}
+  quiet_env = {
+    "KETTLE_JEM_QUIET" => "true",
+    "KETTLE_JEM_DEBUG" => "false",
+    "KETTLE_DEV_DEBUG" => "false",
+    "SMORG_RB_DEBUG" => "false",
+    "DEBUG" => nil,
+    "BUNDLE_QUIET" => "true",
+    "BUNDLE_DEBUG" => "false",
+    "BUNDLER_DEBUG" => "false",
+    "BUNDLE_VERBOSE" => "false",
+    "DEBUG_RESOLVER" => nil,
+    "DEBUG_RESOLVER_TREE" => nil,
+    "BUNDLER_DEBUG_RESOLVER" => nil,
+    "BUNDLER_DEBUG_RESOLVER_TREE" => nil,
+    "DEBUG_COMPACT_INDEX" => nil,
+    "MOLINILLO_DEBUG" => nil,
+    "BUNDLE_SILENCE_DEPRECATIONS" => "true",
+    "BUNDLE_SILENCE_ROOT_WARNING" => "true",
+    "BUNDLE_SUPPRESS_INSTALL_USING_MESSAGES" => "true"
+  }
+  appraisal_env = quiet_env.merge("BUNDLE_GEMFILE" => "Appraisal.root.gemfile")
 
   run_command = lambda do |failure_message, *args|
     ok = system(*args)
@@ -18,7 +38,8 @@ begin
       "appraisal:generate failed: BUNDLE_GEMFILE=Appraisal.root.gemfile bundle install",
       appraisal_env,
       bundle,
-      "install"
+      "install",
+      "--quiet"
     )
 
     # 2) BUNDLE_GEMFILE=Appraisal.root.gemfile bundle exec appraisal generate
@@ -33,18 +54,20 @@ begin
   end
 
   run_appraisal_task = lambda do |task_name, primary_steps = nil|
-    if primary_steps
-      begin
-        primary_steps.call
-      rescue RuntimeError => e
-        warn("[kettle-dev][#{task_name}] #{e.message}; falling back to appraisal:generate")
+    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
         run_generate_steps.call
       end
-    else
-      run_generate_steps.call
+    rescue RuntimeError => e
+      abort(e.message)
     end
-  rescue RuntimeError => e
-    abort(e.message)
   end
 
   desc("Install Appraisal gemfiles (initial setup for projects that didn't previously use Appraisal)")
@@ -58,7 +81,8 @@ begin
             "appraisal:install failed: BUNDLE_GEMFILE=Appraisal.root.gemfile bundle install",
             appraisal_env,
             bundle,
-            "install"
+            "install",
+            "--quiet"
           )
 
           # 2) BUNDLE_GEMFILE=Appraisal.root.gemfile bundle exec appraisal generate-install
@@ -105,7 +129,8 @@ begin
             "appraisal:update failed: BUNDLE_GEMFILE=Appraisal.root.gemfile bundle install",
             appraisal_env,
             bundle,
-            "install"
+            "install",
+            "--quiet"
           )
 
           # 2) BUNDLE_GEMFILE=Appraisal.root.gemfile bundle update --bundler
@@ -122,7 +147,8 @@ begin
             "appraisal:update failed: BUNDLE_GEMFILE=Appraisal.root.gemfile bundle install",
             appraisal_env,
             bundle,
-            "install"
+            "install",
+            "--quiet"
           )
 
           # 4) BUNDLE_GEMFILE=Appraisal.root.gemfile bundle exec appraisal generate-update
@@ -157,11 +183,13 @@ begin
       else
         failures = []
         locks.each do |f|
-          File.delete(f)
-        rescue Errno::ENOENT
-          # Ignore if already gone
-        rescue => e
-          failures << [f, e]
+          begin
+            File.delete(f)
+          rescue Errno::ENOENT
+            # Ignore if already gone
+          rescue => e
+            failures << [f, e]
+          end
         end
 
         unless failures.empty?

data/lib/kettle/dev/release_cli.rb

@@ -9,13 +9,36 @@ require "fileutils"
 require "net/http"
 require "json"
 require "uri"
+require "yaml"
 
 # External gems
+require "kettle/rb/compat_matrix"
 require "ruby-progressbar"
 
 module Kettle
   module Dev
     class ReleaseCLI
+      QUIET_ENV = {
+        "KETTLE_JEM_QUIET" => "true",
+        "KETTLE_JEM_DEBUG" => "false",
+        "KETTLE_DEV_DEBUG" => "false",
+        "SMORG_RB_DEBUG" => "false",
+        "DEBUG" => nil,
+        "BUNDLE_QUIET" => "true",
+        "BUNDLE_DEBUG" => "false",
+        "BUNDLER_DEBUG" => "false",
+        "BUNDLE_VERBOSE" => "false",
+        "DEBUG_RESOLVER" => nil,
+        "DEBUG_RESOLVER_TREE" => nil,
+        "BUNDLER_DEBUG_RESOLVER" => nil,
+        "BUNDLER_DEBUG_RESOLVER_TREE" => nil,
+        "DEBUG_COMPACT_INDEX" => nil,
+        "MOLINILLO_DEBUG" => nil,
+        "BUNDLE_SILENCE_DEPRECATIONS" => "true",
+        "BUNDLE_SILENCE_ROOT_WARNING" => "true",
+        "BUNDLE_SUPPRESS_INSTALL_USING_MESSAGES" => "true"
+      }.freeze
+      DEBUG_TRUE_VALUES = %w[1 true yes on].freeze
       class << self
         def run_cmd!(cmd)
           # For Bundler-invoked build/release, explicitly prefix SKIP_GEM_SIGNING so
@@ -26,7 +49,7 @@ module Kettle
           end
           puts "$ #{cmd}"
           # Pass a plain Hash for the environment to satisfy tests and avoid ENV object oddities
-          env_hash = ENV.respond_to?(:to_hash) ? ENV.to_hash : ENV.to_h
+          env_hash = command_env
 
           # Some commands are interactive (e.g., `bundle exec rake release` prompting for RubyGems MFA).
           # Using capture3 detaches STDIN, preventing prompts from working. For such commands, use system
@@ -62,6 +85,19 @@ module Kettle
             abort("Command failed: #{cmd} (exit #{exit_code})#{diag}")
           end
         end
+
+        private
+
+        def command_env
+          env_hash = ENV.respond_to?(:to_hash) ? ENV.to_hash : ENV.to_h
+          return env_hash if debug_env_enabled?
+
+          env_hash.merge(QUIET_ENV)
+        end
+
+        def debug_env_enabled?
+          DEBUG_TRUE_VALUES.include?(ENV.fetch("KETTLE_DEV_DEBUG", "").downcase)
+        end
       end
 
       private
@@ -72,29 +108,31 @@ module Kettle
 
       public
 
-      def initialize(start_step: 0, local_ci: false, version: nil, appraisal_task: nil)
+      def initialize(start_step: 0, local_ci: false, version: nil, appraisal_task: nil, skip_steps: 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
+        @skip_steps = normalize_skip_steps(skip_steps)
         @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
-        run_pre_release_checks! if @start_step <= 0
+        run_pre_release_checks! if run_step?(0)
 
         # 1. Ensure Bundler version ✓
-        ensure_bundler_2_7_plus!
+        ensure_bundler_2_7_plus! if run_step?(1)
 
         version = nil
         committed = nil
         trunk = nil
         feature = nil
+        branch_stack_release = false
 
         # 2. Version detection and sanity checks + prompt
-        if @start_step <= 2
+        if run_step?(2)
           version = detect_version
           puts "Detected version: #{version.inspect}"
 
@@ -186,13 +224,15 @@ module Kettle
           end
         end
 
+        prepare_rubocop_lts_local_branch! if rubocop_lts_release_preflight_needed?
+
         # 3. bin/setup
-        run_cmd!("bin/setup") if @start_step <= 3
+        run_cmd!("bin/setup") if run_step?(3)
         # 4. bin/rake
-        run_cmd!("bin/rake") if @start_step <= 4
+        run_cmd!("bin/rake") if run_step?(4)
 
         # 5. appraisal:generate (optional) + canonical docs build
-        if @start_step <= 5
+        if run_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_task}"
@@ -206,47 +246,62 @@ module Kettle
         end
 
         # 6. git user + commit release prep
-        if @start_step <= 6
+        if run_step?(6)
           ensure_git_user!
           version ||= detect_version
           committed = commit_release_prep!(version)
         end
 
         # 7. optional local CI via act
-        maybe_run_local_ci_before_push!(committed, force: local_ci?) if @start_step <= 7
+        maybe_run_local_ci_before_push!(committed, force: local_ci?) if run_step?(7)
 
         # 8. ensure trunk synced
-        if @start_step <= 8 && !local_ci?
+        if run_step?(8) && !local_ci?
           trunk = detect_trunk_branch
           feature = current_branch
+          branch_stack_release = branch_stack_release_branch?(feature, trunk)
+          if branch_stack_release
+            puts "Kettle-family branch stack release branch detected: #{feature}; skipping trunk sync/rebase."
+          end
           puts "Trunk branch detected: #{trunk}"
-          ensure_trunk_synced_before_push!(trunk, feature)
-        elsif @start_step <= 8
+          ensure_trunk_synced_before_push!(trunk, feature) unless branch_stack_release
+        elsif run_step?(8)
           puts "Local CI release mode: skipping remote trunk sync before publishing."
         end
 
         # 9. push branches
-        push! if @start_step <= 9 && !local_ci?
+        push! if run_step?(9) && !local_ci?
 
         # 10. monitor CI after push
-        monitor_workflows_after_push! if @start_step <= 10 && !local_ci?
+        monitor_workflows_after_push! if run_step?(10) && !local_ci?
 
         # 11. merge feature into trunk and push
-        if @start_step <= 11 && !local_ci?
+        if run_step?(11) && !local_ci?
           trunk ||= detect_trunk_branch
           feature ||= current_branch
-          merge_feature_into_trunk_and_push!(trunk, feature)
+          branch_stack_release ||= branch_stack_release_branch?(feature, trunk)
+          if branch_stack_release
+            puts "Kettle-family branch stack release branch detected: #{feature}; skipping merge into #{trunk}."
+          else
+            merge_feature_into_trunk_and_push!(trunk, feature)
+          end
         end
 
         # 12. checkout trunk and pull
-        if @start_step <= 12 && !local_ci?
+        if run_step?(12) && !local_ci?
           trunk ||= detect_trunk_branch
-          checkout!(trunk)
-          pull!(trunk)
+          feature ||= current_branch
+          branch_stack_release ||= branch_stack_release_branch?(feature, trunk)
+          if branch_stack_release
+            puts "Kettle-family branch stack release branch detected: #{feature}; staying on release branch."
+          else
+            checkout!(trunk)
+            pull!(trunk)
+          end
         end
 
         # 13. signing guidance and checks
-        if @start_step <= 13
+        if run_step?(13)
           if ENV.fetch("SKIP_GEM_SIGNING", "false").casecmp("false").zero?
             puts "TIP: For local dry-runs or testing the release workflow, set SKIP_GEM_SIGNING=true to avoid PEM password prompts."
             if Kettle::Dev::InputAdapter.tty?
@@ -267,13 +322,13 @@ module Kettle
         end
 
         # 14. build
-        if @start_step <= 14
+        if run_step?(14)
           puts "Running build (you may be prompted for the signing key password)..."
           run_cmd!("bundle exec rake build")
         end
 
         # 15. release and tag
-        if @start_step <= 15
+        if run_step?(15)
           if local_ci?
             version ||= detect_version
             release_gem_and_tag_locally!(version)
@@ -287,7 +342,7 @@ module Kettle
         #    Checksums are generated after release to avoid including checksums/ in gem package
         #    Rationale: Running gem_checksums before release may commit checksums/ and cause Bundler's
         #    release build to include them in the gem, thus altering the artifact, and invalidating the checksums.
-        if @start_step <= 16
+        if run_step?(16)
           # Generate checksums for the just-built artifact, commit them, then validate
           run_cmd!("bin/gem_checksums")
           version ||= detect_version
@@ -295,19 +350,19 @@ module Kettle
         end
 
         # 17. push checksum commit (gem_checksums already commits)
-        if @start_step <= 17
+        if run_step?(17)
           push!
           push_tags! if local_ci?
         end
 
         # 18. create GitHub release (optional)
-        if @start_step <= 18
+        if run_step?(18)
           version ||= detect_version
           maybe_create_github_release!(version)
         end
 
         # 19. push tags to remotes (final step)
-        push_tags! if @start_step <= 19 && !local_ci?
+        push_tags! if run_step?(19) && !local_ci?
 
         # Final success message
         begin
@@ -330,12 +385,72 @@ module Kettle
         abort("Unsupported appraisal task #{value.inspect}; use appraisal:generate or appraisal:update.")
       end
 
+      def normalize_skip_steps(value)
+        raw_steps = Array(value).flat_map { |part| part.to_s.split(",") }.map(&:strip).reject(&:empty?)
+        raw_steps.map do |raw|
+          abort("Invalid skip_steps value #{raw.inspect}; use comma-separated release step numbers from 0 to 19.") unless raw.match?(/\A\d+\z/)
+
+          step = raw.to_i
+          abort("Invalid skip_steps value #{raw.inspect}; release steps are numbered 0 to 19.") unless step.between?(0, 19)
+
+          step
+        end.uniq
+      end
+
       private
 
       def local_ci?
         @local_ci
       end
 
+      def run_step?(step)
+        @start_step <= step && !@skip_steps.include?(step)
+      end
+
+      def rubocop_lts_release_preflight_needed?
+        (3..5).any? { |step| run_step?(step) }
+      end
+
+      def prepare_rubocop_lts_local_branch!
+        local_root = rubocop_lts_local_root
+        return unless local_root
+
+        ruby_gem = selected_rubocop_lts_ruby_gem
+        return unless ruby_gem
+
+        branch = Kettle::Rb::CompatMatrix.rubocop_lts_branch_for_gem(ruby_gem)
+        abort("Cannot select RUBOCOP_LTS_LOCAL branch for #{ruby_gem.inspect}.") unless branch
+
+        checkout = File.join(local_root, "rubocop-lts")
+        current, ok = git_output(["-C", checkout, "branch", "--show-current"])
+        abort("Cannot inspect RUBOCOP_LTS_LOCAL checkout at #{checkout}.") unless ok
+        return if current == branch
+
+        puts "Switching RUBOCOP_LTS_LOCAL checkout #{checkout} to #{branch} for #{ruby_gem}."
+        _stdout, switched = git_output(["-C", checkout, "switch", branch])
+        abort("Cannot switch RUBOCOP_LTS_LOCAL checkout at #{checkout} to #{branch}. Commit or stash local changes, then retry.") unless switched
+      end
+
+      def rubocop_lts_local_root
+        value = ENV["RUBOCOP_LTS_LOCAL"].to_s.strip
+        return nil if value.empty? || %w[false 0 no off].include?(value.downcase)
+        return File.join(Dir.home, "src", "rubocop-lts") if %w[true 1 yes on].include?(value.downcase)
+        return value if value.start_with?("/")
+
+        File.join(Dir.home, value)
+      end
+
+      def selected_rubocop_lts_ruby_gem
+        path = File.join(@root, "gemfiles", "modular", "style_local.gemfile")
+        return nil unless File.file?(path)
+
+        content = File.read(path)
+        # This reads the generated kettle-jem style_local.gemfile declaration
+        # without evaluating the Gemfile during release preflight.
+        local_gems = content[/\blocal_gems\s*=\s*%w\[(.*?)\]/m, 1].to_s.split
+        local_gems.find { |gem_name| Kettle::Rb::CompatMatrix.rubocop_ruby_gem?(gem_name) }
+      end
+
       def run_pre_release_checks!
         puts "Running pre-release checks via kettle-pre-release..."
         Kettle::Dev::PreReleaseCLI.new(check_num: 1).run
@@ -988,6 +1103,44 @@ module Kettle
         puts "Merged #{feature} into #{trunk} and pushed. The PR (if any) should auto-close."
       end
 
+      def branch_stack_release_branch?(branch, trunk = nil)
+        return false if branch.to_s.empty?
+        return false if trunk && branch == trunk
+
+        local_kettle_family_release_target_branches.include?(branch)
+      end
+
+      def local_kettle_family_release_target_branches
+        local_kettle_family_config_paths.each do |path|
+          next unless File.file?(path)
+
+          begin
+            data = YAML.safe_load(File.read(path), permitted_classes: [], aliases: false) || {}
+            branches = Array(dig_string_keys(data, "release", "target_branches")) +
+              Array(dig_string_keys(data, "branches", "release_targets"))
+            return branches.map(&:to_s).reject(&:empty?) unless branches.empty?
+          rescue Psych::Exception => e
+            warn("Ignoring invalid kettle-family config #{Kettle::Dev.display_path(path)}: #{e.message}")
+          end
+        end
+        []
+      end
+
+      def local_kettle_family_config_paths
+        [
+          File.join(@root, ".kettle-family.yml"),
+          File.join(@root, ".structuredmerge", "kettle-family.yml")
+        ]
+      end
+
+      def dig_string_keys(data, *keys)
+        keys.reduce(data) do |memo, key|
+          break nil unless memo.is_a?(Hash)
+
+          memo[key] || memo[key.to_sym]
+        end
+      end
+
       def ensure_signing_setup_or_skip!
         # Treat any non-/true/i value as an explicit skip signal
         return if ENV.fetch("SKIP_GEM_SIGNING", "").casecmp("true").zero?

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

@@ -91,46 +91,48 @@ module Kettle
 
           # Print GitLab pipeline status (if configured) for the current branch.
           print_gitlab_status = proc do
-            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
+            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
 
-            # 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"
+              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})"
               else
-                ((st == "failed") ? "failure" : nil)
+                puts "Latest GL (#{branch}) pipeline: none"
               end
-              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"
+            rescue => e
+              puts "GL status: error #{e.class}: #{e.message}"
             end
-          rescue => e
-            puts "GL status: error #{e.class}: #{e.message}"
           end
 
           run_act_for = proc do |file_path|
@@ -262,10 +264,12 @@ module Kettle
           selected = nil
           input_thread = nil
           read_input = proc do
-            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
+            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
           end
           if tty
             input_thread = Thread.new(&read_input) # rubocop:disable ThreadSafety/NewThread
@@ -279,52 +283,54 @@ 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
-              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"
+              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
                     else
-                      status_q << [c, f, "none"]
-                      break
+                      status_q << [c, f, "fail #{res.code}"]
                     end
-                  else
-                    status_q << [c, f, "fail #{res.code}"]
+                  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__)
-                  # Catch all exceptions to prevent crashing the process from a worker thread
-                  status_q << [c, f, "err"]
+                  sleep(poll_interval)
                 end
-                sleep(poll_interval)
+              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
-            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.19"
+      VERSION = "2.2.21"
     end
     VERSION = Version::VERSION # Traditional Constant Location
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kettle-dev
 version: !ruby/object:Gem::Version
-  version: 2.2.19
+  version: 2.2.21
 platform: ruby
 authors:
 - Peter H. Boling
@@ -37,6 +37,26 @@ cert_chain:
   -----END CERTIFICATE-----
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: kettle-rb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.0
 - !ruby/object:Gem::Dependency
   name: kettle-test
   requirement: !ruby/object:Gem::Requirement
@@ -339,10 +359,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.19
-  changelog_uri: https://github.com/kettle-dev/kettle-dev/blob/v2.2.19/CHANGELOG.md
+  source_code_uri: https://github.com/kettle-dev/kettle-dev/tree/v2.2.21
+  changelog_uri: https://github.com/kettle-dev/kettle-dev/blob/v2.2.21/CHANGELOG.md
   bug_tracker_uri: https://github.com/kettle-dev/kettle-dev/issues
-  documentation_uri: https://www.rubydoc.info/gems/kettle-dev/2.2.19
+  documentation_uri: https://www.rubydoc.info/gems/kettle-dev/2.2.21
   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