mkDevos and evalDevosArgs: Move flake implementation logic into lib

doc/start/index.md

@@ -36,6 +36,7 @@ In addition, the [binary cache](../../cachix) is added for faster deployment.
 - [Make installable ISO](./iso.md)
 - [Bootstrap Host](./bootstrapping.md)
 - [Already on NixOS](./from-nixos.md)
+- [Use mkDevos](./mkDevos.md)
 
 
 [install-nix]: https://nixos.org/manual/nix/stable/#sect-multi-user-installation

doc/start/use-mkdevos.md

@@ -0,0 +1,37 @@
+# Use mkDevos
+You can also use devos as a flake input and get the advantage of using
+nix flakes to sync with upstream changes in devos.
+
+You can either use the default template or use the 'mkdevos' template which only
+includes the necessary files for `mkDevos` usage. It can be pulled with:
+```sh
+nix flake init -t github:divnix/devos#mkdevos
+```
+
+Once you have a template, edit your flake.nix to add devos as an input:
+```nix
+inputs = {
+  ...
+  devos.url = "github:divnix/devos";
+};
+```
+then replace the outputs section with this:
+```nix
+outputs = { self, devos, ... }: devos.lib.mkDevos { inherit self; };
+```
+
+Now you can sync with upstream devos changes just like any other flake input.
+
+If you would like to change your directory's structure, you can pass
+arguments to `mkDevos` to outline where certain things are. You can take a 
+look at [evalDevosArgs](../../lib/devos/evalDevosArgs.nix) to learn about
+the arguments that it can take.
+
+> ##### Notes:
+> - All inputs used in devos must also be added to your flake, due to an
+>   [issue](https://github.com/NixOS/nix/pull/4641) with the `follows` attribute.
+> - You can append `/community` to the `devos.url` to get access to community modules
+>   and packages which can be added in [extern](../../extern).
+> - Many folders in devos will no longer be needed and can, optionally, be deleted.
+> - To use community profiles, you will have to copy them to your tree
+> - If you use this method, you will no longer be able to edit devos internals.

flake.nix

@@ -28,68 +28,11 @@
       pkgs.inputs.nixpkgs.follows = "nixos";
     };
 
-  outputs = inputs@{ deploy, nixos, nur, self, utils, ... }:
-    let
-      inherit (self) lib;
-      inherit (lib) os;
-
-      extern = import ./extern { inherit inputs; };
-
-      multiPkgs = os.mkPkgs;
-
-      outputs = {
-        nixosConfigurations =
-          import ./hosts (nixos.lib.recursiveUpdate inputs {
-            inherit multiPkgs extern;
-            defaultSystem = "x86_64-linux";
-            lib = nixos.lib.extend (final: prev: {
-              dev = self.lib;
-            });
-          });
-
-        homeConfigurations = os.mkHomeConfigurations;
-
-        nixosModules =
-          let moduleList = import ./modules/module-list.nix;
-          in lib.pathsToImportedAttrs moduleList;
-
-        homeModules =
-          let moduleList = import ./users/modules/module-list.nix;
-          in lib.pathsToImportedAttrs moduleList;
-
-        overlay = import ./pkgs;
-        overlays = lib.pathsToImportedAttrs (lib.pathsIn ./overlays);
-
-        lib = import ./lib { inherit nixos self inputs; };
-
-        templates.flk.path = ./.;
-        templates.flk.description = "flk template";
-        defaultTemplate = self.templates.flk;
-
-        deploy.nodes = os.mkNodes deploy self.nixosConfigurations;
+    outputs = inputs@{ deploy, nixos, nur, self, utils, ... }:
+      let
+        lib = import ./lib { inherit self nixos inputs; };
+      in
+      lib.mkDevos {
+        inherit self;
       };
-
-      systemOutputs = utils.lib.eachDefaultSystem (system:
-        let pkgs = multiPkgs.${system}; in
-        {
-          checks =
-            let
-              tests = nixos.lib.optionalAttrs (system == "x86_64-linux")
-                (import ./tests { inherit self pkgs; });
-              deployHosts = nixos.lib.filterAttrs
-                (n: _: self.nixosConfigurations.${n}.config.nixpkgs.system == system) self.deploy.nodes;
-              deployChecks = deploy.lib.${system}.deployChecks { nodes = deployHosts; };
-            in
-            nixos.lib.recursiveUpdate tests deployChecks;
-
-          packages = utils.lib.flattenTreeSystem system
-            (os.mkPackages { inherit pkgs; });
-
-          devShell = import ./shell {
-            inherit self system;
-          };
-        }
-      );
-    in
-    nixos.lib.recursiveUpdate outputs systemOutputs;
 }

