feat: add apply refactoring command handler

Author: s1n7ax

lua/java-refactor/lsp-refactor-commands.lua

@@ -1,10 +1,10 @@
--- local ui = require('java.utils.ui')
+local runner = require('async.runner')
+local get_error_handler = require('java-refactor.utils.error_handler')
+local RefactorCommands = require('java-refactor.refactor-commands')
 
 local M = {
 
 	commands = {
-		-- ['java.action.applyRefactoringCommand'] = function() end,
-
 		---@class java-refactor.RenameAction
 		---@field length number
 		---@field offset number
@@ -32,6 +32,30 @@ local M = {
 				})
 			end
 		end,
+
+		---@class java-refactor.ApplyRefactoringCommandInfo
+		---@field bufnr number
+		---@field client_id number
+		---@field method string
+		---@field params lsp.CodeActionContext
+
+		---comment
+		---@param command lsp.Command
+		---@param command_info java-refactor.ApplyRefactoringCommandInfo
+		['java.action.applyRefactoringCommand'] = function(command, command_info)
+			runner(function()
+					local refactor_type = command.arguments[1] --[[@as jdtls.CodeActionCommand]]
+					local context = command_info.params
+
+					local client = vim.lsp.get_client_by_id(command_info.client_id)
+
+					---@type java-refactor.RefactorCommands
+					local refactor_commands = RefactorCommands(client)
+					refactor_commands:refactor(refactor_type, context)
+				end)
+				.catch(get_error_handler('Failed to run refactoring command'))
+				.run()
+		end,
 	},
 }
 
@@ -49,3 +73,8 @@ id = vim.api.nvim_create_autocmd('LspAttach', {
 		end
 	end,
 })
+
+---@class java-refactor.RefactorContext
+---@field context { diagnostics: any[], triggerKind: number }
+---@field range nvim.Range
+---@field textDocument { uri: string }

lua/java-refactor/refactor-commands.lua

@@ -3,22 +3,23 @@ local notify = require('java-core.utils.notify')
 local JdtlsClient = require('java-core.ls.clients.jdtls-client')
 
 ---@class java-refactor.RefactorCommands
----@field client vim.lsp.Client
 ---@field jdtls_client java-core.JdtlsClient
 local RefactorCommands = class()
 
 ---@param client vim.lsp.Client
 function RefactorCommands:_init(client)
-	self.client = client
 	self.jdtls_client = JdtlsClient(client)
 end
 
 ---Run refactor command
 ---@param refactor_type jdtls.CodeActionCommand
