Merge branch 'main' into fold

Author: lavafroth

.vscode/cspell.dictionaries/shell.wordlist.txt

@@ -101,6 +101,7 @@ flamegraph
 flamegraphs
 gcov
 gmake
+gnuls
 grcov
 grep
 markdownlint

docs/src/performance.md

@@ -41,6 +41,8 @@ hyperfine \
   "{ls} -R ."
 ```
 
+For Ubuntu 25.10 and other distributions that use uutils by default, replace `bin/ls` with `bin/gnuls`. Also:
+
 ```
 # to improve the reproducibility of the results:
 taskset -c 0

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

@@ -109,6 +109,6 @@ cut-error-delimiter-and-whitespace-conflict = invalid input: Only one of --delim
 cut-error-delimiter-must-be-single-character = the delimiter must be a single character
 cut-error-multiple-mode-args = invalid usage: expects no more than one of --fields (-f), --chars (-c) or --bytes (-b)
 cut-error-missing-mode-arg = invalid usage: expects one of --fields (-f), --chars (-c) or --bytes (-b)
-cut-error-delimiter-only-with-fields = invalid input: The '--delimiter' ('-d') option only usable if printing a sequence of fields
-cut-error-whitespace-only-with-fields = invalid input: The '-w' option only usable if printing a sequence of fields
-cut-error-only-delimited-only-with-fields = invalid input: The '--only-delimited' ('-s') option only usable if printing a sequence of fields
+cut-error-delimiter-only-with-fields = invalid input: The '--delimiter' ('-d') option can only be used when printing a sequence of fields
+cut-error-whitespace-only-with-fields = invalid input: The '-w' option can only be used when printing a sequence of fields
+cut-error-only-delimited-only-with-fields = invalid input: The '--only-delimited' ('-s') option can only be used when printing a sequence of fields

src/uu/pr/src/pr.rs

@@ -91,7 +91,7 @@ struct FileLine {
     file_id: usize,
     page_number: usize,
     line_number: usize,
-    line_content: String,
+    line_content: Vec<u8>,
 }
 
 impl FileLine {
@@ -101,29 +101,24 @@ impl FileLine {
         line_number: usize,
         buf: &[u8],
         options: &OutputOptions,
-    ) -> Result<Self, PrError> {
-        // TODO Don't read bytes to String just to directly write them
-        // out again anyway.
+    ) -> Self {
         let line_content = if let Some(expand_tabs) = &options.expand_tabs {
-            // Anticipate a few expandable chars to reduce reallocations
-            let mut line_content =
-                String::with_capacity(buf.len() + buf.len() / 20 * expand_tabs.width as usize);
-            // validate utf correctness
-            let s = std::str::from_utf8(buf)?;
-            for b in s.as_bytes() {
-                apply_expand_tab(&mut line_content, *b, expand_tabs);
+            let mut result =
+                Vec::with_capacity(buf.len() + buf.len() / 20 * expand_tabs.width as usize);
+            for b in buf {
+                apply_expand_tab(&mut result, *b, expand_tabs);
             }
-            line_content
+            result
         } else {
-            String::from_utf8(buf.to_vec())?
+            buf.to_vec()
         };
 
-        Ok(Self {
+        Self {
             file_id,
             page_number,
             line_number,
             line_content,
-        })
+        }
     }
 }
 
@@ -858,24 +853,24 @@ fn read_to_end(path: &str) -> Result<Vec<u8>, std::io::Error> {
     }
 }
 
