Removing snippet dependencies
This commit is contained in:
Mirosław Pragłowski
parent
d0cdc4cae0
commit
040b3b937f
|
|
@ -1,72 +0,0 @@
|
|||
This is a mirror of http://www.vim.org/scripts/script.php?script_id=1863
|
||||
|
||||
This library provides some utility functions. There isn't much need to
|
||||
install it unless another plugin requires you to do so.
|
||||
|
||||
The most useful functions provided by this library probably are:
|
||||
|
||||
tlib#input#List(), tlib#input#ListW()
|
||||
- Display a list
|
||||
- Dynamically filter items matching a pattern (somethat like google)
|
||||
- E.g. you filter for "foo -bar": show all entries containing foo but not bar.
|
||||
- Select items from a list
|
||||
- Do stuff
|
||||
- Developers can define keys that trigger some action with the
|
||||
selected items
|
||||
- Demo: http://vimsomnia.blogspot.com/2010/11/selecting-items-from-list-with-tlibs.html
|
||||
|
||||
tlib#input#EditList
|
||||
+ Edit a list (copy, cut, paste, delete, edit ...)
|
||||
|
||||
:TLet VAR = VALUE
|
||||
Set a variable only if it doesn't already exist.
|
||||
|
||||
:TScratch
|
||||
Open a scratch buffer (a buffer without a file).
|
||||
|
||||
:TVarArg VAR1, [VAR2, DEFAULT2] ...
|
||||
Handle "rest" (variable) arguments in functions.
|
||||
EXAMPLES:
|
||||
function! Foo(...)
|
||||
TVarArg ['a', 1], 'b'
|
||||
echo 'a='. a
|
||||
echo 'b='. b
|
||||
endf
|
||||
|
||||
TBrowseOutput COMMAND
|
||||
Every wondered how to effciently browse the output of a command
|
||||
without redirecting it to a file? This command takes a command as
|
||||
argument and presents the output via |tlib#input#List()| so that you
|
||||
can easily search for a keyword (e.g. the name of a variable or
|
||||
function) and the like.
|
||||
|
||||
If you press enter, the selected line will be copied to the command
|
||||
line. Press ESC to cancel browsing.
|
||||
|
||||
EXAMPLES:
|
||||
TBrowseOutput 20verb TeaseTheCulprit
|
||||
TBrowseOutput let
|
||||
TBrowseOutput map
|
||||
|
||||
|
||||
Related (small) plugins that utilize tlib and thus provide some degree of uniform user experience:
|
||||
tbibtools (vimscript #1915): bibtex-related utilities (sort, reformat, list contents ...)
|
||||
tmarks (vimscript #2594): Browse, place, & delete marks
|
||||
tmboxbrowser (vimscript #1906): A mbox browser -- Read your e-mails with vim
|
||||
tmru (vimscript #1864): Most Recently Used Files
|
||||
trag (vimscript #2033): A slightly language-aware alternative to grep
|
||||
tregisters (vimscript #2017): List, edit, and run/execute registers/clipboards
|
||||
tselectbuffer (vimscript #1866): A quick buffer selector/switcher
|
||||
tselectfiles (vimscript #1865): A quick file selector/browser/explorer (sort of)
|
||||
ttagecho (vimscript #2055): Show current tag information
|
||||
ttagcomplete (vimscript #2069): Context-sensitive tags-based completion and code skeletons
|
||||
ttags (vimscript #2018): Tag list browser (List, filter, preview, jump to tags)
|
||||
ttoc (vimscript #2014): A regexp-based table of contents of the current buffer
|
||||
vikitasks (vimscript #2894): Search viki files for tasks and display them in a list
|
||||
|
||||
|
||||
For full details, please see:
|
||||
http://github.com/tomtom/tlib_vim/blob/master/doc/tlib.txt
|
||||
|
||||
Also available via git
|
||||
http://github.com/tomtom/tlib_vim
|
||||
|
|
@ -1,11 +0,0 @@
|
|||
" tlib.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-07-17.
|
||||
" @Last Change: 2013-09-25.
|
||||
" @Revision: 0.0.12
|
||||
|
||||
" :nodefault:
|
||||
TLet g:tlib#debug = 0
|
||||
|
||||
|
|
@ -1,151 +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: 2014-06-02.
|
||||
" @Revision: 0.0.109
|
||||
|
||||
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
|
||||
|
||||
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 = strpart(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-01-23.
|
||||
" @Revision: 0.0.80
|
||||
|
||||
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,163 +0,0 @@
|
|||
" Object.vim -- Prototype objects?
|
||||
" @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-05-01.
|
||||
" @Last Change: 2011-03-10.
|
||||
" @Revision: 0.1.126
|
||||
|
||||
" :filedoc:
|
||||
" Provides a prototype plus some OO-like methods.
|
||||
|
||||
|
||||
if &cp || exists("loaded_tlib_object_autoload")
|
||||
finish
|
||||
endif
|
||||
let loaded_tlib_object_autoload = 1
|
||||
|
||||
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,27 +0,0 @@
|
|||
" Test.vim -- A test class
|
||||
" @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-05-01.
|
||||
" @Last Change: 2010-09-05.
|
||||
" @Revision: 0.1.10
|
||||
|
||||
" :enddoc:
|
||||
|
||||
if &cp || exists("loaded_tlib_Test_autoload")
|
||||
finish
|
||||
endif
|
||||
let loaded_tlib_Test_autoload = 1
|
||||
|
||||
|
||||
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,27 +0,0 @@
|
|||
" TestChild.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-05-18.
|
||||
" @Last Change: 2010-09-05.
|
||||
" @Revision: 0.1.14
|
||||
|
||||
" :enddoc:
|
||||
|
||||
if &cp || exists("loaded_tlib_TestChild_autoload")
|
||||
finish
|
||||
endif
|
||||
let loaded_tlib_TestChild_autoload = 1
|
||||
|
||||
|
||||
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,614 +0,0 @@
|
|||
" agent.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-24.
|
||||
" @Last Change: 2014-02-06.
|
||||
" @Revision: 0.1.251
|
||||
|
||||
|
||||
" :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
|
||||
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
|
||||
let @* = join(a:selected, "\n")
|
||||
let a:world.state = 'redisplay'
|
||||
return a:world
|
||||
endf
|
||||
|
||||
|
||||
|
||||
" InputList related {{{1
|
||||
|
||||
function! tlib#agent#PageUp(world, selected) "{{{3
|
||||
let a:world.offset -= (winheight(0) / 2)
|
||||
let a:world.state = 'scroll'
|
||||
return a:world
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#agent#PageDown(world, selected) "{{{3
|
||||
let a:world.offset += (winheight(0) / 2)
|
||||
let a:world.state = 'scroll'
|
||||
return a:world
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#agent#Home(world, selected) "{{{3
|
||||
let a:world.prefidx = 1
|
||||
let a:world.state = 'redisplay'
|
||||
return a:world
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#agent#End(world, selected) "{{{3
|
||||
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]
|
||||
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]
|
||||
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
|
||||
return tlib#agent#Up(a:world, a:selected, g:tlib_scroll_lines)
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#agent#DownN(world, selected) "{{{3
|
||||
return tlib#agent#Down(a:world, a:selected, g:tlib_scroll_lines)
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#agent#ShiftLeft(world, selected) "{{{3
|
||||
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
|
||||
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
|
||||
let a:world.state = 'reset'
|
||||
return a:world
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#agent#ToggleRestrictView(world, selected) "{{{3
|
||||
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
|
||||
" TLogVAR a:selected
|
||||
let filtered_items = map(copy(a:selected), 'index(a:world.base, v:val) + 1')
|
||||
" TLogVAR 1, filtered_items
|
||||
let filtered_items = filter(filtered_items, 'v:val > 0')
|
||||
" TLogVAR 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
|
||||
let a:world.filtered_items = []
|
||||
let a:world.state = 'display'
|
||||
return a:world
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#agent#Input(world, selected) "{{{3
|
||||
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
|
||||
let world = a:world
|
||||
let winnr = world.win_wnr
|
||||
" TLogVAR winnr
|
||||
if winnr != -1
|
||||
let world = tlib#agent#Suspend(world, a:selected)
|
||||
if world.state =~ '\<suspend\>'
|
||||
call world.SwitchWindow('win')
|
||||
" let pos = world.cursor
|
||||
" " TLogVAR 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
|
||||
if a:world.allow_suspend
|
||||
" TAssert IsNotEmpty(a:world.scratch)
|
||||
" TLogDBG bufnr('%')
|
||||
let br = tlib#buffer#Set(a:world.scratch)
|
||||
" TLogVAR 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
|
||||
" TLogVAR 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
|
||||
let a:world.state = 'help'
|
||||
return a:world
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#agent#OR(world, selected) "{{{3
|
||||
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
|
||||
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
|
||||
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
|
||||
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
|
||||
" 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
|
||||
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
|
||||
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
|
||||
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
|
||||
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
|
||||
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
|
||||
let lidx = a:world.prefidx
|
||||
" TLogVAR lidx
|
||||
" TLogVAR a:world.table
|
||||
let bidx = a:world.GetBaseIdx(lidx)
|
||||
" TLogVAR 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
|
||||
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
|
||||
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
|
||||
let world = tlib#agent#Copy(a:world, a:selected)
|
||||
return tlib#agent#DeleteItems(world, a:selected)
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#agent#Copy(world, selected) "{{{3
|
||||
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
|
||||
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
|
||||
return [a:world.state !~ '\<exit\>', a:world.base]
|
||||
endf
|
||||
|
||||
|
||||
|
||||
" Files related {{{1
|
||||
|
||||
function! tlib#agent#ViewFile(world, selected) "{{{3
|
||||
if !empty(a:selected)
|
||||
let back = a:world.SwitchWindow('win')
|
||||
" TLogVAR back
|
||||
if !&hidden && &l:modified
|
||||
let cmd0 = 'split'
|
||||
let cmd1 = 'sbuffer'
|
||||
else
|
||||
let cmd0 = 'edit'
|
||||
let cmd1 = 'buffer'
|
||||
endif
|
||||
call tlib#file#With(cmd0, cmd1, a:selected, a:world)
|
||||
" TLogVAR &filetype
|
||||
exec back
|
||||
let a:world.state = 'display'
|
||||
endif
|
||||
return a:world
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#agent#EditFile(world, selected) "{{{3
|
||||
return tlib#agent#Exit(tlib#agent#ViewFile(a:world, a:selected), a:selected)
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#agent#EditFileInSplit(world, selected) "{{{3
|
||||
call a:world.CloseScratch()
|
||||
" call tlib#file#With('edit', 'buffer', a:selected[0:0], a:world)
|
||||
" call tlib#file#With('split', 'sbuffer', a:selected[1:-1], a:world)
|
||||
call tlib#file#With('split', 'sbuffer', a:selected, a:world)
|
||||
return tlib#agent#Exit(a:world, a:selected)
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#agent#EditFileInVSplit(world, selected) "{{{3
|
||||
call a:world.CloseScratch()
|
||||
" call tlib#file#With('edit', 'buffer', a:selected[0:0], a:world)
|
||||
" call tlib#file#With('vertical split', 'vertical sbuffer', a:selected[1:-1], a:world)
|
||||
let winpos = tlib#fixes#Winpos()
|
||||
call tlib#file#With('vertical split', 'vertical sbuffer', a:selected, a:world)
|
||||
if !empty(winpos)
|
||||
exec winpos
|
||||
endif
|
||||
return tlib#agent#Exit(a:world, a:selected)
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#agent#EditFileInTab(world, selected) "{{{3
|
||||
" TLogVAR a:selected
|
||||
call a:world.CloseScratch()
|
||||
call tlib#file#With('tabedit', 'tab sbuffer', a:selected, a:world)
|
||||
return tlib#agent#Exit(a:world, a:selected)
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#agent#ToggleScrollbind(world, selected) "{{{3
|
||||
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)
|
||||
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#PreviewLine(world, selected) "{{{3
|
||||
let l = a:selected[0]
|
||||
let ww = winnr()
|
||||
exec a:world.win_wnr .'wincmd w'
|
||||
call tlib#buffer#ViewLine(l, 1)
|
||||
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
|
||||
if !empty(a:selected)
|
||||
|
||||
" let l = a:selected[0]
|
||||
" " TLogVAR l
|
||||
" let back = a:world.SwitchWindow('win')
|
||||
" " TLogVAR back
|
||||
" " if a:world.win_wnr != winnr()
|
||||
" " let world = tlib#agent#Suspend(a:world, a:selected)
|
||||
" " exec a:world.win_wnr .'wincmd w'
|
||||
" " endif
|
||||
" call tlib#buffer#ViewLine(l)
|
||||
" exec back
|
||||
" let a:world.state = 'display'
|
||||
|
||||
let l = a:selected[0]
|
||||
if a:world.win_wnr != winnr()
|
||||
let world = tlib#agent#Suspend(a:world, a:selected)
|
||||
exec a:world.win_wnr .'wincmd w'
|
||||
endif
|
||||
call tlib#buffer#ViewLine(l, 1)
|
||||
|
||||
endif
|
||||
return a:world
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#agent#DoAtLine(world, selected) "{{{3
|
||||
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
|
||||
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
|
||||
let a:world.state = 'redisplay'
|
||||
return a:world
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#agent#ExecAgentByName(world, selected) "{{{3
|
||||
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')
|
||||
" TLogVAR command
|
||||
if !has_key(agent_names, command)
|
||||
" TLogVAR command
|
||||
silent! let matches = filter(keys(agent_names), 'v:val =~ command')
|
||||
" TLogVAR 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)
|
||||
return filter(copy(s:agent_names), 'stridx(v:val, a:ArgLead) != -1')
|
||||
endf
|
||||
|
||||
|
|
@ -1,103 +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: 2014-07-01.
|
||||
" @Revision: 63
|
||||
|
||||
|
||||
" :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#Key(dict, list, ?default='')
|
||||
" See |:TKeyArg|.
|
||||
function! tlib#arg#Key(list, ...) "{{{3
|
||||
let default = a:0 >= 1 ? a:1 : ''
|
||||
let dict = a:list[0]
|
||||
let list = map(copy(a:list[1:-1]), 'type(v:val) == 3 ? v:val : [v:val, default]')
|
||||
let args = map(list, '"let ". v:val[0] ." = ". string(get(dict, v:val[0], v:val[1]))')
|
||||
" TLogVAR dict, list, args
|
||||
return join(args, ' | ')
|
||||
endf
|
||||
|
||||
|
||||
" :def: function! tlib#arg#StringAsKeyArgs(string, ?keys=[], ?evaluate=0, ?sep=':')
|
||||
function! tlib#arg#StringAsKeyArgs(string, ...) "{{{1
|
||||
TVarArg ['keys', {}], ['evaluate', 0], ['sep', ':']
|
||||
let keyargs = {}
|
||||
let args = split(a:string, '\\\@<! ')
|
||||
let arglist = map(args, 'matchlist(v:val, ''^\%(\(\w\+\)'. sep .'\(.*\)\|\(.*\)\)$'')')
|
||||
" TLogVAR a:string, args, arglist
|
||||
let pos = 0
|
||||
for matchlist in arglist
|
||||
if !empty(matchlist[3])
|
||||
let keyargs[pos] = matchlist[3]
|
||||
let pos += 1
|
||||
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
|
||||
return keyargs
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#arg#StringAsKeyArgsEqual(string) "{{{1
|
||||
return tlib#arg#StringAsKeyArgs(a:string, [], 0, '=')
|
||||
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,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,54 +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: 2010-09-05.
|
||||
" @Revision: 27
|
||||
|
||||
|
||||
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')
|
||||
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
|
||||
|
||||
|
||||
|
|
@ -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,400 +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: 2013-09-25.
|
||||
" @Revision: 0.0.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() "{{{3
|
||||
call tlib#autocmdgroup#Init()
|
||||
autocmd TLib BufEnter * call s:BMRU_Push(bufnr('%'))
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#buffer#DisableMRU() "{{{3
|
||||
call tlib#autocmdgroup#Init()
|
||||
autocmd! TLib BufEnter
|
||||
endf
|
||||
|
||||
|
||||
function! s:BMRU_Push(bnr) "{{{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) "{{{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) "{{{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) "{{{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)
|
||||
" Evaluate CODE in BUFFER.
|
||||
"
|
||||
" EXAMPLES: >
|
||||
" call tlib#buffer#Eval('foo.txt', 'echo b:bar')
|
||||
function! tlib#buffer#Eval(buffer, code) "{{{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')
|
||||
" 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(...)
|
||||
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), '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')
|
||||
" 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, ...) "{{{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() "{{{3
|
||||
3match 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(...) "{{{3
|
||||
TVarArg ['line', line('.')]
|
||||
" exec '3match MatchParen /^\%'. a:line .'l.*/'
|
||||
exec '3match 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) "{{{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)
|
||||
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() "{{{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() "{{{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) "{{{3
|
||||
let bn = bufnr('%')
|
||||
exec 'bufdo '. a:exec
|
||||
exec 'buffer! '. bn
|
||||
endf
|
||||
|
||||
|
||||
" :def: function! tlib#buffer#InsertText(text, keyargs)
|
||||
" 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, ...) "{{{3
|
||||
TVarArg ['keyargs', {}]
|
||||
" TLogVAR a:text, keyargs
|
||||
TKeyArg keyargs, ['shift', 0], ['col', col('.')], ['lineno', line('.')], ['pos', 'e'],
|
||||
\ ['indent', 0]
|
||||
" TLogVAR shift, col, lineno, pos, indent
|
||||
let grow = 0
|
||||
let post_del_last_line = line('$') == 1
|
||||
let line = getline(lineno)
|
||||
if col + shift > 0
|
||||
let pre = line[0 : (col - 1 + shift)]
|
||||
let post = line[(col + shift): -1]
|
||||
else
|
||||
let pre = ''
|
||||
let post = line
|
||||
endif
|
||||
" TLogVAR lineno, line, pre, post
|
||||
let text0 = pre . a:text . post
|
||||
let text = split(text0, '\n', 1)
|
||||
" TLogVAR text
|
||||
let icol = len(pre)
|
||||
" exec 'norm! '. lineno .'G'
|
||||
call cursor(lineno, col)
|
||||
if indent && col > 1
|
||||
if &fo =~# '[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 = strpart(getline('.'), 0, col('.') + shift)
|
||||
" " TLogVAR idt
|
||||
" let idtl = len(idt)
|
||||
" -1,.delete
|
||||
" " TAssertExec redraw | sleep 3
|
||||
" call append(lineno - 1, cline)
|
||||
" call cursor(lineno, 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! '. lineno .'Gdd'
|
||||
call tlib#normal#WithRegister('"tdd', 't')
|
||||
call append(lineno - 1, text)
|
||||
if post_del_last_line
|
||||
call tlib#buffer#KeepCursorPosition('$delete')
|
||||
endif
|
||||
let tlen = len(text)
|
||||
let posshift = matchstr(pos, '\d\+')
|
||||
" TLogVAR pos
|
||||
if pos =~ '^e'
|
||||
exec lineno + tlen - 1
|
||||
exec 'norm! 0'. (len(text[-1]) - len(post) + posshift - 1) .'l'
|
||||
elseif pos =~ '^s'
|
||||
" TLogVAR lineno, pre, posshift
|
||||
exec lineno
|
||||
exec 'norm! '. len(pre) .'|'
|
||||
if !empty(posshift)
|
||||
exec 'norm! '. posshift .'h'
|
||||
endif
|
||||
endif
|
||||
" TLogDBG getline(lineno)
|
||||
" TLogDBG string(getline(1, '$'))
|
||||
return grow
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#buffer#InsertText0(text, ...) "{{{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() "{{{3
|
||||
return line2byte(line('.')) + col('.')
|
||||
endf
|
||||
|
||||
|
||||
" Evaluate cmd while maintaining the cursor position and jump registers.
|
||||
function! tlib#buffer#KeepCursorPosition(cmd) "{{{3
|
||||
" let pos = getpos('.')
|
||||
let view = winsaveview()
|
||||
try
|
||||
keepjumps exec a:cmd
|
||||
finally
|
||||
" call setpos('.', pos)
|
||||
call winrestview(view)
|
||||
endtry
|
||||
endf
|
||||
|
||||
|
|
@ -1,335 +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: 2013-09-25.
|
||||
" @Revision: 0.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
|
||||
|
||||
|
||||
" :display: tlib#cache#Dir(?mode = 'bg')
|
||||
" The default cache directory.
|
||||
function! tlib#cache#Dir(...) "{{{3
|
||||
TVarArg ['mode', 'bg']
|
||||
let dir = tlib#var#Get('tlib_cache', mode)
|
||||
if empty(dir)
|
||||
let dir = tlib#file#Join([tlib#dir#MyRuntime(), 'cache'])
|
||||
endif
|
||||
return dir
|
||||
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
|
||||
if v:version >= 704
|
||||
let shortfilename = pathshorten(file) .'_'. sha256(file)
|
||||
else
|
||||
let shortfilename = pathshorten(file) .'_'. tlib#hash#Adler32(file)
|
||||
endif
|
||||
let cache_file = tlib#cache#Filename(a:type, shortfilename, mkdir, dir0)
|
||||
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! tlib#cache#Save(cfile, dictionary) "{{{3
|
||||
" TLogVAR a:cfile, a:dictionary
|
||||
if !empty(a:cfile)
|
||||
" TLogVAR a:dictionary
|
||||
call writefile([string(a:dictionary)], a: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
|
||||
call tlib#cache#MaybePurge()
|
||||
if !empty(a:cfile) && filereadable(a:cfile)
|
||||
let val = readfile(a:cfile, 'b')
|
||||
call s:SetTimestamp(a:cfile, 'read')
|
||||
return eval(join(val, "\n"))
|
||||
else
|
||||
let default = a:0 >= 1 ? a:1 : {}
|
||||
return default
|
||||
endif
|
||||
endf
|
||||
|
||||
|
||||
" 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
|
||||
if !filereadable(a:cfile) || (a:ftime != 0 && getftime(a:cfile) < a:ftime)
|
||||
let args = a:0 >= 1 ? a:1 : []
|
||||
" 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)
|
||||
return val
|
||||
else
|
||||
let val = tlib#cache#Get(a:cfile)
|
||||
return val.val
|
||||
endif
|
||||
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), 'strpart(v:val, 0, len(file)) ==# file'))
|
||||
call add(deldir, file)
|
||||
endif
|
||||
else
|
||||
if getftime(file) < threshold
|
||||
if delete(file)
|
||||
call add(msg, "TLib: Could not delete cache file: ". file)
|
||||
elseif g:tlib#cache#verbosity >= 2
|
||||
call add(msg, "TLib: Delete cache file: ". file)
|
||||
endif
|
||||
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)
|
||||
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 'cd '. fnameescape(dir)
|
||||
exec '! ' &shell shellescape(scriptfile, 1)
|
||||
exec 'cd -'
|
||||
call delete(scriptfile)
|
||||
elseif yn =~ '^e\%[dit]$'
|
||||
exec 'edit '. fnameescape(scriptfile)
|
||||
endif
|
||||
finally
|
||||
call inputrestore()
|
||||
endtry
|
||||
endif
|
||||
endif
|
||||
call s:PurgeTimestamp(dir)
|
||||
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(strpart(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,67 +0,0 @@
|
|||
" char.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: 2014-01-20.
|
||||
" @Revision: 0.0.37
|
||||
|
||||
if &cp || exists("loaded_tlib_char_autoload")
|
||||
finish
|
||||
endif
|
||||
let loaded_tlib_char_autoload = 1
|
||||
|
||||
|
||||
" :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,111 +0,0 @@
|
|||
" cmd.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-08-23.
|
||||
" @Last Change: 2014-02-05.
|
||||
" @Revision: 0.0.53
|
||||
|
||||
if &cp || exists("loaded_tlib_cmd_autoload")
|
||||
finish
|
||||
endif
|
||||
let loaded_tlib_cmd_autoload = 1
|
||||
|
||||
|
||||
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
|
||||
|
||||
" :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
|
||||
|
||||
|
|
@ -1,57 +0,0 @@
|
|||
" comments.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: 2007-11-15.
|
||||
" @Last Change: 2009-02-15.
|
||||
" @Revision: 0.0.24
|
||||
|
||||
if &cp || exists("loaded_tlib_comments_autoload")
|
||||
finish
|
||||
endif
|
||||
let loaded_tlib_comments_autoload = 1
|
||||
let s:save_cpo = &cpo
|
||||
set cpo&vim
|
||||
|
||||
|
||||
" 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
|
||||
|
||||
|
||||
" function! tlib#comments#PartitionLine(line) "{{{3
|
||||
" if !empty(&commentstring)
|
||||
" let cs = '^\(\s*\)\('. printf(tlib#rx#Escape(&commentstring), '\)\(.\{-}\)\(') .'\)\(.*\)$'
|
||||
" let ml = matchlist(a:line, cs)
|
||||
" else
|
||||
" let ml = []
|
||||
" endif
|
||||
" if !empty(ml)
|
||||
" let [m_0, pre, open, line, close, post; rest] = ml
|
||||
" else
|
||||
" let [m_0, pre, line; rest] = matchstr(a:line, '^\(\s*\)\(.*\)$')
|
||||
" for [key, val] in tlib#comments#Comments()
|
||||
" if +++
|
||||
" endfor
|
||||
" endif
|
||||
" return {'pre': pre, 'open': open, 'line': line, 'close': close, 'post': post}
|
||||
" endf
|
||||
|
||||
|
||||
let &cpo = s:save_cpo
|
||||
unlet s:save_cpo
|
||||
|
|
@ -1,120 +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: 2010-09-17.
|
||||
" @Revision: 0.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
|
||||
|
||||
|
||||
" :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) "{{{3
|
||||
function! tlib#date#Parse(date, ...) "{{{3
|
||||
let min = a:0 >= 1 && a:1 ? 0 : 1
|
||||
" TLogVAR a:date, min
|
||||
let m = matchlist(a:date, '^\(\d\{2}\|\d\{4}\)-\(\d\{1,2}\)-\(\d\{1,2}\)$')
|
||||
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
|
||||
if empty(m) || year == '' || month == '' || days == '' ||
|
||||
\ month < min || month > 12 || days < min || days > 31
|
||||
echoerr 'TLib: Invalid date: '. a:date
|
||||
return []
|
||||
endif
|
||||
if strlen(year) == 2
|
||||
let year = g:tlib#date#ShortDatePrefix . 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
|
||||
|
||||
|
|
@ -1,101 +0,0 @@
|
|||
" dir.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: 2014-07-07.
|
||||
" @Revision: 0.0.38
|
||||
|
||||
if &cp || exists("loaded_tlib_dir_autoload")
|
||||
finish
|
||||
endif
|
||||
let loaded_tlib_dir_autoload = 1
|
||||
|
||||
" 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', 0]
|
||||
let cmd = locally ? 'lcd ' : 'cd '
|
||||
" let cwd = getcwd()
|
||||
let cmd .= tlib#arg#Ex(a:dir)
|
||||
" TLogVAR a:dir, locally, cmd
|
||||
exec cmd
|
||||
" return cwd
|
||||
return getcwd()
|
||||
endf
|
||||
|
||||
|
||||
" :def: function! tlib#dir#Push(dir, ?locally=0) => CWD
|
||||
function! tlib#dir#Push(dir, ...) "{{{3
|
||||
TVarArg ['locally', 0]
|
||||
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,55 +0,0 @@
|
|||
" eval.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: 2007-09-16.
|
||||
" @Last Change: 2009-02-15.
|
||||
" @Revision: 0.0.34
|
||||
|
||||
if &cp || exists("loaded_tlib_eval_autoload")
|
||||
finish
|
||||
endif
|
||||
let loaded_tlib_eval_autoload = 1
|
||||
|
||||
|
||||
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
|
||||
|
||||
|
||||
|
|
@ -1,183 +0,0 @@
|
|||
" file.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: 2014-07-07.
|
||||
" @Revision: 0.0.150
|
||||
|
||||
if &cp || exists("loaded_tlib_file_autoload")
|
||||
finish
|
||||
endif
|
||||
let loaded_tlib_file_autoload = 1
|
||||
|
||||
|
||||
""" 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) "{{{3
|
||||
let prefix = matchstr(a:filename, '^\(\w\+:\)\?/\+')
|
||||
" TLogVAR 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)
|
||||
" EXAMPLES: >
|
||||
" tlib#file#Join(['foo', 'bar', 'filename.txt'])
|
||||
" => 'foo/bar/filename.txt'
|
||||
function! tlib#file#Join(filename_parts, ...) "{{{3
|
||||
TVarArg ['strip_slashes', 1]
|
||||
" TLogVAR a:filename_parts, strip_slashes
|
||||
if strip_slashes
|
||||
" let rx = tlib#rx#Escape(g:tlib#dir#sep) .'$'
|
||||
let rx = '[/\\]\+$'
|
||||
let parts = map(copy(a:filename_parts), 'substitute(v:val, rx, "", "")')
|
||||
" TLogVAR parts
|
||||
return join(parts, g:tlib#dir#sep)
|
||||
else
|
||||
return join(a: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) "{{{3
|
||||
" TLogVAR a:filename, a:basedir
|
||||
" TLogDBG getcwd()
|
||||
" TLogDBG expand('%:p')
|
||||
let b0 = tlib#file#Absolute(a:basedir)
|
||||
let b = tlib#file#Split(b0)
|
||||
" TLogVAR b
|
||||
let f0 = tlib#file#Absolute(a:filename)
|
||||
let fn = fnamemodify(f0, ':t')
|
||||
let fd = fnamemodify(f0, ':h')
|
||||
let f = tlib#file#Split(fd)
|
||||
" TLogVAR 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
|
||||
" TLogVAR f, b
|
||||
let rv = tlib#file#Join(repeat(['..'], len(b)) + f + [fn])
|
||||
endif
|
||||
" TLogVAR rv
|
||||
return rv
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#file#Absolute(filename, ...) "{{{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, ...) "{{{3
|
||||
TVarArg ['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
|
||||
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) "{{{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={})
|
||||
function! tlib#file#With(fcmd, bcmd, files, ...) "{{{3
|
||||
" TLogVAR a:fcmd, a:bcmd, a:files
|
||||
exec tlib#arg#Let([['world', {}]])
|
||||
call tlib#autocmdgroup#Init()
|
||||
augroup TLibFileRead
|
||||
autocmd!
|
||||
augroup END
|
||||
for f in a:files
|
||||
let bn = bufnr('^'.f.'$')
|
||||
" TLogVAR f, bn
|
||||
let bufloaded = bufloaded(bn)
|
||||
let ok = 0
|
||||
let s:bufread = ""
|
||||
if bn != -1 && buflisted(bn)
|
||||
if !empty(a:bcmd)
|
||||
" TLogDBG a:bcmd .' '. bn
|
||||
exec a:bcmd .' '. bn
|
||||
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
|
||||
exec a:fcmd .' '. tlib#arg#Ex(f)
|
||||
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
|
||||
" TLogVAR ok, bufloaded, &filetype
|
||||
if empty(s:bufread) && ok && !bufloaded && empty(&filetype)
|
||||
doautocmd BufRead
|
||||
endif
|
||||
endfor
|
||||
augroup! TLibFileRead
|
||||
unlet! s:bufread
|
||||
" TLogDBG "done"
|
||||
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,33 +0,0 @@
|
|||
" hook.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-08-21.
|
||||
" @Last Change: 2009-02-15.
|
||||
" @Revision: 0.0.10
|
||||
|
||||
if &cp || exists("loaded_tlib_hook_autoload")
|
||||
finish
|
||||
endif
|
||||
let loaded_tlib_hook_autoload = 1
|
||||
|
||||
|
||||
" :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,180 +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: 2011-03-18.
|
||||
" @Revision: 57
|
||||
|
||||
|
||||
""" List related functions {{{1
|
||||
" For the following functions please see ../../test/tlib.vim for examples.
|
||||
|
||||
" :def: function! tlib#list#Inject(list, initial_value, funcref)
|
||||
" EXAMPLES: >
|
||||
" echo tlib#list#Inject([1,2,3], 0, function('Add')
|
||||
" => 6
|
||||
function! tlib#list#Inject(list, value, Function) "{{{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) "{{{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) "{{{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="")
|
||||
" Basically the same as filter()
|
||||
"
|
||||
" EXAMPLES: >
|
||||
" tlib#list#FindAll([1,2,3], 'v:val >= 2')
|
||||
" => [2, 3]
|
||||
function! tlib#list#FindAll(list, filter, ...) "{{{3
|
||||
let rv = filter(copy(a:list), a:filter)
|
||||
if a:0 >= 1 && a:1 != ''
|
||||
let rv = map(rv, a:1)
|
||||
endif
|
||||
return rv
|
||||
endf
|
||||
|
||||
|
||||
" :def: function! tlib#list#Find(list, filter, ?default="", ?process_expr="")
|
||||
"
|
||||
" EXAMPLES: >
|
||||
" tlib#list#Find([1,2,3], 'v:val >= 2')
|
||||
" => 2
|
||||
function! tlib#list#Find(list, filter, ...) "{{{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) "{{{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) "{{{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) "{{{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) "{{{3
|
||||
call filter(a:list, 'v:val != a:element')
|
||||
return a:list
|
||||
endf
|
||||
|
||||
|
||||
" :def: function! tlib#list#Zip(lists, ?default='')
|
||||
" EXAMPLES: >
|
||||
" tlib#list#Zip([[1,2,3], [4,5,6]])
|
||||
" => [[1,4], [2,5], [3,6]]
|
||||
function! tlib#list#Zip(lists, ...) "{{{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) "{{{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, ...) "{{{3
|
||||
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 seen = {}
|
||||
let uniques = []
|
||||
if empty(get_value)
|
||||
for e in a:list
|
||||
if !has_key(seen, e)
|
||||
let seen[e] = 1
|
||||
call add(uniques, e)
|
||||
endif
|
||||
endfor
|
||||
else
|
||||
for e in a:list
|
||||
let v = eval(printf(get_value, string(e)))
|
||||
if !has_key(seen, v)
|
||||
let seen[v] = 1
|
||||
call add(uniques, e)
|
||||
endif
|
||||
endfor
|
||||
endif
|
||||
return uniques
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#list#ToDictionary(list, default, ...) "{{{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,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,104 +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: 2012-01-02.
|
||||
" @Revision: 0.0.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
|
||||
try
|
||||
set noruler
|
||||
set noshowcmd
|
||||
if !empty(style)
|
||||
exec 'echohl '. style
|
||||
endif
|
||||
echo strpart(a: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 strpart(a:message, 0, front) . filler .
|
||||
\strpart(a:message, strlen(a:message) - back)
|
||||
else
|
||||
return a:message
|
||||
endif
|
||||
endfunction
|
||||
|
||||
|
||||
let &cpo = s:save_cpo
|
||||
unlet s:save_cpo
|
||||
|
|
@ -1,30 +0,0 @@
|
|||
" @Author: Tom Link (mailto:micathom AT gmail com?subject=[vim])
|
||||
" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
|
||||
" @Revision: 14
|
||||
|
||||
|
||||
function! tlib#number#ConvertBase(num, base, ...) "{{{3
|
||||
let rtype = a:0 >= 1 ? a:1 : 'string'
|
||||
" TLogVAR a:num, a:base, rtype
|
||||
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)
|
||||
if a:base <= 10
|
||||
call insert(rv, num1)
|
||||
elseif a:base == 16
|
||||
let char = "0123456789ABCDEF"[num1]
|
||||
call insert(rv, char)
|
||||
endif
|
||||
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,47 +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: 2012-05-11.
|
||||
" @Revision: 12
|
||||
|
||||
" 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
|
||||
|
||||
" :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(cfile, dictionary) "{{{3
|
||||
call tlib#cache#Save(a:cfile, a:dictionary)
|
||||
endf
|
||||
|
||||
|
|
@ -1,80 +0,0 @@
|
|||
" progressbar.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: 2007-09-30.
|
||||
" @Last Change: 2010-01-07.
|
||||
" @Revision: 0.0.69
|
||||
|
||||
if &cp || exists("loaded_tlib_progressbar_autoload")
|
||||
finish
|
||||
endif
|
||||
let loaded_tlib_progressbar_autoload = 1
|
||||
|
||||
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]
|
||||
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 &laststatus = 2
|
||||
let s:timestamp = localtime()
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#progressbar#Display(value, ...) "{{{3
|
||||
TVarArg 'extra'
|
||||
let ts = localtime()
|
||||
if ts == s:timestamp
|
||||
return
|
||||
else
|
||||
let s:timestamp = ts
|
||||
endif
|
||||
let val = a:value * s:width[0] / s:max[0]
|
||||
if 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 &l:statusline = txt
|
||||
" TLogDBG txt
|
||||
redrawstatus
|
||||
" redraw
|
||||
" call tlib#notify#Echo(txt)
|
||||
endif
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#progressbar#Restore() "{{{3
|
||||
let &l:statusline = remove(s:statusline, 0)
|
||||
let &laststatus = remove(s:laststatus, 0)
|
||||
redrawstatus
|
||||
" redraw
|
||||
" echo
|
||||
call remove(s:max, 0)
|
||||
call remove(s:format, 0)
|
||||
call remove(s:width, 0)
|
||||
call remove(s:value, 0)
|
||||
endf
|
||||
|
||||
|
||||
|
|
@ -1,63 +0,0 @@
|
|||
" rx.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-07-20.
|
||||
" @Last Change: 2010-02-26.
|
||||
" @Revision: 0.0.28
|
||||
|
||||
if &cp || exists("loaded_tlib_rx_autoload")
|
||||
finish
|
||||
endif
|
||||
let loaded_tlib_rx_autoload = 1
|
||||
|
||||
|
||||
" :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']
|
||||
if magic ==# 'm' || magic ==# 'v'
|
||||
return escape(a:text, '\&~')
|
||||
elseif magic ==# 'M' || magic ==# 'V'
|
||||
return escape(a:text, '\')
|
||||
else
|
||||
echoerr 'magic must be one of: m, v, M, V'
|
||||
endif
|
||||
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
|
||||
|
||||
|
|
@ -1,143 +0,0 @@
|
|||
" scratch.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-07-18.
|
||||
" @Last Change: 2014-02-06.
|
||||
" @Revision: 0.0.252
|
||||
|
||||
if &cp || exists("loaded_tlib_scratch_autoload")
|
||||
finish
|
||||
endif
|
||||
let loaded_tlib_scratch_autoload = 1
|
||||
|
||||
|
||||
" 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 modifiable
|
||||
setlocal nospell
|
||||
" 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,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,158 +0,0 @@
|
|||
" string.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: 2009-02-15.
|
||||
" @Revision: 0.0.115
|
||||
|
||||
if &cp || exists("loaded_tlib_string_autoload")
|
||||
finish
|
||||
endif
|
||||
let loaded_tlib_string_autoload = 1
|
||||
|
||||
|
||||
" :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
|
||||
|
||||
|
||||
function! tlib#string#Format(template, dict) "{{{3
|
||||
let parts = split(a:template, '\ze%\({.\{-}}\|.\)')
|
||||
let out = []
|
||||
for part in parts
|
||||
let ml = matchlist(part, '^%\({\(.\{-}\)}\|\(.\)\)\(.*\)$')
|
||||
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 == '%%'
|
||||
call add(out, '%')
|
||||
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
|
||||
|
||||
|
|
@ -1,51 +0,0 @@
|
|||
" syntax.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: 2007-11-19.
|
||||
" @Last Change: 2009-02-15.
|
||||
" @Revision: 0.0.11
|
||||
|
||||
if &cp || exists("loaded_tlib_syntax_autoload")
|
||||
finish
|
||||
endif
|
||||
let loaded_tlib_syntax_autoload = 1
|
||||
let s:save_cpo = &cpo
|
||||
set cpo&vim
|
||||
|
||||
|
||||
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
|
||||
|
||||
|
||||
let &cpo = s:save_cpo
|
||||
unlet s:save_cpo
|
||||
|
|
@ -1,57 +0,0 @@
|
|||
" tab.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-08-27.
|
||||
" @Last Change: 2014-02-06.
|
||||
" @Revision: 0.0.30
|
||||
|
||||
if &cp || exists("loaded_tlib_tab_autoload")
|
||||
finish
|
||||
endif
|
||||
let loaded_tlib_tab_autoload = 1
|
||||
|
||||
|
||||
" 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,140 +0,0 @@
|
|||
" tag.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: 2007-11-01.
|
||||
" @Last Change: 2013-09-25.
|
||||
" @Revision: 0.0.58
|
||||
|
||||
if &cp || exists("loaded_tlib_tag_autoload")
|
||||
finish
|
||||
endif
|
||||
let loaded_tlib_tag_autoload = 1
|
||||
|
||||
|
||||
" 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]
|
||||
" TLogVAR 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
|
||||
return 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]
|
||||
" TLogVAR a:constraints, use_extra
|
||||
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
|
||||
" TLogVAR rx, use_extra
|
||||
let tags = tlib#tag#Retrieve(rx, use_extra)
|
||||
" TLogDBG 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
|
||||
" TLogVAR 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,60 +0,0 @@
|
|||
" time.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: 2007-10-17.
|
||||
" @Last Change: 2009-02-22.
|
||||
" @Revision: 0.0.29
|
||||
|
||||
if &cp || exists("loaded_tlib_time_autoload")
|
||||
finish
|
||||
endif
|
||||
let loaded_tlib_time_autoload = 1
|
||||
|
||||
|
||||
function! tlib#time#MSecs() "{{{3
|
||||
let rts = reltimestr(reltime())
|
||||
return substitute(rts, '\.', '', '')
|
||||
endf
|
||||
|
||||
|
||||
function! tlib#time#Now() "{{{3
|
||||
let rts = reltimestr(reltime())
|
||||
let rtl = split(rts, '\.')
|
||||
return rtl
|
||||
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
|
||||
|
||||
|
||||
|
|
@ -1,29 +0,0 @@
|
|||
" type.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: 2007-09-30.
|
||||
" @Last Change: 2010-09-27.
|
||||
" @Revision: 0.0.4
|
||||
|
||||
function! tlib#type#IsNumber(expr)
|
||||
return type(a:expr) == 0
|
||||
endf
|
||||
|
||||
function! tlib#type#IsString(expr)
|
||||
return type(a:expr) == 1
|
||||
endf
|
||||
|
||||
function! tlib#type#IsFuncref(expr)
|
||||
return type(a:expr) == 2
|
||||
endf
|
||||
|
||||
function! tlib#type#IsList(expr)
|
||||
return type(a:expr) == 3
|
||||
endf
|
||||
|
||||
function! tlib#type#IsDictionary(expr)
|
||||
return type(a:expr) == 4
|
||||
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,87 +0,0 @@
|
|||
" var.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: 2014-07-03.
|
||||
" @Revision: 0.0.26
|
||||
|
||||
if &cp || exists("loaded_tlib_var_autoload")
|
||||
finish
|
||||
endif
|
||||
let loaded_tlib_var_autoload = 1
|
||||
|
||||
|
||||
" 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}
|
||||
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', '']
|
||||
redir => vars
|
||||
silent! exec 'let '. prefix
|
||||
redir END
|
||||
let varlist = split(vars, '\n')
|
||||
call map(varlist, 'matchstr(v:val, ''^\S\+'')')
|
||||
call filter(varlist, 'v:val =~ a:rx')
|
||||
return varlist
|
||||
endf
|
||||
|
||||
|
|
@ -1,160 +0,0 @@
|
|||
" vcs.vim
|
||||
" @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: 2014-07-01.
|
||||
" @Revision: 131
|
||||
|
||||
|
||||
" 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 %s',
|
||||
\ 'diff': 'git diff --no-ext-diff -U0 %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
|
||||
|
||||
|
||||
function! tlib#vcs#FindVCS(filename) "{{{3
|
||||
let type = ''
|
||||
let dir = ''
|
||||
let dirname = fnamemodify(a:filename, isdirectory(a:filename) ? ':p' : ':p:h')
|
||||
let path = escape(dirname, ';') .';'
|
||||
" TLogVAR a:filename, dirname, 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
|
||||
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
|
||||
" TLogVAR type, dir
|
||||
if empty(type)
|
||||
return ['', '']
|
||||
else
|
||||
return [type, dir]
|
||||
endif
|
||||
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]
|
||||
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
|
||||
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
|
||||
" 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
|
||||
let filess = system(cmd)
|
||||
" TLogVAR filess
|
||||
let files = split(filess, '\n')
|
||||
call map(files, 'join([rootdir, v:val], "/")')
|
||||
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
|
||||
|
||||
|
|
@ -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,136 +0,0 @@
|
|||
" win.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-08-24.
|
||||
" @Last Change: 2010-12-04.
|
||||
" @Revision: 0.0.54
|
||||
|
||||
if &cp || exists("loaded_tlib_win_autoload")
|
||||
finish
|
||||
endif
|
||||
let loaded_tlib_win_autoload = 1
|
||||
|
||||
|
||||
" 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
|
||||
|
||||
|
||||
" :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
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
|
|
@ -1,118 +0,0 @@
|
|||
" @Author: Tom Link (micathom AT gmail com?subject=[vim])
|
||||
" @Created: 2007-04-10.
|
||||
" @Last Change: 2014-07-03.
|
||||
" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
|
||||
" @Revision: 753
|
||||
" @Website: http://www.vim.org/account/profile.php?user_id=4037
|
||||
" GetLatestVimScripts: 1863 1 tlib.vim
|
||||
" tlib.vim -- Some utility functions
|
||||
|
||||
if &cp || exists("loaded_tlib")
|
||||
finish
|
||||
endif
|
||||
if v:version < 700 "{{{2
|
||||
echoerr "tlib requires Vim >= 7"
|
||||
finish
|
||||
endif
|
||||
let loaded_tlib = 112
|
||||
|
||||
let s:save_cpo = &cpo
|
||||
set cpo&vim
|
||||
|
||||
|
||||
" Init~ {{{1
|
||||
" call tlib#autocmdgroup#Init()
|
||||
|
||||
|
||||
" Commands~ {{{1
|
||||
|
||||
" :display: :TRequire NAME [VERSION [FILE]]
|
||||
" Make a certain vim file is loaded.
|
||||
"
|
||||
" Conventions: If FILE isn't defined, plugin/NAME.vim is loaded. The
|
||||
" file must provide a variable loaded_{NAME} that represents the version
|
||||
" number.
|
||||
command! -nargs=+ TRequire let s:require = [<f-args>]
|
||||
\ | if !exists('loaded_'. get(s:require, 0))
|
||||
\ | exec 'runtime '. get(s:require, 2, 'plugin/'. get(s:require, 0) .'.vim')
|
||||
\ | if !exists('loaded_'. get(s:require, 0)) || loaded_{get(s:require, 0)} < get(s:require, 1, loaded_{get(s:require, 0)})
|
||||
\ | echoerr 'Require '. get(s:require, 0) .' >= '. get(s:require, 1, 'any version will do')
|
||||
\ | finish
|
||||
\ | endif
|
||||
\ | endif | unlet s:require
|
||||
|
||||
|
||||
" :display: :TLet VAR = VALUE
|
||||
" Set a variable only if it doesn't already exist.
|
||||
" EXAMPLES: >
|
||||
" TLet foo = 1
|
||||
" TLet foo = 2
|
||||
" echo foo
|
||||
" => 1
|
||||
command! -nargs=+ TLet if !exists(matchstr(<q-args>, '^[^=[:space:]]\+')) | exec 'let '. <q-args> | endif
|
||||
|
||||
|
||||
" Open a scratch buffer (a buffer without a file).
|
||||
" TScratch ... use split window
|
||||
" TScratch! ... use the whole frame
|
||||
" This command takes an (inner) dictionary as optional argument.
|
||||
" EXAMPLES: >
|
||||
" TScratch 'scratch': '__FOO__'
|
||||
" => Open a scratch buffer named __FOO__
|
||||
command! -bar -nargs=* -bang TScratch call tlib#scratch#UseScratch({'scratch_split': '<bang>' != '!', <args>})
|
||||
|
||||
|
||||
" :display: :TVarArg VAR1, [VAR2, DEFAULT2] ...
|
||||
" A convenience wrapper for |tlib#arg#Let|.
|
||||
" EXAMPLES: >
|
||||
" function! Foo(...)
|
||||
" TVarArg ['a', 1], 'b'
|
||||
" echo 'a='. a
|
||||
" echo 'b='. b
|
||||
" endf
|
||||
command! -nargs=+ TVarArg exec tlib#arg#Let([<args>])
|
||||
|
||||
|
||||
" :display: :TKeyArg DICT, VAR1, [VAR2, DEFAULT2] ...
|
||||
" A convenience wrapper for |tlib#arg#Let|.
|
||||
" EXAMPLES: >
|
||||
" function! Foo(keyargs)
|
||||
" TKeyArg a:keyargs, ['a', 1], 'b'
|
||||
" echo 'a='. a
|
||||
" echo 'b='. b
|
||||
" endf
|
||||
command! -nargs=+ TKeyArg exec tlib#arg#Key([<args>])
|
||||
|
||||
|
||||
" :display: :TBrowseOutput COMMAND
|
||||
" Ever wondered how to efficiently browse the output of a command
|
||||
" without redirecting it to a file? This command takes a command as
|
||||
" argument and presents the output via |tlib#input#List()| so that you
|
||||
" can easily search for a keyword (e.g. the name of a variable or
|
||||
" function) and the like.
|
||||
"
|
||||
" If you press enter, the selected line will be copied to the command
|
||||
" line. Press ESC to cancel browsing.
|
||||
"
|
||||
" EXAMPLES: >
|
||||
" TBrowseOutput 20verb TeaseTheCulprit
|
||||
command! -nargs=1 -complete=command TBrowseOutput call tlib#cmd#BrowseOutput(<q-args>)
|
||||
|
||||
" :display: :TBrowseScriptnames
|
||||
" List all sourced script names (the output of ':scriptnames').
|
||||
"
|
||||
" When you press enter, the selected script will be opened in the current
|
||||
" window. Press ESC to cancel.
|
||||
"
|
||||
" EXAMPLES: >
|
||||
" TBrowseScriptnames
|
||||
command! -nargs=0 -complete=command TBrowseScriptnames call
|
||||
\ tlib#cmd#BrowseOutputWithCallback("tlib#cmd#ParseScriptname", "scriptnames")
|
||||
|
||||
" :display: :TTimeCommand CMD
|
||||
" Time the execution time of CMD.
|
||||
command! -nargs=1 -complete=command TTimeCommand call tlib#cmd#Time(<q-args>)
|
||||
|
||||
|
||||
let &cpo = s:save_cpo
|
||||
unlet s:save_cpo
|
||||
|
|
@ -1,219 +0,0 @@
|
|||
" tLib.vim
|
||||
" @Author: Thomas Link (mailto:micathom AT gmail com?subject=vim-tLib)
|
||||
" @Website: http://www.vim.org/account/profile.php?user_id=4037
|
||||
" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
|
||||
" @Created: 2006-12-17.
|
||||
" @Last Change: 2008-11-23.
|
||||
" @Revision: 129
|
||||
|
||||
if !exists("loaded_tassert")
|
||||
echoerr 'tAssert (vimscript #1730) is required'
|
||||
endif
|
||||
|
||||
|
||||
TAssertBegin! "tlib"
|
||||
|
||||
|
||||
" List {{{2
|
||||
fun! Add(a,b)
|
||||
return a:a + a:b
|
||||
endf
|
||||
TAssert IsEqual(tlib#list#Inject([], 0, function('Add')), 0)
|
||||
TAssert IsEqual(tlib#list#Inject([1,2,3], 0, function('Add')), 6)
|
||||
delfunction Add
|
||||
|
||||
TAssert IsEqual(tlib#list#Compact([]), [])
|
||||
TAssert IsEqual(tlib#list#Compact([0,1,2,3,[], {}, ""]), [1,2,3])
|
||||
|
||||
TAssert IsEqual(tlib#list#Flatten([]), [])
|
||||
TAssert IsEqual(tlib#list#Flatten([1,2,3]), [1,2,3])
|
||||
TAssert IsEqual(tlib#list#Flatten([1,2, [1,2,3], 3]), [1,2,1,2,3,3])
|
||||
TAssert IsEqual(tlib#list#Flatten([0,[1,2,[3,""]]]), [0,1,2,3,""])
|
||||
|
||||
TAssert IsEqual(tlib#list#FindAll([1,2,3], 'v:val >= 2'), [2,3])
|
||||
TAssert IsEqual(tlib#list#FindAll([1,2,3], 'v:val >= 2', 'v:val * 10'), [20,30])
|
||||
|
||||
TAssert IsEqual(tlib#list#Find([1,2,3], 'v:val >= 2'), 2)
|
||||
TAssert IsEqual(tlib#list#Find([1,2,3], 'v:val >= 2', 0, 'v:val * 10'), 20)
|
||||
TAssert IsEqual(tlib#list#Find([1,2,3], 'v:val >= 5', 10), 10)
|
||||
|
||||
TAssert IsEqual(tlib#list#Any([1,2,3], 'v:val >= 2'), 1)
|
||||
TAssert IsEqual(tlib#list#Any([1,2,3], 'v:val >= 5'), 0)
|
||||
|
||||
TAssert IsEqual(tlib#list#All([1,2,3], 'v:val < 5'), 1)
|
||||
TAssert IsEqual(tlib#list#All([1,2,3], 'v:val >= 2'), 0)
|
||||
|
||||
TAssert IsEqual(tlib#list#Remove([1,2,1,2], 2), [1,1,2])
|
||||
TAssert IsEqual(tlib#list#RemoveAll([1,2,1,2], 2), [1,1])
|
||||
|
||||
TAssert IsEqual(tlib#list#Zip([[1,2,3], [4,5,6]]), [[1,4], [2,5], [3,6]])
|
||||
TAssert IsEqual(tlib#list#Zip([[1,2,3], [4,5,6,7]]), [[1,4], [2,5], [3,6], ['', 7]])
|
||||
TAssert IsEqual(tlib#list#Zip([[1,2,3], [4,5,6,7]], -1), [[1,4], [2,5], [3,6], [-1,7]])
|
||||
TAssert IsEqual(tlib#list#Zip([[1,2,3,7], [4,5,6]], -1), [[1,4], [2,5], [3,6], [7,-1]])
|
||||
|
||||
|
||||
" Vars {{{2
|
||||
let g:foo = 1
|
||||
let g:bar = 2
|
||||
let b:bar = 3
|
||||
let s:bar = 4
|
||||
|
||||
TAssert IsEqual(tlib#var#Get('bar', 'bg'), 3)
|
||||
TAssert IsEqual(tlib#var#Get('bar', 'g'), 2)
|
||||
TAssert IsEqual(tlib#var#Get('foo', 'bg'), 1)
|
||||
TAssert IsEqual(tlib#var#Get('foo', 'g'), 1)
|
||||
TAssert IsEqual(tlib#var#Get('none', 'l'), '')
|
||||
|
||||
TAssert IsEqual(eval(tlib#var#EGet('bar', 'bg')), 3)
|
||||
TAssert IsEqual(eval(tlib#var#EGet('bar', 'g')), 2)
|
||||
" TAssert IsEqual(eval(tlib#var#EGet('bar', 'sg')), 4)
|
||||
TAssert IsEqual(eval(tlib#var#EGet('foo', 'bg')), 1)
|
||||
TAssert IsEqual(eval(tlib#var#EGet('foo', 'g')), 1)
|
||||
TAssert IsEqual(eval(tlib#var#EGet('none', 'l')), '')
|
||||
|
||||
unlet g:foo
|
||||
unlet g:bar
|
||||
unlet b:bar
|
||||
|
||||
|
||||
|
||||
" Filenames {{{2
|
||||
TAssert IsEqual(tlib#file#Split('foo/bar/filename.txt'), ['foo', 'bar', 'filename.txt'])
|
||||
TAssert IsEqual(tlib#file#Split('/foo/bar/filename.txt'), ['', 'foo', 'bar', 'filename.txt'])
|
||||
TAssert IsEqual(tlib#file#Split('ftp://foo/bar/filename.txt'), ['ftp:/', 'foo', 'bar', 'filename.txt'])
|
||||
|
||||
TAssert IsEqual(tlib#file#Join(['foo', 'bar', 'filename.txt']), 'foo/bar/filename.txt')
|
||||
TAssert IsEqual(tlib#file#Join(['', 'foo', 'bar', 'filename.txt']), '/foo/bar/filename.txt')
|
||||
TAssert IsEqual(tlib#file#Join(['ftp:/', 'foo', 'bar', 'filename.txt']), 'ftp://foo/bar/filename.txt')
|
||||
|
||||
TAssert IsEqual(tlib#file#Relative('foo/bar/filename.txt', 'foo'), 'bar/filename.txt')
|
||||
TAssert IsEqual(tlib#file#Relative('foo/bar/filename.txt', 'foo/base'), '../bar/filename.txt')
|
||||
TAssert IsEqual(tlib#file#Relative('filename.txt', 'foo/base'), '../../filename.txt')
|
||||
TAssert IsEqual(tlib#file#Relative('/foo/bar/filename.txt', '/boo/base'), '../../foo/bar/filename.txt')
|
||||
TAssert IsEqual(tlib#file#Relative('/bar/filename.txt', '/boo/base'), '../../bar/filename.txt')
|
||||
TAssert IsEqual(tlib#file#Relative('/foo/bar/filename.txt', '/base'), '../foo/bar/filename.txt')
|
||||
TAssert IsEqual(tlib#file#Relative('c:/bar/filename.txt', 'x:/boo/base'), 'c:/bar/filename.txt')
|
||||
|
||||
|
||||
|
||||
" Prototype-based programming {{{2
|
||||
let test = tlib#Test#New()
|
||||
TAssert test.IsA('Test')
|
||||
TAssert !test.IsA('foo')
|
||||
TAssert test.RespondTo('RespondTo')
|
||||
TAssert !test.RespondTo('RespondToNothing')
|
||||
let test1 = tlib#Test#New()
|
||||
TAssert test.IsRelated(test1)
|
||||
let testworld = tlib#World#New()
|
||||
TAssert !test.IsRelated(testworld)
|
||||
|
||||
let testc = tlib#TestChild#New()
|
||||
TAssert IsEqual(testc.Dummy(), 'TestChild.vim')
|
||||
TAssert IsEqual(testc.Super('Dummy', []), 'Test.vim')
|
||||
|
||||
|
||||
|
||||
" Optional arguments {{{2
|
||||
function! TestGetArg(...) "{{{3
|
||||
exec tlib#arg#Get(1, 'foo', 1)
|
||||
return foo
|
||||
endf
|
||||
|
||||
function! TestGetArg1(...) "{{{3
|
||||
exec tlib#arg#Get(1, 'foo', 1, '!= ""')
|
||||
return foo
|
||||
endf
|
||||
|
||||
TAssert IsEqual(TestGetArg(), 1)
|
||||
TAssert IsEqual(TestGetArg(''), '')
|
||||
TAssert IsEqual(TestGetArg(2), 2)
|
||||
TAssert IsEqual(TestGetArg1(), 1)
|
||||
TAssert IsEqual(TestGetArg1(''), 1)
|
||||
TAssert IsEqual(TestGetArg1(2), 2)
|
||||
|
||||
function! TestArgs(...) "{{{3
|
||||
exec tlib#arg#Let([['foo', "o"], ['bar', 2]])
|
||||
return repeat(foo, bar)
|
||||
endf
|
||||
TAssert IsEqual(TestArgs(), 'oo')
|
||||
TAssert IsEqual(TestArgs('a'), 'aa')
|
||||
TAssert IsEqual(TestArgs('a', 3), 'aaa')
|
||||
|
||||
function! TestArgs1(...) "{{{3
|
||||
exec tlib#arg#Let(['foo', ['bar', 2]])
|
||||
return repeat(foo, bar)
|
||||
endf
|
||||
TAssert IsEqual(TestArgs1(), '')
|
||||
TAssert IsEqual(TestArgs1('a'), 'aa')
|
||||
TAssert IsEqual(TestArgs1('a', 3), 'aaa')
|
||||
|
||||
function! TestArgs2(...) "{{{3
|
||||
exec tlib#arg#Let(['foo', 'bar'], 1)
|
||||
return repeat(foo, bar)
|
||||
endf
|
||||
TAssert IsEqual(TestArgs2(), '1')
|
||||
TAssert IsEqual(TestArgs2('a'), 'a')
|
||||
TAssert IsEqual(TestArgs2('a', 3), 'aaa')
|
||||
|
||||
function! TestArgs3(...)
|
||||
TVarArg ['a', 1], 'b'
|
||||
return a . b
|
||||
endf
|
||||
TAssert IsEqual(TestArgs3(), '1')
|
||||
TAssert IsEqual(TestArgs3('a'), 'a')
|
||||
TAssert IsEqual(TestArgs3('a', 3), 'a3')
|
||||
|
||||
delfunction TestGetArg
|
||||
delfunction TestGetArg1
|
||||
delfunction TestArgs
|
||||
delfunction TestArgs1
|
||||
delfunction TestArgs2
|
||||
delfunction TestArgs3
|
||||
|
||||
|
||||
|
||||
" Strings {{{2
|
||||
TAssert IsString(tlib#string#RemoveBackslashes('foo bar'))
|
||||
TAssert IsEqual(tlib#string#RemoveBackslashes('foo bar'), 'foo bar')
|
||||
TAssert IsEqual(tlib#string#RemoveBackslashes('foo\ bar'), 'foo bar')
|
||||
TAssert IsEqual(tlib#string#RemoveBackslashes('foo\ \\bar'), 'foo \\bar')
|
||||
TAssert IsEqual(tlib#string#RemoveBackslashes('foo\ \\bar', '\ '), 'foo \bar')
|
||||
|
||||
|
||||
|
||||
" Regexp {{{2
|
||||
for c in split('^$.*+\()|{}[]~', '\zs')
|
||||
let s = printf('%sfoo%sbar%s', c, c, c)
|
||||
TAssert (s =~ '\m^'. tlib#rx#Escape(s, 'm') .'$')
|
||||
TAssert (s =~ '\M^'. tlib#rx#Escape(s, 'M') .'$')
|
||||
TAssert (s =~ '\v^'. tlib#rx#Escape(s, 'v') .'$')
|
||||
TAssert (s =~ '\V\^'. tlib#rx#Escape(s, 'V') .'\$')
|
||||
endfor
|
||||
|
||||
|
||||
" Encode, decode
|
||||
TAssert IsEqual(tlib#url#Decode('http://example.com/foo+bar%25bar'), 'http://example.com/foo bar%bar')
|
||||
TAssert IsEqual(tlib#url#Decode('Hello%20World.%20%20Good%2c%20bye.'), 'Hello World. Good, bye.')
|
||||
|
||||
TAssert IsEqual(tlib#url#Encode('foo bar%bar'), 'foo+bar%%bar')
|
||||
TAssert IsEqual(tlib#url#Encode('Hello World. Good, bye.'), 'Hello+World.+Good%2c+bye.')
|
||||
|
||||
TAssertEnd test test1 testc testworld
|
||||
|
||||
|
||||
TAssert IsEqual(tlib#string#Count("fooo", "o"), 3)
|
||||
TAssert IsEqual(tlib#string#Count("***", "\\*"), 3)
|
||||
TAssert IsEqual(tlib#string#Count("***foo", "\\*"), 3)
|
||||
TAssert IsEqual(tlib#string#Count("foo***", "\\*"), 3)
|
||||
|
||||
|
||||
finish "{{{1
|
||||
|
||||
|
||||
" Input {{{2
|
||||
echo tlib#input#List('s', 'Test', ['barfoobar', 'barFoobar'])
|
||||
echo tlib#input#List('s', 'Test', ['barfoobar', 'bar foo bar', 'barFoobar'])
|
||||
echo tlib#input#List('s', 'Test', ['barfoobar', 'bar1Foo1bar', 'barFoobar'])
|
||||
echo tlib#input#EditList('Test', ['bar1', 'bar2', 'bar3', 'foo1', 'foo2', 'foo3'])
|
||||
|
||||
|
||||
|
|
@ -1 +0,0 @@
|
|||
doc/tags
|
||||
|
|
@ -1,24 +0,0 @@
|
|||
" buf_identifier is either a buf_nr or a filename
|
||||
" If any window shows the buffer move to the buffer
|
||||
" If not show it in current window (by c-w s c^ you can always
|
||||
" reshow the last buffer
|
||||
"
|
||||
" Example: buf_utils#GotoBuf("/tmp/tfile.txt", {'create': 1})
|
||||
" returns: The command which was used to switch to the buffer
|
||||
fun! buf_utils#GotoBuf(buf_identifier, opts)
|
||||
let buf_nr = bufnr(a:buf_identifier)
|
||||
if buf_nr == -1 && ( get(a:opts, 'create', 0) || has_key(a:opts, 'create_cmd'))
|
||||
exec get(a:opts,'create_cmd','e').' '.fnameescape(a:buf_identifier)
|
||||
return "e"
|
||||
else
|
||||
let win_nr = bufwinnr(buf_nr)
|
||||
if win_nr == -1
|
||||
exec 'b '.buf_nr
|
||||
return "b"
|
||||
else
|
||||
exec win_nr.'wincmd w'
|
||||
return "w"
|
||||
endif
|
||||
wincmd w"
|
||||
endif
|
||||
endf
|
||||
|
|
@ -1,104 +0,0 @@
|
|||
" cached_file_contents.vim
|
||||
" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
|
||||
" @Last Change: 2010-01-03.
|
||||
" @Revision: 0.3.0
|
||||
|
||||
"exec vam#DefineAndBind('s:c','g:cache_dir_options','{}')
|
||||
if !exists('g:cache_dir_options') | let g:cache_dir_options = {} | endif | let s:c = g:cache_dir_options
|
||||
|
||||
let s:c['cache_dir'] = get(s:c, 'cache_dir', expand('$HOME').'/.vim-cache')
|
||||
let s:c['scanned_files'] = get(s:c, 'scanned_files', {})
|
||||
let s:scanned_files = s:c['scanned_files']
|
||||
|
||||
|
||||
let s:define_cache_file = "let this_dir = s:c['cache_dir'].'/cached-file-contents' | let cache_file = expand(this_dir.'/'.substitute(string([func_as_string, a:file]),'[[\\]{}:/\\,''\"# ]\\+','_','g'))"
|
||||
|
||||
" read a file, run function to extract contents and cache the result returned
|
||||
" by that function in memory. Optionally the result can be cached on disk as
|
||||
" because VimL can be slow!
|
||||
"
|
||||
" file : the file to be read
|
||||
" func: { 'func': function which will be called by funcref#Call
|
||||
" , 'version' : if this version changes cache will be invalidate automatically
|
||||
" , 'ftime_check': optional, default 1. if set to 0 cache isn't updated when file changes and file is in cache
|
||||
" }
|
||||
"
|
||||
" default: what to return if file doesn't exist
|
||||
" think twice about adding lines. This function is called many times.
|
||||
function! cached_file_contents#CachedFileContents(file, func, ...) abort
|
||||
let ignore_ftime = a:0 > 0 ? a:1 : 0
|
||||
" using string for default so that is evaluated when needed only
|
||||
let use_file_cache = get(a:func, 'use_file_cache', 0)
|
||||
|
||||
" simple kind of normalization. necessary when using file caching
|
||||
" this seems to be slower:
|
||||
" let file = fnamemodify(a:file, ':p') " simple kind of normalization. necessary when using file caching
|
||||
" / = assume its an absolute path
|
||||
" let file = a:file[0] == '/' ? a:file : expand(a:file, ':p')
|
||||
let file = a:file[0] == '/' ? a:file : fnamemodify(a:file, ':p') " simple kind of normalization. necessary when using file caching
|
||||
let func_as_string = string(a:func['func'])
|
||||
|
||||
if (!has_key(s:scanned_files, func_as_string))
|
||||
let s:scanned_files[func_as_string] = {}
|
||||
endif
|
||||
let dict = s:scanned_files[func_as_string]
|
||||
if use_file_cache && !has_key(dict, a:file)
|
||||
exec s:define_cache_file
|
||||
if filereadable(cache_file)
|
||||
let dict[file] = eval(readfile(cache_file,'b')[0])
|
||||
endif
|
||||
endif
|
||||
if has_key(dict, a:file)
|
||||
let d = dict[a:file]
|
||||
if use_file_cache
|
||||
\ && (ignore_ftime || getftime(a:file) <= d['ftime'])
|
||||
\ && d['version'] == a:func['version']
|
||||
return dict[a:file]['scan_result']
|
||||
endif
|
||||
endif
|
||||
let scan_result = funcref#Call(a:func['func'], [a:file] )
|
||||
let dict[a:file] = {"ftime": getftime(a:file), 'version': a:func['version'], "scan_result": scan_result }
|
||||
if use_file_cache
|
||||
if !exists('cache_file') | exec s:define_cache_file | endif
|
||||
if !isdirectory(this_dir) | call mkdir(this_dir,'p',0700) | endif
|
||||
call writefile([string(dict[a:file])], cache_file)
|
||||
endif
|
||||
return scan_result
|
||||
endfunction
|
||||
|
||||
fun! cached_file_contents#ClearScanCache()
|
||||
let s:c['scanned_files'] = {}
|
||||
|
||||
" Don't run rm -fr. Ask user to run it. It cache_dir may have been set to
|
||||
" $HOME ! (should nevere be the case but who knows
|
||||
echoe "run manually in your shell: rm -fr ".shellescape(s:c['cache_dir'])."/*"
|
||||
endf
|
||||
|
||||
fun! cached_file_contents#Test()
|
||||
|
||||
" usually you use a global option so that the function can be reused
|
||||
let my_interpreting_func = {'func' : funcref#Function('return len(readfile(ARGS[0]))'), 'version': 2, 'use_file_cache':1}
|
||||
let my_interpreting_func2 = {'func' : funcref#Function('return ARGS[0]') , 'version': 2, 'use_file_cache':1}
|
||||
|
||||
let tmp = tempname()
|
||||
call writefile(['some text','2nd line'], tmp)
|
||||
|
||||
let r = [ cached_file_contents#CachedFileContents(tmp, my_interpreting_func)
|
||||
\ , cached_file_contents#CachedFileContents(tmp, my_interpreting_func2) ]
|
||||
if r != [2, tmp]
|
||||
throw "test failed 1, got ".string(r)
|
||||
endif
|
||||
unlet r
|
||||
|
||||
sleep 3
|
||||
|
||||
" now let's change contents
|
||||
call writefile(['some text','2nd line','3rd line'], tmp)
|
||||
|
||||
let r = cached_file_contents#CachedFileContents(tmp, my_interpreting_func)
|
||||
if 3 != r
|
||||
throw "test failed 2, got ".string(r)
|
||||
endif
|
||||
|
||||
echo "test passed"
|
||||
endf
|
||||
|
|
@ -1,12 +0,0 @@
|
|||
" in sh/bash you can type export to get a list of environment variables
|
||||
" This function assigns those env vars to Vim.
|
||||
" Does not delete env vars yet
|
||||
" Example: env_reload#ReloadEnv(system("sh -c 'export'")
|
||||
fun! env_reload#ReloadEnv(bash_export_command_output)
|
||||
for i in split(a:bash_export_command_output,"\n")
|
||||
let m = matchlist(i, 'export \([^=]\+\)="\(.*\)"')
|
||||
if empty(m) | continue | endif
|
||||
" don't care about quoted values right now.
|
||||
exec 'let $'.m[1].'='.string(m[2])
|
||||
endfor
|
||||
endf
|
||||
|
|
@ -1,95 +0,0 @@
|
|||
" funcref.vim
|
||||
" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
|
||||
" @Last Change: 2010-01-03.
|
||||
" @Revision: 0.1.0
|
||||
|
||||
" documentation see doc/funcref.txt
|
||||
|
||||
" usage:
|
||||
" funcref#Function("filename#Function")
|
||||
" optionally pass arguments:
|
||||
" funcref#Function("filename#Function",{'args': [2]})
|
||||
" optionally define self:
|
||||
" funcref#Function("filename#Function",{'self': object})
|
||||
function! funcref#Function(name,...)
|
||||
let d = a:0 > 0 ? a:1 : {}
|
||||
let d['faked_function_reference'] = a:name
|
||||
return d
|
||||
endfunction
|
||||
|
||||
" args : same as used for call(f,[args], self)
|
||||
" f must be either
|
||||
" - a string which can be evaled (use "return 'value'" to return a value)
|
||||
" - a Vim function reference created by function('..')
|
||||
" - a faked function reference created by funcref#Function(..)
|
||||
"
|
||||
" the last "self" argument can be overriden by the function reference
|
||||
" You can pass arguments in a closure like style
|
||||
function! funcref#Call(...)
|
||||
let args = copy(a:000)
|
||||
|
||||
" add parameters:
|
||||
if (len(args) < 2)
|
||||
call add(args, [])
|
||||
endif
|
||||
|
||||
|
||||
let isDict = type(args[0]) == type({})
|
||||
|
||||
" prepend parameters which were passed by faked function reference:
|
||||
if isDict && has_key(args[0], 'args')
|
||||
let args[1] = args[0]['args']+args[1]
|
||||
endif
|
||||
|
||||
" always pass self. this way you can call functions from dictionaries not
|
||||
" refering to self
|
||||
if (len(args) < 3)
|
||||
call add(args, {})
|
||||
endif
|
||||
|
||||
" the funcref overrides self:
|
||||
if isDict && has_key(args[0], 'self')
|
||||
let args[2] = args[0]['self']
|
||||
endif
|
||||
|
||||
if type(a:1) == 2
|
||||
" funcref: function must have been laoded
|
||||
return call(function('call'), args)
|
||||
elseif isDict && has_key(args[0], 'faked_function_reference')
|
||||
let Fun = args[0]['faked_function_reference']
|
||||
if type(Fun) == type('')
|
||||
\ && (Fun[:len('return ')-1] == 'return '
|
||||
\ || Fun[:len('call ')-1] == 'call '
|
||||
\ || Fun[:len('if ')-1] == 'if '
|
||||
\ || Fun[:len('let ')-1] == 'let '
|
||||
\ || Fun[:len('echo ')-1] == 'echo '
|
||||
\ || Fun[:len('exec ')-1] == 'exec '
|
||||
\ || Fun[:len('debug ')-1] == 'debug ')
|
||||
" it doesn't make sense to list all vim commands here
|
||||
" So if you want to execute another action consider using
|
||||
" funcref#Function('exec '.string('aw')) or such
|
||||
|
||||
" function is a String, call exec
|
||||
let ARGS = args[1]
|
||||
let SELF = args[2]
|
||||
exec Fun
|
||||
else
|
||||
" pseudo function, let's load it..
|
||||
if type(Fun) == 1
|
||||
if !exists('*'.Fun)
|
||||
" lazily load function
|
||||
let file = substitute(substitute(Fun,'#[^#]*$','',''),'#','/','g')
|
||||
exec 'runtime /autoload/'.file.'.vim'
|
||||
endif
|
||||
let Fun2 = function(Fun)
|
||||
else
|
||||
let Fun2 = Fun
|
||||
endif
|
||||
let args[0] = Fun
|
||||
return call(function('call'), args)
|
||||
endif
|
||||
else
|
||||
" no function, return the value
|
||||
return args[0]
|
||||
endif
|
||||
endfunction
|
||||
|
|
@ -1,27 +0,0 @@
|
|||
exec vam#DefineAndBind('s:c','g:glob_like', '{}')
|
||||
|
||||
" ignore vcs stuff, Don't think you want those..
|
||||
let s:c['regex_ignore_directory'] = '\<\%([_.]darcs\|\.git\|.svn\|.hg\|.cvs\|.bzr\)\>'
|
||||
let s:c['glob_cache'] = get(s:c, 'glob_cache', {})
|
||||
let s:glob_cache = s:c['glob_cache']
|
||||
|
||||
fun! glob#Glob(pattern, ...)
|
||||
let pattern = a:pattern
|
||||
if pattern[0] == '~'
|
||||
let pattern = $HOME.pattern[1:]
|
||||
endif
|
||||
let opts = a:0 > 0 ? a:1 : {}
|
||||
" never cache current directory. You're very likely to edit files in it.
|
||||
|
||||
let c = getcwd()
|
||||
let cachable = get(opts, 'cachable', 0) && pattern[:len(c)-1] != c
|
||||
if cachable && has_key(s:glob_cache, pattern)
|
||||
return s:glob_cache[pattern]
|
||||
endif
|
||||
|
||||
" FIXME: don't recurse into \.git directory (thus reimplement glob in vimL!)
|
||||
let r = filter(split(glob(pattern),"\n"),'v:val !~ '.string(s:c['regex_ignore_directory']))
|
||||
if cachable | let s:glob_cache[pattern] = r | endif
|
||||
return r
|
||||
endf
|
||||
|
||||
|
|
@ -1,19 +0,0 @@
|
|||
" vim suffers:
|
||||
|
||||
exec vam#DefineAndBind('s:c','g:vim_tiny_cmd', '{}')
|
||||
|
||||
fun! tiny_cmd#Put(a)
|
||||
let new = get(s:c,'next',0) +1
|
||||
let s:c['next'] = new
|
||||
let s:c[new] = a:a
|
||||
return new
|
||||
endf
|
||||
|
||||
fun! tiny_cmd#Get(nr)
|
||||
return s:c[a:nr]
|
||||
endf
|
||||
|
||||
" Get and remove item
|
||||
fun! tiny_cmd#Pop(nr)
|
||||
let r = s:c[a:nr] | unlet s:c[a:nr] | return r
|
||||
endf
|
||||
|
|
@ -1,103 +0,0 @@
|
|||
" old code
|
||||
|
||||
augroup TOVLWrite
|
||||
augroup end
|
||||
|
||||
" =========== scratch buffer =========================================
|
||||
" a scratch buffer is a temporary buffer where the user can enter some text
|
||||
" It can be used to get commit messages, edit configuration options and so on
|
||||
|
||||
function! tovl#scratch_buffer#KeepIntactLineNr()
|
||||
let i = 0
|
||||
while getline(i)!= b:keepIntact && i < line('$')
|
||||
let i = i+1
|
||||
endwhile
|
||||
if i > line('$')
|
||||
return -1
|
||||
else
|
||||
return i
|
||||
endif
|
||||
endfunction
|
||||
|
||||
" opens a buffer and runs an action when the buffer is written
|
||||
" keys:
|
||||
" name : the name of the buffer
|
||||
" onWrite : will be called on write
|
||||
" onWrite is responsible for setlocal nomodified to indicate that
|
||||
" saving has been successful
|
||||
" help : callback returning additional information lines
|
||||
" getContent : callback returning lines
|
||||
" cmds : extra commands to be run (optional)
|
||||
" (maybe you prefer adding them the default way afer the
|
||||
" ScratchBuffer call. They'll be rerun on GetContents
|
||||
" sp_cmd : the command to use to create the new buffer. Defaults to :e
|
||||
" buftype : ...
|
||||
" modifiable : 1 / 0 defaults to 1
|
||||
function! tovl#scratch_buffer#ScratchBuffer(opts)
|
||||
let a:opts['name'] = get(a:opts,'name', 'strach_buffer_without_name')
|
||||
exec get(a:opts, 'sp_cmd', 'e').' '.escape(a:opts['name'],' ')
|
||||
let b:settings = a:opts
|
||||
let b:settings['modifiable'] = get(a:opts,'modifiable', 1)
|
||||
setlocal buftype=acwrite
|
||||
command! -buffer -nargs=0 Help call tovl#scratch_buffer#Help()
|
||||
|
||||
" setup write notification
|
||||
au TOVLWrite BufWriteCmd <buffer> call tovl#scratch_buffer#Write()
|
||||
|
||||
if has_key(a:opts,'getContent')
|
||||
command! -buffer -nargs=0 GetContents call tovl#scratch_buffer#GetContents()
|
||||
GetContents
|
||||
if !b:settings['modifiable']
|
||||
setlocal nomodifiable
|
||||
endif
|
||||
endif
|
||||
"let u=&undolevels
|
||||
"setlocal undolevels=-1
|
||||
"exec 'setlocal undolevels='.u
|
||||
|
||||
" mark buffer as not modified
|
||||
setlocal nomodified
|
||||
|
||||
au BufReadCmd <buffer> GetContents
|
||||
|
||||
" run addittional commands
|
||||
for cmd in get(a:opts,'cmds',[])
|
||||
exec cmd
|
||||
endfor
|
||||
silent echo get(a:opts,'echo_help', "type :Help for help")
|
||||
endfunction
|
||||
|
||||
" =========== utility functions ======================================
|
||||
|
||||
function! tovl#scratch_buffer#Write()
|
||||
if has_key(b:settings, 'onWrite')
|
||||
call funcref#Call(b:settings['onWrite'])
|
||||
else
|
||||
echo "don't know how to write. Option hasn't been passed"
|
||||
endif
|
||||
endfunction
|
||||
|
||||
function! tovl#scratch_buffer#GetContents()
|
||||
setlocal modifiable
|
||||
" empty buffer
|
||||
%g!//d
|
||||
call append(0, funcref#Call(b:settings['getContent']))
|
||||
if !b:settings['modifiable']
|
||||
setlocal nomodifiable
|
||||
endif
|
||||
for cmd in get(b:settings,'cmds',[])
|
||||
exec cmd
|
||||
endfor
|
||||
endfunction
|
||||
|
||||
function! tovl#scratch_buffer#Help()
|
||||
let help = ["use :e! to reload contents, ZZ or :w(q) to write and quit"
|
||||
\ ,""
|
||||
\ ,"Help for this scratch buffer:"
|
||||
\ ,"=======================================================","",""]
|
||||
\ + funcref#Call(get(b:settings, 'help', []))
|
||||
call tovl#scratch_buffer#ScratchBuffer({
|
||||
\ 'name' : "return Help of ".b:settings['name'],
|
||||
\ 'getContent' : help
|
||||
\ })
|
||||
endfunction
|
||||
|
|
@ -1,473 +0,0 @@
|
|||
" OLD CODE !
|
||||
" I should contribute the multiple filter feature to tlib
|
||||
|
||||
" filter list displays a list of items
|
||||
" you can white / black filter them by regular expressions (similar to the
|
||||
" tlib TToC command
|
||||
" However you can edit the filters afterwards and select the cols which should
|
||||
" be shown
|
||||
|
||||
fun! tovl#ui#filter_list#ListTest()
|
||||
call tovl#ui#filter_list#ListView({
|
||||
\ 'aligned' : 1,
|
||||
\ 'Continuation' : funcref#Function('echo string(ARGS[0])'),
|
||||
\ 'items' : [ {"aa" : "a\nAAAAAAAAAAA", 'bb' : "bbbbbbbbbbbbb\nB" },
|
||||
\ {"aa" : "2a\n2AAAAAAAAAAAA", "bb" : "2 bbbbbbbbbbbbb\n2B"},
|
||||
\ {"aa" : "XXX", "bb" : "YY"} ],
|
||||
\ })
|
||||
|
||||
endfun
|
||||
|
||||
fun! s:Intersection(a, b)
|
||||
return filter(copy(a:a), 'index(a:b, v:val) >= 0')
|
||||
endf
|
||||
|
||||
fun! tovl#ui#filter_list#ListTestGotoLineCurrentBuf()
|
||||
let nr=1
|
||||
let lines = []
|
||||
for l in getline(0,line('$'))
|
||||
call add(lines, {'nr': nr, 'line' :l})
|
||||
let nr = nr +1
|
||||
endfor
|
||||
call tovl#ui#filter_list#ListView({
|
||||
\ 'aligned' : 0,
|
||||
\ 'keys' : ['nr','line'],
|
||||
\ 'number' : 1,
|
||||
\ 'selectByIdOrFilter' : 1,
|
||||
\ 'Continuation' : funcref#Function('exec ARGS[0]["nr"]'),
|
||||
\ 'items' : lines,
|
||||
\ })
|
||||
endfun
|
||||
|
||||
" opens a new filtered list
|
||||
" keys of opts parameters:
|
||||
" Continuation: This function will be called with the selected items
|
||||
" items: { key : (string or dict) }
|
||||
" items willl be modified. use copy(youritems) as argument to prevent
|
||||
" this. An item is either a string or a dict
|
||||
" (eg {'file' : .., 'line': ... , 'msg' : .. )
|
||||
" keys: list of keys to be shown (optional)
|
||||
" filter: list of inital filters which must be applied
|
||||
" contains [ { filter: .. , keep : .. }, ] see FilterItems() below
|
||||
" aligned: default 0
|
||||
" sp_cmd: the command to be used to create the new buffer (default ':e')
|
||||
" init : 0 / 1 (default 1): wether to show the view right now
|
||||
" number: 0 /1 (default 1): number items ?
|
||||
" selectByIdOrFilter: 1: start in getchar() loop so that the user can select
|
||||
" the item even faster
|
||||
" auto: only do this if all items fit on screen
|
||||
" (recommend)
|
||||
" cmds: extra cmds to be run
|
||||
" cursorAt : at which item to put the cursor?
|
||||
"
|
||||
" If you don't like the default view you can override UpdateDisplay
|
||||
"
|
||||
" Usage examples of this list control:
|
||||
" - db results
|
||||
" - replacement of the quickfix window
|
||||
" - select a buffer etc
|
||||
fun! tovl#ui#filter_list#ListView(opts)
|
||||
" ActivateAddons theonevimlib
|
||||
let d = {}
|
||||
let d.items = a:opts.items
|
||||
let d.cursorAt = get(a:opts, 'cursorAt', 0)
|
||||
let d.aligned = get(a:opts, 'aligned', 0)
|
||||
let d.sep = ' '
|
||||
let d.filter = get(a:opts, 'filter', [])
|
||||
" using sp because of bd! (FIXME)
|
||||
let d.sp_cmd = get(a:opts, 'sp_cmd', 'sp')
|
||||
let d.allKeys = {}
|
||||
let d.closeOnContinuation = get(a:opts,'closeOnContinuation',1)
|
||||
" don't recommend OnSingleMatch, use OnSingleMatchCR instead
|
||||
let d.continueOnSingleMatch = get(a:opts, 'continueOnSingleMatch',0)
|
||||
let d.continueOnSingleMatchCR = get(a:opts, 'continueOnSingleMatchCR',1)
|
||||
let d.selectByIdOrFilter = get(a:opts, 'selectByIdOrFilter', 0)
|
||||
let d.linesToItems = {}
|
||||
let d.number = get(a:opts, 'number', 1)
|
||||
let d.cmds = get(a:opts, 'cmds', [])
|
||||
let d.syn_cmds = get(a:opts, 'syn_cmds', [])
|
||||
|
||||
if has_key(a:opts,'keys') | let d.keys = a:opts.keys | endif
|
||||
if has_key(a:opts,'Continuation') | let d.Continuation = a:opts.Continuation | endif
|
||||
|
||||
" cache already filtered items in case we want to view really long results
|
||||
" contains [ { filter : { regex: .. , keep : .. } , items : .. , cursorAt :},
|
||||
" { filter : { ... } , items: .. , cursorAt : }
|
||||
let d.cached = []
|
||||
" id of buffer
|
||||
let d.buffer = -1
|
||||
let d.modeText = ''
|
||||
|
||||
fun d.HelpText()
|
||||
return [ "you've entered the the help of the powerful filtered view buffer",
|
||||
\ "",
|
||||
\ "type f to start filtering items by regex",
|
||||
\ "type F to start dropping items by regex",
|
||||
\ "k / K will ask you for the key to apply the filter to first",
|
||||
\ "apply the filter by <cr> and press <cr> again to select item",
|
||||
\ "",
|
||||
\ "use :ShowAppliedFilters to list active filters",
|
||||
\ "use :ToggleAlignment to toggle alignment",
|
||||
\ "",
|
||||
\ "TODO: Implement sorting, implement interface to change keys (displayed columns)"
|
||||
\ ]
|
||||
endfun
|
||||
|
||||
" create new scratch buffer
|
||||
" preprocess items calculating line count and maxwidth for all items
|
||||
fun d.NewBufferAndInit()
|
||||
let self.bufferId = bufnr(bufname('%'))
|
||||
for idx in range(0,len(self.items)-1)
|
||||
if type(self.items[idx]) != 4
|
||||
" no dict yet, make it one
|
||||
let self.items[idx] = {'string_line' : self.items[idx]}
|
||||
endif
|
||||
let new = {}
|
||||
for [k,v] in items(self.items[idx])
|
||||
let lines = split(v,"\n")
|
||||
let self.items[idx][k] = { 'text' : v, 'rows' : len(lines), 'cols' : max(map(copy(lines),'len(v:val)')), 'lines' : lines }
|
||||
let self.allKeys[k] = 1
|
||||
unlet k v
|
||||
endfor
|
||||
endfor
|
||||
call tovl#scratch_buffer#ScratchBuffer({
|
||||
\ 'help' : funcref#Function(self.HelpText,{ 'self' : self }),
|
||||
\ 'sp_cmd' : self.sp_cmd,
|
||||
\ 'cmds' : self.cmds
|
||||
\ })
|
||||
" I assume we have some kind of formatting anyway. Thus breaking lines is bad!
|
||||
set nowrap
|
||||
setlocal cursorline
|
||||
let b:filtered_view = self
|
||||
command! -buffer -nargs=0 ToggleAlignment call b:filtered_view.ToggleAlignment()
|
||||
command! -buffer -nargs=0 ShowAppliedFilters call b:filtered_view.ShowAppliedFilters()
|
||||
command! -buffer -nargs=0 RemoveFilters call b:filtered_view.RemoveFilters()
|
||||
noremap <buffer> f :call b:filtered_view.FilterFromKeyboard(1,'')<cr>
|
||||
" noremap <buffer> f :call b:filtered_view.FilterFromKeyboard(1)<cr>
|
||||
noremap <buffer> F :call b:filtered_view.FilterFromKeyboard(0,'')<cr>
|
||||
if has_key(self,'Continuation')
|
||||
nnoremap <buffer> <cr> :call b:filtered_view.Continue()<cr>
|
||||
endif
|
||||
"noremap <buffer> k
|
||||
"noremap <buffer> K
|
||||
|
||||
let [items, cursorAt] = self.FilteredItems()
|
||||
" len(items) is an approximation because one item can have multiple
|
||||
" lines.. However adding the lines first to check takes too much time
|
||||
if self.selectByIdOrFilter == 1 || (self.selectByIdOrFilter == 'auto' && winheight('%') > len(items) )
|
||||
call self.SelectByIdOrFilter()
|
||||
else
|
||||
" user should choose how to proceed
|
||||
call self.UpdateDisplay()
|
||||
endif
|
||||
endfun
|
||||
|
||||
" user interface
|
||||
fun d.ToggleAlignment()
|
||||
let self.aligned = !self.aligned
|
||||
call self.UpdateDisplay()
|
||||
endfun
|
||||
fun d.ShowAppliedFilters()
|
||||
for i in self.filter | echo string(i) | endfor
|
||||
endfun
|
||||
fun d.RemoveFilters()
|
||||
let self.filter = []
|
||||
call self.UpdateDisplay()
|
||||
endfun
|
||||
fun d.Continue()
|
||||
let item = self.CurrentItem()
|
||||
call self.DoContinue(item)
|
||||
endfun
|
||||
fun d.DoContinue(v)
|
||||
if self.closeOnContinuation | bw! | endif
|
||||
call funcref#Call(self.Continuation,[a:v])
|
||||
endfun
|
||||
|
||||
fun d.MapToOriginal(v)
|
||||
if has_key(a:v, 'string_line')
|
||||
return a:v.string_line.text
|
||||
else
|
||||
let d = {}
|
||||
for [k,v] in items(a:v)
|
||||
let d[k] = v.text
|
||||
unlet k v
|
||||
endfor
|
||||
return d
|
||||
endif
|
||||
endfun
|
||||
|
||||
fun d.CurrentItem()
|
||||
let idx=line('.')-len(self.headerLines)
|
||||
while idx >= 0
|
||||
if has_key(self.linesToItems, idx)
|
||||
return self.MapToOriginal(self.FilteredItems()[0][self.linesToItems[idx]])
|
||||
else
|
||||
let idx = idx -1
|
||||
endif
|
||||
endwhile
|
||||
throw "internal error, couldn't determine selected item!"
|
||||
endfun
|
||||
|
||||
" updates the filter cache and returns the final filtered items
|
||||
fun d.FilteredItems()
|
||||
" update cache
|
||||
let idx = 0
|
||||
let [items, cursorAt] = [self.items, self.cursorAt]
|
||||
for idx in range(0, len(self.filter)-1)
|
||||
if idx +1 > len(self.cached) || self.cached[idx]['filter'] != self.filter[idx]
|
||||
let self.cached = self.cached[:idx-1]
|
||||
let [items, cursorAt] = self.FilterItem(copy(items), self.filter[idx], cursorAt)
|
||||
call add(self.cached, { 'cursorAt' : cursorAt, 'items' : items, 'filter' : self.filter[idx]})
|
||||
else
|
||||
let ci = self.cached[idx]
|
||||
let [items, cursorAt] = [ci['items'], ci['cursorAt']]
|
||||
endif
|
||||
endfor
|
||||
return [items, cursorAt]
|
||||
endfun
|
||||
|
||||
" calling this will return a set of lines which are expected to be the new
|
||||
" buffer contents. The self.linesToItems dict is updated
|
||||
fun d.UpdateDisplay()
|
||||
|
||||
if empty(self.filter)
|
||||
let self.statusline= 'no filter applied, :Help for help'
|
||||
else
|
||||
let self.statusline = len(self.filter).' '.string(self.filter[-1])
|
||||
endif
|
||||
|
||||
let self.linesToItems = {}
|
||||
let [items, cursorAt] = self.FilteredItems()
|
||||
"let num_width = printf('%.0f', trunc(log10(len(items))+1))
|
||||
let num_width = 4
|
||||
if self.aligned
|
||||
" get column width.. (probably will not work with unicde characters.. I
|
||||
" don't have a better solution)
|
||||
let maxlens={}
|
||||
for i in items
|
||||
for [k,v] in items(i)
|
||||
if get(maxlens,k,0) < v.cols
|
||||
let maxlens[k] = v.cols
|
||||
endif
|
||||
endfor
|
||||
endfor
|
||||
endif
|
||||
|
||||
" format lines
|
||||
let self.headerLines = [self.modeText]
|
||||
let lines = copy(self.headerLines)
|
||||
let lines_count = 0
|
||||
if self.number
|
||||
let fmt_startA = '%'.num_width.'s)'
|
||||
let fmt_startB = '%'.num_width.'s'
|
||||
else
|
||||
let fmt_startA = '' | let fmt_startB = ''
|
||||
endif
|
||||
let cursorAtLine = 1 " sane default
|
||||
for idx in range(0,len(items)-1)
|
||||
let self.linesToItems[lines_count + 1] = idx
|
||||
let i = items[idx]
|
||||
let keys = has_key(self,'keys')
|
||||
\ ? s:Intersection(self.keys, keys(i))
|
||||
\ : keys(i)
|
||||
let fmt = ''
|
||||
let args = [i]
|
||||
let cols = []
|
||||
for k in keys
|
||||
let fmt .= self.sep.'%-'.(self.aligned ? maxlens[k] : i[k]['cols']).'s'
|
||||
call add(cols, i[k])
|
||||
endfor
|
||||
for row in range(0, max([1] + map(copy(cols),'v:val["rows"]'))-1)
|
||||
let fmt_args = row == 0 ? [fmt_startA.fmt] : [fmt_startB.fmt]
|
||||
if self.number
|
||||
call add(fmt_args, row == 0 ? idx : '')
|
||||
endif
|
||||
for c in cols
|
||||
call add(fmt_args, c.rows <= row ? '' : c.lines[row])
|
||||
endfor
|
||||
call add(lines, call('printf', fmt_args))
|
||||
let lines_count += 1
|
||||
endfor
|
||||
if idx == cursorAt
|
||||
let cursorAtLine = lines_count
|
||||
endif
|
||||
endfor
|
||||
" update stauts line to show last applied filter
|
||||
" disabled cause it causes trouble on :wincmd w
|
||||
" setlocal statusline=%!b:filtered_view.statusline
|
||||
|
||||
" syntax
|
||||
syn clear
|
||||
for s in self.syn_cmds | exec s | endfor
|
||||
let id = 0
|
||||
" highlight filter regex in buffer as well
|
||||
let syn_ids = [ 'Underlined', 'Todo', 'Error', 'Type', 'Statement' ]
|
||||
for f in self.filter
|
||||
if !f.keep || !has_key(f, 'regex') | continue | endif
|
||||
if f.regex != ''
|
||||
try
|
||||
exec 'syn match '.syn_ids[id % len(syn_ids)].' '.string(f.regex)
|
||||
catch /.*/
|
||||
" ignore errors such as \ without following characters. Thus just
|
||||
" ignore and wait for the next character
|
||||
endtry
|
||||
endif
|
||||
let id = id +1
|
||||
endfor
|
||||
if len(lines) > winheight('%')
|
||||
call extend(lines, self.headerLines)
|
||||
endif
|
||||
normal ggdG
|
||||
call append(0, lines)
|
||||
" place cursor
|
||||
exec (cursorAtLine+1)
|
||||
" move cursor into the middle of the window
|
||||
normal zz
|
||||
endf
|
||||
|
||||
" filter = keys :
|
||||
" filter = string to be executed containing Val
|
||||
" keep = 1 keep on match
|
||||
" = 0 drop on match
|
||||
" key (optional)
|
||||
" cursorAt: at which item to put the cursor
|
||||
" if that item is deleted it will be placed at the item above
|
||||
" optional: key of dict if dict
|
||||
fun d.FilterItem(items, filter, cursorAt)
|
||||
let filter = 'Val =~ '.string(a:filter.regex)
|
||||
let keep = a:filter.keep
|
||||
let cursorAt = a:cursorAt
|
||||
|
||||
for idx in reverse(range(0, len(a:items)-1))
|
||||
let i = a:items[idx]
|
||||
if has_key(a:filter,'key')
|
||||
let key = a:filter.key
|
||||
if has_key(i, key)
|
||||
" key given, only filter by this column
|
||||
let Val = i[key]['text']
|
||||
exec 'let any = '.filter
|
||||
else
|
||||
let any = 0
|
||||
endif
|
||||
else
|
||||
let any = 0
|
||||
" no key given, try all
|
||||
for x in values(i)
|
||||
let Val = x['text']
|
||||
exec 'let any = '.filter
|
||||
if any | break | endif
|
||||
endfor
|
||||
endif
|
||||
if any != keep
|
||||
call remove(a:items, idx)
|
||||
if idx <= cursorAt
|
||||
let cursorAt = cursorAt -1
|
||||
endif
|
||||
endif
|
||||
endfor
|
||||
return [a:items, cursorAt]
|
||||
endfun
|
||||
|
||||
" if the user enters a number select by index else start filtering..
|
||||
fun d.SelectByIdOrFilter()
|
||||
let idx=''
|
||||
let items = self.FilteredItems()[0]
|
||||
try
|
||||
let self.modeText = '[0-9]* : select by index| <esc>: escape getchar() loop, any char: start filtering'
|
||||
call self.UpdateDisplay() | redraw
|
||||
while 1
|
||||
let c=getchar()
|
||||
if index([13,10],c) >= 0
|
||||
return self.DoContinue(self.MapToOriginal(items[idx]))
|
||||
elseif index([27], c) >=0
|
||||
" esc, abort
|
||||
return
|
||||
else
|
||||
if type(c) == 0
|
||||
let c = nr2char(c)
|
||||
endif
|
||||
if c == "\<bs>" || index(map(range(0,10),'v:val.""'),c) >= 0
|
||||
if c == "\<bs>"
|
||||
let idx = idx[:-2]
|
||||
else
|
||||
let idx .= c
|
||||
endif
|
||||
if idx < len(items) && idx.'0' > len(items) || idx == 0 && len(items) < 10
|
||||
" only match
|
||||
return self.DoContinue(self.MapToOriginal(items[idx]))
|
||||
endif
|
||||
else
|
||||
return self.FilterFromKeyboard(1,c)
|
||||
endif
|
||||
endif
|
||||
endwhile
|
||||
finally
|
||||
let self.modeText = ''
|
||||
endtry
|
||||
endfun
|
||||
|
||||
" gets a regular expresion filter by keybaord and updates the display while
|
||||
" you're typing. The regex ist shown in the statusline
|
||||
fun d.FilterFromKeyboard(keep, start, ...)
|
||||
let self.modeText = 'press ESC to exit getchar() loop'
|
||||
call self.UpdateDisplay() | redraw
|
||||
|
||||
try
|
||||
let key_text = a:0 > 0 ? 'key : '.a:1 : ''
|
||||
let filter_bak = self.filter
|
||||
let filter = copy(self.filter)
|
||||
let start = a:start
|
||||
let filter_new = ''
|
||||
while 1
|
||||
if start != ''
|
||||
" use c= last char to force updating display etc
|
||||
let filter_new = start[:-2]
|
||||
let c = start[-1:]
|
||||
let start = ''
|
||||
else
|
||||
let c=getchar()
|
||||
endif
|
||||
if index([13,10],c) >= 0
|
||||
" c-j or return, accept new filter
|
||||
let items = self.FilteredItems()
|
||||
if len(items) == 1 && has_key(self, 'Continuation') && self.continueOnSingleMatchCR
|
||||
call self.DoContinue(self.MapToOriginal(items[0]))
|
||||
endif
|
||||
return
|
||||
elseif index([27], c) >=0
|
||||
" esc, abort
|
||||
let self.filter = filter_bak
|
||||
call self.UpdateDisplay()
|
||||
return
|
||||
else
|
||||
if type(c) == 0
|
||||
let c = nr2char(c)
|
||||
endif
|
||||
if c == "\<bs>"
|
||||
let filter_new = filter_new[:-2]
|
||||
else
|
||||
let filter_new .= c
|
||||
endif
|
||||
let d = {'keep' : a:keep, 'regex' : filter_new }
|
||||
if a:0 > 0
|
||||
let d['key'] = a:1
|
||||
endif
|
||||
let self.filter = copy(filter_bak)
|
||||
call add(self.filter, d)
|
||||
let items = self.FilteredItems()
|
||||
if len(items) == 1 && has_key(self, 'Continuation') && self.continueOnSingleMatch
|
||||
call self.DoContinue(self.MapToOriginal(items[0]))
|
||||
return
|
||||
endif
|
||||
call self.UpdateDisplay() | redraw
|
||||
endif
|
||||
endwhile
|
||||
finally
|
||||
let self.modeText = ''
|
||||
endtry
|
||||
endfun
|
||||
|
||||
if get(a:opts,'init',1)
|
||||
call d.NewBufferAndInit()
|
||||
endif
|
||||
endfun
|
||||
|
|
@ -1,7 +0,0 @@
|
|||
*cached_file_contents* read contents of a file then cache extracted data
|
||||
Author: Marc Weber, marco-oweber@gmx.de
|
||||
|
||||
-----------------------------------------------------------------------
|
||||
HOWTO~
|
||||
|
||||
see cached_file_contents#Test()
|
||||
|
|
@ -1,35 +0,0 @@
|
|||
*funcref* create lazier function references. Pass arguments to create closure
|
||||
like function calls
|
||||
Author: Marc Weber, marco-oweber@gmx.de
|
||||
|
||||
-----------------------------------------------------------------------
|
||||
HOWTO~
|
||||
|
||||
Use *funcref#Function* to create a special dict called
|
||||
*faked-function-reference* which can be called by *funcref#Call*
|
||||
>
|
||||
{ 'faked_function_reference': 'file#FuncName' }
|
||||
< passing some arguments and / or self: >
|
||||
{ 'faked_function_reference': 'MyFunc', 'args': [1,2], 'self' : { a object ] }
|
||||
< You can also create lambda like functions which will be evaled: >
|
||||
{ 'faked_function_reference': 'return ARGS[1]' }
|
||||
|
||||
REASONS ~
|
||||
Creating a Vim funcref pointing to an autoload function will make Vim source
|
||||
that file. This is not lazy enough. (Seems to be no longer true? Has this changed?)
|
||||
|
||||
A Vim function reference neither allows attaching arguments nor self.
|
||||
|
||||
Don't care about case of variables. Normally when using Vim function
|
||||
references you have to use variable names starting with an upper case letter
|
||||
(E704)
|
||||
|
||||
Example: ~
|
||||
>
|
||||
let f = funcref#Function('return ARGS[0].ARGS[1].SELF["key"]',{'args':[3], 'self':{'key': 'value'} })
|
||||
echo funcref#Call(f, [2])
|
||||
" prints "32value"
|
||||
|
||||
echo funcref#Call('no value')
|
||||
<
|
||||
echo funcref#Call(f, [2])
|
||||
|
|
@ -1,18 +0,0 @@
|
|||
*tiny-cmd* make long commands short so that they hopefully no longer trigger "press Enter .. [ok]"
|
||||
Author: Marc Weber, marco-oweber@gmx.de
|
||||
|
||||
-----------------------------------------------------------------------
|
||||
HOWTO~
|
||||
|
||||
Problem: >
|
||||
exec 'map <F2> :silent! let g:g="'.repeat('foobar ',200).'"<cr>'
|
||||
Now run the mapping by pressing <F2> and you notice what I'm talking about
|
||||
|
||||
Solution (Example):
|
||||
|
||||
|
||||
Example usage: >
|
||||
let nr = tiny_cmd#Put('let g:g="'.repeat('foobar ',200).'"')
|
||||
exec 'map <F2> :exec tiny_cmd#Get('.nr.')<cr>'
|
||||
<
|
||||
Use Pop instead of Get if you use this command once only
|
||||
|
|
@ -1,9 +0,0 @@
|
|||
{
|
||||
"name" : "vim-addon-mw-utils",
|
||||
"version" : "0.0",
|
||||
"author" : "Marc Weber <marco-oweber@gmx.de>",
|
||||
"maintainer" : "Marc Weber <marco-oweber@gmx.de>",
|
||||
"repository" : {"type": "git", "url": "git://github.com/MarcWeber/vim-addon-manager-known-repositories.git"},
|
||||
"dependencies" : {},
|
||||
"description" : "various utils such as caching interpreted contents of files or advanced glob like things"
|
||||
}
|
||||
Loading…
Reference in New Issue