oak-team/oak-gpui
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

gpui: Update dependency package names (#40143)

Browse Source 
This moves some of the changes made in
https://github.com/zed-industries/zed/pull/39543 to the `publish_gpui`
script.

This PR also updates that script to use `gpui_` instead of `zed-` (where
possible)

Release Notes:

- N/A
This commit is contained in:
Mikayla Maki
2025-10-14 04:43:28 +00:00
committed by GitHub
parent 97f398e677
commit ee60d5855c
22 changed files with 1178 additions and 1033 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tooling/xtask/src/tasks/publish_gpui.rs
+202 -81
View File
@@ -7,13 +7,13 @@ use clap::Parser;
#[derive(Parser)]
pub struct PublishGpuiArgs {
/// Optional pre-release identifier to append to the version (e.g., alpha, test.1). Always bumps the minor version.
#[arg(long)]
pre_release: Option<String>,
/// Perform a dry-run and wait for user confirmation before each publish
#[arg(long)]
dry_run: bool,
/// Skip to a specific package (by package name or crate name) and start from there
#[arg(long)]
skip_to: Option<String>,
}
pub fn run_publish_gpui(args: PublishGpuiArgs) -> Result<()> {
@@ -24,12 +24,16 @@ pub fn run_publish_gpui(args: PublishGpuiArgs) -> Result<()> {
let start_time = std::time::Instant::now();
check_workspace_root()?;
ensure_cargo_set_version()?;
check_git_clean()?;
if args.skip_to.is_none() {
check_git_clean()?;
} else {
println!("Skipping git clean check due to --skip-to flag");
}
let version = read_gpui_version()?;
println!("Updating GPUI to version: {}", version);
publish_dependencies(&version, args.dry_run)?;
publish_dependencies(&version, args.dry_run, args.skip_to.as_deref())?;
publish_gpui(&version, args.dry_run)?;
println!("GPUI published in {}s", start_time.elapsed().as_secs_f32());
Ok(())
@@ -52,62 +56,106 @@ fn read_gpui_version() -> Result<String> {
Ok(version.to_string())
}
fn publish_dependencies(new_version: &str, dry_run: bool) -> Result<()> {
fn publish_dependencies(new_version: &str, dry_run: bool, skip_to: Option<&str>) -> Result<()> {
let gpui_dependencies = vec![
("zed-collections", "collections"),
("zed-perf", "perf"),
("zed-util-macros", "util_macros"),
("zed-util", "util"),
("gpui-macros", "gpui_macros"),
("zed-http-client", "http_client"),
("zed-derive-refineable", "derive_refineable"),
("zed-refineable", "refineable"),
("zed-semantic-version", "semantic_version"),
("zed-sum-tree", "sum_tree"),
("zed-media", "media"),
("collections", "gpui_collections", "crates"),
("perf", "gpui_perf", "tooling"),
("util_macros", "gpui_util_macros", "crates"),
("util", "gpui_util", "crates"),
("gpui_macros", "gpui-macros", "crates"),
("http_client", "gpui_http_client", "crates"),
(
"derive_refineable",
"gpui_derive_refineable",
"crates/refineable",
),
("refineable", "gpui_refineable", "crates"),
("semantic_version", "gpui_semantic_version", "crates"),
("sum_tree", "gpui_sum_tree", "crates"),
("media", "gpui_media", "crates"),
];
for (crate_name, package_name) in gpui_dependencies {
let mut should_skip = skip_to.is_some();
let skip_target = skip_to.unwrap_or("");
for (package_name, crate_name, package_dir) in gpui_dependencies {
if should_skip {
if package_name == skip_target || crate_name == skip_target {
println!("Found skip target: {} ({})", crate_name, package_name);
should_skip = false;
} else {
println!("Skipping: {} ({})", crate_name, package_name);
continue;
}
}
println!(
"Publishing dependency: {} (package: {})",
crate_name, package_name
);
update_crate_version(crate_name, new_version)?;
update_workspace_dependency_version(package_name, new_version)?;
update_crate_cargo_toml(package_name, crate_name, package_dir, new_version)?;
update_workspace_dependency_version(package_name, crate_name, new_version)?;
publish_crate(crate_name, dry_run)?;
}
// println!("Waiting 60s for the rate limit...");
// thread::sleep(Duration::from_secs(60));
if should_skip {
bail!(
"Could not find package or crate named '{}' to skip to",
skip_target
);
}
Ok(())
}
fn publish_gpui(new_version: &str, dry_run: bool) -> Result<()> {
update_crate_version("gpui", new_version)?;
update_crate_cargo_toml("gpui", "gpui", "crates", new_version)?;
publish_crate("gpui", dry_run)?;
Ok(())
}
fn update_crate_version(package_name: &str, new_version: &str) -> Result<()> {
let output = run_command(
Command::new("cargo")
.arg("set-version")
.arg("--package")
.arg(package_name)
.arg(new_version),
)?;
fn update_crate_cargo_toml(
package_name: &str,
crate_name: &str,
package_dir: &str,
new_version: &str,
) -> Result<()> {
let cargo_toml_path = format!("{}/{}/Cargo.toml", package_dir, package_name);
let contents = std::fs::read_to_string(&cargo_toml_path)
.context(format!("Failed to read {}", cargo_toml_path))?;
if !output.status.success() {
bail!("Failed to set version for package {}", package_name);
}
let updated = update_crate_package_fields(&contents, crate_name, new_version)?;
std::fs::write(&cargo_toml_path, updated)
.context(format!("Failed to write {}", cargo_toml_path))?;
Ok(())
}
fn update_crate_package_fields(
toml_contents: &str,
crate_name: &str,
new_version: &str,
) -> Result<String> {
let mut doc = toml_contents
.parse::<toml_edit::DocumentMut>()
.context("Failed to parse TOML")?;
let package = doc
.get_mut("package")
.and_then(|p| p.as_table_like_mut())
.context("Failed to find [package] section")?;
package.insert("name", toml_edit::value(crate_name));
package.insert("version", toml_edit::value(new_version));
package.insert("publish", toml_edit::value(true));
Ok(doc.to_string())
}
fn publish_crate(crate_name: &str, dry_run: bool) -> Result<()> {
let publish_crate_impl = |crate_name, dry_run| {
let cargo = std::env::var("CARGO").unwrap_or_else(|_| "cargo".to_string());
@@ -142,29 +190,34 @@ fn publish_crate(crate_name: &str, dry_run: bool) -> Result<()> {
Ok(())
}
fn update_workspace_dependency_version(package_name: &str, new_version: &str) -> Result<()> {
fn update_workspace_dependency_version(
package_name: &str,
crate_name: &str,
new_version: &str,
) -> Result<()> {
let workspace_cargo_toml_path = "Cargo.toml";
let contents = std::fs::read_to_string(workspace_cargo_toml_path)
.context("Failed to read workspace Cargo.toml")?;
let updated = update_dependency_version_in_toml(&contents, package_name, new_version)?;
let mut doc = contents
.parse::<toml_edit::DocumentMut>()
.context("Failed to parse TOML")?;
std::fs::write(workspace_cargo_toml_path, updated)
update_dependency_version_in_doc(&mut doc, package_name, crate_name, new_version)?;
update_profile_override_in_doc(&mut doc, package_name, crate_name)?;
std::fs::write(workspace_cargo_toml_path, doc.to_string())
.context("Failed to write workspace Cargo.toml")?;
Ok(())
}
fn update_dependency_version_in_toml(
toml_contents: &str,
fn update_dependency_version_in_doc(
doc: &mut toml_edit::DocumentMut,
package_name: &str,
crate_name: &str,
new_version: &str,
) -> Result<String> {
let mut doc = toml_contents
.parse::<toml_edit::DocumentMut>()
.context("Failed to parse TOML")?;
// Navigate to workspace.dependencies.<package_name>
) -> Result<()> {
let dependency = doc
.get_mut("workspace")
.and_then(|w| w.get_mut("dependencies"))
@@ -174,21 +227,35 @@ fn update_dependency_version_in_toml(
package_name
))?;
// Update the version field if it exists
if let Some(dep_table) = dependency.as_table_like_mut() {
if dep_table.contains_key("version") {
dep_table.insert("version", toml_edit::value(new_version));
} else {
bail!(
"No version field found for {} in workspace dependencies",
package_name
);
}
dep_table.insert("version", toml_edit::value(new_version));
dep_table.insert("package", toml_edit::value(crate_name));
} else {
bail!("{} is not a table in workspace dependencies", package_name);
}
Ok(doc.to_string())
Ok(())
}
fn update_profile_override_in_doc(
doc: &mut toml_edit::DocumentMut,
package_name: &str,
crate_name: &str,
) -> Result<()> {
if let Some(profile_dev_package) = doc
.get_mut("profile")
.and_then(|p| p.get_mut("dev"))
.and_then(|d| d.get_mut("package"))
.and_then(|p| p.as_table_like_mut())
{
if let Some(old_entry) = profile_dev_package.get(package_name) {
let old_entry_clone = old_entry.clone();
profile_dev_package.remove(package_name);
profile_dev_package.insert(crate_name, old_entry_clone);
}
}
Ok(())
}
fn check_workspace_root() -> Result<()> {
@@ -215,27 +282,6 @@ fn check_workspace_root() -> Result<()> {
Ok(())
}
fn ensure_cargo_set_version() -> Result<()> {
let output = run_command(
Command::new("which")
.arg("cargo-set-version")
.stdout(Stdio::piped()),
)
.context("Failed to check for cargo-set-version")?;
if !output.status.success() {
println!("cargo-set-version not found. Installing cargo-edit...");
let install_output = run_command(Command::new("cargo").arg("install").arg("cargo-edit"))?;
if !install_output.status.success() {
bail!("Failed to install cargo-edit");
}
}
Ok(())
}
fn check_git_clean() -> Result<()> {
let output = run_command(
Command::new("git")
@@ -281,6 +327,10 @@ fn run_command(command: &mut Command) -> Result<Output> {
.wait_with_output()
.context("failed to wait for child process")?;
if !output.status.success() {
bail!("Command failed with status {}", output.status);
}
Ok(output)
}
@@ -298,12 +348,17 @@ mod tests {
[workspace.dependencies]
# here's a comment
collections = { path = "crates/collections", package = "zed-collections", version = "0.1.0" }
collections = { path = "crates/collections" }
util = { path = "crates/util", package = "zed-util", version = "0.1.0" }
"#};
let result = update_dependency_version_in_toml(input, "collections", "0.2.0").unwrap();
let mut doc = input.parse::<toml_edit::DocumentMut>().unwrap();
update_dependency_version_in_doc(&mut doc, "collections", "gpui_collections", "0.2.0")
.unwrap();
let result = doc.to_string();
let output = indoc! {r#"
[workspace]
@@ -311,11 +366,77 @@ mod tests {
[workspace.dependencies]
# here's a comment
collections = { path = "crates/collections", package = "zed-collections", version = "0.2.0" }
collections = { path = "crates/collections" , version = "0.2.0", package = "gpui_collections" }
util = { path = "crates/util", package = "zed-util", version = "0.1.0" }
"#};
assert_eq!(result, output);
}
#[test]
fn test_update_crate_package_fields() {
let input = indoc! {r#"
[package]
name = "collections"
version = "0.1.0"
edition = "2021"
publish = false
# some comment about the license
license = "GPL-3.0-or-later"
[dependencies]
serde = "1.0"
"#};
let result = update_crate_package_fields(input, "gpui_collections", "0.2.0").unwrap();
let output = indoc! {r#"
[package]
name = "gpui_collections"
version = "0.2.0"
edition = "2021"
publish = true
# some comment about the license
license = "GPL-3.0-or-later"
[dependencies]
serde = "1.0"
"#};
assert_eq!(result, output);
}
#[test]
fn test_update_profile_override_in_toml() {
let input = indoc! {r#"
[profile.dev]
split-debuginfo = "unpacked"
[profile.dev.package]
taffy = { opt-level = 3 }
collections = { codegen-units = 256 }
refineable = { codegen-units = 256 }
util = { codegen-units = 256 }
"#};
let mut doc = input.parse::<toml_edit::DocumentMut>().unwrap();
update_profile_override_in_doc(&mut doc, "collections", "gpui_collections").unwrap();
let result = doc.to_string();
let output = indoc! {r#"
[profile.dev]
split-debuginfo = "unpacked"
[profile.dev.package]
taffy = { opt-level = 3 }
refineable = { codegen-units = 256 }
util = { codegen-units = 256 }
gpui_collections = { codegen-units = 256 }
"#};
assert_eq!(result, output);
}
}