399 lines
10 KiB
Lua
399 lines
10 KiB
Lua
---- Aliases ----
|
|
local cmd = vim.cmd
|
|
local g = vim.g
|
|
local opt = vim.opt
|
|
|
|
---- General Config ----
|
|
opt.mouse = 'a'
|
|
opt.tabstop = 2
|
|
opt.shiftwidth = 2
|
|
opt.number = true
|
|
opt.breakindent = true
|
|
opt.showmatch = true
|
|
opt.ignorecase = true
|
|
opt.smartcase = true
|
|
opt.joinspaces = false
|
|
opt.showmode = false
|
|
opt.hidden = true
|
|
opt.backup = false
|
|
opt.writebackup = false
|
|
opt.swapfile = false
|
|
opt.shortmess:append({ I = true })
|
|
-- whichwrap -- left/right keys can traverse up/down
|
|
--opt.whichwrap = {'<','>','[',']'}
|
|
opt.cmdheight = 2
|
|
opt.showcmd = true
|
|
g.mapleader = ' '
|
|
|
|
---- Terminal ----
|
|
vim.api.nvim_create_autocmd({ "TermOpen" }, {
|
|
callback = function()
|
|
if vim.l then
|
|
vim.l.number = false
|
|
end
|
|
end,
|
|
})
|
|
|
|
---- Theming ----
|
|
opt.termguicolors = true
|
|
opt.background = 'dark'
|
|
g.gruvbox_italic = true
|
|
cmd.colorscheme('gruvbox')
|
|
opt.listchars = {
|
|
eol = '↲' ,
|
|
tab = '▶▹',
|
|
nbsp = '␣',
|
|
extends = '…',
|
|
trail = '•'}
|
|
-- vim-airline config ---
|
|
g.airline_powerline_fonts = true
|
|
g.airline_theme = 'powerlineish'
|
|
g['airline#extensions#tabline#enabled'] = 1
|
|
g['airline#extensions#tabline#left_sep'] = ' '
|
|
g['airline#extensions#tabline#left_alt_sep'] = '|'
|
|
|
|
---- Maps ----
|
|
vim.keymap.set('!','<C-BS>','<C-w>')
|
|
vim.keymap.set('v','>','>gv')
|
|
vim.keymap.set('v','<','<gv')
|
|
vim.keymap.set('n','<C-L>',':nohlsearch<CR>')
|
|
|
|
---- Treesitter ----
|
|
local ts = require 'nvim-treesitter.configs'
|
|
ts.setup {
|
|
ensure_installed = {
|
|
'bash',
|
|
'c',
|
|
'cmake',
|
|
'comment',
|
|
'cpp',
|
|
'css',
|
|
'dockerfile',
|
|
'diff',
|
|
'dot',
|
|
'git_config',
|
|
'git_rebase',
|
|
'gitattributes',
|
|
'gitcommit',
|
|
'gitignore',
|
|
'go',
|
|
'html',
|
|
'http',
|
|
'ini',
|
|
'javascript',
|
|
'json',
|
|
'kdl',
|
|
'kotlin',
|
|
'latex',
|
|
'lua',
|
|
'make',
|
|
'markdown',
|
|
'markdown_inline',
|
|
'passwd',
|
|
'perl',
|
|
'php',
|
|
'python',
|
|
'regex',
|
|
'rust',
|
|
'scss',
|
|
'sql',
|
|
'terraform',
|
|
'toml',
|
|
'typescript',
|
|
'vim',
|
|
'yaml',
|
|
},
|
|
highlight = {enable = true, indent = true}}
|
|
|
|
---- Filetypes ---
|
|
vim.filetype.add({ extension = {kdl = 'kdl'} })
|
|
|
|
|
|
---- LSP ----
|
|
local lsp = require 'lspconfig'
|
|
|
|
-- Use an on_attach function to only map the following keys
|
|
-- after the language server attaches to the current buffer
|
|
local on_lsp_attach = function(client, bufnr)
|
|
-- See `:help vim.lsp.*` for documentation on any of the below functions
|
|
vim.keymap.set('n', 'gD', '<cmd>lua vim.lsp.buf.declaration()<CR>', opts)
|
|
vim.keymap.set('n', 'gd', '<cmd>lua vim.lsp.buf.definition()<CR>', opts)
|
|
vim.keymap.set('n', 'K', '<cmd>lua vim.lsp.buf.hover()<CR>', opts)
|
|
vim.keymap.set('n', 'gi', '<cmd>lua vim.lsp.buf.implementation()<CR>', opts)
|
|
vim.keymap.set('n', '<C-k>', '<cmd>lua vim.lsp.buf.signature_help()<CR>', opts)
|
|
vim.keymap.set('n', '<Leader>D', '<cmd>lua vim.lsp.buf.type_definition()<CR>', opts)
|
|
vim.keymap.set('n', '<Leader>rn', '<cmd>lua vim.lsp.buf.rename()<CR>', opts)
|
|
vim.keymap.set('n', '<Leader>ca', '<cmd>lua vim.lsp.buf.code_action()<CR>', opts)
|
|
vim.keymap.set('n', 'gr', '<cmd>lua vim.lsp.buf.references()<CR>', opts)
|
|
vim.keymap.set('n', '<Leader>e', '<cmd>lua vim.diagnostic.open_float()<CR>', opts)
|
|
vim.keymap.set('n', '[d', '<cmd>lua vim.diagnostic.goto_prev()<CR>', opts)
|
|
vim.keymap.set('n', ']d', '<cmd>lua vim.diagnostic.goto_next()<CR>', opts)
|
|
vim.keymap.set('n', '<Leader>q', '<cmd>lua vim.diagnostic.setloclist()<CR>', opts)
|
|
vim.keymap.set('n', '<F3>', '<cmd>lua vim.lsp.buf.formatting()<CR>', opts)
|
|
end
|
|
|
|
-- Use a loop to conveniently call 'setup' on multiple servers and
|
|
-- map buffer local keybindings when the language server attaches
|
|
local servers = {
|
|
clangd = {},
|
|
eslint = {},
|
|
gopls = {},
|
|
jsonls = {},
|
|
kotlin_language_server = {},
|
|
marksman = {},
|
|
pylsp = {},
|
|
rust_analyzer = {},
|
|
texlab = {},
|
|
tflint = {},
|
|
tsserver = {},
|
|
}
|
|
-- Setup loop moved to the cmp section, since calling setup multiple times
|
|
-- overrides the previous calls.
|
|
|
|
-- Auto format on save
|
|
vim.api.nvim_create_autocmd({ "BufWritePre" }, {
|
|
callback = function()
|
|
vim.lsp.buf.format()
|
|
end,
|
|
})
|
|
|
|
---- Plugins ----
|
|
-- Go
|
|
g.ale_go_golangci_lint_options = ''
|
|
g.ale_go_golangci_lint_package = 1
|
|
---- nvim-lint ----
|
|
local lint = require 'lint'
|
|
local clippy_format = '%E%f:%l:%c: %\\d%#:%\\d%# %.%\\{-}'
|
|
.. 'error:%.%\\{-} %m,%W%f:%l:%c: %\\d%#:%\\d%# %.%\\{-}'
|
|
.. 'warning:%.%\\{-} %m,%C%f:%l %m,%-G,%-G'
|
|
.. 'error: aborting %.%#,%-G'
|
|
.. 'error: Could not compile %.%#,%E'
|
|
.. 'error: %m,%Eerror[E%n]: %m,%-G'
|
|
.. 'warning: the option `Z` is unstable %.%#,%W'
|
|
.. 'warning: %m,%Inote: %m,%C %#--> %f:%l:%c'
|
|
|
|
lint.linters.clippy = {
|
|
cmd = 'cargo clippy',
|
|
stdin = false,
|
|
append_fname = true,
|
|
args = {},
|
|
stream = 'stdout',
|
|
ignore_exitcode = false,
|
|
env = nil,
|
|
parser = require('lint.parser').from_errorformat(clippy_format)
|
|
}
|
|
|
|
linters = {
|
|
bash = {'shellcheck'},
|
|
go = {'golangcilint'},
|
|
python = {'flake8'},
|
|
rust = {'clippy'},
|
|
yaml = {'yamllint'},
|
|
}
|
|
-- set linters --
|
|
lint.linters_by_ft = linters
|
|
-- set autocommands --
|
|
for ft, ft_linters in pairs(linters) do
|
|
local on_change = false
|
|
local on_write = false
|
|
for l in pairs(ft_linters) do
|
|
if lint.linters.l.stdin then
|
|
on_change = true
|
|
else
|
|
on_write = true
|
|
end
|
|
end
|
|
if on_change then
|
|
vim.api.nvim_create_autocmd(
|
|
{"FileType"},
|
|
{
|
|
pattern=ft,
|
|
callback = function()
|
|
vim.api.nvim_create_autocmd(
|
|
{"TextChanged" },
|
|
{
|
|
callback = function()
|
|
lint.try_lint(nil, {ignore_errors=true})
|
|
end,
|
|
}
|
|
)
|
|
end
|
|
}
|
|
)
|
|
end
|
|
if on_write then
|
|
vim.api.nvim_create_autocmd(
|
|
{"FileType"},
|
|
{
|
|
pattern=ft,
|
|
callback = function()
|
|
vim.api.nvim_create_autocmd(
|
|
{"BufWritePost" },
|
|
{
|
|
callback = function()
|
|
lint.try_lint(nil, {ignore_errors=true})
|
|
end,
|
|
}
|
|
)
|
|
end
|
|
}
|
|
)
|
|
end
|
|
end
|
|
---- LuaSnip
|
|
require('luasnip.loaders.from_lua').lazy_load()
|
|
local luasnip = require 'luasnip'
|
|
vim.keymap.set({"i", "s"}, "<Tab>", function()
|
|
if luasnip.expand_or_jumpable() then
|
|
luasnip.expand_or_jump()
|
|
else
|
|
vim.api.nvim_feedkeys(
|
|
vim.api.nvim_replace_termcodes('<Tab>',true,false,true),
|
|
'n', -- noremap to avoid infinite recursion
|
|
true)
|
|
end
|
|
end, {silent = true})
|
|
vim.keymap.set({"i", "s"}, "<S-Tab>", function()
|
|
if luasnip.jumpable(-1) then
|
|
luasnip.jump(-1)
|
|
end
|
|
end, {silent = true})
|
|
---- completion-nvim
|
|
local cmp = require'cmp'
|
|
|
|
cmp.setup({
|
|
snippet = {
|
|
expand = function(args)
|
|
require('luasnip').lsp_expand(args.body) -- For `luasnip` users.
|
|
end,
|
|
},
|
|
window = {
|
|
-- completion = cmp.config.window.bordered(),
|
|
-- documentation = cmp.config.window.bordered(),
|
|
},
|
|
mapping = cmp.mapping.preset.insert({
|
|
['<C-b>'] = cmp.mapping.scroll_docs(-4),
|
|
['<C-f>'] = cmp.mapping.scroll_docs(4),
|
|
['<C-Space>'] = cmp.mapping.complete(),
|
|
['<C-e>'] = cmp.mapping.abort(),
|
|
-- Accept currently selected item. Set `select` to `false` to only confirm explicitly selected items.
|
|
['<CR>'] = cmp.mapping.confirm({ select = true }),
|
|
}),
|
|
sources = cmp.config.sources({
|
|
{ name = 'nvim_lsp' },
|
|
{ name = 'luasnip' },
|
|
{ name = 'path' },
|
|
{ name = 'buffer' },
|
|
})
|
|
})
|
|
--cmd [[autocmd FileType *\(TelescopePrompt\)\@<! lua require'completion'.on_attach()]]
|
|
|
|
-- Setup lspconfig.
|
|
local capabilities = vim.lsp.protocol.make_client_capabilities()
|
|
lsp.util.default_config = vim.tbl_deep_extend(
|
|
'force', lsp.util.default_config, { capabilities = capabilities, })
|
|
for server, add_to_config in pairs(servers) do
|
|
config = {
|
|
on_attach = on_lsp_attach,
|
|
flags = {
|
|
debounce_text_changes = 150,
|
|
},
|
|
}
|
|
for k,v in pairs(add_to_config) do
|
|
config[k] = v
|
|
end
|
|
lsp[server].setup(config)
|
|
end
|
|
---- git-blame.nvim
|
|
g.gitblame_enabled = 0
|
|
---- gitsigns.nvim
|
|
require('gitsigns').setup {
|
|
on_attach = function(bufnr)
|
|
local gs = package.loaded.gitsigns
|
|
|
|
-- Navigation
|
|
vim.keymap.set('n', ']c', function()
|
|
if vim.wo.diff then return ']c' end
|
|
vim.schedule(function() gs.next_hunk() end)
|
|
return '<Ignore>'
|
|
end, {expr=true})
|
|
|
|
vim.keymap.set('n', '[c', function()
|
|
if vim.wo.diff then return '[c' end
|
|
vim.schedule(function() gs.prev_hunk() end)
|
|
return '<Ignore>'
|
|
end, {expr=true})
|
|
|
|
-- Actions
|
|
vim.keymap.set({'n', 'v'}, '<leader>hs', ':Gitsigns stage_hunk<CR>')
|
|
vim.keymap.set({'n', 'v'}, '<leader>hr', ':Gitsigns reset_hunk<CR>')
|
|
vim.keymap.set('n', '<leader>hS', gs.stage_buffer)
|
|
vim.keymap.set('n', '<leader>hu', gs.undo_stage_hunk)
|
|
vim.keymap.set('n', '<leader>hR', gs.reset_buffer)
|
|
vim.keymap.set('n', '<leader>hp', gs.preview_hunk)
|
|
vim.keymap.set('n', '<leader>hb', function() gs.blame_line{full=true} end)
|
|
vim.keymap.set('n', '<leader>tb', gs.toggle_current_line_blame)
|
|
vim.keymap.set('n', '<leader>hd', gs.diffthis)
|
|
vim.keymap.set('n', '<leader>hD', function() gs.diffthis('~') end)
|
|
vim.keymap.set('n', '<leader>td', gs.toggle_deleted)
|
|
|
|
-- Text object
|
|
vim.keymap.set({'o', 'x'}, 'ih', ':<C-U>Gitsigns select_hunk<CR>')
|
|
end
|
|
}
|
|
---- Comment.nvim
|
|
require('Comment').setup()
|
|
---- vim-markdown
|
|
g.vim_markdown_no_default_key_mappings = 1
|
|
g.vim_markdown_folding_disabled = 1
|
|
g.vim_markdown_toml_frontmatter = 1
|
|
---- Telescope
|
|
local telescope = require 'telescope'
|
|
telescope.setup{
|
|
defaults = {
|
|
file_ignore_patterns = {"%.avif", "%.jpg", "%.pdf", "%.png", "%.webp"},
|
|
},
|
|
pickers = {
|
|
find_files = {
|
|
hidden = true,
|
|
}
|
|
}
|
|
}
|
|
telescope.load_extension('fzy_native')
|
|
telescope.load_extension('luasnip')
|
|
local builtin = require('telescope.builtin')
|
|
vim.keymap.set('n', '<Leader>f', builtin.fd)
|
|
vim.keymap.set('n', '<Leader>b', builtin.buffers)
|
|
vim.keymap.set('n', '<Leader>/', builtin.current_buffer_fuzzy_find)
|
|
vim.keymap.set('n', '<Leader>g', builtin.live_grep)
|
|
vim.keymap.set('n', '<Leader>cg', builtin.grep_string)
|
|
vim.keymap.set('n', '<Leader>:', builtin.commands)
|
|
vim.keymap.set('n', '<Leader>s', telescope.extensions.luasnip.luasnip)
|
|
---- nvim-dap
|
|
local dap = require('dap')
|
|
vim.fn.sign_define('DapBreakpoint',{ text ='🟥', texthl ='', linehl ='', numhl =''})
|
|
vim.fn.sign_define('DapStopped',{ text ='▶️', texthl ='', linehl ='', numhl =''})
|
|
-- Set keymaps to control the debugge
|
|
vim.keymap.set('n', '<leader>dc', require 'dap'.continue)
|
|
vim.keymap.set('n', '<leader>do', require 'dap'.step_over)
|
|
vim.keymap.set('n', '<leader>di', require 'dap'.step_into)
|
|
vim.keymap.set('n', '<leader>dO', require 'dap'.step_out)
|
|
vim.keymap.set('n', '<leader>db', require 'dap'.toggle_breakpoint)
|
|
vim.keymap.set('n', '<leader>dB', function()
|
|
require 'dap'.set_breakpoint(vim.fn.input('Breakpoint condition: '))
|
|
end)
|
|
local dapui = require('dapui')
|
|
dap.listeners.after.event_initialized["dapui_config"]=function()
|
|
dapui.open()
|
|
end
|
|
dap.listeners.before.event_terminated["dapui_config"]=function()
|
|
dapui.close()
|
|
end
|
|
dap.listeners.before.event_exited["dapui_config"]=function()
|
|
dapui.close()
|
|
end
|
|
-- nvim-dap-go
|
|
require('dap-go').setup()
|
|
|
|
---- web-devicons
|
|
require('nvim-web-devicons').setup()
|