dela 0.0.6

A task runner that delegates the work to other tools
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

use std::env;

const ZSH_CONFIG: &str = include_str!("../../resources/zsh.sh");
const BASH_CONFIG: &str = include_str!("../../resources/bash.sh");
const FISH_CONFIG: &str = include_str!("../../resources/fish.sh");
const PWSH_CONFIG: &str = include_str!("../../resources/pwsh.ps1");

#[derive(Debug, PartialEq)]
enum Shell {
    Zsh,
    Bash,
    Fish,
    Pwsh,
    Unknown(String),
}

impl Shell {
    fn from_path(path: &str) -> Result<Shell, String> {
        let shell_path = std::path::PathBuf::from(path);
        let shell_name = shell_path
            .file_name()
            .and_then(|name| name.to_str())
            .ok_or_else(|| "Invalid shell path".to_string())?;

        match shell_name {
            "zsh" => Ok(Shell::Zsh),
            "bash" => Ok(Shell::Bash),
            "fish" => Ok(Shell::Fish),
            "pwsh" => Ok(Shell::Pwsh),
            name => Ok(Shell::Unknown(name.to_string())),
        }
    }
}

pub fn execute() -> Result<(), String> {
    // Get the current shell from SHELL environment variable
    let shell = env::var("SHELL").map_err(|_| "SHELL environment variable not set".to_string())?;

    // Parse the shell type
    let shell_type = Shell::from_path(&shell)?;

    // Handle each shell type
    match shell_type {
        Shell::Zsh => {
            print!("{}", ZSH_CONFIG);
            Ok(())
        }
        Shell::Bash => {
            print!("{}", BASH_CONFIG);
            Ok(())
        }
        Shell::Fish => {
            print!("{}", FISH_CONFIG);
            Ok(())
        }
        Shell::Pwsh => {
            print!("{}", PWSH_CONFIG);
            Ok(())
        }
        Shell::Unknown(name) => Err(format!("Unsupported shell: {}", name)),
    }
}

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

    fn setup_test_env(shell: &str) {
        env::remove_var("SHELL");
        env::set_var("SHELL", shell);
    }

    #[test]
    #[serial]
    fn test_zsh_shell() {
        setup_test_env("/bin/zsh");
        let result = execute();
        assert!(result.is_ok());
    }

    #[test]
    #[serial]
    fn test_bash_shell() {
        setup_test_env("/bin/bash");
        let result = execute();
        assert!(result.is_ok());
    }

    #[test]
    #[serial]
    fn test_fish_shell() {
        setup_test_env("/usr/local/bin/fish");
        let result = execute();
        assert!(result.is_ok());
    }

    #[test]
    #[serial]
    fn test_pwsh_shell() {
        setup_test_env("/usr/bin/pwsh");
        let result = execute();
        assert!(result.is_ok());
    }

    #[test]
    #[serial]
    fn test_unknown_shell() {
        setup_test_env("/bin/unknown");
        let result = execute();
        assert!(result.is_err());
        assert_eq!(result.unwrap_err(), "Unsupported shell: unknown");
    }

    #[test]
    #[serial]
    fn test_invalid_shell_path() {
        setup_test_env("");
        let result = execute();
        assert!(result.is_err());
        assert_eq!(result.unwrap_err(), "Invalid shell path");
    }

    #[test]
    #[serial]
    fn test_missing_shell_env() {
        env::remove_var("SHELL");
        let result = execute();
        assert!(result.is_err());
        assert_eq!(result.unwrap_err(), "SHELL environment variable not set");
    }
}