New Feature: Add support for Gradle based groovy projects.

[rohitbishnoi]

[debuos512]

So, what would this involve exactly? Would it just be a matter of parsing the gradle file for the targets/libraries to consume? I think Java language servers already can do this... I might take a look to see if it can be borrowed...

[joshtynjala]

The JDT language server is based on Eclipse and says it uses Buildship for Gradle support. Not sure how easy that would be to integrate outside of an Eclipse-based environment.

https://github.com/eclipse/eclipse.jdt.ls

[joshzcold]

What would be the work around for this before this feature is done?
say I have all my gradle dependencies in ~/.gradle/caches/modules-2/files-2.1/
Can I manually configure the class path with a glob?
Like ~/.gradle/caches/modules-2/files-2.1/**/*

Update:
I realize that if I want this ill have to add it as a feature to https://github.com/dansomething/coc-groovy which uses this server.

[shaneikennedy]

Based on the solution implemented in the referenced PR by @joshzcold (dansomething/coc-groovy#12), it seems like the challenging part was to get the classpath but from what I understand you can get the classpath via gradlew with:

./gradlew dependencies --configuration compileClasspath

or for the runtime classpath:

./gradlew dependencies --configuration runtimeClasspath

That being said, in typical gradle fashion it only outputs in a pretty human readable way so parsing this might be annoying

[joshzcold]

@shaneikennedy the maintainer of coc-groovy made a script to handle that for the same reason

https://github.com/dansomething/coc-groovy/tree/main/utils%2Fgradle-classpath%2Fbin

He references the built jar of another one of his projects

https://github.com/dansomething/gradle-classpath

[shaneikennedy]

@joshzcold I read the PR but didn't realize that script became it's own repo :) thanks!

[gtnbssn]

I have been trying to setup groovyls in neovim: https://www.reddit.com/r/groovy/comments/1eruc6o/setting_up_groovyls_in_neovim_to_properly_find/

I got neovim to recognise the standard groovy libraries by adding this line to my config:

/Users/[my user name]/.asdf/installs/groovy/4.0.9/lib/

