my demo first config lua

current_config/lua/alpha/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("alpha.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", "<c-o>", function()
+          actions.close(prompt_bufnr)
+          local selection = action_state.get_selected_entry()
+          open_resolver(selection.resolver)
+        end)
+        return true
+      end,
+    })
+    :find()
+end
+
+return gateway

current_config/lua/alpha/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

current_config/lua/alpha/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,
+}