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}
64
65pub fn parse_runtime_api(json: &str) -> Result<RuntimeApi, serde_json::Error> {
66 serde_json::from_str(json)
67}
68
69pub fn generate_runtime_api(api: &RuntimeApi) -> GeneratedApi {
70 let mappings = generate::collect_event_mappings(api);
71 let class_names = generate::class_names(api);
72 let filter_concept_names = generate::event_filter_concept_names(api);
73 let concept_names = generate::generatable_concept_names(api, &filter_concept_names);
74 let union_registry = generate::collect_literal_unions(api);
75 let known = generate::KnownTypes {
76 classes: &class_names,
77 concepts: &concept_names,
78 unions: union_registry.names(),
79 union_registry: &union_registry,
80 };
81 let event_filters = generate::generate_event_filters(api);
82
83 GeneratedApi {
84 application_version: api.application_version.clone(),
85 api_version: api.api_version,
86 events: generate::generate_events(api),
87 event_map: generate::generate_event_map(&mappings),
88 event_lookup: generate::generate_event_lookup(&mappings),
89 event_filter_lookup: generate::generate_event_filter_lookup(&mappings),
90 event_module_lookup: generate::generate_event_module_lookup(&mappings),
91 event_filters,
92 event_data: generate::generate_event_data(api, &known),
93 defines: generate::generate_defines(&api.defines),
94 classes: generate::generate_classes(api, &known),
95 globals: generate::generate_globals(api, &known),
96 concepts: generate::generate_concepts(api, &known, &filter_concept_names),
97 unions: generate::generate_unions(&union_registry),
98 }
99}
100
101pub fn generate_from_json(json: &str) -> Result<GeneratedApi, serde_json::Error> {
102 let api = parse_runtime_api(json)?;
103 Ok(generate_runtime_api(&api))
104}
105
106pub fn bundled_runtime_api_json() -> &'static str {
107 include_str!("../api/runtime-api.json")
108}
109
110pub fn generate_from_bundled_api() -> Result<GeneratedApi, serde_json::Error> {
111 generate_from_json(bundled_runtime_api_json())
112}
113
114pub fn write_generated_api(output_dir: &Path, generated: &GeneratedApi) -> std::io::Result<()> {
115 std::fs::create_dir_all(output_dir)?;
116
117 write_module(
118 output_dir,
119 "mod.rs",
120 &format!(
121 "// Generated from Factorio runtime API v{} (format v{}).\n\
122 #[allow(unused, clippy::all, clippy::pedantic, clippy::nursery)]\n\n\
123 pub mod classes;\n\
124 pub mod concepts;\n\
125 pub mod defines;\n\
126 pub mod event_data;\n\
127 pub mod event_filters;\n\
128 pub mod events;\n\
129 pub mod globals;\n\
130 pub mod map;\n\
131 pub mod unions;\n",
132 generated.application_version, generated.api_version
133 ),
134 )?;
135 write_module(output_dir, "events.rs", &generated.events)?;
136 write_module(output_dir, "map.rs", &generated.event_map)?;
137 write_module(output_dir, "event_filters.rs", &generated.event_filters)?;
138 write_module(output_dir, "event_data.rs", &generated.event_data)?;
139 write_module(output_dir, "defines.rs", &generated.defines)?;
140 write_module(output_dir, "classes.rs", &generated.classes)?;
141 write_module(output_dir, "globals.rs", &generated.globals)?;
142 write_module(output_dir, "concepts.rs", &generated.concepts)?;
143 write_module(output_dir, "unions.rs", &generated.unions)?;
144
145 Ok(())
146}
147
148pub fn write_macro_event_lookup(
149 output_dir: &Path,
150 generated: &GeneratedApi,
151) -> std::io::Result<()> {
152 std::fs::create_dir_all(output_dir)?;
153 write_module(output_dir, "event_lookup.rs", &generated.event_lookup)?;
154 write_module(
155 output_dir,
156 "event_filter_lookup.rs",
157 &generated.event_filter_lookup,
158 )?;
159 write_module(
160 output_dir,
161 "event_module_lookup.rs",
162 &generated.event_module_lookup,
163 )
164}
165
166fn write_module(output_dir: &Path, file_name: &str, contents: &str) -> std::io::Result<()> {
167 let path = output_dir.join(file_name);
168 std::fs::write(path, contents)
169}