From aa62e1f27b0cb3d712d6f2b13071cca0f09379be Mon Sep 17 00:00:00 2001 From: sommerfeld Date: Thu, 11 Sep 2025 16:38:11 +0100 Subject: Add a lot of changes --- home/.config/nvim/lua/cfg/options.lua | 66 +-- home/.config/nvim/lua/cfg/utils.lua | 12 +- .../.config/nvim/lua/custom/plugins/completion.lua | 188 ++++----- home/.config/nvim/lua/custom/plugins/debug.lua | 360 ++++++++-------- home/.config/nvim/lua/custom/plugins/ft.lua | 7 - home/.config/nvim/lua/custom/plugins/git.lua | 166 +++++--- home/.config/nvim/lua/custom/plugins/init.lua | 467 ++++++++++++++++++++- home/.config/nvim/lua/custom/plugins/lsp.lua | 387 ++++++++--------- home/.config/nvim/lua/custom/plugins/telescope.lua | 397 ++++++++++++++---- home/.config/nvim/lua/custom/plugins/ts.lua | 292 ++++++------- home/.config/nvim/lua/custom/plugins/ui.lua | 75 ++-- home/.config/nvim/lua/mapper.lua | 84 ---- 12 files changed, 1529 insertions(+), 972 deletions(-) delete mode 100644 home/.config/nvim/lua/custom/plugins/ft.lua delete mode 100644 home/.config/nvim/lua/mapper.lua (limited to 'home/.config/nvim/lua') diff --git a/home/.config/nvim/lua/cfg/options.lua b/home/.config/nvim/lua/cfg/options.lua index 05f563f..47489f1 100644 --- a/home/.config/nvim/lua/cfg/options.lua +++ b/home/.config/nvim/lua/cfg/options.lua @@ -1,4 +1,6 @@ -local opt = vim.opt +local opt = vim.o + +opt.termguicolors = true opt.undofile = true opt.swapfile = false @@ -8,6 +10,7 @@ opt.number = true opt.cursorline = true opt.signcolumn = "auto:2" opt.showmatch = true +opt.laststatus = 3 opt.expandtab = true opt.shiftround = true @@ -15,50 +18,62 @@ opt.shiftwidth = 0 opt.softtabstop = -1 opt.tabstop = 4 +opt.gdefault = true +opt.ignorecase = true +opt.smartcase = true + opt.splitbelow = true opt.splitright = true +opt.splitkeep = "screen" opt.linebreak = true opt.breakindent = true opt.textwidth = 80 opt.colorcolumn = "+1" -opt.formatoptions:remove("t") +vim.opt.formatoptions:remove("t") opt.cmdheight = 2 +-- vim.o.messagesopt = "wait:5000,history:500" -opt.shortmess:append({ a = true }) +vim.opt.shortmess:append({ a = true }) -opt.gdefault = true +opt.updatetime = 250 +opt.timeoutlen = 300 opt.synmaxcol = 500 -opt.completeopt = { "menu", "menuone", "noselect" } +vim.opt.completeopt = { "menuone", "noselect", "popup", "fuzzy" } opt.scrolloff = 999 opt.sidescrolloff = 5 -opt.clipboard = "unnamedplus" +vim.schedule(function() + opt.clipboard = vim.env.SSH_TTY and "" or "unnamedplus" +end) + +vim.o.mouse = "a" -opt.wildmode = { "longest", "full" } +vim.opt.wildmode = { "longest", "full" } -opt.cpoptions:remove({ "_" }) +vim.opt.cpoptions:remove({ "_" }) -opt.listchars = { +vim.opt.listchars = { tab = "> ", - trail = "·", + space = "·", extends = ">", precedes = "<", nbsp = "+", } opt.list = true +opt.confirm = 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_node_provider = 0 +vim.g.loaded_perl_provider = 0 +vim.g.loaded_python3_provider = 0 -opt.diffopt:append({ +vim.opt.diffopt:append({ ["indent-heuristic"] = true, hiddenoff = true, iblank = true, @@ -68,22 +83,25 @@ opt.diffopt:append({ if vim.fn.executable("rg") then opt.grepprg = "rg\\ --vimgrep" - opt.grepformat:append("f:%l:%c:%m") + opt.grepformat = "f:%l:%c:%m" end -opt.termguicolors = true opt.pumblend = 20 -opt.foldmethod = "expr" -opt.foldexpr = "nvim_treesitter#foldexpr()" -opt.foldenable = false +vim.wo.foldmethod = "expr" +vim.wo.foldenable = false vim.g.mapleader = " " vim.g.maplocalleader = "," vim.diagnostic.config({ - virtual_text = { - source = "if_many", - severity = vim.diagnostic.severity.ERROR, - } + virtual_text = false, + virtual_lines = false, }) + +opt.sessionoptions = + "blank,buffers,curdir,help,tabpages,winsize,winpos,terminal,localoptions" + +vim.o.exrc = true + + diff --git a/home/.config/nvim/lua/cfg/utils.lua b/home/.config/nvim/lua/cfg/utils.lua index 7cd172a..300d7a7 100644 --- a/home/.config/nvim/lua/cfg/utils.lua +++ b/home/.config/nvim/lua/cfg/utils.lua @@ -12,9 +12,15 @@ function M.format_hunks(options) local start = hunk.added.start local last = start + hunk.added.count -- nvim_buf_get_lines uses zero-based indexing -> subtract from last - local last_hunk_line = vim.api.nvim_buf_get_lines(0, last - 2, last - 1, true)[1] - local range = { start = { start, 0 }, ["end"] = { last - 1, last_hunk_line:len() } } - options = vim.tbl_extend("force", { range = range, lsp_fallback = true, quiet = true }, options or {}) + local last_hunk_line = + vim.api.nvim_buf_get_lines(0, last - 2, last - 1, true)[1] + local range = + { start = { start, 0 }, ["end"] = { last - 1, last_hunk_line:len() } } + options = vim.tbl_extend( + "force", + { range = range, lsp_fallback = true, quiet = true }, + options or {} + ) conform.format(options) end end diff --git a/home/.config/nvim/lua/custom/plugins/completion.lua b/home/.config/nvim/lua/custom/plugins/completion.lua index 789a459..70fdba0 100644 --- a/home/.config/nvim/lua/custom/plugins/completion.lua +++ b/home/.config/nvim/lua/custom/plugins/completion.lua @@ -1,116 +1,96 @@ return { { - "hrsh7th/nvim-cmp", + "zbirenbaum/copilot.lua", + cmd = "Copilot", + build = ":Copilot auth", 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 = { - [""] = 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", - }), - [""] = 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", - }), - [""] = 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" }, - }, - }) - - local cmp_autopairs = require 'nvim-autopairs.completion.cmp' - cmp.event:on('confirm_done', cmp_autopairs.on_confirm_done()) - end, + keys = { + { + "tc", + function() + require("copilot.command").toggle() + end, + desc = "[T]oggle [C]opilot attachment", + }, + }, + opts = { + suggestion = { enabled = false }, + panel = { enabled = false }, + }, + }, + { + "saghen/blink.compat", + opts = {}, + }, + { + "saghen/blink.cmp", dependencies = { - "hrsh7th/cmp-nvim-lsp", - "hrsh7th/cmp-path", - "hrsh7th/cmp-nvim-lsp-signature-help", + "rafamadriz/friendly-snippets", + "fang2hou/blink-copilot", "rcarriga/cmp-dap", - "windwp/nvim-autopairs", - { - "saadparwaiz1/cmp_luasnip", - dependencies = { - { - "L3MON4D3/LuaSnip", - event = "InsertCharPre", - keys = { - { "", function() require "luasnip".jump(1) end, mode = "i" }, - { "", function() require "luasnip".jump(-1) end, mode = "i" }, - }, - config = function() - require("luasnip/loaders/from_vscode").lazy_load() + }, + opts = { + keymap = { + preset = "cmdline", + [""] = { "accept", "fallback" }, + }, + appearance = { + use_nvim_cmp_as_default = true, + }, + completion = { + list = { + selection = { + preselect = function() + return not require("blink.cmp").snippet_active({ direction = 1 }) end, - dependencies = { - "kitagry/vs-snippets", - "rafamadriz/friendly-snippets", - "kkonghao/snippet-dog", + }, + }, + documentation = { auto_show = true }, + }, + signature = { + enabled = true, + trigger = { + enabled = true, + show_on_keyword = true, + show_on_insert = true, + }, + }, + sources = { + default = { "lazydev", "lsp", "copilot", "snippets", "path", "buffer" }, + per_filetype = { + ["dap-repl"] = { "dap" }, + }, + providers = { + path = { + opts = { + get_cwd = vim.fn.getcwd, }, - } + }, + copilot = { + name = "copilot", + module = "blink-copilot", + score_offset = 100, + async = true, + }, + lazydev = { + name = "LazyDev", + module = "lazydev.integrations.blink", + -- make lazydev completions top priority (see `:h blink.cmp`) + score_offset = 100, + }, + dap = { name = "dap", module = "blink.compat.source" }, }, }, }, }, + { + "saghen/blink.pairs", + version = "*", + dependencies = "saghen/blink.download", + opts = { + mappings = { + disabled_filetypes = { "TelescopePrompt" }, + }, + }, + }, } diff --git a/home/.config/nvim/lua/custom/plugins/debug.lua b/home/.config/nvim/lua/custom/plugins/debug.lua index 82de07d..cec04b1 100644 --- a/home/.config/nvim/lua/custom/plugins/debug.lua +++ b/home/.config/nvim/lua/custom/plugins/debug.lua @@ -1,237 +1,209 @@ -local map = require("mapper") - return { + { + "miroshQa/debugmaster.nvim", + branch = "dashboard", + dependencies = "mfussenegger/nvim-dap", + keys = { + { + "td", + function() + require("debugmaster").mode.toggle() + end, + desc = "[T]oggle [D]ebug mode", + }, + }, + }, { "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 + local variables = vim.fn.environ() + table.insert(variables, { ASAN_OPTIONS = "detect_leaks=0" }) return variables end dap.adapters.lldb = { type = "executable", - command = "/usr/bin/lldb-vscode", + command = "lldb-dap", name = "lldb", + env = get_env_vars, + } + dap.adapters.gdb = { + type = "executable", + command = "gdb", + args = { "--interpreter=dap" }, + env = get_env_vars, + } + dap.adapters.codelldb = { + type = "executable", + command = "codelldb", + env = get_env_vars, } - - 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] + local _program + vim.ui.input({ + prompt = "Program: ", + complete = "file_in_path", + }, function(res) + _program = res + end) + return vim.fn.system("which " .. _program):gsub("\n$", "") 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 + local _args + vim.ui.input({ + prompt = "Args: ", + default = vim.fn.getreg("+"), + complete = "file", + }, function(res) + _args = res + end) + return require("dap.utils").splitstr(_args) end dap.configurations.cpp = { + -- { + -- name = "GDB Launch", + -- type = "gdb", + -- request = "launch", + -- cwd = "${workspaceFolder}", + -- program = get_program, + -- args = get_args, + -- env = get_env_vars, + -- stopAtBeginningOfMainSubprogram = false, + -- }, + -- { + -- name = "LLDB Launch", + -- type = "lldb", + -- request = "launch", + -- cwd = "${workspaceFolder}", + -- program = get_program, + -- args = get_args, + -- env = get_env_vars, + -- stopOnEntry = true, + -- disableASLR = false, + -- }, { - name = "Launch", - type = "lldb", + name = "codelldb Launch", + type = "codelldb", 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, + stopOnEntry = true, + console = "integratedTerminal", }, + -- { + -- name = "GDB Attach to process", + -- type = "gdb", + -- request = "attach", + -- pid = require('dap.utils').pick_process, + -- }, + -- { + -- name = "LLDB Attach to process", + -- type = "lldb", + -- request = "attach", + -- pid = require('dap.utils').pick_process, + -- }, + -- { + -- name = "codelldb Attach to process", + -- type = "codelldb", + -- 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("", dap.close) - map.n("", dap.continue) - map.n("", dap.step_over) - map.n("", dap.step_into) - map.n("", dap.step_out) - map.n("b", dap.toggle_breakpoint) - map.n("B", function() - dap.set_breakpoint(vim.fn.input("Breakpoint condition: ")) - end) - map.n("lp", function() - dap.set_breakpoint(nil, nil, vim.fn.input("Log point message: ")) - end) - map.n("dr", dap.repl.open) - map.n("dl", dap.run_last) - map.n("", 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("du", dapui.toggle) - map.v("de", dapui.eval) + -- local dapui = require("dapui") + -- dap.listeners.before.attach.dapui_config = dapui.open + -- dap.listeners.before.launch.dapui_config = dapui.open + -- dap.listeners.before.event_terminated.dapui_config = dapui.close + -- dap.listeners.before.event_exited.dapui_config = dapui.close + + -- local dv = require("dap-view") + -- dap.listeners.before.attach["dap-view-config"] = dv.open + -- dap.listeners.before.launch["dap-view-config"] = dv.open + -- dap.listeners.before.event_terminated["dap-view-config"] = dv.close + -- dap.listeners.before.event_exited["dap-view-config"] = dv.close end, dependencies = { + -- { + -- "igorlfs/nvim-dap-view", + -- keys = { + -- { + -- "td", + -- function() + -- require("dap-view").toggle(true) + -- end, + -- desc = "[T]oggle [D]ebug UI", + -- }, + -- }, + -- opts = {}, + -- }, + -- { + -- "rcarriga/nvim-dap-ui", + -- dependencies = "nvim-neotest/nvim-nio", + -- keys = { + -- { + -- "td", + -- function() + -- require("dapui").toggle() + -- end, + -- desc = "[T]oggle [D]ebug UI", + -- }, + -- { + -- "de", + -- function() + -- require("dapui").eval() + -- end, + -- desc = "[D]ebug [E]valuate", + -- }, + -- }, + -- 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", + -- }, + -- }, + -- }, + -- }, { - "rcarriga/nvim-dap-ui", - dependencies = "nvim-neotest/nvim-nio", - 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", - }, - }, - }, + "theHamsta/nvim-dap-virtual-text", + opts = {}, + dependencies = { "nvim-treesitter/nvim-treesitter" }, }, + "williamboman/mason.nvim", { - "mfussenegger/nvim-dap-python", - keys = { - { "gm", function() - require("dap-python").test_method() - end }, - { - "g", - function() - require("dap-python").debug_selection() - end, - mode = "v" - }, + "jay-babu/mason-nvim-dap.nvim", + opts = { + automatic_installation = false, + handlers = {}, + ensure_installed = {}, }, }, - "jbyuki/one-small-step-for-vimkind", - { - "theHamsta/nvim-dap-virtual-text", - config = true, - dependencies = { "nvim-treesitter/nvim-treesitter" } - } }, }, } diff --git a/home/.config/nvim/lua/custom/plugins/ft.lua b/home/.config/nvim/lua/custom/plugins/ft.lua deleted file mode 100644 index 769db86..0000000 --- a/home/.config/nvim/lua/custom/plugins/ft.lua +++ /dev/null @@ -1,7 +0,0 @@ -return { - "kovetskiy/sxhkd-vim", - "tmux-plugins/vim-tmux", - "martinda/Jenkinsfile-vim-syntax", - "rhysd/vim-llvm", - "wgwoods/vim-systemd-syntax", -} diff --git a/home/.config/nvim/lua/custom/plugins/git.lua b/home/.config/nvim/lua/custom/plugins/git.lua index 077cfd4..3e41626 100644 --- a/home/.config/nvim/lua/custom/plugins/git.lua +++ b/home/.config/nvim/lua/custom/plugins/git.lua @@ -1,8 +1,7 @@ -local map = require("mapper") - return { { - 'akinsho/git-conflict.nvim', + "akinsho/git-conflict.nvim", + event = "BufRead", opts = { disable_diagnostics = true, highlights = { @@ -11,10 +10,10 @@ return { ancestor = nil, }, default_mappings = { - next = ']x', - prev = '[x', + next = "]x", + prev = "[x", }, - } + }, }, { "NeogitOrg/neogit", @@ -22,46 +21,55 @@ return { "nvim-lua/plenary.nvim", "nvim-telescope/telescope.nvim", }, - config = function() - local neogit = require("neogit") - neogit.setup({ - disable_commit_confirmation = true, - kind = "split", - console_timeout = 5000, - auto_show_console = false, - }) - map.n("ng", neogit.open) - end, + keys = { + { + "go", + function() + require("neogit").open() + end, + desc = "neo[G]it [O]pen", + }, + }, + cmd = "Neogit", + opts = { + disable_commit_confirmation = true, + kind = "split", + console_timeout = 5000, + auto_show_console = false, + }, }, { "ruifm/gitlinker.nvim", keys = { - { "gy", function() require 'gitlinker'.get_buf_range_url("n") end }, { "gy", function() - require 'gitlinker'.get_buf_range_url("v") + require("gitlinker").get_buf_range_url("n") end, - mode = "v" + }, + { + "gy", + function() + require("gitlinker").get_buf_range_url("v") + end, + mode = "v", }, }, dependencies = { "nvim-lua/plenary.nvim", }, - config = function() - require "gitlinker".setup({ - callbacks = { - ["git.sommerfeld.dev"] = 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 + opts = { + callbacks = { + ["git.sommerfeld.dev"] = 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 - }, - }) - end, + return url + end, + }, + }, }, { "lewis6991/gitsigns.nvim", @@ -77,48 +85,80 @@ return { _threaded_diff = true, _refresh_staged_on_update = true, on_attach = function(bufnr) - local gs = require('gitsigns') - + local gs = require("gitsigns") + local function map(mode, l, r, desc) + vim.keymap.set(mode, l, r, { buffer = bufnr, desc = desc }) + end + local function nmap(l, r, desc) + map("n", l, r, desc) + end + local function vmap(l, r, desc) + map("v", l, r, desc) + end -- Navigation - map.n(']c', function() + nmap("]c", function() if vim.wo.diff then - vim.cmd.normal({ ']c', bang = true }) + vim.cmd.normal({ "]c", bang = true }) else - gs.nav_hunk('next') + gs.nav_hunk("next") end - end, nil, bufnr) + end, "Jump to next git [c]hange") - map.n('[c', function() + nmap("[c", function() if vim.wo.diff then - vim.cmd.normal({ '[c', bang = true }) + vim.cmd.normal({ "[c", bang = true }) else - gs.nav_hunk('prev') + gs.nav_hunk("prev") end - end, nil, bufnr) + end, "Jump to previous git [c]hange") -- Actions - map.n('hs', gs.stage_hunk, nil, bufnr) - map.n('hr', gs.reset_hunk, nil, bufnr) - map.v('hs', function() gs.stage_hunk { vim.fn.line('.'), vim.fn.line('v') } end, nil, bufnr) - map.v('hr', function() gs.reset_hunk { vim.fn.line('.'), vim.fn.line('v') } end, nil, bufnr) - map.n('hS', gs.stage_buffer, nil, bufnr) - map.n('hu', gs.undo_stage_hunk, nil, bufnr) - map.n('hR', gs.reset_buffer, nil, bufnr) - map.n('hp', gs.preview_hunk, nil, bufnr) - map.n('hb', function() gs.blame_line { full = true } end, nil, - bufnr) - map.n('tb', gs.toggle_current_line_blame, nil, bufnr) - map.n('hd', gs.diffthis, nil, bufnr) - map.n('hD', function() gs.diffthis('~') end, nil, bufnr) - map.n('hc', gs.change_base, nil, bufnr) - map.n('hC', function() gs.change_base('~') end, nil, bufnr) - map.n('td', gs.toggle_deleted, nil, bufnr) - map.n('tw', gs.toggle_word_diff, nil, bufnr) - map.n('tl', gs.toggle_linehl, nil, bufnr) - + nmap("hs", gs.stage_hunk, "git [s]tage hunk") + nmap("hr", gs.reset_hunk, "git [r]eset hunk") + vmap("hs", function() + gs.stage_hunk({ vim.fn.line("."), vim.fn.line("v") }) + end, "git [s]tage hunk") + vmap("hr", function() + gs.reset_hunk({ vim.fn.line("."), vim.fn.line("v") }) + end, "git [r]eset hunk") + nmap("hS", gs.stage_buffer, "git [S]tage buffer") + nmap("hR", gs.reset_buffer, "git [R]eset buffer") + nmap("hp", gs.preview_hunk, "git [p]review hunk") + nmap("hb", function() + gs.blame_line({ full = true }) + end, "git [b]lame line") + nmap( + "tb", + gs.toggle_current_line_blame, + "[T]oggle git show [b]lame line" + ) + nmap("hd", gs.diffthis, "git [d]iff against index") + nmap("hD", function() + gs.diffthis("~") + end, "git [D]iff against last commit") + nmap("hc", gs.change_base, "git [C]hange base to index") + nmap("hC", function() + gs.change_base("~") + end, "git [C]hange base to HEAD") + nmap( + "tgd", + gs.preview_hunk_inline, + "[T]oggle [G]it show [D]eleted" + ) + nmap("tgw", gs.toggle_word_diff, "[T]oggle [G]it [W]ord diff") + nmap( + "tgl", + gs.toggle_linehl, + "[T]oggle [G]it [L]ine highlighting" + ) -- Text object - map.map({ 'o', 'x' }, 'ih', ':Gitsigns select_hunk', nil, bufnr) - end + map( + { "o", "x" }, + "ih", + ":Gitsigns select_hunk", + "git [H]unk text object" + ) + end, }, dependencies = { "nvim-lua/plenary.nvim", diff --git a/home/.config/nvim/lua/custom/plugins/init.lua b/home/.config/nvim/lua/custom/plugins/init.lua index ed597ba..3b7c821 100644 --- a/home/.config/nvim/lua/custom/plugins/init.lua +++ b/home/.config/nvim/lua/custom/plugins/init.lua @@ -1,38 +1,463 @@ -local map = require("mapper") - return { - { "nvim-lua/plenary.nvim", lazy = true }, - { "tpope/vim-repeat", event = "VeryLazy" }, - 'tpope/vim-sleuth', + { "nvim-lua/plenary.nvim", branch = "master", lazy = true }, { - 'tummetott/unimpaired.nvim', - keys = { "]", "[", "yo" }, - opts = { - -- add options here if you wish to override the default settings - }, + "nmac427/guess-indent.nvim", + event = "BufRead", + opts = {}, }, - { "kylechui/nvim-surround", config = true }, { - "Julian/vim-textobj-variable-segment", - dependencies = { "kana/vim-textobj-user" }, + "kylechui/nvim-surround", + event = "VeryLazy", + opts = {}, + }, + { + "chrisgrieser/nvim-various-textobjs", + event = "VeryLazy", + opts = { + keymaps = { + useDefaults = true, + }, + }, }, { "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 + keys = { + { + "]i", + function() + require("dial.map").inc_normal() + end, + expr = true, + desc = "Increment", + }, + { + "[i", + function() + require("dial.map").dec_normal() + end, + expr = true, + desc = "Decrement", + }, + { + "]i", + function() + require("dial.map").inc_visual() + end, + expr = true, + mode = "v", + desc = "Increment", + }, + { + "[i", + function() + require("dial.map").dec_visual() + end, + expr = true, + mode = "v", + desc = "Decrement", + }, + }, + config = function() end, }, { "iamcco/markdown-preview.nvim", cmd = { "MarkdownPreviewToggle", "MarkdownPreview", "MarkdownPreviewStop" }, build = "cd app && yarn install", - ft = { "markdown" }, + ft = "markdown", }, { "kwkarlwang/bufresize.nvim", - config = true + event = "VeryLazy", + opts = {}, + }, + { + "rmagatti/auto-session", + lazy = false, + opts = function() + -- Convert the cwd to a simple file name + local function get_cwd_as_name() + local dir = vim.fn.getcwd(0) + return dir:gsub("[^A-Za-z0-9]", "_") + end + local overseer = require("overseer") + return { + use_git_branch = true, + pre_save_cmds = { + function() + overseer.save_task_bundle( + get_cwd_as_name(), + -- Passing nil will use config.opts.save_task_opts. You can call list_tasks() explicitly and + -- pass in the results if you want to save specific tasks. + nil, + { on_conflict = "overwrite" } -- Overwrite existing bundle, if any + ) + end, + }, + -- Optionally get rid of all previous tasks when restoring a session + pre_restore_cmds = { + function() + for _, task in ipairs(overseer.list_tasks({})) do + task:dispose(true) + end + end, + }, + post_restore_cmds = { + function() + overseer.load_task_bundle( + get_cwd_as_name(), + { ignore_missing = true, autostart = false } + ) + end, + }, + save_extra_data = function(_) + local ok, breakpoints = pcall(require, "dap.breakpoints") + if not ok or not breakpoints then + return + end + + local bps = {} + local breakpoints_by_buf = breakpoints.get() + for buf, buf_bps in pairs(breakpoints_by_buf) do + bps[vim.api.nvim_buf_get_name(buf)] = buf_bps + end + if vim.tbl_isempty(bps) then + return + end + local extra_data = { + breakpoints = bps, + } + return vim.fn.json_encode(extra_data) + end, + + restore_extra_data = function(_, extra_data) + local json = vim.fn.json_decode(extra_data) + + if json.breakpoints then + local ok, breakpoints = pcall(require, "dap.breakpoints") + + if not ok or not breakpoints then + return + end + vim.notify("restoring breakpoints") + for buf_name, buf_bps in pairs(json.breakpoints) do + for _, bp in pairs(buf_bps) do + local line = bp.line + local opts = { + condition = bp.condition, + log_message = bp.logMessage, + hit_condition = bp.hitCondition, + } + breakpoints.set(opts, vim.fn.bufnr(buf_name), line) + end + end + end + end, + suppressed_dirs = { "~/", "/" }, + } + end, + }, + { + "aserowy/tmux.nvim", + event = "VeryLazy", + opts = { + resize = { + enable_default_keybindings = false, + }, + }, + }, + { + "stevearc/overseer.nvim", + keys = { + { + "to", + function() + require("overseer").toggle() + end, + desc = "[T]oggle [O]verseer", + }, + { + "ob", + function() + require("overseer").run_template({ + name = "just build", + prompt = "never", + }) + end, + desc = "[O]verseer [B]uild", + }, + { + "ot", + function() + require("overseer").run_template({ + name = "just test", + prompt = "never", + }) + end, + desc = "[O]verseer [J]ust [T]est", + }, + { + "of", + function() + require("overseer").run_template({ + name = "just test", + prompt = "never", + params = { target = vim.fn.expand("%") }, + }) + end, + desc = "[O]verseer test [F]ile", + }, + { + "oa", + function() + require("overseer").run_template({ + name = "just test_autofix", + prompt = "never", + params = { target = vim.fn.expand("%") }, + }) + end, + desc = "[O]verseer [A]utofix", + }, + { + "or", + function() + require("overseer").run_template() + end, + desc = "[O]verseer [R]un", + }, + { + "os", + function() + require("overseer").run_template({ name = "shell" }) + end, + desc = "[O]verseer [S]hell", + }, + { + "ol", + function() + local tasks = require("overseer").list_tasks({ recent_first = true }) + if vim.tbl_isempty(tasks) then + vim.notify("No tasks found", vim.log.levels.WARN) + else + require("overseer").run_action(tasks[1], "restart") + end + end, + desc = "[O]verseer run [L]ast", + }, + }, + config = function() + local overseer = require("overseer") + overseer.setup({}) + overseer.add_template_hook({ name = ".*" }, function(task_defn, util) + util.add_component( + task_defn, + { "open_output", on_start = "never", on_complete = "failure" } + ) + end) + end, + }, + { + "ThePrimeagen/refactoring.nvim", + dependencies = { + "nvim-lua/plenary.nvim", + "nvim-treesitter/nvim-treesitter", + }, + keys = { + { + "re", + function() + require("refactoring").refactor("Extract Function") + end, + mode = "x", + desc = "[R]efactor [E]xtract function", + }, + { + "rf", + function() + require("refactoring").refactor("Extract Function To File") + end, + mode = "x", + desc = "[R]efactor extract function to [F]ile", + }, + { + "rv", + function() + require("refactoring").refactor("Extract Variable") + end, + mode = "x", + desc = "[R]efactor extract [V]ariable", + }, + { + "rI", + function() + require("refactoring").refactor("Inline Function") + end, + desc = "[R]efactor [I]nline function", + }, + { + "ri", + function() + require("refactoring").refactor("Inline Variable") + end, + mode = { "x", "n" }, + desc = "[R]efactor [I]nline variable", + }, + { + "rb", + function() + require("refactoring").refactor("Extract Block") + end, + desc = "[R]efactor extract [B]lock", + }, + { + "rB", + function() + require("refactoring").refactor("Extract Block To File") + end, + desc = "[R]efactor extract [B]lock to file", + }, + { + "rp", + function() + require("refactoring").debug.printf({}) + end, + desc = "[R]efactor [P]rint", + }, + + { + "rv", + function() + require("refactoring").debug.print_var({}) + end, + mode = { "x", "n" }, + desc = "[R]efactor [P]rint [V]ariable", + }, + { + "rc", + function() + require("refactoring").debug.cleanup({}) + end, + desc = "[R]efactor [C]leanup", + }, + }, + opts = {}, + config = function() + local refactoring = require("refactoring") + refactoring.setup({}) + end, + }, + { + "folke/which-key.nvim", + event = "VeryLazy", + opts = { + spec = { + { "g", group = "[G]oto" }, + { "yo", group = "Toggle options" }, + { "]", group = "Navigate to next" }, + { "[", group = "Navigate to previous" }, + { "c", group = "[C]ode", mode = { "n", "x" } }, + { "d", group = "[D]ocument" }, + { "g", group = "[G]it" }, + { "h", group = "Git [H]unk", mode = { "n", "v" } }, + { "n", group = "[N]eotest" }, + { "o", group = "[O]verseer" }, + { "r", group = "[R]efactor" }, + { "s", group = "[S]earch" }, + { "w", group = "[W]orkspace" }, + { "t", group = "[T]oggle" }, + }, + }, + keys = { + { + "?", + function() + require("which-key").show({ global = false }) + end, + desc = "Buffer Local Keymaps (which-key)", + }, + }, + }, + { + "stevearc/quicker.nvim", + event = "FileType qf", + keys = { + { + "tq", + function() + require("quicker").toggle() + end, + desc = "[T]oggle [Q]uickfix", + }, + { + "tl", + function() + require("quicker").toggle({ loclist = true }) + end, + desc = "[T]oggle [L]oclist", + }, + }, + opts = { + keys = { + { + ">", + function() + require("quicker").expand({ + before = 2, + after = 2, + add_to_existing = true, + }) + end, + desc = "Expand quickfix context", + }, + { + "<", + function() + require("quicker").collapse() + end, + desc = "Collapse quickfix context", + }, + }, + }, + }, + { + "olimorris/codecompanion.nvim", + dependencies = { + "nvim-lua/plenary.nvim", + "nvim-treesitter/nvim-treesitter", + }, + keys = { + { + "aa", + "CodeCompanionActions", + { "n", "v" }, + { noremap = true, silent = true, desc = "[A]I [A]ctions" }, + }, + { + "ta", + "CodeCompanionChat Toggle", + { "n", "v" }, + { noremap = true, silent = true, desc = "[T]oggle [A]I chat" }, + }, + { + "ac", + "CodeCompanionChat Add", + "v", + { noremap = true, silent = true, desc = "[A]I [C]chat add" }, + }, + }, + opts = { + strategies = { + chat = { + adapter = "copilot", + }, + inline = { + adapter = "copilot", + }, + }, + }, + }, + { + "stevearc/oil.nvim", + opts = {}, + lazy = false, }, } diff --git a/home/.config/nvim/lua/custom/plugins/lsp.lua b/home/.config/nvim/lua/custom/plugins/lsp.lua index b351e10..8ddbbac 100644 --- a/home/.config/nvim/lua/custom/plugins/lsp.lua +++ b/home/.config/nvim/lua/custom/plugins/lsp.lua @@ -1,198 +1,117 @@ -local map = require("mapper") - -local function handler_splitcmd(_, uri, splitcmd) - if not uri or uri == "" then - vim.api.nvim_echo({ { "Corresponding file cannot be determined" } }, false, {}) - return - end - local file_name = vim.uri_to_fname(uri) - vim.api.nvim_cmd({ - cmd = splitcmd, - args = { file_name }, - }, {}) -end - -local function switch_source_header_splitcmd(bufnr, splitcmd) - bufnr = bufnr or 0 - vim.lsp.buf_request(bufnr, "textDocument/switchSourceHeader", { - uri = vim.uri_from_bufnr(bufnr), - }, function(err, uri) return handler_splitcmd(err, uri, splitcmd) end) -end - -local function edit_source_header(bufnr) - switch_source_header_splitcmd(bufnr, "edit") -end - -local function split_source_header(bufnr) - switch_source_header_splitcmd(bufnr, "split") -end - -local function vsplit_source_header(bufnr) - switch_source_header_splitcmd(bufnr, "vsplit") -end - -local function tabedit_source_header(bufnr) - switch_source_header_splitcmd(bufnr, "tabedit") -end - return { + { + "folke/lazydev.nvim", + ft = "lua", + opts = { + library = { + { path = "${3rd}/luv/library", words = { "vim%.uv" } }, + }, + }, + }, { "lewis6991/hover.nvim", - config = function() - require("hover").setup { - init = function() - require("hover.providers.lsp") - require('hover.providers.gh') - require('hover.providers.man') - -- require('hover.providers.dictionary') + keys = { + { + "K", + function() + require("hover").hover({}) end, - } - - vim.keymap.set("n", "K", require("hover").hover, { desc = "hover.nvim" }) - vim.keymap.set("n", "gh", require("hover").hover, { desc = "hover.nvim" }) - vim.keymap.set("n", "gK", require("hover").hover_select, - { desc = "hover.nvim (select)" }) - end + desc = "Hover", + }, + { + "gK", + function() + require("hover").hover_select({}) + end, + desc = "Hover Select", + }, + { + "gh", + function() + require("hover").hover({}) + end, + desc = "[H]over", + }, + }, + opts = { + init = function() + require("hover.providers.lsp") + require("hover.providers.man") + require("hover.providers.dap") + -- require("hover.providers.gh") + require("hover.providers.dictionary") + end, + }, }, { - '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 - if pcall(require, "cmp_nvim_lsp") then - capabilities = require("cmp_nvim_lsp").default_capabilities() - end - - lspconfig.util.default_config = vim.tbl_extend( - "force", - lspconfig.util.default_config, - { - capabilities = capabilities, - } - ) - - local servers = { - bashls = {}, - dockerls = {}, - fortls = {}, - lua_ls = {}, - ruff = {}, - ts_ls = {}, - pyright = {}, - clangd = { - on_attach = function(_, bufnr) - map.n("gH", edit_source_header, { buffer = bufnr }) - map.n("gvH", vsplit_source_header, { buffer = bufnr }) - map.n("gxH", split_source_header, { buffer = bufnr }) - map.n("gtH", tabedit_source_header, { buffer = bufnr }) - end, - init_options = { - clangdFileStatus = true, + "neovim/nvim-lspconfig", + version = false, + dependencies = { + { "j-hui/fidget.nvim", opts = {} }, + "saghen/blink.cmp", + { "williamboman/mason.nvim", opts = {} }, + { + "williamboman/mason-lspconfig.nvim", + opts = { + ensure_installed = {}, + automatic_installation = false, + handlers = { + function(server_name) + vim.lsp.enable(server_name) + end, }, }, - } - - for server, config in pairs(servers) do - local cmd = config.cmd - local config_def = lspconfig[server].config_def - if not cmd and config_def then - local default_config = config_def.default_config - if default_config then - cmd = default_config.cmd - end - end - if cmd then - if vim.fn.executable(cmd[1]) == 1 then - lspconfig[server].setup(config) - end - end - end - - vim.api.nvim_create_autocmd("LspAttach", { - callback = function(args) - local bufnr = args.buf - local client = assert(vim.lsp.get_client_by_id(args.data.client_id)) - - if client.supports_method("textDocument/codeLens") then - vim.api.nvim_create_autocmd( - { "CursorHold", "CursorHoldI", "InsertLeave" }, - { buffer = bufnr, callback = vim.lsp.codelens.refresh } - ) - map.n("gl", vim.lsp.codelens.run, { buffer = bufnr }) - end - - map.n("", vim.lsp.buf.definition, { buffer = bufnr }) - map.n("gD", vim.lsp.buf.declaration, { buffer = bufnr }) - map.n("gR", vim.lsp.buf.rename, { buffer = bufnr }) - map.n("ga", vim.lsp.buf.code_action, { buffer = bufnr }) - map.v("ga", vim.lsp.buf.code_action, { buffer = bufnr }) - - -- 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). - if client.server_capabilities.documentHighlightProvider then - local highlight_augroup = vim.api.nvim_create_augroup('lsp-highlight', { clear = false }) - vim.api.nvim_create_autocmd({ 'CursorHold', 'CursorHoldI' }, { - buffer = bufnr, - group = highlight_augroup, - callback = vim.lsp.buf.document_highlight, - }) - - vim.api.nvim_create_autocmd({ 'CursorMoved', 'CursorMovedI' }, { - buffer = bufnr, - group = highlight_augroup, - callback = vim.lsp.buf.clear_references, - }) - - vim.api.nvim_create_autocmd('LspDetach', { - group = vim.api.nvim_create_augroup('lsp-detach', { clear = true }), - callback = function(event2) - vim.lsp.buf.clear_references() - vim.api.nvim_clear_autocmds { group = 'lsp-highlight', buffer = event2.buf } - end, - }) - end - - -- The following autocommand is used to enable 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.server_capabilities.inlayHintProvider and vim.lsp.inlay_hint then - map.n('th', function() - vim.lsp.inlay_hint.enable(not vim.lsp.inlay_hint.is_enabled({})) - vim.lsp.inlay_hint.enable() - end, { buffer = bufnr }) - end - end, - }) - end, - dependencies = { - { 'folke/neodev.nvim', opts = {} }, + }, + { + "WhoIsSethDaniel/mason-tool-installer.nvim", + opts = { + ensure_installed = { + -- "nginx-language-server", -- needs python <= 3.12 + -- "just-lsp", -- "Platform unsupported" + "actionlint", + "autotools-language-server", + "bash-language-server", + "clangd", + "codelldb", + "codespell", + "css-lsp", + "dockerfile-language-server", + "fortls", + "gh", + "gh-actions-language-server", + "groovy-language-server", + "hadolint", + "html-lsp", + "jq", + "jsonlint", + "lua-language-server", + "markdownlint", + "mdformat", + "neocmakelsp", + "nginx-config-formatter", + "npm-groovy-lint", + "prettier", + "ruff", + "rust-analyzer", + "shellcheck", + -- "shellharden", + "shfmt", + "stylelint", + "stylua", + "systemd-language-server", + "systemdlint", + "typescript-language-server", + "typos", + "yamllint", + "yq", + }, + }, + }, }, - }, - { - "ray-x/lsp_signature.nvim", - event = "VeryLazy", config = function() - local lsp_signature = require "lsp_signature" - lsp_signature.setup({}) - - vim.api.nvim_create_autocmd("LspAttach", { - callback = function(args) - local bufnr = args.buf - local client = assert(vim.lsp.get_client_by_id(args.data.client_id)) - if client.supports_method("textDocument/signatureHelp") then - require("lsp_signature").on_attach({}, bufnr) - map.n("gs", vim.lsp.buf.signature_help, { buffer = bufnr }) - end - end, - }) - end + vim.lsp.enable("just") + vim.lsp.enable("tblgen_lsp_server") + end, }, { "stevearc/conform.nvim", @@ -205,19 +124,32 @@ return { require("conform").format({ async = true, lsp_fallback = true }) end, mode = "", - desc = "Format buffer", + desc = "[F]ormat buffer", }, }, config = function() require("conform").setup({ formatters_by_ft = { - python = { "ruff_format" }, + awk = { "gawk" }, + bash = { "shfmt" }, cmake = { "cmake_format" }, - json = { "jq" }, + css = { "prettier", "stylelint" }, + groovy = { "npm-groovy-lint" }, + html = { "prettier" }, + javascript = { "prettier" }, + typecript = { "prettier" }, + jenkins = { "npm-groovy-lint" }, + json = { "jq", "jsonlint" }, + jsonc = { "prettier" }, + just = { "just" }, + markdown = { "mdformat" }, + nginx = { "nginxfmt" }, + lua = { "stylua" }, + python = { "ruff_format", "ruff_fix", "ruff_organize_imports" }, rust = { "rustfmt" }, - sh = { "shfmt" }, - bash = { "shfmt" }, - zsh = { "shfmt" }, + sh = { "shfmt", "shellcheck", "shellharden" }, + yaml = { "yamllint" }, + zsh = { "shfmt", "shellcheck", "shellharden" }, }, default_format_opts = { lsp_format = "fallback", @@ -229,29 +161,80 @@ return { }, }) vim.o.formatexpr = "v:lua.require'conform'.formatexpr()" - vim.api.nvim_create_autocmd("BufWritePre", { - callback = require "cfg.utils".format_hunks, - }) end, }, { - 'mrcjkb/rustaceanvim', - lazy = false, + "mrcjkb/rustaceanvim", + ft = "rust", }, { "mfussenegger/nvim-lint", - event = { 'BufReadPre', 'BufNewFile' }, + event = { "BufReadPre", "BufNewFile" }, config = function() - local lint = require('lint') + local lint = require("lint") + lint.linters_by_ft = { + css = { "stylelint" }, dockerfile = { "hadolint" }, + groovy = { "npm-groovy-lint" }, + jenkins = { "npm-groovy-lint" }, + json = { "jsonlint" }, + markdown = { "markdownlint" }, + makefile = { "checkmake" }, + systemd = { "systemdlint" }, + yaml = { "yamllint", "yq" }, + ghaction = { "actionlint" }, + zsh = { "zsh" }, + ["*"] = { "codespell", "typos" }, } - vim.api.nvim_create_autocmd({ "BufReadPost", "BufWritePost", "InsertLeave" }, { + local lint_augroup = vim.api.nvim_create_augroup("lint", { clear = true }) + vim.api.nvim_create_autocmd({ "BufReadPost", "BufWritePost" }, { + group = lint_augroup, callback = function() - lint.try_lint() - end + if vim.opt_local.modifiable:get() then + lint.try_lint() + end + end, }) - end + end, }, { "j-hui/fidget.nvim", opts = {} }, + { + "rachartier/tiny-inline-diagnostic.nvim", + event = "VeryLazy", + priority = 1000, + opts = { + options = { + show_source = { + if_many = true, + }, + -- Set the arrow icon to the same color as the first diagnostic severity + set_arrow_to_diag_color = true, + -- Configuration for multiline diagnostics + -- Can be a boolean or a table with detailed options + multilines = { + -- Enable multiline diagnostic messages + enabled = true, + }, + + -- Display all diagnostic messages on the cursor line, not just those under cursor + show_all_diags_on_cursorline = true, + -- Enable diagnostics in Select mode (e.g., when auto-completing with Blink) + enable_on_select = true, + -- Configuration for breaking long messages into separate lines + break_line = { + -- Enable breaking messages after a specific length + enabled = true, + }, + -- Filter diagnostics by severity levels + -- Available severities: vim.diagnostic.severity.ERROR, WARN, INFO, HINT + severity = { + vim.diagnostic.severity.ERROR, + vim.diagnostic.severity.WARN, + vim.diagnostic.severity.INFO, + vim.diagnostic.severity.HINT, + }, + }, + }, + }, } diff --git a/home/.config/nvim/lua/custom/plugins/telescope.lua b/home/.config/nvim/lua/custom/plugins/telescope.lua index d2e97d7..ed88754 100644 --- a/home/.config/nvim/lua/custom/plugins/telescope.lua +++ b/home/.config/nvim/lua/custom/plugins/telescope.lua @@ -1,129 +1,341 @@ -local map = require("mapper") - return { { "nvim-telescope/telescope.nvim", + branch = "master", + keys = { + { + "sg", + function() + require("telescope.builtin").live_grep() + end, + desc = "[S]earch by [G]rep", + }, + { + "sw", + function() + require("telescope.builtin").grep_string() + end, + desc = "[S]earch current [W]ord", + }, + { + "sf", + function() + require("telescope.builtin").find_files() + end, + desc = "[S]earch [F]iles", + }, + { + "", + function() + require("telescope.builtin").buffers() + end, + desc = "[ ] Find existing buffers", + }, + { + "/", + function() + require("telescope.builtin").current_buffer_fuzzy_find() + end, + desc = "[/] Fuzzily search in current buffer", + }, + { + "s/", + function() + require("telescope.builtin").live_grep({ + grep_open_files = true, + prompt_title = "Live Grep in Open Files", + }) + end, + desc = "[S]earch [/] in Open Files", + }, + { + "st", + function() + require("telescope.builtin").treesitter() + end, + desc = "[S]earch [T]reesitter", + }, + { + "ss", + function() + require("telescope.builtin").builtin() + end, + desc = "[S]earch [S]elect Telescope", + }, + { + "sc", + function() + require("telescope.builtin").commands() + end, + desc = "[S]earch [C]ommands", + }, + { + "sh", + function() + require("telescope.builtin").help_tags() + end, + desc = "[S]earch [H]elp", + }, + { + "sm", + function() + require("telescope.builtin").man_pages() + end, + desc = "[S]earch [M]an pages", + }, + { + "sk", + function() + require("telescope.builtin").keymaps() + end, + desc = "[S]earch [K]eymaps", + }, + { + "sd", + function() + require("telescope.builtin").diagnostics() + end, + desc = "[S]earch [D]iagnostics", + }, + -- {"sr", function() require("telescope.builtin").resume() end, desc = '[S]earch [R]esume' }, + { + "s.", + function() + require("telescope.builtin").oldfiles() + end, + desc = '[S]earch Recent Files ("." for repeat)', + }, + { + "sq", + function() + require("telescope.builtin").quickfix() + end, + desc = "[S]earch [Q]uickfixlist", + }, + { + "sl", + function() + require("telescope.builtin").loclist() + end, + desc = "[S]earch [L]ocationlist", + }, + { + "sR", + function() + require("telescope.builtin").registers() + end, + desc = "[S]earch [R]egisters", + }, + { + "sa", + function() + require("telescope.builtin").autocommands() + end, + desc = "[S]earch [A]utocommands", + }, + + { + "gc", + function() + require("telescope.builtin").git_bcommits() + end, + desc = "[G]it buffer [C]commits", + }, + { + "gc", + function() + require("telescope.builtin").git_bcommits_range() + end, + desc = "[G]it [C]commits for selected range", + }, + { + "gC", + function() + require("telescope.builtin").git_commits() + end, + desc = "[G]it (all) [C]commits", + }, + { + "gb", + function() + require("telescope.builtin").git_branches() + end, + desc = "[G]it [B]ranches", + }, + { + "gs", + function() + require("telescope.builtin").git_status() + end, + desc = "[G]it [S]tatus", + }, + { + "gS", + function() + require("telescope.builtin").git_stash() + end, + desc = "[G]it [S]tash", + }, + { + "sr", + function() + require("telescope").extensions.refactoring.refactors() + end, + mode = { "n", "x" }, + desc = "[S]earch [R]efactor", + }, + }, config = function() local actions = require("telescope.actions") + local actions_layout = require("telescope.actions.layout") require("telescope").setup({ defaults = { sorting_strategy = "ascending", layout_config = { prompt_position = "top", + height = 0.95, + width = 0.95, + flip_columns = 200, + vertical = { mirror = true }, + }, + layout_strategy = "flex", + preview = { + filesize_limit = 0.1, -- MB }, scroll_strategy = "cycle", selection_strategy = "follow", color_devicons = false, mappings = { + n = { + [""] = actions_layout.toggle_preview, + ["d"] = actions.delete_buffer + actions.move_to_top, + ["a"] = actions.add_to_qflist, + ["s"] = actions.select_all, + }, i = { + ["jj"] = { "", type = "command" }, [""] = actions.move_selection_next, [""] = actions.move_selection_previous, + [""] = false, + [""] = actions_layout.toggle_preview, + [""] = actions.delete_buffer + actions.move_to_top, }, }, - 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" + }, + pickers = { + find_files = { + follow = true, + hidden = true, + find_command = { + "fd", + "--type", + "f", + "--color", + "never", }, - ["ui-select"] = { - require("telescope.themes").get_dropdown({ - -- even more opts - }), + }, + live_grep = { + additional_args = { + "--hidden", + "--fixed-strings", }, }, + buffers = { + initial_mode = "normal", + sort_lastused = true, + }, + current_buffer_fuzzy_find = { + require("telescope.themes").get_dropdown({ + winblend = 10, + previewer = false, + }), + }, + quickfix = { + initial_mode = "normal", + }, + loclist = { + initial_mode = "normal", + }, + registers = { + initial_mode = "normal", + }, + lsp_definitions = { + initial_mode = "normal", + }, + lsp_type_definitions = { + initial_mode = "normal", + }, + lsp_implementations = { + initial_mode = "normal", + }, + lsp_references = { + initial_mode = "normal", + }, + lsp_incoming_calls = { + initial_mode = "normal", + }, + lsp_outgoing_calls = { + initial_mode = "normal", + }, + }, + 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" + }, }, }) require("telescope").load_extension("fzf") require("telescope").load_extension("ui-select") - - local b = require("telescope.builtin") - - map.n("B", b.builtin) - map.n("/", b.live_grep) - map.n("?", b.grep_string) - map.n("f", function() - b.find_files({ - find_command = { - "fd", - "--type", - "file", - "--follow", - "--hidden", - "--exclude", - ".git", - }, - }) - end) - map.n("b", function() - b.buffers({ sort_lastused = true, initial_mode = "normal" }) - end) - - map.n("t", b.treesitter) - - map.n("c", b.commands) - map.n("h", b.help_tags) - map.n("m", b.man_pages) - map.n("k", b.keymaps) - map.n("Q", function() - b.quickfix({ initial_mode = "normal" }) - end) - map.n("L", function() - b.loclist({ initial_mode = "normal" }) - end) - map.n("R", function() - b.registers({ initial_mode = "normal" }) - end) - map.n("A", b.autocommands) - + require("telescope").load_extension("refactoring") vim.api.nvim_create_autocmd("LspAttach", { callback = function(event) - local bnmap = function(keys, func) - map.n(keys, func, { buffer = event.buf }) + local b = require("telescope.builtin") + local bnmap = function(keys, func, desc) + vim.keymap.set("n", keys, func, { buffer = event.buf, desc = "LSP: " .. desc }) end - bnmap("gd", function() - b.lsp_definitions({ initial_mode = "normal" }) - end) + bnmap("gd", b.lsp_definitions, "[G]oto [D]efinition") bnmap("gvd", function() - b.lsp_definitions({ initial_mode = "normal", jump_type = "vsplit" }) - end) + b.lsp_definitions({ jump_type = "vsplit" }) + end, "[G]oto in a [V]ertical split to [D]efinition") bnmap("gxd", function() - b.lsp_definitions({ initial_mode = "normal", jump_type = "split" }) - end) + b.lsp_definitions({ jump_type = "split" }) + end, "[G]oto in a [X]horizontal split to [D]efinition") bnmap("gtd", function() - b.lsp_definitions({ initial_mode = "normal", jump_type = "tab" }) - end) - bnmap("gi", function() - b.lsp_implementations({ initial_mode = "normal" }) - end) - bnmap("gvi", function() - b.lsp_implementations({ initial_mode = "normal", jump_type = "vsplit" }) - end) - bnmap("gxi", function() - b.lsp_implementations({ initial_mode = "normal", jump_type = "split" }) - end) - bnmap("gti", function() - b.lsp_implementations({ initial_mode = "normal", jump_type = "tab" }) - end) - bnmap("go", b.lsp_document_symbols) - bnmap("gS", b.lsp_dynamic_workspace_symbols) - bnmap("ge", function() - b.lsp_document_diagnostics({ initial_mode = "normal" }) - end) - bnmap("gE", function() - b.lsp_workspace_diagnostics({ initial_mode = "normal" }) - end) - bnmap("gr", function() - b.lsp_references({ initial_mode = "normal" }) - end) - bnmap("gic", function() - b.lsp_incoming_calls({ initial_mode = "normal" }) - end) - bnmap("goc", function() - b.lsp_outgoing_calls({ initial_mode = "normal" }) - end) + b.lsp_definitions({ jump_type = "tab" }) + end, "[G]oto in a [T]ab to [D]efinition") + bnmap("D", b.lsp_type_definitions, "Type [D]efinition") + bnmap("vD", function() + b.lsp_type_definitions({ jump_type = "vsplit" }) + end, "Open in a [V]ertical split Type [D]efinition") + bnmap("xD", function() + b.lsp_type_definitions({ jump_type = "split" }) + end, "Open in a [X]horizontal split Type [D]efinition") + bnmap("tD", function() + b.lsp_type_definitions({ jump_type = "tab" }) + end, "Open in a [T]ab Type [D]efinition") + bnmap("gri", b.lsp_implementations, "[G]oto [I]mplementation") + bnmap("grvi", function() + b.lsp_implementations({ jump_type = "vsplit" }) + end, "[G]oto in a [V]ertical split to [I]mplementation") + bnmap("grxi", function() + b.lsp_implementations({ jump_type = "split" }) + end, "[G]oto in a [X]horizontal split to [I]mplementation") + bnmap("grti", function() + b.lsp_implementations({ jump_type = "tab" }) + end, "[G]oto in a [T]ab to [I]mplementation") + bnmap("grr", b.lsp_references, "[G]oto [R]eferences") + bnmap("ic", b.lsp_incoming_calls, "[I]ncoming [C]alls") + bnmap("oc", b.lsp_outgoing_calls, "[O]utgoing [C]alls") + bnmap("gO", b.lsp_document_symbols, "d[O]ocument symbols") + bnmap( + "ws", + b.lsp_dynamic_workspace_symbols, + "[W]orkspace [S]ymbols" + ) end, }) end, @@ -134,6 +346,7 @@ return { build = "make", }, "nvim-telescope/telescope-ui-select.nvim", + "ThePrimeagen/refactoring.nvim", }, }, } diff --git a/home/.config/nvim/lua/custom/plugins/ts.lua b/home/.config/nvim/lua/custom/plugins/ts.lua index c2741e5..40b1209 100644 --- a/home/.config/nvim/lua/custom/plugins/ts.lua +++ b/home/.config/nvim/lua/custom/plugins/ts.lua @@ -1,155 +1,155 @@ return { { - 'nvim-treesitter/nvim-treesitter', + "aaronik/treewalker.nvim", + keys = { + { + "", + "Treewalker Up", + { "n", "v" }, + silent = true, + desc = "Moves up to the previous neighbor node", + }, + { + "", + "Treewalker Down", + { "n", "v" }, + silent = true, + desc = "Moves up to the next neighbor node", + }, + { + "", + "Treewalker Left", + { "n", "v" }, + silent = true, + desc = "Moves to the first ancestor node that's on a different line from the current node", + }, + { + "", + "Treewalker Right", + { "n", "v" }, + silent = true, + desc = "Moves to the next node down that's indented further than the current node", + }, + { + "Treewalker SwapUp", + "", + silent = true, + desc = "Swaps the highest node on the line upwards in the document", + }, + { + "", + "Treewalker SwapDown", + silent = true, + desc = "Swaps the biggest node on the line downward in the document", + }, + { + "", + "Treewalker SwapLeft", + silent = true, + desc = "Swap the node under the cursor with its previous neighbor", + }, + { + "", + "Treewalker SwapRight", + silent = true, + desc = "Swap the node under the cursor with its next neighbor", + }, + }, + opts = {}, + }, + { + "nvim-treesitter/nvim-treesitter", + branch = "main", + lazy = false, dependencies = { - 'nvim-treesitter/nvim-treesitter-textobjects', - "nvim-treesitter/nvim-treesitter-refactor", - "theHamsta/crazy-node-movement", - "theHamsta/nvim-treesitter-pairs", - "RRethy/nvim-treesitter-endwise", + -- "theHamsta/nvim-treesitter-pairs", -- Reneable once main branch is supported + { + "LiadOz/nvim-dap-repl-highlights", + opts = {}, + }, }, build = ":TSUpdate", config = function() - require("nvim-treesitter.configs").setup({ - ensure_installed = { - "bash", - "c", - "cmake", - "comment", - "cpp", - "css", - "diff", - "dockerfile", - "doxygen", - "fortran", - "git_config", - "git_rebase", - "gitattributes", - "gitcommit", - "gitignore", - "gpg", - "html", - "http", - "ini", - "javascript", - "jsdoc", - "json", - "jsonc", - "llvm", - "lua", - "luadoc", - "luap", - "make", - "markdown", - "markdown_inline", - "python", - "regex", - "rust", - "sql", - "tablegen", - "todotxt", - "toml", - "typescript", - "vim", - "vimdoc", - "xml", - "yaml", - }, - highlight = { - enable = true, - 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 }, - }, - 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 = { ["a"] = "@parameter.inner" }, - swap_previous = { ["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 = "%" }, - }, - node_movement = { - enable = true, - keymaps = { - move_up = "", - move_down = "", - move_left = "", - move_right = "", - swap_left = "", -- will only swap when one of "swappable_textobjects" is selected - swap_right = "", - select_current_node = "", - }, - swappable_textobjects = { '@function.outer', '@parameter.inner', '@statement.outer' }, - allow_switch_parents = true, -- more craziness by switching parents while staying on the same level, false prevents you from accidentally jumping out of a function - allow_next_parent = true, -- more craziness by going up one level if next node does not have children - }, - tree_docs = { - enable = true, - }, - endwise = { - enable = true, - }, + require("nvim-treesitter").install({ + "awk", + "bash", + "c", + "cmake", + "comment", + "cpp", + "css", + "csv", + "diff", + "dockerfile", + "dap_repl", + "doxygen", + "editorconfig", + "fortran", + "git_config", + "git_rebase", + "gitattributes", + "gitcommit", + "gitignore", + "groovy", + "gpg", + "hlsplaylist", + "html", + "http", + "ini", + "javascript", + "jq", + "jsdoc", + "json", + "jsonc", + "just", + "llvm", + "lua", + "luadoc", + "luap", + "make", + "markdown", + "markdown_inline", + "query", + "passwd", + "printf", + "python", + "regex", + "readline", + "requirements", + "rust", + "sql", + "ssh_config", + "strace", + "sxhkdrc", + "tablegen", + "tmux", + "todotxt", + "toml", + "typescript", + "vim", + "vimdoc", + "xcompose", + "xml", + "xresources", + "yaml", + }) + end, + }, + "RRethy/nvim-treesitter-endwise", + { "nvim-treesitter/nvim-treesitter-context", opts = {} }, + { + "JoosepAlviste/nvim-ts-context-commentstring", + config = function() + require("ts_context_commentstring").setup({ + enable_autocmd = false, }) - end + local get_option = vim.filetype.get_option + + vim.filetype.get_option = function(filetype, option) + return option == "commentstring" + and require("ts_context_commentstring.internal").calculate_commentstring() + or get_option(filetype, option) + end + end, }, - "nvim-treesitter/nvim-treesitter-context", } diff --git a/home/.config/nvim/lua/custom/plugins/ui.lua b/home/.config/nvim/lua/custom/plugins/ui.lua index ba9d4ac..a07eda8 100644 --- a/home/.config/nvim/lua/custom/plugins/ui.lua +++ b/home/.config/nvim/lua/custom/plugins/ui.lua @@ -1,24 +1,16 @@ return { { - "sainnhe/gruvbox-material", + "ellisonleao/gruvbox.nvim", 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 - }, - { - "norcalli/nvim-colorizer.lua", - event = "BufRead", - config = true + require("gruvbox").setup({}) + vim.o.background = "dark" + vim.cmd([[colorscheme gruvbox]]) + end, }, { "lukas-reineke/indent-blankline.nvim", + event = "BufRead", config = function() local highlight = { "RainbowRed", @@ -29,7 +21,7 @@ return { "RainbowViolet", "RainbowCyan", } - local hooks = require "ibl.hooks" + 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() @@ -43,38 +35,57 @@ return { end) vim.g.rainbow_delimiters = { highlight = highlight } - require("ibl").setup { scope = { highlight = highlight } } + require("ibl").setup({ + scope = { highlight = highlight }, + }) - hooks.register(hooks.type.SCOPE_HIGHLIGHT, - hooks.builtin.scope_highlight_from_extmark) - end + hooks.register( + hooks.type.SCOPE_HIGHLIGHT, + hooks.builtin.scope_highlight_from_extmark + ) + end, }, { - 'nvim-lualine/lualine.nvim', + "nvim-lualine/lualine.nvim", opts = { options = { icons_enabled = false, - theme = 'gruvbox_dark', - component_separators = '', - section_separators = '|', + theme = "gruvbox_dark", + component_separators = "", + section_separators = "|", + disabled_filetypes = { + winbar = { + "dap-view", + "dap-repl", + "dap-view-term", + }, + }, }, 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' } + lualine_a = { "filetype", { "filename", path = 1 } }, + lualine_b = { "%l/%L:%c:%o" }, + lualine_c = { "diff" }, + lualine_x = { "searchcount, selectioncount" }, + lualine_y = { "overseer", "copilot" }, + lualine_z = { "diagnostics" }, }, inactive_sections = { lualine_a = {}, lualine_b = {}, - lualine_c = { 'filename' }, + lualine_c = { "filename" }, lualine_x = {}, lualine_y = {}, - lualine_z = {} + lualine_z = {}, }, }, + dependencies = { + "AndreM222/copilot-lualine", + }, + }, + { + "jake-stewart/auto-cmdheight.nvim", + lazy = false, + opts = {}, }, - "https://gitlab.com/HiPhish/rainbow-delimiters.nvim", + -- "https://gitlab.com/HiPhish/rainbow-delimiters.nvim", } diff --git a/home/.config/nvim/lua/mapper.lua b/home/.config/nvim/lua/mapper.lua deleted file mode 100644 index c31aeca..0000000 --- a/home/.config/nvim/lua/mapper.lua +++ /dev/null @@ -1,84 +0,0 @@ -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, "" .. action .. "", opts, bufnr) -end - -M.plug = function(mode, keys, action, opts, bufnr) - M.map(mode, keys, "" .. 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 .. "", 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 -- cgit v1.2.3-70-g09d2