mirror of
https://github.com/LGUG2Z/komorebi.git
synced 2026-11-17 22:33:12 +01:00
One flake.nix and one flake.lock replace the root flake that re-exported two nested flakes.
The inputs are one nixpkgs (the revision the KDE flake was locked to, f05535a0: the VM suites
run against its Plasma and KWin 6.8.2), one crane, rust-overlay (19ecdd08, rustc 1.99.1),
flake-parts, treefmt-nix and git-hooks-nix, all the KDE flake revisions, plus asc. A second
nixpkgs, nixpkgs-x86_64-darwin (16c7794d, the macOS flake pin), serves the x86_64-darwin
outputs only: evaluating that system with the unified pin throws (nixpkgs 26.11 dropped it).
Layout: nix/common.nix (systems, pkgs, treefmt, pre-commit, dev shells default and native,
default overlay), nix/lib.nix, nix/workspace-src.nix (one source per platform from the one Cargo
workspace: the platform members, its files of the shared crates told apart by name, the data
files, and stubs for the other members, which cargo needs), nix/{windows,linux,macos}/
{build,flake-module}.nix. The dependency derivations use a manifests-only dummy source, a plain
path, so crane reads nothing built at evaluation and the Darwin outputs evaluate on Linux.
Names: unprefixed outputs are the native build (Linux: KDE; Darwin: macOS); Windows cross
outputs are windows-*; checks are windows-*, linux-*, macos-* and vm-NAME; table in docs/dev/flake.md
(next revision). One deny.toml, one format-all and one version (workspace) are used by all.
PLACEHOLDER for the agent that owns the check sets: the checks that evaluate a NixOS system
or a VM (vm-*, linux-nixos-module-eval, linux-plasma-guests-eval, linux-run-kde*) are
legacyPackages.<system>.heavyChecks.<name>, not checks, because evaluating them needs more
memory than nix flake check --all-systems can use. The Plasma guests got a stub root file system
and boot loader (mkDefault, replaced by their vmVariant) so that nix flake check can evaluate
their toplevel.
Verified: nix flake check --no-build --all-systems passes (42 s, rc 0); nix flake check
--no-build passes. Not verified: any build (next revisions record them).
116 lines
3.8 KiB
Nix
116 lines
3.8 KiB
Nix
# The crane derivations of the Linux (KDE Plasma) packages, from the Linux members of the one Cargo
|
|
# workspace (nix/workspace-src.nix).
|
|
{ inputs, self }:
|
|
let
|
|
lib' = import ../lib.nix { inherit inputs; };
|
|
inherit (lib') version;
|
|
inherit (inputs) crane;
|
|
in
|
|
{
|
|
mkKomorebiPackages =
|
|
{ pkgs }:
|
|
let
|
|
toolchain = pkgs.rust-bin.fromRustupToolchainFile ../../rust-toolchain.toml;
|
|
craneLib = (crane.mkLib pkgs).overrideToolchain toolchain;
|
|
|
|
inherit
|
|
(import ../workspace-src.nix {
|
|
inherit pkgs craneLib;
|
|
repoRoot = ../..;
|
|
platform = "linux";
|
|
})
|
|
real
|
|
src
|
|
stubbedPackages
|
|
;
|
|
|
|
lockFile = lib'.repoFile "Cargo.lock";
|
|
tomlFile = lib'.repoFile "Cargo.toml";
|
|
packages = "-p komorebi -p komorebi-linux -p komorebic -p komorebi-client -p komorebi-hotkeys";
|
|
workspaceArgs = {
|
|
pname = "komorebi-workspace-linux";
|
|
inherit version;
|
|
# the lock and the root manifest as files of their own: a path inside the filtered source
|
|
# would put all of it into the context of every derivation, and an edit of any file
|
|
# would then change the dependencies
|
|
cargoLock = lockFile;
|
|
cargoToml = tomlFile;
|
|
cargoVendorDir = craneLib.vendorCargoDeps { cargoLock = lockFile; };
|
|
};
|
|
|
|
commonArgs = workspaceArgs // {
|
|
cargoExtraArgs = "--locked ${packages}";
|
|
inherit src;
|
|
strictDeps = true;
|
|
# The version crate wants a commit at compile time. It is a constant here, so that the
|
|
# dependencies and every check are the same derivations for every commit; only the final
|
|
# build below knows the real one.
|
|
COMMIT_HASH = "nix-check";
|
|
};
|
|
|
|
# the dummy source is of the manifests alone (nix/lib.nix): the dependencies are the same
|
|
# derivations for every source file and every stub, and nothing is built at evaluation
|
|
cargoArtifacts = craneLib.buildDepsOnly (
|
|
builtins.removeAttrs commonArgs [ "src" ]
|
|
// {
|
|
dummySrc = craneLib.mkDummySrc {
|
|
src = lib'.manifestSource pkgs.lib;
|
|
cargoLock = lockFile;
|
|
};
|
|
}
|
|
);
|
|
|
|
individualCrateArgs = commonArgs // {
|
|
inherit cargoArtifacts;
|
|
doCheck = false;
|
|
doDoc = false;
|
|
};
|
|
|
|
fullBuild = craneLib.buildPackage (
|
|
individualCrateArgs
|
|
// {
|
|
COMMIT_HASH = self.rev or (pkgs.lib.removeSuffix "-dirty" (self.dirtyRev or "unknown"));
|
|
}
|
|
);
|
|
|
|
# the same build with the constant commit of the checks: the VM tests install this one, so
|
|
# that a new commit does not build the daemon again
|
|
vmBuild = craneLib.buildPackage individualCrateArgs;
|
|
|
|
extractBinaryOf =
|
|
package: binaryName:
|
|
pkgs.runCommand "komorebi-${binaryName}" { meta = package.meta // { }; } ''
|
|
mkdir -p $out/bin
|
|
cp ${package}/bin/${binaryName} $out/bin/
|
|
'';
|
|
extractBinary = extractBinaryOf fullBuild;
|
|
in
|
|
{
|
|
inherit
|
|
craneLib
|
|
src
|
|
real
|
|
workspaceArgs
|
|
stubbedPackages
|
|
packages
|
|
commonArgs
|
|
individualCrateArgs
|
|
fullBuild
|
|
vmBuild
|
|
;
|
|
komorebi = extractBinary "komorebi";
|
|
komorebic = extractBinary "komorebic";
|
|
komorebiForVm = extractBinaryOf vmBuild "komorebi";
|
|
komorebicForVm = extractBinaryOf vmBuild "komorebic";
|
|
# komorebic with the constant commit of the checks, whose output the schemas are
|
|
# checked against: it is the same for every commit
|
|
komorebicForChecks = craneLib.buildPackage (
|
|
individualCrateArgs
|
|
// {
|
|
pname = "komorebic-for-checks";
|
|
cargoExtraArgs = "--package komorebic --bin komorebic";
|
|
}
|
|
);
|
|
};
|
|
}
|