ruchy 4.2.0

A systems scripting language that transpiles to idiomatic Rust with extreme quality engineering
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
136
137
138
139
140
141
142
143
144

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

fn run_test_file(code: &str) -> String {
    let mut temp_file = NamedTempFile::new().expect("Failed to create temp file");
    fs::write(temp_file.path(), code).expect("Failed to write test code");

    let output = Command::new("cargo")
        .args(&[
            "run",
            "--quiet",
            "--bin",
            "ruchy",
            "--",
            "run",
            temp_file.path().to_str().unwrap(),
        ])
        .output()
        .expect("Failed to run ruchy");

    String::from_utf8_lossy(&output.stdout).to_string()
}

#[test]
fn test_simple_fstring_interpolation() {
    let code = r#"
let name = "Alice"
let result = f"Hello {name}"
println(result)
"#;
    let output = run_test_file(code);
    assert!(
        output.contains("Hello Alice"),
        "Expected 'Hello Alice' but got: {}",
        output
    );
}

#[test]
fn test_fstring_with_expression() {
    let code = r#"
let x = 5
let y = 3
let result = f"Sum: {x + y}"
println(result)
"#;
    let output = run_test_file(code);
    assert!(
        output.contains("Sum: 8"),
        "Expected 'Sum: 8' but got: {}",
        output
    );
}

#[test]
fn test_fstring_multiple_interpolations() {
    let code = r#"
let score = 85
let grade = "B"
let result = f"Score {score} = Grade {grade}"
println(result)
"#;
    let output = run_test_file(code);
    assert!(
        output.contains("Score 85 = Grade B"),
        "Expected 'Score 85 = Grade B' but got: {}",
        output
    );
}

#[test]
fn test_fstring_with_method_call() {
    let code = r#"
let num = 42
let result = f"Number: {num.to_string()}"
println(result)
"#;
    let output = run_test_file(code);
    assert!(
        output.contains("Number: 42"),
        "Expected 'Number: 42' but got: {}",
        output
    );
}

#[test]
fn test_fstring_escaped_braces() {
    let code = r#"
let value = 10
let result = f"Literal {{braces}} and value: {value}"
println(result)
"#;
    let output = run_test_file(code);
    assert!(
        output.contains("Literal {braces} and value: 10"),
        "Expected escaped braces but got: {}",
        output
    );
}

#[test]
fn test_nested_fstring_expressions() {
    let code = r#"
let x = 5
let y = 3
let result = f"5! = {x * (x-1) * (x-2) * (x-3) * (x-4)}"
println(result)
"#;
    let output = run_test_file(code);
    assert!(
        output.contains("5! = 120"),
        "Expected '5! = 120' but got: {}",
        output
    );
}

#[test]
fn test_fstring_in_println() {
    let code = r#"
let fact_5 = 120
println(f"5! = {fact_5}")
"#;
    let output = run_test_file(code);
    assert!(
        output.contains("5! = 120"),
        "Expected '5! = 120' but got: {}",
        output
    );
}

#[test]
fn test_fstring_boolean_result() {
    let code = r#"
let fact_5 = 120
println(f"5! = 120: {fact_5 == 120}")
"#;
    let output = run_test_file(code);
    assert!(
        output.contains("5! = 120: true"),
        "Expected '5! = 120: true' but got: {}",
        output
    );
}