mirror of
https://github.com/LGUG2Z/komorebi.git
synced 2026-11-22 00:21:43 +01:00
The macOS bar module moves from komorebi-for-mac/komorebi-bar/src/macos to komorebi-bar/src/macos (the include_str! path follows), komorebi-bar/src/main.rs is a cfg_select! over target_os that runs windows::main or macos::main, and komorebi-bar/Cargo.toml has what both share in [dependencies] and the rest in per-target tables (Windows: windows, windows-core, windows-icons x2, systray-util, tokio, regex, which, egui_extras, netdev 0.46, sysinfo 0.39, komorebi-themes without default features; macOS: objc2, objc2-app-kit, icns, raw-window-handle, netdev 0.40, sysinfo 0.38, komorebi-themes with defaults), so each platform keeps the versions it had. The old komorebi-bar-macos package stays as a shim that includes the moved module. The macOS flake builds -p komorebi-bar and its source filter takes the unified package's manifest, main.rs and src/macos; the Windows filter leaves src/macos out. The bar does not build for Linux (no arm of the cfg_select), as before. Gates run: Windows clippy --all-targets -D warnings PASS; macOS fake-CC check --locked --all-targets of -p komorebi-bar and -p komorebi-bar-macos PASS (type check only); bar-core schema oracle (3 + 6) PASS; the S/bar2 harness regenerates schema.bar.json for Windows (9091 lines) and macOS (3774) byte-identical to the checked-in files; tools/kde-closure-check ok; CLI docs oracle identical x3; nix evaluation PASS and by evaluation an edit of komorebi-bar/src/windows changes the Windows derivations only (the macOS side cannot be evaluated on this Linux host). Not run: nix builds, any bar run (Windows screenshot gate and the Mac hand check are owed).
384 lines
14 KiB
Nix
384 lines
14 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;
|
|
in
|
|
((rootCrate || komorebic || komorebiClient || komorebiBar) && !(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-bar"
|
|
|| builtins.any (crate: member == crate || pkgs.lib.hasPrefix "${crate}/" member) rootCrates;
|
|
};
|
|
packages = "-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;
|
|
};
|
|
}
|