Merge pull request #1090 from bouk/open-on-find-unsaved-file

Open the parent directory when revealing a non-existent file

.github/ISSUE_TEMPLATE/bug.md

@@ -3,18 +3,18 @@ name: "Bug Report"
 about: "NERDTree is misbehaving? Tell us about it."
 labels: bug
 ---
+<!-- Attention! Please Read!
 
-# Attention! Please Read!
+Please fill out ALL the information below so that the issue can be fully
+understood. Omitting information will delay the resolution of your issue. It
+will be labeled "Needs More Info", and may be closed until there is enough
+information.
 
-Please fill out **ALL the information** below so that the issue can be fully understood. Omitting information will delay the resolution of your issue. It will be labeled **`Needs More Info`**, and *may* be closed until there is enough information.
+Keep in mind that others may have the same question in the future. The better
-
+your information, the more likely they'll be able to help themselves. -->
-Keep in mind that others may have the same question in the future. The better your information, the more likely they'll be able to help themselves.
-
-After reading, and before submitting your issue, please remove this introductory text.
-
-──────────────────── ✄ ────────────────────
 
 #### Self-Diagnosis
+<!-- Check the boxes after creating the issue, or use [x]. -->
 - [ ] I have searched the [issues](https://github.com/scrooloose/nerdtree/issues) for an answer to my question.
 - [ ] I have reviewed the NERDTree documentation. `:h NERDTree`
 - [ ] I have reviewed the [Wiki](https://github.com/scrooloose/nerdtree/wiki).
@@ -22,9 +22,8 @@ After reading, and before submitting your issue, please remove this introductory
 
 #### Environment (for bug reports)
 - [ ] Operating System: 
-- [ ] Vim/Neovim version `:version`: 
+- [ ] Vim/Neovim version `:echo v:version`: 
-- [ ] NERDTree version `git rev-parse --short HEAD`: 
+- [ ] NERDTree version, found on 1st line in NERDTree quickhelp `?`: 
-- [ ] A link to my [vimrc](), or
 - [ ] vimrc settings
     - [ ] NERDTree variables
     ```vim

.github/ISSUE_TEMPLATE/question.md

@@ -3,18 +3,18 @@ name: "General Question"
 about: "Having trouble setting up NERDTree? Need clarification on a setting? Ask your question here."
 labels: "general question"
 ---
+<!-- Attention! Please Read!
 
-# Attention! Please Read!
+Please fill out ALL the information below so that the issue can be fully
+understood. Omitting information will delay the resolution of your issue. It
+will be labeled "Needs More Info", and may be closed until there is enough
+information.
 
-Please fill out **ALL the information** below so that the issue can be fully understood. Omitting information will delay the resolution of your issue. It will be labeled **`Needs More Info`**, and *may* be closed until there is enough information.
+Keep in mind that others may have the same question in the future. The better
-
+your information, the more likely they'll be able to help themselves. -->
-Keep in mind that others may have the same question in the future. The better your information, the more likely they'll be able to help themselves.
-
-After reading, and before submitting your issue, please remove this introductory text.
-
-──────────────────── ✄ ────────────────────
 
 #### Self-Diagnosis
+<!-- Check the boxes after creating the issue, or use [x]. -->
 - [ ] I have searched the [issues](https://github.com/scrooloose/nerdtree/issues) for an answer to my question.
 - [ ] I have reviewed the NERDTree documentation. `:h NERDTree`
 - [ ] I have reviewed the [Wiki](https://github.com/scrooloose/nerdtree/wiki).

.github/PULL_REQUEST_TEMPLATE.md

@@ -1,22 +1,16 @@
-<!-- Enter the issue number this PR addresses below. If none, remove the line. -->
 ### Description of Changes
+Closes #  <!-- Issue number this PR addresses. If none, remove this line. -->
 
-Closes #
 
 ---
 ### New Version Info
 
-- [ ] Derive a new version number. Increment the:
+#### Author's Instructions
-    - [ ] `MAJOR` version when you make incompatible API changes,
+- [ ] Derive a new `MAJOR.MINOR.PATCH` version number. Increment the:
-    - [ ] `MINOR` version when you add functionality in a backwards-compatible manner, and
+    - `MAJOR` version when you make incompatible API changes
-    - [ ] `PATCH` version when you make backwards-compatible bug fixes.
+    - `MINOR` version when you add functionality in a backwards-compatible manner
-- [ ] Update version number in [autoload/nerdtree.vim](https://github.com/scrooloose/nerdtree/blob/master/autoload/nerdtree.vim#L7)
+    - `PATCH` version when you make backwards-compatible bug fixes
-- [ ] Update the ChangeLog, following this format/example:
+- [ ] Update [CHANGELOG.md](https://github.com/scrooloose/nerdtree/blob/master/CHANGELOG.md), following the established pattern.
-    ```
+#### Collaborator's Instructions
-    MAJOR.MINOR...
+- [ ] Review [CHANGELOG.md](https://github.com/scrooloose/nerdtree/blob/master/CHANGELOG.md), suggesting a different version number if necessary.
-    - **.PATCH**: PR Title (Author) #PR Number
+- [ ] After merge, tag the merge commit, e.g. `git tag -a 3.1.4 -m "v3.1.4" && git push origin --tags`
-
-    ### 5.1...
-    - **.1**: Update Changelog and create PR Template (PhilRunninger) #1007
-    - **.0**: Too many changes for one patch...
-    ```

.github/workflows/vint.yml

@@ -0,0 +1,15 @@
+name: Vint
+on: [push, pull_request]
+jobs:
+  vint:
+    strategy:
+      fail-fast: false
+    runs-on: ubuntu-latest
+    steps:
+    - name: Checkout
+      uses: actions/checkout@master
+    - name: Run vint with reviewdog
+      uses: reviewdog/action-vint@v1.0.1
+      with:
+        github_token: ${{ secrets.github_token }}
+        reporter: github-pr-review

.vintrc.yaml

@@ -0,0 +1,5 @@
+cmdargs:
+  severity: style_problem
+  color: true
+  env:
+    neovim: false

CHANGELOG.md

@@ -1,132 +1,181 @@
-# Change Log
+# NERDTree Change Log
-
+<!-- Introduce a new MAJOR or MINOR version with a 4-hash header.
-### 5.1...
+     PATCH versions are listed from newest to oldest under their respective MAJOR.MINOR
-- **`.3`**: Remove @mentions from PR template and change log. They weren't working. (PhilRunninger) #1009
+     version in an unordered list.  The format is:
-- **`.2`**: Fix NERDTree opening with the wrong size. (PhilRunninger) #1008
+        - **.PATCH**: Pull Request Title (PR Author) [PR Number](Link to PR)
-- **`.1`**: Update Changelog and create PR Template (PhilRunninger) #1007
+-->
-- **`.0`**: Too many changes for one patch...
+#### 6.7
-    - Refresh a dir_node if the file wasn't found in it, and look once more. (PhilRunninger) #1005
+- **.0**: Open the parent directory when revealing a non-existent file with :NERDTreeFind (bouk) [#1090](https://github.com/preservim/nerdtree/pull/1090)
-    - Add a "copy path to clipboard" menu option (PhilRunninger) #1002
+#### 6.6
-    - Enable root refresh on "vim ." a different way than #999. (PhilRunninger) #1001
+- **.1**: [add] How to install using dein.vim (kazukazuinaina) [#1087](https://github.com/preservim/nerdtree/pull/1087)
-    - Fix refreshroot (PhilRunninger) #999
+- **.0**: Add the ability to turn off directory arrows (PhilRunninger) [#1085](https://github.com/preservim/nerdtree/pull/1085)
-    - Change version check to look for 703 not 730 (vhalis) #994
+#### 6.5
-    - Change minimum vim (PhilRunninger) #991
+- **.0**: `NERDTreeToggle <start-directory>` always sets NERDTree root. (PhilRunninger) [#1083](https://github.com/preservim/nerdtree/pull/1083)
-    - Allow multi-character DirArrows (PhilRunninger) #985
+#### 6.4
-    - Remove redraw! while still clearing last message empty string. (PhilRunninger) #979
+- **.6**: NERDTreeFind shows expected message if file doesn't exist e.g. with vim-startify (andys8). [#1081](https://github.com/preservim/nerdtree/pull/1081)
-    - fix _initChildren function value set to numChildrenCached error (terryding77) #969
+- **.5**: Ensure events are (or aren't) being ignored correctly. (PhilRunninger) [#1080](https://github.com/preservim/nerdtree/pull/1080)
-    - On Windows, do a case-insensitive comparison of paths. (PhilRunninger) #967
+- **.4**: Prevent overwriting existing files/dirs on node move. (PhilRunninger) [#1079](https://github.com/preservim/nerdtree/pull/1079)
-    - Remove the "Please wait... DONE" messages. (PhilRunninger) #966
+- **.3**: Fix regex that finds keyword for minimal menu. (PhilRunninger) [#1075](https://github.com/preservim/nerdtree/pull/1075)
-    - Smarter delimiter default (PhilRunninger) #963
+- **.2**: Lint vimscript, fix errors and warnings, add CI job to review PRs (Caleb Maclennan) [#1071](https://github.com/preservim/nerdtree/pull/1071)
-    - Update directory .vimdc readme example (spencerdcarlson) #961
+- **.1**: Ensure backward compatibility. v:t_func is not available before Vim 8.0 (Phil Runninger)
-    - Preview bookmarks (PhilRunninger) #956
+- **.0**: Allow use of function references as callbacks (HiPhish) [#1067](https://github.com/preservim/nerdtree/pull/1067)
-    - Add new value to NERDTreeQuitOnOpen to close bookmark table (PhilRunninger) #955
+#### 6.3
-    - Add an :EditBookmarks command to edit the bookmarks file (PhilRunninger) #954
+- **.0**: Add new command that behaves like NERDTreeToggle but defaults to the root of a VCS repository. (willfindlay) [#1060](https://github.com/preservim/nerdtree/pull/1060)
-    - Before copying, turn off &shellslash. Restore after copy is finished. (PhilRunninger) #952
+#### 6.2
-    - Set a maximum window size when zooming. (PhilRunninger) #950
+- **.1**: Menu option, 'copy path to clipboard' is aware of VIM clipboard option (jhzn) [#1056](https://github.com/preservim/nerdtree/pull/1056)
-    - Confirm the wipeout of a unsaved buffer whose file has been renamed. (PhilRunninger) #949
+- **.0**: Support tab-specific CWDs (PhilRunninger) [#1032](https://github.com/preservim/nerdtree/pull/1032)
-    - Escape a backslash so it can be used in a key mapping. (PhilRunninger) #948
+#### 6.1
-    - Add a NERDTreeMinimalMenu feature (tuzz) #938
+- **.4**: Add VIM built-in package management to read me file. (pesarkhobeee) [#1049](https://github.com/preservim/nerdtree/pull/1049)
-    - fixed root path error for windows (zcodes) #935
+- **.3**: Save/Set screen state also on WinLeave and WinEnter. (PhilRunninger) [#1048](https://github.com/preservim/nerdtree/pull/1048)
-    - Restore getDirChildren for use in nerdtree-project-plugin. (PhilRunninger) #929
+- **.2**: Wrap saveScreenState's statements in a try-catch block. (PhilRunninger) [#1047](https://github.com/preservim/nerdtree/pull/1047)
-    - Document NERDTreeNodeDelimiter #912 (PhilRunninger) #926
+- **.1**: Catch errors when trying to read CHANGELOG.md. (PhilRunninger) [#1045](https://github.com/preservim/nerdtree/pull/1045)
-    - Allow modification of menu keybindings (Leandros) #923
+- **.0**: If file path doesn't exist, :NERDTreeFind its parent directory instead. (PhilRunninger) [#1043](https://github.com/preservim/nerdtree/pull/1043)
-    - Add two more disqualifications for isCascadable(). (PhilRunninger) #914
+#### 6.0
-    - Allow highlighting more than one flag. (kristijanhusak) #908
+- **.1**: Reintroduce necessary variable mistakenly removed. (PhilRunninger) [#1040](https://github.com/preservim/nerdtree/pull/1040)
-    - Support sorting files and directories by modification time. (PhilRunninger) #901
+- **.0**: Make the behavior of window splits consistent (dragonxlwang, PhilRunninger) [#1035](https://github.com/preservim/nerdtree/pull/1035)
-    - Parse . and .. from path string with trailing slash. (PhilRunninger) #899
+#### 5.3
-    - Force sort to recalculate the cached sortKey. (PhilRunninger) #898
+- **.3**: Fix (p)ath not displaying in the minimal menu (tuzz) [#1038](https://github.com/preservim/nerdtree/pull/1038)
-    - Add NERDTreeRefreshRoot command (wgfm) #897
+- **.2**: Enable events when closing NerdTree window. (PhilRunninger) [#1037](https://github.com/preservim/nerdtree/pull/1037)
-    - Call Resolve on the file's path when calling :NERDTreeFind. (PhilRunninger) #896
+- **.1**: Fix the `e` key mapping to use netrw if desired (PhilRunninger) [#1031](https://github.com/preservim/nerdtree/pull/1031)
-    - Catch all errors, not just NERDTree errors. (PhilRunninger) #894
+- **.0**: Add file extension and size to sorting capabilities (PhilRunninger) [#1029](https://github.com/preservim/nerdtree/pull/1029)
-    - Fix typo in help file (lvoisin) #892
+#### 5.2
-    - Make NERDTreeCreator set the `'nolist'` option (lifecrisis) #889
+- **.9**: Suppress events for intermediate window/tab/buffer changes (PhilRunninger) [#1026](https://github.com/preservim/nerdtree/pull/1026)
-    - Refresh buffers after `m`, `m` operation on a folder (PhilRunninger) #888
+- **.8**: Revert [#1019](https://github.com/preservim/nerdtree/pull/1019) to fix nvim artifacts and flickering. (PhilRunninger) [#1021](https://github.com/preservim/nerdtree/pull/1021)
-    - Use a better arg for FINDSTR when using the m,l command in Windows. (PhilRunninger) #887
+- **.7**: Use :mode only in neovim. MacVim still needs to use :redraw! (PhilRunninger) [#1019](https://github.com/preservim/nerdtree/pull/1019)
-    - Fix the <C-J>/<C-K> motions, which currently fail with cascades (lifecrisis) #886
+- **.6**: In CHANGELOG.md and PR template, make reference to PR a true HTML link. (PhilRunninger) [#1017](https://github.com/preservim/nerdtree/pull/1017)
-    - Function "s:UI.getLineNum()" doesn't always work on cascades. (lifecrisis) #882
+- **.5**: Use `:mode` instead of `:redraw!` when updating menu. (PhilRunninger) [#1016](https://github.com/preservim/nerdtree/pull/1016)
-    - NERDTreeCWD: reset CWD if changed by NERDTreeFocus (PhilRunninger) #878
+- **.4**: When searching for root line num, stop at end of file. (PhilRunninger) [#1015](https://github.com/preservim/nerdtree/pull/1015)
-    - Use <count>tabnext instead of <count>gt to allow users to remap gt. (PhilRunninger) #877
+- **.3**: Fix `<CR>` key map on the bookmark (lkebin) [#1014](https://github.com/preservim/nerdtree/pull/1014)
-    - Do a case sensitive comparison of new/existing buffers. (PhilRunninger) #875
+- **.2**: Make Enter work on the `.. ( up a dir )` line (PhilRunninger) [#1013](https://github.com/preservim/nerdtree/pull/1013)
-    - Fix opening sub-directories that have commas in their name. (PhilRunninger) #873
+- **.1**: Fix nerdtree#version() on Windows. (PhilRunninger)
-    - Add new command to open NERDTree in the root of a VCS repository. (PhilRunninger) #872
+- **.0**: Expand functionality of `<CR>` mapping. (PhilRunninger) [#1011](https://github.com/preservim/nerdtree/pull/1011)
-    - Make sure the path to the bookmarks file exists before writing it. (PhilRunninger) #871
+#### 5.1
-    - Unzoom NERDTree when opening a file (PhilRunninger) #870
+- **.3**: Remove @mentions from PR template and change log. They weren't working. (PhilRunninger) [#1009](https://github.com/preservim/nerdtree/pull/1009)
-    - Support unusual characters in file and directory names (PhilRunninger) #868
+- **.2**: Fix NERDTree opening with the wrong size. (PhilRunninger) [#1008](https://github.com/preservim/nerdtree/pull/1008)
-    - Reword renamed-buffer prompt to be more clear (aflock) #867
+- **.1**: Update Changelog and create PR Template (PhilRunninger) [#1007](https://github.com/preservim/nerdtree/pull/1007)
-    - Default to placing cursor on root when closing bookmark table (lifecrisis) #866
+- **.0**: Too many changes for one patch...
-    - Fix issues with sorting of nodes (PhilRunninger) #856
+    - Refresh a dir_node if the file wasn't found in it, and look once more. (PhilRunninger) [#1005](https://github.com/preservim/nerdtree/pull/1005)
-    - Better OSX detection (bubba-h57) #853
+    - Add a "copy path to clipboard" menu option (PhilRunninger) [#1002](https://github.com/preservim/nerdtree/pull/1002)
-    - Bugfix - ensure keymaps dictionary exists before using it (mnussbaum) #852
+    - Enable root refresh on "vim ." a different way than [#999](https://github.com/preservim/nerdtree/pull/999). (PhilRunninger) [#1001](https://github.com/preservim/nerdtree/pull/1001)
-    - Decrease startup-time by avoiding linear-time iteration over key mappings (mnussbaum) #851
+    - Fix refreshroot (PhilRunninger) [#999](https://github.com/preservim/nerdtree/pull/999)
-    - Add code to sort mappings in quickhelp (lifecrisis) #849
+    - Change version check to look for 703 not 730 (vhalis) [#994](https://github.com/preservim/nerdtree/pull/994)
-    - Use ":clearjumps" in new NERDTree windows (lifecrisis) #844
+    - Change minimum vim (PhilRunninger) [#991](https://github.com/preservim/nerdtree/pull/991)
-    - Like m-c did before, create parent directories if needed on m-m. (PhilRunninger) #840
+    - Allow multi-character DirArrows (PhilRunninger) [#985](https://github.com/preservim/nerdtree/pull/985)
-    - BUGFIX: Repair a problem with the `'u'` mapping. (lifecrisis) #838
+    - Remove redraw! while still clearing last message empty string. (PhilRunninger) [#979](https://github.com/preservim/nerdtree/pull/979)
-    - Make the NERDTree buffer writable when rendering it. (PhilRunninger) #837
+    - fix `_initChildren` function value set to numChildrenCached error (terryding77) [#969](https://github.com/preservim/nerdtree/pull/969)
-    - Code cleanup: Remove unsupported bookmark table mappings (lifecrisis) #835
+    - On Windows, do a case-insensitive comparison of paths. (PhilRunninger) [#967](https://github.com/preservim/nerdtree/pull/967)
-    - Replace strcharpart() with substitute() for backward compatibility (bravestarr) #834
+    - Remove the **Please wait... DONE** messages. (PhilRunninger) [#966](https://github.com/preservim/nerdtree/pull/966)
-    - Fixed error `unknown function strcharpart` for older versions of Vim (hav4ik) #833
+    - Smarter delimiter default (PhilRunninger) [#963](https://github.com/preservim/nerdtree/pull/963)
-    - Clear output when NERDTree menu is aborted (lifecrisis) #832
+    - Update directory .vimdc readme example (spencerdcarlson) [#961](https://github.com/preservim/nerdtree/pull/961)
-    - Display a path with multi-byte characters correctly when it is truncated (bravestarr) #830
+    - Preview bookmarks (PhilRunninger) [#956](https://github.com/preservim/nerdtree/pull/956)
-    - Support revealing file and executing file with xdg-open for Linux (ngnmhieu) #824
+    - Add new value to NERDTreeQuitOnOpen to close bookmark table (PhilRunninger) [#955](https://github.com/preservim/nerdtree/pull/955)
-    - If node isn't open, count children on disk before deleting. (PhilRunninger) #822
+    - Add an :EditBookmarks command to edit the bookmarks file (PhilRunninger) [#954](https://github.com/preservim/nerdtree/pull/954)
-    - Add new variable g:NERDTreeRemoveFileCmd (kutsan) #816
+    - Before copying, turn off &shellslash. Restore after copy is finished. (PhilRunninger) [#952](https://github.com/preservim/nerdtree/pull/952)
-    - Use a better check for existence of the NERDTree buffer. (PhilRunninger) #814
+    - Set a maximum window size when zooming. (PhilRunninger) [#950](https://github.com/preservim/nerdtree/pull/950)
-    - Fix focussing previous buffer when closing NERDTree (mrubli) #801
+    - Confirm the wipeout of a unsaved buffer whose file has been renamed. (PhilRunninger) [#949](https://github.com/preservim/nerdtree/pull/949)
-    - Update the docs for "NERDTreeStatusline" (lifecrisis) #796
+    - Escape a backslash so it can be used in a key mapping. (PhilRunninger) [#948](https://github.com/preservim/nerdtree/pull/948)
-    - BUGFIX: Unstable behavior in the "getPath()" method (lifecrisis) #795
+    - Add a NERDTreeMinimalMenu feature (tuzz) [#938](https://github.com/preservim/nerdtree/pull/938)
-    - Revert the bugfix from pull request #785 (lifecrisis) #794
+    - fixed root path error for windows (zcodes) [#935](https://github.com/preservim/nerdtree/pull/935)
-    - BUGFIX: Allow ":NERDTreeFind" to discover hidden files (lifecrisis) #786
+    - Restore getDirChildren for use in nerdtree-project-plugin. (PhilRunninger) [#929](https://github.com/preservim/nerdtree/pull/929)
-    - BUGFIX: Allow ":NERDTreeFind" to reveal new files (lifecrisis) #785
+    - Document NERDTreeNodeDelimiter [#912](https://github.com/preservim/nerdtree/pull/912) (PhilRunninger) [#926](https://github.com/preservim/nerdtree/pull/926)
-    - Add modelines (lifecrisis) #782
+    - Allow modification of menu keybindings (Leandros) [#923](https://github.com/preservim/nerdtree/pull/923)
-    - Change the type of completion used by NERDTreeFind (lifecrisis) #781
+    - Add two more disqualifications for isCascadable(). (PhilRunninger) [#914](https://github.com/preservim/nerdtree/pull/914)
-    - change NERDTreeFind with args (zhenyangze) #778
+    - Allow highlighting more than one flag. (kristijanhusak) [#908](https://github.com/preservim/nerdtree/pull/908)
-    - Style Choice: Using confirm() when deleting a bookmark (lifecrisis) #777
+    - Support sorting files and directories by modification time. (PhilRunninger) [#901](https://github.com/preservim/nerdtree/pull/901)
-    - remove useless substitute when `file =~# "/$"` (skyblueee) #773
+    - Parse . and .. from path string with trailing slash. (PhilRunninger) [#899](https://github.com/preservim/nerdtree/pull/899)
-    - remove useless removeLeadingSpaces in _stripMarkup (skyblueee) #772
+    - Force sort to recalculate the cached sortKey. (PhilRunninger) [#898](https://github.com/preservim/nerdtree/pull/898)
-    - Make the "o" mapping consistent with "x" (lifecrisis) #769
+    - Add NERDTreeRefreshRoot command (wgfm) [#897](https://github.com/preservim/nerdtree/pull/897)
-    - Fix a problem with the "x" handler (lifecrisis) #768
+    - Call Resolve on the file's path when calling :NERDTreeFind. (PhilRunninger) [#896](https://github.com/preservim/nerdtree/pull/896)
-    - Clean up the handler for the "x" mapping (lifecrisis) #767
+    - Catch all errors, not just NERDTree errors. (PhilRunninger) [#894](https://github.com/preservim/nerdtree/pull/894)
-    - Revert change to tab opening method (lifecrisis) #766
+    - Fix typo in help file (lvoisin) [#892](https://github.com/preservim/nerdtree/pull/892)
-    - BUGFIX: Add back support for "b:NERDTreeRoot" (lifecrisis) #765
+    - Make NERDTreeCreator set the `'nolist'` option (lifecrisis) [#889](https://github.com/preservim/nerdtree/pull/889)
-    - Fix broken "t" and "T" mappings, tabs now open at end (lifecrisis) #759
+    - Refresh buffers after `m`, `m` operation on a folder (PhilRunninger) [#888](https://github.com/preservim/nerdtree/pull/888)
-    - Update doc with already existing mapping variables (asnr) #699
+    - Use a better arg for FINDSTR when using the m,l command in Windows. (PhilRunninger) [#887](https://github.com/preservim/nerdtree/pull/887)
-    - Fix the broken g:NERDTreeBookmarksSort setting (lifecrisis) #696
+    - Fix the <C-J>/<C-K> motions, which currently fail with cascades (lifecrisis) [#886](https://github.com/preservim/nerdtree/pull/886)
-    - Correct NERDTreeIgnore pattern in doc (cntoplolicon) #648
+    - Function "s:UI.getLineNum()" doesn't always work on cascades. (lifecrisis) [#882](https://github.com/preservim/nerdtree/pull/882)
-    - Remove empty segments when splitting path (sooth-sayer) #574
+    - NERDTreeCWD: reset CWD if changed by NERDTreeFocus (PhilRunninger) [#878](https://github.com/preservim/nerdtree/pull/878)
-    - Suppress autocmds less agressively (wincent) #578 #691
+    - Use <count>tabnext instead of <count>gt to allow users to remap gt. (PhilRunninger) [#877](https://github.com/preservim/nerdtree/pull/877)
+    - Do a case sensitive comparison of new/existing buffers. (PhilRunninger) [#875](https://github.com/preservim/nerdtree/pull/875)
+    - Fix opening sub-directories that have commas in their name. (PhilRunninger) [#873](https://github.com/preservim/nerdtree/pull/873)
+    - Add new command to open NERDTree in the root of a VCS repository. (PhilRunninger) [#872](https://github.com/preservim/nerdtree/pull/872)
+    - Make sure the path to the bookmarks file exists before writing it. (PhilRunninger) [#871](https://github.com/preservim/nerdtree/pull/871)
+    - Unzoom NERDTree when opening a file (PhilRunninger) [#870](https://github.com/preservim/nerdtree/pull/870)
+    - Support unusual characters in file and directory names (PhilRunninger) [#868](https://github.com/preservim/nerdtree/pull/868)
+    - Reword renamed-buffer prompt to be more clear (aflock) [#867](https://github.com/preservim/nerdtree/pull/867)
+    - Default to placing cursor on root when closing bookmark table (lifecrisis) [#866](https://github.com/preservim/nerdtree/pull/866)
+    - Fix issues with sorting of nodes (PhilRunninger) [#856](https://github.com/preservim/nerdtree/pull/856)
+    - Better OSX detection (bubba-h57) [#853](https://github.com/preservim/nerdtree/pull/853)
+    - Bugfix - ensure keymaps dictionary exists before using it (mnussbaum) [#852](https://github.com/preservim/nerdtree/pull/852)
+    - Decrease startup-time by avoiding linear-time iteration over key mappings (mnussbaum) [#851](https://github.com/preservim/nerdtree/pull/851)
+    - Add code to sort mappings in quickhelp (lifecrisis) [#849](https://github.com/preservim/nerdtree/pull/849)
+    - Use ":clearjumps" in new NERDTree windows (lifecrisis) [#844](https://github.com/preservim/nerdtree/pull/844)
+    - Like m-c did before, create parent directories if needed on m-m. (PhilRunninger) [#840](https://github.com/preservim/nerdtree/pull/840)
+    - BUGFIX: Repair a problem with the `'u'` mapping. (lifecrisis) [#838](https://github.com/preservim/nerdtree/pull/838)
+    - Make the NERDTree buffer writable when rendering it. (PhilRunninger) [#837](https://github.com/preservim/nerdtree/pull/837)
+    - Code cleanup: Remove unsupported bookmark table mappings (lifecrisis) [#835](https://github.com/preservim/nerdtree/pull/835)
+    - Replace strcharpart() with substitute() for backward compatibility (bravestarr) [#834](https://github.com/preservim/nerdtree/pull/834)
+    - Fixed error `unknown function strcharpart` for older versions of Vim (hav4ik) [#833](https://github.com/preservim/nerdtree/pull/833)
+    - Clear output when NERDTree menu is aborted (lifecrisis) [#832](https://github.com/preservim/nerdtree/pull/832)
+    - Display a path with multi-byte characters correctly when it is truncated (bravestarr) [#830](https://github.com/preservim/nerdtree/pull/830)
+    - Support revealing file and executing file with xdg-open for Linux (ngnmhieu) [#824](https://github.com/preservim/nerdtree/pull/824)
+    - If node isn't open, count children on disk before deleting. (PhilRunninger) [#822](https://github.com/preservim/nerdtree/pull/822)
+    - Add new variable g:NERDTreeRemoveFileCmd (kutsan) [#816](https://github.com/preservim/nerdtree/pull/816)
+    - Use a better check for existence of the NERDTree buffer. (PhilRunninger) [#814](https://github.com/preservim/nerdtree/pull/814)
+    - Fix focussing previous buffer when closing NERDTree (mrubli) [#801](https://github.com/preservim/nerdtree/pull/801)
+    - Update the docs for "NERDTreeStatusline" (lifecrisis) [#796](https://github.com/preservim/nerdtree/pull/796)
+    - BUGFIX: Unstable behavior in the "getPath()" method (lifecrisis) [#795](https://github.com/preservim/nerdtree/pull/795)
+    - Revert the bugfix from pull request [#785](https://github.com/preservim/nerdtree/pull/785) (lifecrisis) [#794](https://github.com/preservim/nerdtree/pull/794)
+    - BUGFIX: Allow ":NERDTreeFind" to discover hidden files (lifecrisis) [#786](https://github.com/preservim/nerdtree/pull/786)
+    - BUGFIX: Allow ":NERDTreeFind" to reveal new files (lifecrisis) [#785](https://github.com/preservim/nerdtree/pull/785)
+    - Add modelines (lifecrisis) [#782](https://github.com/preservim/nerdtree/pull/782)
+    - Change the type of completion used by NERDTreeFind (lifecrisis) [#781](https://github.com/preservim/nerdtree/pull/781)
+    - change NERDTreeFind with args (zhenyangze) [#778](https://github.com/preservim/nerdtree/pull/778)
+    - Style Choice: Using confirm() when deleting a bookmark (lifecrisis) [#777](https://github.com/preservim/nerdtree/pull/777)
+    - remove useless substitute when `file =~# "/$"` (skyblueee) [#773](https://github.com/preservim/nerdtree/pull/773)
+    - remove useless removeLeadingSpaces in _stripMarkup (skyblueee) [#772](https://github.com/preservim/nerdtree/pull/772)
+    - Make the "o" mapping consistent with "x" (lifecrisis) [#769](https://github.com/preservim/nerdtree/pull/769)
+    - Fix a problem with the "x" handler (lifecrisis) [#768](https://github.com/preservim/nerdtree/pull/768)
+    - Clean up the handler for the "x" mapping (lifecrisis) [#767](https://github.com/preservim/nerdtree/pull/767)
+    - Revert change to tab opening method (lifecrisis) [#766](https://github.com/preservim/nerdtree/pull/766)
+    - BUGFIX: Add back support for "b:NERDTreeRoot" (lifecrisis) [#765](https://github.com/preservim/nerdtree/pull/765)
+    - Fix broken "t" and "T" mappings, tabs now open at end (lifecrisis) [#759](https://github.com/preservim/nerdtree/pull/759)
+    - Update doc with already existing mapping variables (asnr) [#699](https://github.com/preservim/nerdtree/pull/699)
+    - Fix the broken g:NERDTreeBookmarksSort setting (lifecrisis) [#696](https://github.com/preservim/nerdtree/pull/696)
+    - Correct NERDTreeIgnore pattern in doc (cntoplolicon) [#648](https://github.com/preservim/nerdtree/pull/648)
+    - Remove empty segments when splitting path (sooth-sayer) [#574](https://github.com/preservim/nerdtree/pull/574)
+    - Suppress autocmds less agressively (wincent) [#578](https://github.com/preservim/nerdtree/pull/578) [#691](https://github.com/preservim/nerdtree/pull/691)
     - Add an Issues template to ask for more info initially.
-    - Fix markdown headers in readme (josephfrazier) #676
+    - Fix markdown headers in readme (josephfrazier) [#676](https://github.com/preservim/nerdtree/pull/676)
-    - Don't touch @o and @h registers when rendering
+    - Don't touch `@o` and `@h` registers when rendering
-    - Fix bug with files and directories with dollar signs (alegen) #649
+    - Fix bug with files and directories with dollar signs (alegen) [#649](https://github.com/preservim/nerdtree/pull/649)
-    - Reuse/reopen existing window trees where possible #244
+    - Reuse/reopen existing window trees where possible [#244](https://github.com/preservim/nerdtree/pull/244)
     - Remove NERDTree.previousBuf()
-    - Change color of arrow (Leeiio) #630
+    - Change color of arrow (Leeiio) [#630](https://github.com/preservim/nerdtree/pull/630)
-    - Improved a tip in README.markdown (ggicci) #628
+    - Improved a tip in README.markdown (ggicci) [#628](https://github.com/preservim/nerdtree/pull/628)
-    - Shorten delete confimration of empty directory to `y` (mikeperri) #530
+    - Shorten delete confimration of empty directory to `y` (mikeperri) [#530](https://github.com/preservim/nerdtree/pull/530)
-    - Fix API call to open directory tree in window (devm33) #533
+    - Fix API call to open directory tree in window (devm33) [#533](https://github.com/preservim/nerdtree/pull/533)
-    - Change default arrows on non-Windows platforms (gwilk) #546
+    - Change default arrows on non-Windows platforms (gwilk) [#546](https://github.com/preservim/nerdtree/pull/546)
-    - Update to README - combine cd and git clone (zwhitchcox) #584
+    - Update to README - combine cd and git clone (zwhitchcox) [#584](https://github.com/preservim/nerdtree/pull/584)
-    - Update to README - Tip: start NERDTree when vim starts (therealplato) #593 
+    - Update to README - Tip: start NERDTree when vim starts (therealplato) [#593](https://github.com/preservim/nerdtree/pull/593)
-    - Escape filename when moving an open buffer (zacharyvoase) #595
+    - Escape filename when moving an open buffer (zacharyvoase) [#595](https://github.com/preservim/nerdtree/pull/595)
-    - Fixed incorrect :helptags command in README (curran) #619
+    - Fixed incorrect :helptags command in README (curran) [#619](https://github.com/preservim/nerdtree/pull/619)
-    - Fixed incomplete escaping of folder arrows (adityanatraj) #548
+    - Fixed incomplete escaping of folder arrows (adityanatraj) [#548](https://github.com/preservim/nerdtree/pull/548)
-    - Added NERDTreeCascadeSingleChildDir option (juanibiapina) #558
+    - Added NERDTreeCascadeSingleChildDir option (juanibiapina) [#558](https://github.com/preservim/nerdtree/pull/558)
     - Replace strchars() with backward compatible workaround.
-    - Add support for copy command in Windows (SkylerLipthay) #231
+    - Add support for copy command in Windows (SkylerLipthay) [#231](https://github.com/preservim/nerdtree/pull/231)
     - Fixed typo in README.markdown - :Helptags -> :helptags
     - Rename "primary" and "secondary" trees to "tab" and "window" trees.
     - Move a bunch of buffer level variables into the NERDTree and UI classes.
-    - Display cascading dirs on one line to save vertical/horizontal space (@matt-gardner: brainstorming/testing)
+    - Display cascading dirs on one line to save vertical/horizontal space (matt-gardner: brainstorming/testing)
     - Remove the old style UI - Remove `NERDTreeDirArrows` option.
     - On windows default to + and ~ for expand/collapse directory symbols.
     - Lots more refactoring. Move a bunch of b: level vars into b:NERDTree and friends.
 
-### 5.0.0
+#### 5.0.0
 - Refactor the code significantly:
     * Break the classes out into their own files.
     * Make the majority of the code OO - previously large parts were effectively a tangle of "global" methods.
-- Add an API to assign flags to nodes. This allows VCS plugins like https://github.com/Xuyuanp/nerdtree-git-plugin to exist. Thanks to @Xuyuanp for helping design/test/build said API.
+- Add an API to assign flags to nodes. This allows VCS plugins like https://github.com/Xuyuanp/nerdtree-git-plugin to exist. Thanks to **Xuyuanp** for helping design/test/build said API.
 - add `scope` argument to the key map API see :help NERDTreeAddKeyMap()
 - add magic [[dir]] and [[file]] flags to NERDTreeIgnore
 - add support for custom path filters. See :help NERDTreeAddPathFilter()
@@ -139,32 +188,9 @@
 - make the root note render prettier by truncating it at a path slash (gcmt)
 - remove NERDChristmasTree option - its always christmas now
 - add "cascade" open and closing for dirs containing only another single dir. See :help NERDTreeCascadeOpenSingleChildDir (pendulm)
-- Many other fixes, doc updates and contributions from:
+- Many other fixes, doc updates and contributions from: **actionshrimp**, **agrussellknives**, **alvan**, **AndrewRadev**, **cperl82** (*many small fixes*), **devmanhinton**, **egalpin**, **franksort**, **gastropoda**, **handcraftedbits**, **kelaban**, **lucascaton**, **mixvin**, **pendulm**, **SchDen**, **shanesmith**, **staeff**, **stephenprater**, **toiffel**, **Twinside**, **WoLpH**, **xiaodili**, **zhangoose**
-    - @actionshrimp
-    - @SchDen
-    - @egalpin
-    - @cperl82 - many small fixes
-    - @toiffel
-    - @WoLpH
-    - @handcraftedbits
-    - @devmanhinton
-    - @xiaodili
-    - @zhangoose
-    - @gastropoda
-    - @mixvin
-    - @alvan
-    - @lucascaton
-    - @kelaban
-    - @shanesmith
-    - @staeff
-    - @pendulm
-    - @stephenprater
-    - @franksort
-    - @agrussellknives
-    - @AndrewRadev
-    - @Twinside
 
-### 4.2.0
+#### 4.2.0
 - Add NERDTreeDirArrows option to make the UI use pretty arrow chars instead of the old +~| chars to define the tree structure (sickill)
 - shift the syntax highlighting out into its own syntax file (gnap)
 - add some mac specific options to the filesystem menu - for macvim only (andersonfreitas)
@@ -172,69 +198,58 @@
 - tweak the behaviour of :NERDTreeFind - see :help :NERDTreeFind for the new behaviour (benjamingeiger)
 - if no name is given to :Bookmark, make it default to the name of the target file/dir (minyoung)
 - use `file` completion when doing copying, create, and move operations (EvanDotPro)
-- lots of misc bug fixes from:
+- lots of misc bug fixes from: **AndrewRadev**, **Bogdanov**, **camthompson**, **kml**, **mathias**, **paddyoloughlin**, **scottstvnsn**, **sdewald**, **Vitaly**, **wycats**, me RAWR!
-    - @paddyoloughlin
-    - @sdewald
-    - @camthompson
-    - @Vitaly
-    - @Bogdanov
-    - @AndrewRadev
-    - @mathias
-    - @scottstvnsn
-    - @kml
-    - @wycats
-    - me RAWR!
 
-### 4.1.0
+#### 4.1.0
 - features:
-    - NERDTreeFind to reveal the node for the current buffer in the tree, see `|NERDTreeFind|`. This effectively merges the FindInNERDTree plugin (by Doug McInnes) into the script.
+    - NERDTreeFind to reveal the node for the current buffer in the tree, see `|NERDTreeFind|`. This effectively merges the FindInNERDTree plugin (by **Doug McInnes**) into the script.
-    - make NERDTreeQuitOnOpen apply to the t/T keymaps too. Thanks to Stefan Ritter and Rémi Prévost.
+    - make NERDTreeQuitOnOpen apply to the t/T keymaps too. Thanks to **Stefan Ritter** and **Rémi Prévost**.
-    - truncate the root node if wider than the tree window. Thanks to Victor Gonzalez.
+    - truncate the root node if wider than the tree window. Thanks to **Victor Gonzalez**.
 
 - bugfixes:
     - really fix window state restoring
-    - fix some win32 path escaping issues. Thanks to Stephan Baumeister, Ricky, jfilip1024, and Chris Chambers
+    - fix some win32 path escaping issues. Thanks to **Stephan Baumeister**, **Ricky**, **jfilip1024**, and **Chris Chambers**.
 
-### 4.0.0
+#### 4.0.0
 - add a new programmable menu system (see `:help NERDTreeMenu`).
 - add new APIs to add menus/menu-items to the menu system as well as custom key mappings to the NERD tree buffer (see `:help NERDTreeAPI`).
 - removed the old API functions
 - added a mapping to maximize/restore the size of nerd tree window, thanks to Guillaume Duranceau for the patch. See :help NERDTree-A for details.
-- fix a bug where secondary nerd trees (netrw hijacked trees) and NERDTreeQuitOnOpen didnt play nicely, thanks to Curtis Harvey.
+- fix a bug where secondary nerd trees (netrw hijacked trees) and NERDTreeQuitOnOpen didnt play nicely, thanks to **Curtis Harvey**.
-- fix a bug where the script ignored directories whose name ended in a dot, thanks to Aggelos Orfanakos for the patch.
+- fix a bug where the script ignored directories whose name ended in a dot, thanks to **Aggelos Orfanakos** for the patch.
-- fix a bug when using the x mapping on the tree root, thanks to Bryan Venteicher for the patch.
+- fix a bug when using the x mapping on the tree root, thanks to **Bryan Venteicher** for the patch.
-- fix a bug where the cursor position/window size of the nerd tree buffer wasnt being stored on closing the window, thanks to Richard Hart.
+- fix a bug where the cursor position/window size of the nerd tree buffer wasnt being stored on closing the window, thanks to **Richard Hart**.
 - fix a bug where NERDTreeMirror would mirror the wrong tree
 
-### 3.1.1
+#### 3.1.1
-- fix a bug where a non-listed no-name buffer was getting created every time the tree windows was created, thanks to Derek Wyatt and owen1
+- fix a bug where a non-listed no-name buffer was getting created every time the tree windows was created, thanks to **Derek Wyatt** and **owen1**
 - make `<CR>` behave the same as the `o` mapping
-- some helptag fixes in the doc, thanks @strull
+- some helptag fixes in the doc, thanks **strull**.
-- fix a bug when using `:set nohidden` and opening a file where the previous buf was modified. Thanks @iElectric
+- fix a bug when using `:set nohidden` and opening a file where the previous buf was modified. Thanks **iElectric**.
 - other minor fixes
 
-### 3.1.0
+#### 3.1.0
 - New features:
     - add mappings to open files in a vsplit, see `:help NERDTree-s` and `:help NERDTree-gs`
     - make the statusline for the nerd tree window default to something hopefully more useful. See `:help 'NERDTreeStatusline'`
 - Bugfixes:
-    - make the hijack netrw functionality work when vim is started with `vim <some dir>` (thanks to Alf Mikula for the patch).
+    - make the hijack netrw functionality work when vim is started with `vim <some dir>` (thanks to **Alf Mikula** for the patch).
-    - fix a bug where the CWD wasnt being changed for some operations even when NERDTreeChDirMode==2 (thanks to Lucas S. Buchala)
+    - fix a bug where the CWD wasnt being changed for some operations even when NERDTreeChDirMode==2 (thanks to **Lucas S. Buchala**)
-    - add -bar to all the nerd tree :commands so they can chain with other :commands (thanks to tpope)
+    - add -bar to all the nerd tree :commands so they can chain with other :commands (thanks to **tpope**)
-    - fix bugs when ignorecase was set (thanks to nach)
+    - fix bugs when ignorecase was set (thanks to **nach**)
-    - fix a bug with the relative path code (thanks to nach)
+    - fix a bug with the relative path code (thanks to **nach**)
-    - fix a bug where doing a `:cd` would cause `:NERDTreeToggle` to fail (thanks nach)
+    - fix a bug where doing a `:cd` would cause `:NERDTreeToggle` to fail (thanks **nach**)
 
 
-### 3.0.1
+#### 3.0.1
 - Bugfixes:
     - fix bugs with :NERDTreeToggle and :NERDTreeMirror when `'hidden'` was not set
-    - fix a bug where `:NERDTree <path>` would fail if `<path>` was relative and didnt start with a `./` or `../`  Thanks to James Kanze.
+    - fix a bug where `:NERDTree <path>` would fail if `<path>` was relative and didnt start with a `./` or `../`  Thanks to **James Kanze**.
-    - make the `q` mapping work with secondary (`:e <dir>`  style) trees, thanks to jamessan
+    - make the `q` mapping work with secondary (`:e <dir>`  style) trees, thanks to **jamessan**
     - fix a bunch of small bugs with secondary trees
 - More insane refactoring.
 
-### 3.0.0
+#### 3.0.0
 - hijack netrw so that doing an `:edit <directory>`  will put a NERD tree in the window rather than a netrw browser. See :help 'NERDTreeHijackNetrw'
 - allow sharing of trees across tabs, see `:help :NERDTreeMirror`
 - remove "top" and "bottom" as valid settings for NERDTreeWinPos

README.markdown

@@ -1,4 +1,4 @@
-The NERDTree
+The NERDTree [![Vint](https://github.com/preservim/nerdtree/workflows/Vint/badge.svg)](https://github.com/preservim/nerdtree/actions?workflow=Vint)
 =============
 
 Introduction
@@ -12,32 +12,74 @@ This plugin can also be extended with custom mappings using a special API. The
 details of this API and of other NERDTree features are described in the
 included documentation.
 
-![NERDTree Screenshot](https://github.com/scrooloose/nerdtree/raw/master/screenshot.png)
+![NERDTree Screenshot](https://github.com/preservim/nerdtree/raw/master/screenshot.png)
 
 Installation
 ------------
 
+Below are just some of the methods for installing NERDTree. Do not follow all of these instructions; just pick your favorite one. Other plugin managers exist, and NERDTree should install just fine with any of them.
+
+#### Vim 8+ packages
+
+If you are using VIM version 8 or higher you can use its built-in package management; see `:help packages` for more information. Just run these commands in your terminal:
+
+```bash
+git clone https://github.com/preservim/nerdtree.git ~/.vim/pack/vendor/start/nerdtree
+vim -u NONE -c "helptags ~/.vim/pack/vendor/start/nerdtree/doc" -c q
+```
+
+Otherwise, these are some of the several 3rd-party plugin managers you can choose from. Be sure you read the instructions for your chosen plugin, as there typically are additional steps you nee d to take.
+
 #### [pathogen.vim](https://github.com/tpope/vim-pathogen)
 
-    git clone https://github.com/scrooloose/nerdtree.git ~/.vim/bundle/nerdtree
+In the terminal,
+```bash
+git clone https://github.com/preservim/nerdtree.git ~/.vim/bundle/nerdtree
+```
+In your vimrc,
+```vim
+call pathogen#infect()
+syntax on
+filetype plugin indent on
+```
 
-Then reload Vim, run `:helptags ~/.vim/bundle/nerdtree/doc/` or `:Helptags`, and check out `:help NERDTree.txt`.
+Then reload vim, run `:helptags ~/.vim/bundle/nerdtree/doc/` or `:Helptags`.
 
+#### [Vundle.vim](https://github.com/VundleVim/Vundle.vim)
+```vim
+call vundle#begin()
+Plugin 'preservim/nerdtree'
+call vundle#end()
+```
+
+#### [vim-plug](https://github.com/junegunn/vim-plug)
+```vim
+call plug#begin()
+Plug 'preservim/nerdtree'
+call plug#end()
+```
+
+#### [dein.vim](https://github.com/Shougo/dein.vim)
+```vim
+call dein#begin()
+call dein#add('preservim/nerdtree')
+call dein#end()
+```
 
 #### [apt-vim](https://github.com/egalpin/apt-vim)
+```bash
+apt-vim install -y https://github.com/preservim/nerdtree.git
+```
 
-    apt-vim install -y https://github.com/scrooloose/nerdtree.git
+F.A.Q. (here, and in the [Wiki](https://github.com/preservim/nerdtree/wiki))
-
-F.A.Q.
 ------
 
-> Is there any support for `git` flags?
+#### Is there any support for `git` flags?
 
 Yes, install [nerdtree-git-plugin](https://github.com/Xuyuanp/nerdtree-git-plugin).
 
 ---
-
+#### Can I have the nerdtree on every tab automatically?
-> Can I have the nerdtree on every tab automatically?
 
 Nope. If this is something you want then chances are you aren't using tabs and
 buffers as they were intended to be used. Read this
@@ -46,53 +88,70 @@ http://stackoverflow.com/questions/102384/using-vims-tabs-like-buffers
 If you are interested in this behaviour then consider [vim-nerdtree-tabs](https://github.com/jistr/vim-nerdtree-tabs)
 
 ---
-> How can I open a NERDTree automatically when vim starts up?
+#### How can I open a NERDTree automatically when vim starts up?
 
 Stick this in your vimrc: `autocmd vimenter * NERDTree`
 
 ---
-> How can I open a NERDTree automatically when vim starts up if no files were specified?
+#### How can I open a NERDTree automatically when vim starts up if no files were specified?
 
 Stick this in your vimrc:
-
+```vim
-    autocmd StdinReadPre * let s:std_in=1
+autocmd StdinReadPre * let s:std_in=1
-    autocmd VimEnter * if argc() == 0 && !exists("s:std_in") | NERDTree | endif
+autocmd VimEnter * if argc() == 0 && !exists("s:std_in") | NERDTree | endif
+```
 
 Note: Now start vim with plain `vim`, not `vim .`
 
 ---
-> How can I open NERDTree automatically when vim starts up on opening a directory?
+#### What if I'm also opening a saved session, for example `vim -S session_file.vim`? I don't want NERDTree to open in that scenario.
+```vim
+autocmd StdinReadPre * let s:std_in=1
+autocmd VimEnter * if argc() == 0 && !exists("s:std_in") && v:this_session == "" | NERDTree | endif
+```
 
-    autocmd StdinReadPre * let s:std_in=1
+---
-    autocmd VimEnter * if argc() == 1 && isdirectory(argv()[0]) && !exists("s:std_in") | exe 'NERDTree' argv()[0] | wincmd p | ene | exe 'cd '.argv()[0] | endif
+#### How can I open NERDTree automatically when vim starts up on opening a directory?
+```vim
+autocmd StdinReadPre * let s:std_in=1
+autocmd VimEnter * if argc() == 1 && isdirectory(argv()[0]) && !exists("s:std_in") | exe 'NERDTree' argv()[0] | wincmd p | ene | exe 'cd '.argv()[0] | endif
+```
 
 This window is tab-specific, meaning it's used by all windows in the tab. This trick also prevents NERDTree from hiding when first selecting a file.
 
 Note: Executing `vim ~/some-directory` will open NERDTree and a new edit window. `exe 'cd '.argv()[0]` sets the `pwd` of the new edit window to `~/some-directory`
 
 ---
-> How can I map a specific key or shortcut to open NERDTree?
+#### How can I map a specific key or shortcut to open NERDTree?
 
 Stick this in your vimrc to open NERDTree with `Ctrl+n` (you can set whatever key you want):
-
+```vim
-    map <C-n> :NERDTreeToggle<CR>
+map <C-n> :NERDTreeToggle<CR>
+```
 
 ---
-> How can I close vim if the only window left open is a NERDTree?
+#### How can I close vim if the only window left open is a NERDTree?
 
 Stick this in your vimrc:
-
+```vim
-    autocmd bufenter * if (winnr("$") == 1 && exists("b:NERDTree") && b:NERDTree.isTabTree()) | q | endif
+autocmd bufenter * if (winnr("$") == 1 && exists("b:NERDTree") && b:NERDTree.isTabTree()) | q | endif
+```
 
 ---
-> Can I have different highlighting for different file extensions?
+#### Can I have different highlighting for different file extensions?
 
-See here: https://github.com/scrooloose/nerdtree/issues/433#issuecomment-92590696
+See here: https://github.com/preservim/nerdtree/issues/433#issuecomment-92590696
 
 ---
-> How can I change default arrows?
+#### How can I change default arrows?
 
 Use these variables in your vimrc. Note that below are default arrow symbols
-
+```vim
-    let g:NERDTreeDirArrowExpandable = '▸'
+let g:NERDTreeDirArrowExpandable = '▸'
-    let g:NERDTreeDirArrowCollapsible = '▾'
+let g:NERDTreeDirArrowCollapsible = '▾'
+```
+You can remove the arrows altogether by setting these variables to empty strings, as shown below. This will remove not only the arrows, but a single space following them, shifting the whole tree two character positions to the left.
+```vim
+let g:NERDTreeDirArrowExpandable = ''
+let g:NERDTreeDirArrowCollapsible = ''
+```

_config.yml

@@ -0,0 +1 @@
+theme: jekyll-theme-cayman

autoload/nerdtree.vim

@@ -1,19 +1,53 @@
-if exists("g:loaded_nerdtree_autoload")
+if exists('g:loaded_nerdtree_autoload')
     finish
 endif
 let g:loaded_nerdtree_autoload = 1
 
-function! nerdtree#version()
+let s:rootNERDTreePath = resolve(expand('<sfile>:p:h:h'))
-    return '5.1.3'
+
+"FUNCTION: nerdtree#version(...) {{{1
+"  If any value is given as an argument, the entire line of text from the
+"  change log is shown for the current version; otherwise, only the version
+"  number is shown.
+function! nerdtree#version(...) abort
+    let l:text = 'Unknown'
+    try
+        let l:changelog = readfile(join([s:rootNERDTreePath, 'CHANGELOG.md'], nerdtree#slash()))
+        let l:line = 0
+        while l:line <= len(l:changelog)
+            if l:changelog[l:line] =~# '\d\+\.\d\+'
+                let l:text = substitute(l:changelog[l:line], '.*\(\d\+.\d\+\).*', '\1', '')
+                let l:text .= substitute(l:changelog[l:line+1], '^.\{-}\(\.\d\+\).\{-}:\(.*\)', a:0>0 ? '\1:\2' : '\1', '')
+                break
+            endif
+            let l:line += 1
+        endwhile
+    catch
+    endtry
+    return l:text
 endfunction
 
 " SECTION: General Functions {{{1
 "============================================================
 
+"FUNCTION: nerdtree#slash() {{{2
+function! nerdtree#slash() abort
+
+    if nerdtree#runningWindows()
+        if exists('+shellslash') && &shellslash
+            return '/'
+        endif
+
+        return '\'
+    endif
+
+    return '/'
+endfunction
+
 "FUNCTION: nerdtree#and(x,y) {{{2
 " Implements and() function for Vim <= 7.2
-function! nerdtree#and(x,y)
+function! nerdtree#and(x,y) abort
-    if exists("*and")
+    if exists('*and')
         return and(a:x, a:y)
     else
         let l:x = a:x
@@ -24,7 +58,6 @@ function! nerdtree#and(x,y)
             if (l:x % 2) && (l:y % 2)
                 let l:result += float2nr(pow(2, l:n))
             endif
-            echomsg l:x . ", " . l:y . " => " l:result
             let l:x = float2nr(l:x / 2)
             let l:y = float2nr(l:y / 2)
             let l:n += 1
@@ -35,7 +68,7 @@ endfunction
 
 "FUNCTION: nerdtree#checkForBrowse(dir) {{{2
 "inits a window tree in the current buffer if appropriate
-function! nerdtree#checkForBrowse(dir)
+function! nerdtree#checkForBrowse(dir) abort
     if !isdirectory(a:dir)
         return
     endif
@@ -50,18 +83,18 @@ endfunction
 "FUNCTION: s:reuseWin(dir) {{{2
 "finds a NERDTree buffer with root of dir, and opens it.
 function! s:reuseWin(dir) abort
-    let path = g:NERDTreePath.New(fnamemodify(a:dir, ":p"))
+    let path = g:NERDTreePath.New(fnamemodify(a:dir, ':p'))
 
-    for i in range(1, bufnr("$"))
+    for i in range(1, bufnr('$'))
         unlet! nt
-        let nt = getbufvar(i, "NERDTree")
+        let nt = getbufvar(i, 'NERDTree')
         if empty(nt)
             continue
         endif
 
         if nt.isWinTree() && nt.root.path.equals(path)
-            call nt.setPreviousBuf(bufnr("#"))
+            call nt.setPreviousBuf(bufnr('#'))
-            exec "buffer " . i
+            exec 'buffer ' . i
             return 1
         endif
     endfor
@@ -71,17 +104,17 @@ endfunction
 
 " FUNCTION: nerdtree#completeBookmarks(A,L,P) {{{2
 " completion function for the bookmark commands
-function! nerdtree#completeBookmarks(A,L,P)
+function! nerdtree#completeBookmarks(A,L,P) abort
     return filter(g:NERDTreeBookmark.BookmarkNames(), 'v:val =~# "^' . a:A . '"')
 endfunction
 
 "FUNCTION: nerdtree#compareNodes(dir) {{{2
-function! nerdtree#compareNodes(n1, n2)
+function! nerdtree#compareNodes(n1, n2) abort
     return a:n1.path.compareTo(a:n2.path)
 endfunction
 
 "FUNCTION: nerdtree#compareNodesBySortKey(n1, n2) {{{2
-function! nerdtree#compareNodesBySortKey(n1, n2)
+function! nerdtree#compareNodesBySortKey(n1, n2) abort
     let sortKey1 = a:n1.path.getSortKey()
     let sortKey2 = a:n2.path.getSortKey()
     let i = 0
@@ -89,15 +122,15 @@ function! nerdtree#compareNodesBySortKey(n1, n2)
         " Compare chunks upto common length.
         " If chunks have different type, the one which has
         " integer type is the lesser.
-        if type(sortKey1[i]) == type(sortKey2[i])
+        if type(sortKey1[i]) ==# type(sortKey2[i])
             if sortKey1[i] <# sortKey2[i]
                 return - 1
             elseif sortKey1[i] ># sortKey2[i]
                 return 1
             endif
-        elseif type(sortKey1[i]) == v:t_number
+        elseif type(sortKey1[i]) ==# v:t_number
             return -1
-        elseif type(sortKey2[i]) == v:t_number
+        elseif type(sortKey2[i]) ==# v:t_number
             return 1
         endif
         let i = i + 1
@@ -117,7 +150,7 @@ endfunction
 " FUNCTION: nerdtree#deprecated(func, [msg]) {{{2
 " Issue a deprecation warning for a:func. If a second arg is given, use this
 " as the deprecation message
-function! nerdtree#deprecated(func, ...)
+function! nerdtree#deprecated(func, ...) abort
     let msg = a:0 ? a:func . ' ' . a:1 : a:func . ' is deprecated'
 
     if !exists('s:deprecationWarnings')
@@ -129,24 +162,27 @@ function! nerdtree#deprecated(func, ...)
     endif
 endfunction
 
-" FUNCTION: nerdtree#exec(cmd) {{{2
+" FUNCTION: nerdtree#exec(cmd, ignoreAll) {{{2
-" Same as :exec cmd but with eventignore set for the duration
+" Same as :exec cmd but, if ignoreAll is TRUE, set eventignore=all for the duration
-" to disable the autocommands used by NERDTree (BufEnter,
+function! nerdtree#exec(cmd, ignoreAll) abort
-" BufLeave and VimEnter)
+    let old_ei = &eventignore
-function! nerdtree#exec(cmd)
+    if a:ignoreAll
-    let old_ei = &ei
+        set eventignore=all
-    set ei=BufEnter,BufLeave,VimEnter
+    endif
-    exec a:cmd
+    try
-    let &ei = old_ei
+        exec a:cmd
+    finally
+        let &eventignore = old_ei
+    endtry
 endfunction
 
 " FUNCTION: nerdtree#has_opt(options, name) {{{2
-function! nerdtree#has_opt(options, name)
+function! nerdtree#has_opt(options, name) abort
-    return has_key(a:options, a:name) && a:options[a:name] == 1
+    return has_key(a:options, a:name) && a:options[a:name] ==# 1
 endfunction
 
 " FUNCTION: nerdtree#loadClassFiles() {{{2
-function! nerdtree#loadClassFiles()
+function! nerdtree#loadClassFiles() abort
     runtime lib/nerdtree/path.vim
     runtime lib/nerdtree/menu_controller.vim
     runtime lib/nerdtree/menu_item.vim
@@ -164,7 +200,7 @@ function! nerdtree#loadClassFiles()
 endfunction
 
 " FUNCTION: nerdtree#postSourceActions() {{{2
-function! nerdtree#postSourceActions()
+function! nerdtree#postSourceActions() abort
     call g:NERDTreeBookmark.CacheBookmarks(1)
     call nerdtree#ui_glue#createDefaultBindings()
 
@@ -173,13 +209,13 @@ function! nerdtree#postSourceActions()
 endfunction
 
 "FUNCTION: nerdtree#runningWindows(dir) {{{2
-function! nerdtree#runningWindows()
+function! nerdtree#runningWindows() abort
-    return has("win16") || has("win32") || has("win64")
+    return has('win16') || has('win32') || has('win64')
 endfunction
 
 "FUNCTION: nerdtree#runningCygwin(dir) {{{2
-function! nerdtree#runningCygwin()
+function! nerdtree#runningCygwin() abort
-    return has("win32unix")
+    return has('win32unix')
 endfunction
 
 " SECTION: View Functions {{{1
@@ -190,16 +226,16 @@ endfunction
 "
 "Args:
 "msg: the message to echo
-function! nerdtree#echo(msg)
+function! nerdtree#echo(msg) abort
     redraw
-    echomsg empty(a:msg) ? "" : ("NERDTree: " . a:msg)
+    echomsg empty(a:msg) ? '' : ('NERDTree: ' . a:msg)
 endfunction
 
 "FUNCTION: nerdtree#echoError {{{2
 "Wrapper for nerdtree#echo, sets the message type to errormsg for this message
 "Args:
 "msg: the message to echo
-function! nerdtree#echoError(msg)
+function! nerdtree#echoError(msg) abort
     echohl errormsg
     call nerdtree#echo(a:msg)
     echohl normal
@@ -209,14 +245,14 @@ endfunction
 "Wrapper for nerdtree#echo, sets the message type to warningmsg for this message
 "Args:
 "msg: the message to echo
-function! nerdtree#echoWarning(msg)
+function! nerdtree#echoWarning(msg) abort
     echohl warningmsg
     call nerdtree#echo(a:msg)
     echohl normal
 endfunction
 
 "FUNCTION: nerdtree#renderView {{{2
-function! nerdtree#renderView()
+function! nerdtree#renderView() abort
     call b:NERDTree.render()
 endfunction
 

autoload/nerdtree/ui_glue.vim

@@ -1,117 +1,152 @@
-if exists("g:loaded_nerdtree_ui_glue_autoload")
+if exists('g:loaded_nerdtree_ui_glue_autoload')
     finish
 endif
 let g:loaded_nerdtree_ui_glue_autoload = 1
 
 " FUNCTION: nerdtree#ui_glue#createDefaultBindings() {{{1
-function! nerdtree#ui_glue#createDefaultBindings()
+function! nerdtree#ui_glue#createDefaultBindings() abort
     let s = '<SNR>' . s:SID() . '_'
 
     call NERDTreeAddKeyMap({ 'key': '<MiddleMouse>', 'scope': 'all', 'callback': s . 'handleMiddleMouse' })
-    call NERDTreeAddKeyMap({ 'key': '<LeftRelease>', 'scope': "all", 'callback': s."handleLeftClick" })
+    call NERDTreeAddKeyMap({ 'key': '<LeftRelease>', 'scope': 'all', 'callback': s.'handleLeftClick' })
-    call NERDTreeAddKeyMap({ 'key': '<2-LeftMouse>', 'scope': "DirNode", 'callback': s."activateDirNode" })
+    call NERDTreeAddKeyMap({ 'key': '<2-LeftMouse>', 'scope': 'DirNode', 'callback': s.'activateDirNode' })
-    call NERDTreeAddKeyMap({ 'key': '<2-LeftMouse>', 'scope': "FileNode", 'callback': s."activateFileNode" })
+    call NERDTreeAddKeyMap({ 'key': '<2-LeftMouse>', 'scope': 'FileNode', 'callback': s.'activateFileNode' })
-    call NERDTreeAddKeyMap({ 'key': '<2-LeftMouse>', 'scope': "Bookmark", 'callback': s."activateBookmark" })
+    call NERDTreeAddKeyMap({ 'key': '<2-LeftMouse>', 'scope': 'Bookmark', 'callback': s.'activateBookmark' })
-    call NERDTreeAddKeyMap({ 'key': '<2-LeftMouse>', 'scope': "all", 'callback': s."activateAll" })
+    call NERDTreeAddKeyMap({ 'key': '<2-LeftMouse>', 'scope': 'all', 'callback': s.'activateAll' })
 
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapCustomOpen, 'scope':'FileNode', 'callback': s.'customOpenFile'})
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapCustomOpen, 'scope':'DirNode', 'callback': s.'customOpenDir'})
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapCustomOpen, 'scope':'Bookmark', 'callback': s.'customOpenBookmark'})
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapCustomOpen, 'scope':'all', 'callback': s.'activateAll' })
 
-    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapActivateNode, 'scope': "DirNode", 'callback': s."activateDirNode" })
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapActivateNode, 'scope': 'DirNode', 'callback': s.'activateDirNode' })
-    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapActivateNode, 'scope': "FileNode", 'callback': s."activateFileNode" })
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapActivateNode, 'scope': 'FileNode', 'callback': s.'activateFileNode' })
-    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapActivateNode, 'scope': "Bookmark", 'callback': s."activateBookmark" })
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapActivateNode, 'scope': 'Bookmark', 'callback': s.'activateBookmark' })
-    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapPreview, 'scope': "Bookmark", 'callback': s."previewBookmark" })
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapPreview, 'scope': 'Bookmark', 'callback': s.'previewBookmark' })
-    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapActivateNode, 'scope': "all", 'callback': s."activateAll" })
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapActivateNode, 'scope': 'all', 'callback': s.'activateAll' })
 
-    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapOpenSplit, 'scope': "Node", 'callback': s."openHSplit" })
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapOpenSplit, 'scope': 'Node', 'callback': s.'openHSplit' })
-    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapOpenVSplit, 'scope': "Node", 'callback': s."openVSplit" })
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapOpenVSplit, 'scope': 'Node', 'callback': s.'openVSplit' })
 
-    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapPreview, 'scope': "Node", 'callback': s."previewNodeCurrent" })
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapPreview, 'scope': 'Node', 'callback': s.'previewNodeCurrent' })
-    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapPreviewVSplit, 'scope': "Node", 'callback': s."previewNodeVSplit" })
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapPreviewVSplit, 'scope': 'Node', 'callback': s.'previewNodeVSplit' })
-    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapPreviewSplit, 'scope': "Node", 'callback': s."previewNodeHSplit" })
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapPreviewSplit, 'scope': 'Node', 'callback': s.'previewNodeHSplit' })
 
-    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapOpenRecursively, 'scope': "DirNode", 'callback': s."openNodeRecursively" })
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapOpenRecursively, 'scope': 'DirNode', 'callback': s.'openNodeRecursively' })
 
     call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapUpdir, 'scope': 'all', 'callback': s . 'upDirCurrentRootClosed' })
     call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapUpdirKeepOpen, 'scope': 'all', 'callback': s . 'upDirCurrentRootOpen' })
     call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapChangeRoot, 'scope': 'Node', 'callback': s . 'chRoot' })
 
-    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapChdir, 'scope': "Node", 'callback': s."chCwd" })
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapChdir, 'scope': 'Node', 'callback': s.'chCwd' })
 
-    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapQuit, 'scope': "all", 'callback': s."closeTreeWindow" })
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapQuit, 'scope': 'all', 'callback': s.'closeTreeWindow' })
 
-    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapCWD, 'scope': "all", 'callback': "nerdtree#ui_glue#chRootCwd" })
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapCWD, 'scope': 'all', 'callback': 'nerdtree#ui_glue#chRootCwd' })
 
-    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapRefreshRoot, 'scope': "all", 'callback': s."refreshRoot" })
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapRefreshRoot, 'scope': 'all', 'callback': s.'refreshRoot' })
-    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapRefresh, 'scope': "Node", 'callback': s."refreshCurrent" })
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapRefresh, 'scope': 'Node', 'callback': s.'refreshCurrent' })
 
-    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapHelp, 'scope': "all", 'callback': s."displayHelp" })
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapHelp, 'scope': 'all', 'callback': s.'displayHelp' })
-    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapToggleZoom, 'scope': "all", 'callback': s."toggleZoom" })
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapToggleZoom, 'scope': 'all', 'callback': s.'toggleZoom' })
-    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapToggleHidden, 'scope': "all", 'callback': s."toggleShowHidden" })
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapToggleHidden, 'scope': 'all', 'callback': s.'toggleShowHidden' })
-    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapToggleFilters, 'scope': "all", 'callback': s."toggleIgnoreFilter" })
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapToggleFilters, 'scope': 'all', 'callback': s.'toggleIgnoreFilter' })
-    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapToggleFiles, 'scope': "all", 'callback': s."toggleShowFiles" })
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapToggleFiles, 'scope': 'all', 'callback': s.'toggleShowFiles' })
-    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapToggleBookmarks, 'scope': "all", 'callback': s."toggleShowBookmarks" })
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapToggleBookmarks, 'scope': 'all', 'callback': s.'toggleShowBookmarks' })
 
