toml 1.1.2+spec-1.1.0

A native Rust encoder and decoder of TOML-formatted files and streams. Provides implementations of the standard Serialize/Deserialize traits for TOML data to facilitate deserializing and serializing Rust structures.
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
130
131

use toml_writer::TomlWrite as _;

use crate::alloc_prelude::*;

/// TOML Document serialization buffer
#[derive(Debug, Default)]
pub struct Buffer {
    tables: Vec<Option<Table>>,
}

impl Buffer {
    /// Initialize a new serialization buffer
    pub fn new() -> Self {
        Default::default()
    }

    /// Reset the buffer for serializing another document
    pub fn clear(&mut self) {
        self.tables.clear();
    }

    pub(crate) fn root_table(&mut self) -> Table {
        self.new_table(None)
    }

    pub(crate) fn child_table(&mut self, parent: &mut Table, key: String) -> Table {
        parent.has_children = true;
        let mut key_path = parent.key.clone();
        key_path.get_or_insert_with(Vec::new).push(key);
        self.new_table(key_path)
    }

    pub(crate) fn element_table(&mut self, parent: &mut Table, key: String) -> Table {
        let mut table = self.child_table(parent, key);
        table.array = true;
        table
    }

    pub(crate) fn new_table(&mut self, key: Option<Vec<String>>) -> Table {
        let pos = self.tables.len();
        let table = Table {
            key,
            body: String::new(),
            has_children: false,
            pos,
            array: false,
        };
        self.tables.push(None);
        table
    }

    pub(crate) fn push(&mut self, table: Table) {
        let pos = table.pos;
        self.tables[pos] = Some(table);
    }
}

impl core::fmt::Display for Buffer {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        let mut tables = self
            .tables
            .iter()
            .filter_map(|t| t.as_ref())
            .filter(|t| required_table(t));
        if let Some(table) = tables.next() {
            table.fmt(f)?;
        }
        for table in tables {
            f.newline()?;
            table.fmt(f)?;
        }
        Ok(())
    }
}

fn required_table(table: &Table) -> bool {
    if table.key.is_none() {
        !table.body.is_empty()
    } else {
        table.array || !table.body.is_empty() || !table.has_children
    }
}

#[derive(Clone, Debug)]
pub(crate) struct Table {
    key: Option<Vec<String>>,
    body: String,
    has_children: bool,
    array: bool,
    pos: usize,
}

impl Table {
    pub(crate) fn body_mut(&mut self) -> &mut String {
        &mut self.body
    }

    pub(crate) fn has_children(&mut self, yes: bool) {
        self.has_children = yes;
    }
}

impl core::fmt::Display for Table {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        if let Some(key) = &self.key {
            if self.array {
                f.open_array_of_tables_header()?;
            } else {
                f.open_table_header()?;
            }
            let mut key = key.iter();
            if let Some(key) = key.next() {
                write!(f, "{key}")?;
            }
            for key in key {
                f.key_sep()?;
                write!(f, "{key}")?;
            }
            if self.array {
                f.close_array_of_tables_header()?;
            } else {
                f.close_table_header()?;
            }
            f.newline()?;
        }

        self.body.fmt(f)?;

        Ok(())
    }
}