Custom output directory via build.target

src/cli/build.rs

@@ -30,6 +30,7 @@ pub fn build(args: &[String]) -> i32 {
     let project_compiler = get_config_str(&config, "build.compiler");
     let build_language = get_config_str(&config, "build.language");
     let build_standard = get_config_str(&config, "build.standard");
+    let build_target = get_config_str(&config, "build.target");
     let build_cflags = match get_config_list(&config, "build.cflags") {
         Ok(v) => v,
         Err(msg) => {
@@ -52,7 +53,7 @@ pub fn build(args: &[String]) -> i32 {
         colored(&project_compiler, BOLD_GREEN)
     );
 
-    ensure_target_dirs(&items, &active_profile);
+    ensure_target_dirs(&items, &active_profile, normalize_target(&build_target));
 
     let project_root = match std::env::current_dir() {
         Ok(p) => p,
@@ -74,6 +75,7 @@ pub fn build(args: &[String]) -> i32 {
         compiler: &project_compiler,
         language: &build_language,
         standard: &build_standard,
+        target_dir: normalize_target(&build_target),
         include_dirs: &resolved.include_dirs,
         lib_dirs: &resolved.lib_dirs,
         libs: &resolved.libs,
@@ -138,7 +140,11 @@ fn get_config_list(config: &Config, key: &str) -> Result<Vec<String>, String> {
     Ok(out)
 }
 
-fn ensure_target_dirs(items: &[String], profile: &str) {
+fn ensure_target_dirs(items: &[String], profile: &str, target_dir: Option<&str>) {
+    if let Some(dir) = target_dir {
+        let _ = fs::create_dir_all(dir);
+        return;
+    }
     if !items.contains(&"target".to_string()) {
         let _ = fs::create_dir("./target");
     }
@@ -162,3 +168,12 @@ fn run_build(ctx: &BuildContext) -> Result<f64, String> {
         Err(_) => Err("Build failed".to_string()),
     }
 }
+
+fn normalize_target(target: &str) -> Option<&str> {
+    let trimmed = target.trim();
+    if trimmed.is_empty() {
+        None
+    } else {
+        Some(trimmed)
+    }
+}

src/cli/run.rs

@@ -1,9 +1,11 @@
 use crate::cli::build::build;
 use crate::config::{PROFILE, flags};
 use crate::core::config::Config;
+use crate::platform;
 use crate::utils::fs::check_dir;
 use crate::utils::log::{error, warn};
 use crate::utils::text::{BOLD_GREEN, colored};
+use std::path::Path;
 use std::process::Command;
 
 pub fn run(args: &[String]) -> i32 {
@@ -26,6 +28,11 @@ pub fn run(args: &[String]) -> i32 {
         .get("package.name")
         .and_then(|v| v.as_str())
         .unwrap_or("");
+    let target_dir = config
+        .get("build.target")
+        .and_then(|v| v.as_str())
+        .map(|s| s.trim())
+        .filter(|s| !s.is_empty());
 
     if let Some(first_arg) = args.first() {
         if first_arg.starts_with("--") {
@@ -43,24 +50,34 @@ pub fn run(args: &[String]) -> i32 {
     }
 
     let build_status = build(args);
+    let bin_path = platform::bin_path(&active_profile, project_name, target_dir);
     if build_status == 0 {
-        println!(
-            "\n    {} target/{active_profile}/{project_name}",
-            colored("Running", BOLD_GREEN)
-        );
+        println!("\n    {} {}", colored("Running", BOLD_GREEN), bin_path);
         println!("--------------------------------");
-        return Command::new(format!("./target/{active_profile}/{project_name}"))
+        return Command::new(bin_path)
             .status()
             .map(|status| status.code().unwrap_or(1))
             .unwrap_or(1);
     }
 
-    if check_dir(Some(&format!("target/{active_profile}")))
-        .unwrap_or_default()
-        .contains(&active_profile)
+    if target_dir.is_none()
+        && check_dir(Some(&format!("target/{active_profile}")))
+            .unwrap_or_default()
+            .contains(&active_profile)
     {
         warn("Launch of the latest release");
-        return Command::new(format!("./target/{active_profile}/{project_name}"))
+        return Command::new(platform::bin_path(
+            &active_profile,
+            project_name,
+            target_dir,
+        ))
+        .status()
+        .map(|status| status.code().unwrap_or(1))
+        .unwrap_or(1);
+    }
+    if target_dir.is_some() && Path::new(&bin_path).exists() {
+        warn("Launch of the latest release");
+        return Command::new(bin_path)
             .status()
             .map(|status| status.code().unwrap_or(1))
             .unwrap_or(1);

src/core/builder/clang.rs

@@ -37,8 +37,11 @@ pub fn build(ctx: &BuildContext) -> Result<f64, String> {
     for flag in ctx.ldflags {
         cmd.arg(flag);
     }
-    cmd.arg("-o")
-        .arg(platform::bin_path(ctx.profile, ctx.project_name));
+    cmd.arg("-o").arg(platform::bin_path(
+        ctx.profile,
+        ctx.project_name,
+        ctx.target_dir,
+    ));
 
     match cmd.status() {
         Ok(status) if status.success() => {

src/core/builder/gcc.rs

@@ -37,8 +37,11 @@ pub fn build(ctx: &BuildContext) -> Result<f64, String> {
     for flag in ctx.ldflags {
         cmd.arg(flag);
     }
-    cmd.arg("-o")
-        .arg(platform::bin_path(ctx.profile, ctx.project_name));
+    cmd.arg("-o").arg(platform::bin_path(
+        ctx.profile,
+        ctx.project_name,
+        ctx.target_dir,
+    ));
 
     match cmd.status() {
         Ok(status) if status.success() => {

src/core/builder/mod.rs

@@ -8,6 +8,7 @@ pub struct BuildContext<'a> {
     pub compiler: &'a str,
     pub language: &'a str,
     pub standard: &'a str,
+    pub target_dir: Option<&'a str>,
     pub include_dirs: &'a [String],
     pub lib_dirs: &'a [String],
     pub libs: &'a [String],

src/core/builder/msvc.rs

@@ -63,7 +63,7 @@ pub fn build(ctx: &BuildContext) -> Result<f64, String> {
     }
     cmd.arg(format!(
         "/Fe:{}",
-        platform::bin_path(ctx.profile, ctx.project_name)
+        platform::bin_path(ctx.profile, ctx.project_name, ctx.target_dir)
     ));
 
     match cmd.status() {

src/core/config.rs

@@ -216,16 +216,19 @@ fn format_toml(value: &Value) -> Result<String, ConfigError> {
     out.push_str("[build]\n");
     out.push_str(&format!("language = \"{language}\"\n"));
     out.push_str(&format!("standard = \"{standard}\"\n"));
-    out.push_str(&format!("compiler = \"{compiler}\"\n\n"));
+    out.push_str(&format!("compiler = \"{compiler}\"\n"));
+    if let Some(target) = build.get("target").and_then(|v| v.as_str()) {
+        if !target.trim().is_empty() {
+            out.push_str(&format!("target = \"{target}\"\n"));
+        }
+    }
     if let Some(cflags) = build.get("cflags") {
         out.push_str(&format!("cflags = {}\n", format_string_array(cflags)));
     }
     if let Some(ldflags) = build.get("ldflags") {
         out.push_str(&format!("ldflags = {}\n", format_string_array(ldflags)));
     }
-    if build.contains_key("cflags") || build.contains_key("ldflags") {
-        out.push('\n');
-    }
+    out.push('\n');
 
     out.push_str("[dependencies]\n");
     if !deps.is_empty() {

src/platform/linux.rs

@@ -1,3 +1,6 @@
-pub fn bin_path(profile: &str, name: &str) -> String {
-    format!("./target/{profile}/{name}")
+pub fn bin_path(profile: &str, name: &str, target_dir: Option<&str>) -> String {
+    match target_dir {
+        Some(dir) => format!("{}/{}", dir.trim_end_matches('/'), name),
+        None => format!("./target/{profile}/{name}"),
+    }
 }

src/platform/macos.rs

@@ -1,3 +1,6 @@
-pub fn bin_path(profile: &str, name: &str) -> String {
-    format!("./target/{profile}/{name}")
+pub fn bin_path(profile: &str, name: &str, target_dir: Option<&str>) -> String {
+    match target_dir {
+        Some(dir) => format!("{}/{}", dir.trim_end_matches('/'), name),
+        None => format!("./target/{profile}/{name}"),
+    }
 }

src/platform/mod.rs

@@ -5,21 +5,24 @@ pub mod macos;
 #[cfg(target_os = "windows")]
 pub mod windows;
 
-pub fn bin_path(profile: &str, name: &str) -> String {
+pub fn bin_path(profile: &str, name: &str, target_dir: Option<&str>) -> String {
     #[cfg(target_os = "linux")]
     {
-        linux::bin_path(profile, name)
+        linux::bin_path(profile, name, target_dir)
     }
     #[cfg(target_os = "macos")]
     {
-        return macos::bin_path(profile, name);
+        return macos::bin_path(profile, name, target_dir);
     }
     #[cfg(target_os = "windows")]
     {
-        return windows::bin_path(profile, name);
+        return windows::bin_path(profile, name, target_dir);
     }
     #[cfg(not(any(target_os = "linux", target_os = "macos", target_os = "windows")))]
     {
-        format!("./target/{profile}/{name}")
+        match target_dir {
+            Some(dir) => format!("{}/{}", dir.trim_end_matches('/'), name),
+            None => format!("./target/{profile}/{name}"),
+        }
     }
 }

src/platform/windows.rs

@@ -1,3 +1,6 @@
-pub fn bin_path(profile: &str, name: &str) -> String {
-    format!("./target/{profile}/{name}.exe")
+pub fn bin_path(profile: &str, name: &str, target_dir: Option<&str>) -> String {
+    match target_dir {
+        Some(dir) => format!("{}/{}.exe", dir.trim_end_matches('/'), name),
+        None => format!("./target/{profile}/{name}.exe"),
+    }
 }