eon 0.2.0

Use the Eon config format with serde
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

//! The [`eon_syntax`] crate uses the [`TokenTree`] type as inpuit to the formatter,
//! so in order to format a [`Value`] as we need a way to convert it to [`TokenValue`].
//! That's the purpose of this module.

use crate::{Value, value::Variant};

use eon_syntax::{
    TokenKeyValue, TokenList, TokenMap, TokenTree, TokenValue, TokenVariant, escape_and_quote,
    is_valid_identifier,
};

impl From<Value> for TokenTree<'static> {
    fn from(value: Value) -> Self {
        Self::from(TokenValue::from(value))
    }
}

impl From<Value> for TokenValue<'static> {
    fn from(value: Value) -> Self {
        match value {
            Value::Null => TokenValue::Identifier("null".into()),
            Value::Bool(true) => TokenValue::Identifier("true".into()),
            Value::Bool(false) => TokenValue::Identifier("false".into()),
            Value::Number(number) => TokenValue::Number(number.to_string().into()),
            Value::String(string) => TokenValue::QuotedString(escape_and_quote(&string).into()),
            Value::List(list) => TokenValue::List(TokenList {
                values: list.into_iter().map(Into::into).collect(),
                closing_comments: vec![],
            }),
            Value::Map(map) => {
                let all_keys_are_identifiers = map.iter().all(|(key, _)| {
                    if let Value::String(key) = key {
                        is_valid_identifier(key)
                    } else {
                        false
                    }
                });

                TokenValue::Map(TokenMap {
                    key_values: map
                        .into_iter()
                        .map(|(key, value)| {
                            let key = if all_keys_are_identifiers {
                                if let Value::String(key) = key {
                                    TokenTree::from(TokenValue::Identifier(key.into()))
                                } else {
                                    unreachable!();
                                }
                            } else {
                                TokenTree::from(key)
                            };

                            TokenKeyValue {
                                key,
                                value: TokenTree::from(value),
                            }
                        })
                        .collect(),
                    closing_comments: Default::default(),
                })
            }
            Value::Variant(Variant { name, values }) => TokenValue::Variant(TokenVariant {
                name_span: None,
                quoted_name: escape_and_quote(&name).into(),
                values: values.into_iter().map(Into::into).collect(),
                closing_comments: Default::default(),
            }),
        }
    }
}