toql_derive 0.4.0

Library with derive for toql
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

use crate::result::Result;
use crate::{error::DeriveError, parsed::rename_case::RenameCase};
use syn::{Ident, Lit, Path};

pub(crate) fn parse_lit_str(lit: &Lit) -> Result<String> {
    if let Lit::Str(lit_str) = lit {
        Ok(lit_str.value())
    } else {
        Err(DeriveError::AttributeValueInvalid(lit.span()))
    }
}
pub(crate) fn parse_lit_str_as_path(lit: &Lit) -> Result<Path> {
    if let Lit::Str(lit_str) = lit {
        lit_str
            .parse()
            .map_err(|_| DeriveError::AttributeValueInvalid(lit.span()))
    } else {
        Err(DeriveError::AttributeValueInvalid(lit.span()))
    }
}
pub(crate) fn parse_lit_u64(lit: &Lit) -> Result<u64> {
    if let Lit::Int(lit_int) = lit {
        lit_int
            .base10_parse::<u64>()
            .map_err(|_| DeriveError::AttributeValueInvalid(lit.span()))
    } else {
        Err(DeriveError::AttributeValueInvalid(lit.span()))
    }
}
pub(crate) fn set_unique_bool(value: &mut Option<bool>, ident: &Ident, b: bool) -> Result<()> {
    if value.is_some() {
        return Err(DeriveError::AttributeDuplicate(ident.span()));
    } else {
        *value = Some(b);
    }
    Ok(())
}
pub(crate) fn set_unique_str_lit(
    value: &mut Option<String>,
    ident: &Ident,
    lit: &Lit,
) -> Result<()> {
    if value.is_some() {
        return Err(DeriveError::AttributeDuplicate(ident.span()));
    } else {
        *value = Some(parse_lit_str(lit)?);
    }
    Ok(())
}
pub(crate) fn set_unique_path_lit(
    value: &mut Option<Path>,
    ident: &Ident,
    lit: &Lit,
) -> Result<()> {
    if value.is_some() {
        return Err(DeriveError::AttributeDuplicate(ident.span()));
    } else {
        *value = Some(parse_lit_str_as_path(lit)?);
    }
    Ok(())
}
pub(crate) fn set_unique_usize_lit(
    value: &mut Option<usize>,
    ident: &Ident,
    lit: &Lit,
) -> Result<()> {
    if value.is_some() {
        return Err(DeriveError::AttributeDuplicate(ident.span()));
    } else {
        *value = Some(parse_lit_u64(lit)? as usize);
    }
    Ok(())
}
pub(crate) fn set_unique_rename_case_lit(
    value: &mut Option<RenameCase>,
    ident: &Ident,
    lit: &Lit,
) -> Result<()> {
    if let Lit::Str(lit_str) = lit {
        let lit = lit_str.value();
        match lit.parse() {
            Ok(c) => {
                if value.is_some() {
                    return Err(DeriveError::AttributeDuplicate(ident.span()));
                } else {
                    *value = Some(c);
                }
            }
            Err(_) => {
                let expected: Vec<String> =
                    RenameCase::VARIANTS.iter().map(|s| s.to_string()).collect();
                return Err(DeriveError::AttributeValueUnknown(
                    lit_str.span(),
                    expected.join(", "),
                )
                .into());
            }
        }
    } else {
        return Err(DeriveError::AttributeValueInvalid(lit.span()));
    }
    Ok(())
}