kettle-dev 1.1.4 → 1.1.5

data/exe/kettle-commit-msg

@@ -5,8 +5,15 @@
 
 # Immediate, unbuffered output
 $stdout.sync = true
-# Depending library or project must be using bundler
-require "bundler/setup"
+$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__)
 
@@ -14,11 +21,18 @@ begin
   # Standard library
   require "erb"
 
-  require "kettle/dev"
+  begin
+    require "kettle/dev"
+  rescue LoadError
+    # Fallback: allow running from a checkout without bundler by adding ./lib to the load path
+    repo_lib = File.expand_path("../lib", __dir__)
+    $LOAD_PATH.unshift(repo_lib) unless $LOAD_PATH.include?(repo_lib)
+    require "kettle/dev"
+  end
   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.")
+  warn("Hint: Install the kettle-dev gem (`gem install kettle-dev`) or add it to your Gemfile. Bundler is not required for this script.")
   exit(1)
 end
 
@@ -28,7 +42,8 @@ end
 BRANCH_RULES = {
   "jira" => /^(?<story_type>(hotfix)|(bug)|(feature)|(candy))\/(?<story_id>\d{8,})-.+\Z/,
 }
-BRANCH_RULE_TYPE = (validate = ENV.fetch("GIT_HOOK_BRANCH_VALIDATE", "false")) && !validate.casecmp?("false") && validate
+# Ruby 2.3 compatibility: String#casecmp? is not available; use casecmp.zero?
+BRANCH_RULE_TYPE = (validate = ENV.fetch("GIT_HOOK_BRANCH_VALIDATE", "false")) && !(validate.respond_to?(:casecmp?) ? validate.casecmp?("false") : (validate.casecmp("false").zero?)) && validate
 
 # Called the "JIRA pattern", because of traditional use with JIRA.
 if (branch_rule = BRANCH_RULES[BRANCH_RULE_TYPE])

data/exe/kettle-dev-setup

@@ -71,6 +71,7 @@ module Kettle
           opts.on("--allowed=VAL", "Pass through to kettle:dev:install") { |v| @passthrough << "allowed=#{v}" }
           opts.on("--force", "Pass through to kettle:dev:install") { @passthrough << "force=true" }
           opts.on("--hook_templates=VAL", "Pass through to kettle:dev:install") { |v| @passthrough << "hook_templates=#{v}" }
+          opts.on("--only=VAL", "Pass through to kettle:dev:install") { |v| @passthrough << "only=#{v}" }
           opts.on("-h", "--help", "Show help") do
             puts opts
             exit(0)
@@ -165,7 +166,7 @@ module Kettle
         modified = target.dup
         wanted.each do |gem_name, desired_line|
           # Replace existing add_development_dependency for this gem, else append near the end
