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
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

fn test_shellcheck_long_variable_names() {
    let source = r#"
        fn main() {
            let very_long_variable_name_that_is_descriptive = "test";
            let another_extremely_long_name_for_testing = "value";

            echo(very_long_variable_name_that_is_descriptive);
            echo(another_extremely_long_name_for_testing);
        }
    "#;

    transpile_and_validate(source).expect("Long variable names should pass shellcheck");
}

// ============================================================================
// PROPERTY 8: Boolean values pass ShellCheck
// ============================================================================

#[test]
fn test_shellcheck_boolean_true() {
    let source = r#"
        fn main() {
            let flag = true;
            if flag {
                echo("true");
            }
        }
    "#;

    transpile_and_validate(source).expect("Boolean true should pass shellcheck");
}

#[test]
fn test_shellcheck_boolean_false() {
    let source = r#"
        fn main() {
            let flag = false;
            if flag {
                echo("won't run");
            } else {
                echo("will run");
            }
        }
    "#;

    transpile_and_validate(source).expect("Boolean false should pass shellcheck");
}

// ============================================================================
// PROPERTY 9: Complex real-world scenarios
// ============================================================================

#[test]
fn test_shellcheck_installer_pattern() {
    let source = r#"
        fn main() {
            let package_name = "my-app";
            let version = "1.0.0";
            let install_path = "/usr/local/bin";

            echo("Installing...");
            check_requirements();
            download_package(package_name, version);
            install_binary(package_name, install_path);
            echo("Installation complete!");
        }

        fn check_requirements() {
            echo("Checking requirements...");
        }

        fn download_package(name: &str, ver: &str) {
            echo(name);
            echo(ver);
        }

        fn install_binary(name: &str, path: &str) {
            echo(name);
            echo(path);
        }
    "#;

    transpile_and_validate(source).expect("Installer pattern should pass shellcheck");
}

#[test]
fn test_shellcheck_error_handling_pattern() {
    let source = r#"
        fn main() {
            let success = true;

            if success {
                echo("Success!");
            } else {
                handle_error("Operation failed");
            }
        }

        fn handle_error(message: &str) {
            echo(message);
        }
    "#;

    transpile_and_validate(source).expect("Error handling pattern should pass shellcheck");
}

// ============================================================================
// PROPERTY 10: Determinism - byte-identical output
// ============================================================================

#[test]
fn test_deterministic_output() {
    let source = r#"
        fn main() {
            let x = "test";
            if true {
                echo(x);
            }
        }
    "#;

    let config = Config::default();

    // Transpile 10 times
    let results: Vec<String> = (0..10)
        .map(|_| transpile(source, &config).unwrap())
        .collect();

    // All results should be byte-identical
    for (i, result) in results.iter().enumerate().skip(1) {
        assert_eq!(
            &results[0], result,
            "Transpilation {} differs from first result",
            i
        );
    }

    // And should pass shellcheck
    shellcheck_validate(&results[0]).expect("Deterministic output should pass shellcheck");
}