(It wasn't working when I was using ~/ instead of the developed form.)

But I cannot get it to find the dependencies gradle has installed, unless i write the path all the way to the jar. And so it seems I would need to write the path of every single dependency installed in gradle, which is definitely not great.

It does not seem possible to use a glob as mentioned by @joshzcold 3 years ago.

Is there a solution to get the language server to find the gradle dependencies?

[joshzcold]

@gtnbssn your comment gave me some inspiration to get this working atleast in neovim before tackling the lsp server itself.

groovy language server currently doesn't have any support for figuring out classpath for maven or gradle dynamically.

Maybe maven puts its dependencies in a generic place that groovy lsp can pick up?

In neovim for gradle support you would need to do the following.

1. Install https://github.com/dansomething/gradle-classpath

cd /opt
sudo wget https://github.com/dansomething/gradle-classpath/releases/download/1.3.0/gradle-classpath-1.3.0.zip

sudo unzip gradle-classpath-1.3.0.zip && sudo rm gradle-classpath-1.3.0.zip

cd /usr/local/bin
sudo ln -s /opt/gradle-classpath-1.3.0/bin/gradle-classpath

2. Setup neovim to execute gradle-classpath and set the classpath after attach

• Create these 2 functions somwhere before your setup for groovy-ls

local function search_up(dir_or_file)
  local found = nil
  local dir_to_check = nil
  -- get parent directory via vim expand
  local dir_template = "%:p:h"
  while not found and dir_to_check ~= "/" do
    dir_to_check = vim.fn.expand(dir_template)
    local check_path = dir_to_check .. "/" .. dir_or_file
    local check_git = dir_to_check .. "/" .. ".git"
    if vim.fn.isdirectory(check_path) == 1 or vim.fn.filereadable(check_path) == 1 then
      found = dir_to_check .. "/" .. dir_or_file
    else
      dir_template = dir_template .. ":h"
    end
    -- If we hit a .git directory then stop searching and return found even if nil
    if vim.fn.isdirectory(check_git) == 1 then
      return found
    end
  end
  return found
end

local function set_groovy_classpath()
  local Job = require("plenary.job")
  local gradle_dir = vim.fs.dirname(search_up("build.gradle"))
  vim.notify("groovyls: starting gradle dependencies install at: " .. gradle_dir, vim.log.levels.INFO)
  Job
      :new({
        command = "./gradlew",
        args = {
          "dependencies",
        },
        cwd = gradle_dir,
        on_exit = function(j, _)
          vim.schedule(function()
            if j.code ~= 0 then
              vim.notify(
                "./gradlew dependencies: " .. vim.inspect(j._stderr_results),
                vim.log.levels.ERROR
              )
            else
              Job
                  :new({
                    command = "gradle-classpath",
                    cwd = gradle_dir,
                    on_exit = function(k, _)
                      vim.schedule(function()
                        if k.code ~= 0 then
                          vim.notify("gradle-classpath: " .. vim.inspect(k._stderr_results), vim.log.levels.ERROR)
                        else
                          local _classpath_results_stdout = k._stdout_results[1]
                          local classpath_results = vim.split(_classpath_results_stdout, ":")
                          vim.notify("Setting classpath in groovyls ...", vim.log.levels.INFO)
                          local groovy_lsp_client = vim.lsp.get_clients({ name = "groovyls" })[1]
                          if not groovy_lsp_client then
                            vim.notify("Error lsp client groovyls not found.", vim.log.levels.ERROR)
                            return
                          end
                          if groovy_lsp_client.settings then
                            groovy_lsp_client.settings = vim.tbl_deep_extend(
                              "force",
                              groovy_lsp_client.settings,
                              { groovy = { classpath = classpath_results } }
                            )
                          else
                            groovy_lsp_client.config.settings = vim.tbl_deep_extend(
                              "force",
                              groovy_lsp_client.config.settings,
                              { groovy = { classpath = classpath_results } }
                            )
                          end
                          groovy_lsp_client.notify(
                            "workspace/didChangeConfiguration",
                            { settings = groovy_lsp_client.settings }
                          )
                        end
                      end)
                    end,
                  })
                  :start()
            end
          end)
        end,
      })
      :start()
end

• call the set_groovy_classpath function in on_attach when you are setting up your lsp server

["groovyls"] = function()
    lspconfig.groovyls.setup({
        on_attach = function(client, bufnr)
            on_attach(client, bufnr)
            set_groovy_classpath()
        end,
    })
end,

It takes a while for groovy-ls to initialize before I can start using it, but I was able to get my gradle dependencies with this method.

plenary is required for this to work, but you probably already have that plugin

Results

build.gradle

Make sure you look at the lsp logs for errors while you are debugging any issues

truncate -s 0G ~/.local/state/nvim/lsp.log && tail -f ~/.local/state/nvim/lsp.log

[joshzcold]

I believe here is where groovy-language-server gets most of its built-in classes, otherwise its up to parents to provide the additional classpaths

groovy-language-server/src/main/java/net/prominic/groovyls/config/CompilationUnitFactory.java

Line 74 in 7be0244

classLoader = new GroovyClassLoader(ClassLoader.getSystemClassLoader().getParent(), config, true);

[joshzcold]

These features might be the ultimate solution

eclipse-jdtls/eclipse.jdt.ls#491
groovy/groovy-eclipse#811

eclipse.jdt.ls already supports gradle and maven builds and has way more LSP support built out than groovy-language-server. Its just getting maintainers to dedicate time to groovy seems to be the issue.

[gtnbssn]

Wow, I wasn't expecting such a quick and detailed answer on this issue! Thank you so much!

I tried your suggestion, however the gradle-classpath script takes a whole 3 minutes each time on my m2air.

I will stick to my dirty DIY solution for now, or just use intelliJ. Curious to see if a more ideal solution for neovim comes along one day!

[stefanoboriero]

If "Support for gradle based projects" is just a matter of providing the additional classpath jar locations for external dependencies, this might be doable with gradle tooling api https://docs.gradle.org/current/userguide/tooling_api.html. I did a quick sanity check this would actually work master...stefanoboriero:groovy-language-server:gradle-dependency-support and briefly testing on a blank new Micronaut project. I'd be happy to work on it and open a proper PR if the maintainers are onboard with this feature and approach.

[pvangeel]

I had a go at this in #106
Seems to work for me.

I had to do some slight modifications as I have a multi-language gradle project (kotlin + java + groovy) and it seems to work.

I also added a command line argument to communicate with the LSP over tcp (this allowed for easier debugging)