experimental configuration-based nixvim template

flake-modules/default.nix

@@ -2,15 +2,22 @@
 {
   imports = [
     ./dev
+    ./public
     ./lib.nix
     ./legacy-packages.nix
+    ./nixvim-configurations.nix
     ./overlays.nix
     ./packages.nix
     ./templates.nix
     ./tests.nix
     ./wrappers.nix
+    inputs.flake-parts.flakeModules.flakeModules
   ];
 
+  flake.flakeModules = {
+    default = ./public;
+  };
+
   perSystem =
     { system, ... }:
     {

flake-modules/legacy-packages.nix

@@ -1,19 +1,15 @@
-{ helpers, ... }:
 {
   perSystem =
     {
+      config,
       makeNixvimWithModule,
-      system,
       ...
     }:
     {
       legacyPackages = rec {
         inherit makeNixvimWithModule;
         makeNixvim = module: makeNixvimWithModule { inherit module; };
-
-        nixvimConfiguration = helpers.modules.evalNixvim {
-          inherit system;
-        };
+        nixvimConfiguration = config.nixvimConfigurations.default;
       };
     };
 }

flake-modules/lib.nix

@@ -21,6 +21,10 @@
       overlay = lib.makeOverridable (import ../lib/overlay.nix) {
         flake = self;
       };
+      # Top-top-level aliases
+      inherit (self.lib.nixvim)
+        evalNixvim
+        ;
     }
     // lib.genAttrs config.systems (
       lib.flip withSystem (

flake-modules/nixvim-configurations.nix

@@ -0,0 +1,14 @@
+{ helpers, ... }:
+{
+  flake.flakeModules = {
+    nixvimConfigurations = ./public/nixvimConfigurations.nix;
+  };
+
+  perSystem =
+    { system, ... }:
+    {
+      nixvimConfigurations.default = helpers.modules.evalNixvim {
+        inherit system;
+      };
+    };
+}

flake-modules/public/default.nix

@@ -0,0 +1,5 @@
+{
+  imports = [
+    ./nixvimConfigurations.nix
+  ];
+}

flake-modules/public/nixvimConfigurations.nix

@@ -0,0 +1,21 @@
+{ lib, flake-parts-lib, ... }:
+let
+  configurationType = lib.mkOptionType {
+    name = "configuration";
+    description = "configuration";
+    descriptionClass = "noun";
+    merge = lib.options.mergeOneOption;
+    check = x: x._type or null == "configuration";
+  };
+in
+flake-parts-lib.mkTransposedPerSystemModule {
+  name = "nixvimConfigurations";
+  option = lib.mkOption {
+    type = lib.types.lazyAttrsOf configurationType;
+    default = { };
+    description = ''
+      An attribute set of Nixvim configurations.
+    '';
+  };
+  file = ./nixvimConfigurations.nix;
+}

flake-modules/templates.nix

@@ -5,6 +5,10 @@
       path = ../templates/simple;
       description = "A simple nix flake template for getting started with nixvim";
     };
+    new = {
+      path = ../templates/new;
+      description = "An experimental flake template for configuring nixvim directly with evalNixvim";
+    };
   };
 
   # The following adds the template flake's checks to the main (current) flake's checks.
@@ -25,7 +29,7 @@
             args@{
               inputs,
               outputs,
-              sourceInfo,
+              sourceInfo ? { },
             }:
             let
               outputs = args.outputs (inputs // { self = result; });
@@ -39,18 +43,21 @@
             in
             result;
 
-          templateFlakeOutputs = callFlake {
-            inputs = {
-              inherit (inputs) flake-parts nixpkgs;
-              nixvim = self;
-            };
-            # Import and read the `outputs` field of the template flake.
-            inherit (import ../templates/simple/flake.nix) outputs;
-            sourceInfo = { };
-          };
-
-          templateChecks = templateFlakeOutputs.checks.${system};
+          flakes = lib.mapAttrs (
+            name: template:
+            callFlake {
+              # Use inputs from our flake
+              inputs = {
+                inherit (inputs) flake-parts nixpkgs;
+                nixvim = self;
+              };
+              # Use outputs from the template flake
+              inherit (import "${template.path}/flake.nix") outputs;
+            }
+          ) self.templates;
         in
-        lib.concatMapAttrs (checkName: check: { "template-${checkName}" = check; }) templateChecks;
+        lib.concatMapAttrs (name: flake: {
+          "template-${name}" = pkgs.linkFarm name flake.checks.${system};
+        }) flakes;
     };
 }

lib/default.nix

@@ -44,6 +44,10 @@ lib.makeExtensible (
       transitionType
       ;
 
+    inherit (self.modules)
+      evalNixvim
+      ;
+
     inherit (self.options)
       defaultNullOpts
       mkAutoLoadOption

templates/new/README.md

@@ -0,0 +1,31 @@
+# New Nixvim template
+
+This template gives you a good starting point for configuring nixvim as a standalone module configuration.
+
+## Configuring
+
+To start configuring, just add or modify the module files in `./config`.
+If you add new modules, remember to import them in [`./config/default.nix`](./config/default.nix).
+
+## Using your vim configuration
+
+To use your configuration simply run the following command
+
+```
+nix run
+```
+
+## Configurations and packages
+
+Your nixvim configuration is created using `evalNixvim`.
+This is outputted as the `nixvimConfigurations.<system>.default` flake output.
+
+You can access your configuration's package outputs `<configuration>.config.build.package`.
+This is exported as the flake output `packages.<system>.default`.
+This package can be run using `nix run`.
+
+A test is also available as `<configuration>.config.build.test`.
+This is exported as the flake output `checks.<system>.default`.
+This test can be run using `nix flake check`.
+
+<!-- TODO: figure out how to _wrap_ an existing configuration as a nixos/hm module -->

templates/new/config/bufferline.nix

@@ -0,0 +1,6 @@
+{
+  plugins = {
+    bufferline.enable = true;
+    web-devicons.enable = true;
+  };
+}

templates/new/config/default.nix

@@ -0,0 +1,4 @@
+{
+  # Import all your configuration modules here
+  imports = [ ./bufferline.nix ];
+}

templates/new/flake.nix

@@ -0,0 +1,48 @@
+{
+  description = "A nixvim configuration";
+
+  inputs = {
+    nixpkgs.url = "github:nixos/nixpkgs/nixos-unstable";
+    nixvim.url = "github:nix-community/nixvim";
+    flake-parts.url = "github:hercules-ci/flake-parts";
+  };
+
+  outputs =
+    { nixvim, flake-parts, ... }@inputs:
+    flake-parts.lib.mkFlake { inherit inputs; } {
+      systems = [
+        "x86_64-linux"
+        "aarch64-linux"
+        "x86_64-darwin"
+        "aarch64-darwin"
+      ];
+
+      imports = [
+        # Import nixvim's flake-parts module, to enable defining `nixvimConfigurations`
+        nixvim.flakeModules.default
+      ];
+
+      perSystem =
+        { config, system, ... }:
+        {
+          nixvimConfigurations = {
+            default = nixvim.lib.evalNixvim {
+              inherit system;
+              modules = [
+                ./config
+              ];
+            };
+          };
+
+          checks = {
+            # Run `nix flake check .` to verify that your config is not broken
+            default = config.nixvimConfigurations.default.config.build.test;
+          };
+
+          packages = {
+            # Lets you run `nix run .` to start nixvim
+            default = config.nixvimConfigurations.default.config.build.package;
+          };
+        };
+    };
+}