numfmt: fix error message with unit separator and trailing garbage

GNU test: numfmt.pl unit-sep-22-fail

Author: sylvestre

src/uu/numfmt/src/format.rs

@@ -70,7 +70,7 @@ fn find_valid_number_with_suffix(s: &str, unit: Unit) -> Option<&str> {
     }
 }
 
-fn detailed_error_message(s: &str, unit: Unit) -> Option<String> {
+fn detailed_error_message(s: &str, unit: Unit, unit_separator: &str) -> Option<String> {
     if s.is_empty() {
         return Some(translate!("numfmt-error-invalid-number-empty"));
     }
@@ -87,6 +87,41 @@ fn detailed_error_message(s: &str, unit: Unit) -> Option<String> {
         return Some(translate!("numfmt-error-invalid-number", "input" => s.quote()));
     }
 
+    // When a unit separator is in use, the valid part may extend beyond the
+    // contiguous number+suffix found by find_valid_number_with_suffix.
+    // For example "5 K Field2" with unit_separator=" " has valid_part="5" but
+    // the real valid prefix is "5 K"; the trailing " Field2" is the garbage.
+    let valid_end =
+        if !unit_separator.is_empty() && valid_part == find_numeric_beginning(s).unwrap_or("") {
+            let rest = &s[valid_part.len()..];
+            if let Some(after_sep) = rest.strip_prefix(unit_separator) {
+                // Check if the next char is a valid suffix letter
+                let mut chars = after_sep.chars();
+                let has_suffix = chars
+                    .next()
+                    .is_some_and(|c| RawSuffix::try_from(&c).is_ok());
+                if has_suffix {
+                    let suffix_char_len = 1;
+                    let with_i =
+                        chars.next() == Some('i') && [Unit::Auto, Unit::Iec(true)].contains(&unit);
+                    let suffix_len = if with_i {
+                        suffix_char_len + 1
+                    } else {
+                        suffix_char_len
+                    };
+                    valid_part.len() + unit_separator.len() + suffix_len
+                } else {
+                    valid_part.len()
+                }
+            } else {
+                valid_part.len()
+            }
+        } else {
+            valid_part.len()
+        };
+
+    let valid_part = &s[..valid_end];
+
     if valid_part != s && valid_part.parse::<f64>().is_ok() {
         return match s.chars().nth(valid_part.len()) {
             Some('+' | '-') => {
@@ -100,9 +135,10 @@ fn detailed_error_message(s: &str, unit: Unit) -> Option<String> {
         };
     }
 
-    if valid_part != s && valid_part.parse::<f64>().is_err() {
+    if valid_part != s {
+        let trailing = s[valid_part.len()..].trim_start();
         return Some(
-            translate!("numfmt-error-invalid-specific-suffix", "input" => s.quote(), "suffix" => s[valid_part.len()..].quote()),
+            translate!("numfmt-error-invalid-specific-suffix", "input" => s.quote(), "suffix" => trailing.quote()),
         );
     }
     None
@@ -367,7 +403,9 @@ fn transform_from(s: &str, opts: &TransformOptions, options: &NumfmtOptions) ->
         &options.unit_separator,
         options.explicit_unit_separator,
     )
-    .map_err(|original| detailed_error_message(s, opts.from).unwrap_or(original))?;
+    .map_err(|original| {
+        detailed_error_message(s, opts.from, &options.unit_separator).unwrap_or(original)
+    })?;
     let i = i * (opts.from_unit as f64);
 
     remove_suffix(i, suffix, opts.from).map(|n| {
@@ -818,20 +856,20 @@ mod tests {
 
     #[test]
     fn test_detailed_error_message() {
-        let result = detailed_error_message("123i", Unit::Auto);
+        let result = detailed_error_message("123i", Unit::Auto, "");
         assert!(result.is_some());
         let error = result.unwrap();
         assert!(error.contains("numfmt-error-invalid-suffix") || error.contains("invalid suffix"));
 
-        let result = detailed_error_message("5MF", Unit::Auto);
+        let result = detailed_error_message("5MF", Unit::Auto, "");
         assert!(result.is_some());
         let error = result.unwrap();
         assert!(
             error.contains("numfmt-error-invalid-specific-suffix")
                 || error.contains("invalid suffix")
         );
 
-        let result = detailed_error_message("5KM", Unit::Auto);
+        let result = detailed_error_message("5KM", Unit::Auto, "");
         assert!(result.is_some());
         let error = result.unwrap();
         assert!(