Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.
xtask: Add more helpers for querying information on GPUI crates (#64333)
Finn Eversfcee4a5a4cf6
diff --git a/tooling/xtask/src/main.rs b/tooling/xtask/src/main.rsindex e763c7b1cb4..9594fc6b65c 100644--- a/tooling/xtask/src/main.rs+++ b/tooling/xtask/src/main.rs@@ -19,8 +19,9 @@ enum CliCommand {Licenses(tasks::licenses::LicensesArgs),/// Checks that packages conform to a set of standards.PackageConformity(tasks::package_conformity::PackageConformityArgs),- /// Prints the GPUI crate graph in dependency-first order.- Gpui,+ /// Inspect the GPUI publish plan and its dependencies.+ #[command(subcommand)]+ Gpui(tasks::gpui::GpuiCommand),/// Runs the Linux Bubblewrap sandboxing NixOS VM tests.SandboxTests(tasks::sandbox_tests::SandboxTestsArgs),/// Runs the Windows WSL Bubblewrap sandbox behavior tests.@@ -43,7 +44,7 @@ fn main() -> Result<()> {CliCommand::PackageConformity(args) => {tasks::package_conformity::run_package_conformity(args)}- CliCommand::Gpui => tasks::gpui::run_gpui(),+ CliCommand::Gpui(args) => tasks::gpui::run_gpui(args),CliCommand::SandboxTests(args) => tasks::sandbox_tests::run_sandbox_tests(args),CliCommand::WslSandboxTests(args) => tasks::wsl_sandbox_tests::run_wsl_sandbox_tests(args),CliCommand::SetupWebrtc(args) => tasks::setup_webrtc::run_setup_webrtc(args),diff --git a/tooling/xtask/src/tasks/gpui.rs b/tooling/xtask/src/tasks/gpui.rsindex 483c9153698..76bd52803bf 100644--- a/tooling/xtask/src/tasks/gpui.rs+++ b/tooling/xtask/src/tasks/gpui.rs@@ -1,16 +1,38 @@#![allow(clippy::disallowed_methods, reason = "tooling is exempt")]pub mod crate_graph;+pub mod publish_plan;use std::io::{self, Write};use std::process::{Command, Output, Stdio};use anyhow::{Context as _, Result, bail};-use clap::Parser;+use clap::{Parser, Subcommand};use guppy::graph::DependencyDirection;+use crate::tasks::workflows::GitSha;++#[derive(Subcommand)]+pub enum GpuiCommand {+ /// Print the publish plan in dependency-first order+ List(GpuiArgs),+ /// Show the dependency paths that put a crate in the publish list+ Why {+ /// Original Cargo package name+ crate_name: String,+ },+}+#[derive(Parser)]pub struct GpuiArgs {+ /// Full commit SHA to use when checking out workspace crates+ #[arg(long)]+ sha: GitSha,+}++#[derive(Parser)]+#[allow(unused)]+struct PublishGpuiArgs {/// Perform a dry-run and wait for user confirmation before each publish#[arg(long)]dry_run: bool,@@ -20,18 +42,40 @@ pub struct GpuiArgs {skip_to: Option<String>,}-pub fn run_gpui() -> Result<()> {+pub fn run_gpui(command: GpuiCommand) -> Result<()> {let graph = crate_graph::load_workspace_graph()?;- let crates = crate_graph::gpui_crates(&graph)?;-- println!("GPUI crate graph ({} crates):", crates.len());- for package in crates.packages(DependencyDirection::Reverse) {- println!("{} ({})", package.name(), package.source());- for link in package.direct_links().filter(|link| !link.dev_only()) {- match crates.contains(link.to().id()) {- Ok(true) => println!(" -> {}", link.to().name()),- Ok(false) => {}- Err(e) => eprintln!(" error checking dependency {}: {}", link.to().name(), e),+ match command {+ GpuiCommand::List(args) => {+ let plan = publish_plan::build_publish_plan(&graph)?;+ println!(+ "GPUI publish plan ({} crates, dependencies first):",+ plan.len()+ );+ for entry in &plan {+ let package = entry.repository.publish_info(entry.package.name());+ println!(+ "{} -> {} ({})",+ package.original_name,+ package.repository.target_name(package.original_name),+ package.repository.display(&args)+ );+ }+ }+ GpuiCommand::Why { crate_name } => {+ let explanation = crate_graph::explain_crate(&graph, &crate_name)?;+ println!(+ "Why `{crate_name}` is in the GPUI publish list (A -> B means A depends on B):"+ );+ for package in explanation.packages(DependencyDirection::Forward) {+ if crate_graph::is_gpui_root(package) {+ println!(" {} is a GPUI workspace root", package.name());+ }+ }+ for link in explanation+ .links(DependencyDirection::Forward)+ .filter(|link| !link.dev_only())+ {+ println!(" {} -> {}", link.from().name(), link.to().name());}}}@@ -39,7 +83,7 @@ pub fn run_gpui() -> Result<()> {}#[allow(unused, reason = "retained while GPUI releases are reworked")]-fn run_publish_gpui(args: GpuiArgs) -> Result<()> {+fn run_publish_gpui(args: PublishGpuiArgs) -> Result<()> {println!("Starting GPUI publish process{}...",if args.dry_run { " (with dry-run)" } else { "" }@@ -363,6 +407,29 @@ mod tests {use super::*;+ #[test]+ fn gpui_list_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");+ };+ assert_eq!(args.sha.as_ref(), sha);+ Ok(())+ }++ #[test]+ fn gpui_list_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());+ for sha in ["HEAD", "abc", "g123456789abcdef0123456789abcdef01234567"] {+ assert!(+ crate::Args::try_parse_from(["xtask", "gpui", "list", "--sha", sha]).is_err(),+ "{sha}"+ );+ }+ }+#[test]fn test_update_dependency_version_in_toml() {let input = indoc! {r#"diff --git a/tooling/xtask/src/tasks/gpui/crate_graph.rs b/tooling/xtask/src/tasks/gpui/crate_graph.rsindex a2137677f74..289ac915322 100644--- a/tooling/xtask/src/tasks/gpui/crate_graph.rs+++ b/tooling/xtask/src/tasks/gpui/crate_graph.rs@@ -1,7 +1,10 @@use anyhow::{Context as _, Result, ensure};use guppy::{MetadataCommand,- graph::{DependencyDirection, ExternalSource, PackageGraph, PackageSet, PackageSource},+ graph::{+ DependencyDirection, ExternalSource, PackageGraph, PackageMetadata, PackageSet,+ PackageSource,+ },};use url::Url;@@ -11,12 +14,16 @@ pub fn load_workspace_graph() -> Result<PackageGraph> {.context("failed to load the workspace crate graph")}+pub fn is_gpui_root(package: PackageMetadata<'_>) -> bool {+ package.in_workspace() && package.name().starts_with("gpui")+}+/// Returns all GPUI crates in the current workspacepub fn gpui_crates(graph: &PackageGraph) -> Result<PackageSet<'_>> {let roots = graph.workspace().iter_by_name()- .filter(|(name, _)| name.starts_with("gpui"))+ .filter(|(_, package)| is_gpui_root(*package)).map(|(_, package)| package.id()).collect::<Vec<_>>();ensure!(!roots.is_empty(), "no GPUI crates found in the workspace");@@ -34,6 +41,29 @@ pub fn gpui_crates(graph: &PackageGraph) -> Result<PackageSet<'_>> {)}+pub fn explain_crate<'graph>(+ graph: &'graph PackageGraph,+ name: &str,+) -> Result<PackageSet<'graph>> {+ let crates = gpui_crates(graph)?;+ let selected = crates.filter(DependencyDirection::Forward, |package| {+ package.name() == name+ });+ ensure!(+ !selected.is_empty(),+ "crate `{name}` is not in the GPUI publish list"+ );++ let dependents = selected+ .to_package_query(DependencyDirection::Reverse)+ .resolve_with_fn(|_, link| !link.dev_only());++ let dependencies = crates+ .to_package_query(DependencyDirection::Forward)+ .resolve_with_fn(|_, link| !link.dev_only());+ Ok(dependents.intersection(&dependencies))+}+fn is_zed_fork(source: PackageSource<'_>) -> bool {let Some(ExternalSource::Git { repository, .. }) = source.parse_external() else {return false;@@ -219,7 +249,9 @@ mod tests {},FixturePackage {name: "fork",- origin: Git("git+https://github.com/zed-industries/fork?rev=abc#abc"),+ origin: Git(+ "git+https://github.com/zed-industries/fork?rev=abc#0123456789abcdef0123456789abcdef01234567",+ ),dependencies: &[FixtureDependency {to: "collections",kind: Normal(Required),@@ -283,6 +315,83 @@ mod tests {assert!(crates.links(DependencyDirection::Reverse).all(|link| {names.contains(&link.from().name()) && names.contains(&link.to().name())}));++ let explanation = explain_crate(&graph, "fork")?;+ assert_eq!(+ explanation+ .packages(DependencyDirection::Forward)+ .map(|package| package.name())+ .collect::<Vec<_>>(),+ ["gpui_platform", "gpui", "registry", "fork"],+ );+ assert_eq!(+ explanation+ .links(DependencyDirection::Forward)+ .filter(|link| !link.dev_only())+ .map(|link| (link.from().name(), link.to().name()))+ .collect::<std::collections::BTreeSet<_>>(),+ [+ ("gpui_platform", "gpui"),+ ("gpui", "registry"),+ ("registry", "fork")+ ]+ .into_iter()+ .collect(),+ );+ let root = explain_crate(&graph, "gpui_platform")?;+ assert_eq!(root.len(), 1);+ assert!(+ root.packages(DependencyDirection::Forward)+ .all(is_gpui_root)+ );+ for excluded in ["zed", "test_helper", "registry", "missing"] {+ assert!(explain_crate(&graph, excluded).is_err(), "{excluded}");+ }++ use super::super::publish_plan::{Repository, build_publish_plan};++ let plan = build_publish_plan(&graph)?;+ assert_eq!(+ plan.iter()+ .map(|entry| entry.package.name())+ .collect::<Vec<_>>(),+ names,+ );+ assert_eq!(+ plan.iter()+ .map(|entry| entry.package.id())+ .collect::<Vec<_>>(),+ crates+ .package_ids(DependencyDirection::Reverse)+ .collect::<Vec<_>>(),+ );+ for entry in &plan {+ let package = entry.repository.publish_info(entry.package.name());+ match package.repository {+ Repository::Workspace => {+ assert_ne!(package.original_name, "fork");+ if package.original_name == "gpui_macros" {+ assert_eq!(+ package.repository.target_name(package.original_name),+ "gpui-macros"+ );+ }+ }+ Repository::Git(repository) => {+ assert_eq!(package.original_name, "fork");+ assert_eq!(+ package.repository.target_name(package.original_name),+ "zed-fork"+ );+ assert_eq!(repository.owner, "zed-industries");+ assert_eq!(repository.repo, "fork");+ assert_eq!(+ repository.revision.as_ref(),+ "0123456789abcdef0123456789abcdef01234567"+ );+ }+ }+ }Ok(())}diff --git a/tooling/xtask/src/tasks/gpui/publish_plan.rs b/tooling/xtask/src/tasks/gpui/publish_plan.rsnew file mode 100644index 00000000000..67b0595f746--- /dev/null+++ b/tooling/xtask/src/tasks/gpui/publish_plan.rs@@ -0,0 +1,286 @@+use std::fmt;++use anyhow::{Context as _, Result, bail, ensure};+use guppy::graph::{DependencyDirection, ExternalSource, PackageGraph, PackageMetadata};+use url::Url;++use crate::tasks::{gpui::GpuiArgs, workflows::GitSha};++pub enum Repository {+ Workspace,+ Git(GitRepository),+}++pub struct GitRepository {+ pub owner: String,+ pub repo: String,+ pub revision: GitSha,+}++impl GitRepository {+ fn new(repository: &str, revision: &str) -> Result<Self> {+ let url = Url::parse(repository).context("invalid Git repository URL")?;+ ensure!(+ url.host_str()+ .is_some_and(|host| host.eq_ignore_ascii_case("github.com")),+ "expected a GitHub repository, got {repository}"+ );+ let (owner, repo) = url+ .path()+ .trim_matches('/')+ .split_once('/')+ .context("repository URL must contain an owner and repository name")?;+ let repo = repo.strip_suffix(".git").unwrap_or(repo);+ ensure!(+ !owner.is_empty() && !repo.is_empty() && !repo.contains('/'),+ "expected an owner/repo path, got {repository}"+ );+ let revision = revision+ .parse::<GitSha>()+ .map_err(anyhow::Error::msg)+ .with_context(|| format!("invalid resolved revision for {repository}"))?;++ Ok(Self {+ owner: owner.to_owned(),+ repo: repo.to_owned(),+ revision,+ })+ }+}++impl Repository {+ pub fn fork(repository: &str, revision: &str) -> Result<Self> {+ Ok(Self::Git(GitRepository::new(repository, revision)?))+ }++ pub fn publish_info<'a>(&'a self, name: &'a str) -> CratePublishInfo<'a> {+ CratePublishInfo {+ repository: self,+ original_name: name,+ }+ }++ pub fn name(&self) -> String {+ match self {+ Self::Workspace => "zed-industries/zed".to_owned(),+ Self::Git(repository) => format!(+ "{owner}/{repo}",+ owner = repository.owner,+ repo = repository.repo+ ),+ }+ }++ pub fn target_name(&self, name: &str) -> String {+ match self {+ Self::Workspace => {+ if name == "gpui_macros" {+ "gpui-macros".to_owned()+ } else if name == "gpui" || name.starts_with("gpui_") {+ name.to_owned()+ } else {+ format!("gpui_{name}")+ }+ }+ Self::Git(_) => {+ if name.starts_with("zed-") {+ name.to_owned()+ } else {+ format!("zed-{name}")+ }+ }+ }+ }++ pub fn display<'a>(&'a self, args: &'a GpuiArgs) -> impl fmt::Display + 'a {+ let revision = match self {+ Self::Workspace => &args.sha,+ Self::Git(repository) => &repository.revision,+ };+ fmt::from_fn(move |formatter| {+ write!(+ formatter,+ "{name}@{revision}",+ name = self.name(),+ revision = revision.as_ref()+ )+ })+ }+}++pub struct CratePublishInfo<'a> {+ pub repository: &'a Repository,+ pub original_name: &'a str,+}++pub struct PublishPlanEntry<'graph> {+ pub package: PackageMetadata<'graph>,+ pub repository: Repository,+}++pub fn build_publish_plan(graph: &PackageGraph) -> Result<Vec<PublishPlanEntry<'_>>> {+ let packages = super::crate_graph::gpui_crates(graph)?;+ packages+ .packages(DependencyDirection::Reverse)+ .map(|package| {+ let repository = if package.in_workspace() {+ Repository::Workspace+ } else if let Some(ExternalSource::Git {+ repository,+ resolved,+ ..+ }) = package.source().parse_external()+ {+ Repository::fork(repository, resolved)?+ } else {+ bail!(+ "unexpected source for GPUI crate {}: {}",+ package.name(),+ package.source()+ );+ };+ Ok(PublishPlanEntry {+ package,+ repository,+ })+ })+ .collect()+}++#[cfg(test)]+mod tests {+ use super::*;++ const REVISION: &str = "0123456789abcdef0123456789abcdef01234567";+ const WORKSPACE_REVISION: &str = "fedcba9876543210fedcba9876543210fedcba98";++ #[test]+ fn publishing_info_borrows_its_repository_and_crate_name() {+ let repository = Repository::Workspace;+ let name = String::from("collections");+ let package = repository.publish_info(&name);++ assert!(std::ptr::eq(package.repository, &repository));+ assert!(std::ptr::eq(package.original_name, name.as_str()));+ }++ #[test]+ fn workspace_names_follow_existing_publish_names() {+ let repository = Repository::Workspace;+ for (original, target) in [+ ("collections", "gpui_collections"),+ ("perf", "gpui_perf"),+ ("util_macros", "gpui_util_macros"),+ ("util", "gpui_util"),+ ("gpui_macros", "gpui-macros"),+ ("http_client", "gpui_http_client"),+ ("derive_refineable", "gpui_derive_refineable"),+ ("refineable", "gpui_refineable"),+ ("semantic_version", "gpui_semantic_version"),+ ("sum_tree", "gpui_sum_tree"),+ ("media", "gpui_media"),+ ("gpui", "gpui"),+ ("gpui_platform", "gpui_platform"),+ ("gpui-macros", "gpui_gpui-macros"),+ ("scheduler", "gpui_scheduler"),+ ] {+ let package = repository.publish_info(original);+ assert_eq!(package.original_name, original);+ assert_eq!(+ package.repository.target_name(package.original_name),+ target+ );+ assert!(matches!(package.repository, Repository::Workspace));+ }+ }++ #[test]+ fn fork_names_have_a_single_zed_prefix() -> Result<()> {+ let repository = Repository::fork("https://github.com/zed-industries/fork", REVISION)?;+ for (original, target) in [+ ("calloop", "zed-calloop"),+ ("wasm_thread", "zed-wasm_thread"),+ ("zed-font-kit", "zed-font-kit"),+ ("zed-scap", "zed-scap"),+ ] {+ let package = repository.publish_info(original);+ assert_eq!(package.original_name, original);+ assert_eq!(+ package.repository.target_name(package.original_name),+ target+ );+ }+ Ok(())+ }++ #[test]+ fn workspace_repository_uses_the_argument_sha() -> Result<()> {+ let repository = Repository::Workspace;+ let package = repository.publish_info("gpui");+ assert_eq!(package.repository.name(), "zed-industries/zed");+ for revision in [REVISION, WORKSPACE_REVISION] {+ let args = GpuiArgs {+ sha: revision.parse().map_err(anyhow::Error::msg)?,+ };+ assert_eq!(+ package.repository.display(&args).to_string(),+ format!("zed-industries/zed@{revision}")+ );+ }+ Ok(())+ }++ #[test]+ fn git_repositories_have_checkout_coordinates() -> Result<()> {+ let args = GpuiArgs {+ sha: WORKSPACE_REVISION.parse().map_err(anyhow::Error::msg)?,+ };+ for url in [+ "https://github.com/zed-industries/fork",+ "https://github.com/zed-industries/fork.git",+ "https://github.com/zed-industries/fork.git/",+ "ssh://[email protected]/zed-industries/fork.git",+ ] {+ let repository = Repository::fork(url, REVISION)?;+ let package = repository.publish_info("fork");+ assert_eq!(package.repository.name(), "zed-industries/fork");+ assert_eq!(+ package.repository.display(&args).to_string(),+ format!("zed-industries/fork@{REVISION}")+ );+ let Repository::Git(repository) = package.repository else {+ bail!("expected a Git repository");+ };+ assert_eq!(repository.owner, "zed-industries");+ assert_eq!(repository.repo, "fork");+ assert_eq!(repository.revision.as_ref(), REVISION);+ }+ Ok(())+ }++ #[test]+ fn git_repositories_require_an_owner_repo_and_full_sha() {+ for url in [+ "not a URL",+ "https://example.com/zed-industries/fork",+ "https://github.com/zed-industries",+ "https://github.com/zed-industries/",+ "https://github.com/zed-industries/.git",+ "https://github.com/zed-industries/fork/tree/main",+ ] {+ assert!(Repository::fork(url, REVISION).is_err(), "{url}");+ }+ for revision in [+ "",+ "main",+ "v1.0",+ "abc",+ "g123456789abcdef0123456789abcdef01234567",+ ] {+ assert!(+ Repository::fork("https://github.com/zed-industries/fork", revision).is_err(),+ "{revision}"+ );+ }+ }+}diff --git a/tooling/xtask/src/tasks/workflows.rs b/tooling/xtask/src/tasks/workflows.rsindex 86a2a952205..8107cb45710 100644--- a/tooling/xtask/src/tasks/workflows.rs+++ b/tooling/xtask/src/tasks/workflows.rs@@ -41,44 +41,47 @@ impl AsRef<str> for GitSha {}}+impl std::str::FromStr for GitSha {+ type Err = String;++ fn from_str(value: &str) -> Result<Self, Self::Err> {+ const GIT_SHA_LENGTH: usize = 40;+ if value.len() != GIT_SHA_LENGTH {+ return Err(format!(+ "Git SHA has wrong length! \+ Only SHAs with a full length of {GIT_SHA_LENGTH} are supported, found {len} characters.",+ len = value.len()+ ));+ }+ if !value.bytes().all(|byte| byte.is_ascii_hexdigit()) {+ return Err("Not a valid Git SHA".to_owned());+ }+ Ok(Self(value.to_owned()))+ }+}+#[allow(clippy::disallowed_methods,reason = "This runs only in a CLI environment")]fn parse_ref(value: &str) -> Result<GitSha, String> {- const GIT_SHA_LENGTH: usize = 40;- (value.len() == GIT_SHA_LENGTH)- .then_some(value)- .ok_or_else(|| {- format!(- "Git SHA has wrong length! \- Only SHAs with a full length of {GIT_SHA_LENGTH} are supported, found {len} characters.",- len = value.len()- )- })- .and_then(|value| {- let mut tmp = [0; 4];- value- .chars()- .all(|char| u16::from_str_radix(char.encode_utf8(&mut tmp), 16).is_ok()).then_some(value)- .ok_or_else(|| "Not a valid Git SHA".to_owned())- })- .and_then(|sha| {- std::process::Command::new("git")- .args([- "rev-parse",- "--quiet",- "--verify",- &format!("{sha}^{{commit}}")- ])- .output()- .map_err(|_| "Failed to spawn Git command to verify SHA".to_owned())- .and_then(|output|- output- .status.success()- .then_some(sha)- .ok_or_else(|| format!("SHA {sha} is not a valid Git SHA within this repository!")))- }).map(|sha| GitSha(sha.to_owned()))+ let sha = value.parse::<GitSha>()?;+ let output = std::process::Command::new("git")+ .args([+ "rev-parse",+ "--quiet",+ "--verify",+ &format!("{}^{{commit}}", sha.as_ref()),+ ])+ .output()+ .map_err(|_| "Failed to spawn Git command to verify SHA".to_owned())?;+ if !output.status.success() {+ return Err(format!(+ "SHA {} is not a valid Git SHA within this repository!",+ sha.as_ref()+ ));+ }+ Ok(sha)}#[derive(Parser)]