├── .gitmodules
├── README.md
├── autoload
    └── pathogen.vim
├── gvimrc
├── solarized.zip
└── vimrc


/.gitmodules:
--------------------------------------------------------------------------------
 1 | [submodule "bundle/emmet-vim"]
 2 | 	path = bundle/emmet-vim
 3 | 	url = git@github.com:mattn/emmet-vim.git
 4 | [submodule "bundle/nerdcommenter"]
 5 | 	path = bundle/nerdcommenter
 6 | 	url = git@github.com:scrooloose/nerdcommenter.git
 7 | [submodule "bundle/snipmate"]
 8 | 	path = bundle/snipmate
 9 | 	url = git@github.com:caike/snipmate.vim.git
10 | [submodule "bundle/tlib_vim"]
11 | 	path = bundle/tlib_vim
12 | 	url = git@github.com:tomtom/tlib_vim.git
13 | [submodule "bundle/vim-addon-mw-utils"]
14 | 	path = bundle/vim-addon-mw-utils
15 | 	url = git@github.com:MarcWeber/vim-addon-mw-utils.git
16 | [submodule "bundle/vim-coffee-script"]
17 | 	path = bundle/vim-coffee-script
18 | 	url = git@github.com:kchmck/vim-coffee-script.git
19 | [submodule "bundle/vim-javascript"]
20 | 	path = bundle/vim-javascript
21 | 	url = git@github.com:pangloss/vim-javascript.git
22 | [submodule "bundle/vim-rails"]
23 | 	path = bundle/vim-rails
24 | 	url = git@github.com:tpope/vim-rails.git
25 | [submodule "bundle/vim-ruby"]
26 | 	path = bundle/vim-ruby
27 | 	url = git@github.com:vim-ruby/vim-ruby.git
28 | [submodule "bundle/vim-surround"]
29 | 	path = bundle/vim-surround
30 | 	url = git@github.com:tpope/vim-surround.git
31 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # Vim Config
2 | 
3 | My collection of vim settings and plugins.
4 | 
5 | 


