eleith
/
dot
1
0
Fork 0
Code Pull Requests Releases Activity

[nvim] replace null-ls with efm-langserver

This commit is contained in:
eleith 2023-08-06 15:44:46 +00:00 committed by eleith
parent 37b60e7fa8
commit e6d1535272
4 changed files with 188 additions and 516 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
config/fish/functions/fish_title.fish
View File

@ -12,14 +12,14 @@ function fish_title --argument-names last_cmd
if [ fish != $_ ] if [ fish != $_ ]
switch $_ switch $_
case vi vim nvim case vi vim nvim
set last_path (string split ' ' $last_cmd)[2..] set last_path (string split ' ' $last_cmd)[2..]
if test -n "$last_path" if test -n "$last_path"
and test -f "$last_path" and test -f "$last_path"
echo "$prefix$_ $(path basename $last_path)" echo "$prefix$_ $(path basename $last_path)"
else else
echo "$prefix$last_cmd" echo "$prefix$last_cmd"
end end
case '*' case '*'
echo "$prefix$last_cmd" echo "$prefix$last_cmd"
end end

4
config/nvim/lua/plugins/cmp.lua
View File

@ -41,7 +41,7 @@ return {
["<C-e>"] = cmp.mapping.abort(), ["<C-e>"] = cmp.mapping.abort(),
["<CR>"] = cmp.mapping.confirm({ select = true }), ["<CR>"] = cmp.mapping.confirm({ select = true }),
}), }),
sources = { sources = cmp.config.sources({
{ name = "nvim_lsp" }, { name = "nvim_lsp" },
{ name = "nvim_diagnostic" }, { name = "nvim_diagnostic" },
{ name = "buffer" }, { name = "buffer" },
@ -50,7 +50,7 @@ return {
{ name = "nvim_lua" }, { name = "nvim_lua" },
{ name = "nvim_lsp_signature_help" }, { name = "nvim_lsp_signature_help" },
{ name = "emoji" }, { name = "emoji" },
}, }),
formatting = { formatting = {
format = lspkind.cmp_format({ format = lspkind.cmp_format({
mode = "symbol_text", mode = "symbol_text",

289
config/nvim/lua/plugins/lsp.lua
View File

@ -1,126 +1,195 @@
return { return {
"neovim/nvim-lspconfig", "neovim/nvim-lspconfig",
dependencies = { dependencies = {
"hrsh7th/nvim-cmp", "hrsh7th/nvim-cmp",
}, "creativenull/efmls-configs-nvim",
config = function() },
local lspconfig = require("lspconfig") config = function()
local capabilities = vim.lsp.protocol.make_client_capabilities() local lspconfig = require("lspconfig")
local lspwindow = require("lspconfig.ui.windows") local capabilities = vim.lsp.protocol.make_client_capabilities()
local lspwindow = require("lspconfig.ui.windows")
capabilities = require("cmp_nvim_lsp").default_capabilities(capabilities) capabilities = require("cmp_nvim_lsp").default_capabilities(capabilities)
capabilities.textDocument.completion.completionItem.snippetSupport = true capabilities.textDocument.completion.completionItem.snippetSupport = true
-- disable showing diagnostics in virtual text -- disable showing diagnostics in virtual text
vim.diagnostic.config({ virtual_text = false }) vim.diagnostic.config({ virtual_text = false })
-- close quickfix menu after selecting choice -- close quickfix menu after selecting choice
vim.api.nvim_create_autocmd("FileType", { vim.api.nvim_create_autocmd("FileType", {
pattern = { "qf" }, pattern = { "qf" },
command = [[nnoremap <buffer> <CR> <CR>:cclose<CR>]], command = [[nnoremap <buffer> <CR> <CR>:cclose<CR>]],
}) })
-- override all window borders -- override all window borders
local orig_util_open_floating_preview = vim.lsp.util.open_floating_preview local orig_util_open_floating_preview = vim.lsp.util.open_floating_preview
local border = "rounded" local border = "rounded"
function vim.lsp.util.open_floating_preview(contents, syntax, opts, ...) function vim.lsp.util.open_floating_preview(contents, syntax, opts, ...)
opts = opts or {} opts = opts or {}
opts.border = border opts.border = border
return orig_util_open_floating_preview(contents, syntax, opts, ...) return orig_util_open_floating_preview(contents, syntax, opts, ...)
end end
-- lspinfo needs a separate override -- lspinfo needs a separate override
lspwindow.default_options = { lspwindow.default_options = {
border = border, border = border,
} }
-- LSP settings (for overriding per client) -- LSP settings (for overriding per client)
local handlers = {} local handlers = {}
local opts = { noremap = true, silent = true }
local on_attach = function(_, bufnr) local on_attach = function(_, bufnr)
-- Mappings. -- Mappings.
local bufopts = { noremap = true, silent = true, buffer = bufnr } local bufopts = { noremap = true, silent = true, buffer = bufnr }
-- See `:help vim.lsp.*` for more methods -- See `:help vim.lsp.*` for more methods
vim.keymap.set("n", "<leader>bf", function() vim.keymap.set("n", "<leader>bf", function()
vim.lsp.buf.format({ timeout = 2000, async = true }) vim.lsp.buf.format({ timeout = 2000, async = true })
end, bufopts) end, bufopts)
end end
local function organize_imports() local function organize_imports()
local params = { local params = {
command = "_typescript.organizeImports", command = "_typescript.organizeImports",
arguments = { vim.api.nvim_buf_get_name(0) }, arguments = { vim.api.nvim_buf_get_name(0) },
title = "", title = "",
} }
vim.lsp.buf.execute_command(params) vim.lsp.buf.execute_command(params)
end end
local servers = { local servers = {
{ {
"tsserver", "tsserver",
commands = { commands = {
LspOrganizeImports = { LspOrganizeImports = {
organize_imports, organize_imports,
description = "Organize Imports", description = "Organize Imports",
}, },
}, },
}, },
{ "tailwindcss" }, { "tailwindcss" },
{ "flow" }, { "graphql" },
{ "graphql" }, { "html" },
{ "html" }, { "intelephense" },
{ "intelephense" }, { "jsonls" },
{ "jsonls" }, { "pyright" },
{ "pyright" }, { "vimls" },
{ "vimls" }, { "bashls" },
{ "prismals" }, { "dockerls" },
{ "solargraph" }, { "solargraph" },
{ "bashls" }, -- { "rubocop" }, -- needs rubocop >= 1.54
{ "dockerls" }, -- { "ruby_ls" }, -- wait for nvim 0.10
{ "gopls", { { "gopls", {
root_dir = function() root_dir = function()
return vim.loop.cwd() return vim.loop.cwd()
end, end,
} }, } },
{ { "eslint" },
"yamlls", {
{ "yamlls",
settings = { settings = {
yaml = { yaml = {
schemas = { schemas = {
["https://json.schemastore.org/github-workflow.json"] = "/.github/workflows/*", ["https://json.schemastore.org/github-workflow.json"] = "/.github/workflows/*",
["https://raw.githubusercontent.com/woodpecker-ci/woodpecker/master/pipeline/schema/schema.json"] = "/.woodpecker", ["https://raw.githubusercontent.com/woodpecker-ci/woodpecker/master/pipeline/schema/schema.json"] = "/.woodpecker",
}, },
}, },
}, },
}, },
}, { "stylelint_lsp" },
{ "cssls" }, { "cssls" },
{ "lua_ls" }, {
} "efm",
filetypes = {
"lua",
"fish",
"ruby",
"javascript",
"typescript",
"javascriptreact",
"typescriptreact",
"javascript.tsx",
"typescript.tsx"
},
init_options = {
documentFormatting = true,
hover = true,
documentSymbol = true,
codeAction = true,
completion = true,
},
settings = {
rootMarkers = { ".git/" },
languages = {
lua = {
require("efmls-configs.linters.luacheck"),
},
fish = {
require("efmls-configs.linters.fish"),
require("efmls-configs.formatters.fish_indent"),
},
ruby = {
require("efmls-configs.linters.rubocop"),
},
javascript = {
require("efmls-configs.formatters.prettier"),
},
typescript = {
require("efmls-configs.formatters.prettier"),
},
javascriptreact = {
require("efmls-configs.formatters.prettier"),
},
typescriptreact = {
require("efmls-configs.formatters.prettier"),
},
["javascript.tsx"] = {
require("efmls-configs.formatters.prettier"),
},
["typescript.tsx"] = {
require("efmls-configs.formatters.prettier"),
},
},
},
},
{
"lua_ls",
settings = {
Lua = {
runtime = {
version = 'LuaJIT',
},
diagnostics = {
globals = { 'vim' },
},
workspace = {
library = vim.api.nvim_get_runtime_file("", true),
},
telemetry = {
enable = false,
},
},
},
},
}
for _, server in pairs(servers) do for _, server in pairs(servers) do
local config = lspconfig[server[1]] local config = lspconfig[server[1]]
-- Only setup a language server if we have the binary available! local setup_config = {
if vim.fn.executable(config.document_config.default_config.cmd[1]) == 1 then on_attach = on_attach,
local opts = { handlers = handlers,
on_attach = on_attach, capabilities = capabilities,
handlers = handlers, }
capabilities = capabilities,
}
-- Add custom config if available -- Add custom config if available
for k, v in pairs(server) do for k, v in pairs(server) do
if type(k) ~= "number" then if type(k) ~= "number" then
opts[k] = v setup_config[k] = v
end end
end end
config.setup(opts) config.setup(setup_config)
end end
end end,
end,
} }

397
config/nvim/lua/plugins/null-ls.lua
View File

@ -1,397 +0,0 @@
return {
"jose-elias-alvarez/null-ls.nvim",
dependencies = {
"nvim-lua/plenary.nvim",
"lewis6991/gitsigns.nvim",
},
config = function()
local null_ls = require("null-ls")
local utils = require("null-ls.utils")
local cmd_resolver = require("null-ls.helpers.command_resolver")
local augroup = vim.api.nvim_create_augroup("LspFormatting", {})
local async_formatting = function(bufnr)
bufnr = bufnr or vim.api.nvim_get_current_buf()
vim.lsp.buf_request(
bufnr,
"textDocument/formatting",
vim.lsp.util.make_formatting_params({}),
function(err, res, ctx)
if err then
local err_msg = type(err) == "string" and err or err.message
-- you can modify the log message / level (or ignore it completely)
vim.notify("formatting: " .. err_msg, vim.log.levels.WARN)
return
end
-- don't apply results if buffer is unloaded or has been modified
if not vim.api.nvim_buf_is_loaded(bufnr) or vim.api.nvim_buf_get_option(bufnr, "modified") then
return
end
if res then
local client = vim.lsp.get_client_by_id(ctx.client_id)
if client.name == "null-ls" then
vim.lsp.util.apply_text_edits(res, bufnr, client and client.offset_encoding or "utf-16")
vim.api.nvim_buf_call(bufnr, function()
vim.cmd("silent noautocmd update")
end)
end
end
end
)
end
null_ls.setup({
on_attach = function(client, bufnr)
if client.supports_method("textDocument/formatting") then
vim.api.nvim_clear_autocmds({ group = augroup, buffer = bufnr })
vim.api.nvim_create_autocmd("BufWritePre", {
group = augroup,
buffer = bufnr,
callback = function()
async_formatting(bufnr)
end,
})
end
end,
border = "single",
sources = {
-- nvim plugins
null_ls.builtins.completion.spell,
null_ls.builtins.code_actions.gitsigns,
null_ls.builtins.diagnostics.stylelint.with({
condition = function(u)
local cmd = cmd_resolver.from_node_modules()({
command = "stylelint",
bufnr = vim.api.nvim_get_current_buf(),
bufname = vim.api.nvim_buf_get_name(vim.api.nvim_get_current_buf()),
})
return utils.is_executable(cmd) and u.root_has_file(".stylelintrc.json")
end,
filetypes = {
"css",
"scss",
"less",
"vue",
"html",
"javascript",
"javascriptreact",
"typescript",
"typescriptreact",
},
}),
null_ls.builtins.formatting.stylelint.with({
condition = function(u)
local cmd = cmd_resolver.from_node_modules()({
command = "stylelint",
bufnr = vim.api.nvim_get_current_buf(),
bufname = vim.api.nvim_buf_get_name(vim.api.nvim_get_current_buf()),
})
return utils.is_executable(cmd) and u.root_has_file(".stylelintrc.json")
end,
filetypes = {
"css",
"scss",
"less",
"vue",
"html",
"javascript",
"javascriptreact",
"typescript",
"typescriptreact",
},
}),
-- project local commands
null_ls.builtins.formatting.eslint.with({
condition = function()
local cmd = cmd_resolver.from_node_modules()({
command = "eslint",
bufnr = vim.api.nvim_get_current_buf(),
bufname = vim.api.nvim_buf_get_name(vim.api.nvim_get_current_buf()),
})
return utils.is_executable(cmd)
end,
}),
null_ls.builtins.diagnostics.eslint.with({
condition = function()
local cmd = cmd_resolver.from_node_modules()({
command = "eslint",
bufnr = vim.api.nvim_get_current_buf(),
bufname = vim.api.nvim_buf_get_name(vim.api.nvim_get_current_buf()),
})
return utils.is_executable(cmd)
end,
}),
null_ls.builtins.formatting.prettier.with({
condition = function()
local cmd = cmd_resolver.from_node_modules()({
command = "prettier",
bufnr = vim.api.nvim_get_current_buf(),
bufname = vim.api.nvim_buf_get_name(vim.api.nvim_get_current_buf()),
})
return utils.is_executable(cmd)
end,
filetypes = {
"javascript",
"javascriptreact",
"typescript",
"typescriptreact",
"vue",
"css",
"scss",
"less",
"html",
"yaml",
"json",
"graphql",
},
}),
-- global commands
null_ls.builtins.diagnostics.erb_lint.with({
condition = function()
return utils.is_executable("erblint")
end,
}),
null_ls.builtins.formatting.erb_lint.with({
condition = function()
return utils.is_executable("erblint")
end,
}),
null_ls.builtins.code_actions.shellcheck.with({
condition = function()
return utils.is_executable("shellcheck")
end,
}),
null_ls.builtins.diagnostics.shellcheck.with({
condition = function()
return utils.is_executable("shellcheck")
end,
}),
null_ls.builtins.diagnostics.buf.with({
condition = function()
return utils.is_executable("buf")
end,
}),
null_ls.builtins.diagnostics.checkmake.with({
condition = function()
return utils.is_executable("checkmake")
end,
}),
null_ls.builtins.diagnostics.codespell.with({
condition = function()
return utils.is_executable("codespell")
end,
}),
null_ls.builtins.diagnostics.fish.with({
condition = function()
return utils.is_executable("fish")
end,
}),
null_ls.builtins.formatting.fish_indent.with({
condition = function()
return utils.is_executable("fish_indent")
end,
}),
null_ls.builtins.diagnostics.flake8.with({
condition = function()
return utils.is_executable("flake8")
end,
}),
null_ls.builtins.diagnostics.golangci_lint.with({
condition = function()
return utils.is_executable("golangci-lint")
end,
}),
null_ls.builtins.diagnostics.luacheck.with({
condition = function()
return utils.is_executable("luacheck")
end,
}),
null_ls.builtins.formatting.stylua.with({
condition = function()
return utils.is_executable("stylua")
end,
}),
null_ls.builtins.diagnostics.markdownlint.with({
condition = function()
return utils.is_executable("markdownlint")
end,
}),
null_ls.builtins.formatting.markdownlint.with({
condition = function()
return utils.is_executable("markdownlint")
end,
}),
null_ls.builtins.diagnostics.mypy.with({
condition = function()
return utils.is_executable("mypy")
end,
}),
null_ls.builtins.diagnostics.php.with({
condition = function()
return utils.is_executable("php")
end,
}),
null_ls.builtins.diagnostics.pylint.with({
condition = function()
return utils.is_executable("pylint")
end,
}),
null_ls.builtins.diagnostics.rubocop.with({
condition = function()
return utils.is_executable("rubocop")
end,
}),
null_ls.builtins.formatting.rubocop.with({
condition = function()
return utils.is_executable("rubocop")
end,
}),
null_ls.builtins.diagnostics.tidy.with({
condition = function()
return utils.is_executable("tidy")
end,
}),
null_ls.builtins.formatting.tidy.with({
condition = function()
return utils.is_executable("tidy")
end,
}),
null_ls.builtins.formatting.autopep8.with({
condition = function()
return utils.is_executable("autopep8")
end,
}),
null_ls.builtins.formatting.beautysh.with({
condition = function()
return utils.is_executable("beautysh")
end,
}),
null_ls.builtins.formatting.black.with({
condition = function()
return utils.is_executable("black")
end,
}),
null_ls.builtins.formatting.gofmt.with({
condition = function()
return utils.is_executable("gofmt")
end,
}),
null_ls.builtins.formatting.gofumpt.with({
condition = function()
return utils.is_executable("gofumpt")
end,
}),
null_ls.builtins.formatting.goimports.with({
condition = function()
return utils.is_executable("goimports")
end,
}),
null_ls.builtins.formatting.isort.with({
condition = function()
return utils.is_executable("isort")
end,
}),
null_ls.builtins.formatting.nginx_beautifier.with({
condition = function()
return utils.is_executable("nginxbeautifier")
end,
}),
null_ls.builtins.formatting.pg_format.with({
condition = function()
return utils.is_executable("pg_format")
end,
}),
null_ls.builtins.formatting.prismaFmt.with({
condition = function()
return utils.is_executable("prisma-fmt")
end,
}),
null_ls.builtins.formatting.rustywind.with({
condition = function()
return utils.is_executable("rustywind")
end,
filetypes = {
"eruby",
"javascript",
"javascriptreact",
"typescript",
"typescriptreact",
"vue",
"svelte",
"html",
},
}),
null_ls.builtins.formatting.shfmt.with({
condition = function()
return utils.is_executable("shfmt")
end,
}),
null_ls.builtins.diagnostics.terraform_validate.with({
condition = function()
return utils.is_executable("terraform")
end,
}),
null_ls.builtins.formatting.terraform_fmt.with({
condition = function()
return utils.is_executable("terraform")
end,
}),
null_ls.builtins.diagnostics.actionlint.with({
condition = function()
return utils.is_executable("actionlint")
end,
}),
null_ls.builtins.formatting.xmllint.with({
condition = function()
return utils.is_executable("xmllint")
end,
}),
null_ls.builtins.formatting.deno_fmt.with({
condition = function()
return utils.is_executable("deno")
end,
filetypes = { "markdown" },
}),
},
})
end,
}