165 lines
4.2 KiB
Nix
165 lines
4.2 KiB
Nix
{ lib }:
|
|
# Importers from digga: https://github.com/divnix/digga/blob/main/src/importers.nix
|
|
# Plus the mkHomeConfigurations generator from digga: https://github.com/divnix/digga/blob/main/src/generators.nix
|
|
let
|
|
flattenTree' =
|
|
/*
|
|
*
|
|
Synopsis: flattenTree' _cond_ _sep_ _tree_
|
|
|
|
Flattens a _tree_ of the shape that is produced by rakeLeaves.
|
|
_cond_ determines when to stop recursing
|
|
_sep_ is the separator to join the path with
|
|
|
|
Output Format:
|
|
An attrset with names in the spirit of the Reverse DNS Notation form
|
|
that fully preserve information about grouping from nesting.
|
|
|
|
Example input:
|
|
```
|
|
{
|
|
a = {
|
|
b = {
|
|
c = <path>;
|
|
};
|
|
};
|
|
}
|
|
```
|
|
|
|
Example output:
|
|
```
|
|
{
|
|
"a.b.c" = <path>;
|
|
}
|
|
```
|
|
*
|
|
*/
|
|
cond: sep: tree:
|
|
let
|
|
op =
|
|
sum: path: val:
|
|
let
|
|
pathStr = builtins.concatStringsSep sep path; # dot-based reverse DNS notation
|
|
in
|
|
if cond val then
|
|
# builtins.trace "${toString val} matches condition"
|
|
(sum // { "${pathStr}" = val; })
|
|
else if builtins.isAttrs val then
|
|
# builtins.trace "${builtins.toJSON val} is an attrset"
|
|
# recurse into that attribute set
|
|
(recurse sum path val)
|
|
else
|
|
# ignore that value
|
|
# builtins.trace "${toString path} is something else"
|
|
sum;
|
|
|
|
recurse =
|
|
sum: path: val:
|
|
builtins.foldl' (sum: key: op sum (path ++ [ key ]) val.${key}) sum (builtins.attrNames val);
|
|
in
|
|
recurse { } [ ] tree;
|
|
|
|
flattenTree = flattenTree' builtins.isPath ".";
|
|
|
|
rakeLeaves =
|
|
/*
|
|
*
|
|
Synopsis: rakeLeaves _path_
|
|
|
|
Recursively collect the nix files of _path_ into attrs.
|
|
|
|
Output Format:
|
|
An attribute set where all `.nix` files and directories with `default.nix` in them
|
|
are mapped to keys that are either the file with .nix stripped or the folder name.
|
|
All other directories are recursed further into nested attribute sets with the same format.
|
|
|
|
Example file structure:
|
|
```
|
|
./core/default.nix
|
|
./base.nix
|
|
./main/dev.nix
|
|
./main/os/default.nix
|
|
```
|
|
|
|
Example output:
|
|
```
|
|
{
|
|
core = ./core;
|
|
base = base.nix;
|
|
main = {
|
|
dev = ./main/dev.nix;
|
|
os = ./main/os;
|
|
};
|
|
}
|
|
```
|
|
*
|
|
*/
|
|
dirPath:
|
|
let
|
|
seive =
|
|
file: type:
|
|
# Only rake `.nix` files or directories
|
|
(type == "regular" && lib.hasSuffix ".nix" file) || (type == "directory");
|
|
|
|
collect = file: type: {
|
|
name = lib.removeSuffix ".nix" file;
|
|
value =
|
|
let
|
|
path = dirPath + "/${file}";
|
|
in
|
|
if (type == "regular") || (type == "directory" && builtins.pathExists (path + "/default.nix")) then
|
|
path
|
|
# recurse on directories that don't contain a `default.nix`
|
|
else
|
|
rakeLeaves path;
|
|
};
|
|
|
|
files = lib.filterAttrs seive (builtins.readDir dirPath);
|
|
in
|
|
lib.filterAttrs (n: v: v != { }) (lib.mapAttrs' collect files);
|
|
|
|
flattenLeaves = dir: flattenTree (rakeLeaves dir);
|
|
|
|
getFqdn =
|
|
c:
|
|
let
|
|
net = c.config.networking;
|
|
fqdn =
|
|
if (net ? domain) && (net.domain != null) then "${net.hostName}.${net.domain}" else net.hostName;
|
|
in
|
|
fqdn;
|
|
in
|
|
{
|
|
inherit
|
|
rakeLeaves
|
|
flattenTree
|
|
flattenTree'
|
|
flattenLeaves
|
|
;
|
|
|
|
leaves = dir: builtins.attrValues (flattenLeaves dir);
|
|
|
|
mkHomeConfigurations =
|
|
systemConfigurations:
|
|
/*
|
|
*
|
|
Synopsis: mkHomeConfigurations _systemConfigurations_
|
|
|
|
Generate the `homeConfigurations` attribute expected by `home-manager` cli
|
|
from _nixosConfigurations_ or _darwinConfigurations_ in the form
|
|
_user@hostname_.
|
|
*
|
|
*/
|
|
let
|
|
op =
|
|
attrs: c:
|
|
attrs
|
|
// (lib.mapAttrs' (user: v: {
|
|
name = "${user}@${getFqdn c}";
|
|
value = v.home;
|
|
}) c.config.home-manager.users);
|
|
mkHmConfigs = lib.foldl op { };
|
|
in
|
|
mkHmConfigs (builtins.attrValues systemConfigurations);
|
|
|
|
}
|