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

// SC1094: Parsing of sourced file had errors
//
// When source/dot is used, the sourced file might contain syntax errors.
// Since the linter cannot actually parse sourced files, this rule provides
// an informational note when sourcing is detected.
//
// Examples:
// Flagged:
//   source config.sh
//   . /opt/scripts/setup.sh
//
// Impact: Informational - linter cannot verify sourced file syntax

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

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

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

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

        // Check `source <arg>`
        if let Some(rest) = trimmed.strip_prefix("source") {
            if rest.starts_with(char::is_whitespace) {
                let arg = rest.trim_start();
                if !arg.is_empty() {
                    let path = extract_path(arg);
                    result.add(Diagnostic::new(
                        "SC1094",
                        Severity::Info,
                        format!("SC1094: Parsing of sourced file {} was not performed", path),
                        Span::new(line_num, 1, line_num, line.len() + 1),
                    ));
                }
            }
        }

        // Check `. <arg>` (dot-source, not `./path`)
        if is_dot_source(trimmed) {
            let rest = &trimmed[1..];
            let arg = rest.trim_start();
            if !arg.is_empty() {
                let path = extract_path(arg);
                result.add(Diagnostic::new(
                    "SC1094",
                    Severity::Info,
                    format!("SC1094: Parsing of sourced file {} was not performed", path),
                    Span::new(line_num, 1, line_num, line.len() + 1),
                ));
            }
        }
    }

    result
}

/// Check if a trimmed line starts with dot-source (`. ` but not `./` or `..`)
fn is_dot_source(trimmed: &str) -> bool {
    if !trimmed.starts_with('.') {
        return false;
    }
    if trimmed.len() < 2 {
        return false;
    }
    let second = trimmed.as_bytes()[1];
    second == b' ' || second == b'\t'
}

/// Extract the path argument (first word), stripping surrounding quotes
fn extract_path(arg: &str) -> &str {
    let first_word = arg.split_whitespace().next().unwrap_or(arg);
    first_word.trim_matches('"').trim_matches('\'')
}

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

    #[test]
    fn test_sc1094_source_literal() {
        let code = "source config.sh";
        let result = check(code);
        assert_eq!(result.diagnostics.len(), 1);
        assert_eq!(result.diagnostics[0].code, "SC1094");
        assert_eq!(result.diagnostics[0].severity, Severity::Info);
        assert!(result.diagnostics[0].message.contains("config.sh"));
    }

    #[test]
    fn test_sc1094_dot_source() {
        let code = ". /opt/scripts/setup.sh";
        let result = check(code);
        assert_eq!(result.diagnostics.len(), 1);
        assert!(result.diagnostics[0]
            .message
            .contains("/opt/scripts/setup.sh"));
    }

    #[test]
    fn test_sc1094_source_with_variable() {
        let code = r#"source "$config""#;
        let result = check(code);
        // SC1094 still fires - it flags all source usage
        assert_eq!(result.diagnostics.len(), 1);
    }

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

    #[test]
    fn test_sc1094_dot_slash_no_match() {
        // ./script is execution, not sourcing
        let code = "./script.sh";
        let result = check(code);
        assert_eq!(result.diagnostics.len(), 0);
    }

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

    #[test]
    fn test_sc1094_source_alone_no_match() {
        // `source` with no argument
        let code = "source";
        let result = check(code);
        assert_eq!(result.diagnostics.len(), 0);
    }

    #[test]
    fn test_sc1094_multiple_sources() {
        let code = "source a.sh\nsource b.sh\n. c.sh";
        let result = check(code);
        assert_eq!(result.diagnostics.len(), 3);
    }

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