taplo 0.1.0

A TOML parser, analyzer and formatter library
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

use crate::dom::{nodes::*, rewrite::prelude::*};
use std::fs;

#[test]
fn rewrite_nothing() {
    let src = fs::read_to_string("../test-data/rewrite/nothing.toml").unwrap();
    let expected = fs::read_to_string("../test-data/rewrite/nothing_expected.toml").unwrap();
    let dom = crate::parser::parse(&src).into_dom();
    let rewritten = dom.rewrite(|_, node| node.into());
    assert!(expected == rewritten)
}

#[test]
fn rewrite_key() {
    let src = fs::read_to_string("../test-data/rewrite/key.toml").unwrap();
    let expected = fs::read_to_string("../test-data/rewrite/key_expected.toml").unwrap();
    let dom = crate::parser::parse(&src).into_dom();

    let rewritten = dom.rewrite(|_, node| match node {
        crate::dom::Node::Key(k) => {
            if k.full_key_string_stripped() == "rewrite_me" {
                dbg!(&k);

                KeyNode::rewrite()
                    .with_dotted_keys("rewritten")
                    .build()
                    .into()
            } else {
                k.into()
            }
        }
        _ => node.into(),
    });

    assert!(expected == rewritten)
}

#[test]
fn rewrite_value() {
    let src = fs::read_to_string("../test-data/rewrite/value.toml").unwrap();
    let expected = fs::read_to_string("../test-data/rewrite/value_expected.toml").unwrap();
    let dom = crate::parser::parse(&src).into_dom();

    let rewritten = dom.rewrite(|_, node| match node {
        crate::dom::Node::Value(v) => match v {
            ValueNode::Integer(i) => {
                if i.as_i64() == 2 {
                    TableNode::rewrite()
                        .inline()
                        .with_entry(
                            EntryNode::rewrite()
                                .with_key("original_value")
                                .with_value(ValueNode::Integer(i))
                                .build(),
                        )
                        .with_entry(
                            EntryNode::rewrite()
                                .with_key("additional_value")
                                .with_value(
                                    ValueNode::rewrite()
                                        .with_value(IntegerNode::rewrite().with_value(3).build())
                                        .build(),
                                )
                                .build(),
                        )
                        .build()
                        .into()
                } else {
                    Node::from(ValueNode::Integer(i)).into()
                }
            }
            v => Node::from(v).into(),
        },
        _ => node.into(),
    });

    assert!(expected == rewritten)
}

#[test]
fn rewrite_table() {
    let src = fs::read_to_string("../test-data/rewrite/table.toml").unwrap();
    let expected = fs::read_to_string("../test-data/rewrite/table_expected.toml").unwrap();
    let dom = crate::parser::parse(&src).into_dom();

    let rewritten = dom.rewrite(|_, node| match node {
        Node::Entry(entry) => {
            if entry.key().full_key_string_stripped() == "value" {
                match entry.into_value() {
                    ValueNode::Integer(i) => {
                        if i.as_i64() == 2 {
                            TableNode::rewrite()
                                .top_level("table", false)
                                .with_entry(
                                    EntryNode::rewrite()
                                        .with_key("original_value")
                                        .with_value(ValueNode::Integer(i))
                                        .build(),
                                )
                                .with_entry(
                                    EntryNode::rewrite()
                                        .with_key("additional_value")
                                        .with_value(
                                            ValueNode::rewrite()
                                                .with_value(IntegerNode::rewrite().with_value(3).build())
                                                .build(),
                                        )
                                        .build(),
                                )
                                .build()
                                .into()
                        } else {
                            Node::from(ValueNode::Integer(i)).into()
                        }
                    }
                    v => Node::from(v).into(),
                }
            } else {
                Node::from(entry).into()
            }
        }
        _ => node.into(),
    });

    assert!(expected == rewritten)
}