From ea0f4bf8ffade657b1d45152dbc183d4679e75c4 Mon Sep 17 00:00:00 2001 From: Elvis Claros Castro Date: Fri, 12 Jul 2024 11:18:14 -0300 Subject: Feat: PI --- lua/pi/php/gateway.lua | 137 ++++++++++++++++++++++++++++++++++++++++++++ lua/pi/php/lsp.lua | 151 +++++++++++++++++++++++++++++++++++++++++++++++++ lua/pi/php/servers.lua | 38 +++++++++++++ 3 files changed, 326 insertions(+) create mode 100644 lua/pi/php/gateway.lua create mode 100644 lua/pi/php/lsp.lua create mode 100644 lua/pi/php/servers.lua (limited to 'lua/pi/php') diff --git a/lua/pi/php/gateway.lua b/lua/pi/php/gateway.lua new file mode 100644 index 0000000..83c95e9 --- /dev/null +++ b/lua/pi/php/gateway.lua @@ -0,0 +1,137 @@ +local pickers = require "telescope.pickers" +local finders = require "telescope.finders" +local conf = require("telescope.config").values +local action_state = require "telescope.actions.state" +local action_set = require "telescope.actions.set" +local actions = require "telescope.actions" +local get_node_text = vim.treesitter.get_node_text + +local gateway = {} + +local get_definition_buffer = function(type) + local uri = vim.uri_from_fname(vim.fn.getcwd() .. "/config/graphql/_" .. type .. ".yaml") + local buff = vim.uri_to_bufnr(uri) + vim.fn.bufload(buff) + + return buff +end + +local get_all_definitions = function() + local mutations_definitions = gateway.get_graphql_definitions(get_definition_buffer "mutation") + local queries_definitions = gateway.get_graphql_definitions(get_definition_buffer "query") + for _, definition in ipairs(queries_definitions) do + table.insert(mutations_definitions, definition) + end + + return mutations_definitions +end + +-- "'@=mutation(\"App\\\\GraphQL\\\\Mutations\\\\Mutation::action\", ...)'", +local open_resolver = function(resolver) + -- need to parse to get this values + local args = string.match(resolver, "'@=mutation%((.+)%)'") + if args == nil then + args = string.match(resolver, "'@=query%((.+)%)'") + end + if args == nil then + return + end + + local args_tbl = vim.split(args, ", ") + local fqn = string.match(args_tbl[1], '"(.+)"') + fqn = string.gsub(fqn, "\\\\", "\\") + -- P(fqn) + + require("pi.php.lsp").find(fqn, "phpactor") +end + +--- @param bufnr integer Buff id +gateway.get_graphql_definitions = function(bufnr) + vim.treesitter.query.set( + "yaml", + "GraphQL_endpoints", + [[ + (document (block_node (block_mapping (block_mapping_pair + value: (block_node (block_mapping (block_mapping_pair + value: (block_node (block_mapping (block_mapping_pair + value: (block_node (block_mapping (block_mapping_pair + key: (flow_node) @mutation + value: (block_node (block_mapping (block_mapping_pair + key: (flow_node) @resolve (#eq? @resolve "resolve") + value: (flow_node) @resolver + ))) + ))) + ))) + ))) + )))) + ]] + ) + + local query = vim.treesitter.query.get("yaml", "GraphQL_endpoints") + + local elements = {} + + local parsers = require "nvim-treesitter.parsers" + local parser = parsers.get_parser(bufnr) + local tree = parser:parse()[1] + + for id, node in query:iter_captures(tree:root(), bufnr) do + if query.captures[id] == "mutation" then + table.insert(elements, { + value = get_node_text(node, bufnr), + lnum = node:start() + 1, + buffer = bufnr, + }) + elseif query.captures[id] == "resolver" then + elements[#elements].resolver = get_node_text(node, bufnr) + end + end + + return elements +end + +--- gets the graphql function defined on a given buffer +--- @param opts table: options to pass to the picker +gateway.graphql_definitions = function(opts) + opts = opts or {} + pickers + .new(opts, { + promt_title = "Queries", + finder = finders.new_table { + results = get_all_definitions(), + entry_maker = function(entry) + -- buffer = 43, + -- lnum = 82, + -- resolver = "'@=mutation(\"App\\\\GraphQL\\\\Mutation\\\\Mutation::action\", ...)'", + -- value = "deleteVehicleImage" + return { + value = entry, + display = entry.value, + ordinal = entry.value, + path = vim.api.nvim_buf_get_name(entry.buffer), + lnum = entry.lnum, + resolver = entry.resolver, + } + end, + }, + sorter = conf.generic_sorter(opts), + previewer = conf.grep_previewer(opts), + attach_mappings = function(prompt_bufnr, map) + action_set.select:enhance { + post = function() + local selection = action_state.get_selected_entry() + vim.api.nvim_win_set_cursor(0, { selection.lnum, 0 }) + end, + } + map("i", "", function() + actions.close(prompt_bufnr) + local selection = action_state.get_selected_entry() + open_resolver(selection.resolver) + end) + return true + end, + }) + :find() +end + +return gateway diff --git a/lua/pi/php/lsp.lua b/lua/pi/php/lsp.lua new file mode 100644 index 0000000..37e0bc0 --- /dev/null +++ b/lua/pi/php/lsp.lua @@ -0,0 +1,151 @@ +local Path = require "plenary.path" + +local lsp = {} + +local open_filename = function(filename) + if vim.api.nvim_buf_get_name(0) ~= filename then + filename = Path:new(vim.fn.fnameescape(filename)):normalize(vim.loop.cwd()) + pcall(vim.cmd, string.format("%s %s", "edit", filename)) + end +end + +---@param server_name string +---@return table|nil, boolean +local get_client = function(server_name) + local clients = vim.lsp.get_active_clients { name = server_name } + local client = clients[1] or nil + local new_instance = false + + if not client then + local server = require("lspconfig")[server_name] + local config = server.make_config(vim.fn.getcwd()) + local client_id = vim.lsp.start(config) + client = vim.lsp.get_client_by_id(client_id) + new_instance = true + end + + return client, new_instance +end + +local function go_to(client, is_new_instance, full_class, method) + local class_parts = vim.split(full_class, "\\") + local class = class_parts[#class_parts] + + local resp = client.request_sync("workspace/symbol", { query = class }, nil) + + local locations = vim.lsp.util.symbols_to_items(resp.result or {}, nil) or {} + if vim.tbl_isempty(locations) then + vim.api.nvim_err_writeln("Empty response looking for class: " .. full_class) + if is_new_instance then + vim.lsp.stop_client(client.id) + end + return + end + + local class_location = nil + for idx, location in pairs(locations) do + if location.text == string.format("[Class] %s", full_class) then + class_location = locations[idx] + break + end + end + + if class_location == nil then + vim.api.nvim_err_writeln("Could not find class for : " .. full_class) + if is_new_instance then + vim.lsp.stop_client(client.id) + end + return + end + + open_filename(class_location.filename) + + local params = vim.lsp.util.make_position_params(0) + if is_new_instance then + vim.lsp.buf_attach_client(0, client.id) + end + + vim.lsp.buf_request(0, "textDocument/documentSymbol", params, function(method_err, method_server_result, _, _) + if method_err then + vim.api.nvim_err_writeln("Error when finding workspace symbols: " .. method_err.message) + if is_new_instance then + vim.lsp.stop_client(client.id) + end + return + end + + local method_locations = vim.lsp.util.symbols_to_items(method_server_result or {}, 0) or {} + if vim.tbl_isempty(method_locations) then + vim.api.nvim_err_writeln(string.format("empty response looking for method: %s", method or "__invoke")) + if is_new_instance then + vim.lsp.stop_client(client.id) + end + return + end + + local method_location = nil + for _, value in ipairs(method_locations) do + if value.text == string.format("[Method] %s", method or "__invoke") then + method_location = value + break + end + end + + if method_location == nil then + if is_new_instance then + vim.lsp.stop_client(client.id) + end + return + end + + local row = method_location.lnum + local col = method_location.col - 1 + + if row and col then + local ok, err_msg = pcall(vim.api.nvim_win_set_cursor, 0, { row, col }) + if not ok then + vim.api.nvim_err_writeln("Erro setting row and col " .. err_msg) + end + vim.cmd "normal zt" + end + if is_new_instance then + vim.lsp.stop_client(client.id) + end + end) +end + +---Return a buffer id for the given client +---@param server_name string +---@return integer|nil +lsp.get_lsp_buffer = function(server_name) + local clients = vim.lsp.get_active_clients { name = server_name } + if #clients == 0 then + return nil + end + + local buffers = vim.lsp.get_buffers_by_client_id(clients[1].id) + + if #buffers == 0 then + return nil + end + + return buffers[1] +end + +--- @param fqn string: fully name to search Class::method +lsp.find = function(fqn, server_name) + local search = vim.split(fqn, "::") + local fqn_class = search[1] + local method = search[2] + + local client, is_new_instance = get_client(server_name) + + if not client then + vim.api.nvim_err_writeln "Could not get lsp client" + return + end + + go_to(client, is_new_instance, fqn_class, method) +end + +return lsp diff --git a/lua/pi/php/servers.lua b/lua/pi/php/servers.lua new file mode 100644 index 0000000..9450152 --- /dev/null +++ b/lua/pi/php/servers.lua @@ -0,0 +1,38 @@ +local phpactor = {} + +-- TODO possible improvement look how it works underline +-- use the client directly to call, no need for the buffer +-- to find a class. +-- vim.lsp.start() should return the client + +function phpactor.findclass(buffer, fqn, callback) + local class_parts = vim.split(fqn, "\\") + local class = class_parts[#class_parts] + + vim.lsp.buf_request(buffer, "workspace/symbol", { query = class }, function(err, server_result, _, _) + if err then + callback(nil, "Error when finding workspace symbols: " .. err.message) + + return + end + + local locations = vim.lsp.util.symbols_to_items(server_result or {}, buffer) or {} + if vim.tbl_isempty(locations) then + vim.api.nvim_err_writeln("Empty response looking for class: " .. fqn) + return + end + end) +end + +-- getting the config I can re use the client +-- the next thing is to make the request with the client +local config = require("lspconfig").phpactor +config.root_dir = vim.fn.getcwd() +local client_id = vim.lsp.start(config) + +vim.lsp.get_client_by_id(client_id) +-- use client.request or request_sync +-- look for the direct of the symbol +return { + phpactor = phpactor, +} -- cgit v1.2.3