Jorijn van der Graaf
3ad1951057
ProjectArgs loads a chain app -> lib -> leaf of LocalProjects with --debug
and a project flag. lib, loaded without .args, has to see both, and so
does its own sibling, which takes the default one level further down.
Copies loaded with `.args = {}` and with an explicit list get nothing and
exactly that list. The GitProjectSpec default is checked on the spec
itself, since a GitProject would need a repository to clone. Without the
defaults, five of its checks fail.
ProjectDependency now also loads its consumer with a project flag: the
pragma dependency must still come back with no args. Without the explicit
`.args = {}` in the pragma path it gets the consumer's flag.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
91 lines
4.8 KiB
C++
91 lines
4.8 KiB
C++
// SPDX-License-Identifier: LGPL-3.0-only
|
|
// SPDX-FileCopyrightText: Copyright (C) 2026 Catcrafts®
|
|
|
|
import std;
|
|
import Crafter.Build;
|
|
namespace fs = std::filesystem;
|
|
using namespace Crafter;
|
|
|
|
// A GitProject or LocalProject without `.args` forwards the args of the
|
|
// project file that declares it: both specs default their args to
|
|
// ProjectArgs(). Before that default, every project.cpp with a sibling
|
|
// dependency copied its span into a std::vector<std::string> for each spec,
|
|
// and a spec that missed the copy built its sibling with none of the
|
|
// project's flags: for the host while the project cross-compiled, and in
|
|
// release while the project built --debug. The fixture is a chain
|
|
// app -> lib -> leaf of LocalProjects; app also loads lib with an empty and
|
|
// with a replaced list, and checks the GitProjectSpec default itself, which
|
|
// a clone would need a repository for.
|
|
namespace {
|
|
std::int32_t Failures = 0;
|
|
|
|
void Check(bool cond, std::string_view msg) {
|
|
if (!cond) {
|
|
std::println(std::cerr, "FAIL: {}", msg);
|
|
++Failures;
|
|
}
|
|
}
|
|
|
|
// The single sibling lib and leaf declare, or nullptr.
|
|
const Configuration* OnlyDependency(const Configuration& cfg) {
|
|
return cfg.dependencies.size() == 1 ? cfg.dependencies[0] : nullptr;
|
|
}
|
|
}
|
|
|
|
int main() {
|
|
const fs::path installedHome = GetCrafterBuildHome();
|
|
if (!fs::exists(installedHome / "Crafter.Build.cppm")) {
|
|
std::println(std::cerr, "SKIP: no module sources at {}", installedHome.string());
|
|
return 77;
|
|
}
|
|
|
|
// Staged because LoadProject drops a build/ tree next to every project
|
|
// file it compiles.
|
|
const fs::path fixture = fs::current_path() / "tests" / "ProjectArgs" / "fixture";
|
|
const fs::path scratch = fs::temp_directory_path() / "crafter-build-project-args";
|
|
std::error_code ec;
|
|
fs::remove_all(scratch, ec);
|
|
fs::create_directories(scratch);
|
|
fs::copy(fixture, scratch, fs::copy_options::recursive);
|
|
|
|
Check(ProjectArgs().empty(), "no project args outside a project file");
|
|
|
|
// Loaded from the project's own directory, as crafter-build runs it: the
|
|
// fixture's LocalProject paths are relative to the working directory.
|
|
const fs::path cwd = fs::current_path();
|
|
fs::current_path(scratch / "app");
|
|
std::array<std::string_view, 2> args = { "--debug", "--flavor=x" };
|
|
const std::vector<std::string> flavor = { "--flavor=x" };
|
|
const std::vector<std::string> only = { "--only" };
|
|
try {
|
|
Configuration cfg = LoadProject("project.cpp", args);
|
|
Check(std::ranges::contains(cfg.compileFlags, "-DGIT_DEFAULT=1"), "a GitProjectSpec's args default to the project's own");
|
|
Check(cfg.dependencies.size() == 3, std::format("the project declared its three siblings (got {})", cfg.dependencies.size()));
|
|
if (cfg.dependencies.size() == 3) {
|
|
const Configuration& inherited = *cfg.dependencies[0];
|
|
const Configuration& none = *cfg.dependencies[1];
|
|
const Configuration& replaced = *cfg.dependencies[2];
|
|
Check(inherited.debug && inherited.projectArgs == flavor, std::format("a LocalProject without .args gets the project's args (debug {}, projectArgs {})", inherited.debug, inherited.projectArgs));
|
|
Check(!none.debug && none.projectArgs.empty(), std::format("`.args = {{}}` forwards nothing (debug {}, projectArgs {})", none.debug, none.projectArgs));
|
|
Check(!replaced.debug && replaced.projectArgs == only, std::format("an explicit list replaces the args rather than adding to them (debug {}, projectArgs {})", replaced.debug, replaced.projectArgs));
|
|
Check(&inherited != &none && &inherited != &replaced && &none != &replaced, "each list loads its own configuration");
|
|
|
|
// One sibling further down, the same default passes on what the
|
|
// middle project was given, not what the top one was.
|
|
const Configuration* inheritedLeaf = OnlyDependency(inherited);
|
|
Check(inheritedLeaf && inheritedLeaf->debug && inheritedLeaf->projectArgs == flavor, "the project's args reach its sibling's sibling");
|
|
const Configuration* noneLeaf = OnlyDependency(none);
|
|
Check(noneLeaf && !noneLeaf->debug && noneLeaf->projectArgs.empty(), "a sibling loaded with nothing passes nothing on");
|
|
const Configuration* replacedLeaf = OnlyDependency(replaced);
|
|
Check(replacedLeaf && !replacedLeaf->debug && replacedLeaf->projectArgs == only, "a sibling passes on the list it was given");
|
|
}
|
|
} catch (const std::exception& e) {
|
|
fs::current_path(cwd);
|
|
std::println(std::cerr, "FAIL: LoadProject threw: {}", e.what());
|
|
return 1;
|
|
}
|
|
fs::current_path(cwd);
|
|
|
|
Check(ProjectArgs().empty(), "no project args once the project file has returned");
|
|
return Failures > 0 ? 1 : 0;
|
|
}
|