Class: Kettle::Dev::ReleaseCLI

Inherits:

Object

• Object
• Kettle::Dev::ReleaseCLI

Defined in:

lib/kettle/dev/release_cli.rb

Class Method Summary

• .run_cmd!(cmd) ⇒ Object

Instance Method Summary

• #initialize(start_step: 1) ⇒ ReleaseCLI constructor

  A new instance of ReleaseCLI.

• #run ⇒ Object

Constructor Details

#initialize(start_step: 1) ⇒ ReleaseCLI

Returns a new instance of ReleaseCLI.

# File 'lib/kettle/dev/release_cli.rb', line 73

def initialize(start_step: 1)
  @root = Kettle::Dev::CIHelpers.project_root
  @git = Kettle::Dev::GitAdapter.new
  @start_step = (start_step || 1).to_i
  @start_step = 1 if @start_step < 1
end

Class Method Details

.run_cmd!(cmd) ⇒ Object

# File 'lib/kettle/dev/release_cli.rb', line 20

def run_cmd!(cmd)
  # For Bundler-invoked build/release, explicitly prefix SKIP_GEM_SIGNING so
  # the signing step is skipped even when Bundler scrubs ENV.
  # Always do this on CI to avoid interactive prompts; locally only when explicitly requested.
  if ENV["SKIP_GEM_SIGNING"] && cmd =~ /\Abundle(\s+exec)?\s+rake\s+(build|release)\b/
    cmd = "SKIP_GEM_SIGNING=true #{cmd}"
  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

  # 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
  # so they inherit the current TTY and can read the user's input.
  interactive = cmd =~ /\Abundle(\s+exec)?\s+rake\s+release\b/ || cmd =~ /\Agem\s+push\b/
  if interactive
    ok = system(env_hash, cmd)
    unless ok
      exit_code = $?.respond_to?(:exitstatus) ? $?.exitstatus : 1
      abort("Command failed: #{cmd} (exit #{exit_code})")
    end
    return
  end

  # Non-interactive: capture output so we can surface clear diagnostics on failure
  stdout_str, stderr_str, status = Open3.capture3(env_hash, cmd)

  # Echo command output to match prior behavior
  $stdout.print(stdout_str) unless stdout_str.nil? || stdout_str.empty?
  $stderr.print(stderr_str) unless stderr_str.nil? || stderr_str.empty?

  unless status.success?
    exit_code = status.exitstatus
    # Keep the original prefix to avoid breaking any tooling/tests that grep for it,
    # but add the exit status and a brief diagnostic tail from stderr.
    diag = ""
    unless stderr_str.to_s.empty?
      tail = stderr_str.lines.last(20).join
      diag = "\n--- STDERR (last 20 lines) ---\n#{tail}".rstrip
    end
    abort("Command failed: #{cmd} (exit #{exit_code})#{diag}")
  end
end

Instance Method Details

#run ⇒ Object

# File 'lib/kettle/dev/release_cli.rb', line 80

