David Blume's GitList
Repositories
dotfiles.git
Code
Commits
Branches
Tags
Search
Tree:
f26fde6
Branches
Tags
main
pathogen
remove-vim-airline
vim-airline-disabled
vim-powerline
dotfiles.git
.local
share
nvim
site
plugin
tabular
doc
Tabular.txt
Add vim plugin tabular
dblume
commited
f26fde6
at 2024-10-26 01:08:07
Tabular.txt
Blame
History
Raw
*Tabular.txt* Configurable, flexible, intuitive text aligning *tabular* *tabular.vim* #|#|#|#|#| #| #| ~ #| #|#|#| #|#|#| #| #| #| #|#|#| #| #|#| ~ #| #| #| #| #| #| #| #| #| #| #|#| ~ #| #| #| #| #| #| #| #| #| #| #| ~ #| #|#|#| #|#|#| #|#|#| #| #|#|#| #| ~ For Vim version 7.0 or newer By Matt Wozniski mjw@drexel.edu Reference Manual ~ *tabular-toc* 1. Description |tabular-intro| 2. Walkthrough |tabular-walkthrough| 3. Scripting |tabular-scripting| The functionality mentioned here is a plugin, see |add-plugin|. You can avoid loading this plugin by setting the "Tabular_loaded" global variable in your |vimrc| file: > :let g:tabular_loaded = 1 ============================================================================== 1. Description *tabular-intro* Sometimes, it's useful to line up text. Naturally, it's nicer to have the computer do this for you, since aligning things by hand quickly becomes unpleasant. While there are other plugins for aligning text, the ones I've tried are either impossibly difficult to understand and use, or too simplistic to handle complicated tasks. This plugin aims to make the easy things easy and the hard things possible, without providing an unnecessarily obtuse interface. It's still a work in progress, and criticisms are welcome. ============================================================================== 2. Walkthrough *tabular-walkthrough* *:Tabularize* Tabular's commands are based largely on regular expressions. The basic technique used by Tabular is taking some regex to match field delimiters, splitting the input lines at those delimiters, trimming unnecessary spaces from the non-delimiter parts, padding the non-delimiter parts of the lines with spaces to make them the same length, and joining things back together again. For instance, consider starting with the following lines: > Some short phrase,some other phrase A much longer phrase here,and another long phrase < Let's say we want to line these lines up at the commas. We can tell Tabularize to do this by passing a pattern matching , to the Tabularize command: > :Tabularize /, Some short phrase , some other phrase A much longer phrase here , and another long phrase < I encourage you to try copying those lines to another buffer and trying to call :Tabularize. You'll want to take notice of two things quickly: First, instead of requiring a range, Tabularize tries to figure out what you want to happen. Since it knows that you want to act on lines matching a comma, it will look upwards and downwards for lines around the current line that match a comma, and consider all contiguous lines matching the pattern to be the range to be acted upon. You can always override this by specifying a range, though. The second thing you should notice is that you'll almost certainly be able to abbreviate :Tabularize to :Tab - using this form in mappings and scripts is discouraged as it will make conflicts with other scripts more likely, but for interactive use it's a nice timesaver. Another convenience feature is that running :Tabularize without providing a new pattern will cause it to reuse the last pattern it was called with. So, anyway, now the commas line up. Splitting the lines on commas, Tabular realized that 'Some short phrase' would need to be padded with spaces to match the length of 'A much longer phrase here', and it did that before joining the lines back together. You'll also notice that, in addition to the spaces inserting for padding, extra spaces were inserted between fields. That's because by default, Tabular prints things left-aligned with one space between fields. If you wanted to print things right-aligned with no spaces between fields, you would provide a different format to the Tabularize command: > :Tabularize /,/r0 Some short phrase, some other phrase A much longer phrase here,and another long phrase < A format specifier is either l, r, or c, followed by one or more digits. If the letter is l, the field will be left aligned, similarly for r and right aligning and c and center aligning. The number following the letter is the number of spaces padding to insert before the start of the next field. Multiple format specifiers can be added to the same command - each field will be printed with the next format specifier in the list; when they all have been used the first will be used again, and so on. So, the last command right aligned every field, then inserted 0 spaces of padding before the next field. What if we wanted to right align the text before the comma, and left align the text after the comma? The command would look like this: > :Tabularize /,/r1c1l0 Some short phrase , some other phrase A much longer phrase here , and another long phrase < That command would be read as "Align the matching text, splitting fields on commas. Print everything before the first comma right aligned, then 1 space, then the comma center aligned, then 1 space, then everything after the comma left aligned." Notice that the alignment of the field the comma is in is irrelevant - since it's only 1 cell wide, it looks the same whether it's right, left, or center aligned. Also notice that the 0 padding spaces specified for the 3rd field are unused - but they would be used if there were enough fields to require looping through the fields again. For instance: > abc,def,ghi a,b a,b,c :Tabularize /,/r1c1l0 abc , def, ghi a , b a , b , c < Notice that now, the format pattern has been reused; field 4 (the second comma) is right aligned, field 5 is center aligned. No spaces were inserted between the 3rd field (containing "def") and the 4th field (the second comma) because the format specified 'l0'. But, what if you only wanted to act on the first comma on the line, rather than all of the commas on the line? Let's say we want everything before the first comma right aligned, then the comma, then everything after the comma left aligned: > abc,def,ghi a,b a,b,c :Tabularize /^[^,]*\zs,/r0c0l0 abc,def,ghi a,b a,b,c < Here, we used a Vim regex that would only match the first comma on the line. It matches the beginning of the line, followed by all the non-comma characters up to the first comma, and then forgets about what it matched so far and pretends that the match starts exactly at the comma. But, now that this command does exactly what we want it to, it's become pretty unwieldy. It would be unpleasant to need to type that more than once or twice. The solution is to assign a name to it. > :AddTabularPattern first_comma /^[^,]*\zs,/r0c0l0 < Now, typing ":Tabularize first_comma" will do the same thing as typing the whole pattern out each time. Of course this is more useful if you store the name in a file to be used later. NOTE: In order to make these new commands available every time vim starts, you'll need to put those new commands into a .vim file in a plugin directory somewhere in your 'runtimepath'. In order to make sure that Tabular.vim has already been loaded before your file tries to use :AddTabularPattern or :AddTabularPipeline, the new file should be installed in an after/plugin directory in 'runtimepath'. In general, it will be safe to find out where the TabularMaps.vim plugin was installed, and place other files extending Tabular.vim in the same directory as TabularMaps.vim. For more information, and some suggested best practices, check out the |tabular-scripting| section. Lastly, we'll approach the case where tabular cannot achieve your desired goal just by splitting lines apart, trimming whitespace, padding with whitespace, and rejoining the lines. As an example, consider the multiple_spaces command from TabularMaps.vim. The goal is to split using two or more spaces as a field delimiter, and join fields back together, properly lined up, with only two spaces between the end of each field and the beginning of the next. Unfortunately, Tabular can't do this with only the commands we know so far: > :Tabularize / / < The above function won't work, because it will consider "a b" as 5 fields delimited by two pairs of 2 spaces ( 'a', ' ', '', ' ', 'b' ) instead of as 3 fields delimited by one set of 2 or more spaces ( 'a', ' ', 'b' ). > :Tabularize / \+/ < The above function won't work either, because it will leave the delimiter as 4 spaces when used against "a b", meaning that we would fail at our goal of collapsing everything down to two spaces between fields. So, we need a new command to get around this: > :AddTabularPipeline multiple_spaces / \{2,}/ \ map(a:lines, "substitute(v:val, ' \{2,}', ' ', 'g')") \ | tabular#TabularizeStrings(a:lines, ' ', 'l0') < Yeah. I know it looks complicated. Bear with me. I probably will try to add in some shortcuts for this syntax, but this verbose will be guaranteed to always work. You should already recognize the name being assigned. The next thing to happen is / \{2,}/ which is a pattern specifying which lines should automatically be included in the range when no range is given. Without this, there would be no pattern to use for extending the range. Everything after that is a | separated list of expressions to be evaluated. In the context in which they will be evaluated, a:lines will be set to a List of Strings containing the text of the lines being filtered as they procede through the pipeline you've set up. The \ at the start of the lines are just vim's line continuation marker; you needn't worry much about them. So, the first expression in the pipeline transforms each line by replacing every instance of 2 or more spaces with exactly two spaces. The second command in the pipeline performs the equivalent of ":Tabularize / /l0"; the only difference is that it is operating on a List of Strings rather than text in the buffer. At the end of the pipeline, the Strings in the modified a:lines (or the return value of the last expression in the pipeline, if it returns a List) will replace the chosen range. ============================================================================== 3. Extending *tabular-scripting* As mentioned above, the most important consideration when extending Tabular with new maps or commands is that your plugin must be loaded after Tabular.vim has finished loading, and only if Tabular.vim has loaded successfully. The easiest approach to making sure it loads after Tabular.vim is simply putting the new file (we'll call it "tabular_extra.vim" as an example) into an "after/plugin/" directory in 'runtimepath', for instance: > ~/.vim/after/plugin/tabular_extra.vim < The default set of mappings, found in "TabularMaps.vim", is installed in the after/plugin/ subdirectory of whatever directory Tabular was installed to. The other important consideration is making sure that your commands are only called if Tabular.vim was actually loaded. The easiest way to do this is by checking for the existence of the :Tabularize command at the start of your plugin. A short example plugin would look like this: > " after/plugin/my_tabular_commands.vim " Provides extra :Tabularize commands if !exists(':Tabularize') finish " Give up here; the Tabular plugin musn't have been loaded endif " Make line wrapping possible by resetting the 'cpo' option, first saving it let s:save_cpo = &cpo set cpo&vim AddTabularPattern! asterisk /*/l1 AddTabularPipeline! remove_leading_spaces /^ / \ map(a:lines, "substitute(v:val, '^ *', '', '')") " Restore the saved value of 'cpo' let &cpo = s:save_cpo unlet s:save_cpo < ============================================================================== vim:tw=78:fo=tcq2:isk=!-~,^*,^\|,^\":ts=8:ft=help:norl:
