fieldless_enum_tools_impl 0.2.0

tools for enums without any fields - implementation
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

pub use super::super::Impl;
use syn::{spanned::Spanned, Error, Meta, MetaList, NestedMeta};

pub struct Attrs {
    pub format: Option<Format>,
    pub skip: Option<Skip>,
}

impl Attrs {
    pub fn from_attrs(attrs: &[syn::Attribute]) -> syn::Result<Self> {
        let mut format = None;
        let mut skip = None;

        for attr in attrs {
            try_get! {attr;
                format => Format,
                skip => Skip
            }
        }
        Ok(Self { format, skip })
    }
    #[inline]
    pub fn should_skip(&self, imp: Impl) -> bool {
        self.skip.as_ref().map_or(false, |s| s.should_skip(imp))
    }
}

pub struct Skip(pub Vec<Impl>);

impl Skip {
    pub fn from_attr(attr: MetaList) -> syn::Result<Self> {
        let mut vec = Vec::with_capacity(attr.nested.len());
        let attr_span = attr.span();
        let malformed_err = malformed_err!(attr_span, r#"skip("..."*)"#);

        for nested in attr.nested {
            if let NestedMeta::Meta(Meta::Path(path)) = nested {
                let ident = path.get_ident().ok_or_else(malformed_err)?;

                vec.push(match &*ident.to_string() {
                    "TryFromString" => Impl::TryFromString,
                    "FromStr" => Impl::FromStr,
                    "AsRefStr" => Impl::AsRefStr,
                    "IntoString" => Impl::IntoString,
                    "Display" => Impl::Display,
                    "Serialize" => Impl::Serialize,
                    "Deserialize" => Impl::Deserialize,
                    _ => return Err(Error::new_spanned(ident, "not an avaliable skip!")),
                });
            } else {
                return Err(malformed_err());
            }
        }

        Ok(Self(vec))
    }
    pub fn should_skip(&self, imp: Impl) -> bool {
        self.0.contains(&imp)
    }
}

pub struct Format(pub super::FormatCase);

impl Format {
    pub fn from_attr(attr: MetaList) -> syn::Result<Self> {
        let attr_span = attr.span();
        let malformed_err = malformed_err!(attr_span, r#"format(style = "...")"#);

        Ok(Self(super::FormatCase::from_attr(&attr, malformed_err)?))
    }
    #[inline]
    pub fn format(&self, s: &str) -> String {
        self.0.format(s)
    }
}