convert julia module

modules/plugins/languages/helm.nix

@@ -27,10 +27,10 @@
           dynamicRegistration = true;
         };
       };
-      # TODO: Reconsider this? Not sure if that necessary.
       settings = {
         helm-ls = {
           yamlls = {
+            # TODO: Determine if this is a good enough solution
             path = (head yamlCfg.lsp.servers).cmd;
           };
         };

modules/plugins/languages/java.nix

@@ -7,12 +7,59 @@
   inherit (lib.options) mkEnableOption mkOption;
   inherit (lib.modules) mkIf mkMerge;
   inherit (lib.meta) getExe;
-  inherit (lib.lists) isList;
+  inherit (builtins) attrNames;
-  inherit (lib.types) either listOf package str;
+  inherit (lib.types) listOf enum;
   inherit (lib.nvim.types) mkGrammarOption;
-  inherit (lib.nvim.lua) expToLua;
+  inherit (lib.nvim.attrsets) mapListToAttrs;
+  inherit (lib.nvim.dag) entryBefore;
+  inherit (lib.generators) mkLuaInline;
 
   cfg = config.vim.languages.java;
+
+  defaultServers = ["jdtls"];
+  servers = {
+    jdtls = {
+      enable = true;
+      cmd =
+        mkLuaInline
+        /*
+        lua
+        */
+        ''
+          {
+            '${getExe pkgs.jdt-language-server}',
+            '-configuration',
+            get_jdtls_config_dir(),
+            '-data',
+            get_jdtls_workspace_dir(),
+            get_jdtls_jvm_args(),
+          }
+        '';
+      filetypes = ["java"];
+      root_markers = [
+        # Multi-module projects
+        ".git"
+        "build.gradle"
+        "build.gradle.kts"
+        # Single-module projects
+        "build.xml" # Ant
+        "pom.xml" # Maven
+        "settings.gradle" # Gradle
+        "settings.gradle.kts" # Gradle
+      ];
+      init_options = {
+        workspace = mkLuaInline "get_jdtls_workspace_dir()";
+        jvm_args = {};
+        os_config = mkLuaInline "nil";
+      };
+      handlers = {
+        "textDocument/codeAction" = mkLuaInline "jdtls_on_textdocument_codeaction";
+        "textDocument/rename" = mkLuaInline "jdtls_on_textdocument_rename";
+        "workspace/applyEdit" = mkLuaInline "jdtls_on_workspace_applyedit";
+        "language/status" = mkLuaInline "vim.schedule_wrap(jdtls_on_language_status)";
+      };
+    };
+  };
 in {
   options.vim.languages.java = {
     enable = mkEnableOption "Java language support";
@@ -23,30 +70,107 @@ in {
     };
 
     lsp = {
-      enable = mkEnableOption "Java LSP support (java-language-server)" // {default = config.vim.lsp.enable;};
+      enable = mkEnableOption "Java LSP support" // {default = config.vim.lsp.enable;};
-      package = mkOption {
+      servers = mkOption {
-        description = "java language server package, or the command to run as a list of strings";
+        description = "Java LSP server to use";
-        example = ''[lib.getExe pkgs.jdt-language-server "-data" "~/.cache/jdtls/workspace"]'';
+        type = listOf (enum (attrNames servers));
-        type = either package (listOf str);
+        default = defaultServers;
-        default = pkgs.jdt-language-server;
       };
     };
   };
 
   config = mkIf cfg.enable (mkMerge [
     (mkIf cfg.lsp.enable {
-      vim.lsp.lspconfig.enable = true;
+      vim.luaConfigRC.jdtls-util =
-      vim.lsp.lspconfig.sources.jdtls = ''
+        entryBefore ["lsp-servers"]
-        lspconfig.jdtls.setup {
+        /*
-          capabilities = capabilities,
+        lua
-          on_attach = default_on_attach,
+        */
-          cmd = ${
+        ''
-          if isList cfg.lsp.package
+          local jdtls_handlers = require 'vim.lsp.handlers'
-          then expToLua cfg.lsp.package
+
-          else ''{"${getExe cfg.lsp.package}", "-data", vim.fn.stdpath("cache").."/jdtls/workspace"}''
+          local jdtls_env = {
-        },
+            HOME = vim.uv.os_homedir(),
-        }
+            XDG_CACHE_HOME = os.getenv 'XDG_CACHE_HOME',
-      '';
+            JDTLS_JVM_ARGS = os.getenv 'JDTLS_JVM_ARGS',
+          }
+
+          local function get_cache_dir()
+            return jdtls_env.XDG_CACHE_HOME and jdtls_env.XDG_CACHE_HOME or jdtls_env.HOME .. '/.cache'
+          end
+
+          local function get_jdtls_cache_dir()
+            return get_cache_dir() .. '/jdtls'
+          end
+
+          local function get_jdtls_config_dir()
+            return get_jdtls_cache_dir() .. '/config'
+          end
+
+          local function get_jdtls_workspace_dir()
+            return get_jdtls_cache_dir() .. '/workspace'
+          end
+
+          local function get_jdtls_jvm_args()
+            local args = {}
+            for a in string.gmatch((jdtls_env.JDTLS_JVM_ARGS or '''), '%S+') do
+              local arg = string.format('--jvm-arg=%s', a)
+              table.insert(args, arg)
+            end
+            return unpack(args)
+          end
+
+          -- TextDocument version is reported as 0, override with nil so that
+          -- the client doesn't think the document is newer and refuses to update
+          -- See: https://github.com/eclipse/eclipse.jdt.ls/issues/1695
+          local function jdtls_fix_zero_version(workspace_edit)
+            if workspace_edit and workspace_edit.documentChanges then
+              for _, change in pairs(workspace_edit.documentChanges) do
+                local text_document = change.textDocument
+                if text_document and text_document.version and text_document.version == 0 then
+                  text_document.version = nil
+                end
+              end
+            end
+            return workspace_edit
+          end
+
+          local function jdtls_on_textdocument_codeaction(err, actions, ctx)
+            for _, action in ipairs(actions) do
+              -- TODO: (steelsojka) Handle more than one edit?
+              if action.command == 'java.apply.workspaceEdit' then -- 'action' is Command in java format
+                action.edit = jdtls_fix_zero_version(action.edit or action.arguments[1])
+              elseif type(action.command) == 'table' and action.command.command == 'java.apply.workspaceEdit' then -- 'action' is CodeAction in java format
+                action.edit = jdtls_fix_zero_version(action.edit or action.command.arguments[1])
+              end
+            end
+
+            jdtls_handlers[ctx.method](err, actions, ctx)
+          end
+
+          local function jdtls_on_textdocument_rename(err, workspace_edit, ctx)
+            jdtls_handlers[ctx.method](err, jdtls_fix_zero_version(workspace_edit), ctx)
+          end
+
+          local function jdtls_on_workspace_applyedit(err, workspace_edit, ctx)
+            jdtls_handlers[ctx.method](err, jdtls_fix_zero_version(workspace_edit), ctx)
+          end
+
+          -- Non-standard notification that can be used to display progress
+          local function jdtls_on_language_status(_, result)
+            local command = vim.api.nvim_command
+            command 'echohl ModeMsg'
+            command(string.format('echo "%s"', result.message))
+            command 'echohl None'
+          end
+        '';
+
+      vim.lsp.servers =
+        mapListToAttrs (n: {
+          name = n;
+          value = servers.${n};
+        })
+        cfg.lsp.servers;
     })
 
     (mkIf cfg.treesitter.enable {

modules/plugins/languages/julia.nix

@@ -4,63 +4,82 @@
   config,
   ...
 }: let
-  inherit (builtins) attrNames isList;
+  inherit (builtins) attrNames;
   inherit (lib.options) mkEnableOption mkOption;
-  inherit (lib.types) either listOf package str enum bool nullOr;
+  inherit (lib.types) listOf enum;
   inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.strings) optionalString;
+  inherit (lib.meta) getExe;
   inherit (lib.nvim.types) mkGrammarOption;
-  inherit (lib.nvim.lua) expToLua;
+  inherit (lib.generators) mkLuaInline;
+  inherit (lib.nvim.attrsets) mapListToAttrs;
+  inherit (lib.nvim.dag) entryBefore;
 
-  defaultServer = "julials";
+  defaultServers = ["jdtls"];
   servers = {
-    julials = {
+    jdtls = {
-      package = pkgs.julia.withPackages ["LanguageServer"];
+      enable = true;
-      internalFormatter = true;
+      cmd =
-      lspConfig = ''
+        mkLuaInline
-        lspconfig.julials.setup {
+        /*
-          capabilities = capabilities,
+        lua
-          on_attach = default_on_attach,
+        */
-          cmd = ${
+        ''
-          if isList cfg.lsp.package
+          {
-          then expToLua cfg.lsp.package
+            '${getExe (pkgs.julia.withPackages ["LanguageServer"])}',
-          else ''
+            '--startup-file=no',
-            {
+            '--history-file=no',
-              "${optionalString (cfg.lsp.package != null) "${cfg.lsp.package}/bin/"}julia",
+            '-e',
-              "--startup-file=no",
+            [[
-              "--history-file=no",
+              # Load LanguageServer.jl: attempt to load from ~/.julia/environments/nvim-lspconfig
-              "--eval",
+              # with the regular load path as a fallback
-              [[
+              ls_install_path = joinpath(
-                using LanguageServer
+                  get(DEPOT_PATH, 1, joinpath(homedir(), ".julia")),
-
+                  "environments", "nvim-lspconfig"
-                depot_path = get(ENV, "JULIA_DEPOT_PATH", "")
+              )
-                project_path = let
+              pushfirst!(LOAD_PATH, ls_install_path)
-                    dirname(something(
+              using LanguageServer
-                        ## 1. Finds an explicitly set project (JULIA_PROJECT)
+              popfirst!(LOAD_PATH)
-                        Base.load_path_expand((
+              depot_path = get(ENV, "JULIA_DEPOT_PATH", "")
-                            p = get(ENV, "JULIA_PROJECT", nothing);
+              project_path = let
-                            p === nothing ? nothing : isempty(p) ? nothing : p
+                  dirname(something(
-                        )),
+                      ## 1. Finds an explicitly set project (JULIA_PROJECT)
-                        ## 2. Look for a Project.toml file in the current working directory,
+                      Base.load_path_expand((
-                        ##    or parent directories, with $HOME as an upper boundary
+                          p = get(ENV, "JULIA_PROJECT", nothing);
-                        Base.current_project(),
+                          p === nothing ? nothing : isempty(p) ? nothing : p
-                        ## 3. First entry in the load path
+                      )),
-                        get(Base.load_path(), 1, nothing),
+                      ## 2. Look for a Project.toml file in the current working directory,
-                        ## 4. Fallback to default global environment,
+                      ##    or parent directories, with $HOME as an upper boundary
-                        ##    this is more or less unreachable
+                      Base.current_project(),
-                        Base.load_path_expand("@v#.#"),
+                      ## 3. First entry in the load path
-                    ))
+                      get(Base.load_path(), 1, nothing),
-                end
+                      ## 4. Fallback to default global environment,
-                @info "Running language server" VERSION pwd() project_path depot_path
+                      ##    this is more or less unreachable
-                server = LanguageServer.LanguageServerInstance(stdin, stdout, project_path, depot_path)
+                      Base.load_path_expand("@v#.#"),
-                server.runlinter = true
+                  ))
-                run(server)
+              end
-              ]]
+              @info "Running language server" VERSION pwd() project_path depot_path
-            }
+              server = LanguageServer.LanguageServerInstance(stdin, stdout, project_path, depot_path)
-          ''
+              server.runlinter = true
-        }
+              run(server)
-        }
+            ]],
-      '';
+          }
+        '';
+      filetypes = ["julia"];
+      root_markers = ["Project.toml" "JuliaProject.toml"];
+      on_attach =
+        mkLuaInline
+        /*
+        lua
+        */
+        ''
+          function(_, bufnr)
+              vim.api.nvim_buf_create_user_command(bufnr, 'LspJuliaActivateEnv', activate_julia_env, {
+                desc = 'Activate a Julia environment',
+                nargs = '?',
+                complete = 'file',
+              })
+          end
+        '';
     };
   };
 
@@ -76,11 +95,10 @@ in {
       };
 
       lsp = {
-        enable = mkOption {
+        enable = mkEnableOption "Java LSP support" // {default = config.vim.lsp.enable;};
-          type = bool;
+        servers = mkOption {
-          default = config.vim.lsp.enable;
           description = ''
-            Whether to enable Julia LSP support.
+            Julia LSP Server to Use
 
             ::: {.note}
             The entirety of Julia is bundled with nvf, if you enable this
@@ -92,21 +110,8 @@ in {
             Julia in your devshells.
             :::
           '';
-        };
+          type = listOf (enum (attrNames servers));
-
+          default = defaultServers;
-        server = mkOption {
-          type = enum (attrNames servers);
-          default = defaultServer;
-          description = "Julia LSP server to use";
-        };
-
-        package = mkOption {
-          description = ''
-            Julia LSP server package, `null` to use the Julia binary in {env}`PATH`, or
-            the command to run as a list of strings.
-          '';
-          type = nullOr (either package (listOf str));
-          default = servers.${cfg.lsp.server}.package;
         };
       };
     };
@@ -119,8 +124,70 @@ in {
     })
 
     (mkIf cfg.lsp.enable {
-      vim.lsp.lspconfig.enable = true;
+      vim.luaConfigRC.julia-util =
-      vim.lsp.lspconfig.sources.julia-lsp = servers.${cfg.lsp.server}.lspConfig;
+        entryBefore ["lsp-servers"]
+        /*
+        lua
+        */
+        ''
+          local function activate_julia_env(path)
+            assert(vim.fn.has 'nvim-0.10' == 1, 'requires Nvim 0.10 or newer')
+            local bufnr = vim.api.nvim_get_current_buf()
+            local julials_clients = vim.lsp.get_clients { bufnr = bufnr, name = 'julials' }
+            assert(
+              #julials_clients > 0,
+              'method julia/activateenvironment is not supported by any servers active on the current buffer'
+            )
+            local function _activate_env(environment)
+              if environment then
+                for _, julials_client in ipairs(julials_clients) do
+                  julials_client:notify('julia/activateenvironment', { envPath = environment })
+                end
+                vim.notify('Julia environment activated: \n`' .. environment .. '`', vim.log.levels.INFO)
+              end
+            end
+            if path then
+              path = vim.fs.normalize(vim.fn.fnamemodify(vim.fn.expand(path), ':p'))
+              local found_env = false
+              for _, project_file in ipairs(root_files) do
+                local file = vim.uv.fs_stat(vim.fs.joinpath(path, project_file))
+                if file and file.type then
+                  found_env = true
+                  break
+                end
+              end
+              if not found_env then
+                vim.notify('Path is not a julia environment: \n`' .. path .. '`', vim.log.levels.WARN)
+                return
+              end
+              _activate_env(path)
+            else
+              local depot_paths = vim.env.JULIA_DEPOT_PATH
+                  and vim.split(vim.env.JULIA_DEPOT_PATH, vim.fn.has 'win32' == 1 and ';' or ':')
+                or { vim.fn.expand '~/.julia' }
+              local environments = {}
+              vim.list_extend(environments, vim.fs.find(root_files, { type = 'file', upward = true, limit = math.huge }))
+              for _, depot_path in ipairs(depot_paths) do
+                local depot_env = vim.fs.joinpath(vim.fs.normalize(depot_path), 'environments')
+                vim.list_extend(
+                  environments,
+                  vim.fs.find(function(name, env_path)
+                    return vim.tbl_contains(root_files, name) and string.sub(env_path, #depot_env + 1):match '^/[^/]*$'
+                  end, { path = depot_env, type = 'file', limit = math.huge })
+                )
+              end
+              environments = vim.tbl_map(vim.fs.dirname, environments)
+              vim.ui.select(environments, { prompt = 'Select a Julia environment' }, _activate_env)
+            end
+          end
+        '';
+
+      vim.lsp.servers =
+        mapListToAttrs (n: {
+          name = n;
+          value = servers.${n};
+        })
+        cfg.lsp.servers;
     })
   ]);
 }