1#![allow(
2 clippy::missing_errors_doc,
3 clippy::missing_panics_doc,
4 clippy::module_name_repetitions,
5 clippy::must_use_candidate,
6 clippy::too_many_lines,
7 clippy::cognitive_complexity,
8 clippy::doc_markdown,
9 clippy::unnested_or_patterns,
10 clippy::option_if_let_else,
11 clippy::map_unwrap_or,
12 clippy::needless_pass_by_value,
13 clippy::use_self,
14 clippy::similar_names,
15 clippy::single_match_else,
16 clippy::match_same_arms,
17 clippy::items_after_statements,
18 clippy::struct_field_names,
19 clippy::if_not_else,
20 clippy::from_iter_instead_of_collect,
21 clippy::manual_string_new,
22 clippy::wildcard_imports,
23 clippy::enum_glob_use,
24 clippy::unused_self,
25 clippy::trivially_copy_pass_by_ref,
26 clippy::as_conversions,
27 clippy::indexing_slicing,
28 clippy::integer_division,
29 clippy::arithmetic_side_effects,
30 clippy::missing_const_for_fn,
31 clippy::implicit_hasher,
32 clippy::semicolon_if_nothing_returned,
33 clippy::redundant_closure_for_method_calls,
34 clippy::unnecessary_wraps,
35 clippy::return_self_not_must_use,
36 clippy::pub_use,
37 clippy::module_inception,
38 clippy::redundant_pub_crate
39)]
40
41mod generate;
42mod schema;
43
44use std::path::Path;
45
46pub use schema::RuntimeApi;
47
48pub struct GeneratedApi {
49 pub application_version: String,
50 pub api_version: u32,
51 pub events: String,
52 pub event_map: String,
53 pub event_lookup: String,
54 pub event_filter_lookup: String,
55 pub event_module_lookup: String,
56 pub event_filters: String,
57 pub event_data: String,
58 pub defines: String,
59 pub classes: String,
60 pub globals: String,
61 pub concepts: String,
62 pub unions: String,
63 pub debug_types: String,
64 pub attribute_setters: String,
65}
66
67pub fn parse_runtime_api(json: &str) -> Result<RuntimeApi, serde_json::Error> {
68 serde_json::from_str(json)
69}
70
71pub fn generate_runtime_api(api: &RuntimeApi) -> GeneratedApi {
72 let mappings = generate::collect_event_mappings(api);
73 let class_names = generate::class_names(api);
74 let filter_concept_names = generate::event_filter_concept_names(api);
75 let identification_names = generate::identification_concept_names(api, &filter_concept_names);
76 let identification_signatures = generate::identification_signatures(api, &identification_names);
77 let mut concept_names = generate::generatable_concept_names(api, &filter_concept_names);
78 concept_names.extend(identification_names.iter().cloned());
79 let union_registry = generate::collect_literal_unions(api);
80 let known = generate::KnownTypes {
81 classes: &class_names,
82 concepts: &concept_names,
83 identifications: &identification_names,
84 identification_signatures: &identification_signatures,
85 unions: union_registry.names(),
86 union_registry: &union_registry,
87 };
88 let event_filters = generate::generate_event_filters(api);
89 let concepts = {
90 let mut structs = generate::generate_concepts(api, &known, &filter_concept_names);
91 let ids = generate::generate_identifications(api, &known).to_string();
92 structs.push_str(&ids);
93 structs
94 };
95
96 GeneratedApi {
97 application_version: api.application_version.clone(),
98 api_version: api.api_version,
99 events: generate::generate_events(api),
100 event_map: generate::generate_event_map(&mappings),
101 event_lookup: generate::generate_event_lookup(&mappings),
102 event_filter_lookup: generate::generate_event_filter_lookup(&mappings),
103 event_module_lookup: generate::generate_event_module_lookup(&mappings),
104 event_filters,
105 event_data: generate::generate_event_data(api, &known),
106 defines: generate::generate_defines(&api.defines),
107 classes: generate::generate_classes(api, &known),
108 globals: generate::generate_globals(api, &known),
109 concepts,
110 unions: generate::generate_unions(&union_registry),
111 debug_types: generate::generate_debug_types(api, &known),
112 attribute_setters: generate::generate_attribute_setter_lookup(api),
113 }
114}
115
116pub fn generate_from_json(json: &str) -> Result<GeneratedApi, serde_json::Error> {
117 let api = parse_runtime_api(json)?;
118 Ok(generate_runtime_api(&api))
119}
120
121pub fn bundled_runtime_api_json() -> &'static str {
122 include_str!("../api/runtime-api.json")
123}
124
125pub fn generate_from_bundled_api() -> Result<GeneratedApi, serde_json::Error> {
126 generate_from_json(bundled_runtime_api_json())
127}
128
129pub fn write_generated_api(output_dir: &Path, generated: &GeneratedApi) -> std::io::Result<()> {
130 std::fs::create_dir_all(output_dir)?;
131
132 write_module(
133 output_dir,
134 "mod.rs",
135 &format!(
136 "// Generated from Factorio runtime API v{} (format v{}).\n\
137 #[allow(unused, clippy::all, clippy::pedantic, clippy::nursery)]\n\n\
138 pub mod classes;\n\
139 pub mod concepts;\n\
140 pub mod debug_types;\n\
141 pub mod defines;\n\
142 pub mod event_data;\n\
143 pub mod event_filters;\n\
144 pub mod events;\n\
145 pub mod globals;\n\
146 pub mod map;\n\
147 pub mod unions;\n",
148 generated.application_version, generated.api_version
149 ),
150 )?;
151 write_module(output_dir, "events.rs", &generated.events)?;
152 write_module(output_dir, "map.rs", &generated.event_map)?;
153 write_module(output_dir, "event_filters.rs", &generated.event_filters)?;
154 write_module(output_dir, "event_data.rs", &generated.event_data)?;
155 write_module(output_dir, "defines.rs", &generated.defines)?;
156 write_module(output_dir, "classes.rs", &generated.classes)?;
157 write_module(output_dir, "globals.rs", &generated.globals)?;
158 write_module(output_dir, "concepts.rs", &generated.concepts)?;
159 write_module(output_dir, "unions.rs", &generated.unions)?;
160 write_module(output_dir, "debug_types.rs", &generated.debug_types)?;
161
162 Ok(())
163}
164
165pub fn write_macro_event_lookup(
166 output_dir: &Path,
167 generated: &GeneratedApi,
168) -> std::io::Result<()> {
169 std::fs::create_dir_all(output_dir)?;
170 write_module(output_dir, "event_lookup.rs", &generated.event_lookup)?;
171 write_module(
172 output_dir,
173 "event_filter_lookup.rs",
174 &generated.event_filter_lookup,
175 )?;
176 write_module(
177 output_dir,
178 "event_module_lookup.rs",
179 &generated.event_module_lookup,
180 )
181}
182
183fn write_module(output_dir: &Path, file_name: &str, contents: &str) -> std::io::Result<()> {
184 let path = output_dir.join(file_name);
185 std::fs::write(path, contents)
186}