use super::*;
use serde_json::Value;
use crate::module_scan::{Edition, package_name_to_import_ident};
pub(crate) use xingbiao::{
cargo_metadata, compilation_unit_label, crate_roots, find_package, member_src_dirs,
};
pub(crate) struct RootReading {
pub(crate) edition: Edition,
pub(crate) proc_macro: bool,
}
pub(crate) fn root_reading(
package: &Value,
root_file: Option<&Path>,
crate_package: &str,
) -> Result<RootReading, String> {
let package_edition = package["edition"].as_str();
let targets: Vec<&Value> = package["targets"]
.as_array()
.into_iter()
.flatten()
.filter(|target| {
root_file.is_none_or(|root| target["src_path"].as_str().map(Path::new) == Some(root))
})
.collect();
let proc_macro = targets.iter().any(|target| {
target["kind"]
.as_array()
.is_some_and(|kinds| kinds.iter().any(|kind| kind.as_str() == Some("proc-macro")))
});
let edition = match root_file {
None => Edition::of(package_edition),
Some(root) => {
let mut written: Vec<Option<&str>> = targets
.iter()
.map(|target| target["edition"].as_str().or(package_edition))
.collect();
written.sort();
written.dedup();
let readings: Vec<Edition> = written
.iter()
.map(|edition| Edition::of(*edition))
.collect();
let paths_alike = |reading: &Edition| reading != &Edition::Rust2015;
match readings.first() {
None => Edition::of(package_edition),
Some(first) if readings.iter().all(|reading| reading == first) => *first,
Some(_) if readings.iter().all(paths_alike) => Edition::Rust2018,
Some(_) => {
return Err(crate::errors::root_in_several_editions_error(
crate_package,
root,
&written.iter().map(|e| e.unwrap_or("?")).collect::<Vec<_>>(),
));
}
}
}
};
Ok(RootReading {
edition,
proc_macro,
})
}
#[derive(Debug, PartialEq, Eq)]
pub(crate) enum Members {
Read(Vec<String>),
Unreadable(String),
}
pub(crate) fn workspace_member_names(metadata: &Value) -> Members {
let Some(packages) = metadata["packages"].as_array() else {
return Members::Unreadable(
"cargo metadata carries no `packages` array, so which crates are workspace members \
cannot be decided"
.to_string(),
);
};
let mut names: Vec<String> = Vec::with_capacity(packages.len());
for package in packages {
match package["name"].as_str() {
Some(name) => names.push(name.to_string()),
None => {
return Members::Unreadable(
"cargo metadata carries a package whose `name` is absent or is not a string, \
so the membership set this reader would compare against is incomplete"
.to_string(),
);
}
}
}
names.sort();
names.dedup();
Members::Read(names)
}
fn kind_matches(dependency: &Value, kind: DependencyKind) -> bool {
matches!(
(kind, dependency["kind"].as_str()),
(DependencyKind::Normal, None)
| (DependencyKind::Dev, Some("dev"))
| (DependencyKind::Build, Some("build"))
)
}
fn governed_dependencies(
package: &Value,
kind: DependencyKind,
exclude_self: bool,
) -> impl Iterator<Item = &Value> {
package["dependencies"]
.as_array()
.into_iter()
.flatten()
.filter(move |dependency| {
kind_matches(dependency, kind)
&& !(exclude_self && is_self_dependency(package, dependency))
})
}
pub(crate) fn external_dependencies(package: &Value, kind: DependencyKind) -> Vec<String> {
let mut found: Vec<String> = governed_dependencies(package, kind, false)
.filter(|dependency| !dependency["source"].is_null())
.filter_map(|dependency| dependency["name"].as_str().map(str::to_string))
.collect();
found.sort();
found.dedup();
found
}
fn is_self_dependency(package: &Value, dependency: &Value) -> bool {
let own_name = package["name"].as_str();
own_name.is_some() && dependency["name"].as_str() == own_name && dependency["source"].is_null()
}
pub(crate) fn dependencies(package: &Value, kind: DependencyKind) -> Vec<String> {
let mut found: Vec<String> = governed_dependencies(package, kind, true)
.filter_map(|dependency| dependency["name"].as_str().map(str::to_string))
.collect();
found.sort();
found.dedup();
found
}
pub(crate) fn dependency_import_names(package: &Value) -> Vec<String> {
let mut names: Vec<String> = package["dependencies"]
.as_array()
.map(|deps| {
deps.iter()
.filter_map(|dep| {
dep["rename"]
.as_str()
.or_else(|| dep["name"].as_str())
.map(package_name_to_import_ident)
})
.collect()
})
.unwrap_or_default();
names.sort();
names.dedup();
names
}
pub(crate) fn library_import_names(package: &Value) -> Vec<String> {
const LIBRARY_KINDS: [&str; 6] = ["lib", "rlib", "dylib", "cdylib", "staticlib", "proc-macro"];
package["targets"]
.as_array()
.map(|targets| {
targets
.iter()
.filter(|target| {
target["kind"].as_array().is_some_and(|kinds| {
kinds
.iter()
.any(|kind| kind.as_str().is_some_and(|k| LIBRARY_KINDS.contains(&k)))
})
})
.filter_map(|target| target["name"].as_str().map(package_name_to_import_ident))
.collect()
})
.unwrap_or_default()
}
fn classify_source(dependency: &Value) -> SourceKind {
match dependency["source"].as_str() {
None => SourceKind::Path,
Some(source) if source.starts_with("git+") => SourceKind::Git,
Some(_) => SourceKind::Registry,
}
}
pub(crate) fn dependencies_with_disallowed_source(
package: &Value,
kind: DependencyKind,
allowed: &[SourceKind],
) -> Vec<(String, SourceKind)> {
let mut found: Vec<(String, SourceKind)> = governed_dependencies(package, kind, true)
.filter_map(|dependency| {
let source = classify_source(dependency);
if allowed.contains(&source) {
return None;
}
dependency["name"]
.as_str()
.map(|name| (name.to_string(), source))
})
.collect();
found.sort_by(|(left_name, left_source), (right_name, right_source)| {
left_name
.cmp(right_name)
.then_with(|| left_source.label().cmp(right_source.label()))
});
found.dedup();
found
}
pub(crate) fn declared_features(
package: &Value,
crate_name: &str,
kind: DependencyKind,
) -> Vec<String> {
let mut found = Vec::new();
for dependency in matching_dependency_edges(package, crate_name, kind) {
found.extend(dependency_feature_request(dependency));
}
found.sort();
found.dedup();
found
}
fn matching_dependency_edges<'a>(
package: &'a Value,
crate_name: &str,
kind: DependencyKind,
) -> impl Iterator<Item = &'a Value> {
governed_dependencies(package, kind, true)
.filter(move |dependency| dependency["name"].as_str() == Some(crate_name))
}
fn dependency_feature_request(dependency: &Value) -> Vec<String> {
let mut requested: Vec<String> = dependency["features"]
.as_array()
.into_iter()
.flatten()
.filter_map(Value::as_str)
.map(str::to_string)
.collect();
if dependency["uses_default_features"].as_bool() != Some(false) {
requested.push("default".to_string());
}
requested
}
#[cfg(test)]
mod tests {
use super::*;
use serde_json::json;
#[test]
fn classify_source_reads_the_declared_source_field() {
assert_eq!(
classify_source(&json!({ "name": "localdep", "source": null })),
SourceKind::Path,
"a null source is a path/internal dependency",
);
assert_eq!(
classify_source(&json!({ "name": "gitdep", "source": "git+https://example.com/x" })),
SourceKind::Git,
"a git+ source is git",
);
assert_eq!(
classify_source(&json!({
"name": "crates_io",
"source": "registry+https://github.com/rust-lang/crates.io-index"
})),
SourceKind::Registry,
"a registry+ source is registry",
);
assert_eq!(
classify_source(
&json!({ "name": "alt", "source": "sparse+https://my.registry/index/" })
),
SourceKind::Registry,
"a sparse+ alternative registry is the residual Registry, not misread as git/path",
);
assert_eq!(
classify_source(&json!({ "name": "no_source_key" })),
SourceKind::Path,
);
}
}