rustlens 0.2.1

Blazing-fast Rust Code Inspector for the Terminal
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
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

//! Application settings and configuration

use crate::error::Result;
use serde::{Deserialize, Serialize};
use std::path::PathBuf;

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Settings {
    pub ui: UiSettings,
    pub analyzer: AnalyzerSettings,
    pub keybindings: KeybindingSettings,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct UiSettings {
    pub theme: String,
    pub show_line_numbers: bool,
    pub vim_mode: bool,
    pub tab_width: usize,
    pub wrap_text: bool,
    pub accent_color: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AnalyzerSettings {
    pub include_private: bool,
    pub include_tests: bool,
    pub max_depth: usize,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct KeybindingSettings {
    pub quit: String,
    pub search: String,
    pub help: String,
    pub next_tab: String,
    pub prev_tab: String,
    pub select: String,
}

impl Default for Settings {
    fn default() -> Self {
        Self {
            ui: UiSettings {
                theme: "default".into(),
                show_line_numbers: true,
                vim_mode: false,
                tab_width: 4,
                wrap_text: false,
                accent_color: "#4EBF71".into(),
            },
            analyzer: AnalyzerSettings {
                include_private: true,
                include_tests: false,
                max_depth: 10,
            },
            keybindings: KeybindingSettings {
                quit: "q".into(),
                search: "/".into(),
                help: "?".into(),
                next_tab: "Tab".into(),
                prev_tab: "Shift+Tab".into(),
                select: "Enter".into(),
            },
        }
    }
}

impl Settings {
    pub fn load() -> Result<Self> {
        let config_path = Self::config_path()?;

        if !config_path.exists() {
            return Ok(Self::default());
        }

        let content = std::fs::read_to_string(&config_path)?;
        let settings: Settings = serde_yaml::from_str(&content)?;
        Ok(settings)
    }

    pub fn save(&self) -> Result<()> {
        let config_path = Self::config_path()?;

        if let Some(parent) = config_path.parent() {
            std::fs::create_dir_all(parent)?;
        }

        let content = serde_yaml::to_string(self)?;
        std::fs::write(&config_path, content)?;
        Ok(())
    }

    fn config_path() -> Result<PathBuf> {
        let config_dir = dirs::config_dir()
            .ok_or_else(|| crate::error::RustlensError::Config("No config directory".into()))?;
        Ok(config_dir.join("rustlens").join("config.yaml"))
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_settings_default() {
        let s = Settings::default();
        assert_eq!(s.ui.theme, "default");
        assert!(s.ui.show_line_numbers);
        assert_eq!(s.keybindings.quit, "q");
        assert_eq!(s.keybindings.search, "/");
        assert!(s.analyzer.include_private);
        assert_eq!(s.analyzer.max_depth, 10);
    }

    #[test]
    fn test_settings_roundtrip_yaml() {
        let s = Settings::default();
        let yaml = serde_yaml::to_string(&s).unwrap();
        let loaded: Settings = serde_yaml::from_str(&yaml).unwrap();
        assert_eq!(s.ui.theme, loaded.ui.theme);
        assert_eq!(s.keybindings.quit, loaded.keybindings.quit);
    }
}