-    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapCloseDir, 'scope': "Node", 'callback': s."closeCurrentDir" })
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapCloseDir, 'scope': 'Node', 'callback': s.'closeCurrentDir' })
-    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapCloseChildren, 'scope': "DirNode", 'callback': s."closeChildren" })
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapCloseChildren, 'scope': 'DirNode', 'callback': s.'closeChildren' })
 
-    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapMenu, 'scope': "Node", 'callback': s."showMenu" })
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapMenu, 'scope': 'Node', 'callback': s.'showMenu' })
 
-    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapJumpParent, 'scope': "Node", 'callback': s."jumpToParent" })
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapJumpParent, 'scope': 'Node', 'callback': s.'jumpToParent' })
-    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapJumpFirstChild, 'scope': "Node", 'callback': s."jumpToFirstChild" })
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapJumpFirstChild, 'scope': 'Node', 'callback': s.'jumpToFirstChild' })
-    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapJumpLastChild, 'scope': "Node", 'callback': s."jumpToLastChild" })
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapJumpLastChild, 'scope': 'Node', 'callback': s.'jumpToLastChild' })
-    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapJumpRoot, 'scope': "all", 'callback': s."jumpToRoot" })
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapJumpRoot, 'scope': 'all', 'callback': s.'jumpToRoot' })
-    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapJumpNextSibling, 'scope': "Node", 'callback': s."jumpToNextSibling" })
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapJumpNextSibling, 'scope': 'Node', 'callback': s.'jumpToNextSibling' })
-    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapJumpPrevSibling, 'scope': "Node", 'callback': s."jumpToPrevSibling" })
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapJumpPrevSibling, 'scope': 'Node', 'callback': s.'jumpToPrevSibling' })
 
     call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapOpenInTab, 'scope': 'Node', 'callback': s . 'openInNewTab' })
     call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapOpenInTabSilent, 'scope': 'Node', 'callback': s . 'openInNewTabSilent' })
     call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapOpenInTab, 'scope': 'Bookmark', 'callback': s . 'openInNewTab' })
     call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapOpenInTabSilent, 'scope': 'Bookmark', 'callback': s . 'openInNewTabSilent' })
 
