bashrs 6.66.0

Rust-to-Shell transpiler for deterministic bootstrap scripts
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

//! Translation Patterns for Bash-to-Rash
//!
//! Defines mapping patterns from bash constructs to Rash code.

/// Pattern for translating bash variable assignments
pub struct VariablePattern {
    pub exported: bool,
}

impl VariablePattern {
    pub fn to_rash(&self, name: &str, value_rash: &str) -> String {
        if self.exported {
            format!(
                "let {} = {};\nstd::env::set_var(\"{}\", {});",
                name, value_rash, name, name
            )
        } else {
            format!("let {} = {};", name, value_rash)
        }
    }
}

/// Pattern for translating bash commands
pub struct CommandPattern;

impl CommandPattern {
    pub fn to_rash(cmd: &str, args: &[String]) -> String {
        if args.is_empty() {
            format!("{}();", cmd)
        } else {
            let args_str = args.join(", ");
            format!("{}({});", cmd, args_str)
        }
    }
}

/// Pattern for translating bash if statements
pub struct IfPattern;

impl IfPattern {
    pub fn to_rash(
        condition: &str,
        then_block: &str,
        elif_blocks: &[(String, String)],
        else_block: Option<&str>,
    ) -> String {
        let mut result = format!("if {} {{\n{}}}", condition, then_block);

        for (elif_cond, elif_body) in elif_blocks {
            result.push_str(&format!(" else if {} {{\n{}}}", elif_cond, elif_body));
        }

        if let Some(else_body) = else_block {
            result.push_str(&format!(" else {{\n{}}}", else_body));
        }

        result
    }
}

/// Pattern for translating bash for loops
pub struct ForPattern;

impl ForPattern {
    pub fn to_rash(variable: &str, items: &str, body: &str) -> String {
        format!("for {} in {} {{\n{}}}", variable, items, body)
    }
}

/// Pattern for translating bash while loops
pub struct WhilePattern;

impl WhilePattern {
    pub fn to_rash(condition: &str, body: &str) -> String {
        format!("while {} {{\n{}}}", condition, body)
    }
}

/// Pattern for translating bash functions
pub struct FunctionPattern;

impl FunctionPattern {
    pub fn to_rash(name: &str, body: &str) -> String {
        format!("fn {}() {{\n{}}}", name, body)
    }
}

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

    #[test]
    fn test_variable_pattern() {
        let pattern = VariablePattern { exported: false };
        let rash = pattern.to_rash("FOO", "\"bar\"");
        assert!(rash.contains("let FOO = \"bar\";"));
    }

    #[test]
    fn test_exported_variable_pattern() {
        let pattern = VariablePattern { exported: true };
        let rash = pattern.to_rash("PATH", "\"/usr/bin\"");
        assert!(rash.contains("std::env::set_var"));
    }

    #[test]
    fn test_command_pattern() {
        let rash = CommandPattern::to_rash("echo", &["\"hello\"".to_string()]);
        assert!(rash.contains("echo(\"hello\")"));
    }

    #[test]
    fn test_if_pattern() {
        let rash = IfPattern::to_rash("x == 1", "    println!(\"one\");", &[], None);
        assert!(rash.contains("if x == 1"));
    }

    #[test]
    fn test_for_pattern() {
        let rash = ForPattern::to_rash("i", "0..10", "    println!(\"{}\", i);");
        assert!(rash.contains("for i in 0..10"));
    }
}