--------------------------------------------------------------------------------
/autoload/pathogen.vim:
--------------------------------------------------------------------------------
  1 | " pathogen.vim - path option manipulation
  2 | " Maintainer:   Tim Pope <http://tpo.pe/>
  3 | " Version:      2.3
  4 | 
  5 | " Install in ~/.vim/autoload (or ~\vimfiles\autoload).
  6 | "
  7 | " For management of individually installed plugins in ~/.vim/bundle (or
  8 | " ~\vimfiles\bundle), adding `execute pathogen#infect()` to the top of your
  9 | " .vimrc is the only other setup necessary.
 10 | "
 11 | " The API is documented inline below.
 12 | 
 13 | if exists("g:loaded_pathogen") || &cp
 14 |   finish
 15 | endif
 16 | let g:loaded_pathogen = 1
 17 | 
 18 | " Point of entry for basic default usage.  Give a relative path to invoke
 19 | " pathogen#interpose() (defaults to "bundle/{}"), or an absolute path to invoke
 20 | " pathogen#surround().  Curly braces are expanded with pathogen#expand():
 21 | " "bundle/{}" finds all subdirectories inside "bundle" inside all directories
 22 | " in the runtime path.
 23 | function! pathogen#infect(...) abort
 24 |   for path in a:0 ? filter(reverse(copy(a:000)), 'type(v:val) == type("")') : ['bundle/{}']
 25 |     if path =~# '^\%({\=[$~\\/]\|{\=\w:[\\/]\).*[{}*]'
 26 |       call pathogen#surround(path)
 27 |     elseif path =~# '^\%([$~\\/]\|\w:[\\/]\)'
 28 |       call s:warn('Change pathogen#infect('.string(path).') to pathogen#infect('.string(path.'/{}').')')
 29 |       call pathogen#surround(path . '/{}')
 30 |     elseif path =~# '[{}*]'
 31 |       call pathogen#interpose(path)
 32 |     else
 33 |       call s:warn('Change pathogen#infect('.string(path).') to pathogen#infect('.string(path.'/{}').')')
 34 |       call pathogen#interpose(path . '/{}')
 35 |     endif
 36 |   endfor
 37 |   call pathogen#cycle_filetype()
 38 |   if pathogen#is_disabled($MYVIMRC)
 39 |     return 'finish'
 40 |   endif
 41 |   return ''
 42 | endfunction
 43 | 
 44 | " Split a path into a list.
 45 | function! pathogen#split(path) abort
 46 |   if type(a:path) == type([]) | return a:path | endif
 47 |   if empty(a:path) | return [] | endif
 48 |   let split = split(a:path,'\\\@<!\%(\\\\\)*\zs,')
 49 |   return map(split,'substitute(v:val,''\\\([\\,]\)'',''\1'',"g")')
 50 | endfunction
 51 | 
 52 | " Convert a list to a path.
 53 | function! pathogen#join(...) abort
 54 |   if type(a:1) == type(1) && a:1
 55 |     let i = 1
 56 |     let space = ' '
 57 |   else
 58 |     let i = 0
 59 |     let space = ''
 60 |   endif
 61 |   let path = ""
 62 |   while i < a:0
 63 |     if type(a:000[i]) == type([])
 64 |       let list = a:000[i]
 65 |       let j = 0
 66 |       while j < len(list)
 67 |         let escaped = substitute(list[j],'[,'.space.']\|\\[\,'.space.']\@=','\\&','g')
 68 |         let path .= ',' . escaped
 69 |         let j += 1
 70 |       endwhile
 71 |     else
 72 |       let path .= "," . a:000[i]
 73 |     endif
 74 |     let i += 1
 75 |   endwhile
 76 |   return substitute(path,'^,','','')
 77 | endfunction
 78 | 
 79 | " Convert a list to a path with escaped spaces for 'path', 'tag', etc.
 80 | function! pathogen#legacyjoin(...) abort
 81 |   return call('pathogen#join',[1] + a:000)
 82 | endfunction
 83 | 
 84 | " Turn filetype detection off and back on again if it was already enabled.
 85 | function! pathogen#cycle_filetype() abort
 86 |   if exists('g:did_load_filetypes')
 87 |     filetype off
 88 |     filetype on
 89 |   endif
 90 | endfunction
 91 | 
 92 | " Check if a bundle is disabled.  A bundle is considered disabled if its
 93 | " basename or full name is included in the list g:pathogen_disabled.
 94 | function! pathogen#is_disabled(path) abort
 95 |   if a:path =~# '\~$'
 96 |     return 1
 97 |   endif
 98 |   let sep = pathogen#slash()
 99 |   let blacklist = get(g:, 'pathogen_blacklist', get(g:, 'pathogen_disabled', [])) + pathogen#split($VIMBLACKLIST)
