#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
 pub enum BuildProfile {
     #[default]
     Standard,
     LowResource,
 }
 
 impl BuildProfile {
     pub fn lto_setting(&self) -> &'static str {
         match self {
             BuildProfile::Standard => "true",
             BuildProfile::LowResource => "\"thin\"",
         }
     }
 
     pub fn codegen_units(&self) -> u32 {
         match self {
             BuildProfile::Standard => 1,
             BuildProfile::LowResource => 16,
         }
     }
 
     pub fn opt_level(&self) -> &'static str {
         match self {
             BuildProfile::Standard => "\"z\"",
             BuildProfile::LowResource => "\"s\"",
         }
     }
 
     pub fn parallel_jobs(&self) -> Option<u32> {
         match self {
             BuildProfile::Standard => None,
             BuildProfile::LowResource => Some(2),
         }
     }
 }
 
 pub trait CargoConfigGenerator {
     fn generate_cargo_toml(&self, project_name: &str, dependencies: &str) -> String;
     fn generate_cargo_config(&self) -> String;
 }
 
 pub struct ExeGenerator {
     profile: BuildProfile,
 }
 
 impl ExeGenerator {
     pub fn new(profile: BuildProfile) -> Self {
         Self { profile }
     }
 }
 
 impl CargoConfigGenerator for ExeGenerator {
     fn generate_cargo_toml(&self, project_name: &str, dependencies: &str) -> String {
         format!(
             r#"[package]
 name = "{project_name}"
 version = "0.1.0"
 edition = "2021"
 
 [dependencies]{dependencies}
 
 [profile.release]
 strip = true
 opt-level = {opt_level}
 lto = {lto}
 codegen-units = {codegen_units}
 "#,
             project_name = project_name,
             dependencies = dependencies,
             opt_level = self.profile.opt_level(),
             lto = self.profile.lto_setting(),
             codegen_units = self.profile.codegen_units(),
         )
     }
 
     fn generate_cargo_config(&self) -> String {
         match self.profile.parallel_jobs() {
             Some(jobs) => format!(
                 r#"[build]
 target = "x86_64-pc-windows-gnu"
 jobs = {jobs}
 "#
             ),
             None => r#"[build]
 target = "x86_64-pc-windows-gnu"
 "#
             .to_string(),
         }
     }
 }
 
 pub struct DllGenerator {
     profile: BuildProfile,
 }
 
 impl DllGenerator {
     pub fn new(profile: BuildProfile) -> Self {
         Self { profile }
     }
 }
 
 impl CargoConfigGenerator for DllGenerator {
     fn generate_cargo_toml(&self, project_name: &str, dependencies: &str) -> String {
         format!(
             r#"[package]
 name = "{project_name}"
 version = "0.1.0"
 edition = "2021"
 
 [lib]
 crate-type = ["cdylib"]
 
 [dependencies]{dependencies}
 
 [profile.release]
 strip = true
 opt-level = {opt_level}
 lto = {lto}
 codegen-units = {codegen_units}
 "#,
             project_name = project_name,
             dependencies = dependencies,
             opt_level = self.profile.opt_level(),
             lto = self.profile.lto_setting(),
             codegen_units = self.profile.codegen_units(),
         )
     }
 
     fn generate_cargo_config(&self) -> String {
         match self.profile.parallel_jobs() {
             Some(jobs) => format!(
                 r#"[build]
 target = "x86_64-pc-windows-gnu"
 jobs = {jobs}
 "#
             ),
             None => r#"[build]
 target = "x86_64-pc-windows-gnu"
 "#
             .to_string(),
         }
     }
 }
 
 pub fn generate_cargo_toml_exe(project_name: &str, dependencies: &str) -> String {
     ExeGenerator::new(BuildProfile::Standard).generate_cargo_toml(project_name, dependencies)
 }
 
 pub fn generate_cargo_toml_dll(project_name: &str, dependencies: &str) -> String {
     DllGenerator::new(BuildProfile::Standard).generate_cargo_toml(project_name, dependencies)
 }
 
 pub fn generate_cargo_config() -> &'static str {
     r#"[build]
 target = "x86_64-pc-windows-gnu"
 "#
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
 
     #[test]
     fn standard_profile_uses_full_lto() {
         let profile = BuildProfile::Standard;
         assert_eq!(profile.lto_setting(), "true");
     }
 
     #[test]
     fn standard_profile_uses_single_codegen_unit() {
         let profile = BuildProfile::Standard;
         assert_eq!(profile.codegen_units(), 1);
     }
 
     #[test]
     fn standard_profile_uses_size_optimization() {
         let profile = BuildProfile::Standard;
         assert_eq!(profile.opt_level(), "\"z\"");
     }
 
     #[test]
     fn standard_profile_has_no_job_limit() {
         let profile = BuildProfile::Standard;
         assert_eq!(profile.parallel_jobs(), None);
     }
 
     #[test]
     fn low_resource_profile_uses_thin_lto() {
         let profile = BuildProfile::LowResource;
         assert_eq!(profile.lto_setting(), "\"thin\"");
     }
 
     #[test]
     fn low_resource_profile_uses_multiple_codegen_units() {
         let profile = BuildProfile::LowResource;
         assert_eq!(profile.codegen_units(), 16);
     }
 
     #[test]
     fn low_resource_profile_uses_moderate_optimization() {
         let profile = BuildProfile::LowResource;
         assert_eq!(profile.opt_level(), "\"s\"");
     }
 
     #[test]
     fn low_resource_profile_limits_parallel_jobs() {
         let profile = BuildProfile::LowResource;
         assert_eq!(profile.parallel_jobs(), Some(2));
     }
 
     #[test]
     fn exe_generator_includes_profile_settings() {
         let generator = ExeGenerator::new(BuildProfile::Standard);
         let toml = generator.generate_cargo_toml("test_project", "");
 
         assert!(toml.contains("lto = true"));
         assert!(toml.contains("codegen-units = 1"));
         assert!(toml.contains("opt-level = \"z\""));
     }
 
     #[test]
     fn exe_generator_low_resource_includes_adjusted_settings() {
         let generator = ExeGenerator::new(BuildProfile::LowResource);
         let toml = generator.generate_cargo_toml("test_project", "");
 
         assert!(toml.contains("lto = \"thin\""));
         assert!(toml.contains("codegen-units = 16"));
         assert!(toml.contains("opt-level = \"s\""));
     }
 
     #[test]
     fn dll_generator_includes_cdylib_crate_type() {
         let generator = DllGenerator::new(BuildProfile::Standard);
         let toml = generator.generate_cargo_toml("test_dll", "");
 
         assert!(toml.contains("crate-type = [\"cdylib\"]"));
     }
 
     #[test]
     fn dll_generator_low_resource_includes_adjusted_settings() {
         let generator = DllGenerator::new(BuildProfile::LowResource);
         let toml = generator.generate_cargo_toml("test_dll", "");
 
         assert!(toml.contains("lto = \"thin\""));
         assert!(toml.contains("codegen-units = 16"));
     }
 
     #[test]
     fn cargo_config_standard_has_no_jobs_limit() {
         let generator = ExeGenerator::new(BuildProfile::Standard);
         let config = generator.generate_cargo_config();
 
         assert!(config.contains("target = \"x86_64-pc-windows-gnu\""));
         assert!(!config.contains("jobs"));
     }
 
     #[test]
     fn cargo_config_low_resource_has_jobs_limit() {
         let generator = ExeGenerator::new(BuildProfile::LowResource);
         let config = generator.generate_cargo_config();
 
         assert!(config.contains("target = \"x86_64-pc-windows-gnu\""));
         assert!(config.contains("jobs = 2"));
     }
 
     #[test]
     fn legacy_functions_use_standard_profile() {
         let toml = generate_cargo_toml_exe("legacy_test", "");
         assert!(toml.contains("lto = true"));
         assert!(toml.contains("codegen-units = 1"));
     }
 }

© 2024 - 2026 djnn, inc • generated with stagit