diff options
Diffstat (limited to 'home/.config/nvim')
24 files changed, 1706 insertions, 0 deletions
diff --git a/home/.config/nvim/after/ftplugin/c.lua b/home/.config/nvim/after/ftplugin/c.lua new file mode 120000 index 0000000..48a225a --- /dev/null +++ b/home/.config/nvim/after/ftplugin/c.lua @@ -0,0 +1 @@ +cpp.lua
\ No newline at end of file diff --git a/home/.config/nvim/after/ftplugin/cfg.lua b/home/.config/nvim/after/ftplugin/cfg.lua new file mode 100644 index 0000000..3e79acd --- /dev/null +++ b/home/.config/nvim/after/ftplugin/cfg.lua @@ -0,0 +1,3 @@ +vim.bo.commentstring = "// %s" + +vim.b.undo_ftplugin = vim.b.undo_ftplugin .. "| setlocal commentstring<" diff --git a/home/.config/nvim/after/ftplugin/cpp.lua b/home/.config/nvim/after/ftplugin/cpp.lua new file mode 100644 index 0000000..e3d3a8c --- /dev/null +++ b/home/.config/nvim/after/ftplugin/cpp.lua @@ -0,0 +1,2 @@ +vim.bo.commentstring = "// %s" +vim.b.undo_ftplugin = vim.b.undo_ftplugin .. "| setlocal commentstring<" diff --git a/home/.config/nvim/after/ftplugin/dosini.lua b/home/.config/nvim/after/ftplugin/dosini.lua new file mode 100644 index 0000000..f6d7437 --- /dev/null +++ b/home/.config/nvim/after/ftplugin/dosini.lua @@ -0,0 +1,3 @@ +vim.bo.commentstring = "# %s" +vim.b.undo_ftplugin = vim.b.undo_ftplugin + .. "|setlocal commentstring" diff --git a/home/.config/nvim/after/ftplugin/gitcommit.lua b/home/.config/nvim/after/ftplugin/gitcommit.lua new file mode 100644 index 0000000..8525714 --- /dev/null +++ b/home/.config/nvim/after/ftplugin/gitcommit.lua @@ -0,0 +1,5 @@ +vim.wo.spell = true +vim.b.undo_ftplugin = vim.b.undo_ftplugin .. "|setlocal spell<" +vim.cmd([[match ErrorMsg /\%1l.\%>50v/]]) +local bufnr = vim.api.nvim_buf_get_number(0) +require("mapper").ncmd("gd", "DiffGitCached", nil, bufnr) diff --git a/home/.config/nvim/after/ftplugin/gitrebase.lua b/home/.config/nvim/after/ftplugin/gitrebase.lua new file mode 100644 index 0000000..98fd264 --- /dev/null +++ b/home/.config/nvim/after/ftplugin/gitrebase.lua @@ -0,0 +1,20 @@ +local map = require("mapper") +local ncmd = map.ncmd +local vcmd = map.vcmd +local bufnr = vim.api.nvim_buf_get_number(0) + +ncmd("gc", "Cycle", nil, bufnr) +ncmd("gp", "Pick", nil, bufnr) +ncmd("ge", "Edit", nil, bufnr) +ncmd("gf", "Fixup", nil, bufnr) +ncmd("gd", "Drop", nil, bufnr) +ncmd("gs", "Squash", nil, bufnr) +ncmd("gr", "Reword", nil, bufnr) + +vcmd("gc", "Cycle", nil, bufnr) +vcmd("gp", "Pick", nil, bufnr) +vcmd("ge", "Edit", nil, bufnr) +vcmd("gf", "Fixup", nil, bufnr) +vcmd("gd", "Drop", nil, bufnr) +vcmd("gs", "Squash", nil, bufnr) +vcmd("gr", "Reword", nil, bufnr) diff --git a/home/.config/nvim/after/ftplugin/help.lua b/home/.config/nvim/after/ftplugin/help.lua new file mode 100644 index 0000000..63147a6 --- /dev/null +++ b/home/.config/nvim/after/ftplugin/help.lua @@ -0,0 +1,3 @@ +vim.keymap.set("n", "q", function() + vim.api.nvim_win_close(0, false) +end, { buffer = true }) diff --git a/home/.config/nvim/after/ftplugin/json.lua b/home/.config/nvim/after/ftplugin/json.lua new file mode 100644 index 0000000..726acd0 --- /dev/null +++ b/home/.config/nvim/after/ftplugin/json.lua @@ -0,0 +1 @@ +vim.cmd([[syntax match Comment +\/\/.\+$+]]) diff --git a/home/.config/nvim/after/ftplugin/mail.lua b/home/.config/nvim/after/ftplugin/mail.lua new file mode 100644 index 0000000..538c10b --- /dev/null +++ b/home/.config/nvim/after/ftplugin/mail.lua @@ -0,0 +1,2 @@ +vim.wo.spell = true +vim.b.undo_ftplugin = vim.b.undo_ftplugin .. "|setlocal spell<" diff --git a/home/.config/nvim/after/ftplugin/markdown.lua b/home/.config/nvim/after/ftplugin/markdown.lua new file mode 100644 index 0000000..538c10b --- /dev/null +++ b/home/.config/nvim/after/ftplugin/markdown.lua @@ -0,0 +1,2 @@ +vim.wo.spell = true +vim.b.undo_ftplugin = vim.b.undo_ftplugin .. "|setlocal spell<" diff --git a/home/.config/nvim/after/ftplugin/tex.lua b/home/.config/nvim/after/ftplugin/tex.lua new file mode 100644 index 0000000..b1dbce0 --- /dev/null +++ b/home/.config/nvim/after/ftplugin/tex.lua @@ -0,0 +1,4 @@ +vim.wo.spell = true +vim.bo.formatoptions = vim.bo.formatoptions .. "t" +vim.b.undo_ftplugin = vim.b.undo_ftplugin + .. "|setlocal spell< |setlocal formatoptions<" diff --git a/home/.config/nvim/after/ftplugin/text.lua b/home/.config/nvim/after/ftplugin/text.lua new file mode 100644 index 0000000..8c72f6f --- /dev/null +++ b/home/.config/nvim/after/ftplugin/text.lua @@ -0,0 +1,5 @@ +vim.wo.spell = true +vim.bo.formatoptions = vim.bo.formatoptions .. "t" +vim.bo.commentstring = "# %s" +vim.b.undo_ftplugin = vim.b.undo_ftplugin + .. "|setlocal spell< |setlocal formatoptions< |setlocal commentstring" diff --git a/home/.config/nvim/after/ftplugin/tmux.lua b/home/.config/nvim/after/ftplugin/tmux.lua new file mode 100644 index 0000000..590a12e --- /dev/null +++ b/home/.config/nvim/after/ftplugin/tmux.lua @@ -0,0 +1 @@ +vim.api.nvim_create_autocmd("BufWritePost", { buffer = 0, command = "make" }) diff --git a/home/.config/nvim/after/ftplugin/xdefaults.lua b/home/.config/nvim/after/ftplugin/xdefaults.lua new file mode 100644 index 0000000..0f4ec99 --- /dev/null +++ b/home/.config/nvim/after/ftplugin/xdefaults.lua @@ -0,0 +1,9 @@ +vim.bo.commentstring = "! %s" +vim.api.nvim_create_augroup("xdefaults", {}) +vim.api.nvim_create_autocmd( + "BufWritePost", + { group = "xdefaults", buffer = 0, command = "!xrdb %" } +) + +vim.b.undo_ftplugin = vim.b.undo_ftplugin + .. "| setlocal commentstring< diff --git a/home/.config/nvim/after/ftplugin/xmodmap.lua b/home/.config/nvim/after/ftplugin/xmodmap.lua new file mode 100644 index 0000000..75c9f8a --- /dev/null +++ b/home/.config/nvim/after/ftplugin/xmodmap.lua @@ -0,0 +1,4 @@ +vim.api.nvim_create_autocmd( + "BufWritePost", + { buffer = 0, command = "!xmodmap %" } +) diff --git a/home/.config/nvim/after/plugin/autocmds.lua b/home/.config/nvim/after/plugin/autocmds.lua new file mode 100644 index 0000000..7ab937f --- /dev/null +++ b/home/.config/nvim/after/plugin/autocmds.lua @@ -0,0 +1,137 @@ +local function augroup(name) + return vim.api.nvim_create_augroup(name, {}) +end + +local autocmd = vim.api.nvim_create_autocmd + +-- adapted from https://github.com/ethanholz/nvim-lastplace/blob/main/lua/nvim-lastplace/init.lua +local ignore_buftype = { "quickfix", "nofile", "help" } +local ignore_filetype = { "gitcommit", "gitrebase", "svn", "hgcommit" } + +local function run() + if vim.tbl_contains(ignore_buftype, vim.bo.buftype) then + return + end + + if vim.tbl_contains(ignore_filetype, vim.bo.filetype) then + -- reset cursor to first line + vim.cmd [[normal! gg]] + return + end + + -- If a line has already been specified on the command line, we are done + -- nvim file +num + if vim.fn.line(".") > 1 then + return + end + + local last_line = vim.fn.line([['"]]) + local buff_last_line = vim.fn.line("$") + + -- If the last line is set and the less than the last line in the buffer + if last_line > 0 and last_line <= buff_last_line then + local win_last_line = vim.fn.line("w$") + local win_first_line = vim.fn.line("w0") + -- Check if the last line of the buffer is the same as the win + if win_last_line == buff_last_line then + -- Set line to last line edited + vim.cmd [[normal! g`"]] + -- Try to center + elseif buff_last_line - last_line > + ((win_last_line - win_first_line) / 2) - 1 then + vim.cmd [[normal! g`"zz]] + else + vim.cmd [[normal! G'"<c-e>]] + end + end +end + +augroup("restore position") +autocmd("BufReadPost", { + once = true, + group = "restore position", + callback = run +}) + +augroup("postwrite") +autocmd("BufWritePost", { + group = "postwrite", + pattern = ".Xkeymap", + command = "!xkbcomp % $DISPLAY", +}) +autocmd("BufWritePost", { + group = "postwrite", + pattern = "*bspwmrc", + command = "!bspc wm --restart", +}) +autocmd("BufWritePost", { + group = "postwrite", + pattern = "*/polybar/config", + command = "!polybar-msg cmd restart", +}) +autocmd("BufWritePost", { + group = "postwrite", + pattern = "user-dirs.dirs,user-dirs.locale", + command = "!xdg-user-dirs-update", +}) +autocmd("BufWritePost", { + group = "postwrite", + pattern = "plugins.lua", + command = "source % | PackerSync", +}) +autocmd("BufWritePost", { + group = "postwrite", + pattern = "dunstrc", + command = "!killall -SIGUSR2 dunst", +}) +autocmd( + "BufWritePost", + { group = "postwrite", pattern = "fonts.conf", command = "!fc-cache" } +) + +augroup("autocomplete") +autocmd("CompleteDone", { + group = "autocomplete", + command = "if pumvisible() == 0 | silent! pclose | endif", +}) + +augroup("reload") +autocmd("CompleteDone", { + group = "reload", + command = "if getcmdwintype() == '' | checktime | endif", +}) + +augroup("highlightyank") +autocmd( + "TextYankPost", + { group = "highlightyank", callback = vim.highlight.on_yank } +) + +augroup("quitro") +autocmd("BufReadPost", { + group = "quitro", + callback = function() + if vim.opt.readonly:get() then + vim.keymap.set("n", "q", "<cmd>q<cr>") + end + end, +}) + +augroup("localinit") +autocmd("VimEnter", { + group = "localinit", + callback = function() + local settings = vim.fn.findfile(".doit.lua", ".;") + if settings ~= "" then + print("sourcing local config") + dofile(settings) + end + end, +}) + +augroup("restore guicursor") +autocmd("VimLeave", { + once = true, + group = "restore guicursor", + command = 'set guicursor= | call chansend(v:stderr, "\x1b[ q")' +}) diff --git a/home/.config/nvim/after/plugin/mappings.lua b/home/.config/nvim/after/plugin/mappings.lua new file mode 100644 index 0000000..7fd0f03 --- /dev/null +++ b/home/.config/nvim/after/plugin/mappings.lua @@ -0,0 +1,58 @@ +local map = require("mapper") + +map.n("<Space>", "<Nop>") + +-- make an accidental ; press also enter command mode +-- temporarily disabled to to vim-sneak plugin +map.n(";", ":") + +-- highlight last inserted text +map.n("gV", "`[v`]") + +map.n("<down>", "<c-e>") +map.n("<up>", "<c-y>") + +-- go to first non-blank character of current line +map.n("<c-a>", "^") +map.v("<c-a>", "^") +map.n("<c-e>", "$") +map.v("<c-e>", "$") + +-- This extends p in visual mode (note the noremap), so that if you paste from +-- the unnamed (ie. default) register, that register content is not replaced by +-- the visual selection you just pasted over–which is the default behavior. +-- This enables the user to yank some text and paste it over several places in +-- a row, without using a named register +-- map.v('p', "p:if v:register == '"'<Bar>let @@=@0<Bar>endif<cr>") +map.v("p", 'p:let @+=@0<CR>:let @"=@0<CR>') + +map.v("<leader>p", '"_dP') +map.n("<leader>d", '"_d') +map.n("<leader>D", '"_D') +map.map("", "<leader>c", '"_c') +map.map("", "<leader>C", '"_C') + +-- Find and Replace binds +map.ncmdi("<leader>s", "%s/") +map.vcmdi("<leader>s", "s/") +map.ncmdi("<leader>gs", '%s/<c-r>"/') +map.vcmdi("<leader>gs", 's/<c-r>"/') +map.ncmdi("<Leader>S", "%s/<C-r><C-w>/") + +map.ncmd("<leader>x", "wall") +map.ncmd("<leader>z", "wqall") +map.ncmd("<leader>q", "quitall") +map.ncmd("<localleader>x", "update") + +map.t("<Esc>", "<c-\\><c-n>", { silent = true, noremap = true, expr = true }) + +map.n("gw", vim.diagnostic.open_float) +map.n("gW", vim.diagnostic.setloclist) +map.n("[w", vim.diagnostic.goto_prev) +map.n("]w", vim.diagnostic.goto_next) +map.n("[e", function() + vim.diagnostic.goto_prev({ severity = vim.diagnostic.severity.ERROR }) +end) +map.n("]e", function() + vim.diagnostic.goto_next({ severity = vim.diagnostic.severity.ERROR }) +end) diff --git a/home/.config/nvim/filetype.lua b/home/.config/nvim/filetype.lua new file mode 100644 index 0000000..b13afe0 --- /dev/null +++ b/home/.config/nvim/filetype.lua @@ -0,0 +1,7 @@ +vim.filetype.add({ + extension = { + eml = "mail", + inc = "cpp", + def = "cpp", + }, +}) diff --git a/home/.config/nvim/init.lua b/home/.config/nvim/init.lua new file mode 100644 index 0000000..8326c43 --- /dev/null +++ b/home/.config/nvim/init.lua @@ -0,0 +1,26 @@ +vim.loader.enable() + +function docfg(name) + dofile(vim.fn.stdpath("config") .. "/lua/cfg/" .. name .. ".lua") +end + +docfg("options") + +function P(v) + print(vim.inspect(v)) + return v +end + +local lazypath = vim.fn.stdpath("data") .. "/lazy/lazy.nvim" +if not vim.loop.fs_stat(lazypath) then + vim.fn.system({ + "git", + "clone", + "--filter=blob:none", + "https://github.com/folke/lazy.nvim.git", + "--branch=stable", -- latest stable release + lazypath, + }) +end +vim.opt.rtp:prepend(lazypath) +require("lazy").setup("custom.plugins") diff --git a/home/.config/nvim/lua/cfg/lsp.lua b/home/.config/nvim/lua/cfg/lsp.lua new file mode 100644 index 0000000..5767ff6 --- /dev/null +++ b/home/.config/nvim/lua/cfg/lsp.lua @@ -0,0 +1,64 @@ +return { + on_attach_wrapper = function(client, bufnr, opts) + local map = require("mapper") + local autocmd = vim.api.nvim_create_autocmd + + opts = vim.tbl_extend("force", { auto_format = false }, opts or {}) + + if client.supports_method("textDocument/codeLens") then + require("virtualtypes").on_attach(client, bufnr) + autocmd( + { "CursorHold", "CursorHoldI", "InsertLeave" }, + { buffer = bufnr, callback = vim.lsp.codelens.refresh } + ) + map.n("gl", vim.lsp.codelens.run, { buffer = bufnr }) + end + + if client.supports_method("textDocument/definition") then + map.n("<c-]>", vim.lsp.buf.definition, { buffer = bufnr }) + end + if client.supports_method("textDocument/declaration") then + map.n("gD", vim.lsp.buf.declaration, { buffer = bufnr }) + end + if client.supports_method("textDocument/signatureHelp") then + require("lsp_signature").on_attach(client, bufnr) + map.n("gs", vim.lsp.buf.signature_help, { buffer = bufnr }) + end + if client.supports_method("textDocument/rename") then + map.n("gR", vim.lsp.buf.rename, { buffer = bufnr }) + end + if client.supports_method("textDocument/codeAction") then + map.n("ga", vim.lsp.buf.code_action, { buffer = bufnr }) + map.v("ga", vim.lsp.buf.code_action, { buffer = bufnr }) + end + + local buf_async_format = function() + vim.lsp.buf.format( + { bufnr = bufnr, async = true, id = client.id }) + end + local buf_sync_format = function() + vim.lsp.buf.format( + { bufnr = bufnr, async = false, id = client.id }) + end + local buf_async_format_hunks = function() + require("cfg.utils").format_hunks( + { bufnr = bufnr, async = true, id = client.id }) + end + + if client.supports_method("textDocument/formatting") then + map.n("<leader>f", buf_async_format, { buffer = bufnr }) + if opts.auto_format then + autocmd( + "BufWritePre", + { buffer = bufnr, callback = buf_sync_format } + ) + end + end + if client.supports_method("textDocument/rangeFormatting") then + map.v("<leader>f", buf_async_format, { buffer = bufnr }) + map.n("<leader>hf", buf_async_format_hunks, { buffer = bufnr }) + end + + require("lsp-inlayhints").on_attach(client, bufnr, false) + end +} diff --git a/home/.config/nvim/lua/cfg/options.lua b/home/.config/nvim/lua/cfg/options.lua new file mode 100644 index 0000000..1529121 --- /dev/null +++ b/home/.config/nvim/lua/cfg/options.lua @@ -0,0 +1,124 @@ +local opt = vim.opt + +opt.undofile = true +opt.swapfile = false +vim.opt.shadafile = "NONE" +vim.g.ts_highlight_lua = true +vim.g.ts_highlight_c = true +vim.g.ts_highlight_vim = true + +opt.showmode = true +opt.number = true +opt.cursorline = true +opt.signcolumn = "auto:2" +opt.showtabline = 2 +opt.showmatch = true + +opt.expandtab = true +opt.shiftround = true +opt.shiftwidth = 0 +opt.softtabstop = -1 +opt.tabstop = 4 + +opt.foldenable = false + +opt.splitbelow = true +opt.splitright = true + +opt.linebreak = true +opt.breakindent = true +opt.textwidth = 80 +opt.colorcolumn = "+1" +opt.formatoptions:remove("t") + +opt.spelllang:append({ "pt_pt", "es_es" }) +opt.spellfile = vim.fn.stdpath("config") .. "/spell/en.utf-8.add" + +opt.cmdheight = 2 +opt.updatetime = 300 + +opt.shortmess:append({ a = true }) + +opt.gdefault = true +opt.synmaxcol = 500 + +opt.completeopt = { "menu", "menuone", "noselect" } +opt.scrolloff = 999 +opt.sidescrolloff = 5 + +opt.clipboard = "unnamedplus" + +opt.wildmode = { "longest", "full" } + +opt.cpoptions:remove({ "_" }) + +opt.listchars = { + tab = "> ", + trail = "·", + extends = ">", + precedes = "<", + nbsp = "+", +} +opt.list = true + +opt.virtualedit = "block" +opt.spelloptions = "camel" + +vim.g.is_posix = 1 +vim.g.python_host_prog = 0 +vim.g.python3_host_prog = 0 +vim.g.netrw_home = vim.fn.stdpath("data") + +vim.g.loaded_netrw = 1 +vim.g.loaded_netrwPlugin = 1 +vim.g.loaded_netrwSettings = 1 +vim.g.loaded_netrwFileHandlers = 1 +vim.g.loaded_gzip = 1 +vim.g.loaded_zip = 1 +vim.g.loaded_zipPlugin = 1 +vim.g.loaded_tar = 1 +vim.g.loaded_tarPlugin = 1 +vim.g.loaded_zipPlugin = 1 +vim.g.loaded_getscript = 1 +vim.g.loaded_getscriptPlugin = 1 +vim.g.loaded_vimball = 1 +vim.g.loaded_vimballPlugin = 1 +vim.g.loaded_2html_plugin = 1 +vim.g.loaded_logipat = 1 +vim.g.loaded_rrhelper = 1 +vim.g.loaded_matchparen = 1 +vim.g.loaded_spec = 1 + +opt.diffopt:append({ + ["indent-heuristic"] = true, + hiddenoff = true, + iblank = true, + iwhiteall = true, + algorithm = "histogram", +}) + +if vim.fn.executable("rg") then + opt.grepprg = "rg\\ --vimgrep" + opt.grepformat:append("f:%l:%c:%m") +end + +opt.termguicolors = true +opt.pumblend = 20 + +opt.foldmethod = "expr" +opt.foldexpr = "nvim_treesitter#foldexpr()" +opt.foldenable = false + +opt.laststatus = 2 +vim.g.mapleader = " " +vim.g.maplocalleader = "," + +vim.diagnostic.config({ + virtual_text = { + source = "if_many", + severity = vim.diagnostic.severity.ERROR, + }, + signs = true, + underline = true, + update_in_insert = false, +}) diff --git a/home/.config/nvim/lua/cfg/utils.lua b/home/.config/nvim/lua/cfg/utils.lua new file mode 100644 index 0000000..abda35d --- /dev/null +++ b/home/.config/nvim/lua/cfg/utils.lua @@ -0,0 +1,24 @@ +local M = {} +local gitsigns = require("gitsigns") + +function M.format_hunks(options) + local hunks = require("gitsigns").get_hunks() + if not hunks or vim.tbl_isempty(hunks) then + return + end + for _, hunk in ipairs(hunks) do + local added = hunk.added + if added then + local start_line = added.start + local count = added.count + if start_line and count and start_line > 0 and count > 0 then + local end_line = start_line + added.count - 1 + local range = { start = { start_line, 0 }, ["end"] = { end_line, 0 } } + options = vim.tbl_extend("force", { range = range }, options or {}) + vim.lsp.buf.format(options) + end + end + end +end + +return M diff --git a/home/.config/nvim/lua/custom/plugins/init.lua b/home/.config/nvim/lua/custom/plugins/init.lua new file mode 100644 index 0000000..eb720e6 --- /dev/null +++ b/home/.config/nvim/lua/custom/plugins/init.lua @@ -0,0 +1,1117 @@ +local map = require("mapper") + +return { + { "nvim-lua/plenary.nvim", lazy = true }, + { "tpope/vim-repeat", event = "VeryLazy" }, + 'tpope/vim-sleuth', + { + "numToStr/Comment.nvim", + config = true, + }, + { + "tpope/vim-unimpaired", + keys = { "]", "[", "yo" }, + }, + { "folke/which-key.nvim", lazy = true }, + { "kylechui/nvim-surround", config = true }, + { + "dstein64/vim-startuptime", + cmd = "StartupTime", + }, + { + "folke/persistence.nvim", + config = true, + event = "BufReadPre", + keys = { + { + "<leader>qs", + require("persistence").load, + desc = + "Restore Session" + }, + { + "<leader>ql", + function() require("persistence").load({ last = true }) end, + desc = + "Restore Last Session" + }, + { + "<leader>qd", + require("persistence").stop, + desc = + "Don't Save Current Session" + }, + }, + }, + "xiyaowong/nvim-cursorword", + { + "sainnhe/gruvbox-material", + priority = 1000, + config = function() + vim.g.gruvbox_material_background = "hard" + vim.g.gruvbox_material_enable_bold = 1 + vim.g.gruvbox_material_enable_italic = 1 + vim.g.gruvbox_material_better_performance = 1 + vim.g.gruvbox_material_palette = "original" + + vim.cmd([[ colorscheme gruvbox-material]]) + end + }, + { + "aserowy/tmux.nvim", + config = true, + }, + { + "Julian/vim-textobj-variable-segment", + dependencies = { "kana/vim-textobj-user" }, + }, + { "mzlogin/vim-markdown-toc", ft = "markdown" }, + { + "norcalli/nvim-colorizer.lua", + event = "BufRead", + config = true + }, + { + "lewis6991/hover.nvim", + keys = { { "K", require "hover".hover }, { "gK", require "hover" + .hover_select }, { "gh", require "hover".hover }, + { "gH", require "hover".hover_select } }, + opts = { + init = function() + require("hover.providers.lsp") + require('hover.providers.gh') + require('hover.providers.man') + -- require('hover.providers.dictionary') + end, + }, + }, + { 'akinsho/git-conflict.nvim', config = true }, + { + "lukas-reineke/indent-blankline.nvim", + config = function() + local highlight = { + "RainbowRed", + "RainbowYellow", + "RainbowBlue", + "RainbowOrange", + "RainbowGreen", + "RainbowViolet", + "RainbowCyan", + } + local hooks = require "ibl.hooks" + -- create the highlight groups in the highlight setup hook, so they are reset + -- every time the colorscheme changes + hooks.register(hooks.type.HIGHLIGHT_SETUP, function() + vim.api.nvim_set_hl(0, "RainbowRed", { fg = "#E06C75" }) + vim.api.nvim_set_hl(0, "RainbowYellow", { fg = "#E5C07B" }) + vim.api.nvim_set_hl(0, "RainbowBlue", { fg = "#61AFEF" }) + vim.api.nvim_set_hl(0, "RainbowOrange", { fg = "#D19A66" }) + vim.api.nvim_set_hl(0, "RainbowGreen", { fg = "#98C379" }) + vim.api.nvim_set_hl(0, "RainbowViolet", { fg = "#C678DD" }) + vim.api.nvim_set_hl(0, "RainbowCyan", { fg = "#56B6C2" }) + end) + + vim.g.rainbow_delimiters = { highlight = highlight } + require("ibl").setup { scope = { highlight = highlight } } + + hooks.register(hooks.type.SCOPE_HIGHLIGHT, + hooks.builtin.scope_highlight_from_extmark) + end + }, + { + "monaqa/dial.nvim", + config = function() + map.n("]i", require("dial.map").inc_normal()) + map.n("[i", require("dial.map").dec_normal()) + map.v("]i", require("dial.map").inc_visual()) + map.v("[i", require("dial.map").dec_visual()) + end + }, + { + "iamcco/markdown-preview.nvim", + build = "cd app && yarn install", + ft = "markdown", + config = function() + vim.api.nvim_command([[ + function! g:OpenNewWindow(url) + silent exec "Start! librewolf --new-window " . a:url + endfunction + ]]) + vim.g.mkdp_browserfunc = "g:OpenNewWindow" + end, + }, + "gpanders/editorconfig.nvim", + { + "kwkarlwang/bufresize.nvim", + config = true + }, + "kovetskiy/sxhkd-vim", + "tmux-plugins/vim-tmux", + "chrisbra/csv.vim", + "martinda/Jenkinsfile-vim-syntax", + "rhysd/vim-llvm", + "MTDL9/vim-log-highlighting", + "raimon49/requirements.txt.vim", + "wgwoods/vim-systemd-syntax", + { + "NeogitOrg/neogit", + dependencies = { + "nvim-lua/plenary.nvim", + }, + config = function() + require("neogit").setup({ + disable_commit_confirmation = true, + kind = "split", + console_timeout = 5000, + auto_show_console = false, + }) + map.n("<leader>ng", require "neogit".open) + end, + }, + { + "ruifm/gitlinker.nvim", + keys = { + { "<leader>gy", function() require 'gitlinker'.get_buf_range_url("n") end }, + { + "<leader>gy", + function() + require 'gitlinker'.get_buf_range_url("v") + end, + mode = "v" + }, + }, + dependencies = { + "nvim-lua/plenary.nvim", + }, + config = function() + require "gitlinker".setup({ + callbacks = { + ["personal"] = function(url_data) + url_data.host = "github.com" + return require "gitlinker.hosts".get_github_type_url(url_data) + end, + ["work"] = function(url_data) + url_data.host = "github.com" + return require "gitlinker.hosts".get_github_type_url(url_data) + end, + ["git.strisemarx.com"] = function(url_data) + local url = require "gitlinker.hosts".get_base_https_url(url_data) + url = url .. "/tree/" .. url_data.file .. "?id=" .. url_data.rev + if url_data.lstart then + url = url .. "#n" .. url_data.lstart + end + return url + end + }, + }) + end, + }, + { + "lewis6991/gitsigns.nvim", + event = "BufRead", + opts = { + signs = { + change = { show_count = true }, + delete = { show_count = true }, + topdelete = { show_count = true }, + changedelete = { show_count = true }, + }, + numhl = true, + _extmark_signs = true, + _threaded_diff = true, + _signs_staged_enable = true, + on_attach = function(bufnr) + local gs = package.loaded.gitsigns + + -- Navigation + map.n(']c', function() + if vim.wo.diff then return ']c' end + vim.schedule(function() gs.next_hunk() end) + return '<Ignore>' + end, { expr = true }, bufnr) + + map.n('[c', function() + if vim.wo.diff then return '[c' end + vim.schedule(function() gs.prev_hunk() end) + return '<Ignore>' + end, { expr = true }, bufnr) + + -- Actions + map.nvcmd('<leader>hs', "Gitsigns stage_hunk", nil, bufnr) + map.nvcmd('<leader>hr', "Gitsigns reset_hunk", nil, bufnr) + map.n('<leader>hS', gs.stage_buffer, nil, bufnr) + map.n('<leader>hu', gs.undo_stage_hunk, nil, bufnr) + map.n('<leader>hR', gs.reset_buffer, nil, bufnr) + map.n('<leader>hp', gs.preview_hunk, nil, bufnr) + map.n('<leader>hb', function() gs.blame_line { full = true } end, nil, + bufnr) + map.n('<leader>tb', gs.toggle_current_line_blame, nil, bufnr) + map.n('<leader>hd', gs.diffthis, nil, bufnr) + map.n('<leader>hD', function() gs.diffthis('~') end, nil, bufnr) + map.n('<leader>hc', gs.change_base, nil, bufnr) + map.n('<leader>hC', function() gs.change_base('~') end, nil, bufnr) + map.n('<leader>td', gs.toggle_deleted, nil, bufnr) + map.n('<leader>tw', gs.toggle_word_diff, nil, bufnr) + map.n('<leader>tl', gs.toggle_linehl, nil, bufnr) + + -- Text object + map.map({ 'o', 'x' }, 'ih', ':<C-U>Gitsigns select_hunk<CR>', nil, bufnr) + end + }, + dependencies = { + "nvim-lua/plenary.nvim", + }, + }, + { + "nvim-telescope/telescope.nvim", + config = function() + local actions = require("telescope.actions") + require("telescope").setup({ + defaults = { + sorting_strategy = "ascending", + layout_config = { + prompt_position = "top", + }, + scroll_strategy = "cycle", + selection_strategy = "follow", + color_devicons = false, + mappings = { + i = { + ["<c-j>"] = actions.move_selection_next, + ["<c-k>"] = actions.move_selection_previous, + }, + }, + extensions = { + fzf = { + fuzzy = true, -- false will only do exact matching + override_generic_sorter = true, -- override the generic sorter + override_file_sorter = true, -- override the file sorter + case_mode = "smart_case", -- or "ignore_case" or "respect_case" + }, + ["ui-select"] = { + require("telescope.themes").get_dropdown({ + -- even more opts + }), + }, + }, + }, + }) + require("telescope").load_extension("fzf") + require("telescope").load_extension("ui-select") + + local b = require("telescope.builtin") + + map.n("<localleader>p", b.planets) + map.n("<localleader>B", b.builtin) + map.n("<localleader>/", b.live_grep) + map.n("<localleader>?", b.grep_string) + map.n("<localleader>f", function() + b.find_files({ + find_command = { + "fd", + "--type", + "file", + "--follow", + "--hidden", + "--exclude", + ".git", + }, + }) + end) + map.n("<localleader>b", function() + b.buffers({ sort_lastused = true, initial_mode = "normal" }) + end) + + map.n("<localleader>t", b.treesitter) + + map.n("<localleader>c", b.commands) + map.n("<localleader>h", b.help_tags) + map.n("<localleader>m", b.man_pages) + map.n("<localleader>k", b.keymaps) + map.n("<localleader>Q", function() + b.quickfix({ initial_mode = "normal" }) + end) + map.n("<localleader>L", function() + b.loclist({ initial_mode = "normal" }) + end) + map.n("<localleader>R", function() + b.registers({ initial_mode = "normal" }) + end) + map.n("<localleader>A", b.autocommands) + + map.n("gd", function() + b.lsp_definitions({ initial_mode = "normal" }) + end) + map.n("gvd", function() + b.lsp_definitions({ initial_mode = "normal", jump_type = "vsplit" }) + end) + map.n("gxd", function() + b.lsp_definitions({ initial_mode = "normal", jump_type = "split" }) + end) + map.n("gtd", function() + b.lsp_definitions({ initial_mode = "normal", jump_type = "tab" }) + end) + map.n("gi", function() + b.lsp_implementations({ initial_mode = "normal" }) + end) + map.n("gvi", function() + b.lsp_implementations({ initial_mode = "normal", jump_type = "vsplit" }) + end) + map.n("gxi", function() + b.lsp_implementations({ initial_mode = "normal", jump_type = "split" }) + end) + map.n("gti", function() + b.lsp_implementations({ initial_mode = "normal", jump_type = "tab" }) + end) + map.n("go", b.lsp_document_symbols) + map.n("gS", b.lsp_dynamic_workspace_symbols) + map.n("ge", function() + b.lsp_document_diagnostics({ initial_mode = "normal" }) + end) + map.n("gE", function() + b.lsp_workspace_diagnostics({ initial_mode = "normal" }) + end) + map.n("gr", function() + b.lsp_references({ initial_mode = "normal" }) + end) + map.n("gic", function() + b.lsp_incoming_calls({ initial_mode = "normal" }) + end) + map.n("goc", function() + b.lsp_outgoing_calls({ initial_mode = "normal" }) + end) + end, + dependencies = { + "nvim-lua/plenary.nvim", + { + "nvim-telescope/telescope-fzf-native.nvim", + build = "make", + }, + "nvim-telescope/telescope-ui-select.nvim", + }, + }, + { + "mfussenegger/nvim-dap", + config = function() + local dap = require("dap") + + dap.defaults.fallback.force_external_terminal = true + dap.defaults.fallback.external_terminal = { + command = "/usr/bin/st", + args = { "-e" }, + } + + dap.defaults.fallback.terminal_win_cmd = "50vsplit new" + + local function get_env_vars() + local variables = {} + for k, v in pairs(vim.fn.environ()) do + table.insert(variables, string.format("%s=%s", k, v)) + end + return variables + end + + dap.adapters.lldb = { + type = "executable", + command = "/usr/bin/lldb-vscode", + name = "lldb", + } + + local function str_split(inputstr, sep) + sep = sep or "%s" + local t = {} + for str in inputstr:gmatch("([^" .. sep .. "]+)") do + table.insert(t, str) + end + return t + end + + local _cmd = nil + + local function get_cmd() + if _cmd then + return _cmd + end + local clipboard_cmd = vim.fn.getreg("+") + _cmd = vim.fn.input({ + prompt = "Command to execute: ", + default = clipboard_cmd + }) + return _cmd + end + + local function get_program() + return str_split(get_cmd())[1] + end + + local function get_args() + local argv = str_split(get_cmd()) + local args = {} + + if #argv < 2 then + return {} + end + + for i = 2, #argv do + args[#args + 1] = argv[i] + end + + return args + end + + dap.configurations.cpp = { + { + name = "Launch", + type = "lldb", + request = "launch", + cwd = "${workspaceFolder}", + program = get_program, + stopOnEntry = true, + args = get_args, + env = get_env_vars, + runInTerminal = true, + }, + { + -- If you get an "Operation not permitted" error using this, try disabling YAMA: + -- echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope + name = "Attach to process", + type = "lldb", + request = "attach", + pid = require('dap.utils').pick_process, + }, + } + + dap.configurations.c = dap.configurations.cpp + dap.configurations.rust = dap.configurations.cpp + + local get_python_path = function() + local venv_path = os.getenv("VIRTUAL_ENV") + if venv_path then + return venv_path .. "/bin/python" + end + return "/usr/bin/python" + end + + require("dap-python").setup(get_python_path()) + + dap.adapters.nlua = function(callback, config) + callback({ type = "server", host = config.host, port = config.port }) + end + + dap.configurations.lua = { + { + type = "nlua", + request = "attach", + name = "Attach to running Neovim instance", + host = function() + local value = vim.fn.input("Host [127.0.0.1]: ") + if value ~= "" then + return value + end + return "127.0.0.1" + end, + port = function() + local val = tonumber(vim.fn.input("Port: ")) + assert(val, "Please provide a port number") + return val + end, + }, + } + + dap.repl.commands = vim.tbl_extend("force", dap.repl.commands, { + continue = { "continue", "c" }, + next_ = { "next", "n" }, + back = { "back", "b" }, + reverse_continue = { "reverse-continue", "rc" }, + into = { "into" }, + into_target = { "into_target" }, + out = { "out" }, + scopes = { "scopes" }, + threads = { "threads" }, + frames = { "frames" }, + exit = { "exit", "quit", "q" }, + up = { "up" }, + down = { "down" }, + goto_ = { "goto" }, + capabilities = { "capabilities", "cap" }, + -- add your own commands + custom_commands = { + ["echo"] = function(text) + dap.repl.append(text) + end, + }, + }) + + map.n("<F4>", dap.close) + map.n("<F5>", dap.continue) + map.n("<F10>", dap.step_over) + map.n("<F11>", dap.step_into) + map.n("<F12>", dap.step_out) + map.n("<leader>b", dap.toggle_breakpoint) + map.n("<leader>B", function() + dap.set_breakpoint(vim.fn.input("Breakpoint condition: ")) + end) + map.n("<leader>lp", function() + dap.set_breakpoint(nil, nil, vim.fn.input("Log point message: ")) + end) + map.n("<leader>dr", dap.repl.open) + map.n("<leader>dl", dap.run_last) + map.n("<F2>", dap.list_breakpoints) + + 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 + map.n("<leader>du", dapui.toggle) + map.v("<leader>de", dapui.eval) + end, + dependencies = { + { + "rcarriga/nvim-dap-ui", + opts = { + icons = { expanded = "-", collapsed = "+", current_frame = "*" }, + controls = { enabled = false }, + layouts = { + { + elements = { + -- Elements can be strings or table with id and size keys. + "scopes", + "breakpoints", + "stacks", + "watches", + }, + size = 40, + position = "left", + }, + { + elements = { + "repl", + }, + size = 0.25, -- 25% of total lines + position = "bottom", + }, + }, + }, + }, + { + "mfussenegger/nvim-dap-python", + keys = { + { "gm", function() + require("dap-python").test_method() + end }, + { + "g<cr>", + function() + require("dap-python").debug_selection() + end, + mode = "v" + }, + }, + }, + "jbyuki/one-small-step-for-vimkind", + { + "theHamsta/nvim-dap-virtual-text", + config = true, + dependencies = { "nvim-treesitter/nvim-treesitter" } + } + }, + }, + { + 'nvim-treesitter/nvim-treesitter', + dependencies = { + 'nvim-treesitter/nvim-treesitter-textobjects', + "nvim-treesitter/nvim-treesitter-refactor", + "RRethy/nvim-treesitter-textsubjects", + "theHamsta/nvim-treesitter-pairs", + "RRethy/nvim-treesitter-endwise", + }, + build = ":TSUpdate", + config = function() + require("nvim-treesitter.configs").setup({ + ensure_installed = { + "bash", + "c", + "cmake", + "comment", + "cpp", + "css", + "cuda", + "diff", + "dockerfile", + "fortran", + "git_rebase", + "gitattributes", + "gitcommit", + "gitignore", + "go", + "html", + "javascript", + "jsdoc", + "json", + "llvm", + "lua", + "make", + "markdown", + "markdown_inline", + "ninja", + "python", + "regex", + "rust", + "sql", + "todotxt", + "toml", + "typescript", + "vim", + "vimdoc", + "yaml" + }, + -- ignore_install = { "phpdoc" }, + highlight = { + enable = true, -- false will disable the whole extension + additional_vim_regex_highlighting = false, + }, + incremental_selection = { + enable = true, + keymaps = { + init_selection = "gnn", + node_incremental = "grn", + scope_incremental = "grc", + node_decremental = "grm", + }, + }, + indent = { enable = true }, + refactor = { + highlight_definitions = { enable = true }, + highlight_current_scope = { enable = true }, + smart_rename = { enable = true, keymaps = { smart_rename = "grr" } }, + navigation = { + enable = true, + keymaps = { + goto_definition = "gnd", + list_definitions = "gnD", + list_definitions_toc = "gO", + goto_next_usage = "<a-*>", + goto_previous_usage = "<a-#>", + }, + }, + }, + textobjects = { + select = { + enable = true, + -- Automatically jump forward to textobj, similar to targets.vim + lookahead = true, + keymaps = { + -- You can use the capture groups defined in textobjects.scm + ["af"] = "@function.outer", + ["if"] = "@function.inner", + ["ac"] = "@class.outer", + ["ic"] = "@class.inner", + }, + }, + swap = { + enable = true, + swap_next = { ["<leader>a"] = "@parameter.inner" }, + swap_previous = { ["<leader>A"] = "@parameter.inner" }, + }, + move = { + enable = true, + set_jumps = true, -- whether to set jumps in the jumplist + goto_next_start = { + ["]m"] = "@function.outer", + ["]]"] = "@class.outer", + }, + goto_next_end = { + ["]M"] = "@function.outer", + ["]["] = "@class.outer", + }, + goto_previous_start = { + ["[m"] = "@function.outer", + ["[["] = "@class.outer", + }, + goto_previous_end = { + ["[M"] = "@function.outer", + ["[]"] = "@class.outer", + }, + }, + lsp_interop = { + enable = true, + peek_definition_code = { + ["df"] = "@function.outer", + ["dF"] = "@class.outer", + }, + }, + }, + matchup = { + enable = true, + }, + pairs = { + enable = true, + goto_right_end = false, + keymaps = { goto_partner = "%" }, + }, + textsubjects = { + enable = true, + keymaps = { ["."] = "textsubjects-smart", [";"] = "textsubjects-big" }, + }, + tree_docs = { + enable = true, + }, + endwise = { + enable = true, + }, + }) + end + }, + { + "hrsh7th/nvim-cmp", + event = "InsertEnter", + config = function() + local cmp = require("cmp") + + local has_words_before = function() + local line, col = unpack(vim.api.nvim_win_get_cursor(0)) + return col ~= 0 + and vim.api.nvim_buf_get_lines(0, line - 1, line, true)[1] + :sub(col, col) + :match("%s") + == nil + end + + local luasnip = require("luasnip") + + cmp.setup({ + snippet = { + expand = function(args) + require("luasnip").lsp_expand(args.body) + end, + }, + mapping = { + ["<Tab>"] = cmp.mapping(function(fallback) + if cmp.visible() then + cmp.select_next_item() + elseif luasnip.expand_or_jumpable() then + luasnip.expand_or_jump() + elseif has_words_before() then + cmp.complete() + else + fallback() + end + end, { + "i", + "s", + }), + ["<S-Tab>"] = cmp.mapping(function(fallback) + if cmp.visible() then + cmp.select_prev_item() + elseif luasnip.jumpable(-1) then + luasnip.jump(-1) + else + fallback() + end + end, { + "i", + "s", + }), + ["<CR>"] = cmp.mapping.confirm({ + behavior = cmp.ConfirmBehavior.Replace, + select = true, + }), + }, + formatting = { + format = function(entry, vim_item) + -- set a name for each source + vim_item.menu = ({ + path = "[Path]", + nvim_lsp = "[LSP]", + luasnip = "[LuaSnip]", + dap = "[dap]", + })[entry.source.name] + return vim_item + end, + }, + sources = { + { name = "nvim_lsp" }, + { name = "luasnip" }, + { name = "path" }, + { name = "nvim_lsp_signature_help" }, + }, + }) + + require "cmp".setup.filetype( + { "dap-repl", "dapui_watches", "dapui_hover" }, { + sources = { + { name = "dap" }, + }, + }) + end, + dependencies = { + "hrsh7th/cmp-nvim-lsp", + "hrsh7th/cmp-path", + "hrsh7th/cmp-nvim-lsp-signature-help", + "rcarriga/cmp-dap", + { + "saadparwaiz1/cmp_luasnip", + dependencies = { + { + "L3MON4D3/LuaSnip", + event = "InsertCharPre", + keys = { + { "<c-j>", function() require "luasnip".jump(1) end, mode = "i" }, + { "<c-k>", function() require "luasnip".jump(-1) end, mode = "i" }, + }, + config = function() + require("luasnip/loaders/from_vscode").lazy_load() + end, + dependencies = { + "kitagry/vs-snippets", + "rafamadriz/friendly-snippets", + "kkonghao/snippet-dog", + }, + } + }, + }, + }, + }, + { + 'neovim/nvim-lspconfig', + config = function() + local lspconfig = require("lspconfig") + -- Enable (broadcasting) snippet capability for completion + local capabilities = vim.lsp.protocol.make_client_capabilities() + capabilities.textDocument.completion.completionItem.snippetSupport = true + capabilities.workspace.didChangeWatchedFiles.dynamicRegistration = true + capabilities = require("cmp_nvim_lsp").default_capabilities(capabilities) + + lspconfig.util.default_config = vim.tbl_extend( + "force", + lspconfig.util.default_config, + { + on_attach = require "cfg.lsp".on_attach_wrapper, + capabilities = capabilities, + flags = { + debounce_text_changes = 150, + }, + } + ) + + local function switch_source_header_splitcmd(bufnr, splitcmd) + bufnr = lspconfig.util.validate_bufnr(bufnr) + local clangd_client = lspconfig.util.get_active_client_by_name( + bufnr, + "clangd" + ) + local params = { uri = vim.uri_from_bufnr(bufnr) } + if clangd_client then + clangd_client.request( + "textDocument/switchSourceHeader", + params, + function(err, result) + if err then + error(tostring(err)) + end + if not result then + print("Corresponding file cannot be determined") + return + end + vim.api.nvim_command(splitcmd .. " " .. vim.uri_to_fname(result)) + end, + bufnr + ) + else + print( + "method textDocument/switchSourceHeader is not supported by any servers active on the current buffer" + ) + end + end + + local servers = { + bashls = {}, + fortls = {}, + lua_ls = { + on_attach = function(client, bufnr) + require("cfg.lsp").on_attach_wrapper( + client, + bufnr, + { auto_format = true } + ) + end, + settings = { + Lua = { + completion = { + callSnippet = "Both", + displayContext = 1, + }, + hint = { + enable = true, + } + } + }, + }, + ruff_lsp = {}, + pyright = {}, + clangd = { + cmd = { + "clangd", + "--enable-config", + "--completion-parse=auto", + "--completion-style=bundled", + "--header-insertion=iwyu", + "--header-insertion-decorators", + "--inlay-hints", + "--suggest-missing-includes", + "--folding-ranges", + "--function-arg-placeholders", + "--pch-storage=memory", + }, + commands = { + ClangdSwitchSourceHeader = { + function() + switch_source_header_splitcmd(0, "edit") + end, + description = "Open source/header in current buffer", + }, + ClangdSwitchSourceHeaderVSplit = { + function() + switch_source_header_splitcmd(0, "vsplit") + end, + description = "Open source/header in a new vsplit", + }, + ClangdSwitchSourceHeaderSplit = { + function() + switch_source_header_splitcmd(0, "split") + end, + description = "Open source/header in a new split", + }, + ClangdSwitchSourceHeaderTab = { + function() + switch_source_header_splitcmd(0, "tabedit") + end, + description = "Open source/header in a new tab", + }, + }, + on_attach = function(client, bufnr) + require("cfg.lsp").on_attach_wrapper(client, bufnr) + local cmpconfig = require("cmp.config") + local compare = require("cmp.config.compare") + cmpconfig.set_buffer({ + sorting = { + comparators = { + compare.offset, + compare.exact, + -- compare.scopes, + require("clangd_extensions.cmp_scores"), + compare.recently_used, + compare.locality, + compare.kind, + compare.sort_text, + compare.length, + compare.order, + }, + }, + }, bufnr) + vim.api.nvim_create_augroup("clang-format", {}) + vim.api.nvim_create_autocmd("BufWritePre", { + group = "clang-format", + buffer = bufnr, + callback = function() + if vim.fn.expand('%:p:h'):find("test") then + return + end + require("cfg.utils").format_hunks({ + bufnr = bufnr, + async = false, + id = client.id + }) + end, + }) + map.ncmd("gH", "ClangdSwitchSourceHeader") + map.ncmd("gvH", "ClangdSwitchSourceHeaderVSplit") + map.ncmd("gxH", "ClangdSwitchSourceHeaderSplit") + map.ncmd("gtH", "ClangdSwitchSourceHeaderSplit") + + require("clangd_extensions.inlay_hints").setup_autocmd() + require("clangd_extensions.inlay_hints").set_inlay_hints() + end, + init_options = { + usePlaceholders = true, + completeUnimported = true, + clangdFileStatus = true, + }, + }, + } + + for server, config in pairs(servers) do + local default_config = lspconfig[server].default_config or + lspconfig[server].document_config.default_config + local cmd = config.cmd or default_config.cmd + if vim.fn.executable(cmd[1]) == 1 then lspconfig[server].setup(config) end + end + end, + dependencies = { + "hrsh7th/cmp-nvim-lsp", + "ray-x/lsp_signature.nvim", + "jubnzv/virtual-types.nvim", + { 'folke/neodev.nvim', opts = {} }, + { "lvimuser/lsp-inlayhints.nvim", config = true }, + { + "p00f/clangd_extensions.nvim", + config = function() + require("clangd_extensions").setup({ + }) + end + }, + }, + }, + { + 'nvim-lualine/lualine.nvim', + opts = { + options = { + icons_enabled = false, + theme = 'gruvbox_dark', + component_separators = '', + section_separators = '|', + }, + sections = { + lualine_a = { 'filetype', { 'filename', path = 1 } }, + lualine_b = { '%l/%L:%c:%o' }, + lualine_c = { 'diff' }, + lualine_x = { 'searchcount, selectioncount' }, + lualine_y = {}, + lualine_z = { 'diagnostics' } + }, + inactive_sections = { + lualine_a = { 'filename' }, + lualine_b = {}, + lualine_c = {}, + lualine_x = {}, + lualine_y = {}, + lualine_z = {} + }, + }, + }, + { + "nvimtools/none-ls.nvim", + config = function() + local nls = require("null-ls") + nls.setup({ + on_attach = function(client, bufnr) + require("cfg.lsp").on_attach_wrapper( + client, + bufnr, + { auto_format = true } + ) + end, + sources = { + nls.builtins.formatting.black, + } + }) + end, + }, + "https://gitlab.com/HiPhish/rainbow-delimiters.nvim", +} diff --git a/home/.config/nvim/lua/mapper.lua b/home/.config/nvim/lua/mapper.lua new file mode 100644 index 0000000..c31aeca --- /dev/null +++ b/home/.config/nvim/lua/mapper.lua @@ -0,0 +1,84 @@ +local M = {} + +M.map = function(mode, keys, action, opts, bufnr) + opts = vim.tbl_extend("force", { silent = true, buffer = bufnr }, opts or {}) + vim.keymap.set(mode, keys, action, opts) +end + +M.cmdi = function(mode, keys, action, opts, bufnr) + opts = vim.tbl_extend("force", { silent = false }, opts or {}) + M.map(mode, keys, ":" .. action, opts, bufnr) +end + +M.cmd = function(mode, keys, action, opts, bufnr) + M.map(mode, keys, "<cmd>" .. action .. "<cr>", opts, bufnr) +end + +M.plug = function(mode, keys, action, opts, bufnr) + M.map(mode, keys, "<Plug>" .. action, opts, bufnr) +end + +M.n = function(keys, action, opts, bufnr) + M.map("n", keys, action, opts, bufnr) +end +M.ncmdi = function(keys, action, opts, bufnr) + M.cmdi("n", keys, action, opts, bufnr) +end +M.ncmd = function(keys, action, opts, bufnr) + M.cmd("n", keys, action, opts, bufnr) +end +M.nplug = function(keys, action, opts, bufnr) + M.plug("n", keys, "(" .. action .. ")", opts, bufnr) +end + +M.v = function(keys, action, opts, bufnr) + M.map("v", keys, action, opts, bufnr) +end +M.vcmdi = function(keys, action, opts, bufnr) + opts = vim.tbl_extend("force", { silent = false }, opts or {}) + M.v(keys, ":" .. action, opts, bufnr) +end +M.vcmd = function(keys, action, opts, bufnr) + M.vcmdi(keys, action .. "<cr>", opts, bufnr) +end +M.vplug = function(keys, action, opts, bufnr) + M.plug("v", keys, "(" .. action .. ")", opts, bufnr) +end + +M.nv = function(keys, action, opts, bufnr) + M.map({ "n", "v" }, keys, action, opts, bufnr) +end +M.nvcmdi = function(keys, action, opts, bufnr) + M.ncmdi(keys, action, opts, bufnr) + M.vcmdi(keys, action, opts, bufnr) +end +M.nvcmd = function(keys, action, opts, bufnr) + M.ncmd(keys, action, opts, bufnr) + M.vcmd(keys, action, opts, bufnr) +end +M.nvplug = function(keys, action, opts, bufnr) + M.plug({ "n", "v" }, keys, "(" .. action .. ")", opts, bufnr) +end + +M.i = function(keys, action, opts, bufnr) + M.map("i", keys, action, opts, bufnr) +end +M.iplug = function(keys, action, opts, bufnr) + opts = vim.tbl_extend("force", { silent = false }, opts or {}) + M.plug("i", keys, action, opts, bufnr) +end + +M.t = function(keys, action, opts, bufnr) + M.map("t", keys, action, opts, bufnr) +end +M.tcmdi = function(keys, action, opts, bufnr) + M.cmdi("t", keys, action, opts, bufnr) +end +M.tcmd = function(keys, action, opts, bufnr) + M.cmd("t", keys, action, opts, bufnr) +end +M.tplug = function(keys, action, opts, bufnr) + M.plug("t", keys, action, opts, bufnr) +end + +return M |