Merge branch 'main' into wc-perf

Author: sylvestre

Cargo.lock

@@ -120,19 +120,28 @@ where
         .enumerate();
     let mut input_iter = InputSplitter::new(enumerated_input_lines);
     let mut split_writer = SplitWriter::new(options);
-    let patterns: Vec<patterns::Pattern> = patterns::get_patterns(patterns)?;
-    let ret = do_csplit(&mut split_writer, patterns, &mut input_iter);
+    let patterns_vec: Vec<patterns::Pattern> = patterns::get_patterns(patterns)?;
+    let all_up_to_line = patterns_vec
+        .iter()
+        .all(|p| matches!(p, patterns::Pattern::UpToLine(_, _)));
+    let ret = do_csplit(&mut split_writer, patterns_vec, &mut input_iter);
 
     // consume the rest, unless there was an error
     if ret.is_ok() {
         input_iter.rewind_buffer();
         if let Some((_, line)) = input_iter.next() {
+            // There is remaining input: create a final split and copy remainder
             split_writer.new_writer()?;
             split_writer.writeln(&line?)?;
             for (_, line) in input_iter {
                 split_writer.writeln(&line?)?;
             }
             split_writer.finish_split();
+        } else if all_up_to_line && options.suppress_matched {
+            // GNU semantics for integer patterns with --suppress-matched:
+            // even if no remaining input, create a final (possibly empty) split
+            split_writer.new_writer()?;
+            split_writer.finish_split();
         }
     }
     // delete files on error by default

src/uu/csplit/src/csplit.rs

