iforgor 0.3.3

The CLI tool for all those commands you forget about
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

use {
    serde::{Deserialize, Serialize},
    std::path::Path,
};

use crate::{
    command::{AfterRun, Shell},
    discover,
    on_disk::OnDisk,
};

const CONFIG_FILE: &str = ".config.toml";

/// Configuration loaded from `.iforgor/.config.toml`.
/// When merging multiple configs, project-level overrides global (closest wins).
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct Config {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub default_shell: Option<Shell>,

    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub default_after_run: Option<AfterRun>,
}

impl Config {
    /// Load and merge configs from all discovered `.iforgor/` dirs.
    /// Closest (most specific) folder wins for each field.
    pub fn load_merged(start_dir: &Path) -> Self {
        let dirs = discover::discover_iforgor_dirs(start_dir);
        let mut merged = Config::default();

        // dirs are ordered closest-first, so first non-None wins.
        for dir in &dirs {
            let config_path = dir.join(CONFIG_FILE);
            match OnDisk::<Config>::open(config_path.clone()) {
                Ok(config) => {
                    if merged.default_shell.is_none() {
                        merged.default_shell = config.default_shell.clone();
                    }
                    if merged.default_after_run.is_none() {
                        merged.default_after_run = config.default_after_run.clone();
                    }
                }
                Err(e) if config_path.exists() => {
                    eprintln!("Warning: failed to parse {}: {e}", config_path.display());
                }
                _ => {}
            }
        }

        merged
    }
}

#[cfg(test)]
mod tests {
    use {super::*, std::fs};

    #[test]
    fn parse_empty_config() {
        let config: Config = toml::from_str("").unwrap();
        assert!(config.default_shell.is_none());
        assert!(config.default_after_run.is_none());
    }

    #[test]
    fn parse_default_shell() {
        let config: Config = toml::from_str(r#"default_shell = "bash""#).unwrap();
        assert!(config.default_shell.is_some());
    }

    #[test]
    fn parse_default_after_run() {
        let config: Config = toml::from_str(r#"default_after_run = "wait""#).unwrap();
        assert!(matches!(config.default_after_run, Some(AfterRun::Wait)));
    }

    #[test]
    fn parse_full_config() {
        let config: Config = toml::from_str(
            r#"
            default_shell = "zsh"
            default_after_run = { Delay = 3 }
            "#,
        )
        .unwrap();
        assert!(config.default_shell.is_some());
        assert!(matches!(config.default_after_run, Some(AfterRun::Delay(3))));
    }

    #[test]
    fn load_merged_closest_wins() {
        let tmp = tempfile::tempdir().unwrap();

        // Create nested .iforgor dirs: project/.iforgor and project/sub/.iforgor
        let project_iforgor = tmp.path().join(".iforgor");
        let sub_iforgor = tmp.path().join("sub").join(".iforgor");
        fs::create_dir_all(&project_iforgor).unwrap();
        fs::create_dir_all(&sub_iforgor).unwrap();

        // Project-level: shell=bash, after_run=wait
        fs::write(
            project_iforgor.join(".config.toml"),
            r#"default_shell = "bash"
default_after_run = "wait""#,
        )
        .unwrap();

        // Sub-level (closer): shell=zsh only
        fs::write(sub_iforgor.join(".config.toml"), r#"default_shell = "zsh""#).unwrap();

        let config = Config::load_merged(&tmp.path().join("sub"));
        // Closest wins for shell
        assert!(matches!(
            config.default_shell,
            Some(Shell::Predefined(crate::command::PredefinedShell::Zsh))
        ));
        // Falls back to project-level for after_run
        assert!(matches!(config.default_after_run, Some(AfterRun::Wait)));
    }
}