windjammer 0.48.0

A simple language inspired by Go, Ruby, and Elixir that transpiles to Rust - 80% of Rust's power with 20% of the complexity
Documentation 
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

/// Test that pub structs are generated with pub visibility in Rust
use std::process::Command;
use std::fs;
use tempfile::TempDir;

#[test]
fn test_pub_struct_generates_pub_in_rust() {
    let temp_dir = TempDir::new().unwrap();
    let src_file = temp_dir.path().join("test.wj");
    
    // Write Windjammer source with pub struct
    fs::write(&src_file, r#"
pub struct GpuCameraState {
    pub view_matrix: Mat4
    pub proj_matrix: Mat4
    pub position: Vec3
}

pub struct LightingConfig {
    pub sun_direction: Vec3
    pub sun_intensity: f32
    pub ambient_color: Vec3
}

struct PrivateHelper {
    pub data: i32
}
"#).unwrap();

    // Compile to Rust
    let output = Command::new(env!("CARGO_BIN_EXE_wj"))
        .arg("build")
        .arg(&src_file)
        .arg("--no-cargo")
        .arg("-o")
        .arg(temp_dir.path())
        .output()
        .unwrap();
    
    assert!(output.status.success(), "Compilation failed: {}", String::from_utf8_lossy(&output.stderr));
    
    // Read generated Rust
    let rust_file = temp_dir.path().join("test.rs");
    let rust_code = fs::read_to_string(&rust_file).unwrap();
    
    // Verify pub structs are marked pub
    assert!(rust_code.contains("pub struct GpuCameraState"), 
        "GpuCameraState should be pub in generated Rust");
    assert!(rust_code.contains("pub struct LightingConfig"), 
        "LightingConfig should be pub in generated Rust");
    
    // Verify private structs are not marked pub
    assert!(rust_code.contains("struct PrivateHelper") && !rust_code.contains("pub struct PrivateHelper"),
        "PrivateHelper should NOT be pub in generated Rust");
}

#[test]
fn test_pub_enum_generates_pub_in_rust() {
    let temp_dir = TempDir::new().unwrap();
    let src_file = temp_dir.path().join("test_enum.wj");
    
    fs::write(&src_file, r#"
pub enum ShaderFile {
    VoxelRaymarch
    HiZDownsample
    HiZCull
}

enum PrivateEnum {
    Variant1
    Variant2
}
"#).unwrap();

    let output = Command::new(env!("CARGO_BIN_EXE_wj"))
        .arg("build")
        .arg(&src_file)
        .arg("--no-cargo")
        .arg("-o")
        .arg(temp_dir.path())
        .output()
        .unwrap();
    
    assert!(output.status.success());
    
    let rust_code = fs::read_to_string(temp_dir.path().join("test_enum.rs")).unwrap();
    
    assert!(rust_code.contains("pub enum ShaderFile"), "ShaderFile should be pub");
    assert!(rust_code.contains("enum PrivateEnum") && !rust_code.contains("pub enum PrivateEnum"),
        "PrivateEnum should NOT be pub");
}

#[test]
fn test_pub_fn_generates_pub_in_rust() {
    let temp_dir = TempDir::new().unwrap();
    let src_file = temp_dir.path().join("test_fn.wj");
    
    fs::write(&src_file, r#"
pub fn public_function(x: i32) -> i32 {
    x + 1
}

fn private_function(x: i32) -> i32 {
    x * 2
}
"#).unwrap();

    let output = Command::new(env!("CARGO_BIN_EXE_wj"))
        .arg("build")
        .arg(&src_file)
        .arg("--no-cargo")
        .arg("-o")
        .arg(temp_dir.path())
        .output()
        .unwrap();
    
    assert!(output.status.success());
    
    let rust_code = fs::read_to_string(temp_dir.path().join("test_fn.rs")).unwrap();
    
    assert!(rust_code.contains("pub fn public_function"), "public_function should be pub");
    assert!(rust_code.contains("fn private_function") && !rust_code.contains("pub fn private_function"),
        "private_function should NOT be pub");
}