colorls 1.0.10

A fast, production-ready Rust rewrite of colorls: a beautified ls with icons, colors, git status and tree view.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

use std::cmp::Ordering;

use crate::cli::Cli;
use crate::entry::FileEntry;

fn name_cmp(a: &FileEntry, b: &FileEntry) -> Ordering {
    a.name.to_lowercase().cmp(&b.name.to_lowercase())
}

/// Sort `entries` in place according to the combination of flags on `cli`.
/// Order of precedence: primary key (time/size/extension/name) first, then
/// directories-first / files-first grouping is applied as a stable
/// secondary pass, then the whole thing is reversed if `-r` was given.
pub fn sort_entries(entries: &mut [FileEntry], cli: &Cli) {
    entries.sort_by(|a, b| {
        let primary = if cli.sort_time {
            b.modified.cmp(&a.modified) // newest first
        } else if cli.sort_size {
            b.size.cmp(&a.size) // largest first
        } else if cli.sort_extension {
            let ea = a.extension().unwrap_or_default();
            let eb = b.extension().unwrap_or_default();
            ea.cmp(&eb).then_with(|| name_cmp(a, b))
        } else {
            name_cmp(a, b)
        };
        primary.then_with(|| name_cmp(a, b))
    });

    if cli.group_directories_first {
        entries.sort_by(|a, b| match (a.is_dir, b.is_dir) {
            (true, false) => Ordering::Less,
            (false, true) => Ordering::Greater,
            _ => Ordering::Equal,
        });
    } else if cli.sort_files_first {
        entries.sort_by(|a, b| match (a.is_dir, b.is_dir) {
            (true, false) => Ordering::Greater,
            (false, true) => Ordering::Less,
            _ => Ordering::Equal,
        });
    }

    if cli.reverse {
        entries.reverse();
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use clap::Parser;
    use std::path::PathBuf;
    use std::time::{Duration, SystemTime};

    fn entry(name: &str, is_dir: bool, size: u64, age_secs: u64) -> FileEntry {
        #[cfg(unix)]
        {
            FileEntry {
                path: PathBuf::from(name),
                name: name.to_string(),
                is_dir,
                is_symlink: false,
                symlink_target: None,
                is_broken_symlink: false,
                size,
                modified: Some(SystemTime::now() - Duration::from_secs(age_secs)),
                readonly: false,
                mode: 0o644,
                uid: 0,
                gid: 0,
            }
        }
        #[cfg(not(unix))]
        {
            FileEntry {
                path: PathBuf::from(name),
                name: name.to_string(),
                is_dir,
                is_symlink: false,
                symlink_target: None,
                is_broken_symlink: false,
                size,
                modified: Some(SystemTime::now() - Duration::from_secs(age_secs)),
                readonly: false,
            }
        }
    }

    fn cli_with(args: &[&str]) -> Cli {
        let mut full = vec!["colorls"];
        full.extend_from_slice(args);
        Cli::parse_from(full)
    }

    #[test]
    fn sorts_by_name_case_insensitive_by_default() {
        let mut entries = vec![entry("banana", false, 1, 0), entry("Apple", false, 1, 0)];
        let cli = cli_with(&[]);
        sort_entries(&mut entries, &cli);
        assert_eq!(entries[0].name, "Apple");
        assert_eq!(entries[1].name, "banana");
    }

    #[test]
    fn group_directories_first() {
        let mut entries = vec![entry("a_file", false, 1, 0), entry("z_dir", true, 1, 0)];
        let cli = cli_with(&["--sd"]);
        sort_entries(&mut entries, &cli);
        assert!(entries[0].is_dir);
    }

    #[test]
    fn sort_by_size_largest_first() {
        let mut entries = vec![entry("small", false, 10, 0), entry("large", false, 1000, 0)];
        let cli = cli_with(&["-S"]);
        sort_entries(&mut entries, &cli);
        assert_eq!(entries[0].name, "large");
    }

    #[test]
    fn reverse_flips_final_order() {
        let mut entries = vec![entry("a", false, 1, 0), entry("b", false, 1, 0)];
        let cli = cli_with(&["-r"]);
        sort_entries(&mut entries, &cli);
        assert_eq!(entries[0].name, "b");
        assert_eq!(entries[1].name, "a");
    }
}