from-num 1.1.1

Attribute macro #[from_num(...)]
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

//! Attribute macro,implementing the From trait for your Enum.
//! 
//! ```rust
//! use from_num::from_num;
//! #[derive(Debug,PartialEq)]
//! #[from_num(i8,u64,usize)]
//! enum Planet {
//!     Mercury,
//!     Venus,
//!     Earth,
//!     Mars,
//!     Jupiter = 0b1000,
//!     Saturn,
//!     Uranus = 0xff,
//!     Neptune
//! }
//! pub fn get_from_number() {
//!     assert_eq!(Planet::Jupiter,Planet::from_i8(0b1000 as i8).unwrap());
//!     assert_eq!(Planet::Neptune,Planet::from_u64(256 as u64).unwrap());
//! }
//! ```

use proc_macro::{TokenStream, TokenTree};
use proc_macro2::Ident;
use quote::ToTokens;
use syn::{parse_macro_input, Data, DeriveInput};
extern crate proc_macro;

/// Implements the From trait for your Enum.
///
/// # Examples
/// 
/// ```rust
/// use from_num::from_num;
/// #[derive(Debug,PartialEq)]
/// #[from_num(i8,u64,usize)]
/// enum Planet {
///     Mercury,
///     Venus,
///     Earth,
///     Mars,
///     Jupiter = 0b1000,
///     Saturn,
///     Uranus = 0xff,
///     Neptune
/// }
/// pub fn get_from_number() {
///     assert_eq!(Planet::Jupiter,Planet::from_i8(0b1000 as i8).unwrap());
///     assert_eq!(Planet::Neptune,Planet::from_u64(256 as u64).unwrap());
/// }
/// ```
#[proc_macro_attribute]
pub fn from_num(attrs: TokenStream, item: TokenStream) -> TokenStream {
    let attrs = attrs
        .into_iter()
        .filter(|v| match v {
            TokenTree::Ident(_) => true,
            _ => false,
        })
        .collect::<Vec<_>>();
    let mut item_c = item.clone();
    let input = parse_macro_input!(item as DeriveInput);
    match input.data {
        Data::Enum(data) => {
            let mut arms = format!("");
            let mut count = 0;
            for var in data.variants.iter() {
                if let Some((_, expr)) = var.discriminant.clone() {
                    count = parse_with_prefix(&expr.into_token_stream().to_string());
                };
                arms += &format! {
                    "{} => Ok(Self::{}),",
                    count,
                    var.ident.to_string()
                };
                count += 1;
            }
            let code = num_traits(&input.ident, &arms, &attrs);
            item_c.extend(code.parse::<TokenStream>().unwrap());
            item_c
        }
        _ => unimplemented!(),
    }
}

fn num_traits(name: &Ident, arms: &str, nums: &[TokenTree]) -> String {
    let mut code = String::new();
    for token in nums.iter() {
        code += &format! {
            r#"impl {0} {{ pub fn from_{2}(value:{2}) -> anyhow::Result<Self> {{ match value {{ {1}_ => Err(anyhow::anyhow!("[enum {0}] Failed convertion from {{}}",value)) }} }} }}"#,
            name,
            arms,
            token.to_string(),
        };
    }
    code
}

fn parse_with_prefix(s: &str) -> usize {
    let radix = match s {
        s if s.starts_with("0b") => 2,
        s if s.starts_with("0o") => 8,
        s if s.starts_with("0x") => 16,
        _ => {
            return usize::from_str_radix(s, 10).unwrap();
        }
    };
    usize::from_str_radix(&s[2..], radix).unwrap()
}