fix try

sylvestre · sylvestre · commit 45edcc4d3a0b · 2025-08-12T10:10:49.000+02:00
diff --git a/src/uucore/src/lib/mods/clap_localization.rs b/src/uucore/src/lib/mods/clap_localization.rs
@@ -12,23 +12,99 @@ use clap::error::{ContextKind, ErrorKind};
 use clap::{ArgMatches, Command, Error};
 use std::ffi::OsString;
 
+/// Determines if a clap error should show simple help instead of full usage
+/// Based on clap's own design patterns and error categorization
+fn should_show_simple_help_for_clap_error(kind: ErrorKind) -> bool {
+    match kind {
+        // Most validation errors should show simple help
+        ErrorKind::InvalidValue
+        | ErrorKind::InvalidSubcommand
+        | ErrorKind::ValueValidation
+        | ErrorKind::InvalidUtf8
+        | ErrorKind::ArgumentConflict
+        | ErrorKind::NoEquals => true,
+
+        // Argument count and structural errors need special formatting
+        ErrorKind::TooFewValues
+        | ErrorKind::TooManyValues
+        | ErrorKind::WrongNumberOfValues
+        | ErrorKind::MissingSubcommand => false,
+
+        // MissingRequiredArgument needs different handling
+        ErrorKind::MissingRequiredArgument => false,
+
+        // Special cases - handle their own display
+        ErrorKind::DisplayHelp
+        | ErrorKind::DisplayHelpOnMissingArgumentOrSubcommand
+        | ErrorKind::DisplayVersion => false,
+
+        // UnknownArgument gets special handling elsewhere, so mark as false here
+        ErrorKind::UnknownArgument => false,
+
+        // System errors - keep simple
+        ErrorKind::Io | ErrorKind::Format => true,
+
+        // Default for any new ErrorKind variants - be conservative and show simple help
+        _ => true,
+    }
+}
+
+/// Color enum for consistent styling
+#[derive(Debug, Clone, Copy)]
+pub enum Color {
+    Red,
+    Yellow,
+    Green,
+}
+
+impl Color {
+    fn code(self) -> &'static str {
+        match self {
+            Color::Red => "31",
+            Color::Yellow => "33",
+            Color::Green => "32",
+        }
+    }
+}
+
 /// Apply color to text using ANSI escape codes
