enum_handler_core 0.1.0

This crate is part of the enum_handler library. Do not use it directly.
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
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

use crate::{enum_handler_args::EnumHandlerArgs, Error, Result};
use heck::ToSnakeCase;
use quote::format_ident;
use syn::{Data, DeriveInput, Fields, Ident, Type, Variant, Visibility};

pub struct Enum {
    pub vis: Visibility,
    pub name: Ident,
    pub variants: Vec<EnumVariant>,
}

impl Enum {
    pub fn new(
        derive_input: &DeriveInput,
        args: &EnumHandlerArgs,
    ) -> Result<Self> {
        let data_enum = match &derive_input.data {
            Data::Enum(data_enum) => data_enum,
            _ => return Err(Error::NotEnum),
        };

        let vis = derive_input
            .vis
            .clone();
        let name = derive_input
            .ident
            .clone();
        let variants: Result<Vec<EnumVariant>> = data_enum
            .variants
            .iter()
            .map(|v| EnumVariant::new(v, name.clone(), args))
            .collect();

        match variants {
            Ok(variants) => Ok(Enum {
                vis,
                name,
                variants,
            }),
            Err(e) => Err(e),
        }
    }
}

pub enum EnumVariantType {
    Unit,
    Tuple,
    Struct,
}

pub struct EnumVariant {
    pub enum_name: Ident,
    pub name: Ident,
    pub variant_type: EnumVariantType,
    pub return_type: Type,
    pub fields: Vec<(Option<Ident>, Type)>,
}

impl EnumVariant {
    pub fn new(
        variant: &Variant,
        enum_name: Ident,
        args: &EnumHandlerArgs,
    ) -> Result<Self> {
        let name = variant
            .ident
            .clone();
        let fields = variant
            .fields
            .iter()
            .map(|field| {
                let name = field
                    .ident
                    .clone();
                let ty = field
                    .ty
                    .clone();
                (name, ty)
            })
            .collect();
        let return_type = args.get_return_type()?;
        let variant_type = match variant.fields {
            Fields::Unit => EnumVariantType::Unit,
            Fields::Named(_) => EnumVariantType::Struct,
            Fields::Unnamed(_) => EnumVariantType::Tuple,
        };
        Ok(EnumVariant {
            enum_name,
            name,
            variant_type,
            return_type,
            fields,
        })
    }

    pub fn get_variant_handler_name(
        &self,
        args: &EnumHandlerArgs,
    ) -> Ident {
        format_ident!(
            "{}_{}",
            args.get_handler_name(),
            self.name
                .to_string()
                .to_snake_case()
        )
    }

    pub fn parameter_name(
        &self,
        field_name: &Option<Ident>,
        index: usize,
    ) -> Ident {
        if let Some(name) = field_name {
            return name.clone();
        }

        if self.is_single_field() {
            format_ident!("arg")
        } else {
            format_ident!("arg{}", index)
        }
    }

    fn is_single_field(&self) -> bool {
        self.fields
            .len()
            == 1
    }
}