oh_my_toml 0.1.0

Awesome TOML configuration derive macro
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

//! TOML Values

use crate::{DeserializeErrors, DeserializeTable};
use miette::{Diagnostic, SourceSpan};
use nonempty::NonEmpty;
use thiserror::Error;
use toml::de::DeTable;

use crate::{DeserializeValue, Error, util::value_type_description};

#[doc = concat!("Failed to deserialize [`toml_edit::Table`]")]
#[derive(Diagnostic, Error, Debug, Clone, Eq, PartialEq, Hash)]
#[error("Type mismatch")]
pub struct DeserializeTomlTableError {
    /// Details on why deserialization failed
    pub details: String,
    /// Location of the error in the source file
    #[label("{details}")]
    pub span: SourceSpan,
}

impl Error for DeserializeTomlTableError {
    fn expected_type() -> std::borrow::Cow<'static, str> {
        "table".into()
    }
}

impl<'de> DeserializeTable<'de> for DeTable<'de> {
    type Error = DeserializeTomlTableError;

    fn deserialize_table(
        table: toml::Spanned<DeTable<'de>>,
    ) -> Result<Self, DeserializeErrors<Self, NonEmpty<Self::Error>>> {
        Ok(table.into_inner())
    }
}

/// Failed to deserialize [`Datetime`](toml_datetime::Datetime)
#[derive(Diagnostic, Error, Debug, Clone, Eq, PartialEq, Hash)]
#[error("Type mismatch")]
pub struct DeserializeDatetimeError {
    /// Details on why deserialization failed
    pub details: String,
    /// Location of the error in the source file
    #[label("{details}")]
    pub span: SourceSpan,
}

impl Error for DeserializeDatetimeError {
    fn expected_type() -> std::borrow::Cow<'static, str> {
        "datetime".into()
    }
}

impl DeserializeValue<'_> for toml_datetime::Datetime {
    type Error = DeserializeDatetimeError;

    fn deserialize_value(
        _key: crate::Key,
        value: crate::Value,
    ) -> Result<Self, DeserializeErrors<Self, NonEmpty<Self::Error>>> {
        let span = value.span();
        let description = value_type_description(&value);
        if let toml::de::DeValue::Datetime(datetime) = value.into_inner() {
            Ok(datetime)
        } else {
            Err(DeserializeErrors::err(DeserializeDatetimeError {
                details: DeserializeDatetimeError::details(description),
                span: span.into(),
            }))
        }
    }
}

/// Failed to deserialize [`Array`](toml::Array)
#[derive(Diagnostic, Error, Debug, Clone, Eq, PartialEq, Hash)]
#[error("Type mismatch")]
pub struct DeserializeTomlArrayError {
    /// Details on why deserialization failed
    pub details: String,
    /// Location of the error in the source file
    #[label("{details}")]
    pub span: SourceSpan,
}

impl Error for DeserializeTomlArrayError {
    fn expected_type() -> std::borrow::Cow<'static, str> {
        "list".into()
    }
}

impl<'v> DeserializeValue<'v> for toml::de::DeArray<'v> {
    type Error = DeserializeTomlArrayError;

    fn deserialize_value<'k>(
        _key: crate::Key<'k>,
        value: crate::Value<'v>,
    ) -> Result<Self, DeserializeErrors<Self, NonEmpty<Self::Error>>> {
        let span = value.span();
        let description = value_type_description(&value);
        if let toml::de::DeValue::Array(array) = value.into_inner() {
            Ok(array)
        } else {
            Err(DeserializeErrors::err(DeserializeTomlArrayError {
                details: DeserializeTomlArrayError::details(description),
                span: span.into(),
            }))
        }
    }
}