home-manager/profiles/nvim/lua/config/keymaps.lua

   1 -- Navigating text
   2 vim.keymap.set("n", "i", "gk", {})
   3 vim.keymap.set("n", "k", "gj", {})
   4 vim.keymap.set("n", "j", "<Left>", {})
   5 vim.keymap.set("n", "l", "<Right>", {})
   6 vim.keymap.set("x", "i", "gk", {})
   7 vim.keymap.set("x", "k", "gj", {})
   8 vim.keymap.set("x", "j", "<Left>", {})
   9 vim.keymap.set("x", "l", "<Right>", {})
  10 vim.keymap.set("n", "J", "<Home>", {})
  11 vim.keymap.set("n", "L", "<End>", {})
  12
  13 -- Navigating windows
  14 vim.keymap.set("n", "<C-w>k", ":wincmd j<CR>", {})
  15 vim.keymap.set("n", "<C-w>i", ":wincmd k<CR>", {})
  16 vim.keymap.set("n", "<C-w>j", ":wincmd h<CR>", {})
  17 vim.keymap.set("n", "<C-w>l", ":wincmd l<CR>", {})
  18
  19 -- Navigating with LSP
  20 vim.keymap.set("n", "gd", function()
  21         vim.lsp.buf.definition()
  22 end, { silent = true, desc = "Go to definition" })
  23 local function filterDuplicates(array)
  24         local uniqueArray = {}
  25         for _, tableA in ipairs(array) do
  26                 local isDuplicate = false
  27                 for _, tableB in ipairs(uniqueArray) do
  28                         if vim.deep_equal(tableA, tableB) then
  29                                 isDuplicate = true
  30                                 break
  31                         end
  32                 end
  33                 if not isDuplicate then
  34                         table.insert(uniqueArray, tableA)
  35                 end
  36         end
  37         return uniqueArray
  38 end
  39 vim.keymap.set("n", "gr", function()
  40         vim.lsp.buf.references(nil, {
  41                 on_list = function(options)
  42                         options.items = filterDuplicates(options.items)
  43                         vim.fn.setqflist({}, " ", options)
  44                         vim.cmd("botright copen")
  45                 end,
  46         })
  47 end, { silent = true, desc = "List references in the quickfix list" })
  48 vim.keymap.set("n", "tt", function()
  49         vim.lsp.buf.hover()
  50 end, { silent = true, desc = "hover" })
  51
  52 -- Navigating the buffer list
  53 -- vim.keymap.set("n", "<C-i>", ":bprevious!<CR>", { silent = true })
  54 -- vim.keymap.set("n", "<C-k>", ":bnext!<CR>", { silent = true })
  55 vim.keymap.set("n", "<C-i>", function()
  56         local manager = require("neo-tree.sources.manager")
  57         local state = manager.get_state("buffers")
  58         if state.tree == nil then
  59                 require("neo-tree.command").execute({ reveal = true })
  60         end
  61         local renderer = require("neo-tree.ui.renderer")
  62         local scroll_padding = 3
  63         renderer.focus_node(state, nil, true, -1, scroll_padding)
  64         local node = state.tree:get_node()
  65         if node.type == "directory" then
  66                 return -- state.commands.open(state) would state.commands.toggle_node(state)
  67         else
  68                 state.commands.open(state)
  69         end
  70 end, { silent = true, desc = "Navigate down buffers in neo-tree's order" })
  71
  72 vim.keymap.set("n", "<C-k>", function()
  73         local manager = require("neo-tree.sources.manager")
  74         local state = manager.get_state("buffers")
  75         if state.tree == nil then
  76                 require("neo-tree.command").execute({ reveal = true })
  77         end
  78         local renderer = require("neo-tree.ui.renderer")
  79         local scroll_padding = 3
  80         renderer.focus_node(state, nil, true, 1, scroll_padding)
  81         local node = state.tree:get_node()
  82         if node.type == "directory" then
  83                 return -- state.commands.open(state) would state.commands.toggle_node(state)
  84         else
  85                 state.commands.open(state)
  86         end
  87 end, { silent = true, desc = "Navigate down buffers in neo-tree's order" })
  88 vim.keymap.set("n", "m", "<leader>fb", { desc = "Switch buffer", silent = true })
  89 vim.keymap.set("n", "<leader>m", ":buffer #<CR>", { desc = "Go to last buffer", silent = true })
  90
  91 -- Navigating the location list
  92 -- vim.keymap.set("n", "<C-j>", ":lprevious<CR>", {})
  93 -- vim.keymap.set("n", "<C-l>", ":lnext<CR>", {})
  94 vim.keymap.set("n", "<C-j>", function(opts)
  95         local trouble = require("trouble")
  96         if not trouble.is_open() then
  97                 trouble.open()
  98         else
  99                 trouble.prev({ skip_groups = true, jump = true })
 100         end
 101 end, {})
 102 vim.keymap.set("n", "<C-l>", function(opts)
 103         local trouble = require("trouble")
 104         if not trouble.is_open() then
 105                 trouble.open()
 106         else
 107                 trouble.next({ skip_groups = true, jump = true })
 108         end
 109 end, {})
 110
 111 -- Navigating the quickfix list
 112 vim.keymap.set("n", "<C-u>", ":cprevious<CR>", {})
 113 vim.keymap.set("n", "<C-o>", ":cnext<CR>", {})
 114
 115 -- Modifying text
 116 --- Maintain Visual Mode after shifting > and <
 117 vim.keymap.set("v", "<", "<gv", {})
 118 vim.keymap.set("v", ">", ">gv", {})
 119 --- Copy line
 120 vim.keymap.set("n", "Y", "Vy", {})
 121 --- Joining lines
 122 vim.keymap.set("n", "K", ":join<CR>", {})
 123
 124 vim.keymap.set("n", "rr", function(opts)
 125         vim.lsp.buf.rename()
 126 end, {})
 127
 128 -- Searching text
 129 local search_buffer = function(pattern)
 130         vim.opt.hlsearch = true
 131         vim.fn.setreg("/", pattern)
 132 end
 133 -- Alternative to Telescope live_grep({ grep_open_files = true })
 134 -- followed by <C-q> to but the results in a quicklist.
 135 local search_buffers = function(pattern)
 136         vim.opt.hlsearch = true
 137         vim.fn.setreg("/", pattern)
 138         vim.api.nvim_command(string.format(
 139                 "vimgrep /%s/g %s",
 140                 pattern,
 141                 vim.fn.join(
 142                         vim.tbl_map(function(n)
 143                                 return vim.fn.fnameescape(n.name)
 144                         end, vim.fn.getbufinfo({ buflisted = 1 })),
 145                         " "
 146                 )
 147         ))
 148 end
 149 vim.api.nvim_create_user_command("G", function(opts)
 150         search_buffers(vim.fn.join(opts.fargs, " "))
 151 end, { desc = "Search argument in all buffers", nargs = 1 })
 152 vim.api.nvim_create_user_command("Bclose", function(opts)
 153         vim.tbl_map(function(b)
 154                 vim.api.nvim_buf_delete(b.bufnr, { force = false, unload = false })
 155         end, vim.fn.getbufinfo({ buflisted = 1 }))
 156         local manager = require("neo-tree.sources.manager")
 157         local utils = require("neo-tree.utils")
 158         local refresh = utils.wrap(manager.refresh, "buffers")
 159         refresh()
 160 end, { desc = "Close all buffers", nargs = 0 })
 161
 162 vim.keymap.set("n", "*", function()
 163         search_buffer("\\<" .. vim.fn.expand("<cword>") .. "\\>")
 164 end, { silent = true, desc = "Search word under cursor in current buffer" })
 165 vim.keymap.set("n", "<C-n>", function()
 166         search_buffers("\\<" .. vim.fn.expand("<cword>") .. "\\>")
 167 end, { silent = true, desc = "Search word under cursor in all buffers" })
 168
 169 vim.keymap.set("n", "µ", function()
 170         search_buffer(vim.fn.expand("<cword>"))
 171 end, { silent = true, desc = "Search subword under cursor in current buffers" })
 172 vim.keymap.set("n", "<C-m>", function()
 173         search_buffers(vim.fn.expand("<cword>"))
 174 end, { silent = true, desc = "Search subword under cursor in all buffers" })