komorebi/nix/workspace-src.nix

# The source of a build of one platform, cut from the one Cargo workspace of this repository.
#
#   import ./workspace-src.nix { pkgs; craneLib; repoRoot; platform = "windows" | "linux" | "macos" | "recorder" | "nixgen"; }
#
# Cargo has to load every member of the workspace (the root manifest lists the members of all three
# platforms), but a build of one platform needs the sources of that platform's crates only. The result:
#
#   real      the filtered source: the members of the platform, the root manifest and lock, the
#             platform's files of the crates the platforms share, and the data files they read
#   src       `real` plus, for every other member, its own manifest with an empty library and a `main`
#             that does nothing (a stub: cargo refuses a workspace with a member that is not there, and
#             a lock file that has packages the workspace does not have fails under --locked)
#   members   the members of the platform; stubbed the others; stubbedPackages their package names (for
#             `cargo deny --exclude`)
#
# The platform "recorder" is the source of komorebi-recorder's own builds on macOS and Linux: the recorder
# indexes the log statements of the daemons of all three platforms (komorebi-recorder/build.rs), so it
# has their sources, whole, and nothing else; the Windows build has the recorder as one of its members.
#
# The platform "nixgen" is the source of schemars-nixgen's own builds: the tool and nothing else. It is a
# stub in every other platform, so that an edit of it changes none of their derivations.
#
# An edit under one platform therefore changes nothing in the derivations of the others, except where
# the edit is in a crate they share or in the root manifest, lock or toolchain files.
{
  pkgs,
  craneLib,
  repoRoot,
  platform,
}:
let
  inherit (pkgs) lib;
  root = toString repoRoot;

  allMembers = (builtins.fromTOML (builtins.readFile (repoRoot + "/Cargo.toml"))).workspace.members;

  # the crates of the root workspace that the KDE packages depend on, by path (nix/linux/root-crates.json,
  # kept equal to `cargo tree` by tools/kde-closure-check); komorebi-bar and komorebi-bar-core (the egui
  # bar) are not in it, so an edit of the bar does not rebuild the KDE packages
  linuxShared = builtins.fromJSON (builtins.readFile ./linux/root-crates.json) ++ [
    "komorebi"
  ];

  # the crates only one platform builds; the Windows set also has the e2e guests and the Windows-only
  # binaries, which the other platforms never build
  linuxOnly = [
    "crates/komorebi-linux"
    "crates/komorebi-hotkeys"
  ];
  macosOnly = [ "crates/komorebi-macos" ];

  # crates that no Linux package depends on, but whose tests need no macOS and so run in `linux-nextest`:
  # the FFI-free part of the macOS daemon. They are not in linux/root-crates.json (that list is the
  # `cargo tree` of the Linux packages, which tools/kde-closure-check keeps equal), only members of the
  # Linux source.
  linuxNeutralTests = [ "crates/komorebi-macos-core" ];
  windowsOnly = [
    "crates/komorebi-windows"
    "komorebi-gui"
    "komorebic-no-console"
    "komorebi-shortcuts"
  ];

  # the development tool that writes the Nix options: built by its own checks (nix/nixgen)
  toolOnly = [ "crates/schemars-nixgen" ];

  # the recorder and the crates whose source its build script indexes (komorebi-recorder/build.rs)
  recorderMembers = [
    "komorebi-recorder"
    "crates/komorebi-windows"
    "crates/komorebi-macos"
    "crates/komorebi-linux"
    "crates/komorebi-client"
    "crates/komorebi-layouts"
    "crates/komorebi-core"
    "crates/komorebi-transport"
  ];

  membersOf = {
    recorder = recorderMembers;
    nixgen = toolOnly;
    # everything but the other two platforms' crates and the tool
    windows = builtins.filter (m: !(builtins.elem m (linuxOnly ++ macosOnly ++ toolOnly))) allMembers;
    linux = linuxOnly ++ linuxShared ++ linuxNeutralTests;
    # everything but the Windows and Linux crates, the tool and the recorder
    macos = builtins.filter (
      m: !(builtins.elem m (windowsOnly ++ linuxOnly ++ toolOnly ++ [ "komorebi-recorder" ]))
    ) allMembers;
  };

  members = builtins.filter (m: builtins.elem m membersOf.${platform}) allMembers;
  stubbed = builtins.filter (m: !(builtins.elem m members)) allMembers;
  stubbedPackages = map (
    m: (builtins.fromTOML (builtins.readFile (repoRoot + "/${m}/Cargo.toml"))).package.name
  ) stubbed;

  # the crates one entry point serves for every platform: each keeps its own platform's modules and
  # tests (named by prefix) and drops the other platforms'
  sharedCrates = [
    "komorebic"
    "crates/komorebi-client"
    "komorebi-bar"
    "komorebi"
  ];
  markers = {
    windows = "(src/windows(\\.rs|/.*)|tests/windows_.*)";
    linux = "(src/linux(\\.rs|/.*)|tests/linux_.*)";
    macos = "(src/macos(\\.rs|/.*)|tests/macos_.*)";
  };
  # the recorder indexes every platform's files
  otherMarkers =
    if platform == "recorder" || platform == "nixgen" then
      [ ]
    else
      builtins.attrValues (removeAttrs markers [ platform ]);
  ofOtherPlatform =
    rel:
    builtins.any (
      crate:
      lib.hasPrefix "${crate}/" rel
      && builtins.any (
        marker: builtins.match marker (lib.removePrefix "${crate}/" rel) != null
      ) otherMarkers
    ) sharedCrates;

  # the directories of the source (a file is kept only under one of them)
  roots =
    members
    ++ lib.optional (platform == "windows") "wix"
    ++ (
      if platform == "nixgen" then
        [ ".cargo" ]
      else if platform == "recorder" then
        [
          ".cargo"
          # the installer, which a test of the recorder checks for its binaries
          "wix"
        ]
      else
        [
          "docs"
          "schemas"
          ".cargo"
        ]
    )
    # the configurations that the config_parity test of komorebi-linux loads
    ++ lib.optional (platform == "linux") "spikes/config-parity";
  underRoot = rel: builtins.any (r: rel == r || lib.hasPrefix "${r}/" rel) roots;
  # a directory above a root (`crates` for `crates/komorebi-core`)
  aboveRoot = rel: builtins.any (r: lib.hasPrefix "${rel}/" r) roots;

  # data files that the Rust sources and tests read, outside the Cargo sources
  extra =
    rel:
    # the test inputs of every crate
    (builtins.match ".*/(tests|fixtures|golden)/.*" rel != null)
    || {
      windows =
        # the whole of docs/ (they are embedded in komorebic and the bar) except the other platforms' and
        # the developer notes; the macOS CLI pages are read by a test of komorebic-core
        (
          lib.hasPrefix "docs/" rel
          && !(builtins.any (p: lib.hasPrefix p rel) [
            "docs/linux/"
            "docs/macos/"
            "docs/dev/"
          ])
        )
        || lib.hasPrefix "docs/macos/cli/" rel
        || lib.hasPrefix "schemas/" rel
        # the icon and the guide the recorder embeds, and the installer a test of it reads
        || lib.hasPrefix "komorebi-recorder/" rel
        || lib.hasPrefix "wix/" rel;
      linux =
        # the script komorebi loads into KWin and the JSON the tests and the daemon read
        (lib.hasSuffix ".js" rel || lib.hasSuffix ".json" rel)
        && !(lib.hasPrefix "docs/" rel || lib.hasPrefix "schemas/" rel)
        # the schemas of every platform: a test of komorebi-config compares them
        || lib.hasPrefix "schemas/" rel
        # the macOS CLI pages that a test of komorebic-core compares with the commands
        || lib.hasPrefix "docs/macos/cli/" rel
        || lib.hasPrefix "spikes/config-parity/" rel
        || builtins.elem rel [
          # the example configuration and the sample key bindings that `komorebic quickstart` includes
          "docs/linux/komorebi.example.json"
          "docs/linux/skhdrc.sample"
          # the page that shows the example configuration, which a test compares with the file
          "docs/linux/example-configurations.md"
          # the example a test loads, to see that the docs show one that works
          "docs/linux/usage/wallpapers.md"
        ];
      macos =
        lib.hasSuffix ".json" rel && !(lib.hasPrefix "docs/" rel || lib.hasPrefix "schemas/" rel)
        || lib.hasPrefix "docs/macos/" rel
        || lib.hasPrefix "schemas/macos/" rel;
      # the guide and the icon the recorder embeds, and the installer
      recorder = lib.hasPrefix "komorebi-recorder/" rel || lib.hasPrefix "wix/" rel;
      nixgen = false;
    }
    .${platform};

  real = lib.cleanSourceWith {
    src = repoRoot;
    filter =
      path: type:
      let
        rel = lib.removePrefix "${root}/" path;
        isRootFile = !(lib.hasInfix "/" rel);
      in
      if type == "directory" then
        rel == root || aboveRoot rel || (underRoot rel && !(ofOtherPlatform rel))
      else
        # the files at the top: Cargo.toml, Cargo.lock, rust-toolchain.toml, rustfmt.toml, deny.toml
        (isRootFile && craneLib.filterCargoSources path type)
        || (
          underRoot rel && !(ofOtherPlatform rel) && ((craneLib.filterCargoSources path type) || extra rel)
        );
  };

  stub = member: ''
    mkdir -p $out/${member}/src
    cp ${
      builtins.path {
        path = repoRoot + "/${member}/Cargo.toml";
        name = "Cargo.toml";
      }
    } $out/${member}/Cargo.toml
    : > $out/${member}/src/lib.rs
    echo 'fn main() {}' > $out/${member}/src/main.rs
  '';

  src = pkgs.runCommand "komorebi-${platform}-src" { } ''
    cp -r ${real} $out
    chmod -R u+w $out
    ${lib.concatMapStrings stub stubbed}
  '';
in
{
  inherit
    real
    src
    members
    stubbed
    stubbedPackages
    ;
}