mutable_derive 0.3.3

Implementation for derive for Mutable and Softeq
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

use proc_macro::{TokenStream, Span};
use proc_macro_error::abort;
use quote::ToTokens;
use syn::{Item, Meta, NestedMeta};

pub(crate) fn try_(item: TokenStream) -> Result<TokenStream, ()> {
    let item = syn::parse::<Item>(item).map_err(|_| abort!(Span::call_site(), "Could not parse item"))?;

    let struct_ = match item {
        Item::Struct(struct_) => struct_,
        _ => abort!(item, "Observable may only be derived on structures"),
    };

    let (uid_types, uid_names): (Vec<String>, Vec<String>) = struct_.fields.iter()
        .filter(|field| if let Some(meta) = field.attrs.iter().find(|a| a.path.is_ident("softeq")) {
            if let Ok(Meta::List(list)) = meta.parse_meta() {
                list.nested.iter().any(|m| {
                    if let NestedMeta::Meta(Meta::Path(p)) = m {
                        p.is_ident("uid")
                    } else {
                        false
                    }
                })
            } else {
                false
            }
        } else {
            false
        })
        .map(|field| (field.ty.to_token_stream().to_string(), field.ident.as_ref().unwrap().to_string()))
        .unzip();

    if uid_types.is_empty() {
        abort!(struct_, "SoftEq requires at least one unique identifier");
    }

    Ok(format!(r#"
            impl SoftEq for {}{{
                type Uid = ({});
                fn uid(&self) -> Self::Uid{{
                    ({})
                }}
            }}
            "#,
               struct_.ident,
               uid_types.join(", "),
               uid_names.iter().map(|n| format!("self.{n}.clone()")).collect::<Vec<String>>().join(", ")
    ).parse().unwrap())
}