David Blume commited on 2020-07-08 11:39:03
Showing 8 changed files, with 4 additions and 6309 deletions.
| ... | ... |
@@ -1,104 +0,0 @@ |
| 1 |
-The NERD Tree |
|
| 2 |
-============= |
|
| 3 |
- |
|
| 4 |
-Intro |
|
| 5 |
------ |
|
| 6 |
- |
|
| 7 |
-The NERD tree allows you to explore your filesystem and to open files and |
|
| 8 |
-directories. It presents the filesystem to you in the form of a tree which you |
|
| 9 |
-manipulate with the keyboard and/or mouse. It also allows you to perform |
|
| 10 |
-simple filesystem operations. |
|
| 11 |
- |
|
| 12 |
-The following features and functionality are provided by the NERD tree: |
|
| 13 |
- |
|
| 14 |
- * Files and directories are displayed in a hierarchical tree structure |
|
| 15 |
- * Different highlighting is provided for the following types of nodes: |
|
| 16 |
- * files |
|
| 17 |
- * directories |
|
| 18 |
- * sym-links |
|
| 19 |
- * windows .lnk files |
|
| 20 |
- * read-only files |
|
| 21 |
- * executable files |
|
| 22 |
- * Many (customisable) mappings are provided to manipulate the tree: |
|
| 23 |
- * Mappings to open/close/explore directory nodes |
|
| 24 |
- * Mappings to open files in new/existing windows/tabs |
|
| 25 |
- * Mappings to change the current root of the tree |
|
| 26 |
- * Mappings to navigate around the tree |
|
| 27 |
- * ... |
|
| 28 |
- * Directories and files can be bookmarked. |
|
| 29 |
- * Most NERD tree navigation can also be done with the mouse |
|
| 30 |
- * Filtering of tree content (can be toggled at runtime) |
|
| 31 |
- * custom file filters to prevent e.g. vim backup files being displayed |
|
| 32 |
- * optional displaying of hidden files (. files) |
|
| 33 |
- * files can be "turned off" so that only directories are displayed |
|
| 34 |
- * The position and size of the NERD tree window can be customised |
|
| 35 |
- * The order in which the nodes in the tree are listed can be customised. |
|
| 36 |
- * A model of your filesystem is created/maintained as you explore it. This |
|
| 37 |
- has several advantages: |
|
| 38 |
- * All filesystem information is cached and is only re-read on demand |
|
| 39 |
- * If you revisit a part of the tree that you left earlier in your |
|
| 40 |
- session, the directory nodes will be opened/closed as you left them |
|
| 41 |
- * The script remembers the cursor position and window position in the NERD |
|
| 42 |
- tree so you can toggle it off (or just close the tree window) and then |
|
| 43 |
- reopen it (with NERDTreeToggle) the NERD tree window will appear exactly |
|
| 44 |
- as you left it |
|
| 45 |
- * You can have a separate NERD tree for each tab, share trees across tabs, |
|
| 46 |
- or a mix of both. |
|
| 47 |
- * By default the script overrides the default file browser (netw), so if |
|
| 48 |
- you :edit a directory a (slighly modified) NERD tree will appear in the |
|
| 49 |
- current window |
|
| 50 |
- * A programmable menu system is provided (simulates right clicking on a node) |
|
| 51 |
- * one default menu plugin is provided to perform basic filesytem |
|
| 52 |
- operations (create/delete/move/copy files/directories) |
|
| 53 |
- * There's an API for adding your own keymappings |
|
| 54 |
- |
|
| 55 |
-Installation |
|
| 56 |
------------- |
|
| 57 |
- |
|
| 58 |
-[pathogen.vim](https://github.com/tpope/vim-pathogen) is the recommended way to install nerdtree. |
|
| 59 |
- |
|
| 60 |
- cd ~/.vim/bundle |
|
| 61 |
- git clone https://github.com/scrooloose/nerdtree.git |
|
| 62 |
- |
|
| 63 |
-Then reload vim, run `:helptags`, and check out `:help NERD_tree.txt`. |
|
| 64 |
- |
|
| 65 |
- |
|
| 66 |
-Faq |
|
| 67 |
---- |
|
| 68 |
- |
|
| 69 |
-__Q. Can I have the nerdtree on every tab automatically?__ |
|
| 70 |
- |
|
| 71 |
-A. Nope. If this is something you want then chances are you aren't using tabs |
|
| 72 |
- and buffers as they were intended to be used. Read this |
|
| 73 |
- http://stackoverflow.com/questions/102384/using-vims-tabs-like-buffers |
|
| 74 |
- |
|
| 75 |
- If you are interested in this behaviour then consider [vim-nerdtree-tabs](https://github.com/jistr/vim-nerdtree-tabs) |
|
| 76 |
- |
|
| 77 |
-__Q. How can I open a NERDTree automatically when vim starts up?__ |
|
| 78 |
- |
|
| 79 |
-A. Stick this in your vimrc: `autocmd vimenter * NERDTree` |
|
| 80 |
- |
|
| 81 |
-__Q. How can I open a NERDTree automatically when vim starts up if no files were specified?__ |
|
| 82 |
- |
|
| 83 |
-A. Stick this in your vimrc `autocmd vimenter * if !argc() | NERDTree | endif` |
|
| 84 |
- |
|
| 85 |
-__Q. How can I close vim if the only window left open is a NERDTree?__ |
|
| 86 |
- |
|
| 87 |
-A. Stick this in your vimrc: |
|
| 88 |
- |
|
| 89 |
- `autocmd bufenter * if (winnr("$") == 1 && exists("b:NERDTreeType") && b:NERDTreeType == "primary") | q | endif`
|
|
| 90 |
- |
|
| 91 |
- |
|
| 92 |
-Changelog |
|
| 93 |
---------- |
|
| 94 |
- |
|
| 95 |
-4.2.0 (2011-12-28) |
|
| 96 |
- |
|
| 97 |
- * Add NERDTreeDirArrows option to make the UI use pretty arrow chars instead of the old +~| chars to define the tree structure (sickill) |
|
| 98 |
- * shift the syntax highlighting out into its own syntax file (gnap) * add some mac specific options to the filesystem menu - for macvim only (andersonfreitas) |
|
| 99 |
- * Add NERDTreeMinimalUI option to remove some non functional parts of the nerdtree ui (camthompson) |
|
| 100 |
- * tweak the behaviour of :NERDTreeFind - see :help :NERDTreeFind for the new behaviour (benjamingeiger) |
|
| 101 |
- * if no name is given to :Bookmark, make it default to the name of the target file/dir (minyoung) |
|
| 102 |
- * use 'file' completion when doing copying, create, and move operations (EvanDotPro) |
|
| 103 |
- * lots of misc bug fixes (paddyoloughlin, sdewald, camthompson, Vitaly Bogdanov, AndrewRadev, mathias, scottstvnsn, kml, wycats, me RAWR!) |
|
| 104 |
- |
| ... | ... |
@@ -1,1362 +0,0 @@ |
| 1 |
-*NERD_tree.txt* A tree explorer plugin that owns your momma! |
|
| 2 |
- |
|
| 3 |
- |
|
| 4 |
- |
|
| 5 |
- omg its ... ~ |
|
| 6 |
- |
|
| 7 |
- ________ ________ _ ____________ ____ __________ ____________~ |
|
| 8 |
- /_ __/ / / / ____/ / | / / ____/ __ \/ __ \ /_ __/ __ \/ ____/ ____/~ |
|
| 9 |
- / / / /_/ / __/ / |/ / __/ / /_/ / / / / / / / /_/ / __/ / __/ ~ |
|
| 10 |
- / / / __ / /___ / /| / /___/ _, _/ /_/ / / / / _, _/ /___/ /___ ~ |
|
| 11 |
- /_/ /_/ /_/_____/ /_/ |_/_____/_/ |_/_____/ /_/ /_/ |_/_____/_____/ ~ |
|
| 12 |
- |
|
| 13 |
- |
|
| 14 |
- Reference Manual~ |
|
| 15 |
- |
|
| 16 |
- |
|
| 17 |
- |
|
| 18 |
- |
|
| 19 |
-============================================================================== |
|
| 20 |
-CONTENTS *NERDTree-contents* |
|
| 21 |
- |
|
| 22 |
- 1.Intro...................................|NERDTree| |
|
| 23 |
- 2.Functionality provided..................|NERDTreeFunctionality| |
|
| 24 |
- 2.1.Global commands...................|NERDTreeGlobalCommands| |
|
| 25 |
- 2.2.Bookmarks.........................|NERDTreeBookmarks| |
|
| 26 |
- 2.2.1.The bookmark table..........|NERDTreeBookmarkTable| |
|
| 27 |
- 2.2.2.Bookmark commands...........|NERDTreeBookmarkCommands| |
|
| 28 |
- 2.2.3.Invalid bookmarks...........|NERDTreeInvalidBookmarks| |
|
| 29 |
- 2.3.NERD tree mappings................|NERDTreeMappings| |
|
| 30 |
- 2.4.The NERD tree menu................|NERDTreeMenu| |
|
| 31 |
- 3.Options.................................|NERDTreeOptions| |
|
| 32 |
- 3.1.Option summary....................|NERDTreeOptionSummary| |
|
| 33 |
- 3.2.Option details....................|NERDTreeOptionDetails| |
|
| 34 |
- 4.The NERD tree API.......................|NERDTreeAPI| |
|
| 35 |
- 4.1.Key map API.......................|NERDTreeKeymapAPI| |
|
| 36 |
- 4.2.Menu API..........................|NERDTreeMenuAPI| |
|
| 37 |
- 5.About...................................|NERDTreeAbout| |
|
| 38 |
- 6.Changelog...............................|NERDTreeChangelog| |
|
| 39 |
- 7.Credits.................................|NERDTreeCredits| |
|
| 40 |
- 8.License.................................|NERDTreeLicense| |
|
| 41 |
- |
|
| 42 |
-============================================================================== |
|
| 43 |
-1. Intro *NERDTree* |
|
| 44 |
- |
|
| 45 |
-What is this "NERD tree"?? |
|
| 46 |
- |
|
| 47 |
-The NERD tree allows you to explore your filesystem and to open files and |
|
| 48 |
-directories. It presents the filesystem to you in the form of a tree which you |
|
| 49 |
-manipulate with the keyboard and/or mouse. It also allows you to perform |
|
| 50 |
-simple filesystem operations. |
|
| 51 |
- |
|
| 52 |
-The following features and functionality are provided by the NERD tree: |
|
| 53 |
- * Files and directories are displayed in a hierarchical tree structure |
|
| 54 |
- * Different highlighting is provided for the following types of nodes: |
|
| 55 |
- * files |
|
| 56 |
- * directories |
|
| 57 |
- * sym-links |
|
| 58 |
- * windows .lnk files |
|
| 59 |
- * read-only files |
|
| 60 |
- * executable files |
|
| 61 |
- * Many (customisable) mappings are provided to manipulate the tree: |
|
| 62 |
- * Mappings to open/close/explore directory nodes |
|
| 63 |
- * Mappings to open files in new/existing windows/tabs |
|
| 64 |
- * Mappings to change the current root of the tree |
|
| 65 |
- * Mappings to navigate around the tree |
|
| 66 |
- * ... |
|
| 67 |
- * Directories and files can be bookmarked. |
|
| 68 |
- * Most NERD tree navigation can also be done with the mouse |
|
| 69 |
- * Filtering of tree content (can be toggled at runtime) |
|
| 70 |
- * custom file filters to prevent e.g. vim backup files being displayed |
|
| 71 |
- * optional displaying of hidden files (. files) |
|
| 72 |
- * files can be "turned off" so that only directories are displayed |
|
| 73 |
- * The position and size of the NERD tree window can be customised |
|
| 74 |
- * The order in which the nodes in the tree are listed can be customised. |
|
| 75 |
- * A model of your filesystem is created/maintained as you explore it. This |
|
| 76 |
- has several advantages: |
|
| 77 |
- * All filesystem information is cached and is only re-read on demand |
|
| 78 |
- * If you revisit a part of the tree that you left earlier in your |
|
| 79 |
- session, the directory nodes will be opened/closed as you left them |
|
| 80 |
- * The script remembers the cursor position and window position in the NERD |
|
| 81 |
- tree so you can toggle it off (or just close the tree window) and then |
|
| 82 |
- reopen it (with NERDTreeToggle) the NERD tree window will appear exactly |
|
| 83 |
- as you left it |
|
| 84 |
- * You can have a separate NERD tree for each tab, share trees across tabs, |
|
| 85 |
- or a mix of both. |
|
| 86 |
- * By default the script overrides the default file browser (netw), so if |
|
| 87 |
- you :edit a directory a (slighly modified) NERD tree will appear in the |
|
| 88 |
- current window |
|
| 89 |
- * A programmable menu system is provided (simulates right clicking on a |
|
| 90 |
- node) |
|
| 91 |
- * one default menu plugin is provided to perform basic filesytem |
|
| 92 |
- operations (create/delete/move/copy files/directories) |
|
| 93 |
- * There's an API for adding your own keymappings |
|
| 94 |
- |
|
| 95 |
- |
|
| 96 |
-============================================================================== |
|
| 97 |
-2. Functionality provided *NERDTreeFunctionality* |
|
| 98 |
- |
|
| 99 |
------------------------------------------------------------------------------- |
|
| 100 |
-2.1. Global Commands *NERDTreeGlobalCommands* |
|
| 101 |
- |
|
| 102 |
-:NERDTree [<start-directory> | <bookmark>] *:NERDTree* |
|
| 103 |
- Opens a fresh NERD tree. The root of the tree depends on the argument |
|
| 104 |
- given. There are 3 cases: If no argument is given, the current directory |
|
| 105 |
- will be used. If a directory is given, that will be used. If a bookmark |
|
| 106 |
- name is given, the corresponding directory will be used. For example: > |
|
| 107 |
- :NERDTree /home/marty/vim7/src |
|
| 108 |
- :NERDTree foo (foo is the name of a bookmark) |
|
| 109 |
-< |
|
| 110 |
-:NERDTreeFromBookmark <bookmark> *:NERDTreeFromBookmark* |
|
| 111 |
- Opens a fresh NERD tree with the root initialized to the dir for |
|
| 112 |
- <bookmark>. This only reason to use this command over :NERDTree is for |
|
| 113 |
- the completion (which is for bookmarks rather than directories). |
|
| 114 |
- |
|
| 115 |
-:NERDTreeToggle [<start-directory> | <bookmark>] *:NERDTreeToggle* |
|
| 116 |
- If a NERD tree already exists for this tab, it is reopened and rendered |
|
| 117 |
- again. If no NERD tree exists for this tab then this command acts the |
|
| 118 |
- same as the |:NERDTree| command. |
|
| 119 |
- |
|
| 120 |
-:NERDTreeMirror *:NERDTreeMirror* |
|
| 121 |
- Shares an existing NERD tree, from another tab, in the current tab. |
|
| 122 |
- Changes made to one tree are reflected in both as they are actually the |
|
| 123 |
- same buffer. |
|
| 124 |
- |
|
| 125 |
- If only one other NERD tree exists, that tree is automatically mirrored. If |
|
| 126 |
- more than one exists, the script will ask which tree to mirror. |
|
| 127 |
- |
|
| 128 |
-:NERDTreeClose *:NERDTreeClose* |
|
| 129 |
- Close the NERD tree in this tab. |
|
| 130 |
- |
|
| 131 |
-:NERDTreeFind *:NERDTreeFind* |
|
| 132 |
- Find the current file in the tree. |
|
| 133 |
- |
|
| 134 |
- If not tree exists and the current file is under vim's CWD, then init a |
|
| 135 |
- tree at the CWD and reveal the file. Otherwise init a tree in the current |
|
| 136 |
- file's directory. |
|
| 137 |
- |
|
| 138 |
- In any case, the current file is revealed and the cursor is placed on it. |
|
| 139 |
- |
|
| 140 |
-:NERDTreeCWD *:NERDTreeCWD* |
|
| 141 |
- Change tree root to current directory. If no NERD tree exists for this |
|
| 142 |
- tab, a new tree will be opened. |
|
| 143 |
- |
|
| 144 |
------------------------------------------------------------------------------- |
|
| 145 |
-2.2. Bookmarks *NERDTreeBookmarks* |
|
| 146 |
- |
|
| 147 |
-Bookmarks in the NERD tree are a way to tag files or directories of interest. |
|
| 148 |
-For example, you could use bookmarks to tag all of your project directories. |
|
| 149 |
- |
|
| 150 |
------------------------------------------------------------------------------- |
|
| 151 |
-2.2.1. The Bookmark Table *NERDTreeBookmarkTable* |
|
| 152 |
- |
|
| 153 |
-If the bookmark table is active (see |NERDTree-B| and |
|
| 154 |
-|'NERDTreeShowBookmarks'|), it will be rendered above the tree. You can double |
|
| 155 |
-click bookmarks or use the |NERDTree-o| mapping to activate them. See also, |
|
| 156 |
-|NERDTree-t| and |NERDTree-T| |
|
| 157 |
- |
|
| 158 |
------------------------------------------------------------------------------- |
|
| 159 |
-2.2.2. Bookmark commands *NERDTreeBookmarkCommands* |
|
| 160 |
- |
|
| 161 |
-Note that the following commands are only available in the NERD tree buffer. |
|
| 162 |
- |
|
| 163 |
-:Bookmark <name> |
|
| 164 |
- Bookmark the current node as <name>. If there is already a <name> |
|
| 165 |
- bookmark, it is overwritten. <name> must not contain spaces. |
|
| 166 |
- If <name> is not provided, it defaults to the file or directory name. |
|
| 167 |
- For directories, a trailing slash is present. |
|
| 168 |
- |
|
| 169 |
-:BookmarkToRoot <bookmark> |
|
| 170 |
- Make the directory corresponding to <bookmark> the new root. If a treenode |
|
| 171 |
- corresponding to <bookmark> is already cached somewhere in the tree then |
|
| 172 |
- the current tree will be used, otherwise a fresh tree will be opened. |
|
| 173 |
- Note that if <bookmark> points to a file then its parent will be used |
|
| 174 |
- instead. |
|
| 175 |
- |
|
| 176 |
-:RevealBookmark <bookmark> |
|
| 177 |
- If the node is cached under the current root then it will be revealed |
|
| 178 |
- (i.e. directory nodes above it will be opened) and the cursor will be |
|
| 179 |
- placed on it. |
|
| 180 |
- |
|
| 181 |
-:OpenBookmark <bookmark> |
|
| 182 |
- <bookmark> must point to a file. The file is opened as though |NERDTree-o| |
|
| 183 |
- was applied. If the node is cached under the current root then it will be |
|
| 184 |
- revealed and the cursor will be placed on it. |
|
| 185 |
- |
|
| 186 |
-:ClearBookmarks [<bookmarks>] |
|
| 187 |
- Remove all the given bookmarks. If no bookmarks are given then remove all |
|
| 188 |
- bookmarks on the current node. |
|
| 189 |
- |
|
| 190 |
-:ClearAllBookmarks |
|
| 191 |
- Remove all bookmarks. |
|
| 192 |
- |
|
| 193 |
-:ReadBookmarks |
|
| 194 |
- Re-read the bookmarks in the |'NERDTreeBookmarksFile'|. |
|
| 195 |
- |
|
| 196 |
-See also |:NERDTree| and |:NERDTreeFromBookmark|. |
|
| 197 |
- |
|
| 198 |
------------------------------------------------------------------------------- |
|
| 199 |
-2.2.3. Invalid Bookmarks *NERDTreeInvalidBookmarks* |
|
| 200 |
- |
|
| 201 |
-If invalid bookmarks are detected, the script will issue an error message and |
|
| 202 |
-the invalid bookmarks will become unavailable for use. |
|
| 203 |
- |
|
| 204 |
-These bookmarks will still be stored in the bookmarks file (see |
|
| 205 |
-|'NERDTreeBookmarksFile'|), down the bottom. There will always be a blank line |
|
| 206 |
-after the valid bookmarks but before the invalid ones. |
|
| 207 |
- |
|
| 208 |
-Each line in the bookmarks file represents one bookmark. The proper format is: |
|
| 209 |
-<bookmark name><space><full path to the bookmark location> |
|
| 210 |
- |
|
| 211 |
-After you have corrected any invalid bookmarks, either restart vim, or go |
|
| 212 |
-:ReadBookmarks from the NERD tree window. |
|
| 213 |
- |
|
| 214 |
------------------------------------------------------------------------------- |
|
| 215 |
-2.3. NERD tree Mappings *NERDTreeMappings* |
|
| 216 |
- |
|
| 217 |
-Default Description~ help-tag~ |
|
| 218 |
-Key~ |
|
| 219 |
- |
|
| 220 |
-o.......Open files, directories and bookmarks....................|NERDTree-o| |
|
| 221 |
-go......Open selected file, but leave cursor in the NERDTree.....|NERDTree-go| |
|
| 222 |
-t.......Open selected node/bookmark in a new tab.................|NERDTree-t| |
|
| 223 |
-T.......Same as 't' but keep the focus on the current tab........|NERDTree-T| |
|
| 224 |
-i.......Open selected file in a split window.....................|NERDTree-i| |
|
| 225 |
-gi......Same as i, but leave the cursor on the NERDTree..........|NERDTree-gi| |
|
| 226 |
-s.......Open selected file in a new vsplit.......................|NERDTree-s| |
|
| 227 |
-gs......Same as s, but leave the cursor on the NERDTree..........|NERDTree-gs| |
|
| 228 |
-O.......Recursively open the selected directory..................|NERDTree-O| |
|
| 229 |
-x.......Close the current nodes parent...........................|NERDTree-x| |
|
| 230 |
-X.......Recursively close all children of the current node.......|NERDTree-X| |
|
| 231 |
-e.......Edit the current dif.....................................|NERDTree-e| |
|
| 232 |
- |
|
| 233 |
-<CR>...............same as |NERDTree-o|. |
|
| 234 |
-double-click.......same as the |NERDTree-o| map. |
|
| 235 |
-middle-click.......same as |NERDTree-i| for files, same as |
|
| 236 |
- |NERDTree-e| for dirs. |
|
| 237 |
- |
|
| 238 |
-D.......Delete the current bookmark .............................|NERDTree-D| |
|
| 239 |
- |
|
| 240 |
-P.......Jump to the root node....................................|NERDTree-P| |
|
| 241 |
-p.......Jump to current nodes parent.............................|NERDTree-p| |
|
| 242 |
-K.......Jump up inside directories at the current tree depth.....|NERDTree-K| |
|
| 243 |
-J.......Jump down inside directories at the current tree depth...|NERDTree-J| |
|
| 244 |
-<C-J>...Jump down to the next sibling of the current directory...|NERDTree-C-J| |
|
| 245 |
-<C-K>...Jump up to the previous sibling of the current directory.|NERDTree-C-K| |
|
| 246 |
- |
|
| 247 |
-C.......Change the tree root to the selected dir.................|NERDTree-C| |
|
| 248 |
-u.......Move the tree root up one directory......................|NERDTree-u| |
|
| 249 |
-U.......Same as 'u' except the old root node is left open........|NERDTree-U| |
|
| 250 |
-r.......Recursively refresh the current directory................|NERDTree-r| |
|
| 251 |
-R.......Recursively refresh the current root.....................|NERDTree-R| |
|
| 252 |
-m.......Display the NERD tree menu...............................|NERDTree-m| |
|
| 253 |
-cd......Change the CWD to the dir of the selected node...........|NERDTree-cd| |
|
| 254 |
-CD......Change tree root to the CWD..............................|NERDTree-CD| |
|
| 255 |
- |
|
| 256 |
-I.......Toggle whether hidden files displayed....................|NERDTree-I| |
|
| 257 |
-f.......Toggle whether the file filters are used.................|NERDTree-f| |
|
| 258 |
-F.......Toggle whether files are displayed.......................|NERDTree-F| |
|
| 259 |
-B.......Toggle whether the bookmark table is displayed...........|NERDTree-B| |
|
| 260 |
- |
|
| 261 |
-q.......Close the NERDTree window................................|NERDTree-q| |
|
| 262 |
-A.......Zoom (maximize/minimize) the NERDTree window.............|NERDTree-A| |
|
| 263 |
-?.......Toggle the display of the quick help.....................|NERDTree-?| |
|
| 264 |
- |
|
| 265 |
------------------------------------------------------------------------------- |
|
| 266 |
- *NERDTree-o* |
|
| 267 |
-Default key: o |
|
| 268 |
-Map option: NERDTreeMapActivateNode |
|
| 269 |
-Applies to: files and directories. |
|
| 270 |
- |
|
| 271 |
-If a file node is selected, it is opened in the previous window. |
|
| 272 |
- |
|
| 273 |
-If a directory is selected it is opened or closed depending on its current |
|
| 274 |
-state. |
|
| 275 |
- |
|
| 276 |
-If a bookmark that links to a directory is selected then that directory |
|
| 277 |
-becomes the new root. |
|
| 278 |
- |
|
| 279 |
-If a bookmark that links to a file is selected then that file is opened in the |
|
| 280 |
-previous window. |
|
| 281 |
- |
|
| 282 |
------------------------------------------------------------------------------- |
|
| 283 |
- *NERDTree-go* |
|
| 284 |
-Default key: go |
|
| 285 |
-Map option: None |
|
| 286 |
-Applies to: files. |
|
| 287 |
- |
|
| 288 |
-If a file node is selected, it is opened in the previous window, but the |
|
| 289 |
-cursor does not move. |
|
| 290 |
- |
|
| 291 |
-The key combo for this mapping is always "g" + NERDTreeMapActivateNode (see |
|
| 292 |
-|NERDTree-o|). |
|
| 293 |
- |
|
| 294 |
------------------------------------------------------------------------------- |
|
| 295 |
- *NERDTree-t* |
|
| 296 |
-Default key: t |
|
| 297 |
-Map option: NERDTreeMapOpenInTab |
|
| 298 |
-Applies to: files and directories. |
|
| 299 |
- |
|
| 300 |
-Opens the selected file in a new tab. If a directory is selected, a fresh |
|
| 301 |
-NERD Tree for that directory is opened in a new tab. |
|
| 302 |
- |
|
| 303 |
-If a bookmark which points to a directory is selected, open a NERD tree for |
|
| 304 |
-that directory in a new tab. If the bookmark points to a file, open that file |
|
| 305 |
-in a new tab. |
|
| 306 |
- |
|
| 307 |
------------------------------------------------------------------------------- |
|
| 308 |
- *NERDTree-T* |
|
| 309 |
-Default key: T |
|
| 310 |
-Map option: NERDTreeMapOpenInTabSilent |
|
| 311 |
-Applies to: files and directories. |
|
| 312 |
- |
|
| 313 |
-The same as |NERDTree-t| except that the focus is kept in the current tab. |
|
| 314 |
- |
|
| 315 |
------------------------------------------------------------------------------- |
|
| 316 |
- *NERDTree-i* |
|
| 317 |
-Default key: i |
|
| 318 |
-Map option: NERDTreeMapOpenSplit |
|
| 319 |
-Applies to: files. |
|
| 320 |
- |
|
| 321 |
-Opens the selected file in a new split window and puts the cursor in the new |
|
| 322 |
-window. |
|
| 323 |
- |
|
| 324 |
------------------------------------------------------------------------------- |
|
| 325 |
- *NERDTree-gi* |
|
| 326 |
-Default key: gi |
|
| 327 |
-Map option: None |
|
| 328 |
-Applies to: files. |
|
| 329 |
- |
|
| 330 |
-The same as |NERDTree-i| except that the cursor is not moved. |
|
| 331 |
- |
|
| 332 |
-The key combo for this mapping is always "g" + NERDTreeMapOpenSplit (see |
|
| 333 |
-|NERDTree-i|). |
|
| 334 |
- |
|
| 335 |
------------------------------------------------------------------------------- |
|
| 336 |
- *NERDTree-s* |
|
| 337 |
-Default key: s |
|
| 338 |
-Map option: NERDTreeMapOpenVSplit |
|
| 339 |
-Applies to: files. |
|
| 340 |
- |
|
| 341 |
-Opens the selected file in a new vertically split window and puts the cursor in |
|
| 342 |
-the new window. |
|
| 343 |
- |
|
| 344 |
------------------------------------------------------------------------------- |
|
| 345 |
- *NERDTree-gs* |
|
| 346 |
-Default key: gs |
|
| 347 |
-Map option: None |
|
| 348 |
-Applies to: files. |
|
| 349 |
- |
|
| 350 |
-The same as |NERDTree-s| except that the cursor is not moved. |
|
| 351 |
- |
|
| 352 |
-The key combo for this mapping is always "g" + NERDTreeMapOpenVSplit (see |
|
| 353 |
-|NERDTree-s|). |
|
| 354 |
- |
|
| 355 |
------------------------------------------------------------------------------- |
|
| 356 |
- *NERDTree-O* |
|
| 357 |
-Default key: O |
|
| 358 |
-Map option: NERDTreeMapOpenRecursively |
|
| 359 |
-Applies to: directories. |
|
| 360 |
- |
|
| 361 |
-Recursively opens the selelected directory. |
|
| 362 |
- |
|
| 363 |
-All files and directories are cached, but if a directory would not be |
|
| 364 |
-displayed due to file filters (see |'NERDTreeIgnore'| |NERDTree-f|) or the |
|
| 365 |
-hidden file filter (see |'NERDTreeShowHidden'|) then its contents are not |
|
| 366 |
-cached. This is handy, especially if you have .svn directories. |
|
| 367 |
- |
|
| 368 |
------------------------------------------------------------------------------- |
|
| 369 |
- *NERDTree-x* |
|
| 370 |
-Default key: x |
|
| 371 |
-Map option: NERDTreeMapCloseDir |
|
| 372 |
-Applies to: files and directories. |
|
| 373 |
- |
|
| 374 |
-Closes the parent of the selected node. |
|
| 375 |
- |
|
| 376 |
------------------------------------------------------------------------------- |
|
| 377 |
- *NERDTree-X* |
|
| 378 |
-Default key: X |
|
| 379 |
-Map option: NERDTreeMapCloseChildren |
|
| 380 |
-Applies to: directories. |
|
| 381 |
- |
|
| 382 |
-Recursively closes all children of the selected directory. |
|
| 383 |
- |
|
| 384 |
-Tip: To quickly "reset" the tree, use |NERDTree-P| with this mapping. |
|
| 385 |
- |
|
| 386 |
------------------------------------------------------------------------------- |
|
| 387 |
- *NERDTree-e* |
|
| 388 |
-Default key: e |
|
| 389 |
-Map option: NERDTreeMapOpenExpl |
|
| 390 |
-Applies to: files and directories. |
|
| 391 |
- |
|
| 392 |
-|:edit|s the selected directory, or the selected file's directory. This could |
|
| 393 |
-result in a NERD tree or a netrw being opened, depending on |
|
| 394 |
-|'NERDTreeHijackNetrw'|. |
|
| 395 |
- |
|
| 396 |
------------------------------------------------------------------------------- |
|
| 397 |
- *NERDTree-D* |
|
| 398 |
-Default key: D |
|
| 399 |
-Map option: NERDTreeMapDeleteBookmark |
|
| 400 |
-Applies to: lines in the bookmarks table |
|
| 401 |
- |
|
| 402 |
-Deletes the currently selected bookmark. |
|
| 403 |
- |
|
| 404 |
------------------------------------------------------------------------------- |
|
| 405 |
- *NERDTree-P* |
|
| 406 |
-Default key: P |
|
| 407 |
-Map option: NERDTreeMapJumpRoot |
|
| 408 |
-Applies to: no restrictions. |
|
| 409 |
- |
|
| 410 |
-Jump to the tree root. |
|
| 411 |
- |
|
| 412 |
------------------------------------------------------------------------------- |
|
| 413 |
- *NERDTree-p* |
|
| 414 |
-Default key: p |
|
| 415 |
-Map option: NERDTreeMapJumpParent |
|
| 416 |
-Applies to: files and directories. |
|
| 417 |
- |
|
| 418 |
-Jump to the parent node of the selected node. |
|
| 419 |
- |
|
| 420 |
------------------------------------------------------------------------------- |
|
| 421 |
- *NERDTree-K* |
|
| 422 |
-Default key: K |
|
| 423 |
-Map option: NERDTreeMapJumpFirstChild |
|
| 424 |
-Applies to: files and directories. |
|
| 425 |
- |
|
| 426 |
-Jump to the first child of the current nodes parent. |
|
| 427 |
- |
|
| 428 |
-If the cursor is already on the first node then do the following: |
|
| 429 |
- * loop back thru the siblings of the current nodes parent until we find an |
|
| 430 |
- open dir with children |
|
| 431 |
- * go to the first child of that node |
|
| 432 |
- |
|
| 433 |
------------------------------------------------------------------------------- |
|
| 434 |
- *NERDTree-J* |
|
| 435 |
-Default key: J |
|
| 436 |
-Map option: NERDTreeMapJumpLastChild |
|
| 437 |
-Applies to: files and directories. |
|
| 438 |
- |
|
| 439 |
-Jump to the last child of the current nodes parent. |
|
| 440 |
- |
|
| 441 |
-If the cursor is already on the last node then do the following: |
|
| 442 |
- * loop forward thru the siblings of the current nodes parent until we find |
|
| 443 |
- an open dir with children |
|
| 444 |
- * go to the last child of that node |
|
| 445 |
- |
|
| 446 |
------------------------------------------------------------------------------- |
|
| 447 |
- *NERDTree-C-J* |
|
| 448 |
-Default key: <C-J> |
|
| 449 |
-Map option: NERDTreeMapJumpNextSibling |
|
| 450 |
-Applies to: files and directories. |
|
| 451 |
- |
|
| 452 |
-Jump to the next sibling of the selected node. |
|
| 453 |
- |
|
| 454 |
------------------------------------------------------------------------------- |
|
| 455 |
- *NERDTree-C-K* |
|
| 456 |
-Default key: <C-K> |
|
| 457 |
-Map option: NERDTreeMapJumpPrevSibling |
|
| 458 |
-Applies to: files and directories. |
|
| 459 |
- |
|
| 460 |
-Jump to the previous sibling of the selected node. |
|
| 461 |
- |
|
| 462 |
------------------------------------------------------------------------------- |
|
| 463 |
- *NERDTree-C* |
|
| 464 |
-Default key: C |
|
| 465 |
-Map option: NERDTreeMapChdir |
|
| 466 |
-Applies to: directories. |
|
| 467 |
- |
|
| 468 |
-Make the selected directory node the new tree root. If a file is selected, its |
|
| 469 |
-parent is used. |
|
| 470 |
- |
|
| 471 |
------------------------------------------------------------------------------- |
|
| 472 |
- *NERDTree-u* |
|
| 473 |
-Default key: u |
|
| 474 |
-Map option: NERDTreeMapUpdir |
|
| 475 |
-Applies to: no restrictions. |
|
| 476 |
- |
|
| 477 |
-Move the tree root up a dir (like doing a "cd .."). |
|
| 478 |
- |
|
| 479 |
------------------------------------------------------------------------------- |
|
| 480 |
- *NERDTree-U* |
|
| 481 |
-Default key: U |
|
| 482 |
-Map option: NERDTreeMapUpdirKeepOpen |
|
| 483 |
-Applies to: no restrictions. |
|
| 484 |
- |
|
| 485 |
-Like |NERDTree-u| except that the old tree root is kept open. |
|
| 486 |
- |
|
| 487 |
------------------------------------------------------------------------------- |
|
| 488 |
- *NERDTree-r* |
|
| 489 |
-Default key: r |
|
| 490 |
-Map option: NERDTreeMapRefresh |
|
| 491 |
-Applies to: files and directories. |
|
| 492 |
- |
|
| 493 |
-If a dir is selected, recursively refresh that dir, i.e. scan the filesystem |
|
| 494 |
-for changes and represent them in the tree. |
|
| 495 |
- |
|
| 496 |
-If a file node is selected then the above is done on it's parent. |
|
| 497 |
- |
|
| 498 |
------------------------------------------------------------------------------- |
|
| 499 |
- *NERDTree-R* |
|
| 500 |
-Default key: R |
|
| 501 |
-Map option: NERDTreeMapRefreshRoot |
|
| 502 |
-Applies to: no restrictions. |
|
| 503 |
- |
|
| 504 |
-Recursively refresh the tree root. |
|
| 505 |
- |
|
| 506 |
------------------------------------------------------------------------------- |
|
| 507 |
- *NERDTree-m* |
|
| 508 |
-Default key: m |
|
| 509 |
-Map option: NERDTreeMapMenu |
|
| 510 |
-Applies to: files and directories. |
|
| 511 |
- |
|
| 512 |
-Display the NERD tree menu. See |NERDTreeMenu| for details. |
|
| 513 |
- |
|
| 514 |
------------------------------------------------------------------------------- |
|
| 515 |
- *NERDTree-cd* |
|
| 516 |
-Default key: cd |
|
| 517 |
-Map option: NERDTreeMapChdir |
|
| 518 |
-Applies to: files and directories. |
|
| 519 |
- |
|
| 520 |
-Change vims current working directory to that of the selected node. |
|
| 521 |
- |
|
| 522 |
------------------------------------------------------------------------------- |
|
| 523 |
- *NERDTree-CD* |
|
| 524 |
-Default key: CD |
|
| 525 |
-Map option: NERDTreeMapCWD |
|
| 526 |
-Applies to: no restrictions. |
|
| 527 |
- |
|
| 528 |
-Change tree root to vims current working directory. |
|
| 529 |
- |
|
| 530 |
------------------------------------------------------------------------------- |
|
| 531 |
- *NERDTree-I* |
|
| 532 |
-Default key: I |
|
| 533 |
-Map option: NERDTreeMapToggleHidden |
|
| 534 |
-Applies to: no restrictions. |
|
| 535 |
- |
|
| 536 |
-Toggles whether hidden files (i.e. "dot files") are displayed. |
|
| 537 |
- |
|
| 538 |
------------------------------------------------------------------------------- |
|
| 539 |
- *NERDTree-f* |
|
| 540 |
-Default key: f |
|
| 541 |
-Map option: NERDTreeMapToggleFilters |
|
| 542 |
-Applies to: no restrictions. |
|
| 543 |
- |
|
| 544 |
-Toggles whether file filters are used. See |'NERDTreeIgnore'| for details. |
|
| 545 |
- |
|
| 546 |
------------------------------------------------------------------------------- |
|
| 547 |
- *NERDTree-F* |
|
| 548 |
-Default key: F |
|
| 549 |
-Map option: NERDTreeMapToggleFiles |
|
| 550 |
-Applies to: no restrictions. |
|
| 551 |
- |
|
| 552 |
-Toggles whether file nodes are displayed. |
|
| 553 |
- |
|
| 554 |
------------------------------------------------------------------------------- |
|
| 555 |
- *NERDTree-B* |
|
| 556 |
-Default key: B |
|
| 557 |
-Map option: NERDTreeMapToggleBookmarks |
|
| 558 |
-Applies to: no restrictions. |
|
| 559 |
- |
|
| 560 |
-Toggles whether the bookmarks table is displayed. |
|
| 561 |
- |
|
| 562 |
------------------------------------------------------------------------------- |
|
| 563 |
- *NERDTree-q* |
|
| 564 |
-Default key: q |
|
| 565 |
-Map option: NERDTreeMapQuit |
|
| 566 |
-Applies to: no restrictions. |
|
| 567 |
- |
|
| 568 |
-Closes the NERDtree window. |
|
| 569 |
- |
|
| 570 |
------------------------------------------------------------------------------- |
|
| 571 |
- *NERDTree-A* |
|
| 572 |
-Default key: A |
|
| 573 |
-Map option: NERDTreeMapToggleZoom |
|
| 574 |
-Applies to: no restrictions. |
|
| 575 |
- |
|
| 576 |
-Maximize (zoom) and minimize the NERDtree window. |
|
| 577 |
- |
|
| 578 |
------------------------------------------------------------------------------- |
|
| 579 |
- *NERDTree-?* |
|
| 580 |
-Default key: ? |
|
| 581 |
-Map option: NERDTreeMapHelp |
|
| 582 |
-Applies to: no restrictions. |
|
| 583 |
- |
|
| 584 |
-Toggles whether the quickhelp is displayed. |
|
| 585 |
- |
|
| 586 |
------------------------------------------------------------------------------- |
|
| 587 |
-2.3. The NERD tree menu *NERDTreeMenu* |
|
| 588 |
- |
|
| 589 |
-The NERD tree has a menu that can be programmed via the an API (see |
|
| 590 |
-|NERDTreeMenuAPI|). The idea is to simulate the "right click" menus that most |
|
| 591 |
-file explorers have. |
|
| 592 |
- |
|
| 593 |
-The script comes with two default menu plugins: exec_menuitem.vim and |
|
| 594 |
-fs_menu.vim. fs_menu.vim adds some basic filesystem operations to the menu for |
|
| 595 |
-creating/deleting/moving/copying files and dirs. exec_menuitem.vim provides a |
|
| 596 |
-menu item to execute executable files. |
|
| 597 |
- |
|
| 598 |
-Related tags: |NERDTree-m| |NERDTreeApi| |
|
| 599 |
- |
|
| 600 |
-============================================================================== |
|
| 601 |
-3. Customisation *NERDTreeOptions* |
|
| 602 |
- |
|
| 603 |
- |
|
| 604 |
------------------------------------------------------------------------------- |
|
| 605 |
-3.1. Customisation summary *NERDTreeOptionSummary* |
|
| 606 |
- |
|
| 607 |
-The script provides the following options that can customise the behaviour the |
|
| 608 |
-NERD tree. These options should be set in your vimrc. |
|
| 609 |
- |
|
| 610 |
-|'loaded_nerd_tree'| Turns off the script. |
|
| 611 |
- |
|
| 612 |
-|'NERDChristmasTree'| Tells the NERD tree to make itself colourful |
|
| 613 |
- and pretty. |
|
| 614 |
- |
|
| 615 |
-|'NERDTreeAutoCenter'| Controls whether the NERD tree window centers |
|
| 616 |
- when the cursor moves within a specified |
|
| 617 |
- distance to the top/bottom of the window. |
|
| 618 |
-|'NERDTreeAutoCenterThreshold'| Controls the sensitivity of autocentering. |
|
| 619 |
- |
|
| 620 |
-|'NERDTreeCaseSensitiveSort'| Tells the NERD tree whether to be case |
|
| 621 |
- sensitive or not when sorting nodes. |
|
| 622 |
- |
|
| 623 |
-|'NERDTreeChDirMode'| Tells the NERD tree if/when it should change |
|
| 624 |
- vim's current working directory. |
|
| 625 |
- |
|
| 626 |
-|'NERDTreeHighlightCursorline'| Tell the NERD tree whether to highlight the |
|
| 627 |
- current cursor line. |
|
| 628 |
- |
|
| 629 |
-|'NERDTreeHijackNetrw'| Tell the NERD tree whether to replace the netrw |
|
| 630 |
- autocommands for exploring local directories. |
|
| 631 |
- |
|
| 632 |
-|'NERDTreeIgnore'| Tells the NERD tree which files to ignore. |
|
| 633 |
- |
|
| 634 |
-|'NERDTreeBookmarksFile'| Where the bookmarks are stored. |
|
| 635 |
- |
|
| 636 |
-|'NERDTreeMouseMode'| Tells the NERD tree how to handle mouse |
|
| 637 |
- clicks. |
|
| 638 |
- |
|
| 639 |
-|'NERDTreeQuitOnOpen'| Closes the tree window after opening a file. |
|
| 640 |
- |
|
| 641 |
-|'NERDTreeShowBookmarks'| Tells the NERD tree whether to display the |
|
| 642 |
- bookmarks table on startup. |
|
| 643 |
- |
|
| 644 |
-|'NERDTreeShowFiles'| Tells the NERD tree whether to display files |
|
| 645 |
- in the tree on startup. |
|
| 646 |
- |
|
| 647 |
-|'NERDTreeShowHidden'| Tells the NERD tree whether to display hidden |
|
| 648 |
- files on startup. |
|
| 649 |
- |
|
| 650 |
-|'NERDTreeShowLineNumbers'| Tells the NERD tree whether to display line |
|
| 651 |
- numbers in the tree window. |
|
| 652 |
- |
|
| 653 |
-|'NERDTreeSortOrder'| Tell the NERD tree how to sort the nodes in |
|
| 654 |
- the tree. |
|
| 655 |
- |
|
| 656 |
-|'NERDTreeStatusline'| Set a statusline for NERD tree windows. |
|
| 657 |
- |
|
| 658 |
-|'NERDTreeWinPos'| Tells the script where to put the NERD tree |
|
| 659 |
- window. |
|
| 660 |
- |
|
| 661 |
-|'NERDTreeWinSize'| Sets the window size when the NERD tree is |
|
| 662 |
- opened. |
|
| 663 |
- |
|
| 664 |
-|'NERDTreeMinimalUI'| Disables display of the 'Bookmarks' label and |
|
| 665 |
- 'Press ? for help' text. |
|
| 666 |
- |
|
| 667 |
-|'NERDTreeDirArrows'| Tells the NERD tree to use arrows instead of |
|
| 668 |
- + ~ chars when displaying directories. |
|
| 669 |
- |
|
| 670 |
-|'NERDTreeCasadeOpenSingleChildDir'| |
|
| 671 |
- Casade open while selected directory has only |
|
| 672 |
- one child that also is a directory. |
|
| 673 |
- |
|
| 674 |
-|'NERDTreeAutoDeleteBuffer'| Tells the NERD tree to automatically remove |
|
| 675 |
- a buffer when a file is being deleted or renamed |
|
| 676 |
- via a context menu command. |
|
| 677 |
- |
|
| 678 |
------------------------------------------------------------------------------- |
|
| 679 |
-3.2. Customisation details *NERDTreeOptionDetails* |
|
| 680 |
- |
|
| 681 |
-To enable any of the below options you should put the given line in your |
|
| 682 |
-~/.vimrc |
|
| 683 |
- |
|
| 684 |
- *'loaded_nerd_tree'* |
|
| 685 |
-If this plugin is making you feel homicidal, it may be a good idea to turn it |
|
| 686 |
-off with this line in your vimrc: > |
|
| 687 |
- let loaded_nerd_tree=1 |
|
| 688 |
-< |
|
| 689 |
------------------------------------------------------------------------------- |
|
| 690 |
- *'NERDChristmasTree'* |
|
| 691 |
-Values: 0 or 1. |
|
| 692 |
-Default: 1. |
|
| 693 |
- |
|
| 694 |
-If this option is set to 1 then some extra syntax highlighting elements are |
|
| 695 |
-added to the nerd tree to make it more colourful. |
|
| 696 |
- |
|
| 697 |
-Set it to 0 for a more vanilla looking tree. |
|
| 698 |
- |
|
| 699 |
------------------------------------------------------------------------------- |
|
| 700 |
- *'NERDTreeAutoCenter'* |
|
| 701 |
-Values: 0 or 1. |
|
| 702 |
-Default: 1 |
|
| 703 |
- |
|
| 704 |
-If set to 1, the NERD tree window will center around the cursor if it moves to |
|
| 705 |
-within |'NERDTreeAutoCenterThreshold'| lines of the top/bottom of the window. |
|
| 706 |
- |
|
| 707 |
-This is ONLY done in response to tree navigation mappings, |
|
| 708 |
-i.e. |NERDTree-J| |NERDTree-K| |NERDTree-C-J| |NERDTree-C-K| |NERDTree-p| |
|
| 709 |
-|NERDTree-P| |
|
| 710 |
- |
|
| 711 |
-The centering is done with a |zz| operation. |
|
| 712 |
- |
|
| 713 |
------------------------------------------------------------------------------- |
|
| 714 |
- *'NERDTreeAutoCenterThreshold'* |
|
| 715 |
-Values: Any natural number. |
|
| 716 |
-Default: 3 |
|
| 717 |
- |
|
| 718 |
-This option controls the "sensitivity" of the NERD tree auto centering. See |
|
| 719 |
-|'NERDTreeAutoCenter'| for details. |
|
| 720 |
- |
|
| 721 |
------------------------------------------------------------------------------- |
|
| 722 |
- *'NERDTreeCaseSensitiveSort'* |
|
| 723 |
-Values: 0 or 1. |
|
| 724 |
-Default: 0. |
|
| 725 |
- |
|
| 726 |
-By default the NERD tree does not sort nodes case sensitively, i.e. nodes |
|
| 727 |
-could appear like this: > |
|
| 728 |
- bar.c |
|
| 729 |
- Baz.c |
|
| 730 |
- blarg.c |
|
| 731 |
- boner.c |
|
| 732 |
- Foo.c |
|
| 733 |
-< |
|
| 734 |
-But, if you set this option to 1 then the case of the nodes will be taken into |
|
| 735 |
-account. The above nodes would then be sorted like this: > |
|
| 736 |
- Baz.c |
|
| 737 |
- Foo.c |
|
| 738 |
- bar.c |
|
| 739 |
- blarg.c |
|
| 740 |
- boner.c |
|
| 741 |
-< |
|
| 742 |
------------------------------------------------------------------------------- |
|
| 743 |
- *'NERDTreeChDirMode'* |
|
| 744 |
- |
|
| 745 |
-Values: 0, 1 or 2. |
|
| 746 |
-Default: 0. |
|
| 747 |
- |
|
| 748 |
-Use this option to tell the script when (if at all) to change the current |
|
| 749 |
-working directory (CWD) for vim. |
|
| 750 |
- |
|
| 751 |
-If it is set to 0 then the CWD is never changed by the NERD tree. |
|
| 752 |
- |
|
| 753 |
-If set to 1 then the CWD is changed when the NERD tree is first loaded to the |
|
| 754 |
-directory it is initialized in. For example, if you start the NERD tree with > |
|
| 755 |
- :NERDTree /home/marty/foobar |
|
| 756 |
-< |
|
| 757 |
-then the CWD will be changed to /home/marty/foobar and will not be changed |
|
| 758 |
-again unless you init another NERD tree with a similar command. |
|
| 759 |
- |
|
| 760 |
-If the option is set to 2 then it behaves the same as if set to 1 except that |
|
| 761 |
-the CWD is changed whenever the tree root is changed. For example, if the CWD |
|
| 762 |
-is /home/marty/foobar and you make the node for /home/marty/foobar/baz the new |
|
| 763 |
-root then the CWD will become /home/marty/foobar/baz. |
|
| 764 |
- |
|
| 765 |
------------------------------------------------------------------------------- |
|
| 766 |
- *'NERDTreeHighlightCursorline'* |
|
| 767 |
-Values: 0 or 1. |
|
| 768 |
-Default: 1. |
|
| 769 |
- |
|
| 770 |
-If set to 1, the current cursor line in the NERD tree buffer will be |
|
| 771 |
-highlighted. This is done using the |'cursorline'| option. |
|
| 772 |
- |
|
| 773 |
------------------------------------------------------------------------------- |
|
| 774 |
- *'NERDTreeHijackNetrw'* |
|
| 775 |
-Values: 0 or 1. |
|
| 776 |
-Default: 1. |
|
| 777 |
- |
|
| 778 |
-If set to 1, doing a > |
|
| 779 |
- :edit <some directory> |
|
| 780 |
-< |
|
| 781 |
-will open up a "secondary" NERD tree instead of a netrw in the target window. |
|
| 782 |
- |
|
| 783 |
-Secondary NERD trees behaves slighly different from a regular trees in the |
|
| 784 |
-following respects: |
|
| 785 |
- 1. 'o' will open the selected file in the same window as the tree, |
|
| 786 |
- replacing it. |
|
| 787 |
- 2. you can have as many secondary tree as you want in the same tab. |
|
| 788 |
- |
|
| 789 |
------------------------------------------------------------------------------- |
|
| 790 |
- *'NERDTreeIgnore'* |
|
| 791 |
-Values: a list of regular expressions. |
|
| 792 |
-Default: ['\~$']. |
|
| 793 |
- |
|
| 794 |
-This option is used to specify which files the NERD tree should ignore. It |
|
| 795 |
-must be a list of regular expressions. When the NERD tree is rendered, any |
|
| 796 |
-files/dirs that match any of the regex's in 'NERDTreeIgnore' wont be |
|
| 797 |
-displayed. |
|
| 798 |
- |
|
| 799 |
-For example if you put the following line in your vimrc: > |
|
| 800 |
- let NERDTreeIgnore=['\.vim$', '\~$'] |
|
| 801 |
-< |
|
| 802 |
-then all files ending in .vim or ~ will be ignored. |
|
| 803 |
- |
|
| 804 |
-There are 2 magic flags that can be appended to the end of each regular |
|
| 805 |
-expression to specify that the regex should match only files or only dirs. |
|
| 806 |
-These flags are "[[dir]]" and "[[file]]". Example: > |
|
| 807 |
- let NERDTreeIgnore=['.d$[[dir]]', '.o$[[file]]'] |
|
| 808 |
-< |
|
| 809 |
-This will cause all dirs ending in ".d" to be ignored and all files ending in |
|
| 810 |
-".o" to be ignored. |
|
| 811 |
- |
|
| 812 |
-Note: to tell the NERD tree not to ignore any files you must use the following |
|
| 813 |
-line: > |
|
| 814 |
- let NERDTreeIgnore=[] |
|
| 815 |
-< |
|
| 816 |
- |
|
| 817 |
-The file filters can be turned on and off dynamically with the |NERDTree-f| |
|
| 818 |
-mapping. |
|
| 819 |
- |
|
| 820 |
------------------------------------------------------------------------------- |
|
| 821 |
- *'NERDTreeBookmarksFile'* |
|
| 822 |
-Values: a path |
|
| 823 |
-Default: $HOME/.NERDTreeBookmarks |
|
| 824 |
- |
|
| 825 |
-This is where bookmarks are saved. See |NERDTreeBookmarkCommands|. |
|
| 826 |
- |
|
| 827 |
------------------------------------------------------------------------------- |
|
| 828 |
- *'NERDTreeMouseMode'* |
|
| 829 |
-Values: 1, 2 or 3. |
|
| 830 |
-Default: 1. |
|
| 831 |
- |
|
| 832 |
-If set to 1 then a double click on a node is required to open it. |
|
| 833 |
-If set to 2 then a single click will open directory nodes, while a double |
|
| 834 |
-click will still be required for file nodes. |
|
| 835 |
-If set to 3 then a single click will open any node. |
|
| 836 |
- |
|
| 837 |
-Note: a double click anywhere on a line that a tree node is on will |
|
| 838 |
-activate it, but all single-click activations must be done on name of the node |
|
| 839 |
-itself. For example, if you have the following node: > |
|
| 840 |
- | | |-application.rb |
|
| 841 |
-< |
|
| 842 |
-then (to single click activate it) you must click somewhere in |
|
| 843 |
-'application.rb'. |
|
| 844 |
- |
|
| 845 |
------------------------------------------------------------------------------- |
|
| 846 |
- *'NERDTreeQuitOnOpen'* |
|
| 847 |
- |
|
| 848 |
-Values: 0 or 1. |
|
| 849 |
-Default: 0 |
|
| 850 |
- |
|
| 851 |
-If set to 1, the NERD tree window will close after opening a file with the |
|
| 852 |
-|NERDTree-o|, |NERDTree-i|, |NERDTree-t| and |NERDTree-T| mappings. |
|
| 853 |
- |
|
| 854 |
------------------------------------------------------------------------------- |
|
| 855 |
- *'NERDTreeShowBookmarks'* |
|
| 856 |
-Values: 0 or 1. |
|
| 857 |
-Default: 0. |
|
| 858 |
- |
|
| 859 |
-If this option is set to 1 then the bookmarks table will be displayed. |
|
| 860 |
- |
|
| 861 |
-This option can be toggled dynamically, per tree, with the |NERDTree-B| |
|
| 862 |
-mapping. |
|
| 863 |
- |
|
| 864 |
------------------------------------------------------------------------------- |
|
| 865 |
- *'NERDTreeShowFiles'* |
|
| 866 |
-Values: 0 or 1. |
|
| 867 |
-Default: 1. |
|
| 868 |
- |
|
| 869 |
-If this option is set to 1 then files are displayed in the NERD tree. If it is |
|
| 870 |
-set to 0 then only directories are displayed. |
|
| 871 |
- |
|
| 872 |
-This option can be toggled dynamically, per tree, with the |NERDTree-F| |
|
| 873 |
-mapping and is useful for drastically shrinking the tree when you are |
|
| 874 |
-navigating to a different part of the tree. |
|
| 875 |
- |
|
| 876 |
------------------------------------------------------------------------------- |
|
| 877 |
- *'NERDTreeShowHidden'* |
|
| 878 |
-Values: 0 or 1. |
|
| 879 |
-Default: 0. |
|
| 880 |
- |
|
| 881 |
-This option tells vim whether to display hidden files by default. This option |
|
| 882 |
-can be dynamically toggled, per tree, with the |NERDTree-I| mapping. Use one |
|
| 883 |
-of the follow lines to set this option: > |
|
| 884 |
- let NERDTreeShowHidden=0 |
|
| 885 |
- let NERDTreeShowHidden=1 |
|
| 886 |
-< |
|
| 887 |
- |
|
| 888 |
------------------------------------------------------------------------------- |
|
| 889 |
- *'NERDTreeShowLineNumbers'* |
|
| 890 |
-Values: 0 or 1. |
|
| 891 |
-Default: 0. |
|
| 892 |
- |
|
| 893 |
-This option tells vim whether to display line numbers for the NERD tree |
|
| 894 |
-window. Use one of the follow lines to set this option: > |
|
| 895 |
- let NERDTreeShowLineNumbers=0 |
|
| 896 |
- let NERDTreeShowLineNumbers=1 |
|
| 897 |
-< |
|
| 898 |
- |
|
| 899 |
------------------------------------------------------------------------------- |
|
| 900 |
- *'NERDTreeSortOrder'* |
|
| 901 |
-Values: a list of regular expressions. |
|
| 902 |
-Default: ['\/$', '*', '\.swp$', '\.bak$', '\~$'] |
|
| 903 |
- |
|
| 904 |
-This option is set to a list of regular expressions which are used to |
|
| 905 |
-specify the order of nodes under their parent. |
|
| 906 |
- |
|
| 907 |
-For example, if the option is set to: > |
|
| 908 |
- ['\.vim$', '\.c$', '\.h$', '*', 'foobar'] |
|
| 909 |
-< |
|
| 910 |
-then all .vim files will be placed at the top, followed by all .c files then |
|
| 911 |
-all .h files. All files containing the string 'foobar' will be placed at the |
|
| 912 |
-end. The star is a special flag: it tells the script that every node that |
|
| 913 |
-doesnt match any of the other regexps should be placed here. |
|
| 914 |
- |
|
| 915 |
-If no star is present in 'NERDTreeSortOrder' then one is automatically |
|
| 916 |
-appended to the array. |
|
| 917 |
- |
|
| 918 |
-The regex '\/$' should be used to match directory nodes. |
|
| 919 |
- |
|
| 920 |
-After this sorting is done, the files in each group are sorted alphabetically. |
|
| 921 |
- |
|
| 922 |
-Other examples: > |
|
| 923 |
- (1) ['*', '\/$'] |
|
| 924 |
- (2) [] |
|
| 925 |
- (3) ['\/$', '\.rb$', '\.php$', '*', '\.swp$', '\.bak$', '\~$'] |
|
| 926 |
-< |
|
| 927 |
-1. Directories will appear last, everything else will appear above. |
|
| 928 |
-2. Everything will simply appear in alphabetical order. |
|
| 929 |
-3. Dirs will appear first, then ruby and php. Swap files, bak files and vim |
|
| 930 |
- backup files will appear last with everything else preceding them. |
|
| 931 |
- |
|
| 932 |
------------------------------------------------------------------------------- |
|
| 933 |
- *'NERDTreeStatusline'* |
|
| 934 |
-Values: Any valid statusline setting. |
|
| 935 |
-Default: %{b:NERDTreeRoot.path.strForOS(0)}
|
|
| 936 |
- |
|
| 937 |
-Tells the script what to use as the |'statusline'| setting for NERD tree |
|
| 938 |
-windows. |
|
| 939 |
- |
|
| 940 |
-Note that the statusline is set using |:let-&| not |:set| so escaping spaces |
|
| 941 |
-isn't necessary. |
|
| 942 |
- |
|
| 943 |
-Setting this option to -1 will will deactivate it so that your global |
|
| 944 |
-statusline setting is used instead. |
|
| 945 |
- |
|
| 946 |
------------------------------------------------------------------------------- |
|
| 947 |
- *'NERDTreeWinPos'* |
|
| 948 |
-Values: "left" or "right" |
|
| 949 |
-Default: "left". |
|
| 950 |
- |
|
| 951 |
-This option is used to determine where NERD tree window is placed on the |
|
| 952 |
-screen. |
|
| 953 |
- |
|
| 954 |
-This option makes it possible to use two different explorer plugins |
|
| 955 |
-simultaneously. For example, you could have the taglist plugin on the left of |
|
| 956 |
-the window and the NERD tree on the right. |
|
| 957 |
- |
|
| 958 |
------------------------------------------------------------------------------- |
|
| 959 |
- *'NERDTreeWinSize'* |
|
| 960 |
-Values: a positive integer. |
|
| 961 |
-Default: 31. |
|
| 962 |
- |
|
| 963 |
-This option is used to change the size of the NERD tree when it is loaded. |
|
| 964 |
- |
|
| 965 |
------------------------------------------------------------------------------- |
|
| 966 |
- *'NERDTreeMinimalUI'* |
|
| 967 |
-Values: 0 or 1 |
|
| 968 |
-Default: 0 |
|
| 969 |
- |
|
| 970 |
-This options disables the 'Bookmarks' label 'Press ? for help' text. Use one |
|
| 971 |
-of the following lines to set this option: > |
|
| 972 |
- let NERDTreeMinimalUI=0 |
|
| 973 |
- let NERDTreeMinimalUI=1 |
|
| 974 |
-< |
|
| 975 |
- |
|
| 976 |
------------------------------------------------------------------------------- |
|
| 977 |
- *'NERDTreeDirArrows'* |
|
| 978 |
-Values: 0 or 1 |
|
| 979 |
-Default: 0. |
|
| 980 |
- |
|
| 981 |
-This option is used to change the default look of directory nodes displayed in |
|
| 982 |
-the tree. When set to 0 it shows old-school bars (|), + and ~ chars. If set to |
|
| 983 |
-1 it shows right and down arrows. Use one of the follow lines to set this |
|
| 984 |
-option: > |
|
| 985 |
- let NERDTreeDirArrows=0 |
|
| 986 |
- let NERDTreeDirArrows=1 |
|
| 987 |
-< |
|
| 988 |
- |
|
| 989 |
------------------------------------------------------------------------------- |
|
| 990 |
- *'NERDTreeCasadeOpenSingleChildDir'* |
|
| 991 |
-Values: 0 or 1 |
|
| 992 |
-Default: 1. |
|
| 993 |
- |
|
| 994 |
-When opening dir nodes, this option tells NERDTree to recursively open dirs |
|
| 995 |
-that have only one child which is also a dir. NERDTree will stop when it finds |
|
| 996 |
-a dir that contains anything but another single dir. This option may be useful |
|
| 997 |
-for Java projects. Use one of the follow lines to set this option: > |
|
| 998 |
- let NERDTreeCasadeOpenSingleChildDir=0 |
|
| 999 |
- let NERDTreeCasadeOpenSingleChildDir=1 |
|
| 1000 |
-< |
|
| 1001 |
- |
|
| 1002 |
------------------------------------------------------------------------------- |
|
| 1003 |
- *'NERDTreeAutoDeleteBuffer'* |
|
| 1004 |
-Values: 0 or 1 |
|
| 1005 |
-Default: 0. |
|
| 1006 |
- |
|
| 1007 |
-When using a context menu to delete or rename a file you may also want to delete |
|
| 1008 |
-the buffer which is no more valid. If the option is not set you will see a |
|
| 1009 |
-confirmation if you really want to delete an old buffer. If you always press 'y' |
|
| 1010 |
-then it worths to set this option to 1. Use one of the follow lines to set this |
|
| 1011 |
-option: > |
|
| 1012 |
- let NERDTreeAutoDeleteBuffer=0 |
|
| 1013 |
- let NERDTreeAutoDeleteBuffer=1 |
|
| 1014 |
-< |
|
| 1015 |
- |
|
| 1016 |
-============================================================================== |
|
| 1017 |
-4. The NERD tree API *NERDTreeAPI* |
|
| 1018 |
- |
|
| 1019 |
-The NERD tree script allows you to add custom key mappings and menu items via |
|
| 1020 |
-a set of API calls. Any scripts that use this API should be placed in |
|
| 1021 |
-~/.vim/nerdtree_plugin/ (*nix) or ~/vimfiles/nerdtree_plugin (windows). |
|
| 1022 |
- |
|
| 1023 |
-The script exposes some prototype objects that can be used to manipulate the |
|
| 1024 |
-tree and/or get information from it: > |
|
| 1025 |
- g:NERDTreePath |
|
| 1026 |
- g:NERDTreeDirNode |
|
| 1027 |
- g:NERDTreeFileNode |
|
| 1028 |
- g:NERDTreeBookmark |
|
| 1029 |
-< |
|
| 1030 |
-See the code/comments in NERD_tree.vim to find how to use these objects. The |
|
| 1031 |
-following code conventions are used: |
|
| 1032 |
- * class members start with a capital letter |
|
| 1033 |
- * instance members start with a lower case letter |
|
| 1034 |
- * private members start with an underscore |
|
| 1035 |
- |
|
| 1036 |
-See this blog post for more details: |
|
| 1037 |
- http://got-ravings.blogspot.com/2008/09/vim-pr0n-prototype-based-objects.html |
|
| 1038 |
- |
|
| 1039 |
------------------------------------------------------------------------------- |
|
| 1040 |
-4.1. Key map API *NERDTreeKeymapAPI* |
|
| 1041 |
- |
|
| 1042 |
-NERDTreeAddKeyMap({options}) *NERDTreeAddKeyMap()*
|
|
| 1043 |
- Adds a new keymapping for all NERD tree buffers. |
|
| 1044 |
- {options} must be a dictionary, and must contain the following keys:
|
|
| 1045 |
- "key" - the trigger key for the new mapping |
|
| 1046 |
- "callback" - the function the new mapping will be bound to |
|
| 1047 |
- "quickhelpText" - the text that will appear in the quickhelp (see |
|
| 1048 |
- |NERDTree-?|) |
|
| 1049 |
- |
|
| 1050 |
- Additionally, a "scope" argument may be supplied. This constrains the |
|
| 1051 |
- mapping so that it is only activated if the cursor is on a certain object. |
|
| 1052 |
- That object is then passed into the handling method. Possible values are: |
|
| 1053 |
- "FileNode" - a file node |
|
| 1054 |
- "DirNode" - a directory node |
|
| 1055 |
- "Node" - a file or directory node |
|
| 1056 |
- "Bookmark" - A bookmark |
|
| 1057 |
- "all" - the keymap is not constrained to any scope (default). When |
|
| 1058 |
- thei is used, the handling function is not passed any arguments. |
|
| 1059 |
- |
|
| 1060 |
- |
|
| 1061 |
- Example: > |
|
| 1062 |
- call NERDTreeAddKeyMap({
|
|
| 1063 |
- \ 'key': 'foo', |
|
| 1064 |
- \ 'callback': 'NERDTreeCDHandler', |
|
| 1065 |
- \ 'quickhelpText': 'echo full path of current node' }) |
|
| 1066 |
- \ 'scope': 'DirNode' |
|
| 1067 |
- |
|
| 1068 |
- function! NERDTreeCDHandler(dirnode) |
|
| 1069 |
- call a:dirnode.changeToDir() |
|
| 1070 |
- endfunction |
|
| 1071 |
-< |
|
| 1072 |
- This code should sit in a file like ~/.vim/nerdtree_plugin/mymapping.vim. |
|
| 1073 |
- It adds a (redundant) mapping on 'foo' which changes vim's CWD to that of |
|
| 1074 |
- the current dir node. Note this mapping will only fire when the cursor is |
|
| 1075 |
- on a directory node. |
|
| 1076 |
- |
|
| 1077 |
------------------------------------------------------------------------------- |
|
| 1078 |
-4.2. Menu API *NERDTreeMenuAPI* |
|
| 1079 |
- |
|
| 1080 |
-NERDTreeAddSubmenu({options}) *NERDTreeAddSubmenu()*
|
|
| 1081 |
- Creates and returns a new submenu. |
|
| 1082 |
- |
|
| 1083 |
- {options} must be a dictionary and must contain the following keys:
|
|
| 1084 |
- "text" - the text of the submenu that the user will see |
|
| 1085 |
- "shortcut" - a shortcut key for the submenu (need not be unique) |
|
| 1086 |
- |
|
| 1087 |
- The following keys are optional: |
|
| 1088 |
- "isActiveCallback" - a function that will be called to determine whether |
|
| 1089 |
- this submenu item will be displayed or not. The callback function must return |
|
| 1090 |
- 0 or 1. |
|
| 1091 |
- "parent" - the parent submenu of the new submenu (returned from a previous |
|
| 1092 |
- invocation of NERDTreeAddSubmenu()). If this key is left out then the new |
|
| 1093 |
- submenu will sit under the top level menu. |
|
| 1094 |
- |
|
| 1095 |
- See below for an example. |
|
| 1096 |
- |
|
| 1097 |
-NERDTreeAddMenuItem({options}) *NERDTreeAddMenuItem()*
|
|
| 1098 |
- Adds a new menu item to the NERD tree menu (see |NERDTreeMenu|). |
|
| 1099 |
- |
|
| 1100 |
- {options} must be a dictionary and must contain the
|
|
| 1101 |
- following keys: |
|
| 1102 |
- "text" - the text of the menu item which the user will see |
|
| 1103 |
- "shortcut" - a shortcut key for the menu item (need not be unique) |
|
| 1104 |
- "callback" - the function that will be called when the user activates the |
|
| 1105 |
- menu item. |
|
| 1106 |
- |
|
| 1107 |
- The following keys are optional: |
|
| 1108 |
- "isActiveCallback" - a function that will be called to determine whether |
|
| 1109 |
- this menu item will be displayed or not. The callback function must return |
|
| 1110 |
- 0 or 1. |
|
| 1111 |
- "parent" - if the menu item belongs under a submenu then this key must be |
|
| 1112 |
- specified. This value for this key will be the object that |
|
| 1113 |
- was returned when the submenu was created with |NERDTreeAddSubmenu()|. |
|
| 1114 |
- |
|
| 1115 |
- See below for an example. |
|
| 1116 |
- |
|
| 1117 |
-NERDTreeAddMenuSeparator([{options}]) *NERDTreeAddMenuSeparator()*
|
|
| 1118 |
- Adds a menu separator (a row of dashes). |
|
| 1119 |
- |
|
| 1120 |
- {options} is an optional dictionary that may contain the following keys:
|
|
| 1121 |
- "isActiveCallback" - see description in |NERDTreeAddMenuItem()|. |
|
| 1122 |
- |
|
| 1123 |
-Below is an example of the menu API in action. > |
|
| 1124 |
- call NERDTreeAddMenuSeparator() |
|
| 1125 |
- |
|
| 1126 |
- call NERDTreeAddMenuItem({
|
|
| 1127 |
- \ 'text': 'a (t)op level menu item', |
|
| 1128 |
- \ 'shortcut': 't', |
|
| 1129 |
- \ 'callback': 'SomeFunction' }) |
|
| 1130 |
- |
|
| 1131 |
- let submenu = NERDTreeAddSubmenu({
|
|
| 1132 |
- \ 'text': 'a (s)ub menu', |
|
| 1133 |
- \ 'shortcut': 's' }) |
|
| 1134 |
- |
|
| 1135 |
- call NERDTreeAddMenuItem({
|
|
| 1136 |
- \ 'text': '(n)ested item 1', |
|
| 1137 |
- \ 'shortcut': 'n', |
|
| 1138 |
- \ 'callback': 'SomeFunction', |
|
| 1139 |
- \ 'parent': submenu }) |
|
| 1140 |
- |
|
| 1141 |
- call NERDTreeAddMenuItem({
|
|
| 1142 |
- \ 'text': '(n)ested item 2', |
|
| 1143 |
- \ 'shortcut': 'n', |
|
| 1144 |
- \ 'callback': 'SomeFunction', |
|
| 1145 |
- \ 'parent': submenu }) |
|
| 1146 |
-< |
|
| 1147 |
-This will create the following menu: > |
|
| 1148 |
- -------------------- |
|
| 1149 |
- a (t)op level menu item |
|
| 1150 |
- a (s)ub menu |
|
| 1151 |
-< |
|
| 1152 |
-Where selecting "a (s)ub menu" will lead to a second menu: > |
|
| 1153 |
- (n)ested item 1 |
|
| 1154 |
- (n)ested item 2 |
|
| 1155 |
-< |
|
| 1156 |
-When any of the 3 concrete menu items are selected the function "SomeFunction" |
|
| 1157 |
-will be called. |
|
| 1158 |
- |
|
| 1159 |
------------------------------------------------------------------------------- |
|
| 1160 |
-NERDTreeRender() *NERDTreeRender()* |
|
| 1161 |
- Re-renders the NERD tree buffer. Useful if you change the state of the |
|
| 1162 |
- tree and you want to it to be reflected in the UI. |
|
| 1163 |
- |
|
| 1164 |
-============================================================================== |
|
| 1165 |
-5. About *NERDTreeAbout* |
|
| 1166 |
- |
|
| 1167 |
-The author of the NERD tree is a terrible terrible monster called Martyzilla |
|
| 1168 |
-who gobbles up small children with milk and sugar for breakfast. |
|
| 1169 |
- |
|
| 1170 |
-He can be reached at martin.grenfell at gmail dot com. He would love to hear |
|
| 1171 |
-from you, so feel free to send him suggestions and/or comments about this |
|
| 1172 |
-plugin. Don't be shy --- the worst he can do is slaughter you and stuff you in |
|
| 1173 |
-the fridge for later ;) |
|
| 1174 |
- |
|
| 1175 |
-The latest stable versions can be found at |
|
| 1176 |
- http://www.vim.org/scripts/script.php?script_id=1658 |
|
| 1177 |
- |
|
| 1178 |
-The latest dev versions are on github |
|
| 1179 |
- http://github.com/scrooloose/nerdtree |
|
| 1180 |
- |
|
| 1181 |
- |
|
| 1182 |
-============================================================================== |
|
| 1183 |
-6. Changelog *NERDTreeChangelog* |
|
| 1184 |
- |
|
| 1185 |
-Next |
|
| 1186 |
- - add 'scope' argument to the key map API |
|
| 1187 |
- - add NERDTreeCustomIgnoreFilter hook - needs doc |
|
| 1188 |
- - add magic [[dir]] and [[file]] flags to NERDTreeIgnore |
|
| 1189 |
- |
|
| 1190 |
-4.2.0 |
|
| 1191 |
- - Add NERDTreeDirArrows option to make the UI use pretty arrow chars |
|
| 1192 |
- instead of the old +~| chars to define the tree structure (sickill) |
|
| 1193 |
- - shift the syntax highlighting out into its own syntax file (gnap) |
|
| 1194 |
- - add some mac specific options to the filesystem menu - for macvim |
|
| 1195 |
- only (andersonfreitas) |
|
| 1196 |
- - Add NERDTreeMinimalUI option to remove some non functional parts of the |
|
| 1197 |
- nerdtree ui (camthompson) |
|
| 1198 |
- - tweak the behaviour of :NERDTreeFind - see :help :NERDTreeFind for the |
|
| 1199 |
- new behaviour (benjamingeiger) |
|
| 1200 |
- - if no name is given to :Bookmark, make it default to the name of the |
|
| 1201 |
- target file/dir (minyoung) |
|
| 1202 |
- - use 'file' completion when doing copying, create, and move |
|
| 1203 |
- operations (EvanDotPro) |
|
| 1204 |
- - lots of misc bug fixes (paddyoloughlin, sdewald, camthompson, Vitaly |
|
| 1205 |
- Bogdanov, AndrewRadev, mathias, scottstvnsn, kml, wycats, me RAWR!) |
|
| 1206 |
- |
|
| 1207 |
-4.1.0 |
|
| 1208 |
- features: |
|
| 1209 |
- - NERDTreeFind to reveal the node for the current buffer in the tree, |
|
| 1210 |
- see |NERDTreeFind|. This effectively merges the FindInNERDTree plugin (by |
|
| 1211 |
- Doug McInnes) into the script. |
|
| 1212 |
- - make NERDTreeQuitOnOpen apply to the t/T keymaps too. Thanks to Stefan |
|
| 1213 |
- Ritter and Rémi Prévost. |
|
| 1214 |
- - truncate the root node if wider than the tree window. Thanks to Victor |
|
| 1215 |
- Gonzalez. |
|
| 1216 |
- |
|
| 1217 |
- bugfixes: |
|
| 1218 |
- - really fix window state restoring |
|
| 1219 |
- - fix some win32 path escaping issues. Thanks to Stephan Baumeister, Ricky, |
|
| 1220 |
- jfilip1024, and Chris Chambers |
|
| 1221 |
- |
|
| 1222 |
-4.0.0 |
|
| 1223 |
- - add a new programmable menu system (see :help NERDTreeMenu). |
|
| 1224 |
- - add new APIs to add menus/menu-items to the menu system as well as |
|
| 1225 |
- custom key mappings to the NERD tree buffer (see :help NERDTreeAPI). |
|
| 1226 |
- - removed the old API functions |
|
| 1227 |
- - added a mapping to maximize/restore the size of nerd tree window, thanks |
|
| 1228 |
- to Guillaume Duranceau for the patch. See :help NERDTree-A for details. |
|
| 1229 |
- |
|
| 1230 |
- - fix a bug where secondary nerd trees (netrw hijacked trees) and |
|
| 1231 |
- NERDTreeQuitOnOpen didnt play nicely, thanks to Curtis Harvey. |
|
| 1232 |
- - fix a bug where the script ignored directories whose name ended in a dot, |
|
| 1233 |
- thanks to Aggelos Orfanakos for the patch. |
|
| 1234 |
- - fix a bug when using the x mapping on the tree root, thanks to Bryan |
|
| 1235 |
- Venteicher for the patch. |
|
| 1236 |
- - fix a bug where the cursor position/window size of the nerd tree buffer |
|
| 1237 |
- wasnt being stored on closing the window, thanks to Richard Hart. |
|
| 1238 |
- - fix a bug where NERDTreeMirror would mirror the wrong tree |
|
| 1239 |
- |
|
| 1240 |
-3.1.1 |
|
| 1241 |
- - fix a bug where a non-listed no-name buffer was getting created every |
|
| 1242 |
- time the tree windows was created, thanks to Derek Wyatt and owen1 |
|
| 1243 |
- - make <CR> behave the same as the 'o' mapping |
|
| 1244 |
- - some helptag fixes in the doc, thanks strull |
|
| 1245 |
- - fix a bug when using :set nohidden and opening a file where the previous |
|
| 1246 |
- buf was modified. Thanks iElectric |
|
| 1247 |
- - other minor fixes |
|
| 1248 |
- |
|
| 1249 |
-3.1.0 |
|
| 1250 |
- New features: |
|
| 1251 |
- - add mappings to open files in a vsplit, see :help NERDTree-s and :help |
|
| 1252 |
- NERDTree-gs |
|
| 1253 |
- - make the statusline for the nerd tree window default to something |
|
| 1254 |
- hopefully more useful. See :help 'NERDTreeStatusline' |
|
| 1255 |
- Bugfixes: |
|
| 1256 |
- - make the hijack netrw functionality work when vim is started with "vim |
|
| 1257 |
- <some dir>" (thanks to Alf Mikula for the patch). |
|
| 1258 |
- - fix a bug where the CWD wasnt being changed for some operations even when |
|
| 1259 |
- NERDTreeChDirMode==2 (thanks to Lucas S. Buchala) |
|
| 1260 |
- - add -bar to all the nerd tree :commands so they can chain with other |
|
| 1261 |
- :commands (thanks to tpope) |
|
| 1262 |
- - fix bugs when ignorecase was set (thanks to nach) |
|
| 1263 |
- - fix a bug with the relative path code (thanks to nach) |
|
| 1264 |
- - fix a bug where doing a :cd would cause :NERDTreeToggle to fail (thanks nach) |
|
| 1265 |
- |
|
| 1266 |
- |
|
| 1267 |
-3.0.1 |
|
| 1268 |
- Bugfixes: |
|
| 1269 |
- - fix bugs with :NERDTreeToggle and :NERDTreeMirror when 'hidden |
|
| 1270 |
- was not set |
|
| 1271 |
- - fix a bug where :NERDTree <path> would fail if <path> was relative and |
|
| 1272 |
- didnt start with a ./ or ../ Thanks to James Kanze. |
|
| 1273 |
- - make the q mapping work with secondary (:e <dir> style) trees, |
|
| 1274 |
- thanks to jamessan |
|
| 1275 |
- - fix a bunch of small bugs with secondary trees |
|
| 1276 |
- |
|
| 1277 |
- More insane refactoring. |
|
| 1278 |
- |
|
| 1279 |
-3.0.0 |
|
| 1280 |
- - hijack netrw so that doing an :edit <directory> will put a NERD tree in |
|
| 1281 |
- the window rather than a netrw browser. See :help 'NERDTreeHijackNetrw' |
|
| 1282 |
- - allow sharing of trees across tabs, see :help :NERDTreeMirror |
|
| 1283 |
- - remove "top" and "bottom" as valid settings for NERDTreeWinPos |
|
| 1284 |
- - change the '<tab>' mapping to 'i' |
|
| 1285 |
- - change the 'H' mapping to 'I' |
|
| 1286 |
- - lots of refactoring |
|
| 1287 |
- |
|
| 1288 |
-============================================================================== |
|
| 1289 |
-7. Credits *NERDTreeCredits* |
|
| 1290 |
- |
|
| 1291 |
-Thanks to the following people for testing, bug reports, ideas etc. Without |
|
| 1292 |
-you I probably would have got bored of the hacking the NERD tree and |
|
| 1293 |
-just downloaded pr0n instead. |
|
| 1294 |
- |
|
| 1295 |
- Tim Carey-Smith (halorgium) |
|
| 1296 |
- Vigil |
|
| 1297 |
- Nick Brettell |
|
| 1298 |
- Thomas Scott Urban |
|
| 1299 |
- Terrance Cohen |
|
| 1300 |
- Yegappan Lakshmanan |
|
| 1301 |
- Jason Mills |
|
| 1302 |
- Michael Geddes (frogonwheels) |
|
| 1303 |
- Yu Jun |
|
| 1304 |
- Michael Madsen |
|
| 1305 |
- AOYAMA Shotaro |
|
| 1306 |
- Zhang Weiwu |
|
| 1307 |
- Niels Aan de Brugh |
|
| 1308 |
- Olivier Yiptong |
|
| 1309 |
- Zhang Shuhan |
|
| 1310 |
- Cory Echols |
|
| 1311 |
- Piotr Czachur |
|
| 1312 |
- Yuan Jiang |
|
| 1313 |
- Matan Nassau |
|
| 1314 |
- Maxim Kim |
|
| 1315 |
- Charlton Wang |
|
| 1316 |
- Matt Wozniski (godlygeek) |
|
| 1317 |
- knekk |
|
| 1318 |
- Sean Chou |
|
| 1319 |
- Ryan Penn |
|
| 1320 |
- Simon Peter Nicholls |
|
| 1321 |
- Michael Foobar |
|
| 1322 |
- Tomasz Chomiuk |
|
| 1323 |
- Denis Pokataev |
|
| 1324 |
- Tim Pope (tpope) |
|
| 1325 |
- James Kanze |
|
| 1326 |
- James Vega (jamessan) |
|
| 1327 |
- Frederic Chanal (nach) |
|
| 1328 |
- Alf Mikula |
|
| 1329 |
- Lucas S. Buchala |
|
| 1330 |
- Curtis Harvey |
|
| 1331 |
- Guillaume Duranceau |
|
| 1332 |
- Richard Hart (hates) |
|
| 1333 |
- Doug McInnes |
|
| 1334 |
- Stefan Ritter |
|
| 1335 |
- Rémi Prévost |
|
| 1336 |
- Victor Gonzalez |
|
| 1337 |
- Stephan Baumeister |
|
| 1338 |
- Ricky |
|
| 1339 |
- jfilip1024 |
|
| 1340 |
- Chris Chambers |
|
| 1341 |
- Vitaly Bogdanov |
|
| 1342 |
- Patrick O'Loughlin (paddyoloughlin) |
|
| 1343 |
- Cam Thompson (camthompson) |
|
| 1344 |
- Marcin Kulik (sickill) |
|
| 1345 |
- Steve DeWald (sdewald) |
|
| 1346 |
- Ivan Necas (iNecas) |
|
| 1347 |
- George Ang (gnap) |
|
| 1348 |
- Evan Coury (EvanDotPro) |
|
| 1349 |
- Andrew Radev (AndrewRadev) |
|
| 1350 |
- Matt Gauger (mathias) |
|
| 1351 |
- Scott Stevenson (scottstvnsn) |
|
| 1352 |
- Anderson Freitas (andersonfreitas) |
|
| 1353 |
- Kamil K. Lemański (kml) |
|
| 1354 |
- Yehuda Katz (wycats) |
|
| 1355 |
- Min-Young Wu (minyoung) |
|
| 1356 |
- Benjamin Geiger (benjamingeiger) |
|
| 1357 |
- |
|
| 1358 |
-============================================================================== |
|
| 1359 |
-8. License *NERDTreeLicense* |
|
| 1360 |
- |
|
| 1361 |
-The NERD tree is released under the wtfpl. |
|
| 1362 |
-See http://sam.zoy.org/wtfpl/COPYING. |
| ... | ... |
@@ -1,41 +0,0 @@ |
| 1 |
-" ============================================================================ |
|
| 2 |
-" File: exec_menuitem.vim |
|
| 3 |
-" Description: plugin for NERD Tree that provides an execute file menu item |
|
| 4 |
-" Maintainer: Martin Grenfell <martin.grenfell at gmail dot com> |
|
| 5 |
-" Last Change: 22 July, 2009 |
|
| 6 |
-" License: This program is free software. It comes without any warranty, |
|
| 7 |
-" to the extent permitted by applicable law. You can redistribute |
|
| 8 |
-" it and/or modify it under the terms of the Do What The Fuck You |
|
| 9 |
-" Want To Public License, Version 2, as published by Sam Hocevar. |
|
| 10 |
-" See http://sam.zoy.org/wtfpl/COPYING for more details. |
|
| 11 |
-" |
|
| 12 |
-" ============================================================================ |
|
| 13 |
-if exists("g:loaded_nerdtree_exec_menuitem")
|
|
| 14 |
- finish |
|
| 15 |
-endif |
|
| 16 |
-let g:loaded_nerdtree_exec_menuitem = 1 |
|
| 17 |
- |
|
| 18 |
-call NERDTreeAddMenuItem({
|
|
| 19 |
- \ 'text': '(!)Execute file', |
|
| 20 |
- \ 'shortcut': '!', |
|
| 21 |
- \ 'callback': 'NERDTreeExecFile', |
|
| 22 |
- \ 'isActiveCallback': 'NERDTreeExecFileActive' }) |
|
| 23 |
- |
|
| 24 |
-function! NERDTreeExecFileActive() |
|
| 25 |
- let node = g:NERDTreeFileNode.GetSelected() |
|
| 26 |
- return !node.path.isDirectory && node.path.isExecutable |
|
| 27 |
-endfunction |
|
| 28 |
- |
|
| 29 |
-function! NERDTreeExecFile() |
|
| 30 |
- let treenode = g:NERDTreeFileNode.GetSelected() |
|
| 31 |
- echo "==========================================================\n" |
|
| 32 |
- echo "Complete the command to execute (add arguments etc):\n" |
|
| 33 |
- let cmd = treenode.path.str({'escape': 1})
|
|
| 34 |
- let cmd = input(':!', cmd . ' ')
|
|
| 35 |
- |
|
| 36 |
- if cmd != '' |
|
| 37 |
- exec ':!' . cmd |
|
| 38 |
- else |
|
| 39 |
- echo "Aborted" |
|
| 40 |
- endif |
|
| 41 |
-endfunction |
| ... | ... |
@@ -1,262 +0,0 @@ |
| 1 |
-" ============================================================================ |
|
| 2 |
-" File: fs_menu.vim |
|
| 3 |
-" Description: plugin for the NERD Tree that provides a file system menu |
|
| 4 |
-" Maintainer: Martin Grenfell <martin.grenfell at gmail dot com> |
|
| 5 |
-" Last Change: 17 July, 2009 |
|
| 6 |
-" License: This program is free software. It comes without any warranty, |
|
| 7 |
-" to the extent permitted by applicable law. You can redistribute |
|
| 8 |
-" it and/or modify it under the terms of the Do What The Fuck You |
|
| 9 |
-" Want To Public License, Version 2, as published by Sam Hocevar. |
|
| 10 |
-" See http://sam.zoy.org/wtfpl/COPYING for more details. |
|
| 11 |
-" |
|
| 12 |
-" ============================================================================ |
|
| 13 |
-if exists("g:loaded_nerdtree_fs_menu")
|
|
| 14 |
- finish |
|
| 15 |
-endif |
|
| 16 |
-let g:loaded_nerdtree_fs_menu = 1 |
|
| 17 |
- |
|
| 18 |
-"Automatically delete the buffer after deleting or renaming a file |
|
| 19 |
-if !exists("g:NERDTreeAutoDeleteBuffer")
|
|
| 20 |
- let g:NERDTreeAutoDeleteBuffer = 0 |
|
| 21 |
-endif |
|
| 22 |
- |
|
| 23 |
-call NERDTreeAddMenuItem({'text': '(a)dd a childnode', 'shortcut': 'a', 'callback': 'NERDTreeAddNode'})
|
|
| 24 |
-call NERDTreeAddMenuItem({'text': '(m)ove the current node', 'shortcut': 'm', 'callback': 'NERDTreeMoveNode'})
|
|
| 25 |
-call NERDTreeAddMenuItem({'text': '(d)elete the current node', 'shortcut': 'd', 'callback': 'NERDTreeDeleteNode'})
|
|
| 26 |
- |
|
| 27 |
-if has("gui_mac") || has("gui_macvim")
|
|
| 28 |
- call NERDTreeAddMenuItem({'text': '(r)eveal in Finder the current node', 'shortcut': 'r', 'callback': 'NERDTreeRevealInFinder'})
|
|
| 29 |
- call NERDTreeAddMenuItem({'text': '(o)pen the current node with system editor', 'shortcut': 'o', 'callback': 'NERDTreeExecuteFile'})
|
|
| 30 |
- call NERDTreeAddMenuItem({'text': '(q)uicklook the current node', 'shortcut': 'q', 'callback': 'NERDTreeQuickLook'})
|
|
| 31 |
-endif |
|
| 32 |
- |
|
| 33 |
-if g:NERDTreePath.CopyingSupported() |
|
| 34 |
- call NERDTreeAddMenuItem({'text': '(c)opy the current node', 'shortcut': 'c', 'callback': 'NERDTreeCopyNode'})
|
|
| 35 |
-endif |
|
| 36 |
- |
|
| 37 |
-"FUNCTION: s:echo(msg){{{1
|
|
| 38 |
-function! s:echo(msg) |
|
| 39 |
- redraw |
|
| 40 |
- echomsg "NERDTree: " . a:msg |
|
| 41 |
-endfunction |
|
| 42 |
- |
|
| 43 |
-"FUNCTION: s:echoWarning(msg){{{1
|
|
| 44 |
-function! s:echoWarning(msg) |
|
| 45 |
- echohl warningmsg |
|
| 46 |
- call s:echo(a:msg) |
|
| 47 |
- echohl normal |
|
| 48 |
-endfunction |
|
| 49 |
- |
|
| 50 |
-"FUNCTION: s:promptToDelBuffer(bufnum, msg){{{1
|
|
| 51 |
-"prints out the given msg and, if the user responds by pushing 'y' then the |
|
| 52 |
-"buffer with the given bufnum is deleted |
|
| 53 |
-" |
|
| 54 |
-"Args: |
|
| 55 |
-"bufnum: the buffer that may be deleted |
|
| 56 |
-"msg: a message that will be echoed to the user asking them if they wish to |
|
| 57 |
-" del the buffer |
|
| 58 |
-function! s:promptToDelBuffer(bufnum, msg) |
|
| 59 |
- echo a:msg |
|
| 60 |
- if g:NERDTreeAutoDeleteBuffer || nr2char(getchar()) ==# 'y' |
|
| 61 |
- " 1. ensure that all windows which display the just deleted filename |
|
| 62 |
- " now display an empty buffer (so a layout is preserved). |
|
| 63 |
- " Is not it better to close single tabs with this file only ? |
|
| 64 |
- let s:originalTabNumber = tabpagenr() |
|
| 65 |
- let s:originalWindowNumber = winnr() |
|
| 66 |
- exec "tabdo windo if winbufnr(0) == " . a:bufnum . " | exec ':enew! ' | endif" |
|
| 67 |
- exec "tabnext " . s:originalTabNumber |
|
| 68 |
- exec s:originalWindowNumber . "wincmd w" |
|
| 69 |
- " 3. We don't need a previous buffer anymore |
|
| 70 |
- exec "bwipeout! " . a:bufnum |
|
| 71 |
- endif |
|
| 72 |
-endfunction |
|
| 73 |
- |
|
| 74 |
-"FUNCTION: s:promptToRenameBuffer(bufnum, msg){{{1
|
|
| 75 |
-"prints out the given msg and, if the user responds by pushing 'y' then the |
|
| 76 |
-"buffer with the given bufnum is replaced with a new one |
|
| 77 |
-" |
|
| 78 |
-"Args: |
|
| 79 |
-"bufnum: the buffer that may be deleted |
|
| 80 |
-"msg: a message that will be echoed to the user asking them if they wish to |
|
| 81 |
-" del the buffer |
|
| 82 |
-function! s:promptToRenameBuffer(bufnum, msg, newFileName) |
|
| 83 |
- echo a:msg |
|
| 84 |
- if g:NERDTreeAutoDeleteBuffer || nr2char(getchar()) ==# 'y' |
|
| 85 |
- " 1. ensure that a new buffer is loaded |
|
| 86 |
- exec "badd " . a:newFileName |
|
| 87 |
- " 2. ensure that all windows which display the just deleted filename |
|
| 88 |
- " display a buffer for a new filename. |
|
| 89 |
- let s:originalTabNumber = tabpagenr() |
|
| 90 |
- let s:originalWindowNumber = winnr() |
|
| 91 |
- exec "tabdo windo if winbufnr(0) == " . a:bufnum . " | exec ':e! " . a:newFileName . "' | endif" |
|
| 92 |
- exec "tabnext " . s:originalTabNumber |
|
| 93 |
- exec s:originalWindowNumber . "wincmd w" |
|
| 94 |
- " 3. We don't need a previous buffer anymore |
|
| 95 |
- exec "bwipeout! " . a:bufnum |
|
| 96 |
- endif |
|
| 97 |
-endfunction |
|
| 98 |
-"FUNCTION: NERDTreeAddNode(){{{1
|
|
| 99 |
-function! NERDTreeAddNode() |
|
| 100 |
- let curDirNode = g:NERDTreeDirNode.GetSelected() |
|
| 101 |
- |
|
| 102 |
- let newNodeName = input("Add a childnode\n".
|
|
| 103 |
- \ "==========================================================\n". |
|
| 104 |
- \ "Enter the dir/file name to be created. Dirs end with a '/'\n" . |
|
| 105 |
- \ "", curDirNode.path.str() . g:NERDTreePath.Slash(), "file") |
|
| 106 |
- |
|
| 107 |
- if newNodeName ==# '' |
|
| 108 |
- call s:echo("Node Creation Aborted.")
|
|
| 109 |
- return |
|
| 110 |
- endif |
|
| 111 |
- |
|
| 112 |
- try |
|
| 113 |
- let newPath = g:NERDTreePath.Create(newNodeName) |
|
| 114 |
- let parentNode = b:NERDTreeRoot.findNode(newPath.getParent()) |
|
| 115 |
- |
|
| 116 |
- let newTreeNode = g:NERDTreeFileNode.New(newPath) |
|
| 117 |
- if parentNode.isOpen || !empty(parentNode.children) |
|
| 118 |
- call parentNode.addChild(newTreeNode, 1) |
|
| 119 |
- call NERDTreeRender() |
|
| 120 |
- call newTreeNode.putCursorHere(1, 0) |
|
| 121 |
- endif |
|
| 122 |
- catch /^NERDTree/ |
|
| 123 |
- call s:echoWarning("Node Not Created.")
|
|
| 124 |
- endtry |
|
| 125 |
-endfunction |
|
| 126 |
- |
|
| 127 |
-"FUNCTION: NERDTreeMoveNode(){{{1
|
|
| 128 |
-function! NERDTreeMoveNode() |
|
| 129 |
- let curNode = g:NERDTreeFileNode.GetSelected() |
|
| 130 |
- let newNodePath = input("Rename the current node\n" .
|
|
| 131 |
- \ "==========================================================\n" . |
|
| 132 |
- \ "Enter the new path for the node: \n" . |
|
| 133 |
- \ "", curNode.path.str(), "file") |
|
| 134 |
- |
|
| 135 |
- if newNodePath ==# '' |
|
| 136 |
- call s:echo("Node Renaming Aborted.")
|
|
| 137 |
- return |
|
| 138 |
- endif |
|
| 139 |
- |
|
| 140 |
- try |
|
| 141 |
- let bufnum = bufnr(curNode.path.str()) |
|
| 142 |
- |
|
| 143 |
- call curNode.rename(newNodePath) |
|
| 144 |
- call NERDTreeRender() |
|
| 145 |
- |
|
| 146 |
- "if the node is open in a buffer, ask the user if they want to |
|
| 147 |
- "close that buffer |
|
| 148 |
- if bufnum != -1 |
|
| 149 |
- let prompt = "\nNode renamed.\n\nThe old file is open in buffer ". bufnum . (bufwinnr(bufnum) ==# -1 ? " (hidden)" : "") .". Replace this buffer with a new file? (yN)" |
|
| 150 |
- call s:promptToRenameBuffer(bufnum, prompt, newNodePath) |
|
| 151 |
- endif |
|
| 152 |
- |
|
| 153 |
- call curNode.putCursorHere(1, 0) |
|
| 154 |
- |
|
| 155 |
- redraw |
|
| 156 |
- catch /^NERDTree/ |
|
| 157 |
- call s:echoWarning("Node Not Renamed.")
|
|
| 158 |
- endtry |
|
| 159 |
-endfunction |
|
| 160 |
- |
|
| 161 |
-" FUNCTION: NERDTreeDeleteNode() {{{1
|
|
| 162 |
-function! NERDTreeDeleteNode() |
|
| 163 |
- let currentNode = g:NERDTreeFileNode.GetSelected() |
|
| 164 |
- let confirmed = 0 |
|
| 165 |
- |
|
| 166 |
- if currentNode.path.isDirectory |
|
| 167 |
- let choice =input("Delete the current node\n" .
|
|
| 168 |
- \ "==========================================================\n" . |
|
| 169 |
- \ "STOP! To delete this entire directory, type 'yes'\n" . |
|
| 170 |
- \ "" . currentNode.path.str() . ": ") |
|
| 171 |
- let confirmed = choice ==# 'yes' |
|
| 172 |
- else |
|
| 173 |
- echo "Delete the current node\n" . |
|
| 174 |
- \ "==========================================================\n". |
|
| 175 |
- \ "Are you sure you wish to delete the node:\n" . |
|
| 176 |
- \ "" . currentNode.path.str() . " (yN):" |
|
| 177 |
- let choice = nr2char(getchar()) |
|
| 178 |
- let confirmed = choice ==# 'y' |
|
| 179 |
- endif |
|
| 180 |
- |
|
| 181 |
- |
|
| 182 |
- if confirmed |
|
| 183 |
- try |
|
| 184 |
- call currentNode.delete() |
|
| 185 |
- call NERDTreeRender() |
|
| 186 |
- |
|
| 187 |
- "if the node is open in a buffer, ask the user if they want to |
|
| 188 |
- "close that buffer |
|
| 189 |
- let bufnum = bufnr(currentNode.path.str()) |
|
| 190 |
- if buflisted(bufnum) |
|
| 191 |
- let prompt = "\nNode deleted.\n\nThe file is open in buffer ". bufnum . (bufwinnr(bufnum) ==# -1 ? " (hidden)" : "") .". Delete this buffer? (yN)" |
|
| 192 |
- call s:promptToDelBuffer(bufnum, prompt) |
|
| 193 |
- endif |
|
| 194 |
- |
|
| 195 |
- redraw |
|
| 196 |
- catch /^NERDTree/ |
|
| 197 |
- call s:echoWarning("Could not remove node")
|
|
| 198 |
- endtry |
|
| 199 |
- else |
|
| 200 |
- call s:echo("delete aborted")
|
|
| 201 |
- endif |
|
| 202 |
- |
|
| 203 |
-endfunction |
|
| 204 |
- |
|
| 205 |
-" FUNCTION: NERDTreeCopyNode() {{{1
|
|
| 206 |
-function! NERDTreeCopyNode() |
|
| 207 |
- let currentNode = g:NERDTreeFileNode.GetSelected() |
|
| 208 |
- let newNodePath = input("Copy the current node\n" .
|
|
| 209 |
- \ "==========================================================\n" . |
|
| 210 |
- \ "Enter the new path to copy the node to: \n" . |
|
| 211 |
- \ "", currentNode.path.str(), "file") |
|
| 212 |
- |
|
| 213 |
- if newNodePath != "" |
|
| 214 |
- "strip trailing slash |
|
| 215 |
- let newNodePath = substitute(newNodePath, '\/$', '', '') |
|
| 216 |
- |
|
| 217 |
- let confirmed = 1 |
|
| 218 |
- if currentNode.path.copyingWillOverwrite(newNodePath) |
|
| 219 |
- call s:echo("Warning: copying may overwrite files! Continue? (yN)")
|
|
| 220 |
- let choice = nr2char(getchar()) |
|
| 221 |
- let confirmed = choice ==# 'y' |
|
| 222 |
- endif |
|
| 223 |
- |
|
| 224 |
- if confirmed |
|
| 225 |
- try |
|
| 226 |
- let newNode = currentNode.copy(newNodePath) |
|
| 227 |
- if !empty(newNode) |
|
| 228 |
- call NERDTreeRender() |
|
| 229 |
- call newNode.putCursorHere(0, 0) |
|
| 230 |
- endif |
|
| 231 |
- catch /^NERDTree/ |
|
| 232 |
- call s:echoWarning("Could not copy node")
|
|
| 233 |
- endtry |
|
| 234 |
- endif |
|
| 235 |
- else |
|
| 236 |
- call s:echo("Copy aborted.")
|
|
| 237 |
- endif |
|
| 238 |
- redraw |
|
| 239 |
-endfunction |
|
| 240 |
- |
|
| 241 |
-function! NERDTreeQuickLook() |
|
| 242 |
- let treenode = g:NERDTreeFileNode.GetSelected() |
|
| 243 |
- if treenode != {}
|
|
| 244 |
- call system("qlmanage -p 2>/dev/null '" . treenode.path.str() . "'")
|
|
| 245 |
- endif |
|
| 246 |
-endfunction |
|
| 247 |
- |
|
| 248 |
-function! NERDTreeRevealInFinder() |
|
| 249 |
- let treenode = g:NERDTreeFileNode.GetSelected() |
|
| 250 |
- if treenode != {}
|
|
| 251 |
- let x = system("open -R '" . treenode.path.str() . "'")
|
|
| 252 |
- endif |
|
| 253 |
-endfunction |
|
| 254 |
- |
|
| 255 |
-function! NERDTreeExecuteFile() |
|
| 256 |
- let treenode = g:NERDTreeFileNode.GetSelected() |
|
| 257 |
- if treenode != {}
|
|
| 258 |
- let x = system("open '" . treenode.path.str() . "'")
|
|
| 259 |
- endif |
|
| 260 |
-endfunction |
|
| 261 |
- |
|
| 262 |
-" vim: set sw=4 sts=4 et fdm=marker: |
| ... | ... |
@@ -1,4444 +0,0 @@ |
| 1 |
-" ============================================================================ |
|
| 2 |
-" File: NERD_tree.vim |
|
| 3 |
-" Description: vim global plugin that provides a nice tree explorer |
|
| 4 |
-" Maintainer: Martin Grenfell <martin.grenfell at gmail dot com> |
|
| 5 |
-" Last Change: 28 December, 2011 |
|
| 6 |
-" License: This program is free software. It comes without any warranty, |
|
| 7 |
-" to the extent permitted by applicable law. You can redistribute |
|
| 8 |
-" it and/or modify it under the terms of the Do What The Fuck You |
|
| 9 |
-" Want To Public License, Version 2, as published by Sam Hocevar. |
|
| 10 |
-" See http://sam.zoy.org/wtfpl/COPYING for more details. |
|
| 11 |
-" |
|
| 12 |
-" ============================================================================ |
|
| 13 |
-let s:NERD_tree_version = '4.2.0' |
|
| 14 |
- |
|
| 15 |
-" SECTION: Script init stuff {{{1
|
|
| 16 |
-"============================================================ |
|
| 17 |
-if exists("loaded_nerd_tree")
|
|
| 18 |
- finish |
|
| 19 |
-endif |
|
| 20 |
-if v:version < 700 |
|
| 21 |
- echoerr "NERDTree: this plugin requires vim >= 7. DOWNLOAD IT! You'll thank me later!" |
|
| 22 |
- finish |
|
| 23 |
-endif |
|
| 24 |
-let loaded_nerd_tree = 1 |
|
| 25 |
- |
|
| 26 |
-"for line continuation - i.e dont want C in &cpo |
|
| 27 |
-let s:old_cpo = &cpo |
|
| 28 |
-set cpo&vim |
|
| 29 |
- |
|
| 30 |
-let s:running_windows = has("win16") || has("win32") || has("win64")
|
|
| 31 |
- |
|
| 32 |
-"Function: s:initVariable() function {{{2
|
|
| 33 |
-"This function is used to initialise a given variable to a given value. The |
|
| 34 |
-"variable is only initialised if it does not exist prior |
|
| 35 |
-" |
|
| 36 |
-"Args: |
|
| 37 |
-"var: the name of the var to be initialised |
|
| 38 |
-"value: the value to initialise var to |
|
| 39 |
-" |
|
| 40 |
-"Returns: |
|
| 41 |
-"1 if the var is set, 0 otherwise |
|
| 42 |
-function! s:initVariable(var, value) |
|
| 43 |
- if !exists(a:var) |
|
| 44 |
- exec 'let ' . a:var . ' = ' . "'" . substitute(a:value, "'", "''", "g") . "'" |
|
| 45 |
- return 1 |
|
| 46 |
- endif |
|
| 47 |
- return 0 |
|
| 48 |
-endfunction |
|
| 49 |
- |
|
| 50 |
-"SECTION: Init variable calls and other random constants {{{2
|
|
| 51 |
-call s:initVariable("g:NERDChristmasTree", 1)
|
|
| 52 |
-call s:initVariable("g:NERDTreeAutoCenter", 1)
|
|
| 53 |
-call s:initVariable("g:NERDTreeAutoCenterThreshold", 3)
|
|
| 54 |
-call s:initVariable("g:NERDTreeCaseSensitiveSort", 0)
|
|
| 55 |
-call s:initVariable("g:NERDTreeChDirMode", 0)
|
|
| 56 |
-call s:initVariable("g:NERDTreeMinimalUI", 0)
|
|
| 57 |
-if !exists("g:NERDTreeIgnore")
|
|
| 58 |
- let g:NERDTreeIgnore = ['\~$'] |
|
| 59 |
-endif |
|
| 60 |
-call s:initVariable("g:NERDTreeBookmarksFile", expand('$HOME') . '/.NERDTreeBookmarks')
|
|
| 61 |
-call s:initVariable("g:NERDTreeHighlightCursorline", 1)
|
|
| 62 |
-call s:initVariable("g:NERDTreeHijackNetrw", 1)
|
|
| 63 |
-call s:initVariable("g:NERDTreeMouseMode", 1)
|
|
| 64 |
-call s:initVariable("g:NERDTreeNotificationThreshold", 100)
|
|
| 65 |
-call s:initVariable("g:NERDTreeQuitOnOpen", 0)
|
|
| 66 |
-call s:initVariable("g:NERDTreeShowBookmarks", 0)
|
|
| 67 |
-call s:initVariable("g:NERDTreeShowFiles", 1)
|
|
| 68 |
-call s:initVariable("g:NERDTreeShowHidden", 0)
|
|
| 69 |
-call s:initVariable("g:NERDTreeShowLineNumbers", 0)
|
|
| 70 |
-call s:initVariable("g:NERDTreeSortDirs", 1)
|
|
| 71 |
-call s:initVariable("g:NERDTreeDirArrows", !s:running_windows)
|
|
| 72 |
-call s:initVariable("g:NERDTreeCasadeOpenSingleChildDir", 1)
|
|
| 73 |
- |
|
| 74 |
-if !exists("g:NERDTreeSortOrder")
|
|
| 75 |
- let g:NERDTreeSortOrder = ['\/$', '*', '\.swp$', '\.bak$', '\~$'] |
|
| 76 |
-else |
|
| 77 |
- "if there isnt a * in the sort sequence then add one |
|
| 78 |
- if count(g:NERDTreeSortOrder, '*') < 1 |
|
| 79 |
- call add(g:NERDTreeSortOrder, '*') |
|
| 80 |
- endif |
|
| 81 |
-endif |
|
| 82 |
- |
|
| 83 |
-"we need to use this number many times for sorting... so we calculate it only |
|
| 84 |
-"once here |
|
| 85 |
-let s:NERDTreeSortStarIndex = index(g:NERDTreeSortOrder, '*') |
|
| 86 |
- |
|
| 87 |
-if !exists('g:NERDTreeStatusline')
|
|
| 88 |
- |
|
| 89 |
- "the exists() crap here is a hack to stop vim spazzing out when |
|
| 90 |
- "loading a session that was created with an open nerd tree. It spazzes |
|
| 91 |
- "because it doesnt store b:NERDTreeRoot (its a b: var, and its a hash) |
|
| 92 |
- let g:NERDTreeStatusline = "%{exists('b:NERDTreeRoot')?b:NERDTreeRoot.path.str():''}"
|
|
| 93 |
- |
|
| 94 |
-endif |
|
| 95 |
-call s:initVariable("g:NERDTreeWinPos", "left")
|
|
| 96 |
-call s:initVariable("g:NERDTreeWinSize", 31)
|
|
| 97 |
- |
|
| 98 |
-"init the shell commands that will be used to copy nodes, and remove dir trees |
|
| 99 |
-" |
|
| 100 |
-"Note: the space after the command is important |
|
| 101 |
-if s:running_windows |
|
| 102 |
- call s:initVariable("g:NERDTreeRemoveDirCmd", 'rmdir /s /q ')
|
|
| 103 |
-else |
|
| 104 |
- call s:initVariable("g:NERDTreeRemoveDirCmd", 'rm -rf ')
|
|
| 105 |
- call s:initVariable("g:NERDTreeCopyCmd", 'cp -r ')
|
|
| 106 |
-endif |
|
| 107 |
- |
|
| 108 |
- |
|
| 109 |
-"SECTION: Init variable calls for key mappings {{{2
|
|
| 110 |
-call s:initVariable("g:NERDTreeMapActivateNode", "o")
|
|
| 111 |
-call s:initVariable("g:NERDTreeMapChangeRoot", "C")
|
|
| 112 |
-call s:initVariable("g:NERDTreeMapChdir", "cd")
|
|
| 113 |
-call s:initVariable("g:NERDTreeMapCloseChildren", "X")
|
|
| 114 |
-call s:initVariable("g:NERDTreeMapCloseDir", "x")
|
|
| 115 |
-call s:initVariable("g:NERDTreeMapDeleteBookmark", "D")
|
|
| 116 |
-call s:initVariable("g:NERDTreeMapMenu", "m")
|
|
| 117 |
-call s:initVariable("g:NERDTreeMapHelp", "?")
|
|
| 118 |
-call s:initVariable("g:NERDTreeMapJumpFirstChild", "K")
|
|
| 119 |
-call s:initVariable("g:NERDTreeMapJumpLastChild", "J")
|
|
| 120 |
-call s:initVariable("g:NERDTreeMapJumpNextSibling", "<C-j>")
|
|
| 121 |
-call s:initVariable("g:NERDTreeMapJumpParent", "p")
|
|
| 122 |
-call s:initVariable("g:NERDTreeMapJumpPrevSibling", "<C-k>")
|
|
| 123 |
-call s:initVariable("g:NERDTreeMapJumpRoot", "P")
|
|
| 124 |
-call s:initVariable("g:NERDTreeMapOpenExpl", "e")
|
|
| 125 |
-call s:initVariable("g:NERDTreeMapOpenInTab", "t")
|
|
| 126 |
-call s:initVariable("g:NERDTreeMapOpenInTabSilent", "T")
|
|
| 127 |
-call s:initVariable("g:NERDTreeMapOpenRecursively", "O")
|
|
| 128 |
-call s:initVariable("g:NERDTreeMapOpenSplit", "i")
|
|
| 129 |
-call s:initVariable("g:NERDTreeMapOpenVSplit", "s")
|
|
| 130 |
-call s:initVariable("g:NERDTreeMapPreview", "g" . NERDTreeMapActivateNode)
|
|
| 131 |
-call s:initVariable("g:NERDTreeMapPreviewSplit", "g" . NERDTreeMapOpenSplit)
|
|
| 132 |
-call s:initVariable("g:NERDTreeMapPreviewVSplit", "g" . NERDTreeMapOpenVSplit)
|
|
| 133 |
-call s:initVariable("g:NERDTreeMapQuit", "q")
|
|
| 134 |
-call s:initVariable("g:NERDTreeMapRefresh", "r")
|
|
| 135 |
-call s:initVariable("g:NERDTreeMapRefreshRoot", "R")
|
|
| 136 |
-call s:initVariable("g:NERDTreeMapToggleBookmarks", "B")
|
|
| 137 |
-call s:initVariable("g:NERDTreeMapToggleFiles", "F")
|
|
| 138 |
-call s:initVariable("g:NERDTreeMapToggleFilters", "f")
|
|
| 139 |
-call s:initVariable("g:NERDTreeMapToggleHidden", "I")
|
|
| 140 |
-call s:initVariable("g:NERDTreeMapToggleZoom", "A")
|
|
| 141 |
-call s:initVariable("g:NERDTreeMapUpdir", "u")
|
|
| 142 |
-call s:initVariable("g:NERDTreeMapUpdirKeepOpen", "U")
|
|
| 143 |
-call s:initVariable("g:NERDTreeMapCWD", "CD")
|
|
| 144 |
- |
|
| 145 |
-"SECTION: Script level variable declaration{{{2
|
|
| 146 |
-if s:running_windows |
|
| 147 |
- let s:escape_chars = " `\|\"#%&,?()\*^<>" |
|
| 148 |
-else |
|
| 149 |
- let s:escape_chars = " \\`\|\"#%&,?()\*^<>[]" |
|
| 150 |
-endif |
|
| 151 |
-let s:NERDTreeBufName = 'NERD_tree_' |
|
| 152 |
- |
|
| 153 |
-let s:tree_wid = 2 |
|
| 154 |
- |
|
| 155 |
-if g:NERDTreeDirArrows |
|
| 156 |
- let s:tree_markup_reg = '^\([▾▸] \| \+[▾▸] \| \+\)' |
|
| 157 |
-else |
|
| 158 |
- let s:tree_markup_reg = '^[ `|]*[\-+~]' |
|
| 159 |
-endif |
|
| 160 |
-let s:tree_up_dir_line = '.. (up a dir)' |
|
| 161 |
- |
|
| 162 |
-"the number to add to the nerd tree buffer name to make the buf name unique |
|
| 163 |
-let s:next_buffer_number = 1 |
|
| 164 |
- |
|
| 165 |
-" SECTION: Commands {{{1
|
|
| 166 |
-"============================================================ |
|
| 167 |
-"init the command that users start the nerd tree with |
|
| 168 |
-command! -n=? -complete=dir -bar NERDTree :call s:initNerdTree('<args>')
|
|
| 169 |
-command! -n=? -complete=dir -bar NERDTreeToggle :call s:toggle('<args>')
|
|
| 170 |
-command! -n=0 -bar NERDTreeClose :call s:closeTreeIfOpen() |
|
| 171 |
-command! -n=1 -complete=customlist,s:completeBookmarks -bar NERDTreeFromBookmark call s:initNerdTree('<args>')
|
|
| 172 |
-command! -n=0 -bar NERDTreeMirror call s:initNerdTreeMirror() |
|
| 173 |
-command! -n=0 -bar NERDTreeFind call s:findAndRevealPath() |
|
| 174 |
-command! -n=0 -bar NERDTreeFocus call NERDTreeFocus() |
|
| 175 |
-command! -n=0 -bar NERDTreeCWD call NERDTreeCWD() |
|
| 176 |
-" SECTION: Auto commands {{{1
|
|
| 177 |
-"============================================================ |
|
| 178 |
-augroup NERDTree |
|
| 179 |
- "Save the cursor position whenever we close the nerd tree |
|
| 180 |
- exec "autocmd BufWinLeave ". s:NERDTreeBufName ."* call <SID>saveScreenState()" |
|
| 181 |
- |
|
| 182 |
- "disallow insert mode in the NERDTree |
|
| 183 |
- exec "autocmd BufEnter ". s:NERDTreeBufName ."* stopinsert" |
|
| 184 |
-augroup END |
|
| 185 |
- |
|
| 186 |
-if g:NERDTreeHijackNetrw |
|
| 187 |
- augroup NERDTreeHijackNetrw |
|
| 188 |
- autocmd VimEnter * silent! autocmd! FileExplorer |
|
| 189 |
- au BufEnter,VimEnter * call s:checkForBrowse(expand("<amatch>"))
|
|
| 190 |
- augroup END |
|
| 191 |
-endif |
|
| 192 |
- |
|
| 193 |
-"SECTION: Classes {{{1
|
|
| 194 |
-"============================================================ |
|
| 195 |
-"CLASS: Bookmark {{{2
|
|
| 196 |
-"============================================================ |
|
| 197 |
-let s:Bookmark = {}
|
|
| 198 |
-" FUNCTION: Bookmark.activate() {{{3
|
|
| 199 |
-function! s:Bookmark.activate(...) |
|
| 200 |
- call self.open(a:0 ? a:1 : {})
|
|
| 201 |
-endfunction |
|
| 202 |
-" FUNCTION: Bookmark.AddBookmark(name, path) {{{3
|
|
| 203 |
-" Class method to add a new bookmark to the list, if a previous bookmark exists |
|
| 204 |
-" with the same name, just update the path for that bookmark |
|
| 205 |
-function! s:Bookmark.AddBookmark(name, path) |
|
| 206 |
- for i in s:Bookmark.Bookmarks() |
|
| 207 |
- if i.name ==# a:name |
|
| 208 |
- let i.path = a:path |
|
| 209 |
- return |
|
| 210 |
- endif |
|
| 211 |
- endfor |
|
| 212 |
- call add(s:Bookmark.Bookmarks(), s:Bookmark.New(a:name, a:path)) |
|
| 213 |
- call s:Bookmark.Sort() |
|
| 214 |
-endfunction |
|
| 215 |
-" Function: Bookmark.Bookmarks() {{{3
|
|
| 216 |
-" Class method to get all bookmarks. Lazily initializes the bookmarks global |
|
| 217 |
-" variable |
|
| 218 |
-function! s:Bookmark.Bookmarks() |
|
| 219 |
- if !exists("g:NERDTreeBookmarks")
|
|
| 220 |
- let g:NERDTreeBookmarks = [] |
|
| 221 |
- endif |
|
| 222 |
- return g:NERDTreeBookmarks |
|
| 223 |
-endfunction |
|
| 224 |
-" Function: Bookmark.BookmarkExistsFor(name) {{{3
|
|
| 225 |
-" class method that returns 1 if a bookmark with the given name is found, 0 |
|
| 226 |
-" otherwise |
|
| 227 |
-function! s:Bookmark.BookmarkExistsFor(name) |
|
| 228 |
- try |
|
| 229 |
- call s:Bookmark.BookmarkFor(a:name) |
|
| 230 |
- return 1 |
|
| 231 |
- catch /^NERDTree.BookmarkNotFoundError/ |
|
| 232 |
- return 0 |
|
| 233 |
- endtry |
|
| 234 |
-endfunction |
|
| 235 |
-" Function: Bookmark.BookmarkFor(name) {{{3
|
|
| 236 |
-" Class method to get the bookmark that has the given name. {} is return if no
|
|
| 237 |
-" bookmark is found |
|
| 238 |
-function! s:Bookmark.BookmarkFor(name) |
|
| 239 |
- for i in s:Bookmark.Bookmarks() |
|
| 240 |
- if i.name ==# a:name |
|
| 241 |
- return i |
|
| 242 |
- endif |
|
| 243 |
- endfor |
|
| 244 |
- throw "NERDTree.BookmarkNotFoundError: no bookmark found for name: \"". a:name .'"' |
|
| 245 |
-endfunction |
|
| 246 |
-" Function: Bookmark.BookmarkNames() {{{3
|
|
| 247 |
-" Class method to return an array of all bookmark names |
|
| 248 |
-function! s:Bookmark.BookmarkNames() |
|
| 249 |
- let names = [] |
|
| 250 |
- for i in s:Bookmark.Bookmarks() |
|
| 251 |
- call add(names, i.name) |
|
| 252 |
- endfor |
|
| 253 |
- return names |
|
| 254 |
-endfunction |
|
| 255 |
-" FUNCTION: Bookmark.CacheBookmarks(silent) {{{3
|
|
| 256 |
-" Class method to read all bookmarks from the bookmarks file intialize |
|
| 257 |
-" bookmark objects for each one. |
|
| 258 |
-" |
|
| 259 |
-" Args: |
|
| 260 |
-" silent - dont echo an error msg if invalid bookmarks are found |
|
| 261 |
-function! s:Bookmark.CacheBookmarks(silent) |
|
| 262 |
- if filereadable(g:NERDTreeBookmarksFile) |
|
| 263 |
- let g:NERDTreeBookmarks = [] |
|
| 264 |
- let g:NERDTreeInvalidBookmarks = [] |
|
| 265 |
- let bookmarkStrings = readfile(g:NERDTreeBookmarksFile) |
|
| 266 |
- let invalidBookmarksFound = 0 |
|
| 267 |
- for i in bookmarkStrings |
|
| 268 |
- |
|
| 269 |
- "ignore blank lines |
|
| 270 |
- if i != '' |
|
| 271 |
- |
|
| 272 |
- let name = substitute(i, '^\(.\{-}\) .*$', '\1', '')
|
|
| 273 |
- let path = substitute(i, '^.\{-} \(.*\)$', '\1', '')
|
|
| 274 |
- |
|
| 275 |
- try |
|
| 276 |
- let bookmark = s:Bookmark.New(name, s:Path.New(path)) |
|
| 277 |
- call add(g:NERDTreeBookmarks, bookmark) |
|
| 278 |
- catch /^NERDTree.InvalidArgumentsError/ |
|
| 279 |
- call add(g:NERDTreeInvalidBookmarks, i) |
|
| 280 |
- let invalidBookmarksFound += 1 |
|
| 281 |
- endtry |
|
| 282 |
- endif |
|
| 283 |
- endfor |
|
| 284 |
- if invalidBookmarksFound |
|
| 285 |
- call s:Bookmark.Write() |
|
| 286 |
- if !a:silent |
|
| 287 |
- call s:echo(invalidBookmarksFound . " invalid bookmarks were read. See :help NERDTreeInvalidBookmarks for info.") |
|
| 288 |
- endif |
|
| 289 |
- endif |
|
| 290 |
- call s:Bookmark.Sort() |
|
| 291 |
- endif |
|
| 292 |
-endfunction |
|
| 293 |
-" FUNCTION: Bookmark.compareTo(otherbookmark) {{{3
|
|
| 294 |
-" Compare these two bookmarks for sorting purposes |
|
| 295 |
-function! s:Bookmark.compareTo(otherbookmark) |
|
| 296 |
- return a:otherbookmark.name < self.name |
|
| 297 |
-endfunction |
|
| 298 |
-" FUNCTION: Bookmark.ClearAll() {{{3
|
|
| 299 |
-" Class method to delete all bookmarks. |
|
| 300 |
-function! s:Bookmark.ClearAll() |
|
| 301 |
- for i in s:Bookmark.Bookmarks() |
|
| 302 |
- call i.delete() |
|
| 303 |
- endfor |
|
| 304 |
- call s:Bookmark.Write() |
|
| 305 |
-endfunction |
|
| 306 |
-" FUNCTION: Bookmark.delete() {{{3
|
|
| 307 |
-" Delete this bookmark. If the node for this bookmark is under the current |
|
| 308 |
-" root, then recache bookmarks for its Path object |
|
| 309 |
-function! s:Bookmark.delete() |
|
| 310 |
- let node = {}
|
|
| 311 |
- try |
|
| 312 |
- let node = self.getNode(1) |
|
| 313 |
- catch /^NERDTree.BookmarkedNodeNotFoundError/ |
|
| 314 |
- endtry |
|
| 315 |
- call remove(s:Bookmark.Bookmarks(), index(s:Bookmark.Bookmarks(), self)) |
|
| 316 |
- if !empty(node) |
|
| 317 |
- call node.path.cacheDisplayString() |
|
| 318 |
- endif |
|
| 319 |
- call s:Bookmark.Write() |
|
| 320 |
-endfunction |
|
| 321 |
-" FUNCTION: Bookmark.getNode(searchFromAbsoluteRoot) {{{3
|
|
| 322 |
-" Gets the treenode for this bookmark |
|
| 323 |
-" |
|
| 324 |
-" Args: |
|
| 325 |
-" searchFromAbsoluteRoot: specifies whether we should search from the current |
|
| 326 |
-" tree root, or the highest cached node |
|
| 327 |
-function! s:Bookmark.getNode(searchFromAbsoluteRoot) |
|
| 328 |
- let searchRoot = a:searchFromAbsoluteRoot ? s:TreeDirNode.AbsoluteTreeRoot() : b:NERDTreeRoot |
|
| 329 |
- let targetNode = searchRoot.findNode(self.path) |
|
| 330 |
- if empty(targetNode) |
|
| 331 |
- throw "NERDTree.BookmarkedNodeNotFoundError: no node was found for bookmark: " . self.name |
|
| 332 |
- endif |
|
| 333 |
- return targetNode |
|
| 334 |
-endfunction |
|
| 335 |
-" FUNCTION: Bookmark.GetNodeForName(name, searchFromAbsoluteRoot) {{{3
|
|
| 336 |
-" Class method that finds the bookmark with the given name and returns the |
|
| 337 |
-" treenode for it. |
|
| 338 |
-function! s:Bookmark.GetNodeForName(name, searchFromAbsoluteRoot) |
|
| 339 |
- let bookmark = s:Bookmark.BookmarkFor(a:name) |
|
| 340 |
- return bookmark.getNode(a:searchFromAbsoluteRoot) |
|
| 341 |
-endfunction |
|
| 342 |
-" FUNCTION: Bookmark.GetSelected() {{{3
|
|
| 343 |
-" returns the Bookmark the cursor is over, or {}
|
|
| 344 |
-function! s:Bookmark.GetSelected() |
|
| 345 |
- let line = getline(".")
|
|
| 346 |
- let name = substitute(line, '^>\(.\{-}\) .\+$', '\1', '')
|
|
| 347 |
- if name != line |
|
| 348 |
- try |
|
| 349 |
- return s:Bookmark.BookmarkFor(name) |
|
| 350 |
- catch /^NERDTree.BookmarkNotFoundError/ |
|
| 351 |
- return {}
|
|
| 352 |
- endtry |
|
| 353 |
- endif |
|
| 354 |
- return {}
|
|
| 355 |
-endfunction |
|
| 356 |
- |
|
| 357 |
-" Function: Bookmark.InvalidBookmarks() {{{3
|
|
| 358 |
-" Class method to get all invalid bookmark strings read from the bookmarks |
|
| 359 |
-" file |
|
| 360 |
-function! s:Bookmark.InvalidBookmarks() |
|
| 361 |
- if !exists("g:NERDTreeInvalidBookmarks")
|
|
| 362 |
- let g:NERDTreeInvalidBookmarks = [] |
|
| 363 |
- endif |
|
| 364 |
- return g:NERDTreeInvalidBookmarks |
|
| 365 |
-endfunction |
|
| 366 |
-" FUNCTION: Bookmark.mustExist() {{{3
|
|
| 367 |
-function! s:Bookmark.mustExist() |
|
| 368 |
- if !self.path.exists() |
|
| 369 |
- call s:Bookmark.CacheBookmarks(1) |
|
| 370 |
- throw "NERDTree.BookmarkPointsToInvalidLocationError: the bookmark \"". |
|
| 371 |
- \ self.name ."\" points to a non existing location: \"". self.path.str() |
|
| 372 |
- endif |
|
| 373 |
-endfunction |
|
| 374 |
-" FUNCTION: Bookmark.New(name, path) {{{3
|
|
| 375 |
-" Create a new bookmark object with the given name and path object |
|
| 376 |
-function! s:Bookmark.New(name, path) |
|
| 377 |
- if a:name =~# ' ' |
|
| 378 |
- throw "NERDTree.IllegalBookmarkNameError: illegal name:" . a:name |
|
| 379 |
- endif |
|
| 380 |
- |
|
| 381 |
- let newBookmark = copy(self) |
|
| 382 |
- let newBookmark.name = a:name |
|
| 383 |
- let newBookmark.path = a:path |
|
| 384 |
- return newBookmark |
|
| 385 |
-endfunction |
|
| 386 |
-" FUNCTION: Bookmark.open([options]) {{{3
|
|
| 387 |
-"Args: |
|
| 388 |
-"A dictionary containing the following keys (all optional): |
|
| 389 |
-" 'where': Specifies whether the node should be opened in new split/tab or in |
|
| 390 |
-" the previous window. Can be either 'v' (vertical split), 'h' |
|
| 391 |
-" (horizontal split), 't' (new tab) or 'p' (previous window). |
|
| 392 |
-" 'reuse': if a window is displaying the file then jump the cursor there |
|
| 393 |
-" 'keepopen': dont close the tree window |
|
| 394 |
-" 'stay': open the file, but keep the cursor in the tree win |
|
| 395 |
-" |
|
| 396 |
-function! s:Bookmark.open(...) |
|
| 397 |
- let opts = a:0 ? a:1 : {}
|
|
| 398 |
- |
|
| 399 |
- if self.path.isDirectory && !has_key(opts, 'where') |
|
| 400 |
- call self.toRoot() |
|
| 401 |
- else |
|
| 402 |
- let opener = s:Opener.New(self.path, opts) |
|
| 403 |
- call opener.open(self) |
|
| 404 |
- endif |
|
| 405 |
-endfunction |
|
| 406 |
-" FUNCTION: Bookmark.openInNewTab(options) {{{3
|
|
| 407 |
-" Create a new bookmark object with the given name and path object |
|
| 408 |
-function! s:Bookmark.openInNewTab(options) |
|
| 409 |
- call s:deprecated('Bookmark.openInNewTab', 'is deprecated, use open() instead')
|
|
| 410 |
- call self.open(a:options) |
|
| 411 |
-endfunction |
|
| 412 |
-" Function: Bookmark.setPath(path) {{{3
|
|
| 413 |
-" makes this bookmark point to the given path |
|
| 414 |
-function! s:Bookmark.setPath(path) |
|
| 415 |
- let self.path = a:path |
|
| 416 |
-endfunction |
|
| 417 |
-" Function: Bookmark.Sort() {{{3
|
|
| 418 |
-" Class method that sorts all bookmarks |
|
| 419 |
-function! s:Bookmark.Sort() |
|
| 420 |
- let CompareFunc = function("s:compareBookmarks")
|
|
| 421 |
- call sort(s:Bookmark.Bookmarks(), CompareFunc) |
|
| 422 |
-endfunction |
|
| 423 |
-" Function: Bookmark.str() {{{3
|
|
| 424 |
-" Get the string that should be rendered in the view for this bookmark |
|
| 425 |
-function! s:Bookmark.str() |
|
| 426 |
- let pathStrMaxLen = winwidth(s:getTreeWinNum()) - 4 - len(self.name) |
|
| 427 |
- if &nu |
|
| 428 |
- let pathStrMaxLen = pathStrMaxLen - &numberwidth |
|
| 429 |
- endif |
|
| 430 |
- |
|
| 431 |
- let pathStr = self.path.str({'format': 'UI'})
|
|
| 432 |
- if len(pathStr) > pathStrMaxLen |
|
| 433 |
- let pathStr = '<' . strpart(pathStr, len(pathStr) - pathStrMaxLen) |
|
| 434 |
- endif |
|
| 435 |
- return '>' . self.name . ' ' . pathStr |
|
| 436 |
-endfunction |
|
| 437 |
-" FUNCTION: Bookmark.toRoot() {{{3
|
|
| 438 |
-" Make the node for this bookmark the new tree root |
|
| 439 |
-function! s:Bookmark.toRoot() |
|
| 440 |
- if self.validate() |
|
| 441 |
- try |
|
| 442 |
- let targetNode = self.getNode(1) |
|
| 443 |
- catch /^NERDTree.BookmarkedNodeNotFoundError/ |
|
| 444 |
- let targetNode = s:TreeFileNode.New(s:Bookmark.BookmarkFor(self.name).path) |
|
| 445 |
- endtry |
|
| 446 |
- call targetNode.makeRoot() |
|
| 447 |
- call s:renderView() |
|
| 448 |
- call targetNode.putCursorHere(0, 0) |
|
| 449 |
- endif |
|
| 450 |
-endfunction |
|
| 451 |
-" FUNCTION: Bookmark.ToRoot(name) {{{3
|
|
| 452 |
-" Make the node for this bookmark the new tree root |
|
| 453 |
-function! s:Bookmark.ToRoot(name) |
|
| 454 |
- let bookmark = s:Bookmark.BookmarkFor(a:name) |
|
| 455 |
- call bookmark.toRoot() |
|
| 456 |
-endfunction |
|
| 457 |
- |
|
| 458 |
- |
|
| 459 |
-"FUNCTION: Bookmark.validate() {{{3
|
|
| 460 |
-function! s:Bookmark.validate() |
|
| 461 |
- if self.path.exists() |
|
| 462 |
- return 1 |
|
| 463 |
- else |
|
| 464 |
- call s:Bookmark.CacheBookmarks(1) |
|
| 465 |
- call s:renderView() |
|
| 466 |
- call s:echo(self.name . "now points to an invalid location. See :help NERDTreeInvalidBookmarks for info.") |
|
| 467 |
- return 0 |
|
| 468 |
- endif |
|
| 469 |
-endfunction |
|
| 470 |
- |
|
| 471 |
-" Function: Bookmark.Write() {{{3
|
|
| 472 |
-" Class method to write all bookmarks to the bookmarks file |
|
| 473 |
-function! s:Bookmark.Write() |
|
| 474 |
- let bookmarkStrings = [] |
|
| 475 |
- for i in s:Bookmark.Bookmarks() |
|
| 476 |
- call add(bookmarkStrings, i.name . ' ' . i.path.str()) |
|
| 477 |
- endfor |
|
| 478 |
- |
|
| 479 |
- "add a blank line before the invalid ones |
|
| 480 |
- call add(bookmarkStrings, "") |
|
| 481 |
- |
|
| 482 |
- for j in s:Bookmark.InvalidBookmarks() |
|
| 483 |
- call add(bookmarkStrings, j) |
|
| 484 |
- endfor |
|
| 485 |
- call writefile(bookmarkStrings, g:NERDTreeBookmarksFile) |
|
| 486 |
-endfunction |
|
| 487 |
-"CLASS: KeyMap {{{2
|
|
| 488 |
-"============================================================ |
|
| 489 |
-let s:KeyMap = {}
|
|
| 490 |
-"FUNCTION: KeyMap.All() {{{3
|
|
| 491 |
-function! s:KeyMap.All() |
|
| 492 |
- if !exists("s:keyMaps")
|
|
| 493 |
- let s:keyMaps = [] |
|
| 494 |
- endif |
|
| 495 |
- return s:keyMaps |
|
| 496 |
-endfunction |
|
| 497 |
- |
|
| 498 |
-"FUNCTION: KeyMap.FindFor(key, scope) {{{3
|
|
| 499 |
-function! s:KeyMap.FindFor(key, scope) |
|
| 500 |
- for i in s:KeyMap.All() |
|
| 501 |
- if i.key ==# a:key && i.scope ==# a:scope |
|
| 502 |
- return i |
|
| 503 |
- endif |
|
| 504 |
- endfor |
|
| 505 |
- return {}
|
|
| 506 |
-endfunction |
|
| 507 |
- |
|
| 508 |
-"FUNCTION: KeyMap.BindAll() {{{3
|
|
| 509 |
-function! s:KeyMap.BindAll() |
|
| 510 |
- for i in s:KeyMap.All() |
|
| 511 |
- call i.bind() |
|
| 512 |
- endfor |
|
| 513 |
-endfunction |
|
| 514 |
- |
|
| 515 |
-"FUNCTION: KeyMap.bind() {{{3
|
|
| 516 |
-function! s:KeyMap.bind() |
|
| 517 |
- " If the key sequence we're trying to map contains any '<>' notation, we |
|
| 518 |
- " must replace each of the '<' characters with '<lt>' to ensure the string |
|
| 519 |
- " is not translated into its corresponding keycode during the later part |
|
| 520 |
- " of the map command below |
|
| 521 |
- " :he <> |
|
| 522 |
- let specialNotationRegex = '\m<\([[:alnum:]_-]\+>\)' |
|
| 523 |
- if self.key =~# specialNotationRegex |
|
| 524 |
- let keymapInvokeString = substitute(self.key, specialNotationRegex, '<lt>\1', 'g') |
|
| 525 |
- else |
|
| 526 |
- let keymapInvokeString = self.key |
|
| 527 |
- endif |
|
| 528 |
- |
|
| 529 |
- let premap = self.key == "<LeftRelease>" ? " <LeftRelease>" : " " |
|
| 530 |
- |
|
| 531 |
- exec 'nnoremap <buffer> <silent> '. self.key . premap . ':call <SID>KeyMap_Invoke("'. keymapInvokeString .'")<cr>'
|
|
| 532 |
-endfunction |
|
| 533 |
- |
|
| 534 |
-"FUNCTION: KeyMap.Remove(key, scope) {{{3
|
|
| 535 |
-function! s:KeyMap.Remove(key, scope) |
|
| 536 |
- let maps = s:KeyMap.All() |
|
| 537 |
- for i in range(len(maps)) |
|
| 538 |
- if maps[i].key ==# a:key && maps[i].scope ==# a:scope |
|
| 539 |
- return remove(maps, i) |
|
| 540 |
- endif |
|
| 541 |
- endfor |
|
| 542 |
-endfunction |
|
| 543 |
-"FUNCTION: KeyMap.invoke() {{{3
|
|
| 544 |
-"Call the KeyMaps callback function |
|
| 545 |
-function! s:KeyMap.invoke(...) |
|
| 546 |
- let Callback = function(self.callback) |
|
| 547 |
- if a:0 |
|
| 548 |
- call Callback(a:1) |
|
| 549 |
- else |
|
| 550 |
- call Callback() |
|
| 551 |
- endif |
|
| 552 |
-endfunction |
|
| 553 |
- |
|
| 554 |
- |
|
| 555 |
-"FUNCTION: KeyMap.Invoke() {{{3
|
|
| 556 |
-"Find a keymapping for a:key and the current scope invoke it. |
|
| 557 |
-" |
|
| 558 |
-"Scope is determined as follows: |
|
| 559 |
-" * if the cursor is on a dir node then "DirNode" |
|
| 560 |
-" * if the cursor is on a file node then "FileNode" |
|
| 561 |
-" * if the cursor is on a bookmark then "Bookmark" |
|
| 562 |
-" |
|
| 563 |
-"If a keymap has the scope of "all" then it will be called if no other keymap |
|
| 564 |
-"is found for a:key and the scope. |
|
| 565 |
-function! s:KeyMap.Invoke(key) |
|
| 566 |
- let node = s:TreeFileNode.GetSelected() |
|
| 567 |
- if !empty(node) |
|
| 568 |
- |
|
| 569 |
- "try file node |
|
| 570 |
- if !node.path.isDirectory |
|
| 571 |
- let km = s:KeyMap.FindFor(a:key, "FileNode") |
|
| 572 |
- if !empty(km) |
|
| 573 |
- return km.invoke(node) |
|
| 574 |
- endif |
|
| 575 |
- endif |
|
| 576 |
- |
|
| 577 |
- "try dir node |
|
| 578 |
- if node.path.isDirectory |
|
| 579 |
- let km = s:KeyMap.FindFor(a:key, "DirNode") |
|
| 580 |
- if !empty(km) |
|
| 581 |
- return km.invoke(node) |
|
| 582 |
- endif |
|
| 583 |
- endif |
|
| 584 |
- |
|
| 585 |
- "try generic node |
|
| 586 |
- let km = s:KeyMap.FindFor(a:key, "Node") |
|
| 587 |
- if !empty(km) |
|
| 588 |
- return km.invoke(node) |
|
| 589 |
- endif |
|
| 590 |
- |
|
| 591 |
- endif |
|
| 592 |
- |
|
| 593 |
- "try bookmark |
|
| 594 |
- let bm = s:Bookmark.GetSelected() |
|
| 595 |
- if !empty(bm) |
|
| 596 |
- let km = s:KeyMap.FindFor(a:key, "Bookmark") |
|
| 597 |
- if !empty(km) |
|
| 598 |
- return km.invoke(bm) |
|
| 599 |
- endif |
|
| 600 |
- endif |
|
| 601 |
- |
|
| 602 |
- "try all |
|
| 603 |
- let km = s:KeyMap.FindFor(a:key, "all") |
|
| 604 |
- if !empty(km) |
|
| 605 |
- return km.invoke() |
|
| 606 |
- endif |
|
| 607 |
-endfunction |
|
| 608 |
- |
|
| 609 |
-"this is needed since I cant figure out how to invoke dict functions from a |
|
| 610 |
-"key map |
|
| 611 |
-function! s:KeyMap_Invoke(key) |
|
| 612 |
- call s:KeyMap.Invoke(a:key) |
|
| 613 |
-endfunction |
|
| 614 |
- |
|
| 615 |
-"FUNCTION: KeyMap.Create(options) {{{3
|
|
| 616 |
-function! s:KeyMap.Create(options) |
|
| 617 |
- let newKeyMap = copy(self) |
|
| 618 |
- let opts = extend({'scope': 'all', 'quickhelpText': ''}, copy(a:options))
|
|
| 619 |
- let newKeyMap.key = opts['key'] |
|
| 620 |
- let newKeyMap.quickhelpText = opts['quickhelpText'] |
|
| 621 |
- let newKeyMap.callback = opts['callback'] |
|
| 622 |
- let newKeyMap.scope = opts['scope'] |
|
| 623 |
- |
|
| 624 |
- call s:KeyMap.Add(newKeyMap) |
|
| 625 |
-endfunction |
|
| 626 |
- |
|
| 627 |
-"FUNCTION: KeyMap.Add(keymap) {{{3
|
|
| 628 |
-function! s:KeyMap.Add(keymap) |
|
| 629 |
- call s:KeyMap.Remove(a:keymap.key, a:keymap.scope) |
|
| 630 |
- call add(s:KeyMap.All(), a:keymap) |
|
| 631 |
-endfunction |
|
| 632 |
- |
|
| 633 |
-"CLASS: MenuController {{{2
|
|
| 634 |
-"============================================================ |
|
| 635 |
-let s:MenuController = {}
|
|
| 636 |
-"FUNCTION: MenuController.New(menuItems) {{{3
|
|
| 637 |
-"create a new menu controller that operates on the given menu items |
|
| 638 |
-function! s:MenuController.New(menuItems) |
|
| 639 |
- let newMenuController = copy(self) |
|
| 640 |
- if a:menuItems[0].isSeparator() |
|
| 641 |
- let newMenuController.menuItems = a:menuItems[1:-1] |
|
| 642 |
- else |
|
| 643 |
- let newMenuController.menuItems = a:menuItems |
|
| 644 |
- endif |
|
| 645 |
- return newMenuController |
|
| 646 |
-endfunction |
|
| 647 |
- |
|
| 648 |
-"FUNCTION: MenuController.showMenu() {{{3
|
|
| 649 |
-"start the main loop of the menu and get the user to choose/execute a menu |
|
| 650 |
-"item |
|
| 651 |
-function! s:MenuController.showMenu() |
|
| 652 |
- call self._saveOptions() |
|
| 653 |
- |
|
| 654 |
- try |
|
| 655 |
- let self.selection = 0 |
|
| 656 |
- |
|
| 657 |
- let done = 0 |
|
| 658 |
- while !done |
|
| 659 |
- redraw! |
|
| 660 |
- call self._echoPrompt() |
|
| 661 |
- let key = nr2char(getchar()) |
|
| 662 |
- let done = self._handleKeypress(key) |
|
| 663 |
- endwhile |
|
| 664 |
- finally |
|
| 665 |
- call self._restoreOptions() |
|
| 666 |
- endtry |
|
| 667 |
- |
|
| 668 |
- if self.selection != -1 |
|
| 669 |
- let m = self._current() |
|
| 670 |
- call m.execute() |
|
| 671 |
- endif |
|
| 672 |
-endfunction |
|
| 673 |
- |
|
| 674 |
-"FUNCTION: MenuController._echoPrompt() {{{3
|
|
| 675 |
-function! s:MenuController._echoPrompt() |
|
| 676 |
- echo "NERDTree Menu. Use j/k/enter and the shortcuts indicated" |
|
| 677 |
- echo "==========================================================" |
|
| 678 |
- |
|
| 679 |
- for i in range(0, len(self.menuItems)-1) |
|
| 680 |
- if self.selection == i |
|
| 681 |
- echo "> " . self.menuItems[i].text |
|
| 682 |
- else |
|
| 683 |
- echo " " . self.menuItems[i].text |
|
| 684 |
- endif |
|
| 685 |
- endfor |
|
| 686 |
-endfunction |
|
| 687 |
- |
|
| 688 |
-"FUNCTION: MenuController._current(key) {{{3
|
|
| 689 |
-"get the MenuItem that is currently selected |
|
| 690 |
-function! s:MenuController._current() |
|
| 691 |
- return self.menuItems[self.selection] |
|
| 692 |
-endfunction |
|
| 693 |
- |
|
| 694 |
-"FUNCTION: MenuController._handleKeypress(key) {{{3
|
|
| 695 |
-"change the selection (if appropriate) and return 1 if the user has made |
|
| 696 |
-"their choice, 0 otherwise |
|
| 697 |
-function! s:MenuController._handleKeypress(key) |
|
| 698 |
- if a:key == 'j' |
|
| 699 |
- call self._cursorDown() |
|
| 700 |
- elseif a:key == 'k' |
|
| 701 |
- call self._cursorUp() |
|
| 702 |
- elseif a:key == nr2char(27) "escape |
|
| 703 |
- let self.selection = -1 |
|
| 704 |
- return 1 |
|
| 705 |
- elseif a:key == "\r" || a:key == "\n" "enter and ctrl-j |
|
| 706 |
- return 1 |
|
| 707 |
- else |
|
| 708 |
- let index = self._nextIndexFor(a:key) |
|
| 709 |
- if index != -1 |
|
| 710 |
- let self.selection = index |
|
| 711 |
- if len(self._allIndexesFor(a:key)) == 1 |
|
| 712 |
- return 1 |
|
| 713 |
- endif |
|
| 714 |
- endif |
|
| 715 |
- endif |
|
| 716 |
- |
|
| 717 |
- return 0 |
|
| 718 |
-endfunction |
|
| 719 |
- |
|
| 720 |
-"FUNCTION: MenuController._allIndexesFor(shortcut) {{{3
|
|
| 721 |
-"get indexes to all menu items with the given shortcut |
|
| 722 |
-function! s:MenuController._allIndexesFor(shortcut) |
|
| 723 |
- let toReturn = [] |
|
| 724 |
- |
|
| 725 |
- for i in range(0, len(self.menuItems)-1) |
|
| 726 |
- if self.menuItems[i].shortcut == a:shortcut |
|
| 727 |
- call add(toReturn, i) |
|
| 728 |
- endif |
|
| 729 |
- endfor |
|
| 730 |
- |
|
| 731 |
- return toReturn |
|
| 732 |
-endfunction |
|
| 733 |
- |
|
| 734 |
-"FUNCTION: MenuController._nextIndexFor(shortcut) {{{3
|
|
| 735 |
-"get the index to the next menu item with the given shortcut, starts from the |
|
| 736 |
-"current cursor location and wraps around to the top again if need be |
|
| 737 |
-function! s:MenuController._nextIndexFor(shortcut) |
|
| 738 |
- for i in range(self.selection+1, len(self.menuItems)-1) |
|
| 739 |
- if self.menuItems[i].shortcut == a:shortcut |
|
| 740 |
- return i |
|
| 741 |
- endif |
|
| 742 |
- endfor |
|
| 743 |
- |
|
| 744 |
- for i in range(0, self.selection) |
|
| 745 |
- if self.menuItems[i].shortcut == a:shortcut |
|
| 746 |
- return i |
|
| 747 |
- endif |
|
| 748 |
- endfor |
|
| 749 |
- |
|
| 750 |
- return -1 |
|
| 751 |
-endfunction |
|
| 752 |
- |
|
| 753 |
-"FUNCTION: MenuController._setCmdheight() {{{3
|
|
| 754 |
-"sets &cmdheight to whatever is needed to display the menu |
|
| 755 |
-function! s:MenuController._setCmdheight() |
|
| 756 |
- let &cmdheight = len(self.menuItems) + 3 |
|
| 757 |
-endfunction |
|
| 758 |
- |
|
| 759 |
-"FUNCTION: MenuController._saveOptions() {{{3
|
|
| 760 |
-"set any vim options that are required to make the menu work (saving their old |
|
| 761 |
-"values) |
|
| 762 |
-function! s:MenuController._saveOptions() |
|
| 763 |
- let self._oldLazyredraw = &lazyredraw |
|
| 764 |
- let self._oldCmdheight = &cmdheight |
|
| 765 |
- set nolazyredraw |
|
| 766 |
- call self._setCmdheight() |
|
| 767 |
-endfunction |
|
| 768 |
- |
|
| 769 |
-"FUNCTION: MenuController._restoreOptions() {{{3
|
|
| 770 |
-"restore the options we saved in _saveOptions() |
|
| 771 |
-function! s:MenuController._restoreOptions() |
|
| 772 |
- let &cmdheight = self._oldCmdheight |
|
| 773 |
- let &lazyredraw = self._oldLazyredraw |
|
| 774 |
-endfunction |
|
| 775 |
- |
|
| 776 |
-"FUNCTION: MenuController._cursorDown() {{{3
|
|
| 777 |
-"move the cursor to the next menu item, skipping separators |
|
| 778 |
-function! s:MenuController._cursorDown() |
|
| 779 |
- let done = 0 |
|
| 780 |
- while !done |
|
| 781 |
- if self.selection < len(self.menuItems)-1 |
|
| 782 |
- let self.selection += 1 |
|
| 783 |
- else |
|
| 784 |
- let self.selection = 0 |
|
| 785 |
- endif |
|
| 786 |
- |
|
| 787 |
- if !self._current().isSeparator() |
|
| 788 |
- let done = 1 |
|
| 789 |
- endif |
|
| 790 |
- endwhile |
|
| 791 |
-endfunction |
|
| 792 |
- |
|
| 793 |
-"FUNCTION: MenuController._cursorUp() {{{3
|
|
| 794 |
-"move the cursor to the previous menu item, skipping separators |
|
| 795 |
-function! s:MenuController._cursorUp() |
|
| 796 |
- let done = 0 |
|
| 797 |
- while !done |
|
| 798 |
- if self.selection > 0 |
|
| 799 |
- let self.selection -= 1 |
|
| 800 |
- else |
|
| 801 |
- let self.selection = len(self.menuItems)-1 |
|
| 802 |
- endif |
|
| 803 |
- |
|
| 804 |
- if !self._current().isSeparator() |
|
| 805 |
- let done = 1 |
|
| 806 |
- endif |
|
| 807 |
- endwhile |
|
| 808 |
-endfunction |
|
| 809 |
- |
|
| 810 |
-"CLASS: MenuItem {{{2
|
|
| 811 |
-"============================================================ |
|
| 812 |
-let s:MenuItem = {}
|
|
| 813 |
-"FUNCTION: MenuItem.All() {{{3
|
|
| 814 |
-"get all top level menu items |
|
| 815 |
-function! s:MenuItem.All() |
|
| 816 |
- if !exists("s:menuItems")
|
|
| 817 |
- let s:menuItems = [] |
|
| 818 |
- endif |
|
| 819 |
- return s:menuItems |
|
| 820 |
-endfunction |
|
| 821 |
- |
|
| 822 |
-"FUNCTION: MenuItem.AllEnabled() {{{3
|
|
| 823 |
-"get all top level menu items that are currently enabled |
|
| 824 |
-function! s:MenuItem.AllEnabled() |
|
| 825 |
- let toReturn = [] |
|
| 826 |
- for i in s:MenuItem.All() |
|
| 827 |
- if i.enabled() |
|
| 828 |
- call add(toReturn, i) |
|
| 829 |
- endif |
|
| 830 |
- endfor |
|
| 831 |
- return toReturn |
|
| 832 |
-endfunction |
|
| 833 |
- |
|
| 834 |
-"FUNCTION: MenuItem.Create(options) {{{3
|
|
| 835 |
-"make a new menu item and add it to the global list |
|
| 836 |
-function! s:MenuItem.Create(options) |
|
| 837 |
- let newMenuItem = copy(self) |
|
| 838 |
- |
|
| 839 |
- let newMenuItem.text = a:options['text'] |
|
| 840 |
- let newMenuItem.shortcut = a:options['shortcut'] |
|
| 841 |
- let newMenuItem.children = [] |
|
| 842 |
- |
|
| 843 |
- let newMenuItem.isActiveCallback = -1 |
|
| 844 |
- if has_key(a:options, 'isActiveCallback') |
|
| 845 |
- let newMenuItem.isActiveCallback = a:options['isActiveCallback'] |
|
| 846 |
- endif |
|
| 847 |
- |
|
| 848 |
- let newMenuItem.callback = -1 |
|
| 849 |
- if has_key(a:options, 'callback') |
|
| 850 |
- let newMenuItem.callback = a:options['callback'] |
|
| 851 |
- endif |
|
| 852 |
- |
|
| 853 |
- if has_key(a:options, 'parent') |
|
| 854 |
- call add(a:options['parent'].children, newMenuItem) |
|
| 855 |
- else |
|
| 856 |
- call add(s:MenuItem.All(), newMenuItem) |
|
| 857 |
- endif |
|
| 858 |
- |
|
| 859 |
- return newMenuItem |
|
| 860 |
-endfunction |
|
| 861 |
- |
|
| 862 |
-"FUNCTION: MenuItem.CreateSeparator(options) {{{3
|
|
| 863 |
-"make a new separator menu item and add it to the global list |
|
| 864 |
-function! s:MenuItem.CreateSeparator(options) |
|
| 865 |
- let standard_options = { 'text': '--------------------',
|
|
| 866 |
- \ 'shortcut': -1, |
|
| 867 |
- \ 'callback': -1 } |
|
| 868 |
- let options = extend(a:options, standard_options, "force") |
|
| 869 |
- |
|
| 870 |
- return s:MenuItem.Create(options) |
|
| 871 |
-endfunction |
|
| 872 |
- |
|
| 873 |
-"FUNCTION: MenuItem.CreateSubmenu(options) {{{3
|
|
| 874 |
-"make a new submenu and add it to global list |
|
| 875 |
-function! s:MenuItem.CreateSubmenu(options) |
|
| 876 |
- let standard_options = { 'callback': -1 }
|
|
| 877 |
- let options = extend(a:options, standard_options, "force") |
|
| 878 |
- |
|
| 879 |
- return s:MenuItem.Create(options) |
|
| 880 |
-endfunction |
|
| 881 |
- |
|
| 882 |
-"FUNCTION: MenuItem.enabled() {{{3
|
|
| 883 |
-"return 1 if this menu item should be displayed |
|
| 884 |
-" |
|
| 885 |
-"delegates off to the isActiveCallback, and defaults to 1 if no callback was |
|
| 886 |
-"specified |
|
| 887 |
-function! s:MenuItem.enabled() |
|
| 888 |
- if self.isActiveCallback != -1 |
|
| 889 |
- return {self.isActiveCallback}()
|
|
| 890 |
- endif |
|
| 891 |
- return 1 |
|
| 892 |
-endfunction |
|
| 893 |
- |
|
| 894 |
-"FUNCTION: MenuItem.execute() {{{3
|
|
| 895 |
-"perform the action behind this menu item, if this menuitem has children then |
|
| 896 |
-"display a new menu for them, otherwise deletegate off to the menuitem's |
|
| 897 |
-"callback |
|
| 898 |
-function! s:MenuItem.execute() |
|
| 899 |
- if len(self.children) |
|
| 900 |
- let mc = s:MenuController.New(self.children) |
|
| 901 |
- call mc.showMenu() |
|
| 902 |
- else |
|
| 903 |
- if self.callback != -1 |
|
| 904 |
- call {self.callback}()
|
|
| 905 |
- endif |
|
| 906 |
- endif |
|
| 907 |
-endfunction |
|
| 908 |
- |
|
| 909 |
-"FUNCTION: MenuItem.isSeparator() {{{3
|
|
| 910 |
-"return 1 if this menuitem is a separator |
|
| 911 |
-function! s:MenuItem.isSeparator() |
|
| 912 |
- return self.callback == -1 && self.children == [] |
|
| 913 |
-endfunction |
|
| 914 |
- |
|
| 915 |
-"FUNCTION: MenuItem.isSubmenu() {{{3
|
|
| 916 |
-"return 1 if this menuitem is a submenu |
|
| 917 |
-function! s:MenuItem.isSubmenu() |
|
| 918 |
- return self.callback == -1 && !empty(self.children) |
|
| 919 |
-endfunction |
|
| 920 |
- |
|
| 921 |
-"CLASS: TreeFileNode {{{2
|
|
| 922 |
-"This class is the parent of the TreeDirNode class and constitures the |
|
| 923 |
-"'Component' part of the composite design pattern between the treenode |
|
| 924 |
-"classes. |
|
| 925 |
-"============================================================ |
|
| 926 |
-let s:TreeFileNode = {}
|
|
| 927 |
-"FUNCTION: TreeFileNode.activate(...) {{{3
|
|
| 928 |
-function! s:TreeFileNode.activate(...) |
|
| 929 |
- call self.open(a:0 ? a:1 : {})
|
|
| 930 |
-endfunction |
|
| 931 |
-"FUNCTION: TreeFileNode.bookmark(name) {{{3
|
|
| 932 |
-"bookmark this node with a:name |
|
| 933 |
-function! s:TreeFileNode.bookmark(name) |
|
| 934 |
- |
|
| 935 |
- "if a bookmark exists with the same name and the node is cached then save |
|
| 936 |
- "it so we can update its display string |
|
| 937 |
- let oldMarkedNode = {}
|
|
| 938 |
- try |
|
| 939 |
- let oldMarkedNode = s:Bookmark.GetNodeForName(a:name, 1) |
|
| 940 |
- catch /^NERDTree.BookmarkNotFoundError/ |
|
| 941 |
- catch /^NERDTree.BookmarkedNodeNotFoundError/ |
|
| 942 |
- endtry |
|
| 943 |
- |
|
| 944 |
- call s:Bookmark.AddBookmark(a:name, self.path) |
|
| 945 |
- call self.path.cacheDisplayString() |
|
| 946 |
- call s:Bookmark.Write() |
|
| 947 |
- |
|
| 948 |
- if !empty(oldMarkedNode) |
|
| 949 |
- call oldMarkedNode.path.cacheDisplayString() |
|
| 950 |
- endif |
|
| 951 |
-endfunction |
|
| 952 |
-"FUNCTION: TreeFileNode.cacheParent() {{{3
|
|
| 953 |
-"initializes self.parent if it isnt already |
|
| 954 |
-function! s:TreeFileNode.cacheParent() |
|
| 955 |
- if empty(self.parent) |
|
| 956 |
- let parentPath = self.path.getParent() |
|
| 957 |
- if parentPath.equals(self.path) |
|
| 958 |
- throw "NERDTree.CannotCacheParentError: already at root" |
|
| 959 |
- endif |
|
| 960 |
- let self.parent = s:TreeFileNode.New(parentPath) |
|
| 961 |
- endif |
|
| 962 |
-endfunction |
|
| 963 |
-"FUNCTION: TreeFileNode.compareNodes {{{3
|
|
| 964 |
-"This is supposed to be a class level method but i cant figure out how to |
|
| 965 |
-"get func refs to work from a dict.. |
|
| 966 |
-" |
|
| 967 |
-"A class level method that compares two nodes |
|
| 968 |
-" |
|
| 969 |
-"Args: |
|
| 970 |
-"n1, n2: the 2 nodes to compare |
|
| 971 |
-function! s:compareNodes(n1, n2) |
|
| 972 |
- return a:n1.path.compareTo(a:n2.path) |
|
| 973 |
-endfunction |
|
| 974 |
- |
|
| 975 |
-"FUNCTION: TreeFileNode.clearBookmarks() {{{3
|
|
| 976 |
-function! s:TreeFileNode.clearBookmarks() |
|
| 977 |
- for i in s:Bookmark.Bookmarks() |
|
| 978 |
- if i.path.equals(self.path) |
|
| 979 |
- call i.delete() |
|
| 980 |
- end |
|
| 981 |
- endfor |
|
| 982 |
- call self.path.cacheDisplayString() |
|
| 983 |
-endfunction |
|
| 984 |
-"FUNCTION: TreeFileNode.copy(dest) {{{3
|
|
| 985 |
-function! s:TreeFileNode.copy(dest) |
|
| 986 |
- call self.path.copy(a:dest) |
|
| 987 |
- let newPath = s:Path.New(a:dest) |
|
| 988 |
- let parent = b:NERDTreeRoot.findNode(newPath.getParent()) |
|
| 989 |
- if !empty(parent) |
|
| 990 |
- call parent.refresh() |
|
| 991 |
- return parent.findNode(newPath) |
|
| 992 |
- else |
|
| 993 |
- return {}
|
|
| 994 |
- endif |
|
| 995 |
-endfunction |
|
| 996 |
- |
|
| 997 |
-"FUNCTION: TreeFileNode.delete {{{3
|
|
| 998 |
-"Removes this node from the tree and calls the Delete method for its path obj |
|
| 999 |
-function! s:TreeFileNode.delete() |
|
| 1000 |
- call self.path.delete() |
|
| 1001 |
- call self.parent.removeChild(self) |
|
| 1002 |
-endfunction |
|
| 1003 |
- |
|
| 1004 |
-"FUNCTION: TreeFileNode.displayString() {{{3
|
|
| 1005 |
-" |
|
| 1006 |
-"Returns a string that specifies how the node should be represented as a |
|
| 1007 |
-"string |
|
| 1008 |
-" |
|
| 1009 |
-"Return: |
|
| 1010 |
-"a string that can be used in the view to represent this node |
|
| 1011 |
-function! s:TreeFileNode.displayString() |
|
| 1012 |
- return self.path.displayString() |
|
| 1013 |
-endfunction |
|
| 1014 |
- |
|
| 1015 |
-"FUNCTION: TreeFileNode.equals(treenode) {{{3
|
|
| 1016 |
-" |
|
| 1017 |
-"Compares this treenode to the input treenode and returns 1 if they are the |
|
| 1018 |
-"same node. |
|
| 1019 |
-" |
|
| 1020 |
-"Use this method instead of == because sometimes when the treenodes contain |
|
| 1021 |
-"many children, vim seg faults when doing == |
|
| 1022 |
-" |
|
| 1023 |
-"Args: |
|
| 1024 |
-"treenode: the other treenode to compare to |
|
| 1025 |
-function! s:TreeFileNode.equals(treenode) |
|
| 1026 |
- return self.path.str() ==# a:treenode.path.str() |
|
| 1027 |
-endfunction |
|
| 1028 |
- |
|
| 1029 |
-"FUNCTION: TreeFileNode.findNode(path) {{{3
|
|
| 1030 |
-"Returns self if this node.path.Equals the given path. |
|
| 1031 |
-"Returns {} if not equal.
|
|
| 1032 |
-" |
|
| 1033 |
-"Args: |
|
| 1034 |
-"path: the path object to compare against |
|
| 1035 |
-function! s:TreeFileNode.findNode(path) |
|
| 1036 |
- if a:path.equals(self.path) |
|
| 1037 |
- return self |
|
| 1038 |
- endif |
|
| 1039 |
- return {}
|
|
| 1040 |
-endfunction |
|
| 1041 |
-"FUNCTION: TreeFileNode.findOpenDirSiblingWithVisibleChildren(direction) {{{3
|
|
| 1042 |
-" |
|
| 1043 |
-"Finds the next sibling for this node in the indicated direction. This sibling |
|
| 1044 |
-"must be a directory and may/may not have children as specified. |
|
| 1045 |
-" |
|
| 1046 |
-"Args: |
|
| 1047 |
-"direction: 0 if you want to find the previous sibling, 1 for the next sibling |
|
| 1048 |
-" |
|
| 1049 |
-"Return: |
|
| 1050 |
-"a treenode object or {} if no appropriate sibling could be found
|
|
| 1051 |
-function! s:TreeFileNode.findOpenDirSiblingWithVisibleChildren(direction) |
|
| 1052 |
- "if we have no parent then we can have no siblings |
|
| 1053 |
- if self.parent != {}
|
|
| 1054 |
- let nextSibling = self.findSibling(a:direction) |
|
| 1055 |
- |
|
| 1056 |
- while nextSibling != {}
|
|
| 1057 |
- if nextSibling.path.isDirectory && nextSibling.hasVisibleChildren() && nextSibling.isOpen |
|
| 1058 |
- return nextSibling |
|
| 1059 |
- endif |
|
| 1060 |
- let nextSibling = nextSibling.findSibling(a:direction) |
|
| 1061 |
- endwhile |
|
| 1062 |
- endif |
|
| 1063 |
- |
|
| 1064 |
- return {}
|
|
| 1065 |
-endfunction |
|
| 1066 |
-"FUNCTION: TreeFileNode.findSibling(direction) {{{3
|
|
| 1067 |
-" |
|
| 1068 |
-"Finds the next sibling for this node in the indicated direction |
|
| 1069 |
-" |
|
| 1070 |
-"Args: |
|
| 1071 |
-"direction: 0 if you want to find the previous sibling, 1 for the next sibling |
|
| 1072 |
-" |
|
| 1073 |
-"Return: |
|
| 1074 |
-"a treenode object or {} if no sibling could be found
|
|
| 1075 |
-function! s:TreeFileNode.findSibling(direction) |
|
| 1076 |
- "if we have no parent then we can have no siblings |
|
| 1077 |
- if self.parent != {}
|
|
| 1078 |
- |
|
| 1079 |
- "get the index of this node in its parents children |
|
| 1080 |
- let siblingIndx = self.parent.getChildIndex(self.path) |
|
| 1081 |
- |
|
| 1082 |
- if siblingIndx != -1 |
|
| 1083 |
- "move a long to the next potential sibling node |
|
| 1084 |
- let siblingIndx = a:direction ==# 1 ? siblingIndx+1 : siblingIndx-1 |
|
| 1085 |
- |
|
| 1086 |
- "keep moving along to the next sibling till we find one that is valid |
|
| 1087 |
- let numSiblings = self.parent.getChildCount() |
|
| 1088 |
- while siblingIndx >= 0 && siblingIndx < numSiblings |
|
| 1089 |
- |
|
| 1090 |
- "if the next node is not an ignored node (i.e. wont show up in the |
|
| 1091 |
- "view) then return it |
|
| 1092 |
- if self.parent.children[siblingIndx].path.ignore() ==# 0 |
|
| 1093 |
- return self.parent.children[siblingIndx] |
|
| 1094 |
- endif |
|
| 1095 |
- |
|
| 1096 |
- "go to next node |
|
| 1097 |
- let siblingIndx = a:direction ==# 1 ? siblingIndx+1 : siblingIndx-1 |
|
| 1098 |
- endwhile |
|
| 1099 |
- endif |
|
| 1100 |
- endif |
|
| 1101 |
- |
|
| 1102 |
- return {}
|
|
| 1103 |
-endfunction |
|
| 1104 |
- |
|
| 1105 |
-"FUNCTION: TreeFileNode.getLineNum(){{{3
|
|
| 1106 |
-"returns the line number this node is rendered on, or -1 if it isnt rendered |
|
| 1107 |
-function! s:TreeFileNode.getLineNum() |
|
| 1108 |
- "if the node is the root then return the root line no. |
|
| 1109 |
- if self.isRoot() |
|
| 1110 |
- return s:TreeFileNode.GetRootLineNum() |
|
| 1111 |
- endif |
|
| 1112 |
- |
|
| 1113 |
- let totalLines = line("$")
|
|
| 1114 |
- |
|
| 1115 |
- "the path components we have matched so far |
|
| 1116 |
- let pathcomponents = [substitute(b:NERDTreeRoot.path.str({'format': 'UI'}), '/ *$', '', '')]
|
|
| 1117 |
- "the index of the component we are searching for |
|
| 1118 |
- let curPathComponent = 1 |
|
| 1119 |
- |
|
| 1120 |
- let fullpath = self.path.str({'format': 'UI'})
|
|
| 1121 |
- |
|
| 1122 |
- |
|
| 1123 |
- let lnum = s:TreeFileNode.GetRootLineNum() |
|
| 1124 |
- while lnum > 0 |
|
| 1125 |
- let lnum = lnum + 1 |
|
| 1126 |
- "have we reached the bottom of the tree? |
|
| 1127 |
- if lnum ==# totalLines+1 |
|
| 1128 |
- return -1 |
|
| 1129 |
- endif |
|
| 1130 |
- |
|
| 1131 |
- let curLine = getline(lnum) |
|
| 1132 |
- |
|
| 1133 |
- let indent = s:indentLevelFor(curLine) |
|
| 1134 |
- if indent ==# curPathComponent |
|
| 1135 |
- let curLine = s:stripMarkupFromLine(curLine, 1) |
|
| 1136 |
- |
|
| 1137 |
- let curPath = join(pathcomponents, '/') . '/' . curLine |
|
| 1138 |
- if stridx(fullpath, curPath, 0) ==# 0 |
|
| 1139 |
- if fullpath ==# curPath || strpart(fullpath, len(curPath)-1,1) ==# '/' |
|
| 1140 |
- let curLine = substitute(curLine, '/ *$', '', '') |
|
| 1141 |
- call add(pathcomponents, curLine) |
|
| 1142 |
- let curPathComponent = curPathComponent + 1 |
|
| 1143 |
- |
|
| 1144 |
- if fullpath ==# curPath |
|
| 1145 |
- return lnum |
|
| 1146 |
- endif |
|
| 1147 |
- endif |
|
| 1148 |
- endif |
|
| 1149 |
- endif |
|
| 1150 |
- endwhile |
|
| 1151 |
- return -1 |
|
| 1152 |
-endfunction |
|
| 1153 |
- |
|
| 1154 |
-"FUNCTION: TreeFileNode.GetRootForTab(){{{3
|
|
| 1155 |
-"get the root node for this tab |
|
| 1156 |
-function! s:TreeFileNode.GetRootForTab() |
|
| 1157 |
- if s:treeExistsForTab() |
|
| 1158 |
- return getbufvar(t:NERDTreeBufName, 'NERDTreeRoot') |
|
| 1159 |
- end |
|
| 1160 |
- return {}
|
|
| 1161 |
-endfunction |
|
| 1162 |
-"FUNCTION: TreeFileNode.GetRootLineNum(){{{3
|
|
| 1163 |
-"gets the line number of the root node |
|
| 1164 |
-function! s:TreeFileNode.GetRootLineNum() |
|
| 1165 |
- let rootLine = 1 |
|
| 1166 |
- while getline(rootLine) !~# '^\(/\|<\)' |
|
| 1167 |
- let rootLine = rootLine + 1 |
|
| 1168 |
- endwhile |
|
| 1169 |
- return rootLine |
|
| 1170 |
-endfunction |
|
| 1171 |
- |
|
| 1172 |
-"FUNCTION: TreeFileNode.GetSelected() {{{3
|
|
| 1173 |
-"gets the treenode that the cursor is currently over |
|
| 1174 |
-function! s:TreeFileNode.GetSelected() |
|
| 1175 |
- try |
|
| 1176 |
- let path = s:getPath(line("."))
|
|
| 1177 |
- if path ==# {}
|
|
| 1178 |
- return {}
|
|
| 1179 |
- endif |
|
| 1180 |
- return b:NERDTreeRoot.findNode(path) |
|
| 1181 |
- catch /NERDTree/ |
|
| 1182 |
- return {}
|
|
| 1183 |
- endtry |
|
| 1184 |
-endfunction |
|
| 1185 |
-"FUNCTION: TreeFileNode.isVisible() {{{3
|
|
| 1186 |
-"returns 1 if this node should be visible according to the tree filters and |
|
| 1187 |
-"hidden file filters (and their on/off status) |
|
| 1188 |
-function! s:TreeFileNode.isVisible() |
|
| 1189 |
- return !self.path.ignore() |
|
| 1190 |
-endfunction |
|
| 1191 |
-"FUNCTION: TreeFileNode.isRoot() {{{3
|
|
| 1192 |
-"returns 1 if this node is b:NERDTreeRoot |
|
| 1193 |
-function! s:TreeFileNode.isRoot() |
|
| 1194 |
- if !s:treeExistsForBuf() |
|
| 1195 |
- throw "NERDTree.NoTreeError: No tree exists for the current buffer" |
|
| 1196 |
- endif |
|
| 1197 |
- |
|
| 1198 |
- return self.equals(b:NERDTreeRoot) |
|
| 1199 |
-endfunction |
|
| 1200 |
- |
|
| 1201 |
-"FUNCTION: TreeFileNode.makeRoot() {{{3
|
|
| 1202 |
-"Make this node the root of the tree |
|
| 1203 |
-function! s:TreeFileNode.makeRoot() |
|
| 1204 |
- if self.path.isDirectory |
|
| 1205 |
- let b:NERDTreeRoot = self |
|
| 1206 |
- else |
|
| 1207 |
- call self.cacheParent() |
|
| 1208 |
- let b:NERDTreeRoot = self.parent |
|
| 1209 |
- endif |
|
| 1210 |
- |
|
| 1211 |
- call b:NERDTreeRoot.open() |
|
| 1212 |
- |
|
| 1213 |
- "change dir to the dir of the new root if instructed to |
|
| 1214 |
- if g:NERDTreeChDirMode ==# 2 |
|
| 1215 |
- exec "cd " . b:NERDTreeRoot.path.str({'format': 'Edit'})
|
|
| 1216 |
- endif |
|
| 1217 |
- |
|
| 1218 |
- silent doautocmd User NERDTreeNewRoot |
|
| 1219 |
-endfunction |
|
| 1220 |
-"FUNCTION: TreeFileNode.New(path) {{{3
|
|
| 1221 |
-"Returns a new TreeNode object with the given path and parent |
|
| 1222 |
-" |
|
| 1223 |
-"Args: |
|
| 1224 |
-"path: a path object representing the full filesystem path to the file/dir that the node represents |
|
| 1225 |
-function! s:TreeFileNode.New(path) |
|
| 1226 |
- if a:path.isDirectory |
|
| 1227 |
- return s:TreeDirNode.New(a:path) |
|
| 1228 |
- else |
|
| 1229 |
- let newTreeNode = copy(self) |
|
| 1230 |
- let newTreeNode.path = a:path |
|
| 1231 |
- let newTreeNode.parent = {}
|
|
| 1232 |
- return newTreeNode |
|
| 1233 |
- endif |
|
| 1234 |
-endfunction |
|
| 1235 |
- |
|
| 1236 |
-"FUNCTION: TreeFileNode.open() {{{3
|
|
| 1237 |
-function! s:TreeFileNode.open(...) |
|
| 1238 |
- let opts = a:0 ? a:1 : {}
|
|
| 1239 |
- let opener = s:Opener.New(self.path, opts) |
|
| 1240 |
- call opener.open(self) |
|
| 1241 |
-endfunction |
|
| 1242 |
- |
|
| 1243 |
-"FUNCTION: TreeFileNode.openSplit() {{{3
|
|
| 1244 |
-"Open this node in a new window |
|
| 1245 |
-function! s:TreeFileNode.openSplit() |
|
| 1246 |
- call s:deprecated('TreeFileNode.openSplit', 'is deprecated, use .open() instead.')
|
|
| 1247 |
- call self.open({'where': 'h'})
|
|
| 1248 |
-endfunction |
|
| 1249 |
-"FUNCTION: TreeFileNode.openVSplit() {{{3
|
|
| 1250 |
-"Open this node in a new vertical window |
|
| 1251 |
-function! s:TreeFileNode.openVSplit() |
|
| 1252 |
- call s:deprecated('TreeFileNode.openVSplit', 'is deprecated, use .open() instead.')
|
|
| 1253 |
- call self.open({'where': 'v'})
|
|
| 1254 |
-endfunction |
|
| 1255 |
-"FUNCTION: TreeFileNode.openInNewTab(options) {{{3
|
|
| 1256 |
-function! s:TreeFileNode.openInNewTab(options) |
|
| 1257 |
- echomsg 'TreeFileNode.openInNewTab is deprecated' |
|
| 1258 |
- call self.open(extend({'where': 't'}, a:options))
|
|
| 1259 |
-endfunction |
|
| 1260 |
-"FUNCTION: TreeFileNode.putCursorHere(isJump, recurseUpward){{{3
|
|
| 1261 |
-"Places the cursor on the line number this node is rendered on |
|
| 1262 |
-" |
|
| 1263 |
-"Args: |
|
| 1264 |
-"isJump: 1 if this cursor movement should be counted as a jump by vim |
|
| 1265 |
-"recurseUpward: try to put the cursor on the parent if the this node isnt |
|
| 1266 |
-"visible |
|
| 1267 |
-function! s:TreeFileNode.putCursorHere(isJump, recurseUpward) |
|
| 1268 |
- let ln = self.getLineNum() |
|
| 1269 |
- if ln != -1 |
|
| 1270 |
- if a:isJump |
|
| 1271 |
- mark ' |
|
| 1272 |
- endif |
|
| 1273 |
- call cursor(ln, col("."))
|
|
| 1274 |
- else |
|
| 1275 |
- if a:recurseUpward |
|
| 1276 |
- let node = self |
|
| 1277 |
- while node != {} && node.getLineNum() ==# -1
|
|
| 1278 |
- let node = node.parent |
|
| 1279 |
- call node.open() |
|
| 1280 |
- endwhile |
|
| 1281 |
- call s:renderView() |
|
| 1282 |
- call node.putCursorHere(a:isJump, 0) |
|
| 1283 |
- endif |
|
| 1284 |
- endif |
|
| 1285 |
-endfunction |
|
| 1286 |
- |
|
| 1287 |
-"FUNCTION: TreeFileNode.refresh() {{{3
|
|
| 1288 |
-function! s:TreeFileNode.refresh() |
|
| 1289 |
- call self.path.refresh() |
|
| 1290 |
-endfunction |
|
| 1291 |
-"FUNCTION: TreeFileNode.rename() {{{3
|
|
| 1292 |
-"Calls the rename method for this nodes path obj |
|
| 1293 |
-function! s:TreeFileNode.rename(newName) |
|
| 1294 |
- let newName = substitute(a:newName, '\(\\\|\/\)$', '', '') |
|
| 1295 |
- call self.path.rename(newName) |
|
| 1296 |
- call self.parent.removeChild(self) |
|
| 1297 |
- |
|
| 1298 |
- let parentPath = self.path.getParent() |
|
| 1299 |
- let newParent = b:NERDTreeRoot.findNode(parentPath) |
|
| 1300 |
- |
|
| 1301 |
- if newParent != {}
|
|
| 1302 |
- call newParent.createChild(self.path, 1) |
|
| 1303 |
- call newParent.refresh() |
|
| 1304 |
- endif |
|
| 1305 |
-endfunction |
|
| 1306 |
-"FUNCTION: TreeFileNode.renderToString {{{3
|
|
| 1307 |
-"returns a string representation for this tree to be rendered in the view |
|
| 1308 |
-function! s:TreeFileNode.renderToString() |
|
| 1309 |
- return self._renderToString(0, 0, [], self.getChildCount() ==# 1) |
|
| 1310 |
-endfunction |
|
| 1311 |
- |
|
| 1312 |
- |
|
| 1313 |
-"Args: |
|
| 1314 |
-"depth: the current depth in the tree for this call |
|
| 1315 |
-"drawText: 1 if we should actually draw the line for this node (if 0 then the |
|
| 1316 |
-"child nodes are rendered only) |
|
| 1317 |
-"vertMap: a binary array that indicates whether a vertical bar should be draw |
|
| 1318 |
-"for each depth in the tree |
|
| 1319 |
-"isLastChild:true if this curNode is the last child of its parent |
|
| 1320 |
-function! s:TreeFileNode._renderToString(depth, drawText, vertMap, isLastChild) |
|
| 1321 |
- let output = "" |
|
| 1322 |
- if a:drawText ==# 1 |
|
| 1323 |
- |
|
| 1324 |
- let treeParts = '' |
|
| 1325 |
- |
|
| 1326 |
- "get all the leading spaces and vertical tree parts for this line |
|
| 1327 |
- if a:depth > 1 |
|
| 1328 |
- for j in a:vertMap[0:-2] |
|
| 1329 |
- if g:NERDTreeDirArrows |
|
| 1330 |
- let treeParts = treeParts . ' ' |
|
| 1331 |
- else |
|
| 1332 |
- if j ==# 1 |
|
| 1333 |
- let treeParts = treeParts . '| ' |
|
| 1334 |
- else |
|
| 1335 |
- let treeParts = treeParts . ' ' |
|
| 1336 |
- endif |
|
| 1337 |
- endif |
|
| 1338 |
- endfor |
|
| 1339 |
- endif |
|
| 1340 |
- |
|
| 1341 |
- "get the last vertical tree part for this line which will be different |
|
| 1342 |
- "if this node is the last child of its parent |
|
| 1343 |
- if !g:NERDTreeDirArrows |
|
| 1344 |
- if a:isLastChild |
|
| 1345 |
- let treeParts = treeParts . '`' |
|
| 1346 |
- else |
|
| 1347 |
- let treeParts = treeParts . '|' |
|
| 1348 |
- endif |
|
| 1349 |
- endif |
|
| 1350 |
- |
|
| 1351 |
- "smack the appropriate dir/file symbol on the line before the file/dir |
|
| 1352 |
- "name itself |
|
| 1353 |
- if self.path.isDirectory |
|
| 1354 |
- if self.isOpen |
|
| 1355 |
- if g:NERDTreeDirArrows |
|
| 1356 |
- let treeParts = treeParts . 'â–¾ ' |
|
| 1357 |
- else |
|
| 1358 |
- let treeParts = treeParts . '~' |
|
| 1359 |
- endif |
|
| 1360 |
- else |
|
| 1361 |
- if g:NERDTreeDirArrows |
|
| 1362 |
- let treeParts = treeParts . 'â–¸ ' |
|
| 1363 |
- else |
|
| 1364 |
- let treeParts = treeParts . '+' |
|
| 1365 |
- endif |
|
| 1366 |
- endif |
|
| 1367 |
- else |
|
| 1368 |
- if g:NERDTreeDirArrows |
|
| 1369 |
- let treeParts = treeParts . ' ' |
|
| 1370 |
- else |
|
| 1371 |
- let treeParts = treeParts . '-' |
|
| 1372 |
- endif |
|
| 1373 |
- endif |
|
| 1374 |
- let line = treeParts . self.displayString() |
|
| 1375 |
- |
|
| 1376 |
- let output = output . line . "\n" |
|
| 1377 |
- endif |
|
| 1378 |
- |
|
| 1379 |
- "if the node is an open dir, draw its children |
|
| 1380 |
- if self.path.isDirectory ==# 1 && self.isOpen ==# 1 |
|
| 1381 |
- |
|
| 1382 |
- let childNodesToDraw = self.getVisibleChildren() |
|
| 1383 |
- if len(childNodesToDraw) > 0 |
|
| 1384 |
- |
|
| 1385 |
- "draw all the nodes children except the last |
|
| 1386 |
- let lastIndx = len(childNodesToDraw)-1 |
|
| 1387 |
- if lastIndx > 0 |
|
| 1388 |
- for i in childNodesToDraw[0:lastIndx-1] |
|
| 1389 |
- let output = output . i._renderToString(a:depth + 1, 1, add(copy(a:vertMap), 1), 0) |
|
| 1390 |
- endfor |
|
| 1391 |
- endif |
|
| 1392 |
- |
|
| 1393 |
- "draw the last child, indicating that it IS the last |
|
| 1394 |
- let output = output . childNodesToDraw[lastIndx]._renderToString(a:depth + 1, 1, add(copy(a:vertMap), 0), 1) |
|
| 1395 |
- endif |
|
| 1396 |
- endif |
|
| 1397 |
- |
|
| 1398 |
- return output |
|
| 1399 |
-endfunction |
|
| 1400 |
-"CLASS: TreeDirNode {{{2
|
|
| 1401 |
-"This class is a child of the TreeFileNode class and constitutes the |
|
| 1402 |
-"'Composite' part of the composite design pattern between the treenode |
|
| 1403 |
-"classes. |
|
| 1404 |
-"============================================================ |
|
| 1405 |
-let s:TreeDirNode = copy(s:TreeFileNode) |
|
| 1406 |
-"FUNCTION: TreeDirNode.AbsoluteTreeRoot(){{{3
|
|
| 1407 |
-"class method that returns the highest cached ancestor of the current root |
|
| 1408 |
-function! s:TreeDirNode.AbsoluteTreeRoot() |
|
| 1409 |
- let currentNode = b:NERDTreeRoot |
|
| 1410 |
- while currentNode.parent != {}
|
|
| 1411 |
- let currentNode = currentNode.parent |
|
| 1412 |
- endwhile |
|
| 1413 |
- return currentNode |
|
| 1414 |
-endfunction |
|
| 1415 |
-"FUNCTION: TreeDirNode.activate([options]) {{{3
|
|
| 1416 |
-unlet s:TreeDirNode.activate |
|
| 1417 |
-function! s:TreeDirNode.activate(...) |
|
| 1418 |
- let opts = a:0 ? a:1 : {}
|
|
| 1419 |
- call self.toggleOpen(opts) |
|
| 1420 |
- call s:renderView() |
|
| 1421 |
- call self.putCursorHere(0, 0) |
|
| 1422 |
-endfunction |
|
| 1423 |
-"FUNCTION: TreeDirNode.addChild(treenode, inOrder) {{{3
|
|
| 1424 |
-"Adds the given treenode to the list of children for this node |
|
| 1425 |
-" |
|
| 1426 |
-"Args: |
|
| 1427 |
-"-treenode: the node to add |
|
| 1428 |
-"-inOrder: 1 if the new node should be inserted in sorted order |
|
| 1429 |
-function! s:TreeDirNode.addChild(treenode, inOrder) |
|
| 1430 |
- call add(self.children, a:treenode) |
|
| 1431 |
- let a:treenode.parent = self |
|
| 1432 |
- |
|
| 1433 |
- if a:inOrder |
|
| 1434 |
- call self.sortChildren() |
|
| 1435 |
- endif |
|
| 1436 |
-endfunction |
|
| 1437 |
- |
|
| 1438 |
-"FUNCTION: TreeDirNode.close() {{{3
|
|
| 1439 |
-"Closes this directory |
|
| 1440 |
-function! s:TreeDirNode.close() |
|
| 1441 |
- let self.isOpen = 0 |
|
| 1442 |
-endfunction |
|
| 1443 |
- |
|
| 1444 |
-"FUNCTION: TreeDirNode.closeChildren() {{{3
|
|
| 1445 |
-"Closes all the child dir nodes of this node |
|
| 1446 |
-function! s:TreeDirNode.closeChildren() |
|
| 1447 |
- for i in self.children |
|
| 1448 |
- if i.path.isDirectory |
|
| 1449 |
- call i.close() |
|
| 1450 |
- call i.closeChildren() |
|
| 1451 |
- endif |
|
| 1452 |
- endfor |
|
| 1453 |
-endfunction |
|
| 1454 |
- |
|
| 1455 |
-"FUNCTION: TreeDirNode.createChild(path, inOrder) {{{3
|
|
| 1456 |
-"Instantiates a new child node for this node with the given path. The new |
|
| 1457 |
-"nodes parent is set to this node. |
|
| 1458 |
-" |
|
| 1459 |
-"Args: |
|
| 1460 |
-"path: a Path object that this node will represent/contain |
|
| 1461 |
-"inOrder: 1 if the new node should be inserted in sorted order |
|
| 1462 |
-" |
|
| 1463 |
-"Returns: |
|
| 1464 |
-"the newly created node |
|
| 1465 |
-function! s:TreeDirNode.createChild(path, inOrder) |
|
| 1466 |
- let newTreeNode = s:TreeFileNode.New(a:path) |
|
| 1467 |
- call self.addChild(newTreeNode, a:inOrder) |
|
| 1468 |
- return newTreeNode |
|
| 1469 |
-endfunction |
|
| 1470 |
- |
|
| 1471 |
-"FUNCTION: TreeDirNode.findNode(path) {{{3
|
|
| 1472 |
-"Will find one of the children (recursively) that has the given path |
|
| 1473 |
-" |
|
| 1474 |
-"Args: |
|
| 1475 |
-"path: a path object |
|
| 1476 |
-unlet s:TreeDirNode.findNode |
|
| 1477 |
-function! s:TreeDirNode.findNode(path) |
|
| 1478 |
- if a:path.equals(self.path) |
|
| 1479 |
- return self |
|
| 1480 |
- endif |
|
| 1481 |
- if stridx(a:path.str(), self.path.str(), 0) ==# -1 |
|
| 1482 |
- return {}
|
|
| 1483 |
- endif |
|
| 1484 |
- |
|
| 1485 |
- if self.path.isDirectory |
|
| 1486 |
- for i in self.children |
|
| 1487 |
- let retVal = i.findNode(a:path) |
|
| 1488 |
- if retVal != {}
|
|
| 1489 |
- return retVal |
|
| 1490 |
- endif |
|
| 1491 |
- endfor |
|
| 1492 |
- endif |
|
| 1493 |
- return {}
|
|
| 1494 |
-endfunction |
|
| 1495 |
-"FUNCTION: TreeDirNode.getChildCount() {{{3
|
|
| 1496 |
-"Returns the number of children this node has |
|
| 1497 |
-function! s:TreeDirNode.getChildCount() |
|
| 1498 |
- return len(self.children) |
|
| 1499 |
-endfunction |
|
| 1500 |
- |
|
| 1501 |
-"FUNCTION: TreeDirNode.getChild(path) {{{3
|
|
| 1502 |
-"Returns child node of this node that has the given path or {} if no such node
|
|
| 1503 |
-"exists. |
|
| 1504 |
-" |
|
| 1505 |
-"This function doesnt not recurse into child dir nodes |
|
| 1506 |
-" |
|
| 1507 |
-"Args: |
|
| 1508 |
-"path: a path object |
|
| 1509 |
-function! s:TreeDirNode.getChild(path) |
|
| 1510 |
- if stridx(a:path.str(), self.path.str(), 0) ==# -1 |
|
| 1511 |
- return {}
|
|
| 1512 |
- endif |
|
| 1513 |
- |
|
| 1514 |
- let index = self.getChildIndex(a:path) |
|
| 1515 |
- if index ==# -1 |
|
| 1516 |
- return {}
|
|
| 1517 |
- else |
|
| 1518 |
- return self.children[index] |
|
| 1519 |
- endif |
|
| 1520 |
- |
|
| 1521 |
-endfunction |
|
| 1522 |
- |
|
| 1523 |
-"FUNCTION: TreeDirNode.getChildByIndex(indx, visible) {{{3
|
|
| 1524 |
-"returns the child at the given index |
|
| 1525 |
-"Args: |
|
| 1526 |
-"indx: the index to get the child from |
|
| 1527 |
-"visible: 1 if only the visible children array should be used, 0 if all the |
|
| 1528 |
-"children should be searched. |
|
| 1529 |
-function! s:TreeDirNode.getChildByIndex(indx, visible) |
|
| 1530 |
- let array_to_search = a:visible? self.getVisibleChildren() : self.children |
|
| 1531 |
- if a:indx > len(array_to_search) |
|
| 1532 |
- throw "NERDTree.InvalidArgumentsError: Index is out of bounds." |
|
| 1533 |
- endif |
|
| 1534 |
- return array_to_search[a:indx] |
|
| 1535 |
-endfunction |
|
| 1536 |
- |
|
| 1537 |
-"FUNCTION: TreeDirNode.getChildIndex(path) {{{3
|
|
| 1538 |
-"Returns the index of the child node of this node that has the given path or |
|
| 1539 |
-"-1 if no such node exists. |
|
| 1540 |
-" |
|
| 1541 |
-"This function doesnt not recurse into child dir nodes |
|
| 1542 |
-" |
|
| 1543 |
-"Args: |
|
| 1544 |
-"path: a path object |
|
| 1545 |
-function! s:TreeDirNode.getChildIndex(path) |
|
| 1546 |
- if stridx(a:path.str(), self.path.str(), 0) ==# -1 |
|
| 1547 |
- return -1 |
|
| 1548 |
- endif |
|
| 1549 |
- |
|
| 1550 |
- "do a binary search for the child |
|
| 1551 |
- let a = 0 |
|
| 1552 |
- let z = self.getChildCount() |
|
| 1553 |
- while a < z |
|
| 1554 |
- let mid = (a+z)/2 |
|
| 1555 |
- let diff = a:path.compareTo(self.children[mid].path) |
|
| 1556 |
- |
|
| 1557 |
- if diff ==# -1 |
|
| 1558 |
- let z = mid |
|
| 1559 |
- elseif diff ==# 1 |
|
| 1560 |
- let a = mid+1 |
|
| 1561 |
- else |
|
| 1562 |
- return mid |
|
| 1563 |
- endif |
|
| 1564 |
- endwhile |
|
| 1565 |
- return -1 |
|
| 1566 |
-endfunction |
|
| 1567 |
- |
|
| 1568 |
-"FUNCTION: TreeDirNode.GetSelected() {{{3
|
|
| 1569 |
-"Returns the current node if it is a dir node, or else returns the current |
|
| 1570 |
-"nodes parent |
|
| 1571 |
-unlet s:TreeDirNode.GetSelected |
|
| 1572 |
-function! s:TreeDirNode.GetSelected() |
|
| 1573 |
- let currentDir = s:TreeFileNode.GetSelected() |
|
| 1574 |
- if currentDir != {} && !currentDir.isRoot()
|
|
| 1575 |
- if currentDir.path.isDirectory ==# 0 |
|
| 1576 |
- let currentDir = currentDir.parent |
|
| 1577 |
- endif |
|
| 1578 |
- endif |
|
| 1579 |
- return currentDir |
|
| 1580 |
-endfunction |
|
| 1581 |
-"FUNCTION: TreeDirNode.getVisibleChildCount() {{{3
|
|
| 1582 |
-"Returns the number of visible children this node has |
|
| 1583 |
-function! s:TreeDirNode.getVisibleChildCount() |
|
| 1584 |
- return len(self.getVisibleChildren()) |
|
| 1585 |
-endfunction |
|
| 1586 |
- |
|
| 1587 |
-"FUNCTION: TreeDirNode.getVisibleChildren() {{{3
|
|
| 1588 |
-"Returns a list of children to display for this node, in the correct order |
|
| 1589 |
-" |
|
| 1590 |
-"Return: |
|
| 1591 |
-"an array of treenodes |
|
| 1592 |
-function! s:TreeDirNode.getVisibleChildren() |
|
| 1593 |
- let toReturn = [] |
|
| 1594 |
- for i in self.children |
|
| 1595 |
- if i.path.ignore() ==# 0 |
|
| 1596 |
- call add(toReturn, i) |
|
| 1597 |
- endif |
|
| 1598 |
- endfor |
|
| 1599 |
- return toReturn |
|
| 1600 |
-endfunction |
|
| 1601 |
- |
|
| 1602 |
-"FUNCTION: TreeDirNode.hasVisibleChildren() {{{3
|
|
| 1603 |
-"returns 1 if this node has any childre, 0 otherwise.. |
|
| 1604 |
-function! s:TreeDirNode.hasVisibleChildren() |
|
| 1605 |
- return self.getVisibleChildCount() != 0 |
|
| 1606 |
-endfunction |
|
| 1607 |
- |
|
| 1608 |
-"FUNCTION: TreeDirNode._initChildren() {{{3
|
|
| 1609 |
-"Removes all childen from this node and re-reads them |
|
| 1610 |
-" |
|
| 1611 |
-"Args: |
|
| 1612 |
-"silent: 1 if the function should not echo any "please wait" messages for |
|
| 1613 |
-"large directories |
|
| 1614 |
-" |
|
| 1615 |
-"Return: the number of child nodes read |
|
| 1616 |
-function! s:TreeDirNode._initChildren(silent) |
|
| 1617 |
- "remove all the current child nodes |
|
| 1618 |
- let self.children = [] |
|
| 1619 |
- |
|
| 1620 |
- "get an array of all the files in the nodes dir |
|
| 1621 |
- let dir = self.path |
|
| 1622 |
- let globDir = dir.str({'format': 'Glob'})
|
|
| 1623 |
- |
|
| 1624 |
- if version >= 703 |
|
| 1625 |
- let filesStr = globpath(globDir, '*', 1) . "\n" . globpath(globDir, '.*', 1) |
|
| 1626 |
- else |
|
| 1627 |
- let filesStr = globpath(globDir, '*') . "\n" . globpath(globDir, '.*') |
|
| 1628 |
- endif |
|
| 1629 |
- |
|
| 1630 |
- let files = split(filesStr, "\n") |
|
| 1631 |
- |
|
| 1632 |
- if !a:silent && len(files) > g:NERDTreeNotificationThreshold |
|
| 1633 |
- call s:echo("Please wait, caching a large dir ...")
|
|
| 1634 |
- endif |
|
| 1635 |
- |
|
| 1636 |
- let invalidFilesFound = 0 |
|
| 1637 |
- for i in files |
|
| 1638 |
- |
|
| 1639 |
- "filter out the .. and . directories |
|
| 1640 |
- "Note: we must match .. AND ../ cos sometimes the globpath returns |
|
| 1641 |
- "../ for path with strange chars (eg $) |
|
| 1642 |
- if i !~# '\/\.\.\/\?$' && i !~# '\/\.\/\?$' |
|
| 1643 |
- |
|
| 1644 |
- "put the next file in a new node and attach it |
|
| 1645 |
- try |
|
| 1646 |
- let path = s:Path.New(i) |
|
| 1647 |
- call self.createChild(path, 0) |
|
| 1648 |
- catch /^NERDTree.\(InvalidArguments\|InvalidFiletype\)Error/ |
|
| 1649 |
- let invalidFilesFound += 1 |
|
| 1650 |
- endtry |
|
| 1651 |
- endif |
|
| 1652 |
- endfor |
|
| 1653 |
- |
|
| 1654 |
- call self.sortChildren() |
|
| 1655 |
- |
|
| 1656 |
- if !a:silent && len(files) > g:NERDTreeNotificationThreshold |
|
| 1657 |
- call s:echo("Please wait, caching a large dir ... DONE (". self.getChildCount() ." nodes cached).")
|
|
| 1658 |
- endif |
|
| 1659 |
- |
|
| 1660 |
- if invalidFilesFound |
|
| 1661 |
- call s:echoWarning(invalidFilesFound . " file(s) could not be loaded into the NERD tree") |
|
| 1662 |
- endif |
|
| 1663 |
- return self.getChildCount() |
|
| 1664 |
-endfunction |
|
| 1665 |
-"FUNCTION: TreeDirNode.New(path) {{{3
|
|
| 1666 |
-"Returns a new TreeNode object with the given path and parent |
|
| 1667 |
-" |
|
| 1668 |
-"Args: |
|
| 1669 |
-"path: a path object representing the full filesystem path to the file/dir that the node represents |
|
| 1670 |
-unlet s:TreeDirNode.New |
|
| 1671 |
-function! s:TreeDirNode.New(path) |
|
| 1672 |
- if a:path.isDirectory != 1 |
|
| 1673 |
- throw "NERDTree.InvalidArgumentsError: A TreeDirNode object must be instantiated with a directory Path object." |
|
| 1674 |
- endif |
|
| 1675 |
- |
|
| 1676 |
- let newTreeNode = copy(self) |
|
| 1677 |
- let newTreeNode.path = a:path |
|
| 1678 |
- |
|
| 1679 |
- let newTreeNode.isOpen = 0 |
|
| 1680 |
- let newTreeNode.children = [] |
|
| 1681 |
- |
|
| 1682 |
- let newTreeNode.parent = {}
|
|
| 1683 |
- |
|
| 1684 |
- return newTreeNode |
|
| 1685 |
-endfunction |
|
| 1686 |
-"FUNCTION: TreeDirNode.open([opts]) {{{3
|
|
| 1687 |
-"Open the dir in the current tree or in a new tree elsewhere. |
|
| 1688 |
-" |
|
| 1689 |
-"If opening in the current tree, return the number of cached nodes. |
|
| 1690 |
-unlet s:TreeDirNode.open |
|
| 1691 |
-function! s:TreeDirNode.open(...) |
|
| 1692 |
- let opts = a:0 ? a:1 : {}
|
|
| 1693 |
- |
|
| 1694 |
- if has_key(opts, 'where') && !empty(opts['where']) |
|
| 1695 |
- let opener = s:Opener.New(self.path, opts) |
|
| 1696 |
- call opener.open(self) |
|
| 1697 |
- else |
|
| 1698 |
- let self.isOpen = 1 |
|
| 1699 |
- if self.children ==# [] |
|
| 1700 |
- return self._initChildren(0) |
|
| 1701 |
- else |
|
| 1702 |
- return 0 |
|
| 1703 |
- endif |
|
| 1704 |
- endif |
|
| 1705 |
-endfunction |
|
| 1706 |
-"FUNCTION: TreeDirNode.openAlong([opts]) {{{3
|
|
| 1707 |
-"recursive open the dir if it has only one directory child. |
|
| 1708 |
-" |
|
| 1709 |
-"return the level of opened directories. |
|
| 1710 |
-function! s:TreeDirNode.openAlong(...) |
|
| 1711 |
- let opts = a:0 ? a:1 : {}
|
|
| 1712 |
- let level = 0 |
|
| 1713 |
- |
|
| 1714 |
- let node = self |
|
| 1715 |
- while node.path.isDirectory |
|
| 1716 |
- call node.open(opts) |
|
| 1717 |
- let level += 1 |
|
| 1718 |
- if node.getVisibleChildCount() == 1 |
|
| 1719 |
- let node = node.getChildByIndex(0, 1) |
|
| 1720 |
- else |
|
| 1721 |
- break |
|
| 1722 |
- endif |
|
| 1723 |
- endwhile |
|
| 1724 |
- return level |
|
| 1725 |
-endfunction |
|
| 1726 |
-" FUNCTION: TreeDirNode.openExplorer() {{{3
|
|
| 1727 |
-" opens an explorer window for this node in the previous window (could be a |
|
| 1728 |
-" nerd tree or a netrw) |
|
| 1729 |
-function! s:TreeDirNode.openExplorer() |
|
| 1730 |
- call self.open({'where': 'p'})
|
|
| 1731 |
-endfunction |
|
| 1732 |
-"FUNCTION: TreeDirNode.openInNewTab(options) {{{3
|
|
| 1733 |
-unlet s:TreeDirNode.openInNewTab |
|
| 1734 |
-function! s:TreeDirNode.openInNewTab(options) |
|
| 1735 |
- call s:deprecated('TreeDirNode.openInNewTab', 'is deprecated, use open() instead')
|
|
| 1736 |
- call self.open({'where': 't'})
|
|
| 1737 |
-endfunction |
|
| 1738 |
-"FUNCTION: TreeDirNode._openInNewTab() {{{3
|
|
| 1739 |
-function! s:TreeDirNode._openInNewTab() |
|
| 1740 |
- tabnew |
|
| 1741 |
- call s:initNerdTree(self.path.str()) |
|
| 1742 |
-endfunction |
|
| 1743 |
-"FUNCTION: TreeDirNode.openRecursively() {{{3
|
|
| 1744 |
-"Opens this treenode and all of its children whose paths arent 'ignored' |
|
| 1745 |
-"because of the file filters. |
|
| 1746 |
-" |
|
| 1747 |
-"This method is actually a wrapper for the OpenRecursively2 method which does |
|
| 1748 |
-"the work. |
|
| 1749 |
-function! s:TreeDirNode.openRecursively() |
|
| 1750 |
- call self._openRecursively2(1) |
|
| 1751 |
-endfunction |
|
| 1752 |
- |
|
| 1753 |
-"FUNCTION: TreeDirNode._openRecursively2() {{{3
|
|
| 1754 |
-"Opens this all children of this treenode recursively if either: |
|
| 1755 |
-" *they arent filtered by file filters |
|
| 1756 |
-" *a:forceOpen is 1 |
|
| 1757 |
-" |
|
| 1758 |
-"Args: |
|
| 1759 |
-"forceOpen: 1 if this node should be opened regardless of file filters |
|
| 1760 |
-function! s:TreeDirNode._openRecursively2(forceOpen) |
|
| 1761 |
- if self.path.ignore() ==# 0 || a:forceOpen |
|
| 1762 |
- let self.isOpen = 1 |
|
| 1763 |
- if self.children ==# [] |
|
| 1764 |
- call self._initChildren(1) |
|
| 1765 |
- endif |
|
| 1766 |
- |
|
| 1767 |
- for i in self.children |
|
| 1768 |
- if i.path.isDirectory ==# 1 |
|
| 1769 |
- call i._openRecursively2(0) |
|
| 1770 |
- endif |
|
| 1771 |
- endfor |
|
| 1772 |
- endif |
|
| 1773 |
-endfunction |
|
| 1774 |
- |
|
| 1775 |
-"FUNCTION: TreeDirNode.refresh() {{{3
|
|
| 1776 |
-unlet s:TreeDirNode.refresh |
|
| 1777 |
-function! s:TreeDirNode.refresh() |
|
| 1778 |
- call self.path.refresh() |
|
| 1779 |
- |
|
| 1780 |
- "if this node was ever opened, refresh its children |
|
| 1781 |
- if self.isOpen || !empty(self.children) |
|
| 1782 |
- "go thru all the files/dirs under this node |
|
| 1783 |
- let newChildNodes = [] |
|
| 1784 |
- let invalidFilesFound = 0 |
|
| 1785 |
- let dir = self.path |
|
| 1786 |
- let globDir = dir.str({'format': 'Glob'})
|
|
| 1787 |
- let filesStr = globpath(globDir, '*') . "\n" . globpath(globDir, '.*') |
|
| 1788 |
- let files = split(filesStr, "\n") |
|
| 1789 |
- for i in files |
|
| 1790 |
- "filter out the .. and . directories |
|
| 1791 |
- "Note: we must match .. AND ../ cos sometimes the globpath returns |
|
| 1792 |
- "../ for path with strange chars (eg $) |
|
| 1793 |
- if i !~# '\/\.\.\/\?$' && i !~# '\/\.\/\?$' |
|
| 1794 |
- |
|
| 1795 |
- try |
|
| 1796 |
- "create a new path and see if it exists in this nodes children |
|
| 1797 |
- let path = s:Path.New(i) |
|
| 1798 |
- let newNode = self.getChild(path) |
|
| 1799 |
- if newNode != {}
|
|
| 1800 |
- call newNode.refresh() |
|
| 1801 |
- call add(newChildNodes, newNode) |
|
| 1802 |
- |
|
| 1803 |
- "the node doesnt exist so create it |
|
| 1804 |
- else |
|
| 1805 |
- let newNode = s:TreeFileNode.New(path) |
|
| 1806 |
- let newNode.parent = self |
|
| 1807 |
- call add(newChildNodes, newNode) |
|
| 1808 |
- endif |
|
| 1809 |
- |
|
| 1810 |
- |
|
| 1811 |
- catch /^NERDTree.InvalidArgumentsError/ |
|
| 1812 |
- let invalidFilesFound = 1 |
|
| 1813 |
- endtry |
|
| 1814 |
- endif |
|
| 1815 |
- endfor |
|
| 1816 |
- |
|
| 1817 |
- "swap this nodes children out for the children we just read/refreshed |
|
| 1818 |
- let self.children = newChildNodes |
|
| 1819 |
- call self.sortChildren() |
|
| 1820 |
- |
|
| 1821 |
- if invalidFilesFound |
|
| 1822 |
- call s:echoWarning("some files could not be loaded into the NERD tree")
|
|
| 1823 |
- endif |
|
| 1824 |
- endif |
|
| 1825 |
-endfunction |
|
| 1826 |
- |
|
| 1827 |
-"FUNCTION: TreeDirNode.reveal(path) {{{3
|
|
| 1828 |
-"reveal the given path, i.e. cache and open all treenodes needed to display it |
|
| 1829 |
-"in the UI |
|
| 1830 |
-function! s:TreeDirNode.reveal(path) |
|
| 1831 |
- if !a:path.isUnder(self.path) |
|
| 1832 |
- throw "NERDTree.InvalidArgumentsError: " . a:path.str() . " should be under " . self.path.str() |
|
| 1833 |
- endif |
|
| 1834 |
- |
|
| 1835 |
- call self.open() |
|
| 1836 |
- |
|
| 1837 |
- if self.path.equals(a:path.getParent()) |
|
| 1838 |
- let n = self.findNode(a:path) |
|
| 1839 |
- call s:renderView() |
|
| 1840 |
- call n.putCursorHere(1,0) |
|
| 1841 |
- return |
|
| 1842 |
- endif |
|
| 1843 |
- |
|
| 1844 |
- let p = a:path |
|
| 1845 |
- while !p.getParent().equals(self.path) |
|
| 1846 |
- let p = p.getParent() |
|
| 1847 |
- endwhile |
|
| 1848 |
- |
|
| 1849 |
- let n = self.findNode(p) |
|
| 1850 |
- call n.reveal(a:path) |
|
| 1851 |
-endfunction |
|
| 1852 |
-"FUNCTION: TreeDirNode.removeChild(treenode) {{{3
|
|
| 1853 |
-" |
|
| 1854 |
-"Removes the given treenode from this nodes set of children |
|
| 1855 |
-" |
|
| 1856 |
-"Args: |
|
| 1857 |
-"treenode: the node to remove |
|
| 1858 |
-" |
|
| 1859 |
-"Throws a NERDTree.ChildNotFoundError if the given treenode is not found |
|
| 1860 |
-function! s:TreeDirNode.removeChild(treenode) |
|
| 1861 |
- for i in range(0, self.getChildCount()-1) |
|
| 1862 |
- if self.children[i].equals(a:treenode) |
|
| 1863 |
- call remove(self.children, i) |
|
| 1864 |
- return |
|
| 1865 |
- endif |
|
| 1866 |
- endfor |
|
| 1867 |
- |
|
| 1868 |
- throw "NERDTree.ChildNotFoundError: child node was not found" |
|
| 1869 |
-endfunction |
|
| 1870 |
- |
|
| 1871 |
-"FUNCTION: TreeDirNode.sortChildren() {{{3
|
|
| 1872 |
-" |
|
| 1873 |
-"Sorts the children of this node according to alphabetical order and the |
|
| 1874 |
-"directory priority. |
|
| 1875 |
-" |
|
| 1876 |
-function! s:TreeDirNode.sortChildren() |
|
| 1877 |
- let CompareFunc = function("s:compareNodes")
|
|
| 1878 |
- call sort(self.children, CompareFunc) |
|
| 1879 |
-endfunction |
|
| 1880 |
- |
|
| 1881 |
-"FUNCTION: TreeDirNode.toggleOpen([options]) {{{3
|
|
| 1882 |
-"Opens this directory if it is closed and vice versa |
|
| 1883 |
-function! s:TreeDirNode.toggleOpen(...) |
|
| 1884 |
- let opts = a:0 ? a:1 : {}
|
|
| 1885 |
- if self.isOpen ==# 1 |
|
| 1886 |
- call self.close() |
|
| 1887 |
- else |
|
| 1888 |
- if g:NERDTreeCasadeOpenSingleChildDir == 0 |
|
| 1889 |
- call self.open(opts) |
|
| 1890 |
- else |
|
| 1891 |
- call self.openAlong(opts) |
|
| 1892 |
- endif |
|
| 1893 |
- endif |
|
| 1894 |
-endfunction |
|
| 1895 |
-"FUNCTION: TreeDirNode.transplantChild(newNode) {{{3
|
|
| 1896 |
-"Replaces the child of this with the given node (where the child node's full |
|
| 1897 |
-"path matches a:newNode's fullpath). The search for the matching node is |
|
| 1898 |
-"non-recursive |
|
| 1899 |
-" |
|
| 1900 |
-"Arg: |
|
| 1901 |
-"newNode: the node to graft into the tree |
|
| 1902 |
-function! s:TreeDirNode.transplantChild(newNode) |
|
| 1903 |
- for i in range(0, self.getChildCount()-1) |
|
| 1904 |
- if self.children[i].equals(a:newNode) |
|
| 1905 |
- let self.children[i] = a:newNode |
|
| 1906 |
- let a:newNode.parent = self |
|
| 1907 |
- break |
|
| 1908 |
- endif |
|
| 1909 |
- endfor |
|
| 1910 |
-endfunction |
|
| 1911 |
-"============================================================ |
|
| 1912 |
-"CLASS: Opener {{{2
|
|
| 1913 |
-"============================================================ |
|
| 1914 |
-let s:Opener = {}
|
|
| 1915 |
- |
|
| 1916 |
-"FUNCTION: Opener._checkToCloseTree(newtab) {{{3
|
|
| 1917 |
-"Check the class options and global options (i.e. NERDTreeQuitOnOpen) to see |
|
| 1918 |
-"if the tree should be closed now. |
|
| 1919 |
-" |
|
| 1920 |
-"Args: |
|
| 1921 |
-"a:newtab - boolean. If set, only close the tree now if we are opening the |
|
| 1922 |
-"target in a new tab. This is needed because we have to close tree before we |
|
| 1923 |
-"leave the tab |
|
| 1924 |
-function! s:Opener._checkToCloseTree(newtab) |
|
| 1925 |
- if self._keepopen |
|
| 1926 |
- return |
|
| 1927 |
- endif |
|
| 1928 |
- |
|
| 1929 |
- if (a:newtab && self._where == 't') || !a:newtab |
|
| 1930 |
- call s:closeTreeIfQuitOnOpen() |
|
| 1931 |
- endif |
|
| 1932 |
-endfunction |
|
| 1933 |
- |
|
| 1934 |
-"FUNCTION: Opener._gotoTargetWin() {{{3
|
|
| 1935 |
-function! s:Opener._gotoTargetWin() |
|
| 1936 |
- if b:NERDTreeType ==# "secondary" |
|
| 1937 |
- if self._where == 'v' |
|
| 1938 |
- vsplit |
|
| 1939 |
- elseif self._where == 'h' |
|
| 1940 |
- split |
|
| 1941 |
- elseif self._where == 't' |
|
| 1942 |
- tabnew |
|
| 1943 |
- endif |
|
| 1944 |
- else |
|
| 1945 |
- call self._checkToCloseTree(1) |
|
| 1946 |
- |
|
| 1947 |
- if self._where == 'v' |
|
| 1948 |
- call self._newVSplit() |
|
| 1949 |
- elseif self._where == 'h' |
|
| 1950 |
- call self._newSplit() |
|
| 1951 |
- elseif self._where == 't' |
|
| 1952 |
- tabnew |
|
| 1953 |
- elseif self._where == 'p' |
|
| 1954 |
- call self._previousWindow() |
|
| 1955 |
- endif |
|
| 1956 |
- |
|
| 1957 |
- call self._checkToCloseTree(0) |
|
| 1958 |
- endif |
|
| 1959 |
-endfunction |
|
| 1960 |
- |
|
| 1961 |
-"FUNCTION: Opener.New(path, opts) {{{3
|
|
| 1962 |
-"Args: |
|
| 1963 |
-" |
|
| 1964 |
-"a:path: The path object that is to be opened. |
|
| 1965 |
-" |
|
| 1966 |
-"a:opts: |
|
| 1967 |
-" |
|
| 1968 |
-"A dictionary containing the following keys (all optional): |
|
| 1969 |
-" 'where': Specifies whether the node should be opened in new split/tab or in |
|
| 1970 |
-" the previous window. Can be either 'v' or 'h' or 't' (for open in |
|
| 1971 |
-" new tab) |
|
| 1972 |
-" 'reuse': if a window is displaying the file then jump the cursor there |
|
| 1973 |
-" 'keepopen': dont close the tree window |
|
| 1974 |
-" 'stay': open the file, but keep the cursor in the tree win |
|
| 1975 |
-function! s:Opener.New(path, opts) |
|
| 1976 |
- let newObj = copy(self) |
|
| 1977 |
- |
|
| 1978 |
- let newObj._path = a:path |
|
| 1979 |
- let newObj._stay = s:has_opt(a:opts, 'stay') |
|
| 1980 |
- let newObj._reuse = s:has_opt(a:opts, 'reuse') |
|
| 1981 |
- let newObj._keepopen = s:has_opt(a:opts, 'keepopen') |
|
| 1982 |
- let newObj._where = has_key(a:opts, 'where') ? a:opts['where'] : '' |
|
| 1983 |
- let newObj._treetype = b:NERDTreeType |
|
| 1984 |
- call newObj._saveCursorPos() |
|
| 1985 |
- |
|
| 1986 |
- return newObj |
|
| 1987 |
-endfunction |
|
| 1988 |
- |
|
| 1989 |
-"FUNCTION: Opener._newSplit() {{{3
|
|
| 1990 |
-function! s:Opener._newSplit() |
|
| 1991 |
- " Save the user's settings for splitbelow and splitright |
|
| 1992 |
- let savesplitbelow=&splitbelow |
|
| 1993 |
- let savesplitright=&splitright |
|
| 1994 |
- |
|
| 1995 |
- " 'there' will be set to a command to move from the split window |
|
| 1996 |
- " back to the explorer window |
|
| 1997 |
- " |
|
| 1998 |
- " 'back' will be set to a command to move from the explorer window |
|
| 1999 |
- " back to the newly split window |
|
| 2000 |
- " |
|
| 2001 |
- " 'right' and 'below' will be set to the settings needed for |
|
| 2002 |
- " splitbelow and splitright IF the explorer is the only window. |
|
| 2003 |
- " |
|
| 2004 |
- let there= g:NERDTreeWinPos ==# "left" ? "wincmd h" : "wincmd l" |
|
| 2005 |
- let back = g:NERDTreeWinPos ==# "left" ? "wincmd l" : "wincmd h" |
|
| 2006 |
- let right= g:NERDTreeWinPos ==# "left" |
|
| 2007 |
- let below=0 |
|
| 2008 |
- |
|
| 2009 |
- " Attempt to go to adjacent window |
|
| 2010 |
- call s:exec(back) |
|
| 2011 |
- |
|
| 2012 |
- let onlyOneWin = (winnr("$") ==# 1)
|
|
| 2013 |
- |
|
| 2014 |
- " If no adjacent window, set splitright and splitbelow appropriately |
|
| 2015 |
- if onlyOneWin |
|
| 2016 |
- let &splitright=right |
|
| 2017 |
- let &splitbelow=below |
|
| 2018 |
- else |
|
| 2019 |
- " found adjacent window - invert split direction |
|
| 2020 |
- let &splitright=!right |
|
| 2021 |
- let &splitbelow=!below |
|
| 2022 |
- endif |
|
| 2023 |
- |
|
| 2024 |
- let splitMode = onlyOneWin ? "vertical" : "" |
|
| 2025 |
- |
|
| 2026 |
- " Open the new window |
|
| 2027 |
- try |
|
| 2028 |
- exec(splitMode." sp ") |
|
| 2029 |
- catch /^Vim\%((\a\+)\)\=:E37/ |
|
| 2030 |
- call s:putCursorInTreeWin() |
|
| 2031 |
- throw "NERDTree.FileAlreadyOpenAndModifiedError: ". self._path.str() ." is already open and modified." |
|
| 2032 |
- catch /^Vim\%((\a\+)\)\=:/ |
|
| 2033 |
- "do nothing |
|
| 2034 |
- endtry |
|
| 2035 |
- |
|
| 2036 |
- "resize the tree window if no other window was open before |
|
| 2037 |
- if onlyOneWin |
|
| 2038 |
- let size = exists("b:NERDTreeOldWindowSize") ? b:NERDTreeOldWindowSize : g:NERDTreeWinSize
|
|
| 2039 |
- call s:exec(there) |
|
| 2040 |
- exec("silent ". splitMode ." resize ". size)
|
|
| 2041 |
- call s:exec('wincmd p')
|
|
| 2042 |
- endif |
|
| 2043 |
- |
|
| 2044 |
- " Restore splitmode settings |
|
| 2045 |
- let &splitbelow=savesplitbelow |
|
| 2046 |
- let &splitright=savesplitright |
|
| 2047 |
-endfunction |
|
| 2048 |
- |
|
| 2049 |
-"FUNCTION: Opener._newVSplit() {{{3
|
|
| 2050 |
-function! s:Opener._newVSplit() |
|
| 2051 |
- let winwidth = winwidth(".")
|
|
| 2052 |
- if winnr("$")==#1
|
|
| 2053 |
- let winwidth = g:NERDTreeWinSize |
|
| 2054 |
- endif |
|
| 2055 |
- |
|
| 2056 |
- call s:exec("wincmd p")
|
|
| 2057 |
- vnew |
|
| 2058 |
- |
|
| 2059 |
- "resize the nerd tree back to the original size |
|
| 2060 |
- call s:putCursorInTreeWin() |
|
| 2061 |
- exec("silent vertical resize ". winwidth)
|
|
| 2062 |
- call s:exec('wincmd p')
|
|
| 2063 |
-endfunction |
|
| 2064 |
- |
|
| 2065 |
-"FUNCTION: Opener.open(target) {{{3
|
|
| 2066 |
-function! s:Opener.open(target) |
|
| 2067 |
- if self._path.isDirectory |
|
| 2068 |
- call self._openDirectory(a:target) |
|
| 2069 |
- else |
|
| 2070 |
- call self._openFile() |
|
| 2071 |
- endif |
|
| 2072 |
-endfunction |
|
| 2073 |
- |
|
| 2074 |
-"FUNCTION: Opener._openFile() {{{3
|
|
| 2075 |
-function! s:Opener._openFile() |
|
| 2076 |
- if self._reuse && self._reuseWindow() |
|
| 2077 |
- return |
|
| 2078 |
- endif |
|
| 2079 |
- |
|
| 2080 |
- call self._gotoTargetWin() |
|
| 2081 |
- |
|
| 2082 |
- if self._treetype ==# "secondary" |
|
| 2083 |
- call self._path.edit() |
|
| 2084 |
- else |
|
| 2085 |
- call self._path.edit() |
|
| 2086 |
- |
|
| 2087 |
- |
|
| 2088 |
- if self._stay |
|
| 2089 |
- call self._restoreCursorPos() |
|
| 2090 |
- endif |
|
| 2091 |
- endif |
|
| 2092 |
-endfunction |
|
| 2093 |
- |
|
| 2094 |
-"FUNCTION: Opener._openDirectory(node) {{{3
|
|
| 2095 |
-function! s:Opener._openDirectory(node) |
|
| 2096 |
- if self._treetype ==# "secondary" |
|
| 2097 |
- call self._gotoTargetWin() |
|
| 2098 |
- call s:initNerdTreeInPlace(a:node.path.str()) |
|
| 2099 |
- else |
|
| 2100 |
- call self._gotoTargetWin() |
|
| 2101 |
- if empty(self._where) |
|
| 2102 |
- call a:node.makeRoot() |
|
| 2103 |
- call s:renderView() |
|
| 2104 |
- call a:node.putCursorHere(0, 0) |
|
| 2105 |
- elseif self._where == 't' |
|
| 2106 |
- call s:initNerdTree(a:node.path.str()) |
|
| 2107 |
- else |
|
| 2108 |
- call s:initNerdTreeInPlace(a:node.path.str()) |
|
| 2109 |
- endif |
|
| 2110 |
- endif |
|
| 2111 |
- |
|
| 2112 |
- if self._stay |
|
| 2113 |
- call self._restoreCursorPos() |
|
| 2114 |
- endif |
|
| 2115 |
-endfunction |
|
| 2116 |
- |
|
| 2117 |
-"FUNCTION: Opener._previousWindow() {{{3
|
|
| 2118 |
-function! s:Opener._previousWindow() |
|
| 2119 |
- if !s:isWindowUsable(winnr("#")) && s:firstUsableWindow() ==# -1
|
|
| 2120 |
- call self._newSplit() |
|
| 2121 |
- else |
|
| 2122 |
- try |
|
| 2123 |
- if !s:isWindowUsable(winnr("#"))
|
|
| 2124 |
- call s:exec(s:firstUsableWindow() . "wincmd w") |
|
| 2125 |
- else |
|
| 2126 |
- call s:exec('wincmd p')
|
|
| 2127 |
- endif |
|
| 2128 |
- catch /^Vim\%((\a\+)\)\=:E37/ |
|
| 2129 |
- call s:putCursorInTreeWin() |
|
| 2130 |
- throw "NERDTree.FileAlreadyOpenAndModifiedError: ". self._path.str() ." is already open and modified." |
|
| 2131 |
- catch /^Vim\%((\a\+)\)\=:/ |
|
| 2132 |
- echo v:exception |
|
| 2133 |
- endtry |
|
| 2134 |
- endif |
|
| 2135 |
-endfunction |
|
| 2136 |
- |
|
| 2137 |
-"FUNCTION: Opener._restoreCursorPos(){{{3
|
|
| 2138 |
-function! s:Opener._restoreCursorPos() |
|
| 2139 |
- call s:exec('normal ' . self._tabnr . 'gt')
|
|
| 2140 |
- call s:exec(bufwinnr(self._bufnr) . 'wincmd w') |
|
| 2141 |
-endfunction |
|
| 2142 |
- |
|
| 2143 |
-"FUNCTION: Opener._reuseWindow(){{{3
|
|
| 2144 |
-"put the cursor in the first window we find for this file |
|
| 2145 |
-" |
|
| 2146 |
-"return 1 if we were successful |
|
| 2147 |
-function! s:Opener._reuseWindow() |
|
| 2148 |
- "check the current tab for the window |
|
| 2149 |
- let winnr = bufwinnr('^' . self._path.str() . '$')
|
|
| 2150 |
- if winnr != -1 |
|
| 2151 |
- call s:exec(winnr . "wincmd w") |
|
| 2152 |
- call self._checkToCloseTree(0) |
|
| 2153 |
- return 1 |
|
| 2154 |
- else |
|
| 2155 |
- "check other tabs |
|
| 2156 |
- let tabnr = self._path.tabnr() |
|
| 2157 |
- if tabnr |
|
| 2158 |
- call self._checkToCloseTree(1) |
|
| 2159 |
- call s:exec('normal! ' . tabnr . 'gt')
|
|
| 2160 |
- let winnr = bufwinnr('^' . self._path.str() . '$')
|
|
| 2161 |
- call s:exec(winnr . "wincmd w") |
|
| 2162 |
- return 1 |
|
| 2163 |
- endif |
|
| 2164 |
- endif |
|
| 2165 |
- return 0 |
|
| 2166 |
-endfunction |
|
| 2167 |
- |
|
| 2168 |
-"FUNCTION: Opener._saveCursorPos(){{{3
|
|
| 2169 |
-function! s:Opener._saveCursorPos() |
|
| 2170 |
- let self._bufnr = bufnr("")
|
|
| 2171 |
- let self._tabnr = tabpagenr() |
|
| 2172 |
-endfunction |
|
| 2173 |
- |
|
| 2174 |
-"CLASS: Path {{{2
|
|
| 2175 |
-"============================================================ |
|
| 2176 |
-let s:Path = {}
|
|
| 2177 |
-"FUNCTION: Path.AbsolutePathFor(str) {{{3
|
|
| 2178 |
-function! s:Path.AbsolutePathFor(str) |
|
| 2179 |
- let prependCWD = 0 |
|
| 2180 |
- if s:running_windows |
|
| 2181 |
- let prependCWD = a:str !~# '^.:\(\\\|\/\)' && a:str !~# '^\(\\\\\|\/\/\)' |
|
| 2182 |
- else |
|
| 2183 |
- let prependCWD = a:str !~# '^/' |
|
| 2184 |
- endif |
|
| 2185 |
- |
|
| 2186 |
- let toReturn = a:str |
|
| 2187 |
- if prependCWD |
|
| 2188 |
- let toReturn = getcwd() . s:Path.Slash() . a:str |
|
| 2189 |
- endif |
|
| 2190 |
- |
|
| 2191 |
- return toReturn |
|
| 2192 |
-endfunction |
|
| 2193 |
-"FUNCTION: Path.bookmarkNames() {{{3
|
|
| 2194 |
-function! s:Path.bookmarkNames() |
|
| 2195 |
- if !exists("self._bookmarkNames")
|
|
| 2196 |
- call self.cacheDisplayString() |
|
| 2197 |
- endif |
|
| 2198 |
- return self._bookmarkNames |
|
| 2199 |
-endfunction |
|
| 2200 |
-"FUNCTION: Path.cacheDisplayString() {{{3
|
|
| 2201 |
-function! s:Path.cacheDisplayString() |
|
| 2202 |
- let self.cachedDisplayString = self.getLastPathComponent(1) |
|
| 2203 |
- |
|
| 2204 |
- if self.isExecutable |
|
| 2205 |
- let self.cachedDisplayString = self.cachedDisplayString . '*' |
|
| 2206 |
- endif |
|
| 2207 |
- |
|
| 2208 |
- let self._bookmarkNames = [] |
|
| 2209 |
- for i in s:Bookmark.Bookmarks() |
|
| 2210 |
- if i.path.equals(self) |
|
| 2211 |
- call add(self._bookmarkNames, i.name) |
|
| 2212 |
- endif |
|
| 2213 |
- endfor |
|
| 2214 |
- if !empty(self._bookmarkNames) |
|
| 2215 |
- let self.cachedDisplayString .= ' {' . join(self._bookmarkNames) . '}'
|
|
| 2216 |
- endif |
|
| 2217 |
- |
|
| 2218 |
- if self.isSymLink |
|
| 2219 |
- let self.cachedDisplayString .= ' -> ' . self.symLinkDest |
|
| 2220 |
- endif |
|
| 2221 |
- |
|
| 2222 |
- if self.isReadOnly |
|
| 2223 |
- let self.cachedDisplayString .= ' [RO]' |
|
| 2224 |
- endif |
|
| 2225 |
-endfunction |
|
| 2226 |
-"FUNCTION: Path.changeToDir() {{{3
|
|
| 2227 |
-function! s:Path.changeToDir() |
|
| 2228 |
- let dir = self.str({'format': 'Cd'})
|
|
| 2229 |
- if self.isDirectory ==# 0 |
|
| 2230 |
- let dir = self.getParent().str({'format': 'Cd'})
|
|
| 2231 |
- endif |
|
| 2232 |
- |
|
| 2233 |
- try |
|
| 2234 |
- execute "cd " . dir |
|
| 2235 |
- call s:echo("CWD is now: " . getcwd())
|
|
| 2236 |
- catch |
|
| 2237 |
- throw "NERDTree.PathChangeError: cannot change CWD to " . dir |
|
| 2238 |
- endtry |
|
| 2239 |
-endfunction |
|
| 2240 |
- |
|
| 2241 |
-"FUNCTION: Path.compareTo() {{{3
|
|
| 2242 |
-" |
|
| 2243 |
-"Compares this Path to the given path and returns 0 if they are equal, -1 if |
|
| 2244 |
-"this Path is "less than" the given path, or 1 if it is "greater". |
|
| 2245 |
-" |
|
| 2246 |
-"Args: |
|
| 2247 |
-"path: the path object to compare this to |
|
| 2248 |
-" |
|
| 2249 |
-"Return: |
|
| 2250 |
-"1, -1 or 0 |
|
| 2251 |
-function! s:Path.compareTo(path) |
|
| 2252 |
- let thisPath = self.getLastPathComponent(1) |
|
| 2253 |
- let thatPath = a:path.getLastPathComponent(1) |
|
| 2254 |
- |
|
| 2255 |
- "if the paths are the same then clearly we return 0 |
|
| 2256 |
- if thisPath ==# thatPath |
|
| 2257 |
- return 0 |
|
| 2258 |
- endif |
|
| 2259 |
- |
|
| 2260 |
- let thisSS = self.getSortOrderIndex() |
|
| 2261 |
- let thatSS = a:path.getSortOrderIndex() |
|
| 2262 |
- |
|
| 2263 |
- "compare the sort sequences, if they are different then the return |
|
| 2264 |
- "value is easy |
|
| 2265 |
- if thisSS < thatSS |
|
| 2266 |
- return -1 |
|
| 2267 |
- elseif thisSS > thatSS |
|
| 2268 |
- return 1 |
|
| 2269 |
- else |
|
| 2270 |
- "if the sort sequences are the same then compare the paths |
|
| 2271 |
- "alphabetically |
|
| 2272 |
- let pathCompare = g:NERDTreeCaseSensitiveSort ? thisPath <# thatPath : thisPath <? thatPath |
|
| 2273 |
- if pathCompare |
|
| 2274 |
- return -1 |
|
| 2275 |
- else |
|
| 2276 |
- return 1 |
|
| 2277 |
- endif |
|
| 2278 |
- endif |
|
| 2279 |
-endfunction |
|
| 2280 |
- |
|
| 2281 |
-"FUNCTION: Path.Create(fullpath) {{{3
|
|
| 2282 |
-" |
|
| 2283 |
-"Factory method. |
|
| 2284 |
-" |
|
| 2285 |
-"Creates a path object with the given path. The path is also created on the |
|
| 2286 |
-"filesystem. If the path already exists, a NERDTree.Path.Exists exception is |
|
| 2287 |
-"thrown. If any other errors occur, a NERDTree.Path exception is thrown. |
|
| 2288 |
-" |
|
| 2289 |
-"Args: |
|
| 2290 |
-"fullpath: the full filesystem path to the file/dir to create |
|
| 2291 |
-function! s:Path.Create(fullpath) |
|
| 2292 |
- "bail if the a:fullpath already exists |
|
| 2293 |
- if isdirectory(a:fullpath) || filereadable(a:fullpath) |
|
| 2294 |
- throw "NERDTree.CreatePathError: Directory Exists: '" . a:fullpath . "'" |
|
| 2295 |
- endif |
|
| 2296 |
- |
|
| 2297 |
- try |
|
| 2298 |
- |
|
| 2299 |
- "if it ends with a slash, assume its a dir create it |
|
| 2300 |
- if a:fullpath =~# '\(\\\|\/\)$' |
|
| 2301 |
- "whack the trailing slash off the end if it exists |
|
| 2302 |
- let fullpath = substitute(a:fullpath, '\(\\\|\/\)$', '', '') |
|
| 2303 |
- |
|
| 2304 |
- call mkdir(fullpath, 'p') |
|
| 2305 |
- |
|
| 2306 |
- "assume its a file and create |
|
| 2307 |
- else |
|
| 2308 |
- call writefile([], a:fullpath) |
|
| 2309 |
- endif |
|
| 2310 |
- catch |
|
| 2311 |
- throw "NERDTree.CreatePathError: Could not create path: '" . a:fullpath . "'" |
|
| 2312 |
- endtry |
|
| 2313 |
- |
|
| 2314 |
- return s:Path.New(a:fullpath) |
|
| 2315 |
-endfunction |
|
| 2316 |
- |
|
| 2317 |
-"FUNCTION: Path.copy(dest) {{{3
|
|
| 2318 |
-" |
|
| 2319 |
-"Copies the file/dir represented by this Path to the given location |
|
| 2320 |
-" |
|
| 2321 |
-"Args: |
|
| 2322 |
-"dest: the location to copy this dir/file to |
|
| 2323 |
-function! s:Path.copy(dest) |
|
| 2324 |
- if !s:Path.CopyingSupported() |
|
| 2325 |
- throw "NERDTree.CopyingNotSupportedError: Copying is not supported on this OS" |
|
| 2326 |
- endif |
|
| 2327 |
- |
|
| 2328 |
- let dest = s:Path.WinToUnixPath(a:dest) |
|
| 2329 |
- |
|
| 2330 |
- let cmd = g:NERDTreeCopyCmd . " " . escape(self.str(), s:escape_chars) . " " . escape(dest, s:escape_chars) |
|
| 2331 |
- let success = system(cmd) |
|
| 2332 |
- if success != 0 |
|
| 2333 |
- throw "NERDTree.CopyError: Could not copy ''". self.str() ."'' to: '" . a:dest . "'" |
|
| 2334 |
- endif |
|
| 2335 |
-endfunction |
|
| 2336 |
- |
|
| 2337 |
-"FUNCTION: Path.CopyingSupported() {{{3
|
|
| 2338 |
-" |
|
| 2339 |
-"returns 1 if copying is supported for this OS |
|
| 2340 |
-function! s:Path.CopyingSupported() |
|
| 2341 |
- return exists('g:NERDTreeCopyCmd')
|
|
| 2342 |
-endfunction |
|
| 2343 |
- |
|
| 2344 |
- |
|
| 2345 |
-"FUNCTION: Path.copyingWillOverwrite(dest) {{{3
|
|
| 2346 |
-" |
|
| 2347 |
-"returns 1 if copy this path to the given location will cause files to |
|
| 2348 |
-"overwritten |
|
| 2349 |
-" |
|
| 2350 |
-"Args: |
|
| 2351 |
-"dest: the location this path will be copied to |
|
| 2352 |
-function! s:Path.copyingWillOverwrite(dest) |
|
| 2353 |
- if filereadable(a:dest) |
|
| 2354 |
- return 1 |
|
| 2355 |
- endif |
|
| 2356 |
- |
|
| 2357 |
- if isdirectory(a:dest) |
|
| 2358 |
- let path = s:Path.JoinPathStrings(a:dest, self.getLastPathComponent(0)) |
|
| 2359 |
- if filereadable(path) |
|
| 2360 |
- return 1 |
|
| 2361 |
- endif |
|
| 2362 |
- endif |
|
| 2363 |
-endfunction |
|
| 2364 |
- |
|
| 2365 |
-"FUNCTION: Path.delete() {{{3
|
|
| 2366 |
-" |
|
| 2367 |
-"Deletes the file represented by this path. |
|
| 2368 |
-"Deletion of directories is not supported |
|
| 2369 |
-" |
|
| 2370 |
-"Throws NERDTree.Path.Deletion exceptions |
|
| 2371 |
-function! s:Path.delete() |
|
| 2372 |
- if self.isDirectory |
|
| 2373 |
- |
|
| 2374 |
- let cmd = g:NERDTreeRemoveDirCmd . self.str({'escape': 1})
|
|
| 2375 |
- let success = system(cmd) |
|
| 2376 |
- |
|
| 2377 |
- if v:shell_error != 0 |
|
| 2378 |
- throw "NERDTree.PathDeletionError: Could not delete directory: '" . self.str() . "'" |
|
| 2379 |
- endif |
|
| 2380 |
- else |
|
| 2381 |
- let success = delete(self.str()) |
|
| 2382 |
- if success != 0 |
|
| 2383 |
- throw "NERDTree.PathDeletionError: Could not delete file: '" . self.str() . "'" |
|
| 2384 |
- endif |
|
| 2385 |
- endif |
|
| 2386 |
- |
|
| 2387 |
- "delete all bookmarks for this path |
|
| 2388 |
- for i in self.bookmarkNames() |
|
| 2389 |
- let bookmark = s:Bookmark.BookmarkFor(i) |
|
| 2390 |
- call bookmark.delete() |
|
| 2391 |
- endfor |
|
| 2392 |
-endfunction |
|
| 2393 |
- |
|
| 2394 |
-"FUNCTION: Path.displayString() {{{3
|
|
| 2395 |
-" |
|
| 2396 |
-"Returns a string that specifies how the path should be represented as a |
|
| 2397 |
-"string |
|
| 2398 |
-function! s:Path.displayString() |
|
| 2399 |
- if self.cachedDisplayString ==# "" |
|
| 2400 |
- call self.cacheDisplayString() |
|
| 2401 |
- endif |
|
| 2402 |
- |
|
| 2403 |
- return self.cachedDisplayString |
|
| 2404 |
-endfunction |
|
| 2405 |
-"FUNCTION: Path.edit() {{{3
|
|
| 2406 |
-function! s:Path.edit() |
|
| 2407 |
- exec "edit " . self.str({'format': 'Edit'})
|
|
| 2408 |
-endfunction |
|
| 2409 |
-"FUNCTION: Path.extractDriveLetter(fullpath) {{{3
|
|
| 2410 |
-" |
|
| 2411 |
-"If running windows, cache the drive letter for this path |
|
| 2412 |
-function! s:Path.extractDriveLetter(fullpath) |
|
| 2413 |
- if s:running_windows |
|
| 2414 |
- if a:fullpath =~ '^\(\\\\\|\/\/\)' |
|
| 2415 |
- "For network shares, the 'drive' consists of the first two parts of the path, i.e. \\boxname\share |
|
| 2416 |
- let self.drive = substitute(a:fullpath, '^\(\(\\\\\|\/\/\)[^\\\/]*\(\\\|\/\)[^\\\/]*\).*', '\1', '') |
|
| 2417 |
- let self.drive = substitute(self.drive, '/', '\', "g") |
|
| 2418 |
- else |
|
| 2419 |
- let self.drive = substitute(a:fullpath, '\(^[a-zA-Z]:\).*', '\1', '') |
|
| 2420 |
- endif |
|
| 2421 |
- else |
|
| 2422 |
- let self.drive = '' |
|
| 2423 |
- endif |
|
| 2424 |
- |
|
| 2425 |
-endfunction |
|
| 2426 |
-"FUNCTION: Path.exists() {{{3
|
|
| 2427 |
-"return 1 if this path points to a location that is readable or is a directory |
|
| 2428 |
-function! s:Path.exists() |
|
| 2429 |
- let p = self.str() |
|
| 2430 |
- return filereadable(p) || isdirectory(p) |
|
| 2431 |
-endfunction |
|
| 2432 |
-"FUNCTION: Path.getDir() {{{3
|
|
| 2433 |
-" |
|
| 2434 |
-"Returns this path if it is a directory, else this paths parent. |
|
| 2435 |
-" |
|
| 2436 |
-"Return: |
|
| 2437 |
-"a Path object |
|
| 2438 |
-function! s:Path.getDir() |
|
| 2439 |
- if self.isDirectory |
|
| 2440 |
- return self |
|
| 2441 |
- else |
|
| 2442 |
- return self.getParent() |
|
| 2443 |
- endif |
|
| 2444 |
-endfunction |
|
| 2445 |
-"FUNCTION: Path.getParent() {{{3
|
|
| 2446 |
-" |
|
| 2447 |
-"Returns a new path object for this paths parent |
|
| 2448 |
-" |
|
| 2449 |
-"Return: |
|
| 2450 |
-"a new Path object |
|
| 2451 |
-function! s:Path.getParent() |
|
| 2452 |
- if s:running_windows |
|
| 2453 |
- let path = self.drive . '\' . join(self.pathSegments[0:-2], '\') |
|
| 2454 |
- else |
|
| 2455 |
- let path = '/'. join(self.pathSegments[0:-2], '/') |
|
| 2456 |
- endif |
|
| 2457 |
- |
|
| 2458 |
- return s:Path.New(path) |
|
| 2459 |
-endfunction |
|
| 2460 |
-"FUNCTION: Path.getLastPathComponent(dirSlash) {{{3
|
|
| 2461 |
-" |
|
| 2462 |
-"Gets the last part of this path. |
|
| 2463 |
-" |
|
| 2464 |
-"Args: |
|
| 2465 |
-"dirSlash: if 1 then a trailing slash will be added to the returned value for |
|
| 2466 |
-"directory nodes. |
|
| 2467 |
-function! s:Path.getLastPathComponent(dirSlash) |
|
| 2468 |
- if empty(self.pathSegments) |
|
| 2469 |
- return '' |
|
| 2470 |
- endif |
|
| 2471 |
- let toReturn = self.pathSegments[-1] |
|
| 2472 |
- if a:dirSlash && self.isDirectory |
|
| 2473 |
- let toReturn = toReturn . '/' |
|
| 2474 |
- endif |
|
| 2475 |
- return toReturn |
|
| 2476 |
-endfunction |
|
| 2477 |
- |
|
| 2478 |
-"FUNCTION: Path.getSortOrderIndex() {{{3
|
|
| 2479 |
-"returns the index of the pattern in g:NERDTreeSortOrder that this path matches |
|
| 2480 |
-function! s:Path.getSortOrderIndex() |
|
| 2481 |
- let i = 0 |
|
| 2482 |
- while i < len(g:NERDTreeSortOrder) |
|
| 2483 |
- if self.getLastPathComponent(1) =~# g:NERDTreeSortOrder[i] |
|
| 2484 |
- return i |
|
| 2485 |
- endif |
|
| 2486 |
- let i = i + 1 |
|
| 2487 |
- endwhile |
|
| 2488 |
- return s:NERDTreeSortStarIndex |
|
| 2489 |
-endfunction |
|
| 2490 |
- |
|
| 2491 |
- |
|
| 2492 |
-"FUNCTION: Path.isUnixHiddenFile() {{{3
|
|
| 2493 |
-"check for unix hidden files |
|
| 2494 |
-function! s:Path.isUnixHiddenFile() |
|
| 2495 |
- return self.getLastPathComponent(0) =~# '^\.' |
|
| 2496 |
-endfunction |
|
| 2497 |
- |
|
| 2498 |
-"FUNCTION: Path.ignore() {{{3
|
|
| 2499 |
-"returns true if this path should be ignored |
|
| 2500 |
-function! s:Path.ignore() |
|
| 2501 |
- "filter out the user specified paths to ignore |
|
| 2502 |
- if b:NERDTreeIgnoreEnabled |
|
| 2503 |
- for i in g:NERDTreeIgnore |
|
| 2504 |
- if self._ignorePatternMatches(i) |
|
| 2505 |
- return 1 |
|
| 2506 |
- endif |
|
| 2507 |
- endfor |
|
| 2508 |
- endif |
|
| 2509 |
- |
|
| 2510 |
- "dont show hidden files unless instructed to |
|
| 2511 |
- if b:NERDTreeShowHidden ==# 0 && self.isUnixHiddenFile() |
|
| 2512 |
- return 1 |
|
| 2513 |
- endif |
|
| 2514 |
- |
|
| 2515 |
- if b:NERDTreeShowFiles ==# 0 && self.isDirectory ==# 0 |
|
| 2516 |
- return 1 |
|
| 2517 |
- endif |
|
| 2518 |
- |
|
| 2519 |
- if exists("*NERDTreeCustomIgnoreFilter") && NERDTreeCustomIgnoreFilter(self)
|
|
| 2520 |
- return 1 |
|
| 2521 |
- endif |
|
| 2522 |
- |
|
| 2523 |
- return 0 |
|
| 2524 |
-endfunction |
|
| 2525 |
- |
|
| 2526 |
-"FUNCTION: Path._ignorePatternMatches(pattern) {{{3
|
|
| 2527 |
-"returns true if this path matches the given ignore pattern |
|
| 2528 |
-function! s:Path._ignorePatternMatches(pattern) |
|
| 2529 |
- let pat = a:pattern |
|
| 2530 |
- if strpart(pat,len(pat)-7) == '[[dir]]' |
|
| 2531 |
- if !self.isDirectory |
|
| 2532 |
- return 0 |
|
| 2533 |
- endif |
|
| 2534 |
- let pat = strpart(pat,0, len(pat)-7) |
|
| 2535 |
- elseif strpart(pat,len(pat)-8) == '[[file]]' |
|
| 2536 |
- if self.isDirectory |
|
| 2537 |
- return 0 |
|
| 2538 |
- endif |
|
| 2539 |
- let pat = strpart(pat,0, len(pat)-8) |
|
| 2540 |
- endif |
|
| 2541 |
- |
|
| 2542 |
- return self.getLastPathComponent(0) =~# pat |
|
| 2543 |
-endfunction |
|
| 2544 |
-"FUNCTION: Path.isUnder(path) {{{3
|
|
| 2545 |
-"return 1 if this path is somewhere under the given path in the filesystem. |
|
| 2546 |
-" |
|
| 2547 |
-"a:path should be a dir |
|
| 2548 |
-function! s:Path.isUnder(path) |
|
| 2549 |
- if a:path.isDirectory == 0 |
|
| 2550 |
- return 0 |
|
| 2551 |
- endif |
|
| 2552 |
- |
|
| 2553 |
- let this = self.str() |
|
| 2554 |
- let that = a:path.str() |
|
| 2555 |
- return stridx(this, that . s:Path.Slash()) == 0 |
|
| 2556 |
-endfunction |
|
| 2557 |
- |
|
| 2558 |
-"FUNCTION: Path.JoinPathStrings(...) {{{3
|
|
| 2559 |
-function! s:Path.JoinPathStrings(...) |
|
| 2560 |
- let components = [] |
|
| 2561 |
- for i in a:000 |
|
| 2562 |
- let components = extend(components, split(i, '/')) |
|
| 2563 |
- endfor |
|
| 2564 |
- return '/' . join(components, '/') |
|
| 2565 |
-endfunction |
|
| 2566 |
- |
|
| 2567 |
-"FUNCTION: Path.equals() {{{3
|
|
| 2568 |
-" |
|
| 2569 |
-"Determines whether 2 path objects are "equal". |
|
| 2570 |
-"They are equal if the paths they represent are the same |
|
| 2571 |
-" |
|
| 2572 |
-"Args: |
|
| 2573 |
-"path: the other path obj to compare this with |
|
| 2574 |
-function! s:Path.equals(path) |
|
| 2575 |
- return self.str() ==# a:path.str() |
|
| 2576 |
-endfunction |
|
| 2577 |
- |
|
| 2578 |
-"FUNCTION: Path.New() {{{3
|
|
| 2579 |
-"The Constructor for the Path object |
|
| 2580 |
-function! s:Path.New(path) |
|
| 2581 |
- let newPath = copy(self) |
|
| 2582 |
- |
|
| 2583 |
- call newPath.readInfoFromDisk(s:Path.AbsolutePathFor(a:path)) |
|
| 2584 |
- |
|
| 2585 |
- let newPath.cachedDisplayString = "" |
|
| 2586 |
- |
|
| 2587 |
- return newPath |
|
| 2588 |
-endfunction |
|
| 2589 |
- |
|
| 2590 |
-"FUNCTION: Path.Slash() {{{3
|
|
| 2591 |
-"return the slash to use for the current OS |
|
| 2592 |
-function! s:Path.Slash() |
|
| 2593 |
- return s:running_windows ? '\' : '/' |
|
| 2594 |
-endfunction |
|
| 2595 |
- |
|
| 2596 |
-"FUNCTION: Path.Resolve() {{{3
|
|
| 2597 |
-"Invoke the vim resolve() function and return the result |
|
| 2598 |
-"This is necessary because in some versions of vim resolve() removes trailing |
|
| 2599 |
-"slashes while in other versions it doesn't. This always removes the trailing |
|
| 2600 |
-"slash |
|
| 2601 |
-function! s:Path.Resolve(path) |
|
| 2602 |
- let tmp = resolve(a:path) |
|
| 2603 |
- return tmp =~# '.\+/$' ? substitute(tmp, '/$', '', '') : tmp |
|
| 2604 |
-endfunction |
|
| 2605 |
- |
|
| 2606 |
-"FUNCTION: Path.readInfoFromDisk(fullpath) {{{3
|
|
| 2607 |
-" |
|
| 2608 |
-" |
|
| 2609 |
-"Throws NERDTree.Path.InvalidArguments exception. |
|
| 2610 |
-function! s:Path.readInfoFromDisk(fullpath) |
|
| 2611 |
- call self.extractDriveLetter(a:fullpath) |
|
| 2612 |
- |
|
| 2613 |
- let fullpath = s:Path.WinToUnixPath(a:fullpath) |
|
| 2614 |
- |
|
| 2615 |
- if getftype(fullpath) ==# "fifo" |
|
| 2616 |
- throw "NERDTree.InvalidFiletypeError: Cant handle FIFO files: " . a:fullpath |
|
| 2617 |
- endif |
|
| 2618 |
- |
|
| 2619 |
- let self.pathSegments = split(fullpath, '/') |
|
| 2620 |
- |
|
| 2621 |
- let self.isReadOnly = 0 |
|
| 2622 |
- if isdirectory(a:fullpath) |
|
| 2623 |
- let self.isDirectory = 1 |
|
| 2624 |
- elseif filereadable(a:fullpath) |
|
| 2625 |
- let self.isDirectory = 0 |
|
| 2626 |
- let self.isReadOnly = filewritable(a:fullpath) ==# 0 |
|
| 2627 |
- else |
|
| 2628 |
- throw "NERDTree.InvalidArgumentsError: Invalid path = " . a:fullpath |
|
| 2629 |
- endif |
|
| 2630 |
- |
|
| 2631 |
- let self.isExecutable = 0 |
|
| 2632 |
- if !self.isDirectory |
|
| 2633 |
- let self.isExecutable = getfperm(a:fullpath) =~# 'x' |
|
| 2634 |
- endif |
|
| 2635 |
- |
|
| 2636 |
- "grab the last part of the path (minus the trailing slash) |
|
| 2637 |
- let lastPathComponent = self.getLastPathComponent(0) |
|
| 2638 |
- |
|
| 2639 |
- "get the path to the new node with the parent dir fully resolved |
|
| 2640 |
- let hardPath = s:Path.Resolve(self.strTrunk()) . '/' . lastPathComponent |
|
| 2641 |
- |
|
| 2642 |
- "if the last part of the path is a symlink then flag it as such |
|
| 2643 |
- let self.isSymLink = (s:Path.Resolve(hardPath) != hardPath) |
|
| 2644 |
- if self.isSymLink |
|
| 2645 |
- let self.symLinkDest = s:Path.Resolve(fullpath) |
|
| 2646 |
- |
|
| 2647 |
- "if the link is a dir then slap a / on the end of its dest |
|
| 2648 |
- if isdirectory(self.symLinkDest) |
|
| 2649 |
- |
|
| 2650 |
- "we always wanna treat MS windows shortcuts as files for |
|
| 2651 |
- "simplicity |
|
| 2652 |
- if hardPath !~# '\.lnk$' |
|
| 2653 |
- |
|
| 2654 |
- let self.symLinkDest = self.symLinkDest . '/' |
|
| 2655 |
- endif |
|
| 2656 |
- endif |
|
| 2657 |
- endif |
|
| 2658 |
-endfunction |
|
| 2659 |
- |
|
| 2660 |
-"FUNCTION: Path.refresh() {{{3
|
|
| 2661 |
-function! s:Path.refresh() |
|
| 2662 |
- call self.readInfoFromDisk(self.str()) |
|
| 2663 |
- call self.cacheDisplayString() |
|
| 2664 |
-endfunction |
|
| 2665 |
- |
|
| 2666 |
-"FUNCTION: Path.rename() {{{3
|
|
| 2667 |
-" |
|
| 2668 |
-"Renames this node on the filesystem |
|
| 2669 |
-function! s:Path.rename(newPath) |
|
| 2670 |
- if a:newPath ==# '' |
|
| 2671 |
- throw "NERDTree.InvalidArgumentsError: Invalid newPath for renaming = ". a:newPath |
|
| 2672 |
- endif |
|
| 2673 |
- |
|
| 2674 |
- let success = rename(self.str(), a:newPath) |
|
| 2675 |
- if success != 0 |
|
| 2676 |
- throw "NERDTree.PathRenameError: Could not rename: '" . self.str() . "'" . 'to:' . a:newPath |
|
| 2677 |
- endif |
|
| 2678 |
- call self.readInfoFromDisk(a:newPath) |
|
| 2679 |
- |
|
| 2680 |
- for i in self.bookmarkNames() |
|
| 2681 |
- let b = s:Bookmark.BookmarkFor(i) |
|
| 2682 |
- call b.setPath(copy(self)) |
|
| 2683 |
- endfor |
|
| 2684 |
- call s:Bookmark.Write() |
|
| 2685 |
-endfunction |
|
| 2686 |
- |
|
| 2687 |
-"FUNCTION: Path.str() {{{3
|
|
| 2688 |
-" |
|
| 2689 |
-"Returns a string representation of this Path |
|
| 2690 |
-" |
|
| 2691 |
-"Takes an optional dictionary param to specify how the output should be |
|
| 2692 |
-"formatted. |
|
| 2693 |
-" |
|
| 2694 |
-"The dict may have the following keys: |
|
| 2695 |
-" 'format' |
|
| 2696 |
-" 'escape' |
|
| 2697 |
-" 'truncateTo' |
|
| 2698 |
-" |
|
| 2699 |
-"The 'format' key may have a value of: |
|
| 2700 |
-" 'Cd' - a string to be used with the :cd command |
|
| 2701 |
-" 'Edit' - a string to be used with :e :sp :new :tabedit etc |
|
| 2702 |
-" 'UI' - a string used in the NERD tree UI |
|
| 2703 |
-" |
|
| 2704 |
-"The 'escape' key, if specified will cause the output to be escaped with |
|
| 2705 |
-"shellescape() |
|
| 2706 |
-" |
|
| 2707 |
-"The 'truncateTo' key causes the resulting string to be truncated to the value |
|
| 2708 |
-"'truncateTo' maps to. A '<' char will be prepended. |
|
| 2709 |
-function! s:Path.str(...) |
|
| 2710 |
- let options = a:0 ? a:1 : {}
|
|
| 2711 |
- let toReturn = "" |
|
| 2712 |
- |
|
| 2713 |
- if has_key(options, 'format') |
|
| 2714 |
- let format = options['format'] |
|
| 2715 |
- if has_key(self, '_strFor' . format) |
|
| 2716 |
- exec 'let toReturn = self._strFor' . format . '()' |
|
| 2717 |
- else |
|
| 2718 |
- raise 'NERDTree.UnknownFormatError: unknown format "'. format .'"' |
|
| 2719 |
- endif |
|
| 2720 |
- else |
|
| 2721 |
- let toReturn = self._str() |
|
| 2722 |
- endif |
|
| 2723 |
- |
|
| 2724 |
- if s:has_opt(options, 'escape') |
|
| 2725 |
- let toReturn = shellescape(toReturn) |
|
| 2726 |
- endif |
|
| 2727 |
- |
|
| 2728 |
- if has_key(options, 'truncateTo') |
|
| 2729 |
- let limit = options['truncateTo'] |
|
| 2730 |
- if len(toReturn) > limit |
|
| 2731 |
- let toReturn = "<" . strpart(toReturn, len(toReturn) - limit + 1) |
|
| 2732 |
- endif |
|
| 2733 |
- endif |
|
| 2734 |
- |
|
| 2735 |
- return toReturn |
|
| 2736 |
-endfunction |
|
| 2737 |
- |
|
| 2738 |
-"FUNCTION: Path._strForUI() {{{3
|
|
| 2739 |
-function! s:Path._strForUI() |
|
| 2740 |
- let toReturn = '/' . join(self.pathSegments, '/') |
|
| 2741 |
- if self.isDirectory && toReturn != '/' |
|
| 2742 |
- let toReturn = toReturn . '/' |
|
| 2743 |
- endif |
|
| 2744 |
- return toReturn |
|
| 2745 |
-endfunction |
|
| 2746 |
- |
|
| 2747 |
-"FUNCTION: Path._strForCd() {{{3
|
|
| 2748 |
-" |
|
| 2749 |
-" returns a string that can be used with :cd |
|
| 2750 |
-function! s:Path._strForCd() |
|
| 2751 |
- return escape(self.str(), s:escape_chars) |
|
| 2752 |
-endfunction |
|
| 2753 |
-"FUNCTION: Path._strForEdit() {{{3
|
|
| 2754 |
-" |
|
| 2755 |
-"Return: the string for this path that is suitable to be used with the :edit |
|
| 2756 |
-"command |
|
| 2757 |
-function! s:Path._strForEdit() |
|
| 2758 |
- let p = escape(self.str({'format': 'UI'}), s:escape_chars)
|
|
| 2759 |
- let cwd = getcwd() . s:Path.Slash() |
|
| 2760 |
- |
|
| 2761 |
- "return a relative path if we can |
|
| 2762 |
- let isRelative = 0 |
|
| 2763 |
- if s:running_windows |
|
| 2764 |
- let isRelative = stridx(tolower(p), tolower(cwd)) == 0 |
|
| 2765 |
- else |
|
| 2766 |
- let isRelative = stridx(p, cwd) == 0 |
|
| 2767 |
- endif |
|
| 2768 |
- |
|
| 2769 |
- if isRelative |
|
| 2770 |
- let p = strpart(p, strlen(cwd)) |
|
| 2771 |
- |
|
| 2772 |
- "handle the edge case where the file begins with a + (vim interprets |
|
| 2773 |
- "the +foo in `:e +foo` as an option to :edit) |
|
| 2774 |
- if p[0] == "+" |
|
| 2775 |
- let p = '\' . p |
|
| 2776 |
- endif |
|
| 2777 |
- endif |
|
| 2778 |
- |
|
| 2779 |
- if p ==# '' |
|
| 2780 |
- let p = '.' |
|
| 2781 |
- endif |
|
| 2782 |
- |
|
| 2783 |
- return p |
|
| 2784 |
-endfunction |
|
| 2785 |
-"FUNCTION: Path._strForGlob() {{{3
|
|
| 2786 |
-function! s:Path._strForGlob() |
|
| 2787 |
- let lead = s:Path.Slash() |
|
| 2788 |
- |
|
| 2789 |
- "if we are running windows then slap a drive letter on the front |
|
| 2790 |
- if s:running_windows |
|
| 2791 |
- let lead = self.drive . '\' |
|
| 2792 |
- endif |
|
| 2793 |
- |
|
| 2794 |
- let toReturn = lead . join(self.pathSegments, s:Path.Slash()) |
|
| 2795 |
- |
|
| 2796 |
- if !s:running_windows |
|
| 2797 |
- let toReturn = escape(toReturn, s:escape_chars) |
|
| 2798 |
- endif |
|
| 2799 |
- return toReturn |
|
| 2800 |
-endfunction |
|
| 2801 |
-"FUNCTION: Path._str() {{{3
|
|
| 2802 |
-" |
|
| 2803 |
-"Gets the string path for this path object that is appropriate for the OS. |
|
| 2804 |
-"EG, in windows c:\foo\bar |
|
| 2805 |
-" in *nix /foo/bar |
|
| 2806 |
-function! s:Path._str() |
|
| 2807 |
- let lead = s:Path.Slash() |
|
| 2808 |
- |
|
| 2809 |
- "if we are running windows then slap a drive letter on the front |
|
| 2810 |
- if s:running_windows |
|
| 2811 |
- let lead = self.drive . '\' |
|
| 2812 |
- endif |
|
| 2813 |
- |
|
| 2814 |
- return lead . join(self.pathSegments, s:Path.Slash()) |
|
| 2815 |
-endfunction |
|
| 2816 |
- |
|
| 2817 |
-"FUNCTION: Path.strTrunk() {{{3
|
|
| 2818 |
-"Gets the path without the last segment on the end. |
|
| 2819 |
-function! s:Path.strTrunk() |
|
| 2820 |
- return self.drive . '/' . join(self.pathSegments[0:-2], '/') |
|
| 2821 |
-endfunction |
|
| 2822 |
- |
|
| 2823 |
-" FUNCTION: Path.tabnr() {{{3
|
|
| 2824 |
-" return the number of the first tab that is displaying this file |
|
| 2825 |
-" |
|
| 2826 |
-" return 0 if no tab was found |
|
| 2827 |
-function! s:Path.tabnr() |
|
| 2828 |
- let str = self.str() |
|
| 2829 |
- for t in range(tabpagenr('$'))
|
|
| 2830 |
- for b in tabpagebuflist(t+1) |
|
| 2831 |
- if str == expand('#' . b . ':p')
|
|
| 2832 |
- return t+1 |
|
| 2833 |
- endif |
|
| 2834 |
- endfor |
|
| 2835 |
- endfor |
|
| 2836 |
- return 0 |
|
| 2837 |
-endfunction |
|
| 2838 |
-"FUNCTION: Path.WinToUnixPath(pathstr){{{3
|
|
| 2839 |
-"Takes in a windows path and returns the unix equiv |
|
| 2840 |
-" |
|
| 2841 |
-"A class level method |
|
| 2842 |
-" |
|
| 2843 |
-"Args: |
|
| 2844 |
-"pathstr: the windows path to convert |
|
| 2845 |
-function! s:Path.WinToUnixPath(pathstr) |
|
| 2846 |
- if !s:running_windows |
|
| 2847 |
- return a:pathstr |
|
| 2848 |
- endif |
|
| 2849 |
- |
|
| 2850 |
- let toReturn = a:pathstr |
|
| 2851 |
- |
|
| 2852 |
- "remove the x:\ of the front |
|
| 2853 |
- let toReturn = substitute(toReturn, '^.*:\(\\\|/\)\?', '/', "") |
|
| 2854 |
- |
|
| 2855 |
- "remove the \\ network share from the front |
|
| 2856 |
- let toReturn = substitute(toReturn, '^\(\\\\\|\/\/\)[^\\\/]*\(\\\|\/\)[^\\\/]*\(\\\|\/\)\?', '/', "") |
|
| 2857 |
- |
|
| 2858 |
- "convert all \ chars to / |
|
| 2859 |
- let toReturn = substitute(toReturn, '\', '/', "g") |
|
| 2860 |
- |
|
| 2861 |
- return toReturn |
|
| 2862 |
-endfunction |
|
| 2863 |
- |
|
| 2864 |
-" SECTION: General Functions {{{1
|
|
| 2865 |
-"============================================================ |
|
| 2866 |
-"FUNCTION: s:bufInWindows(bnum){{{2
|
|
| 2867 |
-"[[STOLEN FROM VTREEEXPLORER.VIM]] |
|
| 2868 |
-"Determine the number of windows open to this buffer number. |
|
| 2869 |
-"Care of Yegappan Lakshman. Thanks! |
|
| 2870 |
-" |
|
| 2871 |
-"Args: |
|
| 2872 |
-"bnum: the subject buffers buffer number |
|
| 2873 |
-function! s:bufInWindows(bnum) |
|
| 2874 |
- let cnt = 0 |
|
| 2875 |
- let winnum = 1 |
|
| 2876 |
- while 1 |
|
| 2877 |
- let bufnum = winbufnr(winnum) |
|
| 2878 |
- if bufnum < 0 |
|
| 2879 |
- break |
|
| 2880 |
- endif |
|
| 2881 |
- if bufnum ==# a:bnum |
|
| 2882 |
- let cnt = cnt + 1 |
|
| 2883 |
- endif |
|
| 2884 |
- let winnum = winnum + 1 |
|
| 2885 |
- endwhile |
|
| 2886 |
- |
|
| 2887 |
- return cnt |
|
| 2888 |
-endfunction " >>> |
|
| 2889 |
-"FUNCTION: s:checkForBrowse(dir) {{{2
|
|
| 2890 |
-"inits a secondary nerd tree in the current buffer if appropriate |
|
| 2891 |
-function! s:checkForBrowse(dir) |
|
| 2892 |
- if a:dir != '' && isdirectory(a:dir) |
|
| 2893 |
- call s:initNerdTreeInPlace(a:dir) |
|
| 2894 |
- endif |
|
| 2895 |
-endfunction |
|
| 2896 |
-"FUNCTION: s:compareBookmarks(first, second) {{{2
|
|
| 2897 |
-"Compares two bookmarks |
|
| 2898 |
-function! s:compareBookmarks(first, second) |
|
| 2899 |
- return a:first.compareTo(a:second) |
|
| 2900 |
-endfunction |
|
| 2901 |
- |
|
| 2902 |
-" FUNCTION: s:completeBookmarks(A,L,P) {{{2
|
|
| 2903 |
-" completion function for the bookmark commands |
|
| 2904 |
-function! s:completeBookmarks(A,L,P) |
|
| 2905 |
- return filter(s:Bookmark.BookmarkNames(), 'v:val =~# "^' . a:A . '"') |
|
| 2906 |
-endfunction |
|
| 2907 |
-" FUNCTION: s:createDefaultBindings() {{{2
|
|
| 2908 |
-function! s:createDefaultBindings() |
|
| 2909 |
- let s = '<SNR>' . s:SID() . '_' |
|
| 2910 |
- |
|
| 2911 |
- call NERDTreeAddKeyMap({ 'key': '<MiddleRelease>', 'scope': "all", 'callback': s."handleMiddleMouse" })
|
|
| 2912 |
- call NERDTreeAddKeyMap({ 'key': '<LeftRelease>', 'scope': "all", 'callback': s."handleLeftClick" })
|
|
| 2913 |
- call NERDTreeAddKeyMap({ 'key': '<2-LeftMouse>', 'scope': "DirNode", 'callback': s."activateDirNode" })
|
|
| 2914 |
- call NERDTreeAddKeyMap({ 'key': '<2-LeftMouse>', 'scope': "FileNode", 'callback': s."activateFileNode" })
|
|
| 2915 |
- call NERDTreeAddKeyMap({ 'key': '<2-LeftMouse>', 'scope': "Bookmark", 'callback': s."activateBookmark" })
|
|
| 2916 |
- call NERDTreeAddKeyMap({ 'key': '<2-LeftMouse>', 'scope': "all", 'callback': s."activateAll" })
|
|
| 2917 |
- |
|
| 2918 |
- |
|
| 2919 |
- call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapActivateNode, 'scope': "DirNode", 'callback': s."activateDirNode" })
|
|
| 2920 |
- call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapActivateNode, 'scope': "FileNode", 'callback': s."activateFileNode" })
|
|
| 2921 |
- call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapActivateNode, 'scope': "Bookmark", 'callback': s."activateBookmark" })
|
|
| 2922 |
- call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapActivateNode, 'scope': "all", 'callback': s."activateAll" })
|
|
| 2923 |
- |
|
| 2924 |
- call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapOpenSplit, 'scope': "Node", 'callback': s."openHSplit" })
|
|
| 2925 |
- call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapOpenVSplit, 'scope': "Node", 'callback': s."openVSplit" })
|
|
| 2926 |
- |
|
| 2927 |
- call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapOpenSplit, 'scope': "Bookmark", 'callback': s."openHSplit" })
|
|
| 2928 |
- call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapOpenVSplit, 'scope': "Bookmark", 'callback': s."openVSplit" })
|
|
| 2929 |
- |
|
| 2930 |
- call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapPreview, 'scope': "Node", 'callback': s."previewNodeCurrent" })
|
|
| 2931 |
- call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapPreviewVSplit, 'scope': "Node", 'callback': s."previewNodeVSplit" })
|
|
| 2932 |
- call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapPreviewSplit, 'scope': "Node", 'callback': s."previewNodeHSplit" })
|
|
| 2933 |
- |
|
| 2934 |
- call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapPreview, 'scope': "Bookmark", 'callback': s."previewNodeCurrent" })
|
|
| 2935 |
- call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapPreviewVSplit, 'scope': "Bookmark", 'callback': s."previewNodeVSplit" })
|
|
| 2936 |
- call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapPreviewSplit, 'scope': "Bookmark", 'callback': s."previewNodeHSplit" })
|
|
| 2937 |
- |
|
| 2938 |
- call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapOpenRecursively, 'scope': "DirNode", 'callback': s."openNodeRecursively" })
|
|
| 2939 |
- |
|
| 2940 |
- call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapUpdir, 'scope': "all", 'callback': s."upDirCurrentRootClosed" })
|
|
| 2941 |
- call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapUpdirKeepOpen, 'scope': "all", 'callback': s."upDirCurrentRootOpen" })
|
|
| 2942 |
- call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapChangeRoot, 'scope': "Node", 'callback': s."chRoot" })
|
|
| 2943 |
- |
|
| 2944 |
- call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapChdir, 'scope': "Node", 'callback': s."chCwd" })
|
|
| 2945 |
- |
|
| 2946 |
- call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapQuit, 'scope': "all", 'callback': s."closeTreeWindow" })
|
|
| 2947 |
- |
|
| 2948 |
- call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapCWD, 'scope': "all", 'callback': s."chRootCwd" })
|
|
| 2949 |
- |
|
| 2950 |
- call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapRefreshRoot, 'scope': "all", 'callback': s."refreshRoot" })
|
|
| 2951 |
- call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapRefresh, 'scope': "Node", 'callback': s."refreshCurrent" })
|
|
| 2952 |
- |
|
| 2953 |
- call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapHelp, 'scope': "all", 'callback': s."displayHelp" })
|
|
| 2954 |
- call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapToggleZoom, 'scope': "all", 'callback': s."toggleZoom" })
|
|
| 2955 |
- call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapToggleHidden, 'scope': "all", 'callback': s."toggleShowHidden" })
|
|
| 2956 |
- call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapToggleFilters, 'scope': "all", 'callback': s."toggleIgnoreFilter" })
|
|
| 2957 |
- call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapToggleFiles, 'scope': "all", 'callback': s."toggleShowFiles" })
|
|
| 2958 |
- call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapToggleBookmarks, 'scope': "all", 'callback': s."toggleShowBookmarks" })
|
|
| 2959 |
- |
|
| 2960 |
- call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapCloseDir, 'scope': "Node", 'callback': s."closeCurrentDir" })
|
|
| 2961 |
- call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapCloseChildren, 'scope': "DirNode", 'callback': s."closeChildren" })
|
|
| 2962 |
- |
|
| 2963 |
- call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapMenu, 'scope': "Node", 'callback': s."showMenu" })
|
|
| 2964 |
- |
|
| 2965 |
- call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapJumpParent, 'scope': "Node", 'callback': s."jumpToParent" })
|
|
| 2966 |
- call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapJumpFirstChild, 'scope': "Node", 'callback': s."jumpToFirstChild" })
|
|
| 2967 |
- call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapJumpLastChild, 'scope': "Node", 'callback': s."jumpToLastChild" })
|
|
| 2968 |
- call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapJumpRoot, 'scope': "all", 'callback': s."jumpToRoot" })
|
|
| 2969 |
- call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapJumpNextSibling, 'scope': "Node", 'callback': s."jumpToNextSibling" })
|
|
| 2970 |
- call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapJumpPrevSibling, 'scope': "Node", 'callback': s."jumpToPrevSibling" })
|
|
| 2971 |
- |
|
| 2972 |
- call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapOpenInTab, 'scope': "Node", 'callback': s."openInNewTab" })
|
|
| 2973 |
- call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapOpenInTabSilent, 'scope': "Node", 'callback': s."openInNewTabSilent" })
|
|
| 2974 |
- call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapOpenInTab, 'scope': "Bookmark", 'callback': s."openInNewTab" })
|
|
| 2975 |
- call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapOpenInTabSilent, 'scope': "Bookmark", 'callback': s."openInNewTabSilent" })
|
|
| 2976 |
- |
|
| 2977 |
- call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapOpenExpl, 'scope': "DirNode", 'callback': s."openExplorer" })
|
|
| 2978 |
- |
|
| 2979 |
- call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapDeleteBookmark, 'scope': "Bookmark", 'callback': s."deleteBookmark" })
|
|
| 2980 |
- |
|
| 2981 |
-endfunction |
|
| 2982 |
-" FUNCTION: s:deprecated(func, [msg]) {{{2
|
|
| 2983 |
-" Issue a deprecation warning for a:func. If a second arg is given, use this |
|
| 2984 |
-" as the deprecation message |
|
| 2985 |
-function! s:deprecated(func, ...) |
|
| 2986 |
- let msg = a:0 ? a:func . ' ' . a:1 : a:func . ' is deprecated' |
|
| 2987 |
- |
|
| 2988 |
- if !exists('s:deprecationWarnings')
|
|
| 2989 |
- let s:deprecationWarnings = {}
|
|
| 2990 |
- endif |
|
| 2991 |
- if !has_key(s:deprecationWarnings, a:func) |
|
| 2992 |
- let s:deprecationWarnings[a:func] = 1 |
|
| 2993 |
- echomsg msg |
|
| 2994 |
- endif |
|
| 2995 |
-endfunction |
|
| 2996 |
-" FUNCTION: s:exec(cmd) {{{2
|
|
| 2997 |
-" same as :exec cmd but eventignore=all is set for the duration |
|
| 2998 |
-function! s:exec(cmd) |
|
| 2999 |
- let old_ei = &ei |
|
| 3000 |
- set ei=all |
|
| 3001 |
- exec a:cmd |
|
| 3002 |
- let &ei = old_ei |
|
| 3003 |
-endfunction |
|
| 3004 |
-" FUNCTION: s:findAndRevealPath() {{{2
|
|
| 3005 |
-function! s:findAndRevealPath() |
|
| 3006 |
- try |
|
| 3007 |
- let p = s:Path.New(expand("%:p"))
|
|
| 3008 |
- catch /^NERDTree.InvalidArgumentsError/ |
|
| 3009 |
- call s:echo("no file for the current buffer")
|
|
| 3010 |
- return |
|
| 3011 |
- endtry |
|
| 3012 |
- |
|
| 3013 |
- if p.isUnixHiddenFile() |
|
| 3014 |
- let showhidden=g:NERDTreeShowHidden |
|
| 3015 |
- let g:NERDTreeShowHidden = 1 |
|
| 3016 |
- endif |
|
| 3017 |
- |
|
| 3018 |
- if !s:treeExistsForTab() |
|
| 3019 |
- try |
|
| 3020 |
- let cwd = s:Path.New(getcwd()) |
|
| 3021 |
- catch /^NERDTree.InvalidArgumentsError/ |
|
| 3022 |
- call s:echo("current directory does not exist.")
|
|
| 3023 |
- let cwd = p.getParent() |
|
| 3024 |
- endtry |
|
| 3025 |
- |
|
| 3026 |
- if p.isUnder(cwd) |
|
| 3027 |
- call s:initNerdTree(cwd.str()) |
|
| 3028 |
- else |
|
| 3029 |
- call s:initNerdTree(p.getParent().str()) |
|
| 3030 |
- endif |
|
| 3031 |
- else |
|
| 3032 |
- if !p.isUnder(s:TreeFileNode.GetRootForTab().path) |
|
| 3033 |
- if !s:isTreeOpen() |
|
| 3034 |
- call s:createTreeWin() |
|
| 3035 |
- else |
|
| 3036 |
- call s:putCursorInTreeWin() |
|
| 3037 |
- endif |
|
| 3038 |
- let b:NERDTreeShowHidden = g:NERDTreeShowHidden |
|
| 3039 |
- call s:chRoot(s:TreeDirNode.New(p.getParent())) |
|
| 3040 |
- else |
|
| 3041 |
- if !s:isTreeOpen() |
|
| 3042 |
- call s:toggle("")
|
|
| 3043 |
- endif |
|
| 3044 |
- endif |
|
| 3045 |
- endif |
|
| 3046 |
- call s:putCursorInTreeWin() |
|
| 3047 |
- call b:NERDTreeRoot.reveal(p) |
|
| 3048 |
- |
|
| 3049 |
- if p.isUnixHiddenFile() |
|
| 3050 |
- let g:NERDTreeShowHidden = showhidden |
|
| 3051 |
- endif |
|
| 3052 |
-endfunction |
|
| 3053 |
- |
|
| 3054 |
-" FUNCTION: s:has_opt(options, name) {{{2
|
|
| 3055 |
-function! s:has_opt(options, name) |
|
| 3056 |
- return has_key(a:options, a:name) && a:options[a:name] == 1 |
|
| 3057 |
-endfunction |
|
| 3058 |
- |
|
| 3059 |
-"FUNCTION: s:initNerdTree(name) {{{2
|
|
| 3060 |
-"Initialise the nerd tree for this tab. The tree will start in either the |
|
| 3061 |
-"given directory, or the directory associated with the given bookmark |
|
| 3062 |
-" |
|
| 3063 |
-"Args: |
|
| 3064 |
-"name: the name of a bookmark or a directory |
|
| 3065 |
-function! s:initNerdTree(name) |
|
| 3066 |
- let path = {}
|
|
| 3067 |
- if s:Bookmark.BookmarkExistsFor(a:name) |
|
| 3068 |
- let path = s:Bookmark.BookmarkFor(a:name).path |
|
| 3069 |
- else |
|
| 3070 |
- let dir = a:name ==# '' ? getcwd() : a:name |
|
| 3071 |
- |
|
| 3072 |
- "hack to get an absolute path if a relative path is given |
|
| 3073 |
- if dir =~# '^\.' |
|
| 3074 |
- let dir = getcwd() . s:Path.Slash() . dir |
|
| 3075 |
- endif |
|
| 3076 |
- let dir = s:Path.Resolve(dir) |
|
| 3077 |
- |
|
| 3078 |
- try |
|
| 3079 |
- let path = s:Path.New(dir) |
|
| 3080 |
- catch /^NERDTree.InvalidArgumentsError/ |
|
| 3081 |
- call s:echo("No bookmark or directory found for: " . a:name)
|
|
| 3082 |
- return |
|
| 3083 |
- endtry |
|
| 3084 |
- endif |
|
| 3085 |
- if !path.isDirectory |
|
| 3086 |
- let path = path.getParent() |
|
| 3087 |
- endif |
|
| 3088 |
- |
|
| 3089 |
- "if instructed to, then change the vim CWD to the dir the NERDTree is |
|
| 3090 |
- "inited in |
|
| 3091 |
- if g:NERDTreeChDirMode != 0 |
|
| 3092 |
- call path.changeToDir() |
|
| 3093 |
- endif |
|
| 3094 |
- |
|
| 3095 |
- if s:treeExistsForTab() |
|
| 3096 |
- if s:isTreeOpen() |
|
| 3097 |
- call s:closeTree() |
|
| 3098 |
- endif |
|
| 3099 |
- unlet t:NERDTreeBufName |
|
| 3100 |
- endif |
|
| 3101 |
- |
|
| 3102 |
- let newRoot = s:TreeDirNode.New(path) |
|
| 3103 |
- call newRoot.open() |
|
| 3104 |
- |
|
| 3105 |
- call s:createTreeWin() |
|
| 3106 |
- let b:treeShowHelp = 0 |
|
| 3107 |
- let b:NERDTreeIgnoreEnabled = 1 |
|
| 3108 |
- let b:NERDTreeShowFiles = g:NERDTreeShowFiles |
|
| 3109 |
- let b:NERDTreeShowHidden = g:NERDTreeShowHidden |
|
| 3110 |
- let b:NERDTreeShowBookmarks = g:NERDTreeShowBookmarks |
|
| 3111 |
- let b:NERDTreeRoot = newRoot |
|
| 3112 |
- let b:NERDTreeType = "primary" |
|
| 3113 |
- |
|
| 3114 |
- call s:renderView() |
|
| 3115 |
- call b:NERDTreeRoot.putCursorHere(0, 0) |
|
| 3116 |
- |
|
| 3117 |
- silent doautocmd User NERDTreeInit |
|
| 3118 |
-endfunction |
|
| 3119 |
- |
|
| 3120 |
-"FUNCTION: s:initNerdTreeInPlace(dir) {{{2
|
|
| 3121 |
-function! s:initNerdTreeInPlace(dir) |
|
| 3122 |
- try |
|
| 3123 |
- let path = s:Path.New(a:dir) |
|
| 3124 |
- catch /^NERDTree.InvalidArgumentsError/ |
|
| 3125 |
- call s:echo("Invalid directory name:" . a:name)
|
|
| 3126 |
- return |
|
| 3127 |
- endtry |
|
| 3128 |
- |
|
| 3129 |
- "we want the directory buffer to disappear when we do the :edit below |
|
| 3130 |
- setlocal bufhidden=wipe |
|
| 3131 |
- |
|
| 3132 |
- let previousBuf = expand("#")
|
|
| 3133 |
- |
|
| 3134 |
- "we need a unique name for each secondary tree buffer to ensure they are |
|
| 3135 |
- "all independent |
|
| 3136 |
- exec "silent edit " . s:nextBufferName() |
|
| 3137 |
- |
|
| 3138 |
- let b:NERDTreePreviousBuf = bufnr(previousBuf) |
|
| 3139 |
- |
|
| 3140 |
- let b:NERDTreeRoot = s:TreeDirNode.New(path) |
|
| 3141 |
- call b:NERDTreeRoot.open() |
|
| 3142 |
- |
|
| 3143 |
- call s:setCommonBufOptions() |
|
| 3144 |
- let b:NERDTreeType = "secondary" |
|
| 3145 |
- |
|
| 3146 |
- call s:renderView() |
|
| 3147 |
- |
|
| 3148 |
- silent doautocmd User NERDTreeInit |
|
| 3149 |
-endfunction |
|
| 3150 |
-" FUNCTION: s:initNerdTreeMirror() {{{2
|
|
| 3151 |
-function! s:initNerdTreeMirror() |
|
| 3152 |
- |
|
| 3153 |
- "get the names off all the nerd tree buffers |
|
| 3154 |
- let treeBufNames = [] |
|
| 3155 |
- for i in range(1, tabpagenr("$"))
|
|
| 3156 |
- let nextName = s:tabpagevar(i, 'NERDTreeBufName') |
|
| 3157 |
- if nextName != -1 && (!exists("t:NERDTreeBufName") || nextName != t:NERDTreeBufName)
|
|
| 3158 |
- call add(treeBufNames, nextName) |
|
| 3159 |
- endif |
|
| 3160 |
- endfor |
|
| 3161 |
- let treeBufNames = s:unique(treeBufNames) |
|
| 3162 |
- |
|
| 3163 |
- "map the option names (that the user will be prompted with) to the nerd |
|
| 3164 |
- "tree buffer names |
|
| 3165 |
- let options = {}
|
|
| 3166 |
- let i = 0 |
|
| 3167 |
- while i < len(treeBufNames) |
|
| 3168 |
- let bufName = treeBufNames[i] |
|
| 3169 |
- let treeRoot = getbufvar(bufName, "NERDTreeRoot") |
|
| 3170 |
- let options[i+1 . '. ' . treeRoot.path.str() . ' (buf name: ' . bufName . ')'] = bufName |
|
| 3171 |
- let i = i + 1 |
|
| 3172 |
- endwhile |
|
| 3173 |
- |
|
| 3174 |
- "work out which tree to mirror, if there is more than 1 then ask the user |
|
| 3175 |
- let bufferName = '' |
|
| 3176 |
- if len(keys(options)) > 1 |
|
| 3177 |
- let choices = ["Choose a tree to mirror"] |
|
| 3178 |
- let choices = extend(choices, sort(keys(options))) |
|
| 3179 |
- let choice = inputlist(choices) |
|
| 3180 |
- if choice < 1 || choice > len(options) || choice ==# '' |
|
| 3181 |
- return |
|
| 3182 |
- endif |
|
| 3183 |
- |
|
| 3184 |
- let bufferName = options[sort(keys(options))[choice-1]] |
|
| 3185 |
- elseif len(keys(options)) ==# 1 |
|
| 3186 |
- let bufferName = values(options)[0] |
|
| 3187 |
- else |
|
| 3188 |
- call s:echo("No trees to mirror")
|
|
| 3189 |
- return |
|
| 3190 |
- endif |
|
| 3191 |
- |
|
| 3192 |
- if s:treeExistsForTab() && s:isTreeOpen() |
|
| 3193 |
- call s:closeTree() |
|
| 3194 |
- endif |
|
| 3195 |
- |
|
| 3196 |
- let t:NERDTreeBufName = bufferName |
|
| 3197 |
- call s:createTreeWin() |
|
| 3198 |
- exec 'buffer ' . bufferName |
|
| 3199 |
- if !&hidden |
|
| 3200 |
- call s:renderView() |
|
| 3201 |
- endif |
|
| 3202 |
-endfunction |
|
| 3203 |
-" FUNCTION: s:nextBufferName() {{{2
|
|
| 3204 |
-" returns the buffer name for the next nerd tree |
|
| 3205 |
-function! s:nextBufferName() |
|
| 3206 |
- let name = s:NERDTreeBufName . s:next_buffer_number |
|
| 3207 |
- let s:next_buffer_number += 1 |
|
| 3208 |
- return name |
|
| 3209 |
-endfunction |
|
| 3210 |
-" FUNCTION: s:postSourceActions() {{{2
|
|
| 3211 |
-function! s:postSourceActions() |
|
| 3212 |
- call s:Bookmark.CacheBookmarks(0) |
|
| 3213 |
- call s:createDefaultBindings() |
|
| 3214 |
- |
|
| 3215 |
- "load all nerdtree plugins |
|
| 3216 |
- runtime! nerdtree_plugin/**/*.vim |
|
| 3217 |
-endfunction |
|
| 3218 |
-" FUNCTION: s:tabpagevar(tabnr, var) {{{2
|
|
| 3219 |
-function! s:tabpagevar(tabnr, var) |
|
| 3220 |
- let currentTab = tabpagenr() |
|
| 3221 |
- let old_ei = &ei |
|
| 3222 |
- set ei=all |
|
| 3223 |
- |
|
| 3224 |
- exec "tabnext " . a:tabnr |
|
| 3225 |
- let v = -1 |
|
| 3226 |
- if exists('t:' . a:var)
|
|
| 3227 |
- exec 'let v = t:' . a:var |
|
| 3228 |
- endif |
|
| 3229 |
- exec "tabnext " . currentTab |
|
| 3230 |
- |
|
| 3231 |
- let &ei = old_ei |
|
| 3232 |
- |
|
| 3233 |
- return v |
|
| 3234 |
-endfunction |
|
| 3235 |
-" Function: s:treeExistsForBuffer() {{{2
|
|
| 3236 |
-" Returns 1 if a nerd tree root exists in the current buffer |
|
| 3237 |
-function! s:treeExistsForBuf() |
|
| 3238 |
- return exists("b:NERDTreeRoot")
|
|
| 3239 |
-endfunction |
|
| 3240 |
-" Function: s:treeExistsForTab() {{{2
|
|
| 3241 |
-" Returns 1 if a nerd tree root exists in the current tab |
|
| 3242 |
-function! s:treeExistsForTab() |
|
| 3243 |
- return exists("t:NERDTreeBufName")
|
|
| 3244 |
-endfunction |
|
| 3245 |
-" Function: s:SID() {{{2
|
|
| 3246 |
-function s:SID() |
|
| 3247 |
- if !exists("s:sid")
|
|
| 3248 |
- let s:sid = matchstr(expand('<sfile>'), '<SNR>\zs\d\+\ze_SID$')
|
|
| 3249 |
- endif |
|
| 3250 |
- return s:sid |
|
| 3251 |
-endfun |
|
| 3252 |
-"FUNCTION: s:upDir(keepState) {{{2
|
|
| 3253 |
-"moves the tree up a level |
|
| 3254 |
-" |
|
| 3255 |
-"Args: |
|
| 3256 |
-"keepState: 1 if the current root should be left open when the tree is |
|
| 3257 |
-"re-rendered |
|
| 3258 |
-function! s:upDir(keepState) |
|
| 3259 |
- let cwd = b:NERDTreeRoot.path.str({'format': 'UI'})
|
|
| 3260 |
- if cwd ==# "/" || cwd =~# '^[^/]..$' |
|
| 3261 |
- call s:echo("already at top dir")
|
|
| 3262 |
- else |
|
| 3263 |
- if !a:keepState |
|
| 3264 |
- call b:NERDTreeRoot.close() |
|
| 3265 |
- endif |
|
| 3266 |
- |
|
| 3267 |
- let oldRoot = b:NERDTreeRoot |
|
| 3268 |
- |
|
| 3269 |
- if empty(b:NERDTreeRoot.parent) |
|
| 3270 |
- let path = b:NERDTreeRoot.path.getParent() |
|
| 3271 |
- let newRoot = s:TreeDirNode.New(path) |
|
| 3272 |
- call newRoot.open() |
|
| 3273 |
- call newRoot.transplantChild(b:NERDTreeRoot) |
|
| 3274 |
- let b:NERDTreeRoot = newRoot |
|
| 3275 |
- else |
|
| 3276 |
- let b:NERDTreeRoot = b:NERDTreeRoot.parent |
|
| 3277 |
- endif |
|
| 3278 |
- |
|
| 3279 |
- if g:NERDTreeChDirMode ==# 2 |
|
| 3280 |
- call b:NERDTreeRoot.path.changeToDir() |
|
| 3281 |
- endif |
|
| 3282 |
- |
|
| 3283 |
- call s:renderView() |
|
| 3284 |
- call oldRoot.putCursorHere(0, 0) |
|
| 3285 |
- endif |
|
| 3286 |
-endfunction |
|
| 3287 |
-" Function: s:unique(list) {{{2
|
|
| 3288 |
-" returns a:list without duplicates |
|
| 3289 |
-function! s:unique(list) |
|
| 3290 |
- let uniqlist = [] |
|
| 3291 |
- for elem in a:list |
|
| 3292 |
- if index(uniqlist, elem) ==# -1 |
|
| 3293 |
- let uniqlist += [elem] |
|
| 3294 |
- endif |
|
| 3295 |
- endfor |
|
| 3296 |
- return uniqlist |
|
| 3297 |
-endfunction |
|
| 3298 |
-" SECTION: Public API {{{1
|
|
| 3299 |
-"============================================================ |
|
| 3300 |
-let g:NERDTreePath = s:Path |
|
| 3301 |
-let g:NERDTreeDirNode = s:TreeDirNode |
|
| 3302 |
-let g:NERDTreeFileNode = s:TreeFileNode |
|
| 3303 |
-let g:NERDTreeBookmark = s:Bookmark |
|
| 3304 |
- |
|
| 3305 |
-function! NERDTreeAddMenuItem(options) |
|
| 3306 |
- call s:MenuItem.Create(a:options) |
|
| 3307 |
-endfunction |
|
| 3308 |
- |
|
| 3309 |
-function! NERDTreeAddMenuSeparator(...) |
|
| 3310 |
- let opts = a:0 ? a:1 : {}
|
|
| 3311 |
- call s:MenuItem.CreateSeparator(opts) |
|
| 3312 |
-endfunction |
|
| 3313 |
- |
|
| 3314 |
-function! NERDTreeAddSubmenu(options) |
|
| 3315 |
- return s:MenuItem.Create(a:options) |
|
| 3316 |
-endfunction |
|
| 3317 |
- |
|
| 3318 |
-function! NERDTreeAddKeyMap(options) |
|
| 3319 |
- call s:KeyMap.Create(a:options) |
|
| 3320 |
-endfunction |
|
| 3321 |
- |
|
| 3322 |
-function! NERDTreeRender() |
|
| 3323 |
- call s:renderView() |
|
| 3324 |
-endfunction |
|
| 3325 |
- |
|
| 3326 |
-function! NERDTreeFocus() |
|
| 3327 |
- if s:isTreeOpen() |
|
| 3328 |
- call s:putCursorInTreeWin() |
|
| 3329 |
- else |
|
| 3330 |
- call s:toggle("")
|
|
| 3331 |
- endif |
|
| 3332 |
-endfunction |
|
| 3333 |
- |
|
| 3334 |
-function! NERDTreeCWD() |
|
| 3335 |
- call NERDTreeFocus() |
|
| 3336 |
- call s:chRootCwd() |
|
| 3337 |
-endfunction |
|
| 3338 |
- |
|
| 3339 |
-" SECTION: View Functions {{{1
|
|
| 3340 |
-"============================================================ |
|
| 3341 |
-"FUNCTION: s:centerView() {{{2
|
|
| 3342 |
-"centers the nerd tree window around the cursor (provided the nerd tree |
|
| 3343 |
-"options permit) |
|
| 3344 |
-function! s:centerView() |
|
| 3345 |
- if g:NERDTreeAutoCenter |
|
| 3346 |
- let current_line = winline() |
|
| 3347 |
- let lines_to_top = current_line |
|
| 3348 |
- let lines_to_bottom = winheight(s:getTreeWinNum()) - current_line |
|
| 3349 |
- if lines_to_top < g:NERDTreeAutoCenterThreshold || lines_to_bottom < g:NERDTreeAutoCenterThreshold |
|
| 3350 |
- normal! zz |
|
| 3351 |
- endif |
|
| 3352 |
- endif |
|
| 3353 |
-endfunction |
|
| 3354 |
-"FUNCTION: s:closeTree() {{{2
|
|
| 3355 |
-"Closes the primary NERD tree window for this tab |
|
| 3356 |
-function! s:closeTree() |
|
| 3357 |
- if !s:isTreeOpen() |
|
| 3358 |
- throw "NERDTree.NoTreeFoundError: no NERDTree is open" |
|
| 3359 |
- endif |
|
| 3360 |
- |
|
| 3361 |
- if winnr("$") != 1
|
|
| 3362 |
- if winnr() == s:getTreeWinNum() |
|
| 3363 |
- call s:exec("wincmd p")
|
|
| 3364 |
- let bufnr = bufnr("")
|
|
| 3365 |
- call s:exec("wincmd p")
|
|
| 3366 |
- else |
|
| 3367 |
- let bufnr = bufnr("")
|
|
| 3368 |
- endif |
|
| 3369 |
- |
|
| 3370 |
- call s:exec(s:getTreeWinNum() . " wincmd w") |
|
| 3371 |
- close |
|
| 3372 |
- call s:exec(bufwinnr(bufnr) . " wincmd w") |
|
| 3373 |
- else |
|
| 3374 |
- close |
|
| 3375 |
- endif |
|
| 3376 |
-endfunction |
|
| 3377 |
- |
|
| 3378 |
-"FUNCTION: s:closeTreeIfOpen() {{{2
|
|
| 3379 |
-"Closes the NERD tree window if it is open |
|
| 3380 |
-function! s:closeTreeIfOpen() |
|
| 3381 |
- if s:isTreeOpen() |
|
| 3382 |
- call s:closeTree() |
|
| 3383 |
- endif |
|
| 3384 |
-endfunction |
|
| 3385 |
-"FUNCTION: s:closeTreeIfQuitOnOpen() {{{2
|
|
| 3386 |
-"Closes the NERD tree window if the close on open option is set |
|
| 3387 |
-function! s:closeTreeIfQuitOnOpen() |
|
| 3388 |
- if g:NERDTreeQuitOnOpen && s:isTreeOpen() |
|
| 3389 |
- call s:closeTree() |
|
| 3390 |
- endif |
|
| 3391 |
-endfunction |
|
| 3392 |
-"FUNCTION: s:createTreeWin() {{{2
|
|
| 3393 |
-"Inits the NERD tree window. ie. opens it, sizes it, sets all the local |
|
| 3394 |
-"options etc |
|
| 3395 |
-function! s:createTreeWin() |
|
| 3396 |
- "create the nerd tree window |
|
| 3397 |
- let splitLocation = g:NERDTreeWinPos ==# "left" ? "topleft " : "botright " |
|
| 3398 |
- let splitSize = g:NERDTreeWinSize |
|
| 3399 |
- |
|
| 3400 |
- if !exists('t:NERDTreeBufName')
|
|
| 3401 |
- let t:NERDTreeBufName = s:nextBufferName() |
|
| 3402 |
- silent! exec splitLocation . 'vertical ' . splitSize . ' new' |
|
| 3403 |
- silent! exec "edit " . t:NERDTreeBufName |
|
| 3404 |
- else |
|
| 3405 |
- silent! exec splitLocation . 'vertical ' . splitSize . ' split' |
|
| 3406 |
- silent! exec "buffer " . t:NERDTreeBufName |
|
| 3407 |
- endif |
|
| 3408 |
- |
|
| 3409 |
- setlocal winfixwidth |
|
| 3410 |
- call s:setCommonBufOptions() |
|
| 3411 |
-endfunction |
|
| 3412 |
- |
|
| 3413 |
-"FUNCTION: s:dumpHelp {{{2
|
|
| 3414 |
-"prints out the quick help |
|
| 3415 |
-function! s:dumpHelp() |
|
| 3416 |
- let old_h = @h |
|
| 3417 |
- if b:treeShowHelp ==# 1 |
|
| 3418 |
- let @h= "\" NERD tree (" . s:NERD_tree_version . ") quickhelp~\n"
|
|
| 3419 |
- let @h=@h."\" ============================\n" |
|
| 3420 |
- let @h=@h."\" File node mappings~\n" |
|
| 3421 |
- let @h=@h."\" ". (g:NERDTreeMouseMode ==# 3 ? "single" : "double") ."-click,\n" |
|
| 3422 |
- let @h=@h."\" <CR>,\n" |
|
| 3423 |
- if b:NERDTreeType ==# "primary" |
|
| 3424 |
- let @h=@h."\" ". g:NERDTreeMapActivateNode .": open in prev window\n" |
|
| 3425 |
- else |
|
| 3426 |
- let @h=@h."\" ". g:NERDTreeMapActivateNode .": open in current window\n" |
|
| 3427 |
- endif |
|
| 3428 |
- if b:NERDTreeType ==# "primary" |
|
| 3429 |
- let @h=@h."\" ". g:NERDTreeMapPreview .": preview\n" |
|
| 3430 |
- endif |
|
| 3431 |
- let @h=@h."\" ". g:NERDTreeMapOpenInTab.": open in new tab\n" |
|
| 3432 |
- let @h=@h."\" ". g:NERDTreeMapOpenInTabSilent .": open in new tab silently\n" |
|
| 3433 |
- let @h=@h."\" middle-click,\n" |
|
| 3434 |
- let @h=@h."\" ". g:NERDTreeMapOpenSplit .": open split\n" |
|
| 3435 |
- let @h=@h."\" ". g:NERDTreeMapPreviewSplit .": preview split\n" |
|
| 3436 |
- let @h=@h."\" ". g:NERDTreeMapOpenVSplit .": open vsplit\n" |
|
| 3437 |
- let @h=@h."\" ". g:NERDTreeMapPreviewVSplit .": preview vsplit\n" |
|
| 3438 |
- |
|
| 3439 |
- let @h=@h."\"\n\" ----------------------------\n" |
|
| 3440 |
- let @h=@h."\" Directory node mappings~\n" |
|
| 3441 |
- let @h=@h."\" ". (g:NERDTreeMouseMode ==# 1 ? "double" : "single") ."-click,\n" |
|
| 3442 |
- let @h=@h."\" ". g:NERDTreeMapActivateNode .": open & close node\n" |
|
| 3443 |
- let @h=@h."\" ". g:NERDTreeMapOpenRecursively .": recursively open node\n" |
|
| 3444 |
- let @h=@h."\" ". g:NERDTreeMapCloseDir .": close parent of node\n" |
|
| 3445 |
- let @h=@h."\" ". g:NERDTreeMapCloseChildren .": close all child nodes of\n" |
|
| 3446 |
- let @h=@h."\" current node recursively\n" |
|
| 3447 |
- let @h=@h."\" middle-click,\n" |
|
| 3448 |
- let @h=@h."\" ". g:NERDTreeMapOpenExpl.": explore selected dir\n" |
|
| 3449 |
- |
|
| 3450 |
- let @h=@h."\"\n\" ----------------------------\n" |
|
| 3451 |
- let @h=@h."\" Bookmark table mappings~\n" |
|
| 3452 |
- let @h=@h."\" double-click,\n" |
|
| 3453 |
- let @h=@h."\" ". g:NERDTreeMapActivateNode .": open bookmark\n" |
|
| 3454 |
- let @h=@h."\" ". g:NERDTreeMapOpenInTab.": open in new tab\n" |
|
| 3455 |
- let @h=@h."\" ". g:NERDTreeMapOpenInTabSilent .": open in new tab silently\n" |
|
| 3456 |
- let @h=@h."\" ". g:NERDTreeMapDeleteBookmark .": delete bookmark\n" |
|
| 3457 |
- |
|
| 3458 |
- let @h=@h."\"\n\" ----------------------------\n" |
|
| 3459 |
- let @h=@h."\" Tree navigation mappings~\n" |
|
| 3460 |
- let @h=@h."\" ". g:NERDTreeMapJumpRoot .": go to root\n" |
|
| 3461 |
- let @h=@h."\" ". g:NERDTreeMapJumpParent .": go to parent\n" |
|
| 3462 |
- let @h=@h."\" ". g:NERDTreeMapJumpFirstChild .": go to first child\n" |
|
| 3463 |
- let @h=@h."\" ". g:NERDTreeMapJumpLastChild .": go to last child\n" |
|
| 3464 |
- let @h=@h."\" ". g:NERDTreeMapJumpNextSibling .": go to next sibling\n" |
|
| 3465 |
- let @h=@h."\" ". g:NERDTreeMapJumpPrevSibling .": go to prev sibling\n" |
|
| 3466 |
- |
|
| 3467 |
- let @h=@h."\"\n\" ----------------------------\n" |
|
| 3468 |
- let @h=@h."\" Filesystem mappings~\n" |
|
| 3469 |
- let @h=@h."\" ". g:NERDTreeMapChangeRoot .": change tree root to the\n" |
|
| 3470 |
- let @h=@h."\" selected dir\n" |
|
| 3471 |
- let @h=@h."\" ". g:NERDTreeMapUpdir .": move tree root up a dir\n" |
|
| 3472 |
- let @h=@h."\" ". g:NERDTreeMapUpdirKeepOpen .": move tree root up a dir\n" |
|
| 3473 |
- let @h=@h."\" but leave old root open\n" |
|
| 3474 |
- let @h=@h."\" ". g:NERDTreeMapRefresh .": refresh cursor dir\n" |
|
| 3475 |
- let @h=@h."\" ". g:NERDTreeMapRefreshRoot .": refresh current root\n" |
|
| 3476 |
- let @h=@h."\" ". g:NERDTreeMapMenu .": Show menu\n" |
|
| 3477 |
- let @h=@h."\" ". g:NERDTreeMapChdir .":change the CWD to the\n" |
|
| 3478 |
- let @h=@h."\" selected dir\n" |
|
| 3479 |
- let @h=@h."\" ". g:NERDTreeMapCWD .":change tree root to CWD\n" |
|
| 3480 |
- |
|
| 3481 |
- let @h=@h."\"\n\" ----------------------------\n" |
|
| 3482 |
- let @h=@h."\" Tree filtering mappings~\n" |
|
| 3483 |
- let @h=@h."\" ". g:NERDTreeMapToggleHidden .": hidden files (" . (b:NERDTreeShowHidden ? "on" : "off") . ")\n"
|
|
| 3484 |
- let @h=@h."\" ". g:NERDTreeMapToggleFilters .": file filters (" . (b:NERDTreeIgnoreEnabled ? "on" : "off") . ")\n"
|
|
| 3485 |
- let @h=@h."\" ". g:NERDTreeMapToggleFiles .": files (" . (b:NERDTreeShowFiles ? "on" : "off") . ")\n"
|
|
| 3486 |
- let @h=@h."\" ". g:NERDTreeMapToggleBookmarks .": bookmarks (" . (b:NERDTreeShowBookmarks ? "on" : "off") . ")\n"
|
|
| 3487 |
- |
|
| 3488 |
- "add quickhelp entries for each custom key map |
|
| 3489 |
- let @h=@h."\"\n\" ----------------------------\n" |
|
| 3490 |
- let @h=@h."\" Custom mappings~\n" |
|
| 3491 |
- for i in s:KeyMap.All() |
|
| 3492 |
- if !empty(i.quickhelpText) |
|
| 3493 |
- let @h=@h."\" ". i.key .": ". i.quickhelpText ."\n" |
|
| 3494 |
- endif |
|
| 3495 |
- endfor |
|
| 3496 |
- |
|
| 3497 |
- let @h=@h."\"\n\" ----------------------------\n" |
|
| 3498 |
- let @h=@h."\" Other mappings~\n" |
|
| 3499 |
- let @h=@h."\" ". g:NERDTreeMapQuit .": Close the NERDTree window\n" |
|
| 3500 |
- let @h=@h."\" ". g:NERDTreeMapToggleZoom .": Zoom (maximize-minimize)\n" |
|
| 3501 |
- let @h=@h."\" the NERDTree window\n" |
|
| 3502 |
- let @h=@h."\" ". g:NERDTreeMapHelp .": toggle help\n" |
|
| 3503 |
- let @h=@h."\"\n\" ----------------------------\n" |
|
| 3504 |
- let @h=@h."\" Bookmark commands~\n" |
|
| 3505 |
- let @h=@h."\" :Bookmark <name>\n" |
|
| 3506 |
- let @h=@h."\" :BookmarkToRoot <name>\n" |
|
| 3507 |
- let @h=@h."\" :RevealBookmark <name>\n" |
|
| 3508 |
- let @h=@h."\" :OpenBookmark <name>\n" |
|
| 3509 |
- let @h=@h."\" :ClearBookmarks [<names>]\n" |
|
| 3510 |
- let @h=@h."\" :ClearAllBookmarks\n" |
|
| 3511 |
- silent! put h |
|
| 3512 |
- elseif g:NERDTreeMinimalUI == 0 |
|
| 3513 |
- let @h="\" Press ". g:NERDTreeMapHelp ." for help\n" |
|
| 3514 |
- silent! put h |
|
| 3515 |
- endif |
|
| 3516 |
- |
|
| 3517 |
- let @h = old_h |
|
| 3518 |
-endfunction |
|
| 3519 |
-"FUNCTION: s:echo {{{2
|
|
| 3520 |
-"A wrapper for :echo. Appends 'NERDTree:' on the front of all messages |
|
| 3521 |
-" |
|
| 3522 |
-"Args: |
|
| 3523 |
-"msg: the message to echo |
|
| 3524 |
-function! s:echo(msg) |
|
| 3525 |
- redraw |
|
| 3526 |
- echomsg "NERDTree: " . a:msg |
|
| 3527 |
-endfunction |
|
| 3528 |
-"FUNCTION: s:echoWarning {{{2
|
|
| 3529 |
-"Wrapper for s:echo, sets the message type to warningmsg for this message |
|
| 3530 |
-"Args: |
|
| 3531 |
-"msg: the message to echo |
|
| 3532 |
-function! s:echoWarning(msg) |
|
| 3533 |
- echohl warningmsg |
|
| 3534 |
- call s:echo(a:msg) |
|
| 3535 |
- echohl normal |
|
| 3536 |
-endfunction |
|
| 3537 |
-"FUNCTION: s:echoError {{{2
|
|
| 3538 |
-"Wrapper for s:echo, sets the message type to errormsg for this message |
|
| 3539 |
-"Args: |
|
| 3540 |
-"msg: the message to echo |
|
| 3541 |
-function! s:echoError(msg) |
|
| 3542 |
- echohl errormsg |
|
| 3543 |
- call s:echo(a:msg) |
|
| 3544 |
- echohl normal |
|
| 3545 |
-endfunction |
|
| 3546 |
-"FUNCTION: s:firstUsableWindow(){{{2
|
|
| 3547 |
-"find the window number of the first normal window |
|
| 3548 |
-function! s:firstUsableWindow() |
|
| 3549 |
- let i = 1 |
|
| 3550 |
- while i <= winnr("$")
|
|
| 3551 |
- let bnum = winbufnr(i) |
|
| 3552 |
- if bnum != -1 && getbufvar(bnum, '&buftype') ==# '' |
|
| 3553 |
- \ && !getwinvar(i, '&previewwindow') |
|
| 3554 |
- \ && (!getbufvar(bnum, '&modified') || &hidden) |
|
| 3555 |
- return i |
|
| 3556 |
- endif |
|
| 3557 |
- |
|
| 3558 |
- let i += 1 |
|
| 3559 |
- endwhile |
|
| 3560 |
- return -1 |
|
| 3561 |
-endfunction |
|
| 3562 |
-"FUNCTION: s:getPath(ln) {{{2
|
|
| 3563 |
-"Gets the full path to the node that is rendered on the given line number |
|
| 3564 |
-" |
|
| 3565 |
-"Args: |
|
| 3566 |
-"ln: the line number to get the path for |
|
| 3567 |
-" |
|
| 3568 |
-"Return: |
|
| 3569 |
-"A path if a node was selected, {} if nothing is selected.
|
|
| 3570 |
-"If the 'up a dir' line was selected then the path to the parent of the |
|
| 3571 |
-"current root is returned |
|
| 3572 |
-function! s:getPath(ln) |
|
| 3573 |
- let line = getline(a:ln) |
|
| 3574 |
- |
|
| 3575 |
- let rootLine = s:TreeFileNode.GetRootLineNum() |
|
| 3576 |
- |
|
| 3577 |
- "check to see if we have the root node |
|
| 3578 |
- if a:ln == rootLine |
|
| 3579 |
- return b:NERDTreeRoot.path |
|
| 3580 |
- endif |
|
| 3581 |
- |
|
| 3582 |
- if !g:NERDTreeDirArrows |
|
| 3583 |
- " in case called from outside the tree |
|
| 3584 |
- if line !~# '^ *[|`▸▾ ]' || line =~# '^$' |
|
| 3585 |
- return {}
|
|
| 3586 |
- endif |
|
| 3587 |
- endif |
|
| 3588 |
- |
|
| 3589 |
- if line ==# s:tree_up_dir_line |
|
| 3590 |
- return b:NERDTreeRoot.path.getParent() |
|
| 3591 |
- endif |
|
| 3592 |
- |
|
| 3593 |
- let indent = s:indentLevelFor(line) |
|
| 3594 |
- |
|
| 3595 |
- "remove the tree parts and the leading space |
|
| 3596 |
- let curFile = s:stripMarkupFromLine(line, 0) |
|
| 3597 |
- |
|
| 3598 |
- let wasdir = 0 |
|
| 3599 |
- if curFile =~# '/$' |
|
| 3600 |
- let wasdir = 1 |
|
| 3601 |
- let curFile = substitute(curFile, '/\?$', '/', "") |
|
| 3602 |
- endif |
|
| 3603 |
- |
|
| 3604 |
- let dir = "" |
|
| 3605 |
- let lnum = a:ln |
|
| 3606 |
- while lnum > 0 |
|
| 3607 |
- let lnum = lnum - 1 |
|
| 3608 |
- let curLine = getline(lnum) |
|
| 3609 |
- let curLineStripped = s:stripMarkupFromLine(curLine, 1) |
|
| 3610 |
- |
|
| 3611 |
- "have we reached the top of the tree? |
|
| 3612 |
- if lnum == rootLine |
|
| 3613 |
- let dir = b:NERDTreeRoot.path.str({'format': 'UI'}) . dir
|
|
| 3614 |
- break |
|
| 3615 |
- endif |
|
| 3616 |
- if curLineStripped =~# '/$' |
|
| 3617 |
- let lpindent = s:indentLevelFor(curLine) |
|
| 3618 |
- if lpindent < indent |
|
| 3619 |
- let indent = indent - 1 |
|
| 3620 |
- |
|
| 3621 |
- let dir = substitute (curLineStripped,'^\\', "", "") . dir |
|
| 3622 |
- continue |
|
| 3623 |
- endif |
|
| 3624 |
- endif |
|
| 3625 |
- endwhile |
|
| 3626 |
- let curFile = b:NERDTreeRoot.path.drive . dir . curFile |
|
| 3627 |
- let toReturn = s:Path.New(curFile) |
|
| 3628 |
- return toReturn |
|
| 3629 |
-endfunction |
|
| 3630 |
- |
|
| 3631 |
-"FUNCTION: s:getTreeWinNum() {{{2
|
|
| 3632 |
-"gets the nerd tree window number for this tab |
|
| 3633 |
-function! s:getTreeWinNum() |
|
| 3634 |
- if exists("t:NERDTreeBufName")
|
|
| 3635 |
- return bufwinnr(t:NERDTreeBufName) |
|
| 3636 |
- else |
|
| 3637 |
- return -1 |
|
| 3638 |
- endif |
|
| 3639 |
-endfunction |
|
| 3640 |
-"FUNCTION: s:indentLevelFor(line) {{{2
|
|
| 3641 |
-function! s:indentLevelFor(line) |
|
| 3642 |
- let level = match(a:line, '[^ \-+~▸▾`|]') / s:tree_wid |
|
| 3643 |
- " check if line includes arrows |
|
| 3644 |
- if match(a:line, '[▸▾]') > -1 |
|
| 3645 |
- " decrement level as arrow uses 3 ascii chars |
|
| 3646 |
- let level = level - 1 |
|
| 3647 |
- endif |
|
| 3648 |
- return level |
|
| 3649 |
-endfunction |
|
| 3650 |
-"FUNCTION: s:isTreeOpen() {{{2
|
|
| 3651 |
-function! s:isTreeOpen() |
|
| 3652 |
- return s:getTreeWinNum() != -1 |
|
| 3653 |
-endfunction |
|
| 3654 |
-"FUNCTION: s:isWindowUsable(winnumber) {{{2
|
|
| 3655 |
-"Returns 0 if opening a file from the tree in the given window requires it to |
|
| 3656 |
-"be split, 1 otherwise |
|
| 3657 |
-" |
|
| 3658 |
-"Args: |
|
| 3659 |
-"winnumber: the number of the window in question |
|
| 3660 |
-function! s:isWindowUsable(winnumber) |
|
| 3661 |
- "gotta split if theres only one window (i.e. the NERD tree) |
|
| 3662 |
- if winnr("$") ==# 1
|
|
| 3663 |
- return 0 |
|
| 3664 |
- endif |
|
| 3665 |
- |
|
| 3666 |
- let oldwinnr = winnr() |
|
| 3667 |
- call s:exec(a:winnumber . "wincmd p") |
|
| 3668 |
- let specialWindow = getbufvar("%", '&buftype') != '' || getwinvar('%', '&previewwindow')
|
|
| 3669 |
- let modified = &modified |
|
| 3670 |
- call s:exec(oldwinnr . "wincmd p") |
|
| 3671 |
- |
|
| 3672 |
- "if its a special window e.g. quickfix or another explorer plugin then we |
|
| 3673 |
- "have to split |
|
| 3674 |
- if specialWindow |
|
| 3675 |
- return 0 |
|
| 3676 |
- endif |
|
| 3677 |
- |
|
| 3678 |
- if &hidden |
|
| 3679 |
- return 1 |
|
| 3680 |
- endif |
|
| 3681 |
- |
|
| 3682 |
- return !modified || s:bufInWindows(winbufnr(a:winnumber)) >= 2 |
|
| 3683 |
-endfunction |
|
| 3684 |
- |
|
| 3685 |
-" FUNCTION: s:jumpToChild(direction) {{{2
|
|
| 3686 |
-" Args: |
|
| 3687 |
-" direction: 0 if going to first child, 1 if going to last |
|
| 3688 |
-function! s:jumpToChild(currentNode, direction) |
|
| 3689 |
- if a:currentNode.isRoot() |
|
| 3690 |
- return s:echo("cannot jump to " . (a:direction ? "last" : "first") . " child")
|
|
| 3691 |
- end |
|
| 3692 |
- let dirNode = a:currentNode.parent |
|
| 3693 |
- let childNodes = dirNode.getVisibleChildren() |
|
| 3694 |
- |
|
| 3695 |
- let targetNode = childNodes[0] |
|
| 3696 |
- if a:direction |
|
| 3697 |
- let targetNode = childNodes[len(childNodes) - 1] |
|
| 3698 |
- endif |
|
| 3699 |
- |
|
| 3700 |
- if targetNode.equals(a:currentNode) |
|
| 3701 |
- let siblingDir = a:currentNode.parent.findOpenDirSiblingWithVisibleChildren(a:direction) |
|
| 3702 |
- if siblingDir != {}
|
|
| 3703 |
- let indx = a:direction ? siblingDir.getVisibleChildCount()-1 : 0 |
|
| 3704 |
- let targetNode = siblingDir.getChildByIndex(indx, 1) |
|
| 3705 |
- endif |
|
| 3706 |
- endif |
|
| 3707 |
- |
|
| 3708 |
- call targetNode.putCursorHere(1, 0) |
|
| 3709 |
- |
|
| 3710 |
- call s:centerView() |
|
| 3711 |
-endfunction |
|
| 3712 |
- |
|
| 3713 |
- |
|
| 3714 |
-" FUNCTION: s:jumpToSibling(currentNode, forward) {{{2
|
|
| 3715 |
-" moves the cursor to the sibling of the current node in the given direction |
|
| 3716 |
-" |
|
| 3717 |
-" Args: |
|
| 3718 |
-" forward: 1 if the cursor should move to the next sibling, 0 if it should |
|
| 3719 |
-" move back to the previous sibling |
|
| 3720 |
-function! s:jumpToSibling(currentNode, forward) |
|
| 3721 |
- let sibling = a:currentNode.findSibling(a:forward) |
|
| 3722 |
- |
|
| 3723 |
- if !empty(sibling) |
|
| 3724 |
- call sibling.putCursorHere(1, 0) |
|
| 3725 |
- call s:centerView() |
|
| 3726 |
- endif |
|
| 3727 |
-endfunction |
|
| 3728 |
- |
|
| 3729 |
-"FUNCTION: s:promptToDelBuffer(bufnum, msg){{{2
|
|
| 3730 |
-"prints out the given msg and, if the user responds by pushing 'y' then the |
|
| 3731 |
-"buffer with the given bufnum is deleted |
|
| 3732 |
-" |
|
| 3733 |
-"Args: |
|
| 3734 |
-"bufnum: the buffer that may be deleted |
|
| 3735 |
-"msg: a message that will be echoed to the user asking them if they wish to |
|
| 3736 |
-" del the buffer |
|
| 3737 |
-function! s:promptToDelBuffer(bufnum, msg) |
|
| 3738 |
- echo a:msg |
|
| 3739 |
- if nr2char(getchar()) ==# 'y' |
|
| 3740 |
- exec "silent bdelete! " . a:bufnum |
|
| 3741 |
- endif |
|
| 3742 |
-endfunction |
|
| 3743 |
- |
|
| 3744 |
-"FUNCTION: s:putCursorOnBookmarkTable(){{{2
|
|
| 3745 |
-"Places the cursor at the top of the bookmarks table |
|
| 3746 |
-function! s:putCursorOnBookmarkTable() |
|
| 3747 |
- if !b:NERDTreeShowBookmarks |
|
| 3748 |
- throw "NERDTree.IllegalOperationError: cant find bookmark table, bookmarks arent active" |
|
| 3749 |
- endif |
|
| 3750 |
- |
|
| 3751 |
- if g:NERDTreeMinimalUI |
|
| 3752 |
- return cursor(1, 2) |
|
| 3753 |
- endif |
|
| 3754 |
- |
|
| 3755 |
- let rootNodeLine = s:TreeFileNode.GetRootLineNum() |
|
| 3756 |
- |
|
| 3757 |
- let line = 1 |
|
| 3758 |
- while getline(line) !~# '^>-\+Bookmarks-\+$' |
|
| 3759 |
- let line = line + 1 |
|
| 3760 |
- if line >= rootNodeLine |
|
| 3761 |
- throw "NERDTree.BookmarkTableNotFoundError: didnt find the bookmarks table" |
|
| 3762 |
- endif |
|
| 3763 |
- endwhile |
|
| 3764 |
- call cursor(line, 2) |
|
| 3765 |
-endfunction |
|
| 3766 |
- |
|
| 3767 |
-"FUNCTION: s:putCursorInTreeWin(){{{2
|
|
| 3768 |
-"Places the cursor in the nerd tree window |
|
| 3769 |
-function! s:putCursorInTreeWin() |
|
| 3770 |
- if !s:isTreeOpen() |
|
| 3771 |
- throw "NERDTree.InvalidOperationError: cant put cursor in NERD tree window, no window exists" |
|
| 3772 |
- endif |
|
| 3773 |
- |
|
| 3774 |
- call s:exec(s:getTreeWinNum() . "wincmd w") |
|
| 3775 |
-endfunction |
|
| 3776 |
- |
|
| 3777 |
-"FUNCTION: s:renderBookmarks {{{2
|
|
| 3778 |
-function! s:renderBookmarks() |
|
| 3779 |
- |
|
| 3780 |
- if g:NERDTreeMinimalUI == 0 |
|
| 3781 |
- call setline(line(".")+1, ">----------Bookmarks----------")
|
|
| 3782 |
- call cursor(line(".")+1, col("."))
|
|
| 3783 |
- endif |
|
| 3784 |
- |
|
| 3785 |
- for i in s:Bookmark.Bookmarks() |
|
| 3786 |
- call setline(line(".")+1, i.str())
|
|
| 3787 |
- call cursor(line(".")+1, col("."))
|
|
| 3788 |
- endfor |
|
| 3789 |
- |
|
| 3790 |
- call setline(line(".")+1, '')
|
|
| 3791 |
- call cursor(line(".")+1, col("."))
|
|
| 3792 |
-endfunction |
|
| 3793 |
-"FUNCTION: s:renderView {{{2
|
|
| 3794 |
-"The entry function for rendering the tree |
|
| 3795 |
-function! s:renderView() |
|
| 3796 |
- setlocal modifiable |
|
| 3797 |
- |
|
| 3798 |
- "remember the top line of the buffer and the current line so we can |
|
| 3799 |
- "restore the view exactly how it was |
|
| 3800 |
- let curLine = line(".")
|
|
| 3801 |
- let curCol = col(".")
|
|
| 3802 |
- let topLine = line("w0")
|
|
| 3803 |
- |
|
| 3804 |
- "delete all lines in the buffer (being careful not to clobber a register) |
|
| 3805 |
- silent 1,$delete _ |
|
| 3806 |
- |
|
| 3807 |
- call s:dumpHelp() |
|
| 3808 |
- |
|
| 3809 |
- "delete the blank line before the help and add one after it |
|
| 3810 |
- if g:NERDTreeMinimalUI == 0 |
|
| 3811 |
- call setline(line(".")+1, "")
|
|
| 3812 |
- call cursor(line(".")+1, col("."))
|
|
| 3813 |
- endif |
|
| 3814 |
- |
|
| 3815 |
- if b:NERDTreeShowBookmarks |
|
| 3816 |
- call s:renderBookmarks() |
|
| 3817 |
- endif |
|
| 3818 |
- |
|
| 3819 |
- "add the 'up a dir' line |
|
| 3820 |
- if !g:NERDTreeMinimalUI |
|
| 3821 |
- call setline(line(".")+1, s:tree_up_dir_line)
|
|
| 3822 |
- call cursor(line(".")+1, col("."))
|
|
| 3823 |
- endif |
|
| 3824 |
- |
|
| 3825 |
- "draw the header line |
|
| 3826 |
- let header = b:NERDTreeRoot.path.str({'format': 'UI', 'truncateTo': winwidth(0)})
|
|
| 3827 |
- call setline(line(".")+1, header)
|
|
| 3828 |
- call cursor(line(".")+1, col("."))
|
|
| 3829 |
- |
|
| 3830 |
- "draw the tree |
|
| 3831 |
- let old_o = @o |
|
| 3832 |
- let @o = b:NERDTreeRoot.renderToString() |
|
| 3833 |
- silent put o |
|
| 3834 |
- let @o = old_o |
|
| 3835 |
- |
|
| 3836 |
- "delete the blank line at the top of the buffer |
|
| 3837 |
- silent 1,1delete _ |
|
| 3838 |
- |
|
| 3839 |
- "restore the view |
|
| 3840 |
- let old_scrolloff=&scrolloff |
|
| 3841 |
- let &scrolloff=0 |
|
| 3842 |
- call cursor(topLine, 1) |
|
| 3843 |
- normal! zt |
|
| 3844 |
- call cursor(curLine, curCol) |
|
| 3845 |
- let &scrolloff = old_scrolloff |
|
| 3846 |
- |
|
| 3847 |
- setlocal nomodifiable |
|
| 3848 |
-endfunction |
|
| 3849 |
- |
|
| 3850 |
-"FUNCTION: s:renderViewSavingPosition {{{2
|
|
| 3851 |
-"Renders the tree and ensures the cursor stays on the current node or the |
|
| 3852 |
-"current nodes parent if it is no longer available upon re-rendering |
|
| 3853 |
-function! s:renderViewSavingPosition() |
|
| 3854 |
- let currentNode = s:TreeFileNode.GetSelected() |
|
| 3855 |
- |
|
| 3856 |
- "go up the tree till we find a node that will be visible or till we run |
|
| 3857 |
- "out of nodes |
|
| 3858 |
- while currentNode != {} && !currentNode.isVisible() && !currentNode.isRoot()
|
|
| 3859 |
- let currentNode = currentNode.parent |
|
| 3860 |
- endwhile |
|
| 3861 |
- |
|
| 3862 |
- call s:renderView() |
|
| 3863 |
- |
|
| 3864 |
- if currentNode != {}
|
|
| 3865 |
- call currentNode.putCursorHere(0, 0) |
|
| 3866 |
- endif |
|
| 3867 |
-endfunction |
|
| 3868 |
-"FUNCTION: s:restoreScreenState() {{{2
|
|
| 3869 |
-" |
|
| 3870 |
-"Sets the screen state back to what it was when s:saveScreenState was last |
|
| 3871 |
-"called. |
|
| 3872 |
-" |
|
| 3873 |
-"Assumes the cursor is in the NERDTree window |
|
| 3874 |
-function! s:restoreScreenState() |
|
| 3875 |
- if !exists("b:NERDTreeOldTopLine") || !exists("b:NERDTreeOldPos") || !exists("b:NERDTreeOldWindowSize")
|
|
| 3876 |
- return |
|
| 3877 |
- endif |
|
| 3878 |
- exec("silent vertical resize ".b:NERDTreeOldWindowSize)
|
|
| 3879 |
- |
|
| 3880 |
- let old_scrolloff=&scrolloff |
|
| 3881 |
- let &scrolloff=0 |
|
| 3882 |
- call cursor(b:NERDTreeOldTopLine, 0) |
|
| 3883 |
- normal! zt |
|
| 3884 |
- call setpos(".", b:NERDTreeOldPos)
|
|
| 3885 |
- let &scrolloff=old_scrolloff |
|
| 3886 |
-endfunction |
|
| 3887 |
- |
|
| 3888 |
-"FUNCTION: s:saveScreenState() {{{2
|
|
| 3889 |
-"Saves the current cursor position in the current buffer and the window |
|
| 3890 |
-"scroll position |
|
| 3891 |
-function! s:saveScreenState() |
|
| 3892 |
- let win = winnr() |
|
| 3893 |
- try |
|
| 3894 |
- call s:putCursorInTreeWin() |
|
| 3895 |
- let b:NERDTreeOldPos = getpos(".")
|
|
| 3896 |
- let b:NERDTreeOldTopLine = line("w0")
|
|
| 3897 |
- let b:NERDTreeOldWindowSize = winwidth("")
|
|
| 3898 |
- call s:exec(win . "wincmd w") |
|
| 3899 |
- catch /^NERDTree.InvalidOperationError/ |
|
| 3900 |
- endtry |
|
| 3901 |
-endfunction |
|
| 3902 |
- |
|
| 3903 |
-"FUNCTION: s:setCommonBufOptions() {{{2
|
|
| 3904 |
-function! s:setCommonBufOptions() |
|
| 3905 |
- "throwaway buffer options |
|
| 3906 |
- setlocal noswapfile |
|
| 3907 |
- setlocal buftype=nofile |
|
| 3908 |
- setlocal bufhidden=hide |
|
| 3909 |
- setlocal nowrap |
|
| 3910 |
- setlocal foldcolumn=0 |
|
| 3911 |
- setlocal foldmethod=manual |
|
| 3912 |
- setlocal nofoldenable |
|
| 3913 |
- setlocal nobuflisted |
|
| 3914 |
- setlocal nospell |
|
| 3915 |
- if g:NERDTreeShowLineNumbers |
|
| 3916 |
- setlocal nu |
|
| 3917 |
- else |
|
| 3918 |
- setlocal nonu |
|
| 3919 |
- if v:version >= 703 |
|
| 3920 |
- setlocal nornu |
|
| 3921 |
- endif |
|
| 3922 |
- endif |
|
| 3923 |
- |
|
| 3924 |
- iabc <buffer> |
|
| 3925 |
- |
|
| 3926 |
- if g:NERDTreeHighlightCursorline |
|
| 3927 |
- setlocal cursorline |
|
| 3928 |
- endif |
|
| 3929 |
- |
|
| 3930 |
- call s:setupStatusline() |
|
| 3931 |
- |
|
| 3932 |
- |
|
| 3933 |
- let b:treeShowHelp = 0 |
|
| 3934 |
- let b:NERDTreeIgnoreEnabled = 1 |
|
| 3935 |
- let b:NERDTreeShowFiles = g:NERDTreeShowFiles |
|
| 3936 |
- let b:NERDTreeShowHidden = g:NERDTreeShowHidden |
|
| 3937 |
- let b:NERDTreeShowBookmarks = g:NERDTreeShowBookmarks |
|
| 3938 |
- setfiletype nerdtree |
|
| 3939 |
- call s:bindMappings() |
|
| 3940 |
-endfunction |
|
| 3941 |
- |
|
| 3942 |
-"FUNCTION: s:setupStatusline() {{{2
|
|
| 3943 |
-function! s:setupStatusline() |
|
| 3944 |
- if g:NERDTreeStatusline != -1 |
|
| 3945 |
- let &l:statusline = g:NERDTreeStatusline |
|
| 3946 |
- endif |
|
| 3947 |
-endfunction |
|
| 3948 |
-"FUNCTION: s:stripMarkupFromLine(line, removeLeadingSpaces){{{2
|
|
| 3949 |
-"returns the given line with all the tree parts stripped off |
|
| 3950 |
-" |
|
| 3951 |
-"Args: |
|
| 3952 |
-"line: the subject line |
|
| 3953 |
-"removeLeadingSpaces: 1 if leading spaces are to be removed (leading spaces = |
|
| 3954 |
-"any spaces before the actual text of the node) |
|
| 3955 |
-function! s:stripMarkupFromLine(line, removeLeadingSpaces) |
|
| 3956 |
- let line = a:line |
|
| 3957 |
- "remove the tree parts and the leading space |
|
| 3958 |
- let line = substitute (line, s:tree_markup_reg,"","") |
|
| 3959 |
- |
|
| 3960 |
- "strip off any read only flag |
|
| 3961 |
- let line = substitute (line, ' \[RO\]', "","") |
|
| 3962 |
- |
|
| 3963 |
- "strip off any bookmark flags |
|
| 3964 |
- let line = substitute (line, ' {[^}]*}', "","")
|
|
| 3965 |
- |
|
| 3966 |
- "strip off any executable flags |
|
| 3967 |
- let line = substitute (line, '*\ze\($\| \)', "","") |
|
| 3968 |
- |
|
| 3969 |
- let wasdir = 0 |
|
| 3970 |
- if line =~# '/$' |
|
| 3971 |
- let wasdir = 1 |
|
| 3972 |
- endif |
|
| 3973 |
- let line = substitute (line,' -> .*',"","") " remove link to |
|
| 3974 |
- if wasdir ==# 1 |
|
| 3975 |
- let line = substitute (line, '/\?$', '/', "") |
|
| 3976 |
- endif |
|
| 3977 |
- |
|
| 3978 |
- if a:removeLeadingSpaces |
|
| 3979 |
- let line = substitute (line, '^ *', '', '') |
|
| 3980 |
- endif |
|
| 3981 |
- |
|
| 3982 |
- return line |
|
| 3983 |
-endfunction |
|
| 3984 |
- |
|
| 3985 |
-"FUNCTION: s:toggle(dir) {{{2
|
|
| 3986 |
-"Toggles the NERD tree. I.e the NERD tree is open, it is closed, if it is |
|
| 3987 |
-"closed it is restored or initialized (if it doesnt exist) |
|
| 3988 |
-" |
|
| 3989 |
-"Args: |
|
| 3990 |
-"dir: the full path for the root node (is only used if the NERD tree is being |
|
| 3991 |
-"initialized. |
|
| 3992 |
-function! s:toggle(dir) |
|
| 3993 |
- if s:treeExistsForTab() |
|
| 3994 |
- if !s:isTreeOpen() |
|
| 3995 |
- call s:createTreeWin() |
|
| 3996 |
- if !&hidden |
|
| 3997 |
- call s:renderView() |
|
| 3998 |
- endif |
|
| 3999 |
- call s:restoreScreenState() |
|
| 4000 |
- else |
|
| 4001 |
- call s:closeTree() |
|
| 4002 |
- endif |
|
| 4003 |
- else |
|
| 4004 |
- call s:initNerdTree(a:dir) |
|
| 4005 |
- endif |
|
| 4006 |
-endfunction |
|
| 4007 |
-"SECTION: Interface bindings {{{1
|
|
| 4008 |
-"============================================================ |
|
| 4009 |
- |
|
| 4010 |
-"FUNCTION: s:activateAll() {{{2
|
|
| 4011 |
-"handle the user activating the updir line |
|
| 4012 |
-function! s:activateAll() |
|
| 4013 |
- if getline(".") ==# s:tree_up_dir_line
|
|
| 4014 |
- return s:upDir(0) |
|
| 4015 |
- endif |
|
| 4016 |
-endfunction |
|
| 4017 |
- |
|
| 4018 |
-"FUNCTION: s:activateDirNode() {{{2
|
|
| 4019 |
-"handle the user activating a tree node |
|
| 4020 |
-function! s:activateDirNode(node) |
|
| 4021 |
- call a:node.activate({'reuse': 1})
|
|
| 4022 |
-endfunction |
|
| 4023 |
- |
|
| 4024 |
-"FUNCTION: s:activateFileNode() {{{2
|
|
| 4025 |
-"handle the user activating a tree node |
|
| 4026 |
-function! s:activateFileNode(node) |
|
| 4027 |
- call a:node.activate({'reuse': 1, 'where': 'p'})
|
|
| 4028 |
-endfunction |
|
| 4029 |
- |
|
| 4030 |
-"FUNCTION: s:activateBookmark() {{{2
|
|
| 4031 |
-"handle the user activating a bookmark |
|
| 4032 |
-function! s:activateBookmark(bm) |
|
| 4033 |
- call a:bm.activate(!a:bm.path.isDirectory ? {'where': 'p'} : {})
|
|
| 4034 |
-endfunction |
|
| 4035 |
- |
|
| 4036 |
-"FUNCTION: s:bindMappings() {{{2
|
|
| 4037 |
-function! s:bindMappings() |
|
| 4038 |
- "make <cr> do the same as the default 'o' mapping |
|
| 4039 |
- exec "nnoremap <silent> <buffer> <cr> :call <SID>KeyMap_Invoke('". g:NERDTreeMapActivateNode ."')<cr>"
|
|
| 4040 |
- |
|
| 4041 |
- call s:KeyMap.BindAll() |
|
| 4042 |
- |
|
| 4043 |
- command! -buffer -nargs=? Bookmark :call <SID>bookmarkNode('<args>')
|
|
| 4044 |
- command! -buffer -complete=customlist,s:completeBookmarks -nargs=1 RevealBookmark :call <SID>revealBookmark('<args>')
|
|
| 4045 |
- command! -buffer -complete=customlist,s:completeBookmarks -nargs=1 OpenBookmark :call <SID>openBookmark('<args>')
|
|
| 4046 |
- command! -buffer -complete=customlist,s:completeBookmarks -nargs=* ClearBookmarks call <SID>clearBookmarks('<args>')
|
|
| 4047 |
- command! -buffer -complete=customlist,s:completeBookmarks -nargs=+ BookmarkToRoot call s:Bookmark.ToRoot('<args>')
|
|
| 4048 |
- command! -buffer -nargs=0 ClearAllBookmarks call s:Bookmark.ClearAll() <bar> call <SID>renderView() |
|
| 4049 |
- command! -buffer -nargs=0 ReadBookmarks call s:Bookmark.CacheBookmarks(0) <bar> call <SID>renderView() |
|
| 4050 |
- command! -buffer -nargs=0 WriteBookmarks call s:Bookmark.Write() |
|
| 4051 |
-endfunction |
|
| 4052 |
- |
|
| 4053 |
-" FUNCTION: s:bookmarkNode(name) {{{2
|
|
| 4054 |
-" Associate the current node with the given name |
|
| 4055 |
-function! s:bookmarkNode(...) |
|
| 4056 |
- let currentNode = s:TreeFileNode.GetSelected() |
|
| 4057 |
- if currentNode != {}
|
|
| 4058 |
- let name = a:1 |
|
| 4059 |
- if empty(name) |
|
| 4060 |
- let name = currentNode.path.getLastPathComponent(0) |
|
| 4061 |
- endif |
|
| 4062 |
- try |
|
| 4063 |
- call currentNode.bookmark(name) |
|
| 4064 |
- call s:renderView() |
|
| 4065 |
- catch /^NERDTree.IllegalBookmarkNameError/ |
|
| 4066 |
- call s:echo("bookmark names must not contain spaces")
|
|
| 4067 |
- endtry |
|
| 4068 |
- else |
|
| 4069 |
- call s:echo("select a node first")
|
|
| 4070 |
- endif |
|
| 4071 |
-endfunction |
|
| 4072 |
- |
|
| 4073 |
-" FUNCTION: s:chCwd(node) {{{2
|
|
| 4074 |
-function! s:chCwd(node) |
|
| 4075 |
- try |
|
| 4076 |
- call a:node.path.changeToDir() |
|
| 4077 |
- catch /^NERDTree.PathChangeError/ |
|
| 4078 |
- call s:echoWarning("could not change cwd")
|
|
| 4079 |
- endtry |
|
| 4080 |
-endfunction |
|
| 4081 |
- |
|
| 4082 |
-" FUNCTION: s:chRoot(node) {{{2
|
|
| 4083 |
-" changes the current root to the selected one |
|
| 4084 |
-function! s:chRoot(node) |
|
| 4085 |
- call a:node.makeRoot() |
|
| 4086 |
- call s:renderView() |
|
| 4087 |
- call b:NERDTreeRoot.putCursorHere(0, 0) |
|
| 4088 |
-endfunction |
|
| 4089 |
- |
|
| 4090 |
-" FUNCTION: s:chRootCwd() {{{2
|
|
| 4091 |
-" changes the current root to CWD |
|
| 4092 |
-function! s:chRootCwd() |
|
| 4093 |
- try |
|
| 4094 |
- let cwd = s:Path.New(getcwd()) |
|
| 4095 |
- catch /^NERDTree.InvalidArgumentsError/ |
|
| 4096 |
- call s:echo("current directory does not exist.")
|
|
| 4097 |
- return |
|
| 4098 |
- endtry |
|
| 4099 |
- if cwd.str() == s:TreeFileNode.GetRootForTab().path.str() |
|
| 4100 |
- return |
|
| 4101 |
- endif |
|
| 4102 |
- call s:chRoot(s:TreeDirNode.New(cwd)) |
|
| 4103 |
-endfunction |
|
| 4104 |
- |
|
| 4105 |
-" FUNCTION: s:clearBookmarks(bookmarks) {{{2
|
|
| 4106 |
-function! s:clearBookmarks(bookmarks) |
|
| 4107 |
- if a:bookmarks ==# '' |
|
| 4108 |
- let currentNode = s:TreeFileNode.GetSelected() |
|
| 4109 |
- if currentNode != {}
|
|
| 4110 |
- call currentNode.clearBookmarks() |
|
| 4111 |
- endif |
|
| 4112 |
- else |
|
| 4113 |
- for name in split(a:bookmarks, ' ') |
|
| 4114 |
- let bookmark = s:Bookmark.BookmarkFor(name) |
|
| 4115 |
- call bookmark.delete() |
|
| 4116 |
- endfor |
|
| 4117 |
- endif |
|
| 4118 |
- call s:renderView() |
|
| 4119 |
-endfunction |
|
| 4120 |
-" FUNCTION: s:closeChildren(node) {{{2
|
|
| 4121 |
-" closes all childnodes of the current node |
|
| 4122 |
-function! s:closeChildren(node) |
|
| 4123 |
- call a:node.closeChildren() |
|
| 4124 |
- call s:renderView() |
|
| 4125 |
- call a:node.putCursorHere(0, 0) |
|
| 4126 |
-endfunction |
|
| 4127 |
-" FUNCTION: s:closeCurrentDir(node) {{{2
|
|
| 4128 |
-" closes the parent dir of the current node |
|
| 4129 |
-function! s:closeCurrentDir(node) |
|
| 4130 |
- let parent = a:node.parent |
|
| 4131 |
- if parent ==# {} || parent.isRoot()
|
|
| 4132 |
- call s:echo("cannot close tree root")
|
|
| 4133 |
- else |
|
| 4134 |
- call a:node.parent.close() |
|
| 4135 |
- call s:renderView() |
|
| 4136 |
- call a:node.parent.putCursorHere(0, 0) |
|
| 4137 |
- endif |
|
| 4138 |
-endfunction |
|
| 4139 |
-" FUNCTION: s:closeTreeWindow() {{{2
|
|
| 4140 |
-" close the tree window |
|
| 4141 |
-function! s:closeTreeWindow() |
|
| 4142 |
- if b:NERDTreeType ==# "secondary" && b:NERDTreePreviousBuf != -1 |
|
| 4143 |
- exec "buffer " . b:NERDTreePreviousBuf |
|
| 4144 |
- else |
|
| 4145 |
- if winnr("$") > 1
|
|
| 4146 |
- call s:closeTree() |
|
| 4147 |
- else |
|
| 4148 |
- call s:echo("Cannot close last window")
|
|
| 4149 |
- endif |
|
| 4150 |
- endif |
|
| 4151 |
-endfunction |
|
| 4152 |
-" FUNCTION: s:deleteBookmark(bm) {{{2
|
|
| 4153 |
-" if the cursor is on a bookmark, prompt to delete |
|
| 4154 |
-function! s:deleteBookmark(bm) |
|
| 4155 |
- echo "Are you sure you wish to delete the bookmark:\n\"" . a:bm.name . "\" (yN):" |
|
| 4156 |
- |
|
| 4157 |
- if nr2char(getchar()) ==# 'y' |
|
| 4158 |
- try |
|
| 4159 |
- call a:bm.delete() |
|
| 4160 |
- call s:renderView() |
|
| 4161 |
- redraw |
|
| 4162 |
- catch /^NERDTree/ |
|
| 4163 |
- call s:echoWarning("Could not remove bookmark")
|
|
| 4164 |
- endtry |
|
| 4165 |
- else |
|
| 4166 |
- call s:echo("delete aborted" )
|
|
| 4167 |
- endif |
|
| 4168 |
- |
|
| 4169 |
-endfunction |
|
| 4170 |
- |
|
| 4171 |
-" FUNCTION: s:displayHelp() {{{2
|
|
| 4172 |
-" toggles the help display |
|
| 4173 |
-function! s:displayHelp() |
|
| 4174 |
- let b:treeShowHelp = b:treeShowHelp ? 0 : 1 |
|
| 4175 |
- call s:renderView() |
|
| 4176 |
- call s:centerView() |
|
| 4177 |
-endfunction |
|
| 4178 |
- |
|
| 4179 |
-"FUNCTION: s:handleLeftClick() {{{2
|
|
| 4180 |
-"Checks if the click should open the current node |
|
| 4181 |
-function! s:handleLeftClick() |
|
| 4182 |
- let currentNode = s:TreeFileNode.GetSelected() |
|
| 4183 |
- if currentNode != {}
|
|
| 4184 |
- |
|
| 4185 |
- "the dir arrows are multibyte chars, and vim's string functions only |
|
| 4186 |
- "deal with single bytes - so split the line up with the hack below and |
|
| 4187 |
- "take the line substring manually |
|
| 4188 |
- let line = split(getline(line(".")), '\zs')
|
|
| 4189 |
- let startToCur = "" |
|
| 4190 |
- for i in range(0,len(line)-1) |
|
| 4191 |
- let startToCur .= line[i] |
|
| 4192 |
- endfor |
|
| 4193 |
- |
|
| 4194 |
- if currentNode.path.isDirectory |
|
| 4195 |
- if startToCur =~# s:tree_markup_reg && startToCur =~# '[+~▾▸] \?$' |
|
| 4196 |
- call currentNode.activate() |
|
| 4197 |
- return |
|
| 4198 |
- endif |
|
| 4199 |
- endif |
|
| 4200 |
- |
|
| 4201 |
- if (g:NERDTreeMouseMode ==# 2 && currentNode.path.isDirectory) || g:NERDTreeMouseMode ==# 3 |
|
| 4202 |
- let char = strpart(startToCur, strlen(startToCur)-1, 1) |
|
| 4203 |
- if char !~# s:tree_markup_reg |
|
| 4204 |
- if currentNode.path.isDirectory |
|
| 4205 |
- call currentNode.activate() |
|
| 4206 |
- else |
|
| 4207 |
- call currentNode.activate({'reuse': 1, 'where': 'p'})
|
|
| 4208 |
- endif |
|
| 4209 |
- return |
|
| 4210 |
- endif |
|
| 4211 |
- endif |
|
| 4212 |
- endif |
|
| 4213 |
-endfunction |
|
| 4214 |
- |
|
| 4215 |
-" FUNCTION: s:handleMiddleMouse() {{{2
|
|
| 4216 |
-function! s:handleMiddleMouse() |
|
| 4217 |
- let curNode = s:TreeFileNode.GetSelected() |
|
| 4218 |
- if curNode ==# {}
|
|
| 4219 |
- call s:echo("Put the cursor on a node first" )
|
|
| 4220 |
- return |
|
| 4221 |
- endif |
|
| 4222 |
- |
|
| 4223 |
- if curNode.path.isDirectory |
|
| 4224 |
- call s:openExplorer(curNode) |
|
| 4225 |
- else |
|
| 4226 |
- call curNode.open({'where': 'h'})
|
|
| 4227 |
- endif |
|
| 4228 |
-endfunction |
|
| 4229 |
- |
|
| 4230 |
-" FUNCTION: s:jumpToFirstChild() {{{2
|
|
| 4231 |
-" wrapper for the jump to child method |
|
| 4232 |
-function! s:jumpToFirstChild(node) |
|
| 4233 |
- call s:jumpToChild(a:node, 0) |
|
| 4234 |
-endfunction |
|
| 4235 |
- |
|
| 4236 |
-" FUNCTION: s:jumpToLastChild() {{{2
|
|
| 4237 |
-" wrapper for the jump to child method |
|
| 4238 |
-function! s:jumpToLastChild(node) |
|
| 4239 |
- call s:jumpToChild(a:node, 1) |
|
| 4240 |
-endfunction |
|
| 4241 |
- |
|
| 4242 |
-" FUNCTION: s:jumpToParent(node) {{{2
|
|
| 4243 |
-" moves the cursor to the parent of the current node |
|
| 4244 |
-function! s:jumpToParent(node) |
|
| 4245 |
- if !empty(a:node.parent) |
|
| 4246 |
- call a:node.parent.putCursorHere(1, 0) |
|
| 4247 |
- call s:centerView() |
|
| 4248 |
- else |
|
| 4249 |
- call s:echo("cannot jump to parent")
|
|
| 4250 |
- endif |
|
| 4251 |
-endfunction |
|
| 4252 |
- |
|
| 4253 |
-" FUNCTION: s:jumpToRoot() {{{2
|
|
| 4254 |
-" moves the cursor to the root node |
|
| 4255 |
-function! s:jumpToRoot() |
|
| 4256 |
- call b:NERDTreeRoot.putCursorHere(1, 0) |
|
| 4257 |
- call s:centerView() |
|
| 4258 |
-endfunction |
|
| 4259 |
- |
|
| 4260 |
-" FUNCTION: s:jumpToNextSibling(node) {{{2
|
|
| 4261 |
-function! s:jumpToNextSibling(node) |
|
| 4262 |
- call s:jumpToSibling(a:node, 1) |
|
| 4263 |
-endfunction |
|
| 4264 |
- |
|
| 4265 |
-" FUNCTION: s:jumpToPrevSibling(node) {{{2
|
|
| 4266 |
-function! s:jumpToPrevSibling(node) |
|
| 4267 |
- call s:jumpToSibling(a:node, 0) |
|
| 4268 |
-endfunction |
|
| 4269 |
- |
|
| 4270 |
-" FUNCTION: s:openBookmark(name) {{{2
|
|
| 4271 |
-" put the cursor on the given bookmark and, if its a file, open it |
|
| 4272 |
-function! s:openBookmark(name) |
|
| 4273 |
- try |
|
| 4274 |
- let targetNode = s:Bookmark.GetNodeForName(a:name, 0) |
|
| 4275 |
- call targetNode.putCursorHere(0, 1) |
|
| 4276 |
- redraw! |
|
| 4277 |
- catch /^NERDTree.BookmarkedNodeNotFoundError/ |
|
| 4278 |
- call s:echo("note - target node is not cached")
|
|
| 4279 |
- let bookmark = s:Bookmark.BookmarkFor(a:name) |
|
| 4280 |
- let targetNode = s:TreeFileNode.New(bookmark.path) |
|
| 4281 |
- endtry |
|
| 4282 |
- if targetNode.path.isDirectory |
|
| 4283 |
- call targetNode.openExplorer() |
|
| 4284 |
- else |
|
| 4285 |
- call targetNode.open({'where': 'p'})
|
|
| 4286 |
- endif |
|
| 4287 |
-endfunction |
|
| 4288 |
- |
|
| 4289 |
-" FUNCTION: s:openHSplit(target) {{{2
|
|
| 4290 |
-function! s:openHSplit(target) |
|
| 4291 |
- call a:target.activate({'where': 'h'})
|
|
| 4292 |
-endfunction |
|
| 4293 |
- |
|
| 4294 |
-" FUNCTION: s:openVSplit(target) {{{2
|
|
| 4295 |
-function! s:openVSplit(target) |
|
| 4296 |
- call a:target.activate({'where': 'v'})
|
|
| 4297 |
-endfunction |
|
| 4298 |
- |
|
| 4299 |
-" FUNCTION: s:openExplorer(node) {{{2
|
|
| 4300 |
-function! s:openExplorer(node) |
|
| 4301 |
- call a:node.openExplorer() |
|
| 4302 |
-endfunction |
|
| 4303 |
- |
|
| 4304 |
-" FUNCTION: s:openInNewTab(target) {{{2
|
|
| 4305 |
-function! s:openInNewTab(target) |
|
| 4306 |
- call a:target.activate({'where': 't'})
|
|
| 4307 |
-endfunction |
|
| 4308 |
- |
|
| 4309 |
-" FUNCTION: s:openInNewTabSilent(target) {{{2
|
|
| 4310 |
-function! s:openInNewTabSilent(target) |
|
| 4311 |
- call a:target.activate({'where': 't', 'stay': 1})
|
|
| 4312 |
-endfunction |
|
| 4313 |
- |
|
| 4314 |
-" FUNCTION: s:openNodeRecursively(node) {{{2
|
|
| 4315 |
-function! s:openNodeRecursively(node) |
|
| 4316 |
- call s:echo("Recursively opening node. Please wait...")
|
|
| 4317 |
- call a:node.openRecursively() |
|
| 4318 |
- call s:renderView() |
|
| 4319 |
- redraw |
|
| 4320 |
- call s:echo("Recursively opening node. Please wait... DONE")
|
|
| 4321 |
-endfunction |
|
| 4322 |
- |
|
| 4323 |
-"FUNCTION: s:previewNodeCurrent(node) {{{2
|
|
| 4324 |
-function! s:previewNodeCurrent(node) |
|
| 4325 |
- call a:node.open({'stay': 1, 'where': 'p', 'keepopen': 1})
|
|
| 4326 |
-endfunction |
|
| 4327 |
- |
|
| 4328 |
-"FUNCTION: s:previewNodeHSplit(node) {{{2
|
|
| 4329 |
-function! s:previewNodeHSplit(node) |
|
| 4330 |
- call a:node.open({'stay': 1, 'where': 'h', 'keepopen': 1})
|
|
| 4331 |
-endfunction |
|
| 4332 |
- |
|
| 4333 |
-"FUNCTION: s:previewNodeVSplit(node) {{{2
|
|
| 4334 |
-function! s:previewNodeVSplit(node) |
|
| 4335 |
- call a:node.open({'stay': 1, 'where': 'v', 'keepopen': 1})
|
|
| 4336 |
-endfunction |
|
| 4337 |
- |
|
| 4338 |
-" FUNCTION: s:revealBookmark(name) {{{2
|
|
| 4339 |
-" put the cursor on the node associate with the given name |
|
| 4340 |
-function! s:revealBookmark(name) |
|
| 4341 |
- try |
|
| 4342 |
- let targetNode = s:Bookmark.GetNodeForName(a:name, 0) |
|
| 4343 |
- call targetNode.putCursorHere(0, 1) |
|
| 4344 |
- catch /^NERDTree.BookmarkNotFoundError/ |
|
| 4345 |
- call s:echo("Bookmark isnt cached under the current root")
|
|
| 4346 |
- endtry |
|
| 4347 |
-endfunction |
|
| 4348 |
-" FUNCTION: s:refreshRoot() {{{2
|
|
| 4349 |
-" Reloads the current root. All nodes below this will be lost and the root dir |
|
| 4350 |
-" will be reloaded. |
|
| 4351 |
-function! s:refreshRoot() |
|
| 4352 |
- call s:echo("Refreshing the root node. This could take a while...")
|
|
| 4353 |
- call b:NERDTreeRoot.refresh() |
|
| 4354 |
- call s:renderView() |
|
| 4355 |
- redraw |
|
| 4356 |
- call s:echo("Refreshing the root node. This could take a while... DONE")
|
|
| 4357 |
-endfunction |
|
| 4358 |
- |
|
| 4359 |
-" FUNCTION: s:refreshCurrent(node) {{{2
|
|
| 4360 |
-" refreshes the root for the current node |
|
| 4361 |
-function! s:refreshCurrent(node) |
|
| 4362 |
- let node = a:node |
|
| 4363 |
- if !node.path.isDirectory |
|
| 4364 |
- let node = node.parent |
|
| 4365 |
- endif |
|
| 4366 |
- |
|
| 4367 |
- call s:echo("Refreshing node. This could take a while...")
|
|
| 4368 |
- call node.refresh() |
|
| 4369 |
- call s:renderView() |
|
| 4370 |
- redraw |
|
| 4371 |
- call s:echo("Refreshing node. This could take a while... DONE")
|
|
| 4372 |
-endfunction |
|
| 4373 |
-" FUNCTION: s:showMenu(node) {{{2
|
|
| 4374 |
-function! s:showMenu(node) |
|
| 4375 |
- let mc = s:MenuController.New(s:MenuItem.AllEnabled()) |
|
| 4376 |
- call mc.showMenu() |
|
| 4377 |
-endfunction |
|
| 4378 |
- |
|
| 4379 |
-" FUNCTION: s:toggleIgnoreFilter() {{{2
|
|
| 4380 |
-" toggles the use of the NERDTreeIgnore option |
|
| 4381 |
-function! s:toggleIgnoreFilter() |
|
| 4382 |
- let b:NERDTreeIgnoreEnabled = !b:NERDTreeIgnoreEnabled |
|
| 4383 |
- call s:renderViewSavingPosition() |
|
| 4384 |
- call s:centerView() |
|
| 4385 |
-endfunction |
|
| 4386 |
- |
|
| 4387 |
-" FUNCTION: s:toggleShowBookmarks() {{{2
|
|
| 4388 |
-" toggles the display of bookmarks |
|
| 4389 |
-function! s:toggleShowBookmarks() |
|
| 4390 |
- let b:NERDTreeShowBookmarks = !b:NERDTreeShowBookmarks |
|
| 4391 |
- if b:NERDTreeShowBookmarks |
|
| 4392 |
- call s:renderView() |
|
| 4393 |
- call s:putCursorOnBookmarkTable() |
|
| 4394 |
- else |
|
| 4395 |
- call s:renderViewSavingPosition() |
|
| 4396 |
- endif |
|
| 4397 |
- call s:centerView() |
|
| 4398 |
-endfunction |
|
| 4399 |
-" FUNCTION: s:toggleShowFiles() {{{2
|
|
| 4400 |
-" toggles the display of hidden files |
|
| 4401 |
-function! s:toggleShowFiles() |
|
| 4402 |
- let b:NERDTreeShowFiles = !b:NERDTreeShowFiles |
|
| 4403 |
- call s:renderViewSavingPosition() |
|
| 4404 |
- call s:centerView() |
|
| 4405 |
-endfunction |
|
| 4406 |
- |
|
| 4407 |
-" FUNCTION: s:toggleShowHidden() {{{2
|
|
| 4408 |
-" toggles the display of hidden files |
|
| 4409 |
-function! s:toggleShowHidden() |
|
| 4410 |
- let b:NERDTreeShowHidden = !b:NERDTreeShowHidden |
|
| 4411 |
- call s:renderViewSavingPosition() |
|
| 4412 |
- call s:centerView() |
|
| 4413 |
-endfunction |
|
| 4414 |
- |
|
| 4415 |
-" FUNCTION: s:toggleZoom() {{{2
|
|
| 4416 |
-" zoom (maximize/minimize) the NERDTree window |
|
| 4417 |
-function! s:toggleZoom() |
|
| 4418 |
- if exists("b:NERDTreeZoomed") && b:NERDTreeZoomed
|
|
| 4419 |
- let size = exists("b:NERDTreeOldWindowSize") ? b:NERDTreeOldWindowSize : g:NERDTreeWinSize
|
|
| 4420 |
- exec "silent vertical resize ". size |
|
| 4421 |
- let b:NERDTreeZoomed = 0 |
|
| 4422 |
- else |
|
| 4423 |
- exec "vertical resize" |
|
| 4424 |
- let b:NERDTreeZoomed = 1 |
|
| 4425 |
- endif |
|
| 4426 |
-endfunction |
|
| 4427 |
- |
|
| 4428 |
-" FUNCTION: s:upDirCurrentRootOpen() {{{2
|
|
| 4429 |
-function! s:upDirCurrentRootOpen() |
|
| 4430 |
- call s:upDir(1) |
|
| 4431 |
-endfunction |
|
| 4432 |
- |
|
| 4433 |
-" FUNCTION: s:upDirCurrentRootClosed() {{{2
|
|
| 4434 |
-function! s:upDirCurrentRootClosed() |
|
| 4435 |
- call s:upDir(0) |
|
| 4436 |
-endfunction |
|
| 4437 |
- |
|
| 4438 |
-" SECTION: Post Source Actions {{{1
|
|
| 4439 |
-call s:postSourceActions() |
|
| 4440 |
- |
|
| 4441 |
-"reset &cpo back to users setting |
|
| 4442 |
-let &cpo = s:old_cpo |
|
| 4443 |
- |
|
| 4444 |
-" vim: set sw=4 sts=4 et fdm=marker: |
| ... | ... |
@@ -1,88 +0,0 @@ |
| 1 |
-let s:tree_up_dir_line = '.. (up a dir)' |
|
| 2 |
-"NERDTreeFlags are syntax items that should be invisible, but give clues as to |
|
| 3 |
-"how things should be highlighted |
|
| 4 |
-syn match NERDTreeFlag #\~# |
|
| 5 |
-syn match NERDTreeFlag #\[RO\]# |
|
| 6 |
- |
|
| 7 |
-"highlighting for the .. (up dir) line at the top of the tree |
|
| 8 |
-execute "syn match NERDTreeUp #\\V". s:tree_up_dir_line ."#" |
|
| 9 |
- |
|
| 10 |
-"highlighting for the ~/+ symbols for the directory nodes |
|
| 11 |
-syn match NERDTreeClosable #\~\<# |
|
| 12 |
-syn match NERDTreeClosable #\~\.# |
|
| 13 |
-syn match NERDTreeOpenable #+\<# |
|
| 14 |
-syn match NERDTreeOpenable #+\.#he=e-1 |
|
| 15 |
- |
|
| 16 |
-"highlighting for the tree structural parts |
|
| 17 |
-syn match NERDTreePart #|# |
|
| 18 |
-syn match NERDTreePart #`# |
|
| 19 |
-syn match NERDTreePartFile #[|`]-#hs=s+1 contains=NERDTreePart |
|
| 20 |
- |
|
| 21 |
-"quickhelp syntax elements |
|
| 22 |
-syn match NERDTreeHelpKey #" \{1,2\}[^ ]*:#hs=s+2,he=e-1
|
|
| 23 |
-syn match NERDTreeHelpKey #" \{1,2\}[^ ]*,#hs=s+2,he=e-1
|
|
| 24 |
-syn match NERDTreeHelpTitle #" .*\~#hs=s+2,he=e-1 contains=NERDTreeFlag |
|
| 25 |
-syn match NERDTreeToggleOn #".*(on)#hs=e-2,he=e-1 contains=NERDTreeHelpKey |
|
| 26 |
-syn match NERDTreeToggleOff #".*(off)#hs=e-3,he=e-1 contains=NERDTreeHelpKey |
|
| 27 |
-syn match NERDTreeHelpCommand #" :.\{-}\>#hs=s+3
|
|
| 28 |
-syn match NERDTreeHelp #^".*# contains=NERDTreeHelpKey,NERDTreeHelpTitle,NERDTreeFlag,NERDTreeToggleOff,NERDTreeToggleOn,NERDTreeHelpCommand |
|
| 29 |
- |
|
| 30 |
-"highlighting for readonly files |
|
| 31 |
-syn match NERDTreeRO #.*\[RO\]#hs=s+2 contains=NERDTreeFlag,NERDTreeBookmark,NERDTreePart,NERDTreePartFile |
|
| 32 |
- |
|
| 33 |
-"highlighting for sym links |
|
| 34 |
-syn match NERDTreeLink #[^-| `].* -> # contains=NERDTreeBookmark,NERDTreeOpenable,NERDTreeClosable,NERDTreeDirSlash |
|
| 35 |
- |
|
| 36 |
-"highlighing for directory nodes and file nodes |
|
| 37 |
-syn match NERDTreeDirSlash #/# |
|
| 38 |
-syn match NERDTreeDir #[^-| `].*/# contains=NERDTreeLink,NERDTreeDirSlash,NERDTreeOpenable,NERDTreeClosable |
|
| 39 |
-syn match NERDTreeExecFile #[|` ].*\*\($\| \)# contains=NERDTreeLink,NERDTreePart,NERDTreeRO,NERDTreePartFile,NERDTreeBookmark |
|
| 40 |
-syn match NERDTreeFile #|-.*# contains=NERDTreeLink,NERDTreePart,NERDTreeRO,NERDTreePartFile,NERDTreeBookmark,NERDTreeExecFile |
|
| 41 |
-syn match NERDTreeFile #`-.*# contains=NERDTreeLink,NERDTreePart,NERDTreeRO,NERDTreePartFile,NERDTreeBookmark,NERDTreeExecFile |
|
| 42 |
-syn match NERDTreeCWD #^[</].*$# |
|
| 43 |
- |
|
| 44 |
-"highlighting for bookmarks |
|
| 45 |
-syn match NERDTreeBookmark # {.*}#hs=s+1
|
|
| 46 |
- |
|
| 47 |
-"highlighting for the bookmarks table |
|
| 48 |
-syn match NERDTreeBookmarksLeader #^># |
|
| 49 |
-syn match NERDTreeBookmarksHeader #^>-\+Bookmarks-\+$# contains=NERDTreeBookmarksLeader |
|
| 50 |
-syn match NERDTreeBookmarkName #^>.\{-} #he=e-1 contains=NERDTreeBookmarksLeader
|
|
| 51 |
-syn match NERDTreeBookmark #^>.*$# contains=NERDTreeBookmarksLeader,NERDTreeBookmarkName,NERDTreeBookmarksHeader |
|
| 52 |
- |
|
| 53 |
-if exists("g:NERDChristmasTree") && g:NERDChristmasTree
|
|
| 54 |
- hi def link NERDTreePart Special |
|
| 55 |
- hi def link NERDTreePartFile Type |
|
| 56 |
- hi def link NERDTreeFile Normal |
|
| 57 |
- hi def link NERDTreeExecFile Title |
|
| 58 |
- hi def link NERDTreeDirSlash Identifier |
|
| 59 |
- hi def link NERDTreeClosable Type |
|
| 60 |
-else |
|
| 61 |
- hi def link NERDTreePart Normal |
|
| 62 |
- hi def link NERDTreePartFile Normal |
|
| 63 |
- hi def link NERDTreeFile Normal |
|
| 64 |
- hi def link NERDTreeClosable Title |
|
| 65 |
-endif |
|
| 66 |
- |
|
| 67 |
-hi def link NERDTreeBookmarksHeader statement |
|
| 68 |
-hi def link NERDTreeBookmarksLeader ignore |
|
| 69 |
-hi def link NERDTreeBookmarkName Identifier |
|
| 70 |
-hi def link NERDTreeBookmark normal |
|
| 71 |
- |
|
| 72 |
-hi def link NERDTreeHelp String |
|
| 73 |
-hi def link NERDTreeHelpKey Identifier |
|
| 74 |
-hi def link NERDTreeHelpCommand Identifier |
|
| 75 |
-hi def link NERDTreeHelpTitle Macro |
|
| 76 |
-hi def link NERDTreeToggleOn Question |
|
| 77 |
-hi def link NERDTreeToggleOff WarningMsg |
|
| 78 |
- |
|
| 79 |
-hi def link NERDTreeDir Directory |
|
| 80 |
-hi def link NERDTreeUp Directory |
|
| 81 |
-hi def link NERDTreeCWD Statement |
|
| 82 |
-hi def link NERDTreeLink Macro |
|
| 83 |
-hi def link NERDTreeOpenable Title |
|
| 84 |
-hi def link NERDTreeFlag ignore |
|
| 85 |
-hi def link NERDTreeRO WarningMsg |
|
| 86 |
-hi def link NERDTreeBookmark Statement |
|
| 87 |
- |
|
| 88 |
-hi def link NERDTreeCurrentNode Search |
| ... | ... |
@@ -46,11 +46,10 @@ See [config.dlma.com](http://config.dlma.com) for more. |
| 46 | 46 |
1. [pathogen](https://github.com/tpope/vim-pathogen), the Vim plugin manager. |
| 47 | 47 |
2. [vim-airline](https://github.com/vim-airline/vim-airline), for a better Vim statusline. |
| 48 | 48 |
3. [bbye for :Bdelete](https://github.com/moll/vim-bbye), to delete buffers without affecting windows. |
| 49 |
- 4. [nerdtree](https://github.com/scrooloose/nerdtree), a better filesystem tree-view explorer. |
|
| 50 |
- 5. [taglist](http://www.vim.org/scripts/script.php?script_id=273), a ctags tree-view explorer. |
|
| 51 |
- 6. [file-line](http://www.vim.org/scripts/script.php?script_id=2184), to open file:line as from a compiler error. |
|
| 52 |
- 7. [visual-star-search](http://got-ravings.blogspot.com/2008/07/vim-pr0n-visual-search-mappings.html), so * and # work in visual mode too. |
|
| 53 |
- 8. Assorted favorite colors like [desert](https://github.com/dblume/desert.vim). |
|
| 49 |
+ 4. [taglist](http://www.vim.org/scripts/script.php?script_id=273), a ctags tree-view explorer. |
|
| 50 |
+ 5. [file-line](http://www.vim.org/scripts/script.php?script_id=2184), to open file:line as from a compiler error. |
|
| 51 |
+ 6. [visual-star-search](http://got-ravings.blogspot.com/2008/07/vim-pr0n-visual-search-mappings.html), so * and # work in visual mode too. |
|
| 52 |
+ 7. Assorted favorite colors like [desert](https://github.com/dblume/desert.vim). |
|
| 54 | 53 |
3. .gitconfig and .gitignore |
| 55 | 54 |
4. .tmux.conf |
| 56 | 55 |
5. .inputrc, for a [partially matched command history traversal](http://askubuntu.com/questions/59846/bash-history-search-partial-up-arrow/59855#59855). |
| 57 | 56 |