cornetto 0.1.0

#[cornetto(manage my config)]
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

// In this file you want to read a field and parse
// a nice structure to work with for the quotes

use anyhow::{bail, Result};
use proc_macro2::Ident;
use syn::{Lit, Type};

pub struct CornettoField {
    pub ident: Ident,
    pub value: Lit,
    pub kind: CornettoKind,
    pub ty: Type,
}

pub enum CornettoKind {
    Constant,
    Testmutable,
}

impl CornettoField {
    // Parse attribute for each fields
    pub fn parse(ds: &syn::DataStruct) -> Result<Vec<CornettoField>> {
        let mut ret = vec![];
        for field in &ds.fields {
            let mut kind = None;
            let mut value = None;
            for attr in &field.attrs {
                let meta_list = match attr.parse_meta() {
                    Ok(syn::Meta::List(list)) => list,
                    _ => bail!("Cannot parse other than a metalist"),
                };
                for nested_meta in meta_list.nested {
                    match nested_meta {
                        syn::NestedMeta::Meta(meta) => {
                            if kind.is_some() {
                                bail!("Duplication of fields const, mut")
                            }
                            kind = if meta.path().is_ident("const") {
                                Some(CornettoKind::Constant)
                            } else if meta.path().is_ident("mut") {
                                Some(CornettoKind::Testmutable)
                            } else {
                                bail!("Unexpected term {:?}", meta.path().get_ident())
                            };
                        }
                        syn::NestedMeta::Lit(lit) => {
                            if value.is_some() {
                                bail!("Duplication of fields value")
                            }
                            value = Some(lit)
                        }
                    };
                }
            }
            ret.push(CornettoField {
                kind: kind.expect("Field needs to be const or mut"),
                ident: field.ident.clone().unwrap(),
                value: value.expect("Expected field value literal"),
                ty: field.ty.clone(),
            });
        }
        Ok(ret)
    }
}