serde-saphyr 1.1.0

YAML (de)serializer for Serde, emphasizing panic-free parsing, fast builds and good error reporting. Supports properties, comments, include
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

use granit_parser::{Options as ParserOptions, Parser};

#[cfg(feature = "include")]
use std::rc::Rc;

use granit_parser::StrInput;

#[cfg(feature = "include")]
use crate::include_stack::ParserStack;
#[cfg(feature = "include")]
use crate::input_source::IncludeResolver;

#[cfg(feature = "include")]
use crate::buffered_input::{ReaderInput, ReaderInputBytesRead};

#[cfg(feature = "include")]
pub(crate) type BaseParser<'a> = ParserStack<'a>;

#[cfg(not(feature = "include"))]
pub(crate) type BaseParser<'a, I> = Parser<'a, I>;

#[cfg(feature = "include")]
#[inline]
pub(crate) fn create_parser_from_reader_input<'input>(
    input: ReaderInput<'input>,
    reader_bytes_read: ReaderInputBytesRead,
    budget: &crate::Budget,
    parser_options: ParserOptions,
    resolver: Option<Box<IncludeResolver<'input>>>,
) -> ParserStack<'input> {
    let mut stack =
        ParserStack::with_parser_options(reader_bytes_read, budget, parser_options.clone());
    if let Some(r) = resolver {
        stack.set_resolver(r);
    }
    stack.push_stream_parser(
        Parser::with_options(input, parser_options),
        "<input>".to_string(),
    );
    stack
}

// Note: in non-include builds we construct the parser directly where needed.

#[cfg(feature = "include")]
#[inline]
pub(crate) fn create_parser_from_str<'a>(
    input: &'a str,
    reader_bytes_read: ReaderInputBytesRead,
    budget: &crate::Budget,
    parser_options: ParserOptions,
    resolver: Option<Box<IncludeResolver<'a>>>,
) -> ParserStack<'a> {
    let mut stack =
        ParserStack::with_parser_options(reader_bytes_read, budget, parser_options.clone());
    if let Some(r) = resolver {
        stack.set_resolver(r);
    }
    let snippet = crate::include_stack::SnippetFrame {
        name: "<input>".to_string(),
        text: Rc::from(input),
    };
    stack.push_str_parser_with_snippet(
        Parser::with_options(StrInput::new(input), parser_options),
        "<input>".to_string(),
        Some(&snippet),
        crate::Location::UNKNOWN,
    );
    stack
}

#[cfg(not(feature = "include"))]
#[inline]
pub(crate) fn create_parser_from_str<'a>(
    input: &'a str,
    parser_options: ParserOptions,
) -> BaseParser<'a, StrInput<'a>> {
    Parser::with_options(StrInput::new(input), parser_options)
}

#[cfg(all(test, feature = "include"))]
mod tests {
    use super::*;

    #[test]
    fn create_parser_from_str_borrows_root_text_for_snippets() {
        let input = "root: 1";
        let budget = crate::Budget::default();
        let parser_options = crate::Options::default().parser_options();
        let stack = create_parser_from_str(
            input,
            std::rc::Rc::new(std::cell::Cell::new(0)),
            &budget,
            parser_options,
            None,
        );

        let root = stack
            .resolved_sources
            .get(&1)
            .expect("root source recorded");
        let text = root.text.as_ref().expect("root text recorded");
        assert_eq!(text.as_ref(), input);
    }
}