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

#![allow(missing_docs)]
//! Dataframe Parsing Tests - HYBRID-C-4
//! Empirical verification that dataframe literals already parse correctly

use ruchy::Parser;

#[test]
fn test_simple_dataframe_literal() {
    let code = r#"df!["name" => ["Alice"], "age" => [30]]"#;
    let mut parser = Parser::new(code);
    let result = parser.parse();
    assert!(
        result.is_ok(),
        "Simple dataframe should parse: {:?}",
        result.err()
    );
}

#[test]
fn test_dataframe_multiple_rows() {
    let code = r#"df!["name" => ["Alice", "Bob"], "age" => [30, 25]]"#;
    let mut parser = Parser::new(code);
    let result = parser.parse();
    assert!(
        result.is_ok(),
        "Multi-row dataframe should parse: {:?}",
        result.err()
    );
}

#[test]
fn test_dataframe_empty() {
    let code = r"df![]";
    let mut parser = Parser::new(code);
    let result = parser.parse();
    assert!(
        result.is_ok(),
        "Empty dataframe should parse: {:?}",
        result.err()
    );
}

#[test]
fn test_dataframe_single_column() {
    let code = r#"df!["values" => [1, 2, 3, 4, 5]]"#;
    let mut parser = Parser::new(code);
    let result = parser.parse();
    assert!(
        result.is_ok(),
        "Single column dataframe should parse: {:?}",
        result.err()
    );
}

#[test]
fn test_dataframe_mixed_types() {
    let code = r#"df!["name" => ["Alice"], "age" => [30], "score" => [95.5]]"#;
    let mut parser = Parser::new(code);
    let result = parser.parse();
    assert!(
        result.is_ok(),
        "Mixed type dataframe should parse: {:?}",
        result.err()
    );
}

#[test]
fn test_dataframe_in_variable_assignment() {
    let code = r#"let data = df!["x" => [1, 2], "y" => [3, 4]]"#;
    let mut parser = Parser::new(code);
    let result = parser.parse();
    assert!(
        result.is_ok(),
        "Dataframe in assignment should parse: {:?}",
        result.err()
    );
}

#[test]
fn test_dataframe_in_function_call() {
    let code = r#"process(df!["data" => [1, 2, 3]])"#;
    let mut parser = Parser::new(code);
    let result = parser.parse();
    assert!(
        result.is_ok(),
        "Dataframe in function call should parse: {:?}",
        result.err()
    );
}

#[test]
fn test_dataframe_with_string_values() {
    let code = r#"df!["names" => ["Alice", "Bob", "Charlie"]]"#;
    let mut parser = Parser::new(code);
    let result = parser.parse();
    assert!(
        result.is_ok(),
        "Dataframe with strings should parse: {:?}",
        result.err()
    );
}