foldutil.vim : Utility for creating folds (using specified match criteria)
script karma |
Rating 92/29,
Downloaded by 7741 |
Comments, bugs, improvements
|
Vim wiki
|
created by |
Hari Krishna Dara |
|
script type |
utility |
|
description |
The plugins provides useful commands for the ease of creating folds using
different match-criteria. They support creating folds in three different
modes, in the whole buffer, or only in the selected range:
- block mode
You give a starting and ending pattern for the blocks.
- outline mode
You give a pattern that determines the start of the block. A new
block automatically starts whenever the pattern is found.
- non-block mode
You give a pattern which determines the set of lines that should be
included in the folds. Useful to see only the matching/non-matching
lines with or without context.
The first set of commands use pattern matching criteria (using the
built-in =~ operator, see help on |expr-=~|).
FoldMatching - All arguments are optional. The first argument specifies
the begin pattern and an optional second argument can be
passed to specify an end pattern (for block mode) and
additionally the number of context lines to be shown
(which defaults to 1 if not specified). To specify an
outline mode, a special value of -1 should be specified
as context.
Syntax:
[range]FoldMatching[!] [pattern] [endPattern] [context]
Ex:
FoldMatching
Uses current search pattern and creates folds in non-block mode
with the default context of 1.
FoldMatching! ^\s*// 0
This potentially folds away all the lines that are not in
C++/Java single-line comments such that you can see only those
comments.
FoldMatching public -1
Uses "public" as the pattern and creates folds in outline mode.
FoldMatching /\* \*/ 0
Creates folds for all the C++/Java style block comments with no
context.
FoldNonMatching - This is just an alias for "FoldMatching" with a bang.
The following commands use line number as match criteria
FoldShowLines - Pass a comma-separated list of line numbers and an
optional number of context lines to show/hide. All the
rest of the lines (excluding those in context) will be
folded away. You can also create blocks by specifying an
optional list of line numbers as a second argument. You
can give a range too.
Syntax:
[range]FoldShowLines[!] {lineNumbers} [endLineNumbers] [context]
Ex:
FoldShowLines 10,50,100 3
Creates four folds exposing the lines 10, 50 and 100 with a
context of 3 lines.
FoldShowLines! 5,15,25 10,20,30 0
Creates three folds with 5 to 10, 15 to 20 and 25 to 30 as blocks.
FoldShowMarks - Shows all the lines that have a mark defined in the
current buffer, by folding away all the rest of the
lines. Only the marks from a-z and A-Z are considered
for match criteria.
Syntax:
[range]FoldShowMarks [context]
The following command takes a highlight group as a match criteria, and
uses it to show/hide lines.
FoldShowHiGroup - Pass a highlight group name and an optional number of
context lines to be shown. All the rest of the lines
(excluding those in context) will be folded away. You
can also create blocks by specifying an optional end
highligh group as a second argument. You can give a
range too.
Syntax:
[range]FoldShowHiGroup[!] {HiGroup} [endHiGroup] [context]
Ex:
FoldShowHiGroup Todo
Folds away all the lines except those that have a TODO item
mentioned (in Java, this is all the comments containing the
words TODO or FIXME, by default) with a context of 1 line.
FoldShowHiGroup Special 0
In HTML this reveals just the lines containing special characters.
FoldShowHiGroup! Comment 0
This will fold away all the comment lines in any language.
The following is purely for convenience to reduce the number of commands
to be executed (you need to create separate folds).
FoldShowRange - All the lines are folded except for the lines in the range
given. Helps to search only in a range of lines, as it is
easy to identify when the cursor goes out of the range.
Also consider removing "search" and "jump" from
'foldopen' setting.
Syntax:
[range]FoldShowRange
Ex:
50,500FoldShowRange
The defaults for pattern and context are current search pattern
(extracted from / register) and 1 respectively.
The outline mode additionally modifies the 'foldtext' such that the
starting line shows up as the summary line for the fold (without the
usual dashes and number of lines in the prefix). This allows you to
view the matched lines more clearly and also follow the same
indentation as the original (nice when folding code). You can
however set g:foldutilFoldText to any value that is acceptable for
'foldtext' and customize this behavior (e.g., to view the number of
lines in addition to the matched line, set it to something like:
"getline(v:foldstart).' <'.(v:foldend-v:foldstart+1).' lines>'").
Ex:
- Open a vim script and try:
FoldNonMatching \<function\> -1
- Open a java class and try:
FoldNonMatching public\|private\|protected -1
- Open files with diff/patch output for several files and try:
FoldMatching diff -1
Please send me other uses that you found for the "-1" context and I
will add it to the above list.
Notes:
- The plugin provides several ways to specify the fold blocks, but not all
of them might make sense to you, especially when used with the *bang*
option to invert the match.
- For :FoldMatching command, the pattern is searched using the built-in
search() function, so any limitations application to this function apply
to the patterns passed to the command as well.
- You can change the default for context by setting g:foldutilDefContext.
- The arguments are separated by spaces, so to include spaces in the
patterns, you need to protect them with a back-slash. Specifying a bang
makes the match inverse, so it allows you to show matching lines,
instead of folding them away.
- You can change the context alone by using :FoldSetContext command or
completely end folding and revert the settings modified by the plugin by
using the :FoldEndFolding command.
- When the commands are executed, if the current 'foldmethod' is not
"manual", it is switched to "manual" temporarily and restored when the
folding is ended using the :FoldEndFolding command. It also remembers
other fold related settings (such as the existing folds and
'foldminlines') and restores them as much as possible. For help on
working with folds, see help on |folding|.
- The plugin by default, first clears the existing folds before creating the
new folds. But you can change this by setting g:foldutilClearFolds to 0,
in which case the new folds are added to the existing folds, so you can
create folds incrementally.
- The plugin provides a function to return a string with Vim commands to
recreate the folds in the current window. Executing the string later
results in the folds getting recreated as they were before (so you can
use it to save the folds). You need to make sure that 'fdm' is either in
"manual" or "marker" mode to be able to execute the return value (though
lline is an int, you can pass in the string '$' as a shortcut to mean
the last line).
String FoldCreateFoldsStr(int fline, int lline)
- You can create your own match criteria and extend the functionality of
the plugin by using the b:fuSearchFn variable. If you set the name of
your search function with custom match criteria to this variable, before
calling the :FoldMatching or :FoldNonMatching commands, the plugin uses
the custom function instead of one of the standard search functions that
comes with the plugin. The prototype of the function is:
int Search(pattern, negate)
The function should behave very much like the built-in search()
function, ie., it should search for the next line matching the give
pattern (using your custom match criteria), position the cursor at the
matched line and return the line number. When the match fails, it
should return 0 and shouldn't change the cursor position
(see :help search()).
See one of the existing functions, s:SearchForPattern(),
s:PositionAtNextLine() and s:PositionAtNextHiGroup() for examples.
Summary Of Features:
Command Line:
FoldMatching (or FoldNonMatching), FoldShowLines, FoldShowMarks,
FoldShowHiGroup, FoldShowRange, FoldEndFolding
Functions:
FoldCreateFoldsStr
Settings:
g:foldutilDefContext, g:foldutilClearFolds, g:foldutilFoldText
Search_Key_Words: foldutil foldutils fold util folds Hari Krishna Dara |
|
install details |
Drop it in your plugin directory.
Requires Vim6.3
Requires multvals.vim (vimscript #171)
Requires genutils.vim (vimscript #197) |
|
script versions (upload new version)
Click on the package to download.
foldutil.vim |
3.0 |
2006-10-10 |
7.0 |
Hari Krishna Dara |
- No longer depends on multvals.
- Works with the new autoload version of genutils.
|
foldutil.vim |
2.0 |
2005-05-13 |
6.0 |
Hari Krishna Dara |
- Now you can pass separate begin and end patterns to specify the fold
blocks.
- FoldShowMatching has been renamed to FoldMatching.
- You can also invert the pattern easily by passing a *bang* to the
FoldMatching and other commands.
- There are now multiple ways to specify the match criteria
- Search pattern (existing): FoldMatching, FoldNonMatching
- Line numbers (existing): FoldShowLines
- Vim marks (new): FoldShowMarks
- Highlight group names (new): FoldShowHiGroup
- Easy way to create custom match criteria if the above doesn't suite
your needs. This provides a lot of extensibility.
- The logic has been rewritten for the ease of maintenance and
extensibility. The plugin also runs much faster now (makes difference
on huge log files).
There is a new dependency on the genutils.vim plugin.
|
foldutil.vim |
1.7 |
2004-10-28 |
6.0 |
Hari Krishna Dara |
- New FoldShowRange command to fold all lines except the selected range.
See doc for usage.
|
foldutil.vim |
1.6 |
2004-07-13 |
6.0 |
Hari Krishna Dara |
- Now requires Vim6.2
- Now requires multvals.vim
- The plugin now remembers "manual" folds and restores with :FoldEndFolding. Defines a useful global function FoldCreateFoldsStr() for this purpose.
- A new :FoldSetContext to conveniently change only the context of the current match.
- Also fixed an error with non-existing w:settStr. |
foldutil.vim |
1.5 |
2004-01-26 |
6.0 |
Hari Krishna Dara |
A very useful "-1" context is now supported. Thanks to John A. Peters for the idea. Read the description for details. |
foldutil.vim |
1.4 |
2003-06-18 |
6.0 |
Hari Krishna Dara |
Thanks to Tom Regner {tomte at tomsdiner dot org} for the enhancement to work even when foldmethod is not 'manual'. See description for a new command and more information.
|
foldutil.vim |
1.3 |
2003-06-11 |
6.0 |
Hari Krishna Dara |
Fixed a couple of bugs and added a new command ":FoldShowLines" to fold away all the lines that are not part of the comma separated list of lines specified on the command-line. See description for usage.
|
foldutil.vim |
1.1 |
2002-09-23 |
6.0 |
Hari Krishna Dara |
Fixed a couple of bugs reported by Gergely Kontra and better error messages (missing search pattern etc.) |
foldutil.vim |
1.0.0 |
2001-11-30 |
6.0 |
Hari Krishna Dara |
Initial upload |
ip used for rating: 18.97.14.83
|