Extract build-time generation code into separate crate

1 files changed, 96 insertions, 0 deletions

diff --git a/gen/src/gen_mod_files.rs b/gen/src/gen_mod_files.rs
new file mode 100644
index 0000000..d0b0800
--- /dev/null
+++ b/gen/src/gen_mod_files.rs
@@ -0,0 +1,96 @@
+use std::path::PathBuf;
+
+use crate::constants::REGISTRY_TOML;
+
+/// Generate collect files from directory structure
+pub async fn generate_collect_files(repo_root: &PathBuf) {
+    // Read and parse the TOML configuration
+    let config_path = repo_root.join(REGISTRY_TOML);
+    let config_content = tokio::fs::read_to_string(&config_path).await.unwrap();
+    let config: toml::Value = toml::from_str(&config_content).unwrap();
+
+    // Process each collect configuration
+    let collect_table = config.get("collect").and_then(|v| v.as_table());
+
+    let collect_table = match collect_table {
+        Some(table) => table,
+        None => return,
+    };
+
+    for (_collect_name, collect_config) in collect_table {
+        let config_table = match collect_config.as_table() {
+            Some(table) => table,
+            None => continue,
+        };
+
+        let path_str = match config_table.get("path").and_then(|v| v.as_str()) {
+            Some(path) => path,
+            None => continue,
+        };
+
+        let output_path = repo_root.join(path_str);
+
+        // Extract directory name from the path (e.g., "src/renderers.rs" -> "renderers")
+        let dir_name = match output_path.file_stem().and_then(|s| s.to_str()) {
+            Some(name) => name.to_string(),
+            None => continue,
+        };
+
+        // Get the directory path for this collect type
+        // e.g., for "src/renderers.rs", we want "src/renderers/"
+        let output_parent = output_path.parent().unwrap_or_else(|| repo_root.as_path());
+        let dir_path = output_parent.join(&dir_name);
+
+        // Collect all .rs files in the directory (excluding the output file itself)
+        let mut modules = Vec::new();
+
+        if dir_path.exists() && dir_path.is_dir() {
+            for entry in std::fs::read_dir(&dir_path).unwrap() {
+                let entry = entry.unwrap();
+                let path = entry.path();
+
+                if !path.is_file() {
+                    continue;
+                }
+
+                let extension = match path.extension() {
+                    Some(ext) => ext,
+                    None => continue,
+                };
+
+                if extension != "rs" {
+                    continue;
+                }
+
+                let file_name = match path.file_stem().and_then(|s| s.to_str()) {
+                    Some(name) => name,
+                    None => continue,
+                };
+
+                // Skip files that start with underscore
+                if !file_name.starts_with('_') {
+                    modules.push(file_name.to_string());
+                }
+            }
+        }
+
+        // Sort modules alphabetically
+        modules.sort();
+
+        // Generate the content
+        let mut content = String::new();
+        for module in &modules {
+            content.push_str(&format!("pub mod {};\n", module));
+        }
+
+        // Write the file
+        tokio::fs::write(&output_path, content).await.unwrap();
+
+        println!(
+            "Generated {} with {} modules: {:?}",
+            path_str,
+            modules.len(),
+            modules
+        );
+    }
+}