100 |   return index(blacklist, fnamemodify(a:path, ':t')) != -1 || index(blacklist, a:path) != -1
101 | endfunction "}}}1
102 | 
103 | " Prepend the given directory to the runtime path and append its corresponding
104 | " after directory.  Curly braces are expanded with pathogen#expand().
105 | function! pathogen#surround(path) abort
106 |   let sep = pathogen#slash()
107 |   let rtp = pathogen#split(&rtp)
108 |   let path = fnamemodify(a:path, ':p:?[\\/]\=$??')
109 |   let before = filter(pathogen#expand(path), '!pathogen#is_disabled(v:val)')
110 |   let after = filter(reverse(pathogen#expand(path.sep.'after')), '!pathogen#is_disabled(v:val[0:-7])')
111 |   call filter(rtp, 'index(before + after, v:val) == -1')
112 |   let &rtp = pathogen#join(before, rtp, after)
113 |   return &rtp
114 | endfunction
115 | 
116 | " For each directory in the runtime path, add a second entry with the given
117 | " argument appended.  Curly braces are expanded with pathogen#expand().
118 | function! pathogen#interpose(name) abort
119 |   let sep = pathogen#slash()
120 |   let name = a:name
121 |   if has_key(s:done_bundles, name)
122 |     return ""
123 |   endif
124 |   let s:done_bundles[name] = 1
125 |   let list = []
126 |   for dir in pathogen#split(&rtp)
127 |     if dir =~# '\<after$'
128 |       let list += reverse(filter(pathogen#expand(dir[0:-6].name.sep.'after'), '!pathogen#is_disabled(v:val[0:-7])')) + [dir]
129 |     else
130 |       let list += [dir] + filter(pathogen#expand(dir.sep.name), '!pathogen#is_disabled(v:val)')
131 |     endif
132 |   endfor
133 |   let &rtp = pathogen#join(pathogen#uniq(list))
134 |   return 1
135 | endfunction
136 | 
137 | let s:done_bundles = {}
138 | 
139 | " Invoke :helptags on all non-$VIM doc directories in runtimepath.
140 | function! pathogen#helptags() abort
141 |   let sep = pathogen#slash()
142 |   for glob in pathogen#split(&rtp)
143 |     for dir in map(split(glob(glob), "\n"), 'v:val.sep."/doc/".sep')
144 |       if (dir)[0 : strlen($VIMRUNTIME)] !=# $VIMRUNTIME.sep && filewritable(dir) == 2 && !empty(split(glob(dir.'*.txt'))) && (!filereadable(dir.'tags') || filewritable(dir.'tags'))
145 |         silent! execute 'helptags' pathogen#fnameescape(dir)
146 |       endif
147 |     endfor
148 |   endfor
149 | endfunction
150 | 
151 | command! -bar Helptags :call pathogen#helptags()
152 | 
153 | " Execute the given command.  This is basically a backdoor for --remote-expr.
154 | function! pathogen#execute(...) abort
155 |   for command in a:000
156 |     execute command
157 |   endfor
158 |   return ''
159 | endfunction
160 | 
161 | " Section: Unofficial
162 | 
163 | function! pathogen#is_absolute(path) abort
164 |   return a:path =~# (has('win32') ? '^\%([\\/]\|\w:\)[\\/]\|^[~$]' : '^[/~$]')
165 | endfunction
166 | 
167 | " Given a string, returns all possible permutations of comma delimited braced
168 | " alternatives of that string.  pathogen#expand('/{a,b}/{c,d}') yields
169 | " ['/a/c', '/a/d', '/b/c', '/b/d'].  Empty braces are treated as a wildcard
170 | " and globbed.  Actual globs are preserved.
171 | function! pathogen#expand(pattern) abort
172 |   if a:pattern =~# '{[^{}]\+}'
173 |     let [pre, pat, post] = split(substitute(a:pattern, '\(.\{-\}\){\([^{}]\+\)}\(.*\)', "\\1\001\\2\001\\3", ''), "\001", 1)
174 |     let found = map(split(pat, ',', 1), 'pre.v:val.post')
175 |     let results = []
176 |     for pattern in found
177 |       call extend(results, pathogen#expand(pattern))
178 |     endfor
179 |     return results
180 |   elseif a:pattern =~# '{}'
181 |     let pat = matchstr(a:pattern, '^.*{}[^*]*\%($\|[\\/]\)')
182 |     let post = a:pattern[strlen(pat) : -1]
183 |     return map(split(glob(substitute(pat, '{}', '*', 'g')), "\n"), 'v:val.post')
184 |   else
185 |     return [a:pattern]
186 |   endif
187 | endfunction
188 | 
189 | " \ on Windows unless shellslash is set, / everywhere else.
190 | function! pathogen#slash() abort
191 |   return !exists("+shellslash") || &shellslash ? '/' : '\'
192 | endfunction
193 | 
194 | function! pathogen#separator() abort
195 |   return pathogen#slash()
196 | endfunction
197 | 
198 | " Convenience wrapper around glob() which returns a list.
199 | function! pathogen#glob(pattern) abort
200 |   let files = split(glob(a:pattern),"\n")
201 |   return map(files,'substitute(v:val,"[".pathogen#slash()."/]$","","")')
202 | endfunction "}}}1
203 | 
204 | " Like pathogen#glob(), only limit the results to directories.
205 | function! pathogen#glob_directories(pattern) abort
206 |   return filter(pathogen#glob(a:pattern),'isdirectory(v:val)')
207 | endfunction "}}}1
208 | 
209 | " Remove duplicates from a list.
210 | function! pathogen#uniq(list) abort
211 |   let i = 0
212 |   let seen = {}
213 |   while i < len(a:list)
214 |     if (a:list[i] ==# '' && exists('empty')) || has_key(seen,a:list[i])
215 |       call remove(a:list,i)
216 |     elseif a:list[i] ==# ''
217 |       let i += 1
218 |       let empty = 1
219 |     else
220 |       let seen[a:list[i]] = 1
221 |       let i += 1
222 |     endif
223 |   endwhile
224 |   return a:list
225 | endfunction
226 | 
227 | " Backport of fnameescape().
228 | function! pathogen#fnameescape(string) abort
229 |   if exists('*fnameescape')
230 |     return fnameescape(a:string)
231 |   elseif a:string ==# '-'
232 |     return '\-'
233 |   else
234 |     return substitute(escape(a:string," \t\n*?[{`$\\%#'\"|!<"),'^[+>]','\\&','')
235 |   endif
236 | endfunction
237 | 
238 | " Like findfile(), but hardcoded to use the runtimepath.
239 | function! pathogen#runtime_findfile(file,count) abort "{{{1
240 |   let rtp = pathogen#join(1,pathogen#split(&rtp))
241 |   let file = findfile(a:file,rtp,a:count)
242 |   if file ==# ''
243 |     return ''
244 |   else
245 |     return fnamemodify(file,':p')
246 |   endif
247 | endfunction
248 | 
249 | " Section: Deprecated
250 | 
251 | function! s:warn(msg) abort
252 |   echohl WarningMsg
253 |   echomsg a:msg
254 |   echohl NONE
255 | endfunction
256 | 
257 | " Prepend all subdirectories of path to the rtp, and append all 'after'
258 | " directories in those subdirectories.  Deprecated.
259 | function! pathogen#runtime_prepend_subdirectories(path) abort
260 |   call s:warn('Change pathogen#runtime_prepend_subdirectories('.string(a:path).') to pathogen#infect('.string(a:path.'/{}').')')
261 |   return pathogen#surround(a:path . pathogen#slash() . '{}')
262 | endfunction
263 | 
264 | function! pathogen#incubate(...) abort
265 |   let name = a:0 ? a:1 : 'bundle/{}'
266 |   call s:warn('Change pathogen#incubate('.(a:0 ? string(a:1) : '').') to pathogen#infect('.string(name).')')
267 |   return pathogen#interpose(name)
268 | endfunction
269 | 
270 | " Deprecated alias for pathogen#interpose().
271 | function! pathogen#runtime_append_all_bundles(...) abort
272 |   if a:0
273 |     call s:warn('Change pathogen#runtime_append_all_bundles('.string(a:1).') to pathogen#infect('.string(a:1.'/{}').')')
274 |   else
275 |     call s:warn('Change pathogen#runtime_append_all_bundles() to pathogen#infect()')
276 |   endif
277 |   return pathogen#interpose(a:0 ? a:1 . '/{}' : 'bundle/{}')
278 | endfunction
279 | 
280 | if exists(':Vedit')
281 |   finish
282 | endif
283 | 
284 | let s:vopen_warning = 0
285 | 
286 | function! s:find(count,cmd,file,lcd)
287 |   let rtp = pathogen#join(1,pathogen#split(&runtimepath))
288 |   let file = pathogen#runtime_findfile(a:file,a:count)
289 |   if file ==# ''
290 |     return "echoerr 'E345: Can''t find file \"".a:file."\" in runtimepath'"
291 |   endif
292 |   if !s:vopen_warning
293 |     let s:vopen_warning = 1
294 |     let warning = '|echohl WarningMsg|echo "Install scriptease.vim to continue using :V'.a:cmd.'"|echohl NONE'
295 |   else
296 |     let warning = ''
297 |   endif
298 |   if a:lcd
299 |     let path = file[0:-strlen(a:file)-2]
300 |     execute 'lcd `=path`'
301 |     return a:cmd.' '.pathogen#fnameescape(a:file) . warning
302 |   else
303 |     return a:cmd.' '.pathogen#fnameescape(file) . warning
304 |   endif
305 | endfunction
306 | 
307 | function! s:Findcomplete(A,L,P)
308 |   let sep = pathogen#slash()
309 |   let cheats = {
310 |         \'a': 'autoload',
311 |         \'d': 'doc',
312 |         \'f': 'ftplugin',
313 |         \'i': 'indent',
314 |         \'p': 'plugin',
315 |         \'s': 'syntax'}
316 |   if a:A =~# '^\w[\\/]' && has_key(cheats,a:A[0])
317 |     let request = cheats[a:A[0]].a:A[1:-1]
318 |   else
319 |     let request = a:A
320 |   endif
321 |   let pattern = substitute(request,'/\|\'.sep,'*'.sep,'g').'*'
322 |   let found = {}
323 |   for path in pathogen#split(&runtimepath)
324 |     let path = expand(path, ':p')
325 |     let matches = split(glob(path.sep.pattern),"\n")
326 |     call map(matches,'isdirectory(v:val) ? v:val.sep : v:val')
327 |     call map(matches,'expand(v:val, ":p")[strlen(path)+1:-1]')
328 |     for match in matches
329 |       let found[match] = 1
330 |     endfor
331 |   endfor
332 |   return sort(keys(found))
333 | endfunction
334 | 
335 | command! -bar -bang -range=1 -nargs=1 -complete=customlist,s:Findcomplete Ve       :execute s:find(<count>,'edit<bang>',<q-args>,0)
336 | command! -bar -bang -range=1 -nargs=1 -complete=customlist,s:Findcomplete Vedit    :execute s:find(<count>,'edit<bang>',<q-args>,0)
337 | command! -bar -bang -range=1 -nargs=1 -complete=customlist,s:Findcomplete Vopen    :execute s:find(<count>,'edit<bang>',<q-args>,1)
338 | command! -bar -bang -range=1 -nargs=1 -complete=customlist,s:Findcomplete Vsplit   :execute s:find(<count>,'split',<q-args>,<bang>1)
339 | command! -bar -bang -range=1 -nargs=1 -complete=customlist,s:Findcomplete Vvsplit  :execute s:find(<count>,'vsplit',<q-args>,<bang>1)
340 | command! -bar -bang -range=1 -nargs=1 -complete=customlist,s:Findcomplete Vtabedit :execute s:find(<count>,'tabedit',<q-args>,<bang>1)
341 | command! -bar -bang -range=1 -nargs=1 -complete=customlist,s:Findcomplete Vpedit   :execute s:find(<count>,'pedit',<q-args>,<bang>1)
342 | command! -bar -bang -range=1 -nargs=1 -complete=customlist,s:Findcomplete Vread    :execute s:find(<count>,'read',<q-args>,<bang>1)
343 | 
344 | " vim:set et sw=2 foldmethod=expr foldexpr=getline(v\:lnum)=~'^\"\ Section\:'?'>1'\:getline(v\:lnum)=~#'^fu'?'a1'\:getline(v\:lnum)=~#'^endf'?'s1'\:'=':
345 | 


--------------------------------------------------------------------------------
/gvimrc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/caike/vim-config/80150c11d0fd8d224814dec6ccdca43bc52778ff/gvimrc


--------------------------------------------------------------------------------
/solarized.zip:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/caike/vim-config/80150c11d0fd8d224814dec6ccdca43bc52778ff/solarized.zip


--------------------------------------------------------------------------------
/vimrc:
--------------------------------------------------------------------------------
 1 | call pathogen#infect()
 2 | call pathogen#helptags()
 3 | 
 4 | set nocompatible "ensures vim over vi
 5 | set number
 6 | set ruler "add line/column count to the bottom of screen
 7 | "syntax on
 8 | syntax enable
 9 | set noerrorbells visualbell t_vb= "turn off annoying bells
10 | set tags=.tags "destination file for ctags
11 | set softtabstop=2 "number of space chars a tab counts for
12 | set shiftwidth=2 "number of space chars for indentation
13 | set expandtab "insert space characters whenever the tab key is pressed
14 | set tabstop=2 "space chars inserted when tab key is pressed
15 | set autoindent
16 | 
17 | filetype plugin indent on
18 | 
19 | " For MacVim
20 | if has('gui_running')
21 |   syntax enable
22 |   set background=dark
23 |   colorscheme solarized
24 | endif
25 | 
26 | 
27 | set splitright "opens new split on the right
28 | set splitbelow "open new vsplit on the bottom
29 | 
30 | " Remove trailling whitespace on :w
31 | autocmd BufWritePre * :%s/\s\+$//e
32 | 
33 | " Incremental search
34 | set incsearch
35 | 
36 | highlight Cursor guibg=Green guifg=NONE
37 | 


--------------------------------------------------------------------------------