rush-sh 0.8.0

A POSIX sh-compatible shell written in Rust
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

use std::io::Write;

use crate::parser::ShellCommand;
use crate::state::ShellState;

pub struct HelpBuiltin;

impl super::Builtin for HelpBuiltin {
    fn name(&self) -> &'static str {
        "help"
    }

    fn names(&self) -> Vec<&'static str> {
        vec![self.name()]
    }

    fn description(&self) -> &'static str {
        "Show this help message"
    }

    fn run(
        &self,
        _cmd: &ShellCommand,
        shell_state: &mut ShellState,
        output_writer: &mut dyn Write,
    ) -> i32 {
        // Write header with color if enabled
        let header = format!("Rush Shell v{}", env!("CARGO_PKG_VERSION"));
        if shell_state.colors_enabled {
            if writeln!(
                output_writer,
                "{}{}\x1b[0m",
                shell_state.color_scheme.success, header
            )
            .is_err()
                || writeln!(output_writer).is_err()
                || writeln!(
                    output_writer,
                    "{}Available built-in commands:\x1b[0m",
                    shell_state.color_scheme.builtin
                )
                .is_err()
            {
                return 1;
            }
        } else if writeln!(output_writer, "{}", header).is_err()
            || writeln!(output_writer).is_err()
            || writeln!(output_writer, "Available built-in commands:").is_err()
        {
            return 1;
        }

        // Iterate over builtins with color if enabled
        let builtins = super::get_builtins();
        for builtin in builtins {
            let formatted_line = format!("  {:<12} {}", builtin.name(), builtin.description());
            if shell_state.colors_enabled {
                if writeln!(
                    output_writer,
                    "{}{}\x1b[0m",
                    shell_state.color_scheme.builtin, formatted_line
                )
                .is_err()
                {
                    return 1;
                }
            } else if writeln!(output_writer, "{}", formatted_line).is_err() {
                return 1;
            }
        }
        0
    }
}

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

    #[test]
    fn test_help_builtin_run() {
        let cmd = ShellCommand {
            args: vec!["help".to_string()],
            redirections: Vec::new(),
            compound: None,
        };
        let mut shell_state = ShellState::new();
        let builtin = HelpBuiltin;
        let mut output = Vec::new();
        let exit_code = builtin.run(&cmd, &mut shell_state, &mut output);
        assert_eq!(exit_code, 0);
        let output_str = String::from_utf8(output).unwrap();
        assert!(output_str.contains("Rush Shell"));
        assert!(output_str.contains("Available built-in commands"));
        assert!(output_str.contains("help"));
    }
}