granit-parser 0.0.2

A YAML parser in pure Rust with strict compliance
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

use granit_parser::{Event, Parser, ScalarStyle};

#[test]
fn misplaced_closing_bracket_at_col_0() {
    let yaml = "key: [\n]\n";
    let parser = Parser::new_from_str(yaml);

    let mut events = Vec::new();
    for next in parser {
        match next {
            Ok((ev, _)) => events.push(ev),
            Err(err) => {
                panic!("Error: {}", err.info());
            }
        }
    }

    assert_eq!(events.len(), 9);
    assert!(matches!(events[0], Event::StreamStart));
    assert!(matches!(events[1], Event::DocumentStart(false)));
    assert!(matches!(events[2], Event::MappingStart(0, None)));
    if let Event::Scalar(ref v, ScalarStyle::Plain, 0, None) = events[3] {
        assert_eq!(&**v, "key");
    } else {
        panic!("Expected scalar 'key'");
    }
    assert!(matches!(events[4], Event::SequenceStart(0, None)));
    assert!(matches!(events[5], Event::SequenceEnd));
    assert!(matches!(events[6], Event::MappingEnd));
    assert!(matches!(events[7], Event::DocumentEnd));
    assert!(matches!(events[8], Event::StreamEnd));
}

#[test]
fn misplaced_closing_brace_at_col_0() {
    let yaml = "key: {\n}\n";
    let parser = Parser::new_from_str(yaml);

    let mut events = Vec::new();
    for next in parser {
        match next {
            Ok((ev, _)) => events.push(ev),
            Err(err) => {
                panic!("Error: {}", err.info());
            }
        }
    }

    assert_eq!(events.len(), 9);
    assert!(matches!(events[0], Event::StreamStart));
    assert!(matches!(events[1], Event::DocumentStart(false)));
    assert!(matches!(events[2], Event::MappingStart(0, None)));
    if let Event::Scalar(ref v, ScalarStyle::Plain, 0, None) = events[3] {
        assert_eq!(&**v, "key");
    } else {
        panic!("Expected scalar 'key'");
    }
    assert!(matches!(events[4], Event::MappingStart(0, None)));
    assert!(matches!(events[5], Event::MappingEnd));
    assert!(matches!(events[6], Event::MappingEnd));
    assert!(matches!(events[7], Event::DocumentEnd));
    assert!(matches!(events[8], Event::StreamEnd));
}

#[test]
fn misplaced_comma_at_col_0() {
    let yaml = "key: [\n a\n, b\n]\n";
    let parser = Parser::new_from_str(yaml);

    let mut events = Vec::new();
    for next in parser {
        match next {
            Ok((ev, _)) => events.push(ev),
            Err(err) => {
                panic!("Error: {}", err.info());
            }
        }
    }

    assert_eq!(events.len(), 11);
    assert!(matches!(events[0], Event::StreamStart));
    assert!(matches!(events[1], Event::DocumentStart(false)));
    assert!(matches!(events[2], Event::MappingStart(0, None)));
    if let Event::Scalar(ref v, ScalarStyle::Plain, 0, None) = events[3] {
        assert_eq!(&**v, "key");
    } else {
        panic!("Expected scalar 'key'");
    }
    assert!(matches!(events[4], Event::SequenceStart(0, None)));
    if let Event::Scalar(ref v, ScalarStyle::Plain, 0, None) = events[5] {
        assert_eq!(&**v, "a");
    } else {
        panic!("Expected scalar 'a'");
    }
    if let Event::Scalar(ref v, ScalarStyle::Plain, 0, None) = events[6] {
        assert_eq!(&**v, "b");
    } else {
        panic!("Expected scalar 'b'");
    }
    assert!(matches!(events[7], Event::SequenceEnd));
    assert!(matches!(events[8], Event::MappingEnd));
    assert!(matches!(events[9], Event::DocumentEnd));
    assert!(matches!(events[10], Event::StreamEnd));
}