rusteron_code_gen/
lib.rs

1#![allow(non_upper_case_globals)]
2#![allow(non_camel_case_types)]
3#![allow(non_snake_case)]
4#![allow(clippy::all)]
5#![allow(unused_unsafe)]
6#![allow(unused_variables)]
7#![doc = include_str!("../README.md")]
8
9mod common;
10mod generator;
11mod parser;
12
13pub use common::*;
14pub use generator::*;
15pub use parser::*;
16
17use proc_macro2::TokenStream;
18use std::fs::OpenOptions;
19use std::io::Write;
20use std::process::{Command, Stdio};
21
22pub const CUSTOM_AERON_CODE: &str = include_str!("./aeron_custom.rs");
23pub const CUSTOM_RB_CODE: &str = include_str!("./rb_custom.rs");
24pub const COMMON_CODE: &str = include_str!("./common.rs");
25
26pub fn append_to_file(file_path: &str, code: &str) -> std::io::Result<()> {
27    // Open the file in append mode
28    let mut file = OpenOptions::new()
29        .create(true)
30        .write(true)
31        .append(true)
32        .open(file_path)?;
33
34    // Write the generated code to the file
35    writeln!(file, "\n{}", code)?;
36
37    Ok(())
38}
39
40#[allow(dead_code)]
41pub fn format_with_rustfmt(code: &str) -> Result<String, std::io::Error> {
42    let mut rustfmt = Command::new("rustfmt")
43        .stdin(Stdio::piped())
44        .stdout(Stdio::piped())
45        .spawn()?;
46
47    if let Some(mut stdin) = rustfmt.stdin.take() {
48        stdin.write_all(code.as_bytes())?;
49    }
50
51    let output = rustfmt.wait_with_output()?;
52    let formatted_code = String::from_utf8_lossy(&output.stdout).to_string();
53
54    Ok(formatted_code)
55}
56
57#[allow(dead_code)]
58pub fn format_token_stream(tokens: TokenStream) -> String {
59    let code = tokens.to_string();
60
61    match format_with_rustfmt(&code) {
62        Ok(formatted_code) if !formatted_code.trim().is_empty() => formatted_code,
63        _ => code.replace("{", "{\n"), // Fallback to unformatted code in case of error
64    }
65}
66
67#[cfg(test)]
68mod tests {
69    use crate::generator::MEDIA_DRIVER_BINDINGS;
70    use crate::parser::parse_bindings;
71    use crate::{
72        append_to_file, format_token_stream, format_with_rustfmt, ARCHIVE_BINDINGS,
73        CLIENT_BINDINGS, RB,
74    };
75    use proc_macro2::TokenStream;
76    use std::fs;
77
78    #[test]
79    #[cfg(not(target_os = "windows"))] // the generated bindings have different sizes
80    fn media_driver() {
81        let mut bindings = parse_bindings(&"../rusteron-code-gen/bindings/media-driver.rs".into());
82        assert_eq!(
83            "AeronImageFragmentAssembler",
84            bindings
85                .wrappers
86                .get("aeron_image_fragment_assembler_t")
87                .unwrap()
88                .class_name
89        );
90
91        let file = write_to_file(TokenStream::new(), true, "md.rs");
92
93        let bindings_copy = bindings.clone();
94        for handler in bindings.handlers.iter_mut() {
95            // need to run this first so I know the FnMut(xxxx) which is required in generate_rust_code
96            let _ = crate::generate_handlers(handler, &bindings_copy);
97        }
98        for (p, w) in bindings
99            .wrappers
100            .values()
101            .filter(|w| !w.type_name.contains("_t_") && w.type_name != "in_addr")
102            .enumerate()
103        {
104            let code = crate::generate_rust_code(
105                w,
106                &bindings.wrappers,
107                p == 0,
108                true,
109                true,
110                &bindings.handlers,
111            );
112            write_to_file(code, false, "md.rs");
113        }
114        let bindings_copy = bindings.clone();
115        for handler in bindings.handlers.iter_mut() {
116            let code = crate::generate_handlers(handler, &bindings_copy);
117            append_to_file(&file, &format_with_rustfmt(&code.to_string()).unwrap()).unwrap();
118        }
119        let t = trybuild::TestCases::new();
120        append_to_file(&file, MEDIA_DRIVER_BINDINGS).unwrap();
121        append_to_file(&file, "\npub fn main() {}\n").unwrap();
122        t.pass(&file)
123    }
124
125    #[test]
126    #[cfg(not(target_os = "windows"))] // the generated bindings have different sizes
127    fn client() {
128        let mut bindings = parse_bindings(&"../rusteron-code-gen/bindings/client.rs".into());
129        assert_eq!(
130            "AeronImageFragmentAssembler",
131            bindings
132                .wrappers
133                .get("aeron_image_fragment_assembler_t")
134                .unwrap()
135                .class_name
136        );
137        assert_eq!(
138            0,
139            bindings.methods.len(),
140            "expected all methods to have been matched {:#?}",
141            bindings.methods
142        );
143
144        let file = write_to_file(TokenStream::new(), true, "client.rs");
145        let bindings_copy = bindings.clone();
146        for handler in bindings.handlers.iter_mut() {
147            // need to run this first so I know the FnMut(xxxx) which is required in generate_rust_code
148            let _ = crate::generate_handlers(handler, &bindings_copy);
149        }
150        for (p, w) in bindings.wrappers.values().enumerate() {
151            let code = crate::generate_rust_code(
152                w,
153                &bindings.wrappers,
154                p == 0,
155                true,
156                true,
157                &bindings.handlers,
158            );
159            write_to_file(code, false, "client.rs");
160        }
161        let bindings_copy = bindings.clone();
162        for handler in bindings.handlers.iter_mut() {
163            let code = crate::generate_handlers(handler, &bindings_copy);
164            append_to_file(&file, &format_with_rustfmt(&code.to_string()).unwrap()).unwrap();
165        }
166
167        let t = trybuild::TestCases::new();
168        append_to_file(&file, CLIENT_BINDINGS).unwrap();
169        append_to_file(&file, "\npub fn main() {}\n").unwrap();
170        t.pass(file)
171    }
172
173    #[test]
174    #[cfg(not(target_os = "windows"))] // the generated bindings have different sizes
175    fn rb() {
176        let mut bindings = parse_bindings(&"../rusteron-code-gen/bindings/rb.rs".into());
177
178        let file = write_to_file(TokenStream::new(), true, "rb.rs");
179
180        let bindings_copy = bindings.clone();
181        for handler in bindings.handlers.iter_mut() {
182            // need to run this first so I know the FnMut(xxxx) which is required in generate_rust_code
183            let _ = crate::generate_handlers(handler, &bindings_copy);
184        }
185
186        for (p, w) in bindings.wrappers.values().enumerate() {
187            let code = crate::generate_rust_code(
188                w,
189                &bindings.wrappers,
190                p == 0,
191                true,
192                false,
193                &bindings.handlers,
194            );
195            if code.to_string().contains("ndler : Option < AeronCloseClientHandlerImpl > , rbd :) -> Result < Self , AeronCError > { let resource = Manage") {
196                panic!("{}", format_token_stream(code));
197            }
198
199            write_to_file(code, false, "rb.rs");
200        }
201
202        let bindings_copy = bindings.clone();
203        for handler in bindings.handlers.iter_mut() {
204            let code = crate::generate_handlers(handler, &bindings_copy);
205            append_to_file(&file, &format_with_rustfmt(&code.to_string()).unwrap()).unwrap();
206        }
207
208        let t = trybuild::TestCases::new();
209        append_to_file(&file, RB).unwrap();
210        append_to_file(&file, "\npub fn main() {}\n").unwrap();
211        t.pass(file)
212    }
213
214    #[test]
215    #[cfg(not(target_os = "windows"))] // the generated bindings have different sizes
216    fn archive() {
217        let mut bindings = parse_bindings(&"../rusteron-code-gen/bindings/archive.rs".into());
218        assert_eq!(
219            "AeronImageFragmentAssembler",
220            bindings
221                .wrappers
222                .get("aeron_image_fragment_assembler_t")
223                .unwrap()
224                .class_name
225        );
226
227        let file = write_to_file(TokenStream::new(), true, "archive.rs");
228        let bindings_copy = bindings.clone();
229        for handler in bindings.handlers.iter_mut() {
230            // need to run this first so I know the FnMut(xxxx) which is required in generate_rust_code
231            let _ = crate::generate_handlers(handler, &bindings_copy);
232        }
233        for (p, w) in bindings.wrappers.values().enumerate() {
234            let code = crate::generate_rust_code(
235                w,
236                &bindings.wrappers,
237                p == 0,
238                true,
239                true,
240                &bindings.handlers,
241            );
242            write_to_file(code, false, "archive.rs");
243        }
244        let bindings_copy = bindings.clone();
245        for handler in bindings.handlers.iter_mut() {
246            let code = crate::generate_handlers(handler, &bindings_copy);
247            append_to_file(&file, &format_with_rustfmt(&code.to_string()).unwrap()).unwrap();
248        }
249        let t = trybuild::TestCases::new();
250        append_to_file(&file, ARCHIVE_BINDINGS).unwrap();
251        append_to_file(&file, "\npub fn main() {}\n").unwrap();
252        t.pass(file)
253    }
254
255    fn write_to_file(rust_code: TokenStream, delete: bool, name: &str) -> String {
256        let src = format_token_stream(rust_code);
257        let path = format!("../target/{name}");
258        let path = &path;
259        if delete {
260            let _ = fs::remove_file(path);
261        }
262        append_to_file(path, &src).unwrap();
263        path.to_string()
264    }
265}
rusteron_code_gen/lib.rs

rusteron_code_gen/
lib.rs