-    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapOpenExpl, 'scope': "DirNode", 'callback': s."openExplorer" })
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapOpenExpl, 'scope': 'DirNode', 'callback': s.'openExplorer' })
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapOpenExpl, 'scope': 'FileNode', 'callback': s.'openExplorer' })
 
-    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapDeleteBookmark, 'scope': "Bookmark", 'callback': s."deleteBookmark" })
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapDeleteBookmark, 'scope': 'Bookmark', 'callback': s.'deleteBookmark' })
 endfunction
 
 
 "SECTION: Interface bindings {{{1
 "============================================================
 
+"FUNCTION: s:customOpenFile() {{{1
+" Open file node with the 'custom' key, initially <CR>.
+function! s:customOpenFile(node) abort
+    call a:node.activate(s:initCustomOpenArgs().file)
+endfunction
+
+"FUNCTION: s:customOpenDir() {{{1
+" Open directory node with the 'custom' key, initially <CR>.
+function! s:customOpenDir(node) abort
+    call s:activateDirNode(a:node, s:initCustomOpenArgs().dir)
+endfunction
+
+"FUNCTION: s:customOpenBookmark() {{{1
+" Open bookmark node with the 'custom' key, initially <CR>.
+function! s:customOpenBookmark(node) abort
+    if a:node.path.isDirectory
+        call a:node.activate(b:NERDTree, s:initCustomOpenArgs().dir)
+    else
+        call a:node.activate(b:NERDTree, s:initCustomOpenArgs().file)
+    endif
+endfunction
+
+"FUNCTION: s:initCustomOpenArgs() {{{1
+" Make sure NERDTreeCustomOpenArgs has needed keys
+function! s:initCustomOpenArgs() abort
+    let g:NERDTreeCustomOpenArgs = get(g:, 'NERDTreeCustomOpenArgs', {})
+    return extend(g:NERDTreeCustomOpenArgs, {'file':{'reuse': 'all', 'where': 'p'}, 'dir':{}}, 'keep')
+endfunction
+
 "FUNCTION: s:activateAll() {{{1
 "handle the user activating the updir line
-function! s:activateAll()
+function! s:activateAll() abort
-    if getline(".") ==# g:NERDTreeUI.UpDirLine()
+    if getline('.') ==# g:NERDTreeUI.UpDirLine()
         return nerdtree#ui_glue#upDir(0)
     endif
 endfunction
 
-" FUNCTION: s:activateDirNode(directoryNode) {{{1
+" FUNCTION: s:activateDirNode(directoryNode, options) {{{1
-function! s:activateDirNode(directoryNode)
+" Open a directory with optional options
+function! s:activateDirNode(directoryNode, ...) abort
 
     if a:directoryNode.isRoot() && a:directoryNode.isOpen
         call nerdtree#echo('cannot close tree root')
         return
     endif
 
-    call a:directoryNode.activate()
+    call a:directoryNode.activate((a:0 > 0) ? a:1 : {})
 endfunction
 
 "FUNCTION: s:activateFileNode() {{{1
 "handle the user activating a tree node
-function! s:activateFileNode(node)
+function! s:activateFileNode(node) abort
     call a:node.activate({'reuse': 'all', 'where': 'p'})
 endfunction
 
 "FUNCTION: s:activateBookmark(bookmark) {{{1
 "handle the user activating a bookmark
-function! s:activateBookmark(bm)
+function! s:activateBookmark(bm) abort
     call a:bm.activate(b:NERDTree, !a:bm.path.isDirectory ? {'where': 'p'} : {})
 endfunction
 
 " FUNCTION: nerdtree#ui_glue#bookmarkNode(name) {{{1
 " Associate the current node with the given name
-function! nerdtree#ui_glue#bookmarkNode(...)
+function! nerdtree#ui_glue#bookmarkNode(...) abort
     let currentNode = g:NERDTreeFileNode.GetSelected()
-    if currentNode != {}
+    if currentNode !=# {}
         let name = a:1
         if empty(name)
             let name = currentNode.path.getLastPathComponent(0)
@@ -120,39 +155,39 @@ function! nerdtree#ui_glue#bookmarkNode(...)
             call currentNode.bookmark(name)
             call b:NERDTree.render()
         catch /^NERDTree.IllegalBookmarkNameError/
-            call nerdtree#echo("bookmark names must not contain spaces")
+            call nerdtree#echo('bookmark names must not contain spaces')
         endtry
     else
-        call nerdtree#echo("select a node first")
+        call nerdtree#echo('select a node first')
     endif
 endfunction
 
 " FUNCTION: s:chCwd(node) {{{1
-function! s:chCwd(node)
+function! s:chCwd(node) abort
     try
         call a:node.path.changeToDir()
     catch /^NERDTree.PathChangeError/
-        call nerdtree#echoWarning("could not change cwd")
+        call nerdtree#echoWarning('could not change cwd')
     endtry
 endfunction
 
 " FUNCTION: s:chRoot(node) {{{1
 " changes the current root to the selected one
-function! s:chRoot(node)
+function! s:chRoot(node) abort
     call b:NERDTree.changeRoot(a:node)
 endfunction
 
 " FUNCTION: s:nerdtree#ui_glue#chRootCwd() {{{1
 " Change the NERDTree root to match the current working directory.
-function! nerdtree#ui_glue#chRootCwd()
+function! nerdtree#ui_glue#chRootCwd() abort
     NERDTreeCWD
 endfunction
 
 " FUNCTION: nnerdtree#ui_glue#clearBookmarks(bookmarks) {{{1
-function! nerdtree#ui_glue#clearBookmarks(bookmarks)
+function! nerdtree#ui_glue#clearBookmarks(bookmarks) abort
     if a:bookmarks ==# ''
         let currentNode = g:NERDTreeFileNode.GetSelected()
-        if currentNode != {}
+        if currentNode !=# {}
             call currentNode.clearBookmarks()
         endif
     else
@@ -167,7 +202,7 @@ endfunction
 
 " FUNCTION: s:closeChildren(node) {{{1
 " closes all childnodes of the current node
-function! s:closeChildren(node)
+function! s:closeChildren(node) abort
     call a:node.closeChildren()
     call b:NERDTree.render()
     call a:node.putCursorHere(0, 0)
@@ -175,7 +210,7 @@ endfunction
 
 " FUNCTION: s:closeCurrentDir(node) {{{1
 " Close the parent directory of the current node.
-function! s:closeCurrentDir(node)
+function! s:closeCurrentDir(node) abort
 
     if a:node.isRoot()
         call nerdtree#echo('cannot close parent of tree root')
@@ -200,30 +235,30 @@ endfunction
 
 " FUNCTION: s:closeTreeWindow() {{{1
 " close the tree window
-function! s:closeTreeWindow()
+function! s:closeTreeWindow() abort
-    if b:NERDTree.isWinTree() && b:NERDTree.previousBuf() != -1
+    if b:NERDTree.isWinTree() && b:NERDTree.previousBuf() !=# -1
-        exec "buffer " . b:NERDTree.previousBuf()
+        exec 'buffer ' . b:NERDTree.previousBuf()
     else
-        if winnr("$") > 1
+        if winnr('$') > 1
             call g:NERDTree.Close()
         else
-            call nerdtree#echo("Cannot close last window")
+            call nerdtree#echo('Cannot close last window')
         endif
     endif
 endfunction
 
 " FUNCTION: s:deleteBookmark(bookmark) {{{1
 " Prompt the user to confirm the deletion of the selected bookmark.
-function! s:deleteBookmark(bookmark)
+function! s:deleteBookmark(bookmark) abort
-    let l:message = "Delete the bookmark \"" . a:bookmark.name
+    let l:message = 'Delete the bookmark "' . a:bookmark.name
-                \ . "\" from the bookmark list?"
+                \ . '" from the bookmark list?'
 
     let l:choices = "&Yes\n&No"
 
     echo | redraw
     let l:selection = confirm(l:message, l:choices, 1, 'Warning')
 
-    if l:selection != 1
+    if l:selection !=# 1
         call nerdtree#echo('bookmark not deleted')
         return
     endif
@@ -240,21 +275,27 @@ endfunction
 
 " FUNCTION: s:displayHelp() {{{1
 " toggles the help display
-function! s:displayHelp()
+function! s:displayHelp() abort
     call b:NERDTree.ui.toggleHelp()
     call b:NERDTree.render()
     call b:NERDTree.ui.centerView()
 endfunction
 
 " FUNCTION: s:findAndRevealPath(pathStr) {{{1
-function! s:findAndRevealPath(pathStr)
+function! s:findAndRevealPath(pathStr) abort
     let l:pathStr = !empty(a:pathStr) ? a:pathStr : expand('%:p')
+    let l:revealOpts = {}
 
     if empty(l:pathStr)
         call nerdtree#echoWarning('no file for the current buffer')
         return
     endif
 
+    if !filereadable(l:pathStr)
+        let l:pathStr = fnamemodify(l:pathStr, ':h')
+        let l:revealOpts['open'] = 1
+    endif
+
     try
         let l:pathStr = g:NERDTreePath.Resolve(l:pathStr)
         let l:pathObj = g:NERDTreePath.New(l:pathStr)
@@ -288,22 +329,22 @@ function! s:findAndRevealPath(pathStr)
         call b:NERDTree.ui.setShowHidden(1)
     endif
 
-    let l:node = b:NERDTree.root.reveal(l:pathObj)
+    let l:node = b:NERDTree.root.reveal(l:pathObj, l:revealOpts)
     call b:NERDTree.render()
     call l:node.putCursorHere(1, 0)
 endfunction
 
 "FUNCTION: s:handleLeftClick() {{{1
 "Checks if the click should open the current node
-function! s:handleLeftClick()
+function! s:handleLeftClick() abort
     let currentNode = g:NERDTreeFileNode.GetSelected()
-    if currentNode != {}
+    if currentNode !=# {}
 
         "the dir arrows are multibyte chars, and vim's string functions only
         "deal with single bytes - so split the line up with the hack below and
         "take the line substring manually
-        let line = split(getline(line(".")), '\zs')
+        let line = split(getline(line('.')), '\zs')
-        let startToCur = ""
+        let startToCur = ''
         for i in range(0,len(line)-1)
             let startToCur .= line[i]
         endfor
@@ -330,7 +371,7 @@ function! s:handleLeftClick()
 endfunction
 
 " FUNCTION: s:handleMiddleMouse() {{{1
-function! s:handleMiddleMouse()
+function! s:handleMiddleMouse() abort
 
     " A middle mouse click does not automatically position the cursor as one
     " would expect. Forcing the execution of a regular left mouse click here
@@ -353,17 +394,17 @@ endfunction
 " FUNCTION: nerdtree#ui_glue#invokeKeyMap(key) {{{1
 "this is needed since I cant figure out how to invoke dict functions from a
 "key map
-function! nerdtree#ui_glue#invokeKeyMap(key)
+function! nerdtree#ui_glue#invokeKeyMap(key) abort
     call g:NERDTreeKeyMap.Invoke(a:key)
 endfunction
 
 " FUNCTION: s:jumpToFirstChild(node) {{{1
-function! s:jumpToFirstChild(node)
+function! s:jumpToFirstChild(node) abort
     call s:jumpToChild(a:node, 0)
 endfunction
 
 " FUNCTION: s:jumpToLastChild(node) {{{1
-function! s:jumpToLastChild(node)
+function! s:jumpToLastChild(node) abort
     call s:jumpToChild(a:node, 1)
 endfunction
 
@@ -373,7 +414,7 @@ endfunction
 " Args:
 " node: the node on which the cursor currently sits
 " last: 1 (true) if jumping to last child, 0 (false) if jumping to first
-function! s:jumpToChild(node, last)
+function! s:jumpToChild(node, last) abort
     let l:node = a:node.path.isDirectory ? a:node.getCascadeRoot() : a:node
 
     if l:node.isRoot()
@@ -392,7 +433,7 @@ endfunction
 " FUNCTION: s:jumpToParent(node) {{{1
 " Move the cursor to the parent of the specified node.  For a cascade, move to
 " the parent of the cascade's first node.  At the root node, do nothing.
-function! s:jumpToParent(node)
+function! s:jumpToParent(node) abort
     let l:node = a:node.path.isDirectory ? a:node.getCascadeRoot() : a:node
 
     if l:node.isRoot()
@@ -410,18 +451,18 @@ endfunction
 
 " FUNCTION: s:jumpToRoot() {{{1
 " moves the cursor to the root node
-function! s:jumpToRoot()
+function! s:jumpToRoot() abort
     call b:NERDTree.root.putCursorHere(1, 0)
     call b:NERDTree.ui.centerView()
 endfunction
 
 " FUNCTION: s:jumpToNextSibling(node) {{{1
-function! s:jumpToNextSibling(node)
+function! s:jumpToNextSibling(node) abort
     call s:jumpToSibling(a:node, 1)
 endfunction
 
 " FUNCTION: s:jumpToPrevSibling(node) {{{1
-function! s:jumpToPrevSibling(node)
+function! s:jumpToPrevSibling(node) abort
     call s:jumpToSibling(a:node, 0)
 endfunction
 
@@ -431,7 +472,7 @@ endfunction
 " Args:
 " node: the node on which the cursor currently sits
 " forward: 0 to jump to previous sibling, 1 to jump to next sibling
-function! s:jumpToSibling(node, forward)
+function! s:jumpToSibling(node, forward) abort
     let l:node = a:node.path.isDirectory ? a:node.getCascadeRoot() : a:node
     let l:sibling = l:node.findSibling(a:forward)
 
@@ -445,8 +486,8 @@ endfunction
 
 " FUNCTION: nerdtree#ui_glue#openBookmark(name) {{{1
 " Open the Bookmark that has the specified name. This function provides the
-" implementation for the ":OpenBookmark" command.
+" implementation for the :OpenBookmark command.
-function! nerdtree#ui_glue#openBookmark(name)
+function! nerdtree#ui_glue#openBookmark(name) abort
     try
         let l:bookmark = g:NERDTreeBookmark.BookmarkFor(a:name)
     catch /^NERDTree.BookmarkNotFoundError/
@@ -461,42 +502,42 @@ function! nerdtree#ui_glue#openBookmark(name)
 endfunction
 
 " FUNCTION: s:openHSplit(target) {{{1
-function! s:openHSplit(target)
+function! s:openHSplit(target) abort
     call a:target.activate({'where': 'h'})
 endfunction
 
 " FUNCTION: s:openVSplit(target) {{{1
-function! s:openVSplit(target)
+function! s:openVSplit(target) abort
     call a:target.activate({'where': 'v'})
 endfunction
 
 " FUNCTION: s:openExplorer(node) {{{1
-function! s:openExplorer(node)
+function! s:openExplorer(node) abort
     call a:node.openExplorer()
 endfunction
 
 " FUNCTION: s:openInNewTab(target) {{{1
-function! s:openInNewTab(target)
+function! s:openInNewTab(target) abort
     let l:opener = g:NERDTreeOpener.New(a:target.path, {'where': 't'})
     call l:opener.open(a:target)
 endfunction
 
 " FUNCTION: s:openInNewTabSilent(target) {{{1
-function! s:openInNewTabSilent(target)
+function! s:openInNewTabSilent(target) abort
     let l:opener = g:NERDTreeOpener.New(a:target.path, {'where': 't', 'stay': 1})
     call l:opener.open(a:target)
 endfunction
 
 " FUNCTION: s:openNodeRecursively(node) {{{1
-function! s:openNodeRecursively(node)
+function! s:openNodeRecursively(node) abort
-    call nerdtree#echo("Recursively opening node. Please wait...")
+    call nerdtree#echo('Recursively opening node. Please wait...')
     call a:node.openRecursively()
     call b:NERDTree.render()
-    call nerdtree#echo("")
+    call nerdtree#echo('')
 endfunction
 
 " FUNCTION: s:previewBookmark(bookmark) {{{1
-function! s:previewBookmark(bookmark)
+function! s:previewBookmark(bookmark) abort
     if a:bookmark.path.isDirectory
         execute 'NERDTreeFind '.a:bookmark.path.str()
     else
@@ -505,65 +546,65 @@ function! s:previewBookmark(bookmark)
 endfunction
 
 "FUNCTION: s:previewNodeCurrent(node) {{{1
-function! s:previewNodeCurrent(node)
+function! s:previewNodeCurrent(node) abort
     call a:node.open({'stay': 1, 'where': 'p', 'keepopen': 1})
 endfunction
 
 "FUNCTION: s:previewNodeHSplit(node) {{{1
-function! s:previewNodeHSplit(node)
+function! s:previewNodeHSplit(node) abort
     call a:node.open({'stay': 1, 'where': 'h', 'keepopen': 1})
 endfunction
 
 "FUNCTION: s:previewNodeVSplit(node) {{{1
-function! s:previewNodeVSplit(node)
+function! s:previewNodeVSplit(node) abort
     call a:node.open({'stay': 1, 'where': 'v', 'keepopen': 1})
 endfunction
 
 " FUNCTION: nerdtree#ui_glue#revealBookmark(name) {{{1
 " put the cursor on the node associate with the given name
-function! nerdtree#ui_glue#revealBookmark(name)
+function! nerdtree#ui_glue#revealBookmark(name) abort
     try
         let targetNode = g:NERDTreeBookmark.GetNodeForName(a:name, 0, b:NERDTree)
         call targetNode.putCursorHere(0, 1)
     catch /^NERDTree.BookmarkNotFoundError/
-        call nerdtree#echo("Bookmark isnt cached under the current root")
+        call nerdtree#echo('Bookmark isnt cached under the current root')
     endtry
 endfunction
 
 " FUNCTION: s:refreshRoot() {{{1
 " Reloads the current root. All nodes below this will be lost and the root dir
 " will be reloaded.
-function! s:refreshRoot()
+function! s:refreshRoot() abort
     if !g:NERDTree.IsOpen()
         return
     endif
-    call nerdtree#echo("Refreshing the root node. This could take a while...")
+    call nerdtree#echo('Refreshing the root node. This could take a while...')
 
     let l:curWin = winnr()
-    call nerdtree#exec(g:NERDTree.GetWinNum() . "wincmd w")
+    call nerdtree#exec(g:NERDTree.GetWinNum() . 'wincmd w', 1)
     call b:NERDTree.root.refresh()
     call b:NERDTree.render()
     redraw
-    call nerdtree#exec(l:curWin . "wincmd w")
+    call nerdtree#exec(l:curWin . 'wincmd w', 1)
-    call nerdtree#echo("")
+    call nerdtree#echo('')
 endfunction
 
 " FUNCTION: s:refreshCurrent(node) {{{1
 " refreshes the root for the current node
-function! s:refreshCurrent(node)
+function! s:refreshCurrent(node) abort
     let node = a:node
     if !node.path.isDirectory
         let node = node.parent
     endif
 
-    call nerdtree#echo("Refreshing node. This could take a while...")
+    call nerdtree#echo('Refreshing node. This could take a while...')
     call node.refresh()
     call b:NERDTree.render()
-    call nerdtree#echo("")
+    call nerdtree#echo('')
 endfunction
 
 " FUNCTION: nerdtree#ui_glue#setupCommands() {{{1
-function! nerdtree#ui_glue#setupCommands()
+function! nerdtree#ui_glue#setupCommands() abort
     command! -n=? -complete=dir -bar NERDTree :call g:NERDTreeCreator.CreateTabTree('<args>')
     command! -n=? -complete=dir -bar NERDTreeToggle :call g:NERDTreeCreator.ToggleTabTree('<args>')
     command! -n=0 -bar NERDTreeClose :call g:NERDTree.Close()
@@ -576,42 +617,42 @@ function! nerdtree#ui_glue#setupCommands()
 endfunction
 
 " Function: s:SID()   {{{1
-function s:SID()
+function! s:SID() abort
-    if !exists("s:sid")
+    if !exists('s:sid')
         let s:sid = matchstr(expand('<sfile>'), '<SNR>\zs\d\+\ze_SID$')
     endif
     return s:sid
 endfun
 
 " FUNCTION: s:showMenu(node) {{{1
-function! s:showMenu(node)
+function! s:showMenu(node) abort
     let mc = g:NERDTreeMenuController.New(g:NERDTreeMenuItem.AllEnabled())
     call mc.showMenu()
 endfunction
 
 " FUNCTION: s:toggleIgnoreFilter() {{{1
-function! s:toggleIgnoreFilter()
+function! s:toggleIgnoreFilter() abort
     call b:NERDTree.ui.toggleIgnoreFilter()
 endfunction
 
 " FUNCTION: s:toggleShowBookmarks() {{{1
-function! s:toggleShowBookmarks()
+function! s:toggleShowBookmarks() abort
     call b:NERDTree.ui.toggleShowBookmarks()
 endfunction
 
 " FUNCTION: s:toggleShowFiles() {{{1
-function! s:toggleShowFiles()
+function! s:toggleShowFiles() abort
     call b:NERDTree.ui.toggleShowFiles()
 endfunction
 
 " FUNCTION: s:toggleShowHidden() {{{1
 " toggles the display of hidden files
-function! s:toggleShowHidden()
+function! s:toggleShowHidden() abort
     call b:NERDTree.ui.toggleShowHidden()
 endfunction
 
 " FUNCTION: s:toggleZoom() {{{1
-function! s:toggleZoom()
+function! s:toggleZoom() abort
     call b:NERDTree.ui.toggleZoom()
 endfunction
 
@@ -621,7 +662,7 @@ endfunction
 " Args:
 " preserveState: if 1, the current root is left open when the new tree is
 " rendered; if 0, the current root node is closed
-function! nerdtree#ui_glue#upDir(preserveState)
+function! nerdtree#ui_glue#upDir(preserveState) abort
 
     try
         call b:NERDTree.root.cacheParent()
@@ -645,12 +686,12 @@ function! nerdtree#ui_glue#upDir(preserveState)
 endfunction
 
 " FUNCTION: s:upDirCurrentRootOpen() {{{1
-function! s:upDirCurrentRootOpen()
+function! s:upDirCurrentRootOpen() abort
     call nerdtree#ui_glue#upDir(1)
 endfunction
 
 " FUNCTION: s:upDirCurrentRootClosed() {{{1
-function! s:upDirCurrentRootClosed()
+function! s:upDirCurrentRootClosed() abort
     call nerdtree#ui_glue#upDir(0)
 endfunction
 

doc/NERDTree.txt

@@ -122,8 +122,17 @@ The following features and functionality are provided by the NERDTree:
 
 :NERDTreeToggle [<start-directory> | <bookmark>]               *:NERDTreeToggle*
     If a NERDTree already exists for this tab, it is reopened and rendered
-    again.  If no NERDTree exists for this tab then this command acts the
+    again. If <start-directory> or <bookmark> is given, the root of NERDTree
-    same as the |:NERDTree| command.
+    is set to that path. If no NERDTree exists for this tab then this command
+    acts the same as the |:NERDTree| command.
+
+:NERDTreeToggleVCS [<start-directory> | <bookmark>]            *:NERDTreeToggleVCS*
+    Like |:NERDTreeToggle|, but searches up the directory tree to find the top of
+    the version control system repository, and roots the NERDTree there. It
+    works with Git, Subversion, Mercurial, Bazaar, and Darcs repositories. A
+    couple of examples: >
+        :NERDTreeToggleVCS /home/marty/nerdtree/doc  (opens /home/marty/nerdtree)
+        :NERDTreeToggleVCS              (opens root of repository containing CWD)
 
 :NERDTreeFocus                                                  *:NERDTreeFocus*
     Opens (or reopens) the NERDTree if it is not currently visible;
@@ -247,12 +256,12 @@ i........Open selected file in a split window.......................|NERDTree-i|
 gi.......Same as i, but leave the cursor on the NERDTree...........|NERDTree-gi|
 s........Open selected file in a new vsplit.........................|NERDTree-s|
 gs.......Same as s, but leave the cursor on the NERDTree...........|NERDTree-gs|
+<CR>.....User-definable custom open action.......................|NERDTree-<CR>|
 O........Recursively open the selected directory....................|NERDTree-O|
 x........Close the current nodes parent.............................|NERDTree-x|
 X........Recursively close all children of the current node.........|NERDTree-X|
 e........Edit the current dir.......................................|NERDTree-e|
 
-<CR>............same as |NERDTree-o|.
 double-click....same as |NERDTree-o|.
 middle-click....same as |NERDTree-i| for files, and |NERDTree-e| for dirs.
 
