Compare revisions

lazy-lock.json

# 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

```

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

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 = '*',

})

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' })

-- 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 },

})

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"

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,

}

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',

            }

        },

    },

}

return {

	"kdheepak/lazygit.nvim",

	-- optional for floating window border decoration

	dependencies = {

		"nvim-lua/plenary.nvim",

	}

}

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

}

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,

}

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,

}

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,

        },

    }

}

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,