From debc5d20449503bdf6411b093bf9db4e0bc45a03 Mon Sep 17 00:00:00 2001 From: Dexoron Date: Tue, 12 May 2026 01:29:26 +0800 Subject: [PATCH] =?UTF-8?q?Added:=20-=20Full=20Git=20dependency=20support?= =?UTF-8?q?=20in=20`dcr.toml`=20=20=20-=20Support=20for=20`git`,=20`branch?= =?UTF-8?q?`,=20`tag`,=20and=20`rev`=20fields=20=20=20-=20Automatic=20clon?= =?UTF-8?q?ing=20and=20checkout=20via=20`git2`=20=20=20-=20Dependencies=20?= =?UTF-8?q?are=20stored=20in=20`target//deps/git/`=20-=20New=20`d?= =?UTF-8?q?cr=20add`=20command=20for=20easy=20dependency=20management=20?= =?UTF-8?q?=20=20-=20Short=20syntax:=20`github:user/repo`,=20`gitlab:user/?= =?UTF-8?q?repo`,=20`path:/to/lib`=20=20=20-=20Automatic=20GitHub=20resolu?= =?UTF-8?q?tion=20for=20`git:user/repo`=20-=20Visual=20feedback=20for=20de?= =?UTF-8?q?pendency=20fetching=20with=20in-place=20status=20updates=20("Fe?= =?UTF-8?q?tching"=20=E2=86=92=20"Fetched")=20-=20Modular=20dependency=20m?= =?UTF-8?q?anagement=20architecture=20in=20`src/core/deps/`?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- CHANGELOG.md | 14 + Cargo.lock | 151 ++++++- Cargo.toml | 5 +- README.md | 16 +- TODO.md | 6 +- docs/SUMMARY.md | 1 + docs/commands/dcr-add.md | 32 ++ .../dependency-format.md | 22 +- src/cli/add.rs | 199 +++++++++ src/cli/mod.rs | 1 + src/core/config.rs | 12 + src/core/deps.rs | 390 ------------------ src/core/deps/common.rs | 99 +++++ src/core/deps/git.rs | 52 +++ src/core/deps/lock.rs | 114 +++++ src/core/deps/mod.rs | 286 +++++++++++++ src/main.rs | 1 + tests/cli_basic.rs | 59 +++ 18 files changed, 1059 insertions(+), 401 deletions(-) create mode 100644 docs/commands/dcr-add.md create mode 100644 src/cli/add.rs delete mode 100644 src/core/deps.rs create mode 100644 src/core/deps/common.rs create mode 100644 src/core/deps/git.rs create mode 100644 src/core/deps/lock.rs create mode 100644 src/core/deps/mod.rs diff --git a/CHANGELOG.md b/CHANGELOG.md index 239992d..48b118f 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,19 @@ # Changelog +## [0.6.0] - 2026-05-12 + +Added: + +- Full Git dependency support in `dcr.toml` + - Support for `git`, `branch`, `tag`, and `rev` fields + - Automatic cloning and checkout via `git2` + - Dependencies are stored in `target//deps/git/` +- New `dcr add` command for easy dependency management + - Short syntax: `github:user/repo`, `gitlab:user/repo`, `path:/to/lib` + - Automatic GitHub resolution for `git:user/repo` +- Visual feedback for dependency fetching with in-place status updates ("Fetching" → "Fetched") +- Modular dependency management architecture in `src/core/deps/` + ## [0.5.1] - 2026-04-12 Fixed: diff --git a/Cargo.lock b/Cargo.lock index 04ee09c..4becb97 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -54,6 +54,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "aebf35691d1bfb0ac386a69bac2fde4dd276fb618cf8bf4f5318fe285e821bb2" dependencies = [ "find-msvc-tools", + "jobserver", + "libc", "shlex", ] @@ -69,6 +71,18 @@ version = "0.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724" +[[package]] +name = "console" +version = "0.16.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d64e8af5551369d19cf50138de61f1c42074ab970f74e99be916646777f8fc87" +dependencies = [ + "encode_unicode", + "libc", + "unicode-width", + "windows-sys 0.61.2", +] + [[package]] name = "cpufeatures" version = "0.2.17" @@ -90,9 +104,12 @@ dependencies = [ [[package]] name = "dcr" -version = "0.5.1" +version = "0.6.0" dependencies = [ + "console", + "git2", "glob", + "indicatif", "reqwest", "self-replace", "serde", @@ -121,6 +138,12 @@ dependencies = [ "syn", ] +[[package]] +name = "encode_unicode" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "34aa73646ffb006b8f5147f3dc182bd4bcb190227ce861fc4a4844bf8e3cb2c0" + [[package]] name = "equivalent" version = "1.0.2" @@ -263,6 +286,21 @@ dependencies = [ "wasip3", ] +[[package]] +name = "git2" +version = "0.20.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7b88256088d75a56f8ecfa070513a775dd9107f6530ef14919dac831af9cfe2b" +dependencies = [ + "bitflags", + "libc", + "libgit2-sys", + "log", + "openssl-probe", + "openssl-sys", + "url", +] + [[package]] name = "glob" version = "0.3.3" @@ -510,6 +548,19 @@ dependencies = [ "serde_core", ] +[[package]] +name = "indicatif" +version = "0.18.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "25470f23803092da7d239834776d653104d551bc4d7eacaf31e6837854b8e9eb" +dependencies = [ + "console", + "portable-atomic", + "unicode-width", + "unit-prefix", + "web-time", +] + [[package]] name = "ipnet" version = "2.11.0" @@ -532,6 +583,16 @@ version = "1.0.17" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "92ecc6618181def0457392ccd0ee51198e065e016d1d527a7ac1b6dc7c1f09d2" +[[package]] +name = "jobserver" +version = "0.1.34" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9afb3de4395d6b3e67a780b6de64b51c978ecf11cb9a462c66be7d4ca9039d33" +dependencies = [ + "getrandom 0.3.4", + "libc", +] + [[package]] name = "js-sys" version = "0.3.85" @@ -554,6 +615,46 @@ version = "0.2.182" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6800badb6cb2082ffd7b6a67e6125bb39f18782f793520caee8cb8846be06112" +[[package]] +name = "libgit2-sys" +version = "0.18.4+1.9.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9b26f66f35e1871b22efcf7191564123d2a446ca0538cde63c23adfefa9b15b7" +dependencies = [ + "cc", + "libc", + "libssh2-sys", + "libz-sys", + "openssl-sys", + "pkg-config", +] + +[[package]] +name = "libssh2-sys" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "220e4f05ad4a218192533b300327f5150e809b54c4ec83b5a1d91833601811b9" +dependencies = [ + "cc", + "libc", + "libz-sys", + "openssl-sys", + "pkg-config", + "vcpkg", +] + +[[package]] +name = "libz-sys" +version = "1.1.28" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fc3a226e576f50782b3305c5ccf458698f92798987f551c6a02efe8276721e22" +dependencies = [ + "cc", + "libc", + "pkg-config", + "vcpkg", +] + [[package]] name = "linux-raw-sys" version = "0.11.0" @@ -601,6 +702,24 @@ version = "1.21.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d" +[[package]] +name = "openssl-probe" +version = "0.1.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d05e27ee213611ffe7d6348b942e8f942b37114c00cc03cec254295a4a17852e" + +[[package]] +name = "openssl-sys" +version = "0.9.115" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "158fe5b292746440aa6e7a7e690e55aeb72d41505e2804c23c6973ad0e9c9781" +dependencies = [ + "cc", + "libc", + "pkg-config", + "vcpkg", +] + [[package]] name = "percent-encoding" version = "2.3.2" @@ -619,6 +738,18 @@ version = "0.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184" +[[package]] +name = "pkg-config" +version = "0.3.33" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "19f132c84eca552bf34cab8ec81f1c1dcc229b811638f9d283dceabe58c5569e" + +[[package]] +name = "portable-atomic" +version = "1.13.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c33a9471896f1c69cecef8d20cbe2f7accd12527ce60845ff44c153bb2a21b49" + [[package]] name = "potential_utf" version = "0.1.4" @@ -1241,12 +1372,24 @@ version = "1.0.24" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75" +[[package]] +name = "unicode-width" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b4ac048d71ede7ee76d585517add45da530660ef4390e49b098733c6e897f254" + [[package]] name = "unicode-xid" version = "0.2.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853" +[[package]] +name = "unit-prefix" +version = "0.5.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "81e544489bf3d8ef66c953931f56617f423cd4b5494be343d9b9d3dda037b9a3" + [[package]] name = "untrusted" version = "0.9.0" @@ -1271,6 +1414,12 @@ version = "1.0.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be" +[[package]] +name = "vcpkg" +version = "0.2.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426" + [[package]] name = "version_check" version = "0.9.5" diff --git a/Cargo.toml b/Cargo.toml index 4b46476..1d9ac31 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "dcr" -version = "0.5.1" +version = "0.6.0" edition = "2024" build = "build.rs" @@ -11,3 +11,6 @@ serde = { version = "1", features = ["derive"] } self-replace = "1" sha2 = "0.10" toml = "1.0.3" +indicatif = "0.18.4" +console = "0.16.3" +git2 = "0.20.4" diff --git a/README.md b/README.md index 5cce7b7..03413f8 100644 --- a/README.md +++ b/README.md @@ -17,6 +17,7 @@ The current implementation is written in Rust. - Generate IDE integration files (VS Code, CLion) and compilation databases - Generate a minimal C project template - Build static and shared libraries +- Git and Path dependency support with `dcr.lock` and automatic resolution - ASM projects with NASM/GAS or via GCC/Clang - Mixed language projects (`language = ["c", "asm"]` and similar) - Cross-compilation with `--target` (short names: `linux`, `macos`, `windows`) @@ -106,6 +107,11 @@ Creates a project with the specified name in the current directory. ### `dcr init` Creates a project in the current directory. The project name is taken from the directory name. The directory must be empty. +### `dcr add ` +Adds a dependency to `dcr.toml`. +Sources can be `path:`, `github:`, `gitlab:`, `git:`, or a full URL. +Use `--branch`, `--tag`, or `--rev` for Git dependencies. + ### `dcr build [profile]` Builds the project. If no profile is specified, `--debug` is used. Use `--force` to rebuild without cache, `--clean` to clean before build. @@ -211,20 +217,22 @@ ldflags = ["-lm"] # rcc = "rcc" [dependencies] +my_lib = "path:./libs/my_lib" +cool_lib = { git = "https://github.com/user/cool_lib", tag = "v1.0" } ``` 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`. +Git and 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` or included header files change. -Incremental build note: object files are rebuilt when source `.c/.cpp` files change. Header dependency tracking is not implemented yet. ## Requirements - Rust toolchain (`rustc`, `cargo`) - for building DCR from source diff --git a/TODO.md b/TODO.md index b09daf0..19655f2 100644 --- a/TODO.md +++ b/TODO.md @@ -4,12 +4,16 @@ Priority list of tasks to turn DCR into a true Cargo killer for C/C++ developers ## 🔥 High Priority (Next Releases) -- [ ] **Git dependencies support** +- [x] **Git dependencies support** `git = "https://github.com/user/repo.git#branch"` and `git = "..."@tag` - [ ] **Conan and vcpkg integration** Automatic download, installation and linking of packages - [ ] **Full freestanding / embedded support** `-nostdlib`, linker scripts, bare-metal targets (i686-elf, aarch64-none-elf, etc.) +- [ ] **EFI support** + Dedicated platform configuration for EFI targets +- [ ] **Custom project name** + Override binary name in `dcr.toml` - [ ] **Custom build steps / targets** Ability to define custom pre-build, post-build, codegen steps in `dcr.toml` - [ ] **Improved mixed C/C++/ASM projects** diff --git a/docs/SUMMARY.md b/docs/SUMMARY.md index 1ab1d6d..b5fdc8e 100644 --- a/docs/SUMMARY.md +++ b/docs/SUMMARY.md @@ -21,6 +21,7 @@ * [Global options](commands/global-options.md) * [dcr init/new](commands/dcr-init-or-new.md) +* [dcr add](commands/dcr-add.md) * [dcr build](commands/dcr-build.md) * [dcr run](commands/dcr-run.md) * [dcr clean](commands/dcr-clean.md) diff --git a/docs/commands/dcr-add.md b/docs/commands/dcr-add.md new file mode 100644 index 0000000..356ac71 --- /dev/null +++ b/docs/commands/dcr-add.md @@ -0,0 +1,32 @@ +# dcr add + +Add a dependency to `dcr.toml`. + +## Usage + +```bash +dcr add [options] +``` + +## Sources + +- `path:./path/to/lib`: Local directory. +- `github:user/repo`: GitHub repository. +- `gitlab:user/repo`: GitLab repository. +- `git:host.com/user/repo`: Generic Git repository (HTTPS). +- `https://...`: Full Git URL. + +## Options + +- `--branch `: Use a specific branch. +- `--tag `: Use a specific tag. +- `--rev `: Use a specific commit hash. + +## Examples + +```bash +dcr add my_lib path:./libs/my_lib +dcr add cool_lib github:user/cool_lib +dcr add shared_lib gitlab:org/shared --branch develop +dcr add custom_lib git:git.internal.com/r/lib --tag v1.0.0 +``` diff --git a/docs/dependencies-and-build/dependency-format.md b/docs/dependencies-and-build/dependency-format.md index 8ba83b1..4e57da0 100644 --- a/docs/dependencies-and-build/dependency-format.md +++ b/docs/dependencies-and-build/dependency-format.md @@ -2,25 +2,39 @@ Dependencies are defined in `dcr.toml` under `[dependencies]`. -## Full example +## Full example (Path) ```toml [dependencies] fmt = { path = "./third_party/fmt", include = ["include"], lib = ["lib"], libs = ["fmt"] } ``` +## Full example (Git) + +```toml +[dependencies] +json = { git = "https://github.com/nlohmann/json", tag = "v3.11.2" } +``` + ## Field reference -- `path`: required dependency root path. +- `path`: local path to dependency root. +- `git`: URL of Git repository. +- `branch`: Git branch name. +- `tag`: Git tag name. +- `rev`: Git commit SHA. - `include`: optional include subpaths (absolute or relative to dep root). - `lib`: optional library subpaths (absolute or relative to dep root). - `libs`: optional linker library names. -## Common valid compact form +## Common valid compact forms ```toml [dependencies] mylib = { path = "./libs/mylib" } +gitlib = { git = "https://github.com/user/repo" } +# Shortest form for path +simple = "./libs/simple" ``` -In this form DCR will try defaults for include/lib dirs and use `mylib` as the linker library name. +In these forms DCR will try defaults for include/lib dirs and use the dependency name as the linker library name. diff --git a/src/cli/add.rs b/src/cli/add.rs new file mode 100644 index 0000000..b1284fa --- /dev/null +++ b/src/cli/add.rs @@ -0,0 +1,199 @@ +use crate::core::config::Config; +use crate::utils::fs::find_project_root; +use crate::utils::log::error; +use crate::utils::text::{BOLD_GREEN, colored}; +use toml::Value; +use toml::map::Map; + +pub struct AddArgs { + pub name: String, + pub path: Option, + pub git: Option, + pub branch: Option, + pub tag: Option, + pub rev: Option, +} + +pub fn add(args: &[String]) -> i32 { + let add_args = match parse_add_args(args) { + Ok(a) => a, + Err(code) => return code, + }; + + 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 mut config = match Config::open(&root.join("dcr.toml").to_string_lossy()) { + Ok(cfg) => cfg, + Err(err) => { + error(&err.to_string()); + return 1; + } + }; + + let dep_value = if let Some(git_url) = add_args.git { + if add_args.branch.is_none() && add_args.tag.is_none() && add_args.rev.is_none() { + let mut table = Map::new(); + table.insert("git".to_string(), Value::String(git_url)); + Value::Table(table) + } else { + let mut table = Map::new(); + table.insert("git".to_string(), Value::String(git_url)); + if let Some(b) = add_args.branch { + table.insert("branch".to_string(), Value::String(b)); + } + if let Some(t) = add_args.tag { + table.insert("tag".to_string(), Value::String(t)); + } + if let Some(r) = add_args.rev { + table.insert("rev".to_string(), Value::String(r)); + } + Value::Table(table) + } + } else if let Some(path) = add_args.path { + Value::String(path) + } else { + error("Dependency source (path or git) must be provided"); + return 1; + }; + + let key = format!("dependencies.{}", add_args.name); + if let Err(err) = config.edit(&key, dep_value) { + error(&format!("Failed to update dcr.toml: {}", err)); + return 1; + } + + println!( + " {} dependency `{}` to dcr.toml", + colored("Added", BOLD_GREEN), + add_args.name + ); + 0 +} + +fn parse_add_args(args: &[String]) -> Result { + if args.is_empty() { + error("Usage: dcr add [--branch | --tag | --rev ]"); + error("Sources:"); + error(" user/repo -> github.com/user/repo"); + error(" github:user/repo -> github.com/user/repo"); + error(" gitlab:user/repo -> gitlab.com/user/repo"); + error(" git:host.com/user/repo -> host.com/user/repo"); + error(" path:./path/to/lib -> local path"); + return Err(1); + } + + let mut name = String::new(); + let source_spec: String; + let mut branch = None; + let mut tag = None; + let mut rev = None; + + let mut iter = args.iter(); + if let Some(n) = iter.next() { + if n.starts_with("--") { + error("First argument must be the dependency name"); + return Err(1); + } + name = n.clone(); + } + + if let Some(s) = iter.next() { + if s.starts_with("--") { + error("Second argument must be the dependency source"); + return Err(1); + } + source_spec = s.clone(); + } else { + error("Dependency source is required"); + return Err(1); + } + + while let Some(arg) = iter.next() { + match arg.as_str() { + "--branch" => { + branch = iter.next().cloned(); + if branch.is_none() { + error("--branch requires a value"); + return Err(1); + } + } + "--tag" => { + tag = iter.next().cloned(); + if tag.is_none() { + error("--tag requires a value"); + return Err(1); + } + } + "--rev" => { + rev = iter.next().cloned(); + if rev.is_none() { + error("--rev requires a value"); + return Err(1); + } + } + _ => { + error(&format!("Unknown argument: {}", arg)); + return Err(1); + } + } + } + + let mut path = None; + let mut git = None; + + if let Some(p) = source_spec.strip_prefix("path:") { + path = Some(p.to_string()); + } else if let Some(g) = source_spec.strip_prefix("github:") { + git = Some(format!("https://github.com/{}", g)); + } else if let Some(g) = source_spec.strip_prefix("gitlab:") { + git = Some(format!("https://gitlab.com/{}", g)); + } else if let Some(g) = source_spec.strip_prefix("git:") { + if g.contains('/') && !g.contains('.') { + // git:user/repo -> default to github + git = Some(format!("https://github.com/{}", g)); + } else { + // git:host.com/user/repo + let url = if g.starts_with("http") || g.starts_with("git@") { + g.to_string() + } else { + format!("https://{}", g) + }; + git = Some(url); + } + } else if source_spec.starts_with("http://") + || source_spec.starts_with("https://") + || source_spec.starts_with("git@") + { + git = Some(source_spec); + } else { + error("Source must have a prefix (path:, git:, github:, gitlab:) or be a full URL"); + return Err(1); + } + + Ok(AddArgs { + name, + path, + git, + branch, + tag, + rev, + }) +} diff --git a/src/cli/mod.rs b/src/cli/mod.rs index f0fa7bb..8028548 100644 --- a/src/cli/mod.rs +++ b/src/cli/mod.rs @@ -1,3 +1,4 @@ +pub mod add; pub mod build; pub mod clean; pub mod flag_update; diff --git a/src/core/config.rs b/src/core/config.rs index 3223a95..6ca6223 100644 --- a/src/core/config.rs +++ b/src/core/config.rs @@ -525,6 +525,18 @@ fn format_dep_value(value: &Value) -> String { if let Some(v) = tbl.get("path").and_then(|v| v.as_str()) { parts.push(format!("path = \"{v}\"")); } + if let Some(v) = tbl.get("git").and_then(|v| v.as_str()) { + parts.push(format!("git = \"{v}\"")); + } + if let Some(v) = tbl.get("branch").and_then(|v| v.as_str()) { + parts.push(format!("branch = \"{v}\"")); + } + if let Some(v) = tbl.get("tag").and_then(|v| v.as_str()) { + parts.push(format!("tag = \"{v}\"")); + } + if let Some(v) = tbl.get("rev").and_then(|v| v.as_str()) { + parts.push(format!("rev = \"{v}\"")); + } if let Some(v) = tbl.get("system").and_then(|v| v.as_bool()) { parts.push(format!("system = {}", if v { "true" } else { "false" })); } diff --git a/src/core/deps.rs b/src/core/deps.rs deleted file mode 100644 index 60b5694..0000000 --- a/src/core/deps.rs +++ /dev/null @@ -1,390 +0,0 @@ -use crate::core::config::Config; -use sha2::{Digest, Sha256}; -use std::fs; -use std::path::{Path, PathBuf}; -use toml::Value; - -#[derive(Debug, Clone)] -pub struct DepSpec { - pub name: String, - pub path_raw: String, - pub include_raw: Option>, - pub lib_raw: Option>, - pub libs_raw: Option>, -} - -#[derive(Debug, Clone)] -pub struct ResolvedDeps { - pub include_dirs: Vec, - pub lib_dirs: Vec, - pub libs: Vec, -} - -pub fn resolve_deps( - config: &Config, - profile: &str, - target: Option<&str>, - project_root: &Path, -) -> Result { - let project_name = config - .get("package.name") - .and_then(|v| v.as_str()) - .unwrap_or("") - .to_string(); - let project_version = config - .get("package.version") - .and_then(|v| v.as_str()) - .unwrap_or("") - .to_string(); - let deps = parse_dependencies(config, profile, target)?; - if deps.is_empty() { - return Ok(ResolvedDeps { - include_dirs: Vec::new(), - lib_dirs: Vec::new(), - libs: Vec::new(), - }); - } - - let mut include_dirs = Vec::new(); - let mut lib_dirs = Vec::new(); - let mut libs = Vec::new(); - let mut lock_packages = Vec::new(); - - for dep in deps { - let dep_path_raw = expand_profile(&dep.path_raw, profile); - let dep_path = resolve_path(project_root, &dep_path_raw)?; - if !dep_path.is_dir() { - return Err(format!( - "Dependency '{}' path is not a directory: {}", - dep.name, - dep_path.display() - )); - } - - let include = resolve_paths(&dep_path, dep.include_raw.as_deref(), &["include"], profile)?; - let lib = resolve_paths( - &dep_path, - dep.lib_raw.as_deref(), - &["lib", "lib64"], - profile, - )?; - let libs_list = dep - .libs_raw - .clone() - .unwrap_or_else(|| vec![dep.name.clone()]); - - if include.is_empty() || lib.is_empty() { - return Err(format!( - "Dependency '{}' missing include/lib dirs. Add include/lib in dcr.toml.", - dep.name - )); - } - - include_dirs.extend(include.iter().map(|p| p.to_string_lossy().to_string())); - lib_dirs.extend(lib.iter().map(|p| p.to_string_lossy().to_string())); - libs.extend(libs_list.iter().cloned()); - - let dep_cache = project_root - .join("target") - .join(profile) - .join("deps") - .join(&dep.name); - sync_dep_dir(&dep_path, &dep_cache) - .map_err(|err| format!("Failed to sync dep {}: {err}", dep.name))?; - - let dep_version = read_dep_version(&dep_path).unwrap_or_else(|| "0.0.0".to_string()); - let dep_checksum = compute_checksum(&dep_path) - .map_err(|err| format!("Failed to hash dep {}: {err}", dep.name))?; - lock_packages.push(DepLock { - name: dep.name.clone(), - version: dep_version, - checksum: dep_checksum, - source: format!("path+{}", dep.path_raw), - }); - } - - write_lock( - project_root, - &project_name, - &project_version, - &lock_packages, - )?; - - Ok(ResolvedDeps { - include_dirs, - lib_dirs, - libs, - }) -} - -#[derive(Debug, Clone)] -struct DepLock { - name: String, - version: String, - checksum: String, - source: String, -} - -fn parse_dependencies( - config: &Config, - profile: &str, - target: Option<&str>, -) -> Result, String> { - let mut deps_table = None; - // Order: dependencies.target.profile, dependencies.profile.target, dependencies.target, dependencies.profile, dependencies - let combinations = if let Some(t) = target { - let normalized_t = crate::cli::build::normalize_target_os(t); - vec![ - format!("dependencies.{}.{}", normalized_t, profile), - format!("dependencies.{}.{}", profile, normalized_t), - format!("dependencies.{}", normalized_t), - format!("dependencies.{}", profile), - "dependencies".to_string(), - ] - } else { - vec![ - format!("dependencies.{}", profile), - "dependencies".to_string(), - ] - }; - for key in combinations { - if let Some(val) = config.get(&key).and_then(|v| v.as_table()) { - deps_table = Some(val); - break; - } - } - let deps_table = match deps_table { - Some(t) => t, - None => return Ok(Vec::new()), - }; - let mut deps = Vec::new(); - for (name, value) in deps_table { - match value { - Value::Table(tbl) => { - if tbl.get("system").and_then(|v| v.as_bool()).unwrap_or(false) { - return Err(format!( - "Dependency '{}' uses system=true, which is not supported yet", - name - )); - } - let path = tbl - .get("path") - .and_then(|v| v.as_str()) - .ok_or_else(|| format!("Dependency '{}' missing path", name))? - .to_string(); - let include = parse_string_list(tbl.get("include"), name, "include")?; - let lib = parse_string_list(tbl.get("lib"), name, "lib")?; - let libs = parse_string_list(tbl.get("libs"), name, "libs")?; - deps.push(DepSpec { - name: name.to_string(), - path_raw: path, - include_raw: include, - lib_raw: lib, - libs_raw: libs, - }); - } - _ => { - return Err(format!( - "Dependency '{}' must be a table with path/include/lib", - name - )); - } - } - } - deps.sort_by(|a, b| a.name.cmp(&b.name)); - Ok(deps) -} - -fn parse_string_list( - value: Option<&Value>, - dep_name: &str, - key: &str, -) -> Result>, String> { - let Some(value) = value else { return Ok(None) }; - let list = value.as_array().ok_or_else(|| { - format!( - "Dependency '{}' field '{}' must be an array of strings", - dep_name, key - ) - })?; - let mut out = Vec::new(); - for item in list { - let s = item - .as_str() - .ok_or_else(|| format!("Dependency '{}' field '{}' must be strings", dep_name, key))?; - out.push(s.to_string()); - } - Ok(Some(out)) -} - -fn resolve_path(project_root: &Path, raw: &str) -> Result { - let p = Path::new(raw); - let full = if p.is_absolute() { - p.to_path_buf() - } else { - project_root.join(p) - }; - Ok(full) -} - -fn resolve_paths( - base: &Path, - raw: Option<&[String]>, - defaults: &[&str], - profile: &str, -) -> Result, String> { - let mut out = Vec::new(); - if let Some(raw) = raw { - for r in raw { - let expanded = expand_profile(r, profile); - let p = Path::new(&expanded); - let full = if p.is_absolute() { - p.to_path_buf() - } else { - base.join(p) - }; - if !full.exists() { - return Err(format!("Path does not exist: {}", full.display())); - } - out.push(full); - } - return Ok(out); - } - - for d in defaults { - let candidate = base.join(d); - if candidate.exists() { - out.push(candidate); - } - } - Ok(out) -} - -fn expand_profile(raw: &str, profile: &str) -> String { - raw.replace("{profile}", profile) -} - -fn sync_dep_dir(src: &Path, dst: &Path) -> std::io::Result<()> { - if dst.exists() { - fs::remove_dir_all(dst)?; - } - copy_dir_all(src, dst) -} - -fn copy_dir_all(src: &Path, dst: &Path) -> std::io::Result<()> { - fs::create_dir_all(dst)?; - for entry in fs::read_dir(src)? { - let entry = entry?; - let ty = entry.file_type()?; - let from = entry.path(); - let to = dst.join(entry.file_name()); - if ty.is_dir() { - copy_dir_all(&from, &to)?; - } else { - fs::copy(&from, &to)?; - } - } - Ok(()) -} - -fn write_lock( - project_root: &Path, - project_name: &str, - project_version: &str, - packages: &[DepLock], -) -> Result<(), String> { - let mut out = String::new(); - if !packages.is_empty() { - out.push_str("[[package]]\n"); - out.push_str(&format!("name = \"{}\"\n", escape_value(project_name))); - out.push_str(&format!( - "version = \"{}\"\n", - escape_value(project_version) - )); - out.push_str(&format!( - "dependencies = [{}]\n\n", - quote_list(&packages.iter().map(|p| p.name.clone()).collect::>()) - )); - } - for pkg in packages { - out.push_str("[[package]]\n"); - out.push_str(&format!("name = \"{}\"\n", escape_value(&pkg.name))); - out.push_str(&format!("version = \"{}\"\n", escape_value(&pkg.version))); - out.push_str(&format!("source = \"{}\"\n", escape_value(&pkg.source))); - out.push_str(&format!("checksum = \"{}\"\n", escape_value(&pkg.checksum))); - out.push('\n'); - } - fs::write(project_root.join("dcr.lock"), out) - .map_err(|err| format!("Failed to write dcr.lock: {err}"))?; - Ok(()) -} - -fn quote_list(items: &[String]) -> String { - items - .iter() - .map(|s| format!("\"{}\"", escape_value(s))) - .collect::>() - .join(", ") -} - -fn escape_value(input: &str) -> String { - input.replace('\\', "\\\\").replace('"', "\\\"") -} - -fn read_dep_version(dep_path: &Path) -> Option { - let path = dep_path.join("dcr.toml"); - let content = fs::read_to_string(path).ok()?; - let value: Value = content.parse().ok()?; - value - .get("package") - .and_then(|v| v.as_table()) - .and_then(|t| t.get("version")) - .and_then(|v| v.as_str()) - .map(|s| s.to_string()) -} - -fn compute_checksum(root: &Path) -> Result { - let mut files = Vec::new(); - collect_files(root, root, &mut files)?; - files.sort(); - let mut hasher = Sha256::new(); - for rel in files { - hasher.update(rel.as_bytes()); - let data = - fs::read(root.join(&rel)).map_err(|err| format!("failed to read {}: {err}", rel))?; - hasher.update(&data); - } - let hash = hasher.finalize(); - Ok(to_hex(&hash)) -} - -fn collect_files(root: &Path, dir: &Path, out: &mut Vec) -> Result<(), String> { - for entry in fs::read_dir(dir).map_err(|err| format!("read_dir failed: {err}"))? { - let entry = entry.map_err(|err| format!("read_dir failed: {err}"))?; - let path = entry.path(); - let name = entry.file_name(); - let name_str = name.to_string_lossy(); - if name_str == "target" { - continue; - } - if path.is_dir() { - collect_files(root, &path, out)?; - } else if path.is_file() { - let rel = path - .strip_prefix(root) - .unwrap_or(&path) - .to_string_lossy() - .to_string(); - out.push(rel); - } - } - Ok(()) -} - -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/core/deps/common.rs b/src/core/deps/common.rs new file mode 100644 index 0000000..15e6842 --- /dev/null +++ b/src/core/deps/common.rs @@ -0,0 +1,99 @@ +use std::fs; +use std::path::{Path, PathBuf}; + +#[derive(Debug, Clone)] +pub enum DepSource { + Path(String), + Git { + url: String, + branch: Option, + tag: Option, + rev: Option, + }, +} + +#[derive(Debug, Clone)] +pub struct DepSpec { + pub name: String, + pub source: DepSource, + pub include_raw: Option>, + pub lib_raw: Option>, + pub libs_raw: Option>, +} + +#[derive(Debug, Clone)] +pub struct ResolvedDeps { + pub include_dirs: Vec, + pub lib_dirs: Vec, + pub libs: Vec, +} + +pub fn resolve_path(project_root: &Path, raw: &str) -> Result { + let p = Path::new(raw); + let full = if p.is_absolute() { + p.to_path_buf() + } else { + project_root.join(p) + }; + Ok(full) +} + +pub fn resolve_paths( + base: &Path, + raw: Option<&[String]>, + defaults: &[&str], + profile: &str, +) -> Result, String> { + let mut out = Vec::new(); + if let Some(raw) = raw { + for r in raw { + let expanded = expand_profile(r, profile); + let p = Path::new(&expanded); + let full = if p.is_absolute() { + p.to_path_buf() + } else { + base.join(p) + }; + if !full.exists() { + return Err(format!("Path does not exist: {}", full.display())); + } + out.push(full); + } + return Ok(out); + } + + for d in defaults { + let candidate = base.join(d); + if candidate.exists() { + out.push(candidate); + } + } + Ok(out) +} + +pub fn expand_profile(raw: &str, profile: &str) -> String { + raw.replace("{profile}", profile) +} + +pub fn sync_dep_dir(src: &Path, dst: &Path) -> std::io::Result<()> { + if dst.exists() { + fs::remove_dir_all(dst)?; + } + copy_dir_all(src, dst) +} + +pub fn copy_dir_all(src: &Path, dst: &Path) -> std::io::Result<()> { + fs::create_dir_all(dst)?; + for entry in fs::read_dir(src)? { + let entry = entry?; + let ty = entry.file_type()?; + let from = entry.path(); + let to = dst.join(entry.file_name()); + if ty.is_dir() { + copy_dir_all(&from, &to)?; + } else { + fs::copy(&from, &to)?; + } + } + Ok(()) +} diff --git a/src/core/deps/git.rs b/src/core/deps/git.rs new file mode 100644 index 0000000..979a067 --- /dev/null +++ b/src/core/deps/git.rs @@ -0,0 +1,52 @@ +use std::path::Path; + +pub fn fetch_git_dep( + url: &str, + target_dir: &Path, + branch: Option<&str>, + tag: Option<&str>, + rev: Option<&str>, +) -> Result<(), String> { + if target_dir.exists() { + return Ok(()); + } + + let mut builder = git2::build::RepoBuilder::new(); + if let Some(b) = branch { + builder.branch(b); + } + + let repo = builder + .clone(url, target_dir) + .map_err(|e| format!("failed to clone {}: {}", url, e))?; + + if let Some(t) = tag { + checkout_ref(&repo, &format!("refs/tags/{}", t))?; + } else if let Some(r) = rev { + checkout_ref(&repo, r)?; + } + + Ok(()) +} + +fn checkout_ref(repo: &git2::Repository, reference_str: &str) -> Result<(), String> { + let (object, reference) = repo + .revparse_ext(reference_str) + .map_err(|e| format!("failed to find ref {}: {}", reference_str, e))?; + + repo.checkout_tree(&object, None).map_err(|e| { + let ref_name = reference.as_ref().and_then(|r| r.name()).unwrap_or("HEAD"); + format!("failed to checkout {}: {}", ref_name, e) + })?; + + match reference { + Some(gref) => { + let ref_name = gref.name().unwrap_or("HEAD"); + repo.set_head(ref_name) + } + None => repo.set_head_detached(object.id()), + } + .map_err(|e| format!("failed to set HEAD: {}", e))?; + + Ok(()) +} diff --git a/src/core/deps/lock.rs b/src/core/deps/lock.rs new file mode 100644 index 0000000..9737a44 --- /dev/null +++ b/src/core/deps/lock.rs @@ -0,0 +1,114 @@ +use sha2::{Digest, Sha256}; +use std::fs; +use std::path::Path; +use toml::Value; + +#[derive(Debug, Clone)] +pub struct DepLock { + pub name: String, + pub version: String, + pub checksum: String, + pub source: String, +} + +pub fn write_lock( + project_root: &Path, + project_name: &str, + project_version: &str, + packages: &[DepLock], +) -> Result<(), String> { + let mut out = String::new(); + if !packages.is_empty() { + out.push_str("[[package]]\n"); + out.push_str(&format!("name = \"{}\"\n", escape_value(project_name))); + out.push_str(&format!( + "version = \"{}\"\n", + escape_value(project_version) + )); + out.push_str(&format!( + "dependencies = [{}]\n\n", + quote_list(&packages.iter().map(|p| p.name.clone()).collect::>()) + )); + } + for pkg in packages { + out.push_str("[[package]]\n"); + out.push_str(&format!("name = \"{}\"\n", escape_value(&pkg.name))); + out.push_str(&format!("version = \"{}\"\n", escape_value(&pkg.version))); + out.push_str(&format!("source = \"{}\"\n", escape_value(&pkg.source))); + out.push_str(&format!("checksum = \"{}\"\n", escape_value(&pkg.checksum))); + out.push('\n'); + } + fs::write(project_root.join("dcr.lock"), out) + .map_err(|err| format!("Failed to write dcr.lock: {err}"))?; + Ok(()) +} + +fn quote_list(items: &[String]) -> String { + items + .iter() + .map(|s| format!("\"{}\"", escape_value(s))) + .collect::>() + .join(", ") +} + +fn escape_value(input: &str) -> String { + input.replace('\\', "\\\\").replace('"', "\\\"") +} + +pub fn read_dep_version(dep_path: &Path) -> Option { + let path = dep_path.join("dcr.toml"); + let content = fs::read_to_string(path).ok()?; + let value: Value = content.parse().ok()?; + value + .get("package") + .and_then(|v| v.as_table()) + .and_then(|t| t.get("version")) + .and_then(|v| v.as_str()) + .map(|s| s.to_string()) +} + +pub fn compute_checksum(root: &Path) -> Result { + let mut files = Vec::new(); + collect_files(root, root, &mut files)?; + files.sort(); + let mut hasher = Sha256::new(); + for rel in files { + hasher.update(rel.as_bytes()); + let data = + fs::read(root.join(&rel)).map_err(|err| format!("failed to read {}: {err}", rel))?; + hasher.update(&data); + } + let hash = hasher.finalize(); + Ok(to_hex(&hash)) +} + +fn collect_files(root: &Path, dir: &Path, out: &mut Vec) -> Result<(), String> { + for entry in fs::read_dir(dir).map_err(|err| format!("read_dir failed: {err}"))? { + let entry = entry.map_err(|err| format!("read_dir failed: {err}"))?; + let path = entry.path(); + let name = entry.file_name(); + let name_str = name.to_string_lossy(); + if name_str == "target" { + continue; + } + if path.is_dir() { + collect_files(root, &path, out)?; + } else if path.is_file() { + let rel = path + .strip_prefix(root) + .unwrap_or(&path) + .to_string_lossy() + .to_string(); + out.push(rel); + } + } + Ok(()) +} + +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/core/deps/mod.rs b/src/core/deps/mod.rs new file mode 100644 index 0000000..038778b --- /dev/null +++ b/src/core/deps/mod.rs @@ -0,0 +1,286 @@ +pub mod common; +pub mod git; +pub mod lock; + +use crate::core::config::Config; +use std::fs; +use std::path::Path; +use toml::Value; + +pub use common::{DepSource, DepSpec, ResolvedDeps}; +use common::{expand_profile, resolve_path, resolve_paths, sync_dep_dir}; +use git::fetch_git_dep; +use lock::{DepLock, compute_checksum, read_dep_version, write_lock}; + +pub fn resolve_deps( + config: &Config, + profile: &str, + target: Option<&str>, + project_root: &Path, +) -> Result { + let project_name = config + .get("package.name") + .and_then(|v| v.as_str()) + .unwrap_or("") + .to_string(); + let project_version = config + .get("package.version") + .and_then(|v| v.as_str()) + .unwrap_or("") + .to_string(); + let deps = parse_dependencies(config, profile, target)?; + if deps.is_empty() { + return Ok(ResolvedDeps { + include_dirs: Vec::new(), + lib_dirs: Vec::new(), + libs: Vec::new(), + }); + } + + let mut include_dirs = Vec::new(); + let mut lib_dirs = Vec::new(); + let mut libs = Vec::new(); + let mut lock_packages = Vec::new(); + + for dep in deps { + let (dep_path, is_git) = match &dep.source { + DepSource::Path(path_raw) => { + let expanded = expand_profile(path_raw, profile); + (resolve_path(project_root, &expanded)?, false) + } + DepSource::Git { + url, + branch, + tag, + rev, + } => { + let git_deps_dir = project_root + .join("target") + .join(profile) + .join("deps") + .join("git"); + fs::create_dir_all(&git_deps_dir) + .map_err(|e| format!("failed to create target/{}/deps/git: {}", profile, e))?; + let dep_dir = git_deps_dir.join(&dep.name); + if !dep_dir.exists() { + use crate::utils::text::{BOLD_GREEN, colored}; + use std::io::{self, Write}; + print!( + " {} dependency `{}` from {}...", + colored("Fetching", BOLD_GREEN), + dep.name, + url + ); + io::stdout().flush().ok(); + + fetch_git_dep( + url, + &dep_dir, + branch.as_deref(), + tag.as_deref(), + rev.as_deref(), + )?; + + print!( + "\r\x1B[2K {} dependency `{}`\n", + colored("Fetched", BOLD_GREEN), + dep.name + ); + io::stdout().flush().ok(); + } else { + fetch_git_dep( + url, + &dep_dir, + branch.as_deref(), + tag.as_deref(), + rev.as_deref(), + )?; + } + (dep_dir, true) + } + }; + + if !dep_path.is_dir() { + return Err(format!( + "Dependency '{}' path is not a directory: {}", + dep.name, + dep_path.display() + )); + } + + let include = resolve_paths(&dep_path, dep.include_raw.as_deref(), &["include"], profile)?; + let lib = resolve_paths( + &dep_path, + dep.lib_raw.as_deref(), + &["lib", "lib64"], + profile, + )?; + let libs_list = dep + .libs_raw + .clone() + .unwrap_or_else(|| vec![dep.name.clone()]); + + if include.is_empty() || lib.is_empty() { + return Err(format!( + "Dependency '{}' missing include/lib dirs. Add include/lib in dcr.toml.", + dep.name + )); + } + + include_dirs.extend(include.iter().map(|p| p.to_string_lossy().to_string())); + lib_dirs.extend(lib.iter().map(|p| p.to_string_lossy().to_string())); + libs.extend(libs_list.iter().cloned()); + + if !is_git { + let dep_cache = project_root + .join("target") + .join(profile) + .join("deps") + .join(&dep.name); + sync_dep_dir(&dep_path, &dep_cache) + .map_err(|err| format!("Failed to sync dep {}: {err}", dep.name))?; + } + + let dep_version = read_dep_version(&dep_path).unwrap_or_else(|| "0.0.0".to_string()); + let dep_checksum = compute_checksum(&dep_path) + .map_err(|err| format!("Failed to hash dep {}: {err}", dep.name))?; + let source_str = match &dep.source { + DepSource::Path(p) => format!("path+{}", p), + DepSource::Git { url, .. } => format!("git+{}", url), + }; + lock_packages.push(DepLock { + name: dep.name.clone(), + version: dep_version, + checksum: dep_checksum, + source: source_str, + }); + } + + write_lock( + project_root, + &project_name, + &project_version, + &lock_packages, + )?; + + Ok(ResolvedDeps { + include_dirs, + lib_dirs, + libs, + }) +} + +fn parse_dependencies( + config: &Config, + profile: &str, + target: Option<&str>, +) -> Result, String> { + let mut deps_table = None; + let combinations = if let Some(t) = target { + let normalized_t = crate::cli::build::normalize_target_os(t); + vec![ + format!("dependencies.{}.{}", normalized_t, profile), + format!("dependencies.{}.{}", profile, normalized_t), + format!("dependencies.{}", normalized_t), + format!("dependencies.{}", profile), + "dependencies".to_string(), + ] + } else { + vec![ + format!("dependencies.{}", profile), + "dependencies".to_string(), + ] + }; + for key in combinations { + if let Some(val) = config.get(&key).and_then(|v| v.as_table()) { + deps_table = Some(val); + break; + } + } + let deps_table = match deps_table { + Some(t) => t, + None => return Ok(Vec::new()), + }; + let mut deps = Vec::new(); + for (name, value) in deps_table { + match value { + Value::String(path) => { + deps.push(DepSpec { + name: name.to_string(), + source: DepSource::Path(path.to_string()), + include_raw: None, + lib_raw: None, + libs_raw: None, + }); + } + Value::Table(tbl) => { + if tbl.get("system").and_then(|v| v.as_bool()).unwrap_or(false) { + return Err(format!( + "Dependency '{}' uses system=true, which is not supported yet", + name + )); + } + + let source = if let Some(git_url) = tbl.get("git").and_then(|v| v.as_str()) { + DepSource::Git { + url: git_url.to_string(), + branch: tbl + .get("branch") + .and_then(|v| v.as_str()) + .map(|s| s.to_string()), + tag: tbl + .get("tag") + .and_then(|v| v.as_str()) + .map(|s| s.to_string()), + rev: tbl + .get("rev") + .and_then(|v| v.as_str()) + .map(|s| s.to_string()), + } + } else if let Some(path) = tbl.get("path").and_then(|v| v.as_str()) { + DepSource::Path(path.to_string()) + } else { + return Err(format!("Dependency '{}' missing path or git", name)); + }; + + let include = parse_string_list(tbl.get("include"), name, "include")?; + let lib = parse_string_list(tbl.get("lib"), name, "lib")?; + let libs = parse_string_list(tbl.get("libs"), name, "libs")?; + deps.push(DepSpec { + name: name.to_string(), + source, + include_raw: include, + lib_raw: lib, + libs_raw: libs, + }); + } + _ => { + return Err(format!("Dependency '{}' must be a string or a table", name)); + } + } + } + deps.sort_by(|a, b| a.name.cmp(&b.name)); + Ok(deps) +} + +fn parse_string_list( + value: Option<&Value>, + dep_name: &str, + key: &str, +) -> Result>, String> { + let Some(value) = value else { return Ok(None) }; + let list = value.as_array().ok_or_else(|| { + format!( + "Dependency '{}' field '{}' must be an array of strings", + dep_name, key + ) + })?; + let mut out = Vec::new(); + for item in list { + let s = item + .as_str() + .ok_or_else(|| format!("Dependency '{}' field '{}' must be strings", dep_name, key))?; + out.push(s.to_string()); + } + Ok(Some(out)) +} diff --git a/src/main.rs b/src/main.rs index c4f04af..272c016 100644 --- a/src/main.rs +++ b/src/main.rs @@ -18,6 +18,7 @@ fn main() { let code = match cmd { "new" => cli::r#new::new(rest), "init" => cli::init::init(rest), + "add" => cli::add::add(rest), "build" => cli::build::build(rest), "run" => cli::run::run(rest), "test" | "tests" => cli::test::test(rest), diff --git a/tests/cli_basic.rs b/tests/cli_basic.rs index 4a62b6c..fa3e164 100644 --- a/tests/cli_basic.rs +++ b/tests/cli_basic.rs @@ -221,6 +221,65 @@ fn workspace_build_and_clean_all() { ); } +#[test] +fn dcr_add_dependencies() { + let dir = unique_sandbox_dir("add_dep"); + let out = run_dcr(&["init"], &dir); + assert!(out.status.success(), "dcr init should succeed"); + + // Test path: prefix + let out = run_dcr(&["add", "mylib", "path:./libs/mylib"], &dir); + assert!(out.status.success(), "dcr add path should succeed"); + let toml = std::fs::read_to_string(dir.join("dcr.toml")).unwrap(); + assert!( + toml.contains("mylib = \"./libs/mylib\""), + "path dep not found in toml" + ); + + // Test github: prefix + let out = run_dcr(&["add", "gh_lib", "github:user/repo"], &dir); + assert!(out.status.success(), "dcr add github should succeed"); + let toml = std::fs::read_to_string(dir.join("dcr.toml")).unwrap(); + assert!( + toml.contains("gh_lib = { git = \"https://github.com/user/repo\" }"), + "github dep not found in toml" + ); + + // Test git: prefix (generic) + let out = run_dcr(&["add", "custom_git", "git:host.com/user/repo"], &dir); + assert!(out.status.success(), "dcr add custom git should succeed"); + let toml = std::fs::read_to_string(dir.join("dcr.toml")).unwrap(); + assert!( + toml.contains("custom_git = { git = \"https://host.com/user/repo\" }"), + "custom git dep not found in toml" + ); + + // Test git: prefix (github default) + let out = run_dcr(&["add", "git_short", "git:user/repo"], &dir); + assert!(out.status.success(), "dcr add git short should succeed"); + let toml = std::fs::read_to_string(dir.join("dcr.toml")).unwrap(); + assert!( + toml.contains("git_short = { git = \"https://github.com/user/repo\" }"), + "git short dep not found in toml" + ); + + // Test flags (branch) + let out = run_dcr( + &["add", "branch_lib", "github:user/repo", "--branch", "dev"], + &dir, + ); + assert!(out.status.success(), "dcr add with branch should succeed"); + let toml = std::fs::read_to_string(dir.join("dcr.toml")).unwrap(); + assert!( + toml.contains("branch_lib = { git = \"https://github.com/user/repo\", branch = \"dev\" }"), + "branch lib not found in toml" + ); + + // Test failure on no prefix + let out = run_dcr(&["add", "fail_lib", "user/repo"], &dir); + assert!(!out.status.success(), "dcr add without prefix should fail"); +} + #[test] fn dcr_test_runs_without_sandbox_dependency() { let Some(compiler) = available_compiler() else {