Migrate testing to tcltest + expect

Refactor pairs handling
Rewrite s:keys4right()
2025-12-08 05:34:45 +08:00 · 2017-04-12 15:58:49 -04:00 · 2017-04-01 18:14:12 -04:00 · 2017-03-20 22:49:37 -04:00 · 2017-03-15 03:11:38 -04:00 · 2017-02-21 22:11:52 -05:00
21 changed files with 1785 additions and 2310 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -1,8 +1,12 @@
 *.sw?
 *.un?
 *.vba
 *.vmb
 *.zip
 *.gz
 vimball.txt
 *.orig
 tags
 test/build
 test/*.tap
 test/*.msgout
--- a/LICENSE.txt
+++ b/LICENSE.txt
@@ -0,0 +1,21 @@
 MIT License
 Copyright (c) 2017 Israel Chauca
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
 in the Software without restriction, including without limitation the rights
 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 copies of the Software, and to permit persons to whom the Software is
 furnished to do so, subject to the following conditions:
 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
--- a/67
+++ b/67
@@ -1,62 +1,15 @@
-PLUGIN=$(shell basename "$$PWD")
+.DEFAULT: test
 SCRIPT=$(wildcard plugin/*.vim)
 #AUTOL=$(wildcard autoload/*.vim)
 AUTOL=autoload/$(PLUGIN).vim
 DOC=$(wildcard doc/*.txt)
 TESTS=$(wildcard autoload/*Tests.vim)
 VERSION=$(shell perl -ne 'if (/\*\sCurrent\srelease:/) {s/^\s+(\d+\.\S+)\s.*$$/\1/;print}' $(DOC))
 VIMFOLDER=~/.vim/
 VIM=/usr/bin/vim
-.PHONY: $(PLUGIN).vba README
+test_files := $(wildcard test/*.test)
 short_targets := $(patsubst test/%,%,$(test_files))
-all: vimball README zip gzip
+.PHONY: monitor test $(test_files) $(short_targets)
-vimball: $(PLUGIN).vba
+test:
 	$(MAKE) -C test
-clean:
+monitor:
-	@echo clean
+	$(MAKE) -C test monitor
 	rm -f *.vba */*.orig *.~* .VimballRecord *.zip *.gz
-dist-clean: clean
+$(test_files) $(short_targets):
-
+	$(MAKE) -C test $(patsubst test/%,%,$@)
 undo:
 	for i in */*.orig; do mv -f "$$i" "$${i%.*}"; done
 README:
 	@echo README
 	cp -f $(DOC) README
 $(PLUGIN).vba:
 	@echo $(PLUGIN).vba
 	rm -f $(PLUGIN)-$(VERSION).vba
 	$(VIM) -N -c 'ru! vimballPlugin.vim' -c ':call append("0", [ "$(SCRIPT)", "$(AUTOL)", "$(DOC)"])' -c '$$d' -c ":%MkVimball $(PLUGIN)-$(VERSION)  ." -c':q!'
 	ln -f $(PLUGIN)-$(VERSION).vba $(PLUGIN).vba
 zip:
 	@echo zip
 	rm -f *.zip
 	zip -r $(PLUGIN).zip doc plugin autoload
 	zip $(PLUGIN).zip -d \*.sw\? || echo 1
 	zip $(PLUGIN).zip -d \*.un\? || echo 1
 	zip $(PLUGIN).zip -d \*.orig || echo 1
 	zip $(PLUGIN).zip -d \*tags  || echo 1
 	zip $(PLUGIN).zip -d $(TESTS)
 	ln -f $(PLUGIN).zip $(PLUGIN)-$(VERSION).zip
 gzip: vimball
 	@echo vimball
 	gzip -f $(PLUGIN).vba
 release: version all
 version:
 	@echo version: $(VERSION)
 	perl -i.orig -pne 'if (/^"\sVersion:/) {s/(\d+\.\S+)/$(VERSION)/}' $(SCRIPT) $(AUTOL)
 	perl -i.orig -pne 'if (/let\sdelimitMate_version/) {s/"(\d+\.\S+)"/"$(VERSION)"/}' $(SCRIPT)
 	perl -i.orig -pne 'if (/beasts/) {s/(v\d+\.\S+)/v$(VERSION)/}' $(DOC)
 	perl -i.orig -MPOSIX -pne 'if (/^"\sModified:/) {$$now_string = strftime "%F", localtime; s/(\d+-\d+-\d+)/$$now_string/e}' $(SCRIPT) $(AUTOL)
 	perl -i.orig -MPOSIX -pne 'if (/^\s+$(VERSION)\s+\d+-\d+-\d+\s+\*/) {$$now_string = strftime "%F", localtime; s/(\d+-\d+-\d+)/$$now_string/}' $(DOC)
 	@echo Version: $(VERSION)
 echo:
