mirror of
https://github.com/ray-x/navigator.lua
synced 2024-11-03 15:40:20 +00:00
941b3fc80f
* doc update for lsp-installer * use vim.ui.select and guihua ui patch * adjust null-ls sequence
330 lines
9.2 KiB
Lua
330 lines
9.2 KiB
Lua
local util = require "navigator.util"
|
|
local log = util.log
|
|
local trace = util.trace
|
|
local code_action = {}
|
|
local gui = require "navigator.gui"
|
|
local config = require("navigator").config_values()
|
|
local api = vim.api
|
|
trace = log
|
|
|
|
local sign_name = "NavigatorLightBulb"
|
|
|
|
--- `codeAction/resolve`
|
|
-- from neovim buf.lua, change vim.ui.select to gui
|
|
|
|
local diagnostic = vim.diagnostic or vim.lsp.diagnostic
|
|
|
|
-- https://github.com/glepnir/lspsaga.nvim/blob/main/lua/lspsaga/codeaction.lua
|
|
-- lspsaga has a clever design to inject code action indicator
|
|
local sign_group = "nvcodeaction"
|
|
local get_namespace = function()
|
|
return api.nvim_create_namespace(sign_group)
|
|
end
|
|
|
|
local get_current_winid = function()
|
|
return api.nvim_get_current_win()
|
|
end
|
|
|
|
local function _update_virtual_text(line, actions)
|
|
local namespace = get_namespace()
|
|
pcall(api.nvim_buf_clear_namespace, 0, namespace, 0, -1)
|
|
|
|
if line then
|
|
trace(line, actions)
|
|
local icon_with_indent = " " .. config.icons.code_action_icon
|
|
|
|
local title = actions[1].title
|
|
pcall(api.nvim_buf_set_extmark, 0, namespace, line, -1, {
|
|
virt_text = {{icon_with_indent .. title, "LspDiagnosticsSignHint"}},
|
|
virt_text_pos = "overlay",
|
|
hl_mode = "combine"
|
|
})
|
|
end
|
|
end
|
|
|
|
local function _update_sign(line)
|
|
|
|
if vim.tbl_isempty(vim.fn.sign_getdefined(sign_name)) then
|
|
vim.fn.sign_define(sign_name, {
|
|
text = config.icons.code_action_icon,
|
|
texthl = "LspDiagnosticsSignHint"
|
|
})
|
|
end
|
|
local winid = get_current_winid()
|
|
if code_action[winid] == nil then
|
|
code_action[winid] = {}
|
|
end
|
|
if code_action[winid].lightbulb_line ~= 0 then
|
|
vim.fn.sign_unplace(sign_group, {id = code_action[winid].lightbulb_line, buffer = "%"})
|
|
end
|
|
|
|
if line then
|
|
-- log("updatasign", line, sign_group, sign_name)
|
|
vim.fn.sign_place(line, sign_group, sign_name, "%",
|
|
{lnum = line + 1, priority = config.lsp.code_action.sign_priority})
|
|
code_action[winid].lightbulb_line = line
|
|
end
|
|
end
|
|
|
|
-- local need_check_diagnostic = {["go"] = true, ["python"] = true}
|
|
local need_check_diagnostic = {['python'] = true}
|
|
|
|
function code_action:render_action_virtual_text(line, diagnostics)
|
|
return function(err, actions, context)
|
|
if actions == nil or type(actions) ~= "table" or vim.tbl_isempty(actions) then
|
|
-- no actions cleanup
|
|
if config.lsp.code_action.virtual_text then
|
|
_update_virtual_text(nil)
|
|
end
|
|
if config.lsp.code_action.sign then
|
|
_update_sign(nil)
|
|
end
|
|
else
|
|
trace(err, line, diagnostics, actions, context)
|
|
if config.lsp.code_action.sign then
|
|
if need_check_diagnostic[vim.bo.filetype] then
|
|
if next(diagnostics) == nil then
|
|
_update_sign(nil)
|
|
else
|
|
-- no diagnostic, no code action sign..
|
|
_update_sign(line)
|
|
end
|
|
else
|
|
_update_sign(line)
|
|
end
|
|
end
|
|
|
|
if config.lsp.code_action.virtual_text then
|
|
if need_check_diagnostic[vim.bo.filetype] then
|
|
if next(diagnostics) == nil then
|
|
_update_virtual_text(nil)
|
|
else
|
|
_update_virtual_text(line, actions)
|
|
end
|
|
else
|
|
_update_virtual_text(line, actions)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
local special_buffers = {
|
|
["lspsagafinder"] = true,
|
|
["NvimTree"] = true,
|
|
["vista"] = true,
|
|
["guihua"] = true,
|
|
["lspinfo"] = true,
|
|
["markdown"] = true,
|
|
["text"] = true
|
|
}
|
|
-- local action_call_back = function (_,_)
|
|
-- return Action:action_callback()
|
|
-- end
|
|
|
|
local action_virtual_call_back = function(line, diagnostics)
|
|
return code_action:render_action_virtual_text(line, diagnostics)
|
|
end
|
|
|
|
local code_action_req = function(_call_back_fn, diagnostics)
|
|
local context = {diagnostics = diagnostics}
|
|
local params = vim.lsp.util.make_range_params()
|
|
params.context = context
|
|
local line = params.range.start.line
|
|
local callback = _call_back_fn(line, diagnostics)
|
|
vim.lsp.buf_request(0, "textDocument/codeAction", params, callback)
|
|
end
|
|
|
|
|
|
code_action.code_action = function()
|
|
|
|
local original_select = vim.ui.select
|
|
vim.ui.select = require("guihua.gui").select
|
|
|
|
log('codeaction')
|
|
|
|
vim.lsp.buf.code_action()
|
|
vim.defer_fn(
|
|
function ()
|
|
vim.ui.select = original_select
|
|
end, 1000
|
|
)
|
|
|
|
end
|
|
|
|
code_action.range_code_action = function(startpos, endpos)
|
|
local context = {}
|
|
context.diagnostics = vim.lsp.diagnostic.get_line_diagnostics()
|
|
local params = util.make_given_range_params(startpos, endpos)
|
|
params.context = context
|
|
|
|
|
|
local original_select = vim.ui.select
|
|
vim.ui.select = require("guihua.gui").select
|
|
|
|
vim.lsp.buf.range_code_action(context, startpos, endpos)
|
|
vim.defer_fn(
|
|
function ()
|
|
vim.ui.select = original_select
|
|
end, 1000
|
|
)
|
|
end
|
|
|
|
code_action.code_action_prompt = function()
|
|
if special_buffers[vim.bo.filetype] then
|
|
log('skip buffer', vim.bo.filetype)
|
|
return
|
|
end
|
|
|
|
local diagnostics
|
|
if diagnostic.get_line_diagnostics then
|
|
-- old version
|
|
diagnostics = diagnostic.get_line_diagnostics()
|
|
else
|
|
local lnum = vim.api.nvim_win_get_cursor(0)[1] - 1
|
|
diagnostics = diagnostic.get(vim.api.nvim_get_current_buf(), {lnum = lnum})
|
|
end
|
|
|
|
local winid = get_current_winid()
|
|
code_action[winid] = code_action[winid] or {}
|
|
code_action[winid].lightbulb_line = code_action[winid].lightbulb_line or 0
|
|
code_action_req(action_virtual_call_back, diagnostics)
|
|
end
|
|
|
|
return code_action
|
|
|
|
|
|
|
|
--[[
|
|
|
|
code_action.code_action_handler = util.mk_handler(function(err, results, ctx, cfg)
|
|
log(ctx)
|
|
if err ~= nil then
|
|
log("code action err", err, results, ctx, cfg)
|
|
return
|
|
end
|
|
on_code_action_results(results, ctx)
|
|
end)
|
|
local function code_action_request(params)
|
|
local bufnr = vim.api.nvim_get_current_buf()
|
|
local method = 'textDocument/codeAction'
|
|
vim.lsp.buf_request_all(bufnr, method, params, function(results)
|
|
on_code_action_results(results, {bufnr = bufnr, method = method, params = params})
|
|
end)
|
|
end
|
|
|
|
|
|
local function on_code_action_results(results, ctx, client)
|
|
local trace = log
|
|
local action_tuples = {}
|
|
|
|
local data = {" Auto Fix <C-o> Apply <C-e> Exit"}
|
|
|
|
for client_id, result in pairs(results) do
|
|
for i, action in pairs(result.result or {}) do
|
|
local title = 'apply action'
|
|
trace(action)
|
|
if action.edit and action.edit.title then
|
|
local edit = action.edit
|
|
title = edit.title:gsub("\r\n", " ↳ ")
|
|
title = title:gsub("\n", " ↳ ")
|
|
elseif action.title then
|
|
title = action.title:gsub("\r\n", " ↳ ")
|
|
title = title:gsub("\n", " ↳ ")
|
|
elseif action.command and action.command.title then
|
|
title = action.command.title:gsub("\n", " ↳ ")
|
|
title = title:gsub("\n", " ↳ ")
|
|
end
|
|
|
|
local edit = action.edit or {}
|
|
-- trace(edit.documentChanges)
|
|
if edit.documentChanges or edit.changes then
|
|
local changes = edit.documentChanges or edit.changes
|
|
-- trace(action.edit.documentChanges)
|
|
for _, change in pairs(changes or {}) do
|
|
-- trace(change)
|
|
if change.edits then
|
|
title = title .. " [newText:]"
|
|
for _, ed in pairs(change.edits) do
|
|
-- trace(ed)
|
|
if ed.newText and ed.newText ~= "" then
|
|
local newText = ed.newText:gsub("\n\t", " ↳ ")
|
|
newText = newText:gsub("\n", "↳")
|
|
title = title .. " (" .. newText
|
|
if ed.range then
|
|
title = title .. " line: " .. tostring(ed.range.start.line) .. ")"
|
|
else
|
|
title = title .. ")"
|
|
end
|
|
end
|
|
end
|
|
elseif change.newText and change.newText ~= "" then
|
|
local newText = change.newText:gsub("\"\n\t\"", " ↳ ")
|
|
newText = newText:gsub("\n", "↳")
|
|
title = title .. " (newText: " .. newText
|
|
if change.range then
|
|
title = title .. " line: " .. tostring(change.range.start.line) .. ")"
|
|
else
|
|
title = title .. ")"
|
|
end
|
|
end
|
|
|
|
end
|
|
end
|
|
|
|
title = string.format("[%d] %s", i, title)
|
|
table.insert(data, title)
|
|
table.insert(action_tuples, {client_id, action, title, i})
|
|
end
|
|
end
|
|
|
|
log(action_tuples)
|
|
log(data)
|
|
|
|
if #action_tuples == 0 then
|
|
vim.notify('No code actions available', vim.log.levels.INFO)
|
|
return
|
|
end
|
|
local width = 42
|
|
for _, str in ipairs(data) do
|
|
if #str > width then
|
|
width = #str
|
|
end
|
|
end
|
|
|
|
local divider = string.rep('─', width + 2)
|
|
|
|
table.insert(data, 2, divider)
|
|
|
|
local listview = gui.new_list_view {
|
|
items = data,
|
|
width = width + 4,
|
|
loc = "top_center",
|
|
relative = "cursor",
|
|
rawdata = true,
|
|
data = data,
|
|
on_confirm = function(item)
|
|
trace(item)
|
|
local action_chosen = nil
|
|
for _, value in pairs(action_tuples) do
|
|
if value[3] == item then
|
|
action_chosen = value
|
|
return require('navigator.lspwrapper').on_user_choice(action_chosen, ctx)
|
|
end
|
|
end
|
|
end,
|
|
on_move = function(pos)
|
|
trace(pos)
|
|
return pos
|
|
end
|
|
}
|
|
|
|
log("new buffer", listview.bufnr)
|
|
vim.api.nvim_buf_add_highlight(listview.bufnr, -1, 'Title', 0, 0, -1)
|
|
|
|
-- let move down 2 pos
|
|
ListViewCtrl:on_next()
|
|
ListViewCtrl:on_next()
|
|
end
|
|
]]
|