-fn apply_expand_tab(chunk: &mut String, byte: u8, expand_options: &ExpandTabsOptions) {
+fn apply_expand_tab(chunk: &mut Vec<u8>, byte: u8, expand_options: &ExpandTabsOptions) {
     if byte == expand_options.input_char as u8 {
         // If the byte encountered is the input char we use width to calculate
         // the amount of spaces needed (if no input char given we stored '\t'
         // in our struct)
         let spaces_needed =
             expand_options.width as usize - (chunk.len() % expand_options.width as usize);
-        chunk.extend(std::iter::repeat_n(' ', spaces_needed));
+        chunk.extend(std::iter::repeat_n(b' ', spaces_needed));
     } else if byte == TAB as u8 {
         // If a byte got passed to the -e flag (eg -ea1)  which is not '\t' GNU
         // still expands it but does not use an optionally given width parameter
         // but does the '\t' expansion with the default value (8)
         let spaces_needed = 8 - (chunk.len() % 8);
-        chunk.extend(std::iter::repeat_n(' ', spaces_needed));
+        chunk.extend(std::iter::repeat_n(b' ', spaces_needed));
     } else {
         // This arm means the byte is neither '\t' nor the bytes to be
         // expanded
-        chunk.push(byte as char);
+        chunk.push(byte);
     }
 }
 
@@ -885,7 +880,7 @@ fn pr(path: &str, options: &OutputOptions) -> Result<i32, PrError> {
     // TODO Read incrementally.
     let buf = read_to_end(path)?;
 
-    let pages = get_pages(options, 0, &buf)?;
+    let pages = get_pages(options, 0, &buf);
 
     // Split the text into pages, and then print each line in each page.
     for page_with_page_number in pages {
@@ -901,14 +896,7 @@ fn pr(path: &str, options: &OutputOptions) -> Result<i32, PrError> {
 ///
 /// Returns a list of the form `(page_num, lines)`.
 ///
-/// # Errors
-///
-/// Returns an error if the bytes are not a valid UTF-8 string.
-fn get_pages(
-    options: &OutputOptions,
-    file_id: usize,
-    buf: &[u8],
-) -> Result<Vec<(usize, Vec<FileLine>)>, PrError> {
+fn get_pages(options: &OutputOptions, file_id: usize, buf: &[u8]) -> Vec<(usize, Vec<FileLine>)> {
     let start_page = options.start_page;
     let end_page = options.end_page;
     let lines_needed_per_page = lines_to_read_for_page(options);
@@ -944,7 +932,7 @@ fn get_pages(
                 // `\f` as its own line; instead ignore the empty line.
             } else {
                 let file_line =
-                    FileLine::from_buf(file_id, page_num, line_num, &buf[prev..i], options)?;
+                    FileLine::from_buf(file_id, page_num, line_num, &buf[prev..i], options);
                 page.push(file_line);
             }
 
@@ -970,7 +958,7 @@ fn get_pages(
                 // `\n` as its own line; instead ignore the empty line.
             } else {
                 let file_line =
-                    FileLine::from_buf(file_id, page_num, line_num, &buf[prev..i], options)?;
+                    FileLine::from_buf(file_id, page_num, line_num, &buf[prev..i], options);
                 page.push(file_line);
                 line_num += 1;
             }
@@ -992,7 +980,7 @@ fn get_pages(
 
     // Consider all trailing bytes as the last line.
     if prev < buf.len() {
-        let file_line = FileLine::from_buf(file_id, page_num, line_num, &buf[prev..], options)?;
+        let file_line = FileLine::from_buf(file_id, page_num, line_num, &buf[prev..], options);
         page.push(file_line);
     }
 
@@ -1001,7 +989,7 @@ fn get_pages(
         pages.push((page_num, page.clone()));
     }
 
-    Ok(pages)
+    pages
 }
 
 /// Key used to group lines together according to their file and page number.
@@ -1056,7 +1044,7 @@ fn get_file_line_groups(
 
         // Split the text into pages and collect each line for
         // subsequent grouping.
-        for (_, mut page) in get_pages(options, file_id, &buf)? {
+        for (_, mut page) in get_pages(options, file_id, &buf) {
             all_lines.append(&mut page);
         }
     }
@@ -1291,7 +1279,9 @@ fn get_line_for_printing(
     let blank_line = String::new();
     let formatted_line_number = get_formatted_line_number(options, file_line.line_number, index);
 
-    let mut complete_line = format!("{formatted_line_number}{}", file_line.line_content);
+    // TODO: support non-UTF-8 bytes (currently replaced with U+FFFD)
+    let content = String::from_utf8_lossy(&file_line.line_content);
+    let mut complete_line = format!("{formatted_line_number}{content}");
 
     let offset_spaces = &options.offset_spaces;
 

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

@@ -250,14 +250,15 @@ pub enum SizedAlgoKind {
     Sha3(ShaLength),
     // Note: we store Blake2b's length as BYTES.
     Blake2b(Option<usize>),
+    // Shake* length are stored in bits.
     Shake128(Option<usize>),
     Shake256(Option<usize>),
 }
 
 impl SizedAlgoKind {
-    pub fn from_unsized(kind: AlgoKind, byte_length: Option<usize>) -> UResult<Self> {
+    pub fn from_unsized(kind: AlgoKind, output_length: Option<usize>) -> UResult<Self> {
         use AlgoKind as ak;
-        match (kind, byte_length) {
+        match (kind, output_length) {
             (
                 ak::Sysv
                 | ak::Bsd
@@ -305,19 +306,26 @@ impl SizedAlgoKind {
     }
 
     pub fn to_tag(self) -> String {
-        use SizedAlgoKind::*;
         match self {
-            Md5 => "MD5".into(),
-            Sm3 => "SM3".into(),
-            Sha1 => "SHA1".into(),
-            Blake3 => "BLAKE3".into(),
-            Sha2(len) => format!("SHA{}", len.as_usize()),
-            Sha3(len) => format!("SHA3-{}", len.as_usize()),
-            Blake2b(Some(byte_len)) => format!("BLAKE2b-{}", byte_len * 8),
-            Blake2b(None) => "BLAKE2b".into(),
-            Shake128(_) => "SHAKE128".into(),
-            Shake256(_) => "SHAKE256".into(),
-            Sysv | Bsd | Crc | Crc32b => panic!("Should not be used for tagging"),
+            Self::Md5 => "MD5".into(),
+            Self::Sm3 => "SM3".into(),
+            Self::Sha1 => "SHA1".into(),
+            Self::Blake3 => "BLAKE3".into(),
+            Self::Sha2(len) => format!("SHA{}", len.as_usize()),
+            Self::Sha3(len) => format!("SHA3-{}", len.as_usize()),
+            Self::Blake2b(Some(byte_len)) => format!("BLAKE2b-{}", byte_len * 8),
+            Self::Blake2b(None) => "BLAKE2b".into(),
+            Self::Shake128(opt_bit_len) => format!(
+                "SHAKE128-{}",
+                opt_bit_len.unwrap_or(Shake128::DEFAULT_BIT_SIZE)
+            ),
+            Self::Shake256(opt_bit_len) => format!(
+                "SHAKE256-{}",
+                opt_bit_len.unwrap_or(Shake256::DEFAULT_BIT_SIZE)
+            ),
+            Self::Sysv | Self::Bsd | Self::Crc | Self::Crc32b => {
+                panic!("Should not be used for tagging")
+            }
         }
     }
 

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

@@ -19,7 +19,7 @@ use crate::checksum::{
 };
 use crate::error::{FromIo, UError, UIoError, UResult, USimpleError};
 use crate::quoting_style::{QuotingStyle, locale_aware_escape_name};
-use crate::sum::DigestOutput;
+use crate::sum::{self, DigestOutput};
 use crate::{
     os_str_as_bytes, os_str_from_bytes, read_os_string_lines, show, show_warning_caps, translate,
 };
@@ -643,6 +643,7 @@ fn identify_algo_name_and_length(
             AlgoKind::Sha2 | AlgoKind::Sha3 if [224, 256, 384, 512].contains(&bitlen) => {
                 Some(bitlen)
             }
+            AlgoKind::Shake128 | AlgoKind::Shake256 => Some(bitlen),
             // Either
             //  the algo based line is provided with a bit length
             //  with an algorithm that does not support it (only Blake2B does).
@@ -741,6 +742,9 @@ fn process_algo_based_line(
     // checksum with it.
     let digest_char_length_hint = match (algo_kind, algo_byte_len) {
         (AlgoKind::Blake2b, Some(byte_len)) => Some(byte_len),
+        (AlgoKind::Shake128 | AlgoKind::Shake256, Some(bit_len)) => Some(bit_len.div_ceil(8)),
+        (AlgoKind::Shake128, None) => Some(sum::Shake128::DEFAULT_BIT_SIZE.div_ceil(8)),
+        (AlgoKind::Shake256, None) => Some(sum::Shake256::DEFAULT_BIT_SIZE.div_ceil(8)),
         _ => None,
     };
 

tests/by-util/test_cksum.rs

@@ -3150,13 +3150,19 @@ fn test_check_checkfile_with_io_error() {
     "ac"
 )]
 fn test_shake128(#[case] args: &[&str], #[case] expected: &str) {
+    let bit_len = if args.is_empty() || args[1] == "0" {
+        "256"
+    } else {
+        args[1]
+    };
+
     new_ucmd!()
         .arg("-a")
         .arg("shake128")
         .args(args)
         .pipe_in("xxx")
         .succeeds()
-        .stdout_only(format!("SHAKE128 (-) = {expected}\n"));
+        .stdout_only(format!("SHAKE128-{bit_len} (-) = {expected}\n"));
 }
 
 #[rstest]
@@ -3213,11 +3219,71 @@ fn test_shake128(#[case] args: &[&str], #[case] expected: &str) {
     "2f"
 )]
 fn test_shake256(#[case] args: &[&str], #[case] expected: &str) {
+    let bit_len = if args.is_empty() || args[1] == "0" {
+        "512"
+    } else {
+        args[1]
+    };
+
     new_ucmd!()
         .arg("-a")
         .arg("shake256")
         .args(args)
         .pipe_in("xxx")
         .succeeds()
-        .stdout_only(format!("SHAKE256 (-) = {expected}\n"));
+        .stdout_only(format!("SHAKE256-{bit_len} (-) = {expected}\n"));
+}
+
+#[test]
+fn test_check_shake128_no_length() {
+    const INPUT_SHAKE128_CORRECT_LEN: &str =
+        "SHAKE128 (bar) = ac8549b2861a151896ab721bd29d7a20c1a3d1f75b31266f786f20d963fb0fdf";
+    const INPUT_SHAKE128_WRONG_LEN: &str = "SHAKE128 (bar) = ac8549b2861a151896ab721bd29d7a20";
+
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    at.write("bar", "xxx");
+
+    scene
+        .ucmd()
+        .arg("-a")
+        .arg("shake128")
+        .arg("-c")
+        .pipe_in(INPUT_SHAKE128_CORRECT_LEN)
+        .succeeds();
+
+    scene
+        .ucmd()
+        .arg("-a")
+        .arg("shake128")
+        .arg("-c")
+        .pipe_in(INPUT_SHAKE128_WRONG_LEN)
+        .fails()
+        .stderr_only("cksum: 'standard input': no properly formatted checksum lines found\n");
+}
+
+#[test]
+fn test_check_shake256_no_length() {
+    const INPUT_SHAKE256_CORRECT_LEN: &str = "SHAKE256 (bar) = 2fa631503c3ea5fe85131dbfa24805185474740e6dcb5f2a64f69d932bcb55f7b24958f3e3c4cc0e71f1fe6f054cd3fb28b9efb62b4f8f3fbe6d50d90f5c6eba";
+    const INPUT_SHAKE256_WRONG_LEN: &str =
+        "SHAKE256 (bar) = 2fa631503c3ea5fe85131dbfa24805185474740e6dcb5f2a64f69d932bcb55f7";
+
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    at.write("bar", "xxx");
+
+    scene
+        .ucmd()
+        .arg("-c")
+        .pipe_in(INPUT_SHAKE256_CORRECT_LEN)
+        .succeeds();
+
+    scene
+        .ucmd()
+        .arg("-c")
+        .pipe_in(INPUT_SHAKE256_WRONG_LEN)
+        .fails()
+        .stderr_only("cksum: 'standard input': no properly formatted checksum lines found\n");
 }

tests/by-util/test_cut.rs

@@ -131,7 +131,7 @@ fn test_delimiter_with_byte_and_char() {
         new_ucmd!()
             .args(&[conflicting_arg, COMPLEX_SEQUENCE.sequence, "-d="])
             .fails_with_code(1)
-            .stderr_is("cut: invalid input: The '--delimiter' ('-d') option only usable if printing a sequence of fields\n")
+            .stderr_is("cut: invalid input: The '--delimiter' ('-d') option can only be used when printing a sequence of fields\n")
 ;
     }
 }

util/gnu-patches/tests_cut_error_msg.patch

@@ -21,7 +21,7 @@ Index: gnu/tests/cut/cut.pl
 +my $inval_fld = "$prog: range '--' was invalid: failed to parse range\n";
 +my $inval_pos = "$prog: range '--' was invalid: failed to parse range\n";
 +my $no_endpoint = "$prog: range '-' was invalid: invalid range with no endpoint\n";
-+my $nofield = "$prog: invalid input: The '--delimiter' ('-d') option only usable if printing a sequence of fields\n";
++my $nofield = "$prog: invalid input: The '--delimiter' ('-d') option can only be used when printing a sequence of fields\n";
 
  my @Tests =
   (
@@ -53,7 +53,7 @@ Index: gnu/tests/cut/cut.pl
    ['y', qw(-s -b4), {IN=>":\n"}, {OUT=>""}, {EXIT=>1},
 -   {ERR=>"$prog: suppressing non-delimited lines makes sense\n"
 -    . "\tonly when operating on fields\n$try"}],
-+   {ERR=>"$prog: invalid input: The '--only-delimited' ('-s') option only usable if printing a sequence of fields\n"}],
++   {ERR=>"$prog: invalid input: The '--only-delimited' ('-s') option can only be used when printing a sequence of fields\n"}],
    # You must specify bytes or fields (or chars)
    ['z', '', {IN=>":\n"}, {OUT=>""}, {EXIT=>1},
 -   {ERR=>"$prog: you must specify a list of bytes, characters, or fields\n$try"}