use std::{
collections::{BTreeMap, BTreeSet},
env,
ffi::OsString,
path::{Path, PathBuf},
process::{Command, Stdio},
};
use serde::Deserialize;
use crate::{args::CargoOptions, project::Project};
#[derive(Clone, Debug)]
pub struct NativePackage {
pub version: String,
pub description: Option<String>,
pub authors: Vec<String>,
}
pub fn estimate(project: &Project, options: &CargoOptions, target: Option<&str>) -> Option<usize> {
let mut command = metadata_command(project, options);
command
.arg("--filter-platform")
.arg(target.unwrap_or("host-tuple"));
let output = command.output().ok()?;
if !output.status.success() {
return None;
}
let metadata = serde_json::from_slice::<Metadata>(&output.stdout).ok()?;
reachable_package_count(&metadata, &project.native_manifest)
}
pub fn native_package(project: &Project, options: &CargoOptions) -> Option<NativePackage> {
let output = metadata_command(project, options)
.arg("--no-deps")
.output()
.ok()?;
if !output.status.success() {
return None;
}
let metadata = serde_json::from_slice::<Metadata>(&output.stdout).ok()?;
let package = metadata
.packages
.iter()
.find(|package| same_path(&package.manifest_path, &project.native_manifest))?;
(!package.version.trim().is_empty()).then(|| NativePackage {
version: package.version.clone(),
description: package.description.clone(),
authors: package.authors.clone(),
})
}
fn metadata_command(project: &Project, options: &CargoOptions) -> Command {
let cargo = env::var_os("CARGO").unwrap_or_else(|| OsString::from("cargo"));
let mut command = Command::new(cargo);
command
.arg("metadata")
.arg("--format-version")
.arg("1")
.arg("--manifest-path")
.arg(&project.native_manifest)
.current_dir(&project.root)
.stdin(Stdio::null())
.stderr(Stdio::null());
if !options.unlocked {
command.arg("--locked");
}
if options.offline {
command.arg("--offline");
}
if options.no_default_features {
command.arg("--no-default-features");
}
if !options.features.is_empty() {
command.arg("--features").arg(options.features.join(","));
}
if options
.cargo_arg
.iter()
.any(|argument| argument == "--all-features")
{
command.arg("--all-features");
}
command
}
fn reachable_package_count(metadata: &Metadata, manifest: &Path) -> Option<usize> {
let root = metadata
.packages
.iter()
.find(|package| same_path(&package.manifest_path, manifest))?
.id
.clone();
let nodes = metadata
.resolve
.as_ref()?
.nodes
.iter()
.map(|node| (node.id.as_str(), node.dependencies.as_slice()))
.collect::<BTreeMap<_, _>>();
let mut seen = BTreeSet::new();
let mut pending = vec![root];
while let Some(package) = pending.pop() {
if !seen.insert(package.clone()) {
continue;
}
if let Some(dependencies) = nodes.get(package.as_str()) {
pending.extend(dependencies.iter().cloned());
}
}
(!seen.is_empty()).then_some(seen.len())
}
fn same_path(left: &Path, right: &Path) -> bool {
if left == right {
return true;
}
match (left.canonicalize(), right.canonicalize()) {
(Ok(left), Ok(right)) => left == right,
_ => false,
}
}
#[derive(Deserialize)]
struct Metadata {
packages: Vec<MetadataPackage>,
resolve: Option<MetadataResolve>,
}
#[derive(Deserialize)]
struct MetadataPackage {
id: String,
manifest_path: PathBuf,
#[serde(default)]
version: String,
#[serde(default)]
description: Option<String>,
#[serde(default)]
authors: Vec<String>,
}
#[derive(Deserialize)]
struct MetadataResolve {
nodes: Vec<MetadataNode>,
}
#[derive(Deserialize)]
struct MetadataNode {
id: String,
dependencies: Vec<String>,
}
#[cfg(test)]
mod tests {
use serde_json::json;
use super::*;
#[test]
fn counts_only_packages_reachable_from_the_native_manifest() {
let metadata = serde_json::from_value::<Metadata>(json!({
"packages": [
{ "id": "app", "manifest_path": "/tmp/app/Cargo.toml" },
{ "id": "a", "manifest_path": "/tmp/a/Cargo.toml" },
{ "id": "b", "manifest_path": "/tmp/b/Cargo.toml" },
{ "id": "unused", "manifest_path": "/tmp/unused/Cargo.toml" }
],
"resolve": {
"nodes": [
{ "id": "app", "dependencies": ["a"] },
{ "id": "a", "dependencies": ["b"] },
{ "id": "b", "dependencies": [] },
{ "id": "unused", "dependencies": [] }
]
}
}))
.unwrap();
assert_eq!(
reachable_package_count(&metadata, Path::new("/tmp/app/Cargo.toml")),
Some(3)
);
}
}