diff --git a/Cargo.lock b/Cargo.lock index 47b48dc74d8..12aae028775 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -22562,6 +22562,8 @@ dependencies = [ "serde_json", "serde_yaml", "strum 0.28.0", + "tempfile", + "thiserror 2.0.17", "tokio", "toml 0.8.23", "toml_edit 0.22.27", diff --git a/tooling/xtask/Cargo.toml b/tooling/xtask/Cargo.toml index 5b6b5ecabc0..591ef5c0abe 100644 --- a/tooling/xtask/Cargo.toml +++ b/tooling/xtask/Cargo.toml @@ -26,7 +26,11 @@ serde.workspace = true serde_json.workspace = true serde_yaml = "0.9.34" strum.workspace = true +thiserror.workspace = true tokio = { workspace = true, features = ["rt", "rt-multi-thread"] } toml.workspace = true toml_edit.workspace = true url.workspace = true + +[dev-dependencies] +tempfile.workspace = true diff --git a/tooling/xtask/src/tasks/gpui.rs b/tooling/xtask/src/tasks/gpui.rs index 76bd52803bf..5ace1481541 100644 --- a/tooling/xtask/src/tasks/gpui.rs +++ b/tooling/xtask/src/tasks/gpui.rs @@ -2,6 +2,7 @@ pub mod crate_graph; pub mod publish_plan; +pub mod validation; use std::io::{self, Write}; use std::process::{Command, Output, Stdio}; @@ -15,7 +16,7 @@ use crate::tasks::workflows::GitSha; #[derive(Subcommand)] pub enum GpuiCommand { /// Print the publish plan in dependency-first order - List(GpuiArgs), + Plan(GpuiArgs), /// Show the dependency paths that put a crate in the publish list Why { /// Original Cargo package name @@ -45,8 +46,9 @@ struct PublishGpuiArgs { pub fn run_gpui(command: GpuiCommand) -> Result<()> { let graph = crate_graph::load_workspace_graph()?; match command { - GpuiCommand::List(args) => { + GpuiCommand::Plan(args) => { let plan = publish_plan::build_publish_plan(&graph)?; + validation::validate(&plan)?; println!( "GPUI publish plan ({} crates, dependencies first):", plan.len() @@ -408,23 +410,23 @@ mod tests { use super::*; #[test] - fn gpui_list_accepts_an_explicit_workspace_sha() -> Result<()> { + fn gpui_plan_accepts_an_explicit_workspace_sha() -> Result<()> { let sha = "0123456789abcdef0123456789abcdef01234567"; - let args = crate::Args::try_parse_from(["xtask", "gpui", "list", "--sha", sha])?; - let crate::CliCommand::Gpui(GpuiCommand::List(args)) = args.command else { - bail!("expected the GPUI list command"); + let args = crate::Args::try_parse_from(["xtask", "gpui", "plan", "--sha", sha])?; + let crate::CliCommand::Gpui(GpuiCommand::Plan(args)) = args.command else { + bail!("expected the GPUI plan command"); }; assert_eq!(args.sha.as_ref(), sha); Ok(()) } #[test] - fn gpui_list_requires_a_full_workspace_sha() { + fn gpui_plan_requires_a_full_workspace_sha() { assert!(crate::Args::try_parse_from(["xtask", "gpui"]).is_err()); - assert!(crate::Args::try_parse_from(["xtask", "gpui", "list"]).is_err()); + assert!(crate::Args::try_parse_from(["xtask", "gpui", "plan"]).is_err()); for sha in ["HEAD", "abc", "g123456789abcdef0123456789abcdef01234567"] { assert!( - crate::Args::try_parse_from(["xtask", "gpui", "list", "--sha", sha]).is_err(), + crate::Args::try_parse_from(["xtask", "gpui", "plan", "--sha", sha]).is_err(), "{sha}" ); } diff --git a/tooling/xtask/src/tasks/gpui/validation.rs b/tooling/xtask/src/tasks/gpui/validation.rs new file mode 100644 index 00000000000..b25a772ebe5 --- /dev/null +++ b/tooling/xtask/src/tasks/gpui/validation.rs @@ -0,0 +1,112 @@ +//! Rules that the crates selected for a GPUI release have to satisfy. +//! +//! To add a rule, implement [`Rule`] in a submodule and list it in [`RULES`]. + +mod apache_licensed; +mod unique_publish_names; + +use std::fmt; + +use thiserror::Error; + +use crate::tasks::gpui::publish_plan::PublishPlanEntry; + +const RULES: &[&dyn Rule] = &[ + &apache_licensed::ApacheLicensed, + &unique_publish_names::UniquePublishNames, +]; + +/// A check over the crates selected for a GPUI release. +pub(crate) trait Rule { + /// What the rule guarantees, used to label the violations it reports. + fn name(&self) -> &'static str; + + /// Returns one violation per crate that breaks the rule. + fn check(&self, plan: &[PublishPlanEntry<'_>]) -> Vec; +} + +/// Why a crate does not satisfy a [`Rule`]. +pub(crate) type Violation = Box; + +/// Runs every rule and reports all violations at once, so that a single run +/// surfaces everything that needs fixing. +pub fn validate(plan: &[PublishPlanEntry<'_>]) -> Result<(), ValidationError> { + validate_with(RULES, plan) +} + +fn validate_with( + rules: &[&dyn Rule], + plan: &[PublishPlanEntry<'_>], +) -> Result<(), ValidationError> { + let violations = rules + .iter() + .flat_map(|rule| { + rule.check(plan) + .into_iter() + .map(|violation| (rule.name(), violation)) + }) + .collect::>(); + + if violations.is_empty() { + return Ok(()); + } + Err(ValidationError { violations }) +} + +#[derive(Debug, Error)] +pub struct ValidationError { + violations: Vec<(&'static str, Violation)>, +} + +impl fmt::Display for ValidationError { + fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { + write!( + formatter, + "found {count} violation(s) in the GPUI crate graph:", + count = self.violations.len() + )?; + for (rule, violation) in &self.violations { + write!(formatter, "\n [{rule}] {violation}")?; + } + Ok(()) + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[derive(Debug, Error)] + #[error("{0} is held together with tape")] + struct Ramshackle(&'static str); + + struct Failing; + + impl Rule for Failing { + fn name(&self) -> &'static str { + "crates are structurally sound" + } + + fn check(&self, _: &[PublishPlanEntry<'_>]) -> Vec { + vec![ + Violation::from(Ramshackle("util")), + Violation::from(Ramshackle("gpui")), + ] + } + } + + #[test] + fn labels_each_violation_with_the_rule_that_found_it() { + assert!(validate_with(&[], &[]).is_ok()); + + let error = + validate_with(&[&Failing], &[]).expect_err("expected the failing rule to be reported"); + assert_eq!( + error.to_string(), + indoc::indoc! {" + found 2 violation(s) in the GPUI crate graph: + [crates are structurally sound] util is held together with tape + [crates are structurally sound] gpui is held together with tape"} + ); + } +} diff --git a/tooling/xtask/src/tasks/gpui/validation/apache_licensed.rs b/tooling/xtask/src/tasks/gpui/validation/apache_licensed.rs new file mode 100644 index 00000000000..73cae379096 --- /dev/null +++ b/tooling/xtask/src/tasks/gpui/validation/apache_licensed.rs @@ -0,0 +1,155 @@ +use std::fs; +use std::path::Path; + +use thiserror::Error; + +use super::{Rule, Violation}; +use crate::tasks::gpui::publish_plan::PublishPlanEntry; + +const APACHE_LICENSE: &str = "Apache-2.0"; +const APACHE_LICENSE_FILE: &str = "LICENSE-APACHE"; + +/// License files that contradict [`APACHE_LICENSE_FILE`] when present alongside it. +const CONFLICTING_LICENSE_FILES: &[&str] = &["LICENSE-GPL", "LICENSE-AGPL"]; + +pub struct ApacheLicensed; + +impl Rule for ApacheLicensed { + fn name(&self) -> &'static str { + "workspace crates are Apache-2.0 licensed" + } + + fn check(&self, plan: &[PublishPlanEntry<'_>]) -> Vec { + plan.iter() + .filter(|entry| entry.package.in_workspace()) + .filter_map(|entry| { + let directory = entry.package.manifest_path().as_std_path().parent()?; + let violation = + license_violation(entry.package.name(), entry.package.license(), directory)?; + Some(Violation::from(violation)) + }) + .collect() + } +} + +#[derive(Debug, Error)] +enum LicenseViolation { + #[error("{crate_name}: expected `license = \"{APACHE_LICENSE}\"`, found `{license}`")] + WrongLicense { crate_name: String, license: String }, + #[error("{crate_name}: missing a `license` field, expected `{APACHE_LICENSE}`")] + MissingLicense { crate_name: String }, + #[error("{crate_name}: `{APACHE_LICENSE_FILE}` must be a symlink to the repository license")] + UnlinkedLicenseFile { crate_name: String }, + #[error("{crate_name}: `{conflicting}` contradicts `license = \"{APACHE_LICENSE}\"`")] + ConflictingLicenseFile { + crate_name: String, + conflicting: &'static str, + }, +} + +fn license_violation( + crate_name: &str, + license: Option<&str>, + directory: &Path, +) -> Option { + let crate_name = crate_name.to_owned(); + match license { + Some(APACHE_LICENSE) => {} + Some(license) => { + return Some(LicenseViolation::WrongLicense { + crate_name, + license: license.to_owned(), + }); + } + None => return Some(LicenseViolation::MissingLicense { crate_name }), + } + + if !is_symlinked_license(&directory.join(APACHE_LICENSE_FILE)) { + return Some(LicenseViolation::UnlinkedLicenseFile { crate_name }); + } + + let conflicting = CONFLICTING_LICENSE_FILES + .iter() + .copied() + .find(|license_file| directory.join(license_file).exists())?; + Some(LicenseViolation::ConflictingLicenseFile { + crate_name, + conflicting, + }) +} + +fn is_symlinked_license(license_file: &Path) -> bool { + fs::symlink_metadata(license_file).is_ok_and(|metadata| metadata.is_symlink()) + && fs::canonicalize(license_file) + .is_ok_and(|target| target.file_name() == Some(APACHE_LICENSE_FILE.as_ref())) +} + +#[cfg(all(test, unix))] +mod tests { + use anyhow::Result; + + use super::*; + + #[cfg(unix)] + #[test] + fn requires_an_apache_license_field_and_symlink() -> Result<()> { + use std::os::unix::fs::symlink; + + let root = tempfile::tempdir()?; + let root = root.path(); + fs::write(root.join(APACHE_LICENSE_FILE), "Apache License")?; + fs::write(root.join("LICENSE-GPL"), "GPL")?; + + let crate_directory = |name: &str, license_link: Option<&str>| -> Result<_> { + let directory = root.join(name); + fs::create_dir(&directory)?; + if let Some(license_link) = license_link { + symlink(license_link, directory.join(APACHE_LICENSE_FILE))?; + } + Ok(directory) + }; + + let linked = crate_directory("linked", Some("../LICENSE-APACHE"))?; + assert!(license_violation("linked", Some(APACHE_LICENSE), &linked).is_none()); + assert!(matches!( + license_violation("linked", Some("MIT"), &linked), + Some(LicenseViolation::WrongLicense { license, .. }) if license == "MIT" + )); + assert!(matches!( + license_violation("linked", None, &linked), + Some(LicenseViolation::MissingLicense { .. }) + )); + + for (name, license_link) in [ + ("missing", None), + ("broken", Some("../nowhere")), + ("mismatched", Some("../LICENSE-GPL")), + ] { + let directory = crate_directory(name, license_link)?; + assert!( + matches!( + license_violation(name, Some(APACHE_LICENSE), &directory), + Some(LicenseViolation::UnlinkedLicenseFile { .. }) + ), + "{name}" + ); + } + + let copied = crate_directory("copied", None)?; + fs::write(copied.join(APACHE_LICENSE_FILE), "Apache License")?; + assert!(matches!( + license_violation("copied", Some(APACHE_LICENSE), &copied), + Some(LicenseViolation::UnlinkedLicenseFile { .. }) + )); + + fs::write(linked.join("LICENSE-GPL"), "GPL")?; + assert!(matches!( + license_violation("linked", Some(APACHE_LICENSE), &linked), + Some(LicenseViolation::ConflictingLicenseFile { + conflicting: "LICENSE-GPL", + .. + }) + )); + Ok(()) + } +} diff --git a/tooling/xtask/src/tasks/gpui/validation/unique_publish_names.rs b/tooling/xtask/src/tasks/gpui/validation/unique_publish_names.rs new file mode 100644 index 00000000000..f94f2ee146c --- /dev/null +++ b/tooling/xtask/src/tasks/gpui/validation/unique_publish_names.rs @@ -0,0 +1,89 @@ +use std::collections::BTreeMap; + +use thiserror::Error; + +use super::{Rule, Violation}; +use crate::tasks::gpui::publish_plan::PublishPlanEntry; + +pub struct UniquePublishNames; + +impl Rule for UniquePublishNames { + fn name(&self) -> &'static str { + "published crate names are unique" + } + + fn check(&self, plan: &[PublishPlanEntry<'_>]) -> Vec { + duplicate_publish_names(plan.iter().map(|entry| { + ( + entry.repository.target_name(entry.package.name()), + entry.package.name(), + ) + })) + .into_iter() + .map(Violation::from) + .collect() + } +} + +#[derive(Debug, Error)] +#[error("`{crate_name}` and `{other}` would both be published as `{published_name}`")] +struct DuplicatePublishName { + crate_name: String, + other: String, + published_name: String, +} + +fn duplicate_publish_names<'a>( + published: impl IntoIterator, +) -> Vec { + let mut crates_by_published_name = BTreeMap::>::new(); + for (published_name, crate_name) in published { + crates_by_published_name + .entry(published_name) + .or_default() + .push(crate_name); + } + + let mut duplicates = Vec::new(); + for (published_name, mut crates) in crates_by_published_name { + crates.sort_unstable(); + for &[crate_name, other] in crates.array_windows() { + duplicates.push(DuplicatePublishName { + crate_name: crate_name.to_owned(), + other: other.to_owned(), + published_name: published_name.clone(), + }); + } + } + duplicates +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn reports_crates_that_would_be_published_under_the_same_name() { + let duplicates = duplicate_publish_names([ + ("gpui_util".to_owned(), "util"), + ("gpui_collections".to_owned(), "collections"), + ("gpui_util".to_owned(), "gpui_util"), + ("zed-fork".to_owned(), "fork"), + ]); + assert_eq!( + duplicates + .iter() + .map(ToString::to_string) + .collect::>(), + ["`gpui_util` and `util` would both be published as `gpui_util`"] + ); + + assert!( + duplicate_publish_names([ + ("gpui_util".to_owned(), "util"), + ("gpui_collections".to_owned(), "collections"), + ]) + .is_empty() + ); + } +}