aboutsummaryrefslogtreecommitdiff
path: root/vim/bundle/tlib_vim/autoload/tlib
diff options
context:
space:
mode:
Diffstat (limited to 'vim/bundle/tlib_vim/autoload/tlib')
m---------vim/bundle/tlib_vim0
-rwxr-xr-xvim/bundle/tlib_vim/autoload/tlib/Filter_cnf.vim151
-rwxr-xr-xvim/bundle/tlib_vim/autoload/tlib/Filter_cnfd.vim53
-rwxr-xr-xvim/bundle/tlib_vim/autoload/tlib/Filter_fuzzy.vim83
-rw-r--r--vim/bundle/tlib_vim/autoload/tlib/Filter_glob.vim68
-rwxr-xr-xvim/bundle/tlib_vim/autoload/tlib/Object.vim154
-rwxr-xr-xvim/bundle/tlib_vim/autoload/tlib/Test.vim19
-rwxr-xr-xvim/bundle/tlib_vim/autoload/tlib/TestChild.vim19
-rwxr-xr-xvim/bundle/tlib_vim/autoload/tlib/World.vim1404
-rw-r--r--vim/bundle/tlib_vim/autoload/tlib/agent.vim665
-rwxr-xr-xvim/bundle/tlib_vim/autoload/tlib/arg.vim338
-rw-r--r--vim/bundle/tlib_vim/autoload/tlib/assert.vim44
-rwxr-xr-xvim/bundle/tlib_vim/autoload/tlib/autocmdgroup.vim14
-rw-r--r--vim/bundle/tlib_vim/autoload/tlib/balloon.vim73
-rw-r--r--vim/bundle/tlib_vim/autoload/tlib/bitwise.vim141
-rw-r--r--vim/bundle/tlib_vim/autoload/tlib/buffer.vim401
-rwxr-xr-xvim/bundle/tlib_vim/autoload/tlib/cache.vim360
-rwxr-xr-xvim/bundle/tlib_vim/autoload/tlib/char.vim59
-rwxr-xr-xvim/bundle/tlib_vim/autoload/tlib/cmd.vim117
-rwxr-xr-xvim/bundle/tlib_vim/autoload/tlib/comments.vim26
-rwxr-xr-xvim/bundle/tlib_vim/autoload/tlib/date.vim189
-rw-r--r--vim/bundle/tlib_vim/autoload/tlib/dictionary.vim45
-rwxr-xr-xvim/bundle/tlib_vim/autoload/tlib/dir.vim93
-rwxr-xr-xvim/bundle/tlib_vim/autoload/tlib/eval.vim72
-rw-r--r--vim/bundle/tlib_vim/autoload/tlib/file.vim283
-rw-r--r--vim/bundle/tlib_vim/autoload/tlib/fixes.vim14
-rw-r--r--vim/bundle/tlib_vim/autoload/tlib/grep.vim38
-rw-r--r--vim/bundle/tlib_vim/autoload/tlib/hash.vim145
-rwxr-xr-xvim/bundle/tlib_vim/autoload/tlib/hook.vim25
-rw-r--r--vim/bundle/tlib_vim/autoload/tlib/input.vim1336
-rwxr-xr-xvim/bundle/tlib_vim/autoload/tlib/list.vim194
-rw-r--r--vim/bundle/tlib_vim/autoload/tlib/loclist.vim13
-rwxr-xr-xvim/bundle/tlib_vim/autoload/tlib/map.vim23
-rwxr-xr-xvim/bundle/tlib_vim/autoload/tlib/normal.vim34
-rwxr-xr-xvim/bundle/tlib_vim/autoload/tlib/notify.vim113
-rw-r--r--vim/bundle/tlib_vim/autoload/tlib/number.vim30
-rwxr-xr-xvim/bundle/tlib_vim/autoload/tlib/paragraph.vim97
-rw-r--r--vim/bundle/tlib_vim/autoload/tlib/persistent.vim47
-rwxr-xr-xvim/bundle/tlib_vim/autoload/tlib/progressbar.vim72
-rw-r--r--vim/bundle/tlib_vim/autoload/tlib/qfl.vim312
-rw-r--r--vim/bundle/tlib_vim/autoload/tlib/rx.vim60
-rwxr-xr-xvim/bundle/tlib_vim/autoload/tlib/scratch.vim136
-rw-r--r--vim/bundle/tlib_vim/autoload/tlib/selection.vim40
-rwxr-xr-xvim/bundle/tlib_vim/autoload/tlib/signs.vim103
-rwxr-xr-xvim/bundle/tlib_vim/autoload/tlib/string.vim172
-rwxr-xr-xvim/bundle/tlib_vim/autoload/tlib/syntax.vim38
-rw-r--r--vim/bundle/tlib_vim/autoload/tlib/sys.vim212
-rwxr-xr-xvim/bundle/tlib_vim/autoload/tlib/tab.vim49
-rwxr-xr-xvim/bundle/tlib_vim/autoload/tlib/tag.vim132
-rwxr-xr-xvim/bundle/tlib_vim/autoload/tlib/textobjects.vim45
-rwxr-xr-xvim/bundle/tlib_vim/autoload/tlib/time.vim67
-rw-r--r--vim/bundle/tlib_vim/autoload/tlib/trace.vim159
-rwxr-xr-xvim/bundle/tlib_vim/autoload/tlib/type.vim126
-rwxr-xr-xvim/bundle/tlib_vim/autoload/tlib/url.vim52
-rwxr-xr-xvim/bundle/tlib_vim/autoload/tlib/var.vim83
-rw-r--r--vim/bundle/tlib_vim/autoload/tlib/vcs.vim189
-rw-r--r--vim/bundle/tlib_vim/autoload/tlib/vim.vim152
-rwxr-xr-xvim/bundle/tlib_vim/autoload/tlib/win.vim128
58 files changed, 0 insertions, 9307 deletions
diff --git a/vim/bundle/tlib_vim b/vim/bundle/tlib_vim
new file mode 160000
+Subproject 5636472e5dba1a4104376ce6bd93cc2546e0248
diff --git a/vim/bundle/tlib_vim/autoload/tlib/Filter_cnf.vim b/vim/bundle/tlib_vim/autoload/tlib/Filter_cnf.vim
deleted file mode 100755
index 0bcb6c0..0000000
--- a/vim/bundle/tlib_vim/autoload/tlib/Filter_cnf.vim
+++ /dev/null
@@ -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-11-18.
-" @Revision: 0.0.114
-
-let s:prototype = tlib#Object#New({'_class': ['Filter_cnf'], 'name': 'cnf'}) "{{{2
-let s:prototype.highlight = g:tlib#input#higroup
-
-" The search pattern for |tlib#input#List()| is in conjunctive normal
-" form: (P1 OR P2 ...) AND (P3 OR P4 ...) ...
-" The pattern is a '/\V' very no-'/magic' regexp pattern.
-"
-" Pressing <space> joins two patterns with AND.
-" Pressing | joins two patterns with OR.
-" I.e. In order to get "lala AND (foo OR bar)", you type
-" "lala foo|bar".
-"
-" This is also the base class for other filters.
-function! tlib#Filter_cnf#New(...) "{{{3
- let object = s:prototype.New(a:0 >= 1 ? a:1 : {})
- return object
-endf
-
-
-" :nodoc:
-function! s:prototype.Init(world) dict "{{{3
-endf
-
-
-" :nodoc:
-function! s:prototype.Help(world) dict "{{{3
- call a:world.PushHelp(
- \ printf('"%s", "%s", "%sWORD"', g:tlib#input#and, g:tlib#input#or, g:tlib#input#not),
- \ 'AND, OR, NOT')
-endf
-
-
-" :nodoc:
-function! s:prototype.AssessName(world, name) dict "{{{3
- let xa = 0
- let prefix = self.FilterRxPrefix()
- for flt in a:world.filter_pos
- " let flt = prefix . a:world.GetRx(fltl)
- " if flt =~# '\u' && a:name =~# flt
- " let xa += 5
- " endif
-
- 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
-
diff --git a/vim/bundle/tlib_vim/autoload/tlib/Filter_cnfd.vim b/vim/bundle/tlib_vim/autoload/tlib/Filter_cnfd.vim
deleted file mode 100755
index 27f00fe..0000000
--- a/vim/bundle/tlib_vim/autoload/tlib/Filter_cnfd.vim
+++ /dev/null
@@ -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
-
diff --git a/vim/bundle/tlib_vim/autoload/tlib/Filter_fuzzy.vim b/vim/bundle/tlib_vim/autoload/tlib/Filter_fuzzy.vim
deleted file mode 100755
index 349bfd5..0000000
--- a/vim/bundle/tlib_vim/autoload/tlib/Filter_fuzzy.vim
+++ /dev/null
@@ -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
-
diff --git a/vim/bundle/tlib_vim/autoload/tlib/Filter_glob.vim b/vim/bundle/tlib_vim/autoload/tlib/Filter_glob.vim
deleted file mode 100644
index 904b226..0000000
--- a/vim/bundle/tlib_vim/autoload/tlib/Filter_glob.vim
+++ /dev/null
@@ -1,68 +0,0 @@
-" @Author: Tom Link (mailto:micathom AT gmail com?subject=[vim])
-" @Website: http://www.vim.org/account/profile.php?user_id=4037
-" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
-" @Created: 2008-11-25.
-" @Last Change: 2014-11-18.
-" @Revision: 0.0.82
-
-let s:prototype = tlib#Filter_cnf#New({'_class': ['Filter_glob'], 'name': 'glob'}) "{{{2
-let s:prototype.highlight = g:tlib#input#higroup
-
-
-" A character that should be expanded to '\.\{-}'.
-TLet g:tlib#Filter_glob#seq = '*'
-
-
-" A character that should be expanded to '\.\?'.
-TLet g:tlib#Filter_glob#char = '?'
-
-
-" The same as |tlib#Filter_cnf#New()| but a a customizable character
-" |see tlib#Filter_glob#seq| is expanded to '\.\{-}' and
-" |g:tlib#Filter_glob#char| is expanded to '\.'.
-" The pattern is a '/\V' very no-'/magic' regexp pattern.
-function! tlib#Filter_glob#New(...) "{{{3
- let object = s:prototype.New(a:0 >= 1 ? a:1 : {})
- return object
-endf
-
-
-let s:Help = s:prototype.Help
-
-" :nodoc:
-function! s:prototype.Help(world) dict "{{{3
- call call(s:Help, [a:world], self)
- call a:world.PushHelp(g:tlib#Filter_glob#seq, 'Any characters')
- call a:world.PushHelp(g:tlib#Filter_glob#char, 'Single characters')
-endf
-
-
-" :nodoc:
-function! s:prototype.SetFrontFilter(world, pattern) dict "{{{3
- let pattern = substitute(a:pattern, tlib#rx#Escape(g:tlib#Filter_glob#seq, 'V'), '\\.\\{-}', 'g')
- let pattern = substitute(a:pattern, tlib#rx#Escape(g:tlib#Filter_glob#char, 'V'), '\\.', 'g')
- let a:world.filter[0] = reverse(split(pattern, '\s*|\s*')) + a:world.filter[0][1 : -1]
-endf
-
-
-" :nodoc:
-function! s:prototype.PushFrontFilter(world, char) dict "{{{3
- " TLogVAR a:char, nr2char(a:char)
- if a:char == char2nr(g:tlib#Filter_glob#seq)
- let char = '\.\{-}'
- elseif a:char == char2nr(g:tlib#Filter_glob#char)
- let char = '\.'
- else
- let char = nr2char(a:char)
- endif
- let a:world.filter[0][0] .= char
-endf
-
-
-" :nodoc:
-function! s:prototype.CleanFilter(filter) dict "{{{3
- let filter = substitute(a:filter, '\\\.\\{-}', g:tlib#Filter_glob#seq, 'g')
- let filter = substitute(filter, '\\\.', g:tlib#Filter_glob#char, 'g')
- return filter
-endf
-
diff --git a/vim/bundle/tlib_vim/autoload/tlib/Object.vim b/vim/bundle/tlib_vim/autoload/tlib/Object.vim
deleted file mode 100755
index 21f38b2..0000000
--- a/vim/bundle/tlib_vim/autoload/tlib/Object.vim
+++ /dev/null
@@ -1,154 +0,0 @@
-" @Author: Tom Link (micathom AT gmail com?subject=[vim])
-" @Website: http://www.vim.org/account/profile.php?user_id=4037
-" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
-" @Revision: 127
-
-" :filedoc:
-" Provides a prototype plus some OO-like methods.
-
-let s:id_counter = 0
-let s:prototype = {'_class': ['object'], '_super': [], '_id': 0} "{{{2
-
-" :def: function! tlib#Object#New(?fields={})
-" This function creates a prototype that provides some kind of
-" inheritance mechanism and a way to call parent/super methods.
-"
-" The usage demonstrated in the following example works best when every
-" class/prototype is defined in a file of its own.
-"
-" The reason for why there is a dedicated constructor function is that
-" this layout facilitates the use of templates and that methods are
-" hidden from the user. Other solutions are possible.
-"
-" EXAMPLES: >
-" let s:prototype = tlib#Object#New({
-" \ '_class': ['FooBar'],
-" \ 'foo': 1,
-" \ 'bar': 2,
-" \ })
-" " Constructor
-" function! FooBar(...)
-" let object = s:prototype.New(a:0 >= 1 ? a:1 : {})
-" return object
-" endf
-" function! s:prototype.babble() {
-" echo "I think, therefore I am ". (self.foo * self.bar) ." months old."
-" }
-"
-" < This could now be used like this: >
-" let myfoo = FooBar({'foo': 3})
-" call myfoo.babble()
-" => I think, therefore I am 6 months old.
-" echo myfoo.IsA('FooBar')
-" => 1
-" echo myfoo.IsA('object')
-" => 1
-" echo myfoo.IsA('Foo')
-" => 0
-" echo myfoo.RespondTo('babble')
-" => 1
-" echo myfoo.RespondTo('speak')
-" => 0
-function! tlib#Object#New(...) "{{{3
- return s:prototype.New(a:0 >= 1 ? a:1 : {})
-endf
-
-
-function! s:prototype.New(...) dict "{{{3
- let object = deepcopy(self)
- let s:id_counter += 1
- let object._id = s:id_counter
- if a:0 >= 1 && !empty(a:1)
- " call object.Extend(deepcopy(a:1))
- call object.Extend(a:1)
- endif
- return object
-endf
-
-
-function! s:prototype.Inherit(object) dict "{{{3
- let class = copy(self._class)
- " TLogVAR class
- let objid = self._id
- for c in get(a:object, '_class', [])
- " TLogVAR c
- if index(class, c) == -1
- call add(class, c)
- endif
- endfor
- call extend(self, a:object, 'keep')
- let self._class = class
- " TLogVAR self._class
- let self._id = objid
- " let self._super = [super] + self._super
- call insert(self._super, a:object)
- return self
-endf
-
-
-function! s:prototype.Extend(dictionary) dict "{{{3
- let super = copy(self)
- let class = copy(self._class)
- " TLogVAR class
- let objid = self._id
- let thisclass = get(a:dictionary, '_class', [])
- for c in type(thisclass) == 3 ? thisclass : [thisclass]
- " TLogVAR c
- if index(class, c) == -1
- call add(class, c)
- endif
- endfor
- call extend(self, a:dictionary)
- let self._class = class
- " TLogVAR self._class
- let self._id = objid
- " let self._super = [super] + self._super
- call insert(self._super, super)
- return self
-endf
-
-
-function! s:prototype.IsA(class) dict "{{{3
- return index(self._class, a:class) != -1
-endf
-
-
-function! s:prototype.IsRelated(object) dict "{{{3
- return len(filter(a:object._class, 'self.IsA(v:val)')) > 1
-endf
-
-
-function! s:prototype.RespondTo(name) dict "{{{3
- " return has_key(self, a:name) && type(self[a:name]) == 2
- return has_key(self, a:name)
-endf
-
-
-function! s:prototype.Super(method, arglist) dict "{{{3
- for o in self._super
- " TLogVAR o
- if o.RespondTo(a:method)
- " let self._tmp_method = o[a:method]
- " TLogVAR self._tmp_method
- " return call(self._tmp_method, a:arglist, self)
- return call(o[a:method], a:arglist, self)
- endif
- endfor
- echoerr 'tlib#Object: Does not respond to '. a:method .': '. string(self)
-endf
-
-
-function! tlib#Object#Methods(object, ...) "{{{3
- TVarArg ['pattern', '\d\+']
- let o = items(a:object)
- call filter(o, 'type(v:val[1]) == 2 && string(v:val[1]) =~ "^function(''\\d\\+'')"')
- let acc = {}
- for e in o
- let id = matchstr(string(e[1]), pattern)
- if !empty(id)
- let acc[id] = e[0]
- endif
- endfor
- return acc
-endf
-
diff --git a/vim/bundle/tlib_vim/autoload/tlib/Test.vim b/vim/bundle/tlib_vim/autoload/tlib/Test.vim
deleted file mode 100755
index 4a4281e..0000000
--- a/vim/bundle/tlib_vim/autoload/tlib/Test.vim
+++ /dev/null
@@ -1,19 +0,0 @@
-" @Author: Tom Link (micathom AT gmail com?subject=[vim])
-" @Website: http://www.vim.org/account/profile.php?user_id=4037
-" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
-" @Revision: 11
-
-" :enddoc:
-
-
-let s:prototype = tlib#Object#New({'_class': ['Test']}) "{{{2
-function! tlib#Test#New(...) "{{{3
- let object = s:prototype.New(a:0 >= 1 ? a:1 : {})
- return object
-endf
-
-
-function! s:prototype.Dummy() dict "{{{3
- return 'Test.vim'
-endf
-
diff --git a/vim/bundle/tlib_vim/autoload/tlib/TestChild.vim b/vim/bundle/tlib_vim/autoload/tlib/TestChild.vim
deleted file mode 100755
index 16979a7..0000000
--- a/vim/bundle/tlib_vim/autoload/tlib/TestChild.vim
+++ /dev/null
@@ -1,19 +0,0 @@
-" @Author: Tom Link (micathom AT gmail com?subject=[vim])
-" @Website: http://www.vim.org/account/profile.php?user_id=4037
-" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
-" @Revision: 15
-
-" :enddoc:
-
-
-let s:prototype = tlib#Test#New({'_class': ['TestChild']}) "{{{2
-function! tlib#TestChild#New(...) "{{{3
- let object = s:prototype.New(a:0 >= 1 ? a:1 : {})
- return object
-endf
-
-
-function! s:prototype.Dummy() dict "{{{3
- return 'TestChild.vim'
-endf
-
diff --git a/vim/bundle/tlib_vim/autoload/tlib/World.vim b/vim/bundle/tlib_vim/autoload/tlib/World.vim
deleted file mode 100755
index aa1bc9e..0000000
--- a/vim/bundle/tlib_vim/autoload/tlib/World.vim
+++ /dev/null
@@ -1,1404 +0,0 @@
-" @Author: Tom Link (micathom AT gmail com?subject=[vim])
-" @Website: http://www.vim.org/account/profile.php?user_id=4037
-" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
-" @Revision: 1434
-
-" :filedoc:
-" A prototype used by |tlib#input#List|.
-" Inherits from |tlib#Object#New|.
-
-
-" Size of the input list window (in percent) from the main size (of &lines).
-" See |tlib#input#List()|.
-TLet g:tlib_inputlist_pct = 50
-
-" Size of filename columns when listing filenames.
-" See |tlib#input#List()|.
-TLet g:tlib_inputlist_width_filename = '&co / 3'
-" TLet g:tlib_inputlist_width_filename = 25
-
-" If true, |tlib#input#List()| will show some indicators about the
-" status of a filename (e.g. buflisted(), bufloaded() etc.).
-" This is disabled by default because vim checks also for the file on
-" disk when doing this.
-TLet g:tlib_inputlist_filename_indicators = 0
-
-" If not null, display only a short info about the filter.
-TLet g:tlib_inputlist_shortmessage = 0
-
-
-
-" Known keys & values:
-" scratch_split ... See |tlib#scratch#UseScratch()|
-let s:prototype = tlib#Object#New({
- \ '_class': 'World',
- \ 'name': 'world',
- \ 'allow_suspend': 1,
- \ 'base': [],
- \ 'bufnr': -1,
- \ 'buffer_local': 1,
- \ 'cache_var': '',
- \ 'display_format': '',
- \ 'fileencoding': &fileencoding,
- \ 'fmt_display': {},
- \ 'fmt_filter': {},
- \ 'fmt_options': {},
- \ 'filetype': '',
- \ 'filter': [['']],
- \ 'filter_format': '',
- \ 'filter_options': '',
- \ 'follow_cursor': '',
- \ 'has_menu': 0,
- \ 'help_extra': [],
- \ 'index_table': [],
- \ 'initial_filter': [['']],
- \ 'initial_index': 1,
- \ 'initial_display': 1,
- \ 'initialized': 0,
- \ 'key_handlers': [],
- \ 'list': [],
- \ 'matcher': {},
- \ 'next_agent': '',
- \ 'next_eval': '',
- \ 'next_state': '',
- \ 'numeric_chars': g:tlib#input#numeric_chars,
- \ 'offset': 1,
- \ 'offset_horizontal': 0,
- \ 'on_leave': [],
- \ 'pick_last_item': tlib#var#Get('tlib#input#pick_last_item', 'bg'),
- \ 'post_handlers': [],
- \ 'query': '',
- \ 'resize': 0,
- \ 'resize_vertical': 0,
- \ 'restore_from_cache': [],
- \ 'filtered_items': [],
- \ 'resume_state': '',
- \ 'retrieve_eval': '',
- \ 'return_agent': '',
- \ 'rv': '',
- \ 'scratch': '__InputList__',
- \ 'scratch_filetype': 'tlibInputList',
- \ 'scratch_hidden': g:tlib#scratch#hidden,
- \ 'scratch_vertical': 0,
- \ 'scratch_split': 1,
- \ 'sel_idx': [],
- \ 'show_empty': 0,
- \ 'state': 'display',
- \ 'state_handlers': [],
- \ 'sticky': 0,
- \ 'temp_lines': [],
- \ 'temp_prompt': [],
- \ 'timeout': 0,
- \ 'timeout_resolution': 2,
- \ 'tabpagenr': -1,
- \ 'type': '',
- \ 'win_wnr': -1,
- \ 'win_height': -1,
- \ 'win_width': -1,
- \ 'win_pct': 25,
- \ })
- " \ 'handlers': [],
- " \ 'filter_options': '\c',
-
-function! tlib#World#New(...)
- let object = s:prototype.New(a:0 >= 1 ? a:1 : {})
- call object.SetMatchMode(tlib#var#Get('tlib#input#filter_mode', 'g', 'cnf'))
- return object
-endf
-
-
-" :nodoc:
-function! s:prototype.Set_display_format(value) dict "{{{3
- if a:value == 'filename'
- call self.Set_highlight_filename()
- let self.display_format = 'world.FormatFilename(%s)'
- else
- let self.display_format = a:value
- endif
-endf
-
-
-" :nodoc:
-function! s:prototype.DisplayFormat(list) dict "{{{3
- let display_format = self.display_format
- if !empty(display_format)
- if has_key(self, 'InitFormatName')
- call self.InitFormatName()
- endif
- let cache = self.fmt_display
- " TLogVAR display_format, fmt_entries
- return map(copy(a:list), 'self.FormatName(cache, display_format, v:val)')
- else
- return a:list
- endif
-endf
-
-
-" :nodoc:
-function! s:prototype.Set_highlight_filename() dict "{{{3
- let self.tlib_UseInputListScratch = 'call world.Highlight_filename()'
-endf
-
-
-if g:tlib#input#format_filename == 'r'
-
- " :nodoc:
- function! s:prototype.Highlight_filename() dict "{{{3
- syntax match TLibDir /\s\+\zs.\{-}[\/]\ze[^\/]\+$/
- hi def link TLibDir Directory
- syntax match TLibFilename /[^\/]\+$/
- hi def link TLibFilename Normal
- endf
-
- " :nodoc:
- function! s:prototype.FormatFilename(file) dict "{{{3
- if !has_key(self.fmt_options, 'maxlen')
- let maxco = &co - len(len(self.base)) - eval(g:tlib#input#filename_padding_r)
- let maxfi = max(map(copy(self.base), 'strwidth(v:val)'))
- let self.fmt_options.maxlen = min([maxco, maxfi])
- " TLogVAR maxco, maxfi, self.fmt_options.maxlen
- endif
- let max = self.fmt_options.maxlen
- if len(a:file) > max
- let filename = '...' . strpart(a:file, len(a:file) - max + 3)
- else
- let filename = printf('% '. max .'s', a:file)
- endif
- return filename
- endf
-
-else
-
- " :nodoc:
- function! s:prototype.Highlight_filename() dict "{{{3
- " let self.width_filename = 1 + eval(g:tlib_inputlist_width_filename)
- " TLogVAR self.base
- let self.width_filename = min([
- \ get(self, 'width_filename', &co),
- \ empty(g:tlib#input#filename_max_width) ? &co : eval(g:tlib#input#filename_max_width),
- \ max(map(copy(self.base), 'strwidth(matchstr(v:val, "[^\\/]*$"))'))
- \ ])
- " TLogVAR self.width_filename
- exec 'syntax match TLibDir /\%>'. (1 + self.width_filename) .'c \(|\|\[[^]]*\]\) \zs\(\(\a:\|\.\.\|\.\.\..\{-}\)\?[\/][^&<>*|]\{-}\)\?[^\/]\+$/ contained containedin=TLibMarker contains=TLibFilename'
- exec 'syntax match TLibMarker /\%>'. (1 + self.width_filename) .'c \(|\|\[[^]]*\]\) \S.*$/ contains=TLibDir'
- " exec 'syntax match TLibDir /\(|\|\[.\{-}\]\) \zs\(\(\a:\|\.\.\|\.\.\..\{-}\)\?[\/][^&<>*|]\{-}\)\?[^\/]\+$/ contained containedin=TLibMarker contains=TLibFilename'
- " exec 'syntax match TLibMarker /\(|\|\[.\{-}\]\) \S.*$/ contains=TLibDir'
- exec 'syntax match TLibFilename /[^\/]\+$/ contained containedin=TLibDir'
- hi def link TLibMarker Special
- hi def link TLibDir Directory
- hi def link TLibFilename NonText
- " :nodoc:
- function! self.Highlighter(rx) dict
- let rx = '/\c\%>'. (1 + self.width_filename) .'c \(|\|\[[^]]*\]\) .\{-}\zs'. escape(a:rx, '/') .'/'
- exec 'match' self.matcher.highlight rx
- endf
- endf
-
-
- " :nodoc:
- function! s:prototype.UseFilenameIndicators() dict "{{{3
- return g:tlib_inputlist_filename_indicators || has_key(self, 'filename_indicators')
- endf
-
-
- " :nodoc:
- function! s:prototype.InitFormatName() dict "{{{3
- if self.UseFilenameIndicators()
- let self._buffers = {}
- for bufnr in range(1, bufnr('$'))
- let filename = fnamemodify(bufname(bufnr), ':p')
- " TLogVAR filename
- let bufdef = {
- \ 'bufnr': bufnr,
- \ }
- " '&buflisted'
- for opt in ['&modified', '&bufhidden']
- let bufdef[opt] = getbufvar(bufnr, opt)
- endfor
- let self._buffers[filename] = bufdef
- endfor
- endif
- endf
-
-
- " :nodoc:
- function! s:prototype.FormatFilename(file) dict "{{{3
- " TLogVAR a:file
- let width = self.width_filename
- let split = match(a:file, '[/\\]\zs[^/\\]\+$')
- if split == -1
- let fname = a:file
- let dname = a:file
- else
- let fname = strpart(a:file, split)
- " let dname = strpart(a:file, 0, split - 1)
- let dname = a:file
- endif
- if strwidth(fname) > width
- let fname = strpart(fname, 0, width - 3) .'...'
- endif
- let dnmax = &co - max([width, strwidth(fname)]) - 8 - self.index_width - &fdc
- let use_indicators = self.UseFilenameIndicators()
- " TLogVAR use_indicators
- let marker = []
- if use_indicators
- call insert(marker, '[')
- if g:tlib_inputlist_filename_indicators
- let bufdef = get(self._buffers, a:file, {})
- " let bnr = bufnr(a:file)
- let bnr = get(bufdef, 'bufnr', -1)
- " TLogVAR a:file, bnr, self.bufnr
- if bnr != -1
- if bnr == self.bufnr
- call add(marker, '%')
- else
- call add(marker, bnr)
- endif
- if get(bufdef, '&modified', 0)
- call add(marker, '+')
- endif
- if get(bufdef, '&bufhidden', '') == 'hide'
- call add(marker, 'h')
- endif
- " if !get(bufdef, '&buflisted', 1)
- " call add(marker, 'u')
- " endif
- " echom "DBG" a:file string(get(self,'filename_indicators'))
- endif
- endif
- if has_key(self, 'filename_indicators') && has_key(self.filename_indicators, a:file)
- if len(marker) > 1
- call add(marker, '|')
- endif
- call add(marker, self.filename_indicators[a:file])
- endif
- if len(marker) <= 1
- call add(marker, ' ')
- endif
- call add(marker, ']')
- else
- call add(marker, '|')
- endif
- let markers = join(marker, '')
- if !empty(markers)
- let dnmax -= len(markers)
- endif
- if strwidth(dname) > dnmax
- let dname = '...'. strpart(dname, len(dname) - dnmax)
- endif
- return printf("%-*s %s %s",
- \ self.width_filename + len(fname) - strwidth(fname),
- \ fname, markers, dname)
- endf
-
-endif
-
-
-" :nodoc:
-function! s:prototype.GetSelectedItems(current) dict "{{{3
- " TLogVAR a:current
- if stridx(self.type, 'i') != -1
- let rv = copy(self.sel_idx)
- else
- let rv = map(copy(self.sel_idx), 'self.GetBaseItem(v:val)')
- endif
- if !empty(a:current)
- " TLogVAR a:current, rv, type(a:current)
- if tlib#type#IsNumber(a:current) || tlib#type#IsString(a:current)
- call s:InsertSelectedItems(rv, a:current)
- elseif tlib#type#IsList(a:current)
- for item in a:current
- call s:InsertSelectedItems(rv, item)
- endfor
- elseif tlib#type#IsDictionary(a:current)
- for [inum, item] in items(a:current)
- call s:InsertSelectedItems(rv, item)
- endfor
- endif
- endif
- " TAssert empty(rv) || rv[0] == a:current
- if stridx(self.type, 'i') != -1
- if !empty(self.index_table)
- " TLogVAR rv, self.index_table
- call map(rv, 'self.index_table[v:val - 1]')
- " TLogVAR rv
- endif
- endif
- return rv
-endf
-
-
-function! s:InsertSelectedItems(rv, current) "{{{3
- let ci = index(a:rv, a:current)
- if ci != -1
- call remove(a:rv, ci)
- endif
- call insert(a:rv, a:current)
-endf
-
-
-" :nodoc:
-function! s:prototype.SelectItemsByNames(mode, items) dict "{{{3
- for item in a:items
- let bi = index(self.base, item) + 1
- " TLogVAR item, bi
- if bi > 0
- let si = index(self.sel_idx, bi)
- " TLogVAR self.sel_idx
- " TLogVAR si
- if si == -1
- call add(self.sel_idx, bi)
- elseif a:mode == 'toggle'
- call remove(self.sel_idx, si)
- endif
- endif
- endfor
- return 1
-endf
-
-
-" :nodoc:
-function! s:prototype.SelectItem(mode, index) dict "{{{3
- " TLogVAR a:mode, a:index
- let bi = self.GetBaseIdx(a:index)
- " if self.RespondTo('MaySelectItem')
- " if !self.MaySelectItem(bi)
- " return 0
- " endif
- " endif
- " TLogVAR bi
- let si = index(self.sel_idx, bi)
- " TLogVAR self.sel_idx
- " TLogVAR si
- if si == -1
- call add(self.sel_idx, bi)
- elseif a:mode == 'toggle'
- call remove(self.sel_idx, si)
- endif
- return 1
-endf
-
-
-" :nodoc:
-function! s:prototype.FormatBaseFromData() abort dict "{{{3
- if has_key(self, 'format_data') && has_key(self, 'data')
- let self.base = map(copy(self.data), 'call(self.format_data, [v:val], self)')
- endif
-endf
-
-
-" :nodoc:
-function! s:prototype.FormatArgs(format_string, arg) dict "{{{3
- let nargs = len(substitute(a:format_string, '%%\|[^%]', '', 'g'))
- return [a:format_string] + repeat([string(a:arg)], nargs)
-endf
-
-
-" :nodoc:
-function! s:prototype.GetRx(filter) dict "{{{3
- return '\('. join(filter(copy(a:filter), 'v:val[0] != "!"'), '\|') .'\)'
-endf
-
-
-" :nodoc:
-function! s:prototype.GetRx0(...) dict "{{{3
- exec tlib#arg#Let(['negative'])
- let rx0 = []
- for filter in self.filter
- " TLogVAR filter
- let rx = join(reverse(filter(copy(filter), '!empty(v:val)')), '\|')
- " TLogVAR rx
- if !empty(rx) && (negative ? rx[0] == g:tlib#input#not : rx[0] != g:tlib#input#not)
- call add(rx0, rx)
- endif
- endfor
- let rx0s = join(rx0, '\|')
- if empty(rx0s)
- return ''
- else
- return self.FilterRxPrefix() .'\('. rx0s .'\)'
- endif
-endf
-
-
-" :nodoc:
-function! s:prototype.FormatName(cache, format, value) dict "{{{3
- " TLogVAR a:format, a:value
- " TLogDBG has_key(self.fmt_display, a:value)
- if has_key(a:cache, a:value)
- " TLogDBG "cached"
- return a:cache[a:value]
- else
- let world = self
- let ftpl = self.FormatArgs(a:format, a:value)
- let fn = call(function("printf"), ftpl)
- let fmt = eval(fn)
- " TLogVAR ftpl, fn, fmt
- let a:cache[a:value] = fmt
- return fmt
- endif
-endf
-
-
-" :nodoc:
-function! s:prototype.GetItem(idx) dict "{{{3
- return self.list[a:idx - 1]
-endf
-
-
-" :nodoc:
-function! s:prototype.GetListIdx(baseidx) dict "{{{3
- " if empty(self.index_table)
- let baseidx = a:baseidx
- " else
- " let baseidx = 0 + self.index_table[a:baseidx - 1]
- " " TLogVAR a:baseidx, baseidx, self.index_table
- " endif
- let rv = index(self.table, baseidx)
- " TLogVAR rv, self.table
- return rv
-endf
-
-
-" :nodoc:
-" The first index is 1.
-function! s:prototype.GetBaseIdx(idx) dict "{{{3
- " TLogVAR a:idx, self.table, self.index_table
- if !empty(self.table) && a:idx > 0 && a:idx <= len(self.table)
- return self.table[a:idx - 1]
- else
- return 0
- endif
-endf
-
-
-" :nodoc:
-function! s:prototype.GetBaseIdx0(idx) dict "{{{3
- let idx0 = self.GetBaseIdx(a:idx) - 1
- if idx0 < 0
- call tlib#notify#Echo('TLIB: Internal Error: GetBaseIdx0: idx0 < 0', 'WarningMsg')
- endif
- return idx0
-endf
-
-
-" :nodoc:
-function! s:prototype.GetBaseItem(idx) dict "{{{3
- return self.base[a:idx - 1]
-endf
-
-
-" :nodoc:
-function! s:prototype.SetBaseItem(idx, item) dict "{{{3
- let self.base[a:idx - 1] = a:item
-endf
-
-
-" :nodoc:
-function! s:prototype.GetLineIdx(lnum) dict "{{{3
- let line = getline(a:lnum)
- let prefidx = substitute(matchstr(line, '^\d\+\ze[*:]'), '^0\+', '', '')
- return prefidx
-endf
-
-
-" :nodoc:
-function! s:prototype.SetPrefIdx() dict "{{{3
- " let pref = sort(range(1, self.llen), 'self.SortPrefs')
- " let self.prefidx = get(pref, 0, self.initial_index)
- let pref_idx = -1
- let pref_weight = -1
- " TLogVAR self.filter_pos, self.filter_neg
- " let t0 = localtime() " DBG
- for idx in range(1, self.llen)
- let item = self.GetItem(idx)
- let weight = self.matcher.AssessName(self, item)
- " TLogVAR item, weight
- if weight > pref_weight
- let pref_idx = idx
- let pref_weight = weight
- endif
- endfor
- " TLogVAR localtime() - t0
- " TLogVAR pref_idx
- " TLogDBG self.GetItem(pref_idx)
- if pref_idx == -1
- let self.prefidx = self.initial_index
- else
- let self.prefidx = pref_idx
- endif
-endf
-
-
-" " :nodoc:
-" function! s:prototype.GetCurrentItem() dict "{{{3
-" let idx = self.prefidx
-" " TLogVAR idx
-" if stridx(self.type, 'i') != -1
-" return idx
-" elseif !empty(self.list)
-" if len(self.list) >= idx
-" let idx1 = idx - 1
-" let rv = self.list[idx - 1]
-" " TLogVAR idx, idx1, rv, self.list
-" return rv
-" endif
-" else
-" return ''
-" endif
-" endf
-
-
-" :nodoc:
-function! s:prototype.CurrentItem() dict "{{{3
- if stridx(self.type, 'i') != -1
- return self.GetBaseIdx(self.llen == 1 ? 1 : self.prefidx)
- else
- if self.llen == 1
- " TLogVAR self.llen
- return self.list[0]
- elseif self.prefidx > 0
- " TLogVAR self.prefidx
- " return self.GetCurrentItem()
- if len(self.list) >= self.prefidx
- let rv = self.list[self.prefidx - 1]
- " TLogVAR idx, rv, self.list
- return rv
- endif
- else
- return ''
- endif
- endif
-endf
-
-
-" :nodoc:
-function! s:prototype.FilterRxPrefix() dict "{{{3
- return self.matcher.FilterRxPrefix()
-endf
-
-
-" :nodoc:
-function! s:prototype.SetFilter() dict "{{{3
- " let mrx = '\V'. (a:0 >= 1 && a:1 ? '\C' : '')
- let mrx = self.FilterRxPrefix() . self.filter_options
- let self.filter_pos = []
- let self.filter_neg = []
- " TLogVAR mrx, self.filter
- for filter in self.filter
- " TLogVAR filter
- let rx = join(reverse(filter(copy(filter), '!empty(v:val)')), '\|')
- " TLogVAR rx
- if !empty(rx)
- if rx =~ '\u'
- let mrx1 = mrx .'\C'
- else
- let mrx1 = mrx
- endif
- " TLogVAR rx
- if rx[0] == g:tlib#input#not
- if len(rx) > 1
- call add(self.filter_neg, mrx1 .'\('. rx[1:-1] .'\)')
- endif
- else
- call add(self.filter_pos, mrx1 .'\('. rx .'\)')
- endif
- endif
- endfor
- " TLogVAR self.filter_pos, self.filter_neg
-endf
-
-
-" :nodoc:
-function! s:prototype.IsValidFilter() dict "{{{3
- let last = self.FilterRxPrefix() .'\('. self.filter[0][0] .'\)'
- Tlibtrace 'tlib', last
- " TLogVAR last
- try
- let a = match("", last)
- return 1
- catch
- Tlibtrace 'tlib', v:exception
- return 0
- endtry
-endf
-
-
-" :nodoc:
-function! s:prototype.SetMatchMode(match_mode) dict "{{{3
- " TLogVAR a:match_mode
- if !empty(a:match_mode)
- unlet self.matcher
- try
- let self.matcher = tlib#Filter_{a:match_mode}#New()
- call self.matcher.Init(self)
- catch /^Vim\%((\a\+)\)\=:E117/
- throw 'tlib: Unknown mode for tlib#input#filter_mode: '. a:match_mode
- endtry
- endif
-endf
-
-
-" function! s:prototype.Match(text) dict "{{{3
-" return self.matcher.Match(self, text)
-" endf
-
-
-" :nodoc:
-function! s:prototype.MatchBaseIdx(idx) dict "{{{3
- let text = self.GetBaseItem(a:idx)
- if !empty(self.filter_format)
- let text = self.FormatName(self.fmt_filter, self.filter_format, text)
- endif
- " TLogVAR text
- " return self.Match(text)
- return self.matcher.Match(self, text)
-endf
-
-
-" :nodoc:
-function! s:prototype.BuildTableList() dict "{{{3
- " let time0 = str2float(reltimestr(reltime())) " DBG
- " TLogVAR time0
- call self.SetFilter()
- " TLogVAR self.filter_neg, self.filter_pos
- let self.table = range(1, len(self.base))
- " TLogVAR self.filtered_items
- let copy_base = 1
- if !empty(self.filtered_items)
- let self.table = filter(self.table, 'index(self.filtered_items, v:val) != -1')
- let copy_base = 0
- endif
- if !empty(self.filter_pos) || !empty(self.filter_neg)
- let self.table = filter(self.table, 'self.MatchBaseIdx(v:val)')
- let copy_base = 0
- endif
- if copy_base
- let self.list = copy(self.base)
- else
- let self.list = map(copy(self.table), 'self.GetBaseItem(v:val)')
- endif
-endf
-
-
-" :nodoc:
-function! s:prototype.ReduceFilter() dict "{{{3
- " TLogVAR self.filter
- let reduced = 0
- while !reduced
- if self.filter[0] == [''] && len(self.filter) > 1
- call remove(self.filter, 0)
- elseif empty(self.filter[0][0]) && len(self.filter[0]) > 1
- call remove(self.filter[0], 0)
- else
- call self.matcher.ReduceFrontFilter(self)
- endif
- if self.IsValidFilter()
- let reduced = 1
- endif
- endwh
-endf
-
-
-" :nodoc:
-" filter is either a string or a list of list of strings.
-function! s:prototype.SetInitialFilter(filter) dict "{{{3
- " let self.initial_filter = [[''], [a:filter]]
- Tlibtrace 'tlib', a:filter
- if type(a:filter) == 3
- let self.initial_filter = deepcopy(a:filter)
- else
- let self.initial_filter = [[a:filter]]
- endif
-endf
-
-
-" :nodoc:
-function! s:prototype.PopFilter() dict "{{{3
- " TLogVAR self.filter
- if len(self.filter[0]) > 1
- call remove(self.filter[0], 0)
- elseif len(self.filter) > 1
- call remove(self.filter, 0)
- else
- let self.filter[0] = ['']
- endif
-endf
-
-
-" :nodoc:
-function! s:prototype.FilterIsEmpty() dict "{{{3
- " TLogVAR self.filter
- return self.filter == copy(self.initial_filter)
-endf
-
-
-" :nodoc:
-function! s:prototype.DisplayFilter() dict "{{{3
- let filter1 = copy(self.filter)
- call filter(filter1, 'v:val != [""]')
- " TLogVAR self.matcher['_class']
- let rv = self.matcher.DisplayFilter(filter1)
- let rv = self.CleanFilter(rv)
- return rv
-endf
-
-
-" :nodoc:
-function! s:prototype.SetFrontFilter(pattern) dict "{{{3
- call self.matcher.SetFrontFilter(self, a:pattern)
-endf
-
-
-" :nodoc:
-function! s:prototype.PushFrontFilter(char) dict "{{{3
- call self.matcher.PushFrontFilter(self, a:char)
-endf
-
-
-" :nodoc:
-function! s:prototype.CleanFilter(filter) dict "{{{3
- return self.matcher.CleanFilter(a:filter)
-endf
-
-
-" :nodoc:
-function! s:prototype.UseScratch() dict "{{{3
- " if type(self.scratch) != 0 && get(self, 'buffer_local', 1)
- " if self.scratch != fnamemodify(self.scratch, ':p')
- " let self.scratch = tlib#file#Join([expand('%:p:h'), self.scratch])
- " " TLogVAR self.scratch
- " endif
- " " let self.scratch_hidden = 'wipe'
- " endif
- keepjumps keepalt let rv = tlib#scratch#UseScratch(self)
- " if expand('%:t') == self.scratch
- let b:tlib_world = self
- " endif
- return rv
-endf
-
-
-" :nodoc:
-function! s:prototype.CloseScratch(...) dict "{{{3
- TVarArg ['reset_scratch', 0]
- " TVarArg ['reset_scratch', 1]
- " TLogVAR reset_scratch
- if self.sticky
- return 0
- else
- let rv = tlib#scratch#CloseScratch(self, reset_scratch)
- " TLogVAR rv
- if rv
- call self.SwitchWindow('win')
- endif
- return rv
- endif
-endf
-
-
-" :nodoc:
-function! s:prototype.Initialize() dict "{{{3
- let self.initialized = 1
- call self.SetOrigin(1)
- call self.Reset(1)
- if !empty(self.cache_var) && exists(self.cache_var)
- for prop in self.restore_from_cache
- exec 'let self[prop] = get('. self.cache_var .', prop, self[prop])'
- endfor
- exec 'unlet '. self.cache_var
- endif
-endf
-
-
-" :nodoc:
-function! s:prototype.Leave() dict "{{{3
- if !empty(self.cache_var)
- exec 'let '. self.cache_var .' = self'
- endif
- for handler in self.on_leave
- call call(handler, [self])
- endfor
-endf
-
-
-" :nodoc:
-function! s:prototype.UseInputListScratch() dict "{{{3
- let scratch = self.UseScratch()
- if !exists('b:tlib_list_init')
- call tlib#autocmdgroup#Init()
- autocmd TLib VimResized <buffer> call feedkeys("\<c-j>", 't')
- " autocmd TLib WinLeave <buffer> let b:tlib_world_event = 'WinLeave' | call feedkeys("\<c-j>", 't')
- let b:tlib_list_init = 1
- endif
- if !exists('w:tlib_list_init')
- " TLogVAR scratch
- if has_key(self, 'index_next_syntax')
- if type(self.index_next_syntax) == 1
- exec 'syntax match InputlListIndex /^\d\+:\s/ nextgroup='. self.index_next_syntax
- elseif type(self.index_next_syntax) == 4
- for [n, nsyn] in items(self.index_next_syntax)
- let fn = printf('%0'. world.index_width .'d', n)
- exec 'syntax match InputlListIndex /^'. fn .':\s/ nextgroup='. nsyn
- endfor
- endif
- else
- syntax match InputlListIndex /^\d\+:\s/
- endif
- call tlib#hook#Run('tlib_UseInputListScratch', self)
- syntax match InputlListCursor /^\d\+\* .*$/ contains=InputlListIndex
- syntax match InputlListSelected /^\d\+# .*$/ contains=InputlListIndex
- hi def link InputlListIndex Constant
- hi def link InputlListCursor Search
- hi def link InputlListSelected IncSearch
- setlocal nowrap
- " hi def link InputlListIndex Special
- " let b:tlibDisplayListMarks = {}
- let b:tlibDisplayListMarks = []
- let b:tlibDisplayListWorld = self
- let w:tlib_list_init = 1
- endif
- return scratch
-endf
-
-
-" s:prototype.Reset(?initial=0)
-" :nodoc:
-function! s:prototype.Reset(...) dict "{{{3
- TVarArg ['initial', 0]
- " TLogVAR initial
- Tlibtrace 'tlib', initial, self.initial_filter
- let self.state = 'display'
- let self.offset = 1
- let self.filter = deepcopy(self.initial_filter)
- let self.idx = ''
- let self.prefidx = 0
- let self.initial_display = 1
- let self.fmt_display = {}
- let self.fmt_filter = {}
- call self.UseInputListScratch()
- call self.ResetSelected()
- call self.Retrieve(!initial)
- call self.FormatBaseFromData()
- return self
-endf
-
-
-" :nodoc:
-function! s:prototype.ResetSelected() dict "{{{3
- let self.sel_idx = []
-endf
-
-
-" :nodoc:
-function! s:prototype.Retrieve(anyway) dict "{{{3
- " TLogVAR a:anyway, self.base
- " TLogDBG (a:anyway || empty(self.base))
- if (a:anyway || empty(self.base))
- let ra = self.retrieve_eval
- " TLogVAR ra
- if !empty(ra)
- let back = self.SwitchWindow('win')
- let world = self
- let self.base = eval(ra)
- " TLogVAR self.base
- exec back
- return 1
- endif
- endif
- return 0
-endf
-
-
-function! s:FormatHelp(help) "{{{3
- " TLogVAR a:help
- let max = [0, 0]
- for item in a:help
- " TLogVAR item
- if type(item) == 3
- let itemlen = map(copy(item), 'strwidth(v:val)')
- " TLogVAR itemlen
- let max = map(range(2), 'max[v:val] >= itemlen[v:val] ? max[v:val] : itemlen[v:val]')
- endif
- unlet item
- endfor
- " TLogVAR max
- let cols = float2nr((winwidth(0) - &foldcolumn - 1) / (max[0] + max[1] + 2))
- if cols < 1
- let cols = 1
- endif
- let fmt = printf('%%%ds: %%-%ds', max[0], max[1])
- " TLogVAR cols, fmt
- let help = []
- let idx = -1
- let maxidx = len(a:help)
- while idx < maxidx
- let push_item = 0
- let accum = []
- for i in range(cols)
- let idx += 1
- if idx >= maxidx
- break
- endif
- let item = a:help[idx]
- if type(item) == 3
- call add(accum, item)
- else
- let push_item = 1
- break
- endif
- unlet item
- endfor
- if !empty(accum)
- call add(help, s:FormatHelpItem(accum, fmt))
- endif
- if push_item
- call add(help, a:help[idx])
- endif
- endwh
- " TLogVAR help
- return help
-endf
-
-
-function! s:FormatHelpItem(item, fmt) "{{{3
- let args = [join(repeat([a:fmt], len(a:item)), ' ')]
- for item in a:item
- " TLogVAR item
- let args += item
- endfor
- " TLogVAR args
- return call('printf', args)
-endf
-
-
-" :nodoc:
-function! s:prototype.InitHelp() dict "{{{3
- return []
-endf
-
-
-" :nodoc:
-function! s:prototype.PushHelp(...) dict "{{{3
- " TLogVAR a:000
- if a:0 == 1
- if type(a:1) == 3
- let self.temp_lines += a:1
- else
- call add(self.temp_lines, a:1)
- endif
- elseif a:0 == 2
- call add(self.temp_lines, a:000)
- else
- throw "TLIB: PushHelp: Wrong number of arguments: ". string(a:000)
- endif
- " TLogVAR helpstring
-endf
-
-
-" :nodoc:
-function! s:prototype.DisplayHelp() dict "{{{3
- let self.temp_lines = self.InitHelp()
- call self.PushHelp('<Esc>', self.key_mode == 'default' ? 'Abort' : 'Reset keymap')
- call self.PushHelp('Enter, <cr>', 'Pick the current item')
- call self.PushHelp('Mouse', 'L: Pick item, R: Show menu')
- call self.PushHelp('<M-Number>', 'Select an item')
- call self.PushHelp('<BS>, <C-BS>', 'Reduce filter')
- call self.PushHelp('<Tab>', 'Complete word')
- call self.PushHelp('<S-Esc>, <F10>', 'Enter command')
-
- if self.key_mode == 'default'
- call self.PushHelp('<C|M-r>', 'Reset the display')
- call self.PushHelp('Up/Down', 'Next/previous item')
- call self.PushHelp('<C|M-q>', 'Edit top filter string')
- call self.PushHelp('Page Up/Down', 'Scroll')
- call self.PushHelp('<S-Space>', 'Enter * Wildcard')
- if self.allow_suspend
- call self.PushHelp('<C|M-z>', 'Suspend/Resume')
- call self.PushHelp('<C-o>', 'Switch to origin')
- endif
- if stridx(self.type, 'm') != -1
- call self.PushHelp('<S-Up/Down>', '(Un)Select items')
- call self.PushHelp('#', '(Un)Select the current item')
- call self.PushHelp('<C|M-a>', '(Un)Select all items')
- call self.PushHelp('<F9>', '(Un)Restrict view to selection')
- " \ '<c-\> ... Show only selected',
- endif
- endif
-
- " TLogVAR len(self.temp_lines)
- call self.matcher.Help(self)
-
- " TLogVAR self.key_mode
- for handler in values(self.key_map[self.key_mode])
- " TLogVAR handler
- let key = get(handler, 'key_name', '')
- " TLogVAR key
- if !empty(key)
- let desc = get(handler, 'help', '')
- if empty(desc)
- let desc = get(handler, 'agent', '')
- endif
- call self.PushHelp(key, desc)
- endif
- endfor
-
- if !has_key(self.key_map[self.key_mode], 'unknown_key')
- call self.PushHelp('Letter', 'Filter the list')
- endif
-
- if self.key_mode == 'default' && !empty(self.help_extra)
- call self.PushHelp(self.help_extra)
- endif
-
- " TLogVAR len(self.temp_lines)
- call self.PushHelp([
- \ '',
- \ 'Matches at word boundaries are prioritized.',
- \ ])
- let self.temp_lines = s:FormatHelp(self.temp_lines)
- call self.PrintLines()
-endf
-
-
-function! s:prototype.PrintLines() dict "{{{3
- let self.temp_prompt = ['Press any key to continue.', 'Question']
- call tlib#buffer#DeleteRange('1', '$')
- call append(0, self.temp_lines)
- call tlib#buffer#DeleteRange('$', '$')
- 1
- call self.Resize(len(self.temp_lines), 0)
- let self.temp_lines = []
-endf
-
-
-" :nodoc:
-function! s:prototype.Resize(hsize, vsize) dict "{{{3
- " TLogVAR self.scratch_vertical, a:hsize, a:vsize
- let world_resize = ''
- let winpos = ''
- let scratch_split = get(self, 'scratch_split', 1)
- " TLogVAR scratch_split
- if scratch_split > 0
- if self.scratch_vertical
- if a:vsize
- let world_resize = 'vert resize '. a:vsize
- let winpos = tlib#fixes#Winpos()
- " let w:winresize = {'v': a:vsize}
- setlocal winfixwidth
- endif
- else
- if a:hsize
- let world_resize = 'resize '. a:hsize
- " let w:winresize = {'h': a:hsize}
- setlocal winfixheight
- endif
- endif
- endif
- if !empty(world_resize)
- " TLogVAR world_resize, winpos
- exec world_resize
- if !empty(winpos)
- exec winpos
- endif
- " redraw!
- endif
-endf
-
-
-" :nodoc:
-function! s:prototype.GetResize(size) dict "{{{3
- let resize0 = get(self, 'resize', 0)
- let resize = empty(resize0) ? 0 : eval(resize0)
- " TLogVAR resize0, resize
- let resize = resize == 0 ? a:size : min([a:size, resize])
- " let min = self.scratch_vertical ? &cols : &lines
- let min1 = (self.scratch_vertical ? self.win_width : self.win_height) * g:tlib_inputlist_pct
- let min2 = (self.scratch_vertical ? &columns : &lines) * self.win_pct
- let min = max([min1, min2])
- let resize = min([resize, (min / 100)])
- " TLogVAR resize, a:size, min, min1, min2
- return resize
-endf
-
-
-" function! s:prototype.DisplayList(?query=self.Query(), ?list=[])
-" :nodoc:
-function! s:prototype.DisplayList(...) dict "{{{3
- " TLogVAR self.state
- let query = a:0 >= 1 ? a:1 : self.Query()
- let list = a:0 >= 2 ? a:2 : []
- " TLogVAR query, len(list)
- " TLogDBG 'len(list) = '. len(list)
- call self.UseScratch()
- " TLogVAR self.scratch
- " TAssert IsNotEmpty(self.scratch)
- if self.state == 'scroll'
- call self.ScrollToOffset()
- elseif self.state == 'help'
- call self.DisplayHelp()
- call self.SetStatusline(query)
- elseif self.state == 'printlines'
- call self.PrintLines()
- call self.SetStatusline(query)
- else
- " TLogVAR query
- " let ll = len(list)
- let ll = self.llen
- " let x = len(ll) + 1
- let x = self.index_width + 1
- " TLogVAR ll
- if self.state =~ '\<display\>'
- call self.Resize(self.GetResize(ll), eval(get(self, 'resize_vertical', 0)))
- call tlib#normal#WithRegister('gg"tdG', 't')
- let lines = copy(list)
- let lines = map(lines, 'substitute(v:val, ''[[:cntrl:][:space:]]'', " ", "g")')
- let w = winwidth(0) - &fdc
- " let w = winwidth(0) - &fdc - 1
- let lines = map(lines, 'printf("%-'. w .'.'. w .'s", v:val)')
- " TLogVAR lines
- call append(0, lines)
- call tlib#normal#WithRegister('G"tddgg', 't')
- endif
- " TLogVAR self.prefidx
- let base_pref = self.GetBaseIdx(self.prefidx)
- " TLogVAR base_pref
- if self.state =~ '\<redisplay\>'
- call filter(b:tlibDisplayListMarks, 'index(self.sel_idx, v:val) == -1 && v:val != base_pref')
- " TLogVAR b:tlibDisplayListMarks
- call map(b:tlibDisplayListMarks, 'self.DisplayListMark(x, v:val, ":")')
- " let b:tlibDisplayListMarks = map(copy(self.sel_idx), 'self.DisplayListMark(x, v:val, "#")')
- " call add(b:tlibDisplayListMarks, self.prefidx)
- " call self.DisplayListMark(x, self.GetBaseIdx(self.prefidx), '*')
- endif
- let b:tlibDisplayListMarks = map(copy(self.sel_idx), 'self.DisplayListMark(x, v:val, "#")')
- call add(b:tlibDisplayListMarks, base_pref)
- call self.DisplayListMark(x, base_pref, '*')
- call self.SetOffset()
- call self.SetStatusline(query)
- " TLogVAR self.offset
- call self.ScrollToOffset()
- let rx0 = self.GetRx0()
- " TLogVAR rx0
- if !empty(self.matcher.highlight)
- if empty(rx0)
- match none
- elseif self.IsValidFilter()
- if has_key(self, 'Highlighter')
- call self.Highlighter(rx0)
- else
- exec 'match '. self.matcher.highlight .' /\c'. escape(rx0, '/') .'/'
- endif
- endif
- endif
- endif
- redraw
-endf
-
-
-" :nodoc:
-function! s:prototype.SetStatusline(query) dict "{{{3
- " TLogVAR a:query
- if !empty(self.temp_prompt)
- let echo = get(self.temp_prompt, 0, '')
- let hl = get(self.temp_prompt, 1, 'Normal')
- let self.temp_prompt = []
- else
- let hl = 'Normal'
- let query = a:query
- let options = [self.matcher.name]
- if self.sticky
- call add(options, '#')
- endif
- if self.key_mode != 'default'
- call add(options, 'map:'. self.key_mode)
- endif
- if !empty(self.filtered_items)
- if g:tlib_inputlist_shortmessage
- call add(options, 'R')
- else
- call add(options, 'restricted')
- endif
- endif
- if !empty(options)
- let sopts = printf('[%s]', join(options, ', '))
- " let echo = query . repeat(' ', &columns - len(sopts) - len(query) - 20) . sopts
- let echo = query . ' ' . sopts
- " let query .= '%%='. sopts .' '
- endif
- " TLogVAR &l:statusline, query
- " let &l:statusline = query
- endif
- echo
- if hl != 'Normal'
- exec 'echohl' hl
- echo echo
- echohl None
- else
- echo echo
- endif
-endf
-
-
-" :nodoc:
-function! s:prototype.Query() dict "{{{3
- let flt = self.DisplayFilter()
- if g:tlib_inputlist_shortmessage
- let query = 'Filter: '. flt
- else
- let query = self.query .' (filter: '. flt .'; press <F1> for help)'
- endif
- return query
-endf
-
-
-" :nodoc:
-function! s:prototype.ScrollToOffset() dict "{{{3
- " TLogVAR self.scratch_vertical, self.llen, winheight(0)
- exec 'norm! '. self.offset .'zt'
-endf
-
-
-" :nodoc:
-function! s:prototype.SetOffset() dict "{{{3
- " TLogVAR self.prefidx, self.offset
- " TLogDBG winheight(0)
- " TLogDBG self.prefidx > self.offset + winheight(0) - 1
- let listtop = len(self.list) - winheight(0) + 1
- if listtop < 1
- let listtop = 1
- endif
- if self.prefidx > listtop
- let self.offset = listtop
- elseif self.prefidx > self.offset + winheight(0) - 1
- let listoff = self.prefidx - winheight(0) + 1
- let self.offset = min([listtop, listoff])
- " TLogVAR self.prefidx
- " TLogDBG len(self.list)
- " TLogDBG winheight(0)
- " TLogVAR listtop, listoff, self.offset
- elseif self.prefidx < self.offset
- let self.offset = self.prefidx
- endif
- " TLogVAR self.offset
-endf
-
-
-" :nodoc:
-function! s:prototype.ClearAllMarks() dict "{{{3
- let x = self.index_width + 1
- call map(range(1, line('$')), 'self.DisplayListMark(x, v:val, ":")')
-endf
-
-
-" :nodoc:
-function! s:prototype.MarkCurrent(y) dict "{{{3
- let x = self.index_width + 1
- call self.DisplayListMark(x, a:y, '*')
-endf
-
-
-" :nodoc:
-function! s:prototype.DisplayListMark(x, y, mark) dict "{{{3
- " TLogVAR a:y, a:mark
- if a:x > 0 && a:y >= 0
- " TLogDBG a:x .'x'. a:y .' '. a:mark
- let sy = self.GetListIdx(a:y) + 1
- " TLogVAR sy
- if sy >= 1
- call setpos('.', [0, sy, a:x, 0])
- exec 'norm! r'. a:mark
- " exec 'norm! '. a:y .'gg'. a:x .'|r'. a:mark
- endif
- endif
- return a:y
-endf
-
-
-" :nodoc:
-function! s:prototype.SwitchWindow(where) dict "{{{3
- " TLogDBG string(tlib#win#List())
- if self.tabpagenr != tabpagenr()
- call tlib#tab#Set(self.tabpagenr)
- endif
- let wnr = get(self, a:where.'_wnr')
- " TLogVAR self, wnr
- return tlib#win#Set(wnr)
-endf
-
-
-" :nodoc:
-function! s:prototype.FollowCursor() dict "{{{3
- if !empty(self.follow_cursor)
- let back = self.SwitchWindow('win')
- " TLogVAR back
- " TLogDBG winnr()
- try
- call call(self.follow_cursor, [self, [self.CurrentItem()]])
- finally
- exec back
- endtry
- endif
-endf
-
-
-" :nodoc:
-function! s:prototype.SetOrigin(...) dict "{{{3
- TVarArg ['winview', 0]
- " TLogVAR self.win_wnr, self.bufnr
- " TLogDBG bufname('%')
- " TLogDBG winnr()
- " TLogDBG winnr('$')
- let self.win_wnr = winnr()
- let self.win_height = winheight(self.win_wnr)
- let self.win_width = winwidth(self.win_wnr)
- " TLogVAR self.win_wnr, self.win_height, self.win_width
- let self.bufnr = bufnr('%')
- let self.tabpagenr = tabpagenr()
- let self.cursor = getpos('.')
- if winview
- let self.winview = tlib#win#GetLayout()
- endif
- " TLogVAR self.win_wnr, self.bufnr, self.winview
- return self
-endf
-
-
-" :nodoc:
-function! s:prototype.RestoreOrigin(...) dict "{{{3
- TVarArg ['winview', 0]
- if winview
- " TLogVAR winview
- call tlib#win#SetLayout(self.winview)
- endif
- " TLogVAR self.win_wnr, self.bufnr, self.cursor, &splitbelow
- " TLogDBG "RestoreOrigin0 ". string(tlib#win#List())
- " If &splitbelow or &splitright is false, we cannot rely on
- " self.win_wnr to be our source buffer since, e.g, opening a buffer
- " in a split window changes the whole layout.
- " Possible solutions:
- " - Restrict buffer switching to cases when the number of windows
- " hasn't changed.
- " - Guess the right window, which we try to do here.
- if &splitbelow == 0 || &splitright == 0
- let wn = bufwinnr(self.bufnr)
- " TLogVAR wn
- if wn == -1
- let wn = 1
- end
- else
- let wn = self.win_wnr
- endif
- if wn != winnr()
- exec wn .'wincmd w'
- endif
- exec 'buffer! '. self.bufnr
- call setpos('.', self.cursor)
- " TLogDBG "RestoreOrigin1 ". string(tlib#win#List())
-endf
-
-
-function! s:prototype.Suspend() dict "{{{3
- call tlib#agent#Suspend(self, self.rv)
-endf
-
diff --git a/vim/bundle/tlib_vim/autoload/tlib/agent.vim b/vim/bundle/tlib_vim/autoload/tlib/agent.vim
deleted file mode 100644
index e61f24b..0000000
--- a/vim/bundle/tlib_vim/autoload/tlib/agent.vim
+++ /dev/null
@@ -1,665 +0,0 @@
-" @Author: Tom Link (micathom AT gmail com?subject=[vim])
-" @Website: http://www.vim.org/account/profile.php?user_id=4037
-" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
-" @Revision: 329
-
-
-" :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
- for filename in a:selected
- call tlib#file#Edit(filename)
- endfor
- " 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)
- let arglead = tolower(a:Arglead)
- return filter(copy(s:agent_names), 'stridx(tolower(v:val), arglead) != -1')
-endf
-
-
-function! tlib#agent#Complete(world, selected) abort "{{{3
- let rxprefix = a:world.matcher.FilterRxPrefix()
- let flt = a:world.filter[0][0]
- " TLogVAR flt
- let fltrx = rxprefix . flt . '\m[^[:space:][:cntrl:][:punct:]<>*+?&~{}()\[\]\\/]\+'
- let fltrx0 = '\m^' . fltrx
- " TLogVAR fltrx, fltrx0
- let words = {}
- for item in a:world.list
- let parts = split(item, '\ze'. fltrx)
- " TLogVAR item, parts
- for part in parts
- let word = matchstr(part, fltrx0)
- " TLogVAR part, word
- if !empty(word)
- let words[word] = 1
- endif
- endfor
- endfor
- " TLogVAR keys(words)
- let completions = keys(words)
- " let completions = filter(keys(words), 'matchstr(v:val, fltrx0)')
- let completions = sort(completions, 's:SortCompletions')
- let completions = tlib#list#Uniq(completions)
- " TLogVAR 0, completions
- while len(completions) > 1
- let nchar = strwidth(completions[0]) - 1
- let completions = map(completions, 'strpart(v:val, 0, nchar)')
- " TLogVAR 'reduce', completions
- let completions = tlib#list#Uniq(completions)
- " TLogVAR 'unique', len(completions), completions
- endwh
- " TLogVAR 9, completions
- if empty(completions)
- let a:world.state = 'redisplay update'
- else
- let a:world.filter[0][0] = completions[0]
- let a:world.state = 'display update'
- endif
- return a:world
-endf
-
-
-function! s:SortCompletions(a, b) abort "{{{3
- let i1 = strwidth(a:a)
- let i2 = strwidth(a:b)
- return i2 - i1
-endf
-
diff --git a/vim/bundle/tlib_vim/autoload/tlib/arg.vim b/vim/bundle/tlib_vim/autoload/tlib/arg.vim
deleted file mode 100755
index f7d479e..0000000
--- a/vim/bundle/tlib_vim/autoload/tlib/arg.vim
+++ /dev/null
@@ -1,338 +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: 2016-06-06.
-" @Revision: 267
-
-
-" :def: function! tlib#arg#Get(n, var, ?default="", ?test='')
-" Set a positional argument from a variable argument list.
-" See tlib#string#RemoveBackslashes() for an example.
-function! tlib#arg#Get(n, var, ...) "{{{3
- let default = a:0 >= 1 ? a:1 : ''
- let atest = a:0 >= 2 ? a:2 : ''
- " TLogVAR default, atest
- if !empty(atest)
- let atest = ' && (a:'. a:n .' '. atest .')'
- endif
- let test = printf('a:0 >= %d', a:n) . atest
- return printf('let %s = %s ? a:%d : %s', a:var, test, a:n, string(default))
-endf
-
-
-" :def: function! tlib#arg#Let(list, ?default='')
-" Set a positional arguments from a variable argument list.
-" See tlib#input#List() for an example.
-function! tlib#arg#Let(list, ...) "{{{3
- let default = a:0 >= 1 ? a:1 : ''
- let list = map(copy(a:list), 'type(v:val) == 3 ? v:val : [v:val, default]')
- let args = map(range(1, len(list)), 'call("tlib#arg#Get", [v:val] + list[v:val - 1])')
- return join(args, ' | ')
-endf
-
-
-" :def: function! tlib#arg#StringAsKeyArgs(string, ?keys=[], ?evaluate=0, ?sep=':', ?booleans=0)
-function! tlib#arg#StringAsKeyArgs(string, ...) "{{{1
- TVarArg ['keys', {}], ['evaluate', 0], ['sep', ':'], ['booleans', 0]
- let keyargs = {}
- let args = split(a:string, '\\\@<! ')
- let key_rx = booleans ? '\([-+]\?\w\+\)' : '\(\w\+\)'
- let arglist = map(args, 'matchlist(v:val, ''^\%('. key_rx . sep .'\(.*\)\|\(.*\)\)$'')')
- " TLogVAR a:string, args, arglist
- let pos = -1
- for matchlist in arglist
- if !empty(matchlist[3])
- if booleans && matchlist[3] =~ '^[-+]'
- let key = substitute(matchlist[3], '^[-+]', '', '')
- let val = matchstr(matchlist[3], '^[-+]')
- let keyargs[key] = val ==# '+'
- else
- let pos += 1
- let keyargs[pos] = matchlist[3]
- endif
- else
- let [match, key, val; rest] = matchlist
- if empty(keys) || has_key(keys, key)
- let val = substitute(val, '\\\\', '\\', 'g')
- if evaluate
- let val = eval(val)
- endif
- let keyargs[key] = val
- else
- echom 'Unknown key: '. key .'='. val
- endif
- endif
- endfor
- if pos >= 0
- let keyargs['__posargs__'] = range(0, pos)
- endif
- return keyargs
-endf
-
-
-function! tlib#arg#StringAsKeyArgsEqual(string) "{{{1
- return tlib#arg#StringAsKeyArgs(a:string, [], 0, '=', 1)
-endf
-
-
-" :display: tlib#arg#GetOpts(args, ?def={})
-" Convert a list of strings of command-line arguments into a dictonary.
-"
-" The main use case is to pass [<f-args>], i.e. the command-line
-" arguments of a command as list, from a command definition to this
-" function.
-"
-" Example:
-" ['-h']
-" => If def contains a 'help' key, invoke |:help| on its value.
-"
-" ['-ab', '--foo', '--bar=BAR', 'bla', bla']
-" => {'a': 1, 'b': 1, 'foo': 1, 'bar': 'BAR', '__rest__': ['bla', 'bla']}
-"
-" ['-ab', '--', '--foo', '--bar=BAR']
-" => {'a': 1, 'b': 1, '__rest__': ['--foo', '--bar=BAR']}
-function! tlib#arg#GetOpts(args, ...) abort "{{{3
- let throw = a:0 == 0
- TVarArg ['def', {}]
- " TLogVAR def
- let opts = {'__exit__': 0}
- for [key, vdef] in items(get(def, 'values', {}))
- if has_key(vdef, 'default')
- let opts[key] = vdef.default
- endif
- endfor
- let idx = 0
- for o in a:args
- let [break, idx] = s:SetOpt(def, opts, idx, o)
- if break == 1
- break
- elseif break == 2
- if throw
- throw 'tlib#arg#GetOpts: Show help'
- else
- let opts.__exit__ = 5
- endif
- endif
- endfor
- let opts.__rest__ = a:args[idx : -1]
- return opts
-endf
-
-
-function! s:GetValueType(def) abort "{{{3
- return get(a:def, 'type', type(get(a:def, 'default', '')))
-endf
-
-
-function! s:SetOpt(def, opts, idx, opt) abort "{{{3
- " TLogVAR a:def
- let idx = a:idx + 1
- let break = 0
- let long = get(a:def, 'long', 1)
- let short = get(a:def, 'short', 1)
- if (short && a:opt =~# '^-[?h]$') || (long && a:opt ==# '--help')
- if has_key(a:def, 'help')
- exec 'help' a:def.help
- else
- " TLogVAR a:def
- let values = get(a:def, 'values', {})
- let flags = get(a:def, 'flags', {})
- if empty(values) && empty(flags)
- echom 'No help'
- else
- if !empty(values)
- echom 'Options:'
- for [key, vdef] in sort(items(values))
- let opt = key
- let default = get(vdef, 'default', '')
- let type = s:GetValueType(vdef)
- if default =~ '^-\?\d\+\%(\.\d\+\)$'
- if type == -1
- let opt .= ' (flag)'
- elseif type == 1
- let opt .= '=INT'
- else
- let opt .= '=INT or maybe BOOL'
- endif
- elseif type(default) == 1
- let opt .= '=STRING'
- elseif type(default) == 3
- let opt .= '=COMMA-LIST'
- endif
- echom printf(' --%20s (default: %s)', opt, string(default))
- endfor
- endif
- if !empty(flags)
- echom 'Short flags:'
- for [sflag, lflag] in sort(items(flags))
- echom printf(' -%s -> %s', sflag, lflag)
- endfor
- endif
- endif
- endif
- let break = 2
- elseif long && a:opt =~# '^--\%(no-\)\?debug$'
- if has_key(a:def, 'trace')
- let mod = a:opt =~# '--no-' ? '-' : '+'
- exec 'Tlibtraceset' mod . a:def.trace
- endif
- elseif long && a:opt =~# '^--no-.\+'
- let key = matchstr(a:opt, '^--no-\zs.\+$')
- let a:opts[key] = s:Validate(a:def, key, 0)
- elseif long && a:opt =~# '^--\w\+$'
- let key = matchstr(a:opt, '^--\zs.\+$')
- let a:opts[key] = s:Validate(a:def, key, 1)
- elseif long && a:opt =~# '^--\w\+='
- let ml = matchlist(a:opt, '^--\(\w\+\)=\(.*\)$')
- if empty(ml)
- throw 'tlib#arg#GetOpts: Cannot parse: '. a:opt
- else
- let values = get(a:def, 'values', {})
- if has_key(values, ml[1])
- let vdef = values[ml[1]]
- let type = s:GetValueType(vdef)
- if type == -1
- let opt_value = !!str2nr(ml[2])
- elseif type == 0
- let opt_value = str2nr(ml[2])
- elseif type == 1
- let opt_value = ml[2]
- elseif type == 2
- let opt_value = function(ml[2])
- elseif type == 3
- let opt_value = tlib#string#SplitCommaList(ml[2])
- elseif type == 4
- throw 'tlib#arg#GetOpts: Unsupported type conversion for '. ml[1]
- elseif type == 5
- let opt_value = str2float(ml[2])
- endif
- else
- let opt_value = ml[2]
- endif
- let a:opts[ml[1]] = s:Validate(a:def, ml[1], opt_value)
- unlet opt_value
- endif
- elseif short && a:opt =~# '^-\w='
- let flagdefs = get(a:def, 'flags', {})
- let flag = matchstr(a:opt, '^-\zs\w')
- let rest = matchstr(a:opt, '^-\w\zs.*$')
- call s:SetFlag(a:def, a:opts, idx, flag, rest, flagdefs)
- elseif short && a:opt =~# '^-\w\+$'
- let flagdefs = get(a:def, 'flags', {})
- for flag in split(substitute(a:opt, '^-', '', ''), '\zs')
- call s:SetFlag(a:def, a:opts, idx, flag, '', flagdefs)
- endfor
- else
- let break = 1
- if a:opt !=# '--'
- let idx -= 1
- endif
- endif
- return [break, idx]
-endf
-
-
-function! s:SetFlag(def, opts, idx, flag, rest, flagdefs) abort "{{{3
- " TLogVAR a:def
- if has_key(a:flagdefs, a:flag)
- call s:SetOpt(a:def, a:opts, a:idx, a:flagdefs[a:flag] . a:rest)
- else
- let a:opts[a:flag] = s:Validate(a:def, a:flag, 1)
- endif
-endf
-
-
-function! s:Validate(def, name, value) abort "{{{3
- let values = get(a:def, 'values', {})
- if has_key(values, a:name)
- let vdef = values[a:name]
- if has_key(vdef, 'validate')
- if !call(vdef.validate, [a:value])
- throw printf('tlib#arg: %s has invalid value: %s', string(a:name), string(a:value))
- endif
- endif
- endif
- return a:value
-endf
-
-
-":nodoc:
-function! tlib#arg#CComplete(def, ArgLead) abort "{{{3
- let values = get(a:def, 'values', {})
- let opt = matchstr(a:ArgLead, '^--\zs\w\+\ze=')
- if has_key(values, opt)
- let words = []
- let vals = values[opt]
- let complete_customlist = get(vals, 'complete_customlist', '')
- if !empty(complete_customlist)
- let words = eval(complete_customlist)
- " else
- " let complete = get(vals, 'complete', '')
- " if !empty(complete)
- " endif
- endif
- if !empty(words)
- let prefix = matchstr(a:ArgLead, '^--\w\+=\%([^,]\+,\s*\)*')
- let lead = substitute(a:ArgLead, '^--\w\+=\%([^,]\+,\s*\)*', '', '')
- " TLogVAR a:ArgLead, lead
- if !empty(lead)
- let nchar = len(lead)
- call filter(words, 'strpart(v:val, 0, nchar) ==# lead')
- endif
- let words = map(words, 'prefix . v:val')
- return sort(words)
- endif
- endif
- let cs = {'-h': 1, '--help': 1}
- for [name, vdef] in items(values)
- let type = s:GetValueType(vdef)
- if type >= 0
- let name .= '='
- else
- let cs['--no-'. name] = 1
- endif
- let cs['--'. name] = 1
- endfor
- for [name, subst] in items(get(a:def, 'flags', {}))
- let ldef = get(values, substitute(subst, '^--', '', ''), {})
- let type = s:GetValueType(ldef)
- if type >= 0
- let name .= '='
- endif
- let cs['-'. name] = 1
- endfor
- if has_key(a:def, 'trace')
- let cs['--debug'] = 1
- endif
- let nchar = len(a:ArgLead)
- if nchar > 0
- call filter(cs, 'strpart(v:key, 0, nchar) ==# a:ArgLead')
- endif
- return sort(keys(cs))
-endf
-
-
-
-""" Command line {{{1
-
-" :def: function! tlib#arg#Ex(arg, ?chars='%#! ')
-" Escape some characters in a string.
-"
-" Use |fnamescape()| if available.
-"
-" EXAMPLES: >
-" exec 'edit '. tlib#arg#Ex('foo%#bar.txt')
-function! tlib#arg#Ex(arg, ...) "{{{3
- if exists('*fnameescape') && a:0 == 0
- return fnameescape(a:arg)
- else
- " let chars = '%# \'
- let chars = '%#! '
- if a:0 >= 1
- let chars .= a:1
- endif
- return escape(a:arg, chars)
- endif
-endf
-
-
diff --git a/vim/bundle/tlib_vim/autoload/tlib/assert.vim b/vim/bundle/tlib_vim/autoload/tlib/assert.vim
deleted file mode 100644
index 5d4dea7..0000000
--- a/vim/bundle/tlib_vim/autoload/tlib/assert.vim
+++ /dev/null
@@ -1,44 +0,0 @@
-" @Author: Tom Link (mailto:micathom AT gmail com?subject=[vim])
-" @Website: https://github.com/tomtom
-" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
-" @Last Change: 2015-12-04
-" @Revision: 41
-
-
-" Enable tracing via |:Tlibassert|.
-function! tlib#assert#Enable() abort "{{{3
- " :nodoc:
- command! -nargs=+ -bang Tlibassert call tlib#assert#Assert(expand('<sfile>'), <q-args>, [<args>])
-endf
-
-
-" Disable tracing via |:Tlibassert|.
-function! tlib#assert#Disable() abort "{{{3
- " :nodoc:
- command! -nargs=+ -bang Tlibassert :
-endf
-
-
-function! tlib#assert#Assert(caller, check, vals) abort "{{{3
- for val in a:vals
- " TLogVAR val
- if type(val) == 3
- call tlib#assert#Assert(a:caller, a:check, val)
- elseif !val
- throw 'Tlibassert: '. tlib#trace#Backtrace(a:caller) .': '. a:check
- endif
- endfor
-endf
-
-
-function! tlib#assert#Map(vals, expr) abort "{{{3
- return tlib#assert#All(map(a:vals, a:expr))
-endf
-
-
-function! tlib#assert#All(vals) abort "{{{3
- " TLogVAR a:vals, empty(filter(a:vals, '!v:val'))
- return empty(filter(a:vals, '!v:val'))
-endf
-
-
diff --git a/vim/bundle/tlib_vim/autoload/tlib/autocmdgroup.vim b/vim/bundle/tlib_vim/autoload/tlib/autocmdgroup.vim
deleted file mode 100755
index 8439524..0000000
--- a/vim/bundle/tlib_vim/autoload/tlib/autocmdgroup.vim
+++ /dev/null
@@ -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
-
diff --git a/vim/bundle/tlib_vim/autoload/tlib/balloon.vim b/vim/bundle/tlib_vim/autoload/tlib/balloon.vim
deleted file mode 100644
index 6967523..0000000
--- a/vim/bundle/tlib_vim/autoload/tlib/balloon.vim
+++ /dev/null
@@ -1,73 +0,0 @@
-" @Author: Tom Link (micathom AT gmail com?subject=[vim])
-" @Website: http://www.vim.org/account/profile.php?user_id=4037
-" @GIT: http://github.com/tomtom/tlib_vim/
-" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
-" @Created: 2010-08-30.
-" @Last Change: 2015-11-23.
-" @Revision: 48
-
-
-function! tlib#balloon#Register(expr) "{{{3
- if !has('balloon_eval')
- return
- endif
- if !exists('b:tlib_balloons')
- let b:tlib_balloons = []
- endif
- if !&ballooneval
- setlocal ballooneval
- endif
- if &balloonexpr != 'tlib#balloon#Expr()'
- if !empty(&balloonexpr)
- call add(b:tlib_balloons, &balloonexpr)
- endif
- setlocal ballooneval balloonexpr=tlib#balloon#Expr()
- endif
- if index(b:tlib_balloons, a:expr) == -1
- call add(b:tlib_balloons, a:expr)
- endif
-endf
-
-
-function! tlib#balloon#Remove(expr) "{{{3
- if exists('b:tlib_balloons')
- call filter(b:tlib_balloons, 'v:val != a:expr')
- if empty(b:tlib_balloons)
- setlocal ballooneval&
- setlocal balloonexpr&
- unlet b:tlib_balloons
- endif
- endif
-endf
-
-
-function! tlib#balloon#Expr() "{{{3
- " TLogVAR exists('b:tlib_balloons')
- if !exists('b:tlib_balloons')
- return ''
- endif
- let text = map(copy(b:tlib_balloons), 'eval(v:val)')
- " TLogVAR b:tlib_balloons, text
- call filter(text, '!empty(v:val)')
- if has('balloon_multiline')
- return join(text, "\n----------------------------------\n")
- else
- return get(text, 0, '')
- endif
-endf
-
-
-function! tlib#balloon#Expand(expr) abort "{{{3
- if v:beval_bufnr != bufnr('%')
- " TLogVAR v:beval_bufnr, bufnr('%')
- return ''
- endif
- let win = winsaveview()
- try
- call setpos('.', [v:beval_bufnr, v:beval_lnum, v:beval_col, 0])
- return expand(a:expr)
- finally
- call winrestview(win)
- endtry
-endf
-
diff --git a/vim/bundle/tlib_vim/autoload/tlib/bitwise.vim b/vim/bundle/tlib_vim/autoload/tlib/bitwise.vim
deleted file mode 100644
index 54a4258..0000000
--- a/vim/bundle/tlib_vim/autoload/tlib/bitwise.vim
+++ /dev/null
@@ -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
-
diff --git a/vim/bundle/tlib_vim/autoload/tlib/buffer.vim b/vim/bundle/tlib_vim/autoload/tlib/buffer.vim
deleted file mode 100644
index aa75545..0000000
--- a/vim/bundle/tlib_vim/autoload/tlib/buffer.vim
+++ /dev/null
@@ -1,401 +0,0 @@
-" buffer.vim
-" @Author: Tom Link (micathom AT gmail com?subject=[vim])
-" @Website: http://www.vim.org/account/profile.php?user_id=4037
-" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
-" @Created: 2007-06-30.
-" @Last Change: 2015-11-06.
-" @Revision: 7.1.352
-
-
-" Where to display the line when using |tlib#buffer#ViewLine|.
-" For possible values for position see |scroll-cursor|.
-TLet g:tlib_viewline_position = 'zz'
-
-
-let s:bmru = []
-
-
-function! tlib#buffer#EnableMRU() "{{{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), 'str2nr(matchstr(v:val, ''\s*\zs\d\+\ze''))')
- " TLogVAR buffer_list, buffer_nr
- if show_number
- call map(buffer_list, 'matchstr(v:val, ''^\s*\d\+.\{-}\ze\s\+\S\+ \d\+\s*$'')')
- else
- call map(buffer_list, 'matchstr(v:val, ''^\s*\d\+\zs.\{-}\ze\s\+\S\+ \d\+\s*$'')')
- endif
- " TLogVAR buffer_list
- " call map(buffer_list, 'matchstr(v:val, ''^.\{-}\ze\s\+line \d\+\s*$'')')
- " TLogVAR buffer_list
- call map(buffer_list, 'matchstr(v:val, ''^[^"]\+''). printf("%-20s %s", fnamemodify(matchstr(v:val, ''"\zs.\{-}\ze"$''), ":t"), fnamemodify(matchstr(v:val, ''"\zs.\{-}\ze"$''), ":h"))')
- " TLogVAR buffer_list
- return [buffer_nr, buffer_list]
-endf
-
-
-" :def: function! tlib#buffer#ViewLine(line, ?position='z')
-" 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
- 2match none
- autocmd! TLib CursorMoved,CursorMovedI <buffer>
- autocmd! TLib CursorHold,CursorHoldI <buffer>
- autocmd! TLib InsertEnter,InsertChange,InsertLeave <buffer>
- autocmd! TLib BufLeave,BufWinLeave,WinLeave,BufHidden <buffer>
-endf
-
-
-function! tlib#buffer#HighlightLine(...) "{{{3
- TVarArg ['line', line('.')]
- " exec '2match MatchParen /^\%'. a:line .'l.*/'
- exec '2match Search /^\%'. line .'l.*/'
- call tlib#autocmdgroup#Init()
- exec 'autocmd TLib CursorMoved,CursorMovedI <buffer> if line(".") != '. line .' | call s:UndoHighlightLine() | endif'
- autocmd TLib CursorHold,CursorHoldI <buffer> call s:UndoHighlightLine()
- autocmd TLib InsertEnter <buffer> call s:UndoHighlightLine()
- " autocmd TLib BufLeave,BufWinLeave,WinLeave,BufHidden <buffer> call s:UndoHighlightLine()
-endf
-
-
-" Delete the lines in the current buffer. Wrapper for |:delete|.
-function! tlib#buffer#DeleteRange(line1, line2) "{{{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
- let keyargs = extend({
- \ 'shift': 0, 'col': col('.'), 'lineno': line('.'), 'pos': 'e', 'indent': 0
- \ }, keyargs)
- " TLogVAR keyargs
- let grow = 0
- let post_del_last_line = line('$') == 1
- let line = getline(keyargs.lineno)
- if keyargs.col + keyargs.shift > 0
- let pre = line[0 : (keyargs.col - 1 + keyargs.shift)]
- let post = line[(keyargs.col + keyargs.shift): -1]
- else
- let pre = ''
- let post = line
- endif
- " TLogVAR keyargs.lineno, line, pre, post
- let text0 = pre . a:text . post
- let text = split(text0, '\n', 1)
- " TLogVAR text
- let icol = len(pre)
- " exec 'norm! '. keyargs.lineno .'G'
- call cursor(keyargs.lineno, keyargs.col)
- if keyargs.indent && keyargs.col > 1
- if &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, keyargs.col('.') + keyargs.shift)
- " " TLogVAR idt
- " let idtl = len(idt)
- " -1,.delete
- " " TAssertExec redraw | sleep 3
- " call append(keyargs.lineno - 1, cline)
- " call cursor(keyargs.lineno, keyargs.col)
- " " TAssertExec redraw | sleep 3
- " if idtl == 0 && icol != 0
- " let idt = matchstr(pre, '^\s\+')
- " let idtl = len(idt)
- " endif
- " VERSION 2
- let idt = matchstr(pre, '^\s\+')
- let idtl = len(idt)
- else
- let [m_0, idt, iline; rest] = matchlist(pre, '^\(\s*\)\(.*\)$')
- let idtl = len(idt)
- endif
- if idtl < icol
- let idt .= repeat(' ', icol - idtl)
- endif
- " TLogVAR idt
- let idtl1 = len(idt)
- for i in range(1, len(text) - 1)
- let text[i] = idt . text[i]
- let grow += idtl1
- endfor
- endif
- " TLogVAR text
- " exec 'norm! '. keyargs.lineno .'Gdd'
- call tlib#normal#WithRegister('"tdd', 't')
- call append(keyargs.lineno - 1, text)
- if post_del_last_line
- call tlib#buffer#KeepCursorPosition('$delete')
- endif
- let tlen = len(text)
- let posshift = matchstr(keyargs.pos, '\d\+')
- " TLogVAR keyargs.pos
- if keyargs.pos =~ '^e'
- exec keyargs.lineno + tlen - 1
- exec 'norm! 0'. (len(text[-1]) - len(post) + posshift - 1) .'l'
- elseif keyargs.pos =~ '^s'
- " TLogVAR keyargs.lineno, pre, posshift
- exec keyargs.lineno
- exec 'norm! '. len(pre) .'|'
- if !empty(posshift)
- exec 'norm! '. posshift .'h'
- endif
- endif
- " TLogDBG getline(keyargs.lineno)
- " TLogDBG string(getline(1, '$'))
- return grow
-endf
-
-
-function! tlib#buffer#InsertText0(text, ...) "{{{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
-
diff --git a/vim/bundle/tlib_vim/autoload/tlib/cache.vim b/vim/bundle/tlib_vim/autoload/tlib/cache.vim
deleted file mode 100755
index 0f59f34..0000000
--- a/vim/bundle/tlib_vim/autoload/tlib/cache.vim
+++ /dev/null
@@ -1,360 +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: 2015-11-26.
-" @Revision: 35.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
-
-let s:cache = {}
-
-
-" :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
- TVarArg ['options', {}]
- let in_memory = get(options, 'in_memory', 0)
- if in_memory
- " TLogVAR in_memory, a:cfile, localtime()
- let s:cache[a:cfile] = {'mtime': localtime(), 'data': a:dictionary}
- elseif !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
- TVarArg ['default', {}], ['options', {}]
- let in_memory = get(options, 'in_memory', 0)
- if in_memory
- " TLogVAR in_memory, a:cfile
- return get(get(s:cache, a:cfile, {}), 'data', default)
- else
- 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
- return default
- endif
- endif
-endf
-
-
-" :display: tlib#cache#Value(cfile, generator, ftime, ?generator_args=[], ?options={})
-" Get a cached value from cfile. If it is outdated (compared to ftime)
-" or does not exist, create it calling a generator function.
-function! tlib#cache#Value(cfile, generator, ftime, ...) "{{{3
- TVarArg ['args', []], ['options', {}]
- let in_memory = get(options, 'in_memory', 0)
- if in_memory
- let not_found = !has_key(s:cache, a:cfile)
- let cftime = not_found ? -1 : s:cache[a:cfile].mtime
- else
- let cftime = getftime(a:cfile)
- endif
- " TLogVAR in_memory, cftime
- if cftime == -1 || (a:ftime != 0 && cftime < a:ftime)
- " TLogVAR a:generator, args
- let val = call(a:generator, args)
- " TLogVAR val
- let cval = {'val': val}
- " TLogVAR cval
- call tlib#cache#Save(a:cfile, cval, options)
- return val
- else
- let val = tlib#cache#Get(a:cfile, {}, options)
- if !has_key(val, 'val')
- throw 'tlib#cache#Value: Internal error: '. a:cfile
- else
- return val.val
- endif
- endif
-endf
-
-
-" 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 'silent cd '. fnameescape(dir)
- exec '! ' &shell shellescape(scriptfile, 1)
- exec 'silent cd -'
- call delete(scriptfile)
- elseif yn =~ '^e\%[dit]$'
- exec 'edit '. fnameescape(scriptfile)
- endif
- finally
- call inputrestore()
- endtry
- endif
- endif
- 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
-
diff --git a/vim/bundle/tlib_vim/autoload/tlib/char.vim b/vim/bundle/tlib_vim/autoload/tlib/char.vim
deleted file mode 100755
index d3d2cb6..0000000
--- a/vim/bundle/tlib_vim/autoload/tlib/char.vim
+++ /dev/null
@@ -1,59 +0,0 @@
-" @Author: Tom Link (micathom AT gmail com?subject=[vim])
-" @Website: http://www.vim.org/account/profile.php?user_id=4037
-" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
-" @Revision: 38
-
-
-" :def: function! tlib#char#Get(?timeout=0)
-" Get a character.
-"
-" EXAMPLES: >
-" echo tlib#char#Get()
-" echo tlib#char#Get(5)
-function! tlib#char#Get(...) "{{{3
- TVarArg ['timeout', 0], ['resolution', 0], ['getmod', 0]
- let char = -1
- let mode = 0
- if timeout == 0 || !has('reltime')
- let char = getchar()
- else
- let char = tlib#char#GetWithTimeout(timeout, resolution)
- endif
- if getmod
- if char != -1
- let mode = getcharmod()
- endif
- return [char, mode]
- else
- return char
- endif
-endf
-
-
-function! tlib#char#IsAvailable() "{{{3
- let ch = getchar(1)
- return type(ch) == 0 && ch != 0
-endf
-
-
-function! tlib#char#GetWithTimeout(timeout, ...) "{{{3
- TVarArg ['resolution', 2]
- " TLogVAR a:timeout, resolution
- let start = tlib#time#MSecs()
- while 1
- let c = getchar(0)
- if type(c) != 0 || c != 0
- return c
- else
- let now = tlib#time#MSecs()
- let diff = tlib#time#DiffMSecs(now, start, resolution)
- " TLogVAR diff
- if diff > a:timeout
- return -1
- endif
- endif
- endwh
- return -1
-endf
-
-
diff --git a/vim/bundle/tlib_vim/autoload/tlib/cmd.vim b/vim/bundle/tlib_vim/autoload/tlib/cmd.vim
deleted file mode 100755
index f65a237..0000000
--- a/vim/bundle/tlib_vim/autoload/tlib/cmd.vim
+++ /dev/null
@@ -1,117 +0,0 @@
-" @Author: Tom Link (micathom AT gmail com?subject=[vim])
-" @Website: http://www.vim.org/account/profile.php?user_id=4037
-" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
-" @Revision: 58
-
-
-let g:tlib#cmd#last_output = []
-
-
-function! tlib#cmd#OutputAsList(command) "{{{3
- " TLogVAR a:command
- if exists('s:redir_lines')
- redir END
- let cache = s:redir_lines
- endif
- let s:redir_lines = ''
- redir =>> s:redir_lines
- silent! exec a:command
- redir END
- let g:tlib#cmd#last_output = split(s:redir_lines, '\n')
- unlet s:redir_lines
- if exists('cache')
- let s:redir_lines = cache
- redir =>> s:redir_lines
- endif
- return g:tlib#cmd#last_output
-endf
-
-
-" See |:TBrowseOutput|.
-function! tlib#cmd#BrowseOutput(command) "{{{3
- call tlib#cmd#BrowseOutputWithCallback("tlib#cmd#DefaultBrowseOutput", a:command)
-endf
-
-" :def: function! tlib#cmd#BrowseOutputWithCallback(callback, command)
-" Execute COMMAND and present its output in a |tlib#input#List()|;
-" when a line is selected, execute the function named as the CALLBACK
-" and pass in that line as an argument.
-"
-" The CALLBACK function gives you an opportunity to massage the COMMAND output
-" and possibly act on it in a meaningful way. For example, if COMMAND listed
-" all URIs found in the current buffer, CALLBACK could validate and then open
-" the selected URI in the system's default browser.
-"
-" This function is meant to be a tool to help compose the implementations of
-" powerful commands that use |tlib#input#List()| as a common interface. See
-" |TBrowseScriptnames| as an example.
-"
-" EXAMPLES: >
-" call tlib#cmd#BrowseOutputWithCallback('tlib#cmd#ParseScriptname', 'scriptnames')
-function! tlib#cmd#BrowseOutputWithCallback(callback, command) "{{{3
- let list = tlib#cmd#OutputAsList(a:command)
- let cmds = tlib#input#List('m', 'Output of: '. a:command, list)
- if !empty(cmds)
- for cmd in cmds
- let Callback = function(a:callback)
- call call(Callback, [cmd])
- endfor
- endif
-endf
-
-function! tlib#cmd#DefaultBrowseOutput(cmd) "{{{3
- call feedkeys(':'. a:cmd)
-endf
-
-function! tlib#cmd#ParseScriptname(line) "{{{3
- " let parsedValue = substitute(a:line, '^.\{-}\/', '/', '')
- let parsedValue = matchstr(a:line, '^\s*\d\+:\s*\zs.*$')
- exe 'drop '. fnameescape(parsedValue)
-endf
-
-
-function! tlib#cmd#TBrowseScriptnames() abort "{{{3
- call tlib#cmd#BrowseOutputWithCallback("tlib#cmd#ParseScriptname", "scriptnames")
-endf
-
-
-" :def: function! tlib#cmd#UseVertical(?rx='')
-" Look at the history whether the command was called with vertical. If
-" an rx is provided check first if the last entry in the history matches
-" this rx.
-function! tlib#cmd#UseVertical(...) "{{{3
- TVarArg ['rx']
- let h0 = histget(':')
- let rx0 = '\C\<vert\%[ical]\>\s\+'
- if !empty(rx)
- let rx0 .= '.\{-}'.rx
- endif
- " TLogVAR h0, rx0
- return h0 =~ rx0
-endf
-
-
-" Print the time in seconds or milliseconds (if your version of VIM
-" has |+reltime|) a command takes.
-function! tlib#cmd#Time(cmd) "{{{3
- if has('reltime')
- let start = tlib#time#Now()
- exec a:cmd
- let end = tlib#time#Now()
- let diff = string(tlib#time#Diff(end, start)) .'ms'
- else
- let start = localtime()
- exec a:cmd
- let diff = (localtime() - start) .'s'
- endif
- echom 'Time: '. diff .': '. a:cmd
-endf
-
-
-function! tlib#cmd#Capture(cmd) "{{{3
- redir => s
- silent exec a:cmd
- redir END
- return s
-endf
-
diff --git a/vim/bundle/tlib_vim/autoload/tlib/comments.vim b/vim/bundle/tlib_vim/autoload/tlib/comments.vim
deleted file mode 100755
index 879cde1..0000000
--- a/vim/bundle/tlib_vim/autoload/tlib/comments.vim
+++ /dev/null
@@ -1,26 +0,0 @@
-" @Author: Tom Link (mailto:micathom AT gmail com?subject=[vim])
-" @Website: http://www.vim.org/account/profile.php?user_id=4037
-" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
-" @Revision: 25
-
-
-" function! tlib#comments#Comments(?rx='')
-function! tlib#comments#Comments(...)
- TVarArg ['rx', '']
- let comments = {}
- let co = &comments
- while !empty(co)
- " TLogVAR co
- let [m_0, m_key, m_val, m_val1, co0, co; rest] = matchlist(co, '^\([^:]*\):\(\(\\.\|[^,]*\)\+\)\(,\(.*\)$\|$\)')
- " TLogVAR m_key, m_val, co
- if empty(m_key)
- let m_key = ':'
- endif
- if empty(rx) || m_key =~ rx
- let comments[m_key] = m_val
- endif
- endwh
- return comments
-endf
-
-
diff --git a/vim/bundle/tlib_vim/autoload/tlib/date.vim b/vim/bundle/tlib_vim/autoload/tlib/date.vim
deleted file mode 100755
index 8268424..0000000
--- a/vim/bundle/tlib_vim/autoload/tlib/date.vim
+++ /dev/null
@@ -1,189 +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: 2016-06-06.
-" @Revision: 41.0.34
-
-
-if !exists('g:tlib#date#ShortDatePrefix') | let g:tlib#date#ShortDatePrefix = '20' | endif "{{{2
-if !exists('g:tlib#date#TimeZoneShift') | let g:tlib#date#TimeZoneShift = 0 | endif "{{{2
-
-let g:tlib#date#dayshift = 60 * 60 * 24
-" let g:tlib#date#date_rx = '\<\(\d\{4}\)-\(\d\d\)-\(\d\d\)\%(\s\+\(\(\d\d\):\(\d\d\)\)\)\?\>'
-let g:tlib#date#date_rx = '\<\(\d\{4}\)-\(\d\d\)-\(\d\d\)\>'
-let g:tlib#date#date_format = '%Y-%m-%d'
-
-
-function! tlib#date#IsDate(text) abort "{{{3
- return a:text =~# '^'. g:tlib#date#date_rx .'$' &&
- \ !empty(tlib#date#Parse(a:text, 0, 1))
-endf
-
-
-function! tlib#date#Format(...) abort "{{{3
- let secs1970 = a:0 >= 1 ? a:1 : localtime()
- return strftime(g:tlib#date#date_format, secs1970)
-endf
-
-
-" :display: tlib#date#DiffInDays(date1, ?date2=localtime(), ?allow_zero=0)
-function! tlib#date#DiffInDays(date, ...)
- let allow_zero = a:0 >= 2 ? a:2 : 0
- let s0 = tlib#date#SecondsSince1970(a:date, 0, allow_zero)
- let s1 = a:0 >= 1 ? tlib#date#SecondsSince1970(a:1, 0, allow_zero) : localtime()
- let dd = (s0 - s1) / g:tlib#date#dayshift
- " TLogVAR dd
- return dd
-endf
-
-
-" :display: tlib#date#Parse(date, ?allow_zero=0, ?silent=0) "{{{3
-function! tlib#date#Parse(date, ...) "{{{3
- let min = a:0 >= 1 && a:1 ? 0 : 1
- let silent = a:0 >= 2 ? a:2 : 0
- " 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
- if !silent
- echoerr 'TLib: Invalid date: '. a:date
- endif
- 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
-
-
-function! tlib#date#Shift(date, shift) abort "{{{3
- let n = str2nr(matchstr(a:shift, '\d\+'))
- let ml = matchlist(a:date, g:tlib#date#date_rx)
- " TLogVAR a:date, a:shift, n, ml
- if a:shift =~ 'd$'
- let date = tlib#date#AddDays(a:date, n)
- elseif a:shift =~ 'b$'
- let n1 = n
- let secs = tlib#date#SecondsSince1970(a:date)
- while n1 > 0
- let n1 -= 1
- let secs += g:tlib#date#dayshift
- let uday = strftime('%u', secs)
- if uday == 6
- let secs += g:tlib#date#dayshift * 2
- elseif uday == 7
- let secs += g:tlib#date#dayshift
- endif
- endwh
- let date = tlib#date#Format(secs)
- elseif a:shift =~ 'w$'
- let date = tlib#date#AddDays(a:date, n * 7)
- elseif a:shift =~ 'm$'
- let d = str2nr(ml[3])
- let ms = str2nr(ml[2]) + n
- let m = (ms - 1) % 12 + 1
- let yr = str2nr(ml[1]) + (ms - 1) / 12
- let date = printf('%04d-%02d-%02d', yr, m, d)
- " TLogVAR d, ms, m, yr, date
- elseif a:shift =~ 'y$'
- let yr = str2nr(ml[1]) + n
- let date = substitute(a:date, '^\d\{4}', yr, '')
- else
- throw 'tlib#date#Shift: Unsupported arguments: '. string(a:shift)
- endif
- " if !empty(ml[4]) && date !~ '\s'. ml[4] .'$'
- " let date .= ' '. ml[4]
- " endif
- " TLogVAR date
- return date
-endf
-
-
-function! tlib#date#AddDays(date, n) abort "{{{3
- let secs = tlib#date#SecondsSince1970(a:date) + g:tlib#date#dayshift * a:n
- " TLogVAR secs
- let date = tlib#date#Format(secs)
- return date
-endf
-
diff --git a/vim/bundle/tlib_vim/autoload/tlib/dictionary.vim b/vim/bundle/tlib_vim/autoload/tlib/dictionary.vim
deleted file mode 100644
index a778519..0000000
--- a/vim/bundle/tlib_vim/autoload/tlib/dictionary.vim
+++ /dev/null
@@ -1,45 +0,0 @@
-" @Author: Tom Link (mailto:micathom AT gmail com?subject=[vim])
-" @Website: https://github.com/tomtom
-" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
-" @Last Change: 2016-04-06
-" @Revision: 22
-
-
-" :display: tlib#dictionary#Rev(dict, ?opts = {}) abort "{{{3
-function! tlib#dictionary#Rev(dict, ...) abort "{{{3
- let opts = a:0 >= 1 ? a:1 : {}
- Tlibtype a:dict, 'dict', opts, 'dict'
- let rev = {}
- let use_string = get(opts, 'use_string', 0)
- let use_eval = get(opts, 'use_eval', 0)
- let values_as_list = get(opts, 'values_as_list', 0)
- for [m, f] in items(a:dict)
- if use_string
- let k = string(f)
- else
- let k = type(f) == 1 ? f : string(f)
- if k ==# ''
- let k = get(opts, 'empty', '')
- if empty(k)
- continue
- endif
- endif
- endif
- if use_eval
- let v = eval(m)
- else
- let v = m
- endif
- if values_as_list
- if has_key(rev, k)
- call add(rev[k], v)
- else
- let rev[k] = [v]
- endif
- else
- let rev[k] = v
- endif
- endfor
- return rev
-endf
-
diff --git a/vim/bundle/tlib_vim/autoload/tlib/dir.vim b/vim/bundle/tlib_vim/autoload/tlib/dir.vim
deleted file mode 100755
index 0208107..0000000
--- a/vim/bundle/tlib_vim/autoload/tlib/dir.vim
+++ /dev/null
@@ -1,93 +0,0 @@
-" @Author: Tom Link (micathom AT gmail com?subject=[vim])
-" @Website: http://www.vim.org/account/profile.php?user_id=4037
-" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
-" @Revision: 43
-
-" TLet g:tlib#dir#sep = '/'
-TLet g:tlib#dir#sep = exists('+shellslash') && !&shellslash ? '\' : '/'
-
-
-let s:dir_stack = []
-
-" EXAMPLES: >
-" tlib#dir#CanonicName('foo/bar')
-" => 'foo/bar/'
-function! tlib#dir#CanonicName(dirname) "{{{3
- let dirname = tlib#file#Canonic(a:dirname)
- if dirname !~ '[/\\]$'
- return dirname . g:tlib#dir#sep
- endif
- return dirname
-endf
-
-
-" EXAMPLES: >
-" tlib#dir#NativeName('foo/bar/')
-" On Windows:
-" => 'foo\bar\'
-" On Linux:
-" => 'foo/bar/'
-function! tlib#dir#NativeName(dirname) "{{{3
- let sep = tlib#rx#EscapeReplace(g:tlib#dir#sep)
- let dirname = substitute(a:dirname, '[\/]', sep, 'g')
- return dirname
-endf
-
-
-" EXAMPLES: >
-" tlib#dir#PlainName('foo/bar/')
-" => 'foo/bar'
-function! tlib#dir#PlainName(dirname) "{{{3
- let dirname = a:dirname
- while index(['/', '\'], dirname[-1 : -1]) != -1
- let dirname = dirname[0 : -2]
- endwh
- return dirname
- " return substitute(a:dirname, tlib#rx#Escape(g:tlib#dir#sep).'\+$', '', '')
-endf
-
-
-" Create a directory if it doesn't already exist.
-function! tlib#dir#Ensure(dir) "{{{3
- if !isdirectory(a:dir)
- let dir = tlib#dir#PlainName(a:dir)
- return mkdir(dir, 'p')
- endif
- return 1
-endf
-
-
-" Return the first directory in &rtp.
-function! tlib#dir#MyRuntime() "{{{3
- return get(split(&rtp, ','), 0)
-endf
-
-
-" :def: function! tlib#dir#CD(dir, ?locally=0) => CWD
-function! tlib#dir#CD(dir, ...) "{{{3
- TVarArg ['locally', haslocaldir()]
- let cmd = locally ? 'lcd! ' : 'cd! '
- " let cwd = getcwd()
- let cmd .= tlib#arg#Ex(a:dir)
- " TLogVAR a:dir, locally, cmd
- exec 'silent' cmd
- " return cwd
- return getcwd()
-endf
-
-
-" :def: function! tlib#dir#Push(dir, ?locally=0) => CWD
-function! tlib#dir#Push(dir, ...) "{{{3
- TVarArg ['locally', haslocaldir()]
- call add(s:dir_stack, [getcwd(), locally])
- return tlib#dir#CD(a:dir, locally)
-endf
-
-
-" :def: function! tlib#dir#Pop() => CWD
-function! tlib#dir#Pop() "{{{3
- let [dir, locally] = remove(s:dir_stack, -1)
- return tlib#dir#CD(dir, locally)
-endf
-
-
diff --git a/vim/bundle/tlib_vim/autoload/tlib/eval.vim b/vim/bundle/tlib_vim/autoload/tlib/eval.vim
deleted file mode 100755
index 117209e..0000000
--- a/vim/bundle/tlib_vim/autoload/tlib/eval.vim
+++ /dev/null
@@ -1,72 +0,0 @@
-" @Author: Tom Link (mailto:micathom AT gmail com?subject=[vim])
-" @Website: http://www.vim.org/account/profile.php?user_id=4037
-" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
-" @Revision: 56
-
-
-function! tlib#eval#FormatValue(value, ...) "{{{3
- TVarArg ['indent', 0]
- " TLogVAR a:value, indent
- let indent1 = indent + 1
- let indenti = repeat(' ', &sw)
- let type = type(a:value)
- let acc = []
- if type == 0 || type == 1 || type == 2
- " TLogDBG 'Use string() for type='. type
- call add(acc, string(a:value))
- elseif type == 3 "List
- " TLogDBG 'List'
- call add(acc, '[')
- for e in a:value
- call add(acc, printf('%s%s,', indenti, tlib#eval#FormatValue(e, indent1)))
- unlet e
- endfor
- call add(acc, ']')
- elseif type == 4 "Dictionary
- " TLogDBG 'Dictionary'
- call add(acc, '{')
- let indent1 = indent + 1
- for [k, v] in items(a:value)
- call add(acc, printf("%s%s: %s,", indenti, string(k), tlib#eval#FormatValue(v, indent1)))
- unlet k v
- endfor
- call add(acc, '}')
- else
- " TLogDBG 'Unknown type: '. string(a:value)
- call add(acc, string(a:value))
- endif
- if indent > 0
- let is = repeat(' ', indent * &sw)
- for i in range(1,len(acc) - 1)
- let acc[i] = is . acc[i]
- endfor
- endif
- return join(acc, "\n")
-endf
-
-
-function! tlib#eval#Extend(a, b, ...) abort "{{{3
- let mode = a:0 >= 1 ? a:1 : 'force'
- if type(a:a) != type(a:b)
- throw 'tlib#eval#Extend: Incompatible types: a='. string(a:a) .' b='. string(a:b)
- elseif type(a:a) == 3 " list
- return extend(a:a, a:b, mode)
- elseif type(a:a) == 4 " dict
- for k in keys(a:b)
- if has_key(a:a, k)
- if mode == 'force'
- let a:a[k] = tlib#eval#Extend(copy(a:a[k]), a:b[k], mode)
- elseif mode == 'error'
- throw 'tlib#eval#Extend: Key already exists: '. k
- endif
- else
- let a:a[k] = a:b[k]
- endif
- unlet! k
- endfor
- return a:a
- else
- return a:b
- endif
-endf
-
diff --git a/vim/bundle/tlib_vim/autoload/tlib/file.vim b/vim/bundle/tlib_vim/autoload/tlib/file.vim
deleted file mode 100644
index 44ba044..0000000
--- a/vim/bundle/tlib_vim/autoload/tlib/file.vim
+++ /dev/null
@@ -1,283 +0,0 @@
-" @Author: Tom Link (micathom AT gmail com?subject=[vim])
-" @Website: http://www.vim.org/account/profile.php?user_id=4037
-" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
-" @Revision: 169
-
-
-if !exists('g:tlib#file#drop')
- " If true, use |:drop| to edit loaded buffers (only available with GUI).
- let g:tlib#file#drop = has('gui') "{{{2
-endif
-
-
-if !exists('g:tlib#file#use_tabs')
- let g:tlib#file#use_tabs = 0 "{{{2
-endif
-
-
-if !exists('g:tlib#file#edit_cmds')
- let g:tlib#file#edit_cmds = g:tlib#file#use_tabs ? {'buffer': 'tab split | buffer', 'edit': 'tabedit'} : {} "{{{2
-endif
-
-
-if !exists('g:tlib#file#absolute_filename_rx')
- let g:tlib#file#absolute_filename_rx = '^\~\?[\/]' "{{{2
-endif
-
-""" 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, ?maybe_absolute=0)
-" EXAMPLES: >
-" tlib#file#Join(['foo', 'bar', 'filename.txt'])
-" => 'foo/bar/filename.txt'
-function! tlib#file#Join(filename_parts, ...) "{{{3
- TVarArg ['strip_slashes', 1], 'maybe_absolute'
- " TLogVAR a:filename_parts, strip_slashes
- if maybe_absolute
- let filename_parts = []
- for part in a:filename_parts
- if part =~ g:tlib#file#absolute_filename_rx
- let filename_parts = []
- endif
- call add(filename_parts, part)
- endfor
- else
- let filename_parts = a:filename_parts
- endif
- if strip_slashes
- " let rx = tlib#rx#Escape(g:tlib#dir#sep) .'$'
- let rx = '[/\\]\+$'
- let parts = map(copy(filename_parts), 'substitute(v:val, rx, "", "")')
- " TLogVAR parts
- return join(parts, g:tlib#dir#sep)
- else
- return join(filename_parts, g:tlib#dir#sep)
- endif
-endf
-
-
-" EXAMPLES: >
-" tlib#file#Relative('foo/bar/filename.txt', 'foo')
-" => 'bar/filename.txt'
-function! tlib#file#Relative(filename, basedir) "{{{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#IsAbsolute(filename) "{{{3
- return a:filename =~? '^\%(/\|\w\+:/\)'
-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
-
-
-" Return 0 if the file isn't readable/doesn't exist.
-" Otherwise return 1.
-function! tlib#file#Edit(fileid) "{{{3
- if type(a:fileid) == 0
- let bn = a:fileid
- let filename = fnamemodify(bufname(bn), ':p')
- else
- let filename = fnamemodify(a:fileid, ':p')
- let bn = bufnr(filename)
- endif
- if filename == expand('%:p')
- return 1
- else
- " TLogVAR a:fileid, bn, filename, g:tlib#file#drop, filereadable(filename)
- if bn != -1 && buflisted(bn)
- if g:tlib#file#drop
- " echom "DBG" get(g:tlib#file#edit_cmds, 'drop', 'drop') fnameescape(filename)
- exec get(g:tlib#file#edit_cmds, 'drop', 'drop') fnameescape(filename)
- else
- " echom "DBG" get(g:tlib#file#edit_cmds, 'buffer', 'buffer') bn
- exec get(g:tlib#file#edit_cmds, 'buffer', 'buffer') bn
- endif
- return 1
- elseif filereadable(filename)
- try
- " let file = tlib#arg#Ex(filename)
- " " TLogVAR file
- " echom "DBG" get(g:tlib#file#edit_cmds, 'edit', 'edit') fnameescape(filename)
- exec get(g:tlib#file#edit_cmds, 'edit', 'edit') fnameescape(filename)
- catch /E325/
- " swap file exists, let the user handle it
- catch
- echohl error
- echom v:exception
- echohl NONE
- endtry
- return 1
- else
- echom "TLIB: File not readable: " . filename
- if filename != a:fileid
- echom "TLIB: original filename: " . a:fileid
- endif
- endif
- endif
- return 0
-endf
-
-
-if v:version > 704 || (v:version == 704 && has('patch279'))
-
- function! tlib#file#Glob(pattern) abort "{{{3
- return glob(a:pattern, 0, 1)
- endf
-
- function! tlib#file#Globpath(path, pattern) abort "{{{3
- return globpath(a:path, a:pattern, 0, 1)
- endf
-
-else
-
- " :nodoc:
- function! tlib#file#Glob(pattern) abort "{{{3
- return split(glob(a:pattern), '\n')
- endf
-
- " :nodoc:
- function! tlib#file#Globpath(path, pattern) abort "{{{3
- return split(globpath(a:path, a:pattern), '\n')
- endf
-
-endif
-
diff --git a/vim/bundle/tlib_vim/autoload/tlib/fixes.vim b/vim/bundle/tlib_vim/autoload/tlib/fixes.vim
deleted file mode 100644
index e9247dd..0000000
--- a/vim/bundle/tlib_vim/autoload/tlib/fixes.vim
+++ /dev/null
@@ -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
-
diff --git a/vim/bundle/tlib_vim/autoload/tlib/grep.vim b/vim/bundle/tlib_vim/autoload/tlib/grep.vim
deleted file mode 100644
index 894b1ee..0000000
--- a/vim/bundle/tlib_vim/autoload/tlib/grep.vim
+++ /dev/null
@@ -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
-
diff --git a/vim/bundle/tlib_vim/autoload/tlib/hash.vim b/vim/bundle/tlib_vim/autoload/tlib/hash.vim
deleted file mode 100644
index 29c9ef6..0000000
--- a/vim/bundle/tlib_vim/autoload/tlib/hash.vim
+++ /dev/null
@@ -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
-
-
diff --git a/vim/bundle/tlib_vim/autoload/tlib/hook.vim b/vim/bundle/tlib_vim/autoload/tlib/hook.vim
deleted file mode 100755
index 07d0504..0000000
--- a/vim/bundle/tlib_vim/autoload/tlib/hook.vim
+++ /dev/null
@@ -1,25 +0,0 @@
-" @Author: Tom Link (micathom AT gmail com?subject=[vim])
-" @Website: http://www.vim.org/account/profile.php?user_id=4037
-" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
-" @Revision: 11
-
-
-" :def: function! tlib#hook#Run(hook, ?dict={})
-" Execute dict[hook], w:{hook}, b:{hook}, or g:{hook} if existent.
-function! tlib#hook#Run(hook, ...) "{{{3
- TVarArg ['dict', {}]
- if has_key(dict, a:hook)
- let hook = dict[a:hook]
- else
- let hook = tlib#var#Get(a:hook, 'wbg')
- endif
- if empty(hook)
- return 0
- else
- let world = dict
- exec hook
- return 1
- endif
-endf
-
-
diff --git a/vim/bundle/tlib_vim/autoload/tlib/input.vim b/vim/bundle/tlib_vim/autoload/tlib/input.vim
deleted file mode 100644
index e8f892b..0000000
--- a/vim/bundle/tlib_vim/autoload/tlib/input.vim
+++ /dev/null
@@ -1,1336 +0,0 @@
-" @Author: Tom Link (micathom AT gmail com?subject=[vim])
-" @Website: http://www.vim.org/account/profile.php?user_id=4037
-" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
-" @Revision: 1366
-
-
-" :filedoc:
-" Input-related, select from a list etc.
-
-" If a list is bigger than this value, don't try to be smart when
-" selecting an item. Be slightly faster instead.
-" See |tlib#input#List()|.
-TLet g:tlib#input#sortprefs_threshold = 200
-
-
-" If a list contains more items, |tlib#input#List()| does not perform an
-" incremental "live search" but uses |input()| to query the user for a
-" filter. This is useful on slower machines or with very long lists.
-TLet g:tlib#input#livesearch_threshold = 1000
-
-
-" Determine how |tlib#input#List()| and related functions work.
-" Can be "glob", "cnf", "cnfd", "seq", or "fuzzy". See:
-" glob ... Like cnf but "*" and "?" (see |g:tlib#Filter_glob#seq|,
-" |g:tlib#Filter_glob#char|) are interpreted as glob-like
-" |wildcards| (this is the default method)
-" - Examples:
-" - "f*o" matches "fo", "fxo", and "fxxxoo", but doesn't match
-" "far".
-" - Otherwise it is a derivate of the cnf method (see below).
-" - See also |tlib#Filter_glob#New()|.
-" cnfd ... Like cnf but "." is interpreted as a wildcard, i.e. it is
-" expanded to "\.\{-}"
-" - A period character (".") acts as a wildcard as if ".\{-}" (see
-" |/\{-|) were entered.
-" - Examples:
-" - "f.o" matches "fo", "fxo", and "fxxxoo", but doesn't match
-" "far".
-" - Otherwise it is a derivate of the cnf method (see below).
-" - See also |tlib#Filter_cnfd#New()|.
-" cnf .... Match substrings
-" - A blank creates an AND conjunction, i.e. the next pattern has to
-" match too.
-" - A pipe character ("|") creates an OR conjunction, either this or
-" the next next pattern has to match.
-" - Patterns are very 'nomagic' |regexp| with a |\V| prefix.
-" - A pattern starting with "-" makes the filter exclude items
-" matching that pattern.
-" - Examples:
-" - "foo bar" matches items that contain the strings "foo" AND
-" "bar".
-" - "foo|bar boo|far" matches items that contain either ("foo" OR
-" "bar") AND ("boo" OR "far").
-" - See also |tlib#Filter_cnf#New()|.
-" seq .... Match sequences of characters
-" - |tlib#Filter_seq#New()|
-" fuzzy .. Match fuzzy character sequences
-" - |tlib#Filter_fuzzy#New()|
-TLet g:tlib#input#filter_mode = 'glob'
-
-
-" The highlight group to use for showing matches in the input list
-" window.
-" See |tlib#input#List()|.
-TLet g:tlib#input#higroup = 'IncSearch'
-
-" When 1, automatically select the last remaining item only if the list
-" had only one item to begin with.
-" When 2, automatically select a last remaining item after applying
-" any filters.
-" See |tlib#input#List()|.
-TLet g:tlib_pick_last_item = 1
-
-
-" :doc:
-" Keys for |tlib#input#List|~
-
-TLet g:tlib#input#and = ' '
-TLet g:tlib#input#or = '|'
-TLet g:tlib#input#not = '-'
-
-" When editing a list with |tlib#input#List|, typing these numeric chars
-" (as returned by getchar()) will select an item based on its index, not
-" based on its name. I.e. in the default setting, typing a "4" will
-" select the fourth item, not the item called "4".
-" In order to make keys 0-9 filter the items in the list and make
-" <m-[0-9]> select an item by its index, remove the keys 48 to 57 from
-" this dictionary.
-" Format: [KEY] = BASE ... the number is calculated as KEY - BASE.
-" :nodefault:
-TLet g:tlib#input#numeric_chars = {
- \ 176: 176,
- \ 177: 176,
- \ 178: 176,
- \ 179: 176,
- \ 180: 176,
- \ 181: 176,
- \ 182: 176,
- \ 183: 176,
- \ 184: 176,
- \ 185: 176,
- \}
- " \ 48: 48,
- " \ 49: 48,
- " \ 50: 48,
- " \ 51: 48,
- " \ 52: 48,
- " \ 53: 48,
- " \ 54: 48,
- " \ 55: 48,
- " \ 56: 48,
- " \ 57: 48,
-
-
-" :nodefault:
-" The default key bindings for single-item-select list views.
-"
-" This variable is best customized via the variable
-" g:tlib_extend_keyagents_InputList_s. If you want to use <c-j>, <c-k>
-" to move the cursor up and down, add these two lines to your |vimrc|
-" file:
-"
-" let g:tlib_extend_keyagents_InputList_s = {
-" \ 10: 'tlib#agent#Down',
-" \ 11: 'tlib#agent#Up'
-" \ }
-TLet g:tlib#input#keyagents_InputList_s = {
- \ "\<PageUp>": 'tlib#agent#PageUp',
- \ "\<PageDown>": 'tlib#agent#PageDown',
- \ "\<Home>": 'tlib#agent#Home',
- \ "\<End>": 'tlib#agent#End',
- \ "\<Up>": 'tlib#agent#Up',
- \ "\<Down>": 'tlib#agent#Down',
- \ 9: 'tlib#agent#Complete',
- \ "\<c-Up>": 'tlib#agent#UpN',
- \ "\<c-Down>": 'tlib#agent#DownN',
- \ "\<Left>": 'tlib#agent#ShiftLeft',
- \ "\<Right>": 'tlib#agent#ShiftRight',
- \ 18: 'tlib#agent#Reset',
- \ 242: 'tlib#agent#Reset',
- \ 17: 'tlib#agent#Input',
- \ 241: 'tlib#agent#Input',
- \ 27: 'tlib#agent#Exit',
- \ 26: 'tlib#agent#Suspend',
- \ 250: 'tlib#agent#Suspend',
- \ 15: 'tlib#agent#SuspendToParentWindow',
- \ "\<F1>": 'tlib#agent#Help',
- \ "\<F10>": 'tlib#agent#ExecAgentByName',
- \ "\<S-Esc>": 'tlib#agent#ExecAgentByName',
- \ "\<bs>": 'tlib#agent#ReduceFilter',
- \ "\<del>": 'tlib#agent#ReduceFilter',
- \ "\<c-bs>": 'tlib#agent#PopFilter',
- \ "\<m-bs>": 'tlib#agent#PopFilter',
- \ "\<c-del>": 'tlib#agent#PopFilter',
- \ "\<m-del>": 'tlib#agent#PopFilter',
- \ "\<s-space>": 'tlib#agent#Wildcard',
- \ 191: 'tlib#agent#Debug',
- \ char2nr(g:tlib#input#or): 'tlib#agent#OR',
- \ char2nr(g:tlib#input#and): 'tlib#agent#AND',
- \ }
- " \ 63: 'tlib#agent#Help',
-
-if exists('g:tlib_extend_keyagents_InputList_s')
- let g:tlib#input#keyagents_InputList_s = extend(g:tlib#input#keyagents_InputList_s, g:tlib_extend_keyagents_InputList_s)
-endif
-
-
-" :nodefault:
-TLet g:tlib#input#keyagents_InputList_m = {
- \ 35: 'tlib#agent#Select',
- \ "\<s-up>": 'tlib#agent#SelectUp',
- \ "\<s-down>": 'tlib#agent#SelectDown',
- \ 1: 'tlib#agent#SelectAll',
- \ 225: 'tlib#agent#SelectAll',
- \ "\<F9>": 'tlib#agent#ToggleRestrictView',
- \ }
-" "\<c-space>": 'tlib#agent#Select'
-
-if exists('g:tlib_extend_keyagents_InputList_m')
- let g:tlib#input#keyagents_InputList_m = extend(g:tlib#input#keyagents_InputList_m, g:tlib_extend_keyagents_InputList_m)
-endif
-
-
-
-" :nodefault:
-TLet g:tlib#input#handlers_EditList = [
- \ {'key': 5, 'agent': 'tlib#agent#EditItem', 'key_name': '<c-e>', 'help': 'Edit item'},
- \ {'key': 4, 'agent': 'tlib#agent#DeleteItems', 'key_name': '<c-d>', 'help': 'Delete item(s)'},
- \ {'key': 14, 'agent': 'tlib#agent#NewItem', 'key_name': '<c-n>', 'help': 'New item'},
- \ {'key': 24, 'agent': 'tlib#agent#Cut', 'key_name': '<c-x>', 'help': 'Cut item(s)'},
- \ {'key': 3, 'agent': 'tlib#agent#Copy', 'key_name': '<c-c>', 'help': 'Copy item(s)'},
- \ {'key': 22, 'agent': 'tlib#agent#Paste', 'key_name': '<c-v>', 'help': 'Paste item(s)'},
- \ {'pick_last_item': 0},
- \ {'return_agent': 'tlib#agent#EditReturnValue'},
- \ {'help_extra': [
- \ 'Submit changes by pressing ENTER or <c-s> or <c-w><cr>',
- \ 'Cancel editing by pressing <c-w>c'
- \ ]},
- \ ]
-
-
-" A dictionary KEY => {'agent': AGENT, 'key_name': KEY_NAME} to
-" customize keyboard shortcuts in the list view.
-TLet g:tlib#input#user_shortcuts = {}
-
-
-" If true, define a popup menu for |tlib#input#List()| and related
-" functions.
-TLet g:tlib#input#use_popup = has('menu') && (has('gui_gtk') || has('gui_gtk2') || has('gui_win32'))
-
-
-" How to format filenames:
-" l ... Show basenames on the left side, separated from the
-" directory names
-" r ... Show basenames on the right side
-TLet g:tlib#input#format_filename = 'l'
-
-
-" If g:tlib#input#format_filename == 'r', how much space should be kept
-" free on the right side.
-TLet g:tlib#input#filename_padding_r = '&co / 10'
-
-
-" If g:tlib#input#format_filename == 'l', an expression that
-" |eval()|uates to the maximum display width of filenames.
-TLet g:tlib#input#filename_max_width = '&co / 2'
-
-
-" Functions related to tlib#input#List(type, ...) "{{{2
-
-" :def: function! tlib#input#List(type. ?query='', ?list=[], ?handlers=[], ?default="", ?timeout=0)
-" Select a single or multiple items from a list. Return either the list
-" of selected elements or its indexes.
-"
-" By default, typing numbers will select an item by its index. See
-" |g:tlib#input#numeric_chars| to find out how to change this.
-"
-" The item is automatically selected if the numbers typed equals the
-" number of digits of the list length. I.e. if a list contains 20 items,
-" typing 1 will first highlight item 1 but it won't select/use it
-" because 1 is an ambiguous input in this context. If you press enter,
-" the first item will be selected. If you press another digit (e.g. 0),
-" item 10 will be selected. Another way to select item 1 would be to
-" type 01. If the list contains only 9 items, typing 1 would select the
-" first item right away.
-"
-" type can be:
-" s ... Return one selected element
-" si ... Return the index of the selected element
-" m ... Return a list of selected elements
-" mi ... Return a list of indexes
-"
-" Several pattern matching styles are supported. See
-" |g:tlib#input#filter_mode|.
-"
-" Users can type <Tab> to complete the current filter with the longest
-" match.
-"
-" EXAMPLES: >
-" echo tlib#input#List('s', 'Select one item', [100,200,300])
-" echo tlib#input#List('si', 'Select one item', [100,200,300])
-" echo tlib#input#List('m', 'Select one or more item(s)', [100,200,300])
-" echo tlib#input#List('mi', 'Select one or more item(s)', [100,200,300])
-"
-" See ../samples/tlib/input/tlib_input_list.vim (move the cursor over
-" the filename and press gf) for a more elaborated example.
-function! tlib#input#List(type, ...) "{{{3
- exec tlib#arg#Let([
- \ ['query', ''],
- \ ['list', []],
- \ ['handlers', []],
- \ ['rv', ''],
- \ ['timeout', 0],
- \ ])
- " let handlers = a:0 >= 1 ? a:1 : []
- " let rv = a:0 >= 2 ? a:2 : ''
- " let timeout = a:0 >= 3 ? a:3 : 0
- " let backchar = ["\<bs>", "\<del>"]
-
- if a:type =~ '^resume'
- let world = b:tlib_{matchstr(a:type, ' \zs.\+')}
- else
- let world = tlib#World#New({
- \ 'type': a:type,
- \ 'base': list,
- \ 'query': query,
- \ 'timeout': timeout,
- \ 'rv': rv,
- \ 'handlers': handlers,
- \ })
- let scratch_name = tlib#list#Find(handlers, 'has_key(v:val, "scratch_name")', '', 'v:val.scratch_name')
- if !empty(scratch_name)
- let world.scratch = scratch_name
- endif
- let world.scratch_vertical = tlib#list#Find(handlers, 'has_key(v:val, "scratch_vertical")', 0, 'v:val.scratch_vertical')
- call world.Set_display_format(tlib#list#Find(handlers, 'has_key(v:val, "display_format")', '', 'v:val.display_format'))
- let world.initial_index = tlib#list#Find(handlers, 'has_key(v:val, "initial_index")', 1, 'v:val.initial_index')
- let world.index_table = tlib#list#Find(handlers, 'has_key(v:val, "index_table")', [], 'v:val.index_table')
- let world.state_handlers = filter(copy(handlers), 'has_key(v:val, "state")')
- let world.post_handlers = filter(copy(handlers), 'has_key(v:val, "postprocess")')
- let world.filter_format = tlib#list#Find(handlers, 'has_key(v:val, "filter_format")', '', 'v:val.filter_format')
- let world.return_agent = tlib#list#Find(handlers, 'has_key(v:val, "return_agent")', '', 'v:val.return_agent')
- let world.help_extra = tlib#list#Find(handlers, 'has_key(v:val, "help_extra")', '', 'v:val.help_extra')
- let world.resize = tlib#list#Find(handlers, 'has_key(v:val, "resize")', '', 'v:val.resize')
- let world.show_empty = tlib#list#Find(handlers, 'has_key(v:val, "show_empty")', 0, 'v:val.show_empty')
- let world.pick_last_item = tlib#list#Find(handlers, 'has_key(v:val, "pick_last_item")',
- \ tlib#var#Get('tlib_pick_last_item', 'bg'), 'v:val.pick_last_item')
- let world.numeric_chars = tlib#list#Find(handlers, 'has_key(v:val, "numeric_chars")',
- \ g:tlib#input#numeric_chars, 'v:val.numeric_chars')
- let world.key_handlers = filter(copy(handlers), 'has_key(v:val, "key")')
- let filter = tlib#list#Find(handlers, 'has_key(v:val, "filter")', '', 'v:val.filter')
- if !empty(filter)
- " let world.initial_filter = [[''], [filter]]
- " let world.initial_filter = [[filter]]
- " TLogVAR world.initial_filter
- call world.SetInitialFilter(filter)
- endif
- endif
- return tlib#input#ListW(world)
-endf
-
-
-" A wrapper for |tlib#input#ListW()| that builds |tlib#World#New| from
-" dict.
-function! tlib#input#ListD(dict) "{{{3
- return tlib#input#ListW(tlib#World#New(a:dict))
-endf
-
-
-" :def: function! tlib#input#ListW(world, ?command='')
-" The second argument (command) is meant for internal use only.
-" The same as |tlib#input#List| but the arguments are packed into world
-" (an instance of tlib#World as returned by |tlib#World#New|).
-function! tlib#input#ListW(world, ...) "{{{3
- TVarArg 'cmd'
- " let time0 = str2float(reltimestr(reltime())) " DBG
- " TLogVAR time0
- let world = a:world
- if world.pick_last_item >= 1 && stridx(world.type, 'e') == -1 && len(world.base) <= 1
- let rv = get(world.base, 0, world.rv)
- if stridx(world.type, 'm') != -1
- return [rv]
- else
- return rv
- endif
- endif
- call s:Init(world, cmd)
- " TLogVAR world.state, world.sticky, world.initial_index
- " let statusline = &l:statusline
- " let laststatus = &laststatus
- let showmode = &showmode
- set noshowmode
- let lastsearch = @/
- let scrolloff = &l:scrolloff
- let &l:scrolloff = 0
- let @/ = ''
- let dlist = []
- let post_keys = ''
- " let &laststatus = 2
-
- try
- while !empty(world.state) && world.state !~ '^exit' && (world.show_empty || !empty(world.base))
- let post_keys = ''
- " TLogDBG 'while'
- " TLogVAR world.state
- " let time01 = str2float(reltimestr(reltime())) " DBG
- " TLogVAR time01, time01 - time0
- try
- let world = s:RunStateHandlers(world)
-
- " if exists('b:tlib_world_event')
- " let event = b:tlib_world_event
- " unlet! b:tlib_world_event
- " if event == 'WinLeave'
- " " let world.resume_state = world.state
- " let world = tlib#agent#Suspend(world, world.rv)
- " break
- " endif
- " endif
-
- " let time02 = str2float(reltimestr(reltime())) " DBG
- " TLogVAR time02, time02 - time0
- if world.state =~ '\<reset\>'
- " TLogDBG 'reset'
- " call world.Reset(world.state =~ '\<initial\>')
- call world.Reset()
- continue
- endif
-
- call s:SetOffset(world)
-
- " let time02 = str2float(reltimestr(reltime())) " DBG
- " TLogVAR time02, time02 - time0
- " TLogDBG 1
- " TLogVAR world.state
- if world.state == 'scroll'
- let world.prefidx = world.offset
- let world.state = 'redisplay'
- endif
-
- if world.state =~ '\<sticky\>'
- let world.sticky = 1
- endif
-
- " TLogVAR world.filter
- " TLogVAR world.sticky
- if world.state =~ '\<picked\>'
- " TLogVAR world.rv
- throw 'picked'
- elseif world.state =~ '\<pick\>'
- let world.rv = world.CurrentItem()
- " TLogVAR world.rv
- throw 'picked'
- elseif world.state =~ 'display'
- if world.state =~ '^display'
- " let time03 = str2float(reltimestr(reltime())) " DBG
- " TLogVAR time03, time03 - time0
- if world.IsValidFilter()
-
- " let time1 = str2float(reltimestr(reltime())) " DBG
- " TLogVAR time1, time1 - time0
- call world.BuildTableList()
- " let time2 = str2float(reltimestr(reltime())) " DBG
- " TLogVAR time2, time2 - time0
- " TLogDBG 2
- " TLogDBG len(world.table)
- " TLogVAR world.table
- " let world.list = map(copy(world.table), 'world.GetBaseItem(v:val)')
- " TLogDBG 3
- let world.llen = len(world.list)
- " TLogVAR world.index_table
- if empty(world.index_table)
- let dindex = range(1, world.llen)
- let world.index_width = len(world.llen)
- else
- let dindex = world.index_table
- let world.index_width = len(max(dindex))
- endif
- " let time3 = str2float(reltimestr(reltime())) " DBG
- " TLogVAR time3, time3 - time0
- if world.llen == 0 && !world.show_empty
- call world.ReduceFilter()
- let world.offset = 1
- " TLogDBG 'ReduceFilter'
- continue
- else
- if world.llen == 1
- let world.last_item = world.list[0]
- if world.pick_last_item >= 2
- " echom 'Pick last item: '. world.list[0]
- let world.prefidx = '1'
- " TLogDBG 'pick last item'
- throw 'pick'
- endif
- else
- let world.last_item = ''
- endif
- endif
- " let time4 = str2float(reltimestr(reltime())) " DBG
- " TLogVAR time4, time4 - time0
- " TLogDBG 4
- " TLogVAR world.idx, world.llen, world.state
- " TLogDBG world.FilterIsEmpty()
- if world.state == 'display'
- if world.idx == '' && world.llen < g:tlib#input#sortprefs_threshold && !world.FilterIsEmpty()
- call world.SetPrefIdx()
- else
- let world.prefidx = world.idx == '' ? world.initial_index : world.idx
- endif
- if world.prefidx > world.llen
- let world.prefidx = world.llen
- elseif world.prefidx < 1
- let world.prefidx = 1
- endif
- endif
- " let time5 = str2float(reltimestr(reltime())) " DBG
- " TLogVAR time5, time5 - time0
- " TLogVAR world.initial_index, world.prefidx
- " TLogDBG 5
- " TLogDBG len(world.list)
- " TLogVAR world.list
- let dlist = world.DisplayFormat(world.list)
- " TLogVAR world.prefidx
- " TLogDBG 6
- " let time6 = str2float(reltimestr(reltime())) " DBG
- " TLogVAR time6, time6 - time0
- if world.offset_horizontal > 0
- call map(dlist, 'v:val[world.offset_horizontal:-1]')
- endif
- " let time7 = str2float(reltimestr(reltime())) " DBG
- " TLogVAR time7, time7 - time0
- " TLogVAR dindex
- let dlist = map(range(0, world.llen - 1), 'printf("%0'. world.index_width .'d", dindex[v:val]) .": ". dlist[v:val]')
- " TLogVAR dlist
- " let time8 = str2float(reltimestr(reltime())) " DBG
- " TLogVAR time8, time8 - time0
-
- else
-
- let dlist = ['Malformed filter']
-
- endif
- else
- if world.prefidx == 0
- let world.prefidx = 1
- endif
- endif
- " TLogVAR world.idx, world.prefidx
-
- " TLogDBG 7
- " TLogVAR world.prefidx, world.offset
- " TLogDBG (world.prefidx > world.offset + winheight(0) - 1)
- " if world.prefidx > world.offset + winheight(0) - 1
- " let listtop = world.llen - winheight(0) + 1
- " let listoff = world.prefidx - winheight(0) + 1
- " let world.offset = min([listtop, listoff])
- " TLogVAR world.prefidx
- " TLogDBG len(list)
- " TLogDBG winheight(0)
- " TLogVAR listtop, listoff, world.offset
- " elseif world.prefidx < world.offset
- " let world.offset = world.prefidx
- " endif
- " TLogDBG 8
- " TLogVAR world.initial_display, !tlib#char#IsAvailable()
- if world.state =~ '\<update\>' || world.initial_display || !tlib#char#IsAvailable()
- " TLogDBG len(dlist)
- call world.DisplayList(world.Query(), dlist)
- call world.FollowCursor()
- let world.initial_display = 0
- " TLogDBG 9
- endif
- if world.state =~ '\<hibernate\>'
- let world.state = 'suspend'
- else
- let world.state = ''
- endif
- else
- " if world.state == 'scroll'
- " let world.prefidx = world.offset
- " endif
- call world.DisplayList()
- if world.state == 'help' || world.state == 'printlines'
- let world.state = 'display'
- else
- let world.state = ''
- call world.FollowCursor()
- endif
- endif
- " TAssert IsNotEmpty(world.scratch)
- let world.list_wnr = winnr()
-
- " TLogVAR world.state, world.next_state
- if !empty(world.next_state)
- let world.state = world.next_state
- let world.next_state = ''
- endif
-
- if world.state =~ '\<suspend\>'
- let world = tlib#agent#SuspendToParentWindow(world, world.rv)
- continue
- endif
-
- if world.state =~ '\<eval\>'
- let query = matchstr(world.state, '\<eval\[\zs.\{-}\ze\]')
- if empty(query)
- let query = 'Waiting for input ... Press ESC to continue'
- endif
- if has('gui_win32')
- let exec_cmd = input(query, '')
- " TLogVAR exec_cmd
- if exec_cmd == ''
- let world.state = 'redisplay'
- else
- exec exec_cmd
- endif
- elseif has('gui_gtk') || has('gui_gtk2')
- let c = s:GetModdedChar(world)
- " TLogVAR c
- endif
- else
- " TLogVAR world.timeout
- let c = s:GetModdedChar(world)
- " TLogVAR c, has_key(world.key_map[world.key_mode],c)
- endif
- " TLogVAR c
- " TLogDBG string(sort(keys(world.key_map[world.key_mode])))
-
- " TLogVAR world.next_agent, world.next_eval
- if !empty(world.next_agent)
- let nagent = world.next_agent
- let world.next_agent = ''
- " let world = call(nagent, [world, world.GetSelectedItems(world.CurrentItem())])
- " call s:CheckAgentReturnValue(nagent, world)
- let world = s:CallAgent({'agent': nagent}, world, world.GetSelectedItems(world.CurrentItem()))
- elseif !empty(world.next_eval)
- let selected = world.GetSelectedItems(world.CurrentItem())
- let neval = world.next_eval
- let world.next_eval = ''
- exec neval
- call s:CheckAgentReturnValue(neval, world)
- elseif world.state != ''
- " continue
- elseif has_key(world.key_map[world.key_mode], c)
- let sr = @/
- silent! let @/ = lastsearch
- " TLogVAR c, world.key_map[world.key_mode][c]
- " TLog "Agent: ". string(world.key_map[world.key_mode][c])
- let handler = world.key_map[world.key_mode][c]
- " " TLogVAR handler
- " let world = call(handler.agent, [world, world.GetSelectedItems(world.CurrentItem())])
- " call s:CheckAgentReturnValue(c, world)
- let world = s:CallAgent(handler, world, world.GetSelectedItems(world.CurrentItem()))
- silent! let @/ = sr
- " continue
- elseif c == 13
- throw 'pick'
- elseif c == 27
- " TLogVAR c, world.key_mode
- if world.key_mode != 'default'
- let world.key_mode = 'default'
- let world.state = 'redisplay'
- else
- let world.state = 'exit empty'
- endif
- elseif c == "\<LeftMouse>"
- if v:mouse_win == world.list_wnr
- let world.prefidx = world.GetLineIdx(v:mouse_lnum)
- " let world.offset = world.prefidx
- if empty(world.prefidx)
- " call feedkeys(c, 't')
- let c = s:GetModdedChar(world)
- let world.state = 'help'
- continue
- endif
- throw 'pick'
- else
- let post_keys = v:mouse_lnum .'gg'. v:mouse_col .'|'. c
- if world.allow_suspend
- let world = tlib#agent#SuspendToParentWindow(world, world.rv)
- else
- let world.state = 'exit empty'
- endif
- endif
- elseif c == "\<RightMouse>"
- if v:mouse_win == world.list_wnr
- call s:BuildMenu(world)
- let world.state = 'redisplay'
- if s:PopupmenuExists() == 1
- " if v:mouse_lnum != line('.')
- " endif
- let world.prefidx = world.GetLineIdx(v:mouse_lnum)
- let world.next_state = 'eval[Waiting for popup menu ... Press ESC to continue]'
- call world.DisplayList()
- if line('w$') - v:mouse_lnum < 6
- popup ]TLibInputListPopupMenu
- else
- popup! ]TLibInputListPopupMenu
- endif
- endif
- else
- let post_keys = v:mouse_lnum .'gg'. v:mouse_col .'|'. c
- if world.allow_suspend
- let world = tlib#agent#SuspendToParentWindow(world, world.rv)
- else
- let world.state = 'exit empty'
- endif
- endif
- " TLogVAR world.prefidx, world.state
- elseif has_key(world.key_map[world.key_mode], 'unknown_key')
- let agent = world.key_map[world.key_mode].unknown_key.agent
- " let world = call(agent, [world, c])
- " call s:CheckAgentReturnValue(agent, world)
- let world = s:CallAgent({'agent': agent}, world, c)
- elseif c >= 32
- let world.state = 'display'
- let numbase = get(world.numeric_chars, c, -99999)
- " TLogVAR numbase, world.numeric_chars, c
- if numbase != -99999
- let world.idx .= (c - numbase)
- if len(world.idx) == world.index_width
- let world.prefidx = world.idx
- " TLogVAR world.prefidx
- throw 'pick'
- endif
- else
- let world.idx = ''
- " TLogVAR world.filter
- if world.llen > g:tlib#input#livesearch_threshold
- let pattern = input('Filter: ', world.CleanFilter(world.filter[0][0]) . nr2char(c))
- if empty(pattern)
- let world.state = 'exit empty'
- else
- call world.SetFrontFilter(pattern)
- echo
- endif
- elseif c == 124
- call insert(world.filter[0], [])
- else
- call world.PushFrontFilter(c)
- endif
- " continue
- if c == 45 && world.filter[0][0] == '-'
- let world.state = 'redisplay'
- end
- endif
- else
- let world.state = 'redisplay'
- " let world.state = 'continue'
- endif
-
- catch /^picked$/
- call world.ClearAllMarks()
- call world.MarkCurrent(world.prefidx)
- let world.state = 'exit'
-
- catch /^pick$/
- call world.ClearAllMarks()
- call world.MarkCurrent(world.prefidx)
- let world.state = ''
- " TLogDBG 'Pick item #'. world.prefidx
-
- finally
- " TLogDBG 'finally 1', world.state
- if world.state =~ '\<suspend\>'
- " if !world.allow_suspend
- " echom "Cannot be suspended"
- " let world.state = 'redisplay'
- " endif
- elseif !empty(world.list) && !empty(world.base)
- " TLogVAR world.list
- if empty(world.state)
- let world.rv = world.CurrentItem()
- " TLogVAR world.state, world.rv
- endif
- " TLogVAR "postprocess"
- for handler in world.post_handlers
- let state = get(handler, 'postprocess', '')
- " TLogVAR handler
- " TLogVAR state
- " TLogVAR world.state
- if state == world.state
- let agent = handler.agent
- let [world, world.rv] = call(agent, [world, world.rv])
- " TLogVAR world.state, world.rv
- call s:CheckAgentReturnValue(agent, world)
- endif
- endfor
- endif
- " TLogDBG 'state0='. world.state
- endtry
- " TLogDBG 'state1='. world.state
- endwh
-
- " TLogVAR world.state
- " TLogDBG string(tlib#win#List())
- " TLogDBG 'exit while loop'
- " TLogVAR world.list
- " TLogVAR world.sel_idx
- " TLogVAR world.idx
- " TLogVAR world.prefidx
- " TLogVAR world.rv
- " TLogVAR world.type, world.state, world.return_agent, world.index_table, world.rv
- if world.state =~ '\<\(empty\|escape\)\>'
- let world.sticky = 0
- endif
- if world.state =~ '\<suspend\>'
- " TLogDBG 'return suspended'
- " TLogVAR world.prefidx
- " exec world.prefidx
- return
- elseif world.state =~ '\<empty\>'
- " TLog "empty"
- " TLogDBG 'return empty'
- " TLogVAR world.type
- if stridx(world.type, 'm') != -1
- return []
- elseif stridx(world.type, 'i') != -1
- return 0
- else
- return ''
- endif
- elseif !empty(world.return_agent)
- " TLogDBG 'return agent'
- " TLogVAR world.return_agent
- call world.CloseScratch()
- " TLogDBG "return_agent ". string(tlib#win#List())
- " TAssert IsNotEmpty(world.scratch)
- return call(world.return_agent, [world, world.GetSelectedItems(world.rv)])
- elseif stridx(world.type, 'w') != -1
- " TLog "return_world"
- " TLogDBG 'return world'
- return world
- elseif stridx(world.type, 'm') != -1
- " TLog "return_multi"
- " TLogDBG 'return multi'
- return world.GetSelectedItems(world.rv)
- elseif stridx(world.type, 'i') != -1
- " TLog "return_index"
- " TLogDBG 'return index'
- if empty(world.index_table)
- return world.rv
- else
- return world.index_table[world.rv - 1]
- endif
- else
- " TLog "return_else"
- " TLogDBG 'return normal'
- return world.rv
- endif
-
- finally
- call world.Leave()
-
- " TLogVAR statusline
- " let &l:statusline = statusline
- " let &laststatus = laststatus
- if &showmode != showmode
- let &showmode = showmode
- endif
- silent! let @/ = lastsearch
- let &l:scrolloff = scrolloff
- if s:PopupmenuExists() == 1
- silent! aunmenu ]TLibInputListPopupMenu
- endif
-
- " TLogDBG 'finally 2'
- " TLogDBG string(world.Methods())
- " TLogVAR world.state
- " TLogDBG string(tlib#win#List())
- if world.state !~ '\<suspend\>'
- " redraw
- " TLogVAR world.sticky, bufnr("%")
- if world.sticky
- " TLogDBG "sticky"
- " TLogVAR world.bufnr
- " TLogDBG bufwinnr(world.bufnr)
- if world.scratch_split > 0
- if bufwinnr(world.bufnr) == -1
- " TLogDBG "UseScratch"
- call world.UseScratch()
- endif
- let world = tlib#agent#SuspendToParentWindow(world, world.GetSelectedItems(world.rv))
- endif
- else
- " TLogDBG "non sticky"
- " TLogVAR world.state, world.win_wnr, world.bufnr
- if world.CloseScratch()
- " TLogVAR world.winview
- call tlib#win#SetLayout(world.winview)
- endif
- endif
- endif
- " for i in range(0,5)
- " call getchar(0)
- " endfor
- echo
- redraw!
- if !empty(post_keys)
- " TLogVAR post_keys
- call feedkeys(post_keys)
- endif
- endtry
-endf
-
-
-function! s:CallAgent(handler, world, list) abort "{{{3
- let agent = a:handler.agent
- let args = [a:world, a:list]
- if has_key(a:handler, 'args')
- let args += a:handler.args
- endif
- let world = call(agent, args)
- " TLogVAR world.state, world.rv
- call s:CheckAgentReturnValue(agent, world)
- return world
-endf
-
-function! s:GetModdedChar(world) "{{{3
- let [char, mode] = tlib#char#Get(a:world.timeout, a:world.timeout_resolution, 1)
- if char !~ '\D' && char > 0 && mode != 0
- return printf("<%s-%s>", mode, char)
- else
- return char
- endif
-endf
-
-
-function! s:Init(world, cmd) "{{{3
- " TLogVAR a:cmd
- let a:world.initial_display = 1
- if a:cmd =~ '\<sticky\>'
- let a:world.sticky = 1
- endif
- if a:cmd =~ '^resume'
- call a:world.UseInputListScratch()
- let a:world.initial_index = line('.')
- if a:cmd =~ '\<pick\>'
- let a:world.state = 'pick'
- let a:world.prefidx = a:world.initial_index
- else
- call a:world.Retrieve(1)
- endif
- " if !empty(a:world.resume_state)
- " let a:world.state = a:world.resume_state
- " endif
- elseif !a:world.initialized
- " TLogVAR a:world.initialized, a:world.win_wnr, a:world.bufnr
- let a:world.filetype = &filetype
- let a:world.fileencoding = &fileencoding
- call a:world.SetMatchMode(tlib#var#Get('tlib#input#filter_mode', 'wb'))
- call a:world.Initialize()
- if !has_key(a:world, 'key_mode')
- let a:world.key_mode = 'default'
- endif
- " TLogVAR has_key(a:world,'key_map')
- if has_key(a:world, 'key_map')
- " TLogVAR has_key(a:world.key_map,a:world.key_mode)
- if has_key(a:world.key_map, a:world.key_mode)
- let a:world.key_map[a:world.key_mode] = extend(
- \ a:world.key_map[a:world.key_mode],
- \ copy(g:tlib#input#keyagents_InputList_s),
- \ 'keep')
- else
- let a:world.key_map[a:world.key_mode] = copy(g:tlib#input#keyagents_InputList_s)
- endif
- else
- let a:world.key_map = {
- \ a:world.key_mode : copy(g:tlib#input#keyagents_InputList_s)
- \ }
- endif
- " TLogVAR a:world.type
- if stridx(a:world.type, 'm') != -1
- call extend(a:world.key_map[a:world.key_mode], g:tlib#input#keyagents_InputList_m, 'force')
- endif
- for key_mode in keys(a:world.key_map)
- let a:world.key_map[key_mode] = map(a:world.key_map[key_mode], 'type(v:val) == 4 ? v:val : {"agent": v:val}')
- endfor
- " TLogVAR a:world.key_mode
- if type(a:world.key_handlers) == 3
- call s:ExtendKeyMap(a:world, a:world.key_mode, a:world.key_handlers)
- elseif type(a:world.key_handlers) == 4
- for [world_key_mode, world_key_handlers] in items(a:world.key_handlers)
- call s:ExtendKeyMap(a:world, world_key_mode, world_key_handlers)
- endfor
- else
- throw "tlib#input#ListW: key_handlers must be either a list or a dictionary"
- endif
- " TLogVAR a:world.type, a:world.key_map
- if !empty(a:cmd)
- let a:world.state .= ' '. a:cmd
- endif
- endif
- " TLogVAR a:world.state, a:world.sticky
-endf
-
-
-function! s:ExtendKeyMap(world, key_mode, key_handlers) "{{{3
- for handler in a:key_handlers
- let k = get(handler, 'key', '')
- if !empty(k)
- let a:world.key_map[a:key_mode][k] = handler
- endif
- endfor
-endf
-
-
-function! s:PopupmenuExists()
- if !g:tlib#input#use_popup
- \ || exists(':popup') != 2
- \ || !(has('gui_win32') || has('gui_gtk') || has('gui_gtk2'))
- " \ || !has('gui_win32')
- let rv = -1
- else
- try
- let rv = 1
- silent amenu ]TLibInputListPopupMenu
- catch
- let rv = 0
- endtry
- endif
- " TLogVAR rv
- return rv
-endf
-
-
-function! s:BuildMenu(world) "{{{3
- if g:tlib#input#use_popup && s:PopupmenuExists() == 0
- call s:BuildItem('Pick\ selected\ item', {'key_name': '<cr>', 'eval': 'let world.state = "pick"'})
- call s:BuildItem('Cancel', {'key_name': '<esc>', 'agent': 'tlib#agent#Exit'})
- call s:BuildItem('Select', {'key_name': '#', 'agent': 'tlib#agent#Select'})
- call s:BuildItem('Select\ all', {'key_name': '<c-a>', 'agent': 'tlib#agent#SelectAll'})
- call s:BuildItem('Reset\ list', {'key_name': '<c-r>', 'agent': 'tlib#agent#Reset'})
- call s:BuildItem('-StandardEntries-', {'key': ":", 'eval': 'let world.state = "redisplay"'})
- for [key_mode, key_handlers] in items(a:world.key_map)
- let keys = sort(keys(key_handlers))
- let mitems = {}
- for key in keys
- let handler = key_handlers[key]
- let k = get(handler, 'key', '')
- if !empty(k) && has_key(handler, 'help') && !empty(handler.help)
- if empty(key_mode) || key_mode == 'default'
- let mname = ''
- else
- let mname = escape(key_mode, ' .\') .'.'
- endif
- if has_key(handler, 'submenu')
- let submenu = escape(handler.submenu, ' .\')
- else
- let submenu = '~'
- endif
- for mfield in ['menu', 'help', 'key_name', 'agent']
- if has_key(handler, mfield)
- let mname .= escape(handler[mfield], ' .\')
- break
- endif
- endfor
- if !has_key(mitems, submenu)
- let mitems[submenu] = {}
- endif
- let mitems[submenu][mname] = handler
- endif
- endfor
- for msubname in sort(keys(mitems))
- let msubitems = mitems[msubname]
- if msubname == '~'
- let msubmname = ''
- else
- let msubmname = msubname .'.'
- endif
- for mname in sort(keys(msubitems))
- let msname = msubmname . mname
- let handler = msubitems[mname]
- call s:BuildItem(msname, handler)
- " if has_key(handler, 'agent')
- " call s:BuildItem(msname, {'agent': handler.agent})
- " else
- " call s:BuildItem(msname, {'key': handler.key_name})
- " endif
- endfor
- endfor
- endfor
- endif
-endf
-
-
-function! s:BuildItem(menu, def) "{{{3
- if has('gui_win32')
- let key_mode = 'c'
- elseif has('gui_gtk') || has('gui_gtk2')
- let key_mode = 'raw'
- endif
- for k in ['agent', 'eval', 'key_name', 'key']
- if has('gui_win32')
- elseif has('gui_gtk') || has('gui_gtk')
- if k == 'agent' || k == 'eval'
- continue
- endif
- endif
- try
- if has_key(a:def, k)
- let v = a:def[k]
- if k == 'key'
- if key_mode == 'c'
- " echom 'DBG amenu' (']TLibInputListPopupMenu.'. a:menu) ':let c = "'. v .'"<cr>'
- exec 'amenu' (']TLibInputListPopupMenu.'. a:menu) ':let c = "'. v .'"<cr>'
- else
- " echom 'DBG amenu' (']TLibInputListPopupMenu.'. a:menu) v
- exec 'amenu' (']TLibInputListPopupMenu.'. a:menu) v
- endif
- elseif k == 'key_name'
- if key_mode == 'c'
- " echom 'DBG amenu' (']TLibInputListPopupMenu.'. a:menu) ':let c = "\'. v .'"<cr>'
- exec 'amenu' (']TLibInputListPopupMenu.'. a:menu) ':let c = "\'. v .'"<cr>'
- else
- let key = v
- " echom 'DBG amenu' (']TLibInputListPopupMenu.'. a:menu) key
- exec 'amenu' (']TLibInputListPopupMenu.'. a:menu) key
- endif
- elseif k == 'agent'
- " echom 'DBG amenu' (']TLibInputListPopupMenu.'. a:menu) ':let world.next_agent ='. string(v) .'<cr>'
- exec 'amenu' (']TLibInputListPopupMenu.'. a:menu) ':let world.next_agent ='. string(v) .'<cr>'
- elseif k == 'eval'
- " echom 'DBG amenu' (']TLibInputListPopupMenu.'. a:menu) ':let world.next_eval ='. string(v) .'<cr>'
- exec 'amenu' (']TLibInputListPopupMenu.'. a:menu) ':let world.next_eval ='. string(v) .'<cr>'
- endif
- return
- endif
- catch
- endtry
- endfor
-endf
-
-
-function! s:RunStateHandlers(world) "{{{3
- " Provide the variable "world" in the environment of an "exec"
- " handler (ea).
- let world = a:world
- for handler in a:world.state_handlers
- let eh = get(handler, 'state', '')
- if !empty(eh) && a:world.state =~ eh
- let ea = get(handler, 'exec', '')
- if !empty(ea)
- exec ea
- else
- let agent = get(handler, 'agent', '')
- " let world = call(agent, [a:world, a:world.GetSelectedItems(a:world.CurrentItem())])
- " call s:CheckAgentReturnValue(agent, a:world)
- let world = s:CallAgent({'agent': agent}, world, world.GetSelectedItems(world.CurrentItem()))
- endif
- endif
- endfor
- return world
-endf
-
-
-function! s:CheckAgentReturnValue(name, value) "{{{3
- if type(a:value) != 4 && !has_key(a:value, 'state')
- echoerr 'Malformed agent: '. a:name
- endif
- return a:value
-endf
-
-
-function! s:SetOffset(world) "{{{3
- let llenw = len(a:world.base) - winheight(0) + 1
- if a:world.offset > llenw
- let a:world.offset = llenw
- endif
- if a:world.offset < 1
- let a:world.offset = 1
- endif
-endf
-
-
-" Functions related to tlib#input#EditList(type, ...) "{{{2
-
-" :def: function! tlib#input#EditList(query, list, ?timeout=0)
-" Edit a list.
-"
-" EXAMPLES: >
-" echo tlib#input#EditList('Edit:', [100,200,300])
-function! tlib#input#EditList(query, list, ...) "{{{3
- let handlers = a:0 >= 1 && !empty(a:1) ? a:1 : g:tlib#input#handlers_EditList
- let default = a:0 >= 2 ? a:2 : []
- let timeout = a:0 >= 3 ? a:3 : 0
- " TLogVAR handlers
- let rv = tlib#input#List('me', a:query, copy(a:list), handlers, default, timeout)
- " TLogVAR rv
- if empty(rv)
- return a:list
- else
- let [success, list] = rv
- return success ? list : a:list
- endif
-endf
-
-
-function! tlib#input#Resume(name, pick, bufnr) "{{{3
- " TLogVAR a:name, a:pick
- echo
- if bufnr('%') != a:bufnr
- if g:tlib#debug
- echohl WarningMsg
- echom "tlib#input#Resume: Internal error: Not in scratch buffer:" bufname('%')
- echohl NONE
- endif
- let br = tlib#buffer#Set(a:bufnr)
- endif
- if !exists('b:tlib_'. a:name)
- if g:tlib#debug
- echohl WarningMsg
- echom "tlib#input#Resume: Internal error: b:tlib_". a:name ." does not exist:" bufname('%')
- echohl NONE
- redir => varss
- silent let b:
- redir END
- let vars = split(varss, '\n')
- call filter(vars, 'v:val =~ "^b:tlib_"')
- echom "DEBUG tlib#input#Resume" string(vars)
- endif
- else
- call tlib#autocmdgroup#Init()
- autocmd! TLib BufEnter <buffer>
- if b:tlib_{a:name}.state =~ '\<suspend\>'
- let b:tlib_{a:name}.state = 'redisplay'
- else
- let b:tlib_{a:name}.state .= ' redisplay'
- endif
- " call tlib#input#List('resume '. a:name)
- let cmd = 'resume '. a:name
- if a:pick >= 1
- let cmd .= ' pick'
- if a:pick >= 2
- let cmd .= ' sticky'
- end
- endif
- call tlib#input#ListW(b:tlib_{a:name}, cmd)
- endif
-endf
-
-
-" :def: function! tlib#input#CommandSelect(command, ?keyargs={})
-" Take a command, view the output, and let the user select an item from
-" its output.
-"
-" EXAMPLE: >
-" command! TMarks exec 'norm! `'. matchstr(tlib#input#CommandSelect('marks'), '^ \+\zs.')
-" command! TAbbrevs exec 'norm i'. matchstr(tlib#input#CommandSelect('abbrev'), '^\S\+\s\+\zs\S\+')
-function! tlib#input#CommandSelect(command, ...) "{{{3
- TVarArg ['args', {}]
- if has_key(args, 'retrieve')
- let list = call(args.retrieve)
- elseif has_key(args, 'list')
- let list = args.list
- else
- let list = tlib#cmd#OutputAsList(a:command)
- endif
- if has_key(args, 'filter')
- call map(list, args.filter)
- endif
- let type = has_key(args, 'type') ? args.type : 's'
- let handlers = has_key(args, 'handlers') ? args.handlers : []
- let rv = tlib#input#List(type, 'Select', list, handlers)
- if !empty(rv)
- if has_key(args, 'process')
- let rv = call(args.process, [rv])
- endif
- endif
- return rv
-endf
-
-
-" :def: function! tlib#input#Edit(name, value, callback, ?cb_args=[])
-"
-" Edit a value (asynchronously) in a scratch buffer. Use name for
-" identification. Call callback when done (or on cancel).
-" In the scratch buffer:
-" Press <c-s> or <c-w><cr> to enter the new value, <c-w>c to cancel
-" editing.
-" EXAMPLES: >
-" fun! FooContinue(success, text)
-" if a:success
-" let b:var = a:text
-" endif
-" endf
-" call tlib#input#Edit('foo', b:var, 'FooContinue')
-function! tlib#input#Edit(name, value, callback, ...) "{{{3
- " TLogVAR a:value
- TVarArg ['args', []]
- let sargs = {'scratch': '__EDIT__'. a:name .'__', 'win_wnr': winnr()}
- let scr = tlib#scratch#UseScratch(sargs)
-
- " :nodoc:
- map <buffer> <c-w>c :call <SID>EditCallback(0)<cr>
- " :nodoc:
- imap <buffer> <c-w>c <c-o>call <SID>EditCallback(0)<cr>
- " :nodoc:
- map <buffer> <c-s> :call <SID>EditCallback(1)<cr>
- " :nodoc:
- imap <buffer> <c-s> <c-o>call <SID>EditCallback(1)<cr>
- " :nodoc:
- map <buffer> <c-w><cr> :call <SID>EditCallback(1)<cr>
- " :nodoc:
- imap <buffer> <c-w><cr> <c-o>call <SID>EditCallback(1)<cr>
-
- call tlib#normal#WithRegister('gg"tdG', 't')
- call append(1, split(a:value, "\<c-j>", 1))
- " let hrm = 'DON''T DELETE THIS HEADER'
- " let hr3 = repeat('"', (tlib#win#Width(0) - len(hrm)) / 2)
- let s:horizontal_line = repeat('`', tlib#win#Width(0))
- " hr3.hrm.hr3
- let hd = ['Keys: <c-s>, <c-w><cr> ... save/accept; <c-w>c ... cancel', s:horizontal_line]
- call append(1, hd)
- call tlib#normal#WithRegister('gg"tdd', 't')
- syntax match TlibEditComment /^\%1l.*/
- syntax match TlibEditComment /^```.*/
- hi link TlibEditComment Comment
- exec len(hd) + 1
- if type(a:callback) == 4
- let b:tlib_scratch_edit_callback = get(a:callback, 'submit', '')
- call call(get(a:callback, 'init', ''), [])
- else
- let b:tlib_scratch_edit_callback = a:callback
- endif
- let b:tlib_scratch_edit_args = args
- let b:tlib_scratch_edit_scratch = sargs
- " exec 'autocmd BufDelete,BufHidden,BufUnload <buffer> call s:EditCallback('. string(a:name) .')'
- " echohl MoreMsg
- " echom 'Press <c-s> to enter, <c-w>c to cancel editing.'
- " echohl NONE
-endf
-
-
-function! s:EditCallback(...) "{{{3
- TVarArg ['ok', -1]
- " , ['bufnr', -1]
- " autocmd! BufDelete,BufHidden,BufUnload <buffer>
- if ok == -1
- let ok = confirm('Use value')
- endif
- let start = getline(2) == s:horizontal_line ? 3 : 1
- let text = ok ? join(getline(start, '$'), "\n") : ''
- let cb = b:tlib_scratch_edit_callback
- let args = b:tlib_scratch_edit_args
- let sargs = b:tlib_scratch_edit_scratch
- " TLogVAR cb, args, sargs
- call tlib#scratch#CloseScratch(b:tlib_scratch_edit_scratch)
- call tlib#win#Set(sargs.win_wnr)
- call call(cb, args + [ok, text])
-endf
-
-
-function! tlib#input#Dialog(text, options, default) "{{{3
- if has('dialog_con') || has('dialog_gui')
- let opts = join(map(a:options, '"&". v:val'), "\n")
- let val = confirm(a:text, opts)
- if val
- let yn = a:options[val - 1]
- else
- let yn = a:default
- endif
- else
- let oi = index(a:options, a:default)
- if oi == -1
- let opts = printf("(%s|%s)", join(a:options, '/'), a:default)
- else
- let options = copy(a:options)
- let options[oi] = toupper(options[oi])
- let opts = printf("(%s)", join(a:options, '/'))
- endif
- let yn = inputdialog(a:text .' '. opts)
- endif
- return yn
-endf
-
diff --git a/vim/bundle/tlib_vim/autoload/tlib/list.vim b/vim/bundle/tlib_vim/autoload/tlib/list.vim
deleted file mode 100755
index a18f27f..0000000
--- a/vim/bundle/tlib_vim/autoload/tlib/list.vim
+++ /dev/null
@@ -1,194 +0,0 @@
-" list.vim
-" @Author: Tom Link (micathom AT gmail com?subject=[vim])
-" @Website: http://www.vim.org/account/profile.php?user_id=4037
-" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
-" @Created: 2007-06-30.
-" @Last Change: 2016-03-22.
-" @Revision: 68
-
-
-""" 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
- " TLogVAR a:list
- TVarArg ['get_value', ''], ['remove_empty', 0]
- if remove_empty
- call filter(a:list, 'type(v:val) == 0 || !empty(v:val)')
- endif
- " CREDITS: Based on syntastic#util#unique(list) by scrooloose
- let emptystring = 0
- let seen = {}
- let uniques = []
- if empty(get_value)
- for e in a:list
- if e == ''
- if !emptystring
- let emptystring = 1
- call add(uniques, e)
- endif
- elseif !has_key(seen, e)
- let seen[e] = 1
- call add(uniques, e)
- endif
- unlet e
- endfor
- else
- for e in a:list
- let v = eval(printf(get_value, string(e)))
- if v == ''
- if !emptystring
- let emptystring = 1
- call add(uniques, v)
- endif
- elseif !has_key(seen, v)
- let seen[v] = 1
- call add(uniques, v)
- endif
- unlet e v
- endfor
- endif
- return uniques
-endf
-
-
-function! tlib#list#ToDictionary(list, default, ...) "{{{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
-
diff --git a/vim/bundle/tlib_vim/autoload/tlib/loclist.vim b/vim/bundle/tlib_vim/autoload/tlib/loclist.vim
deleted file mode 100644
index 198dd1b..0000000
--- a/vim/bundle/tlib_vim/autoload/tlib/loclist.vim
+++ /dev/null
@@ -1,13 +0,0 @@
-" @Author: Tom Link (mailto:micathom AT gmail com?subject=[vim])
-" @Website: http://www.vim.org/account/profile.php?user_id=4037
-" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
-" @Last Change: 2015-10-24
-" @Revision: 2
-
-
-function! tlib#loclist#Browse(...) abort "{{{3
- let list = getloclist(0)
- return call(function('tlib#qfl#QflList'), [list] + a:000)
-endf
-
-
diff --git a/vim/bundle/tlib_vim/autoload/tlib/map.vim b/vim/bundle/tlib_vim/autoload/tlib/map.vim
deleted file mode 100755
index c1af13f..0000000
--- a/vim/bundle/tlib_vim/autoload/tlib/map.vim
+++ /dev/null
@@ -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
diff --git a/vim/bundle/tlib_vim/autoload/tlib/normal.vim b/vim/bundle/tlib_vim/autoload/tlib/normal.vim
deleted file mode 100755
index faaa444..0000000
--- a/vim/bundle/tlib_vim/autoload/tlib/normal.vim
+++ /dev/null
@@ -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
diff --git a/vim/bundle/tlib_vim/autoload/tlib/notify.vim b/vim/bundle/tlib_vim/autoload/tlib/notify.vim
deleted file mode 100755
index 541dbd0..0000000
--- a/vim/bundle/tlib_vim/autoload/tlib/notify.vim
+++ /dev/null
@@ -1,113 +0,0 @@
-" notify.vim
-" @Author: Tom Link (mailto:micathom AT gmail com?subject=[vim])
-" @Website: http://www.vim.org/account/profile.php?user_id=4037
-" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
-" @Created: 2008-09-19.
-" @Last Change: 2016-06-28.
-" @Revision: 2.3.19
-
-let s:save_cpo = &cpo
-set cpo&vim
-
-
-" :display: tlib#notify#Echo(text, ?style='')
-" Print text in the echo area. Temporarily disable 'ruler' and 'showcmd'
-" in order to prevent |press-enter| messages.
-function! tlib#notify#Echo(text, ...)
- TVarArg 'style'
- let ruler = &ruler
- let showcmd = &showcmd
- let text = substitute(a:text, '\n', '|', 'g')
- try
- set noruler
- set noshowcmd
- if !empty(style)
- exec 'echohl' style
- endif
- echo strpart(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
-
-
-function! tlib#notify#PrintError() abort "{{{3
- echohl ErrorMsg
- echom v:exception
- echom v:throwpoint
- echohl NONE
-endf
-
-
-let &cpo = s:save_cpo
-unlet s:save_cpo
diff --git a/vim/bundle/tlib_vim/autoload/tlib/number.vim b/vim/bundle/tlib_vim/autoload/tlib/number.vim
deleted file mode 100644
index 94fde02..0000000
--- a/vim/bundle/tlib_vim/autoload/tlib/number.vim
+++ /dev/null
@@ -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
-
-
diff --git a/vim/bundle/tlib_vim/autoload/tlib/paragraph.vim b/vim/bundle/tlib_vim/autoload/tlib/paragraph.vim
deleted file mode 100755
index dd0d112..0000000
--- a/vim/bundle/tlib_vim/autoload/tlib/paragraph.vim
+++ /dev/null
@@ -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
diff --git a/vim/bundle/tlib_vim/autoload/tlib/persistent.vim b/vim/bundle/tlib_vim/autoload/tlib/persistent.vim
deleted file mode 100644
index de3d487..0000000
--- a/vim/bundle/tlib_vim/autoload/tlib/persistent.vim
+++ /dev/null
@@ -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
-
diff --git a/vim/bundle/tlib_vim/autoload/tlib/progressbar.vim b/vim/bundle/tlib_vim/autoload/tlib/progressbar.vim
deleted file mode 100755
index e739eb3..0000000
--- a/vim/bundle/tlib_vim/autoload/tlib/progressbar.vim
+++ /dev/null
@@ -1,72 +0,0 @@
-" @Author: Tom Link (mailto:micathom AT gmail com?subject=[vim])
-" @Website: http://www.vim.org/account/profile.php?user_id=4037
-" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
-" @Revision: 72
-
-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', ['always', 0]
- let ts = localtime()
- if !always && ts == s:timestamp
- return
- else
- let s:timestamp = ts
- endif
- let val = a:value * s:width[0] / s:max[0]
- if always || val != s:value[0]
- let s:value[0] = val
- let pbl = repeat('#', val)
- let pbr = repeat('.', s:width[0] - val)
- let txt = printf(s:format[0], '['.pbl.pbr.']') . extra
- let &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
-
-
diff --git a/vim/bundle/tlib_vim/autoload/tlib/qfl.vim b/vim/bundle/tlib_vim/autoload/tlib/qfl.vim
deleted file mode 100644
index 148620a..0000000
--- a/vim/bundle/tlib_vim/autoload/tlib/qfl.vim
+++ /dev/null
@@ -1,312 +0,0 @@
-" @Author: Tom Link (mailto:micathom AT gmail com?subject=[vim])
-" @Website: https://github.com/tomtom
-" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
-" @Last Change: 2015-12-06
-" @Revision: 60
-
-" :nodoc:
-TLet g:tlib#qfl#world = {
- \ 'type': 'mi',
- \ 'query': 'Select entry',
- \ 'pick_last_item': 0,
- \ 'resize_vertical': 0,
- \ 'resize': 20,
- \ 'scratch': '__TLibQFL__',
- \ 'tlib_UseInputListScratch': 'call tlib#qfl#InitListBuffer(world)',
- \ 'key_handlers': [
- \ {'key': 5, 'agent': 'tlib#qfl#AgentWithSelected', 'key_name': '<c-e>', 'help': 'Run a command on selected lines'},
- \ {'key': 16, 'agent': 'tlib#qfl#AgentPreviewQFE', 'key_name': '<c-p>', 'help': 'Preview'},
- \ {'key': 60, 'agent': 'tlib#qfl#AgentGotoQFE', 'key_name': '<', 'help': 'Jump (don''t close the list)'},
- \ {'key': 19, 'agent': 'tlib#qfl#AgentSplitBuffer', 'key_name': '<c-s>', 'help': 'Show in split buffer'},
- \ {'key': 20, 'agent': 'tlib#qfl#AgentTabBuffer', 'key_name': '<c-t>', 'help': 'Show in tab'},
- \ {'key': 22, 'agent': 'tlib#qfl#AgentVSplitBuffer', 'key_name': '<c-v>', 'help': 'Show in vsplit buffer'},
- \ {'key': 12, 'agent': 'tlib#qfl#AgentEditLine', 'key_name': '<c-l>', 'help': 'Edit selected line(s)'},
- \ {'key': "\<c-insert>", 'agent': 'tlib#qfl#SetFollowCursor', 'key_name': '<c-ins>', 'help': 'Toggle trace cursor'},
- \ ],
- \ 'return_agent': 'tlib#qfl#AgentEditQFE',
- \ }
-
-
-function! tlib#qfl#FormatQFLE(qfe) dict abort "{{{3
- let filename = tlib#qfl#QfeFilename(a:qfe)
- if get(self, 'qfl_short_filename', '')
- let filename = pathshorten(filename)
- endif
- return printf("%s|%d| %s", filename, a:qfe.lnum, get(a:qfe, "text"))
-endf
-
-
-function! tlib#qfl#QfeFilename(qfe) abort "{{{3
- let filename = get(a:qfe, 'filename')
- if empty(filename)
- let filename = bufname(get(a:qfe, 'bufnr'))
- endif
- return filename
-endf
-
-
-function! tlib#qfl#InitListBuffer(world) "{{{3
- let set_syntax = get(a:world, 'set_syntax', 'tlib#qfl#SetSyntax')
- call call(set_syntax, [], a:world)
- if has('balloon_eval')
- setlocal ballooneval balloonexpr=tlib#qfl#Balloon()
- endif
-endf
-
-
-function! tlib#qfl#SetSyntax() dict abort "{{{3
- let syntax = get(self, 'qfl_list_syntax', '')
- let nextgroup = get(self, 'qfl_list_syntax_nextgroup', '')
- " TLogVAR syntax, nextgroup
- if !empty(syntax)
- exec printf('runtime syntax/%s.vim', syntax)
- endif
- syn match TTagedFilesFilename /\%(\f\+\| \)\+\ze|\d\+| / nextgroup=TTagedFilesLNum
- if !empty(nextgroup)
- exec 'syn match TTagedFilesLNum /|\d\+|\s\+/ nextgroup='. nextgroup
- else
- syn match TTagedFilesLNum /|\d\+|/
- endif
- hi def link TTagedFilesFilename Directory
- hi def link TTagedFilesLNum LineNr
-endf
-
-
-function! tlib#qfl#Balloon() "{{{3
- let world = getbufvar(v:beval_bufnr, 'tlibDisplayListWorld')
- let current = max([1, world.offset]) + v:beval_lnum - 1
- if current > len(world.table)
- let current = len(world.table)
- endif
- let baseidx = world.GetBaseIdx0(current)
- " TLogVAR world.offset, v:beval_lnum, current, baseidx
- let item = world.data[baseidx]
- let bufnr = get(item, 'bufnr', 0)
- let bufname = get(item, 'filename', '')
- if bufnr == 0 && !empty(bufname)
- let bufnr = bufnr(bufname)
- endif
- if empty(bufname) && bufnr > 0
- let bufname = bufname(bufnr)
- endif
- " TLogVAR item
- if bufnr == 0
- return ''
- else
- let lines = [printf("%d#%d: %s", bufnr, item.lnum, bufname)]
- if has('balloon_multiline')
- let desc = {'nr': 'Error number', 'type': 'Error type', 'text': ''}
- for key in ['nr', 'type', 'text']
- if has_key(item, key) && !empty(item[key])
- let keydesc = get(desc, key, key)
- if empty(keydesc)
- let text = item[key]
- else
- let text = printf("%s: %s", key, item[key])
- endif
- call add(lines, text)
- endif
- endfor
- endif
- return join(lines, "\n")
- endif
- " v:beval_bufnr number of the buffer in which balloon is going to show
- " v:beval_winnr number of the window
- " v:beval_lnum line number
- " v:beval_col column number (byte index)
- " v:beval_text word under or after the mouse pointer
-endf
-
-
-function! tlib#qfl#AgentEditQFE(world, selected, ...) "{{{3
- TVarArg ['cmd_edit', ''], ['cmd_buffer', '']
- " TVarArg ['cmd_edit', 'edit'], ['cmd_buffer', 'buffer']
- " TLogVAR a:selected
- if empty(a:selected)
- call a:world.RestoreOrigin()
- " call a:world.ResetSelected()
- else
- call a:world.RestoreOrigin()
- for idx in a:selected
- let idx -= 1
- " TLogVAR idx
- if idx >= 0
- " TLogVAR a:world.data
- " call tlog#Debug(string(map(copy(a:world.data), 'v:val.bufnr')))
- " TLogVAR idx, a:world.data[idx]
- let qfe = a:world.data[idx]
- " let back = a:world.SwitchWindow('win')
- " TLogVAR cmd_edit, cmd_buffer, qfe
- let fn = tlib#qfl#QfeFilename(qfe)
- " TLogVAR cmd_edit, cmd_buffer, fn
- if empty(cmd_edit) && empty(cmd_buffer)
- if tlib#file#Edit(fn)
- call tlib#buffer#ViewLine(qfe.lnum)
- endif
- else
- call tlib#file#With(cmd_edit, cmd_buffer, [fn], a:world)
- " TLogDBG bufname('%')
- " TLogVAR &filetype
- call tlib#buffer#ViewLine(qfe.lnum)
- " call a:world.SetOrigin()
- " exec back
- endif
- endif
- endfor
- endif
- return a:world
-endf
-
-
-function! tlib#qfl#AgentPreviewQFE(world, selected) "{{{3
- " TLogVAR a:selected
- let back = a:world.SwitchWindow('win')
- call tlib#qfl#AgentEditQFE(a:world, a:selected[0:0])
- exec back
- redraw
- let a:world.state = 'redisplay'
- return a:world
-endf
-
-
-function! tlib#qfl#AgentGotoQFE(world, selected) "{{{3
- let world = a:world
- if !empty(a:selected)
- let world = tlib#agent#Suspend(world, a:selected)
- call tlib#qfl#AgentEditQFE(world, a:selected[0:0])
- endif
- return world
-endf
-
-
-function! tlib#qfl#AgentWithSelected(world, selected, ...) "{{{3
- let cmd = a:0 >= 1 ? a:1 : input('Ex command: ', '', 'command')
- let world = a:world
- if !empty(cmd)
- let world = tlib#qfl#RunCmdOnSelected(world, a:selected, cmd)
- else
- let world.state = 'redisplay'
- endif
- return world
-endf
-
-
-function! tlib#qfl#RunCmdOnSelected(world, selected, cmd, ...) "{{{3
- let close_scratch = a:0 >= 1 ? a:1 : 1
- if close_scratch
- call a:world.CloseScratch()
- endif
- " TLogVAR a:cmd
- for entry in a:selected
- " TLogVAR entry, a:world.GetBaseItem(entry)
- call tlib#qfl#AgentEditQFE(a:world, [entry])
- " TLogDBG bufname('%')
- exec a:cmd
- " let item = a:world.data[a:world.GetBaseIdx(entry - 1)]
- " <+TODO+>
- let item = a:world.data[entry - 1]
- " TLogVAR entry, item, getline('.')
- if has_key(a:world, 'GetBufferLines')
- let lines = a:world.GetBufferLines('.', '.')
- else
- let lines = getline('.', '.')
- endif
- let item['text'] = tlib#string#Strip(lines[0])
- endfor
- if has_key(a:world, 'AfterRunCmd')
- if bufnr('%') == a:world.bufnr
- call a:world.AfterRunCmd()
- else
- " <+TODO+> Run in other buffer
- endif
- endif
- " call s:FormatBase(a:world)
- call a:world.RestoreOrigin()
- let a:world.state = 'reset'
- return a:world
-endf
-
-
-function! tlib#qfl#AgentSplitBuffer(world, selected) "{{{3
- call a:world.CloseScratch()
- return tlib#qfl#AgentEditQFE(a:world, a:selected, 'split', 'sbuffer')
-endf
-
-
-function! tlib#qfl#AgentTabBuffer(world, selected) "{{{3
- call a:world.CloseScratch()
- return tlib#qfl#AgentEditQFE(a:world, a:selected, 'tabedit', 'tab sbuffer')
-endf
-
-
-function! tlib#qfl#AgentVSplitBuffer(world, selected) "{{{3
- call a:world.CloseScratch()
- return tlib#qfl#AgentEditQFE(a:world, a:selected, 'vertical split', 'vertical sbuffer')
-endf
-
-
-" function! tlib#qfl#AgentOpenBuffer(world, selected) "{{{3
-" endf
-
-
-function! tlib#qfl#AgentEditLine(world, selected) "{{{3
- call a:world.CloseScratch()
- let cmd = 'call tlib#qfl#EditLine(".")'
- return tlib#qfl#RunCmdOnSelected(a:world, a:selected, cmd)
- let a:world.state = 'reset'
- return a:world
-endf
-
-
-function! tlib#qfl#EditLine(lnum) "{{{3
- call inputsave()
- let line = input('', getline(a:lnum))
- call inputrestore()
- if !empty(line)
- call setline(line(a:lnum), line)
- endif
-endf
-
-
-function! tlib#qfl#SetFollowCursor(world, selected) "{{{3
- if empty(a:world.follow_cursor)
- let a:world.follow_cursor = 'tlib#qfl#AgentPreviewQFE'
- else
- let a:world.follow_cursor = ''
- endif
- let a:world.state = 'redisplay'
- return a:world
-endf
-
-
-function! tlib#qfl#QflList(list, ...) abort "{{{3
- TVarArg ['world_dict', {}], ['anyway', 0], ['suspended', 0]
- Tlibtrace 'tlib', world_dict, anyway, suspended
- " TLogVAR a:list, world_dict, anyway, suspended
- if !anyway && empty(a:list)
- return
- endif
- let world = copy(g:tlib#qfl#world)
- if !empty(world_dict)
- let world = tlib#eval#Extend(world, world_dict)
- endif
- " TLogVAR world
- let world = tlib#World#New(world)
- " echom "DBG world" string(sort(keys(world)))
- let world.data = copy(a:list)
- if !has_key(world, 'format_data')
- let world.format_data = 'tlib#qfl#FormatQFLE'
- endif
- " TLogVAR world
- " TLogVAR world.data
- " call s:FormatBase(world)
- " TLogVAR world.base
- return tlib#input#ListW(world, suspended ? 'hibernate' : '')
-endf
-
-
-function! tlib#qfl#Browse(...) abort "{{{3
- let list = getqflist()
- return call(function('tlib#qfl#QflList'), [list] + a:000)
-endf
-
diff --git a/vim/bundle/tlib_vim/autoload/tlib/rx.vim b/vim/bundle/tlib_vim/autoload/tlib/rx.vim
deleted file mode 100644
index 8389983..0000000
--- a/vim/bundle/tlib_vim/autoload/tlib/rx.vim
+++ /dev/null
@@ -1,60 +0,0 @@
-" @Author: Tom Link (micathom AT gmail com?subject=[vim])
-" @Website: http://www.vim.org/account/profile.php?user_id=4037
-" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
-" @Revision: 113
-
-
-" :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
-
-
-function! tlib#rx#LooksLikeRegexp(text) abort "{{{3
- return a:text =~ '[.?*+{}\[\]]'
-endf
-
diff --git a/vim/bundle/tlib_vim/autoload/tlib/scratch.vim b/vim/bundle/tlib_vim/autoload/tlib/scratch.vim
deleted file mode 100755
index c9df64d..0000000
--- a/vim/bundle/tlib_vim/autoload/tlib/scratch.vim
+++ /dev/null
@@ -1,136 +0,0 @@
-" @Author: Tom Link (micathom AT gmail com?subject=[vim])
-" @Website: http://www.vim.org/account/profile.php?user_id=4037
-" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
-" @Revision: 255
-
-
-" Scratch window position. By default the list window is opened on the
-" bottom. Set this variable to 'topleft' or '' to change this behaviour.
-" See |tlib#input#List()|.
-TLet g:tlib_scratch_pos = 'botright'
-
-" If you want the scratch buffer to be fully removed, you might want to
-" set this variable to 'wipe'.
-" See also https://github.com/tomtom/tlib_vim/pull/16
-TLet g:tlib#scratch#hidden = 'hide'
-
-
-" :def: function! tlib#scratch#UseScratch(?keyargs={})
-" Display a scratch buffer (a buffer with no file). See :TScratch for an
-" example.
-" Return the scratch buffer's number.
-" Values for keyargs:
-" scratch_split ... 1: split, 0: window, -1: tab
-function! tlib#scratch#UseScratch(...) "{{{3
- exec tlib#arg#Let([['keyargs', {}]])
- " TLogDBG string(keys(keyargs))
- let id = get(keyargs, 'scratch', '__Scratch__')
- " TLogVAR id, bufwinnr(id)
- " TLogVAR bufnr(id), bufname(id)
- " TLogVAR 1, winnr(), bufnr('%'), bufname("%")
- if bufwinnr(id) != -1
- " echom 'DBG noautocmd keepalt keepj' bufwinnr(id) 'wincmd w'
- exec 'noautocmd keepalt keepj' bufwinnr(id) 'wincmd w'
- " TLogVAR "reuse", bufnr("%"), bufname("%")
- else
- let winpos = ''
- let bn = bufnr(id)
- let wpos = get(keyargs, 'scratch_pos', g:tlib_scratch_pos)
- " TLogVAR keyargs.scratch_vertical
- if get(keyargs, 'scratch_vertical')
- let wpos .= ' vertical'
- let winpos = tlib#fixes#Winpos()
- endif
- " TLogVAR wpos
- let scratch_split = get(keyargs, 'scratch_split', 1)
- if bn != -1
- " TLogVAR bn
- let wn = bufwinnr(bn)
- if wn != -1
- " TLogVAR wn
- exec 'noautocmd keepalt keepj' (wn .'wincmd w')
- else
- if scratch_split == 1
- let cmd = wpos.' sbuffer!'
- elseif scratch_split == -1
- let cmd = wpos.' tab sbuffer!'
- else
- let cmd = 'buffer!'
- endif
- " TLogVAR cmd, bn
- silent exec 'noautocmd keepalt keepj' cmd bn
- endif
- else
- " TLogVAR id
- if scratch_split == 1
- let cmd = wpos.' split'
- elseif scratch_split == -1
- let cmd = wpos.' tab split'
- else
- let cmd = 'edit'
- endif
- " TLogVAR cmd, id
- silent exec 'noautocmd keepalt keepj' cmd escape(id, '%#\ ')
- " silent exec 'split '. id
- endif
- let ft = get(keyargs, 'scratch_filetype', '')
- " TLogVAR ft, winpos
- if !empty(winpos)
- exec winpos
- endif
- setlocal buftype=nofile
- let &l:bufhidden = get(keyargs, 'scratch_hidden', g:tlib#scratch#hidden)
- setlocal noswapfile
- setlocal nobuflisted
- setlocal foldmethod=manual
- setlocal foldcolumn=0
- setlocal nospell
- setlocal modifiable
- setlocal noreadonly
- " TLogVAR &ft, ft
- if !empty(ft)
- let &l:ft = ft
- endif
- endif
- let keyargs.scratch = bufnr('%')
- let keyargs.scratch_tabpagenr = tabpagenr()
- let keyargs.scratch_winnr = winnr()
- " TLogVAR 2, winnr(), bufnr('%'), bufname("%"), keyargs.scratch
- return keyargs.scratch
-endf
-
-
-" Close a scratch buffer as defined in keyargs (usually a World).
-" Return 1 if the scratch buffer is closed (or if it already was
-" closed).
-function! tlib#scratch#CloseScratch(keyargs, ...) "{{{3
- TVarArg ['reset_scratch', 1]
- let scratch = get(a:keyargs, 'scratch', '')
- " TLogVAR scratch, reset_scratch
- " TLogDBG string(tlib#win#List())
- if !empty(scratch) && winnr('$') > 1
- let wn = bufwinnr(scratch)
- " TLogVAR wn
- try
- if wn != -1
- " TLogDBG winnr()
- let wb = tlib#win#Set(wn)
- let winpos = tlib#fixes#Winpos()
- wincmd c
- if get(a:keyargs, 'scratch_vertical') && !empty(winpos)
- exec winpos
- endif
- " exec wb
- " redraw
- " TLogVAR winnr()
- endif
- return 1
- finally
- if reset_scratch
- let a:keyargs.scratch = ''
- endif
- endtry
- endif
- return 0
-endf
-
diff --git a/vim/bundle/tlib_vim/autoload/tlib/selection.vim b/vim/bundle/tlib_vim/autoload/tlib/selection.vim
deleted file mode 100644
index 4417157..0000000
--- a/vim/bundle/tlib_vim/autoload/tlib/selection.vim
+++ /dev/null
@@ -1,40 +0,0 @@
-" @Author: Tom Link (mailto:micathom AT gmail com?subject=[vim])
-" @Website: http://www.vim.org/account/profile.php?user_id=4037
-" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
-" @Last Change: 2016-01-03
-" @Revision: 3
-
-
-" :display: tlib#selection#GetSelection(mode, ?mbeg="'<", ?mend="'>", ?opmode='selection')
-" mode can be one of: selection, lines, block
-function! tlib#selection#GetSelection(mode, ...) range "{{{3
- if a:0 >= 2
- let mbeg = a:1
- let mend = a:2
- else
- let mbeg = "'<"
- let mend = "'>"
- endif
- let opmode = a:0 >= 3 ? a:3 : 'selection'
- let l0 = line(mbeg)
- let l1 = line(mend)
- let text = getline(l0, l1)
- let c0 = col(mbeg)
- let c1 = col(mend)
- " TLogVAR mbeg, mend, opmode, l0, l1, c0, c1
- " TLogVAR text[-1]
- " TLogVAR len(text[-1])
- if opmode == 'block'
- let clen = c1 - c0
- call map(text, 'strpart(v:val, c0, clen)')
- elseif opmode == 'selection'
- if c1 > 1
- let text[-1] = strpart(text[-1], 0, c1 - (a:mode == 'o' || c1 > len(text[-1]) ? 0 : 1))
- endif
- if c0 > 1
- let text[0] = strpart(text[0], c0 - 1)
- endif
- endif
- return text
-endf
-
diff --git a/vim/bundle/tlib_vim/autoload/tlib/signs.vim b/vim/bundle/tlib_vim/autoload/tlib/signs.vim
deleted file mode 100755
index 1664680..0000000
--- a/vim/bundle/tlib_vim/autoload/tlib/signs.vim
+++ /dev/null
@@ -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
diff --git a/vim/bundle/tlib_vim/autoload/tlib/string.vim b/vim/bundle/tlib_vim/autoload/tlib/string.vim
deleted file mode 100755
index 26b1f32..0000000
--- a/vim/bundle/tlib_vim/autoload/tlib/string.vim
+++ /dev/null
@@ -1,172 +0,0 @@
-" @Author: Tom Link (micathom AT gmail com?subject=[vim])
-" @Website: http://www.vim.org/account/profile.php?user_id=4037
-" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
-" @Revision: 126
-
-
-" :def: function! tlib#string#RemoveBackslashes(text, ?chars=' ')
-" Remove backslashes from text (but only in front of the characters in
-" chars).
-function! tlib#string#RemoveBackslashes(text, ...) "{{{3
- exec tlib#arg#Get(1, 'chars', ' ')
- " TLogVAR chars
- let rv = substitute(a:text, '\\\(['. chars .']\)', '\1', 'g')
- return rv
-endf
-
-
-" :display: tlib#string#Chomp(string, ?max=0)
-function! tlib#string#Chomp(string, ...) "{{{3
- let quant = a:0 >= 1 ? '\{,'. a:1 .'}' : '\+'
- return substitute(a:string, '[[:cntrl:][:space:]]'. quant .'$', '', '')
-endf
-
-
-" Format a template string. Placeholders have the format "%{NAME}". A
-" "%" can be inserted as "%%".
-"
-" Examples:
-" echo tlib#string#Format("foo %{bar} foo", {'bar': 123})
-" => foo 123 foo
-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
-
-
-function! tlib#string#SplitCommaList(text, ...) abort "{{{3
- let sep = a:0 >= 1 ? a:1 : ',\s*'
- let parts = split(a:text, '\\\@<!\zs'. sep)
- let parts = map(parts, 'substitute(v:val, ''\\\(.\)'', ''\1'', ''g'')')
- return parts
-endf
-
-
-function! tlib#string#Input(...) abort "{{{3
- TVarArg ['text', ''], ['completion', '']
- call inputsave()
- let rv = call(function('input'), a:000)
- call inputrestore()
- return rv
-endf
diff --git a/vim/bundle/tlib_vim/autoload/tlib/syntax.vim b/vim/bundle/tlib_vim/autoload/tlib/syntax.vim
deleted file mode 100755
index aa30b66..0000000
--- a/vim/bundle/tlib_vim/autoload/tlib/syntax.vim
+++ /dev/null
@@ -1,38 +0,0 @@
-" @Author: Tom Link (mailto:micathom AT gmail com?subject=[vim])
-" @Website: http://www.vim.org/account/profile.php?user_id=4037
-" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
-" @Revision: 13
-
-
-function! tlib#syntax#Collect() "{{{3
- let acc = {}
- let syn = ''
- for line in tlib#cmd#OutputAsList('syntax')
- if line =~ '^---'
- continue
- elseif line =~ '^\w'
- let ml = matchlist(line, '^\(\w\+\)\s\+\(xxx\s\+\(.*\)\|\(cluster.*\)\)$')
- if empty(ml)
- " echoerr 'Internal error: '. string(line)
- else
- let [m_0, syn, m_1, m_def1, m_def2; m_rest] = ml
- let acc[syn] = [empty(m_def1) ? m_def2 : m_def1]
- endif
- else
- call add(acc[syn], matchstr(line, '^\s\+\zs.*$'))
- endif
- endfor
- return acc
-endf
-
-
-" :def: function! tlib#syntax#Names(?rx='')
-function! tlib#syntax#Names(...) "{{{3
- TVarArg 'rx'
- let names = keys(tlib#syntax#Collect())
- if !empty(rx)
- call filter(names, 'v:val =~ rx')
- endif
- return names
-endf
-
diff --git a/vim/bundle/tlib_vim/autoload/tlib/sys.vim b/vim/bundle/tlib_vim/autoload/tlib/sys.vim
deleted file mode 100644
index 0ed24f0..0000000
--- a/vim/bundle/tlib_vim/autoload/tlib/sys.vim
+++ /dev/null
@@ -1,212 +0,0 @@
-" @Author: Tom Link (mailto:micathom AT gmail com?subject=[vim])
-" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
-" @Last Change: 2015-12-12.
-" @Revision: 59
-
-
-if !exists('g:tlib#sys#special_protocols')
- " A list of |regexp|s matching protocol names that should be handled
- " by |g:tlib#sys#system_browser|.
- " CAVEAT: Must be a |\V| |regexp|.
- let g:tlib#sys#special_protocols = ['https\?', 'nntp', 'mailto'] "{{{2
-endif
-
-
-if !exists('g:tlib#sys#special_suffixes')
- " A list of |regexp|s matching suffixes that should be handled by
- " |g:tlib#sys#system_browser|.
- " CAVEAT: Must be a |\V| |regexp|.
- let g:tlib#sys#special_suffixes = ['xlsx\?', 'docx\?', 'pptx\?', 'accdb', 'mdb', 'sqlite', 'pdf', 'jpg', 'png', 'gif', 'od\[tspg]'] "{{{2
-endif
-
-
-if !exists('g:tlib#sys#system_rx')
- " Open links matching this |regexp| with |g:tlib#sys#system_browser|.
- " CAVEAT: Must be a |\V| |regexp|.
- let g:tlib#sys#system_rx = printf('\V\%(\^\%(%s\):\|.\%(%s\)\$\)', join(g:tlib#sys#special_protocols, '\|'), join(g:tlib#sys#special_suffixes, '\|')) "{{{2
-endif
-
-
-if !exists("g:tlib#sys#system_browser")
- if exists('g:netrw_browsex_viewer')
- " Open files in the system browser.
- " :read: let g:tlib#sys#system_browser = ... "{{{2
- let g:tlib#sys#system_browser = "exec 'silent !'. g:netrw_browsex_viewer shellescape('%s')"
- elseif has("win32") || has("win16") || has("win64")
- " let g:tlib#sys#system_browser = "exec 'silent ! start \"\"' shellescape('%s')"
- let g:tlib#sys#system_browser = "exec 'silent ! RunDll32.EXE URL.DLL,FileProtocolHandler' shellescape('%s')"
- elseif has("mac")
- let g:tlib#sys#system_browser = "exec 'silent !open' shellescape('%s')"
- elseif exists('$XDG_CURRENT_DESKTOP') && !empty($XDG_CURRENT_DESKTOP)
- let g:tlib#sys#system_browser = "exec 'silent !xdg-open' shellescape('%s') '&'"
- elseif $GNOME_DESKTOP_SESSION_ID != "" || $DESKTOP_SESSION == 'gnome'
- let g:tlib#sys#system_browser = "exec 'silent !gnome-open' shellescape('%s')"
- elseif exists("$KDEDIR") && !empty($KDEDIR)
- let g:tlib#sys#system_browser = "exec 'silent !kfmclient exec' shellescape('%s')"
- else
- let g:tlib#sys#system_browser = ''
- endif
-endif
-
-
-if !exists('g:tlib#sys#windows')
- let g:tlib#sys#windows = &shell !~ 'sh' && (has('win16') || has('win32') || has('win64')) "{{{2
-endif
-
-
-if !exists('g:tlib#sys#null')
- let g:tlib#sys#null = g:tlib#sys#windows ? 'NUL' : (filereadable('/dev/null') ? '/dev/null' : '') "{{{2
-endif
-
-
-let s:cygwin = {}
-
-function! tlib#sys#IsCygwinBin(cmd) "{{{3
- " TLogVAR a:cmd
- if !g:tlib#sys#windows
- return 0
- elseif has_key(s:cygwin, a:cmd)
- let rv = s:cygwin[a:cmd]
- else
- if !tlib#sys#IsExecutable('cygpath', 1) || !tlib#sys#IsExecutable('which', 1)
- let rv = 0
- else
- let which = substitute(system('which '. shellescape(a:cmd)), '\n$', '', '')
- " echom "DBG which:" which
- if which =~ '^/'
- let filename = system('cygpath -ma '. shellescape(which))
- " echom "DBG filename:" filename
- let rv = filename =~ g:tlib#sys#cygwin_path_rx
- else
- let rv = 0
- endif
- endif
- let s:cygwin[a:cmd] = rv
- endif
- " TLogVAR rv
- return rv
-endf
-
-
-let s:executables = {}
-
-function! tlib#sys#IsExecutable(cmd, ...) "{{{3
- " TLogVAR a:cmd
- " echom "DBG has_key(s:executables, a:cmd)" has_key(s:executables, a:cmd)
- if !has_key(s:executables, a:cmd)
- let executable = executable(a:cmd)
- " TLogVAR 1, executable
- let ignore_cyg = a:0 >= 1 ? a:1 : !g:tlib#sys#windows
- if !executable && !ignore_cyg
- let executable = tlib#sys#IsCygwinBin(a:cmd)
- " TLogVAR 2, executable
- endif
- let s:executables[a:cmd] = executable
- endif
- " echom "DBG s:executables[a:cmd]" s:executables[a:cmd]
- return s:executables[a:cmd]
-endf
-
-
-if !exists('g:tlib#sys#check_cygpath')
- " If true, check whether we have to convert a path via cyppath --
- " see |tlib#sys#MaybeUseCygpath|
- let g:tlib#sys#check_cygpath = g:tlib#sys#windows && tlib#sys#IsExecutable('cygpath', 1) "{{{2
-endif
-
-
-if !exists('g:tlib#sys#cygwin_path_rx')
- " If a full windows filename (with slashes instead of backslashes)
- " matches this |regexp|, it is assumed to be a cygwin executable.
- let g:tlib#sys#cygwin_path_rx = '/cygwin/' "{{{2
-endif
-
-
-if !exists('g:tlib#sys#cygwin_expr')
- " For cygwin binaries, convert command calls using this vim
- " expression.
- let g:tlib#sys#cygwin_expr = '"bash -c ''". escape(%s, "''\\") ."''"' "{{{2
-endif
-
-
-function! tlib#sys#GetCmd(cmd) "{{{3
- if !empty(g:tlib#sys#cygwin_expr) && tlib#sys#IsCygwinBin(matchstr(a:cmd, '^\S\+'))
- let cmd = eval(printf(g:tlib#sys#cygwin_expr, string(a:cmd)))
- " TLogVAR cmd
- return cmd
- else
- return a:cmd
- endif
-endf
-
-
-" If cmd seems to be a cygwin executable, use cygpath to convert
-" filenames. This assumes that cygwin's which command returns full
-" filenames for non-cygwin executables.
-function! tlib#sys#MaybeUseCygpath(cmd) "{{{3
- " echom "DBG" a:cmd
- if g:tlib#sys#check_cygpath && tlib#sys#IsCygwinBin(a:cmd)
- return 'cygpath -u "%s"'
- endif
- return ''
-endf
-
-
-function! tlib#sys#ConvertPath(converter, filename) "{{{3
- return tlib#string#Chomp(system(printf(a:converter, shellescape(a:filename))))
-endf
-
-
-let s:native_filenames = {}
-
-function! tlib#sys#FileArgs(cmd, files) "{{{3
- let cygpath = tlib#sys#MaybeUseCygpath(a:cmd)
- " TLogVAR cygpath
- if empty(cygpath)
- return a:files
- else
- let files = map(copy(a:files), 'has_key(s:native_filenames, v:val) ? s:native_filenames[v:val] : tlib#sys#CygPath(v:val)')
- return files
- endif
-endf
-
-
-" Check whether filename matches |g:tlib#sys#system_rx|, i.e. whether it
-" is a special file that should not be opened in vim.
-function! tlib#sys#IsSpecial(filename) abort "{{{3
- return a:filename =~ g:tlib#sys#system_rx
-endf
-
-
-" Open filename with the default OS application (see
-" |g:tlib#sys#system_browser|), if |tlib#sys#IsSpecial()| return 1.
-" Returns 1 if successful or 0 otherwise.
-function! tlib#sys#Open(filename) abort "{{{3
- Tlibtrace 'tlib', a:filename
- if !empty(g:tlib#sys#system_browser) && tlib#sys#IsSpecial(a:filename)
- try
- let cmd = printf(g:tlib#sys#system_browser, a:filename)
- " let cmd = printf(g:tlib#sys#system_browser, escape(a:filename, ' %#!'))
- Tlibtrace 'tlib', cmd
- exec cmd
- return 1
- catch
- echohl ErrorMsg
- echom v:exception
- echohl NONE
- endtry
- endif
- return 0
-endf
-
-
-" :def: function! tlib#sys#SystemInDir(dir, expr, ?input='')
-function! tlib#sys#SystemInDir(dir, ...) abort "{{{3
- call tlib#dir#CD(a:dir)
- try
- return call(function('system'), a:000)
- finally
- silent cd! -
- endtry
-endf
-
diff --git a/vim/bundle/tlib_vim/autoload/tlib/tab.vim b/vim/bundle/tlib_vim/autoload/tlib/tab.vim
deleted file mode 100755
index fa6bb8d..0000000
--- a/vim/bundle/tlib_vim/autoload/tlib/tab.vim
+++ /dev/null
@@ -1,49 +0,0 @@
-" @Author: Tom Link (micathom AT gmail com?subject=[vim])
-" @Website: http://www.vim.org/account/profile.php?user_id=4037
-" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
-" @Revision: 31
-
-
-" Return a dictionary of bufnumbers => [[tabpage, winnr] ...]
-function! tlib#tab#BufMap() "{{{3
- let acc = {}
- for t in range(tabpagenr('$'))
- let bb = tabpagebuflist(t + 1)
- for b in range(len(bb))
- let bn = bb[b]
- let bd = [t + 1, b + 1]
- if has_key(acc, bn)
- call add(acc[bn], bd)
- else
- let acc[bn] = [bd]
- endif
- endfor
- endfor
- return acc
-endf
-
-
-" Find a buffer's window at some tab page.
-function! tlib#tab#TabWinNr(buffer) "{{{3
- let bn = bufnr(a:buffer)
- let bt = tlib#tab#BufMap()
- let tn = tabpagenr()
- let wn = winnr()
- let bc = get(bt, bn)
- if !empty(bc)
- for [t, w] in bc
- if t == tn
- return [t, w]
- endif
- endfor
- return bc[0]
- endif
-endf
-
-
-function! tlib#tab#Set(tabnr) "{{{3
- if a:tabnr > 0
- exec a:tabnr .'tabnext'
- endif
-endf
-
diff --git a/vim/bundle/tlib_vim/autoload/tlib/tag.vim b/vim/bundle/tlib_vim/autoload/tlib/tag.vim
deleted file mode 100755
index e4239d3..0000000
--- a/vim/bundle/tlib_vim/autoload/tlib/tag.vim
+++ /dev/null
@@ -1,132 +0,0 @@
-" @Author: Tom Link (mailto:micathom AT gmail com?subject=[vim])
-" @Website: http://www.vim.org/account/profile.php?user_id=4037
-" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
-" @Revision: 59
-
-
-" 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
-
diff --git a/vim/bundle/tlib_vim/autoload/tlib/textobjects.vim b/vim/bundle/tlib_vim/autoload/tlib/textobjects.vim
deleted file mode 100755
index fb4170e..0000000
--- a/vim/bundle/tlib_vim/autoload/tlib/textobjects.vim
+++ /dev/null
@@ -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
diff --git a/vim/bundle/tlib_vim/autoload/tlib/time.vim b/vim/bundle/tlib_vim/autoload/tlib/time.vim
deleted file mode 100755
index 2273d55..0000000
--- a/vim/bundle/tlib_vim/autoload/tlib/time.vim
+++ /dev/null
@@ -1,67 +0,0 @@
-" @Author: Tom Link (mailto:micathom AT gmail com?subject=[vim])
-" @Website: http://www.vim.org/account/profile.php?user_id=4037
-" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
-" @Revision: 36
-
-
-function! tlib#time#MSecs() "{{{3
- let rts = reltimestr(reltime())
- return substitute(rts, '\.', '', '')
-endf
-
-
-function! tlib#time#Now() "{{{3
- if has('reltime')
- let rts = reltimestr(reltime())
- let rtl = map(split(rts, '\.'), 'str2nr(v:val)')
- else
- let rtl = [localtime()]
- endif
- return rtl
-endf
-
-
-function! tlib#time#FormatNow() "{{{3
- let rtl = tlib#time#Now()
- if len(rtl) == 2
- let rts = strftime(g:tlib#date#date_format .' %H:%M:%S', rtl[0]) .'.'. rtl[1]
- else
- let rts = strftime(g:tlib#date#date_format .' %H:%M:%S', rtl[0])
- endif
- return rts
-endf
-
-
-function! tlib#time#Diff(a, b, ...) "{{{3
- TVarArg ['resolution', 2]
- let [as, am] = a:a
- let [bs, bm] = a:b
- let rv = 0 + (as - bs)
- if resolution > 0
- let rv .= repeat('0', resolution)
- let am = am[0 : resolution - 1]
- let bm = bm[0 : resolution - 1]
- let rv += (am - bm)
- endif
- return rv
-endf
-
-
-function! tlib#time#DiffMSecs(a, b, ...) "{{{3
- TVarArg ['resolution', 2]
- if a:a == a:b
- return 0
- endif
- let a = printf('%30s', a:a[0 : -(7 - resolution)])
- let b = printf('%30s', a:b[0 : -(7 - resolution)])
- for i in range(0, 29)
- if a[i] != b[i]
- let a = a[i : -1]
- let b = b[i : -1]
- return a - b
- endif
- endfor
- return 0
-endf
-
-
diff --git a/vim/bundle/tlib_vim/autoload/tlib/trace.vim b/vim/bundle/tlib_vim/autoload/tlib/trace.vim
deleted file mode 100644
index cdda1de..0000000
--- a/vim/bundle/tlib_vim/autoload/tlib/trace.vim
+++ /dev/null
@@ -1,159 +0,0 @@
-" @Author: Tom Link (mailto:micathom AT gmail com?subject=[vim])
-" @Website: https://github.com/tomtom
-" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
-" @Last Change: 2016-06-08
-" @Revision: 177
-
-
-if !exists('g:tlib#trace#backtrace')
- " The length of the backtrace that should be included in
- " |tlib#trace#Print()|.
- let g:tlib#trace#backtrace = 2 "{{{2
-endif
-
-
-if !exists('g:tlib#trace#printer')
- " Possible values:
- " - 'echom'
- " - ['file', FILENAME]
- let g:tlib#trace#printer = 'echom' "{{{2
-endif
-
-
-if !exists('g:tlib#trace#hl')
- let g:tlib#trace#hl = {'error': 'ErrorMsg', 'fatal': 'ErrorMsg', 'warn': 'WarningMsg'} "{{{2
-endif
-
-
-" Print traces from |tlib#trace#Print()|.
-function! tlib#trace#Printer_echom(type, text, args) abort "{{{3
- let hl = get(g:tlib#trace#hl, a:type, '')
- try
- if !empty(hl)
- exec 'echohl' hl
- endif
- echom a:text
- finally
- if !empty(hl)
- echohl NONE
- endif
- endtry
-endf
-
-
-function! tlib#trace#Printer_file(type, text, args) abort "{{{3
- let filename = get(a:args, 0, '')
- if !filewritable(filename)
- throw 'tlib#trace#Printer_file: Cannot write to file: '. filename
- else
- call writefile([a:text], filename, 'a')
- endif
-endf
-
-
-" Set the tracing |regexp|. See |:Tlibtrace|.
-" This will also call |tlib#trace#Enable()|.
-"
-" Examples:
-" call tlib#trace#Set(["+foo", "-bar"])
-" call tlib#trace#Set("+foo,-bar")
-function! tlib#trace#Set(vars) abort "{{{3
- call tlib#trace#Enable()
- if type(a:vars) == 1
- let vars = tlib#string#SplitCommaList(a:vars, '[,[:space:]]\+')
- else
- let vars = a:vars
- endif
- " TLogVAR vars
- for rx in vars
- let rx1 = substitute(rx, '^[+-]', '', 'g')
- if rx1 !~# '^\%(error\|warn\|fatal\)$'
- let erx1 = tlib#rx#Escape(rx1)
- " TLogVAR rx, rx1
- " echom "DBG" s:trace_rx
- if rx =~ '^+'
- if s:trace_rx !~# '[(|]'. erx1 .'\\'
- let s:trace_rx = substitute(s:trace_rx, '\ze\\)\$', '\\|'. erx1, '')
- endif
- elseif rx =~ '^-'
- if s:trace_rx =~# '[(|]'. erx1 .'\\'
- let s:trace_rx = substitute(s:trace_rx, '\\|'. erx1, '', '')
- endif
- else
- echohl WarningMsg
- echom 'tlib#trace#Print: Unsupported syntax:' rx
- echohl NONE
- endif
- " echom "DBG" s:trace_rx
- endif
- endfor
- echom "SetTrace:" s:trace_rx
-endf
-
-
-function! tlib#trace#Backtrace(caller) abort "{{{3
- let caller = split(a:caller, '\.\.')
- let start = max([0, len(caller) - g:tlib#trace#backtrace - 1])
- let caller = caller[start : -1]
- return join(caller, '..')
-endf
-
-
-" Print the values of vars. The first value is a "guard" (see
-" |:Tlibtrace|).
-function! tlib#trace#Print(caller, vars, values) abort "{{{3
- let msg = ['TRACE']
- let guard = a:values[0]
- if type(guard) == 0
- let cond = guard
- else
- let cond = guard =~# s:trace_rx
- endif
- " TLogVAR guard, cond, a:vars, a:values
- if cond
- call add(msg, guard)
- call add(msg, tlib#time#FormatNow() .':')
- if g:tlib#trace#backtrace > 0
- let bt = tlib#trace#Backtrace(a:caller)
- if !empty(bt)
- call add(msg, bt .':')
- endif
- endif
- for i in range(1, len(a:vars) - 1)
- let v = substitute(a:vars[i], ',$', '', '')
- let r = a:values[i]
- if v =~# '^\([''"]\).\{-}\1$'
- call add(msg, r .';')
- else
- call add(msg, v .'='. string(r) .';')
- endif
- unlet r
- endfor
- if type(g:tlib#trace#printer) == 1
- let printer = g:tlib#trace#printer
- let args = []
- else
- let [printer; args] = g:tlib#trace#printer
- endif
- call tlib#trace#Printer_{printer}(guard, join(msg), args)
- endif
-endf
-
-
-" Enable tracing via |:Tlibtrace|.
-function! tlib#trace#Enable() abort "{{{3
- if !exists('s:trace_rx')
- let s:trace_rx = '^\%(error\|fatal\|warn\|info\)$'
- " :nodoc:
- command! -nargs=+ -bang Tlibtrace call tlib#trace#Print(expand('<sfile>'), [<f-args>], [<args>])
- endif
-endf
-
-
-" Disable tracing via |:Tlibtrace|.
-function! tlib#trace#Disable() abort "{{{3
- " :nodoc:
- command! -nargs=+ -bang Tlibtrace :
- unlet! s:trace_rx
-endf
-
diff --git a/vim/bundle/tlib_vim/autoload/tlib/type.vim b/vim/bundle/tlib_vim/autoload/tlib/type.vim
deleted file mode 100755
index 63116d2..0000000
--- a/vim/bundle/tlib_vim/autoload/tlib/type.vim
+++ /dev/null
@@ -1,126 +0,0 @@
-" @Author: Tom Link (mailto:micathom AT gmail com?subject=[vim])
-" @Website: http://www.vim.org/account/profile.php?user_id=4037
-" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
-" @Created: 2007-09-30.
-" @Last Change: 2015-12-04.
-" @Revision: 44
-
-
-" Enable type assertiona via |:Tlibtype|.
-function! tlib#type#Enable() abort "{{{3
- " :nodoc:
- command! -nargs=+ Tlibtype call tlib#type#Check(expand('<sfile>'), [<f-args>], [<args>])
-endf
-
-
-" Disable type assertiona via |:Tlibtype|.
-function! tlib#type#Disable() abort "{{{3
- " :nodoc:
- command! -nargs=+ Tlibtype :
-endf
-
-
-function! tlib#type#IsNumber(expr)
- return tlib#type#Is(a:expr, 0)
-endf
-
-
-function! tlib#type#IsString(expr)
- return tlib#type#Is(a:expr, 1)
-endf
-
-
-function! tlib#type#IsFuncref(expr)
- return tlib#type#Is(a:expr, 2)
-endf
-
-
-function! tlib#type#IsList(expr)
- return tlib#type#Is(a:expr, 3)
-endf
-
-
-function! tlib#type#IsDictionary(expr)
- return tlib#type#Is(a:expr, 4)
-endf
-
-
-function! tlib#type#Is(val, type) abort "{{{3
- if has_key(s:schemas, a:type)
- return tlib#type#Has(a:val, a:type)
- else
- if type(a:type) == 0
- let type = a:type
- elseif a:type =~? '^n\%[umber]'
- let type = 0
- elseif a:type =~? '^s\%[tring]'
- let type = 1
- elseif a:type =~? '^fu\%[ncref]'
- let type = 2
- elseif a:type =~? '^l\%[ist]'
- let type = 3
- elseif a:type =~? '^d\%[ictionary]'
- let type = 4
- elseif a:type =~? '^fl\%[oat]'
- let type = 5
- else
- throw 'tlib#type#Is: Unknown type: ' a:type
- endif
- " TLogVAR a:val, a:type, type, type(a:val), type(a:val) == a:type
- return type(a:val) == type
- endif
-endf
-
-
-function! tlib#type#Are(vals, type) abort "{{{3
- return tlib#assert#Map(a:vals, 'tlib#type#Is(v:val,'. string(a:type) .')')
-endf
-
-
-let s:schemas = {}
-
-
-function! tlib#type#Define(name, schema) abort "{{{3
- let s:schemas[a:name] = deepcopy(a:schema)
-endf
-
-
-function! tlib#type#Has(val, schema) abort "{{{3
- " TLogVAR type(a:val), type(a:schema)
- if !tlib#type#IsDictionary(a:val)
- " TLogVAR 'not a dictionary', a:val
- return 0
- endif
- if tlib#type#IsString(a:schema)
- " TLogVAR a:schema
- let schema = copy(s:schemas[a:schema])
- else
- let schema = copy(a:schema)
- endif
- if tlib#type#IsDictionary(schema)
- return tlib#assert#All(map(schema, 'has_key(a:val, v:key) && tlib#type#Is(a:val[v:key], v:val)'))
- else
- " TLogVAR keys(a:val), schema
- return tlib#assert#All(map(schema, 'has_key(a:val, v:val)'))
- endif
-endf
-
-
-function! tlib#type#Have(vals, schema) abort "{{{3
- return tlib#assert#Map(a:vals, 'tlib#type#Has(v:val,'. string(a:schema) .')')
-endf
-
-
-function! tlib#type#Check(caller, names, vals) abort "{{{3
- " TLogVAR a:names, a:vals, len(a:names)
- for i in range(0, len(a:names) - 1, 2)
- let val = a:vals[i]
- let type = a:vals[i + 1]
- " TLogVAR i, val, type
- if !tlib#type#Is(val, type)
- let name = matchstr(a:names[i], '^''\zs.\{-}\ze'',\?$')
- throw 'tlib#type#Check: Type mismatch: '. name .':'. a:vals[i + 1]
- endif
- endfor
-endf
-
diff --git a/vim/bundle/tlib_vim/autoload/tlib/url.vim b/vim/bundle/tlib_vim/autoload/tlib/url.vim
deleted file mode 100755
index b948d48..0000000
--- a/vim/bundle/tlib_vim/autoload/tlib/url.vim
+++ /dev/null
@@ -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
-
-
diff --git a/vim/bundle/tlib_vim/autoload/tlib/var.vim b/vim/bundle/tlib_vim/autoload/tlib/var.vim
deleted file mode 100755
index dcd9264..0000000
--- a/vim/bundle/tlib_vim/autoload/tlib/var.vim
+++ /dev/null
@@ -1,83 +0,0 @@
-" @Author: Tom Link (micathom AT gmail com?subject=[vim])
-" @Website: http://www.vim.org/account/profile.php?user_id=4037
-" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
-" @Revision: 30
-
-
-" 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', 'g:']
- if v:version >= 704
- exec 'let varlist = keys('. prefix .')'
- else
- redir => vars
- silent! exec 'let '. prefix
- redir END
- let varlist = split(vars, '\n')
- call map(varlist, 'matchstr(v:val, ''^\S\+'')')
- endif
- call filter(varlist, 'v:val =~ a:rx')
- return varlist
-endf
-
diff --git a/vim/bundle/tlib_vim/autoload/tlib/vcs.vim b/vim/bundle/tlib_vim/autoload/tlib/vcs.vim
deleted file mode 100644
index 15d051f..0000000
--- a/vim/bundle/tlib_vim/autoload/tlib/vcs.vim
+++ /dev/null
@@ -1,189 +0,0 @@
-" @Author: Tom Link (mailto:micathom AT gmail com?subject=[vim])
-" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
-" @Created: 2012-03-08.
-" @Last Change: 2015-11-07.
-" @Revision: 190
-
-scriptencoding utf-8
-
-
-" A dictionarie of supported VCS (currently: git, hg, svn, bzr).
-" :display: g:tlib#vcs#def {...}
-TLet g:tlib#vcs#def = {
- \ 'git': {
- \ 'dir': '.git',
- \ 'ls': 'git ls-files --full-name',
- \ 'ls.postprocess': '*tlib#vcs#GitLsPostprocess',
- \ 'diff': 'git diff --no-ext-diff -U0 %s'
- \ },
- \ '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
- Tlibtrace 'tlib', a:filename, path
- let depth = -1
- for vcs in keys(g:tlib#vcs#def)
- let subdir = g:tlib#vcs#def[vcs].dir
- let vcsdir = finddir(subdir, path)
- " TLogVAR vcs, subdir, vcsdir
- Tlibtrace 'tlib', vcs, subdir, vcsdir
- if !empty(vcsdir)
- let vcsdir_depth = len(split(fnamemodify(vcsdir, ':p'), '\/'))
- if vcsdir_depth > depth
- let depth = vcsdir_depth
- let type = vcs
- let dir = vcsdir
- " TLogVAR type, depth
- endif
- endif
- endfor
- Tlibtrace 'tlib', type, dir
- " TLogVAR type, dir
- if empty(type)
- 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]
- if cmd =~ '^\*'
- let cmd = substitute(cmd, '^\*', '', '')
- else
- let bin = get(g:tlib#vcs#executables, a:vcstype, '')
- if empty(bin)
- let cmd = ''
- elseif bin != a:vcstype
- " let bin = escape(shellescape(bin), '\')
- let bin = escape(bin, '\')
- let cmd = substitute(cmd, '^.\{-}\zs'. escape(a:vcstype, '\'), bin, '')
- endif
- endif
- return cmd
- else
- return ''
- endif
-endf
-
-
-" :display: tlib#vcs#Ls(?filename=bufname('%'), ?vcs=[type, dir])
-" Return the files under VCS.
-function! tlib#vcs#Ls(...) "{{{3
- if a:0 >= 2
- let vcs = a:2
- else
- let vcs = tlib#vcs#FindVCS(a:0 >= 1 ? a:1 : bufname('%'))
- endif
- Tlibtrace 'tlib', vcs, a:000
- " TLogVAR vcs
- if !empty(vcs)
- let [vcstype, vcsdir] = vcs
- if has_key(g:tlib#vcs#def, vcstype)
- let ls = s:GetCmd(vcstype, 'ls')
- " TLogVAR ls
- if !empty(ls)
- let rootdir = fnamemodify(vcsdir, ':p:h:h')
- " TLogVAR vcsdir, rootdir
- if ls =~ '%s'
- let cmd = printf(ls, shellescape(rootdir))
- else
- let cmd = ls
- endif
- " TLogVAR cmd, getcwd()
- Tlibtrace 'tlib', getcwd(), vcstype, vcsdir, rootdir, cmd
- let filess = tlib#sys#SystemInDir(rootdir, cmd)
- " TLogVAR filess
- let files = split(filess, '\n')
- let postprocess = s:GetCmd(vcstype, 'ls.postprocess')
- if !empty(postprocess)
- call map(files, 'call(postprocess, [v:val])')
- endif
- call map(files, 'join([rootdir, v:val], "/")')
- " TLogVAR files
- return files
- endif
- endif
- endif
- return []
-endf
-
-
-" :display: tlib#vcs#Diff(filename, ?vcs=[type, dir])
-" Return the diff for "filename"
-function! tlib#vcs#Diff(filename, ...) "{{{3
- let vcs = a:0 >= 1 ? a:1 : tlib#vcs#FindVCS(a:filename)
- if !empty(vcs)
- let [vcstype, vcsdir] = vcs
- let diff = s:GetCmd(vcstype, 'diff')
- if !empty(diff)
- let cmd = printf(diff, shellescape(fnamemodify(a:filename, ':p')))
- let patch = system(cmd)
- return patch
- endif
- endif
- return []
-endf
-
-
-function! tlib#vcs#GitLsPostprocess(filename) abort "{{{3
- if a:filename =~ '^".\{-}"$'
- let filename = matchstr(a:filename, '^"\zs.\{-}\ze"$')
- let filename = substitute(filename, '\%(\\\@<!\\\(\d\d\d\)\)\+', '\=eval(''"''. submatch(0) .''"'')', 'g')
- " let filename = eval(a:filename)
- " TLogVAR a:filename, filename, &enc
- return filename
- else
- return a:filename
- endif
-endf
-
diff --git a/vim/bundle/tlib_vim/autoload/tlib/vim.vim b/vim/bundle/tlib_vim/autoload/tlib/vim.vim
deleted file mode 100644
index 7154aeb..0000000
--- a/vim/bundle/tlib_vim/autoload/tlib/vim.vim
+++ /dev/null
@@ -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
-
diff --git a/vim/bundle/tlib_vim/autoload/tlib/win.vim b/vim/bundle/tlib_vim/autoload/tlib/win.vim
deleted file mode 100755
index 4963af1..0000000
--- a/vim/bundle/tlib_vim/autoload/tlib/win.vim
+++ /dev/null
@@ -1,128 +0,0 @@
-" @Author: Tom Link (micathom AT gmail com?subject=[vim])
-" @Website: http://www.vim.org/account/profile.php?user_id=4037
-" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
-" @Revision: 55
-
-
-" 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
-