sapiens_derive 0.2.1

The macro - a simple bot to conquer the world
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

use darling::FromDeriveInput;
use proc_macro::TokenStream;
use quote::{quote, ToTokens};

/// A derive macro for the `ProtoToolDescribe` trait.
#[derive(Debug, FromDeriveInput)]
#[darling(attributes(tool), supports(struct_named), forward_attrs(doc))]
struct DeriveReceiver {
    ident: syn::Ident,
    attrs: Vec<syn::Attribute>,
    generics: syn::Generics,

    name: Option<String>,

    input: syn::Path,
    output: syn::Path,
}

impl ToTokens for DeriveReceiver {
    fn to_tokens(&self, out: &mut proc_macro2::TokenStream) {
        let DeriveReceiver {
            ref ident,
            ref attrs,
            ref generics,
            ref name,
            ref input,
            ref output,
            ..
        } = *self;

        let (imp, ty, wher) = generics.split_for_impl();

        let doc = attrs
            .iter()
            .filter(|attr| attr.path.is_ident("doc"))
            .map(|attr| attr.parse_meta().unwrap())
            .map(|meta| match meta {
                syn::Meta::NameValue(syn::MetaNameValue {
                    lit: syn::Lit::Str(lit_str),
                    ..
                }) => lit_str.value(),
                _ => panic!("Expected doc attribute to be a string"),
            })
            .fold(String::new(), |mut acc, s| {
                if !acc.is_empty() {
                    acc.push('\n');
                }
                acc.push_str(s.trim());
                acc
            });

        let doc = if doc.is_empty() {
            panic!("Expected struct to have a doc string")
        } else {
            doc
        };

        let name = if let Some(name) = name {
            name.clone()
        } else {
            ident.to_string()
        };

        // dbg!(input);

        // dbg!(output);

        let input_ty = &input.segments.last().unwrap().ident;
        let output_ty = &output.segments.last().unwrap().ident;

        // dbg!(fields);
        out.extend(quote! {
            impl #imp ProtoToolDescribe for #ident #ty #wher {
                fn description(&self) -> ToolDescription {
                    ToolDescription {
                        name: #name.to_string(),
                        description: #doc.to_string(),
                        description_context: "Use this when it is the best tool for the job.".to_string(), 
                        input_format: #input_ty::describe(),
                        output_format: #output_ty::describe(),
                    }
                }
            }
        })
    }
}

/// The entry point for the `ProtoToolDescribe` derive macro expansion.
pub fn expand_derive(input: &syn::DeriveInput) -> TokenStream {
    let receiver = match DeriveReceiver::from_derive_input(input) {
        Ok(parsed) => parsed,
        Err(e) => return e.write_errors().into(),
    };

    let tokens = quote! { #receiver };
    tokens.into()
}