1#![doc = include_str!("../README.md")]
2use xmlserde::xml_serde_enum;
3
4#[derive(Debug)]
5pub enum ParserError {
6 IO(std::io::Error),
7 Xml(String),
8}
9
10impl From<std::io::Error> for ParserError {
11 fn from(value: std::io::Error) -> Self {
12 Self::IO(value)
13 }
14}
15
16impl std::error::Error for ParserError {}
17impl std::fmt::Display for ParserError {
18 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19 match self {
20 Self::IO(e) => f.write_fmt(format_args!("I/O operation failed {e}")),
21 Self::Xml(e) => f.write_fmt(format_args!("Failed to parse xml file: {e}")),
22 }
23 }
24}
25
26xml_serde_enum! {
27 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]
28 Stability {
29 Stable => "Stable",
30 Unstable => "Unstable",
31 Private => "Private",
32 }
33}
34
35xml_serde_enum! {
36 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]
37 TransferOwnership {
38 None => "none",
39 Container => "container",
40 Full => "full",
41 }
42}
43
44impl TransferOwnership {
45 pub fn is_none(&self) -> bool {
46 matches!(self, Self::None)
47 }
48
49 pub fn is_full(&self) -> bool {
50 matches!(self, Self::Full)
51 }
52
53 pub fn is_container(&self) -> bool {
54 matches!(self, Self::Container)
55 }
56}
57
58xml_serde_enum! {
59 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]
60 FunctionScope {
61 Call => "call",
62 Notified => "notified",
63 Async => "async",
64 Forever => "forever",
65 }
66}
67
68impl FunctionScope {
69 pub fn is_call(&self) -> bool {
70 matches!(self, Self::Call)
71 }
72
73 pub fn is_notified(&self) -> bool {
74 matches!(self, Self::Notified)
75 }
76
77 pub fn is_async(&self) -> bool {
78 matches!(self, Self::Async)
79 }
80
81 pub fn is_forever(&self) -> bool {
82 matches!(self, Self::Forever)
83 }
84}
85
86xml_serde_enum! {
87 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]
88 SignalEmission {
89 First => "first",
90 Last => "last",
91 Cleanup => "cleanup",
92 }
93}
94
95#[macro_use]
96mod traits;
97pub mod prelude {
98 pub use xmlserde::XmlValue;
99
100 pub use super::traits::*;
101}
102
103mod alias;
104pub use alias::Alias;
105mod array;
106pub use array::Array;
107mod attribute;
108pub use attribute::Attribute;
109mod bitfield;
110pub use bitfield::BitField;
111mod boxed;
112pub use boxed::Boxed;
113mod callback;
114pub use callback::Callback;
115mod class;
116pub use class::{Class, Implements};
117mod constant;
118pub use constant::Constant;
119mod documentation;
120pub use documentation::{DocDeprecated, DocStability, DocVersion, Documentation, SourcePosition};
121mod enums;
122pub use enums::Enumeration;
123mod field;
124pub use field::{Field, FieldType};
125mod function;
126pub use function::{Function, FunctionInline};
127mod function_macro;
128pub use function_macro::FunctionMacro;
129mod interface;
130pub use interface::{Interface, Prerequisite};
131mod member;
132pub use member::Member;
133mod method;
134pub use method::{Method, MethodInline};
135mod namespace;
136pub use namespace::Namespace;
137mod parameter;
138pub use parameter::{Direction, InstanceParameter, Parameter, ParameterType, Parameters};
139mod property;
140pub use property::Property;
141mod record;
142pub use record::Record;
143mod repository;
144pub use repository::{HeaderInclude, NamespaceInclude, Package, Repository};
145mod return_value;
146pub use return_value::ReturnValue;
147mod signal;
148pub use signal::Signal;
149mod r#type;
150pub use r#type::{AnyType, Type};
151mod union;
152pub use union::Union;
153mod version;
154pub use version::Version;
155mod virtual_method;
156pub use virtual_method::VirtualMethod;
157
158#[cfg(test)]
159mod tests {
160 use std::{path::PathBuf, str::FromStr};
161
162 use super::prelude::*;
163
164 const GIR_FILES: [&str; 35] = [
165 "Atk-1.0",
166 "cairo-1.0",
167 "fontconfig-2.0",
168 "freetype2-2.0",
169 "Gdk-3.0",
170 "Gdk-4.0",
171 "GdkPixbuf-2.0",
172 "GdkPixdata-2.0",
173 "GdkWayland-4.0",
174 "GdkWin32-4.0",
175 "GdkX11-3.0",
176 "GdkX11-4.0",
177 "Gio-2.0",
178 "GL-1.0",
179 "GLib-2.0",
180 "GModule-2.0",
181 "GObject-2.0",
182 "Graphene-1.0",
183 "Gsk-4.0",
184 "Gtk-3.0",
185 "Gtk-4.0",
186 "HarfBuzz-0.0",
187 "libxml2-2.0",
188 "Pango-1.0",
189 "PangoCairo-1.0",
190 "PangoFc-1.0",
191 "PangoFT2-1.0",
192 "PangoOT-1.0",
193 "PangoXft-1.0",
194 "Vulkan-1.0",
195 "win32-1.0",
196 "xfixes-4.0",
197 "xft-2.0",
198 "xlib-2.0",
199 "xrandr-1.3",
200 ];
201
202 use super::{repository::Repository, version::Version};
203
204 fn parse_gir(gir_file: &str) -> Repository {
205 let path = PathBuf::from("./gir-files").join(&format!("{}.gir", gir_file));
206 Repository::from_path(path).unwrap()
207 }
208 #[test]
209 fn xft_gir() {
210 let repo = parse_gir(GIR_FILES[32]);
211 assert_eq!(repo.version(), Version::from_str("1.2").ok().as_ref());
212 assert_eq!(repo.namespace_includes()[0].as_package(), "xlib-2.0");
213
214 let namespace = repo.namespace();
215 assert_eq!(namespace.version(), "2.0");
216 assert_eq!(namespace.name(), "xft");
217 assert_eq!(namespace.c_identifier_prefixes(), "Xft");
218 assert_eq!(namespace.c_symbol_prefixes(), Some("Xft"));
219 }
220
221 #[test]
222 fn xlib_gir() {
223 let repo = parse_gir(GIR_FILES[33]);
224 assert_eq!(repo.version(), Version::from_str("1.2").ok().as_ref());
225 let namespace = repo.namespace();
226 assert_eq!(namespace.version(), "2.0");
227 assert_eq!(namespace.name(), "xlib");
228 assert_eq!(namespace.c_identifier_prefixes(), "");
229 assert_eq!(namespace.c_symbol_prefixes(), Some("X"));
230 let aliases = namespace.aliases();
231 assert_eq!(aliases[0].name(), "Atom");
232 assert_eq!(aliases[0].c_type(), "Atom");
233 assert_eq!(aliases[0].ty().as_type().name(), Some("gulong"));
234 assert_eq!(aliases[0].ty().as_type().c_type(), Some("gulong"));
235
236 let records = namespace.records();
237 assert_eq!(records[0].name(), Some("Display"));
238 assert_eq!(records[0].c_type(), Some("Display"));
239
240 let unions = namespace.unions();
241 assert_eq!(unions[0].name(), Some("XEvent"));
242 assert_eq!(unions[0].c_type(), Some("XEvent"));
243
244 let functions = namespace.functions();
245 assert_eq!(functions[0].name(), "open_display");
246 assert_eq!(functions[0].c_identifier(), Some("XOpenDisplay"));
247 assert!(functions[0].parameters().is_empty());
248
249 let return_value = functions[0].return_value();
250 assert!(return_value.transfer_ownership().unwrap().is_none());
251 assert_eq!(return_value.ty().as_type().name(), Some("none"));
252 assert_eq!(return_value.ty().as_type().c_type(), Some("void"));
253 }
254
255 #[test]
256 fn xrandr_gir() {
257 let repo = parse_gir(GIR_FILES[34]);
258 assert_eq!(repo.version(), Version::from_str("1.2").ok().as_ref());
259 let namespace = repo.namespace();
260 assert_eq!(namespace.version(), "1.3");
261 assert_eq!(namespace.name(), "xrandr");
262 assert_eq!(namespace.c_identifier_prefixes(), "XRR");
263 assert_eq!(namespace.c_symbol_prefixes(), Some("XRR"));
264 let records = namespace.records();
265 assert_eq!(records[0].name(), Some("ScreenSize"));
266 assert_eq!(records[0].c_type(), Some("XRRScreenSize"));
267 }
268
269 #[test]
270 fn parse_all_gir_files() {
271 let paths = std::fs::read_dir("./gir-files").unwrap();
272
273 for path in paths {
274 let path = path.unwrap().path();
275 let gir_file = path
276 .file_name()
277 .unwrap()
278 .to_str()
279 .unwrap()
280 .trim_end_matches(".gir")
281 .to_owned();
282 println!("{:#?}", gir_file);
283 let repository = parse_gir(&gir_file);
284 assert!(gir_file.starts_with(repository.namespace().name()));
285 }
286 }
287}