fusen-macro 0.6.3

RPC framework for service registration and discovery through API exposure, compatible with Dubbo3 protocol, intertunable with Java projects
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

use fusen_common::fusen_attr;
use proc_macro::TokenStream;
use quote::{quote, ToTokens};
use syn::{parse::Parser, parse_macro_input, Attribute, DeriveInput, Meta};

mod data;
mod handler_macro;
mod server_macro;
mod trait_macro;

#[proc_macro_attribute]
pub fn handler(attr: TokenStream, item: TokenStream) -> TokenStream {
    let attr = HandlerAttr::from_attr(attr);
    match attr {
        Ok(attr) => handler_macro::fusen_handler(attr, item),
        Err(err) => err.into_compile_error().into(),
    }
}

#[proc_macro_attribute]
pub fn fusen_trait(attr: TokenStream, item: TokenStream) -> TokenStream {
    let attr = FusenAttr::from_attr(attr);
    match attr {
        Ok(attr) => trait_macro::fusen_trait(attr, item),
        Err(err) => err.into_compile_error().into(),
    }
}

#[proc_macro_derive(Data)]
pub fn data(item: TokenStream) -> TokenStream {
    data::data(item)
}

#[proc_macro_attribute]
pub fn fusen_server(attr: TokenStream, item: TokenStream) -> TokenStream {
    let attr = FusenAttr::from_attr(attr);
    match attr {
        Ok(attr) => server_macro::fusen_server(attr, item),
        Err(err) => err.into_compile_error().into(),
    }
}

#[proc_macro_attribute]
pub fn asset(_attr: TokenStream, item: TokenStream) -> TokenStream {
    item
}

#[proc_macro_attribute]
pub fn url_config(attr: TokenStream, item: TokenStream) -> TokenStream {
    let attr = UrlConfigAttr::from_attr(attr);
    if let Err(err) = attr {
        return err.into_compile_error().into();
    }
    let attr = attr.unwrap();
    let attr = attr.attr;
    let org_item = parse_macro_input!(item as DeriveInput);
    let Some(attr) = attr else {
        return syn::Error::new_spanned(
            org_item.to_token_stream(),
            "url_config must label to attr",
        )
        .into_compile_error()
        .into();
    };
    let id = &org_item.ident;
    let token = quote! {

        #[derive(serde::Serialize, serde::Deserialize, Default, fusen_macro::Data)]
        #org_item

        impl #id {
            pub fn from_url(url : &str) -> Result<Self,fusen_common::Error> {
                let info : Vec<&str> = url.split("://").collect();
                if info[0] != #attr {
                   return Err(format!("err1 url {}",url).into());
                }
                let info : Vec<&str> = info[1].split("?").collect();
                if info[0] != stringify!(#id) {
                    return Err(format!("err2 url {}",url).into());
                }
                fusen_common::url::from_url(info[1])
            }
            pub fn to_url(&self) -> Result<String, fusen_common::Error> {
                let mut res = String::new();
                res.push_str(&(#attr.to_owned() + "://" + stringify!(#id) + "?" ));
                res.push_str(&(fusen_common::url::to_url(self)?));
                Ok(res)
            }
        }
    };
    token.into()
}

fn get_asset_by_attrs(attrs: &Vec<Attribute>) -> Result<ResourceAttr, syn::Error> {
    for attr in attrs {
        if let Meta::List(list) = &attr.meta {
            if let Some(segment) = list.path.segments.first() {
                if segment.ident == "asset" {
                    return ResourceAttr::from_attr(list.tokens.clone().into());
                }
            }
        }
    }
    Ok(ResourceAttr::default())
}

fusen_attr! {
    ResourceAttr,
    path,
    method
}

fusen_attr! {
    UrlConfigAttr,
    attr
}

fusen_attr! {
    FusenAttr,
    id,
    version,
    group
}

fusen_attr! {
    HandlerAttr,
    id
}