trixy 0.4.0

A rust crate used to generate multi-language apis for your application
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
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

/*
* Copyright (C) 2023 - 2024:
* The Trinitrix Project <soispha@vhack.eu, antifallobst@systemausfall.org>
* SPDX-License-Identifier: GPL-3.0-or-later
*
* This file is part of the Trixy crate for Trinitrix.
*
* Trixy is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as
* published by the Free Software Foundation, either version 3 of
* the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* and the GNU General Public License along with this program.
* If not, see <https://www.gnu.org/licenses/>.
*/

//! This module is responsible for generating the rust code used to interface with the api.
//! That includes the structs and enums declared in the trixy file and the enum used to describe the
//! command being executed.

use proc_macro2::TokenStream as TokenStream2;
use quote::quote;

use crate::{
    macros::{config::trixy::TrixyConfig, generate::host::format_rust},
    parser::command_spec::{CommandSpec, Enumeration, Namespace, Structure},
};

pub fn generate(trixy: &CommandSpec, config: &TrixyConfig) -> String {
    let host_rust_code = generate_code(&trixy, &config);

    let rust_code = format_rust(host_rust_code);

    format!(
        "\
/* Rust API */\n\
{}",
        rust_code
    )
}

/// This function turns, for example, the following trixy input into this rust code:
/// ```text
/// mod trinitrix {
///    struct Callback {
///        func: String,
///        timeout: String,
///    };
///
///    enum CallbackPriority {
///        High,
///        Medium,
///        Low,
///    };
///
///    fn execute_callback(callback: Callback, priority: CallbackPriority) -> String;
/// }
/// ```
/// ```no_run
/// #[derive(Debug)]
/// pub enum Commands {
///     Trinitrix(trinitrix::Trinitrix),
/// }
/// pub mod trinitrix {
///     #[allow(non_camel_case_types)]
///     #[derive(Debug)]
///     struct Callback {
///         func: String,
///         timeout: String,
///     }
///     #[allow(non_camel_case_types)]
///     #[derive(Debug)]
///     enum CallbackPriority {
///         High,
///         Medium,
///         Low,
///     }
///     #[derive(Debug)]
///     pub enum Trinitrix {
///         #[allow(non_camel_case_types)]
///         execute_callback {
///             callback: Callback,
///             priority: CallbackPriority,
///             trixy_output: trixy::oneshot::channel<String>
///         },
///     }
/// }
/// ```
pub fn generate_code(trixy: &CommandSpec, _config: &TrixyConfig) -> TokenStream2 {
    let modules: TokenStream2 = trixy
        .namespaces
        .iter()
        .map(|nasp| nasp.to_rust_module(&vec![]))
        .collect();
    let structures: TokenStream2 = trixy.structures.iter().map(Structure::to_rust).collect();
    let enumerations: TokenStream2 = trixy
        .enumerations
        .iter()
        .map(Enumeration::to_rust)
        .collect();
    let functions: Vec<TokenStream2> = trixy
        .functions
        .iter()
        .map(|r#fn| r#fn.to_rust(&[]))
        .collect();
    let namespace_modules: Vec<TokenStream2> = trixy
        .namespaces
        .iter()
        .map(Namespace::to_rust_module_enum)
        .collect();

    quote! {
        #structures
        #enumerations
        #[derive(Debug)]
        pub enum Commands {
            #(#functions,)*
            #(#namespace_modules),*
        }
        #modules
    }
}