from_proc 0.1.2

A procedural macro for `from` crate
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

use std::collections::HashMap;

use proc_macro::TokenStream;

use proc_macro2::TokenStream as TokenStream2;
use quote::quote;
use syn::ext::IdentExt;

use crate::metas_holder::{value::FromExpr, MetaNameValues};

use super::Append;

#[track_caller]
#[inline(always)]
pub fn process<F>(
    meta_name_values: &MetaNameValues,
    prop_or_idx: &TokenStream2,
    dflt_lang: &str,
    backup_msg: F,
) -> Result<(TokenStream2, TokenStream2), TokenStream>
where
    F: Fn() -> TokenStream2,
{
    let mut langs_msgs = convert_to_hash_map(meta_name_values)?;

    let dflt_msg = match langs_msgs.remove(dflt_lang) {
        Some(msg) => quote! {String::from(#msg)},
        None => backup_msg(),
    };

    Ok(construct(langs_msgs, prop_or_idx, dflt_lang, dflt_msg))
}

#[track_caller]
#[inline]
fn convert_to_hash_map(metas: &MetaNameValues) -> Result<HashMap<String, String>, TokenStream> {
    let mut lang_msgs = HashMap::<String, String>::new();

    for nv in metas {
        match nv.path.get_ident() {
            Some(ident) => {
                let ident = ident.unraw().to_string();

                lang_msgs.insert(ident, String::from_expr(&nv.value)?);
            }

            None => continue,
        };
    }

    Ok(lang_msgs)
}

#[inline(always)]
pub fn construct(
    langs_msgs: HashMap<String, String>,
    prop_or_idx: &TokenStream2,
    dflt_lang: &str,
    dflt_msg: TokenStream2,
) -> (TokenStream2, TokenStream2) {
    let single_msg_err = quote! {
        ::from::ValidationErr {
            target: From::from(#prop_or_idx),
            path: path.clone(),
            msg: #dflt_msg,
        }
    };

    let multi_msgs_err = {
        match langs_msgs.len() {
            0 => single_msg_err.clone(),

            // > 1
            _ => {
                let mut arms = TokenStream2::new();
                for (lang, msg) in langs_msgs {
                    arms.append(quote! {
                        #lang => String::from(#msg),
                    });
                }

                arms.append(quote! { #dflt_lang | _ => #dflt_msg, });

                quote! {
                    ::from::ValidationErr {
                        target: From::from(#prop_or_idx),
                        path: path.clone(),
                        msg: match lang {#arms},
                    }
                }
            }
        }
    };

    (single_msg_err, multi_msgs_err)
}

#[inline]
pub fn construct_dflt(
    prop_or_idx: &TokenStream2,
    dflt_msg: TokenStream2,
) -> (TokenStream2, TokenStream2) {
    let msg = quote! {
        ::from::ValidationErr {
            target: From::from(#prop_or_idx),
            path: path.clone(),
            msg: String::from(#dflt_msg),
        }
    };

    (msg.clone(), msg)
}