nodety 0.2.0

Easy to use library for node editor types, generics, inference and validation
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
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162

use crate::common::{expr_u, sig_u};
use nodety::{
    NodeSignature, TypeHints,
    demo_type::DemoType,
    scope::LocalParamID,
    type_expr::{TypeExpr, Unscoped},
};
use std::str::FromStr;

mod common;

#[test]
fn test_format_basic_types() {
    assert_eq!("Integer", format!("{}", expr_u("Integer")));
    assert_eq!("String", format!("{}", expr_u("String")));
    assert_eq!("Boolean", format!("{}", expr_u("Boolean")));
    assert_eq!("Float", format!("{}", expr_u("Float")));
    assert_eq!("Any", format!("{}", expr_u("Any")));
    assert_eq!("Never", format!("{}", expr_u("Never")));
    assert_eq!("Unit", format!("{}", expr_u("Unit")));
    assert_eq!("Comparable", format!("{}", expr_u("Comparable")));
    assert_eq!("Countable", format!("{}", expr_u("Countable")));
    assert_eq!("Sortable", format!("{}", expr_u("Sortable")));
    assert_eq!("AnySI", format!("{}", expr_u("AnySI")));
}

#[test]
fn test_format_string_literal() {
    assert_eq!("\"hello\"", format!("{}", expr_u("'hello'")));
}

#[test]
fn test_format_union() {
    assert_eq!("Integer | String", format!("{}", expr_u("Integer | String")));
}

#[test]
fn test_format_intersection() {
    let e: TypeExpr<DemoType, Unscoped> =
        TypeExpr::Intersection(Box::new(expr_u("{a: Integer}")), Box::new(expr_u("{b: String}")));
    let formatted = format!("{}", e);
    assert!(formatted.contains(" & "), "Expected '&' in: {formatted}");
}

#[test]
fn test_format_keyof() {
    assert_eq!("keyof {a: Integer}", format!("{}", expr_u("keyof {a: Integer}")));
}

#[test]
fn test_format_index() {
    assert_eq!("{a: Integer}[\"a\"]", format!("{}", expr_u("{a: Integer}['a']")));
}

#[test]
fn test_format_conditional() {
    let formatted = format!("{}", expr_u("Integer extends Comparable ? Integer : Never"));
    assert!(formatted.contains("extends"), "Expected 'extends' in: {formatted}");
    assert!(formatted.contains("?"), "Expected '?' in: {formatted}");
    assert!(formatted.contains(":"), "Expected ':' in: {formatted}");
}

#[test]
fn test_format_operation() {
    assert_eq!("SI(1, 0, 1) * SI(1, 1)", format!("{}", expr_u("SI(1,0,1) * SI(1,1)")));
    assert_eq!("SI(1, 0, 1) / SI(1, 1)", format!("{}", expr_u("SI(1,0,1) / SI(1,1)")));
}

#[test]
fn test_format_array_with_param() {
    assert_eq!("Array<Integer>", format!("{}", expr_u("Array<Integer>")));
}

#[test]
fn test_format_record() {
    assert_eq!("{a: Integer}", format!("{}", expr_u("{a: Integer}")));
    assert_eq!("{a: Integer, b: String}", format!("{}", expr_u("{a: Integer, b: String}")));
}

#[test]
fn test_format_empty_record() {
    assert_eq!("{}", format!("{}", expr_u("{}")));
}

#[test]
fn test_format_node_signature() {
    let sig = NodeSignature::<DemoType>::from_str("<T>(T) -> (T)").unwrap();
    assert_eq!("<T>(T) -> (T)", format!("{}", sig));
}

#[test]
fn test_format_node_signature_no_params() {
    let sig = NodeSignature::<DemoType>::from_str("(Integer) -> (String)").unwrap();
    assert_eq!("(Integer) -> (String)", format!("{}", sig));
}

#[test]
fn test_format_node_signature_with_bound() {
    let sig = NodeSignature::<DemoType>::from_str("<T extends Comparable>(T) -> (T)").unwrap();
    assert_eq!("<T extends Comparable>(T) -> (T)", format!("{}", sig));
}

#[test]
fn test_format_node_signature_with_default() {
    let sig = NodeSignature::<DemoType>::from_str("<T = Integer>(T) -> (T)").unwrap();
    assert_eq!("<T = Integer>(T) -> (T)", format!("{}", sig));
}

#[test]
fn test_format_port_types_with_varg() {
    assert_eq!("(Integer, ...String) -> ()", format!("{}", sig_u("(Integer, ...String) -> ()")));
}

#[test]
fn test_format_port_types_empty() {
    assert_eq!("() -> ()", format!("{}", sig_u("() -> ()")));
}

#[test]
fn test_format_type_parameter_with_infer_false() {
    let e: TypeExpr<DemoType, Unscoped> = TypeExpr::TypeParameter(LocalParamID::from('T'), false);
    assert_eq!("!T", format!("{}", e));
}

#[test]
fn test_format_type_parameter_numeric_id() {
    let e: TypeExpr<DemoType, Unscoped> = TypeExpr::TypeParameter(LocalParamID(0), true);
    assert_eq!("#0", format!("{}", e));
}

#[test]
fn test_format_si_with_all_components() {
    assert_eq!("SI(1, 1, 2, 3)", format!("{}", expr_u("SI(1,1,2,3)")));
}

#[test]
fn test_format_roundtrip_complex_signature() {
    let input = "<T, U>(Array<T>, (T) -> (U)) -> (Array<U>)";
    let sig = NodeSignature::<DemoType>::from_str(input).unwrap();
    assert_eq!(input, format!("{}", sig));
}

#[test]
fn test_format_type_hints_roundtrip() {
    let input = "T = Integer, U = String";
    let hints: TypeHints<DemoType, Unscoped> = input.parse().unwrap();
    assert_eq!(input, format!("{}", hints));
}

#[test]
fn test_format_nested_node_signature_expr() {
    assert_eq!("(Integer) -> (String)", format!("{}", expr_u("(Integer) -> (String)")));
}

#[test]
fn test_format_string_utility() {
    use nodety::notation::format::format_string;
    assert_eq!("hello", format_string("hello"));
    assert_eq!("\"\"", format_string(""));
    assert_eq!("\"hello world\"", format_string("hello world"));
    assert_eq!("\"hello\\\"world\"", format_string("hello\"world"));
}