mirror of
https://github.com/dexoron/dcr.git
synced 2026-10-21 11:18:36 +00:00
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 <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:
453
src/cli/build.rs
453
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<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
171
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<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
|
||||
}
|
||||
|
||||
@@ -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
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user