Added:

- Incremental builds (object caching by mtime)
- `build.kind` with `staticlib` support
- Custom output directory via `build.target`

src/core/builder/clang.rs

@@ -1,6 +1,7 @@
 use crate::core::builder::BuildContext;
 use crate::platform;
 use std::fs;
+use std::path::Path;
 use std::process::Command;
 use std::time::Instant;
 
@@ -11,13 +12,30 @@ pub fn build(ctx: &BuildContext) -> Result<f64, String> {
         ctx.compiler
     };
     let start_time = Instant::now();
-    let mut cmd = Command::new(compiler);
     let sources = collect_sources(ctx.language)?;
-    for source in &sources {
-        cmd.arg(source);
+    let obj_dir = Path::new("./target").join(ctx.profile).join("obj");
+    let objects = build_objects(compiler, &sources, &obj_dir, ctx, "o")?;
+
+    if ctx.kind == "staticlib" {
+        let lib_path = platform::lib_path(ctx.profile, ctx.project_name, ctx.target_dir);
+        let mut cmd = Command::new("ar");
+        cmd.arg("rcs").arg(&lib_path);
+        for obj in &objects {
+            cmd.arg(obj);
+        }
+        match cmd.status() {
+            Ok(status) if status.success() => {
+                let elapsed = ((start_time.elapsed().as_secs_f64() * 100.0).trunc()) / 100.0;
+                return Ok(elapsed);
+            }
+            Ok(_) => return Err("Build failed".to_string()),
+            Err(err) => return Err(format!("Build failed: {err}")),
+        }
     }
-    if !ctx.standard.is_empty() {
-        cmd.arg(format!("-std={}", ctx.standard));
+
+    let mut cmd = Command::new(compiler);
+    for obj in &objects {
+        cmd.arg(obj);
     }
     for flag in default_flags(ctx.profile) {
         cmd.arg(flag);
@@ -25,9 +43,6 @@ pub fn build(ctx: &BuildContext) -> Result<f64, String> {
     for flag in ctx.cflags {
         cmd.arg(flag);
     }
-    for dir in ctx.include_dirs {
-        cmd.arg(format!("-I{dir}"));
-    }
     for dir in ctx.lib_dirs {
         cmd.arg(format!("-L{dir}"));
     }
@@ -106,3 +121,63 @@ fn default_flags(profile: &str) -> &'static [&'static str] {
         _ => &[],
     }
 }
+
+fn build_objects(
+    compiler: &str,
+    sources: &[String],
+    obj_dir: &Path,
+    ctx: &BuildContext,
+    obj_ext: &str,
+) -> Result<Vec<String>, String> {
+    let mut objects = Vec::new();
+    for source in sources {
+        let obj_path = object_path(obj_dir, source, obj_ext);
+        if let Some(parent) = Path::new(&obj_path).parent() {
+            fs::create_dir_all(parent).map_err(|err| format!("obj dir error: {err}"))?;
+        }
+        if needs_rebuild(source, &obj_path) {
+            let mut cmd = Command::new(compiler);
+            cmd.arg("-c").arg(source).arg("-o").arg(&obj_path);
+            if !ctx.standard.is_empty() {
+                cmd.arg(format!("-std={}", ctx.standard));
+            }
+            for flag in default_flags(ctx.profile) {
+                cmd.arg(flag);
+            }
+            for flag in ctx.cflags {
+                cmd.arg(flag);
+            }
+            for dir in ctx.include_dirs {
+                cmd.arg(format!("-I{dir}"));
+            }
+            match cmd.status() {
+                Ok(status) if status.success() => {}
+                Ok(_) => return Err("Build failed".to_string()),
+                Err(err) => return Err(format!("Build failed: {err}")),
+            }
+        }
+        objects.push(obj_path);
+    }
+    Ok(objects)
+}
+
+fn object_path(obj_dir: &Path, source: &str, obj_ext: &str) -> String {
+    let src_path = Path::new(source);
+    let rel = src_path
+        .strip_prefix("./src")
+        .or_else(|_| src_path.strip_prefix("src"))
+        .unwrap_or(src_path);
+    let mut out = obj_dir.join(rel);
+    out.set_extension(obj_ext.trim_start_matches('.'));
+    out.to_string_lossy().to_string()
+}
+
+fn needs_rebuild(source: &str, object: &str) -> bool {
+    let src_time = fs::metadata(source).and_then(|m| m.modified());
+    let obj_time = fs::metadata(object).and_then(|m| m.modified());
+    match (src_time, obj_time) {
+        (Ok(s), Ok(o)) => s > o,
+        (Ok(_), Err(_)) => true,
+        _ => true,
+    }
+}

src/core/builder/gcc.rs

@@ -1,6 +1,7 @@
 use crate::core::builder::BuildContext;
 use crate::platform;
 use std::fs;
+use std::path::Path;
 use std::process::Command;
 use std::time::Instant;
 
@@ -11,13 +12,30 @@ pub fn build(ctx: &BuildContext) -> Result<f64, String> {
         ctx.compiler
     };
     let start_time = Instant::now();
-    let mut cmd = Command::new(compiler);
     let sources = collect_sources(ctx.language)?;
-    for source in &sources {
-        cmd.arg(source);
+    let obj_dir = Path::new("./target").join(ctx.profile).join("obj");
+    let objects = build_objects(compiler, &sources, &obj_dir, ctx, "o")?;
+
+    if ctx.kind == "staticlib" {
+        let lib_path = platform::lib_path(ctx.profile, ctx.project_name, ctx.target_dir);
+        let mut cmd = Command::new("ar");
+        cmd.arg("rcs").arg(&lib_path);
+        for obj in &objects {
+            cmd.arg(obj);
+        }
+        match cmd.status() {
+            Ok(status) if status.success() => {
+                let elapsed = ((start_time.elapsed().as_secs_f64() * 100.0).trunc()) / 100.0;
+                return Ok(elapsed);
+            }
+            Ok(_) => return Err("Build failed".to_string()),
+            Err(err) => return Err(format!("Build failed: {err}")),
+        }
     }
-    if !ctx.standard.is_empty() {
-        cmd.arg(format!("-std={}", ctx.standard));
+
+    let mut cmd = Command::new(compiler);
+    for obj in &objects {
+        cmd.arg(obj);
     }
     for flag in default_flags(ctx.profile) {
         cmd.arg(flag);
@@ -25,9 +43,6 @@ pub fn build(ctx: &BuildContext) -> Result<f64, String> {
     for flag in ctx.cflags {
         cmd.arg(flag);
     }
-    for dir in ctx.include_dirs {
-        cmd.arg(format!("-I{dir}"));
-    }
     for dir in ctx.lib_dirs {
         cmd.arg(format!("-L{dir}"));
     }
@@ -106,3 +121,63 @@ fn default_flags(profile: &str) -> &'static [&'static str] {
         _ => &[],
     }
 }
+
+fn build_objects(
+    compiler: &str,
+    sources: &[String],
+    obj_dir: &Path,
+    ctx: &BuildContext,
+    obj_ext: &str,
+) -> Result<Vec<String>, String> {
+    let mut objects = Vec::new();
+    for source in sources {
+        let obj_path = object_path(obj_dir, source, obj_ext);
+        if let Some(parent) = Path::new(&obj_path).parent() {
+            fs::create_dir_all(parent).map_err(|err| format!("obj dir error: {err}"))?;
+        }
+        if needs_rebuild(source, &obj_path) {
+            let mut cmd = Command::new(compiler);
+            cmd.arg("-c").arg(source).arg("-o").arg(&obj_path);
+            if !ctx.standard.is_empty() {
+                cmd.arg(format!("-std={}", ctx.standard));
+            }
+            for flag in default_flags(ctx.profile) {
+                cmd.arg(flag);
+            }
+            for flag in ctx.cflags {
+                cmd.arg(flag);
+            }
+            for dir in ctx.include_dirs {
+                cmd.arg(format!("-I{dir}"));
+            }
+            match cmd.status() {
+                Ok(status) if status.success() => {}
+                Ok(_) => return Err("Build failed".to_string()),
+                Err(err) => return Err(format!("Build failed: {err}")),
+            }
+        }
+        objects.push(obj_path);
+    }
+    Ok(objects)
+}
+
+fn object_path(obj_dir: &Path, source: &str, obj_ext: &str) -> String {
+    let src_path = Path::new(source);
+    let rel = src_path
+        .strip_prefix("./src")
+        .or_else(|_| src_path.strip_prefix("src"))
+        .unwrap_or(src_path);
+    let mut out = obj_dir.join(rel);
+    out.set_extension(obj_ext.trim_start_matches('.'));
+    out.to_string_lossy().to_string()
+}
+
+fn needs_rebuild(source: &str, object: &str) -> bool {
+    let src_time = fs::metadata(source).and_then(|m| m.modified());
+    let obj_time = fs::metadata(object).and_then(|m| m.modified());
+    match (src_time, obj_time) {
+        (Ok(s), Ok(o)) => s > o,
+        (Ok(_), Err(_)) => true,
+        _ => true,
+    }
+}

src/core/builder/mod.rs

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

src/core/builder/msvc.rs

@@ -1,6 +1,7 @@
 use crate::core::builder::BuildContext;
 use crate::platform;
 use std::fs;
+use std::path::Path;
 use std::process::Command;
 use std::time::Instant;
 
@@ -11,9 +12,28 @@ pub fn build(ctx: &BuildContext) -> Result<f64, String> {
         ctx.compiler
     };
     let start_time = Instant::now();
-    let mut cmd = Command::new(compiler);
     let sources = collect_sources(ctx.language)?;
+    let obj_dir = Path::new("./target").join(ctx.profile).join("obj");
+    let objects = build_objects(compiler, &sources, &obj_dir, ctx, "obj")?;
 
+    if ctx.kind == "staticlib" {
+        let lib_path = platform::lib_path(ctx.profile, ctx.project_name, ctx.target_dir);
+        let mut cmd = Command::new("lib");
+        cmd.arg("/nologo").arg(format!("/OUT:{lib_path}"));
+        for obj in &objects {
+            cmd.arg(obj);
+        }
+        match cmd.status() {
+            Ok(status) if status.success() => {
+                let elapsed = ((start_time.elapsed().as_secs_f64() * 100.0).trunc()) / 100.0;
+                return Ok(elapsed);
+            }
+            Ok(_) => return Err("Build failed".to_string()),
+            Err(err) => return Err(format!("Build failed: {err}")),
+        }
+    }
+
+    let mut cmd = Command::new(compiler);
     cmd.arg("/nologo");
     match ctx.language.to_lowercase().as_str() {
         "c" => {
@@ -32,15 +52,15 @@ pub fn build(ctx: &BuildContext) -> Result<f64, String> {
         cmd.arg(std_flag);
     }
 
+    for obj in &objects {
+        cmd.arg(obj);
+    }
     for flag in default_flags(ctx.profile) {
         cmd.arg(flag);
     }
     for flag in ctx.cflags {
         cmd.arg(flag);
     }
-    for dir in ctx.include_dirs {
-        cmd.arg(format!("/I{dir}"));
-    }
     for dir in ctx.lib_dirs {
         cmd.arg(format!("/LIBPATH:{dir}"));
     }
@@ -57,10 +77,6 @@ pub fn build(ctx: &BuildContext) -> Result<f64, String> {
             cmd.arg(flag);
         }
     }
-
-    for source in &sources {
-        cmd.arg(source);
-    }
     cmd.arg(format!(
         "/Fe:{}",
         platform::bin_path(ctx.profile, ctx.project_name, ctx.target_dir)
@@ -145,3 +161,76 @@ fn default_flags(profile: &str) -> &'static [&'static str] {
         _ => &[],
     }
 }
+
+fn build_objects(
+    compiler: &str,
+    sources: &[String],
+    obj_dir: &Path,
+    ctx: &BuildContext,
+    obj_ext: &str,
+) -> Result<Vec<String>, String> {
+    let mut objects = Vec::new();
+    for source in sources {
+        let obj_path = object_path(obj_dir, source, obj_ext);
+        if let Some(parent) = Path::new(&obj_path).parent() {
+            fs::create_dir_all(parent).map_err(|err| format!("obj dir error: {err}"))?;
+        }
+        if needs_rebuild(source, &obj_path) {
+            let mut cmd = Command::new(compiler);
+            cmd.arg("/nologo");
+            match ctx.language.to_lowercase().as_str() {
+                "c" => {
+                    cmd.arg("/TC");
+                }
+                "c++" | "cpp" | "cxx" => {
+                    cmd.arg("/TP");
+                }
+                _ => {
+                    return Err("Unsupported language".to_string());
+                }
+            }
+            if !ctx.standard.is_empty() {
+                let std_flag = msvc_standard_flag(ctx.language, ctx.standard)?;
+                cmd.arg(std_flag);
+            }
+            for flag in default_flags(ctx.profile) {
+                cmd.arg(flag);
+            }
+            for flag in ctx.cflags {
+                cmd.arg(flag);
+            }
+            for dir in ctx.include_dirs {
+                cmd.arg(format!("/I{dir}"));
+            }
+            cmd.arg("/c").arg(source).arg(format!("/Fo:{}", obj_path));
+            match cmd.status() {
+                Ok(status) if status.success() => {}
+                Ok(_) => return Err("Build failed".to_string()),
+                Err(err) => return Err(format!("Build failed: {err}")),
+            }
+        }
+        objects.push(obj_path);
+    }
+    Ok(objects)
+}
+
+fn object_path(obj_dir: &Path, source: &str, obj_ext: &str) -> String {
+    let src_path = Path::new(source);
+    let rel = src_path
+        .strip_prefix("./src")
+        .or_else(|_| src_path.strip_prefix("src"))
+        .unwrap_or(src_path);
+    let mut out = obj_dir.join(rel);
+    out.set_extension(obj_ext.trim_start_matches('.'));
+    out.to_string_lossy().to_string()
+}
+
+fn needs_rebuild(source: &str, object: &str) -> bool {
+    let src_time = fs::metadata(source).and_then(|m| m.modified());
+    let obj_time = fs::metadata(object).and_then(|m| m.modified());
+    match (src_time, obj_time) {
+        (Ok(s), Ok(o)) => s > o,
+        (Ok(_), Err(_)) => true,
+        _ => true,
+    }
+}

src/core/config.rs

@@ -7,6 +7,7 @@ const DEFAULT_VERSION: &str = "0.1.0";
 const DEFAULT_LANGUAGE: &str = "c";
 const DEFAULT_STANDARD: &str = "c11";
 const DEFAULT_COMPILER: &str = "clang";
+const DEFAULT_KIND: &str = "bin";
 
 #[derive(Debug)]
 pub enum ConfigError {
@@ -114,12 +115,18 @@ impl Config {
             .and_then(|v| v.as_table())
             .ok_or_else(|| ConfigError::Invalid("missing [build]".into()))?;
 
-        for key in ["language", "standard", "compiler"] {
+        for key in ["language", "standard", "compiler", "kind"] {
             let value = build.get(key).and_then(|v| v.as_str()).unwrap_or("");
             if value.trim().is_empty() {
                 return Err(ConfigError::Invalid(format!("build.{key} is empty")));
             }
         }
+        if let Some(kind) = build.get("kind").and_then(|v| v.as_str()) {
+            let kind = kind.trim();
+            if kind != "bin" && kind != "staticlib" {
+                return Err(ConfigError::Invalid("build.kind is invalid".into()));
+            }
+        }
         Ok(())
     }
 
@@ -171,6 +178,7 @@ fn default_toml() -> Result<Value, ConfigError> {
         "compiler".to_string(),
         Value::String(DEFAULT_COMPILER.to_string()),
     );
+    build.insert("kind".to_string(), Value::String(DEFAULT_KIND.to_string()));
 
     let mut root = Map::new();
     root.insert("package".to_string(), Value::Table(package));
@@ -217,6 +225,11 @@ fn format_toml(value: &Value) -> Result<String, ConfigError> {
     out.push_str(&format!("language = \"{language}\"\n"));
     out.push_str(&format!("standard = \"{standard}\"\n"));
     out.push_str(&format!("compiler = \"{compiler}\"\n"));
+    let kind = build
+        .get("kind")
+        .and_then(|v| v.as_str())
+        .unwrap_or(DEFAULT_KIND);
+    out.push_str(&format!("kind = \"{kind}\"\n"));
     if let Some(target) = build.get("target").and_then(|v| v.as_str())
         && !target.trim().is_empty()
     {

src/core/mod.rs

@@ -1,3 +1,4 @@
 pub mod builder;
 pub mod config;
 pub mod deps;
+pub mod runner;

src/core/runner.rs

@@ -0,0 +1,37 @@
+use crate::platform;
+use crate::utils::fs::check_dir;
+use crate::utils::log::warn;
+use std::path::Path;
+use std::process::Command;
+
+pub fn run_binary(project_name: &str, profile: &str, target_dir: Option<&str>) -> i32 {
+    let bin_path = platform::bin_path(profile, project_name, target_dir);
+    if Path::new(&bin_path).exists() {
+        return Command::new(bin_path)
+            .status()
+            .map(|status| status.code().unwrap_or(1))
+            .unwrap_or(1);
+    }
+
+    if target_dir.is_none()
+        && check_dir(Some(&format!("target/{profile}")))
+            .unwrap_or_default()
+            .contains(&profile.to_string())
+    {
+        warn("Launch of the latest release");
+        return Command::new(platform::bin_path(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);
+    }
+
+    1
+}