Feat: Allow shortened options

Allow --he for help or --l for list.
This is based on PR uutils#11367

Author: Gunter Schmidt

src/bin/coreutils.rs

@@ -8,7 +8,6 @@ use coreutils::validation;
 use itertools::Itertools as _;
 use std::cmp;
 use std::ffi::OsString;
-use std::io::{self, Write};
 use std::process;
 use uucore::Args;
 
@@ -49,13 +48,9 @@ fn usage<T>(utils: &UtilityMap<T>, name: &str) {
 ///     'my_own_directory_service_ls' as long as the last letters match the utility.
 /// * coreutils arg: --list, --version, -V, --help, -h (or shortened long versions): \
 ///   Output information about coreutils itself. \
-///   Multiple of these arguments, output limited to one, with help > version > list.
 /// * util name and any number of arguments: \
 ///   Will get passed on to the selected utility. \
 ///   Error if util name is not recognized.
-/// * --help or -h and a following util name: \
-///   Output help for that specific utility. \
-///   So 'coreutils sum --help' is the same as 'coreutils --help sum'.
 #[allow(clippy::cognitive_complexity)]
 fn main() {
     uucore::panic::mute_sigpipe_panic();
@@ -86,59 +81,49 @@ fn main() {
         validation::not_found(&OsString::from(binary_as_util));
     };
 
-    // 0th argument equals util name?
+    // 0th/1st argument equals util name?
     if let Some(util_os) = util_name {
         let Some(util) = util_os.to_str() else {
+            // Not UTF-8
             validation::not_found(&util_os)
         };
 
-        #[allow(clippy::single_match_else)]
-        match utils.get(util) {
-            Some(&(uumain, _)) => {
-                // TODO: plug the deactivation of the translation
-                // and load the English strings directly at compilation time in the
-                // binary to avoid the load of the flt
-                // Could be something like:
-                // #[cfg(not(feature = "only_english"))]
-                validation::setup_localization_or_exit(util);
-                process::exit(uumain(vec![util_os].into_iter().chain(args)));
-            }
-            None => {
-                let (option, help_util) = find_dominant_option(&util_os, &mut args);
-                match option {
-                    SelectedOption::Help => match help_util {
-                        // see if they want help on a specific util and if it is valid
-                        Some(u_os) => match utils.get(&u_os.to_string_lossy()) {
-                            Some(&(uumain, _)) => {
-                                let code = uumain(
-                                    vec![u_os, OsString::from("--help")]
-                                        .into_iter()
-                                        // Function requires a chain like in the Some case, but
-                                        // the args are discarded as clap returns help immediately.
-                                        .chain(args),
-                                );
-                                io::stdout().flush().expect("could not flush stdout");
-                                process::exit(code);
-                            }
-                            None => validation::not_found(&u_os),
-                        },
-                        // show coreutils help
-                        None => usage(&utils, binary_as_util),
-                    },
-                    SelectedOption::Version => {
-                        println!("{binary_as_util} {VERSION} (multi-call binary)");
-                    }
-                    SelectedOption::List => {
-                        let utils: Vec<_> = utils.keys().collect();
-                        for util in utils {
-                            println!("{util}");
-                        }
-                    }
-                    SelectedOption::Unrecognized(arg) => {
-                        // Argument looks like an option but wasn't recognized
-                        validation::unrecognized_option(binary_as_util, &arg);
-                    }
+        // Util in known list?
+        if let Some(&(uumain, _)) = utils.get(util) {
+            // TODO: plug the deactivation of the translation
+            // and load the English strings directly at compilation time in the
+            // binary to avoid the load of the flt
+            // Could be something like:
+            // #[cfg(not(feature = "only_english"))]
+            validation::setup_localization_or_exit(util);
+            process::exit(uumain(vec![util_os].into_iter().chain(args)));
+        } else {
+            let l = util.len();
+            // GNU coreutils --help string shows help for coreutils
+            if util == "-h" || (l <= 6 && util[0..l] == "--help"[0..l]) {
+                usage(&utils, binary_as_util);
+                process::exit(0);
+            // GNU coreutils --list string shows available utilities as list
+            } else if l <= 6 && util[0..l] == "--list"[0..l] {
+                // If --help is also present, show usage instead of list
+                if args.any(|arg| arg == "--help" || arg == "-h") {
+                    usage(&utils, binary_as_util);
+                    process::exit(0);
+                }
+                let utils: Vec<_> = utils.keys().collect();
+                for util in utils {
+                    println!("{util}");
                 }
+                process::exit(0);
+            // GNU coreutils --version string shows version
+            } else if util == "-V" || (l <= 9 && util[0..l] == "--version"[0..l]) {
+                println!("{binary_as_util} {VERSION} (multi-call binary)");
+                process::exit(0);
+            } else if util.starts_with('-') {
+                // Argument looks like an option but wasn't recognized
+                validation::unrecognized_option(binary_as_util, &util_os);
+            } else {
+                validation::not_found(&util_os);
             }
         }
     } else {
@@ -147,91 +132,3 @@ fn main() {
         process::exit(0);
     }
 }
-
-/// All defined coreutils options.
-// Important: when changing then adapt also [identify_option_from_partial_text]
-// as it works with the indices of this array.
-const COREUTILS_OPTIONS: [&str; 5] = ["--help", "--list", "--version", "-h", "-V"];
-
-/// The dominant selected option.
-#[derive(Debug, Clone, PartialEq)]
-enum SelectedOption {
-    Help,
-    Version,
-    List,
-    Unrecognized(OsString),
-}
-
-/// Coreutils only accepts one single option,
-/// if multiple are given, use the most dominant one.
-///
-/// Help > Version > List (e.g. 'coreutils --list --version' will return version)
-/// Unrecognized will return immediately.
-///
-/// # Returns
-/// (SelectedOption, Util for help request, if any)
-fn find_dominant_option(
-    first_arg: &OsString,
-    args: &mut impl Iterator<Item = OsString>,
-) -> (SelectedOption, Option<OsString>) {
-    let mut sel = identify_option_from_partial_text(first_arg);
-    match sel {
-        SelectedOption::Help => return (SelectedOption::Help, args.next()),
-        SelectedOption::Unrecognized(_) => {
-            return (sel, None);
-        }
-        _ => {}
-    }
-    // check remaining options, allows multiple
-    while let Some(arg) = args.next() {
-        let so = identify_option_from_partial_text(&arg);
-        match so {
-            // most dominant, return directly
-            SelectedOption::Help => {
-                // if help is wanted, check if a tool was named
-                return (so, args.next());
-            }
-            // best after help, can be set directly
-            SelectedOption::Version => sel = SelectedOption::Version,
-            SelectedOption::List => {
-                if sel != SelectedOption::Version {
-                    sel = SelectedOption::List;
-                }
-            }
-            // unrecognized is not allowed
-            SelectedOption::Unrecognized(_) => {
-                return (so, None);
-            }
-        }
-    }
-
-    (sel, None)
-}
-
-// Will identify one, SelectedOption::None cannot be returned.
-fn identify_option_from_partial_text(arg: &OsString) -> SelectedOption {
-    let mut option = &arg.to_string_lossy()[..];
-    if let Some(p) = option.find('=') {
-        option = &option[0..p];
-    }
-    let l = option.len();
-    let possible_opts: Vec<usize> = COREUTILS_OPTIONS
-        .iter()
-        .enumerate()
-        .filter(|(_, it)| it.len() >= l && &it[0..l] == option)
-        .map(|(id, _)| id)
-        .collect();
-
-    match possible_opts.len() {
-        // exactly one hit
-        1 => match &possible_opts[0] {
-            // number represents index of [COREUTILS_OPTIONS]
-            0 | 3 => SelectedOption::Help,
-            1 => SelectedOption::List,
-            2 | 4 => SelectedOption::Version,
-            _ => SelectedOption::Help,
-        },
-        // None or more hits. The latter can not happen with the allowed options.
-        _ => SelectedOption::Unrecognized(arg.clone()),
-    }
-}

tests/test_util_name.rs

@@ -26,6 +26,24 @@ fn init() {
     eprintln!("Setting UUTESTS_BINARY_PATH={TESTS_BINARY}");
 }
 
+#[test]
+fn test_coreutils_help_ignore_args() {
+    use std::process::Command;
+
+    let scenario = TestScenario::new("help_ignoring_args");
+    if !scenario.bin_path.exists() {
+        return;
+    }
+
+    let output = Command::new(&scenario.bin_path)
+        .arg("--help")
+        .arg("---")
+        .output()
+        .unwrap();
+
+    assert_eq!(output.status.code(), Some(0));
+}
+
 #[test]
 #[cfg(feature = "ls")]
 fn execution_phrase_double() {
@@ -246,7 +264,7 @@ fn util_arg_priority() {
     }
     let child = Command::new(&scenario.bin_path)
         .arg("--list")
-        .arg("--version")
+        .arg("--help")
         .stdout(Stdio::piped())
         .stderr(Stdio::piped())
         .spawn()
@@ -255,8 +273,8 @@ fn util_arg_priority() {
     assert_eq!(output.status.code(), Some(0));
     assert_eq!(output.stderr, b"");
     let output_str = String::from_utf8(output.stdout).unwrap();
-    let ver = env::var("CARGO_PKG_VERSION").unwrap();
-    assert_eq!(format!("coreutils {ver} (multi-call binary)\n"), output_str);
+    assert!(output_str.contains("Usage: coreutils"));
+    assert!(output_str.contains("lists all defined functions"));
 }
 
 #[test]

util/fetch-gnu.sh

@@ -4,7 +4,9 @@ repo=https://github.com/coreutils/coreutils
 curl -L "${repo}/releases/download/v${ver}/coreutils-${ver}.tar.xz" | tar --strip-components=1 -xJf -
 
 # TODO stop backporting tests from master at GNU coreutils > $ver
-# backport = ()
-# for f in ${backport[@]}
-#  do curl -L ${repo}/raw/refs/heads/master/tests/$f > tests/$f
-# done
+ backport=(
+  misc/coreutils.sh
+)
+ for f in "${backport[@]}"
+  do curl -L ${repo}/raw/refs/heads/master/tests/$f > tests/$f
+ done