From 177cf4fe59ef87083dde4d94ac93609c8d82ab0f Mon Sep 17 00:00:00 2001
From: James Browne <code@unculture.co.uk>
Date: Fri, 4 Feb 2011 15:18:09 +0000
Subject: [PATCH] First Commit

---
 .vim/.netrwhist                               |    2 +
 .vim/autoload/pathogen.vim                    |  139 +
 .vim/bundle/nerdtree/doc/NERD_tree.txt        | 1226 +++++
 .../nerdtree_plugin/exec_menuitem.vim         |   41 +
 .../nerdtree/nerdtree_plugin/fs_menu.vim      |  194 +
 .vim/bundle/nerdtree/plugin/NERD_tree.vim     | 4076 +++++++++++++++++
 .vim/bundle/vividchalk/colors/vividchalk.vim  |  191 +
 .vim/ftplugin/html/sparkup.py                 | 1087 +++++
 .vim/ftplugin/html/sparkup.vim                |   76 +
 .vimrc                                        |  175 +
 README                                        |    1 +
 11 files changed, 7208 insertions(+)
 create mode 100644 .vim/.netrwhist
 create mode 100644 .vim/autoload/pathogen.vim
 create mode 100644 .vim/bundle/nerdtree/doc/NERD_tree.txt
 create mode 100644 .vim/bundle/nerdtree/nerdtree_plugin/exec_menuitem.vim
 create mode 100644 .vim/bundle/nerdtree/nerdtree_plugin/fs_menu.vim
 create mode 100644 .vim/bundle/nerdtree/plugin/NERD_tree.vim
 create mode 100644 .vim/bundle/vividchalk/colors/vividchalk.vim
 create mode 100755 .vim/ftplugin/html/sparkup.py
 create mode 100644 .vim/ftplugin/html/sparkup.vim
 create mode 100644 .vimrc
 create mode 100644 README

