sword-macros 0.3.0

Structured web framework built on top of tokio ecosystem, providing powerful features for building robust web applications.
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

use crate::shared::StructFields;
use proc_macro::TokenStream;
use syn::parse::{ParseStream, Result as ParseResult};
use syn::{Ident, ItemStruct, Token, Type, parse::Parse};

pub enum InjectableKind {
    Provider,
    Component,
}

pub struct InjectableInput {
    pub struct_name: Ident,
    pub fields: Vec<(Ident, Type)>,
    pub derive_clone: bool,
    pub kind: InjectableKind,
}

struct InjectableArgs {
    kind: InjectableKind,
    derive_clone: bool,
}

impl Parse for InjectableArgs {
    fn parse(input: ParseStream) -> ParseResult<Self> {
        let mut kind = InjectableKind::Component;
        let mut derive_clone = true;

        if input.is_empty() {
            return Ok(Self { kind, derive_clone });
        }

        while !input.is_empty() {
            let arg: Ident = input.parse()?;

            match arg.to_string().as_str() {
                "provider" => kind = InjectableKind::Provider,
                "component" => kind = InjectableKind::Component,
                "no_derive_clone" => derive_clone = false,
                _ => {
                    return Err(syn::Error::new_spanned(
                        arg,
                        "Unknown attribute. Use 'provider', 'component', or 'no_derive_clone'",
                    ));
                }
            }

            if !input.is_empty() {
                input.parse::<Token![,]>()?;
            }
        }

        Ok(Self { kind, derive_clone })
    }
}

pub fn parse_injectable_input(
    attr: TokenStream,
    item: TokenStream,
) -> Result<InjectableInput, syn::Error> {
    let input = syn::parse::<ItemStruct>(item)?;
    let args = syn::parse::<InjectableArgs>(attr)?;

    Ok(InjectableInput {
        struct_name: input.clone().ident,
        fields: StructFields::parse(&input)?,
        derive_clone: args.derive_clone,
        kind: args.kind,
    })
}