Getting error "cannot access configuration"

[danjac]

Getting this error on loading a Django template (having installed django-language-lsp via Mason and pip)

notify.warn [lspconfig] Cannot access configuration for djlsp. Ensure this server is listed in server_configurations.md or added as a custom server.

With this basic config:

require'lspconfig'.djlsp.setup{
  cmd = { "django-template-lsp" },
  filetypes={"html", "htmldjango"}
}

[rubenhesselink]

This is because there is a problem in our README.md

Instead of using djlspyou be using django-template-lsp here:
require'lspconfig'.django-template-lsp{}

I hope this helps! I will also update the README.md

[danjac]

Is this valid Lua (from the README)?

require'lspconfig'.django-template-lsp.setup{
    cmd = { "django-template-lsp" },
}

Getting Invalid configuration: ...'=' expected near '-'"

[rubenhesselink]

You are right this is invalid lua. It has been added to Mason but I am not sure how to use it with Mason.

How I am using it in neovim right now is without mason:

lspconfig['djlsp'].setup {
  cmd = {
    '<path_to_djlsp_executable>',
  },
}

[danjac]

Right, I also tried

require'lspconfig'['django-template-lsp'].setup{
    cmd = { "django-template-lsp" },
}

And got the original error:

[lspconfig] Cannot access configuration for django-template-lsp. Ensure this server is listed in `server_configurations.md` or added as a custom 
server.  

Even though django-template-lsp is installed. All other LSP servers are working fine.

[rubenhesselink]

I think the problem lies with how django-template-lsp has been added to the mason-registry I will look into this. Please try to configure it without mason as described in this comment for now: #67 (comment)

[danjac]

Yes, that's what I did try.

[rubenhesselink]

Weird... djlsp is present in the server_configurations.md of nvim-lspconfig:
https://github.com/neovim/nvim-lspconfig/blob/master/doc/configs.md#djlsp

I will paste my entire lspconfig in here for reference (I am using kickstart.nvim):

