experimental configuration-based nixvim template

flake/templates.nix

@@ -5,6 +5,10 @@
       path = ../templates/simple;
       description = "A simple nix flake template for getting started with nixvim";
     };
+    new = {
+      path = ../templates/experimental-flake-parts;
+      description = "An experimental flake template for configuring nixvim using evalNixvim and flake.parts";
+    };
   };
 
   # 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;
     };
 }

templates/experimental-flake-parts/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/experimental-flake-parts/config/bufferline.nix

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

templates/experimental-flake-parts/config/default.nix

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

templates/experimental-flake-parts/flake.nix

@@ -0,0 +1,54 @@
+{
+  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 =
+    { self, 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;
+        # Adds `flake.nixvimModules` and `perSystem.nixvimConfigurations`
+        inputs.nixvim.flakeModules.default
+      ];
+
+      nixvim = {
+        # Automatically install corresponding packages for each nixvimConfiguration
+        # Lets you run `nix run .#<name>`, or simply `nix run` if you have a default
+        packages.enable = true;
+        # Automatically install checks for each nixvimConfiguration
+        # Run `nix flake check` to verify that your config is not broken
+        checks.enable = true;
+      };
+
+      # You can define your reusable Nixvim modules here
+      flake.nixvimModules = {
+        default = ./config;
+      };
+
+      perSystem =
+        { system, ... }:
+        {
+          # You can define actual Nixvim configurations here
+          nixvimConfigurations = {
+            default = inputs.nixvim.lib.evalNixvim {
+              inherit system;
+              modules = [
+                self.nixvimModules.default
+              ];
+            };
+          };
+        };
+    };
+}