Coverage / crates/flow/src/deps.rs 97.5%

pub fn from_lock(text: &str) -> Result<BTreeSet<Crate>, String> {

    let lock: toml::Value = text.parse().map_err(|e| format!("not a Cargo.lock: {e}"))?;

    let mut out = BTreeSet::new();

    for p in lock.get("package").and_then(|p| p.as_array()).into_iter().flatten() {

        let (Some(name), Some(version)) = (p.get("name").and_then(|v| v.as_str()), p.get("version").and_then(|v| v.as_str())) else {

        if p.get("source").is_some() {

            out.insert((name.to_string(), version.to_string()));

        }

    Ok(out)

}

pub fn from_list(text: &str) -> BTreeSet<Crate> {

    text.lines()

        .map(str::trim)

        .filter(|l| !l.is_empty() && !l.starts_with('#'))

        .filter_map(|l| {

            let mut w = l.split_whitespace();

            Some((w.next()?.to_string(), w.next()?.to_string()))

        })

        .collect()

}

pub fn from_vendor(dir: &Path) -> Result<BTreeSet<Crate>, String> {

    let entries = std::fs::read_dir(dir).map_err(|e| format!("{}: {e}", dir.display()))?;

    let mut out = BTreeSet::new();

    for e in entries.flatten() {

        let manifest = e.path().join("Cargo.toml");

        let Ok(text) = std::fs::read_to_string(&manifest) else { continue };

        let Ok(v) = text.parse::<toml::Value>() else { continue };

        let pkg = v.get("package");

        let field = |k: &str| pkg.and_then(|p| p.get(k)).and_then(|x| x.as_str()).map(str::to_string);

        if let (Some(n), Some(ver)) = (field("name"), field("version")) {

            out.insert((n, ver));

        }

    Ok(out)

}

pub fn missing(need: &BTreeSet<Crate>, have: &BTreeSet<Crate>) -> Vec<(Crate, Vec<String>)> {

    let mut versions: BTreeMap<&str, Vec<String>> = BTreeMap::new();

    for (n, v) in have {

        versions.entry(n.as_str()).or_default().push(v.clone());

    }

    need.iter().filter(|c| !have.contains(*c)).map(|c| (c.clone(), versions.get(c.0.as_str()).cloned().unwrap_or_default())).collect()

}

pub fn render_list(crates: &BTreeSet<Crate>) -> String {

    crates.iter().map(|(n, v)| format!("{n} {v}\n")).collect()

}

    fn names_what_the_image_lacks_and_what_it_has_instead() {

        let need = from_lock(LOCK).unwrap();

        assert_eq!(need.len(), 3, "the workspace's own package is not vendored");

        let have = from_list("# the image\nrustls 0.23.45\ntokio-rustls 0.26.4\n\n");

        let m = missing(&need, &have);

        assert_eq!(

            vec![(("deranged".into(), "0.5.8".into()), vec![]), (("tokio-rustls".into(), "0.26.5".into()), vec!["0.26.4".into()]),]

        assert!(missing(&need, &need).is_empty());

        assert_eq!(from_list(&render_list(&need)), need);

        assert!(from_lock("not = [toml").is_err());

    }

    fn reads_a_vendor_directory() {

        let dir = tempfile::tempdir().unwrap();

        for (d, n, v) in [("rustls-0.23.45", "rustls", "0.23.45"), ("pre-1.0.0-rc.1", "pre", "1.0.0-rc.1")] {

            std::fs::create_dir(dir.path().join(d)).unwrap();

            std::fs::write(dir.path().join(d).join("Cargo.toml"), format!("[package]\nname = \"{n}\"\nversion = \"{v}\"\n")).unwrap();

        }

        std::fs::create_dir(dir.path().join("junk")).unwrap();

        let got = from_vendor(dir.path()).unwrap();

        assert_eq!(got, from_list("rustls 0.23.45\npre 1.0.0-rc.1\n"));

    }