lib/attrs.nix

@@ -21,7 +21,9 @@ rec {
       paths' = lib.filter (lib.hasSuffix ".nix") paths;
     in
     genAttrs' paths' (path: {
-      name = lib.removeSuffix ".nix" (baseNameOf path);
+      name = lib.removeSuffix ".nix"
+        # Safe as long this is just used as a name
+        (builtins.unsafeDiscardStringContext (baseNameOf path));
       value = import path;
     });
 

lib/default.nix

@@ -17,6 +17,7 @@ lib.makeExtensible (final:
     lists = callLibs ./lists.nix;
     strings = callLibs ./strings.nix;
 
+    inherit (os) mkDevos;
     inherit (attrs) mapFilterAttrs genAttrs' pathsToImportedAttrs concatAttrs;
     inherit (lists) pathsIn;
     inherit (strings) rgxToString;

lib/devos/default.nix

@@ -7,10 +7,21 @@
       config = { allowUnfree = true; };
     };
 
+  importIf = path: fallback:
+    if builtins.pathExists path then import path else fallback;
+
   profileMap = map (profile: profile.default);
 
+  evalDevosArgs = dev.callLibs ./evalDevosArgs.nix;
+
+  mkDevos = dev.callLibs ./mkDevos.nix;
+
   mkNodes = dev.callLibs ./mkNodes.nix;
 
+  mkHosts = dev.callLibs ./mkHosts.nix;
+
+  mkSuites = dev.callLibs ./mkSuites.nix;
+
   mkProfileAttrs = dev.callLibs ./mkProfileAttrs.nix;
 
   mkPkgs = dev.callLibs ./mkPkgs.nix;

lib/devos/evalDevosArgs.nix

@@ -0,0 +1,166 @@
+{ self, dev, nixos, inputs, ... }:
+
+{ args }:
+let
+  argOpts = with nixos.lib; { config, options, ... }:
+    let
+      inherit (dev) os;
+      inherit (os) importIf;
+
+      cfg = config;
+      inherit (cfg) self;
+
+      inputAttrs = types.functionTo types.attrs;
+    in
+    {
+      options = with types; {
+        self = mkOption {
+          type = addCheck attrs nixos.lib.isStorePath;
+          description = "The flake to create the devos outputs for";
+        };
+        hosts = mkOption {
+          type = path;
+          default = "${self}/hosts";
+          defaultText = "\${self}/hosts";
+          description = "Path to directory containing host configurations";
+        };
+        packages = mkOption {
+          # functionTo changes arg names which breaks flake check
+          type = types.anything // {
+            check = builtins.isFunction;
+            description = "Nixpkgs overlay";
+          };
+          default = importIf "${self}/pkgs" (final: prev: {});
+          defaultText = "\${self}/pkgs";
+          description = ''
+            Overlay for custom packages that will be included in treewide 'pkgs'.
+            This should follow the standard nixpkgs overlay format - two argument function
+            that returns an attrset.
+          '';
+        };
+        modules = mkOption {
+          type = listOf anything;
+          default = importIf "${self}/modules/module-list.nix" [];
+          defaultText = "\${self}/modules/module-list.nix";
+          apply = dev.pathsToImportedAttrs;
+          description = "list of modules to include in confgurations";
+        };
+        userModules = mkOption {
+          type = listOf anything;
+          default = importIf "${self}/users/modules/module-list.nix" [];
+          defaultText = "\${self}/users/modules/module-list.nix";
+          apply = dev.pathsToImportedAttrs;
+          description = "list of modules to include in home-manager configurations";
+        };
+        profiles = mkOption {
+          type = path;
+          default = "${self}/profiles";
+          defaultText = "\${self}/profiles";
+          apply = os.mkProfileAttrs;
+          description = "path to profiles folder";
+        };
+        userProfiles = mkOption {
+          type = path;
+          default = "${self}/users/profiles";
+          defaultText = "\${self}/users/profiles";
+          apply = os.mkProfileAttrs;
+          description = "path to user profiles folder";
+        };
+        suites =
+          let
+            defaults = { user = {}; system = {}; };
+          in
+          mkOption {
+            type = inputAttrs;
+            default = importIf "${self}/suites" ({...}: defaults);
+            defaultText = "\${self}/suites";
+            apply = suites: defaults // os.mkSuites {
+              inherit suites;
+              inherit (config) profiles users userProfiles;
+            };
+            description = ''
+              function with inputs 'users' and 'profiles' that returns attribute 'system'
+              which defines suites passed to configurations as the suites specialArg
+            '';
+          };
+        users = mkOption {
+          type = path;
+          default = "${self}/users";
+          defaultText = "\${self}/users";
+          apply = os.mkProfileAttrs;
+          description = "path to folder containing user profiles";
+        };
+        extern =
+          let
+            defaults = {
+              modules = []; overlays = []; specialArgs = {};
+              userModules = []; userSpecialArgs = [];
+            };
+          in
+          mkOption {
+            type = inputAttrs;
+            default = importIf "${self}/extern" ({...}: defaults);
+            defaultText = "\${self}/extern";
+            # So unneeded extern attributes can safely be deleted
+            apply = x: defaults // (x { inputs = inputs // self.inputs; });
+            description = ''
+              Function with argument 'inputs' with all devos and this flake's inputs.
+              The function should return an attribute set with modules, overlays, and
+              specialArgs to be included across devos
+            '';
+          };
+        overlays = mkOption {
+          type = path;
+          default = "${self}/overlays";
+          defaultText = "\${self}/overlays";
+          apply = x: dev.pathsToImportedAttrs (dev.pathsIn x);
+          description = "path to folder containing overlays which will be applied to pkgs";
+        };
+        overrides =
+          let
+            defaults = { modules = []; disabledModules = []; packages = _: _: _: {}; };
+          in
+          mkOption {
+            type = attrs;
+            default = importIf "${self}/overrides" defaults;
+            apply = x: defaults // x;
+            defaultText = "\${self}/overrides";
+            description = "attrset of packages and modules that will be pulled from nixpkgs master";
+          };
+        genDoc = mkOption {
+          type = functionTo attrs;
+          internal = true;
+          description = "function that returns a generated options doc derivation given nixpkgs";
+        };
+      };
+      config.genDoc =
+        let
+          singleDoc = name: value: ''
+            ## ${name}
+            ${value.description}
+
+            ${optionalString (value ? type) ''
+              *_Type_*:
+              ${value.type}
+            ''}
+            ${optionalString (value ? default) ''
+              *_Default_*
+              ```
+              ${builtins.toJSON value.default}
+              ```
+            ''}
+            ${optionalString (value ? example) ''
+              *_Example_*
+              ```
+              ${value.example}
+              ```
+            ''}
+          '';
+        in
+          pkgs: with pkgs; writeText "devosOptions.md"
+            (concatStringsSep "" (mapAttrsToList singleDoc (nixosOptionsDoc { inherit options; }).optionsNix));
+    };
+in
+  nixos.lib.evalModules {
+    modules = [ argOpts args ];
+  }