m-vim_plugins/nerdtree
1
0
Fork 0
mirror of https://github.com/preservim/nerdtree.git synced 2025-11-08 11:23:48 -05:00
Code Issues Actions Packages Projects Releases Wiki Activity

Compare commits

base: m-vim_plugins:5.2.3
Branches Tags
m-vim_plugins:master m-vim_plugins:broken-symlink-support
m-vim_plugins:7.1.3 m-vim_plugins:7.1.2 m-vim_plugins:7.1.1 m-vim_plugins:7.1.0 m-vim_plugins:7.0.1 m-vim_plugins:7.0.0 m-vim_plugins:6.10.16 m-vim_plugins:6.10.15 m-vim_plugins:6.10.14 m-vim_plugins:6.10.13 m-vim_plugins:6.10.12 m-vim_plugins:6.10.11 m-vim_plugins:6.10.10 m-vim_plugins:6.10.9 m-vim_plugins:6.10.8 m-vim_plugins:6.10.7 m-vim_plugins:6.10.6 m-vim_plugins:6.10.5 m-vim_plugins:6.10.4 m-vim_plugins:6.10.3 m-vim_plugins:6.10.2 m-vim_plugins:6.10.1 m-vim_plugins:6.10.0 m-vim_plugins:6.9.12 m-vim_plugins:6.9.11 m-vim_plugins:6.9.10 m-vim_plugins:6.9.9 m-vim_plugins:6.9.8 m-vim_plugins:6.9.7 m-vim_plugins:6.9.6 m-vim_plugins:6.9.5 m-vim_plugins:6.9.4 m-vim_plugins:6.9.1 m-vim_plugins:6.9.3 m-vim_plugins:6.9.2 m-vim_plugins:6.9.0 m-vim_plugins:6.8.0 m-vim_plugins:6.7.15 m-vim_plugins:6.7.14 m-vim_plugins:6.7.13 m-vim_plugins:6.7.12 m-vim_plugins:6.7.11 m-vim_plugins:6.7.10 m-vim_plugins:6.7.9 m-vim_plugins:6.7.8 m-vim_plugins:6.7.7 m-vim_plugins:6.7.6 m-vim_plugins:6.7.5 m-vim_plugins:6.7.4 m-vim_plugins:6.7.3 m-vim_plugins:6.7.2 m-vim_plugins:6.7.1 m-vim_plugins:6.7.0 m-vim_plugins:6.6.1 m-vim_plugins:6.6.0 m-vim_plugins:6.5.0 m-vim_plugins:6.4.6 m-vim_plugins:6.4.5 m-vim_plugins:6.4.4 m-vim_plugins:6.4.3 m-vim_plugins:6.4.2 m-vim_plugins:6.4.1 m-vim_plugins:6.4.0 m-vim_plugins:6.3.0 m-vim_plugins:6.2.1 m-vim_plugins:6.2.0 m-vim_plugins:6.1.4 m-vim_plugins:6.1.3 m-vim_plugins:6.1.2 m-vim_plugins:6.1.1 m-vim_plugins:6.1.0 m-vim_plugins:6.0.1 m-vim_plugins:6.0.0 m-vim_plugins:5.3.3 m-vim_plugins:5.3.2 m-vim_plugins:5.3.1 m-vim_plugins:5.3.0 m-vim_plugins:5.2.9 m-vim_plugins:5.2.8 m-vim_plugins:5.2.7 m-vim_plugins:5.2.6 m-vim_plugins:5.2.5 m-vim_plugins:5.2.4 m-vim_plugins:5.2.3 m-vim_plugins:5.2.2 m-vim_plugins:5.2.1 m-vim_plugins:5.2.0 m-vim_plugins:5.1.3 m-vim_plugins:5.1.2 m-vim_plugins:5.1.1 m-vim_plugins:5.1.0 m-vim_plugins:5.0.0 m-vim_plugins:4.2.0 m-vim_plugins:4.1.0 m-vim_plugins:4.0.0 m-vim_plugins:3.1.1 m-vim_plugins:3.1.0 m-vim_plugins:3.0.1 m-vim_plugins:3.0.0 m-vim_plugins:2.14.3 m-vim_plugins:2.14.2 m-vim_plugins:2.14.1 m-vim_plugins:2.14.0 m-vim_plugins:2.13.0 m-vim_plugins:2.12.0 m-vim_plugins:2.11.0 m-vim_plugins:2.10.0 m-vim_plugins:2.10.0rc1 m-vim_plugins:2.9.0 m-vim_plugins:2.8.0 m-vim_plugins:2.7.1 m-vim_plugins:2.7.0
...
compare: m-vim_plugins:6.6.0
Branches Tags
m-vim_plugins:master m-vim_plugins:broken-symlink-support
m-vim_plugins:7.1.3 m-vim_plugins:7.1.2 m-vim_plugins:7.1.1 m-vim_plugins:7.1.0 m-vim_plugins:7.0.1 m-vim_plugins:7.0.0 m-vim_plugins:6.10.16 m-vim_plugins:6.10.15 m-vim_plugins:6.10.14 m-vim_plugins:6.10.13 m-vim_plugins:6.10.12 m-vim_plugins:6.10.11 m-vim_plugins:6.10.10 m-vim_plugins:6.10.9 m-vim_plugins:6.10.8 m-vim_plugins:6.10.7 m-vim_plugins:6.10.6 m-vim_plugins:6.10.5 m-vim_plugins:6.10.4 m-vim_plugins:6.10.3 m-vim_plugins:6.10.2 m-vim_plugins:6.10.1 m-vim_plugins:6.10.0 m-vim_plugins:6.9.12 m-vim_plugins:6.9.11 m-vim_plugins:6.9.10 m-vim_plugins:6.9.9 m-vim_plugins:6.9.8 m-vim_plugins:6.9.7 m-vim_plugins:6.9.6 m-vim_plugins:6.9.5 m-vim_plugins:6.9.4 m-vim_plugins:6.9.1 m-vim_plugins:6.9.3 m-vim_plugins:6.9.2 m-vim_plugins:6.9.0 m-vim_plugins:6.8.0 m-vim_plugins:6.7.15 m-vim_plugins:6.7.14 m-vim_plugins:6.7.13 m-vim_plugins:6.7.12 m-vim_plugins:6.7.11 m-vim_plugins:6.7.10 m-vim_plugins:6.7.9 m-vim_plugins:6.7.8 m-vim_plugins:6.7.7 m-vim_plugins:6.7.6 m-vim_plugins:6.7.5 m-vim_plugins:6.7.4 m-vim_plugins:6.7.3 m-vim_plugins:6.7.2 m-vim_plugins:6.7.1 m-vim_plugins:6.7.0 m-vim_plugins:6.6.1 m-vim_plugins:6.6.0 m-vim_plugins:6.5.0 m-vim_plugins:6.4.6 m-vim_plugins:6.4.5 m-vim_plugins:6.4.4 m-vim_plugins:6.4.3 m-vim_plugins:6.4.2 m-vim_plugins:6.4.1 m-vim_plugins:6.4.0 m-vim_plugins:6.3.0 m-vim_plugins:6.2.1 m-vim_plugins:6.2.0 m-vim_plugins:6.1.4 m-vim_plugins:6.1.3 m-vim_plugins:6.1.2 m-vim_plugins:6.1.1 m-vim_plugins:6.1.0 m-vim_plugins:6.0.1 m-vim_plugins:6.0.0 m-vim_plugins:5.3.3 m-vim_plugins:5.3.2 m-vim_plugins:5.3.1 m-vim_plugins:5.3.0 m-vim_plugins:5.2.9 m-vim_plugins:5.2.8 m-vim_plugins:5.2.7 m-vim_plugins:5.2.6 m-vim_plugins:5.2.5 m-vim_plugins:5.2.4 m-vim_plugins:5.2.3 m-vim_plugins:5.2.2 m-vim_plugins:5.2.1 m-vim_plugins:5.2.0 m-vim_plugins:5.1.3 m-vim_plugins:5.1.2 m-vim_plugins:5.1.1 m-vim_plugins:5.1.0 m-vim_plugins:5.0.0 m-vim_plugins:4.2.0 m-vim_plugins:4.1.0 m-vim_plugins:4.0.0 m-vim_plugins:3.1.1 m-vim_plugins:3.1.0 m-vim_plugins:3.0.1 m-vim_plugins:3.0.0 m-vim_plugins:2.14.3 m-vim_plugins:2.14.2 m-vim_plugins:2.14.1 m-vim_plugins:2.14.0 m-vim_plugins:2.13.0 m-vim_plugins:2.12.0 m-vim_plugins:2.11.0 m-vim_plugins:2.10.0 m-vim_plugins:2.10.0rc1 m-vim_plugins:2.9.0 m-vim_plugins:2.8.0 m-vim_plugins:2.7.1 m-vim_plugins:2.7.0

75 Commits
5.2.3 ... 6.6.0

Author SHA1 Message Date
Phil Runninger
85103aa607 Merge pull request #1085 from preservim/i1064 
Add the ability to turn off directory arrows
 2020-02-06 18:21:00 -05:00
Phil Runninger
1f5018dc45 Update version number in change log. 2020-02-06 17:43:46 -05:00
Phil Runninger
d706f40ae7 Update the documentation/README. 2020-02-06 13:01:04 -05:00
Phil Runninger
e41dd019d9 Reorder syntax statements to fix highlighting. 2020-02-05 15:09:24 -05:00
Phil Runninger
2388af7754 WIP: A better regex for NERDTreeExecFile. Still not all right. 2020-02-04 02:08:08 -05:00
Phil Runninger
c3d7c141bb Simplify and make similar statements more similarer 2020-02-03 09:30:08 -05:00
Phil Runninger
450abd1820 Fix indentLevelFor(), which was getting the right answer the wrong way. 2020-02-03 08:00:06 -05:00
Phil Runninger
6d3743549c Fix vint errors: Use robust operators ==# and !=# 2020-02-03 02:28:53 -05:00
Phil Runninger
961c3571c4 WIP: Fix syntax highlighting when arrows are empty strings. 
Also improved some highlighting to make use of g:NERDTreeNodeDelimiter,
which directly surrounds the filename. More of this to come as errors
are tracked down and fixed in this file.
 2020-02-03 01:59:41 -05:00
Phil Runninger
26333ceeab If arrows are empty strings, don't print their trailing spaces. 2020-02-03 01:58:00 -05:00
Phil Runninger
8c48845d11 Merge pull request #1083 from preservim/1076 
NERDTree <start-directory> always sets NERDTree root.
 2020-01-28 03:59:24 -05:00
Phil Runninger
b16553ac54 Update pull request number in change log. 2020-01-28 03:57:50 -05:00
Phil Runninger
e48b5728f9 NERDTree <start-directory> always sets NERDTree root. 2020-01-28 03:55:58 -05:00
Phil Runninger
f7b09634ba Fix typo in version number. 2020-01-28 03:20:07 -05:00
Phil Runninger
c2c4a6564f Merge pull request #1081 from andys8/bugfix/1059-fails-with-vim-startify 
[BUGFIX] Shows error for empty filenames (vim-startify)
 2020-01-27 20:37:47 -05:00
andys8
881c265438 [BUGFIX] Shows error for empty filenames (vim-startify) 
There was a fix in #1043 which improves the behavior for non saved
filenames. Those are not on disk, but also not empty. This lead to an
issue #1059 where actual "empty files" like created with vim-startify or
stdin lead to an error. This change fixes this by adapting the order of
the tests. It'll print "no file for the current buffer" for empty files.

Solves #1059
 2020-01-20 15:05:47 +01:00
