From f907a2be6b73187e4f4f1507a3c2293be7a69137 Mon Sep 17 00:00:00 2001 From: grimhilt Date: Wed, 28 Aug 2024 17:53:16 +0200 Subject: [PATCH] feat(nvim): fix mistake and improve for rust --- .config/nvim/init.lua | 62 ++++++- .config/nvim/lazy-lock.json | 7 +- .config/nvim/plugin/telescope.lua | 1 + .config/nvim/plugin_back/coc.lua | 184 +++++++++++++++++++ .config/nvim/plugin_back/harpoon.lua | 11 ++ .config/nvim/plugin_back/lsp.lua | 117 ++++++++++++ .config/nvim/plugin_back/neogen.lua | 5 + .config/nvim/plugin_back/packer_compiled.lua | 179 ++++++++++++++++++ .config/nvim/plugin_back/telescope.lua | 4 + .config/nvim/plugin_back/treesitter.lua | 35 ++++ 10 files changed, 597 insertions(+), 8 deletions(-) create mode 100644 .config/nvim/plugin_back/coc.lua create mode 100644 .config/nvim/plugin_back/harpoon.lua create mode 100644 .config/nvim/plugin_back/lsp.lua create mode 100755 .config/nvim/plugin_back/neogen.lua create mode 100644 .config/nvim/plugin_back/packer_compiled.lua create mode 100644 .config/nvim/plugin_back/telescope.lua create mode 100644 .config/nvim/plugin_back/treesitter.lua diff --git a/.config/nvim/init.lua b/.config/nvim/init.lua index 230a627..dcfa96e 100755 --- a/.config/nvim/init.lua +++ b/.config/nvim/init.lua @@ -19,9 +19,14 @@ vim.wo.number = true vim.o.mouse = 'a' -- Sync clipboard between OS and Neovim. +-- Schedule the setting after `UiEnter` because it can increase startup-time. -- Remove this option if you want your OS clipboard to remain independent. -- See `:help 'clipboard'` +vim.schedule(function() + vim.opt.clipboard = 'unnamedplus' +end) vim.o.clipboard = 'unnamedplus' +vim.opt.clipboard = 'unnamedplus' -- Enable break indent vim.o.breakindent = true @@ -54,9 +59,10 @@ vim.o.smartcase = true --number of line to show around the cursor vim.o.scrolloff = 8 +vim.g.rustfmt_autosave = 1 -- -vim.keymap.set("n", "pv", vim.cmd.Ex) +-- vim.keymap.set("n", "pv", vim.cmd.Ex) vim.keymap.set("n", "h", ":noh") --move line shortcut @@ -91,6 +97,7 @@ vim.keymap.set("n", "fp", ":bprev", {noremap = true}) -- wrap toggle vim.keymap.set("n", "w", function() vim.o.wrap = not vim.o.wrap end, {noremap = true}) + --[[ - https://learnxinyminutes.com/docs/lua/ @@ -132,8 +139,11 @@ require('lazy').setup({ 'nvim-lua/plenary.nvim', 'ThePrimeagen/harpoon', + -- Mini + { 'echasnovski/mini.files', version = false }, + -- Detect tabstop and shiftwidth automatically - 'tpope/vim-sleuth', + -- 'tpope/vim-sleuth', -- NOTE: This is where your plugins related to LSP can be installed. -- The configuration is done below. Search for lspconfig to find it below. @@ -188,6 +198,9 @@ require('lazy').setup({ config = function() require("nvim-autopairs").setup {} end }, + -- Rust + "simrat39/rust-tools.nvim", + -- Useful plugin to show you pending keybinds. { 'folke/which-key.nvim', opts = {} }, --{ @@ -395,6 +408,9 @@ require('telescope').setup { }, } +require('mini.files').setup() +vim.keymap.set("n", "pv", 'lua MiniFiles.open(vim.api.nvim_buf_get_name(0)); MiniFiles.reveal_cwd()', { desc = 'Open MiniFiles' }) + -- Enable telescope fzf native, if installed pcall(require('telescope').load_extension, 'fzf') @@ -468,7 +484,7 @@ vim.keymap.set('n', 'sr', require('telescope.builtin').resume, { desc = vim.defer_fn(function() require('nvim-treesitter.configs').setup { -- Add languages to be installed here that you want installed for treesitter - ensure_installed = { 'c', 'cpp', 'go', 'lua', 'python', 'rust', 'tsx', 'javascript', 'typescript', 'vimdoc', 'vim', 'bash' }, + ensure_installed = { 'rust', 'vimdoc', 'vim', 'bash' }, -- Autoinstall languages that are not installed. Defaults to false (but you can change for yourself!) auto_install = false, @@ -606,6 +622,42 @@ require('which-key').register({ require('mason').setup() require('mason-lspconfig').setup() +-- vim.api.nvim_create_augroup("LspAttach_inlayhints", {}) +-- vim.api.nvim_create_autocmd("LspAttach", { +-- group = "LspAttach_inlayhints", +-- callback = function(args) +-- if not (args.data and args.data.client_id) then +-- return +-- end +-- +-- local bufnr = args.buf +-- local client = vim.lsp.get_client_by_id(args.data.client_id) +-- require("lsp-inlayhints").on_attach(client, bufnr) +-- end, +-- }) + +-- rust +require("rust-tools").setup({ + tools = { + inlay_hints = { + auto = true + } + } +}) +vim.api.nvim_create_autocmd("LspAttach", { + group = vim.api.nvim_create_augroup("UserLspConfig", {}), + callback = function(args) + local client = vim.lsp.get_client_by_id(args.data.client_id) + if client.server_capabilities.inlayHintProvider then + vim.lsp.inlay_hint.enable(true, { 0 }) + end + -- whatever other lsp config you want + end +}) +-- toggle inlay hint +vim.keymap.set("n", "ri", function() vim.lsp.inlay_hint.enable(not vim.lsp.inlay_hint.is_enabled({0}), {0}) end) + + -- Enable the following language servers -- Feel free to add/remove any LSPs that you want here. They will automatically be installed. -- @@ -615,10 +667,10 @@ require('mason-lspconfig').setup() -- If you want to override the default filetypes that your language server will attach to you can -- define the property 'filetypes' to the map in question. local servers = { - clangd = {}, + -- clangd = {}, -- gopls = {}, -- pyright = {}, - -- rust_analyzer = {}, + rust_analyzer = {}, -- tsserver = {}, -- html = { filetypes = { 'html', 'twig', 'hbs'} }, diff --git a/.config/nvim/lazy-lock.json b/.config/nvim/lazy-lock.json index d239600..5e299d2 100644 --- a/.config/nvim/lazy-lock.json +++ b/.config/nvim/lazy-lock.json @@ -7,9 +7,10 @@ "fidget.nvim": { "branch": "main", "commit": "60404ba67044c6ab01894dd5bf77bd64ea5e09aa" }, "friendly-snippets": { "branch": "main", "commit": "dcd4a586439a1c81357d5b9d26319ae218cc9479" }, "harpoon": { "branch": "master", "commit": "ccae1b9bec717ae284906b0bf83d720e59d12b91" }, - "lazy.nvim": { "branch": "main", "commit": "28126922c9b54e35a192ac415788f202c3944c9f" }, + "lazy.nvim": { "branch": "main", "commit": "077102c5bfc578693f12377846d427f49bc50076" }, "mason-lspconfig.nvim": { "branch": "main", "commit": "21d33d69a81f6351e5a5f49078b2e4f0075c8e73" }, "mason.nvim": { "branch": "main", "commit": "3b5068f0fc565f337d67a2d315d935f574848ee7" }, + "mini.files": { "branch": "main", "commit": "2e262838a773c0bc3ccbc9c4bcf4a1a012497ea2" }, "neodev.nvim": { "branch": "main", "commit": "3157f2e876fd6223d36cfa76bee4709247d62fa5" }, "nvim-autopairs": { "branch": "master", "commit": "c6139ca0d5ad7af129ea6c89cb4c56093f2c034a" }, "nvim-cmp": { "branch": "main", "commit": "04e0ca376d6abdbfc8b52180f8ea236cbfddf782" }, @@ -18,10 +19,10 @@ "nvim-treesitter-textobjects": { "branch": "master", "commit": "7f00d94543f1fd37cab2afa2e9a6cd54e1c6b9ef" }, "onedark.nvim": { "branch": "master", "commit": "1230aaf2a427b2c5b73aba6e4a9a5881d3e69429" }, "plenary.nvim": { "branch": "master", "commit": "4f71c0c4a196ceb656c824a70792f3df3ce6bb6d" }, + "rust-tools.nvim": { "branch": "master", "commit": "676187908a1ce35ffcd727c654ed68d851299d3e" }, "telescope-fzf-native.nvim": { "branch": "main", "commit": "6c921ca12321edaa773e324ef64ea301a1d0da62" }, "telescope.nvim": { "branch": "0.1.x", "commit": "d90956833d7c27e73c621a61f20b29fdb7122709" }, "vim-fugitive": { "branch": "master", "commit": "2e88f14a585c014691904ba8fe39e6ea851c9422" }, "vim-rhubarb": { "branch": "master", "commit": "ee69335de176d9325267b0fd2597a22901d927b1" }, - "vim-sleuth": { "branch": "master", "commit": "1cc4557420f215d02c4d2645a748a816c220e99b" }, "which-key.nvim": { "branch": "main", "commit": "4433e5ec9a507e5097571ed55c02ea9658fb268a" } -} \ No newline at end of file +} diff --git a/.config/nvim/plugin/telescope.lua b/.config/nvim/plugin/telescope.lua index 93a4dfb..81a0863 100644 --- a/.config/nvim/plugin/telescope.lua +++ b/.config/nvim/plugin/telescope.lua @@ -1,4 +1,5 @@ local builtin = require('telescope.builtin') vim.keymap.set('n', 'pf', builtin.find_files, {noremap = true}) +vim.keymap.set('n', 'pg', builtin.live_grep, {noremap = true}) vim.keymap.set('n', '', builtin.git_files, {noremap = true}) diff --git a/.config/nvim/plugin_back/coc.lua b/.config/nvim/plugin_back/coc.lua new file mode 100644 index 0000000..f34bd2f --- /dev/null +++ b/.config/nvim/plugin_back/coc.lua @@ -0,0 +1,184 @@ +-- Some servers have issues with backup files, see #649 +vim.opt.backup = false +vim.opt.writebackup = false + +-- Having longer updatetime (default is 4000 ms = 4s) leads to noticeable +-- delays and poor user experience +vim.opt.updatetime = 300 + +-- Always show the signcolumn, otherwise it would shift the text each time +-- diagnostics appeared/became resolved +vim.opt.signcolumn = "yes" + +local keyset = vim.keymap.set +-- Autocomplete +function _G.check_back_space() + local col = vim.fn.col('.') - 1 + return col == 0 or vim.fn.getline('.'):sub(col, col):match('%s') ~= nil +end + +-- Use Tab for trigger completion with characters ahead and navigate +-- NOTE: There's always a completion item selected by default, you may want to enable +-- no select by setting `"suggest.noselect": true` in your configuration file +-- NOTE: Use command ':verbose imap ' to make sure Tab is not mapped by +-- other plugins before putting this into your config +local opts = {silent = true, noremap = true, expr = true, replace_keycodes = false} +keyset("i", "", 'coc#pum#visible() ? coc#pum#next(1) : v:lua.check_back_space() ? "" : coc#refresh()', opts) +keyset("i", "", [[coc#pum#visible() ? coc#pum#prev(1) : "\"]], opts) + +-- Make to accept selected completion item or notify coc.nvim to format +-- u breaks current undo, please make your own choice +keyset("i", "", [[coc#pum#visible() ? coc#pum#confirm() : "\u\\=coc#on_enter()\"]], opts) + +-- Use to trigger snippets +keyset("i", "", "(coc-snippets-expand-jump)") +-- Use to trigger completion +keyset("i", "", "coc#refresh()", {silent = true, expr = true}) + +-- Use `[g` and `]g` to navigate diagnostics +-- Use `:CocDiagnostics` to get all diagnostics of current buffer in location list +keyset("n", "[g", "(coc-diagnostic-prev)", {silent = true}) +keyset("n", "]g", "(coc-diagnostic-next)", {silent = true}) + +-- GoTo code navigation +keyset("n", "gd", "(coc-definition)", {silent = true}) +keyset("n", "gy", "(coc-type-definition)", {silent = true}) +keyset("n", "gi", "(coc-implementation)", {silent = true}) +keyset("n", "gr", "(coc-references)", {silent = true}) + + +-- Use K to show documentation in preview window +function _G.show_docs() + local cw = vim.fn.expand('') + if vim.fn.index({'vim', 'help'}, vim.bo.filetype) >= 0 then + vim.api.nvim_command('h ' .. cw) + elseif vim.api.nvim_eval('coc#rpc#ready()') then + vim.fn.CocActionAsync('doHover') + else + vim.api.nvim_command('!' .. vim.o.keywordprg .. ' ' .. cw) + end +end +keyset("n", "K", 'lua _G.show_docs()', {silent = true}) + + +-- Highlight the symbol and its references on a CursorHold event(cursor is idle) +vim.api.nvim_create_augroup("CocGroup", {}) +vim.api.nvim_create_autocmd("CursorHold", { + group = "CocGroup", + command = "silent call CocActionAsync('highlight')", + desc = "Highlight symbol under cursor on CursorHold" +}) + + +-- Symbol renaming +keyset("n", "rn", "(coc-rename)", {silent = true}) + + +-- Formatting selected code +keyset("x", "f", "(coc-format-selected)", {silent = true}) +keyset("n", "f", "(coc-format-selected)", {silent = true}) + + +-- Setup formatexpr specified filetype(s) +vim.api.nvim_create_autocmd("FileType", { + group = "CocGroup", + pattern = "typescript,json", + command = "setl formatexpr=CocAction('formatSelected')", + desc = "Setup formatexpr specified filetype(s)." +}) + +-- Update signature help on jump placeholder +vim.api.nvim_create_autocmd("User", { + group = "CocGroup", + pattern = "CocJumpPlaceholder", + command = "call CocActionAsync('showSignatureHelp')", + desc = "Update signature help on jump placeholder" +}) + +-- Apply codeAction to the selected region +-- Example: `aap` for current paragraph +local opts = {silent = true, nowait = true} +keyset("x", "a", "(coc-codeaction-selected)", opts) +keyset("n", "a", "(coc-codeaction-selected)", opts) + +-- Remap keys for apply code actions at the cursor position. +keyset("n", "ac", "(coc-codeaction-cursor)", opts) +-- Remap keys for apply source code actions for current file. +keyset("n", "as", "(coc-codeaction-source)", opts) +-- Apply the most preferred quickfix action on the current line. +keyset("n", "qf", "(coc-fix-current)", opts) + +-- Remap keys for apply refactor code actions. +keyset("n", "re", "(coc-codeaction-refactor)", { silent = true }) +keyset("x", "r", "(coc-codeaction-refactor-selected)", { silent = true }) +keyset("n", "r", "(coc-codeaction-refactor-selected)", { silent = true }) + +-- Run the Code Lens actions on the current line +keyset("n", "cl", "(coc-codelens-action)", opts) + + +-- Map function and class text objects +-- NOTE: Requires 'textDocument.documentSymbol' support from the language server +keyset("x", "if", "(coc-funcobj-i)", opts) +keyset("o", "if", "(coc-funcobj-i)", opts) +keyset("x", "af", "(coc-funcobj-a)", opts) +keyset("o", "af", "(coc-funcobj-a)", opts) +keyset("x", "ic", "(coc-classobj-i)", opts) +keyset("o", "ic", "(coc-classobj-i)", opts) +keyset("x", "ac", "(coc-classobj-a)", opts) +keyset("o", "ac", "(coc-classobj-a)", opts) + + +-- Remap and to scroll float windows/popups +---@diagnostic disable-next-line: redefined-local +local opts = {silent = true, nowait = true, expr = true} +keyset("n", "", 'coc#float#has_scroll() ? coc#float#scroll(1) : ""', opts) +keyset("n", "", 'coc#float#has_scroll() ? coc#float#scroll(0) : ""', opts) +keyset("i", "", + 'coc#float#has_scroll() ? "=coc#float#scroll(1)" : ""', opts) +keyset("i", "", + 'coc#float#has_scroll() ? "=coc#float#scroll(0)" : ""', opts) +keyset("v", "", 'coc#float#has_scroll() ? coc#float#scroll(1) : ""', opts) +keyset("v", "", 'coc#float#has_scroll() ? coc#float#scroll(0) : ""', opts) + + +-- Use CTRL-S for selections ranges +-- Requires 'textDocument/selectionRange' support of language server +keyset("n", "", "(coc-range-select)", {silent = true}) +keyset("x", "", "(coc-range-select)", {silent = true}) + + +-- Add `:Format` command to format current buffer +vim.api.nvim_create_user_command("Format", "call CocAction('format')", {}) + +-- " Add `:Fold` command to fold current buffer +vim.api.nvim_create_user_command("Fold", "call CocAction('fold', )", {nargs = '?'}) + +-- Add `:OR` command for organize imports of the current buffer +vim.api.nvim_create_user_command("OR", "call CocActionAsync('runCommand', 'editor.action.organizeImport')", {}) + +-- Add (Neo)Vim's native statusline support +-- NOTE: Please see `:h coc-status` for integrations with external plugins that +-- provide custom statusline: lightline.vim, vim-airline +vim.opt.statusline:prepend("%{coc#status()}%{get(b:,'coc_current_function','')}") + +-- Mappings for CoCList +-- code actions and coc stuff +---@diagnostic disable-next-line: redefined-local +local opts = {silent = true, nowait = true} +-- Show all diagnostics +keyset("n", "a", ":CocList diagnostics", opts) +-- Manage extensions +keyset("n", "e", ":CocList extensions", opts) +-- Show commands +keyset("n", "c", ":CocList commands", opts) +-- Find symbol of current document +keyset("n", "o", ":CocList outline", opts) +-- Search workspace symbols +keyset("n", "s", ":CocList -I symbols", opts) +-- Do default action for next item +keyset("n", "j", ":CocNext", opts) +-- Do default action for previous item +keyset("n", "k", ":CocPrev", opts) +-- Resume latest coc list +keyset("n", "p", ":CocListResume", opts) diff --git a/.config/nvim/plugin_back/harpoon.lua b/.config/nvim/plugin_back/harpoon.lua new file mode 100644 index 0000000..fcb2fdc --- /dev/null +++ b/.config/nvim/plugin_back/harpoon.lua @@ -0,0 +1,11 @@ +local mark = require("harpoon.mark") +local ui = require("harpoon.ui") + +vim.keymap.set("n", "q", mark.add_file) +vim.keymap.set("n", "", ui.toggle_quick_menu) + +vim.keymap.set("n", "", function() ui.nav_file(1) end) +vim.keymap.set("n", "", function() ui.nav_file(2) end) +vim.keymap.set("n", "", function() ui.nav_file(3) end) +vim.keymap.set("n", "", function() ui.nav_file(4) end) +vim.keymap.set("n", "", function() ui.nav_file(5) end) diff --git a/.config/nvim/plugin_back/lsp.lua b/.config/nvim/plugin_back/lsp.lua new file mode 100644 index 0000000..1099264 --- /dev/null +++ b/.config/nvim/plugin_back/lsp.lua @@ -0,0 +1,117 @@ +-- Initialize Mason and specify which language servers to install +--require("mason").setup() +--require("mason-lspconfig").setup({ +-- ensured_installed = { "rust_analyzer" } +--}) +-- +---- Define lspconfig settings for rust_analyzer +--local on_attach = function(_, _) +-- local opts = { buffer = bufnr, remap = false } +-- vim.keymap.set("n", "gd", function() vim.lsp.buf.definition() end, opts) +--end +-- +--local capabilities = require('cmp_nvim_lsp').default_capabilities() +-- +---- Configure autocomplete using nvim-cmp +--local cmp = require("cmp") +--cmp.setup({ +-- mapping = { +-- [""] = cmp.mapping.select_prev_item(), +-- [""] = cmp.mapping.select_next_item(), +-- [""] = cmp.mapping.scroll_docs(-4), +-- [""] = cmp.mapping.scroll_docs(4), +-- [""] = cmp.mapping.complete(), +-- [""] = cmp.mapping.confirm({ select = true }), +-- [""] = cmp.mapping.confirm({ select = true }), +-- }, +-- sources = { +-- { name = 'nvim_lsp' }, +-- { name = 'buffer' }, +-- { name = 'path' }, +-- }, +-- experimental = { ghost_text = false }, +-- formatting = { fields = { 'menu', 'abbr', 'kind' } }, +-- confirm_opts = { behavior = cmp.ConfirmBehavior.Replace, select = false }, +-- window = { +-- --completion = cmp.config.window.bordered(), +-- --documentation = cmp.config.window.bordered(), +-- }, +-- capabilities = capabilities, +--}) +-- +---- Set up Rust Analyzer +--local lspconfig = require('lspconfig') +--lspconfig.rust_analyzer.setup { +-- capabilities = capabilities, +-- on_attach = on_attach +--} +--vim.keymap.set('n', 'e', vim.diagnostic.open_float) +--vim.keymap.set('n', '[d', vim.diagnostic.goto_prev) +--vim.keymap.set('n', ']d', vim.diagnostic.goto_next) +---- vim.keymap.set('n', 'q', vim.diagnostic.setloclist) + + +-- old +--require("mason").setup() +--require("mason-lspconfig").setup({ +-- ensure_installed = { "rust_analyzer" } +--}) +-- +--local on_attach = function(_, _) +-- local opts = {buffer = bufnr, remap = false} +-- vim.keymap.set("n", "gd", function() vim.lsp.buf.definition() end, opts) +--end +-- +--local capabilities = require('cmp_nvim_lsp').default_capabilities() +--require("configs.nvim-cmp") +--require('nvim-cmp').setup{} +--require('cmp').setup({ +-- mapping = { +-- [''] = cmp.mapping.select_prev_item(), +-- [''] = cmp.mapping.select_next_item(), +-- [''] = cmp.mapping.scroll_docs(-4), +-- [''] = cmp.mapping.scroll_docs(4), +-- [''] = cmp.mapping.complete(), +-- [''] = cmp.mapping.confirm({ select = true }), +-- }, +-- sources = { +-- { name = 'nvim_lsp' }, +-- { name = 'buffer' }, +-- { name = 'path' }, +-- }, +-- experimental = { ghost_text = false }, +-- formatting = { fields = { 'menu', 'abbr', 'kind' } }, +-- confirm_opts = { behavior = cmp.ConfirmBehavior.Replace, select = false }, +-- window = { +-- completion = cmp.config.window.bordered(), +-- documentation = cmp.config.window.bordered(), +-- }, +-- capabilities = capabilities, +--}) +-- +-- +--require("lspconfig").rust_analyzer.setup { +-- capabilities = capabilities +-- on_attach = on_attach +--} + +--local lsp = require('lsp-zero').preset({}) +-- +-- lsp.on_attach(function(client, bufnr) +-- local opts = {buffer = bufnr, remap = false} +-- +-- vim.keymap.set("n", "gd", function() vim.lsp.buf.definition() end, opts) +-- end) +-- +----lsp['rust_analyzer'].setup({ +---- capabilities = capabilities, +---- on_attach = on_attach +----}) +-- +--lsp.ensure_installed({ +-- 'tsserver', +-- 'eslint', +-- 'rust_analyzer' +--}) +--lsp.setup() +----lsp.rust_analyzer.setup() diff --git a/.config/nvim/plugin_back/neogen.lua b/.config/nvim/plugin_back/neogen.lua new file mode 100755 index 0000000..fe113a9 --- /dev/null +++ b/.config/nvim/plugin_back/neogen.lua @@ -0,0 +1,5 @@ +--require('neogen').generate() +--local opts = { noremap = true, silent = true } +-- +--vim.api.nvim_set_keymap("n", "nf", ":lua require('neogen').generate()", opts) + diff --git a/.config/nvim/plugin_back/packer_compiled.lua b/.config/nvim/plugin_back/packer_compiled.lua new file mode 100644 index 0000000..f86cd30 --- /dev/null +++ b/.config/nvim/plugin_back/packer_compiled.lua @@ -0,0 +1,179 @@ +-- Automatically generated packer.nvim plugin loader code + +if vim.api.nvim_call_function('has', {'nvim-0.5'}) ~= 1 then + vim.api.nvim_command('echohl WarningMsg | echom "Invalid Neovim version for packer.nvim! | echohl None"') + return +end + +vim.api.nvim_command('packadd packer.nvim') + +local no_errors, error_msg = pcall(function() + +_G._packer = _G._packer or {} +_G._packer.inside_compile = true + +local time +local profile_info +local should_profile = false +if should_profile then + local hrtime = vim.loop.hrtime + profile_info = {} + time = function(chunk, start) + if start then + profile_info[chunk] = hrtime() + else + profile_info[chunk] = (hrtime() - profile_info[chunk]) / 1e6 + end + end +else + time = function(chunk, start) end +end + +local function save_profiles(threshold) + local sorted_times = {} + for chunk_name, time_taken in pairs(profile_info) do + sorted_times[#sorted_times + 1] = {chunk_name, time_taken} + end + table.sort(sorted_times, function(a, b) return a[2] > b[2] end) + local results = {} + for i, elem in ipairs(sorted_times) do + if not threshold or threshold and elem[2] > threshold then + results[i] = elem[1] .. ' took ' .. elem[2] .. 'ms' + end + end + if threshold then + table.insert(results, '(Only showing plugins that took longer than ' .. threshold .. ' ms ' .. 'to load)') + end + + _G._packer.profile_output = results +end + +time([[Luarocks path setup]], true) +local package_path_str = "/home/grimhilt/.cache/nvim/packer_hererocks/2.1.1693350652/share/lua/5.1/?.lua;/home/grimhilt/.cache/nvim/packer_hererocks/2.1.1693350652/share/lua/5.1/?/init.lua;/home/grimhilt/.cache/nvim/packer_hererocks/2.1.1693350652/lib/luarocks/rocks-5.1/?.lua;/home/grimhilt/.cache/nvim/packer_hererocks/2.1.1693350652/lib/luarocks/rocks-5.1/?/init.lua" +local install_cpath_pattern = "/home/grimhilt/.cache/nvim/packer_hererocks/2.1.1693350652/lib/lua/5.1/?.so" +if not string.find(package.path, package_path_str, 1, true) then + package.path = package.path .. ';' .. package_path_str +end + +if not string.find(package.cpath, install_cpath_pattern, 1, true) then + package.cpath = package.cpath .. ';' .. install_cpath_pattern +end + +time([[Luarocks path setup]], false) +time([[try_loadstring definition]], true) +local function try_loadstring(s, component, name) + local success, result = pcall(loadstring(s), name, _G.packer_plugins[name]) + if not success then + vim.schedule(function() + vim.api.nvim_notify('packer.nvim: Error running ' .. component .. ' for ' .. name .. ': ' .. result, vim.log.levels.ERROR, {}) + end) + end + return result +end + +time([[try_loadstring definition]], false) +time([[Defining packer_plugins]], true) +_G.packer_plugins = { + ["cmp-buffer"] = { + loaded = true, + path = "/home/grimhilt/.local/share/nvim/site/pack/packer/start/cmp-buffer", + url = "https://github.com/hrsh7th/cmp-buffer" + }, + ["cmp-nvim-lsp"] = { + loaded = true, + path = "/home/grimhilt/.local/share/nvim/site/pack/packer/start/cmp-nvim-lsp", + url = "https://github.com/hrsh7th/cmp-nvim-lsp" + }, + ["cmp-path"] = { + loaded = true, + path = "/home/grimhilt/.local/share/nvim/site/pack/packer/start/cmp-path", + url = "https://github.com/hrsh7th/cmp-path" + }, + ["coc.nvim"] = { + loaded = true, + path = "/home/grimhilt/.local/share/nvim/site/pack/packer/start/coc.nvim", + url = "https://github.com/neoclide/coc.nvim" + }, + harpoon = { + loaded = true, + path = "/home/grimhilt/.local/share/nvim/site/pack/packer/start/harpoon", + url = "https://github.com/theprimeagen/harpoon" + }, + ["mason-lspconfig.nvim"] = { + loaded = true, + path = "/home/grimhilt/.local/share/nvim/site/pack/packer/start/mason-lspconfig.nvim", + url = "https://github.com/williamboman/mason-lspconfig.nvim" + }, + ["mason.nvim"] = { + loaded = true, + path = "/home/grimhilt/.local/share/nvim/site/pack/packer/start/mason.nvim", + url = "https://github.com/williamboman/mason.nvim" + }, + ["nvim-autopairs"] = { + config = { "\27LJ\2\n@\0\0\3\0\3\0\a6\0\0\0'\2\1\0B\0\2\0029\0\2\0004\2\0\0B\0\2\1K\0\1\0\nsetup\19nvim-autopairs\frequire\0" }, + loaded = true, + path = "/home/grimhilt/.local/share/nvim/site/pack/packer/start/nvim-autopairs", + url = "https://github.com/windwp/nvim-autopairs" + }, + ["nvim-cmp"] = { + loaded = true, + path = "/home/grimhilt/.local/share/nvim/site/pack/packer/start/nvim-cmp", + url = "https://github.com/hrsh7th/nvim-cmp" + }, + ["nvim-lspconfig"] = { + loaded = true, + path = "/home/grimhilt/.local/share/nvim/site/pack/packer/start/nvim-lspconfig", + url = "https://github.com/neovim/nvim-lspconfig" + }, + ["nvim-treesitter"] = { + loaded = true, + path = "/home/grimhilt/.local/share/nvim/site/pack/packer/start/nvim-treesitter", + url = "https://github.com/nvim-treesitter/nvim-treesitter" + }, + ["onedark.nvim"] = { + loaded = true, + path = "/home/grimhilt/.local/share/nvim/site/pack/packer/start/onedark.nvim", + url = "https://github.com/navarasu/onedark.nvim" + }, + onehalf = { + loaded = true, + path = "/home/grimhilt/.local/share/nvim/site/pack/packer/start/onehalf", + url = "https://github.com/sonph/onehalf" + }, + ["packer.nvim"] = { + loaded = true, + path = "/home/grimhilt/.local/share/nvim/site/pack/packer/start/packer.nvim", + url = "https://github.com/wbthomason/packer.nvim" + }, + ["plenary.nvim"] = { + loaded = true, + path = "/home/grimhilt/.local/share/nvim/site/pack/packer/start/plenary.nvim", + url = "https://github.com/nvim-lua/plenary.nvim" + }, + ["telescope.nvim"] = { + loaded = true, + path = "/home/grimhilt/.local/share/nvim/site/pack/packer/start/telescope.nvim", + url = "https://github.com/nvim-telescope/telescope.nvim" + } +} + +time([[Defining packer_plugins]], false) +-- Config for: nvim-autopairs +time([[Config for nvim-autopairs]], true) +try_loadstring("\27LJ\2\n@\0\0\3\0\3\0\a6\0\0\0'\2\1\0B\0\2\0029\0\2\0004\2\0\0B\0\2\1K\0\1\0\nsetup\19nvim-autopairs\frequire\0", "config", "nvim-autopairs") +time([[Config for nvim-autopairs]], false) + +_G._packer.inside_compile = false +if _G._packer.needs_bufread == true then + vim.cmd("doautocmd BufRead") +end +_G._packer.needs_bufread = false + +if should_profile then save_profiles() end + +end) + +if not no_errors then + error_msg = error_msg:gsub('"', '\\"') + vim.api.nvim_command('echohl ErrorMsg | echom "Error in packer_compiled: '..error_msg..'" | echom "Please check your config for correctness" | echohl None') +end diff --git a/.config/nvim/plugin_back/telescope.lua b/.config/nvim/plugin_back/telescope.lua new file mode 100644 index 0000000..93a4dfb --- /dev/null +++ b/.config/nvim/plugin_back/telescope.lua @@ -0,0 +1,4 @@ +local builtin = require('telescope.builtin') + +vim.keymap.set('n', 'pf', builtin.find_files, {noremap = true}) +vim.keymap.set('n', '', builtin.git_files, {noremap = true}) diff --git a/.config/nvim/plugin_back/treesitter.lua b/.config/nvim/plugin_back/treesitter.lua new file mode 100644 index 0000000..a8322c0 --- /dev/null +++ b/.config/nvim/plugin_back/treesitter.lua @@ -0,0 +1,35 @@ +require'nvim-treesitter.configs'.setup { + -- A list of parser names, or "all" (the five listed parsers should always be installed) + ensure_installed = { "javascript", "typescript", "rust", "c", "lua", "vim", "vimdoc", "query" }, + + -- Install parsers synchronously (only applied to `ensure_installed`) + sync_install = false, + + -- Automatically install missing parsers when entering buffer + -- Recommendation: set to false if you don't have `tree-sitter` CLI installed locally + auto_install = true, + + highlight = { + enable = true, + + -- NOTE: these are the names of the parsers and not the filetype. (for example if you want to + -- disable highlighting for the `tex` filetype, you need to include `latex` in this list as this is + -- the name of the parser) + -- list of language that will be disabled + disable = { }, + -- Or use a function for more flexibility, e.g. to disable slow treesitter highlight for large files + disable = function(lang, buf) + local max_filesize = 100 * 1024 -- 100 KB + local ok, stats = pcall(vim.loop.fs_stat, vim.api.nvim_buf_get_name(buf)) + if ok and stats and stats.size > max_filesize then + return true + end + end, + + -- Setting this to true will run `:h syntax` and tree-sitter at the same time. + -- Set this to `true` if you depend on 'syntax' being enabled (like for indentation). + -- Using this option may slow down your editor, and you may see some duplicate highlights. + -- Instead of true it can also be a list of languages + additional_vim_regex_highlighting = false, + }, +}