-- Main LSP Configuration
'neovim/nvim-lspconfig',
dependencies = {
  -- Automatically install LSPs and related tools to stdpath for Neovim
  { 'williamboman/mason.nvim', config = true }, -- NOTE: Must be loaded before dependants
  'williamboman/mason-lspconfig.nvim',
  'WhoIsSethDaniel/mason-tool-installer.nvim',

  -- Useful status updates for LSP.
  -- NOTE: `opts = {}` is the same as calling `require('fidget').setup({})`
  { 'j-hui/fidget.nvim', opts = {} },
  { 'saghen/blink.cmp' },
},
config = function()
  -- Brief aside: **What is LSP?**
  --
  -- LSP is an initialism you've probably heard, but might not understand what it is.
  --
  -- LSP stands for Language Server Protocol. It's a protocol that helps editors
  -- and language tooling communicate in a standardized fashion.
  --
  -- In general, you have a "server" which is some tool built to understand a particular
  -- language (such as `gopls`, `lua_ls`, `rust_analyzer`, etc.). These Language Servers
  -- (sometimes called LSP servers, but that's kind of like ATM Machine) are standalone
  -- processes that communicate with some "client" - in this case, Neovim!
  --
  -- LSP provides Neovim with features like:
  --  - Go to definition
  --  - Find references
  --  - Autocompletion
  --  - Symbol Search
  --  - and more!
  --
  -- Thus, Language Servers are external tools that must be installed separately from
  -- Neovim. This is where `mason` and related plugins come into play.
  --
  -- If you're wondering about lsp vs treesitter, you can check out the wonderfully
  -- and elegantly composed help section, `:help lsp-vs-treesitter`

  --  This function gets run when an LSP attaches to a particular buffer.
  --    That is to say, every time a new file is opened that is associated with
  --    an lsp (for example, opening `main.rs` is associated with `rust_analyzer`) this
  --    function will be executed to configure the current buffer
  vim.api.nvim_create_autocmd('LspAttach', {
    group = vim.api.nvim_create_augroup('kickstart-lsp-attach', { clear = true }),
    callback = function(event)
      -- NOTE: Remember that Lua is a real programming language, and as such it is possible
      -- to define small helper and utility functions so you don't have to repeat yourself.
      --
      -- In this case, we create a function that lets us more easily define mappings specific
      -- for LSP related items. It sets the mode, buffer and description for us each time.
      local map = function(keys, func, desc, mode)
        mode = mode or 'n'
        vim.keymap.set(mode, keys, func, { buffer = event.buf, desc = 'LSP: ' .. desc })
      end

      -- Jump to the definition of the word under your cursor.
      --  This is where a variable was first declared, or where a function is defined, etc.
      --  To jump back, press <C-t>.
      map('gd', require('telescope.builtin').lsp_definitions, '[G]oto [D]efinition')

      -- Find references for the word under your cursor.
      map('gr', require('telescope.builtin').lsp_references, '[G]oto [R]eferences')

      -- Jump to the implementation of the word under your cursor.
      --  Useful when your language has ways of declaring types without an actual implementation.
      map('gI', require('telescope.builtin').lsp_implementations, '[G]oto [I]mplementation')

      -- Jump to the type of the word under your cursor.
      --  Useful when you're not sure what type a variable is and you want to see
      --  the definition of its *type*, not where it was *defined*.
      map('<leader>D', require('telescope.builtin').lsp_type_definitions, 'Type [D]efinition')

      -- Fuzzy find all the symbols in your current document.
      --  Symbols are things like variables, functions, types, etc.
      map('<leader>ds', require('telescope.builtin').lsp_document_symbols, '[D]ocument [S]ymbols')

      -- Fuzzy find all the symbols in your current workspace.
      --  Similar to document symbols, except searches over your entire project.
      map('<leader>ws', require('telescope.builtin').lsp_dynamic_workspace_symbols, '[W]orkspace [S]ymbols')

      -- Rename the variable under your cursor.
      --  Most Language Servers support renaming across files, etc.
      map('<leader>rn', vim.lsp.buf.rename, '[R]e[n]ame')

      -- Execute a code action, usually your cursor needs to be on top of an error
      -- or a suggestion from your LSP for this to activate.
      map('<leader>ca', vim.lsp.buf.code_action, '[C]ode [A]ction', { 'n', 'x' })

      -- WARN: This is not Goto Definition, this is Goto Declaration.
      --  For example, in C this would take you to the header.
      map('gD', vim.lsp.buf.declaration, '[G]oto [D]eclaration')

      -- The following two autocommands are used to highlight references of the
      -- word under your cursor when your cursor rests there for a little while.
      --    See `:help CursorHold` for information about when this is executed
      --
      -- When you move your cursor, the highlights will be cleared (the second autocommand).
      local client = vim.lsp.get_client_by_id(event.data.client_id)
      if client and client.supports_method(vim.lsp.protocol.Methods.textDocument_documentHighlight) then
        local highlight_augroup = vim.api.nvim_create_augroup('kickstart-lsp-highlight', { clear = false })
        vim.api.nvim_create_autocmd({ 'CursorHold', 'CursorHoldI' }, {
          buffer = event.buf,
          group = highlight_augroup,
          callback = vim.lsp.buf.document_highlight,
        })

        vim.api.nvim_create_autocmd({ 'CursorMoved', 'CursorMovedI' }, {
          buffer = event.buf,
          group = highlight_augroup,
          callback = vim.lsp.buf.clear_references,
        })

        vim.api.nvim_create_autocmd('LspDetach', {
          group = vim.api.nvim_create_augroup('kickstart-lsp-detach', { clear = true }),
          callback = function(event2)
            vim.lsp.buf.clear_references()
            vim.api.nvim_clear_autocmds { group = 'kickstart-lsp-highlight', buffer = event2.buf }
          end,
        })
      end

      -- The following code creates a keymap to toggle inlay hints in your
      -- code, if the language server you are using supports them
      --
      -- This may be unwanted, since they displace some of your code
      if client and client.supports_method(vim.lsp.protocol.Methods.textDocument_inlayHint) then
        map('<leader>th', function()
          vim.lsp.inlay_hint.enable(not vim.lsp.inlay_hint.is_enabled { bufnr = event.buf })
        end, '[T]oggle Inlay [H]ints')
      end
    end,
  })

  -- Change diagnostic symbols in the sign column (gutter)
  -- if vim.g.have_nerd_font then
  --   local signs = { ERROR = '', WARN = '', INFO = '', HINT = '' }
  --   local diagnostic_signs = {}
  --   for type, icon in pairs(signs) do
  --     diagnostic_signs[vim.diagnostic.severity[type]] = icon
  --   end
  --   vim.diagnostic.config { signs = { text = diagnostic_signs } }
  -- end

  local on_attach = function(client, bufnr)
    if client.name == 'ruff_lsp' then
      -- Disable hover in favor of Pyright
      client.server_capabilities.hoverProvider = false
    end
  end

  -- Enable the following language servers
  --  Feel free to add/remove any LSPs that you want here. They will automatically be installed.
  --
  --  Add any additional override configuration in the following tables. Available keys are:
  --  - cmd (table): Override the default command used to start the server
  --  - filetypes (table): Override the default list of associated filetypes for the server
  --  - capabilities (table): Override fields in capabilities. Can be used to disable certain LSP features.
  --  - settings (table): Override the default settings passed when initializing the server.
  --        For example, to see the options for `lua_ls`, you could go to: https://luals.github.io/wiki/settings/
  local servers = {
    -- clangd = {},
    -- gopls = {},
    -- pyright = {},
    -- rust_analyzer = {},
    -- ... etc. See `:help lspconfig-all` for a list of all the pre-configured LSPs
    --
    -- Some languages (like typescript) have entire language plugins that can be useful:
    --    https://github.com/pmizio/typescript-tools.nvim
    --
    -- But for many setups, the LSP (`ts_ls`) will work just fine
    ts_ls = {},
    djlsp = {},
    basedpyright = {
      settings = {
        basedpyright = {
          analysis = {
            autoSearchPaths = true,
            typeCheckingMode = 'basic',
            ignore = { '*' },
            disableOrganizeImports = true,
          },
        },
      },
      before_init = function(_, config)
        config.settings.basedpyright.analysis.stubPath = vim.fs.joinpath(vim.fn.stdpath 'data', 'lazy', 'python-type-stubs')
      end,
    },
    jsonls = {},
    ruff_lsp = {
      init_options = { settings = { args = {} } },
      on_attach = on_attach,
    },
    lua_ls = {
      -- cmd = {...},
      -- filetypes = { ...},
      -- capabilities = {},
      settings = {
        Lua = {
          completion = {
            callSnippet = 'Replace',
          },
          -- You can toggle below to ignore Lua_LS's noisy `missing-fields` warnings
          -- diagnostics = { disable = { 'missing-fields' } },
        },
      },
    },
  }

  -- Ensure the servers and tools above are installed
  --  To check the current status of installed tools and/or manually install
  --  other tools, you can run
  --    :Mason
  --
  --  You can press `g?` for help in this menu.
  require('mason').setup()

  -- You can add other tools here that you want Mason to install
  -- for you, so that they are available from within Neovim.
  local ensure_installed = vim.tbl_keys(servers or {})
  vim.list_extend(ensure_installed, {
    'stylua', -- Used to format Lua code
  })
  require('mason-tool-installer').setup { ensure_installed = ensure_installed }
  local lspconfig = require 'lspconfig'
  require('mason-lspconfig').setup {
    handlers = {
      function(server_name)
        local server = servers[server_name] or {}
        -- This handles overriding only values explicitly passed
        -- by the server configuration above. Useful when disabling
        -- certain features of an LSP (for example, turning off formatting for ts_ls)
        server.capabilities = require('blink.cmp').get_lsp_capabilities(server.capabilities)
        lspconfig[server_name].setup(server)
      end,
    },
  }
  lspconfig['djlsp'].setup {}
end,

I added djlsp outside of the mason loop.

[danjac]

So it's not clear cut...

1. using lspconfig['django-template-lsp'].setup : I get the "Cannot access configuration..." error immediately on setup.

2. using lspconfig.djlsp : I don't get the error immediately, until I open a valid file (i.e. a Django template).

Either way, I cannot get this server to work.

[rubenhesselink]

I am looking into this. Could you send your current lspconfig? That way I might be able to help you with a temporary solution until I have fixed the problems with mason.

[danjac]

Sure, thanks!

local lspconfig = require'lspconfig'

lspconfig.emmet_ls.setup{
  filetypes={"html", "tmpl", "htmldjango", "jinja", "jinja2"}
}

lspconfig.html.setup{
  filetypes={"html", "tmpl", "htmldjango", "jinja", "jinja2"}
}

-- other LSP setups....

-- also trying djlsp
lspconfig['django-template-lsp'].setup{
    cmd = { "django-template-lsp" },
    filetypes={"html", "htmldjango"},
}

Further info: I'm using LunarVim.

[rubenhesselink]

When typing the djlsp command in your terminal is it valid? I recommend installing it using pipx to always make it accessible in your terminal.

If you installed it through pipx and it is always accessible, the following config should be enough:

lspconfig['djlsp'].setup {
  cmd = {
    'djlsp',
  },
}

[danjac]

I have djlsp installed, yes. The README is confusing as you also refer to django-template-lsp.

[danjac]

In any case, with the setup above it still fails.

[rubenhesselink]

In that case I am out of ideas what could be going wrong here. I will try to get it working with mason again and will let you know as soon as that is working correctly.

[danjac]

I wonder if this is an issue other LunarVim users have run into.

[rubenhesselink]

I am wondering that as well. I will try installing djlsp using LunarVim after work tonight to see if it is LunarVim specific.

[rubenhesselink]

I have tried installing and configuring djlsp on multiple neovim configs:

• LunarVim
• LazyVim (My current config)
• Kickstart
• NvChad

And I have ran into any issues. I have used the same djlsp config for all the different neovim configs:

  {
    "neovim/nvim-lspconfig",
    opts = {
      servers = {
        djlsp = {},
      },
    },
  }

And I made sure Mason was up to date and I had django-template-lsp installed:

I sadly cannot think of anything that might go wrong on side. I hope this last example helps you solve your issue!

[danjac]

Yep, was able to install django-template-lsp in Mason, but still getting the same errors. For whatever reason, this plugin does not work, although all the other ones do.

In any case, thanks for looking into this!

[Igorek1986]

@danjac,
try adding this

  return
  	{
  		"williamboman/mason-lspconfig.nvim",
  		event = { "BufReadPre", "BufNewFile" },
  		config = function()
  			local mason_lspconfig = require("mason-lspconfig")
  			mason_lspconfig.setup_handlers({
  				function(server_name)
  					require("lspconfig")[server_name].setup({
  						capabilities = require("cmp_nvim_lsp").default_capabilities(),
  						on_attach = function(client, bufnr)
  							require("lsp_signature").on_attach({
  								bind = true,
  								floating_window = true,
  								hint_enable = true, 
  							}, bufnr)
  						end,
  					})
  				end,
  				["lua_ls"] = function()
  					local lspconfig = require("lspconfig")
  					lspconfig.lua_ls.setup({
  						settings = {
  							Lua = {
  								diagnostics = {
  									globals = { "vim" },
  								},
  							},
  						},
  					})
  				end,
  			})
  			-- Add djlsp
  			require("lspconfig").djlsp.setup({
  				cmd = { "djlsp" },
  				filetypes = { "html", "htmldjango" },
  				root_dir = require("lspconfig.util").root_pattern("manage.py", ".git"),
  			})
  			require("mason-lspconfig").setup({
  				ensure_installed = { "lua_ls", "pyright", "emmet_ls", "cssls" },
  				automatic_installation = true,
  			})
  		end,
  	},