use std::{
collections::HashMap,
path::{Path, PathBuf},
};
use anyhow::{Context, Result};
use cargo_metadata::{MetadataCommand, PackageId, Target, TargetKind};
use crate::model::SourceKind;
#[derive(Clone, Debug)]
struct PackageInfo {
name: String,
root: PathBuf,
target_kinds: HashMap<PathBuf, SourceKind>,
}
#[derive(Clone, Debug, Default)]
pub struct CargoContext {
packages: Vec<PackageInfo>,
}
impl CargoContext {
pub fn discover(root: &Path) -> Result<Self> {
let manifest = root.join("Cargo.toml");
if !manifest.is_file() {
return Ok(Self::default());
}
let metadata = MetadataCommand::new()
.current_dir(root)
.manifest_path("Cargo.toml")
.no_deps()
.exec()
.with_context(|| format!("cargo metadata failed for {}", manifest.display()))?;
let members = metadata
.workspace_members
.iter()
.collect::<std::collections::HashSet<&PackageId>>();
let metadata_root = PathBuf::from(metadata.workspace_root.as_str());
let mut packages = metadata
.packages
.iter()
.filter(|package| members.contains(&package.id))
.map(|package| {
let manifest_path = rebase_metadata_path(
Path::new(package.manifest_path.as_str()),
&metadata_root,
root,
);
let package_root = manifest_path
.parent()
.context("Cargo package manifest has no parent")?
.to_path_buf();
let target_kinds = package
.targets
.iter()
.map(|target| {
(
rebase_metadata_path(
Path::new(target.src_path.as_str()),
&metadata_root,
root,
),
classify_target(target),
)
})
.collect();
Ok(PackageInfo {
name: package.name.to_string(),
root: package_root,
target_kinds,
})
})
.collect::<Result<Vec<_>>>()?;
packages.sort_by(|left, right| {
right
.root
.components()
.count()
.cmp(&left.root.components().count())
});
Ok(Self { packages })
}
pub fn package_names(&self) -> impl Iterator<Item = &str> {
self.packages.iter().map(|package| package.name.as_str())
}
pub fn classify(&self, path: &Path) -> (Option<String>, SourceKind) {
let Some(package) = self
.packages
.iter()
.find(|package| path.starts_with(&package.root))
else {
return (None, SourceKind::Other);
};
let kind = package
.target_kinds
.get(path)
.copied()
.unwrap_or_else(|| classify_package_path(path, &package.root));
(Some(package.name.clone()), kind)
}
}
fn rebase_metadata_path(path: &Path, metadata_root: &Path, analysis_root: &Path) -> PathBuf {
path.strip_prefix(metadata_root).map_or_else(
|_| path.to_path_buf(),
|relative| analysis_root.join(relative),
)
}
fn classify_target(target: &Target) -> SourceKind {
if target.is_custom_build() {
SourceKind::Build
} else if target.is_test() {
SourceKind::IntegrationTest
} else if target.is_bench() {
SourceKind::Bench
} else if target.is_example() {
SourceKind::Example
} else if target.kind.iter().any(is_production_target) {
SourceKind::Production
} else {
SourceKind::Other
}
}
fn is_production_target(kind: &TargetKind) -> bool {
matches!(
kind,
TargetKind::Bin
| TargetKind::Lib
| TargetKind::RLib
| TargetKind::DyLib
| TargetKind::CDyLib
| TargetKind::StaticLib
| TargetKind::ProcMacro
)
}
fn classify_package_path(path: &Path, package_root: &Path) -> SourceKind {
let Ok(relative) = path.strip_prefix(package_root) else {
return SourceKind::Other;
};
if relative == Path::new("build.rs") {
return SourceKind::Build;
}
match relative
.components()
.next()
.and_then(|component| component.as_os_str().to_str())
{
Some("src") => SourceKind::Production,
Some("tests") => SourceKind::IntegrationTest,
Some("benches") => SourceKind::Bench,
Some("examples") => SourceKind::Example,
_ => SourceKind::Other,
}
}
#[cfg(test)]
mod tests {
use std::path::Path;
use super::classify_package_path;
use crate::model::SourceKind;
#[test]
fn classifies_standard_cargo_directories() {
let root = Path::new("/repo/crate");
assert_eq!(
classify_package_path(Path::new("/repo/crate/src/lib.rs"), root),
SourceKind::Production
);
assert_eq!(
classify_package_path(Path::new("/repo/crate/tests/api.rs"), root),
SourceKind::IntegrationTest
);
assert_eq!(
classify_package_path(Path::new("/repo/crate/benches/load.rs"), root),
SourceKind::Bench
);
assert_eq!(
classify_package_path(Path::new("/repo/crate/examples/demo.rs"), root),
SourceKind::Example
);
}
}