kettle-dev 2.4.5 → 2.5.0

data/lib/kettle/dev/changelog_cli.rb

@@ -27,7 +27,8 @@ module Kettle
       # @param enforce_coverage_thresholds [Boolean] when true, fail strict coverage generation below project thresholds
       # @param update_prep [Boolean] when true, update the most recent prepared release section in place
       # @param version [String, nil] explicit version override for gems without a literal VERSION constant
-      def initialize(strict: true, enforce_coverage_thresholds: true, update_prep: false, version: nil, root: Kettle::Dev::CIHelpers.project_root, refresh_cache: false)
+      # @param yes [Boolean] when true, approve the selected release plan without prompting
+      def initialize(strict: true, enforce_coverage_thresholds: true, update_prep: false, version: nil, root: Kettle::Dev::CIHelpers.project_root, refresh_cache: false, yes: false)
         @root = root
         @changelog_path = File.join(@root, "CHANGELOG.md")
         @coverage_path = File.join(@root, "coverage", "coverage.json")
@@ -36,6 +37,7 @@ module Kettle
         @update_prep = update_prep
         @version_override = Kettle::Dev::Versioning.normalize_explicit_version(version)
         @refresh_cache = refresh_cache
+        @yes = !!yes
       end
 
       # Main entry point to update CHANGELOG.md
@@ -250,8 +252,8 @@ module Kettle
         branch = default_branch_ref
         return nil unless tag && branch
 
-        stdout, _stderr, status = Open3.capture3("git", "rev-list", "--count", "#{tag}..#{branch}", chdir: @root)
-        status.success? ? stdout.to_i : nil
+        stdout, ok = git_capture(["rev-list", "--count", "#{tag}..#{branch}"])
+        ok ? stdout.to_i : nil
       end
 
       def release_tag_for_version(version)
@@ -261,15 +263,15 @@ module Kettle
       end
 
       def default_branch_ref
-        stdout, _stderr, status = Open3.capture3("git", "symbolic-ref", "--quiet", "--short", "refs/remotes/origin/HEAD", chdir: @root)
-        return stdout.strip if status.success? && !stdout.strip.empty?
+        stdout, ok = git_capture(["symbolic-ref", "--quiet", "--short", "refs/remotes/origin/HEAD"])
+        return stdout.strip if ok && !stdout.strip.empty?
 
         %w[main master HEAD].find { |ref| git_ref_exists?(ref) }
       end
 
       def git_ref_exists?(ref)
-        _stdout, _stderr, status = Open3.capture3("git", "rev-parse", "--verify", "--quiet", ref, chdir: @root)
-        status.success?
+        _stdout, ok = git_capture(["rev-parse", "--verify", "--quiet", ref])
+        ok
       end
 
       def detect_plan(changelog, version)
@@ -280,7 +282,7 @@ module Kettle
           gem_name = detect_gem_name
           latest_overall, latest_for_series = latest_released_versions(gem_name, version)
         rescue => e
-          warn("[kettle-changelog] gem.coop release check failed: #{e.class}: #{e.message}")
+          warn("[kettle-changelog] RubyGems.org release check failed: #{e.class}: #{e.message}")
           warn("Proceeding without live release info.")
         end
 
@@ -345,6 +347,11 @@ module Kettle
         puts "  latest released for current series: #{plan.fetch(:latest_for_series) || "unknown"}"
         puts "  latest CHANGELOG.md release: #{plan.fetch(:latest_changelog_version) || "none"}"
         puts "  gem: #{plan.fetch(:gem_name) || "unknown"}"
+        if @yes
+          puts("Continue with this plan? [y/N]: y")
+          return
+        end
+
         print("Continue with this plan? [y/N]: ")
         ans = Kettle::Dev::InputAdapter.gets&.strip&.downcase
         return if ans == "y" || ans == "yes"
@@ -400,7 +407,7 @@ module Kettle
       end
 
       def latest_released_versions(gem_name, current_version)
-        data = Kettle::Dev::GemCoopVersions.fetch(gem_name, version_hint: current_version, refresh: @refresh_cache)
+        data = Kettle::Dev::RubyGemsVersions.fetch(gem_name, version_hint: current_version, refresh: @refresh_cache)
         return [nil, nil, nil] unless data.is_a?(Array)
 
         versions = data.map { |h| h["number"] }.compact