diff --git a/.vim/.netrwhist b/.vim/.netrwhist
new file mode 100644
index 0000000..7771a52
--- /dev/null
+++ b/.vim/.netrwhist
@@ -0,0 +1,2 @@
+let g:netrw_dirhistmax  =10
+let g:netrw_dirhist_cnt =0
diff --git a/.vim/autoload/pathogen.vim b/.vim/autoload/pathogen.vim
new file mode 100644
index 0000000..ff7dba3
--- /dev/null
+++ b/.vim/autoload/pathogen.vim
@@ -0,0 +1,139 @@
+" pathogen.vim - path option manipulation
+" Maintainer:   Tim Pope <vimNOSPAM@tpope.org>
+" Version:      1.2
+
+" Install in ~/.vim/autoload (or ~\vimfiles\autoload).
+"
+" API is documented below.
+
+if exists("g:loaded_pathogen") || &cp
+  finish
+endif
+let g:loaded_pathogen = 1
+
+" Split a path into a list.
+function! pathogen#split(path) abort " {{{1
+  if type(a:path) == type([]) | return a:path | endif
+  let split = split(a:path,'\\\@<!\%(\\\\\)*\zs,')
+  return map(split,'substitute(v:val,''\\\([\\,]\)'',''\1'',"g")')
+endfunction " }}}1
+
+" Convert a list to a path.
+function! pathogen#join(...) abort " {{{1
+  if type(a:1) == type(1) && a:1
+    let i = 1
+    let space = ' '
+  else
+    let i = 0
+    let space = ''
+  endif
+  let path = ""
+  while i < a:0
+    if type(a:000[i]) == type([])
+      let list = a:000[i]
+      let j = 0
+      while j < len(list)
+        let escaped = substitute(list[j],'[,'.space.']\|\\[\,'.space.']\@=','\\&','g')
+        let path .= ',' . escaped
+        let j += 1
+      endwhile
+    else
+      let path .= "," . a:000[i]
+    endif
+    let i += 1
+  endwhile
+  return substitute(path,'^,','','')
+endfunction " }}}1
+
+" Convert a list to a path with escaped spaces for 'path', 'tag', etc.
+function! pathogen#legacyjoin(...) abort " {{{1
+  return call('pathogen#join',[1] + a:000)
+endfunction " }}}1
+
+" Remove duplicates from a list.
+function! pathogen#uniq(list) abort " {{{1
+  let i = 0
+  let seen = {}
+  while i < len(a:list)
+    if has_key(seen,a:list[i])
+      call remove(a:list,i)
+    else
+      let seen[a:list[i]] = 1
+      let i += 1
+    endif
+  endwhile
+  return a:list
+endfunction " }}}1
+
+" Returns a hash indicating which filetype features are enabled.
+function! pathogen#filetype() abort " {{{1
+  redir => output
+  silent filetype
+  redir END
+  let result = {}
+  let result.detection = match(output,'detection:ON') >= 0
+  let result.indent = match(output,'indent:ON') >= 0
+  let result.plugin = match(output,'plugin:ON') >= 0
+  return result
+endfunction " }}}1
+
+" \ on Windows unless shellslash is set, / everywhere else.
+function! pathogen#separator() abort " {{{1
+  return !exists("+shellslash") || &shellslash ? '/' : '\'
+endfunction " }}}1
+
+" Convenience wrapper around glob() which returns a list.
+function! pathogen#glob(pattern) abort " {{{1
+  let files = split(glob(a:pattern),"\n")
+  return map(files,'substitute(v:val,"[".pathogen#separator()."/]$","","")')
+endfunction "}}}1
+
+" Like pathogen#glob(), only limit the results to directories.
+function! pathogen#glob_directories(pattern) abort " {{{1
+  return filter(pathogen#glob(a:pattern),'isdirectory(v:val)')
+endfunction "}}}1
+
+" Prepend all subdirectories of path to the rtp, and append all after
+" directories in those subdirectories.
+function! pathogen#runtime_prepend_subdirectories(path) " {{{1
+  let sep    = pathogen#separator()
+  let before = pathogen#glob_directories(a:path.sep."*[^~]")
+  let after  = pathogen#glob_directories(a:path.sep."*[^~]".sep."after")
+  let rtp = pathogen#split(&rtp)
+  let path = expand(a:path)
+  call filter(rtp,'v:val[0:strlen(path)-1] !=# path')
+  let &rtp = pathogen#join(pathogen#uniq(before + rtp + after))
+  return &rtp
+endfunction " }}}1
+
+" For each directory in rtp, check for a subdirectory named dir.  If it
+" exists, add all subdirectories of that subdirectory to the rtp, immediately
+" after the original directory.  If no argument is given, 'bundle' is used.
+" Repeated calls with the same arguments are ignored.
+function! pathogen#runtime_append_all_bundles(...) " {{{1
+  let sep = pathogen#separator()
+  let name = a:0 ? a:1 : 'bundle'
+  let list = []
+  for dir in pathogen#split(&rtp)
+    if dir =~# '\<after$'
+      let list +=  pathogen#glob_directories(substitute(dir,'after$',name.sep.'*[^~]'.sep.'after','')) + [dir]
+    else
+      let list +=  [dir] + pathogen#glob_directories(dir.sep.name.sep.'*[^~]')
+    endif
+  endfor
+  let &rtp = pathogen#join(pathogen#uniq(list))
+  return 1
+endfunction
+
+" }}}1
+
+" Invoke :helptags on all non-$VIM doc directories in runtimepath.
+function! pathogen#helptags() " {{{1
+  for dir in pathogen#split(&rtp)
+    if dir[0 : strlen($VIM)-1] !=# $VIM && isdirectory(dir.'/doc') && (!filereadable(dir.'/doc/tags') || filewritable(dir.'/doc/tags'))
+      helptags `=dir.'/doc'`
+    endif
+  endfor
+endfunction " }}}1
+
+" vim:set ft=vim ts=8 sw=2 sts=2:
diff --git a/.vim/bundle/nerdtree/doc/NERD_tree.txt b/.vim/bundle/nerdtree/doc/NERD_tree.txt
new file mode 100644
index 0000000..5ff0651
--- /dev/null
+++ b/.vim/bundle/nerdtree/doc/NERD_tree.txt
@@ -0,0 +1,1226 @@
+*NERD_tree.txt*   A tree explorer plugin that owns your momma!
+
+
+
+    omg its ... ~
+
+    ________  ________   _   ____________  ____     __________  ____________~
+   /_  __/ / / / ____/  / | / / ____/ __ \/ __ \   /_  __/ __ \/ ____/ ____/~
+    / / / /_/ / __/    /  |/ / __/ / /_/ / / / /    / / / /_/ / __/ / __/   ~
+   / / / __  / /___   / /|  / /___/ _, _/ /_/ /    / / / _, _/ /___/ /___   ~
+  /_/ /_/ /_/_____/  /_/ |_/_____/_/ |_/_____/    /_/ /_/ |_/_____/_____/   ~
+
+
+                              Reference Manual~
+
+
+
+
+==============================================================================
+CONTENTS                                                   *NERDTree-contents*
+
+    1.Intro...................................|NERDTree|
+    2.Functionality provided..................|NERDTreeFunctionality|
+        2.1.Global commands...................|NERDTreeGlobalCommands|
+        2.2.Bookmarks.........................|NERDTreeBookmarks|
+            2.2.1.The bookmark table..........|NERDTreeBookmarkTable|
+            2.2.2.Bookmark commands...........|NERDTreeBookmarkCommands|
+            2.2.3.Invalid bookmarks...........|NERDTreeInvalidBookmarks|
+        2.3.NERD tree mappings................|NERDTreeMappings|
+        2.4.The NERD tree menu................|NERDTreeMenu|
+    3.Options.................................|NERDTreeOptions|
+        3.1.Option summary....................|NERDTreeOptionSummary|
+        3.2.Option details....................|NERDTreeOptionDetails|
+    4.The NERD tree API.......................|NERDTreeAPI|
+        4.1.Key map API.......................|NERDTreeKeymapAPI|
+        4.2.Menu API..........................|NERDTreeMenuAPI|
+    5.About...................................|NERDTreeAbout|
+    6.Changelog...............................|NERDTreeChangelog|
+    7.Credits.................................|NERDTreeCredits|
+    8.License.................................|NERDTreeLicense|
+
+==============================================================================
+1. Intro                                                            *NERDTree*
+
+What is this "NERD tree"??
+
+The NERD tree allows you to explore your filesystem and to open files and
+directories. It presents the filesystem to you in the form of a tree which you
+manipulate with the keyboard and/or mouse. It also allows you to perform
+simple filesystem operations.
+
+The following features and functionality are provided by the NERD tree:
+    * Files and directories are displayed in a hierarchical tree structure
+    * Different highlighting is provided for the following types of nodes:
+        * files
+        * directories
+        * sym-links
+        * windows .lnk files
+        * read-only files
+        * executable files
+    * Many (customisable) mappings are provided to manipulate the tree:
+        * Mappings to open/close/explore directory nodes
+        * Mappings to open files in new/existing windows/tabs
+        * Mappings to change the current root of the tree
+        * Mappings to navigate around the tree
+        * ...
+    * Directories and files can be bookmarked.
+    * Most NERD tree navigation can also be done with the mouse
+    * Filtering of tree content (can be toggled at runtime)
+        * custom file filters to prevent e.g. vim backup files being displayed
+        * optional displaying of hidden files (. files)
+        * files can be "turned off" so that only directories are displayed
+    * The position and size of the NERD tree window can be customised
+    * The order in which the nodes in the tree are listed can be customised.
+    * A model of your filesystem is created/maintained as you explore it. This
+      has several advantages:
+        * All filesystem information is cached and is only re-read on demand
+        * If you revisit a part of the tree that you left earlier in your
+          session, the directory nodes will be opened/closed as you left them
+    * The script remembers the cursor position and window position in the NERD
+      tree so you can toggle it off (or just close the tree window) and then
+      reopen it (with NERDTreeToggle) the NERD tree window will appear exactly
+      as you left it
+    * You can have a separate NERD tree for each tab, share trees across tabs,
+      or a mix of both.
+    * By default the script overrides the default file browser (netw), so if
+      you :edit a directory a (slighly modified) NERD tree will appear in the
+      current window
+    * A programmable menu system is provided (simulates right clicking on a
+      node)
+        * one default menu plugin is provided to perform basic filesytem
+          operations (create/delete/move/copy files/directories)
+    * There's an API for adding your own keymappings
+
+
+==============================================================================
+2. Functionality provided                              *NERDTreeFunctionality*
+
+------------------------------------------------------------------------------
+2.1. Global Commands                                  *NERDTreeGlobalCommands*
+
+:NERDTree [<start-directory> | <bookmark>]                         *:NERDTree*
+    Opens a fresh NERD tree. The root of the tree depends on the argument
+    given. There are 3 cases: If no argument is given, the current directory
+    will be used.  If a directory is given, that will be used. If a bookmark
+    name is given, the corresponding directory will be used.  For example: >
+        :NERDTree /home/marty/vim7/src
+        :NERDTree foo   (foo is the name of a bookmark)
+<
+:NERDTreeFromBookmark <bookmark>                       *:NERDTreeFromBookmark*
+    Opens a fresh NERD tree with the root initialized to the dir for
+    <bookmark>.  This only reason to use this command over :NERDTree is for
+    the completion (which is for bookmarks rather than directories).
+
+:NERDTreeToggle [<start-directory> | <bookmark>]             *:NERDTreeToggle*
+    If a NERD tree already exists for this tab, it is reopened and rendered
+    again.  If no NERD tree exists for this tab then this command acts the
+    same as the |:NERDTree| command.
+
+:NERDTreeMirror                                              *:NERDTreeMirror*
+    Shares an existing NERD tree, from another tab, in the current tab.
+    Changes made to one tree are reflected in both as they are actually the
+    same buffer.
+
+    If only one other NERD tree exists, that tree is automatically mirrored. If
+    more than one exists, the script will ask which tree to mirror.
+
+:NERDTreeClose                                                *:NERDTreeClose*
+    Close the NERD tree in this tab.
+
+:NERDTreeFind                                                  *:NERDTreeFind*
+    Find the current file in the tree. If no tree exists for the current tab,
+    or the file is not under the current root, then initialize a new tree where
+    the root is the directory of the current file.
+
+------------------------------------------------------------------------------
+2.2. Bookmarks                                             *NERDTreeBookmarks*
+
+Bookmarks in the NERD tree are a way to tag files or directories of interest.
+For example, you could use bookmarks to tag all of your project directories.
+
+------------------------------------------------------------------------------
+2.2.1. The Bookmark Table                              *NERDTreeBookmarkTable*
+
+If the bookmark table is active (see |NERDTree-B| and
+|'NERDTreeShowBookmarks'|), it will be rendered above the tree. You can double
+click bookmarks or use the |NERDTree-o| mapping to activate them. See also,
+|NERDTree-t| and |NERDTree-T|
+
+------------------------------------------------------------------------------
+2.2.2. Bookmark commands                            *NERDTreeBookmarkCommands*
+
+Note that the following commands are only available in the NERD tree buffer.
+
+:Bookmark <name>
+    Bookmark the current node as <name>. If there is already a <name>
+    bookmark, it is overwritten. <name> must not contain spaces.
+
+:BookmarkToRoot <bookmark>
+    Make the directory corresponding to <bookmark> the new root. If a treenode
+    corresponding to <bookmark> is already cached somewhere in the tree then
+    the current tree will be used, otherwise a fresh tree will be opened.
+    Note that if <bookmark> points to a file then its parent will be used
+    instead.
+
+:RevealBookmark <bookmark>
+    If the node is cached under the current root then it will be revealed
+    (i.e. directory nodes above it will be opened) and the cursor will be
+    placed on it.
+
+:OpenBookmark <bookmark>
+    <bookmark> must point to a file. The file is opened as though |NERDTree-o|
+    was applied. If the node is cached under the current root then it will be
+    revealed and the cursor will be placed on it.
+
+:ClearBookmarks [<bookmarks>]
+    Remove all the given bookmarks. If no bookmarks are given then remove all
+    bookmarks on the current node.
+
+:ClearAllBookmarks
+    Remove all bookmarks.
+
+:ReadBookmarks
+    Re-read the bookmarks in the |'NERDTreeBookmarksFile'|.
+
+See also |:NERDTree| and |:NERDTreeFromBookmark|.
+
+------------------------------------------------------------------------------
+2.2.3. Invalid Bookmarks                            *NERDTreeInvalidBookmarks*
+
+If invalid bookmarks are detected, the script will issue an error message and
+the invalid bookmarks will become unavailable for use.
+
+These bookmarks will still be stored in the bookmarks file (see
+|'NERDTreeBookmarksFile'|), down the bottom. There will always be a blank line
+after the valid bookmarks but before the invalid ones.
+
+Each line in the bookmarks file represents one bookmark. The proper format is:
+<bookmark name><space><full path to the bookmark location>
+
+After you have corrected any invalid bookmarks, either restart vim, or go
+:ReadBookmarks from the NERD tree window.
+
+------------------------------------------------------------------------------
+2.3. NERD tree Mappings                                     *NERDTreeMappings*
+
+Default  Description~                                             help-tag~
+Key~
+
+o.......Open files, directories and bookmarks....................|NERDTree-o|
+go......Open selected file, but leave cursor in the NERDTree.....|NERDTree-go|
+t.......Open selected node/bookmark in a new tab.................|NERDTree-t|
+T.......Same as 't' but keep the focus on the current tab........|NERDTree-T|
+i.......Open selected file in a split window.....................|NERDTree-i|
+gi......Same as i, but leave the cursor on the NERDTree..........|NERDTree-gi|
+s.......Open selected file in a new vsplit.......................|NERDTree-s|
+gs......Same as s, but leave the cursor on the NERDTree..........|NERDTree-gs|
+O.......Recursively open the selected directory..................|NERDTree-O|
+x.......Close the current nodes parent...........................|NERDTree-x|
+X.......Recursively close all children of the current node.......|NERDTree-X|
+e.......Edit the current dif.....................................|NERDTree-e|
+
+<CR>...............same as |NERDTree-o|.
+double-click.......same as the |NERDTree-o| map.
+middle-click.......same as |NERDTree-i| for files, same as
+                   |NERDTree-e| for dirs.
+
+D.......Delete the current bookmark .............................|NERDTree-D|
+
+P.......Jump to the root node....................................|NERDTree-P|
+p.......Jump to current nodes parent.............................|NERDTree-p|
+K.......Jump up inside directories at the current tree depth.....|NERDTree-K|
+J.......Jump down inside directories at the current tree depth...|NERDTree-J|
+<C-J>...Jump down to the next sibling of the current directory...|NERDTree-C-J|
+<C-K>...Jump up to the previous sibling of the current directory.|NERDTree-C-K|
+
+C.......Change the tree root to the selected dir.................|NERDTree-C|
+u.......Move the tree root up one directory......................|NERDTree-u|
+U.......Same as 'u' except the old root node is left open........|NERDTree-U|
+r.......Recursively refresh the current directory................|NERDTree-r|
+R.......Recursively refresh the current root.....................|NERDTree-R|
+m.......Display the NERD tree menu...............................|NERDTree-m|
+cd......Change the CWD to the dir of the selected node...........|NERDTree-cd|
+
+I.......Toggle whether hidden files displayed....................|NERDTree-I|
+f.......Toggle whether the file filters are used.................|NERDTree-f|
+F.......Toggle whether files are displayed.......................|NERDTree-F|
+B.......Toggle whether the bookmark table is displayed...........|NERDTree-B|
+
+q.......Close the NERDTree window................................|NERDTree-q|
+A.......Zoom (maximize/minimize) the NERDTree window.............|NERDTree-A|
+?.......Toggle the display of the quick help.....................|NERDTree-?|
+
+------------------------------------------------------------------------------
+                                                                  *NERDTree-o*
+Default key: o
+Map option: NERDTreeMapActivateNode
+Applies to: files and directories.
+
+If a file node is selected, it is opened in the previous window.
+
+If a directory is selected it is opened or closed depending on its current
+state.
+
+If a bookmark that links to a directory is selected then that directory
+becomes the new root.
+
+If a bookmark that links to a file is selected then that file is opened in the
+previous window.
+
+------------------------------------------------------------------------------
+                                                                 *NERDTree-go*
+Default key: go
+Map option: None
+Applies to: files.
+
+If a file node is selected, it is opened in the previous window, but the
+cursor does not move.
+
+The key combo for this mapping is always "g" + NERDTreeMapActivateNode (see
+|NERDTree-o|).
+
+------------------------------------------------------------------------------
+                                                                  *NERDTree-t*
+Default key: t
+Map option: NERDTreeMapOpenInTab
+Applies to: files and directories.
+
+Opens the selected file in a new tab. If a directory is selected, a fresh
+NERD Tree for that directory is opened in a new tab.
+
+If a bookmark which points to a directory is selected, open a NERD tree for
+that directory in a new tab. If the bookmark points to a file, open that file
+in a new tab.
+
+------------------------------------------------------------------------------
+                                                                  *NERDTree-T*
+Default key: T
+Map option: NERDTreeMapOpenInTabSilent
+Applies to: files and directories.
+
+The same as |NERDTree-t| except that the focus is kept in the current tab.
+
+------------------------------------------------------------------------------
+                                                                  *NERDTree-i*
+Default key: i
+Map option: NERDTreeMapOpenSplit
+Applies to: files.
+
+Opens the selected file in a new split window and puts the cursor in the new
+window.
+
+------------------------------------------------------------------------------
+                                                                 *NERDTree-gi*
+Default key: gi
+Map option: None
+Applies to: files.
+
+The same as |NERDTree-i| except that the cursor is not moved.
+
+The key combo for this mapping is always "g" + NERDTreeMapOpenSplit (see
+|NERDTree-i|).
+
+------------------------------------------------------------------------------
+                                                                  *NERDTree-s*
+Default key: s
+Map option: NERDTreeMapOpenVSplit
+Applies to: files.
+
+Opens the selected file in a new vertically split window and puts the cursor in
+the new window.
+
+------------------------------------------------------------------------------
+                                                                 *NERDTree-gs*
+Default key: gs
+Map option: None
+Applies to: files.
+
+The same as |NERDTree-s| except that the cursor is not moved.
+
+The key combo for this mapping is always "g" + NERDTreeMapOpenVSplit (see
+|NERDTree-s|).
+
+------------------------------------------------------------------------------
+                                                                  *NERDTree-O*
+Default key: O
+Map option: NERDTreeMapOpenRecursively
+Applies to: directories.
+
+Recursively opens the selelected directory.
+
+All files and directories are cached, but if a directory would not be
+displayed due to file filters (see |'NERDTreeIgnore'| |NERDTree-f|) or the
+hidden file filter (see |'NERDTreeShowHidden'|) then its contents are not
+cached. This is handy, especially if you have .svn directories.
+
+------------------------------------------------------------------------------
+                                                                  *NERDTree-x*
+Default key: x
+Map option: NERDTreeMapCloseDir
+Applies to: files and directories.
+
+Closes the parent of the selected node.
+
+------------------------------------------------------------------------------
+                                                                  *NERDTree-X*
+Default key: X
+Map option: NERDTreeMapCloseChildren
+Applies to: directories.
+
+Recursively closes all children of the selected directory.
+
+Tip: To quickly "reset" the tree, use |NERDTree-P| with this mapping.
+
+------------------------------------------------------------------------------
+                                                                  *NERDTree-e*
+Default key: e
+Map option: NERDTreeMapOpenExpl
+Applies to: files and directories.
+
+|:edit|s the selected directory, or the selected file's directory. This could
+result in a NERD tree or a netrw being opened, depending on
+|'NERDTreeHijackNetrw'|.
+
+------------------------------------------------------------------------------
+                                                                  *NERDTree-D*
+Default key: D
+Map option: NERDTreeMapDeleteBookmark
+Applies to: lines in the bookmarks table
+
+Deletes the currently selected bookmark.
+
+------------------------------------------------------------------------------
+                                                                  *NERDTree-P*
+Default key: P
+Map option: NERDTreeMapJumpRoot
+Applies to: no restrictions.
+
+Jump to the tree root.
+
+------------------------------------------------------------------------------
+                                                                  *NERDTree-p*
+Default key: p
+Map option: NERDTreeMapJumpParent
+Applies to: files and directories.
+
+Jump to the parent node of the selected node.
+
+------------------------------------------------------------------------------
+                                                                  *NERDTree-K*
+Default key: K
+Map option: NERDTreeMapJumpFirstChild
+Applies to: files and directories.
+
+Jump to the first child of the current nodes parent.
+
+If the cursor is already on the first node then do the following:
+    * loop back thru the siblings of the current nodes parent until we find an
+      open dir with children
+    * go to the first child of that node
+
+------------------------------------------------------------------------------
+                                                                  *NERDTree-J*
+Default key: J
+Map option: NERDTreeMapJumpLastChild
+Applies to: files and directories.
+
+Jump to the last child of the current nodes parent.
+
+If the cursor is already on the last node then do the following:
+    * loop forward thru the siblings of the current nodes parent until we find
+      an open dir with children
+    * go to the last child of that node
+
+------------------------------------------------------------------------------
+                                                                *NERDTree-C-J*
+Default key: <C-J>
+Map option: NERDTreeMapJumpNextSibling
+Applies to: files and directories.
+
+Jump to the next sibling of the selected node.
+
+------------------------------------------------------------------------------
+                                                                *NERDTree-C-K*
+Default key: <C-K>
+Map option: NERDTreeMapJumpPrevSibling
+Applies to: files and directories.
+
+Jump to the previous sibling of the selected node.
+
+------------------------------------------------------------------------------
+                                                                  *NERDTree-C*
+Default key: C
+Map option: NERDTreeMapChdir
+Applies to: directories.
+
+Make the selected directory node the new tree root. If a file is selected, its
+parent is used.
+
+------------------------------------------------------------------------------
+                                                                  *NERDTree-u*
+Default key: u
+Map option: NERDTreeMapUpdir
+Applies to: no restrictions.
+
+Move the tree root up a dir (like doing a "cd ..").
+
+------------------------------------------------------------------------------
+                                                                  *NERDTree-U*
+Default key: U
+Map option: NERDTreeMapUpdirKeepOpen
+Applies to: no restrictions.
+
+Like |NERDTree-u| except that the old tree root is kept open.
+
+------------------------------------------------------------------------------
+                                                                  *NERDTree-r*
+Default key: r
+Map option: NERDTreeMapRefresh
+Applies to: files and directories.
+
+If a dir is selected, recursively refresh that dir, i.e. scan the filesystem
+for changes and represent them in the tree.
+
+If a file node is selected then the above is done on it's parent.
+
+------------------------------------------------------------------------------
+                                                                  *NERDTree-R*
+Default key: R
+Map option: NERDTreeMapRefreshRoot
+Applies to: no restrictions.
+
+Recursively refresh the tree root.
+
+------------------------------------------------------------------------------
+                                                                  *NERDTree-m*
+Default key: m
+Map option: NERDTreeMapMenu
+Applies to: files and directories.
+
+Display the NERD tree menu. See |NERDTreeMenu| for details.
+
+------------------------------------------------------------------------------
+                                                                 *NERDTree-cd*
+Default key: cd
+Map option: NERDTreeMapChdir
+Applies to: files and directories.
+
+Change vims current working directory to that of the selected node.
+
+------------------------------------------------------------------------------
+                                                                  *NERDTree-I*
+Default key: I
+Map option: NERDTreeMapToggleHidden
+Applies to: no restrictions.
+
+Toggles whether hidden files (i.e. "dot files") are displayed.
+
+------------------------------------------------------------------------------
+                                                                  *NERDTree-f*
+Default key: f
+Map option: NERDTreeMapToggleFilters
+Applies to: no restrictions.
+
+Toggles whether file filters are used. See |'NERDTreeIgnore'| for details.
+
+------------------------------------------------------------------------------
+                                                                  *NERDTree-F*
+Default key: F
+Map option: NERDTreeMapToggleFiles
+Applies to: no restrictions.
+
+Toggles whether file nodes are displayed.
+
+------------------------------------------------------------------------------
+                                                                  *NERDTree-B*
+Default key: B
+Map option: NERDTreeMapToggleBookmarks
+Applies to: no restrictions.
+
+Toggles whether the bookmarks table is displayed.
+
+------------------------------------------------------------------------------
+                                                                  *NERDTree-q*
+Default key: q
+Map option: NERDTreeMapQuit
+Applies to: no restrictions.
+
+Closes the NERDtree window.
+
+------------------------------------------------------------------------------
+                                                                  *NERDTree-A*
+Default key: A
+Map option: NERDTreeMapToggleZoom
+Applies to: no restrictions.
+
+Maximize (zoom) and minimize the NERDtree window.
+
+------------------------------------------------------------------------------
+                                                                  *NERDTree-?*
+Default key: ?
+Map option: NERDTreeMapHelp
+Applies to: no restrictions.
+
+Toggles whether the quickhelp is displayed.
+
+------------------------------------------------------------------------------
+2.3. The NERD tree menu                                         *NERDTreeMenu*
+
+The NERD tree has a menu that can be programmed via the an API (see
+|NERDTreeMenuAPI|). The idea is to simulate the "right click" menus that most
+file explorers have.
+
+The script comes with two default menu plugins: exec_menuitem.vim and
+fs_menu.vim. fs_menu.vim adds some basic filesystem operations to the menu for
+creating/deleting/moving/copying files and dirs. exec_menuitem.vim provides a
+menu item to execute executable files.
+
+Related tags: |NERDTree-m| |NERDTreeApi|
+
+==============================================================================
+3. Customisation                                             *NERDTreeOptions*
+
+
+------------------------------------------------------------------------------
+3.1. Customisation summary                             *NERDTreeOptionSummary*
+
+The script provides the following options that can customise the behaviour the
+NERD tree. These options should be set in your vimrc.
+
+|'loaded_nerd_tree'|            Turns off the script.
+
+|'NERDChristmasTree'|           Tells the NERD tree to make itself colourful
+                                and pretty.
+
+|'NERDTreeAutoCenter'|          Controls whether the NERD tree window centers
+                                when the cursor moves within a specified
+                                distance to the top/bottom of the window.
+|'NERDTreeAutoCenterThreshold'| Controls the sensitivity of autocentering.
+
+|'NERDTreeCaseSensitiveSort'|   Tells the NERD tree whether to be case
+                                sensitive or not when sorting nodes.
+
+|'NERDTreeChDirMode'|           Tells the NERD tree if/when it should change
+                                vim's current working directory.
+
+|'NERDTreeHighlightCursorline'| Tell the NERD tree whether to highlight the
+                                current cursor line.
+
+|'NERDTreeHijackNetrw'|         Tell the NERD tree whether to replace the netrw
+                                autocommands for exploring local directories.
+
+|'NERDTreeIgnore'|              Tells the NERD tree which files to ignore.
+
+|'NERDTreeBookmarksFile'|       Where the bookmarks are stored.
+
+|'NERDTreeMouseMode'|           Tells the NERD tree how to handle mouse
+                                clicks.
+
+|'NERDTreeQuitOnOpen'|          Closes the tree window after opening a file.
+
+|'NERDTreeShowBookmarks'|       Tells the NERD tree whether to display the
+                                bookmarks table on startup.
+
+|'NERDTreeShowFiles'|           Tells the NERD tree whether to display files
+                                in the tree on startup.
+
+|'NERDTreeShowHidden'|          Tells the NERD tree whether to display hidden
+                                files on startup.
+
+|'NERDTreeShowLineNumbers'|     Tells the NERD tree whether to display line
+                                numbers in the tree window.
+
+|'NERDTreeSortOrder'|           Tell the NERD tree how to sort the nodes in
+                                the tree.
+
+|'NERDTreeStatusline'|          Set a statusline for NERD tree windows.
+
+|'NERDTreeWinPos'|              Tells the script where to put the NERD tree
+                                window.
+
+|'NERDTreeWinSize'|             Sets the window size when the NERD tree is
+                                opened.
+
+------------------------------------------------------------------------------
+3.2. Customisation details                             *NERDTreeOptionDetails*
+
+To enable any of the below options you should put the given line in your
+~/.vimrc
+
+                                                          *'loaded_nerd_tree'*
+If this plugin is making you feel homicidal, it may be a good idea to turn it
+off with this line in your vimrc: >
+    let loaded_nerd_tree=1
+<
+------------------------------------------------------------------------------
+                                                         *'NERDChristmasTree'*
+Values: 0 or 1.
+Default: 1.
+
+If this option is set to 1 then some extra syntax highlighting elements are
+added to the nerd tree to make it more colourful.
+
+Set it to 0 for a more vanilla looking tree.
+
+------------------------------------------------------------------------------
+                                                        *'NERDTreeAutoCenter'*
+Values: 0 or 1.
+Default: 1
+
+If set to 1, the NERD tree window will center around the cursor if it moves to
+within |'NERDTreeAutoCenterThreshold'| lines of the top/bottom of the window.
+
+This is ONLY done in response to tree navigation mappings,
+i.e. |NERDTree-J| |NERDTree-K| |NERDTree-C-J| |NERDTree-C-K| |NERDTree-p|
+|NERDTree-P|
+
+The centering is done with a |zz| operation.
+
+------------------------------------------------------------------------------
+                                               *'NERDTreeAutoCenterThreshold'*
+Values: Any natural number.
+Default: 3
+
+This option controls the "sensitivity" of the NERD tree auto centering. See
+|'NERDTreeAutoCenter'| for details.
+
+------------------------------------------------------------------------------
+                                                 *'NERDTreeCaseSensitiveSort'*
+Values: 0 or 1.
+Default: 0.
+
+By default the NERD tree does not sort nodes case sensitively, i.e. nodes
+could appear like this: >
+    bar.c
+    Baz.c
+    blarg.c
+    boner.c
+    Foo.c
+<
+But, if you set this option to 1 then the case of the nodes will be taken into
+account. The above nodes would then be sorted like this: >
+    Baz.c
+    Foo.c
+    bar.c
+    blarg.c
+    boner.c
+<
+------------------------------------------------------------------------------
+                                                         *'NERDTreeChDirMode'*
+
+Values: 0, 1 or 2.
+Default: 0.
+
+Use this option to tell the script when (if at all) to change the current
+working directory (CWD) for vim.
+
+If it is set to 0 then the CWD is never changed by the NERD tree.
+
+If set to 1 then the CWD is changed when the NERD tree is first loaded to the
+directory it is initialized in. For example, if you start the NERD tree with >
+    :NERDTree /home/marty/foobar
+<
+then the CWD will be changed to /home/marty/foobar and will not be changed
+again unless you init another NERD tree with a similar command.
+
+If the option is set to 2 then it behaves the same as if set to 1 except that
+the CWD is changed whenever the tree root is changed. For example, if the CWD
+is /home/marty/foobar and you make the node for /home/marty/foobar/baz the new
+root then the CWD will become /home/marty/foobar/baz.
+
+------------------------------------------------------------------------------
+                                               *'NERDTreeHighlightCursorline'*
+Values: 0 or 1.
+Default: 1.
+
+If set to 1, the current cursor line in the NERD tree buffer will be
+highlighted. This is done using the |'cursorline'| option.
+
+------------------------------------------------------------------------------
+                                                       *'NERDTreeHijackNetrw'*
+Values: 0 or 1.
+Default: 1.
+
+If set to 1, doing a >
+    :edit <some directory>
+<
+will open up a "secondary" NERD tree instead of a netrw in the target window.
+
+Secondary NERD trees behaves slighly different from a regular trees in the
+following respects:
+    1. 'o' will open the selected file in the same window as the tree,
+       replacing it.
+    2. you can have as many secondary tree as you want in the same tab.
+
+------------------------------------------------------------------------------
+                                                            *'NERDTreeIgnore'*
+Values: a list of regular expressions.
+Default: ['\~$'].
+
+This option is used to specify which files the NERD tree should ignore.  It
+must be a list of regular expressions. When the NERD tree is rendered, any
+files/dirs that match any of the regex's in 'NERDTreeIgnore' wont be
+displayed.
+
+For example if you put the following line in your vimrc: >
+    let NERDTreeIgnore=['\.vim$', '\~$']
+<
+then all files ending in .vim or ~ will be ignored.
+
+Note: to tell the NERD tree not to ignore any files you must use the following
+line: >
+    let NERDTreeIgnore=[]
+<
+
+The file filters can be turned on and off dynamically with the |NERDTree-f|
+mapping.
+
+------------------------------------------------------------------------------
+                                                     *'NERDTreeBookmarksFile'*
+Values: a path
+Default: $HOME/.NERDTreeBookmarks
+
+This is where bookmarks are saved. See |NERDTreeBookmarkCommands|.
+
+------------------------------------------------------------------------------
+                                                       *'NERDTreeMouseMode'*
+Values: 1, 2 or 3.
+Default: 1.
+
+If set to 1 then a double click on a node is required to open it.
+If set to 2 then a single click will open directory nodes, while a double
+click will still be required for file nodes.
+If set to 3 then a single click will open any node.
+
+Note: a double click anywhere on a line that a tree node is on will
+activate it, but all single-click activations must be done on name of the node
+itself. For example, if you have the following node: >
+    | | |-application.rb
+<
+then (to single click activate it) you must click somewhere in
+'application.rb'.
+
+------------------------------------------------------------------------------
+                                                        *'NERDTreeQuitOnOpen'*
+
+Values: 0 or 1.
+Default: 0
+
+If set to 1, the NERD tree window will close after opening a file with the
+|NERDTree-o|, |NERDTree-i|, |NERDTree-t| and |NERDTree-T| mappings.
+
+------------------------------------------------------------------------------
+                                                     *'NERDTreeShowBookmarks'*
+Values: 0 or 1.
+Default: 0.
+
+If this option is set to 1 then the bookmarks table will be displayed.
+
+This option can be toggled dynamically, per tree, with the |NERDTree-B|
+mapping.
+
+------------------------------------------------------------------------------
+                                                         *'NERDTreeShowFiles'*
+Values: 0 or 1.
+Default: 1.
+
+If this option is set to 1 then files are displayed in the NERD tree. If it is
+set to 0 then only directories are displayed.
+
+This option can be toggled dynamically, per tree, with the |NERDTree-F|
+mapping and is useful for drastically shrinking the tree when you are
+navigating to a different part of the tree.
+
+------------------------------------------------------------------------------
+                                                        *'NERDTreeShowHidden'*
+Values: 0 or 1.
+Default: 0.
+
+This option tells vim whether to display hidden files by default. This option
+can be dynamically toggled, per tree, with the |NERDTree-I| mapping.  Use one
+of the follow lines to set this option: >
+    let NERDTreeShowHidden=0
+    let NERDTreeShowHidden=1
+<
+
+------------------------------------------------------------------------------
+                                                   *'NERDTreeShowLineNumbers'*
+Values: 0 or 1.
+Default: 0.
+
+This option tells vim whether to display line numbers for the NERD tree
+window.  Use one of the follow lines to set this option: >
+    let NERDTreeShowLineNumbers=0
+    let NERDTreeShowLineNumbers=1
+<
+
+------------------------------------------------------------------------------
+                                                         *'NERDTreeSortOrder'*
+Values: a list of regular expressions.
+Default: ['\/$', '*', '\.swp$',  '\.bak$', '\~$']
+
+This option is set to a list of regular expressions which are used to
+specify the order of nodes under their parent.
+
+For example, if the option is set to: >
+    ['\.vim$', '\.c$', '\.h$', '*', 'foobar']
+<
+then all .vim files will be placed at the top, followed by all .c files then
+all .h files. All files containing the string 'foobar' will be placed at the
+end.  The star is a special flag: it tells the script that every node that
+doesnt match any of the other regexps should be placed here.
+
+If no star is present in 'NERDTreeSortOrder' then one is automatically
+appended to the array.
+
+The regex '\/$' should be used to match directory nodes.
+
+After this sorting is done, the files in each group are sorted alphabetically.
+
+Other examples: >
+    (1) ['*', '\/$']
+    (2) []
+    (3) ['\/$', '\.rb$', '\.php$', '*', '\.swp$',  '\.bak$', '\~$']
+<
+1. Directories will appear last, everything else will appear above.
+2. Everything will simply appear in alphabetical order.
+3. Dirs will appear first, then ruby and php. Swap files, bak files and vim
+   backup files will appear last with everything else preceding them.
+
+------------------------------------------------------------------------------
+                                                        *'NERDTreeStatusline'*
+Values: Any valid statusline setting.
+Default: %{b:NERDTreeRoot.path.strForOS(0)}
+
+Tells the script what to use as the |'statusline'| setting for NERD tree
+windows.
+
+Note that the statusline is set using |:let-&| not |:set| so escaping spaces
+isn't necessary.
+
+Setting this option to -1 will will deactivate it so that your global
+statusline setting is used instead.
+
+------------------------------------------------------------------------------
+                                                            *'NERDTreeWinPos'*
+Values: "left" or "right"
+Default: "left".
+
+This option is used to determine where NERD tree window is placed on the
+screen.
+
+This option makes it possible to use two different explorer plugins
+simultaneously. For example, you could have the taglist plugin on the left of
+the window and the NERD tree on the right.
+
+------------------------------------------------------------------------------
+                                                           *'NERDTreeWinSize'*
+Values: a positive integer.
+Default: 31.
+
+This option is used to change the size of the NERD tree when it is loaded.
+
+==============================================================================
+4. The NERD tree API                                             *NERDTreeAPI*
+
+The NERD tree script allows you to add custom key mappings and menu items via
+a set of API calls. Any scripts that use this API should be placed in
+~/.vim/nerdtree_plugin/ (*nix) or ~/vimfiles/nerdtree_plugin (windows).
+
+The script exposes some prototype objects that can be used to manipulate the
+tree and/or get information from it: >
+    g:NERDTreePath
+    g:NERDTreeDirNode
+    g:NERDTreeFileNode
+    g:NERDTreeBookmark
+<
+See the code/comments in NERD_tree.vim to find how to use these objects. The
+following code conventions are used:
+    * class members start with a capital letter
+    * instance members start with a lower case letter
+    * private members start with an underscore
+
+See this blog post for more details:
+ http://got-ravings.blogspot.com/2008/09/vim-pr0n-prototype-based-objects.html
+
+------------------------------------------------------------------------------
+4.1. Key map API                                           *NERDTreeKeymapAPI*
+
+NERDTreeAddKeyMap({options})                             *NERDTreeAddKeyMap()*
+    Adds a new keymapping for all NERD tree buffers.
+    {options} must be a dictionary, and must contain the following keys:
+    "key" - the trigger key for the new mapping
+    "callback" - the function the new mapping will be bound to
+    "quickhelpText" - the text that will appear in the quickhelp (see
+    |NERDTree-?|)
+
+    Example: >
+        call NERDTreeAddKeyMap({
+               \ 'key': 'b',
+               \ 'callback': 'NERDTreeEchoCurrentNode',
+               \ 'quickhelpText': 'echo full path of current node' })
+
+        function! NERDTreeEchoCurrentNode()
+            let n = g:NERDTreeFileNode.GetSelected()
+            if n != {}
+                echomsg 'Current node: ' . n.path.str()
+            endif
+        endfunction
+<
+    This code should sit in a file like ~/.vim/nerdtree_plugin/mymapping.vim.
+    It adds a (rather useless) mapping on 'b' which echos the full path to the
+    current node.
+
+------------------------------------------------------------------------------
+4.2. Menu API                                                *NERDTreeMenuAPI*
+
+NERDTreeAddSubmenu({options})                           *NERDTreeAddSubmenu()*
+    Creates and returns a new submenu.
+
+    {options} must be a dictionary and must contain the following keys:
+    "text" - the text of the submenu that the user will see
+    "shortcut" - a shortcut key for the submenu (need not be unique)
+
+    The following keys are optional:
+    "isActiveCallback" - a function that will be called to determine whether
+    this submenu item will be displayed or not. The callback function must return
+    0 or 1.
+    "parent" - the parent submenu of the new submenu (returned from a previous
+    invocation of NERDTreeAddSubmenu()). If this key is left out then the new
+    submenu will sit under the top level menu.
+
+    See below for an example.
+
+NERDTreeAddMenuItem({options})                         *NERDTreeAddMenuItem()*
+    Adds a new menu item to the NERD tree menu (see |NERDTreeMenu|).
+
+    {options} must be a dictionary and must contain the
+    following keys:
+    "text" - the text of the menu item which the user will see
+    "shortcut" - a shortcut key for the menu item (need not be unique)
+    "callback" - the function that will be called when the user activates the
+    menu item.
+
+    The following keys are optional:
+    "isActiveCallback" - a function that will be called to determine whether
+    this menu item will be displayed or not. The callback function must return
+    0 or 1.
+    "parent" - if the menu item belongs under a submenu then this key must be
+    specified. This value for this key will be the object that
+    was returned when the submenu was created with |NERDTreeAddSubmenu()|.
+
+    See below for an example.
+
+NERDTreeAddMenuSeparator([{options}])             *NERDTreeAddMenuSeparator()*
+    Adds a menu separator (a row of dashes).
+
+    {options} is an optional dictionary that may contain the following keys:
+    "isActiveCallback" - see description in |NERDTreeAddMenuItem()|.
+
+Below is an example of the menu API in action. >
+    call NERDTreeAddMenuSeparator()
+
+    call NERDTreeAddMenuItem({
+                \ 'text': 'a (t)op level menu item',
+                \ 'shortcut': 't',
+                \ 'callback': 'SomeFunction' })
+
+    let submenu = NERDTreeAddSubmenu({
+                \ 'text': 'a (s)ub menu',
+                \ 'shortcut': 's' })
+
+    call NERDTreeAddMenuItem({
+                \ 'text': '(n)ested item 1',
+                \ 'shortcut': 'n',
+                \ 'callback': 'SomeFunction',
+                \ 'parent': submenu })
+
+    call NERDTreeAddMenuItem({
+                \ 'text': '(n)ested item 2',
+                \ 'shortcut': 'n',
+                \ 'callback': 'SomeFunction',
+                \ 'parent': submenu })
+<
+This will create the following menu: >
+  --------------------
+  a (t)op level menu item
+  a (s)ub menu
+<
+Where selecting "a (s)ub menu" will lead to a second menu: >
+  (n)ested item 1
+  (n)ested item 2
+<
+When any of the 3 concrete menu items are selected the function "SomeFunction"
+will be called.
+
+------------------------------------------------------------------------------
+NERDTreeRender()                                            *NERDTreeRender()*
+    Re-renders the NERD tree buffer. Useful if you change the state of the
+    tree and you want to it to be reflected in the UI.
+
+==============================================================================
+5. About                                                       *NERDTreeAbout*
+
+The author of the NERD tree is a terrible terrible monster called Martyzilla
+who gobbles up small children with milk and sugar for breakfast.
+
+He can be reached at martin.grenfell at gmail dot com. He would love to hear
+from you, so feel free to send him suggestions and/or comments about this
+plugin.  Don't be shy --- the worst he can do is slaughter you and stuff you in
+the fridge for later ;)
+
+The latest stable versions can be found at
+    http://www.vim.org/scripts/script.php?script_id=1658
+
+The latest dev versions are on github
+    http://github.com/scrooloose/nerdtree
+
+
+==============================================================================
+6. Changelog                                               *NERDTreeChangelog*
+
+4.x.x
+    - Fix a bug with :NERDTreeFind and symlinks. Thanks to Vitaly Bogdanov.
+
+4.1.0
+    features:
+    - NERDTreeFind to reveal the node for the current buffer in the tree,
+      see |NERDTreeFind|. This effectively merges the FindInNERDTree plugin (by
+      Doug McInnes) into the script.
+    - make NERDTreeQuitOnOpen apply to the t/T keymaps too. Thanks to Stefan
+      Ritter and Rémi Prévost.
+    - truncate the root node if wider than the tree window. Thanks to Victor
+      Gonzalez.
+
+    bugfixes:
+    - really fix window state restoring
+    - fix some win32 path escaping issues. Thanks to Stephan Baumeister, Ricky,
+      jfilip1024, and Chris Chambers
+
+4.0.0
+    - add a new programmable menu system (see :help NERDTreeMenu).
+    - add new APIs to add menus/menu-items to the menu system as well as
+      custom key mappings to the NERD tree buffer (see :help NERDTreeAPI).
+    - removed the old API functions
+    - added a mapping to maximize/restore the size of nerd tree window, thanks
+      to Guillaume Duranceau for the patch. See :help NERDTree-A for details.
+
+    - fix a bug where secondary nerd trees (netrw hijacked trees) and
+      NERDTreeQuitOnOpen didnt play nicely, thanks to Curtis Harvey.
+    - fix a bug where the script ignored directories whose name ended in a dot,
+      thanks to Aggelos Orfanakos for the patch.
+    - fix a bug when using the x mapping on the tree root, thanks to Bryan
+      Venteicher for the patch.
+    - fix a bug where the cursor position/window size of the nerd tree buffer
+      wasnt being stored on closing the window, thanks to Richard Hart.
+    - fix a bug where NERDTreeMirror would mirror the wrong tree
+
+3.1.1
+    - fix a bug where a non-listed no-name buffer was getting created every
+      time the tree windows was created, thanks to Derek Wyatt and owen1
+    - make <CR> behave the same as the 'o' mapping
+    - some helptag fixes in the doc, thanks strull
+    - fix a bug when using :set nohidden and opening a file where the previous
+      buf was modified. Thanks iElectric
+    - other minor fixes
+
+3.1.0
+    New features:
+    - add mappings to open files in a vsplit, see :help NERDTree-s and :help
+      NERDTree-gs
+    - make the statusline for the nerd tree window default to something
+      hopefully more useful. See :help 'NERDTreeStatusline'
+    Bugfixes:
+    - make the hijack netrw functionality work when vim is started with "vim
+      <some dir>" (thanks to Alf Mikula for the patch).
+    - fix a bug where the CWD wasnt being changed for some operations even when
+      NERDTreeChDirMode==2 (thanks to Lucas S. Buchala)
+    - add -bar to all the nerd tree :commands so they can chain with other
+      :commands (thanks to tpope)
+    - fix bugs when ignorecase was set (thanks to nach)
+    - fix a bug with the relative path code (thanks to nach)
+    - fix a bug where doing a :cd would cause :NERDTreeToggle to fail (thanks nach)
+
+
+3.0.1
+    Bugfixes:
+    - fix bugs with :NERDTreeToggle and :NERDTreeMirror when 'hidden
+      was not set
+    - fix a bug where :NERDTree <path> would fail if <path> was relative and
+      didnt start with a ./ or ../  Thanks to James Kanze.
+    - make the q mapping work with secondary (:e <dir>  style) trees,
+      thanks to jamessan
+    - fix a bunch of small bugs with secondary trees
+
+    More insane refactoring.
+
+3.0.0
+    - hijack netrw so that doing an :edit <directory>  will put a NERD tree in
+      the window rather than a netrw browser. See :help 'NERDTreeHijackNetrw'
+    - allow sharing of trees across tabs, see :help :NERDTreeMirror
+    - remove "top" and "bottom" as valid settings for NERDTreeWinPos
+    - change the '<tab>' mapping to 'i'
+    - change the 'H' mapping to 'I'
+    - lots of refactoring
+
+==============================================================================
+7. Credits                                                   *NERDTreeCredits*
+
+Thanks to the following people for testing, bug reports, ideas etc. Without
+you I probably would have got bored of the hacking the NERD tree and
+just downloaded pr0n instead.
+
+    Tim Carey-Smith (halorgium)
+    Vigil
+    Nick Brettell
+    Thomas Scott Urban
+    Terrance Cohen
+    Yegappan Lakshmanan
+    Jason Mills
+    Michael Geddes (frogonwheels)
+    Yu Jun
+    Michael Madsen
+    AOYAMA Shotaro
+    Zhang Weiwu
+    Niels Aan de Brugh
+    Olivier Yiptong
+    Zhang Shuhan
+    Cory Echols
+    Piotr Czachur
+    Yuan Jiang
+    Matan Nassau
+    Maxim Kim
+    Charlton Wang
+    Matt Wozniski (godlygeek)
+    knekk
+    Sean Chou
+    Ryan Penn
+    Simon Peter Nicholls
+    Michael Foobar
+    Tomasz Chomiuk
+    Denis Pokataev
+    Tim Pope (tpope)
+    James Kanze
+    James Vega (jamessan)
+    Frederic Chanal (nach)
+    Alf Mikula
+    Lucas S. Buchala
+    Curtis Harvey
+    Guillaume Duranceau
+    Richard Hart (hates)
+    Doug McInnes
+    Stefan Ritter
+    Rémi Prévost
+    Victor Gonzalez
+    Stephan Baumeister
+    Ricky
+    jfilip1024
+    Chris Chambers
+    Vitaly Bogdanov
+
+==============================================================================
+8. License                                                   *NERDTreeLicense*
+
+The NERD tree is released under the wtfpl.
+See http://sam.zoy.org/wtfpl/COPYING.
diff --git a/.vim/bundle/nerdtree/nerdtree_plugin/exec_menuitem.vim b/.vim/bundle/nerdtree/nerdtree_plugin/exec_menuitem.vim
new file mode 100644
index 0000000..e7a7c53
--- /dev/null
+++ b/.vim/bundle/nerdtree/nerdtree_plugin/exec_menuitem.vim
@@ -0,0 +1,41 @@
+" ============================================================================
+" File:        exec_menuitem.vim
+" Description: plugin for NERD Tree that provides an execute file menu item
+" Maintainer:  Martin Grenfell <martin.grenfell at gmail dot com>
+" Last Change: 22 July, 2009
+" 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.
+"
+" ============================================================================
+if exists("g:loaded_nerdtree_exec_menuitem")
+    finish
+endif
+let g:loaded_nerdtree_exec_menuitem = 1
+
+call NERDTreeAddMenuItem({
+            \ 'text': '(!)Execute file',
+            \ 'shortcut': '!',
+            \ 'callback': 'NERDTreeExecFile',
+            \ 'isActiveCallback': 'NERDTreeExecFileActive' })
+
+function! NERDTreeExecFileActive()
+    let node = g:NERDTreeFileNode.GetSelected()
+    return !node.path.isDirectory && node.path.isExecutable
+endfunction
+
+function! NERDTreeExecFile()
+    let treenode = g:NERDTreeFileNode.GetSelected()
+    echo "==========================================================\n"
+    echo "Complete the command to execute (add arguments etc):\n"
+    let cmd = treenode.path.str({'escape': 1})
+    let cmd = input(':!', cmd . ' ')
+
+    if cmd != ''
+        exec ':!' . cmd
+    else
+        echo "Aborted"
+    endif
+endfunction
diff --git a/.vim/bundle/nerdtree/nerdtree_plugin/fs_menu.vim b/.vim/bundle/nerdtree/nerdtree_plugin/fs_menu.vim
new file mode 100644
index 0000000..e25b38c
--- /dev/null
+++ b/.vim/bundle/nerdtree/nerdtree_plugin/fs_menu.vim
@@ -0,0 +1,194 @@
+" ============================================================================
+" File:        fs_menu.vim
+" Description: plugin for the NERD Tree that provides a file system menu
+" Maintainer:  Martin Grenfell <martin.grenfell at gmail dot com>
+" Last Change: 17 July, 2009
+" 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.
+"
+" ============================================================================
+if exists("g:loaded_nerdtree_fs_menu")
+    finish
+endif
+let g:loaded_nerdtree_fs_menu = 1
+
+call NERDTreeAddMenuItem({'text': '(a)dd a childnode', 'shortcut': 'a', 'callback': 'NERDTreeAddNode'})
+call NERDTreeAddMenuItem({'text': '(m)ove the curent node', 'shortcut': 'm', 'callback': 'NERDTreeMoveNode'})
+call NERDTreeAddMenuItem({'text': '(d)elete the curent node', 'shortcut': 'd', 'callback': 'NERDTreeDeleteNode'})
+if g:NERDTreePath.CopyingSupported()
+    call NERDTreeAddMenuItem({'text': '(c)copy the current node', 'shortcut': 'c', 'callback': 'NERDTreeCopyNode'})
+endif
+
+"FUNCTION: s:echo(msg){{{1
+function! s:echo(msg)
+    redraw
+    echomsg "NERDTree: " . a:msg
+endfunction
+
+"FUNCTION: s:echoWarning(msg){{{1
+function! s:echoWarning(msg)
+    echohl warningmsg
+    call s:echo(a:msg)
+    echohl normal
+endfunction
+
+"FUNCTION: s:promptToDelBuffer(bufnum, msg){{{1
+"prints out the given msg and, if the user responds by pushing 'y' then the
+"buffer with the given bufnum is deleted
+"
+"Args:
+"bufnum: the buffer that may be deleted
+"msg: a message that will be echoed to the user asking them if they wish to
+"     del the buffer
+function! s:promptToDelBuffer(bufnum, msg)
+    echo a:msg
+    if nr2char(getchar()) ==# 'y'
+        exec "silent bdelete! " . a:bufnum
+    endif
+endfunction
+
+"FUNCTION: NERDTreeAddNode(){{{1
+function! NERDTreeAddNode()
+    let curDirNode = g:NERDTreeDirNode.GetSelected()
+
+    let newNodeName = input("Add a childnode\n".
+                          \ "==========================================================\n".
+                          \ "Enter the dir/file name to be created. Dirs end with a '/'\n" .
+                          \ "", curDirNode.path.str({'format': 'Glob'}) . g:NERDTreePath.Slash())
+
+    if newNodeName ==# ''
+        call s:echo("Node Creation Aborted.")
+        return
+    endif
+
+    try
+        let newPath = g:NERDTreePath.Create(newNodeName)
+        let parentNode = b:NERDTreeRoot.findNode(newPath.getParent())
+
+        let newTreeNode = g:NERDTreeFileNode.New(newPath)
+        if parentNode.isOpen || !empty(parentNode.children)
+            call parentNode.addChild(newTreeNode, 1)
+            call NERDTreeRender()
+            call newTreeNode.putCursorHere(1, 0)
+        endif
+    catch /^NERDTree/
+        call s:echoWarning("Node Not Created.")
+    endtry
+endfunction
+
+"FUNCTION: NERDTreeMoveNode(){{{1
+function! NERDTreeMoveNode()
+    let curNode = g:NERDTreeFileNode.GetSelected()
+    let newNodePath = input("Rename the current node\n" .
+                          \ "==========================================================\n" .
+                          \ "Enter the new path for the node:                          \n" .
+                          \ "", curNode.path.str())
+
+    if newNodePath ==# ''
+        call s:echo("Node Renaming Aborted.")
+        return
+    endif
+
+    try
+        let bufnum = bufnr(curNode.path.str())
+
+        call curNode.rename(newNodePath)
+        call NERDTreeRender()
+
+        "if the node is open in a buffer, ask the user if they want to
+        "close that buffer
+        if bufnum != -1
+            let prompt = "\nNode renamed.\n\nThe old file is open in buffer ". bufnum . (bufwinnr(bufnum) ==# -1 ? " (hidden)" : "") .". Delete this buffer? (yN)"
+            call s:promptToDelBuffer(bufnum, prompt)
+        endif
+
+        call curNode.putCursorHere(1, 0)
+
+        redraw
+    catch /^NERDTree/
+        call s:echoWarning("Node Not Renamed.")
+    endtry
+endfunction
+
+" FUNCTION: NERDTreeDeleteNode() {{{1
+function! NERDTreeDeleteNode()
+    let currentNode = g:NERDTreeFileNode.GetSelected()
+    let confirmed = 0
+
+    if currentNode.path.isDirectory
+        let choice =input("Delete the current node\n" .
+                         \ "==========================================================\n" .
+                         \ "STOP! To delete this entire directory, type 'yes'\n" .
+                         \ "" . currentNode.path.str() . ": ")
+        let confirmed = choice ==# 'yes'
+    else
+        echo "Delete the current node\n" .
+           \ "==========================================================\n".
+           \ "Are you sure you wish to delete the node:\n" .
+           \ "" . currentNode.path.str() . " (yN):"
+        let choice = nr2char(getchar())
+        let confirmed = choice ==# 'y'
+    endif
+
+
+    if confirmed
+        try
+            call currentNode.delete()
+            call NERDTreeRender()
+
+            "if the node is open in a buffer, ask the user if they want to
+            "close that buffer
+            let bufnum = bufnr(currentNode.path.str())
+            if buflisted(bufnum)
+                let prompt = "\nNode deleted.\n\nThe file is open in buffer ". bufnum . (bufwinnr(bufnum) ==# -1 ? " (hidden)" : "") .". Delete this buffer? (yN)"
+                call s:promptToDelBuffer(bufnum, prompt)
+            endif
+
+            redraw
+        catch /^NERDTree/
+            call s:echoWarning("Could not remove node")
+        endtry
+    else
+        call s:echo("delete aborted")
+    endif
+
+endfunction
+
+" FUNCTION: NERDTreeCopyNode() {{{1
+function! NERDTreeCopyNode()
+    let currentNode = g:NERDTreeFileNode.GetSelected()
+    let newNodePath = input("Copy the current node\n" .
+                          \ "==========================================================\n" .
+                          \ "Enter the new path to copy the node to:                   \n" .
+                          \ "", currentNode.path.str())
+
+    if newNodePath != ""
+        "strip trailing slash
+        let newNodePath = substitute(newNodePath, '\/$', '', '')
+
+        let confirmed = 1
+        if currentNode.path.copyingWillOverwrite(newNodePath)
+            call s:echo("Warning: copying may overwrite files! Continue? (yN)")
+            let choice = nr2char(getchar())
+            let confirmed = choice ==# 'y'
+        endif
+
+        if confirmed
+            try
+                let newNode = currentNode.copy(newNodePath)
+                call NERDTreeRender()
+                call newNode.putCursorHere(0, 0)
+            catch /^NERDTree/
+                call s:echoWarning("Could not copy node")
+            endtry
+        endif
+    else
+        call s:echo("Copy aborted.")
+    endif
+    redraw
+endfunction
+
+" vim: set sw=4 sts=4 et fdm=marker:
diff --git a/.vim/bundle/nerdtree/plugin/NERD_tree.vim b/.vim/bundle/nerdtree/plugin/NERD_tree.vim
new file mode 100644
index 0000000..bce9ca6
--- /dev/null
+++ b/.vim/bundle/nerdtree/plugin/NERD_tree.vim
@@ -0,0 +1,4076 @@
+" ============================================================================
+" File:        NERD_tree.vim
+" Description: vim global plugin that provides a nice tree explorer
+" Maintainer:  Martin Grenfell <martin.grenfell at gmail dot com>
+" Last Change: 1 December, 2009
+" 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 = '4.1.0'
+
+" 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 . ' = ' . "'" . substitute(a:value, "'", "''", "g") . "'"
+        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:NERDTreeBookmarksFile", expand('$HOME') . '/.NERDTreeBookmarks')
+call s:initVariable("g:NERDTreeHighlightCursorline", 1)
+call s:initVariable("g:NERDTreeHijackNetrw", 1)
+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, '*')
+
+if !exists('g:NERDTreeStatusline')
+
+    "the exists() crap here is a hack to stop vim spazzing out when
+    "loading a session that was created with an open nerd tree. It spazzes
+    "because it doesnt store b:NERDTreeRoot (its a b: var, and its a hash)
+    let g:NERDTreeStatusline = "%{exists('b:NERDTreeRoot')?b:NERDTreeRoot.path.str():''}"
+
+endif
+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:NERDTreeMapMenu", "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", "i")
+call s:initVariable("g:NERDTreeMapOpenVSplit", "s")
+call s:initVariable("g:NERDTreeMapPreview", "g" . NERDTreeMapActivateNode)
+call s:initVariable("g:NERDTreeMapPreviewSplit", "g" . NERDTreeMapOpenSplit)
+call s:initVariable("g:NERDTreeMapPreviewVSplit", "g" . NERDTreeMapOpenVSplit)
+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", "I")
+call s:initVariable("g:NERDTreeMapToggleZoom", "A")
+call s:initVariable("g:NERDTreeMapUpdir", "u")
+call s:initVariable("g:NERDTreeMapUpdirKeepOpen", "U")
+
+"SECTION: Script level variable declaration{{{2
+if s:running_windows
+    let s:escape_chars =  " `\|\"#%&,?()\*^<>"
+else
+    let s:escape_chars =  " \\`\|\"#%&,?()\*^<>"
+endif
+let s:NERDTreeBufName = 'NERD_tree_'
+
+let s:tree_wid = 2
+let s:tree_markup_reg = '^[ `|]*[\-+~]'
+let s:tree_up_dir_line = '.. (up a dir)'
+
+"the number to add to the nerd tree buffer name to make the buf name unique
+let s:next_buffer_number = 1
+
+" SECTION: Commands {{{1
+"============================================================
+"init the command that users start the nerd tree with
+command! -n=? -complete=dir -bar NERDTree :call s:initNerdTree('<args>')
+command! -n=? -complete=dir -bar NERDTreeToggle :call s:toggle('<args>')
+command! -n=0 -bar NERDTreeClose :call s:closeTreeIfOpen()
+command! -n=1 -complete=customlist,s:completeBookmarks -bar NERDTreeFromBookmark call s:initNerdTree('<args>')
+command! -n=0 -bar NERDTreeMirror call s:initNerdTreeMirror()
+command! -n=0 -bar NERDTreeFind call s:findAndRevealPath()
+" SECTION: Auto commands {{{1
+"============================================================
+augroup NERDTree
+    "Save the cursor position whenever we close the nerd tree
+    exec "autocmd BufWinLeave ". s:NERDTreeBufName ."* call <SID>saveScreenState()"
+    "cache bookmarks when vim loads
+    autocmd VimEnter * call s:Bookmark.CacheBookmarks(0)
+
+    "load all nerdtree plugins after vim starts
+    autocmd VimEnter * runtime! nerdtree_plugin/**/*.vim
+augroup END
+
+if g:NERDTreeHijackNetrw
+    augroup NERDTreeHijackNetrw
+        autocmd VimEnter * silent! autocmd! FileExplorer
+        au BufEnter,VimEnter * call s:checkForBrowse(expand("<amatch>"))
+    augroup END
+endif
+
+"SECTION: Classes {{{1
+"============================================================
+"CLASS: Bookmark {{{2
+"============================================================
+let s:Bookmark = {}
+" FUNCTION: Bookmark.activate() {{{3
+function! s:Bookmark.activate()
+    if self.path.isDirectory
+        call self.toRoot()
+    else
+        if self.validate()
+            let n = s:TreeFileNode.New(self.path)
+            call n.open()
+            call s:closeTreeIfQuitOnOpen()
+        endif
+    endif
+endfunction
+" 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.BookmarkNotFoundError/
+        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.BookmarkNotFoundError: 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.InvalidArgumentsError/
+                    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.BookmarkedNodeNotFoundError/
+    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() : b:NERDTreeRoot
+    let targetNode = searchRoot.findNode(self.path)
+    if empty(targetNode)
+        throw "NERDTree.BookmarkedNodeNotFoundError: 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.GetSelected() {{{3
+" returns the Bookmark the cursor is over, or {}
+function! s:Bookmark.GetSelected()
+    let line = getline(".")
+    let name = substitute(line, '^>\(.\{-}\) .\+$', '\1', '')
+    if name != line
+        try
+            return s:Bookmark.BookmarkFor(name)
+        catch /^NERDTree.BookmarkNotFoundError/
+            return {}
+        endtry
+    endif
+    return {}
+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.BookmarkPointsToInvalidLocationError: the bookmark \"".
+            \ self.name ."\" points to a non existing location: \"". self.path.str()
+    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.IllegalBookmarkNameError: illegal name:" . a:name
+    endif
+
+    let newBookmark = copy(self)
+    let newBookmark.name = a:name
+    let newBookmark.path = a:path
+    return newBookmark
+endfunction
+" FUNCTION: Bookmark.openInNewTab(options) {{{3
+" Create a new bookmark object with the given name and path object
+function! s:Bookmark.openInNewTab(options)
+    let currentTab = tabpagenr()
+    if self.path.isDirectory
+        tabnew
+        call s:initNerdTree(self.name)
+    else
+        exec "tabedit " . bookmark.path.str({'format': 'Edit'})
+    endif
+
+    if has_key(a:options, 'stayInCurrentTab')
+        exec "tabnext " . currentTab
+    endif
+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.str({'format': 'UI'})
+    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.BookmarkedNodeNotFoundError/
+            let targetNode = s:TreeFileNode.New(s:Bookmark.BookmarkFor(self.name).path)
+        endtry
+        call targetNode.makeRoot()
+        call s:renderView()
+        call targetNode.putCursorHere(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.str())
+    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: KeyMap {{{2
+"============================================================
+let s:KeyMap = {}
+"FUNCTION: KeyMap.All() {{{3
+function! s:KeyMap.All()
+    if !exists("s:keyMaps")
+        let s:keyMaps = []
+    endif
+    return s:keyMaps
+endfunction
+
+"FUNCTION: KeyMap.BindAll() {{{3
+function! s:KeyMap.BindAll()
+    for i in s:KeyMap.All()
+        call i.bind()
+    endfor
+endfunction
+
+"FUNCTION: KeyMap.bind() {{{3
+function! s:KeyMap.bind()
+    exec "nnoremap <silent> <buffer> ". self.key ." :call ". self.callback ."()<cr>"
+endfunction
+
+"FUNCTION: KeyMap.Create(options) {{{3
+function! s:KeyMap.Create(options)
+    let newKeyMap = copy(self)
+    let newKeyMap.key = a:options['key']
+    let newKeyMap.quickhelpText = a:options['quickhelpText']
+    let newKeyMap.callback = a:options['callback']
+    call add(s:KeyMap.All(), newKeyMap)
+endfunction
+"CLASS: MenuController {{{2
+"============================================================
+let s:MenuController = {}
+"FUNCTION: MenuController.New(menuItems) {{{3
+"create a new menu controller that operates on the given menu items
+function! s:MenuController.New(menuItems)
+    let newMenuController =  copy(self)
+    if a:menuItems[0].isSeparator()
+        let newMenuController.menuItems = a:menuItems[1:-1]
+    else
+        let newMenuController.menuItems = a:menuItems
+    endif
+    return newMenuController
+endfunction
+
+"FUNCTION: MenuController.showMenu() {{{3
+"start the main loop of the menu and get the user to choose/execute a menu
+"item
+function! s:MenuController.showMenu()
+    call self._saveOptions()
+
+    try
+        let self.selection = 0
+
+        let done = 0
+        while !done
+            redraw!
+            call self._echoPrompt()
+            let key = nr2char(getchar())
+            let done = self._handleKeypress(key)
+        endwhile
+    finally
+        call self._restoreOptions()
+    endtry
+
+    if self.selection != -1
+        let m = self._current()
+        call m.execute()
+    endif
+endfunction
+
+"FUNCTION: MenuController._echoPrompt() {{{3
+function! s:MenuController._echoPrompt()
+    echo "NERDTree Menu. Use j/k/enter and the shortcuts indicated"
+    echo "=========================================================="
+
+    for i in range(0, len(self.menuItems)-1)
+        if self.selection == i
+            echo "> " . self.menuItems[i].text
+        else
+            echo "  " . self.menuItems[i].text
+        endif
+    endfor
+endfunction
+
+"FUNCTION: MenuController._current(key) {{{3
+"get the MenuItem that is curently selected
+function! s:MenuController._current()
+    return self.menuItems[self.selection]
+endfunction
+
+"FUNCTION: MenuController._handleKeypress(key) {{{3
+"change the selection (if appropriate) and return 1 if the user has made
+"their choice, 0 otherwise
+function! s:MenuController._handleKeypress(key)
+    if a:key == 'j'
+        call self._cursorDown()
+    elseif a:key == 'k'
+        call self._cursorUp()
+    elseif a:key == nr2char(27) "escape
+        let self.selection = -1
+        return 1
+    elseif a:key == "\r" || a:key == "\n" "enter and ctrl-j
+        return 1
+    else
+        let index = self._nextIndexFor(a:key)
+        if index != -1
+            let self.selection = index
+            if len(self._allIndexesFor(a:key)) == 1
+                return 1
+            endif
+        endif
+    endif
+
+    return 0
+endfunction
+
+"FUNCTION: MenuController._allIndexesFor(shortcut) {{{3
+"get indexes to all menu items with the given shortcut
+function! s:MenuController._allIndexesFor(shortcut)
+    let toReturn = []
+
+    for i in range(0, len(self.menuItems)-1)
+        if self.menuItems[i].shortcut == a:shortcut
+            call add(toReturn, i)
+        endif
+    endfor
+
+    return toReturn
+endfunction
+
+"FUNCTION: MenuController._nextIndexFor(shortcut) {{{3
+"get the index to the next menu item with the given shortcut, starts from the
+"current cursor location and wraps around to the top again if need be
+function! s:MenuController._nextIndexFor(shortcut)
+    for i in range(self.selection+1, len(self.menuItems)-1)
+        if self.menuItems[i].shortcut == a:shortcut
+            return i
+        endif
+    endfor
+
+    for i in range(0, self.selection)
+        if self.menuItems[i].shortcut == a:shortcut
+            return i
+        endif
+    endfor
+
+    return -1
+endfunction
+
+"FUNCTION: MenuController._setCmdheight() {{{3
+"sets &cmdheight to whatever is needed to display the menu
+function! s:MenuController._setCmdheight()
+    let &cmdheight = len(self.menuItems) + 3
+endfunction
+
+"FUNCTION: MenuController._saveOptions() {{{3
+"set any vim options that are required to make the menu work (saving their old
+"values)
+function! s:MenuController._saveOptions()
+    let self._oldLazyredraw = &lazyredraw
+    let self._oldCmdheight = &cmdheight
+    set nolazyredraw
+    call self._setCmdheight()
+endfunction
+
+"FUNCTION: MenuController._restoreOptions() {{{3
+"restore the options we saved in _saveOptions()
+function! s:MenuController._restoreOptions()
+    let &cmdheight = self._oldCmdheight
+    let &lazyredraw = self._oldLazyredraw
+endfunction
+
+"FUNCTION: MenuController._cursorDown() {{{3
+"move the cursor to the next menu item, skipping separators
+function! s:MenuController._cursorDown()
+    let done = 0
+    while !done
+        if self.selection < len(self.menuItems)-1
+            let self.selection += 1
+        else
+            let self.selection = 0
+        endif
+
+        if !self._current().isSeparator()
+            let done = 1
+        endif
+    endwhile
+endfunction
+
+"FUNCTION: MenuController._cursorUp() {{{3
+"move the cursor to the previous menu item, skipping separators
+function! s:MenuController._cursorUp()
+    let done = 0
+    while !done
+        if self.selection > 0
+            let self.selection -= 1
+        else
+            let self.selection = len(self.menuItems)-1
+        endif
+
+        if !self._current().isSeparator()
+            let done = 1
+        endif
+    endwhile
+endfunction
+
+"CLASS: MenuItem {{{2
+"============================================================
+let s:MenuItem = {}
+"FUNCTION: MenuItem.All() {{{3
+"get all top level menu items
+function! s:MenuItem.All()
+    if !exists("s:menuItems")
+        let s:menuItems = []
+    endif
+    return s:menuItems
+endfunction
+
+"FUNCTION: MenuItem.AllEnabled() {{{3
+"get all top level menu items that are currently enabled
+function! s:MenuItem.AllEnabled()
+    let toReturn = []
+    for i in s:MenuItem.All()
+        if i.enabled()
+            call add(toReturn, i)
+        endif
+    endfor
+    return toReturn
+endfunction
+
+"FUNCTION: MenuItem.Create(options) {{{3
+"make a new menu item and add it to the global list
+function! s:MenuItem.Create(options)
+    let newMenuItem = copy(self)
+
+    let newMenuItem.text = a:options['text']
+    let newMenuItem.shortcut = a:options['shortcut']
+    let newMenuItem.children = []
+
+    let newMenuItem.isActiveCallback = -1
+    if has_key(a:options, 'isActiveCallback')
+        let newMenuItem.isActiveCallback = a:options['isActiveCallback']
+    endif
+
+    let newMenuItem.callback = -1
+    if has_key(a:options, 'callback')
+        let newMenuItem.callback = a:options['callback']
+    endif
+
+    if has_key(a:options, 'parent')
+        call add(a:options['parent'].children, newMenuItem)
+    else
+        call add(s:MenuItem.All(), newMenuItem)
+    endif
+
+    return newMenuItem
+endfunction
+
+"FUNCTION: MenuItem.CreateSeparator(options) {{{3
+"make a new separator menu item and add it to the global list
+function! s:MenuItem.CreateSeparator(options)
+    let standard_options = { 'text': '--------------------',
+                \ 'shortcut': -1,
+                \ 'callback': -1 }
+    let options = extend(a:options, standard_options, "force")
+
+    return s:MenuItem.Create(options)
+endfunction
+
+"FUNCTION: MenuItem.CreateSubmenu(options) {{{3
+"make a new submenu and add it to global list
+function! s:MenuItem.CreateSubmenu(options)
+    let standard_options = { 'callback': -1 }
+    let options = extend(a:options, standard_options, "force")
+
+    return s:MenuItem.Create(options)
+endfunction
+
+"FUNCTION: MenuItem.enabled() {{{3
+"return 1 if this menu item should be displayed
+"
+"delegates off to the isActiveCallback, and defaults to 1 if no callback was
+"specified
+function! s:MenuItem.enabled()
+    if self.isActiveCallback != -1
+        return {self.isActiveCallback}()
+    endif
+    return 1
+endfunction
+
+"FUNCTION: MenuItem.execute() {{{3
+"perform the action behind this menu item, if this menuitem has children then
+"display a new menu for them, otherwise deletegate off to the menuitem's
+"callback
+function! s:MenuItem.execute()
+    if len(self.children)
+        let mc = s:MenuController.New(self.children)
+        call mc.showMenu()
+    else
+        if self.callback != -1
+            call {self.callback}()
+        endif
+    endif
+endfunction
+
+"FUNCTION: MenuItem.isSeparator() {{{3
+"return 1 if this menuitem is a separator
+function! s:MenuItem.isSeparator()
+    return self.callback == -1 && self.children == []
+endfunction
+
+"FUNCTION: MenuItem.isSubmenu() {{{3
+"return 1 if this menuitem is a submenu
+function! s:MenuItem.isSubmenu()
+    return self.callback == -1 && !empty(self.children)
+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.activate(forceKeepWinOpen) {{{3
+function! s:TreeFileNode.activate(forceKeepWinOpen)
+    call self.open()
+    if !a:forceKeepWinOpen
+        call s:closeTreeIfQuitOnOpen()
+    end
+endfunction
+"FUNCTION: TreeFileNode.bookmark(name) {{{3
+"bookmark this node with a:name
+function! s:TreeFileNode.bookmark(name)
+
+    "if a bookmark exists with the same name and the node is cached then save
+    "it so we can update its display string
+    let oldMarkedNode = {}
+    try
+        let oldMarkedNode = s:Bookmark.GetNodeForName(a:name, 1)
+    catch /^NERDTree.BookmarkNotFoundError/
+    catch /^NERDTree.BookmarkedNodeNotFoundError/
+    endtry
+
+    call s:Bookmark.AddBookmark(a:name, self.path)
+    call self.path.cacheDisplayString()
+    call s:Bookmark.Write()
+
+    if !empty(oldMarkedNode)
+        call oldMarkedNode.path.cacheDisplayString()
+    endif
+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.CannotCacheParentError: 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 = b: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.displayString() {{{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.displayString()
+    return self.path.displayString()
+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() ==# a:treenode.path.str()
+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.getLineNum(){{{3
+"returns the line number this node is rendered on, or -1 if it isnt rendered
+function! s:TreeFileNode.getLineNum()
+    "if the node is the root then return the root line no.
+    if self.isRoot()
+        return s:TreeFileNode.GetRootLineNum()
+    endif
+
+    let totalLines = line("$")
+
+    "the path components we have matched so far
+    let pathcomponents = [substitute(b:NERDTreeRoot.path.str({'format': 'UI'}), '/ *$', '', '')]
+    "the index of the component we are searching for
+    let curPathComponent = 1
+
+    let fullpath = self.path.str({'format': 'UI'})
+
+
+    let lnum = s:TreeFileNode.GetRootLineNum()
+    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)
+
+        let indent = s:indentLevelFor(curLine)
+        if indent ==# curPathComponent
+            let curLine = s:stripMarkupFromLine(curLine, 1)
+
+            let curPath =  join(pathcomponents, '/') . '/' . curLine
+            if stridx(fullpath, curPath, 0) ==# 0
+                if fullpath ==# curPath || strpart(fullpath, len(curPath)-1,1) ==# '/'
+                    let curLine = substitute(curLine, '/ *$', '', '')
+                    call add(pathcomponents, curLine)
+                    let curPathComponent = curPathComponent + 1
+
+                    if fullpath ==# curPath
+                        return lnum
+                    endif
+                endif
+            endif
+        endif
+    endwhile
+    return -1
+endfunction
+
+"FUNCTION: TreeFileNode.GetRootForTab(){{{3
+"get the root node for this tab
+function! s:TreeFileNode.GetRootForTab()
+    if s:treeExistsForTab()
+        return getbufvar(t:NERDTreeBufName, 'NERDTreeRoot')
+    end
+    return {}
+endfunction
+"FUNCTION: TreeFileNode.GetRootLineNum(){{{3
+"gets the line number of the root node
+function! s:TreeFileNode.GetRootLineNum()
+    let rootLine = 1
+    while getline(rootLine) !~ '^\(/\|<\)'
+        let rootLine = rootLine + 1
+    endwhile
+    return rootLine
+endfunction
+
+"FUNCTION: TreeFileNode.GetSelected() {{{3
+"gets the treenode that the cursor is currently over
+function! s:TreeFileNode.GetSelected()
+    try
+        let path = s:getPath(line("."))
+        if path ==# {}
+            return {}
+        endif
+        return b:NERDTreeRoot.findNode(path)
+    catch /NERDTree/
+        return {}
+    endtry
+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 b:NERDTreeRoot
+function! s:TreeFileNode.isRoot()
+    if !s:treeExistsForBuf()
+        throw "NERDTree.NoTreeError: No tree exists for the current buffer"
+    endif
+
+    return self.equals(b:NERDTreeRoot)
+endfunction
+
+"FUNCTION: TreeFileNode.makeRoot() {{{3
+"Make this node the root of the tree
+function! s:TreeFileNode.makeRoot()
+    if self.path.isDirectory
+        let b:NERDTreeRoot = self
+    else
+        call self.cacheParent()
+        let b:NERDTreeRoot = self.parent
+    endif
+
+    call b:NERDTreeRoot.open()
+
+    "change dir to the dir of the new root if instructed to
+    if g:NERDTreeChDirMode ==# 2
+        exec "cd " . b:NERDTreeRoot.path.str({'format': 'Edit'})
+    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 = copy(self)
+        let newTreeNode.path = a:path
+        let newTreeNode.parent = {}
+        return newTreeNode
+    endif
+endfunction
+
+"FUNCTION: TreeFileNode.open() {{{3
+"Open the file represented by the given node in the current window, splitting
+"the window if needed
+"
+"ARGS:
+"treenode: file node to open
+function! s:TreeFileNode.open()
+    if b:NERDTreeType ==# "secondary"
+        exec 'edit ' . self.path.str({'format': 'Edit'})
+        return
+    endif
+
+    "if the file is already open in this tab then just stick the cursor in it
+    let winnr = bufwinnr('^' . self.path.str() . '$')
+    if winnr != -1
+        call s:exec(winnr . "wincmd w")
+
+    else
+        if !s:isWindowUsable(winnr("#")) && s:firstUsableWindow() ==# -1
+            call self.openSplit()
+        else
+            try
+                if !s:isWindowUsable(winnr("#"))
+                    call s:exec(s:firstUsableWindow() . "wincmd w")
+                else
+                    call s:exec('wincmd p')
+                endif
+                exec ("edit " . self.path.str({'format': 'Edit'}))
+            catch /^Vim\%((\a\+)\)\=:E37/
+                call s:putCursorInTreeWin()
+                throw "NERDTree.FileAlreadyOpenAndModifiedError: ". self.path.str() ." is already open and modified."
+            catch /^Vim\%((\a\+)\)\=:/
+                echo v:exception
+            endtry
+        endif
+    endif
+endfunction
+"FUNCTION: TreeFileNode.openSplit() {{{3
+"Open this node in a new window
+function! s:TreeFileNode.openSplit()
+
+    if b:NERDTreeType ==# "secondary"
+        exec "split " . self.path.str({'format': 'Edit'})
+        return
+    endif
+
+    " Save the user's settings for splitbelow and splitright
+    let savesplitbelow=&splitbelow
+    let savesplitright=&splitright
+
+    " 'there' will be set to a command to move from the split window
+    " back to the explorer window
+    "
+    " 'back' will be set to a command to move from the explorer window
+    " back to the newly split window
+    "
+    " 'right' and 'below' will be set to the settings needed for
+    " splitbelow and splitright IF the explorer is the only window.
+    "
+    let there= g:NERDTreeWinPos ==# "left" ? "wincmd h" : "wincmd l"
+    let back = g:NERDTreeWinPos ==# "left" ? "wincmd l" : "wincmd h"
+    let right= g:NERDTreeWinPos ==# "left"
+    let below=0
+
+    " Attempt to go to adjacent window
+    call s:exec(back)
+
+    let onlyOneWin = (winnr("$") ==# 1)
+
+    " If no adjacent window, set splitright and splitbelow appropriately
+    if onlyOneWin
+        let &splitright=right
+        let &splitbelow=below
+    else
+        " found adjacent window - invert split direction
+        let &splitright=!right
+        let &splitbelow=!below
+    endif
+
+    let splitMode = onlyOneWin ? "vertical" : ""
+
+    " Open the new window
+    try
+        exec(splitMode." sp " . self.path.str({'format': 'Edit'}))
+    catch /^Vim\%((\a\+)\)\=:E37/
+        call s:putCursorInTreeWin()
+        throw "NERDTree.FileAlreadyOpenAndModifiedError: ". self.path.str() ." is already open and modified."
+    catch /^Vim\%((\a\+)\)\=:/
+        "do nothing
+    endtry
+
+    "resize the tree window if no other window was open before
+    if onlyOneWin
+        let size = exists("b:NERDTreeOldWindowSize") ? b:NERDTreeOldWindowSize : g:NERDTreeWinSize
+        call s:exec(there)
+        exec("silent ". splitMode ." resize ". size)
+        call s:exec('wincmd p')
+    endif
+
+    " Restore splitmode settings
+    let &splitbelow=savesplitbelow
+    let &splitright=savesplitright
+endfunction
+"FUNCTION: TreeFileNode.openVSplit() {{{3
+"Open this node in a new vertical window
+function! s:TreeFileNode.openVSplit()
+    if b:NERDTreeType ==# "secondary"
+        exec "vnew " . self.path.str({'format': 'Edit'})
+        return
+    endif
+
+    let winwidth = winwidth(".")
+    if winnr("$")==#1
+        let winwidth = g:NERDTreeWinSize
+    endif
+
+    call s:exec("wincmd p")
+    exec "vnew " . self.path.str({'format': 'Edit'})
+
+    "resize the nerd tree back to the original size
+    call s:putCursorInTreeWin()
+    exec("silent vertical resize ". winwidth)
+    call s:exec('wincmd p')
+endfunction
+"FUNCTION: TreeFileNode.openInNewTab(options) {{{3
+function! s:TreeFileNode.openInNewTab(options)
+    let currentTab = tabpagenr()
+
+    if !has_key(a:options, 'keepTreeOpen')
+        call s:closeTreeIfQuitOnOpen()
+    endif
+
+    exec "tabedit " . self.path.str({'format': 'Edit'})
+
+    if has_key(a:options, 'stayInCurrentTab') && a:options['stayInCurrentTab']
+        exec "tabnext " . currentTab
+    endif
+
+endfunction
+"FUNCTION: TreeFileNode.putCursorHere(isJump, recurseUpward){{{3
+"Places the cursor on the line number this node is rendered on
+"
+"Args:
+"isJump: 1 if this cursor movement should be counted as a jump by vim
+"recurseUpward: try to put the cursor on the parent if the this node isnt
+"visible
+function! s:TreeFileNode.putCursorHere(isJump, recurseUpward)
+    let ln = self.getLineNum()
+    if ln != -1
+        if a:isJump
+            mark '
+        endif
+        call cursor(ln, col("."))
+    else
+        if a:recurseUpward
+            let node = self
+            while node != {} && node.getLineNum() ==# -1
+                let node = node.parent
+                call node.open()
+            endwhile
+            call s:renderView()
+            call node.putCursorHere(a:isJump, 0)
+        endif
+    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.getParent()
+    let newParent = b:NERDTreeRoot.findNode(parentPath)
+
+    if newParent != {}
+        call newParent.createChild(self.path, 1)
+        call newParent.refresh()
+    endif
+endfunction
+"FUNCTION: TreeFileNode.renderToString {{{3
+"returns a string representation for this tree to be rendered in the view
+function! s:TreeFileNode.renderToString()
+    return self._renderToString(0, 0, [], self.getChildCount() ==# 1)
+endfunction
+
+
+"Args:
+"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:TreeFileNode._renderToString(depth, drawText, vertMap, isLastChild)
+    let output = ""
+    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 self.path.isDirectory
+            if self.isOpen
+                let treeParts = treeParts . '~'
+            else
+                let treeParts = treeParts . '+'
+            endif
+        else
+            let treeParts = treeParts . '-'
+        endif
+        let line = treeParts . self.displayString()
+
+        let output = output . line . "\n"
+    endif
+
+    "if the node is an open dir, draw its children
+    if self.path.isDirectory ==# 1 && self.isOpen ==# 1
+
+        let childNodesToDraw = self.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]
+                    let output = output . i._renderToString(a:depth + 1, 1, add(copy(a:vertMap), 1), 0)
+                endfor
+            endif
+
+            "draw the last child, indicating that it IS the last
+            let output = output . childNodesToDraw[lastIndx]._renderToString(a:depth + 1, 1, add(copy(a:vertMap), 0), 1)
+        endif
+    endif
+
+    return output
+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 = b:NERDTreeRoot
+    while currentNode.parent != {}
+        let currentNode = currentNode.parent
+    endwhile
+    return currentNode
+endfunction
+"FUNCTION: TreeDirNode.activate(forceKeepWinOpen) {{{3
+unlet s:TreeDirNode.activate
+function! s:TreeDirNode.activate(forceKeepWinOpen)
+    call self.toggleOpen()
+    call s:renderView()
+    call self.putCursorHere(0, 0)
+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(), self.path.str(), 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(), self.path.str(), 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.InvalidArgumentsError: 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(), self.path.str(), 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.GetSelected() {{{3
+"Returns the current node if it is a dir node, or else returns the current
+"nodes parent
+unlet s:TreeDirNode.GetSelected
+function! s:TreeDirNode.GetSelected()
+    let currentDir = s:TreeFileNode.GetSelected()
+    if currentDir != {} && !currentDir.isRoot()
+        if currentDir.path.isDirectory ==# 0
+            let currentDir = currentDir.parent
+        endif
+    endif
+    return currentDir
+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 globDir = dir.str({'format': 'Glob'})
+    let filesStr = globpath(globDir, '*') . "\n" . globpath(globDir, '.*')
+    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.\(InvalidArguments\|InvalidFiletype\)Error/
+                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.InvalidArgumentsError: 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
+unlet s:TreeDirNode.open
+function! s:TreeDirNode.open()
+    let self.isOpen = 1
+    if self.children ==# []
+        return self._initChildren(0)
+    else
+        return 0
+    endif
+endfunction
+
+" FUNCTION: TreeDirNode.openExplorer() {{{3
+" opens an explorer window for this node in the previous window (could be a
+" nerd tree or a netrw)
+function! s:TreeDirNode.openExplorer()
+    let oldwin = winnr()
+    call s:exec('wincmd p')
+    if oldwin ==# winnr() || (&modified && s:bufInWindows(winbufnr(winnr())) < 2)
+        call s:exec('wincmd p')
+        call self.openSplit()
+    else
+        exec ("silent edit " . self.path.str({'format': 'Edit'}))
+    endif
+endfunction
+"FUNCTION: TreeDirNode.openInNewTab(options) {{{3
+unlet s:TreeDirNode.openInNewTab
+function! s:TreeDirNode.openInNewTab(options)
+    let currentTab = tabpagenr()
+
+    if !has_key(a:options, 'keepTreeOpen') || !a:options['keepTreeOpen']
+        call s:closeTreeIfQuitOnOpen()
+    endif
+
+    tabnew
+    call s:initNerdTree(self.path.str())
+
+    if has_key(a:options, 'stayInCurrentTab') && a:options['stayInCurrentTab']
+        exec "tabnext " . currentTab
+    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 globDir = dir.str({'format': 'Glob'})
+        let filesStr = globpath(globDir, '*') . "\n" . globpath(globDir, '.*')
+        let files = split(filesStr, "\n")
+        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 !~ '\/\.\/\?$'
+
+                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.InvalidArgumentsError/
+                    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.reveal(path) {{{3
+"reveal the given path, i.e. cache and open all treenodes needed to display it
+"in the UI
+function! s:TreeDirNode.reveal(path)
+    if !a:path.isUnder(self.path)
+        throw "NERDTree.InvalidArgumentsError: " . a:path.str() . " should be under " . self.path.str()
+    endif
+
+    call self.open()
+
+    if self.path.equals(a:path.getParent())
+        let n = self.findNode(a:path)
+        call s:renderView()
+        call n.putCursorHere(1,0)
+        return
+    endif
+
+    let p = a:path
+    while !p.getParent().equals(self.path)
+        let p = p.getParent()
+    endwhile
+
+    let n = self.findNode(p)
+    call n.reveal(a:path)
+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.ChildNotFoundError 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.ChildNotFoundError: 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.AbsolutePathFor(str) {{{3
+function! s:Path.AbsolutePathFor(str)
+    let prependCWD = 0
+    if s:running_windows
+        let prependCWD = a:str !~ '^.:\(\\\|\/\)'
+    else
+        let prependCWD = a:str !~ '^/'
+    endif
+
+    let toReturn = a:str
+    if prependCWD
+        let toReturn = getcwd() . s:Path.Slash() . a:str
+    endif
+
+    return toReturn
+endfunction
+"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.str({'format': 'Cd'})
+    if self.isDirectory ==# 0
+        let dir = self.getParent().str({'format': 'Cd'})
+    endif
+
+    try
+        execute "cd " . dir
+        call s:echo("CWD is now: " . getcwd())
+    catch
+        throw "NERDTree.PathChangeError: cannot change CWD 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.CreatePathError: 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.CreatePathError: 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.CopyingNotSupportedError: Copying is not supported on this OS"
+    endif
+
+    let dest = s:Path.WinToUnixPath(a:dest)
+
+    let cmd = g:NERDTreeCopyCmd . " " . self.str() . " " . dest
+    let success = system(cmd)
+    if success != 0
+        throw "NERDTree.CopyError: Could not copy ''". self.str() ."'' 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 = g:NERDTreeRemoveDirCmd . self.str({'escape': 1})
+        let success = system(cmd)
+
+        if v:shell_error != 0
+            throw "NERDTree.PathDeletionError: Could not delete directory: '" . self.str() . "'"
+        endif
+    else
+        let success = delete(self.str())
+        if success != 0
+            throw "NERDTree.PathDeletionError: Could not delete file: '" . self.str() . "'"
+        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.displayString() {{{3
+"
+"Returns a string that specifies how the path should be represented as a
+"string
+function! s:Path.displayString()
+    if self.cachedDisplayString ==# ""
+        call self.cacheDisplayString()
+    endif
+
+    return self.cachedDisplayString
+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()
+    let p = self.str()
+    return filereadable(p) || isdirectory(p)
+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()
+    if s:running_windows
+        let path = self.drive . '\' . join(self.pathSegments[0:-2], '\')
+    else
+        let path = '/'. join(self.pathSegments[0:-2], '/')
+    endif
+
+    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.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 b:NERDTreeIgnoreEnabled
+        for i in g:NERDTreeIgnore
+            if lastPathComponent =~ i
+                return 1
+            endif
+        endfor
+    endif
+
+    "dont show hidden files unless instructed to
+    if b:NERDTreeShowHidden ==# 0 && lastPathComponent =~ '^\.'
+        return 1
+    endif
+
+    if b:NERDTreeShowFiles ==# 0 && self.isDirectory ==# 0
+        return 1
+    endif
+
+    return 0
+endfunction
+
+"FUNCTION: Path.isUnder(path) {{{3
+"return 1 if this path is somewhere under the given path in the filesystem.
+"
+"a:path should be a dir
+function! s:Path.isUnder(path)
+    if a:path.isDirectory == 0
+        return 0
+    endif
+
+    let this = self.str()
+    let that = a:path.str()
+    return stridx(this, that . s:Path.Slash()) == 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() ==# a:path.str()
+endfunction
+
+"FUNCTION: Path.New() {{{3
+"The Constructor for the Path object
+function! s:Path.New(path)
+    let newPath = copy(self)
+
+    call newPath.readInfoFromDisk(s:Path.AbsolutePathFor(a:path))
+
+    let newPath.cachedDisplayString = ""
+
+    return newPath
+endfunction
+
+"FUNCTION: Path.Slash() {{{3
+"return the slash to use for the current OS
+function! s:Path.Slash()
+    return s:running_windows ? '\' : '/'
+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.InvalidFiletypeError: 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.InvalidArgumentsError: 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.str())
+    call self.cacheDisplayString()
+endfunction
+
+"FUNCTION: Path.rename() {{{3
+"
+"Renames this node on the filesystem
+function! s:Path.rename(newPath)
+    if a:newPath ==# ''
+        throw "NERDTree.InvalidArgumentsError: Invalid newPath for renaming = ". a:newPath
+    endif
+
+    let success =  rename(self.str(), a:newPath)
+    if success != 0
+        throw "NERDTree.PathRenameError: Could not rename: '" . self.str() . "'" . '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() {{{3
+"
+"Returns a string representation of this Path
+"
+"Takes an optional dictionary param to specify how the output should be
+"formatted.
+"
+"The dict may have the following keys:
+"  'format'
+"  'escape'
+"  'truncateTo'
+"
+"The 'format' key may have a value of:
+"  'Cd' - a string to be used with the :cd command
+"  'Edit' - a string to be used with :e :sp :new :tabedit etc
+"  'UI' - a string used in the NERD tree UI
+"
+"The 'escape' key, if specified will cause the output to be escaped with
+"shellescape()
+"
+"The 'truncateTo' key causes the resulting string to be truncated to the value
+"'truncateTo' maps to. A '<' char will be prepended.
+function! s:Path.str(...)
+    let options = a:0 ? a:1 : {}
+    let toReturn = ""
+
+    if has_key(options, 'format')
+        let format = options['format']
+        if has_key(self, '_strFor' . format)
+            exec 'let toReturn = self._strFor' . format . '()'
+        else
+            raise 'NERDTree.UnknownFormatError: unknown format "'. format .'"'
+        endif
+    else
+        let toReturn = self._str()
+    endif
+
+    if has_key(options, 'escape') && options['escape']
+        let toReturn = shellescape(toReturn)
+    endif
+
+    if has_key(options, 'truncateTo')
+        let limit = options['truncateTo']
+        if len(toReturn) > limit
+            let toReturn = "<" . strpart(toReturn, len(toReturn) - limit + 1)
+        endif
+    endif
+
+    return toReturn
+endfunction
+
+"FUNCTION: Path._strForUI() {{{3
+function! s:Path._strForUI()
+    let toReturn = '/' . join(self.pathSegments, '/')
+    if self.isDirectory && toReturn != '/'
+        let toReturn  = toReturn . '/'
+    endif
+    return toReturn
+endfunction
+
+"FUNCTION: Path._strForCd() {{{3
+"
+" returns a string that can be used with :cd
+function! s:Path._strForCd()
+    return escape(self.str(), s:escape_chars)
+endfunction
+"FUNCTION: Path._strForEdit() {{{3
+"
+"Return: the string for this path that is suitable to be used with the :edit
+"command
+function! s:Path._strForEdit()
+    let p = self.str({'format': 'UI'})
+    let cwd = getcwd()
+
+    if s:running_windows
+        let p = tolower(self.str())
+        let cwd = tolower(getcwd())
+    endif
+
+    let p = escape(p, s:escape_chars)
+
+    let cwd = cwd . s:Path.Slash()
+
+    "return a relative path if we can
+    if stridx(p, cwd) ==# 0
+        let p = strpart(p, strlen(cwd))
+    endif
+
+    if p ==# ''
+        let p = '.'
+    endif
+
+    return p
+
+endfunction
+"FUNCTION: Path._strForGlob() {{{3
+function! s:Path._strForGlob()
+    let lead = s:Path.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:Path.Slash())
+
+    if !s:running_windows
+        let toReturn = escape(toReturn, s:escape_chars)
+    endif
+    return toReturn
+endfunction
+"FUNCTION: Path._str() {{{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
+function! s:Path._str()
+    let lead = s:Path.Slash()
+
+    "if we are running windows then slap a drive letter on the front
+    if s:running_windows
+        let lead = self.drive . '\'
+    endif
+
+    return lead . join(self.pathSegments, s:Path.Slash())
+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:checkForBrowse(dir) {{{2
+"inits a secondary nerd tree in the current buffer if appropriate
+function! s:checkForBrowse(dir)
+    if a:dir != '' && isdirectory(a:dir)
+        call s:initNerdTreeInPlace(a:dir)
+    endif
+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:exec(cmd) {{{2
+" same as :exec cmd  but eventignore=all is set for the duration
+function! s:exec(cmd)
+    let old_ei = &ei
+    set ei=all
+    exec a:cmd
+    let &ei = old_ei
+endfunction
+" FUNCTION: s:findAndRevealPath() {{{2
+function! s:findAndRevealPath()
+    try
+        let p = s:Path.New(expand("%:p"))
+    catch /^NERDTree.InvalidArgumentsError/
+        call s:echo("no file for the current buffer")
+        return
+    endtry
+
+    if !s:treeExistsForTab()
+        call s:initNerdTree(p.getParent().str())
+    else
+        if !p.isUnder(s:TreeFileNode.GetRootForTab().path)
+            call s:initNerdTree(p.getParent().str())
+        else
+            if !s:isTreeOpen()
+                call s:toggle("")
+            endif
+        endif
+    endif
+    call s:putCursorInTreeWin()
+    call b:NERDTreeRoot.reveal(p)
+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 ==# '' ? getcwd() : a:name
+
+        "hack to get an absolute path if a relative path is given
+        if dir =~ '^\.'
+            let dir = getcwd() . s:Path.Slash() . dir
+        endif
+        let dir = resolve(dir)
+
+        try
+            let path = s:Path.New(dir)
+        catch /^NERDTree.InvalidArgumentsError/
+            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
+        call path.changeToDir()
+    endif
+
+    if s:treeExistsForTab()
+        if s:isTreeOpen()
+            call s:closeTree()
+        endif
+        unlet t:NERDTreeBufName
+    endif
+
+    let newRoot = s:TreeDirNode.New(path)
+    call newRoot.open()
+
+    call s:createTreeWin()
+    let b:treeShowHelp = 0
+    let b:NERDTreeIgnoreEnabled = 1
+    let b:NERDTreeShowFiles = g:NERDTreeShowFiles
+    let b:NERDTreeShowHidden = g:NERDTreeShowHidden
+    let b:NERDTreeShowBookmarks = g:NERDTreeShowBookmarks
+    let b:NERDTreeRoot = newRoot
+
+    let b:NERDTreeType = "primary"
+
+    call s:renderView()
+    call b:NERDTreeRoot.putCursorHere(0, 0)
+endfunction
+
+"FUNCTION: s:initNerdTreeInPlace(dir) {{{2
+function! s:initNerdTreeInPlace(dir)
+    try
+        let path = s:Path.New(a:dir)
+    catch /^NERDTree.InvalidArgumentsError/
+        call s:echo("Invalid directory name:" . a:name)
+        return
+    endtry
+
+    "we want the directory buffer to disappear when we do the :edit below
+    setlocal bufhidden=wipe
+
+    let previousBuf = expand("#")
+
+    "we need a unique name for each secondary tree buffer to ensure they are
+    "all independent
+    exec "silent edit " . s:nextBufferName()
+
+    let b:NERDTreePreviousBuf = bufnr(previousBuf)
+
+    let b:NERDTreeRoot = s:TreeDirNode.New(path)
+    call b:NERDTreeRoot.open()
+
+    "throwaway buffer options
+    setlocal noswapfile
+    setlocal buftype=nofile
+    setlocal bufhidden=hide
+    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:setupStatusline()
+
+    let b:treeShowHelp = 0
+    let b:NERDTreeIgnoreEnabled = 1
+    let b:NERDTreeShowFiles = g:NERDTreeShowFiles
+    let b:NERDTreeShowHidden = g:NERDTreeShowHidden
+    let b:NERDTreeShowBookmarks = g:NERDTreeShowBookmarks
+
+    let b:NERDTreeType = "secondary"
+
+    call s:bindMappings()
+    setfiletype nerdtree
+    " syntax highlighting
+    if has("syntax") && exists("g:syntax_on")
+        call s:setupSyntaxHighlighting()
+    endif
+
+    call s:renderView()
+endfunction
+" FUNCTION: s:initNerdTreeMirror() {{{2
+function! s:initNerdTreeMirror()
+
+    "get the names off all the nerd tree buffers
+    let treeBufNames = []
+    for i in range(1, tabpagenr("$"))
+        let nextName = s:tabpagevar(i, 'NERDTreeBufName')
+        if nextName != -1 && (!exists("t:NERDTreeBufName") || nextName != t:NERDTreeBufName)
+            call add(treeBufNames, nextName)
+        endif
+    endfor
+    let treeBufNames = s:unique(treeBufNames)
+
+    "map the option names (that the user will be prompted with) to the nerd
+    "tree buffer names
+    let options = {}
+    let i = 0
+    while i < len(treeBufNames)
+        let bufName = treeBufNames[i]
+        let treeRoot = getbufvar(bufName, "NERDTreeRoot")
+        let options[i+1 . '. ' . treeRoot.path.str() . '  (buf name: ' . bufName . ')'] = bufName
+        let i = i + 1
+    endwhile
+
+    "work out which tree to mirror, if there is more than 1 then ask the user
+    let bufferName = ''
+    if len(keys(options)) > 1
+        let choices = ["Choose a tree to mirror"]
+        let choices = extend(choices, sort(keys(options)))
+        let choice = inputlist(choices)
+        if choice < 1 || choice > len(options) || choice ==# ''
+            return
+        endif
+
+        let bufferName = options[sort(keys(options))[choice-1]]
+    elseif len(keys(options)) ==# 1
+        let bufferName = values(options)[0]
+    else
+        call s:echo("No trees to mirror")
+        return
+    endif
+
+    if s:treeExistsForTab() && s:isTreeOpen()
+        call s:closeTree()
+    endif
+
+    let t:NERDTreeBufName = bufferName
+    call s:createTreeWin()
+    exec 'buffer ' .  bufferName
+    if !&hidden
+        call s:renderView()
+    endif
+endfunction
+" FUNCTION: s:nextBufferName() {{{2
+" returns the buffer name for the next nerd tree
+function! s:nextBufferName()
+    let name = s:NERDTreeBufName . s:next_buffer_number
+    let s:next_buffer_number += 1
+    return name
+endfunction
+" FUNCTION: s:tabpagevar(tabnr, var) {{{2
+function! s:tabpagevar(tabnr, var)
+    let currentTab = tabpagenr()
+    let old_ei = &ei
+    set ei=all
+
+    exec "tabnext " . a:tabnr
+    let v = -1
+    if exists('t:' . a:var)
+        exec 'let v = t:' . a:var
+    endif
+    exec "tabnext " . currentTab
+
+    let &ei = old_ei
+
+    return v
+endfunction
+" Function: s:treeExistsForBuffer()   {{{2
+" Returns 1 if a nerd tree root exists in the current buffer
+function! s:treeExistsForBuf()
+    return exists("b:NERDTreeRoot")
+endfunction
+" Function: s:treeExistsForTab()   {{{2
+" Returns 1 if a nerd tree root exists in the current tab
+function! s:treeExistsForTab()
+    return exists("t:NERDTreeBufName")
+endfunction
+" Function: s:unique(list)   {{{2
+" returns a:list without duplicates
+function! s:unique(list)
+  let uniqlist = []
+  for elem in a:list
+    if index(uniqlist, elem) ==# -1
+      let uniqlist += [elem]
+    endif
+  endfor
+  return uniqlist
+endfunction
+" SECTION: Public API {{{1
+"============================================================
+let g:NERDTreePath = s:Path
+let g:NERDTreeDirNode = s:TreeDirNode
+let g:NERDTreeFileNode = s:TreeFileNode
+let g:NERDTreeBookmark = s:Bookmark
+
+function! NERDTreeAddMenuItem(options)
+    call s:MenuItem.Create(a:options)
+endfunction
+
+function! NERDTreeAddMenuSeparator(...)
+    let opts = a:0 ? a:1 : {}
+    call s:MenuItem.CreateSeparator(opts)
+endfunction
+
+function! NERDTreeAddSubmenu(options)
+    return s:MenuItem.Create(a:options)
+endfunction
+
+function! NERDTreeAddKeyMap(options)
+    call s:KeyMap.Create(a:options)
+endfunction
+
+function! NERDTreeRender()
+    call s:renderView()
+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 primary NERD tree window for this tab
+function! s:closeTree()
+    if !s:isTreeOpen()
+        throw "NERDTree.NoTreeFoundError: no NERDTree is open"
+    endif
+
+    if winnr("$") != 1
+        if winnr() == s:getTreeWinNum()
+            wincmd p
+            let bufnr = bufnr("")
+            wincmd p
+        else
+            let bufnr = bufnr("")
+        endif
+
+        call s:exec(s:getTreeWinNum() . " wincmd w")
+        close
+        call s:exec(bufwinnr(bufnr) . " wincmd w")
+    else
+        close
+    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 && s:isTreeOpen()
+        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 ==# "left" ? "topleft " : "botright "
+    let splitSize = g:NERDTreeWinSize
+
+    if !exists('t:NERDTreeBufName')
+        let t:NERDTreeBufName = s:nextBufferName()
+        silent! exec splitLocation . 'vertical ' . splitSize . ' new'
+        silent! exec "edit " . t:NERDTreeBufName
+    else
+        silent! exec splitLocation . 'vertical ' . splitSize . ' split'
+        silent! exec "buffer " . t:NERDTreeBufName
+    endif
+
+    setlocal winfixwidth
+
+    "throwaway buffer options
+    setlocal noswapfile
+    setlocal buftype=nofile
+    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:setupStatusline()
+
+    call s:bindMappings()
+    setfiletype nerdtree
+    " syntax highlighting
+    if has("syntax") && exists("g:syntax_on")
+        call s:setupSyntaxHighlighting()
+    endif
+endfunction
+
+"FUNCTION: s:dumpHelp  {{{2
+"prints out the quick help
+function! s:dumpHelp()
+    let old_h = @h
+    if b: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."\" <CR>,\n"
+        if b:NERDTreeType ==# "primary"
+            let @h=@h."\" ". g:NERDTreeMapActivateNode .": open in prev window\n"
+        else
+            let @h=@h."\" ". g:NERDTreeMapActivateNode .": open in current window\n"
+        endif
+        if b:NERDTreeType ==# "primary"
+            let @h=@h."\" ". g:NERDTreeMapPreview .": preview\n"
+        endif
+        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:NERDTreeMapOpenVSplit .": open vsplit\n"
+        let @h=@h."\" ". g:NERDTreeMapPreviewVSplit .": preview vsplit\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.": explore selected dir\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:NERDTreeMapMenu .": Show 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 (" . (b:NERDTreeShowHidden ? "on" : "off") . ")\n"
+        let @h=@h."\" ". g:NERDTreeMapToggleFilters .": file filters (" . (b:NERDTreeIgnoreEnabled ? "on" : "off") . ")\n"
+        let @h=@h."\" ". g:NERDTreeMapToggleFiles .": files (" . (b:NERDTreeShowFiles ? "on" : "off") . ")\n"
+        let @h=@h."\" ". g:NERDTreeMapToggleBookmarks .": bookmarks (" . (b:NERDTreeShowBookmarks ? "on" : "off") . ")\n"
+
+        "add quickhelp entries for each custom key map
+        if len(s:KeyMap.All())
+            let @h=@h."\"\n\" ----------------------------\n"
+            let @h=@h."\" Custom mappings~\n"
+            for i in s:KeyMap.All()
+                let @h=@h."\" ". i.key .": ". i.quickhelpText ."\n"
+            endfor
+        endif
+
+        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:NERDTreeMapToggleZoom .": Zoom (maximize-minimize)\n"
+        let @h=@h."\"    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:firstUsableWindow(){{{2
+"find the window number of the first normal window
+function! s:firstUsableWindow()
+    let i = 1
+    while i <= winnr("$")
+        let bnum = winbufnr(i)
+        if bnum != -1 && getbufvar(bnum, '&buftype') ==# ''
+                    \ && !getwinvar(i, '&previewwindow')
+                    \ && (!getbufvar(bnum, '&modified') || &hidden)
+            return i
+        endif
+
+        let i += 1
+    endwhile
+    return -1
+endfunction
+"FUNCTION: s:getPath(ln) {{{2
+"Gets the full path to the node that is rendered on the given line number
+"
+"Args:
+"ln: the line number to get the path for
+"
+"Return:
+"A path if a node was selected, {} if nothing is selected.
+"If the 'up a dir' line was selected then the path to the parent of the
+"current root is returned
+function! s:getPath(ln)
+    let line = getline(a:ln)
+
+    let rootLine = s:TreeFileNode.GetRootLineNum()
+
+    "check to see if we have the root node
+    if a:ln == rootLine
+        return b:NERDTreeRoot.path
+    endif
+
+    " in case called from outside the tree
+    if line !~ '^ *[|`]' || line =~ '^$'
+        return {}
+    endif
+
+    if line ==# s:tree_up_dir_line
+        return b:NERDTreeRoot.path.getParent()
+    endif
+
+    let indent = s:indentLevelFor(line)
+
+    "remove the tree parts and the leading space
+    let curFile = s:stripMarkupFromLine(line, 0)
+
+    let wasdir = 0
+    if curFile =~ '/$'
+        let wasdir = 1
+        let curFile = substitute(curFile, '/\?$', '/', "")
+    endif
+
+    let dir = ""
+    let lnum = a:ln
+    while lnum > 0
+        let lnum = lnum - 1
+        let curLine = getline(lnum)
+        let curLineStripped = s:stripMarkupFromLine(curLine, 1)
+
+        "have we reached the top of the tree?
+        if lnum == rootLine
+            let dir = b:NERDTreeRoot.path.str({'format': 'UI'}) . dir
+            break
+        endif
+        if curLineStripped =~ '/$'
+            let lpindent = s:indentLevelFor(curLine)
+            if lpindent < indent
+                let indent = indent - 1
+
+                let dir = substitute (curLineStripped,'^\\', "", "") . dir
+                continue
+            endif
+        endif
+    endwhile
+    let curFile = b:NERDTreeRoot.path.drive . dir . curFile
+    let toReturn = s:Path.New(curFile)
+    return toReturn
+endfunction
+
+"FUNCTION: s:getTreeWinNum() {{{2
+"gets the nerd tree window number for this tab
+function! s:getTreeWinNum()
+    if exists("t:NERDTreeBufName")
+        return bufwinnr(t:NERDTreeBufName)
+    else
+        return -1
+    endif
+endfunction
+"FUNCTION: s:indentLevelFor(line) {{{2
+function! s:indentLevelFor(line)
+    return match(a:line, '[^ \-+~`|]') / s:tree_wid
+endfunction
+"FUNCTION: s:isTreeOpen() {{{2
+function! s:isTreeOpen()
+    return s:getTreeWinNum() != -1
+endfunction
+"FUNCTION: s:isWindowUsable(winnumber) {{{2
+"Returns 0 if opening a file from the tree in the given window requires it to
+"be split, 1 otherwise
+"
+"Args:
+"winnumber: the number of the window in question
+function! s:isWindowUsable(winnumber)
+    "gotta split if theres only one window (i.e. the NERD tree)
+    if winnr("$") ==# 1
+        return 0
+    endif
+
+    let oldwinnr = winnr()
+    call s:exec(a:winnumber . "wincmd p")
+    let specialWindow = getbufvar("%", '&buftype') != '' || getwinvar('%', '&previewwindow')
+    let modified = &modified
+    call s:exec(oldwinnr . "wincmd p")
+
+    "if its a special window e.g. quickfix or another explorer plugin then we
+    "have to split
+    if specialWindow
+        return 0
+    endif
+
+    if &hidden
+        return 1
+    endif
+
+    return !modified || s:bufInWindows(winbufnr(a:winnumber)) >= 2
+endfunction
+
+" FUNCTION: s:jumpToChild(direction) {{{2
+" Args:
+" direction: 0 if going to first child, 1 if going to last
+function! s:jumpToChild(direction)
+    let currentNode = s:TreeFileNode.GetSelected()
+    if currentNode ==# {} || currentNode.isRoot()
+        call s:echo("cannot jump to " . (a:direction ? "last" : "first") .  " child")
+        return
+    end
+    let dirNode = currentNode.parent
+    let childNodes = dirNode.getVisibleChildren()
+
+    let targetNode = childNodes[0]
+    if a:direction
+        let targetNode = childNodes[len(childNodes) - 1]
+    endif
+
+    if targetNode.equals(currentNode)
+        let siblingDir = currentNode.parent.findOpenDirSiblingWithVisibleChildren(a:direction)
+        if siblingDir != {}
+            let indx = a:direction ? siblingDir.getVisibleChildCount()-1 : 0
+            let targetNode = siblingDir.getChildByIndex(indx, 1)
+        endif
+    endif
+
+    call targetNode.putCursorHere(1, 0)
+
+    call s:centerView()
+endfunction
+
+
+"FUNCTION: s:promptToDelBuffer(bufnum, msg){{{2
+"prints out the given msg and, if the user responds by pushing 'y' then the
+"buffer with the given bufnum is deleted
+"
+"Args:
+"bufnum: the buffer that may be deleted
+"msg: a message that will be echoed to the user asking them if they wish to
+"     del the buffer
+function! s:promptToDelBuffer(bufnum, msg)
+    echo a:msg
+    if nr2char(getchar()) ==# 'y'
+        exec "silent bdelete! " . a:bufnum
+    endif
+endfunction
+
+"FUNCTION: s:putCursorOnBookmarkTable(){{{2
+"Places the cursor at the top of the bookmarks table
+function! s:putCursorOnBookmarkTable()
+    if !b:NERDTreeShowBookmarks
+        throw "NERDTree.IllegalOperationError: cant find bookmark table, bookmarks arent active"
+    endif
+
+    let rootNodeLine = s:TreeFileNode.GetRootLineNum()
+
+    let line = 1
+    while getline(line) !~ '^>-\+Bookmarks-\+$'
+        let line = line + 1
+        if line >= rootNodeLine
+            throw "NERDTree.BookmarkTableNotFoundError: didnt find the bookmarks table"
+        endif
+    endwhile
+    call cursor(line, 0)
+endfunction
+
+"FUNCTION: s:putCursorInTreeWin(){{{2
+"Places the cursor in the nerd tree window
+function! s:putCursorInTreeWin()
+    if !s:isTreeOpen()
+        throw "NERDTree.InvalidOperationError: cant put cursor in NERD tree window, no window exists"
+    endif
+
+    call s:exec(s:getTreeWinNum() . "wincmd w")
+endfunction
+
+"FUNCTION: s:renderBookmarks {{{2
+function! s:renderBookmarks()
+
+    call setline(line(".")+1, ">----------Bookmarks----------")
+    call cursor(line(".")+1, col("."))
+
+    for i in s:Bookmark.Bookmarks()
+        call setline(line(".")+1, i.str())
+        call cursor(line(".")+1, col("."))
+    endfor
+
+    call setline(line(".")+1, '')
+    call cursor(line(".")+1, col("."))
+endfunction
+"FUNCTION: s:renderView {{{2
+"The entry function for rendering the tree
+function! s:renderView()
+    setlocal modifiable
+
+    "remember the top line of the buffer and the current line so we can
+    "restore the view exactly how it was
+    let curLine = line(".")
+    let curCol = col(".")
+    let topLine = line("w0")
+
+    "delete all lines in the buffer (being careful not to clobber a register)
+    silent 1,$delete _
+
+    call s:dumpHelp()
+
+    "delete the blank line before the help and add one after it
+    call setline(line(".")+1, "")
+    call cursor(line(".")+1, col("."))
+
+    if b:NERDTreeShowBookmarks
+        call s:renderBookmarks()
+    endif
+
+    "add the 'up a dir' line
+    call setline(line(".")+1, s:tree_up_dir_line)
+    call cursor(line(".")+1, col("."))
+
+    "draw the header line
+    let header = b:NERDTreeRoot.path.str({'format': 'UI', 'truncateTo': winwidth(0)})
+    call setline(line(".")+1, header)
+    call cursor(line(".")+1, col("."))
+
+    "draw the tree
+    let old_o = @o
+    let @o = b:NERDTreeRoot.renderToString()
+    silent put o
+    let @o = old_o
+
+    "delete the blank line at the top of the buffer
+    silent 1,1delete _
+
+    "restore the view
+    let old_scrolloff=&scrolloff
+    let &scrolloff=0
+    call cursor(topLine, 1)
+    normal! zt
+    call cursor(curLine, curCol)
+    let &scrolloff = old_scrolloff
+
+    setlocal nomodifiable
+endfunction
+
+"FUNCTION: s:renderViewSavingPosition {{{2
+"Renders the tree and ensures the cursor stays on the current node or the
+"current nodes parent if it is no longer available upon re-rendering
+function! s:renderViewSavingPosition()
+    let currentNode = s:TreeFileNode.GetSelected()
+
+    "go up the tree till we find a node that will be visible or till we run
+    "out of nodes
+    while currentNode != {} && !currentNode.isVisible() && !currentNode.isRoot()
+        let currentNode = currentNode.parent
+    endwhile
+
+    call s:renderView()
+
+    if currentNode != {}
+        call currentNode.putCursorHere(0, 0)
+    endif
+endfunction
+"FUNCTION: s:restoreScreenState() {{{2
+"
+"Sets the screen state back to what it was when s:saveScreenState was last
+"called.
+"
+"Assumes the cursor is in the NERDTree window
+function! s:restoreScreenState()
+    if !exists("b:NERDTreeOldTopLine") || !exists("b:NERDTreeOldPos") || !exists("b:NERDTreeOldWindowSize")
+        return
+    endif
+    exec("silent vertical resize ".b:NERDTreeOldWindowSize)
+
+    let old_scrolloff=&scrolloff
+    let &scrolloff=0
+    call cursor(b:NERDTreeOldTopLine, 0)
+    normal! zt
+    call setpos(".", b:NERDTreeOldPos)
+    let &scrolloff=old_scrolloff
+endfunction
+
+"FUNCTION: s:saveScreenState() {{{2
+"Saves the current cursor position in the current buffer and the window
+"scroll position
+function! s:saveScreenState()
+    let win = winnr()
+    try
+        call s:putCursorInTreeWin()
+        let b:NERDTreeOldPos = getpos(".")
+        let b:NERDTreeOldTopLine = line("w0")
+        let b:NERDTreeOldWindowSize = winwidth("")
+        call s:exec(win . "wincmd w")
+    catch /^NERDTree.InvalidOperationError/
+    endtry
+endfunction
+
+"FUNCTION: s:setupStatusline() {{{2
+function! s:setupStatusline()
+    if g:NERDTreeStatusline != -1
+        let &l:statusline = g:NERDTreeStatusline
+    endif
+endfunction
+"FUNCTION: s:setupSyntaxHighlighting() {{{2
+function! s:setupSyntaxHighlighting()
+    "treeFlags are syntax items that should be invisible, but give clues as to
+    "how things should be highlighted
+    syn match treeFlag #\~#
+    syn match treeFlag #\[RO\]#
+
+    "highlighting for the .. (up dir) line at the top of the tree
+    execute "syn match treeUp #". s:tree_up_dir_line ."#"
+
+    "highlighting for the ~/+ symbols for the directory nodes
+    syn match treeClosable #\~\<#
+    syn match treeClosable #\~\.#
+    syn match treeOpenable #+\<#
+    syn match treeOpenable #+\.#he=e-1
+
+    "highlighting for the tree structural parts
+    syn match treePart #|#
+    syn match treePart #`#
+    syn match treePartFile #[|`]-#hs=s+1 contains=treePart
+
+    "quickhelp syntax elements
+    syn match treeHelpKey #" \{1,2\}[^ ]*:#hs=s+2,he=e-1
+    syn match treeHelpKey #" \{1,2\}[^ ]*,#hs=s+2,he=e-1
+    syn match treeHelpTitle #" .*\~#hs=s+2,he=e-1 contains=treeFlag
+    syn match treeToggleOn #".*(on)#hs=e-2,he=e-1 contains=treeHelpKey
+    syn match treeToggleOff #".*(off)#hs=e-3,he=e-1 contains=treeHelpKey
+    syn match treeHelpCommand #" :.\{-}\>#hs=s+3
+    syn match treeHelp  #^".*# contains=treeHelpKey,treeHelpTitle,treeFlag,treeToggleOff,treeToggleOn,treeHelpCommand
+
+    "highlighting for readonly files
+    syn match treeRO #.*\[RO\]#hs=s+2 contains=treeFlag,treeBookmark,treePart,treePartFile
+
+    "highlighting for sym links
+    syn match treeLink #[^-| `].* -> # contains=treeBookmark,treeOpenable,treeClosable,treeDirSlash
+
+    "highlighing for directory nodes and file nodes
+    syn match treeDirSlash #/#
+    syn match treeDir #[^-| `].*/# contains=treeLink,treeDirSlash,treeOpenable,treeClosable
+    syn match treeExecFile  #[|`]-.*\*\($\| \)# contains=treeLink,treePart,treeRO,treePartFile,treeBookmark
+    syn match treeFile  #|-.*# contains=treeLink,treePart,treeRO,treePartFile,treeBookmark,treeExecFile
+    syn match treeFile  #`-.*# contains=treeLink,treePart,treeRO,treePartFile,treeBookmark,treeExecFile
+    syn match treeCWD #^/.*$#
+
+    "highlighting for bookmarks
+    syn match treeBookmark # {.*}#hs=s+1
+
+    "highlighting for the bookmarks table
+    syn match treeBookmarksLeader #^>#
+    syn match treeBookmarksHeader #^>-\+Bookmarks-\+$# contains=treeBookmarksLeader
+    syn match treeBookmarkName #^>.\{-} #he=e-1 contains=treeBookmarksLeader
+    syn match treeBookmark #^>.*$# contains=treeBookmarksLeader,treeBookmarkName,treeBookmarksHeader
+
+    if g:NERDChristmasTree
+        hi def link treePart Special
+        hi def link treePartFile Type
+        hi def link treeFile Normal
+        hi def link treeExecFile Title
+        hi def link treeDirSlash Identifier
+        hi def link treeClosable Type
+    else
+        hi def link treePart Normal
+        hi def link treePartFile Normal
+        hi def link treeFile Normal
+        hi def link treeClosable Title
+    endif
+
+    hi def link treeBookmarksHeader statement
+    hi def link treeBookmarksLeader ignore
+    hi def link treeBookmarkName Identifier
+    hi def link treeBookmark normal
+
+    hi def link treeHelp String
+    hi def link treeHelpKey Identifier
+    hi def link treeHelpCommand Identifier
+    hi def link treeHelpTitle Macro
+    hi def link treeToggleOn Question
+    hi def link treeToggleOff WarningMsg
+
+    hi def link treeDir Directory
+    hi def link treeUp Directory
+    hi def link treeCWD Statement
+    hi def link treeLink Macro
+    hi def link treeOpenable Title
+    hi def link treeFlag ignore
+    hi def link treeRO WarningMsg
+    hi def link treeBookmark Statement
+
+    hi def link NERDTreeCurrentNode Search
+endfunction
+
+"FUNCTION: s:stripMarkupFromLine(line, removeLeadingSpaces){{{2
+"returns the given line with all the tree parts stripped off
+"
+"Args:
+"line: the subject line
+"removeLeadingSpaces: 1 if leading spaces are to be removed (leading spaces =
+"any spaces before the actual text of the node)
+function! s:stripMarkupFromLine(line, removeLeadingSpaces)
+    let line = a:line
+    "remove the tree parts and the leading space
+    let line = substitute (line, s:tree_markup_reg,"","")
+
+    "strip off any read only flag
+    let line = substitute (line, ' \[RO\]', "","")
+
+    "strip off any bookmark flags
+    let line = substitute (line, ' {[^}]*}', "","")
+
+    "strip off any executable flags
+    let line = substitute (line, '*\ze\($\| \)', "","")
+
+    let wasdir = 0
+    if line =~ '/$'
+        let wasdir = 1
+    endif
+    let line = substitute (line,' -> .*',"","") " remove link to
+    if wasdir ==# 1
+        let line = substitute (line, '/\?$', '/', "")
+    endif
+
+    if a:removeLeadingSpaces
+        let line = substitute (line, '^ *', '', '')
+    endif
+
+    return line
+endfunction
+
+"FUNCTION: s:toggle(dir) {{{2
+"Toggles the NERD tree. I.e the NERD tree is open, it is closed, if it is
+"closed it is restored or initialized (if it doesnt exist)
+"
+"Args:
+"dir: the full path for the root node (is only used if the NERD tree is being
+"initialized.
+function! s:toggle(dir)
+    if s:treeExistsForTab()
+        if !s:isTreeOpen()
+            call s:createTreeWin()
+            if !&hidden
+                call s:renderView()
+            endif
+            call s:restoreScreenState()
+        else
+            call s:closeTree()
+        endif
+    else
+        call s:initNerdTree(a:dir)
+    endif
+endfunction
+"SECTION: Interface bindings {{{1
+"============================================================
+"FUNCTION: s:activateNode(forceKeepWindowOpen) {{{2
+"If the current node is a file, open it in the previous window (or a new one
+"if the previous is modified). If it is a directory then it is opened.
+"
+"args:
+"forceKeepWindowOpen - dont close the window even if NERDTreeQuitOnOpen is set
+function! s:activateNode(forceKeepWindowOpen)
+    if getline(".") ==# s:tree_up_dir_line
+        return s:upDir(0)
+    endif
+
+    let treenode = s:TreeFileNode.GetSelected()
+    if treenode != {}
+        call treenode.activate(a:forceKeepWindowOpen)
+    else
+        let bookmark = s:Bookmark.GetSelected()
+        if !empty(bookmark)
+            call bookmark.activate()
+        endif
+    endif
+endfunction
+
+"FUNCTION: s:bindMappings() {{{2
+function! s:bindMappings()
+    " set up mappings and commands for this buffer
+    nnoremap <silent> <buffer> <middlerelease> :call <SID>handleMiddleMouse()<cr>
+    nnoremap <silent> <buffer> <leftrelease> <leftrelease>:call <SID>checkForActivate()<cr>
+    nnoremap <silent> <buffer> <2-leftmouse> :call <SID>activateNode(0)<cr>
+
+    exec "nnoremap <silent> <buffer> ". g:NERDTreeMapActivateNode . " :call <SID>activateNode(0)<cr>"
+    exec "nnoremap <silent> <buffer> ". g:NERDTreeMapOpenSplit ." :call <SID>openEntrySplit(0,0)<cr>"
+    exec "nnoremap <silent> <buffer> <cr> :call <SID>activateNode(0)<cr>"
+
+    exec "nnoremap <silent> <buffer> ". g:NERDTreeMapPreview ." :call <SID>previewNode(0)<cr>"
+    exec "nnoremap <silent> <buffer> ". g:NERDTreeMapPreviewSplit ." :call <SID>previewNode(1)<cr>"
+
+    exec "nnoremap <silent> <buffer> ". g:NERDTreeMapOpenVSplit ." :call <SID>openEntrySplit(1,0)<cr>"
+    exec "nnoremap <silent> <buffer> ". g:NERDTreeMapPreviewVSplit ." :call <SID>previewNode(2)<cr>"
+
+    exec "nnoremap <silent> <buffer> ". g:NERDTreeMapOpenRecursively ." :call <SID>openNodeRecursively()<cr>"
+
+    exec "nnoremap <silent> <buffer> ". g:NERDTreeMapUpdirKeepOpen ." :call <SID>upDir(1)<cr>"
+    exec "nnoremap <silent> <buffer> ". g:NERDTreeMapUpdir ." :call <SID>upDir(0)<cr>"
+    exec "nnoremap <silent> <buffer> ". g:NERDTreeMapChangeRoot ." :call <SID>chRoot()<cr>"
+
+    exec "nnoremap <silent> <buffer> ". g:NERDTreeMapChdir ." :call <SID>chCwd()<cr>"
+
+    exec "nnoremap <silent> <buffer> ". g:NERDTreeMapQuit ." :call <SID>closeTreeWindow()<cr>"
+
+    exec "nnoremap <silent> <buffer> ". g:NERDTreeMapRefreshRoot ." :call <SID>refreshRoot()<cr>"
+    exec "nnoremap <silent> <buffer> ". g:NERDTreeMapRefresh ." :call <SID>refreshCurrent()<cr>"
+
+    exec "nnoremap <silent> <buffer> ". g:NERDTreeMapHelp ." :call <SID>displayHelp()<cr>"
+    exec "nnoremap <silent> <buffer> ". g:NERDTreeMapToggleZoom ." :call <SID>toggleZoom()<cr>"
+    exec "nnoremap <silent> <buffer> ". g:NERDTreeMapToggleHidden ." :call <SID>toggleShowHidden()<cr>"
+    exec "nnoremap <silent> <buffer> ". g:NERDTreeMapToggleFilters ." :call <SID>toggleIgnoreFilter()<cr>"
+    exec "nnoremap <silent> <buffer> ". g:NERDTreeMapToggleFiles ." :call <SID>toggleShowFiles()<cr>"
+    exec "nnoremap <silent> <buffer> ". g:NERDTreeMapToggleBookmarks ." :call <SID>toggleShowBookmarks()<cr>"
+
+    exec "nnoremap <silent> <buffer> ". g:NERDTreeMapCloseDir ." :call <SID>closeCurrentDir()<cr>"
+    exec "nnoremap <silent> <buffer> ". g:NERDTreeMapCloseChildren ." :call <SID>closeChildren()<cr>"
+
+    exec "nnoremap <silent> <buffer> ". g:NERDTreeMapMenu ." :call <SID>showMenu()<cr>"
+
+    exec "nnoremap <silent> <buffer> ". g:NERDTreeMapJumpParent ." :call <SID>jumpToParent()<cr>"
+    exec "nnoremap <silent> <buffer> ". g:NERDTreeMapJumpNextSibling ." :call <SID>jumpToSibling(1)<cr>"
+    exec "nnoremap <silent> <buffer> ". g:NERDTreeMapJumpPrevSibling ." :call <SID>jumpToSibling(0)<cr>"
+    exec "nnoremap <silent> <buffer> ". g:NERDTreeMapJumpFirstChild ." :call <SID>jumpToFirstChild()<cr>"
+    exec "nnoremap <silent> <buffer> ". g:NERDTreeMapJumpLastChild ." :call <SID>jumpToLastChild()<cr>"
+    exec "nnoremap <silent> <buffer> ". g:NERDTreeMapJumpRoot ." :call <SID>jumpToRoot()<cr>"
+
+    exec "nnoremap <silent> <buffer> ". g:NERDTreeMapOpenInTab ." :call <SID>openInNewTab(0)<cr>"
+    exec "nnoremap <silent> <buffer> ". g:NERDTreeMapOpenInTabSilent ." :call <SID>openInNewTab(1)<cr>"
+
+    exec "nnoremap <silent> <buffer> ". g:NERDTreeMapOpenExpl ." :call <SID>openExplorer()<cr>"
+
+    exec "nnoremap <silent> <buffer> ". g:NERDTreeMapDeleteBookmark ." :call <SID>deleteBookmark()<cr>"
+
+    "bind all the user custom maps
+    call s:KeyMap.BindAll()
+
+    command! -buffer -nargs=1 Bookmark :call <SID>bookmarkNode('<args>')
+    command! -buffer -complete=customlist,s:completeBookmarks -nargs=1 RevealBookmark :call <SID>revealBookmark('<args>')
+    command! -buffer -complete=customlist,s:completeBookmarks -nargs=1 OpenBookmark :call <SID>openBookmark('<args>')
+    command! -buffer -complete=customlist,s:completeBookmarks -nargs=* ClearBookmarks call <SID>clearBookmarks('<args>')
+    command! -buffer -complete=customlist,s:completeBookmarks -nargs=+ BookmarkToRoot call s:Bookmark.ToRoot('<args>')
+    command! -buffer -nargs=0 ClearAllBookmarks call s:Bookmark.ClearAll() <bar> call <SID>renderView()
+    command! -buffer -nargs=0 ReadBookmarks call s:Bookmark.CacheBookmarks(0) <bar> call <SID>renderView()
+    command! -buffer -nargs=0 WriteBookmarks call s:Bookmark.Write()
+endfunction
+
+" FUNCTION: s:bookmarkNode(name) {{{2
+" Associate the current node with the given name
+function! s:bookmarkNode(name)
+    let currentNode = s:TreeFileNode.GetSelected()
+    if currentNode != {}
+        try
+            call currentNode.bookmark(a:name)
+            call s:renderView()
+        catch /^NERDTree.IllegalBookmarkNameError/
+            call s:echo("bookmark names must not contain spaces")
+        endtry
+    else
+        call s:echo("select a node first")
+    endif
+endfunction
+"FUNCTION: s:checkForActivate() {{{2
+"Checks if the click should open the current node, if so then activate() is
+"called (directories are automatically opened if the symbol beside them is
+"clicked)
+function! s:checkForActivate()
+    let currentNode = s:TreeFileNode.GetSelected()
+    if currentNode != {}
+        let startToCur = strpart(getline(line(".")), 0, col("."))
+        let char = strpart(startToCur, strlen(startToCur)-1, 1)
+
+        "if they clicked a dir, check if they clicked on the + or ~ sign
+        "beside it
+        if currentNode.path.isDirectory
+            if startToCur =~ s:tree_markup_reg . '$' && char =~ '[+~]'
+                call s:activateNode(0)
+                return
+            endif
+        endif
+
+        if (g:NERDTreeMouseMode ==# 2 && currentNode.path.isDirectory) || g:NERDTreeMouseMode ==# 3
+            if char !~ s:tree_markup_reg && startToCur !~ '\/$'
+                call s:activateNode(0)
+                return
+            endif
+        endif
+    endif
+endfunction
+
+" FUNCTION: s:chCwd() {{{2
+function! s:chCwd()
+    let treenode = s:TreeFileNode.GetSelected()
+    if treenode ==# {}
+        call s:echo("Select a node first")
+        return
+    endif
+
+    try
+        call treenode.path.changeToDir()
+    catch /^NERDTree.PathChangeError/
+        call s:echoWarning("could not change cwd")
+    endtry
+endfunction
+
+" FUNCTION: s:chRoot() {{{2
+" changes the current root to the selected one
+function! s:chRoot()
+    let treenode = s:TreeFileNode.GetSelected()
+    if treenode ==# {}
+        call s:echo("Select a node first")
+        return
+    endif
+
+    call treenode.makeRoot()
+    call s:renderView()
+    call b:NERDTreeRoot.putCursorHere(0, 0)
+endfunction
+
+" FUNCTION: s:clearBookmarks(bookmarks) {{{2
+function! s:clearBookmarks(bookmarks)
+    if a:bookmarks ==# ''
+        let currentNode = s:TreeFileNode.GetSelected()
+        if currentNode != {}
+            call currentNode.clearBoomarks()
+        endif
+    else
+        for name in split(a:bookmarks, ' ')
+            let bookmark = s:Bookmark.BookmarkFor(name)
+            call bookmark.delete()
+        endfor
+    endif
+    call s:renderView()
+endfunction
+" FUNCTION: s:closeChildren() {{{2
+" closes all childnodes of the current node
+function! s:closeChildren()
+    let currentNode = s:TreeDirNode.GetSelected()
+    if currentNode ==# {}
+        call s:echo("Select a node first")
+        return
+    endif
+
+    call currentNode.closeChildren()
+    call s:renderView()
+    call currentNode.putCursorHere(0, 0)
+endfunction
+" FUNCTION: s:closeCurrentDir() {{{2
+" closes the parent dir of the current node
+function! s:closeCurrentDir()
+    let treenode = s:TreeFileNode.GetSelected()
+    if treenode ==# {}
+        call s:echo("Select a node first")
+        return
+    endif
+
+    let parent = treenode.parent
+    if parent ==# {} || parent.isRoot()
+        call s:echo("cannot close tree root")
+    else
+        call treenode.parent.close()
+        call s:renderView()
+        call treenode.parent.putCursorHere(0, 0)
+    endif
+endfunction
+" FUNCTION: s:closeTreeWindow() {{{2
+" close the tree window
+function! s:closeTreeWindow()
+    if b:NERDTreeType ==# "secondary" && b:NERDTreePreviousBuf != -1
+        exec "buffer " . b:NERDTreePreviousBuf
+    else
+        if winnr("$") > 1
+            call s:closeTree()
+        else
+            call s:echo("Cannot close last window")
+        endif
+    endif
+endfunction
+" FUNCTION: s:deleteBookmark() {{{2
+" if the cursor is on a bookmark, prompt to delete
+function! s:deleteBookmark()
+    let bookmark = s:Bookmark.GetSelected()
+    if bookmark ==# {}
+        call s:echo("Put the cursor on a bookmark")
+        return
+    endif
+
+    echo  "Are you sure you wish to delete the bookmark:\n\"" . bookmark.name . "\" (yN):"
+
+    if  nr2char(getchar()) ==# 'y'
+        try
+            call bookmark.delete()
+            call s:renderView()
+            redraw
+        catch /^NERDTree/
+            call s:echoWarning("Could not remove bookmark")
+        endtry
+    else
+        call s:echo("delete aborted" )
+    endif
+
+endfunction
+
+" FUNCTION: s:displayHelp() {{{2
+" toggles the help display
+function! s:displayHelp()
+    let b:treeShowHelp = b:treeShowHelp ? 0 : 1
+    call s:renderView()
+    call s:centerView()
+endfunction
+
+" FUNCTION: s:handleMiddleMouse() {{{2
+function! s:handleMiddleMouse()
+    let curNode = s:TreeFileNode.GetSelected()
+    if curNode ==# {}
+        call s:echo("Put the cursor on a node first" )
+        return
+    endif
+
+    if curNode.path.isDirectory
+        call s:openExplorer()
+    else
+        call s:openEntrySplit(0,0)
+    endif
+endfunction
+
+
+" FUNCTION: s:jumpToFirstChild() {{{2
+" wrapper for the jump to child method
+function! s:jumpToFirstChild()
+    call s:jumpToChild(0)
+endfunction
+
+" FUNCTION: s:jumpToLastChild() {{{2
+" wrapper for the jump to child method
+function! s:jumpToLastChild()
+    call s:jumpToChild(1)
+endfunction
+
+" FUNCTION: s:jumpToParent() {{{2
+" moves the cursor to the parent of the current node
+function! s:jumpToParent()
+    let currentNode = s:TreeFileNode.GetSelected()
+    if !empty(currentNode)
+        if !empty(currentNode.parent)
+            call currentNode.parent.putCursorHere(1, 0)
+            call s:centerView()
+        else
+            call s:echo("cannot jump to parent")
+        endif
+    else
+        call s:echo("put the cursor on a node first")
+    endif
+endfunction
+
+" FUNCTION: s:jumpToRoot() {{{2
+" moves the cursor to the root node
+function! s:jumpToRoot()
+    call b:NERDTreeRoot.putCursorHere(1, 0)
+    call s:centerView()
+endfunction
+
+" FUNCTION: s:jumpToSibling() {{{2
+" moves the cursor to the sibling of the current node in the given direction
+"
+" Args:
+" forward: 1 if the cursor should move to the next sibling, 0 if it should
+" move back to the previous sibling
+function! s:jumpToSibling(forward)
+    let currentNode = s:TreeFileNode.GetSelected()
+    if !empty(currentNode)
+        let sibling = currentNode.findSibling(a:forward)
+
+        if !empty(sibling)
+            call sibling.putCursorHere(1, 0)
+            call s:centerView()
+        endif
+    else
+        call s:echo("put the cursor on a node first")
+    endif
+endfunction
+
+" FUNCTION: s:openBookmark(name) {{{2
+" put the cursor on the given bookmark and, if its a file, open it
+function! s:openBookmark(name)
+    try
+        let targetNode = s:Bookmark.GetNodeForName(a:name, 0)
+        call targetNode.putCursorHere(0, 1)
+        redraw!
+    catch /^NERDTree.BookmarkedNodeNotFoundError/
+        call s:echo("note - target node is not cached")
+        let bookmark = s:Bookmark.BookmarkFor(a:name)
+        let targetNode = s:TreeFileNode.New(bookmark.path)
+    endtry
+    if targetNode.path.isDirectory
+        call targetNode.openExplorer()
+    else
+        call targetNode.open()
+    endif
+endfunction
+" FUNCTION: s:openEntrySplit(vertical, forceKeepWindowOpen) {{{2
+"Opens the currently selected file from the explorer in a
+"new window
+"
+"args:
+"forceKeepWindowOpen - dont close the window even if NERDTreeQuitOnOpen is set
+function! s:openEntrySplit(vertical, forceKeepWindowOpen)
+    let treenode = s:TreeFileNode.GetSelected()
+    if treenode != {}
+        if a:vertical
+            call treenode.openVSplit()
+        else
+            call treenode.openSplit()
+        endif
+        if !a:forceKeepWindowOpen
+            call s:closeTreeIfQuitOnOpen()
+        endif
+    else
+        call s:echo("select a node first")
+    endif
+endfunction
+
+" FUNCTION: s:openExplorer() {{{2
+function! s:openExplorer()
+    let treenode = s:TreeDirNode.GetSelected()
+    if treenode != {}
+        call treenode.openExplorer()
+    else
+        call s:echo("select a node first")
+    endif
+endfunction
+
+" FUNCTION: s:openInNewTab(stayCurrentTab) {{{2
+" Opens the selected node or bookmark in a new tab
+" Args:
+" stayCurrentTab: if 1 then vim will stay in the current tab, if 0 then vim
+" will go to the tab where the new file is opened
+function! s:openInNewTab(stayCurrentTab)
+    let target = s:TreeFileNode.GetSelected()
+    if target == {}
+        let target = s:Bookmark.GetSelected()
+    endif
+
+    if target != {}
+        call target.openInNewTab({'stayInCurrentTab': a:stayCurrentTab})
+    endif
+endfunction
+
+" FUNCTION: s:openNodeRecursively() {{{2
+function! s:openNodeRecursively()
+    let treenode = s:TreeFileNode.GetSelected()
+    if treenode ==# {} || treenode.path.isDirectory ==# 0
+        call s:echo("Select a directory node first" )
+    else
+        call s:echo("Recursively opening node. Please wait...")
+        call treenode.openRecursively()
+        call s:renderView()
+        redraw
+        call s:echo("Recursively opening node. Please wait... DONE")
+    endif
+
+endfunction
+
+"FUNCTION: s:previewNode() {{{2
+"Args:
+"   openNewWin: if 0, use the previous window, if 1 open in new split, if 2
+"               open in a vsplit
+function! s:previewNode(openNewWin)
+    let currentBuf = bufnr("")
+    if a:openNewWin > 0
+        call s:openEntrySplit(a:openNewWin ==# 2,1)
+    else
+        call s:activateNode(1)
+    end
+    call s:exec(bufwinnr(currentBuf) . "wincmd w")
+endfunction
+
+" FUNCTION: s:revealBookmark(name) {{{2
+" put the cursor on the node associate with the given name
+function! s:revealBookmark(name)
+    try
+        let targetNode = s:Bookmark.GetNodeForName(a:name, 0)
+        call targetNode.putCursorHere(0, 1)
+    catch /^NERDTree.BookmarkNotFoundError/
+        call s:echo("Bookmark isnt cached under the current root")
+    endtry
+endfunction
+" FUNCTION: s:refreshRoot() {{{2
+" Reloads the current root. All nodes below this will be lost and the root dir
+" will be reloaded.
+function! s:refreshRoot()
+    call s:echo("Refreshing the root node. This could take a while...")
+    call b:NERDTreeRoot.refresh()
+    call s:renderView()
+    redraw
+    call s:echo("Refreshing the root node. This could take a while... DONE")
+endfunction
+
+" FUNCTION: s:refreshCurrent() {{{2
+" refreshes the root for the current node
+function! s:refreshCurrent()
+    let treenode = s:TreeDirNode.GetSelected()
+    if treenode ==# {}
+        call s:echo("Refresh failed. Select a node first")
+        return
+    endif
+
+    call s:echo("Refreshing node. This could take a while...")
+    call treenode.refresh()
+    call s:renderView()
+    redraw
+    call s:echo("Refreshing node. This could take a while... DONE")
+endfunction
+" FUNCTION: s:showMenu() {{{2
+function! s:showMenu()
+    let curNode = s:TreeFileNode.GetSelected()
+    if curNode ==# {}
+        call s:echo("Put the cursor on a node first" )
+        return
+    endif
+
+    let mc = s:MenuController.New(s:MenuItem.AllEnabled())
+    call mc.showMenu()
+endfunction
+
+" FUNCTION: s:toggleIgnoreFilter() {{{2
+" toggles the use of the NERDTreeIgnore option
+function! s:toggleIgnoreFilter()
+    let b:NERDTreeIgnoreEnabled = !b:NERDTreeIgnoreEnabled
+    call s:renderViewSavingPosition()
+    call s:centerView()
+endfunction
+
+" FUNCTION: s:toggleShowBookmarks() {{{2
+" toggles the display of bookmarks
+function! s:toggleShowBookmarks()
+    let b:NERDTreeShowBookmarks = !b:NERDTreeShowBookmarks
+    if b:NERDTreeShowBookmarks
+        call s:renderView()
+        call s:putCursorOnBookmarkTable()
+    else
+        call s:renderViewSavingPosition()
+    endif
+    call s:centerView()
+endfunction
+" FUNCTION: s:toggleShowFiles() {{{2
+" toggles the display of hidden files
+function! s:toggleShowFiles()
+    let b:NERDTreeShowFiles = !b:NERDTreeShowFiles
+    call s:renderViewSavingPosition()
+    call s:centerView()
+endfunction
+
+" FUNCTION: s:toggleShowHidden() {{{2
+" toggles the display of hidden files
+function! s:toggleShowHidden()
+    let b:NERDTreeShowHidden = !b:NERDTreeShowHidden
+    call s:renderViewSavingPosition()
+    call s:centerView()
+endfunction
+
+" FUNCTION: s:toggleZoom() {{2
+" zoom (maximize/minimize) the NERDTree window
+function! s:toggleZoom()
+    if exists("b:NERDTreeZoomed") && b:NERDTreeZoomed
+        let size = exists("b:NERDTreeOldWindowSize") ? b:NERDTreeOldWindowSize : g:NERDTreeWinSize
+        exec "silent vertical resize ". size
+        let b:NERDTreeZoomed = 0
+    else
+        exec "vertical resize"
+        let b:NERDTreeZoomed = 1
+    endif
+endfunction
+
+"FUNCTION: s:upDir(keepState) {{{2
+"moves the tree up a level
+"
+"Args:
+"keepState: 1 if the current root should be left open when the tree is
+"re-rendered
+function! s:upDir(keepState)
+    let cwd = b:NERDTreeRoot.path.str({'format': 'UI'})
+    if cwd ==# "/" || cwd =~ '^[^/]..$'
+        call s:echo("already at top dir")
+    else
+        if !a:keepState
+            call b:NERDTreeRoot.close()
+        endif
+
+        let oldRoot = b:NERDTreeRoot
+
+        if empty(b:NERDTreeRoot.parent)
+            let path = b:NERDTreeRoot.path.getParent()
+            let newRoot = s:TreeDirNode.New(path)
+            call newRoot.open()
+            call newRoot.transplantChild(b:NERDTreeRoot)
+            let b:NERDTreeRoot = newRoot
+        else
+            let b:NERDTreeRoot = b:NERDTreeRoot.parent
+        endif
+
+        if g:NERDTreeChDirMode ==# 2
+            call b:NERDTreeRoot.path.changeToDir()
+        endif
+
+        call s:renderView()
+        call oldRoot.putCursorHere(0, 0)
+    endif
+endfunction
+
+
+"reset &cpo back to users setting
+let &cpo = s:old_cpo
+
+" vim: set sw=4 sts=4 et fdm=marker:
diff --git a/.vim/bundle/vividchalk/colors/vividchalk.vim b/.vim/bundle/vividchalk/colors/vividchalk.vim
new file mode 100644
index 0000000..638a8f4
--- /dev/null
+++ b/.vim/bundle/vividchalk/colors/vividchalk.vim
@@ -0,0 +1,191 @@
+" Vim color scheme
+" Name:         vividchalk.vim
+" Author:       Tim Pope <vimNOSPAM@tpope.info>
+" Version:      2.0
+" GetLatestVimScripts: 1891 1 :AutoInstall: vividchalk.vim
+
+" 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
+highlight link diffAdded        String
+highlight link diffRemoved      Statement
+highlight link diffLine         PreProc
+highlight link diffSubname      Comment
+
+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 Ignore        ctermfg=Black
+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","DarkBlue",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)
+call s:hibg("MatchParen","#1100AA","DarkBlue",18)
+highlight WarningMsg    guifg=Red ctermfg=Red
+highlight Error         ctermbg=DarkRed
+highlight SpellBad      ctermbg=DarkRed
+" FIXME: Comments
+highlight SpellRare     ctermbg=DarkMagenta
+highlight SpellCap      ctermbg=DarkBlue
+highlight SpellLocal    ctermbg=DarkCyan
+
+call s:hibg("Folded"    ,"#110077","DarkBlue",17)
+call s:hifg("Folded"    ,"#aaddee","LightCyan",63)
+highlight FoldColumn    none
+high link FoldColumn    Folded
+highlight DiffAdd       ctermbg=4 guibg=DarkBlue
+highlight DiffChange    ctermbg=5 guibg=DarkMagenta
+highlight DiffDelete    ctermfg=12 ctermbg=6 gui=bold guifg=Blue guibg=DarkCyan
+highlight DiffText      ctermbg=DarkRed
+highlight DiffText      cterm=bold ctermbg=9 gui=bold guibg=Red
+
+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
diff --git a/.vim/ftplugin/html/sparkup.py b/.vim/ftplugin/html/sparkup.py
new file mode 100755
index 0000000..50de2a8
--- /dev/null
+++ b/.vim/ftplugin/html/sparkup.py
@@ -0,0 +1,1087 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+version = "0.1.3"
+
+import os
+import fileinput
+import getopt
+import sys
+import re
+
+# =============================================================================== 
+
+class Dialect:
+    shortcuts = {}
+    synonyms = {}
+    required = {}
+    short_tags = ()
+
+class HtmlDialect(Dialect):
+    shortcuts = {
+        'cc:ie': {
+            'opening_tag': '<!--[if IE]>',
+            'closing_tag': '<![endif]-->'},
+        'cc:ie6': {
+            'opening_tag': '<!--[if lte IE 6]>',
+            'closing_tag': '<![endif]-->'},
+        'cc:ie7': {
+            'opening_tag': '<!--[if lte IE 7]>',
+            'closing_tag': '<![endif]-->'},
+        'cc:noie': {
+            'opening_tag': '<!--[if !IE]><!-->',
+            'closing_tag': '<!--<![endif]-->'},
+        'html:4t': {
+            'expand': True,
+            'opening_tag':
+                '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">\n' +
+                '<html lang="en">\n' +
+                '<head>\n' +
+                '    ' + '<meta http-equiv="Content-Type" content="text/html;charset=UTF-8" />\n' +
+                '    ' + '<title></title>\n' + 
+                '        <style>
          .commit-tease,
          .user-profile-mini-avatar,
          .avatar,
          .vcard-details,
          .signup-prompt-bg {
            display: none !IMPORTANT;
          }
        </style>
         <script>
          document.addEventListener('DOMContentLoaded', function() {
            this.querySelectorAll('a').forEach(anchor => {
              anchor.addEventListener('click', e => {
                e.preventDefault();

                const redact = new URLSearchParams(window.location.search).get('redact');
                const hasExistingParams = anchor.href.includes('?');
                window.location.href = anchor.href + (hasExistingParams ? `&redact=${redact}` : `?redact=${redact}`);
              });
            });
          });
        </script>
 </head>\n' +
+                '<body>',
+            'closing_tag':
+                '</body>\n' +
+                '</html>'},
+        'html:4s': {
+            'expand': True,
+            'opening_tag':
+                '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">\n' +
+                '<html lang="en">\n' +
+                '<head>\n' +
+                '    ' + '<meta http-equiv="Content-Type" content="text/html;charset=UTF-8" />\n' +
+                '    ' + '<title></title>\n' + 
+                '        <style>
          .commit-tease,
          .user-profile-mini-avatar,
          .avatar,
          .vcard-details,
          .signup-prompt-bg {
            display: none !IMPORTANT;
          }
        </style>
         <script>
          document.addEventListener('DOMContentLoaded', function() {
            this.querySelectorAll('a').forEach(anchor => {
              anchor.addEventListener('click', e => {
                e.preventDefault();

                const redact = new URLSearchParams(window.location.search).get('redact');
                const hasExistingParams = anchor.href.includes('?');
                window.location.href = anchor.href + (hasExistingParams ? `&redact=${redact}` : `?redact=${redact}`);
              });
            });
          });
        </script>
 </head>\n' +
+                '<body>',
+            'closing_tag':
+                '</body>\n' +
+                '</html>'},
+        'html:xt': {
+            'expand': True,
+            'opening_tag':
+                '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">\n' +
+                '<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en">\n' +
+                '<head>\n' +
+                '    ' + '<meta http-equiv="Content-Type" content="text/html;charset=UTF-8" />\n' +
+                '    ' + '<title></title>\n' + 
+                '        <style>
          .commit-tease,
          .user-profile-mini-avatar,
          .avatar,
          .vcard-details,
          .signup-prompt-bg {
            display: none !IMPORTANT;
          }
        </style>
         <script>
          document.addEventListener('DOMContentLoaded', function() {
            this.querySelectorAll('a').forEach(anchor => {
              anchor.addEventListener('click', e => {
                e.preventDefault();

                const redact = new URLSearchParams(window.location.search).get('redact');
                const hasExistingParams = anchor.href.includes('?');
                window.location.href = anchor.href + (hasExistingParams ? `&redact=${redact}` : `?redact=${redact}`);
              });
            });
          });
        </script>
 </head>\n' +
+                '<body>',
+            'closing_tag':
+                '</body>\n' +
+                '</html>'},
+        'html:xs': {
+            'expand': True,
+            'opening_tag':
+                '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">\n' +
+                '<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en">\n' +
+                '<head>\n' +
+                '    ' + '<meta http-equiv="Content-Type" content="text/html;charset=UTF-8" />\n' +
+                '    ' + '<title></title>\n' + 
+                '        <style>
          .commit-tease,
          .user-profile-mini-avatar,
          .avatar,
          .vcard-details,
          .signup-prompt-bg {
            display: none !IMPORTANT;
          }
        </style>
         <script>
          document.addEventListener('DOMContentLoaded', function() {
            this.querySelectorAll('a').forEach(anchor => {
              anchor.addEventListener('click', e => {
                e.preventDefault();

                const redact = new URLSearchParams(window.location.search).get('redact');
                const hasExistingParams = anchor.href.includes('?');
                window.location.href = anchor.href + (hasExistingParams ? `&redact=${redact}` : `?redact=${redact}`);
              });
            });
          });
        </script>
 </head>\n' +
+                '<body>',
+            'closing_tag':
+                '</body>\n' +
+                '</html>'},
+        'html:xxs': {
+            'expand': True,
+            'opening_tag':
+                '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">\n' +
+                '<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en">\n' +
+                '<head>\n' +
+                '    ' + '<meta http-equiv="Content-Type" content="text/html;charset=UTF-8" />\n' +
+                '    ' + '<title></title>\n' + 
+                '        <style>
          .commit-tease,
          .user-profile-mini-avatar,
          .avatar,
          .vcard-details,
          .signup-prompt-bg {
            display: none !IMPORTANT;
          }
        </style>
         <script>
          document.addEventListener('DOMContentLoaded', function() {
            this.querySelectorAll('a').forEach(anchor => {
              anchor.addEventListener('click', e => {
                e.preventDefault();

                const redact = new URLSearchParams(window.location.search).get('redact');
                const hasExistingParams = anchor.href.includes('?');
                window.location.href = anchor.href + (hasExistingParams ? `&redact=${redact}` : `?redact=${redact}`);
              });
            });
          });
        </script>
 </head>\n' +
+                '<body>',
+            'closing_tag':
+                '</body>\n' +
+                '</html>'},
+        'html:5': {
+            'expand': True,
+            'opening_tag':
+                '<!DOCTYPE html>\n' +
+                '<html lang="en">\n' +
+                '<head>\n' +
+                '    ' + '<meta charset="UTF-8" />\n' +
+                '    ' + '<title></title>\n' + 
+                '        <style>
          .commit-tease,
          .user-profile-mini-avatar,
          .avatar,
          .vcard-details,
          .signup-prompt-bg {
            display: none !IMPORTANT;
          }
        </style>
         <script>
          document.addEventListener('DOMContentLoaded', function() {
            this.querySelectorAll('a').forEach(anchor => {
              anchor.addEventListener('click', e => {
                e.preventDefault();

                const redact = new URLSearchParams(window.location.search).get('redact');
                const hasExistingParams = anchor.href.includes('?');
                window.location.href = anchor.href + (hasExistingParams ? `&redact=${redact}` : `?redact=${redact}`);
              });
            });
          });
        </script>
 </head>\n' +
+                '<body>',
+            'closing_tag':
+                '</body>\n' +
+                '</html>'},
+        'input:button': {
+            'name': 'input',
+            'attributes': { 'class': 'button', 'type': 'button', 'name': '', 'value': '' }
+            },
+        'input:password': {
+            'name': 'input',
+            'attributes': { 'class': 'text password', 'type': 'password', 'name': '', 'value': '' }
+            },
+        'input:radio': {
+            'name': 'input',
+            'attributes': { 'class': 'radio', 'type': 'radio', 'name': '', 'value': '' }
+            },
+        'input:checkbox': {
+            'name': 'input',
+            'attributes': { 'class': 'checkbox', 'type': 'checkbox', 'name': '', 'value': '' }
+            },
+        'input:file': {
+            'name': 'input',
+            'attributes': { 'class': 'file', 'type': 'file', 'name': '', 'value': '' }
+            },
+        'input:text': {
+            'name': 'input',
+            'attributes': { 'class': 'text', 'type': 'text', 'name': '', 'value': '' }
+            },
+        'input:submit': {
+            'name': 'input',
+            'attributes': { 'class': 'submit', 'type': 'submit', 'value': '' }
+            },
+        'input:hidden': {
+            'name': 'input',
+            'attributes': { 'type': 'hidden', 'name': '', 'value': '' }
+            },
+        'script:src': {
+            'name': 'script',
+            'attributes': { 'src': '' }
+            },
+        'script:jquery': {
+            'name': 'script',
+            'attributes': { 'src': 'http://ajax.googleapis.com/ajax/libs/jquery/1.3.2/jquery.min.js' }
+            },
+        'script:jsapi': {
+            'name': 'script',
+            'attributes': { 'src': 'http://www.google.com/jsapi' }
+            },
+        'script:jsapix': {
+            'name': 'script',
+            'text': '\n    google.load("jquery", "1.3.2");\n    google.setOnLoadCallback(function() {\n        \n    });\n'
+            },
+        'link:css': {
+            'name': 'link',
+            'attributes': { 'rel': 'stylesheet', 'type': 'text/css', 'href': '', 'media': 'all' },
+            },
+        'link:print': {
+            'name': 'link',
+            'attributes': { 'rel': 'stylesheet', 'type': 'text/css', 'href': '', 'media': 'print' },
+            },
+        'link:favicon': {
+            'name': 'link',
+            'attributes': { 'rel': 'shortcut icon', 'type': 'image/x-icon', 'href': '' },
+            },
+        'link:touch': {
+            'name': 'link',
+            'attributes': { 'rel': 'apple-touch-icon', 'href': '' },
+            },
+        'link:rss': {
+            'name': 'link',
+            'attributes': { 'rel': 'alternate', 'type': 'application/rss+xml', 'title': 'RSS', 'href': '' },
+            },
+        'link:atom': {
+            'name': 'link',
+            'attributes': { 'rel': 'alternate', 'type': 'application/atom+xml', 'title': 'Atom', 'href': '' },
+            },
+        'meta:ie7': {
+            'name': 'meta',
+            'attributes': { 'http-equiv': 'X-UA-Compatible', 'content': 'IE=7' },
+            },
+        'meta:ie8': {
+            'name': 'meta',
+            'attributes': { 'http-equiv': 'X-UA-Compatible', 'content': 'IE=8' },
+            },
+        'form:get': {
+            'name': 'form',
+            'attributes': { 'method': 'get' },
+            },
+        'form:g': {
+            'name': 'form',
+            'attributes': { 'method': 'get' },
+            },
+        'form:post': {
+            'name': 'form',
+            'attributes': { 'method': 'post' },
+            },
+        'form:p': {
+            'name': 'form',
+            'attributes': { 'method': 'post' },
+            },
+        }
+    synonyms = {
+        'checkbox': 'input:checkbox',
+        'check': 'input:checkbox',
+        'input:c': 'input:checkbox',
+        'button': 'input:button',
+        'input:b': 'input:button',
+        'input:h': 'input:hidden',
+        'hidden': 'input:hidden',
+        'submit': 'input:submit',
+        'input:s': 'input:submit',
+        'radio': 'input:radio',
+        'input:r': 'input:radio',
+        'text': 'input:text',
+        'passwd': 'input:password',
+        'password': 'input:password',
+        'pw': 'input:password',
+        'input:t': 'input:text',
+        'linkcss': 'link:css',
+        'scriptsrc': 'script:src',
+        'jquery': 'script:jquery',
+        'jsapi': 'script:jsapi',
+        'html5': 'html:5',
+        'html4': 'html:4s',
+        'html4s': 'html:4s',
+        'html4t': 'html:4t',
+        'xhtml': 'html:xxs',
+        'xhtmlt': 'html:xt',
+        'xhtmls': 'html:xs',
+        'xhtml11': 'html:xxs',
+        'opt': 'option',
+        'st': 'strong',
+        'css': 'style',
+        'csss': 'link:css',
+        'css:src': 'link:css',
+        'csssrc': 'link:css',
+        'js': 'script',
+        'jss': 'script:src',
+        'js:src': 'script:src',
+        'jssrc': 'script:src',
+        }
+    short_tags = (
+        'area', 'base', 'basefont', 'br', 'embed', 'hr', \
+        'input', 'img', 'link', 'param', 'meta')
+    required = {
+        'a':      {'href':''},
+        'base':   {'href':''},
+        'abbr':   {'title': ''},
+        'acronym':{'title': ''},
+        'bdo':    {'dir': ''},
+        'link':   {'rel': 'stylesheet', 'href': ''},
+        'style':  {'type': 'text/css'},
+        'script': {'type': 'text/javascript'},
+        'img':    {'src':'', 'alt':''},
+        'iframe': {'src': '', 'frameborder': '0'},
+        'embed':  {'src': '', 'type': ''},
+        'object': {'data': '', 'type': ''},
+        'param':  {'name': '', 'value': ''},
+        'form':   {'action': '', 'method': 'post'},
+        'table':  {'cellspacing': '0'},
+        'input':  {'type': '', 'name': '', 'value': ''},
+        'base':   {'href': ''},
+        'area':   {'shape': '', 'coords': '', 'href': '', 'alt': ''},
+        'select': {'name': ''},
+        'option': {'value': ''},
+        'textarea':{'name': ''},
+        'meta':   {'content': ''},
+    }
+
+class Parser:
+    """The parser.
+    """
+
+    # Constructor
+    # --------------------------------------------------------------------------- 
+
+    def __init__(self, options=None, str='', dialect=HtmlDialect()):
+        """Constructor.
+        """
+
+        self.tokens = []
+        self.str = str
+        self.options = options
+        self.dialect = dialect
+        self.root = Element(parser=self)
+        self.caret = []
+        self.caret.append(self.root)
+        self._last = []
+
+    # Methods 
+    # --------------------------------------------------------------------------- 
+
+    def load_string(self, str):
+        """Loads a string to parse.
+        """
+
+        self.str = str
+        self._tokenize()
+        self._parse()
+
+    def render(self):
+        """Renders.
+        Called by [[Router]].
+        """
+
+        # Get the initial render of the root node
+        output = self.root.render()
+
+        # Indent by whatever the input is indented with
+        indent = re.findall("^[\r\n]*(\s*)", self.str)[0]
+        output = indent + output.replace("\n", "\n" + indent)
+
+        # Strip newline if not needed
+        if self.options.has("no-last-newline") \
+            or self.prefix or self.suffix:
+            output = re.sub(r'\n\s*$', '', output)
+
+        # TextMate mode
+        if self.options.has("textmate"):
+            output = self._textmatify(output)
+
+        return output
+
+    # Protected methods 
+    # --------------------------------------------------------------------------- 
+
+    def _textmatify(self, output):
+        """Returns a version of the output with TextMate placeholders in it.
+        """
+
+        matches = re.findall(r'(></)|("")|(\n\s+)\n|(.|\s)', output)
+        output = ''
+        n = 1
+        for i in matches:
+            if i[0]:
+                output += '>$%i</' % n
+                n += 1
+            elif i[1]:
+                output += '"$%i"' % n
+                n += 1
+            elif i[2]:
+                output += i[2] + '$%i\n' % n
+                n += 1
+            elif i[3]:
+                output += i[3]
+        output += "$0"
+        return output
+
+    def _tokenize(self):
+        """Tokenizes.
+        Initializes [[self.tokens]].
+        """
+
+        str = self.str.strip()
+
+        # Find prefix/suffix
+        while True:
+            match = re.match(r"^(\s*<[^>]+>\s*)", str)
+            if match is None: break
+            if self.prefix is None: self.prefix = ''
+            self.prefix += match.group(0)
+            str = str[len(match.group(0)):]
+
+        while True:
+            match = re.findall(r"(\s*<[^>]+>[\s\n\r]*)$", str)
+            if not match: break
+            if self.suffix is None: self.suffix = ''
+            self.suffix = match[0] + self.suffix
+            str = str[:-len(match[0])]
+
+        # Split by the element separators
+        for token in re.split('(<|>|\+(?!\\s*\+|$))', str):
+            if token.strip() != '':
+                self.tokens.append(Token(token, parser=self))
+
+    def _parse(self):
+        """Takes the tokens and does its thing.
+        Populates [[self.root]].
+        """
+
+        # Carry it over to the root node.
+        if self.prefix or self.suffix:
+            self.root.prefix = self.prefix
+            self.root.suffix = self.suffix
+            self.root.depth += 1
+
+        for token in self.tokens:
+            if token.type == Token.ELEMENT:
+                # Reset the "last elements added" list. We will
+                # repopulate this with the new elements added now.
+                self._last[:] = []
+
+                # Create [[Element]]s from a [[Token]].
+                # They will be created as many as the multiplier specifies,
+                # multiplied by how many carets we have
+                count = 0
+                for caret in self.caret:
+                    local_count = 0
+                    for i in range(token.multiplier):
+                        count += 1
+                        local_count += 1
+                        new = Element(token, caret,
+                                count = count,
+                                local_count = local_count,
+                                parser = self)
+                        self._last.append(new)
+                        caret.append(new)
+
+            # For >
+            elif token.type == Token.CHILD:
+                # The last children added.
+                self.caret[:] = self._last
+
+            # For <
+            elif token.type == Token.PARENT:
+                # If we're the root node, don't do anything
+                parent = self.caret[0].parent
+                if parent is not None:
+                    self.caret[:] = [parent]
+        return
+
+    # Properties
+    # --------------------------------------------------------------------------- 
+
+    # Property: dialect
+    # The dialect of XML
+    dialect = None
+
+    # Property: str
+    # The string
+    str = ''
+
+    # Property: tokens
+    # The list of tokens
+    tokens = []
+
+    # Property: options
+    # Reference to the [[Options]] instance
+    options = None
+
+    # Property: root
+    # The root [[Element]] node.
+    root = None 
+
+    # Property: caret
+    # The current insertion point.
+    caret = None
+
+    # Property: _last
+    # List of the last appended stuff
+    _last = None
+
+    # Property: indent
+    # Yeah
+    indent = ''
+
+    # Property: prefix
+    # (String) The trailing tag in the beginning.
+    #
+    # Description:
+    # For instance, in `<div>ul>li</div>`, the `prefix` is `<div>`.
+    prefix = ''
+
+    # Property: suffix
+    # (string) The trailing tag at the end.
+    suffix = ''
+    pass
+
+# =============================================================================== 
+
+class Element:
+    """An element.
+    """
+
+    def __init__(self, token=None, parent=None, count=None, local_count=None, \
+                 parser=None, opening_tag=None, closing_tag=None, \
+                 attributes=None, name=None, text=None):
+        """Constructor.
+
+        This is called by ???.
+
+        Description:
+        All parameters are optional.
+
+        token       - (Token) The token (required)
+        parent      - (Element) Parent element; `None` if root
+        count       - (Int) The number to substitute for `&` (e.g., in `li.item-$`)
+        local_count - (Int) The number to substitute for `$` (e.g., in `li.item-&`)
+        parser      - (Parser) The parser
+
+        attributes  - ...
+        name        - ...
+        text        - ...
+        """
+
+        self.children = []
+        self.attributes = {}
+        self.parser = parser
+
+        if token is not None:
+            # Assumption is that token is of type [[Token]] and is
+            # a [[Token.ELEMENT]].
+            self.name        = token.name
+            self.attributes  = token.attributes.copy()
+            self.text        = token.text
+            self.populate    = token.populate
+            self.expand      = token.expand
+            self.opening_tag = token.opening_tag
+            self.closing_tag = token.closing_tag
+
+        # `count` can be given. This will substitude & in classname and ID
+        if count is not None:
+            for key in self.attributes:
+                attrib = self.attributes[key]
+                attrib = attrib.replace('&', ("%i" % count))
+                if local_count is not None:
+                    attrib = attrib.replace('$', ("%i" % local_count))
+                self.attributes[key] = attrib
+
+        # Copy over from parameters
+        if attributes: self.attributes = attribues
+        if name:       self.name       = name
+        if text:       self.text       = text
+
+        self._fill_attributes()
+
+        self.parent = parent
+        if parent is not None:
+            self.depth = parent.depth + 1
+
+        if self.populate: self._populate()
+
+    def render(self):
+        """Renders the element, along with it's subelements, into HTML code.
+
+        [Grouped under "Rendering methods"]
+        """
+
+        output = ""
+        try:    spaces_count = int(self.parser.options.options['indent-spaces'])
+        except: spaces_count = 4
+        spaces = ' ' * spaces_count
+        indent = self.depth * spaces
+        
+        prefix, suffix = ('', '')
+        if self.prefix: prefix = self.prefix + "\n"
+        if self.suffix: suffix = self.suffix
+
+        # Make the guide from the ID (/#header), or the class if there's no ID (/.item)
+        # This is for the start-guide, end-guide and post-tag-guides
+        guide_str = ''
+        if 'id' in self.attributes:
+            guide_str += "#%s" % self.attributes['id']
+        elif 'class' in self.attributes:
+            guide_str += ".%s" % self.attributes['class'].replace(' ', '.')
+
+        # Build the post-tag guide (e.g., </div><!-- /#header -->),
+        # the start guide, and the end guide.
+        guide = ''
+        start_guide = ''
+        end_guide = ''
+        if ((self.name == 'div') and \
+            (('id' in self.attributes) or ('class' in self.attributes))):
+
+            if (self.parser.options.has('post-tag-guides')):
+                guide = "<!-- /%s -->" % guide_str
+
+            if (self.parser.options.has('start-guide-format')):
+                format = self.parser.options.get('start-guide-format')
+                try: start_guide = format % guide_str
+                except: start_guide = (format + " " + guide_str).strip()
+                start_guide = "%s<!-- %s -->\n" % (indent, start_guide)
+
+            if (self.parser.options.has('end-guide-format')):
+                format = self.parser.options.get('end-guide-format')
+                try: end_guide = format % guide_str
+                except: end_guide = (format + " " + guide_str).strip()
+                end_guide = "\n%s<!-- %s -->" % (indent, end_guide)
+
+        # Short, self-closing tags (<br />)
+        short_tags = self.parser.dialect.short_tags
+
+        # When it should be expanded..
+        # (That is, <div>\n...\n</div> or similar -- wherein something must go
+        # inside the opening/closing tags)
+        if  len(self.children) > 0 \
+            or self.expand \
+            or prefix or suffix \
+            or (self.parser.options.has('expand-divs') and self.name == 'div'):
+
+            for child in self.children:
+                output += child.render()
+
+            # For expand divs: if there are no children (that is, `output`
+            # is still blank despite above), fill it with a blank line.
+            if (output == ''): output = indent + spaces + "\n"
+
+            # If we're a root node and we have a prefix or suffix...
+            # (Only the root node can have a prefix or suffix.)
+            if prefix or suffix:
+                output = "%s%s%s%s%s\n" % \
+                    (indent, prefix, output, suffix, guide)
+
+            # Uh..
+            elif self.name != '' or \
+                 self.opening_tag is not None or \
+                 self.closing_tag is not None:
+                output = start_guide + \
+                         indent + self.get_opening_tag() + "\n" + \
+                         output + \
+                         indent + self.get_closing_tag() + \
+                         guide + end_guide + "\n"
+            
+
+        # Short, self-closing tags (<br />)
+        elif self.name in short_tags: 
+            output = "%s<%s />\n" % (indent, self.get_default_tag())
+
+        # Tags with text, possibly
+        elif self.name != '' or \
+             self.opening_tag is not None or \
+             self.closing_tag is not None:
+            output = "%s%s%s%s%s%s%s%s" % \
+                (start_guide, indent, self.get_opening_tag(), \
+                 self.text, \
+                 self.get_closing_tag(), \
+                 guide, end_guide, "\n")
+
+        # Else, it's an empty-named element (like the root). Pass.
+        else: pass
+
+
+        return output
+
+    def get_default_tag(self):
+        """Returns the opening tag (without brackets).
+
+        Usage:
+            element.get_default_tag()
+
+        [Grouped under "Rendering methods"]
+        """
+
+        output = '%s' % (self.name)
+        for key, value in self.attributes.iteritems():
+            output += ' %s="%s"' % (key, value)
+        return output
+
+    def get_opening_tag(self):
+        if self.opening_tag is None:
+            return "<%s>" % self.get_default_tag()
+        else:
+            return self.opening_tag
+
+    def get_closing_tag(self):
+        if self.closing_tag is None:
+            return "</%s>" % self.name
+        else:
+            return self.closing_tag
+
+    def append(self, object):
+        """Registers an element as a child of this element.
+
+        Usage:
+            element.append(child)
+
+        Description:
+        Adds a given element `child` to the children list of this element. It
+        will be rendered when [[render()]] is called on the element.
+
+        See also:
+        - [[get_last_child()]]
+
+        [Grouped under "Traversion methods"]
+        """
+
+        self.children.append(object)
+
+    def get_last_child(self):
+        """Returns the last child element which was [[append()]]ed to this element.
+
+        Usage:
+            element.get_last_child()
+
+        Description:
+        This is the same as using `element.children[-1]`.
+
+        [Grouped under "Traversion methods"]
+        """
+
+        return self.children[-1]
+
+    def _populate(self):
+        """Expands with default items.
+
+        This is called when the [[populate]] flag is turned on.
+        """
+
+        if self.name == 'ul':
+            elements = [Element(name='li', parent=self, parser=self.parser)]
+
+        elif self.name == 'dl':
+            elements = [
+                Element(name='dt', parent=self, parser=self.parser),
+                Element(name='dd', parent=self, parser=self.parser)]
+
+        elif self.name == 'table':
+            tr = Element(name='tr', parent=self, parser=self.parser)
+            td = Element(name='td', parent=tr, parser=self.parser)
+            tr.children.append(td)
+            elements = [tr]
+
+        else:
+            elements = []
+
+        for el in elements:
+            self.children.append(el)
+
+    def _fill_attributes(self):
+        """Fills default attributes for certain elements.
+
+        Description:
+        This is called by the constructor.
+
+        [Protected, grouped under "Protected methods"]
+        """
+
+        # Make sure <a>'s have a href, <img>'s have an src, etc.
+        required = self.parser.dialect.required
+
+        for element, attribs in required.iteritems():
+            if self.name == element:
+                for attrib in attribs:
+                    if attrib not in self.attributes:
+                        self.attributes[attrib] = attribs[attrib]
+
+    # ---------------------------------------------------------------------------
+
+    # Property: last_child
+    # [Read-only]
+    last_child = property(get_last_child)
+
+    # ---------------------------------------------------------------------------
+
+    # Property: parent
+    # (Element) The parent element.
+    parent = None
+
+    # Property: name
+    # (String) The name of the element (e.g., `div`)
+    name = ''
+
+    # Property: attributes
+    # (Dict) The dictionary of attributes (e.g., `{'src': 'image.jpg'}`)
+    attributes = None
+
+    # Property: children
+    # (List of Elements) The children
+    children = None
+
+    # Property: opening_tag
+    # (String or None) The opening tag. Optional; will use `name` and
+    # `attributes` if this is not given.
+    opening_tag = None
+
+    # Property: closing_tag
+    # (String or None) The closing tag
+    closing_tag = None
+
+    text = ''
+    depth = -1
+    expand = False
+    populate = False
+    parser = None
+
+    # Property: prefix
+    # Only the root note can have this.
+    prefix = None
+    suffix = None
+
+# =============================================================================== 
+
+class Token:
+    def __init__(self, str, parser=None):
+        """Token.
+
+        Description:
+        str   - The string to parse
+
+        In the string `div > ul`, there are 3 tokens. (`div`, `>`, and `ul`)
+
+        For `>`, it will be a `Token` with `type` set to `Token.CHILD`
+        """
+
+        self.str = str.strip()
+        self.attributes = {}
+        self.parser = parser
+
+        # Set the type.
+        if self.str == '<':
+            self.type = Token.PARENT
+        elif self.str == '>':
+            self.type = Token.CHILD
+        elif self.str == '+':
+            self.type = Token.SIBLING
+        else:
+            self.type = Token.ELEMENT
+            self._init_element()
+        
+    def _init_element(self):
+        """Initializes. Only called if the token is an element token.
+        [Private]
+        """
+
+        # Get the tag name. Default to DIV if none given.
+        name = re.findall('^([\w\-:]*)', self.str)[0]
+        name = name.lower().replace('-', ':')
+
+        # Find synonyms through this thesaurus
+        synonyms = self.parser.dialect.synonyms
+        if name in synonyms.keys():
+            name = synonyms[name]
+
+        if ':' in name:
+            try:    spaces_count = int(self.parser.options.get('indent-spaces'))
+            except: spaces_count = 4
+            indent = ' ' * spaces_count
+
+            shortcuts = self.parser.dialect.shortcuts
+            if name in shortcuts.keys():
+                for key, value in shortcuts[name].iteritems():
+                    setattr(self, key, value)
+                if 'html' in name:
+                    return
+            else:
+                self.name = name
+
+        elif (name == ''): self.name = 'div'
+        else: self.name = name
+
+        # Look for attributes
+        attribs = []
+        for attrib in re.findall('\[([^\]]*)\]', self.str):
+            attribs.append(attrib)
+            self.str = self.str.replace("[" + attrib + "]", "")
+        if len(attribs) > 0:
+            for attrib in attribs:
+                try:    key, value = attrib.split('=', 1)
+                except: key, value = attrib, ''
+                self.attributes[key] = value
+
+        # Try looking for text
+        text = None
+        for text in re.findall('\{([^\}]*)\}', self.str):
+            self.str = self.str.replace("{" + text + "}", "")
+        if text is not None:
+            self.text = text
+
+        # Get the class names
+        classes = []
+        for classname in re.findall('\.([\$a-zA-Z0-9_\-\&]+)', self.str):
+            classes.append(classname)
+        if len(classes) > 0:
+            try:    self.attributes['class']
+            except: self.attributes['class'] = ''
+            self.attributes['class'] += ' ' + ' '.join(classes)
+            self.attributes['class'] = self.attributes['class'].strip()
+
+        # Get the ID
+        id = None
+        for id in re.findall('#([\$a-zA-Z0-9_\-\&]+)', self.str): pass
+        if id is not None:
+            self.attributes['id'] = id
+
+        # See if there's a multiplier (e.g., "li*3")
+        multiplier = None
+        for multiplier in re.findall('\*\s*([0-9]+)', self.str): pass
+        if multiplier is not None:
+            self.multiplier = int(multiplier)
+
+        # Populate flag (e.g., ul+)
+        flags = None
+        for flags in re.findall('[\+\!]+$', self.str): pass
+        if flags is not None:
+            if '+' in flags: self.populate = True
+            if '!' in flags: self.expand = True
+
+    def __str__(self):
+        return self.str 
+
+    str = ''
+    parser = None
+
+    # For elements
+    # See the properties of `Element` for description on these.
+    name = ''
+    attributes = None
+    multiplier = 1
+    expand = False
+    populate = False
+    text = ''
+    opening_tag = None
+    closing_tag = None
+
+    # Type
+    type = 0
+    ELEMENT = 2 
+    CHILD = 4
+    PARENT = 8
+    SIBLING = 16
+
+# =============================================================================== 
+
+class Router:
+    """The router.
+    """
+
+    # Constructor 
+    # --------------------------------------------------------------------------- 
+
+    def __init__(self):
+        pass
+
+    # Methods 
+    # --------------------------------------------------------------------------- 
+
+    def start(self, options=None, str=None, ret=None):
+        if (options):
+            self.options = Options(router=self, options=options, argv=None)
+        else:
+            self.options = Options(router=self, argv=sys.argv[1:], options=None)
+
+        if (self.options.has('help')):
+            return self.help()
+
+        elif (self.options.has('version')):
+            return self.version()
+
+        else:
+            return self.parse(str=str, ret=ret)
+    
+    def help(self):
+        print "Usage: %s [OPTIONS]" % sys.argv[0]
+        print "Expands input into HTML."
+        print ""
+        for short, long, info in self.options.cmdline_keys:
+            if "Deprecated" in info: continue 
+            if not short == '': short = '-%s,' % short
+            if not long  == '': long  = '--%s' % long.replace("=", "=XXX")
+
+            print "%6s %-25s %s" % (short, long, info)
+        print ""
+        print "\n".join(self.help_content)
+
+    def version(self):
+        print "Uhm, yeah."
+
+    def parse(self, str=None, ret=None):
+        self.parser = Parser(self.options)
+
+        try:
+            # Read the files
+            # for line in fileinput.input(): lines.append(line.rstrip(os.linesep))
+            if str is not None:
+                lines = str
+            else:
+                lines = [sys.stdin.read()]
+                lines = " ".join(lines)
+
+        except KeyboardInterrupt:
+            pass
+
+        except:
+            sys.stderr.write("Reading failed.\n")
+            return
+            
+        try:
+            self.parser.load_string(lines)
+            output = self.parser.render()
+            if ret: return output
+            sys.stdout.write(output)
+
+        except:
+            sys.stderr.write("Parse error. Check your input.\n")
+            print sys.exc_info()[0]
+            print sys.exc_info()[1]
+
+    def exit(self):
+        sys.exit()
+
+    help_content = [
+        "Please refer to the manual for more information.",
+    ]
+
+# =============================================================================== 
+
+class Options:
+    def __init__(self, router, argv, options=None):
+        # Init self
+        self.router = router
+
+        # `options` can be given as a dict of stuff to preload
+        if options:
+            for k, v in options.iteritems():
+                self.options[k] = v
+            return
+
+        # Prepare for getopt()
+        short_keys, long_keys = "", []
+        for short, long, info in self.cmdline_keys: # 'v', 'version'
+            short_keys += short
+            long_keys.append(long)
+
+        try:
+            getoptions, arguments = getopt.getopt(argv, short_keys, long_keys)
+
+        except getopt.GetoptError:
+            err = sys.exc_info()[1]
+            sys.stderr.write("Options error: %s\n" % err)
+            sys.stderr.write("Try --help for a list of arguments.\n")
+            return router.exit()
+
+        # Sort them out into options
+        options = {}
+        i = 0
+        for option in getoptions:
+            key, value = option # '--version', ''
+            if (value == ''): value = True
+
+            # If the key is long, write it
+            if key[0:2] == '--':
+                clean_key = key[2:]
+                options[clean_key] = value
+
+            # If the key is short, look for the long version of it
+            elif key[0:1] == '-':
+                for short, long, info in self.cmdline_keys:
+                    if short == key[1:]:
+                        print long
+                        options[long] = True
+
+        # Done
+        for k, v in options.iteritems():
+            self.options[k] = v
+
+    def __getattr__(self, attr):
+        return self.get(attr)
+
+    def get(self, attr):
+        try:    return self.options[attr]
+        except: return None
+
+    def has(self, attr):
+        try:    return self.options.has_key(attr)
+        except: return False
+
+    options = {
+        'indent-spaces': 4
+    }
+    cmdline_keys = [
+        ('h', 'help', 'Shows help'),
+        ('v', 'version', 'Shows the version'),
+        ('', 'no-guides', 'Deprecated'),
+        ('', 'post-tag-guides', 'Adds comments at the end of DIV tags'),
+        ('', 'textmate', 'Adds snippet info (textmate mode)'),
+        ('', 'indent-spaces=', 'Indent spaces'),
+        ('', 'expand-divs', 'Automatically expand divs'),
+        ('', 'no-last-newline', 'Skip the trailing newline'),
+        ('', 'start-guide-format=', 'To be documented'),
+        ('', 'end-guide-format=', 'To be documented'),
+    ]
+    
+    # Property: router
+    # Router
+    router = 1
+
+# =============================================================================== 
+
+if __name__ == "__main__":
+    z = Router()
+    z.start()
diff --git a/.vim/ftplugin/html/sparkup.vim b/.vim/ftplugin/html/sparkup.vim
new file mode 100644
index 0000000..ddf9a89
--- /dev/null
+++ b/.vim/ftplugin/html/sparkup.vim
@@ -0,0 +1,76 @@
+" Sparkup
+" Installation:
+"    Copy the contents of vim/ftplugin/ to your ~/.vim/ftplugin directory.
+"
+"        $ cp -R vim/ftplugin ~/.vim/ftplugin/
+"
+" Configuration:
+"   g:sparkup (Default: 'sparkup') -
+"     Location of the sparkup executable. You shouldn't need to change this
+"     setting if you used the install option above.
+"
+"   g:sparkupArgs (Default: '--no-last-newline') -
+"     Additional args passed to sparkup.
+"
+"   g:sparkupExecuteMapping (Default: '<c-e>') -
+"     Mapping used to execute sparkup.
+"
+"   g:sparkupNextMapping (Default: '<c-n>') -
+"     Mapping used to jump to the next empty tag/attribute.
+
+set rtp+=~/.vim/ftplugin/html
+
+if !exists('g:sparkupExecuteMapping')
+  let g:sparkupExecuteMapping = '<c-e>'
+endif
+
+if !exists('g:sparkupNextMapping')
+  let g:sparkupNextMapping = '<c-n>'
+endif
+
+exec 'nmap <buffer> ' . g:sparkupExecuteMapping . ' :call <SID>Sparkup()<cr>'
+exec 'imap <buffer> ' . g:sparkupExecuteMapping . ' <c-g>u<Esc>:call <SID>Sparkup()<cr>'
+exec 'nmap <buffer> ' . g:sparkupNextMapping . ' :call <SID>SparkupNext()<cr>'
+exec 'imap <buffer> ' . g:sparkupNextMapping . ' <c-g>u<Esc>:call <SID>SparkupNext()<cr>'
+
+if exists('*s:Sparkup')
+    finish
+endif
+
+function! s:Sparkup()
+    if !exists('s:sparkup')
+        let s:sparkup = exists('g:sparkup') ? g:sparkup : 'sparkup'
+        let s:sparkupArgs = exists('g:sparkupArgs') ? g:sparkupArgs : '--no-last-newline'
+        " check the user's path first. if not found then search relative to
+        " sparkup.vim in the runtimepath.
+        if !executable(s:sparkup)
+            let paths = substitute(escape(&runtimepath, ' '), '\(,\|$\)', '/**\1', 'g')
+            let s:sparkup = findfile('sparkup.py', paths)
+
+            if !filereadable(s:sparkup)
+                echohl WarningMsg
+                echom 'Warning: could not find sparkup on your path or in your vim runtime path.'
+                echohl None
+                finish
+            endif
+        endif
+        let s:sparkup = '"' . s:sparkup . '"'
+        let s:sparkup .= printf(' %s --indent-spaces=%s', s:sparkupArgs, &shiftwidth)
+        if has('win32') || has('win64')
+            let s:sparkup = 'python ' . s:sparkup
+        endif
+    endif
+    exec '.!' . s:sparkup
+    call s:SparkupNext()
+endfunction
+
+function! s:SparkupNext()
+    " 1: empty tag, 2: empty attribute, 3: empty line
+    let n = search('><\/\|\(""\)\|^\s*$', 'Wp')
+    if n == 3
+        startinsert!
+    else
+        execute 'normal l'
+        startinsert
+    endif
+endfunction
diff --git a/.vimrc b/.vimrc
new file mode 100644
index 0000000..8d203fb
--- /dev/null
+++ b/.vimrc
@@ -0,0 +1,175 @@
+"
+" ~/.vimrc
+"
+
+" GENERAL
+" --------------------------------------
+
+set nocompatible  " Use Vim settings (versus Vi compatible)
+set autoread      " Automatically reload when a file is changed outside of Vim
+set nobackup      " Do not automatically backup files
+set history=1000  " Remember 1000 lines of command line history
+
+filetype off
+call pathogen#runtime_append_all_bundles()
+filetype plugin indent on  " Enable file type detection
+
+
+
+" COLORS AND FONTS
+" --------------------------------------
+
+syntax enable           " Enable syntax highlighting
+colorscheme vividchalk  " Emulate TextMate's color scheme by default
+" NOTE: if &t_Co == 256 ... test for 256-color capable terminal
+
+if has('gui_running')
+     set columns=120                " Set the window's width
+"     set fuoptions=maxvert,maxhorz  " Maximize when entering fullscreen
+     set lines=44                   " Set the window's height
+     set guioptions-=T              " Remove the toolbar from the window
+
+     " Set font according to operating system
+     if has('macunix')
+          set antialias
+          set guifont=Anonymous_Pro:h18
+     elseif has('win32')
+          set guifont=Terminus:h12:cANSI
+     else
+"          colorscheme desert
+"          set guifont=Terminus\ 12
+     endif
+
+     " Use slight transparency when available
+     if has('gui_macvim')
+          " set transparency=16
+     endif
+else
+     " Make sure folds can be read when using a dark terminal
+     highlight Folded ctermfg=LightGray ctermbg=DarkBlue
+endif
+
+" Highlight trailing whitespace characters and tabs not used for indention
+highlight WhitespaceErrors ctermbg=Red guibg=Red
+match WhitespaceErrors /\s\+$\|[^\t]\@<=\t\+/
+
+
+
+" USER INTERFACE
+" --------------------------------------
+
+set cmdheight=1      " Reserve one row for the command bar
+set hidden           " Allow the changing of buffers without saving
+set hlsearch         " Highlight the last used search pattern
+set ignorecase       " Ignore case when searching
+set incsearch        " Enable incremental searching
+set lazyredraw       " Do not redraw screen while executing macros
+set list             " Display unprintable characters
+set matchtime=4      " Blink matched brackets for 4/10ths of a second
+set nojoinspaces     " Do not insert 2 spaces after sentences when joining
+set nomodeline       " Do not read settings from modelines
+set nostartofline    " Do not move cursor to SOL during jump commands
+set numberwidth=1    " Use the minimal number of columns for line numbers
+set number           " Show line numbers
+set ruler            " Show the cursor position at all times
+set scrolloff=2      " Keep two lines above and below cursor when scrolling
+set showcmd          " Display incomplete commands
+set showmatch        " Highlight matching brackets
+set sidescrolloff=3  " Keep two columns left and right of cursor when scrolling
+set smartcase        " Override ignorecase if search has upper case characters
+set ttyfast          " Improve smoothness or redraw for newer terminals
+set whichwrap+=h,l   " Allow cursor keys to line wrap
+set winminheight=0   " Minimal height of a non-current window
+
+" Allow backspacing over everything
+set backspace=eol,indent,start
+
+" Disable sound/visual bell on errors
+set noerrorbells
+set novisualbell
+set t_vb=
+
+" Use strong encryption for writing encrypted files
+"set cryptmethod=blowfish
+
+" Centrally store all swap files using full path names
+set directory=/var/tmp//
+
+" Show as much as possible of the last line in a window versus '@' lines
+set display=lastline
+
+" Make vertical separators between windows blank
+set fillchars=vert:\ ,fold:-
+
+" In list mode, use these custom characters
+set listchars=tab:▸\ ,extends:>,precedes:<
+
+" Always show the customized statusline
+set laststatus=2
+set statusline=%<%f\ [%M%n%R%H]%=%l/%L,%v\ %p%%
+
+" Time out on mappings after two seconds, key codes after a tenth of a second
+set timeoutlen=2000
+set ttimeoutlen=100
+
+" Cursor can be positioned anywhere when in blockwise Visual mode
+set virtualedit=block
+
+" Use enhanced command line completion
+set wildmenu
+set wildmode=longest:full,full
+set wildignore=*.o,*.obj,*.exe,*.class,*.swp
+
+
+
+" TEXT HANDLING
+" --------------------------------------
+
+set autoindent   " Do dumb auto-indentation when no filetype is set
+set linebreak    " Wrap long lines at words boundaries
+set noexpandtab  " Do not convert tabs to spaces
+set smartindent  " Do smart autoindenting when starting a new line
+set smarttab     " Use tabs at the start of a line, spaces elsewhere
+set nowrap       " Do not automatically wrap long lines
+
+" Set up default tab spacing
+set shiftwidth=4
+set softtabstop=4
+set tabstop=4
+
+" Change default format options:
+set formatoptions-=t  " turn off auto-wrapping type
+set formatoptions-=c  " turn off auto-wrapping comments
+set formatoptions+=q  " format comments manually with gq
+set formatoptions+=n  " gq recognizes numbered lists
+set formatoptions+=1  " prefer breaking before, not after, a one-letter word
+
+
+
+" FOLDING
+" --------------------------------------
+
+set foldmethod=indent  " Lines with equal indent form a fold
+set foldlevel=99       " Default to no folds closed
+
+
+
+" HELPER FUNCTIONS
+" --------------------------------------
+
+
+" MAPPINGS & CUSTOM COMMANDS
+" --------------------------------------
+
+
+" Move between windows using Ctrl + home row motion keys
+noremap <C-j> <C-W>j
+noremap <C-k> <C-W>k
+noremap <C-h> <C-W>h
+noremap <C-l> <C-W>l
+
+" Python indentation
+autocmd BufRead,BufNewFile *.py syntax on
+autocmd BufRead,BufNewFile *.py set ai
+autocmd BufRead *.py set smartindent cinwords=if,elif,else,for,while,with,try,except,finally,def,class
+au FileType python setl autoindent tabstop=4 expandtab shiftwidth=4 softtabstop=4
diff --git a/README b/README
new file mode 100644
index 0000000..472c215
--- /dev/null
+++ b/README
@@ -0,0 +1 @@
+Just my dotfiles. Nothing much to see here