custom_debug_derive 0.6.2

Derive Debug with a custom format per field
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 darling::util::Flag;
use darling::FromMeta;
use syn::ExprPath;

#[derive(Default)]
pub struct FieldAttributes {
    pub skip_mode: SkipMode,
    pub debug_format: DebugFormat,
}

impl FieldAttributes {
    fn new(internal: InternalFieldAttributes) -> darling::Result<Self> {
        let mut skip_mode = SkipMode::Default;
        let mut debug_format = DebugFormat::Default;

        if internal.skip.is_present() {
            skip_mode = skip_mode.try_combine(SkipMode::Always)?;
        }

        if let Some(skip_if) = internal.skip_if {
            skip_mode = skip_mode.try_combine(SkipMode::Condition(skip_if))?;
        }

        if let Some(format) = internal.format {
            debug_format = debug_format.try_combine(DebugFormat::Format(format))?;
        }

        if let Some(with) = internal.with {
            debug_format = debug_format.try_combine(DebugFormat::With(with))?;
        }

        Ok(Self {
            skip_mode,
            debug_format,
        })
    }

    pub fn try_combine(self, other: Self) -> darling::Result<Self> {
        let skip_mode = self.skip_mode.try_combine(other.skip_mode)?;
        let debug_format = self.debug_format.try_combine(other.debug_format)?;

        Ok(Self {
            skip_mode,
            debug_format,
        })
    }
}

impl FromMeta for FieldAttributes {
    fn from_nested_meta(item: &darling::ast::NestedMeta) -> darling::Result<Self> {
        InternalFieldAttributes::from_nested_meta(item).and_then(FieldAttributes::new)
    }

    fn from_meta(item: &syn::Meta) -> darling::Result<Self> {
        InternalFieldAttributes::from_meta(item).and_then(FieldAttributes::new)
    }

    fn from_none() -> Option<Self> {
        InternalFieldAttributes::from_none().and_then(|attrs| FieldAttributes::new(attrs).ok())
    }

    fn from_word() -> darling::Result<Self> {
        InternalFieldAttributes::from_word().and_then(FieldAttributes::new)
    }

    fn from_list(items: &[darling::ast::NestedMeta]) -> darling::Result<Self> {
        InternalFieldAttributes::from_list(items).and_then(FieldAttributes::new)
    }
}

#[derive(FromMeta, Debug, PartialEq, Eq, Default)]
pub enum DebugFormat {
    #[default]
    Default,
    Format(String),
    With(ExprPath),
}

impl DebugFormat {
    fn try_combine(self, other: Self) -> darling::Result<Self> {
        match (&self, &other) {
            (DebugFormat::Default, _) => Ok(other),
            (_, DebugFormat::Default) => Ok(self),
            _ => Err(conflicting_format_options_error()),
        }
    }
}

#[derive(Default, PartialEq, Eq)]
pub enum SkipMode {
    #[default]
    Default,
    Condition(ExprPath),
    Always,
}

impl SkipMode {
    fn try_combine(self, other: Self) -> darling::Result<Self> {
        match (&self, &other) {
            (SkipMode::Default, _) => Ok(other),
            (_, SkipMode::Default) => Ok(self),
            _ => Err(conflicting_skip_options_error()),
        }
    }
}

#[derive(FromMeta)]
struct InternalFieldAttributes {
    skip: Flag,
    skip_if: Option<ExprPath>,
    format: Option<String>,
    with: Option<ExprPath>,
}

fn conflicting_skip_options_error() -> darling::Error {
    darling::Error::custom("Conflicting skip options")
}

fn conflicting_format_options_error() -> darling::Error {
    darling::Error::custom("Conflicting format options")
}