neo-tree: lazy load

docs/manual/hacking/additional-plugins.md

@@ -124,3 +124,62 @@ vim.your-plugin.setupOpts = {
   '';
 }
 ```
+
+## Lazy plugins {#sec-lazy-plugins}
+
+If your plugin can be lazy-loaded, you should use `vim.lazy.plugins` to add your plugin. Lazy
+plugins are managed by `lz.n`.
+
+```nix
+# in modules/.../your-plugin/config.nix
+{lib, config, ...}:
+let
+  cfg = config.vim.your-plugin;
+in {
+  vim.lazy.plugins = [
+    {
+      # instead of vim.startPlugins, use this:
+      package = "your-plugin";
+
+      # if your plugin uses the `require('your-plugin').setup{...}` pattern
+      setupModule = "your-plugin";
+      inherit (cfg) setupOpts;
+
+      # events that trigger this plugin to be loaded
+      events = ["DirChanged"];
+      cmd = ["YourPluginCommand"];
+
+      # keymaps
+      keys = [
+        # we'll cover this in detail in the keymaps section
+        {
+          key = "<leader>d";
+          mode = "n";
+          action = ":YourPluginCommand";
+        }
+      ]
+    }
+  ];
+}
+```
+
+This results in the lua code:
+```lua
+require('lz.n').load({
+  {
+    "name-of-your-plugin",
+    after = function()
+      require('your-plugin').setup({--[[ your setupOpts ]]})
+    end,
+
+    events = {"DirChanged"},
+    cmd = {"YourPluginCommand"},
+    keys = {
+      {"<leader>d", ":YourPluginCommand", mode = {"n"}},
+    },
+  }
+})
+```
+
+A full list of options can be found
+[here](https://notashelf.github.io/nvf/options.html#opt-vim.lazy.plugins

lib/binds.nix

@@ -72,6 +72,13 @@
       inherit mode desc key action;
     };
 
+    mkLznExprBinding = mode: key: action: desc: {
+      inherit mode desc key action;
+      lua = true;
+      silent = true;
+      expr = true;
+    };
+
     mkSetLznBinding = binding: action: {
       inherit action;
       key = binding.value;

modules/plugins/comments/comment-nvim/comment-nvim.nix

@@ -1,6 +1,7 @@
 {lib, ...}: let
   inherit (lib.options) mkEnableOption;
   inherit (lib.nvim.binds) mkMappingOption;
+  inherit (lib.nvim.types) mkPluginSetupOption;
 in {
   options.vim.comments.comment-nvim = {
     enable = mkEnableOption "smart and powerful comment plugin for neovim comment-nvim";
@@ -15,5 +16,12 @@ in {
       toggleSelectedLine = mkMappingOption "Toggle selected comment" "gc";
       toggleSelectedBlock = mkMappingOption "Toggle selected block" "gb";
     };
+
+    setupOpts = mkPluginSetupOption "Comment-nvim" {
+      mappings = {
+        basic = mkEnableOption "basic mappings";
+        extra = mkEnableOption "extra mappings";
+      };
+    };
   };
 }

modules/plugins/comments/comment-nvim/config.nix

@@ -3,9 +3,8 @@
   lib,
   ...
 }: let
-  inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.nvim.binds) mkExprBinding mkBinding;
-  inherit (lib.nvim.dag) entryAnywhere;
+  inherit (lib.modules) mkIf;
+  inherit (lib.nvim.binds) mkLznExprBinding mkLznBinding;
 
   cfg = config.vim.comments.comment-nvim;
   self = import ./comment-nvim.nix {inherit lib;};
@@ -16,35 +15,33 @@ in {
       "comment-nvim"
     ];
 
-    vim.maps.normal = mkMerge [
-      (mkBinding cfg.mappings.toggleOpLeaderLine "<Plug>(comment_toggle_linewise)" mappings.toggleOpLeaderLine.description)
-      (mkBinding cfg.mappings.toggleOpLeaderBlock "<Plug>(comment_toggle_blockwise)" mappings.toggleOpLeaderBlock.description)
+    vim.lazy.plugins = [
+      {
+        package = "comment-nvim";
+        setupModule = "Comment";
+        inherit (cfg) setupOpts;
+        keys = [
+          (mkLznBinding ["n"] cfg.mappings.toggleOpLeaderLine "<Plug>(comment_toggle_linewise)" mappings.toggleOpLeaderLine.description)
+          (mkLznBinding ["n"] cfg.mappings.toggleOpLeaderBlock "<Plug>(comment_toggle_blockwise)" mappings.toggleOpLeaderBlock.description)
 
-      (mkExprBinding cfg.mappings.toggleCurrentLine ''
-          function()
-            return vim.api.nvim_get_vvar('count') == 0 and '<Plug>(comment_toggle_linewise_current)'
-                    or '<Plug>(comment_toggle_linewise_count)'
-          end
-        ''
-        mappings.toggleCurrentLine.description)
-      (mkExprBinding cfg.mappings.toggleCurrentBlock ''
-          function()
-            return vim.api.nvim_get_vvar('count') == 0 and '<Plug>(comment_toggle_blockwise_current)'
-                    or '<Plug>(comment_toggle_blockwise_count)'
-          end
-        ''
-        mappings.toggleCurrentBlock.description)
+          (mkLznExprBinding ["n"] cfg.mappings.toggleCurrentLine ''
+              function()
+                return vim.api.nvim_get_vvar('count') == 0 and '<Plug>(comment_toggle_linewise_current)'
+                        or '<Plug>(comment_toggle_linewise_count)'
+              end
+            ''
+            mappings.toggleCurrentLine.description)
+          (mkLznExprBinding ["n"] cfg.mappings.toggleCurrentBlock ''
+              function()
+                return vim.api.nvim_get_vvar('count') == 0 and '<Plug>(comment_toggle_blockwise_current)'
+                        or '<Plug>(comment_toggle_blockwise_count)'
+              end
+            ''
+            mappings.toggleCurrentBlock.description)
+          (mkLznBinding ["x"] cfg.mappings.toggleSelectedLine "<Plug>(comment_toggle_linewise_visual)" mappings.toggleSelectedLine.description)
+          (mkLznBinding ["x"] cfg.mappings.toggleSelectedBlock "<Plug>(comment_toggle_blockwise_visual)" mappings.toggleSelectedBlock.description)
+        ];
+      }
     ];
-
-    vim.maps.visualOnly = mkMerge [
-      (mkBinding cfg.mappings.toggleSelectedLine "<Plug>(comment_toggle_linewise_visual)" mappings.toggleSelectedLine.description)
-      (mkBinding cfg.mappings.toggleSelectedBlock "<Plug>(comment_toggle_blockwise_visual)" mappings.toggleSelectedBlock.description)
-    ];
-
-    vim.pluginRC.comment-nvim = entryAnywhere ''
-      require('Comment').setup({
-        mappings = { basic = false, extra = false, },
-      })
-    '';
   };
 }

modules/plugins/filetree/neo-tree/config.nix

@@ -4,8 +4,6 @@
   ...
 }: let
   inherit (lib.modules) mkIf;
-  inherit (lib.nvim.dag) entryAnywhere;
-  inherit (lib.nvim.lua) toLuaObject;
 
   cfg = config.vim.filetree.neo-tree;
 in {
@@ -20,11 +18,17 @@ in {
         "neo-tree-nvim"
       ];
 
-      visuals.nvimWebDevicons.enable = true;
+      lazy.plugins = [
+        {
+          package = "neo-tree-nvim";
+          setupModule = "neo-tree";
+          inherit (cfg) setupOpts;
 
-      pluginRC.neo-tree = entryAnywhere ''
-        require("neo-tree").setup(${toLuaObject cfg.setupOpts})
-      '';
+          cmd = ["Neotree"];
+        }
+      ];
+
+      visuals.nvimWebDevicons.enable = true;
     };
   };
 }

modules/plugins/utility/surround/config.nix

@@ -8,25 +8,50 @@
   inherit (lib.nvim.lua) toLuaObject;
 
   cfg = config.vim.utility.surround;
+  vendoredKeybinds = {
+    insert = "<C-g>z";
+    insert_line = "<C-g>Z";
+    normal = "gz";
+    normal_cur = "gZ";
+    normal_line = "gzz";
+    normal_cur_line = "gZZ";
+    visual = "gz";
+    visual_line = "gZ";
+    delete = "gzd";
+    change = "gzr";
+    change_line = "gZR";
+  };
+  mkLznKey = mode: key: {
+    inherit key mode;
+  };
 in {
   config = mkIf cfg.enable {
     vim = {
       startPlugins = ["nvim-surround"];
       pluginRC.surround = entryAnywhere "require('nvim-surround').setup(${toLuaObject cfg.setupOpts})";
 
-      utility.surround.setupOpts.keymaps = mkIf cfg.useVendoredKeybindings {
-        insert = "<C-g>z";
-        insert_line = "<C-g>Z";
-        normal = "gz";
-        normal_cur = "gZ";
-        normal_line = "gzz";
-        normal_cur_line = "gZZ";
-        visual = "gz";
-        visual_line = "gZ";
-        delete = "gzd";
-        change = "gzr";
-        change_line = "gZR";
-      };
+      lazy.plugins = [
+        {
+          package = "nvim-surround";
+          setupModule = "nvim-surround";
+          inherit (cfg) setupOpts;
+
+          keys =
+            map (mkLznKey ["i"]) (with vendoredKeybinds; [insert insert_line])
+            ++ map (mkLznKey ["x"]) (with vendoredKeybinds; [visual visual_line])
+            ++ map (mkLznKey ["n"]) (with vendoredKeybinds; [
+              normal
+              normal_cur
+              normal_line
+              normal_cur_line
+              delete
+              change
+              change_line
+            ]);
+        }
+      ];
+
+      utility.surround.setupOpts.keymaps = mkIf cfg.useVendoredKeybindings vendoredKeybinds;
     };
   };
 }

modules/wrapper/lazy/config.nix

@@ -3,32 +3,23 @@
   config,
   ...
 }: let
-  inherit (builtins) toJSON typeOf head length tryEval filter;
-  inherit (lib.modules) mkIf;
+  inherit (builtins) toJSON typeOf head length tryEval filter concatLists concatStringsSep;
+  inherit (lib.modules) mkIf mkMerge;
   inherit (lib.generators) mkLuaInline;
   inherit (lib.strings) optionalString;
   inherit (lib.nvim.lua) toLuaObject;
-  inherit (lib.nvim.dag) entryBefore;
+  inherit (lib.nvim.dag) entryBefore entryAfter;
   cfg = config.vim.lazy;
 
-  toLuaLznKeySpec = {
-    desc,
-    noremap,
-    expr,
-    nowait,
-    ft,
-    key,
-    action,
-    lua,
-    mode,
-  }: {
-    "@1" = key;
-    "@2" =
-      if lua
-      then mkLuaInline action
-      else action;
-    inherit desc noremap expr nowait ft mode;
-  };
+  toLuaLznKeySpec = keySpec:
+    (removeAttrs keySpec ["key" "lua" "action"])
+    // {
+      "@1" = keySpec.key;
+      "@2" =
+        if keySpec.lua
+        then mkLuaInline keySpec.action
+        else keySpec.action;
+    };
 
   toLuaLznSpec = spec: let
     name =
@@ -72,14 +63,44 @@
         else spec.keys;
     };
   lznSpecs = map toLuaLznSpec cfg.plugins;
+
+  specToNotLazyConfig = spec: ''
+    do
+      ${optionalString (spec.before != null) spec.before}
+      ${optionalString (spec.setupModule != null)
+      "require(${toJSON spec.setupModule}).setup(${toLuaObject spec.setupOpts})"}
+      ${optionalString (spec.after != null) spec.after}
+    end
+  '';
+
+  specToKeymaps = spec:
+    if typeOf spec.keys == "list"
+    then map (x: removeAttrs x ["ft"]) (filter (lznKey: lznKey.action != null && lznKey.ft == null) spec.keys)
+    else if spec.keys == null || typeOf spec.keys == "string"
+    then []
+    else [spec.keys];
+
+  notLazyConfig = concatStringsSep "\n" (map specToNotLazyConfig cfg.plugins);
 in {
-  config.vim = mkIf cfg.enable {
-    startPlugins = ["lz-n" "lzn-auto-require"];
+  config.vim = mkMerge [
+    (mkIf cfg.enable {
+      startPlugins = ["lz-n" "lzn-auto-require"];
 
-    optPlugins = map (plugin: plugin.package) cfg.plugins;
+      optPlugins = map (plugin: plugin.package) cfg.plugins;
 
-    luaConfigRC.lzn-load = entryBefore ["pluginConfigs"] ''
-      require('lz.n').load(${toLuaObject lznSpecs})
-    '';
-  };
+      luaConfigRC.lzn-load = entryBefore ["pluginConfigs"] ''
+        require('lz.n').load(${toLuaObject lznSpecs})
+      '';
+    })
+    (
+      mkIf (!cfg.enable) {
+        startPlugins = map (plugin: plugin.package) cfg.plugins;
+        luaConfigPre =
+          concatStringsSep "\n"
+          (filter (x: x != null) (map (spec: spec.beforeAll) cfg.plugins));
+        luaConfigRC.unlazy = entryAfter ["pluginConfigs"] notLazyConfig;
+        keymaps = concatLists (map specToKeymaps cfg.plugins);
+      }
+    )
+  ];
 }

modules/wrapper/lazy/lazy.nix

@@ -39,22 +39,17 @@
         default = ["n" "x" "s" "o"];
       };
 
-      noremap = mkBool true "Whether to use the 'noremap' variant of the command, ignoring any custom mappings on the defined action. It is highly advised to keep this on, which is the default.";
-      expr = mkBool false "Means that the action is actually an expression. Equivalent to adding <expr> to a map.";
+      silent = mkBool true "Whether this mapping should be silent. Equivalent to adding <silent> to a map.";
       nowait = mkBool false "Whether to wait for extra input on ambiguous mappings. Equivalent to adding <nowait> to a map.";
+      script = mkBool false "Equivalent to adding <script> to a map.";
+      expr = mkBool false "Means that the action is actually an expression. Equivalent to adding <expr> to a map.";
+      unique = mkBool false "Whether to fail if the map is already defined. Equivalent to adding <unique> to a map.";
+      noremap = mkBool true "Whether to use the 'noremap' variant of the command, ignoring any custom mappings on the defined action. It is highly advised to keep this on, which is the default.";
     };
   };
 
   lznPluginType = submodule {
     options = {
-      ## Should probably infer from the actual plugin somehow
-      ## In general this is the name passed to packadd, so the dir name of the plugin
-      # name = mkOption {
-      #   type=  str;
-      # }
-
-      # Non-lz.n options
-
       package = mkOption {
         type = pluginType;
         description = "Plugin package";
@@ -94,7 +89,11 @@
 
       after = mkOption {
         type = nullOr str;
-        description = "Lua code to run after plugin is loaded. This will be wrapped in a function.";
+        description = ''
+          Lua code to run after plugin is loaded. This will be wrapped in a function.
+
+          If {opt}`vim.plugins.*.setupModule` is provided, the setup will be ran before `after`.
+        '';
         default = null;
       };
 
@@ -195,7 +194,10 @@ in {
         [
           {
             package = "toggleterm-nvim";
-            after = lib.generators.mkLuaInline "function() require('toggleterm').setup{} end";
+            setupModule = "toggleterm";
+            setupOpts = cfg.setupOpts;
+
+            after = "require('toggleterm').do_something()";
             cmd = ["ToggleTerm"];
           }
         ]