Ything-RepoMirrors/cargo
1
0
Fork 0
mirror of https://github.com/rust-lang/cargo.git synced 2026-01-25 04:16:45 +00:00
Code Issues Packages Projects Releases Wiki Activity

chore: remove xtask-unpublished

Browse Source
This commit is contained in:
Weihang Lo
2023-07-26 00:45:32 +01:00
parent aefa6e96d7
commit 8d31d626a2
5 changed files with 0 additions and 239 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
.cargo/config.toml
View File

@@ -1,5 +1,4 @@
[alias]
build-man = "run --package xtask-build-man --"
stale-label = "run --package xtask-stale-label --"
unpublished = "run --package xtask-unpublished --"
bump-check = "run --package xtask-bump-check --"

11
Cargo.lock generated
View File

@@ -3787,17 +3787,6 @@ dependencies = [
"toml_edit",
]
[[package]]
name = "xtask-unpublished"
version = "0.0.0"
dependencies = [
"anyhow",
"cargo",
"clap",
"env_logger 0.10.0",
"log",
]
[[package]]
name = "yansi"
version = "0.5.1"

12
crates/xtask-unpublished/Cargo.toml
View File

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

15
crates/xtask-unpublished/src/main.rs
View File

@@ -1,15 +0,0 @@
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())
}
}

200
crates/xtask-unpublished/src/xtask.rs
View File

@@ -1,200 +0,0 @@
//! `xtask-unpublished` outputs a table with publish status --- a local version
//! and a version on crates.io for comparisons.
//!
//! This aims to help developers check if there is any crate required a new
//! publish, as well as detect if a version bump is needed in CI pipeline.
use std::collections::HashSet;
use cargo::core::registry::PackageRegistry;
use cargo::core::QueryKind;
use cargo::core::Registry;
use cargo::core::SourceId;
use cargo::ops::Packages;
use cargo::util::command_prelude::*;
pub fn cli() -> clap::Command {
clap::Command::new("xtask-unpublished")
.arg_package_spec_simple("Package to inspect the published status")
.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(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)?;
unpublished(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(())
}
fn unpublished(args: &clap::ArgMatches, config: &mut cargo::util::Config) -> cargo::CliResult {
let ws = args.workspace(config)?;
let members_to_inspect: HashSet<_> = {
let pkgs = args.packages_from_flags()?;
if let Packages::Packages(_) = pkgs {
HashSet::from_iter(pkgs.get_packages(&ws)?)
} else {
HashSet::from_iter(ws.members())
}
};
let mut results = Vec::new();
{
let mut registry = PackageRegistry::new(config)?;
let _lock = config.acquire_package_cache_lock()?;
registry.lock_patches();
let source_id = SourceId::crates_io(config)?;
for member in members_to_inspect {
let name = member.name();
let current = member.version();
if member.publish() == &Some(vec![]) {
log::trace!("skipping {name}, `publish = false`");
continue;
}
let version_req = format!("<={current}");
let query =
cargo::core::dependency::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) {
std::task::Poll::Ready(res) => {
break res?;
}
std::task::Poll::Pending => registry.block_until_ready()?,
}
};
let (last, published) = possibilities
.iter()
.map(|s| s.version())
.max()
.map(|last| (last.to_string(), last == current))
.unwrap_or(("-".to_string(), false));
results.push(vec![
name.to_string(),
last,
current.to_string(),
if published { "yes" } else { "no" }.to_string(),
]);
}
}
results.sort();
if results.is_empty() {
return Ok(());
}
results.insert(
0,
vec![
"name".to_owned(),
"crates.io".to_owned(),
"local".to_owned(),
"published?".to_owned(),
],
);
output_table(results);
Ok(())
}
/// Outputs a markdown table like this.
///
/// ```text
/// | name | crates.io | local | published? |
/// |------------------|-----------|--------|------------|
/// | cargo | 0.70.1 | 0.72.0 | no |
/// | cargo-platform | 0.1.2 | 0.1.2 | yes |
/// | cargo-util | - | 0.2.4 | no |
/// | crates-io | 0.36.0 | 0.36.0 | yes |
/// | home | - | 0.5.6 | no |
/// ```
fn output_table(table: Vec<Vec<String>>) {
let header = table.first().unwrap();
let paddings = table.iter().fold(vec![0; header.len()], |mut widths, row| {
for (width, field) in widths.iter_mut().zip(row) {
*width = usize::max(*width, field.len());
}
widths
});
let print = |row: &[_]| {
for (field, pad) in row.iter().zip(&paddings) {
print!("| {field:pad$} ");
}
println!("|");
};
print(header);
paddings.iter().for_each(|fill| print!("|-{:-<fill$}-", ""));
println!("|");
table.iter().skip(1).for_each(|r| print(r));
}
#[test]
fn verify_cli() {
cli().debug_assert();
}