mirror of
https://github.com/amix/vimrc
synced 2025-07-09 02:25:00 +08:00
Use sources_non_forked folder for pathogen path, with sources_non_forked_fallback folder as fallback.
This commit is contained in:
Wu Tingfeng
@ -1,12 +0,0 @@
|
||||
" para_move.vim
|
||||
" @Author: Tom Link (mailto:micathom AT gmail com?subject=[vim])
|
||||
" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
|
||||
" @Created: 2012-08-28.
|
||||
" @Last Change: 2012-08-29.
|
||||
" @Revision: 3
|
||||
|
||||
" Move paragraphs
|
||||
call tinykeymap#EnterMap("para_move", "gp", {'name': 'move paragraph'})
|
||||
call tinykeymap#Map("para_move", "j", "silent call tlib#paragraph#Move('Down', '<count>')")
|
||||
call tinykeymap#Map("para_move", "k", "silent call tlib#paragraph#Move('Up', '<count>')")
|
||||
|
||||
@ -1,8 +0,0 @@
|
||||
" @Author: Tom Link (micathom AT gmail com?subject=[vim])
|
||||
" @Website: http://www.vim.org/account/profile.php?user_id=4037
|
||||
" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
|
||||
" @Revision: 13
|
||||
|
||||
" :nodefault:
|
||||
TLet g:tlib#debug = 0
|
||||
|
||||
@ -1,152 +0,0 @@
|
||||
" Filter_cnf.vim
|
||||
" @Author: Tom Link (mailto:micathom AT gmail com?subject=[vim])
|
||||
" @Website: http://www.vim.org/account/profile.php?user_id=4037
|
||||
" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
|
||||
" @Created: 2008-11-25.
|
||||
" @Last Change: 2017-09-28.
|
||||
" @Revision: 11.0.114
|
||||
|
||||
let s:prototype = tlib#Object#New({'_class': ['Filter_cnf'], 'name': 'cnf'}) "{{{2
|
||||
let s:prototype.highlight = g:tlib#input#higroup
|
||||
|
||||
" The search pattern for |tlib#input#List()| is in conjunctive normal
|
||||
" form: (P1 OR P2 ...) AND (P3 OR P4 ...) ...
|
||||
" The pattern is a '/\V' very no-'/magic' regexp pattern.
|
||||
"
|
||||
" Pressing <space> joins two patterns with AND.
|
||||
" Pressing | joins two patterns with OR.
|
||||
" I.e. In order to get "lala AND (foo OR bar)", you type
|
||||
" "lala foo|bar".
|
||||
"
|
||||
" This is also the base class for other filters.
|
||||
function! tlib#Filter_cnf#New(...) "{{{3
|
||||
let object = s:prototype.New(a:0 >= 1 ? a:1 : {})
|
||||
return object
|
||||
endf
|
||||
|
||||
|
||||
" :nodoc:
|
||||
function! s:prototype.Init(world) dict "{{{3
|
||||
endf
|
||||
|
||||
|
||||
" :nodoc:
|
||||
function! s:prototype.Help(world) dict "{{{3
|
||||
call a:world.PushHelp(
|
||||
\ printf('"%s", "%s", "%sWORD"', g:tlib#input#and, g:tlib#input#or, g:tlib#input#not),
|
||||
\ 'AND, OR, NOT')
|
||||
endf
|
||||
|
||||
|
||||
" :nodoc:
|
||||
function! s:prototype.AssessName(world, name) dict "{{{3
|
||||
let xa = 0
|
||||
let prefix = self.FilterRxPrefix()
|
||||
for flt in a:world.filter_pos
|
||||
" let flt = prefix . a:world.GetRx(fltl)
|
||||
" if flt =~# '\u' && a:name =~# flt
|
||||
" let xa += 5
|
||||
" endif
|
||||
let rel = 1.0 + 5.0 * len(flt) / len(a:name)
|
||||
let xa += float2nr(rel)
|
||||
if a:name =~ '\^'. flt
|
||||
let xa += 4
|
||||
elseif a:name =~ '\<'. flt
|
||||
let xa += 3
|
||||
" elseif a:name =~ '[[:punct:][:space:][:digit:]]'. flt
|
||||
" let xa += 2
|
||||
elseif a:name =~ '\A'. flt .'\|'. flt .'\A'
|
||||
let xa += 1
|
||||
endif
|
||||
endfor
|
||||
" TLogVAR a:name, xa
|
||||
return xa
|
||||
endf
|
||||
|
||||
|
||||
" :nodoc:
|
||||
function! s:prototype.Match(world, text) dict "{{{3
|
||||
" TLogVAR a:text
|
||||
" let sc = &smartcase
|
||||
" let ic = &ignorecase
|
||||
" if &ignorecase
|
||||
" set smartcase
|
||||
" endif
|
||||
" try
|
||||
if !empty(a:world.filter_neg)
|
||||
for rx in a:world.filter_neg
|
||||
" TLogVAR rx
|
||||
if a:text =~ rx
|
||||
return 0
|
||||
endif
|
||||
endfor
|
||||
endif
|
||||
if !empty(a:world.filter_pos)
|
||||
for rx in a:world.filter_pos
|
||||
" TLogVAR rx
|
||||
if a:text !~ rx
|
||||
return 0
|
||||
endif
|
||||
endfor
|
||||
endif
|
||||
" finally
|
||||
" let &smartcase = sc
|
||||
" let &ignorecase = ic
|
||||
" endtry
|
||||
return 1
|
||||
endf
|
||||
|
||||
|
||||
" :nodoc:
|
||||
function! s:prototype.DisplayFilter(filter) dict "{{{3
|
||||
let filter1 = deepcopy(a:filter)
|
||||
call map(filter1, '"(". join(reverse(self.Pretty(v:val)), " OR ") .")"')
|
||||
return join(reverse(filter1), ' AND ')
|
||||
endf
|
||||
|
||||
|
||||
function! s:prototype.Pretty(filter) dict "{{{3
|
||||
" call map(a:filter, 'substitute(v:val, ''\\\.\\{-}'', ''=>'', ''g'')')
|
||||
call map(a:filter, 'self.CleanFilter(v:val)')
|
||||
return a:filter
|
||||
endf
|
||||
|
||||
|
||||
" :nodoc:
|
||||
function! s:prototype.SetFrontFilter(world, pattern) dict "{{{3
|
||||
let a:world.filter[0] = reverse(split(a:pattern, '\s*|\s*')) + a:world.filter[0][1 : -1]
|
||||
endf
|
||||
|
||||
|
||||
" :nodoc:
|
||||
function! s:prototype.PushFrontFilter(world, char) dict "{{{3
|
||||
let a:world.filter[0][0] .= nr2char(a:char)
|
||||
endf
|
||||
|
||||
|
||||
" :nodoc:
|
||||
function! s:prototype.ReduceFrontFilter(world) dict "{{{3
|
||||
let filter = a:world.filter[0][0]
|
||||
" TLogVAR filter
|
||||
let str = matchstr(filter, '\(\\\(\.\\{-}\|[.?*+$^]\)\|\)$')
|
||||
if empty(str)
|
||||
let filter = filter[0 : -2]
|
||||
else
|
||||
let filter = tlib#string#Strcharpart(filter, 0, len(filter) - len(str))
|
||||
endif
|
||||
" TLogVAR str, filter
|
||||
let a:world.filter[0][0] = filter
|
||||
endf
|
||||
|
||||
|
||||
" :nodoc:
|
||||
function! s:prototype.FilterRxPrefix() dict "{{{3
|
||||
return '\V'
|
||||
endf
|
||||
|
||||
|
||||
" :nodoc:
|
||||
function! s:prototype.CleanFilter(filter) dict "{{{3
|
||||
return a:filter
|
||||
endf
|
||||
|
||||
@ -1,53 +0,0 @@
|
||||
" Filter_cnfd.vim
|
||||
" @Author: Tom Link (mailto:micathom AT gmail com?subject=[vim])
|
||||
" @Website: http://www.vim.org/account/profile.php?user_id=4037
|
||||
" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
|
||||
" @Created: 2008-11-25.
|
||||
" @Last Change: 2014-01-23.
|
||||
" @Revision: 0.0.57
|
||||
|
||||
let s:prototype = tlib#Filter_cnf#New({'_class': ['Filter_cnfd'], 'name': 'cnfd'}) "{{{2
|
||||
let s:prototype.highlight = g:tlib#input#higroup
|
||||
|
||||
|
||||
" The same as |tlib#Filter_cnf#New()| but a dot is expanded to '\.\{-}'.
|
||||
" As a consequence, patterns cannot match dots.
|
||||
" The pattern is a '/\V' very no-'/magic' regexp pattern.
|
||||
function! tlib#Filter_cnfd#New(...) "{{{3
|
||||
let object = s:prototype.New(a:0 >= 1 ? a:1 : {})
|
||||
return object
|
||||
endf
|
||||
|
||||
|
||||
" :nodoc:
|
||||
function! s:prototype.Init(world) dict "{{{3
|
||||
endf
|
||||
|
||||
|
||||
let s:Help = s:prototype.Help
|
||||
|
||||
" :nodoc:
|
||||
function! s:prototype.Help(world) dict "{{{3
|
||||
call call(s:Help, [a:world], self)
|
||||
call a:world.PushHelp('.', 'Any characters')
|
||||
endf
|
||||
|
||||
|
||||
" :nodoc:
|
||||
function! s:prototype.SetFrontFilter(world, pattern) dict "{{{3
|
||||
let pattern = substitute(a:pattern, '\.', '\\.\\{-}', 'g')
|
||||
let a:world.filter[0] = reverse(split(pattern, '\s*|\s*')) + a:world.filter[0][1 : -1]
|
||||
endf
|
||||
|
||||
|
||||
" :nodoc:
|
||||
function! s:prototype.PushFrontFilter(world, char) dict "{{{3
|
||||
let a:world.filter[0][0] .= a:char == 46 ? '\.\{-}' : nr2char(a:char)
|
||||
endf
|
||||
|
||||
|
||||
" :nodoc:
|
||||
function! s:prototype.CleanFilter(filter) dict "{{{3
|
||||
return substitute(a:filter, '\\.\\{-}', '.', 'g')
|
||||
endf
|
||||
|
||||
@ -1,83 +0,0 @@
|
||||
" Filter_fuzzy.vim
|
||||
" @Author: Tom Link (mailto:micathom AT gmail com?subject=[vim])
|
||||
" @Website: http://www.vim.org/account/profile.php?user_id=4037
|
||||
" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
|
||||
" @Created: 2008-11-25.
|
||||
" @Last Change: 2013-09-25.
|
||||
" @Revision: 0.0.47
|
||||
|
||||
let s:prototype = tlib#Filter_cnf#New({'_class': ['Filter_fuzzy'], 'name': 'fuzzy'}) "{{{2
|
||||
let s:prototype.highlight = g:tlib#input#higroup
|
||||
|
||||
|
||||
" Support for "fuzzy" pattern matching in |tlib#input#List()|.
|
||||
" Patterns are interpreted as if characters were connected with '.\{-}'.
|
||||
"
|
||||
" In "fuzzy" mode, the pretty printing of filenames is disabled.
|
||||
function! tlib#Filter_fuzzy#New(...) "{{{3
|
||||
let object = s:prototype.New(a:0 >= 1 ? a:1 : {})
|
||||
return object
|
||||
endf
|
||||
|
||||
|
||||
" :nodoc:
|
||||
function! s:prototype.Init(world) dict "{{{3
|
||||
" TLogVAR a:world.display_format
|
||||
" :nodoc:
|
||||
function! a:world.Set_display_format(value) dict
|
||||
if a:value == 'filename'
|
||||
let self.display_format = ''
|
||||
else
|
||||
let self.display_format = a:value
|
||||
endif
|
||||
endf
|
||||
endf
|
||||
|
||||
|
||||
let s:Help = s:prototype.Help
|
||||
|
||||
" :nodoc:
|
||||
function! s:prototype.Help(world) dict "{{{3
|
||||
call call(s:Help, [a:world], self)
|
||||
call a:world.PushHelp('Patterns are interpreted as if characters were connected with .\{-}')
|
||||
endf
|
||||
|
||||
|
||||
" :nodoc:
|
||||
function! s:prototype.DisplayFilter(filter) dict "{{{3
|
||||
" TLogVAR a:filter
|
||||
let filter1 = deepcopy(a:filter)
|
||||
call map(filter1, '"{". join(reverse(v:val), " OR ") ."}"')
|
||||
return join(reverse(filter1), ' AND ')
|
||||
endf
|
||||
|
||||
|
||||
" :nodoc:
|
||||
function! s:prototype.SetFrontFilter(world, pattern) dict "{{{3
|
||||
let a:world.filter[0] = map(reverse(split(a:pattern, '\s*|\s*')), 'join(map(split(v:val, ''\zs''), ''tlib#rx#Escape(v:val, "V")''), ''\.\{-}'')') + a:world.filter[0][1 : -1]
|
||||
endif
|
||||
endf
|
||||
|
||||
|
||||
" :nodoc:
|
||||
function! s:prototype.PushFrontFilter(world, char) dict "{{{3
|
||||
let ch = tlib#rx#Escape(nr2char(a:char), 'V')
|
||||
if empty(a:world.filter[0][0])
|
||||
let a:world.filter[0][0] .= ch
|
||||
else
|
||||
let a:world.filter[0][0] .= '\.\{-}'. ch
|
||||
endif
|
||||
endf
|
||||
|
||||
|
||||
" :nodoc:
|
||||
function! s:prototype.ReduceFrontFilter(world) dict "{{{3
|
||||
let a:world.filter[0][0] = substitute(a:world.filter[0][0], '\(\\\.\\{-}\)\?.$', '', '')
|
||||
endf
|
||||
|
||||
|
||||
" :nodoc:
|
||||
function! s:prototype.CleanFilter(filter) dict "{{{3
|
||||
return substitute(a:filter, '\\\.\\{-}', '', 'g')
|
||||
endf
|
||||
|
||||
@ -1,68 +0,0 @@
|
||||
" @Author: Tom Link (mailto:micathom AT gmail com?subject=[vim])
|
||||
" @Website: http://www.vim.org/account/profile.php?user_id=4037
|
||||
" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
|
||||
" @Created: 2008-11-25.
|
||||
" @Last Change: 2014-11-18.
|
||||
" @Revision: 0.0.82
|
||||
|
||||
let s:prototype = tlib#Filter_cnf#New({'_class': ['Filter_glob'], 'name': 'glob'}) "{{{2
|
||||
let s:prototype.highlight = g:tlib#input#higroup
|
||||
|
||||
|
||||
" A character that should be expanded to '\.\{-}'.
|
||||
TLet g:tlib#Filter_glob#seq = '*'
|
||||
|
||||
|
||||
" A character that should be expanded to '\.\?'.
|
||||
TLet g:tlib#Filter_glob#char = '?'
|
||||
|
||||
|
||||
" The same as |tlib#Filter_cnf#New()| but a a customizable character
|
||||
" |see tlib#Filter_glob#seq| is expanded to '\.\{-}' and
|
||||
" |g:tlib#Filter_glob#char| is expanded to '\.'.
|
||||
" The pattern is a '/\V' very no-'/magic' regexp pattern.
|
||||
function! tlib#Filter_glob#New(...) "{{{3
|
||||
let object = s:prototype.New(a:0 >= 1 ? a:1 : {})
|
||||
return object
|
||||
endf
|
||||
|
||||
|
||||
let s:Help = s:prototype.Help
|
||||
|
||||
" :nodoc:
|
||||
function! s:prototype.Help(world) dict "{{{3
|
||||
call call(s:Help, [a:world], self)
|
||||
call a:world.PushHelp(g:tlib#Filter_glob#seq, 'Any characters')
|
||||
call a:world.PushHelp(g:tlib#Filter_glob#char, 'Single characters')
|
||||
endf
|
||||
|
||||
|
||||
" :nodoc:
|
||||
function! s:prototype.SetFrontFilter(world, pattern) dict "{{{3
|
||||
let pattern = substitute(a:pattern, tlib#rx#Escape(g:tlib#Filter_glob#seq, 'V'), '\\.\\{-}', 'g')
|
||||
let pattern = substitute(a:pattern, tlib#rx#Escape(g:tlib#Filter_glob#char, 'V'), '\\.', 'g')
|
||||
let a:world.filter[0] = reverse(split(pattern, '\s*|\s*')) + a:world.filter[0][1 : -1]
|
||||
endf
|
||||
|
||||
|
||||
" :nodoc:
|
||||
function! s:prototype.PushFrontFilter(world, char) dict "{{{3
|
||||
" TLogVAR a:char, nr2char(a:char)
|
||||
if a:char == char2nr(g:tlib#Filter_glob#seq)
|
||||
let char = '\.\{-}'
|
||||
elseif a:char == char2nr(g:tlib#Filter_glob#char)
|
||||
let char = '\.'
|
||||
else
|
||||
let char = nr2char(a:char)
|
||||
endif
|
||||
let a:world.filter[0][0] .= char
|
||||
endf
|
||||
|
||||
|
||||
" :nodoc:
|
||||
function! s:prototype.CleanFilter(filter) dict "{{{3
|
||||
let filter = substitute(a:filter, '\\\.\\{-}', g:tlib#Filter_glob#seq, 'g')
|
||||
let filter = substitute(filter, '\\\.', g:tlib#Filter_glob#char, 'g')
|
||||
return filter
|
||||
endf
|
||||
|
||||
@ -1,154 +0,0 @@
|
||||
" @Author: Tom Link (micathom AT gmail com?subject=[vim])
|
||||
" @Website: http://www.vim.org/account/profile.php?user_id=4037
|
||||
" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
|
||||
" @Revision: 127
|
||||
|
||||
" :filedoc:
|
||||
" Provides a prototype plus some OO-like methods.
|
||||
|
||||
let s:id_counter = 0
|
||||
let s:prototype = {'_class': ['object'], '_super': [], '_id': 0} "{{{2
|
||||
|
||||
" :def: function! tlib#Object#New(?fields={})
|
||||
" This function creates a prototype that provides some kind of
|
||||
" inheritance mechanism and a way to call parent/super methods.
|
||||
"
|
||||
" The usage demonstrated in the following example works best when every
|
||||
" class/prototype is defined in a file of its own.
|
||||
"
|
||||
" The reason for why there is a dedicated constructor function is that
|
||||
" this layout facilitates the use of templates and that methods are
|
||||
" hidden from the user. Other solutions are possible.
|
||||
"
|
||||
" EXAMPLES: >
|
||||
" let s:prototype = tlib#Object#New({
|
||||
" \ '_class': ['FooBar'],
|
||||
" \ 'foo': 1,
|
||||
" \ 'bar': 2,
|
||||
" \ })
|
||||
" " Constructor
|
||||
" function! FooBar(...)
|
||||
" let object = s:prototype.New(a:0 >= 1 ? a:1 : {})
|
||||
" return object
|
||||
" endf
|
||||
" function! s:prototype.babble() {
|
||||
" echo "I think, therefore I am ". (self.foo * self.bar) ." months old."
|
||||
" }
|
||||
"
|
||||
" < This could now be used like this: >
|
||||
" let myfoo = FooBar({'foo': 3})
|
||||
" call myfoo.babble()
|
||||
" => I think, therefore I am 6 months old.
|
||||
" echo myfoo.IsA('FooBar')
|
||||
" => 1
|
||||
" echo myfoo.IsA('object')
|
||||
" => 1
|
||||
" echo myfoo.IsA('Foo')
|
||||
" => 0
|
||||
" echo myfoo.RespondTo('babble')
|
||||
" => 1
|
||||
" echo myfoo.RespondTo('speak')
|
||||
" => 0
|
||||
function! tlib#Object#New(...) "{{{3
|
||||
return s:prototype.New(a:0 >= 1 ? a:1 : {})
|
||||
endf
|
||||
|
||||
|
||||
function! s:prototype.New(...) dict "{{{3
|
||||
let object = deepcopy(self)
|
||||
let s:id_counter += 1
|
||||
let object._id = s:id_counter
|
||||
if a:0 >= 1 && !empty(a:1)
|
||||
" call object.Extend(deepcopy(a:1))
|
||||
call object.Extend(a:1)
|
||||
endif
|
||||
return object
|
||||
endf
|
||||
|
||||
|
||||
function! s:prototype.Inherit(object) dict "{{{3
|
||||
let class = copy(self._class)
|
||||
" TLogVAR class
|
||||
let objid = self._id
|
||||
for c in get(a:object, '_class', [])
|
||||
" TLogVAR c
|
||||
if index(class, c) == -1
|
||||
call add(class, c)
|
||||
endif
|
||||
endfor
|
||||
call extend(self, a:object, 'keep')
|
||||
let self._class = class
|
||||
" TLogVAR self._class
|
||||
let self._id = objid
|
||||
" let self._super = [super] + self._super
|
||||
call insert(self._super, a:object)
|
||||
return self
|
||||
endf
|
||||
|
||||
|
||||
function! s:prototype.Extend(dictionary) dict "{{{3
|
||||
let super = copy(self)
|
||||
let class = copy(self._class)
|
||||
" TLogVAR class
|
||||
let objid = self._id
|
||||
let thisclass = get(a:dictionary, '_class', [])
|
||||
for c in type(thisclass) == 3 ? thisclass : [thisclass]
|
||||
" TLogVAR c
|
||||
if index(class, c) == -1
|
||||
call add(class, c)
|
||||
endif
|
||||
endfor
|
||||
call extend(self, a:dictionary)
|
||||
let self._class = class
|
||||
" TLogVAR self._class
|
||||
let self._id = objid
|
||||
" let self._super = [super] + self._super
|
||||
call insert(self._super, super)
|
||||
return self
|
||||
endf
|
||||
|
||||
|
||||
function! s:prototype.IsA(class) dict "{{{3
|
||||
return index(self._class, a:class) != -1
|
||||
endf
|
||||
|
||||
|
||||
function! s:prototype.IsRelated(object) dict "{{{3
|
||||
return len(filter(a:object._class, 'self.IsA(v:val)')) > 1
|
||||
endf
|
||||
|
||||
|
||||
function! s:prototype.RespondTo(name) dict "{{{3
|
||||
" return has_key(self, a:name) && type(self[a:name]) == 2
|
||||
return has_key(self, a:name)
|
||||
endf
|
||||
|
||||
|
||||
function! s:prototype.Super(method, arglist) dict "{{{3
|
||||
for o in self._super
|
||||
" TLogVAR o
|
||||
if o.RespondTo(a:method)
|
||||
" let self._tmp_method = o[a:method]
|
||||
" TLogVAR self._tmp_method
|
||||
" return call(self._tmp_method, a:arglist, self)
|
||||
return call(o[a:method], a:arglist, self)
|
||||
endif
|
||||
endfor
|
||||
echoerr 'tlib#Object: Does not respond to '. a:method .': '. string(self)
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#Object#Methods(object, ...) "{{{3
|
||||
TVarArg ['pattern', '\d\+']
|
||||
let o = items(a:object)
|
||||
call filter(o, 'type(v:val[1]) == 2 && string(v:val[1]) =~ "^function(''\\d\\+'')"')
|
||||
let acc = {}
|
||||
for e in o
|
||||
let id = matchstr(string(e[1]), pattern)
|
||||
if !empty(id)
|
||||
let acc[id] = e[0]
|
||||
endif
|
||||
endfor
|
||||
return acc
|
||||
endf
|
||||
|
||||
@ -1,19 +0,0 @@
|
||||
" @Author: Tom Link (micathom AT gmail com?subject=[vim])
|
||||
" @Website: http://www.vim.org/account/profile.php?user_id=4037
|
||||
" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
|
||||
" @Revision: 11
|
||||
|
||||
" :enddoc:
|
||||
|
||||
|
||||
let s:prototype = tlib#Object#New({'_class': ['Test']}) "{{{2
|
||||
function! tlib#Test#New(...) "{{{3
|
||||
let object = s:prototype.New(a:0 >= 1 ? a:1 : {})
|
||||
return object
|
||||
endf
|
||||
|
||||
|
||||
function! s:prototype.Dummy() dict "{{{3
|
||||
return 'Test.vim'
|
||||
endf
|
||||
|
||||
@ -1,19 +0,0 @@
|
||||
" @Author: Tom Link (micathom AT gmail com?subject=[vim])
|
||||
" @Website: http://www.vim.org/account/profile.php?user_id=4037
|
||||
" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
|
||||
" @Revision: 15
|
||||
|
||||
" :enddoc:
|
||||
|
||||
|
||||
let s:prototype = tlib#Test#New({'_class': ['TestChild']}) "{{{2
|
||||
function! tlib#TestChild#New(...) "{{{3
|
||||
let object = s:prototype.New(a:0 >= 1 ? a:1 : {})
|
||||
return object
|
||||
endf
|
||||
|
||||
|
||||
function! s:prototype.Dummy() dict "{{{3
|
||||
return 'TestChild.vim'
|
||||
endf
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@ -1,716 +0,0 @@
|
||||
" @Author: Tom Link (micathom AT gmail com?subject=[vim])
|
||||
" @Website: http://www.vim.org/account/profile.php?user_id=4037
|
||||
" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
|
||||
" @Revision: 362
|
||||
|
||||
" :filedoc:
|
||||
" Various agents for use as key handlers in tlib#input#List()
|
||||
|
||||
" Number of items to move when pressing <c-up/down> in the input list window.
|
||||
TLet g:tlib_scroll_lines = 10
|
||||
|
||||
|
||||
" General {{{1
|
||||
|
||||
function! tlib#agent#Exit(world, selected) "{{{3
|
||||
Tlibtrace 'tlib', a:selected
|
||||
if a:world.key_mode ==# 'default'
|
||||
call a:world.CloseScratch()
|
||||
let a:world.state = 'exit empty escape'
|
||||
let a:world.list = []
|
||||
" let a:world.base = []
|
||||
call a:world.ResetSelected()
|
||||
else
|
||||
let a:world.key_mode = 'default'
|
||||
let a:world.state = 'redisplay'
|
||||
endif
|
||||
return a:world
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#agent#CopyItems(world, selected) "{{{3
|
||||
Tlibtrace 'tlib', a:selected
|
||||
let @* = join(a:selected, "\n")
|
||||
let a:world.state = 'redisplay'
|
||||
return a:world
|
||||
endf
|
||||
|
||||
|
||||
|
||||
" InputList related {{{1
|
||||
|
||||
function! tlib#agent#PageUp(world, selected) "{{{3
|
||||
Tlibtrace 'tlib', a:selected
|
||||
let a:world.offset -= (winheight(0) / 2)
|
||||
let a:world.state = 'scroll'
|
||||
return a:world
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#agent#PageDown(world, selected) "{{{3
|
||||
Tlibtrace 'tlib', a:selected
|
||||
let a:world.offset += (winheight(0) / 2)
|
||||
let a:world.state = 'scroll'
|
||||
return a:world
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#agent#Home(world, selected) "{{{3
|
||||
Tlibtrace 'tlib', a:selected
|
||||
let a:world.prefidx = 1
|
||||
let a:world.state = 'redisplay'
|
||||
return a:world
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#agent#End(world, selected) "{{{3
|
||||
Tlibtrace 'tlib', a:selected
|
||||
let a:world.prefidx = len(a:world.list)
|
||||
let a:world.state = 'redisplay'
|
||||
return a:world
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#agent#Up(world, selected, ...) "{{{3
|
||||
TVarArg ['lines', 1]
|
||||
Tlibtrace 'tlib', a:selected, lines
|
||||
let a:world.idx = ''
|
||||
if a:world.prefidx > lines
|
||||
let a:world.prefidx -= lines
|
||||
else
|
||||
let a:world.prefidx = len(a:world.list)
|
||||
endif
|
||||
let a:world.state = 'redisplay'
|
||||
return a:world
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#agent#Down(world, selected, ...) "{{{3
|
||||
TVarArg ['lines', 1]
|
||||
Tlibtrace 'tlib', a:selected, lines
|
||||
let a:world.idx = ''
|
||||
if a:world.prefidx <= (len(a:world.list) - lines)
|
||||
let a:world.prefidx += lines
|
||||
else
|
||||
let a:world.prefidx = 1
|
||||
endif
|
||||
let a:world.state = 'redisplay'
|
||||
return a:world
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#agent#UpN(world, selected) "{{{3
|
||||
Tlibtrace 'tlib', a:selected
|
||||
return tlib#agent#Up(a:world, a:selected, g:tlib_scroll_lines)
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#agent#DownN(world, selected) "{{{3
|
||||
Tlibtrace 'tlib', a:selected
|
||||
return tlib#agent#Down(a:world, a:selected, g:tlib_scroll_lines)
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#agent#ShiftLeft(world, selected) "{{{3
|
||||
Tlibtrace 'tlib', a:selected
|
||||
let a:world.offset_horizontal -= (winwidth(0) / 2)
|
||||
if a:world.offset_horizontal < 0
|
||||
let a:world.offset_horizontal = 0
|
||||
endif
|
||||
let a:world.state = 'display shift'
|
||||
return a:world
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#agent#ShiftRight(world, selected) "{{{3
|
||||
Tlibtrace 'tlib', a:selected
|
||||
let a:world.offset_horizontal += (winwidth(0) / 2)
|
||||
let a:world.state = 'display shift'
|
||||
return a:world
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#agent#Reset(world, selected) "{{{3
|
||||
Tlibtrace 'tlib', a:selected
|
||||
let a:world.state = 'reset'
|
||||
return a:world
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#agent#ToggleRestrictView(world, selected) "{{{3
|
||||
Tlibtrace 'tlib', a:selected
|
||||
if empty(a:world.filtered_items)
|
||||
return tlib#agent#RestrictView(a:world, a:selected)
|
||||
else
|
||||
return tlib#agent#UnrestrictView(a:world, a:selected)
|
||||
endif
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#agent#RestrictView(world, selected) "{{{3
|
||||
Tlibtrace 'tlib', a:selected
|
||||
let filtered_items = map(copy(a:selected), 'index(a:world.base, v:val) + 1')
|
||||
Tlibtrace 'tlib', 1, filtered_items
|
||||
let filtered_items = filter(filtered_items, 'v:val > 0')
|
||||
Tlibtrace 'tlib', 2, filtered_items
|
||||
if !empty(filtered_items)
|
||||
let a:world.filtered_items = filtered_items
|
||||
endif
|
||||
let a:world.state = 'display'
|
||||
return a:world
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#agent#UnrestrictView(world, selected) "{{{3
|
||||
Tlibtrace 'tlib', a:selected
|
||||
let a:world.filtered_items = []
|
||||
let a:world.state = 'display'
|
||||
return a:world
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#agent#Input(world, selected) "{{{3
|
||||
Tlibtrace 'tlib', a:selected
|
||||
let flt0 = a:world.CleanFilter(a:world.filter[0][0])
|
||||
let flt1 = input('Filter: ', flt0)
|
||||
echo
|
||||
if flt1 != flt0
|
||||
if empty(flt1)
|
||||
call getchar(0)
|
||||
else
|
||||
call a:world.SetFrontFilter(flt1)
|
||||
endif
|
||||
endif
|
||||
let a:world.state = 'display'
|
||||
return a:world
|
||||
endf
|
||||
|
||||
|
||||
" Suspend (see |tlib#agent#Suspend|) the input loop and jump back to the
|
||||
" original position in the parent window.
|
||||
function! tlib#agent#SuspendToParentWindow(world, selected) "{{{3
|
||||
Tlibtrace 'tlib', a:selected
|
||||
let world = a:world
|
||||
let wid = world.win_id
|
||||
Tlibtrace 'tlib', wid
|
||||
if wid != -1
|
||||
let world = tlib#agent#Suspend(world, a:selected)
|
||||
if world.state =~# '\<suspend\>'
|
||||
call world.SwitchWindow('win')
|
||||
" let pos = world.cursor
|
||||
" Tlibtrace 'tlib', pos
|
||||
" if !empty(pos)
|
||||
" call setpos('.', pos)
|
||||
" endif
|
||||
return world
|
||||
endif
|
||||
endif
|
||||
let world.state = 'redisplay'
|
||||
return world
|
||||
endf
|
||||
|
||||
|
||||
" Suspend lets you temporarily leave the input loop of
|
||||
" |tlib#input#List|. You can resume editing the list by pressing <c-z>,
|
||||
" <m-z>. <space>, <c-LeftMouse> or <MiddleMouse> in the suspended window.
|
||||
" <cr> and <LeftMouse> will immediatly select the item under the cursor.
|
||||
" < will select the item but the window will remain opened.
|
||||
function! tlib#agent#Suspend(world, selected) "{{{3
|
||||
Tlibtrace 'tlib', a:selected
|
||||
if a:world.allow_suspend
|
||||
" TAssert IsNotEmpty(a:world.scratch)
|
||||
" TLogDBG bufnr('%')
|
||||
let br = tlib#buffer#Set(a:world.scratch)
|
||||
Tlibtrace 'tlib', br, a:world.bufnr, a:world.scratch
|
||||
if bufnr('%') != a:world.scratch
|
||||
echohl WarningMsg
|
||||
echom "tlib#agent#Suspend: Internal error: Not a scratch buffer:" bufname('%')
|
||||
echohl NONE
|
||||
endif
|
||||
Tlibtrace 'tlib', bufnr('%'), bufname('%'), a:world.scratch
|
||||
call tlib#autocmdgroup#Init()
|
||||
exec 'autocmd TLib BufEnter <buffer='. a:world.scratch .'> call tlib#input#Resume("world", 0, '. a:world.scratch .')'
|
||||
let b:tlib_world = a:world
|
||||
exec br
|
||||
let a:world.state = 'exit suspend'
|
||||
else
|
||||
echom 'Suspend disabled'
|
||||
let a:world.state = 'redisplay'
|
||||
endif
|
||||
return a:world
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#agent#Help(world, selected) "{{{3
|
||||
Tlibtrace 'tlib', a:selected
|
||||
let a:world.state = 'help'
|
||||
return a:world
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#agent#OR(world, selected) "{{{3
|
||||
Tlibtrace 'tlib', a:selected
|
||||
if !empty(a:world.filter[0])
|
||||
call insert(a:world.filter[0], '')
|
||||
endif
|
||||
let a:world.state = 'display'
|
||||
return a:world
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#agent#AND(world, selected) "{{{3
|
||||
Tlibtrace 'tlib', a:selected
|
||||
if !empty(a:world.filter[0])
|
||||
call insert(a:world.filter, [''])
|
||||
endif
|
||||
let a:world.state = 'display'
|
||||
return a:world
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#agent#ReduceFilter(world, selected) "{{{3
|
||||
Tlibtrace 'tlib', a:selected
|
||||
call a:world.ReduceFilter()
|
||||
let a:world.offset = 1
|
||||
let a:world.state = 'display'
|
||||
return a:world
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#agent#PopFilter(world, selected) "{{{3
|
||||
Tlibtrace 'tlib', a:selected
|
||||
call a:world.PopFilter()
|
||||
let a:world.offset = 1
|
||||
let a:world.state = 'display'
|
||||
return a:world
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#agent#Debug(world, selected) "{{{3
|
||||
Tlibtrace 'tlib', a:selected
|
||||
" echo string(world.state)
|
||||
echo string(a:world.filter)
|
||||
echo string(a:world.idx)
|
||||
echo string(a:world.prefidx)
|
||||
echo string(a:world.sel_idx)
|
||||
call getchar()
|
||||
let a:world.state = 'display'
|
||||
return a:world
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#agent#Select(world, selected) "{{{3
|
||||
Tlibtrace 'tlib', a:selected
|
||||
call a:world.SelectItem('toggle', a:world.prefidx)
|
||||
" let a:world.state = 'display keepcursor'
|
||||
let a:world.state = 'redisplay'
|
||||
return a:world
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#agent#SelectUp(world, selected) "{{{3
|
||||
Tlibtrace 'tlib', a:selected
|
||||
call a:world.SelectItem('toggle', a:world.prefidx)
|
||||
if a:world.prefidx > 1
|
||||
let a:world.prefidx -= 1
|
||||
endif
|
||||
let a:world.state = 'redisplay'
|
||||
return a:world
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#agent#SelectDown(world, selected) "{{{3
|
||||
Tlibtrace 'tlib', a:selected
|
||||
call a:world.SelectItem('toggle', a:world.prefidx)
|
||||
if a:world.prefidx < len(a:world.list)
|
||||
let a:world.prefidx += 1
|
||||
endif
|
||||
let a:world.state = 'redisplay'
|
||||
return a:world
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#agent#SelectAll(world, selected) "{{{3
|
||||
Tlibtrace 'tlib', a:selected
|
||||
let listrange = range(1, len(a:world.list))
|
||||
let mode = empty(filter(copy(listrange), 'index(a:world.sel_idx, a:world.GetBaseIdx(v:val)) == -1'))
|
||||
\ ? 'toggle' : 'set'
|
||||
for i in listrange
|
||||
call a:world.SelectItem(mode, i)
|
||||
endfor
|
||||
let a:world.state = 'display keepcursor'
|
||||
return a:world
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#agent#ToggleStickyList(world, selected) "{{{3
|
||||
Tlibtrace 'tlib', a:selected
|
||||
let a:world.sticky = !a:world.sticky
|
||||
let a:world.state = 'display keepcursor'
|
||||
return a:world
|
||||
endf
|
||||
|
||||
|
||||
|
||||
" EditList related {{{1
|
||||
|
||||
function! tlib#agent#EditItem(world, selected) "{{{3
|
||||
Tlibtrace 'tlib', a:selected
|
||||
let lidx = a:world.prefidx
|
||||
Tlibtrace 'tlib', lidx
|
||||
let bidx = a:world.GetBaseIdx(lidx)
|
||||
Tlibtrace 'tlib', bidx
|
||||
let item = a:world.GetBaseItem(bidx)
|
||||
let item = input(lidx .'@'. bidx .': ', item)
|
||||
if item != ''
|
||||
call a:world.SetBaseItem(bidx, item)
|
||||
endif
|
||||
let a:world.state = 'display'
|
||||
return a:world
|
||||
endf
|
||||
|
||||
|
||||
" Insert a new item below the current one.
|
||||
function! tlib#agent#NewItem(world, selected) "{{{3
|
||||
Tlibtrace 'tlib', a:selected
|
||||
let basepi = a:world.GetBaseIdx(a:world.prefidx)
|
||||
let item = input('New item: ')
|
||||
call insert(a:world.base, item, basepi)
|
||||
let a:world.state = 'reset'
|
||||
return a:world
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#agent#DeleteItems(world, selected) "{{{3
|
||||
Tlibtrace 'tlib', a:selected
|
||||
let remove = copy(a:world.sel_idx)
|
||||
let basepi = a:world.GetBaseIdx(a:world.prefidx)
|
||||
if index(remove, basepi) == -1
|
||||
call add(remove, basepi)
|
||||
endif
|
||||
" call map(remove, 'a:world.GetBaseIdx(v:val)')
|
||||
for idx in reverse(sort(remove))
|
||||
call remove(a:world.base, idx - 1)
|
||||
endfor
|
||||
let a:world.state = 'display'
|
||||
call a:world.ResetSelected()
|
||||
" let a:world.state = 'reset'
|
||||
return a:world
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#agent#Cut(world, selected) "{{{3
|
||||
Tlibtrace 'tlib', a:selected
|
||||
let world = tlib#agent#Copy(a:world, a:selected)
|
||||
return tlib#agent#DeleteItems(world, a:selected)
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#agent#Copy(world, selected) "{{{3
|
||||
Tlibtrace 'tlib', a:selected
|
||||
let a:world.clipboard = []
|
||||
let bidxs = copy(a:world.sel_idx)
|
||||
call add(bidxs, a:world.GetBaseIdx(a:world.prefidx))
|
||||
for bidx in sort(bidxs)
|
||||
call add(a:world.clipboard, a:world.GetBaseItem(bidx))
|
||||
endfor
|
||||
let a:world.state = 'redisplay'
|
||||
return a:world
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#agent#Paste(world, selected) "{{{3
|
||||
Tlibtrace 'tlib', a:selected
|
||||
if has_key(a:world, 'clipboard')
|
||||
for e in reverse(copy(a:world.clipboard))
|
||||
call insert(a:world.base, e, a:world.prefidx)
|
||||
endfor
|
||||
endif
|
||||
let a:world.state = 'display'
|
||||
call a:world.ResetSelected()
|
||||
return a:world
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#agent#EditReturnValue(world, rv) "{{{3
|
||||
Tlibtrace 'tlib', a:rv
|
||||
return [a:world.state !~ '\<exit\>', a:world.base]
|
||||
endf
|
||||
|
||||
|
||||
|
||||
" Files related {{{1
|
||||
|
||||
function! tlib#agent#ViewFile(world, selected) "{{{3
|
||||
Tlibtrace 'tlib', a:selected
|
||||
if !empty(a:selected)
|
||||
let back = a:world.SwitchWindow('win')
|
||||
Tlibtrace 'tlib', back
|
||||
for filename in a:selected
|
||||
call tlib#file#Edit(filename)
|
||||
endfor
|
||||
call a:world.SetOrigin(1)
|
||||
silent! exec back
|
||||
let a:world.state = 'display'
|
||||
endif
|
||||
return a:world
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#agent#EditFile(world, selected) "{{{3
|
||||
Tlibtrace 'tlib', a:selected
|
||||
return tlib#agent#Exit(tlib#agent#ViewFile(a:world, a:selected), a:selected)
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#agent#EditFileInSplit(world, selected) "{{{3
|
||||
Tlibtrace 'tlib', a:selected
|
||||
call a:world.CloseScratch()
|
||||
call tlib#file#With('split', 'sbuffer', a:selected, a:world, 1)
|
||||
call a:world.SetOrigin(1)
|
||||
return tlib#agent#Exit(a:world, a:selected)
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#agent#EditFileInVSplit(world, selected) "{{{3
|
||||
Tlibtrace 'tlib', a:selected
|
||||
call a:world.CloseScratch()
|
||||
let winpos = tlib#fixes#Winpos()
|
||||
call tlib#file#With('vertical split', 'vertical sbuffer', a:selected, a:world, 1)
|
||||
if !empty(winpos)
|
||||
exec winpos
|
||||
endif
|
||||
call a:world.SetOrigin(1)
|
||||
return tlib#agent#Exit(a:world, a:selected)
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#agent#EditFileInTab(world, selected) "{{{3
|
||||
Tlibtrace 'tlib', a:selected
|
||||
call a:world.CloseScratch()
|
||||
call tlib#file#With('tabedit', 'tab sbuffer', a:selected, a:world, 1)
|
||||
call a:world.SetOrigin(1)
|
||||
return tlib#agent#Exit(a:world, a:selected)
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#agent#EditFileInWindow(world, selected) "{{{3
|
||||
Tlibtrace 'tlib', a:selected
|
||||
call a:world.CloseScratch()
|
||||
call tlib#file#With('hide edit', 'hide buffer', a:selected, a:world, 1)
|
||||
call a:world.SetOrigin(1)
|
||||
return tlib#agent#Exit(a:world, a:selected)
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#agent#ToggleScrollbind(world, selected) "{{{3
|
||||
Tlibtrace 'tlib', a:selected
|
||||
let a:world.scrollbind = get(a:world, 'scrollbind') ? 0 : 1
|
||||
let a:world.state = 'redisplay'
|
||||
return a:world
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#agent#ShowInfo(world, selected)
|
||||
Tlibtrace 'tlib', a:selected
|
||||
let lines = []
|
||||
for f in a:selected
|
||||
if filereadable(f)
|
||||
let desc = [getfperm(f), strftime('%c', getftime(f)), getfsize(f) .' bytes', getftype(f)]
|
||||
call add(lines, fnamemodify(f, ':p'))
|
||||
call add(lines, ' '. join(desc, '; '))
|
||||
endif
|
||||
endfor
|
||||
let a:world.temp_lines = lines
|
||||
let a:world.state = 'printlines'
|
||||
return a:world
|
||||
endf
|
||||
|
||||
|
||||
|
||||
" Buffer related {{{1
|
||||
|
||||
function! tlib#agent#ViewBufferInWindow(world, selected) "{{{3
|
||||
Tlibtrace 'tlib', a:selected
|
||||
if !empty(a:selected)
|
||||
let back = a:world.SwitchWindow('win')
|
||||
Tlibtrace 'tlib', back
|
||||
for bufname in a:selected
|
||||
let cmd = &modified && !&hidden ? 'sbuffer' : 'buffer'
|
||||
exec cmd fnameescape(bufname)
|
||||
endfor
|
||||
" exec back
|
||||
endif
|
||||
return tlib#agent#Exit(a:world, a:selected)
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#agent#PreviewLine(world, selected) "{{{3
|
||||
Tlibtrace 'tlib', a:selected
|
||||
let l = a:selected[0]
|
||||
" let ww = winnr()
|
||||
let wid = tlib#win#GetID()
|
||||
call tlib#agent#SuspendToParentWindow(a:world, a:selected)
|
||||
call tlib#buffer#ViewLine(l, 1)
|
||||
call tlib#win#GotoID(wid)
|
||||
" exec ww .'wincmd w'
|
||||
let a:world.state = 'redisplay'
|
||||
return a:world
|
||||
endf
|
||||
|
||||
|
||||
" If not called from the scratch, we assume/guess that we don't have to
|
||||
" suspend the input-evaluation loop.
|
||||
function! tlib#agent#GotoLine(world, selected) "{{{3
|
||||
Tlibtrace 'tlib', a:selected
|
||||
if !empty(a:selected)
|
||||
let l = a:selected[0]
|
||||
if a:world.win_id != tlib#win#GetID()
|
||||
let world = tlib#agent#Suspend(a:world, a:selected)
|
||||
call tlib#win#GotoID(a:world.win_id)
|
||||
endif
|
||||
call tlib#buffer#ViewLine(l, 1)
|
||||
|
||||
endif
|
||||
return a:world
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#agent#DoAtLine(world, selected) "{{{3
|
||||
Tlibtrace 'tlib', a:selected
|
||||
if !empty(a:selected)
|
||||
let cmd = input('Command: ', '', 'command')
|
||||
if !empty(cmd)
|
||||
call a:world.SwitchWindow('win')
|
||||
" let pos = getpos('.')
|
||||
let view = winsaveview()
|
||||
for l in a:selected
|
||||
call tlib#buffer#ViewLine(l, '')
|
||||
exec cmd
|
||||
endfor
|
||||
" call setpos('.', pos)
|
||||
call winrestview(view)
|
||||
endif
|
||||
endif
|
||||
call a:world.ResetSelected()
|
||||
let a:world.state = 'exit'
|
||||
return a:world
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#agent#Wildcard(world, selected) "{{{3
|
||||
Tlibtrace 'tlib', a:selected
|
||||
if !empty(a:world.filter[0])
|
||||
let rx_type = a:world.matcher.FilterRxPrefix()
|
||||
let flt0 = a:world.CleanFilter(a:world.filter[0][0])
|
||||
if rx_type == '\V'
|
||||
let flt0 .= '\.\{-}'
|
||||
else
|
||||
let flt0 .= '.\{-}'
|
||||
endif
|
||||
call a:world.SetFrontFilter(flt0)
|
||||
endif
|
||||
let a:world.state = 'redisplay'
|
||||
return a:world
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#agent#Null(world, selected) "{{{3
|
||||
Tlibtrace 'tlib', a:selected
|
||||
let a:world.state = 'redisplay'
|
||||
return a:world
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#agent#ExecAgentByName(world, selected) "{{{3
|
||||
Tlibtrace 'tlib', a:selected
|
||||
let s:agent_names_world = a:world
|
||||
let agent_names = {'Help': 'tlib#agent#Help'}
|
||||
for def in values(a:world.key_map[a:world.key_mode])
|
||||
if has_key(def, 'help') && !empty(def.help) && has_key(def, 'agent') && !empty(def.agent)
|
||||
let agent_names[def.help] = def.agent
|
||||
endif
|
||||
endfor
|
||||
let s:agent_names = sort(keys(agent_names))
|
||||
let command = input('Command: ', '', 'customlist,tlib#agent#CompleteAgentNames')
|
||||
Tlibtrace 'tlib', command
|
||||
if !has_key(agent_names, command)
|
||||
Tlibtrace 'tlib', command
|
||||
silent! let matches = filter(keys(agent_names), 'v:val =~ command')
|
||||
Tlibtrace 'tlib', matches
|
||||
if len(matches) == 1
|
||||
let command = matches[0]
|
||||
endif
|
||||
endif
|
||||
if has_key(agent_names, command)
|
||||
let agent = agent_names[command]
|
||||
return call(agent, [a:world, a:selected])
|
||||
else
|
||||
if !empty(command)
|
||||
echohl WarningMsg
|
||||
echom "Unknown command:" command
|
||||
echohl NONE
|
||||
sleep 1
|
||||
endif
|
||||
let a:world.state = 'display'
|
||||
return a:world
|
||||
endif
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#agent#CompleteAgentNames(ArgLead, CmdLine, CursorPos)
|
||||
let arglead = tolower(a:Arglead)
|
||||
return filter(copy(s:agent_names), 'stridx(tolower(v:val), arglead) != -1')
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#agent#Complete(world, selected) abort "{{{3
|
||||
Tlibtrace 'tlib', a:selected
|
||||
let rxprefix = a:world.matcher.FilterRxPrefix()
|
||||
let flt = a:world.filter[0][0]
|
||||
Tlibtrace 'tlib', flt
|
||||
let fltrx = rxprefix . flt . '\m[^[:space:][:cntrl:][:punct:]<>*+?&~{}()\[\]\\/]\+'
|
||||
let fltrx0 = '\m^' . fltrx
|
||||
Tlibtrace 'tlib', fltrx, fltrx0
|
||||
let words = {}
|
||||
for item in a:world.list
|
||||
let parts = split(item, '\ze'. fltrx)
|
||||
Tlibtrace 'tlib', item, parts
|
||||
for part in parts
|
||||
let word = matchstr(part, fltrx0)
|
||||
Tlibtrace 'tlib', part, word
|
||||
if !empty(word)
|
||||
let words[word] = 1
|
||||
endif
|
||||
endfor
|
||||
endfor
|
||||
Tlibtrace 'tlib', keys(words)
|
||||
let completions = keys(words)
|
||||
" let completions = filter(keys(words), 'matchstr(v:val, fltrx0)')
|
||||
let completions = sort(completions, 's:SortCompletions')
|
||||
let completions = tlib#list#Uniq(completions)
|
||||
Tlibtrace 'tlib', 0, completions
|
||||
while len(completions) > 1
|
||||
let nchar = strwidth(completions[0]) - 1
|
||||
let completions = map(completions, 'tlib#string#Strcharpart(v:val, 0, nchar)')
|
||||
Tlibtrace 'tlib', 'reduce', completions
|
||||
let completions = tlib#list#Uniq(completions)
|
||||
Tlibtrace 'tlib', 'unique', len(completions), completions
|
||||
endwh
|
||||
Tlibtrace 'tlib', 9, completions
|
||||
if empty(completions)
|
||||
let a:world.state = 'redisplay update'
|
||||
else
|
||||
let a:world.filter[0][0] = completions[0]
|
||||
let a:world.state = 'display update'
|
||||
endif
|
||||
return a:world
|
||||
endf
|
||||
|
||||
|
||||
function! s:SortCompletions(a, b) abort "{{{3
|
||||
let i1 = strwidth(a:a)
|
||||
let i2 = strwidth(a:b)
|
||||
return i2 - i1
|
||||
endf
|
||||
|
||||
@ -1,342 +0,0 @@
|
||||
" @Author: Tom Link (micathom AT gmail com?subject=[vim])
|
||||
" @Website: http://www.vim.org/account/profile.php?user_id=4037
|
||||
" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
|
||||
" @Last Change: 2017-09-28.
|
||||
" @Revision: 273
|
||||
|
||||
|
||||
" :def: function! tlib#arg#Get(n, var, ?default="", ?test='')
|
||||
" Set a positional argument from a variable argument list.
|
||||
" See tlib#string#RemoveBackslashes() for an example.
|
||||
function! tlib#arg#Get(n, var, ...) "{{{3
|
||||
let default = a:0 >= 1 ? a:1 : ''
|
||||
let atest = a:0 >= 2 ? a:2 : ''
|
||||
" TLogVAR default, atest
|
||||
if !empty(atest)
|
||||
let atest = ' && (a:'. a:n .' '. atest .')'
|
||||
endif
|
||||
let test = printf('a:0 >= %d', a:n) . atest
|
||||
return printf('let %s = %s ? a:%d : %s', a:var, test, a:n, string(default))
|
||||
endf
|
||||
|
||||
|
||||
" :def: function! tlib#arg#Let(list, ?default='')
|
||||
" Set a positional arguments from a variable argument list.
|
||||
" See tlib#input#List() for an example.
|
||||
function! tlib#arg#Let(list, ...) "{{{3
|
||||
let default = a:0 >= 1 ? a:1 : ''
|
||||
let list = map(copy(a:list), 'type(v:val) == 3 ? v:val : [v:val, default]')
|
||||
let args = map(range(1, len(list)), 'call("tlib#arg#Get", [v:val] + list[v:val - 1])')
|
||||
return join(args, ' | ')
|
||||
endf
|
||||
|
||||
|
||||
" :def: function! tlib#arg#StringAsKeyArgs(string, ?keys=[], ?evaluate=0, ?sep=':', ?booleans=0)
|
||||
function! tlib#arg#StringAsKeyArgs(string, ...) "{{{1
|
||||
TVarArg ['keys', {}], ['evaluate', 0], ['sep', ':'], ['booleans', 0]
|
||||
let keyargs = {}
|
||||
let args = split(a:string, '\\\@<! ')
|
||||
let key_rx = booleans ? '\([-+]\?\w\+\)' : '\(\w\+\)'
|
||||
let arglist = map(args, 'matchlist(v:val, ''^\%('. key_rx . sep .'\(.*\)\|\(.*\)\)$'')')
|
||||
" TLogVAR a:string, args, arglist
|
||||
let pos = -1
|
||||
for matchlist in arglist
|
||||
if !empty(matchlist[3])
|
||||
if booleans && matchlist[3] =~ '^[-+]'
|
||||
let key = substitute(matchlist[3], '^[-+]', '', '')
|
||||
let val = matchstr(matchlist[3], '^[-+]')
|
||||
let keyargs[key] = val ==# '+'
|
||||
else
|
||||
let pos += 1
|
||||
let keyargs[pos] = matchlist[3]
|
||||
endif
|
||||
else
|
||||
let [match, key, val; rest] = matchlist
|
||||
if empty(keys) || has_key(keys, key)
|
||||
let val = substitute(val, '\\\\', '\\', 'g')
|
||||
if evaluate
|
||||
let val = eval(val)
|
||||
endif
|
||||
let keyargs[key] = val
|
||||
else
|
||||
echom 'Unknown key: '. key .'='. val
|
||||
endif
|
||||
endif
|
||||
endfor
|
||||
if pos >= 0
|
||||
let keyargs['__posargs__'] = range(0, pos)
|
||||
endif
|
||||
return keyargs
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#arg#StringAsKeyArgsEqual(string) "{{{1
|
||||
return tlib#arg#StringAsKeyArgs(a:string, [], 0, '=', 1)
|
||||
endf
|
||||
|
||||
|
||||
" :display: tlib#arg#GetOpts(args, ?def={})
|
||||
" Convert a list of strings of command-line arguments into a dictonary.
|
||||
"
|
||||
" The main use case is to pass [<f-args>], i.e. the command-line
|
||||
" arguments of a command as list, from a command definition to this
|
||||
" function.
|
||||
"
|
||||
" Example:
|
||||
" ['-h']
|
||||
" => If def contains a 'help' key, invoke |:help| on its value.
|
||||
"
|
||||
" ['-ab', '--foo', '--bar=BAR', 'bla', bla']
|
||||
" => {'a': 1, 'b': 1, 'foo': 1, 'bar': 'BAR', '__rest__': ['bla', 'bla']}
|
||||
"
|
||||
" ['-ab', '--', '--foo', '--bar=BAR']
|
||||
" => {'a': 1, 'b': 1, '__rest__': ['--foo', '--bar=BAR']}
|
||||
function! tlib#arg#GetOpts(args, ...) abort "{{{3
|
||||
if type(a:args) == 4
|
||||
reutrn a:args
|
||||
else
|
||||
let throw = a:0 == 0
|
||||
TVarArg ['def', {}]
|
||||
" TLogVAR def
|
||||
let opts = {'__exit__': 0}
|
||||
for [key, vdef] in items(get(def, 'values', {}))
|
||||
if has_key(vdef, 'default')
|
||||
let opts[key] = vdef.default
|
||||
endif
|
||||
endfor
|
||||
let idx = 0
|
||||
for o in a:args
|
||||
let [break, idx] = s:SetOpt(def, opts, idx, o)
|
||||
if break == 1
|
||||
break
|
||||
elseif break == 2
|
||||
if throw
|
||||
throw 'tlib#arg#GetOpts: Show help'
|
||||
else
|
||||
let opts.__exit__ = 5
|
||||
endif
|
||||
endif
|
||||
endfor
|
||||
let opts.__rest__ = a:args[idx : -1]
|
||||
return opts
|
||||
endif
|
||||
endf
|
||||
|
||||
|
||||
function! s:GetValueType(def) abort "{{{3
|
||||
return get(a:def, 'type', type(get(a:def, 'default', '')))
|
||||
endf
|
||||
|
||||
|
||||
function! s:SetOpt(def, opts, idx, opt) abort "{{{3
|
||||
" TLogVAR a:def
|
||||
let idx = a:idx + 1
|
||||
let break = 0
|
||||
let long = get(a:def, 'long', 1)
|
||||
let short = get(a:def, 'short', 1)
|
||||
if (short && a:opt =~# '^-[?h]$') || (long && a:opt ==# '--help')
|
||||
if has_key(a:def, 'help')
|
||||
exec 'help' a:def.help
|
||||
else
|
||||
" TLogVAR a:def
|
||||
let values = get(a:def, 'values', {})
|
||||
let flags = get(a:def, 'flags', {})
|
||||
if empty(values) && empty(flags)
|
||||
echom 'No help'
|
||||
else
|
||||
if !empty(values)
|
||||
echom 'Options:'
|
||||
for [key, vdef] in sort(items(values))
|
||||
let opt = key
|
||||
let default = get(vdef, 'default', '')
|
||||
let type = s:GetValueType(vdef)
|
||||
if default =~ '^-\?\d\+\%(\.\d\+\)$'
|
||||
if type == -1 || type == 6
|
||||
let opt .= ' (flag)'
|
||||
elseif type == 1
|
||||
let opt .= '=INT'
|
||||
else
|
||||
let opt .= '=INT or maybe BOOL'
|
||||
endif
|
||||
elseif type(default) == 1
|
||||
let opt .= '=STRING'
|
||||
elseif type(default) == 3
|
||||
let opt .= '=COMMA-LIST'
|
||||
endif
|
||||
echom printf(' --%20s (default: %s)', opt, string(default))
|
||||
endfor
|
||||
endif
|
||||
if !empty(flags)
|
||||
echom 'Short flags:'
|
||||
for [sflag, lflag] in sort(items(flags))
|
||||
echom printf(' -%s -> %s', sflag, lflag)
|
||||
endfor
|
||||
endif
|
||||
endif
|
||||
endif
|
||||
let break = 2
|
||||
elseif long && a:opt =~# '^--\%(no-\)\?debug$'
|
||||
if has_key(a:def, 'trace')
|
||||
let mod = a:opt =~# '--no-' ? '-' : '+'
|
||||
exec 'Tlibtraceset' mod . a:def.trace
|
||||
endif
|
||||
elseif long && a:opt =~# '^--no-.\+'
|
||||
let key = matchstr(a:opt, '^--no-\zs.\+$')
|
||||
let a:opts[key] = s:Validate(a:def, key, 0)
|
||||
elseif long && a:opt =~# '^--\w\+$'
|
||||
let key = matchstr(a:opt, '^--\zs.\+$')
|
||||
let a:opts[key] = s:Validate(a:def, key, 1)
|
||||
elseif long && a:opt =~# '^--\w\+='
|
||||
let ml = matchlist(a:opt, '^--\(\w\+\)=\(.*\)$')
|
||||
if empty(ml)
|
||||
throw 'tlib#arg#GetOpts: Cannot parse: '. a:opt
|
||||
else
|
||||
let values = get(a:def, 'values', {})
|
||||
if has_key(values, ml[1])
|
||||
let vdef = values[ml[1]]
|
||||
let type = s:GetValueType(vdef)
|
||||
if type == -1
|
||||
let opt_value = !!str2nr(ml[2])
|
||||
elseif type == 0
|
||||
let opt_value = str2nr(ml[2])
|
||||
elseif type == 1
|
||||
let opt_value = ml[2]
|
||||
elseif type == 2
|
||||
let opt_value = function(ml[2])
|
||||
elseif type == 3
|
||||
let opt_value = tlib#string#SplitCommaList(ml[2])
|
||||
elseif type == 4
|
||||
throw 'tlib#arg#GetOpts: Unsupported type conversion for '. ml[1]
|
||||
elseif type == 5
|
||||
let opt_value = str2float(ml[2])
|
||||
endif
|
||||
else
|
||||
let opt_value = ml[2]
|
||||
endif
|
||||
let a:opts[ml[1]] = s:Validate(a:def, ml[1], opt_value)
|
||||
unlet opt_value
|
||||
endif
|
||||
elseif short && a:opt =~# '^-\w='
|
||||
let flagdefs = get(a:def, 'flags', {})
|
||||
let flag = matchstr(a:opt, '^-\zs\w')
|
||||
let rest = matchstr(a:opt, '^-\w\zs.*$')
|
||||
call s:SetFlag(a:def, a:opts, idx, flag, rest, flagdefs)
|
||||
elseif short && a:opt =~# '^-\w\+$'
|
||||
let flagdefs = get(a:def, 'flags', {})
|
||||
for flag in split(substitute(a:opt, '^-', '', ''), '\zs')
|
||||
call s:SetFlag(a:def, a:opts, idx, flag, '', flagdefs)
|
||||
endfor
|
||||
else
|
||||
let break = 1
|
||||
if a:opt !=# '--'
|
||||
let idx -= 1
|
||||
endif
|
||||
endif
|
||||
return [break, idx]
|
||||
endf
|
||||
|
||||
|
||||
function! s:SetFlag(def, opts, idx, flag, rest, flagdefs) abort "{{{3
|
||||
" TLogVAR a:def
|
||||
if has_key(a:flagdefs, a:flag)
|
||||
call s:SetOpt(a:def, a:opts, a:idx, a:flagdefs[a:flag] . a:rest)
|
||||
else
|
||||
let a:opts[a:flag] = s:Validate(a:def, a:flag, 1)
|
||||
endif
|
||||
endf
|
||||
|
||||
|
||||
function! s:Validate(def, name, value) abort "{{{3
|
||||
let values = get(a:def, 'values', {})
|
||||
if has_key(values, a:name)
|
||||
let vdef = values[a:name]
|
||||
if has_key(vdef, 'validate')
|
||||
if !call(vdef.validate, [a:value])
|
||||
throw printf('tlib#arg: %s has invalid value: %s', string(a:name), string(a:value))
|
||||
endif
|
||||
endif
|
||||
endif
|
||||
return a:value
|
||||
endf
|
||||
|
||||
|
||||
":nodoc:
|
||||
function! tlib#arg#CComplete(def, ArgLead) abort "{{{3
|
||||
let values = get(a:def, 'values', {})
|
||||
let opt = matchstr(a:ArgLead, '^--\zs\w\+\ze=')
|
||||
if has_key(values, opt)
|
||||
let words = []
|
||||
let vals = values[opt]
|
||||
let complete_customlist = get(vals, 'complete_customlist', '')
|
||||
if !empty(complete_customlist)
|
||||
let words = eval(complete_customlist)
|
||||
" else
|
||||
" let complete = get(vals, 'complete', '')
|
||||
" if !empty(complete)
|
||||
" endif
|
||||
endif
|
||||
if !empty(words)
|
||||
let prefix = matchstr(a:ArgLead, '^--\w\+=\%([^,]\+,\s*\)*')
|
||||
let lead = substitute(a:ArgLead, '^--\w\+=\%([^,]\+,\s*\)*', '', '')
|
||||
" TLogVAR a:ArgLead, lead
|
||||
if !empty(lead)
|
||||
let nchar = len(lead)
|
||||
call filter(words, 'tlib#string#Strcharpart(v:val, 0, nchar) ==# lead')
|
||||
endif
|
||||
let words = map(words, 'prefix . v:val')
|
||||
return sort(words)
|
||||
endif
|
||||
endif
|
||||
let cs = {'-h': 1, '--help': 1}
|
||||
for [name, vdef] in items(values)
|
||||
let type = s:GetValueType(vdef)
|
||||
if type >= 0
|
||||
let name .= '='
|
||||
else
|
||||
let cs['--no-'. name] = 1
|
||||
endif
|
||||
let cs['--'. name] = 1
|
||||
endfor
|
||||
for [name, subst] in items(get(a:def, 'flags', {}))
|
||||
let ldef = get(values, substitute(subst, '^--', '', ''), {})
|
||||
let type = s:GetValueType(ldef)
|
||||
if type >= 0
|
||||
let name .= '='
|
||||
endif
|
||||
let cs['-'. name] = 1
|
||||
endfor
|
||||
if has_key(a:def, 'trace')
|
||||
let cs['--debug'] = 1
|
||||
endif
|
||||
let nchar = len(a:ArgLead)
|
||||
if nchar > 0
|
||||
call filter(cs, 'tlib#string#Strcharpart(v:key, 0, nchar) ==# a:ArgLead')
|
||||
endif
|
||||
return sort(keys(cs))
|
||||
endf
|
||||
|
||||
|
||||
|
||||
""" Command line {{{1
|
||||
|
||||
" :def: function! tlib#arg#Ex(arg, ?chars='%#! ')
|
||||
" Escape some characters in a string.
|
||||
"
|
||||
" Use |fnamescape()| if available.
|
||||
"
|
||||
" EXAMPLES: >
|
||||
" exec 'edit '. tlib#arg#Ex('foo%#bar.txt')
|
||||
function! tlib#arg#Ex(arg, ...) "{{{3
|
||||
if exists('*fnameescape') && a:0 == 0
|
||||
return fnameescape(a:arg)
|
||||
else
|
||||
" let chars = '%# \'
|
||||
let chars = '%#! '
|
||||
if a:0 >= 1
|
||||
let chars .= a:1
|
||||
endif
|
||||
return escape(a:arg, chars)
|
||||
endif
|
||||
endf
|
||||
|
||||
|
||||
@ -1,44 +0,0 @@
|
||||
" @Author: Tom Link (mailto:micathom AT gmail com?subject=[vim])
|
||||
" @Website: https://github.com/tomtom
|
||||
" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
|
||||
" @Last Change: 2017-02-22
|
||||
" @Revision: 42
|
||||
|
||||
|
||||
" Enable tracing via |:Tlibassert|.
|
||||
function! tlib#assert#Enable() abort "{{{3
|
||||
" :nodoc:
|
||||
command! -nargs=+ -bang Tlibassert call tlib#assert#Assert(expand('<sfile>'), <q-args>, [<args>])
|
||||
endf
|
||||
|
||||
|
||||
" Disable tracing via |:Tlibassert|.
|
||||
function! tlib#assert#Disable() abort "{{{3
|
||||
" :nodoc:
|
||||
command! -nargs=+ -bang Tlibassert :
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#assert#Assert(caller, check, vals) abort "{{{3
|
||||
for val in a:vals
|
||||
" TLogVAR val
|
||||
if type(val) == 3
|
||||
call tlib#assert#Assert(a:caller, a:check, val)
|
||||
elseif !val
|
||||
throw 'Tlibassert: '. tlib#trace#Backtrace(a:caller) .': '. a:check
|
||||
endif
|
||||
endfor
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#assert#Map(vals, expr) abort "{{{3
|
||||
return tlib#assert#All(map(a:vals, a:expr))
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#assert#All(vals) abort "{{{3
|
||||
" TLogVAR a:vals, empty(filter(a:vals, '!v:val'))
|
||||
return empty(filter(a:vals, '!v:val'))
|
||||
endf
|
||||
|
||||
|
||||
@ -1,14 +0,0 @@
|
||||
" autocmdgroup.vim
|
||||
" @Author: Tom Link (mailto:micathom AT gmail com?subject=[vim])
|
||||
" @Website: http://www.vim.org/account/profile.php?user_id=4037
|
||||
" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
|
||||
" @Revision: 7
|
||||
|
||||
augroup TLib
|
||||
autocmd!
|
||||
augroup END
|
||||
|
||||
|
||||
function! tlib#autocmdgroup#Init() "{{{3
|
||||
endf
|
||||
|
||||
@ -1,73 +0,0 @@
|
||||
" @Author: Tom Link (micathom AT gmail com?subject=[vim])
|
||||
" @Website: http://www.vim.org/account/profile.php?user_id=4037
|
||||
" @GIT: http://github.com/tomtom/tlib_vim/
|
||||
" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
|
||||
" @Created: 2010-08-30.
|
||||
" @Last Change: 2015-11-23.
|
||||
" @Revision: 48
|
||||
|
||||
|
||||
function! tlib#balloon#Register(expr) "{{{3
|
||||
if !has('balloon_eval')
|
||||
return
|
||||
endif
|
||||
if !exists('b:tlib_balloons')
|
||||
let b:tlib_balloons = []
|
||||
endif
|
||||
if !&ballooneval
|
||||
setlocal ballooneval
|
||||
endif
|
||||
if &balloonexpr != 'tlib#balloon#Expr()'
|
||||
if !empty(&balloonexpr)
|
||||
call add(b:tlib_balloons, &balloonexpr)
|
||||
endif
|
||||
setlocal ballooneval balloonexpr=tlib#balloon#Expr()
|
||||
endif
|
||||
if index(b:tlib_balloons, a:expr) == -1
|
||||
call add(b:tlib_balloons, a:expr)
|
||||
endif
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#balloon#Remove(expr) "{{{3
|
||||
if exists('b:tlib_balloons')
|
||||
call filter(b:tlib_balloons, 'v:val != a:expr')
|
||||
if empty(b:tlib_balloons)
|
||||
setlocal ballooneval&
|
||||
setlocal balloonexpr&
|
||||
unlet b:tlib_balloons
|
||||
endif
|
||||
endif
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#balloon#Expr() "{{{3
|
||||
" TLogVAR exists('b:tlib_balloons')
|
||||
if !exists('b:tlib_balloons')
|
||||
return ''
|
||||
endif
|
||||
let text = map(copy(b:tlib_balloons), 'eval(v:val)')
|
||||
" TLogVAR b:tlib_balloons, text
|
||||
call filter(text, '!empty(v:val)')
|
||||
if has('balloon_multiline')
|
||||
return join(text, "\n----------------------------------\n")
|
||||
else
|
||||
return get(text, 0, '')
|
||||
endif
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#balloon#Expand(expr) abort "{{{3
|
||||
if v:beval_bufnr != bufnr('%')
|
||||
" TLogVAR v:beval_bufnr, bufnr('%')
|
||||
return ''
|
||||
endif
|
||||
let win = winsaveview()
|
||||
try
|
||||
call setpos('.', [v:beval_bufnr, v:beval_lnum, v:beval_col, 0])
|
||||
return expand(a:expr)
|
||||
finally
|
||||
call winrestview(win)
|
||||
endtry
|
||||
endf
|
||||
|
||||
@ -1,141 +0,0 @@
|
||||
" @Author: Tom Link (mailto:micathom AT gmail com?subject=[vim])
|
||||
" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
|
||||
" @Revision: 124
|
||||
|
||||
|
||||
function! tlib#bitwise#Num2Bits(num) "{{{3
|
||||
if type(a:num) <= 1 || type(a:num) == 5
|
||||
let bits = reverse(tlib#number#ConvertBase(a:num, 2, 'list'))
|
||||
elseif type(a:num) == 3
|
||||
let bits = copy(a:num)
|
||||
else
|
||||
throw "tlib#bitwise#Num2Bits: Must be number of list: ". string(a:num)
|
||||
endif
|
||||
return bits
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#bitwise#Bits2Num(bits, ...) "{{{3
|
||||
let base = a:0 >= 1 ? a:1 : 10
|
||||
" TLogVAR a:bits
|
||||
let num = 0.0
|
||||
for i in range(len(a:bits))
|
||||
if get(a:bits, i, 0)
|
||||
let num += pow(2, i)
|
||||
endif
|
||||
endfor
|
||||
" TLogVAR num
|
||||
if base == 10
|
||||
if type(base) == 5
|
||||
return num
|
||||
else
|
||||
return float2nr(num)
|
||||
endif
|
||||
else
|
||||
return tlib#number#ConvertBase(num, base)
|
||||
endif
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#bitwise#AND(num1, num2, ...) "{{{3
|
||||
let rtype = a:0 >= 1 ? a:1 : 'num'
|
||||
return s:BitwiseComparison(a:num1, a:num2, rtype,
|
||||
\ 'get(bits1, v:val) && get(bits2, v:val)')
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#bitwise#OR(num1, num2, ...) "{{{3
|
||||
let rtype = a:0 >= 1 ? a:1 : 'num'
|
||||
return s:BitwiseComparison(a:num1, a:num2, rtype,
|
||||
\ 'get(bits1, v:val) || get(bits2, v:val)')
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#bitwise#XOR(num1, num2, ...) "{{{3
|
||||
let rtype = a:0 >= 1 ? a:1 : 'num'
|
||||
return s:BitwiseComparison(a:num1, a:num2, rtype,
|
||||
\ 'get(bits1, v:val) ? !get(bits2, v:val) : get(bits2, v:val)')
|
||||
endf
|
||||
|
||||
|
||||
function! s:BitwiseComparison(num1, num2, rtype, expr) "{{{3
|
||||
let bits1 = tlib#bitwise#Num2Bits(a:num1)
|
||||
let bits2 = tlib#bitwise#Num2Bits(a:num2)
|
||||
let range = range(max([len(bits1), len(bits2)]))
|
||||
let bits = map(range, a:expr)
|
||||
if a:rtype == 'num' || (a:rtype == 'auto' && type(a:num1) <= 1)
|
||||
return tlib#bitwise#Bits2Num(bits)
|
||||
else
|
||||
return bits
|
||||
endif
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#bitwise#ShiftRight(bits, n) "{{{3
|
||||
let bits = a:bits[a:n : -1]
|
||||
if empty(bits)
|
||||
let bits = [0]
|
||||
endif
|
||||
return bits
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#bitwise#ShiftLeft(bits, n) "{{{3
|
||||
let bits = repeat([0], a:n) + a:bits
|
||||
return bits
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#bitwise#Add(num1, num2, ...) "{{{3
|
||||
let rtype = a:0 >= 1 ? a:1 : 'num'
|
||||
let bits1 = tlib#bitwise#Num2Bits(a:num1)
|
||||
let bits2 = tlib#bitwise#Num2Bits(a:num2)
|
||||
let range = range(max([len(bits1), len(bits2)]))
|
||||
" TLogVAR bits1, bits2, range
|
||||
let carry = 0
|
||||
let bits = []
|
||||
for i in range
|
||||
let sum = get(bits1, i) + get(bits2, i) + carry
|
||||
if sum == 3
|
||||
let bit = 1
|
||||
let carry = 1
|
||||
elseif sum == 2
|
||||
let bit = 0
|
||||
let carry = 1
|
||||
elseif sum == 1
|
||||
let bit = 1
|
||||
let carry = 0
|
||||
elseif sum == 0
|
||||
let bit = 0
|
||||
let carry = 0
|
||||
endif
|
||||
call add(bits, bit)
|
||||
" TLogVAR i, bits, bit
|
||||
endfor
|
||||
if carry == 1
|
||||
call add(bits, carry)
|
||||
endif
|
||||
if rtype == 'num' || (rtype == 'auto' && type(a:num1) <= 1)
|
||||
return tlib#bitwise#Bits2Num(bits)
|
||||
else
|
||||
return bits
|
||||
endif
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#bitwise#Sub(num1, num2, ...) "{{{3
|
||||
let rtype = a:0 >= 1 ? a:1 : 'num'
|
||||
let bits1 = tlib#bitwise#Num2Bits(a:num1)
|
||||
let bits2 = tlib#bitwise#Num2Bits(a:num2)
|
||||
let range = range(max([len(bits1), len(bits2)]))
|
||||
let bits2 = map(range, '!get(bits2, v:val)')
|
||||
let bits2 = tlib#bitwise#Add(bits2, [1], 'bits')
|
||||
let bits3 = tlib#bitwise#Add(bits1, bits2, 'bits')
|
||||
let bits = bits3[0 : -2]
|
||||
if rtype == 'num' || (rtype == 'auto' && type(a:num1) <= 1)
|
||||
return tlib#bitwise#Bits2Num(bits)
|
||||
else
|
||||
return bits
|
||||
endif
|
||||
endf
|
||||
|
||||
@ -1,401 +0,0 @@
|
||||
" buffer.vim
|
||||
" @Author: Tom Link (micathom AT gmail com?subject=[vim])
|
||||
" @Website: http://www.vim.org/account/profile.php?user_id=4037
|
||||
" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
|
||||
" @Created: 2007-06-30.
|
||||
" @Last Change: 2017-09-28.
|
||||
" @Revision: 12.1.352
|
||||
|
||||
|
||||
" Where to display the line when using |tlib#buffer#ViewLine|.
|
||||
" For possible values for position see |scroll-cursor|.
|
||||
TLet g:tlib_viewline_position = 'zz'
|
||||
|
||||
|
||||
let s:bmru = []
|
||||
|
||||
|
||||
function! tlib#buffer#EnableMRU() abort "{{{3
|
||||
call tlib#autocmdgroup#Init()
|
||||
autocmd TLib BufEnter * call s:BMRU_Push(bufnr('%'))
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#buffer#DisableMRU() abort "{{{3
|
||||
call tlib#autocmdgroup#Init()
|
||||
autocmd! TLib BufEnter
|
||||
endf
|
||||
|
||||
|
||||
function! s:BMRU_Push(bnr) abort "{{{3
|
||||
let i = index(s:bmru, a:bnr)
|
||||
if i >= 0
|
||||
call remove(s:bmru, i)
|
||||
endif
|
||||
call insert(s:bmru, a:bnr)
|
||||
endf
|
||||
|
||||
|
||||
function! s:CompareBuffernameByBasename(a, b) abort "{{{3
|
||||
let rx = '"\zs.\{-}\ze" \+\S\+ \+\d\+$'
|
||||
let an = matchstr(a:a, rx)
|
||||
let an = fnamemodify(an, ':t')
|
||||
let bn = matchstr(a:b, rx)
|
||||
let bn = fnamemodify(bn, ':t')
|
||||
let rv = an == bn ? 0 : an > bn ? 1 : -1
|
||||
return rv
|
||||
endf
|
||||
|
||||
|
||||
function! s:CompareBufferNrByMRU(a, b) abort "{{{3
|
||||
let an = matchstr(a:a, '\s*\zs\d\+\ze')
|
||||
let bn = matchstr(a:b, '\s*\zs\d\+\ze')
|
||||
let ai = index(s:bmru, 0 + an)
|
||||
if ai == -1
|
||||
return 1
|
||||
else
|
||||
let bi = index(s:bmru, 0 + bn)
|
||||
if bi == -1
|
||||
return -1
|
||||
else
|
||||
return ai == bi ? 0 : ai > bi ? 1 : -1
|
||||
endif
|
||||
endif
|
||||
endf
|
||||
|
||||
|
||||
" Set the buffer to buffer and return a command as string that can be
|
||||
" evaluated by |:execute| in order to restore the original view.
|
||||
function! tlib#buffer#Set(buffer) abort "{{{3
|
||||
let lazyredraw = &lazyredraw
|
||||
set lazyredraw
|
||||
try
|
||||
let cb = bufnr('%')
|
||||
let sn = bufnr(a:buffer)
|
||||
if sn != cb
|
||||
let ws = bufwinnr(sn)
|
||||
if ws != -1
|
||||
let wb = bufwinnr('%')
|
||||
exec ws.'wincmd w'
|
||||
return wb.'wincmd w'
|
||||
else
|
||||
silent exec 'sbuffer! '. sn
|
||||
return 'wincmd c'
|
||||
endif
|
||||
else
|
||||
return ''
|
||||
endif
|
||||
finally
|
||||
let &lazyredraw = lazyredraw
|
||||
endtry
|
||||
endf
|
||||
|
||||
|
||||
" :def: function! tlib#buffer#Eval(buffer, code) abort
|
||||
" Evaluate CODE in BUFFER.
|
||||
"
|
||||
" EXAMPLES: >
|
||||
" call tlib#buffer#Eval('foo.txt', 'echo b:bar')
|
||||
function! tlib#buffer#Eval(buffer, code) abort "{{{3
|
||||
" let cb = bufnr('%')
|
||||
" let wb = bufwinnr('%')
|
||||
" " TLogVAR cb
|
||||
" let sn = bufnr(a:buffer)
|
||||
" let sb = sn != cb
|
||||
let lazyredraw = &lazyredraw
|
||||
set lazyredraw
|
||||
let restore = tlib#buffer#Set(a:buffer)
|
||||
try
|
||||
exec a:code
|
||||
" if sb
|
||||
" let ws = bufwinnr(sn)
|
||||
" if ws != -1
|
||||
" try
|
||||
" exec ws.'wincmd w'
|
||||
" exec a:code
|
||||
" finally
|
||||
" exec wb.'wincmd w'
|
||||
" endtry
|
||||
" else
|
||||
" try
|
||||
" silent exec 'sbuffer! '. sn
|
||||
" exec a:code
|
||||
" finally
|
||||
" wincmd c
|
||||
" endtry
|
||||
" endif
|
||||
" else
|
||||
" exec a:code
|
||||
" endif
|
||||
finally
|
||||
exec restore
|
||||
let &lazyredraw = lazyredraw
|
||||
endtry
|
||||
endf
|
||||
|
||||
|
||||
" :def: function! tlib#buffer#GetList(?show_hidden=0, ?show_number=0, " ?order='bufnr') abort
|
||||
" Possible values for the "order" argument:
|
||||
" bufnr :: Default behaviour
|
||||
" mru :: Sort buffers according to most recent use
|
||||
" basename :: Sort by the file's basename (last component)
|
||||
"
|
||||
" NOTE: MRU order works on second invocation only. If you want to always
|
||||
" use MRU order, call tlib#buffer#EnableMRU() in your ~/.vimrc file.
|
||||
function! tlib#buffer#GetList(...) abort
|
||||
TVarArg ['show_hidden', 0], ['show_number', 0], ['order', '']
|
||||
" TLogVAR show_hidden, show_number, order
|
||||
let ls_bang = show_hidden ? '!' : ''
|
||||
redir => bfs
|
||||
exec 'silent ls'. ls_bang
|
||||
redir END
|
||||
let buffer_list = split(bfs, '\n')
|
||||
if order ==# 'mru'
|
||||
if empty(s:bmru)
|
||||
call tlib#buffer#EnableMRU()
|
||||
echom 'tlib: Installed Buffer MRU logger; disable with: call tlib#buffer#DisableMRU()'
|
||||
else
|
||||
call sort(buffer_list, function('s:CompareBufferNrByMRU'))
|
||||
endif
|
||||
elseif order ==# 'basename'
|
||||
call sort(buffer_list, function('s:CompareBuffernameByBasename'))
|
||||
endif
|
||||
let buffer_nr = map(copy(buffer_list), 'str2nr(matchstr(v:val, ''\s*\zs\d\+\ze''))')
|
||||
" TLogVAR buffer_list, buffer_nr
|
||||
if show_number
|
||||
call map(buffer_list, 'matchstr(v:val, ''^\s*\d\+.\{-}\ze\s\+\S\+ \d\+\s*$'')')
|
||||
else
|
||||
call map(buffer_list, 'matchstr(v:val, ''^\s*\d\+\zs.\{-}\ze\s\+\S\+ \d\+\s*$'')')
|
||||
endif
|
||||
" TLogVAR buffer_list
|
||||
" call map(buffer_list, 'matchstr(v:val, ''^.\{-}\ze\s\+line \d\+\s*$'')')
|
||||
" TLogVAR buffer_list
|
||||
call map(buffer_list, 'matchstr(v:val, ''^[^"]\+''). printf("%-20s %s", fnamemodify(matchstr(v:val, ''"\zs.\{-}\ze"$''), ":t"), fnamemodify(matchstr(v:val, ''"\zs.\{-}\ze"$''), ":h"))')
|
||||
" TLogVAR buffer_list
|
||||
return [buffer_nr, buffer_list]
|
||||
endf
|
||||
|
||||
|
||||
" :def: function! tlib#buffer#ViewLine(line, ?position='z') abort
|
||||
" line is either a number or a string that begins with a number.
|
||||
" For possible values for position see |scroll-cursor|.
|
||||
" See also |g:tlib_viewline_position|.
|
||||
function! tlib#buffer#ViewLine(line, ...) abort "{{{3
|
||||
if a:line
|
||||
TVarArg 'pos'
|
||||
let ln = matchstr(a:line, '^\d\+')
|
||||
let lt = matchstr(a:line, '^\d\+: \zs.*')
|
||||
" TLogVAR pos, ln, lt
|
||||
exec ln
|
||||
if empty(pos)
|
||||
let pos = tlib#var#Get('tlib_viewline_position', 'wbg')
|
||||
endif
|
||||
" TLogVAR pos
|
||||
if !empty(pos)
|
||||
exec 'norm! '. pos
|
||||
endif
|
||||
call tlib#buffer#HighlightLine(ln)
|
||||
" let @/ = '\%'. ln .'l.*'
|
||||
endif
|
||||
endf
|
||||
|
||||
|
||||
function! s:UndoHighlightLine() abort "{{{3
|
||||
2match none
|
||||
autocmd! TLib CursorMoved,CursorMovedI <buffer>
|
||||
autocmd! TLib CursorHold,CursorHoldI <buffer>
|
||||
autocmd! TLib InsertEnter,InsertChange,InsertLeave <buffer>
|
||||
autocmd! TLib BufLeave,BufWinLeave,WinLeave,BufHidden <buffer>
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#buffer#HighlightLine(...) abort "{{{3
|
||||
TVarArg ['line', line('.')]
|
||||
" exec '2match MatchParen /^\%'. a:line .'l.*/'
|
||||
exec '2match Search /^\%'. line .'l.*/'
|
||||
call tlib#autocmdgroup#Init()
|
||||
exec 'autocmd TLib CursorMoved,CursorMovedI <buffer> if line(".") != '. line .' | call s:UndoHighlightLine() | endif'
|
||||
autocmd TLib CursorHold,CursorHoldI <buffer> call s:UndoHighlightLine()
|
||||
autocmd TLib InsertEnter <buffer> call s:UndoHighlightLine()
|
||||
" autocmd TLib BufLeave,BufWinLeave,WinLeave,BufHidden <buffer> call s:UndoHighlightLine()
|
||||
endf
|
||||
|
||||
|
||||
" Delete the lines in the current buffer. Wrapper for |:delete|.
|
||||
function! tlib#buffer#DeleteRange(line1, line2) abort "{{{3
|
||||
let r = @t
|
||||
try
|
||||
exec a:line1.','.a:line2.'delete t'
|
||||
finally
|
||||
let @t = r
|
||||
endtry
|
||||
endf
|
||||
|
||||
|
||||
" Replace a range of lines.
|
||||
function! tlib#buffer#ReplaceRange(line1, line2, lines) abort
|
||||
call tlib#buffer#DeleteRange(a:line1, a:line2)
|
||||
call append(a:line1 - 1, a:lines)
|
||||
endf
|
||||
|
||||
|
||||
" Initialize some scratch area at the bottom of the current buffer.
|
||||
function! tlib#buffer#ScratchStart() abort "{{{3
|
||||
norm! Go
|
||||
let b:tlib_inbuffer_scratch = line('$')
|
||||
return b:tlib_inbuffer_scratch
|
||||
endf
|
||||
|
||||
|
||||
" Remove the in-buffer scratch area.
|
||||
function! tlib#buffer#ScratchEnd() abort "{{{3
|
||||
if !exists('b:tlib_inbuffer_scratch')
|
||||
echoerr 'tlib: In-buffer scratch not initalized'
|
||||
endif
|
||||
call tlib#buffer#DeleteRange(b:tlib_inbuffer_scratch, line('$'))
|
||||
unlet b:tlib_inbuffer_scratch
|
||||
endf
|
||||
|
||||
|
||||
" Run exec on all buffers via bufdo and return to the original buffer.
|
||||
function! tlib#buffer#BufDo(exec) abort "{{{3
|
||||
let bn = bufnr('%')
|
||||
exec 'bufdo '. a:exec
|
||||
exec 'buffer! '. bn
|
||||
endf
|
||||
|
||||
|
||||
" :def: function! tlib#buffer#InsertText(text, keyargs) abort
|
||||
" Keyargs:
|
||||
" 'shift': 0|N
|
||||
" 'col': col('.')|N
|
||||
" 'lineno': line('.')|N
|
||||
" 'indent': 0|1
|
||||
" 'pos': 'e'|'s' ... Where to locate the cursor (somewhat like s and e in {offset})
|
||||
" Insert text (a string) in the buffer.
|
||||
function! tlib#buffer#InsertText(text, ...) abort "{{{3
|
||||
TVarArg ['keyargs', {}]
|
||||
" TLogVAR a:text, keyargs
|
||||
let keyargs = extend({
|
||||
\ 'shift': 0, 'col': col('.'), 'lineno': line('.'), 'pos': 'e', 'indent': 0
|
||||
\ }, keyargs)
|
||||
" TLogVAR keyargs
|
||||
let grow = 0
|
||||
let post_del_last_line = line('$') == 1
|
||||
let line = getline(keyargs.lineno)
|
||||
if keyargs.col + keyargs.shift > 0
|
||||
let pre = line[0 : (keyargs.col - 1 + keyargs.shift)]
|
||||
let post = line[(keyargs.col + keyargs.shift): -1]
|
||||
else
|
||||
let pre = ''
|
||||
let post = line
|
||||
endif
|
||||
" TLogVAR keyargs.lineno, line, pre, post
|
||||
let text0 = pre . a:text . post
|
||||
let text = split(text0, '\n', 1)
|
||||
" TLogVAR text
|
||||
let icol = len(pre)
|
||||
" exec 'norm! '. keyargs.lineno .'G'
|
||||
call cursor(keyargs.lineno, keyargs.col)
|
||||
if keyargs.indent && keyargs.col > 1
|
||||
if &formatoptions =~# '[or]'
|
||||
" FIXME: Is the simple version sufficient?
|
||||
" VERSION 1
|
||||
" " This doesn't work because it's not guaranteed that the
|
||||
" " cursor is set.
|
||||
" let cline = getline('.')
|
||||
" norm! a
|
||||
" "norm! o
|
||||
" " TAssertExec redraw | sleep 3
|
||||
" let idt = tlib#string#Strcharpart(getline('.'), 0, keyargs.col('.') + keyargs.shift)
|
||||
" " TLogVAR idt
|
||||
" let idtl = len(idt)
|
||||
" -1,.delete
|
||||
" " TAssertExec redraw | sleep 3
|
||||
" call append(keyargs.lineno - 1, cline)
|
||||
" call cursor(keyargs.lineno, keyargs.col)
|
||||
" " TAssertExec redraw | sleep 3
|
||||
" if idtl == 0 && icol != 0
|
||||
" let idt = matchstr(pre, '^\s\+')
|
||||
" let idtl = len(idt)
|
||||
" endif
|
||||
" VERSION 2
|
||||
let idt = matchstr(pre, '^\s\+')
|
||||
let idtl = len(idt)
|
||||
else
|
||||
let [m_0, idt, iline; rest] = matchlist(pre, '^\(\s*\)\(.*\)$')
|
||||
let idtl = len(idt)
|
||||
endif
|
||||
if idtl < icol
|
||||
let idt .= repeat(' ', icol - idtl)
|
||||
endif
|
||||
" TLogVAR idt
|
||||
let idtl1 = len(idt)
|
||||
for i in range(1, len(text) - 1)
|
||||
let text[i] = idt . text[i]
|
||||
let grow += idtl1
|
||||
endfor
|
||||
endif
|
||||
" TLogVAR text
|
||||
" exec 'norm! '. keyargs.lineno .'Gdd'
|
||||
call tlib#normal#WithRegister('"tdd', 't')
|
||||
call append(keyargs.lineno - 1, text)
|
||||
if post_del_last_line
|
||||
call tlib#buffer#KeepCursorPosition('$delete')
|
||||
endif
|
||||
let tlen = len(text)
|
||||
let posshift = matchstr(keyargs.pos, '\d\+')
|
||||
" TLogVAR keyargs.pos
|
||||
if keyargs.pos =~# '^e'
|
||||
exec keyargs.lineno + tlen - 1
|
||||
exec 'norm! 0'. (len(text[-1]) - len(post) + posshift - 1) .'l'
|
||||
elseif keyargs.pos =~# '^s'
|
||||
" TLogVAR keyargs.lineno, pre, posshift
|
||||
exec keyargs.lineno
|
||||
exec 'norm! '. len(pre) .'|'
|
||||
if !empty(posshift)
|
||||
exec 'norm! '. posshift .'h'
|
||||
endif
|
||||
endif
|
||||
" TLogDBG getline(keyargs.lineno)
|
||||
" TLogDBG string(getline(1, '$'))
|
||||
return grow
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#buffer#InsertText0(text, ...) abort "{{{3
|
||||
TVarArg ['keyargs', {}]
|
||||
let mode = get(keyargs, 'mode', 'i')
|
||||
" TLogVAR mode
|
||||
if !has_key(keyargs, 'shift')
|
||||
let col = col('.')
|
||||
" if mode =~ 'i'
|
||||
" let col += 1
|
||||
" endif
|
||||
let keyargs.shift = col >= col('$') ? 0 : -1
|
||||
" let keyargs.shift = col('.') >= col('$') ? 0 : -1
|
||||
" TLogVAR col
|
||||
" TLogDBG col('.') .'-'. col('$') .': '. string(getline('.'))
|
||||
endif
|
||||
" TLogVAR keyargs.shift
|
||||
return tlib#buffer#InsertText(a:text, keyargs)
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#buffer#CurrentByte() abort "{{{3
|
||||
return line2byte(line('.')) + col('.')
|
||||
endf
|
||||
|
||||
|
||||
" Evaluate cmd while maintaining the cursor position and jump registers.
|
||||
function! tlib#buffer#KeepCursorPosition(cmd) abort "{{{3
|
||||
" let pos = getpos('.')
|
||||
let view = winsaveview()
|
||||
try
|
||||
keepjumps exec a:cmd
|
||||
finally
|
||||
" call setpos('.', pos)
|
||||
call winrestview(view)
|
||||
endtry
|
||||
endf
|
||||
|
||||
@ -1,464 +0,0 @@
|
||||
" cache.vim
|
||||
" @Author: Tom Link (micathom AT gmail com?subject=[vim])
|
||||
" @Website: http://www.vim.org/account/profile.php?user_id=4037
|
||||
" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
|
||||
" @Created: 2007-06-30.
|
||||
" @Last Change: 2019-01-02.
|
||||
" @Revision: 125.1.243
|
||||
|
||||
|
||||
" The cache directory. If empty, use |tlib#dir#MyRuntime|.'/cache'.
|
||||
" You might want to delete old files from this directory from time to
|
||||
" time with a command like: >
|
||||
" find ~/vimfiles/cache/ -atime +31 -type f -print -delete
|
||||
TLet g:tlib_cache = ''
|
||||
|
||||
" |tlib#cache#Purge()|: Remove cache files older than N days.
|
||||
TLet g:tlib#cache#purge_days = 31
|
||||
|
||||
" Purge the cache every N days. Disable automatic purging by setting
|
||||
" this value to a negative value.
|
||||
TLet g:tlib#cache#purge_every_days = 31
|
||||
|
||||
" The encoding used for the purge-cache script.
|
||||
" Default: 'enc'
|
||||
TLet g:tlib#cache#script_encoding = &enc
|
||||
|
||||
" Whether to run the directory removal script:
|
||||
" 0 ... No
|
||||
" 1 ... Query user
|
||||
" 2 ... Yes
|
||||
TLet g:tlib#cache#run_script = 1
|
||||
|
||||
" Verbosity level:
|
||||
" 0 ... Be quiet
|
||||
" 1 ... Display informative message
|
||||
" 2 ... Display detailed messages
|
||||
TLet g:tlib#cache#verbosity = 1
|
||||
|
||||
" A list of regexps that are matched against partial filenames of the
|
||||
" cached files. If a regexp matches, the file won't be removed by
|
||||
" |tlib#cache#Purge()|.
|
||||
TLet g:tlib#cache#dont_purge = ['[\/]\.last_purge$']
|
||||
|
||||
" If the cache filename is longer than N characters, use
|
||||
" |pathshorten()|.
|
||||
TLet g:tlib#cache#max_filename = 200
|
||||
|
||||
TLet g:tlib#cache#use_json = 0
|
||||
|
||||
TLet g:tlib#cache#use_encoding = ''
|
||||
|
||||
|
||||
let s:cache = {}
|
||||
|
||||
|
||||
" :display: tlib#cache#Dir(?mode = 'bg', ?ensure_dir = true)
|
||||
" The default cache directory.
|
||||
function! tlib#cache#Dir(...) "{{{3
|
||||
TVarArg ['mode', 'bg'], ['ensure_dir', 1]
|
||||
let dir = tlib#var#Get('tlib_cache', mode)
|
||||
if empty(dir)
|
||||
let dir = tlib#file#Join([tlib#dir#MyRuntime(), 'cache'])
|
||||
endif
|
||||
if ensure_dir
|
||||
call tlib#dir#Ensure(dir)
|
||||
endif
|
||||
return dir
|
||||
endf
|
||||
|
||||
|
||||
" :display: tlib#cache#EncodedFilename(type, file, ?mkdir=0, ?dir='')
|
||||
" Encode `file` and call |tlib#cache#Filename()|.
|
||||
function! tlib#cache#EncodedFilename(type, file, ...) "{{{3
|
||||
let file = tlib#url#Encode(a:file)
|
||||
return call(function('tlib#cache#Filename'), [a:type, file] + a:000)
|
||||
endf
|
||||
|
||||
|
||||
" :def: function! tlib#cache#Filename(type, ?file=%, ?mkdir=0, ?dir='')
|
||||
function! tlib#cache#Filename(type, ...) "{{{3
|
||||
" TLogDBG 'bufname='. bufname('.')
|
||||
let dir0 = a:0 >= 3 && !empty(a:3) ? a:3 : tlib#cache#Dir()
|
||||
let dir = dir0
|
||||
if a:0 >= 1 && !empty(a:1)
|
||||
let file = a:1
|
||||
else
|
||||
if empty(expand('%:t'))
|
||||
return ''
|
||||
endif
|
||||
let file = expand('%:p')
|
||||
let file = tlib#file#Relative(file, tlib#file#Join([dir, '..']))
|
||||
endif
|
||||
" TLogVAR file, dir
|
||||
let mkdir = a:0 >= 2 ? a:2 : 0
|
||||
let file = substitute(file, '\.\.\|[:&<>]\|//\+\|\\\\\+', '_', 'g')
|
||||
let dirs = [dir, a:type]
|
||||
let dirf = fnamemodify(file, ':h')
|
||||
if dirf != '.'
|
||||
call add(dirs, dirf)
|
||||
endif
|
||||
let dir = tlib#file#Join(dirs)
|
||||
" TLogVAR dir
|
||||
let dir = tlib#dir#PlainName(dir)
|
||||
" TLogVAR dir
|
||||
let file = fnamemodify(file, ':t')
|
||||
" TLogVAR file, dir, mkdir
|
||||
let cache_file = tlib#file#Join([dir, file])
|
||||
if len(cache_file) > g:tlib#cache#max_filename
|
||||
" echom "DBG long filename" cache_file
|
||||
" echom "DBG long filename" dir
|
||||
if v:version >= 704
|
||||
let shortfilename = sha256(file)
|
||||
else
|
||||
let shortfilename = tlib#hash#Adler32(file)
|
||||
endif
|
||||
" let cache_file = tlib#cache#Filename(a:type, shortfilename, mkdir, dir0)
|
||||
let cache_file = tlib#file#Join([dir, shortfilename])
|
||||
else
|
||||
if mkdir && !isdirectory(dir)
|
||||
try
|
||||
call mkdir(dir, 'p')
|
||||
catch /^Vim\%((\a\+)\)\=:E739:/
|
||||
if filereadable(dir) && !isdirectory(dir)
|
||||
echoerr 'TLib: Cannot create directory for cache file because a file with the same name exists (please delete it):' dir
|
||||
" call delete(dir)
|
||||
" call mkdir(dir, 'p')
|
||||
endif
|
||||
endtry
|
||||
endif
|
||||
endif
|
||||
" TLogVAR cache_file
|
||||
return cache_file
|
||||
endf
|
||||
|
||||
|
||||
let s:timestamps = {}
|
||||
|
||||
|
||||
function! s:SetTimestamp(cfile, type) "{{{3
|
||||
if !has_key(s:timestamps, a:cfile)
|
||||
let s:timestamps[a:cfile] = {}
|
||||
endif
|
||||
let s:timestamps[a:cfile].atime = getftime(a:cfile)
|
||||
let s:timestamps[a:cfile][a:type] = s:timestamps[a:cfile].atime
|
||||
endf
|
||||
|
||||
|
||||
function! s:PutValue(cfile, value) abort "{{{3
|
||||
let s:cache[a:cfile] = {'mtime': localtime(), 'data': a:value}
|
||||
endf
|
||||
|
||||
|
||||
function! s:GetValue(cfile, default) abort "{{{3
|
||||
return get(get(s:cache, a:cfile, {}), 'data', a:default)
|
||||
endf
|
||||
|
||||
|
||||
function! s:GetCacheTime(cfile) abort "{{{3
|
||||
let not_found = !has_key(s:cache, a:cfile)
|
||||
let cftime = not_found ? -1 : s:cache[a:cfile].mtime
|
||||
return cftime
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#cache#Save(cfile, value, ...) "{{{3
|
||||
TVarArg ['options', {}]
|
||||
let in_memory = get(options, 'in_memory', 0)
|
||||
if in_memory
|
||||
" TLogVAR in_memory, a:cfile, localtime()
|
||||
call s:PutValue(a:cfile, a:value)
|
||||
elseif !empty(a:cfile)
|
||||
" TLogVAR a:value
|
||||
let cfile = a:cfile
|
||||
if g:tlib#cache#use_json && exists('*json_encode')
|
||||
try
|
||||
let value = json_encode(a:value)
|
||||
let cfile .= '.json'
|
||||
catch
|
||||
echoerr v:exception
|
||||
let value = string(a:value)
|
||||
endtry
|
||||
else
|
||||
let value = string(a:value)
|
||||
endif
|
||||
Tlibtrace 'tlib', cfile, value
|
||||
call writefile([value], cfile, 'b')
|
||||
call s:SetTimestamp(a:cfile, 'write')
|
||||
endif
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#cache#MTime(cfile) "{{{3
|
||||
let mtime = {'mtime': getftime(a:cfile)}
|
||||
let mtime = extend(mtime, get(s:timestamps, a:cfile, {}))
|
||||
return mtime
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#cache#Get(cfile, ...) "{{{3
|
||||
TVarArg ['default', {}], ['options', {}]
|
||||
let in_memory = get(options, 'in_memory', 0)
|
||||
if in_memory
|
||||
" TLogVAR in_memory, a:cfile
|
||||
return s:GetValue(a:cfile, default)
|
||||
else
|
||||
call tlib#cache#MaybePurge()
|
||||
if !empty(a:cfile)
|
||||
let jsonfile = a:cfile .'.json'
|
||||
let use_json = g:tlib#cache#use_json && exists('*json_decode') && exists('v:none') && filereadable(jsonfile)
|
||||
if use_json
|
||||
let use_json = 1
|
||||
let cfile = jsonfile
|
||||
else
|
||||
let cfile = a:cfile
|
||||
endif
|
||||
let mt = s:GetCacheTime(cfile)
|
||||
let ft = getftime(cfile)
|
||||
if mt != -1 && mt >= ft
|
||||
return s:GetValue(cfile, default)
|
||||
elseif ft != -1
|
||||
call s:SetTimestamp(cfile, 'read')
|
||||
let val = join(readfile(cfile, 'b'), '\n')
|
||||
try
|
||||
if use_json
|
||||
" NOTE: Copy result of json_decode() in order to
|
||||
" avoid "E741: value is locked" error in vim8.
|
||||
let value = json_decode(val)
|
||||
if value is v:none
|
||||
let value = default
|
||||
else
|
||||
let value = copy(value)
|
||||
endif
|
||||
else
|
||||
let value = eval(val)
|
||||
endif
|
||||
call s:PutValue(cfile, value)
|
||||
return value
|
||||
catch
|
||||
echohl ErrorMsg
|
||||
echom v:exception
|
||||
echom 'tlib#cache#Get: Invalid value in:' cfile
|
||||
echom 'Value:' string(val)
|
||||
echom 'Please review the file and delete it if necessary'
|
||||
echom 'Will use default value:' string(default)
|
||||
echohl NONE
|
||||
if g:tlib#debug
|
||||
let @* = string(val)
|
||||
endif
|
||||
" call s:PutValue(cfile, default)
|
||||
return default
|
||||
endtry
|
||||
endif
|
||||
endif
|
||||
return default
|
||||
endif
|
||||
endf
|
||||
|
||||
|
||||
" :display: tlib#cache#Value(cfile, generator, ftime, ?generator_args=[], ?options={})
|
||||
" Get a cached value from cfile. If it is outdated (compared to ftime)
|
||||
" or does not exist, create it calling a generator function.
|
||||
function! tlib#cache#Value(cfile, generator, ftime, ...) "{{{3
|
||||
TVarArg ['args', []], ['options', {}]
|
||||
let in_memory = get(options, 'in_memory', 0)
|
||||
if in_memory
|
||||
let cftime = s:GetCacheTime(a:cfile)
|
||||
else
|
||||
let cftime = getftime(a:cfile)
|
||||
endif
|
||||
let ftime = a:ftime
|
||||
" TLogVAR in_memory, cftime
|
||||
if cftime == -1 || ftime == -1 || (ftime != 0 && cftime < ftime)
|
||||
" TLogVAR a:generator, args
|
||||
let val = call(a:generator, args)
|
||||
" TLogVAR val
|
||||
let cval = {'val': val}
|
||||
" TLogVAR cval
|
||||
call tlib#cache#Save(a:cfile, cval, options)
|
||||
return val
|
||||
else
|
||||
let val = tlib#cache#Get(a:cfile, {}, options)
|
||||
if !has_key(val, 'val')
|
||||
throw 'tlib#cache#Value: Internal error: '. a:cfile
|
||||
else
|
||||
return val.val
|
||||
endif
|
||||
endif
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#cache#ValueFromName(type, name, ...) abort "{{{3
|
||||
let cfile = tlib#cache#Filename(a:type, tlib#url#Encode(a:name), 1)
|
||||
return call(function('tlib#cache#Value'), [cfile] + a:000)
|
||||
endf
|
||||
|
||||
|
||||
" Call |tlib#cache#Purge()| if the last purge was done before
|
||||
" |g:tlib#cache#purge_every_days|.
|
||||
function! tlib#cache#MaybePurge() "{{{3
|
||||
if g:tlib#cache#purge_every_days < 0
|
||||
return
|
||||
endif
|
||||
let dir = tlib#cache#Dir('g')
|
||||
let last_purge = tlib#file#Join([dir, '.last_purge'])
|
||||
let last_purge_exists = filereadable(last_purge)
|
||||
if last_purge_exists
|
||||
let threshold = localtime() - g:tlib#cache#purge_every_days * g:tlib#date#dayshift
|
||||
let should_purge = getftime(last_purge) < threshold
|
||||
else
|
||||
let should_purge = 0 " should ignore empty dirs, like the tmru one: !empty(glob(tlib#file#Join([dir, '**'])))
|
||||
endif
|
||||
if should_purge
|
||||
if last_purge_exists
|
||||
let yn = 'y'
|
||||
else
|
||||
let txt = "TLib: The cache directory '". dir ."' should be purged of old files.\nDelete files older than ". g:tlib#cache#purge_days ." days now?"
|
||||
let yn = tlib#input#Dialog(txt, ['yes', 'no'], 'no')
|
||||
endif
|
||||
if yn =~ '^y\%[es]$'
|
||||
call tlib#cache#Purge()
|
||||
else
|
||||
let g:tlib#cache#purge_every_days = -1
|
||||
if !last_purge_exists
|
||||
call s:PurgeTimestamp(dir)
|
||||
endif
|
||||
echohl WarningMsg
|
||||
echom "TLib: Please run :call tlib#cache#Purge() to clean up ". dir
|
||||
echohl NONE
|
||||
endif
|
||||
elseif !last_purge_exists
|
||||
call s:PurgeTimestamp(dir)
|
||||
endif
|
||||
endf
|
||||
|
||||
|
||||
" Delete old files.
|
||||
function! tlib#cache#Purge() "{{{3
|
||||
let threshold = localtime() - g:tlib#cache#purge_days * g:tlib#date#dayshift
|
||||
let dir = tlib#cache#Dir('g')
|
||||
if g:tlib#cache#verbosity >= 1
|
||||
echohl WarningMsg
|
||||
echom "TLib: Delete files older than ". g:tlib#cache#purge_days ." days from ". dir
|
||||
echohl NONE
|
||||
endif
|
||||
let files = tlib#cache#ListFilesInCache()
|
||||
let deldir = []
|
||||
let newer = []
|
||||
let msg = []
|
||||
let more = &more
|
||||
set nomore
|
||||
try
|
||||
for file in files
|
||||
if isdirectory(file)
|
||||
if empty(filter(copy(newer), 'tlib#string#Strcharpart(v:val, 0, len(file)) ==# file'))
|
||||
call add(deldir, file)
|
||||
endif
|
||||
else
|
||||
if getftime(file) < threshold
|
||||
call s:Delete(msg, file, '')
|
||||
else
|
||||
call add(newer, file)
|
||||
endif
|
||||
endif
|
||||
endfor
|
||||
finally
|
||||
let &more = more
|
||||
endtry
|
||||
if !empty(msg) && g:tlib#cache#verbosity >= 1
|
||||
echo join(msg, "\n")
|
||||
endif
|
||||
if !empty(deldir)
|
||||
let deldir = filter(reverse(sort(deldir)), 's:Delete(msg, v:val, "d")')
|
||||
if !empty(deldir)
|
||||
if &shell =~ 'sh\(\.exe\)\?$'
|
||||
let scriptfile = 'deldir.sh'
|
||||
let rmdir = 'rm -rf %s'
|
||||
else
|
||||
let scriptfile = 'deldir.bat'
|
||||
let rmdir = 'rmdir /S /Q %s'
|
||||
endif
|
||||
let enc = g:tlib#cache#script_encoding
|
||||
if has('multi_byte') && enc != &enc
|
||||
call map(deldir, 'iconv(v:val, &enc, enc)')
|
||||
endif
|
||||
let scriptfile = tlib#file#Join([dir, scriptfile])
|
||||
if filereadable(scriptfile)
|
||||
let script = readfile(scriptfile)
|
||||
else
|
||||
let script = []
|
||||
endif
|
||||
let script += map(copy(deldir), 'printf(rmdir, shellescape(v:val, 1))')
|
||||
let script = tlib#list#Uniq(script)
|
||||
call writefile(script, scriptfile)
|
||||
call inputsave()
|
||||
if g:tlib#cache#run_script == 0
|
||||
if g:tlib#cache#verbosity >= 1
|
||||
echohl WarningMsg
|
||||
if g:tlib#cache#verbosity >= 2
|
||||
echom "TLib: Purged cache. Need to run script to delete directories"
|
||||
endif
|
||||
echom "TLib: Please review and execute: ". scriptfile
|
||||
echohl NONE
|
||||
endif
|
||||
else
|
||||
try
|
||||
let yn = g:tlib#cache#run_script == 2 ? 'y' : tlib#input#Dialog("TLib: About to delete directories by means of a shell script.\nDirectory removal script: ". scriptfile ."\nRun script to delete directories now?", ['yes', 'no', 'edit'], 'no')
|
||||
if yn =~ '^y\%[es]$'
|
||||
exec 'silent cd '. fnameescape(dir)
|
||||
exec '! ' &shell shellescape(scriptfile, 1)
|
||||
exec 'silent cd -'
|
||||
call delete(scriptfile)
|
||||
elseif yn =~ '^e\%[dit]$'
|
||||
exec 'edit '. fnameescape(scriptfile)
|
||||
endif
|
||||
finally
|
||||
call inputrestore()
|
||||
endtry
|
||||
endif
|
||||
endif
|
||||
endif
|
||||
call s:PurgeTimestamp(dir)
|
||||
endf
|
||||
|
||||
|
||||
function! s:Delete(msg, file, flags) abort "{{{3
|
||||
let rv = delete(a:file, a:flags)
|
||||
if !rv && g:tlib#cache#verbosity >= 2
|
||||
call add(a:msg, "TLib#cache: Delete ". file)
|
||||
endif
|
||||
return rv
|
||||
endf
|
||||
|
||||
|
||||
function! s:PurgeTimestamp(dir) "{{{3
|
||||
let last_purge = tlib#file#Join([a:dir, '.last_purge'])
|
||||
" TLogVAR last_purge
|
||||
call writefile([" "], last_purge)
|
||||
endf
|
||||
|
||||
function! tlib#cache#ListFilesInCache(...) "{{{3
|
||||
let dir = a:0 >= 1 ? a:1 : tlib#cache#Dir('g')
|
||||
if v:version > 702 || (v:version == 702 && has('patch51'))
|
||||
let filess = glob(tlib#file#Join([dir, '**']), 1)
|
||||
else
|
||||
let filess = glob(tlib#file#Join([dir, '**']))
|
||||
endif
|
||||
let files = reverse(split(filess, '\n'))
|
||||
let pos0 = len(tlib#dir#CanonicName(dir))
|
||||
call filter(files, 's:ShouldPurge(tlib#string#Strcharpart(v:val, pos0))')
|
||||
return files
|
||||
endf
|
||||
|
||||
|
||||
function! s:ShouldPurge(partial_filename) "{{{3
|
||||
" TLogVAR a:partial_filename
|
||||
for rx in g:tlib#cache#dont_purge
|
||||
if a:partial_filename =~ rx
|
||||
" TLogVAR a:partial_filename, rx
|
||||
return 0
|
||||
endif
|
||||
endfor
|
||||
return 1
|
||||
endf
|
||||
|
||||
@ -1,59 +0,0 @@
|
||||
" @Author: Tom Link (micathom AT gmail com?subject=[vim])
|
||||
" @Website: http://www.vim.org/account/profile.php?user_id=4037
|
||||
" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
|
||||
" @Revision: 38
|
||||
|
||||
|
||||
" :def: function! tlib#char#Get(?timeout=0)
|
||||
" Get a character.
|
||||
"
|
||||
" EXAMPLES: >
|
||||
" echo tlib#char#Get()
|
||||
" echo tlib#char#Get(5)
|
||||
function! tlib#char#Get(...) "{{{3
|
||||
TVarArg ['timeout', 0], ['resolution', 0], ['getmod', 0]
|
||||
let char = -1
|
||||
let mode = 0
|
||||
if timeout == 0 || !has('reltime')
|
||||
let char = getchar()
|
||||
else
|
||||
let char = tlib#char#GetWithTimeout(timeout, resolution)
|
||||
endif
|
||||
if getmod
|
||||
if char != -1
|
||||
let mode = getcharmod()
|
||||
endif
|
||||
return [char, mode]
|
||||
else
|
||||
return char
|
||||
endif
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#char#IsAvailable() "{{{3
|
||||
let ch = getchar(1)
|
||||
return type(ch) == 0 && ch != 0
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#char#GetWithTimeout(timeout, ...) "{{{3
|
||||
TVarArg ['resolution', 2]
|
||||
" TLogVAR a:timeout, resolution
|
||||
let start = tlib#time#MSecs()
|
||||
while 1
|
||||
let c = getchar(0)
|
||||
if type(c) != 0 || c != 0
|
||||
return c
|
||||
else
|
||||
let now = tlib#time#MSecs()
|
||||
let diff = tlib#time#DiffMSecs(now, start, resolution)
|
||||
" TLogVAR diff
|
||||
if diff > a:timeout
|
||||
return -1
|
||||
endif
|
||||
endif
|
||||
endwh
|
||||
return -1
|
||||
endf
|
||||
|
||||
|
||||
@ -1,117 +0,0 @@
|
||||
" @Author: Tom Link (micathom AT gmail com?subject=[vim])
|
||||
" @Website: http://www.vim.org/account/profile.php?user_id=4037
|
||||
" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
|
||||
" @Revision: 58
|
||||
|
||||
|
||||
let g:tlib#cmd#last_output = []
|
||||
|
||||
|
||||
function! tlib#cmd#OutputAsList(command) "{{{3
|
||||
" TLogVAR a:command
|
||||
if exists('s:redir_lines')
|
||||
redir END
|
||||
let cache = s:redir_lines
|
||||
endif
|
||||
let s:redir_lines = ''
|
||||
redir =>> s:redir_lines
|
||||
silent! exec a:command
|
||||
redir END
|
||||
let g:tlib#cmd#last_output = split(s:redir_lines, '\n')
|
||||
unlet s:redir_lines
|
||||
if exists('cache')
|
||||
let s:redir_lines = cache
|
||||
redir =>> s:redir_lines
|
||||
endif
|
||||
return g:tlib#cmd#last_output
|
||||
endf
|
||||
|
||||
|
||||
" See |:TBrowseOutput|.
|
||||
function! tlib#cmd#BrowseOutput(command) "{{{3
|
||||
call tlib#cmd#BrowseOutputWithCallback("tlib#cmd#DefaultBrowseOutput", a:command)
|
||||
endf
|
||||
|
||||
" :def: function! tlib#cmd#BrowseOutputWithCallback(callback, command)
|
||||
" Execute COMMAND and present its output in a |tlib#input#List()|;
|
||||
" when a line is selected, execute the function named as the CALLBACK
|
||||
" and pass in that line as an argument.
|
||||
"
|
||||
" The CALLBACK function gives you an opportunity to massage the COMMAND output
|
||||
" and possibly act on it in a meaningful way. For example, if COMMAND listed
|
||||
" all URIs found in the current buffer, CALLBACK could validate and then open
|
||||
" the selected URI in the system's default browser.
|
||||
"
|
||||
" This function is meant to be a tool to help compose the implementations of
|
||||
" powerful commands that use |tlib#input#List()| as a common interface. See
|
||||
" |TBrowseScriptnames| as an example.
|
||||
"
|
||||
" EXAMPLES: >
|
||||
" call tlib#cmd#BrowseOutputWithCallback('tlib#cmd#ParseScriptname', 'scriptnames')
|
||||
function! tlib#cmd#BrowseOutputWithCallback(callback, command) "{{{3
|
||||
let list = tlib#cmd#OutputAsList(a:command)
|
||||
let cmds = tlib#input#List('m', 'Output of: '. a:command, list)
|
||||
if !empty(cmds)
|
||||
for cmd in cmds
|
||||
let Callback = function(a:callback)
|
||||
call call(Callback, [cmd])
|
||||
endfor
|
||||
endif
|
||||
endf
|
||||
|
||||
function! tlib#cmd#DefaultBrowseOutput(cmd) "{{{3
|
||||
call feedkeys(':'. a:cmd)
|
||||
endf
|
||||
|
||||
function! tlib#cmd#ParseScriptname(line) "{{{3
|
||||
" let parsedValue = substitute(a:line, '^.\{-}\/', '/', '')
|
||||
let parsedValue = matchstr(a:line, '^\s*\d\+:\s*\zs.*$')
|
||||
exe 'drop '. fnameescape(parsedValue)
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#cmd#TBrowseScriptnames() abort "{{{3
|
||||
call tlib#cmd#BrowseOutputWithCallback("tlib#cmd#ParseScriptname", "scriptnames")
|
||||
endf
|
||||
|
||||
|
||||
" :def: function! tlib#cmd#UseVertical(?rx='')
|
||||
" Look at the history whether the command was called with vertical. If
|
||||
" an rx is provided check first if the last entry in the history matches
|
||||
" this rx.
|
||||
function! tlib#cmd#UseVertical(...) "{{{3
|
||||
TVarArg ['rx']
|
||||
let h0 = histget(':')
|
||||
let rx0 = '\C\<vert\%[ical]\>\s\+'
|
||||
if !empty(rx)
|
||||
let rx0 .= '.\{-}'.rx
|
||||
endif
|
||||
" TLogVAR h0, rx0
|
||||
return h0 =~ rx0
|
||||
endf
|
||||
|
||||
|
||||
" Print the time in seconds or milliseconds (if your version of VIM
|
||||
" has |+reltime|) a command takes.
|
||||
function! tlib#cmd#Time(cmd) "{{{3
|
||||
if has('reltime')
|
||||
let start = tlib#time#Now()
|
||||
exec a:cmd
|
||||
let end = tlib#time#Now()
|
||||
let diff = string(tlib#time#Diff(end, start)) .'ms'
|
||||
else
|
||||
let start = localtime()
|
||||
exec a:cmd
|
||||
let diff = (localtime() - start) .'s'
|
||||
endif
|
||||
echom 'Time: '. diff .': '. a:cmd
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#cmd#Capture(cmd) "{{{3
|
||||
redir => s
|
||||
silent exec a:cmd
|
||||
redir END
|
||||
return s
|
||||
endf
|
||||
|
||||
@ -1,26 +0,0 @@
|
||||
" @Author: Tom Link (mailto:micathom AT gmail com?subject=[vim])
|
||||
" @Website: http://www.vim.org/account/profile.php?user_id=4037
|
||||
" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
|
||||
" @Revision: 25
|
||||
|
||||
|
||||
" function! tlib#comments#Comments(?rx='')
|
||||
function! tlib#comments#Comments(...)
|
||||
TVarArg ['rx', '']
|
||||
let comments = {}
|
||||
let co = &comments
|
||||
while !empty(co)
|
||||
" TLogVAR co
|
||||
let [m_0, m_key, m_val, m_val1, co0, co; rest] = matchlist(co, '^\([^:]*\):\(\(\\.\|[^,]*\)\+\)\(,\(.*\)$\|$\)')
|
||||
" TLogVAR m_key, m_val, co
|
||||
if empty(m_key)
|
||||
let m_key = ':'
|
||||
endif
|
||||
if empty(rx) || m_key =~ rx
|
||||
let comments[m_key] = m_val
|
||||
endif
|
||||
endwh
|
||||
return comments
|
||||
endf
|
||||
|
||||
|
||||
@ -1,195 +0,0 @@
|
||||
" date.vim
|
||||
" @Author: Tom Link (mailto:micathom AT gmail com?subject=[vim])
|
||||
" @Website: http://www.vim.org/account/profile.php?user_id=4037
|
||||
" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
|
||||
" @Created: 2010-03-25.
|
||||
" @Last Change: 2017-09-06.
|
||||
" @Revision: 44.0.34
|
||||
|
||||
|
||||
if !exists('g:tlib#date#ShortDatePrefix') | let g:tlib#date#ShortDatePrefix = '20' | endif "{{{2
|
||||
if !exists('g:tlib#date#TimeZoneShift') | let g:tlib#date#TimeZoneShift = 0 | endif "{{{2
|
||||
|
||||
let g:tlib#date#dayshift = 60 * 60 * 24
|
||||
" let g:tlib#date#date_rx = '\<\(\d\{4}\)-\(\d\d\)-\(\d\d\)\%(\s\+\(\(\d\d\):\(\d\d\)\)\)\?\>'
|
||||
let g:tlib#date#date_rx = '\<\(\d\{4}\)-\(\d\d\)-\(\d\d\)\>'
|
||||
let g:tlib#date#date_format = '%Y-%m-%d'
|
||||
|
||||
|
||||
function! tlib#date#IsDate(text) abort "{{{3
|
||||
return a:text =~# '^'. g:tlib#date#date_rx .'$' &&
|
||||
\ !empty(tlib#date#Parse(a:text, 0, 1))
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#date#Format(...) abort "{{{3
|
||||
let secs1970 = a:0 >= 1 ? a:1 : localtime()
|
||||
return strftime(g:tlib#date#date_format, secs1970)
|
||||
endf
|
||||
|
||||
|
||||
" :display: tlib#date#DiffInDays(date1, ?date2=localtime(), ?allow_zero=0)
|
||||
function! tlib#date#DiffInDays(date, ...)
|
||||
let allow_zero = a:0 >= 2 ? a:2 : 0
|
||||
let s0 = tlib#date#SecondsSince1970(a:date, 0, allow_zero)
|
||||
let s1 = a:0 >= 1 ? tlib#date#SecondsSince1970(a:1, 0, allow_zero) : localtime()
|
||||
let dd = (s0 - s1) / g:tlib#date#dayshift
|
||||
" TLogVAR dd
|
||||
return dd
|
||||
endf
|
||||
|
||||
|
||||
" :display: tlib#date#Parse(date, ?allow_zero=0, ?silent=0) "{{{3
|
||||
function! tlib#date#Parse(date, ...) "{{{3
|
||||
let min = a:0 >= 1 && a:1 ? 0 : 1
|
||||
let silent = a:0 >= 2 ? a:2 : 0
|
||||
Tlibtype 'tlib', a:date, min, silent
|
||||
let m = matchlist(a:date, '^\(\d\{2}\|\d\{4}\)-\(\d\{1,2}\)-\(\d\{1,2}\)$')
|
||||
Tlibtype 'tlib', m
|
||||
let year = ''
|
||||
let month = ''
|
||||
let days = ''
|
||||
if !empty(m)
|
||||
let year = m[1]
|
||||
let month = m[2]
|
||||
let days = m[3]
|
||||
else
|
||||
let m = matchlist(a:date, '^\(\d\+\)/\(\d\{1,2}\)/\(\d\{1,2}\)$')
|
||||
if !empty(m)
|
||||
let year = m[1]
|
||||
let month = m[3]
|
||||
let days = m[2]
|
||||
else
|
||||
let m = matchlist(a:date, '^\(\d\{1,2}\)\.\s*\(\d\{1,2}\)\.\s*\(\d\d\{2}\|\d\{4}\)$')
|
||||
if !empty(m)
|
||||
let year = m[3]
|
||||
let month = m[2]
|
||||
let days = m[1]
|
||||
endif
|
||||
endif
|
||||
endif
|
||||
Tlibtype 'tlib', year, month, days
|
||||
if empty(m) || year == '' || month == '' || days == '' ||
|
||||
\ month < min || month > 12 || days < min || days > 31
|
||||
if !silent
|
||||
echoerr 'TLib: Invalid date: '. a:date
|
||||
endif
|
||||
return []
|
||||
endif
|
||||
if strlen(year) == 2
|
||||
let year = g:tlib#date#ShortDatePrefix . year
|
||||
Tlibtype 'tlib', year
|
||||
endif
|
||||
return [0 + year, 0 + month, 0 + days]
|
||||
endf
|
||||
|
||||
|
||||
" tlib#date#SecondsSince1970(date, ?daysshift=0, ?allow_zero=0)
|
||||
function! tlib#date#SecondsSince1970(date, ...) "{{{3
|
||||
let allow_zero = a:0 >= 2 ? a:2 : 0
|
||||
" TLogVAR a:date, allow_zero
|
||||
let date = tlib#date#Parse(a:date, allow_zero)
|
||||
if empty(date)
|
||||
return 0
|
||||
endif
|
||||
let [year, month, days] = date
|
||||
if a:0 >= 1 && a:1 > 0
|
||||
let days = days + a:1
|
||||
end
|
||||
let days_passed = days
|
||||
let i = 1970
|
||||
while i < year
|
||||
let days_passed = days_passed + 365
|
||||
if i % 4 == 0 || i == 2000
|
||||
let days_passed = days_passed + 1
|
||||
endif
|
||||
let i = i + 1
|
||||
endwh
|
||||
let i = 1
|
||||
while i < month
|
||||
if i == 1
|
||||
let days_passed = days_passed + 31
|
||||
elseif i == 2
|
||||
let days_passed = days_passed + 28
|
||||
if year % 4 == 0 || year == 2000
|
||||
let days_passed = days_passed + 1
|
||||
endif
|
||||
elseif i == 3
|
||||
let days_passed = days_passed + 31
|
||||
elseif i == 4
|
||||
let days_passed = days_passed + 30
|
||||
elseif i == 5
|
||||
let days_passed = days_passed + 31
|
||||
elseif i == 6
|
||||
let days_passed = days_passed + 30
|
||||
elseif i == 7
|
||||
let days_passed = days_passed + 31
|
||||
elseif i == 8
|
||||
let days_passed = days_passed + 31
|
||||
elseif i == 9
|
||||
let days_passed = days_passed + 30
|
||||
elseif i == 10
|
||||
let days_passed = days_passed + 31
|
||||
elseif i == 11
|
||||
let days_passed = days_passed + 30
|
||||
endif
|
||||
let i = i + 1
|
||||
endwh
|
||||
let seconds = (days_passed - 1) * 24 * 60 * 60
|
||||
let seconds = seconds + (strftime('%H') + g:tlib#date#TimeZoneShift) * 60 * 60
|
||||
let seconds = seconds + strftime('%M') * 60
|
||||
let seconds = seconds + strftime('%S')
|
||||
return seconds
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#date#Shift(date, shift) abort "{{{3
|
||||
let n = str2nr(matchstr(a:shift, '\d\+'))
|
||||
let ml = matchlist(a:date, g:tlib#date#date_rx)
|
||||
" TLogVAR a:date, a:shift, n, ml
|
||||
if a:shift =~ 'd$'
|
||||
let date = tlib#date#AddDays(a:date, n)
|
||||
elseif a:shift =~ 'b$'
|
||||
let n1 = n
|
||||
let secs = tlib#date#SecondsSince1970(a:date)
|
||||
while n1 > 0
|
||||
let n1 -= 1
|
||||
let secs += g:tlib#date#dayshift
|
||||
let uday = strftime('%u', secs)
|
||||
if uday == 6
|
||||
let secs += g:tlib#date#dayshift * 2
|
||||
elseif uday == 7
|
||||
let secs += g:tlib#date#dayshift
|
||||
endif
|
||||
endwh
|
||||
let date = tlib#date#Format(secs)
|
||||
elseif a:shift =~ 'w$'
|
||||
let date = tlib#date#AddDays(a:date, n * 7)
|
||||
elseif a:shift =~ 'm$'
|
||||
let d = str2nr(ml[3])
|
||||
let ms = str2nr(ml[2]) + n
|
||||
let m = (ms - 1) % 12 + 1
|
||||
let yr = str2nr(ml[1]) + (ms - 1) / 12
|
||||
let date = printf('%04d-%02d-%02d', yr, m, d)
|
||||
" TLogVAR d, ms, m, yr, date
|
||||
elseif a:shift =~ 'y$'
|
||||
let yr = str2nr(ml[1]) + n
|
||||
let date = substitute(a:date, '^\d\{4}', yr, '')
|
||||
else
|
||||
throw 'tlib#date#Shift: Unsupported arguments: '. string(a:shift)
|
||||
endif
|
||||
" if !empty(ml[4]) && date !~ '\s'. ml[4] .'$'
|
||||
" let date .= ' '. ml[4]
|
||||
" endif
|
||||
" TLogVAR date
|
||||
return date
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#date#AddDays(date, n) abort "{{{3
|
||||
let secs = tlib#date#SecondsSince1970(a:date) + g:tlib#date#dayshift * a:n
|
||||
" TLogVAR secs
|
||||
let date = tlib#date#Format(secs)
|
||||
return date
|
||||
endf
|
||||
|
||||
@ -1,45 +0,0 @@
|
||||
" @Author: Tom Link (mailto:micathom AT gmail com?subject=[vim])
|
||||
" @Website: https://github.com/tomtom
|
||||
" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
|
||||
" @Last Change: 2016-04-06
|
||||
" @Revision: 22
|
||||
|
||||
|
||||
" :display: tlib#dictionary#Rev(dict, ?opts = {}) abort "{{{3
|
||||
function! tlib#dictionary#Rev(dict, ...) abort "{{{3
|
||||
let opts = a:0 >= 1 ? a:1 : {}
|
||||
Tlibtype a:dict, 'dict', opts, 'dict'
|
||||
let rev = {}
|
||||
let use_string = get(opts, 'use_string', 0)
|
||||
let use_eval = get(opts, 'use_eval', 0)
|
||||
let values_as_list = get(opts, 'values_as_list', 0)
|
||||
for [m, f] in items(a:dict)
|
||||
if use_string
|
||||
let k = string(f)
|
||||
else
|
||||
let k = type(f) == 1 ? f : string(f)
|
||||
if k ==# ''
|
||||
let k = get(opts, 'empty', '')
|
||||
if empty(k)
|
||||
continue
|
||||
endif
|
||||
endif
|
||||
endif
|
||||
if use_eval
|
||||
let v = eval(m)
|
||||
else
|
||||
let v = m
|
||||
endif
|
||||
if values_as_list
|
||||
if has_key(rev, k)
|
||||
call add(rev[k], v)
|
||||
else
|
||||
let rev[k] = [v]
|
||||
endif
|
||||
else
|
||||
let rev[k] = v
|
||||
endif
|
||||
endfor
|
||||
return rev
|
||||
endf
|
||||
|
||||
@ -1,93 +0,0 @@
|
||||
" @Author: Tom Link (micathom AT gmail com?subject=[vim])
|
||||
" @Website: http://www.vim.org/account/profile.php?user_id=4037
|
||||
" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
|
||||
" @Revision: 43
|
||||
|
||||
" TLet g:tlib#dir#sep = '/'
|
||||
TLet g:tlib#dir#sep = exists('+shellslash') && !&shellslash ? '\' : '/'
|
||||
|
||||
|
||||
let s:dir_stack = []
|
||||
|
||||
" EXAMPLES: >
|
||||
" tlib#dir#CanonicName('foo/bar')
|
||||
" => 'foo/bar/'
|
||||
function! tlib#dir#CanonicName(dirname) "{{{3
|
||||
let dirname = tlib#file#Canonic(a:dirname)
|
||||
if dirname !~ '[/\\]$'
|
||||
return dirname . g:tlib#dir#sep
|
||||
endif
|
||||
return dirname
|
||||
endf
|
||||
|
||||
|
||||
" EXAMPLES: >
|
||||
" tlib#dir#NativeName('foo/bar/')
|
||||
" On Windows:
|
||||
" => 'foo\bar\'
|
||||
" On Linux:
|
||||
" => 'foo/bar/'
|
||||
function! tlib#dir#NativeName(dirname) "{{{3
|
||||
let sep = tlib#rx#EscapeReplace(g:tlib#dir#sep)
|
||||
let dirname = substitute(a:dirname, '[\/]', sep, 'g')
|
||||
return dirname
|
||||
endf
|
||||
|
||||
|
||||
" EXAMPLES: >
|
||||
" tlib#dir#PlainName('foo/bar/')
|
||||
" => 'foo/bar'
|
||||
function! tlib#dir#PlainName(dirname) "{{{3
|
||||
let dirname = a:dirname
|
||||
while index(['/', '\'], dirname[-1 : -1]) != -1
|
||||
let dirname = dirname[0 : -2]
|
||||
endwh
|
||||
return dirname
|
||||
" return substitute(a:dirname, tlib#rx#Escape(g:tlib#dir#sep).'\+$', '', '')
|
||||
endf
|
||||
|
||||
|
||||
" Create a directory if it doesn't already exist.
|
||||
function! tlib#dir#Ensure(dir) "{{{3
|
||||
if !isdirectory(a:dir)
|
||||
let dir = tlib#dir#PlainName(a:dir)
|
||||
return mkdir(dir, 'p')
|
||||
endif
|
||||
return 1
|
||||
endf
|
||||
|
||||
|
||||
" Return the first directory in &rtp.
|
||||
function! tlib#dir#MyRuntime() "{{{3
|
||||
return get(split(&rtp, ','), 0)
|
||||
endf
|
||||
|
||||
|
||||
" :def: function! tlib#dir#CD(dir, ?locally=0) => CWD
|
||||
function! tlib#dir#CD(dir, ...) "{{{3
|
||||
TVarArg ['locally', haslocaldir()]
|
||||
let cmd = locally ? 'lcd! ' : 'cd! '
|
||||
" let cwd = getcwd()
|
||||
let cmd .= tlib#arg#Ex(a:dir)
|
||||
" TLogVAR a:dir, locally, cmd
|
||||
exec 'silent' cmd
|
||||
" return cwd
|
||||
return getcwd()
|
||||
endf
|
||||
|
||||
|
||||
" :def: function! tlib#dir#Push(dir, ?locally=0) => CWD
|
||||
function! tlib#dir#Push(dir, ...) "{{{3
|
||||
TVarArg ['locally', haslocaldir()]
|
||||
call add(s:dir_stack, [getcwd(), locally])
|
||||
return tlib#dir#CD(a:dir, locally)
|
||||
endf
|
||||
|
||||
|
||||
" :def: function! tlib#dir#Pop() => CWD
|
||||
function! tlib#dir#Pop() "{{{3
|
||||
let [dir, locally] = remove(s:dir_stack, -1)
|
||||
return tlib#dir#CD(dir, locally)
|
||||
endf
|
||||
|
||||
|
||||
@ -1,72 +0,0 @@
|
||||
" @Author: Tom Link (mailto:micathom AT gmail com?subject=[vim])
|
||||
" @Website: http://www.vim.org/account/profile.php?user_id=4037
|
||||
" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
|
||||
" @Revision: 56
|
||||
|
||||
|
||||
function! tlib#eval#FormatValue(value, ...) "{{{3
|
||||
TVarArg ['indent', 0]
|
||||
" TLogVAR a:value, indent
|
||||
let indent1 = indent + 1
|
||||
let indenti = repeat(' ', &sw)
|
||||
let type = type(a:value)
|
||||
let acc = []
|
||||
if type == 0 || type == 1 || type == 2
|
||||
" TLogDBG 'Use string() for type='. type
|
||||
call add(acc, string(a:value))
|
||||
elseif type == 3 "List
|
||||
" TLogDBG 'List'
|
||||
call add(acc, '[')
|
||||
for e in a:value
|
||||
call add(acc, printf('%s%s,', indenti, tlib#eval#FormatValue(e, indent1)))
|
||||
unlet e
|
||||
endfor
|
||||
call add(acc, ']')
|
||||
elseif type == 4 "Dictionary
|
||||
" TLogDBG 'Dictionary'
|
||||
call add(acc, '{')
|
||||
let indent1 = indent + 1
|
||||
for [k, v] in items(a:value)
|
||||
call add(acc, printf("%s%s: %s,", indenti, string(k), tlib#eval#FormatValue(v, indent1)))
|
||||
unlet k v
|
||||
endfor
|
||||
call add(acc, '}')
|
||||
else
|
||||
" TLogDBG 'Unknown type: '. string(a:value)
|
||||
call add(acc, string(a:value))
|
||||
endif
|
||||
if indent > 0
|
||||
let is = repeat(' ', indent * &sw)
|
||||
for i in range(1,len(acc) - 1)
|
||||
let acc[i] = is . acc[i]
|
||||
endfor
|
||||
endif
|
||||
return join(acc, "\n")
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#eval#Extend(a, b, ...) abort "{{{3
|
||||
let mode = a:0 >= 1 ? a:1 : 'force'
|
||||
if type(a:a) != type(a:b)
|
||||
throw 'tlib#eval#Extend: Incompatible types: a='. string(a:a) .' b='. string(a:b)
|
||||
elseif type(a:a) == 3 " list
|
||||
return extend(a:a, a:b, mode)
|
||||
elseif type(a:a) == 4 " dict
|
||||
for k in keys(a:b)
|
||||
if has_key(a:a, k)
|
||||
if mode == 'force'
|
||||
let a:a[k] = tlib#eval#Extend(copy(a:a[k]), a:b[k], mode)
|
||||
elseif mode == 'error'
|
||||
throw 'tlib#eval#Extend: Key already exists: '. k
|
||||
endif
|
||||
else
|
||||
let a:a[k] = a:b[k]
|
||||
endif
|
||||
unlet! k
|
||||
endfor
|
||||
return a:a
|
||||
else
|
||||
return a:b
|
||||
endif
|
||||
endf
|
||||
|
||||
@ -1,356 +0,0 @@
|
||||
" @Author: Tom Link (micathom AT gmail com?subject=[vim])
|
||||
" @Website: http://www.vim.org/account/profile.php?user_id=4037
|
||||
" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
|
||||
" @Revision: 225
|
||||
|
||||
|
||||
if !exists('g:tlib#file#drop')
|
||||
" If true, use |:drop| to edit loaded buffers (only available with GUI).
|
||||
let g:tlib#file#drop = has('gui') "{{{2
|
||||
endif
|
||||
|
||||
|
||||
if !exists('g:tlib#file#use_tabs')
|
||||
let g:tlib#file#use_tabs = 0 "{{{2
|
||||
endif
|
||||
|
||||
|
||||
if !exists('g:tlib#file#edit_cmds')
|
||||
let g:tlib#file#edit_cmds = g:tlib#file#use_tabs ? {'buffer': 'tab split | buffer', 'edit': 'tabedit'} : {} "{{{2
|
||||
endif
|
||||
|
||||
|
||||
if !exists('g:tlib#file#absolute_filename_rx')
|
||||
let g:tlib#file#absolute_filename_rx = '^\~\?[\/]' "{{{2
|
||||
endif
|
||||
|
||||
|
||||
if !exists('g:tlib#file#reject_rx')
|
||||
let g:tlib#file#reject_rx = '\%(^\|[\/]\)\%(tags\|Thumbs\.db\)$' "{{{2
|
||||
endif
|
||||
|
||||
|
||||
""" File related {{{1
|
||||
" For the following functions please see ../../test/tlib.vim for examples.
|
||||
|
||||
|
||||
" EXAMPLES: >
|
||||
" tlib#file#Split('foo/bar/filename.txt')
|
||||
" => ['foo', 'bar', 'filename.txt']
|
||||
function! tlib#file#Split(filename) abort "{{{3
|
||||
let prefix = matchstr(a:filename, '^\(\w\+:\)\?/\+')
|
||||
Tlibtrace 'tlib', prefix
|
||||
if !empty(prefix)
|
||||
let filename = a:filename[len(prefix) : -1]
|
||||
else
|
||||
let filename = a:filename
|
||||
endif
|
||||
let rv = split(filename, '[\/]')
|
||||
" let rv = split(filename, '[\/]', 1)
|
||||
if !empty(prefix)
|
||||
call insert(rv, prefix[0:-2])
|
||||
endif
|
||||
return rv
|
||||
endf
|
||||
|
||||
|
||||
" :display: tlib#file#Join(filename_parts, ?strip_slashes=1, ?maybe_absolute=0)
|
||||
" EXAMPLES: >
|
||||
" tlib#file#Join(['foo', 'bar', 'filename.txt'])
|
||||
" => 'foo/bar/filename.txt'
|
||||
function! tlib#file#Join(filename_parts, ...) abort "{{{3
|
||||
TVarArg ['strip_slashes', 1], 'maybe_absolute'
|
||||
Tlibtrace 'tlib', a:filename_parts, strip_slashes
|
||||
if maybe_absolute
|
||||
let filename_parts = []
|
||||
for part in a:filename_parts
|
||||
if part =~ g:tlib#file#absolute_filename_rx
|
||||
let filename_parts = []
|
||||
endif
|
||||
call add(filename_parts, part)
|
||||
endfor
|
||||
else
|
||||
let filename_parts = a:filename_parts
|
||||
endif
|
||||
if strip_slashes
|
||||
" let rx = tlib#rx#Escape(g:tlib#dir#sep) .'$'
|
||||
let rx = '[/\\]\+$'
|
||||
let parts = map(copy(filename_parts), 'substitute(v:val, rx, "", "")')
|
||||
Tlibtrace 'tlib', parts
|
||||
return join(parts, g:tlib#dir#sep)
|
||||
else
|
||||
return join(filename_parts, g:tlib#dir#sep)
|
||||
endif
|
||||
endf
|
||||
|
||||
|
||||
" EXAMPLES: >
|
||||
" tlib#file#Relative('foo/bar/filename.txt', 'foo')
|
||||
" => 'bar/filename.txt'
|
||||
function! tlib#file#Relative(filename, basedir) abort "{{{3
|
||||
Tlibtrace 'tlib', a:filename, a:basedir
|
||||
" TLogDBG getcwd()
|
||||
" TLogDBG expand('%:p')
|
||||
let b0 = tlib#file#Absolute(a:basedir)
|
||||
let b = tlib#file#Split(b0)
|
||||
Tlibtrace 'tlib', b
|
||||
let f0 = tlib#file#Absolute(a:filename)
|
||||
let fn = fnamemodify(f0, ':t')
|
||||
let fd = fnamemodify(f0, ':h')
|
||||
let f = tlib#file#Split(fd)
|
||||
Tlibtrace 'tlib', f0, fn, fd, f
|
||||
if f[0] != b[0]
|
||||
let rv = f0
|
||||
else
|
||||
while !empty(f) && !empty(b)
|
||||
if f[0] != b[0]
|
||||
break
|
||||
endif
|
||||
call remove(f, 0)
|
||||
call remove(b, 0)
|
||||
endwh
|
||||
Tlibtrace 'tlib', f, b
|
||||
let rv = tlib#file#Join(repeat(['..'], len(b)) + f + [fn])
|
||||
endif
|
||||
Tlibtrace 'tlib', rv
|
||||
return rv
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#file#IsAbsolute(filename) abort "{{{3
|
||||
return a:filename =~? '^\%(/\|\w\+:/\)'
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#file#Absolute(filename, ...) abort "{{{3
|
||||
if filereadable(a:filename)
|
||||
let filename = fnamemodify(a:filename, ':p')
|
||||
elseif a:filename =~# '^\(/\|[^\/]\+:\)'
|
||||
let filename = a:filename
|
||||
else
|
||||
let cwd = a:0 >= 1 ? a:1 : getcwd()
|
||||
let filename = tlib#file#Join([cwd, a:filename])
|
||||
endif
|
||||
let filename = substitute(filename, '\(^\|[\/]\)\zs\.[\/]', '', 'g')
|
||||
let filename = substitute(filename, '[\/]\zs[^\/]\+[\/]\.\.[\/]', '', 'g')
|
||||
return filename
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#file#Canonic(filename, ...) abort "{{{3
|
||||
TVarArg ['mode', '']
|
||||
if empty(mode)
|
||||
if a:filename =~# '^\\\\'
|
||||
let mode = 'windows'
|
||||
elseif a:filename =~# '^\(file\|ftp\|http\)s\?:'
|
||||
let mode = 'url'
|
||||
elseif (empty(mode) && g:tlib#sys#windows)
|
||||
let mode = 'windows'
|
||||
endif
|
||||
endif
|
||||
let filename = a:filename
|
||||
if mode ==# 'windows'
|
||||
let filename = substitute(filename, '/', '\\', 'g')
|
||||
else
|
||||
let filename = substitute(filename, '\\', '/', 'g')
|
||||
endif
|
||||
return filename
|
||||
endf
|
||||
|
||||
|
||||
function! s:SetScrollBind(world) abort "{{{3
|
||||
let sb = get(a:world, 'scrollbind', &scrollbind)
|
||||
if sb != &scrollbind
|
||||
let &scrollbind = sb
|
||||
endif
|
||||
endf
|
||||
|
||||
|
||||
" :def: function! tlib#file#With(fcmd, bcmd, files, ?world={}) abort
|
||||
function! tlib#file#With(fcmd, bcmd, files, ...) abort "{{{3
|
||||
Tlibtrace 'tlib', a:fcmd, a:bcmd, a:files
|
||||
let world = a:0 >= 1 ? a:1 : {}
|
||||
let unset_switchbuf = a:0 >= 2 ? a:2 : 0
|
||||
exec tlib#arg#Let([['world', {}]])
|
||||
call tlib#autocmdgroup#Init()
|
||||
augroup TLibFileRead
|
||||
autocmd!
|
||||
augroup END
|
||||
if unset_switchbuf
|
||||
let switchbuf = &switchbuf
|
||||
set switchbuf&
|
||||
endif
|
||||
try
|
||||
for f in a:files
|
||||
try
|
||||
let bn = bufnr('^'.f.'$')
|
||||
Tlibtrace 'tlib', f, bn
|
||||
let bufloaded = bufloaded(bn)
|
||||
let ok = 0
|
||||
let s:bufread = ""
|
||||
if bn != -1 && buflisted(bn)
|
||||
if !empty(a:bcmd)
|
||||
let bcmd = a:bcmd .' '. bn
|
||||
Tlibtrace 'tlib', bcmd
|
||||
exec bcmd
|
||||
let ok = 1
|
||||
call s:SetScrollBind(world)
|
||||
endif
|
||||
else
|
||||
if filereadable(f)
|
||||
if !empty(a:fcmd)
|
||||
" TLogDBG a:fcmd .' '. tlib#arg#Ex(f)
|
||||
exec 'autocmd TLibFileRead BufRead' escape(f, '\ ') 'let s:bufread=expand("<afile>:p")'
|
||||
try
|
||||
let fcmd = a:fcmd .' '. tlib#arg#Ex(f)
|
||||
Tlibtrace 'tlib', fcmd
|
||||
exec fcmd
|
||||
finally
|
||||
exec 'autocmd! TLibFileRead BufRead'
|
||||
endtry
|
||||
let ok = 1
|
||||
call s:SetScrollBind(world)
|
||||
endif
|
||||
else
|
||||
echohl error
|
||||
echom 'File not readable: '. f
|
||||
echohl NONE
|
||||
endif
|
||||
endif
|
||||
Tlibtrace 'tlib', ok, bufloaded, &filetype
|
||||
if empty(s:bufread) && ok && !bufloaded && empty(&filetype)
|
||||
doautocmd BufRead
|
||||
endif
|
||||
catch /^Vim\%((\a\+)\)\=:E325/
|
||||
echohl ErrorMsg
|
||||
echom v:exception
|
||||
echohl NONE
|
||||
endtry
|
||||
endfor
|
||||
finally
|
||||
augroup! TLibFileRead
|
||||
if unset_switchbuf
|
||||
let &switchbuf = switchbuf
|
||||
endif
|
||||
unlet! s:bufread
|
||||
endtry
|
||||
" TLogDBG "done"
|
||||
endf
|
||||
|
||||
|
||||
" Return 0 if the file isn't readable/doesn't exist.
|
||||
" Otherwise return 1.
|
||||
function! tlib#file#Edit(fileid) abort "{{{3
|
||||
if type(a:fileid) == 0
|
||||
let bn = a:fileid
|
||||
let filename = fnamemodify(bufname(bn), ':p')
|
||||
else
|
||||
let filename = fnamemodify(a:fileid, ':p')
|
||||
let bn = bufnr(filename)
|
||||
endif
|
||||
if filename == expand('%:p')
|
||||
return 1
|
||||
else
|
||||
Tlibtrace 'tlib', a:fileid, bn, filename, g:tlib#file#drop, filereadable(filename), bufnr('%')
|
||||
if bn != -1 && buflisted(bn)
|
||||
if g:tlib#file#drop
|
||||
" echom "DBG" get(g:tlib#file#edit_cmds, 'drop', 'drop') fnameescape(filename)
|
||||
exec get(g:tlib#file#edit_cmds, 'drop', 'drop') fnameescape(filename)
|
||||
" echom "DBG" bufnr('%')
|
||||
else
|
||||
" echom "DBG" get(g:tlib#file#edit_cmds, 'buffer', 'buffer') bn
|
||||
exec get(g:tlib#file#edit_cmds, 'buffer', 'buffer') bn
|
||||
" echom "DBG" bufnr('%')
|
||||
endif
|
||||
return 1
|
||||
endif
|
||||
if !filereadable(filename) && exists('#TLibPrepareFile#User')
|
||||
exec 'doautocmd TLibPrepareFile User' filename
|
||||
endif
|
||||
if filereadable(filename)
|
||||
try
|
||||
" let file = tlib#arg#Ex(filename)
|
||||
" Tlibtrace 'tlib', file
|
||||
" echom "DBG" get(g:tlib#file#edit_cmds, 'edit', 'edit') fnameescape(filename)
|
||||
exec get(g:tlib#file#edit_cmds, 'edit', 'edit') fnameescape(filename)
|
||||
catch /E325/
|
||||
" swap file exists, let the user handle it
|
||||
catch
|
||||
echohl error
|
||||
echom v:exception
|
||||
echohl NONE
|
||||
endtry
|
||||
return 1
|
||||
else
|
||||
echom "TLIB: File not readable: " . filename
|
||||
if filename != a:fileid
|
||||
echom "TLIB: original filename: " . a:fileid
|
||||
endif
|
||||
endif
|
||||
endif
|
||||
return 0
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#file#FilterFiles(files, options) abort "{{{3
|
||||
Tlibtrace 'tlib', a:files, a:options, g:tlib#file#reject_rx
|
||||
if !get(a:options, 'all', 0)
|
||||
call filter(a:files, 'v:val !~# g:tlib#file#reject_rx')
|
||||
endif
|
||||
Tlibtrace 'tlib', a:files
|
||||
let type = get(a:options, 'type', 'fd')
|
||||
Tlibtrace 'tlib', type
|
||||
if type !~# 'd' || type !~# 'f'
|
||||
call filter(a:files, 'isdirectory(v:val) ? type =~# "d" : type =~# "f"')
|
||||
endif
|
||||
Tlibtrace 'tlib', a:files
|
||||
return a:files
|
||||
endf
|
||||
|
||||
|
||||
if v:version > 704 || (v:version == 704 && has('patch279'))
|
||||
|
||||
function! tlib#file#Glob(pattern, ...) abort "{{{3
|
||||
let all = a:0 >= 1 ? a:1 : 0
|
||||
let nosuf = a:0 >= 2 ? a:2 : 0
|
||||
return tlib#file#FilterFiles(glob(a:pattern, nosuf, 1), {'all': all})
|
||||
endf
|
||||
|
||||
function! tlib#file#Globpath(path, pattern, ...) abort "{{{3
|
||||
let all = a:0 >= 1 ? a:1 : 0
|
||||
let nosuf = a:0 >= 2 ? a:2 : 0
|
||||
return tlib#file#FilterFiles(globpath(a:path, a:pattern, nosuf, 1), {'all': all})
|
||||
endf
|
||||
|
||||
else
|
||||
|
||||
" :nodoc:
|
||||
function! tlib#file#Glob(pattern, ...) abort "{{{3
|
||||
let all = a:0 >= 1 ? a:1 : 0
|
||||
let nosuf = a:0 >= 2 ? a:2 : 0
|
||||
return tlib#file#FilterFiles(split(glob(a:pattern, nosuf), '\n'), {'all': all})
|
||||
endf
|
||||
|
||||
" :nodoc:
|
||||
function! tlib#file#Globpath(path, pattern, ...) abort "{{{3
|
||||
let all = a:0 >= 1 ? a:1 : 0
|
||||
let nosuf = a:0 >= 2 ? a:2 : 0
|
||||
return tlib#file#FilterFiles(split(globpath(a:path, a:pattern), '\n'), {'all': all})
|
||||
endf
|
||||
|
||||
endif
|
||||
|
||||
|
||||
let s:filereadable = {}
|
||||
|
||||
augroup TLib
|
||||
autocmd BufWritePost,FileWritePost,FocusLost * let s:filereadable = {}
|
||||
augroup end
|
||||
|
||||
function! tlib#file#Filereadable(filename) abort "{{{3
|
||||
if !has_key(s:filereadable, a:filename)
|
||||
let s:filereadable[a:filename] = filereadable(a:filename)
|
||||
endif
|
||||
return s:filereadable[a:filename]
|
||||
endf
|
||||
|
||||
@ -1,14 +0,0 @@
|
||||
" @Author: Tom Link (mailto:micathom AT gmail com?subject=[vim])
|
||||
" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
|
||||
" @Last Change: 2013-02-22.
|
||||
" @Revision: 3
|
||||
|
||||
|
||||
function! tlib#fixes#Winpos() "{{{3
|
||||
if has('gui_win32')
|
||||
return 'winpos '. getwinposx() .' '. getwinposy()
|
||||
else
|
||||
return ''
|
||||
endif
|
||||
endf
|
||||
|
||||
@ -1,38 +0,0 @@
|
||||
" @Author: Tom Link (mailto:micathom AT gmail com?subject=[vim])
|
||||
" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
|
||||
" @Last Change: 2013-10-16.
|
||||
" @Revision: 31
|
||||
|
||||
|
||||
function! tlib#grep#Do(cmd, rx, files) "{{{3
|
||||
" TLogVAR a:cmd, a:rx, a:files
|
||||
let files = join(map(copy(a:files), 'tlib#arg#Ex(v:val, "")'), ' ')
|
||||
let rx = '/'. escape(a:rx, '/') .'/j'
|
||||
" TLogVAR rx, files
|
||||
silent exec a:cmd rx files
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#grep#LocList(rx, files) "{{{3
|
||||
return tlib#grep#Do('noautocmd lvimgrep', a:rx, a:files)
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#grep#QuickFixList(rx, files) "{{{3
|
||||
return tlib#grep#Do('noautocmd vimgrep', a:rx, a:files)
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#grep#List(rx, files) "{{{3
|
||||
call setqflist([])
|
||||
call tlib#grep#Do('noautocmd vimgrepadd', a:rx, a:files)
|
||||
let qfl = getqflist()
|
||||
" TLogVAR qfl
|
||||
" try
|
||||
silent! colder
|
||||
" catch
|
||||
" call setqflist([], 'r')
|
||||
" endtry
|
||||
return qfl
|
||||
endf
|
||||
|
||||
@ -1,145 +0,0 @@
|
||||
" @Author: Tom Link (mailto:micathom AT gmail com?subject=[vim])
|
||||
" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
|
||||
" @Revision: 276
|
||||
|
||||
|
||||
if !exists('g:tlib#hash#use_crc32')
|
||||
let g:tlib#hash#use_crc32 = '' "{{{2
|
||||
endif
|
||||
|
||||
|
||||
if !exists('g:tlib#hash#use_adler32')
|
||||
let g:tlib#hash#use_adler32 = '' "{{{2
|
||||
endif
|
||||
|
||||
|
||||
function! tlib#hash#CRC32B(chars) "{{{3
|
||||
if !empty(g:tlib#hash#use_crc32)
|
||||
let use = g:tlib#hash#use_crc32
|
||||
elseif has('ruby')
|
||||
let use = 'ruby'
|
||||
else
|
||||
let use = 'vim'
|
||||
endif
|
||||
if exists('*tlib#hash#CRC32B_'. use)
|
||||
return tlib#hash#CRC32B_{use}(a:chars)
|
||||
else
|
||||
throw "Unknown version of tlib#hash#CRC32B: ". use
|
||||
endif
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#hash#CRC32B_ruby(chars) "{{{3
|
||||
if has('ruby')
|
||||
let rv = ''
|
||||
if !exists('s:loaded_ruby_zlib')
|
||||
ruby require 'zlib'
|
||||
let s:loaded_ruby_zlib = 1
|
||||
endif
|
||||
ruby VIM::command('let rv = "%08X"' % Zlib.crc32(VIM::evaluate("a:chars")))
|
||||
return rv
|
||||
else
|
||||
throw "tlib#hash#CRC32B_ruby not supported in this version of vim"
|
||||
endif
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#hash#CRC32B_vim(chars) "{{{3
|
||||
if !exists('s:crc_table')
|
||||
let cfile = tlib#persistent#Filename('tlib', 'crc_table', 1)
|
||||
let s:crc_table = tlib#persistent#Value(cfile, 'tlib#hash#CreateCrcTable', 0)
|
||||
endif
|
||||
let xFFFF_FFFF = repeat([1], 32)
|
||||
let crc = tlib#bitwise#XOR([0], xFFFF_FFFF, 'bits')
|
||||
for char in split(a:chars, '\zs')
|
||||
let octet = char2nr(char)
|
||||
let r1 = tlib#bitwise#ShiftRight(crc, 8)
|
||||
let i0 = tlib#bitwise#AND(crc, xFFFF_FFFF, 'bits')
|
||||
let i1 = tlib#bitwise#XOR(i0, octet, 'bits')
|
||||
let i2 = tlib#bitwise#Bits2Num(tlib#bitwise#AND(i1, 0xff, 'bits'))
|
||||
let r2 = s:crc_table[i2]
|
||||
let crc = tlib#bitwise#XOR(r1, r2, 'bits')
|
||||
endfor
|
||||
let crc = tlib#bitwise#XOR(crc, xFFFF_FFFF, 'bits')
|
||||
let rv = tlib#bitwise#Bits2Num(crc, 16)
|
||||
if len(rv) < 8
|
||||
let rv = repeat('0', 8 - len(rv)) . rv
|
||||
endif
|
||||
return rv
|
||||
endf
|
||||
|
||||
|
||||
" :nodoc:
|
||||
function! tlib#hash#CreateCrcTable() "{{{3
|
||||
let sum = 0.0
|
||||
for exponent in [0, 1, 2, 4, 5, 7, 8, 10, 11, 12, 16, 22, 23, 26, 32]
|
||||
let exp = tlib#bitwise#Bits2Num(repeat([0], 32 - exponent) + [1], 10.0)
|
||||
let sum += exp
|
||||
endfor
|
||||
let divisor = tlib#bitwise#Num2Bits(sum)
|
||||
let crc_table = []
|
||||
for octet in range(256)
|
||||
let remainder = tlib#bitwise#Num2Bits(octet)
|
||||
for i in range(8)
|
||||
if get(remainder, i) != 0
|
||||
let remainder = tlib#bitwise#XOR(remainder, tlib#bitwise#ShiftLeft(divisor, i), "bits")
|
||||
endif
|
||||
endfor
|
||||
let remainder = tlib#bitwise#ShiftRight(remainder, 8)
|
||||
call add(crc_table, remainder)
|
||||
endfor
|
||||
return crc_table
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#hash#Adler32(chars) "{{{3
|
||||
if !empty(g:tlib#hash#use_adler32)
|
||||
let use = g:tlib#hash#use_adler32
|
||||
elseif exists('*or')
|
||||
let use = 'vim'
|
||||
else
|
||||
let use = 'tlib'
|
||||
endif
|
||||
if exists('*tlib#hash#Adler32_'. use)
|
||||
return tlib#hash#Adler32_{use}(a:chars)
|
||||
else
|
||||
throw "Unknown version of tlib#hash#Adler32_: ". use
|
||||
endif
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#hash#Adler32_vim(chars) "{{{3
|
||||
if exists('*or')
|
||||
let mod_adler = 65521
|
||||
let a = 1
|
||||
let b = 0
|
||||
for index in range(len(a:chars))
|
||||
let c = char2nr(a:chars[index])
|
||||
let a = (a + c) % mod_adler
|
||||
let b = (b + a) % mod_adler
|
||||
endfor
|
||||
let bb = b * float2nr(pow(2, 16))
|
||||
let checksum = or(bb, a)
|
||||
" TLogVAR checksum, a, b, bb
|
||||
return printf("%08X", checksum)
|
||||
else
|
||||
throw "TLIB: Vim version doesn't support bitwise or()"
|
||||
endif
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#hash#Adler32_tlib(chars) "{{{3
|
||||
let mod_adler = 65521
|
||||
let a = 1
|
||||
let b = 0
|
||||
for index in range(len(a:chars))
|
||||
let c = char2nr(a:chars[index])
|
||||
let a = (a + c) % mod_adler
|
||||
let b = (b + a) % mod_adler
|
||||
endfor
|
||||
let bb = tlib#bitwise#ShiftLeft(tlib#bitwise#Num2Bits(b), 16)
|
||||
let checksum = tlib#bitwise#OR(bb, a, "bits")
|
||||
return printf('%08s', tlib#bitwise#Bits2Num(checksum, 16))
|
||||
endf
|
||||
|
||||
|
||||
@ -1,25 +0,0 @@
|
||||
" @Author: Tom Link (micathom AT gmail com?subject=[vim])
|
||||
" @Website: http://www.vim.org/account/profile.php?user_id=4037
|
||||
" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
|
||||
" @Revision: 11
|
||||
|
||||
|
||||
" :def: function! tlib#hook#Run(hook, ?dict={})
|
||||
" Execute dict[hook], w:{hook}, b:{hook}, or g:{hook} if existent.
|
||||
function! tlib#hook#Run(hook, ...) "{{{3
|
||||
TVarArg ['dict', {}]
|
||||
if has_key(dict, a:hook)
|
||||
let hook = dict[a:hook]
|
||||
else
|
||||
let hook = tlib#var#Get(a:hook, 'wbg')
|
||||
endif
|
||||
if empty(hook)
|
||||
return 0
|
||||
else
|
||||
let world = dict
|
||||
exec hook
|
||||
return 1
|
||||
endif
|
||||
endf
|
||||
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@ -1,194 +0,0 @@
|
||||
" list.vim
|
||||
" @Author: Tom Link (micathom AT gmail com?subject=[vim])
|
||||
" @Website: http://www.vim.org/account/profile.php?user_id=4037
|
||||
" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
|
||||
" @Created: 2007-06-30.
|
||||
" @Last Change: 2017-03-26.
|
||||
" @Revision: 71
|
||||
|
||||
|
||||
""" List related functions {{{1
|
||||
" For the following functions please see ../../test/tlib.vim for examples.
|
||||
|
||||
" :def: function! tlib#list#Inject(list, initial_value, funcref) abort
|
||||
" EXAMPLES: >
|
||||
" echo tlib#list#Inject([1,2,3], 0, function('Add')
|
||||
" => 6
|
||||
function! tlib#list#Inject(list, value, Function) abort "{{{3
|
||||
if empty(a:list)
|
||||
return a:value
|
||||
else
|
||||
let item = a:list[0]
|
||||
let rest = a:list[1:-1]
|
||||
let value = call(a:Function, [a:value, item])
|
||||
return tlib#list#Inject(rest, value, a:Function)
|
||||
endif
|
||||
endf
|
||||
|
||||
|
||||
" EXAMPLES: >
|
||||
" tlib#list#Compact([0,1,2,3,[], {}, ""])
|
||||
" => [1,2,3]
|
||||
function! tlib#list#Compact(list) abort "{{{3
|
||||
return filter(copy(a:list), '!empty(v:val)')
|
||||
endf
|
||||
|
||||
|
||||
" EXAMPLES: >
|
||||
" tlib#list#Flatten([0,[1,2,[3,""]]])
|
||||
" => [0,1,2,3,""]
|
||||
function! tlib#list#Flatten(list) abort "{{{3
|
||||
let acc = []
|
||||
for e in a:list
|
||||
if type(e) == 3
|
||||
let acc += tlib#list#Flatten(e)
|
||||
else
|
||||
call add(acc, e)
|
||||
endif
|
||||
unlet e
|
||||
endfor
|
||||
return acc
|
||||
endf
|
||||
|
||||
|
||||
" :def: function! tlib#list#FindAll(list, filter, ?process_expr="") abort
|
||||
" Basically the same as filter()
|
||||
"
|
||||
" EXAMPLES: >
|
||||
" tlib#list#FindAll([1,2,3], 'v:val >= 2')
|
||||
" => [2, 3]
|
||||
function! tlib#list#FindAll(list, filter, ...) abort "{{{3
|
||||
let rv = filter(copy(a:list), a:filter)
|
||||
if a:0 >= 1 && !empty(a:1)
|
||||
let rv = map(rv, a:1)
|
||||
endif
|
||||
return rv
|
||||
endf
|
||||
|
||||
|
||||
" :def: function! tlib#list#Find(list, filter, ?default="", ?process_expr="") abort
|
||||
"
|
||||
" EXAMPLES: >
|
||||
" tlib#list#Find([1,2,3], 'v:val >= 2')
|
||||
" => 2
|
||||
function! tlib#list#Find(list, filter, ...) abort "{{{3
|
||||
let default = a:0 >= 1 ? a:1 : ''
|
||||
let expr = a:0 >= 2 ? a:2 : ''
|
||||
return get(tlib#list#FindAll(a:list, a:filter, expr), 0, default)
|
||||
endf
|
||||
|
||||
|
||||
" EXAMPLES: >
|
||||
" tlib#list#Any([1,2,3], 'v:val >= 2')
|
||||
" => 1
|
||||
function! tlib#list#Any(list, expr) abort "{{{3
|
||||
return !empty(tlib#list#FindAll(a:list, a:expr))
|
||||
endf
|
||||
|
||||
|
||||
" EXAMPLES: >
|
||||
" tlib#list#All([1,2,3], 'v:val >= 2')
|
||||
" => 0
|
||||
function! tlib#list#All(list, expr) abort "{{{3
|
||||
return len(tlib#list#FindAll(a:list, a:expr)) == len(a:list)
|
||||
endf
|
||||
|
||||
|
||||
" EXAMPLES: >
|
||||
" tlib#list#Remove([1,2,1,2], 2)
|
||||
" => [1,1,2]
|
||||
function! tlib#list#Remove(list, element) abort "{{{3
|
||||
let idx = index(a:list, a:element)
|
||||
if idx != -1
|
||||
call remove(a:list, idx)
|
||||
endif
|
||||
return a:list
|
||||
endf
|
||||
|
||||
|
||||
" EXAMPLES: >
|
||||
" tlib#list#RemoveAll([1,2,1,2], 2)
|
||||
" => [1,1]
|
||||
function! tlib#list#RemoveAll(list, element) abort "{{{3
|
||||
call filter(a:list, 'v:val != a:element')
|
||||
return a:list
|
||||
endf
|
||||
|
||||
|
||||
" :def: function! tlib#list#Zip(lists, ?default='') abort
|
||||
" EXAMPLES: >
|
||||
" tlib#list#Zip([[1,2,3], [4,5,6]])
|
||||
" => [[1,4], [2,5], [3,6]]
|
||||
function! tlib#list#Zip(lists, ...) abort "{{{3
|
||||
TVarArg 'default'
|
||||
let lists = copy(a:lists)
|
||||
let max = 0
|
||||
for l in lists
|
||||
let ll = len(l)
|
||||
if ll > max
|
||||
let max = ll
|
||||
endif
|
||||
endfor
|
||||
" TLogVAR default, max
|
||||
return map(range(0, max - 1), 's:GetNthElement(v:val, lists, default)')
|
||||
endf
|
||||
|
||||
function! s:GetNthElement(n, lists, default) abort "{{{3
|
||||
" TLogVAR a:n, a:lists, a:default
|
||||
return map(copy(a:lists), 'get(v:val, a:n, a:default)')
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#list#Uniq(list, ...) abort "{{{3
|
||||
" TLogVAR a:list
|
||||
TVarArg ['get_value', ''], ['remove_empty', 0]
|
||||
if remove_empty
|
||||
call filter(a:list, 'type(v:val) == 0 || !empty(v:val)')
|
||||
endif
|
||||
" CREDITS: Based on syntastic#util#unique(list) by scrooloose
|
||||
let emptystring = 0
|
||||
let seen = {}
|
||||
let uniques = []
|
||||
if empty(get_value)
|
||||
for e in a:list
|
||||
if empty(e)
|
||||
if !emptystring
|
||||
let emptystring = 1
|
||||
call add(uniques, e)
|
||||
endif
|
||||
elseif !has_key(seen, e)
|
||||
let seen[e] = 1
|
||||
call add(uniques, e)
|
||||
endif
|
||||
unlet e
|
||||
endfor
|
||||
else
|
||||
for e in a:list
|
||||
let v = eval(printf(get_value, string(e)))
|
||||
if empty(v)
|
||||
if !emptystring
|
||||
let emptystring = 1
|
||||
call add(uniques, v)
|
||||
endif
|
||||
elseif !has_key(seen, v)
|
||||
let seen[v] = 1
|
||||
call add(uniques, v)
|
||||
endif
|
||||
unlet e v
|
||||
endfor
|
||||
endif
|
||||
return uniques
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#list#ToDictionary(list, default, ...) abort "{{{3
|
||||
TVarArg ['generator', '']
|
||||
let dict = {}
|
||||
for item in a:list
|
||||
if !empty(item)
|
||||
let dict[item] = empty(generator) ? a:default : call(generator, [item, a:default])
|
||||
endif
|
||||
endfor
|
||||
return dict
|
||||
endf
|
||||
|
||||
@ -1,13 +0,0 @@
|
||||
" @Author: Tom Link (mailto:micathom AT gmail com?subject=[vim])
|
||||
" @Website: http://www.vim.org/account/profile.php?user_id=4037
|
||||
" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
|
||||
" @Last Change: 2015-10-24
|
||||
" @Revision: 2
|
||||
|
||||
|
||||
function! tlib#loclist#Browse(...) abort "{{{3
|
||||
let list = getloclist(0)
|
||||
return call(function('tlib#qfl#QflList'), [list] + a:000)
|
||||
endf
|
||||
|
||||
|
||||
@ -1,23 +0,0 @@
|
||||
" map.vim
|
||||
" @Author: Tom Link (mailto:micathom AT gmail com?subject=[vim])
|
||||
" @Website: http://www.vim.org/account/profile.php?user_id=4037
|
||||
" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
|
||||
" @Created: 2009-08-23.
|
||||
" @Last Change: 2009-08-23.
|
||||
" @Revision: 0.0.4
|
||||
|
||||
let s:save_cpo = &cpo
|
||||
set cpo&vim
|
||||
|
||||
|
||||
" If |pumvisible()| is true, return "\<c-y>". Otherwise return a:key.
|
||||
" For use in maps like: >
|
||||
" imap <expr> <cr> tlib#map#PumAccept("\<cr>")
|
||||
function! tlib#map#PumAccept(key) "{{{3
|
||||
return pumvisible() ? "\<c-y>" : a:key
|
||||
endf
|
||||
|
||||
|
||||
|
||||
let &cpo = s:save_cpo
|
||||
unlet s:save_cpo
|
||||
@ -1,34 +0,0 @@
|
||||
" normal.vim
|
||||
" @Author: Tom Link (mailto:micathom AT gmail com?subject=[vim])
|
||||
" @Website: http://www.vim.org/account/profile.php?user_id=4037
|
||||
" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
|
||||
" @Created: 2008-10-06.
|
||||
" @Last Change: 2010-09-22.
|
||||
" @Revision: 28
|
||||
|
||||
let s:save_cpo = &cpo
|
||||
set cpo&vim
|
||||
|
||||
|
||||
" :display: tlib#normal#WithRegister(cmd, ?register='t', ?norm_cmd='norm!')
|
||||
" Execute a normal command while maintaining all registers.
|
||||
function! tlib#normal#WithRegister(cmd, ...) "{{{3
|
||||
TVarArg ['register', 't'], ['norm_cmd', 'norm!']
|
||||
let registers = {}
|
||||
for reg in split('123456789'. register, '\zs')
|
||||
exec 'let registers[reg] = @'. reg
|
||||
endfor
|
||||
exec 'let reg = @'. register
|
||||
try
|
||||
exec norm_cmd .' '. a:cmd
|
||||
exec 'return @'. register
|
||||
finally
|
||||
for [reg, value] in items(registers)
|
||||
exec 'let @'. reg .' = value'
|
||||
endfor
|
||||
endtry
|
||||
endf
|
||||
|
||||
|
||||
let &cpo = s:save_cpo
|
||||
unlet s:save_cpo
|
||||
@ -1,113 +0,0 @@
|
||||
" notify.vim
|
||||
" @Author: Tom Link (mailto:micathom AT gmail com?subject=[vim])
|
||||
" @Website: http://www.vim.org/account/profile.php?user_id=4037
|
||||
" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
|
||||
" @Created: 2008-09-19.
|
||||
" @Last Change: 2017-09-28.
|
||||
" @Revision: 3.3.19
|
||||
|
||||
let s:save_cpo = &cpo
|
||||
set cpo&vim
|
||||
|
||||
|
||||
" :display: tlib#notify#Echo(text, ?style='')
|
||||
" Print text in the echo area. Temporarily disable 'ruler' and 'showcmd'
|
||||
" in order to prevent |press-enter| messages.
|
||||
function! tlib#notify#Echo(text, ...)
|
||||
TVarArg 'style'
|
||||
let ruler = &ruler
|
||||
let showcmd = &showcmd
|
||||
let text = substitute(a:text, '\n', '|', 'g')
|
||||
try
|
||||
set noruler
|
||||
set noshowcmd
|
||||
if !empty(style)
|
||||
exec 'echohl' style
|
||||
endif
|
||||
echo tlib#string#Strcharpart(text, 0, &columns - 1)
|
||||
finally
|
||||
if !empty(style)
|
||||
echohl None
|
||||
endif
|
||||
let &ruler = ruler
|
||||
let &showcmd = showcmd
|
||||
endtry
|
||||
endf
|
||||
|
||||
|
||||
" Contributed by Erik Falor:
|
||||
" If the line containing the message is too long, echoing it will cause
|
||||
" a 'Hit ENTER' prompt to appear. This function cleans up the line so
|
||||
" that does not happen.
|
||||
" The echoed line is too long if it is wider than the width of the
|
||||
" window, minus cmdline space taken up by the ruler and showcmd
|
||||
" features.
|
||||
function! tlib#notify#TrimMessage(message) "{{{3
|
||||
let filler = '...'
|
||||
|
||||
" If length of message with tabs converted into spaces + length of
|
||||
" line number + 2 (for the ': ' that follows the line number) is
|
||||
" greater than the width of the screen, truncate in the middle
|
||||
let to_fill = &columns
|
||||
" TLogVAR to_fill
|
||||
|
||||
" Account for space used by elements in the command-line to avoid
|
||||
" 'Hit ENTER' prompts.
|
||||
" If showcmd is on, it will take up 12 columns.
|
||||
" If the ruler is enabled, but not displayed in the statusline, it
|
||||
" will in its default form take 17 columns. If the user defines a
|
||||
" custom &rulerformat, they will need to specify how wide it is.
|
||||
if has('cmdline_info')
|
||||
if &showcmd
|
||||
let to_fill -= 12
|
||||
else
|
||||
let to_fill -= 1
|
||||
endif
|
||||
" TLogVAR &showcmd, to_fill
|
||||
|
||||
" TLogVAR &laststatus, &ruler, &rulerformat
|
||||
if &ruler
|
||||
if &laststatus == 0 || winnr('$') == 1
|
||||
if has('statusline')
|
||||
if &rulerformat == ''
|
||||
" default ruler is 17 chars wide
|
||||
let to_fill -= 17
|
||||
elseif exists('g:MP_rulerwidth')
|
||||
let to_fill -= g:MP_rulerwidth
|
||||
else
|
||||
" tml: fallback: guess length
|
||||
let to_fill -= strlen(&rulerformat)
|
||||
endif
|
||||
else
|
||||
endif
|
||||
endif
|
||||
else
|
||||
endif
|
||||
else
|
||||
let to_fill -= 1
|
||||
endif
|
||||
|
||||
" TLogVAR to_fill
|
||||
" TLogDBG strlen(a:message)
|
||||
if strlen(a:message) > to_fill
|
||||
let front = to_fill / 2 - 1
|
||||
let back = front
|
||||
if to_fill % 2 == 0 | let back -= 1 | endif
|
||||
return tlib#string#Strcharpart(a:message, 0, front) . filler .
|
||||
\ tlib#string#Strcharpart(a:message, strlen(a:message) - back)
|
||||
else
|
||||
return a:message
|
||||
endif
|
||||
endfunction
|
||||
|
||||
|
||||
function! tlib#notify#PrintError() abort "{{{3
|
||||
echohl ErrorMsg
|
||||
echom v:exception
|
||||
echom v:throwpoint
|
||||
echohl NONE
|
||||
endf
|
||||
|
||||
|
||||
let &cpo = s:save_cpo
|
||||
unlet s:save_cpo
|
||||
@ -1,36 +0,0 @@
|
||||
" @Author: Tom Link (mailto:micathom AT gmail com?subject=[vim])
|
||||
" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
|
||||
" @Revision: 26
|
||||
|
||||
|
||||
function! tlib#number#ConvertBase(num, base, ...) "{{{3
|
||||
let rtype = a:0 >= 1 ? a:1 : 'string'
|
||||
" TLogVAR a:num, a:base, rtype
|
||||
if a:base == 32
|
||||
let chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567"
|
||||
elseif a:base == 63 || a:base == 64
|
||||
let chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
|
||||
elseif a:base == 85
|
||||
let chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz!#$%&()*+-;<=>?@^_`{|}~"
|
||||
elseif a:base <= 62
|
||||
let chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
|
||||
else
|
||||
throw 'tlib#number#ConvertBase: base is not supported'
|
||||
endif
|
||||
let rv = []
|
||||
let num = 0.0 + a:num
|
||||
while floor(num) > 0.0
|
||||
let div = floor(num / a:base)
|
||||
let num1 = float2nr(num - a:base * div)
|
||||
call insert(rv, chars[num1])
|
||||
let num = num / a:base
|
||||
endwh
|
||||
" TLogVAR rv
|
||||
if rtype == 'list'
|
||||
return rv
|
||||
else
|
||||
return join(rv, '')
|
||||
endif
|
||||
endf
|
||||
|
||||
|
||||
@ -1,97 +0,0 @@
|
||||
" paragraph.vim
|
||||
" @Author: Tom Link (mailto:micathom AT gmail com?subject=[vim])
|
||||
" @Website: http://www.vim.org/account/profile.php?user_id=4037
|
||||
" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
|
||||
" @Created: 2009-10-26.
|
||||
" @Last Change: 2011-04-03.
|
||||
" @Revision: 62
|
||||
|
||||
let s:save_cpo = &cpo
|
||||
set cpo&vim
|
||||
|
||||
|
||||
" Return an object describing a |paragraph|.
|
||||
function! tlib#paragraph#GetMetric() "{{{3
|
||||
let sp = {'text_start': line("'{") + 1}
|
||||
if line("'}") == line("$")
|
||||
let sp.last = 1
|
||||
let sp.text_end = line("'}")
|
||||
if line("'{") == 1
|
||||
let sp.ws_start = 0
|
||||
let sp.ws_end = 0
|
||||
let sp.top = sp.text_start
|
||||
let sp.bottom = sp.text_end
|
||||
else
|
||||
let sp.ws_start = prevnonblank(line("'{")) + 1
|
||||
let sp.ws_end = line("'{")
|
||||
let sp.top = sp.ws_start
|
||||
let sp.bottom = sp.text_end
|
||||
endif
|
||||
else
|
||||
let sp.last = 0
|
||||
let sp.text_end = line("'}") - 1
|
||||
let sp.ws_start = line("'}")
|
||||
for i in range(line("'}"), line('$'))
|
||||
if getline(i) =~ '\w'
|
||||
let sp.ws_end = i - 1
|
||||
break
|
||||
elseif i == line("$")
|
||||
let sp.ws_end = i
|
||||
endif
|
||||
endfor
|
||||
let sp.top = sp.text_start
|
||||
let sp.bottom = sp.ws_end
|
||||
endif
|
||||
return sp
|
||||
endf
|
||||
|
||||
|
||||
" This function can be used with the tinymode plugin to move around
|
||||
" paragraphs.
|
||||
"
|
||||
" Example configuration: >
|
||||
"
|
||||
" call tinymode#EnterMap("para_move", "gp")
|
||||
" call tinymode#ModeMsg("para_move", "Move paragraph: j/k")
|
||||
" call tinymode#Map("para_move", "j", "silent call tlib#paragraph#Move('Down', '[N]')")
|
||||
" call tinymode#Map("para_move", "k", "silent call tlib#paragraph#Move('Up', '[N]')")
|
||||
" call tinymode#ModeArg("para_move", "owncount", 1)
|
||||
function! tlib#paragraph#Move(direction, count)
|
||||
" TLogVAR a:direction, a:count
|
||||
let mycount = empty(a:count) ? 1 : a:count
|
||||
for i in range(1, mycount)
|
||||
let para = tlib#paragraph#GetMetric()
|
||||
" TLogVAR para
|
||||
let text = getline(para.text_start, para.text_end)
|
||||
let ws = getline(para.ws_start, para.ws_end)
|
||||
" TLogVAR text, ws
|
||||
exec para.top .','. para.bottom .'delete'
|
||||
if a:direction == "Down"
|
||||
let other = tlib#paragraph#GetMetric()
|
||||
let target = other.bottom + 1
|
||||
if other.last
|
||||
let lines = ws + text
|
||||
let pos = target + len(ws)
|
||||
else
|
||||
let lines = text + ws
|
||||
let pos = target
|
||||
endif
|
||||
elseif a:direction == "Up"
|
||||
if !para.last
|
||||
norm! {
|
||||
endif
|
||||
let other = tlib#paragraph#GetMetric()
|
||||
let target = other.text_start
|
||||
let lines = text + ws
|
||||
let pos = target
|
||||
endif
|
||||
" TLogVAR other, target
|
||||
" TLogVAR lines
|
||||
call append(target - 1, lines)
|
||||
exec pos
|
||||
endfor
|
||||
endf
|
||||
|
||||
|
||||
let &cpo = s:save_cpo
|
||||
unlet s:save_cpo
|
||||
@ -1,54 +0,0 @@
|
||||
" persistent.vim -- Persistent data
|
||||
" @Author: Tom Link (mailto:micathom AT gmail com?subject=[vim])
|
||||
" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
|
||||
" @Created: 2012-05-11.
|
||||
" @Last Change: 2017-03-29.
|
||||
" @Revision: 15
|
||||
|
||||
" The directory for persistent data files. If empty, use
|
||||
" |tlib#dir#MyRuntime|.'/share'.
|
||||
TLet g:tlib_persistent = ''
|
||||
|
||||
|
||||
" :display: tlib#persistent#Dir(?mode = 'bg')
|
||||
" Return the full directory name for persistent data files.
|
||||
function! tlib#persistent#Dir() "{{{3
|
||||
TVarArg ['mode', 'bg']
|
||||
let dir = tlib#var#Get('tlib_persistent', mode)
|
||||
if empty(dir)
|
||||
let dir = tlib#file#Join([tlib#dir#MyRuntime(), 'share'])
|
||||
endif
|
||||
return dir
|
||||
endf
|
||||
|
||||
" :display: tlib#persistent#EncodedFilename(type, file, ?mkdir=0, ?dir='')
|
||||
" Encode `file` and call |tlib#persistent#Filename()|.
|
||||
function! tlib#persistent#EncodedFilename(type, file, ...) "{{{3
|
||||
let file = tlib#url#Encode(a:file)
|
||||
return call(function('tlib#persistent#Filename'), [a:type, file] + a:000)
|
||||
endf
|
||||
|
||||
" :def: function! tlib#persistent#Filename(type, ?file=%, ?mkdir=0)
|
||||
function! tlib#persistent#Filename(type, ...) "{{{3
|
||||
" TLogDBG 'bufname='. bufname('.')
|
||||
let file = a:0 >= 1 ? a:1 : ''
|
||||
let mkdir = a:0 >= 2 ? a:2 : 0
|
||||
return tlib#cache#Filename(a:type, file, mkdir, tlib#persistent#Dir())
|
||||
endf
|
||||
|
||||
function! tlib#persistent#Get(...) "{{{3
|
||||
return call('tlib#cache#Get', a:000)
|
||||
endf
|
||||
|
||||
function! tlib#persistent#MTime(cfile) "{{{3
|
||||
return tlib#cache#MTime(a:cfile)
|
||||
endf
|
||||
|
||||
function! tlib#persistent#Value(...) "{{{3
|
||||
return call('tlib#cache#Value', a:000)
|
||||
endf
|
||||
|
||||
function! tlib#persistent#Save(...) "{{{3
|
||||
call call(function('tlib#cache#Save'), a:000)
|
||||
endf
|
||||
|
||||
@ -1,95 +0,0 @@
|
||||
" @Author: Tom Link (mailto:micathom AT gmail com?subject=[vim])
|
||||
" @Website: http://www.vim.org/account/profile.php?user_id=4037
|
||||
" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
|
||||
" @Revision: 86
|
||||
|
||||
let s:id = 0
|
||||
let s:ids = []
|
||||
let s:statusline = []
|
||||
let s:laststatus = []
|
||||
let s:max = []
|
||||
let s:format = []
|
||||
let s:width = []
|
||||
let s:value = []
|
||||
let s:timestamp = -1
|
||||
|
||||
" EXAMPLE: >
|
||||
" call tlib#progressbar#Init(20)
|
||||
" try
|
||||
" for i in range(20)
|
||||
" call tlib#progressbar#Display(i)
|
||||
" call DoSomethingThatTakesSomeTime(i)
|
||||
" endfor
|
||||
" finally
|
||||
" call tlib#progressbar#Restore()
|
||||
" endtry
|
||||
function! tlib#progressbar#Init(max, ...) "{{{3
|
||||
TVarArg ['format', '%s'], ['width', 10]
|
||||
let s:id += 1
|
||||
call insert(s:ids, s:id)
|
||||
call insert(s:statusline, &statusline)
|
||||
call insert(s:laststatus, &laststatus)
|
||||
call insert(s:max, a:max)
|
||||
call insert(s:format, format)
|
||||
call insert(s:width, width)
|
||||
call insert(s:value, -1)
|
||||
let sl = {
|
||||
\ 'id': s:id,
|
||||
\ 'statusline': &statusline,
|
||||
\ 'laststatus': &laststatus,
|
||||
\ 'max': a:max,
|
||||
\ 'format': format,
|
||||
\ 'width': width,
|
||||
\ 'value': -1
|
||||
\ }
|
||||
let &laststatus = 2
|
||||
let s:timestamp = localtime()
|
||||
return sl
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#progressbar#Restore(...) "{{{3
|
||||
if a:0 >= 1
|
||||
let sl = a:1
|
||||
let idx = index(s:ids, sl.id)
|
||||
let &statusline = sl.statusline
|
||||
let &laststatus = sl.laststatus
|
||||
else
|
||||
let idx = 0
|
||||
let &statusline = remove(s:statusline, idx)
|
||||
let &laststatus = remove(s:laststatus, idx)
|
||||
endif
|
||||
call remove(s:ids, idx)
|
||||
call remove(s:max, idx)
|
||||
call remove(s:format, idx)
|
||||
call remove(s:width, idx)
|
||||
call remove(s:value, idx)
|
||||
redrawstatus
|
||||
" redraw
|
||||
" echo
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#progressbar#Display(value, ...) "{{{3
|
||||
TVarArg 'extra', ['always', 0]
|
||||
let ts = localtime()
|
||||
if !always && ts == s:timestamp
|
||||
return
|
||||
else
|
||||
let s:timestamp = ts
|
||||
endif
|
||||
let val = a:value * s:width[0] / s:max[0]
|
||||
if always || val != s:value[0]
|
||||
let s:value[0] = val
|
||||
let pbl = repeat('#', val)
|
||||
let pbr = repeat('.', s:width[0] - val)
|
||||
let txt = printf(s:format[0], '['.pbl.pbr.']') . extra
|
||||
let &statusline = txt
|
||||
" TLogDBG txt
|
||||
redrawstatus
|
||||
" redraw
|
||||
" call tlib#notify#Echo(txt)
|
||||
endif
|
||||
endf
|
||||
|
||||
|
||||
@ -1,317 +0,0 @@
|
||||
" @Author: Tom Link (mailto:micathom AT gmail com?subject=[vim])
|
||||
" @Website: https://github.com/tomtom
|
||||
" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
|
||||
" @Last Change: 2018-02-08
|
||||
" @Revision: 69
|
||||
|
||||
" :nodoc:
|
||||
TLet g:tlib#qfl#world = {
|
||||
\ 'type': 'mi',
|
||||
\ 'query': 'Select entry',
|
||||
\ 'pick_last_item': 0,
|
||||
\ 'resize_vertical': 0,
|
||||
\ 'resize': 20,
|
||||
\ 'scratch': '__TLibQFL__',
|
||||
\ 'tlib_UseInputListScratch': 'call tlib#qfl#InitListBuffer(world)',
|
||||
\ 'key_handlers': [
|
||||
\ {'key': 5, 'agent': 'tlib#qfl#AgentWithSelected', 'key_name': '<c-e>', 'help': 'Run a command on selected lines'},
|
||||
\ {'key': 16, 'agent': 'tlib#qfl#AgentPreviewQFE', 'key_name': '<c-p>', 'help': 'Preview'},
|
||||
\ {'key': 60, 'agent': 'tlib#qfl#AgentGotoQFE', 'key_name': '<', 'help': 'Jump (don''t close the list)'},
|
||||
\ {'key': 19, 'agent': 'tlib#qfl#AgentSplitBuffer', 'key_name': '<c-s>', 'help': 'Show in split buffer'},
|
||||
\ {'key': 20, 'agent': 'tlib#qfl#AgentTabBuffer', 'key_name': '<c-t>', 'help': 'Show in tab'},
|
||||
\ {'key': 22, 'agent': 'tlib#qfl#AgentVSplitBuffer', 'key_name': '<c-v>', 'help': 'Show in vsplit buffer'},
|
||||
\ {'key': 12, 'agent': 'tlib#qfl#AgentEditLine', 'key_name': '<c-l>', 'help': 'Edit selected line(s)'},
|
||||
\ {'key': "\<c-insert>", 'agent': 'tlib#qfl#SetFollowCursor', 'key_name': '<c-ins>', 'help': 'Toggle trace cursor'},
|
||||
\ ],
|
||||
\ 'return_agent': 'tlib#qfl#AgentEditQFE',
|
||||
\ }
|
||||
|
||||
|
||||
function! tlib#qfl#FormatQFLE(qfe) dict abort "{{{3
|
||||
let filename = tlib#qfl#QfeFilename(a:qfe)
|
||||
let short_filename = get(self, 'qfl_short_filename', '')
|
||||
if short_filename ==# 'basename'
|
||||
let filename = matchstr(filename, '[^\\/]\+$')
|
||||
elseif !empty(short_filename)
|
||||
let filename = pathshorten(filename)
|
||||
endif
|
||||
return printf("%s|%d| %s", filename, a:qfe.lnum, get(a:qfe, "text"))
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#qfl#QfeFilename(qfe) abort "{{{3
|
||||
let filename = get(a:qfe, 'filename')
|
||||
if empty(filename)
|
||||
let filename = bufname(get(a:qfe, 'bufnr'))
|
||||
endif
|
||||
return filename
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#qfl#InitListBuffer(world) "{{{3
|
||||
let set_syntax = get(a:world, 'set_syntax', 'tlib#qfl#SetSyntax')
|
||||
call call(set_syntax, [], a:world)
|
||||
if has('balloon_eval')
|
||||
setlocal ballooneval balloonexpr=tlib#qfl#Balloon()
|
||||
endif
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#qfl#SetSyntax() dict abort "{{{3
|
||||
let syntax = get(self, 'qfl_list_syntax', '')
|
||||
let nextgroup = get(self, 'qfl_list_syntax_nextgroup', '')
|
||||
" TLogVAR syntax, nextgroup
|
||||
if !empty(syntax)
|
||||
exec printf('runtime syntax/%s.vim', syntax)
|
||||
endif
|
||||
syn match TTagedFilesFilename /\%(\f\+\| \)\+\ze|\d\+| / nextgroup=TTagedFilesLNum
|
||||
if !empty(nextgroup)
|
||||
exec 'syn match TTagedFilesLNum /|\d\+|\s\+/ nextgroup='. nextgroup
|
||||
else
|
||||
syn match TTagedFilesLNum /|\d\+|/
|
||||
endif
|
||||
hi def link TTagedFilesFilename Directory
|
||||
hi def link TTagedFilesLNum LineNr
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#qfl#Balloon() "{{{3
|
||||
let world = getbufvar(v:beval_bufnr, 'tlibDisplayListWorld')
|
||||
let current = max([1, world.offset]) + v:beval_lnum - 1
|
||||
if current > len(world.table)
|
||||
let current = len(world.table)
|
||||
endif
|
||||
let baseidx = world.GetBaseIdx0(current)
|
||||
" TLogVAR world.offset, v:beval_lnum, current, baseidx
|
||||
let item = world.data[baseidx]
|
||||
let bufnr = get(item, 'bufnr', 0)
|
||||
let bufname = get(item, 'filename', '')
|
||||
if bufnr == 0 && !empty(bufname)
|
||||
let bufnr = bufnr(bufname)
|
||||
endif
|
||||
if empty(bufname) && bufnr > 0
|
||||
let bufname = bufname(bufnr)
|
||||
endif
|
||||
" TLogVAR item
|
||||
if bufnr == 0
|
||||
return ''
|
||||
else
|
||||
let lines = [printf("%d#%d: %s", bufnr, item.lnum, bufname)]
|
||||
if has('balloon_multiline')
|
||||
let desc = {'nr': 'Error number', 'type': 'Error type', 'text': ''}
|
||||
for key in ['nr', 'type', 'text']
|
||||
if has_key(item, key) && !empty(item[key])
|
||||
let keydesc = get(desc, key, key)
|
||||
if empty(keydesc)
|
||||
let text = item[key]
|
||||
else
|
||||
let text = printf("%s: %s", key, item[key])
|
||||
endif
|
||||
call add(lines, text)
|
||||
endif
|
||||
endfor
|
||||
endif
|
||||
return join(lines, "\n")
|
||||
endif
|
||||
" v:beval_bufnr number of the buffer in which balloon is going to show
|
||||
" v:beval_winnr number of the window
|
||||
" v:beval_lnum line number
|
||||
" v:beval_col column number (byte index)
|
||||
" v:beval_text word under or after the mouse pointer
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#qfl#AgentEditQFE(world, selected, ...) "{{{3
|
||||
TVarArg ['cmd_edit', ''], ['cmd_buffer', ''], ['set_origin', 1]
|
||||
" TVarArg ['cmd_edit', 'edit'], ['cmd_buffer', 'buffer']
|
||||
" TLogVAR a:selected
|
||||
if empty(a:selected)
|
||||
" call a:world.RestoreOrigin()
|
||||
" call a:world.ResetSelected()
|
||||
else
|
||||
call a:world.RestoreOrigin()
|
||||
for idx in a:selected
|
||||
let idx -= 1
|
||||
" TLogVAR idx
|
||||
if idx >= 0
|
||||
" TLogVAR a:world.data
|
||||
" call tlog#Debug(string(map(copy(a:world.data), 'v:val.bufnr')))
|
||||
" TLogVAR idx, a:world.data[idx]
|
||||
let qfe = a:world.data[idx]
|
||||
" let back = a:world.SwitchWindow('win')
|
||||
" TLogVAR cmd_edit, cmd_buffer, qfe
|
||||
let fn = tlib#qfl#QfeFilename(qfe)
|
||||
" TLogVAR cmd_edit, cmd_buffer, fn
|
||||
if empty(cmd_edit) && empty(cmd_buffer)
|
||||
if tlib#file#Edit(fn)
|
||||
call tlib#buffer#ViewLine(qfe.lnum)
|
||||
endif
|
||||
else
|
||||
call tlib#file#With(cmd_edit, cmd_buffer, [fn], a:world)
|
||||
" TLogDBG bufname('%')
|
||||
" TLogVAR &filetype
|
||||
call tlib#buffer#ViewLine(qfe.lnum)
|
||||
" exec back
|
||||
endif
|
||||
endif
|
||||
endfor
|
||||
if set_origin
|
||||
call a:world.SetOrigin()
|
||||
endif
|
||||
endif
|
||||
return a:world
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#qfl#AgentPreviewQFE(world, selected) "{{{3
|
||||
" TLogVAR a:selected
|
||||
let back = a:world.SwitchWindow('win')
|
||||
call tlib#qfl#AgentEditQFE(a:world, a:selected[0:0], '', '', 0)
|
||||
exec back
|
||||
redraw
|
||||
let a:world.state = 'redisplay'
|
||||
return a:world
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#qfl#AgentGotoQFE(world, selected) "{{{3
|
||||
let world = a:world
|
||||
if !empty(a:selected)
|
||||
let world = tlib#agent#Suspend(world, a:selected)
|
||||
call tlib#qfl#AgentEditQFE(world, a:selected[0:0])
|
||||
endif
|
||||
return world
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#qfl#AgentWithSelected(world, selected, ...) "{{{3
|
||||
let cmd = a:0 >= 1 ? a:1 : input('Ex command: ', '', 'command')
|
||||
let world = a:world
|
||||
if !empty(cmd)
|
||||
let world = tlib#qfl#RunCmdOnSelected(world, a:selected, cmd)
|
||||
else
|
||||
let world.state = 'redisplay'
|
||||
endif
|
||||
return world
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#qfl#RunCmdOnSelected(world, selected, cmd, ...) "{{{3
|
||||
let close_scratch = a:0 >= 1 ? a:1 : 1
|
||||
if close_scratch
|
||||
call a:world.CloseScratch()
|
||||
endif
|
||||
" TLogVAR a:cmd
|
||||
for entry in a:selected
|
||||
" TLogVAR entry, a:world.GetBaseItem(entry)
|
||||
call tlib#qfl#AgentEditQFE(a:world, [entry], '', '', 0)
|
||||
" TLogDBG bufname('%')
|
||||
exec a:cmd
|
||||
" let item = a:world.data[a:world.GetBaseIdx(entry - 1)]
|
||||
" <+TODO+>
|
||||
let item = a:world.data[entry - 1]
|
||||
" TLogVAR entry, item, getline('.')
|
||||
if has_key(a:world, 'GetBufferLines')
|
||||
let lines = a:world.GetBufferLines('.', '.')
|
||||
else
|
||||
let lines = getline('.', '.')
|
||||
endif
|
||||
let item['text'] = tlib#string#Strip(lines[0])
|
||||
endfor
|
||||
if has_key(a:world, 'AfterRunCmd')
|
||||
if bufnr('%') == a:world.bufnr
|
||||
call a:world.AfterRunCmd()
|
||||
else
|
||||
" <+TODO+> Run in other buffer
|
||||
endif
|
||||
endif
|
||||
" call s:FormatBase(a:world)
|
||||
call a:world.RestoreOrigin()
|
||||
let a:world.state = 'reset'
|
||||
return a:world
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#qfl#AgentSplitBuffer(world, selected) "{{{3
|
||||
call a:world.CloseScratch()
|
||||
return tlib#qfl#AgentEditQFE(a:world, a:selected, 'split', 'sbuffer')
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#qfl#AgentTabBuffer(world, selected) "{{{3
|
||||
call a:world.CloseScratch()
|
||||
return tlib#qfl#AgentEditQFE(a:world, a:selected, 'tabedit', 'tab sbuffer')
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#qfl#AgentVSplitBuffer(world, selected) "{{{3
|
||||
call a:world.CloseScratch()
|
||||
return tlib#qfl#AgentEditQFE(a:world, a:selected, 'vertical split', 'vertical sbuffer')
|
||||
endf
|
||||
|
||||
|
||||
" function! tlib#qfl#AgentOpenBuffer(world, selected) "{{{3
|
||||
" endf
|
||||
|
||||
|
||||
function! tlib#qfl#AgentEditLine(world, selected) "{{{3
|
||||
call a:world.CloseScratch()
|
||||
let cmd = 'call tlib#qfl#EditLine(".")'
|
||||
return tlib#qfl#RunCmdOnSelected(a:world, a:selected, cmd)
|
||||
let a:world.state = 'reset'
|
||||
return a:world
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#qfl#EditLine(lnum) "{{{3
|
||||
call inputsave()
|
||||
let line = input('', getline(a:lnum))
|
||||
call inputrestore()
|
||||
if !empty(line)
|
||||
call setline(line(a:lnum), line)
|
||||
endif
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#qfl#SetFollowCursor(world, selected) "{{{3
|
||||
if empty(a:world.follow_cursor)
|
||||
let a:world.follow_cursor = 'tlib#qfl#AgentPreviewQFE'
|
||||
else
|
||||
let a:world.follow_cursor = ''
|
||||
endif
|
||||
let a:world.state = 'redisplay'
|
||||
return a:world
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#qfl#QflList(list, ...) abort "{{{3
|
||||
TVarArg ['world_dict', {}], ['anyway', 0], ['suspended', 0]
|
||||
Tlibtrace 'tlib', world_dict, anyway, suspended
|
||||
" TLogVAR a:list, world_dict, anyway, suspended
|
||||
if !anyway && empty(a:list)
|
||||
return
|
||||
endif
|
||||
let world = copy(g:tlib#qfl#world)
|
||||
if !empty(world_dict)
|
||||
let world = tlib#eval#Extend(world, world_dict)
|
||||
endif
|
||||
" TLogVAR world
|
||||
let world = tlib#World#New(world)
|
||||
" echom "DBG world" string(sort(keys(world)))
|
||||
let world.data = copy(a:list)
|
||||
if !has_key(world, 'format_data')
|
||||
let world.format_data = 'tlib#qfl#FormatQFLE'
|
||||
endif
|
||||
" TLogVAR world
|
||||
" TLogVAR world.data
|
||||
" call s:FormatBase(world)
|
||||
" TLogVAR world.base
|
||||
return tlib#input#ListW(world, suspended ? 'hibernate' : '')
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#qfl#Browse(...) abort "{{{3
|
||||
let list = getqflist()
|
||||
return call(function('tlib#qfl#QflList'), [list] + a:000)
|
||||
endf
|
||||
|
||||
@ -1,54 +0,0 @@
|
||||
" @Author: Tom Link (micathom AT gmail com?subject=[vim])
|
||||
" @Website: http://www.vim.org/account/profile.php?user_id=4037
|
||||
" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
|
||||
" @Revision: 114
|
||||
|
||||
|
||||
" :def: function! tlib#rx#Escape(text, ?magic='m')
|
||||
" magic can be one of: m, M, v, V
|
||||
" See :help 'magic'
|
||||
function! tlib#rx#Escape(text, ...) "{{{3
|
||||
TVarArg 'magic'
|
||||
if empty(magic)
|
||||
let magic = 'm'
|
||||
endif
|
||||
if magic =~# '^\\\?m$'
|
||||
return escape(a:text, '^$.*\[]~')
|
||||
elseif magic =~# '^\\\?M$'
|
||||
return escape(a:text, '^$\')
|
||||
elseif magic =~# '^\\\?V$'
|
||||
return escape(a:text, '\')
|
||||
elseif magic =~# '^\\\?v$'
|
||||
return substitute(a:text, '[^0-9a-zA-Z_]', '\\&', 'g')
|
||||
else
|
||||
echoerr 'tlib: Unsupported magic type'
|
||||
return a:text
|
||||
endif
|
||||
endf
|
||||
|
||||
" :def: function! tlib#rx#EscapeReplace(text, ?magic='m')
|
||||
" Escape return |sub-replace-special|.
|
||||
function! tlib#rx#EscapeReplace(text, ...) "{{{3
|
||||
TVarArg ['magic', 'm']
|
||||
return escape(a:text, '\&~')
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#rx#Suffixes(...) "{{{3
|
||||
TVarArg ['magic', 'm']
|
||||
let sfx = split(&suffixes, ',')
|
||||
call map(sfx, 'tlib#rx#Escape(v:val, magic)')
|
||||
if magic ==# 'v'
|
||||
return '('. join(sfx, '|') .')$'
|
||||
elseif magic ==# 'V'
|
||||
return '\('. join(sfx, '\|') .'\)\$'
|
||||
else
|
||||
return '\('. join(sfx, '\|') .'\)$'
|
||||
endif
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#rx#LooksLikeRegexp(text) abort "{{{3
|
||||
return a:text =~ '[.?*+{}\[\]]'
|
||||
endf
|
||||
|
||||
@ -1,136 +0,0 @@
|
||||
" @Author: Tom Link (micathom AT gmail com?subject=[vim])
|
||||
" @Website: http://www.vim.org/account/profile.php?user_id=4037
|
||||
" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
|
||||
" @Revision: 255
|
||||
|
||||
|
||||
" Scratch window position. By default the list window is opened on the
|
||||
" bottom. Set this variable to 'topleft' or '' to change this behaviour.
|
||||
" See |tlib#input#List()|.
|
||||
TLet g:tlib_scratch_pos = 'botright'
|
||||
|
||||
" If you want the scratch buffer to be fully removed, you might want to
|
||||
" set this variable to 'wipe'.
|
||||
" See also https://github.com/tomtom/tlib_vim/pull/16
|
||||
TLet g:tlib#scratch#hidden = 'hide'
|
||||
|
||||
|
||||
" :def: function! tlib#scratch#UseScratch(?keyargs={})
|
||||
" Display a scratch buffer (a buffer with no file). See :TScratch for an
|
||||
" example.
|
||||
" Return the scratch buffer's number.
|
||||
" Values for keyargs:
|
||||
" scratch_split ... 1: split, 0: window, -1: tab
|
||||
function! tlib#scratch#UseScratch(...) "{{{3
|
||||
exec tlib#arg#Let([['keyargs', {}]])
|
||||
" TLogDBG string(keys(keyargs))
|
||||
let id = get(keyargs, 'scratch', '__Scratch__')
|
||||
" TLogVAR id, bufwinnr(id)
|
||||
" TLogVAR bufnr(id), bufname(id)
|
||||
" TLogVAR 1, winnr(), bufnr('%'), bufname("%")
|
||||
if bufwinnr(id) != -1
|
||||
" echom 'DBG noautocmd keepalt keepj' bufwinnr(id) 'wincmd w'
|
||||
exec 'noautocmd keepalt keepj' bufwinnr(id) 'wincmd w'
|
||||
" TLogVAR "reuse", bufnr("%"), bufname("%")
|
||||
else
|
||||
let winpos = ''
|
||||
let bn = bufnr(id)
|
||||
let wpos = get(keyargs, 'scratch_pos', g:tlib_scratch_pos)
|
||||
" TLogVAR keyargs.scratch_vertical
|
||||
if get(keyargs, 'scratch_vertical')
|
||||
let wpos .= ' vertical'
|
||||
let winpos = tlib#fixes#Winpos()
|
||||
endif
|
||||
" TLogVAR wpos
|
||||
let scratch_split = get(keyargs, 'scratch_split', 1)
|
||||
if bn != -1
|
||||
" TLogVAR bn
|
||||
let wn = bufwinnr(bn)
|
||||
if wn != -1
|
||||
" TLogVAR wn
|
||||
exec 'noautocmd keepalt keepj' (wn .'wincmd w')
|
||||
else
|
||||
if scratch_split == 1
|
||||
let cmd = wpos.' sbuffer!'
|
||||
elseif scratch_split == -1
|
||||
let cmd = wpos.' tab sbuffer!'
|
||||
else
|
||||
let cmd = 'buffer!'
|
||||
endif
|
||||
" TLogVAR cmd, bn
|
||||
silent exec 'noautocmd keepalt keepj' cmd bn
|
||||
endif
|
||||
else
|
||||
" TLogVAR id
|
||||
if scratch_split == 1
|
||||
let cmd = wpos.' split'
|
||||
elseif scratch_split == -1
|
||||
let cmd = wpos.' tab split'
|
||||
else
|
||||
let cmd = 'edit'
|
||||
endif
|
||||
" TLogVAR cmd, id
|
||||
silent exec 'noautocmd keepalt keepj' cmd escape(id, '%#\ ')
|
||||
" silent exec 'split '. id
|
||||
endif
|
||||
let ft = get(keyargs, 'scratch_filetype', '')
|
||||
" TLogVAR ft, winpos
|
||||
if !empty(winpos)
|
||||
exec winpos
|
||||
endif
|
||||
setlocal buftype=nofile
|
||||
let &l:bufhidden = get(keyargs, 'scratch_hidden', g:tlib#scratch#hidden)
|
||||
setlocal noswapfile
|
||||
setlocal nobuflisted
|
||||
setlocal foldmethod=manual
|
||||
setlocal foldcolumn=0
|
||||
setlocal nospell
|
||||
setlocal modifiable
|
||||
setlocal noreadonly
|
||||
" TLogVAR &ft, ft
|
||||
if !empty(ft)
|
||||
let &l:ft = ft
|
||||
endif
|
||||
endif
|
||||
let keyargs.scratch = bufnr('%')
|
||||
let keyargs.scratch_tabpagenr = tabpagenr()
|
||||
let keyargs.scratch_winnr = winnr()
|
||||
" TLogVAR 2, winnr(), bufnr('%'), bufname("%"), keyargs.scratch
|
||||
return keyargs.scratch
|
||||
endf
|
||||
|
||||
|
||||
" Close a scratch buffer as defined in keyargs (usually a World).
|
||||
" Return 1 if the scratch buffer is closed (or if it already was
|
||||
" closed).
|
||||
function! tlib#scratch#CloseScratch(keyargs, ...) "{{{3
|
||||
TVarArg ['reset_scratch', 1]
|
||||
let scratch = get(a:keyargs, 'scratch', '')
|
||||
" TLogVAR scratch, reset_scratch
|
||||
" TLogDBG string(tlib#win#List())
|
||||
if !empty(scratch) && winnr('$') > 1
|
||||
let wn = bufwinnr(scratch)
|
||||
" TLogVAR wn
|
||||
try
|
||||
if wn != -1
|
||||
" TLogDBG winnr()
|
||||
let wb = tlib#win#Set(wn)
|
||||
let winpos = tlib#fixes#Winpos()
|
||||
wincmd c
|
||||
if get(a:keyargs, 'scratch_vertical') && !empty(winpos)
|
||||
exec winpos
|
||||
endif
|
||||
" exec wb
|
||||
" redraw
|
||||
" TLogVAR winnr()
|
||||
endif
|
||||
return 1
|
||||
finally
|
||||
if reset_scratch
|
||||
let a:keyargs.scratch = ''
|
||||
endif
|
||||
endtry
|
||||
endif
|
||||
return 0
|
||||
endf
|
||||
|
||||
@ -1,40 +0,0 @@
|
||||
" @Author: Tom Link (mailto:micathom AT gmail com?subject=[vim])
|
||||
" @Website: http://www.vim.org/account/profile.php?user_id=4037
|
||||
" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
|
||||
" @Last Change: 2017-09-28
|
||||
" @Revision: 4
|
||||
|
||||
|
||||
" :display: tlib#selection#GetSelection(mode, ?mbeg="'<", ?mend="'>", ?opmode='selection')
|
||||
" mode can be one of: selection, lines, block
|
||||
function! tlib#selection#GetSelection(mode, ...) range "{{{3
|
||||
if a:0 >= 2
|
||||
let mbeg = a:1
|
||||
let mend = a:2
|
||||
else
|
||||
let mbeg = "'<"
|
||||
let mend = "'>"
|
||||
endif
|
||||
let opmode = a:0 >= 3 ? a:3 : 'selection'
|
||||
let l0 = line(mbeg)
|
||||
let l1 = line(mend)
|
||||
let text = getline(l0, l1)
|
||||
let c0 = col(mbeg)
|
||||
let c1 = col(mend)
|
||||
" TLogVAR mbeg, mend, opmode, l0, l1, c0, c1
|
||||
" TLogVAR text[-1]
|
||||
" TLogVAR len(text[-1])
|
||||
if opmode == 'block'
|
||||
let clen = c1 - c0
|
||||
call map(text, 'tlib#string#Strcharpart(v:val, c0, clen)')
|
||||
elseif opmode == 'selection'
|
||||
if c1 > 1
|
||||
let text[-1] = tlib#string#Strcharpart(text[-1], 0, c1 - (a:mode == 'o' || c1 > len(text[-1]) ? 0 : 1))
|
||||
endif
|
||||
if c0 > 1
|
||||
let text[0] = tlib#string#Strcharpart(text[0], c0 - 1)
|
||||
endif
|
||||
endif
|
||||
return text
|
||||
endf
|
||||
|
||||
@ -1,103 +0,0 @@
|
||||
" @Author: Tom Link (mailto:micathom AT gmail com?subject=[vim])
|
||||
" @Website: http://www.vim.org/account/profile.php?user_id=4037
|
||||
" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
|
||||
" @Created: 2009-03-12.
|
||||
" @Last Change: 2011-03-10.
|
||||
" @Revision: 0.0.45
|
||||
|
||||
let s:save_cpo = &cpo
|
||||
set cpo&vim
|
||||
|
||||
|
||||
let s:base = 2327
|
||||
let s:register = {}
|
||||
|
||||
|
||||
" Clear all signs with name SIGN.
|
||||
function! tlib#signs#ClearAll(sign) "{{{3
|
||||
" TLog a:sign
|
||||
for bn in keys(s:register)
|
||||
let idxs = keys(s:register)
|
||||
call filter(idxs, 's:register[v:val].sign == a:sign')
|
||||
" TLogVAR bns
|
||||
for idx in idxs
|
||||
exec 'sign unplace '. idx .' buffer='. s:register[idx].bn
|
||||
call remove(s:register, idx)
|
||||
endfor
|
||||
endfor
|
||||
endf
|
||||
|
||||
|
||||
" Clear all signs with name SIGN in buffer BUFNR.
|
||||
function! tlib#signs#ClearBuffer(sign, bufnr) "{{{3
|
||||
for bn in keys(s:register)
|
||||
let idxs = keys(s:register)
|
||||
call filter(idxs, 's:register[v:val].sign == a:sign && s:register[v:val].bn == a:bufnr')
|
||||
" TLogVAR bns
|
||||
for idx in idxs
|
||||
exec 'sign unplace '. idx .' buffer='. s:register[idx].bn
|
||||
call remove(s:register, idx)
|
||||
endfor
|
||||
endfor
|
||||
endf
|
||||
|
||||
|
||||
" function! tlib#signs#Clear(sign, list) "{{{3
|
||||
" " TLogVAR a:sign
|
||||
" let done = []
|
||||
" for item in a:list
|
||||
" let bn = get(item, 'bufnr', -1)
|
||||
" if index(done, bn) == -1
|
||||
" let idxs = keys(s:register)
|
||||
" call filter(idxs, 's:register[v:val].sign == a:sign && s:register[v:val].bn == bn')
|
||||
" for idx in idxs
|
||||
" exec 'sign unplace '. idx .' buffer='. s:register[idx].bn
|
||||
" call remove(s:register, idx)
|
||||
" endfor
|
||||
" call add(done, bn)
|
||||
" endif
|
||||
" endfor
|
||||
" endf
|
||||
|
||||
|
||||
" Add signs for all locations in LIST. LIST must adhere with the
|
||||
" quickfix list format (see |getqflist()|; only the fields lnum and
|
||||
" bufnr are required).
|
||||
"
|
||||
" list:: a quickfix or location list
|
||||
" sign:: a sign defined with |:sign-define|
|
||||
function! tlib#signs#Mark(sign, list) "{{{3
|
||||
" TLogVAR a:sign
|
||||
for item in a:list
|
||||
let idx = s:SignId(item)
|
||||
if idx >= 0
|
||||
let lnum = get(item, 'lnum', 0)
|
||||
if lnum > 0
|
||||
let bn = get(item, 'bufnr')
|
||||
exec ':sign place '. idx .' line='. lnum .' name='. a:sign .' buffer='. bn
|
||||
let s:register[idx] = {'sign': a:sign, 'bn': bn}
|
||||
endif
|
||||
endif
|
||||
endfor
|
||||
endf
|
||||
|
||||
|
||||
function! s:SignId(item) "{{{3
|
||||
" TLogVAR a:item
|
||||
" let bn = bufnr('%')
|
||||
let bn = get(a:item, 'bufnr', -1)
|
||||
if bn == -1
|
||||
return -1
|
||||
else
|
||||
let idx = s:base + bn * 500
|
||||
while has_key(s:register, idx)
|
||||
let idx += 1
|
||||
endwh
|
||||
return idx
|
||||
endif
|
||||
endf
|
||||
|
||||
|
||||
|
||||
let &cpo = s:save_cpo
|
||||
unlet s:save_cpo
|
||||
@ -1,208 +0,0 @@
|
||||
" @Author: Tom Link (micathom AT gmail com?subject=[vim])
|
||||
" @Website: http://www.vim.org/account/profile.php?user_id=4037
|
||||
" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
|
||||
" @Revision: 148
|
||||
|
||||
|
||||
" :def: function! tlib#string#RemoveBackslashes(text, ?chars=' ')
|
||||
" Remove backslashes from text (but only in front of the characters in
|
||||
" chars).
|
||||
function! tlib#string#RemoveBackslashes(text, ...) "{{{3
|
||||
exec tlib#arg#Get(1, 'chars', ' ')
|
||||
" TLogVAR chars
|
||||
let rv = substitute(a:text, '\\\(['. chars .']\)', '\1', 'g')
|
||||
return rv
|
||||
endf
|
||||
|
||||
|
||||
" :display: tlib#string#Chomp(string, ?max=0)
|
||||
function! tlib#string#Chomp(string, ...) "{{{3
|
||||
let quant = a:0 >= 1 ? '\{,'. a:1 .'}' : '\+'
|
||||
return substitute(a:string, '[[:cntrl:][:space:]]'. quant .'$', '', '')
|
||||
endf
|
||||
|
||||
|
||||
" Format a template string. Placeholders have the format "%{NAME}". A
|
||||
" "%" can be inserted as "%%".
|
||||
"
|
||||
" Examples:
|
||||
" echo tlib#string#Format("foo %{bar} foo", {'bar': 123}, ?prefix='%')
|
||||
" => foo 123 foo
|
||||
function! tlib#string#Format(template, dict, ...) "{{{3
|
||||
let prefix = a:0 >= 1 ? a:1 : '%'
|
||||
let pesc = prefix . prefix
|
||||
let prx = tlib#rx#Escape(prefix)
|
||||
let parts = split(a:template, '\ze'. prx .'\({.\{-}}\|.\)')
|
||||
let partrx = '^'. prx .'\({\(.\{-}\)}\|\(.\)\)\(.*\)$'
|
||||
let out = []
|
||||
for part in parts
|
||||
let ml = matchlist(part, partrx)
|
||||
if empty(ml)
|
||||
let rest = part
|
||||
else
|
||||
let var = empty(ml[2]) ? ml[3] : ml[2]
|
||||
let rest = ml[4]
|
||||
if has_key(a:dict, var)
|
||||
call add(out, a:dict[var])
|
||||
elseif var ==# pesc
|
||||
call add(out, prefix)
|
||||
else
|
||||
call add(out, ml[1])
|
||||
endif
|
||||
endif
|
||||
call add(out, rest)
|
||||
endfor
|
||||
return join(out, '')
|
||||
endf
|
||||
|
||||
|
||||
" This function deviates from |printf()| in certain ways.
|
||||
" Additional items:
|
||||
" %{rx} ... insert escaped regexp
|
||||
" %{fuzzyrx} ... insert typo-tolerant regexp
|
||||
function! tlib#string#Printf1(format, string) "{{{3
|
||||
let s = split(a:format, '%.\zs')
|
||||
" TLogVAR s
|
||||
return join(map(s, 's:PrintFormat(v:val, a:string)'), '')
|
||||
endf
|
||||
|
||||
function! s:PrintFormat(format, string) "{{{3
|
||||
let cut = match(a:format, '%\({.\{-}}\|.\)$')
|
||||
if cut == -1
|
||||
return a:format
|
||||
else
|
||||
let head = cut > 0 ? a:format[0 : cut - 1] : ''
|
||||
let tail = a:format[cut : -1]
|
||||
" TLogVAR head, tail
|
||||
if tail == '%{fuzzyrx}'
|
||||
let frx = []
|
||||
for i in range(len(a:string))
|
||||
if i > 0
|
||||
let pb = i - 1
|
||||
else
|
||||
let pb = 0
|
||||
endif
|
||||
let slice = tlib#rx#Escape(a:string[pb : i + 1])
|
||||
call add(frx, '['. slice .']')
|
||||
call add(frx, '.\?')
|
||||
endfor
|
||||
let tail = join(frx, '')
|
||||
elseif tail == '%{rx}'
|
||||
let tail = tlib#rx#Escape(a:string)
|
||||
elseif tail == '%%'
|
||||
let tail = '%'
|
||||
elseif tail == '%s'
|
||||
let tail = a:string
|
||||
endif
|
||||
" TLogVAR tail
|
||||
return head . tail
|
||||
endif
|
||||
endf
|
||||
" function! tlib#string#Printf1(format, string) "{{{3
|
||||
" let n = len(split(a:format, '%\@<!%s', 1)) - 1
|
||||
" let f = a:format
|
||||
" if f =~ '%\@<!%{fuzzyrx}'
|
||||
" let frx = []
|
||||
" for i in range(len(a:string))
|
||||
" if i > 0
|
||||
" let pb = i - 1
|
||||
" else
|
||||
" let pb = 0
|
||||
" endif
|
||||
" let slice = tlib#rx#Escape(a:string[pb : i + 1])
|
||||
" call add(frx, '['. slice .']')
|
||||
" call add(frx, '.\?')
|
||||
" endfor
|
||||
" let f = s:RewriteFormatString(f, '%{fuzzyrx}', join(frx, ''))
|
||||
" endif
|
||||
" if f =~ '%\@<!%{rx}'
|
||||
" let f = s:RewriteFormatString(f, '%{rx}', tlib#rx#Escape(a:string))
|
||||
" endif
|
||||
" if n == 0
|
||||
" return substitute(f, '%%', '%', 'g')
|
||||
" else
|
||||
" let a = repeat([a:string], n)
|
||||
" return call('printf', insert(a, f))
|
||||
" endif
|
||||
" endf
|
||||
|
||||
|
||||
function! s:RewriteFormatString(format, pattern, string) "{{{3
|
||||
let string = substitute(a:string, '%', '%%', 'g')
|
||||
return substitute(a:format, tlib#rx#Escape(a:pattern), escape(string, '\'), 'g')
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#string#TrimLeft(string) "{{{3
|
||||
return substitute(a:string, '^[[:space:][:cntrl:]]\+', '', '')
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#string#TrimRight(string) "{{{3
|
||||
return substitute(a:string, '[[:space:][:cntrl:]]\+$', '', '')
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#string#Strip(string) "{{{3
|
||||
return tlib#string#TrimRight(tlib#string#TrimLeft(a:string))
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#string#Count(string, rx) "{{{3
|
||||
let s:count = 0
|
||||
call substitute(a:string, a:rx, '\=s:CountHelper()', 'g')
|
||||
return s:count
|
||||
endf
|
||||
|
||||
function! s:CountHelper() "{{{3
|
||||
let s:count += 1
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#string#SplitCommaList(text, ...) abort "{{{3
|
||||
let sep = a:0 >= 1 ? a:1 : ',\s*'
|
||||
let parts = split(a:text, '\\\@<!\zs'. sep)
|
||||
let parts = map(parts, 'substitute(v:val, ''\\\(.\)'', ''\1'', ''g'')')
|
||||
return parts
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#string#Input(...) abort "{{{3
|
||||
TVarArg ['text', ''], ['completion', '']
|
||||
call inputsave()
|
||||
let rv = call(function('input'), a:000)
|
||||
call inputrestore()
|
||||
return rv
|
||||
endf
|
||||
|
||||
|
||||
" :display: tlib#string#MatchAll(string, sep_regexp, ?item_regexp='') abort
|
||||
function! tlib#string#MatchAll(string, regexp, ...) abort "{{{3
|
||||
let eregexp = a:0 >= 1 ? a:1 : ''
|
||||
Tlibtrace 'tlib', a:string, a:regexp, eregexp
|
||||
let ms = []
|
||||
if a:regexp =~ '\\ze'
|
||||
let regexp1 = substitute(a:regexp, '\\ze.*$', '', '')
|
||||
else
|
||||
let regexp1 = a:regexp
|
||||
endif
|
||||
for m in split(a:string, '\ze'. regexp1)
|
||||
let m1 = matchstr(m, !empty(eregexp) ? eregexp : a:regexp)
|
||||
Tlibtrace 'tlib', m, m1
|
||||
if !empty(m1)
|
||||
call add(ms, m1)
|
||||
endif
|
||||
endfor
|
||||
return ms
|
||||
endf
|
||||
|
||||
if exists('*strcharpart')
|
||||
function! tlib#string#Strcharpart(...) abort "{{{3
|
||||
return call(function('strcharpart'), a:000)
|
||||
endf
|
||||
else
|
||||
function! tlib#string#Strcharpart(...) abort "{{{3
|
||||
return call(function('strpart'), a:000)
|
||||
endf
|
||||
endif
|
||||
|
||||
@ -1,38 +0,0 @@
|
||||
" @Author: Tom Link (mailto:micathom AT gmail com?subject=[vim])
|
||||
" @Website: http://www.vim.org/account/profile.php?user_id=4037
|
||||
" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
|
||||
" @Revision: 13
|
||||
|
||||
|
||||
function! tlib#syntax#Collect() "{{{3
|
||||
let acc = {}
|
||||
let syn = ''
|
||||
for line in tlib#cmd#OutputAsList('syntax')
|
||||
if line =~ '^---'
|
||||
continue
|
||||
elseif line =~ '^\w'
|
||||
let ml = matchlist(line, '^\(\w\+\)\s\+\(xxx\s\+\(.*\)\|\(cluster.*\)\)$')
|
||||
if empty(ml)
|
||||
" echoerr 'Internal error: '. string(line)
|
||||
else
|
||||
let [m_0, syn, m_1, m_def1, m_def2; m_rest] = ml
|
||||
let acc[syn] = [empty(m_def1) ? m_def2 : m_def1]
|
||||
endif
|
||||
else
|
||||
call add(acc[syn], matchstr(line, '^\s\+\zs.*$'))
|
||||
endif
|
||||
endfor
|
||||
return acc
|
||||
endf
|
||||
|
||||
|
||||
" :def: function! tlib#syntax#Names(?rx='')
|
||||
function! tlib#syntax#Names(...) "{{{3
|
||||
TVarArg 'rx'
|
||||
let names = keys(tlib#syntax#Collect())
|
||||
if !empty(rx)
|
||||
call filter(names, 'v:val =~ rx')
|
||||
endif
|
||||
return names
|
||||
endf
|
||||
|
||||
@ -1,218 +0,0 @@
|
||||
" @Author: Tom Link (mailto:micathom AT gmail com?subject=[vim])
|
||||
" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
|
||||
" @Last Change: 2017-04-12.
|
||||
" @Revision: 62
|
||||
|
||||
|
||||
if !exists('g:tlib#sys#special_protocols')
|
||||
" A list of |regexp|s matching protocol names that should be handled
|
||||
" by |g:tlib#sys#system_browser|.
|
||||
" CAVEAT: Must be a |\V| |regexp|.
|
||||
let g:tlib#sys#special_protocols = ['https\?', 'nntp', 'mailto'] "{{{2
|
||||
endif
|
||||
|
||||
|
||||
if !exists('g:tlib#sys#special_suffixes')
|
||||
" A list of |regexp|s matching suffixes that should be handled by
|
||||
" |g:tlib#sys#system_browser|.
|
||||
" CAVEAT: Must be a |\V| |regexp|.
|
||||
let g:tlib#sys#special_suffixes = ['xlsx\?', 'docx\?', 'pptx\?', 'accdb', 'mdb', 'sqlite', 'pdf', 'jpg', 'png', 'gif', 'od\[tspg]'] "{{{2
|
||||
endif
|
||||
|
||||
|
||||
if !exists('g:tlib#sys#system_rx')
|
||||
" Open links matching this |regexp| with |g:tlib#sys#system_browser|.
|
||||
" CAVEAT: Must be a |\V| |regexp|.
|
||||
let g:tlib#sys#system_rx = printf('\V\%(\^\%(%s\):\|.\%(%s\)\$\)', join(g:tlib#sys#special_protocols, '\|'), join(g:tlib#sys#special_suffixes, '\|')) "{{{2
|
||||
endif
|
||||
|
||||
|
||||
if !exists("g:tlib#sys#system_browser")
|
||||
if exists('g:netrw_browsex_viewer')
|
||||
" Open files in the system browser.
|
||||
" :read: let g:tlib#sys#system_browser = ... "{{{2
|
||||
let g:tlib#sys#system_browser = "exec 'silent !'. g:netrw_browsex_viewer shellescape('%s')"
|
||||
elseif has("win32") || has("win16") || has("win64")
|
||||
" let g:tlib#sys#system_browser = "exec 'silent ! start \"\"' shellescape('%s')"
|
||||
let g:tlib#sys#system_browser = "exec 'silent ! RunDll32.EXE URL.DLL,FileProtocolHandler' shellescape('%s')"
|
||||
elseif has("mac")
|
||||
let g:tlib#sys#system_browser = "exec 'silent !open' shellescape('%s')"
|
||||
elseif exists('$XDG_CURRENT_DESKTOP') && !empty($XDG_CURRENT_DESKTOP)
|
||||
let g:tlib#sys#system_browser = "exec 'silent !xdg-open' shellescape('%s') '&'"
|
||||
elseif !empty($GNOME_DESKTOP_SESSION_ID) || $DESKTOP_SESSION ==# 'gnome'
|
||||
let g:tlib#sys#system_browser = "exec 'silent !gnome-open' shellescape('%s')"
|
||||
elseif exists("$KDEDIR") && !empty($KDEDIR)
|
||||
let g:tlib#sys#system_browser = "exec 'silent !kfmclient exec' shellescape('%s')"
|
||||
else
|
||||
let g:tlib#sys#system_browser = ''
|
||||
endif
|
||||
endif
|
||||
|
||||
|
||||
if !exists('g:tlib#sys#windows')
|
||||
let g:tlib#sys#windows = &shell !~ 'sh' && (has('win16') || has('win32') || has('win64')) "{{{2
|
||||
endif
|
||||
|
||||
|
||||
if !exists('g:tlib#sys#null')
|
||||
let g:tlib#sys#null = g:tlib#sys#windows ? 'NUL' : (filereadable('/dev/null') ? '/dev/null' : '') "{{{2
|
||||
endif
|
||||
|
||||
|
||||
let s:cygwin = {}
|
||||
|
||||
function! tlib#sys#IsCygwinBin(cmd) "{{{3
|
||||
" TLogVAR a:cmd
|
||||
if !g:tlib#sys#windows
|
||||
return 0
|
||||
elseif has_key(s:cygwin, a:cmd)
|
||||
let rv = s:cygwin[a:cmd]
|
||||
else
|
||||
if !tlib#sys#IsExecutable('cygpath', 1) || !tlib#sys#IsExecutable('which', 1)
|
||||
let rv = 0
|
||||
else
|
||||
let which = substitute(system('which '. shellescape(a:cmd)), '\n$', '', '')
|
||||
" echom "DBG which:" which
|
||||
if which =~ '^/'
|
||||
let filename = system('cygpath -ma '. shellescape(which))
|
||||
" echom "DBG filename:" filename
|
||||
let rv = filename =~ g:tlib#sys#cygwin_path_rx
|
||||
else
|
||||
let rv = 0
|
||||
endif
|
||||
endif
|
||||
let s:cygwin[a:cmd] = rv
|
||||
endif
|
||||
" TLogVAR rv
|
||||
return rv
|
||||
endf
|
||||
|
||||
|
||||
let s:executables = {}
|
||||
|
||||
function! tlib#sys#IsExecutable(cmd, ...) "{{{3
|
||||
" TLogVAR a:cmd
|
||||
" echom "DBG has_key(s:executables, a:cmd)" has_key(s:executables, a:cmd)
|
||||
if !has_key(s:executables, a:cmd)
|
||||
let executable = executable(a:cmd)
|
||||
" TLogVAR 1, executable
|
||||
let ignore_cyg = a:0 >= 1 ? a:1 : !g:tlib#sys#windows
|
||||
if !executable && !ignore_cyg
|
||||
let executable = tlib#sys#IsCygwinBin(a:cmd)
|
||||
" TLogVAR 2, executable
|
||||
endif
|
||||
let s:executables[a:cmd] = executable
|
||||
endif
|
||||
" echom "DBG s:executables[a:cmd]" s:executables[a:cmd]
|
||||
return s:executables[a:cmd]
|
||||
endf
|
||||
|
||||
|
||||
if !exists('g:tlib#sys#check_cygpath')
|
||||
" If true, check whether we have to convert a path via cyppath --
|
||||
" see |tlib#sys#MaybeUseCygpath|
|
||||
let g:tlib#sys#check_cygpath = g:tlib#sys#windows && tlib#sys#IsExecutable('cygpath', 1) "{{{2
|
||||
endif
|
||||
|
||||
|
||||
if !exists('g:tlib#sys#cygwin_path_rx')
|
||||
" If a full windows filename (with slashes instead of backslashes)
|
||||
" matches this |regexp|, it is assumed to be a cygwin executable.
|
||||
let g:tlib#sys#cygwin_path_rx = '/cygwin/' "{{{2
|
||||
endif
|
||||
|
||||
|
||||
if !exists('g:tlib#sys#cygwin_expr')
|
||||
" For cygwin binaries, convert command calls using this vim
|
||||
" expression.
|
||||
let g:tlib#sys#cygwin_expr = '"bash -c ''". escape(%s, "''\\") ."''"' "{{{2
|
||||
endif
|
||||
|
||||
|
||||
function! tlib#sys#GetCmd(cmd) "{{{3
|
||||
if !empty(g:tlib#sys#cygwin_expr) && tlib#sys#IsCygwinBin(matchstr(a:cmd, '^\S\+'))
|
||||
let cmd = eval(printf(g:tlib#sys#cygwin_expr, string(a:cmd)))
|
||||
" TLogVAR cmd
|
||||
return cmd
|
||||
else
|
||||
return a:cmd
|
||||
endif
|
||||
endf
|
||||
|
||||
|
||||
" If cmd seems to be a cygwin executable, use cygpath to convert
|
||||
" filenames. This assumes that cygwin's which command returns full
|
||||
" filenames for non-cygwin executables.
|
||||
function! tlib#sys#MaybeUseCygpath(cmd) "{{{3
|
||||
" echom "DBG" a:cmd
|
||||
if g:tlib#sys#check_cygpath && tlib#sys#IsCygwinBin(a:cmd)
|
||||
return 'cygpath -u "%s"'
|
||||
endif
|
||||
return ''
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#sys#ConvertPath(converter, filename) "{{{3
|
||||
return tlib#string#Chomp(system(printf(a:converter, shellescape(a:filename))))
|
||||
endf
|
||||
|
||||
|
||||
let s:native_filenames = {}
|
||||
|
||||
function! tlib#sys#FileArgs(cmd, files) "{{{3
|
||||
let cygpath = tlib#sys#MaybeUseCygpath(a:cmd)
|
||||
" TLogVAR cygpath
|
||||
if empty(cygpath)
|
||||
return a:files
|
||||
else
|
||||
let files = map(copy(a:files), 'has_key(s:native_filenames, v:val) ? s:native_filenames[v:val] : tlib#sys#CygPath(v:val)')
|
||||
return files
|
||||
endif
|
||||
endf
|
||||
|
||||
|
||||
" Check whether filename matches |g:tlib#sys#system_rx|, i.e. whether it
|
||||
" is a special file that should not be opened in vim.
|
||||
function! tlib#sys#IsSpecial(filename) abort "{{{3
|
||||
return a:filename =~ g:tlib#sys#system_rx
|
||||
endf
|
||||
|
||||
|
||||
" Open filename with the default OS application (see
|
||||
" |g:tlib#sys#system_browser|), if |tlib#sys#IsSpecial()| return 1.
|
||||
" Returns 1 if successful or 0 otherwise.
|
||||
function! tlib#sys#Open(filename) abort "{{{3
|
||||
Tlibtrace 'tlib', a:filename
|
||||
if !empty(g:tlib#sys#system_browser) && tlib#sys#IsSpecial(a:filename)
|
||||
try
|
||||
call tlib#sys#OpenWithSystemViewer(a:filename)
|
||||
return 1
|
||||
catch
|
||||
echohl ErrorMsg
|
||||
echom v:exception
|
||||
echohl NONE
|
||||
endtry
|
||||
endif
|
||||
return 0
|
||||
endf
|
||||
|
||||
|
||||
" Open filename with the default system viewer.
|
||||
function! tlib#sys#OpenWithSystemViewer(filename) abort "{{{3
|
||||
let cmd = printf(g:tlib#sys#system_browser, a:filename)
|
||||
" let cmd = printf(g:tlib#sys#system_browser, escape(a:filename, ' %#!'))
|
||||
Tlibtrace 'tlib', cmd
|
||||
exec cmd
|
||||
endf
|
||||
|
||||
|
||||
" :def: function! tlib#sys#SystemInDir(dir, expr, ?input='')
|
||||
function! tlib#sys#SystemInDir(dir, ...) abort "{{{3
|
||||
call tlib#dir#CD(a:dir)
|
||||
try
|
||||
return call(function('system'), a:000)
|
||||
finally
|
||||
silent cd! -
|
||||
endtry
|
||||
endf
|
||||
|
||||
@ -1,49 +0,0 @@
|
||||
" @Author: Tom Link (micathom AT gmail com?subject=[vim])
|
||||
" @Website: http://www.vim.org/account/profile.php?user_id=4037
|
||||
" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
|
||||
" @Revision: 31
|
||||
|
||||
|
||||
" Return a dictionary of bufnumbers => [[tabpage, winnr] ...]
|
||||
function! tlib#tab#BufMap() "{{{3
|
||||
let acc = {}
|
||||
for t in range(tabpagenr('$'))
|
||||
let bb = tabpagebuflist(t + 1)
|
||||
for b in range(len(bb))
|
||||
let bn = bb[b]
|
||||
let bd = [t + 1, b + 1]
|
||||
if has_key(acc, bn)
|
||||
call add(acc[bn], bd)
|
||||
else
|
||||
let acc[bn] = [bd]
|
||||
endif
|
||||
endfor
|
||||
endfor
|
||||
return acc
|
||||
endf
|
||||
|
||||
|
||||
" Find a buffer's window at some tab page.
|
||||
function! tlib#tab#TabWinNr(buffer) "{{{3
|
||||
let bn = bufnr(a:buffer)
|
||||
let bt = tlib#tab#BufMap()
|
||||
let tn = tabpagenr()
|
||||
let wn = winnr()
|
||||
let bc = get(bt, bn)
|
||||
if !empty(bc)
|
||||
for [t, w] in bc
|
||||
if t == tn
|
||||
return [t, w]
|
||||
endif
|
||||
endfor
|
||||
return bc[0]
|
||||
endif
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#tab#Set(tabnr) "{{{3
|
||||
if a:tabnr > 0
|
||||
exec a:tabnr .'tabnext'
|
||||
endif
|
||||
endf
|
||||
|
||||
@ -1,133 +0,0 @@
|
||||
" @Author: Tom Link (mailto:micathom AT gmail com?subject=[vim])
|
||||
" @Website: http://www.vim.org/account/profile.php?user_id=4037
|
||||
" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
|
||||
" @Revision: 64
|
||||
|
||||
|
||||
" Extra tags for |tlib#tag#Retrieve()| (see there). Can also be buffer-local.
|
||||
TLet g:tlib_tags_extra = ''
|
||||
|
||||
" Filter the tag description through |substitute()| for these filetypes.
|
||||
" This applies only if the tag cmd field (see |taglist()|) is used.
|
||||
" :nodefault:
|
||||
TLet g:tlib_tag_substitute = {
|
||||
\ 'java': [['\s*{\s*$', '', '']],
|
||||
\ 'ruby': [['\<\(def\|class\|module\)\>\s\+', '', '']],
|
||||
\ 'vim': [
|
||||
\ ['^\s*com\%[mand]!\?\(\s\+-\S\+\)*\s*\u\w*\zs.*$', '', ''],
|
||||
\ ['^\s*\(let\|aug\%[roup]\|fu\%[nction]!\?\|com\%[mand]!\?\(\s\+-\S\+\)*\)\s*', '', ''],
|
||||
\ ['"\?\s*{{{\d.*$', '', ''],
|
||||
\ ],
|
||||
\ }
|
||||
|
||||
|
||||
" :def: function! tlib#tag#Retrieve(rx, ?extra_tags=0)
|
||||
" Get all tags matching rx. Basically, this function simply calls
|
||||
" |taglist()|, but when extra_tags is true, the list of the tag files
|
||||
" (see 'tags') is temporarily expanded with |g:tlib_tags_extra|.
|
||||
"
|
||||
" Example use:
|
||||
" If you want to include tags for, eg, JDK, normal tags use can become
|
||||
" slow. You could proceed as follows:
|
||||
" 1. Create a tags file for the JDK sources. When creating the tags
|
||||
" file, make sure to include inheritance information and the like
|
||||
" (command-line options like --fields=+iaSm --extra=+q should be ok).
|
||||
" In this example, we want tags only for public methods (there are
|
||||
" most likely better ways to do this): >
|
||||
" ctags -R --fields=+iaSm --extra=+q ${JAVA_HOME}/src
|
||||
" head -n 6 tags > tags0
|
||||
" grep access:public tags >> tags0
|
||||
" < 2. Make 'tags' include project specific tags files. In
|
||||
" ~/vimfiles/after/ftplugin/java.vim insert: >
|
||||
" let b:tlib_tags_extra = $JAVA_HOME .'/tags0'
|
||||
" < 3. When this function is invoked as >
|
||||
" echo tlib#tag#Retrieve('print')
|
||||
" < it will return only project-local tags. If it is invoked as >
|
||||
" echo tlib#tag#Retrieve('print', 1)
|
||||
" < tags from the JDK will be included.
|
||||
function! tlib#tag#Retrieve(rx, ...) "{{{3
|
||||
TVarArg ['extra_tags', 0]
|
||||
Tlibtrace 'tlib', a:rx, extra_tags
|
||||
if extra_tags
|
||||
let tags_orig = &l:tags
|
||||
if empty(tags_orig)
|
||||
setlocal tags<
|
||||
endif
|
||||
try
|
||||
let more_tags = tlib#var#Get('tlib_tags_extra', 'bg')
|
||||
if !empty(more_tags)
|
||||
let &l:tags .= ','. more_tags
|
||||
endif
|
||||
let taglist = taglist(a:rx)
|
||||
finally
|
||||
let &l:tags = tags_orig
|
||||
endtry
|
||||
else
|
||||
let taglist = taglist(a:rx)
|
||||
endif
|
||||
Tlibtrace 'tlib', len(taglist)
|
||||
return copy(taglist)
|
||||
endf
|
||||
|
||||
|
||||
" Retrieve tags that meet the constraints (a dictionnary of fields and
|
||||
" regexp, with the exception of the kind field which is a list of chars).
|
||||
" For the use of the optional use_extra argument see
|
||||
" |tlib#tag#Retrieve()|.
|
||||
" :def: function! tlib#tag#Collect(constraints, ?use_extra=1, ?match_front=1)
|
||||
function! tlib#tag#Collect(constraints, ...) "{{{3
|
||||
TVarArg ['use_extra', 0], ['match_end', 1], ['match_front', 1]
|
||||
Tlibtrace 'tlib', a:constraints, use_extra, match_end, match_front
|
||||
let rx = get(a:constraints, 'name', '')
|
||||
if empty(rx) || rx == '*'
|
||||
let rx = '.'
|
||||
else
|
||||
let rxl = ['\C']
|
||||
if match_front
|
||||
call add(rxl, '^')
|
||||
endif
|
||||
" call add(rxl, tlib#rx#Escape(rx))
|
||||
call add(rxl, rx)
|
||||
if match_end
|
||||
call add(rxl, '$')
|
||||
endif
|
||||
let rx = join(rxl, '')
|
||||
endif
|
||||
Tlibtrace 'tlib', rx, use_extra
|
||||
let tags = tlib#tag#Retrieve(rx, use_extra)
|
||||
Tlibtrace 'tlib', len(tags)
|
||||
for [field, rx] in items(a:constraints)
|
||||
if !empty(rx) && rx != '*'
|
||||
" TLogVAR field, rx
|
||||
if field == 'kind'
|
||||
call filter(tags, 'v:val.kind =~ "['. rx .']"')
|
||||
elseif field != 'name'
|
||||
call filter(tags, '!empty(get(v:val, field)) && get(v:val, field) =~ rx')
|
||||
endif
|
||||
endif
|
||||
endfor
|
||||
Tlibtrace 'tlib', len(tags)
|
||||
return tags
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#tag#Format(tag) "{{{3
|
||||
if has_key(a:tag, 'signature')
|
||||
let name = a:tag.name . a:tag.signature
|
||||
elseif a:tag.cmd[0] == '/'
|
||||
let name = a:tag.cmd
|
||||
let name = substitute(name, '^/\^\?\s*', '', '')
|
||||
let name = substitute(name, '\s*\$\?/$', '', '')
|
||||
let name = substitute(name, '\s\{2,}', ' ', 'g')
|
||||
let tsub = tlib#var#Get('tlib_tag_substitute', 'bg')
|
||||
if has_key(tsub, &filetype)
|
||||
for [rx, rplc, sub] in tsub[&filetype]
|
||||
let name = substitute(name, rx, rplc, sub)
|
||||
endfor
|
||||
endif
|
||||
else
|
||||
let name = a:tag.name
|
||||
endif
|
||||
return name
|
||||
endf
|
||||
|
||||
@ -1,45 +0,0 @@
|
||||
" textobjects.vim
|
||||
" @Author: Tom Link (mailto:micathom AT gmail com?subject=[vim])
|
||||
" @Website: http://www.vim.org/account/profile.php?user_id=4037
|
||||
" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
|
||||
" @Created: 2010-01-09.
|
||||
" @Last Change: 2010-01-10.
|
||||
" @Revision: 0.0.29
|
||||
|
||||
let s:save_cpo = &cpo
|
||||
set cpo&vim
|
||||
|
||||
|
||||
" :tag: standard-paragraph
|
||||
" Select a "Standard Paragraph", i.e. a text block followed by blank
|
||||
" lines. Other than |ap|, the last paragraph in a document is handled
|
||||
" just the same.
|
||||
"
|
||||
" The |text-object| can be accessed as "sp". Example: >
|
||||
"
|
||||
" vsp ... select the current standard paragraph
|
||||
"
|
||||
" Return 1, if the paragraph is the last one in the document.
|
||||
function! tlib#textobjects#StandardParagraph() "{{{3
|
||||
if line("'}") == line('$')
|
||||
norm! vip
|
||||
return 1
|
||||
else
|
||||
norm! vap
|
||||
return 0
|
||||
endif
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#textobjects#Init() "{{{3
|
||||
if !exists('s:tlib_done_textobjects')
|
||||
" sp ... Standard paragraph (for use as |text-objects|).
|
||||
vnoremap <silent> sp <Esc>:call tlib#textobjects#StandardParagraph()<CR>
|
||||
onoremap <silent> sp :<C-u>normal Vsp<CR>
|
||||
let s:tlib_done_textobjects = 1
|
||||
endif
|
||||
endf
|
||||
|
||||
|
||||
let &cpo = s:save_cpo
|
||||
unlet s:save_cpo
|
||||
@ -1,84 +0,0 @@
|
||||
" @Author: Tom Link (mailto:micathom AT gmail com?subject=[vim])
|
||||
" @Website: http://www.vim.org/account/profile.php?user_id=4037
|
||||
" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
|
||||
" @Revision: 42
|
||||
|
||||
|
||||
function! tlib#time#MSecs() "{{{3
|
||||
let rts = reltimestr(reltime())
|
||||
return substitute(rts, '\.', '', '')
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#time#Now() "{{{3
|
||||
if has('reltime')
|
||||
let rts = reltimestr(reltime())
|
||||
let rtl = map(split(rts, '\.'), 'str2nr(v:val)')
|
||||
else
|
||||
let rtl = [localtime()]
|
||||
endif
|
||||
return rtl
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#time#FormatNow() "{{{3
|
||||
let rtl = tlib#time#Now()
|
||||
if len(rtl) == 2
|
||||
let rts = strftime(g:tlib#date#date_format .' %H:%M:%S', rtl[0]) .'.'. rtl[1]
|
||||
else
|
||||
let rts = strftime(g:tlib#date#date_format .' %H:%M:%S', rtl[0])
|
||||
endif
|
||||
return rts
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#time#Diff(a, b, ...) "{{{3
|
||||
TVarArg ['resolution', 2]
|
||||
let [as, am] = a:a
|
||||
let [bs, bm] = a:b
|
||||
let rv = 0 + (as - bs)
|
||||
if resolution > 0
|
||||
let rv .= repeat('0', resolution)
|
||||
let am = am[0 : resolution - 1]
|
||||
let bm = bm[0 : resolution - 1]
|
||||
let rv += (am - bm)
|
||||
endif
|
||||
return rv
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#time#DiffMSecs(a, b, ...) "{{{3
|
||||
TVarArg ['resolution', 2]
|
||||
if a:a == a:b
|
||||
return 0
|
||||
endif
|
||||
let a = printf('%30s', a:a[0 : -(7 - resolution)])
|
||||
let b = printf('%30s', a:b[0 : -(7 - resolution)])
|
||||
for i in range(0, 29)
|
||||
if a[i] != b[i]
|
||||
let a = a[i : -1]
|
||||
let b = b[i : -1]
|
||||
return a - b
|
||||
endif
|
||||
endfor
|
||||
return 0
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#time#Command(cmd, ...) abort "{{{3
|
||||
let loops = a:0 >= 1 ? a:1 : 1
|
||||
let silent = a:0 >= 1 ? a:1 : 0
|
||||
let start = tlib#time#Now()
|
||||
for loop in range(loops)
|
||||
if silent
|
||||
silent! exec a:cmd
|
||||
else
|
||||
exec a:cmd
|
||||
endif
|
||||
endfor
|
||||
let end = tlib#time#Now()
|
||||
let diff = tlib#time#Diff(end, start)
|
||||
echom 'Time:' diff
|
||||
return diff
|
||||
endf
|
||||
|
||||
@ -1,198 +0,0 @@
|
||||
" @Author: Tom Link (mailto:micathom AT gmail com?subject=[vim])
|
||||
" @Website: https://github.com/tomtom
|
||||
" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
|
||||
" @Last Change: 2017-03-09
|
||||
" @Revision: 205
|
||||
|
||||
|
||||
if !exists('g:tlib#trace#backtrace')
|
||||
" The length of the backtrace that should be included in
|
||||
" |tlib#trace#Print()|.
|
||||
let g:tlib#trace#backtrace = 2 "{{{2
|
||||
endif
|
||||
|
||||
|
||||
if !exists('g:tlib#trace#printer')
|
||||
" Possible values:
|
||||
" - 'echom'
|
||||
" - ['file', FILENAME]
|
||||
let g:tlib#trace#printer = 'echom' "{{{2
|
||||
endif
|
||||
|
||||
|
||||
if !exists('g:tlib#trace#hl')
|
||||
let g:tlib#trace#hl = {'error': 'ErrorMsg', 'fatal': 'ErrorMsg', 'warn': 'WarningMsg'} "{{{2
|
||||
endif
|
||||
|
||||
|
||||
" Print traces from |tlib#trace#Print()|.
|
||||
function! tlib#trace#Printer_echom(type, text, args) abort "{{{3
|
||||
let hl = get(g:tlib#trace#hl, a:type, '')
|
||||
try
|
||||
if !empty(hl)
|
||||
exec 'echohl' hl
|
||||
endif
|
||||
echom a:text
|
||||
finally
|
||||
if !empty(hl)
|
||||
echohl NONE
|
||||
endif
|
||||
endtry
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#trace#Printer_file(type, text, args) abort "{{{3
|
||||
let filename = get(a:args, 0, '')
|
||||
if exists(filename) && !filewritable(filename)
|
||||
throw 'tlib#trace#Printer_file: Cannot write to file: '. filename
|
||||
else
|
||||
call writefile([a:text], filename, 'a')
|
||||
endif
|
||||
endf
|
||||
|
||||
|
||||
" Set the tracing |regexp|. See |:Tlibtrace|.
|
||||
" This will also call |tlib#trace#Enable()|.
|
||||
"
|
||||
" Examples:
|
||||
" call tlib#trace#Set(["+foo", "-bar"])
|
||||
" call tlib#trace#Set("+foo,-bar")
|
||||
function! tlib#trace#Set(vars, ...) abort "{{{3
|
||||
let reset = a:0 >= 1 ? a:1 : 0
|
||||
if reset
|
||||
call tlib#trace#Reset()
|
||||
endif
|
||||
if empty(a:vars)
|
||||
return
|
||||
endif
|
||||
call tlib#trace#Enable()
|
||||
if type(a:vars) == v:t_string
|
||||
let vars = tlib#string#SplitCommaList(a:vars, '[,[:space:]]\+')
|
||||
let opts = {}
|
||||
elseif type(a:vars) == v:t_dict
|
||||
let vars = a:vars.__rest__
|
||||
if has_key(a:vars, 'file')
|
||||
let g:tlib#trace#printer = ['file', a:vars.file]
|
||||
endif
|
||||
if has_key(a:vars, 'echo')
|
||||
let g:tlib#trace#printer = 'echom'
|
||||
endif
|
||||
else
|
||||
let vars = a:vars
|
||||
let opts = {}
|
||||
endif
|
||||
" TLogVAR vars
|
||||
for rx in vars
|
||||
let rx1 = substitute(rx, '^[+-]', '', 'g')
|
||||
if rx1 !~# '^\%(error\|warn\|fatal\)$'
|
||||
let erx1 = tlib#rx#Escape(rx1)
|
||||
" TLogVAR rx, rx1
|
||||
" echom "DBG" s:trace_rx
|
||||
if rx =~ '^-'
|
||||
let erx1 .= '\[0-\d\]\\?'
|
||||
if s:trace_rx =~# '[(|]'. erx1 .'\\'
|
||||
let s:trace_rx = substitute(s:trace_rx, '\\|'. erx1, '', '')
|
||||
endif
|
||||
" elseif rx =~ '^+'
|
||||
else
|
||||
if erx1 =~ '\d$'
|
||||
let erx1 = substitute(erx1, '\d$', '[0-\0]\\?', '')
|
||||
else
|
||||
let erx1 .= '[0-9]\?'
|
||||
endif
|
||||
if s:trace_rx !~# '[(|]'. erx1 .'\\'
|
||||
let s:trace_rx = substitute(s:trace_rx, '\ze\\)\$', '\\|'. escape(erx1, '\'), '')
|
||||
endif
|
||||
" else
|
||||
" echohl WarningMsg
|
||||
" echom 'tlib#trace#Print: Unsupported syntax:' rx
|
||||
" echohl NONE
|
||||
endif
|
||||
" echom "DBG" s:trace_rx
|
||||
endif
|
||||
endfor
|
||||
echom "SetTrace:" s:trace_rx
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#trace#Backtrace(caller) abort "{{{3
|
||||
let caller = split(a:caller, '\.\.')
|
||||
let start = max([0, len(caller) - g:tlib#trace#backtrace - 1])
|
||||
let caller = caller[start : -1]
|
||||
return join(caller, '..')
|
||||
endf
|
||||
|
||||
|
||||
" Print the values of vars. The first value is a "guard" (see
|
||||
" |:Tlibtrace|).
|
||||
function! tlib#trace#Print(caller, vars, values) abort "{{{3
|
||||
" echom "DBG tlib#trace#Print" string(a:vars) string(a:values)
|
||||
let msg = ['TRACE']
|
||||
let guard = a:values[0]
|
||||
if type(guard) == 0
|
||||
let cond = guard
|
||||
else
|
||||
let cond = guard =~# s:trace_rx
|
||||
endif
|
||||
" TLogVAR guard, cond, a:vars, a:values
|
||||
if cond
|
||||
call add(msg, guard)
|
||||
call add(msg, tlib#time#FormatNow() .':')
|
||||
if g:tlib#trace#backtrace > 0
|
||||
let bt = tlib#trace#Backtrace(a:caller)
|
||||
if !empty(bt)
|
||||
call add(msg, bt .':')
|
||||
endif
|
||||
endif
|
||||
if len(a:vars) == len(a:values)
|
||||
for i in range(1, len(a:vars) - 1)
|
||||
let v = substitute(a:vars[i], ',$', '', '')
|
||||
if type(a:values[i]) == v:t_func
|
||||
let r = string(a:values[i])
|
||||
else
|
||||
let r = a:values[i]
|
||||
endif
|
||||
if v =~# '^\([''"]\).\{-}\1$'
|
||||
call add(msg, r .';')
|
||||
else
|
||||
call add(msg, v .'='. string(r) .';')
|
||||
endif
|
||||
unlet r
|
||||
endfor
|
||||
else
|
||||
call add(msg, join(a:values[1:-1]))
|
||||
endif
|
||||
if type(g:tlib#trace#printer) == v:t_string
|
||||
let printer = g:tlib#trace#printer
|
||||
let args = []
|
||||
else
|
||||
let [printer; args] = g:tlib#trace#printer
|
||||
endif
|
||||
call tlib#trace#Printer_{printer}(guard, join(msg), args)
|
||||
endif
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#trace#Reset() abort "{{{3
|
||||
let s:trace_rx = '^\%(error\|fatal\|warn\|info\)$'
|
||||
let g:tlib#trace#printer = 'echom'
|
||||
endf
|
||||
|
||||
|
||||
" Enable tracing via |:Tlibtrace|.
|
||||
function! tlib#trace#Enable() abort "{{{3
|
||||
if !exists('s:trace_rx')
|
||||
call tlib#trace#Reset()
|
||||
" :nodoc:
|
||||
command! -nargs=+ -bang Tlibtrace call tlib#trace#Print(expand('<sfile>'), [<f-args>], [<args>])
|
||||
endif
|
||||
endf
|
||||
|
||||
|
||||
" Disable tracing via |:Tlibtrace|.
|
||||
function! tlib#trace#Disable() abort "{{{3
|
||||
" :nodoc:
|
||||
command! -nargs=+ -bang Tlibtrace :
|
||||
unlet! s:trace_rx
|
||||
endf
|
||||
|
||||
@ -1,142 +0,0 @@
|
||||
" @Author: Tom Link (mailto:micathom AT gmail com?subject=[vim])
|
||||
" @Website: http://www.vim.org/account/profile.php?user_id=4037
|
||||
" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
|
||||
" @Created: 2007-09-30.
|
||||
" @Last Change: 2017-02-22.
|
||||
" @Revision: 57
|
||||
|
||||
|
||||
let g:tlib#type#nil = []
|
||||
|
||||
|
||||
" Enable type assertiona via |:Tlibtype|.
|
||||
function! tlib#type#Enable() abort "{{{3
|
||||
" :nodoc:
|
||||
command! -nargs=+ Tlibtype call tlib#type#Check(expand('<sfile>'), [<f-args>], [<args>])
|
||||
endf
|
||||
|
||||
|
||||
" Disable type assertiona via |:Tlibtype|.
|
||||
function! tlib#type#Disable() abort "{{{3
|
||||
" :nodoc:
|
||||
command! -nargs=+ Tlibtype :
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#type#IsNil(expr) abort "{{{3
|
||||
return tlib#type#Is(a:expr, v:t_none) || a:expr is g:tlib#type#nil
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#type#IsNumber(expr)
|
||||
return tlib#type#Is(a:expr, 0)
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#type#IsString(expr)
|
||||
return tlib#type#Is(a:expr, 1)
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#type#IsFuncref(expr)
|
||||
return tlib#type#Is(a:expr, 2)
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#type#IsList(expr)
|
||||
return tlib#type#Is(a:expr, 3)
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#type#IsDictionary(expr)
|
||||
return tlib#type#Is(a:expr, 4)
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#type#Is(val, type) abort "{{{3
|
||||
if has_key(s:schemas, a:type)
|
||||
return tlib#type#Has(a:val, a:type)
|
||||
else
|
||||
if type(a:type) == 0
|
||||
let type = a:type
|
||||
elseif a:type =~? '^b\%[oolean]$'
|
||||
let type = v:t_bool
|
||||
elseif a:type =~? '^c\%[hannel]$'
|
||||
let type = v:t_channel
|
||||
elseif a:type =~? '^d\%[ictionary]$'
|
||||
let type = v:t_dict
|
||||
elseif a:type =~? '^fl\%[oat]$'
|
||||
let type = v:t_float
|
||||
elseif a:type =~? '^fu\%[ncref]$'
|
||||
let type = v:t_func
|
||||
elseif a:type =~? '^j\%[ob]$'
|
||||
let type = v:t_job
|
||||
elseif a:type =~? '^l\%[ist]$'
|
||||
let type = v:t_list
|
||||
elseif a:type =~? '^\%(nil\|null\|none\)$'
|
||||
let type = v:t_none
|
||||
elseif a:type =~? '^n\%[umber]$'
|
||||
let type = v:t_number
|
||||
elseif a:type =~? '^s\%[tring]$'
|
||||
let type = v:t_string
|
||||
else
|
||||
throw 'tlib#type#Is: Unknown type: ' a:type
|
||||
endif
|
||||
Tlibtrace 'tlib', a:val, a:type, type, type(a:val), type(a:val) == a:type
|
||||
return type(a:val) == type
|
||||
endif
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#type#Are(vals, type) abort "{{{3
|
||||
return tlib#assert#Map(a:vals, 'tlib#type#Is(v:val,'. string(a:type) .')')
|
||||
endf
|
||||
|
||||
|
||||
let s:schemas = {}
|
||||
|
||||
|
||||
function! tlib#type#Define(name, schema) abort "{{{3
|
||||
let s:schemas[a:name] = deepcopy(a:schema)
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#type#Has(val, schema) abort "{{{3
|
||||
Tlibtrace 'tlib', type(a:val), type(a:schema)
|
||||
if !tlib#type#IsDictionary(a:val)
|
||||
Tlibtrace 'tlib', 'not a dictionary', a:val
|
||||
return 0
|
||||
endif
|
||||
if tlib#type#IsString(a:schema)
|
||||
Tlibtrace 'tlib', a:schema
|
||||
let schema = copy(s:schemas[a:schema])
|
||||
else
|
||||
let schema = copy(a:schema)
|
||||
endif
|
||||
if tlib#type#IsDictionary(schema)
|
||||
return tlib#assert#All(map(schema, 'has_key(a:val, v:key) && tlib#type#Is(a:val[v:key], v:val)'))
|
||||
else
|
||||
Tlibtrace 'tlib', keys(a:val), schema
|
||||
return tlib#assert#All(map(schema, 'has_key(a:val, v:val)'))
|
||||
endif
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#type#Have(vals, schema) abort "{{{3
|
||||
return tlib#assert#Map(a:vals, 'tlib#type#Has(v:val,'. string(a:schema) .')')
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#type#Check(caller, names, vals) abort "{{{3
|
||||
Tlibtrace 'tlib', a:names, a:vals, len(a:names)
|
||||
for i in range(0, len(a:names) - 1, 2)
|
||||
let val = a:vals[i]
|
||||
let type = a:vals[i + 1]
|
||||
Tlibtrace 'tlib', i, val, type
|
||||
if !tlib#type#Is(val, type)
|
||||
let name = matchstr(a:names[i], '^''\zs.\{-}\ze'',\?$')
|
||||
throw 'tlib#type#Check: Type mismatch: '. name .':'. a:vals[i + 1]
|
||||
endif
|
||||
endfor
|
||||
endf
|
||||
|
||||
@ -1,52 +0,0 @@
|
||||
" url.vim
|
||||
" @Author: Tom Link (micathom AT gmail com?subject=[vim])
|
||||
" @Website: http://www.vim.org/account/profile.php?user_id=4037
|
||||
" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
|
||||
" @Created: 2007-06-30.
|
||||
" @Last Change: 2011-03-10.
|
||||
" @Revision: 0.0.28
|
||||
|
||||
|
||||
" TODO: These functions could use printf() now.
|
||||
|
||||
" Decode an encoded URL.
|
||||
function! tlib#url#Decode(url) "{{{3
|
||||
return substitute(a:url, '\(+\|%\(%\|\x\x\)\)', '\=tlib#url#DecodeChar(submatch(1))', 'g')
|
||||
endf
|
||||
|
||||
|
||||
" Decode a single character.
|
||||
function! tlib#url#DecodeChar(char) "{{{3
|
||||
if a:char == '%%'
|
||||
return '%'
|
||||
elseif a:char == '+'
|
||||
return ' '
|
||||
else
|
||||
return nr2char("0x".a:char[1 : -1])
|
||||
endif
|
||||
endf
|
||||
|
||||
|
||||
" Encode a single character.
|
||||
function! tlib#url#EncodeChar(char) "{{{3
|
||||
if a:char == '%'
|
||||
return '%%'
|
||||
elseif a:char == ' '
|
||||
return '+'
|
||||
else
|
||||
return printf("%%%X", char2nr(a:char))
|
||||
endif
|
||||
endf
|
||||
|
||||
|
||||
" Encode an URL.
|
||||
function! tlib#url#Encode(url, ...) "{{{3
|
||||
TVarArg ['extrachars', '']
|
||||
let rx = '\([^a-zA-Z0-9_.'. extrachars .'-]\)'
|
||||
" TLogVAR a:url, rx
|
||||
let rv = substitute(a:url, rx, '\=tlib#url#EncodeChar(submatch(1))', 'g')
|
||||
" TLogVAR rv
|
||||
return rv
|
||||
endf
|
||||
|
||||
|
||||
@ -1,90 +0,0 @@
|
||||
" @Author: Tom Link (micathom AT gmail com?subject=[vim])
|
||||
" @Website: http://www.vim.org/account/profile.php?user_id=4037
|
||||
" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
|
||||
" @Revision: 34
|
||||
|
||||
|
||||
" Define a variable called NAME if yet undefined.
|
||||
" You can also use the :TLLet command.
|
||||
"
|
||||
" EXAMPLES: >
|
||||
" exec tlib#var#Let('g:foo', 1)
|
||||
" TLet g:foo = 1
|
||||
function! tlib#var#Let(name, val) "{{{3
|
||||
return printf('if !exists(%s) | let %s = %s | endif', string(a:name), a:name, string(a:val))
|
||||
" return printf('if !exists(%s) | let %s = %s | endif', string(a:name), a:name, a:val)
|
||||
endf
|
||||
|
||||
|
||||
" :def: function! tlib#var#EGet(var, namespace, ?default='')
|
||||
" Retrieve a variable by searching several namespaces.
|
||||
"
|
||||
" EXAMPLES: >
|
||||
" let g:foo = 1
|
||||
" let b:foo = 2
|
||||
" let w:foo = 3
|
||||
" echo eval(tlib#var#EGet('foo', 'vg')) => 1
|
||||
" echo eval(tlib#var#EGet('foo', 'bg')) => 2
|
||||
" echo eval(tlib#var#EGet('foo', 'wbg')) => 3
|
||||
function! tlib#var#EGet(var, namespace, ...) "{{{3
|
||||
let pre = []
|
||||
let post = []
|
||||
for namespace in split(a:namespace, '\zs')
|
||||
let var = namespace .':'. a:var
|
||||
call add(pre, printf('exists("%s") ? %s : (', var, var))
|
||||
call add(post, ')')
|
||||
endfor
|
||||
let default = a:0 >= 1 ? a:1 : ''
|
||||
return join(pre) . string(default) . join(post)
|
||||
endf
|
||||
|
||||
|
||||
" :def: function! tlib#var#Get(var, namespace, ?default='')
|
||||
" Retrieve a variable by searching several namespaces.
|
||||
"
|
||||
" EXAMPLES: >
|
||||
" let g:foo = 1
|
||||
" let b:foo = 2
|
||||
" let w:foo = 3
|
||||
" echo tlib#var#Get('foo', 'bg') => 1
|
||||
" echo tlib#var#Get('foo', 'bg') => 2
|
||||
" echo tlib#var#Get('foo', 'wbg') => 3
|
||||
function! tlib#var#Get(var, namespace, ...) "{{{3
|
||||
let var_ = substitute(a:var, '#', '_', 'g')
|
||||
for namespace in split(a:namespace, '\zs')
|
||||
let vname = namespace ==# 'g' ? a:var : var_
|
||||
let var = namespace .':'. vname
|
||||
if exists(var)
|
||||
return {var}
|
||||
elseif namespace ==# 'g'
|
||||
try
|
||||
let val = {var}
|
||||
catch /^Vim\%((\a\+)\)\=:E\(121\|15\)/
|
||||
continue
|
||||
endtry
|
||||
return val
|
||||
endif
|
||||
endfor
|
||||
return a:0 >= 1 ? a:1 : ''
|
||||
endf
|
||||
|
||||
|
||||
" :def: function! tlib#var#List(rx, ?prefix='')
|
||||
" Get a list of variables matching rx.
|
||||
" EXAMPLE:
|
||||
" echo tlib#var#List('tlib_', 'g:')
|
||||
function! tlib#var#List(rx, ...) "{{{3
|
||||
TVarArg ['prefix', 'g:']
|
||||
if v:version >= 704
|
||||
exec 'let varlist = keys('. prefix .')'
|
||||
else
|
||||
redir => vars
|
||||
silent! exec 'let '. prefix
|
||||
redir END
|
||||
let varlist = split(vars, '\n')
|
||||
call map(varlist, 'matchstr(v:val, ''^\S\+'')')
|
||||
endif
|
||||
call filter(varlist, 'v:val =~ a:rx')
|
||||
return varlist
|
||||
endf
|
||||
|
||||
@ -1,230 +0,0 @@
|
||||
" @Author: Tom Link (mailto:micathom AT gmail com?subject=[vim])
|
||||
" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
|
||||
" @Created: 2012-03-08.
|
||||
" @Last Change: 2017-04-10.
|
||||
" @Revision: 224
|
||||
|
||||
scriptencoding utf-8
|
||||
|
||||
|
||||
" A dictionarie of supported VCS (currently: git, hg, svn, bzr).
|
||||
" :display: g:tlib#vcs#def {...}
|
||||
TLet g:tlib#vcs#def = {
|
||||
\ 'git': {
|
||||
\ 'dir': '.git',
|
||||
\ 'ls': 'git ls-files --full-name',
|
||||
\ 'ls.postprocess': '*tlib#vcs#GitLsPostprocess',
|
||||
\ 'diff': 'git diff --no-ext-diff -U0 %s',
|
||||
\ 'status': 'git status -s',
|
||||
\ 'status.filterrx': '^\C[ MADRCU!?]\{2}\s'},
|
||||
\ 'hg': {
|
||||
\ 'dir': '.hg',
|
||||
\ 'diff': 'hg diff -U0 %s',
|
||||
\ 'ls': 'hg manifest'},
|
||||
\ 'svn': {
|
||||
\ 'dir': '.svn',
|
||||
\ 'diff': 'svn diff --diff-cmd diff --extensions -U0 %s'},
|
||||
\ 'bzr': {
|
||||
\ 'dir': '.bzr',
|
||||
\ 'diff': 'bzr diff --diff-options=-U0 %s'}
|
||||
\ }
|
||||
|
||||
|
||||
" A dictionary of custom executables for VCS commands. If the value is
|
||||
" empty, support for that VCS will be removed. If no key is present, it
|
||||
" is assumed that the VCS "type" is the name of the executable.
|
||||
" :display: g:tlib#vcs#executables {...}
|
||||
TLet g:tlib#vcs#executables = {}
|
||||
|
||||
|
||||
" If non-empty, use it as a format string to check whether a VCS is
|
||||
" installed on your computer.
|
||||
TLet g:tlib#vcs#check = has('win16') || has('win32') || has('win64') ? '%s.exe' : '%s'
|
||||
|
||||
|
||||
if !empty(g:tlib#vcs#check)
|
||||
for [s:cmd, s:def] in items(g:tlib#vcs#def)
|
||||
if !has_key(g:tlib#vcs#executables, s:cmd)
|
||||
let s:cmd1 = printf(g:tlib#vcs#check, s:cmd)
|
||||
let g:tlib#vcs#executables[s:cmd] = executable(s:cmd1) ? s:cmd1 : ''
|
||||
endif
|
||||
endfor
|
||||
unlet! s:cmd s:def s:cmd1
|
||||
endif
|
||||
|
||||
|
||||
function! tlib#vcs#Executable(type) "{{{3
|
||||
return get(g:tlib#vcs#executables, a:type, '')
|
||||
endf
|
||||
|
||||
|
||||
let s:vcs_cache = {}
|
||||
autocmd TLib FocusGained * let s:vcs_cache = {}
|
||||
|
||||
|
||||
function! tlib#vcs#FindVCS(filename) "{{{3
|
||||
let type = ''
|
||||
let dir = ''
|
||||
let filename = fnamemodify(a:filename, ':p')
|
||||
let dirname = isdirectory(filename) ? filename : fnamemodify(filename, ':h')
|
||||
if !has_key(s:vcs_cache, dirname)
|
||||
let path = escape(dirname, ';') .';'
|
||||
" TLogVAR filename, dirname, path
|
||||
Tlibtrace 'tlib', filename, path
|
||||
let depth = -1
|
||||
for vcs in keys(g:tlib#vcs#def)
|
||||
let subdir = g:tlib#vcs#def[vcs].dir
|
||||
let vcsdir = finddir(subdir, path)
|
||||
" TLogVAR vcs, subdir, vcsdir
|
||||
Tlibtrace 'tlib', vcs, subdir, vcsdir
|
||||
if !empty(vcsdir)
|
||||
let vcsdir_depth = len(split(fnamemodify(vcsdir, ':p'), '\/'))
|
||||
if vcsdir_depth > depth
|
||||
let depth = vcsdir_depth
|
||||
let type = vcs
|
||||
let dir = vcsdir
|
||||
" TLogVAR type, depth
|
||||
endif
|
||||
endif
|
||||
endfor
|
||||
Tlibtrace 'tlib', type, dir
|
||||
" TLogVAR type, dir
|
||||
if empty(type)
|
||||
let s:vcs_cache[dirname] = ['', '']
|
||||
else
|
||||
let s:vcs_cache[dirname] = [type, dir]
|
||||
endif
|
||||
endif
|
||||
return s:vcs_cache[dirname]
|
||||
endf
|
||||
|
||||
|
||||
function! s:GetCmd(vcstype, cmd)
|
||||
let vcsdef = get(g:tlib#vcs#def, a:vcstype, {})
|
||||
if has_key(vcsdef, a:cmd)
|
||||
let cmd = vcsdef[a:cmd]
|
||||
if cmd =~# '^\*'
|
||||
let cmd = substitute(cmd, '^\*', '', '')
|
||||
else
|
||||
let bin = get(g:tlib#vcs#executables, a:vcstype, '')
|
||||
if empty(bin)
|
||||
let cmd = ''
|
||||
elseif bin != a:vcstype
|
||||
" let bin = escape(shellescape(bin), '\')
|
||||
let bin = escape(bin, '\')
|
||||
let cmd = substitute(cmd, '^.\{-}\zs'. escape(a:vcstype, '\'), bin, '')
|
||||
endif
|
||||
endif
|
||||
return cmd
|
||||
else
|
||||
return ''
|
||||
endif
|
||||
endf
|
||||
|
||||
|
||||
" :display: tlib#vcs#Ls(?filename=bufname('%'), ?vcs=[type, dir])
|
||||
" Return the files under VCS.
|
||||
function! tlib#vcs#Ls(...) "{{{3
|
||||
if a:0 >= 2
|
||||
let vcs = a:2
|
||||
else
|
||||
let vcs = tlib#vcs#FindVCS(a:0 >= 1 ? a:1 : bufname('%'))
|
||||
endif
|
||||
Tlibtrace 'tlib', vcs, a:000
|
||||
" TLogVAR vcs
|
||||
if !empty(vcs)
|
||||
let [vcstype, vcsdir] = vcs
|
||||
if has_key(g:tlib#vcs#def, vcstype)
|
||||
let ls = s:GetCmd(vcstype, 'ls')
|
||||
" TLogVAR ls
|
||||
if !empty(ls)
|
||||
let rootdir = fnamemodify(vcsdir, ':p:h:h')
|
||||
" TLogVAR vcsdir, rootdir
|
||||
if ls =~# '%s'
|
||||
let cmd = printf(ls, shellescape(rootdir))
|
||||
else
|
||||
let cmd = ls
|
||||
endif
|
||||
" TLogVAR cmd, getcwd()
|
||||
Tlibtrace 'tlib', getcwd(), vcstype, vcsdir, rootdir, cmd
|
||||
let filess = tlib#sys#SystemInDir(rootdir, cmd)
|
||||
" TLogVAR filess
|
||||
let files = split(filess, '\n')
|
||||
let postprocess = s:GetCmd(vcstype, 'ls.postprocess')
|
||||
if !empty(postprocess)
|
||||
call map(files, 'call(postprocess, [v:val])')
|
||||
endif
|
||||
call map(files, 'join([rootdir, v:val], "/")')
|
||||
" TLogVAR files
|
||||
return files
|
||||
endif
|
||||
endif
|
||||
endif
|
||||
return []
|
||||
endf
|
||||
|
||||
|
||||
" :display: tlib#vcs#Diff(filename, ?vcs=[type, dir])
|
||||
" Return the diff for "filename"
|
||||
function! tlib#vcs#Diff(filename, ...) "{{{3
|
||||
let vcs = a:0 >= 1 ? a:1 : tlib#vcs#FindVCS(a:filename)
|
||||
if !empty(vcs)
|
||||
let [vcstype, vcsdir] = vcs
|
||||
let diff = s:GetCmd(vcstype, 'diff')
|
||||
if !empty(diff)
|
||||
let cmd = printf(diff, shellescape(fnamemodify(a:filename, ':p')))
|
||||
let patch = system(cmd)
|
||||
return patch
|
||||
endif
|
||||
endif
|
||||
return []
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#vcs#GitLsPostprocess(filename) abort "{{{3
|
||||
if a:filename =~# '^".\{-}"$'
|
||||
let filename = matchstr(a:filename, '^"\zs.\{-}\ze"$')
|
||||
let filename = substitute(filename, '\%(\\\@<!\\\(\d\d\d\)\)\+', '\=eval(''"''. submatch(0) .''"'')', 'g')
|
||||
" let filename = eval(a:filename)
|
||||
" TLogVAR a:filename, filename, &enc
|
||||
return filename
|
||||
else
|
||||
return a:filename
|
||||
endif
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#vcs#Status(...) abort "{{{3
|
||||
let filename = a:0 >= 1 ? a:1 : '%'
|
||||
let vcs = a:0 >= 2 ? a:2 : tlib#vcs#FindVCS(filename)
|
||||
if !empty(vcs)
|
||||
let [vcstype, vcsdir] = vcs
|
||||
let cstatus = s:GetCmd(vcstype, 'status')
|
||||
if !empty(cstatus)
|
||||
let status = exists('*systemlist') ? systemlist(cstatus) : split(system(cstatus), '\n')
|
||||
let sfilter = s:GetCmd(vcstype, 'status.filterrx')
|
||||
if !empty(sfilter)
|
||||
let status = filter(status, 'v:val =~# sfilter')
|
||||
endif
|
||||
return status
|
||||
endif
|
||||
endif
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#vcs#IsDirty(...) abort "{{{3
|
||||
let filename = a:0 >= 1 ? a:1 : '%'
|
||||
let vcs = a:0 >= 2 ? a:2 : tlib#vcs#FindVCS(filename)
|
||||
let status = tlib#vcs#Status(filename, vcs)
|
||||
return empty(status) ? '' : vcs[0] .'!'
|
||||
endf
|
||||
|
||||
|
||||
" function! tlib#vcs#EnableTStatus() abort "{{{3
|
||||
" if has('vim_starting')
|
||||
" autocmd VimEnter * TStatusregister1 --event=FocusGained,BufRead,BufWritePost %s tlib#vcs#IsDirty()
|
||||
" else
|
||||
" TStatusregister1 --event=FocusGained,BufRead,BufWritePost %s tlib#vcs#IsDirty()
|
||||
" endif
|
||||
" endf
|
||||
|
||||
@ -1,152 +0,0 @@
|
||||
" @Author: Tom Link (micathom AT gmail com?subject=[vim])
|
||||
" @Website: http://www.vim.org/account/profile.php?user_id=4037
|
||||
" @GIT: http://github.com/tomtom/tlib_vim/
|
||||
" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
|
||||
" @Created: 2010-07-19.
|
||||
" @Last Change: 2012-06-08.
|
||||
" @Revision: 37
|
||||
|
||||
|
||||
let s:restoreframecmd = ''
|
||||
let s:fullscreen = 0
|
||||
|
||||
if has('win16') || has('win32') || has('win64')
|
||||
|
||||
if !exists('g:tlib#vim#simalt_maximize')
|
||||
" The alt-key for maximizing the window.
|
||||
" CAUTION: The value of this paramter depends on your locale and
|
||||
" maybe the windows version you are running.
|
||||
let g:tlib#vim#simalt_maximize = 'x' "{{{2
|
||||
endif
|
||||
|
||||
if !exists('g:tlib#vim#simalt_restore')
|
||||
" The alt-key for restoring the window.
|
||||
" CAUTION: The value of this paramter depends on your locale and
|
||||
" maybe the windows version you are running.
|
||||
let g:tlib#vim#simalt_restore = 'r' "{{{2
|
||||
endif
|
||||
|
||||
if !exists('g:tlib#vim#use_vimtweak')
|
||||
" If true, use the vimtweak.dll for windows. This will enable
|
||||
" tlib to remove the caption for fullscreen windows.
|
||||
let g:tlib#vim#use_vimtweak = 0 "{{{2
|
||||
endif
|
||||
|
||||
" Maximize the window.
|
||||
" You might need to redefine |g:tlib#vim#simalt_maximize| if it doesn't
|
||||
" work for you.
|
||||
fun! tlib#vim#Maximize(fullscreen) "{{{3
|
||||
if !has("gui_running")
|
||||
return
|
||||
endif
|
||||
call s:SaveFrameParams()
|
||||
let s:fullscreen = a:fullscreen
|
||||
if g:tlib#vim#use_vimtweak && a:fullscreen
|
||||
call libcallnr("vimtweak.dll", "EnableCaption", 0)
|
||||
endif
|
||||
exec 'simalt ~'. g:tlib#vim#simalt_maximize
|
||||
endf
|
||||
|
||||
" Restore the original vimsize after having called |tlib#vim#Maximize()|.
|
||||
function! tlib#vim#RestoreWindow() "{{{3
|
||||
if !has("gui_running")
|
||||
return
|
||||
endif
|
||||
if g:tlib#vim#use_vimtweak
|
||||
call libcallnr("vimtweak.dll", "EnableCaption", 1)
|
||||
endif
|
||||
exec 'simalt ~'. g:tlib#vim#simalt_restore
|
||||
call s:RestoreFrameParams()
|
||||
endf
|
||||
|
||||
else
|
||||
|
||||
if !exists('g:tlib#vim#use_wmctrl')
|
||||
" If true, use wmctrl for X windows to make a window
|
||||
" maximized/fullscreen.
|
||||
"
|
||||
" This is the preferred method for maximizing windows under X
|
||||
" windows. Some window managers have problem coping with the
|
||||
" default method of setting 'lines' and 'columns' to a large
|
||||
" value.
|
||||
let g:tlib#vim#use_wmctrl = executable('wmctrl') "{{{2
|
||||
endif
|
||||
|
||||
" :nodoc:
|
||||
fun! tlib#vim#Maximize(fullscreen) "{{{3
|
||||
if !has("gui_running")
|
||||
return
|
||||
endif
|
||||
call s:SaveFrameParams()
|
||||
let s:fullscreen = a:fullscreen
|
||||
if g:tlib#vim#use_wmctrl
|
||||
if a:fullscreen
|
||||
silent !wmctrl -r :ACTIVE: -b add,fullscreen
|
||||
else
|
||||
silent !wmctrl -r :ACTIVE: -b add,maximized_vert,maximized_horz
|
||||
endif
|
||||
else
|
||||
set lines=1000 columns=1000
|
||||
endif
|
||||
endf
|
||||
|
||||
" :nodoc:
|
||||
function! tlib#vim#RestoreWindow() "{{{3
|
||||
if !has("gui_running")
|
||||
return
|
||||
endif
|
||||
if g:tlib#vim#use_wmctrl
|
||||
if s:fullscreen
|
||||
silent !wmctrl -r :ACTIVE: -b remove,fullscreen
|
||||
else
|
||||
silent !wmctrl -r :ACTIVE: -b remove,maximized_vert,maximized_horz
|
||||
endif
|
||||
endif
|
||||
call s:RestoreFrameParams()
|
||||
endf
|
||||
|
||||
endif
|
||||
|
||||
|
||||
function! s:SaveFrameParams() "{{{3
|
||||
let s:restoreframecmd = printf("set lines=%d columns=%d | winpos %d %d", &lines, &columns, getwinposx(), getwinposy())
|
||||
endf
|
||||
|
||||
|
||||
function! s:RestoreFrameParams() "{{{3
|
||||
if !empty(s:restoreframecmd)
|
||||
exec s:restoreframecmd
|
||||
let s:restoreframecmd = ''
|
||||
endif
|
||||
endf
|
||||
|
||||
|
||||
" :display: tlib#vim##CopyFunction(old, new, overwrite=0)
|
||||
function! tlib#vim#CopyFunction(old, new, ...) "{{{3
|
||||
let overwrite = a:0 >= 1 ? a:1 : 0
|
||||
redir => oldfn
|
||||
exec 'silent function' a:old
|
||||
redir END
|
||||
if exists('*'. a:new)
|
||||
if overwrite > 0
|
||||
exec 'delfunction' a:new
|
||||
elseif overwrite < 0
|
||||
throw 'tlib#vim##CopyFunction: Function already exists: '. a:old .' -> '. a:new
|
||||
else
|
||||
return
|
||||
endif
|
||||
endif
|
||||
let fn = split(oldfn, '\n')
|
||||
let fn = map(fn, 'substitute(v:val, ''^\d\+'', "", "")')
|
||||
let fn[0] = substitute(fn[0], '\V\^\s\*fu\%[nction]!\?\s\+\zs'. a:old, a:new, '')
|
||||
let t = @t
|
||||
try
|
||||
let @t = join(fn, "\n")
|
||||
redir => out
|
||||
@t
|
||||
redir END
|
||||
finally
|
||||
let @t = t
|
||||
endtry
|
||||
endf
|
||||
|
||||
@ -1,201 +0,0 @@
|
||||
" @Author: Tom Link (micathom AT gmail com?subject=[vim])
|
||||
" @Website: http://www.vim.org/account/profile.php?user_id=4037
|
||||
" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
|
||||
" @Revision: 84
|
||||
|
||||
|
||||
if !exists('g:tlib#win#use_winid')
|
||||
let g:tlib#win#use_winid = exists('*win_gotoid') && exists('*win_getid') "{{{2
|
||||
endif
|
||||
|
||||
|
||||
" Return vim code to jump back to the original window.
|
||||
function! tlib#win#Set(winnr) "{{{3
|
||||
if a:winnr > 0
|
||||
" TLogVAR a:winnr
|
||||
" TLogDBG winnr()
|
||||
" TLogDBG string(tlib#win#List())
|
||||
if winnr() != a:winnr && winbufnr(a:winnr) != -1
|
||||
let rv = winnr().'wincmd w'
|
||||
exec a:winnr .'wincmd w'
|
||||
" TLogVAR rv
|
||||
" TLogDBG string(tlib#win#List())
|
||||
return rv
|
||||
endif
|
||||
endif
|
||||
return ''
|
||||
endf
|
||||
|
||||
|
||||
if g:tlib#win#use_winid
|
||||
let g:tlib#win#null_id = -1
|
||||
function! tlib#win#GetID() abort "{{{3
|
||||
return win_getid()
|
||||
endf
|
||||
function! tlib#win#GotoID(win_id) abort "{{{3
|
||||
call win_gotoid(a:win_id)
|
||||
endf
|
||||
else
|
||||
let s:win_id = 0
|
||||
let g:tlib#win#null_id = {}
|
||||
function! tlib#win#GetID() abort "{{{3
|
||||
if !exists('w:tlib_win_id')
|
||||
let s:win_id += 1
|
||||
let w:tlib_win_id = s:win_id
|
||||
endif
|
||||
return {'tabpagenr': tabpagenr(), 'bufnr': bufnr('%'), 'winnr': winnr(), 'win_id': w:tlib_win_id}
|
||||
endf
|
||||
function! tlib#win#GotoID(win_id) abort "{{{3
|
||||
Tlibtrace 'tlib', a:win_id
|
||||
if tabpagenr() != a:win_id.tabpagenr
|
||||
exec 'tabnext' a:win_id.tabpagenr
|
||||
endif
|
||||
for wnr in range(1, winnr('$'))
|
||||
let win_id = getwinvar(wnr, 'tlib_win_id', -1)
|
||||
Tlibtrace 'tlib', wnr, win_id
|
||||
if win_id == a:win_id.win_id
|
||||
Tlibtrace 'tlib', wnr
|
||||
exec wnr 'wincmd w'
|
||||
return
|
||||
endif
|
||||
endfor
|
||||
" Was the window closed? What should we do now?
|
||||
if winnr() != a:win_id.winnr
|
||||
exec a:win_id.winnr 'wincmd w'
|
||||
endif
|
||||
if bufnr('%') != a:win_id.bufnr
|
||||
exec 'hide buffer' a:win_id.bufnr
|
||||
endif
|
||||
endf
|
||||
endif
|
||||
|
||||
|
||||
" Return vim code to jump back to the original window.
|
||||
function! tlib#win#SetById(win_id) "{{{3
|
||||
if a:win_id != g:tlib#win#null_id
|
||||
if g:tlib#win#use_winid
|
||||
let win_id = tlib#win#GetID()
|
||||
else
|
||||
let win_id = tlib#win#GetID().win_id
|
||||
endif
|
||||
call tlib#win#GotoID(a:win_id)
|
||||
return printf('call tlib#win#GotoID(%s)', win_id)
|
||||
" " TLogVAR a:winnr
|
||||
" " TLogDBG winnr()
|
||||
" " TLogDBG string(tlib#win#List())
|
||||
" if winnr() != a:winnr && winbufnr(a:winnr) != -1
|
||||
" let rv = winnr().'wincmd w'
|
||||
" exec a:winnr .'wincmd w'
|
||||
" " TLogVAR rv
|
||||
" " TLogDBG string(tlib#win#List())
|
||||
" return rv
|
||||
" endif
|
||||
endif
|
||||
return ''
|
||||
endf
|
||||
|
||||
|
||||
" :def: function! tlib#win#GetLayout(?save_view=0)
|
||||
function! tlib#win#GetLayout(...) "{{{3
|
||||
TVarArg ['save_view', 0]
|
||||
let views = {}
|
||||
if save_view
|
||||
let winnr = winnr()
|
||||
windo let views[winnr()] = winsaveview()
|
||||
" for w in range(1, winnr('$'))
|
||||
" call tlib#win#Set(w)
|
||||
" let views[w] = winsaveview()
|
||||
" endfor
|
||||
call tlib#win#Set(winnr)
|
||||
endif
|
||||
return {'winnr': winnr('$'), 'winrestcmd': winrestcmd(), 'views': views, 'cmdheight': &cmdheight, 'guioptions': &guioptions, 'tabpagenr': tabpagenr()}
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#win#SetLayout(layout) "{{{3
|
||||
if a:layout.tabpagenr == tabpagenr() && a:layout.winnr == winnr('$')
|
||||
" TLogVAR a:layout.winrestcmd
|
||||
" TLogDBG string(tlib#win#List())
|
||||
exec a:layout.winrestcmd
|
||||
if !empty(a:layout.views)
|
||||
let winnr = winnr()
|
||||
" TLogVAR winnr
|
||||
for [w, v] in items(a:layout.views)
|
||||
" TLogVAR w, v
|
||||
call tlib#win#Set(w)
|
||||
call winrestview(v)
|
||||
endfor
|
||||
call tlib#win#Set(winnr)
|
||||
endif
|
||||
if a:layout.cmdheight != &cmdheight
|
||||
let &cmdheight = a:layout.cmdheight
|
||||
endif
|
||||
" TLogDBG string(tlib#win#List())
|
||||
return 1
|
||||
endif
|
||||
return 0
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#win#List() "{{{3
|
||||
let wl = {}
|
||||
for wn in range(1, winnr('$'))
|
||||
let wl[wn] = bufname(winbufnr(wn))
|
||||
endfor
|
||||
return wl
|
||||
endf
|
||||
|
||||
|
||||
" " :def: function! tlib#win#GetLayout1(?save_view=0)
|
||||
" " Contrary to |tlib#win#GetLayout|, this version doesn't use
|
||||
" " |winrestcmd()|. It can also save windows views.
|
||||
" function! tlib#win#GetLayout1(...) "{{{3
|
||||
" TVarArg ['save_view', 0]
|
||||
" let winnr = winnr()
|
||||
" let acc = {}
|
||||
" for w in range(1, winnr('$'))
|
||||
" let def = {'h': winheight(w), 'w': winwidth(w)}
|
||||
" if save_view
|
||||
" call tlib#win#Set(w)
|
||||
" let def.view = winsaveview()
|
||||
" endif
|
||||
" let acc[w] = def
|
||||
" endfor
|
||||
" call tlib#win#Set(winnr)
|
||||
" return acc
|
||||
" endf
|
||||
"
|
||||
"
|
||||
" " Reset layout from the value of |tlib#win#GetLayout1|.
|
||||
" function! tlib#win#SetLayout1(layout) "{{{3
|
||||
" if len(a:layout) != winnr('$')
|
||||
" return 0
|
||||
" endif
|
||||
" let winnr = winnr()
|
||||
" for [w, def] in items(a:layout)
|
||||
" if tlib#win#Set(w)
|
||||
" exec 'resize '. def.h
|
||||
" exec 'vertical resize '. def.w
|
||||
" if has_key(def, 'view')
|
||||
" call winrestview(def.view)
|
||||
" endif
|
||||
" else
|
||||
" break
|
||||
" endif
|
||||
" endfor
|
||||
" call tlib#win#Set(winnr)
|
||||
" return 1
|
||||
" endf
|
||||
|
||||
|
||||
function! tlib#win#Width(wnr) "{{{3
|
||||
return winwidth(a:wnr) - &fdc
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#win#WinDo(ex) "{{{3
|
||||
let w = winnr()
|
||||
exec 'windo '. a:ex
|
||||
exec w .'wincmd w'
|
||||
endf
|
||||
|
||||
Reference in New Issue
Block a user