From 588e4dd13f3d207e067d2d0bdbca64f623a40aa4 Mon Sep 17 00:00:00 2001 From: Dexoron Date: Thu, 23 Jul 2026 13:56:36 +0800 Subject: [PATCH] feat(build): archive feature, progress UI, and workspace path fixes --- .github/workflows/ci.yml | 89 ++++++++++++++++++++++++- .github/workflows/release.yml | 30 ++++----- AGENTS.md | 56 ---------------- CHANGELOG.md | 68 ++++++++++++++------ Cargo.lock | 2 +- Cargo.toml | 8 ++- TODO.md | 65 ------------------- docs/changelog.mdx | 25 ++++++-- docs/contributing.mdx | 9 +-- docs/reference/dcr-toml.mdx | 2 + man/man1/dcr.1 | 5 +- src/cli/build.rs | 89 ++++++++++++------------- src/cli/clean.rs | 5 +- src/cli/help.rs | 3 + src/cli/new.rs | 2 +- src/cli/run.rs | 32 +++++---- src/core/build/builder/artifact.rs | 19 +++++- src/core/build/common.rs | 80 ++++++++++++++++++++++- src/core/build/engine.rs | 92 ++++++++++++++++++++++++-- src/core/build/mod.rs | 1 + src/core/build/report.rs | 3 + src/core/build_config.rs | 1 + src/main.rs | 2 +- src/utils/log.rs | 19 +----- tests/cli_build.rs | 100 ++++++++++++++++++++++++++++- tests/cli_errors.rs | 52 +++++++++++---- tests/cli_workspace.rs | 14 ++++ 27 files changed, 597 insertions(+), 276 deletions(-) delete mode 100644 AGENTS.md delete mode 100644 TODO.md diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index f7c5269..570ca30 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -5,10 +5,16 @@ on: branches: - master - main + - dev pull_request: +env: + CARGO_TERM_COLOR: always + RUSTFLAGS: -Dwarnings + jobs: checks: + name: fmt / clippy / check runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 @@ -18,11 +24,90 @@ jobs: with: components: rustfmt, clippy + - uses: Swatinem/rust-cache@v2 + - name: Format run: cargo fmt --all --check - - name: Lint + - name: Clippy (default features) + run: cargo clippy --all-targets -- -D warnings + + - name: Clippy (all features) run: cargo clippy --all-targets --all-features -- -D warnings - - name: Check + - name: Check (all features) run: cargo check --all-targets --all-features + + test: + name: tests (${{ matrix.os }}) + needs: checks + strategy: + fail-fast: false + matrix: + os: [ubuntu-latest, macos-latest, windows-latest] + runs-on: ${{ matrix.os }} + steps: + - uses: actions/checkout@v4 + + - name: Setup Rust + uses: dtolnay/rust-toolchain@stable + + - uses: Swatinem/rust-cache@v2 + + - name: Install Linux tools + if: runner.os == 'Linux' + run: | + sudo apt-get update + sudo apt-get install -y \ + build-essential \ + clang \ + nasm \ + clang-format \ + clang-tidy \ + git + + - name: Install macOS tools + if: runner.os == 'macOS' + run: | + brew install nasm llvm || true + echo "$(brew --prefix llvm)/bin" >> "$GITHUB_PATH" + + - name: Install Windows tools + if: runner.os == 'Windows' + shell: pwsh + run: | + choco install nasm -y + echo "C:\Program Files\NASM" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append + + - name: Unit tests (binary crate) + run: cargo test --bins -- --nocapture + + - name: Integration tests (default features) + run: cargo test --tests -- --nocapture + + - name: Integration tests (archive feature) + if: runner.os != 'Windows' + run: cargo test --tests --features archive -- --nocapture + + test-archive-linux: + name: archive feature smoke + needs: checks + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + + - name: Setup Rust + uses: dtolnay/rust-toolchain@stable + + - uses: Swatinem/rust-cache@v2 + + - name: Install tools + run: | + sudo apt-get update + sudo apt-get install -y build-essential clang nasm + + - name: Build with archive + run: cargo build --features archive + + - name: Flat-bin + unit suite with archive + run: cargo test --features archive --test cli_build --test cli_workspace --test cli_errors -- --nocapture diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml index 88e4fe1..ab1c4a4 100644 --- a/.github/workflows/release.yml +++ b/.github/workflows/release.yml @@ -223,9 +223,9 @@ jobs: - name: Build run: | if [ "${{ matrix.target }}" != "x86_64-unknown-linux-gnu" ]; then - cargo zigbuild --release --target ${{ matrix.target }} + cargo zigbuild --release --features archive --target ${{ matrix.target }} else - cargo build --release --target ${{ matrix.target }} + cargo build --release --features archive --target ${{ matrix.target }} fi - name: Prepare Artifact @@ -298,9 +298,9 @@ jobs: run: | cargo install cargo-deb if [ "${{ matrix.target }}" != "x86_64-unknown-linux-gnu" ]; then - cargo zigbuild --release --target ${{ matrix.target }} + cargo zigbuild --release --features archive --target ${{ matrix.target }} else - cargo build --release --target ${{ matrix.target }} + cargo build --release --features archive --target ${{ matrix.target }} fi cargo deb --no-build --target ${{ matrix.target }} mkdir -p dist-packages && cp target/${{ matrix.target }}/debian/*.deb dist-packages/ @@ -311,9 +311,9 @@ jobs: run: | cargo install cargo-generate-rpm if [ "${{ matrix.target }}" != "x86_64-unknown-linux-gnu" ]; then - cargo zigbuild --release --target ${{ matrix.target }} + cargo zigbuild --release --features archive --target ${{ matrix.target }} else - cargo build --release --target ${{ matrix.target }} + cargo build --release --features archive --target ${{ matrix.target }} fi cargo generate-rpm --target ${{ matrix.target }} mkdir -p dist-packages && cp target/${{ matrix.target }}/generate-rpm/*.rpm dist-packages/ @@ -322,7 +322,7 @@ jobs: - name: Build Snap Package if: matrix.package_type == 'snap' run: | - cargo build --release + cargo build --release --features archive mkdir -p packaging/snap/dist/bin cp target/release/dcr packaging/snap/dist/bin/ cp -r man packaging/snap/dist/man @@ -364,7 +364,7 @@ jobs: cd "\$srcdir/\$pkgname-${PKGVER_ORIG}" unset CFLAGS CXXFLAGS LDFLAGS export RUSTFLAGS="-C linker=cc" - cargo build --release --locked + cargo build --release --locked --features archive } package() { cd "\$srcdir/dcr-${PKGVER_ORIG}" @@ -454,7 +454,7 @@ jobs: targets: ${{ matrix.target }} - name: Build - run: cargo build --release --target ${{ matrix.target }} + run: cargo build --release --features archive --target ${{ matrix.target }} - name: Prepare Artifact run: | @@ -499,7 +499,7 @@ jobs: run: | export PATH="/usr/local/bin:/usr/local/sbin:$PATH" pkg install -y rust perl5 gmake - cargo build --release + cargo build --release --features archive - name: Prepare FreeBSD Artifact if: matrix.system == 'freebsd' @@ -517,7 +517,7 @@ jobs: run: | export PATH="/usr/local/bin:$PATH" pkg_add rust perl gmake - cargo build --release + cargo build --release --features archive - name: Prepare OpenBSD Artifact if: matrix.system == 'openbsd' @@ -537,7 +537,7 @@ jobs: mkdir -p /tmp/bin ln -sf /usr/pkg/bin/gmake /tmp/bin/make export PATH="/tmp/bin:/usr/pkg/bin:/usr/pkg/sbin:$PATH" - cargo build --release + cargo build --release --features archive - name: Prepare NetBSD Artifact if: matrix.system == 'netbsd' @@ -585,7 +585,7 @@ jobs: targets: ${{ matrix.target }} - name: Build - run: cargo build --release --target ${{ matrix.target }} + run: cargo build --release --features archive --target ${{ matrix.target }} - name: Prepare Artifact shell: pwsh @@ -654,7 +654,7 @@ jobs: cd "\$srcdir/\$pkgname-${PKGVER_ORIG}" unset CFLAGS CXXFLAGS LDFLAGS export RUSTFLAGS="-C linker=cc" - cargo build --release --locked + cargo build --release --locked --features archive } package() { @@ -919,7 +919,7 @@ jobs: cd "\$srcdir/dcr-${PKGVER_ORIG}" unset CFLAGS CXXFLAGS LDFLAGS export RUSTFLAGS="-C linker=cc" - cargo build --release --locked + cargo build --release --locked --features archive } package() { diff --git a/AGENTS.md b/AGENTS.md deleted file mode 100644 index 63afa31..0000000 --- a/AGENTS.md +++ /dev/null @@ -1,56 +0,0 @@ -# AGENTS.md - -## Quick start - -```bash -cargo build --release && ./target/release/dcr setup -``` - -## Pre-PR (CI) gate - -```bash -cargo fmt --all --check -cargo clippy --all-targets --all-features -- -D warnings -cargo check --all-targets --all-features -cargo test -``` - -CI (`.github/workflows/ci.yml`) runs fmt, clippy, check — **not** tests. - -## Tests - -- Integration tests in `tests/` build the dcr binary and run it in temp dirs under `sandbox/cli-tests/` (gitignored). -- Some tests **skip** if no C compiler (`gcc`/`clang`/`cc`) is found at runtime. -- Compiler can be overridden via `DCR_COMPILER` or `DCR_CC` env vars. -- Tests use `$CARGO_BIN_EXE_dcr` when available, else `target/debug/dcr`. - -## Architecture - -- **Single Rust package** (edition 2024), not a workspace. Only one binary: `dcr`. -- **Entrypoint**: `src/main.rs` — matches `args[1]` against command names. -- **Compiler backends** in `src/core/builder/`: `unix_cc` (gcc/clang), `msvc` (cl/clang-cl), `gas`, `nasm`. Dispatched by matching compiler name string. -- **Config**: `dcr.toml` (per-project), `~/.dcr/config.toml` (registry), `~/.dcr/index.json` (index). Defaults: `language=c`, `standard=c11`, `compiler=clang`, `kind=bin`. -- **`build.rs`** embeds `TARGET` as `DCR_TARGET` env var (shown in `--version`). -- **CLI output** must be in English. Use `utils::log` for messaging. - -## Key commands - -| Command | Notes | -|---|---| -| `dcr new ` | Creates project dir | -| `dcr init` | Init from CWD (must be empty) | -| `dcr build [--debug\|--release] [--target ]` | Default profile: `--debug` | -| `dcr run [--debug\|--release]` | Only for `kind = "bin"` | -| `dcr clean [--debug\|--release] [--all]` | `--all` for workspace roots | -| `dcr tree` | Dependency tree viewer | -| `dcr test [--init]` | Runs/test project tests | -| `dcr gen ` | IDE integration | -| `dcr --update` | Self-update from GitHub Releases | - -## Cross-compilation - -`--target` accepts short names (`linux`, `macos`, `windows`) or full triples. In CI, Linux cross-builds use `cargo-zigbuild`. When `build.target` is set in `dcr.toml`, DCR auto-injects `--target=` into cflags (clang). Bare-metal targets (containing `none`/`-elf`/`eabi`/`baremetal`) skip DCR's default compiler flags. - -## Dependencies (Cargo) - -reqwest (blocking+json+rustls-tls), serde, toml, git2, openssl (vendored), self-replace, sha2, ctrlc. diff --git a/CHANGELOG.md b/CHANGELOG.md index 5bdd571..eacd841 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,45 @@ # Changelog +## [0.8.2] - 2026-07-22 "CLI Progress, archive Feature, Workspace Path Fixes / CLI Progress, archive Feature, Workspace Path Fixes" + +### RU + +**Добавлено:** + +- **Прогресс компиляции `[N/M]`** — live-строка `compile pkg v0.1.0 [12/41]` на TTY (stderr), чтобы длинные mono-package сборки не выглядели «зависшими». +- **Свой стиль статуса build** — фиксированная колонка глаголов: `project`, `compile`, `dep`, `ready`, `pack`, `done`, `run` (не cargo-clone). +- **Cargo feature `archive`** — `fatfs` и упаковка FAT-образов опциональны (`cargo build --features archive`). Release CI собирает с feature; без feature `[archive]` даёт явную ошибку. +- **Интеграционные тесты** — `flat_bin_nasm_build`, `package_build_target_used_without_cli_flag`, усилен workspace `clean --all`. +- **Расширенный CI** — unit + integration на Linux/macOS/Windows, отдельный job с `--features archive`, rust-cache, clippy default + all-features. + +**Изменено:** + +- **CLI host triple больше не форсится** — без `--target` используется `build.target` пакета/member (важно для bare-metal / post_steps ISO). +- **Relative `-I`/`-L`/`-T` (и `-isystem`/`-idirafter`)** в cflags/ldflags абсолютизируются относительно корня пакета (workspace CWD = root). +- **`dcr clean --all`** — не спамит `target not found` по members без локального `target/` (общий root `target/`). +- **`error` / `warn`** — красный / жёлтый, вывод на stderr; `Подсказка:` → `Hint:`. +- **`dcr --help` / man** — добавлены `add`, `lint`, `setup`; unknown command → exit code 1. +- **Сообщения NotFound** — `linker not found: ld.lld …` / `{tool} not found …` вместо сырого `os error 2`. + +### EN + +**Added:** + +- **Compile progress `[N/M]`** — live TTY line `compile pkg v0.1.0 [12/41]` so long mono-package builds do not look hung. +- **DCR status verbs** — fixed-width column: `project`, `compile`, `dep`, `ready`, `pack`, `done`, `run`. +- **Cargo feature `archive`** — optional `fatfs` / FAT packing (`cargo build --features archive`). Release CI builds with the feature; without it `[archive]` errors clearly. +- **Integration tests** — `flat_bin_nasm_build`, package `build.target` without CLI flag, stricter workspace `clean --all`. +- **Expanded CI** — unit + integration on Linux/macOS/Windows, archive feature job, rust-cache, clippy default + all-features. + +**Changed:** + +- **CLI no longer forces host triple** — without `--target`, package/member `build.target` is used (bare-metal / ISO post_steps). +- **Relative `-I`/`-L`/`-T` (and `-isystem`/`-idirafter`)** in flags are absolutized against the package root when workspace CWD is the root. +- **`dcr clean --all`** — no spam for members without a local `target/` (shared root `target/`). +- **`error` / `warn`** — red / yellow on stderr; Russian `Подсказка:` → `Hint:`. +- **`dcr --help` / man** — list `add`, `lint`, `setup`; unknown command exits 1. +- **NotFound messages** — `linker not found: ld.lld …` / `{tool} not found …` instead of raw `os error 2`. + ## [0.8.1] - 2026-07-20 "OS-Dev: flat-bin, FAT-образы / OS-Dev: flat-bin & FAT Images" ### RU @@ -12,39 +52,25 @@ - **GAS / MASM / LLVM IR (`llc`)** — объект → `objcopy -O binary` → `.bin` - **C/C++ (gcc/clang/MSVC)** — compile → link (nostdlib/static) → `objcopy -O binary` → `.bin` - Требуется `llvm-objcopy` / `objcopy` / `gobjcopy` в PATH (кроме NASM/FASM direct) -- **Секция `[archive]`** — после успешной сборки DCR собирает образ диска (FAT12/16/32 через `fatfs`): размер, offset, volume label, опциональный bootsector (512 байт в начало при `offset = 0`) и `layout` (копирование файлов/glob в FS). Плейсхолдер `{profile}` в путях. -- **Одиночные файлы в `build.roots`** — корень может быть файлом (`.c`, `.asm`, header), а не только каталогом; то же для сбора заголовков в cache. +- **Секция `[archive]`** — после успешной сборки DCR собирает образ диска (FAT12/16/32): размер, offset, volume label, опциональный bootsector и `layout`. С 0.8.2 — за feature `archive`. +- **Одиночные файлы в `build.roots`** — корень может быть файлом (`.c`, `.asm`, header), а не только каталогом. **Изменено:** - **`dcr build --force` / `dcr run --force`** — force также перезапускает `build.steps` и `build.post_steps`. -- **`dcr run` на workspace-only root** — если задан `[run].cmd`, сначала build + run по конфигу корня; иначе делегирование члену workspace (как в 0.8.0). - -**Зависимости:** - -- `fatfs = "0.3"` для упаковки FAT-образов. +- **`dcr run` на workspace-only root** — если задан `[run].cmd`, сначала build + run по конфигу корня; иначе делегирование члену workspace. ### EN **Added:** -- **`build.kind = "flat-bin"`** — raw binary artifact (default extension `.bin`): - - **NASM** — `-f bin`, direct `.bin` - - **FASM** — direct output (`format binary` in source) - - **GAS / MASM / LLVM IR (`llc`)** — object → `objcopy -O binary` → `.bin` - - **C/C++ (gcc/clang/MSVC)** — compile → link (`-nostdlib -static`) → `objcopy -O binary` → `.bin` - - Needs `llvm-objcopy` / `objcopy` / `gobjcopy` in PATH (except NASM/FASM direct) -- **`[archive]` section** — after a successful build, pack a disk image (FAT12/16/32 via `fatfs`): size, offset, volume label, optional bootsector (512 bytes at start when `offset = 0`), and `layout` (file/glob copy into the FS). `{profile}` substitution in paths. -- **Single-file `build.roots`** — a root may be a file (`.c`, `.asm`, header), not only a directory; header collection in the cache follows the same rule. +- **`build.kind = "flat-bin"`** — raw binary (default `.bin`) across NASM/FASM/GAS/MASM/LLC and C/C++ (objcopy where needed). +- **`[archive]` section** — FAT12/16/32 disk images after build (from 0.8.2 gated by feature `archive`). +- **Single-file `build.roots`**. **Changed:** -- **`dcr build --force` / `dcr run --force`** — force also re-runs `build.steps` and `build.post_steps`. -- **`dcr run` on a workspace-only root** — if `[run].cmd` is set, build + run that command first; otherwise fall back to workspace member delegation (0.8.0 behavior). - -**Dependencies:** - -- `fatfs = "0.3"` for FAT image packing. +- **`--force`** re-runs steps/post_steps; workspace-only **`dcr run`** prefers root `[run].cmd` when set. ## [0.8.0] - 2026-07-18 "Модульный Движок Сборки, Новая Архитектура Ядра и Улучшение Workspaces / Modular Build Engine, New Core Architecture, & Workspace Improvements" diff --git a/Cargo.lock b/Cargo.lock index d654054..1a44f4c 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -154,7 +154,7 @@ dependencies = [ [[package]] name = "dcr" -version = "0.8.1" +version = "0.8.2" dependencies = [ "ctrlc", "fatfs", diff --git a/Cargo.toml b/Cargo.toml index d46ffab..35cd7c1 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "dcr" -version = "0.8.1" +version = "0.8.2" edition = "2024" build = "build.rs" description = "DCR is a utility for managing C/C++ projects in a Cargo-like style." @@ -59,6 +59,10 @@ assets = [ { source = "man/man1/dcr-tree.1", dest = "/usr/share/man/man1/dcr-tree.1", mode = "644" }, ] +[features] +default = [] +archive = ["dep:fatfs"] + [dependencies] glob = "0.3" ureq = { version = "2.10", default-features = false, features = ["json", "native-certs"] } @@ -69,7 +73,7 @@ toml = "1.0.3" toml_edit = "0.22" serde_json = "1" ctrlc = "3" -fatfs = "0.3" +fatfs = { version = "0.3", optional = true } [profile.release] opt-level = "z" diff --git a/TODO.md b/TODO.md deleted file mode 100644 index c660942..0000000 --- a/TODO.md +++ /dev/null @@ -1,65 +0,0 @@ -# DCR TODO.md - -Priority list of tasks to turn DCR into a true Cargo killer for C/C++ developers. - -**Legend:** `[ ]` — not implemented | `[-]` — partially implemented | `[x]` — implemented - -## 🔥 High Priority - -- [ ] **CLI Output Refactoring & Cleanup** - - [ ] Move all terminal strings to a dedicated module (`src/ui/messages.rs`) - - [ ] Standardize logging formats (`error:`, `warning:`, `status:`) - - [x] Add build execution time statistics to the final output (e.g., `Finished in 4.23s`) -- [ ] **Internationalization (i18n) / Localization** - - [ ] Integrate a lightweight localization engine (`fluent` or `gettext` pure-Rust port) - - [ ] Create initial translation catalogs (`en.ftl`, `ru.ftl`) -- [x] **Self-Update Stability Validation** - - [x] Self-update implemented via `self-replace` + `ureq` in `flag_update.rs` -- [-] **Freestanding / Embedded Automation** - - *`-ffreestanding` injected at compile time, `-nostdlib -static` at link time for bare-metal targets or `build.freestanding = true`. Config option `build.freestanding` (bool) added.* -- [ ] **Conan and vcpkg integration** Automatic download, installation and linking of packages - -## ✅ Medium Priority - -- [ ] **Static analysis** (`dcr check`) - Integration with clang-tidy, cppcheck, include-what-you-use -- [x] **Linter + Formatter** (`dcr fmt`, `dcr lint`) - *`dcr fmt` (clang-format) and `dcr lint` (clang-tidy) are implemented* -- [ ] **Hot reload / Live reload** for applications (raylib, SFML, SDL, etc.) -- [-] **Workspaces improvements** Per-member include directories, selective builds, better dependency graph - *Basic workspaces with dep ordering + topological sort work; advanced features missing* -- [-] **Build-time code generation** Support for protobuf, flatbuffers, Qt moc, custom generators - *Generic `build.steps` machinery + Qt toolchain (uic/moc/rcc) work; no dedicated protobuf/flatbuffers generators* -- [-] **dcr publish + official package registry** *Registry consumption (fetch, resolve, link) works; `dcr publish` command / local packing missing* - -## 📌 Low Priority / Nice to Have - -- [ ] Support for Meson and Ninja as alternative backends -- [ ] Dockerfile generation (`dcr docker init`) -- [ ] First-class Windows MSVC support (currently works but rough) -- [ ] Documentation generation (`dcr doc`) -- [ ] Sanitizers integration (`dcr sanitize`) -- [ ] Benchmarks and comparison with CMake/Meson -- [ ] C++20 modules support (when it becomes stable) - -## 🧠 Future Ideas - -- Official DCR package registry (dcrhub) -- GUI wrapper (dcr-gui) -- Plugin system -- Toolchain manager (like rustup) -- Zig as alternative compiler -- deb/rpm/flatpak/AppImage packaging support - ---- - -**Currently in progress:** -- UI/UX terminal output unification and benchmarking metrics. - -**Completed in recent releases:** -- Extreme binary size optimization (-50% weight reduction via `ureq` + `native-certs`) -- Complete removal of `git2` and `openssl` in favor of system Git execution -- Workspaces & Cross-compilation (`--target `) -- IDE config generation (VS Code, CLion, compile_commands.json) -- EFI support & Linker script support (`build.ldscript`) -- Mixed C/C++/ASM compilation with custom `std::thread::scope` work-stealing engine \ No newline at end of file diff --git a/docs/changelog.mdx b/docs/changelog.mdx index d78a810..2e29677 100644 --- a/docs/changelog.mdx +++ b/docs/changelog.mdx @@ -4,6 +4,25 @@ sidebar_label: Changelog # Changelog +## 0.8.2 (2026-07-22) + +### Added + +- **Compile progress `[N/M]`** — live TTY status line (`compile pkg v0.1.0 [12/41]`) so long mono-package builds do not look hung. +- **DCR status style** — fixed-width verbs: `project`, `compile`, `dep`, `ready`, `pack`, `done`, `run`. +- **Cargo feature `archive`** — optional FAT packing via `fatfs` (`cargo build --features archive`). Release CI builds with the feature; without it `[archive]` fails with a clear message. +- **Tests** — `flat_bin_nasm_build`, package `build.target` without CLI `--target`, stricter workspace `clean --all`. +- **CI expansion** — unit + integration on Linux/macOS/Windows, archive feature job, rust-cache, clippy default + all-features (see `.github/workflows/ci.yml`). + +### Changed + +- **No forced host triple from CLI** — without `--target`, package/member `build.target` is honored (bare-metal / ISO `post_steps` paths). +- **Relative include/lib flags** (`-I`, `-i`, `-isystem`, `-idirafter`, `-L`, `-T`) absolutized against the package root under workspace builds. +- **`dcr clean --all`** — no spam for members without a local `target/` (shared root `target/`). +- **`error` / `warn`** — red / yellow on stderr; CLI fully English (`Hint:`). +- **Help / man** — list `add`, `lint`, `setup`; unknown command exits with code 1. +- **Tool NotFound** — `linker not found: ld.lld …` / `{tool} not found …` instead of raw `os error 2`. + ## 0.8.1 (2026-07-20) ### Added @@ -14,7 +33,7 @@ sidebar_label: Changelog - **GAS / MASM / LLC** — object → `objcopy -O binary` → `.bin` - **C/C++** — objects → freestanding link → `objcopy -O binary` → `.bin` - Requires `llvm-objcopy` / `objcopy` / `gobjcopy` except for NASM/FASM direct emit -- **`[archive]` section** — after a successful build, pack a FAT disk image (`fatfs`): `output`, `format` (`fat12`/`fat16`/`fat32`), optional `size` (default 1.44 MiB), `offset`, `label`, `bootsector`, and `layout` (`from` → `to`, supports globs). `{profile}` works in paths. +- **`[archive]` section** — FAT12/16/32 disk images after build (`output`, `format`, `size`, `offset`, `label`, `bootsector`, `layout`). From 0.8.2 requires feature `archive`. - **Single-file `build.roots`** — a root may be a single source or header file, not only a directory. ### Changed @@ -22,10 +41,6 @@ sidebar_label: Changelog - **`--force`** also re-runs `build.steps` and `build.post_steps`. - **`dcr run` on workspace-only root** — if `[run].cmd` is set, run that after build; otherwise delegate to a workspace member. -### Dependencies - -- `fatfs = "0.3"` for FAT image packing. - ## 0.8.0 (2026-07-18) ### Added diff --git a/docs/contributing.mdx b/docs/contributing.mdx index d91c7fd..8883c5b 100644 --- a/docs/contributing.mdx +++ b/docs/contributing.mdx @@ -42,9 +42,10 @@ cargo test --all-targets ## CI -CI runs: +CI runs (see `.github/workflows/ci.yml`): - `cargo fmt --check` -- `cargo clippy --all-targets -- -D warnings` +- `cargo clippy` (default + `--all-features`) - `cargo check --all-targets --all-features` -- Build on Linux, macOS, Windows -- Integration tests (compilation check) +- Unit + integration tests on Linux, macOS, Windows +- Extra Linux job with `--features archive` (FAT images) +- Tools on runners: clang, nasm, clang-format/tidy (Linux) diff --git a/docs/reference/dcr-toml.mdx b/docs/reference/dcr-toml.mdx index b806c58..45273f1 100644 --- a/docs/reference/dcr-toml.mdx +++ b/docs/reference/dcr-toml.mdx @@ -183,6 +183,8 @@ See [workspaces](/docs/reference/workspaces). Optional post-build step: format a FAT volume and copy built artifacts into a disk image. Runs after a successful package build (and after workspace member builds that define `[archive]`). +Requires DCR built with the `archive` Cargo feature (`cargo build --features archive`). Release binaries include this feature. + | Field | Required | Description | |-------|----------|-------------| | `output` | yes | Image path relative to project root (`{profile}` allowed) | diff --git a/man/man1/dcr.1 b/man/man1/dcr.1 index 183c570..4af6cfd 100644 --- a/man/man1/dcr.1 +++ b/man/man1/dcr.1 @@ -38,11 +38,14 @@ Display the dependency tree of the current project. .B fmt Format all C/C++ source files using clang-format. .TP +.B lint [\fI\-\-fix\fR] +Run clang-tidy static analysis on C/C++ sources. +.TP .B gen \fI\fR Generate IDE integration files (vscode, clion, compile-commands, project-info). .TP .B setup -Set up DCR registries for dependency resolution. +Show configured package registries. .SH GLOBAL FLAGS .TP .B \-\-help diff --git a/src/cli/build.rs b/src/cli/build.rs index 0c7881c..36bae24 100644 --- a/src/cli/build.rs +++ b/src/cli/build.rs @@ -17,18 +17,29 @@ use crate::cli::clean::clean; use crate::cli::flags::parse_build_run_flags; +use crate::core::build::common; use crate::core::build::{BuildEvent, BuildReporter, BuildRequest, run_build}; use crate::core::build_config::Config; -use crate::utils::build::default_target_triple; use crate::utils::fs::find_project_root; use crate::utils::log::error; -use crate::utils::text::{BOLD_CYAN, BOLD_GREEN, colored, printc}; +use crate::utils::text::{BOLD_CYAN, BOLD_GREEN, BOLD_YELLOW, colored, printc}; +use std::io::IsTerminal; use std::sync::{Arc, atomic::AtomicBool}; pub use crate::core::build::get_build_string_with_profile; +fn status(verb: &str, style: &str) -> String { + colored(&format!("{verb:<9}"), style) +} + struct CliReporter; +impl CliReporter { + fn line(&self, verb: &str, style: &str, rest: &str) { + eprintln!(" {} {}", status(verb, style), rest); + } +} + impl BuildReporter for CliReporter { fn on_event(&mut self, event: BuildEvent<'_>) { match event { @@ -37,73 +48,57 @@ impl BuildReporter for CliReporter { total, target, } => { - println!(" Building target {} of {}: {}", index, total, target); + common::finish_progress_line(); + self.line("target", BOLD_CYAN, &format!("{index}/{total} {target}")); } BuildEvent::ProjectStart { name, profile, target, } => { - println!( - " Building project `{}`\n Profile: {}\n Target: {}", - colored(name, BOLD_GREEN), - colored(profile, BOLD_GREEN), - colored(target, BOLD_GREEN) + common::finish_progress_line(); + self.line( + "project", + BOLD_CYAN, + &format!("{name} ({profile}, {target})"), ); } BuildEvent::DepBuilding { name, version } => { - print!( - "\r{:100}\r {} {} v{}", - "", - colored("Building", BOLD_GREEN), - name, - version - ); - std::io::Write::flush(&mut std::io::stdout()).unwrap(); + common::finish_progress_line(); + self.line("dep", BOLD_YELLOW, &format!("{name} v{version}")); } BuildEvent::DepReady { name, version, rebuilt, } => { + common::finish_progress_line(); if rebuilt { - print!( - "\r{:100}\r {} {} v{}", - "", - colored("Ready", BOLD_GREEN), - name, - version - ); - println!(); - } else { - println!( - " {} {} v{}", - colored("Ready", BOLD_GREEN), - name, - version - ); + self.line("ready", BOLD_GREEN, &format!("{name} v{version}")); } } BuildEvent::Compiling { name, version } => { - println!( - " {} {} v{}", - colored("Compiling", BOLD_GREEN), - name, - version - ); + common::finish_progress_line(); + let label = format!(" {} {} v{}", status("compile", BOLD_GREEN), name, version); + common::set_progress_label(Some(label.clone())); + if !std::io::stderr().is_terminal() { + eprintln!("{label}"); + } + } + BuildEvent::Packing { path } => { + common::finish_progress_line(); + self.line("pack", BOLD_CYAN, path); } BuildEvent::Finished { secs } => { - println!( - " {} Build completed successfully in {} seconds", - colored("✔", BOLD_GREEN), - colored(&secs.to_string(), BOLD_GREEN) - ); + common::finish_progress_line(); + self.line("done", BOLD_GREEN, &format!("in {secs}s")); } BuildEvent::CompilerOutput { stream, text } => { + common::interrupt_progress_for_output(); if stream == "stderr" { - eprintln!("{}", text); + eprint!("{text}"); } else { - println!("{}", text); + print!("{text}"); } } } @@ -166,15 +161,12 @@ pub fn build(args: &[String]) -> i32 { if let Ok(config) = Config::open(config_path.to_str().unwrap()) && !config.is_workspace_only() { - let bt = get_build_string_with_profile(&config, "target", "debug"); + let bt = get_build_string_with_profile(&config, "target", &flags.profile); if !bt.is_empty() { flags.target = Some(bt); } } } - if flags.target.is_none() { - flags.target = Some(default_target_triple()); - } if flags.clean { let mut clean_args = Vec::new(); clean_args.push(format!("--{}", flags.profile)); @@ -193,6 +185,7 @@ pub fn build(args: &[String]) -> i32 { match run_build(&root, &req, &mut reporter) { Ok(_) => 0, Err(err) => { + common::finish_progress_line(); error(&err.message); 1 } diff --git a/src/cli/clean.rs b/src/cli/clean.rs index 296b038..66b73ee 100644 --- a/src/cli/clean.rs +++ b/src/cli/clean.rs @@ -146,7 +146,10 @@ fn clean_from_root(root: &Path, flags: &CleanFlags) -> Result<(), String> { )? { for member in &workspace.members { - clean_project_at(&member.path, flags.profile.as_deref(), target.as_deref())?; + let member_target = member.path.join("target"); + if member_target.is_dir() { + clean_project_at(&member.path, flags.profile.as_deref(), target.as_deref())?; + } } } clean_project_at(root, flags.profile.as_deref(), target.as_deref()) diff --git a/src/cli/help.rs b/src/cli/help.rs index eb791a1..0f3d771 100644 --- a/src/cli/help.rs +++ b/src/cli/help.rs @@ -29,9 +29,12 @@ pub fn help() -> i32 { println!(" init Initialize the current directory as a project"); println!(" build [--profile] Build the project (default: --debug)"); println!(" run [--profile] Build and run the project (default: --debug)"); + println!(" add ... Add a dependency to dcr.toml"); println!(" tree Display the dependency tree"); println!(" test Run project tests (alias: tests)"); println!(" fmt Format all C/C++ source files using clang-format"); + println!(" lint Run clang-tidy on C/C++ sources"); + println!(" setup Show configured package registries"); println!(" clean Remove the target directory"); println!(" gen Generate IDE integration files"); printc("FLAGS:", BOLD_GREEN); diff --git a/src/cli/new.rs b/src/cli/new.rs index c9d7651..e133ae8 100644 --- a/src/cli/new.rs +++ b/src/cli/new.rs @@ -85,7 +85,7 @@ pub fn new(args: &[String]) -> i32 { "Directory `{}` already exists\n", colored(project_name, BOLD_CYAN) )); - printc("Подсказка:", BOLD_CYAN); + printc("Hint:", BOLD_CYAN); println!( " Use `{}` to initialize an existing project\n or specify a different project name", colored("dcr init", BOLD_CYAN) diff --git a/src/cli/run.rs b/src/cli/run.rs index 49d216b..9bcc731 100644 --- a/src/cli/run.rs +++ b/src/cli/run.rs @@ -19,9 +19,7 @@ use crate::cli::build::build; use crate::cli::flags::parse_build_run_flags; use crate::core::build_config::Config; use crate::core::runner::run_binary; -use crate::utils::build::{ - default_target_triple, normalize_target_os, parse_version_info, substitute_vars, -}; +use crate::utils::build::{normalize_target_os, parse_version_info, substitute_vars}; use crate::utils::fs::find_project_root; use crate::utils::fs::with_dir; use crate::utils::log::error; @@ -114,8 +112,11 @@ pub fn run(args: &[String]) -> i32 { if let Some(cmd) = get_run_cmd(&config, &flags.profile, flags.target.as_deref(), "") { let build_status = build(&args_for_build(&flags)); if build_status == 0 { - println!("\n {} {}", colored("Running", BOLD_GREEN), cmd); - println!("--------------------------------"); + println!( + " {} {}", + colored(&format!("{:<9}", "run"), BOLD_GREEN), + cmd + ); return run_shell(&cmd); } return build_status; @@ -186,10 +187,13 @@ fn run_project( .and_then(|v| v.as_str()) .unwrap_or(""); - // If no target specified, use default host target for target-specific config let mut target = flags.target.clone(); if target.is_none() { - target = Some(default_target_triple()); + let bt = + crate::cli::build::get_build_string_with_profile(&config, "target", &flags.profile); + if !bt.is_empty() { + target = Some(bt); + } } let build_kind = config @@ -246,12 +250,18 @@ fn run_project( ); if build_status == 0 { if let Some(cmd) = run_cmd { - println!("\n {} {}", colored("Running", BOLD_GREEN), cmd); - println!("--------------------------------"); + println!( + " {} {}", + colored(&format!("{:<9}", "run"), BOLD_GREEN), + cmd + ); return Ok(run_shell(&cmd)); } - println!("\n {} {}", colored("Running", BOLD_GREEN), bin_path); - println!("--------------------------------"); + println!( + " {} {}", + colored(&format!("{:<9}", "run"), BOLD_GREEN), + bin_path + ); return Ok(run_binary( project_name, &flags.profile, diff --git a/src/core/build/builder/artifact.rs b/src/core/build/builder/artifact.rs index 73d8c5e..1a1c22a 100644 --- a/src/core/build/builder/artifact.rs +++ b/src/core/build/builder/artifact.rs @@ -130,7 +130,14 @@ pub(crate) fn link_flat_binary( if ctx.verbose || std::env::var("DCR_DEBUG").is_ok() { eprintln!("[dcr] {:?}", cmd); } - let output = cmd.output().map_err(|err| format!("Build failed: {err}"))?; + let program = cmd.get_program().to_string_lossy().into_owned(); + let output = cmd.output().map_err(|err| { + if err.kind() == std::io::ErrorKind::NotFound { + format!("linker not found: {program} (check [toolchain].ld / PATH)") + } else { + format!("flat-bin link failed: {err}") + } + })?; if !output.status.success() { let stderr = String::from_utf8_lossy(&output.stderr); let stdout = String::from_utf8_lossy(&output.stdout); @@ -240,7 +247,15 @@ fn run(ctx: &BuildContext, mut cmd: Command, start_time: Instant) -> Result. use std::fs; +use std::io::{self, IsTerminal, Write}; use std::path::{Path, PathBuf}; use std::process::Command; +use std::sync::atomic::{AtomicBool, Ordering}; use std::sync::{Mutex, OnceLock}; use std::time::Instant; static OUTPUT_MUTEX: OnceLock> = OnceLock::new(); +static PROGRESS_LABEL: OnceLock>> = OnceLock::new(); +static PROGRESS_DIRTY: AtomicBool = AtomicBool::new(false); pub fn get_output_lock() -> &'static Mutex<()> { OUTPUT_MUTEX.get_or_init(|| Mutex::new(())) } +fn progress_label_lock() -> &'static Mutex> { + PROGRESS_LABEL.get_or_init(|| Mutex::new(None)) +} + +pub fn set_progress_label(label: Option) { + *progress_label_lock().lock().unwrap() = label; +} + +pub fn finish_progress_line() { + let was_dirty = PROGRESS_DIRTY.swap(false, Ordering::SeqCst); + *progress_label_lock().lock().unwrap() = None; + if !was_dirty { + return; + } + if io::stderr().is_terminal() { + let _guard = get_output_lock().lock().unwrap(); + let _ = writeln!(io::stderr()); + let _ = io::stderr().flush(); + } +} + +pub fn interrupt_progress_for_output() { + if !PROGRESS_DIRTY.swap(false, Ordering::SeqCst) { + return; + } + if io::stderr().is_terminal() { + let _guard = get_output_lock().lock().unwrap(); + let _ = writeln!(io::stderr()); + let _ = io::stderr().flush(); + } +} + +fn report_compile_progress(done: usize, total: usize) { + let label = progress_label_lock().lock().unwrap().clone(); + let Some(label) = label else { + return; + }; + if !io::stderr().is_terminal() { + return; + } + let _guard = get_output_lock().lock().unwrap(); + let msg = format!("{label} [{done}/{total}]"); + if PROGRESS_DIRTY.load(Ordering::SeqCst) { + eprint!("\r{msg:<80}"); + } else { + eprint!("{msg}"); + } + let _ = io::stderr().flush(); + PROGRESS_DIRTY.store(true, Ordering::SeqCst); +} + pub fn collect_sources( roots: &[PathBuf], extensions: &[&str], @@ -214,8 +269,13 @@ where }; let counter = std::sync::atomic::AtomicUsize::new(0); + let completed = std::sync::atomic::AtomicUsize::new(0); let err_msg = std::sync::Mutex::new(None); + if total_tasks > 0 { + report_compile_progress(0, total_tasks); + } + std::thread::scope(|s| { for _ in 0..num_threads { s.spawn(|| { @@ -236,6 +296,9 @@ where } break; } + + let done = completed.fetch_add(1, std::sync::atomic::Ordering::Relaxed) + 1; + report_compile_progress(done, total_tasks); } }); } @@ -249,10 +312,21 @@ where } pub fn run_command_sync_output(cmd: &mut Command) -> Result<(), String> { - let output = cmd.output().map_err(|err| format!("Build failed: {err}"))?; - let _guard = OUTPUT_MUTEX.get_or_init(|| Mutex::new(())).lock().unwrap(); + let program = cmd.get_program().to_string_lossy().into_owned(); + let output = cmd.output().map_err(|err| { + if err.kind() == std::io::ErrorKind::NotFound { + format!("{program} not found (check PATH / [toolchain])") + } else { + format!("Build failed: {err}") + } + })?; + let has_out = !output.stdout.is_empty() || !output.stderr.is_empty(); + if has_out { + interrupt_progress_for_output(); + } + let _guard = get_output_lock().lock().unwrap(); if !output.stdout.is_empty() { - print!("{}", String::from_utf8_lossy(&output.stdout)); + eprint!("{}", String::from_utf8_lossy(&output.stdout)); } if !output.stderr.is_empty() { eprint!("{}", String::from_utf8_lossy(&output.stderr)); diff --git a/src/core/build/engine.rs b/src/core/build/engine.rs index bb306b9..02521ad 100644 --- a/src/core/build/engine.rs +++ b/src/core/build/engine.rs @@ -90,7 +90,9 @@ fn run_compile( _rep: &mut dyn BuildReporter, ) -> Result { let start_time = Instant::now(); - match build_project(ctx) { + let result = build_project(ctx); + common::finish_progress_line(); + match result { Ok(times) => { let times = if times == 0.0 { ((start_time.elapsed().as_secs_f64() * 100.0).trunc()) / 100.0 @@ -166,7 +168,17 @@ fn build_all( )?; } if let Some(archive) = &config.typed().archive { - super::archive::pack_archive(root, archive, profile)?; + #[cfg(feature = "archive")] + { + super::archive::pack_archive(root, archive, profile)?; + } + #[cfg(not(feature = "archive"))] + { + let _ = (archive, profile); + return Err( + "disk image packing requires building dcr with --features archive".to_string(), + ); + } } return Ok(0.0); } @@ -777,10 +789,12 @@ fn build_project_at( let resolved_cflags: Vec = resolved_cflags .iter() .map(|f| substitute_vars(f, &version_info, profile, &project_name)) + .map(|f| absolutize_flag_path(&f, project_root, &["-isystem", "-idirafter", "-I", "-i"])) .collect(); let modified_ldflags: Vec = resolved_ldflags .iter() .map(|f| substitute_vars(f, &version_info, profile, &project_name)) + .map(|f| absolutize_flag_path(&f, project_root, &["-L", "-T"])) .collect(); let merged_include_dirs: Vec = merged_include_dirs .iter() @@ -876,11 +890,11 @@ fn build_project_at( if skip && !debug_enabled { return Ok(()); } - rep.on_event(BuildEvent::Compiling { - name: &project_name, - version: &project_version, - }); if !skip { + rep.on_event(BuildEvent::Compiling { + name: &project_name, + version: &project_version, + }); run_compile(&ctx, cancel, rep)?; if cancel.load(Ordering::SeqCst) { return Err("Build interrupted".to_string()); @@ -906,10 +920,42 @@ fn build_project_at( } verify_expectations(&build_expects, &step_vars)?; if let Some(archive) = &config.typed().archive { - super::archive::pack_archive(project_root, archive, profile)?; + let out = archive.output.replace("{profile}", profile); + rep.on_event(BuildEvent::Packing { path: &out }); + #[cfg(feature = "archive")] + { + super::archive::pack_archive(project_root, archive, profile)?; + } + #[cfg(not(feature = "archive"))] + { + let _ = (project_root, archive, profile, out); + return Err( + "disk image packing requires building dcr with --features archive".to_string(), + ); + } } Ok(()) } + +fn absolutize_flag_path(flag: &str, project_root: &Path, prefixes: &[&str]) -> String { + for prefix in prefixes { + if let Some(rest) = flag.strip_prefix(prefix) { + if rest.is_empty() { + return flag.to_string(); + } + if rest.starts_with('/') || rest.starts_with('@') { + return flag.to_string(); + } + if rest.len() >= 2 && rest.as_bytes()[1] == b':' { + return flag.to_string(); + } + let abs = project_root.join(rest); + return format!("{prefix}{}", abs.to_string_lossy()); + } + } + flag.to_string() +} + fn find_target_root(dir: &str, fallback: &Path) -> PathBuf { let p = Path::new(dir); for ancestor in p.ancestors() { @@ -1094,3 +1140,35 @@ fn is_on_path(cmd: &str) -> bool { std::env::var_os("PATH") .is_some_and(|paths| std::env::split_paths(&paths).any(|dir| dir.join(cmd).is_file())) } + +#[cfg(test)] +mod tests { + use super::absolutize_flag_path; + use std::path::Path; + + #[test] + fn absolutize_prefers_long_include_prefixes() { + let root = Path::new("/pkg"); + let prefs = ["-isystem", "-idirafter", "-I", "-i"]; + assert_eq!( + absolutize_flag_path("-isystemvendor/inc", root, &prefs), + "-isystem/pkg/vendor/inc" + ); + assert_eq!( + absolutize_flag_path("-idiraftervendor/old", root, &prefs), + "-idirafter/pkg/vendor/old" + ); + assert_eq!( + absolutize_flag_path("-I../inc", root, &prefs), + "-I/pkg/../inc" + ); + assert_eq!( + absolutize_flag_path("-i../inc", root, &prefs), + "-i/pkg/../inc" + ); + assert_eq!( + absolutize_flag_path("-I/usr/include", root, &prefs), + "-I/usr/include" + ); + } +} diff --git a/src/core/build/mod.rs b/src/core/build/mod.rs index 27ea698..4139744 100644 --- a/src/core/build/mod.rs +++ b/src/core/build/mod.rs @@ -15,6 +15,7 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . +#[cfg(feature = "archive")] pub mod archive; pub mod builder; pub mod cache; diff --git a/src/core/build/report.rs b/src/core/build/report.rs index d439a21..a23c2ca 100644 --- a/src/core/build/report.rs +++ b/src/core/build/report.rs @@ -69,6 +69,9 @@ pub enum BuildEvent<'a> { name: &'a str, version: &'a str, }, + Packing { + path: &'a str, + }, CompilerOutput { stream: &'a str, text: &'a str, diff --git a/src/core/build_config.rs b/src/core/build_config.rs index f77149d..96c6f42 100644 --- a/src/core/build_config.rs +++ b/src/core/build_config.rs @@ -120,6 +120,7 @@ pub struct ArchiveConfig { pub layout: Vec, } +#[allow(dead_code)] #[derive(Debug, Clone, Deserialize)] pub struct ArchiveLayout { pub from: String, diff --git a/src/main.rs b/src/main.rs index c238e76..2305790 100644 --- a/src/main.rs +++ b/src/main.rs @@ -57,7 +57,7 @@ fn main() { "--update" => cli::flag_update::flag_update(rest), _ => { error("Unknown command or argument"); - 0 + 1 } }; diff --git a/src/utils/log.rs b/src/utils/log.rs index f565cfe..8d3ad6d 100644 --- a/src/utils/log.rs +++ b/src/utils/log.rs @@ -15,27 +15,14 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . -use crate::utils::text::{BOLD_CYAN, colored}; +use crate::utils::text::{BOLD_RED, BOLD_YELLOW, colored}; #[allow(dead_code)] pub fn error(msg: &str) { - println!("{}: {msg}", colored("error", BOLD_CYAN),); + eprintln!("{}: {msg}", colored("error", BOLD_RED)); } #[allow(dead_code)] pub fn warn(msg: &str) { - println!("{}: {msg}", colored("warn", BOLD_CYAN),); + eprintln!("{}: {msg}", colored("warn", BOLD_YELLOW)); } - -// #[allow(dead_code)] -// pub fn info(msg: &str) { -// println!("{}: {msg}", colored("info", BOLD)); -// } -// -// #[allow(dead_code)] -// pub fn ok(msg: &str) { -// println!( -// "{}: {msg}", -// colored("ok", &(BRIGHT_GREEN.to_owned() + BOLD)) -// ); -// } diff --git a/tests/cli_build.rs b/tests/cli_build.rs index 3b02f26..7e8b190 100644 --- a/tests/cli_build.rs +++ b/tests/cli_build.rs @@ -77,8 +77,15 @@ fn build_run_clean_flags_normal_project() { assert!(out.status.success(), "dcr build --release should succeed"); let out = run_dcr_env(&["run"], &dir, &envs); - let stdout = String::from_utf8_lossy(&out.stdout); - assert!(stdout.contains("Running"), "dcr run should start"); + let combined = format!( + "{}{}", + String::from_utf8_lossy(&out.stdout), + String::from_utf8_lossy(&out.stderr) + ); + assert!( + combined.contains("run") || combined.contains("Running"), + "dcr run should start" + ); let out = run_dcr_env(&["clean", "--release"], &dir, &envs); assert!(out.status.success(), "dcr clean --release should succeed"); @@ -170,3 +177,92 @@ fn build_with_out_dir() { "artifact should NOT be at default path when out_dir is set" ); } + +#[test] +fn flat_bin_nasm_build() { + let nasm_ok = std::process::Command::new("nasm") + .arg("-v") + .output() + .map(|o| o.status.success()) + .unwrap_or(false); + if !nasm_ok { + eprintln!("nasm not found; skipping flat-bin test"); + return; + } + + let dir = unique_sandbox_dir("flat_bin"); + let out = run_dcr(&["init"], &dir); + assert!(out.status.success(), "dcr init should succeed"); + + std::fs::write( + dir.join("dcr.toml"), + r#"[package] +name = "flatdemo" +version = "0.1.0" + +[build] +language = "asm" +compiler = "nasm" +kind = "flat-bin" +extension = "bin" +roots = ["src"] +"#, + ) + .expect("write dcr.toml"); + + std::fs::create_dir_all(dir.join("src")).expect("src"); + std::fs::write( + dir.join("src/boot.asm"), + "bits 16\norg 0x7c00\ncli\nhlt\ntimes 510-($-$$) db 0\ndw 0xaa55\n", + ) + .expect("write boot.asm"); + + let out = run_dcr(&["build"], &dir); + if !out.status.success() { + eprintln!("stdout: {}", String::from_utf8_lossy(&out.stdout)); + eprintln!("stderr: {}", String::from_utf8_lossy(&out.stderr)); + } + assert!(out.status.success(), "flat-bin nasm build should succeed"); + + let candidates = [ + dir.join("target/debug/boot.bin"), + dir.join("target").join(format!( + "{}-unknown-linux-gnu/debug/boot.bin", + std::env::consts::ARCH + )), + ]; + assert!( + candidates.iter().any(|p| p.is_file()), + "expected boot.bin under target/…/debug, candidates: {candidates:?}" + ); +} + +#[test] +fn package_build_target_used_without_cli_flag() { + let Some(compiler) = available_compiler() else { + eprintln!("no compiler found; skipping package target test"); + return; + }; + + let dir = unique_sandbox_dir("pkg_target"); + let out = run_dcr(&["init"], &dir); + assert!(out.status.success()); + + let toml_path = dir.join("dcr.toml"); + let toml = std::fs::read_to_string(&toml_path).unwrap(); + let project_name = parse_project_name(&toml); + let updated = toml.replace("[build]", "[build]\ntarget = \"x86_64-unknown-linux-gnu\""); + std::fs::write(&toml_path, updated).unwrap(); + + let envs = [("DCR_COMPILER", compiler)]; + let out = run_dcr_env(&["build"], &dir, &envs); + assert!(out.status.success(), "build should use package target"); + + let artifact = dir + .join("target/x86_64-unknown-linux-gnu/debug") + .join(&project_name); + assert!( + artifact.is_file(), + "artifact should be under package build.target path" + ); +} diff --git a/tests/cli_errors.rs b/tests/cli_errors.rs index fa6b967..2a761d9 100644 --- a/tests/cli_errors.rs +++ b/tests/cli_errors.rs @@ -92,9 +92,17 @@ fn no_args_shows_help() { fn unknown_command_fails() { let dir = unique_sandbox_dir("unknown_cmd"); let out = run_dcr(&["foobar"], &dir); - let stdout = String::from_utf8_lossy(&out.stdout); assert!( - stdout.contains("error") || stdout.contains("Unknown"), + !out.status.success(), + "unknown command should exit non-zero" + ); + let combined = format!( + "{}{}", + String::from_utf8_lossy(&out.stdout), + String::from_utf8_lossy(&out.stderr) + ); + assert!( + combined.contains("error") || combined.contains("Unknown"), "unknown command should print error" ); } @@ -104,9 +112,13 @@ fn build_without_toml_fails() { let dir = unique_sandbox_dir("build_no_toml"); let out = run_dcr(&["build"], &dir); assert!(!out.status.success(), "build without dcr.toml should fail"); - let stdout = String::from_utf8_lossy(&out.stdout); + let combined = format!( + "{}{}", + String::from_utf8_lossy(&out.stdout), + String::from_utf8_lossy(&out.stderr) + ); assert!( - stdout.contains("dcr.toml") || stdout.contains("not found"), + combined.contains("dcr.toml") || combined.contains("not found"), "should mention missing dcr.toml" ); } @@ -132,9 +144,13 @@ fn new_existing_dir_fails() { std::fs::create_dir_all(dir.join("hello")).expect("failed to create dir"); let out = run_dcr(&["new", "hello"], &dir); assert!(!out.status.success(), "dcr new on existing dir should fail"); - let stdout = String::from_utf8_lossy(&out.stdout); + let combined = format!( + "{}{}", + String::from_utf8_lossy(&out.stdout), + String::from_utf8_lossy(&out.stderr) + ); assert!( - stdout.contains("already exists") || stdout.contains("error"), + combined.contains("already exists") || combined.contains("error"), "should report dir already exists" ); } @@ -149,9 +165,13 @@ fn init_nonempty_dir_fails() { !out.status.success(), "dcr init in non-empty dir should fail" ); - let stdout = String::from_utf8_lossy(&out.stdout); + let combined = format!( + "{}{}", + String::from_utf8_lossy(&out.stdout), + String::from_utf8_lossy(&out.stderr) + ); assert!( - stdout.contains("not empty") || stdout.contains("error"), + combined.contains("not empty") || combined.contains("error"), "should report dir not empty" ); } @@ -186,9 +206,13 @@ fn run_library_project_fails() { let envs = [("DCR_COMPILER", compiler)]; let out = run_dcr_env(&["run"], &dir, &envs); assert!(!out.status.success(), "dcr run on staticlib should fail"); - let stdout = String::from_utf8_lossy(&out.stdout); + let combined = format!( + "{}{}", + String::from_utf8_lossy(&out.stdout), + String::from_utf8_lossy(&out.stderr) + ); assert!( - stdout.contains("library") || stdout.contains("Cannot run"), + combined.contains("library") || combined.contains("Cannot run"), "should report cannot run library" ); } @@ -226,9 +250,13 @@ fn new_no_name_fails() { let dir = unique_sandbox_dir("new_noname"); let out = run_dcr(&["new"], &dir); assert!(!out.status.success(), "dcr new without name should fail"); - let stdout = String::from_utf8_lossy(&out.stdout); + let combined = format!( + "{}{}", + String::from_utf8_lossy(&out.stdout), + String::from_utf8_lossy(&out.stderr) + ); assert!( - stdout.contains("not specified") || stdout.contains("error"), + combined.contains("not specified") || combined.contains("error"), "should report name not specified" ); } diff --git a/tests/cli_workspace.rs b/tests/cli_workspace.rs index c16d8ab..6059bcc 100644 --- a/tests/cli_workspace.rs +++ b/tests/cli_workspace.rs @@ -45,6 +45,16 @@ fn workspace_build_and_clean_all() { out.status.success(), "workspace clean --all --release should succeed" ); + let combined = format!( + "{}{}", + String::from_utf8_lossy(&out.stdout), + String::from_utf8_lossy(&out.stderr) + ); + let spam = combined.matches("Directory target not found").count(); + assert!( + spam <= 1, + "clean --all should not spam missing member target/: {combined}" + ); let target_dir = "target/x86_64-unknown-linux-gnu"; assert!( @@ -55,4 +65,8 @@ fn workspace_build_and_clean_all() { root.join(target_dir).join("debug").exists(), "root target/x86_64-unknown-linux-gnu/debug should remain" ); + + let out = run_dcr_env(&["clean", "--all"], &root, &envs); + assert!(out.status.success(), "workspace clean --all should succeed"); + assert!(!root.join("target").exists(), "root target/ should be gone"); }