From 401bc8434c5718190292a68f1a4f210ad10595da Mon Sep 17 00:00:00 2001
From: derped <derped@ophanim.de>
Date: Sun, 5 May 2024 16:20:05 +0200
Subject: [PATCH] Add module definition.

---
 flake.nix                         |  12 +-
 modules/nvim-lazy/default.nix     | 204 ++++++++++++++++++++++++++++++
 modules/nvim-lazy/homeManager.nix |  31 +++++
 modules/nvim-lazy/nixosModule.nix |  31 +++++
 4 files changed, 276 insertions(+), 2 deletions(-)
 create mode 100644 modules/nvim-lazy/default.nix
 create mode 100644 modules/nvim-lazy/homeManager.nix
 create mode 100644 modules/nvim-lazy/nixosModule.nix

diff --git a/flake.nix b/flake.nix
index 3af8c26..cade818 100644
--- a/flake.nix
+++ b/flake.nix
@@ -5,7 +5,7 @@
     flake-utils.url = "github:numtide/flake-utils";
   };
   outputs =
-    { nixpkgs, flake-utils, ... }:
+    { self, nixpkgs, flake-utils, ... }:
     flake-utils.lib.eachDefaultSystem (
       system:
       let
@@ -13,5 +13,13 @@
         lib = nixpkgs.lib;
       in
       import ./default.nix { inherit pkgs lib; }
-    );
+    )
+    // ({
+      nixosModules = {
+        nvim-lazy = import ./modules/nvim-lazy/nixosModule.nix;
+        default = self.nixosModules.nvim-lazy;
+      };
+      homeManagerModules.nvim-lazy = import ./modules/nvim-lazy/homeManager.nix;
+      homeManagerModule = self.homeManagerModules.nvim-lazy;
+    });
 }