@@ -319,7 +328,7 @@ The default key combo for this mapping is "g" + NERDTreeMapActivateNode (see
 ------------------------------------------------------------------------------
                                                                     *NERDTree-t*
 Default key: t
-Map setting: NERDTreeMapOpenInTab
+Map setting: *NERDTreeMapOpenInTab*
 Applies to: files and directories.
 
 Opens the selected file in a new tab. If a directory is selected, a fresh
@@ -332,7 +341,7 @@ in a new tab.
 ------------------------------------------------------------------------------
                                                                     *NERDTree-T*
 Default key: T
-Map setting: NERDTreeMapOpenInTabSilent
+Map setting: *NERDTreeMapOpenInTabSilent*
 Applies to: files and directories.
 
 The same as |NERDTree-t| except that the focus is kept in the current tab.
@@ -340,7 +349,7 @@ The same as |NERDTree-t| except that the focus is kept in the current tab.
 ------------------------------------------------------------------------------
                                                                     *NERDTree-i*
 Default key: i
-Map setting: NERDTreeMapOpenSplit
+Map setting: *NERDTreeMapOpenSplit*
 Applies to: files.
 
 Opens the selected file in a new split window and puts the cursor in the new
@@ -349,7 +358,7 @@ window.
 ------------------------------------------------------------------------------
                                                                    *NERDTree-gi*
 Default key: gi
-Map setting: NERDTreeMapPreviewSplit
+Map setting: *NERDTreeMapPreviewSplit*
 Applies to: files.
 
 The same as |NERDTree-i| except that the cursor is not moved.
@@ -360,7 +369,7 @@ The default key combo for this mapping is "g" + NERDTreeMapOpenSplit (see
 ------------------------------------------------------------------------------
                                                                     *NERDTree-s*
 Default key: s
-Map setting: NERDTreeMapOpenVSplit
+Map setting: *NERDTreeMapOpenVSplit*
 Applies to: files.
 
 Opens the selected file in a new vertically split window and puts the cursor
@@ -369,7 +378,7 @@ in the new window.
 ------------------------------------------------------------------------------
                                                                    *NERDTree-gs*
 Default key: gs
-Map setting: NERDTreeMapPreviewVSplit
+Map setting: *NERDTreeMapPreviewVSplit*
 Applies to: files.
 
 The same as |NERDTree-s| except that the cursor is not moved.
@@ -377,10 +386,19 @@ The same as |NERDTree-s| except that the cursor is not moved.
 The default key combo for this mapping is "g" + NERDTreeMapOpenVSplit (see
 |NERDTree-s|).
 
+------------------------------------------------------------------------------
+                                                                 *NERDTree-<CR>*
+Default key: <CR>
+Map setting: *NERDTreeMapCustomOpen*
+Applies to: files, directories, and bookmarks
+
+Performs a customized open action on the selected node. This allows the user
+to define an action that behaves differently from any of the standard
+keys. See |NERDTreeCustomOpenArgs| for more details.
 ------------------------------------------------------------------------------
                                                                     *NERDTree-O*
 Default key: O
-Map setting: NERDTreeMapOpenRecursively
+Map setting: *NERDTreeMapOpenRecursively*
 Applies to: directories.
 
 Recursively opens the selected directory.
@@ -393,7 +411,7 @@ cached. This is handy, especially if you have .svn directories.
 ------------------------------------------------------------------------------
                                                                     *NERDTree-x*
 Default key: x
-Map setting: NERDTreeMapCloseDir
+Map setting: *NERDTreeMapCloseDir*
 Applies to: files and directories.
 
 Closes the parent of the selected node.
@@ -401,7 +419,7 @@ Closes the parent of the selected node.
 ------------------------------------------------------------------------------
                                                                     *NERDTree-X*
 Default key: X
-Map setting: NERDTreeMapCloseChildren
+Map setting: *NERDTreeMapCloseChildren*
 Applies to: directories.
 
 Recursively closes all children of the selected directory.
@@ -411,7 +429,7 @@ Tip: To quickly "reset" the tree, use |NERDTree-P| with this mapping.
 ------------------------------------------------------------------------------
                                                                     *NERDTree-e*
 Default key: e
-Map setting: NERDTreeMapOpenExpl
+Map setting: *NERDTreeMapOpenExpl*
 Applies to: files and directories.
 
 |:edit|s the selected directory, or the selected file's directory. This could
@@ -421,7 +439,7 @@ result in a NERDTree or a netrw being opened, depending on
 ------------------------------------------------------------------------------
                                                                     *NERDTree-D*
 Default key: D
-Map setting: NERDTreeMapDeleteBookmark
+Map setting: *NERDTreeMapDeleteBookmark*
 Applies to: lines in the bookmarks table
 
 Deletes the currently selected bookmark.
@@ -429,7 +447,7 @@ Deletes the currently selected bookmark.
 ------------------------------------------------------------------------------
                                                                     *NERDTree-P*
 Default key: P
-Map setting: NERDTreeMapJumpRoot
+Map setting: *NERDTreeMapJumpRoot*
 Applies to: no restrictions.
 
 Jump to the tree root.
@@ -437,7 +455,7 @@ Jump to the tree root.
 ------------------------------------------------------------------------------
                                                                     *NERDTree-p*
 Default key: p
-Map setting: NERDTreeMapJumpParent
+Map setting: *NERDTreeMapJumpParent*
 Applies to: files and directories.
 
 Jump to the parent node of the selected node.
@@ -445,7 +463,7 @@ Jump to the parent node of the selected node.
 ------------------------------------------------------------------------------
                                                                     *NERDTree-K*
 Default key: K
-Map setting: NERDTreeMapJumpFirstChild
+Map setting: *NERDTreeMapJumpFirstChild*
 Applies to: files and directories.
 
 Jump to the first child of the current nodes parent.
@@ -458,7 +476,7 @@ If the cursor is already on the first node then do the following:
 ------------------------------------------------------------------------------
                                                                     *NERDTree-J*
 Default key: J
-Map setting: NERDTreeMapJumpLastChild
+Map setting: *NERDTreeMapJumpLastChild*
 Applies to: files and directories.
 
 Jump to the last child of the current nodes parent.
@@ -471,7 +489,7 @@ If the cursor is already on the last node then do the following:
 ------------------------------------------------------------------------------
                                                                   *NERDTree-C-J*
 Default key: <C-J>
-Map setting: NERDTreeMapJumpNextSibling
+Map setting: *NERDTreeMapJumpNextSibling*
 Applies to: files and directories.
 
 Jump to the next sibling of the selected node.
@@ -479,7 +497,7 @@ Jump to the next sibling of the selected node.
 ------------------------------------------------------------------------------
                                                                   *NERDTree-C-K*
 Default key: <C-K>
-Map setting: NERDTreeMapJumpPrevSibling
+Map setting: *NERDTreeMapJumpPrevSibling*
 Applies to: files and directories.
 
 Jump to the previous sibling of the selected node.
@@ -487,7 +505,7 @@ Jump to the previous sibling of the selected node.
 ------------------------------------------------------------------------------
                                                                     *NERDTree-C*
 Default key: C
-Map setting: NERDTreeMapChangeRoot
+Map setting: *NERDTreeMapChangeRoot*
 Applies to: files and directories.
 
 Make the selected directory node the new tree root. If a file is selected, its
@@ -496,7 +514,7 @@ parent is used.
 ------------------------------------------------------------------------------
                                                                     *NERDTree-u*
 Default key: u
-Map setting: NERDTreeMapUpdir
+Map setting: *NERDTreeMapUpdir*
 Applies to: no restrictions.
 
 Move the tree root up a dir (like doing a "cd ..").
@@ -504,7 +522,7 @@ Move the tree root up a dir (like doing a "cd ..").
 ------------------------------------------------------------------------------
                                                                     *NERDTree-U*
 Default key: U
-Map setting: NERDTreeMapUpdirKeepOpen
+Map setting: *NERDTreeMapUpdirKeepOpen*
 Applies to: no restrictions.
 
 Like |NERDTree-u| except that the old tree root is kept open.
@@ -512,7 +530,7 @@ Like |NERDTree-u| except that the old tree root is kept open.
 ------------------------------------------------------------------------------
                                                                     *NERDTree-r*
 Default key: r
-Map setting: NERDTreeMapRefresh
+Map setting: *NERDTreeMapRefresh*
 Applies to: files and directories.
 
 If a dir is selected, recursively refresh that dir, i.e. scan the filesystem
@@ -523,7 +541,7 @@ If a file node is selected then the above is done on it's parent.
 ------------------------------------------------------------------------------
                                                                     *NERDTree-R*
 Default key: R
-Map setting: NERDTreeMapRefreshRoot
+Map setting: *NERDTreeMapRefreshRoot*
 Applies to: no restrictions.
 
 Recursively refresh the tree root.
@@ -531,7 +549,7 @@ Recursively refresh the tree root.
 ------------------------------------------------------------------------------
                                                                     *NERDTree-m*
 Default key: m
-Map setting: NERDTreeMapMenu
+Map setting: *NERDTreeMapMenu*
 Applies to: files and directories.
 
 Display the NERDTree menu. See |NERDTreeMenu| for details.
@@ -539,7 +557,7 @@ Display the NERDTree menu. See |NERDTreeMenu| for details.
 ------------------------------------------------------------------------------
                                                                    *NERDTree-cd*
 Default key: cd
-Map setting: NERDTreeMapChdir
+Map setting: *NERDTreeMapChdir*
 Applies to: files and directories.
 
 Change Vim's current working directory to that of the selected node.
@@ -547,7 +565,7 @@ Change Vim's current working directory to that of the selected node.
 ------------------------------------------------------------------------------
                                                                    *NERDTree-CD*
 Default key: CD
-Map setting: NERDTreeMapCWD
+Map setting: *NERDTreeMapCWD*
 Applies to: no restrictions.
 
 Change the NERDTree root to Vim's current working directory.
@@ -555,7 +573,7 @@ Change the NERDTree root to Vim's current working directory.
 ------------------------------------------------------------------------------
                                                                     *NERDTree-I*
 Default key: I
-Map setting: NERDTreeMapToggleHidden
+Map setting: *NERDTreeMapToggleHidden*
 Applies to: no restrictions.
 
 Toggles whether hidden files (i.e. "dot files") are displayed.
@@ -563,7 +581,7 @@ Toggles whether hidden files (i.e. "dot files") are displayed.
 ------------------------------------------------------------------------------
                                                                     *NERDTree-f*
 Default key: f
-Map setting: NERDTreeMapToggleFilters
+Map setting: *NERDTreeMapToggleFilters*
 Applies to: no restrictions.
 
 Toggles whether file filters are used. See |NERDTreeIgnore| for details.
@@ -571,7 +589,7 @@ Toggles whether file filters are used. See |NERDTreeIgnore| for details.
 ------------------------------------------------------------------------------
                                                                     *NERDTree-F*
 Default key: F
-Map setting: NERDTreeMapToggleFiles
+Map setting: *NERDTreeMapToggleFiles*
 Applies to: no restrictions.
 
 Toggles whether file nodes are displayed.
@@ -579,7 +597,7 @@ Toggles whether file nodes are displayed.
 ------------------------------------------------------------------------------
                                                                     *NERDTree-B*
 Default key: B
-Map setting: NERDTreeMapToggleBookmarks
+Map setting: *NERDTreeMapToggleBookmarks*
 Applies to: no restrictions.
 
 Toggles whether the bookmarks table is displayed.
@@ -587,7 +605,7 @@ Toggles whether the bookmarks table is displayed.
 ------------------------------------------------------------------------------
                                                                     *NERDTree-q*
 Default key: q
-Map setting: NERDTreeMapQuit
+Map setting: *NERDTreeMapQuit*
 Applies to: no restrictions.
 
 Closes the NERDTree window.
@@ -595,7 +613,7 @@ Closes the NERDTree window.
 ------------------------------------------------------------------------------
                                                                     *NERDTree-A*
 Default key: A
-Map setting: NERDTreeMapToggleZoom
+Map setting: *NERDTreeMapToggleZoom*
 Applies to: no restrictions.
 
 Maximize (zoom) and minimize the NERDTree window.
@@ -603,7 +621,7 @@ Maximize (zoom) and minimize the NERDTree window.
 ------------------------------------------------------------------------------
                                                                     *NERDTree-?*
 Default key: ?
-Map setting: NERDTreeMapHelp
+Map setting: *NERDTreeMapHelp*
 Applies to: no restrictions.
 
 Toggles whether the quickhelp is displayed.
@@ -625,7 +643,7 @@ Related tags: |NERDTree-m| |NERDTreeApi|
 ------------------------------------------------------------------------------
                                                                 *NERDTreeMenu-j*
 Default key: j
-Map option: NERDTreeMenuDown
+Map option: *NERDTreeMenuDown*
 Applies to: The NERDTree menu.
 
 Moves the cursor down.
@@ -633,7 +651,7 @@ Moves the cursor down.
 ------------------------------------------------------------------------------
                                                                 *NERDTreeMenu-k*
 Default key: k
-Map option: NERDTreeMenuUp
+Map option: *NERDTreeMenuUp*
 Applies to: The NERDTree menu.
 
 Moves the cursor up.
@@ -754,6 +772,9 @@ the NERDTree. These settings should be set in your vimrc, using `:let`.
                             file or directory name from the rest of the
                             characters on the line of text.
 
+|NERDTreeCustomOpenArgs|      A dictionary with values that control how a node
+                            is opened with the |NERDTree-<CR>| key.
+
 ------------------------------------------------------------------------------
 3.2. Customisation details                             *NERDTreeSettingsDetails*
 
@@ -837,9 +858,17 @@ above nodes would then be sorted like this: >
     z110.txt
 <
 ------------------------------------------------------------------------------
-                                                             *NERDTreeChDirMode*
+                                                                *NERDTreeUseTCD*
+Values: 0 or 1.
+Default: 0.
 
-Values: 0, 1 or 2.
+By default, NERDTree will use the `:cd` command to change the current working
+directory. If this setting is turned on, and the `:tcd` command is available, it
+will be used instead.
+
+------------------------------------------------------------------------------
+                                                             *NERDTreeChDirMode*
+Values: 0, 1, 2, or 3.
 Default: 0.
 
 Use this setting to tell the script when (if at all) to change the current
@@ -859,6 +888,9 @@ the CWD is changed whenever the tree root is changed. For example, if the CWD
 is /home/marty/foobar and you make the node for /home/marty/foobar/baz the new
 root then the CWD will become /home/marty/foobar/baz.
 
+If the set to 3, then it behaves the same as if set to 2, and the CWD is
+changed whenever changing tabs to whatever the tree root is on that tab.
+
 ------------------------------------------------------------------------------
                                                    *NERDTreeHighlightCursorline*
 Values: 0 or 1.
@@ -968,7 +1000,6 @@ then (to single click activate it) you must click somewhere in
 
 ------------------------------------------------------------------------------
                                                             *NERDTreeQuitOnOpen*
-
 Values: 0,1,2 or 3.
 Default: 0
 
@@ -1031,28 +1062,31 @@ window.  Use one of the follow lines for this setting: >
 Values: a list of regular expressions.
 Default: ['\/$', '*', '\.swp$',  '\.bak$', '\~$']
 
-This setting is a list of regular expressions which are used to specify the
+This setting is a list of regular expressions which are used to group or sort
-order of nodes under their parent.
+the nodes under their parent.
 
 For example, if the setting is: >
     ['\.vim$', '\.c$', '\.h$', '*', 'foobar']
 <
-then all .vim files will be placed at the top, followed by all .c files then
+then all .vim files will be grouped at the top, followed by all .c files then
 all .h files. All files containing the string 'foobar' will be placed at the
 end.  The star is a special flag: it tells the script that every node that
 doesn't match any of the other regexps should be placed here.
 
-If no star is present in NERDTreeSortOrder then one is automatically
+If no star is present in NERDTreeSortOrder, then one is automatically
-appended to the array.
+appended to the end of the list.
 
 The regex '\/$' should be used to match directory nodes.
 
-A special flag can be used to sort by the modification timestamps of files and
+Files can also be sorted by 1) the modification timestamp, 2) the size, or 3)
-directories. It is either '[[timestamp]]' for ascending, or '[[-timestamp]]'
+the extension. Directories are always sorted by name. To accomplish this, the
-for descending. If placed at the beginning of the list, files and directories
+following special flags are used:
-are sorted by timestamp, and then by the remaining items in the sort order
+  [[timestamp]]   [[-timestamp]]   [[size]]   [[-size]]   [[extension]]
-list. If this flag is in any other position of the list, timestamp sorting is
+The hyphen specifies a descending sort; extensions are sorted in ascending
-done secondarily. See examples 4, 5, and 6 below.
+order only. If placed at the beginning of the list, files are sorted according
+to these flags first, and then grouped by the remaining items in the list. If
+the flags are in any other position of the list, this special sorting is done
+secondarily. See examples 4, 5, and 6 below.
 
 After this sorting is done, the files in each group are sorted alphabetically.
 
@@ -1060,20 +1094,20 @@ Examples: >
     (1) ['*', '\/$']
     (2) []
     (3) ['\/$', '\.rb$', '\.php$', '*', '\.swp$',  '\.bak$', '\~$']
-    (4) ['[[timestamp]]']
+    (4) ['[[-size]]']
-    (5) ['\/$', '*', '[[-timestamp]]']
+    (5) ['\/$', '*', '[[timestamp]]']
-    (6) ['\.md$', '\.c$', '[[-timestamp]]', '*']
+    (6) ['foo','\/$','[[extension]]']
 <
 1. Directories will appear last, everything else will appear above.
 2. Everything will simply appear in alphabetical order.
 3. Dirs will appear first, then ruby and php. Swap files, bak files and vim
    backup files will appear last with everything else preceding them.
-4. All files and directories are sorted by timestamp, oldest first. If any
+4. Everything is sorted by size, largest to smallest, with directories
-   files have identical timestamps, they are sorted alphabetically.
+   considered to have size 0 bytes.
-5. Directories are first, newest to oldest, then everything else, newest to
+5. Directories will appear first alphabetically, followed by files, sorted by
-   oldest.
+   timestamp, oldest first.
-6. Markdown files first, followed by C source files, then everything else.
+6. Files and directories matching 'foo' first, followed by other directories,
-   Each group is shown newest to oldest.
+   then all other files. Each section of files is sorted by file extension.
 
 ------------------------------------------------------------------------------
                                                             *NERDTreeStatusline*
@@ -1189,13 +1223,19 @@ Values: Any single character.
 Defaults:   Windows: ~ and +    Others: ▾ and ▸
 
 These characters indicate whether a directory is collapsible or expandable.
-
+Example: >
-They can be set to "\u00a0" to hide the arrows, but if you do this you may
-need to change the node delimiter. See |NERDTreeNodeDelimiter|. You cannot use
-the same character for both the arrows and the delimiter. Example: >
     let NERDTreeDirArrowExpandable=">"
     let NERDTreeDirArrowCollapsible="v"
 <
+They can be set to "\u00a0" to replace the arrows with a non-breaking space.
+If you do this you may need to change the node delimiter. See
+|NERDTreeNodeDelimiter|. You cannot use the same character for both the arrows
+and the delimiter.
+
+Alternatively, they can be set to '' (an empty string). This removes the
+arrows and the single space that follows them, shifting the entire tree two
+character positions to the left.
+
 ------------------------------------------------------------------------------
                                                          *NERDTreeNodeDelimiter*
 Values: Any single character.
@@ -1205,7 +1245,7 @@ This character is used to separate the file or directory name from the rest of
 the characters in the line of text. It allows filenames to contain special
 characters that are otherwise used in the NERDTree, such as square brackets,
 braces, trailing asterisk, and leading space. For more details, see the
-responsible pull request: https://github.com/scrooloose/nerdtree/pull/868.
+responsible pull request: https://github.com/preservim/nerdtree/pull/868.
 
 The default value of this variable depends on the features compiled into your
 vim and the values of |NERDTreeDirArrowCollapsible| and
@@ -1233,6 +1273,32 @@ when specifying by hex or Unicode. >
     let NERDTreeNodeDelimiter="\u00a0"   "non-breaking space
     let NERDTreeNodeDelimiter="😀"       "smiley face
 <
+------------------------------------------------------------------------------
+                                                        *NERDTreeCustomOpenArgs*
+Values: A nested dictionary, as described below
+Default: {'file': {'reuse': 'all', 'where': 'p'}, 'dir': {}}
+
+This dictionary contains two keys, 'file' and 'dir', whose values each are
+another dictionary. The inner dictionary is a set of parameters used by
+|NERDTree-<CR>| to open a file or directory. Setting these parameters allows you
+to customize the way the node is opened. The default value matches what
+|NERDTree-o| does. To change that behavior, use these keys and
+values in the inner dictionaries:
+
+'where':    specifies whether the node should be opened in a new split ("h" or
+            "v"), in a new tab ("t") or, in the last window ("p").
+'reuse':    if file is already shown in a window, jump there; takes values
+            "all", "currenttab", or empty
+'keepopen': boolean (0 or 1); if true, the tree window will not be closed
+'stay':     boolean (0 or 1); if true, remain in tree window after opening
+
+For example:
+To open files and directories (creating a new NERDTree) in a new tab, >
+    {'file':{'where': 't'}, 'dir':{'where':'t'}}
+<
+To open a file always in the current tab, and expand directories in place, >
+    {'file': {'reuse':'currenttab', 'where':'p', 'keepopen':1, 'stay':1}}
+<
 ==============================================================================
 4. The NERDTree API                                                *NERDTreeAPI*
 
@@ -1256,6 +1322,10 @@ following code conventions are used:
 See this blog post for more details:
  http://got-ravings.blogspot.com/2008/09/vim-pr0n-prototype-based-objects.html
 
+A number of API functions take a callback argument to call. The callback can
+be either a string with the name of a function to call, or a |Funcref| object
+which will be called directly.
+
 ------------------------------------------------------------------------------
 4.1. Key map API                                             *NERDTreeKeymapAPI*
 
@@ -1435,11 +1505,11 @@ in the fridge for later ;)
 Martyzilla recruited two other unwitting accomplices to become his minions in
 his quest to conquer the Vim plugin world. While he may still love to receive
 your emails, the best way to send suggestions, bug reports, and questions is
-to submit an issue at http://github.com/scrooloose/nerdtree/issues.
+to submit an issue at http://github.com/preservim/nerdtree/issues.
 
 The latest stable and development versions are on Github.
-    Stable: http://github.com/scrooloose/nerdtree (master branch)
+    Stable: http://github.com/preservim/nerdtree (master branch)
-    Development: http://github.com/scrooloose/nerdtree/branches
+    Development: http://github.com/preservim/nerdtree/branches
 
 Title Credit:
   * http://ascii.co.uk/art/tree

lib/nerdtree/bookmark.vim

@@ -33,7 +33,7 @@ endfunction
 " Class method to get all bookmarks. Lazily initializes the bookmarks global
 " variable
 function! s:Bookmark.Bookmarks()
-    if !exists("g:NERDTreeBookmarks")
+    if !exists('g:NERDTreeBookmarks')
         let g:NERDTreeBookmarks = []
     endif
     return g:NERDTreeBookmarks
@@ -53,7 +53,7 @@ endfunction
 
 " FUNCTION: Bookmark.BookmarkFor(name) {{{1
 " Class method that returns the Bookmark object having the specified name.
-" Throws "NERDTree.BookmarkNotFoundError" if no Bookmark is found.
+" Throws NERDTree.BookmarkNotFoundError if no Bookmark is found.
 function! s:Bookmark.BookmarkFor(name)
     let l:result = {}
     for l:bookmark in s:Bookmark.Bookmarks()
@@ -93,7 +93,7 @@ function! s:Bookmark.CacheBookmarks(silent)
         for i in bookmarkStrings
 
             "ignore blank lines
-            if i != ''
+            if i !=# ''
 
                 let name = substitute(i, '^\(.\{-}\) .*$', '\1', '')
                 let path = substitute(i, '^.\{-} \(.*\)$', '\1', '')
@@ -111,7 +111,7 @@ function! s:Bookmark.CacheBookmarks(silent)
         if invalidBookmarksFound
             call s:Bookmark.Write()
             if !a:silent
-                call nerdtree#echo(invalidBookmarksFound . " invalid bookmarks were read. See :help NERDTreeInvalidBookmarks for info.")
+                call nerdtree#echo(invalidBookmarksFound . ' invalid bookmarks were read. See :help NERDTreeInvalidBookmarks for info.')
             endif
         endif
     endif
@@ -120,16 +120,16 @@ endfunction
 " FUNCTION: Bookmark.CompareBookmarksByName(firstBookmark, secondBookmark) {{{1
 " Class method that indicates the relative position of two bookmarks when
 " placed in alphabetical order by name. Case-sensitivity is determined by an
-" option. Supports the "s:Bookmark.SortBookmarksList()" method.
+" option. Supports the s:Bookmark.SortBookmarksList() method.
 function! s:Bookmark.CompareBookmarksByName(firstBookmark, secondBookmark)
     let l:result = 0
-    if g:NERDTreeBookmarksSort == 1
+    if g:NERDTreeBookmarksSort ==# 1
         if a:firstBookmark.name <? a:secondBookmark.name
             let l:result = -1
         elseif a:firstBookmark.name >? a:secondBookmark.name
             let l:result = 1
         endif
-    elseif g:NERDTreeBookmarksSort == 2
+    elseif g:NERDTreeBookmarksSort ==# 2
         if a:firstBookmark.name <# a:secondBookmark.name
             let l:result = -1
         elseif a:firstBookmark.name ># a:secondBookmark.name
@@ -159,13 +159,13 @@ endfunction
 " FUNCTION: s:Edit() {{{1
 " opens the NERDTreeBookmarks file for manual editing
 function! s:Bookmark.Edit()
-    execute "wincmd w"
+    call nerdtree#exec('wincmd w', 1)
-    execute "edit ".g:NERDTreeBookmarksFile
+    call nerdtree#exec('edit '.g:NERDTreeBookmarksFile, 1)
 endfunction
 
 " FUNCTION: Bookmark.getNode(nerdtree, searchFromAbsoluteRoot) {{{1
 " Returns the tree node object associated with this Bookmark.
-" Throws "NERDTree.BookmarkedNodeNotFoundError" if the node is not found.
+" Throws NERDTree.BookmarkedNodeNotFoundError if the node is not found.
 "
 " Args:
 " searchFromAbsoluteRoot: boolean flag, search from the highest cached node
@@ -185,8 +185,8 @@ endfunction
 
 " FUNCTION: Bookmark.GetNodeForName(name, searchFromAbsoluteRoot, nerdtree) {{{1
 " Class method that returns the tree node object for the Bookmark with the
-" given name. Throws "NERDTree.BookmarkNotFoundError" if a Bookmark with the
+" given name. Throws NERDTree.BookmarkNotFoundError if a Bookmark with the
-" name does not exist. Throws "NERDTree.BookmarkedNodeNotFoundError" if a
+" name does not exist. Throws NERDTree.BookmarkedNodeNotFoundError if a
 " tree node for the named Bookmark could not be found.
 function! s:Bookmark.GetNodeForName(name, searchFromAbsoluteRoot, nerdtree)
     let l:bookmark = s:Bookmark.BookmarkFor(a:name)
@@ -196,9 +196,9 @@ endfunction
 " FUNCTION: Bookmark.GetSelected() {{{1
 " returns the Bookmark the cursor is over, or {}
 function! s:Bookmark.GetSelected()
-    let line = getline(".")
+    let line = getline('.')
     let name = substitute(line, '^>\(.\{-}\) .\+$', '\1', '')
-    if name != line
+    if name !=# line
         try
             return s:Bookmark.BookmarkFor(name)
         catch /^NERDTree.BookmarkNotFoundError/
@@ -212,7 +212,7 @@ endfunction
 " Class method to get all invalid bookmark strings read from the bookmarks
 " file
 function! s:Bookmark.InvalidBookmarks()
-    if !exists("g:NERDTreeInvalidBookmarks")
+    if !exists('g:NERDTreeInvalidBookmarks')
         let g:NERDTreeInvalidBookmarks = []
     endif
     return g:NERDTreeInvalidBookmarks
@@ -222,8 +222,8 @@ endfunction
 function! s:Bookmark.mustExist()
     if !self.path.exists()
         call s:Bookmark.CacheBookmarks(1)
-        throw "NERDTree.BookmarkPointsToInvalidLocationError: the bookmark \"".
+        throw 'NERDTree.BookmarkPointsToInvalidLocationError: the bookmark "'.
-            \ self.name ."\" points to a non existing location: \"". self.path.str()
+            \ self.name .'" points to a non existing location: "'. self.path.str()
     endif
 endfunction
 
@@ -231,7 +231,7 @@ endfunction
 " Create a new bookmark object with the given name and path object
 function! s:Bookmark.New(name, path)
     if a:name =~# ' '
-        throw "NERDTree.IllegalBookmarkNameError: illegal name:" . a:name
+        throw 'NERDTree.IllegalBookmarkNameError: illegal name:' . a:name
     endif
 
     let newBookmark = copy(self)
@@ -292,7 +292,7 @@ endfunction
 " Get the string that should be rendered in the view for this bookmark
 function! s:Bookmark.str()
     let pathStrMaxLen = winwidth(g:NERDTree.GetWinNum()) - 4 - strdisplaywidth(self.name)
-    if &nu
+    if &number
         let pathStrMaxLen = pathStrMaxLen - &numberwidth
     endif
 
@@ -335,7 +335,7 @@ function! s:Bookmark.validate()
         return 1
     else
         call s:Bookmark.CacheBookmarks(1)
-        call nerdtree#echo(self.name . "now points to an invalid location. See :help NERDTreeInvalidBookmarks for info.")
+        call nerdtree#echo(self.name . 'now points to an invalid location. See :help NERDTreeInvalidBookmarks for info.')
         return 0
     endif
 endfunction
@@ -349,7 +349,7 @@ function! s:Bookmark.Write()
     endfor
 
     "add a blank line before the invalid ones
-    call add(bookmarkStrings, "")
+    call add(bookmarkStrings, '')
 
     for j in s:Bookmark.InvalidBookmarks()
         call add(bookmarkStrings, j)
@@ -358,7 +358,7 @@ function! s:Bookmark.Write()
     try
         call writefile(bookmarkStrings, g:NERDTreeBookmarksFile)
     catch
-        call nerdtree#echoError("Failed to write bookmarks file. Make sure g:NERDTreeBookmarksFile points to a valid location.")
+        call nerdtree#echoError('Failed to write bookmarks file. Make sure g:NERDTreeBookmarksFile points to a valid location.')
     endtry
 endfunction
 

lib/nerdtree/creator.vim

@@ -13,9 +13,6 @@ let g:NERDTreeCreator = s:Creator
 
 " FUNCTION: s:Creator._bindMappings() {{{1
 function! s:Creator._bindMappings()
-    "make <cr> do the same as the activate node mapping
-    nnoremap <silent> <buffer> <cr> :call nerdtree#ui_glue#invokeKeyMap(g:NERDTreeMapActivateNode)<cr>
-
     call g:NERDTreeKeyMap.BindAll()
 
     command! -buffer -nargs=? Bookmark :call nerdtree#ui_glue#bookmarkNode('<args>')
@@ -85,20 +82,20 @@ function! s:Creator.createWindowTree(dir)
     try
         let path = g:NERDTreePath.New(a:dir)
     catch /^NERDTree.InvalidArgumentsError/
-        call nerdtree#echo("Invalid directory name:" . a:name)
+        call nerdtree#echo('Invalid directory name:' . a:dir)
         return
     endtry
 
     "we want the directory buffer to disappear when we do the :edit below
     setlocal bufhidden=wipe
 
-    let previousBuf = expand("#")
+    let previousBuf = expand('#')
 
     "we need a unique name for each window tree buffer to ensure they are
     "all independent
-    exec g:NERDTreeCreatePrefix . " edit " . self._nextBufferName()
+    exec g:NERDTreeCreatePrefix . ' edit ' . self._nextBufferName()
 
-    call self._createNERDTree(path, "window")
+    call self._createNERDTree(path, 'window')
     let b:NERDTree._previousBuf = bufnr(previousBuf)
     call self._setCommonBufOptions()
 
@@ -112,7 +109,7 @@ function! s:Creator._createNERDTree(path, type)
     let b:NERDTree = g:NERDTree.New(a:path, a:type)
 
     " TODO: This assignment is kept for compatibility reasons.  Many other
-    " plugins use "b:NERDTreeRoot" instead of "b:NERDTree.root".  Remove this
+    " plugins use b:NERDTreeRoot instead of b:NERDTree.root.  Remove this
     " assignment in the future.
     let b:NERDTreeRoot = b:NERDTree.root
 
@@ -129,9 +126,9 @@ endfunction
 function! s:Creator.createMirror()
     "get the names off all the nerd tree buffers
     let treeBufNames = []
-    for i in range(1, tabpagenr("$"))
+    for i in range(1, tabpagenr('$'))
         let nextName = self._tabpagevar(i, 'NERDTreeBufName')
-        if nextName != -1 && (!exists("t:NERDTreeBufName") || nextName != t:NERDTreeBufName)
+        if nextName != -1 && (!exists('t:NERDTreeBufName') || nextName != t:NERDTreeBufName)
             call add(treeBufNames, nextName)
         endif
     endfor
@@ -143,7 +140,7 @@ function! s:Creator.createMirror()
     let i = 0
     while i < len(treeBufNames)
         let bufName = treeBufNames[i]
-        let treeRoot = getbufvar(bufName, "NERDTree").root
+        let treeRoot = getbufvar(bufName, 'NERDTree').root
         let options[i+1 . '. ' . treeRoot.path.str() . '  (buf name: ' . bufName . ')'] = bufName
         let i = i + 1
     endwhile
@@ -151,7 +148,7 @@ function! s:Creator.createMirror()
     "work out which tree to mirror, if there is more than 1 then ask the user
     let bufferName = ''
     if len(keys(options)) > 1
-        let choices = ["Choose a tree to mirror"]
+        let choices = ['Choose a tree to mirror']
         let choices = extend(choices, sort(keys(options)))
         let choice = inputlist(choices)
         if choice < 1 || choice > len(options) || choice ==# ''
@@ -162,7 +159,7 @@ function! s:Creator.createMirror()
     elseif len(keys(options)) ==# 1
         let bufferName = values(options)[0]
     else
-        call nerdtree#echo("No trees to mirror")
+        call nerdtree#echo('No trees to mirror')
         return
     endif
 
