enum-extract-macro 0.1.1

A derive macro for extracting enum variants into their own types.
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
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

use heck::ToSnakeCase;
use proc_macro2::{Ident, Span};
use quote::ToTokens;

static DOCS_ERROR_TYPE: &'static str = "enum_extract_error::EnumExtractError";

pub struct FunctionDef {
    pub declaration: syn::Ident,
    pub docs: String,
}

impl ToTokens for FunctionDef {
    fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
        self.declaration.to_tokens(tokens)
    }
}

impl FunctionDef {
    pub fn new_is_variant(enum_name: &Ident, variant_name: &Ident) -> Self {
        FunctionDef {
            docs: format!(
                "Returns true if this is a `{}::{}`, otherwise false",
                enum_name, variant_name,
            ),
            declaration: Ident::new(
                &format!("is_{}", variant_name).to_snake_case(),
                Span::call_site(),
            ),
        }
    }

    pub fn new_as_variant(enum_name: &Ident, variant_name: &Ident) -> Self {
        FunctionDef {
            docs: format!(
                "Returns references to the inner fields if this is a `{}::{}`, otherwise an [`{}`]",
                enum_name, variant_name, DOCS_ERROR_TYPE,
            ),
            declaration: Ident::new(
                &format!("as_{}", variant_name).to_snake_case(),
                Span::call_site(),
            ),
        }
    }

    pub fn new_extract_as_variant(enum_name: &Ident, variant_name: &Ident) -> Self {
        let alt_fn = Self::new_as_variant(enum_name, variant_name);

        FunctionDef {
            docs: format!(
                r#"
                Returns references to the inner fields if this is a `{enum_name}::{variant}`, otherwise panics.
    
                # Panics
    
                Panics when the value is not a `{enum_name}::{variant}`.
                Prefer using a `match` or [`{enum_name}::{alt_fn}`]; only use this if you *know* this is a `{enum_name}::{variant}`,
                or if panicking is ok, such as during testing.
                "#,
                enum_name = enum_name,
                variant = variant_name,
                alt_fn = alt_fn.declaration,
            ),
            declaration: Ident::new(
                &format!("extract_as_{}", variant_name).to_snake_case(),
                Span::call_site(),
            ),
        }
    }

    pub fn new_as_variant_mut(enum_name: &Ident, variant_name: &Ident) -> Self {
        FunctionDef {
            docs: format!(
                "Returns mutable references to the inner fields if this is a `{}::{}`, otherwise an [`{}`].",
                enum_name,
                variant_name,
                DOCS_ERROR_TYPE,
            ),
            declaration: Ident::new(
                &format!("as_{}_mut", variant_name).to_snake_case(),
                Span::call_site(),
            )
        }
    }

    pub fn new_extract_as_variant_mut(enum_name: &Ident, variant_name: &Ident) -> Self {
        let alt_fn = Self::new_as_variant_mut(enum_name, variant_name);

        FunctionDef {
            docs: format!(
                r#"
                Returns mutable references to the inner fields if this is a `{enum_name}::{variant}`, otherwise panics.
    
                # Panics
    
                Panics when the value is not a `{enum_name}::{variant}`.
                Prefer using a `match` or [`{enum_name}::{alt_fn}`]; only use this if you *know* this is a `{enum_name}::{variant}`,
                or if panicking is ok, such as during testing.
                "#,
                enum_name = enum_name,
                variant = variant_name,
                alt_fn = alt_fn.declaration,
            ),
            declaration: Ident::new(
                &format!("extract_as_{}_mut", variant_name).to_snake_case(),
                Span::call_site(),
            ),
        }
    }

    pub fn new_into_variant(enum_name: &Ident, variant_name: &Ident) -> Self {
        FunctionDef {
            docs: format!(
                "Returns the inner fields if this is a `{}::{}`, otherwise otherwise an [`{}`].",
                enum_name, variant_name, DOCS_ERROR_TYPE,
            ),
            declaration: Ident::new(
                &format!("into_{}", variant_name).to_snake_case(),
                Span::call_site(),
            ),
        }
    }

    pub fn new_extract_into_variant(enum_name: &Ident, variant_name: &Ident) -> Self {
        let alt_fn = Self::new_into_variant(enum_name, variant_name);

        FunctionDef {
            docs: format!(
                r#"
                Returns the inner fields if this is a `{enum_name}::{variant}`, otherwise panics.
                
                # Panics
    
                Panics when the value is not a `{enum_name}::{variant}`.
                Prefer using a `match` or [`{enum_name}::{alt_fn}`]; only use this if you *know* this is a `{enum_name}::{variant}`,
                or if panicking is ok, such as during testing.
                "#,
                enum_name = enum_name,
                variant = variant_name,
                alt_fn = alt_fn.declaration,
            ),
            declaration: Ident::new(
                &format!("extract_into_{}", variant_name).to_snake_case(),
                Span::call_site(),
            ),
        }
    }
}