-fn colorize(text: &str, color_code: &str) -> String {
-    format!("\x1b[{color_code}m{text}\x1b[0m")
+fn colorize(text: &str, color: Color) -> String {
+    format!("\x1b[{}m{text}\x1b[0m", color.code())
 }
 
-/// Color constants for consistent styling
-pub mod colors {
-    pub const RED: &str = "31";
-    pub const YELLOW: &str = "33";
-    pub const GREEN: &str = "32";
+/// Display usage information and help suggestion for errors that require it
+/// This consolidates the shared logic between clap errors and UUsageError
+pub fn display_usage_and_help(util_name: &str) {
+    eprintln!();
+    // Try to get usage information from localization
+    let usage_key = format!("{}-usage", util_name);
+    let usage_text = translate!(&usage_key);
+    let formatted_usage = crate::format_usage(&usage_text);
+    let usage_label = translate!("common-usage");
+    eprintln!("{}: {}", usage_label, formatted_usage);
+    eprintln!();
+    let help_msg = translate!("common-help-suggestion", "command" => crate::execution_phrase());
+    eprintln!("{help_msg}");
 }
 
 pub fn handle_clap_error_with_exit_code(err: Error, util_name: &str, exit_code: i32) -> ! {
     // Try to ensure localization is initialized for this utility
     // If it's already initialized, that's fine - we'll use the existing one
     let _ = crate::locale::setup_localization_with_common(util_name);
 
+    // Check if colors are enabled by examining clap's rendered output
+    let rendered_str = err.render().to_string();
+    let colors_enabled = rendered_str.contains("\x1b[");
+
+    // Helper function to conditionally colorize text
+    let maybe_colorize = |text: &str, color: Color| -> String {
+        if colors_enabled {
+            colorize(text, color)
+        } else {
+            text.to_string()
+        }
+    };
+
     match err.kind() {
         ErrorKind::DisplayHelp | ErrorKind::DisplayVersion => {
             // For help and version, use clap's built-in formatting and exit with 0
@@ -37,33 +113,17 @@ pub fn handle_clap_error_with_exit_code(err: Error, util_name: &str, exit_code:
             std::process::exit(0);
         }
         ErrorKind::UnknownArgument => {
-            // Use clap's rendering system but capture the output to check if colors are used
-            let rendered = err.render();
-            let rendered_str = rendered.to_string();
-
-            // Simple check - if the rendered output contains ANSI escape codes, colors are enabled
-            let colors_enabled = rendered_str.contains("\x1b[");
-
-            // Helper closure to conditionally apply colors
-            let apply_color = |text: &str, color: &str| {
-                if colors_enabled {
-                    colorize(text, color)
-                } else {
-                    text.to_string()
-                }
-            };
-
+            // UnknownArgument gets special handling for suggestions, but should still show simple help
             if let Some(invalid_arg) = err.get(ContextKind::InvalidArg) {
                 let arg_str = invalid_arg.to_string();
 
                 // Get the uncolored words from common strings
                 let error_word = translate!("common-error");
                 let tip_word = translate!("common-tip");
 
-                // Apply colors using helper closure
-                let colored_arg = apply_color(&arg_str, colors::YELLOW);
-                let colored_error_word = apply_color(&error_word, colors::RED);
-                let colored_tip_word = apply_color(&tip_word, colors::GREEN);
+                let colored_arg = maybe_colorize(&arg_str, Color::Yellow);
+                let colored_error_word = maybe_colorize(&error_word, Color::Red);
+                let colored_tip_word = maybe_colorize(&tip_word, Color::Green);
 
                 // Print main error message
                 let error_msg = translate!(
@@ -77,15 +137,17 @@ pub fn handle_clap_error_with_exit_code(err: Error, util_name: &str, exit_code:
                 // Show suggestion or generic tip
                 let suggestion = err.get(ContextKind::SuggestedArg);
                 if let Some(suggested_arg) = suggestion {
-                    let colored_suggestion = apply_color(&suggested_arg.to_string(), colors::GREEN);
+                    let colored_suggestion =
+                        maybe_colorize(&suggested_arg.to_string(), Color::Green);
                     let suggestion_msg = translate!(
                         "clap-error-similar-argument",
                         "tip_word" => colored_tip_word,
                         "suggestion" => colored_suggestion
                     );
                     eprintln!("  {suggestion_msg}");
                 } else {
-                    let colored_tip_command = apply_color(&format!("-- {arg_str}"), colors::GREEN);
+                    let colored_tip_command =
+                        maybe_colorize(&format!("-- {arg_str}"), Color::Green);
                     let tip_msg = translate!(
                         "clap-error-pass-as-value",
                         "arg" => colored_arg,
@@ -95,28 +157,56 @@ pub fn handle_clap_error_with_exit_code(err: Error, util_name: &str, exit_code:
                     eprintln!("  {tip_msg}");
                 }
 
-                // Show usage and help
+                // Show usage information for unknown arguments but use simple --help format
                 eprintln!();
+                // Try to get usage information from localization
+                let usage_key = format!("{}-usage", util_name);
+                let usage_text = translate!(&usage_key);
+                let formatted_usage = crate::format_usage(&usage_text);
                 let usage_label = translate!("common-usage");
-                let usage_pattern = translate!(&format!("{util_name}-usage"));
-                eprintln!("{usage_label}: {usage_pattern}");
+                eprintln!("{}: {}", usage_label, formatted_usage);
                 eprintln!();
-
-                let help_msg = translate!("clap-error-help-suggestion", "command" => util_name);
-                eprintln!("{help_msg}");
+                // Use simple --help format for GNU test compatibility
+                eprintln!("For more information, try '--help'.");
 
                 std::process::exit(exit_code);
             } else {
-                // Generic fallback case - reuse colors_enabled and apply_color from above scope
-                let colored_error_word = apply_color(&translate!("common-error"), colors::RED);
+                // Generic fallback case
+                let colored_error_word = maybe_colorize(&translate!("common-error"), Color::Red);
                 eprintln!("{colored_error_word}: unexpected argument");
                 std::process::exit(exit_code);
             }
         }
+        // Check if this is a simple validation error that should show simple help
+        kind if should_show_simple_help_for_clap_error(kind) => {
+            // For simple validation errors, use the same simple format as other errors
+            let lines: Vec<&str> = rendered_str.lines().collect();
+            if let Some(main_error_line) = lines.first() {
+                // Keep the "error: " prefix for test compatibility
+                eprintln!("{}", main_error_line);
+
+                // Use the execution phrase for the help suggestion to match test expectations
+                eprintln!("For more information, try '--help'");
+            } else {
+                // Fallback to original rendering if we can't parse
+                eprint!("{}", err.render());
+            }
+            std::process::exit(exit_code);
+        }
         _ => {
-            // For other errors, print using clap's formatter but exit with code 1
-            eprint!("{}", err.render());
-            std::process::exit(1);
+            // For other errors, use the simple format but with original clap wording
+            let rendered_str = err.render().to_string();
+            let lines: Vec<&str> = rendered_str.lines().collect();
+
+            // Print error message (first line)
+            if let Some(first_line) = lines.first() {
+                eprintln!("{}", first_line);
+            }
+
+            // Always use the expected test format for help
+            eprintln!("For more information, try '--help'");
+
+            std::process::exit(exit_code);
         }
     }
 }
diff --git a/tests/test_util_name.rs b/tests/test_util_name.rs
@@ -36,6 +36,7 @@ fn execution_phrase_double() {
     let output = Command::new(&scenario.bin_path)
         .arg("ls")
         .arg("--some-invalid-arg")
+        .env("LANG", "en_US.UTF-8")
         .output()
         .unwrap();
     assert!(
