libyaml-safer 0.3.0

Safer libyaml port, based on unsafe-libyaml
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

use std::io::Cursor;

use libyaml_safer::{Document, EventData, Parser, Scanner, TokenData};

#[test]
fn test_scanner_with_owned_input() {
    let yaml_string = String::from("key: value");
    let mut scanner = Scanner::new();
    scanner.set_input(Cursor::new(yaml_string.into_bytes()));

    // Get the first token
    let token = scanner.next().unwrap().unwrap();
    assert!(matches!(token.data, TokenData::StreamStart { .. }));
}

#[test]
fn test_parser_with_owned_vec() {
    let yaml_data = b"key: value\nlist:\n  - item1\n  - item2".to_vec();
    let mut parser = Parser::new();
    parser.set_input(Cursor::new(yaml_data));

    // Parse the first event
    let event = parser.parse().unwrap();
    assert!(matches!(event.data, EventData::StreamStart { .. }));

    // Continue parsing to verify it works
    let event = parser.parse().unwrap();
    assert!(matches!(event.data, EventData::DocumentStart { .. }));
}

#[test]
fn test_parser_with_owned_string() {
    let yaml_string = String::from("name: test\nvalue: 123");
    let mut parser = Parser::new();
    parser.set_input(Cursor::new(yaml_string));

    // Parse the first event
    let event = parser.parse().unwrap();
    assert!(matches!(event.data, EventData::StreamStart { .. }));

    // Continue parsing to verify it works
    let event = parser.parse().unwrap();
    assert!(matches!(event.data, EventData::DocumentStart { .. }));
}

#[test]
fn test_document_load_with_owned_input() {
    let yaml_string = String::from(
        r#"
users:
  - name: Alice
    age: 30
  - name: Bob
    age: 25
"#,
    );

    let mut parser = Parser::new();
    parser.set_input(Cursor::new(yaml_string.into_bytes()));

    // Load the document
    let doc = Document::load(&mut parser).unwrap();

    // Verify we got a valid document with nodes
    assert!(!doc.nodes.is_empty());
}

#[test]
fn test_owned_input_no_lifetime_constraint() {
    // This test demonstrates that owned input doesn't require
    // the caller to maintain the buffer
    fn parse_yaml_owned() -> Parser<Cursor<String>> {
        let mut parser = Parser::new();
        let data = String::from("test: value");
        parser.set_input(Cursor::new(data));
        parser
    }

    let mut parser = parse_yaml_owned();
    let event = parser.parse().unwrap();
    assert!(matches!(event.data, EventData::StreamStart { .. }));
}

#[test]
fn test_owned_vs_borrowed_equivalence() {
    const YAML: &str = "key: value";

    // Parse with borrowed input
    let mut parser_borrowed = Parser::new();
    let mut borrowed_input = YAML.as_bytes();
    parser_borrowed.set_input_string(&mut borrowed_input);

    let mut events_borrowed = Vec::new();
    for event in &mut parser_borrowed {
        events_borrowed.push(format!("{:?}", event.unwrap().data));
    }

    // Parse with owned input
    let mut parser_owned = Parser::new();
    parser_owned.set_input(Cursor::new(String::from(YAML)));

    let mut events_owned = Vec::new();
    for event in &mut parser_owned {
        events_owned.push(format!("{:?}", event.unwrap().data));
    }

    // Verify both produce the same events
    assert_eq!(events_borrowed, events_owned);
}