From 1dc846082bca78ec0a7a4da730bfafdeb5b3eb7f Mon Sep 17 00:00:00 2001 From: ItaloBorrelli Date: Tue, 9 Sep 2025 11:37:30 -0700 Subject: [PATCH] Add missed files --- .config/nvim/lua/jdtls/jdtls_setup.lua | 264 ++++++++++++++++++ .config/nvim/lua/jdtls/keymaps.lua | 104 +++++++ .../lua/plugins/language_support/gradle.lua | 10 + .config/nvim/lua/utils.lua | 35 +++ 4 files changed, 413 insertions(+) create mode 100644 .config/nvim/lua/jdtls/jdtls_setup.lua create mode 100644 .config/nvim/lua/jdtls/keymaps.lua create mode 100644 .config/nvim/lua/plugins/language_support/gradle.lua create mode 100644 .config/nvim/lua/utils.lua diff --git a/.config/nvim/lua/jdtls/jdtls_setup.lua b/.config/nvim/lua/jdtls/jdtls_setup.lua new file mode 100644 index 0000000..5000760 --- /dev/null +++ b/.config/nvim/lua/jdtls/jdtls_setup.lua @@ -0,0 +1,264 @@ +local utils = require("utils") + +local M = {} + +function M.setup() + local jdtls = require("jdtls") + local jdtls_dap = require("jdtls.dap") + local jdtls_setup = require("jdtls.setup") + local home = os.getenv("HOME") + + local root_markers = { ".git", "mvnw", "gradlew" } + local root_dir = jdtls_setup.find_root(root_markers) + + local project_name = vim.fn.fnamemodify(root_dir, ":p:h:t") + local workspace_dir = home .. "/.cache/jdtls/workspace/" .. project_name + + local path_to_nvim_packages = home .. "/.local/share/nvim" + local path_to_mason_packages = home .. "/.local/share/nvim/mason/packages" + + local path_to_jdtls = path_to_mason_packages .. "/jdtls" + local path_to_java_dap = path_to_mason_packages .. "/java-debug-adapter" + local path_to_jtest = path_to_mason_packages .. "/java-test" + + local path_to_config = path_to_jdtls .. "/config_linux" + local lombok_path = path_to_jdtls .. "/lombok.jar" + + local path_to_jar = vim.fn.glob(path_to_jdtls .. "/plugins/org.eclipse.equinox.launcher_*.jar", true) + + local bundles = { + -- vim.fn.glob(path_to_java_dap .. "/extension/server/com.microsoft.java.debug.plugin-*.jar", true), + vim.fn.glob( + path_to_nvim_packages + .. "/java-debug/com.microsoft.java.debug.plugin/target/com.microsoft.java.debug.plugin-*.jar" + ), + } + vim.list_extend(bundles, vim.split(vim.fn.glob(path_to_nvim_packages .. "/vscode-java-test/server/*.jar"), "\n")) + + -- vim.list_extend(bundles, vim.split(vim.fn.glob(path_to_jtest .. "/extension/server/*.jar", true), "\n")) + + local on_attach = function(_, bufnr) + -- Regular Neovim LSP client keymappings + local opts = { noremap = true, silent = true, buffer = bufnr } + local telescope = require("telescope.builtin") + utils.nmapkey("gR", telescope.lsp_references, "Go to references", opts) + utils.nmapkey("gD", jdtls.declaration, "Go to declaration", opts) + utils.nmapkey("K", jdtls.hover, "Hover text", opts) + utils.nmapkey("gd", jdtls.definition, "Go to definition", opts) + utils.nmapkey("gi", jdtls.implementation, "Go to implementation", opts) + utils.nmapkey("gt", telescope.lsp_type_definitions, "Show LSP type definitions", opts) + utils.nmapkey("", jdtls.signature_help, "Show signature", opts) + + utils.nmapkey("wa", jdtls.add_workspace_folder, "Add workspace folder", opts) + utils.nmapkey("wr", jdtls.remove_workspace_folder, "Remove workspace folder", opts) + utils.nmapkey("wl", function() + print(vim.inspect(jdtls.list_workspace_folders())) + end, "List workspace folders", opts) + + utils.nmapkey("D", telescope.diagnostics({ bufnr = 0 }), "Show buffer diagnostics", opts) -- show diagnostics for file + utils.nmapkey("d", vim.diagnostic.open_float, "Show line diagnostics", opts) -- show diagnostics for line + utils.nmapkey("[d", function() + vim.diagnostic.jump({ count = -1, float = true }) + end, "Go to previous diagnostic", opts) -- jump to previous diagnostic in buffer + utils.nmapkey("]d", function() + vim.diagnostic.jump({ count = 1, float = true }) + end, "Go to next diagnostic", opts) -- jump to next diagnostic in buffer + utils.nmapkey("rs", "LspRestart", "Restart LSP", opts) -- mapping to restart lsp if necessary + + -- Java extensions provided by jdtls + utils.nmapkey("di", jdtls.organize_imports, "Organize imports", opts) + utils.nmapkey("dt", jdtls.test_class, "Test class", opts) + utils.nmapkey("dn", jdtls.test_nearest_method, "Test nearest method", opts) + + utils.nmapkey("cf", jdtls.formatting, "LSP Format", opts) + + utils.nmapkey("", jdtls.organize_imports, "Organize imports", opts) + utils.mapkey({ "n", "v" }, "ev", jdtls.extract_variable, "Extract variable", opts) + utils.mapkey({ "n", "v" }, "ec", jdtls.extract_constant, "Extract constant", opts) + utils.mapkey({ "n", "v" }, "em", jdtls.extract_variable, "Extract method", opts) + end + + local config = { + init_options = { + bundles = vim.split(vim.fn.glob("/home/iborrelli/pde/extension/server/*.jar"), "\n"), + }, + flags = { + allow_incremental_sync = true, + }, + on_attach = on_attach, -- We pass our on_attach keybindings to the configuration map + } + + config.cmd = { + "/usr/lib/jvm/java-21-openjdk/bin/java", + + "-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", + "-javaagent:" .. lombok_path, + "--add-modules=ALL-SYSTEM", + "--add-opens", + "java.base/java.util=ALL-UNNAMED", + "--add-opens", + "java.base/java.lang=ALL-UNNAMED", + + "-jar", + path_to_jar, + + "-configuration", + path_to_config, + + "-data", + workspace_dir, + } + -- print(table.concat(config.cmd, " ")) + -- print(vim.inspect(config.cmd)) + + config.settings = { + java = { + references = { + includeDecompiledSources = true, + }, + -- format = { + -- enabled = true, + -- settings = { + -- url = vim.fn.stdpath("config") .. "/lang_servers/intellij-java-google-style.xml", + -- profile = "GoogleStyle", + -- }, + -- }, + eclipse = { + downloadSources = true, + }, + maven = { + downloadSources = true, + }, + -- signatureHelp = { enabled = true }, + -- contentProvider = { preferred = "fernflower" }, + implementationsCodeLens = { + enabled = true, + }, + import = { + gradle = { + wrapper = { + enabled = true, + }, + }, + }, + completion = { + favoriteStaticMembers = { + "org.hamcrest.MatcherAssert.assertThat", + "org.hamcrest.Matchers.*", + "org.hamcrest.CoreMatchers.*", + "org.junit.jupiter.api.Assertions.*", + "java.util.Objects.requireNonNull", + "java.util.Objects.requireNonNullElse", + "org.mockito.Mockito.*", + }, + filteredTypes = { + "com.sun.*", + "io.micrometer.shaded.*", + "java.awt.*", + "jdk.*", + "sun.*", + }, + importOrder = { + "java", + "javax", + "com", + "org", + }, + }, + sources = { + organizeImports = { + starThreshold = 9999, + staticStarThreshold = 9999, + }, + }, + -- codeGeneration = { + -- toString = { + -- template = "${object.className}{${member.name()}=${member.value}, ${otherMembers}}", + -- -- flags = { + -- -- allow_incremental_sync = true, + -- -- }, + -- }, + -- useBlocks = true, + -- }, + configuration = { + updateBuildConfiguration = "automatic", + runtimes = { + { + name = "JavaSE-17", + path = "/usr/lib/jvm/java-17-openjdk/", + }, + { + name = "JavaSE-21", + path = "/usr/lib/jvm/java-21-openjdk/", + }, + }, + }, + -- project = { + -- referencedLibraries = { + -- "**/lib/*.jar", + -- }, + -- }, + }, + } + -- -- LSP settings for Java. + -- local on_attach = function(_, bufnr) + -- jdtls.setup_dap({ hotcodereplace = "auto" }) + -- jdtls_dap.setup_dap_main_class_configs() + -- jdtls_setup.add_commands() + -- + -- -- Create a command `:Format` local to the LSP buffer + -- vim.api.nvim_buf_create_user_command(bufnr, "Format", function(_) + -- vim.lsp.buf.format() + -- end, { desc = "Format current buffer with LSP" }) + -- + -- require("lsp_signature").on_attach({ + -- bind = true, + -- padding = "", + -- handler_opts = { + -- border = "rounded", + -- }, + -- hint_prefix = "󱄑 ", + -- }, bufnr) + -- + -- -- NOTE: comment out if you don't use Lspsaga + -- -- require("lspsaga").init_lsp_saga() + -- end + + local capabilities = { + workspace = { + configuration = true, + }, + textDocument = { + completion = { + completionItem = { + snippetSupport = true, + }, + }, + }, + } + + config.on_attach = on_attach + config.capabilities = capabilities + config.on_init = function(client, _) + client.notify("workspace/didChangeConfiguration", { settings = config.settings }) + end + + local extendedClientCapabilities = require("jdtls").extendedClientCapabilities + extendedClientCapabilities.resolveAdditionalTextEditsSupport = true + + config.init_options = { + extendedClientCapabilities = extendedClientCapabilities, + } + + -- Start Server + require("jdtls").start_or_attach(config) + + -- -- Set Java Specific Keymaps + -- require("jdtls.keymaps") +end +return M diff --git a/.config/nvim/lua/jdtls/keymaps.lua b/.config/nvim/lua/jdtls/keymaps.lua new file mode 100644 index 0000000..3229f1a --- /dev/null +++ b/.config/nvim/lua/jdtls/keymaps.lua @@ -0,0 +1,104 @@ +-- NOTE: Java specific keymaps with which key +vim.cmd( + "command! -buffer -nargs=? -complete=custom,v:lua.require'jdtls'._complete_compile JdtCompile lua require('jdtls').compile()" +) +vim.cmd( + "command! -buffer -nargs=? -complete=custom,v:lua.require'jdtls'._complete_set_runtime JdtSetRuntime lua require('jdtls').set_runtime()" +) +vim.cmd("command! -buffer JdtUpdateConfig lua require('jdtls').update_project_config()") +vim.cmd("command! -buffer JdtJol lua require('jdtls').jol()") +vim.cmd("command! -buffer JdtBytecode lua require('jdtls').javap()") +vim.cmd("command! -buffer JdtJshell lua require('jdtls').jshell()") + +local status_ok, which_key = pcall(require, "which-key") +if not status_ok then + return +end + +local opts = { + mode = "n", -- NORMAL mode + prefix = "", + buffer = nil, -- Global mappings. Specify a buffer number for buffer local mappings + silent = true, -- use `silent` when creating keymaps + noremap = true, -- use `noremap` when creating keymaps + nowait = true, -- use `nowait` when creating keymaps +} + +local vopts = { + mode = "v", -- VISUAL mode + prefix = "", + buffer = nil, -- Global mappings. Specify a buffer number for buffer local mappings + silent = true, -- use `silent` when creating keymaps + noremap = true, -- use `noremap` when creating keymaps + nowait = true, -- use `nowait` when creating keymaps +} + +local mappings = { + J = { + name = "Java", + o = { "lua require'jdtls'.organize_imports()", "Organize Imports" }, + v = { "lua require('jdtls').extract_variable()", "Extract Variable" }, + c = { "lua require('jdtls').extract_constant()", "Extract Constant" }, + t = { "lua require'jdtls'.test_nearest_method()", "Test Method" }, + T = { "lua require'jdtls'.test_class()", "Test Class" }, + u = { "JdtUpdateConfig", "Update Config" }, + }, +} + +local vmappings = { + J = { + name = "Java", + v = { "lua require('jdtls').extract_variable(true)", "Extract Variable" }, + c = { "lua require('jdtls').extract_constant(true)", "Extract Constant" }, + m = { "lua require('jdtls').extract_method(true)", "Extract Method" }, + }, +} + +which_key.register(mappings, opts) +which_key.register(vmappings, vopts) + +-- If you want you can add here Old School Mappings. Me I setup Telescope, LSP and Lspsaga mapping somewhere else and I just reuse them + +-- vim.keymap.set("gI", vim.lsp.buf.implementation,{ desc = "[G]oto [I]mplementation" }) +-- vim.keymap.set("D", vim.lsp.buf.type_definition,{ desc = "Type [D]definition" }) +-- vim.keymap.set("hh", vim.lsp.buf.signature_help,{ desc = "Signature [H][H]elp Documentation" }) + +-- vim.keymap.set("gD", vim.lsp.buf.declaration,{ desc = "[G]oto [D]eclaration" }) +-- vim.keymap.set("wa", vim.lsp.buf.add_workspace_folder,{ desc = "[W]orkspace [A]dd Folder" }) +-- vim.keymap.set("wr", vim.lsp.buf.remove_workspace_folder,{ desc = "[W]orkspace [R]emove Folder" }) +-- vim.keymap.set("wl", function() +-- print(vim.inspect(vim.lsp.buf.list_workspace_folders())) +-- end, "[W]orkspace [L]ist Folders") + +-- Create a command `:Format` local to the LSP buffer +-- vim.api.nvim_buf_create_user_command(bufnr, "Format", function(_) +-- vim.lsp.buf.format() +-- end, { desc = "Format current buffer with LSP" }) + +-- vim.keymap.set("n", "gr", vim.lsp.buf.references, { desc = "[G]oto [R]eferences - Java", expr = true, silent = true }) +vim.keymap.set("n", "gr", require("telescope.builtin").lsp_references, { desc = "[G]oto [R]eferences" }) +vim.keymap.set("n", "gD", vim.lsp.buf.declaration, { desc = "" }) +vim.keymap.set("n", "gd", vim.lsp.buf.definition, { desc = "" }) +vim.keymap.set('n', 'K', vim.lsp.buf.hover, { desc = "" }) +vim.keymap.set('n', 'gi', vim.lsp.buf.implementation, { desc = "" }) +vim.keymap.set('n', '', vim.lsp.buf.signature_help, { desc = "" }) +vim.keymap.set('n', 'wa', vim.lsp.buf.add_workspace_folder, { desc = "" }) +vim.keymap.set('n', 'wr', vim.lsp.buf.remove_workspace_folder, { desc = "" }) +vim.keymap.set('n', 'wl', print(vim.inspect(vim.lsp.buf.list_workspace_folders()))', { desc = "" }) +vim.keymap.set('n', 'D', vim.lsp.buf.type_definition, { desc = "" }) +vim.keymap.set('n', 'rn', vim.lsp.buf.rename, { desc = "" }) +vim.keymap.set('n', 'gr', vim.lsp.buf.references() && vim.cmd("copen")', { desc = "" }) +vim.keymap.set('n', 'e', vim.lsp.diagnostic.show_line_diagnostics, { desc = "" }) +vim.keymap.set('n', '[d', vim.lsp.diagnostic.goto_prev, { desc = "" }) +vim.keymap.set('n', ']d', vim.lsp.diagnostic.goto_next, { desc = "" }) +vim.keymap.set('n', 'q', vim.lsp.diagnostic.set_loclist, { desc = "" }) + +-- Java specific +vim.keymap.set("n", "di", "lua require'jdtls'.organize_imports()", { desc = "" }) +vim.keymap.set("n", "dt", "lua require'jdtls'.test_class()", { desc = "" }) +vim.keymap.set("n", "dn", "lua require'jdtls'.test_nearest_method()", { desc = "" }) +vim.keymap.set("v", "de", "lua require('jdtls').extract_variable(true)", { desc = "" }) +vim.keymap.set("n", "de", "lua require('jdtls').extract_variable()", { desc = "" }) +vim.keymap.set("v", "dm", "lua require('jdtls').extract_method(true)", { desc = "" }) + +vim.keymap.set("n", "cf", "lua vim.lsp.buf.formatting()", { desc = "" }) diff --git a/.config/nvim/lua/plugins/language_support/gradle.lua b/.config/nvim/lua/plugins/language_support/gradle.lua new file mode 100644 index 0000000..457d500 --- /dev/null +++ b/.config/nvim/lua/plugins/language_support/gradle.lua @@ -0,0 +1,10 @@ +return { + "oclay1st/gradle.nvim", + cmd = { "Gradle", "GradleExec", "GradleInit" }, + dependencies = { + "nvim-lua/plenary.nvim", + "MunifTanjim/nui.nvim", + }, + opts = {}, -- options, see default configuration + keys = { { "G", "Gradle", desc = "Gradle" } }, +} diff --git a/.config/nvim/lua/utils.lua b/.config/nvim/lua/utils.lua new file mode 100644 index 0000000..d9c636a --- /dev/null +++ b/.config/nvim/lua/utils.lua @@ -0,0 +1,35 @@ +local M = {} + +--- Sets a non-recursive keymap with optional description. +---@param mode string|table Mode(s) for the keymap. +---@param lhs string Left-hand side of the keymap. +---@param rhs string|function Right-hand side of the keymap. +---@param desc string|nil Description for the keymap. +---@param bufopts table|nil Additional options for the keymap. +M.mapkey = function(mode, lhs, rhs, desc, bufopts) + bufopts = bufopts or {} + if desc then + bufopts.desc = desc + end + vim.keymap.set(mode, lhs, rhs, bufopts) +end + +--- Sets a non-recursive keymap for normal mode. +---@param lhs string Left-hand side of the keymap. +---@param rhs string|function Right-hand side of the keymap. +---@param desc string|nil Description for the keymap. +---@param bufopts table|nil Additional options for the keymap. +function M.nmapkey(lhs, rhs, desc, bufopts) + M.mapkey("n", lhs, rhs, desc, bufopts) +end + +--- Sets a non-recursive keymap for visual mode. +---@param lhs string Left-hand side of the keymap. +---@param rhs string|function Right-hand side of the keymap. +---@param desc string|nil Description for the keymap. +---@param bufopts table|nil Additional options for the keymap. +function M.vmapkey(lhs, rhs, desc, bufopts) + M.mapkey("v", lhs, rhs, desc, bufopts) +end + +return M