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
158
159
160
161
162
163
164
165

use super::*;

#[test]
fn test_engine_creation() {
    let engine = NormalizationEngine::new();
    assert_eq!(engine.ws_stack.len(), 1);
    assert!(matches!(engine.ws_stack[0], WhitespaceContext::Command));
}

#[test]
fn test_engine_with_config() {
    let config = EngineConfig {
        enable_fast_path: false,
        max_nesting_depth: 512,
        preserve_comments: false,
        generate_proofs: true,
    };

    let engine = NormalizationEngine::with_config(config.clone());
    assert!(!engine.config.enable_fast_path);
    assert_eq!(engine.config.max_nesting_depth, 512);
}

#[test]
fn test_is_canonical_simple() {
    let engine = NormalizationEngine::new();

    assert!(engine.is_canonical(b"echo hello"));
    assert!(!engine.is_canonical(b"echo  hello")); // Multiple spaces
    assert!(!engine.is_canonical(b" echo hello")); // Leading space
    assert!(!engine.is_canonical(b"echo hello ")); // Trailing space
    assert!(!engine.is_canonical(b"echo\thello")); // Tab
}

#[test]
fn test_is_canonical_quoting() {
    let engine = NormalizationEngine::new();

    assert!(engine.is_canonical(b"echo \"$var\""));
    assert!(!engine.is_canonical(b"echo $var")); // Unquoted variable
}

#[test]
fn test_normalize_identity() {
    let mut engine = NormalizationEngine::new();
    let input = b"echo hello";
    let config = FormatConfig::default();

    let result = engine.normalize(input, ShellDialect::Posix, config);
    assert!(result.is_ok());

    let formatted = result.unwrap();
    assert_eq!(formatted.text.as_ref(), "echo hello");
}

#[test]
fn test_normalize_whitespace() {
    let mut engine = NormalizationEngine::new();
    let input = b"echo  hello   world";
    let config = FormatConfig::default();

    let result = engine.normalize(input, ShellDialect::Posix, config);
    assert!(result.is_ok());

    let formatted = result.unwrap();
    assert_eq!(formatted.text.as_ref(), "echo hello world");
    assert!(!formatted.transforms.entries.is_empty());
}

#[test]
fn test_normalize_variable_quoting() {
    let mut engine = NormalizationEngine::new();
    let input = b"echo $var";
    let config = FormatConfig::default();

    let result = engine.normalize(input, ShellDialect::Posix, config);
    assert!(result.is_ok());

    let formatted = result.unwrap();
    assert_eq!(formatted.text.as_ref(), "echo \"$var\"");

    // Should have a quote expansion transform
    let has_quote_transform = formatted
        .transforms
        .entries
        .iter()
        .any(|entry| matches!(entry.transform, Transform::QuoteExpansion { .. }));
    assert!(has_quote_transform);
}

#[test]
fn test_normalize_quoted_strings() {
    let mut engine = NormalizationEngine::new();
    let input = b"echo 'hello  world'";
    let config = FormatConfig::default();

    let result = engine.normalize(input, ShellDialect::Posix, config);
    assert!(result.is_ok());

    let formatted = result.unwrap();
    // Whitespace inside quotes should be preserved
    assert_eq!(formatted.text.as_ref(), "echo 'hello  world'");
}

#[test]
fn test_normalize_comments() {
    let mut engine = NormalizationEngine::new();
    let input = b"echo hello # this is a comment";
    let config = FormatConfig::default();

    let result = engine.normalize(input, ShellDialect::Posix, config);
    assert!(result.is_ok());

    let formatted = result.unwrap();
    assert_eq!(formatted.text.as_ref(), "echo hello # this is a comment");
    assert_eq!(formatted.metadata.comments.len(), 1);
    assert_eq!(
        formatted.metadata.comments[0].content,
        "# this is a comment"
    );
}

#[test]
fn test_normalize_multiline() {
    let mut engine = NormalizationEngine::new();
    let input = b"echo  hello\necho   world";
    let config = FormatConfig::default();

    let result = engine.normalize(input, ShellDialect::Posix, config);
    assert!(result.is_ok());

    let formatted = result.unwrap();
    assert_eq!(formatted.text.as_ref(), "echo hello\necho world");
}

#[test]
fn test_has_proper_quoting() {
    let engine = NormalizationEngine::new();

    assert!(engine.has_proper_quoting("echo \"$var\""));
    assert!(engine.has_proper_quoting("echo '$var'"));
    assert!(!engine.has_proper_quoting("echo $var"));
    assert!(engine.has_proper_quoting("echo hello")); // No variables
}

#[test]
fn test_config_effects() {
    let config = EngineConfig {
        enable_fast_path: false,
        preserve_comments: false,
        ..Default::default()
    };

    let mut engine = NormalizationEngine::with_config(config);

    // Fast path should be disabled
    assert!(!engine.is_canonical(b"echo hello"));

    // Comments should not be preserved (this would need full implementation)
    let input = b"echo hello # comment";
    let format_config = FormatConfig::default();

    let result = engine.normalize(input, ShellDialect::Posix, format_config);
    assert!(result.is_ok());
}