tauri-interop-macro 2.2.0

Macros for the tauri-interop crate.
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

use std::collections::HashSet;

use proc_macro2::{Ident, TokenStream};
use quote::{format_ident, quote};
use syn::parse::Parser;
use syn::punctuated::Punctuated;
use syn::token::Comma;
use syn::{parse_quote, ExprPath, ItemUse, Token};

pub fn commands_with_mod_name(mod_name: &str, commands: &HashSet<String>) -> HashSet<String> {
    commands
        .iter()
        .map(|cmd| format!("{mod_name}::{cmd}"))
        .collect()
}

pub fn commands_to_punctuated(commands: &HashSet<String>) -> Punctuated<ExprPath, Comma> {
    commands.iter().map(command_to_expr_path).collect()
}

pub fn command_to_expr_path(command: &String) -> ExprPath {
    match get_separated_command(command) {
        None => {
            let ident = format_ident!("{command}");
            parse_quote!(#ident)
        }
        Some((mod_name, cmd_name)) => parse_quote!(#mod_name::#cmd_name),
    }
}

pub fn get_separated_command(input: &str) -> Option<(Ident, Ident)> {
    let mut split_cmd = input.split("::");
    let mod_name = format_ident!("{}", split_cmd.next()?);
    // order matters
    let cmd_name = format_ident!("{}", split_cmd.next()?);

    Some((mod_name, cmd_name))
}

pub fn get_filtered_commands(commands: &HashSet<String>, mods: &[ExprPath]) -> HashSet<String> {
    commands
        .iter()
        .flat_map(|command| {
            let (mod_name, _) = get_separated_command(command)?;
            mods.iter()
                .any(|r#mod| {
                    r#mod
                        .path
                        .segments
                        .iter()
                        .any(|seg| mod_name.eq(&seg.ident))
                })
                .then_some(command.clone())
        })
        .collect::<HashSet<_>>()
}

pub fn get_handler_function(
    fn_name: Ident,
    commands: &HashSet<String>,
    handlers: Punctuated<ExprPath, Comma>,
    include_mods: Vec<ExprPath>,
) -> TokenStream {
    let commands = commands.iter().collect::<Vec<_>>();
    quote! {
        #[cfg(not(target_family = "wasm"))]
        #[doc = "auto generated function to register all configured commands"]
        pub fn #fn_name() -> impl Fn(tauri::ipc::Invoke) -> bool {
            #( use #include_mods; )*

            let handlers = vec! [ #( #commands ),* ];
            log::debug!("Registering following commands to tauri: {handlers:#?}");

            ::tauri::generate_handler![ #handlers ]
        }
    }
}

pub fn uses(stream: proc_macro::TokenStream) -> Vec<ItemUse> {
    Punctuated::<ItemUse, Token![|]>::parse_terminated
        .parse2(stream.into())
        .unwrap()
        .into_iter()
        .collect::<Vec<_>>()
}