ceedling 1.2.0 → 1.2.2

data/docs/Changelog.md

@@ -8,6 +8,87 @@ This changelog is complemented by three other documents:
 1. 💔 **[Breaking Changes](BreakingChanges.md)** for a list of impacts to existing Ceedling projects.
 1. 🐛 **[Known Issues](KnownIssues.md)** for a list of presently known problems and limitations.
 
+Each release has its own section, listing only what changed in that release.
+
+---
+
+# [1.2.2] — 2026-10-31
+
+## 💪 Fixed
+
+- Fixed the [Valgrind plugin](https://docs.throwtheswitch.org/Ceedling/1.2.0/plugins/valgrind/) writing no report, and reporting a crash, for any test below its test root. The [Raw Output Log plugin](https://docs.throwtheswitch.org/Ceedling/1.2.0/plugins/report-tests-raw-output-log/) failed to write such a test’s log.
+- Fixed [`:use_backtrace: :gdb`](https://docs.throwtheswitch.org/Ceedling/1.2.0/configuration/reference/project/#use_backtrace) logs of same-named tests sharing one file, and every log collecting crashes from earlier builds. A crash summary pointed to a log whose first trace could be stale. Each test now has its own logs, and each holds only the latest crash.
+- Fixed [TeamCity plugin](https://docs.throwtheswitch.org/Ceedling/1.2.0/plugins/report-tests-teamcity-stdout/) naming the suites of same-named tests alike. A suite is now named by its test’s path, and escaped as TeamCity requires.
+- [#1369](https://github.com/ThrowTheSwitch/Ceedling/issues/1369) Fixed [TeamCity](https://docs.throwtheswitch.org/Ceedling/1.2.0/plugins/report-tests-teamcity-stdout/) test names and failure details going out unescaped. A test path or case name holding `'`, `|`, `[`, `]`, or a line break broke the service message, and TeamCity misread or dropped the test’s result.
+- Fixed checking of [`TEST_SOURCE_FILE()`](https://docs.throwtheswitch.org/Ceedling/1.2.0/testing-guide/build-directives/#test_source_file) entries:
+   - Each test now checks only its own entries, removing unnecessarily duplicated checks yielding a test build speedup.
+   - A misspelled entry now stops the build with an error naming its own test. Previously, the error could name another test, and with [`:use_test_preprocessor`](https://docs.throwtheswitch.org/Ceedling/1.2.0/configuration/reference/project/#use_test_preprocessor) `:none` or `:mocks` the entry went unchecked (see [Breaking Changes](BreakingChanges.md)).
+   - An entry using `..` is no longer rejected with test preprocessing on.
+- A “Multiple files matched” notice now prints once a build, not once for every lookup that makes the same choice.
+- Fixed a [delta build](https://docs.throwtheswitch.org/Ceedling/1.2.0/getting-started/builds/) keeping a test executable or release artifact after a source file left the build — deleted, excluded through `:files`, or moved outside `:paths` — while every other object was unchanged. A test kept passing on the removed code, even with `--force-test-rerun`, and a release artifact kept it. A link now rebuilds whenever its list of objects changes.
+- [#1365](https://github.com/ThrowTheSwitch/Ceedling/issues/1365) Fixed a project that selects another Ceedling installation — through [`:project` ↳ `:which_ceedling`](https://docs.throwtheswitch.org/Ceedling/1.2.0/configuration/which-ceedling/), `WHICH_CEEDLING`, or a `vendor/ceedling/` copy — running on a mix of both installations’ code. Across versions it failed outright: a 1.2.1 `ceedling` could not run a project vendoring 1.2.0. A development checkout selected this way silently ran partly on the gem’s code. Each command now runs whole in the installation it selects (see _Changed_).
+- Fixed [`ceedling version`](https://docs.throwtheswitch.org/Ceedling/1.2.0/getting-started/command-line/#ceedling-version) reporting the launcher’s version number for the application and ignoring a project’s `:which_ceedling`. It now reads your project file and takes `--project` and `--mixin`.
+- Fixed `ceedling new`, `ceedling example`, and `ceedling examples` running the launcher’s code with the installation `WHICH_CEEDLING` selects, and `new` recording the launcher’s version in `:ceedling_version:`. `docs` ignored the selection. It now exports the selected installation’s documentation, or the launcher’s with a notice when the selected installation holds none, as a `--local` copy does not.
+- Fixed `ceedling upgrade` run inside a `--local` project deleting the project’s vendored Ceedling and then failing to copy from it (see [Breaking Changes](BreakingChanges.md)).
+- [#1371](https://github.com/ThrowTheSwitch/Ceedling/issues/1371) Fixed `ceedling upgrade` never refreshing documentation that `new --docs` or `example --docs` exported since 1.1.0. It now replaces only what the export wrote, and leaves your own files in `docs/`. Previously, a project exported by 1.0.x lost all of `docs/`.
+- Fixed a `--local` project’s `./ceedling` failing since 1.1.0 with “`vendor/ceedling/vendor/unity/test/targets` does not exist”. Vendoring now copies Unity’s built-in mixins. Re-vendor an existing project with `ceedling upgrade`.
+- Fixed the `./ceedling` launch script splitting arguments that contain spaces, such as `--test-case="adds two"` or an inline YAML `--mixin`.
+- Fixed backslashes in a `WHICH_CEEDLING` or `:which_ceedling` path going unconverted.
+- [#1366](https://github.com/ThrowTheSwitch/Ceedling/issues/1366) Fixed the [gcov plugin](https://docs.throwtheswitch.org/Ceedling/1.2.0/plugins/gcov/gcovr/#fail_under_decision) repeating gcovr’s first coverage threshold message for every violated `:fail_under_*` threshold, and losing the others. Each violated threshold is now its own build failure, with gcovr’s own message. From gcovr 8.7, `:fail_under_decision` also checks condition coverage, which `:mcdc` produces.
+- [#1368](https://github.com/ThrowTheSwitch/Ceedling/issues/1368) Fixed a [delta build](https://docs.throwtheswitch.org/Ceedling/1.2.0/getting-started/builds/) not relinking a test or release when a library it links changes. A link now depends on the library files its [`:libraries`](https://docs.throwtheswitch.org/Ceedling/1.2.0/configuration/reference/libraries/) entries name on `:paths` ↳ `:libraries`, and on the libraries the Dependencies plugin builds.
+- Fixed a [Unity helper](https://docs.throwtheswitch.org/Ceedling/1.2.0/configuration/reference/cmock/#unity_helper_path) named by its header compiling that header instead of the source beside it. A helper written with backslashes was also included in mocks by its whole path.
+- [#1377](https://github.com/ThrowTheSwitch/Ceedling/issues/1377) Fixed the [FFF plugin](https://docs.throwtheswitch.org/Ceedling/1.2.0/plugins/fff/#cmock-configuration) leaving out the headers that `:cmock` ↳ `:includes_c_pre_header`, `:includes_c_post_header`, and `:includes_h_pre_orig_header` name, so a fake could fail to compile where a mock of the same header compiled. Fakes now include them where CMock does. A [Unity helper](https://docs.throwtheswitch.org/Ceedling/1.2.0/configuration/reference/cmock/#unity_helper_path) is now included in a fake’s source, as in a mock’s.
+- Fixed the [Dependencies plugin](https://docs.throwtheswitch.org/Ceedling/1.2.0/plugins/dependencies/) placing an absolute artifact or include path below its `:artifact` path, and `:build_lib` writing its list files into the working directory.
+
+### Path handling
+
+The bulk of the fixes that follow are the consequence of funneling all path handling through common hygiene, standardized path creation beneath the project build root, and handling for a variety edge cases. While extensive, this list of fixes addresses problems most projects never encountered.
+
+- [#1376](https://github.com/ThrowTheSwitch/Ceedling/issues/1376) Fixed the copy of Unity, CMock, and CException into the build directory failing when Ruby reports a vendored file as a directory, as it can for a Ruby installation on a Windows network share with Data Deduplication. The copy left a directory where the file belongs, and every later build failed on it. Ceedling now tells files from directories without that misreport, and replaces any entry of the wrong type with a notice. `ceedling new --local`, `upgrade`, and `example` list what they copy the same way. This is best effort, since Ceedling cannot vouch for every filesystem (see [Known Issues](KnownIssues.md)).
+- [#1364](https://github.com/ThrowTheSwitch/Ceedling/issues/1364) Fixed test builds stopping with “Ambiguous file reference” when a test file’s name ended another test file’s path, such as `test/test_calc.c` beside `test/unit/test_calc.c`. It stopped `test:all`, a test named by its full path, and plugin builds such as `gcov:all`. Each test is now properly [named by its path from the project root](https://docs.throwtheswitch.org/Ceedling/1.2.0/testing-guide/conventions/#test-names-build-output), and its build finds its own source by that name.
+- Fixed two test files sharing one build name, so that one silently replaced the other: tests under overlapping `:paths` ↳ `:test` roots (e.g. `test/**` and `test/unit/**`), the same layout under two roots, or a `:files` ↳ `:test` test outside every root. Since 1.2.0, the error above hid it.
+- Fixed a directory of tests named like a test beside it, such as `test/test_foo/` beside `test/test_foo.c`, making a mock both tests use ambiguous.
+- [#1373](https://github.com/ThrowTheSwitch/Ceedling/issues/1373) Fixed tests failing to run under a path holding an apostrophe or a space. Every case reported a crash, or the build stopped. The default tools that run a test executable, and the tools for the CppCheck, Dependencies, and Valgrind plugins now quote the paths they name.
+- [#1370](https://github.com/ThrowTheSwitch/Ceedling/issues/1370) Fixed mocking a header found below a `:paths` root such as `../**` beside headers far outside the project, such as `C:/Keil_v5/…`. The mock was written outside the build directory, and the build stopped with “Found no file … in search paths”. Ceedling now compares paths by the directories they name, not by their text.
+- Fixed same-named sources in one build sharing one object, so that one silently replaced the other. This happened with release sources below two roots (e.g. `src/foo.c` and `lib/foo.c`), sources below nested roots (`src/util.c` and `src/legacy/util.c`), sources named by `:files`, gcov and Bullseye untested sources, and sources the Dependencies plugin’s `:build_lib` compiles. Each now builds to its own object (see _Changed_). Two sources that would still build to one file stop the build with an error naming both.
+- Fixed a `:paths` entry written as `./src/**`, as an absolute path, or through a symlink not matching the same directories written as `src/**`. A header below such a root missed the source beside it, and its mock missed its directory.
+- Fixed a `:paths` root such as `../**` or `./**` collecting the build directory’s own generated mocks, runners, and objects.
+- Fixed a `:files` glob such as `+:**/*.c` collecting the build directory’s own mocks, runners, and vendored Unity and CMock sources, which stopped a release build. A `:files` glob now adds nothing from the build directory.
+- Fixed a `:files` glob such as `+:**/*.c`, or a source root holding the test root, collecting test files into a release build, which then stopped compiling them. A `:files` revision also no longer adds a test file to the source collection.
+- Fixed a `-:` `:paths` entry naming a directory that does not exist, such as one below the build root before a first build, failing validation. It now logs a warning, or nothing below the build root.
+- Fixed `:project` ↳ `:build_root: .` letting `clobber` delete the project’s own `test/` directory. Such a build root is now refused (see [Breaking Changes](BreakingChanges.md)).
+- Fixed `~` in a configured path naming a directory called `~`. It now names your home directory in `:paths`, `:files`, `:project` ↳ `:build_root`, every `*_path` setting, tool executables, mixins, `--project`, `--logfile`, `:which_ceedling`, `WHICH_CEEDLING`, plugin load paths, and the Dependencies plugin’s paths.
+- Fixed `-L` linker arguments repeating `:paths` ↳ `:libraries` entries as written, decorators and globs included (see _Changed_).
+- Fixed a [`TEST_INCLUDE_PATH()`](https://docs.throwtheswitch.org/Ceedling/1.2.0/testing-guide/build-directives/#test_include_path) written differently from its `:paths` entry, such as with `./`, ranking its headers last among same-named candidates.
+- Fixed `test:` tasks naming a test with `./` or a leading `..`, such as `ceedling test:../tests/test_x`.
+- Fixed mocks failing to compile in three cases: a mock whose `#include` folder shares the test file’s name, two same-named mocks told apart only by their `#include` folders, and a mock `#include` spelling more path than its header’s directory with [`:cmock` ↳ `:mock_name_include_folder`](https://docs.throwtheswitch.org/Ceedling/1.2.0/configuration/reference/cmock/#mock_name_include_folder) disabled.
+- Fixed an absolute [`:release_build` ↳ `:output`](https://docs.throwtheswitch.org/Ceedling/1.2.0/configuration/reference/release-build/#output) placed below the release build directory. It now names the release itself, with its map file beside it.
+- Fixed the log directory and plugin load paths ignoring inline Ruby string expansion and backslashes when read before configuration loads.
+- Fixed a test in a project directory named `_up_` or `_abs_` sharing a build name with a test outside the project.
+
+## ⚠️ Changed
+
+- Each test’s build output, results, and logs now sit beneath [its path from the project root](https://docs.throwtheswitch.org/Ceedling/1.2.0/testing-guide/conventions/#test-names-build-output). `test/unit/test_calc.c`, once `unit/test_calc`, is now `test/unit/test_calc`, and a test at its root gains its root (e.g. `build/artifacts/valgrind/test/test_calc.log`). The first build after upgrading rebuilds everything once and logs a warning saying so. Run `ceedling clobber` to remove the output left in the old layout, which [coverage reports](https://docs.throwtheswitch.org/Ceedling/1.2.0/plugins/gcov/) would otherwise still read. See [Breaking Changes](BreakingChanges.md).
+- A command that selects another Ceedling installation now runs in that installation’s own process, handed off by the `ceedling` command you run. Both sides log a notice naming both versions. Every command except `version` hands off this way, adding about 0.2 seconds. See [Which Ceedling](https://docs.throwtheswitch.org/Ceedling/1.2.0/configuration/which-ceedling/) and [Breaking Changes](BreakingChanges.md).
+- A 1.2.2 application loaded by an older launcher into its own process warns and restarts in its own process.
+- Each object, preprocessed file, and dependencies file now sits below its build directory at its source’s path from the project root. In test `test/test_uart`, `src/drivers/uart.c` builds to `build/test/out/test/test_uart/src/drivers/uart.o`, and a release builds it to `build/release/out/src/drivers/uart.o`. A source outside the project gains `_up_` for each `..` (e.g. `_up_/shared/src/crc.o`), and a file of the running Ceedling installation outside the project sits below `_ceedling_`. Mocks, runners, and vendored frameworks keep their places. The first build after upgrading recompiles each moved object once. See [Breaking Changes](BreakingChanges.md).
+- A `-:` `:paths` entry now removes the directory it names and every directory below it, unless an additive entry names one of them more closely, as `+:src/legacy/keep` does beside `-:src/legacy`. See [Breaking Changes](BreakingChanges.md).
+- A `:paths` or `:files` entry within the build root now logs a warning, and no entry collects from the directories Ceedling and its plugins create, such as `build/test/` or `build/vendor/`. See [Breaking Changes](BreakingChanges.md).
+- `-L` linker arguments now name the directories `:paths` ↳ `:libraries` entries collect, as any `:paths` entry does. An entry that collects no existing directory adds no `-L` argument.
+- Copying Unity, CMock, and CException into the build directory (for short paths and to alleviate possible network filesystem issues with a shared gem installation) retries a file only on an error that clears on its own, such as another program holding the file open, and fails at once on any other. Vendored files are always writable by their owner.
+- `ceedling new --local`, `upgrade`, and `example` now copy the contents of a linked directory within a Ceedling installation, and stop on a link loop.
+- Ceedling’s file and path code moved to `lib/ceedling/filesystem/`. A third-party plugin that requires one of its files directly must name the new path (see [Breaking Changes](BreakingChanges.md)). Plugin development currently makes no guarantees as to the location of internal Ceedling resources.
+
+---
+
+# [1.2.1] — 2026-10-24
+
+## 💪 Fixed
+
+- [#1360](https://github.com/ThrowTheSwitch/Ceedling/issues/1360) Fixed a delta build reporting another run’s cached test results when the [`--test-case` or `--exclude_test_case`](https://docs.throwtheswitch.org/Ceedling/1.2.0/getting-started/command-line/#ceedling-test-test-casetest_case_name) filter changed between runs. It affected every project whose [`:use_backtrace`](https://docs.throwtheswitch.org/Ceedling/1.2.0/configuration/reference/project/#use_backtrace) is not `:none`, including the `:simple` default. A changed filter now reruns the test executable without recompiling or relinking it. An unchanged filter still reuses the cached results.
+- [#1361](https://github.com/ThrowTheSwitch/Ceedling/issues/1361) Fixed every command that loads a project, `files:test` and `dumpconfig` included, rewriting the vendored Unity, CMock, and CException sources in `build/vendor/` in place. A second command run while a build compiled could leave the compiler reading a half-written header. Only a test build or release build now brings `build/vendor/` up to date. A vendored file that already matches its source is no longer written, and one that differs (e.g. after an accidental edit) is replaced whole.
+- [#1362](https://github.com/ThrowTheSwitch/Ceedling/issues/1362) Fixed [`gcov:`](https://docs.throwtheswitch.org/Ceedling/1.2.0/plugins/gcov/), [`valgrind:`](https://docs.throwtheswitch.org/Ceedling/1.2.0/plugins/valgrind/), [`sanitize:`](https://docs.throwtheswitch.org/Ceedling/1.2.0/plugins/sanitize/), and [`bullseye:`](https://docs.throwtheswitch.org/Ceedling/1.2.0/plugins/bullseye/) single-file tasks rejecting a project-relative path, such as `gcov:test/test_calculator.c`. They now accept a path to tell same-named test files apart, as [`test:` tasks](https://docs.throwtheswitch.org/Ceedling/1.2.0/getting-started/command-line/#ceedling-test) do.
+
 ---
 
 # [1.2.0] — 2026-10-21
@@ -108,7 +189,7 @@ The new [Sanitize plugin](https://docs.throwtheswitch.org/Ceedling/1.2.0/plugins
 [#1110](https://github.com/ThrowTheSwitch/Ceedling/issues/1110) A dependency can now list the programs it builds under [`:artifacts` ↳ `:executables`](https://docs.throwtheswitch.org/Ceedling/1.2.0/plugins/dependencies/#executables) for tools rather than libraries. A release build or [`dependencies:make`](https://docs.throwtheswitch.org/Ceedling/1.2.0/plugins/dependencies/#ceedling-dependenciesmake) builds them when missing, test builds do not wait on them, and they are never linked. [`dependencies:deploy`](https://docs.throwtheswitch.org/Ceedling/1.2.0/plugins/dependencies/#ceedling-dependenciesdeploy) copies them, along with [dynamic libraries](https://docs.throwtheswitch.org/Ceedling/1.2.0/plugins/dependencies/#dynamic_libraries), to a new optional [`:paths` ↳ `:deploy`](https://docs.throwtheswitch.org/Ceedling/1.2.0/plugins/dependencies/#working-paths) folder, by default beside the release executable.
 
 ### Build warnings plugin context, deduplication, and filtering
-The [Build Warnings Log plugin](https://docs.throwtheswitch.org/Ceedling/1.2.0/plugins/report-build-warnings-log/) now logs each GCC or Clang warning with the lines that explain it — the function or include context before it along with the source line, caret, and any note after it. Each distinct warning is logged once per build context, so a header's warning appears once rather than once per file including it, and compiler summary lines are left out. New [`:patterns`](https://docs.throwtheswitch.org/Ceedling/1.2.0/plugins/report-build-warnings-log/#patterns) and [`:excludes`](https://docs.throwtheswitch.org/Ceedling/1.2.0/plugins/report-build-warnings-log/#excludes) settings optionally take regular expressions that replace the default match of any line mentioning “warning” and optionally drop warnings you have already accepted or prevent false positives.
+The [Build Warnings Log plugin](https://docs.throwtheswitch.org/Ceedling/1.2.0/plugins/report-build-warnings-log/) now logs each GCC or Clang warning with the lines that explain it — the function or include context before it along with the source line, caret, and any note after it. Each distinct warning is logged once per build context, so a header’s warning appears once rather than once per file including it, and compiler summary lines are left out. New [`:patterns`](https://docs.throwtheswitch.org/Ceedling/1.2.0/plugins/report-build-warnings-log/#patterns) and [`:excludes`](https://docs.throwtheswitch.org/Ceedling/1.2.0/plugins/report-build-warnings-log/#excludes) settings optionally take regular expressions that replace the default match of any line mentioning “warning” and optionally drop warnings you have already accepted or prevent false positives.
 
 ### Build warnings plugin SARIF and JSON reports
 The [Build Warnings Log plugin](https://docs.throwtheswitch.org/Ceedling/1.2.0/plugins/report-build-warnings-log/#reports) can now write its warnings as [SARIF](https://docs.throwtheswitch.org/Ceedling/1.2.0/plugins/report-build-warnings-log/#sarif-report) and [JSON](https://docs.throwtheswitch.org/Ceedling/1.2.0/plugins/report-build-warnings-log/#json-report) reports alongside, or instead of, its plain [text log](https://docs.throwtheswitch.org/Ceedling/1.2.0/plugins/report-build-warnings-log/#text-report). SARIF, the standard format for static analysis results, lets GitHub code scanning, Azure DevOps, SonarQube, Jenkins, and IDE viewers show each warning on the line it concerns. The [JSON report](https://docs.throwtheswitch.org/Ceedling/1.2.0/plugins/report-build-warnings-log/#json-report) lists each warning’s file, line, column, severity, flag, message, and context for scripts. The new [`:reports`](https://docs.throwtheswitch.org/Ceedling/1.2.0/plugins/report-build-warnings-log/#reports) setting selects any of `:text`, `:sarif`, and `:json`, and defaults to `:text`. The structured reports are written for every build context that ran a build step, even without warnings, so a CI step always finds its file.
@@ -196,10 +277,10 @@ Note: 1.2.0 includes all bug fixes for 1.1.x.
 - [#1076](https://github.com/ThrowTheSwitch/Ceedling/issues/1076) Fixed a second [`dependencies:fetch`](https://docs.throwtheswitch.org/Ceedling/1.2.0/plugins/dependencies/#ceedling-dependenciesfetch), or a [`dependencies:make`](https://docs.throwtheswitch.org/Ceedling/1.2.0/plugins/dependencies/#ceedling-dependenciesmake) after a fetch, failing because `git clone` ran into the already-populated folder. A dependency whose fetch path holds files now counts as fetched, and [`dependencies:clean`](https://docs.throwtheswitch.org/Ceedling/1.2.0/plugins/dependencies/#ceedling-dependenciesclean) allows a fresh fetch. [Working paths](https://docs.throwtheswitch.org/Ceedling/1.2.0/plugins/dependencies/#working-paths) are no longer created ahead of fetching, which made a clone into a fetch path containing the build path fail.
 - [#1110](https://github.com/ThrowTheSwitch/Ceedling/issues/1110) Fixed [`dependencies:deploy`](https://docs.throwtheswitch.org/Ceedling/1.2.0/plugins/dependencies/#ceedling-dependenciesdeploy) trying to copy a file named for the dependency rather than its dynamic libraries. It now copies every [dynamic library](https://docs.throwtheswitch.org/Ceedling/1.2.0/plugins/dependencies/#dynamic_libraries) from the artifact path beside the release executable.
 - Fixed a [`:tar_gzip`](https://docs.throwtheswitch.org/Ceedling/1.2.0/plugins/dependencies/#fetching-dependencies) fetch from an absolute Windows path failing with "Cannot connect to D: resolve failed" where GNU tar, as Git for Windows provides, came first on the path. GNU tar reads a path beginning with a drive letter as a remote host, so `tar` now reads the archive on its standard input.
-- Fixed a dependency's [`:environment`](https://docs.throwtheswitch.org/Ceedling/1.2.0/plugins/dependencies/#environment-variables) variables lasting for the rest of the run, reaching every later dependency and Ceedling itself. They now apply only while that dependency's commands run. An entry not of the form `NAME=value`, `NAME+=value`, or `NAME-=value` now stops the build rather than being ignored. Text after `+=` and `-=` now keeps its leading space, so an appended flag can carry the delimiter it needs.
+- Fixed a dependency’s [`:environment`](https://docs.throwtheswitch.org/Ceedling/1.2.0/plugins/dependencies/#environment-variables) variables lasting for the rest of the run, reaching every later dependency and Ceedling itself. They now apply only while that dependency’s commands run. An entry not of the form `NAME=value`, `NAME+=value`, or `NAME-=value` now stops the build rather than being ignored. Text after `+=` and `-=` now keeps its leading space, so an appended flag can carry the delimiter it needs.
 - Fixed a dependency without [`:artifacts`](https://docs.throwtheswitch.org/Ceedling/1.2.0/plugins/dependencies/#artifacts) crashing the build. Configuration problems now stop the build with a message naming the dependency: a missing name, a name without letters or digits, two names sharing a task name, an unknown [fetch method](https://docs.throwtheswitch.org/Ceedling/1.2.0/plugins/dependencies/#fetching-dependencies), or a fetch method missing its `:source` or `:executable`.
 - Fixed an [`:includes`](https://docs.throwtheswitch.org/Ceedling/1.2.0/plugins/dependencies/#includes) glob under [`:artifacts`](https://docs.throwtheswitch.org/Ceedling/1.2.0/plugins/dependencies/#artifacts) expanding against the working directory rather than the artifact path, and joining every directory it found into one path.
-- Fixed [`:build_lib`](https://docs.throwtheswitch.org/Ceedling/1.2.0/plugins/dependencies/#building-dependencies) depending on the process working directory, and miscomputing where to copy its library when the `:artifact` path was absolute or climbed with `..`. The [`:deps_compiler`](https://docs.throwtheswitch.org/Ceedling/1.2.0/plugins/dependencies/#custom-tools) tool now receives its search paths and defines as `${5}` and `${6}`, like Ceedling's own [compilers](https://docs.throwtheswitch.org/Ceedling/1.2.0/configuration/reference/tools/#tool-element-runtime-substitution-notational-substitution).
+- Fixed [`:build_lib`](https://docs.throwtheswitch.org/Ceedling/1.2.0/plugins/dependencies/#building-dependencies) depending on the process working directory, and miscomputing where to copy its library when the `:artifact` path was absolute or climbed with `..`. The [`:deps_compiler`](https://docs.throwtheswitch.org/Ceedling/1.2.0/plugins/dependencies/#custom-tools) tool now receives its search paths and defines as `${5}` and `${6}`, like Ceedling’s own [compilers](https://docs.throwtheswitch.org/Ceedling/1.2.0/configuration/reference/tools/#tool-element-runtime-substitution-notational-substitution).
 
 ### Valgrind & Cppcheck plugins
 

data/docs/KnownIssues.md

@@ -6,6 +6,8 @@ Known issues are complemented by three other documents:
 1. 🪵 **[Changelog](Changelog.md)** for a structured list of additions, fixes, changes, and removals.
 1. 💔 **[Breaking Changes](BreakingChanges.md)** for a list of impacts to existing Ceedling projects.
 
+Each release has its own section, listing every issue known to affect it. An issue that persists appears again in each later release. A section for an earlier release closes by naming what a later release resolved. Before 1.2.0, a section covers a whole minor version.
+
 ---
 
 ## All versions
@@ -14,15 +16,89 @@ Known issues are complemented by three other documents:
 
 ---
 
+## 1.2.2 — 2026-10-31
+
+Ceedling 1.2.x requires Ruby 3+ but only unofficially supports Ruby 4.
+
+1. The new internal pipeline as of 1.0.0 that allows builds to be parallelized and configured per-test-executable can mean a fair amount of duplication of steps. A header file may be mocked identically multiple times. The same source file may be compiled identically multiple times. Delta builds (as of 1.2.0) offer considerable build time savings as do the speedup gains due to parallelization as of 1.0.0. Future releases will optimize away duplication of build steps.
+1. An `#include` directive must resolve to a file within your project’s configured `:paths` search collection. A path that would resolve outside your configured search paths (e.g. via relative paths beyond search paths or excessive `..` parent-directory segments) is now rejected with a clear, specific error rather than silently causing a confusing downstream build failure.
+1. With test preprocessing enabled, a test file’s `#include` of a mock whose name comes from a macro defined only in a header, as in `#include MOCK_HEADER` with `MOCK_HEADER` defined in another header, cannot be found. Define the macro under `:defines` ↳ `:test` so the test file sees it directly.
+1. Fallback preprocessing remains a best effort with no guarantees. It is used where your toolchain’s preprocessor does not support `-fdirectives-only` or where you force it with `:test_build` ↳ `:preprocess_force_fallback`. Its handling of conditional compilation is limited and may not resolve the same branches your compiler would. Macro expansion is not supported at all.
+1. Delta builds track a library only when they find its file on `:paths` ↳ `:libraries`, or the Dependencies plugin builds it. An “untracked” library found only among your toolchain’s internal search paths, or through a `-L` written into `:flags`, relinks nothing when it changes. Run `ceedling clobber` after such a library changes.
+1. On Linux and macOS, a test, source, or build path holding `"`, `$`, a backtick, or `\` can still break the commands Ceedling runs. So can any path in a tool you define with an unquoted `${1}`. Quote your own tools’ paths, as [`:tools`](https://docs.throwtheswitch.org/Ceedling/1.2.0/configuration/reference/tools/) describes.
+1. Paths for `TEST_SOURCE_FILE(...)` remain relative to **_project root_** — that is, from where you execute `ceedling` at the command line. If you move source files or change your directory structure, `TEST_SOURCE_FILE(...)` calls referencing moved files will need to be updated.
+1. The `ceedling` command of an installation before 1.2.2, such as a 1.2.1 gem, loads a 1.2.2 application that a project selects into its own process. The 1.2.2 application restarts itself in its own process. `new`, `example`, `examples`, `upgrade`, `docs`, and `help` without a project never load the application, so they still run on the older installation’s code. Upgrade the Ceedling whose `ceedling` command you run, typically the gem, to 1.2.2.
+1. The `ceedling` command you run parses your command line before it hands off to the installation a project selects. It rejects an option that only the selected installation knows. Run the selected installation’s own launcher instead, such as a `--local` project’s `./ceedling` launch script from the project root (`.\ceedling.cmd` on Windows).
+1. A mock `#include` written relative to the test file that climbs with `..` to a directory the mock search paths do not reach, such as `#include "../src/drivers/mock_foo.h"`, fails to compile, as in earlier releases. Include the mock relative to a search path instead, such as `#include "drivers/mock_foo.h"`.
+1. On Windows, a source far outside the project lengthens its build paths, since each `..` in its path from the project adds `_up_/`. Ceedling warns as a path nears Windows’ 260-character limit.
+
+### Partials
+
+1. A module whose header protects itself with `#pragma once` instead of a traditional `#ifndef` include guard can still hit a `redefinition` or `conflicting types` error, if any other header your module uses reaches that header in turn. Ceedling suppresses the real header by defining its include guard, and `#pragma once` provides no guard to define. Converting the module’s header to a traditional include guard works around it.
+1. A type created by a macro invocation rather than written out — the list and queue building macros in `sys/queue.h`, for instance — is not recognized as a type, and a Partial using one fails to compile with an `unknown type name` error.
+1. A `struct`, `union`, or `enum` written directly on a variable, as in `static struct { int depth; } slot;`, is treated as a variable alone. The generated Partial states the type twice and fails to compile.
+1. A `struct`, `union`, or `enum` named but not defined, as in `struct node;`, is reproduced in the generated Partial as an invalid declaration. Builds treating warnings as errors fail on it.
+1. A macro the module retires with `#undef` is carried into the generated Partial anyway, so the name stays visible to your test file and can collide with another macro of the same name.
+1. Exposing a module’s file-scope variables and functions removes what kept their names private to that module. Two Partialized modules in one test file that each use the same name for a file-scope variable collide at link time.
+1. Partials cannot generate a module that text-only fallback preprocessing is unable to resolve — a module with an `#include` naming a macro, or with a type behind a conditional expression that cannot be evaluated without a real preprocessor. Ceedling stops the build and names the file and line rather than generating something subtly wrong. Fallback preprocessing is only used where your compiler does not support `-fdirectives-only`, older Apple Clang releases most notably, or where you force it with `:test_build` ↳ `:preprocess_force_fallback`.
+
+---
+
+## 1.2.1 — 2026-10-24
+
+Ceedling 1.2.x requires Ruby 3+ but only unofficially supports Ruby 4.
+
+1. The new internal pipeline as of 1.0.0 that allows builds to be parallelized and configured per-test-executable can mean a fair amount of duplication of steps. A header file may be mocked identically multiple times. The same source file may be compiled identically multiple times. Delta builds (as of 1.2.0) offer considerable build time savings as do the speedup gains due to parallelization as of 1.0.0. Future releases will optimize away duplication of build steps.
+1. An `#include` directive must resolve to a file within your project’s configured `:paths` search collection. A path that would resolve outside your configured search paths (e.g. via relative paths beyond search paths or excessive `..` parent-directory segments) is now rejected with a clear, specific error rather than silently causing a confusing downstream build failure.
+1. With test preprocessing enabled, a test file’s `#include` of a mock whose name comes from a macro defined only in a header, as in `#include MOCK_HEADER` with `MOCK_HEADER` defined in another header, cannot be found. Define the macro under `:defines` ↳ `:test` so the test file sees it directly.
+1. Fallback preprocessing remains a best effort with no guarantees. It is used where your toolchain’s preprocessor does not support `-fdirectives-only` or where you force it with `:test_build` ↳ `:preprocess_force_fallback`. Its handling of conditional compilation is limited and may not resolve the same branches your compiler would. Macro expansion is not supported at all.
+1. Delta builds track the libraries a test or release links only by their `-l` and `-L` arguments, not their contents. A library rebuilt or replaced under the same name, such as one the Dependencies plugin builds, relinks nothing. Tests report results against the old library, and a release keeps it. Run `ceedling clobber` after a library changes ([#1368](https://github.com/ThrowTheSwitch/Ceedling/issues/1368)).
+1. A test can't run when its file name, its directory below its test root, or the build root holds a space, an apostrophe, or another character the shell reads, such as `&`, `;`, `(`, or `|`. Every case reports a crash, or the build stops. Paths the cppcheck, Dependencies, and Valgrind tools name break the same way. Rename the file or directory, or quote the test fixture’s executable: `:tools` ↳ `:test_fixture` ↳ `:executable: '"${1}"'` ([#1373](https://github.com/ThrowTheSwitch/Ceedling/issues/1373)).
+1. Paths for `TEST_SOURCE_FILE(...)` remain relative to **_project root_** — that is, from where you execute `ceedling` at the command line. If you move source files or change your directory structure, `TEST_SOURCE_FILE(...)` calls referencing moved files will need to be updated.
+1. The `ceedling` command loads the application of the installation a project selects — through `:project` ↳ `:which_ceedling`, `WHICH_CEEDLING`, or a `vendor/ceedling/` copy — into its own process, where the two installations’ code mixes. For example, the 1.2.1 gem’s `ceedling` command fails in a project vendoring 1.2.0, and a development checkout selected this way runs partly on the gem’s code. Upgrade the Ceedling whose `ceedling` command you run, typically the gem, to 1.2.2 ([#1365](https://github.com/ThrowTheSwitch/Ceedling/issues/1365)).
+1. A `--local` project’s `./ceedling` fails with “`vendor/ceedling/vendor/unity/test/targets` does not exist”, because vendoring leaves out Unity’s built-in mixins. Running the project with the gem’s `ceedling` command works around it.
+1. A mocked header found below a `:paths` root such as `../**`, beside headers far outside the project, has its mock written outside the build directory, and the build stops with “Found no file … in search paths”. Give those headers’ own directories as roots instead of `..` ([#1370](https://github.com/ThrowTheSwitch/Ceedling/issues/1370)).
+1. Same-named sources in one build can share one object, so that one replaces the other. This happens with release sources below two roots, sources below nested roots, and sources named by `:files`. Rename one of them.
+1. `:project` ↳ `:build_root: .` lets `clobber` delete the project’s own `test/` directory. Give the build a directory of its own, such as `build`.
+1. Where Windows Data Deduplication has optimized the gem’s files, as on a deduplicated network share holding your Ruby installation, Ruby’s `File.lstat` can report such a file as a directory. Ruby can mistake the reparse point that deduplication leaves on the file for a directory. A copy that trusts `lstat`, as Ceedling 1.2.0 and earlier did, makes a directory in `build/vendor/` where the file belongs. Ceedling 1.2.1 removes such a directory only when it stands in for `unity.c`, `cmock.c`, or `CException.c`. One standing in for any other vendored file, such as `unity.h`, fails every build. Delete `build/vendor/` and rebuild ([#1376](https://github.com/ThrowTheSwitch/Ceedling/issues/1376)).
+1. A `-:` `:paths` entry removes only the directory it names, not the directories below it. Add a `-:` entry for each, or use a glob such as `-:src/legacy/**`.
+1. `~` in a configured path names a directory called `~`, not your home directory. Write the full path instead.
+1. A `:files` glob such as `+:**/*.c` collects the build directory’s own mocks, runners, and vendored Unity and CMock sources, and test files, and a release build then stops compiling them. Write the glob below your own source directories, such as `+:src/**/*.c`. A source root holding the test root also collects test files into a release build; add a `-:` `:files` entry for them.
+
+### Partials
+
+1. A module whose header protects itself with `#pragma once` instead of a traditional `#ifndef` include guard can still hit a `redefinition` or `conflicting types` error, if any other header your module uses reaches that header in turn. Ceedling suppresses the real header by defining its include guard, and `#pragma once` provides no guard to define. Converting the module’s header to a traditional include guard works around it.
+1. A type created by a macro invocation rather than written out — the list and queue building macros in `sys/queue.h`, for instance — is not recognized as a type, and a Partial using one fails to compile with an `unknown type name` error.
+1. A `struct`, `union`, or `enum` written directly on a variable, as in `static struct { int depth; } slot;`, is treated as a variable alone. The generated Partial states the type twice and fails to compile.
+1. A `struct`, `union`, or `enum` named but not defined, as in `struct node;`, is reproduced in the generated Partial as an invalid declaration. Builds treating warnings as errors fail on it.
+1. A macro the module retires with `#undef` is carried into the generated Partial anyway, so the name stays visible to your test file and can collide with another macro of the same name.
+1. Exposing a module’s file-scope variables and functions removes what kept their names private to that module. Two Partialized modules in one test file that each use the same name for a file-scope variable collide at link time.
+1. Partials cannot generate a module that text-only fallback preprocessing is unable to resolve — a module with an `#include` naming a macro, or with a type behind a conditional expression that cannot be evaluated without a real preprocessor. Ceedling stops the build and names the file and line rather than generating something subtly wrong. Fallback preprocessing is only used where your compiler does not support `-fdirectives-only`, older Apple Clang releases most notably, or where you force it with `:test_build` ↳ `:preprocess_force_fallback`.
+
+Resolved in 1.2.2: the mixing of two installations’ code, `./ceedling` failing in a `--local` project, delta builds not relinking a changed library, most shell characters in a path stopping a test from running, and the path handling problems above: mocks written outside the build directory, same-named sources sharing an object, `clobber` emptying a project under a `.` build root, `-:` entries keeping the directories below them, and `~`. Also resolved: a directory left in `build/vendor/` for a file `lstat` misreported failing every build. The [Changelog](Changelog.md) lists every other fix since this release.
+
+---
+
 ## 1.2.0 — 2026-10-21
 
-Ceedling 1.2.0 requires Ruby 3+ but only unoficially supports Ruby 4.
+Ceedling 1.2.x requires Ruby 3+ but only unofficially supports Ruby 4.
 
 1. The new internal pipeline as of 1.0.0 that allows builds to be parallelized and configured per-test-executable can mean a fair amount of duplication of steps. A header file may be mocked identically multiple times. The same source file may be compiled identically multiple times. Delta builds (as of 1.2.0) offer considerable build time savings as do the speedup gains due to parallelization as of 1.0.0. Future releases will optimize away duplication of build steps.
-1. An `#include` directive must resolve to a file within your project's configured `:paths` search collection. A path that would resolve outside your configured search paths (e.g. via relative paths beyond search paths or excessive `..` parent-directory segments) is now rejected with a clear, specific error rather than silently causing a confusing downstream build failure.
+1. An `#include` directive must resolve to a file within your project’s configured `:paths` search collection. A path that would resolve outside your configured search paths (e.g. via relative paths beyond search paths or excessive `..` parent-directory segments) is now rejected with a clear, specific error rather than silently causing a confusing downstream build failure.
 1. With test preprocessing enabled, a test file’s `#include` of a mock whose name comes from a macro defined only in a header, as in `#include MOCK_HEADER` with `MOCK_HEADER` defined in another header, cannot be found. Define the macro under `:defines` ↳ `:test` so the test file sees it directly.
 1. Fallback preprocessing remains a best effort with no guarantees. It is used where your toolchain’s preprocessor does not support `-fdirectives-only` or where you force it with `:test_build` ↳ `:preprocess_force_fallback`. Its handling of conditional compilation is limited and may not resolve the same branches your compiler would. Macro expansion is not supported at all.
+1. Delta builds track the libraries a test or release links only by their `-l` and `-L` arguments, not their contents. A library rebuilt or replaced under the same name, such as one the Dependencies plugin builds, relinks nothing. Tests report results against the old library, and a release keeps it. Run `ceedling clobber` after a library changes ([#1368](https://github.com/ThrowTheSwitch/Ceedling/issues/1368)).
+1. A test can't run when its file name, its directory below its test root, or the build root holds a space, an apostrophe, or another character the shell reads, such as `&`, `;`, `(`, or `|`. Every case reports a crash, or the build stops. Paths the cppcheck, Dependencies, and Valgrind tools name break the same way. Rename the file or directory, or quote the test fixture’s executable: `:tools` ↳ `:test_fixture` ↳ `:executable: '"${1}"'` ([#1373](https://github.com/ThrowTheSwitch/Ceedling/issues/1373)).
 1. Paths for `TEST_SOURCE_FILE(...)` remain relative to **_project root_** — that is, from where you execute `ceedling` at the command line. If you move source files or change your directory structure, `TEST_SOURCE_FILE(...)` calls referencing moved files will need to be updated.
+1. The `ceedling` command loads the application of the installation a project selects — through `:project` ↳ `:which_ceedling`, `WHICH_CEEDLING`, or a `vendor/ceedling/` copy — into its own process, where the two installations’ code mixes. For example, the 1.2.1 gem’s `ceedling` command fails in a project vendoring 1.2.0, and a development checkout selected this way runs partly on the gem’s code. Upgrade the Ceedling whose `ceedling` command you run, typically the gem, to 1.2.2 ([#1365](https://github.com/ThrowTheSwitch/Ceedling/issues/1365)).
+1. A `--local` project’s `./ceedling` fails with “`vendor/ceedling/vendor/unity/test/targets` does not exist”, because vendoring leaves out Unity’s built-in mixins. Running the project with the gem’s `ceedling` command works around it.
+1. A mocked header found below a `:paths` root such as `../**`, beside headers far outside the project, has its mock written outside the build directory, and the build stops with “Found no file … in search paths”. Give those headers’ own directories as roots instead of `..` ([#1370](https://github.com/ThrowTheSwitch/Ceedling/issues/1370)).
+1. Same-named sources in one build can share one object, so that one replaces the other. This happens with release sources below two roots, sources below nested roots, and sources named by `:files`. Rename one of them.
+1. `:project` ↳ `:build_root: .` lets `clobber` delete the project’s own `test/` directory. Give the build a directory of its own, such as `build`.
+1. Where Windows Data Deduplication has optimized the gem’s files, as on a deduplicated network share holding your Ruby installation, Ruby’s `File.lstat` can report such a file as a directory. Ruby can mistake the reparse point that deduplication leaves on the file for a directory. Ceedling copies Unity, CMock, and CException into the build directory with Ruby’s `FileUtils.cp_r`, which classifies each entry with `lstat`. Told that a file is a directory, `cp_r` makes a directory of that name in `build/vendor/` and fails reading the file as one, and every later build fails on that directory. Install Ruby and the gem on a local drive, or exclude them from deduplication ([#1376](https://github.com/ThrowTheSwitch/Ceedling/issues/1376)).
+1. A `-:` `:paths` entry removes only the directory it names, not the directories below it. Add a `-:` entry for each, or use a glob such as `-:src/legacy/**`.
+1. `~` in a configured path names a directory called `~`, not your home directory. Write the full path instead.
+1. A `:files` glob such as `+:**/*.c` collects the build directory’s own mocks, runners, and vendored Unity and CMock sources, and test files, and a release build then stops compiling them. Write the glob below your own source directories, such as `+:src/**/*.c`. A source root holding the test root also collects test files into a release build; add a `-:` `:files` entry for them.
 
 ### Partials
 
@@ -34,17 +110,26 @@ Ceedling 1.2.0 requires Ruby 3+ but only unoficially supports Ruby 4.
 1. Exposing a module’s file-scope variables and functions removes what kept their names private to that module. Two Partialized modules in one test file that each use the same name for a file-scope variable collide at link time.
 1. Partials cannot generate a module that text-only fallback preprocessing is unable to resolve — a module with an `#include` naming a macro, or with a type behind a conditional expression that cannot be evaluated without a real preprocessor. Ceedling stops the build and names the file and line rather than generating something subtly wrong. Fallback preprocessing is only used where your compiler does not support `-fdirectives-only`, older Apple Clang releases most notably, or where you force it with `:test_build` ↳ `:preprocess_force_fallback`.
 
+Resolved in 1.2.2: the mixing of two installations’ code, `./ceedling` failing in a `--local` project, delta builds not relinking a changed library, most shell characters in a path stopping a test from running, and the path handling problems above: mocks written outside the build directory, same-named sources sharing an object, `clobber` emptying a project under a `.` build root, `-:` entries keeping the directories below them, and `~`. Also resolved: frameworks vendor copying failing on files `lstat` misreports as directories. The [Changelog](Changelog.md) lists every other fix since this release.
+
+---
+
 ## 1.1.x — 2026-07-16
 
+Covers 1.1.0 through 1.1.10 as known by 1.1.10. An item may not apply to every patch release.
+
 1. The new internal pipeline as of 1.0.0 that allows builds to be parallelized and configured per-test-executable can mean a fair amount of duplication of steps. A header file may be mocked identically multiple times. The same source file may be compiled identically multiple times. The speed gains due to parallelization help make up for this. Future releases will concentrate on optimizing away duplication of build steps.
 1. While header file search paths are now customizable per executable, this currently only applies to the search paths the compiler uses. Distinguishing test files or header files of the same name in different directories for test runner and mock generation respectively continues to rely on educated guesses in Ceedling code.
 1. All header files needed for test compilation must be within the `:includes` path collection. Relative paths in include directives that extend outside the path collection will cause build problems.
 1. Any path for a C file specified with `TEST_SOURCE_FILE(...)` is in relation to **_project root_** — that is, from where you execute `ceedling` at the command line. If you move source files or change your directory structure, many of your `TEST_SOURCE_FILE(...)` calls may need to be updated. A more flexible and dynamic approach to path handling will come in a future update.
 1. In certain combinations of conditional preprocessing blocks with dependent symbols defined in another file, Ceedling can silently fail to extract computed includes (e.g. `#include SOME_MACRO()`).
-1. The automatic vendor copying of Unity, CMock, and CException into a project's build directory can intermittently fail with a file/directory type error, most often under antivirus/EDR file locking, cloud-sync filter drivers, or two concurrent Ceedling invocations racing the same destination. Deleting `build/` (or reinstalling the gem) and rebuilding works around it.
+1. The automatic vendor copying of Unity, CMock, and CException into a project’s build directory can intermittently fail with a file/directory type error, most often under antivirus/EDR file locking, cloud-sync filter drivers, or two concurrent Ceedling invocations racing the same destination. Deleting `build/` (or reinstalling the gem) and rebuilding works around it.
 1. The Bullseye code coverage plugin has been temporarily disabled as of 1.0.0. The makers of Bullseye have generously provided a license for development, and the plugin will be available in 1.2.0.
 1. On Windows, a test file whose name contains _install_, _setup_, _update_, or _patch_ can build a test executable that the Installer Detection feature of User Account Control (UAC) will not run without administrator privileges. Toolchains that embed a manifest requesting the invoker’s privileges, such as MSYS2’s MinGW-w64 GCC with its default manifest installed, avoid this. Otherwise, avoid these words in test filenames.
-1. Ceedling depends on the `erb` gem. Published `erb` versions include those affected by CVE-2026-41316, a flaw in how ERB reconstructs a template object from serialized data. Ceedling never reconstructs a template object this way, so Ceedling itself is not exposed. Dependency and security scanners may still flag the `erb` gem because the dependency is present. The `erb` dependency will be removed entirely as of 1.2.0 for multiple reasons beyond resolving the security issue.
+1. A test can't run when its file name or the build root holds a space, an apostrophe, or another character the shell reads, such as `&`, `;`, `(`, or `|`. Every case reports a crash, or the build stops. Paths the cppcheck, Dependencies, and Valgrind tools name break the same way. Rename the file, or quote the test fixture’s executable: `:tools` ↳ `:test_fixture` ↳ `:executable: '"${1}"'` ([#1373](https://github.com/ThrowTheSwitch/Ceedling/issues/1373)).
+1. A release isn't relinked when only a library it links changes, since it depends only on its objects. Test builds relink every time. Run `ceedling clobber` after a library changes ([#1368](https://github.com/ThrowTheSwitch/Ceedling/issues/1368)).
+1. A `--local` project’s `./ceedling` fails with “`vendor/ceedling/vendor/unity/test/targets` does not exist”, because vendoring leaves out Unity’s built-in mixins. Running the project with the gem’s `ceedling` command works around it.
+1. Ceedling depends on the `erb` gem. Published `erb` versions include those affected by CVE-2026-41316, a flaw in how ERB reconstructs a template object from serialized data. Ceedling never reconstructs a template object this way, so Ceedling itself is not exposed. Dependency and security scanners may still flag the `erb` gem because the dependency is present. The `erb` dependency will be removed entirely as of 1.2.0 for multiple reasons beyond eliminating any false positive flags of the security issue.
 
 ### Partials
 
@@ -72,3 +157,4 @@ Ceedling 1.2.0 requires Ruby 3+ but only unoficially supports Ruby 4.
 1. Ceedling’s many test preprocessing improvements are not presently able to preserve Unity’s special `TEST_CASE()` and `TEST_RANGE()` features. However, preprocessing of test files is much less frequently needed than preprocessing of mockable header files. Test preprocessing can now be configured to enable only one or the other. As such, these advanced Unity features can still be used in even sophisticated projects.
 1. The Bullseye code coverage plugin has been temporarily disabled until a license can be procured that will allow updates and improvements.
 1. On Windows, a test file whose name contains _install_, _setup_, _update_, or _patch_ can build a test executable that the Installer Detection feature of User Account Control (UAC) will not run without administrator privileges. Toolchains that embed a manifest requesting the invoker’s privileges, such as MSYS2’s MinGW-w64 GCC with its default manifest installed, avoid this. Otherwise, avoid these words in test filenames.
+1. A test can't run when its file name or the build root holds a space, an apostrophe, or another character the shell reads, such as `&`, `;`, `(`, or `|`. Every case reports a crash, or the build stops. Paths the Dependencies plugin’s tools name break the same way. Rename the file, or quote the test fixture’s executable: `:tools` ↳ `:test_fixture` ↳ `:executable: '"${1}"'` ([#1373](https://github.com/ThrowTheSwitch/Ceedling/issues/1373)).

data/docs/ReleaseNotes.md

@@ -8,6 +8,19 @@ These release notes are complemented by three other documents:
 
 ---
 
+# 1.2.2 — October 31, 2026
+
+## ⚠️ Breaking changes in a patch release
+
+1.2.2 is a patch release, yet [Breaking Changes](BreakingChanges.md) lists several entries for 1.2.2. Each entry is a bug fix that changes a behavior that a project might rely on and is, therefore, technically a breaking change. Despite this, we decided to maintain 1.2.2 as only a patch version for a few reasons:
+
+1. **Core builds are unaffected.** A correctly configured project builds and tests as before. The first test build after upgrading rebuilds everything once via a full delta build because of changes to how ephemeral build directory output is organized.
+1. **Plugin changes are limited to artifact paths.** Plugins that write per-test logs and reports, such as Valgrind, Sanitize, and Raw Output Log, write them to new paths because of build directory output fixes (see [1]). In a Ceedling build, every plugin is optional, and these changes do not impact test suites or release builds.
+1. **The fixes resolve latent bugs.** Nobody reported these bugs and some persisted across several versions: complete diambiguation of same-named tests, `TEST_SOURCE_FILE()` checking, [Which Ceedling](https://docs.throwtheswitch.org/Ceedling/1.2.0/configuration/which-ceedling/), CLI `--local` vendoring, `ceedling upgrade`, and `ceedling version`. With the fixes, these features now do what they were meant to do.
+1. **Path configuration changes reach only unusual layouts.** A `-:` `:paths` entry now also removes the directories below the one it names. A build root that is the project directory or a directory above it is now refused, because `clobber` could delete the project’s own files. A `:paths` or `:files` entry within the build root now logs a warning, and no entry collects from the directories Ceedling creates there. See [Breaking Changes](BreakingChanges.md).
+
+---
+
 # 1.2.0 — October 21, 2026
 
 ## 👀 Highlights

data/docs/overrides/main.html

@@ -4,11 +4,14 @@
   Material's own `outdated`/`announce` blocks (base.html) ship empty by
   default -- both are opt-in via a project template override like this one.
 
+  Material only renders a block's wrapping banner markup when the block
+  produces non-empty output, and whitespace alone counts as output. The
+  `{%- -%}` whitespace control below is load-bearing: without it the
+  indentation around each `if` leaks out, rendering an empty banner (a blank
+  dark bar for `announce`) even when the condition is false.
+
   `outdated`: the standard "you're not viewing the latest version" warning
-  banner. Material only renders its wrapping markup when this block actually
-  produces non-empty output, so suppressing it here for prerelease pages
-  (rather than just leaving the block's *content* blank) is what keeps the
-  banner from appearing at all on those pages.
+  banner, suppressed entirely on prerelease pages.
 
   `announce`: a separate announcement bar, used here to carry the prerelease
   notice instead. `extra.prerelease` is set to `true` only in
@@ -17,16 +20,16 @@
 #}
 
 {% block outdated %}
-  {% if not config.extra.prerelease %}
+  {%- if not config.extra.prerelease -%}
     You are not viewing the latest version.
     <a href="{{ '../' ~ base_url }}">
       <strong>Click here to go to latest.</strong>
     </a>
-  {% endif %}
+  {%- endif -%}
 {% endblock %}
 
 {% block announce %}
-  {% if config.extra.prerelease %}
+  {%- if config.extra.prerelease -%}
     This is prerelease documentation for an upcoming Ceedling release.
-  {% endif %}
+  {%- endif -%}
 {% endblock %}

data/lib/ceedling/build_log_writer.rb

@@ -0,0 +1,33 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+# Writes logs that hold only the current build's entries, such as gdb crash backtraces and
+# sanitizer findings. A build's first write to a log replaces whatever an earlier build left
+# there, and its later writes append. Build threads share one writer, so deciding first or
+# later and writing happen together under one lock, and an append never lands before the
+# write that replaces the file.
+class BuildLogWriter
+
+  constructor :file_wrapper
+
+  def setup
+    @written = []
+    @mutex   = Mutex.new
+  end
+
+  # `separator` goes between entries appended to one log
+  def write(filepath, text, separator: '')
+    @mutex.synchronize do
+      first = !@written.include?( filepath )
+      @written << filepath if first
+
+      @file_wrapper.mkdir_for( filepath )
+      @file_wrapper.write( filepath, first ? text : separator + text, first ? 'w' : 'a' )
+    end
+  end
+
+end

data/lib/ceedling/config/build_root_policy.rb

@@ -0,0 +1,70 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+require 'ceedling/filesystem/file_path_utils'
+require 'ceedling/filesystem/project_paths'
+
+# What a build root may be, and what in it a build may collect. Clobber empties the
+# directories Ceedling creates in the build root, so the build root names a directory,
+# neither the project directory nor one above it. Collection leaves out the directories
+# Ceedling creates, and a :paths or :files entry within the build root is warned of.
+module BuildRootPolicy
+
+  # The settings naming the directories Ceedling creates, in the build root or, for mocks,
+  # wherever the mock path places them
+  CREATED = %i[
+    project_build_artifacts_root project_build_tests_root project_build_release_root project_build_vendor_root
+    project_build_dependencies_cache_path project_log_path cmock_mock_path
+  ].freeze
+
+  # Why `root` is no build root, or nil when it is one. Compared as the places really are,
+  # so no symlinked spelling of the project gets by.
+  def self.problem(root)
+    return 'names no directory' if root.strip.empty?
+    return 'is the project directory or holds it' if ProjectPaths.contains?( ProjectPaths.canonical( root ), ProjectPaths.working_dir )
+
+    return nil
+  end
+
+  # The message refusing `root` for `problem`
+  def self.message(root, problem)
+    return ":project ↳ :build_root => '#{root}' #{problem}. Give the build its own directory, such as 'build'."
+  end
+
+  # Each :paths and :files entry that adds to a build from within `root`, as
+  # [section, key, entry]
+  def self.entries_within(root, config)
+    real = ProjectPaths.canonical( root )
+    return additive_entries( config ).select { |_, _, entry| ProjectPaths.contains?( real, ProjectPaths.canonical( FilePathUtils.no_decorators( entry ) ) ) }
+  end
+
+  # A warning of each :paths and :files entry that adds to a build from within `root`, its
+  # place in the configuration spelled by the block
+  def self.warnings(root, config)
+    return entries_within( root, config ).map do |section, key, entry|
+      "#{yield( [section, key] )} => '#{entry}' lies in the build root '#{root}'. Ceedling leaves out the directories it creates there."
+    end
+  end
+
+  # The directories Ceedling creates, each enabled plugin's build directory among them, from
+  # a flattened configuration. A setting with no path names none.
+  def self.reserved(config)
+    root    = config[:project_build_root].to_s
+    plugins = root.empty? ? [] : (config[:plugins_enabled] || []).map { |plugin| File.join( root, File.basename( plugin.to_s ) ) }
+    return (CREATED.map { |key| config[key].to_s } + plugins).reject( &:empty? ).uniq
+  end
+
+  # Every :paths and :files entry that adds to a build, as [section, key, entry]
+  def self.additive_entries(config)
+    entries = [:paths, :files].flat_map do |section|
+      (config[section] || {}).flat_map { |key, list| Array( list ).flatten.map { |entry| [section, key, entry] } }
+    end
+    return entries.select { |_, _, entry| entry.is_a?( String ) and FilePathUtils.add_path?( entry ) }
+  end
+  private_class_method :additive_entries
+
+end

data/lib/ceedling/config/configurator.rb

@@ -7,7 +7,7 @@
 
 require 'ceedling/defaults'
 require 'ceedling/constants'
-require 'ceedling/file_path_utils'
+require 'ceedling/filesystem/file_path_utils'
 require 'ceedling/exceptions'
 require 'ceedling/rake_app/rakefile_component_resolver'
 require 'ceedling/tool_executor'
@@ -16,7 +16,8 @@ require 'deep_merge'
 class Configurator
 
   attr_reader :project_config_hash, :programmatic_plugins, :rake_plugins
-  attr_accessor :project_logging, :sanity_checks, :include_test_case, :exclude_test_case, :force_test_rerun
+  attr_accessor :project_logging, :sanity_checks, :include_test_case, :exclude_test_case, :force_test_rerun,
+                :test_build_tasks, :release_build_tasks
 
   constructor :configurator_setup, :configurator_builder, :configurator_plugins, :config_walkinator, :yaml_wrapper, :system_wrapper, :loginator, :reportinator, :ruby_expandinator
 
@@ -26,7 +27,7 @@ class Configurator
 
   # Validations of the completed configuration
   FINAL_VALIDATIONS = [
-    :validate_paths, :validate_tools, :validate_defines, :validate_flags, :validate_line_markers,
+    :validate_build_root, :validate_paths, :validate_tools, :validate_defines, :validate_flags, :validate_line_markers,
     :validate_test_preprocessor, :validate_backtrace, :validate_threads, :validate_partials, :validate_plugins
   ].freeze
 
@@ -150,18 +151,11 @@ class Configurator
 
 
   def prepare_plugins_load_paths(plugins_load_path, config)
-    # Plugins must be loaded before generic path evaluation & magic that happen later.
-    # So, perform path magic here as discrete step.
-    # (String replacement and standardization require DI objects not available in bin/ scope.)
-    config[:plugins][:load_paths].each do |path|
-      path.replace( @ruby_expandinator.expand( path, source: ":plugins ↳ :load_paths" ) )
-      FilePathUtils::standardize_in_place( path )
-    end
-
-    # Delegate list construction to the shared helper (user paths first, built-in last).
-    # This mirrors what RakefileComponentResolver.resolve() does in the bin/ CLI scope,
-    # ensuring both scopes search plugins in the same priority order.
-    config[:plugins][:load_paths] = RakefileComponentResolver.prepare_plugin_load_paths( config, plugins_load_path )
+    # Plugins must be loaded before generic path evaluation & magic that happen later, so
+    # their load paths are expanded and standardized here, by the helper bin/ shares (user
+    # paths first, built-in last), so both scopes search plugins alike.
+    expand = ->(path) { @ruby_expandinator.expand( path, source: ":plugins ↳ :load_paths" ) }
+    config[:plugins][:load_paths] = RakefileComponentResolver.prepare_plugin_load_paths( config, plugins_load_path, expand: expand )
 
     return @configurator_plugins.process_aux_load_paths( config )
   end
@@ -232,6 +226,13 @@ class Configurator
   end
 
 
+  # Each Unity helper's header is included in every mock by its filename, so this follows
+  # path standardizing, which a helper written with backslashes needs to have a filename
+  def populate_cmock_helpers(config)
+    include_unity_helpers( config[:cmock] ) if config[:project][:use_mocks]
+  end
+
+
   def populate_test_runner_generation_config(config)
     progress( 'Populating test runner generation settings' )
 
@@ -431,7 +432,9 @@ class Configurator
     @configurator_setup.build_directory_structure( flattened_config )
 
     # Copy Unity, CMock, CException into vendor directory within build directory
-    @configurator_setup.vendor_frameworks_and_support_files( ceedling_lib_path, flattened_config )
+    @configurator_setup.vendor_frameworks_and_support_files(
+      ceedling_lib_path, flattened_config, test_build: @test_build_tasks == true, release_build: @release_build_tasks == true
+    )
     @configurator_setup.build_project_collections( flattened_config )
 
     @project_config_hash = flattened_config.clone
@@ -570,8 +573,6 @@ class Configurator
     # Plugins housekeeping
     cmock[:plugins].map! { |plugin| plugin.to_sym() }.uniq!
 
-    include_unity_helpers( cmock )
-
     # Add mocking prefix symbol for all test compilation
     cmock[:defines] << "CMOCK_MOCK_PREFIX=#{cmock[:mock_prefix]}"
   end