refactor: Use --sort mechanism with printing (until buffer full)

Author: DeflateAwning

src/cli.rs

@@ -547,7 +547,7 @@ pub struct Opts {
     ///
     /// Amount of time in milliseconds to buffer, before streaming the search
     /// results to the console.
-    #[arg(long, hide = true, value_parser = parse_millis)]
+    #[arg(long, hide = true, value_parser = parse_millis, conflicts_with("sort"))]
     pub max_buffer_time: Option<Duration>,
 
     /// Sort search results by the given key before printing or executing commands.
@@ -560,7 +560,7 @@ pub struct Opts {
         hide_short_help = true,
         help = "Sort results by: path, size, created, or modified",
         long_help,
-        conflicts_with("list_details")
+        conflicts_with_all(&["list_details", "max_buffer_time"])
     )]
     pub sort: Option<SortKey>,
 

src/main.rs

@@ -17,6 +17,7 @@ use std::env;
 use std::io::IsTerminal;
 use std::path::Path;
 use std::sync::Arc;
+use std::time::Duration;
 
 use anyhow::{Context, Result, anyhow, bail};
 use clap::{CommandFactory, Parser};
@@ -273,7 +274,11 @@ fn construct_config(mut opts: Opts, pattern_regexps: &[String]) -> Result<Config
         min_depth: opts.min_depth(),
         prune: opts.prune,
         threads: opts.threads().get(),
-        max_buffer_time: opts.max_buffer_time,
+        max_buffer_time: match opts.sort {
+            // If sorting is enabled, the set max_buffer_time to practically infinity.
+            Some(_) => Some(Duration::from_secs(u64::MAX / 2)),
+            None => opts.max_buffer_time,
+        },
         ls_colors,
         hyperlink,
         interactive_terminal,

src/walk.rs

@@ -24,7 +24,7 @@ use crate::filesystem;
 use crate::output;
 
 /// The receiver thread can either be buffering results or directly streaming to the console.
-#[derive(PartialEq)]
+#[derive(Copy, Clone, PartialEq)]
 enum ReceiverMode {
     /// Receiver is still buffering in order to sort the results, if the search finishes fast
     /// enough.
@@ -241,6 +241,7 @@ impl<'a, W: Write> ReceiverBuffer<'a, W> {
                 self.stream()?;
             }
             Err(RecvTimeoutError::Disconnected) => {
+                // Note: This branch is called when all the results are walked/exhausted.
                 return self.stop();
             }
         }
@@ -280,9 +281,22 @@ impl<'a, W: Write> ReceiverBuffer<'a, W> {
 
     /// Stop looping.
     fn stop(&mut self) -> Result<(), ExitCode> {
-        if self.mode == ReceiverMode::Buffering {
-            self.buffer.sort();
-            self.stream()?;
+        match (self.mode, self.config.sort_key) {
+            (ReceiverMode::Buffering, None) => {
+                self.buffer.sort();
+                self.stream()?;
+            }
+            (ReceiverMode::Buffering, Some(sort_key)) => {
+                sort_dir_entry_results(&mut self.buffer, sort_key);
+                self.stream()?;
+            }
+            (ReceiverMode::Streaming, None) => {}
+            (ReceiverMode::Streaming, Some(_)) => {
+                // We force Buffering mode in Config construction if --sort is set by setting the timeout to almost infinity.
+                unreachable!(
+                    "--sort cannot work in Streaming mode. Buffering mode is forced in Config construction."
+                );
+            }
         }
 
         if self.config.quiet {
@@ -674,36 +688,30 @@ impl WorkerState {
     }
 }
 
+fn dir_entry_key_fn(sort_key: SortKey) -> Box<dyn Fn(&DirEntry) -> Option<SortKeyValue>> {
+    match sort_key {
+        SortKey::Path => Box::new(|e| Some(SortKeyValue::Path(e.path().to_path_buf()))),
+        SortKey::Size => Box::new(|e| e.metadata().map(|m| SortKeyValue::Size(m.len()))),
+        SortKey::Created => {
+            Box::new(|e| e.metadata().map(|m| SortKeyValue::Time(m.created().ok())))
+        }
+        SortKey::Modified => {
+            Box::new(|e| e.metadata().map(|m| SortKeyValue::Time(m.modified().ok())))
+        }
+    }
+}
+
+fn sort_dir_entry_results(results: &mut [DirEntry], sort_key: SortKey) {
+    let key_fn = dir_entry_key_fn(sort_key);
+    results.sort_by_cached_key(|e| key_fn(e));
+}
+
 fn sort_worker_results(results: &mut [WorkerResult], sort_key: SortKey) {
-    // Build the key extractor once, based on sort_key.
-    // Returns None for errors, pushing them to the end naturally via Ord on Option.
-    let key_fn: Box<dyn Fn(&WorkerResult) -> Option<SortKeyValue>> = match sort_key {
-        SortKey::Path => Box::new(|r| match r {
-            WorkerResult::Entry(e) => Some(SortKeyValue::Path(e.path().to_path_buf())),
-            WorkerResult::Error(_) => None,
-        }),
-        SortKey::Size => Box::new(|r| match r {
-            WorkerResult::Entry(e) => Some(SortKeyValue::Size(
-                e.metadata().map(|m| m.len()).unwrap_or(0),
-            )),
-            WorkerResult::Error(_) => None,
-        }),
-        SortKey::Created => Box::new(|r| match r {
-            WorkerResult::Entry(e) => Some(SortKeyValue::Time(
-                e.metadata().and_then(|m| m.created().ok()),
-            )),
-            WorkerResult::Error(_) => None,
-        }),
-        SortKey::Modified => Box::new(|r| match r {
-            WorkerResult::Entry(e) => Some(SortKeyValue::Time(
-                e.metadata().and_then(|m| m.modified().ok()),
-            )),
-            WorkerResult::Error(_) => None,
-        }),
-    };
-
-    // Use sort_by_cached_key to avoid recomputing the key for each comparison.
-    results.sort_by_cached_key(|r| key_fn(r));
+    let key_fn = dir_entry_key_fn(sort_key);
+    results.sort_by_cached_key(|r| match r {
+        WorkerResult::Entry(e) => key_fn(e),
+        WorkerResult::Error(_) => None,
+    });
 }
 
 /// Comparable key values, one variant per SortKey.