chore: new xtask bump-check

This is a rewrite of old `ci/validate-version-bump.sh` in Rust.

Author: weihanglo

crates/xtask-bump-check/Cargo.toml

@@ -0,0 +1,13 @@
+[package]
+name = "xtask-bump-check"
+version = "0.0.0"
+edition.workspace = true
+publish = false
+
+[dependencies]
+anyhow.workspace = true
+cargo.workspace = true
+clap.workspace = true
+env_logger.workspace = true
+git2.workspace = true
+log.workspace = true

crates/xtask-bump-check/src/main.rs

@@ -0,0 +1,15 @@
+mod xtask;
+
+fn main() {
+    env_logger::init_from_env("CARGO_LOG");
+    let cli = xtask::cli();
+    let matches = cli.get_matches();
+
+    let mut config = cargo::util::config::Config::default().unwrap_or_else(|e| {
+        let mut eval = cargo::core::shell::Shell::new();
+        cargo::exit_with_error(e.into(), &mut eval)
+    });
+    if let Err(e) = xtask::exec(&matches, &mut config) {
+        cargo::exit_with_error(e, &mut config.shell())
+    }
+}

crates/xtask-bump-check/src/xtask.rs

@@ -0,0 +1,271 @@
+//! ```text
+//! NAME
+//!         xtask-bump-check
+//!
+//! SYNOPSIS
+//!         xtask-bump-check --baseline-rev <REV>
+//!
+//! DESCRIPTION
+//!         Checks if there is any member got changed since a base commit
+//!         but forgot to bump its version.
+//! ```
+
+use std::collections::HashMap;
+use std::fmt::Write;
+use std::fs;
+use std::task;
+
+use cargo::core::dependency::Dependency;
+use cargo::core::registry::PackageRegistry;
+use cargo::core::Package;
+use cargo::core::QueryKind;
+use cargo::core::Registry;
+use cargo::core::SourceId;
+use cargo::core::Workspace;
+use cargo::util::command_prelude::*;
+use cargo::util::ToSemver;
+use cargo::CargoResult;
+
+pub fn cli() -> clap::Command {
+    clap::Command::new("xtask-bump-check")
+        .arg(
+            opt(
+                "verbose",
+                "Use verbose output (-vv very verbose/build.rs output)",
+            )
+            .short('v')
+            .action(ArgAction::Count)
+            .global(true),
+        )
+        .arg_quiet()
+        .arg(
+            opt("color", "Coloring: auto, always, never")
+                .value_name("WHEN")
+                .global(true),
+        )
+        .arg(
+            opt("baseline-rev", "Git revision to lookup for a baseline")
+                .action(ArgAction::Set)
+                .required(true),
+        )
+        .arg(flag("frozen", "Require Cargo.lock and cache are up to date").global(true))
+        .arg(flag("locked", "Require Cargo.lock is up to date").global(true))
+        .arg(flag("offline", "Run without accessing the network").global(true))
+        .arg(multi_opt("config", "KEY=VALUE", "Override a configuration value").global(true))
+        .arg(
+            Arg::new("unstable-features")
+                .help("Unstable (nightly-only) flags to Cargo, see 'cargo -Z help' for details")
+                .short('Z')
+                .value_name("FLAG")
+                .action(ArgAction::Append)
+                .global(true),
+        )
+}
+
+pub fn exec(args: &clap::ArgMatches, config: &mut cargo::util::Config) -> cargo::CliResult {
+    config_configure(config, args)?;
+
+    bump_check(args, config)?;
+
+    Ok(())
+}
+
+fn config_configure(config: &mut Config, args: &ArgMatches) -> CliResult {
+    let verbose = args.verbose();
+    // quiet is unusual because it is redefined in some subcommands in order
+    // to provide custom help text.
+    let quiet = args.flag("quiet");
+    let color = args.get_one::<String>("color").map(String::as_str);
+    let frozen = args.flag("frozen");
+    let locked = args.flag("locked");
+    let offline = args.flag("offline");
+    let mut unstable_flags = vec![];
+    if let Some(values) = args.get_many::<String>("unstable-features") {
+        unstable_flags.extend(values.cloned());
+    }
+    let mut config_args = vec![];
+    if let Some(values) = args.get_many::<String>("config") {
+        config_args.extend(values.cloned());
+    }
+    config.configure(
+        verbose,
+        quiet,
+        color,
+        frozen,
+        locked,
+        offline,
+        &None,
+        &unstable_flags,
+        &config_args,
+    )?;
+    Ok(())
+}
+
+/// Turns an arg into a commit object.
+fn arg_to_commit<'a>(
+    args: &clap::ArgMatches,
+    repo: &'a git2::Repository,
+    name: &str,
+) -> CargoResult<git2::Commit<'a>> {
+    let arg = args.get_one::<String>(name).map(String::as_str).unwrap();
+    Ok(repo.revparse_single(arg)?.peel_to_commit()?)
+}
+
+/// Checkouts a temporary workspace to do further version comparsions.
+fn checkout_ws<'cfg, 'a>(
+    ws: &Workspace<'cfg>,
+    repo: &'a git2::Repository,
+    referenced_commit: &git2::Commit<'a>,
+) -> CargoResult<Workspace<'cfg>> {
+    let repo_path = repo.path().as_os_str().to_str().unwrap();
+    // Put it under `target/cargo-<short-id>`
+    let short_id = &referenced_commit.id().to_string()[..7];
+    let checkout_path = ws.target_dir().join(format!("cargo-{short_id}"));
+    let checkout_path = checkout_path.as_path_unlocked();
+    let _ = fs::remove_dir_all(checkout_path);
+    let new_repo = git2::build::RepoBuilder::new()
+        .clone_local(git2::build::CloneLocal::Local)
+        .clone(repo_path, checkout_path)
+        .unwrap();
+    let obj = new_repo.find_object(referenced_commit.id(), None)?;
+    new_repo.reset(&obj, git2::ResetType::Hard, None)?;
+    Workspace::new(&checkout_path.join("Cargo.toml"), ws.config())
+}
+
+/// Get the current beta and stable branch in cargo repository.
+///
+/// Assumptions:
+///
+/// * The repository contains the full history of `origin/rust-1.*.0` branches.
+/// * The version part of `origin/rust-1.*.0` always ends with a zero.
+/// * The maximum version is for beta channel, and the second one is for stable.
+fn beta_and_stable_branch(repo: &git2::Repository) -> CargoResult<[git2::Branch<'_>; 2]> {
+    let mut release_branches = Vec::new();
+    for branch in repo.branches(Some(git2::BranchType::Remote))? {
+        let (branch, _) = branch?;
+        let Some(version) = branch.name()?.and_then(|n| n.strip_prefix("origin/rust-")) else {
+            continue;
+        };
+        release_branches.push((version.to_semver()?, branch));
+    }
+    release_branches.sort_unstable_by(|a, b| a.0.cmp(&b.0));
+
+    let beta = release_branches.pop().unwrap();
+    let stable = release_branches.pop().unwrap();
+
+    assert_eq!(beta.0.major, 1);
+    assert_eq!(beta.0.patch, 0);
+    assert_eq!(stable.0.major, 1);
+    assert_eq!(stable.0.patch, 0);
+    assert_ne!(beta.0.minor, stable.0.minor);
+
+    Ok([beta.1, stable.1])
+}
+
+/// Gets the referenced commit to compare if version bump needed.
+///
+/// * When merging into nightly, check the version with beta branch
+/// * When merging into beta, check the version with stable branch
+/// * When merging into stable, check against crates.io registry directly
+fn get_referenced_commit<'a>(
+    repo: &'a git2::Repository,
+    base: &git2::Commit<'a>,
+) -> CargoResult<Option<git2::Commit<'a>>> {
+    let [beta, stable] = beta_and_stable_branch(&repo)?;
+    let rev_id = base.id();
+    let stable_commit = stable.get().peel_to_commit()?;
+    let beta_commit = beta.get().peel_to_commit()?;
+
+    let commit = if rev_id == stable_commit.id() {
+        None
+    } else if rev_id == beta_commit.id() {
+        Some(stable_commit)
+    } else {
+        Some(beta_commit)
+    };
+
+    Ok(commit)
+}
+
+/// Main entry of `xtask-bump-check`.
+///
+/// Assumption: version number are incremental. We never have point release for old versions.
+fn bump_check(args: &clap::ArgMatches, config: &mut cargo::util::Config) -> CargoResult<()> {
+    let ws = args.workspace(config)?;
+    let repo = git2::Repository::open(ws.root()).unwrap();
+    let base_commit = arg_to_commit(args, &repo, "baseline-rev")?;
+    let referenced_commit = get_referenced_commit(&repo, &base_commit)?;
+    let published_members = HashMap::<&str, &Package>::from_iter(
+        ws.members()
+            .filter(|m| m.publish() != &Some(vec![])) // package.publish = false
+            .map(|m| (m.name().as_str(), m)),
+    );
+
+    let mut needs_bump = Vec::new();
+
+    if let Some(commit) = referenced_commit.as_ref() {
+        config.shell().status(
+            "BumpCheck",
+            format_args!("compare aginst `{}`", commit.id()),
+        )?;
+        for member in checkout_ws(&ws, &repo, commit)?.members() {
+            let name = member.name().as_str();
+            let Some(changed) = published_members.get(name) else {
+                log::trace!("skpping {name}, may be removed or not published");
+                continue;
+            };
+
+            if changed.version() <= member.version() {
+                needs_bump.push(*changed);
+            }
+        }
+    } else {
+        let source_id = SourceId::crates_io(config)?;
+        let mut registry = PackageRegistry::new(config)?;
+        let _lock = config.acquire_package_cache_lock()?;
+        registry.lock_patches();
+        config.shell().status(
+            "BumpCheck",
+            format_args!("compare against `{}`", source_id.display_registry_name()),
+        )?;
+        for member in published_members.values() {
+            let name = member.name();
+            let current = member.version();
+            let version_req = format!("<={current}");
+            let query = Dependency::parse(name, Some(&version_req), source_id)?;
+            let possibilities = loop {
+                // Exact to avoid returning all for path/git
+                match registry.query_vec(&query, QueryKind::Exact) {
+                    task::Poll::Ready(res) => {
+                        break res?;
+                    }
+                    task::Poll::Pending => registry.block_until_ready()?,
+                }
+            };
+            let max_version = possibilities.iter().map(|s| s.version()).max();
+            if max_version >= Some(current) {
+                needs_bump.push(member);
+            }
+        }
+    }
+
+    if needs_bump.is_empty() {
+        config
+            .shell()
+            .status("BumpCheck", "no version bump needed for member crates.")?;
+        return Ok(());
+    }
+
+    let mut msg = String::new();
+    msg.push_str("Detected changes in these crates but no version bump found:\n");
+    for pkg in needs_bump {
+        writeln!(&mut msg, "  {}@{}", pkg.name(), pkg.version())?;
+    }
+    msg.push_str("\nPlease bump at least one patch version in each corresponding Cargo.toml.");
+    anyhow::bail!(msg)
+}
+
+#[test]
+fn verify_cli() {
+    cli().debug_assert();
+}