use std::collections::{BTreeMap, BTreeSet};
use std::fs;
use std::path::{Path, PathBuf};
use std::process::Command;
use semver::{Version, VersionReq};
use serde::Deserialize;
use toml_edit::{DocumentMut, Item};
use super::paths::{canonicalize, ensure_contained, repo_relative};
use super::DiscoverError;
use crate::manifest::{
dependency_entry, item_workspace_true, member_version, workspace_entry,
workspace_entry_declares_version, EntryMiss, MemberVersion, WorkspaceMiss,
};
use crate::plan::{
Bounds, BuildResolution, Declaration, DeclaredRange, Dependency, DependencyKind, Ecosystem,
ExternalDependency, Package, PackageId, PathCrate, ResolvesDependenciesAt, Workspace,
};
pub fn discover_cargo(
manifest_dir: impl AsRef<Path>,
repository_root: impl AsRef<Path>,
) -> Result<Workspace, DiscoverError> {
let json = run_cargo_metadata(manifest_dir.as_ref())?;
workspace_from_cargo_metadata(&json, repository_root)
}
pub fn workspace_from_cargo_metadata(
json: &str,
repository_root: impl AsRef<Path>,
) -> Result<Workspace, DiscoverError> {
let contained = ContainedMetadata::parse(json, repository_root.as_ref())?;
let (repository_root, workspace_root) = (&contained.repository_root, &contained.workspace_root);
let members = contained.members();
if members.is_empty() {
return Err(DiscoverError::InvalidMetadata {
message: String::from("cargo metadata reported no workspace members"),
});
}
let mut by_dir = BTreeMap::new();
for package in &members {
let dir = package_dir(package)?;
if by_dir.insert(dir.clone(), *package).is_some() {
return Err(DiscoverError::InvalidMetadata {
message: format!(
"duplicate workspace member directories for {}",
dir.display()
),
});
}
}
let patched = patched_members(workspace_root, &by_dir)?;
let mut packages = Vec::with_capacity(members.len());
for package in &members {
packages.push(map_package(
package,
&by_dir,
&patched,
workspace_root,
repository_root,
)?);
}
let root = repo_relative(workspace_root, repository_root)?;
let workspace = Workspace::new(packages)?.with_cargo_workspace_root(root);
Ok(match linked_root_files(workspace_root, repository_root) {
Some((manifest, lock)) => workspace.with_cargo_root_files(manifest, lock),
None => workspace,
})
}
fn linked_root_files(workspace_root: &Path, repository_root: &Path) -> Option<(String, String)> {
let resolve = |name: &str| -> Option<(bool, String)> {
let path = workspace_root.join(name);
let target = fs::symlink_metadata(&path)
.is_ok_and(|meta| meta.file_type().is_symlink())
.then(|| canonicalize(&path).ok())
.flatten()
.and_then(|target| repo_relative(&target, repository_root).ok());
match target {
Some(target) => Some((true, target)),
None => Some((false, repo_relative(&path, repository_root).ok()?)),
}
};
let (manifest_linked, manifest) = resolve("Cargo.toml")?;
let (lock_linked, lock) = resolve("Cargo.lock")?;
(manifest_linked || lock_linked).then_some((manifest, lock))
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct CargoMember {
pub name: String,
pub version: Version,
pub manifest_dir: String,
}
pub fn cargo_members(
manifest_dir: impl AsRef<Path>,
repository_root: impl AsRef<Path>,
) -> Result<Vec<CargoMember>, DiscoverError> {
let json = run_cargo_metadata(manifest_dir.as_ref())?;
members_from_cargo_metadata(&json, repository_root.as_ref())
}
fn members_from_cargo_metadata(
json: &str,
repository_root: &Path,
) -> Result<Vec<CargoMember>, DiscoverError> {
let contained = ContainedMetadata::parse(json, repository_root)?;
contained
.members()
.into_iter()
.map(|package| {
Ok(CargoMember {
name: package.name.clone(),
version: parse_version(package)?,
manifest_dir: repo_relative(&package_dir(package)?, &contained.repository_root)?,
})
})
.collect()
}
struct ContainedMetadata {
meta: Metadata,
repository_root: PathBuf,
workspace_root: PathBuf,
}
impl ContainedMetadata {
fn parse(json: &str, repository_root: &Path) -> Result<Self, DiscoverError> {
let meta: Metadata = serde_json::from_str(json)?;
let repository_root = canonicalize(repository_root)?;
let workspace_root = canonicalize(Path::new(&meta.workspace_root))?;
ensure_contained(&workspace_root, &repository_root)?;
Ok(Self {
meta,
repository_root,
workspace_root,
})
}
fn members(&self) -> Vec<&MetaPackage> {
let member_ids: BTreeSet<&str> = self
.meta
.workspace_members
.iter()
.map(String::as_str)
.collect();
self.meta
.packages
.iter()
.filter(|package| member_ids.contains(package.id.as_str()))
.collect()
}
}
fn parse_version(package: &MetaPackage) -> Result<Version, DiscoverError> {
Version::parse(&package.version).map_err(|err| DiscoverError::Version {
package: package.name.clone(),
message: err.to_string(),
})
}
pub fn discover_cargo_under(
manifest_dir: impl AsRef<Path>,
repository_root: impl AsRef<Path>,
toolchain: Option<&Toolchain>,
) -> Result<Option<Workspace>, DiscoverError> {
let json = run_cargo_metadata_under(manifest_dir.as_ref(), toolchain)?;
let no_members = serde_json::from_str::<serde_json::Value>(&json)
.ok()
.and_then(|metadata| {
metadata
.get("workspace_members")?
.as_array()
.map(Vec::is_empty)
})
.unwrap_or(false);
if no_members {
return Ok(None);
}
workspace_from_cargo_metadata(&json, repository_root).map(Some)
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct Toolchain {
cargo: PathBuf,
rustc: PathBuf,
}
#[must_use]
pub fn running_toolchain(dir: &Path) -> Option<Toolchain> {
let limit = super::child::deadline().ok()?;
let output = super::child::output_within(
Command::new("rustc")
.args(["--print", "sysroot"])
.current_dir(dir),
limit,
)
.ok()?;
if !output.status.success() {
return None;
}
let sysroot = PathBuf::from(String::from_utf8(output.stdout).ok()?.trim());
let bin = |name: &str| {
sysroot
.join("bin")
.join(format!("{name}{}", std::env::consts::EXE_SUFFIX))
};
let toolchain = Toolchain {
cargo: bin("cargo"),
rustc: bin("rustc"),
};
toolchain.cargo.is_file().then_some(toolchain)
}
fn run_cargo_metadata(manifest_dir: &Path) -> Result<String, DiscoverError> {
run_cargo_metadata_under(manifest_dir, None)
}
fn run_cargo_metadata_under(
manifest_dir: &Path,
toolchain: Option<&Toolchain>,
) -> Result<String, DiscoverError> {
const TOOL: &str = "cargo metadata";
let limit = super::child::deadline().map_err(DiscoverError::BadDeadline)?;
let mut command = Command::new(toolchain.map_or(Path::new("cargo"), |t| t.cargo.as_path()));
command
.args(["metadata", "--format-version", "1", "--no-deps"])
.current_dir(manifest_dir);
if let Some(toolchain) = toolchain {
command.env("RUSTC", &toolchain.rustc);
}
let output = super::child::output_within(&mut command, limit).map_err(|failure| {
DiscoverError::from_child(TOOL, failure, |source| DiscoverError::CargoNotRunnable {
source,
})
})?;
if !output.status.success() {
return Err(DiscoverError::CargoMetadata {
status: output.status.code(),
message: super::child::complaint(&output),
});
}
String::from_utf8(output.stdout).map_err(|err| DiscoverError::InvalidMetadata {
message: format!("stdout was not utf-8: {err}"),
})
}
struct Patched {
key: String,
name: String,
version: Version,
}
fn patched_members(
workspace_root: &Path,
members_by_dir: &BTreeMap<PathBuf, &MetaPackage>,
) -> Result<Vec<Patched>, DiscoverError> {
let manifest = read_manifest(&workspace_root.join("Cargo.toml"))?;
let mut patched = Vec::new();
let Some(sources) = manifest.get("patch").and_then(Item::as_table_like) else {
return Ok(patched);
};
for (key, entries) in sources.iter() {
let Some(entries) = entries.as_table_like() else {
continue;
};
for (_, entry) in entries.iter() {
let Some(path) = entry.get("path").and_then(Item::as_str) else {
continue;
};
let Ok(dir) = canonicalize(&workspace_root.join(path)) else {
continue;
};
if let Some(member) = members_by_dir.get(&dir) {
patched.push(Patched {
key: key.to_owned(),
name: member.name.clone(),
version: parse_version(member)?,
});
}
}
}
Ok(patched)
}
impl Patched {
fn applies_to(&self, dep: &MetaDependency, unversioned: bool) -> bool {
let unversioned_git = unversioned
&& dep
.source
.as_deref()
.is_some_and(|source| source.starts_with("git+"));
self.name == dep.name
&& patch_applies(&self.key, dep.source.as_deref())
&& (unversioned_git
|| VersionReq::parse(&dep.req).is_ok_and(|req| req.matches(&self.version)))
}
}
fn patch_applies(key: &str, source: Option<&str>) -> bool {
let Some(source) = source else {
return false;
};
if key == "crates-io" {
return source == CRATES_IO;
}
let source = if source.starts_with("sparse+") {
source
} else if let Some(url) = source
.strip_prefix("registry+")
.or_else(|| source.strip_prefix("git+"))
{
url.split(['?', '#']).next().unwrap_or(url)
} else {
return false;
};
canonical_url(source).is_some_and(|source| canonical_url(key) == Some(source))
}
fn canonical_url(url: &str) -> Option<String> {
let mut url = url::Url::parse(url).ok()?;
if !url.scheme().contains('+') && url.host_str() == Some("github.com") {
url = format!("https{}", &url[url::Position::AfterScheme..])
.parse()
.ok()?;
}
let mut path = url.path().to_owned();
if path.len() > 1 {
if let Some(stripped) = path.strip_suffix('/') {
path = stripped.to_owned();
}
}
if !url.scheme().contains('+') {
if url.host_str() == Some("github.com") {
path = path.to_lowercase();
}
if let Some(stripped) = path.strip_suffix(".git") {
path = stripped.to_owned();
}
}
url.set_path(&path);
Some(url.to_string())
}
const CRATES_IO: &str = "registry+https://github.com/rust-lang/crates.io-index";
fn map_package(
package: &MetaPackage,
members_by_dir: &BTreeMap<PathBuf, &MetaPackage>,
patched: &[Patched],
workspace_root: &Path,
repository_root: &Path,
) -> Result<Package, DiscoverError> {
let version = parse_version(package)?;
let resolves = resolution(&package.targets);
let mut manifest = read_manifest(Path::new(&package.manifest_path))?;
let mut dependencies = Vec::new();
let mut external_dependencies = Vec::new();
let mut inherited_path_dependencies = BTreeSet::new();
let mut path_crates = Vec::new();
for dep in &package.dependencies {
let declared_as = declared_as(dep);
let kind = dependency_kind(package, dep).unwrap_or(DependencyKind::Normal);
let inherited = dependency_entry(&mut manifest, kind, dep.target.as_deref(), &declared_as)
.map_or(true, |entry| item_workspace_true(entry));
let Some(dep_path) = dep.path.as_ref() else {
let unversioned = dep.req == "*"
&& !dependency_declares_version(
Path::new(&package.manifest_path),
workspace_root,
&declared_as,
kind,
dep.target.as_deref(),
&package.name,
&dep.name,
)
.unwrap_or(true);
if patched
.iter()
.any(|member| member.applies_to(dep, unversioned))
{
if inherited && kind.is_runtime() {
inherited_path_dependencies.insert(declared_as.clone());
}
dependencies.push(map_dependency(package, dep, workspace_root)?);
}
external_dependencies.push(ExternalDependency {
name: dep.name.clone(),
declared_as,
kind,
source: dep.source.clone(),
req: VersionReq::parse(&dep.req).unwrap_or(VersionReq::STAR),
inherited,
declaration: dep.declaration(None),
});
continue;
};
if inherited && kind.is_runtime() {
inherited_path_dependencies.insert(declared_as.clone());
}
let dep_dir = canonicalize(Path::new(dep_path))?;
let Some(member) = members_by_dir.get(&dep_dir) else {
let dir = repo_relative(&dep_dir, repository_root).ok();
if let Some(dir) = &dir {
path_crates.push(PathCrate {
name: dep.name.clone(),
dir: dir.clone(),
kind,
});
}
external_dependencies.push(ExternalDependency {
name: dep.name.clone(),
declared_as,
kind,
source: None,
req: VersionReq::parse(&dep.req).unwrap_or(VersionReq::STAR),
inherited,
declaration: dep.declaration(dir),
});
continue;
};
if member.name != dep.name {
return Err(DiscoverError::InvalidMetadata {
message: format!(
"{} path dependency {} resolves to package {}, not {}",
package.name, dep_path, member.name, dep.name
),
});
}
dependencies.push(map_dependency(package, dep, workspace_root)?);
}
let dir = package_dir(package)?;
let manifest_dir = repo_relative(&dir, repository_root)?;
Ok(Package::new(
PackageId::new(Ecosystem::Cargo, package.name.clone()),
version,
resolves,
cargo_is_publishable(package.publish.as_ref()),
dependencies,
)
.with_external_dependencies(external_dependencies)
.with_inherited_fields(inherited_fields(&manifest))
.with_inherited_path_dependencies(inherited_path_dependencies)
.with_path_crates(path_crates)
.with_manifest_dir(manifest_dir)
.with_ships_library(ships_library(&package.targets)))
}
fn resolution(targets: &[MetaTarget]) -> ResolvesDependenciesAt {
if targets.iter().any(|t| t.kind.iter().any(|k| k == "bin")) {
ResolvesDependenciesAt::Build(BuildResolution::BinaryTarget)
} else {
ResolvesDependenciesAt::Install
}
}
fn ships_library(targets: &[MetaTarget]) -> bool {
targets.iter().any(|target| {
target
.kind
.iter()
.any(|kind| matches!(kind.as_str(), "lib" | "rlib" | "dylib" | "proc-macro"))
})
}
fn inherited_fields(manifest: &DocumentMut) -> BTreeSet<String> {
manifest
.get("package")
.and_then(Item::as_table_like)
.map(|table| {
table
.iter()
.filter(|(_, item)| item_workspace_true(item))
.map(|(key, _)| key.to_owned())
.collect()
})
.unwrap_or_default()
}
fn cargo_is_publishable(publish: Option<&Vec<String>>) -> bool {
match publish {
None => true,
Some(registries) => !registries.is_empty(),
}
}
fn map_dependency(
dependent: &MetaPackage,
dep: &MetaDependency,
workspace_root: &Path,
) -> Result<Dependency, DiscoverError> {
let kind = dependency_kind(dependent, dep)?;
let declared_as = declared_as(dep);
let range = declared_range(dependent, dep, &declared_as, kind, workspace_root)?;
Ok(Dependency {
on: PackageId::new(Ecosystem::Cargo, dep.name.clone()),
kind,
declared_as,
target: dep.target.clone(),
range,
})
}
fn dependency_kind(
dependent: &MetaPackage,
dep: &MetaDependency,
) -> Result<DependencyKind, DiscoverError> {
match dep.kind.as_deref() {
None => Ok(DependencyKind::Normal),
Some("dev") => Ok(DependencyKind::Development),
Some("build") => Ok(DependencyKind::Build),
Some(other) => Err(DiscoverError::UnknownDependencyKind {
package: dependent.name.clone(),
dependency: dep.name.clone(),
kind: other.to_owned(),
}),
}
}
fn declared_as(dep: &MetaDependency) -> String {
dep.rename.clone().unwrap_or_else(|| dep.name.clone())
}
fn declared_range(
dependent: &MetaPackage,
dep: &MetaDependency,
declared_as: &str,
kind: DependencyKind,
workspace_root: &Path,
) -> Result<DeclaredRange, DiscoverError> {
if dep.req == "*" {
let manifest = PathBuf::from(&dependent.manifest_path);
if !dependency_declares_version(
&manifest,
workspace_root,
declared_as,
kind,
dep.target.as_deref(),
&dependent.name,
&dep.name,
)? {
return Ok(DeclaredRange::PathLinked);
}
}
let bounds = Bounds::from_cargo_text(&dep.req).map_err(|err| DiscoverError::Range {
package: dependent.name.clone(),
dependency: dep.name.clone(),
message: err.to_string(),
})?;
Ok(DeclaredRange::Plain(bounds))
}
fn dependency_declares_version(
manifest_path: &Path,
workspace_root: &Path,
declared_as: &str,
kind: DependencyKind,
target: Option<&str>,
package_name: &str,
dependency_name: &str,
) -> Result<bool, DiscoverError> {
let mut doc = read_manifest(manifest_path)?;
let section = kind.section(Ecosystem::Cargo).unwrap_or_default();
let predicate = target.unwrap_or_default();
let toml_error = |message: String| DiscoverError::Toml {
path: manifest_path.to_path_buf(),
message,
};
let entry = dependency_entry(&mut doc, kind, target, declared_as).map_err(|miss| match miss {
EntryMiss::KindHasNoSection => DiscoverError::UnknownDependencyKind {
package: package_name.to_owned(),
dependency: dependency_name.to_owned(),
kind: format!("{kind}"),
},
EntryMiss::TargetTable => toml_error(format!(
"{package_name}: metadata listed target {predicate:?} for {declared_as}, but manifest has no [target]"
)),
EntryMiss::TargetPredicate => toml_error(format!(
"{package_name}: metadata listed target {predicate:?} for {declared_as}, missing from manifest"
)),
EntryMiss::SectionTable => toml_error(format!(
"{package_name}: metadata listed {declared_as} under {section}, missing from manifest"
)),
EntryMiss::Key => toml_error(format!(
"{package_name}: metadata listed dependency key {declared_as}, missing from manifest"
)),
})?;
match member_version(entry) {
MemberVersion::Declared => Ok(true),
MemberVersion::Absent => Ok(false),
MemberVersion::Inherited => workspace_dependency_declares_version(
workspace_root,
declared_as,
package_name,
dependency_name,
),
MemberVersion::Unexpected => Err(toml_error(format!(
"{package_name} dependency {declared_as}: unexpected TOML value {entry:?}"
))),
}
}
fn read_manifest(path: &Path) -> Result<DocumentMut, DiscoverError> {
let text = fs::read_to_string(path).map_err(|source| DiscoverError::Io {
path: path.to_path_buf(),
source,
})?;
text.parse()
.map_err(|err: toml_edit::TomlError| DiscoverError::Toml {
path: path.to_path_buf(),
message: err.to_string(),
})
}
fn workspace_dependency_declares_version(
workspace_root: &Path,
declared_as: &str,
package_name: &str,
dependency_name: &str,
) -> Result<bool, DiscoverError> {
let root_manifest = workspace_root.join("Cargo.toml");
let mut doc = read_manifest(&root_manifest)?;
let toml_error = |message: String| DiscoverError::Toml {
path: root_manifest.clone(),
message,
};
let entry = workspace_entry(&mut doc, declared_as).map_err(|miss| match miss {
WorkspaceMiss::WorkspaceTable => toml_error(format!(
"{package_name} inherits {dependency_name} via workspace = true, but root has no [workspace]"
)),
WorkspaceMiss::DependenciesTable => toml_error(format!(
"{package_name} inherits {dependency_name} via workspace = true, but root has no [workspace.dependencies]"
)),
WorkspaceMiss::Key => toml_error(format!(
"{package_name} inherits {declared_as}, but [workspace.dependencies] has no such key"
)),
})?;
workspace_entry_declares_version(entry).ok_or_else(|| {
toml_error(format!(
"[workspace.dependencies].{declared_as}: unexpected {entry:?}"
))
})
}
fn package_dir(package: &MetaPackage) -> Result<PathBuf, DiscoverError> {
let manifest = Path::new(&package.manifest_path);
let Some(dir) = manifest.parent() else {
return Err(DiscoverError::InvalidMetadata {
message: format!("package {} has no manifest directory", package.name),
});
};
canonicalize(dir)
}
#[derive(Debug, Deserialize)]
struct Metadata {
packages: Vec<MetaPackage>,
workspace_members: Vec<String>,
workspace_root: String,
}
#[derive(Debug, Deserialize)]
struct MetaPackage {
name: String,
version: String,
id: String,
manifest_path: String,
publish: Option<Vec<String>>,
dependencies: Vec<MetaDependency>,
targets: Vec<MetaTarget>,
}
#[derive(Debug, Deserialize)]
struct MetaDependency {
name: String,
req: String,
kind: Option<String>,
rename: Option<String>,
target: Option<String>,
path: Option<String>,
source: Option<String>,
#[serde(default)]
features: BTreeSet<String>,
#[serde(default = "default_true")]
uses_default_features: bool,
#[serde(default)]
optional: bool,
}
const fn default_true() -> bool {
true
}
impl MetaDependency {
fn declaration(&self, path: Option<String>) -> Declaration {
Declaration {
target: self.target.clone(),
features: self.features.clone(),
default_features: self.uses_default_features,
optional: self.optional,
path,
}
}
}
#[derive(Debug, Deserialize)]
struct MetaTarget {
kind: Vec<String>,
}
#[cfg(test)]
mod tests {
use super::*;
fn patched_helper(key: &str, version: &str) -> Patched {
Patched {
key: key.to_owned(),
name: String::from("helper"),
version: Version::parse(version).expect("version"),
}
}
fn helper_from(source: &str, req: &str) -> MetaDependency {
serde_json::from_value(serde_json::json!({
"name": "helper", "req": req, "kind": null, "rename": null, "target": null,
"path": null, "source": source
}))
.expect("dependency")
}
#[test]
fn only_an_unversioned_git_declaration_takes_a_prerelease_member() {
let git = "https://example.invalid/helper";
let from_git = helper_from(&format!("git+{git}"), "*");
let member = patched_helper(git, "0.1.0-dev");
assert!(member.applies_to(&from_git, true));
assert!(!member.applies_to(&from_git, false));
let member = patched_helper("crates-io", "0.1.0-dev");
assert!(!member.applies_to(&helper_from(CRATES_IO, "*"), true));
assert!(
patched_helper("crates-io", "0.1.0").applies_to(&helper_from(CRATES_IO, "*"), false)
);
}
use crate::plan::DeclaredRange;
fn fixture_dir(name: &str) -> PathBuf {
PathBuf::from(env!("CARGO_MANIFEST_DIR"))
.join("tests/fixtures/cargo-discover")
.join(name)
}
fn discover(name: &str) -> Workspace {
let root = fixture_dir(name);
discover_cargo(&root, &root).expect("discover")
}
#[test]
fn cargo_members_lists_each_member_with_its_directory() {
let root = fixture_dir("workspace-inherit-star");
let mut members = cargo_members(&root, &root).expect("members");
members.sort_by(|a, b| a.name.cmp(&b.name));
let listed: Vec<(&str, &str)> = members
.iter()
.map(|member| (member.name.as_str(), member.manifest_dir.as_str()))
.collect();
assert_eq!(listed, [("app", "app"), ("core", "core")]);
assert_eq!(members[0].version, Version::new(0, 1, 0));
}
#[test]
fn cargo_members_of_an_empty_workspace_is_empty() {
let root = crate::test_fixture::Fixture::new("cargo-members", "empty");
fs::write(root.join("Cargo.toml"), "[workspace]\nmembers = []\n").expect("manifest");
assert_eq!(cargo_members(&root, &root).expect("no members"), []);
assert!(discover_cargo(&root, &root).is_err());
}
#[test]
fn lone_lib_is_one_member_workspace() {
let root = fixture_dir("lone-lib");
let workspace = discover_cargo(&root, &root).expect("discover");
assert_eq!(workspace.packages().count(), 1);
let pkg = workspace
.get(&PackageId::new(Ecosystem::Cargo, "lone-lib"))
.expect("lone-lib");
assert_eq!(
pkg.resolves_dependencies_at(),
ResolvesDependenciesAt::Install
);
assert_eq!(pkg.manifest_dir(), "");
assert!(pkg.ships_library());
assert_eq!(workspace.cargo_workspace_root(), Some(""));
assert!(
!root.join("Cargo.lock").exists(),
"--no-deps must not write a lockfile"
);
}
#[test]
fn binary_target_marks_build_resolution() {
let pkg = discover("with-bin")
.get(&PackageId::new(Ecosystem::Cargo, "with-bin"))
.expect("with-bin")
.clone();
assert_eq!(
pkg.resolves_dependencies_at(),
ResolvesDependenciesAt::Build(BuildResolution::BinaryTarget)
);
assert!(!pkg.ships_library());
}
#[test]
fn a_library_target_ships_a_library_and_a_cdylib_alone_does_not() {
let read = |kinds: &str| -> bool {
let kind: Vec<String> = serde_json::from_str(kinds).expect("kinds");
ships_library(&[MetaTarget { kind }])
};
for kinds in [
r#"["lib"]"#,
r#"["rlib","cdylib"]"#,
r#"["dylib"]"#,
r#"["proc-macro"]"#,
] {
assert!(read(kinds), "{kinds}");
}
for kinds in [r#"["cdylib"]"#, r#"["staticlib"]"#, r#"["bin"]"#] {
assert!(!read(kinds), "{kinds}");
}
}
#[test]
fn path_only_edge_is_path_linked() {
let edge = discover("path-linked")
.get(&PackageId::new(Ecosystem::Cargo, "app"))
.expect("app")
.dependencies()
.iter()
.find(|d| d.on.name == "core")
.expect("edge")
.clone();
assert_eq!(edge.range, DeclaredRange::PathLinked);
}
#[test]
fn nested_members_have_repo_relative_dirs() {
let workspace = discover("path-linked");
assert_eq!(
workspace
.get(&PackageId::new(Ecosystem::Cargo, "app"))
.expect("app")
.manifest_dir(),
"app"
);
assert_eq!(
workspace
.get(&PackageId::new(Ecosystem::Cargo, "core"))
.expect("core")
.manifest_dir(),
"core"
);
assert_eq!(workspace.cargo_workspace_root(), Some(""));
}
#[test]
fn path_with_star_version_is_plain_star() {
let edge = discover("path-star-version")
.get(&PackageId::new(Ecosystem::Cargo, "app"))
.expect("app")
.dependencies()
.iter()
.find(|d| d.on.name == "core")
.expect("edge")
.clone();
let expected = DeclaredRange::Plain(Bounds::from_cargo_text("*").expect("*"));
assert_eq!(edge.range, expected);
}
#[test]
fn workspace_inherited_star_is_plain_star() {
let edge = discover("workspace-inherit-star")
.get(&PackageId::new(Ecosystem::Cargo, "app"))
.expect("app")
.dependencies()
.iter()
.find(|d| d.on.name == "core")
.expect("edge")
.clone();
let expected = DeclaredRange::Plain(Bounds::from_cargo_text("*").expect("*"));
assert_eq!(edge.range, expected);
}
#[test]
fn cargo_publish_null_is_publishable_empty_list_is_not() {
assert!(cargo_is_publishable(None));
assert!(!cargo_is_publishable(Some(&Vec::new())));
assert!(cargo_is_publishable(Some(&vec![String::from("crates-io")])));
}
#[test]
fn publish_gate_maps_null_empty_and_allow_list() {
let workspace = discover("publish-gate");
let open = workspace
.get(&PackageId::new(Ecosystem::Cargo, "open"))
.expect("open");
let closed = workspace
.get(&PackageId::new(Ecosystem::Cargo, "closed"))
.expect("closed");
let restricted = workspace
.get(&PackageId::new(Ecosystem::Cargo, "restricted"))
.expect("restricted");
assert!(open.publishable());
assert!(!closed.publishable());
assert!(restricted.publishable());
}
#[test]
fn workspace_maps_runtime_and_dev_edges() {
let workspace = discover("workspace");
assert_eq!(workspace.packages().count(), 3);
let cli = workspace
.get(&PackageId::new(Ecosystem::Cargo, "cli"))
.expect("cli");
assert_eq!(
cli.resolves_dependencies_at(),
ResolvesDependenciesAt::Build(BuildResolution::BinaryTarget)
);
let normal = cli
.dependencies()
.iter()
.find(|d| d.on.name == "core" && d.kind == DependencyKind::Normal)
.expect("normal");
assert!(matches!(normal.range, DeclaredRange::Plain(_)));
let tool = workspace
.get(&PackageId::new(Ecosystem::Cargo, "tool"))
.expect("tool");
let dev = tool
.dependencies()
.iter()
.find(|d| d.kind == DependencyKind::Development)
.expect("dev");
assert_eq!(dev.on.name, "core");
}
#[test]
fn a_patch_table_applies_to_its_own_source_only() {
let git = "git+https://github.com/o/r?branch=main#cafebabe";
let sparse = "sparse+https://registry.example/index/";
let registry = "registry+https://registry.example/git-index";
for (key, source) in [
("crates-io", CRATES_IO),
("https://github.com/o/r", git),
("https://github.com/O/r.git/", git),
("http://github.com/o/R.GIT", git),
("ssh://git@github.com/o/r", "git+ssh://git@github.com/o/r"),
("sparse+https://registry.example/index/", sparse),
("https://registry.example/git-index", registry),
] {
assert!(patch_applies(key, Some(source)), "{key} {source}");
}
for (key, source) in [
("https://registry.example/index/", sparse),
("sparse+https://registry.example/git-index", registry),
("https://github.com/o/r", "git+https://github.com/o/r2"),
("crates-io", git),
("https://github.com/o/r", CRATES_IO),
("my-registry", sparse),
] {
assert!(!patch_applies(key, Some(source)), "{key} {source}");
}
assert!(!patch_applies("crates-io", None));
}
fn external(
name: &str,
declared_as: &str,
kind: DependencyKind,
req: &str,
) -> ExternalDependency {
ExternalDependency {
name: name.to_owned(),
declared_as: declared_as.to_owned(),
kind,
source: Some(CRATES_IO.to_owned()),
req: VersionReq::parse(req).expect("req"),
inherited: false,
declaration: Declaration::default(),
}
}
fn inherited(dep: ExternalDependency) -> ExternalDependency {
ExternalDependency {
inherited: true,
..dep
}
}
#[test]
fn registry_and_git_dependencies_are_kept_beside_the_graph() {
let workspace = discover("external-deps");
let externals = |name: &str| {
let mut list = workspace
.get(&PackageId::new(Ecosystem::Cargo, name))
.expect(name)
.external_dependencies()
.to_vec();
list.sort_by(|a, b| a.name.cmp(&b.name));
list
};
assert_eq!(
externals("cli"),
[
ExternalDependency {
declaration: Declaration {
optional: true,
..Declaration::default()
},
..external("anyhow", "anyhow", DependencyKind::Normal, "^1")
},
external("cc", "cc", DependencyKind::Build, "^1"),
ExternalDependency {
source: Some(String::from("git+https://example.invalid/foo.git")),
..external("foo", "gitdep", DependencyKind::Normal, "*")
},
ExternalDependency {
source: None,
declaration: Declaration {
features: BTreeSet::from([String::from("fast")]),
path: Some(String::from("helper")),
..Declaration::default()
},
..external("helper", "helper", DependencyKind::Normal, "*")
},
inherited(external(
"serde",
"serde",
DependencyKind::Development,
"^1"
)),
ExternalDependency {
declaration: Declaration {
features: BTreeSet::from([String::from("std")]),
default_features: false,
..Declaration::default()
},
..external("serde_json", "json", DependencyKind::Normal, "^1")
},
ExternalDependency {
declaration: Declaration {
target: Some(String::from("cfg(windows)")),
..Declaration::default()
},
..external("winapi", "winapi", DependencyKind::Normal, "^0.3")
},
]
);
assert_eq!(externals("core"), []);
assert_eq!(
externals("store"),
[ExternalDependency {
declaration: Declaration {
features: BTreeSet::from([String::from("bundled")]),
..Declaration::default()
},
..inherited(external(
"rusqlite",
"rusqlite",
DependencyKind::Normal,
"^0.31"
))
}]
);
let fields = |name: &str| {
workspace
.get(&PackageId::new(Ecosystem::Cargo, name))
.expect(name)
.inherited_fields()
.clone()
};
assert!(fields("cli").is_empty());
assert_eq!(fields("store"), BTreeSet::from([String::from("edition")]));
let paths = |name: &str| {
workspace
.get(&PackageId::new(Ecosystem::Cargo, name))
.expect(name)
.inherited_path_dependencies()
.clone()
};
assert!(paths("cli").is_empty(), "cli writes its `core` path out");
assert_eq!(paths("core"), BTreeSet::from([String::from("store")]));
}
#[test]
fn an_external_dependency_of_an_unknown_kind_counts_as_normal() {
let root = fixture_dir("external-deps");
let json = run_cargo_metadata(&root)
.expect("metadata")
.replace(r#""kind":"build""#, r#""kind":"future""#);
assert!(
json.contains(r#""kind":"future""#),
"fixture lost its build dependency"
);
let workspace = workspace_from_cargo_metadata(&json, &root).expect("discover");
let cc = workspace
.get(&PackageId::new(Ecosystem::Cargo, "cli"))
.expect("cli")
.external_dependencies()
.iter()
.find(|dep| dep.name == "cc")
.expect("cc");
assert_eq!(cc.kind, DependencyKind::Normal);
}
#[test]
fn exit_101_relays_cargo_stderr() {
let root = fixture_dir("stray-nested");
let err = discover_cargo(root.join("stray"), &root).expect_err("must fail");
match err {
DiscoverError::CargoMetadata {
status: Some(101),
message,
} => {
assert!(
message.contains("workspace") || message.contains("members"),
"expected cargo's stray-manifest wording, got: {message}"
);
}
other => panic!("expected CargoMetadata exit 101, got {other}"),
}
}
#[test]
fn workspace_root_outside_repository_is_rejected() {
let outside = std::env::temp_dir();
let json = serde_json::json!({
"packages": [],
"workspace_members": [],
"workspace_root": outside,
});
let err = workspace_from_cargo_metadata(&json.to_string(), fixture_dir("lone-lib"))
.expect_err("outside root");
assert!(
matches!(err, DiscoverError::WorkspaceRootOutsideRepository { .. }),
"{err}"
);
}
#[test]
fn workspace_root_missing_is_io() {
let json = serde_json::json!({
"packages": [],
"workspace_members": [],
"workspace_root": "/this-path-does-not-exist-oakum-probe",
});
let err = workspace_from_cargo_metadata(&json.to_string(), fixture_dir("lone-lib"))
.expect_err("missing root");
assert!(matches!(err, DiscoverError::Io { .. }), "{err}");
}
#[cfg(windows)]
#[test]
fn workspace_root_unix_tmp_is_io_on_windows() {
let json = r#"{"packages":[],"workspace_members":[],"workspace_root":"/tmp"}"#;
let err =
workspace_from_cargo_metadata(json, fixture_dir("lone-lib")).expect_err("unix tmp");
assert!(matches!(err, DiscoverError::Io { .. }), "{err}");
}
}