Merge pull request #8 from mhiro2/feat/lsp-symbols-document

feat(lsp): Add document symbols provider

Author: mhiro2

README.md

@@ -89,10 +89,13 @@ require("peekstack").peek.definition({ mode = "inline" })
 
 -- Quick peek (temporary, no stack)
 require("peekstack").peek.references({ mode = "quick" })
+
+-- Document symbols in current buffer
+require("peekstack").peek.symbols_document()
 ```
 
 Built-in provider names:
-`lsp.definition`, `lsp.implementation`, `lsp.references`, `lsp.type_definition`, `lsp.declaration`,
+`lsp.definition`, `lsp.implementation`, `lsp.references`, `lsp.type_definition`, `lsp.declaration`, `lsp.symbols_document`,
 `diagnostics.under_cursor`, `diagnostics.in_buffer`, `file.under_cursor`, `grep.search`, `marks.buffer`,
 `marks.global`, `marks.all` (marks require their provider enabled; `grep.search` requires `rg`).
 

doc/peekstack.txt

@@ -215,6 +215,7 @@ LSP:
     lsp.references
     lsp.type_definition
     lsp.declaration
+    lsp.symbols_document
 
 Diagnostics:
     diagnostics.under_cursor   diagnostics at the cursor line (message shown above the preview)
@@ -255,6 +256,7 @@ The main module exposes the following API:
 `require("peekstack").peek.references(opts)`
 `require("peekstack").peek.type_definition(opts)`
 `require("peekstack").peek.declaration(opts)`
+`require("peekstack").peek.symbols_document(opts)`
 `require("peekstack").peek.diagnostics_cursor(opts)`
 `require("peekstack").peek.diagnostics_buffer(opts)`
 `require("peekstack").peek.file_under_cursor(opts)`
@@ -270,6 +272,7 @@ Built-in provider names:
     lsp.references
     lsp.type_definition
     lsp.declaration
+    lsp.symbols_document
     diagnostics.under_cursor
     diagnostics.in_buffer
     file.under_cursor

lua/peekstack/commands.lua

@@ -183,6 +183,7 @@ function M.setup()
         "lsp.references",
         "lsp.type_definition",
         "lsp.declaration",
+        "lsp.symbols_document",
         "diagnostics.under_cursor",
         "diagnostics.in_buffer",
         "file.under_cursor",

lua/peekstack/init.lua

@@ -201,6 +201,7 @@ end
 ---@field references fun(opts?: table)
 ---@field type_definition fun(opts?: table)
 ---@field declaration fun(opts?: table)
+---@field symbols_document fun(opts?: table)
 ---@field diagnostics_cursor fun(opts?: table)
 ---@field diagnostics_buffer fun(opts?: table)
 ---@field file_under_cursor fun(opts?: table)
@@ -230,6 +231,9 @@ M.peek = setmetatable({
   declaration = function(opts)
     return peek_by_provider("lsp.declaration", opts)
   end,
+  symbols_document = function(opts)
+    return peek_by_provider("lsp.symbols_document", opts)
+  end,
   diagnostics_cursor = function(opts)
     return peek_by_provider("diagnostics.under_cursor", opts)
   end,
@@ -301,6 +305,7 @@ function M.setup(opts)
       "references",
       "type_definition",
       "declaration",
+      "symbols_document",
     })
   end
 

lua/peekstack/providers/lsp.lua

@@ -2,12 +2,101 @@ local location = require("peekstack.core.location")
 
 local M = {}
 
+---@alias PeekstackLspResultMapper fun(result: any, provider: string, ctx: PeekstackProviderContext): PeekstackLocation[]
+
+---@param symbol table
+---@param uri string
+---@param provider string
+---@param out PeekstackLocation[]
+local function append_document_symbol(symbol, uri, provider, out)
+  if type(symbol) ~= "table" then
+    return
+  end
+
+  local range = symbol.selectionRange or symbol.range
+  local start_pos = range and range.start
+  local end_pos = range and range["end"]
+  if start_pos and end_pos then
+    local text = symbol.name
+    if type(text) ~= "string" then
+      text = nil
+    end
+    if type(symbol.detail) == "string" and symbol.detail ~= "" then
+      if text and text ~= "" then
+        text = string.format("%s - %s", text, symbol.detail)
+      else
+        text = symbol.detail
+      end
+    end
+
+    table.insert(out, {
+      uri = uri,
+      range = range,
+      text = text,
+      kind = symbol.kind,
+      provider = provider,
+    })
+  end
+
+  if vim.islist(symbol.children) then
+    for _, child in ipairs(symbol.children) do
+      append_document_symbol(child, uri, provider, out)
+    end
+  end
+end
+
+---@param result any
+---@param provider string
+---@param _ctx PeekstackProviderContext
+---@return PeekstackLocation[]
+local function default_result_mapper(result, provider, _ctx)
+  return location.list_from_lsp(result, provider)
+end
+
+---@param result any
+---@param provider string
+---@param ctx PeekstackProviderContext
+---@return PeekstackLocation[]
+local function document_symbol_result_mapper(result, provider, ctx)
+  local items = {}
+  if not result then
+    return items
+  end
+
+  local results = vim.islist(result) and result or { result }
+
+  local uri
+  if ctx.bufnr and vim.api.nvim_buf_is_valid(ctx.bufnr) then
+    uri = vim.uri_from_bufnr(ctx.bufnr)
+  end
+
+  for _, symbol in ipairs(results) do
+    if type(symbol) == "table" and symbol.location then
+      local loc = location.normalize(symbol.location, provider)
+      if loc then
+        if type(symbol.name) == "string" and symbol.name ~= "" then
+          loc.text = symbol.name
+        end
+        if type(symbol.kind) == "number" then
+          loc.kind = symbol.kind
+        end
+        table.insert(items, loc)
+      end
+    elseif uri then
+      append_document_symbol(symbol, uri, provider, items)
+    end
+  end
+
+  return items
+end
+
 ---@param ctx PeekstackProviderContext
 ---@param method string
 ---@param provider string
 ---@param params_modifier nil|fun(params: table)
+---@param result_mapper nil|PeekstackLspResultMapper
 ---@param cb fun(locations: PeekstackLocation[])
-local function request(ctx, method, provider, params_modifier, cb)
+local function request(ctx, method, provider, params_modifier, result_mapper, cb)
   local bufnr = ctx.bufnr
   local clients = vim.lsp.get_clients({ bufnr = bufnr, method = method })
   if not clients or vim.tbl_isempty(clients) then
@@ -17,6 +106,7 @@ local function request(ctx, method, provider, params_modifier, cb)
 
   local all_locations = {}
   local remaining = #clients
+  local mapper = result_mapper or default_result_mapper
 
   for _, client in ipairs(clients) do
     local params = {
@@ -31,8 +121,10 @@ local function request(ctx, method, provider, params_modifier, cb)
     end
     client:request(method, params, function(err, result)
       if not err and result then
-        local locs = location.list_from_lsp(result, provider)
-        vim.list_extend(all_locations, locs)
+        local ok, locs = pcall(mapper, result, provider, ctx)
+        if ok and type(locs) == "table" then
+          vim.list_extend(all_locations, locs)
+        end
       end
       remaining = remaining - 1
       if remaining == 0 then
@@ -45,10 +137,11 @@ end
 ---@param method string
 ---@param provider string
 ---@param params_modifier nil|fun(params: table)
+---@param result_mapper nil|PeekstackLspResultMapper
 ---@return fun(ctx: PeekstackProviderContext, cb: fun(locations: PeekstackLocation[]))
-local function create_provider(method, provider, params_modifier)
+local function create_provider(method, provider, params_modifier, result_mapper)
   return function(ctx, cb)
-    request(ctx, method, provider, params_modifier, cb)
+    request(ctx, method, provider, params_modifier, result_mapper, cb)
   end
 end
 
@@ -59,5 +152,8 @@ M.declaration = create_provider("textDocument/declaration", "lsp.declaration")
 M.references = create_provider("textDocument/references", "lsp.references", function(params)
   params.context = { includeDeclaration = false }
 end)
+M.symbols_document = create_provider("textDocument/documentSymbol", "lsp.symbols_document", function(params)
+  params.position = nil
+end, document_symbol_result_mapper)
 
 return M

tests/commands_spec.lua

@@ -140,6 +140,7 @@ describe("peekstack.commands", function()
     local names = vim.fn.getcompletion("PeekstackQuickPeek ", "cmdline")
 
     assert.is_true(vim.list_contains(names, "lsp.declaration"))
+    assert.is_true(vim.list_contains(names, "lsp.symbols_document"))
     assert.is_true(vim.list_contains(names, "diagnostics.in_buffer"))
     assert.is_true(vim.list_contains(names, "marks.buffer"))
     assert.is_true(vim.list_contains(names, "marks.global"))

tests/lsp_provider_spec.lua

@@ -0,0 +1,164 @@
+local lsp_provider = require("peekstack.providers.lsp")
+
+describe("peekstack.providers.lsp", function()
+  local original_get_clients
+  local original_notify
+  local notifications
+
+  local function make_ctx()
+    local winid = vim.api.nvim_get_current_win()
+    local bufnr = vim.api.nvim_get_current_buf()
+    return {
+      winid = winid,
+      bufnr = bufnr,
+      source_bufnr = nil,
+      popup_id = nil,
+      buffer_mode = nil,
+      line_offset = 0,
+      position = { line = 0, character = 0 },
+      root_winid = winid,
+      from_popup = false,
+    }
+  end
+
+  before_each(function()
+    original_get_clients = vim.lsp.get_clients
+    original_notify = vim.notify
+    notifications = {}
+    vim.notify = function(msg, level)
+      table.insert(notifications, { msg = msg, level = level })
+    end
+  end)
+
+  after_each(function()
+    vim.lsp.get_clients = original_get_clients
+    vim.notify = original_notify
+  end)
+
+  it("maps DocumentSymbol results with hierarchy flattening", function()
+    vim.lsp.get_clients = function(opts)
+      assert.equals("textDocument/documentSymbol", opts.method)
+      return {
+        {
+          request = function(_, method, params, handler, _bufnr)
+            assert.equals("textDocument/documentSymbol", method)
+            assert.is_nil(params.position)
+            assert.is_table(params.textDocument)
+
+            handler(nil, {
+              {
+                name = "Parent",
+                detail = "class",
+                kind = 5,
+                range = {
+                  start = { line = 0, character = 0 },
+                  ["end"] = { line = 20, character = 0 },
+                },
+                selectionRange = {
+                  start = { line = 1, character = 2 },
+                  ["end"] = { line = 1, character = 8 },
+                },
+                children = {
+                  {
+                    name = "Child",
+                    kind = 6,
+                    range = {
+                      start = { line = 3, character = 1 },
+                      ["end"] = { line = 3, character = 5 },
+                    },
+                  },
+                },
+              },
+              { name = "BrokenWithoutRange" },
+            })
+          end,
+        },
+      }
+    end
+
+    local received
+    local ctx = make_ctx()
+    lsp_provider.symbols_document(ctx, function(locations)
+      received = locations
+    end)
+
+    assert.is_table(received)
+    assert.equals(2, #received)
+    assert.equals(vim.uri_from_bufnr(ctx.bufnr), received[1].uri)
+    assert.equals(1, received[1].range.start.line)
+    assert.equals(2, received[1].range.start.character)
+    assert.equals("Parent - class", received[1].text)
+    assert.equals(5, received[1].kind)
+    assert.equals("lsp.symbols_document", received[1].provider)
+
+    assert.equals(3, received[2].range.start.line)
+    assert.equals(1, received[2].range.start.character)
+    assert.equals("Child", received[2].text)
+    assert.equals(6, received[2].kind)
+    assert.equals("lsp.symbols_document", received[2].provider)
+  end)
+
+  it("maps SymbolInformation results", function()
+    vim.lsp.get_clients = function(opts)
+      assert.equals("textDocument/documentSymbol", opts.method)
+      return {
+        {
+          request = function(_, _method, _params, handler, _bufnr)
+            handler(nil, {
+              {
+                name = "GlobalFn",
+                kind = 12,
+                location = {
+                  uri = "file:///tmp/symbol.lua",
+                  range = {
+                    start = { line = 9, character = 4 },
+                    ["end"] = { line = 9, character = 12 },
+                  },
+                },
+              },
+              {
+                name = "Invalid",
+                location = {},
+              },
+            })
+          end,
+        },
+      }
+    end
+
+    local received
+    lsp_provider.symbols_document(make_ctx(), function(locations)
+      received = locations
+    end)
+
+    assert.is_table(received)
+    assert.equals(1, #received)
+    assert.equals("file:///tmp/symbol.lua", received[1].uri)
+    assert.equals(9, received[1].range.start.line)
+    assert.equals(4, received[1].range.start.character)
+    assert.equals("GlobalFn", received[1].text)
+    assert.equals(12, received[1].kind)
+    assert.equals("lsp.symbols_document", received[1].provider)
+  end)
+
+  it("warns when no lsp clients are attached", function()
+    vim.lsp.get_clients = function(_opts)
+      return {}
+    end
+
+    local called = false
+    lsp_provider.symbols_document(make_ctx(), function(_locations)
+      called = true
+    end)
+
+    assert.is_false(called)
+    local found = false
+    for _, item in ipairs(notifications) do
+      if item.msg == "No LSP clients attached" then
+        found = true
+        break
+      end
+    end
+    assert.is_true(found)
+  end)
+end)