architecture.rs (63172B)
1 use std::{ 2 collections::{BTreeMap, BTreeSet}, 3 fs, 4 path::{Component, Path}, 5 }; 6 7 use serde::Deserialize; 8 9 mod api_leakage; 10 mod core_contract; 11 mod decision_package; 12 mod dependency_boundary; 13 mod retired_compatibility; 14 15 pub(crate) const STABLE_TOOLCHAIN: &str = "1.99.0"; 16 const FROZEN_V1_MSRV: &str = "1.97.1"; 17 18 const DEVIATIONS_RELATIVE: &str = "contracts/architecture/deviations.toml"; 19 const ARCHITECTURE_RELATIVE: &str = "contracts/crates/release_v1/radroots_crates_release_v1.toml"; 20 const ARCHITECTURE_ID: &str = "radroots.crates.release.v1"; 21 const PUBLIC_HOMEPAGE: &str = "https://radroots.org"; 22 const PUBLIC_README: &str = "README.md"; 23 const PUBLIC_AUTHORS: &[&str] = &["Tyson Lupul <tyson@radroots.org>"]; 24 25 #[derive(Debug, Deserialize)] 26 #[serde(deny_unknown_fields)] 27 struct DeviationLedger { 28 schema_version: u16, 29 architecture_id: String, 30 deviation: Vec<DeviationRecord>, 31 } 32 33 #[derive(Debug, Deserialize)] 34 #[serde(deny_unknown_fields)] 35 struct DeviationRecord { 36 id: String, 37 date: String, 38 status: String, 39 approval: String, 40 affected_steps: Vec<String>, 41 spec_anchors: Vec<String>, 42 source_evidence: Vec<String>, 43 replacement_action: String, 44 verification: Vec<String>, 45 unresolved_risk: String, 46 normative_architecture_change: bool, 47 adr_required: bool, 48 #[serde(default)] 49 closure_evidence: Vec<String>, 50 } 51 52 #[derive(Debug, Deserialize)] 53 struct ArchitectureIdentity { 54 spec_id: String, 55 edition: String, 56 resolver: String, 57 rust_version: String, 58 license: String, 59 canonical_repositories: Vec<String>, 60 repositories: BTreeMap<String, ArchitectureRepository>, 61 package: Vec<ArchitecturePackage>, 62 } 63 64 #[derive(Debug, Deserialize)] 65 struct ArchitectureRepository { 66 url: String, 67 version: String, 68 packages: Vec<String>, 69 } 70 71 #[derive(Debug, Deserialize)] 72 struct ArchitecturePackage { 73 name: String, 74 } 75 76 #[derive(Debug, Deserialize)] 77 struct ConsolidationOwnership { 78 canonical_rust_repository: String, 79 } 80 81 #[derive(Debug, Deserialize)] 82 struct WorkspaceManifest { 83 workspace: WorkspaceMembers, 84 } 85 86 #[derive(Debug, Deserialize)] 87 struct WorkspaceMembershipManifest { 88 workspace: WorkspaceMembership, 89 } 90 91 #[derive(Debug, Deserialize)] 92 struct WorkspaceMembership { 93 members: Vec<String>, 94 } 95 96 #[derive(Debug, Deserialize)] 97 struct WorkspaceMembers { 98 members: Vec<String>, 99 resolver: String, 100 package: WorkspacePackage, 101 metadata: WorkspaceMetadata, 102 lints: WorkspaceLints, 103 } 104 105 #[derive(Debug, Deserialize)] 106 struct WorkspaceLints { 107 rust: WorkspaceRustLints, 108 rustdoc: WorkspaceRustdocLints, 109 clippy: WorkspaceClippyLints, 110 } 111 112 #[derive(Debug, Deserialize)] 113 struct WorkspaceRustLints { 114 unsafe_code: String, 115 } 116 117 #[derive(Debug, Deserialize)] 118 struct WorkspaceRustdocLints { 119 broken_intra_doc_links: String, 120 } 121 122 #[derive(Debug, Deserialize)] 123 struct WorkspaceClippyLints { 124 dbg_macro: String, 125 todo: String, 126 unimplemented: String, 127 } 128 129 #[derive(Debug, Deserialize)] 130 struct WorkspaceMetadata { 131 radroots: RadrootsWorkspaceMetadata, 132 } 133 134 #[derive(Debug, Deserialize)] 135 struct RadrootsWorkspaceMetadata { 136 #[serde(rename = "public-package")] 137 public_package: PublicPackageMetadata, 138 } 139 140 #[derive(Debug, Deserialize)] 141 struct PublicPackageMetadata { 142 version: String, 143 authors: Vec<String>, 144 readme: String, 145 } 146 147 #[derive(Debug, Deserialize)] 148 struct WorkspacePackage { 149 version: String, 150 edition: String, 151 #[serde(rename = "rust-version")] 152 rust_version: String, 153 license: String, 154 repository: String, 155 homepage: String, 156 readme: String, 157 authors: Vec<String>, 158 } 159 160 pub fn validate(workspace_root: &Path) -> Result<(), String> { 161 validate_workspace_members(workspace_root)?; 162 let architecture_path = workspace_root.join(ARCHITECTURE_RELATIVE); 163 let architecture_raw = fs::read_to_string(&architecture_path) 164 .map_err(|error| format!("read {}: {error}", architecture_path.display()))?; 165 let architecture = toml::from_str::<ArchitectureIdentity>(&architecture_raw) 166 .map_err(|error| format!("parse {}: {error}", architecture_path.display()))?; 167 168 let architecture_packages = public_package_names(workspace_root, &architecture)?; 169 core_contract::validate(workspace_root)?; 170 api_leakage::validate_policy_catalog(workspace_root, &architecture_packages)?; 171 dependency_boundary::validate_policy_catalog(workspace_root, &architecture_packages)?; 172 retired_compatibility::validate(workspace_root)?; 173 decision_package::validate(workspace_root)?; 174 validate_workspace_toolchain(workspace_root, &architecture)?; 175 validate_public_package_metadata(workspace_root, &architecture)?; 176 validate_no_production_sibling_paths(workspace_root)?; 177 validate_public_dependency_versions(workspace_root, &architecture)?; 178 179 let ledger_path = workspace_root.join(DEVIATIONS_RELATIVE); 180 let ledger_raw = fs::read_to_string(&ledger_path) 181 .map_err(|error| format!("read {}: {error}", ledger_path.display()))?; 182 validate_ledger(workspace_root, &architecture.spec_id, &ledger_raw) 183 } 184 185 pub fn validate_dependency_boundaries(workspace_root: &Path) -> Result<(), String> { 186 validate(workspace_root)?; 187 dependency_boundary::validate_resolved_boundaries(workspace_root) 188 } 189 190 pub fn validate_api_boundaries(workspace_root: &Path) -> Result<(), String> { 191 validate(workspace_root)?; 192 api_leakage::validate_public_api(workspace_root) 193 } 194 195 pub fn validate_ci(workspace_root: &Path) -> Result<(), String> { 196 validate(workspace_root)?; 197 dependency_boundary::validate_resolved_boundaries(workspace_root)?; 198 api_leakage::validate_public_api(workspace_root) 199 } 200 201 fn validate_workspace_toolchain( 202 workspace_root: &Path, 203 architecture: &ArchitectureIdentity, 204 ) -> Result<(), String> { 205 let manifest_path = workspace_root.join("Cargo.toml"); 206 let manifest_raw = fs::read_to_string(&manifest_path) 207 .map_err(|error| format!("read {}: {error}", manifest_path.display()))?; 208 let manifest = toml::from_str::<WorkspaceManifest>(&manifest_raw) 209 .map_err(|error| format!("parse {}: {error}", manifest_path.display()))?; 210 if manifest.workspace.resolver != architecture.resolver || architecture.resolver != "3" { 211 return Err(format!( 212 "workspace resolver {} must match architecture resolver {}", 213 manifest.workspace.resolver, architecture.resolver 214 )); 215 } 216 if architecture.rust_version != FROZEN_V1_MSRV { 217 return Err("frozen release-v1 compiler identity must remain unchanged".to_owned()); 218 } 219 if manifest.workspace.package.rust_version != STABLE_TOOLCHAIN { 220 return Err(format!( 221 "workspace rust-version {} must match current minimum {STABLE_TOOLCHAIN}", 222 manifest.workspace.package.rust_version 223 )); 224 } 225 let workspace_package = &manifest.workspace.package; 226 let public_metadata = &manifest.workspace.metadata.radroots.public_package; 227 let repository = architecture 228 .repositories 229 .values() 230 .find(|repository| repository.url == workspace_package.repository) 231 .ok_or_else(|| "workspace repository has no architecture allocation".to_owned())?; 232 if public_metadata.version != repository.version { 233 return Err(format!( 234 "public package version source {} must match repository version {}", 235 public_metadata.version, repository.version 236 )); 237 } 238 if public_metadata.authors != PUBLIC_AUTHORS { 239 return Err("public package authors source must match the workspace convention".to_owned()); 240 } 241 if public_metadata.readme != PUBLIC_README { 242 return Err(format!( 243 "public package readme source must be {PUBLIC_README}" 244 )); 245 } 246 let lints = &manifest.workspace.lints; 247 if lints.rust.unsafe_code != "deny" 248 || lints.rustdoc.broken_intra_doc_links != "deny" 249 || lints.clippy.dbg_macro != "deny" 250 || lints.clippy.todo != "deny" 251 || lints.clippy.unimplemented != "deny" 252 { 253 return Err( 254 "workspace lints must deny unsafe code and deny the approved rustdoc/Clippy baseline" 255 .to_owned(), 256 ); 257 } 258 if workspace_package.edition != architecture.edition || architecture.edition != "2024" { 259 return Err(format!( 260 "workspace edition {} must match architecture edition {}", 261 workspace_package.edition, architecture.edition 262 )); 263 } 264 if workspace_package.license != architecture.license { 265 return Err(format!( 266 "workspace license {} must match architecture license {}", 267 workspace_package.license, architecture.license 268 )); 269 } 270 if !architecture 271 .canonical_repositories 272 .contains(&workspace_package.repository) 273 { 274 return Err(format!( 275 "workspace repository {} is not canonical", 276 workspace_package.repository 277 )); 278 } 279 if workspace_package.homepage != PUBLIC_HOMEPAGE { 280 return Err(format!( 281 "workspace homepage {} must be {PUBLIC_HOMEPAGE}", 282 workspace_package.homepage 283 )); 284 } 285 if workspace_package.authors != PUBLIC_AUTHORS { 286 return Err("workspace authors must match the public package convention".to_owned()); 287 } 288 if !workspace_root.join(&workspace_package.readme).is_file() { 289 return Err(format!( 290 "workspace readme {} does not exist", 291 workspace_package.readme 292 )); 293 } 294 for license in ["LICENSE-MIT", "LICENSE-APACHE"] { 295 if !workspace_root.join(license).is_file() { 296 return Err(format!("workspace is missing {license}")); 297 } 298 } 299 let toolchain_path = workspace_root.join("rust-toolchain.toml"); 300 let toolchain_raw = fs::read_to_string(&toolchain_path) 301 .map_err(|error| format!("read {}: {error}", toolchain_path.display()))?; 302 let toolchain = toolchain_raw 303 .parse::<toml::Value>() 304 .map_err(|error| format!("parse {}: {error}", toolchain_path.display()))?; 305 let channel = toolchain 306 .get("toolchain") 307 .and_then(|value| value.get("channel")) 308 .and_then(toml::Value::as_str); 309 if channel != Some(STABLE_TOOLCHAIN) { 310 return Err(format!( 311 "rust-toolchain.toml channel must match current compiler {STABLE_TOOLCHAIN}" 312 )); 313 } 314 Ok(()) 315 } 316 317 fn public_package_names( 318 workspace_root: &Path, 319 architecture: &ArchitectureIdentity, 320 ) -> Result<BTreeSet<String>, String> { 321 if workspace_root 322 .join("contracts/crates/catalog.v2.toml") 323 .is_file() 324 { 325 // Current allocation supersedes the frozen V1 inventory. A malformed 326 // present catalog must fail; only historical fixtures lack this input. 327 return crate::catalog::public_packages(workspace_root) 328 .map(|packages| packages.into_iter().collect()); 329 } 330 Ok(architecture 331 .package 332 .iter() 333 .map(|p| p.name.clone()) 334 .collect()) 335 } 336 337 fn validate_public_package_metadata( 338 workspace_root: &Path, 339 architecture: &ArchitectureIdentity, 340 ) -> Result<(), String> { 341 let workspace_raw = fs::read_to_string(workspace_root.join("Cargo.toml")) 342 .map_err(|error| format!("read workspace Cargo.toml: {error}"))?; 343 let workspace = toml::from_str::<WorkspaceManifest>(&workspace_raw) 344 .map_err(|error| format!("parse workspace Cargo.toml: {error}"))?; 345 let repository = architecture 346 .repositories 347 .values() 348 .find(|repository| repository.url == workspace.workspace.package.repository) 349 .ok_or_else(|| "workspace repository has no architecture allocation".to_owned())?; 350 let all_packages = public_package_names(workspace_root, architecture)?; 351 let consolidation_path = workspace_root.join("contracts/consolidation/architecture.v1.toml"); 352 let consolidated_owner = if consolidation_path.is_file() { 353 let consolidation = fs::read_to_string(&consolidation_path) 354 .map_err(|error| format!("read {}: {error}", consolidation_path.display()))?; 355 Some( 356 toml::from_str::<ConsolidationOwnership>(&consolidation) 357 .map_err(|error| format!("parse {}: {error}", consolidation_path.display()))? 358 .canonical_rust_repository, 359 ) 360 } else { 361 None 362 }; 363 let local_packages = 364 if consolidated_owner.as_deref() == Some(workspace.workspace.package.repository.as_str()) { 365 all_packages.iter().map(|name| (*name).to_owned()).collect() 366 } else { 367 repository.packages.iter().cloned().collect::<BTreeSet<_>>() 368 }; 369 let mut found_local_packages = BTreeSet::new(); 370 371 for member in &workspace.workspace.members { 372 let manifest_path = workspace_root.join(member).join("Cargo.toml"); 373 let raw = fs::read_to_string(&manifest_path) 374 .map_err(|error| format!("read {}: {error}", manifest_path.display()))?; 375 let manifest = raw 376 .parse::<toml::Value>() 377 .map_err(|error| format!("parse {}: {error}", manifest_path.display()))?; 378 let package = manifest 379 .get("package") 380 .and_then(toml::Value::as_table) 381 .ok_or_else(|| format!("{} is missing [package]", manifest_path.display()))?; 382 let name = package 383 .get("name") 384 .and_then(toml::Value::as_str) 385 .ok_or_else(|| format!("{} is missing package.name", manifest_path.display()))?; 386 if !all_packages.contains(name) { 387 continue; 388 } 389 if !local_packages.contains(name) { 390 return Err(format!( 391 "public package {name} belongs to a different canonical repository" 392 )); 393 } 394 found_local_packages.insert(name.to_owned()); 395 validate_public_manifest_field( 396 package, 397 "version", 398 &workspace.workspace.package.version, 399 &repository.version, 400 name, 401 )?; 402 validate_public_manifest_field( 403 package, 404 "edition", 405 &workspace.workspace.package.edition, 406 &architecture.edition, 407 name, 408 )?; 409 validate_public_manifest_field( 410 package, 411 "rust-version", 412 &workspace.workspace.package.rust_version, 413 STABLE_TOOLCHAIN, 414 name, 415 )?; 416 validate_public_manifest_field( 417 package, 418 "license", 419 &workspace.workspace.package.license, 420 &architecture.license, 421 name, 422 )?; 423 validate_public_manifest_field( 424 package, 425 "repository", 426 &workspace.workspace.package.repository, 427 &repository.url, 428 name, 429 )?; 430 validate_public_manifest_field( 431 package, 432 "homepage", 433 &workspace.workspace.package.homepage, 434 PUBLIC_HOMEPAGE, 435 name, 436 )?; 437 let authors = resolve_public_authors(package, &workspace.workspace.package.authors) 438 .ok_or_else(|| format!("public package {name} must declare authors"))?; 439 if authors != PUBLIC_AUTHORS { 440 return Err(format!( 441 "public package {name} authors must match the workspace convention" 442 )); 443 } 444 let readme = package.get("readme").and_then(toml::Value::as_str); 445 if readme != Some(PUBLIC_README) 446 || !workspace_root.join(member).join(PUBLIC_README).is_file() 447 { 448 return Err(format!( 449 "public package {name} must use an existing crate-local {PUBLIC_README}" 450 )); 451 } 452 let publish_registries = package 453 .get("publish") 454 .and_then(toml::Value::as_array) 455 .ok_or_else(|| format!("public package {name} must set publish = [\"crates-io\"]"))?; 456 if publish_registries.len() != 1 || publish_registries[0].as_str() != Some("crates-io") { 457 return Err(format!( 458 "public package {name} must set publish = [\"crates-io\"]" 459 )); 460 } 461 let inherits_lints = manifest 462 .get("lints") 463 .and_then(toml::Value::as_table) 464 .is_some_and(|lints| { 465 lints.len() == 1 466 && lints.get("workspace").and_then(toml::Value::as_bool) == Some(true) 467 }); 468 if !inherits_lints { 469 return Err(format!( 470 "public package {name} must inherit the workspace lint policy" 471 )); 472 } 473 } 474 if found_local_packages != local_packages { 475 let missing = local_packages 476 .difference(&found_local_packages) 477 .cloned() 478 .collect::<Vec<_>>() 479 .join(", "); 480 let extra = found_local_packages 481 .difference(&local_packages) 482 .cloned() 483 .collect::<Vec<_>>() 484 .join(", "); 485 return Err(format!( 486 "workspace public package inventory is missing: {missing}; workspace public package inventory has unallocated packages: {extra}" 487 )); 488 } 489 Ok(()) 490 } 491 492 fn validate_public_dependency_versions( 493 workspace_root: &Path, 494 architecture: &ArchitectureIdentity, 495 ) -> Result<(), String> { 496 let workspace_path = workspace_root.join("Cargo.toml"); 497 let workspace_raw = fs::read_to_string(&workspace_path) 498 .map_err(|error| format!("read {}: {error}", workspace_path.display()))?; 499 let workspace = toml::from_str::<WorkspaceManifest>(&workspace_raw) 500 .map_err(|error| format!("parse {}: {error}", workspace_path.display()))?; 501 let workspace_value = workspace_raw 502 .parse::<toml::Value>() 503 .map_err(|error| format!("parse {}: {error}", workspace_path.display()))?; 504 let workspace_dependencies = workspace_value 505 .get("workspace") 506 .and_then(toml::Value::as_table) 507 .and_then(|workspace| workspace.get("dependencies")) 508 .and_then(toml::Value::as_table); 509 let repository = architecture 510 .repositories 511 .values() 512 .find(|repository| repository.url == workspace.workspace.package.repository) 513 .ok_or_else(|| "workspace repository has no architecture allocation".to_owned())?; 514 let current_public = public_package_names(workspace_root, architecture)?; 515 let public_packages = current_public 516 .iter() 517 .map(String::as_str) 518 .collect::<BTreeSet<_>>(); 519 let current_catalog = workspace_root 520 .join("contracts/crates/catalog.v2.toml") 521 .is_file(); 522 let local_packages = if current_catalog { 523 public_packages.clone() 524 } else { 525 repository.packages.iter().map(String::as_str).collect() 526 }; 527 let package_versions = if current_catalog { 528 public_packages 529 .iter() 530 .map(|name| (*name, workspace.workspace.package.version.as_str())) 531 .collect() 532 } else { 533 architecture 534 .repositories 535 .values() 536 .flat_map(|repository| { 537 repository 538 .packages 539 .iter() 540 .map(|package| (package.as_str(), repository.version.as_str())) 541 }) 542 .collect::<BTreeMap<_, _>>() 543 }; 544 545 for member in &workspace.workspace.members { 546 let manifest_path = workspace_root.join(member).join("Cargo.toml"); 547 let raw = fs::read_to_string(&manifest_path) 548 .map_err(|error| format!("read {}: {error}", manifest_path.display()))?; 549 let manifest = raw 550 .parse::<toml::Value>() 551 .map_err(|error| format!("parse {}: {error}", manifest_path.display()))?; 552 let package_name = manifest 553 .get("package") 554 .and_then(toml::Value::as_table) 555 .and_then(|package| package.get("name")) 556 .and_then(toml::Value::as_str) 557 .ok_or_else(|| format!("{} is missing package.name", manifest_path.display()))?; 558 if !local_packages.contains(package_name) { 559 continue; 560 } 561 let policy = PublicDependencyPolicy { 562 workspace_root, 563 workspace_dependencies, 564 public_packages: &public_packages, 565 local_packages: &local_packages, 566 package_versions: &package_versions, 567 }; 568 validate_public_dependency_sections(member, package_name, &manifest, &policy)?; 569 } 570 Ok(()) 571 } 572 573 struct PublicDependencyPolicy<'a> { 574 workspace_root: &'a Path, 575 workspace_dependencies: Option<&'a toml::value::Table>, 576 public_packages: &'a BTreeSet<&'a str>, 577 local_packages: &'a BTreeSet<&'a str>, 578 package_versions: &'a BTreeMap<&'a str, &'a str>, 579 } 580 581 fn validate_public_dependency_sections( 582 member: &str, 583 owner: &str, 584 manifest: &toml::Value, 585 policy: &PublicDependencyPolicy<'_>, 586 ) -> Result<(), String> { 587 let manifest_table = manifest 588 .as_table() 589 .ok_or_else(|| format!("{member}/Cargo.toml must be a TOML table"))?; 590 for section in ["dependencies", "dev-dependencies", "build-dependencies"] { 591 if let Some(dependencies) = manifest_table.get(section).and_then(toml::Value::as_table) { 592 validate_public_dependency_table(member, owner, section, dependencies, policy)?; 593 } 594 } 595 if let Some(targets) = manifest_table.get("target").and_then(toml::Value::as_table) { 596 for (target, target_value) in targets { 597 let Some(target_table) = target_value.as_table() else { 598 continue; 599 }; 600 for section in ["dependencies", "dev-dependencies", "build-dependencies"] { 601 if let Some(dependencies) = 602 target_table.get(section).and_then(toml::Value::as_table) 603 { 604 validate_public_dependency_table( 605 member, 606 owner, 607 &format!("target.{target}.{section}"), 608 dependencies, 609 policy, 610 )?; 611 } 612 } 613 } 614 } 615 Ok(()) 616 } 617 618 fn validate_public_dependency_table( 619 member: &str, 620 owner: &str, 621 section: &str, 622 dependencies: &toml::value::Table, 623 policy: &PublicDependencyPolicy<'_>, 624 ) -> Result<(), String> { 625 for (dependency_key, declaration) in dependencies { 626 let inherits_workspace = declaration 627 .as_table() 628 .and_then(|table| table.get("workspace")) 629 .and_then(toml::Value::as_bool) 630 == Some(true); 631 let resolved = if inherits_workspace { 632 policy 633 .workspace_dependencies 634 .and_then(|dependencies| dependencies.get(dependency_key)) 635 .ok_or_else(|| { 636 format!( 637 "public package {owner} {section}.{dependency_key} inherits a missing workspace dependency" 638 ) 639 })? 640 } else { 641 declaration 642 }; 643 let resolved_table = resolved.as_table(); 644 let dependency_path = resolved_table 645 .and_then(|table| table.get("path")) 646 .and_then(toml::Value::as_str); 647 let declared_package = resolved_table 648 .and_then(|table| table.get("package")) 649 .and_then(toml::Value::as_str); 650 let path_base = if inherits_workspace { 651 policy.workspace_root.to_path_buf() 652 } else { 653 policy.workspace_root.join(member) 654 }; 655 let path_package = if declared_package.is_none() { 656 dependency_path 657 .map(|path| dependency_package_name(&path_base.join(path))) 658 .transpose()? 659 } else { 660 None 661 }; 662 let dependency_name = declared_package 663 .or(path_package.as_deref()) 664 .unwrap_or(dependency_key.as_str()); 665 let first_party = 666 dependency_key.starts_with("radroots_") || dependency_name.starts_with("radroots_"); 667 if first_party && !policy.public_packages.contains(dependency_name) { 668 return Err(format!( 669 "public package {owner} {section}.{dependency_key} must not depend on private first-party package {dependency_name}" 670 )); 671 } 672 if !policy.public_packages.contains(dependency_name) { 673 continue; 674 } 675 let version = match resolved { 676 toml::Value::String(version) => Some(version.as_str()), 677 toml::Value::Table(table) => table.get("version").and_then(toml::Value::as_str), 678 _ => None, 679 }; 680 let governed_version = policy 681 .package_versions 682 .get(dependency_name) 683 .ok_or_else(|| { 684 format!("public dependency {dependency_name} has no repository version authority") 685 })?; 686 let exact_version = format!("={governed_version}"); 687 if policy.local_packages.contains(dependency_name) 688 && (dependency_path.is_none() || version != Some(exact_version.as_str())) 689 { 690 return Err(format!( 691 "public package {owner} {section}.{dependency_key} dependency on {dependency_name} must declare path and exact version {exact_version}" 692 )); 693 } 694 if !policy.local_packages.contains(dependency_name) 695 && (dependency_path.is_some() || version != Some(exact_version.as_str())) 696 { 697 return Err(format!( 698 "public package {owner} {section}.{dependency_key} cross-repository dependency on {dependency_name} must declare exact registry version {exact_version} without a path" 699 )); 700 } 701 } 702 Ok(()) 703 } 704 705 fn validate_no_production_sibling_paths(workspace_root: &Path) -> Result<(), String> { 706 let canonical_root = fs::canonicalize(workspace_root) 707 .map_err(|error| format!("canonicalize {}: {error}", workspace_root.display()))?; 708 let workspace_path = workspace_root.join("Cargo.toml"); 709 let workspace_raw = fs::read_to_string(&workspace_path) 710 .map_err(|error| format!("read {}: {error}", workspace_path.display()))?; 711 let workspace = toml::from_str::<WorkspaceManifest>(&workspace_raw) 712 .map_err(|error| format!("parse {}: {error}", workspace_path.display()))?; 713 let workspace_value = workspace_raw 714 .parse::<toml::Value>() 715 .map_err(|error| format!("parse {}: {error}", workspace_path.display()))?; 716 if let Some(dependencies) = workspace_value 717 .get("workspace") 718 .and_then(toml::Value::as_table) 719 .and_then(|workspace| workspace.get("dependencies")) 720 .and_then(toml::Value::as_table) 721 { 722 validate_dependency_path_table( 723 &canonical_root, 724 &canonical_root, 725 "workspace", 726 "workspace.dependencies", 727 dependencies, 728 )?; 729 } 730 for member in &workspace.workspace.members { 731 let manifest_path = workspace_root.join(member).join("Cargo.toml"); 732 let raw = fs::read_to_string(&manifest_path) 733 .map_err(|error| format!("read {}: {error}", manifest_path.display()))?; 734 let manifest = raw 735 .parse::<toml::Value>() 736 .map_err(|error| format!("parse {}: {error}", manifest_path.display()))?; 737 validate_manifest_dependency_paths( 738 &canonical_root, 739 &canonical_root.join(member), 740 member, 741 &manifest, 742 )?; 743 } 744 Ok(()) 745 } 746 747 fn validate_manifest_dependency_paths( 748 workspace_root: &Path, 749 package_root: &Path, 750 owner: &str, 751 manifest: &toml::Value, 752 ) -> Result<(), String> { 753 let Some(manifest_table) = manifest.as_table() else { 754 return Err(format!("{owner}/Cargo.toml must be a TOML table")); 755 }; 756 for section in ["dependencies", "dev-dependencies", "build-dependencies"] { 757 if let Some(dependencies) = manifest_table.get(section).and_then(toml::Value::as_table) { 758 validate_dependency_path_table( 759 workspace_root, 760 package_root, 761 owner, 762 section, 763 dependencies, 764 )?; 765 } 766 } 767 if let Some(targets) = manifest_table.get("target").and_then(toml::Value::as_table) { 768 for (target, target_value) in targets { 769 let Some(target_table) = target_value.as_table() else { 770 continue; 771 }; 772 for section in ["dependencies", "dev-dependencies", "build-dependencies"] { 773 if let Some(dependencies) = 774 target_table.get(section).and_then(toml::Value::as_table) 775 { 776 validate_dependency_path_table( 777 workspace_root, 778 package_root, 779 owner, 780 &format!("target.{target}.{section}"), 781 dependencies, 782 )?; 783 } 784 } 785 } 786 } 787 Ok(()) 788 } 789 790 fn validate_dependency_path_table( 791 workspace_root: &Path, 792 path_base: &Path, 793 owner: &str, 794 section: &str, 795 dependencies: &toml::value::Table, 796 ) -> Result<(), String> { 797 for (dependency, declaration) in dependencies { 798 let Some(path) = declaration 799 .as_table() 800 .and_then(|table| table.get("path")) 801 .and_then(toml::Value::as_str) 802 else { 803 continue; 804 }; 805 let resolved = fs::canonicalize(path_base.join(path)).map_err(|error| { 806 format!( 807 "resolve production dependency {owner} {section}.{dependency} path {path}: {error}" 808 ) 809 })?; 810 if !resolved.starts_with(workspace_root) { 811 return Err(format!( 812 "production dependency {owner} {section}.{dependency} path {path} escapes the repository; use a registry version or an external local-development override" 813 )); 814 } 815 } 816 Ok(()) 817 } 818 819 fn dependency_package_name(package_root: &Path) -> Result<String, String> { 820 let manifest_path = package_root.join("Cargo.toml"); 821 let raw = fs::read_to_string(&manifest_path).map_err(|error| { 822 format!( 823 "read dependency manifest {}: {error}", 824 manifest_path.display() 825 ) 826 })?; 827 let manifest = raw.parse::<toml::Value>().map_err(|error| { 828 format!( 829 "parse dependency manifest {}: {error}", 830 manifest_path.display() 831 ) 832 })?; 833 manifest 834 .get("package") 835 .and_then(toml::Value::as_table) 836 .and_then(|package| package.get("name")) 837 .and_then(toml::Value::as_str) 838 .map(str::to_owned) 839 .ok_or_else(|| format!("{} is missing package.name", manifest_path.display())) 840 } 841 842 fn validate_public_manifest_field( 843 package: &toml::value::Table, 844 key: &str, 845 workspace_value: &str, 846 expected: &str, 847 package_name: &str, 848 ) -> Result<(), String> { 849 let value = resolve_public_string(package, key, workspace_value) 850 .ok_or_else(|| format!("public package {package_name} must declare {key}"))?; 851 if value != expected { 852 return Err(format!( 853 "public package {package_name} {key} {value} must be {expected}" 854 )); 855 } 856 Ok(()) 857 } 858 859 fn resolve_public_string<'a>( 860 package: &'a toml::value::Table, 861 key: &str, 862 workspace_value: &'a str, 863 ) -> Option<&'a str> { 864 match package.get(key)? { 865 toml::Value::String(value) => Some(value), 866 toml::Value::Table(value) 867 if value.get("workspace").and_then(toml::Value::as_bool) == Some(true) => 868 { 869 Some(workspace_value) 870 } 871 _ => None, 872 } 873 } 874 875 fn resolve_public_authors<'a>( 876 package: &'a toml::value::Table, 877 workspace_authors: &'a [String], 878 ) -> Option<Vec<&'a str>> { 879 match package.get("authors")? { 880 toml::Value::Array(values) => values.iter().map(toml::Value::as_str).collect(), 881 toml::Value::Table(value) 882 if value.get("workspace").and_then(toml::Value::as_bool) == Some(true) => 883 { 884 Some(workspace_authors.iter().map(String::as_str).collect()) 885 } 886 _ => None, 887 } 888 } 889 890 fn validate_workspace_members(workspace_root: &Path) -> Result<(), String> { 891 let manifest_path = workspace_root.join("Cargo.toml"); 892 let manifest_raw = fs::read_to_string(&manifest_path) 893 .map_err(|error| format!("read {}: {error}", manifest_path.display()))?; 894 let manifest = toml::from_str::<WorkspaceMembershipManifest>(&manifest_raw) 895 .map_err(|error| format!("parse {}: {error}", manifest_path.display()))?; 896 let manifest_value = manifest_raw 897 .parse::<toml::Value>() 898 .map_err(|error| format!("parse {}: {error}", manifest_path.display()))?; 899 validate_manifest_dependency_keys(&manifest_value, "Cargo.toml")?; 900 let declared = manifest 901 .workspace 902 .members 903 .into_iter() 904 .collect::<BTreeSet<_>>(); 905 let mut discovered = BTreeSet::new(); 906 for root in ["crates", "tools"] { 907 let directory = workspace_root.join(root); 908 for entry in fs::read_dir(&directory) 909 .map_err(|error| format!("read {}: {error}", directory.display()))? 910 { 911 let entry = 912 entry.map_err(|error| format!("read {} entry: {error}", directory.display()))?; 913 if entry 914 .file_type() 915 .map_err(|error| format!("read {} type: {error}", entry.path().display()))? 916 .is_dir() 917 && entry.path().join("Cargo.toml").is_file() 918 { 919 let directory_name = entry.file_name().to_string_lossy().into_owned(); 920 require_lower_snake_case( 921 &directory_name, 922 &format!("{root}/{directory_name} crate directory"), 923 )?; 924 let package_manifest_path = entry.path().join("Cargo.toml"); 925 let package_manifest_raw = 926 fs::read_to_string(&package_manifest_path).map_err(|error| { 927 format!("read {}: {error}", package_manifest_path.display()) 928 })?; 929 let package_manifest = 930 package_manifest_raw 931 .parse::<toml::Value>() 932 .map_err(|error| { 933 format!("parse {}: {error}", package_manifest_path.display()) 934 })?; 935 let package_name = package_manifest 936 .get("package") 937 .and_then(toml::Value::as_table) 938 .and_then(|package| package.get("name")) 939 .and_then(toml::Value::as_str) 940 .ok_or_else(|| { 941 format!( 942 "{} is missing package.name", 943 package_manifest_path.display() 944 ) 945 })?; 946 require_lower_snake_case( 947 package_name, 948 &format!("{} package.name", package_manifest_path.display()), 949 )?; 950 validate_manifest_dependency_keys( 951 &package_manifest, 952 &package_manifest_path.display().to_string(), 953 )?; 954 discovered.insert(format!("{root}/{directory_name}")); 955 } 956 } 957 } 958 if declared != discovered { 959 let missing = discovered 960 .difference(&declared) 961 .cloned() 962 .collect::<Vec<_>>() 963 .join(", "); 964 let unknown = declared 965 .difference(&discovered) 966 .cloned() 967 .collect::<Vec<_>>() 968 .join(", "); 969 return Err(format!( 970 "workspace membership is missing local package roots: {missing}; workspace membership has unknown package roots: {unknown}" 971 )); 972 } 973 Ok(()) 974 } 975 976 fn validate_manifest_dependency_keys(manifest: &toml::Value, label: &str) -> Result<(), String> { 977 let Some(manifest) = manifest.as_table() else { 978 return Err(format!("{label} must be a TOML table")); 979 }; 980 for section in ["dependencies", "dev-dependencies", "build-dependencies"] { 981 if let Some(dependencies) = manifest.get(section).and_then(toml::Value::as_table) { 982 validate_dependency_keys(dependencies, label, section)?; 983 } 984 } 985 if let Some(workspace_dependencies) = manifest 986 .get("workspace") 987 .and_then(toml::Value::as_table) 988 .and_then(|workspace| workspace.get("dependencies")) 989 .and_then(toml::Value::as_table) 990 { 991 validate_dependency_keys(workspace_dependencies, label, "workspace.dependencies")?; 992 } 993 if let Some(targets) = manifest.get("target").and_then(toml::Value::as_table) { 994 for (target, target_value) in targets { 995 let Some(target_table) = target_value.as_table() else { 996 continue; 997 }; 998 for section in ["dependencies", "dev-dependencies", "build-dependencies"] { 999 if let Some(dependencies) = 1000 target_table.get(section).and_then(toml::Value::as_table) 1001 { 1002 validate_dependency_keys( 1003 dependencies, 1004 label, 1005 &format!("target.{target}.{section}"), 1006 )?; 1007 } 1008 } 1009 } 1010 } 1011 Ok(()) 1012 } 1013 1014 fn validate_dependency_keys( 1015 dependencies: &toml::value::Table, 1016 label: &str, 1017 section: &str, 1018 ) -> Result<(), String> { 1019 for key in dependencies 1020 .keys() 1021 .filter(|key| key.starts_with("radroots")) 1022 { 1023 require_lower_snake_case(key, &format!("{label} {section} dependency key"))?; 1024 } 1025 Ok(()) 1026 } 1027 1028 fn require_lower_snake_case(value: &str, label: &str) -> Result<(), String> { 1029 if is_lower_snake_case(value) { 1030 Ok(()) 1031 } else { 1032 Err(format!("{label} `{value}` must use lowercase snake case")) 1033 } 1034 } 1035 1036 fn is_lower_snake_case(value: &str) -> bool { 1037 !value.is_empty() 1038 && value.split('_').all(|segment| { 1039 segment 1040 .as_bytes() 1041 .first() 1042 .is_some_and(u8::is_ascii_lowercase) 1043 && segment 1044 .bytes() 1045 .all(|byte| byte.is_ascii_lowercase() || byte.is_ascii_digit()) 1046 }) 1047 } 1048 1049 fn validate_ledger( 1050 workspace_root: &Path, 1051 expected_architecture_id: &str, 1052 raw: &str, 1053 ) -> Result<(), String> { 1054 let ledger = toml::from_str::<DeviationLedger>(raw) 1055 .map_err(|error| format!("parse {DEVIATIONS_RELATIVE}: {error}"))?; 1056 if ledger.schema_version != 1 { 1057 return Err("deviation ledger schema_version must be 1".to_owned()); 1058 } 1059 if ledger.architecture_id != expected_architecture_id 1060 || ledger.architecture_id != ARCHITECTURE_ID 1061 { 1062 return Err(format!( 1063 "deviation ledger architecture_id {} must match {}", 1064 ledger.architecture_id, expected_architecture_id 1065 )); 1066 } 1067 1068 let mut ids = BTreeSet::new(); 1069 for record in &ledger.deviation { 1070 validate_record(workspace_root, record)?; 1071 if !ids.insert(record.id.as_str()) { 1072 return Err(format!("duplicate deviation id {}", record.id)); 1073 } 1074 } 1075 Ok(()) 1076 } 1077 1078 fn validate_record(workspace_root: &Path, record: &DeviationRecord) -> Result<(), String> { 1079 if !is_deviation_id(&record.id) { 1080 return Err(format!("deviation id {} must use RCRV1-DEV-NNN", record.id)); 1081 } 1082 if !is_iso_date(&record.date) { 1083 return Err(format!("deviation {} date must use YYYY-MM-DD", record.id)); 1084 } 1085 if !matches!(record.status.as_str(), "active" | "closed" | "superseded") { 1086 return Err(format!( 1087 "deviation {} status must be active, closed, or superseded", 1088 record.id 1089 )); 1090 } 1091 require_text(&record.id, "approval", &record.approval)?; 1092 require_text(&record.id, "replacement_action", &record.replacement_action)?; 1093 require_text(&record.id, "unresolved_risk", &record.unresolved_risk)?; 1094 require_nonempty_list(&record.id, "affected_steps", &record.affected_steps)?; 1095 require_nonempty_list(&record.id, "spec_anchors", &record.spec_anchors)?; 1096 require_nonempty_list(&record.id, "source_evidence", &record.source_evidence)?; 1097 require_nonempty_list(&record.id, "verification", &record.verification)?; 1098 1099 for step in &record.affected_steps { 1100 let valid = step.len() == 3 1101 && step.bytes().all(|byte| byte.is_ascii_digit()) 1102 && step 1103 .parse::<u16>() 1104 .is_ok_and(|value| (1..=315).contains(&value)); 1105 if !valid { 1106 return Err(format!( 1107 "deviation {} affected step {} must be in 001..315", 1108 record.id, step 1109 )); 1110 } 1111 } 1112 for anchor in &record.spec_anchors { 1113 validate_spec_anchor(workspace_root, &record.id, anchor)?; 1114 } 1115 if record.status == "active" && !record.closure_evidence.is_empty() { 1116 return Err(format!( 1117 "active deviation {} must not carry closure_evidence", 1118 record.id 1119 )); 1120 } 1121 if record.status != "active" { 1122 require_nonempty_list(&record.id, "closure_evidence", &record.closure_evidence)?; 1123 } 1124 1125 let _ = (record.normative_architecture_change, record.adr_required); 1126 Ok(()) 1127 } 1128 1129 fn validate_spec_anchor( 1130 workspace_root: &Path, 1131 deviation_id: &str, 1132 anchor: &str, 1133 ) -> Result<(), String> { 1134 let (relative, fragment) = anchor 1135 .split_once('#') 1136 .map_or((anchor, None), |(path, fragment)| (path, Some(fragment))); 1137 if relative.trim().is_empty() || fragment.is_none_or(|value| value.trim().is_empty()) { 1138 return Err(format!( 1139 "deviation {deviation_id} has invalid spec anchor {anchor}" 1140 )); 1141 } 1142 let path = Path::new(relative); 1143 if path.components().any(|component| { 1144 matches!( 1145 component, 1146 Component::ParentDir | Component::RootDir | Component::Prefix(_) 1147 ) 1148 }) { 1149 return Err(format!( 1150 "deviation {deviation_id} spec anchor must be repository-relative: {anchor}" 1151 )); 1152 } 1153 if relative != ARCHITECTURE_RELATIVE { 1154 return Err(format!( 1155 "deviation {deviation_id} spec anchor must target {ARCHITECTURE_RELATIVE}: {anchor}" 1156 )); 1157 } 1158 let machine_path = workspace_root.join(path); 1159 let raw = fs::read_to_string(&machine_path) 1160 .map_err(|error| format!("read {}: {error}", machine_path.display()))?; 1161 let machine = toml::from_str::<toml::Value>(&raw) 1162 .map_err(|error| format!("parse {}: {error}", machine_path.display()))?; 1163 let selector = fragment.expect("fragment is required above"); 1164 if !machine_selector_exists(&machine, selector) { 1165 return Err(format!( 1166 "deviation {deviation_id} spec anchor has unknown machine selector {selector}" 1167 )); 1168 } 1169 Ok(()) 1170 } 1171 1172 fn machine_selector_exists(machine: &toml::Value, selector: &str) -> bool { 1173 let segments = selector.split('.').collect::<Vec<_>>(); 1174 if segments.iter().any(|segment| segment.is_empty()) { 1175 return false; 1176 } 1177 let root = match machine.as_table() { 1178 Some(root) => root, 1179 None => return false, 1180 }; 1181 match segments.as_slice() { 1182 ["repositories", repository] => root 1183 .get("repositories") 1184 .and_then(toml::Value::as_table) 1185 .and_then(|repositories| repositories.get(*repository)) 1186 .is_some_and(toml::Value::is_table), 1187 ["repository_policy"] | ["release_policy"] => { 1188 root.get(segments[0]).is_some_and(toml::Value::is_table) 1189 } 1190 ["quality_policy", "coverage"] => root 1191 .get("quality_policy") 1192 .and_then(toml::Value::as_table) 1193 .and_then(|quality| quality.get("coverage")) 1194 .is_some_and(toml::Value::is_table), 1195 ["package", package] => root 1196 .get("package") 1197 .and_then(toml::Value::as_array) 1198 .is_some_and(|packages| { 1199 packages.iter().any(|candidate| { 1200 candidate 1201 .as_table() 1202 .and_then(|table| table.get("name")) 1203 .and_then(toml::Value::as_str) 1204 == Some(*package) 1205 }) 1206 }), 1207 _ => false, 1208 } 1209 } 1210 1211 fn require_text(deviation_id: &str, field: &str, value: &str) -> Result<(), String> { 1212 if value.trim().is_empty() { 1213 return Err(format!( 1214 "deviation {deviation_id} field {field} must not be empty" 1215 )); 1216 } 1217 Ok(()) 1218 } 1219 1220 fn require_nonempty_list(deviation_id: &str, field: &str, values: &[String]) -> Result<(), String> { 1221 if values.is_empty() || values.iter().any(|value| value.trim().is_empty()) { 1222 return Err(format!( 1223 "deviation {deviation_id} field {field} must contain non-empty values" 1224 )); 1225 } 1226 Ok(()) 1227 } 1228 1229 fn is_deviation_id(value: &str) -> bool { 1230 value 1231 .strip_prefix("RCRV1-DEV-") 1232 .is_some_and(|suffix| suffix.len() == 3 && suffix.bytes().all(|byte| byte.is_ascii_digit())) 1233 } 1234 1235 fn is_iso_date(value: &str) -> bool { 1236 value.len() == 10 1237 && value.as_bytes()[4] == b'-' 1238 && value.as_bytes()[7] == b'-' 1239 && value 1240 .bytes() 1241 .enumerate() 1242 .all(|(index, byte)| matches!(index, 4 | 7) || byte.is_ascii_digit()) 1243 } 1244 1245 #[cfg(test)] 1246 mod tests { 1247 use std::{ 1248 collections::BTreeMap, 1249 fs, 1250 path::PathBuf, 1251 time::{SystemTime, UNIX_EPOCH}, 1252 }; 1253 1254 use super::{ 1255 ArchitectureIdentity, ArchitecturePackage, ArchitectureRepository, validate_ledger, 1256 validate_no_production_sibling_paths, validate_public_dependency_versions, 1257 validate_public_package_metadata, validate_workspace_members, validate_workspace_toolchain, 1258 }; 1259 1260 fn test_root(label: &str) -> PathBuf { 1261 let nonce = SystemTime::now() 1262 .duration_since(UNIX_EPOCH) 1263 .expect("clock") 1264 .as_nanos(); 1265 let root = std::env::temp_dir().join(format!("radroots_architecture_{label}_{nonce}")); 1266 fs::create_dir_all(root.join("contracts/crates/release_v1")).expect("create spec root"); 1267 fs::write( 1268 root.join("contracts/crates/release_v1/radroots_crates_release_v1.toml"), 1269 "spec_id = \"radroots.crates.release.v1\"\n\n[repositories.sdk]\nurl = \"https://github.com/radrootslabs/sdk\"\n", 1270 ) 1271 .expect("write spec"); 1272 root 1273 } 1274 1275 fn complete_ledger() -> &'static str { 1276 r#"schema_version = 1 1277 architecture_id = "radroots.crates.release.v1" 1278 1279 [[deviation]] 1280 id = "RCRV1-DEV-001" 1281 date = "2026-07-27" 1282 status = "active" 1283 approval = "Explicit user correction dated 2026-07-27." 1284 affected_steps = ["015", "016"] 1285 spec_anchors = ["contracts/crates/release_v1/radroots_crates_release_v1.toml#repositories.sdk"] 1286 source_evidence = ["The approved architecture assigns packages to the existing lib and sdk repositories."] 1287 replacement_action = "Keep both standalone repositories and verify them independently." 1288 verification = ["Repository-local architecture validation passes."] 1289 unresolved_risk = "Remote publication remains separately authorized." 1290 normative_architecture_change = false 1291 adr_required = false 1292 "# 1293 } 1294 1295 fn architecture() -> ArchitectureIdentity { 1296 ArchitectureIdentity { 1297 spec_id: "radroots.crates.release.v1".to_string(), 1298 edition: "2024".to_string(), 1299 resolver: "3".to_string(), 1300 rust_version: "1.97.1".to_string(), 1301 license: "MIT OR Apache-2.0".to_string(), 1302 canonical_repositories: vec!["https://github.com/radrootslabs/sdk".to_string()], 1303 repositories: BTreeMap::from([( 1304 "sdk".to_string(), 1305 ArchitectureRepository { 1306 url: "https://github.com/radrootslabs/sdk".to_string(), 1307 version: "0.1.0".to_string(), 1308 packages: vec!["radroots".to_string()], 1309 }, 1310 )]), 1311 package: vec![ArchitecturePackage { 1312 name: "radroots".to_string(), 1313 }], 1314 } 1315 } 1316 1317 fn complete_workspace_manifest(members: &str) -> String { 1318 format!( 1319 "[workspace]\nmembers = [{members}]\nresolver = \"3\"\n\n[workspace.package]\nversion = \"0.1.0\"\nedition = \"2024\"\nrust-version = \"1.99.0\"\nlicense = \"MIT OR Apache-2.0\"\nrepository = \"https://github.com/radrootslabs/sdk\"\nhomepage = \"https://radroots.org\"\nreadme = \"README\"\nauthors = [\"Tyson Lupul <tyson@radroots.org>\"]\n\n[workspace.metadata.radroots.public-package]\nversion = \"0.1.0\"\nauthors = [\"Tyson Lupul <tyson@radroots.org>\"]\nreadme = \"README.md\"\n\n[workspace.lints.rust]\nunsafe_code = \"deny\"\n\n[workspace.lints.rustdoc]\nbroken_intra_doc_links = \"deny\"\n\n[workspace.lints.clippy]\ndbg_macro = \"deny\"\ntodo = \"deny\"\nunimplemented = \"deny\"\n" 1320 ) 1321 } 1322 1323 #[test] 1324 fn accepts_complete_active_deviation() { 1325 let root = test_root("complete"); 1326 validate_ledger(&root, "radroots.crates.release.v1", complete_ledger()) 1327 .expect("complete deviation"); 1328 let _ = fs::remove_dir_all(root); 1329 } 1330 1331 #[test] 1332 fn rejects_incomplete_active_deviation() { 1333 let root = test_root("incomplete"); 1334 let incomplete = complete_ledger().replace( 1335 "spec_anchors = [\"contracts/crates/release_v1/radroots_crates_release_v1.toml#repositories.sdk\"]", 1336 "spec_anchors = []", 1337 ); 1338 let error = validate_ledger(&root, "radroots.crates.release.v1", &incomplete) 1339 .expect_err("missing anchor must fail"); 1340 assert!(error.contains("field spec_anchors must contain non-empty values")); 1341 let _ = fs::remove_dir_all(root); 1342 } 1343 1344 #[test] 1345 fn deviation_anchors_require_resolving_machine_selectors() { 1346 let root = test_root("machine_selector"); 1347 let invalid = complete_ledger().replace("#repositories.sdk", "#garbage"); 1348 let error = validate_ledger(&root, "radroots.crates.release.v1", &invalid) 1349 .expect_err("arbitrary fragment must fail"); 1350 assert!(error.contains("unknown machine selector garbage")); 1351 1352 let markdown_slug = 1353 complete_ledger().replace("#repositories.sdk", "#20-current-to-target-migration-map"); 1354 let error = validate_ledger(&root, "radroots.crates.release.v1", &markdown_slug) 1355 .expect_err("Markdown heading slug must fail"); 1356 assert!(error.contains("unknown machine selector")); 1357 let _ = fs::remove_dir_all(root); 1358 } 1359 1360 #[test] 1361 fn workspace_membership_requires_every_local_package_root() { 1362 let root = test_root("workspace_members"); 1363 for path in ["crates/a", "tools/xtask"] { 1364 fs::create_dir_all(root.join(path)).expect("create package root"); 1365 fs::write( 1366 root.join(path).join("Cargo.toml"), 1367 "[package]\nname = \"fixture\"\n", 1368 ) 1369 .expect("write package manifest"); 1370 } 1371 fs::write( 1372 root.join("Cargo.toml"), 1373 "[workspace]\nmembers = [\"crates/a\", \"tools/xtask\"]\nresolver = \"3\"\n\n[workspace.package]\nrust-version = \"1.99.0\"\n", 1374 ) 1375 .expect("write complete workspace"); 1376 validate_workspace_members(&root).expect("complete membership"); 1377 1378 fs::write( 1379 root.join("Cargo.toml"), 1380 "[workspace]\nmembers = [\"tools/xtask\"]\nresolver = \"3\"\n\n[workspace.package]\nrust-version = \"1.99.0\"\n", 1381 ) 1382 .expect("write incomplete workspace"); 1383 let error = validate_workspace_members(&root).expect_err("missing member must fail"); 1384 assert!(error.contains("missing local package roots: crates/a")); 1385 let _ = fs::remove_dir_all(root); 1386 } 1387 1388 #[test] 1389 fn workspace_identity_rejects_kebab_case_crate_names_and_dependency_keys() { 1390 let root = test_root("workspace_snake_case_identity"); 1391 fs::create_dir_all(root.join("crates/radroots_probe")).expect("create package root"); 1392 fs::create_dir_all(root.join("tools/xtask")).expect("create xtask root"); 1393 fs::write( 1394 root.join("Cargo.toml"), 1395 "[workspace]\nmembers = [\"crates/radroots_probe\", \"tools/xtask\"]\nresolver = \"3\"\n", 1396 ) 1397 .expect("write workspace manifest"); 1398 fs::write( 1399 root.join("crates/radroots_probe/Cargo.toml"), 1400 "[package]\nname = \"radroots-probe\"\n", 1401 ) 1402 .expect("write kebab package manifest"); 1403 fs::write( 1404 root.join("tools/xtask/Cargo.toml"), 1405 "[package]\nname = \"xtask\"\n", 1406 ) 1407 .expect("write xtask manifest"); 1408 1409 let package_error = validate_workspace_members(&root) 1410 .expect_err("kebab-case Cargo package identity must fail"); 1411 assert!(package_error.contains("package.name")); 1412 assert!(package_error.contains("lowercase snake case")); 1413 1414 fs::write( 1415 root.join("crates/radroots_probe/Cargo.toml"), 1416 "[package]\nname = \"radroots_probe\"\n", 1417 ) 1418 .expect("write snake package manifest"); 1419 fs::write( 1420 root.join("Cargo.toml"), 1421 "[workspace]\nmembers = [\"crates/radroots_probe\", \"tools/xtask\"]\nresolver = \"3\"\n\n[workspace.dependencies]\nradroots-probe = \"0.1.0\"\n", 1422 ) 1423 .expect("write kebab dependency key"); 1424 1425 let dependency_error = validate_workspace_members(&root) 1426 .expect_err("kebab-case Radroots dependency key must fail"); 1427 assert!(dependency_error.contains("workspace.dependencies dependency key")); 1428 assert!(dependency_error.contains("lowercase snake case")); 1429 let _ = fs::remove_dir_all(root); 1430 } 1431 1432 #[test] 1433 fn workspace_toolchain_requires_exact_resolver_and_rust_version() { 1434 let root = test_root("workspace_toolchain"); 1435 fs::write(root.join("Cargo.toml"), complete_workspace_manifest("")) 1436 .expect("write workspace manifest"); 1437 for path in ["README", "LICENSE-MIT", "LICENSE-APACHE"] { 1438 fs::write(root.join(path), "fixture\n").expect("write workspace metadata file"); 1439 } 1440 fs::write( 1441 root.join("rust-toolchain.toml"), 1442 "[toolchain]\nchannel = \"1.99.0\"\n", 1443 ) 1444 .expect("write toolchain"); 1445 let mut architecture = architecture(); 1446 assert_eq!(architecture.rust_version, "1.97.1"); 1447 validate_workspace_toolchain(&root, &architecture).expect("exact current toolchain policy"); 1448 1449 for minimum in ["1.97.1", "1.98.0", "stable", "1.100.0"] { 1450 let manifest = complete_workspace_manifest("").replace("1.99.0", minimum); 1451 fs::write(root.join("Cargo.toml"), manifest).expect("write wrong current minimum"); 1452 assert!( 1453 validate_workspace_toolchain(&root, &architecture).is_err(), 1454 "accepted wrong current minimum {minimum}" 1455 ); 1456 } 1457 fs::write(root.join("Cargo.toml"), complete_workspace_manifest("")) 1458 .expect("restore current minimum"); 1459 architecture.rust_version = "1.99.0".to_owned(); 1460 assert!( 1461 validate_workspace_toolchain(&root, &architecture).is_err(), 1462 "accepted relabeled frozen release minimum" 1463 ); 1464 architecture.rust_version = "1.97.1".to_owned(); 1465 1466 fs::write( 1467 root.join("rust-toolchain.toml"), 1468 "[toolchain]\nchannel = \"1.97.1\"\n", 1469 ) 1470 .expect("write mismatched toolchain"); 1471 let error = validate_workspace_toolchain(&root, &architecture) 1472 .expect_err("mismatched toolchain must fail"); 1473 assert!(error.contains("channel must match")); 1474 let _ = fs::remove_dir_all(root); 1475 } 1476 1477 #[test] 1478 fn malformed_current_catalog_never_falls_back_to_frozen_allocation() { 1479 let root = test_root("malformed_current_catalog"); 1480 fs::create_dir_all(root.join("contracts/crates")).unwrap(); 1481 fs::write( 1482 root.join("contracts/crates/catalog.v2.toml"), 1483 "invalid current input", 1484 ) 1485 .unwrap(); 1486 assert!(super::public_package_names(&root, &architecture()).is_err()); 1487 let _ = fs::remove_dir_all(root); 1488 } 1489 1490 #[test] 1491 fn current_allocation_includes_shared_owners_and_rejects_private_packages() { 1492 let root = std::path::Path::new(env!("CARGO_MANIFEST_DIR")) 1493 .parent() 1494 .unwrap() 1495 .parent() 1496 .unwrap(); 1497 let names = super::public_package_names(root, &architecture()).unwrap(); 1498 assert_eq!(names.len(), 22); 1499 assert!(names.contains("radroots_domain") && names.contains("radroots_execution")); 1500 assert!(!names.contains("radroots_nostrdb")); 1501 } 1502 1503 #[test] 1504 fn public_package_metadata_requires_canonical_inheritance() { 1505 let root = test_root("public_package_metadata"); 1506 fs::create_dir_all(root.join("crates/radroots")).expect("create public package"); 1507 fs::write( 1508 root.join("Cargo.toml"), 1509 complete_workspace_manifest("\"crates/radroots\""), 1510 ) 1511 .expect("write workspace manifest"); 1512 let manifest = "[package]\nname = \"radroots\"\nversion.workspace = true\nedition.workspace = true\nrust-version.workspace = true\nlicense.workspace = true\nrepository.workspace = true\nhomepage.workspace = true\nauthors.workspace = true\nreadme = \"README.md\"\npublish = [\"crates-io\"]\n\n[lints]\nworkspace = true\n"; 1513 fs::write(root.join("crates/radroots/Cargo.toml"), manifest) 1514 .expect("write public manifest"); 1515 fs::write(root.join("crates/radroots/README.md"), "fixture\n") 1516 .expect("write public readme"); 1517 validate_public_package_metadata(&root, &architecture()).expect("canonical metadata"); 1518 1519 fs::write( 1520 root.join("crates/radroots/Cargo.toml"), 1521 manifest.replace("[lints]\nworkspace = true\n", ""), 1522 ) 1523 .expect("write incomplete public manifest"); 1524 let error = validate_public_package_metadata(&root, &architecture()) 1525 .expect_err("missing lint inheritance must fail"); 1526 assert!(error.contains("must inherit the workspace lint policy")); 1527 let _ = fs::remove_dir_all(root); 1528 } 1529 1530 #[test] 1531 fn public_package_inventory_requires_every_local_package() { 1532 let root = test_root("public_package_inventory"); 1533 fs::write(root.join("Cargo.toml"), complete_workspace_manifest("")) 1534 .expect("write workspace manifest"); 1535 let error = validate_public_package_metadata(&root, &architecture()) 1536 .expect_err("missing local public package must fail"); 1537 assert!(error.contains("workspace public package inventory is missing: radroots")); 1538 let _ = fs::remove_dir_all(root); 1539 } 1540 1541 #[test] 1542 fn public_dependencies_require_path_and_exact_version() { 1543 let root = test_root("public_dependency_version"); 1544 fs::create_dir_all(root.join("crates/radroots")).expect("create public package"); 1545 fs::create_dir_all(root.join("crates/dependency")).expect("create dependency package"); 1546 fs::write( 1547 root.join("Cargo.toml"), 1548 format!( 1549 "{}\n[workspace.dependencies]\nradroots_core = {{ package = \"radroots_core\", path = \"crates/dependency\", version = \"=0.1.0\" }}\n", 1550 complete_workspace_manifest("\"crates/radroots\"") 1551 ), 1552 ) 1553 .expect("write workspace manifest"); 1554 fs::write( 1555 root.join("crates/radroots/Cargo.toml"), 1556 "[package]\nname = \"radroots\"\nversion = \"0.1.0\"\n\n[dependencies]\nradroots_core = { workspace = true }\n", 1557 ) 1558 .expect("write public manifest"); 1559 fs::write( 1560 root.join("crates/dependency/Cargo.toml"), 1561 "[package]\nname = \"radroots_core\"\nversion = \"0.1.0\"\n", 1562 ) 1563 .expect("write dependency manifest"); 1564 let mut architecture = architecture(); 1565 architecture.package.push(ArchitecturePackage { 1566 name: "radroots_core".to_owned(), 1567 }); 1568 architecture 1569 .repositories 1570 .get_mut("sdk") 1571 .expect("sdk repository") 1572 .packages 1573 .push("radroots_core".to_owned()); 1574 validate_public_dependency_versions(&root, &architecture) 1575 .expect("path plus exact version public dependency"); 1576 1577 let workspace_path = root.join("Cargo.toml"); 1578 let workspace = fs::read_to_string(&workspace_path).expect("read workspace manifest"); 1579 fs::write( 1580 &workspace_path, 1581 workspace.replace(", version = \"=0.1.0\"", ""), 1582 ) 1583 .expect("write path-only dependency"); 1584 let error = validate_public_dependency_versions(&root, &architecture) 1585 .expect_err("path-only public dependency must fail"); 1586 assert!(error.contains("must declare path and exact version =0.1.0")); 1587 let _ = fs::remove_dir_all(root); 1588 } 1589 1590 #[test] 1591 fn production_dependencies_reject_sibling_paths() { 1592 let root = test_root("production_sibling_path"); 1593 let sibling = root.with_extension("sibling"); 1594 fs::create_dir_all(root.join("crates/radroots")).expect("create public package"); 1595 fs::create_dir_all(root.join("crates/dependency")).expect("create local dependency"); 1596 fs::create_dir_all(&sibling).expect("create sibling dependency"); 1597 fs::write( 1598 root.join("Cargo.toml"), 1599 complete_workspace_manifest("\"crates/radroots\""), 1600 ) 1601 .expect("write workspace manifest"); 1602 let sibling_path = sibling.to_string_lossy(); 1603 fs::write( 1604 root.join("crates/radroots/Cargo.toml"), 1605 format!( 1606 "[package]\nname = \"radroots\"\nversion = \"0.1.0\"\n\n[dependencies]\nprobe = {{ path = \"{sibling_path}\" }}\n" 1607 ), 1608 ) 1609 .expect("write sibling dependency"); 1610 let error = validate_no_production_sibling_paths(&root) 1611 .expect_err("sibling production path must fail"); 1612 assert!(error.contains("escapes the repository")); 1613 1614 fs::write( 1615 root.join("crates/radroots/Cargo.toml"), 1616 "[package]\nname = \"radroots\"\nversion = \"0.1.0\"\n\n[dependencies]\nprobe = { path = \"../dependency\" }\n", 1617 ) 1618 .expect("write local dependency"); 1619 fs::create_dir_all(root.join(".cargo")).expect("create cargo config directory"); 1620 fs::write( 1621 root.join(".cargo/config.toml"), 1622 format!("[patch.crates-io]\nprobe = {{ path = \"{sibling_path}\" }}\n"), 1623 ) 1624 .expect("write development override"); 1625 validate_no_production_sibling_paths(&root).expect("in-repository path"); 1626 let _ = fs::remove_dir_all(root); 1627 let _ = fs::remove_dir_all(sibling); 1628 } 1629 }