feat: Add no space requirement for short options

BREAKING CHANGE: `require_equals` no longer affects the short option
thus this may break some arguments. For example, if an argument has
`require_equals` and `min_vals == 0`, `val` in `-o val` is now parsed as
the argument value rather than a separate positional argument.

Introduce `require_no_space` which requires that the short option has no
space between it and the associated value.

Limit `require_equals` to only the long option.

clap_builder/src/builder/arg.rs

@@ -1449,15 +1449,17 @@ impl Arg {
         }
     }
 
-    /// Requires that options use the `--option=val` syntax
+    /// Requires that long options use the `--option=val` syntax
     ///
-    /// i.e. an equals between the option and associated value.
+    /// i.e. an equals between the long option and associated value.
     ///
     /// **NOTE:** Setting this requires [taking values][Arg::num_args]
     ///
+    /// **NOTE:** Setting this does not affect any short version
+    ///
     /// # Examples
     ///
-    /// Setting `require_equals` requires that the option have an equals sign between
+    /// Setting `require_equals` requires that the long option have an equals sign between
     /// it and the associated value.
     ///
     /// ```rust
@@ -1503,6 +1505,62 @@ impl Arg {
         }
     }
 
+    /// Requires that options use the `-oval` syntax
+    ///
+    /// i.e. no space between the short option and associated value.
+    ///
+    /// **NOTE:** Setting this requires [taking values][Arg::num_args]
+    ///
+    /// **NOTE:** Setting this does not affect any long version
+    ///
+    /// # Examples
+    ///
+    /// Setting `require_no_space` requires that the short option has no space between
+    /// it and the associated value.
+    ///
+    /// ```rust
+    /// # use clap_builder as clap;
+    /// # use clap::{Command, Arg, ArgAction};
+    /// let res = Command::new("prog")
+    ///     .arg(Arg::new("cfg")
+    ///         .action(ArgAction::Set)
+    ///         .require_no_space(true)
+    ///         .short('c'))
+    ///     .try_get_matches_from(vec![
+    ///         "prog", "-cfile.conf"
+    ///     ]);
+    ///
+    /// assert!(res.is_ok());
+    /// ```
+    ///
+    /// Setting `require_no_space` and having a space will cause an
+    /// error.
+    ///
+    /// ```rust
+    /// # use clap_builder as clap;
+    /// # use clap::{Command, Arg, error::ErrorKind, ArgAction};
+    /// let res = Command::new("prog")
+    ///     .arg(Arg::new("cfg")
+    ///         .action(ArgAction::Set)
+    ///         .require_no_space(true)
+    ///         .short('c'))
+    ///     .try_get_matches_from(vec![
+    ///         "prog", "-c", "file.conf"
+    ///     ]);
+    ///
+    /// assert!(res.is_err());
+    /// assert_eq!(res.unwrap_err().kind(), ErrorKind::SpaceFound);
+    /// ```
+    #[inline]
+    #[must_use]
+    pub fn require_no_space(self, yes: bool) -> Self {
+        if yes {
+            self.setting(ArgSettings::RequireNoSpace)
+        } else {
+            self.unset_setting(ArgSettings::RequireNoSpace)
+        }
+    }
+
     #[doc(hidden)]
     #[cfg_attr(
         feature = "deprecated",
@@ -4176,6 +4234,11 @@ impl Arg {
         self.is_set(ArgSettings::RequireEquals)
     }
 
+    /// Report whether [`Arg::require_no_space`] is set
+    pub fn is_require_no_space_set(&self) -> bool {
+        self.is_set(ArgSettings::RequireNoSpace)
+    }
+
     /// Reports whether [`Arg::exclusive`] is set
     pub fn is_exclusive_set(&self) -> bool {
         self.is_set(ArgSettings::Exclusive)
@@ -4293,6 +4356,10 @@ impl Arg {
             );
         } else if let Some(s) = self.get_short() {
             let _ = write!(styled, "{}-{s}{}", literal.render(), literal.render_reset());
+            if self.is_require_no_space_set() {
+                styled.push_styled(&self.stylize_arg_no_space_suffix(styles, required));
+                return styled;
+            }
         }
         styled.push_styled(&self.stylize_arg_suffix(styles, required));
         styled