def run
  # 1. Ensure Bundler version ✓
  ensure_bundler_2_7_plus!

  version = nil
  committed = nil
  trunk = nil
  feature = nil

  # 2. Version detection and sanity checks + prompt
  if @start_step <= 2
    version = detect_version
    puts "Detected version: #{version.inspect}"

    latest_overall = nil
    latest_for_series = nil
    begin
      gem_name = detect_gem_name
      latest_overall, latest_for_series = latest_released_versions(gem_name, version)
    rescue StandardError => e
      warn("[kettle-release] RubyGems check failed: #{e.class}: #{e.message}")
      warn(e.backtrace.first(3).map { |l| "  " + l }.join("\n")) if ENV["DEBUG"]
      warn("Proceeding without RubyGems latest version info.")
    end

    if latest_overall
      msg = "Latest released: #{latest_overall}"
      if latest_for_series && latest_for_series != latest_overall
        msg += " | Latest for series #{Gem::Version.new(version).segments[0, 2].join(".")}.x: #{latest_for_series}"
      elsif latest_for_series
        msg += " (matches current series)"
      end
      puts msg

      cur = Gem::Version.new(version)
      overall = Gem::Version.new(latest_overall)
      cur_series = cur.segments[0, 2]
      overall_series = overall.segments[0, 2]
      # Ensure latest_for_series actually matches our current series; ignore otherwise.
      if latest_for_series
        lfs_series = Gem::Version.new(latest_for_series).segments[0, 2]
        latest_for_series = nil unless lfs_series == cur_series
      end
      # Determine the sanity-check target correctly for the current series.
      # If RubyGems has a newer overall series than our current series, only compare
      # against the latest published in our current series. If that cannot be determined
      # (e.g., offline), skip the sanity check rather than treating the overall as target.
      target = if (cur_series <=> overall_series) == -1
        latest_for_series
      else
        latest_overall
      end
      # IMPORTANT: Never treat a higher different-series "latest_overall" as a downgrade target.
      # If our current series is behind overall and RubyGems does not report a latest_for_series,
      # then we cannot determine the correct target for this series and should skip the check.
      if (cur_series <=> overall_series) == -1 && target.nil?
        puts "Could not determine latest released version from RubyGems (offline?). Proceeding without sanity check."
      elsif target
        bump = Kettle::Dev::Versioning.classify_bump(target, version)
        case bump
        when :same
          series = cur_series.join(".")
          warn("version.rb (#{version}) matches the latest released version for series #{series} (#{target}).")
          abort("Aborting: version bump required. Bump PATCH/MINOR/MAJOR/EPIC.")
        when :downgrade
          series = cur_series.join(".")
          warn("version.rb (#{version}) is lower than the latest released version for series #{series} (#{target}).")
          abort("Aborting: version must be bumped above #{target}.")
        else
          label = {epic: "EPIC", major: "MAJOR", minor: "MINOR", patch: "PATCH"}[bump] || bump.to_s.upcase
          puts "Proposed bump type: #{label} (from #{target} -> #{version})"
        end
      else
        puts "Could not determine latest released version from RubyGems (offline?). Proceeding without sanity check."
      end
    else
      puts "Could not determine latest released version from RubyGems (offline?). Proceeding without sanity check."
    end

    puts "Have you updated lib/**/version.rb and CHANGELOG.md for v#{version}? [y/N]"
    print("> ")
    ans = Kettle::Dev::InputAdapter.gets&.strip
    abort("Aborted: please update version.rb and CHANGELOG.md, then re-run.") unless ans&.downcase&.start_with?("y")

    # Initial validation: Ensure README.md and LICENSE.txt have identical sets of copyright years; also ensure current year present when matched
    validate_copyright_years!

    # Ensure README KLOC badge reflects current CHANGELOG coverage denominator
    begin
      update_readme_kloc_badge!
    rescue StandardError => e
      warn("Failed to update KLOC badge in README: #{e.class}: #{e.message}")
    end

    # Update Rakefile.example header banner with current version and date
    begin
      update_rakefile_example_header!(version)
    rescue StandardError => e
      warn("Failed to update Rakefile.example header: #{e.class}: #{e.message}")
    end
  end

  # 3. bin/setup
  run_cmd!("bin/setup") if @start_step <= 3
  # 4. bin/rake
  run_cmd!("bin/rake") if @start_step <= 4

  # 5. appraisal:update (optional)
  if @start_step <= 5
    appraisals_path = File.join(@root, "Appraisals")
    if File.file?(appraisals_path)
      puts "Appraisals detected at #{appraisals_path}. Running: bin/rake appraisal:update"
      run_cmd!("bin/rake appraisal:update")
    else
      puts "No Appraisals file found; skipping appraisal:update"
    end
  end

  # 6. git user + commit release prep
  if @start_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) if @start_step <= 7

  # 8. ensure trunk synced
  if @start_step <= 8
    trunk = detect_trunk_branch
    feature = current_branch
    puts "Trunk branch detected: #{trunk}"
    ensure_trunk_synced_before_push!(trunk, feature)
  end

  # 9. push branches
  push! if @start_step <= 9

  # 10. monitor CI after push
  monitor_workflows_after_push! if @start_step <= 10

  # 11. merge feature into trunk and push
  if @start_step <= 11
    trunk ||= detect_trunk_branch
    feature ||= current_branch
    merge_feature_into_trunk_and_push!(trunk, feature)
  end

  # 12. checkout trunk and pull
  if @start_step <= 12
    trunk ||= detect_trunk_branch
    checkout!(trunk)
    pull!(trunk)
  end

  # 13. signing guidance and checks
  if @start_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?
        # In CI, avoid interactive prompts when no TTY is present (e.g., act or GitHub Actions "CI validation").
        # Non-interactive CI runs should not abort here; later signing checks are either stubbed in tests
        # or will be handled explicitly by ensure_signing_setup_or_skip!.
        print("Proceed with signing enabled? This may hang waiting for a PEM password. [y/N]: ")
        ans = Kettle::Dev::InputAdapter.gets&.strip
        unless ans&.downcase&.start_with?("y")
          abort("Aborted. Re-run with SKIP_GEM_SIGNING=true bundle exec kettle-release (or set it in your environment).")
        end
      else
        warn("Non-interactive shell detected (non-TTY); skipping interactive signing confirmation.")
      end
    end

    ensure_signing_setup_or_skip!
  end

  # 14. build
  if @start_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
    puts "Running release (you may be prompted for signing key password and RubyGems MFA OTP)..."
    run_cmd!("bundle exec rake release")
  end

  # 16. generate checksums
  #    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, altering the artifact.
  if @start_step <= 16
    # Generate checksums for the just-built artifact, then validate
    run_cmd!("bin/gem_checksums")
    version ||= detect_version
    validate_checksums!(version, stage: "after release")
  end

  # 17. create GitHub release (optional)
  if @start_step <= 17
    version ||= detect_version
    maybe_create_github_release!(version)
  end

  # 18. push tags to remotes (new final step)
  push_tags! if @start_step <= 18

  # Final success message
  begin
    version ||= detect_version
    gem_name = detect_gem_name
    puts "\n🚀 Release #{gem_name} v#{version} Complete 🚀"
  rescue StandardError => e
    Kettle::Dev.debug_error(e, __method__)
    # Fallback if detection fails for any reason
    puts "\n🚀 Release v#{version || "unknown"} Complete 🚀"
  end
end