nixfiles/tree.nix

{ lib }:
{ config, folder, inputs, ... }@args:
with lib;
let
  # Made by kat witch (kittywitch)
  pureTreeGrab = { base, path }:
    let
      realPath = toString path;
      dirContents = builtins.readDir path;
      isDirectory = entry: dirContents."${entry}" == "directory";
      isHidden = entry: hasPrefix "." entry;
      isDir = entry: _: (isDirectory entry) && !(isHidden entry);
      directories = filterAttrs isDir dirContents;
      isNixFile = entry: _:
        let result = builtins.match "(.*)\\.nix" entry;
        in result != null && builtins.length result > 0;
      nixFiles = filterAttrs isNixFile dirContents;
      getPath = entry: "${realPath}/${entry}";
      getPaths = entries:
        mapAttrs' (n: v: nameValuePair (removeSuffix ".nix" n) (getPath n))
        entries;
      nixFilePaths = getPaths nixFiles;
      dirPaths = getPaths directories;
      recursedPaths = mapAttrs (_: fullPath:
        pureTreeGrab {
          inherit base;
          path = fullPath;
        }) dirPaths;
      contents = recursedPaths // nixFilePaths;
    in contents;
  configTreeStruct = { config, ... }: {
    options.treeConfig = mkOption {
      type = with types;
        attrsOf (submodule ({ name, options, config, ... }: {
          options = {
            evaluateDefault = mkOption {
              type = types.bool;
              description =
                "Replace the contents of this branch or leaf with those provided by the evaluation of default.nix.";
              default = false;
            };
            aliasDefault = mkOption {
              type = types.bool;
              description =
                "Replace the contents of this branch or leaf with the default.nix.";
              default = false;
            };
            excludes = mkOption {
              type = types.listOf types.str;
              description = "Exclude files or folders from the recurser.";
              default = [ ];
            };
            functor = {
              enable = mkOption {
                type = types.bool;
                description = "Provide a functor for the path provided";
                default = false;
              };
              external = mkOption {
                type = types.listOf types.unspecified;
                description = "Add external imports into the functor.";
                default = [ ];
              };
              excludes = mkOption {
                type = types.listOf types.str;
                description = "Exclude files or folders from the functor.";
                default = [ ];
              };
            };
          };
        }));
    };
    config.treeConfig = { "*" = { }; };
  };
  configTree.treeConfig = config;
  configTreeModule = (evalModules {
    modules = [ configTreeStruct configTree ];
  }).config.treeConfig;
  mapAttrsRecursive = f: set:
    let
      recurse = path: set:
        let
          g = name: value:
            if isAttrs value then
              f (path ++ [ name ]) (recurse (path ++ [ name ]) value)
            else
              f (path ++ [ name ]) value;
        in mapAttrs g set;
    in recurse [ ] set;
  getPathString = path: concatStringsSep "/" path;
  getConfig = path: default: configTreeModule.${getPathString path} or default;
  revtail = path: sublist 0 (length path - 1) path;
  getConfigRecursive = path:
    let parentPath = revtail path;
    in getConfig (path ++ singleton "*") (getConfigRecursive parentPath);
  processLeaves = tree: config:
    mapAttrsRecursive (path: value:
      let
        pathString = getPathString path;
        leafConfig = getConfig path (getConfigRecursive (revtail path));
        processConfig = path: value:
          let
            processFunctor = prev:
              prev // {
                __functor = self:
                  { ... }: {
                    imports =
                      attrValues (removeAttrs prev leafConfig.functor.excludes)
                      ++ leafConfig.functor.external;
                  };
              };
            processAliasDefault = prev: prev.default;
            processDefault = prev:
              import prev.default (args // {
                inherit lib;
                tree = {
                  prev = removeAttrs prev (singleton "default");
                  pure = pureTree;
                  impure = impureTree;
                };
              });
            processExcludes = prev: removeAttrs prev leafConfig.excludes;
            processes = optionals (isAttrs value)
              (optional (leafConfig.excludes != [ ]) processExcludes
                ++ optional leafConfig.evaluateDefault processDefault
                ++ optional leafConfig.aliasDefault processAliasDefault
                ++ optional leafConfig.functor.enable processFunctor);
          in pipe value processes;
      in processConfig path value) tree;
  pureTree = pureTreeGrab {
    base = folder;
    path = folder;
  };
  impureTree = processLeaves pureTree configTreeModule;
in {
  config = configTreeModule;
  pure = pureTree;
  impure = impureTree;
}