--- a/746
+++ b/746
@@ -1,746 +0,0 @@
 *delimitMate*    Trying to keep those beasts at bay! v2.4.1  *delimitMate.txt*
  MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
  MMMM  MMMMMMMMM  MMMMMMMMMMMMMMMMMMMMMMMMMM  MMMMM  MMMMMMMMMMMMMMMMMMMMM  ~
  MMMM  MMMMMMMMM  MMMMMMMMMMMMMMMMMMMMMMMMMM   MMM   MMMMMMMMMMMMMMMMMMMMM
  MMMM  MMMMMMMMM  MMMMMMMMMMMMMMMMMMMMM  MMM  M   M  MMMMMMMMMM  MMMMMMMMM  ~
  MMMM  MMM   MMM  MM  MM  M  M MMM  MM    MM  MM MM  MMM   MMM    MMM   MM
  MM    MM  M  MM  MMMMMM        MMMMMMM  MMM  MMMMM  MM  M  MMM  MMM  M  M  ~
  M  M  MM     MM  MM  MM  M  M  MM  MMM  MMM  MMMMM  MMMMM  MMM  MMM     M
  M  M  MM  MMMMM  MM  MM  M  M  MM  MMM  MMM  MMMMM  MMM    MMM  MMM  MMMM  ~
  M  M  MM  M  MM  MM  MM  M  M  MM  MMM  MMM  MMMMM  MM  M  MMM  MMM  M  M
  MM    MMM   MMM  MM  MM  M  M  MM  MMM   MM  MMMMM  MMM    MMM   MMM   MM  ~
  MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
 ==============================================================================
 0.- CONTENTS                                           *delimitMate-contents*
    1. Introduction____________________________|delimitMateIntro|
    2. Functionality___________________________|delimitMateFunctionality|
        2.1 Automatic closing & exiting________|delimitMateAutoClose|
        2.2 Expansion of space and CR__________|delimitMateExpansion|
        2.3 Backspace__________________________|delimitMateBackspace|
        2.4 Visual wrapping____________________|delimitMateVisualWrapping|
        2.5 Smart Quotes_______________________|delimitMateSmartQuotes|
        2.6 Balancing matching pairs___________|delimitMateBalance|
        2.7 FileType based configuration_______|delimitMateFileType|
        2.8 Syntax awareness___________________|delimitMateSyntax|
    3. Customization___________________________|delimitMateOptions|
        3.1 Options summary____________________|delimitMateOptionSummary|
        3.2 Options details____________________|delimitMateOptionDetails|
    4. Commands________________________________|delimitMateCommands|
    5. Functions_______________________________|delimitMateFunctions|
    6. TODO list_______________________________|delimitMateTodo|
    7. Maintainer______________________________|delimitMateMaintainer|
    8. Credits_________________________________|delimitMateCredits|
    9. History_________________________________|delimitMateHistory|
 ==============================================================================
 1.- INTRODUCTION                                           *delimitMateIntro*
 This plug-in provides automatic closing of quotes, parenthesis, brackets,
 etc.; besides some other related features that should make your time in insert
 mode a little bit easier.
 Most of the features can be modified or disabled permanently, using global
 variables, or on a FileType basis, using autocommands. With a couple of
 exceptions and limitations, this features don't brake undo, redo or history.
 ==============================================================================
 2. FUNCTIONALITY                                   *delimitMateFunctionality*
 ------------------------------------------------------------------------------
   2.1 AUTOMATIC CLOSING AND EXITING                    *delimitMateAutoClose*
 With automatic closing enabled, if an opening delimiter is inserted the plugin
 inserts the closing delimiter and places the cursor between the pair. With
 automatic closing disabled, no closing delimiters is inserted by delimitMate,
 but when a pair of delimiters is typed, the cursor is placed in the middle.
 When the cursor is inside an empty pair or located next to the left of a
 closing delimiter, the cursor is placed outside the pair to the right of the
 closing delimiter.
 Unless |'delimitMate_matchpairs'| or |'delimitMate_quotes'|are set, this
 script uses the values in '&matchpairs' to identify the pairs, and ", ' and `
 for quotes respectively.
 The following table shows the behaviour, this applies to quotes too (the final
 position of the cursor is represented by a "|"):
 With auto-close: >
                          Type   |  You get
                        ====================
                           (     |    (|)
                        –––––––––|––––––––––
                           ()    |    ()|
                        –––––––––|––––––––––
                        (<S-Tab> |    ()|
 <
 Without auto-close: >
                          Type    |  You get
                        =====================
                           ()     |    (|)
                        –––––––––-|––––––––––
                           ())    |    ()|
                        –––––––––-|––––––––––
                        ()<S-Tab> |    ()|
 <
 NOTE: Abbreviations will not be expanded by delimiters used on delimitMate,
 you should use <C-]> (read |i_CTRL-]|) to expand them on the go.
 ------------------------------------------------------------------------------
   2.2 EXPANSION OF SPACE AND CAR RETURN                *delimitMateExpansion*
 When the cursor is inside an empty pair of delimiters, <Space> and <CR> can be
 expanded, see |'delimitMate_expand_space'| and
 |'delimitMate_expand_cr'|:
 Expand <Space> to: >
                    <Space><Space><Left>  |  You get
                  ====================================
                              (|)         |    ( | )
 <
 Expand <CR> to: >
                      <CR><CR><Up>  |  You get
                    ============================
                           (|)      |    (
                                    |    |
                                    |    )
 <
 NOTE that the expansion of <CR> will brake the redo command.
 Since <Space> and <CR> are used everywhere, I have made the functions involved
 in expansions global, so they can be used to make custom mappings. Read
 |delimitMateFunctions| for more details.
 ------------------------------------------------------------------------------
   2.3 BACKSPACE                                        *delimitMateBackspace*
 If you press backspace inside an empty pair, both delimiters are deleted. When
 expansions are enabled, <BS> will also delete the expansions. NOTE that
 deleting <CR> expansions will brake the redo command.
 If you type <S-BS> (shift + backspace) instead, only the closing delimiter
 will be deleted. NOTE that this will not usually work when using Vim from the
 terminal, see 'delimitMate#JumpAny()' below to see how to fix it.
 e.g. typing at the "|": >
                  What  |      Before       |      After
               ==============================================
                  <BS>  |  call expand(|)   |  call expand|
               ---------|-------------------|-----------------
                  <BS>  |  call expand( | ) |  call expand(|)
               ---------|-------------------|-----------------
                  <BS>  |  call expand(     |  call expand(|)
                        |  |                |
                        |  )                |
               ---------|-------------------|-----------------
                 <S-BS> |  call expand(|)   |  call expand(|
 <
 ------------------------------------------------------------------------------
   2.4 WRAPPING OF VISUAL SELECTION                *delimitMateVisualWrapping*
 When visual mode is active this script allows for the selection to be enclosed
 with delimiters. But, since brackets have special meaning in visual mode, a
 leader (the value of 'mapleader' by default) should precede the delimiter.
 NOTE that this feature brakes the redo command and doesn't currently work well
 on blockwise visual mode when the selection has lines one character smaller
 than the rest, any suggestions to fix this will be very welcome.
 e.g. (selection represented between square brackets): >
                      Selected text    |       After \"
                 =============================================
                  An [absurd] example! | An "absurd" example!
 <
 ------------------------------------------------------------------------------
   2.5 SMART QUOTES                                   *delimitMateSmartQuotes*
 Only one quote will be inserted following a quote, a "\" or, following or
 preceding an alphanumeric character. This should cover closing quotes after a
 string, opening quotes before a string, escaped quotes and apostrophes. Except
 for apostrophes, this feature can be disabled setting the option
 |'delimitMate_smart_quotes'| to 0.
 e.g. typing at the "|": >
                     What |    Before    |     After
                  =======================================
                      "   |  "String|    |  "String"|
                      "   |  let i = "|  |  let i = "|"
                      '   |  I|          |  I'|
 <
 ------------------------------------------------------------------------------
   2.6 BALANCING MATCHING PAIRS                           *delimitMateBalance*
 When inserting an opening paren and |'delimitMate_balance_matchpairs'| is
 enabled, delimitMate will try to balance the closing pairs in the current
 line.
 e.g. typing at the "|": >
                     What |    Before    |     After
                  =======================================
                      (   |      |)      |     (|)
                      (   |      |       |     (|)
                      (   |     (|)      |    ((|))
 <
 ------------------------------------------------------------------------------
   2.7 FILE TYPE BASED CONFIGURATION                     *delimitMateFileType*
 delimitMate options can be set globally for all buffers using global
 ("regular") variables in your |vimrc| file. But |:autocmd| can be used to set
 options for specific file types (see |'filetype'|) using buffer variables in
 the following way: >
   au FileType mail,text let b:delimitMate_autoclose = 0
         ^       ^           ^            ^            ^
         |       |           |            |            |
         |       |           |            |            - Option value.
         |       |           |            - Option name.
         |       |           - Buffer variable.
         |       - File types for which the option will be set.
         - Don't forget to put this event.
 <
 NOTE that you should use buffer variables (|b:var|) only to set options with
 |:autocmd|, for global options use regular variables (|g:var|) in your vimrc.
 ------------------------------------------------------------------------------
   2.8 SYNTAX AWARENESS                                    *delimitMateSyntax*
 The features of this plug-in might not be always helpful, comments and strings
 usualy don't need auto-completion. delimitMate monitors which region is being
 edited and if it detects that the cursor is in a comment it'll turn itself off
 until the cursor leaves the comment. The excluded regions can be set using the
 option |'delimitMate_excluded_regions'|. Read |group-name| for a list of
 regions or syntax group names.
 NOTE that this feature relies on a proper syntax file for the current file
 type, if the appropiate syntax file doesn't define a region, delimitMate won't
 know about it.
 ==============================================================================
 3. CUSTOMIZATION                                         *delimitMateOptions*
 You can create your own mappings for some features using the global functions.
 Read |DelimitMateFunctions| for more info.
 ------------------------------------------------------------------------------
   3.1 OPTIONS SUMMARY                              *delimitMateOptionSummary*
 The behaviour of this script can be customized setting the following options
 in your vimrc file. You can use local options to set the configuration for
 specific file types, see |delimitMateOptionDetails| for examples.
 |'loaded_delimitMate'|            Turns off the script.
 |'delimitMate_autoclose'|         Tells delimitMate whether to automagically
                                insert the closing delimiter.
 |'delimitMate_matchpairs'|        Tells delimitMate which characters are
                                matching pairs.
 |'delimitMate_quotes'|            Tells delimitMate which quotes should be
                                used.
 |'delimitMate_nesting_quotes'|    Tells delimitMate which quotes should be
                                allowed to be nested.
 |'delimitMate_visual_leader'|     Sets the leader to be used in visual mode.
 |'delimitMate_expand_cr'|         Turns on/off the expansion of <CR>.
 |'delimitMate_expand_space'|      Turns on/off the expansion of <Space>.
 |'delimitMate_smart_quotes'|      Turns on/off the "smart quotes" feature.
 |'delimitMate_balance_matchpairs'|Turns on/off the "balance matching pairs"
                                feature.
 |'delimitMate_excluded_regions'|  Turns off the script for the given regions or
                                syntax group names.
 |'delimitMate_excluded_ft'|       Turns off the script for the given file types.
 |'delimitMate_apostrophes'|       Tells delimitMate how it should "fix"
                                balancing of single quotes when used as
                                apostrophes. NOTE: Not needed any more, kept
                                for compatibility with older versions.
 ------------------------------------------------------------------------------
   3.2 OPTIONS DETAILS                              *delimitMateOptionDetails*
 Add the shown lines to your vimrc file in order to set the below options.
 Buffer variables take precedence over global ones and can be used along with
 autocmd to modify delimitMate's behavior for specific file types, read more in
 |delimitMateFileType|.
 Note: Use buffer variables only to set options for specific file types using
 :autocmd, use global variables to set options for every buffer. Read more in
 |g:var| and |b:var|.
 ------------------------------------------------------------------------------
                                                        *'loaded_delimitMate'*
                                                      *'b:loaded_delimitMate'*
 This option prevents delimitMate from loading.
 e.g.: >
        let loaded_delimitMate = 1
        au FileType mail let b:loaded_delimitMate = 1
 <
 ------------------------------------------------------------------------------
                                                     *'delimitMate_autoclose'*
                                                   *'b:delimitMate_autoclose'*
 Values: 0 or 1.                                                              ~
 Default: 1                                                                   ~
 If this option is set to 0, delimitMate will not add a closing delimiter
 automagically. See |delimitMateAutoClose| for details.
 e.g.: >
        let delimitMate_autoclose = 0
        au FileType mail let b:delimitMate_autoclose = 0
 <
 ------------------------------------------------------------------------------
                                                    *'delimitMate_matchpairs'*
                                                  *'b:delimitMate_matchpairs'*
 Values: A string with |'matchpairs'| syntax.                                 ~
 Default: &matchpairs                                                         ~
 Use this option to tell delimitMate which characters should be considered
 matching pairs. Read |delimitMateAutoClose| for details.
 e.g: >
        let delimitMate_matchpairs = "(:),[:],{:},<:>"
        au FileType vim,html let b:delimitMate_matchpairs = "(:),[:],{:},<:>"
 <
 ------------------------------------------------------------------------------
                                                        *'delimitMate_quotes'*
                                                      *'b:delimitMate_quotes'*
 Values: A string of characters separated by spaces.                          ~
 Default: "\" ' `"                                                            ~
 Use this option to tell delimitMate which characters should be considered as
 quotes. Read |delimitMateAutoClose| for details.
 e.g.: >
        let delimitMate_quotes = "\" ' ` *"
        au FileType html let b:delimitMate_quotes = "\" '"
 <
 ------------------------------------------------------------------------------
                                                *'delimitMate_nesting_quotes'*
                                              *'b:delimitMate_nesting_quotes'*
 Values: A list of quotes.                                                    ~
 Default: []                                                                  ~
 Quotes listed here will not be able to jump out of the empty pair, thus
 allowing the autoclosed quotes to be nested.
 e.g.: >
        let delimitMate_nesting_quotes = ['"','`']
        au FileType python let b:delimitMate_nesting_quotes = ['"']
 <
 ------------------------------------------------------------------------------
                                                 *'delimitMate_visual_leader'*
                                               *'b:delimitMate_visual_leader'*
 Values: Any character.                                                       ~
 Default: q                                                                   ~
 The value of this option will be used to wrap the selection in visual mode
 when followed by a delimiter. Read |delimitMateVisualWrap| for details.
 e.g: >
        let delimitMate_visual_leader = "f"
        au FileType html let b:delimitMate_visual_leader = "f"
 <
 ------------------------------------------------------------------------------
                                                     *'delimitMate_expand_cr'*
                                                   *'b:delimitMate_expand_cr'*
 Values: 1 or 0                                                               ~
 Default: 0                                                                   ~
 This option turns on/off the expansion of <CR>. Read |delimitMateExpansion|
 for details.
 e.g.: >
        let delimitMate_expand_cr = 1
        au FileType mail let b:delimitMate_expand_cr = 1
 <
 ------------------------------------------------------------------------------
                                                  *'delimitMate_expand_space'*
                                                *'b:delimitMate_expand_space'*
 Values: 1 or 0                                                               ~
 Default: 0                                                                   ~
 This option turns on/off the expansion of <Space>. Read |delimitMateExpansion|
 for details.
 e.g.: >
        let delimitMate_expand_space = 1
        au FileType tcl let b:delimitMate_expand_space = 1
 <
 ------------------------------------------------------------------------------
                                                  *'delimitMate_smart_quotes'*
                                                *'b:delimitMate_smart_quotes'*
 Values: 1 or 0                                                               ~
 Default: 1                                                                   ~
 This option turns on/off the smart quotes feature. Read
 |delimitMateSmartQuotes| for details.
 e.g.: >
        let delimitMate_smart_quotes = 0
        au FileType tcl let b:delimitMate_smart_quotes = 0
 <
 ------------------------------------------------------------------------------
                                            *'delimitMate_balance_matchpairs'*
                                          *'b:delimitMate_balance_matchpairs'*
 Values: 1 or 0                                                               ~
 Default: 0                                                                   ~
 This option turns on/off the balancing of matching pairs. Read
 |delimitMateBalance| for details.
 e.g.: >
        let delimitMate_balance_matchpairs = 1
        au FileType tcl let b:delimitMate_balance_matchpairs = 1
 <
 ------------------------------------------------------------------------------
                                              *'delimitMate_excluded_regions'*
 Values: A string of syntax group names names separated by single commas.     ~
 Default: Comment                                                             ~
 This options turns delimitMate off for the listed regions, read |group-name|
 for more info about what is a region.
 e.g.: >
        let delimitMate_excluded_regions = "Comments,String"
 <
 ------------------------------------------------------------------------------
                                                   *'delimitMate_excluded_ft'*
 Values: A string of file type names separated by single commas.              ~
 Default: Empty.                                                              ~
 This options turns delimitMate off for the listed file types, use this option
 only if you don't want any of the features it provides on those file types.
 e.g.: >
        let delimitMate_excluded_ft = "mail,txt"
 <
 ------------------------------------------------------------------------------
                                                   *'delimitMate_apostrophes'*
 Values: Strings separated by ":".                                            ~
 Default: No longer used.                                                     ~
 NOTE: This feature is turned off by default, it's been kept for compatibility
 with older version, read |delimitMateSmartQuotes| for details.
 If auto-close is enabled, this option tells delimitMate how to try to fix the
 balancing of single quotes when used as apostrophes. The values of this option
 are strings of text where a single quote would be used as an apostrophe (e.g.:
 the "n't" of wouldn't or can't) separated by ":". Set it to an empty string to
 disable this feature.
 e.g.: >
        let delimitMate_apostrophes = ""
        au FileType tcl let delimitMate_apostrophes = ""
 <
 ==============================================================================
 4. COMMANDS                                             *delimitMateCommands*
 ------------------------------------------------------------------------------
 :DelimitMateReload                                        *:DelimitMateReload*
 Re-sets all the mappings used for this script, use it if any option has been
 changed or if the filetype option hasn't been set yet.
 ------------------------------------------------------------------------------
 :DelimitMateSwitch                                        *:DelimitMateSwitch*
 Switches the plug-in on and off.
 ------------------------------------------------------------------------------
 :DelimitMateTest                                            *:DelimitMateTest*
 This command tests every mapping set-up for this script, useful for testing
 custom configurations.
 The following output corresponds to the default values, it will be different
 depending on your configuration. "Open & close:" represents the final result
 when the closing delimiter has been inserted, either manually or
 automatically, see |delimitMateExpansion|. "Delete:" typing backspace in an
 empty pair, see |delimitMateBackspace|. "Exit:" typing a closing delimiter
 inside a pair of delimiters, see |delimitMateAutoclose|. "Space:" the
 expansion, if any, of space, see |delimitMateExpansion|. "Visual-L",
 "Visual-R" and "Visual" shows visual wrapping, see
 |delimitMateVisualWrapping|. "Car return:" the expansion of car return, see
 |delimitMateExpansion|. The cursor's position at the end of every test is
 represented by an "|": >
            * AUTOCLOSE:
            Open & close: (|)
            Delete: |
            Exit: ()|
            Space: ( |)
            Visual-L: (v)
            Visual-R: (v)
            Car return: (
            |)
            Open & close: {|}
            Delete: |
            Exit: {}|
            Space: { |}
            Visual-L: {v}
            Visual-R: {v}
            Car return: {
            |}
            Open & close: [|]
            Delete: |
            Exit: []|
            Space: [ |]
            Visual-L: [v]
            Visual-R: [v]
            Car return: [
            |]
            Open & close: "|"
            Delete: |
            Exit: ""|
            Space: " |"
            Visual: "v"
            Car return: "
            |"
            Open & close: '|'
            Delete: |
            Exit: ''|
            Space: ' |'
            Visual: 'v'
            Car return: '
            |'
            Open & close: `|`
            Delete: |
            Exit: ``|
            Space: ` |`
            Visual: `v`
            Car return: `
            |`
 <
 ==============================================================================
 5. FUNCTIONS                                           *delimitMateFunctions*
 Functions should be used enclosed between <C-R>= and <CR>, otherwise they
 might not work as expected or at all.
 ------------------------------------------------------------------------------
 delimitMate#WithinEmptyPair()                  *delimitMate_WithinEmptyPair()*
 Returns 1 if the cursor is inside an empty pair, 0 otherwise.
 e.g.: >
    inoremap <expr> <CR> delimitMate#WithinEmptyPair() ?
             \ "\<C-R>=delimitMate#ExpandReturn()\<CR>" :
             \ "external_mapping"
 <
 ------------------------------------------------------------------------------
 delimitMate#ExpandReturn()                        *delimitMate#ExpandReturn()*
 Returns the expansion for <CR> if enabled and inside an empty pair, returns
 <CR> otherwise.
 e.g.: This mapping could be used to select an item on a pop-up menu or expand
 <CR> inside an empty pair: >
        inoremap <expr> <CR> pumvisible() ?
                 \"\<c-y>" :
                 \ "\<C-R>=delimitMate#ExpandReturn()\<CR>"
 <
 ------------------------------------------------------------------------------
 delimitMate#ExpandSpace()                          *delimitMate#ExpandSpace()*
 Returns the expansion for <Space> if enabled and inside an empty pair, returns
 <Space> otherwise.
 e.g.: >
    inoremap <Space> <C-R>=delimitMate#ExpandSpace()<CR>
 <
 ------------------------------------------------------------------------------
 delimitMate#ShouldJump()                            *delimitMate#ShouldJump()*
 Returns 1 if there is a closing delimiter or a quote to the right of the
 cursor, 0 otherwise.
 ------------------------------------------------------------------------------
 delimitMate#JumpAny(key)                               *delimitMate#JumpAny()*
 This function returns a mapping that will make the cursor jump to the right
 when delimitMate#ShouldJump() returns 1, returns the argument "key" otherwise.
 e.g.: You can use this to create your own mapping to jump over any delimiter.
 >
   inoremap <C-Tab> <C-R>=delimitMate#JumpAny("\<C-Tab>")<CR>
 <
 ==============================================================================
 6. TODO LIST                                                *delimitMateTodo*
 - Automatic set-up by file type.
 - Make block-wise visual wrapping work on un-even regions.
 ==============================================================================
 7. MAINTAINER                                         *delimitMateMaintainer*
 Hi there! My name is Israel Chauca F. and I can be reached at:
    mailto:israelchauca@gmail.com
 Feel free to send me any suggestions and/or comments about this plugin, I'll
 be very pleased to read them.
 ==============================================================================
 8. CREDITS                                               *delimitMateCredits*
 Some of the code that make this script is modified or just shamelessly copied
 from the following sources:
   - Ian McCracken
     Post titled: Vim, Part II: Matching Pairs:
     http://concisionandconcinnity.blogspot.com/
   - Aristotle Pagaltzis
     From the comments on the previous blog post and from:
     http://gist.github.com/144619
   - Karl Guertin
     AutoClose:
     http://www.vim.org/scripts/script.php?script_id=1849
   - Thiago Alves
     AutoClose:
     http://www.vim.org/scripts/script.php?script_id=2009
   - Edoardo Vacchi
     ClosePairs:
     http://www.vim.org/scripts/script.php?script_id=2373
 This script was inspired by the auto-completion of delimiters on TextMate.
 ==============================================================================
 9. HISTORY                                               *delimitMateHistory*
  Version      Date      Release notes                                       ~
 |---------|------------|-----------------------------------------------------|
    2.4.1   2010-07-31 * Current release:
                         - Fix problem with <Home> and <End>.
                         - Add missing doc on |'delimitMate_smart_quotes'|,
                           |delimitMateBalance| and
                           |'delimitMate_balance_matchpairs'|.
 |---------|------------|-----------------------------------------------------|
    2.4     2010-07-29 * - Unbalanced parens: see :help delimitMateBalance.
                         - Visual wrapping now works on block-wise visual
                           with some limitations.
                         - Arrow keys didn't work on terminal.
                         - Added option to allow nested quotes.
                         - Expand Smart Quotes to look for a string on the
                           right of the cursor.
 |---------|------------|-----------------------------------------------------|
    2.3.1   2010-06-06 * - Fix: an extra <Space> is inserted after <Space>
                           expansion.
 |---------|------------|-----------------------------------------------------|
    2.3     2010-06-06 * - Syntax aware: Will turn off when editing comments
                           or other regions, customizable.
                         - Changed format of most mappings.
                         - Fix: <CR> expansion doesn't brake automatic
                           indentation adjustments anymore.
                         - Fix: Arrow keys would insert A, B, C or D instead
                           of moving the cursor when using Vim on a terminal.
 |---------|------------|-----------------------------------------------------|
    2.2     2010-05-16 * - Added command to switch the plug-in on and off.
                         - Fix: some problems with <Left>, <Right> and <CR>.
                         - Fix: A small problem when inserting a delimiter at
                           the beginning of the line.
 |---------|------------|-----------------------------------------------------|
    2.1     2010-05-10 * - Most of the functions have been moved to an
                           autoload script to avoid loading unnecessary ones.
                         - Fixed a problem with the redo command.
                         - Many small fixes.
 |---------|------------|-----------------------------------------------------|
    2.0     2010-04-01 * New features:
                         - All features are redo/undo-wise safe.
                         - A single quote typed after an alphanumeric
                           character is considered an apostrophe and one
                           single quote is inserted.
                         - A quote typed after another quote inserts a single
                           quote and the cursor jumps to the middle.
                         - <S-Tab> jumps out of any empty pair.
                         - <CR> and <Space> expansions are fixed, but the
                           functions used for it are global and can be used in
                           custom mappings. The previous system is still
                           active if you have any of the expansion options
                           set.
                         - <S-Backspace> deletes the closing delimiter.
                         * Fixed bug:
                         - s:vars were being used to store buffer options.
 |---------|------------|-----------------------------------------------------|
    1.6     2009-10-10 * Now delimitMate tries to fix the balancing of single
                         quotes when used as apostrophes. You can read
                         |delimitMate_apostrophes| for details.
                         Fixed an error when |b:delimitMate_expand_space|
                         wasn't set but |delimitMate_expand_space| wasn't.
 |---------|------------|-----------------------------------------------------|
    1.5     2009-10-05 * Fix: delimitMate should work correctly for files
                         passed as arguments to Vim. Thanks to Ben Beuchler
                         for helping to nail this bug.
 |---------|------------|-----------------------------------------------------|
    1.4     2009-09-27 * Fix: delimitMate is now enabled on new buffers even
                         if they don't have set the file type option or were
                         opened directly from the terminal.
 |---------|------------|-----------------------------------------------------|
    1.3     2009-09-24 * Now local options can be used along with autocmd
                         for specific file type configurations.
                         Fixes:
                         - Unnamed register content is not lost on visual
                         mode.
                         - Use noremap where appropiate.
                         - Wrapping a single empty line works as expected.
 |---------|------------|-----------------------------------------------------|
    1.2     2009-09-07 * Fixes:
                         - When inside nested empty pairs, deleting the
                         innermost left delimiter would delete all right
                         contiguous delimiters.
                         - When inside an empty pair, inserting a left
                         delimiter wouldn't insert the right one, instead
                         the cursor would jump to the right.
                         - New buffer inside the current window wouldn't
                         have the mappings set.
 |---------|------------|-----------------------------------------------------|
    1.1     2009-08-25 * Fixed an error that ocurred when mapleader wasn't
                         set and added support for GetLatestScripts
                         auto-detection.
 |---------|------------|-----------------------------------------------------|
    1.0     2009-08-23 * Initial upload.
 |---------|------------|-----------------------------------------------------|
  `\|||/´         MMM           \|/            www            __^__          ~
   (o o)         (o o)          @ @           (O-O)          /(o o)\\        ~
 ooO_(_)_Ooo__ ooO_(_)_Ooo___oOO_(_)_OOo___oOO__(_)__OOo___oOO__(_)__OOo_____ ~
 _____|_____|_____|_____|_____|_____|_____|_____|_____|_____|_____|_____|____ ~
 __|_____|_____|_____|_____|_____|_____|_____|_____|_____|_____|_____|_____|_ ~
 _____|_____|_____|_____|_____|_____|_____|_____|_____|_____|_____|_____|____ ~
 vim:tw=78:et:ts=2:sw=2:ft=help:norl:formatoptions+=tcroqn:autoindent:
--- a/README.md
+++ b/README.md
@@ -0,0 +1,6 @@
 This plug-in provides automatic closing of quotes, parenthesis, brackets, etc., besides some other related features that
 should make your time in insert mode a little bit easier, like syntax awareness (will not insert the closing delimiter
 in comments and other configurable regions), <CR> and <Space> expansions (off by default), and some more.
 Most of the features can be modified or disabled permanently, using global variables, or on a FileType basis, using
 :autocmd.
--- a/autoload/delimitMate.vim
+++ b/autoload/delimitMate.vim
--- a/autoload/delimitMateTests.vim
+++ b/autoload/delimitMateTests.vim
@@ -1,281 +0,0 @@
 function! delimitMateTests#Main()
 	if !exists("g:delimitMate_testing")
 		echoerr "delimitMateTests#Main(): If you really want to use me, you must set delimitMate_testing to any value."
 		return
 	elseif g:delimitMate_testing == "fork"
 		!gvim -N -u NONE -U NONE -c "set backspace=eol,start" -c "set background=light" -c "syntax on" -c "let delimitMate_testing = 1" -c "so autoload/delimitMate.vim" -c "so autoload/delimitMateTests.vim" -c "so plugin/delimitMate.vim" -c "call delimitMateTests\#Main()"
 		return ""
 	endif
 	nmap <F1> :qall!<CR>
 	let nomore = &more
 	set nomore
 	let b:test_results = {}
 	let b:errors = 0
 	let b:corrects = 0
 	let b:ignores = 0
 	function! SetOptions(list) " {{{
 		let b:delimitMate_autoclose = 1
 		let b:delimitMate_matchpairs = &matchpairs
 		let b:delimitMate_quotes = "\" ' `"
 		let b:delimitMate_excluded_regions = "Comment"
 		silent! unlet b:delimitMate_visual_leader
 		let b:delimitMate_expand_space = 0
 		let b:delimitMate_expand_cr = 0
 		let b:delimitMate_smart_quotes = 1
 		let b:delimitMate_apostrophes = ""
 		let b:delimitMate_tab2exit = 1
 		" Set current test options:
 		for str in a:list
 			let pair = split(str, ':')
 			exec "let b:delimitMate_" . pair[0] . " = " . pair[1]
 		endfor
 		DelimitMateReload
 	endfunction " }}}
 	function! Type(name, input, output, options, ...) " {{{
 		if a:0 > 0
 			let ignore = a:1
 		else
 			let ignore = 0
 		endif
 		if a:input != "\<Esc>."
 			" Set default options:
 			call SetOptions(a:options)
 			let CapR = ""
 			normal ggVG"_d
 			exec "normal i" . a:input . "|\<Esc>"
 		else
 			let CapR = "_R"
 			normal gg.
 		endif
 		exec "normal \<Esc>"
 		call setpos('.', [0, 1, 1, 0])
 		let result = len(a:output) != line('$')
 		for line in a:output
 			if getline('.') != line || result == 1
 				let result = 1
 				break
 			endif
 			call setpos('.', [0, line('.') + 1, 1, 0])
 		endfor
 		let text = getline('.')
 		let i = 2
 		while i <= line('$')
 			let text = text . "<cr>" . getline(i)
 			let i += 1
 		endwhile
 		if ignore == 1
 			let label = "Ignored"
 			let result = "?="
 			let b:ignores += 1
 		elseif result == 0
 			let label = "Passed"
 			let result = "=="
 			let b:corrects += 1
 		else
 			let label = "Failed"
 			let result = "!="
 			let b:errors += 1
 		endif
 		exec "let b:test_results['" .
 					\ substitute(a:name, "[^a-zA-Z0-9_]", "_", "g") . CapR . "'] = '" .
 					\ label . ": ' . a:input . ' => ' . text . ' " .
 					\ result . " ' . join(a:output, '<cr>')"
 	endfunction " }}}
 	function! RepeatLast(name, output, ...) " {{{
 		if a:0 > 0
 			let arg1 = a:1
 		else
 			let arg1 = ''
 		endif
 		call Type(a:name, "\<Esc>.", a:output, [], arg1)
 	endfunction " }}}
 	" Test's test {{{
 	call Type("Test 1", "123", ["123|"], [])
 	call RepeatLast("Test 1", ["123|123|"])
 	" Auto-closing parens
 	call Type("Autoclose parens", "(", ["(|)"], [])
 	call RepeatLast("Autoclose_parens", ["(|)(|)"])
 	" Auto-closing quotes
 	call Type("Autoclose quotes", '"', ['"|"'], [])
 	call RepeatLast("Autoclose_quotes", ['"|""|"'])
 	" Deleting parens
 	call Type("Delete empty parens", "(\<BS>", ["|"], [])
 	call RepeatLast("Delete empty parens", ["||"])
 	" Deleting quotes
 	call Type("Delete emtpy quotes", "\"\<BS>", ['|'], [])
 	call RepeatLast("Delete empty quotes", ["||"])
 	" Manual closing parens
 	call Type("Manual closing parens", "()", ["(|)"], ["autoclose:0"])
 	call RepeatLast("Manual closing parens", ["(|)(|)"])
 	" Manual closing quotes
 	call Type("Manual closing quotes", "\"\"", ['"|"'], ["autoclose:0"])
 	call RepeatLast("Manual closing quotes", ['"|""|"'])
 	" Jump over paren
 	call Type("Jump over paren", "()", ['()|'], [])
 	call RepeatLast("Jump over paren", ['()|()|'])
 	" Jump over quote
 	call Type("Jump over quote", "\"\"", ['""|'], [])
 	call RepeatLast("Jump over quote", ['""|""|'])
 	" Apostrophe
 	call Type("Apostrophe", "test'", ["test'|"], [])
 	call RepeatLast("Apostrophe", ["test'|test'|"])
 	" Close quote
 	call Type("Close quote", "'\<Del>\<Esc>a'", ["'|'"], [])
 	" Closing paren
 	call Type("Closing paren", "abcd)", ["abcd)|"], [])
 	" <S-Tab>
 	call Type("S Tab", "(\<S-Tab>", ["()|"], [])
 	call RepeatLast("S Tab", ["()|()|"])
 	" Space expansion
 	call Type("Space expansion", "(\<Space>\<BS>", ['(|)'], ['expand_space:1'])
 	call RepeatLast("BS with space expansion", ['(|)(|)'])
 	" BS with space expansion
 	call Type("BS with space expansion", "(\<Space>", ['( | )'], ['expand_space:1'])
 	call RepeatLast("Space expansion", ['( | )( | )'])
 	" Car return expansion
 	call Type("CR expansion", "(\<CR>", ['(', '|', ')'], ['expand_cr:1'])
 	call RepeatLast("CR expansion", ['(', '|', ')(', '|', ')'], 1)
 	" BS with car return expansion
 	call Type("BS with CR expansion", "(\<CR>\<BS>", ['(|)'], ['expand_cr:1'])
 	call RepeatLast("BS with CR expansion", ['(|)(|)'], 1)
 	" Visual wrapping
 	call Type("Visual wrapping left paren", "1234\<Esc>v,(", ['123(4)'], ['visual_leader:","'])
 	cal RepeatLast("Visual wrapping left paren", ['(1)23(4)'], 1)
 	" Visual line wrapping
 	call Type("Visual line wrapping left paren", "1234\<Esc>V,(", ['(1234)'], ['visual_leader:","'])
 	cal RepeatLast("Visual line wrapping left paren", ['((1234))'], 1)
 	" Visual wrapping
 	call Type("Visual wrapping right paren", "1234\<Esc>v,)", ['123(4)'], ['visual_leader:","'])
 	cal RepeatLast("Visual wrapping right paren", ['(1)23(4)'], 1)
 	" Visual line wrapping
 	call Type("Visual line wrapping right paren", "1234\<Esc>V,)", ['(1234)'], ['visual_leader:","'])
 	cal RepeatLast("Visual line wrapping right paren", ['((1234))'], 1)
 	" Visual wrapping
 	call Type("Visual wrapping quote", "1234\<Esc>v,\"", ['123"4"'], ['visual_leader:","'])
 	cal RepeatLast("Visual wrapping quote", ['"1"23"4"'], 1)
 	" Visual line wrapping
 	call Type("Visual line wrapping quote", "1234\<Esc>V,\"", ['"1234"'], ['visual_leader:","'])
 	cal RepeatLast("Visual line wrapping quote", ['""1234""'], 1)
 	" Visual line wrapping empty line
 	call Type("Visual line wrapping paren empty line", "\<Esc>V,(", ['()'], ['visual_leader:","'])
 	" Visual line wrapping empty line
 	call Type("Visual line wrapping quote empty line", "\<Esc>V,\"", ['""'], ['visual_leader:","'])
 	" Smart quotes
 	call Type("Smart quote alphanumeric", "a\"4", ['a"4|'], [])
 	call RepeatLast("Smart quote alphanumeric", ['a"4|a"4|'])
 	" Smart quotes
 	call Type("Smart quote escaped", "esc\\\"", ['esc\"|'], [])
 	call RepeatLast("Smart quote escaped", ['esc\"|esc\"|'])
 	" Smart quotes
 	call Type("Smart quote apostrophe", "I'm", ["I'm|"], ['smart_quotes:0'])
 	call RepeatLast("Smart quote escaped", ["I'm|I'm|"])
 	" Backspace inside space expansion
 	call Type("Backspace inside space expansion", "(\<Space>\<BS>", ['(|)'], ['expand_space:1'])
 	call RepeatLast("Backspace inside space expansion", ['(|)(|)'])
 	" <Right-arrow> inserts text
 	call Type("<Right-arrow> inserts text", "(he\<Right>\<Space>th\<Right>\<Right>", ['(he) th|'], [])
 	" Backspace inside CR expansion
 	call Type("Backspace inside CR expansion", "(\<CR>\<BS>", ['(|)'], ['expand_cr:1'])
 	call RepeatLast("Backspace inside CR expansion", ['(|)(|)'], 1)
 	" FileType event
 	let g:delimitMate_excluded_ft = "vim"
 	set ft=vim
 	call Type("FileType Autoclose parens", "(", ["(|"], [])
 	unlet g:delimitMate_excluded_ft
 	set ft=
 	" Duplicated delimiter after CR
 	call Type("Duplicated delimiter after CR", "(\<CR>", ['(', '|)'], [])
 	" Deactivate on comments: The first call to a closing delimiter
 	" will not work here as expected, but it does in real life tests.
 	set ft=vim
 	call Type("Deactivate on comments", "\"()``[]''\"\"", ["\"()``[]''\"\"|"], ["autoclose:0"], 1)
 	set ft=
 	" Deactivate parens on comments: The first call to a closing delimiter
 	" will not work here as expected, but it does in real life tests.
 	set ft=vim
 	call Type("Deactivate parens on comments", "\"()[]", ["\"()[]|"], ["autoclose:0"], 1)
 	set ft=
 	" Deactivate quotes on comments: See previous note.
 	set ft=vim
 	call Type("Deactivate parens on comments", "\"(`", ["\"(``|"], [], 1)
 	set ft=
 	" Manual close at start of line
 	call Type("Manual close at start of line", "m)\<Left>\<Left>)", [')|m)'], ["autoclose:0"])
 	"}}}
 	" Show results: {{{
 	normal ggVG"_d
 	call append(0, split(string(b:test_results)[1:-2], ', '))
 	call append(0, "*TESTS REPORT: " . b:errors . " failed, " . b:corrects . " passed and " . b:ignores . " ignored.")
 	normal "_ddgg
 	let @/ = ".\\+Failed:.*!="
 	2,$sort /^.\+':/
 	normal gg
 	exec search('Ignored:','nW').",$sort! /^.\\+':/"
 	set nohlsearch
 	syn match lineIgnored ".*Ignored.*"
 	syn match labelPassed "'\@<=.\+\(': 'Passed\)\@="
 	syn match labelFailed "'\@<=.\+\(': 'Failed\)\@="
 	syn match resultPassed "\('Passed: \)\@<=.\+\('$\)\@="
 	syn match resultFailed "\('Failed: \)\@<=.\+\('$\)\@=" contains=resultInequal
 	syn match resultIgnored "\('Ignored: \)\@<=.\+\('$\)\@="
 	syn match resultInequal "!="
 	syn match resultSummary "^\*.\+" contains=resultSummaryNumber
 	syn match resultSummaryNumber "[1-9][0-9]* failed*" contained
 	hi def link lineIgnored Ignore
 	hi def link labelPassed Comment
 	hi def link labelFailed Special
 	hi def link resultPassed Ignore
 	hi def link resultFailed Boolean
 	hi def link resultInequal Error
 	hi def link resultSummary SpecialComment
 	hi def link resultSummaryNumber Error
 	" }}}
 	let &more = nomore
 endfunction
 " vim:foldmethod=marker:foldcolumn=4
--- a/4
+++ b/4
@@ -0,0 +1,4 @@
 so ./test/_setup.vim
 let delimitMate_expand_cr = 1
 filetype indent plugin on
--- a/doc/delimitMate.txt
+++ b/doc/delimitMate.txt
@@ -1,4 +1,4 @@
-*delimitMate*    Trying to keep those beasts at bay! v2.4.1  *delimitMate.txt*
+*delimitMate.txt*   Trying to keep those beasts at bay! v2.7     *delimitMate*
@@ -20,24 +20,25 @@
 0.- CONTENTS                                           *delimitMate-contents*
    1. Introduction____________________________|delimitMateIntro|
-    2. Functionality___________________________|delimitMateFunctionality|
+    2. Customization___________________________|delimitMateOptions|
-        2.1 Automatic closing & exiting________|delimitMateAutoClose|
+        2.1 Options summary____________________|delimitMateOptionSummary|
-        2.2 Expansion of space and CR__________|delimitMateExpansion|
+        2.2 Options details____________________|delimitMateOptionDetails|
-        2.3 Backspace__________________________|delimitMateBackspace|
+    3. Functionality___________________________|delimitMateFunctionality|
-        2.4 Visual wrapping____________________|delimitMateVisualWrapping|
+        3.1 Automatic closing & exiting________|delimitMateAutoClose|
-        2.5 Smart Quotes_______________________|delimitMateSmartQuotes|
+        3.2 Expansion of space and CR__________|delimitMateExpansion|
-        2.6 Balancing matching pairs___________|delimitMateBalance|
+        3.3 Backspace__________________________|delimitMateBackspace|
-        2.7 FileType based configuration_______|delimitMateFileType|
+        3.4 Smart Quotes_______________________|delimitMateSmartQuotes|
-        2.8 Syntax awareness___________________|delimitMateSyntax|
+        3.5 Balancing matching pairs___________|delimitMateBalance|
-    3. Customization___________________________|delimitMateOptions|
+        3.6 FileType based configuration_______|delimitMateFileType|
-        3.1 Options summary____________________|delimitMateOptionSummary|
+        3.7 Syntax awareness___________________|delimitMateSyntax|
        3.2 Options details____________________|delimitMateOptionDetails|
    4. Commands________________________________|delimitMateCommands|
-    5. Functions_______________________________|delimitMateFunctions|
+    5. Mappings________________________________|delimitMateMappings|
-    6. TODO list_______________________________|delimitMateTodo|
+    6. Functions_______________________________|delimitMateFunctions|
-    7. Maintainer______________________________|delimitMateMaintainer|
+    7. Autocommands____________________________|delimitMateAutocmds|
-    8. Credits_________________________________|delimitMateCredits|
+    8. TODO list_______________________________|delimitMateTodo|
-    9. History_________________________________|delimitMateHistory|
+    9. Maintainer______________________________|delimitMateMaintainer|
   10. Credits_________________________________|delimitMateCredits|
   11. History_________________________________|delimitMateHistory|
 ==============================================================================
 1.- INTRODUCTION                                           *delimitMateIntro*
@@ -47,198 +48,23 @@ etc.; besides some other related features that should make your time in insert
 mode a little bit easier.
 Most of the features can be modified or disabled permanently, using global
-variables, or on a FileType basis, using autocommands. With a couple of
+variables, or on a FileType basis, using autocommands.
-exceptions and limitations, this features don't brake undo, redo or history.
+
 NOTE 1: If you have any trouble with this plugin, please run |:DelimitMateTest|
 in a new buffer to see what is not working.
 NOTE 2: Abbreviations set with |:iabbrev| will not be expanded by delimiters
 used on delimitMate, you should use <C-]> (read |i_CTRL-]|) to expand them on
 the go.
 ==============================================================================
- 2. FUNCTIONALITY                                   *delimitMateFunctionality*
+ 2. CUSTOMIZATION                                         *delimitMateOptions*
 ------------------------------------------------------------------------------
   2.1 AUTOMATIC CLOSING AND EXITING                    *delimitMateAutoClose*
 With automatic closing enabled, if an opening delimiter is inserted the plugin
 inserts the closing delimiter and places the cursor between the pair. With
 automatic closing disabled, no closing delimiters is inserted by delimitMate,
 but when a pair of delimiters is typed, the cursor is placed in the middle.
 When the cursor is inside an empty pair or located next to the left of a
 closing delimiter, the cursor is placed outside the pair to the right of the
 closing delimiter.
 Unless |'delimitMate_matchpairs'| or |'delimitMate_quotes'|are set, this
 script uses the values in '&matchpairs' to identify the pairs, and ", ' and `
 for quotes respectively.
 The following table shows the behaviour, this applies to quotes too (the final
 position of the cursor is represented by a "|"):
 With auto-close: >
                          Type   |  You get
                        ====================
                           (     |    (|)
                        –––––––––|––––––––––
                           ()    |    ()|
                        –––––––––|––––––––––
                        (<S-Tab> |    ()|
 <
 Without auto-close: >
                          Type    |  You get
                        =====================
                           ()     |    (|)
                        –––––––––-|––––––––––
                           ())    |    ()|
                        –––––––––-|––––––––––
                        ()<S-Tab> |    ()|
 <
 NOTE: Abbreviations will not be expanded by delimiters used on delimitMate,
 you should use <C-]> (read |i_CTRL-]|) to expand them on the go.
 ------------------------------------------------------------------------------
   2.2 EXPANSION OF SPACE AND CAR RETURN                *delimitMateExpansion*
 When the cursor is inside an empty pair of delimiters, <Space> and <CR> can be
 expanded, see |'delimitMate_expand_space'| and
 |'delimitMate_expand_cr'|:
 Expand <Space> to: >
                    <Space><Space><Left>  |  You get
                  ====================================
                              (|)         |    ( | )
 <
 Expand <CR> to: >
                      <CR><CR><Up>  |  You get
                    ============================
                           (|)      |    (
                                    |    |
                                    |    )
 <
 NOTE that the expansion of <CR> will brake the redo command.
 Since <Space> and <CR> are used everywhere, I have made the functions involved
 in expansions global, so they can be used to make custom mappings. Read
 |delimitMateFunctions| for more details.
 ------------------------------------------------------------------------------
   2.3 BACKSPACE                                        *delimitMateBackspace*
 If you press backspace inside an empty pair, both delimiters are deleted. When
 expansions are enabled, <BS> will also delete the expansions. NOTE that
 deleting <CR> expansions will brake the redo command.
 If you type <S-BS> (shift + backspace) instead, only the closing delimiter
 will be deleted. NOTE that this will not usually work when using Vim from the
 terminal, see 'delimitMate#JumpAny()' below to see how to fix it.
 e.g. typing at the "|": >
                  What  |      Before       |      After
               ==============================================
                  <BS>  |  call expand(|)   |  call expand|
               ---------|-------------------|-----------------
                  <BS>  |  call expand( | ) |  call expand(|)
               ---------|-------------------|-----------------
                  <BS>  |  call expand(     |  call expand(|)
                        |  |                |
                        |  )                |
               ---------|-------------------|-----------------
                 <S-BS> |  call expand(|)   |  call expand(|
 <
 ------------------------------------------------------------------------------
   2.4 WRAPPING OF VISUAL SELECTION                *delimitMateVisualWrapping*
 When visual mode is active this script allows for the selection to be enclosed
 with delimiters. But, since brackets have special meaning in visual mode, a
 leader (the value of 'mapleader' by default) should precede the delimiter.
 NOTE that this feature brakes the redo command and doesn't currently work well
 on blockwise visual mode when the selection has lines one character smaller
 than the rest, any suggestions to fix this will be very welcome.
 e.g. (selection represented between square brackets): >
                      Selected text    |       After \"
                 =============================================
                  An [absurd] example! | An "absurd" example!
 <
 ------------------------------------------------------------------------------
   2.5 SMART QUOTES                                   *delimitMateSmartQuotes*
 Only one quote will be inserted following a quote, a "\" or, following or
 preceding an alphanumeric character. This should cover closing quotes after a
 string, opening quotes before a string, escaped quotes and apostrophes. Except
 for apostrophes, this feature can be disabled setting the option
 |'delimitMate_smart_quotes'| to 0.
 e.g. typing at the "|": >
                     What |    Before    |     After
                  =======================================
                      "   |  "String|    |  "String"|
                      "   |  let i = "|  |  let i = "|"
                      '   |  I|          |  I'|
 <
 ------------------------------------------------------------------------------
   2.6 BALANCING MATCHING PAIRS                           *delimitMateBalance*
 When inserting an opening paren and |'delimitMate_balance_matchpairs'| is
 enabled, delimitMate will try to balance the closing pairs in the current
 line.
 e.g. typing at the "|": >
                     What |    Before    |     After
                  =======================================
                      (   |      |)      |     (|)
                      (   |      |       |     (|)
                      (   |     (|)      |    ((|))
 <
 ------------------------------------------------------------------------------
   2.7 FILE TYPE BASED CONFIGURATION                     *delimitMateFileType*
 delimitMate options can be set globally for all buffers using global
 ("regular") variables in your |vimrc| file. But |:autocmd| can be used to set
 options for specific file types (see |'filetype'|) using buffer variables in
 the following way: >
   au FileType mail,text let b:delimitMate_autoclose = 0
         ^       ^           ^            ^            ^
         |       |           |            |            |
         |       |           |            |            - Option value.
         |       |           |            - Option name.
         |       |           - Buffer variable.
         |       - File types for which the option will be set.
         - Don't forget to put this event.
 <
 NOTE that you should use buffer variables (|b:var|) only to set options with
 |:autocmd|, for global options use regular variables (|g:var|) in your vimrc.
 ------------------------------------------------------------------------------
   2.8 SYNTAX AWARENESS                                    *delimitMateSyntax*
 The features of this plug-in might not be always helpful, comments and strings
 usualy don't need auto-completion. delimitMate monitors which region is being
 edited and if it detects that the cursor is in a comment it'll turn itself off
 until the cursor leaves the comment. The excluded regions can be set using the
 option |'delimitMate_excluded_regions'|. Read |group-name| for a list of
 regions or syntax group names.
 NOTE that this feature relies on a proper syntax file for the current file
 type, if the appropiate syntax file doesn't define a region, delimitMate won't
 know about it.
 ==============================================================================
 3. CUSTOMIZATION                                         *delimitMateOptions*
 You can create your own mappings for some features using the global functions.
-Read |DelimitMateFunctions| for more info.
+Read |delimitMateFunctions| for more info.
 ------------------------------------------------------------------------------
-   3.1 OPTIONS SUMMARY                              *delimitMateOptionSummary*
+   2.1 OPTIONS SUMMARY                              *delimitMateOptionSummary*
 The behaviour of this script can be customized setting the following options
 in your vimrc file. You can use local options to set the configuration for
@@ -258,14 +84,16 @@ specific file types, see |delimitMateOptionDetails| for examples.
 |'delimitMate_nesting_quotes'|    Tells delimitMate which quotes should be
                                allowed to be nested.
 |'delimitMate_visual_leader'|     Sets the leader to be used in visual mode.
 |'delimitMate_expand_cr'|         Turns on/off the expansion of <CR>.
 |'delimitMate_expand_space'|      Turns on/off the expansion of <Space>.
 |'delimitMate_jump_expansion'|    Turns on/off jumping over expansions.
 |'delimitMate_smart_quotes'|      Turns on/off the "smart quotes" feature.
 |'delimitMate_smart_matchpairs'|  Turns on/off the "smart matchpairs" feature.
 |'delimitMate_balance_matchpairs'|Turns on/off the "balance matching pairs"
                                feature.
@@ -274,13 +102,17 @@ specific file types, see |delimitMateOptionDetails| for examples.
 |'delimitMate_excluded_ft'|       Turns off the script for the given file types.
 |'delimitMate_eol_marker'|        Determines what to insert after the closing
                                matchpair when typing an opening matchpair on
                                the end of the line.
 |'delimitMate_apostrophes'|       Tells delimitMate how it should "fix"
                                balancing of single quotes when used as
                                apostrophes. NOTE: Not needed any more, kept
                                for compatibility with older versions.
 ------------------------------------------------------------------------------
-   3.2 OPTIONS DETAILS                              *delimitMateOptionDetails*
+   2.2 OPTIONS DETAILS                              *delimitMateOptionDetails*
 Add the shown lines to your vimrc file in order to set the below options.
 Buffer variables take precedence over global ones and can be used along with
@@ -288,7 +120,7 @@ autocmd to modify delimitMate's behavior for specific file types, read more in
 |delimitMateFileType|.
 Note: Use buffer variables only to set options for specific file types using
-:autocmd, use global variables to set options for every buffer. Read more in
+:autocmd, use global variables to set options for all buffers. Read more in
 |g:var| and |b:var|.
 ------------------------------------------------------------------------------
@@ -299,6 +131,15 @@ e.g.: >
        let loaded_delimitMate = 1
        au FileType mail let b:loaded_delimitMate = 1
 <
 ------------------------------------------------------------------------------
                                                  *'delimitMate_offByDefault'*
 Values: 0 or 1.~
 Default: 0~
 If this option is set to 1, delimitMate will load, but will not take
 effect in any buffer unless |:DelimitMateSwitch| is called in that
 buffer.
 ------------------------------------------------------------------------------
                                                     *'delimitMate_autoclose'*
                                                   *'b:delimitMate_autoclose'*
@@ -314,7 +155,8 @@ e.g.: >
 ------------------------------------------------------------------------------
                                                    *'delimitMate_matchpairs'*
                                                  *'b:delimitMate_matchpairs'*
-Values: A string with |'matchpairs'| syntax.                                 ~
+Values: A string with |'matchpairs'| syntax, plus support for multi-byte~
        characters.~
 Default: &matchpairs                                                         ~
 Use this option to tell delimitMate which characters should be considered
@@ -341,32 +183,23 @@ e.g.: >
 Values: A list of quotes.                                                    ~
 Default: []                                                                  ~
-Quotes listed here will not be able to jump out of the empty pair, thus
+When adding a third quote listed in this option is inserted, three quotes will
-allowing the autoclosed quotes to be nested.
+be inserted to the right of the cursor and the cursor will stay in the middle.
 If more quotes are inserted the number of quotes on both sides of the cursor
 will stay balanced.
 e.g.: >
        let delimitMate_nesting_quotes = ['"','`']
        au FileType python let b:delimitMate_nesting_quotes = ['"']
 <
 ------------------------------------------------------------------------------
                                                 *'delimitMate_visual_leader'*
                                               *'b:delimitMate_visual_leader'*
 Values: Any character.                                                       ~
 Default: q                                                                   ~
 The value of this option will be used to wrap the selection in visual mode
 when followed by a delimiter. Read |delimitMateVisualWrap| for details.
 e.g: >
        let delimitMate_visual_leader = "f"
        au FileType html let b:delimitMate_visual_leader = "f"
 <
 ------------------------------------------------------------------------------
                                                     *'delimitMate_expand_cr'*
                                                   *'b:delimitMate_expand_cr'*
-Values: 1 or 0                                                               ~
+Values: 0, 1 or 2                                                             ~
 Default: 0                                                                   ~
 This option turns on/off the expansion of <CR>. Read |delimitMateExpansion|
-for details.
+for details. NOTE This feature requires that 'backspace' is either set to 2 or
 has "eol" and "start" as part of its value.
 e.g.: >
        let delimitMate_expand_cr = 1
        au FileType mail let b:delimitMate_expand_cr = 1
@@ -376,24 +209,73 @@ e.g.: >
                                                *'b:delimitMate_expand_space'*
 Values: 1 or 0                                                               ~
 Default: 0                                                                   ~
 This option turns on/off the expansion of <Space>. Read |delimitMateExpansion|
 for details.
 e.g.: >
        let delimitMate_expand_space = 1
        au FileType tcl let b:delimitMate_expand_space = 1
 <
 ------------------------------------------------------------------------------
                                          *'delimitMate_expand_inside_quotes'*
                                        *'b:delimitMate_expand_inside_quotes'*
 Values: 1 or 0                                                                ~
 Default: 0                                                                   ~
 When this option is set to 1 the expansion of space and cr will also be
 applied to quotes. Read |delimitMateExpansion| for details.
 e.g.: >
        let delimitMate_expand_inside_quotes = 1
        au FileType mail let b:delimitMate_expand_inside_quotes = 1
 <
 ------------------------------------------------------------------------------
                                                *'delimitMate_jump_expansion'*
                                              *'b:delimitMate_jump_expansion'*
 Values: 1 or 0                                                               ~
 Default: 0                                                                   ~
 This option turns on/off the jumping over <CR> and <Space> expansions when
 inserting closing matchpairs. Read |delimitMateExpansion| for details.
 e.g.: >
        let delimitMate_jump_expansion = 1
        au FileType tcl let b:delimitMate_jump_expansion = 1
 <
 ------------------------------------------------------------------------------
                                                  *'delimitMate_smart_quotes'*
                                                *'b:delimitMate_smart_quotes'*
-Values: 1 or 0                                                               ~
+Values: String with an optional !  at the beginning followed by a regexp     ~
-Default: 1                                                                   ~
+Default:~
 '\%(\w\|[^[:punct:][:space:]]\|\%(\\\\\)*\\\)\%#\|\%#\%(\w\|[^[:space:][:punct:]]\)'                  ~
 A bang (!) at the beginning is removed and used to "negate" the pattern. The
 remaining text is used as a regexp to be matched on the current line. A single
 quote is inserted when the pattern matches and a bang is not present. The bang
 changes that, so a single quote is inserted only if the regexp does not match.
 This feature is disabled when the variable is set to an empty string, with the
 exception of apostrophes.
 Note that you need to use '\%#' to match the position of the cursor.  Keep in
 mind that '\%#' matches with zero width, so if you need to match the char
 under the cursor (which would be the one to the right on insert mode) use
 something like '\%#.'.
 This option turns on/off the smart quotes feature. Read
 |delimitMateSmartQuotes| for details.
 e.g.: >
-        let delimitMate_smart_quotes = 0
+        let delimitMate_smart_quotes = '\w\%#'
-        au FileType tcl let b:delimitMate_smart_quotes = 0
+        au FileType tcl let b:delimitMate_smart_quotes = '!\s\%#\w'
 <
 ------------------------------------------------------------------------------
                                              *'delimitMate_smart_matchpairs'*
                                            *'b:delimitMate_smart_matchpairs'*
 Values: Regexp                                                               ~
 Default: '^\%(\w\|\!\|[£$]\|[^[:space:][:punct:]]\)'                                ~
 This regex is matched against the text to the right of cursor, if it's not
 empty and there is a match delimitMate will not autoclose the pair. At the
 moment to match the text, an escaped bang (\!) in the regex will be replaced
 by the character being inserted, while an escaped number symbol (\#) will be
 replaced by the closing pair.
 e.g.: >
        let delimitMate_smart_matchpairs = ''
        au FileType tcl let b:delimitMate_smart_matchpairs = '^\%(\w\|\$\)'
 <
 ------------------------------------------------------------------------------
                                            *'delimitMate_balance_matchpairs'*
@@ -415,7 +297,7 @@ Default: Comment                                                             ~
 This options turns delimitMate off for the listed regions, read |group-name|
 for more info about what is a region.
 e.g.: >
-        let delimitMate_excluded_regions = "Comments,String"
+        let delimitMate_excluded_regions = "Comment,String"
 <
 ------------------------------------------------------------------------------
                                                   *'delimitMate_excluded_ft'*
@@ -427,6 +309,32 @@ only if you don't want any of the features it provides on those file types.
 e.g.: >
        let delimitMate_excluded_ft = "mail,txt"
 <
 ------------------------------------------------------------------------------
                                             *'delimitMate_insert_eol_marker'*
 Values: Integer                                                              ~
 Default: 1                                                              ~
 Whether to insert the eol marker (EM) or not. The EM is inserted following
 rules:
 0 -> never
 1 -> when inserting any matchpair
 2 -> when expanding car return in matchpair
 e.g.: >
        au FileType c,perl let b:delimitMate_insert_eol_marker = 2
 <
 ------------------------------------------------------------------------------
                                                    *'delimitMate_eol_marker'*
 Values: String.                                                              ~
 Default: Empty.                                                              ~
 The contents of this string will be inserted after the closing matchpair or
 quote when the respective opening matchpair or quote is inserted at the end
 of the line.
 e.g.: >
        au FileType c,perl let b:delimitMate_eol_marker = ";"
 <
 ------------------------------------------------------------------------------
                                                   *'delimitMate_apostrophes'*
 Values: Strings separated by ":".                                            ~
@@ -443,6 +351,209 @@ e.g.: >
        let delimitMate_apostrophes = ""
        au FileType tcl let delimitMate_apostrophes = ""
 <
 ==============================================================================
 3. FUNCTIONALITY                                   *delimitMateFunctionality*
 ------------------------------------------------------------------------------
   3.1 AUTOMATIC CLOSING AND EXITING                    *delimitMateAutoClose*
 With automatic closing enabled, if an opening delimiter is inserted the plugin
 inserts the closing delimiter and places the cursor between the pair. With
 automatic closing disabled, no closing delimiters is inserted by delimitMate,
 but when a pair of delimiters is typed, the cursor is placed in the middle.
 When the cursor is inside an empty pair or located next to the left of a
 closing delimiter, the cursor is placed outside the pair to the right of the
 closing delimiter.
 When |'delimitMate_smart_matchpairs'| is not empty and it matches the text to
 the right of the cursor, delimitMate will not automatically insert the closing
 pair.
 Unless |'delimitMate_matchpairs'| or |'delimitMate_quotes'| are set, this
 script uses the values in '&matchpairs' to identify the pairs, and ", ' and `
 for quotes respectively.
 <S-Tab> will jump over a single closing delimiter or quote, <C-G>g will jump
 over contiguous delimiters and/or quotes.
 The following table shows the behaviour, this applies to quotes too (the final
 position of the cursor is represented by a "|"):
 With auto-close: >
                          Type     |  You get
                        =======================
                           (       |    (|)
                        –––––––––––|–––––––––––
                           ()      |    ()|
                        –––––––––––|–––––––––––
                        (<S-Tab>   |    ()|
                        –––––––––––|–––––––––––
                        {("<C-G>g  |  {("")}|
 <
 Without auto-close: >
                          Type        |  You get
                        =========================
                           ()         |    (|)
                        –––––––––-----|––––––––––
                           ())        |    ()|
                        –––––––––-----|––––––––––
                        ()<S-Tab>     |    ()|
                        ––––––––––––––|–––––––––––
                        {}()""<C-G>g  |  {("")}|
 <
 NOTE: Abbreviations will not be expanded by delimiters used on delimitMate,
 you should use <C-]> (read |i_CTRL-]|) to expand them on the go.
 ------------------------------------------------------------------------------
   3.2 EXPANSION OF SPACE AND CAR RETURN                *delimitMateExpansion*
 When the cursor is inside an empty pair of any matchpair, <Space> and <CR> can be
 expanded, see |'delimitMate_expand_space'| and
 |'delimitMate_expand_cr'|:
 Expand <Space> to: >
                    You start with  |  You get
                  ==============================
                        (|)         |    ( | )
 <
 Expand <CR> to: >
                   You start with   |  You get
                  ==============================
                        (|)         |    (
                                    |      |
                                    |    )
 <
 When you have |'delimitMate_jump_expansion'| enabled, if there is an existing
 closing paren/bracket/etc. on the next line, delimitMate will make the cursor
 jump over any whitespace/<CR> and place it after the existing closing
 delimiter instead of inserting a new one.
 When |'delimitMate_expand_cr'| is set to 2, the following will also happen: >
                    You start with  |  You get
                  ==============================
                       (foo|)       |    (foo
                                    |      |
                                    |    )
 <
 Since <Space> and <CR> are used everywhere, I have made the functions involved
 in expansions global, so they can be used to make custom mappings. Read
 |delimitMateFunctions| for more details.
 ------------------------------------------------------------------------------
   3.3 BACKSPACE                                        *delimitMateBackspace*
 If you press backspace inside an empty pair, both delimiters are deleted. When
 expansions are enabled, <BS> will also delete the expansions.
 If you type <S-BS> (shift + backspace) instead, only the closing delimiter
 will be deleted. NOTE that this will not usually work when using Vim from the
 terminal, see 'delimitMate#JumpAny()' below to see how to fix it.
 e.g. typing at the "|": >
                  What  |      Before       |      After
               ==============================================
                  <BS>  |  call expand(|)   |  call expand|
               ---------|-------------------|-----------------
                  <BS>  |  call expand( | ) |  call expand(|)
               ---------|-------------------|-----------------
                  <BS>  |  call expand(     |  call expand(|)
                        |  |                |
                        |  )                |
               ---------|-------------------|-----------------
                 <S-BS> |  call expand(|)   |  call expand(|
 <
 ------------------------------------------------------------------------------
   3.4 SMART QUOTES                                   *delimitMateSmartQuotes*
 Only one quote will be inserted following a quote, a "\", following or
 preceding a keyword character, or when the number of quotes in the current
 line is odd. This should cover closing quotes after a string, opening quotes
 before a string, escaped quotes and apostrophes. See more details about
 customizing this feature on |'delimitMate_smart_quotes'|.
 e.g. typing at the "|": >
                     What |    Before    |     After
                  =======================================
                      "   |  Text |      |  Text "|"
                      "   |  "String|    |  "String"|
                      "   |  let i = "|  |  let i = "|"
                      'm  |  I|          |  I'm|
 <
 ------------------------------------------------------------------------------
   3.4 SMART MATCHPAIRS                           *delimitMateSmartMatchpairs*
 This is similar to "smart quotes", but applied to the characters in
 |'delimitMate_matchpairs'|. The difference is that delimitMate will not
 auto-close the pair when the regex matches the text on the right of the
 cursor. See |'delimitMate_smart_matchpairs'| for more details.
 e.g. typing at the "|": >
                     What |    Before    |     After
                  =======================================
                      (   |  function|   |  function(|)
                      (   |  |var        |  (|var
 <
 ------------------------------------------------------------------------------
   3.5 BALANCING MATCHING PAIRS                           *delimitMateBalance*
 When inserting an opening paren and |'delimitMate_balance_matchpairs'| is
 enabled, delimitMate will try to balance the closing pairs in the current
 line.
 e.g. typing at the "|": >
                     What |    Before    |     After
                  =======================================
                      (   |      |       |     (|)
                      (   |      |)      |     (|)
                      ((  |      |)      |    ((|))
 <
 ------------------------------------------------------------------------------
   3.6 FILE TYPE BASED CONFIGURATION                     *delimitMateFileType*
 delimitMate options can be set globally for all buffers using global
 ("regular") variables in your |vimrc| file. But |:autocmd| can be used to set
 options for specific file types (see |'filetype'|) using buffer variables in
 the following way: >
   au FileType mail,text let b:delimitMate_autoclose = 0
         ^       ^           ^            ^            ^
         |       |           |            |            |
         |       |           |            |            - Option value.
         |       |           |            - Option name.
         |       |           - Buffer variable.
         |       - File types for which the option will be set.
         - Don't forget to put this event.
 <
 NOTE that you should use buffer variables (|b:var|) only to set options with
 |:autocmd|, for global options use regular variables (|g:var|) in your vimrc.
 ------------------------------------------------------------------------------
   3.7 SYNTAX AWARENESS                                    *delimitMateSyntax*
 The features of this plug-in might not be always helpful, comments and strings
 usualy don't need auto-completion. delimitMate monitors which region is being
 edited and if it detects that the cursor is in a comment it'll turn itself off
 until the cursor leaves the comment. The excluded regions can be set using the
 option |'delimitMate_excluded_regions'|. Read |group-name| for a list of
 regions or syntax group names.
 NOTE that this feature relies on a proper syntax file for the current file
 type, if the appropiate syntax file doesn't define a region, delimitMate won't
 know about it.
 ==============================================================================
 4. COMMANDS                                             *delimitMateCommands*
@@ -452,6 +563,16 @@ e.g.: >
 Re-sets all the mappings used for this script, use it if any option has been
 changed or if the filetype option hasn't been set yet.
 ------------------------------------------------------------------------------
 :DelimitMateOn                                                *:DelimitMateOn*
 Enable delimitMate mappings.
 ------------------------------------------------------------------------------
 :DelimitMateOff                                              *:DelimitMateOff*
 Disable delimitMate mappings.
 ------------------------------------------------------------------------------
 :DelimitMateSwitch                                        *:DelimitMateSwitch*
@@ -529,44 +650,55 @@ represented by an "|": >
 <
 ==============================================================================
- 5. FUNCTIONS                                           *delimitMateFunctions*
+ 5. MAPPINGS                                             *delimitMateMappings*
-Functions should be used enclosed between <C-R>= and <CR>, otherwise they
+delimitMate doesn't override any existing map, so you may encounter that it
-might not work as expected or at all.
+doesn't work as expected because a mapping is missing. In that case, the
 conflicting mappings should be resolved by either disabling the conflicting
 mapping or creating a custom mappings.
 In order to make custom mappings easier and prevent overwritting existing
 ones, delimitMate uses the |<Plug>| + |hasmapto()| (|usr_41.txt|) construct
 for its mappings.
 These are the default mappings for the extra features:
 <BS>         is mapped to <Plug>delimitMateBS
 <S-BS>       is mapped to <Plug>delimitMateS-BS
 <S-Tab>      is mapped to <Plug>delimitMateS-Tab
 <C-G>g       is mapped to <Plug>delimitMateJumpMany
 The rest of the mappings correspond to parens, quotes, CR, Space, etc. and they
 depend on the values of the delimitMate options, they have the following form:
 <Plug>delimitMate + char
 e.g.: for "(":
 ( is mapped to <Plug>delimitMate(
 e.g.: If you have <CR> expansion enabled, you might want to skip it on pop-up
 menus:
    imap <expr> <CR> pumvisible()
                     \ ? "\<C-Y>"
                     \ : "<Plug>delimitMateCR"
 ==============================================================================
 6. FUNCTIONS                                           *delimitMateFunctions*
 ------------------------------------------------------------------------------
-delimitMate#WithinEmptyPair()                  *delimitMate_WithinEmptyPair()*
+delimitMate#WithinEmptyPair()                  *delimitMate#WithinEmptyPair()*
 Returns 1 if the cursor is inside an empty pair, 0 otherwise.
 e.g.: >
    inoremap <expr> <CR> delimitMate#WithinEmptyPair() ?
-             \ "\<C-R>=delimitMate#ExpandReturn()\<CR>" :
+             \ "<Plug>delimitMateCR" :
             \ "external_mapping"
 <
 ------------------------------------------------------------------------------
 delimitMate#ExpandReturn()                        *delimitMate#ExpandReturn()*
 Returns the expansion for <CR> if enabled and inside an empty pair, returns
 <CR> otherwise.
 e.g.: This mapping could be used to select an item on a pop-up menu or expand
 <CR> inside an empty pair: >
        inoremap <expr> <CR> pumvisible() ?
                 \"\<c-y>" :
                 \ "\<C-R>=delimitMate#ExpandReturn()\<CR>"
 <
 ------------------------------------------------------------------------------
 delimitMate#ExpandSpace()                          *delimitMate#ExpandSpace()*
 Returns the expansion for <Space> if enabled and inside an empty pair, returns
 <Space> otherwise.
 e.g.: >
    inoremap <Space> <C-R>=delimitMate#ExpandSpace()<CR>
 <
 ------------------------------------------------------------------------------
 delimitMate#ShouldJump()                            *delimitMate#ShouldJump()*
@@ -574,23 +706,56 @@ Returns 1 if there is a closing delimiter or a quote to the right of the
 cursor, 0 otherwise.
 ------------------------------------------------------------------------------
-delimitMate#JumpAny(key)                               *delimitMate#JumpAny()*
+delimitMate#JumpAny()                               *delimitMate#JumpAny()*
 This function returns a mapping that will make the cursor jump to the right
 when delimitMate#ShouldJump() returns 1, returns the argument "key" otherwise.
 e.g.: You can use this to create your own mapping to jump over any delimiter.
 >
-   inoremap <C-Tab> <C-R>=delimitMate#JumpAny("\<C-Tab>")<CR>
+   inoremap <expr> <C-Tab> delimitMate#JumpAny()
 <
 ==============================================================================
 7. AUTOCOMMANDS                                         *delimitMateAutocmds*
 delimitMate emits 2 |User| autocommands to make it easier for users to
 leverage delimitMate's support for per-filetype customization.
 ------------------------------------------------------------------------------
 delimitMate_map                                              *delimitMate_map*
 This |User| event is emittted just prior to delimitMate defining its
 buffer-local key mappings. You can use this command to define your own
 mappings that are disabled when delimitMate is turned off or excludes the
 current filetype.
 >
    au User delimitMate_map call s:delimitMate_map()
    function s:delimitMate_map()
        imap <buffer><expr> <C-Tab> delimitMate#JumpAny()
    endfunction
 <
 ------------------------------------------------------------------------------
 delimitMate_unmap                                          *delimitMate_unmap*
 This |User| event is emitted just after delimitMate clears its buffer-local
 key mappings. You can use this command to clear your own mappings that you set
 in response to |delimitMate_map|.
 >
    au User delimitMate_unmap call s:delimitMate_unmap()
    function s:delimitMate_unmap()
        silent! iunmap <buffer> <C-Tab>
    endfunction
 <
 Note: This event may be emitted before |delimitMate_map|, and may be emitted
 multiple times in a row without any intervening |delimitMate_map| events.
 ==============================================================================
- 6. TODO LIST                                                *delimitMateTodo*
+ 8. TODO LIST                                                *delimitMateTodo*
 - Automatic set-up by file type.
 - Make block-wise visual wrapping work on un-even regions.
 ==============================================================================
- 7. MAINTAINER                                         *delimitMateMaintainer*
+ 9. MAINTAINER                                         *delimitMateMaintainer*
 Hi there! My name is Israel Chauca F. and I can be reached at:
    mailto:israelchauca@gmail.com
@@ -599,40 +764,72 @@ Feel free to send me any suggestions and/or comments about this plugin, I'll
 be very pleased to read them.
 ==============================================================================
- 8. CREDITS                                               *delimitMateCredits*
+ 10. CREDITS                                              *delimitMateCredits*
-Some of the code that make this script is modified or just shamelessly copied
+Contributors: ~
 from the following sources:
-   - Ian McCracken
+  - Kim Silkebækken                                                         ~
    Fixed mappings being echoed in the terminal.
  - Eric Van Dewoestine                                                     ~
    Implemented smart matchpairs.
 Some of the code that makes this script was modified or just shamelessly
 copied from the following sources:
  - Ian McCracken                                                          ~
    Post titled: Vim, Part II: Matching Pairs:
    http://concisionandconcinnity.blogspot.com/
-   - Aristotle Pagaltzis
+  - Aristotle Pagaltzis                                                    ~
    From the comments on the previous blog post and from:
    http://gist.github.com/144619
-   - Karl Guertin
+  - Karl Guertin                                                           ~
    AutoClose:
    http://www.vim.org/scripts/script.php?script_id=1849
-   - Thiago Alves
+  - Thiago Alves                                                           ~
    AutoClose:
    http://www.vim.org/scripts/script.php?script_id=2009
-   - Edoardo Vacchi
+  - Edoardo Vacchi                                                         ~
    ClosePairs:
    http://www.vim.org/scripts/script.php?script_id=2373
 This script was inspired by the auto-completion of delimiters on TextMate.
 ==============================================================================
- 9. HISTORY                                               *delimitMateHistory*
+ 11. HISTORY                                               *delimitMateHistory*
  Version      Date      Release notes                                       ~
 |---------|------------|-----------------------------------------------------|
-    2.4.1   2010-07-31 * Current release:
+    2.8     2013-07-15 * Current release:
-                         - Fix problem with <Home> and <End>.
+                         - Add :DelimitMateOn & :DelimitMateOff.
 |---------|------------|-----------------------------------------------------|
    2.7     2013-07-15 * - Lots of bug fixes.
                         - Add delimitMate_offByDefault.
                         - Add delimitMate_eol_marker.
                         - Reduce the number of mappings.
                         - Stop using setline().
                         - Better handling of nested quotes.
                         - Allow a custom pattern for smart_quotes.
 |---------|------------|-----------------------------------------------------|
    2.6     2011-01-14 * - Add smart_matchpairs feature.
                         - Add mapping to jump over contiguous delimiters.
                         - Fix behaviour of b:loaded_delimitMate.
 |---------|------------|-----------------------------------------------------|
    2.5.1   2010-09-30 * - Remove visual wrapping. Surround.vim offers a much
                           better implementation.
                         - Minor mods to DelimitMateTest.
 |---------|------------|-----------------------------------------------------|
    2.5     2010-09-22 * - Better handling of mappings.
                         - Add report for mappings in |:DelimitMateTest|.
                         - Allow the use of "|" and multi-byte characters in
                           |'delimitMate_quotes'| and |'delimitMate_matchpairs'|.
                         - Allow commands to be concatenated using |.
 |---------|------------|-----------------------------------------------------|
    2.4.1   2010-07-31 * - Fix problem with <Home> and <End>.
                         - Add missing doc on |'delimitMate_smart_quotes'|,
                           |delimitMateBalance| and
                           |'delimitMate_balance_matchpairs'|.
@@ -653,7 +850,7 @@ This script was inspired by the auto-completion of delimiters on TextMate.
    2.3     2010-06-06 * - Syntax aware: Will turn off when editing comments
                           or other regions, customizable.
                         - Changed format of most mappings.
-                         - Fix: <CR> expansion doesn't brake automatic
+                         - Fix: <CR> expansion doesn't break automatic
                           indentation adjustments anymore.
                         - Fix: Arrow keys would insert A, B, C or D instead
                           of moving the cursor when using Vim on a terminal.
@@ -743,4 +940,4 @@ _____|_____|_____|_____|_____|_____|_____|_____|_____|_____|_____|_____|____ ~
 __|_____|_____|_____|_____|_____|_____|_____|_____|_____|_____|_____|_____|_ ~
 _____|_____|_____|_____|_____|_____|_____|_____|_____|_____|_____|_____|____ ~
-vim:tw=78:et:ts=2:sw=2:ft=help:norl:formatoptions+=tcroqn:autoindent:
+vim:tw=78:et:ts=8:sw=2:ft=help:norl:formatoptions+=tcroqn:autoindent:
--- a/plugin/delimitMate.vim
+++ b/plugin/delimitMate.vim
@@ -1,142 +1,22 @@
-" ============================================================================
+if exists("g:loaded_delimitMate") || &cp || !exists('##InsertCharPre')
 " File:        plugin/delimitMate.vim
 " Version:     2.4.1
 " Modified:    2010-07-31
 " Description: This plugin provides auto-completion for quotes, parens, etc.
 " Maintainer:  Israel Chauca F. <israelchauca@gmail.com>
 " Manual:      Read ":help delimitMate".
 " Initialization: {{{
 if exists("g:loaded_delimitMate") || &cp
 	" User doesn't want this plugin or compatible is set, let's get out!
  finish
 endif
 let g:loaded_delimitMate = 1
 let save_cpo = &cpo
 set cpo&vim
-if exists("s:loaded_delimitMate") && !exists("g:delimitMate_testing")
+command! -bar -bang DelimitMateSwitch call delimitMate#ex_cmd(<bang>0, 'switch' )
-	" Don't define the functions if they already exist: just do the work
+command! -bar -bang DelimitMateOn     call delimitMate#ex_cmd(<bang>0, 'enable' )
-	" (unless we are testing):
+command! -bar -bang DelimitMateOff    call delimitMate#ex_cmd(<bang>0, 'disable')
 	call s:DelimitMateDo()
 	finish
 endif
 if v:version < 700
 	echoerr "delimitMate: this plugin requires vim >= 7!"
 	finish
 endif
 let s:loaded_delimitMate = 1
 let delimitMate_version = "2.4.1"
 "}}}
 " Functions: {{{
 function! s:TestMappingsDo() "{{{
 	if !exists("g:delimitMate_testing")
 		silent call delimitMate#TestMappings()
 	else
 		let temp_varsDM = [b:_l_delimitMate_expand_space, b:_l_delimitMate_expand_cr, b:_l_delimitMate_autoclose]
 		for i in [0,1]
 			let b:delimitMate_expand_space = i
 			let b:delimitMate_expand_cr = i
 			for a in [0,1]
 				let b:delimitMate_autoclose = a
 				call delimitMate#Init()
 				call delimitMate#UnMap()
 				call delimitMate#Map()
 				call delimitMate#TestMappings()
 				normal o
 			endfor
 		endfor
 		let b:delimitMate_expand_space = temp_varsDM[0]
 		let b:delimitMate_expand_cr = temp_varsDM[1]
 		let b:delimitMate_autoclose = temp_varsDM[2]
 		unlet temp_varsDM
 	endif
 	normal gg
 endfunction "}}}
 function! s:DelimitMateDo(...) "{{{
 	" Initialize settings:
 	call delimitMate#Init()
 	" Check if this file type is excluded:
 	if exists("g:delimitMate_excluded_ft") &&
 				\ index(split(g:delimitMate_excluded_ft, ','), &filetype, 0, 1) >= 0
 			" Remove any magic:
 			call delimitMate#UnMap()
 			" Finish here:
 			return 1
 	endif
 	" First, remove all magic, if needed:
 	if exists("b:delimitMate_enabled") && b:delimitMate_enabled == 1
 		call delimitMate#UnMap()
 	endif
 	" Now, add magic:
 	call delimitMate#Map()
 	if a:0 > 0
 		echo "delimitMate has been reset."
 	endif
 endfunction "}}}
 function! s:DelimitMateSwitch() "{{{
 	call delimitMate#Init()
 	if exists("b:delimitMate_enabled") && b:delimitMate_enabled
 		call delimitMate#UnMap()
 		echo "delimitMate has been disabled."
 	else
 		call delimitMate#UnMap()
 		call delimitMate#Map()
 		echo "delimitMate has been enabled."
 	endif
 endfunction "}}}
 "}}}
 " Commands: {{{
 call s:DelimitMateDo()
 " Let me refresh without re-loading the buffer:
 command! DelimitMateReload call s:DelimitMateDo(1)
 " Quick test:
 command! DelimitMateTest call s:TestMappingsDo()
 " Switch On/Off:
 command! DelimitMateSwitch call s:DelimitMateSwitch()
 "}}}
 " Autocommands: {{{
 augroup delimitMate
  au!
-	" Run on file type change.
+  au InsertCharPre * call delimitMate#InsertCharPre(v:char)
-	"autocmd VimEnter * autocmd FileType * call <SID>DelimitMateDo()
+  au TextChangedI  * call delimitMate#TextChangedI()
-	autocmd FileType * call <SID>DelimitMateDo()
+  au InsertEnter   * call delimitMate#InsertEnter()
-
+  au CursorMovedI  * call delimitMate#CursorMovedI()
 	" Run on new buffers.
 	autocmd BufNewFile,BufRead,BufEnter *
 				\ if !exists("b:loaded_delimitMate") |
 				\ call <SID>DelimitMateDo() |
 				\ endif
 	" Flush the char buffer:
 	autocmd InsertEnter * call delimitMate#FlushBuffer()
 	autocmd BufEnter *
 				\ if mode() == 'i' |
 				\ call delimitMate#FlushBuffer() |
 				\ endif
 augroup END
-"}}}
+let &cpo = save_cpo
 " GetLatestVimScripts: 2754 1 :AutoInstall: delimitMate.vim
-" vim:foldmethod=marker:foldcolumn=4
+" vim: sw=2 et
--- a/test/Makefile
+++ b/test/Makefile
@@ -0,0 +1,14 @@
 test_files := $(wildcard *.test)
 .PHONY: all monitor $(test_files)
 all:
 	time tclsh all.tcl
 $(test_files):
 	time tclsh $@
 	printf "\a"
 monitor:
 	fswatch -o ../autoload/*.vim ../plugin/*.vim *.test \
 		| xargs -n1 -I\{\} time tclsh all.tcl || printf "\a"
--- a/test/README.md
+++ b/test/README.md
@@ -0,0 +1,18 @@
 # Automatic test setup
 You can use `make` (or `make test` from the top level directory) to run the
 tests.
 # Manual test setup instructions
 The plugins [runVimTests](http://www.vim.org/scripts/script.php?script_id=2565)
 and [VimTAP](http://www.vim.org/scripts/script.php?script_id=2213) are needed
 to run these tests.
 Besides the `_setup.vim` configuration file present in this repo you need to
 create a global one and place it in the same dir where the runVimTests
 executable is located. Assuming the executable is at '~/bin/runVimTests' this
 global configuration file should be '~/bin/runVimTestsSetup.vim' and should
 have something like the following lines inside of it:
    " Prepend tests repos to &rtp
    let &runtimepath = '/path/to/runVimTests_dir,' . &rtp
    let &runtimepath = '/path/to/vimTAP_dir,' . &rtp
--- a/test/_setup.vim
+++ b/test/_setup.vim
@@ -0,0 +1,11 @@
 set bs=2
 set hidden
 set noshowmode
 set whichwrap=[]
 set noswapfile
 let &hl = join(map(split(&hl, ','), 'substitute(v:val, '':.\+'', ''n'', ''g'')'), ',')
 let &rtp = expand('<sfile>:p:h:h') . ',' . &rtp . ',' . expand('<sfile>:p:h:h') . '/after'
 let g:delimitMate_pairs = ['()','{}','[]','<>','¿?','¡!',',:']
 let g:delimitMate_quotes = ['"', "'", '`', '«', '|']
 ru plugin/delimitMate.vim
 au VimEnter * echom 'Start test'
--- a/test/all.tcl
+++ b/test/all.tcl
@@ -0,0 +1,18 @@
 package require tcltest 2
 namespace import -force ::tcltest::*
 configure {*}$argv -testdir [file dir [info script]]
 # Hook to determine if any of the tests failed. Then we can exit with
 # proper exit code: 0=all passed, 1=one or more failed
 proc tcltest::cleanupTestsHook {} {
 	variable numTests
 	upvar 2 testFileFailures crashed
 	set ::exitCode [expr {$numTests(Failed) > 0}]
 	if {[info exists crashed]} {
 		set ::exitCode [expr {$::exitCode || [llength $crashed]}]
 	}
 }
 runAllTests
 puts "\a"
 exit $exitCode
--- a/test/eol_marker.test
+++ b/test/eol_marker.test
@@ -0,0 +1,49 @@
 # singleTest name desc setup input result vimCmds? skipScript?
 #
 # - desc can be empty and input would be used.
 # - vimCmds is a list of ex commands.
 # - skipScript will be evaluated in the scope of the function "single" and it
 #   should return a keywowd such as toDo, badTest or other as listed in the
 #   docs for tcltest. e.g.:
 #     {expr "[string first {i'} \"${input}\"] > -1 ? {emptyTest} : {}"}
 # see tcltest documentation for other values.
 # Get some help:
 source helper.tcl
 set vimCmds [list {let g:delimitMate_expand_cr = 1}]
 lappend vimCmds {let g:delimitMate_eol_marker = ';'}
 lappend vimCmds {let g:delimitMate_insert_eol_marker = 0}
 single ins_eol_marker_0-1 {} "" "i(" "()" ${vimCmds}
 single ins_eol_marker_0-2 {} "" "i(\rx" "(\nx\n)" ${vimCmds}
 set vimCmds [list {let g:delimitMate_expand_cr = 1}]
 lappend vimCmds {let g:delimitMate_eol_marker = ';'}
 lappend vimCmds {let g:delimitMate_insert_eol_marker = 1}
 single ins_eol_marker_1-1 {} "" "i(" "();" ${vimCmds}
 single ins_eol_marker_1-2 {} " a" "0i(" "() a" ${vimCmds}
 single ins_eol_marker_1-3 {} "" "i(\rx" "(\nx\n);" ${vimCmds}
 set vimCmds [list {let g:delimitMate_expand_cr = 1}]
 lappend vimCmds {let g:delimitMate_eol_marker = ';'}
 lappend vimCmds {let g:delimitMate_insert_eol_marker = 2}
 single ins_eol_marker_2-1 {} "" "i(" "()" ${vimCmds}
 single ins_eol_marker_2-2 {} "" "i(\rx" "(\nx\n);" ${vimCmds}
 # Issue #195
 single issue_195-1 {} "" "i{(\rx" "{(\nx\n)}" ${vimCmds}
 # Issue #195
 single issue_195-2 {} ";" "I{(\rx" "{(\nx\n)};" ${vimCmds}
 ################################################################
 # This gives nice statistics and cleans up the mess left behind.
 cleanupTests
 # vim: set filetype=tcl et sw=2 sts=0 ts=8:
--- a/test/expand_cr.test
+++ b/test/expand_cr.test
@@ -0,0 +1,92 @@
 # singleTest name desc setup input result vimCmds? skipScript?
 #
 # - desc can be empty and input would be used.
 # - vimCmds is a list of ex commands.
 # - skipScript will be evaluated in the scope of the function "single" and it
 #   should return a keywowd such as toDo, badTest or other as listed in the
 #   docs for tcltest. e.g.:
 #     {expr "[string first {i'} \"${input}\"] > -1 ? {emptyTest} : {}"}
 # see tcltest documentation for other values.
 # Get some help:
 source helper.tcl
 set vimCmds [list {let g:delimitMate_expand_cr = 1}]
 #"let g:delimitMate_eol_marker = ';'
 lappend vimCmds {filetype indent on}
 lappend vimCmds {set bs=2 et sts=4 sw=4 ft=javascript}
 single javascript-1 {} "\$(document).ready(function() {})" "f{a\rx" \
    "\$(document).ready(function() {\n    x\n})" ${vimCmds}
 # Issue #95
 set vimCmds [list {let g:delimitMate_expand_cr = 1}]
 lappend vimCmds {let b:delimitMate_jump_expansion = 1}
 set skipScript {string cat toDo}
 single issue_95 {} "" "i(\rtest)x" "(\ntest\n)x" ${vimCmds} ${skipScript}
 # Remove CR expansion on BS
 set skipScript {string cat toDo}
 single bs {} "" "i(\r\bx" "(x)" ${vimCmds} ${skipScript}
 # Consider indentation with BS inside an empty CR expansion.
 single bs_indentation {} "" "i( \r\b\bx"  "(x)" ${vimCmds}
 # Conflict with indentation settings (cindent). Issue #95
 lappend vimCmds {se cindent}
 single issue_95 {} "sub foo {\n    while (1) {\n\n    }\n}" "3Gi\bx" \
      "sub foo {\n    while (1) {x}\n}" ${vimCmds}
 single nested_expansion-1 {} "sub foo {\n    while (1) {\n        bar\n    }\n}" \
      "3GA}x" "sub foo {\n    while (1) {\n        bar\n    }x\n}" ${vimCmds}
 single nested_expansion-2 {} "sub foo {\n    while (1) {\n        bar\n    }\n}" \
      "3GA{x" "sub foo {\n    while (1) {\n        bar{x}\n    }\n}" ${vimCmds}
 single bracketed {} "\"{bracketed}" "\033A\"x" "\"{bracketed}\"x" ${vimCmds}
 # Syntax folding enabled by autocmd breaks expansion.
 set vimCmds [list {let g:delimitMate_expand_cr = 1}]
 lappend vimCmds {se cindent}
 lappend vimCmds {set bs=2 et sts=4 sw=4}
 lappend vimCmds {autocmd InsertEnter <buffer> let w:fdm=&foldmethod \
    | setl foldmethod=manual}
 lappend vimCmds {autocmd InsertLeave <buffer> let &foldmethod = w:fdm}
 lappend vimCmds {set foldmethod=marker}
 lappend vimCmds {set foldmarker={,}}
 lappend vimCmds {set foldlevel=0}
 lappend vimCmds {set backspace=2}
 single folding {} "" "iabc {\rx" "abc {\n    x\n}" ${vimCmds}
 # expand_cr != 2}
 set vimCmds [list {let g:delimitMate_expand_cr = 1}]
 lappend vimCmds {se cindent}
 lappend vimCmds {set bs=2 et sts=4 sw=4 ft=javascript}
 lappend vimCmds {let b:delimitMate_jump_expansion = 1}
 single axpand_cr_no_2 {} "abc(def)" "\$i\rx" "abc(def\n        x)" ${vimCmds}
 # expand_cr == 2
 set vimCmds [list {let g:delimitMate_expand_cr = 2}]
 lappend vimCmds {se cindent}
 lappend vimCmds {set bs=2 et sts=4 sw=4 ft=javascript}
 lappend vimCmds {let b:delimitMate_jump_expansion = 1}
 single expand_cr_2 {} "abc(def)" "\$i\rx" "abc(def\n        x\n   )" ${vimCmds}
 # Play nice with smartindent
 set vimCmds [list {let g:delimitMate_expand_cr = 2}]
 lappend vimCmds {let b:delimitMate_jump_expansion = 1}
 lappend vimCmds {set smartindent}
 single smartindent-1 {} "" "i{\rx" "{\n	x\n}" ${vimCmds}
 single quotes-1 {} "" "i\" x" {" x"} ${vimCmds}
 single quotes-2 {} "" "i\"\rx" "\"\nx\"" ${vimCmds}
 lappend vimCmds {let g:delimitMate_expand_inside_quotes = 1}
 single quotes-3 {} "" "i\"\nx" "\"\nx\n\"" ${vimCmds}
 ################################################################
 # This gives nice statistics and cleans up the mess left behind.
 cleanupTests
 # vim: set filetype=tcl et sw=2 sts=0 ts=8:
--- a/test/expand_space.test
+++ b/test/expand_space.test
@@ -0,0 +1,48 @@
 # singleTest name desc setup input result vimCmds? skipScript?
 #
 # - desc can be empty and input would be used.
 # - vimCmds is a list of ex commands.
 # - skipScript will be evaluated in the scope of the function "single" and it
 #   should return a keywowd such as toDo, badTest or other as listed in the
 #   docs for tcltest. e.g.:
 #     {expr "[string first {i'} \"${input}\"] > -1 ? {emptyTest} : {}"}
 # see tcltest documentation for other values.
 # Get some help:
 source helper.tcl
 set vimCmds [list {let g:delimitMate_expand_space = 1}]
 lappend vimCmds {let g:delimitMate_autoclose = 1}
 pairs pairs-1 {} "" "i( x" "( x )" ${vimCmds}
 pairs pairs-2 {} "(  )" "la\bx" "(x)" ${vimCmds}
 pairs pairs-3 {} "" "iabc x" "abc x" ${vimCmds}
 quotes quotes-1 {} "" "i' x" "' x'" ${vimCmds}
 lappend vimCmds {let g:delimitMate_expand_inside_quotes = 1}
 quotes quotes-2 {} "" "i' x" "' x '" ${vimCmds}
 quotes quotes-3 {} "" "i' \bx" "'x'" ${vimCmds}
 set skipScript {string cat quoteBug}
 lappend vimCmds {let g:delimitMate_autoclose = 0}
 quotes quotes-4 {} "abc\\" "A'' x" "abc\\'' x '" ${vimCmds} ${skipScript}
 # Issue #95
 lappend vimCmds {let b:delimitMate_jump_expansion = 1}
 set skipScript {string cat toDo}
 pairs issue_95 {} "" "i( test)x" "( test )x" ${vimCmds} ${skipScript}
 pairs pairs-4 {} "" "i() \bx" "(x)" ${vimCmds}
 quotes quotes-5 {} "" "i'' \bx" "'x'" ${vimCmds}
 ################################################################
 # This gives nice statistics and cleans up the mess left behind.
 cleanupTests
 # vim: set filetype=tcl et sw=2 sts=0 ts=8:
--- a/test/helper.tcl
+++ b/test/helper.tcl
@@ -0,0 +1,125 @@
 if {[lsearch [namespace children] ::tcltest] == -1} {
  package require tcltest 2
  namespace import -force ::tcltest::*
 }
 configure -verbose {body error skip}
 #configure -verbose {start msec pass body error skip}
 set charMap [list    \
    "\""      "\\\"" \
    "\$"      "\\$"  \
    "\["      "\\\[" \
    "\]"      "\\\]" \
    "\\"      "\\\\" \
    "{"       "\\{"  \
    "}"       "\\}"  \
  ]
 # In order to skip a test pass a script that, when evaluated, returns emptyTest
 # for tests that can not pass, or knownBug for ToDo features. e.g.:
 #   {expr "[string first {i'} \"${input}\"] > -1 ? {emptyTest} : {}"}
 # see tcltest documentation for other values.
 proc single {name desc setup input result \
  {vimCmds {}}                            \
  {constr {}}                             \
  } {
  set fnamePrefix "test_${name}"
  global charMap
  makeFile ${setup} "${fnamePrefix}.in"
  makeFile {} "${fnamePrefix}.out"
  makeFile [join ${vimCmds} "\n"] "${fnamePrefix}.vim"
  set input [string map ${charMap} ${input}]
  #puts [lindex ${vimCmds} 0]
  set optCharMap [list {[} {\[} {]} {\]}]
  set vimArgs [lmap option ${vimCmds} \
      {string cat " -c \"[string map $charMap ${option}]\""}]
  set body [string cat "
  exec -- ./test.exp \"${fnamePrefix}\" \"${input}\"
  return \[viewFile \"${fnamePrefix}.out\"\]
  " ]
  #puts ${body}
  if {[string length ${desc}] eq 0} {
    set desc ${input}
  }
  if {[string length ${constr}] ne 0} {
    #puts ${constr}
    set constr [eval ${constr}]
    #puts ${constr}
  }
  set name "${name}:  \"${setup}\", \"${desc}\" ->"
  #puts $desc
  #puts $name
  test ${name}               \
      ${desc}                \
      -body ${body}          \
      -constraints ${constr} \
      -result ${result}
 }
 proc multi {items evalScript name desc setup input result \
  {vimCmds {}}                                            \
  {constr {}}                                             \
  } {
  global charMap
  set minor 0
  foreach item $items {
    incr minor
    eval ${evalScript}
    foreach var {desc setup input result} {
      set "the_${var}"   [string map ${aCharMap} [expr "$${var}"]]
    }
    set the_name "${name}.${minor}"
    single       \
        ${the_name}   \
        ${the_desc}   \
        ${the_setup}  \
        ${the_input}  \
        ${the_result} \
        ${vimCmds}    \
        ${constr}     \
  }
 }
 proc quotes {name desc setup input result \
  {vimCmds {}}                            \
  {constr {}}                             \
  } {
  set quotes [list {'} \" {`} {«} {|}]
  set mapScript {set aCharMap [list "'" ${item}]}
  multi       \
      ${quotes}    \
      ${mapScript} \
      ${name}      \
      ${desc}      \
      ${setup}     \
      ${input}     \
      ${result}    \
      ${vimCmds}   \
      ${constr}    \
 }
 proc pairs {name desc setup input result \
  {vimCmds {}}                           \
  {constr {}}                            \
  } {
  set pairs [list () \{\} \[\] <> ¿? ¡!  ,:]
  set mapScript {
    set left [string index ${item} 0]
    set right [string index ${item} 1]
    set aCharMap [list ( ${left} ) ${right}]
  }
  multi       \
      ${pairs}     \
      ${mapScript} \
      ${name}      \
      ${desc}      \
      ${setup}     \
      ${input}     \
      ${result}    \
      ${vimCmds}   \
      ${constr}    \
 }
 # vim: set filetype=tcl et sw=2 sts=0 ts=8:
--- a/test/pairs.test
+++ b/test/pairs.test
@@ -0,0 +1,153 @@
 # singleTest name desc setup input result vimCmds? skipScript?
 #
 # - desc can be empty and input would be used.
 # - vimCmds is a list of ex commands.
 # - skipScript will be evaluated in the scope of the function "single" and it
 #   should return a keywowd such as toDo, badTest or other as listed in the
 #   docs for tcltest. e.g.:
 #     {expr "[string first {i'} \"${input}\"] > -1 ? {emptyTest} : {}"}
 # see tcltest documentation for other values.
 # Get some help:
 source helper.tcl
 set vimCmds [list ]
 pairs autoclose-1 {} {} "i(" "()"
 pairs autoclose-2 {} {()} "a\b" ""
 pairs autoclose-3 {} "()" "a)x" "()x"
 set skipScript {string cat {toDo}}
 single jump_all {} "" "((<magic>x" "(())x" {} ${skipScript}
 pairs undo {} "" "i(x\033u" ""
 pairs autoclose-4 {} "" "i@(x" "@(x)"
 pairs autoclose-5 {} "@#" "a(x" "@(x)#"
 pairs autoclose-6 {} "\\" "a(x" "\\(x"
 pairs autoclose-7 {} "(\\)" "la)x" "(\\)x)"
 pairs autoclose-8 {} {"abc"} "ifoo(" "foo(\"abc\""
 set vimCmds [list {let g:delimitMate_autoclose = 0}]
 pairs noautoclose-1 {} "" "i(x" "(x" ${vimCmds}
 pairs noautoclose-2 {} "" "i()x" "(x)" ${vimCmds}
 pairs noautoclose-3 {} "" "i())x" "()x" ${vimCmds}
 pairs noautoclose-4 {} "" "i()\bx" "x" ${vimCmds}
 pairs noautoclose-5 {} "" "i@()x" "@(x)" ${vimCmds}
 pairs noautoclose-6 {} "@#" "a()x" "@(x)#" ${vimCmds}
 #" Handle backspace gracefully.
 set vimCmds [list {set backspace=}]
 pairs bad_bs {} "" "i(\033a\bx" "(x)" ${vimCmds}
 set vimCmds [list ]
 # closing parens removes characters. #133
 pairs autoclose-9 {} "(a)" "a)" "()a)" ${vimCmds}
 # Expand iabbreviations
 set vimCmds [list {iabb def ghi}]
 # Not sure how to make it work on the test
 pairs iabbr {} "" "idef(" "ghi()" ${vimCmds}
 set vimCmds [list ]
 pairs autoclose-10 {} {abc а} {$i(} {abc (а} ${vimCmds}
 pairs autoclose-11 {} "abc ñ" "\$i(" "abc (ñ" ${vimCmds}
 pairs autoclose-12 {} "abc \$" "\$i(" "abc (\$" ${vimCmds}
 pairs autoclose-13 {} "abc £" "\$i(" "abc (£" ${vimCmds}
 pairs autoclose-14 {} "abc d" "\$i(" "abc (d" ${vimCmds}
 pairs autoclose-15 {} "abc ." "\$i(" "abc ()." ${vimCmds}
 pairs autoclose-16 {} "abc  " "\$i(" "abc () " ${vimCmds}
 pairs autoclose-17 {} "abc (" "\$i(" "abc ((" ${vimCmds}
 # Play nice with undo.
 pairs undo {} "" "ia\007u(c)b\033u" "a" ${vimCmds}
 # TODO: way to jump over one or several closing chars
 set skipScript {string cat {toDo}}
 single jump_to {} "()" "a\<magic>x" "()x" ${vimCmds} ${skipScript}
 single jump_to {} "{()}" "la\\<magic>x" "{()}x" ${vimCmds} ${skipScript}
 set vimCmds [list {let g:delimitMate_balance_pairs = 0}]
 pairs no_balance_pairs-1 {} "ab cd)" "la(x" "ab(x) cd)" ${vimCmds}
 # Issue #229
 pairs issue_229-1 {} "((ab cd)" "\$i)x" "((ab cd)x" ${vimCmds}
 set vimCmds [list ]
 set vimCmds [list {let g:delimitMate_balance_pairs = 1}]
 pairs issue_229-2 {} "ab cd)" "la(x" "ab(x cd)" ${vimCmds}
 # Issue #229
 pairs issue_229-3 {} "((ab cd)" "\$i)x" "((ab cd)x)" ${vimCmds}
 # Issue #220
 set vimCmds [list {let g:delimitMate_jump_next = 0}]
 pairs issue_220-1 {} "()" "a)" "())" ${vimCmds}
 # Issues #207 and #223
 set vimCmds [list {let g:delimitMate_jump_long = 1}]
 pairs jump_long-1 {} "{\[(foobar)\]}" "fbi)x" "{\[(foobar)x\]}" ${vimCmds}
 # Issues #207 and #223
 set skipScript {expr "[string first {[[foobar]]} \"${setup}\"] > -1 \
    ? {badTest} : {}"}
 single jump_long-2 {} "{\[(foobar)\]}" "fbi\]x" "{\[(foobar)\]x}" ${vimCmds} ${skipScript}
 # Issues #207 and #223
 set skipScript {string cat {toDo}}
 set vimCmds [list {let g:delimitMate_jump_all = 1}]
 single issues_207_223 {} "{\[(foobar)\]}" "fbi<magic>x" "{\[(foobar)\]}x" \
    ${vimCmds} ${skipScript}
 set vimCmds [list {let g:delimitMate_jump_back = 1}]
 pairs jump_back {} "" "i()x" "()x" ${vimCmds}
 # Disable on syntax groups
 set vimCmds [list {syntax on}]
 lappend vimCmds {set ft=vim}
 lappend vimCmds {let g:delimitMate_excluded_regions = ['String']}
 pairs ignore_syntax {} {echo "  "} "f\"la(" {echo " ( "} ${vimCmds}
 #" Issue #160
 set vimCmds [list {filetype indent plugin on}]
 lappend vimCmds {set ft=php}
 set skipScript {string cat {toDo}}
 single issue_160 {} "<?php incl" "A\x18\x0F\x19" "<?php include()" \
    ${vimCmds} ${skipScript}
 set vimCmds [list ]
 # Play nice with redo
 pairs redo {} "abc " "Afoo(x\033." "abc foo(x)foo(x)" ${vimCmds}
 pairs smart {} {""} "0a(x" {"(x"}
 pairs smart {} {""} "0a()x" {"(x)"}
 ################################################################
 # This gives nice statistics and cleans up the mess left behind.
 cleanupTests
 # vim: set filetype=tcl et sw=2 sts=0 ts=8:
--- a/test/quotes.test
+++ b/test/quotes.test
@@ -0,0 +1,107 @@
 # singleTest name desc setup input result vimCmds? skipScript?
 #
 # - desc can be empty and input would be used.
 # - vimCmds is a list of ex commands.
 # - skipScript will be evaluated in the scope of the function "single" and it
 #   should return a keywowd such as toDo, badTest or other as listed in the
 #   docs for tcltest. e.g.:
 #     {expr "[string first {i'} \"${input}\"] > -1 ? {emptyTest} : {}"}
 # see tcltest documentation for other values.
 # Get some help:
 source helper.tcl
 quotes autoclose-1 {} {} "i'x" "'x'"
 quotes autoclose-2 {} {} "i'x\033u" {}
 quotes autoclose-3 {} {} {i''x} {''x}
 quotes autoclose-4 {} {''} "a\bx" {x}
 set skipScript {expr "[string first {i\"} \"${input}\"] > -1 ? {badTest} : {}"}
 quotes autoclose-5 {} "" "i'x\"" "'x\"'" {} ${skipScript}
 quotes autoclose-6 {} {} "i@'x" "@'x'"
 quotes autoclose-7 {} {@#} "a'x" "@'x'#"
 #quotes autoclose-8 {} {} "'\<S-Tab>x" "''x"
 single autoclose-8 {} {abc'} "A'" "abc'" {} {string cat toDo}
 quotes autoclose-9 {} "abc\\" "A'x" {abc\'x}
 quotes autoclose-10 {} {} "au'Привет'" "u'Привет'"
 quotes autoclose-11 {} {} "au'string'" "u'string'"
 set vimCmds [list {let g:delimitMate_autoclose = 0}]
 quotes noautoclose-1 {} {} "a'x" "'x" ${vimCmds}
 quotes noautoclose-2 {} {} "a''x" "'x'" ${vimCmds}
 quotes noautoclose-3 {} {} "a'''x" "''x" ${vimCmds}
 quotes noautoclose-4 {} {} "a''\bx" "x" ${vimCmds}
 quotes noautoclose-5 {} {} "a@''x" "@'x'" ${vimCmds}
 quotes noautoclose-6 {} "@#" "a''x" "@'x'#" ${vimCmds}
 set vimCmds [list {let g:delimitMate_autoclose = 1}]
 # Handle backspace gracefully.
 lappend vimCmds {set backspace=}
 quotes badBS-1 {} {} "a'\033a\bx" "'x'" ${vimCmds}
 set vimCmds [list {set cpo=ces$}]
 quotes cpo {} {} "a'x" "'x'" ${vimCmds}
 # Make sure smart quote works beyond first column.
 quotes beyond_first_column {} { } "a'x" " 'x'"
 # smart quote, check fo char on the right.
 quotes smart_quote-1 {} "a b" "la'" "a 'b"
 # Make sure we jump over a quote on the right. #89.
 quotes autoclose-12 {} {} "a('test'x" "('test'x)"
 # Duplicate whole line when inserting quote at bol #105
 quotes autoclose-13 {} "}" "i'" "''}"
 quotes autoclose-14 {} "'abc  " "A'" "'abc  '"
 quotes autoclose-15 {} "''abc " "A'" "''abc ''"
 # Nesting quotes:
 set vimCmds [list {let g:delimitMate_nesting_quotes = delimitMate#option('quotes')}]
 quotes nesting-1 {} "''" "A'x" "'''x'''" ${vimCmds}
 quotes nesting-2 {} "'''" "A'x" "''''x''''" ${vimCmds}
 quotes nesting-3 {} {} "i''x" "''x" ${vimCmds}
 quotes nesting-4 {} {} "i'x" "'x'" ${vimCmds}
 set vimCmds [list]
 # expand iabbreviations
 set vimCmds [list {iabb def ghi}]
 single iabbr {} {} {idef"} {ghi"} ${vimCmds}
 set vimCmds [list]
 quotes autoclose-16 {} {} "i'\n\b" "''"
 # Double quote starts a comment in viml
 set vimCmds [list {set ft=vim}]
 single vim_comment {} {} {i"} {"} ${vimCmds}
 #" Allow quote to exit from string when disabled by syntax group.
 set vimCmds [list {syntax on}]
 quotes disabled_syntax {} "'abc'" "\$i'x" "'abc'x" ${vimCmds}
 # --------
 # This gives nice statistics and cleans up the mess left behind.
 cleanupTests
 # vim: set filetype=tcl et sw=2 sts=0 ts=8:
--- a/test/test.exp
+++ b/test/test.exp
@@ -0,0 +1,20 @@
 #!/usr/bin/env expect -f
 set testName [lindex $argv 0]
 set filein "${testName}.in"
 set fileout "${testName}.out"
 set input [lindex $argv 1]
 set timeout 2
 spawn env TERM=dumb vim -N -i NONE -u _setup.vim -S "${testName}.vim" -- ${filein}
 match_max 100000
 expect -exact "Start test"
 foreach char [split ${input} {}] {
 	send -- "${char}"
 	sleep .01
 }
 send -- " "
 sleep .01
 send -- ":w! ${fileout}\r"
 send -- ":qa!\r"
 expect eof