Problems with adding fennel-ls

[fabianpage]

Hi

I'm trying to add fennel-ls to the starter nixcats template. Now i always get the error:

E5108: Error executing lua ...ck-dir/pack/myNeovimPackages/start/lze/lua/lze/h/cmd.lua:19:
Invalid command name: 'fennel-ls'

In flake.nix i added:

      # lspsAndRuntimeDeps:
      # this section is for dependencies that should be available
      # at RUN TIME for plugins. Will be available to PATH within neovim terminal
      # this includes LSPs
      lspsAndRuntimeDeps = {
        # some categories of stuff.
        general = with pkgs; [
          universal-ctags
          ripgrep
          fd
        ];
        fennel = with pkgs; [
          fennel-ls
        ];
....
        categories = {
          fennel = true;
          markdown = true;
          general = true;
          lint = true;

and in lua/myLuaConf/LSPs/init.lua:

{
"fennel-ls",
-- enabled = true;
cmd = { "fennel-ls" },
for_cat = "fennel",
-- if you don't provide the filetypes it asks lspconfig for them
lsp = {
filetypes = { "fennel" },
},
},

What do i miss? If i leave the cmd empty i get a: Failed to run 'load' hook for fennel-ls: Vim:E919: Di
rectory not found in 'packpath': "pack/*/opt/fennel-ls".

[BirdeeHub]

Failed to run 'load' hook for fennel-ls: Vim:E919: Directory not found in 'packpath': "pack/*/opt/fennel-ls".

This is actually not making a ton of sense to me yet with the info I have right now.

The spec you showed (which, in isolation looks correct, it should load the lsp, the configuration for the lsp for fennel is handled in a separate file or by nfnl or aniseed)

  {
    "fennel_ls",
    for_cat = "fennel",
    lsp = {
      filetypes = { "fennel" },
    },
  },

The lsp field comes from the lsp handler from lzextras

It is added to the example configuration here:

nixCats-nvim/templates/example/lua/myLuaConf/init.lua

Line 12 in b262211

require('lze').register_handlers(require('lzextras').lsp)

The thing which is confusing to me, is that the lsp handler disables the default load hook for specs with the lsp field. So that error shouldn't be possible given the spec you showed if the handler is registered prior to that call to lze.load?

What the lsp handler does is allows you to easily use lze to lazily setup your lsps on that specific filetype (or other trigger). Calling vim.lsp.enable on a bunch of lsps at startup can be heavy because each call has to search the rtp for lsp/*.lua files, so this allows you to easily delay that until they are needed, without needing to put each one in their own ftplugin file and/or set up your own autocommand system for them

You define a spec with lsp field as a function, and the lsp function fields get ran for all specs where lsp field is a table.

require('lze').register_handlers(require('lzextras').lsp)
require('lze').load {
  {
    "nvim-lspconfig",
    lsp = function(plugin) -- <- this gets ran for all specs with an lsp field of a non-function type
      vim.lsp.config(plugin.name, plugin.lsp or {})
      vim.lsp.enable(plugin.name)
    end,
    before = function(_) -- <- the rest of the spec is only ran when loading nvim-lspconfig spec as normal
      vim.lsp.config('*', {
        on_attach = require('LSPs.on_attach'),
      })
    end,
  },
  {
    "bashls",
    lsp = { -- <-- this will cause the lsp handler to modify the spec, removing the default load field and instead running the lsp function fields.
      filetypes = { "bash", "sh" },
    },
  },
  {
    "fennel_ls",
    lsp = {
      filetypes = { "fennel" },
    },
  },
}

This should work as long as it is added to your path, which, if you put it in lspsAndRuntimeDeps and then made sure the category was enabled, then it should be.

Also if you wanted to see how to set up lsps without the lsp handler

https://github.com/BirdeeHub/nixCats-nvim/blob/main/templates/simple/plugin/lsp.lua

There's an example of that also

As long as the lsp is in the path for that instance, either via nixCats or some other way, both of the ways should work

[fabianpage]

Thanks for your help!

fennel-ls works when im loading it with load. I still don't understand why...

require('lze').register_handlers(require('lzextras').lsp)
require('lze').load {
  {
    "fennel_ls",
    lsp = {
      filetypes = { "fennel" },
    },
  },
}

[BirdeeHub]

In this spec, you register a function

  {
    "nvim-lspconfig",
    lsp = function(plugin) -- <- this gets ran for all specs with an lsp field of a non-function type
      vim.lsp.config(plugin.name, plugin.lsp or {})
      vim.lsp.enable(plugin.name)
    end,
    -- ...
  },

The lsp handler holds onto it.

When you pass a spec with the lsp field in it

  {
    "fennel_ls",
    lsp = {
      filetypes = { "fennel" },
    },
  },

It will set up triggers on the mentioned filetypes.

It will also wraps the fields of the spec such that it runs all the functions you registered on the spec when the spec is triggered.

The key part is this

      vim.lsp.config(plugin.name, plugin.lsp or {})
      vim.lsp.enable(plugin.name)

The reason the handler exists is so that you only run this when you need it.

You do not need to do this. When you call vim.lsp.enable, it will only activate the server on the correct filetype.

However, it will search the runtime path for all lsp configurations for that server when it is called. This adds startup time for stuff you arent currently using. That is what the lsp handler is for. But if you only have like 4-5 of them, it is not necessary.

I would encourage checking out this example

https://github.com/BirdeeHub/nixCats-nvim/blob/main/templates/simple/plugin/lsp.lua

And make sure you understand what is going on, and deciding if you want to use lze to load your lsps, or if you want to use the default way.

I have the handler because I like it.

Another good way to go about it for example would be the following

In the example, I loop over the servers table and call vim.lsp.config and vim.lsp.enable

nixCats-nvim/templates/simple/plugin/lsp.lua

Lines 110 to 113 in b262211

	for server_name, cfg in pairs(servers) do
	vim.lsp.config(server_name, cfg)
	vim.lsp.enable(server_name)
	end

but, instead of that, you could put the call to vim.lsp.enable in an ftplugin file and gain the same sort of behavior you gain from the handler. You could even leave the config where it is and just put the enable call in the ftplugin file, it searches the rtp when you call vim.lsp.enable not vim.lsp.config

lze itself is not necessary to use nixCats but it is a good solution for lazy loading that works much better than lazy.nvim with it due to lazy.nvim taking over the rtp. But lazy loading in and of itself is technically not necessary either.