638 lines
17 KiB
Lua
638 lines
17 KiB
Lua
local lazypath = vim.fn.stdpath("data") .. "/lazy/lazy.nvim"
|
|
if not vim.loop.fs_stat(lazypath) then
|
|
vim.fn.system({
|
|
"git",
|
|
"clone",
|
|
"--filter=blob:none",
|
|
"https://github.com/folke/lazy.nvim.git",
|
|
"--branch=stable",
|
|
lazypath,
|
|
})
|
|
end
|
|
vim.opt.rtp:prepend(lazypath)
|
|
|
|
-- Basic Options
|
|
vim.g.mapleader = " "
|
|
vim.wo.number = true
|
|
vim.opt.tabstop = 2
|
|
vim.opt.softtabstop = 2
|
|
vim.opt.shiftwidth = 2
|
|
vim.opt.autoindent = true
|
|
vim.opt.smartindent = true
|
|
vim.opt.termguicolors = true
|
|
vim.opt.expandtab = true
|
|
vim.opt.clipboard = "unnamedplus" -- Use system clipboard
|
|
if vim.fn.has("win32") == 1 then
|
|
vim.g.clipboard = {
|
|
name = "win32yank",
|
|
copy = {
|
|
["+"] = "win32yank.exe -i --crlf",
|
|
["*"] = "win32yank.exe -i --crlf",
|
|
},
|
|
paste = {
|
|
["+"] = "win32yank.exe -o --lf",
|
|
["*"] = "win32yank.exe -o --lf",
|
|
},
|
|
cache_enabled = 0,
|
|
}
|
|
end
|
|
vim.opt.ignorecase = true
|
|
vim.opt.smartcase = true
|
|
|
|
-- Keymaps (Global)
|
|
local options = { noremap = true, silent = true }
|
|
vim.keymap.set("i", "jk", "<esc>", options)
|
|
|
|
-- Clipboard Mappings (IDE Style)
|
|
vim.keymap.set("v", "<C-c>", '"+y', { desc = "Copy to clipboard" })
|
|
vim.keymap.set("v", "<C-x>", '"+d', { desc = "Cut to clipboard" })
|
|
vim.keymap.set("n", "<C-v>", '"+p', { desc = "Paste from clipboard" })
|
|
vim.keymap.set("i", "<C-v>", "<C-r>+", { desc = "Paste from clipboard" })
|
|
vim.keymap.set("c", "<C-v>", "<C-r>+", { desc = "Paste from clipboard" })
|
|
vim.keymap.set("t", "<C-v>", [[<C-\><C-n>"+pa]], { desc = "Paste from clipboard" })
|
|
|
|
if vim.g.vscode then
|
|
-- VS Code specific settings/keymaps could go here
|
|
else
|
|
-- Highlight on yank
|
|
vim.api.nvim_create_autocmd("textyankpost", {
|
|
group = vim.api.nvim_create_augroup("highlight_yank", {}),
|
|
desc = "Highlight selection on yank",
|
|
pattern = "*",
|
|
callback = function()
|
|
vim.highlight.on_yank({ higroup = "incsearch", timeout = 500 })
|
|
end,
|
|
})
|
|
|
|
require("lazy").setup({
|
|
-- UI & Utilities
|
|
{
|
|
"folke/which-key.nvim",
|
|
event = "VeryLazy",
|
|
init = function()
|
|
vim.o.timeout = true
|
|
vim.o.timeoutlen = 300
|
|
end,
|
|
opts = {},
|
|
},
|
|
{ "folke/trouble.nvim", dependencies = { "nvim-tree/nvim-web-devicons" } },
|
|
{ "nvim-tree/nvim-web-devicons" },
|
|
{ "folke/neodev.nvim", opts = {} }, -- Better Lua dev experience
|
|
|
|
-- Git
|
|
{ "kdheepak/lazygit.nvim", dependencies = { "nvim-lua/plenary.nvim" } },
|
|
{ "lewis6991/gitsigns.nvim", dependencies = { "nvim-lua/plenary.nvim" } },
|
|
{ "tpope/vim-rhubarb" },
|
|
{ "tommcdo/vim-fubitive" },
|
|
{ "theprimeagen/git-worktree.nvim" },
|
|
{
|
|
"neogitorg/neogit",
|
|
dependencies = {
|
|
"nvim-lua/plenary.nvim",
|
|
"sindrets/diffview.nvim",
|
|
"nvim-telescope/telescope.nvim",
|
|
},
|
|
config = true,
|
|
},
|
|
|
|
-- Java Environment
|
|
{ "mfussenegger/nvim-jdtls", dependencies = { "mfussenegger/nvim-dap" } },
|
|
|
|
-- Debugging UI
|
|
{
|
|
"rcarriga/nvim-dap-ui",
|
|
dependencies = { "mfussenegger/nvim-dap", "nvim-neotest/nvim-nio" },
|
|
config = function()
|
|
require("dapui").setup()
|
|
local dap, dapui = require("dap"), 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
|
|
end,
|
|
},
|
|
|
|
-- LSP & Completion (The Modern Stack)
|
|
{
|
|
"williamboman/mason.nvim",
|
|
dependencies = {
|
|
"WhoIsSethDaniel/mason-tool-installer.nvim",
|
|
},
|
|
config = function()
|
|
require("mason").setup()
|
|
require("mason-tool-installer").setup({
|
|
ensure_installed = {
|
|
"black",
|
|
"isort",
|
|
"prettierd",
|
|
"stylua",
|
|
"google-java-format",
|
|
"eslint_d", -- for nvim-lint
|
|
"pylint", -- for nvim-lint
|
|
},
|
|
})
|
|
end,
|
|
},
|
|
{
|
|
"williamboman/mason-lspconfig.nvim",
|
|
dependencies = { "williamboman/mason.nvim" },
|
|
config = function()
|
|
local capabilities = require("cmp_nvim_lsp").default_capabilities()
|
|
local lspconfig = require("lspconfig")
|
|
|
|
require("mason-lspconfig").setup({
|
|
ensure_installed = { "lua_ls", "jdtls" },
|
|
automatic_installation = true,
|
|
handlers = {
|
|
function(server_name)
|
|
if server_name == "jdtls" then
|
|
-- JDTLS is handled by nvim-jdtls via autocommand below
|
|
else
|
|
lspconfig[server_name].setup({
|
|
capabilities = capabilities,
|
|
})
|
|
end
|
|
end,
|
|
},
|
|
})
|
|
end,
|
|
},
|
|
{ "neovim/nvim-lspconfig" },
|
|
{
|
|
"hrsh7th/nvim-cmp",
|
|
dependencies = {
|
|
"hrsh7th/cmp-nvim-lsp",
|
|
"hrsh7th/cmp-nvim-lua",
|
|
"hrsh7th/cmp-buffer",
|
|
"hrsh7th/cmp-cmdline",
|
|
"saadparwaiz1/cmp_luasnip",
|
|
"l3mon4d3/luasnip",
|
|
},
|
|
config = function()
|
|
local cmp = require("cmp")
|
|
local luasnip = require("luasnip")
|
|
cmp.setup({
|
|
snippet = {
|
|
expand = function(args)
|
|
luasnip.lsp_expand(args.body)
|
|
end,
|
|
},
|
|
window = {
|
|
completion = cmp.config.window.bordered(),
|
|
documentation = cmp.config.window.bordered(),
|
|
},
|
|
mapping = cmp.mapping.preset.insert({
|
|
["<C-b>"] = cmp.mapping.scroll_docs(-4),
|
|
["<C-f>"] = cmp.mapping.scroll_docs(4),
|
|
["<C-Space>"] = cmp.mapping.complete(),
|
|
["<C-e>"] = cmp.mapping.abort(),
|
|
["<CR>"] = cmp.mapping.confirm({ select = true }),
|
|
["<Tab>"] = cmp.mapping(function(fallback)
|
|
if cmp.visible() then
|
|
cmp.select_next_item()
|
|
elseif luasnip.expand_or_jumpable() then
|
|
luasnip.expand_or_jump()
|
|
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" }),
|
|
}),
|
|
sources = cmp.config.sources({
|
|
{ name = "nvim_lsp" },
|
|
{ name = "luasnip" },
|
|
{ name = "nvim_lua" },
|
|
}, {
|
|
{ name = "buffer" },
|
|
}),
|
|
})
|
|
end,
|
|
},
|
|
|
|
-- Editing
|
|
{
|
|
"stevearc/conform.nvim",
|
|
opts = {
|
|
formatters_by_ft = {
|
|
lua = { "stylua" },
|
|
python = { "isort", "black" },
|
|
javascript = { "prettierd", "prettier", stop_after_first = true },
|
|
java = { "google-java-format" },
|
|
},
|
|
format_on_save = {
|
|
timeout_ms = 500,
|
|
lsp_fallback = true,
|
|
},
|
|
},
|
|
},
|
|
{
|
|
"mfussenegger/nvim-lint",
|
|
event = { "BufReadPre", "BufNewFile" },
|
|
config = function()
|
|
local lint = require("lint")
|
|
lint.linters_by_ft = {
|
|
javascript = { "eslint_d" },
|
|
typescript = { "eslint_d" },
|
|
javascriptreact = { "eslint_d" },
|
|
typescriptreact = { "eslint_d" },
|
|
python = { "pylint" },
|
|
}
|
|
|
|
local lint_augroup = vim.api.nvim_create_augroup("lint", { clear = true })
|
|
vim.api.nvim_create_autocmd({ "BufEnter", "BufWritePost", "InsertLeave" }, {
|
|
group = lint_augroup,
|
|
callback = function()
|
|
lint.try_lint()
|
|
end,
|
|
})
|
|
end,
|
|
},
|
|
{ "numtostr/comment.nvim", opts = {}, lazy = false },
|
|
{ "windwp/nvim-autopairs", event = "InsertEnter", opts = {} },
|
|
{ "folke/todo-comments.nvim", dependencies = { "nvim-lua/plenary.nvim" }, opts = {} },
|
|
{ "lukas-reineke/indent-blankline.nvim", main = "ibl", opts = {} },
|
|
{
|
|
"kylechui/nvim-surround",
|
|
event = "VeryLazy",
|
|
config = function()
|
|
require("nvim-surround").setup({})
|
|
end,
|
|
},
|
|
{
|
|
"Cassin01/wf.nvim",
|
|
version = "*",
|
|
config = function()
|
|
require("wf").setup()
|
|
end,
|
|
},
|
|
|
|
-- UI / Theme
|
|
{
|
|
"nvim-neo-tree/neo-tree.nvim",
|
|
branch = "v3.x",
|
|
dependencies = {
|
|
"nvim-lua/plenary.nvim",
|
|
"nvim-tree/nvim-web-devicons", -- not strictly required, but recommended
|
|
"MunifTanjim/nui.nvim",
|
|
},
|
|
},
|
|
{ "akinsho/bufferline.nvim", branch = "main", dependencies = "nvim-tree/nvim-web-devicons" },
|
|
{
|
|
"nvim-lualine/lualine.nvim",
|
|
dependencies = { "nvim-tree/nvim-web-devicons" },
|
|
opts = { theme = "codedark" },
|
|
},
|
|
{
|
|
"folke/tokyonight.nvim",
|
|
lazy = false,
|
|
priority = 1000,
|
|
opts = {
|
|
on_highlights = function(hl, c)
|
|
-- Ensure high contrast for popup menu
|
|
hl.Pmenu = { bg = "#1f2335", fg = "#c0caf5" }
|
|
hl.PmenuSel = { bg = "#3d59a1", fg = "#ffffff", bold = true }
|
|
hl.FloatBorder = { fg = "#3d59a1" }
|
|
end,
|
|
},
|
|
},
|
|
{ "hiphish/rainbow-delimiters.nvim" },
|
|
|
|
-- Telescope
|
|
{ "nvim-telescope/telescope.nvim", dependencies = { "nvim-lua/plenary.nvim" } },
|
|
{ "lukaspietzschmann/telescope-tabs", dependencies = { "nvim-telescope/telescope.nvim" } },
|
|
|
|
-- Treesitter
|
|
{
|
|
"nvim-treesitter/nvim-treesitter",
|
|
build = ":TSUpdate",
|
|
config = function()
|
|
require("nvim-treesitter.configs").setup({
|
|
ensure_installed = {
|
|
"lua",
|
|
"groovy",
|
|
"java",
|
|
"c",
|
|
"cpp",
|
|
"javascript",
|
|
"python",
|
|
"yaml",
|
|
"json",
|
|
"xml",
|
|
"html",
|
|
"ssh_config",
|
|
"csv",
|
|
"vim",
|
|
"vimdoc",
|
|
"query",
|
|
"markdown",
|
|
"markdown_inline",
|
|
},
|
|
sync_install = false,
|
|
highlight = { enable = true },
|
|
indent = { enable = true },
|
|
})
|
|
end,
|
|
},
|
|
|
|
-- Flash
|
|
{
|
|
"folke/flash.nvim",
|
|
event = "VeryLazy",
|
|
opts = {},
|
|
keys = {
|
|
{
|
|
"s",
|
|
mode = { "n", "x", "o" },
|
|
function()
|
|
require("flash").jump()
|
|
end,
|
|
desc = "flash",
|
|
},
|
|
{
|
|
"S",
|
|
mode = { "n", "x", "o" },
|
|
function()
|
|
require("flash").treesitter()
|
|
end,
|
|
desc = "flash treesitter",
|
|
},
|
|
{
|
|
"r",
|
|
mode = "o",
|
|
function()
|
|
require("flash").remote()
|
|
end,
|
|
desc = "remote flash",
|
|
},
|
|
{
|
|
"R",
|
|
mode = { "o", "x" },
|
|
function()
|
|
require("flash").treesitter_search()
|
|
end,
|
|
desc = "treesitter search",
|
|
},
|
|
{
|
|
"<c-s>",
|
|
mode = { "c" },
|
|
function()
|
|
require("flash").toggle()
|
|
end,
|
|
desc = "toggle flash search",
|
|
},
|
|
},
|
|
},
|
|
|
|
-- Markdown
|
|
{
|
|
"iamcco/markdown-preview.nvim",
|
|
cmd = { "Markdownpreviewtoggle", "Markdownpreview", "Markdownpreviewstop" },
|
|
build = "cd app && yarn install",
|
|
init = function()
|
|
vim.g.mkdp_filetypes = { "markdown" }
|
|
end,
|
|
ft = { "markdown" },
|
|
},
|
|
})
|
|
|
|
-- Configs
|
|
vim.g.fubitive_domain_pattern = "bitbucket.ingg.com"
|
|
|
|
-- Correctly setup indent-blankline
|
|
require("ibl").setup({})
|
|
|
|
require("bufferline").setup({})
|
|
|
|
-- Telescope Setup
|
|
local telescope = require("telescope")
|
|
local open_with_trouble = require("trouble.sources.telescope").open
|
|
telescope.setup({
|
|
defaults = {
|
|
mappings = {
|
|
i = { ["<c-t>"] = open_with_trouble },
|
|
n = { ["<c-t>"] = open_with_trouble },
|
|
},
|
|
},
|
|
})
|
|
telescope.load_extension("git_worktree")
|
|
|
|
-- Git Worktree
|
|
local worktree = require("git-worktree")
|
|
worktree.on_tree_change(function(op, metadata)
|
|
if op == worktree.operations.switch then
|
|
print("switched from " .. metadata.prev_path .. " to " .. metadata.path)
|
|
end
|
|
end)
|
|
|
|
-- Lualine
|
|
require("lualine").setup({
|
|
sections = {
|
|
lualine_a = { "mode" },
|
|
lualine_b = { { "b:gitsigns_head", icon = "" }, "diff", "diagnostics" },
|
|
},
|
|
})
|
|
|
|
-- Colorscheme
|
|
vim.cmd([[colorscheme tokyonight-night]])
|
|
|
|
-- Keymaps
|
|
-- IntelliJ-like Mappings
|
|
vim.keymap.set("n", "<A-CR>", vim.lsp.buf.code_action, { desc = "Code Action (Alt+Enter)" })
|
|
vim.keymap.set("n", "<S-F6>", vim.lsp.buf.rename, { desc = "Rename Symbol (Shift+F6)" })
|
|
vim.keymap.set("n", "<C-A-l>", function()
|
|
require("conform").format({ async = true, lsp_fallback = true })
|
|
end, { desc = "Reformat Code (Ctrl+Alt+L)" })
|
|
|
|
-- Navigation & Search
|
|
vim.keymap.set("n", "<C-n>", require("telescope.builtin").find_files, { desc = "Go to File (Ctrl+N)" })
|
|
vim.keymap.set("n", "<C-S-n>", require("telescope.builtin").live_grep, { desc = "Find in Path" })
|
|
vim.keymap.set("n", "<leader><leader>", require("telescope.builtin").buffers, { desc = "Search Open Files" })
|
|
|
|
-- LSP Navigation
|
|
vim.keymap.set("n", "gd", vim.lsp.buf.definition, { desc = "Go to Definition" })
|
|
vim.keymap.set("n", "gi", vim.lsp.buf.implementation, { desc = "Go to Implementation" })
|
|
vim.keymap.set("n", "gr", require("telescope.builtin").lsp_references, { desc = "Find Usages" })
|
|
vim.keymap.set("n", "K", vim.lsp.buf.hover, { desc = "Hover Documentation" })
|
|
vim.keymap.set("n", "[d", vim.diagnostic.goto_prev, { desc = "Previous Diagnostic" })
|
|
vim.keymap.set("n", "]d", vim.diagnostic.goto_next, { desc = "Next Diagnostic" })
|
|
|
|
-- Existing Mappings
|
|
vim.keymap.set("n", "<leader>e", ":Neotree toggle<CR>", { desc = "Toggle Explorer" })
|
|
vim.keymap.set("n", "<leader>ft", ":TodoTelescope<CR>", { desc = "Find TODOs" })
|
|
vim.keymap.set("n", "<leader>ff", require("telescope.builtin").find_files, { desc = "List Files" })
|
|
vim.keymap.set("n", "<leader>fg", require("telescope.builtin").live_grep, { desc = "Search Current Dir" })
|
|
vim.keymap.set("n", "<leader>fh", require("telescope.builtin").help_tags, { desc = "List Help Tags" })
|
|
vim.keymap.set("n", "<leader>lg", ":LazyGit<CR>", { desc = "LazyGit" })
|
|
|
|
vim.keymap.set("n", "<leader>gws", ":telescope git_worktree git_worktrees<CR>", { desc = "List Git Worktrees" })
|
|
vim.keymap.set(
|
|
"n",
|
|
"<leader>gwc",
|
|
":telescope git_worktree create_git_worktree<CR>",
|
|
{ desc = "Create Git Worktrees " }
|
|
)
|
|
|
|
vim.keymap.set("n", "<leader>r", ":!%:p<CR>", { desc = "Run file" })
|
|
|
|
-- Trouble (IntelliJ "Problems" View)
|
|
vim.keymap.set("n", "<leader>xx", function()
|
|
require("trouble").toggle()
|
|
end, { desc = "Toggle Problems View" })
|
|
vim.keymap.set("n", "<leader>xw", function()
|
|
require("trouble").toggle("workspace_diagnostics")
|
|
end, { desc = "Workspace Problems" })
|
|
vim.keymap.set("n", "<leader>xd", function()
|
|
require("trouble").toggle("document_diagnostics")
|
|
end, { desc = "Document Problems" })
|
|
|
|
vim.keymap.set("t", "<Esc>", [[<C-\><C-n>]], { desc = "Escape from terminal" })
|
|
|
|
-- GitSigns
|
|
require("gitsigns").setup({
|
|
on_attach = function(bufnr)
|
|
local gs = package.loaded.gitsigns
|
|
|
|
local function map(mode, l, r, opts)
|
|
opts = opts or {}
|
|
opts.buffer = bufnr
|
|
vim.keymap.set(mode, l, r, opts)
|
|
end
|
|
|
|
-- 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 })
|
|
|
|
map("n", "[c", function()
|
|
if vim.wo.diff then
|
|
return "[c"
|
|
end
|
|
vim.schedule(function()
|
|
gs.prev_hunk()
|
|
end)
|
|
return "<ignore>"
|
|
end, { expr = true })
|
|
|
|
-- Actions
|
|
map("n", "<leader>hs", gs.stage_hunk, { desc = "Stage Hunk" })
|
|
map("n", "<leader>hr", gs.reset_hunk, { desc = "Reset Hunk" })
|
|
map("v", "<leader>hs", function()
|
|
gs.stage_hunk({ vim.fn.line("."), vim.fn.line("v") })
|
|
end, { desc = "Stage Hunk (v)" })
|
|
map("v", "<leader>hr", function()
|
|
gs.reset_hunk({ vim.fn.line("."), vim.fn.line("v") })
|
|
end, { desc = "Reset Hunk (v)" })
|
|
map("n", "<leader>hS", gs.stage_buffer, { desc = "Stage Buffer" })
|
|
map("n", "<leader>hu", gs.undo_stage_hunk, { desc = "Undo Stage Hunk" })
|
|
map("n", "<leader>hR", gs.reset_buffer, { desc = "Reset Buffer" })
|
|
map("n", "<leader>hp", gs.preview_hunk, { desc = "Preview Hunk" })
|
|
map("n", "<leader>hb", function()
|
|
gs.blame_line({ full = true })
|
|
end, { desc = "Blame Line" })
|
|
map("n", "<leader>Tb", gs.toggle_current_line_blame, { desc = "Toggle Blame" })
|
|
map("n", "<leader>hd", gs.diffthis, { desc = "Diff This" })
|
|
map("n", "<leader>hD", function()
|
|
gs.diffthis("~")
|
|
end, { desc = "Diff This ~" })
|
|
map("n", "<leader>Td", gs.toggle_deleted, { desc = "Toggle Deleted" })
|
|
|
|
-- Text Object
|
|
map({ "o", "x" }, "ih", ":<C-U>Gitsigns select_hunk<CR>")
|
|
end,
|
|
})
|
|
end
|
|
|
|
-- JDTLS Setup
|
|
local function get_jdtls_config()
|
|
local mason_registry = require("mason-registry")
|
|
if not mason_registry.is_installed("jdtls") then
|
|
vim.notify("JDTLS not installed. Run :MasonInstall jdtls", vim.log.levels.WARN)
|
|
return nil
|
|
end
|
|
|
|
local jdtls_path = vim.fn.stdpath("data") .. "/mason/packages/jdtls"
|
|
|
|
-- Find launcher jar
|
|
local launcher_jars = vim.fn.glob(jdtls_path .. "/plugins/org.eclipse.equinox.launcher_*.jar", true, true)
|
|
local launcher_jar = launcher_jars[1]
|
|
|
|
if not launcher_jar then
|
|
vim.notify("JDTLS Launcher JAR not found in " .. jdtls_path, vim.log.levels.ERROR)
|
|
return nil
|
|
end
|
|
|
|
local config_dir = jdtls_path .. (vim.fn.has("win32") == 1 and "/config_win" or "/config_linux")
|
|
local workspace_dir = vim.fn.stdpath("data")
|
|
.. "/site/java/workspace-root/"
|
|
.. vim.fn.fnamemodify(vim.fn.getcwd(), ":p:h:t")
|
|
|
|
local java_cmd = "java"
|
|
if vim.fn.has("win32") == 1 then
|
|
java_cmd = "C:/Program Files/Eclipse Adoptium/jdk-25.0.1.8-hotspot/bin/java.exe"
|
|
end
|
|
|
|
local cmd = {
|
|
java_cmd,
|
|
"-Declipse.application=org.eclipse.jdt.ls.core.id1",
|
|
"-Dosgi.bundles.defaultStartLevel=4",
|
|
"-Declipse.product=org.eclipse.jdt.ls.core.product",
|
|
"-Dlog.protocol=true",
|
|
"-Dlog.level=ALL",
|
|
"-Xmx1g",
|
|
"--add-opens",
|
|
"java.base/java.util=ALL-UNNAMED",
|
|
"--add-opens",
|
|
"java.base/java.lang=ALL-UNNAMED",
|
|
}
|
|
|
|
-- Add Lombok from Mason package if available
|
|
local lombok_jar = jdtls_path .. "/lombok.jar"
|
|
if vim.fn.filereadable(lombok_jar) == 1 then
|
|
table.insert(cmd, "-javaagent:" .. lombok_jar)
|
|
end
|
|
|
|
-- Finish constructing cmd
|
|
table.insert(cmd, "-jar")
|
|
table.insert(cmd, launcher_jar)
|
|
table.insert(cmd, "-configuration")
|
|
table.insert(cmd, config_dir)
|
|
table.insert(cmd, "-data")
|
|
table.insert(cmd, workspace_dir)
|
|
|
|
local config = {
|
|
cmd = cmd,
|
|
root_dir = require("jdtls.setup").find_root({ ".git", "mvnw", "gradlew", "pom.xml", "build.gradle" }),
|
|
capabilities = require("cmp_nvim_lsp").default_capabilities(),
|
|
}
|
|
return config
|
|
end
|
|
|
|
vim.api.nvim_create_autocmd("FileType", {
|
|
pattern = "java",
|
|
callback = function()
|
|
local config = get_jdtls_config()
|
|
if config then
|
|
require("jdtls").start_or_attach(config)
|
|
end
|
|
end,
|
|
})
|