cargo-rail 0.32.0

Cargo-native Rust workspace engine for affected CI, Rust source-surface analysis, compiler reuse, dependency coherence, exact-SHA releases, and split/sync
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

//! `cargo rail release`: preview, confirm, and run or finish one release.

use crate::commands::cli::ReleaseArgs;
use crate::error::{RailError, RailResult};
use crate::release::engine::{self, Effect, Report, State};
use crate::release::version::BumpRequest;
use crate::workspace::WorkspaceContext;

/// Run `cargo rail release`.
pub fn run_release(ctx: &WorkspaceContext, args: ReleaseArgs) -> RailResult<()> {
    let options = engine::Options {
        crates: (!args.crate_names.is_empty()).then_some(args.crate_names),
        bump: args.bump.parse::<BumpRequest>()?,
        pull_request: args.pr,
        yes: args.yes,
        dry_run: args.dry_run,
        json: args.format.is_json(),
    };
    let warnings = match ctx.config() {
        Some(config) => config.release_warnings(ctx.graph().workspace_members())?,
        None => Vec::new(),
    };
    if !options.json {
        for warning in &warnings {
            crate::warn!("{warning}");
        }
    }
    let report = engine::run(ctx, &options).map_err(|error| error.with_warnings(warnings.clone()))?;
    // Waiting for checks changed nothing and is not a release, so it exits like pending work.
    let exit_code = if report.state == State::AwaitingChecks { 1 } else { 0 };
    if options.json {
        let mut payload = serde_json::to_value(&report)?;
        if !warnings.is_empty() {
            payload["warnings"] = serde_json::json!(warnings);
        }
        let mode = if options.dry_run { "dry_run" } else { "apply" };
        let state = serde_json::to_value(report.state)?;
        let output = crate::output::machine_json_envelope(
            "release",
            mode,
            state.as_str().unwrap_or("unknown"),
            exit_code,
            payload,
        );
        println!("{}", serde_json::to_string_pretty(&output)?);
    } else {
        println!("{}", render(&report));
    }
    if exit_code == 1 {
        return Err(RailError::CheckHasPendingChanges);
    }
    Ok(())
}

fn render(report: &Report) -> String {
    let mut out = String::new();
    let headline = match report.state {
        State::NothingToRelease => "nothing to release".to_owned(),
        State::Planned => "dry run: every check passed; nothing changed".to_owned(),
        State::Cancelled => "cancelled; nothing changed".to_owned(),
        State::PullRequest => format!(
            "release pull request: {}",
            report.pull_request.as_deref().unwrap_or("open")
        ),
        State::AwaitingChecks => format!("waiting for checks: {}", report.pending_checks.join(", ")),
        State::AwaitingAssets => "draft release waits for assets".to_owned(),
        State::Released => "released".to_owned(),
    };
    out.push_str(&headline);
    for release in &report.crates {
        out.push_str(&format!("\n  {} {} ({})", release.name, release.version, release.tag));
        let registry = report.registry.as_deref().unwrap_or("registry");
        match release.registry {
            Effect::Done => out.push_str(&format!("\n    {registry}: published")),
            Effect::Pending if report.state != State::Planned => {
                out.push_str(&format!("\n    {registry}: not yet published"));
            }
            Effect::Pending => out.push_str(&format!("\n    {registry}: will publish")),
            Effect::Skipped => {}
        }
        match (release.github_release, &release.release_url) {
            (Effect::Done, Some(url)) => out.push_str(&format!("\n    GitHub release: {url}")),
            (Effect::Pending, Some(url)) => out.push_str(&format!("\n    draft GitHub release: {url}")),
            _ => {}
        }
        if !release.missing_assets.is_empty() && report.state == State::AwaitingAssets {
            out.push_str(&format!("\n    missing assets: {}", release.missing_assets.join(", ")));
        }
    }
    if report.state == State::NothingToRelease && !report.skipped.is_empty() && crate::output::is_verbose() {
        for skipped in &report.skipped {
            out.push_str(&format!("\n  {}: {}", skipped.name, skipped.reason));
        }
    }
    if let Some(next) = &report.next {
        out.push_str(&format!("\nnext: {next}"));
    }
    out
}