Anonymous avatar Anonymous committed fea2aeb

now have an install script

Comments (0)

Files changed (8)

 syntax glob:
-.*

.vim/colors/vividchalk.vim

-" Vim color scheme
-" Name:         vividchalk.vim
-" Author:       Tim Pope <vimNOSPAM@tpope.info>
-" GetLatestVimScripts: 1891 1 :AutoInstall: vividchalk.vim
-" $Id: vividchalk.vim,v 1.8 2007-07-11 18:50:16 tpope Exp $
-
-" Based on the Vibrank Ink theme for TextMate
-" Distributable under the same terms as Vim itself (see :help license)
-
-if has("gui_running")
-    set background=dark
-endif
-hi clear
-if exists("syntax_on")
-   syntax reset
-endif
-
-let colors_name = "vividchalk"
-
-" First two functions adapted from inkpot.vim
-
-" map a urxvt cube number to an xterm-256 cube number
-fun! s:M(a)
-    return strpart("0245", a:a, 1) + 0
-endfun
-
-" map a urxvt colour to an xterm-256 colour
-fun! s:X(a)
-    if &t_Co == 88
-        return a:a
-    else
-        if a:a == 8
-            return 237
-        elseif a:a < 16
-            return a:a
-        elseif a:a > 79
-            return 232 + (3 * (a:a - 80))
-        else
-            let l:b = a:a - 16
-            let l:x = l:b % 4
-            let l:y = (l:b / 4) % 4
-            let l:z = (l:b / 16)
-            return 16 + s:M(l:x) + (6 * s:M(l:y)) + (36 * s:M(l:z))
-        endif
-    endif
-endfun
-
-function! E2T(a)
-    return s:X(a:a)
-endfunction
-
-function! s:choose(mediocre,good)
-    if &t_Co != 88 && &t_Co != 256
-        return a:mediocre
-    else
-        return s:X(a:good)
-    endif
-endfunction
-
-function! s:hifg(group,guifg,first,second,...)
-    if a:0 && &t_Co == 256
-        let ctermfg = a:1
-    else
-        let ctermfg = s:choose(a:first,a:second)
-    endif
-    exe "highlight ".a:group." guifg=".a:guifg." ctermfg=".ctermfg
-endfunction
-
-function! s:hibg(group,guibg,first,second)
-    let ctermbg = s:choose(a:first,a:second)
-    exe "highlight ".a:group." guibg=".a:guibg." ctermbg=".ctermbg
-endfunction
-
-hi link railsMethod         PreProc
-hi link rubyDefine          Keyword
-hi link rubySymbol          Constant
-hi link rubyAccess          rubyMethod
-hi link rubyAttribute       rubyMethod
-hi link rubyEval            rubyMethod
-hi link rubyException       rubyMethod
-hi link rubyInclude         rubyMethod
-hi link rubyStringDelimiter rubyString
-hi link rubyRegexp          Regexp
-hi link rubyRegexpDelimiter rubyRegexp
-"hi link rubyConstant        Variable
-"hi link rubyGlobalVariable  Variable
-"hi link rubyClassVariable   Variable
-"hi link rubyInstanceVariable Variable
-hi link javascriptRegexpString  Regexp
-hi link javascriptNumber        Number
-hi link javascriptNull          Constant
-
-call s:hifg("Normal","#EEEEEE","White",87)
-if &background == "light" || has("gui_running")
-    hi Normal guibg=Black ctermbg=Black
-else
-    hi Normal guibg=Black ctermbg=NONE
-endif
-highlight StatusLine    guifg=Black   guibg=#aabbee gui=bold ctermfg=Black ctermbg=White  cterm=bold
-highlight StatusLineNC  guifg=#444444 guibg=#aaaaaa gui=none ctermfg=Black ctermbg=Grey   cterm=none
-"if &t_Co == 256
-    "highlight StatusLine ctermbg=117
-"else
-    "highlight StatusLine ctermbg=43
-"endif
-highlight WildMenu      guifg=Black   guibg=#ffff00 gui=bold ctermfg=Black ctermbg=Yellow cterm=bold
-highlight Cursor        guifg=Black guibg=White ctermfg=Black ctermbg=White
-highlight CursorLine    guibg=#333333 guifg=NONE
-highlight CursorColumn  guibg=#333333 guifg=NONE
-highlight NonText       guifg=#404040 ctermfg=8
-highlight SpecialKey    guifg=#404040 ctermfg=8
-highlight Directory     none
-high link Directory     Identifier
-highlight ErrorMsg      guibg=Red ctermbg=DarkRed guifg=NONE ctermfg=NONE
-highlight Search        guifg=NONE ctermfg=NONE gui=none cterm=none
-call s:hibg("Search"    ,"#555555","Black",81)
-highlight IncSearch     guifg=White guibg=Black ctermfg=White ctermbg=Black
-highlight MoreMsg       guifg=#00AA00 ctermfg=Green
-highlight LineNr        guifg=#DDEEFF ctermfg=White
-call s:hibg("LineNr"    ,"#222222","DarkBlue",80)
-highlight Question      none
-high link Question      MoreMsg
-highlight Title         guifg=Magenta ctermfg=Magenta
-highlight VisualNOS     gui=none cterm=none
-call s:hibg("Visual"    ,"#555577","LightBlue",83)
-call s:hibg("VisualNOS" ,"#444444","DarkBlue",81)
-highlight WarningMsg    guifg=Red ctermfg=Red
-highlight Folded        guibg=#1100aa ctermbg=DarkBlue
-call s:hibg("Folded"    ,"#110077","DarkBlue",17)
-call s:hifg("Folded"    ,"#aaddee","LightCyan",63)
-highlight FoldColumn    none
-high link FoldColumn    Folded
-highlight Pmenu         guifg=White ctermfg=White gui=bold cterm=bold
-highlight PmenuSel      guifg=White ctermfg=White gui=bold cterm=bold
-call s:hibg("Pmenu"     ,"#000099","Blue",18)
-call s:hibg("PmenuSel"  ,"#5555ff","DarkCyan",39)
-highlight PmenuSbar     guibg=Grey ctermbg=Grey
-highlight PmenuThumb    guibg=White ctermbg=White
-highlight TabLine       gui=underline cterm=underline
-call s:hifg("TabLine"   ,"#bbbbbb","LightGrey",85)
-call s:hibg("TabLine"   ,"#333333","DarkGrey",80)
-highlight TabLineSel    guifg=White guibg=Black ctermfg=White ctermbg=Black
-highlight TabLineFill   gui=underline cterm=underline
-call s:hifg("TabLineFill","#bbbbbb","LightGrey",85)
-call s:hibg("TabLineFill","#808080","Grey",83)
-
-hi Type gui=none
-hi Statement gui=none
-if !has("gui_mac")
-    " Mac GUI degrades italics to ugly underlining.
-    hi Comment gui=italic
-    hi railsUserClass  gui=italic
-    hi railsUserMethod gui=italic
-endif
-hi Identifier cterm=none
-" Commented numbers at the end are *old* 256 color values
-"highlight PreProc       guifg=#EDF8F9
-call s:hifg("Comment"        ,"#9933CC","DarkMagenta",34) " 92
-" 26 instead?
-call s:hifg("Constant"       ,"#339999","DarkCyan",21) " 30
-call s:hifg("rubyNumber"     ,"#CCFF33","Yellow",60) " 190
-call s:hifg("String"         ,"#66FF00","LightGreen",44,82) " 82
-call s:hifg("Identifier"     ,"#FFCC00","Yellow",72) " 220
-call s:hifg("Statement"      ,"#FF6600","Brown",68) " 202
-call s:hifg("PreProc"        ,"#AAFFFF","LightCyan",47) " 213
-call s:hifg("railsUserMethod","#AACCFF","LightCyan",27)
-call s:hifg("Type"           ,"#AAAA77","Grey",57) " 101
-call s:hifg("railsUserClass" ,"#AAAAAA","Grey",7) " 101
-call s:hifg("Special"        ,"#33AA00","DarkGreen",24) " 7
-call s:hifg("Regexp"         ,"#44B4CC","DarkCyan",21) " 74
-call s:hifg("rubyMethod"     ,"#DDE93D","Yellow",77) " 191
-"highlight railsMethod   guifg=#EE1122 ctermfg=1

.vim/plugin/NERD_tree.vim

