ingredients 0.1.0

Check ingredients of published Rust crates
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
77
78
79
80
81
82
83
84
85
86
87
88
89
90

use std::path::Path;

use cargo_metadata::camino::Utf8PathBuf;

use crate::error::Error;

fn utf8_path_replace(path: &Utf8PathBuf, left: &str, right: &str) -> Utf8PathBuf {
    Utf8PathBuf::from(path.to_string().replace(left, right))
}

#[derive(Clone, Debug, PartialEq)]
pub struct Metadata {
    pub inner: cargo_metadata::Package,
}

impl Metadata {
    pub fn from_cargo_metadata<P: AsRef<Path>>(
        mut md: cargo_metadata::Package,
        root: P,
        path_in_vcs: Option<&str>,
    ) -> Self {
        let root_str = {
            let mut temp = root.as_ref().to_path_buf();
            if let Some(path_in_vcs) = path_in_vcs {
                temp.push(path_in_vcs);
            }
            temp.push("");
            temp.to_string_lossy().to_string()
        };

        // manifest_path: replace absolute path
        md.manifest_path = utf8_path_replace(&md.manifest_path, &root_str, "");

        for target in &mut md.targets {
            // src_path: replace absolute path
            target.src_path = utf8_path_replace(&target.src_path, &root_str, "");
        }

        Metadata { inner: md }
    }
}

fn load_metadata_from_path<P: AsRef<Path>>(path: P) -> Result<cargo_metadata::Metadata, Error> {
    cargo_metadata::MetadataCommand::new()
        .manifest_path(path.as_ref())
        .no_deps()
        .other_options(vec![String::from("--offline")])
        .exec()
        .map_err(|err| Error::Metadata { inner: err.to_string() })
}

pub fn get_crate_metadata<P: AsRef<Path>>(root: P) -> Result<Metadata, Error> {
    let path = root.as_ref().join("Cargo.toml");
    let md = load_metadata_from_path(path)?;

    let [package]: [cargo_metadata::Package; 1] =
        md.packages
            .into_iter()
            .collect::<Vec<_>>()
            .try_into()
            .map_err(|_| Error::Metadata {
                inner: String::from("Failed to load crate metadata (too many workspace members)."),
            })?;

    Ok(Metadata::from_cargo_metadata(package, root, None))
}

pub fn get_crate_metadata_from_workspace<P: AsRef<Path>>(
    root: P,
    path_in_vcs: &str,
    name: &str,
) -> Result<Metadata, Error> {
    let path = root.as_ref().join(path_in_vcs).join("Cargo.toml");
    let md = load_metadata_from_path(path)?;

    let [package]: [cargo_metadata::Package; 1] = md
        .packages
        .into_iter()
        .filter(|p| p.name.as_ref() == name)
        .collect::<Vec<_>>()
        .try_into()
        .map_err(|_| Error::Metadata {
            inner: format!(
                "Failed to load crate metadata (name does not match any workspace member): {}",
                name.to_owned()
            ),
        })?;

    Ok(Metadata::from_cargo_metadata(package, root, Some(path_in_vcs)))
}