tom 0.0.1

Yet another format-preserving TOML parser/manipulator.
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

use {
    CstNode, SyntaxError, TextRange, TomlDoc, ChunkedText,
    ast,
    visitor,
};

pub(crate) fn validate(doc: &TomlDoc) -> Vec<SyntaxError> {
    visitor::process(
        doc.cst(),
        doc,
        visitor::visitor(Vec::new())
            .visit::<ast::Entry, _>(|errors, entry| {
                if let Some(first_key) = entry.keys(doc).next() {
                    check_new_line(
                        doc,
                        errors,
                        first_key,
                        entry.value(doc),
                        Forbid,
                        "newlines are forbidden in entries",
                    );
                }
            })
            .visit::<ast::Dict, _>(|errors, d| {
                check_new_line(
                    doc,
                    errors,
                    d.cst().children(doc).first().unwrap(),
                    d.cst().children(doc).last().unwrap(),
                    Forbid,
                    "newlines are forbidden in inline tables",
                )
            })
            .visit::<ast::Table, _>(|errors, table| check_table(doc, errors, table))
            .visit::<ast::ArrayTable, _>(|errors, table| check_table(doc, errors, table)),
    )
}

fn check_table<'f>(
    doc: &TomlDoc,
    errors: &mut Vec<SyntaxError>,
    table: impl ast::EntryOwner + ast::TableHeaderOwner,
) {
    let header = table.header(doc);
    match (
        header.cst().children(doc).first(),
        header.cst().children(doc).last(),
    ) {
        (Some(first), Some(last)) => check_new_line(
            doc,
            errors,
            first,
            last,
            Forbid,
            "table header must fit into a single line",
        ),
        _ => (),
    }
    if let Some(entry) = table.entries(doc).next() {
        check_new_line(
            doc,
            errors,
            header,
            entry,
            Require,
            "newline is mandatory after table header",
        );
    }
}

#[derive(PartialOrd, PartialEq)]
enum Requirement {
    Forbid,
    Require,
}
use self::Requirement::*;

fn check_new_line<'f>(
    doc: &TomlDoc,
    errors: &mut Vec<SyntaxError>,
    left: impl Into<CstNode>,
    right: impl Into<CstNode>,
    r: Requirement,
    msg: &str,
) {
    let left = left.into();
    let right = right.into();
    assert_eq!(left.parent(doc), right.parent(doc));
    let parent = left.parent(doc).unwrap();
    // TODO: more precise
    let start = left.range(doc).start();
    let end = right.range(doc).start();
    let range = TextRange::from_to(start, end);
    let has_newline = parent.chunked_substring(doc, range).contains_char('\n');
    if has_newline != (r == Require) {
        errors.push(SyntaxError {
            range,
            message: msg.into(),
        });
    }
}