feat: Add --sort arg to CLI to sort by path/size/dates

CHANGELOG.md

@@ -2,6 +2,7 @@
 
 ## Features
 - Add `--ignore-parent` option to override `--no-ignore-parent`, see #1958 (@tmchow)
+- Add `--sort` arg to CLI to sort by path/size/dates, see #1875 and #1982 (@DeflateAwning)
 
 ## Bugfixes
 - Handle invalid working directories gracefully when using `--full-path`, see #1900 (@Xavrir).

Cargo.toml

@@ -75,6 +75,7 @@ diff = "0.1"
 tempfile = "3.27"
 filetime = "0.2"
 test-case = "3.3"
+rand = "0.10.1"
 
 [profile.dev]
 debug = "line-tables-only"

src/cli.rs

@@ -16,7 +16,7 @@ use crate::exec::CommandSet;
 use crate::filesystem;
 #[cfg(unix)]
 use crate::filter::OwnerFilter;
-use crate::filter::SizeFilter;
+use crate::filter::{SizeFilter, SortKey};
 
 #[derive(Parser)]
 #[command(
@@ -549,6 +549,20 @@ pub struct Opts {
     #[arg(long, hide = true, value_parser = parse_millis)]
     pub max_buffer_time: Option<Duration>,
 
+    /// Sort search results by the given key before printing or executing commands.
+    ///
+    /// Note: this buffers all results in memory before outputting.
+    #[arg(
+        long,
+        value_name = "key",
+        value_enum,
+        hide_short_help = true,
+        help = "Sort results by: path, size, created, or modified",
+        long_help,
+        conflicts_with("list_details")
+    )]
+    pub sort: Option<SortKey>,
+
     ///Limit the number of search results to 'count' and quit immediately.
     #[arg(
         long,

src/config.rs

@@ -7,7 +7,7 @@ use crate::exec::CommandSet;
 use crate::filetypes::FileTypes;
 #[cfg(unix)]
 use crate::filter::OwnerFilter;
-use crate::filter::{SizeFilter, TimeFilter};
+use crate::filter::{SizeFilter, SortKey, TimeFilter};
 use crate::fmt::FormatTemplate;
 
 /// Configuration options for *fd*.
@@ -133,6 +133,9 @@ pub struct Config {
 
     /// Names that should stop traversal down their parent. (e.g. https://bford.info/cachedir/).
     pub ignore_contain: Vec<String>,
+
+    /// The key to sort results by
+    pub sort_key: Option<SortKey>,
 }
 
 impl Config {

src/filter/mod.rs

@@ -1,10 +1,12 @@
 pub use self::size::SizeFilter;
+pub use self::sort::SortKey;
 pub use self::time::TimeFilter;
 
 #[cfg(unix)]
 pub use self::owner::OwnerFilter;
 
 mod size;
+mod sort; // Arguably not a "filter", but more of an augmentation on search results.
 mod time;
 
 #[cfg(unix)]

src/filter/sort.rs

@@ -0,0 +1,13 @@
+use clap::ValueEnum;
+
+#[derive(Copy, Clone, PartialEq, Eq, Debug, ValueEnum)]
+pub enum SortKey {
+    /// Sort by path
+    Path,
+    /// Sort by file size
+    Size,
+    /// Sort by creation time
+    Created,
+    /// Sort by modification time
+    Modified,
+}

src/main.rs

@@ -336,6 +336,7 @@ fn construct_config(mut opts: Opts, pattern_regexps: &[String]) -> Result<Config
         max_results: opts.max_results(),
         strip_cwd_prefix: opts.strip_cwd_prefix(|| !(opts.null_separator || has_command)),
         ignore_contain: opts.ignore_contain,
+        sort_key: opts.sort,
     })
 }
 

src/walk.rs

@@ -21,6 +21,7 @@ use crate::error::print_error;
 use crate::exec;
 use crate::exit_codes::{ExitCode, merge_exitcodes};
 use crate::filesystem;
+use crate::filter::SortKey;
 use crate::output;
 
 /// The receiver thread can either be buffering results or directly streaming to the console.
