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

//! PORT001: Array syntax in POSIX sh
//!
//! **Rule**: Detect `arr=()` array syntax in `#!/bin/sh` scripts
//!
//! **Why this matters**:
//! POSIX sh does not support array syntax (`arr=()`). This is a bash/zsh
//! extension that will fail on dash, ash, or other strict POSIX shells.
//!
//! **Auto-fix**: None (manual refactoring required)
//!
//! ## Examples
//!
//! Bad (bash-only syntax in sh script):
//! ```bash
//! #!/bin/sh
//! files=()
//! files=(foo bar baz)
//! ```
//!
//! Good (POSIX-compatible):
//! ```bash
//! #!/bin/sh
//! files="foo bar baz"
//! ```

use crate::linter::{Diagnostic, LintResult, Severity, Span};
use regex::Regex;

/// Check if the script has a POSIX sh shebang
fn is_posix_sh(source: &str) -> bool {
    let first_line = source.lines().next().unwrap_or("");
    first_line.starts_with("#!/bin/sh")
        || first_line.starts_with("#! /bin/sh")
        || first_line.starts_with("#!/usr/bin/env sh")
}

/// Check for array syntax in POSIX sh scripts
static PATTERN: std::sync::LazyLock<Regex> =
    std::sync::LazyLock::new(|| Regex::new(r"\b\w+=\(").unwrap());

pub fn check(source: &str) -> LintResult {
    let mut result = LintResult::new();

    if !is_posix_sh(source) {
        return result;
    }

    // Match: var=() or var=(items)
    let pattern = &*PATTERN;

    for (line_num, line) in source.lines().enumerate() {
        let trimmed = line.trim_start();

        // Skip comments
        if trimmed.starts_with('#') {
            continue;
        }

        if let Some(m) = pattern.find(line) {
            let start_col = m.start() + 1;
            let end_col = m.end() + 1;

            let diagnostic = Diagnostic::new(
                "PORT001",
                Severity::Warning,
                "Array syntax `=()` is not supported in POSIX sh. Use space-separated strings or positional parameters instead.",
                Span::new(line_num + 1, start_col, line_num + 1, end_col),
            );

            result.add(diagnostic);
        }
    }

    result
}

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

    #[test]
    fn test_port001_detects_array_in_sh() {
        let script = "#!/bin/sh\nfiles=(foo bar baz)";
        let result = check(script);
        assert_eq!(result.diagnostics.len(), 1);
        assert_eq!(result.diagnostics[0].code, "PORT001");
        assert_eq!(result.diagnostics[0].severity, Severity::Warning);
    }

    #[test]
    fn test_port001_detects_empty_array() {
        let script = "#!/bin/sh\narr=()";
        let result = check(script);
        assert_eq!(result.diagnostics.len(), 1);
    }

    #[test]
    fn test_port001_no_flag_in_bash() {
        let script = "#!/bin/bash\nfiles=(foo bar baz)";
        let result = check(script);
        assert_eq!(result.diagnostics.len(), 0);
    }

    #[test]
    fn test_port001_no_flag_without_shebang() {
        let script = "files=(foo bar baz)";
        let result = check(script);
        assert_eq!(result.diagnostics.len(), 0);
    }

    #[test]
    fn test_port001_no_false_positive_comment() {
        let script = "#!/bin/sh\n# arr=(foo)";
        let result = check(script);
        assert_eq!(result.diagnostics.len(), 0);
    }

    #[test]
    fn test_port001_no_fix_provided() {
        let script = "#!/bin/sh\narr=(1 2 3)";
        let result = check(script);
        assert!(result.diagnostics[0].fix.is_none());
    }

    #[test]
    fn test_port001_env_sh_shebang() {
        let script = "#!/usr/bin/env sh\narr=(1 2 3)";
        let result = check(script);
        assert_eq!(result.diagnostics.len(), 1);
    }
}