use alloc::collections::{BTreeMap, BTreeSet};
use alloc::string::String;
use alloc::vec::Vec;
use core::fmt;
use semver::{Comparator, Op, Version, VersionReq};
use super::bounds::Bounds;
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum Ecosystem {
Npm,
Cargo,
}
impl Ecosystem {
#[must_use]
pub const fn manifest_name(self) -> &'static str {
match self {
Self::Npm => "package.json",
Self::Cargo => "Cargo.toml",
}
}
const fn has_range_protocols(self) -> bool {
match self {
Self::Npm => true,
Self::Cargo => false,
}
}
const fn has_target_tables(self) -> bool {
match self {
Self::Npm => false,
Self::Cargo => true,
}
}
}
impl fmt::Display for Ecosystem {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(match self {
Self::Npm => "npm",
Self::Cargo => "cargo",
})
}
}
#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct PackageId {
pub ecosystem: Ecosystem,
pub name: String,
}
impl PackageId {
#[must_use]
pub fn new(ecosystem: Ecosystem, name: impl Into<String>) -> Self {
Self {
ecosystem,
name: name.into(),
}
}
}
impl fmt::Display for PackageId {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{} ({})", self.name, self.ecosystem)
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum DependencyKind {
Normal,
Peer,
Optional,
Build,
Development,
}
impl DependencyKind {
#[must_use]
pub const fn section(self, ecosystem: Ecosystem) -> Option<&'static str> {
match (ecosystem, self) {
(Ecosystem::Npm | Ecosystem::Cargo, Self::Normal) => Some("dependencies"),
(Ecosystem::Npm, Self::Peer) => Some("peerDependencies"),
(Ecosystem::Npm, Self::Optional) => Some("optionalDependencies"),
(Ecosystem::Npm, Self::Development) => Some("devDependencies"),
(Ecosystem::Cargo, Self::Build) => Some("build-dependencies"),
(Ecosystem::Cargo, Self::Development) => Some("dev-dependencies"),
(Ecosystem::Npm, Self::Build) | (Ecosystem::Cargo, Self::Peer | Self::Optional) => None,
}
}
#[must_use]
pub const fn is_runtime(self) -> bool {
match self {
Self::Normal | Self::Peer | Self::Optional | Self::Build => true,
Self::Development => false,
}
}
}
impl fmt::Display for DependencyKind {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(match self {
Self::Normal => "normal",
Self::Peer => "peer",
Self::Optional => "optional",
Self::Build => "build",
Self::Development => "development",
})
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Tracking {
Exact,
Tilde,
Caret,
}
impl fmt::Display for Tracking {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(match self {
Self::Exact => "*",
Self::Tilde => "~",
Self::Caret => "^",
})
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum RangeProtocol {
Workspace,
Catalog,
}
impl fmt::Display for RangeProtocol {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(match self {
Self::Workspace => "workspace:",
Self::Catalog => "catalog:",
})
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum DeclaredRange {
Plain(Bounds),
Workspace(Bounds),
WorkspaceTracking(Tracking),
Catalog {
name: Option<String>,
bounds: Bounds,
},
PathLinked,
}
impl fmt::Display for DeclaredRange {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::Plain(bounds) => write!(f, "{bounds}"),
Self::Workspace(bounds) => write!(f, "workspace:{bounds}"),
Self::WorkspaceTracking(tracking) => write!(f, "workspace:{tracking}"),
Self::Catalog { name: None, .. } => f.write_str("catalog:"),
Self::Catalog {
name: Some(name), ..
} => write!(f, "catalog:{name}"),
Self::PathLinked => f.write_str("path-linked"),
}
}
}
impl DeclaredRange {
#[must_use]
pub const fn protocol(&self) -> Option<RangeProtocol> {
match self {
Self::Workspace(_) | Self::WorkspaceTracking(_) => Some(RangeProtocol::Workspace),
Self::Catalog { .. } => Some(RangeProtocol::Catalog),
Self::Plain(_) | Self::PathLinked => None,
}
}
#[must_use]
pub const fn is_path_linked(&self) -> bool {
matches!(self, Self::PathLinked)
}
fn expand_tracking(tracking: Tracking, version_at_last_tag: &Version) -> VersionReq {
VersionReq {
comparators: Vec::from([Comparator {
op: match tracking {
Tracking::Exact => Op::Exact,
Tracking::Tilde => Op::Tilde,
Tracking::Caret => Op::Caret,
},
major: version_at_last_tag.major,
minor: Some(version_at_last_tag.minor),
patch: Some(version_at_last_tag.patch),
pre: version_at_last_tag.pre.clone(),
}]),
}
}
#[must_use]
pub fn admits(&self, version_at_last_tag: &Version, candidate: &Version) -> bool {
match self {
Self::PathLinked => false,
Self::Plain(bounds) | Self::Workspace(bounds) | Self::Catalog { bounds, .. } => {
bounds.matches(candidate)
}
Self::WorkspaceTracking(tracking) => {
Self::expand_tracking(*tracking, version_at_last_tag).matches(candidate)
}
}
}
#[must_use]
pub fn retargeted_text(&self, new: &Version) -> Option<String> {
match self {
Self::Plain(bounds) | Self::Workspace(bounds) if bounds.is_blank() => None,
Self::Plain(bounds) => bounds.retargeted(new),
Self::Workspace(bounds) => bounds
.retargeted(new)
.map(|range| alloc::format!("workspace:{range}")),
Self::WorkspaceTracking(_) | Self::Catalog { .. } | Self::PathLinked => None,
}
}
const fn fits_ecosystem(&self, ecosystem: Ecosystem) -> bool {
matches!(
(ecosystem, self),
(
Ecosystem::Cargo,
Self::PathLinked | Self::Plain(Bounds::Cargo(_))
) | (
Ecosystem::Npm,
Self::Plain(Bounds::Npm { .. })
| Self::Workspace(Bounds::Npm { .. })
| Self::Catalog {
bounds: Bounds::Npm { .. },
..
}
| Self::WorkspaceTracking(_)
)
)
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct Dependency {
pub on: PackageId,
pub kind: DependencyKind,
pub declared_as: String,
pub target: Option<String>,
pub range: DeclaredRange,
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct UnlinkedDependency {
pub on: String,
pub declared_as: String,
pub kind: DependencyKind,
pub range: DeclaredRange,
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct ExternalDependency {
pub name: String,
pub declared_as: String,
pub kind: DependencyKind,
pub source: Option<String>,
pub req: VersionReq,
pub inherited: bool,
pub declaration: Declaration,
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct Declaration {
pub target: Option<String>,
pub features: BTreeSet<String>,
pub default_features: bool,
pub optional: bool,
pub path: Option<String>,
}
impl Default for Declaration {
fn default() -> Self {
Self {
target: None,
features: BTreeSet::new(),
default_features: true,
optional: false,
path: None,
}
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct PathCrate {
pub name: String,
pub dir: String,
pub kind: DependencyKind,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum ResolvesDependenciesAt {
Install,
Build(BuildResolution),
}
impl ResolvesDependenciesAt {
#[must_use]
pub const fn is_build(self) -> bool {
match self {
Self::Build(_) => true,
Self::Install => false,
}
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum BuildResolution {
BinaryTarget,
Declared,
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct Package {
id: PackageId,
version: Version,
resolves_dependencies_at: ResolvesDependenciesAt,
publishable: bool,
dependencies: Vec<Dependency>,
external_dependencies: Vec<ExternalDependency>,
unlinked_dependencies: Vec<UnlinkedDependency>,
inherited_fields: BTreeSet<String>,
inherited_path_dependencies: BTreeSet<String>,
path_crates: Vec<PathCrate>,
manifest_dir: String,
ships_library: bool,
}
impl Package {
#[must_use]
pub fn new(
id: PackageId,
version: Version,
resolves_dependencies_at: ResolvesDependenciesAt,
publishable: bool,
dependencies: Vec<Dependency>,
) -> Self {
Self {
id,
version,
resolves_dependencies_at,
publishable,
dependencies,
external_dependencies: Vec::new(),
unlinked_dependencies: Vec::new(),
inherited_fields: BTreeSet::new(),
inherited_path_dependencies: BTreeSet::new(),
path_crates: Vec::new(),
manifest_dir: String::new(),
ships_library: false,
}
}
#[must_use]
pub const fn with_ships_library(mut self, ships: bool) -> Self {
self.ships_library = ships;
self
}
#[must_use]
pub const fn ships_library(&self) -> bool {
self.ships_library
}
#[must_use]
pub fn with_path_crates(mut self, crates: Vec<PathCrate>) -> Self {
self.path_crates = crates;
self
}
#[must_use]
pub fn with_external_dependencies(mut self, external: Vec<ExternalDependency>) -> Self {
self.external_dependencies = external;
self
}
#[must_use]
pub fn with_unlinked_dependencies(mut self, unlinked: Vec<UnlinkedDependency>) -> Self {
self.unlinked_dependencies = unlinked;
self
}
#[must_use]
pub fn with_inherited_fields(mut self, fields: BTreeSet<String>) -> Self {
self.inherited_fields = fields;
self
}
#[must_use]
pub fn with_inherited_path_dependencies(mut self, keys: BTreeSet<String>) -> Self {
self.inherited_path_dependencies = keys;
self
}
#[must_use]
pub fn with_manifest_dir(mut self, dir: impl Into<String>) -> Self {
self.manifest_dir = dir.into();
self
}
#[must_use]
pub fn with_resolves_dependencies_at(mut self, at: ResolvesDependenciesAt) -> Self {
let binary = ResolvesDependenciesAt::Build(BuildResolution::BinaryTarget);
let declared = ResolvesDependenciesAt::Build(BuildResolution::Declared);
if !(at == declared && self.resolves_dependencies_at == binary) {
self.resolves_dependencies_at = at;
}
self
}
#[must_use]
pub fn manifest_dir(&self) -> &str {
&self.manifest_dir
}
#[must_use]
pub fn file_path(&self, name: &str) -> String {
in_dir(&self.manifest_dir, name)
}
#[must_use]
pub fn manifest_path(&self) -> String {
self.file_path(self.id.ecosystem.manifest_name())
}
#[must_use]
pub const fn id(&self) -> &PackageId {
&self.id
}
#[must_use]
pub const fn version(&self) -> &Version {
&self.version
}
#[must_use]
pub const fn resolves_dependencies_at(&self) -> ResolvesDependenciesAt {
self.resolves_dependencies_at
}
#[must_use]
pub const fn publishable(&self) -> bool {
self.publishable
}
#[must_use]
pub fn dependencies(&self) -> &[Dependency] {
&self.dependencies
}
pub fn runtime_dependencies(&self) -> impl Iterator<Item = &Dependency> {
self.dependencies.iter().filter(|d| d.kind.is_runtime())
}
#[must_use]
pub fn external_dependencies(&self) -> &[ExternalDependency] {
&self.external_dependencies
}
#[must_use]
pub fn unlinked_dependencies(&self) -> &[UnlinkedDependency] {
&self.unlinked_dependencies
}
#[must_use]
pub const fn inherited_fields(&self) -> &BTreeSet<String> {
&self.inherited_fields
}
#[must_use]
pub const fn inherited_path_dependencies(&self) -> &BTreeSet<String> {
&self.inherited_path_dependencies
}
#[must_use]
pub fn path_crates(&self) -> &[PathCrate] {
&self.path_crates
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct Workspace {
packages: BTreeMap<PackageId, Package>,
cargo_workspace_root: Option<String>,
cargo_root_files: Option<(String, String)>,
catalog_file: Option<String>,
pnpm_lock_dir: Option<String>,
pnpm_projects: Vec<String>,
}
impl Workspace {
pub fn new(packages: impl IntoIterator<Item = Package>) -> Result<Self, WorkspaceError> {
let mut map = BTreeMap::new();
for package in packages {
if let Some(existing) = map.insert(package.id.clone(), package) {
return Err(WorkspaceError::DuplicatePackage { id: existing.id });
}
}
if map.is_empty() {
return Err(WorkspaceError::Empty);
}
for package in map.values() {
let id = &package.id;
let mut seen = BTreeSet::new();
for dependency in &package.dependencies {
if dependency.on.ecosystem != id.ecosystem {
return Err(WorkspaceError::CrossEcosystemDependency {
dependent: id.clone(),
dependency: dependency.on.clone(),
});
}
let Some(section) = dependency.kind.section(id.ecosystem) else {
return Err(WorkspaceError::KindNotInEcosystem {
dependent: id.clone(),
dependency: dependency.on.clone(),
kind: dependency.kind,
});
};
if let Some(target) = &dependency.target {
if !id.ecosystem.has_target_tables() {
return Err(WorkspaceError::TargetNotInEcosystem {
dependent: id.clone(),
dependency: dependency.on.clone(),
target: target.clone(),
});
}
}
if let Some(protocol) = dependency.range.protocol() {
if !id.ecosystem.has_range_protocols() {
return Err(WorkspaceError::RangeNotInEcosystem {
dependent: id.clone(),
dependency: dependency.on.clone(),
protocol,
});
}
}
if !dependency.range.fits_ecosystem(id.ecosystem) {
return Err(WorkspaceError::BoundsNotInEcosystem {
dependent: id.clone(),
dependency: dependency.on.clone(),
});
}
if !map.contains_key(&dependency.on) {
return Err(WorkspaceError::UnknownDependency {
dependent: id.clone(),
dependency: dependency.on.clone(),
});
}
if !seen.insert((section, &dependency.declared_as, &dependency.target)) {
return Err(WorkspaceError::DuplicateEdge {
dependent: id.clone(),
declared_as: dependency.declared_as.clone(),
section,
target: dependency.target.clone(),
});
}
}
}
if let Some(path) = multi_package_cycle(&map) {
return Err(WorkspaceError::Cycle { path });
}
Ok(Self {
packages: map,
cargo_workspace_root: None,
cargo_root_files: None,
catalog_file: None,
pnpm_lock_dir: None,
pnpm_projects: Vec::new(),
})
}
#[must_use]
pub fn with_cargo_root_files(mut self, manifest: String, lock: String) -> Self {
self.cargo_root_files = Some((manifest, lock));
self
}
#[must_use]
pub fn cargo_root_files(&self) -> Option<(String, String)> {
let root = self.cargo_workspace_root()?;
Some(self.cargo_root_files.clone().unwrap_or_else(|| {
(
in_dir(root, Ecosystem::Cargo.manifest_name()),
in_dir(root, "Cargo.lock"),
)
}))
}
#[must_use]
pub fn with_cargo_workspace_root(mut self, dir: impl Into<String>) -> Self {
self.cargo_workspace_root = Some(dir.into());
self
}
#[must_use]
pub fn with_catalog_file(mut self, path: impl Into<String>) -> Self {
self.catalog_file = Some(path.into());
self
}
#[must_use]
pub fn with_pnpm_lock_dir(mut self, dir: impl Into<String>) -> Self {
self.pnpm_lock_dir = Some(dir.into());
self
}
#[must_use]
pub fn with_pnpm_projects(mut self, dirs: Vec<String>) -> Self {
self.pnpm_projects = dirs;
self
}
#[must_use]
pub fn pnpm_projects(&self) -> &[String] {
&self.pnpm_projects
}
#[must_use]
pub fn with_discovery_paths(mut self, other: &Self) -> Self {
self.cargo_workspace_root
.clone_from(&other.cargo_workspace_root);
self.cargo_root_files.clone_from(&other.cargo_root_files);
self.catalog_file.clone_from(&other.catalog_file);
self.pnpm_lock_dir.clone_from(&other.pnpm_lock_dir);
self.pnpm_projects.clone_from(&other.pnpm_projects);
self
}
#[must_use]
pub fn pnpm_lock_dir(&self) -> Option<&str> {
self.pnpm_lock_dir.as_deref()
}
#[must_use]
pub fn cargo_workspace_root(&self) -> Option<&str> {
self.cargo_workspace_root.as_deref()
}
#[must_use]
pub fn cargo_root_manifest(&self) -> Option<String> {
self.cargo_workspace_root()
.map(|root| in_dir(root, Ecosystem::Cargo.manifest_name()))
}
#[must_use]
pub fn catalog_file(&self) -> Option<&str> {
self.catalog_file.as_deref()
}
#[must_use]
pub fn get(&self, id: &PackageId) -> Option<&Package> {
self.packages.get(id)
}
pub fn packages(&self) -> impl Iterator<Item = &Package> {
self.packages.values()
}
pub fn dependents<'a, 'b>(
&'a self,
id: &'b PackageId,
) -> impl Iterator<Item = (&'a Package, &'a Dependency)> + use<'a, 'b> {
self.packages.values().flat_map(move |package| {
package
.dependencies
.iter()
.filter(move |d| &d.on == id)
.map(move |d| (package, d))
})
}
pub fn runtime_dependents<'a, 'b>(
&'a self,
id: &'b PackageId,
) -> impl Iterator<Item = (&'a Package, &'a Dependency)> + use<'a, 'b> {
self.dependents(id)
.filter(|(_, dependency)| dependency.kind.is_runtime())
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum WorkspaceError {
Empty,
DuplicatePackage {
id: PackageId,
},
CrossEcosystemDependency {
dependent: PackageId,
dependency: PackageId,
},
KindNotInEcosystem {
dependent: PackageId,
dependency: PackageId,
kind: DependencyKind,
},
TargetNotInEcosystem {
dependent: PackageId,
dependency: PackageId,
target: String,
},
RangeNotInEcosystem {
dependent: PackageId,
dependency: PackageId,
protocol: RangeProtocol,
},
BoundsNotInEcosystem {
dependent: PackageId,
dependency: PackageId,
},
UnknownDependency {
dependent: PackageId,
dependency: PackageId,
},
DuplicateEdge {
dependent: PackageId,
declared_as: String,
section: &'static str,
target: Option<String>,
},
Cycle {
path: Vec<PackageId>,
},
}
impl fmt::Display for WorkspaceError {
#[expect(clippy::too_many_lines)]
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::Empty => f.write_str(
"discovery reported no packages; a workspace file above the repository root can \
reparent the workspace, so check which root the package manager resolved",
),
Self::DuplicatePackage { id } => {
write!(f, "the workspace reports {id} more than once")
}
Self::CrossEcosystemDependency {
dependent,
dependency,
} => write!(
f,
"{dependent} declares an edge on {dependency}, which no manifest can express"
),
Self::KindNotInEcosystem {
dependent,
dependency,
kind,
} => {
write!(
f,
"{dependent} declares {dependency} with kind {kind}, which {} has no section for",
dependent.ecosystem
)?;
if (dependent.ecosystem, kind) == (Ecosystem::Cargo, &DependencyKind::Optional) {
f.write_str(
"; Cargo declares optional dependencies as `optional = true` entries in \
[dependencies], which is the normal kind",
)?;
}
Ok(())
}
Self::TargetNotInEcosystem {
dependent,
dependency,
target,
} => write!(
f,
"{dependent} declares {dependency} under target `{target}`, which {} has no tables for",
dependent.ecosystem
),
Self::RangeNotInEcosystem {
dependent,
dependency,
protocol,
} => {
write!(
f,
"{dependent} declares {dependency} with a `{protocol}` range, which {} has no \
protocol for",
dependent.ecosystem
)?;
if (dependent.ecosystem, protocol) == (Ecosystem::Cargo, &RangeProtocol::Workspace)
{
f.write_str(
"; Cargo's `workspace = true` inheritance is a different mechanism and \
reaches the planner as a plain range",
)?;
}
Ok(())
}
Self::BoundsNotInEcosystem {
dependent,
dependency,
} => write!(
f,
"{dependent} declares {dependency} with a range shape {} cannot express",
dependent.ecosystem
),
Self::UnknownDependency {
dependent,
dependency,
} => write!(
f,
"{dependent} depends on {dependency}, which the workspace does not contain"
),
Self::DuplicateEdge {
dependent,
declared_as,
section,
target,
} => match target {
Some(target) => write!(
f,
"{dependent} declares `{declared_as}` more than once in \
[target.'{target}'.{section}]"
),
None => write!(
f,
"{dependent} declares `{declared_as}` more than once in {section}"
),
},
Self::Cycle { path } => {
debug_assert!(
path.len() >= 3 && path.first() == path.last(),
"Cycle.path must be a closed multi-package walk"
);
f.write_str("found cycle in dependency graph: ")?;
for (i, id) in path.iter().enumerate() {
if i > 0 {
f.write_str(" -> ")?;
}
write!(f, "{id}")?;
}
Ok(())
}
}
}
}
fn multi_package_cycle(packages: &BTreeMap<PackageId, Package>) -> Option<Vec<PackageId>> {
#[derive(Clone, Copy, PartialEq, Eq)]
enum Color {
White,
Gray,
Black,
}
fn visit(
id: &PackageId,
packages: &BTreeMap<PackageId, Package>,
color: &mut BTreeMap<PackageId, Color>,
path: &mut Vec<PackageId>,
) -> Option<Vec<PackageId>> {
color.insert(id.clone(), Color::Gray);
path.push(id.clone());
if let Some(package) = packages.get(id) {
for dependency in &package.dependencies {
let next = &dependency.on;
match color.get(next).copied().unwrap_or(Color::White) {
Color::Gray => {
let start = path
.iter()
.position(|step| step == next)
.expect("gray node must be on the DFS path");
if path.len() - start < 2 {
continue;
}
let mut cycle: Vec<PackageId> = path[start..].to_vec();
cycle.push(next.clone());
return Some(cycle);
}
Color::White => {
if let Some(cycle) = visit(next, packages, color, path) {
return Some(cycle);
}
}
Color::Black => {}
}
}
}
path.pop();
color.insert(id.clone(), Color::Black);
None
}
let mut color = BTreeMap::new();
for id in packages.keys() {
color.insert(id.clone(), Color::White);
}
let mut path = Vec::new();
for id in packages.keys() {
if color.get(id).copied() != Some(Color::White) {
continue;
}
if let Some(cycle) = visit(id, packages, &mut color, &mut path) {
return Some(cycle);
}
}
None
}
impl core::error::Error for WorkspaceError {}
fn in_dir(dir: &str, name: &str) -> String {
if dir.is_empty() {
String::from(name)
} else {
alloc::format!("{dir}/{name}")
}
}
#[cfg(test)]
mod tests {
use alloc::format;
use alloc::string::ToString;
use alloc::vec;
use super::*;
fn cargo(name: &str) -> PackageId {
PackageId::new(Ecosystem::Cargo, name)
}
fn npm(name: &str) -> PackageId {
PackageId::new(Ecosystem::Npm, name)
}
fn req(text: &str) -> VersionReq {
VersionReq::parse(text).expect("test range should parse")
}
fn plain_cargo(text: &str) -> DeclaredRange {
DeclaredRange::Plain(Bounds::from_cargo_text(text).expect("test cargo range"))
}
fn plain_npm(text: &str) -> DeclaredRange {
DeclaredRange::Plain(Bounds::from_npm_text(text).expect("test npm range"))
}
fn workspace_npm(text: &str) -> DeclaredRange {
DeclaredRange::Workspace(Bounds::from_npm_text(text).expect("test npm range"))
}
fn catalog_npm(name: Option<&str>, text: &str) -> DeclaredRange {
DeclaredRange::Catalog {
name: name.map(str::to_string),
bounds: Bounds::from_npm_text(text).expect("test npm range"),
}
}
fn edge(on: PackageId, kind: DependencyKind) -> Dependency {
let declared_as = on.name.clone();
let range = match on.ecosystem {
Ecosystem::Cargo => plain_cargo("^1.0.0"),
Ecosystem::Npm => plain_npm("^1.0.0"),
};
Dependency {
on,
kind,
declared_as,
target: None,
range,
}
}
fn package(id: PackageId, dependencies: Vec<Dependency>) -> Package {
Package::new(
id,
Version::new(1, 0, 0),
ResolvesDependenciesAt::Install,
true,
dependencies,
)
}
#[test]
fn a_package_path_joins_its_directory_with_a_slash() {
let root = package(cargo("core"), vec![]);
let nested = package(npm("ui"), vec![]).with_manifest_dir("packages/ui");
assert_eq!(root.manifest_path(), "Cargo.toml");
assert_eq!(nested.manifest_path(), "packages/ui/package.json");
assert_eq!(nested.file_path("CHANGELOG.md"), "packages/ui/CHANGELOG.md");
let workspace = Workspace::new([root.clone()]).expect("workspace");
assert_eq!(workspace.cargo_root_manifest(), None);
for (dir, manifest) in [("", "Cargo.toml"), ("rust", "rust/Cargo.toml")] {
let workspace = Workspace::new([root.clone()])
.expect("workspace")
.with_cargo_workspace_root(dir);
assert_eq!(workspace.cargo_root_manifest().as_deref(), Some(manifest));
}
}
#[test]
fn a_duplicate_package_is_refused() {
let error = Workspace::new([
package(cargo("core"), vec![]),
package(cargo("core"), vec![]),
])
.expect_err("two packages under one id should not build a workspace");
assert_eq!(
error,
WorkspaceError::DuplicatePackage { id: cargo("core") }
);
assert_eq!(
error.to_string(),
"the workspace reports core (cargo) more than once"
);
}
#[test]
fn an_empty_workspace_is_refused_and_names_the_likely_cause() {
let error = Workspace::new([]).expect_err("an empty workspace should be refused");
assert_eq!(error, WorkspaceError::Empty);
assert!(
error.to_string().contains("reparent the workspace"),
"message gives the reader nothing to check: {error}"
);
}
#[test]
fn discovery_paths_survive_a_package_rebuild() {
let bare = Workspace::new([package(cargo("core"), vec![])]).expect("workspace");
assert_eq!(bare.cargo_workspace_root(), None);
assert_eq!(bare.catalog_file(), None);
let original = bare
.with_cargo_workspace_root("rust")
.with_catalog_file("js/pnpm-workspace.yaml")
.with_pnpm_lock_dir("js");
let rebuilt = Workspace::new(original.packages().cloned())
.expect("workspace")
.with_discovery_paths(&original);
assert_eq!(rebuilt.cargo_workspace_root(), Some("rust"));
assert_eq!(rebuilt.catalog_file(), Some("js/pnpm-workspace.yaml"));
assert_eq!(rebuilt.pnpm_lock_dir(), Some("js"));
}
#[test]
fn an_edge_onto_a_package_outside_the_workspace_is_refused_by_name() {
let error = Workspace::new([package(
cargo("cli"),
vec![edge(cargo("core"), DependencyKind::Normal)],
)])
.expect_err("an unresolvable edge should not build a workspace");
assert_eq!(
error.to_string(),
"cli (cargo) depends on core (cargo), which the workspace does not contain"
);
assert_eq!(
error,
WorkspaceError::UnknownDependency {
dependent: cargo("cli"),
dependency: cargo("core"),
}
);
}
#[test]
fn one_name_in_two_ecosystems_is_two_packages() {
let workspace = Workspace::new([
package(cargo("oakum"), vec![]),
package(npm("oakum"), vec![]),
])
.expect("distinct ecosystems should not collide");
assert_eq!(workspace.packages().count(), 2);
assert_eq!(
workspace.get(&cargo("oakum")).map(Package::id),
Some(&cargo("oakum"))
);
let cargo_only = Workspace::new([package(cargo("oakum"), vec![])]).expect("should build");
assert!(cargo_only.get(&npm("oakum")).is_none());
}
#[test]
fn an_edge_across_ecosystems_is_refused() {
let error = Workspace::new([
package(cargo("core"), vec![]),
package(
npm("cli"),
vec![edge(cargo("core"), DependencyKind::Normal)],
),
])
.expect_err("a cross-ecosystem edge should be refused");
assert_eq!(
error.to_string(),
"cli (npm) declares an edge on core (cargo), which no manifest can express"
);
assert_eq!(
error,
WorkspaceError::CrossEcosystemDependency {
dependent: npm("cli"),
dependency: cargo("core"),
}
);
}
#[test]
fn dependents_does_not_match_across_ecosystems() {
let workspace = Workspace::new([
package(npm("shared"), vec![]),
package(cargo("shared"), vec![]),
package(
cargo("cli"),
vec![edge(cargo("shared"), DependencyKind::Normal)],
),
])
.expect("workspace should build");
let found: Vec<&PackageId> = workspace
.dependents(&cargo("shared"))
.map(|(package, _)| package.id())
.collect();
assert_eq!(found, vec![&cargo("cli")]);
assert_eq!(workspace.dependents(&npm("shared")).count(), 0);
}
#[test]
fn a_development_edge_stays_in_the_graph_and_out_of_the_cascade_set() {
let workspace = Workspace::new([
package(cargo("config"), vec![]),
package(
cargo("cli"),
vec![edge(cargo("config"), DependencyKind::Development)],
),
])
.expect("a development edge should build a workspace");
let cli = workspace.get(&cargo("cli")).expect("cli should be present");
assert_eq!(cli.dependencies().len(), 1);
assert_eq!(cli.runtime_dependencies().count(), 0);
let dependents: Vec<&PackageId> = workspace
.dependents(&cargo("config"))
.map(|(package, _)| package.id())
.collect();
assert_eq!(dependents, vec![&cargo("cli")]);
assert_eq!(workspace.runtime_dependents(&cargo("config")).count(), 0);
}
#[test]
fn every_kind_lands_on_the_side_adr_0008_puts_it() {
for kind in [
DependencyKind::Normal,
DependencyKind::Peer,
DependencyKind::Optional,
DependencyKind::Build,
] {
assert!(kind.is_runtime(), "{kind:?} should cascade");
}
assert!(!DependencyKind::Development.is_runtime());
}
#[test]
fn every_kind_maps_to_the_section_its_ecosystem_writes() {
use DependencyKind::{Build, Development, Normal, Optional, Peer};
for (ecosystem, kind, section) in [
(Ecosystem::Npm, Normal, Some("dependencies")),
(Ecosystem::Npm, Peer, Some("peerDependencies")),
(Ecosystem::Npm, Optional, Some("optionalDependencies")),
(Ecosystem::Npm, Development, Some("devDependencies")),
(Ecosystem::Npm, Build, None),
(Ecosystem::Cargo, Normal, Some("dependencies")),
(Ecosystem::Cargo, Build, Some("build-dependencies")),
(Ecosystem::Cargo, Development, Some("dev-dependencies")),
(Ecosystem::Cargo, Peer, None),
(Ecosystem::Cargo, Optional, None),
] {
assert_eq!(kind.section(ecosystem), section, "{ecosystem} {kind:?}");
}
}
#[test]
fn a_kind_the_ecosystem_has_no_section_for_is_refused() {
let error = Workspace::new([
package(cargo("core"), vec![]),
package(
cargo("cli"),
vec![edge(cargo("core"), DependencyKind::Peer)],
),
])
.expect_err("a Cargo peer dependency should be refused");
assert_eq!(
error.to_string(),
"cli (cargo) declares core (cargo) with kind peer, which cargo has no section for"
);
assert_eq!(
error,
WorkspaceError::KindNotInEcosystem {
dependent: cargo("cli"),
dependency: cargo("core"),
kind: DependencyKind::Peer,
}
);
}
#[test]
fn a_package_declared_in_two_sections_yields_one_edge_each() {
let workspace = Workspace::new([
package(npm("host"), vec![]),
package(
npm("plugin"),
vec![
edge(npm("host"), DependencyKind::Peer),
edge(npm("host"), DependencyKind::Development),
],
),
])
.expect("two sections naming one dependency should build a workspace");
let kinds: Vec<DependencyKind> = workspace
.dependents(&npm("host"))
.map(|(_, dependency)| dependency.kind)
.collect();
assert_eq!(
kinds,
vec![DependencyKind::Peer, DependencyKind::Development]
);
assert_eq!(workspace.runtime_dependents(&npm("host")).count(), 1);
}
#[test]
fn one_dependency_declared_twice_under_one_key_is_refused() {
let mut tighter = edge(cargo("core"), DependencyKind::Normal);
tighter.range = plain_cargo("=1.0.0");
let error = Workspace::new([
package(cargo("core"), vec![]),
package(
cargo("cli"),
vec![edge(cargo("core"), DependencyKind::Normal), tighter],
),
])
.expect_err("two ranges for one entry should be refused");
assert_eq!(
error.to_string(),
"cli (cargo) declares `core` more than once in dependencies"
);
assert_eq!(
error,
WorkspaceError::DuplicateEdge {
dependent: cargo("cli"),
declared_as: "core".to_string(),
section: "dependencies",
target: None,
}
);
}
#[test]
fn two_packages_under_one_key_is_refused() {
let mut collides = edge(cargo("utils"), DependencyKind::Normal);
collides.declared_as = "shared".to_string();
let mut first = edge(cargo("core"), DependencyKind::Normal);
first.declared_as = "shared".to_string();
let error = Workspace::new([
package(cargo("core"), vec![]),
package(cargo("utils"), vec![]),
package(cargo("cli"), vec![first, collides]),
])
.expect_err("one key naming two packages should be refused");
assert_eq!(
error,
WorkspaceError::DuplicateEdge {
dependent: cargo("cli"),
declared_as: "shared".to_string(),
section: "dependencies",
target: None,
}
);
}
#[test]
fn a_renamed_edge_alongside_the_plain_one_is_not_a_duplicate() {
let mut renamed = edge(cargo("core"), DependencyKind::Normal);
renamed.declared_as = "core_alias".to_string();
let workspace = Workspace::new([
package(cargo("core"), vec![]),
package(
cargo("cli"),
vec![edge(cargo("core"), DependencyKind::Normal), renamed],
),
])
.expect("a rename beside the plain entry should build a workspace");
assert_eq!(workspace.dependents(&cargo("core")).count(), 2);
}
#[test]
fn one_key_in_two_target_tables_is_not_a_duplicate() {
let mut unix = edge(cargo("core"), DependencyKind::Normal);
unix.target = Some("cfg(unix)".to_string());
let mut windows = edge(cargo("core"), DependencyKind::Normal);
windows.target = Some("cfg(windows)".to_string());
windows.range = plain_cargo("=1.0.0");
let workspace = Workspace::new([
package(cargo("core"), vec![]),
package(cargo("cli"), vec![unix, windows]),
])
.expect("two target tables should build a workspace");
assert_eq!(workspace.runtime_dependents(&cargo("core")).count(), 2);
}
#[test]
fn a_range_protocol_the_ecosystem_does_not_have_is_refused() {
let inheritance = "; Cargo's `workspace = true` inheritance is a different \
mechanism and reaches the planner as a plain range";
for (range, protocol, tail) in [
(
DeclaredRange::WorkspaceTracking(Tracking::Caret),
RangeProtocol::Workspace,
inheritance,
),
(
workspace_npm("^1.0.0"),
RangeProtocol::Workspace,
inheritance,
),
(catalog_npm(None, "^1.0.0"), RangeProtocol::Catalog, ""),
] {
let mut dependency = edge(cargo("core"), DependencyKind::Normal);
dependency.range = range;
let error = Workspace::new([
package(cargo("core"), vec![]),
package(cargo("cli"), vec![dependency]),
])
.expect_err("a protocol range on a Cargo package should be refused");
assert_eq!(
error,
WorkspaceError::RangeNotInEcosystem {
dependent: cargo("cli"),
dependency: cargo("core"),
protocol,
}
);
assert_eq!(
error.to_string(),
format!(
"cli (cargo) declares core (cargo) with a `{protocol}` range, \
which cargo has no protocol for{tail}"
)
);
}
assert_eq!(
WorkspaceError::RangeNotInEcosystem {
dependent: npm("cli"),
dependency: npm("core"),
protocol: RangeProtocol::Workspace,
}
.to_string(),
"cli (npm) declares core (npm) with a `workspace:` range, which npm has no protocol for"
);
for range in [
DeclaredRange::WorkspaceTracking(Tracking::Caret),
workspace_npm("^1.0.0"),
catalog_npm(None, "^1.0.0"),
catalog_npm(Some("react18"), "^1.0.0 || ^2.0.0"),
] {
Workspace::new([
package(npm("core"), vec![]),
package(npm("cli"), {
let mut d = edge(npm("core"), DependencyKind::Normal);
d.range = range;
vec![d]
}),
])
.expect("npm protocol / tracking ranges should build");
}
}
#[test]
fn a_multi_package_cycle_is_refused_and_a_self_edge_is_not() {
for kind in [DependencyKind::Normal, DependencyKind::Development] {
Workspace::new([package(cargo("core"), vec![edge(cargo("core"), kind)])])
.unwrap_or_else(|e| panic!("a {kind} self-edge should build: {e}"));
}
for kind in [DependencyKind::Normal, DependencyKind::Development] {
let error = Workspace::new([
package(cargo("a"), vec![edge(cargo("b"), kind)]),
package(cargo("b"), vec![edge(cargo("a"), kind)]),
])
.expect_err("a two-node cycle should refuse");
match &error {
WorkspaceError::Cycle { path } => {
assert!(path.len() >= 3, "{path:?}");
assert_eq!(path.first(), path.last());
let distinct: BTreeSet<_> = path.iter().collect();
assert_eq!(distinct.len(), 2);
}
other => panic!("expected Cycle, got {other:?}"),
}
assert!(
error
.to_string()
.starts_with("found cycle in dependency graph: "),
"{error}"
);
}
let workspace = Workspace::new([package(
cargo("core"),
vec![edge(cargo("core"), DependencyKind::Normal)],
)])
.expect("workspace should build");
let reached: Vec<&PackageId> = workspace
.runtime_dependents(&cargo("core"))
.map(|(package, _)| package.id())
.collect();
assert_eq!(reached, vec![&cargo("core")]);
}
#[test]
fn a_development_cycle_is_refused_like_a_runtime_one() {
let error = Workspace::new([
package(
npm("eslint-plugin-treekeeper"),
vec![edge(
npm("eslint-plugin-node-specifier"),
DependencyKind::Development,
)],
),
package(
npm("eslint-plugin-node-specifier"),
vec![edge(
npm("eslint-plugin-treekeeper"),
DependencyKind::Development,
)],
),
])
.expect_err("a development-only cycle should refuse");
assert!(matches!(error, WorkspaceError::Cycle { .. }));
let message = error.to_string();
assert!(
message.contains("eslint-plugin-treekeeper")
&& message.contains("eslint-plugin-node-specifier"),
"{message}"
);
}
#[test]
fn a_three_node_cycle_names_every_package() {
let error = Workspace::new([
package(cargo("a"), vec![edge(cargo("b"), DependencyKind::Normal)]),
package(cargo("b"), vec![edge(cargo("c"), DependencyKind::Build)]),
package(
cargo("c"),
vec![edge(cargo("a"), DependencyKind::Development)],
),
])
.expect_err("a three-node mixed-kind cycle should refuse");
let WorkspaceError::Cycle { path } = error else {
panic!("expected Cycle");
};
assert_eq!(path.len(), 4);
assert_eq!(path.first(), path.last());
let distinct: BTreeSet<_> = path.iter().cloned().collect();
assert_eq!(
distinct,
BTreeSet::from([cargo("a"), cargo("b"), cargo("c")])
);
}
#[test]
fn an_unknown_dependency_is_reported_before_a_cycle() {
let error = Workspace::new([
package(
cargo("a"),
vec![
edge(cargo("b"), DependencyKind::Normal),
edge(cargo("absent"), DependencyKind::Normal),
],
),
package(cargo("b"), vec![edge(cargo("a"), DependencyKind::Normal)]),
])
.expect_err("unknown dependency should win over the a↔b cycle");
assert_eq!(
error,
WorkspaceError::UnknownDependency {
dependent: cargo("a"),
dependency: cargo("absent"),
}
);
}
#[test]
fn a_mixed_kind_two_node_cycle_is_refused() {
let error = Workspace::new([
package(cargo("a"), vec![edge(cargo("b"), DependencyKind::Normal)]),
package(
cargo("b"),
vec![edge(cargo("a"), DependencyKind::Development)],
),
])
.expect_err("runtime↔development between the same pair is still a cycle");
assert!(matches!(error, WorkspaceError::Cycle { .. }));
}
#[test]
fn a_self_edge_does_not_hide_a_multi_package_cycle() {
let error = Workspace::new([
package(
cargo("a"),
vec![
edge(cargo("a"), DependencyKind::Development),
edge(cargo("b"), DependencyKind::Normal),
],
),
package(cargo("b"), vec![edge(cargo("a"), DependencyKind::Normal)]),
])
.expect_err("self-edge plus a↔b must still refuse");
let WorkspaceError::Cycle { path } = error else {
panic!("expected Cycle");
};
let distinct: BTreeSet<_> = path.iter().collect();
assert!(distinct.contains(&&cargo("a")) && distinct.contains(&&cargo("b")));
}
#[test]
fn a_diamond_is_not_a_cycle() {
Workspace::new([
package(
cargo("a"),
vec![
edge(cargo("b"), DependencyKind::Normal),
edge(cargo("c"), DependencyKind::Normal),
],
),
package(cargo("b"), vec![edge(cargo("d"), DependencyKind::Normal)]),
package(cargo("c"), vec![edge(cargo("d"), DependencyKind::Normal)]),
package(cargo("d"), vec![]),
])
.expect("a diamond DAG should build");
}
#[test]
fn a_two_fault_edge_reports_the_fault_that_explains_the_other() {
let keyed = |on: PackageId| {
let mut dependency = edge(on, DependencyKind::Normal);
dependency.declared_as = "shared".to_string();
dependency
};
assert!(matches!(
Workspace::new([package(
npm("cli"),
vec![edge(cargo("core"), DependencyKind::Build)]
)]),
Err(WorkspaceError::CrossEcosystemDependency { .. })
));
assert!(matches!(
Workspace::new([package(
cargo("cli"),
vec![edge(cargo("absent"), DependencyKind::Peer)]
)]),
Err(WorkspaceError::KindNotInEcosystem { .. })
));
assert!(matches!(
Workspace::new([
package(cargo("core"), vec![]),
package(
cargo("cli"),
vec![keyed(cargo("core")), keyed(cargo("absent"))]
),
]),
Err(WorkspaceError::UnknownDependency { .. })
));
let mut targeted = edge(cargo("core"), DependencyKind::Normal);
targeted.target = Some("cfg(windows)".to_string());
assert!(matches!(
Workspace::new([package(npm("cli"), vec![targeted])]),
Err(WorkspaceError::CrossEcosystemDependency { .. })
));
let mut sectionless = edge(cargo("core"), DependencyKind::Peer);
sectionless.range = DeclaredRange::WorkspaceTracking(Tracking::Caret);
assert!(matches!(
Workspace::new([
package(cargo("core"), vec![]),
package(cargo("cli"), vec![sectionless]),
]),
Err(WorkspaceError::KindNotInEcosystem { .. })
));
let mut crossed = edge(npm("core"), DependencyKind::Normal);
crossed.range = DeclaredRange::WorkspaceTracking(Tracking::Caret);
assert!(matches!(
Workspace::new([
package(npm("core"), vec![]),
package(cargo("cli"), vec![crossed]),
]),
Err(WorkspaceError::CrossEcosystemDependency { .. })
));
let mut sectionless = edge(npm("core"), DependencyKind::Build);
sectionless.target = Some("cfg(windows)".to_string());
assert!(matches!(
Workspace::new([
package(npm("core"), vec![]),
package(npm("cli"), vec![sectionless]),
]),
Err(WorkspaceError::KindNotInEcosystem { .. })
));
let mut protocol_on_absent = edge(cargo("absent"), DependencyKind::Normal);
protocol_on_absent.range = DeclaredRange::WorkspaceTracking(Tracking::Caret);
assert!(matches!(
Workspace::new([package(cargo("cli"), vec![protocol_on_absent])]),
Err(WorkspaceError::RangeNotInEcosystem { .. })
));
let mut absent = edge(npm("absent"), DependencyKind::Normal);
absent.target = Some("cfg(windows)".to_string());
assert!(matches!(
Workspace::new([package(npm("cli"), vec![absent])]),
Err(WorkspaceError::TargetNotInEcosystem { .. })
));
}
#[test]
fn an_npm_edge_carrying_a_target_is_refused() {
let mut targeted = edge(npm("core"), DependencyKind::Normal);
targeted.target = Some("cfg(windows)".to_string());
let error = Workspace::new([
package(npm("core"), vec![]),
package(npm("cli"), vec![targeted]),
])
.expect_err("an npm target should be refused");
assert_eq!(
error.to_string(),
"cli (npm) declares core (npm) under target `cfg(windows)`, which npm has no tables for"
);
assert_eq!(
error,
WorkspaceError::TargetNotInEcosystem {
dependent: npm("cli"),
dependency: npm("core"),
target: "cfg(windows)".to_string(),
}
);
}
#[test]
fn a_duplicate_names_the_section_and_target_table_it_fired_in() {
let npm_dev = Workspace::new([
package(npm("core"), vec![]),
package(
npm("cli"),
vec![
edge(npm("core"), DependencyKind::Development),
edge(npm("core"), DependencyKind::Development),
],
),
])
.expect_err("a repeated npm development edge should be refused");
assert_eq!(
npm_dev.to_string(),
"cli (npm) declares `core` more than once in devDependencies"
);
let mut windows = edge(cargo("core"), DependencyKind::Normal);
windows.target = Some("cfg(windows)".to_string());
let in_target = Workspace::new([
package(cargo("core"), vec![]),
package(cargo("cli"), vec![windows.clone(), windows]),
])
.expect_err("a repeated edge inside one target table should be refused");
assert_eq!(
in_target.to_string(),
"cli (cargo) declares `core` more than once in [target.'cfg(windows)'.dependencies]"
);
}
#[test]
fn every_kind_renders_its_own_word() {
for (kind, word) in [
(DependencyKind::Normal, "normal"),
(DependencyKind::Peer, "peer"),
(DependencyKind::Optional, "optional"),
(DependencyKind::Build, "build"),
(DependencyKind::Development, "development"),
] {
assert_eq!(kind.to_string(), word);
}
let cargo_optional = WorkspaceError::KindNotInEcosystem {
dependent: cargo("cli"),
dependency: cargo("core"),
kind: DependencyKind::Optional,
}
.to_string();
assert!(
cargo_optional.contains("`optional = true` entries in [dependencies]"),
"the message does not name the fix: {cargo_optional}"
);
let npm_optional = WorkspaceError::KindNotInEcosystem {
dependent: npm("cli"),
dependency: npm("core"),
kind: DependencyKind::Optional,
}
.to_string();
assert!(
!npm_optional.contains("optional = true"),
"npm carries Cargo's advice: {npm_optional}"
);
let npm_build = WorkspaceError::KindNotInEcosystem {
dependent: npm("cli"),
dependency: npm("core"),
kind: DependencyKind::Build,
}
.to_string();
assert_eq!(
npm_build,
"cli (npm) declares core (npm) with kind build, which npm has no section for"
);
}
#[test]
fn packages_iterate_in_id_order_whatever_order_they_arrived_in() {
let workspace = Workspace::new([
package(cargo("zephyr"), vec![]),
package(npm("alpha"), vec![]),
package(cargo("alpha"), vec![]),
])
.expect("workspace should build");
let order: Vec<&PackageId> = workspace.packages().map(Package::id).collect();
assert_eq!(
order,
vec![&npm("alpha"), &cargo("alpha"), &cargo("zephyr")]
);
}
#[test]
fn ids_sort_by_ecosystem_before_name() {
let workspace = Workspace::new([
package(cargo("alpha"), vec![]),
package(npm("zephyr"), vec![]),
])
.expect("workspace should build");
let order: Vec<&PackageId> = workspace.packages().map(Package::id).collect();
assert_eq!(order, vec![&npm("zephyr"), &cargo("alpha")]);
}
#[test]
fn a_tracking_range_publishes_as_adr_0010_says() {
for (version, exact, tilde, caret) in [
("1.5.0", "=1.5.0", "~1.5.0", "^1.5.0"),
("1.5.0-rc.1", "=1.5.0-rc.1", "~1.5.0-rc.1", "^1.5.0-rc.1"),
] {
let version = Version::parse(version).expect("test version should parse");
for (tracking, published) in [
(Tracking::Exact, exact),
(Tracking::Tilde, tilde),
(Tracking::Caret, caret),
] {
assert_eq!(
DeclaredRange::expand_tracking(tracking, &version),
req(published),
"{version} {tracking:?}"
);
}
}
}
#[test]
fn an_exact_tracking_range_excludes_the_version_it_is_gating() {
let at_last_tag = Version::new(1, 5, 0);
let bumped_to = Version::new(1, 6, 0);
let published = DeclaredRange::expand_tracking(Tracking::Exact, &at_last_tag);
assert!(!published.matches(&bumped_to));
assert!(published.matches(&at_last_tag));
}
#[test]
fn workspace_tracking_admits_via_tag_expansion() {
let at_tag = Version::new(1, 5, 0);
let same = Version::new(1, 5, 0);
let minor = Version::new(1, 6, 0);
let major = Version::new(2, 0, 0);
let exact = DeclaredRange::WorkspaceTracking(Tracking::Exact);
assert!(exact.admits(&at_tag, &same));
assert!(!exact.admits(&at_tag, &minor));
let tilde = DeclaredRange::WorkspaceTracking(Tracking::Tilde);
assert!(tilde.admits(&at_tag, &same));
assert!(!tilde.admits(&at_tag, &minor));
let caret = DeclaredRange::WorkspaceTracking(Tracking::Caret);
assert!(caret.admits(&at_tag, &same));
assert!(caret.admits(&at_tag, &minor));
assert!(!caret.admits(&at_tag, &major));
}
#[test]
fn a_declared_range_admits_through_the_bounds_it_carries() {
let moved_on = Version::new(9, 9, 9);
for range in [
plain_cargo("^1.5.0"),
workspace_npm("^1.5.0"),
catalog_npm(Some("react18"), "^1.5.0"),
] {
assert!(range.admits(&moved_on, &Version::new(1, 5, 0)));
assert!(!range.admits(&moved_on, &Version::new(2, 0, 0)));
}
}
#[test]
fn workspace_and_catalog_admit_through_their_carried_req() {
let at_tag = Version::new(9, 9, 9);
for range in [workspace_npm("^1.5.0"), catalog_npm(None, "^1.5.0")] {
assert!(range.admits(&at_tag, &Version::new(1, 5, 0)));
assert!(!range.admits(&at_tag, &Version::new(2, 0, 0)));
}
for range in [
workspace_npm("^1.0.0 || ^2.0.0"),
catalog_npm(None, "^1.0.0 || ^2.0.0"),
] {
assert!(range.admits(&at_tag, &Version::new(1, 5, 0)));
assert!(range.admits(&at_tag, &Version::new(2, 1, 0)));
assert!(!range.admits(&at_tag, &Version::new(3, 0, 0)));
}
for range in [
workspace_npm("1.5.0"),
catalog_npm(Some("react18"), "1.5.0"),
] {
assert!(range.admits(&at_tag, &Version::new(1, 5, 0)));
assert!(!range.admits(&at_tag, &Version::new(1, 6, 0)));
}
}
#[test]
fn path_linked_on_cargo_builds_a_workspace() {
let mut path = edge(cargo("core"), DependencyKind::Normal);
path.range = DeclaredRange::PathLinked;
let workspace = Workspace::new([
package(cargo("core"), vec![]),
package(cargo("cli"), vec![path]),
])
.expect("path-linked Cargo edges should build");
let edge = &workspace.get(&cargo("cli")).expect("cli").dependencies()[0];
assert!(edge.range.is_path_linked());
assert_eq!(workspace.dependents(&cargo("core")).count(), 1);
}
#[test]
fn path_linked_never_admits() {
let at_tag = Version::new(1, 0, 0);
let next = Version::new(1, 0, 1);
assert!(!DeclaredRange::PathLinked.admits(&at_tag, &at_tag));
assert!(!DeclaredRange::PathLinked.admits(&at_tag, &next));
assert_eq!(DeclaredRange::PathLinked.protocol(), None);
assert!(DeclaredRange::PathLinked.is_path_linked());
assert_eq!(
DeclaredRange::PathLinked.retargeted_text(&Version::new(0, 2, 0)),
None
);
}
#[test]
fn retarget_keeps_workspace_prefix_and_skips_tracking() {
let new = Version::new(0, 2, 0);
assert_eq!(
plain_cargo("^0.1.3").retargeted_text(&new).as_deref(),
Some("^0.2.0")
);
assert_eq!(
workspace_npm("^0.1.3").retargeted_text(&new).as_deref(),
Some("workspace:^0.2.0")
);
assert_eq!(
DeclaredRange::WorkspaceTracking(Tracking::Caret).retargeted_text(&new),
None
);
assert_eq!(catalog_npm(None, "^0.1.3").retargeted_text(&new), None);
}
#[test]
fn npm_plain_admits_via_js_semver_not_version_req() {
let at_tag = Version::new(1, 5, 0);
let range = plain_npm("1.5.0");
assert!(range.admits(&at_tag, &Version::new(1, 5, 0)));
assert!(!range.admits(&at_tag, &Version::new(1, 6, 0)));
}
#[test]
fn bare_version_at_declared_range_keeps_ecosystem_meaning() {
let at_tag = Version::new(1, 5, 0);
let cargo = plain_cargo("1.5.0");
let npm = plain_npm("1.5.0");
assert!(cargo.admits(&at_tag, &Version::new(1, 6, 0)));
assert!(!npm.admits(&at_tag, &Version::new(1, 6, 0)));
}
#[test]
fn a_range_shape_the_ecosystem_cannot_express_is_refused() {
let mut path_on_npm = edge(npm("core"), DependencyKind::Normal);
path_on_npm.range = DeclaredRange::PathLinked;
assert_eq!(
Workspace::new([
package(npm("core"), vec![]),
package(npm("cli"), vec![path_on_npm]),
])
.expect_err("path-linked is Cargo-only"),
WorkspaceError::BoundsNotInEcosystem {
dependent: npm("cli"),
dependency: npm("core"),
}
);
let mut npm_bounds_on_cargo = edge(cargo("core"), DependencyKind::Normal);
npm_bounds_on_cargo.range = plain_npm("^1.0.0");
assert_eq!(
Workspace::new([
package(cargo("core"), vec![]),
package(cargo("cli"), vec![npm_bounds_on_cargo]),
])
.expect_err("npm Bounds on Cargo is refused"),
WorkspaceError::BoundsNotInEcosystem {
dependent: cargo("cli"),
dependency: cargo("core"),
}
);
let mut cargo_bounds_on_npm = edge(npm("core"), DependencyKind::Normal);
cargo_bounds_on_npm.range = plain_cargo("^1.0.0");
assert_eq!(
Workspace::new([
package(npm("core"), vec![]),
package(npm("cli"), vec![cargo_bounds_on_npm]),
])
.expect_err("Cargo Bounds on npm is refused"),
WorkspaceError::BoundsNotInEcosystem {
dependent: npm("cli"),
dependency: npm("core"),
}
);
let cargo_bounds = Bounds::from_cargo_text("^1.0.0").expect("cargo");
for range in [
DeclaredRange::Workspace(cargo_bounds.clone()),
DeclaredRange::Catalog {
name: None,
bounds: cargo_bounds,
},
] {
let mut edge = edge(npm("core"), DependencyKind::Normal);
edge.range = range;
assert_eq!(
Workspace::new([
package(npm("core"), vec![]),
package(npm("cli"), vec![edge]),
])
.expect_err("Cargo Bounds on npm protocol arms is refused"),
WorkspaceError::BoundsNotInEcosystem {
dependent: npm("cli"),
dependency: npm("core"),
}
);
}
}
#[test]
fn a_caret_on_a_zero_major_excludes_the_next_minor() {
assert!(!req("^0.1.3").matches(&Version::new(0, 2, 0)));
assert!(req("^1.1.3").matches(&Version::new(1, 2, 0)));
}
#[test]
fn cargos_grammar_reads_a_bare_version_as_a_caret() {
assert_ne!(req("1.5.0"), req("=1.5.0"));
assert!(req("1.5.0").matches(&Version::new(1, 6, 0)));
assert!(!req("=1.5.0").matches(&Version::new(1, 6, 0)));
}
#[test]
fn either_route_to_build_time_resolution_reads_as_one() {
for resolution in [BuildResolution::BinaryTarget, BuildResolution::Declared] {
assert!(ResolvesDependenciesAt::Build(resolution).is_build());
}
assert!(!ResolvesDependenciesAt::Install.is_build());
}
#[test]
fn a_package_keeps_the_version_and_resolution_it_was_built_with() {
let workspace = Workspace::new([Package::new(
cargo("cli"),
Version::new(2, 3, 4),
ResolvesDependenciesAt::Build(BuildResolution::BinaryTarget),
true,
vec![],
)])
.expect("workspace should build");
let cli = workspace.get(&cargo("cli")).expect("cli should be present");
assert_eq!(cli.version(), &Version::new(2, 3, 4));
assert_eq!(
cli.resolves_dependencies_at(),
ResolvesDependenciesAt::Build(BuildResolution::BinaryTarget)
);
}
#[test]
fn both_ecosystems_render_their_own_name() {
assert_eq!(npm("x").to_string(), "x (npm)");
assert_eq!(cargo("x").to_string(), "x (cargo)");
}
}