eclipse.jdt.ls VS vim-fugitive

Thanks Eclipse : https://github.com/eclipse-jdtls/eclipse.jdt.ls

I installed eclipse jdtls which worked for Java, but I was not able to go to definitions for methods/classes outside of my project (ie, libraries and such, something like in IntelliJ where you can go to the definition or implementation for the library code), so I thought it may be a limitation of nvim-lspconfig

return { { "neovim/nvim-lspconfig", dependencies = { "mfussenegger/nvim-jdtls", init = function() require("lazyvim.util").on_attach(function(_, buffer) -- stylua: ignore vim.keymap.set( "n", "di", "lua require'jdtls'.organize_imports()", { buffer = buffer, desc = "Organize Imports" } ) vim.keymap.set( "n", "dt", "lua require'jdtls'.test_class()", { buffer = buffer, desc = "Test Class" } ) vim.keymap.set( "n", "dn", "lua require'jdtls'.test_nearest_method()", { buffer = buffer, desc = "Test Nearest Method" } ) vim.keymap.set( "v", "de", "lua require('jdtls').extract_variable(true)", { buffer = buffer, desc = "Extract Variable" } ) vim.keymap.set( "n", "de", "lua require('jdtls').extract_variable()", { buffer = buffer, desc = "Extract Variable" } ) vim.keymap.set( "v", "dm", "lua require('jdtls').extract_method(true)", { buffer = buffer, desc = "Extract Method" } ) vim.keymap.set( "n", "cf", "lua vim.lsp.buf.formatting()", { buffer = buffer, desc = "Format" } ) end) end, }, ---@class PluginLspOpts opts = { ---@type lspconfig.options servers = {}, -- you can do any additional lsp server setup here -- return true if you don't want this server to be setup with lspconfig ---@type table setup = { -- example to setup with typescript.nvim jdtls = function(_, opts) local project_name = vim.fn.fnamemodify(vim.fn.getcwd(), ":p:h:t") -- vim.lsp.set_log_level('DEBUG') local workspace_dir = "/home/jake/.workspace/" .. project_name -- See `:help vim.lsp.start_client` for an overview of the supported `config` options. local config = { -- The command that starts the language server -- See: https://github.com/eclipse/eclipse.jdt.ls#running-from-the-command-line cmd = { "java", -- or '/path/to/java17_or_newer/bin/java' "-javaagent:/home/jake/.local/share/java/lombok.jar", -- '-Xbootclasspath/a:/home/jake/.local/share/java/lombok.jar', "-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", -- '-noverify', "-Xms1g", "--add-modules=ALL-SYSTEM", "--add-opens", "java.base/java.util=ALL-UNNAMED", "--add-opens", "java.base/java.lang=ALL-UNNAMED", "-jar", vim.fn.glob("/usr/share/java/jdtls/plugins/org.eclipse.equinox.launcher_*.jar"), "-configuration", "/usr/share/java/jdtls/config_linux", "-data", workspace_dir, }, root_dir = require("jdtls.setup").find_root({ ".git", "mvnw", "gradlew" settings = { java = {}, }, } require("jdtls").start_or_attach(config) return true end, -- Specify * to use this function as a fallback for any server -- ["*"] = function(server, opts) end, }, }, }, }

You can absolutely just use Gradle on the command line, and use a language server to get code intelligence in pretty much any editor you like. IntelliJ is very nice, especially for refactoring, but it doesn't have a giant advantage over any other editor, as long as you're sticking to mostly Java.

Try neovim. Builtin support for language servers which provide the basis for IDE functionality, autocomplete, auto import, code actions, refactoring, etc. I believe VSCode uses jdtls on the backend and you can use the same thing with neovim.

Is seems like valid manual to start language server here https://github.com/eclipse/eclipse.jdt.ls. Not sure what you mean by "starting it with other editors" though. It should be covered by editor own integration with the given LS.

But all of the above to say that Emacs can have the ability to some of if not more than VSCode. As others have said, the Jetbrains IDEs are a different story. They're built to actually understand the code you're writing. It's quite possible, with features like auto-insert and skeletons, to replicate some of the functionality that, say, IntelliJ does. For example, say you find-file into a new file for some Java project. When you first enter the buffer, you could setup a prompt to create a class, enum, interface etc. and then upon a selection, you have the basic relevant code for whatever the selection was made auto-inserted. Or you could just quit the prompt with C-g. Granted that takes some time to set up as well as recreating other smaller features that IntelliJ has. JDTLS can do some of this, but at the end of the day it's not a replacement for IntelliJ and I don't think JDTLS intends to be such.

Just the other day I tested VS Code Java again and apparently the Red Hat team that did the Java language support has gotten some level of null analysis turned on now. Thus I assume the Eclipse LSP https://github.com/eclipse/eclipse.jdt.ls has that support now.

the only reason I do some git stuff in vim and not _always_ in the shell, is because tpope is very thoughtful and fugitive.vim provides nice ways to deal with hunks or hunk partials (visually selecting a range within a hunk, for i.e.)

https://github.com/tpope/vim-fugitive/blob/master/doc/fugiti...

I agree, navigating blame history is incredibly useful, if only to save you from asking the wrong person about a particular change.

Vim's Fugitive[1] can do this and also in Textmate to. So I would hope that most editor git plugins can.

1. https://github.com/tpope/vim-fugitive

Git: vim-fugitive and gitsigns.nvim

You'll want to invest the time in learning Magit, which will change your life once you get the hang of it (and I was a heavy user of Fugitive in Vim previously!), and it's unlikely you'll find a better integration with GDB anywhere else on the planet than with Emacs, though I can't say that empirically. You just need to take the plunge and start learning it, then cut over and take the hit in productivity one day when you're feeling adventurous. You'll ultimately become far more powerful than you've ever been. Especially if you delve into elisp over time. I use Spacemacs, which is bloated and has bugs, but it has so many features that I haven't undertaken the massive endeavor to replace it from scratch yet.

For an option that works on Vim, if you already use tpope's vim-fugitive, there's vim-rhubarb (for GitHub) and fugitive-gitlab.vim (for GitLab).

I replace vim-fugitive with :! git

The only thing I truly miss from Emacs is [Magit](https://magit.vc/) since I still consider it the best git wrapper available. It is just too good. Unfortunately [Neogit](https://github.com/TimUntersberger/neogit) is not quite there yet although I hope it makes it at some point. I didn't like [Fugitive]https://github.com/tpope/vim-fugitive), but I ended up finding a good enough workaround by using [Lazygit](https://github.com/jesseduffield/lazygit) through [Toggleterm](https://github.com/akinsho/toggleterm.nvim).

I do think VSCode is a great tool and I recommend it frequently to people, but I still want to set the record straight here. Yes, vim is obviously limited in the sense that as a CLI app it doesn't draw it's own PDF or HTML windows, that's fair. But it can remote control your favorite PDF viewer or browser for roughly the same functionality. I'm currently writing my thesis using vimtex and it's quite smooth. And all the other stuff you mention is implemented quite competently by various plugins like vim-fugitive, coc.nvim, vimspector and copilot.vim.

Edit: je viens de trouver [https://github.com/tpope/vim-fugitive de Val