dotfiles/.config/nvim/lua/plugins/language.lua

return {
    {
        "nvim-treesitter/nvim-treesitter",
        opts = {
            auto_install = true,
            ensure_installed = Custom.language.treesitter_install,
        },
    },
    {
        "stevearc/conform.nvim",
        opts = {
            formatters_by_ft = Custom.language.formatters_by_ft,
            formatters = Custom.language.formatters,
        },
    },
    {
        "neovim/nvim-lspconfig",
        opts = {
            servers = Custom.language.lsp,
            setup = Custom.language.lsp_setup,
        },
    },
    {
        "mfussenegger/nvim-lint",
        opts = {
            linters_by_ft = Custom.language.linters_by_ft,
            linters = Custom.language.linters,
        },
    },
    {
        "williamboman/mason.nvim",
        opts = {
            ensure_installed = Custom.language.mason_install,
        },
    },
    {
        "hrsh7th/nvim-cmp",
        opts = function(_, opts)
            local cmp = require("cmp")
            local function has_words_before()
                local line, col = (unpack or table.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
            -- stylua: ignore
            table.insert(opts.auto_brackets, "python")
            table.insert(opts.sources, { name = "crates" })

            opts.mapping = vim.tbl_deep_extend("force", opts.mapping, {
                ["<up>"] = require("cmp").mapping.select_prev_item({ behavior = cmp.SelectBehavior.Select }),
                ["<Down>"] = require("cmp").mapping.select_next_item({ behavior = cmp.SelectBehavior.Select }),
                ["<C-p>"] = require("cmp").mapping.select_prev_item({ behavior = cmp.SelectBehavior.Insert }),
                ["<C-n>"] = require("cmp").mapping.select_next_item({ behavior = cmp.SelectBehavior.Insert }),
                ["<C-k>"] = require("cmp").mapping.select_prev_item({ behavior = cmp.SelectBehavior.Insert }),
                ["<C-j>"] = require("cmp").mapping.select_next_item({ behavior = cmp.SelectBehavior.Insert }),
                ["<C-u>"] = require("cmp").mapping(cmp.mapping.scroll_docs(-4), { "i", "c" }),
                ["<C-d>"] = require("cmp").mapping(cmp.mapping.scroll_docs(4), { "i", "c" }),
                ["<C-Space>"] = cmp.mapping.confirm({ select = false }),
                ["<C-y>"] = cmp.config.disable,
                ["<C-e>"] = cmp.mapping({ i = cmp.mapping.abort(), c = cmp.mapping.close() }),
                ["<CR>"] = vim.NIL,
                ["<Tab>"] = cmp.mapping(function(fallback)
                    if cmp.visible() then
                        cmp.select_next_item()
                    elseif require("luasnip").expand_or_locally_jumpable() then
                        require("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 require("luasnip").jumpable(-1) then
                        require("luasnip").jump(-1)
                    else
                        fallback()
                    end
                end, { "i", "s" }),
            })
        end,
    },
    {
        "mfussenegger/nvim-ansible",
        keys = {
            {
                "<leader>tr",
                function()
                    require("ansible").run()
                end,
                silent = true,
            },
        },
        {
            "b0o/SchemaStore.nvim",
            lazy = true,
            version = false,
        },
    },
    {
        "iamcco/markdown-preview.nvim",
        cmd = { "MarkdownPreviewToggle", "MarkdownPreview", "MarkdownPreviewStop" },
        build = function()
            vim.fn["mkdp#util#install"]()
        end,
        keys = {
            {
                "<leader>cp",
                ft = "markdown",
                "<cmd>MarkdownPreviewToggle<cr>",
                desc = "Markdown Preview",
            },
        },
        config = function()
            vim.cmd([[do FileType]])
        end,
    },
    {
        "nvim-neotest/neotest",
        dependencies = {
            "nvim-neotest/neotest-python",
        },
        opts = function(_, opts)
            local _, rt = pcall(require, "rustaceanvim.neotest")
            opts.adapters = vim.tbl_deep_extend("force", opts.adapters, {
                ["neotest-python"] = {},
                rt,
            })
        end,
    },
    {
        "mfussenegger/nvim-dap-python",
        -- stylua: ignore
        keys = {
            { "<leader>dPt", function() require("dap-python").test_method() end, desc = "Debug Method", ft = "python" },
            { "<leader>dPc", function() require("dap-python").test_class() end, desc = "Debug Class", ft = "python" },
        },
        config = function()
            local path = require("mason-registry").get_package("debugpy"):get_install_path()
            require("dap-python").setup(path .. "/venv/bin/python")
        end,
    },
    {
        "linux-cultist/venv-selector.nvim",
        cmd = "VenvSelect",
        opts = function(_, opts)
            if LazyVim.has("nvim-dap-python") then
                opts.dap_enabled = true
            end
            return vim.tbl_deep_extend("force", opts, {
                name = {
                    "venv",
                    ".venv",
                    "env",
                    ".env",
                },
            })
        end,
        keys = { { "<leader>cv", "<cmd>:VenvSelect<cr>", desc = "Select VirtualEnv" } },
    },
    {
        "Saecki/crates.nvim",
        event = { "BufRead Cargo.toml" },
        opts = {
            src = {
                cmp = { enabled = true },
            },
        },
    },
    {
        "mrcjkb/rustaceanvim",
        version = "^4",
        ft = { "rust" },
        opts = {
            server = {
                on_attach = function(_, bufnr)
                    vim.keymap.set("n", "<leader>cR", function()
                        vim.cmd.RustLsp("codeAction")
                    end, { desc = "Code Action", buffer = bufnr })
                    vim.keymap.set("n", "<leader>dr", function()
                        vim.cmd.RustLsp("debuggables")
                    end, { desc = "Rust Debuggables", buffer = bufnr })
                end,
                default_settings = {
                    ["rust-analyzer"] = {
                        cargo = {
                            allFeatures = true,
                            loadOutDirsFromCheck = true,
                            runBuildScripts = true,
                        },
                        checkOnSave = {
                            allFeatures = true,
                            command = "clippy",
                            extraArgs = { "--no-deps" },
                        },
                        procMacro = {
                            enable = true,
                            ignored = {
                                ["async-trait"] = { "async_trait" },
                                ["napi-derive"] = { "napi" },
                                ["async-recursion"] = { "async_recursion" },
                            },
                        },
                    },
                },
            },
        },
        config = function(_, opts)
            vim.g.rustaceanvim = vim.tbl_deep_extend("keep", vim.g.rustaceanvim or {}, opts or {})
        end,
    },
}