@@ -230,7 +227,7 @@ endfunction
 " FUNCTION: s:Creator._nextBufferNumber() {{{1
 " the number to add to the nerd tree buffer name to make the buf name unique
 function! s:Creator._nextBufferNumber()
-    if !exists("s:Creator._NextBufNum")
+    if !exists('s:Creator._NextBufNum')
         let s:Creator._NextBufNum = 1
     else
         let s:Creator._NextBufNum += 1
@@ -257,7 +254,7 @@ function! s:Creator._pathForString(str)
         try
             let path = g:NERDTreePath.New(dir)
         catch /^NERDTree.InvalidArgumentsError/
-            call nerdtree#echo("No bookmark or directory found for: " . a:str)
+            call nerdtree#echo('No bookmark or directory found for: ' . a:str)
             return {}
         endtry
     endif
@@ -277,7 +274,7 @@ function! s:Creator._removeTreeBufForTab()
 
         "nerdtree buf may be mirrored/displayed elsewhere
         if self._isBufHidden(buf)
-            exec "bwipeout " . buf
+            exec 'bwipeout ' . buf
         endif
 
     endif
@@ -303,11 +300,11 @@ function! s:Creator._setCommonBufOptions()
     setlocal nowrap
 
     if g:NERDTreeShowLineNumbers
-        setlocal nu
+        setlocal number
     else
-        setlocal nonu
+        setlocal nonumber
         if v:version >= 703
-            setlocal nornu
+            setlocal norelativenumber
         endif
     endif
 
@@ -333,17 +330,20 @@ endfunction
 " FUNCTION: s:Creator._tabpagevar(tabnr, var) {{{1
 function! s:Creator._tabpagevar(tabnr, var)
     let currentTab = tabpagenr()
-    let old_ei = &ei
+    let old_ei = &eventignore
-    set ei=all
+    set eventignore=all
 
-    exec "tabnext " . a:tabnr
+    try
-    let v = -1
+        exec 'tabnext ' . a:tabnr
-    if exists('t:' . a:var)
+        let v = -1
-        exec 'let v = t:' . a:var
+        if exists('t:' . a:var)
-    endif
+            exec 'let v = t:' . a:var
-    exec "tabnext " . currentTab
+        endif
+        exec 'tabnext ' . currentTab
 
-    let &ei = old_ei
+    finally
+        let &eventignore = old_ei
+    endtry
 
     return v
 endfunction
@@ -355,17 +355,20 @@ function! s:Creator.ToggleTabTree(dir)
 endfunction
 
 " FUNCTION: s:Creator.toggleTabTree(dir) {{{1
-" Toggles the NERD tree. I.e the NERD tree is open, it is closed, if it is
+" Toggles the NERD tree. I.e if the NERD tree is open, it is closed. If it is
-" closed it is restored or initialized (if it doesnt exist)
+" closed, it is restored or initialized. If dir is not empty, it will be set
+" as the new root.
 "
 " Args:
-" dir: the full path for the root node (is only used if the NERD tree is being
+" dir: the full path for the root node (is used if the NERD tree is being
-" initialized.
+" initialized, or to change the root to a new dir.)
 function! s:Creator.toggleTabTree(dir)
     if g:NERDTree.ExistsForTab()
         if !g:NERDTree.IsOpen()
             call self._createTreeWin()
-            if !&hidden
+            if !empty(a:dir)
+                call self.createTabTree(a:dir)
+            elseif !&hidden
                 call b:NERDTree.render()
             endif
             call b:NERDTree.ui.restoreScreenState()

lib/nerdtree/flag_set.vim

@@ -43,13 +43,13 @@ endfunction
 
 "FUNCTION: FlagSet.renderToString() {{{1
 function! s:FlagSet.renderToString()
-    let flagstring = ""
+    let flagstring = ''
     for i in values(self._flags)
         let flagstring .= join(i)
     endfor
 
     if len(flagstring) == 0
-        return ""
+        return ''
     endif
 
     return '[' . flagstring . ']'

lib/nerdtree/key_map.vim

