RUBY					*ruby.vim* *ft-ruby-syntax*

There are a number of options to the Ruby syntax highlighting.

1. Ruby operators                     |ruby_operators|
2. Whitespace errors                  |ruby_space_errors|
3. Folds                              |ruby_fold|
4. Foldable groups                    |ruby_foldable_groups|
5. Reducing expensive operations      |ruby_no_expensive| |ruby_minlines|


1. Ruby operators				*ruby_operators*

Ruby operators can be highlighted.

This is enabled by defining "ruby_operators": >

	:let ruby_operators = 1
<

2. Whitespace errors				*ruby_space_errors*

Whitespace errors can be highlighted by defining "ruby_space_errors": >

	:let ruby_space_errors = 1
<

This will highlight trailing whitespace and tabs preceded by a space character
as errors.  This can be refined by defining "ruby_no_trail_space_error" and
"ruby_no_tab_space_error" which will ignore trailing whitespace and tabs after
spaces respectively.

3. Folds					*ruby_fold*

Folds can be enabled by defining "ruby_fold": >

	:let ruby_fold = 1
<

This will set the value |foldmethod| to "syntax" locally to the current buffer
or window, which will enable syntax-based folding when editing Ruby filetypes.

4. Foldable groups				*ruby_foldable_groups*

Default folding is rather detailed, i.e., small syntax units like "if", "do",
"%w[]" may create corresponding fold levels.

You can set "ruby_foldable_groups" to restrict which groups are foldable: >

        :let ruby_foldable_groups = 'if case %'
<
The value is a space-separated list of keywords:

    keyword       meaning ~
    --------  ------------------------------------- ~
    ALL        Most block syntax (default)
    NONE       Nothing
    if         "if" or "unless" block
    def        "def" block
    class      "class" block
    module     "module" block
    do         "do" block
    begin      "begin" block
    case       "case" block
    for        "for", "while", "until" loops
    {          Curly bracket block or hash literal
    [          Array literal
    %          Literal with "%" notation, e.g.: %w(STRING), %!STRING!
    /          Regexp
    string     String and shell command output (surrounded by ', ", `)
    :          Symbol
    #          Multiline comment
    <<         Here documents
    __END__    Source code after "__END__" directive

5. Reducing expensive operations		*ruby_no_expensive*

By default, the "end" keyword is colorized according to the opening statement
of the block it closes.  While useful, this feature can be expensive; if you
experience slow redrawing (or you are on a terminal with poor color support)
you may want to turn it off by defining the "ruby_no_expensive" variable: >

	:let ruby_no_expensive = 1
<
In this case the same color will be used for all control keywords.

						*ruby_minlines*

If you do want this feature enabled, but notice highlighting errors while
scrolling backwards, which are fixed when redrawing with CTRL-L, try setting
the "ruby_minlines" variable to a value larger than 50: >

	:let ruby_minlines = 100
<
Ideally, this value should be a number of lines large enough to embrace your
largest class or module.

6. Spellchecking strings			*ruby_spellcheck_strings*

Ruby syntax will perform spellchecking of strings if you define "ruby_spellcheck_strings": >

	:let ruby_spellcheck_strings = 1
<

 vim:tw=78:sw=4:ts=8:ft=help:norl:
