act-zero-ext 0.2.0

use proc_macro::TokenStream;
use quote::{format_ident, quote};
use syn::{ItemFn, ReturnType, parse_macro_input};

/// Converts a function that returns a `Result<T,E>` into an a function that returns a `ActorResult<Result<T, E>>`
/// Also works with Option<T> will return `ActorResult<Option<T>>`
///
/// Example:
///
/// ```rust
/// use act_zero::*;
/// pub struct App {}
///
/// impl App {
///     #[act_zero_ext::into_actor_result]
///     async fn hello(&self, name: String) -> Result<String, Box<dyn std::error::Error>> {
///         Ok(format!("Hello, {}!", name))
///     }
/// }
/// ```
///
/// Will be converted to:
///
/// ```rust
/// use act_zero::*;
/// pub struct App {}
///
/// impl App {
///     pub async fn hello(&self, name: String) -> ActorResult<Result<String, Box<dyn std::error::Error>>> {
///         let result = self.do_hello(name).await;
///         Produces::ok(result)
///     }
///
///     async fn do_hello(&self, name: String) -> Result<String, Box<dyn std::error::Error>> {
///         Ok(format!("Hello, {}!", name))
///     }
/// }
/// ```
///
/// Example with Option:
///
/// ```rust
/// use act_zero::*;
/// pub struct App {}
///
/// impl App {
///     #[act_zero_ext::into_actor_result]
///     async fn find_user(&self, id: u64) -> Option<String> {
///         if id > 0 {
///             Some(format!("User {}", id))
///         } else {
///             None
///         }
///     }
/// }
/// ```
///
/// Will be converted to:
///
/// ```rust
/// use act_zero::*;
/// pub struct App {}
///
/// impl App {
///     pub async fn find_user(&self, id: u64) -> ActorResult<Option<String>> {
///         let result = self.do_find_user(id).await;
///         Produces::ok(result)
///     }
///
///     async fn do_find_user(&self, id: u64) -> Option<String> {
///         if id > 0 {
///             Some(format!("User {}", id))
///         } else {
///             None
///         }
///     }
/// }
/// ```
#[proc_macro_attribute]
pub fn into_actor_result(_attr: TokenStream, item: TokenStream) -> TokenStream {
    // Parse the function
    let input_fn = parse_macro_input!(item as ItemFn);

    // clone for the do_ version
    let mut do_fn = input_fn.clone();

    // change the function name to do_
    let fn_name = &input_fn.sig.ident;
    let do_fn_name = format_ident!("do_{}", fn_name);
    do_fn.sig.ident = do_fn_name.clone();

    // make the do_ function private
    do_fn.vis = syn::Visibility::Inherited;

    // extract information for the wrapper function
    let vis = &input_fn.vis;
    let asyncness = &input_fn.sig.asyncness;
    let generics = &input_fn.sig.generics;
    let inputs = &input_fn.sig.inputs;

    // extract return type for ActorResult wrapper
    let return_type = match &input_fn.sig.output {
        ReturnType::Default => quote! { () },
        ReturnType::Type(_, ty) => quote! { #ty },
    };

    // get argument names for passing to do_ function
    let arg_names = inputs
        .iter()
        .filter_map(|arg| {
            if let syn::FnArg::Typed(pat_type) = arg
                && let syn::Pat::Ident(pat_ident) = &*pat_type.pat
                && pat_ident.ident != "self"
            {
                return Some(&pat_ident.ident);
            }
            None
        })
        .collect::<Vec<_>>();

    let awaiter = asyncness.is_some().then(|| quote!(.await));

    let wrapper_fn = quote! {
        #vis async fn #fn_name #generics (#inputs) -> act_zero::ActorResult<#return_type> {
            let result = self.#do_fn_name(#(#arg_names),*) #awaiter;
            act_zero::Produces::ok(result)
        }
    };

    // generate the final code
    let result = quote! {
        #wrapper_fn
        #do_fn
    };

    result.into()
}