@@ -53,7 +53,7 @@ function! s:KeyMap.bind()
     endif
     let keymapInvokeString = escape(keymapInvokeString, '\')
 
-    let premap = self.key == "<LeftRelease>" ? " <LeftRelease>" : " "
+    let premap = self.key ==# '<LeftRelease>' ? ' <LeftRelease>' : ' '
 
     exec 'nnoremap <buffer> <silent> '. self.key . premap . ':call nerdtree#ui_glue#invokeKeyMap("'. keymapInvokeString .'")<cr>'
 endfunction
@@ -66,7 +66,7 @@ endfunction
 "FUNCTION: KeyMap.invoke() {{{1
 "Call the KeyMaps callback function
 function! s:KeyMap.invoke(...)
-    let Callback = function(self.callback)
+    let Callback = type(self.callback) ==# type(function('tr')) ? self.callback : function(self.callback)
     if a:0
         call Callback(a:1)
     else
@@ -78,11 +78,11 @@ endfunction
 "Find a keymapping for a:key and the current scope invoke it.
 "
 "Scope is determined as follows:
-"   * if the cursor is on a dir node then "DirNode"
+"   * if the cursor is on a dir node then DirNode
-"   * if the cursor is on a file node then "FileNode"
+"   * if the cursor is on a file node then FileNode
-"   * if the cursor is on a bookmark then "Bookmark"
+"   * if the cursor is on a bookmark then Bookmark
 "
-"If a keymap has the scope of "all" then it will be called if no other keymap
+"If a keymap has the scope of 'all' then it will be called if no other keymap
 "is found for a:key and the scope.
 function! s:KeyMap.Invoke(key)
 
@@ -100,7 +100,7 @@ function! s:KeyMap.Invoke(key)
 
         "try file node
         if !node.path.isDirectory
-            let km = s:KeyMap.FindFor(a:key, "FileNode")
+            let km = s:KeyMap.FindFor(a:key, 'FileNode')
             if !empty(km)
                 return km.invoke(node)
             endif
@@ -108,14 +108,14 @@ function! s:KeyMap.Invoke(key)
 
         "try dir node
         if node.path.isDirectory
-            let km = s:KeyMap.FindFor(a:key, "DirNode")
+            let km = s:KeyMap.FindFor(a:key, 'DirNode')
             if !empty(km)
                 return km.invoke(node)
             endif
         endif
 
         "try generic node
-        let km = s:KeyMap.FindFor(a:key, "Node")
+        let km = s:KeyMap.FindFor(a:key, 'Node')
         if !empty(km)
             return km.invoke(node)
         endif
@@ -125,14 +125,14 @@ function! s:KeyMap.Invoke(key)
     "try bookmark
     let bm = g:NERDTreeBookmark.GetSelected()
     if !empty(bm)
-        let km = s:KeyMap.FindFor(a:key, "Bookmark")
+        let km = s:KeyMap.FindFor(a:key, 'Bookmark')
         if !empty(km)
             return km.invoke(bm)
         endif
     endif
 
     "try all
-    let km = s:KeyMap.FindFor(a:key, "all")
+    let km = s:KeyMap.FindFor(a:key, 'all')
     if !empty(km)
         return km.invoke()
     endif
@@ -143,7 +143,7 @@ function! s:KeyMap.Create(options)
     let opts = extend({'scope': 'all', 'quickhelpText': ''}, copy(a:options))
 
     "dont override other mappings unless the 'override' option is given
-    if get(opts, 'override', 0) == 0 && !empty(s:KeyMap.FindFor(opts['key'], opts['scope']))
+    if get(opts, 'override', 0) ==# 0 && !empty(s:KeyMap.FindFor(opts['key'], opts['scope']))
         return
     end
 

lib/nerdtree/menu_controller.vim

@@ -31,7 +31,11 @@ function! s:MenuController.showMenu()
         let l:done = 0
 
         while !l:done
-            redraw!
+            if has('nvim')
+                mode
+            else
+                redraw!
+            endif
             call self._echoPrompt()
 
             let l:key = nr2char(getchar())
@@ -40,13 +44,13 @@ function! s:MenuController.showMenu()
     finally
         call self._restoreOptions()
 
-        " Redraw when "Ctrl-C" or "Esc" is received.
+        " Redraw when Ctrl-C or Esc is received.
-        if !l:done || self.selection == -1
+        if !l:done || self.selection ==# -1
             redraw!
         endif
     endtry
 
-    if self.selection != -1
+    if self.selection !=# -1
         let l:m = self._current()
         call l:m.execute()
     endif
@@ -54,24 +58,25 @@ endfunction
 
 "FUNCTION: MenuController._echoPrompt() {{{1
 function! s:MenuController._echoPrompt()
-    let navHelp = "Use " . g:NERDTreeMenuDown . "/" . g:NERDTreeMenuUp . "/enter"
+    let navHelp = 'Use ' . g:NERDTreeMenuDown . '/' . g:NERDTreeMenuUp . '/enter'
 
     if self.isMinimal()
         let selection = self.menuItems[self.selection].text
+        let keyword = matchstr(selection, '[^ ]*([^ ]*')
 
         let shortcuts = map(copy(self.menuItems), "v:val['shortcut']")
-        let shortcuts[self.selection] = " " . split(selection)[0] . " "
+        let shortcuts[self.selection] = ' ' . keyword . ' '
 
-        echo "Menu: [" . join(shortcuts, ",") . "] (" . navHelp . " or shortcut): "
+        echo 'Menu: [' . join(shortcuts, ',') . '] (' . navHelp . ' or shortcut): '
     else
-        echo "NERDTree Menu. " . navHelp . " . or the shortcuts indicated"
+        echo 'NERDTree Menu. ' . navHelp . ', or the shortcuts indicated'
-        echo "========================================================="
+        echo '========================================================='
 
         for i in range(0, len(self.menuItems)-1)
-            if self.selection == i
+            if self.selection ==# i
-                echo "> " . self.menuItems[i].text
+                echo '> ' . self.menuItems[i].text
             else
-                echo "  " . self.menuItems[i].text
+                echo '  ' . self.menuItems[i].text
             endif
         endfor
     endif
@@ -87,20 +92,20 @@ endfunction
 "change the selection (if appropriate) and return 1 if the user has made
 "their choice, 0 otherwise
 function! s:MenuController._handleKeypress(key)
-    if a:key == g:NERDTreeMenuDown
+    if a:key ==# g:NERDTreeMenuDown
         call self._cursorDown()
-    elseif a:key == g:NERDTreeMenuUp
+    elseif a:key ==# g:NERDTreeMenuUp
         call self._cursorUp()
-    elseif a:key == nr2char(27) "escape
+    elseif a:key ==# nr2char(27) "escape
         let self.selection = -1
         return 1
-    elseif a:key == "\r" || a:key == "\n" "enter and ctrl-j
+    elseif a:key ==# "\r" || a:key ==# "\n" "enter and ctrl-j
         return 1
     else
         let index = self._nextIndexFor(a:key)
-        if index != -1
+        if index !=# -1
             let self.selection = index
-            if len(self._allIndexesFor(a:key)) == 1
+            if len(self._allIndexesFor(a:key)) ==# 1
                 return 1
             endif
         endif
@@ -115,7 +120,7 @@ function! s:MenuController._allIndexesFor(shortcut)
     let toReturn = []
 
     for i in range(0, len(self.menuItems)-1)
-        if self.menuItems[i].shortcut == a:shortcut
+        if self.menuItems[i].shortcut ==# a:shortcut
             call add(toReturn, i)
         endif
     endfor
@@ -128,13 +133,13 @@ endfunction
 "current cursor location and wraps around to the top again if need be
 function! s:MenuController._nextIndexFor(shortcut)
     for i in range(self.selection+1, len(self.menuItems)-1)
-        if self.menuItems[i].shortcut == a:shortcut
+        if self.menuItems[i].shortcut ==# a:shortcut
             return i
         endif
     endfor
 
     for i in range(0, self.selection)
-        if self.menuItems[i].shortcut == a:shortcut
+        if self.menuItems[i].shortcut ==# a:shortcut
             return i
         endif
     endfor

lib/nerdtree/menu_item.vim

@@ -6,7 +6,7 @@ let g:NERDTreeMenuItem = s:MenuItem
 "FUNCTION: MenuItem.All() {{{1
 "get all top level menu items
 function! s:MenuItem.All()
-    if !exists("s:menuItems")
+    if !exists('s:menuItems')
         let s:menuItems = []
     endif
     return s:menuItems
@@ -58,7 +58,7 @@ function! s:MenuItem.CreateSeparator(options)
     let standard_options = { 'text': '--------------------',
                 \ 'shortcut': -1,
                 \ 'callback': -1 }
-    let options = extend(a:options, standard_options, "force")
+    let options = extend(a:options, standard_options, 'force')
 
     return s:MenuItem.Create(options)
 endfunction
@@ -67,7 +67,7 @@ endfunction
 "make a new submenu and add it to global list
 function! s:MenuItem.CreateSubmenu(options)
     let standard_options = { 'callback': -1 }
-    let options = extend(a:options, standard_options, "force")
+    let options = extend(a:options, standard_options, 'force')
 
     return s:MenuItem.Create(options)
 endfunction
@@ -79,7 +79,7 @@ endfunction
 "specified
 function! s:MenuItem.enabled()
     if self.isActiveCallback != -1
-        return {self.isActiveCallback}()
+        return type(self.isActiveCallback) == type(function('tr')) ? self.isActiveCallback() : {self.isActiveCallback}()
     endif
     return 1
 endfunction
@@ -94,7 +94,11 @@ function! s:MenuItem.execute()
         call mc.showMenu()
     else
         if self.callback != -1
-            call {self.callback}()
+            if type(self.callback) == type(function('tr'))
+                call self.callback()
+            else
+                call {self.callback}()
+            endif
         endif
     endif
 endfunction

lib/nerdtree/nerdtree.vim

@@ -20,7 +20,7 @@ function! s:NERDTree.changeRoot(node)
     call self.root.open()
 
     "change dir to the dir of the new root if instructed to
-    if g:NERDTreeChDirMode ==# 2
+    if g:NERDTreeChDirMode >= 2
         call self.root.path.changeToDir()
     endif
 
@@ -37,26 +37,26 @@ function! s:NERDTree.Close()
         return
     endif
 
-    if winnr("$") != 1
+    if winnr('$') !=# 1
         " Use the window ID to identify the currently active window or fall
         " back on the buffer ID if win_getid/win_gotoid are not available, in
         " which case we'll focus an arbitrary window showing the buffer.
         let l:useWinId = exists('*win_getid') && exists('*win_gotoid')
 
-        if winnr() == s:NERDTree.GetWinNum()
+        if winnr() ==# s:NERDTree.GetWinNum()
-            call nerdtree#exec("wincmd p")
+            call nerdtree#exec('wincmd p', 1)
-            let l:activeBufOrWin = l:useWinId ? win_getid() : bufnr("")
+            let l:activeBufOrWin = l:useWinId ? win_getid() : bufnr('')
-            call nerdtree#exec("wincmd p")
+            call nerdtree#exec('wincmd p', 1)
         else
-            let l:activeBufOrWin = l:useWinId ? win_getid() : bufnr("")
+            let l:activeBufOrWin = l:useWinId ? win_getid() : bufnr('')
         endif
 
-        call nerdtree#exec(s:NERDTree.GetWinNum() . " wincmd w")
+        call nerdtree#exec(s:NERDTree.GetWinNum() . ' wincmd w', 1)
-        close
+        call nerdtree#exec('close', 0)
         if l:useWinId
-            call nerdtree#exec("call win_gotoid(" . l:activeBufOrWin . ")")
+            call nerdtree#exec('call win_gotoid(' . l:activeBufOrWin . ')', 0)
         else
-            call nerdtree#exec(bufwinnr(l:activeBufOrWin) . " wincmd w")
+            call nerdtree#exec(bufwinnr(l:activeBufOrWin) . ' wincmd w', 0)
         endif
     else
         close
@@ -75,7 +75,7 @@ endfunction
 "Places the cursor at the top of the bookmarks table
 function! s:NERDTree.CursorToBookmarkTable()
     if !b:NERDTree.ui.getShowBookmarks()
-        throw "NERDTree.IllegalOperationError: cant find bookmark table, bookmarks arent active"
+        throw 'NERDTree.IllegalOperationError: cant find bookmark table, bookmarks arent active'
     endif
 
     if g:NERDTreeMinimalUI
@@ -88,7 +88,7 @@ function! s:NERDTree.CursorToBookmarkTable()
     while getline(line) !~# '^>-\+Bookmarks-\+$'
         let line = line + 1
         if line >= rootNodeLine
-            throw "NERDTree.BookmarkTableNotFoundError: didnt find the bookmarks table"
+            throw 'NERDTree.BookmarkTableNotFoundError: didnt find the bookmarks table'
         endif
     endwhile
     call cursor(line, 2)
@@ -98,19 +98,19 @@ endfunction
 "Places the cursor in the nerd tree window
 function! s:NERDTree.CursorToTreeWin()
     call g:NERDTree.MustBeOpen()
-    call nerdtree#exec(g:NERDTree.GetWinNum() . "wincmd w")
+    call nerdtree#exec(g:NERDTree.GetWinNum() . 'wincmd w', 1)
 endfunction
 
 " Function: s:NERDTree.ExistsForBuffer()   {{{1
 " Returns 1 if a nerd tree root exists in the current buffer
 function! s:NERDTree.ExistsForBuf()
-    return exists("b:NERDTree")
+    return exists('b:NERDTree')
 endfunction
 
 " Function: s:NERDTree.ExistsForTab()   {{{1
 " Returns 1 if a nerd tree root exists in the current tab
 function! s:NERDTree.ExistsForTab()
-    if !exists("t:NERDTreeBufName")
+    if !exists('t:NERDTreeBufName')
         return
     end
 
@@ -133,7 +133,7 @@ function! s:NERDTree.ForCurrentTab()
     endif
 
     let bufnr = bufnr(t:NERDTreeBufName)
-    return getbufvar(bufnr, "NERDTree")
+    return getbufvar(bufnr, 'NERDTree')
 endfunction
 
 "FUNCTION: s:NERDTree.getRoot() {{{1
@@ -144,32 +144,39 @@ endfunction
 "FUNCTION: s:NERDTree.GetWinNum() {{{1
 "gets the nerd tree window number for this tab
 function! s:NERDTree.GetWinNum()
-    if exists("t:NERDTreeBufName")
+    if exists('t:NERDTreeBufName')
         return bufwinnr(t:NERDTreeBufName)
     endif
 
+    " If WindowTree, there is no t:NERDTreeBufName variable. Search all windows.
+    for w in range(1,winnr('$'))
+        if bufname(winbufnr(w)) =~# '^' . g:NERDTreeCreator.BufNamePrefix() . '\d\+$'
+            return w
+        endif
+    endfor
+
     return -1
 endfunction
 
 "FUNCTION: s:NERDTree.IsOpen() {{{1
 function! s:NERDTree.IsOpen()
-    return s:NERDTree.GetWinNum() != -1 || bufname('%') =~# '^' . g:NERDTreeCreator.BufNamePrefix() . '\d\+$'
+    return s:NERDTree.GetWinNum() !=# -1
 endfunction
 
 "FUNCTION: s:NERDTree.isTabTree() {{{1
 function! s:NERDTree.isTabTree()
-    return self._type == "tab"
+    return self._type ==# 'tab'
 endfunction
 
 "FUNCTION: s:NERDTree.isWinTree() {{{1
 function! s:NERDTree.isWinTree()
-    return self._type == "window"
+    return self._type ==# 'window'
 endfunction
 
 "FUNCTION: s:NERDTree.MustBeOpen() {{{1
 function! s:NERDTree.MustBeOpen()
     if !s:NERDTree.IsOpen()
-        throw "NERDTree.TreeNotOpen"
+        throw 'NERDTree.TreeNotOpen'
     endif
 endfunction
 

lib/nerdtree/notifier.vim

@@ -14,13 +14,14 @@ endfunction
 function! s:Notifier.NotifyListeners(event, path, nerdtree, params)
     let event = g:NERDTreeEvent.New(a:nerdtree, a:path, a:event, a:params)
 
-    for listener in s:Notifier.GetListenersForEvent(a:event)
+    for Listener in s:Notifier.GetListenersForEvent(a:event)
-        call {listener}(event)
+    	let Callback = type(Listener) == type(function('tr')) ? Listener : function(Listener)
+        call Callback(event)
     endfor
 endfunction
 
 function! s:Notifier.GetListenersMap()
-    if !exists("s:refreshListenersMap")
+    if !exists('s:refreshListenersMap')
         let s:refreshListenersMap = {}
     endif
     return s:refreshListenersMap

lib/nerdtree/opener.vim

@@ -1,7 +1,7 @@
 " ============================================================================
 " CLASS: Opener
 "
-" The Opener class defines an API for "opening" operations.
+" The Opener class defines an API for 'opening' operations.
 " ============================================================================
 
 
@@ -45,7 +45,7 @@ function! s:Opener._checkToCloseTree(newtab)
         return
     endif
 
-    if (a:newtab && self._where == 't') || !a:newtab
+    if (a:newtab && self._where ==# 't') || !a:newtab
         call g:NERDTree.CloseIfQuitOnOpen()
     endif
 endfunction
@@ -54,9 +54,9 @@ endfunction
 " find the window number of the first normal window
 function! s:Opener._firstUsableWindow()
     let i = 1
-    while i <= winnr("$")
+    while i <= winnr('$')
         let bnum = winbufnr(i)
-        if bnum != -1 && getbufvar(bnum, '&buftype') ==# ''
+        if bnum !=# -1 && getbufvar(bnum, '&buftype') ==# ''
                     \ && !getwinvar(i, '&previewwindow')
                     \ && (!getbufvar(bnum, '&modified') || &hidden)
             return i
@@ -70,23 +70,23 @@ endfunction
 " FUNCTION: Opener._gotoTargetWin() {{{1
 function! s:Opener._gotoTargetWin()
     if b:NERDTree.isWinTree()
-        if self._where == 'v'
+        if self._where ==# 'v'
-            vsplit
+            call self._newVSplit()
-        elseif self._where == 'h'
+        elseif self._where ==# 'h'
-            split
+            call self._newSplit()
-        elseif self._where == 't'
+        elseif self._where ==# 't'
             tabnew
         endif
     else
         call self._checkToCloseTree(1)
 
-        if self._where == 'v'
+        if self._where ==# 'v'
             call self._newVSplit()
-        elseif self._where == 'h'
+        elseif self._where ==# 'h'
             call self._newSplit()
-        elseif self._where == 't'
+        elseif self._where ==# 't'
             tabnew
-        elseif self._where == 'p'
+        elseif self._where ==# 'p'
             call self._previousWindow()
         endif
 
@@ -102,15 +102,15 @@ endfunction
 " winnumber: the number of the window in question
 function! s:Opener._isWindowUsable(winnumber)
     "gotta split if theres only one window (i.e. the NERD tree)
-    if winnr("$") ==# 1
+    if winnr('$') ==# 1
         return 0
     endif
 
     let oldwinnr = winnr()
-    call nerdtree#exec(a:winnumber . "wincmd p")
+    call nerdtree#exec(a:winnumber . 'wincmd p', 1)
-    let specialWindow = getbufvar("%", '&buftype') != '' || getwinvar('%', '&previewwindow')
+    let specialWindow = getbufvar('%', '&buftype') !=# '' || getwinvar('%', '&previewwindow')
     let modified = &modified
-    call nerdtree#exec(oldwinnr . "wincmd p")
+    call nerdtree#exec(oldwinnr . 'wincmd p', 1)
 
     "if its a special window e.g. quickfix or another explorer plugin then we
     "have to split
@@ -131,9 +131,9 @@ endfunction
 " a:path: the path object that is to be opened
 " a:opts: a dictionary containing the following optional keys...
 "   'where': specifies whether the node should be opened in new split, in
-"            a new tab or, in the last window; takes values "v", "h", or "t"
+"            a new tab or, in the last window; takes values 'v', 'h', or 't'
 "   'reuse': if file is already shown in a window, jump there; takes values
-"            "all", "currenttab", or empty
+"            'all', 'currenttab', or empty
 "   'keepopen': boolean (0 or 1); if true, the tree window will not be closed
 "   'stay': boolean (0 or 1); if true, remain in tree window after opening
 function! s:Opener.New(path, opts)
@@ -153,61 +153,33 @@ endfunction
 
 " FUNCTION: Opener._newSplit() {{{1
 function! s:Opener._newSplit()
-    " Save the user's settings for splitbelow and splitright
+    let onlyOneWin = (winnr('$') ==# 1)
-    let savesplitbelow=&splitbelow
+    let savesplitright = &splitright
-    let savesplitright=&splitright
-
-    " 'there' will be set to a command to move from the split window
-    " back to the explorer window
-    "
-    " 'back' will be set to a command to move from the explorer window
-    " back to the newly split window
-    "
-    " 'right' and 'below' will be set to the settings needed for
-    " splitbelow and splitright IF the explorer is the only window.
-    "
-    let there= g:NERDTreeWinPos ==# "left" ? "wincmd h" : "wincmd l"
-    let back = g:NERDTreeWinPos ==# "left" ? "wincmd l" : "wincmd h"
-    let right= g:NERDTreeWinPos ==# "left"
-    let below=0
-
-    " Attempt to go to adjacent window
-    call nerdtree#exec(back)
-
-    let onlyOneWin = (winnr("$") ==# 1)
-
-    " If no adjacent window, set splitright and splitbelow appropriately
     if onlyOneWin
-        let &splitright=right
+        let &splitright = (g:NERDTreeWinPos ==# 'left')
-        let &splitbelow=below
-    else
-        " found adjacent window - invert split direction
-        let &splitright=!right
-        let &splitbelow=!below
     endif
-
+    " If only one window (ie. NERDTree), split vertically instead.
-    let splitMode = onlyOneWin ? "vertical" : ""
+    let splitMode = onlyOneWin ? 'vertical' : ''
 
     " Open the new window
     try
-        exec(splitMode." sp ")
+        call nerdtree#exec('wincmd p', 1)
+        call nerdtree#exec(splitMode . ' split',1)
     catch /^Vim\%((\a\+)\)\=:E37/
         call g:NERDTree.CursorToTreeWin()
-        throw "NERDTree.FileAlreadyOpenAndModifiedError: ". self._path.str() ." is already open and modified."
+        throw 'NERDTree.FileAlreadyOpenAndModifiedError: '. self._path.str() .' is already open and modified.'
     catch /^Vim\%((\a\+)\)\=:/
         "do nothing
     endtry
 
     "resize the tree window if no other window was open before
     if onlyOneWin
-        let size = exists("b:NERDTreeOldWindowSize") ? b:NERDTreeOldWindowSize : g:NERDTreeWinSize
+        let size = exists('b:NERDTreeOldWindowSize') ? b:NERDTreeOldWindowSize : g:NERDTreeWinSize
-        call nerdtree#exec(there)
+        call nerdtree#exec('wincmd p', 1)
-        exec("silent ". splitMode ." resize ". size)
+        call nerdtree#exec('silent '. splitMode .' resize '. size, 1)
-        call nerdtree#exec('wincmd p')
+        call nerdtree#exec('wincmd p', 0)
     endif
 
-    " Restore splitmode settings
-    let &splitbelow=savesplitbelow
     let &splitright=savesplitright
 endfunction
 
@@ -215,12 +187,15 @@ endfunction
 function! s:Opener._newVSplit()
     let l:winwidth = winwidth('.')
 
-    if winnr('$') == 1
+    let onlyOneWin = (winnr('$') ==# 1)
+    let savesplitright = &splitright
+    if onlyOneWin
+        let &splitright = (g:NERDTreeWinPos ==# 'left')
         let l:winwidth = g:NERDTreeWinSize
     endif
 
-    call nerdtree#exec('wincmd p')
+    call nerdtree#exec('wincmd p', 1)
-    vnew
+    call nerdtree#exec('vnew', 1)
 
     let l:currentWindowNumber = winnr()
 
@@ -228,7 +203,8 @@ function! s:Opener._newVSplit()
     call g:NERDTree.CursorToTreeWin()
     execute 'silent vertical resize ' . l:winwidth
 
-    call nerdtree#exec(l:currentWindowNumber . 'wincmd w')
+    call nerdtree#exec(l:currentWindowNumber . 'wincmd w', 0)
+    let &splitright=savesplitright
 endfunction
 
 " FUNCTION: Opener.open(target) {{{1
@@ -243,7 +219,7 @@ endfunction
 
 " FUNCTION: Opener._openFile() {{{1
 function! s:Opener._openFile()
-    if !self._stay && !and(g:NERDTreeQuitOnOpen,1) && exists("b:NERDTreeZoomed") && b:NERDTreeZoomed
+    if !self._stay && !and(g:NERDTreeQuitOnOpen,1) && exists('b:NERDTreeZoomed') && b:NERDTreeZoomed
         call b:NERDTree.ui.toggleZoom()
     endif
 
@@ -271,7 +247,7 @@ function! s:Opener._openDirectory(node)
     else
         if empty(self._where)
             call b:NERDTree.changeRoot(a:node)
-        elseif self._where == 't'
+        elseif self._where ==# 't'
             call g:NERDTreeCreator.CreateTabTree(a:node.path.str())
         else
             call g:NERDTreeCreator.CreateWindowTree(a:node.path.str())
@@ -285,18 +261,18 @@ endfunction
 
 " FUNCTION: Opener._previousWindow() {{{1
 function! s:Opener._previousWindow()
-    if !self._isWindowUsable(winnr("#")) && self._firstUsableWindow() ==# -1
+    if !self._isWindowUsable(winnr('#')) && self._firstUsableWindow() ==# -1
         call self._newSplit()
     else
         try
-            if !self._isWindowUsable(winnr("#"))
+            if !self._isWindowUsable(winnr('#'))
-                call nerdtree#exec(self._firstUsableWindow() . "wincmd w")
+                call nerdtree#exec(self._firstUsableWindow() . 'wincmd w', 1)
             else
-                call nerdtree#exec('wincmd p')
+                call nerdtree#exec('wincmd p', 1)
             endif
         catch /^Vim\%((\a\+)\)\=:E37/
             call g:NERDTree.CursorToTreeWin()
-            throw "NERDTree.FileAlreadyOpenAndModifiedError: ". self._path.str() ." is already open and modified."
+            throw 'NERDTree.FileAlreadyOpenAndModifiedError: '. self._path.str() .' is already open and modified.'
         catch /^Vim\%((\a\+)\)\=:/
             echo v:exception
         endtry
@@ -305,8 +281,8 @@ endfunction
 
 " FUNCTION: Opener._restoreCursorPos() {{{1
 function! s:Opener._restoreCursorPos()
-    call nerdtree#exec(self._tabnr . 'tabnext')
+    call nerdtree#exec(self._tabnr . 'tabnext', 1)
-    call nerdtree#exec(bufwinnr(self._bufnr) . 'wincmd w')
+    call nerdtree#exec(bufwinnr(self._bufnr) . 'wincmd w', 1)
 endfunction
 
 " FUNCTION: Opener._reuseWindow() {{{1
@@ -320,13 +296,13 @@ function! s:Opener._reuseWindow()
 
     "check the current tab for the window
     let winnr = bufwinnr('^' . self._path.str() . '$')
-    if winnr != -1
+    if winnr !=# -1
-        call nerdtree#exec(winnr . "wincmd w")
+        call nerdtree#exec(winnr . 'wincmd w', 0)
         call self._checkToCloseTree(0)
         return 1
     endif
 
-    if self._reuse == 'currenttab'
+    if self._reuse ==# 'currenttab'
         return 0
     endif
 
@@ -334,9 +310,9 @@ function! s:Opener._reuseWindow()
     let tabnr = self._path.tabnr()
     if tabnr
         call self._checkToCloseTree(1)
-        call nerdtree#exec(tabnr . 'tabnext')
+        call nerdtree#exec(tabnr . 'tabnext', 1)
         let winnr = bufwinnr('^' . self._path.str() . '$')
-        call nerdtree#exec(winnr . "wincmd w")
+        call nerdtree#exec(winnr . 'wincmd w', 0)
         return 1
     endif
 
@@ -345,7 +321,7 @@ endfunction
 
 " FUNCTION: Opener._saveCursorPos() {{{1
 function! s:Opener._saveCursorPos()
-    let self._bufnr = bufnr("")
+    let self._bufnr = bufnr('')
     let self._tabnr = tabpagenr()
 endfunction
 

lib/nerdtree/path.vim

@@ -25,7 +25,7 @@ function! s:Path.AbsolutePathFor(pathStr)
     if l:prependWorkingDir
         let l:result = getcwd()
 
-        if l:result[-1:] == s:Path.Slash()
+        if l:result[-1:] ==# s:Path.Slash()
             let l:result = l:result . a:pathStr
         else
             let l:result = l:result . s:Path.Slash() . a:pathStr
@@ -37,7 +37,7 @@ endfunction
 
 " FUNCTION: Path.bookmarkNames() {{{1
 function! s:Path.bookmarkNames()
-    if !exists("self._bookmarkNames")
+    if !exists('self._bookmarkNames')
         call self.cacheDisplayString()
     endif
     return self._bookmarkNames
@@ -57,7 +57,7 @@ function! s:Path.cacheDisplayString() abort
             call add(self._bookmarkNames, i.name)
         endif
     endfor
-    if !empty(self._bookmarkNames) && g:NERDTreeMarkBookmarks == 1
+    if !empty(self._bookmarkNames) && g:NERDTreeMarkBookmarks ==# 1
         let self.cachedDisplayString = self.addDelimiter(self.cachedDisplayString) . ' {' . join(self._bookmarkNames) . '}'
     endif
 
@@ -87,17 +87,22 @@ function! s:Path.changeToDir()
     endif
 
     try
-        execute "cd " . dir
+        if g:NERDTreeUseTCD && exists(':tcd') ==# 2
-        call nerdtree#echo("CWD is now: " . getcwd())
+            execute 'tcd ' . dir
+            call nerdtree#echo("Tab's CWD is now: " . getcwd())
+        else
+            execute 'cd ' . dir
+            call nerdtree#echo('CWD is now: ' . getcwd())
+        endif
     catch
-        throw "NERDTree.PathChangeError: cannot change CWD to " . dir
+        throw 'NERDTree.PathChangeError: cannot change CWD to ' . dir
     endtry
 endfunction
 
 " FUNCTION: Path.compareTo() {{{1
 "
 " Compares this Path to the given path and returns 0 if they are equal, -1 if
-" this Path is "less than" the given path, or 1 if it is "greater".
+" this Path is 'less than' the given path, or 1 if it is 'greater'.
 "
 " Args:
 " path: the path object to compare this to
@@ -183,7 +188,7 @@ endfunction
 " dest: the location to copy this dir/file to
 function! s:Path.copy(dest)
     if !s:Path.CopyingSupported()
-        throw "NERDTree.CopyingNotSupportedError: Copying is not supported on this OS"
+        throw 'NERDTree.CopyingNotSupportedError: Copying is not supported on this OS'
     endif
 
     call s:Path.createParentDirectories(a:dest)
@@ -194,10 +199,10 @@ function! s:Path.copy(dest)
         let cmd_prefix = (self.isDirectory ? g:NERDTreeCopyDirCmd : g:NERDTreeCopyFileCmd)
     endif
 
-    let cmd = cmd_prefix . " " . escape(self.str(), self._escChars()) . " " . escape(a:dest, self._escChars())
+    let cmd = cmd_prefix . ' ' . escape(self.str(), self._escChars()) . ' ' . escape(a:dest, self._escChars())
     let success = system(cmd)
-    if v:shell_error != 0
+    if v:shell_error !=# 0
-        throw "NERDTree.CopyError: Could not copy ''". self.str() ."'' to: '" . a:dest . "'"
+        throw "NERDTree.CopyError: Could not copy '". self.str() ."' to: '" . a:dest . "'"
     endif
 endfunction
 
@@ -253,7 +258,7 @@ function! s:Path.delete()
         let cmd = g:NERDTreeRemoveDirCmd . self.str({'escape': 1})
         let success = system(cmd)
 
-        if v:shell_error != 0
+        if v:shell_error !=# 0
             throw "NERDTree.PathDeletionError: Could not delete directory: '" . self.str() . "'"
         endif
     else
@@ -264,7 +269,7 @@ function! s:Path.delete()
             let success = delete(self.str())
         endif
 
-        if success != 0
+        if success !=# 0
             throw "NERDTree.PathDeletionError: Could not delete file: '" . self.str() . "'"
         endif
     endif
@@ -281,7 +286,7 @@ endfunction
 " Returns a string that specifies how the path should be represented as a
 " string
 function! s:Path.displayString()
-    if self.cachedDisplayString ==# ""
+    if self.cachedDisplayString ==# ''
         call self.cacheDisplayString()
     endif
 
@@ -290,7 +295,7 @@ endfunction
 
 " FUNCTION: Path.edit() {{{1
 function! s:Path.edit()
-    exec "edit " . self.str({'format': 'Edit'})
+    exec 'edit ' . self.str({'format': 'Edit'})
 endfunction
 
 " FUNCTION: Path.extractDriveLetter(fullpath) {{{1
@@ -298,10 +303,10 @@ endfunction
 " If running windows, cache the drive letter for this path
 function! s:Path.extractDriveLetter(fullpath)
     if nerdtree#runningWindows()
-        if a:fullpath =~ '^\(\\\\\|\/\/\)'
+        if a:fullpath =~# '^\(\\\\\|\/\/\)'
             "For network shares, the 'drive' consists of the first two parts of the path, i.e. \\boxname\share
             let self.drive = substitute(a:fullpath, '^\(\(\\\\\|\/\/\)[^\\\/]*\(\\\|\/\)[^\\\/]*\).*', '\1', '')
-            let self.drive = substitute(self.drive, '/', '\', "g")
+            let self.drive = substitute(self.drive, '/', '\', 'g')
         else
             let self.drive = substitute(a:fullpath, '\(^[a-zA-Z]:\).*', '\1', '')
         endif
@@ -380,7 +385,8 @@ endfunction
 function! s:Path.getSortOrderIndex()
     let i = 0
     while i < len(g:NERDTreeSortOrder)
-        if  self.getLastPathComponent(1) =~# g:NERDTreeSortOrder[i]
+        if g:NERDTreeSortOrder[i] !~? '\[\[-\?\(timestamp\|size\|extension\)\]\]' &&
+        \ self.getLastPathComponent(1) =~# g:NERDTreeSortOrder[i]
             return i
         endif
         let i = i + 1
@@ -396,7 +402,7 @@ function! s:Path._splitChunks(path)
     let i = 0
     while i < len(chunks)
         "convert number literals to numbers
-        if match(chunks[i], '^\d\+$') == 0
+        if match(chunks[i], '^\d\+$') ==# 0
             let chunks[i] = str2nr(chunks[i])
         endif
         let i = i + 1
@@ -407,15 +413,26 @@ endfunction
 " FUNCTION: Path.getSortKey() {{{1
 " returns a key used in compare function for sorting
 function! s:Path.getSortKey()
-    let l:ascending = index(g:NERDTreeSortOrder,'[[timestamp]]')
+    if !exists('self._sortKey') || g:NERDTreeSortOrder !=# g:NERDTreeOldSortOrder
-    let l:descending = index(g:NERDTreeSortOrder,'[[-timestamp]]')
+        " Look for file metadata tags: [[timestamp]], [[extension]], [[size]]
-    if !exists("self._sortKey") || g:NERDTreeSortOrder !=# g:NERDTreeOldSortOrder || l:ascending >= 0 || l:descending >= 0
+        let metadata = []
-        let self._sortKey = [self.getSortOrderIndex()]
+        for tag in g:NERDTreeSortOrder
+            if tag =~? '\[\[-\?timestamp\]\]'
+                let metadata += [self.isDirectory ? 0 : getftime(self.str()) * (tag =~# '-' ? -1 : 1)]
+            elseif tag =~? '\[\[-\?size\]\]'
+                let metadata += [self.isDirectory ? 0 : getfsize(self.str()) * (tag =~# '-' ? -1 : 1)]
+            elseif tag =~? '\[\[extension\]\]'
+                let extension = matchstr(self.getLastPathComponent(0), '[^.]\+\.\zs[^.]\+$')
+                let metadata += [self.isDirectory ? '' : (extension ==# '' ? nr2char(str2nr('0x10ffff',16)) : extension)]
+            endif
+        endfor
 
-        if l:descending >= 0
+        if g:NERDTreeSortOrder[0] =~# '\[\[.*\]\]'
-            call insert(self._sortKey, -getftime(self.str()), l:descending == 0 ? 0 : len(self._sortKey))
+            " Apply tags' sorting first if specified first.
-        elseif l:ascending >= 0
+            let self._sortKey = metadata + [self.getSortOrderIndex()]
-            call insert(self._sortKey, getftime(self.str()), l:ascending == 0 ? 0 : len(self._sortKey))
+        else
+            " Otherwise, do regex grouping first.
+            let self._sortKey = [self.getSortOrderIndex()] + metadata
         endif
 
         let path = self.getLastPathComponent(1)
@@ -483,8 +500,9 @@ function! s:Path.ignore(nerdtree)
             endif
         endfor
 
-        for callback in g:NERDTree.PathFilters()
+        for Callback in g:NERDTree.PathFilters()
-            if {callback}({'path': self, 'nerdtree': a:nerdtree})
+            let Callback = type(Callback) ==# type(function('tr')) ? Callback : function(Callback)
+            if Callback({'path': self, 'nerdtree': a:nerdtree})
                 return 1
             endif
         endfor
@@ -506,12 +524,12 @@ endfunction
 " returns true if this path matches the given ignore pattern
 function! s:Path._ignorePatternMatches(pattern)
     let pat = a:pattern
-    if strpart(pat,len(pat)-7) == '[[dir]]'
+    if strpart(pat,len(pat)-7) ==# '[[dir]]'
         if !self.isDirectory
             return 0
         endif
         let pat = strpart(pat,0, len(pat)-7)
-    elseif strpart(pat,len(pat)-8) == '[[file]]'
+    elseif strpart(pat,len(pat)-8) ==# '[[file]]'
         if self.isDirectory
             return 0
         endif
@@ -532,19 +550,19 @@ function! s:Path.isAncestor(path)
 
     let this = self.str()
     let that = a:path.str()
-    return stridx(that, this) == 0
+    return stridx(that, this) ==# 0
 endfunction
 
 " FUNCTION: Path.isUnder(path) {{{1
 " return 1 if this path is somewhere under the given path in the filesystem.
 function! s:Path.isUnder(path)
-    if a:path.isDirectory == 0
+    if a:path.isDirectory ==# 0
         return 0
     endif
 
     let this = self.str()
     let that = a:path.str()
-    return stridx(this, that . s:Path.Slash()) == 0
+    return stridx(this, that . s:Path.Slash()) ==# 0
 endfunction
 
 " FUNCTION: Path.JoinPathStrings(...) {{{1
@@ -619,8 +637,8 @@ function! s:Path.readInfoFromDisk(fullpath)
 
     let fullpath = s:Path.WinToUnixPath(a:fullpath)
 
-    if getftype(fullpath) ==# "fifo"
+    if getftype(fullpath) ==# 'fifo'
-        throw "NERDTree.InvalidFiletypeError: Cant handle FIFO files: " . a:fullpath
+        throw 'NERDTree.InvalidFiletypeError: Cant handle FIFO files: ' . a:fullpath
     endif
 
     let self.pathSegments = filter(split(fullpath, '/'), '!empty(v:val)')
@@ -632,7 +650,7 @@ function! s:Path.readInfoFromDisk(fullpath)
         let self.isDirectory = 0
         let self.isReadOnly = filewritable(a:fullpath) ==# 0
     else
-        throw "NERDTree.InvalidArgumentsError: Invalid path = " . a:fullpath
+        throw 'NERDTree.InvalidArgumentsError: Invalid path = ' . a:fullpath
     endif
 
     let self.isExecutable = 0
@@ -647,7 +665,7 @@ function! s:Path.readInfoFromDisk(fullpath)
     let hardPath = s:Path.Resolve(self.strTrunk()) . '/' . lastPathComponent
 
     "if  the last part of the path is a symlink then flag it as such
-    let self.isSymLink = (s:Path.Resolve(hardPath) != hardPath)
+    let self.isSymLink = (s:Path.Resolve(hardPath) !=# hardPath)
     if self.isSymLink
         let self.symLinkDest = s:Path.Resolve(fullpath)
 
@@ -682,13 +700,13 @@ endfunction
 " Renames this node on the filesystem
 function! s:Path.rename(newPath)
     if a:newPath ==# ''
-        throw "NERDTree.InvalidArgumentsError: Invalid newPath for renaming = ". a:newPath
+        throw 'NERDTree.InvalidArgumentsError: Invalid newPath for renaming = '. a:newPath
     endif
 
     call s:Path.createParentDirectories(a:newPath)
 
     let success =  rename(self.str(), a:newPath)
-    if success != 0
+    if success !=# 0
         throw "NERDTree.PathRenameError: Could not rename: '" . self.str() . "'" . 'to:' . a:newPath
     endif
     call self.readInfoFromDisk(a:newPath)
@@ -724,7 +742,7 @@ endfunction
 " value associated with 'truncateTo'. A '<' is prepended.
 function! s:Path.str(...)
     let options = a:0 ? a:1 : {}
-    let toReturn = ""
+    let toReturn = ''
 
     if has_key(options, 'format')
         let format = options['format']
@@ -761,7 +779,7 @@ endfunction
 " FUNCTION: Path._strForUI() {{{1
 function! s:Path._strForUI()
     let toReturn = '/' . join(self.pathSegments, '/')
-    if self.isDirectory && toReturn != '/'
+    if self.isDirectory && toReturn !=# '/'
         let toReturn  = toReturn . '/'
     endif
     return toReturn
@@ -784,7 +802,7 @@ function! s:Path._strForEdit()
 
     " On Windows, the drive letter may be removed by "fnamemodify()".  Add it
     " back, if necessary.
-    if nerdtree#runningWindows() && l:result[0] == s:Path.Slash()
+    if nerdtree#runningWindows() && l:result[0] ==# s:Path.Slash()
         let l:result = self.drive . l:result
     endif
 
@@ -865,13 +883,13 @@ function! s:Path.WinToUnixPath(pathstr)
     let toReturn = a:pathstr
 
     "remove the x:\ of the front
-    let toReturn = substitute(toReturn, '^.*:\(\\\|/\)\?', '/', "")
+    let toReturn = substitute(toReturn, '^.*:\(\\\|/\)\?', '/', '')
 
     "remove the \\ network share from the front
-    let toReturn = substitute(toReturn, '^\(\\\\\|\/\/\)[^\\\/]*\(\\\|\/\)[^\\\/]*\(\\\|\/\)\?', '/', "")
+    let toReturn = substitute(toReturn, '^\(\\\\\|\/\/\)[^\\\/]*\(\\\|\/\)[^\\\/]*\(\\\|\/\)\?', '/', '')
 
     "convert all \ chars to /
-    let toReturn = substitute(toReturn, '\', '/', "g")
+    let toReturn = substitute(toReturn, '\', '/', 'g')
 
     return toReturn
 endfunction

lib/nerdtree/tree_dir_node.vim

@@ -14,7 +14,7 @@ let g:NERDTreeDirNode = s:TreeDirNode
 " Class method that returns the highest cached ancestor of the current root.
 function! s:TreeDirNode.AbsoluteTreeRoot()
     let currentNode = b:NERDTree.root
-    while currentNode.parent != {}
+    while currentNode.parent !=# {}
         let currentNode = currentNode.parent
     endwhile
     return currentNode
@@ -100,20 +100,15 @@ function! s:TreeDirNode.displayString()
     let l:cascade = self.getCascade()
     for l:dirNode in l:cascade
         let l:next = l:dirNode.path.displayString()
-        let l:label .= l:label == '' ? l:next : substitute(l:next,'^.','','')
+        let l:label .= l:label ==# '' ? l:next : substitute(l:next,'^.','','')
     endfor
 
     " Select the appropriate open/closed status indicator symbol.
-    if l:cascade[-1].isOpen
+    let l:symbol = (l:cascade[-1].isOpen ? g:NERDTreeDirArrowCollapsible : g:NERDTreeDirArrowExpandable )
-        let l:symbol = g:NERDTreeDirArrowCollapsible
+    let l:symbol .= (g:NERDTreeDirArrowExpandable ==# '' ? '' : ' ')
-    else
-        let l:symbol = g:NERDTreeDirArrowExpandable
-    endif
-
     let l:flags = l:cascade[-1].path.flagSet.renderToString()
 
-    let l:result = l:symbol . ' ' . l:flags . l:label
+    return l:symbol . l:flags . l:label
-    return l:result
 endfunction
 
 " FUNCTION: TreeDirNode.findNode(path) {{{1
@@ -133,7 +128,7 @@ function! s:TreeDirNode.findNode(path)
     if self.path.isDirectory
         for i in self.children
             let retVal = i.findNode(a:path)
-            if retVal != {}
+            if retVal !=# {}
                 return retVal
             endif
         endfor
@@ -169,7 +164,7 @@ function! s:TreeDirNode.getCascadeRoot()
 
     while !empty(l:parent) && !l:parent.isRoot()
 
-        if index(l:parent.getCascade(), self) == -1
+        if index(l:parent.getCascade(), self) ==# -1
             break
         endif
 
@@ -218,7 +213,7 @@ endfunction
 function! s:TreeDirNode.getChildByIndex(indx, visible)
     let array_to_search = a:visible? self.getVisibleChildren() : self.children
     if a:indx > len(array_to_search)
-        throw "NERDTree.InvalidArgumentsError: Index is out of bounds."
+        throw 'NERDTree.InvalidArgumentsError: Index is out of bounds.'
     endif
     return array_to_search[a:indx]
 endfunction
@@ -255,10 +250,10 @@ function! s:TreeDirNode.getChildIndex(path)
 endfunction
 
 " FUNCTION: TreeDirNode.getDirChildren() {{{1
-" Return a list of all child nodes from "self.children" that are of type
+" Return a list of all child nodes from 'self.children' that are of type
 " TreeDirNode. This function supports http://github.com/scrooloose/nerdtree-project-plugin.git.
 function! s:TreeDirNode.getDirChildren()
-    return filter(copy(self.children), 'v:val.path.isDirectory == 1')
+    return filter(copy(self.children), 'v:val.path.isDirectory ==# 1')
 endfunction
 
 " FUNCTION: TreeDirNode._glob(pattern, all) {{{1
@@ -267,7 +262,7 @@ endfunction
 "
 " Args:
 " pattern: (string) the glob pattern to apply
-" all: (0 or 1) if 1, include "." and ".." if they match "pattern"; if 0,
+" all: (0 or 1) if 1, include '.' and '..' if they match 'pattern'; if 0,
 "      always exclude them
 "
 " Note: If the pathnames in the result list are below the working directory,
@@ -276,28 +271,28 @@ endfunction
 " relative paths.
 function! s:TreeDirNode._glob(pattern, all)
 
-    " Construct a path specification such that "globpath()" will return
+    " Construct a path specification such that globpath() will return
     " relative pathnames, if possible.
-    if self.path.str() == getcwd()
+    if self.path.str() ==# getcwd()
         let l:pathSpec = ','
     else
         let l:pathSpec = escape(fnamemodify(self.path.str({'format': 'Glob'}), ':.'), ',')
 
-        " On Windows, the drive letter may be removed by "fnamemodify()".
+        " On Windows, the drive letter may be removed by fnamemodify().
-        if nerdtree#runningWindows() && l:pathSpec[0] == g:NERDTreePath.Slash()
+        if nerdtree#runningWindows() && l:pathSpec[0] ==# g:NERDTreePath.Slash()
             let l:pathSpec = self.path.drive . l:pathSpec
         endif
     endif
 
     let l:globList = []
 
-    " See ":h version7.txt" and ":h version8.txt" for details on the
+    " See ':h version7.txt' and ':h version8.txt' for details on the
-    " development of the "glob()" and "globpath()" functions.
+    " development of the glob() and globpath() functions.
-    if v:version > 704 || (v:version == 704 && has('patch654'))
+    if v:version > 704 || (v:version ==# 704 && has('patch654'))
         let l:globList = globpath(l:pathSpec, a:pattern, !g:NERDTreeRespectWildIgnore, 1, 0)
-    elseif v:version == 704 && has('patch279')
+    elseif v:version ==# 704 && has('patch279')
         let l:globList = globpath(l:pathSpec, a:pattern, !g:NERDTreeRespectWildIgnore, 1)
-    elseif v:version > 702 || (v:version == 702 && has('patch051'))
+    elseif v:version > 702 || (v:version ==# 702 && has('patch051'))
         let l:globString = globpath(l:pathSpec, a:pattern, !g:NERDTreeRespectWildIgnore)
         let l:globList = split(l:globString, "\n")
     else
@@ -305,7 +300,7 @@ function! s:TreeDirNode._glob(pattern, all)
         let l:globList = split(l:globString, "\n")
     endif
 
-    " If "a:all" is false, filter "." and ".." from the output.
+    " If a:all is false, filter '.' and '..' from the output.
     if !a:all
         let l:toRemove = []
 
@@ -315,13 +310,13 @@ function! s:TreeDirNode._glob(pattern, all)
             " If l:file has a trailing slash, then its :tail will be ''. Use
             " :h to drop the slash and the empty string after it; then use :t
             " to get the directory name.
-            if l:tail == ''
+            if l:tail ==# ''
                 let l:tail = fnamemodify(l:file, ':h:t')
             endif
 
-            if l:tail == '.' || l:tail == '..'
+            if l:tail ==# '.' || l:tail ==# '..'
                 call add(l:toRemove, l:file)
-                if len(l:toRemove) == 2
+                if len(l:toRemove) ==# 2
                     break
                 endif
             endif
@@ -341,7 +336,7 @@ endfunction
 unlet s:TreeDirNode.GetSelected
 function! s:TreeDirNode.GetSelected()
     let currentDir = g:NERDTreeFileNode.GetSelected()
-    if currentDir != {} && !currentDir.isRoot()
+    if currentDir !=# {} && !currentDir.isRoot()
         if currentDir.path.isDirectory ==# 0
             let currentDir = currentDir.parent
         endif
@@ -373,7 +368,7 @@ endfunction
 " FUNCTION: TreeDirNode.hasVisibleChildren() {{{1
 " returns 1 if this node has any childre, 0 otherwise..
 function! s:TreeDirNode.hasVisibleChildren()
-    return self.getVisibleChildCount() != 0
+    return self.getVisibleChildCount() !=# 0
 endfunction
 
 " FUNCTION: TreeDirNode.isCascadable() {{{1
@@ -383,7 +378,7 @@ endfunction
 "  2. If the parent is a symlink or is bookmarked, you end up with unparsable
 "     text, and NERDTree cannot get the path of any child node.
 function! s:TreeDirNode.isCascadable()
-    if g:NERDTreeCascadeSingleChildDir == 0
+    if g:NERDTreeCascadeSingleChildDir ==# 0
         return 0
     endif
 
@@ -398,14 +393,14 @@ function! s:TreeDirNode.isCascadable()
     endfor
 
     let c = self.getVisibleChildren()
-    return len(c) == 1 && c[0].path.isDirectory
+    return len(c) ==# 1 && c[0].path.isDirectory
 endfunction
 
 " FUNCTION: TreeDirNode._initChildren() {{{1
 " Removes all childen from this node and re-reads them
 "
 " Args:
-" silent: 1 if the function should not echo any "please wait" messages for
+" silent: 1 if the function should not echo any 'please wait' messages for
 " large directories
 "
 " Return: the number of child nodes read
@@ -416,7 +411,7 @@ function! s:TreeDirNode._initChildren(silent)
     let files = self._glob('*', 1) + self._glob('.*', 0)
 
     if !a:silent && len(files) > g:NERDTreeNotificationThreshold
-        call nerdtree#echo("Please wait, caching a large dir ...")
+        call nerdtree#echo('Please wait, caching a large dir ...')
     endif
 
     let invalidFilesFound = 0
@@ -432,10 +427,10 @@ function! s:TreeDirNode._initChildren(silent)
 
     call self.sortChildren()
 
-    call nerdtree#echo("")
+    call nerdtree#echo('')
 
     if invalidFilesFound
-        call nerdtree#echoWarning(invalidFilesFound . " file(s) could not be loaded into the NERD tree")
+        call nerdtree#echoWarning(invalidFilesFound . ' file(s) could not be loaded into the NERD tree')
     endif
     return self.getChildCount()
 endfunction
@@ -447,8 +442,8 @@ endfunction
 " path: dir that the node represents
 " nerdtree: the tree the node belongs to
 function! s:TreeDirNode.New(path, nerdtree)
-    if a:path.isDirectory != 1
+    if a:path.isDirectory !=# 1
-        throw "NERDTree.InvalidArgumentsError: A TreeDirNode object must be instantiated with a directory Path object."
+        throw 'NERDTree.InvalidArgumentsError: A TreeDirNode object must be instantiated with a directory Path object.'
     endif
 
     let newTreeNode = copy(self)
@@ -510,7 +505,7 @@ function! s:TreeDirNode.openAlong(...)
     while node.path.isDirectory
         call node.open(opts)
         let level += 1
-        if node.getVisibleChildCount() == 1
+        if node.getVisibleChildCount() ==# 1
             let node = node.getChildByIndex(0, 1)
         else
             break
@@ -523,7 +518,8 @@ endfunction
 " Open an explorer window for this node in the previous window. The explorer
 " can be a NERDTree window or a netrw window.
 function! s:TreeDirNode.openExplorer()
-    call self.open({'where': 'p'})
+    execute 'wincmd p'
+    execute 'edit '.self.path.str({'format':'Edit'})
 endfunction
 
 " FUNCTION: TreeDirNode.openInNewTab(options) {{{1
@@ -566,7 +562,7 @@ function! s:TreeDirNode.refresh()
                 "create a new path and see if it exists in this nodes children
                 let path = g:NERDTreePath.New(i)
                 let newNode = self.getChild(path)
-                if newNode != {}
+                if newNode !=# {}
                     call newNode.refresh()
                     call add(newChildNodes, newNode)
 
@@ -586,7 +582,7 @@ function! s:TreeDirNode.refresh()
         call self.sortChildren()
 
         if invalidFilesFound
-            call nerdtree#echoWarning("some files could not be loaded into the NERD tree")
+            call nerdtree#echoWarning('some files could not be loaded into the NERD tree')
         endif
     endif
 endfunction
@@ -613,7 +609,7 @@ function! s:TreeDirNode.reveal(path, ...)
     let opts = a:0 ? a:1 : {}
 
     if !a:path.isUnder(self.path)
-        throw "NERDTree.InvalidArgumentsError: " . a:path.str() . " should be under " . self.path.str()
+        throw 'NERDTree.InvalidArgumentsError: ' . a:path.str() . ' should be under ' . self.path.str()
     endif
 
     call self.open()
@@ -621,11 +617,11 @@ function! s:TreeDirNode.reveal(path, ...)
     if self.path.equals(a:path.getParent())
         let n = self.findNode(a:path)
         " We may be looking for a newly-saved file that isn't in the tree yet.
-        if n == {}
+        if n ==# {}
             call self.refresh()
             let n = self.findNode(a:path)
         endif
-        if has_key(opts, "open")
+        if has_key(opts, 'open')
             call n.open()
         endif
         return n
@@ -641,8 +637,8 @@ function! s:TreeDirNode.reveal(path, ...)
 endfunction
 
 " FUNCTION: TreeDirNode.removeChild(treenode) {{{1
-" Remove the given treenode from "self.children".
+" Remove the given treenode from self.children.
-" Throws "NERDTree.ChildNotFoundError" if the node is not found.
+" Throws NERDTree.ChildNotFoundError if the node is not found.
 "
 " Args:
 " treenode: the node object to remove
@@ -654,16 +650,16 @@ function! s:TreeDirNode.removeChild(treenode)
         endif
     endfor
 
-    throw "NERDTree.ChildNotFoundError: child node was not found"
+    throw 'NERDTree.ChildNotFoundError: child node was not found'
 endfunction
 
 " FUNCTION: TreeDirNode.sortChildren() {{{1
-" Sort "self.children" by alphabetical order and directory priority.
+" Sort self.children by alphabetical order and directory priority.
 function! s:TreeDirNode.sortChildren()
     if count(g:NERDTreeSortOrder, '*') < 1
         call add(g:NERDTreeSortOrder, '*')
     endif
-    let CompareFunc = function("nerdtree#compareNodesBySortKey")
+    let CompareFunc = function('nerdtree#compareNodesBySortKey')
     call sort(self.children, CompareFunc)
     let g:NERDTreeOldSortOrder = g:NERDTreeSortOrder
 endfunction
@@ -675,7 +671,7 @@ function! s:TreeDirNode.toggleOpen(...)
     if self.isOpen ==# 1
         call self.close()
     else
-        if g:NERDTreeCascadeOpenSingleChildDir == 0
+        if g:NERDTreeCascadeOpenSingleChildDir ==# 0
             call self.open(opts)
         else
             call self.openAlong(opts)

lib/nerdtree/tree_file_node.vim

@@ -1,7 +1,7 @@
 " ============================================================================
 " CLASS: TreeFileNode
 "
-" This class is the parent of the "TreeDirNode" class and is the "Component"
+" This class is the parent of the TreeDirNode class and is the 'Component'
 " part of the composite design pattern between the NERDTree node classes.
 " ============================================================================
 
@@ -42,7 +42,7 @@ function! s:TreeFileNode.cacheParent()
     if empty(self.parent)
         let parentPath = self.path.getParent()
         if parentPath.equals(self.path)
-            throw "NERDTree.CannotCacheParentError: already at root"
+            throw 'NERDTree.CannotCacheParentError: already at root'
         endif
         let self.parent = s:TreeFileNode.New(parentPath, self.getNerdtree())
     endif
@@ -195,7 +195,7 @@ endfunction
 " FUNCTION: TreeFileNode.isRoot() {{{1
 function! s:TreeFileNode.isRoot()
     if !g:NERDTree.ExistsForBuf()
-        throw "NERDTree.NoTreeError: No tree exists for the current buffer"
+        throw 'NERDTree.NoTreeError: No tree exists for the current buffer'
     endif
 
     return self.equals(self.getNerdtree().root)
@@ -246,6 +246,12 @@ function! s:TreeFileNode.openInNewTab(options)
     call self.open(extend({'where': 't'}, a:options))
 endfunction
 
+" FUNCTION: TreeFileNode.openExplorer()
+function! s:TreeFileNode.openExplorer()
+    execute 'wincmd p'
+    execute 'edit '.self.path.getParent().str({'format':'Edit'})
+endfunction
+
 " FUNCTION: TreeFileNode.putCursorHere(isJump, recurseUpward){{{1
 " Places the cursor on the line number this node is rendered on
 "
@@ -259,7 +265,7 @@ function! s:TreeFileNode.putCursorHere(isJump, recurseUpward)
         if a:isJump
             mark '
         endif
-        call cursor(ln, col("."))
+        call cursor(ln, col('.'))
     else
         if a:recurseUpward
             let node = self
@@ -311,17 +317,13 @@ endfunction
 " child nodes are rendered only)
 " for each depth in the tree
 function! s:TreeFileNode._renderToString(depth, drawText)
-    let output = ""
+    let output = ''
     if a:drawText ==# 1
 
         let treeParts = repeat('  ', a:depth - 1)
-
+        let treeParts .= (self.path.isDirectory || g:NERDTreeDirArrowExpandable ==# '' ? '' : '  ')
-        if !self.path.isDirectory
-            let treeParts = treeParts . '  '
-        endif
 
         let line = treeParts . self.displayString()
-
         let output = output . line . "\n"
     endif
 

lib/nerdtree/ui.vim

@@ -27,92 +27,94 @@ function! s:UI._dumpHelp()
         let help  = "\" NERDTree (" . nerdtree#version() . ") quickhelp~\n"
         let help .= "\" ============================\n"
         let help .= "\" File node mappings~\n"
-        let help .= "\" ". (g:NERDTreeMouseMode ==# 3 ? "single" : "double") ."-click,\n"
+        let help .= '" '. (g:NERDTreeMouseMode ==# 3 ? 'single' : 'double') ."-click,\n"
-        let help .= "\" <CR>,\n"
         if self.nerdtree.isTabTree()
-            let help .= "\" ". g:NERDTreeMapActivateNode .": open in prev window\n"
+            let help .= '" '. g:NERDTreeMapActivateNode .": open in prev window\n"
         else
-            let help .= "\" ". g:NERDTreeMapActivateNode .": open in current window\n"
+            let help .= '" '. g:NERDTreeMapActivateNode .": open in current window\n"
         endif
         if self.nerdtree.isTabTree()
-            let help .= "\" ". g:NERDTreeMapPreview .": preview\n"
+            let help .= '" '. g:NERDTreeMapPreview .": preview\n"
         endif
-        let help .= "\" ". g:NERDTreeMapOpenInTab.": open in new tab\n"
+        let help .= '" '. g:NERDTreeMapOpenInTab.": open in new tab\n"
-        let help .= "\" ". g:NERDTreeMapOpenInTabSilent .": open in new tab silently\n"
+        let help .= '" '. g:NERDTreeMapOpenInTabSilent .": open in new tab silently\n"
         let help .= "\" middle-click,\n"
-        let help .= "\" ". g:NERDTreeMapOpenSplit .": open split\n"
+        let help .= '" '. g:NERDTreeMapOpenSplit .": open split\n"
-        let help .= "\" ". g:NERDTreeMapPreviewSplit .": preview split\n"
+        let help .= '" '. g:NERDTreeMapPreviewSplit .": preview split\n"
-        let help .= "\" ". g:NERDTreeMapOpenVSplit .": open vsplit\n"
+        let help .= '" '. g:NERDTreeMapOpenVSplit .": open vsplit\n"
-        let help .= "\" ". g:NERDTreeMapPreviewVSplit .": preview vsplit\n"
+        let help .= '" '. g:NERDTreeMapPreviewVSplit .": preview vsplit\n"
+        let help .= '" '. g:NERDTreeMapCustomOpen .": custom open\n"
 
         let help .= "\"\n\" ----------------------------\n"
         let help .= "\" Directory node mappings~\n"
-        let help .= "\" ". (g:NERDTreeMouseMode ==# 1 ? "double" : "single") ."-click,\n"
+        let help .= '" '. (g:NERDTreeMouseMode ==# 1 ? 'double' : 'single') ."-click,\n"
-        let help .= "\" ". g:NERDTreeMapActivateNode .": open & close node\n"
+        let help .= '" '. g:NERDTreeMapActivateNode .": open & close node\n"
-        let help .= "\" ". g:NERDTreeMapOpenRecursively .": recursively open node\n"
+        let help .= '" '. g:NERDTreeMapOpenRecursively .": recursively open node\n"
-        let help .= "\" ". g:NERDTreeMapOpenInTab.": open in new tab\n"
+        let help .= '" '. g:NERDTreeMapOpenInTab.": open in new tab\n"
-        let help .= "\" ". g:NERDTreeMapOpenInTabSilent .": open in new tab silently\n"
+        let help .= '" '. g:NERDTreeMapOpenInTabSilent .": open in new tab silently\n"
-        let help .= "\" ". g:NERDTreeMapCloseDir .": close parent of node\n"
+        let help .= '" '. g:NERDTreeMapCustomOpen .": custom open\n"
-        let help .= "\" ". g:NERDTreeMapCloseChildren .": close all child nodes of\n"
+        let help .= '" '. g:NERDTreeMapCloseDir .": close parent of node\n"
+        let help .= '" '. g:NERDTreeMapCloseChildren .": close all child nodes of\n"
         let help .= "\"    current node recursively\n"
         let help .= "\" middle-click,\n"
-        let help .= "\" ". g:NERDTreeMapOpenExpl.": explore selected dir\n"
+        let help .= '" '. g:NERDTreeMapOpenExpl.": explore selected dir\n"
 
         let help .= "\"\n\" ----------------------------\n"
         let help .= "\" Bookmark table mappings~\n"
         let help .= "\" double-click,\n"
-        let help .= "\" ". g:NERDTreeMapActivateNode .": open bookmark\n"
+        let help .= '" '. g:NERDTreeMapActivateNode .": open bookmark\n"
-        let help .= "\" ". g:NERDTreeMapPreview .": preview file\n"
+        let help .= '" '. g:NERDTreeMapPreview .": preview file\n"
-        let help .= "\" ". g:NERDTreeMapPreview .": find dir in tree\n"
+        let help .= '" '. g:NERDTreeMapPreview .": find dir in tree\n"
-        let help .= "\" ". g:NERDTreeMapOpenInTab.": open in new tab\n"
+        let help .= '" '. g:NERDTreeMapOpenInTab.": open in new tab\n"
-        let help .= "\" ". g:NERDTreeMapOpenInTabSilent .": open in new tab silently\n"
+        let help .= '" '. g:NERDTreeMapOpenInTabSilent .": open in new tab silently\n"
-        let help .= "\" ". g:NERDTreeMapDeleteBookmark .": delete bookmark\n"
+        let help .= '" '. g:NERDTreeMapCustomOpen .": custom open\n"
+        let help .= '" '. g:NERDTreeMapDeleteBookmark .": delete bookmark\n"
 
         let help .= "\"\n\" ----------------------------\n"
         let help .= "\" Tree navigation mappings~\n"
-        let help .= "\" ". g:NERDTreeMapJumpRoot .": go to root\n"
+        let help .= '" '. g:NERDTreeMapJumpRoot .": go to root\n"
-        let help .= "\" ". g:NERDTreeMapJumpParent .": go to parent\n"
+        let help .= '" '. g:NERDTreeMapJumpParent .": go to parent\n"
-        let help .= "\" ". g:NERDTreeMapJumpFirstChild  .": go to first child\n"
+        let help .= '" '. g:NERDTreeMapJumpFirstChild  .": go to first child\n"
-        let help .= "\" ". g:NERDTreeMapJumpLastChild   .": go to last child\n"
+        let help .= '" '. g:NERDTreeMapJumpLastChild   .": go to last child\n"
-        let help .= "\" ". g:NERDTreeMapJumpNextSibling .": go to next sibling\n"
+        let help .= '" '. g:NERDTreeMapJumpNextSibling .": go to next sibling\n"
-        let help .= "\" ". g:NERDTreeMapJumpPrevSibling .": go to prev sibling\n"
+        let help .= '" '. g:NERDTreeMapJumpPrevSibling .": go to prev sibling\n"
 
         let help .= "\"\n\" ----------------------------\n"
         let help .= "\" Filesystem mappings~\n"
-        let help .= "\" ". g:NERDTreeMapChangeRoot .": change tree root to the\n"
+        let help .= '" '. g:NERDTreeMapChangeRoot .": change tree root to the\n"
         let help .= "\"    selected dir\n"
-        let help .= "\" ". g:NERDTreeMapUpdir .": move tree root up a dir\n"
+        let help .= '" '. g:NERDTreeMapUpdir .": move tree root up a dir\n"
-        let help .= "\" ". g:NERDTreeMapUpdirKeepOpen .": move tree root up a dir\n"
+        let help .= '" '. g:NERDTreeMapUpdirKeepOpen .": move tree root up a dir\n"
         let help .= "\"    but leave old root open\n"
-        let help .= "\" ". g:NERDTreeMapRefresh .": refresh cursor dir\n"
+        let help .= '" '. g:NERDTreeMapRefresh .": refresh cursor dir\n"
-        let help .= "\" ". g:NERDTreeMapRefreshRoot .": refresh current root\n"
+        let help .= '" '. g:NERDTreeMapRefreshRoot .": refresh current root\n"
-        let help .= "\" ". g:NERDTreeMapMenu .": Show menu\n"
+        let help .= '" '. g:NERDTreeMapMenu .": Show menu\n"
-        let help .= "\" ". g:NERDTreeMapChdir .":change the CWD to the\n"
+        let help .= '" '. g:NERDTreeMapChdir .":change the CWD to the\n"
         let help .= "\"    selected dir\n"
-        let help .= "\" ". g:NERDTreeMapCWD .":change tree root to CWD\n"
+        let help .= '" '. g:NERDTreeMapCWD .":change tree root to CWD\n"
 
         let help .= "\"\n\" ----------------------------\n"
         let help .= "\" Tree filtering mappings~\n"
-        let help .= "\" ". g:NERDTreeMapToggleHidden .": hidden files (" . (self.getShowHidden() ? "on" : "off") . ")\n"
+        let help .= '" '. g:NERDTreeMapToggleHidden .': hidden files (' . (self.getShowHidden() ? 'on' : 'off') . ")\n"
-        let help .= "\" ". g:NERDTreeMapToggleFilters .": file filters (" . (self.isIgnoreFilterEnabled() ? "on" : "off") . ")\n"
+        let help .= '" '. g:NERDTreeMapToggleFilters .': file filters (' . (self.isIgnoreFilterEnabled() ? 'on' : 'off') . ")\n"
-        let help .= "\" ". g:NERDTreeMapToggleFiles .": files (" . (self.getShowFiles() ? "on" : "off") . ")\n"
+        let help .= '" '. g:NERDTreeMapToggleFiles .': files (' . (self.getShowFiles() ? 'on' : 'off') . ")\n"
-        let help .= "\" ". g:NERDTreeMapToggleBookmarks .": bookmarks (" . (self.getShowBookmarks() ? "on" : "off") . ")\n"
+        let help .= '" '. g:NERDTreeMapToggleBookmarks .': bookmarks (' . (self.getShowBookmarks() ? 'on' : 'off') . ")\n"
 
         " add quickhelp entries for each custom key map
         let help .= "\"\n\" ----------------------------\n"
         let help .= "\" Custom mappings~\n"
         for i in g:NERDTreeKeyMap.All()
             if !empty(i.quickhelpText)
-                let help .= "\" ". i.key .": ". i.quickhelpText ."\n"
+                let help .= '" '. i.key .': '. i.quickhelpText ."\n"
             endif
         endfor
 
         let help .= "\"\n\" ----------------------------\n"
         let help .= "\" Other mappings~\n"
-        let help .= "\" ". g:NERDTreeMapQuit .": Close the NERDTree window\n"
+        let help .= '" '. g:NERDTreeMapQuit .": Close the NERDTree window\n"
-        let help .= "\" ". g:NERDTreeMapToggleZoom .": Zoom (maximize-minimize)\n"
+        let help .= '" '. g:NERDTreeMapToggleZoom .": Zoom (maximize-minimize)\n"
         let help .= "\"    the NERDTree window\n"
-        let help .= "\" ". g:NERDTreeMapHelp .": toggle help\n"
+        let help .= '" '. g:NERDTreeMapHelp .": toggle help\n"
         let help .= "\"\n\" ----------------------------\n"
         let help .= "\" Bookmark commands~\n"
         let help .= "\" :Bookmark [<name>]\n"
@@ -126,7 +128,7 @@ function! s:UI._dumpHelp()
         let help .= "\" :EditBookmarks\n"
         silent! put =help
     elseif !self.isMinimal()
-        let help ="\" Press ". g:NERDTreeMapHelp ." for help\n"
+        let help ='" Press '. g:NERDTreeMapHelp ." for help\n"
         silent! put =help
     endif
 endfunction
@@ -146,8 +148,8 @@ function! s:UI.New(nerdtree)
 endfunction
 
 " FUNCTION: s:UI.getPath(ln) {{{1
-" Return the "Path" object for the node that is rendered on the given line
+" Return the Path object for the node that is rendered on the given line
-" number.  If the "up a dir" line is selected, return the "Path" object for
+" number.  If the 'up a dir' line is selected, return the Path object for
 " the parent of the root.  Return the empty dictionary if the given line
 " does not reference a tree node.
 function! s:UI.getPath(ln)
@@ -155,7 +157,7 @@ function! s:UI.getPath(ln)
 
     let rootLine = self.getRootLineNum()
 
-    if a:ln == rootLine
+    if a:ln ==# rootLine
         return self.nerdtree.root.path
     endif
 
@@ -172,7 +174,7 @@ function! s:UI.getPath(ln)
     " remove the tree parts and the leading space
     let curFile = self._stripMarkup(line)
 
-    let dir = ""
+    let dir = ''
     let lnum = a:ln
     while lnum > 0
         let lnum = lnum - 1
@@ -180,7 +182,7 @@ function! s:UI.getPath(ln)
         let curLineStripped = self._stripMarkup(curLine)
 
         " have we reached the top of the tree?
-        if lnum == rootLine
+        if lnum ==# rootLine
             let dir = self.nerdtree.root.path.str({'format': 'UI'}) . dir
             break
         endif
@@ -189,7 +191,7 @@ function! s:UI.getPath(ln)
             if lpindent < indent
                 let indent = indent - 1
 
-                let dir = substitute (curLineStripped,'^\\', "", "") . dir
+                let dir = substitute (curLineStripped,'^\\', '', '') . dir
                 continue
             endif
         endif
@@ -217,17 +219,17 @@ function! s:UI.getLineNum(node)
         let l:currentLine = getline(l:lineNumber)
         let l:indentLevel = self._indentLevelFor(l:currentLine)
 
-        if l:indentLevel != l:currentPathComponent
+        if l:indentLevel !=# l:currentPathComponent
             continue
         endif
 
         let l:currentLine = self._stripMarkup(l:currentLine)
         let l:currentPath =  join(l:pathComponents, '/') . '/' . l:currentLine
 
-        " Directories: If the current path "starts with" the full path, then
+        " Directories: If the current path 'starts with' the full path, then
         " either the paths are equal or the line is a cascade containing the
         " full path.
-        if l:fullPath[-1:] == '/' && stridx(l:currentPath, l:fullPath) == 0
+        if l:fullPath[-1:] ==# '/' && stridx(l:currentPath, l:fullPath) ==# 0
             return l:lineNumber
         endif
 
@@ -238,7 +240,7 @@ function! s:UI.getLineNum(node)
 
         " Otherwise: If the full path starts with the current path and the
         " current path is a directory, we add a new path component.
-        if stridx(l:fullPath, l:currentPath) == 0 && l:currentPath[-1:] == '/'
+        if stridx(l:fullPath, l:currentPath) ==# 0 && l:currentPath[-1:] ==# '/'
             let l:currentLine = substitute(l:currentLine, '/\s*$', '', '')
             call add(l:pathComponents, l:currentLine)
             let l:currentPathComponent += 1
@@ -252,7 +254,7 @@ endfunction
 " gets the line number of the root node
 function! s:UI.getRootLineNum()
     let rootLine = 1
-    while getline(rootLine) !~# '^\(/\|<\)'
+    while rootLine <= line('$') && getline(rootLine) !~# '^\(/\|<\)'
         let rootLine = rootLine + 1
     endwhile
     return rootLine
@@ -282,7 +284,11 @@ endfunction
 function! s:UI._indentLevelFor(line)
     " Replace multi-character DirArrows with a single space so the
     " indentation calculation doesn't get messed up.
-    let l:line = substitute(substitute(a:line, '\V'.g:NERDTreeDirArrowExpandable, ' ', ''), '\V'.g:NERDTreeDirArrowCollapsible, ' ', '')
+    if g:NERDTreeDirArrowExpandable ==# ''
+        let l:line = '  '.a:line
+    else
+        let l:line = substitute(substitute(a:line, '\V'.g:NERDTreeDirArrowExpandable, ' ', ''), '\V'.g:NERDTreeDirArrowCollapsible, ' ', '')
+    endif
     let leadChars = match(l:line, '\M\[^ ]')
     return leadChars / s:UI.IndentWid()
 endfunction
@@ -294,7 +300,7 @@ endfunction
 
 " FUNCTION: s:UI.isIgnoreFilterEnabled() {{{1
 function! s:UI.isIgnoreFilterEnabled()
-    return self._ignoreEnabled == 1
+    return self._ignoreEnabled ==# 1
 endfunction
 
 " FUNCTION: s:UI.isMinimal() {{{1
@@ -311,21 +317,21 @@ endfunction
 function! s:UI._renderBookmarks()
 
     if !self.isMinimal()
-        call setline(line(".")+1, ">----------Bookmarks----------")
+        call setline(line('.')+1, '>----------Bookmarks----------')
-        call cursor(line(".")+1, col("."))
+        call cursor(line('.')+1, col('.'))
     endif
 
-    if g:NERDTreeBookmarksSort == 1 || g:NERDTreeBookmarksSort == 2
+    if g:NERDTreeBookmarksSort ==# 1 || g:NERDTreeBookmarksSort ==# 2
         call g:NERDTreeBookmark.SortBookmarksList()
     endif
 
     for i in g:NERDTreeBookmark.Bookmarks()
-        call setline(line(".")+1, i.str())
+        call setline(line('.')+1, i.str())
-        call cursor(line(".")+1, col("."))
+        call cursor(line('.')+1, col('.'))
     endfor
 
-    call setline(line(".")+1, '')
+    call setline(line('.')+1, '')
-    call cursor(line(".")+1, col("."))
+    call cursor(line('.')+1, col('.'))
 endfunction
 
 " FUNCTION: s:UI.restoreScreenState() {{{1
@@ -338,13 +344,13 @@ function! s:UI.restoreScreenState()
     if !has_key(self, '_screenState')
         return
     endif
-    exec("silent vertical resize " . self._screenState['oldWindowSize'])
+    call nerdtree#exec('silent vertical resize ' . self._screenState['oldWindowSize'], 1)
 
     let old_scrolloff=&scrolloff
     let &scrolloff=0
     call cursor(self._screenState['oldTopLine'], 0)
     normal! zt
-    call setpos(".", self._screenState['oldPos'])
+    call setpos('.', self._screenState['oldPos'])
     let &scrolloff=old_scrolloff
 endfunction
 
@@ -353,12 +359,15 @@ endfunction
 " scroll position
 function! s:UI.saveScreenState()
     let win = winnr()
-    call g:NERDTree.CursorToTreeWin()
     let self._screenState = {}
-    let self._screenState['oldPos'] = getpos(".")
+    try
-    let self._screenState['oldTopLine'] = line("w0")
+        call g:NERDTree.CursorToTreeWin()
-    let self._screenState['oldWindowSize']= winwidth("")
+        let self._screenState['oldPos'] = getpos('.')
-    call nerdtree#exec(win . "wincmd w")
+        let self._screenState['oldTopLine'] = line('w0')
+        let self._screenState['oldWindowSize']= winwidth('')
+        call nerdtree#exec(win . 'wincmd w', 1)
+    catch
+    endtry
 endfunction
 
 " FUNCTION: s:UI.setShowHidden(val) {{{1
@@ -382,9 +391,9 @@ function! s:UI.render()
 
     " remember the top line of the buffer and the current line so we can
     " restore the view exactly how it was
-    let curLine = line(".")
+    let curLine = line('.')
-    let curCol = col(".")
+    let curCol = col('.')
-    let topLine = line("w0")
+    let topLine = line('w0')
 
     " delete all lines in the buffer (being careful not to clobber a register)
     silent 1,$delete _
@@ -393,8 +402,8 @@ function! s:UI.render()
 
     " delete the blank line before the help and add one after it
     if !self.isMinimal()
-        call setline(line(".")+1, "")
+        call setline(line('.')+1, '')
-        call cursor(line(".")+1, col("."))
+        call cursor(line('.')+1, col('.'))
     endif
 
     if self.getShowBookmarks()
@@ -403,14 +412,14 @@ function! s:UI.render()
 
     " add the 'up a dir' line
     if !self.isMinimal()
-        call setline(line(".")+1, s:UI.UpDirLine())
+        call setline(line('.')+1, s:UI.UpDirLine())
-        call cursor(line(".")+1, col("."))
+        call cursor(line('.')+1, col('.'))
     endif
 
     " draw the header line
     let header = self.nerdtree.root.path.str({'format': 'UI', 'truncateTo': winwidth(0)})
-    call setline(line(".")+1, header)
+    call setline(line('.')+1, header)
-    call cursor(line(".")+1, col("."))
+    call cursor(line('.')+1, col('.'))
 
     " draw the tree
     silent put =self.nerdtree.root.renderToString()
@@ -438,13 +447,13 @@ function! s:UI.renderViewSavingPosition()
 
     " go up the tree till we find a node that will be visible or till we run
     " out of nodes
-    while currentNode != {} && !currentNode.isVisible() && !currentNode.isRoot()
+    while currentNode !=# {} && !currentNode.isVisible() && !currentNode.isRoot()
         let currentNode = currentNode.parent
     endwhile
 
     call self.render()
 
-    if currentNode != {}
+    if currentNode !=# {}
         call currentNode.putCursorHere(0, 0)
     endif
 endfunction
@@ -502,12 +511,12 @@ endfunction
 " FUNCTION: s:UI.toggleZoom() {{{1
 " zoom (maximize/minimize) the NERDTree window
 function! s:UI.toggleZoom()
-    if exists("b:NERDTreeZoomed") && b:NERDTreeZoomed
+    if exists('b:NERDTreeZoomed') && b:NERDTreeZoomed
-        let size = exists("b:NERDTreeOldWindowSize") ? b:NERDTreeOldWindowSize : g:NERDTreeWinSize
+        let size = exists('b:NERDTreeOldWindowSize') ? b:NERDTreeOldWindowSize : g:NERDTreeWinSize
-        exec "silent vertical resize ". size
+        call nerdtree#exec('silent vertical resize '. size, 1)
         let b:NERDTreeZoomed = 0
     else
-        exec "vertical resize ". get(g:, 'NERDTreeWinSizeMax', '')
+        call nerdtree#exec('vertical resize '. get(g:, 'NERDTreeWinSizeMax', ''), 1)
         let b:NERDTreeZoomed = 1
     endif
 endfunction

nerdtree_plugin/exec_menuitem.vim

@@ -9,7 +9,7 @@
 "              See http://sam.zoy.org/wtfpl/COPYING for more details.
 "
 " ============================================================================
-if exists("g:loaded_nerdtree_exec_menuitem")
+if exists('g:loaded_nerdtree_exec_menuitem')
     finish
 endif
 let g:loaded_nerdtree_exec_menuitem = 1
@@ -32,9 +32,9 @@ function! NERDTreeExecFile()
     let cmd = treenode.path.str({'escape': 1})
     let cmd = input(':!', cmd . ' ')
 
-    if cmd != ''
+    if cmd !=# ''
         exec ':!' . cmd
     else
-        echo "Aborted"
+        echo 'Aborted'
     endif
 endfunction

nerdtree_plugin/fs_menu.vim

@@ -9,13 +9,13 @@
 "              See http://sam.zoy.org/wtfpl/COPYING for more details.
 "
 " ============================================================================
-if exists("g:loaded_nerdtree_fs_menu")
+if exists('g:loaded_nerdtree_fs_menu')
     finish
 endif
 let g:loaded_nerdtree_fs_menu = 1
 
 "Automatically delete the buffer after deleting or renaming a file
-if !exists("g:NERDTreeAutoDeleteBuffer")
+if !exists('g:NERDTreeAutoDeleteBuffer')
     let g:NERDTreeAutoDeleteBuffer = 0
 endif
 
@@ -23,13 +23,13 @@ call NERDTreeAddMenuItem({'text': '(a)dd a childnode', 'shortcut': 'a', 'callbac
 call NERDTreeAddMenuItem({'text': '(m)ove the current node', 'shortcut': 'm', 'callback': 'NERDTreeMoveNode'})
 call NERDTreeAddMenuItem({'text': '(d)elete the current node', 'shortcut': 'd', 'callback': 'NERDTreeDeleteNode'})
 
-if has("gui_mac") || has("gui_macvim") || has("mac")
+if has('gui_mac') || has('gui_macvim') || has('mac')
     call NERDTreeAddMenuItem({'text': '(r)eveal in Finder the current node', 'shortcut': 'r', 'callback': 'NERDTreeRevealInFinder'})
     call NERDTreeAddMenuItem({'text': '(o)pen the current node with system editor', 'shortcut': 'o', 'callback': 'NERDTreeExecuteFile'})
     call NERDTreeAddMenuItem({'text': '(q)uicklook the current node', 'shortcut': 'q', 'callback': 'NERDTreeQuickLook'})
 endif
 
-if executable("xdg-open")
+if executable('xdg-open')
     call NERDTreeAddMenuItem({'text': '(r)eveal the current node in file manager', 'shortcut': 'r', 'callback': 'NERDTreeRevealFileLinux'})
     call NERDTreeAddMenuItem({'text': '(o)pen the current node with system editor', 'shortcut': 'o', 'callback': 'NERDTreeExecuteFileLinux'})
 endif
@@ -37,9 +37,9 @@ endif
 if g:NERDTreePath.CopyingSupported()
     call NERDTreeAddMenuItem({'text': '(c)opy the current node', 'shortcut': 'c', 'callback': 'NERDTreeCopyNode'})
 endif
-call NERDTreeAddMenuItem({'text': (has("clipboard")?'copy (p)ath to clipboard':'print (p)ath to screen'), 'shortcut': 'p', 'callback': 'NERDTreeCopyPath'})
+call NERDTreeAddMenuItem({'text': (has('clipboard')?'copy (p)ath to clipboard':'print (p)ath to screen'), 'shortcut': 'p', 'callback': 'NERDTreeCopyPath'})
 
-if has("unix") || has("osx")
+if has('unix') || has('osx')
     call NERDTreeAddMenuItem({'text': '(l)ist the current node', 'shortcut': 'l', 'callback': 'NERDTreeListNode'})
 else
     call NERDTreeAddMenuItem({'text': '(l)ist the current node', 'shortcut': 'l', 'callback': 'NERDTreeListNodeWin32'})
@@ -51,37 +51,37 @@ endif
 "Args:
 "action: the action that is being performed, e.g. 'delete'
 function! s:inputPrompt(action)
-    if a:action == "add"
+    if a:action ==# 'add'
-        let title = "Add a childnode"
+        let title = 'Add a childnode'
         let info = "Enter the dir/file name to be created. Dirs end with a '/'"
-        let minimal = "Add node:"
+        let minimal = 'Add node:'
 
-    elseif a:action == "copy"
+    elseif a:action ==# 'copy'
-        let title = "Copy the current node"
+        let title = 'Copy the current node'
-        let info = "Enter the new path to copy the node to:"
+        let info = 'Enter the new path to copy the node to:'
-        let minimal = "Copy to:"
+        let minimal = 'Copy to:'
 
-    elseif a:action == "delete"
+    elseif a:action ==# 'delete'
-        let title = "Delete the current node"
+        let title = 'Delete the current node'
-        let info = "Are you sure you wish to delete the node:"
+        let info = 'Are you sure you wish to delete the node:'
-        let minimal = "Delete?"
+        let minimal = 'Delete?'
 
-    elseif a:action == "deleteNonEmpty"
+    elseif a:action ==# 'deleteNonEmpty'
-        let title = "Delete the current node"
+        let title = 'Delete the current node'
         let info =  "STOP! Directory is not empty! To delete, type 'yes'"
-        let minimal = "Delete directory?"
+        let minimal = 'Delete directory?'
 
-    elseif a:action == "move"
+    elseif a:action ==# 'move'
-        let title = "Rename the current node"
+        let title = 'Rename the current node'
-        let info = "Enter the new path for the node:"
+        let info = 'Enter the new path for the node:'
-        let minimal = "Move to:"
+        let minimal = 'Move to:'
     endif
 
     if g:NERDTreeMenuController.isMinimal()
         redraw! " Clear the menu
-        return minimal . " "
+        return minimal . ' '
     else
-        let divider = "=========================================================="
+        let divider = '=========================================================='
         return title . "\n" . divider . "\n" . info . "\n"
     end
 endfunction
@@ -114,14 +114,14 @@ function! s:promptToDelBuffer(bufnum, msg)
             let l:listedBufferCount = 0
         endif
         if l:listedBufferCount > 1
-            exec "tabdo windo if winbufnr(0) == " . a:bufnum . " | exec ':bnext! ' | endif"
+            call nerdtree#exec('tabdo windo if winbufnr(0) ==# ' . a:bufnum . " | exec ':bnext! ' | endif", 1)
         else
-            exec "tabdo windo if winbufnr(0) == " . a:bufnum . " | exec ':enew! ' | endif"
+            call nerdtree#exec('tabdo windo if winbufnr(0) ==# ' . a:bufnum . " | exec ':enew! ' | endif", 1)
         endif
-        exec "tabnext " . s:originalTabNumber
+        call nerdtree#exec('tabnext ' . s:originalTabNumber, 1)
-        exec s:originalWindowNumber . "wincmd w"
+        call nerdtree#exec(s:originalWindowNumber . 'wincmd w', 1)
         " 3. We don't need a previous buffer anymore
-        exec "bwipeout! " . a:bufnum
+        call nerdtree#exec('bwipeout! ' . a:bufnum, 0)
     endif
 endfunction
 
@@ -141,17 +141,17 @@ function! s:renameBuffer(bufNum, newNodeName, isDirectory)
         let editStr = g:NERDTreePath.New(a:newNodeName).str({'format': 'Edit'})
     endif
     " 1. ensure that a new buffer is loaded
-    exec "badd " . quotedFileName
+    call nerdtree#exec('badd ' . quotedFileName, 0)
     " 2. ensure that all windows which display the just deleted filename
     " display a buffer for a new filename.
     let s:originalTabNumber = tabpagenr()
     let s:originalWindowNumber = winnr()
-    exec "tabdo windo if winbufnr(0) == " . a:bufNum . " | exec ':e! " . editStr . "' | endif"
+    call nerdtree#exec('tabdo windo if winbufnr(0) ==# ' . a:bufNum . " | exec ':e! " . editStr . "' | endif", 0)
-    exec "tabnext " . s:originalTabNumber
+    call nerdtree#exec('tabnext ' . s:originalTabNumber, 1)
-    exec s:originalWindowNumber . "wincmd w"
+    call nerdtree#exec(s:originalWindowNumber . 'wincmd w', 1)
     " 3. We don't need a previous buffer anymore
     try
-        exec "confirm bwipeout " . a:bufNum
+        call nerdtree#exec('confirm bwipeout ' . a:bufNum, 0)
     catch
         " This happens when answering Cancel if confirmation is needed. Do nothing.
     endtry
@@ -160,11 +160,11 @@ endfunction
 "FUNCTION: NERDTreeAddNode(){{{1
 function! NERDTreeAddNode()
     let curDirNode = g:NERDTreeDirNode.GetSelected()
-    let prompt = s:inputPrompt("add")
+    let prompt = s:inputPrompt('add')
-    let newNodeName = input(prompt, curDirNode.path.str() . g:NERDTreePath.Slash(), "file")
+    let newNodeName = input(prompt, curDirNode.path.str() . g:NERDTreePath.Slash(), 'file')
 
     if newNodeName ==# ''
-        call nerdtree#echo("Node Creation Aborted.")
+        call nerdtree#echo('Node Creation Aborted.')
         return
     endif
 
@@ -187,26 +187,31 @@ function! NERDTreeAddNode()
 
         redraw!
     catch /^NERDTree/
-        call nerdtree#echoWarning("Node Not Created.")
+        call nerdtree#echoWarning('Node Not Created.')
     endtry
 endfunction
 
 "FUNCTION: NERDTreeMoveNode(){{{1
 function! NERDTreeMoveNode()
     let curNode = g:NERDTreeFileNode.GetSelected()
-    let prompt = s:inputPrompt("move")
+    let prompt = s:inputPrompt('move')
-    let newNodePath = input(prompt, curNode.path.str(), "file")
+    let newNodePath = input(prompt, curNode.path.str(), 'file')
+    while filereadable(newNodePath)
+        call nerdtree#echoWarning('This destination already exists. Try again.')
+        let newNodePath = input(prompt, curNode.path.str(), 'file')
+    endwhile
+
 
     if newNodePath ==# ''
-        call nerdtree#echo("Node Renaming Aborted.")
+        call nerdtree#echo('Node Renaming Aborted.')
         return
     endif
 
     try
         if curNode.path.isDirectory
-            let l:openBuffers = filter(range(1,bufnr("$")),'bufexists(v:val) && fnamemodify(bufname(v:val),":p") =~# curNode.path.str() . "/.*"')
+            let l:openBuffers = filter(range(1,bufnr('$')),'bufexists(v:val) && fnamemodify(bufname(v:val),":p") =~# curNode.path.str() . "/.*"')
         else
-            let l:openBuffers = filter(range(1,bufnr("$")),'bufexists(v:val) && fnamemodify(bufname(v:val),":p") ==# curNode.path.str()')
+            let l:openBuffers = filter(range(1,bufnr('$')),'bufexists(v:val) && fnamemodify(bufname(v:val),":p") ==# curNode.path.str()')
         endif
 
         call curNode.rename(newNodePath)
@@ -221,9 +226,9 @@ function! NERDTreeMoveNode()
         " renamed files.
         if !empty(l:openBuffers)
             if curNode.path.isDirectory
-                echo "\nDirectory renamed.\n\nFiles with the old directory name are open in buffers " . join(l:openBuffers, ', ') . ". Replace these buffers with the new files? (yN)"
+                echo "\nDirectory renamed.\n\nFiles with the old directory name are open in buffers " . join(l:openBuffers, ', ') . '. Replace these buffers with the new files? (yN)'
             else
-                echo "\nFile renamed.\n\nThe old file is open in buffer " . l:openBuffers[0] . ". Replace this buffer with the new file? (yN)"
+                echo "\nFile renamed.\n\nThe old file is open in buffer " . l:openBuffers[0] . '. Replace this buffer with the new file? (yN)'
             endif
             if g:NERDTreeAutoDeleteBuffer || nr2char(getchar()) ==# 'y'
                 for bufNum in l:openBuffers
@@ -236,7 +241,7 @@ function! NERDTreeMoveNode()
 
         redraw!
     catch /^NERDTree/
-        call nerdtree#echoWarning("Node Not Renamed.")
+        call nerdtree#echoWarning('Node Not Renamed.')
     endtry
 endfunction
 
@@ -249,11 +254,11 @@ function! NERDTreeDeleteNode()
 
     if currentNode.path.isDirectory && ((currentNode.isOpen && currentNode.getChildCount() > 0) ||
                                       \ (len(currentNode._glob('*', 1)) > 0))
-        let prompt = s:inputPrompt("deleteNonEmpty") . currentNode.path.str() . ": "
+        let prompt = s:inputPrompt('deleteNonEmpty') . currentNode.path.str() . ': '
         let choice = input(prompt)
         let confirmed = choice ==# 'yes'
     else
-        let prompt = s:inputPrompt("delete") . currentNode.path.str() . " (yN): "
+        let prompt = s:inputPrompt('delete') . currentNode.path.str() . ' (yN): '
         echo prompt
         let choice = nr2char(getchar())
         let confirmed = choice ==# 'y'
@@ -266,18 +271,18 @@ function! NERDTreeDeleteNode()
 
             "if the node is open in a buffer, ask the user if they want to
             "close that buffer
-            let bufnum = bufnr("^".currentNode.path.str()."$")
+            let bufnum = bufnr('^'.currentNode.path.str().'$')
             if buflisted(bufnum)
-                let prompt = "\nNode deleted.\n\nThe file is open in buffer ". bufnum . (bufwinnr(bufnum) ==# -1 ? " (hidden)" : "") .". Delete this buffer? (yN)"
+                let prompt = "\nNode deleted.\n\nThe file is open in buffer ". bufnum . (bufwinnr(bufnum) ==# -1 ? ' (hidden)' : '') .'. Delete this buffer? (yN)'
                 call s:promptToDelBuffer(bufnum, prompt)
             endif
 
             redraw!
         catch /^NERDTree/
-            call nerdtree#echoWarning("Could not remove node")
+            call nerdtree#echoWarning('Could not remove node')
         endtry
     else
-        call nerdtree#echo("delete aborted")
+        call nerdtree#echo('delete aborted')
     endif
     let &shellslash = l:shellslash
 endfunction
@@ -286,10 +291,10 @@ endfunction
 function! NERDTreeListNode()
     let treenode = g:NERDTreeFileNode.GetSelected()
     if !empty(treenode)
-        let s:uname = system("uname")
+        let s:uname = system('uname')
         let stat_cmd = 'stat -c "%s" '
 
-        if s:uname =~? "Darwin"
+        if s:uname =~? 'Darwin'
             let stat_cmd = 'stat -f "%z" '
         endif
 
@@ -300,7 +305,7 @@ function! NERDTreeListNode()
         let metadata = split(system(cmd),'\n')
         call nerdtree#echo(metadata[0])
     else
-        call nerdtree#echo("No information available")
+        call nerdtree#echo('No information available')
     endif
 endfunction
 
@@ -310,10 +315,10 @@ function! NERDTreeListNodeWin32()
 
     if !empty(l:node)
         let l:path = l:node.path.str()
-        call nerdtree#echo(printf("%s:%s  MOD:%s  BYTES:%d  PERMISSIONS:%s",
+        call nerdtree#echo(printf('%s:%s  MOD:%s  BYTES:%d  PERMISSIONS:%s',
                     \ toupper(getftype(l:path)),
                     \ fnamemodify(l:path, ':t'),
-                    \ strftime("%c", getftime(l:path)),
+                    \ strftime('%c', getftime(l:path)),
                     \ getfsize(l:path),
                     \ getfperm(l:path)))
         return
@@ -327,16 +332,16 @@ function! NERDTreeCopyNode()
     let l:shellslash = &shellslash
     let &shellslash = 0
     let currentNode = g:NERDTreeFileNode.GetSelected()
-    let prompt = s:inputPrompt("copy")
+    let prompt = s:inputPrompt('copy')
-    let newNodePath = input(prompt, currentNode.path.str(), "file")
+    let newNodePath = input(prompt, currentNode.path.str(), 'file')
 
-    if newNodePath != ""
+    if newNodePath !=# ''
         "strip trailing slash
         let newNodePath = substitute(newNodePath, '\/$', '', '')
 
         let confirmed = 1
         if currentNode.path.copyingWillOverwrite(newNodePath)
-            call nerdtree#echo("Warning: copying may overwrite files! Continue? (yN)")
+            call nerdtree#echo('Warning: copying may overwrite files! Continue? (yN)')
             let choice = nr2char(getchar())
             let confirmed = choice ==# 'y'
         endif
@@ -355,11 +360,11 @@ function! NERDTreeCopyNode()
                     call newNode.putCursorHere(0, 0)
                 endif
             catch /^NERDTree/
-                call nerdtree#echoWarning("Could not copy node")
+                call nerdtree#echoWarning('Could not copy node')
             endtry
         endif
     else
-        call nerdtree#echo("Copy aborted.")
+        call nerdtree#echo('Copy aborted.')
     endif
     let &shellslash = l:shellslash
     redraw!
@@ -368,18 +373,22 @@ endfunction
 " FUNCTION: NERDTreeCopyPath() {{{1
 function! NERDTreeCopyPath()
     let l:nodePath = g:NERDTreeFileNode.GetSelected().path.str()
-    if has("clipboard")
+    if has('clipboard')
-        let @* = l:nodePath
+        if &clipboard ==# 'unnamedplus'
-        call nerdtree#echo("The path [" . l:nodePath . "] was copied to your clipboard.")
+            let @+ = l:nodePath
+        else
+            let @* = l:nodePath
+        endif
+        call nerdtree#echo('The path [' . l:nodePath . '] was copied to your clipboard.')
     else
-        call nerdtree#echo("The full path is: " . l:nodePath)
+        call nerdtree#echo('The full path is: ' . l:nodePath)
     endif
 endfunction
 
 " FUNCTION: NERDTreeQuickLook() {{{1
 function! NERDTreeQuickLook()
     let treenode = g:NERDTreeFileNode.GetSelected()
-    if treenode != {}
+    if treenode !=# {}
         call system("qlmanage -p 2>/dev/null '" . treenode.path.str() . "'")
     endif
 endfunction
@@ -387,7 +396,7 @@ endfunction
 " FUNCTION: NERDTreeRevealInFinder() {{{1
 function! NERDTreeRevealInFinder()
     let treenode = g:NERDTreeFileNode.GetSelected()
-    if treenode != {}
+    if treenode !=# {}
         call system("open -R '" . treenode.path.str() . "'")
     endif
 endfunction
@@ -395,7 +404,7 @@ endfunction
 " FUNCTION: NERDTreeExecuteFile() {{{1
 function! NERDTreeExecuteFile()
     let treenode = g:NERDTreeFileNode.GetSelected()
-    if treenode != {}
+    if treenode !=# {}
         call system("open '" . treenode.path.str() . "'")
     endif
 endfunction
@@ -404,7 +413,7 @@ endfunction
 function! NERDTreeRevealFileLinux()
     let treenode = g:NERDTreeFileNode.GetSelected()
     let parentnode = treenode.parent
-    if parentnode != {}
+    if parentnode !=# {}
         call system("xdg-open '" . parentnode.path.str() . "' &")
     endif
 endfunction
@@ -412,7 +421,7 @@ endfunction
 " FUNCTION: NERDTreeExecuteFileLinux() {{{1
 function! NERDTreeExecuteFileLinux()
     let treenode = g:NERDTreeFileNode.GetSelected()
-    if treenode != {}
+    if treenode !=# {}
         call system("xdg-open '" . treenode.path.str() . "' &")
     endif
 endfunction

nerdtree_plugin/vcs.vim

@@ -11,12 +11,21 @@
 "
 " ============================================================================
 command! -n=? -complete=dir -bar NERDTreeVCS :call <SID>CreateTabTreeVCS('<args>')
+command! -n=? -complete=dir -bar NERDTreeToggleVCS :call <SID>ToggleTabTreeVCS('<args>')
 
 " FUNCTION: s:CreateTabTreeVCS(a:name) {{{1
 function! s:CreateTabTreeVCS(name)
     let l:path = g:NERDTreeCreator._pathForString(a:name)
     let l:path = s:FindParentVCSRoot(l:path)
-    call g:NERDTreeCreator.createTabTree(empty(l:path) ? "" : l:path._str())
+    call g:NERDTreeCreator.createTabTree(empty(l:path) ? '' : l:path._str())
+endfunction
+
+" FUNCTION: s:ToggleTabTreeVCS(a:name) {{{1
+" Behaves the same as ToggleTabTree except roots directory at VCS root
+function! s:ToggleTabTreeVCS(name)
+    let l:path = g:NERDTreeCreator._pathForString(a:name)
+    let l:path = s:FindParentVCSRoot(l:path)
+    call g:NERDTreeCreator.toggleTabTree(empty(l:path) ? '' : l:path._str())
 endfunction
 
 " FUNCTION: s:FindParentVCSRoot(a:path) {{{1
@@ -25,7 +34,7 @@ endfunction
 function! s:FindParentVCSRoot(path)
     let l:path = a:path
     while !empty(l:path) &&
-        \ l:path._str() !~ '^\(\a:\\\|\/\)$' &&
+        \ l:path._str() !~# '^\(\a:\\\|\/\)$' &&
         \ !isdirectory(l:path._str() . '/.git') &&
         \ !isdirectory(l:path._str() . '/.svn') &&
         \ !isdirectory(l:path._str() . '/.hg') &&
@@ -33,6 +42,6 @@ function! s:FindParentVCSRoot(path)
         \ !isdirectory(l:path._str() . '/_darcs')
         let l:path = l:path.getParent()
     endwhile
-    return (empty(l:path) || l:path._str() =~ '^\(\a:\\\|\/\)$') ? a:path : l:path
+    return (empty(l:path) || l:path._str() =~# '^\(\a:\\\|\/\)$') ? a:path : l:path
 endfunction
 

plugin/NERD_tree.vim

@@ -11,7 +11,9 @@
 "
 " SECTION: Script init stuff {{{1
 "============================================================
-if exists("loaded_nerd_tree")
+scriptencoding utf-8
+
+if exists('loaded_nerd_tree')
     finish
 endif
 if v:version < 703
@@ -20,9 +22,9 @@ if v:version < 703
 endif
 let loaded_nerd_tree = 1
 
-"for line continuation - i.e dont want C in &cpo
+"for line continuation - i.e dont want C in &cpoptions
-let s:old_cpo = &cpo
+let s:old_cpo = &cpoptions
-set cpo&vim
+set cpoptions&vim
 
 "Function: s:initVariable() function {{{2
 "This function is used to initialise a given variable to a given value. The
@@ -36,64 +38,65 @@ set cpo&vim
 "1 if the var is set, 0 otherwise
 function! s:initVariable(var, value)
     if !exists(a:var)
-        exec 'let ' . a:var . ' = ' . "'" . substitute(a:value, "'", "''", "g") . "'"
+        exec 'let ' . a:var . ' = ' . "'" . substitute(a:value, "'", "''", 'g') . "'"
         return 1
     endif
     return 0
 endfunction
 
 "SECTION: Init variable calls and other random constants {{{2
-call s:initVariable("g:NERDTreeAutoCenter", 1)
+call s:initVariable('g:NERDTreeAutoCenter', 1)
-call s:initVariable("g:NERDTreeAutoCenterThreshold", 3)
+call s:initVariable('g:NERDTreeAutoCenterThreshold', 3)
-call s:initVariable("g:NERDTreeCaseSensitiveSort", 0)
+call s:initVariable('g:NERDTreeCaseSensitiveSort', 0)
-call s:initVariable("g:NERDTreeNaturalSort", 0)
+call s:initVariable('g:NERDTreeNaturalSort', 0)
-call s:initVariable("g:NERDTreeSortHiddenFirst", 1)
+call s:initVariable('g:NERDTreeSortHiddenFirst', 1)
-call s:initVariable("g:NERDTreeChDirMode", 0)
+call s:initVariable('g:NERDTreeUseTCD', 0)
-call s:initVariable("g:NERDTreeCreatePrefix", "silent")
+call s:initVariable('g:NERDTreeChDirMode', 0)
-call s:initVariable("g:NERDTreeMinimalUI", 0)
+call s:initVariable('g:NERDTreeCreatePrefix', 'silent')
-call s:initVariable("g:NERDTreeMinimalMenu", 0)
+call s:initVariable('g:NERDTreeMinimalUI', 0)
-if !exists("g:NERDTreeIgnore")
+call s:initVariable('g:NERDTreeMinimalMenu', 0)
+if !exists('g:NERDTreeIgnore')
     let g:NERDTreeIgnore = ['\~$']
 endif
-call s:initVariable("g:NERDTreeBookmarksFile", expand('$HOME') . '/.NERDTreeBookmarks')
+call s:initVariable('g:NERDTreeBookmarksFile', expand('$HOME') . '/.NERDTreeBookmarks')
-call s:initVariable("g:NERDTreeBookmarksSort", 1)
+call s:initVariable('g:NERDTreeBookmarksSort', 1)
-call s:initVariable("g:NERDTreeHighlightCursorline", 1)
+call s:initVariable('g:NERDTreeHighlightCursorline', 1)
-call s:initVariable("g:NERDTreeHijackNetrw", 1)
+call s:initVariable('g:NERDTreeHijackNetrw', 1)
 call s:initVariable('g:NERDTreeMarkBookmarks', 1)
-call s:initVariable("g:NERDTreeMouseMode", 1)
+call s:initVariable('g:NERDTreeMouseMode', 1)
-call s:initVariable("g:NERDTreeNotificationThreshold", 100)
+call s:initVariable('g:NERDTreeNotificationThreshold', 100)
-call s:initVariable("g:NERDTreeQuitOnOpen", 0)
+call s:initVariable('g:NERDTreeQuitOnOpen', 0)
-call s:initVariable("g:NERDTreeRespectWildIgnore", 0)
+call s:initVariable('g:NERDTreeRespectWildIgnore', 0)
-call s:initVariable("g:NERDTreeShowBookmarks", 0)
+call s:initVariable('g:NERDTreeShowBookmarks', 0)
-call s:initVariable("g:NERDTreeShowFiles", 1)
+call s:initVariable('g:NERDTreeShowFiles', 1)
-call s:initVariable("g:NERDTreeShowHidden", 0)
+call s:initVariable('g:NERDTreeShowHidden', 0)
-call s:initVariable("g:NERDTreeShowLineNumbers", 0)
+call s:initVariable('g:NERDTreeShowLineNumbers', 0)
-call s:initVariable("g:NERDTreeSortDirs", 1)
+call s:initVariable('g:NERDTreeSortDirs', 1)
 
 if !nerdtree#runningWindows() && !nerdtree#runningCygwin()
-    call s:initVariable("g:NERDTreeDirArrowExpandable", "▸")
+    call s:initVariable('g:NERDTreeDirArrowExpandable', '▸')
-    call s:initVariable("g:NERDTreeDirArrowCollapsible", "▾")
+    call s:initVariable('g:NERDTreeDirArrowCollapsible', '▾')
 else
-    call s:initVariable("g:NERDTreeDirArrowExpandable", "+")
+    call s:initVariable('g:NERDTreeDirArrowExpandable', '+')
-    call s:initVariable("g:NERDTreeDirArrowCollapsible", "~")
+    call s:initVariable('g:NERDTreeDirArrowCollapsible', '~')
 endif
 
-call s:initVariable("g:NERDTreeCascadeOpenSingleChildDir", 1)
+call s:initVariable('g:NERDTreeCascadeOpenSingleChildDir', 1)
-call s:initVariable("g:NERDTreeCascadeSingleChildDir", 1)
+call s:initVariable('g:NERDTreeCascadeSingleChildDir', 1)
 
-if !exists("g:NERDTreeSortOrder")
+if !exists('g:NERDTreeSortOrder')
     let g:NERDTreeSortOrder = ['\/$', '*', '\.swp$',  '\.bak$', '\~$']
 endif
 let g:NERDTreeOldSortOrder = []
 
-call s:initVariable("g:NERDTreeGlyphReadOnly", "RO")
+call s:initVariable('g:NERDTreeGlyphReadOnly', 'RO')
 
-if has("conceal")
+if has('conceal')
-    call s:initVariable("g:NERDTreeNodeDelimiter", "\x07")
+    call s:initVariable('g:NERDTreeNodeDelimiter', "\x07")
-elseif (g:NERDTreeDirArrowExpandable == "\u00a0" || g:NERDTreeDirArrowCollapsible == "\u00a0")
+elseif (g:NERDTreeDirArrowExpandable ==# "\u00a0" || g:NERDTreeDirArrowCollapsible ==# "\u00a0")
-    call s:initVariable("g:NERDTreeNodeDelimiter", "\u00b7")
+    call s:initVariable('g:NERDTreeNodeDelimiter', "\u00b7")
 else
-    call s:initVariable("g:NERDTreeNodeDelimiter", "\u00a0")
+    call s:initVariable('g:NERDTreeNodeDelimiter', "\u00a0")
 endif
 
 if !exists('g:NERDTreeStatusline')
@@ -104,59 +107,60 @@ if !exists('g:NERDTreeStatusline')
     let g:NERDTreeStatusline = "%{exists('b:NERDTree')?b:NERDTree.root.path.str():''}"
 
 endif
-call s:initVariable("g:NERDTreeWinPos", "left")
+call s:initVariable('g:NERDTreeWinPos', 'left')
-call s:initVariable("g:NERDTreeWinSize", 31)
+call s:initVariable('g:NERDTreeWinSize', 31)
 
 "init the shell commands that will be used to copy nodes, and remove dir trees
 "
 "Note: the space after the command is important
 if nerdtree#runningWindows()
-    call s:initVariable("g:NERDTreeRemoveDirCmd", 'rmdir /s /q ')
+    call s:initVariable('g:NERDTreeRemoveDirCmd', 'rmdir /s /q ')
-    call s:initVariable("g:NERDTreeCopyDirCmd", 'xcopy /s /e /i /y /q ')
+    call s:initVariable('g:NERDTreeCopyDirCmd', 'xcopy /s /e /i /y /q ')
-    call s:initVariable("g:NERDTreeCopyFileCmd", 'copy /y ')
+    call s:initVariable('g:NERDTreeCopyFileCmd', 'copy /y ')
 else
-    call s:initVariable("g:NERDTreeRemoveDirCmd", 'rm -rf ')
+    call s:initVariable('g:NERDTreeRemoveDirCmd', 'rm -rf ')
-    call s:initVariable("g:NERDTreeCopyCmd", 'cp -r ')
+    call s:initVariable('g:NERDTreeCopyCmd', 'cp -r ')
 endif
 
 
 "SECTION: Init variable calls for key mappings {{{2
-call s:initVariable("g:NERDTreeMapActivateNode", "o")
+call s:initVariable('g:NERDTreeMapCustomOpen', '<CR>')
-call s:initVariable("g:NERDTreeMapChangeRoot", "C")
+call s:initVariable('g:NERDTreeMapActivateNode', 'o')
-call s:initVariable("g:NERDTreeMapChdir", "cd")
+call s:initVariable('g:NERDTreeMapChangeRoot', 'C')
-call s:initVariable("g:NERDTreeMapCloseChildren", "X")
+call s:initVariable('g:NERDTreeMapChdir', 'cd')
-call s:initVariable("g:NERDTreeMapCloseDir", "x")
+call s:initVariable('g:NERDTreeMapCloseChildren', 'X')
-call s:initVariable("g:NERDTreeMapDeleteBookmark", "D")
+call s:initVariable('g:NERDTreeMapCloseDir', 'x')
-call s:initVariable("g:NERDTreeMapMenu", "m")
+call s:initVariable('g:NERDTreeMapDeleteBookmark', 'D')
-call s:initVariable("g:NERDTreeMapHelp", "?")
+call s:initVariable('g:NERDTreeMapMenu', 'm')
-call s:initVariable("g:NERDTreeMapJumpFirstChild", "K")
+call s:initVariable('g:NERDTreeMapHelp', '?')
-call s:initVariable("g:NERDTreeMapJumpLastChild", "J")
+call s:initVariable('g:NERDTreeMapJumpFirstChild', 'K')
-call s:initVariable("g:NERDTreeMapJumpNextSibling", "<C-j>")
+call s:initVariable('g:NERDTreeMapJumpLastChild', 'J')
-call s:initVariable("g:NERDTreeMapJumpParent", "p")
+call s:initVariable('g:NERDTreeMapJumpNextSibling', '<C-j>')
-call s:initVariable("g:NERDTreeMapJumpPrevSibling", "<C-k>")
+call s:initVariable('g:NERDTreeMapJumpParent', 'p')
-call s:initVariable("g:NERDTreeMapJumpRoot", "P")
+call s:initVariable('g:NERDTreeMapJumpPrevSibling', '<C-k>')
-call s:initVariable("g:NERDTreeMapOpenExpl", "e")
+call s:initVariable('g:NERDTreeMapJumpRoot', 'P')
-call s:initVariable("g:NERDTreeMapOpenInTab", "t")
+call s:initVariable('g:NERDTreeMapOpenExpl', 'e')
-call s:initVariable("g:NERDTreeMapOpenInTabSilent", "T")
+call s:initVariable('g:NERDTreeMapOpenInTab', 't')
-call s:initVariable("g:NERDTreeMapOpenRecursively", "O")
+call s:initVariable('g:NERDTreeMapOpenInTabSilent', 'T')
-call s:initVariable("g:NERDTreeMapOpenSplit", "i")
+call s:initVariable('g:NERDTreeMapOpenRecursively', 'O')
-call s:initVariable("g:NERDTreeMapOpenVSplit", "s")
+call s:initVariable('g:NERDTreeMapOpenSplit', 'i')
-call s:initVariable("g:NERDTreeMapPreview", "g" . NERDTreeMapActivateNode)
+call s:initVariable('g:NERDTreeMapOpenVSplit', 's')
-call s:initVariable("g:NERDTreeMapPreviewSplit", "g" . NERDTreeMapOpenSplit)
+call s:initVariable('g:NERDTreeMapPreview', 'g' . NERDTreeMapActivateNode)
-call s:initVariable("g:NERDTreeMapPreviewVSplit", "g" . NERDTreeMapOpenVSplit)
+call s:initVariable('g:NERDTreeMapPreviewSplit', 'g' . NERDTreeMapOpenSplit)
-call s:initVariable("g:NERDTreeMapQuit", "q")
+call s:initVariable('g:NERDTreeMapPreviewVSplit', 'g' . NERDTreeMapOpenVSplit)
-call s:initVariable("g:NERDTreeMapRefresh", "r")
+call s:initVariable('g:NERDTreeMapQuit', 'q')
-call s:initVariable("g:NERDTreeMapRefreshRoot", "R")
+call s:initVariable('g:NERDTreeMapRefresh', 'r')
-call s:initVariable("g:NERDTreeMapToggleBookmarks", "B")
+call s:initVariable('g:NERDTreeMapRefreshRoot', 'R')
-call s:initVariable("g:NERDTreeMapToggleFiles", "F")
+call s:initVariable('g:NERDTreeMapToggleBookmarks', 'B')
-call s:initVariable("g:NERDTreeMapToggleFilters", "f")
+call s:initVariable('g:NERDTreeMapToggleFiles', 'F')
-call s:initVariable("g:NERDTreeMapToggleHidden", "I")
+call s:initVariable('g:NERDTreeMapToggleFilters', 'f')
-call s:initVariable("g:NERDTreeMapToggleZoom", "A")
+call s:initVariable('g:NERDTreeMapToggleHidden', 'I')
-call s:initVariable("g:NERDTreeMapUpdir", "u")
+call s:initVariable('g:NERDTreeMapToggleZoom', 'A')
-call s:initVariable("g:NERDTreeMapUpdirKeepOpen", "U")
+call s:initVariable('g:NERDTreeMapUpdir', 'u')
-call s:initVariable("g:NERDTreeMapCWD", "CD")
+call s:initVariable('g:NERDTreeMapUpdirKeepOpen', 'U')
-call s:initVariable("g:NERDTreeMenuDown", "j")
+call s:initVariable('g:NERDTreeMapCWD', 'CD')
-call s:initVariable("g:NERDTreeMenuUp", "k")
+call s:initVariable('g:NERDTreeMenuDown', 'j')
+call s:initVariable('g:NERDTreeMenuUp', 'k')
 
 "SECTION: Load class files{{{2
 call nerdtree#loadClassFiles()
@@ -169,16 +173,22 @@ call nerdtree#ui_glue#setupCommands()
 "============================================================
 augroup NERDTree
     "Save the cursor position whenever we close the nerd tree
-    exec "autocmd BufLeave ". g:NERDTreeCreator.BufNamePrefix() ."* if g:NERDTree.IsOpen() | call b:NERDTree.ui.saveScreenState() | endif"
+    exec 'autocmd BufLeave,WinLeave '. g:NERDTreeCreator.BufNamePrefix() .'* if g:NERDTree.IsOpen() | call b:NERDTree.ui.saveScreenState() | endif'
 
     "disallow insert mode in the NERDTree
-    exec "autocmd BufEnter ". g:NERDTreeCreator.BufNamePrefix() ."* stopinsert"
+    exec 'autocmd BufEnter,WinEnter '. g:NERDTreeCreator.BufNamePrefix() .'* stopinsert'
 augroup END
 
 if g:NERDTreeHijackNetrw
     augroup NERDTreeHijackNetrw
         autocmd VimEnter * silent! autocmd! FileExplorer
-        au BufEnter,VimEnter * call nerdtree#checkForBrowse(expand("<amatch>"))
+        au BufEnter,VimEnter * call nerdtree#checkForBrowse(expand('<amatch>'))
+    augroup END
+endif
+
+if g:NERDTreeChDirMode ==# 3
+    augroup NERDTreeChDirOnTabSwitch
+        autocmd TabEnter * if g:NERDTree.ExistsForTab()|call g:NERDTree.ForCurrentTab().getRoot().path.changeToDir()|endif
     augroup END
 endif
 
@@ -209,7 +219,7 @@ function! NERDTreeFocus()
     if g:NERDTree.IsOpen()
         call g:NERDTree.CursorToTreeWin()
     else
-        call g:NERDTreeCreator.ToggleTabTree("")
+        call g:NERDTreeCreator.ToggleTabTree('')
     endif
 endfunction
 
@@ -245,7 +255,7 @@ endfunction
 " SECTION: Post Source Actions {{{1
 call nerdtree#postSourceActions()
 
-"reset &cpo back to users setting
+"reset &cpoptions back to users setting
-let &cpo = s:old_cpo
+let &cpoptions = s:old_cpo
 
 " vim: set sw=4 sts=4 et fdm=marker:

syntax/nerdtree.vim

@@ -3,7 +3,7 @@ syn match NERDTreeIgnore #\~#
 exec 'syn match NERDTreeIgnore #\['.g:NERDTreeGlyphReadOnly.'\]#'
 
 "highlighting for the .. (up dir) line at the top of the tree
-execute "syn match NERDTreeUp #\\V". s:tree_up_dir_line ."#"
+execute "syn match NERDTreeUp #\\V". s:tree_up_dir_line .'#'
 
 "quickhelp syntax elements
 syn match NERDTreeHelpKey #" \{1,2\}[^ ]*:#ms=s+2,me=e-1
@@ -19,25 +19,8 @@ syn match NERDTreeLinkTarget #->.*# containedin=NERDTreeDir,NERDTreeFile
 syn match NERDTreeLinkFile #.* ->#me=e-3 containedin=NERDTreeFile
 syn match NERDTreeLinkDir #.*/ ->#me=e-3 containedin=NERDTreeDir
 
-"highlighing for directory nodes and file nodes
+"highlighting to conceal the delimiter around the file/dir name
-syn match NERDTreeDirSlash #/# containedin=NERDTreeDir
+if has('conceal')
-
-exec 'syn match NERDTreeClosable #' . escape(g:NERDTreeDirArrowCollapsible, '~') . '\ze .*/# containedin=NERDTreeDir,NERDTreeFile'
-exec 'syn match NERDTreeOpenable #' . escape(g:NERDTreeDirArrowExpandable, '~') . '\ze .*/# containedin=NERDTreeDir,NERDTreeFile'
-
-let s:dirArrows = escape(g:NERDTreeDirArrowCollapsible, '~]\-').escape(g:NERDTreeDirArrowExpandable, '~]\-')
-exec 'syn match NERDTreeDir #[^'.s:dirArrows.' ].*/#'
-syn match NERDTreeExecFile  #^ .*\*\($\| \)# contains=NERDTreeRO,NERDTreeBookmark
-exec 'syn match NERDTreeFile  #^[^"\.'.s:dirArrows.'] *[^'.s:dirArrows.']*# contains=NERDTreeLink,NERDTreeRO,NERDTreeBookmark,NERDTreeExecFile'
-
-"highlighting for readonly files
-exec 'syn match NERDTreeRO # *\zs.*\ze \['.g:NERDTreeGlyphReadOnly.'\]# contains=NERDTreeIgnore,NERDTreeBookmark,NERDTreeFile'
-
-syn match NERDTreeFlags #^ *\zs\[[^\]]*\]# containedin=NERDTreeFile,NERDTreeExecFile
-syn match NERDTreeFlags #\[[^\]]*\]# containedin=NERDTreeDir
-
-"highlighing to conceal the delimiter around the file/dir name
-if has("conceal")
     exec 'syn match NERDTreeNodeDelimiters #\%d' . char2nr(g:NERDTreeNodeDelimiter) . '# conceal containedin=ALL'
     setlocal conceallevel=3 concealcursor=nvic
 else
@@ -45,6 +28,27 @@ else
     hi! link NERDTreeNodeDelimiters Ignore
 endif
 
+"highlighing for directory nodes and file nodes
+syn match NERDTreeDirSlash #/# containedin=NERDTreeDir
+
+if g:NERDTreeDirArrowExpandable !=# ''
+    exec 'syn match NERDTreeClosable #' . escape(g:NERDTreeDirArrowCollapsible, '~') . '\ze .*/# containedin=NERDTreeDir,NERDTreeFile'
+    exec 'syn match NERDTreeOpenable #' . escape(g:NERDTreeDirArrowExpandable, '~') . '\ze .*/# containedin=NERDTreeDir,NERDTreeFile'
+    let s:dirArrows = escape(g:NERDTreeDirArrowCollapsible, '~]\-').escape(g:NERDTreeDirArrowExpandable, '~]\-')
+    exec 'syn match NERDTreeDir #[^'.s:dirArrows.' ].*/#'
+    exec 'syn match NERDTreeExecFile #^.*'.g:NERDTreeNodeDelimiter.'\*\($\| \)# contains=NERDTreeRO,NERDTreeBookmark'
+    exec 'syn match NERDTreeFile  #^[^"\.'.s:dirArrows.'] *[^'.s:dirArrows.']*# contains=NERDTreeLink,NERDTreeRO,NERDTreeBookmark,NERDTreeExecFile'
+else
+    exec 'syn match NERDTreeDir #[^'.g:NERDTreeNodeDelimiter.']\{-}/\ze\($\|'.g:NERDTreeNodeDelimiter.'\)#'
+    exec 'syn match NERDTreeExecFile #[^'.g:NERDTreeNodeDelimiter.']\{-}'.g:NERDTreeNodeDelimiter.'\*\($\| \)# contains=NERDTreeRO,NERDTreeBookmark'
+    exec 'syn match NERDTreeFile     #^.*'.g:NERDTreeNodeDelimiter.'.*[^\/]\($\|'.g:NERDTreeNodeDelimiter.'.*\)# contains=NERDTreeLink,NERDTreeRO,NERDTreeBookmark,NERDTreeExecFile'
+endif
+
+"highlighting for readonly files
+exec 'syn match NERDTreeRO #.*'.g:NERDTreeNodeDelimiter.'\zs.*\ze'.g:NERDTreeNodeDelimiter.'.*\['.g:NERDTreeGlyphReadOnly.'\]# contains=NERDTreeIgnore,NERDTreeBookmark,NERDTreeFile'
+
+exec 'syn match NERDTreeFlags #\[[^\]]*\]\ze'.g:NERDTreeNodeDelimiter.'# containedin=NERDTreeFile,NERDTreeExecFile,NERDTreeDir'
+
 syn match NERDTreeCWD #^[</].*$#
 
 "highlighting for bookmarks