feat: dap config and adapter for java (#3)

Author: s1n7ax

lua/java.lua

@@ -1,6 +1,6 @@
 local server = require('java.server')
 local config = require('java.config')
-local settings = require('java.settings')
+local lsp = require('java.utils.lsp')
 
 ---@class Java
 ---@field config JavaConfig
@@ -22,7 +22,7 @@ function M.get_config(root_markers)
 end
 
 M.__run = function()
-	settings.change_settings({})
+	print('>>>>>')
 end
 
 return M

lua/java/dap.lua

@@ -0,0 +1,195 @@
+local log = require('java.utils.log')
+local lsp = require('java.utils.lsp')
+local JavaDebug = require('java.ls.clients.java-debug-client')
+local Promise = require('java.utils.promise')
+
+local M = {}
+
+function M.setup_dap_on_attach()
+	vim.api.nvim_create_autocmd('LspAttach', {
+		pattern = '*',
+		callback = function(a)
+			local client = vim.lsp.get_client_by_id(a.data.client_id)
+
+			if client.name == 'jdtls' then
+				Promise.all({
+					M.set_dap_config(),
+					M.set_dap_adapter(),
+				}):catch(function(err)
+					local msg = [[Faild to set DAP configuration & adapter]]
+
+					error(msg, err)
+					log.error(msg, err)
+				end)
+			end
+		end,
+	})
+end
+
+function M.set_dap_config()
+	log.info('setting dap configurations for java')
+
+	local dap = require('dap')
+
+	return M.get_dap_config():thenCall(
+		---@type JavaDapConfigurationList
+		function(res)
+			dap.configurations.java = res
+		end
+	)
+end
+
+function M.set_dap_adapter()
+	log.info('setting dap adapter for java')
+
+	local dap = require('dap')
+
+	return M.get_dap_adapter():thenCall(
+		---@type JavaDapAdapter
+		function(res)
+			log.debug('adapter settings: ', res)
+			dap.adapters.java = res
+		end
+	)
+end
+
+---@class JavaDapAdapter
+---@field type string
+---@field host string
+---@field port integer
+
+---Returns the dap adapter config
+---@return Promise
+function M.get_dap_adapter()
+	log.info('creating dap adapter for java')
+
+	local client = lsp.get_jdtls_client()
+
+	--@TODO when thrown from the function instead of the promise,
+	--error handling has to be done in two places
+	if not client then
+		local msg = 'no active jdtls client was found'
+
+		log.error(msg)
+		error(msg)
+	end
+
+	local jdtlsClient = JavaDebug:new({
+		client = client,
+	})
+
+	return jdtlsClient:start_debug_session():thenCall(
+		---@param port JavaDebugStartDebugSessionResponse
+		function(port)
+			return {
+				type = 'server',
+				host = '127.0.0.1',
+				port = port,
+			}
+		end
+	)
+end
+
+---@class JavaDapConfiguration
+---@field name string
+---@field projectName string
+---@field mainClass string
+---@field javaExec string
+---@field modulePaths string[]
+---@field classPaths string[]
+---@field request string
+
+---@alias JavaDapConfigurationList JavaDapConfiguration[]
+
+---Returns the dap configuration for the current project
+---@return Promise
+function M.get_dap_config()
+	log.info('creating dap configuration for java')
+
+	local client = lsp.get_jdtls_client()
+
+	if not client then
+		local msg = 'no active jdtls client was found'
+
+		log.error(msg)
+		error(msg)
+	end
+
+	local jdtlsClient = JavaDebug:new({
+		client = client,
+	})
+
+	---@type JavaDebugResolveMainClassResponse
+	local main_classes_info_list
+
+	return jdtlsClient
+		:resolve_main_class()
+		:thenCall(
+			---@param main_classes_info JavaDebugResolveMainClassResponse
+			function(main_classes_info)
+				main_classes_info_list = main_classes_info
+
+				---@type Promise[]
+				local classpath_promises = {}
+				---@type Promise[]
+				local java_exec_promises = {}
+
+				for _, single_class_info in ipairs(main_classes_info) do
+					table.insert(
+						classpath_promises,
+						jdtlsClient:resolve_classpath(
+							single_class_info.mainClass,
+							single_class_info.projectName
+						)
+					)
+
+					table.insert(
+						java_exec_promises,
+						jdtlsClient:resolve_java_executable(
+							single_class_info.mainClass,
+							single_class_info.projectName
+						)
+					)
+				end
+
+				return Promise.all({
+					Promise.all(classpath_promises),
+					Promise.all(java_exec_promises),
+				})
+			end
+		)
+		:thenCall(function(result)
+			return M.__get_dap_java_config(
+				main_classes_info_list,
+				result[1],
+				result[2]
+			)
+		end)
+end
+
+function M.__get_dap_java_config(main_classes, classpaths, java_execs)
+	local len = #main_classes
+	local dap_config_list = {}
+
+	for i = 1, len do
+		local main_class = main_classes[i].mainClass
+		local project_name = main_classes[i].projectName
+		local module_paths = classpaths[i][1]
+		local class_paths = classpaths[i][2]
+
+		table.insert(dap_config_list, {
+			name = string.format('%s -> %s', project_name, main_class),
+			projectName = project_name,
+			mainClass = main_class,
+			javaExec = java_execs[i],
+			request = 'launch',
+			type = 'java',
+			modulePaths = module_paths,
+			classPaths = class_paths,
+		})
+	end
+
+	return dap_config_list
+end
+
+return M

lua/java/ls/clients/java-debug-client.lua

@@ -0,0 +1,81 @@
+local JDTLSClient = require('java.ls.clients.jdtls-client')
+
+local M = JDTLSClient:new()
+
+---@class JavaDebugResolveMainClassRecord
+---@field mainClass string
+---@field projectName string
+---@field fileName string
+
+---@alias JavaDebugResolveMainClassResponse JavaDebugResolveMainClassRecord[]
+
+---Returns a list of main classes in the current workspace
+---@return Promise
+function M:resolve_main_class()
+	return self:execute_command('vscode.java.resolveMainClass')
+end
+
+---@alias JavaDebugResolveClasspathResponse string[][]
+
+---Returns module paths and class paths of a given main class
+---@param project_name string
+---@param main_class string
+---@return Promise
+function M:resolve_classpath(main_class, project_name)
+	return self:execute_command(
+		'vscode.java.resolveClasspath',
+		{ main_class, project_name }
+	)
+end
+
+---@alias JavaDebugResolveJavaExecutableResponse string
+
+---Returns the path to java executable for a given main class
+---@param project_name string
+---@param main_class string
+---@return Promise
+function M:resolve_java_executable(main_class, project_name)
+	return self:execute_command('vscode.java.resolveJavaExecutable', {
+		main_class,
+		project_name,
+	})
+end
+
+---@alias JavaDebugCheckProjectSettingsResponse boolean
+
+---Returns true if the project settings is the expected
+---@param project_name string
+---@param main_class string
+---@param inheritedOptions boolean
+---@param expectedOptions { [string]: any }
+---@return Promise
+function M:check_project_settings(
+	main_class,
+	project_name,
+	inheritedOptions,
+	expectedOptions
+)
+	return self:execute_command(
+		'vscode.java.checkProjectSettings',
+		vim.fn.json_encode({
+			className = main_class,
+			projectName = project_name,
+			inheritedOptions = inheritedOptions,
+			expectedOptions = expectedOptions,
+		})
+	)
+end
+
+---@alias JavaDebugStartDebugSessionResponse integer
+
+---Starts a debug session and returns the port number
+---@return Promise
+function M:start_debug_session()
+	return self:execute_command('vscode.java.startDebugSession')
+end
+
+function M:build_workspace()
+	return self:execute_command('vscode.java.buildWorkspace')
+end
+
+return M

lua/java/ls/clients/jdtls-client.lua

@@ -0,0 +1,64 @@
+local log = require('java.utils.log')
+local Promise = require('java.utils.promise')
+
+---@class JDTLSClient
+---@field client LSPClient
+local M = {}
+
+function M:new(o)
+	o = o or {}
+	setmetatable(o, self)
+	self.__index = self
+	return o
+end
+
+---Executes a workspace/executeCommand and returns the result
+---@param command string
+---@param arguments? string | string[]
+---@param buffer? integer
+---@return Promise
+function M:execute_command(command, arguments, buffer)
+	return Promise.new(function(resolve, reject)
+		local cmd_info = {
+			command = command,
+			arguments = arguments,
+		}
+
+		log.debug('workspace/executeCommand: ', cmd_info)
+
+		self.client.request('workspace/executeCommand', cmd_info, function(err, res)
+			if err then
+				reject(err)
+			else
+				resolve(res)
+			end
+		end, buffer)
+	end)
+end
+
+function M:get_capability(...)
+	local capability = self.client.server_capabilities
+
+	for _, value in ipairs({ ... }) do
+		if type(capability) ~= 'table' then
+			log.fmt_warn('Looking for capability: %s in value %s', value, capability)
+			return nil
+		end
+
+		capability = capability[value]
+	end
+
+	return capability
+end
+
+function M:has_command(command_name)
+	local commands = self:get_capability('executeCommandProvider', 'commands')
+
+	if not commands then
+		return false
+	end
+
+	return vim.tbl_contains(commands, command_name)
+end
+
+return M

lua/java/lspconfig-types.lua

@@ -12,6 +12,17 @@
 ---@field on_attach fun(client: object, bufnr: number) Callback invoked by Nvim's built-in client when attaching a buffer to a language server. Often used to set Nvim (buffer or global) options or to override the Nvim client properties (`server_capabilities`) after a language server attaches. Most commonly used for settings buffer local keybindings. See |lspconfig-keybindings| for a usage example.
 ---@field settings table <string, string|table|boolean> The `settings` table is sent in `on_init` via a `workspace/didChangeConfiguration` notification from the Nvim client to the language server. These settings allow a user to change optional runtime settings of the language server.
 
+---@class LSPClientRequestParameters
+---@field command string
+---@field arguments string | string[] | nil
+
+---@class LSPClientResponse
+---@field err LSPClientResponseError
+
+---@class LSPClientResponseError
+---@field code number
+---@field message string
+
 ---@class LSPClient
 ---@field attached_buffers table<number, boolean>
 ---@field cancel_request function
@@ -25,7 +36,7 @@
 ---@field name string
 ---@field notify fun(method: string, params: object): boolean
 ---@field offset_encoding string
----@field request function
+---@field request fun(method: string, params: LSPClientRequestParameters, callback: fun(err: any, result: any), bufnr?: number): any
 ---@field request_sync function
 ---@field requests object
 ---@field rpc object

lua/java/settings.lua

@@ -13,8 +13,6 @@ function M.change_settings(settings)
 
 	local client = lsp.get_jdtls_client()
 
-	vim.print(client)
-
 	if not client then
 		local msg = 'jdtls client not found'
 		log.error(msg)