tsort: gnu misc tsort.pl (#9289)

* test: add comprehensive test coverage for tsort cycle detection and graph topologies

- Introduce new test cases for cycle loops in file inputs, including extra nodes and multiple loops
- Add tests for POSIX graph examples and linear tree graphs to validate topological sorting
- Include tests for error handling on odd token counts and multiple file inputs
- Ensures robustness and correctness of tsort implementation across various edge cases and standard scenarios

* refactor(tests): consolidate multi-line string constants to single-line literals in tsort test file

- Reformatted TSORT_LOOP_STDERR_AC and TSORT_UNEXPECTED_ARG_ERROR constants for improved code readability and consistency, with no change in string content or functionality. The multi-line format was merged into single lines to align with potential linting rules or style preferences for string literals in tests. This refactoring enhances maintainability without affecting test logic.

* feat(tsort): add hidden warn flag and reverse successor iteration order

- Added `ArgAction` import and a new hidden `-w`/`--warn` argument to the tsort command for future warning features
- Modified iteration of successor names to use `.into_iter().rev()` in the topological sorting algorithm to process nodes in reverse order, ensuring more stable and predictable output sequence
- Refactored Clap error localization in `clap_localization.rs` to use `print_prefixed_error()` method instead of direct `eprintln!` calls, improving consistency in error message formatting across the application

* fix(test): prefix uniq error messages with program name

Update expected error outputs in uniq tests to match the new format where error messages are prefixed with "uniq: ". This ensures test cases align with the updated error message formatting in the utility, providing clearer error identification by including the program name at the start of each error message. Changes affect multiple test assertions for invalid options and incompatible argument combinations.

* fix(test): update chroot error assertion to include command prefix

The expected error message now starts with "chroot: " to match the updated output format in the chroot utility. This ensures the test accurately reflects the command's behavior.

* fix(test/chroot): update error message assertion to match standardized format

Remove "chroot: " prefix from expected error output, aligning the test with the updated stderr format that omits utility name redundancy in error messages.

* fix: update uniq error messages in tests, removing 'uniq: ' prefix

Remove the 'uniq: ' prefix from expected error messages in test cases to match the updated output format of the uniq utility, ensuring tests pass with the current implementation. This change affects multiple GNU compatibility tests for invalid options and argument conflicts.

* fix(comm): update test assertion to match actual error message without 'comm: ' prefix

The stderr assertion in test_comm_arg_error was expecting an error message prefixed with "comm: ", but the actual command output does not include this prefix. This update fixes the test to align with the real behavior, ensuring the test passes correctly.

* refactor(clap_localization): replace print_prefixed_error with direct stderr output in ErrorFormatter

Replace the call to self.print_prefixed_error with direct eprintln for printing unexpected argument errors, and add an additional blank line for better formatting and readability in error messages. This change aims to simplify the output process and ensure consistent error presentation in the clap localization module.

* refactor(clap_localization): remove prefixed error printing and use direct eprintln for cleaner output

Modified error handling in clap_localization.rs to eliminate the utility name prefix by replacing self.print_prefixed_error calls with direct eprintln! invocations. This simplifies the codebase and changes error message formatting to display clap errors without the preceding util name. Removed the unused print_prefixed_error method.

* test(tests/tsort): ignore test for single input file until error message is corrected

- Added #[ignore] attribute to test_only_one_input_file to skip it during execution.
- Reason: Test likely fails due to an incorrect error message; this prevents false negatives while the message is being fixed in the tsort utility.

* feat(tsort): reject multiple input arguments with custom error

- Change FILE arg to accept zero or more inputs (appended), defaulting to "-" if none
- Add validation to error on more than one input with "extra operand" message
- Update test to expect new error format, matching GNU tsort behavior
- Unignore test_only_one_input_file after error message correction

* refactor: format TSORT_EXTRA_OPERAND_ERROR constant for readability

Split the TSORT_EXTRA_OPERAND_ERROR constant string into multiple lines
to improve code formatting and adhere to line length guidelines.

* chore: remove tests_tsort.patch from gnu-patches series

Removed the tests_tsort.patch entry as it is no longer applied, possibly due to upstream integration or obsolescence, to keep the patch series current and relevant.

* fix(tsort): simplify error message construction by removing .into() wrapper

Remove unnecessary `.into()` call when creating the extra operand error in uumain,
resulting in cleaner, more concise error handling code. This change does not alter
the program's functionality but improves code readability and reduces nesting.

* feat: internationalize error messages in tsort command

Add localized strings for 'extra operand' and 'at least one input' errors in en-US and fr-FR locales. Update code to use translate! macro for consistent error reporting across languages, improving user experience for international users.

* fix(tsort): ensure expect message is &str by calling .as_str()

The translate! macro returns a String, but expect() requires a &str. Added .as_str() to convert the translated string for correct type usage and fix compilation error.

Author: mattsu2020

src/uu/tsort/locales/en-US.ftl

@@ -6,3 +6,6 @@ tsort-usage = tsort [OPTIONS] FILE
 tsort-error-is-dir = read error: Is a directory
 tsort-error-odd = input contains an odd number of tokens
 tsort-error-loop = input contains a loop:
+tsort-error-extra-operand = extra operand { $operand }
+  Try '{ $util } --help' for more information.
+tsort-error-at-least-one-input = at least one input

src/uu/tsort/locales/fr-FR.ftl

@@ -6,3 +6,6 @@ tsort-usage = tsort [OPTIONS] FILE
 tsort-error-is-dir = erreur de lecture : c'est un répertoire
 tsort-error-odd = l'entrée contient un nombre impair de jetons
 tsort-error-loop = l'entrée contient une boucle :
+tsort-error-extra-operand = opérande supplémentaire { $operand }
+  Essayez '{ $util } --help' pour plus d'informations.
+tsort-error-at-least-one-input = au moins une entrée

src/uu/tsort/src/tsort.rs

@@ -3,14 +3,14 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 //spell-checker:ignore TAOCP indegree
-use clap::{Arg, Command};
+use clap::{Arg, ArgAction, Command};
 use std::collections::hash_map::Entry;
 use std::collections::{HashMap, VecDeque};
 use std::ffi::OsString;
 use std::path::Path;
 use thiserror::Error;
 use uucore::display::Quotable;
-use uucore::error::{UError, UResult};
+use uucore::error::{UError, UResult, USimpleError};
 use uucore::{format_usage, show};
 
 use uucore::translate;
@@ -49,15 +49,36 @@ impl UError for LoopNode<'_> {}
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let matches = uucore::clap_localization::handle_clap_result(uu_app(), args)?;
 
-    let input = matches
-        .get_one::<OsString>(options::FILE)
-        .expect("Value is required by clap");
+    let mut inputs: Vec<OsString> = matches
+        .get_many::<OsString>(options::FILE)
+        .map(|vals| vals.cloned().collect())
+        .unwrap_or_default();
+
+    if inputs.is_empty() {
+        inputs.push(OsString::from("-"));
+    }
+
+    if inputs.len() > 1 {
+        return Err(USimpleError::new(
+            1,
+            translate!(
+                "tsort-error-extra-operand",
+                "operand" => inputs[1].quote(),
+                "util" => uucore::util_name()
+            ),
+        ));
+    }
+
+    let input = inputs
+        .into_iter()
+        .next()
+        .expect(translate!("tsort-error-at-least-one-input").as_str());
 
     let data = if input == "-" {
         let stdin = std::io::stdin();
         std::io::read_to_string(stdin)?
     } else {
-        let path = Path::new(input);
+        let path = Path::new(&input);
         if path.is_dir() {
             return Err(TsortError::IsDir(input.to_string_lossy().to_string()).into());
         }
@@ -96,12 +117,19 @@ pub fn uu_app() -> Command {
         .override_usage(format_usage(&translate!("tsort-usage")))
         .about(translate!("tsort-about"))
         .infer_long_args(true)
+        .arg(
+            Arg::new("warn")
+                .short('w')
+                .action(ArgAction::SetTrue)
+                .hide(true),
+        )
         .arg(
             Arg::new(options::FILE)
-                .default_value("-")
                 .hide(true)
                 .value_parser(clap::value_parser!(OsString))
-                .value_hint(clap::ValueHint::FilePath),
+                .value_hint(clap::ValueHint::FilePath)
+                .num_args(0..)
+                .action(ArgAction::Append),
         )
 }
 
@@ -190,7 +218,7 @@ impl<'input> Graph<'input> {
             let v = self.find_next_node(&mut independent_nodes_queue);
             println!("{v}");
             if let Some(node_to_process) = self.nodes.remove(v) {
-                for successor_name in node_to_process.successor_names {
+                for successor_name in node_to_process.successor_names.into_iter().rev() {
                     let successor_node = self.nodes.get_mut(successor_name).unwrap();
                     successor_node.predecessor_count -= 1;
                     if successor_node.predecessor_count == 0 {

src/uucore/src/lib/mods/clap_localization.rs

@@ -205,7 +205,6 @@ impl<'a> ErrorFormatter<'a> {
                     "value" => self.color_mgr.colorize(&value, Color::Yellow),
                     "option" => self.color_mgr.colorize(&option, Color::Green)
                 );
-
                 // Include validation error if present
                 match err.source() {
                     Some(source) if matches!(err.kind(), ErrorKind::ValueValidation) => {

tests/by-util/test_tsort.rs

@@ -77,7 +77,7 @@ fn test_multiple_arguments() {
         .arg("call_graph.txt")
         .arg("invalid_file")
         .fails()
-        .stderr_contains("unexpected argument 'invalid_file' found");
+        .stderr_contains("extra operand 'invalid_file'");
 }
 
 #[test]
@@ -119,7 +119,7 @@ fn test_two_cycles() {
     new_ucmd!()
         .pipe_in("a b b c c b b d d b")
         .fails_with_code(1)
-        .stdout_is("a\nb\nc\nd\n")
+        .stdout_is("a\nb\nd\nc\n")
         .stderr_is("tsort: -: input contains a loop:\ntsort: b\ntsort: c\ntsort: -: input contains a loop:\ntsort: b\ntsort: d\n");
 }
 
@@ -153,3 +153,95 @@ fn test_loop_for_iterative_dfs_correctness() {
         .fails_with_code(1)
         .stderr_contains("tsort: -: input contains a loop:\ntsort: B\ntsort: C");
 }
+
+const TSORT_LOOP_STDERR: &str = "tsort: f: input contains a loop:\ntsort: s\ntsort: t\n";
+const TSORT_LOOP_STDERR_AC: &str = "tsort: f: input contains a loop:\ntsort: a\ntsort: b\ntsort: f: input contains a loop:\ntsort: a\ntsort: c\n";
+const TSORT_ODD_ERROR: &str = "tsort: -: input contains an odd number of tokens\n";
+const TSORT_EXTRA_OPERAND_ERROR: &str =
+    "tsort: extra operand 'g'\nTry 'tsort --help' for more information.\n";
+
+#[test]
+fn test_cycle_loop_from_file() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    at.write("f", "t b\nt s\ns t\n");
+
+    ucmd.arg("f")
+        .fails_with_code(1)
+        .stdout_is("s\nt\nb\n")
+        .stderr_is(TSORT_LOOP_STDERR);
+}
+
+#[test]
+fn test_cycle_loop_with_extra_node_from_file() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    at.write("f", "t x\nt s\ns t\n");
+
+    ucmd.arg("f")
+        .fails_with_code(1)
+        .stdout_is("s\nt\nx\n")
+        .stderr_is(TSORT_LOOP_STDERR);
+}
+
+#[test]
+fn test_cycle_loop_multiple_loops_from_file() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    at.write("f", "a a\na b\na c\nc a\nb a\n");
+
+    ucmd.arg("f")
+        .fails_with_code(1)
+        .stdout_is("a\nc\nb\n")
+        .stderr_is(TSORT_LOOP_STDERR_AC);
+}
+
+#[test]
+fn test_posix_graph_examples() {
+    new_ucmd!()
+        .pipe_in("a b c c d e\ng g\nf g e f\nh h\n")
+        .succeeds()
+        .stdout_only("a\nc\nd\nh\nb\ne\nf\ng\n");
+
+    new_ucmd!()
+        .pipe_in("b a\nd c\nz h x h r h\n")
+        .succeeds()
+        .stdout_only("b\nd\nr\nx\nz\na\nc\nh\n");
+}
+
+#[test]
+fn test_linear_tree_graphs() {
+    new_ucmd!()
+        .pipe_in("a b b c c d d e e f f g\n")
+        .succeeds()
+        .stdout_only("a\nb\nc\nd\ne\nf\ng\n");
+
+    new_ucmd!()
+        .pipe_in("a b b c c d d e e f f g\nc x x y y z\n")
+        .succeeds()
+        .stdout_only("a\nb\nc\nx\nd\ny\ne\nz\nf\ng\n");
+
+    new_ucmd!()
+        .pipe_in("a b b c c d d e e f f g\nc x x y y z\nf r r s s t\n")
+        .succeeds()
+        .stdout_only("a\nb\nc\nx\nd\ny\ne\nz\nf\nr\ng\ns\nt\n");
+}
+
+#[test]
+fn test_odd_number_of_tokens() {
+    new_ucmd!()
+        .pipe_in("a\n")
+        .fails_with_code(1)
+        .stdout_is("")
+        .stderr_is(TSORT_ODD_ERROR);
+}
+
+#[test]
+fn test_only_one_input_file() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    at.write("f", "");
+    at.write("g", "");
+
+    ucmd.arg("f")
+        .arg("g")
+        .fails_with_code(1)
+        .stdout_is("")
+        .stderr_is(TSORT_EXTRA_OPERAND_ERROR);
+}

tests/fixtures/tsort/call_graph.expected

@@ -1,17 +1,17 @@
 main
-parse_options
-tail_file
 tail_forever
-tail
+tail_file
+parse_options
 recheck
+tail
 write_header
-tail_lines
-tail_bytes
 pretty_name
-start_lines
-file_lines
-pipe_lines
-xlseek
-start_bytes
+tail_bytes
+tail_lines
 pipe_bytes
+start_bytes
+xlseek
+pipe_lines
+file_lines
+start_lines
 dump_remainder

util/gnu-patches/series

@@ -7,7 +7,6 @@ tests_env_env-S.pl.patch
 tests_invalid_opt.patch
 tests_ls_no_cap.patch
 tests_sort_merge.pl.patch
-tests_tsort.patch
 tests_du_move_dir_while_traversing.patch
 test_mkdir_restorecon.patch
 error_msg_uniq.diff