mirror of
https://github.com/LGUG2Z/komorebi.git
synced 2026-11-20 07:31:39 +01:00
Step 8 (Option A of docs/dev/unified-binaries.md). The main.rs of komorebi-windows, komorebi-linux and komorebi-macos becomes daemon.rs of the library (pub fn run; komorebi:: paths are crate:: paths now, the inner attributes and the unit tests move with it), and their [[bin]] is gone, so each is a library only. The new package komorebi (komorebi-daemon/, version 0.1.42) is the one binary: its main calls komorebi_windows::daemon::run, komorebi_linux::daemon::run or komorebi_macos::daemon::run by cfg_select! on the target OS, through target-gated dependencies (one key per library, cargo allows one path per key), and forwards the features deadlock_detection and schemars. The binary name komorebi now comes from exactly one package. The four KDE integration tests that run the binary (no_kwin, socket, hot_reload, version) move to komorebi-daemon/tests/linux_*.rs; the version test compares with the KDE version crate, since the package version is now shared. Old names: komorebi-windows, komorebi-linux and komorebi-macos still build, as libraries (no binary any more: use -p komorebi). The flakes build -p komorebi with the KDE and macOS packages, the source filters take komorebi-daemon (manifest, main.rs, linux tests), the Windows filter leaves its linux tests out, deny.toml clarify entries gain komorebi, the release workflow's cargo wix and the justfile version lookup name komorebi, tools/fast-check checks -p komorebi on KDE and macOS. Behaviour: the same code runs, the same binary name; the Windows executable is rebuilt from the library (BEHAVIOUR for the e2e gate: the Windows e2e must run). Gates run: Windows clippy --all-targets -D warnings PASS; KDE check; macOS fake-CC check of -p komorebi -p komorebi-macos PASS (type check only); KDE cargo test -p komorebi -p komorebi-linux -p komorebic -p komorebi-client -p komorebi-hotkeys -p komorebi-core: 903 passed, 0 failed (the four moved tests and the unit test of daemon.rs included); CLI docs oracle identical x3; bar schema harness identical both bars; kde-closure-check ok; nix evaluation of the root and both nested flakes PASS; by evaluation an edit of komorebi/src/daemon.rs changes the Windows derivations only, of the KDE daemon.rs kfde only, of the macOS one neither (the shared komorebi-daemon/src/main.rs changes all, as expected). Not run: nix builds, VM, e2e, any Mac run.
395 lines
15 KiB
Nix
395 lines
15 KiB
Nix
{
|
|
description = "komorebi for Mac";
|
|
|
|
inputs = {
|
|
nixpkgs.url = "github:NixOS/nixpkgs/nixpkgs-unstable";
|
|
flake-parts.url = "github:hercules-ci/flake-parts";
|
|
crane.url = "github:ipetkov/crane";
|
|
rust-overlay.url = "github:oxalica/rust-overlay";
|
|
rust-overlay.inputs.nixpkgs.follows = "nixpkgs";
|
|
treefmt-nix.url = "github:numtide/treefmt-nix";
|
|
treefmt-nix.inputs.nixpkgs.follows = "nixpkgs";
|
|
git-hooks-nix.url = "github:cachix/git-hooks.nix";
|
|
git-hooks-nix.inputs.nixpkgs.follows = "nixpkgs";
|
|
};
|
|
|
|
# The outputs are a function of the repository they are built from, so that the root flake can
|
|
# build them with the whole repository as the source (the Rust workspace here depends on the
|
|
# crates of the root workspace by path) and with its own `self`. `lib.mkOutputs` is that function.
|
|
# The outputs of this flake on its own use the directory it is in: that evaluates everything and
|
|
# builds what is not Rust, but cannot build the Rust workspace.
|
|
outputs =
|
|
inputs@{ self, ... }:
|
|
let
|
|
mkOutputs =
|
|
{
|
|
inputs,
|
|
self,
|
|
# the source of the repository, and the path of this tree in it
|
|
repoRoot,
|
|
platformDir,
|
|
}:
|
|
let
|
|
inherit (inputs)
|
|
nixpkgs
|
|
flake-parts
|
|
crane
|
|
rust-overlay
|
|
;
|
|
rootCrates = [
|
|
"crates"
|
|
"komorebi-layouts"
|
|
"komorebi-scrolling"
|
|
"komorebi-themes"
|
|
];
|
|
mkKomorebiPackages =
|
|
{ pkgs }:
|
|
let
|
|
toolchain = pkgs.rust-bin.fromRustupToolchainFile ./rust-toolchain.toml;
|
|
craneLib = (crane.mkLib pkgs).overrideToolchain toolchain;
|
|
version = "0.1.0";
|
|
|
|
# the repository, cut down to this workspace and the crates of the root workspace it depends
|
|
# on by path, with the root manifest those crates inherit their dependencies from
|
|
real = pkgs.lib.cleanSourceWith {
|
|
src = repoRoot;
|
|
filter =
|
|
path: type:
|
|
let
|
|
relative = pkgs.lib.removePrefix "${toString repoRoot}/" path;
|
|
inTree =
|
|
platformDir == "" || relative == platformDir || pkgs.lib.hasPrefix "${platformDir}/" relative;
|
|
rootCrate = builtins.any (
|
|
crate: relative == crate || pkgs.lib.hasPrefix "${crate}/" relative
|
|
) rootCrates;
|
|
# the unified komorebic package: its manifest, build script, main and the macOS module
|
|
komorebic =
|
|
builtins.elem relative [
|
|
"komorebic"
|
|
"komorebic/Cargo.toml"
|
|
"komorebic/build.rs"
|
|
"komorebic/src"
|
|
"komorebic/src/main.rs"
|
|
]
|
|
|| pkgs.lib.hasPrefix "komorebic/src/macos" relative;
|
|
|
|
# the unified komorebi-client package: its manifest, lib.rs and the module of this platform
|
|
komorebiClient =
|
|
builtins.elem relative [
|
|
"komorebi-client"
|
|
"komorebi-client/Cargo.toml"
|
|
"komorebi-client/src"
|
|
"komorebi-client/src/lib.rs"
|
|
"komorebi-client/src/macos.rs"
|
|
"komorebi-client/tests"
|
|
];
|
|
|
|
# the unified komorebi-bar package: its manifest, main.rs and the macOS module
|
|
komorebiBar =
|
|
builtins.elem relative [
|
|
"komorebi-bar"
|
|
"komorebi-bar/Cargo.toml"
|
|
"komorebi-bar/src"
|
|
"komorebi-bar/src/main.rs"
|
|
]
|
|
|| pkgs.lib.hasPrefix "komorebi-bar/src/macos" relative;
|
|
|
|
# the one komorebi binary package: its manifest, main.rs and tests
|
|
komorebiDaemon =
|
|
builtins.elem relative [
|
|
"komorebi-daemon"
|
|
"komorebi-daemon/Cargo.toml"
|
|
"komorebi-daemon/src"
|
|
"komorebi-daemon/src/main.rs"
|
|
"komorebi-daemon/tests"
|
|
];
|
|
in
|
|
((rootCrate || komorebic || komorebiClient || komorebiBar || komorebiDaemon) && !(pkgs.lib.hasSuffix "/Cargo.lock" path) || relative == "Cargo.toml" || relative == "Cargo.lock" || inTree)
|
|
&& (
|
|
(craneLib.filterCargoSources path type)
|
|
|| (pkgs.lib.hasInfix "/docs/" path)
|
|
|| (builtins.match ".*/docs/.*" path != null)
|
|
# embedded by include_str! in komorebic
|
|
|| (pkgs.lib.hasSuffix "/komorebic/src/macos/applications.json" path)
|
|
);
|
|
};
|
|
|
|
# the platform is a part of the one workspace of the repository: cargo loads every member (the
|
|
# others are stubs, see nix/workspace-src.nix) and is told which packages are this platform's
|
|
src = import (repoRoot + "/nix/workspace-src.nix") {
|
|
inherit pkgs repoRoot real;
|
|
isReal =
|
|
member:
|
|
pkgs.lib.hasPrefix "${platformDir}/" member
|
|
|| member == "komorebic"
|
|
|| member == "komorebi-client"
|
|
|| member == "komorebi-daemon"
|
|
|| member == "komorebi-bar"
|
|
|| builtins.any (crate: member == crate || pkgs.lib.hasPrefix "${crate}/" member) rootCrates;
|
|
};
|
|
packages = "-p komorebi -p komorebi-macos -p komorebic -p komorebi-client -p komorebi-bar";
|
|
workspaceArgs = {
|
|
pname = "komorebi-workspace";
|
|
inherit version;
|
|
cargoLock = "${real}/Cargo.lock";
|
|
cargoToml = "${real}/Cargo.toml";
|
|
# vendored from the filtered source, not the stubbed one: no build is needed to evaluate
|
|
cargoVendorDir = craneLib.vendorCargoDeps { src = real; };
|
|
};
|
|
|
|
commonArgs = workspaceArgs // {
|
|
cargoExtraArgs = "--locked ${packages}";
|
|
inherit src version;
|
|
strictDeps = true;
|
|
COMMIT_HASH = self.rev or (pkgs.lib.removeSuffix "-dirty" (self.dirtyRev or "unknown"));
|
|
nativeBuildInputs = [
|
|
pkgs.darwin.cctools
|
|
];
|
|
postFixup = ''
|
|
for bin in $out/bin/*; do
|
|
if [ -f "$bin" ] && [ -x "$bin" ]; then
|
|
# Get all linked libraries and fix libiconv references
|
|
otool -L "$bin" | grep -o '/nix/store/[^/]*/lib/libiconv[^ ]*' | while read -r lib; do
|
|
install_name_tool -change "$lib" /usr/lib/libiconv.dylib "$bin"
|
|
done
|
|
fi
|
|
done
|
|
'';
|
|
};
|
|
|
|
cargoArtifacts = craneLib.buildDepsOnly commonArgs;
|
|
|
|
individualCrateArgs = commonArgs // {
|
|
inherit cargoArtifacts;
|
|
doCheck = false;
|
|
doDoc = false;
|
|
};
|
|
|
|
fullBuild = craneLib.buildPackage (
|
|
individualCrateArgs
|
|
// {
|
|
pname = "komorebi-workspace";
|
|
}
|
|
);
|
|
|
|
extractBinary =
|
|
binaryName:
|
|
pkgs.runCommand "komorebi-${binaryName}"
|
|
{
|
|
meta = fullBuild.meta // { };
|
|
}
|
|
''
|
|
mkdir -p $out/bin
|
|
cp ${fullBuild}/bin/${binaryName} $out/bin/
|
|
'';
|
|
in
|
|
{
|
|
inherit
|
|
craneLib
|
|
src
|
|
real
|
|
workspaceArgs
|
|
packages
|
|
individualCrateArgs
|
|
fullBuild
|
|
;
|
|
komorebi = extractBinary "komorebi";
|
|
komorebic = extractBinary "komorebic";
|
|
komorebi-bar = extractBinary "komorebi-bar";
|
|
};
|
|
|
|
mkPkgs =
|
|
system:
|
|
import nixpkgs {
|
|
inherit system;
|
|
overlays = [ (import rust-overlay) ];
|
|
};
|
|
in
|
|
flake-parts.lib.mkFlake { inherit inputs; } {
|
|
systems = [
|
|
"aarch64-darwin"
|
|
"x86_64-darwin"
|
|
];
|
|
|
|
imports = [
|
|
inputs.treefmt-nix.flakeModule
|
|
inputs.git-hooks-nix.flakeModule
|
|
];
|
|
|
|
perSystem =
|
|
{ config, system, ... }:
|
|
let
|
|
pkgs = mkPkgs system;
|
|
build = mkKomorebiPackages { inherit pkgs; };
|
|
rustToolchain = pkgs.rust-bin.fromRustupToolchainFile ./rust-toolchain.toml;
|
|
nightlyRustfmt = pkgs.rust-bin.nightly.latest.rustfmt;
|
|
rustToolchainWithNightlyRustfmt = pkgs.symlinkJoin {
|
|
name = "rust-toolchain-with-nightly-rustfmt";
|
|
paths = [
|
|
nightlyRustfmt
|
|
rustToolchain
|
|
];
|
|
};
|
|
nightlyToolchain = pkgs.rust-bin.nightly.latest.default;
|
|
cargo-udeps = pkgs.writeShellScriptBin "cargo-udeps" ''
|
|
export PATH="${nightlyToolchain}/bin:$PATH"
|
|
exec ${pkgs.cargo-udeps}/bin/cargo-udeps "$@"
|
|
'';
|
|
in
|
|
{
|
|
treefmt = {
|
|
projectRootFile = "flake.nix";
|
|
programs = {
|
|
deadnix.enable = true;
|
|
just.enable = true;
|
|
nixfmt.enable = true;
|
|
taplo.enable = true;
|
|
rustfmt = {
|
|
enable = true;
|
|
package = pkgs.rust-bin.nightly.latest.rustfmt;
|
|
};
|
|
};
|
|
};
|
|
|
|
checks = {
|
|
komorebi-workspace-clippy = build.craneLib.cargoClippy build.individualCrateArgs;
|
|
|
|
komorebi-workspace-fmt = build.craneLib.cargoFmt (build.workspaceArgs // { inherit (build) src; cargoExtraArgs = build.packages; });
|
|
|
|
komorebi-workspace-toml-fmt = build.craneLib.taploFmt (
|
|
build.workspaceArgs
|
|
// {
|
|
src = pkgs.lib.sources.sourceFilesBySuffices build.real [ ".toml" ];
|
|
}
|
|
);
|
|
|
|
# cargo deny sees every member of the workspace: leave out the other platforms' packages
|
|
# and use this tree's policy
|
|
komorebi-workspace-deny = build.craneLib.cargoDeny (
|
|
build.workspaceArgs
|
|
// {
|
|
inherit (build) src;
|
|
cargoDenyExtraArgs =
|
|
"--workspace "
|
|
+ pkgs.lib.concatMapStringsSep " " (p: "--exclude ${p}") [
|
|
"komorebi-windows"
|
|
"komorebi-gui"
|
|
"komorebic-no-console"
|
|
"komorebi-shortcuts"
|
|
"komorebi-e2e-agent"
|
|
"komorebi-testwin"
|
|
"komorebi-linux"
|
|
"komorebic-linux"
|
|
"komorebi-client-linux"
|
|
"komorebi-hotkeys"
|
|
"version-linux"
|
|
];
|
|
cargoDenyChecks = "--config ${platformDir}/deny.toml bans licenses sources";
|
|
}
|
|
);
|
|
|
|
komorebi-workspace-nextest = build.craneLib.cargoNextest build.individualCrateArgs;
|
|
|
|
nix-options-validation = import ./nix/tests { inherit pkgs; };
|
|
|
|
darwin-module-validation = import ./nix/tests/darwin-module.nix { inherit pkgs; };
|
|
};
|
|
|
|
packages = {
|
|
inherit (build) komorebi komorebic komorebi-bar;
|
|
komorebi-full = build.fullBuild;
|
|
default = build.fullBuild;
|
|
};
|
|
|
|
apps = {
|
|
komorebi = {
|
|
type = "app";
|
|
program = "${build.komorebi}/bin/komorebi";
|
|
};
|
|
komorebic = {
|
|
type = "app";
|
|
program = "${build.komorebic}/bin/komorebic";
|
|
};
|
|
komorebi-bar = {
|
|
type = "app";
|
|
program = "${build.komorebi-bar}/bin/komorebi-bar";
|
|
};
|
|
default = {
|
|
type = "app";
|
|
program = "${build.fullBuild}/bin/komorebi";
|
|
};
|
|
};
|
|
|
|
devShells.default = pkgs.mkShell {
|
|
name = "komorebi";
|
|
|
|
RUST_BACKTRACE = "full";
|
|
|
|
inputsFrom = [ build.fullBuild ];
|
|
|
|
packages = [
|
|
rustToolchainWithNightlyRustfmt
|
|
cargo-udeps
|
|
|
|
pkgs.cargo-deny
|
|
pkgs.cargo-nextest
|
|
pkgs.cargo-outdated
|
|
pkgs.jq
|
|
pkgs.just
|
|
pkgs.prettier
|
|
pkgs.wrangler
|
|
];
|
|
};
|
|
|
|
pre-commit = {
|
|
check.enable = true;
|
|
settings.hooks.treefmt = {
|
|
enable = true;
|
|
package = config.treefmt.build.wrapper;
|
|
pass_filenames = false;
|
|
};
|
|
};
|
|
};
|
|
|
|
flake = {
|
|
overlays.default =
|
|
final: _:
|
|
let
|
|
pkgs = mkPkgs final.system;
|
|
build = mkKomorebiPackages {
|
|
inherit pkgs;
|
|
};
|
|
in
|
|
{
|
|
inherit (build) komorebi komorebic komorebi-bar;
|
|
komorebi-full = build.fullBuild;
|
|
};
|
|
|
|
overlays.komorebi =
|
|
final: _:
|
|
let
|
|
pkgs = mkPkgs final.system;
|
|
build = mkKomorebiPackages {
|
|
inherit pkgs;
|
|
};
|
|
in
|
|
{
|
|
inherit (build) komorebi komorebic komorebi-bar;
|
|
komorebi-full = build.fullBuild;
|
|
};
|
|
|
|
darwinModules.default = import ./nix/darwin-module.nix;
|
|
darwinModules.komorebi = import ./nix/darwin-module.nix;
|
|
};
|
|
};
|
|
in
|
|
mkOutputs {
|
|
inherit inputs self;
|
|
repoRoot = ./.;
|
|
platformDir = "";
|
|
}
|
|
// {
|
|
lib.mkOutputs = mkOutputs;
|
|
};
|
|
}
|