Phil Runninger
26740d1157 Merge pull request #1080 from preservim/restore_eventignore_in_finally_block 
Ensure events are (or aren't) being ignored correctly.
 2020-01-16 13:29:33 -05:00
Phil Runninger
6d5e185cef Update version in change log. 2020-01-16 13:25:57 -05:00
Phil Runninger
3a3636b7cb Don't ignore events when opening renamed files. 2020-01-16 11:17:33 -05:00
Phil Runninger
5fbf0d7dba Put the eventignore reset inside a finally block to ensure it's called. 2020-01-16 10:51:12 -05:00
Phil Runninger
901aba632b Merge pull request #1079 from preservim/1078 
Prevent overwriting existing files/dirs on node move. (m-m)
 2020-01-15 19:55:31 -05:00
Phil Runninger
a046ba5c5b Update version number in change log. 2020-01-15 19:54:06 -05:00
Phil Runninger
97e4b47aa3 Prevent overwriting existing files/dirs on node move. (m-m) 2020-01-15 19:51:39 -05:00
Phil Runninger
ee79ecfb67 Merge pull request #1075 from preservim/1073 
Fix regex that finds keyword for minimal menu.
 2020-01-06 09:21:11 -05:00
Phil Runninger
b579c7751d Fix regex that finds keyword for minimal menu. 2020-01-06 09:19:25 -05:00
Phil Runninger
8a14891241 Merge pull request #1072 from preservim/migrate 
Update links to repository with new org namespace
 2020-01-02 09:55:17 -05:00
Caleb Maclennan
914970157f Update links to repository with new org namespace 2020-01-02 12:09:02 +03:00
Phil Runninger
97fb849a29 Merge pull request #1071 from preservim/vint 
Lint vimscript, fix errors and warnings, add CI job to review PRs
 2020-01-02 02:12:21 -05:00
Caleb Maclennan
3fb31b2e81 Update changelog for 6.4.2 and add CI badge 2019-12-31 10:30:00 +03:00
Caleb Maclennan
907587f7a3 Fix lint warnings: use the full option name 2019-12-31 10:30:00 +03:00
Caleb Maclennan
38b1e5e7aa Fix lint warnings: use the abort attribute for functions in autoload 2019-12-31 09:42:19 +03:00
Caleb Maclennan
10868dd94c Fix lint warnings: use scriptencoding when multibyte char exists 2019-12-31 09:42:19 +03:00
Caleb Maclennan
a722613f36 Fix lint warnings: use robust operators 2019-12-31 09:42:19 +03:00
Caleb Maclennan
45e33f2502 Fix lint warnings: prefer single quoted strings 2019-12-31 09:42:14 +03:00
Caleb Maclennan
8d81510aa6 Fix VimL syntax error: undefined variable 2019-12-31 09:41:46 +03:00
Caleb Maclennan
d8d799a4d6 Fix VimL syntax error: escapes work differently outside quotes 2019-12-31 09:40:58 +03:00
Caleb Maclennan
ec0fca4c7d Add CI job that lints VimL and reviews PRs 2019-12-31 09:20:35 +03:00
Caleb Maclennan
fff3975608 Configure Vint linter 2019-12-31 09:20:35 +03:00
Phil Runninger
f64c0062ee Set theme jekyll-theme-cayman 2019-12-30 23:31:06 -05:00
Phil Runninger
1ab85e33be Update version in change log. 2019-12-16 09:06:45 -05:00
Phil Runninger
c962796b03 Ensure backward compatibility. v:t_func is not available before 8.0. 2019-12-16 09:04:16 -05:00
Alejandro Sanchez
a7886fb6c4 Allow use of function references as callbacks (#1067) 2019-12-14 20:25:17 -05:00
William Findlay
82b1649f2e Add a NERDTreeToggleVCS command to the vcs plugin (#1060) 
* NERDTreeToggleVCS

* nerdtree toggle vcs documentation

* fix function documentation

* changelog

* Update CHANGELOG.md

* Update CHANGELOG.md

* simplify toggletreevcs

* Update CHANGELOG.md
 2019-11-22 11:26:25 -05:00
Phil Runninger
8d9b8dae67 Update version number in changelog. 2019-11-13 09:00:41 -05:00
jhzn
960fda6299 Menu option, 'copy path to clipboard' is aware of VIM clipboard option (#1056) 
VIM noob here, so code might not be optimal.

My setup is as follows.
NVIM v0.5.0-95-g2e14dffbb, Linux Mint 19.2.

I have this in init.vim
```vim
set clipboard=unnamedplus
```
This enables me to share clipboard between VIM and X clipboard.

The problem is that the menu option in NERDTree copies the file path to the "* register.
This means I can't access the value in the X clipboard.
 2019-11-13 08:58:42 -05:00
Phil Runninger
fec3e57ad2 Closes #1050. Update README; don't show NERDTree if opening a session. 2019-10-22 01:21:23 -04:00
Phil Runninger
371feb7e54 Support tab-specific CWDs (#1032) 
* Change CWD when switching tabs to the tab's NERDTree root.

* Remove commented-out code.

* List the new possible value for NERDTreeChDirMode in doc.

* Add new option to select between `:cd` and `:tcd`.

* Document the new NERDTreeUseTCD option.

* Update version number in change log.
 2019-10-16 13:26:20 -04:00
Farid Ahmadian
4245517689 Add VIM built-in package management to readme (#1049) 2019-10-14 09:13:20 -04:00
Phil Runninger
926ff0ec03 Update version number instructions in PR template and change log. 2019-10-11 10:44:25 -04:00
Phil Runninger
53eef21ad6 Save/Set screen state also on WinLeave and WinEnter. (#1048) 
* Save/Set screen state also on WinLeave and WinEnter.

The particular use case here is when switching tabs with `gt` and the
NERDTrees have been mirrored.

* Update version number and change log.
 2019-10-11 01:04:06 -04:00
Phil Runninger
4fe24d3156 Wrap saveScreenState's statements in a try-catch block. (#1047) 
* Wrap saveScreenState's statements in a try-catch block.

If you're in NERDTree, and you press : to open a command line, and then
press Ctrl+F to open the [Command Line] window, you will see errors
related to switching windows while in this function. (Those commands are
not allowed while in the [Command Line] window.) The try-catch block
handles the errors, preventing their being displayed.

* Update version number in change log.
 2019-10-08 14:01:50 -04:00
Phil Runninger
2d639b70e7 Catch errors when trying to read CHANGELOG.md. (#1045) 
* Catch errors when trying to read CHANGELOG.md.

The ArchLinux package
(https://www.archlinux.org/packages/community/any/vim-nerdtree/) puts
this file in the wrong location.

* Update version number in change log.
 2019-10-01 09:17:32 -04:00
Phil Runninger
6318406f66 If file path doesn't exist, :NERDTreeFind its parent directory instead. (#1043) 
* If file path doesn't exist, :NERDTreeFind its parent directory instead.

This happens in the following scenario:
```
:edit path/new_file
:NERDTreeFind
```
Instead of an error message about an **invalid path**, this change will
now find the parent directory instead. It will not work if the new file
is **path/new_folder/new_file**, and that's OK because even vim itself
cannot handle both the new folder and the new file; `:w` won't create
the new folder.

* Update version number in change log.

* Change version change from PATCH to MINOR.
 2019-09-29 11:28:59 -04:00
Phil Runninger
496b61ead1 Give @dragonxlwang proper credit on PR #1035. 2019-09-26 08:48:57 -04:00
Phil Runninger
5af6859846 Reintroduce necessary variable mistakenly removed. (#1040) 
* Reintroduce lost variable: splitMode.

* Add a space between splitMode and "split". `verticalsplit` is invalid.

* Update version number, and add attributions (PR authors)
 2019-09-26 08:47:36 -04:00
Phil Runninger
bd744eab8d Make the behavior of window splits consistent (#1035) 
* add option to spawn split from previous window

* Update some comments and remove debugging statement.

* Simplify the code, and make it respect NERDTreeWinPos and 'splitbelow'.

* Better logic for getting NERDTree window number when not active window.

* Use common functions for splitting windows. Make splitting respect user.

The placement of split windows now respects the user's choices for the
splitright and splitbelow settings, and the g:NERDTreeWinPos variable.

* Update version number in change log.
 2019-09-24 01:19:27 -04:00
Phil Runninger
9193962ad8 Update version number in change log. 2019-09-15 14:44:09 -04:00
Chris Patuzzo
2eaedd8bf4 Fix (p)ath not displaying in the minimal menu (#1038) 
The ‘copy (p)ath to clipboard’ menu item was added
recently in this pull request:
https://github.com/scrooloose/nerdtree/pull/1002/files

However, this caused the NERDTreeMinimalMenu to
display ‘copy’ instead of ‘(p)ath’ because it was
simply using the first word of the item’s text.

This change fixes that bug by using a regex to
pick out the first word beginning with ‘(’
 2019-09-15 14:41:27 -04:00
Phil Runninger
60ec10b477 Enable events when closing NerdTree window. (#1037) 
* Enable events when closing NT window. Triggers updates in Airline.

* Update version number in change log.
 2019-09-13 10:49:26 -04:00
Phil Runninger (mac)
51fc75efdb Fix version number. I was on the wrong branch. 2019-09-09 09:40:18 -04:00
Phil Runninger (mac)
79ef87b009 Update version number in change log. 2019-09-09 05:27:48 -04:00
Phil Runninger
3d508aedce Fix the e key mapping to use netrw if desired (#1031) 
* Use :edit in openExplorer to allow NERDTreeHijackNetrw to do its thing.

* Remove commented-out code.

* Make `e` work on file nodes, opening a new NERDTree or netrw buffer.

* Update change log.
 2019-08-27 20:53:23 -04:00
Phil Runninger (mac)
9afab6257b Condense code: ternary operators vs. if-then-else blocks. 2019-08-19 14:39:17 -04:00
Phil Runninger (mac)
877f41e243 Update PR template with instructions to tag the release. 2019-08-19 09:36:50 -04:00
Phil Runninger
c4a7ca084e Add file extension and size to sorting capabilities (#1029) 
* Add ability to sort by extension and file size.

Use the tags [[extension]], [[size]], or [[-size]] in the
g:NERDTreeSortOrder list to accomplish this sorting.

* Prevent metadata tags being misused in getSortOrderIndex().

* Apply metadata tags only to files.

* Update NERDTreeSortOrder in help file.

* Update version number in CHANGELOG.
 2019-08-19 03:51:34 -04:00
Phil Runninger (mac)
184fbb6ffe Better spacing of comment in issue templates. 2019-08-09 10:27:47 -04:00
Phil Runninger (mac)
03073bb1c8 Update issue templates, moving some text into comments. 2019-08-09 10:07:14 -04:00
Phil Runninger (mac)
858b3c0004 Update PR template, moving some text into a comment. 2019-08-09 09:45:46 -04:00
Phil Runninger
ae1c0004ec Suppress events for intermediate window/tab/buffer changes (#1026) 
* Add an optional parameter to neredtree#exec to suppress all events.

The value doesn't matter, but 1 is a good choice. Its presence is an
indicator that tells NERDTree to tell Vim to ignore all events. I'm not
yet sure if there needs to be an else section to that if block. It may
be OK to allow all events to fire in the right situations.

* Supress events in all intermediate nerdtree#exec calls.

Finding all the right function calls is the key here.

* Make ignoreAll a required parameter to nerdtree#exec().

* Put required ignoreAll argument (==0) in where it's now needed.

* Ignore events when creating a new vertical split.

* Ignore events when closing NERDTree. This may need to be reverted.

* Remove debugging statment and commented-out code.

* Wrap remaining buffer/window-switching commands in nerdtree#exec().

* Update version number.

* Add a space between arguments in nerdtree#exec() calls.
 2019-08-08 22:00:35 -04:00
Phil Runninger
63c59208c1 Revert #1019 to fix nvim artifacts and flickering. (#1021) 
* Revert "Use :mode only in neovim. MacVim still needs to use :redraw! (#1019)"

This reverts commit 4ac07f52a3.

* If not Neovim, use `:redraw!` as was done before.

* Update version number.

* Fix punctuation in NERDTree Menu instructions.
 2019-07-14 15:17:56 -04:00
Phil Runninger
4ac07f52a3 Use :mode only in neovim. MacVim still needs to use :redraw! (#1019) 
* Use :mode only in neovim. MacVim still needs to use :redraw!

* Make nerdtree#redraw do both redraw and redraw! based on a parameter.

* Make bang a required parameter.

* Replace all redraw statments with call nerdtree#redraw function calls.

* Update version in change log.
 2019-07-10 09:45:58 -04:00
Phil Runninger (mac)
2f0d48d632 Update version in change log. 2019-07-07 03:53:06 -04:00
Phil Runninger
a460d6ef7f In CHANGELOG.md and PR template, make reference to PR a true HTML link. (#1017) 2019-07-07 03:50:59 -04:00
Phil Runninger
3b1a850b85 Use :mode instead of :redraw! when updating menu. (#1016) 
* Use :mode instead of :redraw! when updating screen.

In neovim, it will actually clear the whole screen, whereas, redraw!
does not.

* Update version number in change log.
 2019-07-07 03:19:17 -04:00
Phil Runninger
89a1a4355b When searching for root line num, stop at the end of the file. (#1015) 
* When searching for root line num, stop at the end of the file.

When using the following NERDTreeStatusLine, Vim would lock up and not
work anymore. The problem was that when trying to find the root line
number, the loop was continuing past the end of the file, looping
"forever". The fix was to simply stop at the end of the file.

let g:NERDTreeStatusline = "%{exists('g:NERDTreeFileNode')&&" .
      \ "has_key(g:NERDTreeFileNode.GetSelected(),'path')?" .
      \ "g:NERDTreeFileNode.GetSelected().path.getLastPathComponent(0):''}"

* Update change log.
 2019-07-04 00:21:50 -04:00
29 changed files with 1189 additions and 978 deletions
Expand all files Collapse all files

16
.github/ISSUE_TEMPLATE/bug.md vendored
View File

@@ -3,18 +3,18 @@ name: "Bug Report"
about: "NERDTree is misbehaving? Tell us about it." about: "NERDTree is misbehaving? Tell us about it."
labels: bug 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 #### 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 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 NERDTree documentation. `:h NERDTree`
- [ ] I have reviewed the [Wiki](https://github.com/scrooloose/nerdtree/wiki). - [ ] I have reviewed the [Wiki](https://github.com/scrooloose/nerdtree/wiki).

16
.github/ISSUE_TEMPLATE/question.md vendored
View File

@@ -3,18 +3,18 @@ name: "General Question"
about: "Having trouble setting up NERDTree? Need clarification on a setting? Ask your question here." about: "Having trouble setting up NERDTree? Need clarification on a setting? Ask your question here."
labels: "general question" 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 #### 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 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 NERDTree documentation. `:h NERDTree`
- [ ] I have reviewed the [Wiki](https://github.com/scrooloose/nerdtree/wiki). - [ ] I have reviewed the [Wiki](https://github.com/scrooloose/nerdtree/wiki).

22
.github/PULL_REQUEST_TEMPLATE.md vendored
View File

@@ -5,16 +5,12 @@ Closes # <!-- Issue number this PR addresses. If none, remove this line. -->
--- ---
### New Version Info ### 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 - `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 [CHANGELOG.md](https://github.com/scrooloose/nerdtree/blob/master/CHANGELOG.md), following this format/example: - `PATCH` version when you make backwards-compatible bug fixes
``` - [ ] Update [CHANGELOG.md](https://github.com/scrooloose/nerdtree/blob/master/CHANGELOG.md), following the established pattern.
#### MAJOR.MINOR... #### Collaborator's Instructions
- **.PATCH**: PR Title (Author) #PR Number - [ ] Review [CHANGELOG.md](https://github.com/scrooloose/nerdtree/blob/master/CHANGELOG.md), suggesting a different version number if necessary.
- [ ] 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...
```

15
.github/workflows/vint.yml vendored Normal file
View File

@@ -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

5
.vintrc.yaml Normal file
View File

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

279
CHANGELOG.md
View File

@@ -1,128 +1,169 @@
# Change Log # NERDTree Change Log
<!-- Introduce a new MAJOR or MINOR version with a 4-hash header.
#### 5.2... PATCH versions are listed from newest to oldest under their respective MAJOR.MINOR
- **.3**: Fix `<CR>` key map on the bookmark (lkebin) #1014 version in an unordered list. The format is:
- **.2**: Make Enter work on the `.. ( up a dir )` line (PhilRunninger) #1013 - **.PATCH**: Pull Request Title (PR Author) [PR Number](Link to PR)
- **.1**: Fix nerdtree#version() on Windows. (PhilRunninger) N/A -->
- **.0**: Expand functionality of `<CR>` mapping. (PhilRunninger) #1011 #### 6.6
#### 5.1... - **.0**: Add the ability to turn off directory arrows (PhilRunninger) [#1085](https://github.com/preservim/nerdtree/pull/1085)
- **.3**: Remove @mentions from PR template and change log. They weren't working. (PhilRunninger) #1009 #### 6.5
- **.2**: Fix NERDTree opening with the wrong size. (PhilRunninger) #1008 - **.0**: `NERDTreeToggle <start-directory>` always sets NERDTree root. (PhilRunninger) [#1083](https://github.com/preservim/nerdtree/pull/1083)
- **.1**: Update Changelog and create PR Template (PhilRunninger) #1007 #### 6.4
- **.6**: NERDTreeFind shows expected message if file doesn't exist e.g. with vim-startify (andys8). [#1081](https://github.com/preservim/nerdtree/pull/1081)
- **.5**: Ensure events are (or aren't) being ignored correctly. (PhilRunninger) [#1080](https://github.com/preservim/nerdtree/pull/1080)
- **.4**: Prevent overwriting existing files/dirs on node move. (PhilRunninger) [#1079](https://github.com/preservim/nerdtree/pull/1079)
- **.3**: Fix regex that finds keyword for minimal menu. (PhilRunninger) [#1075](https://github.com/preservim/nerdtree/pull/1075)
- **.2**: Lint vimscript, fix errors and warnings, add CI job to review PRs (Caleb Maclennan) [#1071](https://github.com/preservim/nerdtree/pull/1071)
- **.1**: Ensure backward compatibility. v:t_func is not available before Vim 8.0 (Phil Runninger)
- **.0**: Allow use of function references as callbacks (HiPhish) [#1067](https://github.com/preservim/nerdtree/pull/1067)
#### 6.3
- **.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)
#### 6.2
- **.1**: Menu option, 'copy path to clipboard' is aware of VIM clipboard option (jhzn) [#1056](https://github.com/preservim/nerdtree/pull/1056)
- **.0**: Support tab-specific CWDs (PhilRunninger) [#1032](https://github.com/preservim/nerdtree/pull/1032)
#### 6.1
- **.4**: Add VIM built-in package management to read me file. (pesarkhobeee) [#1049](https://github.com/preservim/nerdtree/pull/1049)
- **.3**: Save/Set screen state also on WinLeave and WinEnter. (PhilRunninger) [#1048](https://github.com/preservim/nerdtree/pull/1048)
- **.2**: Wrap saveScreenState's statements in a try-catch block. (PhilRunninger) [#1047](https://github.com/preservim/nerdtree/pull/1047)
- **.1**: Catch errors when trying to read CHANGELOG.md. (PhilRunninger) [#1045](https://github.com/preservim/nerdtree/pull/1045)
- **.0**: If file path doesn't exist, :NERDTreeFind its parent directory instead. (PhilRunninger) [#1043](https://github.com/preservim/nerdtree/pull/1043)
#### 6.0
- **.1**: Reintroduce necessary variable mistakenly removed. (PhilRunninger) [#1040](https://github.com/preservim/nerdtree/pull/1040)
- **.0**: Make the behavior of window splits consistent (dragonxlwang, PhilRunninger) [#1035](https://github.com/preservim/nerdtree/pull/1035)
#### 5.3
- **.3**: Fix (p)ath not displaying in the minimal menu (tuzz) [#1038](https://github.com/preservim/nerdtree/pull/1038)
- **.2**: Enable events when closing NerdTree window. (PhilRunninger) [#1037](https://github.com/preservim/nerdtree/pull/1037)
- **.1**: Fix the `e` key mapping to use netrw if desired (PhilRunninger) [#1031](https://github.com/preservim/nerdtree/pull/1031)
- **.0**: Add file extension and size to sorting capabilities (PhilRunninger) [#1029](https://github.com/preservim/nerdtree/pull/1029)
#### 5.2
- **.9**: Suppress events for intermediate window/tab/buffer changes (PhilRunninger) [#1026](https://github.com/preservim/nerdtree/pull/1026)
- **.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)
- **.7**: Use :mode only in neovim. MacVim still needs to use :redraw! (PhilRunninger) [#1019](https://github.com/preservim/nerdtree/pull/1019)
- **.6**: In CHANGELOG.md and PR template, make reference to PR a true HTML link. (PhilRunninger) [#1017](https://github.com/preservim/nerdtree/pull/1017)
- **.5**: Use `:mode` instead of `:redraw!` when updating menu. (PhilRunninger) [#1016](https://github.com/preservim/nerdtree/pull/1016)
- **.4**: When searching for root line num, stop at end of file. (PhilRunninger) [#1015](https://github.com/preservim/nerdtree/pull/1015)
- **.3**: Fix `<CR>` key map on the bookmark (lkebin) [#1014](https://github.com/preservim/nerdtree/pull/1014)
- **.2**: Make Enter work on the `.. ( up a dir )` line (PhilRunninger) [#1013](https://github.com/preservim/nerdtree/pull/1013)
- **.1**: Fix nerdtree#version() on Windows. (PhilRunninger)
- **.0**: Expand functionality of `<CR>` mapping. (PhilRunninger) [#1011](https://github.com/preservim/nerdtree/pull/1011)
#### 5.1
- **.3**: Remove @mentions from PR template and change log. They weren't working. (PhilRunninger) [#1009](https://github.com/preservim/nerdtree/pull/1009)
- **.2**: Fix NERDTree opening with the wrong size. (PhilRunninger) [#1008](https://github.com/preservim/nerdtree/pull/1008)
- **.1**: Update Changelog and create PR Template (PhilRunninger) [#1007](https://github.com/preservim/nerdtree/pull/1007)
- **.0**: Too many changes for one patch... - **.0**: Too many changes for one patch...
- Refresh a dir_node if the file wasn't found in it, and look once more. (PhilRunninger) #1005 - 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)
- Add a "copy path to clipboard" menu option (PhilRunninger) #1002 - Add a "copy path to clipboard" menu option (PhilRunninger) [#1002](https://github.com/preservim/nerdtree/pull/1002)
- Enable root refresh on "vim ." a different way than #999. (PhilRunninger) #1001 - 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)
- Fix refreshroot (PhilRunninger) #999 - Fix refreshroot (PhilRunninger) [#999](https://github.com/preservim/nerdtree/pull/999)
- Change version check to look for 703 not 730 (vhalis) #994 - Change version check to look for 703 not 730 (vhalis) [#994](https://github.com/preservim/nerdtree/pull/994)
- Change minimum vim (PhilRunninger) #991 - Change minimum vim (PhilRunninger) [#991](https://github.com/preservim/nerdtree/pull/991)
- Allow multi-character DirArrows (PhilRunninger) #985 - Allow multi-character DirArrows (PhilRunninger) [#985](https://github.com/preservim/nerdtree/pull/985)
- Remove redraw! while still clearing last message empty string. (PhilRunninger) #979 - Remove redraw! while still clearing last message empty string. (PhilRunninger) [#979](https://github.com/preservim/nerdtree/pull/979)
- fix _initChildren function value set to numChildrenCached error (terryding77) #969 - fix `_initChildren` function value set to numChildrenCached error (terryding77) [#969](https://github.com/preservim/nerdtree/pull/969)
- On Windows, do a case-insensitive comparison of paths. (PhilRunninger) #967 - On Windows, do a case-insensitive comparison of paths. (PhilRunninger) [#967](https://github.com/preservim/nerdtree/pull/967)
- Remove the "Please wait... DONE" messages. (PhilRunninger) #966 - Remove the **Please wait... DONE** messages. (PhilRunninger) [#966](https://github.com/preservim/nerdtree/pull/966)
- Smarter delimiter default (PhilRunninger) #963 - Smarter delimiter default (PhilRunninger) [#963](https://github.com/preservim/nerdtree/pull/963)
- Update directory .vimdc readme example (spencerdcarlson) #961 - Update directory .vimdc readme example (spencerdcarlson) [#961](https://github.com/preservim/nerdtree/pull/961)
- Preview bookmarks (PhilRunninger) #956 - Preview bookmarks (PhilRunninger) [#956](https://github.com/preservim/nerdtree/pull/956)
- Add new value to NERDTreeQuitOnOpen to close bookmark table (PhilRunninger) #955 - Add new value to NERDTreeQuitOnOpen to close bookmark table (PhilRunninger) [#955](https://github.com/preservim/nerdtree/pull/955)
- Add an :EditBookmarks command to edit the bookmarks file (PhilRunninger) #954 - Add an :EditBookmarks command to edit the bookmarks file (PhilRunninger) [#954](https://github.com/preservim/nerdtree/pull/954)
- Before copying, turn off &shellslash. Restore after copy is finished. (PhilRunninger) #952 - Before copying, turn off &shellslash. Restore after copy is finished. (PhilRunninger) [#952](https://github.com/preservim/nerdtree/pull/952)
- Set a maximum window size when zooming. (PhilRunninger) #950 - Set a maximum window size when zooming. (PhilRunninger) [#950](https://github.com/preservim/nerdtree/pull/950)
- Confirm the wipeout of a unsaved buffer whose file has been renamed. (PhilRunninger) #949 - Confirm the wipeout of a unsaved buffer whose file has been renamed. (PhilRunninger) [#949](https://github.com/preservim/nerdtree/pull/949)
- Escape a backslash so it can be used in a key mapping. (PhilRunninger) #948 - Escape a backslash so it can be used in a key mapping. (PhilRunninger) [#948](https://github.com/preservim/nerdtree/pull/948)
- Add a NERDTreeMinimalMenu feature (tuzz) #938 - Add a NERDTreeMinimalMenu feature (tuzz) [#938](https://github.com/preservim/nerdtree/pull/938)
- fixed root path error for windows (zcodes) #935 - fixed root path error for windows (zcodes) [#935](https://github.com/preservim/nerdtree/pull/935)
- Restore getDirChildren for use in nerdtree-project-plugin. (PhilRunninger) #929 - Restore getDirChildren for use in nerdtree-project-plugin. (PhilRunninger) [#929](https://github.com/preservim/nerdtree/pull/929)
- Document NERDTreeNodeDelimiter #912 (PhilRunninger) #926 - Document NERDTreeNodeDelimiter [#912](https://github.com/preservim/nerdtree/pull/912) (PhilRunninger) [#926](https://github.com/preservim/nerdtree/pull/926)
- Allow modification of menu keybindings (Leandros) #923 - Allow modification of menu keybindings (Leandros) [#923](https://github.com/preservim/nerdtree/pull/923)
- Add two more disqualifications for isCascadable(). (PhilRunninger) #914 - Add two more disqualifications for isCascadable(). (PhilRunninger) [#914](https://github.com/preservim/nerdtree/pull/914)
- Allow highlighting more than one flag. (kristijanhusak) #908 - Allow highlighting more than one flag. (kristijanhusak) [#908](https://github.com/preservim/nerdtree/pull/908)
- Support sorting files and directories by modification time. (PhilRunninger) #901 - Support sorting files and directories by modification time. (PhilRunninger) [#901](https://github.com/preservim/nerdtree/pull/901)
- Parse . and .. from path string with trailing slash. (PhilRunninger) #899 - Parse . and .. from path string with trailing slash. (PhilRunninger) [#899](https://github.com/preservim/nerdtree/pull/899)
- Force sort to recalculate the cached sortKey. (PhilRunninger) #898 - Force sort to recalculate the cached sortKey. (PhilRunninger) [#898](https://github.com/preservim/nerdtree/pull/898)
- Add NERDTreeRefreshRoot command (wgfm) #897 - Add NERDTreeRefreshRoot command (wgfm) [#897](https://github.com/preservim/nerdtree/pull/897)
- Call Resolve on the file's path when calling :NERDTreeFind. (PhilRunninger) #896 - Call Resolve on the file's path when calling :NERDTreeFind. (PhilRunninger) [#896](https://github.com/preservim/nerdtree/pull/896)
- Catch all errors, not just NERDTree errors. (PhilRunninger) #894 - Catch all errors, not just NERDTree errors. (PhilRunninger) [#894](https://github.com/preservim/nerdtree/pull/894)
- Fix typo in help file (lvoisin) #892 - Fix typo in help file (lvoisin) [#892](https://github.com/preservim/nerdtree/pull/892)
- Make NERDTreeCreator set the `'nolist'` option (lifecrisis) #889 - Make NERDTreeCreator set the `'nolist'` option (lifecrisis) [#889](https://github.com/preservim/nerdtree/pull/889)
- Refresh buffers after `m`, `m` operation on a folder (PhilRunninger) #888 - Refresh buffers after `m`, `m` operation on a folder (PhilRunninger) [#888](https://github.com/preservim/nerdtree/pull/888)
- Use a better arg for FINDSTR when using the m,l command in Windows. (PhilRunninger) #887 - 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 <C-J>/<C-K> motions, which currently fail with cascades (lifecrisis) #886 - Fix the <C-J>/<C-K> motions, which currently fail with cascades (lifecrisis) [#886](https://github.com/preservim/nerdtree/pull/886)
- Function "s:UI.getLineNum()" doesn't always work on cascades. (lifecrisis) #882 - Function "s:UI.getLineNum()" doesn't always work on cascades. (lifecrisis) [#882](https://github.com/preservim/nerdtree/pull/882)
- NERDTreeCWD: reset CWD if changed by NERDTreeFocus (PhilRunninger) #878 - NERDTreeCWD: reset CWD if changed by NERDTreeFocus (PhilRunninger) [#878](https://github.com/preservim/nerdtree/pull/878)
- Use <count>tabnext instead of <count>gt to allow users to remap gt. (PhilRunninger) #877 - 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 - 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 - 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 - 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 - 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 - 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 - 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 - 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 - 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 - Fix issues with sorting of nodes (PhilRunninger) [#856](https://github.com/preservim/nerdtree/pull/856)
- Better OSX detection (bubba-h57) #853 - Better OSX detection (bubba-h57) [#853](https://github.com/preservim/nerdtree/pull/853)
- Bugfix - ensure keymaps dictionary exists before using it (mnussbaum) #852 - 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 - 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 - Add code to sort mappings in quickhelp (lifecrisis) [#849](https://github.com/preservim/nerdtree/pull/849)
- Use ":clearjumps" in new NERDTree windows (lifecrisis) #844 - 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 - 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 - 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 - 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 - 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 - 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 - 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 - 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 - 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 - 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 - 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 - 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 - 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 - Fix focussing previous buffer when closing NERDTree (mrubli) [#801](https://github.com/preservim/nerdtree/pull/801)
- Update the docs for "NERDTreeStatusline" (lifecrisis) #796 - Update the docs for "NERDTreeStatusline" (lifecrisis) [#796](https://github.com/preservim/nerdtree/pull/796)
- BUGFIX: Unstable behavior in the "getPath()" method (lifecrisis) #795 - BUGFIX: Unstable behavior in the "getPath()" method (lifecrisis) [#795](https://github.com/preservim/nerdtree/pull/795)
- Revert the bugfix from pull request #785 (lifecrisis) #794 - 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 - 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 - BUGFIX: Allow ":NERDTreeFind" to reveal new files (lifecrisis) [#785](https://github.com/preservim/nerdtree/pull/785)
- Add modelines (lifecrisis) #782 - Add modelines (lifecrisis) [#782](https://github.com/preservim/nerdtree/pull/782)
- Change the type of completion used by NERDTreeFind (lifecrisis) #781 - Change the type of completion used by NERDTreeFind (lifecrisis) [#781](https://github.com/preservim/nerdtree/pull/781)
- change NERDTreeFind with args (zhenyangze) #778 - change NERDTreeFind with args (zhenyangze) [#778](https://github.com/preservim/nerdtree/pull/778)
- Style Choice: Using confirm() when deleting a bookmark (lifecrisis) #777 - Style Choice: Using confirm() when deleting a bookmark (lifecrisis) [#777](https://github.com/preservim/nerdtree/pull/777)
- remove useless substitute when `file =~# "/$"` (skyblueee) #773 - remove useless substitute when `file =~# "/$"` (skyblueee) [#773](https://github.com/preservim/nerdtree/pull/773)
- remove useless removeLeadingSpaces in _stripMarkup (skyblueee) #772 - remove useless removeLeadingSpaces in _stripMarkup (skyblueee) [#772](https://github.com/preservim/nerdtree/pull/772)
- Make the "o" mapping consistent with "x" (lifecrisis) #769 - 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 - 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 - 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 - Revert change to tab opening method (lifecrisis) [#766](https://github.com/preservim/nerdtree/pull/766)
- BUGFIX: Add back support for "b:NERDTreeRoot" (lifecrisis) #765 - 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 - 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 - Update doc with already existing mapping variables (asnr) [#699](https://github.com/preservim/nerdtree/pull/699)
- Fix the broken g:NERDTreeBookmarksSort setting (lifecrisis) #696 - Fix the broken g:NERDTreeBookmarksSort setting (lifecrisis) [#696](https://github.com/preservim/nerdtree/pull/696)
- Correct NERDTreeIgnore pattern in doc (cntoplolicon) #648 - Correct NERDTreeIgnore pattern in doc (cntoplolicon) [#648](https://github.com/preservim/nerdtree/pull/648)
- Remove empty segments when splitting path (sooth-sayer) #574 - Remove empty segments when splitting path (sooth-sayer) [#574](https://github.com/preservim/nerdtree/pull/574)
- Suppress autocmds less agressively (wincent) #578 #691 - 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. - 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() - 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. - 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 - Fixed typo in README.markdown - :Helptags -> :helptags
- Rename "primary" and "secondary" trees to "tab" and "window" trees. - Rename "primary" and "secondary" trees to "tab" and "window" trees.
- Move a bunch of buffer level variables into the NERDTree and UI classes. - 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. - Remove the old style UI - Remove `NERDTreeDirArrows` option.
- On windows default to + and ~ for expand/collapse directory symbols. - 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. - Lots more refactoring. Move a bunch of b: level vars into b:NERDTree and friends.
@@ -131,7 +172,7 @@
- Refactor the code significantly: - Refactor the code significantly:
* Break the classes out into their own files. * 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. * 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 `scope` argument to the key map API see :help NERDTreeAddKeyMap()
- add magic [[dir]] and [[file]] flags to NERDTreeIgnore - add magic [[dir]] and [[file]] flags to NERDTreeIgnore
- add support for custom path filters. See :help NERDTreeAddPathFilter() - add support for custom path filters. See :help NERDTreeAddPathFilter()

112
README.markdown
View File

@@ -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 Introduction
@@ -12,32 +12,67 @@ 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 details of this API and of other NERDTree features are described in the
included documentation. 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 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) #### [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()
```
#### [apt-vim](https://github.com/egalpin/apt-vim) #### [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). 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 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 buffers as they were intended to be used. Read this
@@ -46,53 +81,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) 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` 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: 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 .` 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. 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` 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): 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: 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 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 = ''
```

1
_config.yml Normal file
View File

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

115
autoload/nerdtree.vim
View File

@@ -1,28 +1,37 @@
if exists("g:loaded_nerdtree_autoload") if exists('g:loaded_nerdtree_autoload')
finish finish
endif endif
let g:loaded_nerdtree_autoload = 1 let g:loaded_nerdtree_autoload = 1
let s:rootNERDTreePath = resolve(expand("<sfile>:p:h:h")) let s:rootNERDTreePath = resolve(expand('<sfile>:p:h:h'))
function! nerdtree#version(...)
let l:changelog = readfile(join([s:rootNERDTreePath, "CHANGELOG.md"], nerdtree#slash())) "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' let l:text = 'Unknown'
let l:line = 0 try
while l:line <= len(l:changelog) let l:changelog = readfile(join([s:rootNERDTreePath, 'CHANGELOG.md'], nerdtree#slash()))
if l:changelog[l:line] =~ '\d\+\.\d\+' let l:line = 0
let l:text = substitute(l:changelog[l:line], '.*\(\d\+.\d\+\).*', '\1', '') while l:line <= len(l:changelog)
let l:text .= substitute(l:changelog[l:line+1], '^.\{-}\(\.\d\+\).\{-}:\(.*\)', a:0>0 ? '\1:\2' : '\1', '') if l:changelog[l:line] =~# '\d\+\.\d\+'
break let l:text = substitute(l:changelog[l:line], '.*\(\d\+.\d\+\).*', '\1', '')
endif let l:text .= substitute(l:changelog[l:line+1], '^.\{-}\(\.\d\+\).\{-}:\(.*\)', a:0>0 ? '\1:\2' : '\1', '')
let l:line += 1 break
endwhile endif
let l:line += 1
endwhile
catch
endtry
return l:text return l:text
endfunction endfunction
" SECTION: General Functions {{{1 " SECTION: General Functions {{{1
"============================================================ "============================================================
function! nerdtree#slash() "FUNCTION: nerdtree#slash() {{{2
function! nerdtree#slash() abort
if nerdtree#runningWindows() if nerdtree#runningWindows()
if exists('+shellslash') && &shellslash if exists('+shellslash') && &shellslash
@@ -37,8 +46,8 @@ endfunction
"FUNCTION: nerdtree#and(x,y) {{{2 "FUNCTION: nerdtree#and(x,y) {{{2
" Implements and() function for Vim <= 7.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) return and(a:x, a:y)
else else
let l:x = a:x let l:x = a:x
@@ -49,7 +58,6 @@ function! nerdtree#and(x,y)
if (l:x % 2) && (l:y % 2) if (l:x % 2) && (l:y % 2)
let l:result += float2nr(pow(2, l:n)) let l:result += float2nr(pow(2, l:n))
endif endif
echomsg l:x . ", " . l:y . " => " l:result
let l:x = float2nr(l:x / 2) let l:x = float2nr(l:x / 2)
let l:y = float2nr(l:y / 2) let l:y = float2nr(l:y / 2)
let l:n += 1 let l:n += 1
@@ -60,7 +68,7 @@ endfunction
"FUNCTION: nerdtree#checkForBrowse(dir) {{{2 "FUNCTION: nerdtree#checkForBrowse(dir) {{{2
"inits a window tree in the current buffer if appropriate "inits a window tree in the current buffer if appropriate
function! nerdtree#checkForBrowse(dir) function! nerdtree#checkForBrowse(dir) abort
if !isdirectory(a:dir) if !isdirectory(a:dir)
return return
endif endif
@@ -75,18 +83,18 @@ endfunction
"FUNCTION: s:reuseWin(dir) {{{2 "FUNCTION: s:reuseWin(dir) {{{2
"finds a NERDTree buffer with root of dir, and opens it. "finds a NERDTree buffer with root of dir, and opens it.
function! s:reuseWin(dir) abort 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 unlet! nt
let nt = getbufvar(i, "NERDTree") let nt = getbufvar(i, 'NERDTree')
if empty(nt) if empty(nt)
continue continue
endif endif
if nt.isWinTree() && nt.root.path.equals(path) if nt.isWinTree() && nt.root.path.equals(path)
call nt.setPreviousBuf(bufnr("#")) call nt.setPreviousBuf(bufnr('#'))
exec "buffer " . i exec 'buffer ' . i
return 1 return 1
endif endif
endfor endfor
@@ -96,17 +104,17 @@ endfunction
" FUNCTION: nerdtree#completeBookmarks(A,L,P) {{{2 " FUNCTION: nerdtree#completeBookmarks(A,L,P) {{{2
" completion function for the bookmark commands " 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 . '"') return filter(g:NERDTreeBookmark.BookmarkNames(), 'v:val =~# "^' . a:A . '"')
endfunction endfunction
"FUNCTION: nerdtree#compareNodes(dir) {{{2 "FUNCTION: nerdtree#compareNodes(dir) {{{2
function! nerdtree#compareNodes(n1, n2) function! nerdtree#compareNodes(n1, n2) abort
return a:n1.path.compareTo(a:n2.path) return a:n1.path.compareTo(a:n2.path)
endfunction endfunction
"FUNCTION: nerdtree#compareNodesBySortKey(n1, n2) {{{2 "FUNCTION: nerdtree#compareNodesBySortKey(n1, n2) {{{2
function! nerdtree#compareNodesBySortKey(n1, n2) function! nerdtree#compareNodesBySortKey(n1, n2) abort
let sortKey1 = a:n1.path.getSortKey() let sortKey1 = a:n1.path.getSortKey()
let sortKey2 = a:n2.path.getSortKey() let sortKey2 = a:n2.path.getSortKey()
let i = 0 let i = 0
@@ -114,15 +122,15 @@ function! nerdtree#compareNodesBySortKey(n1, n2)
" Compare chunks upto common length. " Compare chunks upto common length.
" If chunks have different type, the one which has " If chunks have different type, the one which has
" integer type is the lesser. " integer type is the lesser.
if type(sortKey1[i]) == type(sortKey2[i]) if type(sortKey1[i]) ==# type(sortKey2[i])
if sortKey1[i] <# sortKey2[i] if sortKey1[i] <# sortKey2[i]
return - 1 return - 1
elseif sortKey1[i] ># sortKey2[i] elseif sortKey1[i] ># sortKey2[i]
return 1 return 1
endif endif
elseif type(sortKey1[i]) == v:t_number elseif type(sortKey1[i]) ==# v:t_number
return -1 return -1
elseif type(sortKey2[i]) == v:t_number elseif type(sortKey2[i]) ==# v:t_number
return 1 return 1
endif endif
let i = i + 1 let i = i + 1
@@ -142,7 +150,7 @@ endfunction
" FUNCTION: nerdtree#deprecated(func, [msg]) {{{2 " FUNCTION: nerdtree#deprecated(func, [msg]) {{{2
" Issue a deprecation warning for a:func. If a second arg is given, use this " Issue a deprecation warning for a:func. If a second arg is given, use this
" as the deprecation message " 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' let msg = a:0 ? a:func . ' ' . a:1 : a:func . ' is deprecated'
if !exists('s:deprecationWarnings') if !exists('s:deprecationWarnings')
@@ -154,24 +162,27 @@ function! nerdtree#deprecated(func, ...)
endif endif
endfunction 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 endfunction
" FUNCTION: nerdtree#has_opt(options, name) {{{2 " 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 endfunction
" FUNCTION: nerdtree#loadClassFiles() {{{2 " FUNCTION: nerdtree#loadClassFiles() {{{2
function! nerdtree#loadClassFiles() function! nerdtree#loadClassFiles() abort
runtime lib/nerdtree/path.vim runtime lib/nerdtree/path.vim
runtime lib/nerdtree/menu_controller.vim runtime lib/nerdtree/menu_controller.vim
runtime lib/nerdtree/menu_item.vim runtime lib/nerdtree/menu_item.vim
@@ -189,7 +200,7 @@ function! nerdtree#loadClassFiles()
endfunction endfunction
" FUNCTION: nerdtree#postSourceActions() {{{2 " FUNCTION: nerdtree#postSourceActions() {{{2
function! nerdtree#postSourceActions() function! nerdtree#postSourceActions() abort
call g:NERDTreeBookmark.CacheBookmarks(1) call g:NERDTreeBookmark.CacheBookmarks(1)
call nerdtree#ui_glue#createDefaultBindings() call nerdtree#ui_glue#createDefaultBindings()
@@ -198,13 +209,13 @@ function! nerdtree#postSourceActions()
endfunction endfunction
"FUNCTION: nerdtree#runningWindows(dir) {{{2 "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 endfunction
"FUNCTION: nerdtree#runningCygwin(dir) {{{2 "FUNCTION: nerdtree#runningCygwin(dir) {{{2
function! nerdtree#runningCygwin() function! nerdtree#runningCygwin() abort
return has("win32unix") return has('win32unix')
endfunction endfunction
" SECTION: View Functions {{{1 " SECTION: View Functions {{{1
@@ -215,16 +226,16 @@ endfunction
" "
"Args: "Args:
"msg: the message to echo "msg: the message to echo
function! nerdtree#echo(msg) function! nerdtree#echo(msg) abort
redraw redraw
echomsg empty(a:msg) ? "" : ("NERDTree: " . a:msg) echomsg empty(a:msg) ? '' : ('NERDTree: ' . a:msg)
endfunction endfunction
"FUNCTION: nerdtree#echoError {{{2 "FUNCTION: nerdtree#echoError {{{2
"Wrapper for nerdtree#echo, sets the message type to errormsg for this message "Wrapper for nerdtree#echo, sets the message type to errormsg for this message
"Args: "Args:
"msg: the message to echo "msg: the message to echo
function! nerdtree#echoError(msg) function! nerdtree#echoError(msg) abort
echohl errormsg echohl errormsg
call nerdtree#echo(a:msg) call nerdtree#echo(a:msg)
echohl normal echohl normal
@@ -234,14 +245,14 @@ endfunction
"Wrapper for nerdtree#echo, sets the message type to warningmsg for this message "Wrapper for nerdtree#echo, sets the message type to warningmsg for this message
"Args: "Args:
"msg: the message to echo "msg: the message to echo
function! nerdtree#echoWarning(msg) function! nerdtree#echoWarning(msg) abort
echohl warningmsg echohl warningmsg
call nerdtree#echo(a:msg) call nerdtree#echo(a:msg)
echohl normal echohl normal
endfunction endfunction
"FUNCTION: nerdtree#renderView {{{2 "FUNCTION: nerdtree#renderView {{{2
function! nerdtree#renderView() function! nerdtree#renderView() abort
call b:NERDTree.render() call b:NERDTree.render()
endfunction endfunction

263
autoload/nerdtree/ui_glue.vim
View File

@@ -1,79 +1,80 @@
if exists("g:loaded_nerdtree_ui_glue_autoload") if exists('g:loaded_nerdtree_ui_glue_autoload')
finish finish
endif endif
let g:loaded_nerdtree_ui_glue_autoload = 1 let g:loaded_nerdtree_ui_glue_autoload = 1
" FUNCTION: nerdtree#ui_glue#createDefaultBindings() {{{1 " FUNCTION: nerdtree#ui_glue#createDefaultBindings() {{{1
function! nerdtree#ui_glue#createDefaultBindings() function! nerdtree#ui_glue#createDefaultBindings() abort
let s = '<SNR>' . s:SID() . '_' let s = '<SNR>' . s:SID() . '_'
call NERDTreeAddKeyMap({ 'key': '<MiddleMouse>', 'scope': 'all', 'callback': s . 'handleMiddleMouse' }) 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':'FileNode', 'callback': s.'customOpenFile'})
call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapCustomOpen, 'scope':'DirNode', 'callback': s."customOpenDir"}) 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':'Bookmark', 'callback': s.'customOpenBookmark'})
call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapCustomOpen, 'scope':'all', 'callback': s."activateAll" }) 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:NERDTreeMapUpdir, 'scope': 'all', 'callback': s . 'upDirCurrentRootClosed' })
call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapUpdirKeepOpen, 'scope': 'all', 'callback': s . 'upDirCurrentRootOpen' }) call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapUpdirKeepOpen, 'scope': 'all', 'callback': s . 'upDirCurrentRootOpen' })
call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapChangeRoot, 'scope': 'Node', 'callback': s . 'chRoot' }) 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:NERDTreeMapOpenInTab, 'scope': 'Node', 'callback': s . 'openInNewTab' })
call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapOpenInTabSilent, 'scope': 'Node', 'callback': s . 'openInNewTabSilent' }) call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapOpenInTabSilent, 'scope': 'Node', 'callback': s . 'openInNewTabSilent' })
call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapOpenInTab, 'scope': 'Bookmark', 'callback': s . 'openInNewTab' }) call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapOpenInTab, 'scope': 'Bookmark', 'callback': s . 'openInNewTab' })
call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapOpenInTabSilent, 'scope': 'Bookmark', 'callback': s . 'openInNewTabSilent' }) 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 endfunction
@@ -81,20 +82,20 @@ endfunction
"============================================================ "============================================================
"FUNCTION: s:customOpenFile() {{{1 "FUNCTION: s:customOpenFile() {{{1
" Open file node with the "custom" key, initially <CR>. " Open file node with the 'custom' key, initially <CR>.
function! s:customOpenFile(node) function! s:customOpenFile(node) abort
call a:node.activate(s:initCustomOpenArgs().file) call a:node.activate(s:initCustomOpenArgs().file)
endfunction endfunction
"FUNCTION: s:customOpenDir() {{{1 "FUNCTION: s:customOpenDir() {{{1
" Open directory node with the "custom" key, initially <CR>. " Open directory node with the 'custom' key, initially <CR>.
function! s:customOpenDir(node) function! s:customOpenDir(node) abort
call s:activateDirNode(a:node, s:initCustomOpenArgs().dir) call s:activateDirNode(a:node, s:initCustomOpenArgs().dir)
endfunction endfunction
"FUNCTION: s:customOpenBookmark() {{{1 "FUNCTION: s:customOpenBookmark() {{{1
" Open bookmark node with the "custom" key, initially <CR>. " Open bookmark node with the 'custom' key, initially <CR>.
function! s:customOpenBookmark(node) function! s:customOpenBookmark(node) abort
if a:node.path.isDirectory if a:node.path.isDirectory
call a:node.activate(b:NERDTree, s:initCustomOpenArgs().dir) call a:node.activate(b:NERDTree, s:initCustomOpenArgs().dir)
else else
@@ -104,22 +105,22 @@ endfunction
"FUNCTION: s:initCustomOpenArgs() {{{1 "FUNCTION: s:initCustomOpenArgs() {{{1
" Make sure NERDTreeCustomOpenArgs has needed keys " Make sure NERDTreeCustomOpenArgs has needed keys
function! s:initCustomOpenArgs() function! s:initCustomOpenArgs() abort
let g:NERDTreeCustomOpenArgs = get(g:, 'NERDTreeCustomOpenArgs', {}) let g:NERDTreeCustomOpenArgs = get(g:, 'NERDTreeCustomOpenArgs', {})
return extend(g:NERDTreeCustomOpenArgs, {'file':{'reuse': 'all', 'where': 'p'}, 'dir':{}}, 'keep') return extend(g:NERDTreeCustomOpenArgs, {'file':{'reuse': 'all', 'where': 'p'}, 'dir':{}}, 'keep')
endfunction endfunction
"FUNCTION: s:activateAll() {{{1 "FUNCTION: s:activateAll() {{{1
"handle the user activating the updir line "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) return nerdtree#ui_glue#upDir(0)
endif endif
endfunction endfunction
" FUNCTION: s:activateDirNode(directoryNode, options) {{{1 " FUNCTION: s:activateDirNode(directoryNode, options) {{{1
" Open a directory with optional options " Open a directory with optional options
function! s:activateDirNode(directoryNode, ...) function! s:activateDirNode(directoryNode, ...) abort
if a:directoryNode.isRoot() && a:directoryNode.isOpen if a:directoryNode.isRoot() && a:directoryNode.isOpen
call nerdtree#echo('cannot close tree root') call nerdtree#echo('cannot close tree root')
@@ -131,21 +132,21 @@ endfunction
"FUNCTION: s:activateFileNode() {{{1 "FUNCTION: s:activateFileNode() {{{1
"handle the user activating a tree node "handle the user activating a tree node
function! s:activateFileNode(node) function! s:activateFileNode(node) abort
call a:node.activate({'reuse': 'all', 'where': 'p'}) call a:node.activate({'reuse': 'all', 'where': 'p'})
endfunction endfunction
"FUNCTION: s:activateBookmark(bookmark) {{{1 "FUNCTION: s:activateBookmark(bookmark) {{{1
"handle the user activating a bookmark "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'} : {}) call a:bm.activate(b:NERDTree, !a:bm.path.isDirectory ? {'where': 'p'} : {})
endfunction endfunction
" FUNCTION: nerdtree#ui_glue#bookmarkNode(name) {{{1 " FUNCTION: nerdtree#ui_glue#bookmarkNode(name) {{{1
" Associate the current node with the given name " Associate the current node with the given name
function! nerdtree#ui_glue#bookmarkNode(...) function! nerdtree#ui_glue#bookmarkNode(...) abort
let currentNode = g:NERDTreeFileNode.GetSelected() let currentNode = g:NERDTreeFileNode.GetSelected()
if currentNode != {} if currentNode !=# {}
let name = a:1 let name = a:1
if empty(name) if empty(name)
let name = currentNode.path.getLastPathComponent(0) let name = currentNode.path.getLastPathComponent(0)
@@ -154,39 +155,39 @@ function! nerdtree#ui_glue#bookmarkNode(...)
call currentNode.bookmark(name) call currentNode.bookmark(name)
call b:NERDTree.render() call b:NERDTree.render()
catch /^NERDTree.IllegalBookmarkNameError/ catch /^NERDTree.IllegalBookmarkNameError/
call nerdtree#echo("bookmark names must not contain spaces") call nerdtree#echo('bookmark names must not contain spaces')
endtry endtry
else else
call nerdtree#echo("select a node first") call nerdtree#echo('select a node first')
endif endif
endfunction endfunction
" FUNCTION: s:chCwd(node) {{{1 " FUNCTION: s:chCwd(node) {{{1
function! s:chCwd(node) function! s:chCwd(node) abort
try try
call a:node.path.changeToDir() call a:node.path.changeToDir()
catch /^NERDTree.PathChangeError/ catch /^NERDTree.PathChangeError/
call nerdtree#echoWarning("could not change cwd") call nerdtree#echoWarning('could not change cwd')
endtry endtry
endfunction endfunction
" FUNCTION: s:chRoot(node) {{{1 " FUNCTION: s:chRoot(node) {{{1
" changes the current root to the selected one " changes the current root to the selected one
function! s:chRoot(node) function! s:chRoot(node) abort
call b:NERDTree.changeRoot(a:node) call b:NERDTree.changeRoot(a:node)
endfunction endfunction
" FUNCTION: s:nerdtree#ui_glue#chRootCwd() {{{1 " FUNCTION: s:nerdtree#ui_glue#chRootCwd() {{{1
" Change the NERDTree root to match the current working directory. " Change the NERDTree root to match the current working directory.
function! nerdtree#ui_glue#chRootCwd() function! nerdtree#ui_glue#chRootCwd() abort
NERDTreeCWD NERDTreeCWD
endfunction endfunction
" FUNCTION: nnerdtree#ui_glue#clearBookmarks(bookmarks) {{{1 " FUNCTION: nnerdtree#ui_glue#clearBookmarks(bookmarks) {{{1
function! nerdtree#ui_glue#clearBookmarks(bookmarks) function! nerdtree#ui_glue#clearBookmarks(bookmarks) abort
if a:bookmarks ==# '' if a:bookmarks ==# ''
let currentNode = g:NERDTreeFileNode.GetSelected() let currentNode = g:NERDTreeFileNode.GetSelected()
if currentNode != {} if currentNode !=# {}
call currentNode.clearBookmarks() call currentNode.clearBookmarks()
endif endif
else else
@@ -201,7 +202,7 @@ endfunction
" FUNCTION: s:closeChildren(node) {{{1 " FUNCTION: s:closeChildren(node) {{{1
" closes all childnodes of the current node " closes all childnodes of the current node
function! s:closeChildren(node) function! s:closeChildren(node) abort
call a:node.closeChildren() call a:node.closeChildren()
call b:NERDTree.render() call b:NERDTree.render()
call a:node.putCursorHere(0, 0) call a:node.putCursorHere(0, 0)
@@ -209,7 +210,7 @@ endfunction
" FUNCTION: s:closeCurrentDir(node) {{{1 " FUNCTION: s:closeCurrentDir(node) {{{1
" Close the parent directory of the current node. " Close the parent directory of the current node.
function! s:closeCurrentDir(node) function! s:closeCurrentDir(node) abort
if a:node.isRoot() if a:node.isRoot()
call nerdtree#echo('cannot close parent of tree root') call nerdtree#echo('cannot close parent of tree root')
@@ -234,30 +235,30 @@ endfunction
" FUNCTION: s:closeTreeWindow() {{{1 " FUNCTION: s:closeTreeWindow() {{{1
" close the tree window " 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 else
if winnr("$") > 1 if winnr('$') > 1
call g:NERDTree.Close() call g:NERDTree.Close()
else else
call nerdtree#echo("Cannot close last window") call nerdtree#echo('Cannot close last window')
endif endif
endif endif
endfunction endfunction
" FUNCTION: s:deleteBookmark(bookmark) {{{1 " FUNCTION: s:deleteBookmark(bookmark) {{{1
" Prompt the user to confirm the deletion of the selected bookmark. " 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" let l:choices = "&Yes\n&No"
echo | redraw echo | redraw
let l:selection = confirm(l:message, l:choices, 1, 'Warning') let l:selection = confirm(l:message, l:choices, 1, 'Warning')
if l:selection != 1 if l:selection !=# 1
call nerdtree#echo('bookmark not deleted') call nerdtree#echo('bookmark not deleted')
return return
endif endif
@@ -274,14 +275,14 @@ endfunction
" FUNCTION: s:displayHelp() {{{1 " FUNCTION: s:displayHelp() {{{1
" toggles the help display " toggles the help display
function! s:displayHelp() function! s:displayHelp() abort
call b:NERDTree.ui.toggleHelp() call b:NERDTree.ui.toggleHelp()
call b:NERDTree.render() call b:NERDTree.render()
call b:NERDTree.ui.centerView() call b:NERDTree.ui.centerView()
endfunction endfunction
" FUNCTION: s:findAndRevealPath(pathStr) {{{1 " 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:pathStr = !empty(a:pathStr) ? a:pathStr : expand('%:p')
if empty(l:pathStr) if empty(l:pathStr)
@@ -289,6 +290,10 @@ function! s:findAndRevealPath(pathStr)
return return
endif endif
if !filereadable(l:pathStr)
let l:pathStr = fnamemodify(l:pathStr, ':h')
endif
try try
let l:pathStr = g:NERDTreePath.Resolve(l:pathStr) let l:pathStr = g:NERDTreePath.Resolve(l:pathStr)
let l:pathObj = g:NERDTreePath.New(l:pathStr) let l:pathObj = g:NERDTreePath.New(l:pathStr)
@@ -329,15 +334,15 @@ endfunction
"FUNCTION: s:handleLeftClick() {{{1 "FUNCTION: s:handleLeftClick() {{{1
"Checks if the click should open the current node "Checks if the click should open the current node
function! s:handleLeftClick() function! s:handleLeftClick() abort
let currentNode = g:NERDTreeFileNode.GetSelected() let currentNode = g:NERDTreeFileNode.GetSelected()
if currentNode != {} if currentNode !=# {}
"the dir arrows are multibyte chars, and vim's string functions only "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 "deal with single bytes - so split the line up with the hack below and
"take the line substring manually "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) for i in range(0,len(line)-1)
let startToCur .= line[i] let startToCur .= line[i]
endfor endfor
@@ -364,7 +369,7 @@ function! s:handleLeftClick()
endfunction endfunction
" FUNCTION: s:handleMiddleMouse() {{{1 " FUNCTION: s:handleMiddleMouse() {{{1
function! s:handleMiddleMouse() function! s:handleMiddleMouse() abort
" A middle mouse click does not automatically position the cursor as one " A middle mouse click does not automatically position the cursor as one
" would expect. Forcing the execution of a regular left mouse click here " would expect. Forcing the execution of a regular left mouse click here
@@ -387,17 +392,17 @@ endfunction
" FUNCTION: nerdtree#ui_glue#invokeKeyMap(key) {{{1 " FUNCTION: nerdtree#ui_glue#invokeKeyMap(key) {{{1
"this is needed since I cant figure out how to invoke dict functions from a "this is needed since I cant figure out how to invoke dict functions from a
"key map "key map
function! nerdtree#ui_glue#invokeKeyMap(key) function! nerdtree#ui_glue#invokeKeyMap(key) abort
call g:NERDTreeKeyMap.Invoke(a:key) call g:NERDTreeKeyMap.Invoke(a:key)
endfunction endfunction
" FUNCTION: s:jumpToFirstChild(node) {{{1 " FUNCTION: s:jumpToFirstChild(node) {{{1
function! s:jumpToFirstChild(node) function! s:jumpToFirstChild(node) abort
call s:jumpToChild(a:node, 0) call s:jumpToChild(a:node, 0)
endfunction endfunction
" FUNCTION: s:jumpToLastChild(node) {{{1 " FUNCTION: s:jumpToLastChild(node) {{{1
function! s:jumpToLastChild(node) function! s:jumpToLastChild(node) abort
call s:jumpToChild(a:node, 1) call s:jumpToChild(a:node, 1)
endfunction endfunction
@@ -407,7 +412,7 @@ endfunction
" Args: " Args:
" node: the node on which the cursor currently sits " node: the node on which the cursor currently sits
" last: 1 (true) if jumping to last child, 0 (false) if jumping to first " 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 let l:node = a:node.path.isDirectory ? a:node.getCascadeRoot() : a:node
if l:node.isRoot() if l:node.isRoot()
@@ -426,7 +431,7 @@ endfunction
" FUNCTION: s:jumpToParent(node) {{{1 " FUNCTION: s:jumpToParent(node) {{{1
" Move the cursor to the parent of the specified node. For a cascade, move to " 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. " 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 let l:node = a:node.path.isDirectory ? a:node.getCascadeRoot() : a:node
if l:node.isRoot() if l:node.isRoot()
@@ -444,18 +449,18 @@ endfunction
" FUNCTION: s:jumpToRoot() {{{1 " FUNCTION: s:jumpToRoot() {{{1
" moves the cursor to the root node " moves the cursor to the root node
function! s:jumpToRoot() function! s:jumpToRoot() abort
call b:NERDTree.root.putCursorHere(1, 0) call b:NERDTree.root.putCursorHere(1, 0)
call b:NERDTree.ui.centerView() call b:NERDTree.ui.centerView()
endfunction endfunction
" FUNCTION: s:jumpToNextSibling(node) {{{1 " FUNCTION: s:jumpToNextSibling(node) {{{1
function! s:jumpToNextSibling(node) function! s:jumpToNextSibling(node) abort
call s:jumpToSibling(a:node, 1) call s:jumpToSibling(a:node, 1)
endfunction endfunction
" FUNCTION: s:jumpToPrevSibling(node) {{{1 " FUNCTION: s:jumpToPrevSibling(node) {{{1
function! s:jumpToPrevSibling(node) function! s:jumpToPrevSibling(node) abort
call s:jumpToSibling(a:node, 0) call s:jumpToSibling(a:node, 0)
endfunction endfunction
@@ -465,7 +470,7 @@ endfunction
" Args: " Args:
" node: the node on which the cursor currently sits " node: the node on which the cursor currently sits
" forward: 0 to jump to previous sibling, 1 to jump to next sibling " 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:node = a:node.path.isDirectory ? a:node.getCascadeRoot() : a:node
let l:sibling = l:node.findSibling(a:forward) let l:sibling = l:node.findSibling(a:forward)
@@ -479,8 +484,8 @@ endfunction
" FUNCTION: nerdtree#ui_glue#openBookmark(name) {{{1 " FUNCTION: nerdtree#ui_glue#openBookmark(name) {{{1
" Open the Bookmark that has the specified name. This function provides the " 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 try
let l:bookmark = g:NERDTreeBookmark.BookmarkFor(a:name) let l:bookmark = g:NERDTreeBookmark.BookmarkFor(a:name)
catch /^NERDTree.BookmarkNotFoundError/ catch /^NERDTree.BookmarkNotFoundError/
@@ -495,42 +500,42 @@ function! nerdtree#ui_glue#openBookmark(name)
endfunction endfunction
" FUNCTION: s:openHSplit(target) {{{1 " FUNCTION: s:openHSplit(target) {{{1
function! s:openHSplit(target) function! s:openHSplit(target) abort
call a:target.activate({'where': 'h'}) call a:target.activate({'where': 'h'})
endfunction endfunction
" FUNCTION: s:openVSplit(target) {{{1 " FUNCTION: s:openVSplit(target) {{{1
function! s:openVSplit(target) function! s:openVSplit(target) abort
call a:target.activate({'where': 'v'}) call a:target.activate({'where': 'v'})
endfunction endfunction
" FUNCTION: s:openExplorer(node) {{{1 " FUNCTION: s:openExplorer(node) {{{1
function! s:openExplorer(node) function! s:openExplorer(node) abort
call a:node.openExplorer() call a:node.openExplorer()
endfunction endfunction
" FUNCTION: s:openInNewTab(target) {{{1 " 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'}) let l:opener = g:NERDTreeOpener.New(a:target.path, {'where': 't'})
call l:opener.open(a:target) call l:opener.open(a:target)
endfunction endfunction
" FUNCTION: s:openInNewTabSilent(target) {{{1 " 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}) let l:opener = g:NERDTreeOpener.New(a:target.path, {'where': 't', 'stay': 1})
call l:opener.open(a:target) call l:opener.open(a:target)
endfunction endfunction
" FUNCTION: s:openNodeRecursively(node) {{{1 " 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 a:node.openRecursively()
call b:NERDTree.render() call b:NERDTree.render()
call nerdtree#echo("") call nerdtree#echo('')
endfunction endfunction
" FUNCTION: s:previewBookmark(bookmark) {{{1 " FUNCTION: s:previewBookmark(bookmark) {{{1
function! s:previewBookmark(bookmark) function! s:previewBookmark(bookmark) abort
if a:bookmark.path.isDirectory if a:bookmark.path.isDirectory
execute 'NERDTreeFind '.a:bookmark.path.str() execute 'NERDTreeFind '.a:bookmark.path.str()
else else
@@ -539,65 +544,65 @@ function! s:previewBookmark(bookmark)
endfunction endfunction
"FUNCTION: s:previewNodeCurrent(node) {{{1 "FUNCTION: s:previewNodeCurrent(node) {{{1
function! s:previewNodeCurrent(node) function! s:previewNodeCurrent(node) abort
call a:node.open({'stay': 1, 'where': 'p', 'keepopen': 1}) call a:node.open({'stay': 1, 'where': 'p', 'keepopen': 1})
endfunction endfunction
"FUNCTION: s:previewNodeHSplit(node) {{{1 "FUNCTION: s:previewNodeHSplit(node) {{{1
function! s:previewNodeHSplit(node) function! s:previewNodeHSplit(node) abort
call a:node.open({'stay': 1, 'where': 'h', 'keepopen': 1}) call a:node.open({'stay': 1, 'where': 'h', 'keepopen': 1})
endfunction endfunction
"FUNCTION: s:previewNodeVSplit(node) {{{1 "FUNCTION: s:previewNodeVSplit(node) {{{1
function! s:previewNodeVSplit(node) function! s:previewNodeVSplit(node) abort
call a:node.open({'stay': 1, 'where': 'v', 'keepopen': 1}) call a:node.open({'stay': 1, 'where': 'v', 'keepopen': 1})
endfunction endfunction
" FUNCTION: nerdtree#ui_glue#revealBookmark(name) {{{1 " FUNCTION: nerdtree#ui_glue#revealBookmark(name) {{{1
" put the cursor on the node associate with the given name " 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 try
let targetNode = g:NERDTreeBookmark.GetNodeForName(a:name, 0, b:NERDTree) let targetNode = g:NERDTreeBookmark.GetNodeForName(a:name, 0, b:NERDTree)
call targetNode.putCursorHere(0, 1) call targetNode.putCursorHere(0, 1)
catch /^NERDTree.BookmarkNotFoundError/ catch /^NERDTree.BookmarkNotFoundError/
call nerdtree#echo("Bookmark isnt cached under the current root") call nerdtree#echo('Bookmark isnt cached under the current root')
endtry endtry
endfunction endfunction
" FUNCTION: s:refreshRoot() {{{1 " FUNCTION: s:refreshRoot() {{{1
" Reloads the current root. All nodes below this will be lost and the root dir " Reloads the current root. All nodes below this will be lost and the root dir
" will be reloaded. " will be reloaded.
function! s:refreshRoot() function! s:refreshRoot() abort
if !g:NERDTree.IsOpen() if !g:NERDTree.IsOpen()
return return
endif 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() 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.root.refresh()
call b:NERDTree.render() call b:NERDTree.render()
redraw redraw
call nerdtree#exec(l:curWin . "wincmd w") call nerdtree#exec(l:curWin . 'wincmd w', 1)
call nerdtree#echo("") call nerdtree#echo('')
endfunction endfunction
" FUNCTION: s:refreshCurrent(node) {{{1 " FUNCTION: s:refreshCurrent(node) {{{1
" refreshes the root for the current node " refreshes the root for the current node
function! s:refreshCurrent(node) function! s:refreshCurrent(node) abort
let node = a:node let node = a:node
if !node.path.isDirectory if !node.path.isDirectory
let node = node.parent let node = node.parent
endif 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 node.refresh()
call b:NERDTree.render() call b:NERDTree.render()
call nerdtree#echo("") call nerdtree#echo('')
endfunction endfunction
" FUNCTION: nerdtree#ui_glue#setupCommands() {{{1 " 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 NERDTree :call g:NERDTreeCreator.CreateTabTree('<args>')
command! -n=? -complete=dir -bar NERDTreeToggle :call g:NERDTreeCreator.ToggleTabTree('<args>') command! -n=? -complete=dir -bar NERDTreeToggle :call g:NERDTreeCreator.ToggleTabTree('<args>')
command! -n=0 -bar NERDTreeClose :call g:NERDTree.Close() command! -n=0 -bar NERDTreeClose :call g:NERDTree.Close()
@@ -610,42 +615,42 @@ function! nerdtree#ui_glue#setupCommands()
endfunction endfunction
" Function: s:SID() {{{1 " 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$') let s:sid = matchstr(expand('<sfile>'), '<SNR>\zs\d\+\ze_SID$')
endif endif
return s:sid return s:sid
endfun endfun
" FUNCTION: s:showMenu(node) {{{1 " FUNCTION: s:showMenu(node) {{{1
function! s:showMenu(node) function! s:showMenu(node) abort
let mc = g:NERDTreeMenuController.New(g:NERDTreeMenuItem.AllEnabled()) let mc = g:NERDTreeMenuController.New(g:NERDTreeMenuItem.AllEnabled())
call mc.showMenu() call mc.showMenu()
endfunction endfunction
" FUNCTION: s:toggleIgnoreFilter() {{{1 " FUNCTION: s:toggleIgnoreFilter() {{{1
function! s:toggleIgnoreFilter() function! s:toggleIgnoreFilter() abort
call b:NERDTree.ui.toggleIgnoreFilter() call b:NERDTree.ui.toggleIgnoreFilter()
endfunction endfunction
" FUNCTION: s:toggleShowBookmarks() {{{1 " FUNCTION: s:toggleShowBookmarks() {{{1
function! s:toggleShowBookmarks() function! s:toggleShowBookmarks() abort
call b:NERDTree.ui.toggleShowBookmarks() call b:NERDTree.ui.toggleShowBookmarks()
endfunction endfunction
" FUNCTION: s:toggleShowFiles() {{{1 " FUNCTION: s:toggleShowFiles() {{{1
function! s:toggleShowFiles() function! s:toggleShowFiles() abort
call b:NERDTree.ui.toggleShowFiles() call b:NERDTree.ui.toggleShowFiles()
endfunction endfunction
" FUNCTION: s:toggleShowHidden() {{{1 " FUNCTION: s:toggleShowHidden() {{{1
" toggles the display of hidden files " toggles the display of hidden files
function! s:toggleShowHidden() function! s:toggleShowHidden() abort
call b:NERDTree.ui.toggleShowHidden() call b:NERDTree.ui.toggleShowHidden()
endfunction endfunction
" FUNCTION: s:toggleZoom() {{{1 " FUNCTION: s:toggleZoom() {{{1
function! s:toggleZoom() function! s:toggleZoom() abort
call b:NERDTree.ui.toggleZoom() call b:NERDTree.ui.toggleZoom()
endfunction endfunction
@@ -655,7 +660,7 @@ endfunction
" Args: " Args:
" preserveState: if 1, the current root is left open when the new tree is " preserveState: if 1, the current root is left open when the new tree is
" rendered; if 0, the current root node is closed " rendered; if 0, the current root node is closed
function! nerdtree#ui_glue#upDir(preserveState) function! nerdtree#ui_glue#upDir(preserveState) abort
try try
call b:NERDTree.root.cacheParent() call b:NERDTree.root.cacheParent()
@@ -679,12 +684,12 @@ function! nerdtree#ui_glue#upDir(preserveState)
endfunction endfunction
" FUNCTION: s:upDirCurrentRootOpen() {{{1 " FUNCTION: s:upDirCurrentRootOpen() {{{1
function! s:upDirCurrentRootOpen() function! s:upDirCurrentRootOpen() abort
call nerdtree#ui_glue#upDir(1) call nerdtree#ui_glue#upDir(1)
endfunction endfunction
" FUNCTION: s:upDirCurrentRootClosed() {{{1 " FUNCTION: s:upDirCurrentRootClosed() {{{1
function! s:upDirCurrentRootClosed() function! s:upDirCurrentRootClosed() abort
call nerdtree#ui_glue#upDir(0) call nerdtree#ui_glue#upDir(0)
endfunction endfunction

98
doc/NERDTree.txt
View File

@@ -122,8 +122,17 @@ The following features and functionality are provided by the NERDTree:
:NERDTreeToggle [<start-directory> | <bookmark>] *:NERDTreeToggle* :NERDTreeToggle [<start-directory> | <bookmark>] *:NERDTreeToggle*
If a NERDTree already exists for this tab, it is reopened and rendered 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* :NERDTreeFocus *:NERDTreeFocus*
Opens (or reopens) the NERDTree if it is not currently visible; Opens (or reopens) the NERDTree if it is not currently visible;
@@ -849,9 +858,17 @@ above nodes would then be sorted like this: >
z110.txt 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. Default: 0.
Use this setting to tell the script when (if at all) to change the current Use this setting to tell the script when (if at all) to change the current
@@ -871,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 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. 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* *NERDTreeHighlightCursorline*
Values: 0 or 1. Values: 0 or 1.
@@ -980,7 +1000,6 @@ then (to single click activate it) you must click somewhere in
------------------------------------------------------------------------------ ------------------------------------------------------------------------------
*NERDTreeQuitOnOpen* *NERDTreeQuitOnOpen*
Values: 0,1,2 or 3. Values: 0,1,2 or 3.
Default: 0 Default: 0
@@ -1043,28 +1062,31 @@ window. Use one of the follow lines for this setting: >
Values: a list of regular expressions. Values: a list of regular expressions.
Default: ['\/$', '*', '\.swp$', '\.bak$', '\~$'] 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: > For example, if the setting is: >
['\.vim$', '\.c$', '\.h$', '*', 'foobar'] ['\.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 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 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. 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. 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. After this sorting is done, the files in each group are sorted alphabetically.
@@ -1072,20 +1094,20 @@ Examples: >
(1) ['*', '\/$'] (1) ['*', '\/$']
(2) [] (2) []
(3) ['\/$', '\.rb$', '\.php$', '*', '\.swp$', '\.bak$', '\~$'] (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. 1. Directories will appear last, everything else will appear above.
2. Everything will simply appear in alphabetical order. 2. Everything will simply appear in alphabetical order.
3. Dirs will appear first, then ruby and php. Swap files, bak files and vim 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. 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* *NERDTreeStatusline*
@@ -1201,13 +1223,19 @@ Values: Any single character.
Defaults: Windows: ~ and + Others: ▾ and ▸ Defaults: Windows: ~ and + Others: ▾ and ▸
These characters indicate whether a directory is collapsible or expandable. 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 NERDTreeDirArrowExpandable=">"
let NERDTreeDirArrowCollapsible="v" 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* *NERDTreeNodeDelimiter*
Values: Any single character. Values: Any single character.
@@ -1217,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 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, characters that are otherwise used in the NERDTree, such as square brackets,
braces, trailing asterisk, and leading space. For more details, see the 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 The default value of this variable depends on the features compiled into your
vim and the values of |NERDTreeDirArrowCollapsible| and vim and the values of |NERDTreeDirArrowCollapsible| and
@@ -1294,6 +1322,10 @@ following code conventions are used:
See this blog post for more details: See this blog post for more details:
http://got-ravings.blogspot.com/2008/09/vim-pr0n-prototype-based-objects.html 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* 4.1. Key map API *NERDTreeKeymapAPI*
@@ -1473,11 +1505,11 @@ in the fridge for later ;)
Martyzilla recruited two other unwitting accomplices to become his minions in 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 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 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. 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: Title Credit:
* http://ascii.co.uk/art/tree * http://ascii.co.uk/art/tree

44
lib/nerdtree/bookmark.vim
View File

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

66
lib/nerdtree/creator.vim
View File

@@ -82,20 +82,20 @@ function! s:Creator.createWindowTree(dir)
try try
let path = g:NERDTreePath.New(a:dir) let path = g:NERDTreePath.New(a:dir)
catch /^NERDTree.InvalidArgumentsError/ catch /^NERDTree.InvalidArgumentsError/
call nerdtree#echo("Invalid directory name:" . a:name) call nerdtree#echo('Invalid directory name:' . a:dir)
return return
endtry endtry
"we want the directory buffer to disappear when we do the :edit below "we want the directory buffer to disappear when we do the :edit below
setlocal bufhidden=wipe setlocal bufhidden=wipe
let previousBuf = expand("#") let previousBuf = expand('#')
"we need a unique name for each window tree buffer to ensure they are "we need a unique name for each window tree buffer to ensure they are
"all independent "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) let b:NERDTree._previousBuf = bufnr(previousBuf)
call self._setCommonBufOptions() call self._setCommonBufOptions()
@@ -109,7 +109,7 @@ function! s:Creator._createNERDTree(path, type)
let b:NERDTree = g:NERDTree.New(a:path, a:type) let b:NERDTree = g:NERDTree.New(a:path, a:type)
" TODO: This assignment is kept for compatibility reasons. Many other " 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. " assignment in the future.
let b:NERDTreeRoot = b:NERDTree.root let b:NERDTreeRoot = b:NERDTree.root
@@ -126,9 +126,9 @@ endfunction
function! s:Creator.createMirror() function! s:Creator.createMirror()
"get the names off all the nerd tree buffers "get the names off all the nerd tree buffers
let treeBufNames = [] let treeBufNames = []
for i in range(1, tabpagenr("$")) for i in range(1, tabpagenr('$'))
let nextName = self._tabpagevar(i, 'NERDTreeBufName') 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) call add(treeBufNames, nextName)
endif endif
endfor endfor
@@ -140,7 +140,7 @@ function! s:Creator.createMirror()
let i = 0 let i = 0
while i < len(treeBufNames) while i < len(treeBufNames)
let bufName = treeBufNames[i] 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 options[i+1 . '. ' . treeRoot.path.str() . ' (buf name: ' . bufName . ')'] = bufName
let i = i + 1 let i = i + 1
endwhile endwhile
@@ -148,7 +148,7 @@ function! s:Creator.createMirror()
"work out which tree to mirror, if there is more than 1 then ask the user "work out which tree to mirror, if there is more than 1 then ask the user
let bufferName = '' let bufferName = ''
if len(keys(options)) > 1 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 choices = extend(choices, sort(keys(options)))
let choice = inputlist(choices) let choice = inputlist(choices)
if choice < 1 || choice > len(options) || choice ==# '' if choice < 1 || choice > len(options) || choice ==# ''
@@ -159,7 +159,7 @@ function! s:Creator.createMirror()
elseif len(keys(options)) ==# 1 elseif len(keys(options)) ==# 1
let bufferName = values(options)[0] let bufferName = values(options)[0]
else else
call nerdtree#echo("No trees to mirror") call nerdtree#echo('No trees to mirror')
return return
endif endif
@@ -227,7 +227,7 @@ endfunction
" FUNCTION: s:Creator._nextBufferNumber() {{{1 " FUNCTION: s:Creator._nextBufferNumber() {{{1
" the number to add to the nerd tree buffer name to make the buf name unique " the number to add to the nerd tree buffer name to make the buf name unique
function! s:Creator._nextBufferNumber() function! s:Creator._nextBufferNumber()
if !exists("s:Creator._NextBufNum") if !exists('s:Creator._NextBufNum')
let s:Creator._NextBufNum = 1 let s:Creator._NextBufNum = 1
else else
let s:Creator._NextBufNum += 1 let s:Creator._NextBufNum += 1
@@ -254,7 +254,7 @@ function! s:Creator._pathForString(str)
try try
let path = g:NERDTreePath.New(dir) let path = g:NERDTreePath.New(dir)
catch /^NERDTree.InvalidArgumentsError/ 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 {} return {}
endtry endtry
endif endif
@@ -274,7 +274,7 @@ function! s:Creator._removeTreeBufForTab()
"nerdtree buf may be mirrored/displayed elsewhere "nerdtree buf may be mirrored/displayed elsewhere
if self._isBufHidden(buf) if self._isBufHidden(buf)
exec "bwipeout " . buf exec 'bwipeout ' . buf
endif endif
endif endif
@@ -300,11 +300,11 @@ function! s:Creator._setCommonBufOptions()
setlocal nowrap setlocal nowrap
if g:NERDTreeShowLineNumbers if g:NERDTreeShowLineNumbers
setlocal nu setlocal number
else else
setlocal nonu setlocal nonumber
if v:version >= 703 if v:version >= 703
setlocal nornu setlocal norelativenumber
endif endif
endif endif
@@ -330,17 +330,20 @@ endfunction
" FUNCTION: s:Creator._tabpagevar(tabnr, var) {{{1 " FUNCTION: s:Creator._tabpagevar(tabnr, var) {{{1
function! s:Creator._tabpagevar(tabnr, var) function! s:Creator._tabpagevar(tabnr, var)
let currentTab = tabpagenr() 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 return v
endfunction endfunction
@@ -352,17 +355,20 @@ function! s:Creator.ToggleTabTree(dir)
endfunction endfunction
" FUNCTION: s:Creator.toggleTabTree(dir) {{{1 " 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: " 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) function! s:Creator.toggleTabTree(dir)
if g:NERDTree.ExistsForTab() if g:NERDTree.ExistsForTab()
if !g:NERDTree.IsOpen() if !g:NERDTree.IsOpen()
call self._createTreeWin() call self._createTreeWin()
if !&hidden if !empty(a:dir)
call self.createTabTree(a:dir)
elseif !&hidden
call b:NERDTree.render() call b:NERDTree.render()
endif endif
call b:NERDTree.ui.restoreScreenState() call b:NERDTree.ui.restoreScreenState()

4
lib/nerdtree/flag_set.vim
View File

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

24
lib/nerdtree/key_map.vim
View File

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

47
lib/nerdtree/menu_controller.vim
View File

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

14
lib/nerdtree/menu_item.vim
View File

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

51
lib/nerdtree/nerdtree.vim
View File

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

7
lib/nerdtree/notifier.vim
View File

@@ -14,13 +14,14 @@ endfunction
function! s:Notifier.NotifyListeners(event, path, nerdtree, params) function! s:Notifier.NotifyListeners(event, path, nerdtree, params)
let event = g:NERDTreeEvent.New(a:nerdtree, a:path, a:event, a: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 endfor
endfunction endfunction
function! s:Notifier.GetListenersMap() function! s:Notifier.GetListenersMap()
if !exists("s:refreshListenersMap") if !exists('s:refreshListenersMap')
let s:refreshListenersMap = {} let s:refreshListenersMap = {}
endif endif
return s:refreshListenersMap return s:refreshListenersMap

132
lib/nerdtree/opener.vim
View File

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

110
lib/nerdtree/path.vim
View File

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

100
lib/nerdtree/tree_dir_node.vim
View File

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

22
lib/nerdtree/tree_file_node.vim
View File

@@ -1,7 +1,7 @@
" ============================================================================ " ============================================================================
" CLASS: TreeFileNode " 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. " part of the composite design pattern between the NERDTree node classes.
" ============================================================================ " ============================================================================
@@ -42,7 +42,7 @@ function! s:TreeFileNode.cacheParent()
if empty(self.parent) if empty(self.parent)
let parentPath = self.path.getParent() let parentPath = self.path.getParent()
if parentPath.equals(self.path) if parentPath.equals(self.path)
throw "NERDTree.CannotCacheParentError: already at root" throw 'NERDTree.CannotCacheParentError: already at root'
endif endif
let self.parent = s:TreeFileNode.New(parentPath, self.getNerdtree()) let self.parent = s:TreeFileNode.New(parentPath, self.getNerdtree())
endif endif
@@ -195,7 +195,7 @@ endfunction
" FUNCTION: TreeFileNode.isRoot() {{{1 " FUNCTION: TreeFileNode.isRoot() {{{1
function! s:TreeFileNode.isRoot() function! s:TreeFileNode.isRoot()
if !g:NERDTree.ExistsForBuf() 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 endif
return self.equals(self.getNerdtree().root) return self.equals(self.getNerdtree().root)
@@ -246,6 +246,12 @@ function! s:TreeFileNode.openInNewTab(options)
call self.open(extend({'where': 't'}, a:options)) call self.open(extend({'where': 't'}, a:options))
endfunction 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 " FUNCTION: TreeFileNode.putCursorHere(isJump, recurseUpward){{{1
" Places the cursor on the line number this node is rendered on " 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 if a:isJump
mark ' mark '
endif endif
call cursor(ln, col(".")) call cursor(ln, col('.'))
else else
if a:recurseUpward if a:recurseUpward
let node = self let node = self
@@ -311,17 +317,13 @@ endfunction
" child nodes are rendered only) " child nodes are rendered only)
" for each depth in the tree " for each depth in the tree
function! s:TreeFileNode._renderToString(depth, drawText) function! s:TreeFileNode._renderToString(depth, drawText)
let output = "" let output = ''
if a:drawText ==# 1 if a:drawText ==# 1
let treeParts = repeat(' ', a:depth - 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 line = treeParts . self.displayString()
let output = output . line . "\n" let output = output . line . "\n"
endif endif

191
lib/nerdtree/ui.vim
View File

@@ -27,94 +27,94 @@ function! s:UI._dumpHelp()
let help = "\" NERDTree (" . nerdtree#version() . ") quickhelp~\n" let help = "\" NERDTree (" . nerdtree#version() . ") quickhelp~\n"
let help .= "\" ============================\n" let help .= "\" ============================\n"
let help .= "\" File node mappings~\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"
if self.nerdtree.isTabTree() if self.nerdtree.isTabTree()
let help .= "\" ". g:NERDTreeMapActivateNode .": open in prev window\n" let help .= '" '. g:NERDTreeMapActivateNode .": open in prev window\n"
else else
let help .= "\" ". g:NERDTreeMapActivateNode .": open in current window\n" let help .= '" '. g:NERDTreeMapActivateNode .": open in current window\n"
endif endif
if self.nerdtree.isTabTree() if self.nerdtree.isTabTree()
let help .= "\" ". g:NERDTreeMapPreview .": preview\n" let help .= '" '. g:NERDTreeMapPreview .": preview\n"
endif 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 .= "\" 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 .= '" '. g:NERDTreeMapCustomOpen .": custom open\n"
let help .= "\"\n\" ----------------------------\n" let help .= "\"\n\" ----------------------------\n"
let help .= "\" Directory node mappings~\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:NERDTreeMapCustomOpen .": custom open\n" let help .= '" '. g:NERDTreeMapCustomOpen .": custom open\n"
let help .= "\" ". g:NERDTreeMapCloseDir .": close parent of node\n" let help .= '" '. g:NERDTreeMapCloseDir .": close parent of node\n"
let help .= "\" ". g:NERDTreeMapCloseChildren .": close all child nodes of\n" let help .= '" '. g:NERDTreeMapCloseChildren .": close all child nodes of\n"
let help .= "\" current node recursively\n" let help .= "\" current node recursively\n"
let help .= "\" middle-click,\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 .= "\"\n\" ----------------------------\n"
let help .= "\" Bookmark table mappings~\n" let help .= "\" Bookmark table mappings~\n"
let help .= "\" double-click,\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:NERDTreeMapCustomOpen .": custom open\n" let help .= '" '. g:NERDTreeMapCustomOpen .": custom open\n"
let help .= "\" ". g:NERDTreeMapDeleteBookmark .": delete bookmark\n" let help .= '" '. g:NERDTreeMapDeleteBookmark .": delete bookmark\n"
let help .= "\"\n\" ----------------------------\n" let help .= "\"\n\" ----------------------------\n"
let help .= "\" Tree navigation mappings~\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 .= "\"\n\" ----------------------------\n"
let help .= "\" Filesystem mappings~\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 .= "\" 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 .= "\" 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 .= "\" 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 .= "\"\n\" ----------------------------\n"
let help .= "\" Tree filtering mappings~\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 " add quickhelp entries for each custom key map
let help .= "\"\n\" ----------------------------\n" let help .= "\"\n\" ----------------------------\n"
let help .= "\" Custom mappings~\n" let help .= "\" Custom mappings~\n"
for i in g:NERDTreeKeyMap.All() for i in g:NERDTreeKeyMap.All()
if !empty(i.quickhelpText) if !empty(i.quickhelpText)
let help .= "\" ". i.key .": ". i.quickhelpText ."\n" let help .= '" '. i.key .': '. i.quickhelpText ."\n"
endif endif
endfor endfor
let help .= "\"\n\" ----------------------------\n" let help .= "\"\n\" ----------------------------\n"
let help .= "\" Other mappings~\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 .= "\" the NERDTree window\n"
let help .= "\" ". g:NERDTreeMapHelp .": toggle help\n" let help .= '" '. g:NERDTreeMapHelp .": toggle help\n"
let help .= "\"\n\" ----------------------------\n" let help .= "\"\n\" ----------------------------\n"
let help .= "\" Bookmark commands~\n" let help .= "\" Bookmark commands~\n"
let help .= "\" :Bookmark [<name>]\n" let help .= "\" :Bookmark [<name>]\n"
@@ -128,7 +128,7 @@ function! s:UI._dumpHelp()
let help .= "\" :EditBookmarks\n" let help .= "\" :EditBookmarks\n"
silent! put =help silent! put =help
elseif !self.isMinimal() elseif !self.isMinimal()
let help ="\" Press ". g:NERDTreeMapHelp ." for help\n" let help ='" Press '. g:NERDTreeMapHelp ." for help\n"
silent! put =help silent! put =help
endif endif
endfunction endfunction
@@ -148,8 +148,8 @@ function! s:UI.New(nerdtree)
endfunction endfunction
" FUNCTION: s:UI.getPath(ln) {{{1 " 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 " the parent of the root. Return the empty dictionary if the given line
" does not reference a tree node. " does not reference a tree node.
function! s:UI.getPath(ln) function! s:UI.getPath(ln)
@@ -157,7 +157,7 @@ function! s:UI.getPath(ln)
let rootLine = self.getRootLineNum() let rootLine = self.getRootLineNum()
if a:ln == rootLine if a:ln ==# rootLine
return self.nerdtree.root.path return self.nerdtree.root.path
endif endif
@@ -174,7 +174,7 @@ function! s:UI.getPath(ln)
" remove the tree parts and the leading space " remove the tree parts and the leading space
let curFile = self._stripMarkup(line) let curFile = self._stripMarkup(line)
let dir = "" let dir = ''
let lnum = a:ln let lnum = a:ln
while lnum > 0 while lnum > 0
let lnum = lnum - 1 let lnum = lnum - 1
@@ -182,7 +182,7 @@ function! s:UI.getPath(ln)
let curLineStripped = self._stripMarkup(curLine) let curLineStripped = self._stripMarkup(curLine)
" have we reached the top of the tree? " have we reached the top of the tree?
if lnum == rootLine if lnum ==# rootLine
let dir = self.nerdtree.root.path.str({'format': 'UI'}) . dir let dir = self.nerdtree.root.path.str({'format': 'UI'}) . dir
break break
endif endif
@@ -191,7 +191,7 @@ function! s:UI.getPath(ln)
if lpindent < indent if lpindent < indent
let indent = indent - 1 let indent = indent - 1
let dir = substitute (curLineStripped,'^\\', "", "") . dir let dir = substitute (curLineStripped,'^\\', '', '') . dir
continue continue
endif endif
endif endif
@@ -219,17 +219,17 @@ function! s:UI.getLineNum(node)
let l:currentLine = getline(l:lineNumber) let l:currentLine = getline(l:lineNumber)
let l:indentLevel = self._indentLevelFor(l:currentLine) let l:indentLevel = self._indentLevelFor(l:currentLine)
if l:indentLevel != l:currentPathComponent if l:indentLevel !=# l:currentPathComponent
continue continue
endif endif
let l:currentLine = self._stripMarkup(l:currentLine) let l:currentLine = self._stripMarkup(l:currentLine)
let l:currentPath = join(l:pathComponents, '/') . '/' . 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 " either the paths are equal or the line is a cascade containing the
" full path. " 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 return l:lineNumber
endif endif
@@ -240,7 +240,7 @@ function! s:UI.getLineNum(node)
" Otherwise: If the full path starts with the current path and the " Otherwise: If the full path starts with the current path and the
" current path is a directory, we add a new path component. " 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*$', '', '') let l:currentLine = substitute(l:currentLine, '/\s*$', '', '')
call add(l:pathComponents, l:currentLine) call add(l:pathComponents, l:currentLine)
let l:currentPathComponent += 1 let l:currentPathComponent += 1
@@ -254,7 +254,7 @@ endfunction
" gets the line number of the root node " gets the line number of the root node
function! s:UI.getRootLineNum() function! s:UI.getRootLineNum()
let rootLine = 1 let rootLine = 1
while getline(rootLine) !~# '^\(/\|<\)' while rootLine <= line('$') && getline(rootLine) !~# '^\(/\|<\)'
let rootLine = rootLine + 1 let rootLine = rootLine + 1
endwhile endwhile
return rootLine return rootLine
@@ -284,7 +284,11 @@ endfunction
function! s:UI._indentLevelFor(line) function! s:UI._indentLevelFor(line)
" Replace multi-character DirArrows with a single space so the " Replace multi-character DirArrows with a single space so the
" indentation calculation doesn't get messed up. " 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\[^ ]') let leadChars = match(l:line, '\M\[^ ]')
return leadChars / s:UI.IndentWid() return leadChars / s:UI.IndentWid()
endfunction endfunction
@@ -296,7 +300,7 @@ endfunction
" FUNCTION: s:UI.isIgnoreFilterEnabled() {{{1 " FUNCTION: s:UI.isIgnoreFilterEnabled() {{{1
function! s:UI.isIgnoreFilterEnabled() function! s:UI.isIgnoreFilterEnabled()
return self._ignoreEnabled == 1 return self._ignoreEnabled ==# 1
endfunction endfunction
" FUNCTION: s:UI.isMinimal() {{{1 " FUNCTION: s:UI.isMinimal() {{{1
@@ -313,21 +317,21 @@ endfunction
function! s:UI._renderBookmarks() function! s:UI._renderBookmarks()
if !self.isMinimal() if !self.isMinimal()
call setline(line(".")+1, ">----------Bookmarks----------") call setline(line('.')+1, '>----------Bookmarks----------')
call cursor(line(".")+1, col(".")) call cursor(line('.')+1, col('.'))
endif endif
if g:NERDTreeBookmarksSort == 1 || g:NERDTreeBookmarksSort == 2 if g:NERDTreeBookmarksSort ==# 1 || g:NERDTreeBookmarksSort ==# 2
call g:NERDTreeBookmark.SortBookmarksList() call g:NERDTreeBookmark.SortBookmarksList()
endif endif
for i in g:NERDTreeBookmark.Bookmarks() 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 endfor
call setline(line(".")+1, '') call setline(line('.')+1, '')
call cursor(line(".")+1, col(".")) call cursor(line('.')+1, col('.'))
endfunction endfunction
" FUNCTION: s:UI.restoreScreenState() {{{1 " FUNCTION: s:UI.restoreScreenState() {{{1
@@ -340,13 +344,13 @@ function! s:UI.restoreScreenState()
if !has_key(self, '_screenState') if !has_key(self, '_screenState')
return return
endif endif
exec("silent vertical resize " . self._screenState['oldWindowSize']) call nerdtree#exec('silent vertical resize ' . self._screenState['oldWindowSize'], 1)
let old_scrolloff=&scrolloff let old_scrolloff=&scrolloff
let &scrolloff=0 let &scrolloff=0
call cursor(self._screenState['oldTopLine'], 0) call cursor(self._screenState['oldTopLine'], 0)
normal! zt normal! zt
call setpos(".", self._screenState['oldPos']) call setpos('.', self._screenState['oldPos'])
let &scrolloff=old_scrolloff let &scrolloff=old_scrolloff
endfunction endfunction
@@ -355,12 +359,15 @@ endfunction
" scroll position " scroll position
function! s:UI.saveScreenState() function! s:UI.saveScreenState()
let win = winnr() let win = winnr()
call g:NERDTree.CursorToTreeWin()
let self._screenState = {} 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 endfunction
" FUNCTION: s:UI.setShowHidden(val) {{{1 " FUNCTION: s:UI.setShowHidden(val) {{{1
@@ -384,9 +391,9 @@ function! s:UI.render()
" remember the top line of the buffer and the current line so we can " remember the top line of the buffer and the current line so we can
" restore the view exactly how it was " 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) " delete all lines in the buffer (being careful not to clobber a register)
silent 1,$delete _ silent 1,$delete _
@@ -395,8 +402,8 @@ function! s:UI.render()
" delete the blank line before the help and add one after it " delete the blank line before the help and add one after it
if !self.isMinimal() if !self.isMinimal()
call setline(line(".")+1, "") call setline(line('.')+1, '')
call cursor(line(".")+1, col(".")) call cursor(line('.')+1, col('.'))
endif endif
if self.getShowBookmarks() if self.getShowBookmarks()
@@ -405,14 +412,14 @@ function! s:UI.render()
" add the 'up a dir' line " add the 'up a dir' line
if !self.isMinimal() 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 endif
" draw the header line " draw the header line
let header = self.nerdtree.root.path.str({'format': 'UI', 'truncateTo': winwidth(0)}) 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 " draw the tree
silent put =self.nerdtree.root.renderToString() silent put =self.nerdtree.root.renderToString()
@@ -440,13 +447,13 @@ function! s:UI.renderViewSavingPosition()
" go up the tree till we find a node that will be visible or till we run " go up the tree till we find a node that will be visible or till we run
" out of nodes " out of nodes
while currentNode != {} && !currentNode.isVisible() && !currentNode.isRoot() while currentNode !=# {} && !currentNode.isVisible() && !currentNode.isRoot()
let currentNode = currentNode.parent let currentNode = currentNode.parent
endwhile endwhile
call self.render() call self.render()
if currentNode != {} if currentNode !=# {}
call currentNode.putCursorHere(0, 0) call currentNode.putCursorHere(0, 0)
endif endif
endfunction endfunction
@@ -504,12 +511,12 @@ endfunction
" FUNCTION: s:UI.toggleZoom() {{{1 " FUNCTION: s:UI.toggleZoom() {{{1
" zoom (maximize/minimize) the NERDTree window " zoom (maximize/minimize) the NERDTree window
function! s:UI.toggleZoom() 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 let b:NERDTreeZoomed = 0
else else
exec "vertical resize ". get(g:, 'NERDTreeWinSizeMax', '') call nerdtree#exec('vertical resize '. get(g:, 'NERDTreeWinSizeMax', ''), 1)
let b:NERDTreeZoomed = 1 let b:NERDTreeZoomed = 1
endif endif
endfunction endfunction

6
nerdtree_plugin/exec_menuitem.vim
View File

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

157
nerdtree_plugin/fs_menu.vim
View File

@@ -9,13 +9,13 @@
" See http://sam.zoy.org/wtfpl/COPYING for more details. " 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 finish
endif endif
let g:loaded_nerdtree_fs_menu = 1 let g:loaded_nerdtree_fs_menu = 1
"Automatically delete the buffer after deleting or renaming a file "Automatically delete the buffer after deleting or renaming a file
if !exists("g:NERDTreeAutoDeleteBuffer") if !exists('g:NERDTreeAutoDeleteBuffer')
let g:NERDTreeAutoDeleteBuffer = 0 let g:NERDTreeAutoDeleteBuffer = 0
endif 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': '(m)ove the current node', 'shortcut': 'm', 'callback': 'NERDTreeMoveNode'})
call NERDTreeAddMenuItem({'text': '(d)elete the current node', 'shortcut': 'd', 'callback': 'NERDTreeDeleteNode'}) 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': '(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': '(o)pen the current node with system editor', 'shortcut': 'o', 'callback': 'NERDTreeExecuteFile'})
call NERDTreeAddMenuItem({'text': '(q)uicklook the current node', 'shortcut': 'q', 'callback': 'NERDTreeQuickLook'}) call NERDTreeAddMenuItem({'text': '(q)uicklook the current node', 'shortcut': 'q', 'callback': 'NERDTreeQuickLook'})
endif 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': '(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'}) call NERDTreeAddMenuItem({'text': '(o)pen the current node with system editor', 'shortcut': 'o', 'callback': 'NERDTreeExecuteFileLinux'})
endif endif
@@ -37,9 +37,9 @@ endif
if g:NERDTreePath.CopyingSupported() if g:NERDTreePath.CopyingSupported()
call NERDTreeAddMenuItem({'text': '(c)opy the current node', 'shortcut': 'c', 'callback': 'NERDTreeCopyNode'}) call NERDTreeAddMenuItem({'text': '(c)opy the current node', 'shortcut': 'c', 'callback': 'NERDTreeCopyNode'})
endif 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'}) call NERDTreeAddMenuItem({'text': '(l)ist the current node', 'shortcut': 'l', 'callback': 'NERDTreeListNode'})
else else
call NERDTreeAddMenuItem({'text': '(l)ist the current node', 'shortcut': 'l', 'callback': 'NERDTreeListNodeWin32'}) call NERDTreeAddMenuItem({'text': '(l)ist the current node', 'shortcut': 'l', 'callback': 'NERDTreeListNodeWin32'})
@@ -51,37 +51,37 @@ endif
"Args: "Args:
"action: the action that is being performed, e.g. 'delete' "action: the action that is being performed, e.g. 'delete'
function! s:inputPrompt(action) 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 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 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 endif
if g:NERDTreeMenuController.isMinimal() if g:NERDTreeMenuController.isMinimal()
redraw! " Clear the menu redraw! " Clear the menu
return minimal . " " return minimal . ' '
else else
let divider = "==========================================================" let divider = '=========================================================='
return title . "\n" . divider . "\n" . info . "\n" return title . "\n" . divider . "\n" . info . "\n"
end end
endfunction endfunction
@@ -114,14 +114,14 @@ function! s:promptToDelBuffer(bufnum, msg)
let l:listedBufferCount = 0 let l:listedBufferCount = 0
endif endif
if l:listedBufferCount > 1 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 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 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 " 3. We don't need a previous buffer anymore
exec "bwipeout! " . a:bufnum call nerdtree#exec('bwipeout! ' . a:bufnum, 0)
endif endif
endfunction endfunction
@@ -141,17 +141,17 @@ function! s:renameBuffer(bufNum, newNodeName, isDirectory)
let editStr = g:NERDTreePath.New(a:newNodeName).str({'format': 'Edit'}) let editStr = g:NERDTreePath.New(a:newNodeName).str({'format': 'Edit'})
endif endif
" 1. ensure that a new buffer is loaded " 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 " 2. ensure that all windows which display the just deleted filename
" display a buffer for a new filename. " display a buffer for a new filename.
let s:originalTabNumber = tabpagenr() let s:originalTabNumber = tabpagenr()
let s:originalWindowNumber = winnr() 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 " 3. We don't need a previous buffer anymore
try try
exec "confirm bwipeout " . a:bufNum call nerdtree#exec('confirm bwipeout ' . a:bufNum, 0)
catch catch
" This happens when answering Cancel if confirmation is needed. Do nothing. " This happens when answering Cancel if confirmation is needed. Do nothing.
endtry endtry
@@ -160,11 +160,11 @@ endfunction
"FUNCTION: NERDTreeAddNode(){{{1 "FUNCTION: NERDTreeAddNode(){{{1
function! NERDTreeAddNode() function! NERDTreeAddNode()
let curDirNode = g:NERDTreeDirNode.GetSelected() 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 ==# '' if newNodeName ==# ''
call nerdtree#echo("Node Creation Aborted.") call nerdtree#echo('Node Creation Aborted.')
return return
endif endif
@@ -187,26 +187,31 @@ function! NERDTreeAddNode()
redraw! redraw!
catch /^NERDTree/ catch /^NERDTree/
call nerdtree#echoWarning("Node Not Created.") call nerdtree#echoWarning('Node Not Created.')
endtry endtry
endfunction endfunction
"FUNCTION: NERDTreeMoveNode(){{{1 "FUNCTION: NERDTreeMoveNode(){{{1
function! NERDTreeMoveNode() function! NERDTreeMoveNode()
let curNode = g:NERDTreeFileNode.GetSelected() 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 ==# '' if newNodePath ==# ''
call nerdtree#echo("Node Renaming Aborted.") call nerdtree#echo('Node Renaming Aborted.')
return return
endif endif
try try
if curNode.path.isDirectory 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 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 endif
call curNode.rename(newNodePath) call curNode.rename(newNodePath)
@@ -221,9 +226,9 @@ function! NERDTreeMoveNode()
" renamed files. " renamed files.
if !empty(l:openBuffers) if !empty(l:openBuffers)
if curNode.path.isDirectory 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 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 endif
if g:NERDTreeAutoDeleteBuffer || nr2char(getchar()) ==# 'y' if g:NERDTreeAutoDeleteBuffer || nr2char(getchar()) ==# 'y'
for bufNum in l:openBuffers for bufNum in l:openBuffers
@@ -236,7 +241,7 @@ function! NERDTreeMoveNode()
redraw! redraw!
catch /^NERDTree/ catch /^NERDTree/
call nerdtree#echoWarning("Node Not Renamed.") call nerdtree#echoWarning('Node Not Renamed.')
endtry endtry
endfunction endfunction
@@ -249,11 +254,11 @@ function! NERDTreeDeleteNode()
if currentNode.path.isDirectory && ((currentNode.isOpen && currentNode.getChildCount() > 0) || if currentNode.path.isDirectory && ((currentNode.isOpen && currentNode.getChildCount() > 0) ||
\ (len(currentNode._glob('*', 1)) > 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 choice = input(prompt)
let confirmed = choice ==# 'yes' let confirmed = choice ==# 'yes'
else else
let prompt = s:inputPrompt("delete") . currentNode.path.str() . " (yN): " let prompt = s:inputPrompt('delete') . currentNode.path.str() . ' (yN): '
echo prompt echo prompt
let choice = nr2char(getchar()) let choice = nr2char(getchar())
let confirmed = choice ==# 'y' 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 "if the node is open in a buffer, ask the user if they want to
"close that buffer "close that buffer
let bufnum = bufnr("^".currentNode.path.str()."$") let bufnum = bufnr('^'.currentNode.path.str().'$')
if buflisted(bufnum) 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) call s:promptToDelBuffer(bufnum, prompt)
endif endif
redraw! redraw!
catch /^NERDTree/ catch /^NERDTree/
call nerdtree#echoWarning("Could not remove node") call nerdtree#echoWarning('Could not remove node')
endtry endtry
else else
call nerdtree#echo("delete aborted") call nerdtree#echo('delete aborted')
endif endif
let &shellslash = l:shellslash let &shellslash = l:shellslash
endfunction endfunction
@@ -286,10 +291,10 @@ endfunction
function! NERDTreeListNode() function! NERDTreeListNode()
let treenode = g:NERDTreeFileNode.GetSelected() let treenode = g:NERDTreeFileNode.GetSelected()
if !empty(treenode) if !empty(treenode)
let s:uname = system("uname") let s:uname = system('uname')
let stat_cmd = 'stat -c "%s" ' let stat_cmd = 'stat -c "%s" '
if s:uname =~? "Darwin" if s:uname =~? 'Darwin'
let stat_cmd = 'stat -f "%z" ' let stat_cmd = 'stat -f "%z" '
endif endif
@@ -300,7 +305,7 @@ function! NERDTreeListNode()
let metadata = split(system(cmd),'\n') let metadata = split(system(cmd),'\n')
call nerdtree#echo(metadata[0]) call nerdtree#echo(metadata[0])
else else
call nerdtree#echo("No information available") call nerdtree#echo('No information available')
endif endif
endfunction endfunction
@@ -310,10 +315,10 @@ function! NERDTreeListNodeWin32()
if !empty(l:node) if !empty(l:node)
let l:path = l:node.path.str() 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)), \ toupper(getftype(l:path)),
\ fnamemodify(l:path, ':t'), \ fnamemodify(l:path, ':t'),
\ strftime("%c", getftime(l:path)), \ strftime('%c', getftime(l:path)),
\ getfsize(l:path), \ getfsize(l:path),
\ getfperm(l:path))) \ getfperm(l:path)))
return return
@@ -327,16 +332,16 @@ function! NERDTreeCopyNode()
let l:shellslash = &shellslash let l:shellslash = &shellslash
let &shellslash = 0 let &shellslash = 0
let currentNode = g:NERDTreeFileNode.GetSelected() 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 "strip trailing slash
let newNodePath = substitute(newNodePath, '\/$', '', '') let newNodePath = substitute(newNodePath, '\/$', '', '')
let confirmed = 1 let confirmed = 1
if currentNode.path.copyingWillOverwrite(newNodePath) 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 choice = nr2char(getchar())
let confirmed = choice ==# 'y' let confirmed = choice ==# 'y'
endif endif
@@ -355,11 +360,11 @@ function! NERDTreeCopyNode()
call newNode.putCursorHere(0, 0) call newNode.putCursorHere(0, 0)
endif endif
catch /^NERDTree/ catch /^NERDTree/
call nerdtree#echoWarning("Could not copy node") call nerdtree#echoWarning('Could not copy node')
endtry endtry
endif endif
else else
call nerdtree#echo("Copy aborted.") call nerdtree#echo('Copy aborted.')
endif endif
let &shellslash = l:shellslash let &shellslash = l:shellslash
redraw! redraw!
@@ -368,18 +373,22 @@ endfunction
" FUNCTION: NERDTreeCopyPath() {{{1 " FUNCTION: NERDTreeCopyPath() {{{1
function! NERDTreeCopyPath() function! NERDTreeCopyPath()
let l:nodePath = g:NERDTreeFileNode.GetSelected().path.str() 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 else
call nerdtree#echo("The full path is: " . l:nodePath) call nerdtree#echo('The full path is: ' . l:nodePath)
endif endif
endfunction endfunction
" FUNCTION: NERDTreeQuickLook() {{{1 " FUNCTION: NERDTreeQuickLook() {{{1
function! NERDTreeQuickLook() function! NERDTreeQuickLook()
let treenode = g:NERDTreeFileNode.GetSelected() let treenode = g:NERDTreeFileNode.GetSelected()
if treenode != {} if treenode !=# {}
call system("qlmanage -p 2>/dev/null '" . treenode.path.str() . "'") call system("qlmanage -p 2>/dev/null '" . treenode.path.str() . "'")
endif endif
endfunction endfunction
@@ -387,7 +396,7 @@ endfunction
" FUNCTION: NERDTreeRevealInFinder() {{{1 " FUNCTION: NERDTreeRevealInFinder() {{{1
function! NERDTreeRevealInFinder() function! NERDTreeRevealInFinder()
let treenode = g:NERDTreeFileNode.GetSelected() let treenode = g:NERDTreeFileNode.GetSelected()
if treenode != {} if treenode !=# {}
call system("open -R '" . treenode.path.str() . "'") call system("open -R '" . treenode.path.str() . "'")
endif endif
endfunction endfunction
@@ -395,7 +404,7 @@ endfunction
" FUNCTION: NERDTreeExecuteFile() {{{1 " FUNCTION: NERDTreeExecuteFile() {{{1
function! NERDTreeExecuteFile() function! NERDTreeExecuteFile()
let treenode = g:NERDTreeFileNode.GetSelected() let treenode = g:NERDTreeFileNode.GetSelected()
if treenode != {} if treenode !=# {}
call system("open '" . treenode.path.str() . "'") call system("open '" . treenode.path.str() . "'")
endif endif
endfunction endfunction
@@ -404,7 +413,7 @@ endfunction
function! NERDTreeRevealFileLinux() function! NERDTreeRevealFileLinux()
let treenode = g:NERDTreeFileNode.GetSelected() let treenode = g:NERDTreeFileNode.GetSelected()
let parentnode = treenode.parent let parentnode = treenode.parent
if parentnode != {} if parentnode !=# {}
call system("xdg-open '" . parentnode.path.str() . "' &") call system("xdg-open '" . parentnode.path.str() . "' &")
endif endif
endfunction endfunction
@@ -412,7 +421,7 @@ endfunction
" FUNCTION: NERDTreeExecuteFileLinux() {{{1 " FUNCTION: NERDTreeExecuteFileLinux() {{{1
function! NERDTreeExecuteFileLinux() function! NERDTreeExecuteFileLinux()
let treenode = g:NERDTreeFileNode.GetSelected() let treenode = g:NERDTreeFileNode.GetSelected()
if treenode != {} if treenode !=# {}
call system("xdg-open '" . treenode.path.str() . "' &") call system("xdg-open '" . treenode.path.str() . "' &")
endif endif
endfunction endfunction

15
nerdtree_plugin/vcs.vim
View File

@@ -11,12 +11,21 @@
" "
" ============================================================================ " ============================================================================
command! -n=? -complete=dir -bar NERDTreeVCS :call <SID>CreateTabTreeVCS('<args>') 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(a:name) {{{1
function! s:CreateTabTreeVCS(name) function! s:CreateTabTreeVCS(name)
let l:path = g:NERDTreeCreator._pathForString(a:name) let l:path = g:NERDTreeCreator._pathForString(a:name)
let l:path = s:FindParentVCSRoot(l:path) 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 endfunction
" FUNCTION: s:FindParentVCSRoot(a:path) {{{1 " FUNCTION: s:FindParentVCSRoot(a:path) {{{1
@@ -25,7 +34,7 @@ endfunction
function! s:FindParentVCSRoot(path) function! s:FindParentVCSRoot(path)
let l:path = a:path let l:path = a:path
while !empty(l:path) && while !empty(l:path) &&
\ l:path._str() !~ '^\(\a:\\\|\/\)$' && \ l:path._str() !~# '^\(\a:\\\|\/\)$' &&
\ !isdirectory(l:path._str() . '/.git') && \ !isdirectory(l:path._str() . '/.git') &&
\ !isdirectory(l:path._str() . '/.svn') && \ !isdirectory(l:path._str() . '/.svn') &&
\ !isdirectory(l:path._str() . '/.hg') && \ !isdirectory(l:path._str() . '/.hg') &&
@@ -33,6 +42,6 @@ function! s:FindParentVCSRoot(path)
\ !isdirectory(l:path._str() . '/_darcs') \ !isdirectory(l:path._str() . '/_darcs')
let l:path = l:path.getParent() let l:path = l:path.getParent()
endwhile 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 endfunction

191
plugin/NERD_tree.vim
View File

@@ -11,7 +11,9 @@
" "
" SECTION: Script init stuff {{{1 " SECTION: Script init stuff {{{1
"============================================================ "============================================================
if exists("loaded_nerd_tree") scriptencoding utf-8
if exists('loaded_nerd_tree')
finish finish
endif endif
if v:version < 703 if v:version < 703
@@ -20,9 +22,9 @@ if v:version < 703
endif endif
let loaded_nerd_tree = 1 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 "Function: s:initVariable() function {{{2
"This function is used to initialise a given variable to a given value. The "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 "1 if the var is set, 0 otherwise
function! s:initVariable(var, value) function! s:initVariable(var, value)
if !exists(a:var) if !exists(a:var)
exec 'let ' . a:var . ' = ' . "'" . substitute(a:value, "'", "''", "g") . "'" exec 'let ' . a:var . ' = ' . "'" . substitute(a:value, "'", "''", 'g') . "'"
return 1 return 1
endif endif
return 0 return 0
endfunction endfunction
"SECTION: Init variable calls and other random constants {{{2 "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 = ['\~$'] let g:NERDTreeIgnore = ['\~$']
endif 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: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() 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 else
call s:initVariable("g:NERDTreeDirArrowExpandable", "+") call s:initVariable('g:NERDTreeDirArrowExpandable', '+')
call s:initVariable("g:NERDTreeDirArrowCollapsible", "~") call s:initVariable('g:NERDTreeDirArrowCollapsible', '~')
endif 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$', '\~$'] let g:NERDTreeSortOrder = ['\/$', '*', '\.swp$', '\.bak$', '\~$']
endif endif
let g:NERDTreeOldSortOrder = [] 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 else
call s:initVariable("g:NERDTreeNodeDelimiter", "\u00a0") call s:initVariable('g:NERDTreeNodeDelimiter', "\u00a0")
endif endif
if !exists('g:NERDTreeStatusline') if !exists('g:NERDTreeStatusline')
@@ -104,60 +107,60 @@ if !exists('g:NERDTreeStatusline')
let g:NERDTreeStatusline = "%{exists('b:NERDTree')?b:NERDTree.root.path.str():''}" let g:NERDTreeStatusline = "%{exists('b:NERDTree')?b:NERDTree.root.path.str():''}"
endif 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 "init the shell commands that will be used to copy nodes, and remove dir trees
" "
"Note: the space after the command is important "Note: the space after the command is important
if nerdtree#runningWindows() 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 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 endif
"SECTION: Init variable calls for key mappings {{{2 "SECTION: Init variable calls for key mappings {{{2
call s:initVariable("g:NERDTreeMapCustomOpen", "<CR>") call s:initVariable('g:NERDTreeMapCustomOpen', '<CR>')
call s:initVariable("g:NERDTreeMapActivateNode", "o") call s:initVariable('g:NERDTreeMapActivateNode', 'o')
call s:initVariable("g:NERDTreeMapChangeRoot", "C") call s:initVariable('g:NERDTreeMapChangeRoot', 'C')
call s:initVariable("g:NERDTreeMapChdir", "cd") call s:initVariable('g:NERDTreeMapChdir', 'cd')
call s:initVariable("g:NERDTreeMapCloseChildren", "X") call s:initVariable('g:NERDTreeMapCloseChildren', 'X')
call s:initVariable("g:NERDTreeMapCloseDir", "x") call s:initVariable('g:NERDTreeMapCloseDir', 'x')
call s:initVariable("g:NERDTreeMapDeleteBookmark", "D") call s:initVariable('g:NERDTreeMapDeleteBookmark', 'D')
call s:initVariable("g:NERDTreeMapMenu", "m") call s:initVariable('g:NERDTreeMapMenu', 'm')
call s:initVariable("g:NERDTreeMapHelp", "?") call s:initVariable('g:NERDTreeMapHelp', '?')
call s:initVariable("g:NERDTreeMapJumpFirstChild", "K") call s:initVariable('g:NERDTreeMapJumpFirstChild', 'K')
call s:initVariable("g:NERDTreeMapJumpLastChild", "J") call s:initVariable('g:NERDTreeMapJumpLastChild', 'J')
call s:initVariable("g:NERDTreeMapJumpNextSibling", "<C-j>") call s:initVariable('g:NERDTreeMapJumpNextSibling', '<C-j>')
call s:initVariable("g:NERDTreeMapJumpParent", "p") call s:initVariable('g:NERDTreeMapJumpParent', 'p')
call s:initVariable("g:NERDTreeMapJumpPrevSibling", "<C-k>") call s:initVariable('g:NERDTreeMapJumpPrevSibling', '<C-k>')
call s:initVariable("g:NERDTreeMapJumpRoot", "P") call s:initVariable('g:NERDTreeMapJumpRoot', 'P')
call s:initVariable("g:NERDTreeMapOpenExpl", "e") call s:initVariable('g:NERDTreeMapOpenExpl', 'e')
call s:initVariable("g:NERDTreeMapOpenInTab", "t") call s:initVariable('g:NERDTreeMapOpenInTab', 't')
call s:initVariable("g:NERDTreeMapOpenInTabSilent", "T") call s:initVariable('g:NERDTreeMapOpenInTabSilent', 'T')
call s:initVariable("g:NERDTreeMapOpenRecursively", "O") call s:initVariable('g:NERDTreeMapOpenRecursively', 'O')
call s:initVariable("g:NERDTreeMapOpenSplit", "i") call s:initVariable('g:NERDTreeMapOpenSplit', 'i')
call s:initVariable("g:NERDTreeMapOpenVSplit", "s") call s:initVariable('g:NERDTreeMapOpenVSplit', 's')
call s:initVariable("g:NERDTreeMapPreview", "g" . NERDTreeMapActivateNode) call s:initVariable('g:NERDTreeMapPreview', 'g' . NERDTreeMapActivateNode)
call s:initVariable("g:NERDTreeMapPreviewSplit", "g" . NERDTreeMapOpenSplit) call s:initVariable('g:NERDTreeMapPreviewSplit', 'g' . NERDTreeMapOpenSplit)
call s:initVariable("g:NERDTreeMapPreviewVSplit", "g" . NERDTreeMapOpenVSplit) call s:initVariable('g:NERDTreeMapPreviewVSplit', 'g' . NERDTreeMapOpenVSplit)
call s:initVariable("g:NERDTreeMapQuit", "q") call s:initVariable('g:NERDTreeMapQuit', 'q')
call s:initVariable("g:NERDTreeMapRefresh", "r") call s:initVariable('g:NERDTreeMapRefresh', 'r')
call s:initVariable("g:NERDTreeMapRefreshRoot", "R") call s:initVariable('g:NERDTreeMapRefreshRoot', 'R')
call s:initVariable("g:NERDTreeMapToggleBookmarks", "B") call s:initVariable('g:NERDTreeMapToggleBookmarks', 'B')
call s:initVariable("g:NERDTreeMapToggleFiles", "F") call s:initVariable('g:NERDTreeMapToggleFiles', 'F')
call s:initVariable("g:NERDTreeMapToggleFilters", "f") call s:initVariable('g:NERDTreeMapToggleFilters', 'f')
call s:initVariable("g:NERDTreeMapToggleHidden", "I") call s:initVariable('g:NERDTreeMapToggleHidden', 'I')
call s:initVariable("g:NERDTreeMapToggleZoom", "A") call s:initVariable('g:NERDTreeMapToggleZoom', 'A')
call s:initVariable("g:NERDTreeMapUpdir", "u") call s:initVariable('g:NERDTreeMapUpdir', 'u')
call s:initVariable("g:NERDTreeMapUpdirKeepOpen", "U") call s:initVariable('g:NERDTreeMapUpdirKeepOpen', 'U')
call s:initVariable("g:NERDTreeMapCWD", "CD") call s:initVariable('g:NERDTreeMapCWD', 'CD')
call s:initVariable("g:NERDTreeMenuDown", "j") call s:initVariable('g:NERDTreeMenuDown', 'j')
call s:initVariable("g:NERDTreeMenuUp", "k") call s:initVariable('g:NERDTreeMenuUp', 'k')
"SECTION: Load class files{{{2 "SECTION: Load class files{{{2
call nerdtree#loadClassFiles() call nerdtree#loadClassFiles()
@@ -170,16 +173,22 @@ call nerdtree#ui_glue#setupCommands()
"============================================================ "============================================================
augroup NERDTree augroup NERDTree
"Save the cursor position whenever we close the nerd tree "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 "disallow insert mode in the NERDTree
exec "autocmd BufEnter ". g:NERDTreeCreator.BufNamePrefix() ."* stopinsert" exec 'autocmd BufEnter,WinEnter '. g:NERDTreeCreator.BufNamePrefix() .'* stopinsert'
augroup END augroup END
if g:NERDTreeHijackNetrw if g:NERDTreeHijackNetrw
augroup NERDTreeHijackNetrw augroup NERDTreeHijackNetrw
autocmd VimEnter * silent! autocmd! FileExplorer 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 augroup END
endif endif
@@ -210,7 +219,7 @@ function! NERDTreeFocus()
if g:NERDTree.IsOpen() if g:NERDTree.IsOpen()
call g:NERDTree.CursorToTreeWin() call g:NERDTree.CursorToTreeWin()
else else
call g:NERDTreeCreator.ToggleTabTree("") call g:NERDTreeCreator.ToggleTabTree('')
endif endif
endfunction endfunction
@@ -246,7 +255,7 @@ endfunction
" SECTION: Post Source Actions {{{1 " SECTION: Post Source Actions {{{1
call nerdtree#postSourceActions() 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: " vim: set sw=4 sts=4 et fdm=marker:

44
syntax/nerdtree.vim
View File

@@ -3,7 +3,7 @@ syn match NERDTreeIgnore #\~#
exec 'syn match NERDTreeIgnore #\['.g:NERDTreeGlyphReadOnly.'\]#' exec 'syn match NERDTreeIgnore #\['.g:NERDTreeGlyphReadOnly.'\]#'
"highlighting for the .. (up dir) line at the top of the tree "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 "quickhelp syntax elements
syn match NERDTreeHelpKey #" \{1,2\}[^ ]*:#ms=s+2,me=e-1 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 NERDTreeLinkFile #.* ->#me=e-3 containedin=NERDTreeFile
syn match NERDTreeLinkDir #.*/ ->#me=e-3 containedin=NERDTreeDir 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' exec 'syn match NERDTreeNodeDelimiters #\%d' . char2nr(g:NERDTreeNodeDelimiter) . '# conceal containedin=ALL'
setlocal conceallevel=3 concealcursor=nvic setlocal conceallevel=3 concealcursor=nvic
else else
@@ -45,6 +28,27 @@ else
hi! link NERDTreeNodeDelimiters Ignore hi! link NERDTreeNodeDelimiters Ignore
endif 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 #^[</].*$# syn match NERDTreeCWD #^[</].*$#
"highlighting for bookmarks "highlighting for bookmarks