├── .gitignore
├── README.md
├── bundles.txt
├── quick-vim
├── screen.jpg
├── vim
    ├── .netrwhist
    ├── autoload
    │   └── pathogen.vim
    └── syntax
    │   └── arc.vim
└── vimrc


/.gitignore:
--------------------------------------------------------------------------------
1 | backup
2 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # quick-vim
 2 | 
 3 |                               {__                                      
 4 |                      {_       {__                       {_             
 5 |       {__   {__  {__      {___{__  {__      {__     {__   {___ {__ {__ 
 6 |     {_  {__ {__  {__{__ {__   {__ {__ {_____ {__   {__ {__ {__  {_  {__
 7 |     {_  {__ {__  {__{__{__    {_{__           {__ {__  {__ {__  {_  {__
 8 |      {__{__ {__  {__{__ {__   {__ {__          {_{__   {__ {__  {_  {__
 9 |         {__   {__{__{__   {___{__  {__          {__    {__{___  {_  {__
10 |         {___                   
11 |                                                                        
12 | Portable text exiting for devs.
13 | 
14 | ## the problem
15 | 
16 | When software does many things it sacrifices doing one thing very well. Instead of trying to make vim a clumsy "does it all" IDE `quick-vim` is lightweight, relies on simple defaults, thusly very portable and easily repeatable text editor. 
17 | 
18 | ## solution
19 | 
20 | - three use cases: install, upgrade, and uninstall
21 | - bash and git are the only deps
22 | - no goofy gui tty business; this is a vimrc for a vim that lives in a shell
23 | - pathogen for managing deps
24 | - bundles are limited to the simple stuff and not relearning things your shell does better: like git
25 | - no weird bundles that require re-compilation of vim or outside scripting languages
26 | - bundle config is in a plain text file stored in the root of this directory
27 | 
28 | <img src="https://github.com/brianleroux/quick-vim/raw/master/screen.jpg" />
29 | 
30 | ## the bundles for me
31 | 
32 | This is a portable text editor for doing dev on the run, in a shell, probably on a temporary machine, possibly drunk. Vim is surprisingly powerful stand-alone, odds are you don't *really* need a particular plugin bundle. Try to work with the stock install. You'll be surprised! And less, dependant on custom schemes. (Ironic words for a vim config project, I know.)
33 | 
34 | If you do need more, you can always fork this repo, create a branch, modify the bundles.txt to your hearts desire. If you find a bundle that meets the criteria above that you think I should check out: pls send a pull request!
35 | 
36 | ## usage
37 | 
38 | Getting started with `quick-vim` is easy:
39 | 
40 |     git clone git://github.com/brianleroux/quick-vim.git
41 |     cd quick-vim
42 |     ./quick-vim install
43 | 
44 | You can reset to the default/previous vim env simply:
45 | 
46 |     ./quick-vim uninstall
47 | 
48 | Brute force upgrade everything:
49 | 
50 |     ./quick-vim upgrade
51 | 
52 | And thats it.
53 | 
54 | 


--------------------------------------------------------------------------------
/bundles.txt:
--------------------------------------------------------------------------------
1 | https://github.com/scrooloose/nerdtree.git
2 | https://github.com/tpope/vim-surround.git
3 | https://github.com/pangloss/vim-javascript.git
4 | https://github.com/jonsmithers/vim-html-template-literals.git
5 | https://github.com/plasticboy/vim-markdown.git
6 | https://github.com/jonathanfilip/vim-lucius.git
7 | https://github.com/hashivim/vim-terraform.git
8 | 
9 | 


--------------------------------------------------------------------------------
/quick-vim:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | set -e
 3 | 
 4 | help () {
 5 |     cat<<EOF
 6 | 
 7 | Usage: quick-vim [install|uninstall|upgrade|help]
 8 | 
 9 | Commands:
10 |     
11 |     install    installs from the git repo
12 |     uninstall  restores original system vim config
13 |     upgrade    clobbers existing setup and installs fresh from git
14 |     help       print this msg
15 | 
16 | EOF
17 | }
18 | 
19 | # backs default home vim up
20 | backup () {
21 |     if [ -e ./backup ]
22 |     then 
23 |         echo 'skipping backup'
24 |     else
25 |         mkdir -p ./backup
26 |         if [ -e ~/.vimrc ]
27 |         then
28 |             mv ~/.vimrc ./backup/.vimrc
29 |         fi
30 |         if [ -e ~/.vim ]
31 |         then
32 |             mv ~/.vim ./backup/.vim
33 |         fi
34 |     fi
35 | }
36 | 
37 | # copy in pathogen and then clone in bundles
38 | install () {
39 |     backup
40 | 
41 |     # copy in vimrc and pathogen
42 |     cp ./vimrc ~/.vimrc
43 |     cp -r ./vim ~/.vim
44 | 
45 |     # add in bundles from bundle.txt
46 |     mkdir -p ~/.vim/bundle
47 |     bundles=$(cat ./bundles.txt)
48 |     cd ~/.vim/bundle
49 |     for repo in $bundles; do
50 |         git clone $repo
51 |     done
52 | }
53 | 
54 | # if backup exists clobbers home vim and copies in backup
55 | uninstall () {
56 |     if [ -e ./backup ]
57 |     then
58 |         rm ~/.vimrc
59 |         rm -rf ~/.vim
60 |         if [ -e ./backup/.vimrc ]
61 |         then
62 |             mv ./backup/.vimrc ~/.vimrc
63 |         fi
64 |         if [ -e ./backup/.vim ]
65 |         then
66 |             mv ./backup/.vim ~/.vim
67 |         fi
68 |         rm -rf ./backup
69 |     fi
70 | }
71 | 
72 | # kills everything, pulls latest from git, installs it
73 | upgrade () {
74 |     uninstall
75 |     git pull
76 |     install
77 | }
78 | 
79 | # fucking cryptic bash, test for a valid arg and execute it if so; otherwise show the help
80 | if [ "$1" != "" ]; then
81 |     wl=(install uninstall upgrade help)
82 |     for i in "${wl[@]}"
83 |     do
84 |         if [ "$i" == "$1" ]
85 |         then
86 |             $1
87 |             exit 0
88 |         fi
89 |     done
90 | fi
91 | 
92 | # show a flailer some help
93 | help 
94 | exit 0
95 | 


--------------------------------------------------------------------------------
/screen.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/brianleroux/quick-vim/2a66355841b315bedae0d576e2af5dfe5120614a/screen.jpg


--------------------------------------------------------------------------------
/vim/.netrwhist:
--------------------------------------------------------------------------------
1 | let g:netrw_dirhistmax  =10
2 | let g:netrw_dirhist_cnt =2
3 | 


--------------------------------------------------------------------------------
/vim/autoload/pathogen.vim:
--------------------------------------------------------------------------------
  1 | " pathogen.vim - path option manipulation
  2 | " Maintainer:   Tim Pope <http://tpo.pe/>
  3 | " Version:      2.0
  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 `call pathogen#infect()` to your .vimrc
  9 | " prior to `filetype plugin indent on` is the only other setup necessary.
 10 | "
 11 | " The API is documented inline below.  For maximum ease of reading,
 12 | " :set foldmethod=marker
 13 | 
 14 | if exists("g:loaded_pathogen") || &cp
 15 |   finish
 16 | endif
 17 | let g:loaded_pathogen = 1
 18 | 
 19 | " Point of entry for basic default usage.  Give a directory name to invoke
 20 | " pathogen#runtime_append_all_bundles() (defaults to "bundle"), or a full path
 21 | " to invoke pathogen#runtime_prepend_subdirectories().  Afterwards,
 22 | " pathogen#cycle_filetype() is invoked.
 23 | function! pathogen#infect(...) abort " {{{1
 24 |   let source_path = a:0 ? a:1 : 'bundle'
 25 |   if source_path =~# '[\\/]'
 26 |     call pathogen#runtime_prepend_subdirectories(source_path)
 27 |   else
 28 |     call pathogen#runtime_append_all_bundles(source_path)
 29 |   endif
 30 |   call pathogen#cycle_filetype()
 31 | endfunction " }}}1
 32 | 
 33 | " Split a path into a list.
 34 | function! pathogen#split(path) abort " {{{1
 35 |   if type(a:path) == type([]) | return a:path | endif
 36 |   let split = split(a:path,'\\\@<!\%(\\\\\)*\zs,')
 37 |   return map(split,'substitute(v:val,''\\\([\\,]\)'',''\1'',"g")')
 38 | endfunction " }}}1
 39 | 
 40 | " Convert a list to a path.
 41 | function! pathogen#join(...) abort " {{{1
 42 |   if type(a:1) == type(1) && a:1
 43 |     let i = 1
 44 |     let space = ' '
 45 |   else
 46 |     let i = 0
 47 |     let space = ''
 48 |   endif
 49 |   let path = ""
 50 |   while i < a:0
 51 |     if type(a:000[i]) == type([])
 52 |       let list = a:000[i]
 53 |       let j = 0
 54 |       while j < len(list)
 55 |         let escaped = substitute(list[j],'[,'.space.']\|\\[\,'.space.']\@=','\\&','g')
 56 |         let path .= ',' . escaped
 57 |         let j += 1
 58 |       endwhile
 59 |     else
 60 |       let path .= "," . a:000[i]
 61 |     endif
 62 |     let i += 1
 63 |   endwhile
 64 |   return substitute(path,'^,','','')
 65 | endfunction " }}}1
 66 | 
 67 | " Convert a list to a path with escaped spaces for 'path', 'tag', etc.
 68 | function! pathogen#legacyjoin(...) abort " {{{1
 69 |   return call('pathogen#join',[1] + a:000)
 70 | endfunction " }}}1
 71 | 
 72 | " Remove duplicates from a list.
 73 | function! pathogen#uniq(list) abort " {{{1
 74 |   let i = 0
 75 |   let seen = {}
 76 |   while i < len(a:list)
 77 |     if (a:list[i] ==# '' && exists('empty')) || has_key(seen,a:list[i])
 78 |       call remove(a:list,i)
 79 |     elseif a:list[i] ==# ''
 80 |       let i += 1
 81 |       let empty = 1
 82 |     else
 83 |       let seen[a:list[i]] = 1
 84 |       let i += 1
 85 |     endif
 86 |   endwhile
 87 |   return a:list
 88 | endfunction " }}}1
 89 | 
 90 | " \ on Windows unless shellslash is set, / everywhere else.
 91 | function! pathogen#separator() abort " {{{1
 92 |   return !exists("+shellslash") || &shellslash ? '/' : '\'
 93 | endfunction " }}}1
 94 | 
 95 | " Convenience wrapper around glob() which returns a list.
 96 | function! pathogen#glob(pattern) abort " {{{1
 97 |   let files = split(glob(a:pattern),"\n")
 98 |   return map(files,'substitute(v:val,"[".pathogen#separator()."/]$","","")')
 99 | endfunction "}}}1
100 | 
101 | " Like pathogen#glob(), only limit the results to directories.
102 | function! pathogen#glob_directories(pattern) abort " {{{1
103 |   return filter(pathogen#glob(a:pattern),'isdirectory(v:val)')
104 | endfunction "}}}1
105 | 
106 | " Turn filetype detection off and back on again if it was already enabled.
107 | function! pathogen#cycle_filetype() " {{{1
108 |   if exists('g:did_load_filetypes')
109 |     filetype off
110 |     filetype on
111 |   endif
112 | endfunction " }}}1
113 | 
114 | " Checks if a bundle is 'disabled'. A bundle is considered 'disabled' if
115 | " its 'basename()' is included in g:pathogen_disabled[]' or ends in a tilde.
116 | function! pathogen#is_disabled(path) " {{{1
117 |   if a:path =~# '\~$'
118 |     return 1
119 |   elseif !exists("g:pathogen_disabled")
120 |     return 0
121 |   endif
122 |   let sep = pathogen#separator()
123 |   return index(g:pathogen_disabled, strpart(a:path, strridx(a:path, sep)+1)) != -1
124 | endfunction "}}}1
125 | 
126 | " Prepend all subdirectories of path to the rtp, and append all 'after'
127 | " directories in those subdirectories.
128 | function! pathogen#runtime_prepend_subdirectories(path) " {{{1
129 |   let sep    = pathogen#separator()
130 |   let before = filter(pathogen#glob_directories(a:path.sep."*"), '!pathogen#is_disabled(v:val)')
131 |   let after  = filter(pathogen#glob_directories(a:path.sep."*".sep."after"), '!pathogen#is_disabled(v:val[0:-7])')
132 |   let rtp = pathogen#split(&rtp)
133 |   let path = expand(a:path)
134 |   call filter(rtp,'v:val[0:strlen(path)-1] !=# path')
135 |   let &rtp = pathogen#join(pathogen#uniq(before + rtp + after))
136 |   return &rtp
137 | endfunction " }}}1
138 | 
139 | " For each directory in rtp, check for a subdirectory named dir.  If it
140 | " exists, add all subdirectories of that subdirectory to the rtp, immediately
141 | " after the original directory.  If no argument is given, 'bundle' is used.
142 | " Repeated calls with the same arguments are ignored.
143 | function! pathogen#runtime_append_all_bundles(...) " {{{1
144 |   let sep = pathogen#separator()
145 |   let name = a:0 ? a:1 : 'bundle'
146 |   if "\n".s:done_bundles =~# "\\M\n".name."\n"
147 |     return ""
148 |   endif
149 |   let s:done_bundles .= name . "\n"
150 |   let list = []
151 |   for dir in pathogen#split(&rtp)
152 |     if dir =~# '\<after$'
153 |       let list +=  filter(pathogen#glob_directories(substitute(dir,'after$',name,'').sep.'*[^~]'.sep.'after'), '!pathogen#is_disabled(v:val[0:-7])') + [dir]
154 |     else
155 |       let list +=  [dir] + filter(pathogen#glob_directories(dir.sep.name.sep.'*[^~]'), '!pathogen#is_disabled(v:val)')
156 |     endif
157 |   endfor
158 |   let &rtp = pathogen#join(pathogen#uniq(list))
159 |   return 1
160 | endfunction
161 | 
162 | let s:done_bundles = ''
163 | " }}}1
164 | 
165 | " Invoke :helptags on all non-$VIM doc directories in runtimepath.
166 | function! pathogen#helptags() " {{{1
167 |   let sep = pathogen#separator()
168 |   for dir in pathogen#split(&rtp)
169 |     if (dir.sep)[0 : strlen($VIMRUNTIME)] !=# $VIMRUNTIME.sep && filewritable(dir.sep.'doc') == 2 && !empty(glob(dir.sep.'doc'.sep.'*')) && (!filereadable(dir.sep.'doc'.sep.'tags') || filewritable(dir.sep.'doc'.sep.'tags'))
170 |       helptags `=dir.'/doc'`
171 |     endif
172 |   endfor
173 | endfunction " }}}1
174 | 
175 | command! -bar Helptags :call pathogen#helptags()
176 | 
177 | " Like findfile(), but hardcoded to use the runtimepath.
178 | function! pathogen#runtime_findfile(file,count) "{{{1
179 |   let rtp = pathogen#join(1,pathogen#split(&rtp))
180 |   return fnamemodify(findfile(a:file,rtp,a:count),':p')
181 | endfunction " }}}1
182 | 
183 | " Backport of fnameescape().
184 | function! pathogen#fnameescape(string) " {{{1
185 |   if exists('*fnameescape')
186 |     return fnameescape(a:string)
187 |   elseif a:string ==# '-'
188 |     return '\-'
189 |   else
190 |     return substitute(escape(a:string," \t\n*?[{`$\\%#'\"|!<"),'^[+>]','\\&','')
191 |   endif
192 | endfunction " }}}1
193 | 
194 | function! s:find(count,cmd,file,lcd) " {{{1
195 |   let rtp = pathogen#join(1,pathogen#split(&runtimepath))
196 |   let file = pathogen#runtime_findfile(a:file,a:count)
197 |   if file ==# ''
198 |     return "echoerr 'E345: Can''t find file \"".a:file."\" in runtimepath'"
199 |   elseif a:lcd
200 |     let path = file[0:-strlen(a:file)-2]
201 |     execute 'lcd `=path`'
202 |     return a:cmd.' '.pathogen#fnameescape(a:file)
203 |   else
204 |     return a:cmd.' '.pathogen#fnameescape(file)
205 |   endif
206 | endfunction " }}}1
207 | 
208 | function! s:Findcomplete(A,L,P) " {{{1
209 |   let sep = pathogen#separator()
210 |   let cheats = {
211 |         \'a': 'autoload',
212 |         \'d': 'doc',
213 |         \'f': 'ftplugin',
214 |         \'i': 'indent',
215 |         \'p': 'plugin',
216 |         \'s': 'syntax'}
217 |   if a:A =~# '^\w[\\/]' && has_key(cheats,a:A[0])
218 |     let request = cheats[a:A[0]].a:A[1:-1]
219 |   else
220 |     let request = a:A
221 |   endif
222 |   let pattern = substitute(request,'\'.sep,'*'.sep,'g').'*'
223 |   let found = {}
224 |   for path in pathogen#split(&runtimepath)
225 |     let path = expand(path, ':p')
226 |     let matches = split(glob(path.sep.pattern),"\n")
227 |     call map(matches,'isdirectory(v:val) ? v:val.sep : v:val')
228 |     call map(matches,'expand(v:val, ":p")[strlen(path)+1:-1]')
229 |     for match in matches
230 |       let found[match] = 1
231 |     endfor
232 |   endfor
233 |   return sort(keys(found))
234 | endfunction " }}}1
235 | 
236 | command! -bar -bang -range=1 -nargs=1 -complete=customlist,s:Findcomplete Ve       :execute s:find(<count>,'edit<bang>',<q-args>,0)
237 | command! -bar -bang -range=1 -nargs=1 -complete=customlist,s:Findcomplete Vedit    :execute s:find(<count>,'edit<bang>',<q-args>,0)
238 | command! -bar -bang -range=1 -nargs=1 -complete=customlist,s:Findcomplete Vopen    :execute s:find(<count>,'edit<bang>',<q-args>,1)
239 | command! -bar -bang -range=1 -nargs=1 -complete=customlist,s:Findcomplete Vsplit   :execute s:find(<count>,'split',<q-args>,<bang>1)
240 | command! -bar -bang -range=1 -nargs=1 -complete=customlist,s:Findcomplete Vvsplit  :execute s:find(<count>,'vsplit',<q-args>,<bang>1)
241 | command! -bar -bang -range=1 -nargs=1 -complete=customlist,s:Findcomplete Vtabedit :execute s:find(<count>,'tabedit',<q-args>,<bang>1)
242 | command! -bar -bang -range=1 -nargs=1 -complete=customlist,s:Findcomplete Vpedit   :execute s:find(<count>,'pedit',<q-args>,<bang>1)
243 | command! -bar -bang -range=1 -nargs=1 -complete=customlist,s:Findcomplete Vread    :execute s:find(<count>,'read',<q-args>,<bang>1)
244 | 
245 | " vim:set ft=vim ts=8 sw=2 sts=2:
246 | 


--------------------------------------------------------------------------------
/vim/syntax/arc.vim:
--------------------------------------------------------------------------------
 1 | syntax region arcAppSection start=/\v\@app/ skip=/\v\\./ end="\v\@="
 2 | syntax region arcHtmlSection start=/\v\@http/ skip=/\v\\./ end="\v\@="
 3 | syntax region arcJsonSection start=/\v\@queues/ skip=/\v\\./ end="\v\@="
 4 | syntax region arcJsonSection start=/\v\@static/ skip=/\v\\./ end="\v\@="
 5 | syntax region arcJsonSection start=/\v\@domain/ skip=/\v\\./ end="\v\@="
 6 | syntax region arcJsonSection start=/\v\@aws/ skip=/\v\\./ end="\v\@="
 7 | syntax region arcJsonSection start=/\v\@ws/ skip=/\v\\./ end="\v\@="
 8 | syntax region arcEventsSection start=/\v\@events/ skip=/\v\\./ end="\v\@="
 9 | syntax region arcTablesSection start=/\v\@tables/ skip=/\v\\./ end="\v\@="
10 | syntax region arcIndexesSection start=/\v\@tables-indexes/ skip=/\v\\./ end="\v\@="
11 | syntax region arcIndexesSection start=/\v\@indexes/ skip=/\v\\./ end="\v\@="
12 | syntax region arcScheduledSection start=/\v\@scheduled/ skip=/\v\\./ end="\v\@=" 
13 | syntax region arcScheduledSection start=/\v\@cdn/ skip=/\v\\./ end="\v\@=" 
14 | syntax region arcScheduledSection start=/\v\@plugins/ skip=/\v\\./ end="\v\@=" 
15 | 
16 | syntax match Comments "\v#.*$"
17 | syntax match HTTP "\vget|post|put|patch|delete|any"
18 | syntax match URL "\v\/\S+|\/"
19 | 
20 | "highlight Normal ctermfg=47
21 | highlight link Comments Comment
22 | highlight HTTP ctermfg=72 ctermbg=NONE cterm=NONE
23 | highlight URL ctermfg=47 ctermbg=NONE cterm=NONE
24 | 
25 | highlight arcAppSection ctermfg=35
26 | highlight arcHtmlSection ctermfg=35
27 | highlight arcJsonSection ctermfg=35
28 | highlight arcEventsSection ctermfg=35
29 | highlight arcTablesSection ctermfg=35
30 | highlight arcIndexesSection ctermfg=35
31 | highlight arcScheduledSection ctermfg=35
32 | 


--------------------------------------------------------------------------------
/vimrc:
--------------------------------------------------------------------------------
 1 | call pathogen#infect()
 2 | syntax on
 3 | filetype plugin indent on
 4 | set nofoldenable
 5 | set nocompatible
 6 | set nobackup
 7 | set nowb
 8 | set noswapfile
 9 | set ic
10 | set mouse=a 
11 | 
12 | " syntax highligting
13 | syntax enable
14 | colorscheme lucius 
15 | LuciusDark
16 | 
17 | " add arcfile support
18 | au BufRead,BufNewFile *.arc set filetype=arc
19 | 
20 | " make subshell way more obvs
21 | let $DGREY="\e[0;36m"
22 | let $ENDCOLOR="\e[0m"
23 | let $PS1="$DGREY#! $ENDCOLOR"
24 | 
25 | " get rid of the VertSplit | uglyness
26 | set fillchars+=vert:\ 
27 | hi VertSplit ctermbg=NONE
28 | 
29 | " hide the status message bar
30 | set noshowmode
31 | set noruler
32 | set laststatus=0
33 | set noshowcmd
34 | 
35 | " quiet pls
36 | set visualbell t_vb=
37 | 
38 | " 2 space softabs default
39 | set expandtab
40 | set ts=2
41 | set sw=2
42 | 
43 | " reset leader
44 | let maplocalleader = ","
45 | 
46 | " :Toggle the nerdtree
47 | " \+n toggles the nerdtree
48 | " ,+n toggles the nerdtree
49 | command Toggle NERDTreeToggle
50 | map <leader>n :Toggle<CR>
51 | map <localleader>n :Toggle<CR>
52 | 
53 | " hide the annoying Press ? for help in NerdTree
54 | let NERDTreeIgnore = ['node_modules'] " show with 'f'
55 | let NERDTreeMinimalUI = 1
56 | let NERDTreeDirArrows = 1
57 | hi NERDTreeFile ctermfg=darkgrey ctermbg=none cterm=none
58 | 
59 | " no need to fold things in markdown all the time
60 | let g:vim_markdown_folding_disabled = 1
61 | 


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