-          if modified.match?(/add_development_dependency\s*\(\s*["']#{Regexp.escape(gem_name)}["']/)
+          if /add_development_dependency\s*\(\s*["']#{Regexp.escape(gem_name)}["']/ =~ modified
             modified = modified.gsub(/^[^\n]*add_development_dependency\s*\(\s*["']#{Regexp.escape(gem_name)}["'][^\n]*\)$/) do |_|
               desired_line
             end

data/exe/kettle-dvcs

@@ -11,8 +11,13 @@
 $stdout.sync = true
 $stderr.sync = true
 
-# Depending library or project must be using bundler
-require "bundler/setup"
+# 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__)
 

data/exe/kettle-pre-release

@@ -0,0 +1,66 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# vim: set syntax=ruby
+
+# kettle-pre-release: Run pre-release checks to catch avoidable mistakes.
+# - Structured as a sequence of checks that can be resumed via check_num
+# - Initial check: validate all image URLs referenced by Markdown files resolve (HTTP HEAD)
+
+require "optparse"
+
+# 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 StandardError => 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
+
+# Option parsing
+options = {
+  check_num: 1,
+}
+
+parser = OptionParser.new do |opts|
+  opts.banner = "Usage: kettle-pre-release [options]"
+  opts.on("--check-num N", Integer, "Start from check number N (1-based)") { |v| options[:check_num] = v }
+  opts.on("-cN", Integer, "Alias for --check-num N") { |v| options[:check_num] = v }
+  opts.on("-h", "--help", "Show this help") do
+    puts opts
+    puts
+    puts "Checks:"
+    puts "  1) Validate Markdown image links (HTTP HEAD)"
+    exit(0)
+  end
+end
+
+begin
+  parser.parse!(ARGV)
+rescue OptionParser::ParseError => e
+  warn("#{script_basename}: #{e.message}")
+  puts parser
+  exit(2)
+end
+
+# Execute
+# Build and run CLI in the same style as kettle-release
+cli = Kettle::Dev::PreReleaseCLI.new(check_num: options[:check_num])
+cli.run
+
+puts "== #{script_basename} complete =="

data/exe/kettle-readme-backers

@@ -5,8 +5,13 @@
 
 # Immediate, unbuffered output
 $stdout.sync = true
-# Depending library or project must be using bundler
-require "bundler/setup"
+# 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__)
 

data/exe/kettle-release

@@ -16,8 +16,15 @@
 
 # Immediate, unbuffered output
 $stdout.sync = true
-# Depending library or project must be using bundler
-require "bundler/setup"
+$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__)
 

data/lib/kettle/dev/changelog_cli.rb

@@ -3,6 +3,7 @@
 module Kettle
   module Dev
     class ChangelogCLI
+      UNRELEASED_SECTION_HEADING = "[Unreleased]:"
       def initialize
         @root = Kettle::Dev::CIHelpers.project_root
         @changelog_path = File.join(@root, "CHANGELOG.md")
@@ -70,7 +71,7 @@ module Kettle
         if after && !after.empty?
           # Split 'after' by lines so we can locate the first link-ref to Unreleased
           after_lines = after.lines
-          unreleased_ref_idx = after_lines.index { |l| l.start_with?("[Unreleased]:") }
+          unreleased_ref_idx = after_lines.index { |l| l.start_with?(UNRELEASED_SECTION_HEADING) }
           if unreleased_ref_idx
             # Keep all content prior to the link-ref (older releases and interspersed refs)
             preserved_body = after_lines[0...unreleased_ref_idx].join
@@ -96,8 +97,6 @@ module Kettle
 
       def abort(msg)
         Kettle::Dev::ExitAdapter.abort(msg)
-      rescue NameError
-        Kernel.abort(msg)
       end
 
       def detect_version
@@ -260,7 +259,7 @@ module Kettle
         # Identify the true start of the footer reference block: the line with the [Unreleased] link-ref.
         # Do NOT assume the first link-ref after the Unreleased heading starts the footer, because
         # some changelogs contain interspersed link-refs within section bodies.
-        unreleased_ref_idx = lines.index { |l| l.start_with?("[Unreleased]:") }
+        unreleased_ref_idx = lines.index { |l| l.start_with?(UNRELEASED_SECTION_HEADING) }
         first_ref = if unreleased_ref_idx
           unreleased_ref_idx
         else
@@ -274,7 +273,7 @@ module Kettle
           # Update an existing Unreleased ref only if it appears after Unreleased heading; otherwise append
           idx = nil
           lines.each_with_index do |l, i|
-            if l.start_with?("[Unreleased]:") && i >= first_ref
+            if l.start_with?(UNRELEASED_SECTION_HEADING) && i >= first_ref
               idx = i
               break
             end

data/lib/kettle/dev/ci_helpers.rb

@@ -115,7 +115,8 @@ module Kettle
           "html_url" => run["html_url"],
           "id" => run["id"],
         }
-      rescue StandardError
+      rescue StandardError => e
+        Kettle::Dev.debug_error(e, __method__)
         nil
       end
 
@@ -185,8 +186,9 @@ module Kettle
         res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
         return unless res.is_a?(Net::HTTPSuccess)
         data = JSON.parse(res.body)
-        pipe = data&.first
-        return unless pipe
+        return unless data.is_a?(Array)
+        pipe = data.first
+        return unless pipe.is_a?(Hash)
         # Attempt to enrich with failure_reason by querying the single pipeline endpoint
         begin
           if pipe["id"]
@@ -202,7 +204,8 @@ module Kettle
               pipe["web_url"] = det["web_url"] if det["web_url"]
             end
           end
-        rescue StandardError
+        rescue StandardError => e
+          Kettle::Dev.debug_error(e, __method__)
           # ignore enrichment errors; fall back to basic fields
         end
         {
@@ -211,7 +214,8 @@ module Kettle
           "id" => pipe["id"],
           "failure_reason" => pipe["failure_reason"],
         }
-      rescue StandardError
+      rescue StandardError => e
+        Kettle::Dev.debug_error(e, __method__)
         nil
       end
 

data/lib/kettle/dev/ci_monitor.rb

@@ -21,8 +21,28 @@ module Kettle
       end
       module_function :abort
 
+      # Small helper to map CI run status/conclusion to an emoji.
+      # Reused by ci:act and release summary.
+      # @param status [String, nil]
+      # @param conclusion [String, nil]
+      # @return [String]
+      def status_emoji(status, conclusion)
+        case status.to_s
+        when "queued" then "⏳️"
+        when "in_progress", "running" then "👟"
+        when "completed"
+          (conclusion.to_s == "success") ? "✅" : "🍅"
+        else
+          # Some APIs report only a final state string like "success"/"failed"
+          return "✅" if conclusion.to_s == "success" || status.to_s == "success"
+          return "🍅" if conclusion.to_s == "failure" || status.to_s == "failed"
+          "⏳️"
+        end
+      end
+      module_function :status_emoji
+
       # Monitor both GitHub and GitLab CI for the current project/branch.
-      # This mirrors ReleaseCLI behavior.
+      # This mirrors ReleaseCLI behavior and aborts on first failure.
       #
       # @param restart_hint [String] guidance command shown on failure
       # @return [void]
@@ -33,16 +53,217 @@ module Kettle
         abort("CI configuration not detected (GitHub or GitLab). Ensure CI is configured and remotes point to the correct hosts.") unless checks_any
       end
 
-      # Monitor only the GitLab pipeline for current project/branch.
-      # Used by ci:act after running 'act'.
-      #
-      # @param restart_hint [String] guidance command shown on failure
-      # @return [Boolean] true if check performed (gitlab configured), false otherwise
-      def monitor_gitlab!(restart_hint: "bundle exec rake ci:act")
+      # Public wrapper to monitor GitLab pipeline with abort-on-failure semantics.
+      # Matches RBS and call sites expecting ::monitor_gitlab!
+      # Returns false when GitLab is not configured for this repo/branch.
+      # @param restart_hint [String]
+      # @return [Boolean]
+      def monitor_gitlab!(restart_hint: "bundle exec kettle-release start_step=10")
         monitor_gitlab_internal!(restart_hint: restart_hint)
       end
+      module_function :monitor_gitlab!
+
+      # Non-aborting collection across GH and GL, returning a compact results hash.
+      # Results format:
+      #   {
+      #     github: [ {workflow: "file.yml", status: "completed", conclusion: "success"|"failure"|nil, url: String} ],
+      #     gitlab: { status: "success"|"failed"|"blocked"|"unknown"|nil, url: String }
+      #   }
+      # @return [Hash]
+      def collect_all
+        results = {github: [], gitlab: nil}
+        begin
+          gh = collect_github
+          results[:github] = gh if gh
+        rescue StandardError => e
+          Kettle::Dev.debug_error(e, __method__)
+        end
+        begin
+          gl = collect_gitlab
+          results[:gitlab] = gl if gl
+        rescue StandardError => e
+          Kettle::Dev.debug_error(e, __method__)
+        end
+        results
+      end
+      module_function :collect_all
+
+      # Print a concise summary like ci:act and return whether everything is green.
+      # @param results [Hash]
+      # @return [Boolean] true when all checks passed or were unknown, false when any failed
+      def summarize_results(results)
+        all_ok = true
+        gh_items = results[:github] || []
+        unless gh_items.empty?
+          puts "GitHub Actions:"
+          gh_items.each do |it|
+            emoji = status_emoji(it[:status], it[:conclusion])
+            details = [it[:status], it[:conclusion]].compact.join("/")
+            wf = it[:workflow]
+            puts "  - #{wf}: #{emoji} (#{details}) #{it[:url] ? "-> #{it[:url]}" : ""}"
+            all_ok &&= (it[:conclusion] == "success")
+          end
+        end
+        gl = results[:gitlab]
+        if gl
+          status = if gl[:status] == "success"
+            "success"
+          else
+            ((gl[:status] == "failed") ? "failure" : nil)
+          end
+          emoji = status_emoji(gl[:status], status)
+          details = gl[:status].to_s
+          puts "GitLab Pipeline: #{emoji} (#{details}) #{gl[:url] ? "-> #{gl[:url]}" : ""}"
+          all_ok &&= (gl[:status] != "failed")
+        end
+        all_ok
+      end
+      module_function :summarize_results
+
+      # Prompt user to continue or quit when failures are present; otherwise return.
+      # Designed for kettle-release.
+      # @param restart_hint [String]
+      # @return [void]
+      def monitor_and_prompt_for_release!(restart_hint: "bundle exec kettle-release start_step=10")
+        results = collect_all
+        any_checks = !(results[:github].nil? || results[:github].empty?) || !!results[:gitlab]
+        abort("CI configuration not detected (GitHub or GitLab). Ensure CI is configured and remotes point to the correct hosts.") unless any_checks
+
+        ok = summarize_results(results)
+        return if ok
+
+        # Non-interactive environments default to quitting unless explicitly allowed
+        env_val = ENV.fetch("K_RELEASE_CI_CONTINUE", "false")
+        non_interactive_continue = !!(Kettle::Dev::ENV_TRUE_RE =~ env_val)
+        if !$stdin.tty?
+          abort("CI checks reported failures. Fix and restart from CI validation (#{restart_hint}).") unless non_interactive_continue
+          puts "CI checks reported failures, but continuing due to K_RELEASE_CI_CONTINUE=true."
+          return
+        end
+
+        # Prompt exactly once; avoid repeated printing in case of unexpected input buffering.
+        # Accept c/continue to proceed or q/quit to abort. Any other input defaults to quit with a message.
+        print("One or more CI checks failed. (c)ontinue or (q)uit? ")
+        ans = Kettle::Dev::InputAdapter.gets
+        if ans.nil?
+          abort("Aborting (no input available). Fix CI, then restart with: #{restart_hint}")
+        end
+        ans = ans.strip.downcase
+        if ans == "c" || ans == "continue"
+          puts "Continuing release despite CI failures."
+        elsif ans == "q" || ans == "quit"
+          abort("Aborting per user choice. Fix CI, then restart with: #{restart_hint}")
+        else
+          abort("Unrecognized input '#{ans}'. Aborting. Fix CI, then restart with: #{restart_hint}")
+        end
+      end
+      module_function :monitor_and_prompt_for_release!
+
+      # --- Collectors ---
+      def collect_github
+        root = Kettle::Dev::CIHelpers.project_root
+        workflows = Kettle::Dev::CIHelpers.workflows_list(root)
+        gh_remote = preferred_github_remote
+        return unless gh_remote && !workflows.empty?
+
+        branch = Kettle::Dev::CIHelpers.current_branch
+        abort("Could not determine current branch for CI checks.") unless branch
+
+        url = remote_url(gh_remote)
+        owner, repo = parse_github_owner_repo(url)
+        return unless owner && repo
+
+        total = workflows.size
+        return [] if total.zero?
+
+        puts "Checking GitHub Actions workflows on #{branch} (#{owner}/#{repo}) via remote '#{gh_remote}'"
+        pbar = if defined?(ProgressBar)
+          ProgressBar.create(title: "GHA", total: total, format: "%t %b %c/%C", length: 30)
+        end
+        # Initial sleep same as aborting path
+        begin
+          initial_sleep = Integer(ENV["K_RELEASE_CI_INITIAL_SLEEP"])
+        rescue
+          initial_sleep = nil
+        end
+        sleep((initial_sleep && initial_sleep >= 0) ? initial_sleep : 3)
+
+        results = {}
+        idx = 0
+        loop do
+          wf = workflows[idx]
+          run = Kettle::Dev::CIHelpers.latest_run(owner: owner, repo: repo, workflow_file: wf, branch: branch)
+          if run
+            if Kettle::Dev::CIHelpers.success?(run)
+              unless results[wf]
+                status = run["status"] || "completed"
+                conclusion = run["conclusion"] || "success"
+                results[wf] = {workflow: wf, status: status, conclusion: conclusion, url: run["html_url"]}
+                pbar&.increment
+              end
+            elsif Kettle::Dev::CIHelpers.failed?(run)
+              unless results[wf]
+                results[wf] = {workflow: wf, status: run["status"], conclusion: run["conclusion"] || "failure", url: run["html_url"] || "https://github.com/#{owner}/#{repo}/actions/workflows/#{wf}"}
+                pbar&.increment
+              end
+            end
+          end
+          break if results.size == total
+          idx = (idx + 1) % total
+          sleep(1)
+        end
+        pbar&.finish unless pbar&.finished?
+        results.values
+      end
+      module_function :collect_github
+
+      def collect_gitlab
+        root = Kettle::Dev::CIHelpers.project_root
+        gitlab_ci = File.exist?(File.join(root, ".gitlab-ci.yml"))
+        gl_remote = gitlab_remote_candidates.first
+        return unless gitlab_ci && gl_remote
+
+        branch = Kettle::Dev::CIHelpers.current_branch
+        abort("Could not determine current branch for CI checks.") unless branch
+
+        owner, repo = Kettle::Dev::CIHelpers.repo_info_gitlab
+        return unless owner && repo
+
+        puts "Checking GitLab pipeline on #{branch} (#{owner}/#{repo}) via remote '#{gl_remote}'"
+        pbar = if defined?(ProgressBar)
+          ProgressBar.create(title: "GL", total: 1, format: "%t %b %c/%C", length: 30)
+        end
+        result = {status: "unknown", url: nil}
+        loop do
+          pipe = Kettle::Dev::CIHelpers.gitlab_latest_pipeline(owner: owner, repo: repo, branch: branch)
+          if pipe
+            result[:url] ||= pipe["web_url"] || "https://gitlab.com/#{owner}/#{repo}/-/pipelines"
+            if Kettle::Dev::CIHelpers.gitlab_success?(pipe)
+              result[:status] = "success"
+              pbar&.increment unless pbar&.finished?
+            elsif Kettle::Dev::CIHelpers.gitlab_failed?(pipe)
+              reason = (pipe["failure_reason"] || "").to_s
+              if reason =~ /insufficient|quota|minute/i
+                result[:status] = "unknown"
+                pbar&.finish unless pbar&.finished?
+              else
+                result[:status] = "failed"
+                pbar&.increment unless pbar&.finished?
+              end
+            elsif pipe["status"] == "blocked"
+              result[:status] = "blocked"
+              pbar&.finish unless pbar&.finished?
+            end
+            break
+          end
+          sleep(1)
+        end
+        pbar&.finish unless pbar&.finished?
+        result
+      end
+      module_function :collect_gitlab
 
-      # -- internals --
+      # -- internals (abort-on-failure legacy paths used elsewhere) --
 
       def monitor_github_internal!(restart_hint:)
         root = Kettle::Dev::CIHelpers.project_root