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
125
126
127
128
129
130
131
132
133
134
135

#![cfg(any(
    not(any(
        feature = "parser_tests",
        feature = "analyzer_tests",
        feature = "codegen_tests",
        feature = "interpreter_tests",
        feature = "conformance_tests",
        feature = "integration_tests",
    )),
    feature = "codegen_tests",
))]

// TDD Test: Property test should automatically import windjammer_runtime::property functions

#[path = "common/test_utils.rs"]
mod test_utils;

use std::fs;
use std::process::Command;
use tempfile::TempDir;

#[test]
#[cfg_attr(tarpaulin, ignore)]
fn test_property_test_imports_property_functions() {
    let source = r#"
@test
@property_test(cases: 10)
fn test_addition_commutative(a: i32) {
    assert_eq(a + a, 2 * a)
}
"#;

    let temp_dir = TempDir::new().expect("Failed to create temp dir");
    let wj_path = temp_dir.path().join("test.wj");
    let out_dir = temp_dir.path().join("out");

    fs::write(&wj_path, source).expect("Failed to write test file");
    fs::create_dir_all(&out_dir).expect("Failed to create output dir");

    let output = Command::new(test_utils::wj_binary())
        .args([
            "build",
            wj_path.to_str().unwrap(),
            "-o",
            out_dir.to_str().unwrap(),
            "--no-cargo",
        ])
        .output()
        .expect("Failed to run compiler");

    if !output.status.success() {
        let stderr = String::from_utf8_lossy(&output.stderr).to_string();
        panic!("Compilation failed:\n{}", stderr);
    }

    // Read generated Rust
    let generated_rs = out_dir.join("test.rs");
    let rust_code = fs::read_to_string(&generated_rs).expect("Failed to read generated Rust");

    // Should import property_test_with_gen1
    assert!(
        rust_code.contains("use windjammer_runtime::property::property_test_with_gen1;")
            || rust_code.contains("use windjammer_runtime::property::*;"),
        "Generated code should import property_test_with_gen1 or property::*\nGenerated:\n{}",
        rust_code
    );

    // Should generate property_test_with_gen1 call
    assert!(
        rust_code.contains("property_test_with_gen1"),
        "Generated code should call property_test_with_gen1\nGenerated:\n{}",
        rust_code
    );

    // Should use rand::random
    assert!(
        rust_code.contains("rand::random"),
        "Generated code should use rand::random for generation\nGenerated:\n{}",
        rust_code
    );
}

#[test]
#[cfg_attr(tarpaulin, ignore)]
fn test_property_test_with_multiple_params_imports_correct_function() {
    let source = r#"
@test
@property_test(cases: 20)
fn test_addition_commutative(a: i32, b: i32) {
    assert_eq(a + b, b + a)
}
"#;

    let temp_dir = TempDir::new().expect("Failed to create temp dir");
    let wj_path = temp_dir.path().join("test.wj");
    let out_dir = temp_dir.path().join("out");

    fs::write(&wj_path, source).expect("Failed to write test file");
    fs::create_dir_all(&out_dir).expect("Failed to create output dir");

    let output = Command::new(test_utils::wj_binary())
        .args([
            "build",
            wj_path.to_str().unwrap(),
            "-o",
            out_dir.to_str().unwrap(),
            "--no-cargo",
        ])
        .output()
        .expect("Failed to run compiler");

    if !output.status.success() {
        let stderr = String::from_utf8_lossy(&output.stderr).to_string();
        panic!("Compilation failed:\n{}", stderr);
    }

    // Read generated Rust
    let generated_rs = out_dir.join("test.rs");
    let rust_code = fs::read_to_string(&generated_rs).expect("Failed to read generated Rust");

    // Should import property_test_with_gen2
    assert!(
        rust_code.contains("use windjammer_runtime::property::property_test_with_gen2;")
            || rust_code.contains("use windjammer_runtime::property::*;"),
        "Generated code should import property_test_with_gen2 or property::*\nGenerated:\n{}",
        rust_code
    );

    // Should generate property_test_with_gen2 call
    assert!(
        rust_code.contains("property_test_with_gen2"),
        "Generated code should call property_test_with_gen2\nGenerated:\n{}",
        rust_code
    );
}