* 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.
This function was added to support a separate plugin:
https://github.com/scrooloose/nerdtree-project-plugin.git. It was
subsequently removed without recognizing its contribution to the
external plugin. This commit restores that function so NERDTree projects
will work.
* Add two more disqualifications for isCascadable().
A directory that is bookmarked or that is a symlink to another location
has trailing text indicating so. This extra text causes problem when
cascading with a directory underneath it, so disable it in this case.
* Add comments to explain the new exclusions for bookmarks and symlinks.
* Use a delimiter in node to separate file/dir name from the rest.
* Switch warning message to use nerdtree#deprecated function.
* Compress the space between the tree symbols and the node.
* Include the delimiter when calculating indent or getting filename.
* Don't need to strip leading delimiter. It will already be gone.
* Simplify the way the delimiter is being used.
I don't know what I was thinking. The delimiter doesn't need to be used
to separate every indicator on the node's text, ie.
Bad: Tree|GenericFlags|Filename|ExecutableFlag|Link|ReadonlyFlag
Better: Tree GenericFlags|Filename|ExecutableFlag Link ReadonlyFlag
This was unnecessary, given that we're only interested in the filename.
So, just one pair of delimiters is all we need. That greatly simplifies
the _stripMarkup function, and restores a bunch of other statements to
what they already are in the master branch.
* Add syntax highlighting to conceal the delimiter
* Put a if has("conceal") check around the syntax statement using it.
* Make concealment work correctly for LinkFile and readonly files.
* Use highlight Ignore if conceal isn't available.
This is probably the best we can do, especially if some other character
must be used in place of nbsp.
* Make the regex better match the original, but more compact.
It was allowing 2+ spaces, instead of only 1+.
* Fix the syntax highlighing of delimiters around NERDTreeExecFile.
* Bug fix: Parse . and .. from path string with trailing slash.
* Fix unresponsive cascaded directories.
Using ':' as a more visible delimiter, when directories are cascaded,
the line appears in NERDTree like so:
▾ :lib/::nerdtree/:
Before this commit, the s:UI._stripMarkup function was leaving the
internal delimiters in place (lib/::nerdtree/). Now they are removed,
resulting in a valid path (lib/nerdtree/).
* Use .= to shorten statement. Use clearer substitutes to get node name.
* Remove node delimiters that terminate the line.
* If flags are needed after the node name, then put another delimiter
before them.
* When joining directory nodes for cascaded display, strip off the
delimiter from the child node(s).
* Remove the unnecessary substitution of doubled intermediate
delimiters, since they're not in there anymore.
* DRY up the addition of the 2nd delimiter, and use only 1 for all tags.
Also add a new global variable to track when the g:NERDTreeSortOrder
changes. If it has been changed, or when the cached _sortKey value is
uninitialized, then calculate the sort key. This improves processing
speed over the previous commit, and allows on-the-fly changes to the
sort order, (without required vim to be restarted.)
The call to AddDefaultGroupToSortOrder in NERD_tree.vim is redundant
because it's also done every time sortChildren is called. And since the
check is done only once, there's no need for a function either.
sortChildren now just contains the needed if statement.
The small change here reverts an attempted bugfix from #785. That
change resulted in the unintended side-effect of closing other
children of the root whenever ":NERDTreeFind" was invoked. This was
disruptive (as reported in #793), so a new method must be found to
solve the problem of ":NERDTreeFind" not opening newly created
files.
Fixes#793.
The ":NERDTreeFind" command calls the "reveal()" method on the
NERDTree root node. The "reveal()" method would, in turn, call the
node's "open()" method. Since the "open()" method would only
initialize the child nodes of the root (i.e., read them from disk)
when the list of child nodes was empty, new paths would not be
included in the list.
This commit will result in the refreshing of the child node list
whenever "reveal()" is called on a directory node (unless it is the
first time the node is being opened... the most efficient option).
The result is that ":NERDTreeFind" will discover newly created paths
that exist on disk but are not cached in the NERDTree.
A stray debugging message is also removed.
Fixes issue #779.
This check did not use the proper abstract method to check for a
path separator. It now does.
This fixes a problem with the 'u' macro that I noticed while working
on the fix for using the NERDTree with 'shellslash'.
The "TreeDirNode.getDirChildren()" method is never called and can be
safely removed.
Further, note that this method has a bug. It calls the "filter()"
builtin function, which modifies "self.children" in-place. This is
obviously not a desirable side effect of calling this function.
If the functionality is genuinely required later, "filter()" should
be called on a copy of "self.children" to achieve the desired
result.
The support function for this method was unnecessary, so I took the
time to remove it. Since "TreeDirNode.openRecursively()" now calls
the "open()" method, it can take advantage of the improvements made
to that function in recent commits. Specifically, this method will
reflect the bugfix provided in pull request #720.
A proper instance method was substituted for the more brittle
equality test in the "TreeDirNode.open()" method.
Note that the order of the tests was reversed to account for the
fact that the "isRoot()" method can only be called after the first
test has passed.
This method required adjustment to take cascades into consideration.
Since the arrow in the NERDTree window reflects the status of the
tail directory of the associated cascade, an arrow indicating open
status can be present when a higher directory in the cascade was
closed.
This commit will automatically close child nodes within the same
cascade of a closed directory node so that the arrow accurately
reflects what is rendered.
Issues #547 and #526 reported a problem with the "open()" method in
the "TreeDirNode" class.
Specifically, opening a cascade in the NERDTree will perform the
opening operation on the tail of the cascade. This is a problem when
other operations (such as the "u" mapping) close intermediate
cascaded directories, which causes opening the tail to have no
effect (other than toggling the arrow).
Here, the "open()" method was modified to open all directories in a
cascade whenever the tail is opened. This is the only reasonable fix
for this type of problem.
Fixes#547 and fixes#526.
Calling the function "globpath()" is complex when one is trying to
support multiple versions of Vim because this particular function
developed rapidly (as did "glob()") during the life of Vim 7.0.
This commit makes the version check for calling "globpath()" much
clearer. It also allows for rendering dead links in the NERDTree by
changing the "globpath()" call for versions of Vim that include
patch 7.4.654. This can be done later when the effects are known and
the feature is officially requested.
Fixes#718.
The commentary in "tree_dir_node.vim" needed to be cleaned up a
little. Spaces after leading quotes are a good idea, to avoid the
"clustered" appearance that comments can sometimes have.
Use the following substitution command...
:s/^"\ze\S/" /
to make this change to longer scripts.
Pull request #710 also brought to my attention some glaring code
duplication in the TreeDirNode class. This commit renames and
expands the glob method defined in PR #710 into a more general
purpose helper method.
The new method also ensures that 'wildignore' rules are applied
consistently. Issue #569 noted that the application of the
'wildignore' setting in populating a node's children was
unpredictable. When a node was rendered, "_initChildren()" would
load the children with its own call to "globpath()". Refreshing the
same node would then invoke "globpath()" again, but with different
arguments.
The result was that a node's children were initialized using the
'g:NERDTreeRespectWildIgnore' setting, but refreshing ignored this
setting. So, if it the setting was 0, "test.class" might render when
the parent was initialized, and then be removed on refresh (if
'wildignore' contained '*.class').
This commit solves this problem by ensuring that the NERDTree
setting mentioned above is only checked and applied to a node's
children in one place by cleaning up the duplication.
Fixes#569.
Pull request #710 correctly noted that TreeDirNode directories must
be passed to "globpath()" as relative paths (i.e., to the working
directory) if 'wildignore' rules for relative paths are to be
obeyed.
The solution was to use "fnamemodify()" to get a relative path to
the TreeDirNode object's directory, if possible. However, this
method does not modify our TreeDirNode path if it IS the current
working directory. Thus, immediate children of the node are seen as
absolute paths in glob results when our PWD is pointing to their
parent. This is not consistent behavior.
This commit defines the result of this function as ',' when this
special case arises to fix this problem.
See ":h 'path'" for an explanation of how this works.
In Windows, fnamemodify with ':.' will strip the drive letter from a
path that isn't under CWD. This update ensures such a path has the drive
letter.
references #709
Wildignore rules that involve directories aren't handled properly (or at
least as one might expect) when globpath uses absolute paths. For
example, when wildignore contains `src/*.js`, `globpath("src", "*")`
works as expected, while `globpath("/home/user/project/src", "*")`
doesn't.
Use the innermost dirs flags only. Previously each dirs flags were
rendered inline i.e.
[x]dir1/[y]dir2/[z]dir3/
This looked bad and broke the UI. Now we only render the flags for dir3
- and render them on the left side of the cascade.
Not sure if this is ultimately the right decision - but will do for now.
Render cascading dirs on one line i.e.
> foo/bar/baz
file1
instead of
> foo
> bar
> baz
> file1
This should be useful things like java projects that have deep dir
structures.
Remove the old UI view (pre the dir arrows) as this simply isnt worth
supporting for a proof of concept. This may get added back - or not.