@@ -736,7 +743,7 @@ module Kettle
           "K_SOUP_COV_DO" => "true",
           "K_SOUP_COV_FORMATTERS" => "json",
           "K_SOUP_COV_MIN_HARD" => @enforce_coverage_thresholds ? "true" : "false",
-          "K_SOUP_COV_MULTI_FORMATTERS" => "true",
+          "K_SOUP_COV_MULTI_FORMATTERS" => "false",
           "K_SOUP_COV_OPEN_BIN" => ""
         }
       end
@@ -766,30 +773,59 @@ module Kettle
           end
         end
 
-        begin
-          # Run the canonical docs task to get the documentation percentage.
-          out = +""
-          commands.each do |command|
-            prepare_yard_fence_tmp_files if command == [File.join(@root, "bin", "yard")]
-            output, _status = Open3.capture2(*command, {chdir: @root})
-            out << output
-            line = documented_percent_line(output)
-            return line if line
+        # Run the canonical docs task to get the documentation percentage.
+        commands.each do |command|
+          prepare_yard_fence_tmp_files if command == [File.join(@root, "bin", "yard")]
+          output, status = capture_yard_command(command)
+          unless command_successful?(status)
+            return handle_yard_documentation_failure(yard_command_failure_message(command, output, status))
           end
+          line = documented_percent_line(output)
+          return line if line
+        end
 
-          if @strict
-            raise "Could not find documented percentage in bin/rake yard output"
-          else
-            warn("Could not find documented percentage in bin/rake yard output.")
-            nil
-          end
-        rescue => e
-          if @strict
-            raise "Failed to run bin/rake yard: #{e.class}: #{e.message}"
-          else
-            warn("Failed to run bin/rake yard: #{e.class}: #{e.message}")
-            nil
-          end
+        handle_yard_documentation_failure("Could not find documented percentage in YARD output")
+      end
+
+      def capture_yard_command(command)
+        Open3.capture2e(*command, {chdir: @root})
+      rescue => e
+        ["#{e.class}: #{e.message}", false]
+      end
+
+      def handle_yard_documentation_failure(message)
+        if @strict
+          raise message
+        else
+          warn(message)
+          nil
+        end
+      end
+
+      def command_successful?(status)
+        return status if status == true || status == false
+
+        !status.respond_to?(:success?) || status.success?
+      end
+
+      def yard_command_failure_message(command, output, status)
+        exit_status = status.respond_to?(:exitstatus) ? status.exitstatus : nil
+        message = "Failed to run #{yard_command_label(command)}"
+        message = "#{message} (exit #{exit_status})" if exit_status
+        output = output.to_s.strip
+        message = "#{message}: #{output}" unless output.empty?
+        message
+      end
+
+      def yard_command_label(command)
+        command = Array(command)
+        bin = command.first.to_s
+        if bin == File.join(@root, "bin", "rake")
+          "bin/rake #{command.drop(1).join(" ")}".strip
+        elsif bin == File.join(@root, "bin", "yard")
+          "bin/yard"
+        else
+          command.join(" ")
         end
       end
 
@@ -1111,13 +1147,16 @@ module Kettle
       # Return the root commit SHA of the current repository, or nil on failure.
       # Uses the generic GitAdapter#capture escape hatch so tests can stub it.
       def git_root_commit
-        adapter = Kettle::Dev::GitAdapter.new
-        out, ok = adapter.capture(["rev-list", "--max-parents=0", "HEAD"])
+        out, ok = git_capture(["rev-list", "--max-parents=0", "HEAD"])
         sha = out.to_s.lines.last&.strip   # take last line in case of multiple root commits
         (ok && sha && !sha.empty?) ? sha : nil
       rescue
         nil
       end
+
+      def git_capture(args)
+        Kettle::Dev::GitAdapter.new(@root).capture(args)
+      end
     end
   end
 end

data/lib/kettle/dev/ci_monitor.rb

@@ -267,8 +267,6 @@ module Kettle
       end
       module_function :collect_gitlab
 
-      # -- internals (abort-on-failure legacy paths used elsewhere) --
-
       def monitor_github_internal!(restart_hint:, workflows: nil)
         root = Kettle::Dev::CIHelpers.project_root
         workflows = Array(workflows).empty? ? Kettle::Dev::CIHelpers.workflows_list(root) : Array(workflows)

data/lib/kettle/dev/dvcs_cli.rb

@@ -22,10 +22,11 @@ module Kettle
     # - Creates an "all" remote that fetches from origin only and pushes to all three forges
     # - Attempts to fetch from each forge to determine availability and updates README federation summary
     #