-" ============================================================================
-" File:        NERD_tree.vim
-" Description: vim global plugin that provides a nice tree explorer
-" Maintainer:  Martin Grenfell <martin_grenfell at msn dot com>
-" Last Change: 29 October, 2008
-" License:     This program is free software. It comes without any warranty,
-"              to the extent permitted by applicable law. You can redistribute
-"              it and/or modify it under the terms of the Do What The Fuck You
-"              Want To Public License, Version 2, as published by Sam Hocevar.
-"              See http://sam.zoy.org/wtfpl/COPYING for more details.
-"
-" ============================================================================
-let s:NERD_tree_version = '2.14.2'
-
-" SECTION: Script init stuff {{{1
-"============================================================
-if exists("loaded_nerd_tree")
-    finish
-endif
-if v:version < 700
-    echoerr "NERDTree: this plugin requires vim >= 7. DOWNLOAD IT! You'll thank me later!"
-    finish
-endif
-let loaded_nerd_tree = 1
-
-"for line continuation - i.e dont want C in &cpo
-let s:old_cpo = &cpo
-set cpo&vim
-
-"Function: s:initVariable() function {{{2
-"This function is used to initialise a given variable to a given value. The
-"variable is only initialised if it does not exist prior
-"
-"Args:
-"var: the name of the var to be initialised
-"value: the value to initialise var to
-"
-"Returns:
-"1 if the var is set, 0 otherwise
-function! s:initVariable(var, value)
-    if !exists(a:var)
-        exec 'let ' . a:var . ' = ' . "'" . a:value . "'"
-        return 1
-    endif
-    return 0
-endfunction
-
-"SECTION: Init variable calls and other random constants {{{2
-call s:initVariable("g:NERDChristmasTree", 1)
-call s:initVariable("g:NERDTreeAutoCenter", 1)
-call s:initVariable("g:NERDTreeAutoCenterThreshold", 3)
-call s:initVariable("g:NERDTreeCaseSensitiveSort", 0)
-call s:initVariable("g:NERDTreeChDirMode", 0)
-if !exists("g:NERDTreeIgnore")
-    let g:NERDTreeIgnore = ['\~$']
-endif
-call s:initVariable("g:NERDTreeHighlightCursorline", 1)
-call s:initVariable("g:NERDTreeBookmarksFile", expand('$HOME') . '/.NERDTreeBookmarks')
-call s:initVariable("g:NERDTreeMouseMode", 1)
-call s:initVariable("g:NERDTreeNotificationThreshold", 100)
-call s:initVariable("g:NERDTreeQuitOnOpen", 0)
-call s:initVariable("g:NERDTreeShowBookmarks", 0)
-call s:initVariable("g:NERDTreeShowFiles", 1)
-call s:initVariable("g:NERDTreeShowHidden", 0)
-call s:initVariable("g:NERDTreeShowLineNumbers", 0)
-call s:initVariable("g:NERDTreeSortDirs", 1)
-
-if !exists("g:NERDTreeSortOrder")
-    let g:NERDTreeSortOrder = ['\/$', '*', '\.swp$',  '\.bak$', '\~$']
-else
-    "if there isnt a * in the sort sequence then add one
-    if count(g:NERDTreeSortOrder, '*') < 1
-        call add(g:NERDTreeSortOrder, '*')
-    endif
-endif
-
-"we need to use this number many times for sorting... so we calculate it only
-"once here
-let s:NERDTreeSortStarIndex = index(g:NERDTreeSortOrder, '*')
-
-call s:initVariable("g:NERDTreeWinPos", "left")
-call s:initVariable("g:NERDTreeWinSize", 31)
-
-let s:running_windows = has("win16") || has("win32") || has("win64")
-
-"init the shell commands that will be used to copy nodes, and remove dir trees
-"
-"Note: the space after the command is important
-if s:running_windows
-    call s:initVariable("g:NERDTreeRemoveDirCmd", 'rmdir /s /q ')
-else
-    call s:initVariable("g:NERDTreeRemoveDirCmd", 'rm -rf ')
-    call s:initVariable("g:NERDTreeCopyCmd", 'cp -r ')
-endif
-
-
-"SECTION: Init variable calls for key mappings {{{2
-call s:initVariable("g:NERDTreeMapActivateNode", "o")
-call s:initVariable("g:NERDTreeMapChangeRoot", "C")
-call s:initVariable("g:NERDTreeMapChdir", "cd")
-call s:initVariable("g:NERDTreeMapCloseChildren", "X")
-call s:initVariable("g:NERDTreeMapCloseDir", "x")
-call s:initVariable("g:NERDTreeMapDeleteBookmark", "D")
-call s:initVariable("g:NERDTreeMapExecute", "!")
-call s:initVariable("g:NERDTreeMapFilesystemMenu", "m")
-call s:initVariable("g:NERDTreeMapHelp", "?")
-call s:initVariable("g:NERDTreeMapJumpFirstChild", "K")
-call s:initVariable("g:NERDTreeMapJumpLastChild", "J")
-call s:initVariable("g:NERDTreeMapJumpNextSibling", "<C-j>")
-call s:initVariable("g:NERDTreeMapJumpParent", "p")
-call s:initVariable("g:NERDTreeMapJumpPrevSibling", "<C-k>")
-call s:initVariable("g:NERDTreeMapJumpRoot", "P")
-call s:initVariable("g:NERDTreeMapOpenExpl", "e")
-call s:initVariable("g:NERDTreeMapOpenInTab", "t")
-call s:initVariable("g:NERDTreeMapOpenInTabSilent", "T")
-call s:initVariable("g:NERDTreeMapOpenRecursively", "O")
-call s:initVariable("g:NERDTreeMapOpenSplit", "<tab>")
-call s:initVariable("g:NERDTreeMapPreview", "g" . NERDTreeMapActivateNode)
-call s:initVariable("g:NERDTreeMapPreviewSplit", "g" . NERDTreeMapOpenSplit)
-call s:initVariable("g:NERDTreeMapQuit", "q")
-call s:initVariable("g:NERDTreeMapRefresh", "r")
-call s:initVariable("g:NERDTreeMapRefreshRoot", "R")
-call s:initVariable("g:NERDTreeMapToggleBookmarks", "B")
-call s:initVariable("g:NERDTreeMapToggleFiles", "F")
-call s:initVariable("g:NERDTreeMapToggleFilters", "f")
-call s:initVariable("g:NERDTreeMapToggleHidden", "H")
-call s:initVariable("g:NERDTreeMapUpdir", "u")
-call s:initVariable("g:NERDTreeMapUpdirKeepOpen", "U")
-
-"SECTION: Script level variable declaration{{{2
-let s:escape_chars =  " \\`\|\"#%&,?()\*^<>"
-let s:NERDTreeWinName = '_NERD_tree_'
-
-let s:tree_wid = 2
-let s:tree_markup_reg = '^[ `|]*[\-+~]'
-let s:tree_up_dir_line = '.. (up a dir)'
-
-let s:os_slash = '/'
-if s:running_windows
-    let s:os_slash = '\'
-endif
-
-" SECTION: Commands {{{1
-"============================================================
-"init the command that users start the nerd tree with
-command! -n=? -complete=dir NERDTree :call s:initNerdTree('<args>')
-command! -n=? -complete=dir NERDTreeToggle :call s:toggle('<args>')
-command! -n=0 NERDTreeClose :call s:closeTreeIfOpen()
-command! -n=1 -complete=customlist,s:completeBookmarks NERDTreeFromBookmark call s:initNerdTree('<args>')
-" SECTION: Auto commands {{{1
-"============================================================
-"Save the cursor position whenever we close the nerd tree
-exec "autocmd BufWinLeave *". s:NERDTreeWinName ." call <SID>saveScreenState()"
-"cache bookmarks when vim loads
-autocmd VimEnter * call s:Bookmark.CacheBookmarks(0)
-
-"SECTION: Classes {{{1
-"============================================================
-"CLASS: Bookmark {{{2
-"============================================================
-let s:Bookmark = {}
-" FUNCTION: Bookmark.AddBookmark(name, path) {{{3
-" Class method to add a new bookmark to the list, if a previous bookmark exists
-" with the same name, just update the path for that bookmark
-function! s:Bookmark.AddBookmark(name, path)
-    for i in s:Bookmark.Bookmarks()
-        if i.name == a:name
-            let i.path = a:path
-            return
-        endif
-    endfor
-    call add(s:Bookmark.Bookmarks(), s:Bookmark.New(a:name, a:path))
-    call s:Bookmark.Sort()
-endfunction
-" Function: Bookmark.Bookmarks()   {{{3
-" Class method to get all bookmarks. Lazily initializes the bookmarks global
-" variable
-function! s:Bookmark.Bookmarks()
-    if !exists("g:NERDTreeBookmarks")
-        let g:NERDTreeBookmarks = []
-    endif
-    return g:NERDTreeBookmarks
-endfunction
-" Function: Bookmark.BookmarkExistsFor(name)   {{{3
-" class method that returns 1 if a bookmark with the given name is found, 0
-" otherwise
-function! s:Bookmark.BookmarkExistsFor(name)
-    try
-        call s:Bookmark.BookmarkFor(a:name)
-        return 1
-    catch /NERDTree.BookmarkNotFound/
-        return 0
-    endtry
-endfunction
-" Function: Bookmark.BookmarkFor(name)   {{{3
-" Class method to get the bookmark that has the given name. {} is return if no
-" bookmark is found
-function! s:Bookmark.BookmarkFor(name)
-    for i in s:Bookmark.Bookmarks()
-        if i.name == a:name
-            return i
-        endif
-    endfor
-    throw "NERDTree.BookmarkNotFound exception: no bookmark found for name: \"". a:name  .'"'
-endfunction
-" Function: Bookmark.BookmarkNames()   {{{3
-" Class method to return an array of all bookmark names
-function! s:Bookmark.BookmarkNames()
-    let names = []
-    for i in s:Bookmark.Bookmarks()
-        call add(names, i.name)
-    endfor
-    return names
-endfunction
-" FUNCTION: Bookmark.CacheBookmarks(silent) {{{3
-" Class method to read all bookmarks from the bookmarks file intialize
-" bookmark objects for each one.
-"
-" Args:
-" silent - dont echo an error msg if invalid bookmarks are found
-function! s:Bookmark.CacheBookmarks(silent)
-    if filereadable(g:NERDTreeBookmarksFile)
-        let g:NERDTreeBookmarks = []
-        let g:NERDTreeInvalidBookmarks = []
-        let bookmarkStrings = readfile(g:NERDTreeBookmarksFile)
-        let invalidBookmarksFound = 0
-        for i in bookmarkStrings
-
-            "ignore blank lines
-            if i != ''
-
-                let name = substitute(i, '^\(.\{-}\) .*$', '\1', '')
-                let path = substitute(i, '^.\{-} \(.*\)$', '\1', '')
-
-                try
-                    let bookmark = s:Bookmark.New(name, s:Path.New(path))
-                    call add(g:NERDTreeBookmarks, bookmark)
-                catch /NERDTree.Path.InvalidArguments/
-                    call add(g:NERDTreeInvalidBookmarks, i)
-                    let invalidBookmarksFound += 1
-                endtry
-            endif
-        endfor
-        if invalidBookmarksFound
-            call s:Bookmark.Write()
-            if !a:silent
-                call s:echo(invalidBookmarksFound . " invalid bookmarks were read. See :help NERDTreeInvalidBookmarks for info.")
-            endif
-        endif
-        call s:Bookmark.Sort()
-    endif
-endfunction
-" FUNCTION: Bookmark.compareTo(otherbookmark) {{{3
-" Compare these two bookmarks for sorting purposes
-function! s:Bookmark.compareTo(otherbookmark)
-    return a:otherbookmark.name < self.name
-endfunction
-" FUNCTION: Bookmark.ClearAll() {{{3
-" Class method to delete all bookmarks.
-function! s:Bookmark.ClearAll()
-    for i in s:Bookmark.Bookmarks()
-        call i.delete()
-    endfor
-    call s:Bookmark.Write()
-endfunction
-" FUNCTION: Bookmark.delete() {{{3
-" Delete this bookmark. If the node for this bookmark is under the current
-" root, then recache bookmarks for its Path object
-function! s:Bookmark.delete()
-    let node = {}
-    try
-        let node = self.getNode(1)
-    catch /NERDTree.BookmarkedNodeNotFound/
-    endtry
-    call remove(s:Bookmark.Bookmarks(), index(s:Bookmark.Bookmarks(), self))
-    if !empty(node)
-        call node.path.cacheDisplayString()
-    endif
-    call s:Bookmark.Write()
-endfunction
-" FUNCTION: Bookmark.getNode(searchFromAbsoluteRoot) {{{3
-" Gets the treenode for this bookmark
-"
-" Args:
-" searchFromAbsoluteRoot: specifies whether we should search from the current
-" tree root, or the highest cached node
-function! s:Bookmark.getNode(searchFromAbsoluteRoot)
-    let searchRoot = a:searchFromAbsoluteRoot ? s:TreeDirNode.AbsoluteTreeRoot() : t:NERDTreeRoot
-    let targetNode = searchRoot.findNode(self.path)
-    if empty(targetNode)
-        throw "NERDTree.BookmarkedNodeNotFound no node was found for bookmark: " . self.name
-    endif
-    return targetNode
-endfunction
-" FUNCTION: Bookmark.GetNodeForName(name, searchFromAbsoluteRoot) {{{3
-" Class method that finds the bookmark with the given name and returns the
-" treenode for it.
-function! s:Bookmark.GetNodeForName(name, searchFromAbsoluteRoot)
-    let bookmark = s:Bookmark.BookmarkFor(a:name)
-    return bookmark.getNode(a:searchFromAbsoluteRoot)
-endfunction
-" Function: Bookmark.InvalidBookmarks()   {{{3
-" Class method to get all invalid bookmark strings read from the bookmarks
-" file
-function! s:Bookmark.InvalidBookmarks()
-    if !exists("g:NERDTreeInvalidBookmarks")
-        let g:NERDTreeInvalidBookmarks = []
-    endif
-    return g:NERDTreeInvalidBookmarks
-endfunction
-" FUNCTION: Bookmark.mustExist() {{{3
-function! s:Bookmark.mustExist()
-    if !self.path.exists()
-        call s:Bookmark.CacheBookmarks(1)
-        throw "NERDTree.BookmarkPointsToInvalidLocation exception: the bookmark \"".
-            \ self.name ."\" points to a non existing location: \"". self.path.strForOS(0)
-    endif
-endfunction
-" FUNCTION: Bookmark.New(name, path) {{{3
-" Create a new bookmark object with the given name and path object
-function! s:Bookmark.New(name, path)
-    if a:name =~ ' '
-        throw "NERDTree.IllegalBookmarkName illegal name:" . a:name
-    endif
-
-    let newBookmark = copy(self)
-    let newBookmark.name = a:name
-    let newBookmark.path = a:path
-    return newBookmark
-endfunction
-" Function: Bookmark.setPath(path)   {{{3
-" makes this bookmark point to the given path
-function! s:Bookmark.setPath(path)
-    let self.path = a:path
-endfunction
-" Function: Bookmark.Sort()   {{{3
-" Class method that sorts all bookmarks
-function! s:Bookmark.Sort()
-    let CompareFunc = function("s:compareBookmarks")
-    call sort(s:Bookmark.Bookmarks(), CompareFunc)
-endfunction
-" Function: Bookmark.str()   {{{3
-" Get the string that should be rendered in the view for this bookmark
-function! s:Bookmark.str()
-    let pathStrMaxLen = winwidth(s:getTreeWinNum()) - 4 - len(self.name)
-    if &nu
-        let pathStrMaxLen = pathStrMaxLen - &numberwidth
-    endif
-
-    let pathStr = self.path.strForOS(0)
-    if len(pathStr) > pathStrMaxLen
-        let pathStr = '<' . strpart(pathStr, len(pathStr) - pathStrMaxLen)
-    endif
-    return '>' . self.name . ' ' . pathStr
-endfunction
-" FUNCTION: Bookmark.toRoot() {{{3
-" Make the node for this bookmark the new tree root
-function! s:Bookmark.toRoot()
-    if self.validate()
-        try
-            let targetNode = self.getNode(1)
-        catch /NERDTree.BookmarkedNodeNotFound/
-            let targetNode = s:TreeFileNode.New(s:Bookmark.BookmarkFor(self.name).path)
-        endtry
-        call targetNode.makeRoot()
-        call s:renderView()
-        call s:putCursorOnNode(targetNode, 0, 0)
-    endif
-endfunction
-" FUNCTION: Bookmark.ToRoot(name) {{{3
-" Make the node for this bookmark the new tree root
-function! s:Bookmark.ToRoot(name)
-    let bookmark = s:Bookmark.BookmarkFor(a:name)
-    call bookmark.toRoot()
-endfunction
-
-
-"FUNCTION: Bookmark.validate() {{{3
-function! s:Bookmark.validate()
-    if self.path.exists()
-        return 1
-    else
-        call s:Bookmark.CacheBookmarks(1)
-        call s:renderView()
-        call s:echo(self.name . "now points to an invalid location. See :help NERDTreeInvalidBookmarks for info.")
-        return 0
-    endif
-endfunction
-
-" Function: Bookmark.Write()   {{{3
-" Class method to write all bookmarks to the bookmarks file
-function! s:Bookmark.Write()
-    let bookmarkStrings = []
-    for i in s:Bookmark.Bookmarks()
-        call add(bookmarkStrings, i.name . ' ' . i.path.strForOS(0))
-    endfor
-
-    "add a blank line before the invalid ones
-    call add(bookmarkStrings, "")
-
-    for j in s:Bookmark.InvalidBookmarks()
-        call add(bookmarkStrings, j)
-    endfor
-    call writefile(bookmarkStrings, g:NERDTreeBookmarksFile)
-endfunction
-"CLASS: TreeFileNode {{{2
-"This class is the parent of the TreeDirNode class and constitures the
-"'Component' part of the composite design pattern between the treenode
-"classes.
-"============================================================
-let s:TreeFileNode = {}
-"FUNCTION: TreeFileNode.bookmark(name) {{{3
-"bookmark this node with a:name
-function! s:TreeFileNode.bookmark(name)
-    try
-        let oldMarkedNode = s:Bookmark.GetNodeForName(a:name, 1)
-        call oldMarkedNode.path.cacheDisplayString()
-    catch /NERDTree.Bookmark\(DoesntExist\|NotFound\)/
-    endtry
-
-    call s:Bookmark.AddBookmark(a:name, self.path)
-    call self.path.cacheDisplayString()
-    call s:Bookmark.Write()
-endfunction
-"FUNCTION: TreeFileNode.cacheParent() {{{3
-"initializes self.parent if it isnt already
-function! s:TreeFileNode.cacheParent()
-    if empty(self.parent)
-        let parentPath = self.path.getParent()
-        if parentPath.equals(self.path)
-            throw "NERDTree.CannotCacheParent exception: already at root"
-        endif
-        let self.parent = s:TreeFileNode.New(parentPath)
-    endif
-endfunction
-"FUNCTION: TreeFileNode.compareNodes {{{3
-"This is supposed to be a class level method but i cant figure out how to
-"get func refs to work from a dict..
-"
-"A class level method that compares two nodes
-"
-"Args:
-"n1, n2: the 2 nodes to compare
-function! s:compareNodes(n1, n2)
-    return a:n1.path.compareTo(a:n2.path)
-endfunction
-
-"FUNCTION: TreeFileNode.clearBoomarks() {{{3
-function! s:TreeFileNode.clearBoomarks()
-    for i in s:Bookmark.Bookmarks()
-        if i.path.equals(self.path)
-            call i.delete()
-        end
-    endfor
-    call self.path.cacheDisplayString()
-endfunction
-"FUNCTION: TreeFileNode.copy(dest) {{{3
-function! s:TreeFileNode.copy(dest)
-    call self.path.copy(a:dest)
-    let newPath = s:Path.New(a:dest)
-    let parent = t:NERDTreeRoot.findNode(newPath.getParent())
-    if !empty(parent)
-        call parent.refresh()
-    endif
-    return parent.findNode(newPath)
-endfunction
-
-"FUNCTION: TreeFileNode.delete {{{3
-"Removes this node from the tree and calls the Delete method for its path obj
-function! s:TreeFileNode.delete()
-    call self.path.delete()
-    call self.parent.removeChild(self)
-endfunction
-
-"FUNCTION: TreeFileNode.equals(treenode) {{{3
-"
-"Compares this treenode to the input treenode and returns 1 if they are the
-"same node.
-"
-"Use this method instead of ==  because sometimes when the treenodes contain
-"many children, vim seg faults when doing ==
-"
-"Args:
-"treenode: the other treenode to compare to
-function! s:TreeFileNode.equals(treenode)
-    return self.path.str(1) == a:treenode.path.str(1)
-endfunction
-
-"FUNCTION: TreeFileNode.findNode(path) {{{3
-"Returns self if this node.path.Equals the given path.
-"Returns {} if not equal.
-"
-"Args:
-"path: the path object to compare against
-function! s:TreeFileNode.findNode(path)
-    if a:path.equals(self.path)
-        return self
-    endif
-    return {}
-endfunction
-"FUNCTION: TreeFileNode.findOpenDirSiblingWithVisibleChildren(direction) {{{3
-"
-"Finds the next sibling for this node in the indicated direction. This sibling
-"must be a directory and may/may not have children as specified.
-"
-"Args:
-"direction: 0 if you want to find the previous sibling, 1 for the next sibling
-"
-"Return:
-"a treenode object or {} if no appropriate sibling could be found
-function! s:TreeFileNode.findOpenDirSiblingWithVisibleChildren(direction)
-    "if we have no parent then we can have no siblings
-    if self.parent != {}
-        let nextSibling = self.findSibling(a:direction)
-
-        while nextSibling != {}
-            if nextSibling.path.isDirectory && nextSibling.hasVisibleChildren() && nextSibling.isOpen
-                return nextSibling
-            endif
-            let nextSibling = nextSibling.findSibling(a:direction)
-        endwhile
-    endif
-
-    return {}
-endfunction
-"FUNCTION: TreeFileNode.findSibling(direction) {{{3
-"
-"Finds the next sibling for this node in the indicated direction
-"
-"Args:
-"direction: 0 if you want to find the previous sibling, 1 for the next sibling
-"
-"Return:
-"a treenode object or {} if no sibling could be found
-function! s:TreeFileNode.findSibling(direction)
-    "if we have no parent then we can have no siblings
-    if self.parent != {}
-
-        "get the index of this node in its parents children
-        let siblingIndx = self.parent.getChildIndex(self.path)
-
-        if siblingIndx != -1
-            "move a long to the next potential sibling node
-            let siblingIndx = a:direction == 1 ? siblingIndx+1 : siblingIndx-1
-
-            "keep moving along to the next sibling till we find one that is valid
-            let numSiblings = self.parent.getChildCount()
-            while siblingIndx >= 0 && siblingIndx < numSiblings
-
-                "if the next node is not an ignored node (i.e. wont show up in the
-                "view) then return it
-                if self.parent.children[siblingIndx].path.ignore() == 0
-                    return self.parent.children[siblingIndx]
-                endif
-
-                "go to next node
-                let siblingIndx = a:direction == 1 ? siblingIndx+1 : siblingIndx-1
-            endwhile
-        endif
-    endif
-
-    return {}
-endfunction
-
-"FUNCTION: TreeFileNode.isVisible() {{{3
-"returns 1 if this node should be visible according to the tree filters and
-"hidden file filters (and their on/off status)
-function! s:TreeFileNode.isVisible()
-    return !self.path.ignore()
-endfunction
-
-
-"FUNCTION: TreeFileNode.isRoot() {{{3
-"returns 1 if this node is t:NERDTreeRoot
-function! s:TreeFileNode.isRoot()
-    if !s:treeExistsForTab()
-        throw "NERDTree.TreeFileNode.IsRoot exception: No tree exists for the current tab"
-    endif
-    return self.equals(t:NERDTreeRoot)
-endfunction
-
-"FUNCTION: TreeFileNode.makeRoot() {{{3
-"Make this node the root of the tree
-function! s:TreeFileNode.makeRoot()
-    if self.path.isDirectory
-        let t:NERDTreeRoot = self
-    else
-        call self.cacheParent()
-        let t:NERDTreeRoot = self.parent
-    endif
-
-    call t:NERDTreeRoot.open()
-
-    "change dir to the dir of the new root if instructed to
-    if g:NERDTreeChDirMode == 2
-        exec "cd " . t:NERDTreeRoot.path.strForEditCmd()
-    endif
-endfunction
-"FUNCTION: TreeFileNode.New(path) {{{3
-"Returns a new TreeNode object with the given path and parent
-"
-"Args:
-"path: a path object representing the full filesystem path to the file/dir that the node represents
-function! s:TreeFileNode.New(path)
-    if a:path.isDirectory
-        return s:TreeDirNode.New(a:path)
-    else
-        let newTreeNode = {}
-        let newTreeNode = copy(self)
-        let newTreeNode.path = a:path
-        let newTreeNode.parent = {}
-        return newTreeNode
-    endif
-endfunction
-
-"FUNCTION: TreeFileNode.refresh() {{{3
-function! s:TreeFileNode.refresh()
-    call self.path.refresh()
-endfunction
-"FUNCTION: TreeFileNode.rename() {{{3
-"Calls the rename method for this nodes path obj
-function! s:TreeFileNode.rename(newName)
-    let newName = substitute(a:newName, '\(\\\|\/\)$', '', '')
-    call self.path.rename(newName)
-    call self.parent.removeChild(self)
-
-    let parentPath = self.path.getPathTrunk()
-    let newParent = t:NERDTreeRoot.findNode(parentPath)
-
-    if newParent != {}
-        call newParent.createChild(self.path, 1)
-        call newParent.refresh()
-    endif
-endfunction
-"FUNCTION: TreeFileNode.strDisplay() {{{3
-"
-"Returns a string that specifies how the node should be represented as a
-"string
-"
-"Return:
-"a string that can be used in the view to represent this node
-function! s:TreeFileNode.strDisplay()
-    return self.path.strDisplay()
-endfunction
-
-"CLASS: TreeDirNode {{{2
-"This class is a child of the TreeFileNode class and constitutes the
-"'Composite' part of the composite design pattern between the treenode
-"classes.
-"============================================================
-let s:TreeDirNode = copy(s:TreeFileNode)
-"FUNCTION: TreeDirNode.AbsoluteTreeRoot(){{{3
-"class method that returns the highest cached ancestor of the current root
-function! s:TreeDirNode.AbsoluteTreeRoot()
-    let currentNode = t:NERDTreeRoot
-    while currentNode.parent != {}
-        let currentNode = currentNode.parent
-    endwhile
-    return currentNode
-endfunction
-"FUNCTION: TreeDirNode.addChild(treenode, inOrder) {{{3
-"Adds the given treenode to the list of children for this node
-"
-"Args:
-"-treenode: the node to add
-"-inOrder: 1 if the new node should be inserted in sorted order
-function! s:TreeDirNode.addChild(treenode, inOrder)
-    call add(self.children, a:treenode)
-    let a:treenode.parent = self
-
-    if a:inOrder
-        call self.sortChildren()
-    endif
-endfunction
-
-"FUNCTION: TreeDirNode.close() {{{3
-"Closes this directory
-function! s:TreeDirNode.close()
-    let self.isOpen = 0
-endfunction
-
-"FUNCTION: TreeDirNode.closeChildren() {{{3
-"Closes all the child dir nodes of this node
-function! s:TreeDirNode.closeChildren()
-    for i in self.children
-        if i.path.isDirectory
-            call i.close()
-            call i.closeChildren()
-        endif
-    endfor
-endfunction
-
-"FUNCTION: TreeDirNode.createChild(path, inOrder) {{{3
-"Instantiates a new child node for this node with the given path. The new
-"nodes parent is set to this node.
-"
-"Args:
-"path: a Path object that this node will represent/contain
-"inOrder: 1 if the new node should be inserted in sorted order
-"
-"Returns:
-"the newly created node
-function! s:TreeDirNode.createChild(path, inOrder)
-    let newTreeNode = s:TreeFileNode.New(a:path)
-    call self.addChild(newTreeNode, a:inOrder)
-    return newTreeNode
-endfunction
-
-"FUNCTION: TreeDirNode.findNode(path) {{{3
-"Will find one of the children (recursively) that has the given path
-"
-"Args:
-"path: a path object
-unlet s:TreeDirNode.findNode
-function! s:TreeDirNode.findNode(path)
-    if a:path.equals(self.path)
-        return self
-    endif
-    if stridx(a:path.str(1), self.path.str(1), 0) == -1
-        return {}
-    endif
-
-    if self.path.isDirectory
-        for i in self.children
-            let retVal = i.findNode(a:path)
-            if retVal != {}
-                return retVal
-            endif
-        endfor
-    endif
-    return {}
-endfunction
-"FUNCTION: TreeDirNode.getChildCount() {{{3
-"Returns the number of children this node has
-function! s:TreeDirNode.getChildCount()
-    return len(self.children)
-endfunction
-
-"FUNCTION: TreeDirNode.getChild(path) {{{3
-"Returns child node of this node that has the given path or {} if no such node
-"exists.
-"
-"This function doesnt not recurse into child dir nodes
-"
-"Args:
-"path: a path object
-function! s:TreeDirNode.getChild(path)
-    if stridx(a:path.str(1), self.path.str(1), 0) == -1
-        return {}
-    endif
-
-    let index = self.getChildIndex(a:path)
-    if index == -1
-        return {}
-    else
-        return self.children[index]
-    endif
-
-endfunction
-
-"FUNCTION: TreeDirNode.getChildByIndex(indx, visible) {{{3
-"returns the child at the given index
-"Args:
-"indx: the index to get the child from
-"visible: 1 if only the visible children array should be used, 0 if all the
-"children should be searched.
-function! s:TreeDirNode.getChildByIndex(indx, visible)
-    let array_to_search = a:visible? self.getVisibleChildren() : self.children
-    if a:indx > len(array_to_search)
-        throw "NERDTree.TreeDirNode.InvalidArguments exception. Index is out of bounds."
-    endif
-    return array_to_search[a:indx]
-endfunction
-
-"FUNCTION: TreeDirNode.getChildIndex(path) {{{3
-"Returns the index of the child node of this node that has the given path or
-"-1 if no such node exists.
-"
-"This function doesnt not recurse into child dir nodes
-"
-"Args:
-"path: a path object
-function! s:TreeDirNode.getChildIndex(path)
-    if stridx(a:path.str(1), self.path.str(1), 0) == -1
-        return -1
-    endif
-
-    "do a binary search for the child
-    let a = 0
-    let z = self.getChildCount()
-    while a < z
-        let mid = (a+z)/2
-        let diff = a:path.compareTo(self.children[mid].path)
-
-        if diff == -1
-            let z = mid
-        elseif diff == 1
-            let a = mid+1
-        else
-            return mid
-        endif
-    endwhile
-    return -1
-endfunction
-
-"FUNCTION: TreeDirNode.getVisibleChildCount() {{{3
-"Returns the number of visible children this node has
-function! s:TreeDirNode.getVisibleChildCount()
-    return len(self.getVisibleChildren())
-endfunction
-
-"FUNCTION: TreeDirNode.getVisibleChildren() {{{3
-"Returns a list of children to display for this node, in the correct order
-"
-"Return:
-"an array of treenodes
-function! s:TreeDirNode.getVisibleChildren()
-    let toReturn = []
-    for i in self.children
-        if i.path.ignore() == 0
-            call add(toReturn, i)
-        endif
-    endfor
-    return toReturn
-endfunction
-
-"FUNCTION: TreeDirNode.hasVisibleChildren() {{{3
-"returns 1 if this node has any childre, 0 otherwise..
-function! s:TreeDirNode.hasVisibleChildren()
-    return self.getVisibleChildCount() != 0
-endfunction
-
-"FUNCTION: TreeDirNode._initChildren() {{{3
-"Removes all childen from this node and re-reads them
-"
-"Args:
-"silent: 1 if the function should not echo any "please wait" messages for
-"large directories
-"
-"Return: the number of child nodes read
-function! s:TreeDirNode._initChildren(silent)
-    "remove all the current child nodes
-    let self.children = []
-
-    "get an array of all the files in the nodes dir
-    let dir = self.path
-    let filesStr = globpath(dir.strForGlob(), '*') . "\n" . globpath(dir.strForGlob(), '.*')
-    let files = split(filesStr, "\n")
-
-    if !a:silent && len(files) > g:NERDTreeNotificationThreshold
-        call s:echo("Please wait, caching a large dir ...")
-    endif
-
-    let invalidFilesFound = 0
-    for i in files
-
-        "filter out the .. and . directories
-        "Note: we must match .. AND ../ cos sometimes the globpath returns
-        "../ for path with strange chars (eg $)
-        if i !~ '\.\.\/\?$' && i !~ '\.\/\?$'
-
-            "put the next file in a new node and attach it
-            try
-                let path = s:Path.New(i)
-                call self.createChild(path, 0)
-            catch /^NERDTree.Path.\(InvalidArguments\|InvalidFiletype\)/
-                let invalidFilesFound += 1
-            endtry
-        endif
-    endfor
-
-    call self.sortChildren()
-
-    if !a:silent && len(files) > g:NERDTreeNotificationThreshold
-        call s:echo("Please wait, caching a large dir ... DONE (". self.getChildCount() ." nodes cached).")
-    endif
-
-    if invalidFilesFound
-        call s:echoWarning(invalidFilesFound . " file(s) could not be loaded into the NERD tree")
-    endif
-    return self.getChildCount()
-endfunction
-"FUNCTION: TreeDirNode.New(path) {{{3
-"Returns a new TreeNode object with the given path and parent
-"
-"Args:
-"path: a path object representing the full filesystem path to the file/dir that the node represents
-unlet s:TreeDirNode.New
-function! s:TreeDirNode.New(path)
-    if a:path.isDirectory != 1
-        throw "NERDTree.TreeDirNode.InvalidArguments exception. A TreeDirNode object must be instantiated with a directory Path object."
-    endif
-
-    let newTreeNode = copy(self)
-    let newTreeNode.path = a:path
-
-    let newTreeNode.isOpen = 0
-    let newTreeNode.children = []
-
-    let newTreeNode.parent = {}
-
-    return newTreeNode
-endfunction
-"FUNCTION: TreeDirNode.open() {{{3
-"Reads in all this nodes children
-"
-"Return: the number of child nodes read
-function! s:TreeDirNode.open()
-    let self.isOpen = 1
-    if self.children == []
-        return self._initChildren(0)
-    else
-        return 0
-    endif
-endfunction
-
-"FUNCTION: TreeDirNode.openRecursively() {{{3
-"Opens this treenode and all of its children whose paths arent 'ignored'
-"because of the file filters.
-"
-"This method is actually a wrapper for the OpenRecursively2 method which does
-"the work.
-function! s:TreeDirNode.openRecursively()
-    call self._openRecursively2(1)
-endfunction
-
-"FUNCTION: TreeDirNode._openRecursively2() {{{3
-"Opens this all children of this treenode recursively if either:
-"   *they arent filtered by file filters
-"   *a:forceOpen is 1
-"
-"Args:
-"forceOpen: 1 if this node should be opened regardless of file filters
-function! s:TreeDirNode._openRecursively2(forceOpen)
-    if self.path.ignore() == 0 || a:forceOpen
-        let self.isOpen = 1
-        if self.children == []
-            call self._initChildren(1)
-        endif
-
-        for i in self.children
-            if i.path.isDirectory == 1
-                call i._openRecursively2(0)
-            endif
-        endfor
-    endif
-endfunction
-
-"FUNCTION: TreeDirNode.refresh() {{{3
-unlet s:TreeDirNode.refresh
-function! s:TreeDirNode.refresh()
-    call self.path.refresh()
-
-    "if this node was ever opened, refresh its children
-    if self.isOpen || !empty(self.children)
-        "go thru all the files/dirs under this node
-        let newChildNodes = []
-        let invalidFilesFound = 0
-        let dir = self.path
-        let filesStr = globpath(dir.strForGlob(), '*') . "\n" . globpath(dir.strForGlob(), '.*')
-        let files = split(filesStr, "\n")
-        for i in files
-            if i !~ '\.\.$' && i !~ '\.$'
-
-                try
-                    "create a new path and see if it exists in this nodes children
-                    let path = s:Path.New(i)
-                    let newNode = self.getChild(path)
-                    if newNode != {}
-                        call newNode.refresh()
-                        call add(newChildNodes, newNode)
-
-                    "the node doesnt exist so create it
-                    else
-                        let newNode = s:TreeFileNode.New(path)
-                        let newNode.parent = self
-                        call add(newChildNodes, newNode)
-                    endif
-
-
-                catch /^NERDTree.InvalidArguments/
-                    let invalidFilesFound = 1
-                endtry
-            endif
-        endfor
-
-        "swap this nodes children out for the children we just read/refreshed
-        let self.children = newChildNodes
-        call self.sortChildren()
-
-        if invalidFilesFound
-            call s:echoWarning("some files could not be loaded into the NERD tree")
-        endif
-    endif
-endfunction
-
-"FUNCTION: TreeDirNode.removeChild(treenode) {{{3
-"
-"Removes the given treenode from this nodes set of children
-"
-"Args:
-"treenode: the node to remove
-"
-"Throws a NERDTree.TreeDirNode exception if the given treenode is not found
-function! s:TreeDirNode.removeChild(treenode)
-    for i in range(0, self.getChildCount()-1)
-        if self.children[i].equals(a:treenode)
-            call remove(self.children, i)
-            return
-        endif
-    endfor
-
-    throw "NERDTree.TreeDirNode exception: child node was not found"
-endfunction
-
-"FUNCTION: TreeDirNode.sortChildren() {{{3
-"
-"Sorts the children of this node according to alphabetical order and the
-"directory priority.
-"
-function! s:TreeDirNode.sortChildren()
-    let CompareFunc = function("s:compareNodes")
-    call sort(self.children, CompareFunc)
-endfunction
-
-"FUNCTION: TreeDirNode.toggleOpen() {{{3
-"Opens this directory if it is closed and vice versa
-function! s:TreeDirNode.toggleOpen()
-    if self.isOpen == 1
-        call self.close()
-    else
-        call self.open()
-    endif
-endfunction
-
-"FUNCTION: TreeDirNode.transplantChild(newNode) {{{3
-"Replaces the child of this with the given node (where the child node's full
-"path matches a:newNode's fullpath). The search for the matching node is
-"non-recursive
-"
-"Arg:
-"newNode: the node to graft into the tree
-function! s:TreeDirNode.transplantChild(newNode)
-    for i in range(0, self.getChildCount()-1)
-        if self.children[i].equals(a:newNode)
-            let self.children[i] = a:newNode
-            let a:newNode.parent = self
-            break
-        endif
-    endfor
-endfunction
-"============================================================
-"CLASS: Path {{{2
-"============================================================
-let s:Path = {}
-"FUNCTION: Path.bookmarkNames() {{{3
-function! s:Path.bookmarkNames()
-    if !exists("self._bookmarkNames")
-        call self.cacheDisplayString()
-    endif
-    return self._bookmarkNames
-endfunction
-"FUNCTION: Path.cacheDisplayString() {{{3
-function! s:Path.cacheDisplayString()
-    let self.cachedDisplayString = self.getLastPathComponent(1)
-
-    if self.isExecutable
-        let self.cachedDisplayString = self.cachedDisplayString . '*'
-    endif
-
-    let self._bookmarkNames = []
-    for i in s:Bookmark.Bookmarks()
-        if i.path.equals(self)
-            call add(self._bookmarkNames, i.name)
-        endif
-    endfor
-    if !empty(self._bookmarkNames)
-        let self.cachedDisplayString .= ' {' . join(self._bookmarkNames) . '}'
-    endif
-
-    if self.isSymLink
-        let self.cachedDisplayString .=  ' -> ' . self.symLinkDest
-    endif
-
-    if self.isReadOnly
-        let self.cachedDisplayString .=  ' [RO]'
-    endif
-endfunction
-"FUNCTION: Path.changeToDir() {{{3
-function! s:Path.changeToDir()
-    let dir = self.strForCd()
-    if self.isDirectory == 0
-        let dir = self.getPathTrunk().strForCd()
-    endif
-
-    try
-        execute "cd " . dir
-        call s:echo("CWD is now: " . getcwd())
-    catch
-        throw "NERDTree.Path.Change exception: cannot change to " . dir
-    endtry
-endfunction
-
-"FUNCTION: Path.compareTo() {{{3
-"
-"Compares this Path to the given path and returns 0 if they are equal, -1 if
-"this Path is "less than" the given path, or 1 if it is "greater".
-"
-"Args:
-"path: the path object to compare this to
-"
-"Return:
-"1, -1 or 0
-function! s:Path.compareTo(path)
-    let thisPath = self.getLastPathComponent(1)
-    let thatPath = a:path.getLastPathComponent(1)
-
-    "if the paths are the same then clearly we return 0
-    if thisPath == thatPath
-        return 0
-    endif
-
-    let thisSS = self.getSortOrderIndex()
-    let thatSS = a:path.getSortOrderIndex()
-
-    "compare the sort sequences, if they are different then the return
-    "value is easy
-    if thisSS < thatSS
-        return -1
-    elseif thisSS > thatSS
-        return 1
-    else
-        "if the sort sequences are the same then compare the paths
-        "alphabetically
-        let pathCompare = g:NERDTreeCaseSensitiveSort ? thisPath <# thatPath : thisPath <? thatPath
-        if pathCompare
-            return -1
-        else
-            return 1
-        endif
-    endif
-endfunction
-
-"FUNCTION: Path.Create(fullpath) {{{3
-"
-"Factory method.
-"
-"Creates a path object with the given path. The path is also created on the
-"filesystem. If the path already exists, a NERDTree.Path.Exists exception is
-"thrown. If any other errors occur, a NERDTree.Path exception is thrown.
-"
-"Args:
-"fullpath: the full filesystem path to the file/dir to create
-function! s:Path.Create(fullpath)
-    "bail if the a:fullpath already exists
-    if isdirectory(a:fullpath) || filereadable(a:fullpath)
-        throw "NERDTree.Path.Exists Exception: Directory Exists: '" . a:fullpath . "'"
-    endif
-
-    try
-
-        "if it ends with a slash, assume its a dir create it
-        if a:fullpath =~ '\(\\\|\/\)$'
-            "whack the trailing slash off the end if it exists
-            let fullpath = substitute(a:fullpath, '\(\\\|\/\)$', '', '')
-
-            call mkdir(fullpath, 'p')
-
-        "assume its a file and create
-        else
-            call writefile([], a:fullpath)
-        endif
-    catch /.*/
-        throw "NERDTree.Path Exception: Could not create path: '" . a:fullpath . "'"
-    endtry
-
-    return s:Path.New(a:fullpath)
-endfunction
-
-"FUNCTION: Path.copy(dest) {{{3
-"
-"Copies the file/dir represented by this Path to the given location
-"
-"Args:
-"dest: the location to copy this dir/file to
-function! s:Path.copy(dest)
-    if !s:Path.CopyingSupported()
-        throw "NERDTree.Path.CopyingNotSupported Exception: Copying is not supported on this OS"
-    endif
-
-    let dest = s:Path.WinToUnixPath(a:dest)
-
-    let cmd = g:NERDTreeCopyCmd . " " . self.strForOS(0) . " " . dest
-    let success = system(cmd)
-    if success != 0
-        throw "NERDTree.Path Exception: Could not copy ''". self.strForOS(0) ."'' to: '" . a:dest . "'"
-    endif
-endfunction
-
-"FUNCTION: Path.CopyingSupported() {{{3
-"
-"returns 1 if copying is supported for this OS
-function! s:Path.CopyingSupported()
-    return exists('g:NERDTreeCopyCmd')
-endfunction
-
-
-"FUNCTION: Path.copyingWillOverwrite(dest) {{{3
-"
-"returns 1 if copy this path to the given location will cause files to
-"overwritten
-"
-"Args:
-"dest: the location this path will be copied to
-function! s:Path.copyingWillOverwrite(dest)
-    if filereadable(a:dest)
-        return 1
-    endif
-
-    if isdirectory(a:dest)
-        let path = s:Path.JoinPathStrings(a:dest, self.getLastPathComponent(0))
-        if filereadable(path)
-            return 1
-        endif
-    endif
-endfunction
-
-"FUNCTION: Path.delete() {{{3
-"
-"Deletes the file represented by this path.
-"Deletion of directories is not supported
-"
-"Throws NERDTree.Path.Deletion exceptions
-function! s:Path.delete()
-    if self.isDirectory
-
-        let cmd = ""
-        if s:running_windows
-            "if we are runnnig windows then put quotes around the pathstring
-            let cmd = g:NERDTreeRemoveDirCmd . self.strForOS(1)
-        else
-            let cmd = g:NERDTreeRemoveDirCmd . self.strForOS(1)
-        endif
-        let success = system(cmd)
-
-        if v:shell_error != 0
-            throw "NERDTree.Path.Deletion Exception: Could not delete directory: '" . self.strForOS(0) . "'"
-        endif
-    else
-        let success = delete(self.strForOS(0))
-        if success != 0
-            throw "NERDTree.Path.Deletion Exception: Could not delete file: '" . self.str(0) . "'"
-        endif
-    endif
-
-    "delete all bookmarks for this path
-    for i in self.bookmarkNames()
-        let bookmark = s:Bookmark.BookmarkFor(i)
-        call bookmark.delete()
-    endfor
-endfunction
-
-"FUNCTION: Path.extractDriveLetter(fullpath) {{{3
-"
-"If running windows, cache the drive letter for this path
-function! s:Path.extractDriveLetter(fullpath)
-    if s:running_windows
-        let self.drive = substitute(a:fullpath, '\(^[a-zA-Z]:\).*', '\1', '')
-    else
-        let self.drive = ''
-    endif
-
-endfunction
-"FUNCTION: Path.exists() {{{3
-"return 1 if this path points to a location that is readable or is a directory
-function! s:Path.exists()
-    return filereadable(self.strForOS(0)) || isdirectory(self.strForOS(0))
-endfunction
-"FUNCTION: Path.getDir() {{{3
-"
-"Returns this path if it is a directory, else this paths parent.
-"
-"Return:
-"a Path object
-function! s:Path.getDir()
-    if self.isDirectory
-        return self
-    else
-        return self.getParent()
-    endif
-endfunction
-"FUNCTION: Path.getParent() {{{3
-"
-"Returns a new path object for this paths parent
-"
-"Return:
-"a new Path object
-function! s:Path.getParent()
-    let path = '/'. join(self.pathSegments[0:-2], '/')
-    return s:Path.New(path)
-endfunction
-"FUNCTION: Path.getLastPathComponent(dirSlash) {{{3
-"
-"Gets the last part of this path.
-"
-"Args:
-"dirSlash: if 1 then a trailing slash will be added to the returned value for
-"directory nodes.
-function! s:Path.getLastPathComponent(dirSlash)
-    if empty(self.pathSegments)
-        return ''
-    endif
-    let toReturn = self.pathSegments[-1]
-    if a:dirSlash && self.isDirectory
-        let toReturn = toReturn . '/'
-    endif
-    return toReturn
-endfunction
-
-"FUNCTION: Path.getPathTrunk() {{{3
-"Gets the path without the last segment on the end.
-function! s:Path.getPathTrunk()
-    return s:Path.New(self.strTrunk())
-endfunction
-
-"FUNCTION: Path.getSortOrderIndex() {{{3
-"returns the index of the pattern in g:NERDTreeSortOrder that this path matches
-function! s:Path.getSortOrderIndex()
-    let i = 0
-    while i < len(g:NERDTreeSortOrder)
-        if  self.getLastPathComponent(1) =~ g:NERDTreeSortOrder[i]
-            return i
-        endif
-        let i = i + 1
-    endwhile
-    return s:NERDTreeSortStarIndex
-endfunction
-
-"FUNCTION: Path.ignore() {{{3
-"returns true if this path should be ignored
-function! s:Path.ignore()
-    let lastPathComponent = self.getLastPathComponent(0)
-
-    "filter out the user specified paths to ignore
-    if t:NERDTreeIgnoreEnabled
-        for i in g:NERDTreeIgnore
-            if lastPathComponent =~ i
-                return 1
-            endif
-        endfor
-    endif
-
-    "dont show hidden files unless instructed to
-    if t:NERDTreeShowHidden == 0 && lastPathComponent =~ '^\.'
-        return 1
-    endif
-
-    if t:NERDTreeShowFiles == 0 && self.isDirectory == 0
-        return 1
-    endif
-
-    return 0
-endfunction
-
-"FUNCTION: Path.JoinPathStrings(...) {{{3
-function! s:Path.JoinPathStrings(...)
-    let components = []
-    for i in a:000
-        let components = extend(components, split(i, '/'))
-    endfor
-    return '/' . join(components, '/')
-endfunction
-
-"FUNCTION: Path.equals() {{{3
-"
-"Determines whether 2 path objects are "equal".
-"They are equal if the paths they represent are the same
-"
-"Args:
-"path: the other path obj to compare this with
-function! s:Path.equals(path)
-    return self.str(0) == a:path.str(0)
-endfunction
-
-"FUNCTION: Path.New() {{{3
-"
-"The Constructor for the Path object
-"Throws NERDTree.Path.InvalidArguments exception.
-function! s:Path.New(fullpath)
-    let newPath = copy(self)
-
-    call newPath.readInfoFromDisk(a:fullpath)
-
-    let newPath.cachedDisplayString = ""
-
-    return newPath
-endfunction
-
-"FUNCTION: Path.readInfoFromDisk(fullpath) {{{3
-"
-"
-"Throws NERDTree.Path.InvalidArguments exception.
-function! s:Path.readInfoFromDisk(fullpath)
-    call self.extractDriveLetter(a:fullpath)
-
-    let fullpath = s:Path.WinToUnixPath(a:fullpath)
-
-    if getftype(fullpath) == "fifo"
-        throw "NERDTree.Path.InvalidFiletype Exception: Cant handle FIFO files: " . a:fullpath
-    endif
-
-    let self.pathSegments = split(fullpath, '/')
-
-
-    let self.isReadOnly = 0
-    if isdirectory(a:fullpath)
-        let self.isDirectory = 1
-    elseif filereadable(a:fullpath)
-        let self.isDirectory = 0
-        let self.isReadOnly = filewritable(a:fullpath) == 0
-    else
-        throw "NERDTree.Path.InvalidArguments Exception: Invalid path = " . a:fullpath
-    endif
-
-    let self.isExecutable = 0
-    if !self.isDirectory
-        let self.isExecutable = getfperm(a:fullpath) =~ 'x'
-    endif
-
-    "grab the last part of the path (minus the trailing slash)
-    let lastPathComponent = self.getLastPathComponent(0)
-
-    "get the path to the new node with the parent dir fully resolved
-    let hardPath = resolve(self.strTrunk()) . '/' . lastPathComponent
-
-    "if  the last part of the path is a symlink then flag it as such
-    let self.isSymLink = (resolve(hardPath) != hardPath)
-    if self.isSymLink
-        let self.symLinkDest = resolve(fullpath)
-
-        "if the link is a dir then slap a / on the end of its dest
-        if isdirectory(self.symLinkDest)
-
-            "we always wanna treat MS windows shortcuts as files for
-            "simplicity
-            if hardPath !~ '\.lnk$'
-
-                let self.symLinkDest = self.symLinkDest . '/'
-            endif
-        endif
-    endif
-endfunction
-
-"FUNCTION: Path.refresh() {{{3
-function! s:Path.refresh()
-    call self.readInfoFromDisk(self.strForOS(0))
-    call self.cacheDisplayString()
-endfunction
-
-"FUNCTION: Path.rename() {{{3
-"
-"Renames this node on the filesystem
-function! s:Path.rename(newPath)
-    if a:newPath == ''
-        throw "NERDTree.Path.InvalidArguments exception. Invalid newPath for renaming = ". a:newPath
-    endif
-
-    let success =  rename(self.strForOS(0), a:newPath)
-    if success != 0
-        throw "NERDTree.Path.Rename Exception: Could not rename: '" . self.strForOS(0) . "'" . 'to:' . a:newPath
-    endif
-    call self.readInfoFromDisk(a:newPath)
-
-    for i in self.bookmarkNames()
-        let b = s:Bookmark.BookmarkFor(i)
-        call b.setPath(copy(self))
-    endfor
-    call s:Bookmark.Write()
-endfunction
-
-"FUNCTION: Path.str(esc) {{{3
-"
-"Gets the actual string path that this obj represents.
-"
-"Args:
-"esc: if 1 then all the tricky chars in the returned string will be escaped
-function! s:Path.str(esc)
-    let toReturn = '/' . join(self.pathSegments, '/')
-    if self.isDirectory && toReturn != '/'
-        let toReturn  = toReturn . '/'
-    endif
-
-    if a:esc
-        let toReturn = escape(toReturn, s:escape_chars)
-    endif
-    return toReturn
-endfunction
-
-"FUNCTION: Path.strAbs() {{{3
-"
-"Returns a string representing this path with all the symlinks resolved
-"
-"Return:
-"string
-function! s:Path.strAbs()
-    return resolve(self.str(1))
-endfunction
-
-"FUNCTION: Path.strForCd() {{{3
-"
-" returns a string that can be used with :cd
-"
-"Return:
-"a string that can be used in the view to represent this path
-function! s:Path.strForCd()
-    if s:running_windows
-        return self.strForOS(0)
-    else
-        return self.strForOS(1)
-    endif
-endfunction
-"FUNCTION: Path.strDisplay() {{{3
-"
-"Returns a string that specifies how the path should be represented as a
-"string
-"
-"Return:
-"a string that can be used in the view to represent this path
-function! s:Path.strDisplay()
-    if self.cachedDisplayString == ""
-        call self.cacheDisplayString()
-    endif
-
-    return self.cachedDisplayString
-endfunction
-
-"FUNCTION: Path.strForEditCmd() {{{3
-"
-"Return: the string for this path that is suitable to be used with the :edit
-"command
-function! s:Path.strForEditCmd()
-    if s:running_windows
-        return self.strForOS(0)
-    else
-        return self.str(1)
-    endif
-
-endfunction
-"FUNCTION: Path.strForGlob() {{{3
-function! s:Path.strForGlob()
-    let lead = s:os_slash
-
-    "if we are running windows then slap a drive letter on the front
-    if s:running_windows
-        let lead = self.drive . '\'
-    endif
-
-    let toReturn = lead . join(self.pathSegments, s:os_slash)
-
-    if !s:running_windows
-        let toReturn = escape(toReturn, s:escape_chars)
-    endif
-    return toReturn
-endfunction
-"FUNCTION: Path.strForOS(esc) {{{3
-"
-"Gets the string path for this path object that is appropriate for the OS.
-"EG, in windows c:\foo\bar
-"    in *nix  /foo/bar
-"
-"Args:
-"esc: if 1 then all the tricky chars in the returned string will be
-" escaped. If we are running windows then the str is double quoted instead.
-function! s:Path.strForOS(esc)
-    let lead = s:os_slash
-
-    "if we are running windows then slap a drive letter on the front
-    if s:running_windows
-        let lead = self.drive . '\'
-    endif
-
-    let toReturn = lead . join(self.pathSegments, s:os_slash)
-
-    if a:esc
-        if s:running_windows
-            let toReturn = '"' .  toReturn . '"'
-        else
-            let toReturn = escape(toReturn, s:escape_chars)
-        endif
-    endif
-    return toReturn
-endfunction
-
-"FUNCTION: Path.strTrunk() {{{3
-"Gets the path without the last segment on the end.
-function! s:Path.strTrunk()
-    return self.drive . '/' . join(self.pathSegments[0:-2], '/')
-endfunction
-
-"FUNCTION: Path.WinToUnixPath(pathstr){{{3
-"Takes in a windows path and returns the unix equiv
-"
-"A class level method
-"
-"Args:
-"pathstr: the windows path to convert
-function! s:Path.WinToUnixPath(pathstr)
-    if !s:running_windows
-        return a:pathstr
-    endif
-
-    let toReturn = a:pathstr
-
-    "remove the x:\ of the front
-    let toReturn = substitute(toReturn, '^.*:\(\\\|/\)\?', '/', "")
-
-    "convert all \ chars to /
-    let toReturn = substitute(toReturn, '\', '/', "g")
-
-    return toReturn
-endfunction
-
-" SECTION: General Functions {{{1
-"============================================================
-"FUNCTION: s:bufInWindows(bnum){{{2
-"[[STOLEN FROM VTREEEXPLORER.VIM]]
-"Determine the number of windows open to this buffer number.
-"Care of Yegappan Lakshman.  Thanks!
-"
-"Args:
-"bnum: the subject buffers buffer number
-function! s:bufInWindows(bnum)
-    let cnt = 0
-    let winnum = 1
-    while 1
-        let bufnum = winbufnr(winnum)
-        if bufnum < 0
-            break
-        endif
-        if bufnum == a:bnum
-            let cnt = cnt + 1
-        endif
-        let winnum = winnum + 1
-    endwhile
-
-    return cnt
-endfunction " >>>
-
-"FUNCTION: s:compareBookmarks(first, second) {{{2
-"Compares two bookmarks
-function! s:compareBookmarks(first, second)
-    return a:first.compareTo(a:second)
-endfunction
-
-" FUNCTION: s:completeBookmarks(A,L,P) {{{2
-" completion function for the bookmark commands
-function! s:completeBookmarks(A,L,P)
-    return filter(s:Bookmark.BookmarkNames(), 'v:val =~ "^' . a:A . '"')
-endfunction
-"FUNCTION: s:initNerdTree(name) {{{2
-"Initialise the nerd tree for this tab. The tree will start in either the
-"given directory, or the directory associated with the given bookmark
-"
-"Args:
-"name: the name of a bookmark or a directory
-function! s:initNerdTree(name)
-    let path = {}
-    if s:Bookmark.BookmarkExistsFor(a:name)
-        let path = s:Bookmark.BookmarkFor(a:name).path
-    else
-        let dir = a:name == '' ? expand('%:p:h') : a:name
-        let dir = resolve(dir)
-        try
-            let path = s:Path.New(dir)
-        catch /NERDTree.Path.InvalidArguments/
-            call s:echo("No bookmark or directory found for: " . a:name)
-            return
-        endtry
-    endif
-    if !path.isDirectory
-        let path = path.getParent()
-    endif
-
-    "if instructed to, then change the vim CWD to the dir the NERDTree is
-    "inited in
-    if g:NERDTreeChDirMode != 0
-        exec 'cd ' . path.strForCd()
-    endif
-
-    let t:treeShowHelp = 0
-    let t:NERDTreeIgnoreEnabled = 1
-    let t:NERDTreeShowFiles = g:NERDTreeShowFiles
-    let t:NERDTreeShowHidden = g:NERDTreeShowHidden
-    let t:NERDTreeShowBookmarks = g:NERDTreeShowBookmarks
-
-    if s:treeExistsForTab()
-        if s:isTreeOpen()
-            call s:closeTree()
-        endif
-        unlet t:NERDTreeRoot
-    endif
-
-    let t:NERDTreeRoot = s:TreeDirNode.New(path)
-    call t:NERDTreeRoot.open()
-
-    call s:createTreeWin()
-    call s:renderView()
-    call s:putCursorOnNode(t:NERDTreeRoot, 0, 0)
-endfunction
-" Function: s:treeExistsForTab()   {{{2
-" Returns 1 if a nerd tree root exists in the current tab
-function! s:treeExistsForTab()
-    return exists("t:NERDTreeRoot")
-endfunction
-" SECTION: Public Functions {{{1
-"============================================================
-"Returns the node that the cursor is currently on.
-"
-"If the cursor is not in the NERDTree window, it is temporarily put there.
-"
-"If no NERD tree window exists for the current tab, a NERDTree.NoTreeForTab
-"exception is thrown.
-"
-"If the cursor is not on a node then an empty dictionary {} is returned.
-function! NERDTreeGetCurrentNode()
-    if !s:treeExistsForTab() || !s:isTreeOpen()
-        throw "NERDTree.NoTreeForTab exception: there is no NERD tree open for the current tab"
-    endif
-
-    let winnr = winnr()
-    if winnr != s:getTreeWinNum()
-        call s:putCursorInTreeWin()
-    endif
-
-    let treenode = s:getSelectedNode()
-
-    if winnr != winnr()
-        wincmd w
-    endif
-
-    return treenode
-endfunction
-
-"Returns the path object for the current node.
-"
-"Subject to the same conditions as NERDTreeGetCurrentNode
-function! NERDTreeGetCurrentPath()
-    let node = NERDTreeGetCurrentNode()
-    if node != {}
-        return node.path
-    else
-        return {}
-    endif
-endfunction
-
-" SECTION: View Functions {{{1
-"============================================================
-"FUNCTION: s:centerView() {{{2
-"centers the nerd tree window around the cursor (provided the nerd tree
-"options permit)
-function! s:centerView()
-    if g:NERDTreeAutoCenter
-        let current_line = winline()
-        let lines_to_top = current_line
-        let lines_to_bottom = winheight(s:getTreeWinNum()) - current_line
-        if lines_to_top < g:NERDTreeAutoCenterThreshold || lines_to_bottom < g:NERDTreeAutoCenterThreshold
-            normal! zz
-        endif
-    endif
-endfunction
-"FUNCTION: s:closeTree() {{{2
-"Closes the NERD tree window
-function! s:closeTree()
-    if !s:isTreeOpen()
-        throw "NERDTree.view.closeTree exception: no NERDTree is open"
-    endif
-
-    if winnr("$") != 1
-        execute s:getTreeWinNum() . " wincmd w"
-        close
-        execute "wincmd p"
-    else
-        :q
-    endif
-endfunction
-
-"FUNCTION: s:closeTreeIfOpen() {{{2
-"Closes the NERD tree window if it is open
-function! s:closeTreeIfOpen()
-   if s:isTreeOpen()
-      call s:closeTree()
-   endif
-endfunction
-"FUNCTION: s:closeTreeIfQuitOnOpen() {{{2
-"Closes the NERD tree window if the close on open option is set
-function! s:closeTreeIfQuitOnOpen()
-    if g:NERDTreeQuitOnOpen
-        call s:closeTree()
-    endif
-endfunction
-"FUNCTION: s:createTreeWin() {{{2
-"Inits the NERD tree window. ie. opens it, sizes it, sets all the local
-"options etc
-function! s:createTreeWin()
-    "create the nerd tree window
-    let splitLocation = (g:NERDTreeWinPos == "top" || g:NERDTreeWinPos == "left") ? "topleft " : "botright "
-    let splitMode = s:shouldSplitVertically() ? "vertical " : ""
-    let splitSize = g:NERDTreeWinSize
-    let t:NERDTreeWinName = localtime() . s:NERDTreeWinName
-    let cmd = splitLocation . splitMode . splitSize . ' new ' . t:NERDTreeWinName
-    silent! execute cmd
-
-    setlocal winfixwidth
-
-    "throwaway buffer options
-    setlocal noswapfile
-    setlocal buftype=nofile
-    setlocal bufhidden=delete
-    setlocal nowrap
-    setlocal foldcolumn=0
-    setlocal nobuflisted
-    setlocal nospell
-    if g:NERDTreeShowLineNumbers
-        setlocal nu
-    else
-        setlocal nonu
-    endif
-
-    iabc <buffer>
-
-    if g:NERDTreeHighlightCursorline
-        setlocal cursorline
-    endif
-
-
-
-    call s:bindMappings()
-    setfiletype nerdtree
-    " syntax highlighting
-    if has("syntax") && exists("g:syntax_on") && !has("syntax_items")
-        call s:setupSyntaxHighlighting()
-    endif
-endfunction
-
-"FUNCTION: s:drawTree {{{2
-"Draws the given node recursively
-"
-"Args:
-"curNode: the node that is being rendered with this call
-"depth: the current depth in the tree for this call
-"drawText: 1 if we should actually draw the line for this node (if 0 then the
-"child nodes are rendered only)
-"vertMap: a binary array that indicates whether a vertical bar should be draw
-"for each depth in the tree
-"isLastChild:true if this curNode is the last child of its parent
-function! s:drawTree(curNode, depth, drawText, vertMap, isLastChild)
-    if a:drawText == 1
-
-        let treeParts = ''
-
-        "get all the leading spaces and vertical tree parts for this line
-        if a:depth > 1
-            for j in a:vertMap[0:-2]
-                if j == 1
-                    let treeParts = treeParts . '| '
-                else
-                    let treeParts = treeParts . '  '
-                endif
-            endfor
-        endif
-
-        "get the last vertical tree part for this line which will be different
-        "if this node is the last child of its parent
-        if a:isLastChild
-            let treeParts = treeParts . '`'
-        else
-            let treeParts = treeParts . '|'
-        endif
-
-
-        "smack the appropriate dir/file symbol on the line before the file/dir
-        "name itself
-        if a:curNode.path.isDirectory
-            if a:curNode.isOpen
-                let treeParts = treeParts . '~'
-            else
-                let treeParts = treeParts . '+'
-            endif
-        else
-            let treeParts = treeParts . '-'
-        endif
-        let line = treeParts . a:curNode.strDisplay()
-
-        call setline(line(".")+1, line)
-        call cursor(line(".")+1, col("."))
-    endif
-
-    "if the node is an open dir, draw its children
-    if a:curNode.path.isDirectory == 1 && a:curNode.isOpen == 1
-
-        let childNodesToDraw = a:curNode.getVisibleChildren()
-        if len(childNodesToDraw) > 0
-
-            "draw all the nodes children except the last
-            let lastIndx = len(childNodesToDraw)-1
-            if lastIndx > 0
-                for i in childNodesToDraw[0:lastIndx-1]
-                    call s:drawTree(i, a:depth + 1, 1, add(copy(a:vertMap), 1), 0)
-                endfor
-            endif
-
-            "draw the last child, indicating that it IS the last
-            call s:drawTree(childNodesToDraw[lastIndx], a:depth + 1, 1, add(copy(a:vertMap), 0), 1)
-        endif
-    endif
-endfunction
-
-
-"FUNCTION: s:dumpHelp  {{{2
-"prints out the quick help
-function! s:dumpHelp()
-    let old_h = @h
-    if t:treeShowHelp == 1
-        let @h=   "\" NERD tree (" . s:NERD_tree_version . ") quickhelp~\n"
-        let @h=@h."\" ============================\n"
-        let @h=@h."\" File node mappings~\n"
-        let @h=@h."\" ". (g:NERDTreeMouseMode == 3 ? "single" : "double") ."-click,\n"
-        let @h=@h."\" ". g:NERDTreeMapActivateNode .": open in prev window\n"
-        let @h=@h."\" ". g:NERDTreeMapPreview .": preview\n"
-        let @h=@h."\" ". g:NERDTreeMapOpenInTab.": open in new tab\n"
-        let @h=@h."\" ". g:NERDTreeMapOpenInTabSilent .": open in new tab silently\n"
-        let @h=@h."\" middle-click,\n"
-        let @h=@h."\" ". g:NERDTreeMapOpenSplit .": open split\n"
-        let @h=@h."\" ". g:NERDTreeMapPreviewSplit .": preview split\n"
-        let @h=@h."\" ". g:NERDTreeMapExecute.": Execute file\n"
-
-        let @h=@h."\"\n\" ----------------------------\n"
-        let @h=@h."\" Directory node mappings~\n"
-        let @h=@h."\" ". (g:NERDTreeMouseMode == 1 ? "double" : "single") ."-click,\n"
-        let @h=@h."\" ". g:NERDTreeMapActivateNode .": open & close node\n"
-        let @h=@h."\" ". g:NERDTreeMapOpenRecursively .": recursively open node\n"
-        let @h=@h."\" ". g:NERDTreeMapCloseDir .": close parent of node\n"
-        let @h=@h."\" ". g:NERDTreeMapCloseChildren .": close all child nodes of\n"
-        let @h=@h."\"    current node recursively\n"
-        let @h=@h."\" middle-click,\n"
-        let @h=@h."\" ". g:NERDTreeMapOpenExpl.": Open netrw for selected\n"
-        let @h=@h."\"    node\n"
-
-        let @h=@h."\"\n\" ----------------------------\n"
-        let @h=@h."\" Bookmark table mappings~\n"
-        let @h=@h."\" double-click,\n"
-        let @h=@h."\" ". g:NERDTreeMapActivateNode .": open bookmark\n"
-        let @h=@h."\" ". g:NERDTreeMapOpenInTab.": open in new tab\n"
-        let @h=@h."\" ". g:NERDTreeMapOpenInTabSilent .": open in new tab silently\n"
-        let @h=@h."\" ". g:NERDTreeMapDeleteBookmark .": delete bookmark\n"
-
-        let @h=@h."\"\n\" ----------------------------\n"
-        let @h=@h."\" Tree navigation mappings~\n"
-        let @h=@h."\" ". g:NERDTreeMapJumpRoot .": go to root\n"
-        let @h=@h."\" ". g:NERDTreeMapJumpParent .": go to parent\n"
-        let @h=@h."\" ". g:NERDTreeMapJumpFirstChild  .": go to first child\n"
-        let @h=@h."\" ". g:NERDTreeMapJumpLastChild   .": go to last child\n"
-        let @h=@h."\" ". g:NERDTreeMapJumpNextSibling .": go to next sibling\n"
-        let @h=@h."\" ". g:NERDTreeMapJumpPrevSibling .": go to prev sibling\n"
-
-        let @h=@h."\"\n\" ----------------------------\n"
-        let @h=@h."\" Filesystem mappings~\n"
-        let @h=@h."\" ". g:NERDTreeMapChangeRoot .": change tree root to the\n"
-        let @h=@h."\"    selected dir\n"
-        let @h=@h."\" ". g:NERDTreeMapUpdir .": move tree root up a dir\n"
-        let @h=@h."\" ". g:NERDTreeMapUpdirKeepOpen .": move tree root up a dir\n"
-        let @h=@h."\"    but leave old root open\n"
-        let @h=@h."\" ". g:NERDTreeMapRefresh .": refresh cursor dir\n"
-        let @h=@h."\" ". g:NERDTreeMapRefreshRoot .": refresh current root\n"
-        let @h=@h."\" ". g:NERDTreeMapFilesystemMenu .": Show filesystem menu\n"
-        let @h=@h."\" ". g:NERDTreeMapChdir .":change the CWD to the\n"
-        let @h=@h."\"    selected dir\n"
-
-        let @h=@h."\"\n\" ----------------------------\n"
-        let @h=@h."\" Tree filtering mappings~\n"
-        let @h=@h."\" ". g:NERDTreeMapToggleHidden .": hidden files (" . (t:NERDTreeShowHidden ? "on" : "off") . ")\n"
-        let @h=@h."\" ". g:NERDTreeMapToggleFilters .": file filters (" . (t:NERDTreeIgnoreEnabled ? "on" : "off") . ")\n"
-        let @h=@h."\" ". g:NERDTreeMapToggleFiles .": files (" . (t:NERDTreeShowFiles ? "on" : "off") . ")\n"
-        let @h=@h."\" ". g:NERDTreeMapToggleBookmarks .": bookmarks (" . (t:NERDTreeShowBookmarks ? "on" : "off") . ")\n"
-
-        let @h=@h."\"\n\" ----------------------------\n"
-        let @h=@h."\" Other mappings~\n"
-        let @h=@h."\" ". g:NERDTreeMapQuit .": Close the NERDTree window\n"
-        let @h=@h."\" ". g:NERDTreeMapHelp .": toggle help\n"
-        let @h=@h."\"\n\" ----------------------------\n"
-        let @h=@h."\" Bookmark commands~\n"
-        let @h=@h."\" :Bookmark <name>\n"
-        let @h=@h."\" :BookmarkToRoot <name>\n"
-        let @h=@h."\" :RevealBookmark <name>\n"
-        let @h=@h."\" :OpenBookmark <name>\n"
-        let @h=@h."\" :ClearBookmarks [<names>]\n"
-        let @h=@h."\" :ClearAllBookmarks\n"
-    else
-        let @h="\" Press ". g:NERDTreeMapHelp ." for help\n"
-    endif
-
-    silent! put h
-
-    let @h = old_h
-endfunction
-"FUNCTION: s:echo  {{{2
-"A wrapper for :echo. Appends 'NERDTree:' on the front of all messages
-"
-"Args:
-"msg: the message to echo
-function! s:echo(msg)
-    redraw
-    echomsg "NERDTree: " . a:msg
-endfunction
-"FUNCTION: s:echoWarning {{{2
-"Wrapper for s:echo, sets the message type to warningmsg for this message
-"Args:
-"msg: the message to echo
-function! s:echoWarning(msg)
-    echohl warningmsg
-    call s:echo(a:msg)
-    echohl normal
-endfunction
-"FUNCTION: s:echoError {{{2
-"Wrapper for s:echo, sets the message type to errormsg for this message
-"Args:
-"msg: the message to echo
-function! s:echoError(msg)
-    echohl errormsg
-    call s:echo(a:msg)
-    echohl normal
-endfunction
-"FUNCTION: s:findNodeLineNumber(treenode){{{2
-"Finds the line number for the given tree node
-"
-"Args:
-"treenode: the node to find the line no. for
-function! s:findNodeLineNumber(treenode)
-    "if the node is the root then return the root line no.
-    if a:treenode.isRoot()
-        return s:findRootNodeLineNumber()
-    endif
-
-    let totalLines = line("$")
-
-    "the path components we have matched so far
-    let pathcomponents = [substitute(t:NERDTreeRoot.path.str(0), '/ *$', '', '')]
-    "the index of the component we are searching for
-    let curPathComponent = 1
-
-    let fullpath = a:treenode.path.str(0)
-
-
-    let lnum = s:findRootNodeLineNumber()
-    while lnum > 0
-        let lnum = lnum + 1
-        "have we reached the bottom of the tree?
-        if lnum == totalLines+1
-            return -1
-        endif
-
-        let curLine = getline(lnum)
-