afmt 0.1.1

Basic data structure parsing from strings
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

//! This crate provides the `fmt` attribute macro, its usage is simple:
//!
//! ```
//! #[macro_use] extern crate afmt;
//!
//! #[fmt("value: " v)]
//! struct Foo {
//!     v: u32,   
//! }
//!
//! fn main() -> Result<(), Box<dyn std::error::Error>> {
//!     let f: Foo = "value: 65".parse()?;
//!     assert_eq!(f.v, 65);
//!
//!     let f: Result<Foo,_> = "val: 65".parse();
//!     assert!(f.is_err());
//!     Ok(())
//! }
//! ```

extern crate devise;
extern crate proc_macro;
use ::devise::quote::quote;
use ::devise::syn;
use ::proc_macro::TokenStream;

mod parse;
mod codegen;

#[proc_macro_attribute]
pub fn fmt(attr: TokenStream, item: TokenStream) -> TokenStream {
    let input = syn::parse_macro_input!(item as syn::ItemStruct);
    let fmt = syn::parse_macro_input!(attr as parse::Fmt);

    /* gather everything we need */
    let s = &input;
    let s_ident = &input.ident;
    let s_build = codegen::struct_builder(s);
    let s_parse = codegen::codegen(fmt);

    let code = quote! {
        #s

        impl ::std::str::FromStr for #s_ident {
            type Err = String;
            fn from_str(s: &str) -> Result<#s_ident, String> {
                #s_parse

                Ok(#s_build)
            }
        }
    };

    code.into()
}