Merge pull request #2 from photovoltex/cleanup-macro

Split macros for readability

Author: photovoltex

Cargo.toml

@@ -50,5 +50,5 @@ tauri = "1.5.2"
 default = [ "event" ]
 event   = [ "tauri-interop-macro/event" ]
 leptos  = [ "dep:leptos", "tauri-interop-macro/leptos" ]
-# used to generated the missing documentation only generated for "target_family = wasm"
+# used to generate the missing documentation, otherwise it's only generated for "target_family = wasm"
 wasm    = []

README.md

@@ -5,9 +5,9 @@
 ![License](https://img.shields.io/crates/l/tauri-interop.svg)
 
 What this crate tries to achieve:
-- generate a equal wasm-function from your defined `tauri::command`
-- collect all defined `tauri::command`s without adding them manually
-- a simplified way to sending events from tauri and receiving them in the frontend
+- generate a equal wasm-function for your defined `tauri::command`
+- collecting all defined `tauri::command`s without adding them manually
+- a way to sending events from tauri and receiving them in the frontend
 
 
 ## Basic usage:
@@ -41,8 +41,8 @@ Using `tauri_interop::command` does two things:
 - it provides the command with two macros which are used depending on the `target_family`
   - `tauri_interop::binding` is used when compiling to `wasm`
   - `tauri::command` is used otherwise
-- it adds an entry to `tauri_interop::collect_commands!()` so that the generated 
-  `get_commands()` function includes/registers the given commands for the tauri context
+- it adds an entry to `tauri_interop::collect_commands!()` so that the generated `get_handlers()` function includes the given commands for the tauri context
+  - the function is not generated when targeting `wasm`
 
 The defined command above can then be used in wasm as below. Due to receiving data from 
 tauri via a promise, the command response has to be awaited.
@@ -64,13 +64,13 @@ fn main() {
 
 #### Command representation Host/Wasm
 
-- technically all commands need to be of type `Result<T, E>`
-  - where E is a error that the command isn't defined, if not explicitly redefined via the return type
-  - this error will show up in the web console, so there shouldn't be a problem ignoring it
+- the returned type of the wasm binding should be 1:1 the same type as send from the "backend" 
+  - technically all commands need to be of type `Result<T, E>` because there is always the possibility of a command getting called, that isn't registered in the context of tauri
+    - when using `tauri_interop::collect_commands!()` this possibility is near fully removed
+    - for convenience, we ignore that possibility, and even if the error occurs it will be logged into the console
 - all arguments with type "State", "AppHandle" and "Window" are removed automatically
 > the current implementation relies on the name of the type and can not separate between a 
 > tauri::State and a self defined "State" struct
-- asynchronous commands are values as is seen [async-commands](https://tauri.app/v1/guides/features/command#async-commands) for a detail explanation
 
 ```rust , ignore-wasm32-unknown-unknown
 // let _: () = trigger_something();
@@ -95,7 +95,7 @@ async fn asynchronous_execution(change: bool) -> Result<String, String> {
     }
 }
 
-// let _wait_for_completion: () = asynchronous_execution(true).await;
+// let _wait_for_completion: () = heavy_computation().await;
 #[tauri_interop::command]
 async fn heavy_computation() {
   std::thread::sleep(std::time::Duration::from_millis(5000))
@@ -117,10 +117,9 @@ pub struct Test {
 fn main() {}
 ```
 
-Using `tauri_interop::emit_or_listen` does provides the command with two macros,
-which are used depending on the `target_family`
-  - `tauri_interop::listen_to` is used when compiling to `wasm`
-  - derive trait `tauri_interop::Emit` is used otherwise
+When using the derive macro `tauri_interop::Event` it expands depending on the `target_family` to
+  - derive trait `tauri_interop::Listen` (when compiling to `wasm`)
+  - derive trait `tauri_interop::Emit` (otherwise)
 
 To emit a variable from the above struct (which is mostly intended to be used as state) in the host triplet
 ```rust , ignore-wasm32-unknown-unknown
@@ -162,7 +161,9 @@ fn main() {
 
 the above emitted value can then be received in wasm as:
 ```rust , ignore
-#[tauri_interop::emit_or_listen]
+use tauri_interop::Event;
+
+#[derive(Default, Event)]
 pub struct Test {
     foo: String,
     pub bar: bool,
@@ -175,17 +176,19 @@ async fn main() {
 }
 ```
 
-The `liste_handle` contains the provided closure and the "unlisten" method. It has to be hold in scope as long 
+The `ListenHandle` contains the provided closure and the "unlisten" method. It has to be hold in scope as long 
 as the event should be received. Dropping it will automatically detach the closure from the event. See 
 [cmd.rs](./test-project/api/src/cmd.rs) for other example how it could be used.
 
 #### Feature: leptos
 When the `leptos` feature is enabled it will add additional `use_<field>` methods on the provided struct.
-These methods take care of the required initial asynchron call to register the listener and will hold the
+These methods take care of the required initial asynchronous call to register the listener and will hold the
 handle in scope as long as the component is rendered.
 
 ```rust , ignore
-#[tauri_interop::emit_or_listen]
+use tauri_interop::Event;
+
+#[derive(Default, Event)]
 pub struct Test {
     foo: String,
     pub bar: bool,

src/event.rs

@@ -1,6 +1,6 @@
-use serde::{Serialize, Deserialize};
+use serde::{Deserialize, Serialize};
 #[cfg(not(target_family = "wasm"))]
-use tauri::{AppHandle, Wry, Error};
+use tauri::{AppHandle, Error, Wry};
 
 /// traits for event emitting in the host code (feat: `tauri`)
 #[cfg(not(target_family = "wasm"))]
@@ -44,7 +44,7 @@ where
 
     #[cfg(not(target_family = "wasm"))]
     /// Updates the related field and emit its event
-    /// 
+    ///
     /// Only required for "target_family = wasm"
     fn update(s: &mut P, handle: &AppHandle<Wry>, v: Self::Type) -> Result<(), Error>;
 }

src/event/listen.rs

@@ -115,7 +115,6 @@ impl<'s> ListenHandle<'s> {
     }
 }
 
-
 /// Trait that defines the available listen methods
 pub trait Listen {
     /// Registers an callback to a [Field]
@@ -134,9 +133,7 @@ pub trait Listen {
     ///
     /// Default Implementation: see [ListenHandle::use_register]
     #[cfg(feature = "leptos")]
-    fn use_field<F: Field<Self>>(
-        initial: F::Type,
-    ) -> (ReadSignal<F::Type>, WriteSignal<F::Type>)
+    fn use_field<F: Field<Self>>(initial: F::Type) -> (ReadSignal<F::Type>, WriteSignal<F::Type>)
     where
         Self: Sized + super::Parent,
     {

src/lib.rs

@@ -1,6 +1,5 @@
 #![warn(missing_docs)]
 #![doc = include_str!("../README.md")]
-
 #![feature(trait_alias)]
 
 /// wasm bindings for tauri's provided js functions (target: `wasm` or feat: `wasm`)

tauri-interop-macro/src/command.rs

@@ -0,0 +1,59 @@
+use crate::command::wrapper::{InvokeArgument, InvokeCommand};
+use proc_macro::TokenStream;
+use proc_macro2::Ident;
+use quote::{format_ident, quote, ToTokens};
+use syn::punctuated::Punctuated;
+use syn::token::Comma;
+use syn::{parse_macro_input, FnArg, ItemFn};
+
+mod wrapper;
+
+pub fn convert_to_binding(stream: TokenStream) -> TokenStream {
+    let item_fn = parse_macro_input!(stream as ItemFn);
+    let InvokeCommand {
+        attributes,
+        name,
+        generics,
+        return_type,
+        invoke,
+        invoke_argument,
+    } = wrapper::prepare(item_fn);
+
+    let InvokeArgument {
+        argument_name,
+        fields,
+    } = invoke_argument;
+
+    let async_ident = invoke.as_async();
+    let field_usage = fields
+        .iter()
+        .map(|field| field.ident.clone())
+        .collect::<Punctuated<Ident, Comma>>();
+    let field_definitions = fields
+        .into_iter()
+        .map(|field| field.argument)
+        .collect::<Punctuated<FnArg, Comma>>();
+
+    let command_name = name.to_string();
+    let args_ident = format_ident!("args");
+    let invoke_binding = invoke.as_expr(command_name, &args_ident);
+
+    let stream = quote! {
+        #[derive(::serde::Serialize, ::serde::Deserialize)]
+        struct #argument_name #generics {
+            #field_definitions
+        }
+
+        #( #attributes )*
+        pub #async_ident fn #name #generics (#field_definitions) #return_type
+        {
+            let #args_ident = #argument_name { #field_usage };
+            let #args_ident = ::serde_wasm_bindgen::to_value(&#args_ident)
+                .expect("serialized arguments");
+
+            #invoke_binding
+        }
+    };
+
+    TokenStream::from(stream.to_token_stream())
+}

tauri-interop-macro/src/command/wrapper.rs

@@ -0,0 +1,164 @@
+use convert_case::{Case, Casing};
+use proc_macro::Span;
+use proc_macro2::Ident;
+use quote::{format_ident, ToTokens};
+use syn::{
+    parse_quote, Attribute, Expr, ExprPath, FnArg, GenericParam, Generics, ItemFn, Lifetime,
+    LifetimeParam, Pat, PathSegment, ReturnType, Signature, Type, TypePath,
+};
+
+#[derive(PartialEq)]
+pub enum Invoke {
+    Empty,
+    AsyncEmpty,
+    Async,
+    AsyncResult,
+}
+
+impl Invoke {
+    pub fn as_async(&self) -> Option<Ident> {
+        self.ne(&Invoke::Empty).then_some(format_ident!("async"))
+    }
+
+    pub fn as_expr(&self, cmd_name: String, arg_name: &Ident) -> Expr {
+        let expr: ExprPath = match self {
+            Invoke::Empty => parse_quote!(bindings::invoke),
+            Invoke::Async | Invoke::AsyncEmpty => parse_quote!(command::async_invoke),
+            Invoke::AsyncResult => parse_quote!(command::invoke_catch),
+        };
+
+        let call = parse_quote!( ::tauri_interop::#expr(#cmd_name, #arg_name) );
+
+        if self.as_async().is_some() {
+            Expr::Await(parse_quote!(#call.await))
+        } else {
+            Expr::Call(call)
+        }
+    }
+}
+
+fn is_result(segment: &PathSegment) -> bool {
+    segment.ident.to_string().as_str() == "Result"
+}
+
+fn determine_invoke(return_type: &ReturnType, is_async: bool) -> Invoke {
+    match return_type {
+        ReturnType::Default => {
+            if is_async {
+                Invoke::AsyncEmpty
+            } else {
+                Invoke::Empty
+            }
+        }
+        ReturnType::Type(_, ty) => match ty.as_ref() {
+            // fixme: if it's an single ident, catch isn't needed this could probably be a problem later
+            Type::Path(path) if path.path.segments.iter().any(is_result) => Invoke::AsyncResult,
+            Type::Path(_) => Invoke::Async,
+            others => panic!("no support for '{}'", others.to_token_stream()),
+        },
+    }
+}
+
+const ARGUMENT_LIFETIME: &str = "'arg_lifetime";
+
+fn new_arg_lt() -> Lifetime {
+    Lifetime::new(ARGUMENT_LIFETIME, Span::call_site().into())
+}
+
+const TAURI_TYPES: [&str; 3] = ["State", "AppHandle", "Window"];
+
+fn any_tauri(ty_path: &TypePath) -> bool {
+    ty_path
+        .path
+        .segments
+        .iter()
+        .any(|segment| TAURI_TYPES.contains(&segment.ident.to_string().as_str()))
+}
+
+pub struct InvokeCommand {
+    pub attributes: Vec<Attribute>,
+    pub name: Ident,
+    pub generics: Generics,
+    pub return_type: ReturnType,
+    pub invoke: Invoke,
+    pub invoke_argument: InvokeArgument,
+}
+
+pub struct InvokeArgument {
+    pub argument_name: Ident,
+    pub fields: Vec<FieldArg>,
+}
+
+pub struct FieldArg {
+    pub ident: Ident,
+    pub argument: FnArg,
+    requires_lifetime: bool,
+}
+
+pub fn prepare(function: ItemFn) -> InvokeCommand {
+    let ItemFn {
+        attrs: attributes,
+        sig,
+        ..
+    } = function;
+
+    let Signature {
+        ident: name,
+        mut generics,
+        inputs,
+        output: return_type,
+        asyncness,
+        ..
+    } = sig;
+
+    let filtered_fields = inputs
+        .into_iter()
+        .filter_map(|mut fn_arg| {
+            let typed = match fn_arg {
+                FnArg::Typed(ref mut typed) => typed,
+                _ => return None,
+            };
+
+            if matches!(typed.ty.as_ref(), Type::Path(ty_path) if any_tauri(ty_path)) {
+                return None;
+            }
+
+            let req_lf = if let Type::Reference(ty_ref) = typed.ty.as_mut() {
+                ty_ref.lifetime = Some(new_arg_lt());
+                true
+            } else {
+                false
+            };
+
+            match typed.pat.as_ref() {
+                Pat::Ident(ident) => Some(FieldArg {
+                    ident: ident.ident.clone(),
+                    argument: fn_arg,
+                    requires_lifetime: req_lf,
+                }),
+                _ => None,
+            }
+        })
+        .collect::<Vec<_>>();
+
+    if filtered_fields.iter().any(|field| field.requires_lifetime) {
+        generics
+            .params
+            .push(GenericParam::Lifetime(LifetimeParam::new(new_arg_lt())))
+    }
+
+    let invoke = determine_invoke(&return_type, asyncness.is_some());
+    let argument_name = format_ident!("{}Args", name.to_string().to_case(Case::Pascal));
+
+    InvokeCommand {
+        attributes,
+        name,
+        generics,
+        return_type,
+        invoke,
+        invoke_argument: InvokeArgument {
+            argument_name,
+            fields: filtered_fields,
+        },
+    }
+}