granit-parser 1.2.0

A YAML parser with comment and style support, written in pure Rust
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

/// Options controlling parser and scanner behavior and resource usage.
///
/// Construct this type with [`crate::options!`] so that code remains compatible when new options
/// are added in future releases.
///
/// # Examples
///
/// ```rust
/// let options = granit_parser::options! {
///     max_buffered_comment_events: 64,
///     emit_comments: false,
///     flow_nesting_limit: 512,
///     block_nesting_limit: 256,
/// };
///
/// assert_eq!(options.max_buffered_comment_events, 64);
/// assert!(!options.emit_comments);
/// assert_eq!(options.flow_nesting_limit, 512);
/// assert_eq!(options.block_nesting_limit, 256);
/// ```
#[non_exhaustive]
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct Options {
    /// Whether scanners emit comment tokens and parsers emit comment events.
    ///
    /// The default is `true`. When this is `false`, comments are still recognized and validated
    /// as YAML syntax, but their text is not captured and no comment tokens or events are emitted.
    /// Comment bytes are still consumed, so this is not an input-size or processing-time limit.
    /// [`Self::max_buffered_comment_events`] has no effect while comment emission is disabled.
    pub emit_comments: bool,
    /// Maximum number of consecutive comment events buffered while resolving an ambiguous
    /// collection entry.
    ///
    /// The default is 96. A value of zero rejects the first comment that would need buffering.
    pub max_buffered_comment_events: usize,
    /// Maximum number of characters inspected while resolving a simple key.
    ///
    /// The default is 1024, matching YAML's simple-key length restriction. A key at exactly this
    /// limit is accepted. Lower values impose a stricter resource limit; higher values relax that
    /// YAML restriction.
    pub simple_key_max_lookahead: usize,
    /// Maximum number of simultaneously nested flow collections.
    ///
    /// The default is 255. A value of zero rejects the first flow collection opener.
    pub flow_nesting_limit: usize,
    /// Maximum number of simultaneously nested block collections parsed, or block indentation
    /// levels retained by a scanner used directly.
    ///
    /// The default is 255. A value of zero rejects the first block sequence or mapping. This
    /// bounds both indentation state retained while scanning and the number of closing tokens
    /// queued when nested block collections end together. Parsers also count indentless block
    /// sequences, which do not add scanner indentation state.
    pub block_nesting_limit: usize,
    /// Maximum number of UTF-8 source bytes retained for a directive name and payload.
    ///
    /// The default is 1024. Separating blanks before retained values count toward the limit.
    /// `%YAML` version components instead have a fixed nine-digit limit and are stored as integers.
    /// Real directives are far shorter than the default.
    pub max_directive_bytes: usize,
    /// Maximum number of parameters retained for a single reserved directive.
    ///
    /// The default is 16. The parser ignores reserved directives, so their parameters only reach
    /// code driving [`crate::Scanner`] directly. A value of zero rejects the first parameter.
    pub max_reserved_directive_params: usize,
}

impl Default for Options {
    fn default() -> Self {
        Self {
            emit_comments: true,
            max_buffered_comment_events: 96,
            simple_key_max_lookahead: 1024,
            flow_nesting_limit: 255,
            block_nesting_limit: 255,
            max_directive_bytes: 1024,
            max_reserved_directive_params: 16,
        }
    }
}