leigh/outline.nvim
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: Symbol filtering config structure

Browse Source 
This commit introduces a basic framework for symbol filtering in
outline.nvim, where users can set per-filetype kinds to filter - include
or exclude for each filetype.

As a side effect the checking of symbol inclusion function has been
improved to O(1) time-complexity (previously O(n)). You can see this
from types/outline.lua and config.lua: a lookup table is used to check
if a kind is filtered, rather than looping through a list each time.
Former takes O(1) for lookup whereas the old implementation would be
O(n) for *each* node!

The old symbols.blacklist option *still works as expected*.

The schema for the new confit is detailed in #23 and types/outline.lua.
By the way, this commit also closes #23.

These should equivalent:
    symbols.blacklist = { 'Function', 'Method' }
    symbols.filter = { 'Function', 'Method', exclude=true }
    symbols.filter = {
      ['*'] = { 'Function', 'Method', exclude=true }
    }

And these should be equivalent:
    symbols.blacklist = {}
    symbols.filter = false
    symbols.filter = nil
    symbols.filter = { ['*'] = false }
    symbols.filter = { ['*'] = { exclude = true } }
    symbols.filter = { exclude = true }

The last two of which could be considered unidiomatic.

When multiple filetypes are specified, filetype specific filters
are NOT merged with the default ('*') filter, they are independent. If a
filetype is used, the default filter is not considered. The default
filter is only considered if a filetype filter for the given buffer is
not provided.

LIMITATIONS:
This is carried over from the implementation from symbols-outline:
filters can only be applied to parents at the moment. I.e.: If some node
has a kind that is excluded, all its children will NOT be considered.

Filters are only applied to children if its parent was not excluded
during filtering.

Also extracted all types into types module, and updated conversion
script to use the new symbols.filter opt.

NOTE:
On outline open it appears that parsing functions are called twice?
I should definitely add tests soon.
This commit is contained in:
hedy
2023-11-16 21:21:55 +08:00
parent 5278eb5b2b
commit 24680f13f7
7 changed files with 244 additions and 80 deletions
Download Patch File Download Diff File Expand all files Collapse all files

173
lua/outline/config.lua
View File

