oe 0.0.2

OE is a macro to make errors easy and expressive
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

use syn::Path;
use proc_macro2::{Ident, Span};
use quote::{ToTokens, TokenStreamExt};
use inflector::cases::classcase::to_class_case;

pub struct Variant{
    variant_name: String,
    error_type: Path
}

impl From<Path> for Variant{
    fn from(path: Path) -> Self {
        Variant{
            variant_name: recapitalize_error_path(&path),
            error_type: path
        }
    }
}

impl Variant{
    pub fn build_from_impl(&self, enum_name: &Ident, tokens: &mut proc_macro2::TokenStream){
        let name = Ident::new(&self.variant_name, Span::call_site());
        let error_type = &self.error_type;
        tokens.append_all(quote! {
            impl ::std::convert::From<#error_type> for #enum_name{
                fn from(error: #error_type) -> Self{
                    Self::#name(error)
                }
            }
        });
    }
}

impl ToTokens for Variant{
    fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
        let name = Ident::new(&self.variant_name, Span::call_site());
        let error_type = &self.error_type;
        tokens.append_all(quote! {
            #name(#error_type)
        });
    }
}

fn recapitalize_error_path(path: &Path) -> String{
    let mut words = Vec::new();
    for segment in &path.segments{
        let name_string = segment.ident.to_string();
        for word in name_string.split("_"){
            words.push(String::from(word));
        }
    }

    let mut name = String::new();
    for word in words{
        name.push_str(&to_class_case(&word));
    }

    name
}