.gitignore

+lazy-lock.json

README.md

+# NeoVim configuration
+
+## Neovim installation process (Arch based distros)
+
+```bash
+sudo pacman -S neovim
+```
+
+## Removing previous config
+
+**I highly encourage you to backup your previous configuration that should be
+located at `$HOME/.config/nvim`**
+
+```bash
+rm -rf ~/.config/nvim
+rm -rf ~/.local/share/nvim
+```
+
+## Using my config
+
+```bash
+git clone https://gitedu.hesge.ch/iliya.saroukha/nvim_config.git ~/.config/nvim
+```

init.lua

+require("config.lazy")
+require("config.keymaps")
+require("config.set")
+require("config.autocmds")
+
+vim.g.netrw_browse_split = 0
+vim.g.netrw_banner = 0
+vim.g.netrw_liststyle = 0
+vim.g.netrw_winsize = 25

lua/config/autocmds.lua

+vim.cmd [[autocmd! ColorScheme * highlight NormalFloat bg=#1f1d2e guibg=#1f1d2e]]
+vim.cmd [[autocmd! ColorScheme * highlight FloatBorder guifg=#ea9a97]]
+vim.cmd [[autocmd BufWritePre * lua vim.lsp.buf.format()]]
+
+-- [[ Highlight on yank ]]
+-- See `:help vim.highlight.on_yank()`
+local highlight_group = vim.api.nvim_create_augroup('YankHighlight', { clear = true })
+vim.api.nvim_create_autocmd('TextYankPost', {
+    callback = function()
+        vim.highlight.on_yank(
+            {
+                higroup = 'IncSearch',
+                timeout = 60,
+            }
+        )
+    end,
+    group = highlight_group,
+    pattern = '*',
+})

lua/config/keymaps.lua

+vim.g.mapleader = " "
+vim.keymap.set("n", "<leader>pv", vim.cmd.Ex)
+
+vim.keymap.set("v", "J", ":m '>+1<CR>gv=gv")
+vim.keymap.set("v", "K", ":m '<-2<CR>gv=gv")
+
+vim.keymap.set("n", "J", "mzJ`z")
+vim.keymap.set("n", "<C-d>", "<C-d>zz")
+vim.keymap.set("n", "<C-u>", "<C-u>zz")
+vim.keymap.set("n", "n", "nzzzv")
+vim.keymap.set("n", "N", "Nzzzv")
+
+-- Where Am I?
+vim.keymap.set("n", "<leader>w", "<cmd>echo @%<CR>")
+
+-- alternate file --
+vim.keymap.set("n", "<M-a>", "<cmd>silent :b#<CR>")
+
+-- greatest remap ever
+vim.keymap.set("x", "<leader>p", [["_dP]])
+
+-- next greatest remap ever : asbjornHaland
+vim.keymap.set({ "n", "v" }, "<leader>y", [["+y]])
+vim.keymap.set("n", "<leader>Y", [["+Y]])
+
+vim.keymap.set({ "n", "v" }, "<leader>d", [["_d]])
+
+vim.keymap.set("i", "<C-c>", "<Esc>")
+
+vim.keymap.set("n", "<leader>f", vim.lsp.buf.format)
+
+vim.keymap.set("n", "<leader>x", "<cmd>!chmod u+x %<CR>", { silent = true })
+vim.keymap.set("n", "<leader>ng", ":lua require('neogen').generate()<CR>")
+vim.keymap.set("n", "<leader>t", "<cmd>TroubleToggle<CR>")
+
+vim.keymap.set("n", "<leader>mp", "<cmd>MarkdownPreviewToggle<CR>")
+
+vim.keymap.set("n", "<leader><leader>", function()
+	vim.cmd("so")
+end)
+
+-- Diagnostic keymaps
+vim.keymap.set('n', '[d', vim.diagnostic.goto_prev, { desc = 'Go to previous diagnostic message' })
+vim.keymap.set('n', ']d', vim.diagnostic.goto_next, { desc = 'Go to next diagnostic message' })
+vim.keymap.set('n', '<leader>e', vim.diagnostic.open_float, { desc = 'Open floating diagnostic message' })
+vim.keymap.set('n', '<leader>q', vim.diagnostic.setloclist, { desc = 'Open diagnostics list' })
+
+-- Undotree
+vim.keymap.set("n", "<leader>u", vim.cmd.UndotreeToggle)
+
+-- LazyGit
+vim.keymap.set("n", "<leader>lg", "<cmd>LazyGit<CR>")
+
+
+-- Telescope
+vim.keymap.set('n', '<leader>?', require('telescope.builtin').oldfiles, { desc = '[?] Find recently opened files' })
+vim.keymap.set('n', '<leader><space>', require('telescope.builtin').buffers, { desc = '[ ] Find existing buffers' })
+vim.keymap.set('n', '<leader>/', function()
+	-- You can pass additional configuration to telescope to change theme, layout, etc.
+	require('telescope.builtin').current_buffer_fuzzy_find(require('telescope.themes').get_dropdown {
+		winblend = 10,
+		previewer = false,
+	})
+end, { desc = '[/] Fuzzily search in current buffer' })
+
+vim.keymap.set('n', '<C-p>', require('telescope.builtin').git_files, { desc = 'Search [G]it [F]iles' })
+vim.keymap.set('n', '<leader>ff', require('telescope.builtin').find_files, { desc = '[S]earch [F]iles' })
+vim.keymap.set('n', '<leader>sh', require('telescope.builtin').help_tags, { desc = '[S]earch [H]elp' })
+vim.keymap.set('n', '<leader>sw', require('telescope.builtin').grep_string, { desc = '[S]earch current [W]ord' })
+vim.keymap.set('n', '<leader>sg', require('telescope.builtin').live_grep, { desc = '[S]earch by [G]rep' })
+vim.keymap.set('n', '<leader>sd', require('telescope.builtin').diagnostics, { desc = '[S]earch [D]iagnostics' })
+vim.keymap.set('n', '<leader>sr', require('telescope.builtin').resume, { desc = '[S]earch [R]esume' })

lua/config/lazy.lua

+-- Bootstrap lazy.nvim
+local lazypath = vim.fn.stdpath("data") .. "/lazy/lazy.nvim"
+if not (vim.uv or vim.loop).fs_stat(lazypath) then
+	local lazyrepo = "https://github.com/folke/lazy.nvim.git"
+	local out = vim.fn.system({ "git", "clone", "--filter=blob:none", "--branch=stable", lazyrepo, lazypath })
+	if vim.v.shell_error ~= 0 then
+		vim.api.nvim_echo({
+			{ "Failed to clone lazy.nvim:\n", "ErrorMsg" },
+			{ out, "WarningMsg" },
+			{ "\nPress any key to exit..." },
+		}, true, {})
+		vim.fn.getchar()
+		os.exit(1)
+	end
+end
+vim.opt.rtp:prepend(lazypath)
+
+-- Make sure to setup `mapleader` and `maplocalleader` before
+-- loading lazy.nvim so that mappings are correct.
+-- This is also a good place to setup other settings (vim.opt)
+vim.g.mapleader = " "
+vim.g.maplocalleader = "\\"
+
+-- Setup lazy.nvim
+require("lazy").setup({
+	spec = {
+		-- import your plugins
+		{ import = "plugins" },
+	},
+	-- Configure any other settings here. See the documentation for more details.
+	-- colorscheme that will be used when installing plugins.
+	install = { colorscheme = { "habamax" } },
+	-- automatically check for plugin updates
+	checker = { enabled = true },
+})

lua/config/set.lua

+vim.opt.nu = true
+vim.opt.relativenumber = true
+
+vim.opt.clipboard = "unnamedplus"
+
+vim.opt.tabstop = 4
+vim.opt.softtabstop = 4
+vim.opt.shiftwidth = 4
+vim.opt.expandtab = true
+
+vim.opt.smartindent = true
+
+vim.opt.wrap = false
+
+vim.opt.swapfile = false
+vim.opt.backup = false
+vim.opt.undodir = os.getenv("HOME") .. "/.vim/undodir"
+vim.opt.undofile = true
+
+vim.opt.hlsearch = false
+vim.opt.incsearch = true
+
+vim.opt.termguicolors = true
+
+vim.opt.scrolloff = 8
+vim.opt.signcolumn = "yes"
+vim.opt.isfname:append("@-@")
+
+vim.opt.updatetime = 50
+
+vim.opt.colorcolumn = "80"

lua/plugins/harpoon.lua

+return {
+    'ThePrimeagen/harpoon',
+    branch = 'harpoon2',
+    dependencies = {
+        'nvim-lua/plenary.nvim',
+        'nvim-telescope/telescope.nvim'
+    },
+    config = function()
+        local harpoon = require("harpoon")
+
+        -- harpoon:setup()
+        -- REQUIRED
+        harpoon:setup({})
+        -- REQUIRED
+
+        -- basic telescope configuration
+        local conf = require("telescope.config").values
+        local function toggle_telescope(harpoon_files)
+            local file_paths = {}
+            for _, item in ipairs(harpoon_files.items) do
+                table.insert(file_paths, item.value)
+            end
+
+            require("telescope.pickers").new({}, {
+                prompt_title = "Harpoon",
+                finder = require("telescope.finders").new_table({
+                    results = file_paths,
+                }),
+                previewer = conf.file_previewer({}),
+                sorter = conf.generic_sorter({}),
+            }):find()
+        end
+
+        vim.keymap.set("n", "<C-e>", function() toggle_telescope(harpoon:list()) end,
+            { desc = "Open harpoon window" })
+
+        vim.keymap.set("n", "<leader>a", function() harpoon:list():add() end)
+        vim.keymap.set("n", "<C-e>", function() harpoon.ui:toggle_quick_menu(harpoon:list()) end)
+
+        vim.keymap.set("n", "<C-s>", function() harpoon:list():select(1) end)
+        vim.keymap.set("n", "<C-x>", function() harpoon:list():select(2) end)
+        vim.keymap.set("n", "<C-h>", function() harpoon:list():select(3) end)
+        vim.keymap.set("n", "<C-t>", function() harpoon:list():select(4) end)
+    end,
+}

lua/plugins/indent-blankline.lua

+return {
+    -- Add indentation guides even on blank lines
+    'lukas-reineke/indent-blankline.nvim',
+    -- Enable `lukas-reineke/indent-blankline.nvim`
+    -- See `:help ibl`
+    main = 'ibl',
+    opts = {
+        exclude = {
+            filetypes = {
+                'dashboard',
+            }
+        },
+    },
+}

lua/plugins/lazygit.lua

+return {
+	"kdheepak/lazygit.nvim",
+	-- optional for floating window border decoration
+	dependencies = {
+		"nvim-lua/plenary.nvim",
+	}
+}

lua/plugins/lualine.lua

+return {
+    'nvim-lualine/lualine.nvim',
+    dependencies = { 'nvim-tree/nvim-web-devicons' },
+    event = 'ColorScheme',
+    config = function()
+        require('lualine').setup({
+            options = {
+                --- @usage 'rose-pine' | 'rose-pine-alt'
+                theme = 'rose-pine'
+            }
+        })
+    end
+}

lua/plugins/nvim-cmp.lua

+return { -- Autocompletion
+    'hrsh7th/nvim-cmp',
+    event = 'InsertEnter',
+    dependencies = {
+        -- Snippet Engine & its associated nvim-cmp source
+        {
+            'L3MON4D3/LuaSnip',
+            build = (function()
+                -- Build Step is needed for regex support in snippets.
+                -- This step is not supported in many windows environments.
+                -- Remove the below condition to re-enable on windows.
+                if vim.fn.has 'win32' == 1 or vim.fn.executable 'make' == 0 then
+                    return
+                end
+                return 'make install_jsregexp'
+            end)(),
+            dependencies = {
+                -- `friendly-snippets` contains a variety of premade snippets.
+                --    See the README about individual language/framework/plugin snippets:
+                --    https://github.com/rafamadriz/friendly-snippets
+                -- {
+                --   'rafamadriz/friendly-snippets',
+                --   config = function()
+                --     require('luasnip.loaders.from_vscode').lazy_load()
+                --   end,
+                -- },
+            },
+        },
+        'saadparwaiz1/cmp_luasnip',
+
+        -- Adds other completion capabilities.
+        --  nvim-cmp does not ship with all sources by default. They are split
+        --  into multiple repos for maintenance purposes.
+        'hrsh7th/cmp-nvim-lsp',
+        'hrsh7th/cmp-path',
+    },
+    config = function()
+        -- See `:help cmp`
+        local cmp = require 'cmp'
+        local luasnip = require 'luasnip'
+        luasnip.config.setup {}
+
+        cmp.setup {
+            snippet = {
+                expand = function(args)
+                    luasnip.lsp_expand(args.body)
+                end,
+            },
+            completion = { completeopt = 'menu,menuone,noinsert' },
+
+            -- For an understanding of why these mappings were
+            -- chosen, you will need to read `:help ins-completion`
+            --
+            -- No, but seriously. Please read `:help ins-completion`, it is really good!
+            mapping = cmp.mapping.preset.insert {
+                -- Select the [n]ext item
+                ['<C-n>'] = cmp.mapping.select_next_item(),
+                -- Select the [p]revious item
+                ['<C-p>'] = cmp.mapping.select_prev_item(),
+
+                -- Scroll the documentation window [b]ack / [f]orward
+                ['<C-b>'] = cmp.mapping.scroll_docs(-4),
+                ['<C-f>'] = cmp.mapping.scroll_docs(4),
+
+                -- Accept ([y]es) the completion.
+                --  This will auto-import if your LSP supports it.
+                --  This will expand snippets if the LSP sent a snippet.
+                ['<CR>'] = cmp.mapping.confirm { select = true },
+
+                -- If you prefer more traditional completion keymaps,
+                -- you can uncomment the following lines
+                --['<CR>'] = cmp.mapping.confirm { select = true },
+                --['<Tab>'] = cmp.mapping.select_next_item(),
+                --['<S-Tab>'] = cmp.mapping.select_prev_item(),
+
+                -- Manually trigger a completion from nvim-cmp.
+                --  Generally you don't need this, because nvim-cmp will display
+                --  completions whenever it has completion options available.
+                ['<C-Space>'] = cmp.mapping.complete {},
+
+                -- Think of <c-l> as moving to the right of your snippet expansion.
+                --  So if you have a snippet that's like:
+                --  function $name($args)
+                --    $body
+                --  end
+                --
+                -- <c-l> will move you to the right of each of the expansion locations.
+                -- <c-h> is similar, except moving you backwards.
+                ['<C-l>'] = cmp.mapping(function()
+                    if luasnip.expand_or_locally_jumpable() then
+                        luasnip.expand_or_jump()
+                    end
+                end, { 'i', 's' }),
+                ['<C-h>'] = cmp.mapping(function()
+                    if luasnip.locally_jumpable(-1) then
+                        luasnip.jump(-1)
+                    end
+                end, { 'i', 's' }),
+
+                -- For more advanced Luasnip keymaps (e.g. selecting choice nodes, expansion) see:
+                --    https://github.com/L3MON4D3/LuaSnip?tab=readme-ov-file#keymaps
+            },
+            sources = {
+                {
+                    name = 'lazydev',
+                    -- set group index to 0 to skip loading LuaLS completions as lazydev recommends it
+                    group_index = 0,
+                },
+                { name = 'nvim_lsp' },
+                { name = 'luasnip' },
+                { name = 'path' },
+            },
+        }
+    end,
+}

lua/plugins/nvim-lspconfig.lua

+return { -- LSP Configuration & Plugins
+    'neovim/nvim-lspconfig',
+    dependencies = {
+        -- Automatically install LSPs and related tools to stdpath for Neovim
+        { 'williamboman/mason.nvim', config = true }, -- NOTE: Must be loaded before dependants
+        'williamboman/mason-lspconfig.nvim',
+        'WhoIsSethDaniel/mason-tool-installer.nvim',
+
+        -- Useful status updates for LSP.
+        -- NOTE: `opts = {}` is the same as calling `require('fidget').setup({})`
+        { 'j-hui/fidget.nvim',       opts = {} },
+
+        -- `lazydev` configures Lua LSP for your Neovim config, runtime and plugins
+        -- used for completion, annotations and signatures of Neovim apis
+        {
+            'folke/lazydev.nvim',
+            ft = 'lua',
+            opts = {
+                library = {
+                    -- Load luvit types when the `vim.uv` word is found
+                    { path = 'luvit-meta/library', words = { 'vim%.uv' } },
+                },
+            },
+        },
+        { 'Bilal2453/luvit-meta', lazy = true },
+    },
+    config = function()
+        -- Brief aside: **What is LSP?**
+        --
+        -- LSP is an initialism you've probably heard, but might not understand what it is.
+        --
+        -- LSP stands for Language Server Protocol. It's a protocol that helps editors
+        -- and language tooling communicate in a standardized fashion.
+        --
+        -- In general, you have a "server" which is some tool built to understand a particular
+        -- language (such as `gopls`, `lua_ls`, `rust_analyzer`, etc.). These Language Servers
+        -- (sometimes called LSP servers, but that's kind of like ATM Machine) are standalone
+        -- processes that communicate with some "client" - in this case, Neovim!
+        --
+        -- LSP provides Neovim with features like:
+        --  - Go to definition
+        --  - Find references
+        --  - Autocompletion
+        --  - Symbol Search
+        --  - and more!
+        --
+        -- Thus, Language Servers are external tools that must be installed separately from
+        -- Neovim. This is where `mason` and related plugins come into play.
+        --
+        -- If you're wondering about lsp vs treesitter, you can check out the wonderfully
+        -- and elegantly composed help section, `:help lsp-vs-treesitter`
+
+        --  This function gets run when an LSP attaches to a particular buffer.
+        --    That is to say, every time a new file is opened that is associated with
+        --    an lsp (for example, opening `main.rs` is associated with `rust_analyzer`) this
+        --    function will be executed to configure the current buffer
+        vim.api.nvim_create_autocmd('LspAttach', {
+            group = vim.api.nvim_create_augroup('kickstart-lsp-attach', { clear = true }),
+            callback = function(event)
+                -- NOTE: Remember that Lua is a real programming language, and as such it is possible
+                -- to define small helper and utility functions so you don't have to repeat yourself.
+                --
+                -- In this case, we create a function that lets us more easily define mappings specific
+                -- for LSP related items. It sets the mode, buffer and description for us each time.
+                local map = function(keys, func, desc)
+                    vim.keymap.set('n', keys, func, { buffer = event.buf, desc = 'LSP: ' .. desc })
+                end
+
+                -- Jump to the definition of the word under your cursor.
+                --  This is where a variable was first declared, or where a function is defined, etc.
+                --  To jump back, press <C-t>.
+                map('gd', require('telescope.builtin').lsp_definitions, '[G]oto [D]efinition')
+
+                -- Find references for the word under your cursor.
+                map('gr', require('telescope.builtin').lsp_references, '[G]oto [R]eferences')
+
+                -- Jump to the implementation of the word under your cursor.
+                --  Useful when your language has ways of declaring types without an actual implementation.
+                map('gI', require('telescope.builtin').lsp_implementations, '[G]oto [I]mplementation')
+
+                -- Jump to the type of the word under your cursor.
+                --  Useful when you're not sure what type a variable is and you want to see
+                --  the definition of its *type*, not where it was *defined*.
+                map('<leader>D', require('telescope.builtin').lsp_type_definitions, 'Type [D]efinition')
+
+                -- Fuzzy find all the symbols in your current document.
+                --  Symbols are things like variables, functions, types, etc.
+                map('<leader>ds', require('telescope.builtin').lsp_document_symbols, '[D]ocument [S]ymbols')
+
+                -- Fuzzy find all the symbols in your current workspace.
+                --  Similar to document symbols, except searches over your entire project.
+                map('<leader>ws', require('telescope.builtin').lsp_dynamic_workspace_symbols, '[W]orkspace [S]ymbols')
+
+                -- Rename the variable under your cursor.
+                --  Most Language Servers support renaming across files, etc.
+                map('<leader>rn', vim.lsp.buf.rename, '[R]e[n]ame')
+
+                -- Execute a code action, usually your cursor needs to be on top of an error
+                -- or a suggestion from your LSP for this to activate.
+                map('<leader>ca', vim.lsp.buf.code_action, '[C]ode [A]ction')
+
+                -- WARN: This is not Goto Definition, this is Goto Declaration.
+                --  For example, in C this would take you to the header.
+                map('gD', vim.lsp.buf.declaration, '[G]oto [D]eclaration')
+
+                -- 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).
+                local client = vim.lsp.get_client_by_id(event.data.client_id)
+                if client and client.supports_method(vim.lsp.protocol.Methods.textDocument_documentHighlight) then
+                    local highlight_augroup = vim.api.nvim_create_augroup('kickstart-lsp-highlight', { clear = false })
+                    vim.api.nvim_create_autocmd({ 'CursorHold', 'CursorHoldI' }, {
+                        buffer = event.buf,
+                        group = highlight_augroup,
+                        callback = vim.lsp.buf.document_highlight,
+                    })
+
+                    vim.api.nvim_create_autocmd({ 'CursorMoved', 'CursorMovedI' }, {
+                        buffer = event.buf,
+                        group = highlight_augroup,
+                        callback = vim.lsp.buf.clear_references,
+                    })
+
+                    vim.api.nvim_create_autocmd('LspDetach', {
+                        group = vim.api.nvim_create_augroup('kickstart-lsp-detach', { clear = true }),
+                        callback = function(event2)
+                            vim.lsp.buf.clear_references()
+                            vim.api.nvim_clear_autocmds { group = 'kickstart-lsp-highlight', buffer = event2.buf }
+                        end,
+                    })
+                end
+
+                -- The following code creates a keymap to toggle 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 and client.supports_method(vim.lsp.protocol.Methods.textDocument_inlayHint) then
+                    map('<leader>th', function()
+                        vim.lsp.inlay_hint.enable(not vim.lsp.inlay_hint.is_enabled { bufnr = event.buf })
+                    end, '[T]oggle Inlay [H]ints')
+                end
+            end,
+        })
+
+        -- LSP servers and clients are able to communicate to each other what features they support.
+        --  By default, Neovim doesn't support everything that is in the LSP specification.
+        --  When you add nvim-cmp, luasnip, etc. Neovim now has *more* capabilities.
+        --  So, we create new capabilities with nvim cmp, and then broadcast that to the servers.
+        local capabilities = vim.lsp.protocol.make_client_capabilities()
+        capabilities = vim.tbl_deep_extend('force', capabilities, require('cmp_nvim_lsp').default_capabilities())
+
+        -- Enable the following language servers
+        --  Feel free to add/remove any LSPs that you want here. They will automatically be installed.
+        --
+        --  Add any additional override configuration in the following tables. Available keys are:
+        --  - cmd (table): Override the default command used to start the server
+        --  - filetypes (table): Override the default list of associated filetypes for the server
+        --  - capabilities (table): Override fields in capabilities. Can be used to disable certain LSP features.
+        --  - settings (table): Override the default settings passed when initializing the server.
+        --        For example, to see the options for `lua_ls`, you could go to: https://luals.github.io/wiki/settings/
+        local servers = {
+            -- clangd = {},
+            -- gopls = {},
+            -- pyright = {},
+            -- rust_analyzer = {},
+            -- ... etc. See `:help lspconfig-all` for a list of all the pre-configured LSPs
+            --
+            -- Some languages (like typescript) have entire language plugins that can be useful:
+            --    https://github.com/pmizio/typescript-tools.nvim
+            --
+            -- But for many setups, the LSP (`tsserver`) will work just fine
+            -- tsserver = {},
+            --
+
+            lua_ls = {
+                -- cmd = {...},
+                -- filetypes = { ...},
+                -- capabilities = {},
+                settings = {
+                    Lua = {
+                        completion = {
+                            callSnippet = 'Replace',
+                        },
+                        -- You can toggle below to ignore Lua_LS's noisy `missing-fields` warnings
+                        -- diagnostics = { disable = { 'missing-fields' } },
+                    },
+                },
+            },
+        }
+
+        -- Ensure the servers and tools above are installed
+        --  To check the current status of installed tools and/or manually install
+        --  other tools, you can run
+        --    :Mason
+        --
+        --  You can press `g?` for help in this menu.
+        require('mason').setup()
+
+        -- You can add other tools here that you want Mason to install
+        -- for you, so that they are available from within Neovim.
+        local ensure_installed = vim.tbl_keys(servers or {})
+        vim.list_extend(ensure_installed, {
+            'stylua', -- Used to format Lua code
+        })
+        require('mason-tool-installer').setup { ensure_installed = ensure_installed }
+
+        require('mason-lspconfig').setup {
+            handlers = {
+                function(server_name)
+                    local server = servers[server_name] or {}
+                    -- This handles overriding only values explicitly passed
+                    -- by the server configuration above. Useful when disabling
+                    -- certain features of an LSP (for example, turning off formatting for tsserver)
+                    server.capabilities = vim.tbl_deep_extend('force', {}, capabilities, server.capabilities or {})
+                    require('lspconfig')[server_name].setup(server)
+                end,
+            },
+        }
+    end,
+}

lua/plugins/nvim-treesitter.lua

+return {
+    -- Highlight, edit, and navigate code
+    'nvim-treesitter/nvim-treesitter',
+    dependencies = {
+        'nvim-treesitter/nvim-treesitter-textobjects',
+    },
+    build = ':TSUpdate',
+
+    opts = {
+        ensure_installed = { "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,
+
+            -- 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,
+        },
+    }
+}

lua/plugins/rose-pine.lua

+return {
+    'rose-pine/neovim',
+    name = 'rose-pine',
+    lazy = false,
+    priority = 1000,
+    config = function()
+        require('rose-pine').setup({
+            variant = "moon",      -- auto, main, moon, or dawn
+            dark_variant = "main", -- main, moon, or dawn
+            dim_inactive_windows = false,
+            extend_background_behind_borders = false,
+
+            styles = {
+                bold = true,
+                italic = true,
+                transparency = true,
+            },
+
+            groups = {
+                border = "muted",
+                link = "iris",
+                panel = "surface",
+
+                error = "love",
+                hint = "iris",
+                info = "foam",
+                warn = "gold",
+
+                git_add = "foam",
+                git_change = "rose",
+                git_delete = "love",
+                git_dirty = "rose",
+                git_ignore = "muted",
+                git_merge = "iris",
+                git_rename = "pine",
+                git_stage = "iris",
+                git_text = "rose",
+                git_untracked = "subtle",
+                --
+                headings = {
+                    h1 = "iris",
+                    h2 = "foam",
+                    h3 = "rose",
+                    h4 = "gold",
+                    h5 = "pine",
+                    h6 = "foam",
+                },
+                -- Alternatively, set all headings at once.
+                -- headings = "subtle",
+            },
+
+
+            highlight_groups = {
+                -- Comment = { fg = "foam" },
+                -- VertSplit = { fg = "muted", bg = "muted" },
+                Normal = { bg = 'none' },
+                NormalFloat = { bg = 'none' },
+                ColorColumn = { bg = 'rose' },
+
+                -- Blend colours against the "base" background
+                CursorLine = { bg = 'foam', blend = 10 },
+                StatusLine = { fg = 'love', bg = 'love', blend = 10 },
+
+                -- By default each group adds to the existing config.
+                -- If you only want to set what is written in this config exactly,
+                -- you can set the inherit option:
+                IncSearch = { bg = 'pine', inherit = false },
+            },
+
+            before_highlight = function(group, highlight, palette)
+                -- Disable all undercurls
+                -- if highlight.undercurl then
+                --     highlight.undercurl = false
+                -- end
+                --
+                -- Change palette colour
+                -- if highlight.fg == palette.pine then
+                --     highlight.fg = palette.foam
+                -- end
+            end,
+        })
+        vim.cmd.colorscheme 'rose-pine'
+    end,
+}

lua/plugins/telescope.lua

+return	{
+	-- Fuzzy Finder (files, lsp, etc)
+	'nvim-telescope/telescope.nvim',
+	branch = '0.1.x',
+	dependencies = {
+		'nvim-lua/plenary.nvim',
+		-- Fuzzy Finder Algorithm which requires local dependencies to be built.
+		-- Only load if `make` is available. Make sure you have the system
+		-- requirements installed.
+		{
+			'nvim-telescope/telescope-fzf-native.nvim',
+			-- NOTE: If you are having trouble with this installation,
+			--       refer to the README for telescope-fzf-native for more instructions.
+			build = 'make',
+			cond = function()
+				return vim.fn.executable 'make' == 1
+			end,
+		},
+	},
+}

lua/plugins/todo-comments.lua

+return {
+	"folke/todo-comments.nvim",
+	dependencies = { "nvim-lua/plenary.nvim" },
+	opts = {
+		-- your configuration comes here
+		-- or leave it empty to use the default settings
+		-- refer to the configuration section below
+	}
+}

lua/plugins/trouble.lua

+return {
+    "folke/trouble.nvim",
+    opts = {}, -- for default options, refer to the configuration section for custom setup.
+    cmd = "Trouble",
+    keys = {
+        {
+            "<leader>t",
+            "<cmd>Trouble diagnostics toggle<cr>",
+            desc = "Diagnostics (Trouble)",
+        },
+        {
+            "<leader>q",
+            "<cmd>Trouble todo toggle<cr>",
+            desc = "Todo (Trouble)",
+        },
+        {
+            "<leader>xX",
+            "<cmd>Trouble diagnostics toggle filter.buf=0<cr>",
+            desc = "Buffer Diagnostics (Trouble)",
+        },
+        {
+            "<leader>cs",
+            "<cmd>Trouble symbols toggle focus=false<cr>",
+            desc = "Symbols (Trouble)",
+        },
+        {
+            "<leader>cl",
+            "<cmd>Trouble lsp toggle focus=false win.position=right<cr>",
+            desc = "LSP Definitions / references / ... (Trouble)",
+        },
+        {
+            "<leader>xL",
+            "<cmd>Trouble loclist toggle<cr>",
+            desc = "Location List (Trouble)",
+        },
+        {
+            "<leader>xQ",
+            "<cmd>Trouble qflist toggle<cr>",
+            desc = "Quickfix List (Trouble)",
+        },
+    },
+}

lua/plugins/undotree.lua

+return {
+	'mbbill/undotree'
+}