Replace manual template processing with just_template library

6 files changed, 137 insertions, 220 deletions

diff --git a/gen/gen_commands_file.rs b/gen/gen_commands_file.rs
index 4131154..b68ac0a 100644
--- a/gen/gen_commands_file.rs
+++ b/gen/gen_commands_file.rs
@@ -1,33 +1,32 @@
 use std::path::PathBuf;
 
 use just_fmt::pascal_case;
+use just_template::{Template, tmpl, tmpl_param};
 
-use crate::r#gen::constants::{
-    COMMAND_LIST, COMMAND_LIST_TEMPLATE, COMMANDS_PATH, REGISTRY_TOML, TEMPLATE_END, TEMPLATE_START,
-};
+use crate::r#gen::constants::{COMMAND_LIST, COMMAND_LIST_TEMPLATE, COMMANDS_PATH, REGISTRY_TOML};
 
-/// Generate registry file from Registry.toml configuration
+/// Generate registry file from Registry.toml configuration using just_template
 pub async fn generate_commands_file(repo_root: &PathBuf) {
     let template_path = repo_root.join(COMMAND_LIST_TEMPLATE);
     let output_path = repo_root.join(COMMAND_LIST);
     let config_path = repo_root.join(REGISTRY_TOML);
 
     // Read the template
-    let template = tokio::fs::read_to_string(&template_path).await.unwrap();
+    let template_content = tokio::fs::read_to_string(&template_path).await.unwrap();
 
     // Read and parse the TOML configuration
     let config_content = tokio::fs::read_to_string(&config_path).await.unwrap();
     let config: toml::Value = toml::from_str(&config_content).unwrap();
 
     // Collect all command configurations
-    let mut commands = Vec::new();
-    let mut nodes = Vec::new();
+    let mut all_commands: Vec<(String, String, String)> = Vec::new();
+    let mut all_nodes: Vec<String> = Vec::new();
 
     // Collect commands from registry.toml and COMMANDS_PATH in parallel
     let (registry_collected, auto_collected) = tokio::join!(
         async {
-            let mut commands = Vec::new();
-            let mut nodes = Vec::new();
+            let mut commands: Vec<(String, String, String)> = Vec::new();
+            let mut nodes: Vec<String> = Vec::new();
 
             let Some(table) = config.as_table() else {
                 return (commands, nodes);
@@ -70,8 +69,8 @@ pub async fn generate_commands_file(repo_root: &PathBuf) {
             (commands, nodes)
         },
         async {
-            let mut commands = Vec::new();
-            let mut nodes = Vec::new();
+            let mut commands: Vec<(String, String, String)> = Vec::new();
+            let mut nodes: Vec<String> = Vec::new();
             let commands_dir = repo_root.join(COMMANDS_PATH);
             if commands_dir.exists() && commands_dir.is_dir() {
                 let mut entries = tokio::fs::read_dir(&commands_dir).await.unwrap();
@@ -120,69 +119,43 @@ pub async fn generate_commands_file(repo_root: &PathBuf) {
     let (mut registry_commands, mut registry_nodes) = registry_collected;
     let (mut auto_commands, mut auto_nodes) = auto_collected;
 
-    commands.append(&mut registry_commands);
-    commands.append(&mut auto_commands);
-    nodes.append(&mut registry_nodes);
-    nodes.append(&mut auto_nodes);
-
-    // Extract the node_if template from the template content
-    const PROCESS_MARKER: &str = "// PROCESS";
-    const LINE: &str = "<<LINE>>";
-    const NODES: &str = "<<NODES>>";
-
-    let template_start_index = template
-        .find(TEMPLATE_START)
-        .ok_or("Template start marker not found")
-        .unwrap();
-    let template_end_index = template
-        .find(TEMPLATE_END)
-        .ok_or("Template end marker not found")
-        .unwrap();
-
-    let template_slice = &template[template_start_index..template_end_index + TEMPLATE_END.len()];
-    let node_if_template = template_slice
-        .trim_start_matches(TEMPLATE_START)
-        .trim_end_matches(TEMPLATE_END)
-        .trim_matches('\n');
-
-    // Generate the match arms for each command
-    let match_arms: String = commands
-        .iter()
-        .map(|(key, node, cmd_type)| {
-            node_if_template
-                .replace("<<KEY>>", key)
-                .replace("<<NODE_NAME>>", node)
-                .replace("<<COMMAND_TYPE>>", cmd_type)
-                .trim_matches('\n')
-                .to_string()
-        })
-        .collect::<Vec<_>>()
-        .join("\n");
+    all_commands.append(&mut registry_commands);
+    all_commands.append(&mut auto_commands);
+
+    all_nodes.append(&mut registry_nodes);
+    all_nodes.append(&mut auto_nodes);
+
+    // Create template
+    let mut template = Template::from(template_content);
+
+    for (key, node, cmd_type) in &all_commands {
+        tmpl!(template += {
+            command_match_arms {
+                (key = key, node_name = node, cmd_type = cmd_type)
+            }
+        });
+    }
 
     let nodes_str = format!(
         "[\n        {}\n    ]",
-        nodes
+        all_nodes
             .iter()
             .map(|node| format!("\"{}\".to_string()", node))
             .collect::<Vec<_>>()
             .join(", ")
     );
 
-    // Replace the template section with the generated match arms
-    let final_content = template
-        .replace(node_if_template, "")
-        .replace(TEMPLATE_START, "")
-        .replace(TEMPLATE_END, "")
-        .replace(PROCESS_MARKER, &match_arms)
-        .lines()
-        .filter(|line| !line.trim().is_empty())
-        .collect::<Vec<_>>()
-        .join("\n")
-        .replace(LINE, "")
-        .replace(NODES, nodes_str.as_str());
+    // Use insert_param for the NODES parameter
+    tmpl_param!(template, nodes = nodes_str);
+
+    // Expand the template
+    let final_content = template.expand().unwrap();
 
     // Write the generated code
     tokio::fs::write(output_path, final_content).await.unwrap();
 
-    println!("Generated registry file with {} commands", commands.len());
+    println!(
+        "Generated registry file with {} commands using just_template",
+        all_commands.len()
+    );
 }
diff --git a/gen/gen_compile_info.rs b/gen/gen_compile_info.rs
index 5af030c..8d68d89 100644
--- a/gen/gen_compile_info.rs
+++ b/gen/gen_compile_info.rs
@@ -1,17 +1,20 @@
 use std::path::PathBuf;
 
+use just_template::{Template, tmpl_param};
+
 use crate::r#gen::{
     constants::{COMPILE_INFO_RS, COMPILE_INFO_RS_TEMPLATE},
     env::{get_git_branch, get_git_commit, get_platform, get_toolchain, get_version},
 };
 
-/// Generate compile info
+/// Generate compile info using just_template
 pub async fn generate_compile_info(repo_root: &PathBuf) {
     // Read the template code
     let template_code = tokio::fs::read_to_string(repo_root.join(COMPILE_INFO_RS_TEMPLATE))
         .await
         .unwrap();
 
+    // Get all the values needed for the template
     let date = chrono::Local::now().format("%Y-%m-%d %H:%M:%S").to_string();
     let target = std::env::var("TARGET").unwrap_or_else(|_| "unknown".to_string());
     let platform = get_platform(&target);
@@ -20,18 +23,29 @@ pub async fn generate_compile_info(repo_root: &PathBuf) {
     let branch = get_git_branch().unwrap_or_else(|_| "unknown".to_string());
     let commit = get_git_commit().unwrap_or_else(|_| "unknown".to_string());
 
-    let generated_code = template_code
-        .replace("{date}", &date)
-        .replace("{target}", &target)
-        .replace("{platform}", &platform)
-        .replace("{toolchain}", &toolchain)
-        .replace("{version}", &version)
-        .replace("{branch}", &branch)
-        .replace("{commit}", &commit);
+    // Create a Template instance
+    let mut template = Template::from(template_code);
+
+    // Set all parameters
+    tmpl_param!(
+        template,
+        date = date,
+        target = target,
+        platform = platform,
+        toolchain = toolchain,
+        version = version,
+        branch = branch,
+        commit = commit
+    );
+
+    // Expand the template
+    let generated_code = template.expand().unwrap();
 
     // Write the generated code
     let compile_info_path = repo_root.join(COMPILE_INFO_RS);
     tokio::fs::write(compile_info_path, generated_code)
         .await
         .unwrap();
+
+    println!("Generated compile_info.rs using just_template");
 }
diff --git a/gen/gen_iscc_script.rs b/gen/gen_iscc_script.rs
index 1eddcca..23328ab 100644
--- a/gen/gen_iscc_script.rs
+++ b/gen/gen_iscc_script.rs
@@ -1,25 +1,36 @@
 use std::path::PathBuf;
 
+use just_template::{Template, tmpl_param};
+
 use crate::r#gen::{
     constants::{SETUP_JV_CLI_ISS, SETUP_JV_CLI_ISS_TEMPLATE},
     env::{get_author, get_site, get_version},
 };
 
-/// Generate Inno Setup installer script (Windows only)
+/// Generate Inno Setup installer script (Windows only) using just_template
 pub async fn generate_installer_script(repo_root: &PathBuf) {
     let template_path = repo_root.join(SETUP_JV_CLI_ISS_TEMPLATE);
     let output_path = repo_root.join(SETUP_JV_CLI_ISS);
 
-    let template = tokio::fs::read_to_string(&template_path).await.unwrap();
+    // Read the template
+    let template_content = tokio::fs::read_to_string(&template_path).await.unwrap();
 
+    // Get values for the template
     let author = get_author().unwrap();
     let version = get_version();
     let site = get_site().unwrap();
 
-    let generated = template
-        .replace("<<<AUTHOR>>>", &author)
-        .replace("<<<VERSION>>>", &version)
-        .replace("<<<SITE>>>", &site);
+    // Create template
+    let mut template = Template::from(template_content);
+
+    // Set all parameters
+    tmpl_param!(template, version = version, author = author, site = site);
 
+    // Expand the template
+    let generated = template.expand().unwrap();
+
+    // Write the generated script
     tokio::fs::write(output_path, generated).await.unwrap();
+
+    println!("Generated Inno Setup script using just_template");
 }
diff --git a/gen/gen_override_renderer.rs b/gen/gen_override_renderer.rs
index dafca91..1e67be4 100644
--- a/gen/gen_override_renderer.rs
+++ b/gen/gen_override_renderer.rs
@@ -1,13 +1,11 @@
 use std::{collections::HashSet, path::PathBuf};
 
+use just_template::{Template, tmpl};
 use regex::Regex;
 use tokio::fs;
 
 use crate::r#gen::{
-    constants::{
-        COMMANDS_PATH, OVERRIDE_RENDERER_ENTRY, OVERRIDE_RENDERER_ENTRY_TEMPLATE, TEMPLATE_END,
-        TEMPLATE_START,
-    },
+    constants::{COMMANDS_PATH, OVERRIDE_RENDERER_ENTRY, OVERRIDE_RENDERER_ENTRY_TEMPLATE},
     resolve_types::resolve_type_paths,
 };
 
@@ -17,53 +15,30 @@ pub async fn generate_override_renderer(repo_root: &PathBuf) {
     let all_possible_types = collect_all_possible_types(&PathBuf::from(COMMANDS_PATH)).await;
 
     // Read the template
-    let template = tokio::fs::read_to_string(&template_path).await.unwrap();
-
-    // Extract the template section from the template content
-    const MATCH_MARKER: &str = "// MATCHING";
-
-    let template_start_index = template
-        .find(TEMPLATE_START)
-        .ok_or("Template start marker not found")
-        .unwrap();
-    let template_end_index = template
-        .find(TEMPLATE_END)
-        .ok_or("Template end marker not found")
-        .unwrap();
-
-    let template_slice = &template[template_start_index..template_end_index + TEMPLATE_END.len()];
-    let renderer_template = template_slice
-        .trim_start_matches(TEMPLATE_START)
-        .trim_end_matches(TEMPLATE_END)
-        .trim_matches('\n');
-
-    // Generate the match arms for each renderer
-    let match_arms: String = all_possible_types
-        .iter()
-        .map(|type_name| {
-            let name = type_name.split("::").last().unwrap_or(type_name);
-            renderer_template
-                .replace("JVOutputTypeName", name)
-                .replace("JVOutputType", type_name)
-                .trim_matches('\n')
-                .to_string()
-        })
-        .collect::<Vec<String>>()
-        .join("\n");
-
-    // Replace the template section with the generated match arms
-    let final_content = template
-        .replace(renderer_template, "")
-        .replace(TEMPLATE_START, "")
-        .replace(TEMPLATE_END, "")
-        .replace(MATCH_MARKER, &match_arms)
-        .lines()
-        .filter(|line| !line.trim().is_empty())
-        .collect::<Vec<_>>()
-        .join("\n");
+    let template_content = tokio::fs::read_to_string(&template_path).await.unwrap();
+
+    // Create template
+    let mut template = Template::from(template_content);
+
+    for type_name in &all_possible_types {
+        let name = type_name.split("::").last().unwrap_or(type_name);
+        tmpl!(template += {
+            type_match_arms {
+                (jv_output_type_name = name, jv_output_type = type_name)
+            }
+        });
+    }
+
+    // Expand the template
+    let final_content = template.expand().unwrap();
 
     // Write the generated code
     tokio::fs::write(output_path, final_content).await.unwrap();
+
+    println!(
+        "Generated override renderer entry with {} types using just_template",
+        all_possible_types.len()
+    );
 }
 
 pub async fn collect_all_possible_types(dir: &PathBuf) -> HashSet<String> {
diff --git a/gen/gen_renderers_file.rs b/gen/gen_renderers_file.rs
index 497d258..f16c504 100644
--- a/gen/gen_renderers_file.rs
+++ b/gen/gen_renderers_file.rs
@@ -1,18 +1,19 @@
 use std::path::PathBuf;
 
+use just_template::{Template, tmpl};
+
 use crate::r#gen::constants::{
     OVERRIDE_RENDERER_DISPATCHER, OVERRIDE_RENDERER_DISPATCHER_TEMPLATE, REGISTRY_TOML,
-    TEMPLATE_END, TEMPLATE_START,
 };
 
-/// Generate renderer list file from Registry.toml configuration
+/// Generate renderer list file from Registry.toml configuration using just_template
 pub async fn generate_renderers_file(repo_root: &PathBuf) {
     let template_path = repo_root.join(OVERRIDE_RENDERER_DISPATCHER_TEMPLATE);
     let output_path = repo_root.join(OVERRIDE_RENDERER_DISPATCHER);
     let config_path = repo_root.join(REGISTRY_TOML);
 
     // Read the template
-    let template = tokio::fs::read_to_string(&template_path).await.unwrap();
+    let template_content = tokio::fs::read_to_string(&template_path).await.unwrap();
 
     // Read and parse the TOML configuration
     let config_content = tokio::fs::read_to_string(&config_path).await.unwrap();
@@ -45,53 +46,24 @@ pub async fn generate_renderers_file(repo_root: &PathBuf) {
         renderers.push((name.to_string(), renderer_type.to_string()));
     }
 
-    // Extract the template section from the template content
-    const MATCH_MARKER: &str = "// MATCH";
-
-    let template_start_index = template
-        .find(TEMPLATE_START)
-        .ok_or("Template start marker not found")
-        .unwrap();
-    let template_end_index = template
-        .find(TEMPLATE_END)
-        .ok_or("Template end marker not found")
-        .unwrap();
+    // Create template
+    let mut template = Template::from(template_content);
 
-    let template_slice = &template[template_start_index..template_end_index + TEMPLATE_END.len()];
-    let renderer_template = template_slice
-        .trim_start_matches(TEMPLATE_START)
-        .trim_end_matches(TEMPLATE_END)
-        .trim_matches('\n');
-
-    // Generate the match arms for each renderer
-    let match_arms: String = renderers
-        .iter()
-        .map(|(name, renderer_type)| {
-            renderer_template
-                .replace("<<NAME>>", name)
-                .replace("RendererType", renderer_type)
-                .trim_matches('\n')
-                .to_string()
-        })
-        .collect::<Vec<String>>()
-        .join("\n");
+    for (name, renderer_type) in &renderers {
+        tmpl!(template += {
+            renderer_match_arms {
+                (name = name, renderer_type = renderer_type)
+            }
+        });
+    }
 
-    // Replace the template section with the generated match arms
-    let final_content = template
-        .replace(renderer_template, "")
-        .replace(TEMPLATE_START, "")
-        .replace(TEMPLATE_END, "")
-        .replace(MATCH_MARKER, &match_arms)
-        .lines()
-        .filter(|line| !line.trim().is_empty())
-        .collect::<Vec<_>>()
-        .join("\n");
+    let final_content = template.expand().unwrap();
 
     // Write the generated code
     tokio::fs::write(output_path, final_content).await.unwrap();
 
     println!(
-        "Generated renderer list file with {} renderers",
+        "Generated renderer list file with {} renderers using just_template",
         renderers.len()
     );
 }
diff --git a/gen/gen_specific_renderer.rs b/gen/gen_specific_renderer.rs
index 0c66631..95e6900 100644
--- a/gen/gen_specific_renderer.rs
+++ b/gen/gen_specific_renderer.rs
@@ -1,78 +1,50 @@
 use std::{collections::HashMap, path::PathBuf};
 
+use just_template::{Template, tmpl};
 use regex::Regex;
 
 use crate::r#gen::{
-    constants::{
-        RENDERERS_PATH, SPECIFIC_RENDERER_MATCHING, SPECIFIC_RENDERER_MATCHING_TEMPLATE,
-        TEMPLATE_END, TEMPLATE_START,
-    },
+    constants::{RENDERERS_PATH, SPECIFIC_RENDERER_MATCHING, SPECIFIC_RENDERER_MATCHING_TEMPLATE},
     resolve_types::resolve_type_paths,
 };
 
 const RENDERER_TYPE_PREFIX: &str = "crate::";
 
+/// Generate specific renderer matching file using just_template
 pub async fn generate_specific_renderer(repo_root: &PathBuf) {
-    // Matches
-    // HashMap<RendererTypeFullName, OutputTypeFullName>
+    // Matches: HashMap<RendererTypeFullName, OutputTypeFullName>
     let mut renderer_matches: HashMap<String, String> = HashMap::new();
 
     let renderer_path = repo_root.join(RENDERERS_PATH);
-
     collect_renderers(&renderer_path, &mut renderer_matches);
 
     let template_path = repo_root.join(SPECIFIC_RENDERER_MATCHING_TEMPLATE);
     let output_path = repo_root.join(SPECIFIC_RENDERER_MATCHING);
 
     // Read the template
-    let template = tokio::fs::read_to_string(&template_path).await.unwrap();
-
-    // Extract the template section from the template content
-    const MATCH_MARKER: &str = "// MATCHING";
-
-    let template_start_index = template
-        .find(TEMPLATE_START)
-        .ok_or("Template start marker not found")
-        .unwrap();
-    let template_end_index = template
-        .find(TEMPLATE_END)
-        .ok_or("Template end marker not found")
-        .unwrap();
-
-    let template_slice = &template[template_start_index..template_end_index + TEMPLATE_END.len()];
-    let renderer_template = template_slice
-        .trim_start_matches(TEMPLATE_START)
-        .trim_end_matches(TEMPLATE_END)
-        .trim_matches('\n');
-
-    // Generate the match arms for each renderer
-    let match_arms: String = renderer_matches
-        .iter()
-        .map(|(renderer, output)| {
-            let output_name = output.split("::").last().unwrap_or(output);
-            renderer_template
-                .replace("OutputTypeName", output_name)
-                .replace("OutputType", output)
-                .replace("RendererType", renderer)
-                .trim_matches('\n')
-                .to_string()
-        })
-        .collect::<Vec<String>>()
-        .join("\n");
+    let template_content = tokio::fs::read_to_string(&template_path).await.unwrap();
 
-    // Replace the template section with the generated match arms
-    let final_content = template
-        .replace(renderer_template, "")
-        .replace(TEMPLATE_START, "")
-        .replace(TEMPLATE_END, "")
-        .replace(MATCH_MARKER, &match_arms)
-        .lines()
-        .filter(|line| !line.trim().is_empty())
-        .collect::<Vec<_>>()
-        .join("\n");
+    // Create template
+    let mut template = Template::from(template_content);
+
+    for (renderer, output) in &renderer_matches {
+        let output_name = output.split("::").last().unwrap_or(output);
+        tmpl!(template += {
+            renderer_match_arms {
+                (output_type_name = output_name, output_type = output, renderer_type = renderer)
+            }
+        });
+    }
+
+    let final_content = template.expand().unwrap();
 
     // Write the generated code
     tokio::fs::write(output_path, final_content).await.unwrap();
+
+    println!(
+        "Generated specific renderer matching with {} renderers using just_template",
+        renderer_matches.len()
+    );
 }
 
 fn collect_renderers(dir_path: &PathBuf, matches: &mut HashMap<String, String>) {