static-toml 1.3.0

Effortlessly embed TOML files into your Rust code as static data with custom data 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

use quote::{format_ident, quote};
use toml::Value;

use crate::parse::StaticTomlAttributes;
use crate::toml_tokens::TomlTokens;

#[test]
fn default_static_tokens_works() {
    let config = StaticTomlAttributes::default();
    let mut namespace = vec![format_ident!("toml")];

    let toml: Value = toml::from_str(include_str!("../../../example.toml")).unwrap();
    let toml_ts = toml
        .static_tokens(namespace[0].to_string().as_str(), &config, &mut namespace)
        .unwrap();
    let toml_ts_expected = quote! {
        toml::Toml {
            database: toml::database::Database {
                data: toml::database::data::Data(["delta", "phi"], [3.14f64]),
                enabled: true,
                ports: [8000i64, 8001i64, 8002i64],
                temp_targets: toml::database::temp_targets::TempTargets {
                    case: 72f64,
                    cpu: 79.5f64
                }
            },
            owner: toml::owner::Owner {
                dob: "1979-05-27T07:32:00-08:00",
                name: "Tom Preston-Werner"
            },
            servers: toml::servers::Servers {
                alpha: toml::servers::alpha::Alpha {
                    ip: "10.0.0.1",
                    role: "frontend"
                },
                beta: toml::servers::beta::Beta {
                    ip: "10.0.0.2",
                    role: "backend"
                }
            },
            title: "TOML Example"
        }
    };

    assert_eq!(toml_ts.to_string(), toml_ts_expected.to_string());
}

#[test]
fn values_ident_works() {
    let default_config = StaticTomlAttributes::default();
    let value_ident_config = StaticTomlAttributes {
        values_ident: Some(format_ident!("items")),
        ..StaticTomlAttributes::default()
    };
    let mut namespace = vec![format_ident!("toml")];

    let toml: Value = toml::from_str(
        "
    [[list]]
    value = 123

    [[list]]
    value = 456

    [[tuple]]
    a = 1

    [[tuple]]
    b = 2
    "
    )
    .unwrap();

    let default_toml_ts = toml
        .static_tokens(
            namespace[0].to_string().as_str(),
            &default_config,
            &mut namespace
        )
        .unwrap();
    let default_toml_ts_expected = quote! {
        toml::Toml {
            list: [
                toml::list::values::Values { value: 123i64 },
                toml::list::values::Values { value: 456i64 }
            ],
            tuple: toml::tuple::Tuple(
                toml::tuple::values_0::Values0 { a: 1i64 },
                toml::tuple::values_1::Values1 { b: 2i64 }
            )
        }
    };
    assert_eq!(
        default_toml_ts.to_string(),
        default_toml_ts_expected.to_string()
    );

    let items_toml_ts = toml
        .static_tokens(
            namespace[0].to_string().as_str(),
            &value_ident_config,
            &mut namespace
        )
        .unwrap();
    let items_toml_ts_expected = quote! {
        toml::Toml {
            list: [
                toml::list::items::Items { value: 123i64 },
                toml::list::items::Items { value: 456i64 }
            ],
            tuple: toml::tuple::Tuple(
                toml::tuple::items_0::Items0 { a: 1i64 },
                toml::tuple::items_1::Items1 { b: 2i64 }
            )
        }
    };
    assert_eq!(
        items_toml_ts.to_string(),
        items_toml_ts_expected.to_string()
    );
}