cargo-uv 0.7.0

A simple Cargo tool for updating the version in your project.
Documentation 
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

pub(crate) mod error;
pub(crate) mod toml_file;
pub(crate) mod version_location;

use miette::Result;
use tracing::{info, instrument, warn};

use crate::{Cli, Packages, error::ManifestNotFoundError};

#[instrument(skip(args), fields(cargo_file))]
pub fn generate_packages(args: &mut Cli) -> Result<Packages> {
    let mut cli_path = args.manifest.manifest_path.as_ref();
    let mut command = args.manifest.metadata();
    if let Some(manifest_path) = cli_path.as_mut() {
        let mut manifest_path = manifest_path.clone();
        if manifest_path.is_dir() {
            manifest_path.push("Cargo.toml");
        }
        command.manifest_path(manifest_path);
    };
    let metadata = match command.exec() {
        Ok(m) => m,
        Err(e) => {
            use cargo_metadata::Error as CmErr;
            let mut msg = match e {
                CmErr::CargoMetadata { stderr: s } => s,
                CmErr::Io(e) => e.to_string(),
                CmErr::Utf8(utf8_error) => utf8_error.to_string(),
                CmErr::ErrUtf8(_) => "Cargo.toml is not in valid Utf-8.".into(),
                CmErr::Json(error) => error.to_string(),
                CmErr::NoJson => CmErr::NoJson.to_string(),
            };
            msg.retain(|s| s != '\n');
            let source_code = cli_path.as_ref().map(|&s| {
                s.clone()
                    .canonicalize()
                    .unwrap_or(s.clone())
                    .display()
                    .to_string()
                    .strip_prefix("\\\\?\\") // Bug fix
                    .unwrap_or_default()
                    .to_string()
            });
            let source_len = source_code.clone().unwrap_or_default().len();

            Err(ManifestNotFoundError {
                help: "Ensure you run the command in a rust project or use '--manifest-path' to set a Cargo.toml file".into(),
                source_code,
                label: Some((0, source_len)),
                label_msg: "Check path ends with Cargo.toml or one exists in the given folder.",
                msg,
            })?;
            unreachable!()
        }
    };
    let mut packages = Packages::from(&metadata);
    let cargo_file = metadata.workspace_root.clone().join("Cargo.toml");
    tracing::Span::current().record("cargo_file", cargo_file.clone().to_string());
    if cargo_file.exists() {
        info!("Found")
    } else {
        warn!("Not Found");
        // TODO: Validate this error.
        Err(ManifestNotFoundError {
            help: "Cargo could not find the Cargo.toml file, try specifying it with '-P'.".into(),
            source_code: None,
            label: None,
            label_msg: "",
            msg: "Cargo.toml file was not found by Cargo".into(),
        })?;
    }

    packages.set_cargo_file_path(cargo_file.into());

    Ok(packages)
}