@@ -97,8 +97,10 @@ fn create_algorithm_from_flags(matches: &ArgMatches) -> UResult<HashAlgorithm> {
         set_or_err(detect_algo("b3sum", None)?)?;
     }
     if matches.get_flag("sha3") {
-        let bits = matches.get_one::<usize>("bits").copied();
-        set_or_err(create_sha3(bits)?)?;
+        match matches.get_one::<usize>("bits") {
+            Some(bits) => set_or_err(create_sha3(*bits)?)?,
+            None => return Err(ChecksumError::BitsRequiredForSha3.into()),
+        }
     }
     if matches.get_flag("sha3-224") {
         set_or_err(HashAlgorithm {

src/uu/hashsum/src/hashsum.rs

@@ -19,6 +19,7 @@ pinky-help-omit-headings = omit the line of column headings in short format
 pinky-help-omit-name = omit the user's full name in short format
 pinky-help-omit-name-host = omit the user's full name and remote host in short format
 pinky-help-omit-name-host-time = omit the user's full name, remote host and idle time in short format
+pinky-help-lookup = attempt to canonicalize hostnames via DNS
 pinky-help-help = Print help information
 
 # Column headers for short format

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

@@ -19,6 +19,7 @@ pinky-help-omit-headings = omettre la ligne des en-têtes de colonnes en format
 pinky-help-omit-name = omettre le nom complet de l'utilisateur en format court
 pinky-help-omit-name-host = omettre le nom complet et l'hôte distant de l'utilisateur en format court
 pinky-help-omit-name-host-time = omettre le nom complet, l'hôte distant et le temps d'inactivité de l'utilisateur en format court
+pinky-help-lookup = tenter de donner un forme canonique aux noms d'hôte avec DNS
 pinky-help-help = Afficher les informations d'aide
 
 # En-têtes de colonnes pour le format court

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

@@ -13,6 +13,7 @@ mod platform;
 
 mod options {
     pub const LONG_FORMAT: &str = "long_format";
+    pub const LOOKUP: &str = "lookup";
     pub const OMIT_HOME_DIR: &str = "omit_home_dir";
     pub const OMIT_PROJECT_FILE: &str = "omit_project_file";
     pub const OMIT_PLAN_FILE: &str = "omit_plan_file";
@@ -101,6 +102,12 @@ pub fn uu_app() -> Command {
                 .action(ArgAction::Append)
                 .value_hint(clap::ValueHint::Username),
         )
+        .arg(
+            Arg::new(options::LOOKUP)
+                .long(options::LOOKUP)
+                .help(translate!("pinky-help-lookup"))
+                .action(ArgAction::SetTrue),
+        )
         .arg(
             // Redefine the help argument to not include the short flag
             // since that conflicts with omit_project_file.

src/uu/pinky/src/pinky.rs

@@ -64,6 +64,9 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     // if true, use the "short" output format.
     let do_short_format = !matches.get_flag(options::LONG_FORMAT);
 
+    // If true, attempt to canonicalize hostname via a DNS lookup.
+    let do_lookup = matches.get_flag(options::LOOKUP);
+
     /* if true, display the ut_host field. */
     let mut include_where = true;
 
@@ -81,6 +84,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     }
 
     let pk = Pinky {
+        do_lookup,
         include_idle,
         include_heading,
         include_fullname,
@@ -103,6 +107,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
 }
 
 struct Pinky {
+    do_lookup: bool,
     include_idle: bool,
     include_heading: bool,
     include_fullname: bool,
@@ -136,11 +141,20 @@ fn idle_string(when: i64) -> String {
 }
 
 fn time_string(ut: &UtmpxRecord) -> String {
-    // "%b %e %H:%M"
-    let time_format: Vec<time::format_description::FormatItem> =
+    let lc_time: String = std::env::var("LC_ALL")
+        .or_else(|_| std::env::var("LC_TIME"))
+        .or_else(|_| std::env::var("LANG"))
+        .unwrap_or_default();
+
+    let time_format: Vec<time::format_description::FormatItem> = if lc_time == "C" {
+        // "%b %e %H:%M"
         time::format_description::parse("[month repr:short] [day padding:space] [hour]:[minute]")
-            .unwrap();
-    ut.login_time().format(&time_format).unwrap() // LC_ALL=C
+            .unwrap()
+    } else {
+        // "%Y-%m-%d %H:%M"
+        time::format_description::parse("[year]-[month]-[day] [hour]:[minute]").unwrap()
+    };
+    ut.login_time().format(&time_format).unwrap()
 }
 
 fn gecos_to_fullname(pw: &Passwd) -> Option<String> {
@@ -206,10 +220,16 @@ impl Pinky {
 
         print!(" {}", time_string(ut));
 
-        let mut s = ut.host();
-        if self.include_where && !s.is_empty() {
-            s = ut.canon_host()?;
-            print!(" {s}");
+        if self.include_where {
+            let s: String = if self.do_lookup {
+                ut.canon_host().unwrap_or(ut.host())
+            } else {
+                ut.host()
+            };
+
+            if !s.is_empty() {
+                print!(" {s}");
+            }
         }
 
         println!();

src/uu/pinky/src/platform/unix.rs

@@ -249,34 +249,32 @@ impl UError for ChecksumError {
 ///
 /// # Returns
 ///
-/// Returns a UResult of a tuple containing the algorithm name, the hasher instance, and
-/// the output length in bits or an Err if an unsupported output size is provided, or if
-/// the `--bits` flag is missing.
-pub fn create_sha3(bits: Option<usize>) -> UResult<HashAlgorithm> {
+/// Returns a `UResult` with an `HashAlgorithm` or an `Err` if an unsupported
+/// output size is provided.
+pub fn create_sha3(bits: usize) -> UResult<HashAlgorithm> {
     match bits {
-        Some(224) => Ok(HashAlgorithm {
+        224 => Ok(HashAlgorithm {
             name: "SHA3_224",
             create_fn: Box::new(|| Box::new(Sha3_224::new())),
             bits: 224,
         }),
-        Some(256) => Ok(HashAlgorithm {
+        256 => Ok(HashAlgorithm {
             name: "SHA3_256",
             create_fn: Box::new(|| Box::new(Sha3_256::new())),
             bits: 256,
         }),
-        Some(384) => Ok(HashAlgorithm {
+        384 => Ok(HashAlgorithm {
             name: "SHA3_384",
             create_fn: Box::new(|| Box::new(Sha3_384::new())),
             bits: 384,
         }),
-        Some(512) => Ok(HashAlgorithm {
+        512 => Ok(HashAlgorithm {
             name: "SHA3_512",
             create_fn: Box::new(|| Box::new(Sha3_512::new())),
             bits: 512,
         }),
 
-        Some(_) => Err(ChecksumError::InvalidOutputSizeForSha3.into()),
-        None => Err(ChecksumError::BitsRequiredForSha3.into()),
+        _ => Err(ChecksumError::InvalidOutputSizeForSha3.into()),
     }
 }
 
@@ -459,8 +457,10 @@ pub fn detect_algo(algo: &str, length: Option<usize>) -> UResult<HashAlgorithm>
                 bits,
             })
         }
-        //ALGORITHM_OPTIONS_SHA3 | "sha3" => (
-        _ if algo.starts_with("sha3") => create_sha3(length),
+        _ if algo.starts_with("sha3") => {
+            let bits = length.ok_or(ChecksumError::BitsRequiredForSha3)?;
+            create_sha3(bits)
+        }
 
         _ => Err(ChecksumError::UnknownAlgorithm.into()),
     }

src/uucore/src/lib/features/checksum.rs

@@ -12,6 +12,44 @@ fn generate(from: u32, to: u32) -> String {
     (from..to).fold(String::new(), |acc, v| format!("{acc}{v}\n"))
 }
 
+#[test]
+fn test_line_numbers_suppress_matched_final_empty() {
+    // Repro for #7286
+    let (at, mut ucmd) = at_and_ucmd!();
+    ucmd.args(&["--suppress-matched", "-", "2", "4", "6"]) // stdin, split at 2/4/6
+        .pipe_in("1\n2\n3\n4\n5\n6\n")
+        .succeeds()
+        .stdout_only("2\n2\n2\n0\n");
+
+    // Expect four files: xx00:"1\n", xx01:"3\n", xx02:"5\n", xx03:""
+    let count = glob(&at.plus_as_string("xx*"))
+        .expect("there should be splits created")
+        .count();
+    assert_eq!(count, 4);
+    assert_eq!(at.read("xx00"), "1\n");
+    assert_eq!(at.read("xx01"), "3\n");
+    assert_eq!(at.read("xx02"), "5\n");
+    assert_eq!(at.read("xx03"), "");
+}
+
+#[test]
+fn test_line_numbers_suppress_matched_final_empty_elided_with_z() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    ucmd.args(&["--suppress-matched", "-z", "-", "2", "4", "6"]) // elide empty
+        .pipe_in("1\n2\n3\n4\n5\n6\n")
+        .succeeds()
+        .stdout_only("2\n2\n2\n");
+
+    // Expect three files: xx00:"1\n", xx01:"3\n", xx02:"5\n"
+    let count = glob(&at.plus_as_string("xx*"))
+        .expect("there should be splits created")
+        .count();
+    assert_eq!(count, 3);
+    assert_eq!(at.read("xx00"), "1\n");
+    assert_eq!(at.read("xx01"), "3\n");
+    assert_eq!(at.read("xx02"), "5\n");
+}
+
 #[test]
 fn test_invalid_arg() {
     new_ucmd!().arg("--definitely-invalid").fails_with_code(1);

tests/by-util/test_csplit.rs

@@ -90,6 +90,19 @@ fn test_short_format_i() {
     assert_eq!(v_actual, v_expect);
 }
 
+#[cfg(unix)]
+#[test]
+#[cfg(not(target_os = "openbsd"))]
+fn test_lookup() {
+    let args = ["--lookup"];
+    let ts = TestScenario::new(util_name!());
+    let actual = ts.ucmd().args(&args).succeeds().stdout_move_str();
+    let expect = unwrap_or_return!(expected_result(&ts, &[])).stdout_move_str();
+    let v_actual: Vec<&str> = actual.split_whitespace().collect();
+    let v_expect: Vec<&str> = expect.split_whitespace().collect();
+    assert_eq!(v_actual, v_expect);
+}
+
 #[cfg(unix)]
 #[test]
 #[cfg(not(target_os = "openbsd"))]