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

// SC2112: 'function' keyword is non-standard. Delete it
//
// Even if your shell supports 'function', it's better to use POSIX syntax.
// The 'function' keyword is bash/ksh-specific and not portable.
//
// Examples:
// Bad:
//   #!/bin/bash
//   function myfunc { echo "test"; }
//
// Good:
//   #!/bin/bash
//   myfunc() { echo "test"; }
//
// Impact: Portability - script won't work in POSIX sh

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

static FUNCTION_KEYWORD_ANY: std::sync::LazyLock<Regex> = std::sync::LazyLock::new(|| {
    // Match: function name (no parens) or function name()
    Regex::new(r"\bfunction\s+([a-zA-Z_][a-zA-Z0-9_]*)").unwrap()
});

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

    // Check if script has bash/ksh shebang
    let has_bash_shebang = source.lines().next().is_some_and(|line| {
        line.starts_with("#!/bin/bash")
            || line.starts_with("#!/usr/bin/bash")
            || line.starts_with("#!/bin/ksh")
            || line.starts_with("#!/usr/bin/ksh")
    });

    for (line_num, line) in source.lines().enumerate() {
        let line_num = line_num + 1;

        if line.trim_start().starts_with('#') {
            continue;
        }

        for mat in FUNCTION_KEYWORD_ANY.find_iter(line) {
            let start_col = mat.start() + 1;
            let end_col = mat.start() + 9; // length of "function "

            let message = if has_bash_shebang {
                "'function' keyword is non-standard. Delete it for better portability".to_string()
            } else {
                "'function' keyword is non-standard. Delete it".to_string()
            };

            let diagnostic = Diagnostic::new(
                "SC2112",
                Severity::Info,
                message,
                Span::new(line_num, start_col, line_num, end_col),
            );

            result.add(diagnostic);
        }
    }

    result
}

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

    #[test]
    fn test_sc2112_function_keyword() {
        let code = "function foo { echo \"bar\"; }";
        let result = check(code);
        assert_eq!(result.diagnostics.len(), 1);
    }

    #[test]
    fn test_sc2112_bash_shebang() {
        let code = r#"#!/bin/bash
function deploy { echo "test"; }
"#;
        let result = check(code);
        assert_eq!(result.diagnostics.len(), 1);
        assert!(result.diagnostics[0].message.contains("better portability"));
    }

    #[test]
    fn test_sc2112_sh_shebang() {
        let code = r#"#!/bin/sh
function deploy { echo "test"; }
"#;
        let result = check(code);
        assert_eq!(result.diagnostics.len(), 1);
        assert!(!result.diagnostics[0].message.contains("better portability"));
    }

    #[test]
    fn test_sc2112_posix_ok() {
        let code = "foo() { echo \"bar\"; }";
        let result = check(code);
        // POSIX style is OK
        assert_eq!(result.diagnostics.len(), 0);
    }

    #[test]
    fn test_sc2112_comment_ok() {
        let code = "# function foo { echo \"bar\"; }";
        let result = check(code);
        assert_eq!(result.diagnostics.len(), 0);
    }

    #[test]
    fn test_sc2112_multiple() {
        let code = r#"
function foo { echo "foo"; }
function bar { echo "bar"; }
"#;
        let result = check(code);
        assert_eq!(result.diagnostics.len(), 2);
    }

    #[test]
    fn test_sc2112_with_parens() {
        let code = "function test() { echo \"test\"; }";
        let result = check(code);
        assert_eq!(result.diagnostics.len(), 1);
    }

    #[test]
    fn test_sc2112_multiline() {
        let code = r#"
function process_data {
    local input=$1
    echo "$input"
}
"#;
        let result = check(code);
        assert_eq!(result.diagnostics.len(), 1);
    }

    #[test]
    fn test_sc2112_ksh_shebang() {
        let code = r#"#!/bin/ksh
function myfunc { echo "ksh"; }
"#;
        let result = check(code);
        assert_eq!(result.diagnostics.len(), 1);
    }

    #[test]
    fn test_sc2112_no_shebang() {
        let code = "function helper { echo \"help\"; }";
        let result = check(code);
        assert_eq!(result.diagnostics.len(), 1);
    }
}