Jorijn van der Graaf
653813e1e3
The transport needed Crafter.Network's callback API, which lived on an unpushed branch, so project.cpp took Network from whatever project.cpp $CRAFTER_DEBUG_NETWORK named. That API and the ~ClientQUIC fix are on Network's master now (79a2f12), so the hook goes: Network comes from forgejo, unpinned, or from ../Crafter.Network with --local, as before. The notes and the README stop telling people to set it, and say which Network the transport needs. Every test passes with Network cloned from forgejo, and the example builds and is driven end to end that way. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
234 lines
9.9 KiB
C++
234 lines
9.9 KiB
C++
// SPDX-License-Identifier: LGPL-3.0-only
|
|
// SPDX-FileCopyrightText: Copyright (C) 2026 Catcrafts®
|
|
|
|
// Four configurations:
|
|
// Crafter.Debug.Core what the app and the client share (values, codecs,
|
|
// the protocol, discovery, build info)
|
|
// Crafter.Debug.Cli the client's code, a library so tests can run it
|
|
// crafter.debug-cli the client, crafter-debug
|
|
// Crafter.Debug what an app links (returned), depending on the core
|
|
// and the client
|
|
// The client is one of the library's dependencies only so that a consumer's
|
|
// debug build compiles it in the same pass as the app; an executable adds no
|
|
// link flags to what depends on it. Consumers load this file through
|
|
// Debug::Use (tooling/), which also writes their launcher.
|
|
//
|
|
// The library and the client talk QUIC through Crafter.Network, which comes
|
|
// from forgejo, or with --local from the checkout beside this one.
|
|
import std;
|
|
import Crafter.Build;
|
|
namespace fs = std::filesystem;
|
|
using namespace Crafter;
|
|
|
|
namespace {
|
|
// The configurations this file makes besides the one it returns, at
|
|
// stable addresses for the pointers in `dependencies`. One set per load,
|
|
// not statics: a static would keep the first load's args for every load.
|
|
std::deque<Configuration> owned;
|
|
|
|
// This file's directory. A configuration a project file makes for itself
|
|
// keeps the path it is given, and "./" would later resolve against the
|
|
// consumer's directory instead of this one.
|
|
fs::path Root() {
|
|
return fs::path(std::source_location::current().file_name()).parent_path();
|
|
}
|
|
|
|
// Crafter.Network, with the args unchanged: a consumer that also uses
|
|
// it passes the same ones, so both resolve to one configuration rather
|
|
// than one module built twice.
|
|
Configuration* Network(std::span<const std::string_view> args) {
|
|
const std::vector<std::string> forwarded(args.begin(), args.end());
|
|
if (std::ranges::find(args, std::string_view("--local")) != args.end()) {
|
|
return LocalProject({ .projectFile = Root().parent_path() / "Crafter.Network" / "project.cpp", .args = forwarded });
|
|
}
|
|
return GitProject({
|
|
.source = { .url = "https://forgejo.catcrafts.net/Catcrafts/Crafter.Network.git" },
|
|
.args = forwarded,
|
|
});
|
|
}
|
|
|
|
// Tests of the core, linked against it alone.
|
|
constexpr std::array<std::string_view, 5> coreTests = {
|
|
"ShouldRoundTripJson",
|
|
"ShouldRoundTripAggregates",
|
|
"ShouldReportDecodeErrorsWithPaths",
|
|
"ShouldDescribeDefaultsAndRequired",
|
|
"ShouldDiscoverLiveInstances",
|
|
};
|
|
|
|
// Tests of the app library.
|
|
constexpr std::array<std::string_view, 7> libraryTests = {
|
|
"ShouldInvokeCommands",
|
|
"ShouldResolveWatchPaths",
|
|
"ShouldRecordTimeline",
|
|
"ShouldEvaluateConditions",
|
|
"ShouldAnswerRequests",
|
|
"ShouldPauseAndStep",
|
|
"ShouldWaitTraceAndFollow",
|
|
};
|
|
|
|
std::string ReadFile(const fs::path& path) {
|
|
std::ifstream in(path, std::ios::binary);
|
|
return std::string((std::istreambuf_iterator<char>(in)), std::istreambuf_iterator<char>());
|
|
}
|
|
|
|
// FNV-1a over the path and bytes of every source, in a fixed order: what
|
|
// the app and the client compare to tell they came from the same code.
|
|
std::string SourceId() {
|
|
std::vector<fs::path> files;
|
|
for (const std::string_view dir : { "interfaces", "implementations" }) {
|
|
std::error_code ec;
|
|
for (const fs::directory_entry& entry : fs::recursive_directory_iterator(Root() / dir, ec)) {
|
|
if (entry.is_regular_file() && (entry.path().extension() == ".cppm" || entry.path().extension() == ".cpp")) files.push_back(entry.path());
|
|
}
|
|
}
|
|
std::ranges::sort(files);
|
|
std::uint64_t hash = 14695981039346656037ULL;
|
|
const auto mix = [&](std::string_view bytes) {
|
|
for (const char c : bytes) {
|
|
hash ^= static_cast<std::uint8_t>(c);
|
|
hash *= 1099511628211ULL;
|
|
}
|
|
};
|
|
for (const fs::path& file : files) {
|
|
mix(file.lexically_relative(Root()).generic_string());
|
|
mix(ReadFile(file));
|
|
}
|
|
return std::format("{:016x}", hash);
|
|
}
|
|
|
|
void WriteIfChanged(const fs::path& file, const std::string& text) {
|
|
if (fs::exists(file) && ReadFile(file) == text) return;
|
|
fs::create_directories(file.parent_path());
|
|
std::ofstream(file, std::ios::binary | std::ios::trunc) << text;
|
|
}
|
|
|
|
// Generates the definitions of :BuildInfo for this variant of the core and
|
|
// returns the source to compile, without its extension.
|
|
fs::path GenerateBuildInfo(const Configuration& core, const Configuration& client) {
|
|
const fs::path source = Root() / "build" / "generated" / core.VariantId() / "Crafter.Debug.Core-BuildInfo";
|
|
const fs::path clientPath = client.BinDir() / client.outputName;
|
|
WriteIfChanged(fs::path(source).concat(".cpp"), std::format(
|
|
"// Generated by Crafter.Debug's project.cpp whenever the sources or the client's\n"
|
|
"// path change. Not to be edited.\n"
|
|
"module Crafter.Debug.Core:BuildInfo_impl;\n"
|
|
"import std;\n"
|
|
"import :BuildInfo;\n"
|
|
"\n"
|
|
"std::string_view Crafter::Debug::Detail::SourceId() {{\n"
|
|
" return \"{}\";\n"
|
|
"}}\n"
|
|
"\n"
|
|
"std::string_view Crafter::Debug::Detail::ClientPath() {{\n"
|
|
" return R\"crafter-debug({})crafter-debug\";\n"
|
|
"}}\n",
|
|
SourceId(), clientPath.string()));
|
|
return source;
|
|
}
|
|
}
|
|
|
|
extern "C" Configuration CrafterBuildProject(std::span<const std::string_view> args) {
|
|
Configuration cfg;
|
|
cfg.path = "./";
|
|
cfg.name = "Crafter.Debug";
|
|
cfg.outputName = "Crafter.Debug";
|
|
cfg.type = ConfigurationType::LibraryStatic;
|
|
ApplyStandardArgs(cfg, args);
|
|
|
|
Configuration* network = Network(args);
|
|
|
|
Configuration& core = owned.emplace_back();
|
|
core.path = Root();
|
|
core.name = "Crafter.Debug.Core";
|
|
core.outputName = "Crafter.Debug.Core";
|
|
core.type = ConfigurationType::LibraryStatic;
|
|
ApplyStandardArgs(core, args);
|
|
|
|
// The client, built for the library's target. Not through
|
|
// ApplyStandardArgs: a consumer's --lib would make it a library.
|
|
Configuration& client = owned.emplace_back();
|
|
client.path = Root();
|
|
client.name = "crafter.debug-cli";
|
|
client.outputName = "crafter-debug";
|
|
client.type = ConfigurationType::Executable;
|
|
client.target = cfg.target;
|
|
client.march = cfg.march;
|
|
client.mtune = cfg.mtune;
|
|
client.sysroot = cfg.sysroot;
|
|
client.debug = cfg.debug;
|
|
|
|
// The client's code as a library, so tests can run it in process.
|
|
Configuration& cli = owned.emplace_back();
|
|
cli.path = Root();
|
|
cli.name = "Crafter.Debug.Cli";
|
|
cli.outputName = "Crafter.Debug.Cli";
|
|
cli.type = ConfigurationType::LibraryStatic;
|
|
cli.target = cfg.target;
|
|
cli.march = cfg.march;
|
|
cli.mtune = cfg.mtune;
|
|
cli.sysroot = cfg.sysroot;
|
|
cli.debug = cfg.debug;
|
|
cli.dependencies = { &core, network };
|
|
client.dependencies = { &cli };
|
|
|
|
{
|
|
std::array<fs::path, 8> interfaces = {
|
|
"interfaces/Crafter.Debug.Core-Value",
|
|
"interfaces/Crafter.Debug.Core-Reflect",
|
|
"interfaces/Crafter.Debug.Core-Codec",
|
|
"interfaces/Crafter.Debug.Core-Result",
|
|
"interfaces/Crafter.Debug.Core-Protocol",
|
|
"interfaces/Crafter.Debug.Core-BuildInfo",
|
|
"interfaces/Crafter.Debug.Core-Discovery",
|
|
"interfaces/Crafter.Debug.Core",
|
|
};
|
|
std::array<fs::path, 5> implementations = {
|
|
"implementations/Crafter.Debug.Core-Value",
|
|
"implementations/Crafter.Debug.Core-Codec",
|
|
"implementations/Crafter.Debug.Core-Protocol",
|
|
"implementations/Crafter.Debug.Core-Discovery",
|
|
GenerateBuildInfo(core, client),
|
|
};
|
|
core.GetInterfacesAndImplementations(interfaces, implementations);
|
|
}
|
|
{
|
|
std::array<fs::path, 3> interfaces = { "interfaces/Crafter.Debug.Cli-Client", "interfaces/Crafter.Debug.Cli-Quic", "interfaces/Crafter.Debug.Cli" };
|
|
std::array<fs::path, 2> implementations = { "implementations/Crafter.Debug.Cli-Client", "implementations/Crafter.Debug.Cli-Quic" };
|
|
cli.GetInterfacesAndImplementations(interfaces, implementations);
|
|
}
|
|
{
|
|
std::array<fs::path, 0> interfaces = {};
|
|
std::array<fs::path, 1> implementations = { "implementations/main" };
|
|
client.GetInterfacesAndImplementations(interfaces, implementations);
|
|
}
|
|
|
|
cfg.dependencies = { &core, &client, network };
|
|
{
|
|
std::array<fs::path, 6> interfaces = {
|
|
"interfaces/Crafter.Debug-Registry",
|
|
"interfaces/Crafter.Debug-Timeline",
|
|
"interfaces/Crafter.Debug-Condition",
|
|
"interfaces/Crafter.Debug-Session",
|
|
"interfaces/Crafter.Debug-Transport",
|
|
"interfaces/Crafter.Debug",
|
|
};
|
|
std::array<fs::path, 5> implementations = {
|
|
"implementations/Crafter.Debug-Registry",
|
|
"implementations/Crafter.Debug-Timeline",
|
|
"implementations/Crafter.Debug-Condition",
|
|
"implementations/Crafter.Debug-Session",
|
|
"implementations/Crafter.Debug-Transport",
|
|
};
|
|
cfg.GetInterfacesAndImplementations(interfaces, implementations);
|
|
}
|
|
|
|
// Tests only when this is the project being built: a consumer's load of
|
|
// this file has no use for them.
|
|
if (IsTopLevelProject()) {
|
|
for (const std::string_view test : coreTests) cfg.AddTest(test).Dependencies({ &core });
|
|
for (const std::string_view test : libraryTests) cfg.AddTest(test).Dependencies({ &cfg });
|
|
cfg.AddTest("ShouldRunClientCommands").Dependencies({ &cfg, &cli });
|
|
cfg.AddTest("ShouldServeOverQuic").Dependencies({ &cfg, &cli });
|
|
}
|
|
return cfg;
|
|
}
|