* Don't show errors when opening preview window (occurs when buffer has unsaved changes).
* Update autoload/tagbar.vim
Co-authored-by: David Hegland <darth.gerbil@gmail.com>
Co-authored-by: David Hegland <darth.gerbil@gmail.com>
ballooneval is a global option, so setting it while initialising tagbar
permanently enables ballooneval functionality for the GUI, overriding
the vim default (disabled) or a user explicitly setting noballooneval.
To address this, only set ballooneval when entering the tagbar window,
and restore the original ballooneval setting when leaving the window.
This is not perfect, but there is precedent, Netrw behaves like this.
* Add JumpToNearbyTag functionality
Closes#779
Updated functions:
`s:GetNearbyTag()` - Allow for a direction parameter to be passed into
the routine. This will allow for a forward or backward search. It will
default to a backward search line the current behavior if the
`a:direction` parameter is not used.
`s:JumpToTag()` - Allow for an optional parameter to be passed in to
specify the tag instead of using the tag under the cursor on the current
line. This also allows this routine to be executed from the file window
instead of the tagbar window. Assume `autoclose=0` if passing in the tag.
Add new functions:
`s:JumpToNearbyTag()` - This routine will do a forward or backward search
for the nearst tag using the `GetNearbyTag()` with the new direction
field, then call the `JumpToTag()` with the tag we found.
`tagbar#jumpToNextTag()` - New public facing wrapper routine around the
`JumpToNearbyTag()` routine. Optionally take in `a:lnum` and
`a:search_method` to be used in other routines. If `a:lnum` is not
present, then the line number will search from the next or previous line
depending on the `a:direction` value.
TODO:
- [ ] Still need to write up the documentation for this.
- [ ] Possibly look at providing default keymap. Currently this can be
done using a custom definition in `.vimrc`.
* Add documentation and fix lazy scroll
Added documentation for this feature
Corrected the lazy scroll behavior when the next/prev tag is visible
Use the existing `w:autoclose` if set, else default to 0.
* Fix argument ordering
Correct the argument ordering and numbering for the jumpToNearbyTag()
routine.
Add documentation example for the 'nearest' search-method.
Rename jumpToNextTag() to jumpToNearbyTag() to be more inline with the
other routines.
* remove debug
* Fix current line processing
In the event there is a tag on the immediately previous/next line, then
the GetNearbyTag will return that tag even if the scoped-stl
search-method is set.
* Cleanup optional argument initialization
* Update tagbar#jumpToNearbyTag() - remove lnum and add flags parameter
Changes to the tagbar#jumpToNearbyTag() routine to allow more
flexibility. Removing the optional lnum parameter as this likely will
not be needed and could actually cause confusion in its use. Add a flags
field so different options can be set such as the 's':'scroll_offset'
option.
Adding additional setting to `g:tagbar_wrap` to allow for more granular
control of the `linebreak` functionality. If set to 1, linebreak will
also be set. If set to 2, linebreak will be disabled.
Closes#778
Add to the `JumpToTag()` routine so if the current line does not contain
a valid tag, then it will check if the line is foldable, and if so will
either call the `OpenFold()` or `CloseFold()` as necessary. This allows
the `<Enter>` key to be used to toggle a foldable header in the tagbar
window.
Closes#776
Change the ordering of the --options field when executing ctags. This
allows overrides of things like the --<lang>-kinds definitions to omit
certain kinds.
Also add check to ensure the typeinfo.deffile exists before attempting
to use it in the ctags arguments.
Fixes#750
Once the tagbar window is opened and a file is registered, that file
stays in memory even if the tagbar window is closed. This allows tagbar
to cache the info so if the tagbar window is opened again, it doesn't
have to rescan the file and rerun ctags on the file.
However if this buffer is wiped out using `:bwipe <file>`, then the
buffer is completely unloaded from vim memory and also needs to be
unloaded from tagbar memory. This works if the tagbar window is open,
but in the event the tagbar window is closed, all autocmds are
unregistered, so tagbar never gets the BufWipeout notification. This
results in tagbar leaving the buffer in active memory even though the
buffer doesn't exist anymore.
This fix will leave the BufWipeout and BufDelete autocmds active even if
the tagbar window is closed. This allows the buffer cleanup to occur on
a `:bwipe` command even if the tagbar window is closed.
Closes#750
On `:bdelete` or `:bwipe` of a file, remove the file from the known file
listing even if the tagbar window is not open. Previously was only
removing the file if the tagbar window was open.
Clearly steer users away from Exuberant Ctags and be more explicit that
it is less well supported and will be deprecated. Rephrase sentence on
additional providers because an exemplary enumeration (such as) does not
redundantly need to add (or others).
This adds an option making the highlight in the Tagbar follow the cursor
in insert mode as well. This feature is guarded behind an option because
it may introduce some delay in the input.
GitHub: closes#724
* Fix the problem that the data type was unexpectedly displayed in the C++ destructor's tag.
* Update autoload/tagbar/prototypes/normaltag.vim
Co-authored-by: Caleb Maclennan <caleb@alerque.com>
Closes#632
Support for kotlin type was recently added into universal ctags
(https://github.com/universal-ctags/ctags/pull/2769)
Currently there is no scope information in the ctags definition. So the
`scope2kind` and `kind2scope` settings are not functional. If support is
added, then these definitions can be updated to include that info.
Note: these kind definitions are based on the output from `ctags
--list-kinds=kotlin` which is slightly different than the definitions
provided in #632. So this may not be fully compatible with the custom
ctags configuration from that issue. The default definition for
univercal ctags should be used instead.
Closes#726
New option `g:tagbar_ignore_anonymous` to ignore any tags with __anon in
the tag name. CTAGS will print any unlabeled tags with the __anon###
name with a custom hash. This option will ignore those tags and they
will not be visible in the tagbar window. This could potentially result
in unknown behavior when a parent object has been ignored in this way.
However these tags should then fall under the default hierarchy for that
particular kind.
* Add option for g:tagbar_highlight_current_tag
Closes#708
Add option for g:tagbar_highlight_current_tag which will allow
highlighting of tags on the current line in addition to highlighting the
scoped tags. Reverts the behavior added in #638 to the default from
before that commit
* Rework to allow direct configuration of highlight method
* Address review comments
* Add g:tagbar_jump_lazy_scroll option.
When this option is on, a jump to a tag will only cause the
window to scroll if the tag line is not already visible on
the window. If it is visible, the cursor will simply move
to that line without scrolling the window. If the tagline
is not visible then the window will be scrolled as in current
behavior (according to the g:tagbar_jump_offset option).
Fixes#703
* Factor our new logic into a function.
* Add jump target line to doc.
* Add linenr protection into getPrototype
Closes#706
Add protection to not go beyond the last line in the file when calling the `s:getPrototype()` routine. This occurs when there is an `=` character in the tag prototype. For example in a python tag with a parameter line this: `some_function(arg1, optional_arg_2=False)`
* Fix issue with python prototypes that can include `=` character in the argument list
* Add support for scope
Closes#508, #516
Add --fields=e (end) to the ctags field types to look for the end of the scope.
Update the `s:GetNearbyTag()` routine to use this scope to look for the correct tag.
* Update comment to call out exuberant ctags not supporting the -e option
* Update autoload/tagbar.vim
Co-authored-by: Caleb Maclennan <caleb@alerque.com>
* Optimize nearesttag search, add option for scoped-stl search method
Co-authored-by: Caleb Maclennan <caleb@alerque.com>
Closes#680
Add `g:tagbar_show_data_type` field to show the tag datatype next to the tag in the tagbar window
This uses the `--fields=t` field to get the datatype from ctags. If not found, then it will attempt to derive the datatype by extracting all the output from the `pattern` preceeding the tag name.
More testing is needed on other languages. So far this has been stable with C / C++ files parsing the datatype from ctags output. It has also been tested with Java files for the inferred datatype by parsing the pattern line and pulling out everything prior to the tag.
* Add g:tagbar_show_tag_count option
Closes#290
This option will show the tag kind count next to the kind label in the
tagbar window.
* Address review comments
* Add option to print the tag linenumber in the tagbar window
* Update documentation markup
* Change variable name to g:tagbar_show_tag_linenumbers to be more consistent with other variables
* Fix documentation
* Scoped highlighting fix
Attempt to change the scoped highlighting of the tagbar window. This
will now look only for 'stl' tag types when looking for the nearby tag
when looking to highlight. It does however take into account if the
cursor is on the same line as the tag and highlights it then as well.
* Add additional documentation
* Add documentation for tagbar#printfileinfo() debug routine
Perform a has_key() check prior to referencing the dictionary to ensure
the dictionary has a valid key for the specified kind.
Note: When an unknown kind is found, it can mess up the tag highlighting
in the tagbar window. Not sure why this is occurring.
* Fix for window positioning
With default case having multiple vertically split windows, the tagbar
window should open on the far right of the screen. When the feature in
pull-request 630 was added, this behavior changed to open the tagbar
window relative to the current window. This commit will fix that by
allowing direct usage of the vim split options.
Validated the following cases for the old default values. These all
still behave the same way as prior to pull-request 630 when the tagbar
is activated in the `active` window shown in the below examples:
```
" No options
+-----------------------------------+
| preview |
+--------+--------+--------+--------+
| edit | edit | edit | tagbar |
| | active | | |
+--------+--------+--------+--------+
" tagbar on left, preview above
let g:tagbar_left = 1
+-----------------------------------+
| preview |
+--------+--------+--------+--------+
| tagbar | edit | edit | edit |
| | | active | |
+--------+--------+--------+--------+
" tagbar on bottom, preview to right of tagbar
let g:tagbar_vertical = 10
+--------+---------------+--------+
| edit | edit | edit |
| | active | |
| +-----+---------+ |
| | tag | preview | |
+--------+-----+---------+--------+
" tagbar on top, preview to the right of tagbar
let g:tagbar_left = 1
let g:tagbar_vertical = 10
+--------+-----+---------+--------+
| edit | tag | preview | edit |
| +-----+---------+ |
| | edit | |
| | active | |
+--------+---------------+--------+
```
New values also all validated using the following:
```
" Behaves the same as no options
let g:tagbar_position = 'right'
" Behaves the same as g:tagbar_left = 1
let g:tagbar_position = 'left'
" Behaves the same as g:tagbar_vertical = <#>
let g:tagbar_position = 'bottom'
" Behaves the same as g:tagbar_left = 1 | g:tagbar_vertical = <#>
let g:tagbar_position = 'top'
```
* #650 - Fix typo in doc/tagbar.txt for g:tagbar_height option
In C++, the name of the destructor of a class starts with a
tidle(~) which is special when the option 'magic' is set. This
will cause an error when jumping to a destructor. Call search()
in "very nomagic" environment can solve this problem no matter the
option 'magic' is set or not.
New configuration option for g:tagbar_position that will supercede g:tagbar_left. This option allows for new values for 'top', 'bottom', 'left' and 'right' (default:'right') to position the Tagbar window.
New configuration option for g:tagbar_height that will supercede g:tagbar_vertical. This option is used to set the Tagbar window height when the window is split using the 'top' or 'bottom' position.
New configuration option for g:tagbar_no_status_line. This option will disable any Tagbar status line updates in the event another plugin is controlling the status line. This prevents Tagbar from changing the status line when Tagbar is not the active window.
Co-authored-by: David Hegland <david.hegland@broadcom.com>
If vim is launched from the Elvish shell, then fall back to using the
bourne shell (sh) or a bourne compatible shell when calling
{universal/exuberant-}ctags.
Signed-off-by: Adam Jimerson <vendion@gmail.com>
There is no spoon. My testing last night was flawed because I had a typo
in my RC file that was complicating matters. In seems the syntax fix was
all this needed to work okay, not disabling the feature
This makes it possible to actually see the function names in
stacktraces. It also means that the internal objects of some of the tag
prototypes don't need to be public any more.
The TagbarKind syntax match pattern has a zero-width look-behind atom
with unlimited length. This can slow down syntax highlighting. Since in
this case there can only be 1 or 2 characters that get matched, we can
set a limit for the match, thus speeding up the matching.
Since the limit unfortunately works with bytes instead of characters,
use 3 instead of 2 to account for double-width folding characters.
Exuberant Ctags:
- ObjectiveC
Universal Ctags:
- Ada
- Autoconf
- Automake
- Ctags config
- D
- Elm (courtesy of @bitterjug)
- Go
- ObjectiveC
- Perl 6
- Protobuf (closes#437)
- R
Also various improvements to existing definitions based on changes in
Universal Ctags.
Added scopes, so tagbar will show the following hierarchy:
```
namespace
subnamespace
...
class
property (variable)
...
method
...
```
Additional kinds added (basically the same as #283):
* namespaces
* use aliases (imports)
* traits
The view files created with the 'mkview' command run the
'SessionLoadPost' autocommand at the end, which creates problems if
Tagbar has alread been initialized. Add a new variable so that we can
detect this situation.
Currently the tags will always get updated immediately when writing a
file. However, for large files that can slow down the writing process
noticeably, leading to annoying pauses. This commit instead defers the
updating process to the first CursorHold/CursorHoldI event after writing
a file, which should make the process much less noticeable.
Closes#289Closes#381
References SpaceVim/SpaceVim#129
When constructing the tag tree it is often necessary to look up tags
with a certain name and other attributes at the current depth. This was
previously done with the filter() function on the list of all the
relevant tags. However, this filtering is very slow.
This commit changes the FileInfo and TagInfo objects to save added tags
in a dictionary indexed by the name of the tag in addition to the list
(which is still maintained in parallel since it is necessary for things
like sorting). This significatly speeds up tag lookup since most tags
have unique names.
The current algorithm for contructing the tag tree works pretty well
even when pseudo-tags are encountered, but is quite complex, hard to
understand, and hard to tweak and optimize. This commit rewrites the
algorithm to a relatively straight-forward recursive algorithm that
makes use of placeholder pseudo-tags if required that will get replaced
if the actual tag is encountered later.
When switching buffers during the handling of the BufDelete event the
saved buffer number of the last alternate buffer will change, so we have
to save a local copy to be able to properly unset the 'tagbar_ignore'
buffer variable.
When opening the Tagbar window the window numbers can change so that
restoring the window history is not possible. Use the new window ID
functionality if it is available to make that possible.
When we have to go to the Tagbar window to update it the knowledge of
the previous window to the one we're coming from gets lost. Save it
before switching windows so we can restore it after returning from the
Tagbar window.
The QuitPre autocommand was introduced in Vim version 7.3.544. If Vim is
older than this then don't use the HandleOnlyWindow() functionality, so
in the case of closing the last window in a tab a user will have to
close the Tagbar window themselves.
This commit should (hopefully) finally fix the case of users calling
':bdelete/:bwipeout' or ':quit' while Tagbar is open and just do the
right thing. See commit e4cfe8a for a more thorough description of how
it's supposed to work.
When a window that is displaying a normal file gets closed with a :quit,
:bdelete or other command, Tagbar may end up as the only visible window
left, which isn't very useful. Previously Tagbar would just quit in such
a situation (unless there was more than one tab), but that is rather
non-intuitive.
The change in this commit introduces a mechanism that should hopefully
handle such a case properly based on which command was executed, and do
exactly what a user would expect:
- In the ':quit' case, it will close the current tabpage including
Tagbar unless it was the only tabpage, in which case it will quit Vim.
- In the ':bdelete/:bwipeout' case, it will delete the Tagbar buffer and
then reopen Tagbar once the buffer that Vim switched to is being
displayed.
This commit fixes tagbar compatibility issues with the
[universal-ctags](/universal-ctags/ctags), which is the most active and
consistently updated fork of the old exuberant ctags.
Failing to suppress output can cause problems in some environments,
especially if the shell command fails or does something else spooky.
Example where failing to suppress the shell command causes issues with
[vim-airline](https://github.com/bling/vim-airline) with the tagbar
extension enabled:
Here's another example:
Both were taken using uxterm in Linux.
If the runtimepath has been set incorrectly and the autoload file is
getting loaded by something, then the code won't be able to load the
"plugin" file. Print a warning message and stop loading the file instead
of throwing lots of errors.
Instead of using 'echoerr' and essentially breaking the plugin after
that problems are now reported as warnings with 'echomsg'. They will
also only be shown once for a particular problem.
The current tagbar_autoclose state will be displayed in the statusline.
Also change the "hide nonpublic" flag to "v" to match the mapping and
properly document the statusline flags.
If someone already has a function that includes "JumpToTag" in its name
then the current method of detecting whether mappings should be
initialized would fail. Use a buffer-local variable instead.
If 'hidden' is not set then BufUnload is called every time a buffer
would get hidden, removing the fileinfo. This causes unnecessary ctags
processing of files.
The current pause functionality simply removes all the autocommands to
stop updating Tagbar. This has the problem that at the moment the
statusline functions immediately restore the commands so pausing doesn't
work, but even if that didn't happen it would stop the statusline
functionality from working which is not desirable. The solution is to
have a reference to the paused file which will get used by the Tagbar
window, but not the statusline functions.
Certain quickfix-commands like vimgrep have to load all searched files
into Vim and will execute the BufReadPost autocmd for all of them. Since
Tagbar doesn't need to generate tags for those files pause processing
while the command is running.
There doesn't seem to be a better way to find out whether vimgrep is
running than to set a temporary variable with the QuickFixCmdPre/Post
autocmds, see also
https://groups.google.com/forum/#!topic/vim_use/sUj5MFGmwD8
Closing Tagbar with :q instead of the provided commands and mappings
would bypass the Vim application window shrinking logic. Install an
autocommand that checks for this situation.
This prevents files being processed twice unnecessarily, once for
FileType and once for BufReadPost. All cases where BufReadPost is called
without FileType should be covered by the checks in AutoUpdate().
When g:tagbar_iconchars = ['+', '-'] (default on Windows), and viewing a filetype (e.g. java) that has visibility information (i.e. the [-+#] sigils), the method is mistakenly highlighted as TagbarKind. Restrict its matches to when the sigil is at the beginning of the line to avoid the false matches at the indented method tags.
When there's a tag e.g. "foo-bar", the "-bar" part is matched as TagbarKind. Add a zero-width condition to all sigil patterns that allow only whitespace characters before the sigil.
a:ctags_bin calls a batch file that uses %~dp0. Changes include:
- Enable ctags_args to be a list
- Changed default ctags_args to be a list to improve robustness of
s:EscapeCtagsCmd()
- Do not escape 0th argument of ctags_cmd for cmd.exe when it is not
necessary because otherwise batch files may not return expected value
for %~dp0
- Updated tagbar documentation about string and list value types for
ctags_args
See https://github.com/majutsushi/tagbar/issues/133
Since the window numbers can change when opening and closing windows
Tagbar so far has used bufwinnr() to find the right window to jump back
to. However, this fails if the same file is being displayed in more than
one window. Save a window-local variable instead to detect the correct
window to jump back to.
If a ctags-compatible program returns an error status code on a parsing
failure then it would never be run again on the same file, even if later
invocations would have returned normally (for example after fixing an
error in the current file). Therefore we need to execute the program on
updates as usual, but do not repeat error messages if the previous run
already did.
We only need to reset '0 mark when our tagbar window is the last one,
otherwise, just quit the window and let the other window handle the
error that might happen on quiting Vim.
If there are other plugin windows open, close tagbar window and handle
over the control to the other window.
If the last file in the Vim's file arguments list has not been edited
yet, normal Vim's behavior would be quit on ':q!' or twice ':q'. As our
plugin window is the last window now, previously quiting on the file
window will not trigger the "more files" check, but our window does.
We'd better to behave the same. Currently, twice ':q' quiting would work,
but ':q!' not. There is no easy way to determine whether the command
being executed with a "!" or not, so this is a flaw now and we need
to come up a better solution someday, but it is a progress than before.
Changes requested by majutsushi.
Changed function to :TagbarTogglePause
Added documentation for function, including usage and defintion.
Changed autocommands_enable to autocommands_enabled.
tagbar#PauseAutocommands :TagbarPause
:TagbarPause pauses autocmds, effectively freezing Tagbar on the last
file. Useful for keeping a tag reference for a file open whilst working
in a different file.
Files are now cached locally in a temporary file, and the parsing
happens on that file. This allows displaying tags for remote (Netrw)
files, and it will also make access to files on remote filesystems like
NFS and sshfs faster.
Additionally, tags are now always updated when the files are saved,
deprecating the tagbar_updateonsave_maxlines option. Otherwise checking
for changes in remote files would not have been possible.
If ctags isn't installed, then until now most of the autoload script
would have been skipped, leaving functions like tagbar#currenttag()
undefined. Move the ctags check to the exuberant-ctags checking function
to prevent errors in this case.
If tagbar#currenttag() was used in a statusline on a system that had
Tagbar installed, but not ctags, then an error was reported on every
statusline update. Change the ctags checking so that errors in
currenttag() fail silently while still reporting an error message if
Tagbar is opened normally.
If a tag was in a closed fold that was itself in a closed fold, and
those folds existed since the initial display (for example by using the
g:tagbar_foldlevel option), then intermediate tags could have invalid
tline values which resulted in the search pattern failing.
- added zo alias to OpenFold()
- added za alias to ToggleFold()
- added zc alias to CloseFold()
- added zC alias to CloseParent()
- added zn alias to SetFoldLevel(99, 1)
- added zR alias to SetFoldLevel(99, 1)
- added zM alias to SetFoldLevel(0, 1)
- changed z zoom shortcut to zz to avoid delay caused by presence of new z-prefix bindings
- update s:PrintHelp() to reflect new bindings
" vim: ts=8 sw=4 sts=4 et foldenable foldmethod=marker foldcolumn=1
Reference in New Issue
Block a user
Blocking a user prevents them from interacting with repositories, such as opening or commenting on pull requests or issues. Learn more about blocking a user.
Alexey Radkov
gryf
