knus-derive 3.3.0

A derive implementation for knus KDL parser
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

use knus::ast::{BuiltinType, TypeName};
use knus::span::Span;
use knus::traits::Decode;

#[derive(knus_derive::Decode, Debug, PartialEq)]
struct Child;

#[derive(knus_derive::Decode, Debug, PartialEq)]
#[knus(span_type=Span)]
struct NodeSpan {
    #[knus(span)]
    span: Span,
    #[knus(argument)]
    name: String,
    #[knus(children)]
    children: Vec<Child>,
}

#[derive(knus_derive::Decode, Debug, PartialEq)]
struct NodeType {
    #[knus(type_name)]
    type_name: String,
}

#[derive(knus_derive::Decode, Debug, PartialEq)]
struct NameAndType {
    #[knus(node_name)]
    node_name: String,
    #[knus(type_name)]
    type_name: Option<TypeName>,
}

fn parse<T: Decode<Span>>(text: &str) -> T {
    let mut nodes: Vec<T> = knus::parse("<test>", text).unwrap();
    assert_eq!(nodes.len(), 1);
    nodes.remove(0)
}

#[test]
fn parse_node_span() {
    assert_eq!(
        parse::<NodeSpan>(r#"node "hello""#),
        NodeSpan {
            span: Span(0, 12),
            name: "hello".into(),
            children: Vec::new(),
        }
    );
    assert_eq!(
        parse::<NodeSpan>(r#"   node  "hello"     "#),
        NodeSpan {
            span: Span(3, 21),
            name: "hello".into(),
            children: Vec::new(),
        }
    );
    assert_eq!(
        parse::<NodeSpan>(r#"   node  "hello";     "#),
        NodeSpan {
            span: Span(3, 17),
            name: "hello".into(),
            children: Vec::new(),
        }
    );
    assert_eq!(
        parse::<NodeSpan>(r#"   node  "hello"     {   child;   }"#),
        NodeSpan {
            span: Span(3, 35),
            name: "hello".into(),
            children: vec![Child],
        }
    );
}

#[test]
fn parse_node_type() {
    assert_eq!(
        parse::<NodeType>(r#"(unknown)node {}"#),
        NodeType {
            type_name: "unknown".into()
        }
    );
}

#[test]
fn parse_name_and_type() {
    assert_eq!(
        parse::<NameAndType>(r#"(u32)nodexxx"#),
        NameAndType {
            node_name: "nodexxx".into(),
            type_name: Some(BuiltinType::U32.into()),
        }
    );

    assert_eq!(
        parse::<NameAndType>(r#"yyynode /-{   }"#),
        NameAndType {
            node_name: "yyynode".into(),
            type_name: None,
        }
    );
}