@@ -1,8 +1,7 @@
local utils = require('outline.utils')
local M = {}
-- TODO: Types for config schema
local all_kinds = {'File', 'Module', 'Namespace', 'Package', 'Class', 'Method', 'Property', 'Field', 'Constructor', 'Enum', 'Interface', 'Function', 'Variable', 'Constant', 'String', 'Number', 'Boolean', 'Array', 'Object', 'Key', 'Null', 'EnumMember', 'Struct', 'Event', 'Operator', 'TypeParameter', 'Component', 'Fragment', 'TypeAlias', 'Parameter', 'StaticMethod', 'Macro',}
M.defaults = {
guides = {
@@ -77,7 +76,8 @@ M.defaults = {
},
},
symbols = {
blacklist = {},
---@type outline.FilterConfig?
filter = nil,
icon_source = nil,
icon_fetcher = nil,
icons = {
@@ -166,6 +166,16 @@ function M.get_split_command()
end
end
---Whether table == {}
---@param t table
local function is_empty_table(t)
return t and next(t) == nil
end
local function table_has_content(t)
return t and next(t) ~= nil
end
local function has_value(tab, val)
for _, value in ipairs(tab) do
if value == val then
@@ -176,11 +186,33 @@ local function has_value(tab, val)
return false
end
function M.is_symbol_blacklisted(kind)
if kind == nil then
return false
---Determine whether to include symbol in outline based on bufnr and its kind
---@param kind string
---@param bufnr integer
---@return boolean include
function M.should_include_symbol(kind, bufnr)
local ft = vim.api.nvim_buf_get_option(bufnr, 'ft')
-- There can only be one kind in markdown as of now
if ft == 'markdown' or kind == nil then
return true
end
return has_value(M.o.symbols.blacklist, kind)
local filter_table = M.o.symbols.filter[ft]
local default_filter_table = M.o.symbols.filter['*']
-- When filter table for a ft is not specified, all symbols are shown
if not filter_table then
if not default_filter_table then
return true
else
return default_filter_table[kind] ~= false
end
end
-- XXX: If the given kind is not known by outline.nvim (ie: not in
-- all_kinds), still return true. Only exclude those symbols that were
-- explicitly filtered out.
return filter_table[kind] ~= false
end
---@param client vim.lsp.client|number
@@ -197,6 +229,8 @@ function M.is_client_blacklisted(client)
return has_value(M.o.providers.lsp.blacklist_clients, client.name)
end
---Retrieve and cache import paths of all providers in order of given priority
---@return string[]
function M.get_providers()
if M.providers then
return M.providers
@@ -217,15 +251,26 @@ function M.show_help()
print(vim.inspect(M.o.keymaps))
end
---Check for inconsistent or mutually exclusive opts. Does not alter the opts
---Check for inconsistent or mutually exclusive opts.
-- Does not alter the opts. Might show messages.
function M.check_config()
if M.o.outline_window.hide_cursor and not M.o.outline_window.show_cursorline then
utils.echo("config", "hide_cursor enabled without cursorline enabled!")
utils.echo("config", "Warning: hide_cursor enabled without cursorline enabled")
end
end
---Resolve shortcuts and deprecated option conversions
---Resolve shortcuts and deprecated option conversions.
-- Might alter opts. Might show messages.
function M.resolve_config()
----- GUIDES -----
local guides = M.o.guides
if type(guides) == 'boolean' then
M.o.guides = M.defaults.guides
if not guides then
M.o.guides.enabled = false
end
end
----- SPLIT COMMAND -----
local sc = M.o.outline_window.split_command
if sc then
-- This should not be needed, nor is it failsafe. But in case user only provides
@@ -234,7 +279,7 @@ function M.resolve_config()
M.o.outline_window.split_command = sc..' vs'
end
end
----- COMPAT (renaming) -----
local dg = M.o.keymaps.down_and_goto
local ug = M.o.keymaps.up_and_goto
if dg then
@@ -245,23 +290,113 @@ function M.resolve_config()
M.o.keymaps.up_and_jump = ug
M.o.keymaps.up_and_goto = nil
end
-- if dg or ug then
-- vim.notify("[outline.config]: keymaps down/up_and_goto are renamed to down/up_and_jump. Your keymaps for the current session is converted successfully.", vim.log.levels.WARN)
-- end
if M.o.outline_window.auto_goto then
M.o.outline_window.auto_jump = M.o.outline_window.auto_goto
M.o.outline_window.auto_goto = nil
end
----- SYMBOLS FILTER -----
M.resolve_filter_config()
end
---Ensure l is either table, false, or nil. If not, print warning using given
-- name that describes l, set l to nil, and return l.
---@generic T
---@param l T
---@param name string
---@return T
local function validate_filter_list(l, name)
if type(l) == 'boolean' and l then
utils.echo("config", ("Setting %s to true is undefined behaviour. Defaulting to nil."):format(name))
l = nil
elseif l and type(l) ~= 'table' and type(l) ~= 'boolean' then
utils.echo("config", ("%s must either be a table, false, or nil. Defaulting to nil."):format(name))
l = nil
end
return l
end
---Resolve shortcuts and compat opt for symbol filtering config, and set up
-- `M.o.symbols.filter` to be a proper `outline.FilterFtTable` lookup table.
function M.resolve_filter_config()
---@type outline.FilterConfig
local tmp = M.o.symbols.filter
tmp = validate_filter_list(tmp, "symbols.filter")
---- legacy form -> ft filter list ----
if table_has_content(M.o.symbols.blacklist) then
tmp = { ['*'] = M.o.symbols.blacklist }
tmp['*'].exclude = true
M.o.symbols.blacklist = nil
else
---- nil or {} -> include all symbols ----
-- For filter = {}: theoretically this would make no symbols show up. The
-- user can't possibly want this (they should've disabled the plugin
-- through the plugin manager); so we let filter = {} denote filter = nil
-- (or false), meaning include all symbols.
if not table_has_content(tmp) then
tmp = { ['*'] = { exclude = true } }
-- Lazy filter list -> ft filter list
elseif tmp[1] then
if type(tmp[1]) == 'string' then
tmp = { ['*'] = vim.deepcopy(tmp) }
else
tmp['*'] = vim.deepcopy(tmp[1])
tmp[1] = nil
end
end
end
---@type outline.FilterFtList
local filter = tmp
---@type outline.FilterFtTable
M.o.symbols.filter = {}
---- ft filter list -> lookup table ----
-- We do this so that all the O(N) checks happen once, in the setup phase,
-- and checks for the filter list later on can be speedy.
-- After this operation, filter table would have ft as keys, and for each
-- value, it has each kind key denoting whether to include that kind for this
-- filetype.
-- {
-- python = { String = false, Variable = true, ... },
-- ['*'] = { File = true, Method = true, ... },
-- }
for ft, list in pairs(filter) do
if type(ft) ~= 'string' then
utils.echo("config", "ft (keys) for symbols.filter table can only be string. Skipping this ft.")
goto continue
end
M.o.symbols.filter[ft] = {}
list = validate_filter_list(list, ("filter list for ft '%s'"):format(ft))
-- Ensure boolean.
-- Catches setting some ft = false/nil, meaning include all kinds
if not list then
list = { exclude = true }
else
list.exclude = (list.exclude ~= nil and list.exclude) or false
end
-- If it's an exclude-list, set all kinds to be included (true) by default
-- If it's an inclusive list, set all kinds to be excluded (false) by default
for _, kind in pairs(all_kinds) do
M.o.symbols.filter[ft][kind] = list.exclude
end
-- Now flip the switches
for _, kind in ipairs(list) do
M.o.symbols.filter[ft][kind] = not M.o.symbols.filter[ft][kind]
end
::continue::
end
end
function M.setup(options)
vim.g.outline_loaded = 1
M.o = vim.tbl_deep_extend('force', {}, M.defaults, options or {})
local guides = M.o.guides
if type(guides) == 'boolean' and guides then
M.o.guides = M.defaults.guides
end
M.check_config()
M.resolve_config()
end