diff --git a/CHANGELOG.md b/CHANGELOG.md index 9d9396a..ae36048 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,17 @@ # Changelog +## [0.2.8] - 2026-03-06 +Added: +- Workspace support (`[workspace]` with deps ordering) +- `clean --all` for workspace members +Changed: +- Project root discovery for `build/run/clean` (searches parent dirs) +- Workspace paths are excluded from root source scan +- Build output now uses a Cargo-style `Compiling v` line +- Build time now reports total time for the whole build stage (workspace included) +- Cache hits are silent (no compile line when nothing is rebuilt) +- Safer build cache: fingerprints include headers and resolved library files + ## [0.2.7] - 2026-03-03 Added: - Toolchain overrides via `[toolchain]` and env (`DCR_*`) diff --git a/Cargo.lock b/Cargo.lock index 0823ec7..b1c80eb 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -90,7 +90,7 @@ dependencies = [ [[package]] name = "dcr" -version = "0.2.7" +version = "0.2.8" dependencies = [ "reqwest", "self-replace", diff --git a/Cargo.toml b/Cargo.toml index ea2030b..5d47866 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "dcr" -version = "0.2.7" +version = "0.2.8" edition = "2024" build = "build.rs" diff --git a/README.md b/README.md index 4dc0d16..8f28830 100644 --- a/README.md +++ b/README.md @@ -113,6 +113,7 @@ Run manually: ### `dcr clean` Removes the `target` directory in the project root. +Use `dcr clean --all` in a workspace root to clean all member projects. ## Build Profiles Two profiles are supported: @@ -157,6 +158,15 @@ ldflags = ["-lm"] [dependencies] ``` +Workspace example: + +```toml +[workspace] +kernel = { path = "src/kernel", deps = ["core", "userspace"] } +core = { path = "src/core", deps = ["userspace"] } +userspace = { path = "src/userspace" } +``` + Path dependencies are supported. DCR will resolve them on build and generate `dcr.lock`. Incremental build note: object files are rebuilt when source `.c/.cpp` files change. Header dependency tracking is not implemented yet. diff --git a/TODO.md b/TODO.md index cc73861..2dafcfe 100644 --- a/TODO.md +++ b/TODO.md @@ -2,6 +2,5 @@ - Add header dependency tracking for incremental builds (GCC/Clang: -MMD, MSVC: /showIncludes) - Add external package managers (Conan, vcpkg) -- Multi-target - Linker script + direct linker control - Custom targets/steps \ No newline at end of file diff --git a/docs/README.md b/docs/README.md index c6a0642..b1a19c0 100644 --- a/docs/README.md +++ b/docs/README.md @@ -24,6 +24,7 @@ Current DCR focuses on a simple, predictable workflow: - `sharedlib` - Optional custom output directory via `build.target`. - Optional `build.platform` to pass architecture hints (`-march` / `/arch`). +- Workspace builds via `[workspace]` with per-project `dcr.toml`. - Path dependencies with include/lib resolution and `dcr.lock` generation. ## Important behavior notes diff --git a/docs/commands/dcr-build.md b/docs/commands/dcr-build.md index 9cbdaf3..40b0d6f 100644 --- a/docs/commands/dcr-build.md +++ b/docs/commands/dcr-build.md @@ -43,3 +43,4 @@ dcr build --release - Unknown profile flags return an error. - Incremental rebuild is based on source/object mtime comparison. - For `language = "asm"` with `compiler = "as"`/`"gas"`, use `.s` files (no preprocessing). For `.S`, use `gcc` or `clang`. +- In workspace root, `dcr build` builds all members in dependency order. diff --git a/docs/commands/dcr-clean.md b/docs/commands/dcr-clean.md index 2da92b8..1ba38f3 100644 --- a/docs/commands/dcr-clean.md +++ b/docs/commands/dcr-clean.md @@ -8,16 +8,18 @@ Removes build artifacts in `target/`. dcr clean dcr clean --debug dcr clean --release +dcr clean --all +dcr clean --release --all ``` ## Behavior - Without arguments: removes entire `target/`. - With profile: removes only `target//`. +- With `--all`: also cleans all workspace members. ## Validation - `dcr.toml` must exist. -- More than one argument is treated as error. -- Unknown profile is treated as error. +- Unknown flags are treated as error. - If `target` or selected profile directory does not exist, command prints a warning. diff --git a/docs/configuration/dcr.toml-overview.md b/docs/configuration/dcr.toml-overview.md index 0383ec5..c411911 100644 --- a/docs/configuration/dcr.toml-overview.md +++ b/docs/configuration/dcr.toml-overview.md @@ -26,6 +26,9 @@ kind = "bin" - `[build]` - `[dependencies]` +Workspace-only root: +- `[workspace]` may be used instead of `[package]`/`[build]` for a workspace root. + ## Required keys - `package.name` @@ -43,3 +46,5 @@ kind = "bin" - `build.cflags` - `build.ldflags` - dependency fields (`include`, `lib`, `libs`, `system`) +- `[toolchain]` overrides (`cc`, `cxx`, `as`, `ar`, `ld`) +- `[workspace]` members diff --git a/docs/getting-started/build-and-run.md b/docs/getting-started/build-and-run.md index ae2c361..2e51494 100644 --- a/docs/getting-started/build-and-run.md +++ b/docs/getting-started/build-and-run.md @@ -37,6 +37,8 @@ Profile-only cleanup: ```sh dcr clean --debug dcr clean --release +dcr clean --all +dcr clean --release --all ``` ## Notes @@ -44,3 +46,4 @@ dcr clean --release - `run` is unavailable for `build.kind = "staticlib"` and `build.kind = "sharedlib"`. - Build profile flag is parsed from the first command argument. - Unknown profile flags produce an error. +- In workspace root, `clean --all` cleans all member projects. diff --git a/docs/reference-and-help/cli-reference.md b/docs/reference-and-help/cli-reference.md index ed71afc..ea93c8c 100644 --- a/docs/reference-and-help/cli-reference.md +++ b/docs/reference-and-help/cli-reference.md @@ -7,7 +7,7 @@ dcr new dcr init dcr build [--debug|--release] dcr run [--debug|--release] -dcr clean [--debug|--release] +dcr clean [--debug|--release] [--all] dcr --help dcr --version dcr --update @@ -18,7 +18,7 @@ dcr --update - Most commands parse profile from the first argument. - `new` requires exactly one argument. - `init` and `--update` do not accept extra arguments. -- `clean` accepts at most one argument. +- `clean` accepts `--debug|--release` and optional `--all`. ## Exit behavior overview diff --git a/docs/reference-and-help/config-reference.md b/docs/reference-and-help/config-reference.md index 9566218..ec9ceef 100644 --- a/docs/reference-and-help/config-reference.md +++ b/docs/reference-and-help/config-reference.md @@ -24,6 +24,9 @@ as = "string" # optional ar = "string" # optional ld = "string" # optional +[workspace] +name = { path = "string", deps = ["string", "..."] } + [dependencies] name = { path = "string", # required for each dependency diff --git a/src/cli/build.rs b/src/cli/build.rs index 133beea..9bf5902 100644 --- a/src/cli/build.rs +++ b/src/cli/build.rs @@ -1,117 +1,41 @@ use crate::config::{PROFILE, flags}; -use crate::core::builder::{BuildContext, build as build_project}; +use crate::core::builder::{BuildContext, build as build_project, collect_sources}; use crate::core::config::Config; use crate::core::deps::resolve_deps; -use crate::utils::fs::check_dir; +use crate::core::workspace::parse_workspace; +use crate::utils::fs::{check_dir, find_project_root}; use crate::utils::log::{error, warn}; use crate::utils::text::{BOLD_GREEN, colored}; +use sha2::{Digest, Sha256}; use std::fs; +use std::path::Path; use std::time::Instant; pub fn build(args: &[String]) -> i32 { - let items = check_dir(None).unwrap_or_default(); - if !items.contains(&"dcr.toml".to_string()) { - error("dcr.toml file not found"); - return 1; - } - - let config = match Config::open("./dcr.toml") { - Ok(cfg) => cfg, + let start_dir = match std::env::current_dir() { + Ok(dir) => dir, Err(_) => { + error("Failed to determine current directory"); + return 1; + } + }; + let root = match find_project_root(&start_dir) { + Ok(Some(dir)) => dir, + Ok(None) => { error("dcr.toml file not found"); return 1; } + Err(_) => { + error("Failed to find project root"); + return 1; + } }; let active_profile = match parse_profile(args) { Ok(profile) => profile, Err(code) => return code, }; - let project_name = get_config_str(&config, "package.name"); - 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_kind = get_config_str(&config, "build.kind"); - let build_platform = get_config_str(&config, "build.platform"); - let tc_cc = get_config_opt(&config, "toolchain.cc"); - let tc_cxx = get_config_opt(&config, "toolchain.cxx"); - let tc_as = get_config_opt(&config, "toolchain.as"); - let tc_ar = get_config_opt(&config, "toolchain.ar"); - let tc_ld = get_config_opt(&config, "toolchain.ld"); - let build_cflags = match get_config_list(&config, "build.cflags") { - Ok(v) => v, - Err(msg) => { - error(&msg); - return 1; - } - }; - let build_ldflags = match get_config_list(&config, "build.ldflags") { - Ok(v) => v, - Err(msg) => { - error(&msg); - return 1; - } - }; - - let resolved_compiler = resolve_compiler( - &build_language, - &project_compiler, - tc_cc.as_deref(), - tc_cxx.as_deref(), - tc_as.as_deref(), - ); - let resolved_linker = resolve_tool("DCR_LD", tc_ld.as_deref()); - let resolved_archiver = resolve_tool("DCR_AR", tc_ar.as_deref()); - - println!( - " Building project `{}`\n Profile: {}\n Compiler: {}\n", - colored(&project_name, BOLD_GREEN), - colored(&active_profile, BOLD_GREEN), - colored(&resolved_compiler, BOLD_GREEN) - ); - - ensure_target_dirs(&items, &active_profile, normalize_target(&build_target)); - - let project_root = match std::env::current_dir() { - Ok(p) => p, - Err(_) => { - error("Failed to determine project root"); - return 1; - } - }; - let resolved = match resolve_deps(&config, &active_profile, &project_root) { - Ok(r) => r, - Err(msg) => { - error(&msg); - return 1; - } - }; - let ctx = BuildContext { - profile: &active_profile, - project_name: &project_name, - compiler: &resolved_compiler, - language: &build_language, - standard: &build_standard, - target_dir: normalize_target(&build_target), - kind: normalize_kind(&build_kind), - platform: normalize_platform(&build_platform), - linker: resolved_linker.as_deref(), - archiver: resolved_archiver.as_deref(), - include_dirs: &resolved.include_dirs, - lib_dirs: &resolved.lib_dirs, - libs: &resolved.libs, - cflags: &build_cflags, - ldflags: &build_ldflags, - }; - match run_build(&ctx) { - Ok(times) => { - println!( - " {} Build completed successfully in {} seconds", - colored("✔", BOLD_GREEN), - colored(×.to_string(), BOLD_GREEN) - ); - 0 - } + match with_dir(&root, || build_from_root(&root, &active_profile)) { + Ok(()) => 0, Err(msg) => { error(&msg); 1 @@ -200,6 +124,136 @@ fn run_build(ctx: &BuildContext) -> Result { } } +fn build_from_root(root: &Path, profile: &str) -> Result<(), String> { + let config = Config::open("./dcr.toml").map_err(|err| err.to_string())?; + let project_name = get_config_str(&config, "package.name"); + let start_time = Instant::now(); + println!( + " Building project `{}`\n Profile: {}", + colored(&project_name, BOLD_GREEN), + colored(profile, BOLD_GREEN) + ); + if let Some(workspace) = parse_workspace(&config, root)? { + build_workspace(&workspace, profile)?; + let excludes: Vec = + workspace.members.iter().map(|m| m.path.clone()).collect(); + build_project_at(root, profile, &excludes)?; + let elapsed = ((start_time.elapsed().as_secs_f64() * 100.0).trunc()) / 100.0; + println!( + " {} Build completed successfully in {} seconds", + colored("✔", BOLD_GREEN), + colored(&elapsed.to_string(), BOLD_GREEN) + ); + return Ok(()); + } + build_project_at(root, profile, &[])?; + let elapsed = ((start_time.elapsed().as_secs_f64() * 100.0).trunc()) / 100.0; + println!( + " {} Build completed successfully in {} seconds", + colored("✔", BOLD_GREEN), + colored(&elapsed.to_string(), BOLD_GREEN) + ); + Ok(()) +} + +fn build_workspace( + workspace: &crate::core::workspace::Workspace, + profile: &str, +) -> Result<(), String> { + for member in &workspace.members { + build_project_at(&member.path, profile, &[])?; + } + Ok(()) +} + +fn build_project_at( + project_root: &Path, + profile: &str, + exclude_dirs: &[std::path::PathBuf], +) -> Result<(), String> { + with_dir(project_root, || { + let items = check_dir(None).map_err(|_| "Failed to read project directory".to_string())?; + if !items.contains(&"dcr.toml".to_string()) { + return Err("dcr.toml file not found".to_string()); + } + let config = Config::open("./dcr.toml").map_err(|err| err.to_string())?; + let project_name = get_config_str(&config, "package.name"); + let project_version = get_config_str(&config, "package.version"); + 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_kind = get_config_str(&config, "build.kind"); + let build_platform = get_config_str(&config, "build.platform"); + let tc_cc = get_config_opt(&config, "toolchain.cc"); + let tc_cxx = get_config_opt(&config, "toolchain.cxx"); + let tc_as = get_config_opt(&config, "toolchain.as"); + let tc_ar = get_config_opt(&config, "toolchain.ar"); + let tc_ld = get_config_opt(&config, "toolchain.ld"); + let build_cflags = get_config_list(&config, "build.cflags")?; + let build_ldflags = get_config_list(&config, "build.ldflags")?; + + let resolved_compiler = resolve_compiler( + &build_language, + &project_compiler, + tc_cc.as_deref(), + tc_cxx.as_deref(), + tc_as.as_deref(), + ); + let resolved_linker = resolve_tool("DCR_LD", tc_ld.as_deref()); + let resolved_archiver = resolve_tool("DCR_AR", tc_ar.as_deref()); + + ensure_target_dirs(&items, profile, normalize_target(&build_target)); + + let resolved = resolve_deps(&config, profile, project_root)?; + let ctx = BuildContext { + profile, + project_name: &project_name, + compiler: &resolved_compiler, + language: &build_language, + standard: &build_standard, + target_dir: normalize_target(&build_target), + kind: normalize_kind(&build_kind), + platform: normalize_platform(&build_platform), + linker: resolved_linker.as_deref(), + archiver: resolved_archiver.as_deref(), + exclude_dirs, + include_dirs: &resolved.include_dirs, + lib_dirs: &resolved.lib_dirs, + libs: &resolved.libs, + cflags: &build_cflags, + ldflags: &build_ldflags, + }; + let sources = collect_sources(&ctx)?; + let headers = collect_header_files(&ctx, project_root)?; + let lib_files = collect_lib_files(&ctx); + let fingerprint = compute_build_fingerprint(&ctx, &sources, &headers, &lib_files)?; + if should_skip_build(&ctx, &fingerprint) { + return Ok(()); + } + println!( + " {} {} v{}", + colored("Compiling", BOLD_GREEN), + project_name, + project_version + ); + run_build(&ctx)?; + write_build_fingerprint(&ctx, &fingerprint)?; + Ok(()) + }) +} + +fn with_dir(dir: &Path, f: F) -> Result +where + F: FnOnce() -> Result, +{ + let prev = std::env::current_dir().map_err(|_| "Failed to get current dir".to_string())?; + std::env::set_current_dir(dir).map_err(|_| "Failed to change directory".to_string())?; + let result = f(); + let _ = std::env::set_current_dir(prev); + result +} + fn normalize_target(target: &str) -> Option<&str> { let trimmed = target.trim(); if trimmed.is_empty() { @@ -295,3 +349,210 @@ fn resolve_tool(env_key: &str, fallback: Option<&str>) -> Option { } fallback.map(|v| v.to_string()) } + +fn compute_build_fingerprint( + ctx: &BuildContext, + sources: &[String], + headers: &[std::path::PathBuf], + lib_files: &[std::path::PathBuf], +) -> Result { + let mut hasher = Sha256::new(); + hasher.update(ctx.profile.as_bytes()); + hasher.update(ctx.project_name.as_bytes()); + hasher.update(ctx.compiler.as_bytes()); + hasher.update(ctx.language.as_bytes()); + hasher.update(ctx.standard.as_bytes()); + hasher.update(ctx.kind.as_bytes()); + if let Some(v) = ctx.target_dir { + hasher.update(v.as_bytes()); + } + if let Some(v) = ctx.platform { + hasher.update(v.as_bytes()); + } + if let Some(v) = ctx.linker { + hasher.update(v.as_bytes()); + } + if let Some(v) = ctx.archiver { + hasher.update(v.as_bytes()); + } + for value in ctx.include_dirs { + hasher.update(value.as_bytes()); + } + for value in ctx.lib_dirs { + hasher.update(value.as_bytes()); + } + for value in ctx.libs { + hasher.update(value.as_bytes()); + } + for value in ctx.cflags { + hasher.update(value.as_bytes()); + } + for value in ctx.ldflags { + hasher.update(value.as_bytes()); + } + let toml = + fs::read_to_string("dcr.toml").map_err(|err| format!("Failed to read dcr.toml: {err}"))?; + hasher.update(toml.as_bytes()); + if let Ok(lock) = fs::read_to_string("dcr.lock") { + hasher.update(lock.as_bytes()); + } + for source in sources { + let path = Path::new(source); + update_hasher_with_file(&mut hasher, path)?; + } + for header in headers { + update_hasher_with_file(&mut hasher, header)?; + } + for lib in lib_files { + update_hasher_with_file(&mut hasher, lib)?; + } + Ok(to_hex(&hasher.finalize())) +} + +fn should_skip_build(ctx: &BuildContext, fingerprint: &str) -> bool { + let output = build_output_path(ctx); + if !Path::new(&output).is_file() { + return false; + } + let cache_path = build_cache_path(ctx.profile, ctx.target_dir); + let cached = fs::read_to_string(cache_path).unwrap_or_default(); + cached.trim() == fingerprint +} + +fn write_build_fingerprint(ctx: &BuildContext, fingerprint: &str) -> Result<(), String> { + let cache_path = build_cache_path(ctx.profile, ctx.target_dir); + if let Some(parent) = cache_path.parent() { + fs::create_dir_all(parent).map_err(|err| format!("Failed to create cache dir: {err}"))?; + } + fs::write(cache_path, format!("{fingerprint}\n")) + .map_err(|err| format!("Failed to write cache: {err}")) +} + +fn build_cache_path(profile: &str, target_dir: Option<&str>) -> std::path::PathBuf { + match target_dir { + Some(dir) => Path::new(dir).join(format!(".dcr-build.{profile}.hash")), + None => Path::new("./target").join(profile).join(".dcr-build.hash"), + } +} + +fn build_output_path(ctx: &BuildContext) -> String { + if ctx.kind == "staticlib" { + return crate::platform::lib_path(ctx.profile, ctx.project_name, ctx.target_dir); + } + if ctx.kind == "sharedlib" { + return crate::platform::shared_lib_path(ctx.profile, ctx.project_name, ctx.target_dir); + } + crate::platform::bin_path(ctx.profile, ctx.project_name, ctx.target_dir) +} + +fn collect_header_files( + ctx: &BuildContext, + project_root: &Path, +) -> Result, String> { + let mut out = Vec::new(); + let mut roots = Vec::new(); + roots.push(project_root.join("src")); + for dir in ctx.include_dirs { + roots.push(Path::new(dir).to_path_buf()); + } + for root in roots { + if !root.exists() { + continue; + } + collect_header_files_rec(&root, &mut out, ctx.exclude_dirs)?; + } + out.sort(); + out.dedup(); + Ok(out) +} + +fn collect_header_files_rec( + dir: &Path, + out: &mut Vec, + exclude_dirs: &[std::path::PathBuf], +) -> Result<(), String> { + if is_excluded(dir, exclude_dirs) { + return Ok(()); + } + for entry in fs::read_dir(dir).map_err(|err| format!("read_dir error: {err}"))? { + let entry = entry.map_err(|err| format!("read_dir error: {err}"))?; + let path = entry.path(); + if path.is_dir() { + if is_excluded(&path, exclude_dirs) { + continue; + } + collect_header_files_rec(&path, out, exclude_dirs)?; + continue; + } + if !path.is_file() { + continue; + } + if is_header_file(&path) { + out.push(path); + } + } + Ok(()) +} + +fn is_header_file(path: &Path) -> bool { + let ext = path.extension().and_then(|v| v.to_str()).unwrap_or(""); + matches!(ext, "h" | "hpp" | "hh" | "hxx" | "inc") +} + +fn collect_lib_files(ctx: &BuildContext) -> Vec { + let mut out = Vec::new(); + for dir in ctx.lib_dirs { + let dir_path = Path::new(dir); + for lib in ctx.libs { + for candidate in lib_candidates(lib) { + let path = dir_path.join(candidate); + if path.is_file() { + out.push(path); + } + } + } + } + out +} + +fn lib_candidates(name: &str) -> Vec { + if cfg!(target_os = "windows") { + return vec![format!("{name}.lib")]; + } + if cfg!(target_os = "macos") { + return vec![ + format!("lib{name}.a"), + format!("lib{name}.dylib"), + format!("lib{name}.so"), + ]; + } + vec![ + format!("lib{name}.a"), + format!("lib{name}.so"), + format!("lib{name}.so.0"), + ] +} + +fn update_hasher_with_file(hasher: &mut Sha256, path: &Path) -> Result<(), String> { + hasher.update(path.to_string_lossy().as_bytes()); + let meta = fs::metadata(path).map_err(|err| format!("source read error: {err}"))?; + hasher.update(meta.len().to_le_bytes()); + if let Ok(modified) = meta.modified() + && let Ok(duration) = modified.duration_since(std::time::UNIX_EPOCH) + { + hasher.update(duration.as_nanos().to_le_bytes()); + } + Ok(()) +} + +fn is_excluded(path: &Path, exclude_dirs: &[std::path::PathBuf]) -> bool { + exclude_dirs.iter().any(|dir| path.starts_with(dir)) +} + +fn to_hex(bytes: &[u8]) -> String { + let mut out = String::with_capacity(bytes.len() * 2); + for b in bytes { + out.push_str(&format!("{:02x}", b)); + } + out +} diff --git a/src/cli/clean.rs b/src/cli/clean.rs index 70ddf4a..7e46f94 100644 --- a/src/cli/clean.rs +++ b/src/cli/clean.rs @@ -1,63 +1,138 @@ use crate::config::flags; -use crate::utils::fs::check_dir; +use crate::core::config::Config; +use crate::core::workspace::parse_workspace; +use crate::utils::fs::{check_dir, find_project_root}; use crate::utils::log::{error, warn}; use crate::utils::text::{BOLD_GREEN, colored}; use std::fs; +use std::path::Path; pub fn clean(args: &[String]) -> i32 { - let project_name = std::env::current_dir() - .ok() - .and_then(|p| p.file_name().map(|v| v.to_string_lossy().to_string())) - .unwrap_or_else(|| "project".to_string()); - let items = check_dir(None).unwrap_or_default(); - - if args.len() > 1 { - error("Unknown argument"); - return 1; - } - if !items.contains(&"dcr.toml".to_string()) { - error("dcr.toml file not found"); - return 1; - } - - println!( - " Cleaning project `{}`", - colored(&project_name, BOLD_GREEN) - ); - if !items.contains(&"target".to_string()) { - warn("Directory target not found"); - return 1; - } - - if let Some(arg) = args.first() { - let mut profile = arg.clone(); - if profile.starts_with("--") { - profile = profile.trim_start_matches("--").to_string(); - } - if flags(&profile).is_none() { - error("Unknown profile"); + let start_dir = match std::env::current_dir() { + Ok(dir) => dir, + Err(_) => { + error("Failed to determine current directory"); return 1; } - - let target_items = check_dir(Some("target")).unwrap_or_default(); - if !target_items.contains(&profile) { - warn(&format!("Directory target/{profile} not found")); + }; + let root = match find_project_root(&start_dir) { + Ok(Some(dir)) => dir, + Ok(None) => { + error("dcr.toml file not found"); return 1; } + Err(_) => { + error("Failed to find project root"); + return 1; + } + }; + let flags = match parse_clean_flags(args) { + Ok(v) => v, + Err(msg) => { + error(&msg); + return 1; + } + }; - println!(" Profile: {}", colored(&profile, BOLD_GREEN)); - let _ = fs::remove_dir_all(format!("target/{profile}")); + match with_dir(&root, || clean_from_root(&root, &flags)) { + Ok(()) => 0, + Err(msg) => { + error(&msg); + 1 + } + } +} + +struct CleanFlags { + profile: Option, + all: bool, +} + +fn parse_clean_flags(args: &[String]) -> Result { + let mut profile: Option = None; + let mut all = false; + for arg in args { + if arg == "--all" { + all = true; + continue; + } + if arg.starts_with("--") { + let candidate = arg.trim_start_matches("--").to_string(); + if flags(&candidate).is_some() { + if profile.is_some() { + return Err("Duplicate profile flag".to_string()); + } + profile = Some(candidate); + continue; + } + } + return Err("Unknown argument".to_string()); + } + Ok(CleanFlags { profile, all }) +} + +fn clean_from_root(root: &Path, flags: &CleanFlags) -> Result<(), String> { + let config = Config::open("./dcr.toml").map_err(|err| err.to_string())?; + if flags.all + && let Some(workspace) = parse_workspace(&config, root)? + { + for member in &workspace.members { + clean_project_at(&member.path, flags.profile.as_deref())?; + } + } + clean_project_at(root, flags.profile.as_deref()) +} + +fn clean_project_at(project_root: &Path, profile: Option<&str>) -> Result<(), String> { + with_dir(project_root, || { + let project_name = std::env::current_dir() + .ok() + .and_then(|p| p.file_name().map(|v| v.to_string_lossy().to_string())) + .unwrap_or_else(|| "project".to_string()); + let items = check_dir(None).map_err(|_| "Failed to read project directory".to_string())?; + if !items.contains(&"dcr.toml".to_string()) { + return Err("dcr.toml file not found".to_string()); + } println!( - "{} Removed directory target/{profile}", + " Cleaning project `{}`", + colored(&project_name, BOLD_GREEN) + ); + if !items.contains(&"target".to_string()) { + warn("Directory target not found"); + return Ok(()); + } + + if let Some(profile) = profile { + let target_items = check_dir(Some("target")).unwrap_or_default(); + if !target_items.contains(&profile.to_string()) { + warn(&format!("Directory target/{profile} not found")); + return Ok(()); + } + println!(" Profile: {}", colored(profile, BOLD_GREEN)); + let _ = fs::remove_dir_all(format!("target/{profile}")); + println!( + "{} Removed directory target/{profile}", + colored("\n ✔", BOLD_GREEN) + ); + return Ok(()); + } + + let _ = fs::remove_dir_all("target"); + println!( + "{} Removed directory target", colored("\n ✔", BOLD_GREEN) ); - return 0; - } - - let _ = fs::remove_dir_all("target"); - println!( - "{} Removed directory target", - colored("\n ✔", BOLD_GREEN) - ); - 0 + Ok(()) + }) +} + +fn with_dir(dir: &Path, f: F) -> Result +where + F: FnOnce() -> Result, +{ + let prev = std::env::current_dir().map_err(|_| "Failed to get current dir".to_string())?; + std::env::set_current_dir(dir).map_err(|_| "Failed to change directory".to_string())?; + let result = f(); + let _ = std::env::set_current_dir(prev); + result } diff --git a/src/cli/run.rs b/src/cli/run.rs index 5b1fe31..dc46d50 100644 --- a/src/cli/run.rs +++ b/src/cli/run.rs @@ -2,25 +2,40 @@ use crate::cli::build::build; use crate::config::{PROFILE, flags}; use crate::core::config::Config; use crate::core::runner::run_binary; -use crate::utils::fs::check_dir; +use crate::utils::fs::find_project_root; use crate::utils::log::{error, warn}; use crate::utils::text::{BOLD_GREEN, colored}; +use std::path::Path; pub fn run(args: &[String]) -> i32 { let mut active_profile = PROFILE.to_string(); - let items = check_dir(None).unwrap_or_default(); - if !items.contains(&"dcr.toml".to_string()) { - error("dcr.toml file not found"); - return 1; - } - - let config = match Config::open("./dcr.toml") { - Ok(cfg) => cfg, + let start_dir = match std::env::current_dir() { + Ok(dir) => dir, Err(_) => { + error("Failed to determine current directory"); + return 1; + } + }; + let root = match find_project_root(&start_dir) { + Ok(Some(dir)) => dir, + Ok(None) => { error("dcr.toml file not found"); return 1; } + Err(_) => { + error("Failed to find project root"); + return 1; + } + }; + let config = match with_dir(&root, || { + Config::open("./dcr.toml").map_err(|err| err.to_string()) + }) { + Ok(cfg) => cfg, + Err(err) => { + error(&err); + return 1; + } }; let project_name: &str = config .get("package.name") @@ -72,3 +87,14 @@ pub fn run(args: &[String]) -> i32 { error("Fix errors in the code to run the project"); 1 } + +fn with_dir(dir: &Path, f: F) -> Result +where + F: FnOnce() -> Result, +{ + let prev = std::env::current_dir().map_err(|_| "Failed to get current dir".to_string())?; + std::env::set_current_dir(dir).map_err(|_| "Failed to change directory".to_string())?; + let result = f(); + let _ = std::env::set_current_dir(prev); + result +} diff --git a/src/core/builder/clang.rs b/src/core/builder/clang.rs index 9caefa2..97136ff 100644 --- a/src/core/builder/clang.rs +++ b/src/core/builder/clang.rs @@ -1,7 +1,7 @@ use crate::core::builder::BuildContext; use crate::platform; use std::fs; -use std::path::Path; +use std::path::{Path, PathBuf}; use std::process::Command; use std::time::Instant; @@ -12,7 +12,7 @@ pub fn build(ctx: &BuildContext) -> Result { ctx.compiler }; let start_time = Instant::now(); - let sources = collect_sources(ctx.language)?; + let sources = collect_sources(ctx.language, ctx.exclude_dirs)?; let obj_dir = Path::new("./target").join(ctx.profile).join("obj"); let objects = build_objects(compiler, &sources, &obj_dir, ctx, "o")?; @@ -76,10 +76,13 @@ pub fn build(ctx: &BuildContext) -> Result { } } -fn collect_sources(language: &str) -> Result, String> { +pub(crate) fn collect_sources( + language: &str, + exclude_dirs: &[PathBuf], +) -> Result, String> { let lang = language.to_lowercase(); let mut sources = Vec::new(); - collect_sources_rec("./src", &lang, &mut sources)?; + collect_sources_rec("./src", &lang, &mut sources, exclude_dirs)?; sources.sort(); if sources.is_empty() { return Err("No source files found in ./src".to_string()); @@ -87,13 +90,32 @@ fn collect_sources(language: &str) -> Result, String> { Ok(sources) } -fn collect_sources_rec(dir: &str, lang: &str, out: &mut Vec) -> Result<(), String> { - let entries = fs::read_dir(dir).map_err(|err| format!("src dir error: {err}"))?; +fn collect_sources_rec( + dir: &str, + lang: &str, + out: &mut Vec, + exclude_dirs: &[PathBuf], +) -> Result<(), String> { + let dir_path = Path::new(dir); + let full_dir = if dir_path.is_absolute() { + dir_path.to_path_buf() + } else { + std::env::current_dir() + .map_err(|err| format!("src dir error: {err}"))? + .join(dir_path) + }; + if is_excluded(&full_dir, exclude_dirs) { + return Ok(()); + } + let entries = fs::read_dir(&full_dir).map_err(|err| format!("src dir error: {err}"))?; for entry in entries { let entry = entry.map_err(|err| format!("src dir error: {err}"))?; let path = entry.path(); if path.is_dir() { - collect_sources_rec(&path.to_string_lossy(), lang, out)?; + if is_excluded(&path, exclude_dirs) { + continue; + } + collect_sources_rec(&path.to_string_lossy(), lang, out, exclude_dirs)?; continue; } if !path.is_file() { @@ -104,7 +126,7 @@ fn collect_sources_rec(dir: &str, lang: &str, out: &mut Vec) -> Result<( .and_then(|v| v.to_str()) .unwrap_or("") .to_lowercase(); - let file = path.to_string_lossy().to_string(); + let file = normalize_source_path(&path); let allowed = (lang == "c" && ext == "c") || ((lang == "c++" || lang == "cpp" || lang == "cxx") && (ext == "cpp" || ext == "cxx" || ext == "cc")) @@ -116,6 +138,22 @@ fn collect_sources_rec(dir: &str, lang: &str, out: &mut Vec) -> Result<( Ok(()) } +fn is_excluded(path: &Path, exclude_dirs: &[PathBuf]) -> bool { + exclude_dirs.iter().any(|dir| path.starts_with(dir)) +} + +fn normalize_source_path(path: &Path) -> String { + if !path.is_absolute() { + return path.to_string_lossy().to_string(); + } + if let Ok(base) = std::env::current_dir() + && let Ok(rel) = path.strip_prefix(&base) + { + return format!("./{}", rel.to_string_lossy()); + } + path.to_string_lossy().to_string() +} + fn default_flags(profile: &str) -> &'static [&'static str] { match profile { "release" => &["-O3", "-DNDEBUG", "-march=native"], diff --git a/src/core/builder/gas.rs b/src/core/builder/gas.rs index cdd4ea6..9a0aded 100644 --- a/src/core/builder/gas.rs +++ b/src/core/builder/gas.rs @@ -1,7 +1,7 @@ use crate::core::builder::BuildContext; use crate::platform; use std::fs; -use std::path::Path; +use std::path::{Path, PathBuf}; use std::process::Command; use std::time::Instant; @@ -15,7 +15,7 @@ pub fn build(ctx: &BuildContext) -> Result { ctx.compiler }; let start_time = Instant::now(); - let sources = collect_sources(ctx.language)?; + let sources = collect_sources(ctx.language, ctx.exclude_dirs)?; let obj_dir = Path::new("./target").join(ctx.profile).join("obj"); let objects = build_objects(assembler, &sources, &obj_dir, ctx, "o")?; @@ -82,10 +82,13 @@ pub fn build(ctx: &BuildContext) -> Result { } } -fn collect_sources(language: &str) -> Result, String> { +pub(crate) fn collect_sources( + language: &str, + exclude_dirs: &[PathBuf], +) -> Result, String> { let lang = language.to_lowercase(); let mut sources = Vec::new(); - collect_sources_rec("./src", &lang, &mut sources)?; + collect_sources_rec("./src", &lang, &mut sources, exclude_dirs)?; sources.sort(); if sources.is_empty() { return Err("No source files found in ./src".to_string()); @@ -93,13 +96,32 @@ fn collect_sources(language: &str) -> Result, String> { Ok(sources) } -fn collect_sources_rec(dir: &str, lang: &str, out: &mut Vec) -> Result<(), String> { - let entries = fs::read_dir(dir).map_err(|err| format!("src dir error: {err}"))?; +fn collect_sources_rec( + dir: &str, + lang: &str, + out: &mut Vec, + exclude_dirs: &[PathBuf], +) -> Result<(), String> { + let dir_path = Path::new(dir); + let full_dir = if dir_path.is_absolute() { + dir_path.to_path_buf() + } else { + std::env::current_dir() + .map_err(|err| format!("src dir error: {err}"))? + .join(dir_path) + }; + if is_excluded(&full_dir, exclude_dirs) { + return Ok(()); + } + let entries = fs::read_dir(&full_dir).map_err(|err| format!("src dir error: {err}"))?; for entry in entries { let entry = entry.map_err(|err| format!("src dir error: {err}"))?; let path = entry.path(); if path.is_dir() { - collect_sources_rec(&path.to_string_lossy(), lang, out)?; + if is_excluded(&path, exclude_dirs) { + continue; + } + collect_sources_rec(&path.to_string_lossy(), lang, out, exclude_dirs)?; continue; } if !path.is_file() { @@ -107,7 +129,7 @@ fn collect_sources_rec(dir: &str, lang: &str, out: &mut Vec) -> Result<( } let ext_raw = path.extension().and_then(|v| v.to_str()).unwrap_or(""); let ext = ext_raw.to_lowercase(); - let file = path.to_string_lossy().to_string(); + let file = normalize_source_path(&path); let allowed = lang == "asm" && ext == "s" && ext_raw == "s"; if allowed { out.push(file); @@ -116,6 +138,22 @@ fn collect_sources_rec(dir: &str, lang: &str, out: &mut Vec) -> Result<( Ok(()) } +fn is_excluded(path: &Path, exclude_dirs: &[PathBuf]) -> bool { + exclude_dirs.iter().any(|dir| path.starts_with(dir)) +} + +fn normalize_source_path(path: &Path) -> String { + if !path.is_absolute() { + return path.to_string_lossy().to_string(); + } + if let Ok(base) = std::env::current_dir() + && let Ok(rel) = path.strip_prefix(&base) + { + return format!("./{}", rel.to_string_lossy()); + } + path.to_string_lossy().to_string() +} + fn build_objects( assembler: &str, sources: &[String], diff --git a/src/core/builder/gcc.rs b/src/core/builder/gcc.rs index 9caefa2..97136ff 100644 --- a/src/core/builder/gcc.rs +++ b/src/core/builder/gcc.rs @@ -1,7 +1,7 @@ use crate::core::builder::BuildContext; use crate::platform; use std::fs; -use std::path::Path; +use std::path::{Path, PathBuf}; use std::process::Command; use std::time::Instant; @@ -12,7 +12,7 @@ pub fn build(ctx: &BuildContext) -> Result { ctx.compiler }; let start_time = Instant::now(); - let sources = collect_sources(ctx.language)?; + let sources = collect_sources(ctx.language, ctx.exclude_dirs)?; let obj_dir = Path::new("./target").join(ctx.profile).join("obj"); let objects = build_objects(compiler, &sources, &obj_dir, ctx, "o")?; @@ -76,10 +76,13 @@ pub fn build(ctx: &BuildContext) -> Result { } } -fn collect_sources(language: &str) -> Result, String> { +pub(crate) fn collect_sources( + language: &str, + exclude_dirs: &[PathBuf], +) -> Result, String> { let lang = language.to_lowercase(); let mut sources = Vec::new(); - collect_sources_rec("./src", &lang, &mut sources)?; + collect_sources_rec("./src", &lang, &mut sources, exclude_dirs)?; sources.sort(); if sources.is_empty() { return Err("No source files found in ./src".to_string()); @@ -87,13 +90,32 @@ fn collect_sources(language: &str) -> Result, String> { Ok(sources) } -fn collect_sources_rec(dir: &str, lang: &str, out: &mut Vec) -> Result<(), String> { - let entries = fs::read_dir(dir).map_err(|err| format!("src dir error: {err}"))?; +fn collect_sources_rec( + dir: &str, + lang: &str, + out: &mut Vec, + exclude_dirs: &[PathBuf], +) -> Result<(), String> { + let dir_path = Path::new(dir); + let full_dir = if dir_path.is_absolute() { + dir_path.to_path_buf() + } else { + std::env::current_dir() + .map_err(|err| format!("src dir error: {err}"))? + .join(dir_path) + }; + if is_excluded(&full_dir, exclude_dirs) { + return Ok(()); + } + let entries = fs::read_dir(&full_dir).map_err(|err| format!("src dir error: {err}"))?; for entry in entries { let entry = entry.map_err(|err| format!("src dir error: {err}"))?; let path = entry.path(); if path.is_dir() { - collect_sources_rec(&path.to_string_lossy(), lang, out)?; + if is_excluded(&path, exclude_dirs) { + continue; + } + collect_sources_rec(&path.to_string_lossy(), lang, out, exclude_dirs)?; continue; } if !path.is_file() { @@ -104,7 +126,7 @@ fn collect_sources_rec(dir: &str, lang: &str, out: &mut Vec) -> Result<( .and_then(|v| v.to_str()) .unwrap_or("") .to_lowercase(); - let file = path.to_string_lossy().to_string(); + let file = normalize_source_path(&path); let allowed = (lang == "c" && ext == "c") || ((lang == "c++" || lang == "cpp" || lang == "cxx") && (ext == "cpp" || ext == "cxx" || ext == "cc")) @@ -116,6 +138,22 @@ fn collect_sources_rec(dir: &str, lang: &str, out: &mut Vec) -> Result<( Ok(()) } +fn is_excluded(path: &Path, exclude_dirs: &[PathBuf]) -> bool { + exclude_dirs.iter().any(|dir| path.starts_with(dir)) +} + +fn normalize_source_path(path: &Path) -> String { + if !path.is_absolute() { + return path.to_string_lossy().to_string(); + } + if let Ok(base) = std::env::current_dir() + && let Ok(rel) = path.strip_prefix(&base) + { + return format!("./{}", rel.to_string_lossy()); + } + path.to_string_lossy().to_string() +} + fn default_flags(profile: &str) -> &'static [&'static str] { match profile { "release" => &["-O3", "-DNDEBUG", "-march=native"], diff --git a/src/core/builder/mod.rs b/src/core/builder/mod.rs index 4ecd2ff..4c442c3 100644 --- a/src/core/builder/mod.rs +++ b/src/core/builder/mod.rs @@ -15,6 +15,7 @@ pub struct BuildContext<'a> { pub platform: Option<&'a str>, pub linker: Option<&'a str>, pub archiver: Option<&'a str>, + pub exclude_dirs: &'a [std::path::PathBuf], pub include_dirs: &'a [String], pub lib_dirs: &'a [String], pub libs: &'a [String], @@ -44,3 +45,26 @@ pub fn build(ctx: &BuildContext) -> Result { } clang::build(ctx) } + +pub fn collect_sources(ctx: &BuildContext) -> Result, String> { + let compiler = ctx.compiler.to_lowercase(); + if compiler.contains("clang-cl") { + return msvc::collect_sources(ctx.language, ctx.exclude_dirs); + } + if compiler == "as" || compiler.contains("gas") { + return gas::collect_sources(ctx.language, ctx.exclude_dirs); + } + if compiler.contains("nasm") { + return nasm::collect_sources(ctx.language, ctx.exclude_dirs); + } + if compiler.contains("gcc") || compiler.contains("g++") { + return gcc::collect_sources(ctx.language, ctx.exclude_dirs); + } + if compiler.contains("clang") || compiler.contains("clang++") { + return clang::collect_sources(ctx.language, ctx.exclude_dirs); + } + if compiler == "cl" || compiler.contains("msvc") { + return msvc::collect_sources(ctx.language, ctx.exclude_dirs); + } + clang::collect_sources(ctx.language, ctx.exclude_dirs) +} diff --git a/src/core/builder/msvc.rs b/src/core/builder/msvc.rs index 9c18d39..9aaa3c1 100644 --- a/src/core/builder/msvc.rs +++ b/src/core/builder/msvc.rs @@ -1,7 +1,7 @@ use crate::core::builder::BuildContext; use crate::platform; use std::fs; -use std::path::Path; +use std::path::{Path, PathBuf}; use std::process::Command; use std::time::Instant; @@ -15,7 +15,7 @@ pub fn build(ctx: &BuildContext) -> Result { return Err("MSVC backend does not support build.language = \"asm\"".to_string()); } let start_time = Instant::now(); - let sources = collect_sources(ctx.language)?; + let sources = collect_sources(ctx.language, ctx.exclude_dirs)?; let obj_dir = Path::new("./target").join(ctx.profile).join("obj"); let objects = build_objects(compiler, &sources, &obj_dir, ctx, "obj")?; @@ -100,10 +100,13 @@ pub fn build(ctx: &BuildContext) -> Result { } } -fn collect_sources(language: &str) -> Result, String> { +pub(crate) fn collect_sources( + language: &str, + exclude_dirs: &[PathBuf], +) -> Result, String> { let lang = language.to_lowercase(); let mut sources = Vec::new(); - collect_sources_rec("./src", &lang, &mut sources)?; + collect_sources_rec("./src", &lang, &mut sources, exclude_dirs)?; sources.sort(); if sources.is_empty() { return Err("No source files found in ./src".to_string()); @@ -111,13 +114,32 @@ fn collect_sources(language: &str) -> Result, String> { Ok(sources) } -fn collect_sources_rec(dir: &str, lang: &str, out: &mut Vec) -> Result<(), String> { - let entries = fs::read_dir(dir).map_err(|err| format!("src dir error: {err}"))?; +fn collect_sources_rec( + dir: &str, + lang: &str, + out: &mut Vec, + exclude_dirs: &[PathBuf], +) -> Result<(), String> { + let dir_path = Path::new(dir); + let full_dir = if dir_path.is_absolute() { + dir_path.to_path_buf() + } else { + std::env::current_dir() + .map_err(|err| format!("src dir error: {err}"))? + .join(dir_path) + }; + if is_excluded(&full_dir, exclude_dirs) { + return Ok(()); + } + let entries = fs::read_dir(&full_dir).map_err(|err| format!("src dir error: {err}"))?; for entry in entries { let entry = entry.map_err(|err| format!("src dir error: {err}"))?; let path = entry.path(); if path.is_dir() { - collect_sources_rec(&path.to_string_lossy(), lang, out)?; + if is_excluded(&path, exclude_dirs) { + continue; + } + collect_sources_rec(&path.to_string_lossy(), lang, out, exclude_dirs)?; continue; } if !path.is_file() { @@ -128,7 +150,7 @@ fn collect_sources_rec(dir: &str, lang: &str, out: &mut Vec) -> Result<( .and_then(|v| v.to_str()) .unwrap_or("") .to_lowercase(); - let file = path.to_string_lossy().to_string(); + let file = normalize_source_path(&path); let allowed = (lang == "c" && ext == "c") || ((lang == "c++" || lang == "cpp" || lang == "cxx") && (ext == "cpp" || ext == "cxx" || ext == "cc")) @@ -140,6 +162,22 @@ fn collect_sources_rec(dir: &str, lang: &str, out: &mut Vec) -> Result<( Ok(()) } +fn is_excluded(path: &Path, exclude_dirs: &[PathBuf]) -> bool { + exclude_dirs.iter().any(|dir| path.starts_with(dir)) +} + +fn normalize_source_path(path: &Path) -> String { + if !path.is_absolute() { + return path.to_string_lossy().to_string(); + } + if let Ok(base) = std::env::current_dir() + && let Ok(rel) = path.strip_prefix(&base) + { + return format!("./{}", rel.to_string_lossy()); + } + path.to_string_lossy().to_string() +} + fn msvc_standard_flag(language: &str, standard: &str) -> Result { let lang = language.to_lowercase(); let std = standard.to_lowercase(); diff --git a/src/core/builder/nasm.rs b/src/core/builder/nasm.rs index 57aa131..db092d6 100644 --- a/src/core/builder/nasm.rs +++ b/src/core/builder/nasm.rs @@ -1,7 +1,7 @@ use crate::core::builder::BuildContext; use crate::platform; use std::fs; -use std::path::Path; +use std::path::{Path, PathBuf}; use std::process::Command; use std::time::Instant; @@ -15,7 +15,7 @@ pub fn build(ctx: &BuildContext) -> Result { ctx.compiler }; let start_time = Instant::now(); - let sources = collect_sources(ctx.language)?; + let sources = collect_sources(ctx.language, ctx.exclude_dirs)?; let obj_dir = Path::new("./target").join(ctx.profile).join("obj"); let objects = build_objects(assembler, &sources, &obj_dir, ctx, "o")?; @@ -82,10 +82,13 @@ pub fn build(ctx: &BuildContext) -> Result { } } -fn collect_sources(language: &str) -> Result, String> { +pub(crate) fn collect_sources( + language: &str, + exclude_dirs: &[PathBuf], +) -> Result, String> { let lang = language.to_lowercase(); let mut sources = Vec::new(); - collect_sources_rec("./src", &lang, &mut sources)?; + collect_sources_rec("./src", &lang, &mut sources, exclude_dirs)?; sources.sort(); if sources.is_empty() { return Err("No source files found in ./src".to_string()); @@ -93,13 +96,32 @@ fn collect_sources(language: &str) -> Result, String> { Ok(sources) } -fn collect_sources_rec(dir: &str, lang: &str, out: &mut Vec) -> Result<(), String> { - let entries = fs::read_dir(dir).map_err(|err| format!("src dir error: {err}"))?; +fn collect_sources_rec( + dir: &str, + lang: &str, + out: &mut Vec, + exclude_dirs: &[PathBuf], +) -> Result<(), String> { + let dir_path = Path::new(dir); + let full_dir = if dir_path.is_absolute() { + dir_path.to_path_buf() + } else { + std::env::current_dir() + .map_err(|err| format!("src dir error: {err}"))? + .join(dir_path) + }; + if is_excluded(&full_dir, exclude_dirs) { + return Ok(()); + } + let entries = fs::read_dir(&full_dir).map_err(|err| format!("src dir error: {err}"))?; for entry in entries { let entry = entry.map_err(|err| format!("src dir error: {err}"))?; let path = entry.path(); if path.is_dir() { - collect_sources_rec(&path.to_string_lossy(), lang, out)?; + if is_excluded(&path, exclude_dirs) { + continue; + } + collect_sources_rec(&path.to_string_lossy(), lang, out, exclude_dirs)?; continue; } if !path.is_file() { @@ -107,7 +129,7 @@ fn collect_sources_rec(dir: &str, lang: &str, out: &mut Vec) -> Result<( } let ext_raw = path.extension().and_then(|v| v.to_str()).unwrap_or(""); let ext = ext_raw.to_lowercase(); - let file = path.to_string_lossy().to_string(); + let file = normalize_source_path(&path); let allowed = lang == "asm" && (ext == "asm" || (ext == "s" && ext_raw == "s")); if allowed { out.push(file); @@ -116,6 +138,22 @@ fn collect_sources_rec(dir: &str, lang: &str, out: &mut Vec) -> Result<( Ok(()) } +fn is_excluded(path: &Path, exclude_dirs: &[PathBuf]) -> bool { + exclude_dirs.iter().any(|dir| path.starts_with(dir)) +} + +fn normalize_source_path(path: &Path) -> String { + if !path.is_absolute() { + return path.to_string_lossy().to_string(); + } + if let Ok(base) = std::env::current_dir() + && let Ok(rel) = path.strip_prefix(&base) + { + return format!("./{}", rel.to_string_lossy()); + } + path.to_string_lossy().to_string() +} + fn build_objects( assembler: &str, sources: &[String], diff --git a/src/core/config.rs b/src/core/config.rs index faf63ee..10abd05 100644 --- a/src/core/config.rs +++ b/src/core/config.rs @@ -115,7 +115,7 @@ impl Config { .and_then(|v| v.as_table()) .ok_or_else(|| ConfigError::Invalid("missing [build]".into()))?; - for key in ["language", "standard", "compiler", "kind"] { + for key in ["language", "standard", "compiler"] { 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"))); @@ -140,10 +140,11 @@ impl Config { } if let Some(kind) = build.get("kind").and_then(|v| v.as_str()) { let kind = kind.trim(); - if kind != "bin" && kind != "staticlib" && kind != "sharedlib" { + if !kind.is_empty() && kind != "bin" && kind != "staticlib" && kind != "sharedlib" { return Err(ConfigError::Invalid("build.kind is invalid".into())); } } + self.validate_workspace()?; Ok(()) } @@ -159,6 +160,39 @@ impl Config { } } +impl Config { + fn validate_workspace(&self) -> Result<(), ConfigError> { + let Some(workspace) = self.get("workspace").and_then(|v| v.as_table()) else { + return Ok(()); + }; + for (name, value) in workspace { + let tbl = value + .as_table() + .ok_or_else(|| ConfigError::Invalid(format!("workspace.{name} must be a table")))?; + let path = tbl.get("path").and_then(|v| v.as_str()).unwrap_or(""); + if path.trim().is_empty() { + return Err(ConfigError::Invalid(format!( + "workspace.{name}.path is empty" + ))); + } + if let Some(deps) = tbl.get("deps") { + let arr = deps.as_array().ok_or_else(|| { + ConfigError::Invalid(format!("workspace.{name}.deps must be array")) + })?; + for item in arr { + let s = item.as_str().unwrap_or(""); + if s.trim().is_empty() { + return Err(ConfigError::Invalid(format!( + "workspace.{name}.deps contains empty value" + ))); + } + } + } + } + Ok(()) + } +} + fn read_toml(path: &Path) -> Result { let content = fs::read_to_string(path)?; Ok(toml::from_str(&content)?) diff --git a/src/core/mod.rs b/src/core/mod.rs index 78f3a00..9fc634e 100644 --- a/src/core/mod.rs +++ b/src/core/mod.rs @@ -2,3 +2,4 @@ pub mod builder; pub mod config; pub mod deps; pub mod runner; +pub mod workspace; diff --git a/src/core/workspace.rs b/src/core/workspace.rs new file mode 100644 index 0000000..d71a6f6 --- /dev/null +++ b/src/core/workspace.rs @@ -0,0 +1,124 @@ +use crate::core::config::Config; +use std::collections::{HashMap, HashSet}; +use std::path::{Path, PathBuf}; +use toml::Value; + +#[derive(Debug, Clone)] +pub struct WorkspaceMember { + pub name: String, + pub path: PathBuf, + pub deps: Vec, +} + +#[derive(Debug, Clone)] +pub struct Workspace { + pub members: Vec, +} + +pub fn parse_workspace(config: &Config, root: &Path) -> Result, String> { + let table = match config.get("workspace").and_then(|v| v.as_table()) { + Some(t) => t, + None => return Ok(None), + }; + + let mut members = Vec::new(); + for (name, value) in table { + let tbl = value + .as_table() + .ok_or_else(|| format!("workspace.{name} must be a table with path and deps"))?; + let path_raw = tbl + .get("path") + .and_then(|v| v.as_str()) + .ok_or_else(|| format!("workspace.{name}.path is required"))?; + let path = resolve_path(root, path_raw)?; + if !path.join("dcr.toml").is_file() { + return Err(format!( + "workspace.{name}.path does not contain dcr.toml: {}", + path.display() + )); + } + let deps = parse_deps(tbl.get("deps"))?; + members.push(WorkspaceMember { + name: name.to_string(), + path, + deps, + }); + } + + let mut ws = Workspace { members }; + ws.members = topo_sort(&ws.members)?; + Ok(Some(ws)) +} + +fn resolve_path(root: &Path, raw: &str) -> Result { + let p = Path::new(raw); + let full = if p.is_absolute() { + p.to_path_buf() + } else { + root.join(p) + }; + Ok(full) +} + +fn parse_deps(value: Option<&Value>) -> Result, String> { + let Some(value) = value else { + return Ok(Vec::new()); + }; + let arr = value + .as_array() + .ok_or_else(|| "workspace deps must be an array of strings".to_string())?; + let mut out = Vec::new(); + for item in arr { + let s = item + .as_str() + .ok_or_else(|| "workspace deps must be an array of strings".to_string())?; + out.push(s.to_string()); + } + Ok(out) +} + +fn topo_sort(members: &[WorkspaceMember]) -> Result, String> { + let mut map = HashMap::new(); + for m in members { + map.insert(m.name.clone(), m.clone()); + } + let mut state: HashMap = HashMap::new(); + let mut order: Vec = Vec::new(); + + for name in map.keys() { + if *state.get(name).unwrap_or(&0) == 0 { + visit(name, &map, &mut state, &mut order)?; + } + } + Ok(order) +} + +fn visit( + name: &str, + map: &HashMap, + state: &mut HashMap, + order: &mut Vec, +) -> Result<(), String> { + match state.get(name).copied().unwrap_or(0) { + 1 => return Err(format!("workspace dependency cycle at {name}")), + 2 => return Ok(()), + _ => {} + } + state.insert(name.to_string(), 1); + let member = map + .get(name) + .ok_or_else(|| format!("unknown workspace member {name}"))?; + let mut seen = HashSet::new(); + for dep in &member.deps { + if !seen.insert(dep) { + continue; + } + if !map.contains_key(dep) { + return Err(format!("workspace dependency '{dep}' not found")); + } + visit(dep, map, state, order)?; + } + state.insert(name.to_string(), 2); + order.push(member.clone()); + Ok(()) +} diff --git a/src/utils/fs.rs b/src/utils/fs.rs index 9b60307..357a318 100644 --- a/src/utils/fs.rs +++ b/src/utils/fs.rs @@ -1,5 +1,5 @@ use std::io; -use std::path::PathBuf; +use std::path::{Path, PathBuf}; #[allow(dead_code)] pub fn check_dir(dir: Option<&str>) -> io::Result> { @@ -16,3 +16,16 @@ pub fn check_dir(dir: Option<&str>) -> io::Result> { Ok(items) } + +pub fn find_project_root(start: &Path) -> io::Result> { + let mut current = start.to_path_buf(); + loop { + if current.join("dcr.toml").is_file() { + return Ok(Some(current)); + } + if !current.pop() { + break; + } + } + Ok(None) +} diff --git a/tests/cli_basic.rs b/tests/cli_basic.rs index 68fb8f1..a1213d5 100644 --- a/tests/cli_basic.rs +++ b/tests/cli_basic.rs @@ -19,25 +19,32 @@ fn bin_path() -> PathBuf { path } -fn unique_temp_dir(prefix: &str) -> PathBuf { +fn unique_sandbox_dir(prefix: &str) -> PathBuf { let pid = std::process::id(); let n = COUNTER.fetch_add(1, Ordering::SeqCst); let now = SystemTime::now() .duration_since(UNIX_EPOCH) .unwrap_or_default() .as_nanos(); - let mut path = std::env::temp_dir(); + let mut path = PathBuf::from(env!("CARGO_MANIFEST_DIR")); + path.push("sandbox"); + path.push("cli-tests"); path.push(format!("dcr_{prefix}_{pid}_{n}_{now}")); std::fs::create_dir_all(&path).expect("failed to create temp dir"); path } fn run_dcr(args: &[&str], cwd: &Path) -> std::process::Output { - Command::new(bin_path()) - .args(args) - .current_dir(cwd) - .output() - .expect("failed to run dcr") + run_dcr_env(args, cwd, &[]) +} + +fn run_dcr_env(args: &[&str], cwd: &Path, envs: &[(&str, &str)]) -> std::process::Output { + let mut cmd = Command::new(bin_path()); + cmd.args(args).current_dir(cwd); + for (k, v) in envs { + cmd.env(k, v); + } + cmd.output().expect("failed to run dcr") } fn ensure_bin_built() { @@ -51,9 +58,23 @@ fn ensure_bin_built() { }); } +fn available_compiler() -> Option<&'static str> { + for candidate in ["clang", "gcc", "cc"] { + let ok = Command::new(candidate) + .arg("--version") + .output() + .map(|o| o.status.success()) + .unwrap_or(false); + if ok { + return Some(candidate); + } + } + None +} + #[test] fn help_and_version_work() { - let dir = unique_temp_dir("help"); + let dir = unique_sandbox_dir("help"); let out = run_dcr(&["--help"], &dir); assert!(out.status.success(), "--help should succeed"); @@ -65,7 +86,7 @@ fn help_and_version_work() { #[test] fn new_creates_project_layout() { - let dir = unique_temp_dir("new"); + let dir = unique_sandbox_dir("new"); let out = run_dcr(&["new", "hello"], &dir); assert!(out.status.success(), "dcr new should succeed"); @@ -80,7 +101,7 @@ fn new_creates_project_layout() { #[test] fn init_and_clean_remove_target() { - let dir = unique_temp_dir("init"); + let dir = unique_sandbox_dir("init"); let out = run_dcr(&["init"], &dir); assert!(out.status.success(), "dcr init should succeed"); @@ -92,3 +113,108 @@ fn init_and_clean_remove_target() { assert!(out.status.success(), "dcr clean should succeed"); assert!(!dir.join("target").exists(), "target should be removed"); } + +#[test] +fn build_run_clean_flags_normal_project() { + let Some(compiler) = available_compiler() else { + eprintln!("no compiler found; skipping build/run test"); + return; + }; + + let dir = unique_sandbox_dir("normal"); + let out = run_dcr(&["init"], &dir); + assert!(out.status.success(), "dcr init should succeed"); + + let envs = [("DCR_COMPILER", compiler)]; + let out = run_dcr_env(&["build"], &dir, &envs); + assert!(out.status.success(), "dcr build should succeed"); + + let out = run_dcr_env(&["build", "--release"], &dir, &envs); + assert!(out.status.success(), "dcr build --release should succeed"); + + let out = run_dcr_env(&["run"], &dir, &envs); + assert!(out.status.success(), "dcr run should succeed"); + let stdout = String::from_utf8_lossy(&out.stdout); + assert!(stdout.contains("Hello World!"), "run output missing"); + + let out = run_dcr_env(&["clean", "--release"], &dir, &envs); + assert!(out.status.success(), "dcr clean --release should succeed"); + assert!( + !dir.join("target").join("release").exists(), + "target/release should be removed" + ); + assert!( + dir.join("target").join("debug").is_dir(), + "target/debug should remain" + ); + + let out = run_dcr_env(&["clean"], &dir, &envs); + assert!(out.status.success(), "dcr clean should succeed"); + assert!(!dir.join("target").exists(), "target should be removed"); +} + +#[test] +fn workspace_build_and_clean_all() { + let Some(compiler) = available_compiler() else { + eprintln!("no compiler found; skipping workspace test"); + return; + }; + + let root = unique_sandbox_dir("workspace"); + let out = run_dcr(&["init"], &root); + assert!(out.status.success(), "root init should succeed"); + + let members = [ + ("userspace", &[][..]), + ("core", &["userspace"][..]), + ("kernel", &["core"][..]), + ]; + for (name, _) in &members { + let member_dir = root.join("src").join(name); + std::fs::create_dir_all(&member_dir).expect("failed to create member dir"); + let out = run_dcr(&["init"], &member_dir); + assert!(out.status.success(), "member init should succeed"); + } + + let workspace_toml = "[package]\nname = \"ws-root\"\nversion = \"0.1.0\"\n\n[build]\nlanguage = \"c\"\nstandard = \"c11\"\ncompiler = \"clang\"\nkind = \"bin\"\n\n[workspace]\nuserspace = { path = \"src/userspace\", deps = [] }\ncore = { path = \"src/core\", deps = [\"userspace\"] }\nkernel = { path = \"src/kernel\", deps = [\"core\"] }\n\n[dependencies]\n"; + std::fs::write(root.join("dcr.toml"), workspace_toml).expect("failed to write root dcr.toml"); + + let envs = [("DCR_COMPILER", compiler)]; + let out = run_dcr_env(&["build"], &root, &envs); + assert!(out.status.success(), "workspace build should succeed"); + + let out = run_dcr_env(&["build"], &root, &envs); + assert!(out.status.success(), "workspace build should succeed"); + + let out = run_dcr_env(&["build", "--release"], &root, &envs); + assert!( + out.status.success(), + "workspace build --release should succeed" + ); + + let out = run_dcr_env(&["clean", "--release", "--all"], &root, &envs); + assert!( + out.status.success(), + "workspace clean --all --release should succeed" + ); + + for (name, _) in &members { + let member = root.join("src").join(name); + assert!( + !member.join("target").join("release").exists(), + "member target/release should be removed" + ); + assert!( + member.join("target").join("debug").exists(), + "member target/debug should remain" + ); + } + assert!( + !root.join("target").join("release").exists(), + "root target/release should be removed" + ); + assert!( + root.join("target").join("debug").exists(), + "root target/debug should remain" + ); +}