first commit

1 files changed, 1117 insertions, 0 deletions

diff --git a/home/.config/nvim/lua/custom/plugins/init.lua b/home/.config/nvim/lua/custom/plugins/init.lua
new file mode 100644
index 0000000..eb720e6
--- /dev/null
+++ b/home/.config/nvim/lua/custom/plugins/init.lua
@@ -0,0 +1,1117 @@
+local map = require("mapper")
+
+return {
+  { "nvim-lua/plenary.nvim", lazy = true },
+  { "tpope/vim-repeat",      event = "VeryLazy" },
+  'tpope/vim-sleuth',
+  {
+    "numToStr/Comment.nvim",
+    config = true,
+  },
+  {
+    "tpope/vim-unimpaired",
+    keys = { "]", "[", "yo" },
+  },
+  { "folke/which-key.nvim",   lazy = true },
+  { "kylechui/nvim-surround", config = true },
+  {
+    "dstein64/vim-startuptime",
+    cmd = "StartupTime",
+  },
+  {
+    "folke/persistence.nvim",
+    config = true,
+    event = "BufReadPre",
+    keys = {
+      {
+        "<leader>qs",
+        require("persistence").load,
+        desc =
+        "Restore Session"
+      },
+      {
+        "<leader>ql",
+        function() require("persistence").load({ last = true }) end,
+        desc =
+        "Restore Last Session"
+      },
+      {
+        "<leader>qd",
+        require("persistence").stop,
+        desc =
+        "Don't Save Current Session"
+      },
+    },
+  },
+  "xiyaowong/nvim-cursorword",
+  {
+    "sainnhe/gruvbox-material",
+    priority = 1000,
+    config = function()
+      vim.g.gruvbox_material_background = "hard"
+      vim.g.gruvbox_material_enable_bold = 1
+      vim.g.gruvbox_material_enable_italic = 1
+      vim.g.gruvbox_material_better_performance = 1
+      vim.g.gruvbox_material_palette = "original"
+
+      vim.cmd([[ colorscheme  gruvbox-material]])
+    end
+  },
+  {
+    "aserowy/tmux.nvim",
+    config = true,
+  },
+  {
+    "Julian/vim-textobj-variable-segment",
+    dependencies = { "kana/vim-textobj-user" },
+  },
+  { "mzlogin/vim-markdown-toc",  ft = "markdown" },
+  {
+    "norcalli/nvim-colorizer.lua",
+    event = "BufRead",
+    config = true
+  },
+  {
+    "lewis6991/hover.nvim",
+    keys = { { "K", require "hover".hover }, { "gK", require "hover"
+        .hover_select }, { "gh", require "hover".hover },
+      { "gH", require "hover".hover_select } },
+    opts = {
+      init = function()
+        require("hover.providers.lsp")
+        require('hover.providers.gh')
+        require('hover.providers.man')
+        -- require('hover.providers.dictionary')
+      end,
+    },
+  },
+  { 'akinsho/git-conflict.nvim', config = true },
+  {
+    "lukas-reineke/indent-blankline.nvim",
+    config = function()
+      local highlight = {
+        "RainbowRed",
+        "RainbowYellow",
+        "RainbowBlue",
+        "RainbowOrange",
+        "RainbowGreen",
+        "RainbowViolet",
+        "RainbowCyan",
+      }
+      local hooks = require "ibl.hooks"
+      -- create the highlight groups in the highlight setup hook, so they are reset
+      -- every time the colorscheme changes
+      hooks.register(hooks.type.HIGHLIGHT_SETUP, function()
+        vim.api.nvim_set_hl(0, "RainbowRed", { fg = "#E06C75" })
+        vim.api.nvim_set_hl(0, "RainbowYellow", { fg = "#E5C07B" })
+        vim.api.nvim_set_hl(0, "RainbowBlue", { fg = "#61AFEF" })
+        vim.api.nvim_set_hl(0, "RainbowOrange", { fg = "#D19A66" })
+        vim.api.nvim_set_hl(0, "RainbowGreen", { fg = "#98C379" })
+        vim.api.nvim_set_hl(0, "RainbowViolet", { fg = "#C678DD" })
+        vim.api.nvim_set_hl(0, "RainbowCyan", { fg = "#56B6C2" })
+      end)
+
+      vim.g.rainbow_delimiters = { highlight = highlight }
+      require("ibl").setup { scope = { highlight = highlight } }
+
+      hooks.register(hooks.type.SCOPE_HIGHLIGHT,
+        hooks.builtin.scope_highlight_from_extmark)
+    end
+  },
+  {
+    "monaqa/dial.nvim",
+    config = function()
+      map.n("]i", require("dial.map").inc_normal())
+      map.n("[i", require("dial.map").dec_normal())
+      map.v("]i", require("dial.map").inc_visual())
+      map.v("[i", require("dial.map").dec_visual())
+    end
+  },
+  {
+    "iamcco/markdown-preview.nvim",
+    build = "cd app && yarn install",
+    ft = "markdown",
+    config = function()
+      vim.api.nvim_command([[
+          function! g:OpenNewWindow(url)
+              silent exec "Start! librewolf --new-window " . a:url
+          endfunction
+          ]])
+      vim.g.mkdp_browserfunc = "g:OpenNewWindow"
+    end,
+  },
+  "gpanders/editorconfig.nvim",
+  {
+    "kwkarlwang/bufresize.nvim",
+    config = true
+  },
+  "kovetskiy/sxhkd-vim",
+  "tmux-plugins/vim-tmux",
+  "chrisbra/csv.vim",
+  "martinda/Jenkinsfile-vim-syntax",
+  "rhysd/vim-llvm",
+  "MTDL9/vim-log-highlighting",
+  "raimon49/requirements.txt.vim",
+  "wgwoods/vim-systemd-syntax",
+  {
+    "NeogitOrg/neogit",
+    dependencies = {
+      "nvim-lua/plenary.nvim",
+    },
+    config = function()
+      require("neogit").setup({
+        disable_commit_confirmation = true,
+        kind = "split",
+        console_timeout = 5000,
+        auto_show_console = false,
+      })
+      map.n("<leader>ng", require "neogit".open)
+    end,
+  },
+  {
+    "ruifm/gitlinker.nvim",
+    keys = {
+      { "<leader>gy", function() require 'gitlinker'.get_buf_range_url("n") end },
+      {
+        "<leader>gy",
+        function()
+          require 'gitlinker'.get_buf_range_url("v")
+        end,
+        mode = "v"
+      },
+    },
+    dependencies = {
+      "nvim-lua/plenary.nvim",
+    },
+    config = function()
+      require "gitlinker".setup({
+        callbacks = {
+          ["personal"] = function(url_data)
+            url_data.host = "github.com"
+            return require "gitlinker.hosts".get_github_type_url(url_data)
+          end,
+          ["work"] = function(url_data)
+            url_data.host = "github.com"
+            return require "gitlinker.hosts".get_github_type_url(url_data)
+          end,
+          ["git.strisemarx.com"] = function(url_data)
+            local url = require "gitlinker.hosts".get_base_https_url(url_data)
+            url = url .. "/tree/" .. url_data.file .. "?id=" .. url_data.rev
+            if url_data.lstart then
+              url = url .. "#n" .. url_data.lstart
+            end
+            return url
+          end
+        },
+      })
+    end,
+  },
+  {
+    "lewis6991/gitsigns.nvim",
+    event = "BufRead",
+    opts = {
+      signs = {
+        change = { show_count = true },
+        delete = { show_count = true },
+        topdelete = { show_count = true },
+        changedelete = { show_count = true },
+      },
+      numhl = true,
+      _extmark_signs = true,
+      _threaded_diff = true,
+      _signs_staged_enable = true,
+      on_attach = function(bufnr)
+        local gs = package.loaded.gitsigns
+
+        -- Navigation
+        map.n(']c', function()
+          if vim.wo.diff then return ']c' end
+          vim.schedule(function() gs.next_hunk() end)
+          return '<Ignore>'
+        end, { expr = true }, bufnr)
+
+        map.n('[c', function()
+          if vim.wo.diff then return '[c' end
+          vim.schedule(function() gs.prev_hunk() end)
+          return '<Ignore>'
+        end, { expr = true }, bufnr)
+
+        -- Actions
+        map.nvcmd('<leader>hs', "Gitsigns stage_hunk", nil, bufnr)
+        map.nvcmd('<leader>hr', "Gitsigns reset_hunk", nil, bufnr)
+        map.n('<leader>hS', gs.stage_buffer, nil, bufnr)
+        map.n('<leader>hu', gs.undo_stage_hunk, nil, bufnr)
+        map.n('<leader>hR', gs.reset_buffer, nil, bufnr)
+        map.n('<leader>hp', gs.preview_hunk, nil, bufnr)
+        map.n('<leader>hb', function() gs.blame_line { full = true } end, nil,
+          bufnr)
+        map.n('<leader>tb', gs.toggle_current_line_blame, nil, bufnr)
+        map.n('<leader>hd', gs.diffthis, nil, bufnr)
+        map.n('<leader>hD', function() gs.diffthis('~') end, nil, bufnr)
+        map.n('<leader>hc', gs.change_base, nil, bufnr)
+        map.n('<leader>hC', function() gs.change_base('~') end, nil, bufnr)
+        map.n('<leader>td', gs.toggle_deleted, nil, bufnr)
+        map.n('<leader>tw', gs.toggle_word_diff, nil, bufnr)
+        map.n('<leader>tl', gs.toggle_linehl, nil, bufnr)
+
+        -- Text object
+        map.map({ 'o', 'x' }, 'ih', ':<C-U>Gitsigns select_hunk<CR>', nil, bufnr)
+      end
+    },
+    dependencies = {
+      "nvim-lua/plenary.nvim",
+    },
+  },
+  {
+    "nvim-telescope/telescope.nvim",
+    config = function()
+      local actions = require("telescope.actions")
+      require("telescope").setup({
+        defaults = {
+          sorting_strategy = "ascending",
+          layout_config = {
+            prompt_position = "top",
+          },
+          scroll_strategy = "cycle",
+          selection_strategy = "follow",
+          color_devicons = false,
+          mappings = {
+            i = {
+              ["<c-j>"] = actions.move_selection_next,
+              ["<c-k>"] = actions.move_selection_previous,
+            },
+          },
+          extensions = {
+            fzf = {
+              fuzzy = true,                   -- false will only do exact matching
+              override_generic_sorter = true, -- override the generic sorter
+              override_file_sorter = true,    -- override the file sorter
+              case_mode = "smart_case",       -- or "ignore_case" or "respect_case"
+            },
+            ["ui-select"] = {
+              require("telescope.themes").get_dropdown({
+                -- even more opts
+              }),
+            },
+          },
+        },
+      })
+      require("telescope").load_extension("fzf")
+      require("telescope").load_extension("ui-select")
+
+      local b = require("telescope.builtin")
+
+      map.n("<localleader>p", b.planets)
+      map.n("<localleader>B", b.builtin)
+      map.n("<localleader>/", b.live_grep)
+      map.n("<localleader>?", b.grep_string)
+      map.n("<localleader>f", function()
+        b.find_files({
+          find_command = {
+            "fd",
+            "--type",
+            "file",
+            "--follow",
+            "--hidden",
+            "--exclude",
+            ".git",
+          },
+        })
+      end)
+      map.n("<localleader>b", function()
+        b.buffers({ sort_lastused = true, initial_mode = "normal" })
+      end)
+
+      map.n("<localleader>t", b.treesitter)
+
+      map.n("<localleader>c", b.commands)
+      map.n("<localleader>h", b.help_tags)
+      map.n("<localleader>m", b.man_pages)
+      map.n("<localleader>k", b.keymaps)
+      map.n("<localleader>Q", function()
+        b.quickfix({ initial_mode = "normal" })
+      end)
+      map.n("<localleader>L", function()
+        b.loclist({ initial_mode = "normal" })
+      end)
+      map.n("<localleader>R", function()
+        b.registers({ initial_mode = "normal" })
+      end)
+      map.n("<localleader>A", b.autocommands)
+
+      map.n("gd", function()
+        b.lsp_definitions({ initial_mode = "normal" })
+      end)
+      map.n("gvd", function()
+        b.lsp_definitions({ initial_mode = "normal", jump_type = "vsplit" })
+      end)
+      map.n("gxd", function()
+        b.lsp_definitions({ initial_mode = "normal", jump_type = "split" })
+      end)
+      map.n("gtd", function()
+        b.lsp_definitions({ initial_mode = "normal", jump_type = "tab" })
+      end)
+      map.n("gi", function()
+        b.lsp_implementations({ initial_mode = "normal" })
+      end)
+      map.n("gvi", function()
+        b.lsp_implementations({ initial_mode = "normal", jump_type = "vsplit" })
+      end)
+      map.n("gxi", function()
+        b.lsp_implementations({ initial_mode = "normal", jump_type = "split" })
+      end)
+      map.n("gti", function()
+        b.lsp_implementations({ initial_mode = "normal", jump_type = "tab" })
+      end)
+      map.n("go", b.lsp_document_symbols)
+      map.n("gS", b.lsp_dynamic_workspace_symbols)
+      map.n("ge", function()
+        b.lsp_document_diagnostics({ initial_mode = "normal" })
+      end)
+      map.n("gE", function()
+        b.lsp_workspace_diagnostics({ initial_mode = "normal" })
+      end)
+      map.n("gr", function()
+        b.lsp_references({ initial_mode = "normal" })
+      end)
+      map.n("gic", function()
+        b.lsp_incoming_calls({ initial_mode = "normal" })
+      end)
+      map.n("goc", function()
+        b.lsp_outgoing_calls({ initial_mode = "normal" })
+      end)
+    end,
+    dependencies = {
+      "nvim-lua/plenary.nvim",
+      {
+        "nvim-telescope/telescope-fzf-native.nvim",
+        build = "make",
+      },
+      "nvim-telescope/telescope-ui-select.nvim",
+    },
+  },
+  {
+    "mfussenegger/nvim-dap",
+    config = function()
+      local dap = require("dap")
+
+      dap.defaults.fallback.force_external_terminal = true
+      dap.defaults.fallback.external_terminal = {
+        command = "/usr/bin/st",
+        args = { "-e" },
+      }
+
+      dap.defaults.fallback.terminal_win_cmd = "50vsplit new"
+
+      local function get_env_vars()
+        local variables = {}
+        for k, v in pairs(vim.fn.environ()) do
+          table.insert(variables, string.format("%s=%s", k, v))
+        end
+        return variables
+      end
+
+      dap.adapters.lldb = {
+        type = "executable",
+        command = "/usr/bin/lldb-vscode",
+        name = "lldb",
+      }
+
+      local function str_split(inputstr, sep)
+        sep = sep or "%s"
+        local t = {}
+        for str in inputstr:gmatch("([^" .. sep .. "]+)") do
+          table.insert(t, str)
+        end
+        return t
+      end
+
+      local _cmd = nil
+
+      local function get_cmd()
+        if _cmd then
+          return _cmd
+        end
+        local clipboard_cmd = vim.fn.getreg("+")
+        _cmd = vim.fn.input({
+          prompt = "Command to execute: ",
+          default = clipboard_cmd
+        })
+        return _cmd
+      end
+
+      local function get_program()
+        return str_split(get_cmd())[1]
+      end
+
+      local function get_args()
+        local argv = str_split(get_cmd())
+        local args = {}
+
+        if #argv < 2 then
+          return {}
+        end
+
+        for i = 2, #argv do
+          args[#args + 1] = argv[i]
+        end
+
+        return args
+      end
+
+      dap.configurations.cpp = {
+        {
+          name = "Launch",
+          type = "lldb",
+          request = "launch",
+          cwd = "${workspaceFolder}",
+          program = get_program,
+          stopOnEntry = true,
+          args = get_args,
+          env = get_env_vars,
+          runInTerminal = true,
+        },
+        {
+          -- If you get an "Operation not permitted" error using this, try disabling YAMA:
+          --  echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope
+          name = "Attach to process",
+          type = "lldb",
+          request = "attach",
+          pid = require('dap.utils').pick_process,
+        },
+      }
+
+      dap.configurations.c = dap.configurations.cpp
+      dap.configurations.rust = dap.configurations.cpp
+
+      local get_python_path = function()
+        local venv_path = os.getenv("VIRTUAL_ENV")
+        if venv_path then
+          return venv_path .. "/bin/python"
+        end
+        return "/usr/bin/python"
+      end
+
+      require("dap-python").setup(get_python_path())
+
+      dap.adapters.nlua = function(callback, config)
+        callback({ type = "server", host = config.host, port = config.port })
+      end
+
+      dap.configurations.lua = {
+        {
+          type = "nlua",
+          request = "attach",
+          name = "Attach to running Neovim instance",
+          host = function()
+            local value = vim.fn.input("Host [127.0.0.1]: ")
+            if value ~= "" then
+              return value
+            end
+            return "127.0.0.1"
+          end,
+          port = function()
+            local val = tonumber(vim.fn.input("Port: "))
+            assert(val, "Please provide a port number")
+            return val
+          end,
+        },
+      }
+
+      dap.repl.commands = vim.tbl_extend("force", dap.repl.commands, {
+        continue = { "continue", "c" },
+        next_ = { "next", "n" },
+        back = { "back", "b" },
+        reverse_continue = { "reverse-continue", "rc" },
+        into = { "into" },
+        into_target = { "into_target" },
+        out = { "out" },
+        scopes = { "scopes" },
+        threads = { "threads" },
+        frames = { "frames" },
+        exit = { "exit", "quit", "q" },
+        up = { "up" },
+        down = { "down" },
+        goto_ = { "goto" },
+        capabilities = { "capabilities", "cap" },
+        -- add your own commands
+        custom_commands = {
+          ["echo"] = function(text)
+            dap.repl.append(text)
+          end,
+        },
+      })
+
+      map.n("<F4>", dap.close)
+      map.n("<F5>", dap.continue)
+      map.n("<F10>", dap.step_over)
+      map.n("<F11>", dap.step_into)
+      map.n("<F12>", dap.step_out)
+      map.n("<leader>b", dap.toggle_breakpoint)
+      map.n("<leader>B", function()
+        dap.set_breakpoint(vim.fn.input("Breakpoint condition: "))
+      end)
+      map.n("<leader>lp", function()
+        dap.set_breakpoint(nil, nil, vim.fn.input("Log point message: "))
+      end)
+      map.n("<leader>dr", dap.repl.open)
+      map.n("<leader>dl", dap.run_last)
+      map.n("<F2>", dap.list_breakpoints)
+
+      local dapui = require("dapui")
+      dap.listeners.after.event_initialized["dapui_config"] = function()
+        dapui.open()
+      end
+      dap.listeners.before.event_terminated["dapui_config"] = function()
+        dapui.close()
+      end
+      dap.listeners.before.event_exited["dapui_config"] = function()
+        dapui.close()
+      end
+      map.n("<leader>du", dapui.toggle)
+      map.v("<leader>de", dapui.eval)
+    end,
+    dependencies = {
+      {
+        "rcarriga/nvim-dap-ui",
+        opts = {
+          icons = { expanded = "-", collapsed = "+", current_frame = "*" },
+          controls = { enabled = false },
+          layouts = {
+            {
+              elements = {
+                -- Elements can be strings or table with id and size keys.
+                "scopes",
+                "breakpoints",
+                "stacks",
+                "watches",
+              },
+              size = 40,
+              position = "left",
+            },
+            {
+              elements = {
+                "repl",
+              },
+              size = 0.25, -- 25% of total lines
+              position = "bottom",
+            },
+          },
+        },
+      },
+      {
+        "mfussenegger/nvim-dap-python",
+        keys = {
+          { "gm", function()
+            require("dap-python").test_method()
+          end },
+          {
+            "g<cr>",
+            function()
+              require("dap-python").debug_selection()
+            end,
+            mode = "v"
+          },
+        },
+      },
+      "jbyuki/one-small-step-for-vimkind",
+      {
+        "theHamsta/nvim-dap-virtual-text",
+        config = true,
+        dependencies = { "nvim-treesitter/nvim-treesitter" }
+      }
+    },
+  },
+  {
+    'nvim-treesitter/nvim-treesitter',
+    dependencies = {
+      'nvim-treesitter/nvim-treesitter-textobjects',
+      "nvim-treesitter/nvim-treesitter-refactor",
+      "RRethy/nvim-treesitter-textsubjects",
+      "theHamsta/nvim-treesitter-pairs",
+      "RRethy/nvim-treesitter-endwise",
+    },
+    build = ":TSUpdate",
+    config = function()
+      require("nvim-treesitter.configs").setup({
+        ensure_installed = {
+          "bash",
+          "c",
+          "cmake",
+          "comment",
+          "cpp",
+          "css",
+          "cuda",
+          "diff",
+          "dockerfile",
+          "fortran",
+          "git_rebase",
+          "gitattributes",
+          "gitcommit",
+          "gitignore",
+          "go",
+          "html",
+          "javascript",
+          "jsdoc",
+          "json",
+          "llvm",
+          "lua",
+          "make",
+          "markdown",
+          "markdown_inline",
+          "ninja",
+          "python",
+          "regex",
+          "rust",
+          "sql",
+          "todotxt",
+          "toml",
+          "typescript",
+          "vim",
+          "vimdoc",
+          "yaml"
+        },
+        -- ignore_install = { "phpdoc" },
+        highlight = {
+          enable = true, -- false will disable the whole extension
+          additional_vim_regex_highlighting = false,
+        },
+        incremental_selection = {
+          enable = true,
+          keymaps = {
+            init_selection = "gnn",
+            node_incremental = "grn",
+            scope_incremental = "grc",
+            node_decremental = "grm",
+          },
+        },
+        indent = { enable = true },
+        refactor = {
+          highlight_definitions = { enable = true },
+          highlight_current_scope = { enable = true },
+          smart_rename = { enable = true, keymaps = { smart_rename = "grr" } },
+          navigation = {
+            enable = true,
+            keymaps = {
+              goto_definition = "gnd",
+              list_definitions = "gnD",
+              list_definitions_toc = "gO",
+              goto_next_usage = "<a-*>",
+              goto_previous_usage = "<a-#>",
+            },
+          },
+        },
+        textobjects = {
+          select = {
+            enable = true,
+            -- Automatically jump forward to textobj, similar to targets.vim
+            lookahead = true,
+            keymaps = {
+              -- You can use the capture groups defined in textobjects.scm
+              ["af"] = "@function.outer",
+              ["if"] = "@function.inner",
+              ["ac"] = "@class.outer",
+              ["ic"] = "@class.inner",
+            },
+          },
+          swap = {
+            enable = true,
+            swap_next = { ["<leader>a"] = "@parameter.inner" },
+            swap_previous = { ["<leader>A"] = "@parameter.inner" },
+          },
+          move = {
+            enable = true,
+            set_jumps = true, -- whether to set jumps in the jumplist
+            goto_next_start = {
+              ["]m"] = "@function.outer",
+              ["]]"] = "@class.outer",
+            },
+            goto_next_end = {
+              ["]M"] = "@function.outer",
+              ["]["] = "@class.outer",
+            },
+            goto_previous_start = {
+              ["[m"] = "@function.outer",
+              ["[["] = "@class.outer",
+            },
+            goto_previous_end = {
+              ["[M"] = "@function.outer",
+              ["[]"] = "@class.outer",
+            },
+          },
+          lsp_interop = {
+            enable = true,
+            peek_definition_code = {
+              ["df"] = "@function.outer",
+              ["dF"] = "@class.outer",
+            },
+          },
+        },
+        matchup = {
+          enable = true,
+        },
+        pairs = {
+          enable = true,
+          goto_right_end = false,
+          keymaps = { goto_partner = "%" },
+        },
+        textsubjects = {
+          enable = true,
+          keymaps = { ["."] = "textsubjects-smart", [";"] = "textsubjects-big" },
+        },
+        tree_docs = {
+          enable = true,
+        },
+        endwise = {
+          enable = true,
+        },
+      })
+    end
+  },
+  {
+    "hrsh7th/nvim-cmp",
+    event = "InsertEnter",
+    config = function()
+      local cmp = require("cmp")
+
+      local has_words_before = function()
+        local line, col = unpack(vim.api.nvim_win_get_cursor(0))
+        return col ~= 0
+            and vim.api.nvim_buf_get_lines(0, line - 1, line, true)[1]
+            :sub(col, col)
+            :match("%s")
+            == nil
+      end
+
+      local luasnip = require("luasnip")
+
+      cmp.setup({
+        snippet = {
+          expand = function(args)
+            require("luasnip").lsp_expand(args.body)
+          end,
+        },
+        mapping = {
+          ["<Tab>"] = cmp.mapping(function(fallback)
+            if cmp.visible() then
+              cmp.select_next_item()
+            elseif luasnip.expand_or_jumpable() then
+              luasnip.expand_or_jump()
+            elseif has_words_before() then
+              cmp.complete()
+            else
+              fallback()
+            end
+          end, {
+            "i",
+            "s",
+          }),
+          ["<S-Tab>"] = cmp.mapping(function(fallback)
+            if cmp.visible() then
+              cmp.select_prev_item()
+            elseif luasnip.jumpable(-1) then
+              luasnip.jump(-1)
+            else
+              fallback()
+            end
+          end, {
+            "i",
+            "s",
+          }),
+          ["<CR>"] = cmp.mapping.confirm({
+            behavior = cmp.ConfirmBehavior.Replace,
+            select = true,
+          }),
+        },
+        formatting = {
+          format = function(entry, vim_item)
+            -- set a name for each source
+            vim_item.menu = ({
+              path = "[Path]",
+              nvim_lsp = "[LSP]",
+              luasnip = "[LuaSnip]",
+              dap = "[dap]",
+            })[entry.source.name]
+            return vim_item
+          end,
+        },
+        sources = {
+          { name = "nvim_lsp" },
+          { name = "luasnip" },
+          { name = "path" },
+          { name = "nvim_lsp_signature_help" },
+        },
+      })
+
+      require "cmp".setup.filetype(
+        { "dap-repl", "dapui_watches", "dapui_hover" }, {
+          sources = {
+            { name = "dap" },
+          },
+        })
+    end,
+    dependencies = {
+      "hrsh7th/cmp-nvim-lsp",
+      "hrsh7th/cmp-path",
+      "hrsh7th/cmp-nvim-lsp-signature-help",
+      "rcarriga/cmp-dap",
+      {
+        "saadparwaiz1/cmp_luasnip",
+        dependencies = {
+          {
+            "L3MON4D3/LuaSnip",
+            event = "InsertCharPre",
+            keys = {
+              { "<c-j>", function() require "luasnip".jump(1) end,  mode = "i" },
+              { "<c-k>", function() require "luasnip".jump(-1) end, mode = "i" },
+            },
+            config = function()
+              require("luasnip/loaders/from_vscode").lazy_load()
+            end,
+            dependencies = {
+              "kitagry/vs-snippets",
+              "rafamadriz/friendly-snippets",
+              "kkonghao/snippet-dog",
+            },
+          }
+        },
+      },
+    },
+  },
+  {
+    'neovim/nvim-lspconfig',
+    config = function()
+      local lspconfig = require("lspconfig")
+      -- Enable (broadcasting) snippet capability for completion
+      local capabilities = vim.lsp.protocol.make_client_capabilities()
+      capabilities.textDocument.completion.completionItem.snippetSupport = true
+      capabilities.workspace.didChangeWatchedFiles.dynamicRegistration = true
+      capabilities = require("cmp_nvim_lsp").default_capabilities(capabilities)
+
+      lspconfig.util.default_config = vim.tbl_extend(
+        "force",
+        lspconfig.util.default_config,
+        {
+          on_attach = require "cfg.lsp".on_attach_wrapper,
+          capabilities = capabilities,
+          flags = {
+            debounce_text_changes = 150,
+          },
+        }
+      )
+
+      local function switch_source_header_splitcmd(bufnr, splitcmd)
+        bufnr = lspconfig.util.validate_bufnr(bufnr)
+        local clangd_client = lspconfig.util.get_active_client_by_name(
+          bufnr,
+          "clangd"
+        )
+        local params = { uri = vim.uri_from_bufnr(bufnr) }
+        if clangd_client then
+          clangd_client.request(
+            "textDocument/switchSourceHeader",
+            params,
+            function(err, result)
+              if err then
+                error(tostring(err))
+              end
+              if not result then
+                print("Corresponding file cannot be determined")
+                return
+              end
+              vim.api.nvim_command(splitcmd .. " " .. vim.uri_to_fname(result))
+            end,
+            bufnr
+          )
+        else
+          print(
+            "method textDocument/switchSourceHeader is not supported by any servers active on the current buffer"
+          )
+        end
+      end
+
+      local servers = {
+        bashls = {},
+        fortls = {},
+        lua_ls = {
+          on_attach = function(client, bufnr)
+            require("cfg.lsp").on_attach_wrapper(
+              client,
+              bufnr,
+              { auto_format = true }
+            )
+          end,
+          settings = {
+            Lua = {
+              completion = {
+                callSnippet = "Both",
+                displayContext = 1,
+              },
+              hint = {
+                enable = true,
+              }
+            }
+          },
+        },
+        ruff_lsp = {},
+        pyright = {},
+        clangd = {
+          cmd = {
+            "clangd",
+            "--enable-config",
+            "--completion-parse=auto",
+            "--completion-style=bundled",
+            "--header-insertion=iwyu",
+            "--header-insertion-decorators",
+            "--inlay-hints",
+            "--suggest-missing-includes",
+            "--folding-ranges",
+            "--function-arg-placeholders",
+            "--pch-storage=memory",
+          },
+          commands = {
+            ClangdSwitchSourceHeader = {
+              function()
+                switch_source_header_splitcmd(0, "edit")
+              end,
+              description = "Open source/header in current buffer",
+            },
+            ClangdSwitchSourceHeaderVSplit = {
+              function()
+                switch_source_header_splitcmd(0, "vsplit")
+              end,
+              description = "Open source/header in a new vsplit",
+            },
+            ClangdSwitchSourceHeaderSplit = {
+              function()
+                switch_source_header_splitcmd(0, "split")
+              end,
+              description = "Open source/header in a new split",
+            },
+            ClangdSwitchSourceHeaderTab = {
+              function()
+                switch_source_header_splitcmd(0, "tabedit")
+              end,
+              description = "Open source/header in a new tab",
+            },
+          },
+          on_attach = function(client, bufnr)
+            require("cfg.lsp").on_attach_wrapper(client, bufnr)
+            local cmpconfig = require("cmp.config")
+            local compare = require("cmp.config.compare")
+            cmpconfig.set_buffer({
+              sorting = {
+                comparators = {
+                  compare.offset,
+                  compare.exact,
+                  -- compare.scopes,
+                  require("clangd_extensions.cmp_scores"),
+                  compare.recently_used,
+                  compare.locality,
+                  compare.kind,
+                  compare.sort_text,
+                  compare.length,
+                  compare.order,
+                },
+              },
+            }, bufnr)
+            vim.api.nvim_create_augroup("clang-format", {})
+            vim.api.nvim_create_autocmd("BufWritePre", {
+              group = "clang-format",
+              buffer = bufnr,
+              callback = function()
+                if vim.fn.expand('%:p:h'):find("test") then
+                  return
+                end
+                require("cfg.utils").format_hunks({
+                  bufnr = bufnr,
+                  async = false,
+                  id = client.id
+                })
+              end,
+            })
+            map.ncmd("gH", "ClangdSwitchSourceHeader")
+            map.ncmd("gvH", "ClangdSwitchSourceHeaderVSplit")
+            map.ncmd("gxH", "ClangdSwitchSourceHeaderSplit")
+            map.ncmd("gtH", "ClangdSwitchSourceHeaderSplit")
+
+            require("clangd_extensions.inlay_hints").setup_autocmd()
+            require("clangd_extensions.inlay_hints").set_inlay_hints()
+          end,
+          init_options = {
+            usePlaceholders = true,
+            completeUnimported = true,
+            clangdFileStatus = true,
+          },
+        },
+      }
+
+      for server, config in pairs(servers) do
+        local default_config = lspconfig[server].default_config or
+            lspconfig[server].document_config.default_config
+        local cmd = config.cmd or default_config.cmd
+        if vim.fn.executable(cmd[1]) == 1 then lspconfig[server].setup(config) end
+      end
+    end,
+    dependencies = {
+      "hrsh7th/cmp-nvim-lsp",
+      "ray-x/lsp_signature.nvim",
+      "jubnzv/virtual-types.nvim",
+      { 'folke/neodev.nvim',            opts = {} },
+      { "lvimuser/lsp-inlayhints.nvim", config = true },
+      {
+        "p00f/clangd_extensions.nvim",
+        config = function()
+          require("clangd_extensions").setup({
+          })
+        end
+      },
+    },
+  },
+  {
+    'nvim-lualine/lualine.nvim',
+    opts = {
+      options = {
+        icons_enabled = false,
+        theme = 'gruvbox_dark',
+        component_separators = '',
+        section_separators = '|',
+      },
+      sections = {
+        lualine_a = { 'filetype', { 'filename', path = 1 } },
+        lualine_b = { '%l/%L:%c:%o' },
+        lualine_c = { 'diff' },
+        lualine_x = { 'searchcount, selectioncount' },
+        lualine_y = {},
+        lualine_z = { 'diagnostics' }
+      },
+      inactive_sections = {
+        lualine_a = { 'filename' },
+        lualine_b = {},
+        lualine_c = {},
+        lualine_x = {},
+        lualine_y = {},
+        lualine_z = {}
+      },
+    },
+  },
+  {
+    "nvimtools/none-ls.nvim",
+    config = function()
+      local nls = require("null-ls")
+      nls.setup({
+        on_attach = function(client, bufnr)
+          require("cfg.lsp").on_attach_wrapper(
+            client,
+            bufnr,
+            { auto_format = true }
+          )
+        end,
+        sources = {
+          nls.builtins.formatting.black,
+        }
+      })
+    end,
+  },
+  "https://gitlab.com/HiPhish/rainbow-delimiters.nvim",
+}