@@ -411,7 +412,18 @@ impl WorkerState {
         // This will be set to `Some` if the `--exec` argument was supplied.
         if let Some(ref cmd) = config.command {
             if cmd.in_batch_mode() {
-                exec::batch(rx.into_iter().flatten(), cmd, config)
+                let mut results: Vec<WorkerResult> = rx.into_iter().flatten().collect();
+                if let Some(sort_key) = config.sort_key {
+                    sort_worker_results(&mut results, sort_key);
+                }
+                exec::batch(results, cmd, config)
+            } else if let Some(sort_key) = config.sort_key {
+                // With --sort, we must collect all results before dispatching,
+                // and run sequentially so the order is preserved.
+
+                let mut results: Vec<WorkerResult> = rx.into_iter().flatten().collect();
+                sort_worker_results(&mut results, sort_key);
+                exec::job(results, cmd, config)
             } else {
                 thread::scope(|scope| {
                     // Each spawned job will store its thread handle in here.
@@ -663,6 +675,35 @@ impl WorkerState {
     }
 }
 
+fn sort_worker_results(results: &mut [WorkerResult], sort_key: SortKey) {
+    results.sort_by(|a, b| {
+        // Errors sort to the end; two errors are considered equal
+        let (WorkerResult::Entry(a), WorkerResult::Entry(b)) = (a, b) else {
+            return match (a, b) {
+                (WorkerResult::Error(_), WorkerResult::Entry(_)) => std::cmp::Ordering::Greater,
+                (WorkerResult::Entry(_), WorkerResult::Error(_)) => std::cmp::Ordering::Less,
+                _ => std::cmp::Ordering::Equal,
+            };
+        };
+
+        match sort_key {
+            SortKey::Path => a.path().cmp(b.path()),
+            SortKey::Size => {
+                let size = |e: &DirEntry| e.metadata().map(|m| m.len()).unwrap_or(0);
+                size(a).cmp(&size(b))
+            }
+            SortKey::Created => {
+                let time = |e: &DirEntry| e.metadata().and_then(|m| m.created().ok());
+                time(a).cmp(&time(b))
+            }
+            SortKey::Modified => {
+                let time = |e: &DirEntry| e.metadata().and_then(|m| m.modified().ok());
+                time(a).cmp(&time(b))
+            }
+        }
+    });
+}
+
 fn search_str_for_entry<'a>(
     entry_path: &'a std::path::Path,
     full_path_base: Option<&std::path::Path>,

tests/tests.rs

@@ -2023,6 +2023,49 @@ fn test_exec_batch_with_limit() {
     );
 }
 
+fn shuffle_files(files: &[&'static str], seed: u64) -> Vec<&'static str> {
+    use rand::SeedableRng as _;
+    use rand::seq::SliceRandom as _;
+    let mut files = files.to_vec();
+    files.shuffle(&mut rand::rngs::StdRng::seed_from_u64(seed));
+
+    files
+}
+
+#[test]
+fn test_sort_by_path() {
+    let te = TestEnv::new(DEFAULT_DIRS, &shuffle_files(DEFAULT_FILES, 42));
+
+    // --sort=path should produce deterministic alphabetical output
+    te.assert_output(
+        &["--sort=path", "foo"],
+        "a.foo
+        one/b.foo
+        one/two/C.Foo2
+        one/two/c.foo
+        one/two/three/d.foo
+        one/two/three/directory_foo/",
+    );
+}
+
+/// Shell script execution with --sort (--exec)
+#[cfg(not(windows))]
+#[test]
+fn test_sort_by_path_with_exec() {
+    let te = TestEnv::new(DEFAULT_DIRS, &shuffle_files(DEFAULT_FILES, 42));
+
+    // --exec with --sort should produce output in sorted order
+    te.assert_output(
+        &["foo", "--sort=path", "--exec", "echo", "File: {}"],
+        "File: ./a.foo
+        File: ./one/b.foo
+        File: ./one/two/C.Foo2
+        File: ./one/two/c.foo
+        File: ./one/two/three/d.foo
+        File: ./one/two/three/directory_foo",
+    );
+}
+
 /// Shell script execution (--exec) with a custom --path-separator
 #[test]
 fn test_exec_with_separator() {