dexoron/dcr
1
1
Fork 0
mirror of https://github.com/dexoron/dcr.git synced 2026-10-21 16:39:37 +00:00
Code Issues Packages Projects Releases Wiki Activity

Added:

Browse Source 
- 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 <name> v<version>` 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
This commit is contained in:
Dexoron
2026-03-06 21:58:54 +08:00
parent 617ba85442
commit 4ea6267a88
26 changed files with 1123 additions and 213 deletions
Download Patch File Download Diff File Expand all files Collapse all files

453
src/cli/build.rs
View File

@@ -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(&times.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<f64, String> {
}
}
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<std::path::PathBuf> =
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<F, T>(dir: &Path, f: F) -> Result<T, String>
where
F: FnOnce() -> Result<T, String>,
{
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<String> {
}
fallback.map(|v| v.to_string())
}
fn compute_build_fingerprint(
ctx: &BuildContext,
sources: &[String],
headers: &[std::path::PathBuf],
lib_files: &[std::path::PathBuf],
) -> Result<String, String> {
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<Vec<std::path::PathBuf>, 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<std::path::PathBuf>,
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<std::path::PathBuf> {
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<String> {
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
}

171
src/cli/clean.rs
View File

@@ -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<String>,
all: bool,
}
fn parse_clean_flags(args: &[String]) -> Result<CleanFlags, String> {
let mut profile: Option<String> = 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<F, T>(dir: &Path, f: F) -> Result<T, String>
where
F: FnOnce() -> Result<T, String>,
{
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
}

44
src/cli/run.rs
View File

@@ -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<F, T>(dir: &Path, f: F) -> Result<T, String>
where
F: FnOnce() -> Result<T, String>,
{
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
}

54
src/core/builder/clang.rs
View File

@@ -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<f64, String> {
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<f64, String> {
}
}
fn collect_sources(language: &str) -> Result<Vec<String>, String> {
pub(crate) fn collect_sources(
language: &str,
exclude_dirs: &[PathBuf],
) -> Result<Vec<String>, 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<Vec<String>, String> {
Ok(sources)
}
fn collect_sources_rec(dir: &str, lang: &str, out: &mut Vec<String>) -> 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<String>,
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<String>) -> 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<String>) -> 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"],

54
src/core/builder/gas.rs
View File

@@ -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<f64, String> {
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<f64, String> {
}
}
fn collect_sources(language: &str) -> Result<Vec<String>, String> {
pub(crate) fn collect_sources(
language: &str,
exclude_dirs: &[PathBuf],
) -> Result<Vec<String>, 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<Vec<String>, String> {
Ok(sources)
}
fn collect_sources_rec(dir: &str, lang: &str, out: &mut Vec<String>) -> 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<String>,
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<String>) -> 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<String>) -> 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],

54
src/core/builder/gcc.rs
View File

@@ -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<f64, String> {
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<f64, String> {
}
}
fn collect_sources(language: &str) -> Result<Vec<String>, String> {
pub(crate) fn collect_sources(
language: &str,
exclude_dirs: &[PathBuf],
) -> Result<Vec<String>, 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<Vec<String>, String> {
Ok(sources)
}
fn collect_sources_rec(dir: &str, lang: &str, out: &mut Vec<String>) -> 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<String>,
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<String>) -> 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<String>) -> 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"],

24
src/core/builder/mod.rs
View File

@@ -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<f64, String> {
}
clang::build(ctx)
}
pub fn collect_sources(ctx: &BuildContext) -> Result<Vec<String>, 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)
}

54
src/core/builder/msvc.rs
View File

@@ -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<f64, String> {
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<f64, String> {
}
}
fn collect_sources(language: &str) -> Result<Vec<String>, String> {
pub(crate) fn collect_sources(
language: &str,
exclude_dirs: &[PathBuf],
) -> Result<Vec<String>, 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<Vec<String>, String> {
Ok(sources)
}
fn collect_sources_rec(dir: &str, lang: &str, out: &mut Vec<String>) -> 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<String>,
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<String>) -> 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<String>) -> 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<String, String> {
let lang = language.to_lowercase();
let std = standard.to_lowercase();

54
src/core/builder/nasm.rs
View File

@@ -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<f64, String> {
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<f64, String> {
}
}
fn collect_sources(language: &str) -> Result<Vec<String>, String> {
pub(crate) fn collect_sources(
language: &str,
exclude_dirs: &[PathBuf],
) -> Result<Vec<String>, 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<Vec<String>, String> {
Ok(sources)
}
fn collect_sources_rec(dir: &str, lang: &str, out: &mut Vec<String>) -> 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<String>,
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<String>) -> 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<String>) -> 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],

38
src/core/config.rs
View File

@@ -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<Value, ConfigError> {
let content = fs::read_to_string(path)?;
Ok(toml::from_str(&content)?)

1
src/core/mod.rs
View File

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

124
src/core/workspace.rs Normal file
View File

@@ -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<String>,
}
#[derive(Debug, Clone)]
pub struct Workspace {
pub members: Vec<WorkspaceMember>,
}
pub fn parse_workspace(config: &Config, root: &Path) -> Result<Option<Workspace>, 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<PathBuf, String> {
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<Vec<String>, 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<Vec<WorkspaceMember>, String> {
let mut map = HashMap::new();
for m in members {
map.insert(m.name.clone(), m.clone());
}
let mut state: HashMap<String, u8> = HashMap::new();
let mut order: Vec<WorkspaceMember> = 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<String, WorkspaceMember>,
state: &mut HashMap<String, u8>,
order: &mut Vec<WorkspaceMember>,
) -> 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(())
}

15
src/utils/fs.rs
View File

@@ -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<Vec<String>> {
@@ -16,3 +16,16 @@ pub fn check_dir(dir: Option<&str>) -> io::Result<Vec<String>> {
Ok(items)
}
pub fn find_project_root(start: &Path) -> io::Result<Option<PathBuf>> {
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)
}