Merge branch 'main' into date-positional-set-format

Author: aguimaraes

Cargo.lock

@@ -113,22 +113,13 @@ impl Display for NumError<'_> {
     /// the invalid ones as escaped octal, like GNU. For example, the
     /// (escaped) string "\xFFabc\x1C" is formatted as "\377abc\034".
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match str::from_utf8(self.0) {
-            Ok(s) => write!(f, "{s}"),
-            Err(e) => {
-                let valid = e.valid_up_to();
-                let cont = valid + e.error_len().unwrap_or(1);
-                // SAFETY: `self.0` has been checked to contain valid
-                // UTF-8 sequences up to `valid`.
-                write!(f, "{}", unsafe {
-                    str::from_utf8_unchecked(&self.0[..valid])
-                })?;
-                for b in &self.0[valid..cont] {
-                    write!(f, "\\{b:03o}")?;
-                }
-                <Self as Display>::fmt(&Self(&self.0[cont..]), f)
+        for chunk in self.0.utf8_chunks() {
+            f.write_str(chunk.valid())?;
+            for &b in chunk.invalid() {
+                write!(f, "\\{b:03o}")?;
             }
         }
+        Ok(())
     }
 }
 

fuzz/Cargo.lock

@@ -1481,7 +1481,12 @@ fn sort_entries(entries: &mut [PathData], config: &Config) {
             )
         }),
         Sort::Size => {
-            entries.sort_unstable_by_key(|k| Reverse(k.metadata().map_or(0, Metadata::len)));
+            entries.sort_unstable_by(|a, b| {
+                b.metadata()
+                    .map_or(0, Metadata::len)
+                    .cmp(&a.metadata().map_or(0, Metadata::len))
+                    .then(a.file_name().cmp(b.file_name()))
+            });
         }
         // The default sort in GNU ls is case insensitive
         Sort::Name => entries.sort_unstable_by(|a, b| a.display_name().cmp(b.display_name())),
@@ -1512,7 +1517,7 @@ fn sort_entries(entries: &mut [PathData], config: &Config) {
     }
 
     if config.group_directories_first && config.sort != Sort::None {
-        entries.sort_unstable_by_key(|p| {
+        entries.sort_by_key(|p| {
             let ft = {
                 // We will always try to deref symlinks to group directories, so PathData.md
                 // is not always useful.

src/uu/factor/src/factor.rs

@@ -27,16 +27,9 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let matches = uucore::clap_localization::handle_clap_result(uu_app(), args)?;
 
     #[allow(clippy::unwrap_used, reason = "clap provides 'y' by default")]
-    let mut buffer = args_into_buffer(matches.get_many::<OsString>("STRING").unwrap())?;
-    #[cfg(any(target_os = "linux", target_os = "android"))]
-    let aligned_before_growing = PAGE_SIZE.is_multiple_of(buffer.len());
-
-    prepare_buffer(&mut buffer);
-    #[cfg(any(target_os = "linux", target_os = "android"))]
-    let res = exec(&buffer, aligned_before_growing);
-    #[cfg(not(any(target_os = "linux", target_os = "android")))]
-    let res = exec(&buffer);
-    match res {
+    let buffer = args_into_buffer(matches.get_many::<OsString>("STRING").unwrap())?;
+
+    match exec(buffer) {
         Ok(()) => Ok(()),
         // On Windows, silently handle broken pipe since there's no SIGPIPE
         #[cfg(windows)]
@@ -98,7 +91,7 @@ fn args_into_buffer<'a>(i: impl Iterator<Item = &'a OsString>) -> UResult<Vec<u8
 
 /// Assumes buf holds a single output line forged from the command line arguments, copies it
 /// repeatedly until the buffer holds as many copies as it can
-fn prepare_buffer(buf: &mut Vec<u8>) {
+fn repeat_content_to_capacity(buf: &mut Vec<u8>) {
     let line_len = buf.len();
     debug_assert!(line_len > 0, "buffer is not empty since we have newline");
     let target_size = line_len * (buf.capacity() / line_len); // 0 if line_len is already large enough
@@ -111,16 +104,21 @@ fn prepare_buffer(buf: &mut Vec<u8>) {
 }
 
 #[cfg(not(any(target_os = "linux", target_os = "android")))]
-pub fn exec(bytes: &[u8]) -> io::Result<()> {
+pub fn exec(mut bytes: Vec<u8>) -> io::Result<()> {
+    repeat_content_to_capacity(&mut bytes);
+    let bytes = bytes.as_slice();
     let mut stdout = io::stdout().lock();
     loop {
         stdout.write_all(bytes)?;
     }
 }
 
 #[cfg(any(target_os = "linux", target_os = "android"))]
-pub fn exec(bytes: &[u8], aligned: bool) -> io::Result<()> {
+pub fn exec(mut bytes: Vec<u8>) -> io::Result<()> {
     use uucore::pipes::{pipe, splice, tee};
+    let aligned = PAGE_SIZE.is_multiple_of(bytes.len());
+    repeat_content_to_capacity(&mut bytes);
+    let bytes = bytes.as_slice();
     let mut stdout = io::stdout(); // no need to lock with zero-copy
     // don't show any error from fast-path and fallback to write for proper message
     if let Ok((p_read, mut p_write)) = pipe()
@@ -182,7 +180,7 @@ mod tests {
         for (line, final_len) in tests {
             let mut v = Vec::with_capacity(BUF_SIZE);
             v.extend(std::iter::repeat_n(b'a', line));
-            prepare_buffer(&mut v);
+            repeat_content_to_capacity(&mut v);
             assert_eq!(v.len(), final_len);
         }
     }

src/uu/ls/src/ls.rs

@@ -1941,6 +1941,10 @@ fn test_ls_group_directories_first() {
     }
     filenames.sort_unstable();
 
+    for (i, name) in filenames.iter().enumerate() {
+        at.write_bytes(name, "a".repeat(i).as_bytes());
+    }
+
     let dirnames = ["aaa", "bbb", "ccc", "yyy"];
     for dirname in dirnames {
         at.mkdir(dirname);
@@ -1954,27 +1958,39 @@ fn test_ls_group_directories_first() {
         .arg("--group-directories-first")
         .succeeds();
     assert_eq!(
-        result.stdout_str().split('\n').collect::<Vec<_>>(),
+        result.stdout_str().lines().collect::<Vec<_>>(),
         dots.into_iter()
             .chain(dirnames.into_iter())
             .chain(filenames.into_iter())
-            .chain([""].into_iter())
             .collect::<Vec<_>>(),
     );
 
+    let result = scene
+        .ucmd()
+        .arg("-1")
+        .arg("--group-directories-first")
+        .arg("--sort=size")
+        .succeeds();
+    assert_eq!(
+        result.stdout_str().lines().collect::<Vec<_>>(),
+        dirnames
+            .into_iter()
+            .chain(filenames.into_iter().rev())
+            .collect::<Vec<_>>()
+    );
+
     let result = scene
         .ucmd()
         .arg("-1ar")
         .arg("--group-directories-first")
         .succeeds();
     assert_eq!(
-        result.stdout_str().split('\n').collect::<Vec<_>>(),
+        result.stdout_str().lines().collect::<Vec<_>>(),
         dirnames
             .into_iter()
             .rev()
             .chain(dots.into_iter().rev())
             .chain(filenames.into_iter().rev())
-            .chain([""].into_iter())
             .collect::<Vec<_>>(),
     );