utils/interpretNonstandardModule.nix

# As our modules have nonstandard properties, we need to have some way of
# properly intepreting them
# This function takes a list of modules, as well as arguments to import them
# with, and returns a list of modules, each with the standard NixOS module
# properties as well as with custom properties as described in /README.md
lib: transformArgs: modules: args @ { pkgs, ... }:
let
  resolver = module:
    let
      importedModule =
        if builtins.typeOf module == "path"
        then import module
        else module;
      resolvedModule =
        if builtins.typeOf importedModule == "lambda"
        then
          importedModule
            (transformArgs args)
        else importedModule;
      moduleName =
        if builtins.typeOf module == "lambda"
        then "<AnonFunction>"
        else if builtins.typeOf module == "path"
        then builtins.toString module
        else builtins.toJSON module;
    in
    lib.warnIfNot
      ((lib.pipe resolvedModule [
        builtins.attrNames
        (lib.subtractLists [ "home" "config" "imports" "options" "traces" ])
      ])
      == [ ])
      "Module ${moduleName} had attribute names ${builtins.toJSON (builtins.attrNames resolvedModule)} but only home, config, imports and options are resolved"
      [
        {
          config = lib.recursiveUpdate (resolvedModule.config or { }) {
            home-manager.users."${args.username}".imports =
              (resolvedModule.config.home-manager.users."${args.username}".imports or [ ])
              ++ [ resolvedModule.home or { } ];
          };
          imports = resolvedModule.imports or [ ];
          options = resolvedModule.options or { };
        }
      ]
    ++ (builtins.map
      (trace:
        let
          splitTrace = lib.splitString "." trace;
          traceHead = builtins.head splitTrace;
          traceTail = builtins.tail splitTrace;
          resolvedTrace =
            (
              if traceHead == "home"
              then [ "home-manager" "users" args.username ]
              else lib.errorIfNot (traceHead == "config") [ ]
            )
            ++ traceTail;
        in
        { config, ... }: (builtins.seq
          (
            lib.pipe resolvedTrace [
              (lib.foldl
                ({ value
                 , error
                 ,
                 }: key:
                  if builtins.hasAttr key value
                  then {
                    value = value.${key};
                    inherit error;
                  }
                  else {
                    value = { };
                    error = true;
                  })
                {
                  value = { };
                  error = false;
                })
              (data: lib.warnIf data.error "trace@${moduleName}/${trace} is invalid; the key does not exist" data)
              ({ value
               , error
               ,
               }: {
                value = builtins.toJSON value;
                inherit error;
              })
              ({ value
               , error
               ,
               }: {
                value = "trace@${moduleName}/${trace}: ${value}";
                inherit error;
              })
              ({ value
               , error
               ,
               }:
                lib.traceIf (!error) value null)
            ]
          )
          { }))
      (resolvedModule.traces or [ ]));
in
{
  imports = (
    if builtins.typeOf modules == "list"
    then builtins.concatLists (builtins.map resolver modules)
    else resolver modules
  );
}