mirror of
https://github.com/preservim/nerdtree.git
synced 2024-11-24 04:07:03 +08:00
312ce93bb4
when you hit t/T on a bookmark a new tab is opened and, if the bookmark is a dir, a nerd tree is opened for that dir. If the bookmark is a file then just open the file
3399 lines
106 KiB
VimL
3399 lines
106 KiB
VimL
" ============================================================================
|
|
" File: NERD_tree.vim
|
|
" Description: vim global plugin that provides a nice tree explorer
|
|
" Maintainer: Martin Grenfell <martin_grenfell at msn dot com>
|
|
" Last Change: 23 June, 2008
|
|
" License: This program is free software. It comes without any warranty,
|
|
" to the extent permitted by applicable law. You can redistribute
|
|
" it and/or modify it under the terms of the Do What The Fuck You
|
|
" Want To Public License, Version 2, as published by Sam Hocevar.
|
|
" See http://sam.zoy.org/wtfpl/COPYING for more details.
|
|
"
|
|
" ============================================================================
|
|
let s:NERD_tree_version = '2.11.0'
|
|
|
|
" SECTION: Script init stuff {{{1
|
|
"============================================================
|
|
if exists("loaded_nerd_tree")
|
|
finish
|
|
endif
|
|
if v:version < 700
|
|
echoerr "NERDTree: this plugin requires vim >= 7. DOWNLOAD IT! You'll thank me later!"
|
|
finish
|
|
endif
|
|
let loaded_nerd_tree = 1
|
|
"Function: s:InitVariable() function {{{2
|
|
"This function is used to initialise a given variable to a given value. The
|
|
"variable is only initialised if it does not exist prior
|
|
"
|
|
"Args:
|
|
"var: the name of the var to be initialised
|
|
"value: the value to initialise var to
|
|
"
|
|
"Returns:
|
|
"1 if the var is set, 0 otherwise
|
|
function! s:InitVariable(var, value)
|
|
if !exists(a:var)
|
|
exec 'let ' . a:var . ' = ' . "'" . a:value . "'"
|
|
return 1
|
|
endif
|
|
return 0
|
|
endfunction
|
|
|
|
"SECTION: Init variable calls and other random constants {{{2
|
|
call s:InitVariable("g:NERDChristmasTree", 1)
|
|
call s:InitVariable("g:NERDTreeAutoCenter", 1)
|
|
call s:InitVariable("g:NERDTreeAutoCenterThreshold", 3)
|
|
call s:InitVariable("g:NERDTreeCaseSensitiveSort", 0)
|
|
call s:InitVariable("g:NERDTreeChDirMode", 1)
|
|
if !exists("g:NERDTreeIgnore")
|
|
let g:NERDTreeIgnore = ['\~$']
|
|
endif
|
|
call s:InitVariable("g:NERDTreeHighlightCursorline", 1)
|
|
call s:InitVariable("g:NERDTreeBookmarksFile", expand('$HOME') . '/.NERDTreeBookmarks')
|
|
call s:InitVariable("g:NERDTreeMouseMode", 1)
|
|
call s:InitVariable("g:NERDTreeNotificationThreshold", 100)
|
|
call s:InitVariable("g:NERDTreeQuitOnOpen", 0)
|
|
call s:InitVariable("g:NERDTreeShowBookmarks", 0)
|
|
call s:InitVariable("g:NERDTreeShowFiles", 1)
|
|
call s:InitVariable("g:NERDTreeShowHidden", 0)
|
|
call s:InitVariable("g:NERDTreeShowLineNumbers", 0)
|
|
call s:InitVariable("g:NERDTreeSortDirs", 1)
|
|
|
|
if !exists("g:NERDTreeSortOrder")
|
|
let g:NERDTreeSortOrder = ['\/$', '*', '\.swp$', '\.bak$', '\~$']
|
|
else
|
|
"if there isnt a * in the sort sequence then add one
|
|
if count(g:NERDTreeSortOrder, '*') < 1
|
|
call add(g:NERDTreeSortOrder, '*')
|
|
endif
|
|
endif
|
|
|
|
"we need to use this number many times for sorting... so we calculate it only
|
|
"once here
|
|
let s:NERDTreeSortStarIndex = index(g:NERDTreeSortOrder, '*')
|
|
|
|
call s:InitVariable("g:NERDTreeSplitVertical", 1)
|
|
call s:InitVariable("g:NERDTreeWinPos", 1)
|
|
call s:InitVariable("g:NERDTreeWinSize", 31)
|
|
|
|
let s:running_windows = has("win16") || has("win32") || has("win64")
|
|
|
|
"init the shell commands that will be used to copy nodes, and remove dir trees
|
|
"
|
|
"Note: the space after the command is important
|
|
if s:running_windows
|
|
call s:InitVariable("g:NERDTreeRemoveDirCmd", 'rmdir /s /q ')
|
|
else
|
|
call s:InitVariable("g:NERDTreeRemoveDirCmd", 'rm -rf ')
|
|
call s:InitVariable("g:NERDTreeCopyCmd", 'cp -r ')
|
|
endif
|
|
|
|
|
|
"SECTION: Init variable calls for key mappings {{{2
|
|
call s:InitVariable("g:NERDTreeMapActivateNode", "o")
|
|
call s:InitVariable("g:NERDTreeMapChangeRoot", "C")
|
|
call s:InitVariable("g:NERDTreeMapChdir", "cd")
|
|
call s:InitVariable("g:NERDTreeMapCloseChildren", "X")
|
|
call s:InitVariable("g:NERDTreeMapCloseDir", "x")
|
|
call s:InitVariable("g:NERDTreeMapExecute", "!")
|
|
call s:InitVariable("g:NERDTreeMapFilesystemMenu", "m")
|
|
call s:InitVariable("g:NERDTreeMapHelp", "?")
|
|
call s:InitVariable("g:NERDTreeMapJumpFirstChild", "K")
|
|
call s:InitVariable("g:NERDTreeMapJumpLastChild", "J")
|
|
call s:InitVariable("g:NERDTreeMapJumpNextSibling", "<C-j>")
|
|
call s:InitVariable("g:NERDTreeMapJumpParent", "p")
|
|
call s:InitVariable("g:NERDTreeMapJumpPrevSibling", "<C-k>")
|
|
call s:InitVariable("g:NERDTreeMapJumpRoot", "P")
|
|
call s:InitVariable("g:NERDTreeMapOpenExpl", "e")
|
|
call s:InitVariable("g:NERDTreeMapOpenInTab", "t")
|
|
call s:InitVariable("g:NERDTreeMapOpenInTabSilent", "T")
|
|
call s:InitVariable("g:NERDTreeMapOpenRecursively", "O")
|
|
call s:InitVariable("g:NERDTreeMapOpenSplit", "<tab>")
|
|
call s:InitVariable("g:NERDTreeMapPreview", "g" . NERDTreeMapActivateNode)
|
|
call s:InitVariable("g:NERDTreeMapPreviewSplit", "g" . NERDTreeMapOpenSplit)
|
|
call s:InitVariable("g:NERDTreeMapQuit", "q")
|
|
call s:InitVariable("g:NERDTreeMapRefresh", "r")
|
|
call s:InitVariable("g:NERDTreeMapRefreshRoot", "R")
|
|
call s:InitVariable("g:NERDTreeMapToggleBookmarks", "B")
|
|
call s:InitVariable("g:NERDTreeMapToggleFiles", "F")
|
|
call s:InitVariable("g:NERDTreeMapToggleFilters", "f")
|
|
call s:InitVariable("g:NERDTreeMapToggleHidden", "H")
|
|
call s:InitVariable("g:NERDTreeMapUpdir", "u")
|
|
call s:InitVariable("g:NERDTreeMapUpdirKeepOpen", "U")
|
|
|
|
"SECTION: Script level variable declaration{{{2
|
|
let s:escape_chars = " \\`\|\"#%&,?()\*^<>"
|
|
let s:NERDTreeWinName = '_NERD_tree_'
|
|
|
|
let s:tree_wid = 2
|
|
let s:tree_markup_reg = '[ \-+~`|]'
|
|
let s:tree_markup_reg_neg = '[^ \-+~`|]'
|
|
let s:tree_up_dir_line = '.. (up a dir)'
|
|
|
|
let s:os_slash = '/'
|
|
if s:running_windows
|
|
let s:os_slash = '\'
|
|
endif
|
|
|
|
|
|
" SECTION: Commands {{{1
|
|
"============================================================
|
|
"init the command that users start the nerd tree with
|
|
command! -n=? -complete=dir NERDTree :call s:InitNerdTree('<args>')
|
|
command! -n=? -complete=dir NERDTreeToggle :call s:Toggle('<args>')
|
|
command! -n=0 NERDTreeClose :call s:CloseTreeIfOpen()
|
|
command! -n=1 -complete=customlist,s:CompleteBookmarks NERDTreeFromBookmark call s:InitNerdTree('<args>')
|
|
" SECTION: Auto commands {{{1
|
|
"============================================================
|
|
"Save the cursor position whenever we close the nerd tree
|
|
exec "autocmd BufWinLeave *". s:NERDTreeWinName ."* :call <SID>SaveScreenState()"
|
|
"cache bookmarks when vim loads
|
|
autocmd VimEnter * call s:oBookmark.CacheBookmarks()
|
|
|
|
"SECTION: Classes {{{1
|
|
"============================================================
|
|
"CLASS: oBookmark {{{2
|
|
"============================================================
|
|
let s:oBookmark = {}
|
|
" FUNCTION: oBookmark.AddBookmark(name, path) {{{3
|
|
" Class method to add a new bookmark to the list, if a previous bookmark exists
|
|
" with the same name, just update the path for that bookmark
|
|
function! s:oBookmark.AddBookmark(name, path) dict
|
|
for i in s:oBookmark.Bookmarks()
|
|
if i.name == a:name
|
|
let i.path = a:path
|
|
return
|
|
endif
|
|
endfor
|
|
call add(s:oBookmark.Bookmarks(), s:oBookmark.New(a:name, a:path))
|
|
endfunction
|
|
" Function: oBookmark.Bookmarks() {{{3
|
|
" Class method to get all bookmarks. Lazily initializes the bookmarks global
|
|
" variable
|
|
function! s:oBookmark.Bookmarks() dict
|
|
if !exists("g:NERDTreeBookmarks")
|
|
let g:NERDTreeBookmarks = []
|
|
endif
|
|
return g:NERDTreeBookmarks
|
|
endfunction
|
|
" Function: oBookmark.BookmarkFor(name) {{{3
|
|
" Class method to get the bookmark that has the given name. {} is return if no
|
|
" bookmark is found
|
|
function! s:oBookmark.BookmarkFor(name) dict
|
|
for i in s:oBookmark.Bookmarks()
|
|
if i.name == a:name
|
|
return i
|
|
endif
|
|
endfor
|
|
return {}
|
|
endfunction
|
|
" Function: oBookmark.BookmarkNames() {{{3
|
|
" Class method to return an array of all bookmark names
|
|
function! s:oBookmark.BookmarkNames() dict
|
|
let names = []
|
|
for i in s:oBookmark.Bookmarks()
|
|
call add(names, i.name)
|
|
endfor
|
|
return names
|
|
endfunction
|
|
" FUNCTION: oBookmark.CacheBookmarks() {{{3
|
|
" Class method to read all bookmarks from the bookmarks file intialize
|
|
" bookmark objects for each one.
|
|
function! s:oBookmark.CacheBookmarks() dict
|
|
if filereadable(g:NERDTreeBookmarksFile)
|
|
let bookmarks = []
|
|
let bookmarkStrings = readfile(g:NERDTreeBookmarksFile)
|
|
let invalidBookmarksFound = 0
|
|
for i in bookmarkStrings
|
|
let name = substitute(i, '^\(\w\{-}\) .*$', '\1', '')
|
|
let path = substitute(i, '^\w\{-} \(.*\)$', '\1', '')
|
|
|
|
try
|
|
let bookmark = s:oBookmark.New(name, s:oPath.New(path))
|
|
catch /NERDTree.Path.InvalidArguments/
|
|
let invalidBookmarksFound += 1
|
|
endtry
|
|
call add(bookmarks, bookmark)
|
|
endfor
|
|
let g:NERDTreeBookmarks = bookmarks
|
|
if invalidBookmarksFound
|
|
call s:Echo(invalidBookmarksFound . " invalid bookmarks were read and discarded")
|
|
call s:WriteBookmarks()
|
|
endif
|
|
endif
|
|
endfunction
|
|
" FUNCTION: oBookmark.ClearAll() {{{3
|
|
" Class method to delete all bookmarks.
|
|
function! s:oBookmark.ClearAll() dict
|
|
for i in s:oBookmark.Bookmarks()
|
|
call i.Delete()
|
|
endfor
|
|
call s:oBookmark.Write()
|
|
endfunction
|
|
" FUNCTION: oBookmark.Delete() {{{3
|
|
" Delete this bookmark. If the node for this bookmark is under the current
|
|
" root, then recache bookmarks for its Path object
|
|
function! s:oBookmark.Delete() dict
|
|
let node = {}
|
|
try
|
|
let node = self.GetNode(1)
|
|
catch /NERDTree.BookmarkNodeNotFound/
|
|
endtry
|
|
call remove(s:oBookmark.Bookmarks(), index(s:oBookmark.Bookmarks(), self))
|
|
if !empty(node)
|
|
call node.path.CacheBookmarks()
|
|
endif
|
|
endfunction
|
|
" FUNCTION: oBookmark.GetNode(searchFromAbsoluteRoot) {{{3
|
|
" Gets the treenode for this bookmark
|
|
"
|
|
" Args:
|
|
" searchFromAbsoluteRoot: specifies whether we should search from the current
|
|
" tree root, or the highest cached node
|
|
function! s:oBookmark.GetNode(searchFromAbsoluteRoot) dict
|
|
let searchRoot = a:searchFromAbsoluteRoot ? s:AbsoluteTreeRoot() : t:NERDTreeRoot
|
|
let targetNode = searchRoot.FindNode(self.path)
|
|
if empty(targetNode)
|
|
throw "NERDTree.BookmarkNodeNotFound no node was found for bookmark: " . self.name
|
|
endif
|
|
return targetNode
|
|
endfunction
|
|
" FUNCTION: oBookmark.GetNodeForName(name, searchFromAbsoluteRoot) {{{3
|
|
" Class method that finds the bookmark with the given name and returns the
|
|
" treenode for it.
|
|
function! s:oBookmark.GetNodeForName(name, searchFromAbsoluteRoot) dict
|
|
let bookmark = s:oBookmark.BookmarkFor(a:name)
|
|
if bookmark == {}
|
|
throw "NERDTree.BookmarkNotFound no node was found for bookmark: " . a:name
|
|
endif
|
|
return bookmark.GetNode(a:searchFromAbsoluteRoot)
|
|
endfunction
|
|
" FUNCTION: oBookmark.New(name, path) {{{3
|
|
" Create a new bookmark object with the given name and path object
|
|
function! s:oBookmark.New(name, path) dict
|
|
if a:name !~ '^[0-9a-zA-Z_]*$'
|
|
throw "NERDTree.IllegalBookmarkName illegal name:" a:name
|
|
endif
|
|
|
|
let newBookmark = copy(self)
|
|
let newBookmark.name = a:name
|
|
let newBookmark.path = a:path
|
|
return newBookmark
|
|
endfunction
|
|
" Function: oBookmark.Str() {{{3
|
|
" Get the string that should be rendered in the view for this bookmark
|
|
function! s:oBookmark.Str() dict
|
|
let pathStrMaxLen = winwidth(s:GetTreeWinNum()) - 5 - len(self.name)
|
|
let pathStr = self.path.StrForOS(0)
|
|
if len(pathStr) > pathStrMaxLen
|
|
let pathStr = '<' . strpart(pathStr, len(pathStr) - pathStrMaxLen)
|
|
endif
|
|
return '>' . self.name . ' [' . pathStr . ']'
|
|
endfunction
|
|
" Function: oBookmark.Write() {{{3
|
|
" Class method to write all bookmarks to the bookmarks file
|
|
function! s:oBookmark.Write() dict
|
|
let bookmarkStrings = []
|
|
for i in s:oBookmark.Bookmarks()
|
|
call add(bookmarkStrings, i.name . ' ' . i.path.StrForOS(0))
|
|
endfor
|
|
call writefile(bookmarkStrings, g:NERDTreeBookmarksFile)
|
|
endfunction
|
|
"CLASS: oTreeFileNode {{{2
|
|
"This class is the parent of the oTreeDirNode class and constitures the
|
|
"'Component' part of the composite design pattern between the treenode
|
|
"classes.
|
|
"============================================================
|
|
let s:oTreeFileNode = {}
|
|
"FUNCTION: oTreeFileNode.Bookmark(name) {{{3
|
|
"bookmark this node with a:name
|
|
function! s:oTreeFileNode.Bookmark(name) dict
|
|
try
|
|
let oldMarkedNode = s:oBookmark.GetNodeForName(a:name, 1)
|
|
call oldMarkedNode.path.UncacheBookmark(a:name)
|
|
catch /NERDTree.Bookmark\(DoesntExist\|NotFound\)/
|
|
endtry
|
|
|
|
call s:oBookmark.AddBookmark(a:name, self.path)
|
|
call self.path.CacheBookmarks()
|
|
call s:oBookmark.Write()
|
|
endfunction
|
|
"FUNCTION: oTreeFileNode.CacheParent {{{3
|
|
"initializes self.parent if it isnt already
|
|
function! s:oTreeFileNode.CacheParent() dict
|
|
if empty(self.parent)
|
|
let parentPath = self.path.GetParent()
|
|
if parentPath.Equals(self.path)
|
|
throw "NERDTree.CannotCacheParent exception: already at root"
|
|
endif
|
|
let self.parent = s:oTreeFileNode.New(parentPath)
|
|
endif
|
|
endfunction
|
|
"FUNCTION: oTreeFileNode.CompareNodes {{{3
|
|
"This is supposed to be a class level method but i cant figure out how to
|
|
"get func refs to work from a dict..
|
|
"
|
|
"A class level method that compares two nodes
|
|
"
|
|
"Args:
|
|
"n1, n2: the 2 nodes to compare
|
|
function! s:CompareNodes(n1, n2)
|
|
return a:n1.path.CompareTo(a:n2.path)
|
|
endfunction
|
|
|
|
"FUNCTION: oTreeFileNode.ClearBookmarks() {{{3
|
|
function! s:oTreeFileNode.ClearBookmarks() dict
|
|
for i in s:oBookmark.Bookmarks()
|
|
if i.path.Equals(self.path)
|
|
call i.Delete()
|
|
end
|
|
endfor
|
|
call self.path.CacheBookmarks()
|
|
endfunction
|
|
"FUNCTION: oTreeFileNode.Copy(dest) {{{3
|
|
function! s:oTreeFileNode.Copy(dest) dict
|
|
call self.path.Copy(a:dest)
|
|
let newPath = s:oPath.New(a:dest)
|
|
let parent = t:NERDTreeRoot.FindNode(newPath.GetParent())
|
|
if !empty(parent)
|
|
call parent.Refresh()
|
|
endif
|
|
return parent.FindNode(newPath)
|
|
endfunction
|
|
|
|
"FUNCTION: oTreeFileNode.Delete {{{3
|
|
"Removes this node from the tree and calls the Delete method for its path obj
|
|
function! s:oTreeFileNode.Delete() dict
|
|
call self.path.Delete()
|
|
call self.parent.RemoveChild(self)
|
|
endfunction
|
|
|
|
"FUNCTION: oTreeFileNode.Equals(treenode) {{{3
|
|
"
|
|
"Compares this treenode to the input treenode and returns 1 if they are the
|
|
"same node.
|
|
"
|
|
"Use this method instead of == because sometimes when the treenodes contain
|
|
"many children, vim seg faults when doing ==
|
|
"
|
|
"Args:
|
|
"treenode: the other treenode to compare to
|
|
function! s:oTreeFileNode.Equals(treenode) dict
|
|
return self.path.Str(1) == a:treenode.path.Str(1)
|
|
endfunction
|
|
|
|
"FUNCTION: oTreeFileNode.FindNode(path) {{{3
|
|
"Returns self if this node.path.Equals the given path.
|
|
"Returns {} if not equal.
|
|
"
|
|
"Args:
|
|
"path: the path object to compare against
|
|
function! s:oTreeFileNode.FindNode(path) dict
|
|
if a:path.Equals(self.path)
|
|
return self
|
|
endif
|
|
return {}
|
|
endfunction
|
|
"FUNCTION: oTreeFileNode.FindOpenDirSiblingWithChildren(direction) {{{3
|
|
"
|
|
"Finds the next sibling for this node in the indicated direction. This sibling
|
|
"must be a directory and may/may not have children as specified.
|
|
"
|
|
"Args:
|
|
"direction: 0 if you want to find the previous sibling, 1 for the next sibling
|
|
"
|
|
"Return:
|
|
"a treenode object or {} if no appropriate sibling could be found
|
|
function! s:oTreeFileNode.FindOpenDirSiblingWithChildren(direction) dict
|
|
"if we have no parent then we can have no siblings
|
|
if self.parent != {}
|
|
let nextSibling = self.FindSibling(a:direction)
|
|
|
|
while nextSibling != {}
|
|
if nextSibling.path.isDirectory && nextSibling.HasVisibleChildren() && nextSibling.isOpen
|
|
return nextSibling
|
|
endif
|
|
let nextSibling = nextSibling.FindSibling(a:direction)
|
|
endwhile
|
|
endif
|
|
|
|
return {}
|
|
endfunction
|
|
"FUNCTION: oTreeFileNode.FindSibling(direction) {{{3
|
|
"
|
|
"Finds the next sibling for this node in the indicated direction
|
|
"
|
|
"Args:
|
|
"direction: 0 if you want to find the previous sibling, 1 for the next sibling
|
|
"
|
|
"Return:
|
|
"a treenode object or {} if no sibling could be found
|
|
function! s:oTreeFileNode.FindSibling(direction) dict
|
|
"if we have no parent then we can have no siblings
|
|
if self.parent != {}
|
|
|
|
"get the index of this node in its parents children
|
|
let siblingIndx = self.parent.GetChildIndex(self.path)
|
|
|
|
if siblingIndx != -1
|
|
"move a long to the next potential sibling node
|
|
let siblingIndx = a:direction == 1 ? siblingIndx+1 : siblingIndx-1
|
|
|
|
"keep moving along to the next sibling till we find one that is valid
|
|
let numSiblings = self.parent.GetChildCount()
|
|
while siblingIndx >= 0 && siblingIndx < numSiblings
|
|
|
|
"if the next node is not an ignored node (i.e. wont show up in the
|
|
"view) then return it
|
|
if self.parent.children[siblingIndx].path.Ignore() == 0
|
|
return self.parent.children[siblingIndx]
|
|
endif
|
|
|
|
"go to next node
|
|
let siblingIndx = a:direction == 1 ? siblingIndx+1 : siblingIndx-1
|
|
endwhile
|
|
endif
|
|
endif
|
|
|
|
return {}
|
|
endfunction
|
|
|
|
"FUNCTION: oTreeFileNode.IsVisible() {{{3
|
|
"returns 1 if this node should be visible according to the tree filters and
|
|
"hidden file filters (and their on/off status)
|
|
function! s:oTreeFileNode.IsVisible() dict
|
|
return !self.path.Ignore()
|
|
endfunction
|
|
|
|
|
|
"FUNCTION: oTreeFileNode.IsRoot() {{{3
|
|
"returns 1 if this node is t:NERDTreeRoot
|
|
function! s:oTreeFileNode.IsRoot() dict
|
|
if !s:TreeExistsForTab()
|
|
throw "NERDTree.TreeFileNode.IsRoot exception: No tree exists for the current tab"
|
|
endif
|
|
return self.Equals(t:NERDTreeRoot)
|
|
endfunction
|
|
|
|
"FUNCTION: oTreeFileNode.MakeRoot() {{{3
|
|
"Make this node the root of the tree
|
|
function! s:oTreeFileNode.MakeRoot() dict
|
|
if self.path.isDirectory
|
|
let t:NERDTreeRoot = self
|
|
else
|
|
call self.CacheParent()
|
|
let t:NERDTreeRoot = self.parent
|
|
endif
|
|
|
|
call t:NERDTreeRoot.Open()
|
|
|
|
"change dir to the dir of the new root if instructed to
|
|
if g:NERDTreeChDirMode == 2
|
|
exec "cd " . t:NERDTreeRoot.path.StrForEditCmd()
|
|
endif
|
|
endfunction
|
|
"FUNCTION: oTreeFileNode.New(path) {{{3
|
|
"Returns a new TreeNode object with the given path and parent
|
|
"
|
|
"Args:
|
|
"path: a path object representing the full filesystem path to the file/dir that the node represents
|
|
function! s:oTreeFileNode.New(path) dict
|
|
if a:path.isDirectory
|
|
return s:oTreeDirNode.New(a:path)
|
|
else
|
|
let newTreeNode = {}
|
|
let newTreeNode = copy(self)
|
|
let newTreeNode.path = a:path
|
|
let newTreeNode.parent = {}
|
|
return newTreeNode
|
|
endif
|
|
endfunction
|
|
|
|
"FUNCTION: oTreeFileNode.Refresh {{{3
|
|
function! s:oTreeFileNode.Refresh() dict
|
|
call self.path.Refresh()
|
|
endfunction
|
|
"FUNCTION: oTreeFileNode.Rename {{{3
|
|
"Calls the rename method for this nodes path obj
|
|
function! s:oTreeFileNode.Rename(newName) dict
|
|
let newName = substitute(a:newName, '\(\\\|\/\)$', '', '')
|
|
call self.path.Rename(newName)
|
|
call self.parent.RemoveChild(self)
|
|
|
|
let parentPath = self.path.GetPathTrunk()
|
|
let newParent = t:NERDTreeRoot.FindNode(parentPath)
|
|
|
|
if newParent != {}
|
|
call newParent.CreateChild(self.path, 1)
|
|
endif
|
|
endfunction
|
|
"FUNCTION: oTreeFileNode.StrDisplay() {{{3
|
|
"
|
|
"Returns a string that specifies how the node should be represented as a
|
|
"string
|
|
"
|
|
"Return:
|
|
"a string that can be used in the view to represent this node
|
|
function! s:oTreeFileNode.StrDisplay() dict
|
|
return self.path.StrDisplay()
|
|
endfunction
|
|
|
|
"CLASS: oTreeDirNode {{{2
|
|
"This class is a child of the oTreeFileNode class and constitutes the
|
|
"'Composite' part of the composite design pattern between the treenode
|
|
"classes.
|
|
"============================================================
|
|
let s:oTreeDirNode = copy(s:oTreeFileNode)
|
|
"FUNCTION: oTreeDirNode.AddChild(treenode, inOrder) {{{3
|
|
"Adds the given treenode to the list of children for this node
|
|
"
|
|
"Args:
|
|
"-treenode: the node to add
|
|
"-inOrder: 1 if the new node should be inserted in sorted order
|
|
function! s:oTreeDirNode.AddChild(treenode, inOrder) dict
|
|
call add(self.children, a:treenode)
|
|
let a:treenode.parent = self
|
|
|
|
if a:inOrder
|
|
call self.SortChildren()
|
|
endif
|
|
endfunction
|
|
|
|
"FUNCTION: oTreeDirNode.Close {{{3
|
|
"Closes this directory
|
|
function! s:oTreeDirNode.Close() dict
|
|
let self.isOpen = 0
|
|
endfunction
|
|
|
|
"FUNCTION: oTreeDirNode.CloseChildren {{{3
|
|
"Closes all the child dir nodes of this node
|
|
function! s:oTreeDirNode.CloseChildren() dict
|
|
for i in self.children
|
|
if i.path.isDirectory
|
|
call i.Close()
|
|
call i.CloseChildren()
|
|
endif
|
|
endfor
|
|
endfunction
|
|
|
|
"FUNCTION: oTreeDirNode.CreateChild(path, inOrder) {{{3
|
|
"Instantiates a new child node for this node with the given path. The new
|
|
"nodes parent is set to this node.
|
|
"
|
|
"Args:
|
|
"path: a Path object that this node will represent/contain
|
|
"inOrder: 1 if the new node should be inserted in sorted order
|
|
"
|
|
"Returns:
|
|
"the newly created node
|
|
function! s:oTreeDirNode.CreateChild(path, inOrder) dict
|
|
let newTreeNode = s:oTreeFileNode.New(a:path)
|
|
call self.AddChild(newTreeNode, a:inOrder)
|
|
return newTreeNode
|
|
endfunction
|
|
|
|
"FUNCTION: oTreeDirNode.FindNode(path) {{{3
|
|
"Will find one of the children (recursively) that has the given path
|
|
"
|
|
"Args:
|
|
"path: a path object
|
|
unlet s:oTreeDirNode.FindNode
|
|
function! s:oTreeDirNode.FindNode(path) dict
|
|
if a:path.Equals(self.path)
|
|
return self
|
|
endif
|
|
if stridx(a:path.Str(1), self.path.Str(1), 0) == -1
|
|
return {}
|
|
endif
|
|
|
|
if self.path.isDirectory
|
|
for i in self.children
|
|
let retVal = i.FindNode(a:path)
|
|
if retVal != {}
|
|
return retVal
|
|
endif
|
|
endfor
|
|
endif
|
|
return {}
|
|
endfunction
|
|
|
|
"FUNCTION: oTreeDirNode.GetChildDirs() {{{3
|
|
"Returns the number of children this node has
|
|
function! s:oTreeDirNode.GetChildCount() dict
|
|
return len(self.children)
|
|
endfunction
|
|
|
|
"FUNCTION: oTreeDirNode.GetChildDirs() {{{3
|
|
"Returns an array of all children of this node that are directories
|
|
"
|
|
"Return:
|
|
"an array of directory treenodes
|
|
function! s:oTreeDirNode.GetChildDirs() dict
|
|
let toReturn = []
|
|
for i in self.children
|
|
if i.path.isDirectory
|
|
call add(toReturn, i)
|
|
endif
|
|
endfor
|
|
return toReturn
|
|
endfunction
|
|
|
|
"FUNCTION: oTreeDirNode.GetChildFiles() {{{3
|
|
"Returns an array of all children of this node that are files
|
|
"
|
|
"Return:
|
|
"an array of file treenodes
|
|
function! s:oTreeDirNode.GetChildFiles() dict
|
|
let toReturn = []
|
|
for i in self.children
|
|
if i.path.isDirectory == 0
|
|
call add(toReturn, i)
|
|
endif
|
|
endfor
|
|
return toReturn
|
|
endfunction
|
|
|
|
"FUNCTION: oTreeDirNode.GetChild(path) {{{3
|
|
"Returns child node of this node that has the given path or {} if no such node
|
|
"exists.
|
|
"
|
|
"This function doesnt not recurse into child dir nodes
|
|
"
|
|
"Args:
|
|
"path: a path object
|
|
function! s:oTreeDirNode.GetChild(path) dict
|
|
if stridx(a:path.Str(1), self.path.Str(1), 0) == -1
|
|
return {}
|
|
endif
|
|
|
|
let index = self.GetChildIndex(a:path)
|
|
if index == -1
|
|
return {}
|
|
else
|
|
return self.children[index]
|
|
endif
|
|
|
|
endfunction
|
|
|
|
"FUNCTION: oTreeDirNode.GetChildByIndex(indx, visible) {{{3
|
|
"returns the child at the given index
|
|
"Args:
|
|
"indx: the index to get the child from
|
|
"visible: 1 if only the visible children array should be used, 0 if all the
|
|
"children should be searched.
|
|
function! s:oTreeDirNode.GetChildByIndex(indx, visible) dict
|
|
let array_to_search = a:visible? self.GetVisibleChildren() : self.children
|
|
if a:indx > len(array_to_search)
|
|
throw "NERDTree.TreeDirNode.InvalidArguments exception. Index is out of bounds."
|
|
endif
|
|
return array_to_search[a:indx]
|
|
endfunction
|
|
|
|
"FUNCTION: oTreeDirNode.GetChildIndex(path) {{{3
|
|
"Returns the index of the child node of this node that has the given path or
|
|
"-1 if no such node exists.
|
|
"
|
|
"This function doesnt not recurse into child dir nodes
|
|
"
|
|
"Args:
|
|
"path: a path object
|
|
function! s:oTreeDirNode.GetChildIndex(path) dict
|
|
if stridx(a:path.Str(1), self.path.Str(1), 0) == -1
|
|
return -1
|
|
endif
|
|
|
|
"do a binary search for the child
|
|
let a = 0
|
|
let z = self.GetChildCount()
|
|
while a < z
|
|
let mid = (a+z)/2
|
|
let diff = a:path.CompareTo(self.children[mid].path)
|
|
|
|
if diff == -1
|
|
let z = mid
|
|
elseif diff == 1
|
|
let a = mid+1
|
|
else
|
|
return mid
|
|
endif
|
|
endwhile
|
|
return -1
|
|
endfunction
|
|
|
|
"FUNCTION: oTreeDirNode.GetVisibleChildCount() {{{3
|
|
"Returns the number of visible children this node has
|
|
function! s:oTreeDirNode.GetVisibleChildCount() dict
|
|
return len(self.GetVisibleChildren())
|
|
endfunction
|
|
|
|
"FUNCTION: oTreeDirNode.GetVisibleChildren() {{{3
|
|
"Returns a list of children to display for this node, in the correct order
|
|
"
|
|
"Return:
|
|
"an array of treenodes
|
|
function! s:oTreeDirNode.GetVisibleChildren() dict
|
|
let toReturn = []
|
|
for i in self.children
|
|
if i.path.Ignore() == 0
|
|
call add(toReturn, i)
|
|
endif
|
|
endfor
|
|
return toReturn
|
|
endfunction
|
|
|
|
"FUNCTION: oTreeDirNode.HasVisibleChildren {{{3
|
|
"returns 1 if this node has any childre, 0 otherwise..
|
|
function! s:oTreeDirNode.HasVisibleChildren()
|
|
return self.GetChildCount() != 0
|
|
endfunction
|
|
|
|
"FUNCTION: oTreeDirNode.InitChildren {{{3
|
|
"Removes all childen from this node and re-reads them
|
|
"
|
|
"Args:
|
|
"silent: 1 if the function should not echo any "please wait" messages for
|
|
"large directories
|
|
"
|
|
"Return: the number of child nodes read
|
|
function! s:oTreeDirNode.InitChildren(silent) dict
|
|
"remove all the current child nodes
|
|
let self.children = []
|
|
|
|
"get an array of all the files in the nodes dir
|
|
let dir = self.path
|
|
let filesStr = globpath(dir.StrForGlob(), '*') . "\n" . globpath(dir.StrForGlob(), '.*')
|
|
let files = split(filesStr, "\n")
|
|
|
|
if !a:silent && len(files) > g:NERDTreeNotificationThreshold
|
|
call s:Echo("Please wait, caching a large dir ...")
|
|
endif
|
|
|
|
let invalidFilesFound = 0
|
|
for i in files
|
|
|
|
"filter out the .. and . directories
|
|
"Note: we must match .. AND ../ cos sometimes the globpath returns
|
|
"../ for path with strange chars (eg $)
|
|
if i !~ '\.\.\/\?$' && i !~ '\.\/\?$'
|
|
|
|
"put the next file in a new node and attach it
|
|
try
|
|
let path = s:oPath.New(i)
|
|
call self.CreateChild(path, 0)
|
|
catch /^NERDTree.Path.InvalidArguments/
|
|
let invalidFilesFound = 1
|
|
endtry
|
|
endif
|
|
endfor
|
|
|
|
call self.SortChildren()
|
|
|
|
if !a:silent && len(files) > g:NERDTreeNotificationThreshold
|
|
call s:Echo("Please wait, caching a large dir ... DONE (". self.GetChildCount() ." nodes cached).")
|
|
endif
|
|
|
|
if invalidFilesFound
|
|
call s:EchoWarning("some files could not be loaded into the NERD tree")
|
|
endif
|
|
return self.GetChildCount()
|
|
endfunction
|
|
"FUNCTION: oTreeDirNode.New(path) {{{3
|
|
"Returns a new TreeNode object with the given path and parent
|
|
"
|
|
"Args:
|
|
"path: a path object representing the full filesystem path to the file/dir that the node represents
|
|
unlet s:oTreeDirNode.New
|
|
function! s:oTreeDirNode.New(path) dict
|
|
if a:path.isDirectory != 1
|
|
throw "NERDTree.TreeDirNode.InvalidArguments exception. A TreeDirNode object must be instantiated with a directory Path object."
|
|
endif
|
|
|
|
let newTreeNode = copy(self)
|
|
let newTreeNode.path = a:path
|
|
|
|
let newTreeNode.isOpen = 0
|
|
let newTreeNode.children = []
|
|
|
|
let newTreeNode.parent = {}
|
|
|
|
return newTreeNode
|
|
endfunction
|
|
"FUNCTION: oTreeDirNode.Open {{{3
|
|
"Reads in all this nodes children
|
|
"
|
|
"Return: the number of child nodes read
|
|
function! s:oTreeDirNode.Open() dict
|
|
let self.isOpen = 1
|
|
if self.children == []
|
|
return self.InitChildren(0)
|
|
else
|
|
return 0
|
|
endif
|
|
endfunction
|
|
|
|
"FUNCTION: oTreeDirNode.OpenRecursively {{{3
|
|
"Opens this treenode and all of its children whose paths arent 'ignored'
|
|
"because of the file filters.
|
|
"
|
|
"This method is actually a wrapper for the OpenRecursively2 method which does
|
|
"the work.
|
|
function! s:oTreeDirNode.OpenRecursively() dict
|
|
call self.OpenRecursively2(1)
|
|
endfunction
|
|
|
|
"FUNCTION: oTreeDirNode.OpenRecursively2 {{{3
|
|
"Dont call this method from outside this object.
|
|
"
|
|
"Opens this all children of this treenode recursively if either:
|
|
" *they arent filtered by file filters
|
|
" *a:forceOpen is 1
|
|
"
|
|
"Args:
|
|
"forceOpen: 1 if this node should be opened regardless of file filters
|
|
function! s:oTreeDirNode.OpenRecursively2(forceOpen) dict
|
|
if self.path.Ignore() == 0 || a:forceOpen
|
|
let self.isOpen = 1
|
|
if self.children == []
|
|
call self.InitChildren(1)
|
|
endif
|
|
|
|
for i in self.children
|
|
if i.path.isDirectory == 1
|
|
call i.OpenRecursively2(0)
|
|
endif
|
|
endfor
|
|
endif
|
|
endfunction
|
|
|
|
"FUNCTION: oTreeDirNode.Refresh {{{3
|
|
unlet s:oTreeDirNode.Refresh
|
|
function! s:oTreeDirNode.Refresh() dict
|
|
call self.path.Refresh()
|
|
|
|
"if this node was ever opened, refresh its children
|
|
if self.isOpen || !empty(self.children)
|
|
"go thru all the files/dirs under this node
|
|
let newChildNodes = []
|
|
let invalidFilesFound = 0
|
|
let dir = self.path
|
|
let filesStr = globpath(dir.StrForGlob(), '*') . "\n" . globpath(dir.StrForGlob(), '.*')
|
|
let files = split(filesStr, "\n")
|
|
for i in files
|
|
if i !~ '\.\.$' && i !~ '\.$'
|
|
|
|
try
|
|
"create a new path and see if it exists in this nodes children
|
|
let path = s:oPath.New(i)
|
|
let newNode = self.GetChild(path)
|
|
if newNode != {}
|
|
call newNode.Refresh()
|
|
call add(newChildNodes, newNode)
|
|
|
|
"the node doesnt exist so create it
|
|
else
|
|
let newNode = s:oTreeFileNode.New(path)
|
|
let newNode.parent = self
|
|
call add(newChildNodes, newNode)
|
|
endif
|
|
|
|
|
|
catch /^NERDTree.InvalidArguments/
|
|
let invalidFilesFound = 1
|
|
endtry
|
|
endif
|
|
endfor
|
|
|
|
"swap this nodes children out for the children we just read/refreshed
|
|
let self.children = newChildNodes
|
|
call self.SortChildren()
|
|
|
|
if invalidFilesFound
|
|
call s:EchoWarning("some files could not be loaded into the NERD tree")
|
|
endif
|
|
endif
|
|
endfunction
|
|
|
|
"FUNCTION: oTreeDirNode.RemoveChild {{{3
|
|
"
|
|
"Removes the given treenode from this nodes set of children
|
|
"
|
|
"Args:
|
|
"treenode: the node to remove
|
|
"
|
|
"Throws a NERDTree.TreeDirNode exception if the given treenode is not found
|
|
function! s:oTreeDirNode.RemoveChild(treenode) dict
|
|
for i in range(0, self.GetChildCount()-1)
|
|
if self.children[i].Equals(a:treenode)
|
|
call remove(self.children, i)
|
|
return
|
|
endif
|
|
endfor
|
|
|
|
throw "NERDTree.TreeDirNode exception: child node was not found"
|
|
endfunction
|
|
|
|
"FUNCTION: oTreeDirNode.SortChildren {{{3
|
|
"
|
|
"Sorts the children of this node according to alphabetical order and the
|
|
"directory priority.
|
|
"
|
|
function! s:oTreeDirNode.SortChildren() dict
|
|
let CompareFunc = function("s:CompareNodes")
|
|
call sort(self.children, CompareFunc)
|
|
endfunction
|
|
|
|
"FUNCTION: oTreeDirNode.ToggleOpen {{{3
|
|
"Opens this directory if it is closed and vice versa
|
|
function! s:oTreeDirNode.ToggleOpen() dict
|
|
if self.isOpen == 1
|
|
call self.Close()
|
|
else
|
|
call self.Open()
|
|
endif
|
|
endfunction
|
|
|
|
"FUNCTION: oTreeDirNode.TransplantChild(newNode) {{{3
|
|
"Replaces the child of this with the given node (where the child node's full
|
|
"path matches a:newNode's fullpath). The search for the matching node is
|
|
"non-recursive
|
|
"
|
|
"Arg:
|
|
"newNode: the node to graft into the tree
|
|
function! s:oTreeDirNode.TransplantChild(newNode) dict
|
|
for i in range(0, self.GetChildCount()-1)
|
|
if self.children[i].Equals(a:newNode)
|
|
let self.children[i] = a:newNode
|
|
let a:newNode.parent = self
|
|
break
|
|
endif
|
|
endfor
|
|
endfunction
|
|
"============================================================
|
|
"CLASS: oPath {{{2
|
|
"============================================================
|
|
let s:oPath = {}
|
|
"FUNCTION: oPath.BookmarkNames() {{{3
|
|
function! s:oPath.BookmarkNames() dict
|
|
if !exists("self.bookmark")
|
|
call self.CacheBookmarks()
|
|
endif
|
|
return self.bookmarkNames
|
|
endfunction
|
|
"FUNCTION: oPath.CacheBookmarks() {{{3
|
|
function! s:oPath.CacheBookmarks() dict
|
|
let self.bookmarkNames = []
|
|
for i in s:oBookmark.Bookmarks()
|
|
if i.path.Equals(self)
|
|
call add(self.bookmarkNames, i.name)
|
|
endif
|
|
endfor
|
|
return self.bookmarkNames
|
|
endfunction
|
|
"FUNCTION: oPath.ChangeToDir() {{{3
|
|
function! s:oPath.ChangeToDir() dict
|
|
let dir = self.StrForCd()
|
|
if self.isDirectory == 0
|
|
let dir = self.GetPathTrunk().StrForCd()
|
|
endif
|
|
|
|
try
|
|
execute "cd " . dir
|
|
call s:Echo("CWD is now: " . getcwd())
|
|
catch
|
|
throw "NERDTree.Path.Change exception: cannot change to " . dir
|
|
endtry
|
|
endfunction
|
|
|
|
"FUNCTION: oPath.ChopTrailingSlash(str) {{{3
|
|
function! s:oPath.ChopTrailingSlash(str) dict
|
|
if a:str =~ '\/$'
|
|
return substitute(a:str, "\/$", "", "")
|
|
else
|
|
return substitute(a:str, "\\$", "", "")
|
|
endif
|
|
endfunction
|
|
|
|
"FUNCTION: oPath.CompareTo() {{{3
|
|
"
|
|
"Compares this oPath to the given path and returns 0 if they are equal, -1 if
|
|
"this oPath is "less than" the given path, or 1 if it is "greater".
|
|
"
|
|
"Args:
|
|
"path: the path object to compare this to
|
|
"
|
|
"Return:
|
|
"1, -1 or 0
|
|
function! s:oPath.CompareTo(path) dict
|
|
let thisPath = self.GetLastPathComponent(1)
|
|
let thatPath = a:path.GetLastPathComponent(1)
|
|
|
|
"if the paths are the same then clearly we return 0
|
|
if thisPath == thatPath
|
|
return 0
|
|
endif
|
|
|
|
let thisSS = self.GetSortOrderIndex()
|
|
let thatSS = a:path.GetSortOrderIndex()
|
|
|
|
"compare the sort sequences, if they are different then the return
|
|
"value is easy
|
|
if thisSS < thatSS
|
|
return -1
|
|
elseif thisSS > thatSS
|
|
return 1
|
|
else
|
|
"if the sort sequences are the same then compare the paths
|
|
"alphabetically
|
|
let pathCompare = g:NERDTreeCaseSensitiveSort ? thisPath <# thatPath : thisPath <? thatPath
|
|
if pathCompare
|
|
return -1
|
|
else
|
|
return 1
|
|
endif
|
|
endif
|
|
endfunction
|
|
|
|
"FUNCTION: oPath.Create(fullpath) {{{3
|
|
"
|
|
"Factory method.
|
|
"
|
|
"Creates a path object with the given path. The path is also created on the
|
|
"filesystem. If the path already exists, a NERDTree.Path.Exists exception is
|
|
"thrown. If any other errors occur, a NERDTree.Path exception is thrown.
|
|
"
|
|
"Args:
|
|
"fullpath: the full filesystem path to the file/dir to create
|
|
function! s:oPath.Create(fullpath) dict
|
|
"bail if the a:fullpath already exists
|
|
if isdirectory(a:fullpath) || filereadable(a:fullpath)
|
|
throw "NERDTree.Path.Exists Exception: Directory Exists: '" . a:fullpath . "'"
|
|
endif
|
|
|
|
try
|
|
|
|
"if it ends with a slash, assume its a dir create it
|
|
if a:fullpath =~ '\(\\\|\/\)$'
|
|
"whack the trailing slash off the end if it exists
|
|
let fullpath = substitute(a:fullpath, '\(\\\|\/\)$', '', '')
|
|
|
|
call mkdir(fullpath, 'p')
|
|
|
|
"assume its a file and create
|
|
else
|
|
call writefile([], a:fullpath)
|
|
endif
|
|
catch /.*/
|
|
throw "NERDTree.Path Exception: Could not create path: '" . a:fullpath . "'"
|
|
endtry
|
|
|
|
return s:oPath.New(a:fullpath)
|
|
endfunction
|
|
|
|
"FUNCTION: oPath.Copy(dest) {{{3
|
|
"
|
|
"Copies the file/dir represented by this Path to the given location
|
|
"
|
|
"Args:
|
|
"dest: the location to copy this dir/file to
|
|
function! s:oPath.Copy(dest) dict
|
|
if !s:oPath.CopyingSupported()
|
|
throw "NERDTree.Path.CopyingNotSupported Exception: Copying is not supported on this OS"
|
|
endif
|
|
|
|
let dest = s:oPath.WinToUnixPath(a:dest)
|
|
|
|
let cmd = g:NERDTreeCopyCmd . " " . self.StrForOS(0) . " " . dest
|
|
let success = system(cmd)
|
|
if success != 0
|
|
throw "NERDTree.Path Exception: Could not copy ''". self.StrForOS(0) ."'' to: '" . a:dest . "'"
|
|
endif
|
|
endfunction
|
|
|
|
"FUNCTION: oPath.CopyingSupported() {{{3
|
|
"
|
|
"returns 1 if copying is supported for this OS
|
|
function! s:oPath.CopyingSupported() dict
|
|
return exists('g:NERDTreeCopyCmd')
|
|
endfunction
|
|
|
|
|
|
"FUNCTION: oPath.CopyingWillOverwrite(dest) {{{3
|
|
"
|
|
"returns 1 if copy this path to the given location will cause files to
|
|
"overwritten
|
|
"
|
|
"Args:
|
|
"dest: the location this path will be copied to
|
|
function! s:oPath.CopyingWillOverwrite(dest) dict
|
|
if filereadable(a:dest)
|
|
return 1
|
|
endif
|
|
|
|
if isdirectory(a:dest)
|
|
let path = s:oPath.JoinPathStrings(a:dest, self.GetLastPathComponent(0))
|
|
if filereadable(path)
|
|
return 1
|
|
endif
|
|
endif
|
|
endfunction
|
|
|
|
"FUNCTION: oPath.Delete() {{{3
|
|
"
|
|
"Deletes the file represented by this path.
|
|
"Deletion of directories is not supported
|
|
"
|
|
"Throws NERDTree.Path.Deletion exceptions
|
|
function! s:oPath.Delete() dict
|
|
if self.isDirectory
|
|
|
|
let cmd = ""
|
|
if s:running_windows
|
|
"if we are runnnig windows then put quotes around the pathstring
|
|
let cmd = g:NERDTreeRemoveDirCmd . self.StrForOS(1)
|
|
else
|
|
let cmd = g:NERDTreeRemoveDirCmd . self.StrForOS(1)
|
|
endif
|
|
let success = system(cmd)
|
|
|
|
if v:shell_error != 0
|
|
throw "NERDTree.Path.Deletion Exception: Could not delete directory: '" . self.StrForOS(0) . "'"
|
|
endif
|
|
else
|
|
let success = delete(self.StrForOS(0))
|
|
if success != 0
|
|
throw "NERDTree.Path.Deletion Exception: Could not delete file: '" . self.Str(0) . "'"
|
|
endif
|
|
endif
|
|
endfunction
|
|
|
|
"FUNCTION: oPath.ExtractDriveLetter(fullpath) {{{3
|
|
"
|
|
"If running windows, cache the drive letter for this path
|
|
function! s:oPath.ExtractDriveLetter(fullpath) dict
|
|
if s:running_windows
|
|
let self.drive = substitute(a:fullpath, '\(^[a-zA-Z]:\).*', '\1', '')
|
|
else
|
|
let self.drive = ''
|
|
endif
|
|
|
|
endfunction
|
|
"FUNCTION: oPath.GetDir() {{{3
|
|
"
|
|
"Returns this path if it is a directory, else this paths parent.
|
|
"
|
|
"Return:
|
|
"a Path object
|
|
function! s:oPath.GetDir() dict
|
|
if self.isDirectory
|
|
return self
|
|
else
|
|
return self.GetParent()
|
|
endif
|
|
endfunction
|
|
|
|
|
|
"FUNCTION: oPath.GetParent() {{{3
|
|
"
|
|
"Returns a new path object for this paths parent
|
|
"
|
|
"Return:
|
|
"a new Path object
|
|
function! s:oPath.GetParent() dict
|
|
let path = '/'. join(self.pathSegments[0:-2], '/')
|
|
return s:oPath.New(path)
|
|
endfunction
|
|
"FUNCTION: oPath.GetLastPathComponent(dirSlash) {{{3
|
|
"
|
|
"Gets the last part of this path.
|
|
"
|
|
"Args:
|
|
"dirSlash: if 1 then a trailing slash will be added to the returned value for
|
|
"directory nodes.
|
|
function! s:oPath.GetLastPathComponent(dirSlash) dict
|
|
if empty(self.pathSegments)
|
|
return ''
|
|
endif
|
|
let toReturn = self.pathSegments[-1]
|
|
if a:dirSlash && self.isDirectory
|
|
let toReturn = toReturn . '/'
|
|
endif
|
|
return toReturn
|
|
endfunction
|
|
|
|
"FUNCTION: oPath.GetPathTrunk() {{{3
|
|
"Gets the path without the last segment on the end.
|
|
function! s:oPath.GetPathTrunk() dict
|
|
return s:oPath.New(self.StrTrunk())
|
|
endfunction
|
|
|
|
"FUNCTION: oPath.GetSortOrderIndex() {{{3
|
|
"returns the index of the pattern in g:NERDTreeSortOrder that this path matches
|
|
function! s:oPath.GetSortOrderIndex() dict
|
|
let i = 0
|
|
while i < len(g:NERDTreeSortOrder)
|
|
if self.GetLastPathComponent(1) =~ g:NERDTreeSortOrder[i]
|
|
return i
|
|
endif
|
|
let i = i + 1
|
|
endwhile
|
|
return s:NERDTreeSortStarIndex
|
|
endfunction
|
|
|
|
"FUNCTION: oPath.Ignore() {{{3
|
|
"returns true if this path should be ignored
|
|
function! s:oPath.Ignore() dict
|
|
let lastPathComponent = self.GetLastPathComponent(0)
|
|
|
|
"filter out the user specified paths to ignore
|
|
if t:NERDTreeIgnoreEnabled
|
|
for i in g:NERDTreeIgnore
|
|
if lastPathComponent =~ i
|
|
return 1
|
|
endif
|
|
endfor
|
|
endif
|
|
|
|
"dont show hidden files unless instructed to
|
|
if g:NERDTreeShowHidden == 0 && lastPathComponent =~ '^\.'
|
|
return 1
|
|
endif
|
|
|
|
if g:NERDTreeShowFiles == 0 && self.isDirectory == 0
|
|
return 1
|
|
endif
|
|
|
|
return 0
|
|
endfunction
|
|
|
|
"FUNCTION: oPath.JoinPathStrings(...) {{{3
|
|
function! s:oPath.JoinPathStrings(...) dict
|
|
let components = []
|
|
for i in a:000
|
|
let components = extend(components, split(i, '/'))
|
|
endfor
|
|
return '/' . join(components, '/')
|
|
endfunction
|
|
|
|
"FUNCTION: oPath.Equals() {{{3
|
|
"
|
|
"Determines whether 2 path objects are "equal".
|
|
"They are equal if the paths they represent are the same
|
|
"
|
|
"Args:
|
|
"path: the other path obj to compare this with
|
|
function! s:oPath.Equals(path) dict
|
|
return self.Str(0) == a:path.Str(0)
|
|
endfunction
|
|
|
|
"FUNCTION: oPath.New() {{{3
|
|
"
|
|
"The Constructor for the Path object
|
|
"Throws NERDTree.Path.InvalidArguments exception.
|
|
function! s:oPath.New(fullpath) dict
|
|
let newPath = copy(self)
|
|
|
|
call newPath.ReadInfoFromDisk(a:fullpath)
|
|
|
|
return newPath
|
|
endfunction
|
|
|
|
"FUNCTION: oPath.ReadInfoFromDisk(fullpath) {{{3
|
|
"
|
|
"
|
|
"Throws NERDTree.Path.InvalidArguments exception.
|
|
function! s:oPath.ReadInfoFromDisk(fullpath) dict
|
|
call self.ExtractDriveLetter(a:fullpath)
|
|
|
|
let fullpath = s:oPath.WinToUnixPath(a:fullpath)
|
|
|
|
let self.pathSegments = split(fullpath, '/')
|
|
|
|
let self.isReadOnly = 0
|
|
if isdirectory(a:fullpath)
|
|
let self.isDirectory = 1
|
|
elseif filereadable(a:fullpath)
|
|
let self.isDirectory = 0
|
|
let self.isReadOnly = filewritable(a:fullpath) == 0
|
|
else
|
|
throw "NERDTree.Path.InvalidArguments Exception: Invalid path = " . a:fullpath
|
|
endif
|
|
|
|
let self.isExecutable = 0
|
|
if !self.isDirectory
|
|
let self.isExecutable = getfperm(a:fullpath) =~ 'x'
|
|
endif
|
|
|
|
"grab the last part of the path (minus the trailing slash)
|
|
let lastPathComponent = self.GetLastPathComponent(0)
|
|
|
|
"get the path to the new node with the parent dir fully resolved
|
|
let hardPath = resolve(self.StrTrunk()) . '/' . lastPathComponent
|
|
|
|
"if the last part of the path is a symlink then flag it as such
|
|
let self.isSymLink = (resolve(hardPath) != hardPath)
|
|
if self.isSymLink
|
|
let self.symLinkDest = resolve(fullpath)
|
|
|
|
"if the link is a dir then slap a / on the end of its dest
|
|
if isdirectory(self.symLinkDest)
|
|
|
|
"we always wanna treat MS windows shortcuts as files for
|
|
"simplicity
|
|
if hardPath !~ '\.lnk$'
|
|
|
|
let self.symLinkDest = self.symLinkDest . '/'
|
|
endif
|
|
endif
|
|
endif
|
|
endfunction
|
|
|
|
"FUNCTION: oPath.Refresh() {{{3
|
|
function! s:oPath.Refresh() dict
|
|
call self.ReadInfoFromDisk(self.StrForOS(0))
|
|
call self.CacheBookmarks()
|
|
endfunction
|
|
|
|
"FUNCTION: oPath.Rename() {{{3
|
|
"
|
|
"Renames this node on the filesystem
|
|
function! s:oPath.Rename(newPath) dict
|
|
if a:newPath == ''
|
|
throw "NERDTree.Path.InvalidArguments exception. Invalid newPath for renaming = ". a:newPath
|
|
endif
|
|
|
|
let success = rename(self.StrForOS(0), a:newPath)
|
|
if success != 0
|
|
throw "NERDTree.Path.Rename Exception: Could not rename: '" . self.StrForOS(0) . "'" . 'to:' . a:newPath
|
|
endif
|
|
call self.ReadInfoFromDisk(a:newPath)
|
|
endfunction
|
|
|
|
"FUNCTION: oPath.Str(esc) {{{3
|
|
"
|
|
"Gets the actual string path that this obj represents.
|
|
"
|
|
"Args:
|
|
"esc: if 1 then all the tricky chars in the returned string will be escaped
|
|
function! s:oPath.Str(esc) dict
|
|
let toReturn = '/' . join(self.pathSegments, '/')
|
|
if self.isDirectory && toReturn != '/'
|
|
let toReturn = toReturn . '/'
|
|
endif
|
|
|
|
if a:esc
|
|
let toReturn = escape(toReturn, s:escape_chars)
|
|
endif
|
|
return toReturn
|
|
endfunction
|
|
|
|
"FUNCTION: oPath.StrAbs() {{{3
|
|
"
|
|
"Returns a string representing this path with all the symlinks resolved
|
|
"
|
|
"Return:
|
|
"string
|
|
function! s:oPath.StrAbs() dict
|
|
return resolve(self.Str(1))
|
|
endfunction
|
|
|
|
"FUNCTION: oPath.StrForCd() {{{3
|
|
"
|
|
" returns a string that can be used with :cd
|
|
"
|
|
"Return:
|
|
"a string that can be used in the view to represent this path
|
|
function! s:oPath.StrForCd() dict
|
|
if s:running_windows
|
|
return self.StrForOS(0)
|
|
else
|
|
return self.StrForOS(1)
|
|
endif
|
|
endfunction
|
|
"FUNCTION: oPath.StrDisplay() {{{3
|
|
"
|
|
"Returns a string that specifies how the path should be represented as a
|
|
"string
|
|
"
|
|
"Return:
|
|
"a string that can be used in the view to represent this path
|
|
function! s:oPath.StrDisplay() dict
|
|
let toReturn = self.GetLastPathComponent(1)
|
|
|
|
if self.isExecutable
|
|
let toReturn = toReturn . '*'
|
|
endif
|
|
|
|
if !empty(self.BookmarkNames())
|
|
let toReturn .= ' {' . join(self.BookmarkNames(), ',') . '}'
|
|
endif
|
|
|
|
if self.isSymLink
|
|
let toReturn .= ' -> ' . self.symLinkDest
|
|
endif
|
|
|
|
if self.isReadOnly
|
|
let toReturn .= ' [RO]'
|
|
endif
|
|
|
|
return toReturn
|
|
endfunction
|
|
|
|
"FUNCTION: oPath.StrForEditCmd() {{{3
|
|
"
|
|
"Return: the string for this path that is suitable to be used with the :edit
|
|
"command
|
|
function! s:oPath.StrForEditCmd() dict
|
|
if s:running_windows
|
|
return self.StrForOS(0)
|
|
else
|
|
return self.Str(1)
|
|
endif
|
|
|
|
endfunction
|
|
"FUNCTION: oPath.StrForGlob() {{{3
|
|
function! s:oPath.StrForGlob() dict
|
|
let lead = s:os_slash
|
|
|
|
"if we are running windows then slap a drive letter on the front
|
|
if s:running_windows
|
|
let lead = self.drive . '\'
|
|
endif
|
|
|
|
let toReturn = lead . join(self.pathSegments, s:os_slash)
|
|
|
|
if !s:running_windows
|
|
let toReturn = escape(toReturn, s:escape_chars)
|
|
endif
|
|
return toReturn
|
|
endfunction
|
|
"FUNCTION: oPath.StrForOS(esc) {{{3
|
|
"
|
|
"Gets the string path for this path object that is appropriate for the OS.
|
|
"EG, in windows c:\foo\bar
|
|
" in *nix /foo/bar
|
|
"
|
|
"Args:
|
|
"esc: if 1 then all the tricky chars in the returned string will be
|
|
" escaped. If we are running windows then the str is double quoted instead.
|
|
function! s:oPath.StrForOS(esc) dict
|
|
let lead = s:os_slash
|
|
|
|
"if we are running windows then slap a drive letter on the front
|
|
if s:running_windows
|
|
let lead = self.drive . '\'
|
|
endif
|
|
|
|
let toReturn = lead . join(self.pathSegments, s:os_slash)
|
|
|
|
if a:esc
|
|
if s:running_windows
|
|
let toReturn = '"' . toReturn . '"'
|
|
else
|
|
let toReturn = escape(toReturn, s:escape_chars)
|
|
endif
|
|
endif
|
|
return toReturn
|
|
endfunction
|
|
|
|
"FUNCTION: oPath.StrTrunk() {{{3
|
|
"Gets the path without the last segment on the end.
|
|
function! s:oPath.StrTrunk() dict
|
|
return self.drive . '/' . join(self.pathSegments[0:-2], '/')
|
|
endfunction
|
|
|
|
"FUNCTION: oPath.UncacheBookmark(name){{{3
|
|
"remove the given bookmark from this paths cached bookmarks
|
|
function! s:oPath.UncacheBookmark(name) dict
|
|
let bookmarks = self.BookmarkNames()
|
|
let i = index(bookmarks, a:name)
|
|
if i != -1
|
|
call remove(bookmarks, i)
|
|
endif
|
|
endfunction
|
|
"FUNCTION: oPath.WinToUnixPath(pathstr){{{3
|
|
"Takes in a windows path and returns the unix equiv
|
|
"
|
|
"A class level method
|
|
"
|
|
"Args:
|
|
"pathstr: the windows path to convert
|
|
function! s:oPath.WinToUnixPath(pathstr) dict
|
|
if !s:running_windows
|
|
return a:pathstr
|
|
endif
|
|
|
|
let toReturn = a:pathstr
|
|
|
|
"remove the x:\ of the front
|
|
let toReturn = substitute(toReturn, '^.*:\(\\\|/\)\?', '/', "")
|
|
|
|
"convert all \ chars to /
|
|
let toReturn = substitute(toReturn, '\', '/', "g")
|
|
|
|
return toReturn
|
|
endfunction
|
|
|
|
" SECTION: General Functions {{{1
|
|
"============================================================
|
|
"FUNCTION: s:Abs(num){{{2
|
|
"returns the absolute value of the input
|
|
function! s:Abs(num)
|
|
if a:num > 0
|
|
return a:num
|
|
else
|
|
return 0 - a:num
|
|
end
|
|
endfunction
|
|
"FUNCTION: s:AbsoluteTreeRoot(){{{2
|
|
" returns the highest cached ancestor of the current root
|
|
function! s:AbsoluteTreeRoot()
|
|
let currentNode = t:NERDTreeRoot
|
|
while currentNode.parent != {}
|
|
let currentNode = currentNode.parent
|
|
endwhile
|
|
return currentNode
|
|
endfunction
|
|
"FUNCTION: s:BufInWindows(bnum){{{2
|
|
"[[STOLEN FROM VTREEEXPLORER.VIM]]
|
|
"Determine the number of windows open to this buffer number.
|
|
"Care of Yegappan Lakshman. Thanks!
|
|
"
|
|
"Args:
|
|
"bnum: the subject buffers buffer number
|
|
function! s:BufInWindows(bnum)
|
|
let cnt = 0
|
|
let winnum = 1
|
|
while 1
|
|
let bufnum = winbufnr(winnum)
|
|
if bufnum < 0
|
|
break
|
|
endif
|
|
if bufnum == a:bnum
|
|
let cnt = cnt + 1
|
|
endif
|
|
let winnum = winnum + 1
|
|
endwhile
|
|
|
|
return cnt
|
|
endfunction " >>>
|
|
|
|
" FUNCTION: s:CompleteBookmarks(A,L,P) {{{2
|
|
" completion function for the bookmark commands
|
|
function! s:CompleteBookmarks(A,L,P)
|
|
return filter(s:oBookmark.BookmarkNames(), 'v:val =~ "^' . a:A . '"')
|
|
endfunction
|
|
"FUNCTION: s:InitNerdTree(name) {{{2
|
|
"Initialise the nerd tree for this tab. The tree will start in either the
|
|
"given directory, or the directory associated with the given bookmark
|
|
"
|
|
"Args:
|
|
"name: the name of a bookmark or a directory
|
|
function! s:InitNerdTree(name)
|
|
let path = {}
|
|
if s:oBookmark.BookmarkFor(a:name) != {}
|
|
let path = s:oBookmark.BookmarkFor(a:name).path
|
|
else
|
|
let dir = a:name == '' ? expand('%:p:h') : a:name
|
|
let dir = resolve(dir)
|
|
try
|
|
let path = s:oPath.New(dir)
|
|
catch /NERDTree.Path.InvalidArguments/
|
|
call s:Echo("No bookmark or directory found for: " . a:name)
|
|
return
|
|
endtry
|
|
endif
|
|
if !path.isDirectory
|
|
let path = path.GetParent()
|
|
endif
|
|
|
|
"if instructed to, then change the vim CWD to the dir the NERDTree is
|
|
"inited in
|
|
if g:NERDTreeChDirMode != 0
|
|
exec 'cd ' . path.StrForCd()
|
|
endif
|
|
|
|
let t:treeShowHelp = 0
|
|
let t:NERDTreeIgnoreEnabled = 1
|
|
|
|
if s:TreeExistsForTab()
|
|
if s:IsTreeOpen()
|
|
call s:CloseTree()
|
|
endif
|
|
unlet t:NERDTreeRoot
|
|
endif
|
|
|
|
let t:NERDTreeRoot = s:oTreeDirNode.New(path)
|
|
call t:NERDTreeRoot.Open()
|
|
|
|
call s:CreateTreeWin()
|
|
call s:RenderView()
|
|
call s:PutCursorOnNode(t:NERDTreeRoot, 0, 0)
|
|
endfunction
|
|
" Function: s:TreeExistsForTab() {{{2
|
|
" Returns 1 if a nerd tree root exists in the current tab
|
|
function! s:TreeExistsForTab()
|
|
return exists("t:NERDTreeRoot")
|
|
endfunction
|
|
" SECTION: Public Functions {{{1
|
|
"============================================================
|
|
"Returns the node that the cursor is currently on.
|
|
"
|
|
"If the cursor is not in the NERDTree window, it is temporarily put there.
|
|
"
|
|
"If no NERD tree window exists for the current tab, a NERDTree.NoTreeForTab
|
|
"exception is thrown.
|
|
"
|
|
"If the cursor is not on a node then an empty dictionary {} is returned.
|
|
function! NERDTreeGetCurrentNode()
|
|
if !s:TreeExistsForTab() || !s:IsTreeOpen()
|
|
throw "NERDTree.NoTreeForTab exception: there is no NERD tree open for the current tab"
|
|
endif
|
|
|
|
let winnr = winnr()
|
|
if winnr != s:GetTreeWinNum()
|
|
call s:PutCursorInTreeWin()
|
|
endif
|
|
|
|
let treenode = s:GetSelectedNode()
|
|
|
|
if winnr != winnr()
|
|
wincmd w
|
|
endif
|
|
|
|
return treenode
|
|
endfunction
|
|
|
|
"Returns the path object for the current node.
|
|
"
|
|
"Subject to the same conditions as NERDTreeGetCurrentNode
|
|
function! NERDTreeGetCurrentPath()
|
|
let node = NERDTreeGetCurrentNode()
|
|
if node != {}
|
|
return node.path
|
|
else
|
|
return {}
|
|
endif
|
|
endfunction
|
|
|
|
" SECTION: View Functions {{{1
|
|
"============================================================
|
|
"FUNCTION: s:CenterView() {{{2
|
|
"centers the nerd tree window around the cursor (provided the nerd tree
|
|
"options permit)
|
|
function! s:CenterView()
|
|
if g:NERDTreeAutoCenter
|
|
let current_line = winline()
|
|
let lines_to_top = current_line
|
|
let lines_to_bottom = winheight(s:GetTreeWinNum()) - current_line
|
|
if lines_to_top < g:NERDTreeAutoCenterThreshold || lines_to_bottom < g:NERDTreeAutoCenterThreshold
|
|
normal! zz
|
|
endif
|
|
endif
|
|
endfunction
|
|
"FUNCTION: s:CloseTreeIfOpen() {{{2
|
|
"Closes the NERD tree window if it is open
|
|
function! s:CloseTreeIfOpen()
|
|
if s:IsTreeOpen()
|
|
call s:CloseTree()
|
|
endif
|
|
endfunction
|
|
"FUNCTION: s:CloseTree() {{{2
|
|
"Closes the NERD tree window
|
|
function! s:CloseTree()
|
|
if !s:IsTreeOpen()
|
|
throw "NERDTree.view.CloseTree exception: no NERDTree is open"
|
|
endif
|
|
|
|
if winnr("$") != 1
|
|
execute s:GetTreeWinNum() . " wincmd w"
|
|
close
|
|
execute "wincmd p"
|
|
else
|
|
:q
|
|
endif
|
|
endfunction
|
|
|
|
"FUNCTION: s:CreateTreeWin() {{{2
|
|
"Inits the NERD tree window. ie. opens it, sizes it, sets all the local
|
|
"options etc
|
|
function! s:CreateTreeWin()
|
|
"create the nerd tree window
|
|
let splitLocation = g:NERDTreeWinPos ? "topleft " : "botright "
|
|
let splitMode = g:NERDTreeSplitVertical ? "vertical " : ""
|
|
let splitSize = g:NERDTreeWinSize
|
|
let t:NERDTreeWinName = localtime() . s:NERDTreeWinName
|
|
let cmd = splitLocation . splitMode . splitSize . ' new ' . t:NERDTreeWinName
|
|
silent! execute cmd
|
|
|
|
setlocal winfixwidth
|
|
|
|
"throwaway buffer options
|
|
setlocal noswapfile
|
|
setlocal buftype=nofile
|
|
setlocal bufhidden=delete
|
|
setlocal nowrap
|
|
setlocal foldcolumn=0
|
|
setlocal nobuflisted
|
|
setlocal nospell
|
|
if g:NERDTreeShowLineNumbers
|
|
setlocal nu
|
|
else
|
|
setlocal nonu
|
|
endif
|
|
|
|
iabc <buffer>
|
|
|
|
if g:NERDTreeHighlightCursorline
|
|
setlocal cursorline
|
|
endif
|
|
|
|
|
|
" for line continuation
|
|
let cpo_save1 = &cpo
|
|
set cpo&vim
|
|
|
|
call s:BindMappings()
|
|
setfiletype nerdtree
|
|
" syntax highlighting
|
|
if has("syntax") && exists("g:syntax_on") && !has("syntax_items")
|
|
call s:SetupSyntaxHighlighting()
|
|
endif
|
|
endfunction
|
|
|
|
"FUNCTION: s:DrawTree {{{2
|
|
"Draws the given node recursively
|
|
"
|
|
"Args:
|
|
"curNode: the node that is being rendered with this call
|
|
"depth: the current depth in the tree for this call
|
|
"drawText: 1 if we should actually draw the line for this node (if 0 then the
|
|
"child nodes are rendered only)
|
|
"vertMap: a binary array that indicates whether a vertical bar should be draw
|
|
"for each depth in the tree
|
|
"isLastChild:true if this curNode is the last child of its parent
|
|
function! s:DrawTree(curNode, depth, drawText, vertMap, isLastChild)
|
|
if a:drawText == 1
|
|
|
|
let treeParts = ''
|
|
|
|
"get all the leading spaces and vertical tree parts for this line
|
|
if a:depth > 1
|
|
for j in a:vertMap[0:-2]
|
|
if j == 1
|
|
let treeParts = treeParts . '| '
|
|
else
|
|
let treeParts = treeParts . ' '
|
|
endif
|
|
endfor
|
|
endif
|
|
|
|
"get the last vertical tree part for this line which will be different
|
|
"if this node is the last child of its parent
|
|
if a:isLastChild
|
|
let treeParts = treeParts . '`'
|
|
else
|
|
let treeParts = treeParts . '|'
|
|
endif
|
|
|
|
|
|
"smack the appropriate dir/file symbol on the line before the file/dir
|
|
"name itself
|
|
if a:curNode.path.isDirectory
|
|
if a:curNode.isOpen
|
|
let treeParts = treeParts . '~'
|
|
else
|
|
let treeParts = treeParts . '+'
|
|
endif
|
|
else
|
|
let treeParts = treeParts . '-'
|
|
endif
|
|
let line = treeParts . a:curNode.StrDisplay()
|
|
|
|
call setline(line(".")+1, line)
|
|
call cursor(line(".")+1, col("."))
|
|
endif
|
|
|
|
"if the node is an open dir, draw its children
|
|
if a:curNode.path.isDirectory == 1 && a:curNode.isOpen == 1
|
|
|
|
let childNodesToDraw = a:curNode.GetVisibleChildren()
|
|
if len(childNodesToDraw) > 0
|
|
|
|
"draw all the nodes children except the last
|
|
let lastIndx = len(childNodesToDraw)-1
|
|
if lastIndx > 0
|
|
for i in childNodesToDraw[0:lastIndx-1]
|
|
call s:DrawTree(i, a:depth + 1, 1, add(copy(a:vertMap), 1), 0)
|
|
endfor
|
|
endif
|
|
|
|
"draw the last child, indicating that it IS the last
|
|
call s:DrawTree(childNodesToDraw[lastIndx], a:depth + 1, 1, add(copy(a:vertMap), 0), 1)
|
|
endif
|
|
endif
|
|
endfunction
|
|
|
|
|
|
"FUNCTION: s:DumpHelp {{{2
|
|
"prints out the quick help
|
|
function! s:DumpHelp()
|
|
let old_h = @h
|
|
if t:treeShowHelp == 1
|
|
let @h= "\" NERD tree (" . s:NERD_tree_version . ") quickhelp~\n"
|
|
let @h=@h."\" ============================\n"
|
|
let @h=@h."\" File node mappings~\n"
|
|
let @h=@h."\" ". (g:NERDTreeMouseMode == 3 ? "single" : "double") ."-click,\n"
|
|
let @h=@h."\" ". g:NERDTreeMapActivateNode .": open in prev window\n"
|
|
let @h=@h."\" ". g:NERDTreeMapPreview .": preview\n"
|
|
let @h=@h."\" ". g:NERDTreeMapOpenInTab.": open in new tab\n"
|
|
let @h=@h."\" ". g:NERDTreeMapOpenInTabSilent .": open in new tab silently\n"
|
|
let @h=@h."\" middle-click,\n"
|
|
let @h=@h."\" ". g:NERDTreeMapOpenSplit .": open split\n"
|
|
let @h=@h."\" ". g:NERDTreeMapPreviewSplit .": preview split\n"
|
|
let @h=@h."\" ". g:NERDTreeMapExecute.": Execute file\n"
|
|
|
|
let @h=@h."\"\n\" ----------------------------\n"
|
|
let @h=@h."\" Directory node mappings~\n"
|
|
let @h=@h."\" ". (g:NERDTreeMouseMode == 1 ? "double" : "single") ."-click,\n"
|
|
let @h=@h."\" ". g:NERDTreeMapActivateNode .": open & close node\n"
|
|
let @h=@h."\" ". g:NERDTreeMapOpenRecursively .": recursively open node\n"
|
|
let @h=@h."\" ". g:NERDTreeMapCloseDir .": close parent of node\n"
|
|
let @h=@h."\" ". g:NERDTreeMapCloseChildren .": close all child nodes of\n"
|
|
let @h=@h."\" current node recursively\n"
|
|
let @h=@h."\" middle-click,\n"
|
|
let @h=@h."\" ". g:NERDTreeMapOpenExpl.": Open netrw for selected\n"
|
|
let @h=@h."\" node\n"
|
|
|
|
let @h=@h."\"\n\" ----------------------------\n"
|
|
let @h=@h."\" Bookmark table mappings~\n"
|
|
let @h=@h."\" double-click,\n"
|
|
let @h=@h."\" ". g:NERDTreeMapActivateNode .": activate bookmark\n"
|
|
|
|
let @h=@h."\"\n\" ----------------------------\n"
|
|
let @h=@h."\" Tree navigation mappings~\n"
|
|
let @h=@h."\" ". g:NERDTreeMapJumpRoot .": go to root\n"
|
|
let @h=@h."\" ". g:NERDTreeMapJumpParent .": go to parent\n"
|
|
let @h=@h."\" ". g:NERDTreeMapJumpFirstChild .": go to first child\n"
|
|
let @h=@h."\" ". g:NERDTreeMapJumpLastChild .": go to last child\n"
|
|
let @h=@h."\" ". g:NERDTreeMapJumpNextSibling .": go to next sibling\n"
|
|
let @h=@h."\" ". g:NERDTreeMapJumpPrevSibling .": go to prev sibling\n"
|
|
|
|
let @h=@h."\"\n\" ----------------------------\n"
|
|
let @h=@h."\" Filesystem mappings~\n"
|
|
let @h=@h."\" ". g:NERDTreeMapChangeRoot .": change tree root to the\n"
|
|
let @h=@h."\" selected dir\n"
|
|
let @h=@h."\" ". g:NERDTreeMapUpdir .": move tree root up a dir\n"
|
|
let @h=@h."\" ". g:NERDTreeMapUpdirKeepOpen .": move tree root up a dir\n"
|
|
let @h=@h."\" but leave old root open\n"
|
|
let @h=@h."\" ". g:NERDTreeMapRefresh .": refresh cursor dir\n"
|
|
let @h=@h."\" ". g:NERDTreeMapRefreshRoot .": refresh current root\n"
|
|
let @h=@h."\" ". g:NERDTreeMapFilesystemMenu .": Show filesystem menu\n"
|
|
let @h=@h."\" ". g:NERDTreeMapChdir .":change the CWD to the\n"
|
|
let @h=@h."\" selected dir\n"
|
|
|
|
let @h=@h."\"\n\" ----------------------------\n"
|
|
let @h=@h."\" Tree filtering mappings~\n"
|
|
let @h=@h."\" ". g:NERDTreeMapToggleHidden .": hidden files (" . (g:NERDTreeShowHidden ? "on" : "off") . ")\n"
|
|
let @h=@h."\" ". g:NERDTreeMapToggleFilters .": file filters (" . (t:NERDTreeIgnoreEnabled ? "on" : "off") . ")\n"
|
|
let @h=@h."\" ". g:NERDTreeMapToggleFiles .": files (" . (g:NERDTreeShowFiles ? "on" : "off") . ")\n"
|
|
let @h=@h."\" ". g:NERDTreeMapToggleBookmarks .": bookmarks (" . (g:NERDTreeShowBookmarks ? "on" : "off") . ")\n"
|
|
|
|
let @h=@h."\"\n\" ----------------------------\n"
|
|
let @h=@h."\" Other mappings~\n"
|
|
let @h=@h."\" ". g:NERDTreeMapQuit .": Close the NERDTree window\n"
|
|
let @h=@h."\" ". g:NERDTreeMapHelp .": toggle help\n"
|
|
let @h=@h."\"\n\" ----------------------------\n"
|
|
let @h=@h."\" Bookmark commands~\n"
|
|
let @h=@h."\" :Bookmark <name>\n"
|
|
let @h=@h."\" :BookmarkToRoot <name>\n"
|
|
let @h=@h."\" :RevealBookmark <name>\n"
|
|
let @h=@h."\" :OpenBookmark <name>\n"
|
|
let @h=@h."\" :ClearBookmarks [<names>]\n"
|
|
let @h=@h."\" :ClearAllBookmarks\n"
|
|
else
|
|
let @h="\" Press ". g:NERDTreeMapHelp ." for help\n"
|
|
endif
|
|
|
|
silent! put h
|
|
|
|
let @h = old_h
|
|
endfunction
|
|
"FUNCTION: s:Echo {{{2
|
|
"A wrapper for :echo. Appends 'NERDTree:' on the front of all messages
|
|
"
|
|
"Args:
|
|
"msg: the message to echo
|
|
function! s:Echo(msg)
|
|
redraw
|
|
echomsg "NERDTree: " . a:msg
|
|
endfunction
|
|
"FUNCTION: s:EchoWarning {{{2
|
|
"Wrapper for s:Echo, sets the message type to warningmsg for this message
|
|
"Args:
|
|
"msg: the message to echo
|
|
function! s:EchoWarning(msg)
|
|
echohl warningmsg
|
|
call s:Echo(a:msg)
|
|
echohl normal
|
|
endfunction
|
|
"FUNCTION: s:EchoError {{{2
|
|
"Wrapper for s:Echo, sets the message type to errormsg for this message
|
|
"Args:
|
|
"msg: the message to echo
|
|
function! s:EchoError(msg)
|
|
echohl errormsg
|
|
call s:Echo(a:msg)
|
|
echohl normal
|
|
endfunction
|
|
"FUNCTION: s:FindNodeLineNumber(treenode){{{2
|
|
"Finds the line number for the given tree node
|
|
"
|
|
"Args:
|
|
"treenode: the node to find the line no. for
|
|
function! s:FindNodeLineNumber(treenode)
|
|
"if the node is the root then return the root line no.
|
|
if a:treenode.IsRoot()
|
|
return s:FindRootNodeLineNumber()
|
|
endif
|
|
|
|
let totalLines = line("$")
|
|
|
|
"the path components we have matched so far
|
|
let pathcomponents = [substitute(t:NERDTreeRoot.path.Str(0), '/ *$', '', '')]
|
|
"the index of the component we are searching for
|
|
let curPathComponent = 1
|
|
|
|
let fullpath = a:treenode.path.Str(0)
|
|
|
|
|
|
let lnum = s:FindRootNodeLineNumber()
|
|
while lnum > 0
|
|
let lnum = lnum + 1
|
|
"have we reached the bottom of the tree?
|
|
if lnum == totalLines+1
|
|
return -1
|
|
endif
|
|
|
|
let curLine = getline(lnum)
|
|
|
|
let indent = match(curLine,s:tree_markup_reg_neg) / s:tree_wid
|
|
if indent == curPathComponent
|
|
let curLine = s:StripMarkupFromLine(curLine, 1)
|
|
|
|
let curPath = join(pathcomponents, '/') . '/' . curLine
|
|
if stridx(fullpath, curPath, 0) == 0
|
|
if fullpath == curPath || strpart(fullpath, len(curPath)-1,1) == '/'
|
|
let curLine = substitute(curLine, '/ *$', '', '')
|
|
call add(pathcomponents, curLine)
|
|
let curPathComponent = curPathComponent + 1
|
|
|
|
if fullpath == curPath
|
|
return lnum
|
|
endif
|
|
endif
|
|
endif
|
|
endif
|
|
endwhile
|
|
return -1
|
|
endfunction
|
|
|
|
"FUNCTION: s:FindRootNodeLineNumber(){{{2
|
|
"Finds the line number of the root node
|
|
function! s:FindRootNodeLineNumber()
|
|
let rootLine = 1
|
|
while getline(rootLine) !~ '^/'
|
|
let rootLine = rootLine + 1
|
|
endwhile
|
|
return rootLine
|
|
endfunction
|
|
|
|
"FUNCTION: s:GetPath(ln) {{{2
|
|
"Gets the full path to the node that is rendered on the given line number
|
|
"
|
|
"Args:
|
|
"ln: the line number to get the path for
|
|
"
|
|
"Return:
|
|
"A path if a node was selected, {} if nothing is selected.
|
|
"If the 'up a dir' line was selected then the path to the parent of the
|
|
"current root is returned
|
|
function! s:GetPath(ln)
|
|
let line = getline(a:ln)
|
|
|
|
"check to see if we have the root node
|
|
if line =~ '^\/'
|
|
return t:NERDTreeRoot.path
|
|
endif
|
|
|
|
" in case called from outside the tree
|
|
if line !~ '^ *[|`]' || line =~ '^$'
|
|
return {}
|
|
endif
|
|
|
|
if line == s:tree_up_dir_line
|
|
return t:NERDTreeRoot.path.GetParent()
|
|
endif
|
|
|
|
"get the indent level for the file (i.e. how deep in the tree it is)
|
|
let indent = match(line, s:tree_markup_reg_neg) / s:tree_wid
|
|
|
|
|
|
"remove the tree parts and the leading space
|
|
let curFile = s:StripMarkupFromLine(line, 0)
|
|
|
|
let wasdir = 0
|
|
if curFile =~ '/$'
|
|
let wasdir = 1
|
|
let curFile = substitute(curFile, '/\?$', '/', "")
|
|
endif
|
|
|
|
|
|
let dir = ""
|
|
let lnum = a:ln
|
|
while lnum > 0
|
|
let lnum = lnum - 1
|
|
let curLine = getline(lnum)
|
|
let curLineStripped = s:StripMarkupFromLine(curLine, 1)
|
|
|
|
"have we reached the top of the tree?
|
|
if curLine =~ '^/'
|
|
let dir = substitute (curLine, ' *$', "", "") . dir
|
|
break
|
|
endif
|
|
if curLineStripped =~ '/$'
|
|
let lpindent = match(curLine,s:tree_markup_reg_neg) / s:tree_wid
|
|
if lpindent < indent
|
|
let indent = indent - 1
|
|
|
|
let dir = substitute (curLineStripped,'^\\', "", "") . dir
|
|
continue
|
|
endif
|
|
endif
|
|
endwhile
|
|
let curFile = t:NERDTreeRoot.path.drive . dir . curFile
|
|
let toReturn = s:oPath.New(curFile)
|
|
return toReturn
|
|
endfunction
|
|
|
|
"FUNCTION: s:GetSelectedBookmark() {{{2
|
|
"Returns the current node if it is a dir node, or else returns the current
|
|
"nodes parent
|
|
function! s:GetSelectedBookmark()
|
|
let line = getline(".")
|
|
let name = substitute(line, '^>\(.\{-}\) \[.*\]$', '\1', '')
|
|
if name != line
|
|
return s:oBookmark.BookmarkFor(name)
|
|
endif
|
|
endfunction
|
|
|
|
"FUNCTION: s:GetSelectedDir() {{{2
|
|
"Returns the current node if it is a dir node, or else returns the current
|
|
"nodes parent
|
|
function! s:GetSelectedDir()
|
|
let currentDir = s:GetSelectedNode()
|
|
if currentDir != {} && !currentDir.IsRoot()
|
|
if currentDir.path.isDirectory == 0
|
|
let currentDir = currentDir.parent
|
|
endif
|
|
endif
|
|
return currentDir
|
|
endfunction
|
|
"FUNCTION: s:GetSelectedNode() {{{2
|
|
"gets the treenode that the cursor is currently over
|
|
function! s:GetSelectedNode()
|
|
try
|
|
let path = s:GetPath(line("."))
|
|
if path == {}
|
|
return {}
|
|
endif
|
|
return t:NERDTreeRoot.FindNode(path)
|
|
catch /^NERDTree/
|
|
return {}
|
|
endtry
|
|
endfunction
|
|
"FUNCTION: s:GetTreeBufNum() {{{2
|
|
"gets the nerd tree buffer number for this tab
|
|
function! s:GetTreeBufNum()
|
|
if exists("t:NERDTreeWinName")
|
|
return bufnr(t:NERDTreeWinName)
|
|
else
|
|
return -1
|
|
endif
|
|
endfunction
|
|
"FUNCTION: s:GetTreeWinNum() {{{2
|
|
"gets the nerd tree window number for this tab
|
|
function! s:GetTreeWinNum()
|
|
if exists("t:NERDTreeWinName")
|
|
return bufwinnr(t:NERDTreeWinName)
|
|
else
|
|
return -1
|
|
endif
|
|
endfunction
|
|
|
|
"FUNCTION: s:IsTreeOpen() {{{2
|
|
function! s:IsTreeOpen()
|
|
return s:GetTreeWinNum() != -1
|
|
endfunction
|
|
|
|
" FUNCTION: s:JumpToChild(direction) {{{2
|
|
" Args:
|
|
" direction: 0 if going to first child, 1 if going to last
|
|
function! s:JumpToChild(direction)
|
|
let currentNode = s:GetSelectedNode()
|
|
if currentNode == {} || currentNode.IsRoot()
|
|
call s:Echo("cannot jump to " . (a:direction ? "last" : "first") . " child")
|
|
return
|
|
end
|
|
let dirNode = currentNode.parent
|
|
let childNodes = dirNode.GetVisibleChildren()
|
|
|
|
let targetNode = childNodes[0]
|
|
if a:direction
|
|
let targetNode = childNodes[len(childNodes) - 1]
|
|
endif
|
|
|
|
if targetNode.Equals(currentNode)
|
|
let siblingDir = currentNode.parent.FindOpenDirSiblingWithChildren(a:direction)
|
|
if siblingDir != {}
|
|
let indx = a:direction ? siblingDir.GetVisibleChildCount()-1 : 0
|
|
let targetNode = siblingDir.GetChildByIndex(indx, 1)
|
|
endif
|
|
endif
|
|
|
|
call s:PutCursorOnNode(targetNode, 1, 0)
|
|
|
|
call s:CenterView()
|
|
endfunction
|
|
|
|
|
|
"FUNCTION: s:OpenDirNodeSplit(treenode) {{{2
|
|
"Open the file represented by the given node in a new window.
|
|
"No action is taken for file nodes
|
|
"
|
|
"ARGS:
|
|
"treenode: file node to open
|
|
function! s:OpenDirNodeSplit(treenode)
|
|
if a:treenode.path.isDirectory == 1
|
|
call s:OpenNodeSplit(a:treenode)
|
|
endif
|
|
endfunction
|
|
|
|
" FUNCTION: s:OpenExplorerFor(treenode) {{{2
|
|
" opens a netrw window for the given dir treenode
|
|
function! s:OpenExplorerFor(treenode)
|
|
let oldwin = winnr()
|
|
wincmd p
|
|
if oldwin == winnr() || (&modified && s:BufInWindows(winbufnr(winnr())) < 2)
|
|
wincmd p
|
|
call s:OpenDirNodeSplit(a:treenode)
|
|
else
|
|
exec ("silent edit " . a:treenode.path.StrForEditCmd())
|
|
endif
|
|
endfunction
|
|
"FUNCTION: s:OpenFileNode(treenode) {{{2
|
|
"Open the file represented by the given node in the current window, splitting
|
|
"the window if needed
|
|
"
|
|
"ARGS:
|
|
"treenode: file node to open
|
|
function! s:OpenFileNode(treenode)
|
|
call s:PutCursorInTreeWin()
|
|
|
|
"if the file is already open in this tab then just stick the cursor in it
|
|
let winnr = bufwinnr(a:treenode.path.StrForOS(0))
|
|
if winnr != -1
|
|
exec winnr . "wincmd w"
|
|
|
|
elseif s:ShouldSplitToOpen(winnr("#"))
|
|
call s:OpenFileNodeSplit(a:treenode)
|
|
else
|
|
try
|
|
wincmd p
|
|
exec ("edit " . a:treenode.path.StrForEditCmd())
|
|
catch /^Vim\%((\a\+)\)\=:E37/
|
|
call s:PutCursorInTreeWin()
|
|
call s:Echo("Cannot open file, it is already open and modified")
|
|
catch /^Vim\%((\a\+)\)\=:/
|
|
echo v:exception
|
|
endtry
|
|
endif
|
|
endfunction
|
|
|
|
"FUNCTION: s:OpenFileNodeSplit(treenode) {{{2
|
|
"Open the file represented by the given node in a new window.
|
|
"No action is taken for dir nodes
|
|
"
|
|
"ARGS:
|
|
"treenode: file node to open
|
|
function! s:OpenFileNodeSplit(treenode)
|
|
if a:treenode.path.isDirectory == 0
|
|
try
|
|
call s:OpenNodeSplit(a:treenode)
|
|
catch /^NERDTree.view.FileOpen/
|
|
call s:Echo("Cannot open file, it is already open and modified" )
|
|
endtry
|
|
endif
|
|
endfunction
|
|
|
|
"FUNCTION: s:OpenNodeSplit(treenode) {{{2
|
|
"Open the file/dir represented by the given node in a new window
|
|
"
|
|
"ARGS:
|
|
"treenode: file node to open
|
|
function! s:OpenNodeSplit(treenode)
|
|
call s:PutCursorInTreeWin()
|
|
|
|
" Save the user's settings for splitbelow and splitright
|
|
let savesplitbelow=&splitbelow
|
|
let savesplitright=&splitright
|
|
|
|
" Figure out how to do the split based on the user's preferences.
|
|
" We want to split to the (left,right,top,bottom) of the explorer
|
|
" window, but we want to extract the screen real-estate from the
|
|
" window next to the explorer if possible.
|
|
"
|
|
" '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.
|
|
"
|
|
if g:NERDTreeSplitVertical == 1
|
|
let there= g:NERDTreeWinPos ? "wincmd h" : "wincmd l"
|
|
let back= g:NERDTreeWinPos ? "wincmd l" : "wincmd h"
|
|
let right=g:NERDTreeWinPos ? 1 : 0
|
|
let below=0
|
|
else
|
|
let there= g:NERDTreeWinPos ? "wincmd k" : "wincmd j"
|
|
let back= g:NERDTreeWinPos ? "wincmd j" : "wincmd k"
|
|
let right=0
|
|
let below=g:NERDTreeWinPos ? 1 : 0
|
|
endif
|
|
|
|
" Attempt to go to adjacent window
|
|
exec(back)
|
|
|
|
let onlyOneWin = (winnr() == s:GetTreeWinNum())
|
|
|
|
" If no adjacent window, set splitright and splitbelow appropriately
|
|
if onlyOneWin
|
|
let &splitright=right
|
|
let &splitbelow=below
|
|
else
|
|
" found adjacent window - invert split direction
|
|
let &splitright=!right
|
|
let &splitbelow=!below
|
|
endif
|
|
|
|
" Create a variable to use if splitting vertically
|
|
let splitMode = ""
|
|
if (onlyOneWin && g:NERDTreeSplitVertical) || (!onlyOneWin && !g:NERDTreeSplitVertical)
|
|
let splitMode = "vertical"
|
|
endif
|
|
|
|
" Open the new window
|
|
try
|
|
exec("silent " . splitMode." sp " . a:treenode.path.StrForEditCmd())
|
|
catch /^Vim\%((\a\+)\)\=:E37/
|
|
call s:PutCursorInTreeWin()
|
|
throw "NERDTree.view.FileOpen exception: ". a:treenode.path.Str(0) ." is already open and modified."
|
|
catch /^Vim\%((\a\+)\)\=:/
|
|
"do nothing
|
|
endtry
|
|
|
|
"resize the tree window if no other window was open before
|
|
if onlyOneWin
|
|
let size = exists("t:NERDTreeOldWindowSize") ? t:NERDTreeOldWindowSize : g:NERDTreeWinSize
|
|
exec(there)
|
|
exec("silent ". splitMode ." resize ". size)
|
|
wincmd p
|
|
endif
|
|
|
|
" Restore splitmode settings
|
|
let &splitbelow=savesplitbelow
|
|
let &splitright=savesplitright
|
|
endfunction
|
|
|
|
"FUNCTION: s:PromptToDelBuffer(bufnum, msg){{{2
|
|
"prints out the given msg and, if the user responds by pushing 'y' then the
|
|
"buffer with the given bufnum is deleted
|
|
"
|
|
"Args:
|
|
"bufnum: the buffer that may be deleted
|
|
"msg: a message that will be echoed to the user asking them if they wish to
|
|
" del the buffer
|
|
function! s:PromptToDelBuffer(bufnum, msg)
|
|
echo a:msg
|
|
if nr2char(getchar()) == 'y'
|
|
exec "silent bdelete! " . a:bufnum
|
|
endif
|
|
endfunction
|
|
|
|
"FUNCTION: s:PutCursorOnNode(treenode, isJump, recurseUpward){{{2
|
|
"Places the cursor on the line number representing the given node
|
|
"
|
|
"Args:
|
|
"treenode: the node to put the cursor on
|
|
"isJump: 1 if this cursor movement should be counted as a jump by vim
|
|
"recurseUpward: try to put the cursor on the parent if the this node isnt
|
|
"visible
|
|
function! s:PutCursorOnNode(treenode, isJump, recurseUpward)
|
|
let ln = s:FindNodeLineNumber(a:treenode)
|
|
if ln != -1
|
|
if a:isJump
|
|
mark '
|
|
endif
|
|
call cursor(ln, col("."))
|
|
else
|
|
if a:recurseUpward
|
|
let node = a:treenode
|
|
while s:FindNodeLineNumber(node) == -1 && node != {}
|
|
let node = node.parent
|
|
call node.Open()
|
|
endwhile
|
|
call s:RenderView()
|
|
call s:PutCursorOnNode(a:treenode, a:isJump, 0)
|
|
endif
|
|
endif
|
|
endfunction
|
|
|
|
"FUNCTION: s:PutCursorInTreeWin(){{{2
|
|
"Places the cursor in the nerd tree window
|
|
function! s:PutCursorInTreeWin()
|
|
if !s:IsTreeOpen()
|
|
throw "NERDTree.view.InvalidOperation Exception: No NERD tree window exists"
|
|
endif
|
|
|
|
exec s:GetTreeWinNum() . "wincmd w"
|
|
endfunction
|
|
|
|
"FUNCTION: s:RenderBookmarks {{{2
|
|
function! s:RenderBookmarks()
|
|
|
|
call setline(line(".")+1, ">----------Bookmarks----------")
|
|
call cursor(line(".")+1, col("."))
|
|
|
|
for i in s:oBookmark.Bookmarks()
|
|
call setline(line(".")+1, i.Str())
|
|
call cursor(line(".")+1, col("."))
|
|
endfor
|
|
|
|
call setline(line(".")+1, '')
|
|
call cursor(line(".")+1, col("."))
|
|
endfunction
|
|
"FUNCTION: s:RenderView {{{2
|
|
"The entry function for rendering the tree. Renders the root then calls
|
|
"s:DrawTree to draw the children of the root
|
|
"
|
|
"Args:
|
|
function! s:RenderView()
|
|
execute s:GetTreeWinNum() . "wincmd w"
|
|
|
|
setlocal modifiable
|
|
|
|
"remember the top line of the buffer and the current line so we can
|
|
"restore the view exactly how it was
|
|
let curLine = line(".")
|
|
let curCol = col(".")
|
|
let topLine = line("w0")
|
|
|
|
"delete all lines in the buffer (being careful not to clobber a register)
|
|
silent 1,$delete _
|
|
|
|
call s:DumpHelp()
|
|
|
|
"delete the blank line before the help and add one after it
|
|
call setline(line(".")+1, "")
|
|
call cursor(line(".")+1, col("."))
|
|
|
|
if g:NERDTreeShowBookmarks
|
|
call s:RenderBookmarks()
|
|
endif
|
|
|
|
"add the 'up a dir' line
|
|
call setline(line(".")+1, s:tree_up_dir_line)
|
|
call cursor(line(".")+1, col("."))
|
|
|
|
"draw the header line
|
|
call setline(line(".")+1, t:NERDTreeRoot.path.Str(0))
|
|
call cursor(line(".")+1, col("."))
|
|
|
|
"draw the tree
|
|
call s:DrawTree(t:NERDTreeRoot, 0, 0, [], t:NERDTreeRoot.GetChildCount() == 1)
|
|
|
|
"delete the blank line at the top of the buffer
|
|
silent 1,1delete _
|
|
|
|
"restore the view
|
|
let old_scrolloff=&scrolloff
|
|
let &scrolloff=0
|
|
call cursor(topLine, 1)
|
|
normal! zt
|
|
call cursor(curLine, curCol)
|
|
let &scrolloff = old_scrolloff
|
|
|
|
setlocal nomodifiable
|
|
endfunction
|
|
|
|
"FUNCTION: s:RenderViewSavingPosition {{{2
|
|
"Renders the tree and ensures the cursor stays on the current node or the
|
|
"current nodes parent if it is no longer available upon re-rendering
|
|
function! s:RenderViewSavingPosition()
|
|
let currentNode = s:GetSelectedNode()
|
|
|
|
"go up the tree till we find a node that will be visible or till we run
|
|
"out of nodes
|
|
while currentNode != {} && !currentNode.IsVisible() && !currentNode.IsRoot()
|
|
let currentNode = currentNode.parent
|
|
endwhile
|
|
|
|
call s:RenderView()
|
|
|
|
if currentNode != {}
|
|
call s:PutCursorOnNode(currentNode, 0, 0)
|
|
endif
|
|
endfunction
|
|
"FUNCTION: s:RestoreScreenState() {{{2
|
|
"
|
|
"Sets the screen state back to what it was when s:SaveScreenState was last
|
|
"called.
|
|
"
|
|
"Assumes the cursor is in the NERDTree window
|
|
function! s:RestoreScreenState()
|
|
if !exists("t:NERDTreeOldTopLine") || !exists("t:NERDTreeOldPos") || !exists("t:NERDTreeOldWindowSize")
|
|
return
|
|
endif
|
|
exec("silent ". (g:NERDTreeSplitVertical ? "vertical" : "") ." resize ".t:NERDTreeOldWindowSize)
|
|
|
|
let old_scrolloff=&scrolloff
|
|
let &scrolloff=0
|
|
call cursor(t:NERDTreeOldTopLine, 0)
|
|
normal! zt
|
|
call setpos(".", t:NERDTreeOldPos)
|
|
let &scrolloff=old_scrolloff
|
|
endfunction
|
|
|
|
"FUNCTION: s:SaveScreenState() {{{2
|
|
"Saves the current cursor position in the current buffer and the window
|
|
"scroll position
|
|
"
|
|
"Assumes the cursor is in the NERDTree window
|
|
function! s:SaveScreenState()
|
|
let t:NERDTreeOldPos = getpos(".")
|
|
let t:NERDTreeOldTopLine = line("w0")
|
|
let t:NERDTreeOldWindowSize = g:NERDTreeSplitVertical ? winwidth("") : winheight("")
|
|
endfunction
|
|
|
|
"FUNCTION: s:SetupSyntaxHighlighting() {{{2
|
|
function! s:SetupSyntaxHighlighting()
|
|
"treeFlags are syntax items that should be invisible, but give clues as to
|
|
"how things should be highlighted
|
|
syn match treeFlag #\~#
|
|
syn match treeFlag #\[RO\]#
|
|
|
|
"highlighting for the .. (up dir) line at the top of the tree
|
|
execute "syn match treeUp #". s:tree_up_dir_line ."#"
|
|
|
|
"highlighting for the ~/+ symbols for the directory nodes
|
|
syn match treeClosable #\~\<#
|
|
syn match treeClosable #\~\.#
|
|
syn match treeOpenable #+\<#
|
|
syn match treeOpenable #+\.#he=e-1
|
|
|
|
"highlighting for the tree structural parts
|
|
syn match treePart #|#
|
|
syn match treePart #`#
|
|
syn match treePartFile #[|`]-#hs=s+1 contains=treePart
|
|
|
|
"quickhelp syntax elements
|
|
syn match treeHelpKey #" \{1,2\}[^ ]*:#hs=s+2,he=e-1
|
|
syn match treeHelpKey #" \{1,2\}[^ ]*,#hs=s+2,he=e-1
|
|
syn match treeHelpTitle #" .*\~#hs=s+2,he=e-1 contains=treeFlag
|
|
syn match treeToggleOn #".*(on)#hs=e-2,he=e-1 contains=treeHelpKey
|
|
syn match treeToggleOff #".*(off)#hs=e-3,he=e-1 contains=treeHelpKey
|
|
syn match treeHelpCommand #" :.\{-}\>#hs=s+3
|
|
syn match treeHelp #^".*# contains=treeHelpKey,treeHelpTitle,treeFlag,treeToggleOff,treeToggleOn,treeHelpCommand
|
|
|
|
"highlighting for readonly files
|
|
syn match treeRO #[\/0-9a-zA-Z]\+.*\[RO\]# contains=treeFlag,treeBookmark
|
|
|
|
"highlighting for sym links
|
|
syn match treeLink #[^-| `].* -> # contains=treeBookmark,treeOpenable,treeClosable,treeDirSlash
|
|
|
|
"highlighing for directory nodes and file nodes
|
|
syn match treeDirSlash #/#
|
|
syn match treeDir #[^-| `].*/# contains=treeLink,treeDirSlash,treeOpenable,treeClosable
|
|
syn match treeExecFile #[|`]-.*\*\($\| \)# contains=treeLink,treePart,treeRO,treePartFile,treeBookmark
|
|
syn match treeFile #|-.*# contains=treeLink,treePart,treeRO,treePartFile,treeBookmark,treeExecFile
|
|
syn match treeFile #`-.*# contains=treeLink,treePart,treeRO,treePartFile,treeBookmark,treeExecFile
|
|
syn match treeCWD #^/.*$#
|
|
|
|
"highlighting for bookmarks
|
|
syn match treeBookmark # {.*}#hs=s+1
|
|
|
|
"highlighting for the bookmarks display
|
|
syn match treeBookmarksLeader #^>#
|
|
syn match treeBookmarksHeader #^>-\+Bookmarks-\+# contains=treeBookmarksLeader
|
|
syn match treeBookmarkName #^>[a-zA-Z_]\{-} #he=e-1 contains=treeBookmarksLeader
|
|
syn match treeBookmark #^>.*$# contains=treeBookmarksLeader,treeBookmarkName
|
|
|
|
if g:NERDChristmasTree
|
|
hi def link treePart Special
|
|
hi def link treePartFile Type
|
|
hi def link treeFile Normal
|
|
hi def link treeExecFile Title
|
|
hi def link treeDirSlash Identifier
|
|
hi def link treeClosable Type
|
|
else
|
|
hi def link treePart Normal
|
|
hi def link treePartFile Normal
|
|
hi def link treeFile Normal
|
|
hi def link treeClosable Title
|
|
endif
|
|
|
|
hi def link treeBookmarksHeader macro
|
|
hi def link treeBookmarksLeader ignore
|
|
hi def link treeBookmarkName Identifier
|
|
hi def link treeBookmark Statement
|
|
|
|
hi def link treeHelp String
|
|
hi def link treeHelpKey Identifier
|
|
hi def link treeHelpCommand Identifier
|
|
hi def link treeHelpTitle Macro
|
|
hi def link treeToggleOn Question
|
|
hi def link treeToggleOff WarningMsg
|
|
|
|
hi def link treeDir Directory
|
|
hi def link treeUp Directory
|
|
hi def link treeCWD Statement
|
|
hi def link treeLink Macro
|
|
hi def link treeOpenable Title
|
|
hi def link treeFlag ignore
|
|
hi def link treeRO WarningMsg
|
|
hi def link treeBookmark Statement
|
|
|
|
hi def link NERDTreeCurrentNode Search
|
|
endfunction
|
|
|
|
"FUNCTION: s:ShouldSplitToOpen() {{{2
|
|
"Returns 1 if opening a file from the tree in the given window requires it to
|
|
"be split
|
|
"
|
|
"Args:
|
|
"winnumber: the number of the window in question
|
|
function! s:ShouldSplitToOpen(winnumber)
|
|
"gotta split if theres only one window (i.e. the NERD tree)
|
|
if winnr("$") == 1
|
|
return 1
|
|
endif
|
|
|
|
let oldwinnr = winnr()
|
|
exec a:winnumber . "wincmd p"
|
|
let specialWindow = getbufvar("%", '&buftype') != '' || getwinvar('%', '&previewwindow')
|
|
let modified = &modified
|
|
exec oldwinnr . "wincmd p"
|
|
|
|
"if its a special window e.g. quickfix or another explorer plugin then we
|
|
"have to split
|
|
if specialWindow
|
|
return 1
|
|
endif
|
|
|
|
if &hidden
|
|
return 0
|
|
endif
|
|
|
|
return modified && s:BufInWindows(winbufnr(a:winnumber)) < 2
|
|
endfunction
|
|
|
|
"FUNCTION: s:StripMarkupFromLine(line, removeLeadingSpaces){{{2
|
|
"returns the given line with all the tree parts stripped off
|
|
"
|
|
"Args:
|
|
"line: the subject line
|
|
"removeLeadingSpaces: 1 if leading spaces are to be removed (leading spaces =
|
|
"any spaces before the actual text of the node)
|
|
function! s:StripMarkupFromLine(line, removeLeadingSpaces)
|
|
let line = a:line
|
|
"remove the tree parts and the leading space
|
|
let line = substitute (line,"^" . s:tree_markup_reg . "*","","")
|
|
|
|
"strip off any read only flag
|
|
let line = substitute (line, ' \[RO\]', "","")
|
|
|
|
"strip off any bookmark flags
|
|
let line = substitute (line, ' {[^}]*}', "","")
|
|
|
|
"strip off any executable flags
|
|
let line = substitute (line, '*\ze\($\| \)', "","")
|
|
|
|
let wasdir = 0
|
|
if line =~ '/$'
|
|
let wasdir = 1
|
|
endif
|
|
let line = substitute (line,' -> .*',"","") " remove link to
|
|
if wasdir == 1
|
|
let line = substitute (line, '/\?$', '/', "")
|
|
endif
|
|
|
|
if a:removeLeadingSpaces
|
|
let line = substitute (line, '^ *', '', '')
|
|
endif
|
|
|
|
return line
|
|
endfunction
|
|
|
|
"FUNCTION: s:Toggle(dir) {{{2
|
|
"Toggles the NERD tree. I.e the NERD tree is open, it is closed, if it is
|
|
"closed it is restored or initialized (if it doesnt exist)
|
|
"
|
|
"Args:
|
|
"dir: the full path for the root node (is only used if the NERD tree is being
|
|
"initialized.
|
|
function! s:Toggle(dir)
|
|
if s:TreeExistsForTab()
|
|
if !s:IsTreeOpen()
|
|
call s:CreateTreeWin()
|
|
call s:RenderView()
|
|
|
|
call s:RestoreScreenState()
|
|
else
|
|
call s:CloseTree()
|
|
endif
|
|
else
|
|
call s:InitNerdTree(a:dir)
|
|
endif
|
|
endfunction
|
|
"SECTION: Interface bindings {{{1
|
|
"============================================================
|
|
"FUNCTION: s:ActivateNode() {{{2
|
|
"If the current node is a file, open it in the previous window (or a new one
|
|
"if the previous is modified). If it is a directory then it is opened.
|
|
function! s:ActivateNode()
|
|
if getline(".") == s:tree_up_dir_line
|
|
return s:UpDir(0)
|
|
endif
|
|
|
|
let treenode = s:GetSelectedNode()
|
|
if treenode != {}
|
|
if treenode.path.isDirectory
|
|
call treenode.ToggleOpen()
|
|
call s:RenderView()
|
|
call s:PutCursorOnNode(treenode, 0, 0)
|
|
else
|
|
call s:OpenFileNode(treenode)
|
|
if g:NERDTreeQuitOnOpen
|
|
call s:CloseTree()
|
|
endif
|
|
endif
|
|
else
|
|
let bookmark = s:GetSelectedBookmark()
|
|
if !empty(bookmark)
|
|
if bookmark.path.isDirectory
|
|
call s:BookmarkToRoot(bookmark.name)
|
|
else
|
|
call s:OpenFileNode(s:oTreeFileNode.New(bookmark.path))
|
|
endif
|
|
endif
|
|
endif
|
|
endfunction
|
|
|
|
"FUNCTION: s:BindMappings() {{{2
|
|
function! s:BindMappings()
|
|
" set up mappings and commands for this buffer
|
|
nnoremap <silent> <buffer> <middlerelease> :call <SID>HandleMiddleMouse()<cr>
|
|
nnoremap <silent> <buffer> <leftrelease> <leftrelease>:call <SID>CheckForActivate()<cr>
|
|
nnoremap <silent> <buffer> <2-leftmouse> :call <SID>ActivateNode()<cr>
|
|
|
|
exec "nnoremap <silent> <buffer> ". g:NERDTreeMapActivateNode . " :call <SID>ActivateNode()<cr>"
|
|
exec "nnoremap <silent> <buffer> ". g:NERDTreeMapOpenSplit ." :call <SID>OpenEntrySplit()<cr>"
|
|
|
|
exec "nnoremap <silent> <buffer> ". g:NERDTreeMapPreview ." :call <SID>PreviewNode(0)<cr>"
|
|
exec "nnoremap <silent> <buffer> ". g:NERDTreeMapPreviewSplit ." :call <SID>PreviewNode(1)<cr>"
|
|
|
|
|
|
exec "nnoremap <silent> <buffer> ". g:NERDTreeMapExecute ." :call <SID>ExecuteNode()<cr>"
|
|
|
|
exec "nnoremap <silent> <buffer> ". g:NERDTreeMapOpenRecursively ." :call <SID>OpenNodeRecursively()<cr>"
|
|
|
|
exec "nnoremap <silent> <buffer> ". g:NERDTreeMapUpdirKeepOpen ." :call <SID>UpDir(1)<cr>"
|
|
exec "nnoremap <silent> <buffer> ". g:NERDTreeMapUpdir ." :call <SID>UpDir(0)<cr>"
|
|
exec "nnoremap <silent> <buffer> ". g:NERDTreeMapChangeRoot ." :call <SID>ChRoot()<cr>"
|
|
|
|
exec "nnoremap <silent> <buffer> ". g:NERDTreeMapChdir ." :call <SID>ChCwd()<cr>"
|
|
|
|
exec "nnoremap <silent> <buffer> ". g:NERDTreeMapQuit ." :NERDTreeToggle<cr>"
|
|
|
|
exec "nnoremap <silent> <buffer> ". g:NERDTreeMapRefreshRoot ." :call <SID>RefreshRoot()<cr>"
|
|
exec "nnoremap <silent> <buffer> ". g:NERDTreeMapRefresh ." :call <SID>RefreshCurrent()<cr>"
|
|
|
|
exec "nnoremap <silent> <buffer> ". g:NERDTreeMapHelp ." :call <SID>DisplayHelp()<cr>"
|
|
exec "nnoremap <silent> <buffer> ". g:NERDTreeMapToggleHidden ." :call <SID>ToggleShowHidden()<cr>"
|
|
exec "nnoremap <silent> <buffer> ". g:NERDTreeMapToggleFilters ." :call <SID>ToggleIgnoreFilter()<cr>"
|
|
exec "nnoremap <silent> <buffer> ". g:NERDTreeMapToggleFiles ." :call <SID>ToggleShowFiles()<cr>"
|
|
exec "nnoremap <silent> <buffer> ". g:NERDTreeMapToggleBookmarks ." :call <SID>ToggleShowBookmarks()<cr>"
|
|
|
|
exec "nnoremap <silent> <buffer> ". g:NERDTreeMapCloseDir ." :call <SID>CloseCurrentDir()<cr>"
|
|
exec "nnoremap <silent> <buffer> ". g:NERDTreeMapCloseChildren ." :call <SID>CloseChildren()<cr>"
|
|
|
|
exec "nnoremap <silent> <buffer> ". g:NERDTreeMapFilesystemMenu ." :call <SID>ShowFileSystemMenu()<cr>"
|
|
|
|
exec "nnoremap <silent> <buffer> ". g:NERDTreeMapJumpParent ." :call <SID>JumpToParent()<cr>"
|
|
exec "nnoremap <silent> <buffer> ". g:NERDTreeMapJumpNextSibling ." :call <SID>JumpToSibling(1)<cr>"
|
|
exec "nnoremap <silent> <buffer> ". g:NERDTreeMapJumpPrevSibling ." :call <SID>JumpToSibling(0)<cr>"
|
|
exec "nnoremap <silent> <buffer> ". g:NERDTreeMapJumpFirstChild ." :call <SID>JumpToFirstChild()<cr>"
|
|
exec "nnoremap <silent> <buffer> ". g:NERDTreeMapJumpLastChild ." :call <SID>JumpToLastChild()<cr>"
|
|
exec "nnoremap <silent> <buffer> ". g:NERDTreeMapJumpRoot ." :call <SID>JumpToRoot()<cr>"
|
|
|
|
exec "nnoremap <silent> <buffer> ". g:NERDTreeMapOpenInTab ." :call <SID>OpenInNewTab(0)<cr>"
|
|
exec "nnoremap <silent> <buffer> ". g:NERDTreeMapOpenInTabSilent ." :call <SID>OpenInNewTab(1)<cr>"
|
|
|
|
exec "nnoremap <silent> <buffer> ". g:NERDTreeMapOpenExpl ." :call <SID>OpenExplorer()<cr>"
|
|
|
|
command! -buffer -nargs=1 Bookmark :call <SID>BookmarkNode('<args>')
|
|
command! -buffer -complete=customlist,s:CompleteBookmarks -nargs=1 RevealBookmark :call <SID>RevealBookmark('<args>')
|
|
command! -buffer -complete=customlist,s:CompleteBookmarks -nargs=1 OpenBookmark :call <SID>OpenBookmark('<args>')
|
|
command! -buffer -complete=customlist,s:CompleteBookmarks -nargs=* ClearBookmarks call <SID>ClearBookmarks('<args>')
|
|
command! -buffer -complete=customlist,s:CompleteBookmarks -nargs=+ BookmarkToRoot call <SID>BookmarkToRoot('<args>')
|
|
command! -buffer -nargs=0 ClearAllBookmarks call s:oBookmark.ClearAll() <bar> call <SID>RenderView()
|
|
command! -buffer -nargs=0 ReadBookmarks call s:oBookmark.CacheBookmarks() <bar> call <SID>RenderView()
|
|
command! -buffer -nargs=0 WriteBookmarks call s:oBookmark.Write()
|
|
endfunction
|
|
|
|
" FUNCTION: s:BookmarkNode(name) {{{2
|
|
" Associate the current node with the given name
|
|
function! s:BookmarkNode(name)
|
|
let currentNode = s:GetSelectedNode()
|
|
if currentNode != {}
|
|
call currentNode.Bookmark(a:name)
|
|
call s:RenderView()
|
|
else
|
|
call s:Echo("select a node first")
|
|
endif
|
|
endfunction
|
|
" FUNCTION: s:BookmarkToRoot(name) {{{2
|
|
" Make the node for the given bookmark the new tree root
|
|
function! s:BookmarkToRoot(name)
|
|
try
|
|
let targetNode = s:oBookmark.GetNodeForName(a:name, 1)
|
|
catch /NERDTree.BookmarkNodeNotFound/
|
|
let targetNode = s:oTreeFileNode.New(s:oBookmark.BookmarkFor(a:name).path)
|
|
endtry
|
|
call targetNode.MakeRoot()
|
|
call s:RenderView()
|
|
call s:PutCursorOnNode(targetNode, 0, 0)
|
|
endfunction
|
|
"FUNCTION: s:CheckForActivate() {{{2
|
|
"Checks if the click should open the current node, if so then activate() is
|
|
"called (directories are automatically opened if the symbol beside them is
|
|
"clicked)
|
|
function! s:CheckForActivate()
|
|
let currentNode = s:GetSelectedNode()
|
|
if currentNode != {}
|
|
let startToCur = strpart(getline(line(".")), 0, col("."))
|
|
let char = strpart(startToCur, strlen(startToCur)-1, 1)
|
|
|
|
"if they clicked a dir, check if they clicked on the + or ~ sign
|
|
"beside it
|
|
if currentNode.path.isDirectory
|
|
let reg = '^' . s:tree_markup_reg .'*[~+]$'
|
|
if startToCur =~ reg
|
|
call s:ActivateNode()
|
|
return
|
|
endif
|
|
endif
|
|
|
|
if (g:NERDTreeMouseMode == 2 && currentNode.path.isDirectory) || g:NERDTreeMouseMode == 3
|
|
if char !~ s:tree_markup_reg && startToCur !~ '\/$'
|
|
call s:ActivateNode()
|
|
return
|
|
endif
|
|
endif
|
|
endif
|
|
endfunction
|
|
|
|
" FUNCTION: s:ChCwd() {{{2
|
|
function! s:ChCwd()
|
|
let treenode = s:GetSelectedNode()
|
|
if treenode == {}
|
|
call s:Echo("Select a node first")
|
|
return
|
|
endif
|
|
|
|
try
|
|
call treenode.path.ChangeToDir()
|
|
catch /^NERDTree.Path.Change/
|
|
call s:EchoWarning("could not change cwd")
|
|
endtry
|
|
endfunction
|
|
|
|
" FUNCTION: s:ChRoot() {{{2
|
|
" changes the current root to the selected one
|
|
function! s:ChRoot()
|
|
let treenode = s:GetSelectedNode()
|
|
if treenode == {}
|
|
call s:Echo("Select a node first")
|
|
return
|
|
endif
|
|
|
|
call treenode.MakeRoot()
|
|
call s:RenderView()
|
|
call s:PutCursorOnNode(t:NERDTreeRoot, 0, 0)
|
|
endfunction
|
|
|
|
" FUNCTION: s:ClearBookmarks(bookmarks) {{{2
|
|
function! s:ClearBookmarks(bookmarks)
|
|
if a:bookmarks == ''
|
|
let currentNode = s:GetSelectedNode()
|
|
if currentNode != {}
|
|
call currentNode.ClearBookmarks()
|
|
endif
|
|
else
|
|
for name in split(a:bookmarks, ' ')
|
|
let bookmark = s:oBookmark.BookmarkFor(name)
|
|
call bookmark.Delete()
|
|
endfor
|
|
endif
|
|
call s:oBookmark.Write()
|
|
call s:RenderView()
|
|
endfunction
|
|
" FUNCTION: s:CloseChildren() {{{2
|
|
" closes all childnodes of the current node
|
|
function! s:CloseChildren()
|
|
let currentNode = s:GetSelectedDir()
|
|
if currentNode == {}
|
|
call s:Echo("Select a node first")
|
|
return
|
|
endif
|
|
|
|
call currentNode.CloseChildren()
|
|
call s:RenderView()
|
|
call s:PutCursorOnNode(currentNode, 0, 0)
|
|
endfunction
|
|
" FUNCTION: s:CloseCurrentDir() {{{2
|
|
" closes the parent dir of the current node
|
|
function! s:CloseCurrentDir()
|
|
let treenode = s:GetSelectedNode()
|
|
if treenode == {}
|
|
call s:Echo("Select a node first")
|
|
return
|
|
endif
|
|
|
|
let parent = treenode.parent
|
|
if parent.IsRoot()
|
|
call s:Echo("cannot close tree root")
|
|
else
|
|
call treenode.parent.Close()
|
|
call s:RenderView()
|
|
call s:PutCursorOnNode(treenode.parent, 0, 0)
|
|
endif
|
|
endfunction
|
|
|
|
" FUNCTION: s:CopyNode() {{{2
|
|
function! s:CopyNode()
|
|
let currentNode = s:GetSelectedNode()
|
|
if currentNode == {}
|
|
call s:Echo("Put the cursor on a file node first")
|
|
return
|
|
endif
|
|
|
|
let newNodePath = input("Copy the current node\n" .
|
|
\ "==========================================================\n" .
|
|
\ "Enter the new path to copy the node to: \n" .
|
|
\ "", currentNode.path.Str(0))
|
|
|
|
if newNodePath != ""
|
|
"strip trailing slash
|
|
let newNodePath = substitute(newNodePath, '\/$', '', '')
|
|
|
|
let confirmed = 1
|
|
if currentNode.path.CopyingWillOverwrite(newNodePath)
|
|
echo "\nWarning: copying may overwrite files! Continue? (yN)"
|
|
let choice = nr2char(getchar())
|
|
let confirmed = choice == 'y'
|
|
endif
|
|
|
|
if confirmed
|
|
try
|
|
let newNode = currentNode.Copy(newNodePath)
|
|
call s:RenderView()
|
|
call s:PutCursorOnNode(newNode, 0, 0)
|
|
catch /^NERDTree/
|
|
call s:EchoWarning("Could not copy node")
|
|
endtry
|
|
endif
|
|
else
|
|
call s:Echo("Copy aborted.")
|
|
endif
|
|
redraw
|
|
endfunction
|
|
|
|
" FUNCTION: s:DeleteNode() {{{2
|
|
" if the current node is a file, pops up a dialog giving the user the option
|
|
" to delete it
|
|
function! s:DeleteNode()
|
|
let currentNode = s:GetSelectedNode()
|
|
if currentNode == {}
|
|
call s:Echo("Put the cursor on a file node first")
|
|
return
|
|
endif
|
|
|
|
let confirmed = 0
|
|
|
|
if currentNode.path.isDirectory
|
|
let choice =input("Delete the current node\n" .
|
|
\ "==========================================================\n" .
|
|
\ "STOP! To delete this entire directory, type 'yes'\n" .
|
|
\ "" . currentNode.path.StrForOS(0) . ": ")
|
|
let confirmed = choice == 'yes'
|
|
else
|
|
echo "Delete the current node\n" .
|
|
\ "==========================================================\n".
|
|
\ "Are you sure you wish to delete the node:\n" .
|
|
\ "" . currentNode.path.StrForOS(0) . " (yN):"
|
|
let choice = nr2char(getchar())
|
|
let confirmed = choice == 'y'
|
|
endif
|
|
|
|
|
|
if confirmed
|
|
try
|
|
call currentNode.Delete()
|
|
call s:RenderView()
|
|
|
|
"if the node is open in a buffer, ask the user if they want to
|
|
"close that buffer
|
|
let bufnum = bufnr(currentNode.path.Str(0))
|
|
if buflisted(bufnum)
|
|
let prompt = "\nNode deleted.\n\nThe file is open in buffer ". bufnum . (bufwinnr(bufnum) == -1 ? " (hidden)" : "") .". Delete this buffer? (yN)"
|
|
call s:PromptToDelBuffer(bufnum, prompt)
|
|
endif
|
|
|
|
redraw
|
|
catch /^NERDTree/
|
|
call s:EchoWarning("Could not remove node")
|
|
endtry
|
|
else
|
|
call s:Echo("delete aborted" )
|
|
endif
|
|
|
|
endfunction
|
|
|
|
" FUNCTION: s:DisplayHelp() {{{2
|
|
" toggles the help display
|
|
function! s:DisplayHelp()
|
|
let t:treeShowHelp = t:treeShowHelp ? 0 : 1
|
|
call s:RenderView()
|
|
call s:CenterView()
|
|
endfunction
|
|
|
|
" FUNCTION: s:ExecuteNode() {{{2
|
|
function! s:ExecuteNode()
|
|
let treenode = s:GetSelectedNode()
|
|
if treenode == {} || treenode.path.isDirectory
|
|
call s:Echo("Select an executable file node first" )
|
|
else
|
|
echo "NERDTree executor\n" .
|
|
\ "==========================================================\n".
|
|
\ "Complete the command to execute (add arguments etc): \n\n"
|
|
let cmd = treenode.path.StrForOS(1)
|
|
let cmd = input(':!', cmd . ' ')
|
|
|
|
if cmd != ''
|
|
exec ':!' . cmd
|
|
else
|
|
call s:Echo("command aborted")
|
|
endif
|
|
endif
|
|
endfunction
|
|
|
|
" FUNCTION: s:HandleMiddleMouse() {{{2
|
|
function! s:HandleMiddleMouse()
|
|
let curNode = s:GetSelectedNode()
|
|
if curNode == {}
|
|
call s:Echo("Put the cursor on a node first" )
|
|
return
|
|
endif
|
|
|
|
if curNode.path.isDirectory
|
|
call s:OpenExplorer()
|
|
else
|
|
call s:OpenEntrySplit()
|
|
endif
|
|
endfunction
|
|
|
|
|
|
" FUNCTION: s:InsertNewNode() {{{2
|
|
" Adds a new node to the filesystem and then into the tree
|
|
function! s:InsertNewNode()
|
|
let curDirNode = s:GetSelectedDir()
|
|
if curDirNode == {}
|
|
call s:Echo("Put the cursor on a node first" )
|
|
return
|
|
endif
|
|
|
|
let newNodeName = input("Add a childnode\n".
|
|
\ "==========================================================\n".
|
|
\ "Enter the dir/file name to be created. Dirs end with a '/'\n" .
|
|
\ "", curDirNode.path.StrForGlob() . s:os_slash)
|
|
|
|
if newNodeName == ''
|
|
call s:Echo("Node Creation Aborted.")
|
|
return
|
|
endif
|
|
|
|
try
|
|
let newPath = s:oPath.Create(newNodeName)
|
|
let parentNode = t:NERDTreeRoot.FindNode(newPath.GetPathTrunk())
|
|
|
|
let newTreeNode = s:oTreeFileNode.New(newPath)
|
|
if parentNode.isOpen || !empty(parentNode.children)
|
|
call parentNode.AddChild(newTreeNode, 1)
|
|
call s:RenderView()
|
|
call s:PutCursorOnNode(newTreeNode, 1, 0)
|
|
endif
|
|
catch /^NERDTree/
|
|
call s:EchoWarning("Node Not Created.")
|
|
endtry
|
|
endfunction
|
|
|
|
" FUNCTION: s:JumpToFirstChild() {{{2
|
|
" wrapper for the jump to child method
|
|
function! s:JumpToFirstChild()
|
|
call s:JumpToChild(0)
|
|
endfunction
|
|
|
|
" FUNCTION: s:JumpToLastChild() {{{2
|
|
" wrapper for the jump to child method
|
|
function! s:JumpToLastChild()
|
|
call s:JumpToChild(1)
|
|
endfunction
|
|
|
|
" FUNCTION: s:JumpToParent() {{{2
|
|
" moves the cursor to the parent of the current node
|
|
function! s:JumpToParent()
|
|
let currentNode = s:GetSelectedNode()
|
|
if !empty(currentNode)
|
|
if !empty(currentNode.parent)
|
|
call s:PutCursorOnNode(currentNode.parent, 1, 0)
|
|
call s:CenterView()
|
|
else
|
|
call s:Echo("cannot jump to parent")
|
|
endif
|
|
else
|
|
call s:Echo("put the cursor on a node first")
|
|
endif
|
|
endfunction
|
|
|
|
" FUNCTION: s:JumpToRoot() {{{2
|
|
" moves the cursor to the root node
|
|
function! s:JumpToRoot()
|
|
call s:PutCursorOnNode(t:NERDTreeRoot, 1, 0)
|
|
call s:CenterView()
|
|
endfunction
|
|
|
|
" FUNCTION: s:JumpToSibling() {{{2
|
|
" moves the cursor to the sibling of the current node in the given direction
|
|
"
|
|
" Args:
|
|
" forward: 1 if the cursor should move to the next sibling, 0 if it should
|
|
" move back to the previous sibling
|
|
function! s:JumpToSibling(forward)
|
|
let currentNode = s:GetSelectedNode()
|
|
if !empty(currentNode)
|
|
let sibling = currentNode.FindSibling(a:forward)
|
|
|
|
if !empty(sibling)
|
|
call s:PutCursorOnNode(sibling, 1, 0)
|
|
call s:CenterView()
|
|
endif
|
|
else
|
|
call s:Echo("put the cursor on a node first")
|
|
endif
|
|
endfunction
|
|
|
|
" FUNCTION: s:OpenBookmark(name) {{{2
|
|
" put the cursor on the given bookmark and, if its a file, open it
|
|
function! s:OpenBookmark(name)
|
|
try
|
|
let targetNode = s:oBookmark.GetNodeForName(a:name, 0)
|
|
call s:PutCursorOnNode(targetNode, 0, 1)
|
|
redraw!
|
|
catch /NERDTree.BookmarkNotFound/
|
|
call s:Echo("note - target node is not cached")
|
|
let bookmark = s:oBookmark.BookmarkFor(a:name)
|
|
let targetNode = s:oTreeFileNode.New(bookmark.path)
|
|
endtry
|
|
if targetNode.path.isDirectory
|
|
call s:OpenExplorerFor(targetNode)
|
|
else
|
|
call s:OpenFileNode(targetNode)
|
|
endif
|
|
endfunction
|
|
" FUNCTION: s:OpenEntrySplit() {{{2
|
|
" Opens the currently selected file from the explorer in a
|
|
" new window
|
|
function! s:OpenEntrySplit()
|
|
let treenode = s:GetSelectedNode()
|
|
if treenode != {}
|
|
call s:OpenFileNodeSplit(treenode)
|
|
if g:NERDTreeQuitOnOpen
|
|
call s:CloseTree()
|
|
endif
|
|
else
|
|
call s:Echo("select a node first")
|
|
endif
|
|
endfunction
|
|
|
|
" FUNCTION: s:OpenExplorer() {{{2
|
|
function! s:OpenExplorer()
|
|
let treenode = s:GetSelectedDir()
|
|
if treenode != {}
|
|
call s:OpenExplorerFor(treenode)
|
|
else
|
|
call s:Echo("select a node first")
|
|
endif
|
|
endfunction
|
|
|
|
" FUNCTION: s:OpenInNewTab(stayCurrentTab) {{{2
|
|
" Opens the selected node or bookmark in a new tab
|
|
" Args:
|
|
" stayCurrentTab: if 1 then vim will stay in the current tab, if 0 then vim
|
|
" will go to the tab where the new file is opened
|
|
function! s:OpenInNewTab(stayCurrentTab)
|
|
let currentTab = tabpagenr()
|
|
|
|
let treenode = s:GetSelectedNode()
|
|
if treenode != {}
|
|
exec "tabedit " . treenode.path.StrForEditCmd()
|
|
if a:stayCurrentTab
|
|
exec "tabnext " . currentTab
|
|
endif
|
|
else
|
|
let bookmark = s:GetSelectedBookmark()
|
|
if bookmark != {}
|
|
if bookmark.path.isDirectory
|
|
exec "tabnew +NERDTreeFromBookmark\\ " . bookmark.name
|
|
else
|
|
exec "tabedit " . bookmark.path.StrForEditCmd()
|
|
endif
|
|
if a:stayCurrentTab
|
|
exec "tabnext " . currentTab
|
|
endif
|
|
endif
|
|
endif
|
|
endfunction
|
|
|
|
" FUNCTION: s:OpenNodeRecursively() {{{2
|
|
function! s:OpenNodeRecursively()
|
|
let treenode = s:GetSelectedNode()
|
|
if treenode == {} || treenode.path.isDirectory == 0
|
|
call s:Echo("Select a directory node first" )
|
|
else
|
|
call s:Echo("Recursively opening node. Please wait...")
|
|
call treenode.OpenRecursively()
|
|
call s:RenderView()
|
|
redraw
|
|
call s:Echo("Recursively opening node. Please wait... DONE")
|
|
endif
|
|
|
|
endfunction
|
|
|
|
"FUNCTION: s:PreviewNode() {{{2
|
|
function! s:PreviewNode(openNewWin)
|
|
let treenode = s:GetSelectedNode()
|
|
if treenode == {} || treenode.path.isDirectory
|
|
call s:Echo("Select a file node first" )
|
|
return
|
|
endif
|
|
|
|
if a:openNewWin
|
|
call s:OpenEntrySplit()
|
|
else
|
|
call s:ActivateNode()
|
|
end
|
|
call s:PutCursorInTreeWin()
|
|
endfunction
|
|
|
|
" FUNCTION: s:RevealBookmark(name) {{{2
|
|
" put the cursor on the node associate with the given name
|
|
function! s:RevealBookmark(name)
|
|
try
|
|
let targetNode = s:oBookmark.GetNodeForName(a:name, 0)
|
|
call s:PutCursorOnNode(targetNode, 0, 1)
|
|
catch /NERDTree.BookmarkDoesntExist/
|
|
call s:Echo("Bookmark isnt cached under the current root")
|
|
endtry
|
|
endfunction
|
|
" FUNCTION: s:RefreshRoot() {{{2
|
|
" Reloads the current root. All nodes below this will be lost and the root dir
|
|
" will be reloaded.
|
|
function! s:RefreshRoot()
|
|
call s:Echo("Refreshing the root node. This could take a while...")
|
|
call t:NERDTreeRoot.Refresh()
|
|
call s:RenderView()
|
|
redraw
|
|
call s:Echo("Refreshing the root node. This could take a while... DONE")
|
|
endfunction
|
|
|
|
" FUNCTION: s:RefreshCurrent() {{{2
|
|
" refreshes the root for the current node
|
|
function! s:RefreshCurrent()
|
|
let treenode = s:GetSelectedDir()
|
|
if treenode == {}
|
|
call s:Echo("Refresh failed. Select a node first")
|
|
return
|
|
endif
|
|
|
|
call s:Echo("Refreshing node. This could take a while...")
|
|
call treenode.Refresh()
|
|
call s:RenderView()
|
|
redraw
|
|
call s:Echo("Refreshing node. This could take a while... DONE")
|
|
endfunction
|
|
" FUNCTION: s:RenameCurrent() {{{2
|
|
" allows the user to rename the current node
|
|
function! s:RenameCurrent()
|
|
let curNode = s:GetSelectedNode()
|
|
if curNode == {}
|
|
call s:Echo("Put the cursor on a node first" )
|
|
return
|
|
endif
|
|
|
|
let newNodePath = input("Rename the current node\n" .
|
|
\ "==========================================================\n" .
|
|
\ "Enter the new path for the node: \n" .
|
|
\ "", curNode.path.StrForOS(0))
|
|
|
|
if newNodePath == ''
|
|
call s:Echo("Node Renaming Aborted.")
|
|
return
|
|
endif
|
|
|
|
try
|
|
let bufnum = bufnr(curNode.path.Str(0))
|
|
|
|
call curNode.Rename(newNodePath)
|
|
call s:RenderView()
|
|
|
|
"if the node is open in a buffer, ask the user if they want to
|
|
"close that buffer
|
|
if bufnum != -1
|
|
let prompt = "\nNode renamed.\n\nThe old file is open in buffer ". bufnum . (bufwinnr(bufnum) == -1 ? " (hidden)" : "") .". Delete this buffer? (yN)"
|
|
call s:PromptToDelBuffer(bufnum, prompt)
|
|
endif
|
|
|
|
call s:PutCursorOnNode(curNode, 1, 0)
|
|
|
|
redraw
|
|
catch /^NERDTree/
|
|
call s:EchoWarning("Node Not Renamed.")
|
|
endtry
|
|
endfunction
|
|
|
|
" FUNCTION: s:ShowFileSystemMenu() {{{2
|
|
function! s:ShowFileSystemMenu()
|
|
let curNode = s:GetSelectedNode()
|
|
if curNode == {}
|
|
call s:Echo("Put the cursor on a node first" )
|
|
return
|
|
endif
|
|
|
|
|
|
let prompt = "NERDTree Filesystem Menu\n" .
|
|
\ "==========================================================\n".
|
|
\ "Select the desired operation: \n" .
|
|
\ " (a)dd a childnode\n".
|
|
\ " (m)ove the current node\n".
|
|
\ " (d)elete the current node\n"
|
|
if s:oPath.CopyingSupported()
|
|
let prompt = prompt . " (c)opy the current node\n\n"
|
|
else
|
|
let prompt = prompt . " \n"
|
|
endif
|
|
|
|
echo prompt
|
|
|
|
let choice = nr2char(getchar())
|
|
|
|
if choice ==? "a"
|
|
call s:InsertNewNode()
|
|
elseif choice ==? "m"
|
|
call s:RenameCurrent()
|
|
elseif choice ==? "d"
|
|
call s:DeleteNode()
|
|
elseif choice ==? "c" && s:oPath.CopyingSupported()
|
|
call s:CopyNode()
|
|
endif
|
|
endfunction
|
|
|
|
" FUNCTION: s:ToggleIgnoreFilter() {{{2
|
|
" toggles the use of the NERDTreeIgnore option
|
|
function! s:ToggleIgnoreFilter()
|
|
let t:NERDTreeIgnoreEnabled = !t:NERDTreeIgnoreEnabled
|
|
call s:RenderViewSavingPosition()
|
|
call s:CenterView()
|
|
endfunction
|
|
|
|
" FUNCTION: s:ToggleShowBookmarks() {{{2
|
|
" toggles the display of bookmarks
|
|
function! s:ToggleShowBookmarks()
|
|
let g:NERDTreeShowBookmarks = !g:NERDTreeShowBookmarks
|
|
call s:RenderViewSavingPosition()
|
|
call s:CenterView()
|
|
endfunction
|
|
" FUNCTION: s:ToggleShowFiles() {{{2
|
|
" toggles the display of hidden files
|
|
function! s:ToggleShowFiles()
|
|
let g:NERDTreeShowFiles = !g:NERDTreeShowFiles
|
|
call s:RenderViewSavingPosition()
|
|
call s:CenterView()
|
|
endfunction
|
|
|
|
" FUNCTION: s:ToggleShowHidden() {{{2
|
|
" toggles the display of hidden files
|
|
function! s:ToggleShowHidden()
|
|
let g:NERDTreeShowHidden = !g:NERDTreeShowHidden
|
|
call s:RenderViewSavingPosition()
|
|
call s:CenterView()
|
|
endfunction
|
|
|
|
"FUNCTION: s:UpDir(keepState) {{{2
|
|
"moves the tree up a level
|
|
"
|
|
"Args:
|
|
"keepState: 1 if the current root should be left open when the tree is
|
|
"re-rendered
|
|
function! s:UpDir(keepState)
|
|
let cwd = t:NERDTreeRoot.path.Str(0)
|
|
if cwd == "/" || cwd =~ '^[^/]..$'
|
|
call s:Echo("already at top dir")
|
|
else
|
|
if !a:keepState
|
|
call t:NERDTreeRoot.Close()
|
|
endif
|
|
|
|
let oldRoot = t:NERDTreeRoot
|
|
|
|
if empty(t:NERDTreeRoot.parent)
|
|
let path = t:NERDTreeRoot.path.GetPathTrunk()
|
|
let newRoot = s:oTreeDirNode.New(path)
|
|
call newRoot.Open()
|
|
call newRoot.TransplantChild(t:NERDTreeRoot)
|
|
let t:NERDTreeRoot = newRoot
|
|
else
|
|
let t:NERDTreeRoot = t:NERDTreeRoot.parent
|
|
|
|
endif
|
|
|
|
call s:RenderView()
|
|
call s:PutCursorOnNode(oldRoot, 0, 0)
|
|
endif
|
|
endfunction
|
|
|
|
" vim: set sw=4 sts=4 et fdm=marker:
|