oak-yaml 0.0.11

High-performance incremental YAML parser for the oak ecosystem with flexible configuration, optimized for configuration files and data serialization.
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
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

#![doc = include_str!("readme.md")]

use core::{fmt, range::Range};

/// YAML root node.
#[derive(Debug, Clone)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct YamlRoot {
    /// Range of the node in the source code.
    #[cfg_attr(feature = "serde", serde(with = "oak_core::serde_range"))]
    pub span: Range<usize>,
    /// Items in the YAML document.
    pub items: Vec<YamlValueNode>,
}

/// YAML value.
#[derive(Debug, Clone)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum YamlValueNode {
    /// Scalar value.
    Scalar(YamlScalar),
    /// Sequence value.
    Sequence(YamlSequence),
    /// Mapping value.
    Mapping(YamlMapping),
}

/// YAML scalar value.
#[derive(Debug, Clone)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct YamlScalar {
    /// Range of the scalar in the source code.
    #[cfg_attr(feature = "serde", serde(with = "oak_core::serde_range"))]
    pub span: Range<usize>,
    /// Value of the scalar.
    pub value: String,
}

/// YAML sequence value.
#[derive(Debug, Clone)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct YamlSequence {
    /// Range of the sequence in the source code.
    #[cfg_attr(feature = "serde", serde(with = "oak_core::serde_range"))]
    pub span: Range<usize>,
    /// Items in the sequence.
    pub items: Vec<YamlValueNode>,
}

/// YAML mapping value.
#[derive(Debug, Clone)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct YamlMapping {
    /// Range of the mapping in the source code.
    #[cfg_attr(feature = "serde", serde(with = "oak_core::serde_range"))]
    pub span: Range<usize>,
    /// Entries in the mapping.
    pub entries: Vec<YamlMappingEntry>,
}

/// YAML mapping entry.
#[derive(Debug, Clone)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct YamlMappingEntry {
    /// Range of the entry in the source code.
    #[cfg_attr(feature = "serde", serde(with = "oak_core::serde_range"))]
    pub span: Range<usize>,
    /// Key of the entry.
    pub key: YamlValueNode,
    /// Value of the entry.
    pub value: YamlValueNode,
}

impl fmt::Display for YamlValueNode {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        self.fmt_with_indent(f, 0)
    }
}

impl YamlValueNode {
    fn fmt_with_indent(&self, f: &mut fmt::Formatter<'_>, indent: usize) -> fmt::Result {
        let indent_str = "  ".repeat(indent);
        match self {
            YamlValueNode::Scalar(scalar) => {
                write!(f, "{}", scalar.value)
            }
            YamlValueNode::Sequence(seq) => {
                for (i, item) in seq.items.iter().enumerate() {
                    if i > 0 {
                        writeln!(f)?;
                    }
                    write!(f, "{indent_str}-")?;
                    match item {
                        YamlValueNode::Scalar(_) => {
                            write!(f, " ")?;
                            item.fmt_with_indent(f, indent)
                        }
                        _ => {
                            writeln!(f)?;
                            item.fmt_with_indent(f, indent + 1)
                        }
                    }?;
                }
                Ok(())
            }
            YamlValueNode::Mapping(map) => {
                for (i, entry) in map.entries.iter().enumerate() {
                    if i > 0 {
                        writeln!(f)?;
                    }
                    write!(f, "{indent_str}")?;
                    entry.key.fmt_with_indent(f, 0)?;
                    write!(f, ":")?;
                    match &entry.value {
                        YamlValueNode::Scalar(_) => {
                            write!(f, " ")?;
                            entry.value.fmt_with_indent(f, 0)
                        }
                        _ => {
                            writeln!(f)?;
                            entry.value.fmt_with_indent(f, indent + 1)
                        }
                    }?;
                }
                Ok(())
            }
        }
    }
}