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

// SC2148: Tips depend on the shebang - add explicit shebang.
//
// Scripts should have an explicit shebang to indicate which interpreter to use.
// Without a shebang, the script's behavior depends on how it's invoked.
//
// Examples:
// Bad:
//   (no shebang at start of file)
//   echo "Hello World"
//
// Good:
//   #!/bin/sh
//   echo "Hello World"
//
//   #!/bin/bash
//   echo "Hello ${USER}"
//
//   #!/usr/bin/env python3
//   print("Hello")
//
// Impact: Portability - script may run with wrong interpreter

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

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

    // Only check first line for shebang
    if let Some(first_line) = source.lines().next() {
        // Skip if it's a blank line or comment that's not a shebang
        if first_line.trim().is_empty() {
            return result;
        }

        // Check if first line is a shebang
        if !first_line.starts_with("#!") {
            // File doesn't start with shebang
            let diagnostic = Diagnostic::new(
                "SC2148",
                Severity::Info,
                "Add a shebang to indicate which interpreter should be used".to_string(),
                Span::new(1, 1, 1, first_line.len() + 1),
            );

            result.add(diagnostic);
        }
    }

    result
}

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

    #[test]
    fn test_sc2148_missing_shebang() {
        let code = r#"echo "Hello World""#;
        let result = check(code);
        assert_eq!(result.diagnostics.len(), 1);
        assert!(result.diagnostics[0].message.contains("shebang"));
    }

    #[test]
    fn test_sc2148_with_shebang_bash_ok() {
        let code = r#"#!/bin/bash
echo "Hello World""#;
        let result = check(code);
        assert_eq!(result.diagnostics.len(), 0);
    }

    #[test]
    fn test_sc2148_with_shebang_sh_ok() {
        let code = r#"#!/bin/sh
echo "Hello World""#;
        let result = check(code);
        assert_eq!(result.diagnostics.len(), 0);
    }

    #[test]
    fn test_sc2148_with_env_shebang_ok() {
        let code = r#"#!/usr/bin/env bash
echo "Hello World""#;
        let result = check(code);
        assert_eq!(result.diagnostics.len(), 0);
    }

    #[test]
    fn test_sc2148_comment_not_shebang() {
        let code = r#"# This is a script
echo "Hello""#;
        let result = check(code);
        // First line is comment, not shebang
        assert_eq!(result.diagnostics.len(), 1);
    }

    #[test]
    fn test_sc2148_empty_file() {
        let code = "";
        let result = check(code);
        assert_eq!(result.diagnostics.len(), 0);
    }

    #[test]
    fn test_sc2148_blank_first_line() {
        let code = r#"
echo "Hello""#;
        let result = check(code);
        // Blank first line, no warning
        assert_eq!(result.diagnostics.len(), 0);
    }

    #[test]
    fn test_sc2148_python_shebang_ok() {
        let code = r#"#!/usr/bin/env python3
print("Hello")"#;
        let result = check(code);
        assert_eq!(result.diagnostics.len(), 0);
    }

    #[test]
    fn test_sc2148_variable_assignment_without_shebang() {
        let code = r#"FOO=bar
echo "$FOO""#;
        let result = check(code);
        assert_eq!(result.diagnostics.len(), 1);
    }

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