Allow explicit values with uv version --bump (#16555)

Resolves #16427

This PR updates `uv version --bump` so you can pin the exact number
you’re targeting, i.e. `--bump patch=10` or `--bump dev=42`. The
command-line interface now parses those `component=value` flags, and the
bump logic actually sets the version to the number you asked for.

Author: terror

crates/uv-cli/src/lib.rs

@@ -1,11 +1,14 @@
 use std::ffi::OsString;
+use std::fmt::{self, Display, Formatter};
 use std::ops::{Deref, DerefMut};
 use std::path::PathBuf;
 use std::str::FromStr;
 
 use anyhow::{Result, anyhow};
-use clap::builder::Styles;
+use clap::ValueEnum;
 use clap::builder::styling::{AnsiColor, Effects, Style};
+use clap::builder::{PossibleValue, Styles, TypedValueParser, ValueParserFactory};
+use clap::error::ErrorKind;
 use clap::{Args, Parser, Subcommand};
 
 use uv_auth::Service;
@@ -587,8 +590,8 @@ pub struct VersionArgs {
     /// Update the project version using the given semantics
     ///
     /// This flag can be passed multiple times.
-    #[arg(group = "operation", long)]
-    pub bump: Vec<VersionBump>,
+    #[arg(group = "operation", long, value_name = "BUMP[=VALUE]")]
+    pub bump: Vec<VersionBumpSpec>,
 
     /// Don't write a new version to the `pyproject.toml`
     ///
@@ -698,8 +701,8 @@ pub enum VersionBump {
     Dev,
 }
 
-impl std::fmt::Display for VersionBump {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl Display for VersionBump {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         let string = match self {
             Self::Major => "major",
             Self::Minor => "minor",
@@ -715,6 +718,110 @@ impl std::fmt::Display for VersionBump {
     }
 }
 
+impl FromStr for VersionBump {
+    type Err = String;
+
+    fn from_str(value: &str) -> Result<Self, Self::Err> {
+        match value {
+            "major" => Ok(Self::Major),
+            "minor" => Ok(Self::Minor),
+            "patch" => Ok(Self::Patch),
+            "stable" => Ok(Self::Stable),
+            "alpha" => Ok(Self::Alpha),
+            "beta" => Ok(Self::Beta),
+            "rc" => Ok(Self::Rc),
+            "post" => Ok(Self::Post),
+            "dev" => Ok(Self::Dev),
+            _ => Err(format!("invalid bump component `{value}`")),
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
+pub struct VersionBumpSpec {
+    pub bump: VersionBump,
+    pub value: Option<u64>,
+}
+
+impl Display for VersionBumpSpec {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        match self.value {
+            Some(value) => write!(f, "{}={value}", self.bump),
+            None => self.bump.fmt(f),
+        }
+    }
+}
+
+impl FromStr for VersionBumpSpec {
+    type Err = String;
+
+    fn from_str(input: &str) -> Result<Self, Self::Err> {
+        let (name, value) = match input.split_once('=') {
+            Some((name, value)) => (name, Some(value)),
+            None => (input, None),
+        };
+
+        let bump = name.parse::<VersionBump>()?;
+
+        if bump == VersionBump::Stable && value.is_some() {
+            return Err("`--bump stable` does not accept a value".to_string());
+        }
+
+        let value = match value {
+            Some("") => {
+                return Err("`--bump` values cannot be empty".to_string());
+            }
+            Some(raw) => Some(
+                raw.parse::<u64>()
+                    .map_err(|_| format!("invalid numeric value `{raw}` for `--bump {name}`"))?,
+            ),
+            None => None,
+        };
+
+        Ok(Self { bump, value })
+    }
+}
+
+impl ValueParserFactory for VersionBumpSpec {
+    type Parser = VersionBumpSpecValueParser;
+
+    fn value_parser() -> Self::Parser {
+        VersionBumpSpecValueParser
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct VersionBumpSpecValueParser;
+
+impl TypedValueParser for VersionBumpSpecValueParser {
+    type Value = VersionBumpSpec;
+
+    fn parse_ref(
+        &self,
+        _cmd: &clap::Command,
+        _arg: Option<&clap::Arg>,
+        value: &std::ffi::OsStr,
+    ) -> Result<Self::Value, clap::Error> {
+        let raw = value.to_str().ok_or_else(|| {
+            clap::Error::raw(
+                ErrorKind::InvalidUtf8,
+                "`--bump` values must be valid UTF-8",
+            )
+        })?;
+
+        VersionBumpSpec::from_str(raw)
+            .map_err(|message| clap::Error::raw(ErrorKind::InvalidValue, message))
+    }
+
+    fn possible_values(&self) -> Option<Box<dyn Iterator<Item = PossibleValue> + '_>> {
+        Some(Box::new(
+            VersionBump::value_variants()
+                .iter()
+                .filter_map(ValueEnum::to_possible_value),
+        ))
+    }
+}
+
 #[derive(Args)]
 pub struct SelfNamespace {
     #[command(subcommand)]