release-plz 0.3.61

Update version and changelog based on semantic versioning and conventional commits
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

mod args;
mod changelog_config;
mod config;
mod generate_schema;
pub mod init;
mod log;
mod update_checker;

use anyhow::Context;
use args::OutputType;
use clap::Parser;
use release_plz_core::{ReleasePrRequest, ReleaseRequest};
use serde::Serialize;
use tracing::error;

use crate::args::{repo_command::RepoCommand as _, CliArgs, Command};

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let args = CliArgs::parse();
    log::init(args.verbose);
    run(args).await.map_err(|e| {
        error!("{:?}", e);
        e
    })?;

    Ok(())
}

async fn run(args: CliArgs) -> anyhow::Result<()> {
    match args.command {
        Command::Update(cmd_args) => {
            let cargo_metadata = cmd_args.cargo_metadata()?;
            let config = cmd_args.config()?;
            let update_request = cmd_args.update_request(config, cargo_metadata)?;
            let updates = release_plz_core::update(&update_request)?;
            println!("{}", updates.0.summary());
        }
        Command::ReleasePr(cmd_args) => {
            let cargo_metadata = cmd_args.update.cargo_metadata()?;
            let config = cmd_args.update.config()?;
            let pr_labels = config.workspace.pr_labels.clone();
            let pr_draft = config.workspace.pr_draft;
            let update_request = cmd_args.update.update_request(config, cargo_metadata)?;
            let repo_url = update_request
                .repo_url()
                .context("can't determine repo url")?;
            let git = cmd_args
                .git_backend(repo_url.clone())
                .context("invalid git backend settings")?;
            let request = ReleasePrRequest::new(git, update_request)
                .mark_as_draft(pr_draft)
                .with_labels(pr_labels);
            let release_pr = release_plz_core::release_pr(&request).await?;
            if let Some(release_pr) = release_pr {
                if let Some(output_type) = cmd_args.output {
                    let out = serde_json::json!({
                        "prs": [release_pr]
                    });
                    print_output(output_type, out)
                }
            }
        }
        Command::Release(cmd_args) => {
            let cargo_metadata = cmd_args.cargo_metadata()?;
            let config = cmd_args.config()?;
            let cmd_args_output = cmd_args.output;
            let request: ReleaseRequest = cmd_args.release_request(config, cargo_metadata)?;
            if let Some(release) = release_plz_core::release(&request).await? {
                if let Some(output_type) = cmd_args_output {
                    print_output(output_type, release)
                }
            }
        }
        Command::GenerateCompletions(cmd_args) => cmd_args.print(),
        Command::CheckUpdates => update_checker::check_update().await?,
        Command::GenerateSchema => generate_schema::generate_schema_to_disk()?,
        Command::Init => init::init()?,
    }
    Ok(())
}

fn print_output(output_type: OutputType, output: impl Serialize) {
    match output_type {
        OutputType::Json => match serde_json::to_string(&output) {
            Ok(json) => println!("{json}"),
            Err(e) => tracing::error!("can't serialize release pr to json: {e}"),
        },
    }
}