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
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159

fn test_batch17_backtick_command_substitution_universal() {
    // Batch 17: Backtick & command substitution (Universal - POSIX)
    let backtick_rules = vec![
        ("SC2036", "Quotes in backticks need escaping"),
        ("SC2037", "To assign command output, use var=$(cmd)"),
    ];

    for (rule, description) in backtick_rules {
        assert_eq!(
            get_rule_compatibility(rule),
            Some(ShellCompatibility::Universal),
            "Batch 17 backtick rule {} ({}) should be Universal (POSIX)",
            rule,
            description
        );

        // Should apply to ALL shells
        for shell in [
            ShellType::Bash,
            ShellType::Zsh,
            ShellType::Sh,
            ShellType::Ksh,
        ] {
            assert!(
                should_apply_rule(rule, shell),
                "{} should apply to {:?}",
                rule,
                shell
            );
        }
    }
}

#[test]
fn test_batch17_function_parameter_usage_universal() {
    // Batch 17: Function & parameter usage (Universal - POSIX positional params, PATH, brace expansion)
    let function_universal_rules = vec![
        (
            "SC2119",
            "Use foo \"$@\" if function's $1 should mean script's $1",
        ),
        (
            "SC2123",
            "PATH is the shell search path. Assign to path instead",
        ),
        ("SC2125", "Brace expansion doesn't happen in [[ ]]"),
    ];

    for (rule, description) in function_universal_rules {
        assert_eq!(
            get_rule_compatibility(rule),
            Some(ShellCompatibility::Universal),
            "Batch 17 function rule {} ({}) should be Universal (POSIX)",
            rule,
            description
        );

        // Should apply to ALL shells
        for shell in [
            ShellType::Bash,
            ShellType::Zsh,
            ShellType::Sh,
            ShellType::Ksh,
        ] {
            assert!(
                should_apply_rule(rule, shell),
                "{} should apply to {:?}",
                rule,
                shell
            );
        }
    }
}

#[test]
fn test_batch17_array_usage_notsh() {
    // Batch 17: Array usage (NotSh - bash/zsh/ksh specific)
    let array_rule = "SC2124";

    assert_eq!(
        get_rule_compatibility(array_rule),
        Some(ShellCompatibility::NotSh),
        "Batch 17 array rule {} should be NotSh (arrays are bash/zsh/ksh specific)",
        array_rule
    );

    // Should NOT apply to POSIX sh
    assert!(
        !should_apply_rule(array_rule, ShellType::Sh),
        "{} should not apply to sh",
        array_rule
    );

    // But SHOULD apply to bash/zsh/ksh
    assert!(
        should_apply_rule(array_rule, ShellType::Bash),
        "{} should apply to bash",
        array_rule
    );
    assert!(
        should_apply_rule(array_rule, ShellType::Zsh),
        "{} should apply to zsh",
        array_rule
    );
}

#[test]
fn test_batch17_parameter_expansion_universal() {
    // Batch 17: Parameter expansion & command optimization (Universal - POSIX)
    let param_expansion_rules = vec![
        (
            "SC2294",
            "Use arithmetic expansion ((...)) for simple assignments",
        ),
        (
            "SC2295",
            "Expansions inside ${} need to be quoted separately",
        ),
        ("SC2296", "Parameter expansions can't be nested"),
        ("SC2297", "Redirect before pipe"),
        ("SC2298", "Useless use of cat before pipe"),
        ("SC2299", "Parameter expansion only allows literals here"),
        ("SC2300", "Use ${var:?} for required environment variables"),
        ("SC2303", "Arithmetic base only allowed in assignments"),
        ("SC2304", "Command appears to be undefined"),
        ("SC2305", "Use ${var:=value} to assign default value"),
        (
            "SC2319",
            "This $? refers to a condition, not the previous command",
        ),
    ];

    for (rule, description) in param_expansion_rules {
        assert_eq!(
            get_rule_compatibility(rule),
            Some(ShellCompatibility::Universal),
            "Batch 17 parameter expansion rule {} ({}) should be Universal (POSIX)",
            rule,
            description
        );

        // Should apply to ALL shells
        assert!(
            should_apply_rule(rule, ShellType::Bash),
            "{} should apply to bash",
            rule
        );
        assert!(
            should_apply_rule(rule, ShellType::Sh),
            "{} should apply to sh",
            rule
        );
        assert!(
            should_apply_rule(rule, ShellType::Zsh),
            "{} should apply to zsh",
            rule
        );
    }
}