@@ -4307,7 +4374,7 @@ impl Arg {
         let mut need_closing_bracket = false;
         if self.is_takes_value_set() && !self.is_positional() {
             let is_optional_val = self.get_min_vals() == 0;
-            let (style, start) = if self.is_require_equals_set() {
+            let (style, start) = if self.is_require_equals_set() && self.get_long().is_some() {
                 if is_optional_val {
                     need_closing_bracket = true;
                     (placeholder, "[=")
@@ -4351,6 +4418,44 @@ impl Arg {
         styled
     }
 
+    pub(crate) fn stylize_arg_no_space_suffix(
+        &self,
+        styles: &Styles,
+        required: Option<bool>,
+    ) -> StyledStr {
+        use std::fmt::Write as _;
+        let placeholder = styles.get_placeholder();
+        let mut styled = StyledStr::new();
+
+        let is_optional_val = self.get_min_vals() == 0;
+        if is_optional_val {
+            let _ = write!(
+                styled,
+                "{}[{}",
+                placeholder.render(),
+                placeholder.render_reset()
+            );
+        }
+        let required = required.unwrap_or_else(|| self.is_required_set());
+        let arg_val = self.render_arg_val(required);
+        let _ = write!(
+            styled,
+            "{}{arg_val}{}",
+            placeholder.render(),
+            placeholder.render_reset()
+        );
+        if is_optional_val {
+            let _ = write!(
+                styled,
+                "{}]{}",
+                placeholder.render(),
+                placeholder.render_reset()
+            );
+        }
+
+        styled
+    }
+
     /// Write the values such as `<name1> <name2>`
     fn render_arg_val(&self, required: bool) -> String {
         let mut rendered = String::new();

clap_builder/src/builder/arg_settings.rs

@@ -50,6 +50,7 @@ pub(crate) enum ArgSettings {
     AllowHyphenValues,
     AllowNegativeNumbers,
     RequireEquals,
+    RequireNoSpace,
     Last,
     TrailingVarArg,
     HideDefaultValue,

clap_builder/src/builder/debug_asserts.rs

@@ -790,6 +790,13 @@ fn assert_arg(arg: &Arg) {
             arg.get_id(),
             num_vals
         );
+
+        assert!(
+            !arg.is_require_no_space_set(),
+            "Argument {}: cannot accept more than 1 arg (num_args={}) with require_no_space",
+            arg.get_id(),
+            num_vals
+        )
     }
 
     if num_vals == ValueRange::SINGLE {
@@ -827,6 +834,7 @@ fn assert_arg_flags(arg: &Arg) {
     checker!(is_allow_hyphen_values_set requires is_takes_value_set);
     checker!(is_allow_negative_numbers_set requires is_takes_value_set);
     checker!(is_require_equals_set requires is_takes_value_set);
+    checker!(is_require_no_space_set requires is_takes_value_set);
     checker!(is_last_set requires is_takes_value_set);
     checker!(is_hide_default_value_set requires is_takes_value_set);
     checker!(is_multiple_values_set requires is_takes_value_set);

clap_builder/src/error/format.rs

@@ -220,6 +220,20 @@ fn write_dynamic_context(
                 false
             }
         }
+        ErrorKind::SpaceFound => {
+            let invalid_arg = error.get(ContextKind::InvalidArg);
+            if let Some(ContextValue::String(invalid_arg)) = invalid_arg {
+                let _ = write!(
+                    styled,
+                    "no space is allowed when assigning values to '{}{invalid_arg}{}'",
+                    invalid.render(),
+                    invalid.render_reset()
+                );
+                true
+            } else {
+                false
+            }
+        }
         ErrorKind::InvalidValue => {
             let invalid_arg = error.get(ContextKind::InvalidArg);
             let invalid_value = error.get(ContextKind::InvalidValue);

clap_builder/src/error/kind.rs

@@ -60,7 +60,7 @@ pub enum ErrorKind {
     /// [`UnknownArgument`]: ErrorKind::UnknownArgument
     InvalidSubcommand,
 
-    /// Occurs when the user doesn't use equals for an option that requires equal
+    /// Occurs when the user doesn't use equals for a long option that requires equal
     /// sign to provide values.
     ///
     /// ```rust
@@ -77,6 +77,23 @@ pub enum ErrorKind {
     /// ```
     NoEquals,
 
+    /// Occurs when the user uses a space for a short option that requires no space
+    /// to provide values.
+    ///
+    /// ```rust
+    /// # use clap_builder as clap;
+    /// # use clap::{Command, Arg, error::ErrorKind, ArgAction};
+    /// let res = Command::new("prog")
+    ///     .arg(Arg::new("color")
+    ///          .action(ArgAction::Set)
+    ///          .require_no_space(true)
+    ///          .short('c'))
+    ///     .try_get_matches_from(vec!["prog", "-c", "red"]);
+    /// assert!(res.is_err());
+    /// assert_eq!(res.unwrap_err().kind(), ErrorKind::SpaceFound);
+    /// ```
+    SpaceFound,
+
     /// Occurs when the user provides a value for an argument with a custom validation and the
     /// value fails that validation.
     ///
@@ -338,6 +355,7 @@ impl ErrorKind {
             Self::UnknownArgument => Some("unexpected argument found"),
             Self::InvalidSubcommand => Some("unrecognized subcommand"),
             Self::NoEquals => Some("equal is needed when assigning values to one of the arguments"),
+            Self::SpaceFound => Some("no space is allowed when assigning values to one of the arguments"),
             Self::ValueValidation => Some("invalid value for one of the arguments"),
             Self::TooManyValues => Some("unexpected value for an argument found"),
             Self::TooFewValues => Some("more values required for an argument"),

clap_builder/src/error/mod.rs

@@ -439,6 +439,22 @@ impl<F: ErrorFormatter> Error<F> {
         err
     }
 
+    pub(crate) fn space_found(cmd: &Command, arg: String, usage: Option<StyledStr>) -> Self {
+        let mut err = Self::new(ErrorKind::SpaceFound).with_cmd(cmd);
+
+        #[cfg(feature = "error-context")]
+        {
+            err = err
+                .extend_context_unchecked([(ContextKind::InvalidArg, ContextValue::String(arg))]);
+            if let Some(usage) = usage {
+                err = err
+                    .insert_context_unchecked(ContextKind::Usage, ContextValue::StyledStr(usage));
+            }
+        }
+
+        err
+    }
+
     pub(crate) fn invalid_value(
         cmd: &Command,
         bad_val: String,

clap_builder/src/output/help_template.rs

@@ -498,7 +498,7 @@ impl<'cmd, 'writer> HelpTemplate<'cmd, 'writer> {
             should_show_arg(self.use_long, arg)
         }) {
             if longest_filter(arg) {
-                longest = longest.max(display_width(&arg.to_string()));
+                longest = longest.max(longest_length(arg));
                 debug!(
                     "HelpTemplate::write_args: arg={:?} longest={}",
                     arg.get_id(),
@@ -530,9 +530,15 @@ impl<'cmd, 'writer> HelpTemplate<'cmd, 'writer> {
 
         self.writer.push_str(TAB);
         self.short(arg);
+        if arg.is_require_no_space_set() && arg.get_short().is_some() {
+            self.writer
+                .push_styled(&arg.stylize_arg_no_space_suffix(self.styles, None));
+        }
         self.long(arg);
-        self.writer
-            .push_styled(&arg.stylize_arg_suffix(self.styles, None));
+        if arg.get_long().is_some() || !arg.is_require_no_space_set() {
+            self.writer
+                .push_styled(&arg.stylize_arg_suffix(self.styles, None));
+        }
         self.align_to_about(arg, next_line_help, longest);
 
         let about = if self.use_long {
@@ -598,7 +604,7 @@ impl<'cmd, 'writer> HelpTemplate<'cmd, 'writer> {
             debug!("HelpTemplate::align_to_about: printing long help so skip alignment");
             0
         } else if !arg.is_positional() {
-            let self_len = display_width(&arg.to_string());
+            let self_len = longest_length(arg);
             // Since we're writing spaces from the tab point we first need to know if we
             // had a long and short, or just short
             let padding = if arg.get_long().is_some() {
@@ -615,7 +621,7 @@ impl<'cmd, 'writer> HelpTemplate<'cmd, 'writer> {
 
             spcs
         } else {
-            let self_len = display_width(&arg.to_string());
+            let self_len = longest_length(arg);
             let padding = TAB_WIDTH;
             let spcs = longest + padding - self_len;
             debug!(
@@ -1158,6 +1164,16 @@ fn longest_filter(arg: &Arg) -> bool {
     arg.is_takes_value_set() || arg.get_long().is_some() || arg.get_short().is_none()
 }
 
+fn longest_length(arg: &Arg) -> usize {
+    let mut len = display_width(&arg.to_string());
+    if arg.is_require_no_space_set() && arg.get_short().is_some() && arg.get_long().is_some() {
+        len += arg
+            .stylize_arg_no_space_suffix(&Styles::plain(), None)
+            .display_width();
+    }
+    len
+}
+
 #[cfg(test)]
 mod test {
     #[test]