-function RefactorCommands:refactor(refactor_type)
-	local context = vim.lsp.util.make_range_params(0)
-	context.context = {}
-	context.context.diagnostics = vim.lsp.diagnostic.get_line_diagnostics(0)
+---@param context lsp.CodeActionContext
+function RefactorCommands:refactor(refactor_type, context)
+	if not context then
+		context = vim.lsp.util.make_range_params(0)
+		context.context = {}
+		context.context.diagnostics = vim.lsp.diagnostic.get_line_diagnostics(0)
+	end
 
 	local formatting_options = {
 		tabSize = vim.bo.tabstop,
@@ -27,8 +28,15 @@ function RefactorCommands:refactor(refactor_type)
 
 	local buffer = vim.api.nvim_get_current_buf()
 
-	local selection =
-		self.jdtls_client:java_infer_selection(refactor_type, context, buffer)
+	local selection = {}
+
+	if
+		context.range.start.character == context.range['end'].character
+		and context.range.start.line == context.range['end'].line
+	then
+		selection =
+			self.jdtls_client:java_infer_selection(refactor_type, context, buffer)
+	end
 
 	local edit = self.jdtls_client:java_get_refactor_edit(
 		refactor_type,
@@ -38,6 +46,11 @@ function RefactorCommands:refactor(refactor_type)
 		buffer
 	)
 
+	if not edit then
+		notify.warn('No edits suggested for action')
+		return
+	end
+
 	vim.lsp.util.apply_workspace_edit(edit.edit, 'utf-8')
 
 	RefactorCommands.run_lsp_client_command(
@@ -47,7 +60,6 @@ function RefactorCommands:refactor(refactor_type)
 end
 
 function RefactorCommands.run_lsp_client_command(command_name, arguments)
-	-- vim.print(command_name, arguments)
 	local command = vim.lsp.commands[command_name]
 
 	if not command then

lua/java-refactor/utils/error_handler.lua

@@ -0,0 +1,32 @@
+local notify = require('java-core.utils.notify')
+local log = require('java-refactor.utils.log')
+
+local function table_tostring(tbl)
+	local str = ''
+	for _, v in ipairs(tbl) do
+		str = str .. '\n' .. tostring(v)
+	end
+
+	return str
+end
+
+---Returns a error handler
+---@param msg string messages to show in the error
+---@return fun(err: any) # function that log and notify the error
+local function get_error_handler(msg)
+	return function(err)
+		local trace = debug.traceback()
+
+		local log_obj = { msg }
+		table.insert(log_obj, err)
+		table.insert(log_obj, trace)
+
+		local log_str = table_tostring(log_obj)
+
+		log.error(log_str)
+		notify.error(log_str)
+		error(log_str)
+	end
+end
+
+return get_error_handler

lua/java-refactor/utils/log.lua

@@ -0,0 +1,169 @@
+--[[
+--FROM: https://github.com/tjdevries/vlog.nvim
+--]]
+
+-- log.lua
+--
+-- Inspired by rxi/log.lua
+-- Modified by tjdevries and can be found at github.com/tjdevries/vlog.nvim
+--
+-- This library is free software; you can redistribute it and/or modify it
+-- under the terms of the MIT license. See LICENSE for details.
+
+-- User configuration section
+local default_config = {
+	-- Name of the plugin. Prepended to log messages
+	plugin = 'nvim-java-refactor',
+
+	-- Should print the output to neovim while running
+	use_console = false,
+
+	-- Should highlighting be used in console (using echohl)
+	highlights = true,
+
+	-- Should write to a file
+	use_file = true,
+
+	-- Any messages above this level will be logged.
+	level = 'trace',
+
+	-- Level configuration
+	modes = {
+		{ name = 'trace', hl = 'Comment' },
+		{ name = 'debug', hl = 'Comment' },
+		{ name = 'info', hl = 'None' },
+		{ name = 'warn', hl = 'WarningMsg' },
+		{ name = 'error', hl = 'ErrorMsg' },
+		{ name = 'fatal', hl = 'ErrorMsg' },
+	},
+
+	-- Can limit the number of decimals displayed for floats
+	float_precision = 0.01,
+}
+
+-- {{{ NO NEED TO CHANGE
+local log = {}
+
+local unpack = unpack or table.unpack
+
+log.new = function(config, standalone)
+	config = vim.tbl_deep_extend('force', default_config, config)
+
+	local outfile = string.format(
+		'%s/%s.log',
+		vim.api.nvim_call_function('stdpath', { 'data' }),
+		config.plugin
+	)
+
+	local obj
+	if standalone then
+		obj = log
+	else
+		obj = {}
+	end
+
+	local levels = {}
+	for i, v in ipairs(config.modes) do
+		levels[v.name] = i
+	end
+
+	local round = function(x, increment)
+		increment = increment or 1
+		x = x / increment
+		return (x > 0 and math.floor(x + 0.5) or math.ceil(x - 0.5)) * increment
+	end
+
+	local make_string = function(...)
+		local t = {}
+		for i = 1, select('#', ...) do
+			local x = select(i, ...)
+
+			if type(x) == 'number' and config.float_precision then
+				x = tostring(round(x, config.float_precision))
+			elseif type(x) == 'table' then
+				x = vim.inspect(x)
+			else
+				x = tostring(x)
+			end
+
+			t[#t + 1] = x
+		end
+		return table.concat(t, ' ')
+	end
+
+	local log_at_level = function(level, level_config, message_maker, ...)
+		-- Return early if we're below the config.level
+		if level < levels[config.level] then
+			return
+		end
+		local nameupper = level_config.name:upper()
+
+		local msg = message_maker(...)
+		local info = debug.getinfo(2, 'Sl')
+		local lineinfo = info.short_src .. ':' .. info.currentline
+
+		-- Output to console
+		if config.use_console then
+			local console_string = string.format(
+				'[%-6s%s] %s: %s',
+				nameupper,
+				os.date('%H:%M:%S'),
+				lineinfo,
+				msg
+			)
+
+			if config.highlights and level_config.hl then
+				vim.cmd(string.format('echohl %s', level_config.hl))
+			end
+
+			local split_console = vim.split(console_string, '\n')
+			for _, v in ipairs(split_console) do
+				vim.cmd(
+					string.format(
+						[[echom "[%s] %s"]],
+						config.plugin,
+						vim.fn.escape(v, '"')
+					)
+				)
+			end
+
+			if config.highlights and level_config.hl then
+				vim.cmd('echohl NONE')
+			end
+		end
+
+		-- Output to log file
+		if config.use_file then
+			local fp = io.open(outfile, 'a')
+			local str =
+				string.format('[%-6s%s] %s: %s\n', nameupper, os.date(), lineinfo, msg)
+			assert(fp, 'cannot open file: ' .. ' to write logs')
+			fp:write(str)
+			fp:close()
+		end
+	end
+
+	for i, x in ipairs(config.modes) do
+		obj[x.name] = function(...)
+			return log_at_level(i, x, make_string, ...)
+		end
+
+		obj[('fmt_%s'):format(x.name)] = function(...)
+			local passed = { ... }
+			return log_at_level(i, x, function()
+				local fmt = table.remove(passed, 1)
+				local inspected = {}
+				for _, v in ipairs(passed) do
+					table.insert(inspected, vim.inspect(v))
+				end
+				return string.format(fmt, unpack(inspected))
+			end)
+		end
+	end
+
+	return obj
+end
+
+log.new(default_config, true)
+
+return log