cargo-buckal 0.1.3

Seamlessly build Cargo projects with Buck2.
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

use std::process::{Command, Stdio};

use anyhow::{Context, Result, anyhow};
use cargo_metadata::MetadataCommand;
use clap::Parser;

use crate::{
    cache::BuckalCache,
    context::BuckalContext,
    utils::{UnwrapOrExit, ensure_prerequisites, get_last_cache, section},
};

#[derive(Parser, Debug)]
pub struct UpdateArgs {
    /// Package to update
    #[clap(value_name = "SPEC", num_args = 0..)]
    pub packages: Vec<String>,

    /// Only update the workspace packages
    #[arg(long, short = 'w')]
    pub workspace: bool,

    /// Don't actually write the lockfile
    #[arg(long)]
    pub dry_run: bool,

    /// Path to Cargo.toml
    #[arg(long)]
    pub manifest_path: Option<String>,
}

pub fn execute(args: &UpdateArgs) {
    ensure_prerequisites().unwrap_or_exit();

    let last_cache = get_last_cache();

    handle_cargo_update(args).unwrap_or_exit_ctx("failed to execute cargo update");

    if args.dry_run {
        return;
    }

    section("Buckal Console");

    // Refresh Cargo metadata
    if let Some(manifest) = &args.manifest_path {
        let _ = MetadataCommand::new().manifest_path(manifest).exec();
    } else {
        let _ = MetadataCommand::new().exec();
    }

    let ctx = BuckalContext::new(args.manifest_path.clone());

    let new_cache = BuckalCache::new(&ctx.nodes_map, &ctx.workspace_root);
    let changes = new_cache.diff(&last_cache, &ctx.workspace_root);

    changes.apply(&ctx);
    new_cache.save();
}

fn handle_cargo_update(args: &UpdateArgs) -> Result<()> {
    let mut cargo_cmd = Command::new("cargo");
    cargo_cmd.arg("update");

    if args.workspace {
        cargo_cmd.arg("--workspace");
    }

    if args.dry_run {
        cargo_cmd.arg("--dry-run");
    }

    if let Some(manifest) = &args.manifest_path {
        cargo_cmd.arg("--manifest-path").arg(manifest);
    }

    cargo_cmd.args(&args.packages);

    cargo_cmd.stdout(Stdio::inherit()).stderr(Stdio::inherit());

    let status = cargo_cmd
        .status()
        .context("failed to execute `cargo update`")?;

    if !status.success() {
        return Err(anyhow!("cargo update exited with failure status"));
    }
    Ok(())
}