diff --git a/modules/nvim-lazy/default.nix b/modules/nvim-lazy/default.nix
new file mode 100644
index 0000000..24169cf
--- /dev/null
+++ b/modules/nvim-lazy/default.nix
@@ -0,0 +1,204 @@
+{ lib, ... }:
+let
+  mkOption = lib.mkOption;
+  types = lib.types;
+  plugin = types.submodule (
+    { ... }:
+    {
+      options = {
+        short = mkOption {
+          type = with types; nullOr str;
+          default = null;
+          description = ''Short plugin url. (installation is handled by lazy.nvim)'';
+        };
+        dir = mkOption {
+          type =
+            with types;
+            nullOr (oneOf [
+              path
+              package
+            ]);
+          default = null;
+          description = ''A vim plugin package or a path pointing to a local plugin.'';
+        };
+        url = mkOption {
+          type = types.nullOr types.str;
+          default = null;
+          description = ''A custom git url where the plugin is hosted. (installation is handled by lazy.nvim)'';
+        };
+        name = mkOption {
+          type = types.nullOr types.str;
+          default = null;
+          description = ''A custom name for the plugin used for the local plugin directory and as the display name.'';
+        };
+        dev = mkOption {
+          type = types.nullOr types.bool;
+          default = null;
+          description = ''When `true`, a local plugin directory will be used instead. See config.dev.'';
+        };
+        lazy = mkOption {
+          type = types.nullOr types.bool;
+          default = null;
+          description = ''When true, the plugin will only be loaded when needed. Lazy-loaded plugins are automatically loaded when their Lua modules are required, or when one of the lazy-loading handlers trigger'';
+        };
+        enabled = mkOption {
+          type =
+            with types;
+            nullOr (oneOf [
+              bool
+              str
+            ]);
+          default = null;
+          description = ''When false, or if the function returns false, then this plugin will not be included in the spec.'';
+        };
+        cond = mkOption {
+          type =
+            with types;
+            nullOr (oneOf [
+              bool
+              str
+            ]);
+          default = null;
+          description = ''When false, or if the function returns false, then this plugin will not be loaded. Useful to disable some plugins in vscode, or firenvim for example.'';
+        };
+        dependencies = mkOption {
+          type =
+            with types;
+            nullOr (
+              listOf (oneOf [
+                str
+                package
+              ])
+            );
+          default = null;
+          description = ''A list of plugin names or plugin specs that should be loaded when the plugin loads. Dependencies are always lazy-loaded unless specified otherwise. When specifying a name, make sure the plugin spec has been defined somewhere else.'';
+        };
+        init = mkOption {
+          type = types.nullOr types.str;
+          default = null;
+          description = ''init functions are always executed during startup'';
+        };
+        opts = mkOption {
+          type = types.nullOr types.attrs;
+          default = null;
+          description = ''opts should be a table (will be merged with parent specs), return a table (replaces parent specs) or should change a table. The table will be passed to the Plugin.config() function. Setting this value will imply Plugin.config()'';
+        };
+        config = mkOption {
+          type =
+            with types;
+            nullOr (oneOf [
+              bool
+              str
+            ]);
+          default = null;
+          description = ''config is executed when the plugin loads. The default implementation will automatically run require(MAIN).setup(opts). Lazy uses several heuristics to determine the plugin's MAIN module automatically based on the plugin's name. See also opts. To use the default implementation without opts set config to true.'';
+        };
+        main = mkOption {
+          type = types.nullOr types.str;
+          default = null;
+          description = ''You can specify the main module to use for config() and opts(), in case it can not be determined automatically. See config()'';
+        };
+        build = mkOption {
+          type = types.nullOr types.str;
+          default = null;
+          description = ''build is executed when a plugin is installed or updated. Before running build, a plugin is first loaded. If it's a string it will be ran as a shell command. When prefixed with : it is a Neovim command. You can also specify a list to executed multiple build commands. Some plugins provide their own build.lua which is automatically used by lazy. So no need to specify a build step for those plugins.'';
+        };
+        branch = mkOption {
+          type = types.nullOr types.str;
+          default = null;
+          description = ''Branch of the repository'';
+        };
+        tag = mkOption {
+          type = types.nullOr types.str;
+          default = null;
+          description = ''Tag of the repository'';
+        };
+        commit = mkOption {
+          type = types.nullOr types.str;
+          default = null;
+          description = ''Commit of the repository'';
+        };
+        version = mkOption {
+          type = types.nullOr types.str;
+          default = null;
+          description = ''Version to use from the repository. Full Semver ranges are supported.'';
+        };
+        pin = mkOption {
+          type = types.nullOr types.bool;
+          default = null;
+          description = ''When true, this plugin will not be included in updates.'';
+        };
+        submodules = mkOption {
+          type = types.nullOr types.bool;
+          default = null;
+          description = ''When false, git submodules will not be fetched. Defaults to true if unset/null.'';
+        };
+        event = mkOption {
+          type = with types; nullOr (listOf str);
+          default = null;
+          description = ''Lazy-load on event. Events can be specified as BufEnter or with a pattern like BufEnter *.lua'';
+        };
+        cmd = mkOption {
+          type = with types; nullOr (listOf str);
+          default = null;
+          description = ''Lazy-load on command'';
+        };
+        ft = mkOption {
+          type = with types; nullOr (listOf str);
+          default = null;
+          description = ''Lazy-load on filetype'';
+        };
+        keys = mkOption {
+          # TODO: update;
+          type = with types; nullOr (listOf attrs);
+          default = null;
+          description = ''Lazy-load on key mapping.'';
+        };
+        module = mkOption {
+          type = types.nullOr types.bool;
+          default = null;
+          description = ''Do not automatically load this Lua module when it's required somewhere'';
+        };
+        priority = mkOption {
+          type = types.nullOr types.number;
+          default = null;
+          description = ''Only useful for start plugins (lazy=false) to force loading certain plugins first. Default priority is 50. It's recommended to set this to a high number for colorschemes.'';
+        };
+        optional = mkOption {
+          type = types.nullOr types.bool;
+          default = null;
+          description = ''When a spec is tagged optional, it will only be included in the final spec, when the same plugin has been specified at least once somewhere else without optional. This is mainly useful for Neovim distros, to allow setting options on plugins that may/may not be part of the user's plugins'';
+        };
+      };
+    }
+  );
+in
+{
+  options.programs.nvim-lazy = {
+    enable = mkOption {
+      type = types.bool;
+      default = false;
+      description = ''If set to true nvim will be installed with the plugins defined in program.nvim-lazy.plugins.'';
+    };
+    luaRcContent = mkOption {
+      type = types.str;
+      default = "";
+    };
+    # TODO: Map options from lazy.nvim
+    lazyConfig = mkOption {
+      type = types.attrs;
+      default = { };
+      description = ''Lazy configuration. See: https://github.com/folke/lazy.nvim?tab=readme-ov-file#%EF%B8%8F-configuration'';
+    };
+    lazyPlugins = mkOption {
+      type =
+        with types;
+        listOf (oneOf [
+          str
+          plugin
+        ]);
+      default = [ ];
+      description = ''List of plugins to be installed with neovim.'';
+    };
+  };
+}
diff --git a/modules/nvim-lazy/homeManager.nix b/modules/nvim-lazy/homeManager.nix
new file mode 100644
index 0000000..3ce7f09
--- /dev/null
+++ b/modules/nvim-lazy/homeManager.nix
@@ -0,0 +1,31 @@
+{
+  lib,
+  config,
+  pkgs,
+  ...
+}:
+let
+  cfg = config.programs.nvim-lazy;
+  # TODO: There must be a better way to implement this...
+  luaUtils = import ../../pkgs/luaUtils.nix { inherit lib pkgs; };
+  lazyUtils = import ../../pkgs/lazyUtils.nix { inherit lib luaUtils pkgs; };
+  wrapNeovimLazy =
+    (import ../../default.nix {
+      inherit
+        lib
+        pkgs
+        luaUtils
+        lazyUtils
+        ;
+    }).packages.wrapNeovimLazy;
+in
+{
+  imports = [ ./default.nix ];
+
+  config = (lib.mkIf cfg.enable) {
+    _module.check = lib.mkDefault false;
+    home.packages = [
+      (wrapNeovimLazy pkgs.neovim-unwrapped { inherit (cfg) luaRcContent lazyConfig lazyPlugins; })
+    ];
+  };
+}
diff --git a/modules/nvim-lazy/nixosModule.nix b/modules/nvim-lazy/nixosModule.nix
new file mode 100644
index 0000000..df2fae2
--- /dev/null
+++ b/modules/nvim-lazy/nixosModule.nix
@@ -0,0 +1,31 @@
+{
+  lib,
+  config,
+  pkgs,
+  ...
+}:
+let
+  cfg = config.programs.nvim-lazy;
+  # TODO: There must be a better way to implement this...
+  luaUtils = import ../../pkgs/luaUtils.nix { inherit lib pkgs; };
+  lazyUtils = import ../../pkgs/lazyUtils.nix { inherit lib luaUtils pkgs; };
+  wrapNeovimLazy =
+    (import ../../default.nix {
+      inherit
+        lib
+        pkgs
+        luaUtils
+        lazyUtils
+        ;
+    }).packages.wrapNeovimLazy;
+in
+{
+  imports = [ ./default.nix ];
+
+  config = (lib.mkIf cfg.enable) {
+    _module.check = lib.mkDefault false;
+    environment.systemPackages = [
+      (wrapNeovimLazy pkgs.neovim-unwrapped { inherit (cfg) luaRcContent lazyConfig lazyPlugins; })
+    ];
+  };
+}