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

#![allow(clippy::unwrap_used)] // Tests can use unwrap() for simplicity
#![allow(clippy::expect_used)]
// Integration test for Issue #5: zsh shell type detection
// Verifies that bashrs correctly detects zsh files

use bashrs::linter::{detect_shell_type, ShellType};
use std::path::PathBuf;

#[test]
fn test_issue_005_zshrc_detected_as_zsh() {
    // Issue #5: .zshrc should be detected as zsh, not bash
    let content = r#"#!/usr/bin/env zsh
# Test .zshrc file

# zsh array splitting (valid zsh syntax that bash might flag)
filtered_args=("${(@f)"$(echo -e "line1\nline2")"}")

echo "Array: ${filtered_args[*]}"
"#;

    let path = PathBuf::from(".zshrc");
    let shell_type = detect_shell_type(&path, content);

    assert_eq!(
        shell_type,
        ShellType::Zsh,
        "Issue #5: .zshrc should be detected as zsh"
    );
}

#[test]
fn test_issue_005_bash_shebang_overrides_zsh_extension() {
    // Issue #5: Shebang should have priority over extension
    let content = r#"#!/bin/bash
# This is actually a bash script with .zsh extension

echo "Hello from bash"
"#;

    let path = PathBuf::from("script.zsh");
    let shell_type = detect_shell_type(&path, content);

    assert_eq!(
        shell_type,
        ShellType::Bash,
        "Issue #5: bash shebang should override .zsh extension"
    );
}

#[test]
fn test_issue_005_shellcheck_directive_highest_priority() {
    // Issue #5: ShellCheck directive should override everything
    let content = r#"#!/bin/bash
# shellcheck shell=zsh
# This tells linters to treat it as zsh

echo "Hello"
"#;

    let path = PathBuf::from("script.sh");
    let shell_type = detect_shell_type(&path, content);

    assert_eq!(
        shell_type,
        ShellType::Zsh,
        "Issue #5: shellcheck directive should have highest priority"
    );
}

#[test]
fn test_issue_005_zsh_files_detected() {
    // Test all common zsh config files
    let test_cases = vec![
        (".zshrc", "echo hello"),
        (".zshenv", "export PATH=/bin"),
        (".zprofile", "echo profile"),
        ("script.zsh", "echo script"),
    ];

    for (filename, content) in test_cases {
        let path = PathBuf::from(filename);
        let shell_type = detect_shell_type(&path, content);

        assert_eq!(
            shell_type,
            ShellType::Zsh,
            "Issue #5: {} should be detected as zsh",
            filename
        );
    }
}

#[test]
fn test_issue_005_bash_files_still_work() {
    // Ensure bash detection still works (no regression)
    let test_cases = vec![
        (".bashrc", "echo hello"),
        (".bash_profile", "export PATH=/bin"),
        ("script.sh", "#!/bin/bash\necho script"),
    ];

    for (filename, content) in test_cases {
        let path = PathBuf::from(filename);
        let shell_type = detect_shell_type(&path, content);

        assert_eq!(
            shell_type,
            ShellType::Bash,
            "Issue #5: {} should be detected as bash (no regression)",
            filename
        );
    }
}

#[test]
fn test_issue_005_default_to_bash() {
    // Files with no indicators default to bash
    let content = "echo hello";
    let path = PathBuf::from("script");

    let shell_type = detect_shell_type(&path, content);

    assert_eq!(
        shell_type,
        ShellType::Bash,
        "Issue #5: unknown files should default to bash"
    );
}

#[test]
fn test_issue_005_real_zsh_syntax() {
    // Real zsh syntax from the GitHub issue
    let zsh_content = r#"#!/usr/bin/env zsh

filter_region_args() {
    for arg in "$@"; do
        if [[ "$arg" != --region=* ]]; then
            echo "$arg"
        fi
    done
}

# This is valid zsh syntax that bash might flag with SC2296
filtered_args=("${(@f)"$(filter_region_args "${@}")"}")

echo "Filtered args: ${filtered_args[*]}"
"#;

    let path = PathBuf::from(".zshrc");
    let shell_type = detect_shell_type(&path, zsh_content);

    assert_eq!(
        shell_type,
        ShellType::Zsh,
        "Issue #5: Real zsh syntax should be detected as zsh"
    );
}