sicth 1.1.0

A minimal TUI file navigator with fuzzy search
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

use std::path::{Path, PathBuf};

use crate::settings::SortKey;

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum Kind {
    Dir,
    File,
}

#[derive(Debug, Clone)]
pub struct Entry {
    pub rel: String,
    pub abs: PathBuf,
    pub kind: Kind,
    pub size: u64,
    pub mtime: Option<std::time::SystemTime>,
}

fn from_dir_entry(de: &std::fs::DirEntry) -> Entry {
    let name = de.file_name().to_string_lossy().to_string();
    let path = de.path();
    let kind = if path.is_dir() { Kind::Dir } else { Kind::File };
    let meta = de.metadata().ok();
    Entry {
        rel: name,
        abs: path,
        kind,
        size: meta.as_ref().map(|m| m.len()).unwrap_or(0),
        mtime: meta.and_then(|m| m.modified().ok()),
    }
}

fn sort(entries: &mut [Entry], sort_by: SortKey, dirs_first: bool, reverse: bool) {
    entries.sort_by(|a, b| {
        let pa = a.kind == Kind::Dir;
        let pb = b.kind == Kind::Dir;
        let pa = if dirs_first { !pa } else { pa };
        let pb = if dirs_first { !pb } else { pb };
        pa.cmp(&pb)
            .then_with(|| match sort_by {
                SortKey::Name => a.rel.to_lowercase().cmp(&b.rel.to_lowercase()),
                SortKey::Size => b.size.cmp(&a.size),
                SortKey::Mtime => b.mtime.cmp(&a.mtime),
            })
            .then_with(|| a.rel.to_lowercase().cmp(&b.rel.to_lowercase()))
    });
    if reverse {
        entries.reverse();
    }
}

/// One-level listing of `dir`, dirs first then case-insensitive name.
/// Dotfiles skipped unless show_hidden.
/// Unreadable entries are skipped silently; unreadable dir -> empty Vec.
pub fn browse(
    dir: &Path,
    show_hidden: bool,
    sort_by: SortKey,
    dirs_first: bool,
    reverse: bool,
) -> Vec<Entry> {
    let Ok(iter) = dir.read_dir() else {
        return Vec::new();
    };
    let mut entries: Vec<Entry> = iter
        .filter_map(|r| r.ok())
        .filter_map(|de| {
            let name_str = de.file_name().to_string_lossy().to_string();
            if !show_hidden && name_str.starts_with('.') {
                return None;
            }
            Some(from_dir_entry(&de))
        })
        .collect();
    sort(&mut entries, sort_by, dirs_first, reverse);
    entries
}

/// Recursive listing under `dir` via `ignore::WalkBuilder`.
/// Capped at 100k entries to avoid pathological hangs.
pub fn browse_recursive(
    dir: &Path,
    show_hidden: bool,
    ignore_gitignore: bool,
    follow_links: bool,
    sort_by: SortKey,
    dirs_first: bool,
    reverse: bool,
) -> Vec<Entry> {
    let mut b = ignore::WalkBuilder::new(dir);
    b.hidden(!show_hidden)
        .git_ignore(!ignore_gitignore)
        .git_global(!ignore_gitignore)
        .git_exclude(!ignore_gitignore)
        .parents(true)
        .follow_links(follow_links)
        .filter_entry(|e| e.file_name() != ".git");
    let mut out: Vec<Entry> = Vec::new();
    for r in b.build() {
        if out.len() >= 100_000 {
            break;
        }
        let Ok(de) = r else {
            continue;
        };
        let abs = de.path().to_path_buf();
        if abs == dir {
            continue;
        }
        let rel = abs
            .strip_prefix(dir)
            .unwrap_or(&abs)
            .to_string_lossy()
            .to_string();
        let kind = if abs.is_dir() { Kind::Dir } else { Kind::File };
        let meta = de.metadata().ok();
        out.push(Entry {
            rel,
            abs,
            kind,
            size: meta.as_ref().map(|m| m.len()).unwrap_or(0),
            mtime: meta.and_then(|m| m.modified().ok()),
        });
    }
    sort(&mut out, sort_by, dirs_first, reverse);
    out
}