This commit removed the ability to receive symbols from all attached
clients in the current buffer. Everything works as before when only one
client is attached to a buffer.
This also fixes outline LSP finding clients on nvim-0.7
Primarily:
- Utils
- Sidebar (removed the need of writer.lua)
- Resolve keymaps shortcut in config eraly
- Put highlight functions into highlight.lua
- Put functions that do stuff on outline window into view.lua
Previously on each outline open, the `writer.make_outline` function
might be called at least 4 times(!), after this refactor it will only be
called once. And on update cursor autocmds, also called once (previously
at least twice).
behaviour:
- Now the outline window focus and highlight can update on each cursor
move (previously CursorHold, dependent on updatetime). This is now
configurable as well.
- During fold-all/unfold-all operations, now the cursor will remain on
the same node (rather than same line in outline buffer).
- The performance improvement is not significantly observable since even
the old implementation can appear instant. One may even argue I am
fixing a problem that did not exist, but implementation-wise it's just
so much better now.
config:
- outline_window.auto_update_events, list of events to be passed to
create_user_autocmd for updating cursor focus in outline, and updating
outline items (refetching symbols), using keys cursor and items
respectively.
- outline_window.show_cursorline now supports 2 other string values:
'focus_in_outline'/'focus_in_code' which controls when to enable
cursorline. Setting to true retains the default behaviour of always
showing the cursorline. This was added because now that the cursor
focus on the outline could change on each CursorMoved, the cursorline
may pose to be qute attention-seeking during the outline cursor
updates. Hence `focus_in_outline` is added so that when focus is in
code, the cursorline for outline window is not shown.
'focus_in_code' is added so that a user who disabled
highlight_hovered_item can keep track of position in outline when
focus is in code, disabling cursorline when focus is in outline.
At any given time, if hide cursor is enabled and show_cursorline is a
string value, hiding of cursor will not be done if cursorline is not
shown in the the given situation.
implementation:
- The reason for the improvement in performance as described in the
first paragraph is due to merging of finding hover item and finding
the deepest matched node to put cursor, into writer.make_outline. This
done, when previously done in separate function, because after the
separate function (namely _highlight_hovered_item) finishes,
writer.make_outline is called *again* anyway.
- Autocmds to update cursor position in outline is now done per buffer
rather than global.
Somehow the auto unfold and unfold depth options still work perfectly,
for this we should thank simrat or which ever contributor that
modularized the folding module and made it adaptable :)
Closes#27
- Highlight group 'OutlineJumpHighlight' (links to Visual by default)
- Config: outline_window.jump_highlight_duration (integer for
milliseconds, or boolean to enable/disable)
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.
Scope:
- Parsing of symbol tree
- Producing the flattened tree
- Producing the lines shown in the outline based on the symbol tree
- API of exported functions for parser.lua and writer.lua
Note that the formatting of the outline remains the same as before.
Fixes:
- Guide highlights sometimes cover fold marker areas (may be related to
the issue brought up by @silvercircle on reddit)
- Guide highlights do not work when using guide markers of different
widths than the default (such as setting all markers to ascii chars)
All of these issues are now fixed after integrating the a parser
algorithm.
This commit introduces:
1. A better algorithm for flattening & parsing the tree in one go
2. `OutlineFoldMarker` highlight group
3. Fixed inconsistent highlighting of guides and legacy (somewhat weaker
code), through (1).
4. Minor performance improvements
5. Type hints for the symbol tree
6. Removed several functions from writer.lua and parser.lua due to them
being merged into writer.make_outline
This can be seen as a breaking change because functions that were
exported had altered behaviours. However I doubt these functions
actually have any critical use outside of this plugin, hence it isn't
really a breaking change as the user-experience remains the same.
The extraneous left padding on the outline window is now a relic of the
past 🎉
The old implementation, parser.get_lines used a flattened tree and was
inefficient, full of off-by-one corrections.
While trying to look for bug fixes in that function I realized it's the
sort of "if it works, don't touch it" portion of code.
Hence, I figured a complete rewrite is necessary.
Now, the function responsible for making the outline lines lives at
writer.make_outline. Building the flattened tree, getting lines, details
and linenos are now done in one go.
This is a tradeoff between modular design and efficiency.
parser.lua still serve important purposes:
- local parse_result function converts the hierarchical tables from
provider into a nested form tree, used everywhere in outline.nvim. The
type hint of the return value is now defined -- outline.SymbolNode
- preorder_iter is an iterator that traverses the aforementioned tree in
pre-order style. First the parents, all the childrens, and so on until
the last node of the root tree. This is used in writer.make_outline to
abstract a way the traversal code from the code of making the lines.
Thanks to stack overflow I did not have to consult a DS book to figure
out the cleanest way of this traversal method without using recursion.
This, of course, closes#14 on github.
Note that another minor 'breaking' change is that previously, hl for the
guides where grouped per-character, now they are grouped together for
all the guide markers in the same line. This should not be a problem for
those who only style the fg color for guide hl. However, if you're
styling the bg color, they will now take on that bg collectively rather
than individually.
This change eliminates future maintenance burden because controlling
per-character guide highlights requires careful avoidance of off-by-one
errors.
I have tested most common features to work as before.
I may have missed particular edge cases.
Please take note of "scope" at the top of this commit message.
