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

use std::iter;
use testutils::assert_eq_text;
use tom::{CstNode, TomlDoc};

#[test]
fn create_key_with_space() {
    check(|doc| doc.new_key("foo bar"), "\"foo bar\"");
}

#[test]
fn create_entry() {
    check(
        |doc| {
            let key = doc.new_key("foo");
            let val = doc.new_value("1.0");
            doc.new_entry(iter::once(key), val)
        },
        r#"foo = "1.0""#,
    );
}

#[test]
fn create_dict() {
    check(
        |doc| {
            let a = doc.new_entry_from_text("foo = \"1.0\"");
            let b = doc.new_entry_from_text("bar = \"0.0.1\"");
            doc.new_value_dict(vec![a, b].into_iter())
        },
        r#"{ foo = "1.0", bar = "0.0.1" }"#,
    );
}

#[test]
fn create_array() {
    check(
        |doc| {
            let a = doc.new_value(92);
            let b = doc.new_value(62);
            doc.new_value_array(vec![a, b].into_iter())
        },
        "[ 92, 62 ]",
    );
}

#[test]
fn create_table() {
    check(
        |doc| {
            let a = doc.new_entry_from_text("foo = \"1.0\"");
            let b = doc.new_entry_from_text("bar = \"0.0.1\"");
            let mut keys = Vec::new();
            for key in "target x86_64.json dependencies".split_whitespace() {
                keys.push(doc.new_key(key));
            }
            doc.new_table(keys.into_iter(), vec![a, b].into_iter())
        },
        r#"[target."x86_64.json".dependencies]
foo = "1.0"
bar = "0.0.1""#,
    );
}

#[test]
fn create_array_table() {
    check(
        |doc| {
            let a = doc.new_entry_from_text("name = \"foo\"");
            let key = doc.new_key("bin");

            doc.new_array_table(iter::once(key), iter::once(a)).cst()
        },
        r#"[[bin]]
name = "foo""#,
    );
}

fn check<F: FnOnce(&mut TomlDoc) -> R, R: Into<CstNode>>(f: F, expected: &str) {
    let mut doc = TomlDoc::new("");
    doc.start_edit();
    let cst = f(&mut doc).into();
    let actual = cst.get_text(&doc);
    assert_eq_text(expected, &actual)
}