-    # @example Non-interactive run with defaults (origin: github, protocol: ssh)
+    # Examples:
+    #   Non-interactive run with defaults (origin: github, protocol: ssh)
     #   kettle-dvcs --force my-org my-repo
     #
-    # @example Use GitLab as origin and HTTPS URLs
+    #   Use GitLab as origin and HTTPS URLs
     #   kettle-dvcs --origin gitlab --protocol https my-org my-repo
     class DvcsCLI
       DEFAULTS = {

data/lib/kettle/dev/executable_version.rb

@@ -14,7 +14,9 @@ module Kettle
         exit(0)
       end
 
-      def print_header(script_basename)
+      def print_header(script_basename, argv = ARGV)
+        return unless consume_verbose!(argv)
+
         puts header(script_basename)
       end
 
@@ -22,6 +24,18 @@ module Kettle
         "== #{script_basename} v#{Kettle::Dev::Version::VERSION} =="
       end
 
+      def verbose?(argv)
+        argv.any? { |arg| arg == "--verbose" }
+      end
+
+      def consume_verbose!(argv)
+        index = argv.index("--verbose")
+        return false unless index
+
+        argv.delete_at(index)
+        true
+      end
+
       def requested?(argv, value_option: false)
         argv.each_with_index.any? do |arg, index|
           arg == "-v" || bare_long_version?(argv, arg, index, value_option: value_option)

data/lib/kettle/dev/git_adapter.rb

@@ -28,7 +28,7 @@ module Kettle
             false
           end
         else
-          out, st = Open3.capture2("git", "status", "--porcelain")
+          out, st = git_capture2("status", "--porcelain")
           st.success? && out.strip.empty?
         end
       rescue => e
@@ -43,16 +43,106 @@ module Kettle
       # @param args [Array<String>]
       # @return [Array<(String, Boolean)>] [output, success]
       def capture(args)
-        out, status = Open3.capture2("git", *args)
+        out, status = git_capture2(*args)
         [out.strip, status.success?]
       rescue => e
         Kettle::Dev.debug_error(e, __method__)
         ["", false]
       end
 
+      # Stage all changes in the repository.
+      #
+      # @return [Boolean]
+      def add_all
+        git_system("add", "-A")
+      rescue => e
+        Kettle::Dev.debug_error(e, __method__)
+        false
+      end
+
+      # Stage selected paths.
+      #
+      # @param paths [Array<String>]
+      # @return [Boolean]
+      def add_paths(paths)
+        git_system("add", "--", *Array(paths).map(&:to_s))
+      rescue => e
+        Kettle::Dev.debug_error(e, __method__)
+        false
+      end
+
+      # Commit all staged/tracked changes with a message.
+      #
+      # @param message [String]
+      # @return [Boolean]
+      def commit_all(message)
+        git_system("commit", "-am", message.to_s)
+      rescue => e
+        Kettle::Dev.debug_error(e, __method__)
+        false
+      end
+
+      # Amend the current commit without changing its message.
+      #
+      # @return [Boolean]
+      def commit_amend_no_edit
+        git_system("commit", "--amend", "--no-edit")
+      rescue => e
+        Kettle::Dev.debug_error(e, __method__)
+        false
+      end
+
+      # Return whether a tracked path has no unstaged changes.
+      #
+      # @param path [String]
+      # @return [Boolean]
+      def diff_quiet?(path)
+        _out, status = git_capture2("diff", "--quiet", "--", path.to_s)
+        status.success?
+      rescue => e
+        Kettle::Dev.debug_error(e, __method__)
+        false
+      end
+
+      # Return whether a tracked path has no changes compared with HEAD.
+      #
+      # @param path [String]
+      # @return [Boolean]
+      def diff_head_quiet?(path)
+        _out, status = git_capture2("diff", "--quiet", "HEAD", "--", path.to_s)
+        status.success?
+      rescue => e
+        Kettle::Dev.debug_error(e, __method__)
+        false
+      end
+
+      # Create an annotated tag.
+      #
+      # @param tag [String]
+      # @param message [String]
+      # @return [Boolean]
+      def tag_annotated(tag, message)
+        git_system("tag", "-a", tag.to_s, "-m", message.to_s)
+      rescue => e
+        Kettle::Dev.debug_error(e, __method__)
+        false
+      end
+
+      # Soft reset to a ref.
+      #
+      # @param ref [String]
+      # @return [Boolean]
+      def reset_soft(ref)
+        git_system("reset", "--soft", ref.to_s)
+      rescue => e
+        Kettle::Dev.debug_error(e, __method__)
+        false
+      end
+
       # Create a new adapter rooted at the current working directory.
       # @return [void]
-      def initialize
+      def initialize(root = Dir.pwd)
+        @root = File.expand_path(root.to_s)
         # 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"]
@@ -63,7 +153,7 @@ module Kettle
         else
           Kernel.require "git"
           @backend = :gem
-          @git = ::Git.open(Dir.pwd)
+          @git = ::Git.open(@root)
         end
       rescue LoadError => e
         Kettle::Dev.debug_error(e, __method__, backtrace: false)
@@ -118,14 +208,14 @@ module Kettle
           # The ruby-git gem does not expose a dedicated API for "--tags" consistently across versions.
           # Use a shell fallback even when the gem backend is active. Tests should stub this method.
           if remote && !remote.to_s.empty?
-            system("git", "push", remote.to_s, "--tags")
+            git_system("push", remote.to_s, "--tags")
           else
-            system("git", "push", "--tags")
+            git_system("push", "--tags")
           end
         elsif remote && !remote.to_s.empty?
-          system("git", "push", remote.to_s, "--tags")
+          git_system("push", remote.to_s, "--tags")
         else
-          system("git", "push", "--tags")
+          git_system("push", "--tags")
         end
       rescue => e
         Kettle::Dev.debug_error(e, __method__)
@@ -137,7 +227,7 @@ module Kettle
         if @backend == :gem
           @git.current_branch
         else
-          out, status = Open3.capture2("git", "rev-parse", "--abbrev-ref", "HEAD")
+          out, status = git_capture2("rev-parse", "--abbrev-ref", "HEAD")
           status.success? ? out.strip : nil
         end
       rescue => e
@@ -157,7 +247,7 @@ module Kettle
             []
           end
         else
-          out, status = Open3.capture2("git", "ls-files")
+          out, status = git_capture2("ls-files")
           status.success? ? out.split(/\r?\n/).reject(&:empty?) : []
         end
       rescue => e
@@ -174,7 +264,7 @@ module Kettle
       # @param path [String] path to the file, relative to the repository root
       # @return [String] raw porcelain blame output, or "" on error / untracked file
       def blame_porcelain(path)
-        out, status = Open3.capture2("git", "blame", "--porcelain", path.to_s)
+        out, status = git_capture2("blame", "--porcelain", path.to_s)
         status.success? ? out : ""
       rescue => e
         Kettle::Dev.debug_error(e, __method__)
@@ -186,7 +276,7 @@ module Kettle
         if @backend == :gem
           @git.remotes.map(&:name)
         else
-          out, status = Open3.capture2("git", "remote")
+          out, status = git_capture2("remote")
           status.success? ? out.split(/\r?\n/).map(&:strip).reject(&:empty?) : []
         end
       rescue => e
@@ -206,7 +296,7 @@ module Kettle
             end
           end
         else
-          out, status = Open3.capture2("git", "remote", "-v")
+          out, status = git_capture2("remote", "-v")
           return {} unless status.success?
 
           urls = {}
@@ -230,7 +320,7 @@ module Kettle
           r = @git.remotes.find { |x| x.name == name }
           r&.url
         else
-          out, status = Open3.capture2("git", "config", "--get", "remote.#{name}.url")
+          out, status = git_capture2("config", "--get", "remote.#{name}.url")
           status.success? ? out.strip : nil
         end
       rescue => e
@@ -246,7 +336,7 @@ module Kettle
           @git.checkout(branch)
           true
         else
-          system("git", "checkout", branch.to_s)
+          git_system("checkout", branch.to_s)
         end
       rescue => e
         Kettle::Dev.debug_error(e, __method__)
@@ -262,7 +352,7 @@ module Kettle
           @git.pull(remote, branch)
           true
         else
-          system("git", "pull", remote.to_s, branch.to_s)
+          git_system("pull", remote.to_s, branch.to_s)
         end
       rescue => e
         Kettle::Dev.debug_error(e, __method__)
@@ -282,14 +372,32 @@ module Kettle
           end
           true
         elsif ref
-          system("git", "fetch", remote.to_s, ref.to_s)
+          git_system("fetch", remote.to_s, ref.to_s)
         else
-          system("git", "fetch", remote.to_s)
+          git_system("fetch", remote.to_s)
         end
       rescue => e
         Kettle::Dev.debug_error(e, __method__)
         false
       end
+
+      private
+
+      def git_capture2(*args)
+        if @root == Dir.pwd
+          Open3.capture2("git", *args)
+        else
+          Open3.capture2("git", *args, chdir: @root)
+        end
+      end
+
+      def git_system(*args)
+        if @root == Dir.pwd
+          system("git", *args)
+        else
+          system("git", *args, chdir: @root)
+        end
+      end
     end
   end
 end

data/lib/kettle/dev/interactive_release_command.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require "open3"
+
+module Kettle
+  module Dev
+    class InteractiveReleaseCommand
+      def initialize(secrets_provider:, input: $stdin, output: $stdout, error: $stderr)
+        @secrets_provider = secrets_provider
+        @input = input
+        @output = output
+        @error = error
+        @gem_signing_passphrase = nil
+      end
+
+      def call(env, cmd)
+        return call_with_pty(env, cmd) if pty_available?
+
+        call_with_open3(env, cmd)
+      end
+
+      private
+
+      attr_reader :secrets_provider
+
+      def call_with_pty(env, cmd)
+        stdout_str = +""
+        status = nil
+        PTY.spawn(env, cmd) do |output, input, pid|
+          begin
+            loop do
+              chunk = output.readpartial(1024)
+              stdout_str << chunk
+              @output.print(chunk)
+              handle_prompt(input, chunk)
+            end
+          rescue Errno::EIO
+            # PTY raises EIO when the child process exits after closing the slave.
+          rescue Kettle::Dev::Error
+            Process.kill("TERM", pid)
+            raise
+          ensure
+            _, status = Process.wait2(pid)
+          end
+        end
+        [stdout_str, "", status]
+      end
+
+      def call_with_open3(env, cmd)
+        stdout_str = +""
+        stderr_str = +""
+        status = nil
+        Open3.popen3(env, cmd) do |input, output, error, wait_thread|
+          readers = [output, error]
+          until readers.empty?
+            ready = IO.select(readers)
+            ready.first.each do |reader|
+              begin
+                chunk = reader.readpartial(1024)
+                if reader.equal?(output)
+                  stdout_str << chunk
+                  @output.print(chunk)
+                else
+                  stderr_str << chunk
+                  @error.print(chunk)
+                end
+                handle_prompt(input, chunk)
+              rescue EOFError
+                readers.delete(reader)
+              end
+            end
+          end
+          status = wait_thread.value
+        end
+        [stdout_str, stderr_str, status]
+      end
+
+      def handle_prompt(input, chunk)
+        if otp_prompt?(chunk)
+          write_secret(input, secrets_provider.rubygems_otp, label: "RubyGems MFA code") if otp_response_prompt?(chunk)
+          return
+        end
+
+        write_secret(input, gem_signing_passphrase, label: "gem signing passphrase") if signing_password_prompt?(chunk)
+      end
+
+      def gem_signing_passphrase
+        @gem_signing_passphrase ||= secrets_provider.gem_signing_passphrase.to_s
+      end
+
+      def write_secret(input, value, label:)
+        secret = value.to_s
+        if secret.empty?
+          raise Kettle::Dev::Error, "#{label} prompt reached, but the configured release secrets provider returned no value. Aborting because secret prompts are not allowed when a secrets provider is configured."
+        end
+
+        @output.puts("#{label} loaded from configured secrets provider.")
+        input.write("#{secret}\n")
+        input.flush
+      end
+
+      def otp_prompt?(chunk)
+        chunk.match?(/(?:multi-factor authentication|OTP code|one-time password|\bCode:\s*)/i)
+      end
+
+      def otp_response_prompt?(chunk)
+        chunk.match?(/(?:OTP code|one-time password|\bCode:\s*)/i)
+      end
+
+      def signing_password_prompt?(chunk)
+        chunk.match?(/(?:enter\s+)?(?:PEM\s+)?pass(?:\s|-)?phrase\s*(?:for\s+[^:]+)?[:?]\s*\z/i) ||
+          chunk.match?(/(?:PEM|private key) password\s*[:?]\s*\z/i)
+      end
+
+      def pty_available?
+        return false unless RUBY_ENGINE == "ruby"
+
+        require "pty"
+        true
+      rescue LoadError
+        false
+      end
+    end
+  end
+end