Merging upstream version 1.72.1+dfsg1.

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

6 files changed, 74 insertions, 86 deletions

diff --git a/vendor/clap_builder/src/output/help_template.rs b/vendor/clap_builder/src/output/help_template.rs
index 86a61169c..68ff58077 100644
--- a/vendor/clap_builder/src/output/help_template.rs
+++ b/vendor/clap_builder/src/output/help_template.rs
@@ -450,9 +450,10 @@ impl<'cmd, 'writer> HelpTemplate<'cmd, 'writer> {
             }
         }
     }
+
     /// Sorts arguments by length and display order and write their help to the wrapped stream.
     fn write_args(&mut self, args: &[&Arg], _category: &str, sort_key: ArgSortKey) {
-        debug!("HelpTemplate::write_args {}", _category);
+        debug!("HelpTemplate::write_args {_category}");
         // The shortest an arg can legally be is 2 (i.e. '-x')
         let mut longest = 2;
         let mut ord_v = Vec::new();
@@ -577,8 +578,7 @@ impl<'cmd, 'writer> HelpTemplate<'cmd, 'writer> {
             };
             let spcs = longest + padding - self_len;
             debug!(
-                "HelpTemplate::align_to_about: positional=false arg_len={}, spaces={}",
-                self_len, spcs
+                "HelpTemplate::align_to_about: positional=false arg_len={self_len}, spaces={spcs}"
             );
 
             spcs
@@ -587,8 +587,7 @@ impl<'cmd, 'writer> HelpTemplate<'cmd, 'writer> {
             let padding = TAB_WIDTH;
             let spcs = longest + padding - self_len;
             debug!(
-                "HelpTemplate::align_to_about: positional=true arg_len={}, spaces={}",
-                self_len, spcs
+                "HelpTemplate::align_to_about: positional=true arg_len={self_len}, spaces={spcs}",
             );
 
             spcs
@@ -612,7 +611,7 @@ impl<'cmd, 'writer> HelpTemplate<'cmd, 'writer> {
 
         // Is help on next line, if so then indent
         if next_line_help {
-            debug!("HelpTemplate::help: Next Line...{:?}", next_line_help);
+            debug!("HelpTemplate::help: Next Line...{next_line_help:?}");
             self.writer.push_str("\n");
             self.writer.push_str(TAB);
             self.writer.push_str(NEXT_LINE_INDENT);
@@ -654,38 +653,21 @@ impl<'cmd, 'writer> HelpTemplate<'cmd, 'writer> {
         self.writer.push_styled(&help);
         if let Some(arg) = arg {
             const DASH_SPACE: usize = "- ".len();
-            const COLON_SPACE: usize = ": ".len();
             let possible_vals = arg.get_possible_values();
-            if self.use_long
+            if !possible_vals.is_empty()
                 && !arg.is_hide_possible_values_set()
-                && possible_vals.iter().any(PossibleValue::should_show_help)
+                && self.use_long_pv(arg)
             {
-                debug!(
-                    "HelpTemplate::help: Found possible vals...{:?}",
-                    possible_vals
-                );
+                debug!("HelpTemplate::help: Found possible vals...{possible_vals:?}");
                 let longest = possible_vals
                     .iter()
-                    .filter_map(|f| f.get_visible_quoted_name().map(|name| display_width(&name)))
+                    .filter(|f| !f.is_hide_set())
+                    .map(|f| display_width(f.get_name()))
                     .max()
                     .expect("Only called with possible value");
-                let help_longest = possible_vals
-                    .iter()
-                    .filter_map(|f| f.get_visible_help().map(|h| h.display_width()))
-                    .max()
-                    .expect("Only called with possible value with help");
-                // should new line
-                let taken = longest + spaces + DASH_SPACE;
-
-                let possible_value_new_line =
-                    self.term_w >= taken && self.term_w < taken + COLON_SPACE + help_longest;
 
                 let spaces = spaces + TAB_WIDTH - DASH_SPACE;
-                let trailing_indent = if possible_value_new_line {
-                    spaces + DASH_SPACE
-                } else {
-                    spaces + longest + DASH_SPACE + COLON_SPACE
-                };
+                let trailing_indent = spaces + DASH_SPACE;
                 let trailing_indent = self.get_spaces(trailing_indent);
 
                 if !help_is_empty {
@@ -704,14 +686,9 @@ impl<'cmd, 'writer> HelpTemplate<'cmd, 'writer> {
                     if let Some(help) = pv.get_help() {
                         debug!("HelpTemplate::help: Possible Value help");
 
-                        if possible_value_new_line {
-                            let padding = trailing_indent.len();
-                            let _ = write!(self.writer, ":\n{:padding$}", "");
-                        } else {
-                            // To align help messages
-                            let padding = longest - display_width(pv.get_name());
-                            let _ = write!(self.writer, ": {:padding$}", "");
-                        }
+                        // To align help messages
+                        let padding = longest - display_width(pv.get_name());
+                        let _ = write!(self.writer, ": {:padding$}", "");
 
                         let avail_chars = if self.term_w > trailing_indent.len() {
                             self.term_w - trailing_indent.len()
@@ -760,7 +737,7 @@ impl<'cmd, 'writer> HelpTemplate<'cmd, 'writer> {
     }
 
     fn spec_vals(&self, a: &Arg) -> String {
-        debug!("HelpTemplate::spec_vals: a={}", a);
+        debug!("HelpTemplate::spec_vals: a={a}");
         let mut spec_vals = Vec::new();
         #[cfg(feature = "env")]
         if let Some(ref env) = a.env {
@@ -835,14 +812,8 @@ impl<'cmd, 'writer> HelpTemplate<'cmd, 'writer> {
         }
 
         let possible_vals = a.get_possible_values();
-        if !(a.is_hide_possible_values_set()
-            || possible_vals.is_empty()
-            || self.use_long && possible_vals.iter().any(PossibleValue::should_show_help))
-        {
-            debug!(
-                "HelpTemplate::spec_vals: Found possible vals...{:?}",
-                possible_vals
-            );
+        if !possible_vals.is_empty() && !a.is_hide_possible_values_set() && !self.use_long_pv(a) {
+            debug!("HelpTemplate::spec_vals: Found possible vals...{possible_vals:?}");
 
             let pvs = possible_vals
                 .iter()
@@ -864,6 +835,14 @@ impl<'cmd, 'writer> HelpTemplate<'cmd, 'writer> {
         use std::fmt::Write as _;
         let _ = write!(self.writer, "{:amount$}", "");
     }
+
+    fn use_long_pv(&self, arg: &Arg) -> bool {
+        self.use_long
+            && arg
+                .get_possible_values()
+                .iter()
+                .any(PossibleValue::should_show_help)
+    }
 }
 
 /// Subcommand handling
@@ -910,15 +889,12 @@ impl<'cmd, 'writer> HelpTemplate<'cmd, 'writer> {
         }
         ord_v.sort_by(|a, b| (a.0, &a.1).cmp(&(b.0, &b.1)));
 
-        debug!("HelpTemplate::write_subcommands longest = {}", longest);
+        debug!("HelpTemplate::write_subcommands longest = {longest}");
 
         let next_line_help = self.will_subcommands_wrap(cmd.get_subcommands(), longest);
 
-        let mut first = true;
-        for (_, sc_str, sc) in ord_v {
-            if first {
-                first = false;
-            } else {
+        for (i, (_, sc_str, sc)) in ord_v.into_iter().enumerate() {
+            if 0 < i {
                 self.writer.push_str("\n");
             }
             self.write_subcommand(sc_str, sc, next_line_help, longest);
@@ -987,7 +963,8 @@ impl<'cmd, 'writer> HelpTemplate<'cmd, 'writer> {
     }
 
     fn subcommand_next_line_help(&self, cmd: &Command, spec_vals: &str, longest: usize) -> bool {
-        if self.next_line_help | self.use_long {
+        // Ignore `self.use_long` since subcommands are only shown as short help
+        if self.next_line_help {
             // setting_next_line
             true
         } else {
diff --git a/vendor/clap_builder/src/output/textwrap/core.rs b/vendor/clap_builder/src/output/textwrap/core.rs
index 25c9eb6b0..2f6004c71 100644
--- a/vendor/clap_builder/src/output/textwrap/core.rs
+++ b/vendor/clap_builder/src/output/textwrap/core.rs
@@ -102,7 +102,7 @@ mod tests {
                 let desc = format!("{:?} U+{:04X}", ch, ch as u32);
 
                 #[cfg(feature = "unicode")]
-                assert_eq!(ch.width().unwrap(), 1, "char: {}", desc);
+                assert_eq!(ch.width().unwrap(), 1, "char: {desc}");
 
                 #[cfg(not(feature = "unicode"))]
                 assert_eq!(ch_width(ch), 1, "char: {desc}");
@@ -120,7 +120,7 @@ mod tests {
                 let desc = format!("{:?} U+{:04X}", ch, ch as u32);
 
                 #[cfg(feature = "unicode")]
-                assert!(ch.width().unwrap() <= 2, "char: {}", desc);
+                assert!(ch.width().unwrap() <= 2, "char: {desc}");
 
                 #[cfg(not(feature = "unicode"))]
                 assert_eq!(ch_width(ch), 1, "char: {desc}");
diff --git a/vendor/clap_builder/src/output/textwrap/mod.rs b/vendor/clap_builder/src/output/textwrap/mod.rs
index d14d3fe7f..fe8139f1a 100644
--- a/vendor/clap_builder/src/output/textwrap/mod.rs
+++ b/vendor/clap_builder/src/output/textwrap/mod.rs
@@ -83,7 +83,7 @@ mod test {
 
     #[test]
     fn leading_whitespace() {
-        assert_eq!(wrap("  foo bar", 6), vec!["  foo", "bar"]);
+        assert_eq!(wrap("  foo bar", 6), vec!["  foo", "  bar"]);
     }
 
     #[test]
@@ -92,7 +92,7 @@ mod test {
         // will be empty. This is because the string is split into
         // words like [" ", "foobar ", "baz"], which puts "foobar " on
         // the second line. We never output trailing whitespace
-        assert_eq!(wrap(" foobar baz", 6), vec!["", "foobar", "baz"]);
+        assert_eq!(wrap(" foobar baz", 6), vec!["", " foobar", " baz"]);
     }
 
     #[test]
diff --git a/vendor/clap_builder/src/output/textwrap/word_separators.rs b/vendor/clap_builder/src/output/textwrap/word_separators.rs
index ac09231d5..cb8250b60 100644
--- a/vendor/clap_builder/src/output/textwrap/word_separators.rs
+++ b/vendor/clap_builder/src/output/textwrap/word_separators.rs
@@ -5,14 +5,15 @@ pub(crate) fn find_words_ascii_space(line: &str) -> impl Iterator<Item = &'_ str
 
     std::iter::from_fn(move || {
         for (idx, ch) in char_indices.by_ref() {
-            if in_whitespace && ch != ' ' {
+            let next_whitespace = ch == ' ';
+            if in_whitespace && !next_whitespace {
                 let word = &line[start..idx];
                 start = idx;
-                in_whitespace = ch == ' ';
+                in_whitespace = next_whitespace;
                 return Some(word);
             }
 
-            in_whitespace = ch == ' ';
+            in_whitespace = next_whitespace;
         }
 
         if start < line.len() {
diff --git a/vendor/clap_builder/src/output/textwrap/wrap_algorithms.rs b/vendor/clap_builder/src/output/textwrap/wrap_algorithms.rs
index 019cc04ff..34b4fd2b7 100644
--- a/vendor/clap_builder/src/output/textwrap/wrap_algorithms.rs
+++ b/vendor/clap_builder/src/output/textwrap/wrap_algorithms.rs
@@ -1,24 +1,37 @@
 use super::core::display_width;
 
 #[derive(Debug)]
-pub(crate) struct LineWrapper {
-    line_width: usize,
+pub(crate) struct LineWrapper<'w> {
     hard_width: usize,
+    line_width: usize,
+    carryover: Option<&'w str>,
 }
 
-impl LineWrapper {
+impl<'w> LineWrapper<'w> {
     pub(crate) fn new(hard_width: usize) -> Self {
         Self {
-            line_width: 0,
             hard_width,
+            line_width: 0,
+            carryover: None,
         }
     }
 
     pub(crate) fn reset(&mut self) {
         self.line_width = 0;
+        self.carryover = None;
     }
 
-    pub(crate) fn wrap<'w>(&mut self, mut words: Vec<&'w str>) -> Vec<&'w str> {
+    pub(crate) fn wrap(&mut self, mut words: Vec<&'w str>) -> Vec<&'w str> {
+        if self.carryover.is_none() {
+            if let Some(word) = words.first() {
+                if word.trim().is_empty() {
+                    self.carryover = Some(*word);
+                } else {
+                    self.carryover = Some("");
+                }
+            }
+        }
+
         let mut i = 0;
         while i < words.len() {
             let word = &words[i];
@@ -31,9 +44,15 @@ impl LineWrapper {
                     let trimmed = words[last].trim_end();
                     words[last] = trimmed;
                 }
+
+                self.line_width = 0;
                 words.insert(i, "\n");
                 i += 1;
-                self.reset();
+                if let Some(carryover) = self.carryover {
+                    words.insert(i, carryover);
+                    self.line_width += carryover.len();
+                    i += 1;
+                }
             }
             self.line_width += word_width + trimmed_delta;
 
diff --git a/vendor/clap_builder/src/output/usage.rs b/vendor/clap_builder/src/output/usage.rs
index dd99c63c7..3f387a0d7 100644
--- a/vendor/clap_builder/src/output/usage.rs
+++ b/vendor/clap_builder/src/output/usage.rs
@@ -79,7 +79,7 @@ impl<'cmd> Usage<'cmd> {
 impl<'cmd> Usage<'cmd> {
     // Creates a usage string for display in help messages (i.e. not for errors)
     fn create_help_usage(&self, incl_reqs: bool) -> StyledStr {
-        debug!("Usage::create_help_usage; incl_reqs={:?}", incl_reqs);
+        debug!("Usage::create_help_usage; incl_reqs={incl_reqs:?}");
         use std::fmt::Write as _;
         let literal = &self.styles.get_literal();
         let placeholder = &self.styles.get_placeholder();
@@ -157,7 +157,7 @@ impl<'cmd> Usage<'cmd> {
             }
         }
         styled.trim();
-        debug!("Usage::create_help_usage: usage={}", styled);
+        debug!("Usage::create_help_usage: usage={styled}");
         styled
     }
 
@@ -220,7 +220,7 @@ impl<'cmd> Usage<'cmd> {
                 continue;
             }
             for grp_s in self.cmd.groups_for_arg(f.get_id()) {
-                debug!("Usage::needs_options_tag:iter:iter: grp_s={:?}", grp_s);
+                debug!("Usage::needs_options_tag:iter:iter: grp_s={grp_s:?}");
                 if self.cmd.get_groups().any(|g| g.id == grp_s && g.required) {
                     debug!("Usage::needs_options_tag:iter:iter: Group is required");
                     continue 'outer;
@@ -244,7 +244,7 @@ impl<'cmd> Usage<'cmd> {
     }
 
     pub(crate) fn get_args(&self, incls: &[Id], force_optional: bool) -> Vec<StyledStr> {
-        debug!("Usage::get_args: incls={:?}", incls,);
+        debug!("Usage::get_args: incls={incls:?}",);
         use std::fmt::Write as _;
         let literal = &self.styles.get_literal();
 
@@ -275,7 +275,7 @@ impl<'cmd> Usage<'cmd> {
             // by unroll_requirements_for_arg.
             unrolled_reqs.push(a.clone());
         }
-        debug!("Usage::get_args: unrolled_reqs={:?}", unrolled_reqs);
+        debug!("Usage::get_args: unrolled_reqs={unrolled_reqs:?}");
 
         let mut required_groups_members = FlatSet::new();
         let mut required_groups = FlatSet::new();
@@ -360,7 +360,7 @@ impl<'cmd> Usage<'cmd> {
             ret_val.push(pos);
         }
 
-        debug!("Usage::get_args: ret_val={:?}", ret_val);
+        debug!("Usage::get_args: ret_val={ret_val:?}");
         ret_val
     }
 
@@ -410,10 +410,7 @@ impl<'cmd> Usage<'cmd> {
             // by unroll_requirements_for_arg.
             unrolled_reqs.push(a.clone());
         }
-        debug!(
-            "Usage::get_required_usage_from: unrolled_reqs={:?}",
-            unrolled_reqs
-        );
+        debug!("Usage::get_required_usage_from: unrolled_reqs={unrolled_reqs:?}");
 
         let mut required_groups_members = FlatSet::new();
         let mut required_groups = FlatSet::new();
@@ -427,10 +424,7 @@ impl<'cmd> Usage<'cmd> {
                             .any(|arg| m.check_explicit(arg, &ArgPredicate::IsPresent))
                     })
                     .unwrap_or(false);
-                debug!(
-                    "Usage::get_required_usage_from:iter:{:?} group is_present={}",
-                    req, is_present
-                );
+                debug!("Usage::get_required_usage_from:iter:{req:?} group is_present={is_present}");
                 if is_present {
                     continue;
                 }
@@ -439,7 +433,7 @@ impl<'cmd> Usage<'cmd> {
                 required_groups.insert(elem);
                 required_groups_members.extend(group_members);
             } else {
-                debug_assert!(self.cmd.find(req).is_some());
+                debug_assert!(self.cmd.find(req).is_some(), "`{req}` must exist");
             }
         }
 
@@ -454,10 +448,7 @@ impl<'cmd> Usage<'cmd> {
                 let is_present = matcher
                     .map(|m| m.check_explicit(req, &ArgPredicate::IsPresent))
                     .unwrap_or(false);
-                debug!(
-                    "Usage::get_required_usage_from:iter:{:?} arg is_present={}",
-                    req, is_present
-                );
+                debug!("Usage::get_required_usage_from:iter:{req:?} arg is_present={is_present}");
                 if is_present {
                     continue;
                 }
@@ -486,7 +477,7 @@ impl<'cmd> Usage<'cmd> {
             ret_val.push(pos);
         }
 
-        debug!("Usage::get_required_usage_from: ret_val={:?}", ret_val);
+        debug!("Usage::get_required_usage_from: ret_val={ret_val:?}");
         ret_val
     }
 }