whi 0.3.2

Stupid simple PATH management
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
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150

use std::env;
use std::path::PathBuf;
use std::str::FromStr;

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Shell {
    Bash,
    Zsh,
    Fish,
}

impl Shell {
    pub fn as_str(&self) -> &'static str {
        match self {
            Shell::Bash => "bash",
            Shell::Zsh => "zsh",
            Shell::Fish => "fish",
        }
    }
}

impl FromStr for Shell {
    type Err = String;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match s.to_lowercase().as_str() {
            "bash" => Ok(Shell::Bash),
            "zsh" => Ok(Shell::Zsh),
            "fish" => Ok(Shell::Fish),
            _ => Err(format!(
                "Unknown shell: {s}. Valid options: bash, zsh, fish"
            )),
        }
    }
}

/// Detect the current shell from environment
pub fn detect_current_shell() -> Result<Shell, String> {
    // Try $SHELL environment variable first
    if let Ok(shell_path) = env::var("SHELL") {
        if shell_path.contains("bash") {
            return Ok(Shell::Bash);
        } else if shell_path.contains("zsh") {
            return Ok(Shell::Zsh);
        } else if shell_path.contains("fish") {
            return Ok(Shell::Fish);
        }
    }

    // Fallback: Check for shell-specific environment variables
    if env::var("BASH_VERSION").is_ok() {
        return Ok(Shell::Bash);
    }
    if env::var("ZSH_VERSION").is_ok() {
        return Ok(Shell::Zsh);
    }
    if env::var("FISH_VERSION").is_ok() {
        return Ok(Shell::Fish);
    }

    Err("Could not detect shell. Please specify: bash, zsh, or fish".to_string())
}

/// Get the config file path for a given shell
pub fn get_config_file_path(shell: &Shell) -> Result<PathBuf, String> {
    let home = env::var("HOME").map_err(|_| "HOME environment variable not set".to_string())?;
    let home_path = PathBuf::from(home);

    match shell {
        Shell::Bash => {
            // Prefer ~/.bash_profile (especially on macOS)
            let bash_profile = home_path.join(".bash_profile");
            if bash_profile.exists() {
                return Ok(bash_profile);
            }

            // Fallback to ~/.bashrc (common on Linux)
            let bashrc = home_path.join(".bashrc");
            if bashrc.exists() {
                return Ok(bashrc);
            }

            // Default to .bash_profile on macOS, .bashrc on Linux
            #[cfg(target_os = "macos")]
            {
                Ok(bash_profile)
            }
            #[cfg(not(target_os = "macos"))]
            {
                Ok(bashrc)
            }
        }
        Shell::Zsh => {
            // Use ~/.zprofile (recommended for PATH on macOS)
            Ok(home_path.join(".zprofile"))
        }
        Shell::Fish => {
            // Use ~/.config/fish/config.fish
            Ok(home_path.join(".config/fish/config.fish"))
        }
    }
}

/// Get the path to the saved PATH file for a given shell
pub fn get_saved_path_file(shell: &Shell) -> Result<PathBuf, String> {
    let home = env::var("HOME").map_err(|_| "HOME environment variable not set".to_string())?;
    let whi_dir = PathBuf::from(home).join(".whi");

    Ok(whi_dir.join(format!("saved_path_{}", shell.as_str())))
}

/// Get the sourcing line to add to shell config
pub fn get_sourcing_line(shell: &Shell) -> Result<String, String> {
    let saved_path_file = get_saved_path_file(shell)?;
    let saved_path_str = saved_path_file.display().to_string();

    match shell {
        Shell::Bash | Shell::Zsh => {
            Ok(format!(
                "# whi: Load saved PATH\n[ -f {saved_path_str} ] && export PATH=\"$(cat {saved_path_str})\"\n"
            ))
        }
        Shell::Fish => {
            Ok(format!(
                "# whi: Load saved PATH\nif test -f {saved_path_str}\n    set -gx PATH (cat {saved_path_str} | string split :)\nend\n"
            ))
        }
    }
}

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

    #[test]
    fn test_shell_from_str() {
        assert_eq!("bash".parse::<Shell>().unwrap(), Shell::Bash);
        assert_eq!("BASH".parse::<Shell>().unwrap(), Shell::Bash);
        assert_eq!("zsh".parse::<Shell>().unwrap(), Shell::Zsh);
        assert_eq!("fish".parse::<Shell>().unwrap(), Shell::Fish);
        assert!("invalid".parse::<Shell>().is_err());
    }

    #[test]
    fn test_shell_as_str() {
        assert_eq!(Shell::Bash.as_str(), "bash");
        assert_eq!(Shell::Zsh.as_str(), "zsh");
        assert_eq!(Shell::Fish.as_str(), "fish");
    }
}