elio 1.6.0

Snappy, batteries-included terminal file manager with rich previews, inline images, bulk actions, and trash support.
Documentation 
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

mod loading;
mod parsing;
mod resolve;
mod rules;
#[cfg(test)]
mod tests;
mod types;

pub(crate) use self::types::{CodePreviewPalette, Palette};
use self::{
    loading::load_theme_from_disk,
    resolve::builtin_classify_browser_entry,
    types::{EntryClassCacheKey, ResolvedAppearance, Theme},
};
use super::builtin_themes::DEFAULT_THEME_TOML;
use crate::core::{Entry, EntryKind, FileClass};
use std::{
    collections::{HashMap, VecDeque},
    path::Path,
    sync::{Mutex, OnceLock},
};

const ENTRY_CLASS_CACHE_LIMIT: usize = 4_096;

#[derive(Default)]
struct EntryClassCache {
    classes: HashMap<EntryClassCacheKey, FileClass>,
    order: VecDeque<EntryClassCacheKey>,
}

static ACTIVE_THEME: OnceLock<Theme> = OnceLock::new();
static ENTRY_CLASS_CACHE: OnceLock<Mutex<EntryClassCache>> = OnceLock::new();

pub(crate) fn initialize() {
    let _ = ACTIVE_THEME.get_or_init(load_theme_from_disk);
}

pub(crate) fn palette() -> Palette {
    active_theme().palette
}

pub(crate) fn code_preview_palette() -> CodePreviewPalette {
    active_theme().preview.code
}

pub(crate) fn resolve_path(path: &Path, kind: EntryKind) -> ResolvedAppearance<'static> {
    active_theme().resolve(path, kind)
}

pub(crate) fn resolve_path_with_class(
    path: &Path,
    kind: EntryKind,
    class: FileClass,
) -> ResolvedAppearance<'static> {
    active_theme().resolve_with_builtin_class(path, kind, class)
}

pub(crate) fn resolve_entry(entry: &Entry) -> ResolvedAppearance<'static> {
    let builtin_class = resolve::symlink_entry_class(entry)
        .unwrap_or_else(|| crate::file_info::inspect_entry_cached(entry).builtin_class);
    active_theme().resolve_with_builtin_class(&entry.path, entry.kind, builtin_class)
}

pub(crate) fn resolve_browser_entry(entry: &Entry) -> ResolvedAppearance<'static> {
    let builtin_class = builtin_classify_browser_entry(entry);
    active_theme().resolve_with_builtin_class(&entry.path, entry.kind, builtin_class)
}

#[cfg(test)]
pub(crate) fn specific_type_label(path: &Path, kind: EntryKind) -> Option<&'static str> {
    crate::file_info::inspect_path(path, kind).specific_type_label
}

fn active_theme() -> &'static Theme {
    ACTIVE_THEME.get_or_init(Theme::default_theme)
}

fn entry_class_cache() -> &'static Mutex<EntryClassCache> {
    ENTRY_CLASS_CACHE.get_or_init(|| Mutex::new(EntryClassCache::default()))
}

impl EntryClassCache {
    fn get(&self, key: &EntryClassCacheKey) -> Option<FileClass> {
        self.classes.get(key).copied()
    }

    fn insert(&mut self, key: EntryClassCacheKey, class: FileClass) {
        self.classes.insert(key.clone(), class);
        self.order.retain(|cached| cached != &key);
        self.order.push_back(key);
        while self.order.len() > ENTRY_CLASS_CACHE_LIMIT {
            if let Some(stale_key) = self.order.pop_front() {
                self.classes.remove(&stale_key);
            }
        }
    }
}

impl Theme {
    fn default_theme() -> Self {
        Self::apply_config_on(Self::base_theme(), DEFAULT_THEME_TOML).unwrap_or_else(|error| {
            eprintln!("elio: failed to load built-in default theme: {error}");
            Self::base_theme()
        })
    }
}