ruchy 4.1.1

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

#![allow(missing_docs)]
// DEFECT-PARSER-008: Tuple Struct Destructuring in Let Patterns
// Bug: Parser failed with "Expected RightParen, found Comma" on tuple patterns
// Fix: Updated parse_variant_pattern_with_name() to handle multiple comma-separated patterns

use assert_cmd::Command;
use predicates::prelude::*;

fn ruchy_cmd() -> Command {
    assert_cmd::cargo::cargo_bin_cmd!("ruchy")
}

// Test 1: Basic tuple struct destructuring with 3 elements
#[test]
fn test_parser_008_tuple_three_elements() {
    let code = r"
let Color(r, g, b) = red
";
    std::fs::write("/tmp/test_parser_008_three.ruchy", code).unwrap();

    ruchy_cmd()
        .arg("check")
        .arg("/tmp/test_parser_008_three.ruchy")
        .assert()
        .success()
        .stdout(predicate::str::contains("✓ Syntax is valid"));
}

// Test 2: Tuple struct with 2 elements
#[test]
fn test_parser_008_tuple_two_elements() {
    let code = r"
let Point(x, y) = origin
";
    std::fs::write("/tmp/test_parser_008_two.ruchy", code).unwrap();

    ruchy_cmd()
        .arg("check")
        .arg("/tmp/test_parser_008_two.ruchy")
        .assert()
        .success();
}

// Test 3: Tuple struct with 4 elements
#[test]
fn test_parser_008_tuple_four_elements() {
    let code = r"
let Rgba(r, g, b, a) = color
";
    std::fs::write("/tmp/test_parser_008_four.ruchy", code).unwrap();

    ruchy_cmd()
        .arg("check")
        .arg("/tmp/test_parser_008_four.ruchy")
        .assert()
        .success();
}

// Test 4: Single element tuple (regression test for Some/Ok/Err)
#[test]
fn test_parser_008_single_element_still_works() {
    let code = r"
let Some(value) = maybe
let Ok(result) = res
let Err(error) = failure
";
    std::fs::write("/tmp/test_parser_008_single.ruchy", code).unwrap();

    ruchy_cmd()
        .arg("check")
        .arg("/tmp/test_parser_008_single.ruchy")
        .assert()
        .success();
}

// Test 5: Book example (appendix-b-syntax-reference_example_18)
#[test]
fn test_parser_008_book_example() {
    let code = r"
// Creating instances
let origin = Point { x: 0.0, y: 0.0 }
let red = Color(255, 0, 0)

// Field access
let x_coord = origin.x

// Struct update syntax
let point2 = Point { x: 1.0, ..origin }

// Destructuring
let Point { x, y } = origin
let Color(r, g, b) = red
";
    std::fs::write("/tmp/test_parser_008_book.ruchy", code).unwrap();

    ruchy_cmd()
        .arg("check")
        .arg("/tmp/test_parser_008_book.ruchy")
        .assert()
        .success();
}

// Test 6: Empty tuple (edge case)
#[test]
fn test_parser_008_empty_tuple() {
    let code = r"
let Unit() = unit_value
";
    std::fs::write("/tmp/test_parser_008_empty.ruchy", code).unwrap();

    ruchy_cmd()
        .arg("check")
        .arg("/tmp/test_parser_008_empty.ruchy")
        .assert()
        .success();
}

// Test 7: Trailing comma support
#[test]
fn test_parser_008_trailing_comma() {
    let code = r"
let Color(r, g, b,) = red
";
    std::fs::write("/tmp/test_parser_008_trailing.ruchy", code).unwrap();

    ruchy_cmd()
        .arg("check")
        .arg("/tmp/test_parser_008_trailing.ruchy")
        .assert()
        .success();
}