├── .gitignore
├── README.md
├── autoload
    └── plug.vim
├── colors
    ├── forgotten-dark.vim
    ├── forgotten-light.vim
    ├── material-monokai.vim
    ├── office-dark.vim
    ├── office-light.vim
    ├── vrunchbang-dark.vim
    └── vrunchbang-light.vim
├── img
    └── putty-setting.PNG
└── vimrc


/.gitignore:
--------------------------------------------------------------------------------
 1 | # Created by https://www.gitignore.io/api/vim
 2 | 
 3 | ### Vim ###
 4 | # swap
 5 | .sw[a-p]
 6 | .*.sw[a-p]
 7 | # session
 8 | Session.vim
 9 | # temporary
10 | .netrwhist
11 | *~
12 | # auto-generated tag files
13 | tags
14 | 
15 | # End of https://www.gitignore.io/api/vim
16 | 
17 | /plugged
18 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # yonghyuk's vimrc
  2 | 
  3 | ## 설치
  4 | 
  5 | ```bash
  6 | cd ~/
  7 | git clone https://github.com/dbdydgur2244/vim-setting .vim
  8 | ln -s ~/.vim/vimrc ~/.vimrc
  9 | vim -c ":PlugInstall" -c ":q" -c ":q"
 10 | ```
 11 | 
 12 | 
 13 | 
 14 | ## Vim
 15 | 
 16 | ### Leader Key
 17 | 
 18 | 현재 Leader key는 `,`로 되어있음
 19 | 
 20 | 
 21 | 
 22 | ### map과 noremap의 차이
 23 | 
 24 | `map`과 `noremap`은 각각  둘다 **normal** mode, **visual** mode and other modes에서 모두 작동함. 둘의 차이는 **recursive** and **non-recursive**임. 다음과 같이 세팅을 했다고 하자.
 25 | 
 26 | ```
 27 | :map j gg
 28 | :map Q j
 29 | :noremap W j
 30 | ```
 31 | 
 32 | 그렇다면 `map`의 경우 `Q`, `j` 모두 `gg`로 mapping되어 있을 것이다. 하지만 `noremap`은 `W`는 `j`로 세팅되어 있을 것이다.
 33 | 
 34 | `nnoremap`의 경우는  `noremap`과 기능은 같지만 **normal** mode에서만 작동한다.
 35 | 
 36 | |       명령어       |                  설명                  |
 37 | | :-------------: | :----------------------------------: |
 38 | |    **`F2`**     |                  저장                  |
 39 | |    **`F3`**     |            nerdtree 창 띄어줌            |
 40 | |    **`,cc`**    |           해당하는 line에 주석을 담           |
 41 | | **`,c<space>`** | 해당하는 line에 주석을 다는데 다시 명령어를 치면 주석 사라짐 |
 42 | |  **` Ctrl-p`**  |             ctrlp 창 띄어줌              |
 43 | 
 44 | 
 45 | 
 46 | ## Plugin
 47 | 
 48 | ### nerdtree
 49 | 
 50 | vim용 탐색기이다. vim창에서 쉽게 파일 탐색가능하다.
 51 | 
 52 | `Ctrl+f`를 누르면 현재 파일을 찾아준다. 숨김파일을 보려면 I를 누르면 볼 수 있다.
 53 | 
 54 | 
 55 | 
 56 | ### vim-airline
 57 | 
 58 | buffer에 쌓여있는 파일들을 시각화해서 보여주고 하단에 현재 모드를 표시해준다.
 59 | 
 60 | 
 61 | 
 62 | ### vim-airline-themes
 63 | 
 64 | vim-airline theme plugin
 65 | 
 66 | 
 67 | 
 68 | ### vim-cpp-highlighting
 69 | 
 70 | c++ syntax highlighting plugin이다. c++11기준으로 세팅하였다.
 71 | 
 72 | 
 73 | 
 74 | ### python-syntax
 75 | 
 76 | python syntax highlighting plugin이다. python3 기준으로 세팅하였다.
 77 | 
 78 | python2로 바꾸려면 `Python2Syntax`를 입력하면 된다. 마찬가지로 python3는 `Python2Syntax`이다.
 79 | 
 80 | 
 81 | 
 82 | ### vim-fugitive
 83 | 
 84 | git 명령을 vim에서 사용할 수 있게 git을 래핑한 플러그인이다. 로그 보기, 체크아웃, 상태 보기 등 git의 기능을 대부분 사용할 수 있다. git 기능을 안쓰더라도 설치만 해두면 **vim-airline**플러그인과 연동되어 상태바에 현재 브랜치를 띄울 수 있기 때문에 편리하다.
 85 | 
 86 | 
 87 | 
 88 | ### vim-gitgutter
 89 | 
 90 | **vim-gitgutter**는 git으로 관리하는 파일의 변경된 부분을 Vim에서 확인할 수 있는 플러그인이다.
 91 | 
 92 | 
 93 | 
 94 | ### ctrlp
 95 | 
 96 | Vim에서 파일을 빠르게 찾을 수 있는 기능을 제공한다. 현재 `Ctrl+p`를 누르면 실행된다. `Ctrl+f`를 눌러서 `mru`, `file`, `buffer`를 선택하여 파일을 찾을 수 있다.
 97 | 
 98 | 
 99 | 
100 | ### html
101 | 
102 | html syntax highlighting  plugin
103 | 
104 | 
105 | 
106 | ### nerdcommenter
107 | 
108 | 언어를 고려하지 않고 쉽게 주석을 달 수 있는 plugin이다. **`,c<space>`**를 통해서 주석을 달 수 있다. 다시 입력하면 주석이 사라진다.
109 | 
110 | 
111 | 
112 | ### vim-easy-align
113 | 
114 | vim 자동정렬 plugin이다. 이 plugin은 설명을 읽어보는 것이 좋다. 기능이 너무 많다. 
115 | 
116 | https://github.com/junegunn/vim-easy-align
117 | 
118 | 
119 | 
120 | ### Indent Guides
121 | 
122 | Indent Guides는 indent level을 시각화해서 보여주는 plugin이다. vim에서 다음과 같은 명령어로 활성화 또는 비활성화 가능.
123 | 
124 | ```
125 | :IndentGuidesEnable
126 | :IndentGuidesDisable
127 | :IndentGuidesToggle
128 | ```
129 | 
130 | 
131 | 
132 | ## putty인 경우
133 | 
134 | 기본적으로 putty 색깔은 너무 이쁘지 않다.
135 | 
136 | 고로 다음과 사진과 같이 Window-Colours에서 색깔들을 바꿔주어야함.
137 | 
138 | ![screensh](https://github.com/dbdydgur2244/vim-setting/blob/master/img/putty-setting.PNG)
139 | 
140 | 다음과 같이 바꾸면 된다. 이는 원하는대로 좀 수정하시길 바람.
141 | 
142 | - Default Foreground - 255/255/255
143 | - Default Background - 51/51/51
144 | - ANSI Black - 77/77/77
145 | - ANSI Green - 152/251/152
146 | - ANSI Yellow - 240/230/140
147 | - ANSI Blue - 205/133/63
148 | - ANSI Blue Bold -135/206/235
149 | - ANSI Magenta - 255/222/173 or 205/92/92
150 | - ANSI Cyan - 255/160/160
151 | - ANSI Cyan Bold - 255/215/0
152 | - ANSI White - 245/222/179
153 | 
154 | 
155 | 
156 | 
157 | ## Terminal인 경우
158 | 
159 | iTerm을 사용합시다. 다음 링크에서 맘에 드는 color scheme를 적용해서 사용
160 | 
161 | http://iterm2colorschemes.com/
162 | 
163 | 
164 | 
165 | iTerm2 + Oh My Zsh + Solarized color scheme + Meslo powerline font + [Powerlevel9k]  조합 추천드림
166 | 
167 | https://gist.github.com/kevin-smets/8568070
168 | 
169 | 
170 | 
171 | 
172 | 
173 | 


--------------------------------------------------------------------------------
/autoload/plug.vim:
--------------------------------------------------------------------------------
   1 | " vim-plug: Vim plugin manager
   2 | " ============================
   3 | "
   4 | " Download plug.vim and put it in ~/.vim/autoload
   5 | "
   6 | "   curl -fLo ~/.vim/autoload/plug.vim --create-dirs \
   7 | "     https://raw.githubusercontent.com/junegunn/vim-plug/master/plug.vim
   8 | "
   9 | " Edit your .vimrc
  10 | "
  11 | "   call plug#begin('~/.vim/plugged')
  12 | "
  13 | "   " Make sure you use single quotes
  14 | "
  15 | "   " Shorthand notation; fetches https://github.com/junegunn/vim-easy-align
  16 | "   Plug 'junegunn/vim-easy-align'
  17 | "
  18 | "   " Any valid git URL is allowed
  19 | "   Plug 'https://github.com/junegunn/vim-github-dashboard.git'
  20 | "
  21 | "   " Multiple Plug commands can be written in a single line using | separators
  22 | "   Plug 'SirVer/ultisnips' | Plug 'honza/vim-snippets'
  23 | "
  24 | "   " On-demand loading
  25 | "   Plug 'scrooloose/nerdtree', { 'on':  'NERDTreeToggle' }
  26 | "   Plug 'tpope/vim-fireplace', { 'for': 'clojure' }
  27 | "
  28 | "   " Using a non-master branch
  29 | "   Plug 'rdnetto/YCM-Generator', { 'branch': 'stable' }
  30 | "
  31 | "   " Using a tagged release; wildcard allowed (requires git 1.9.2 or above)
  32 | "   Plug 'fatih/vim-go', { 'tag': '*' }
  33 | "
  34 | "   " Plugin options
  35 | "   Plug 'nsf/gocode', { 'tag': 'v.20150303', 'rtp': 'vim' }
  36 | "
  37 | "   " Plugin outside ~/.vim/plugged with post-update hook
  38 | "   Plug 'junegunn/fzf', { 'dir': '~/.fzf', 'do': './install --all' }
  39 | "
  40 | "   " Unmanaged plugin (manually installed and updated)
  41 | "   Plug '~/my-prototype-plugin'
  42 | "
  43 | "   " Initialize plugin system
  44 | "   call plug#end()
  45 | "
  46 | " Then reload .vimrc and :PlugInstall to install plugins.
  47 | "
  48 | " Plug options:
  49 | "
  50 | "| Option                  | Description                                      |
  51 | "| ----------------------- | ------------------------------------------------ |
  52 | "| `branch`/`tag`/`commit` | Branch/tag/commit of the repository to use       |
  53 | "| `rtp`                   | Subdirectory that contains Vim plugin            |
  54 | "| `dir`                   | Custom directory for the plugin                  |
  55 | "| `as`                    | Use different name for the plugin                |
  56 | "| `do`                    | Post-update hook (string or funcref)             |
  57 | "| `on`                    | On-demand loading: Commands or `<Plug>`-mappings |
  58 | "| `for`                   | On-demand loading: File types                    |
  59 | "| `frozen`                | Do not update unless explicitly specified        |
  60 | "
  61 | " More information: https://github.com/junegunn/vim-plug
  62 | "
  63 | "
  64 | " Copyright (c) 2017 Junegunn Choi
  65 | "
  66 | " MIT License
  67 | "
  68 | " Permission is hereby granted, free of charge, to any person obtaining
  69 | " a copy of this software and associated documentation files (the
  70 | " "Software"), to deal in the Software without restriction, including
  71 | " without limitation the rights to use, copy, modify, merge, publish,
  72 | " distribute, sublicense, and/or sell copies of the Software, and to
  73 | " permit persons to whom the Software is furnished to do so, subject to
  74 | " the following conditions:
  75 | "
  76 | " The above copyright notice and this permission notice shall be
  77 | " included in all copies or substantial portions of the Software.
  78 | "
  79 | " THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  80 | " EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  81 | " MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  82 | " NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  83 | " LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  84 | " OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  85 | " WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  86 | 
  87 | if exists('g:loaded_plug')
  88 |   finish
  89 | endif
  90 | let g:loaded_plug = 1
  91 | 
  92 | let s:cpo_save = &cpo
  93 | set cpo&vim
  94 | 
  95 | let s:plug_src = 'https://github.com/junegunn/vim-plug.git'
  96 | let s:plug_tab = get(s:, 'plug_tab', -1)
  97 | let s:plug_buf = get(s:, 'plug_buf', -1)
  98 | let s:mac_gui = has('gui_macvim') && has('gui_running')
  99 | let s:is_win = has('win32') || has('win64')
 100 | let s:nvim = has('nvim-0.2') || (has('nvim') && exists('*jobwait') && !s:is_win)
 101 | let s:vim8 = has('patch-8.0.0039') && exists('*job_start')
 102 | let s:me = resolve(expand('<sfile>:p'))
 103 | let s:base_spec = { 'branch': 'master', 'frozen': 0 }
 104 | let s:TYPE = {
 105 | \   'string':  type(''),
 106 | \   'list':    type([]),
 107 | \   'dict':    type({}),
 108 | \   'funcref': type(function('call'))
 109 | \ }
 110 | let s:loaded = get(s:, 'loaded', {})
 111 | let s:triggers = get(s:, 'triggers', {})
 112 | 
 113 | function! plug#begin(...)
 114 |   if a:0 > 0
 115 |     let s:plug_home_org = a:1
 116 |     let home = s:path(fnamemodify(expand(a:1), ':p'))
 117 |   elseif exists('g:plug_home')
 118 |     let home = s:path(g:plug_home)
 119 |   elseif !empty(&rtp)
 120 |     let home = s:path(split(&rtp, ',')[0]) . '/plugged'
 121 |   else
 122 |     return s:err('Unable to determine plug home. Try calling plug#begin() with a path argument.')
 123 |   endif
 124 |   if fnamemodify(home, ':t') ==# 'plugin' && fnamemodify(home, ':h') ==# s:first_rtp
 125 |     return s:err('Invalid plug home. '.home.' is a standard Vim runtime path and is not allowed.')
 126 |   endif
 127 | 
 128 |   let g:plug_home = home
 129 |   let g:plugs = {}
 130 |   let g:plugs_order = []
 131 |   let s:triggers = {}
 132 | 
 133 |   call s:define_commands()
 134 |   return 1
 135 | endfunction
 136 | 
 137 | function! s:define_commands()
 138 |   command! -nargs=+ -bar Plug call plug#(<args>)
 139 |   if !executable('git')
 140 |     return s:err('`git` executable not found. Most commands will not be available. To suppress this message, prepend `silent!` to `call plug#begin(...)`.')
 141 |   endif
 142 |   command! -nargs=* -bar -bang -complete=customlist,s:names PlugInstall call s:install(<bang>0, [<f-args>])
 143 |   command! -nargs=* -bar -bang -complete=customlist,s:names PlugUpdate  call s:update(<bang>0, [<f-args>])
 144 |   command! -nargs=0 -bar -bang PlugClean call s:clean(<bang>0)
 145 |   command! -nargs=0 -bar PlugUpgrade if s:upgrade() | execute 'source' s:esc(s:me) | endif
 146 |   command! -nargs=0 -bar PlugStatus  call s:status()
 147 |   command! -nargs=0 -bar PlugDiff    call s:diff()
 148 |   command! -nargs=? -bar -bang -complete=file PlugSnapshot call s:snapshot(<bang>0, <f-args>)
 149 | endfunction
 150 | 
 151 | function! s:to_a(v)
 152 |   return type(a:v) == s:TYPE.list ? a:v : [a:v]
 153 | endfunction
 154 | 
 155 | function! s:to_s(v)
 156 |   return type(a:v) == s:TYPE.string ? a:v : join(a:v, "\n") . "\n"
 157 | endfunction
 158 | 
 159 | function! s:glob(from, pattern)
 160 |   return s:lines(globpath(a:from, a:pattern))
 161 | endfunction
 162 | 
 163 | function! s:source(from, ...)
 164 |   let found = 0
 165 |   for pattern in a:000
 166 |     for vim in s:glob(a:from, pattern)
 167 |       execute 'source' s:esc(vim)
 168 |       let found = 1
 169 |     endfor
 170 |   endfor
 171 |   return found
 172 | endfunction
 173 | 
 174 | function! s:assoc(dict, key, val)
 175 |   let a:dict[a:key] = add(get(a:dict, a:key, []), a:val)
 176 | endfunction
 177 | 
 178 | function! s:ask(message, ...)
 179 |   call inputsave()
 180 |   echohl WarningMsg
 181 |   let answer = input(a:message.(a:0 ? ' (y/N/a) ' : ' (y/N) '))
 182 |   echohl None
 183 |   call inputrestore()
 184 |   echo "\r"
 185 |   return (a:0 && answer =~? '^a') ? 2 : (answer =~? '^y') ? 1 : 0
 186 | endfunction
 187 | 
 188 | function! s:ask_no_interrupt(...)
 189 |   try
 190 |     return call('s:ask', a:000)
 191 |   catch
 192 |     return 0
 193 |   endtry
 194 | endfunction
 195 | 
 196 | function! plug#end()
 197 |   if !exists('g:plugs')
 198 |     return s:err('Call plug#begin() first')
 199 |   endif
 200 | 
 201 |   if exists('#PlugLOD')
 202 |     augroup PlugLOD
 203 |       autocmd!
 204 |     augroup END
 205 |     augroup! PlugLOD
 206 |   endif
 207 |   let lod = { 'ft': {}, 'map': {}, 'cmd': {} }
 208 | 
 209 |   if exists('g:did_load_filetypes')
 210 |     filetype off
 211 |   endif
 212 |   for name in g:plugs_order
 213 |     if !has_key(g:plugs, name)
 214 |       continue
 215 |     endif
 216 |     let plug = g:plugs[name]
 217 |     if get(s:loaded, name, 0) || !has_key(plug, 'on') && !has_key(plug, 'for')
 218 |       let s:loaded[name] = 1
 219 |       continue
 220 |     endif
 221 | 
 222 |     if has_key(plug, 'on')
 223 |       let s:triggers[name] = { 'map': [], 'cmd': [] }
 224 |       for cmd in s:to_a(plug.on)
 225 |         if cmd =~? '^<Plug>.\+'
 226 |           if empty(mapcheck(cmd)) && empty(mapcheck(cmd, 'i'))
 227 |             call s:assoc(lod.map, cmd, name)
 228 |           endif
 229 |           call add(s:triggers[name].map, cmd)
 230 |         elseif cmd =~# '^[A-Z]'
 231 |           let cmd = substitute(cmd, '!*$', '', '')
 232 |           if exists(':'.cmd) != 2
 233 |             call s:assoc(lod.cmd, cmd, name)
 234 |           endif
 235 |           call add(s:triggers[name].cmd, cmd)
 236 |         else
 237 |           call s:err('Invalid `on` option: '.cmd.
 238 |           \ '. Should start with an uppercase letter or `<Plug>`.')
 239 |         endif
 240 |       endfor
 241 |     endif
 242 | 
 243 |     if has_key(plug, 'for')
 244 |       let types = s:to_a(plug.for)
 245 |       if !empty(types)
 246 |         augroup filetypedetect
 247 |         call s:source(s:rtp(plug), 'ftdetect/**/*.vim', 'after/ftdetect/**/*.vim')
 248 |         augroup END
 249 |       endif
 250 |       for type in types
 251 |         call s:assoc(lod.ft, type, name)
 252 |       endfor
 253 |     endif
 254 |   endfor
 255 | 
 256 |   for [cmd, names] in items(lod.cmd)
 257 |     execute printf(
 258 |     \ 'command! -nargs=* -range -bang -complete=file %s call s:lod_cmd(%s, "<bang>", <line1>, <line2>, <q-args>, %s)',
 259 |     \ cmd, string(cmd), string(names))
 260 |   endfor
 261 | 
 262 |   for [map, names] in items(lod.map)
 263 |     for [mode, map_prefix, key_prefix] in
 264 |           \ [['i', '<C-O>', ''], ['n', '', ''], ['v', '', 'gv'], ['o', '', '']]
 265 |       execute printf(
 266 |       \ '%snoremap <silent> %s %s:<C-U>call <SID>lod_map(%s, %s, %s, "%s")<CR>',
 267 |       \ mode, map, map_prefix, string(map), string(names), mode != 'i', key_prefix)
 268 |     endfor
 269 |   endfor
 270 | 
 271 |   for [ft, names] in items(lod.ft)
 272 |     augroup PlugLOD
 273 |       execute printf('autocmd FileType %s call <SID>lod_ft(%s, %s)',
 274 |             \ ft, string(ft), string(names))
 275 |     augroup END
 276 |   endfor
 277 | 
 278 |   call s:reorg_rtp()
 279 |   filetype plugin indent on
 280 |   if has('vim_starting')
 281 |     if has('syntax') && !exists('g:syntax_on')
 282 |       syntax enable
 283 |     end
 284 |   else
 285 |     call s:reload_plugins()
 286 |   endif
 287 | endfunction
 288 | 
 289 | function! s:loaded_names()
 290 |   return filter(copy(g:plugs_order), 'get(s:loaded, v:val, 0)')
 291 | endfunction
 292 | 
 293 | function! s:load_plugin(spec)
 294 |   call s:source(s:rtp(a:spec), 'plugin/**/*.vim', 'after/plugin/**/*.vim')
 295 | endfunction
 296 | 
 297 | function! s:reload_plugins()
 298 |   for name in s:loaded_names()
 299 |     call s:load_plugin(g:plugs[name])
 300 |   endfor
 301 | endfunction
 302 | 
 303 | function! s:trim(str)
 304 |   return substitute(a:str, '[\/]\+$', '', '')
 305 | endfunction
 306 | 
 307 | function! s:version_requirement(val, min)
 308 |   for idx in range(0, len(a:min) - 1)
 309 |     let v = get(a:val, idx, 0)
 310 |     if     v < a:min[idx] | return 0
 311 |     elseif v > a:min[idx] | return 1
 312 |     endif
 313 |   endfor
 314 |   return 1
 315 | endfunction
 316 | 
 317 | function! s:git_version_requirement(...)
 318 |   if !exists('s:git_version')
 319 |     let s:git_version = map(split(split(s:system('git --version'))[2], '\.'), 'str2nr(v:val)')
 320 |   endif
 321 |   return s:version_requirement(s:git_version, a:000)
 322 | endfunction
 323 | 
 324 | function! s:progress_opt(base)
 325 |   return a:base && !s:is_win &&
 326 |         \ s:git_version_requirement(1, 7, 1) ? '--progress' : ''
 327 | endfunction
 328 | 
 329 | if s:is_win
 330 |   function! s:rtp(spec)
 331 |     return s:path(a:spec.dir . get(a:spec, 'rtp', ''))
 332 |   endfunction
 333 | 
 334 |   function! s:path(path)
 335 |     return s:trim(substitute(a:path, '/', '\', 'g'))
 336 |   endfunction
 337 | 
 338 |   function! s:dirpath(path)
 339 |     return s:path(a:path) . '\'
 340 |   endfunction
 341 | 
 342 |   function! s:is_local_plug(repo)
 343 |     return a:repo =~? '^[a-z]:\|^[%~]'
 344 |   endfunction
 345 | else
 346 |   function! s:rtp(spec)
 347 |     return s:dirpath(a:spec.dir . get(a:spec, 'rtp', ''))
 348 |   endfunction
 349 | 
 350 |   function! s:path(path)
 351 |     return s:trim(a:path)
 352 |   endfunction
 353 | 
 354 |   function! s:dirpath(path)
 355 |     return substitute(a:path, '[/\\]*$', '/', '')
 356 |   endfunction
 357 | 
 358 |   function! s:is_local_plug(repo)
 359 |     return a:repo[0] =~ '[/$~]'
 360 |   endfunction
 361 | endif
 362 | 
 363 | function! s:err(msg)
 364 |   echohl ErrorMsg
 365 |   echom '[vim-plug] '.a:msg
 366 |   echohl None
 367 | endfunction
 368 | 
 369 | function! s:warn(cmd, msg)
 370 |   echohl WarningMsg
 371 |   execute a:cmd 'a:msg'
 372 |   echohl None
 373 | endfunction
 374 | 
 375 | function! s:esc(path)
 376 |   return escape(a:path, ' ')
 377 | endfunction
 378 | 
 379 | function! s:escrtp(path)
 380 |   return escape(a:path, ' ,')
 381 | endfunction
 382 | 
 383 | function! s:remove_rtp()
 384 |   for name in s:loaded_names()
 385 |     let rtp = s:rtp(g:plugs[name])
 386 |     execute 'set rtp-='.s:escrtp(rtp)
 387 |     let after = globpath(rtp, 'after')
 388 |     if isdirectory(after)
 389 |       execute 'set rtp-='.s:escrtp(after)
 390 |     endif
 391 |   endfor
 392 | endfunction
 393 | 
 394 | function! s:reorg_rtp()
 395 |   if !empty(s:first_rtp)
 396 |     execute 'set rtp-='.s:first_rtp
 397 |     execute 'set rtp-='.s:last_rtp
 398 |   endif
 399 | 
 400 |   " &rtp is modified from outside
 401 |   if exists('s:prtp') && s:prtp !=# &rtp
 402 |     call s:remove_rtp()
 403 |     unlet! s:middle
 404 |   endif
 405 | 
 406 |   let s:middle = get(s:, 'middle', &rtp)
 407 |   let rtps     = map(s:loaded_names(), 's:rtp(g:plugs[v:val])')
 408 |   let afters   = filter(map(copy(rtps), 'globpath(v:val, "after")'), '!empty(v:val)')
 409 |   let rtp      = join(map(rtps, 'escape(v:val, ",")'), ',')
 410 |                  \ . ','.s:middle.','
 411 |                  \ . join(map(afters, 'escape(v:val, ",")'), ',')
 412 |   let &rtp     = substitute(substitute(rtp, ',,*', ',', 'g'), '^,\|,$', '', 'g')
 413 |   let s:prtp   = &rtp
 414 | 
 415 |   if !empty(s:first_rtp)
 416 |     execute 'set rtp^='.s:first_rtp
 417 |     execute 'set rtp+='.s:last_rtp
 418 |   endif
 419 | endfunction
 420 | 
 421 | function! s:doautocmd(...)
 422 |   if exists('#'.join(a:000, '#'))
 423 |     execute 'doautocmd' ((v:version > 703 || has('patch442')) ? '<nomodeline>' : '') join(a:000)
 424 |   endif
 425 | endfunction
 426 | 
 427 | function! s:dobufread(names)
 428 |   for name in a:names
 429 |     let path = s:rtp(g:plugs[name]).'/**'
 430 |     for dir in ['ftdetect', 'ftplugin']
 431 |       if len(finddir(dir, path))
 432 |         if exists('#BufRead')
 433 |           doautocmd BufRead
 434 |         endif
 435 |         return
 436 |       endif
 437 |     endfor
 438 |   endfor
 439 | endfunction
 440 | 
 441 | function! plug#load(...)
 442 |   if a:0 == 0
 443 |     return s:err('Argument missing: plugin name(s) required')
 444 |   endif
 445 |   if !exists('g:plugs')
 446 |     return s:err('plug#begin was not called')
 447 |   endif
 448 |   let names = a:0 == 1 && type(a:1) == s:TYPE.list ? a:1 : a:000
 449 |   let unknowns = filter(copy(names), '!has_key(g:plugs, v:val)')
 450 |   if !empty(unknowns)
 451 |     let s = len(unknowns) > 1 ? 's' : ''
 452 |     return s:err(printf('Unknown plugin%s: %s', s, join(unknowns, ', ')))
 453 |   end
 454 |   let unloaded = filter(copy(names), '!get(s:loaded, v:val, 0)')
 455 |   if !empty(unloaded)
 456 |     for name in unloaded
 457 |       call s:lod([name], ['ftdetect', 'after/ftdetect', 'plugin', 'after/plugin'])
 458 |     endfor
 459 |     call s:dobufread(unloaded)
 460 |     return 1
 461 |   end
 462 |   return 0
 463 | endfunction
 464 | 
 465 | function! s:remove_triggers(name)
 466 |   if !has_key(s:triggers, a:name)
 467 |     return
 468 |   endif
 469 |   for cmd in s:triggers[a:name].cmd
 470 |     execute 'silent! delc' cmd
 471 |   endfor
 472 |   for map in s:triggers[a:name].map
 473 |     execute 'silent! unmap' map
 474 |     execute 'silent! iunmap' map
 475 |   endfor
 476 |   call remove(s:triggers, a:name)
 477 | endfunction
 478 | 
 479 | function! s:lod(names, types, ...)
 480 |   for name in a:names
 481 |     call s:remove_triggers(name)
 482 |     let s:loaded[name] = 1
 483 |   endfor
 484 |   call s:reorg_rtp()
 485 | 
 486 |   for name in a:names
 487 |     let rtp = s:rtp(g:plugs[name])
 488 |     for dir in a:types
 489 |       call s:source(rtp, dir.'/**/*.vim')
 490 |     endfor
 491 |     if a:0
 492 |       if !s:source(rtp, a:1) && !empty(s:glob(rtp, a:2))
 493 |         execute 'runtime' a:1
 494 |       endif
 495 |       call s:source(rtp, a:2)
 496 |     endif
 497 |     call s:doautocmd('User', name)
 498 |   endfor
 499 | endfunction
 500 | 
 501 | function! s:lod_ft(pat, names)
 502 |   let syn = 'syntax/'.a:pat.'.vim'
 503 |   call s:lod(a:names, ['plugin', 'after/plugin'], syn, 'after/'.syn)
 504 |   execute 'autocmd! PlugLOD FileType' a:pat
 505 |   call s:doautocmd('filetypeplugin', 'FileType')
 506 |   call s:doautocmd('filetypeindent', 'FileType')
 507 | endfunction
 508 | 
 509 | function! s:lod_cmd(cmd, bang, l1, l2, args, names)
 510 |   call s:lod(a:names, ['ftdetect', 'after/ftdetect', 'plugin', 'after/plugin'])
 511 |   call s:dobufread(a:names)
 512 |   execute printf('%s%s%s %s', (a:l1 == a:l2 ? '' : (a:l1.','.a:l2)), a:cmd, a:bang, a:args)
 513 | endfunction
 514 | 
 515 | function! s:lod_map(map, names, with_prefix, prefix)
 516 |   call s:lod(a:names, ['ftdetect', 'after/ftdetect', 'plugin', 'after/plugin'])
 517 |   call s:dobufread(a:names)
 518 |   let extra = ''
 519 |   while 1
 520 |     let c = getchar(0)
 521 |     if c == 0
 522 |       break
 523 |     endif
 524 |     let extra .= nr2char(c)
 525 |   endwhile
 526 | 
 527 |   if a:with_prefix
 528 |     let prefix = v:count ? v:count : ''
 529 |     let prefix .= '"'.v:register.a:prefix
 530 |     if mode(1) == 'no'
 531 |       if v:operator == 'c'
 532 |         let prefix = "\<esc>" . prefix
 533 |       endif
 534 |       let prefix .= v:operator
 535 |     endif
 536 |     call feedkeys(prefix, 'n')
 537 |   endif
 538 |   call feedkeys(substitute(a:map, '^<Plug>', "\<Plug>", '') . extra)
 539 | endfunction
 540 | 
 541 | function! plug#(repo, ...)
 542 |   if a:0 > 1
 543 |     return s:err('Invalid number of arguments (1..2)')
 544 |   endif
 545 | 
 546 |   try
 547 |     let repo = s:trim(a:repo)
 548 |     let opts = a:0 == 1 ? s:parse_options(a:1) : s:base_spec
 549 |     let name = get(opts, 'as', fnamemodify(repo, ':t:s?\.git$??'))
 550 |     let spec = extend(s:infer_properties(name, repo), opts)
 551 |     if !has_key(g:plugs, name)
 552 |       call add(g:plugs_order, name)
 553 |     endif
 554 |     let g:plugs[name] = spec
 555 |     let s:loaded[name] = get(s:loaded, name, 0)
 556 |   catch
 557 |     return s:err(v:exception)
 558 |   endtry
 559 | endfunction
 560 | 
 561 | function! s:parse_options(arg)
 562 |   let opts = copy(s:base_spec)
 563 |   let type = type(a:arg)
 564 |   if type == s:TYPE.string
 565 |     let opts.tag = a:arg
 566 |   elseif type == s:TYPE.dict
 567 |     call extend(opts, a:arg)
 568 |     if has_key(opts, 'dir')
 569 |       let opts.dir = s:dirpath(expand(opts.dir))
 570 |     endif
 571 |   else
 572 |     throw 'Invalid argument type (expected: string or dictionary)'
 573 |   endif
 574 |   return opts
 575 | endfunction
 576 | 
 577 | function! s:infer_properties(name, repo)
 578 |   let repo = a:repo
 579 |   if s:is_local_plug(repo)
 580 |     return { 'dir': s:dirpath(expand(repo)) }
 581 |   else
 582 |     if repo =~ ':'
 583 |       let uri = repo
 584 |     else
 585 |       if repo !~ '/'
 586 |         throw printf('Invalid argument: %s (implicit `vim-scripts'' expansion is deprecated)', repo)
 587 |       endif
 588 |       let fmt = get(g:, 'plug_url_format', 'https://git::@github.com/%s.git')
 589 |       let uri = printf(fmt, repo)
 590 |     endif
 591 |     return { 'dir': s:dirpath(g:plug_home.'/'.a:name), 'uri': uri }
 592 |   endif
 593 | endfunction
 594 | 
 595 | function! s:install(force, names)
 596 |   call s:update_impl(0, a:force, a:names)
 597 | endfunction
 598 | 
 599 | function! s:update(force, names)
 600 |   call s:update_impl(1, a:force, a:names)
 601 | endfunction
 602 | 
 603 | function! plug#helptags()
 604 |   if !exists('g:plugs')
 605 |     return s:err('plug#begin was not called')
 606 |   endif
 607 |   for spec in values(g:plugs)
 608 |     let docd = join([s:rtp(spec), 'doc'], '/')
 609 |     if isdirectory(docd)
 610 |       silent! execute 'helptags' s:esc(docd)
 611 |     endif
 612 |   endfor
 613 |   return 1
 614 | endfunction
 615 | 
 616 | function! s:syntax()
 617 |   syntax clear
 618 |   syntax region plug1 start=/\%1l/ end=/\%2l/ contains=plugNumber
 619 |   syntax region plug2 start=/\%2l/ end=/\%3l/ contains=plugBracket,plugX
 620 |   syn match plugNumber /[0-9]\+[0-9.]*/ contained
 621 |   syn match plugBracket /[[\]]/ contained
 622 |   syn match plugX /x/ contained
 623 |   syn match plugDash /^-/
 624 |   syn match plugPlus /^+/
 625 |   syn match plugStar /^*/
 626 |   syn match plugMessage /\(^- \)\@<=.*/
 627 |   syn match plugName /\(^- \)\@<=[^ ]*:/
 628 |   syn match plugSha /\%(: \)\@<=[0-9a-f]\{4,}$/
 629 |   syn match plugTag /(tag: [^)]\+)/
 630 |   syn match plugInstall /\(^+ \)\@<=[^:]*/
 631 |   syn match plugUpdate /\(^* \)\@<=[^:]*/
 632 |   syn match plugCommit /^  \X*[0-9a-f]\{7,9} .*/ contains=plugRelDate,plugEdge,plugTag
 633 |   syn match plugEdge /^  \X\+$/
 634 |   syn match plugEdge /^  \X*/ contained nextgroup=plugSha
 635 |   syn match plugSha /[0-9a-f]\{7,9}/ contained
 636 |   syn match plugRelDate /([^)]*)$/ contained
 637 |   syn match plugNotLoaded /(not loaded)$/
 638 |   syn match plugError /^x.*/
 639 |   syn region plugDeleted start=/^\~ .*/ end=/^\ze\S/
 640 |   syn match plugH2 /^.*:\n-\+$/
 641 |   syn keyword Function PlugInstall PlugStatus PlugUpdate PlugClean
 642 |   hi def link plug1       Title
 643 |   hi def link plug2       Repeat
 644 |   hi def link plugH2      Type
 645 |   hi def link plugX       Exception
 646 |   hi def link plugBracket Structure
 647 |   hi def link plugNumber  Number
 648 | 
 649 |   hi def link plugDash    Special
 650 |   hi def link plugPlus    Constant
 651 |   hi def link plugStar    Boolean
 652 | 
 653 |   hi def link plugMessage Function
 654 |   hi def link plugName    Label
 655 |   hi def link plugInstall Function
 656 |   hi def link plugUpdate  Type
 657 | 
 658 |   hi def link plugError   Error
 659 |   hi def link plugDeleted Ignore
 660 |   hi def link plugRelDate Comment
 661 |   hi def link plugEdge    PreProc
 662 |   hi def link plugSha     Identifier
 663 |   hi def link plugTag     Constant
 664 | 
 665 |   hi def link plugNotLoaded Comment
 666 | endfunction
 667 | 
 668 | function! s:lpad(str, len)
 669 |   return a:str . repeat(' ', a:len - len(a:str))
 670 | endfunction
 671 | 
 672 | function! s:lines(msg)
 673 |   return split(a:msg, "[\r\n]")
 674 | endfunction
 675 | 
 676 | function! s:lastline(msg)
 677 |   return get(s:lines(a:msg), -1, '')
 678 | endfunction
 679 | 
 680 | function! s:new_window()
 681 |   execute get(g:, 'plug_window', 'vertical topleft new')
 682 | endfunction
 683 | 
 684 | function! s:plug_window_exists()
 685 |   let buflist = tabpagebuflist(s:plug_tab)
 686 |   return !empty(buflist) && index(buflist, s:plug_buf) >= 0
 687 | endfunction
 688 | 
 689 | function! s:switch_in()
 690 |   if !s:plug_window_exists()
 691 |     return 0
 692 |   endif
 693 | 
 694 |   if winbufnr(0) != s:plug_buf
 695 |     let s:pos = [tabpagenr(), winnr(), winsaveview()]
 696 |     execute 'normal!' s:plug_tab.'gt'
 697 |     let winnr = bufwinnr(s:plug_buf)
 698 |     execute winnr.'wincmd w'
 699 |     call add(s:pos, winsaveview())
 700 |   else
 701 |     let s:pos = [winsaveview()]
 702 |   endif
 703 | 
 704 |   setlocal modifiable
 705 |   return 1
 706 | endfunction
 707 | 
 708 | function! s:switch_out(...)
 709 |   call winrestview(s:pos[-1])
 710 |   setlocal nomodifiable
 711 |   if a:0 > 0
 712 |     execute a:1
 713 |   endif
 714 | 
 715 |   if len(s:pos) > 1
 716 |     execute 'normal!' s:pos[0].'gt'
 717 |     execute s:pos[1] 'wincmd w'
 718 |     call winrestview(s:pos[2])
 719 |   endif
 720 | endfunction
 721 | 
 722 | function! s:finish_bindings()
 723 |   nnoremap <silent> <buffer> R  :call <SID>retry()<cr>
 724 |   nnoremap <silent> <buffer> D  :PlugDiff<cr>
 725 |   nnoremap <silent> <buffer> S  :PlugStatus<cr>
 726 |   nnoremap <silent> <buffer> U  :call <SID>status_update()<cr>
 727 |   xnoremap <silent> <buffer> U  :call <SID>status_update()<cr>
 728 |   nnoremap <silent> <buffer> ]] :silent! call <SID>section('')<cr>
 729 |   nnoremap <silent> <buffer> [[ :silent! call <SID>section('b')<cr>
 730 | endfunction
 731 | 
 732 | function! s:prepare(...)
 733 |   if empty(getcwd())
 734 |     throw 'Invalid current working directory. Cannot proceed.'
 735 |   endif
 736 | 
 737 |   for evar in ['$GIT_DIR', '$GIT_WORK_TREE']
 738 |     if exists(evar)
 739 |       throw evar.' detected. Cannot proceed.'
 740 |     endif
 741 |   endfor
 742 | 
 743 |   call s:job_abort()
 744 |   if s:switch_in()
 745 |     if b:plug_preview == 1
 746 |       pc
 747 |     endif
 748 |     enew
 749 |   else
 750 |     call s:new_window()
 751 |   endif
 752 | 
 753 |   nnoremap <silent> <buffer> q  :if b:plug_preview==1<bar>pc<bar>endif<bar>bd<cr>
 754 |   if a:0 == 0
 755 |     call s:finish_bindings()
 756 |   endif
 757 |   let b:plug_preview = -1
 758 |   let s:plug_tab = tabpagenr()
 759 |   let s:plug_buf = winbufnr(0)
 760 |   call s:assign_name()
 761 | 
 762 |   for k in ['<cr>', 'L', 'o', 'X', 'd', 'dd']
 763 |     execute 'silent! unmap <buffer>' k
 764 |   endfor
 765 |   setlocal buftype=nofile bufhidden=wipe nobuflisted nolist noswapfile nowrap cursorline modifiable nospell
 766 |   setf vim-plug
 767 |   if exists('g:syntax_on')
 768 |     call s:syntax()
 769 |   endif
 770 | endfunction
 771 | 
 772 | function! s:assign_name()
 773 |   " Assign buffer name
 774 |   let prefix = '[Plugins]'
 775 |   let name   = prefix
 776 |   let idx    = 2
 777 |   while bufexists(name)
 778 |     let name = printf('%s (%s)', prefix, idx)
 779 |     let idx = idx + 1
 780 |   endwhile
 781 |   silent! execute 'f' fnameescape(name)
 782 | endfunction
 783 | 
 784 | function! s:chsh(swap)
 785 |   let prev = [&shell, &shellcmdflag, &shellredir]
 786 |   if s:is_win
 787 |     set shell=cmd.exe shellcmdflag=/c shellredir=>%s\ 2>&1
 788 |   elseif a:swap
 789 |     set shell=sh shellredir=>%s\ 2>&1
 790 |   endif
 791 |   return prev
 792 | endfunction
 793 | 
 794 | function! s:bang(cmd, ...)
 795 |   try
 796 |     let [sh, shellcmdflag, shrd] = s:chsh(a:0)
 797 |     " FIXME: Escaping is incomplete. We could use shellescape with eval,
 798 |     "        but it won't work on Windows.
 799 |     let cmd = a:0 ? s:with_cd(a:cmd, a:1) : a:cmd
 800 |     if s:is_win
 801 |       let batchfile = tempname().'.bat'
 802 |       call writefile(['@echo off', cmd], batchfile)
 803 |       let cmd = batchfile
 804 |     endif
 805 |     let g:_plug_bang = (s:is_win && has('gui_running') ? 'silent ' : '').'!'.escape(cmd, '#!%')
 806 |     execute "normal! :execute g:_plug_bang\<cr>\<cr>"
 807 |   finally
 808 |     unlet g:_plug_bang
 809 |     let [&shell, &shellcmdflag, &shellredir] = [sh, shellcmdflag, shrd]
 810 |     if s:is_win
 811 |       call delete(batchfile)
 812 |     endif
 813 |   endtry
 814 |   return v:shell_error ? 'Exit status: ' . v:shell_error : ''
 815 | endfunction
 816 | 
 817 | function! s:regress_bar()
 818 |   let bar = substitute(getline(2)[1:-2], '.*\zs=', 'x', '')
 819 |   call s:progress_bar(2, bar, len(bar))
 820 | endfunction
 821 | 
 822 | function! s:is_updated(dir)
 823 |   return !empty(s:system_chomp('git log --pretty=format:"%h" "HEAD...HEAD@{1}"', a:dir))
 824 | endfunction
 825 | 
 826 | function! s:do(pull, force, todo)
 827 |   for [name, spec] in items(a:todo)
 828 |     if !isdirectory(spec.dir)
 829 |       continue
 830 |     endif
 831 |     let installed = has_key(s:update.new, name)
 832 |     let updated = installed ? 0 :
 833 |       \ (a:pull && index(s:update.errors, name) < 0 && s:is_updated(spec.dir))
 834 |     if a:force || installed || updated
 835 |       execute 'cd' s:esc(spec.dir)
 836 |       call append(3, '- Post-update hook for '. name .' ... ')
 837 |       let error = ''
 838 |       let type = type(spec.do)
 839 |       if type == s:TYPE.string
 840 |         if spec.do[0] == ':'
 841 |           if !get(s:loaded, name, 0)
 842 |             let s:loaded[name] = 1
 843 |             call s:reorg_rtp()
 844 |           endif
 845 |           call s:load_plugin(spec)
 846 |           try
 847 |             execute spec.do[1:]
 848 |           catch
 849 |             let error = v:exception
 850 |           endtry
 851 |           if !s:plug_window_exists()
 852 |             cd -
 853 |             throw 'Warning: vim-plug was terminated by the post-update hook of '.name
 854 |           endif
 855 |         else
 856 |           let error = s:bang(spec.do)
 857 |         endif
 858 |       elseif type == s:TYPE.funcref
 859 |         try
 860 |           let status = installed ? 'installed' : (updated ? 'updated' : 'unchanged')
 861 |           call spec.do({ 'name': name, 'status': status, 'force': a:force })
 862 |         catch
 863 |           let error = v:exception
 864 |         endtry
 865 |       else
 866 |         let error = 'Invalid hook type'
 867 |       endif
 868 |       call s:switch_in()
 869 |       call setline(4, empty(error) ? (getline(4) . 'OK')
 870 |                                  \ : ('x' . getline(4)[1:] . error))
 871 |       if !empty(error)
 872 |         call add(s:update.errors, name)
 873 |         call s:regress_bar()
 874 |       endif
 875 |       cd -
 876 |     endif
 877 |   endfor
 878 | endfunction
 879 | 
 880 | function! s:hash_match(a, b)
 881 |   return stridx(a:a, a:b) == 0 || stridx(a:b, a:a) == 0
 882 | endfunction
 883 | 
 884 | function! s:checkout(spec)
 885 |   let sha = a:spec.commit
 886 |   let output = s:system('git rev-parse HEAD', a:spec.dir)
 887 |   if !v:shell_error && !s:hash_match(sha, s:lines(output)[0])
 888 |     let output = s:system(
 889 |           \ 'git fetch --depth 999999 && git checkout '.s:esc(sha).' --', a:spec.dir)
 890 |   endif
 891 |   return output
 892 | endfunction
 893 | 
 894 | function! s:finish(pull)
 895 |   let new_frozen = len(filter(keys(s:update.new), 'g:plugs[v:val].frozen'))
 896 |   if new_frozen
 897 |     let s = new_frozen > 1 ? 's' : ''
 898 |     call append(3, printf('- Installed %d frozen plugin%s', new_frozen, s))
 899 |   endif
 900 |   call append(3, '- Finishing ... ') | 4
 901 |   redraw
 902 |   call plug#helptags()
 903 |   call plug#end()
 904 |   call setline(4, getline(4) . 'Done!')
 905 |   redraw
 906 |   let msgs = []
 907 |   if !empty(s:update.errors)
 908 |     call add(msgs, "Press 'R' to retry.")
 909 |   endif
 910 |   if a:pull && len(s:update.new) < len(filter(getline(5, '$'),
 911 |                 \ "v:val =~ '^- ' && stridx(v:val, 'Already up-to-date') < 0"))
 912 |     call add(msgs, "Press 'D' to see the updated changes.")
 913 |   endif
 914 |   echo join(msgs, ' ')
 915 |   call s:finish_bindings()
 916 | endfunction
 917 | 
 918 | function! s:retry()
 919 |   if empty(s:update.errors)
 920 |     return
 921 |   endif
 922 |   echo
 923 |   call s:update_impl(s:update.pull, s:update.force,
 924 |         \ extend(copy(s:update.errors), [s:update.threads]))
 925 | endfunction
 926 | 
 927 | function! s:is_managed(name)
 928 |   return has_key(g:plugs[a:name], 'uri')
 929 | endfunction
 930 | 
 931 | function! s:names(...)
 932 |   return sort(filter(keys(g:plugs), 'stridx(v:val, a:1) == 0 && s:is_managed(v:val)'))
 933 | endfunction
 934 | 
 935 | function! s:check_ruby()
 936 |   silent! ruby require 'thread'; VIM::command("let g:plug_ruby = '#{RUBY_VERSION}'")
 937 |   if !exists('g:plug_ruby')
 938 |     redraw!
 939 |     return s:warn('echom', 'Warning: Ruby interface is broken')
 940 |   endif
 941 |   let ruby_version = split(g:plug_ruby, '\.')
 942 |   unlet g:plug_ruby
 943 |   return s:version_requirement(ruby_version, [1, 8, 7])
 944 | endfunction
 945 | 
 946 | function! s:update_impl(pull, force, args) abort
 947 |   let sync = index(a:args, '--sync') >= 0 || has('vim_starting')
 948 |   let args = filter(copy(a:args), 'v:val != "--sync"')
 949 |   let threads = (len(args) > 0 && args[-1] =~ '^[1-9][0-9]*$') ?
 950 |                   \ remove(args, -1) : get(g:, 'plug_threads', 16)
 951 | 
 952 |   let managed = filter(copy(g:plugs), 's:is_managed(v:key)')
 953 |   let todo = empty(args) ? filter(managed, '!v:val.frozen || !isdirectory(v:val.dir)') :
 954 |                          \ filter(managed, 'index(args, v:key) >= 0')
 955 | 
 956 |   if empty(todo)
 957 |     return s:warn('echo', 'No plugin to '. (a:pull ? 'update' : 'install'))
 958 |   endif
 959 | 
 960 |   if !s:is_win && s:git_version_requirement(2, 3)
 961 |     let s:git_terminal_prompt = exists('$GIT_TERMINAL_PROMPT') ? $GIT_TERMINAL_PROMPT : ''
 962 |     let $GIT_TERMINAL_PROMPT = 0
 963 |     for plug in values(todo)
 964 |       let plug.uri = substitute(plug.uri,
 965 |             \ '^https://git::@github\.com', 'https://github.com', '')
 966 |     endfor
 967 |   endif
 968 | 
 969 |   if !isdirectory(g:plug_home)
 970 |     try
 971 |       call mkdir(g:plug_home, 'p')
 972 |     catch
 973 |       return s:err(printf('Invalid plug directory: %s. '.
 974 |               \ 'Try to call plug#begin with a valid directory', g:plug_home))
 975 |     endtry
 976 |   endif
 977 | 
 978 |   if has('nvim') && !exists('*jobwait') && threads > 1
 979 |     call s:warn('echom', '[vim-plug] Update Neovim for parallel installer')
 980 |   endif
 981 | 
 982 |   let use_job = s:nvim || s:vim8
 983 |   let python = (has('python') || has('python3')) && !use_job
 984 |   let ruby = has('ruby') && !use_job && (v:version >= 703 || v:version == 702 && has('patch374')) && !(s:is_win && has('gui_running')) && threads > 1 && s:check_ruby()
 985 | 
 986 |   let s:update = {
 987 |     \ 'start':   reltime(),
 988 |     \ 'all':     todo,
 989 |     \ 'todo':    copy(todo),
 990 |     \ 'errors':  [],
 991 |     \ 'pull':    a:pull,
 992 |     \ 'force':   a:force,
 993 |     \ 'new':     {},
 994 |     \ 'threads': (python || ruby || use_job) ? min([len(todo), threads]) : 1,
 995 |     \ 'bar':     '',
 996 |     \ 'fin':     0
 997 |   \ }
 998 | 
 999 |   call s:prepare(1)
1000 |   call append(0, ['', ''])
1001 |   normal! 2G
1002 |   silent! redraw
1003 | 
1004 |   let s:clone_opt = get(g:, 'plug_shallow', 1) ?
1005 |         \ '--depth 1' . (s:git_version_requirement(1, 7, 10) ? ' --no-single-branch' : '') : ''
1006 | 
1007 |   if has('win32unix')
1008 |     let s:clone_opt .= ' -c core.eol=lf -c core.autocrlf=input'
1009 |   endif
1010 | 
1011 |   " Python version requirement (>= 2.7)
1012 |   if python && !has('python3') && !ruby && !use_job && s:update.threads > 1
1013 |     redir => pyv
1014 |     silent python import platform; print platform.python_version()
1015 |     redir END
1016 |     let python = s:version_requirement(
1017 |           \ map(split(split(pyv)[0], '\.'), 'str2nr(v:val)'), [2, 6])
1018 |   endif
1019 | 
1020 |   if (python || ruby) && s:update.threads > 1
1021 |     try
1022 |       let imd = &imd
1023 |       if s:mac_gui
1024 |         set noimd
1025 |       endif
1026 |       if ruby
1027 |         call s:update_ruby()
1028 |       else
1029 |         call s:update_python()
1030 |       endif
1031 |     catch
1032 |       let lines = getline(4, '$')
1033 |       let printed = {}
1034 |       silent! 4,$d _
1035 |       for line in lines
1036 |         let name = s:extract_name(line, '.', '')
1037 |         if empty(name) || !has_key(printed, name)
1038 |           call append('$', line)
1039 |           if !empty(name)
1040 |             let printed[name] = 1
1041 |             if line[0] == 'x' && index(s:update.errors, name) < 0
1042 |               call add(s:update.errors, name)
1043 |             end
1044 |           endif
1045 |         endif
1046 |       endfor
1047 |     finally
1048 |       let &imd = imd
1049 |       call s:update_finish()
1050 |     endtry
1051 |   else
1052 |     call s:update_vim()
1053 |     while use_job && sync
1054 |       sleep 100m
1055 |       if s:update.fin
1056 |         break
1057 |       endif
1058 |     endwhile
1059 |   endif
1060 | endfunction
1061 | 
1062 | function! s:log4(name, msg)
1063 |   call setline(4, printf('- %s (%s)', a:msg, a:name))
1064 |   redraw
1065 | endfunction
1066 | 
1067 | function! s:update_finish()
1068 |   if exists('s:git_terminal_prompt')
1069 |     let $GIT_TERMINAL_PROMPT = s:git_terminal_prompt
1070 |   endif
1071 |   if s:switch_in()
1072 |     call append(3, '- Updating ...') | 4
1073 |     for [name, spec] in items(filter(copy(s:update.all), 'index(s:update.errors, v:key) < 0 && (s:update.force || s:update.pull || has_key(s:update.new, v:key))'))
1074 |       let [pos, _] = s:logpos(name)
1075 |       if !pos
1076 |         continue
1077 |       endif
1078 |       if has_key(spec, 'commit')
1079 |         call s:log4(name, 'Checking out '.spec.commit)
1080 |         let out = s:checkout(spec)
1081 |       elseif has_key(spec, 'tag')
1082 |         let tag = spec.tag
1083 |         if tag =~ '\*'
1084 |           let tags = s:lines(s:system('git tag --list '.s:shellesc(tag).' --sort -version:refname 2>&1', spec.dir))
1085 |           if !v:shell_error && !empty(tags)
1086 |             let tag = tags[0]
1087 |             call s:log4(name, printf('Latest tag for %s -> %s', spec.tag, tag))
1088 |             call append(3, '')
1089 |           endif
1090 |         endif
1091 |         call s:log4(name, 'Checking out '.tag)
1092 |         let out = s:system('git checkout -q '.s:esc(tag).' -- 2>&1', spec.dir)
1093 |       else
1094 |         let branch = s:esc(get(spec, 'branch', 'master'))
1095 |         call s:log4(name, 'Merging origin/'.branch)
1096 |         let out = s:system('git checkout -q '.branch.' -- 2>&1'
1097 |               \. (has_key(s:update.new, name) ? '' : ('&& git merge --ff-only origin/'.branch.' 2>&1')), spec.dir)
1098 |       endif
1099 |       if !v:shell_error && filereadable(spec.dir.'/.gitmodules') &&
1100 |             \ (s:update.force || has_key(s:update.new, name) || s:is_updated(spec.dir))
1101 |         call s:log4(name, 'Updating submodules. This may take a while.')
1102 |         let out .= s:bang('git submodule update --init --recursive 2>&1', spec.dir)
1103 |       endif
1104 |       let msg = s:format_message(v:shell_error ? 'x': '-', name, out)
1105 |       if v:shell_error
1106 |         call add(s:update.errors, name)
1107 |         call s:regress_bar()
1108 |         silent execute pos 'd _'
1109 |         call append(4, msg) | 4
1110 |       elseif !empty(out)
1111 |         call setline(pos, msg[0])
1112 |       endif
1113 |       redraw
1114 |     endfor
1115 |     silent 4 d _
1116 |     try
1117 |       call s:do(s:update.pull, s:update.force, filter(copy(s:update.all), 'index(s:update.errors, v:key) < 0 && has_key(v:val, "do")'))
1118 |     catch
1119 |       call s:warn('echom', v:exception)
1120 |       call s:warn('echo', '')
1121 |       return
1122 |     endtry
1123 |     call s:finish(s:update.pull)
1124 |     call setline(1, 'Updated. Elapsed time: ' . split(reltimestr(reltime(s:update.start)))[0] . ' sec.')
1125 |     call s:switch_out('normal! gg')
1126 |   endif
1127 | endfunction
1128 | 
1129 | function! s:job_abort()
1130 |   if (!s:nvim && !s:vim8) || !exists('s:jobs')
1131 |     return
1132 |   endif
1133 | 
1134 |   for [name, j] in items(s:jobs)
1135 |     if s:nvim
1136 |       silent! call jobstop(j.jobid)
1137 |     elseif s:vim8
1138 |       silent! call job_stop(j.jobid)
1139 |     endif
1140 |     if j.new
1141 |       call s:system('rm -rf ' . s:shellesc(g:plugs[name].dir))
1142 |     endif
1143 |   endfor
1144 |   let s:jobs = {}
1145 | endfunction
1146 | 
1147 | function! s:last_non_empty_line(lines)
1148 |   let len = len(a:lines)
1149 |   for idx in range(len)
1150 |     let line = a:lines[len-idx-1]
1151 |     if !empty(line)
1152 |       return line
1153 |     endif
1154 |   endfor
1155 |   return ''
1156 | endfunction
1157 | 
1158 | function! s:job_out_cb(self, data) abort
1159 |   let self = a:self
1160 |   let data = remove(self.lines, -1) . a:data
1161 |   let lines = map(split(data, "\n", 1), 'split(v:val, "\r", 1)[-1]')
1162 |   call extend(self.lines, lines)
1163 |   " To reduce the number of buffer updates
1164 |   let self.tick = get(self, 'tick', -1) + 1
1165 |   if !self.running || self.tick % len(s:jobs) == 0
1166 |     let bullet = self.running ? (self.new ? '+' : '*') : (self.error ? 'x' : '-')
1167 |     let result = self.error ? join(self.lines, "\n") : s:last_non_empty_line(self.lines)
1168 |     call s:log(bullet, self.name, result)
1169 |   endif
1170 | endfunction
1171 | 
1172 | function! s:job_exit_cb(self, data) abort
1173 |   let a:self.running = 0
1174 |   let a:self.error = a:data != 0
1175 |   call s:reap(a:self.name)
1176 |   call s:tick()
1177 | endfunction
1178 | 
1179 | function! s:job_cb(fn, job, ch, data)
1180 |   if !s:plug_window_exists() " plug window closed
1181 |     return s:job_abort()
1182 |   endif
1183 |   call call(a:fn, [a:job, a:data])
1184 | endfunction
1185 | 
1186 | function! s:nvim_cb(job_id, data, event) dict abort
1187 |   return a:event == 'stdout' ?
1188 |     \ s:job_cb('s:job_out_cb',  self, 0, join(a:data, "\n")) :
1189 |     \ s:job_cb('s:job_exit_cb', self, 0, a:data)
1190 | endfunction
1191 | 
1192 | function! s:spawn(name, cmd, opts)
1193 |   let job = { 'name': a:name, 'running': 1, 'error': 0, 'lines': [''],
1194 |             \ 'batchfile': (s:is_win && (s:nvim || s:vim8)) ? tempname().'.bat' : '',
1195 |             \ 'new': get(a:opts, 'new', 0) }
1196 |   let s:jobs[a:name] = job
1197 |   let cmd = has_key(a:opts, 'dir') ? s:with_cd(a:cmd, a:opts.dir) : a:cmd
1198 |   if !empty(job.batchfile)
1199 |     call writefile(['@echo off', cmd], job.batchfile)
1200 |     let cmd = job.batchfile
1201 |   endif
1202 |   let argv = add(s:is_win ? ['cmd', '/c'] : ['sh', '-c'], cmd)
1203 | 
1204 |   if s:nvim
1205 |     call extend(job, {
1206 |     \ 'on_stdout': function('s:nvim_cb'),
1207 |     \ 'on_exit':   function('s:nvim_cb'),
1208 |     \ })
1209 |     let jid = jobstart(argv, job)
1210 |     if jid > 0
1211 |       let job.jobid = jid
1212 |     else
1213 |       let job.running = 0
1214 |       let job.error   = 1
1215 |       let job.lines   = [jid < 0 ? argv[0].' is not executable' :
1216 |             \ 'Invalid arguments (or job table is full)']
1217 |     endif
1218 |   elseif s:vim8
1219 |     let jid = job_start(s:is_win ? join(argv, ' ') : argv, {
1220 |     \ 'out_cb':   function('s:job_cb', ['s:job_out_cb',  job]),
1221 |     \ 'exit_cb':  function('s:job_cb', ['s:job_exit_cb', job]),
1222 |     \ 'out_mode': 'raw'
1223 |     \})
1224 |     if job_status(jid) == 'run'
1225 |       let job.jobid = jid
1226 |     else
1227 |       let job.running = 0
1228 |       let job.error   = 1
1229 |       let job.lines   = ['Failed to start job']
1230 |     endif
1231 |   else
1232 |     let job.lines = s:lines(call('s:system', [cmd]))
1233 |     let job.error = v:shell_error != 0
1234 |     let job.running = 0
1235 |   endif
1236 | endfunction
1237 | 
1238 | function! s:reap(name)
1239 |   let job = s:jobs[a:name]
1240 |   if job.error
1241 |     call add(s:update.errors, a:name)
1242 |   elseif get(job, 'new', 0)
1243 |     let s:update.new[a:name] = 1
1244 |   endif
1245 |   let s:update.bar .= job.error ? 'x' : '='
1246 | 
1247 |   let bullet = job.error ? 'x' : '-'
1248 |   let result = job.error ? join(job.lines, "\n") : s:last_non_empty_line(job.lines)
1249 |   call s:log(bullet, a:name, empty(result) ? 'OK' : result)
1250 |   call s:bar()
1251 | 
1252 |   if has_key(job, 'batchfile') && !empty(job.batchfile)
1253 |     call delete(job.batchfile)
1254 |   endif
1255 |   call remove(s:jobs, a:name)
1256 | endfunction
1257 | 
1258 | function! s:bar()
1259 |   if s:switch_in()
1260 |     let total = len(s:update.all)
1261 |     call setline(1, (s:update.pull ? 'Updating' : 'Installing').
1262 |           \ ' plugins ('.len(s:update.bar).'/'.total.')')
1263 |     call s:progress_bar(2, s:update.bar, total)
1264 |     call s:switch_out()
1265 |   endif
1266 | endfunction
1267 | 
1268 | function! s:logpos(name)
1269 |   for i in range(4, line('$'))
1270 |     if getline(i) =~# '^[-+x*] '.a:name.':'
1271 |       for j in range(i + 1, line('$'))
1272 |         if getline(j) !~ '^ '
1273 |           return [i, j - 1]
1274 |         endif
1275 |       endfor
1276 |       return [i, i]
1277 |     endif
1278 |   endfor
1279 |   return [0, 0]
1280 | endfunction
1281 | 
1282 | function! s:log(bullet, name, lines)
1283 |   if s:switch_in()
1284 |     let [b, e] = s:logpos(a:name)
1285 |     if b > 0
1286 |       silent execute printf('%d,%d d _', b, e)
1287 |       if b > winheight('.')
1288 |         let b = 4
1289 |       endif
1290 |     else
1291 |       let b = 4
1292 |     endif
1293 |     " FIXME For some reason, nomodifiable is set after :d in vim8
1294 |     setlocal modifiable
1295 |     call append(b - 1, s:format_message(a:bullet, a:name, a:lines))
1296 |     call s:switch_out()
1297 |   endif
1298 | endfunction
1299 | 
1300 | function! s:update_vim()
1301 |   let s:jobs = {}
1302 | 
1303 |   call s:bar()
1304 |   call s:tick()
1305 | endfunction
1306 | 
1307 | function! s:tick()
1308 |   let pull = s:update.pull
1309 |   let prog = s:progress_opt(s:nvim || s:vim8)
1310 | while 1 " Without TCO, Vim stack is bound to explode
1311 |   if empty(s:update.todo)
1312 |     if empty(s:jobs) && !s:update.fin
1313 |       call s:update_finish()
1314 |       let s:update.fin = 1
1315 |     endif
1316 |     return
1317 |   endif
1318 | 
1319 |   let name = keys(s:update.todo)[0]
1320 |   let spec = remove(s:update.todo, name)
1321 |   let new  = !isdirectory(spec.dir)
1322 | 
1323 |   call s:log(new ? '+' : '*', name, pull ? 'Updating ...' : 'Installing ...')
1324 |   redraw
1325 | 
1326 |   let has_tag = has_key(spec, 'tag')
1327 |   if !new
1328 |     let [error, _] = s:git_validate(spec, 0)
1329 |     if empty(error)
1330 |       if pull
1331 |         let fetch_opt = (has_tag && !empty(globpath(spec.dir, '.git/shallow'))) ? '--depth 99999999' : ''
1332 |         call s:spawn(name, printf('git fetch %s %s 2>&1', fetch_opt, prog), { 'dir': spec.dir })
1333 |       else
1334 |         let s:jobs[name] = { 'running': 0, 'lines': ['Already installed'], 'error': 0 }
1335 |       endif
1336 |     else
1337 |       let s:jobs[name] = { 'running': 0, 'lines': s:lines(error), 'error': 1 }
1338 |     endif
1339 |   else
1340 |     call s:spawn(name,
1341 |           \ printf('git clone %s %s %s %s 2>&1',
1342 |           \ has_tag ? '' : s:clone_opt,
1343 |           \ prog,
1344 |           \ s:shellesc(spec.uri),
1345 |           \ s:shellesc(s:trim(spec.dir))), { 'new': 1 })
1346 |   endif
1347 | 
1348 |   if !s:jobs[name].running
1349 |     call s:reap(name)
1350 |   endif
1351 |   if len(s:jobs) >= s:update.threads
1352 |     break
1353 |   endif
1354 | endwhile
1355 | endfunction
1356 | 
1357 | function! s:update_python()
1358 | let py_exe = has('python') ? 'python' : 'python3'
1359 | execute py_exe "<< EOF"
1360 | import datetime
1361 | import functools
1362 | import os
1363 | try:
1364 |   import queue
1365 | except ImportError:
1366 |   import Queue as queue
1367 | import random
1368 | import re
1369 | import shutil
1370 | import signal
1371 | import subprocess
1372 | import tempfile
1373 | import threading as thr
1374 | import time
1375 | import traceback
1376 | import vim
1377 | 
1378 | G_NVIM = vim.eval("has('nvim')") == '1'
1379 | G_PULL = vim.eval('s:update.pull') == '1'
1380 | G_RETRIES = int(vim.eval('get(g:, "plug_retries", 2)')) + 1
1381 | G_TIMEOUT = int(vim.eval('get(g:, "plug_timeout", 60)'))
1382 | G_CLONE_OPT = vim.eval('s:clone_opt')
1383 | G_PROGRESS = vim.eval('s:progress_opt(1)')
1384 | G_LOG_PROB = 1.0 / int(vim.eval('s:update.threads'))
1385 | G_STOP = thr.Event()
1386 | G_IS_WIN = vim.eval('s:is_win') == '1'
1387 | 
1388 | class PlugError(Exception):
1389 |   def __init__(self, msg):
1390 |     self.msg = msg
1391 | class CmdTimedOut(PlugError):
1392 |   pass
1393 | class CmdFailed(PlugError):
1394 |   pass
1395 | class InvalidURI(PlugError):
1396 |   pass
1397 | class Action(object):
1398 |   INSTALL, UPDATE, ERROR, DONE = ['+', '*', 'x', '-']
1399 | 
1400 | class Buffer(object):
1401 |   def __init__(self, lock, num_plugs, is_pull):
1402 |     self.bar = ''
1403 |     self.event = 'Updating' if is_pull else 'Installing'
1404 |     self.lock = lock
1405 |     self.maxy = int(vim.eval('winheight(".")'))
1406 |     self.num_plugs = num_plugs
1407 | 
1408 |   def __where(self, name):
1409 |     """ Find first line with name in current buffer. Return line num. """
1410 |     found, lnum = False, 0
1411 |     matcher = re.compile('^[-+x*] {0}:'.format(name))
1412 |     for line in vim.current.buffer:
1413 |       if matcher.search(line) is not None:
1414 |         found = True
1415 |         break
1416 |       lnum += 1
1417 | 
1418 |     if not found:
1419 |       lnum = -1
1420 |     return lnum
1421 | 
1422 |   def header(self):
1423 |     curbuf = vim.current.buffer
1424 |     curbuf[0] = self.event + ' plugins ({0}/{1})'.format(len(self.bar), self.num_plugs)
1425 | 
1426 |     num_spaces = self.num_plugs - len(self.bar)
1427 |     curbuf[1] = '[{0}{1}]'.format(self.bar, num_spaces * ' ')
1428 | 
1429 |     with self.lock:
1430 |       vim.command('normal! 2G')
1431 |       vim.command('redraw')
1432 | 
1433 |   def write(self, action, name, lines):
1434 |     first, rest = lines[0], lines[1:]
1435 |     msg = ['{0} {1}{2}{3}'.format(action, name, ': ' if first else '', first)]
1436 |     msg.extend(['    ' + line for line in rest])
1437 | 
1438 |     try:
1439 |       if action == Action.ERROR:
1440 |         self.bar += 'x'
1441 |         vim.command("call add(s:update.errors, '{0}')".format(name))
1442 |       elif action == Action.DONE:
1443 |         self.bar += '='
1444 | 
1445 |       curbuf = vim.current.buffer
1446 |       lnum = self.__where(name)
1447 |       if lnum != -1: # Found matching line num
1448 |         del curbuf[lnum]
1449 |         if lnum > self.maxy and action in set([Action.INSTALL, Action.UPDATE]):
1450 |           lnum = 3
1451 |       else:
1452 |         lnum = 3
1453 |       curbuf.append(msg, lnum)
1454 | 
1455 |       self.header()
1456 |     except vim.error:
1457 |       pass
1458 | 
1459 | class Command(object):
1460 |   CD = 'cd /d' if G_IS_WIN else 'cd'
1461 | 
1462 |   def __init__(self, cmd, cmd_dir=None, timeout=60, cb=None, clean=None):
1463 |     self.cmd = cmd
1464 |     if cmd_dir:
1465 |       self.cmd = '{0} {1} && {2}'.format(Command.CD, cmd_dir, self.cmd)
1466 |     self.timeout = timeout
1467 |     self.callback = cb if cb else (lambda msg: None)
1468 |     self.clean = clean if clean else (lambda: None)
1469 |     self.proc = None
1470 | 
1471 |   @property
1472 |   def alive(self):
1473 |     """ Returns true only if command still running. """
1474 |     return self.proc and self.proc.poll() is None
1475 | 
1476 |   def execute(self, ntries=3):
1477 |     """ Execute the command with ntries if CmdTimedOut.
1478 |         Returns the output of the command if no Exception.
1479 |     """
1480 |     attempt, finished, limit = 0, False, self.timeout
1481 | 
1482 |     while not finished:
1483 |       try:
1484 |         attempt += 1
1485 |         result = self.try_command()
1486 |         finished = True
1487 |         return result
1488 |       except CmdTimedOut:
1489 |         if attempt != ntries:
1490 |           self.notify_retry()
1491 |           self.timeout += limit
1492 |         else:
1493 |           raise
1494 | 
1495 |   def notify_retry(self):
1496 |     """ Retry required for command, notify user. """
1497 |     for count in range(3, 0, -1):
1498 |       if G_STOP.is_set():
1499 |         raise KeyboardInterrupt
1500 |       msg = 'Timeout. Will retry in {0} second{1} ...'.format(
1501 |             count, 's' if count != 1 else '')
1502 |       self.callback([msg])
1503 |       time.sleep(1)
1504 |     self.callback(['Retrying ...'])
1505 | 
1506 |   def try_command(self):
1507 |     """ Execute a cmd & poll for callback. Returns list of output.
1508 |         Raises CmdFailed   -> return code for Popen isn't 0
1509 |         Raises CmdTimedOut -> command exceeded timeout without new output
1510 |     """
1511 |     first_line = True
1512 | 
1513 |     try:
1514 |       tfile = tempfile.NamedTemporaryFile(mode='w+b')
1515 |       preexec_fn = not G_IS_WIN and os.setsid or None
1516 |       self.proc = subprocess.Popen(self.cmd, stdout=tfile,
1517 |                                    stderr=subprocess.STDOUT,
1518 |                                    stdin=subprocess.PIPE, shell=True,
1519 |                                    preexec_fn=preexec_fn)
1520 |       thrd = thr.Thread(target=(lambda proc: proc.wait()), args=(self.proc,))
1521 |       thrd.start()
1522 | 
1523 |       thread_not_started = True
1524 |       while thread_not_started:
1525 |         try:
1526 |           thrd.join(0.1)
1527 |           thread_not_started = False
1528 |         except RuntimeError:
1529 |           pass
1530 | 
1531 |       while self.alive:
1532 |         if G_STOP.is_set():
1533 |           raise KeyboardInterrupt
1534 | 
1535 |         if first_line or random.random() < G_LOG_PROB:
1536 |           first_line = False
1537 |           line = '' if G_IS_WIN else nonblock_read(tfile.name)
1538 |           if line:
1539 |             self.callback([line])
1540 | 
1541 |         time_diff = time.time() - os.path.getmtime(tfile.name)
1542 |         if time_diff > self.timeout:
1543 |           raise CmdTimedOut(['Timeout!'])
1544 | 
1545 |         thrd.join(0.5)
1546 | 
1547 |       tfile.seek(0)
1548 |       result = [line.decode('utf-8', 'replace').rstrip() for line in tfile]
1549 | 
1550 |       if self.proc.returncode != 0:
1551 |         raise CmdFailed([''] + result)
1552 | 
1553 |       return result
1554 |     except:
1555 |       self.terminate()
1556 |       raise
1557 | 
1558 |   def terminate(self):
1559 |     """ Terminate process and cleanup. """
1560 |     if self.alive:
1561 |       if G_IS_WIN:
1562 |         os.kill(self.proc.pid, signal.SIGINT)
1563 |       else:
1564 |         os.killpg(self.proc.pid, signal.SIGTERM)
1565 |     self.clean()
1566 | 
1567 | class Plugin(object):
1568 |   def __init__(self, name, args, buf_q, lock):
1569 |     self.name = name
1570 |     self.args = args
1571 |     self.buf_q = buf_q
1572 |     self.lock = lock
1573 |     self.tag = args.get('tag', 0)
1574 | 
1575 |   def manage(self):
1576 |     try:
1577 |       if os.path.exists(self.args['dir']):
1578 |         self.update()
1579 |       else:
1580 |         self.install()
1581 |         with self.lock:
1582 |           thread_vim_command("let s:update.new['{0}'] = 1".format(self.name))
1583 |     except PlugError as exc:
1584 |       self.write(Action.ERROR, self.name, exc.msg)
1585 |     except KeyboardInterrupt:
1586 |       G_STOP.set()
1587 |       self.write(Action.ERROR, self.name, ['Interrupted!'])
1588 |     except:
1589 |       # Any exception except those above print stack trace
1590 |       msg = 'Trace:\n{0}'.format(traceback.format_exc().rstrip())
1591 |       self.write(Action.ERROR, self.name, msg.split('\n'))
1592 |       raise
1593 | 
1594 |   def install(self):
1595 |     target = self.args['dir']
1596 |     if target[-1] == '\\':
1597 |       target = target[0:-1]
1598 | 
1599 |     def clean(target):
1600 |       def _clean():
1601 |         try:
1602 |           shutil.rmtree(target)
1603 |         except OSError:
1604 |           pass
1605 |       return _clean
1606 | 
1607 |     self.write(Action.INSTALL, self.name, ['Installing ...'])
1608 |     callback = functools.partial(self.write, Action.INSTALL, self.name)
1609 |     cmd = 'git clone {0} {1} {2} {3} 2>&1'.format(
1610 |           '' if self.tag else G_CLONE_OPT, G_PROGRESS, self.args['uri'],
1611 |           esc(target))
1612 |     com = Command(cmd, None, G_TIMEOUT, callback, clean(target))
1613 |     result = com.execute(G_RETRIES)
1614 |     self.write(Action.DONE, self.name, result[-1:])
1615 | 
1616 |   def repo_uri(self):
1617 |     cmd = 'git rev-parse --abbrev-ref HEAD 2>&1 && git config -f .git/config remote.origin.url'
1618 |     command = Command(cmd, self.args['dir'], G_TIMEOUT,)
1619 |     result = command.execute(G_RETRIES)
1620 |     return result[-1]
1621 | 
1622 |   def update(self):
1623 |     actual_uri = self.repo_uri()
1624 |     expect_uri = self.args['uri']
1625 |     regex = re.compile(r'^(?:\w+://)?(?:[^@/]*@)?([^:/]*(?::[0-9]*)?)[:/](.*?)(?:\.git)?/?$')
1626 |     ma = regex.match(actual_uri)
1627 |     mb = regex.match(expect_uri)
1628 |     if ma is None or mb is None or ma.groups() != mb.groups():
1629 |       msg = ['',
1630 |              'Invalid URI: {0}'.format(actual_uri),
1631 |              'Expected     {0}'.format(expect_uri),
1632 |              'PlugClean required.']
1633 |       raise InvalidURI(msg)
1634 | 
1635 |     if G_PULL:
1636 |       self.write(Action.UPDATE, self.name, ['Updating ...'])
1637 |       callback = functools.partial(self.write, Action.UPDATE, self.name)
1638 |       fetch_opt = '--depth 99999999' if self.tag and os.path.isfile(os.path.join(self.args['dir'], '.git/shallow')) else ''
1639 |       cmd = 'git fetch {0} {1} 2>&1'.format(fetch_opt, G_PROGRESS)
1640 |       com = Command(cmd, self.args['dir'], G_TIMEOUT, callback)
1641 |       result = com.execute(G_RETRIES)
1642 |       self.write(Action.DONE, self.name, result[-1:])
1643 |     else:
1644 |       self.write(Action.DONE, self.name, ['Already installed'])
1645 | 
1646 |   def write(self, action, name, msg):
1647 |     self.buf_q.put((action, name, msg))
1648 | 
1649 | class PlugThread(thr.Thread):
1650 |   def __init__(self, tname, args):
1651 |     super(PlugThread, self).__init__()
1652 |     self.tname = tname
1653 |     self.args = args
1654 | 
1655 |   def run(self):
1656 |     thr.current_thread().name = self.tname
1657 |     buf_q, work_q, lock = self.args
1658 | 
1659 |     try:
1660 |       while not G_STOP.is_set():
1661 |         name, args = work_q.get_nowait()
1662 |         plug = Plugin(name, args, buf_q, lock)
1663 |         plug.manage()
1664 |         work_q.task_done()
1665 |     except queue.Empty:
1666 |       pass
1667 | 
1668 | class RefreshThread(thr.Thread):
1669 |   def __init__(self, lock):
1670 |     super(RefreshThread, self).__init__()
1671 |     self.lock = lock
1672 |     self.running = True
1673 | 
1674 |   def run(self):
1675 |     while self.running:
1676 |       with self.lock:
1677 |         thread_vim_command('noautocmd normal! a')
1678 |       time.sleep(0.33)
1679 | 
1680 |   def stop(self):
1681 |     self.running = False
1682 | 
1683 | if G_NVIM:
1684 |   def thread_vim_command(cmd):
1685 |     vim.session.threadsafe_call(lambda: vim.command(cmd))
1686 | else:
1687 |   def thread_vim_command(cmd):
1688 |     vim.command(cmd)
1689 | 
1690 | def esc(name):
1691 |   return '"' + name.replace('"', '\"') + '"'
1692 | 
1693 | def nonblock_read(fname):
1694 |   """ Read a file with nonblock flag. Return the last line. """
1695 |   fread = os.open(fname, os.O_RDONLY | os.O_NONBLOCK)
1696 |   buf = os.read(fread, 100000).decode('utf-8', 'replace')
1697 |   os.close(fread)
1698 | 
1699 |   line = buf.rstrip('\r\n')
1700 |   left = max(line.rfind('\r'), line.rfind('\n'))
1701 |   if left != -1:
1702 |     left += 1
1703 |     line = line[left:]
1704 | 
1705 |   return line
1706 | 
1707 | def main():
1708 |   thr.current_thread().name = 'main'
1709 |   nthreads = int(vim.eval('s:update.threads'))
1710 |   plugs = vim.eval('s:update.todo')
1711 |   mac_gui = vim.eval('s:mac_gui') == '1'
1712 | 
1713 |   lock = thr.Lock()
1714 |   buf = Buffer(lock, len(plugs), G_PULL)
1715 |   buf_q, work_q = queue.Queue(), queue.Queue()
1716 |   for work in plugs.items():
1717 |     work_q.put(work)
1718 | 
1719 |   start_cnt = thr.active_count()
1720 |   for num in range(nthreads):
1721 |     tname = 'PlugT-{0:02}'.format(num)
1722 |     thread = PlugThread(tname, (buf_q, work_q, lock))
1723 |     thread.start()
1724 |   if mac_gui:
1725 |     rthread = RefreshThread(lock)
1726 |     rthread.start()
1727 | 
1728 |   while not buf_q.empty() or thr.active_count() != start_cnt:
1729 |     try:
1730 |       action, name, msg = buf_q.get(True, 0.25)
1731 |       buf.write(action, name, ['OK'] if not msg else msg)
1732 |       buf_q.task_done()
1733 |     except queue.Empty:
1734 |       pass
1735 |     except KeyboardInterrupt:
1736 |       G_STOP.set()
1737 | 
1738 |   if mac_gui:
1739 |     rthread.stop()
1740 |     rthread.join()
1741 | 
1742 | main()
1743 | EOF
1744 | endfunction
1745 | 
1746 | function! s:update_ruby()
1747 |   ruby << EOF
1748 |   module PlugStream
1749 |     SEP = ["\r", "\n", nil]
1750 |     def get_line
1751 |       buffer = ''
1752 |       loop do
1753 |         char = readchar rescue return
1754 |         if SEP.include? char.chr
1755 |           buffer << $/
1756 |           break
1757 |         else
1758 |           buffer << char
1759 |         end
1760 |       end
1761 |       buffer
1762 |     end
1763 |   end unless defined?(PlugStream)
1764 | 
1765 |   def esc arg
1766 |     %["#{arg.gsub('"', '\"')}"]
1767 |   end
1768 | 
1769 |   def killall pid
1770 |     pids = [pid]
1771 |     if /mswin|mingw|bccwin/ =~ RUBY_PLATFORM
1772 |       pids.each { |pid| Process.kill 'INT', pid.to_i rescue nil }
1773 |     else
1774 |       unless `which pgrep 2> /dev/null`.empty?
1775 |         children = pids
1776 |         until children.empty?
1777 |           children = children.map { |pid|
1778 |             `pgrep -P #{pid}`.lines.map { |l| l.chomp }
1779 |           }.flatten
1780 |           pids += children
1781 |         end
1782 |       end
1783 |       pids.each { |pid| Process.kill 'TERM', pid.to_i rescue nil }
1784 |     end
1785 |   end
1786 | 
1787 |   def compare_git_uri a, b
1788 |     regex = %r{^(?:\w+://)?(?:[^@/]*@)?([^:/]*(?::[0-9]*)?)[:/](.*?)(?:\.git)?/?$}
1789 |     regex.match(a).to_a.drop(1) == regex.match(b).to_a.drop(1)
1790 |   end
1791 | 
1792 |   require 'thread'
1793 |   require 'fileutils'
1794 |   require 'timeout'
1795 |   running = true
1796 |   iswin = VIM::evaluate('s:is_win').to_i == 1
1797 |   pull  = VIM::evaluate('s:update.pull').to_i == 1
1798 |   base  = VIM::evaluate('g:plug_home')
1799 |   all   = VIM::evaluate('s:update.todo')
1800 |   limit = VIM::evaluate('get(g:, "plug_timeout", 60)')
1801 |   tries = VIM::evaluate('get(g:, "plug_retries", 2)') + 1
1802 |   nthr  = VIM::evaluate('s:update.threads').to_i
1803 |   maxy  = VIM::evaluate('winheight(".")').to_i
1804 |   vim7  = VIM::evaluate('v:version').to_i <= 703 && RUBY_PLATFORM =~ /darwin/
1805 |   cd    = iswin ? 'cd /d' : 'cd'
1806 |   tot   = VIM::evaluate('len(s:update.todo)') || 0
1807 |   bar   = ''
1808 |   skip  = 'Already installed'
1809 |   mtx   = Mutex.new
1810 |   take1 = proc { mtx.synchronize { running && all.shift } }
1811 |   logh  = proc {
1812 |     cnt = bar.length
1813 |     $curbuf[1] = "#{pull ? 'Updating' : 'Installing'} plugins (#{cnt}/#{tot})"
1814 |     $curbuf[2] = '[' + bar.ljust(tot) + ']'
1815 |     VIM::command('normal! 2G')
1816 |     VIM::command('redraw')
1817 |   }
1818 |   where = proc { |name| (1..($curbuf.length)).find { |l| $curbuf[l] =~ /^[-+x*] #{name}:/ } }
1819 |   log   = proc { |name, result, type|
1820 |     mtx.synchronize do
1821 |       ing  = ![true, false].include?(type)
1822 |       bar += type ? '=' : 'x' unless ing
1823 |       b = case type
1824 |           when :install  then '+' when :update then '*'
1825 |           when true, nil then '-' else
1826 |             VIM::command("call add(s:update.errors, '#{name}')")
1827 |             'x'
1828 |           end
1829 |       result =
1830 |         if type || type.nil?
1831 |           ["#{b} #{name}: #{result.lines.to_a.last || 'OK'}"]
1832 |         elsif result =~ /^Interrupted|^Timeout/
1833 |           ["#{b} #{name}: #{result}"]
1834 |         else
1835 |           ["#{b} #{name}"] + result.lines.map { |l| "    " << l }
1836 |         end
1837 |       if lnum = where.call(name)
1838 |         $curbuf.delete lnum
1839 |         lnum = 4 if ing && lnum > maxy
1840 |       end
1841 |       result.each_with_index do |line, offset|
1842 |         $curbuf.append((lnum || 4) - 1 + offset, line.gsub(/\e\[./, '').chomp)
1843 |       end
1844 |       logh.call
1845 |     end
1846 |   }
1847 |   bt = proc { |cmd, name, type, cleanup|
1848 |     tried = timeout = 0
1849 |     begin
1850 |       tried += 1
1851 |       timeout += limit
1852 |       fd = nil
1853 |       data = ''
1854 |       if iswin
1855 |         Timeout::timeout(timeout) do
1856 |           tmp = VIM::evaluate('tempname()')
1857 |           system("(#{cmd}) > #{tmp}")
1858 |           data = File.read(tmp).chomp
1859 |           File.unlink tmp rescue nil
1860 |         end
1861 |       else
1862 |         fd = IO.popen(cmd).extend(PlugStream)
1863 |         first_line = true
1864 |         log_prob = 1.0 / nthr
1865 |         while line = Timeout::timeout(timeout) { fd.get_line }
1866 |           data << line
1867 |           log.call name, line.chomp, type if name && (first_line || rand < log_prob)
1868 |           first_line = false
1869 |         end
1870 |         fd.close
1871 |       end
1872 |       [$? == 0, data.chomp]
1873 |     rescue Timeout::Error, Interrupt => e
1874 |       if fd && !fd.closed?
1875 |         killall fd.pid
1876 |         fd.close
1877 |       end
1878 |       cleanup.call if cleanup
1879 |       if e.is_a?(Timeout::Error) && tried < tries
1880 |         3.downto(1) do |countdown|
1881 |           s = countdown > 1 ? 's' : ''
1882 |           log.call name, "Timeout. Will retry in #{countdown} second#{s} ...", type
1883 |           sleep 1
1884 |         end
1885 |         log.call name, 'Retrying ...', type
1886 |         retry
1887 |       end
1888 |       [false, e.is_a?(Interrupt) ? "Interrupted!" : "Timeout!"]
1889 |     end
1890 |   }
1891 |   main = Thread.current
1892 |   threads = []
1893 |   watcher = Thread.new {
1894 |     if vim7
1895 |       while VIM::evaluate('getchar(1)')
1896 |         sleep 0.1
1897 |       end
1898 |     else
1899 |       require 'io/console' # >= Ruby 1.9
1900 |       nil until IO.console.getch == 3.chr
1901 |     end
1902 |     mtx.synchronize do
1903 |       running = false
1904 |       threads.each { |t| t.raise Interrupt } unless vim7
1905 |     end
1906 |     threads.each { |t| t.join rescue nil }
1907 |     main.kill
1908 |   }
1909 |   refresh = Thread.new {
1910 |     while true
1911 |       mtx.synchronize do
1912 |         break unless running
1913 |         VIM::command('noautocmd normal! a')
1914 |       end
1915 |       sleep 0.2
1916 |     end
1917 |   } if VIM::evaluate('s:mac_gui') == 1
1918 | 
1919 |   clone_opt = VIM::evaluate('s:clone_opt')
1920 |   progress = VIM::evaluate('s:progress_opt(1)')
1921 |   nthr.times do
1922 |     mtx.synchronize do
1923 |       threads << Thread.new {
1924 |         while pair = take1.call
1925 |           name = pair.first
1926 |           dir, uri, tag = pair.last.values_at *%w[dir uri tag]
1927 |           exists = File.directory? dir
1928 |           ok, result =
1929 |             if exists
1930 |               chdir = "#{cd} #{iswin ? dir : esc(dir)}"
1931 |               ret, data = bt.call "#{chdir} && git rev-parse --abbrev-ref HEAD 2>&1 && git config -f .git/config remote.origin.url", nil, nil, nil
1932 |               current_uri = data.lines.to_a.last
1933 |               if !ret
1934 |                 if data =~ /^Interrupted|^Timeout/
1935 |                   [false, data]
1936 |                 else
1937 |                   [false, [data.chomp, "PlugClean required."].join($/)]
1938 |                 end
1939 |               elsif !compare_git_uri(current_uri, uri)
1940 |                 [false, ["Invalid URI: #{current_uri}",
1941 |                          "Expected:    #{uri}",
1942 |                          "PlugClean required."].join($/)]
1943 |               else
1944 |                 if pull
1945 |                   log.call name, 'Updating ...', :update
1946 |                   fetch_opt = (tag && File.exist?(File.join(dir, '.git/shallow'))) ? '--depth 99999999' : ''
1947 |                   bt.call "#{chdir} && git fetch #{fetch_opt} #{progress} 2>&1", name, :update, nil
1948 |                 else
1949 |                   [true, skip]
1950 |                 end
1951 |               end
1952 |             else
1953 |               d = esc dir.sub(%r{[\\/]+$}, '')
1954 |               log.call name, 'Installing ...', :install
1955 |               bt.call "git clone #{clone_opt unless tag} #{progress} #{uri} #{d} 2>&1", name, :install, proc {
1956 |                 FileUtils.rm_rf dir
1957 |               }
1958 |             end
1959 |           mtx.synchronize { VIM::command("let s:update.new['#{name}'] = 1") } if !exists && ok
1960 |           log.call name, result, ok
1961 |         end
1962 |       } if running
1963 |     end
1964 |   end
1965 |   threads.each { |t| t.join rescue nil }
1966 |   logh.call
1967 |   refresh.kill if refresh
1968 |   watcher.kill
1969 | EOF
1970 | endfunction
1971 | 
1972 | function! s:shellesc_cmd(arg)
1973 |   let escaped = substitute(a:arg, '[&|<>()@^]', '^&', 'g')
1974 |   let escaped = substitute(escaped, '%', '%%', 'g')
1975 |   let escaped = substitute(escaped, '"', '\\^&', 'g')
1976 |   let escaped = substitute(escaped, '\(\\\+\)\(\\^\)', '\1\1\2', 'g')
1977 |   return '^"'.substitute(escaped, '\(\\\+\)$', '\1\1', '').'^"'
1978 | endfunction
1979 | 
1980 | function! s:shellesc(arg)
1981 |   if &shell =~# 'cmd.exe$'
1982 |     return s:shellesc_cmd(a:arg)
1983 |   endif
1984 |   return shellescape(a:arg)
1985 | endfunction
1986 | 
1987 | function! s:glob_dir(path)
1988 |   return map(filter(s:glob(a:path, '**'), 'isdirectory(v:val)'), 's:dirpath(v:val)')
1989 | endfunction
1990 | 
1991 | function! s:progress_bar(line, bar, total)
1992 |   call setline(a:line, '[' . s:lpad(a:bar, a:total) . ']')
1993 | endfunction
1994 | 
1995 | function! s:compare_git_uri(a, b)
1996 |   " See `git help clone'
1997 |   " https:// [user@] github.com[:port] / junegunn/vim-plug [.git]
1998 |   "          [git@]  github.com[:port] : junegunn/vim-plug [.git]
1999 |   " file://                            / junegunn/vim-plug        [/]
2000 |   "                                    / junegunn/vim-plug        [/]
2001 |   let pat = '^\%(\w\+://\)\='.'\%([^@/]*@\)\='.'\([^:/]*\%(:[0-9]*\)\=\)'.'[:/]'.'\(.\{-}\)'.'\%(\.git\)\=/\?$'
2002 |   let ma = matchlist(a:a, pat)
2003 |   let mb = matchlist(a:b, pat)
2004 |   return ma[1:2] ==# mb[1:2]
2005 | endfunction
2006 | 
2007 | function! s:format_message(bullet, name, message)
2008 |   if a:bullet != 'x'
2009 |     return [printf('%s %s: %s', a:bullet, a:name, s:lastline(a:message))]
2010 |   else
2011 |     let lines = map(s:lines(a:message), '"    ".v:val')
2012 |     return extend([printf('x %s:', a:name)], lines)
2013 |   endif
2014 | endfunction
2015 | 
2016 | function! s:with_cd(cmd, dir)
2017 |   return printf('cd%s %s && %s', s:is_win ? ' /d' : '', s:shellesc(a:dir), a:cmd)
2018 | endfunction
2019 | 
2020 | function! s:system(cmd, ...)
2021 |   try
2022 |     let [sh, shellcmdflag, shrd] = s:chsh(1)
2023 |     let cmd = a:0 > 0 ? s:with_cd(a:cmd, a:1) : a:cmd
2024 |     if s:is_win
2025 |       let batchfile = tempname().'.bat'
2026 |       call writefile(['@echo off', cmd], batchfile)
2027 |       let cmd = batchfile
2028 |     endif
2029 |     return system(s:is_win ? '('.cmd.')' : cmd)
2030 |   finally
2031 |     let [&shell, &shellcmdflag, &shellredir] = [sh, shellcmdflag, shrd]
2032 |     if s:is_win
2033 |       call delete(batchfile)
2034 |     endif
2035 |   endtry
2036 | endfunction
2037 | 
2038 | function! s:system_chomp(...)
2039 |   let ret = call('s:system', a:000)
2040 |   return v:shell_error ? '' : substitute(ret, '\n$', '', '')
2041 | endfunction
2042 | 
2043 | function! s:git_validate(spec, check_branch)
2044 |   let err = ''
2045 |   if isdirectory(a:spec.dir)
2046 |     let result = s:lines(s:system('git rev-parse --abbrev-ref HEAD 2>&1 && git config -f .git/config remote.origin.url', a:spec.dir))
2047 |     let remote = result[-1]
2048 |     if v:shell_error
2049 |       let err = join([remote, 'PlugClean required.'], "\n")
2050 |     elseif !s:compare_git_uri(remote, a:spec.uri)
2051 |       let err = join(['Invalid URI: '.remote,
2052 |                     \ 'Expected:    '.a:spec.uri,
2053 |                     \ 'PlugClean required.'], "\n")
2054 |     elseif a:check_branch && has_key(a:spec, 'commit')
2055 |       let result = s:lines(s:system('git rev-parse HEAD 2>&1', a:spec.dir))
2056 |       let sha = result[-1]
2057 |       if v:shell_error
2058 |         let err = join(add(result, 'PlugClean required.'), "\n")
2059 |       elseif !s:hash_match(sha, a:spec.commit)
2060 |         let err = join([printf('Invalid HEAD (expected: %s, actual: %s)',
2061 |                               \ a:spec.commit[:6], sha[:6]),
2062 |                       \ 'PlugUpdate required.'], "\n")
2063 |       endif
2064 |     elseif a:check_branch
2065 |       let branch = result[0]
2066 |       " Check tag
2067 |       if has_key(a:spec, 'tag')
2068 |         let tag = s:system_chomp('git describe --exact-match --tags HEAD 2>&1', a:spec.dir)
2069 |         if a:spec.tag !=# tag && a:spec.tag !~ '\*'
2070 |           let err = printf('Invalid tag: %s (expected: %s). Try PlugUpdate.',
2071 |                 \ (empty(tag) ? 'N/A' : tag), a:spec.tag)
2072 |         endif
2073 |       " Check branch
2074 |       elseif a:spec.branch !=# branch
2075 |         let err = printf('Invalid branch: %s (expected: %s). Try PlugUpdate.',
2076 |               \ branch, a:spec.branch)
2077 |       endif
2078 |       if empty(err)
2079 |         let [ahead, behind] = split(s:lastline(s:system(printf(
2080 |               \ 'git rev-list --count --left-right HEAD...origin/%s',
2081 |               \ a:spec.branch), a:spec.dir)), '\t')
2082 |         if !v:shell_error && ahead
2083 |           if behind
2084 |             " Only mention PlugClean if diverged, otherwise it's likely to be
2085 |             " pushable (and probably not that messed up).
2086 |             let err = printf(
2087 |                   \ "Diverged from origin/%s (%d commit(s) ahead and %d commit(s) behind!\n"
2088 |                   \ .'Backup local changes and run PlugClean and PlugUpdate to reinstall it.', a:spec.branch, ahead, behind)
2089 |           else
2090 |             let err = printf("Ahead of origin/%s by %d commit(s).\n"
2091 |                   \ .'Cannot update until local changes are pushed.',
2092 |                   \ a:spec.branch, ahead)
2093 |           endif
2094 |         endif
2095 |       endif
2096 |     endif
2097 |   else
2098 |     let err = 'Not found'
2099 |   endif
2100 |   return [err, err =~# 'PlugClean']
2101 | endfunction
2102 | 
2103 | function! s:rm_rf(dir)
2104 |   if isdirectory(a:dir)
2105 |     call s:system((s:is_win ? 'rmdir /S /Q ' : 'rm -rf ') . s:shellesc(a:dir))
2106 |   endif
2107 | endfunction
2108 | 
2109 | function! s:clean(force)
2110 |   call s:prepare()
2111 |   call append(0, 'Searching for invalid plugins in '.g:plug_home)
2112 |   call append(1, '')
2113 | 
2114 |   " List of valid directories
2115 |   let dirs = []
2116 |   let errs = {}
2117 |   let [cnt, total] = [0, len(g:plugs)]
2118 |   for [name, spec] in items(g:plugs)
2119 |     if !s:is_managed(name)
2120 |       call add(dirs, spec.dir)
2121 |     else
2122 |       let [err, clean] = s:git_validate(spec, 1)
2123 |       if clean
2124 |         let errs[spec.dir] = s:lines(err)[0]
2125 |       else
2126 |         call add(dirs, spec.dir)
2127 |       endif
2128 |     endif
2129 |     let cnt += 1
2130 |     call s:progress_bar(2, repeat('=', cnt), total)
2131 |     normal! 2G
2132 |     redraw
2133 |   endfor
2134 | 
2135 |   let allowed = {}
2136 |   for dir in dirs
2137 |     let allowed[s:dirpath(fnamemodify(dir, ':h:h'))] = 1
2138 |     let allowed[dir] = 1
2139 |     for child in s:glob_dir(dir)
2140 |       let allowed[child] = 1
2141 |     endfor
2142 |   endfor
2143 | 
2144 |   let todo = []
2145 |   let found = sort(s:glob_dir(g:plug_home))
2146 |   while !empty(found)
2147 |     let f = remove(found, 0)
2148 |     if !has_key(allowed, f) && isdirectory(f)
2149 |       call add(todo, f)
2150 |       call append(line('$'), '- ' . f)
2151 |       if has_key(errs, f)
2152 |         call append(line('$'), '    ' . errs[f])
2153 |       endif
2154 |       let found = filter(found, 'stridx(v:val, f) != 0')
2155 |     end
2156 |   endwhile
2157 | 
2158 |   4
2159 |   redraw
2160 |   if empty(todo)
2161 |     call append(line('$'), 'Already clean.')
2162 |   else
2163 |     let s:clean_count = 0
2164 |     call append(3, ['Directories to delete:', ''])
2165 |     redraw!
2166 |     if a:force || s:ask_no_interrupt('Delete all directories?')
2167 |       call s:delete([6, line('$')], 1)
2168 |     else
2169 |       call setline(4, 'Cancelled.')
2170 |       nnoremap <silent> <buffer> d :set opfunc=<sid>delete_op<cr>g@
2171 |       nmap     <silent> <buffer> dd d_
2172 |       xnoremap <silent> <buffer> d :<c-u>call <sid>delete_op(visualmode(), 1)<cr>
2173 |       echo 'Delete the lines (d{motion}) to delete the corresponding directories'
2174 |     endif
2175 |   endif
2176 |   4
2177 |   setlocal nomodifiable
2178 | endfunction
2179 | 
2180 | function! s:delete_op(type, ...)
2181 |   call s:delete(a:0 ? [line("'<"), line("'>")] : [line("'["), line("']")], 0)
2182 | endfunction
2183 | 
2184 | function! s:delete(range, force)
2185 |   let [l1, l2] = a:range
2186 |   let force = a:force
2187 |   while l1 <= l2
2188 |     let line = getline(l1)
2189 |     if line =~ '^- ' && isdirectory(line[2:])
2190 |       execute l1
2191 |       redraw!
2192 |       let answer = force ? 1 : s:ask('Delete '.line[2:].'?', 1)
2193 |       let force = force || answer > 1
2194 |       if answer
2195 |         call s:rm_rf(line[2:])
2196 |         setlocal modifiable
2197 |         call setline(l1, '~'.line[1:])
2198 |         let s:clean_count += 1
2199 |         call setline(4, printf('Removed %d directories.', s:clean_count))
2200 |         setlocal nomodifiable
2201 |       endif
2202 |     endif
2203 |     let l1 += 1
2204 |   endwhile
2205 | endfunction
2206 | 
2207 | function! s:upgrade()
2208 |   echo 'Downloading the latest version of vim-plug'
2209 |   redraw
2210 |   let tmp = tempname()
2211 |   let new = tmp . '/plug.vim'
2212 | 
2213 |   try
2214 |     let out = s:system(printf('git clone --depth 1 %s %s', s:plug_src, tmp))
2215 |     if v:shell_error
2216 |       return s:err('Error upgrading vim-plug: '. out)
2217 |     endif
2218 | 
2219 |     if readfile(s:me) ==# readfile(new)
2220 |       echo 'vim-plug is already up-to-date'
2221 |       return 0
2222 |     else
2223 |       call rename(s:me, s:me . '.old')
2224 |       call rename(new, s:me)
2225 |       unlet g:loaded_plug
2226 |       echo 'vim-plug has been upgraded'
2227 |       return 1
2228 |     endif
2229 |   finally
2230 |     silent! call s:rm_rf(tmp)
2231 |   endtry
2232 | endfunction
2233 | 
2234 | function! s:upgrade_specs()
2235 |   for spec in values(g:plugs)
2236 |     let spec.frozen = get(spec, 'frozen', 0)
2237 |   endfor
2238 | endfunction
2239 | 
2240 | function! s:status()
2241 |   call s:prepare()
2242 |   call append(0, 'Checking plugins')
2243 |   call append(1, '')
2244 | 
2245 |   let ecnt = 0
2246 |   let unloaded = 0
2247 |   let [cnt, total] = [0, len(g:plugs)]
2248 |   for [name, spec] in items(g:plugs)
2249 |     let is_dir = isdirectory(spec.dir)
2250 |     if has_key(spec, 'uri')
2251 |       if is_dir
2252 |         let [err, _] = s:git_validate(spec, 1)
2253 |         let [valid, msg] = [empty(err), empty(err) ? 'OK' : err]
2254 |       else
2255 |         let [valid, msg] = [0, 'Not found. Try PlugInstall.']
2256 |       endif
2257 |     else
2258 |       if is_dir
2259 |         let [valid, msg] = [1, 'OK']
2260 |       else
2261 |         let [valid, msg] = [0, 'Not found.']
2262 |       endif
2263 |     endif
2264 |     let cnt += 1
2265 |     let ecnt += !valid
2266 |     " `s:loaded` entry can be missing if PlugUpgraded
2267 |     if is_dir && get(s:loaded, name, -1) == 0
2268 |       let unloaded = 1
2269 |       let msg .= ' (not loaded)'
2270 |     endif
2271 |     call s:progress_bar(2, repeat('=', cnt), total)
2272 |     call append(3, s:format_message(valid ? '-' : 'x', name, msg))
2273 |     normal! 2G
2274 |     redraw
2275 |   endfor
2276 |   call setline(1, 'Finished. '.ecnt.' error(s).')
2277 |   normal! gg
2278 |   setlocal nomodifiable
2279 |   if unloaded
2280 |     echo "Press 'L' on each line to load plugin, or 'U' to update"
2281 |     nnoremap <silent> <buffer> L :call <SID>status_load(line('.'))<cr>
2282 |     xnoremap <silent> <buffer> L :call <SID>status_load(line('.'))<cr>
2283 |   end
2284 | endfunction
2285 | 
2286 | function! s:extract_name(str, prefix, suffix)
2287 |   return matchstr(a:str, '^'.a:prefix.' \zs[^:]\+\ze:.*'.a:suffix.'$')
2288 | endfunction
2289 | 
2290 | function! s:status_load(lnum)
2291 |   let line = getline(a:lnum)
2292 |   let name = s:extract_name(line, '-', '(not loaded)')
2293 |   if !empty(name)
2294 |     call plug#load(name)
2295 |     setlocal modifiable
2296 |     call setline(a:lnum, substitute(line, ' (not loaded)$', '', ''))
2297 |     setlocal nomodifiable
2298 |   endif
2299 | endfunction
2300 | 
2301 | function! s:status_update() range
2302 |   let lines = getline(a:firstline, a:lastline)
2303 |   let names = filter(map(lines, 's:extract_name(v:val, "[x-]", "")'), '!empty(v:val)')
2304 |   if !empty(names)
2305 |     echo
2306 |     execute 'PlugUpdate' join(names)
2307 |   endif
2308 | endfunction
2309 | 
2310 | function! s:is_preview_window_open()
2311 |   silent! wincmd P
2312 |   if &previewwindow
2313 |     wincmd p
2314 |     return 1
2315 |   endif
2316 | endfunction
2317 | 
2318 | function! s:find_name(lnum)
2319 |   for lnum in reverse(range(1, a:lnum))
2320 |     let line = getline(lnum)
2321 |     if empty(line)
2322 |       return ''
2323 |     endif
2324 |     let name = s:extract_name(line, '-', '')
2325 |     if !empty(name)
2326 |       return name
2327 |     endif
2328 |   endfor
2329 |   return ''
2330 | endfunction
2331 | 
2332 | function! s:preview_commit()
2333 |   if b:plug_preview < 0
2334 |     let b:plug_preview = !s:is_preview_window_open()
2335 |   endif
2336 | 
2337 |   let sha = matchstr(getline('.'), '^  \X*\zs[0-9a-f]\{7,9}')
2338 |   if empty(sha)
2339 |     return
2340 |   endif
2341 | 
2342 |   let name = s:find_name(line('.'))
2343 |   if empty(name) || !has_key(g:plugs, name) || !isdirectory(g:plugs[name].dir)
2344 |     return
2345 |   endif
2346 | 
2347 |   if exists('g:plug_pwindow') && !s:is_preview_window_open()
2348 |     execute g:plug_pwindow
2349 |     execute 'e' sha
2350 |   else
2351 |     execute 'pedit' sha
2352 |     wincmd P
2353 |   endif
2354 |   setlocal previewwindow filetype=git buftype=nofile nobuflisted modifiable
2355 |   try
2356 |     let [sh, shellcmdflag, shrd] = s:chsh(1)
2357 |     let cmd = 'cd '.s:shellesc(g:plugs[name].dir).' && git show --no-color --pretty=medium '.sha
2358 |     if s:is_win
2359 |       let batchfile = tempname().'.bat'
2360 |       call writefile(['@echo off', cmd], batchfile)
2361 |       let cmd = batchfile
2362 |     endif
2363 |     execute 'silent %!' cmd
2364 |   finally
2365 |     let [&shell, &shellcmdflag, &shellredir] = [sh, shellcmdflag, shrd]
2366 |     if s:is_win
2367 |       call delete(batchfile)
2368 |     endif
2369 |   endtry
2370 |   setlocal nomodifiable
2371 |   nnoremap <silent> <buffer> q :q<cr>
2372 |   wincmd p
2373 | endfunction
2374 | 
2375 | function! s:section(flags)
2376 |   call search('\(^[x-] \)\@<=[^:]\+:', a:flags)
2377 | endfunction
2378 | 
2379 | function! s:format_git_log(line)
2380 |   let indent = '  '
2381 |   let tokens = split(a:line, nr2char(1))
2382 |   if len(tokens) != 5
2383 |     return indent.substitute(a:line, '\s*$', '', '')
2384 |   endif
2385 |   let [graph, sha, refs, subject, date] = tokens
2386 |   let tag = matchstr(refs, 'tag: [^,)]\+')
2387 |   let tag = empty(tag) ? ' ' : ' ('.tag.') '
2388 |   return printf('%s%s%s%s%s (%s)', indent, graph, sha, tag, subject, date)
2389 | endfunction
2390 | 
2391 | function! s:append_ul(lnum, text)
2392 |   call append(a:lnum, ['', a:text, repeat('-', len(a:text))])
2393 | endfunction
2394 | 
2395 | function! s:diff()
2396 |   call s:prepare()
2397 |   call append(0, ['Collecting changes ...', ''])
2398 |   let cnts = [0, 0]
2399 |   let bar = ''
2400 |   let total = filter(copy(g:plugs), 's:is_managed(v:key) && isdirectory(v:val.dir)')
2401 |   call s:progress_bar(2, bar, len(total))
2402 |   for origin in [1, 0]
2403 |     let plugs = reverse(sort(items(filter(copy(total), (origin ? '' : '!').'(has_key(v:val, "commit") || has_key(v:val, "tag"))'))))
2404 |     if empty(plugs)
2405 |       continue
2406 |     endif
2407 |     call s:append_ul(2, origin ? 'Pending updates:' : 'Last update:')
2408 |     for [k, v] in plugs
2409 |       let range = origin ? '..origin/'.v.branch : 'HEAD@{1}..'
2410 |       let diff = s:system_chomp('git log --graph --color=never '.join(map(['--pretty=format:%x01%h%x01%d%x01%s%x01%cr', range], 's:shellesc(v:val)')), v.dir)
2411 |       if !empty(diff)
2412 |         let ref = has_key(v, 'tag') ? (' (tag: '.v.tag.')') : has_key(v, 'commit') ? (' '.v.commit) : ''
2413 |         call append(5, extend(['', '- '.k.':'.ref], map(s:lines(diff), 's:format_git_log(v:val)')))
2414 |         let cnts[origin] += 1
2415 |       endif
2416 |       let bar .= '='
2417 |       call s:progress_bar(2, bar, len(total))
2418 |       normal! 2G
2419 |       redraw
2420 |     endfor
2421 |     if !cnts[origin]
2422 |       call append(5, ['', 'N/A'])
2423 |     endif
2424 |   endfor
2425 |   call setline(1, printf('%d plugin(s) updated.', cnts[0])
2426 |         \ . (cnts[1] ? printf(' %d plugin(s) have pending updates.', cnts[1]) : ''))
2427 | 
2428 |   if cnts[0] || cnts[1]
2429 |     nnoremap <silent> <buffer> <cr> :silent! call <SID>preview_commit()<cr>
2430 |     nnoremap <silent> <buffer> o    :silent! call <SID>preview_commit()<cr>
2431 |   endif
2432 |   if cnts[0]
2433 |     nnoremap <silent> <buffer> X :call <SID>revert()<cr>
2434 |     echo "Press 'X' on each block to revert the update"
2435 |   endif
2436 |   normal! gg
2437 |   setlocal nomodifiable
2438 | endfunction
2439 | 
2440 | function! s:revert()
2441 |   if search('^Pending updates', 'bnW')
2442 |     return
2443 |   endif
2444 | 
2445 |   let name = s:find_name(line('.'))
2446 |   if empty(name) || !has_key(g:plugs, name) ||
2447 |     \ input(printf('Revert the update of %s? (y/N) ', name)) !~? '^y'
2448 |     return
2449 |   endif
2450 | 
2451 |   call s:system('git reset --hard HEAD@{1} && git checkout '.s:esc(g:plugs[name].branch).' --', g:plugs[name].dir)
2452 |   setlocal modifiable
2453 |   normal! "_dap
2454 |   setlocal nomodifiable
2455 |   echo 'Reverted'
2456 | endfunction
2457 | 
2458 | function! s:snapshot(force, ...) abort
2459 |   call s:prepare()
2460 |   setf vim
2461 |   call append(0, ['" Generated by vim-plug',
2462 |                 \ '" '.strftime("%c"),
2463 |                 \ '" :source this file in vim to restore the snapshot',
2464 |                 \ '" or execute: vim -S snapshot.vim',
2465 |                 \ '', '', 'PlugUpdate!'])
2466 |   1
2467 |   let anchor = line('$') - 3
2468 |   let names = sort(keys(filter(copy(g:plugs),
2469 |         \'has_key(v:val, "uri") && !has_key(v:val, "commit") && isdirectory(v:val.dir)')))
2470 |   for name in reverse(names)
2471 |     let sha = s:system_chomp('git rev-parse --short HEAD', g:plugs[name].dir)
2472 |     if !empty(sha)
2473 |       call append(anchor, printf("silent! let g:plugs['%s'].commit = '%s'", name, sha))
2474 |       redraw
2475 |     endif
2476 |   endfor
2477 | 
2478 |   if a:0 > 0
2479 |     let fn = expand(a:1)
2480 |     if filereadable(fn) && !(a:force || s:ask(a:1.' already exists. Overwrite?'))
2481 |       return
2482 |     endif
2483 |     call writefile(getline(1, '$'), fn)
2484 |     echo 'Saved as '.a:1
2485 |     silent execute 'e' s:esc(fn)
2486 |     setf vim
2487 |   endif
2488 | endfunction
2489 | 
2490 | function! s:split_rtp()
2491 |   return split(&rtp, '\\\@<!,')
2492 | endfunction
2493 | 
2494 | let s:first_rtp = s:escrtp(get(s:split_rtp(), 0, ''))
2495 | let s:last_rtp  = s:escrtp(get(s:split_rtp(), -1, ''))
2496 | 
2497 | if exists('g:plugs')
2498 |   let g:plugs_order = get(g:, 'plugs_order', keys(g:plugs))
2499 |   call s:upgrade_specs()
2500 |   call s:define_commands()
2501 | endif
2502 | 
2503 | let &cpo = s:cpo_save
2504 | unlet s:cpo_save
2505 | 


--------------------------------------------------------------------------------
/colors/forgotten-dark.vim:
--------------------------------------------------------------------------------
  1 | " forgotten-dark, a vim colourscheme by nightsense
  2 | "
  3 | " generated with a theme template adapted from
  4 | " base16-vim (https://github.com/chriskempson/base16-vim)
  5 | " by Chris Kempson (http://chriskempson.com)
  6 | 
  7 | 
  8 | "=== SET COLOUR VARIABLES =====================================================
  9 | 
 10 | " GUI colours
 11 | let s:g0 = '1d242b'
 12 | let s:g1 = '2c333b'
 13 | let s:g2 = '616b75'
 14 | let s:g3 = '77808a'
 15 | let s:g4 = '8b959e'
 16 | let s:g5 = 'a3acb5'
 17 | let s:g6 = 'dde6f0'
 18 | let s:g7 = 'f0f8ff'
 19 | let s:g8 = 'bf5858'
 20 | let s:g9 = 'b56f45'
 21 | let s:gA = 'ab8e38'
 22 | let s:gB = '508a50'
 23 | let s:gC = '458a8a'
 24 | let s:gD = '557b9e'
 25 | let s:gE = '8b6a9e'
 26 | let s:gF = 'ab6a7a'
 27 | 
 28 | " terminal colours
 29 | let s:t0 = '00'
 30 | let s:t3 = '08'
 31 | let s:t5 = '07'
 32 | let s:t7 = '15'
 33 | let s:t8 = '01'
 34 | let s:tA = '03'
 35 | let s:tB = '02'
 36 | let s:tC = '06'
 37 | let s:tD = '04'
 38 | let s:tE = '05'
 39 | let s:t1 = '10'
 40 | let s:t2 = '11'
 41 | let s:t4 = '12'
 42 | let s:t6 = '13'
 43 | let s:t9 = '09'
 44 | let s:tF = '14'
 45 | 
 46 | " neovim colours
 47 | if has('nvim')
 48 |   let g:terminal_color_0 =  '#1d242b'
 49 |   let g:terminal_color_1 =  '#bf5858'
 50 |   let g:terminal_color_2 =  '#508a50'
 51 |   let g:terminal_color_3 =  '#ab8e38'
 52 |   let g:terminal_color_4 =  '#557b9e'
 53 |   let g:terminal_color_5 =  '#8b6a9e'
 54 |   let g:terminal_color_6 =  '#458a8a'
 55 |   let g:terminal_color_7 =  '#a3acb5'
 56 |   let g:terminal_color_8 =  '#77808a'
 57 |   let g:terminal_color_9 =  '#b56f45'
 58 |   let g:terminal_color_10 = '#2c333b'
 59 |   let g:terminal_color_11 = '#616b75'
 60 |   let g:terminal_color_12 = '#8b959e'
 61 |   let g:terminal_color_13 = '#dde6f0'
 62 |   let g:terminal_color_14 = '#ab6a7a'
 63 |   let g:terminal_color_15 = '#f0f8ff'
 64 | endif
 65 | 
 66 | 
 67 | "=== OTHER PREPARATION ========================================================
 68 | 
 69 | " run theme-setting script if using terminal vim
 70 | if filereadable(expand('~/.nightshell/forgotten-dark'))
 71 |   if !has('gui_running')
 72 |     execute 'silent !/bin/sh $HOME/.nightshell/forgotten-dark'
 73 |   endif
 74 | endif
 75 | 
 76 | " clear old theme
 77 | hi clear
 78 | syntax reset
 79 | 
 80 | " set new theme
 81 | set background=dark
 82 | augroup NightsenseThemeSet
 83 |    autocmd!
 84 |    autocmd CursorMoved * execute 'if !exists("colors_name") |
 85 |          \ colorscheme forgotten-dark | endif'
 86 | augroup END
 87 | let colors_name = 'forgotten-dark'
 88 | 
 89 | " highlighting function
 90 | fun! <sid>h(x, gf, gb, cf, cb, a, s)
 91 |   if a:gf != '' | exe 'hi ' . a:x . ' guifg=#'  . a:gf                  | endif
 92 |   if a:gb != '' | exe 'hi ' . a:x . ' guibg=#'  . a:gb                  | endif
 93 |   if a:cf != '' | exe 'hi ' . a:x . ' ctermfg=' . a:cf                  | endif
 94 |   if a:cb != '' | exe 'hi ' . a:x . ' ctermbg=' . a:cb                  | endif
 95 |   if a:a  != '' | exe 'hi ' . a:x . ' gui='     . a:a . ' cterm=' . a:a | endif
 96 |   if a:s  != '' | exe 'hi ' . a:x . ' guisp=#'  . a:s                   | endif
 97 | endfun
 98 | 
 99 | 
100 | "=== BASIC HIGHLIGHTING =======================================================
101 | 
102 | " cursor + status line + selected tab
103 | cal <sid>h('Cursor'           , s:g0 , s:g8 , s:t0 , s:t8 , 'none'      , ''  )
104 | cal <sid>h('StatusLine'       , s:g0 , s:g8 , s:t0 , s:t8 , 'none'      , ''  )
105 | cal <sid>h('StatusLineTerm'   , s:g0 , s:g8 , s:t0 , s:t8 , 'none'      , ''  )
106 | cal <sid>h('TabLineSel'       , s:g0 , s:g8 , s:t0 , s:t8 , 'none'      , ''  )
107 | cal <sid>h('TermCursor'       , s:g0 , s:g8 , s:t0 , s:t8 , 'none'      , ''  )
108 | 
109 | " line numbers
110 | cal <sid>h('CursorLineNr'     , s:g0 , s:g3 , s:t0 , s:t3 , 'none'      , ''  )
111 | cal <sid>h('LineNr'           , s:g4 , s:g1 , s:t4 , s:t1 , 'none'      , ''  )
112 | 
113 | " basic text
114 | cal <sid>h('Bold'             , ''   , ''   , ''   , ''   , 'bold'      , ''  )
115 | cal <sid>h('Directory'        , s:g5 , ''   , s:t5 , ''   , 'bold'      , ''  )
116 | cal <sid>h('Italic'           , ''   , ''   , ''   , ''   , 'italic'    , ''  )
117 | cal <sid>h('Normal'           , s:g5 , s:g0 , s:t5 , s:t0 , 'none'      , ''  )
118 | cal <sid>h('Underlined'       , s:g5 , ''   , s:t5 , ''   , 'underline' , ''  )
119 | 
120 | " commented-out text
121 | cal <sid>h('Comment'          , s:g3 , ''   , s:t3 , ''   , 'none'      , ''  )
122 | cal <sid>h('Conceal'          , s:g3 , ''   , s:t3 , ''   , 'none'      , ''  )
123 | cal <sid>h('EndOfBuffer'      , s:g3 , ''   , s:t3 , ''   , 'none'      , ''  )
124 | cal <sid>h('Ignore'           , s:g3 , ''   , s:t3 , ''   , 'none'      , ''  )
125 | cal <sid>h('NonText'          , s:g3 , ''   , s:t3 , ''   , 'none'      , ''  )
126 | 
127 | " highlighted background
128 | cal <sid>h('ColorColumn'      , ''   , s:g1 , ''   , s:t1 , 'none'      , ''  )
129 | cal <sid>h('CursorColumn'     , ''   , s:g1 , ''   , s:t1 , 'none'      , ''  )
130 | cal <sid>h('CursorLine'       , ''   , s:g1 , ''   , s:t1 , 'none'      , ''  )
131 | cal <sid>h('QuickFixLine'     , ''   , s:g1 , ''   , s:t1 , 'none'      , ''  )
132 | cal <sid>h('StatusLineNC'     , s:g5 , s:g1 , s:t5 , s:t1 , 'none'      , ''  )
133 | cal <sid>h('StatusLineTermNC' , s:g5 , s:g1 , s:t5 , s:t1 , 'none'      , ''  )
134 | cal <sid>h('TabLineFill'      , ''   , s:g1 , ''   , s:t1 , 'none'      , ''  )
135 | cal <sid>h('TermCursorNC'     , ''   , s:g1 , ''   , s:t1 , 'none'      , ''  )
136 | 
137 | " muted text on highlighted background
138 | cal <sid>h('DiffChange'       , s:g4 , s:g1 , s:t4 , s:t1 , 'none'      , ''  )
139 | cal <sid>h('FoldColumn'       , s:g4 , s:g1 , s:t4 , s:t1 , 'none'      , ''  )
140 | cal <sid>h('Folded'           , s:g4 , s:g1 , s:t4 , s:t1 , 'none'      , ''  )
141 | cal <sid>h('SignColumn'       , s:g4 , s:g1 , s:t4 , s:t1 , 'none'      , ''  )
142 | cal <sid>h('TabLine'          , s:g4 , s:g1 , s:t4 , s:t1 , 'none'      , ''  )
143 | cal <sid>h('VisualNOS'        , s:g4 , s:g1 , s:t4 , s:t1 , 'none'      , ''  )
144 | 
145 | " strongly highlighted background
146 | cal <sid>h('MatchParen'       , s:g6 , s:g2 , s:t6 , s:t2 , 'none'      , ''  )
147 | cal <sid>h('Pmenu'            , s:g6 , s:g2 , s:t6 , s:t2 , 'none'      , ''  )
148 | cal <sid>h('Visual'           , s:g6 , s:g2 , s:t6 , s:t2 , 'none'      , ''  )
149 | 
150 | " selected menu item
151 | cal <sid>h('PmenuSel'         , s:g0 , s:g5 , s:t0 , s:t5 , 'none'      , ''  )
152 | cal <sid>h('WildMenu'         , s:g0 , s:g6 , s:t0 , s:t6 , 'none'      , ''  )
153 | 
154 | " solid lines
155 | cal <sid>h('PmenuSbar'        , s:g1 , s:g1 , s:t1 , s:t1 , 'none'      , ''  )
156 | cal <sid>h('PmenuThumb'       , s:g4 , s:g4 , s:t4 , s:t4 , 'none'      , ''  )
157 | cal <sid>h('VertSplit'        , s:g2 , s:g2 , s:t2 , s:t2 , 'none'      , ''  )
158 | 
159 | 
160 | "=== ALERT/SYNTAX HIGHLIGHTING ================================================
161 | 
162 | " RED for warning elements
163 | cal <sid>h('DiffDelete'       , s:g8 , s:g0 , s:t8 , s:t0 , 'reverse'   , ''  )
164 | cal <sid>h('Error'            , s:g8 , s:g0 , s:t8 , s:t0 , 'reverse'   , ''  )
165 | cal <sid>h('ErrorMsg'         , s:g8 , s:g0 , s:t8 , s:t0 , 'none'      , ''  )
166 | cal <sid>h('SpellBad'         , ''   , ''   , s:t0 , s:t8 , 'undercurl' , s:g8)
167 | cal <sid>h('TooLong'          , s:g8 , ''   , s:t8 , ''   , 'none'      , ''  )
168 | cal <sid>h('WarningMsg'       , s:g8 , s:g0 , s:t8 , s:t0 , 'none'      , ''  )
169 | 
170 | " ORANGE for preliminary elements
171 | cal <sid>h('Define'           , s:g9 , ''   , s:t9 , ''   , 'none'      , ''  )
172 | cal <sid>h('IncSearch'        , s:g9 , s:g0 , s:t9 , s:t0 , 'reverse'   , ''  )
173 | cal <sid>h('Include'          , s:g9 , ''   , s:t9 , ''   , 'none'      , ''  )
174 | cal <sid>h('Macro'            , s:g9 , ''   , s:t9 , ''   , 'none'      , ''  )
175 | cal <sid>h('PreCondit'        , s:g9 , ''   , s:t9 , ''   , 'none'      , ''  )
176 | cal <sid>h('PreProc'          , s:g9 , ''   , s:t9 , ''   , 'none'      , ''  )
177 | cal <sid>h('SpellCap'         , ''   , ''   , s:t0 , s:t9 , 'undercurl' , s:g9)
178 | cal <sid>h('Title'            , s:g9 , ''   , s:t9 , ''   , 'none'      , ''  )
179 | 
180 | " YELLOW for highlighted elements
181 | cal <sid>h('DiffText'         , s:gA , s:g0 , s:tA , s:t0 , 'reverse'   , ''  )
182 | cal <sid>h('Search'           , s:gA , s:g0 , s:tA , s:t0 , 'reverse'   , ''  )
183 | cal <sid>h('Todo'             , s:gA , s:g0 , s:tA , s:t0 , 'reverse'   , ''  )
184 | 
185 | " GREEN for action elements
186 | cal <sid>h('Conditional'      , s:gB , ''   , s:tB , ''   , 'none'      , ''  )
187 | cal <sid>h('DiffAdd'          , s:gB , s:g0 , s:tB , s:t0 , 'reverse'   , ''  )
188 | cal <sid>h('Exception'        , s:gB , ''   , s:tB , ''   , 'none'      , ''  )
189 | cal <sid>h('Keyword'          , s:gB , ''   , s:tB , ''   , 'none'      , ''  )
190 | cal <sid>h('Label'            , s:gB , ''   , s:tB , ''   , 'none'      , ''  )
191 | cal <sid>h('ModeMsg'          , s:gB , ''   , s:tB , ''   , 'none'      , ''  )
192 | cal <sid>h('MoreMsg'          , s:gB , ''   , s:tB , ''   , 'none'      , ''  )
193 | cal <sid>h('Operator'         , s:gB , ''   , s:tB , ''   , 'none'      , ''  )
194 | cal <sid>h('Question'         , s:gB , ''   , s:tB , ''   , 'none'      , ''  )
195 | cal <sid>h('Repeat'           , s:gB , ''   , s:tB , ''   , 'none'      , ''  )
196 | cal <sid>h('Statement'        , s:gB , ''   , s:tB , ''   , 'none'      , ''  )
197 | 
198 | " TEAL for object types
199 | cal <sid>h('SpellLocal'       , ''   , ''   , s:t0 , s:tC , 'undercurl' , s:gC)
200 | cal <sid>h('StorageClass'     , s:gC , ''   , s:tC , ''   , 'none'      , ''  )
201 | cal <sid>h('Structure'        , s:gC , ''   , s:tC , ''   , 'none'      , ''  )
202 | cal <sid>h('Type'             , s:gC , ''   , s:tC , ''   , 'none'      , ''  )
203 | cal <sid>h('Typedef'          , s:gC , ''   , s:tC , ''   , 'none'      , ''  )
204 | 
205 | " BLUE for constants
206 | cal <sid>h('Boolean'          , s:gD , ''   , s:tD , ''   , 'none'      , ''  )
207 | cal <sid>h('Character'        , s:gD , ''   , s:tD , ''   , 'none'      , ''  )
208 | cal <sid>h('Constant'         , s:gD , ''   , s:tD , ''   , 'none'      , ''  )
209 | cal <sid>h('Float'            , s:gD , ''   , s:tD , ''   , 'none'      , ''  )
210 | cal <sid>h('Number'           , s:gD , ''   , s:tD , ''   , 'none'      , ''  )
211 | cal <sid>h('String'           , s:gD , ''   , s:tD , ''   , 'none'      , ''  )
212 | 
213 | " PURPLE for special text
214 | cal <sid>h('Debug'            , s:gE , ''   , s:tE , ''   , 'none'      , ''  )
215 | cal <sid>h('Delimiter'        , s:gE , ''   , s:tE , ''   , 'none'      , ''  )
216 | cal <sid>h('Special'          , s:gE , ''   , s:tE , ''   , 'none'      , ''  )
217 | cal <sid>h('SpecialChar'      , s:gE , ''   , s:tE , ''   , 'none'      , ''  )
218 | cal <sid>h('SpecialComment'   , s:gE , ''   , s:tE , ''   , 'none'      , ''  )
219 | cal <sid>h('SpecialKey'       , s:gE , ''   , s:tE , ''   , 'none'      , ''  )
220 | cal <sid>h('SpellRare'        , ''   , ''   , s:t0 , s:tE , 'undercurl' , s:gE)
221 | cal <sid>h('Tag'              , s:gE , ''   , s:tE , ''   , 'none'      , ''  )
222 | 
223 | " PINK for object names
224 | cal <sid>h('Function'         , s:gF , ''   , s:tF , ''   , 'none'      , ''  )
225 | cal <sid>h('Identifier'       , s:gF , ''   , s:tF , ''   , 'none'      , ''  )
226 | 
227 | 
228 | "=== OPTIONS ==================================================================
229 | 
230 | " disable highlighted CursorLineNr
231 | if exists('g:forgotten_dark_CursorLineNr')
232 | if g:forgotten_dark_CursorLineNr == 'off'
233 | cal <sid>h('CursorLineNr'     , s:g4 , s:g1 , s:t4 , s:t1 , 'none'      , ''  )
234 | endif
235 | endif
236 | 
237 | " disable LineNr background altogether
238 | if exists('g:forgotten_dark_LineNr')
239 | if g:forgotten_dark_LineNr == 'off'
240 | cal <sid>h('CursorLineNr'     , s:g4 , s:g0 , s:t4 , s:t0 , 'none'      , ''  )
241 | cal <sid>h('LineNr'           , s:g4 , s:g0 , s:t4 , s:t0 , 'none'      , ''  )
242 | endif
243 | endif
244 | 


--------------------------------------------------------------------------------
/colors/forgotten-light.vim:
--------------------------------------------------------------------------------
  1 | " forgotten-light, a vim colourscheme by nightsense
  2 | "
  3 | " generated with a theme template adapted from
  4 | " base16-vim (https://github.com/chriskempson/base16-vim)
  5 | " by Chris Kempson (http://chriskempson.com)
  6 | 
  7 | 
  8 | "=== SET COLOUR VARIABLES =====================================================
  9 | 
 10 | " GUI colours
 11 | let s:g0 = 'f0f8ff'
 12 | let s:g1 = 'dde6f0'
 13 | let s:g2 = 'a3acb5'
 14 | let s:g3 = '8b959e'
 15 | let s:g4 = '77808a'
 16 | let s:g5 = '616b75'
 17 | let s:g6 = '2c333b'
 18 | let s:g7 = '1d242b'
 19 | let s:g8 = 'f55050'
 20 | let s:g9 = 'e06a26'
 21 | let s:gA = 'd4ac35'
 22 | let s:gB = '219e21'
 23 | let s:gC = '1b9e9e'
 24 | let s:gD = '468dd4'
 25 | let s:gE = 'a26fbf'
 26 | let s:gF = 'd46a84'
 27 | 
 28 | " terminal colours
 29 | let s:t0 = '00'
 30 | let s:t3 = '08'
 31 | let s:t5 = '07'
 32 | let s:t7 = '15'
 33 | let s:t8 = '01'
 34 | let s:tA = '03'
 35 | let s:tB = '02'
 36 | let s:tC = '06'
 37 | let s:tD = '04'
 38 | let s:tE = '05'
 39 | let s:t1 = '10'
 40 | let s:t2 = '11'
 41 | let s:t4 = '12'
 42 | let s:t6 = '13'
 43 | let s:t9 = '09'
 44 | let s:tF = '14'
 45 | 
 46 | " neovim colours
 47 | if has('nvim')
 48 |   let g:terminal_color_0 =  '#f0f8ff'
 49 |   let g:terminal_color_1 =  '#f55050'
 50 |   let g:terminal_color_2 =  '#219e21'
 51 |   let g:terminal_color_3 =  '#d4ac35'
 52 |   let g:terminal_color_4 =  '#468dd4'
 53 |   let g:terminal_color_5 =  '#a26fbf'
 54 |   let g:terminal_color_6 =  '#1b9e9e'
 55 |   let g:terminal_color_7 =  '#616b75'
 56 |   let g:terminal_color_8 =  '#8b959e'
 57 |   let g:terminal_color_9 =  '#e06a26'
 58 |   let g:terminal_color_10 = '#dde6f0'
 59 |   let g:terminal_color_11 = '#a3acb5'
 60 |   let g:terminal_color_12 = '#77808a'
 61 |   let g:terminal_color_13 = '#2c333b'
 62 |   let g:terminal_color_14 = '#d46a84'
 63 |   let g:terminal_color_15 = '#1d242b'
 64 | endif
 65 | 
 66 | 
 67 | "=== OTHER PREPARATION ========================================================
 68 | 
 69 | " run theme-setting script if using terminal vim
 70 | if filereadable(expand('~/.nightshell/forgotten-light'))
 71 |   if !has('gui_running')
 72 |     execute 'silent !/bin/sh $HOME/.nightshell/forgotten-light'
 73 |   endif
 74 | endif
 75 | 
 76 | " clear old theme
 77 | hi clear
 78 | syntax reset
 79 | 
 80 | " set new theme
 81 | set background=light
 82 | augroup NightsenseThemeSet
 83 |    autocmd!
 84 |    autocmd CursorMoved * execute 'if !exists("colors_name") |
 85 |          \ colorscheme forgotten-light | endif'
 86 | augroup END
 87 | let colors_name = 'forgotten-light'
 88 | 
 89 | " highlighting function
 90 | fun! <sid>h(x, gf, gb, cf, cb, a, s)
 91 |   if a:gf != '' | exe 'hi ' . a:x . ' guifg=#'  . a:gf                  | endif
 92 |   if a:gb != '' | exe 'hi ' . a:x . ' guibg=#'  . a:gb                  | endif
 93 |   if a:cf != '' | exe 'hi ' . a:x . ' ctermfg=' . a:cf                  | endif
 94 |   if a:cb != '' | exe 'hi ' . a:x . ' ctermbg=' . a:cb                  | endif
 95 |   if a:a  != '' | exe 'hi ' . a:x . ' gui='     . a:a . ' cterm=' . a:a | endif
 96 |   if a:s  != '' | exe 'hi ' . a:x . ' guisp=#'  . a:s                   | endif
 97 | endfun
 98 | 
 99 | 
100 | "=== BASIC HIGHLIGHTING =======================================================
101 | 
102 | " cursor + status line + selected tab
103 | cal <sid>h('Cursor'           , s:g0 , s:gD , s:t0 , s:tD , 'none'      , ''  )
104 | cal <sid>h('StatusLine'       , s:g0 , s:gD , s:t0 , s:tD , 'none'      , ''  )
105 | cal <sid>h('StatusLineTerm'   , s:g0 , s:gD , s:t0 , s:tD , 'none'      , ''  )
106 | cal <sid>h('TabLineSel'       , s:g0 , s:gD , s:t0 , s:tD , 'none'      , ''  )
107 | cal <sid>h('TermCursor'       , s:g0 , s:gD , s:t0 , s:tD , 'none'      , ''  )
108 | 
109 | " line numbers
110 | cal <sid>h('CursorLineNr'     , s:g0 , s:g3 , s:t0 , s:t3 , 'none'      , ''  )
111 | cal <sid>h('LineNr'           , s:g4 , s:g1 , s:t4 , s:t1 , 'none'      , ''  )
112 | 
113 | " basic text
114 | cal <sid>h('Bold'             , ''   , ''   , ''   , ''   , 'bold'      , ''  )
115 | cal <sid>h('Directory'        , s:g5 , ''   , s:t5 , ''   , 'bold'      , ''  )
116 | cal <sid>h('Italic'           , ''   , ''   , ''   , ''   , 'italic'    , ''  )
117 | cal <sid>h('Normal'           , s:g5 , s:g0 , s:t5 , s:t0 , 'none'      , ''  )
118 | cal <sid>h('Underlined'       , s:g5 , ''   , s:t5 , ''   , 'underline' , ''  )
119 | 
120 | " commented-out text
121 | cal <sid>h('Comment'          , s:g3 , ''   , s:t3 , ''   , 'none'      , ''  )
122 | cal <sid>h('Conceal'          , s:g3 , ''   , s:t3 , ''   , 'none'      , ''  )
123 | cal <sid>h('EndOfBuffer'      , s:g3 , ''   , s:t3 , ''   , 'none'      , ''  )
124 | cal <sid>h('Ignore'           , s:g3 , ''   , s:t3 , ''   , 'none'      , ''  )
125 | cal <sid>h('NonText'          , s:g3 , ''   , s:t3 , ''   , 'none'      , ''  )
126 | 
127 | " highlighted background
128 | cal <sid>h('ColorColumn'      , ''   , s:g1 , ''   , s:t1 , 'none'      , ''  )
129 | cal <sid>h('CursorColumn'     , ''   , s:g1 , ''   , s:t1 , 'none'      , ''  )
130 | cal <sid>h('CursorLine'       , ''   , s:g1 , ''   , s:t1 , 'none'      , ''  )
131 | cal <sid>h('QuickFixLine'     , ''   , s:g1 , ''   , s:t1 , 'none'      , ''  )
132 | cal <sid>h('StatusLineNC'     , s:g5 , s:g1 , s:t5 , s:t1 , 'none'      , ''  )
133 | cal <sid>h('StatusLineTermNC' , s:g5 , s:g1 , s:t5 , s:t1 , 'none'      , ''  )
134 | cal <sid>h('TabLineFill'      , ''   , s:g1 , ''   , s:t1 , 'none'      , ''  )
135 | cal <sid>h('TermCursorNC'     , ''   , s:g1 , ''   , s:t1 , 'none'      , ''  )
136 | 
137 | " muted text on highlighted background
138 | cal <sid>h('DiffChange'       , s:g4 , s:g1 , s:t4 , s:t1 , 'none'      , ''  )
139 | cal <sid>h('FoldColumn'       , s:g4 , s:g1 , s:t4 , s:t1 , 'none'      , ''  )
140 | cal <sid>h('Folded'           , s:g4 , s:g1 , s:t4 , s:t1 , 'none'      , ''  )
141 | cal <sid>h('SignColumn'       , s:g4 , s:g1 , s:t4 , s:t1 , 'none'      , ''  )
142 | cal <sid>h('TabLine'          , s:g4 , s:g1 , s:t4 , s:t1 , 'none'      , ''  )
143 | cal <sid>h('VisualNOS'        , s:g4 , s:g1 , s:t4 , s:t1 , 'none'      , ''  )
144 | 
145 | " strongly highlighted background
146 | cal <sid>h('MatchParen'       , s:g6 , s:g2 , s:t6 , s:t2 , 'none'      , ''  )
147 | cal <sid>h('Pmenu'            , s:g6 , s:g2 , s:t6 , s:t2 , 'none'      , ''  )
148 | cal <sid>h('Visual'           , s:g6 , s:g2 , s:t6 , s:t2 , 'none'      , ''  )
149 | 
150 | " selected menu item
151 | cal <sid>h('PmenuSel'         , s:g0 , s:g5 , s:t0 , s:t5 , 'none'      , ''  )
152 | cal <sid>h('WildMenu'         , s:g0 , s:g6 , s:t0 , s:t6 , 'none'      , ''  )
153 | 
154 | " solid lines
155 | cal <sid>h('PmenuSbar'        , s:g1 , s:g1 , s:t1 , s:t1 , 'none'      , ''  )
156 | cal <sid>h('PmenuThumb'       , s:g4 , s:g4 , s:t4 , s:t4 , 'none'      , ''  )
157 | cal <sid>h('VertSplit'        , s:g2 , s:g2 , s:t2 , s:t2 , 'none'      , ''  )
158 | 
159 | 
160 | "=== ALERT/SYNTAX HIGHLIGHTING ================================================
161 | 
162 | " RED for warning elements
163 | cal <sid>h('DiffDelete'       , s:g8 , s:g0 , s:t8 , s:t0 , 'reverse'   , ''  )
164 | cal <sid>h('Error'            , s:g8 , s:g0 , s:t8 , s:t0 , 'reverse'   , ''  )
165 | cal <sid>h('ErrorMsg'         , s:g8 , s:g0 , s:t8 , s:t0 , 'none'      , ''  )
166 | cal <sid>h('SpellBad'         , ''   , ''   , s:t0 , s:t8 , 'undercurl' , s:g8)
167 | cal <sid>h('TooLong'          , s:g8 , ''   , s:t8 , ''   , 'none'      , ''  )
168 | cal <sid>h('WarningMsg'       , s:g8 , s:g0 , s:t8 , s:t0 , 'none'      , ''  )
169 | 
170 | " ORANGE for preliminary elements
171 | cal <sid>h('Define'           , s:g9 , ''   , s:t9 , ''   , 'none'      , ''  )
172 | cal <sid>h('IncSearch'        , s:g9 , s:g0 , s:t9 , s:t0 , 'reverse'   , ''  )
173 | cal <sid>h('Include'          , s:g9 , ''   , s:t9 , ''   , 'none'      , ''  )
174 | cal <sid>h('Macro'            , s:g9 , ''   , s:t9 , ''   , 'none'      , ''  )
175 | cal <sid>h('PreCondit'        , s:g9 , ''   , s:t9 , ''   , 'none'      , ''  )
176 | cal <sid>h('PreProc'          , s:g9 , ''   , s:t9 , ''   , 'none'      , ''  )
177 | cal <sid>h('SpellCap'         , ''   , ''   , s:t0 , s:t9 , 'undercurl' , s:g9)
178 | cal <sid>h('Title'            , s:g9 , ''   , s:t9 , ''   , 'none'      , ''  )
179 | 
180 | " YELLOW for highlighted elements
181 | cal <sid>h('DiffText'         , s:gA , s:g6 , s:tA , s:t6 , 'reverse'   , ''  )
182 | cal <sid>h('Search'           , s:gA , s:g6 , s:tA , s:t6 , 'reverse'   , ''  )
183 | cal <sid>h('Todo'             , s:gA , s:g6 , s:tA , s:t6 , 'reverse'   , ''  )
184 | 
185 | " GREEN for action elements
186 | cal <sid>h('Conditional'      , s:gB , ''   , s:tB , ''   , 'none'      , ''  )
187 | cal <sid>h('DiffAdd'          , s:gB , s:g0 , s:tB , s:t0 , 'reverse'   , ''  )
188 | cal <sid>h('Exception'        , s:gB , ''   , s:tB , ''   , 'none'      , ''  )
189 | cal <sid>h('Keyword'          , s:gB , ''   , s:tB , ''   , 'none'      , ''  )
190 | cal <sid>h('Label'            , s:gB , ''   , s:tB , ''   , 'none'      , ''  )
191 | cal <sid>h('ModeMsg'          , s:gB , ''   , s:tB , ''   , 'none'      , ''  )
192 | cal <sid>h('MoreMsg'          , s:gB , ''   , s:tB , ''   , 'none'      , ''  )
193 | cal <sid>h('Operator'         , s:gB , ''   , s:tB , ''   , 'none'      , ''  )
194 | cal <sid>h('Question'         , s:gB , ''   , s:tB , ''   , 'none'      , ''  )
195 | cal <sid>h('Repeat'           , s:gB , ''   , s:tB , ''   , 'none'      , ''  )
196 | cal <sid>h('Statement'        , s:gB , ''   , s:tB , ''   , 'none'      , ''  )
197 | 
198 | " TEAL for object types
199 | cal <sid>h('SpellLocal'       , ''   , ''   , s:t0 , s:tC , 'undercurl' , s:gC)
200 | cal <sid>h('StorageClass'     , s:gC , ''   , s:tC , ''   , 'none'      , ''  )
201 | cal <sid>h('Structure'        , s:gC , ''   , s:tC , ''   , 'none'      , ''  )
202 | cal <sid>h('Type'             , s:gC , ''   , s:tC , ''   , 'none'      , ''  )
203 | cal <sid>h('Typedef'          , s:gC , ''   , s:tC , ''   , 'none'      , ''  )
204 | 
205 | " BLUE for constants
206 | cal <sid>h('Boolean'          , s:gD , ''   , s:tD , ''   , 'none'      , ''  )
207 | cal <sid>h('Character'        , s:gD , ''   , s:tD , ''   , 'none'      , ''  )
208 | cal <sid>h('Constant'         , s:gD , ''   , s:tD , ''   , 'none'      , ''  )
209 | cal <sid>h('Float'            , s:gD , ''   , s:tD , ''   , 'none'      , ''  )
210 | cal <sid>h('Number'           , s:gD , ''   , s:tD , ''   , 'none'      , ''  )
211 | cal <sid>h('String'           , s:gD , ''   , s:tD , ''   , 'none'      , ''  )
212 | 
213 | " PURPLE for special text
214 | cal <sid>h('Debug'            , s:gE , ''   , s:tE , ''   , 'none'      , ''  )
215 | cal <sid>h('Delimiter'        , s:gE , ''   , s:tE , ''   , 'none'      , ''  )
216 | cal <sid>h('Special'          , s:gE , ''   , s:tE , ''   , 'none'      , ''  )
217 | cal <sid>h('SpecialChar'      , s:gE , ''   , s:tE , ''   , 'none'      , ''  )
218 | cal <sid>h('SpecialComment'   , s:gE , ''   , s:tE , ''   , 'none'      , ''  )
219 | cal <sid>h('SpecialKey'       , s:gE , ''   , s:tE , ''   , 'none'      , ''  )
220 | cal <sid>h('SpellRare'        , ''   , ''   , s:t0 , s:tE , 'undercurl' , s:gE)
221 | cal <sid>h('Tag'              , s:gE , ''   , s:tE , ''   , 'none'      , ''  )
222 | 
223 | " PINK for object names
224 | cal <sid>h('Function'         , s:gF , ''   , s:tF , ''   , 'none'      , ''  )
225 | cal <sid>h('Identifier'       , s:gF , ''   , s:tF , ''   , 'none'      , ''  )
226 | 
227 | 
228 | "=== OPTIONS ==================================================================
229 | 
230 | " disable highlighted CursorLineNr
231 | if exists('g:forgotten_light_CursorLineNr')
232 | if g:forgotten_light_CursorLineNr == 'off'
233 | cal <sid>h('CursorLineNr'     , s:g4 , s:g1 , s:t4 , s:t1 , 'none'      , ''  )
234 | endif
235 | endif
236 | 
237 | " disable LineNr background altogether
238 | if exists('g:forgotten_light_LineNr')
239 | if g:forgotten_light_LineNr == 'off'
240 | cal <sid>h('CursorLineNr'     , s:g4 , s:g0 , s:t4 , s:t0 , 'none'      , ''  )
241 | cal <sid>h('LineNr'           , s:g4 , s:g0 , s:t4 , s:t0 , 'none'      , ''  )
242 | endif
243 | endif
244 | 


--------------------------------------------------------------------------------
/colors/material-monokai.vim:
--------------------------------------------------------------------------------
  1 | " File:       matrial-monokai.vim
  2 | " Maintainer: skielbasa
  3 | " URL:        https://github.com/skielbasa/vim-monokai
  4 | " License:    MIT
  5 | "
  6 | " A vim port of the Material Monokai Atom theme
  7 | " Uses the Monokai theme by crusoexia as a base
  8 | 
  9 | " Initialisation
 10 | " --------------
 11 | 
 12 | if !has("gui_running") && &t_Co < 256
 13 |   finish
 14 | endif
 15 | 
 16 | if ! exists("g:materialmonokai_gui_italic")
 17 |     let g:materialmonokai_gui_italic = 1
 18 | endif
 19 | 
 20 | if ! exists("g:materialmonokai_italic")
 21 |     let g:materialmonokai_italic = 0
 22 | endif
 23 | 
 24 | if ! exists("g:materialmonokai_subtle_spell")
 25 |     let g:materialmonokai_subtle_spell = 0
 26 | endif
 27 | 
 28 | if ! exists("g:materialmonokai_custom_lint_indicators")
 29 |     let g:materialmonokai_custom_lint_indicators = 1
 30 | endif
 31 | 
 32 | let g:materialmonokai_termcolors = 256 " does not support 16 color term right now.
 33 | 
 34 | set background=dark
 35 | hi clear
 36 | 
 37 | if exists("syntax_on")
 38 |   syntax reset
 39 | endif
 40 | 
 41 | let colors_name = "material-monokai"
 42 | 
 43 | function! s:h(group, style)
 44 |   let s:ctermformat = "NONE"
 45 |   let s:guiformat = "NONE"
 46 |   if has_key(a:style, "format")
 47 |     let s:ctermformat = a:style.format
 48 |     let s:guiformat = a:style.format
 49 |   endif
 50 |   if g:materialmonokai_italic == 0
 51 |     let s:ctermformat = substitute(s:ctermformat, ",italic", "", "")
 52 |     let s:ctermformat = substitute(s:ctermformat, "italic,", "", "")
 53 |     let s:ctermformat = substitute(s:ctermformat, "italic", "", "")
 54 |   endif
 55 |   if g:materialmonokai_gui_italic == 0
 56 |     let s:guiformat = substitute(s:guiformat, ",italic", "", "")
 57 |     let s:guiformat = substitute(s:guiformat, "italic,", "", "")
 58 |     let s:guiformat = substitute(s:guiformat, "italic", "", "")
 59 |   endif
 60 |   if g:materialmonokai_termcolors == 16
 61 |     let l:ctermfg = (has_key(a:style, "fg") ? a:style.fg.cterm16 : "NONE")
 62 |     let l:ctermbg = (has_key(a:style, "bg") ? a:style.bg.cterm16 : "NONE")
 63 |   else
 64 |     let l:ctermfg = (has_key(a:style, "fg") ? a:style.fg.cterm : "NONE")
 65 |     let l:ctermbg = (has_key(a:style, "bg") ? a:style.bg.cterm : "NONE")
 66 |   end
 67 |   execute "highlight" a:group
 68 |     \ "guifg="   (has_key(a:style, "fg")      ? a:style.fg.gui   : "NONE")
 69 |     \ "guibg="   (has_key(a:style, "bg")      ? a:style.bg.gui   : "NONE")
 70 |     \ "guisp="   (has_key(a:style, "sp")      ? a:style.sp.gui   : "NONE")
 71 |     \ "gui="     (!empty(s:guiformat) ? s:guiformat   : "NONE")
 72 |     \ "ctermfg=" . l:ctermfg
 73 |     \ "ctermbg=" . l:ctermbg
 74 |     \ "cterm="   (!empty(s:ctermformat) ? s:ctermformat   : "NONE")
 75 | endfunction
 76 | 
 77 | " Palettes
 78 | " --------
 79 | 
 80 | 
 81 | let s:white       = { "gui": "#CDD3DE", "cterm": "253" }
 82 | let s:black       = { "gui": "#263238", "cterm": "235" }
 83 | let s:lightblack  = { "gui": "#2D2E27", "cterm": "234" }
 84 | let s:lightblack2 = { "gui": "#383a3e", "cterm": "236" }
 85 | let s:darkblack   = { "gui": "#1F292D", "cterm": "233" }
 86 | let s:grey        = { "gui": "#3F565F", "cterm": "238" }
 87 | let s:lightgrey   = { "gui": "#575b61", "cterm": "241" }
 88 | let s:darkgrey    = { "gui": "#232E33", "cterm": "236" }
 89 | let s:coolgrey    = { "gui": "#506E79", "cterm": "241" }
 90 | 
 91 | let s:pink        = { "gui": "#FC3488", "cterm": "197" }
 92 | let s:green       = { "gui": "#A6E22E", "cterm": "148" }
 93 | let s:aqua        = { "gui": "#66d9ef", "cterm": "81" }
 94 | let s:blue        = { "gui": "#82B1FF", "cterm": "81" }
 95 | let s:yellow      = { "gui": "#E6DB74", "cterm": "186" }
 96 | let s:orange      = { "gui": "#FD9720", "cterm": "208" }
 97 | let s:purple      = { "gui": "#ae81ff", "cterm": "141" }
 98 | let s:red         = { "gui": "#e73c50", "cterm": "196" }
 99 | let s:darkred     = { "gui": "#5f0000", "cterm": "52" }
100 | 
101 | let s:addfg       = { "gui": "#d7ffaf", "cterm": "193" }
102 | let s:addbg       = { "gui": "#5f875f", "cterm": "65" }
103 | let s:delbg       = { "gui": "#f75f5f", "cterm": "167" }
104 | let s:changefg    = { "gui": "#d7d7ff", "cterm": "189" }
105 | let s:changebg    = { "gui": "#5f5f87", "cterm": "60" }
106 | 
107 | " Highlighting
108 | " ------------
109 | 
110 | " editor
111 | call s:h("Normal",        { "fg": s:white,      "bg": s:black })
112 | call s:h("ColorColumn",   {                     "bg": s:lightgrey })
113 | call s:h("CursorColumn",  {                     "bg": s:lightblack2 })
114 | call s:h("CursorLine",    {                     "bg": s:darkblack })
115 | call s:h("NonText",       { "fg": s:lightgrey })
116 | call s:h("StatusLine",    { "fg": s:white,      "bg": s:darkblack })
117 | call s:h("StatusLineNC",  { "fg": s:darkgrey,   "bg": s:coolgrey,     "format": "reverse" })
118 | call s:h("WildMenu",      { "fg": s:white,      "bg": s:pink })
119 | call s:h("TabLine",       { "fg": s:white,      "bg": s:darkblack,    "format": "reverse" })
120 | call s:h("Visual",        {                     "bg": s:lightgrey })
121 | call s:h("Search",        { "fg": s:black,      "bg": s:yellow })
122 | call s:h("MatchParen",    { "fg": s:black,      "bg": s:purple })
123 | call s:h("Question",      { "fg": s:yellow })
124 | call s:h("ModeMsg",       { "fg": s:yellow })
125 | call s:h("MoreMsg",       { "fg": s:yellow })
126 | call s:h("ErrorMsg",      { "fg": s:black,      "bg": s:red,          "format": "standout" })
127 | call s:h("WarningMsg",    { "fg": s:red })
128 | call s:h("VertSplit",     { "fg": s:grey,       "bg": s:darkgrey })
129 | call s:h("LineNr",        { "fg": s:grey,       "bg": s:darkgrey })
130 | call s:h("CursorLineNr",  { "fg": s:aqua,       "bg": s:darkblack })
131 | call s:h("SignColumn",    {                     "bg": s:lightblack })
132 | call s:h("SpellCap",      {                                           "format": "underline"})
133 | call s:h("SpellLocal",    { "fg": s:yellow,                           "format": "underline"})
134 | if g:materialmonokai_subtle_spell == 1
135 |   call s:h("SpellBad",    {                                           "format": "underline"})
136 | else
137 |   call s:h("SpellBad",    { "fg": s:red,        "bg": s:yellow })
138 | endif
139 | 
140 | " misc
141 | call s:h("SpecialKey",    { "fg": s:coolgrey })
142 | call s:h("Title",         { "fg": s:yellow })
143 | call s:h("Directory",     { "fg": s:aqua })
144 | 
145 | " diff
146 | call s:h("DiffAdd",       { "fg": s:addfg,      "bg": s:addbg })
147 | call s:h("DiffDelete",    { "fg": s:black,      "bg": s:delbg })
148 | call s:h("DiffChange",    { "fg": s:changefg,   "bg": s:changebg })
149 | call s:h("DiffText",      { "fg": s:black,      "bg": s:aqua })
150 | 
151 | " fold
152 | call s:h("Folded",        { "fg": s:coolgrey,   "bg": s:darkblack })
153 | call s:h("FoldColumn",    {                     "bg": s:darkblack })
154 | "        Incsearch"
155 | 
156 | " popup menu
157 | call s:h("Pmenu",         { "fg": s:white,      "bg": s:darkblack })
158 | call s:h("PmenuSel",      { "fg": s:pink,       "bg": s:white,      "format": "reverse,bold" })
159 | call s:h("PmenuThumb",    { "fg": s:lightblack, "bg": s:grey })
160 | "        PmenuSbar"
161 | 
162 | " Generic Syntax Highlighting
163 | " ---------------------------
164 | 
165 | call s:h("Constant",      { "fg": s:purple })
166 | call s:h("Number",        { "fg": s:purple })
167 | call s:h("Float",         { "fg": s:purple })
168 | call s:h("Boolean",       { "fg": s:purple })
169 | call s:h("Character",     { "fg": s:yellow })
170 | call s:h("String",        { "fg": s:yellow })
171 | 
172 | call s:h("Type",          { "fg": s:aqua })
173 | call s:h("Structure",     { "fg": s:aqua })
174 | call s:h("StorageClass",  { "fg": s:aqua })
175 | call s:h("Typedef",       { "fg": s:aqua })
176 | 
177 | call s:h("Identifier",    { "fg": s:green })
178 | call s:h("Function",      { "fg": s:green })
179 | 
180 | call s:h("Statement",     { "fg": s:pink })
181 | call s:h("Operator",      { "fg": s:pink })
182 | call s:h("Label",         { "fg": s:pink })
183 | call s:h("Keyword",       { "fg": s:aqua })
184 | "        Conditional"
185 | "        Repeat"
186 | "        Exception"
187 | 
188 | call s:h("PreProc",       { "fg": s:green })
189 | call s:h("Include",       { "fg": s:pink })
190 | call s:h("Define",        { "fg": s:pink })
191 | call s:h("Macro",         { "fg": s:green })
192 | call s:h("PreCondit",     { "fg": s:green })
193 | 
194 | call s:h("Special",       { "fg": s:aqua })
195 | call s:h("SpecialChar",   { "fg": s:pink })
196 | call s:h("Delimiter",     { "fg": s:red })
197 | call s:h("SpecialComment",{ "fg": s:aqua })
198 | call s:h("Tag",           { "fg": s:pink })
199 | "        Debug"
200 | 
201 | call s:h("Todo",          { "fg": s:aqua,     "format": "bold,italic" })
202 | call s:h("Comment",       { "fg": s:coolgrey, "format": "italic" })
203 | 
204 | call s:h("Underlined",    { "fg": s:green })
205 | call s:h("Ignore",        {})
206 | call s:h("Error",         { "fg": s:red, "bg": s:darkred })
207 | 
208 | " ALE
209 | " ---
210 | 
211 | if g:materialmonokai_custom_lint_indicators == 1
212 |   call s:h("ALEErrorSign",   { "fg": s:red,    "bg": s:darkgrey })
213 |   call s:h("ALEWarningSign", { "fg": s:yellow, "bg": s:darkgrey })
214 | 
215 |   let g:ale_sign_error = '●'
216 |   let g:ale_sign_warning = '●'
217 | endif
218 | 
219 | " Git Gutter
220 | " ---------
221 | 
222 | call s:h("GitGutterAdd",          { "fg": s:green,  "bg": s:darkgrey})
223 | call s:h("GitGutterChange",       { "fg": s:yellow, "bg": s:darkgrey })
224 | call s:h("GitGutterDelete",       { "fg": s:red,    "bg": s:darkgrey })
225 | call s:h("GitGutterChangeDelete", { "fg": s:yellow, "bg": s:darkgrey })
226 | 
227 | " NerdTree
228 | " --------
229 | 
230 | call s:h("NERDTreeOpenable",        { "fg": s:pink })
231 | call s:h("NERDTreeClosable",        { "fg": s:pink })
232 | call s:h("NERDTreeHelp",            { "fg": s:yellow })
233 | call s:h("NERDTreeBookmarksHeader", { "fg": s:aqua })
234 | call s:h("NERDTreeBookmarksLeader", { "fg": s:black })
235 | call s:h("NERDTreeBookmarkName",    { "fg": s:yellow })
236 | call s:h("NERDTreeCWD",             { "fg": s:pink })
237 | call s:h("NERDTreeUp",              { "fg": s:white })
238 | call s:h("NERDTreeDirSlash",        { "fg": s:grey })
239 | call s:h("NERDTreeDir",             { "fg": s:coolgrey })
240 | 
241 | " Syntastic
242 | " ---------
243 | 
244 | hi! link SyntasticErrorSign Error
245 | call s:h("SyntasticWarningSign",    { "fg": s:lightblack, "bg": s:orange })
246 | 
247 | " Language highlight
248 | " ------------------
249 | 
250 | " Java properties
251 | call s:h("jpropertiesIdentifier",   { "fg": s:pink })
252 | 
253 | " Vim command
254 | call s:h("vimCommand",              { "fg": s:pink })
255 | 
256 | " Javascript
257 | call s:h("jsFuncName",          { "fg": s:green })
258 | call s:h("jsThis",              { "fg": s:pink })
259 | call s:h("jsFunctionKey",       { "fg": s:green })
260 | call s:h("jsPrototype",         { "fg": s:aqua })
261 | call s:h("jsExceptions",        { "fg": s:aqua })
262 | call s:h("jsFutureKeys",        { "fg": s:aqua })
263 | call s:h("jsBuiltins",          { "fg": s:aqua })
264 | call s:h("jsArgsObj",           { "fg": s:aqua })
265 | call s:h("jsStatic",            { "fg": s:aqua })
266 | call s:h("jsSuper",             { "fg": s:aqua })
267 | call s:h("jsFuncArgRest",       { "fg": s:purple, "format": "italic" })
268 | call s:h("jsFuncArgs",          { "fg": s:orange, "format": "italic" })
269 | call s:h("jsStorageClass",      { "fg": s:aqua })
270 | call s:h("jsVariableDef",       { "fg": s:purple })
271 | call s:h("jsDocTags",           { "fg": s:aqua,   "format": "italic" })
272 | " pangloss/vim-javascript
273 | call s:h('jsArrowFunction',      { "fg": s:green, })
274 | call s:h('jsAsyncKeyword',       { "fg": s:aqua, })
275 | call s:h('jsExtendsKeyword',     { "fg": s:purple, })
276 | call s:h('jsClassKeyword',       { "fg": s:purple, })
277 | call s:h('jsDocParam',           { "fg": s:aqua, })
278 | call s:h('jsDocTags',            { "fg": s:green, })
279 | call s:h('jsForAwait',           { "fg": s:purple, })
280 | call s:h('jsFlowArgumentDef',    { "fg": s:yellow, })
281 | call s:h('jsFrom',               { "fg": s:purple, })
282 | call s:h('jsImport',             { "fg": s:pink, })
283 | call s:h('jsExport',             { "fg": s:pink, })
284 | call s:h('jsExportDefault',      { "fg": s:orange, })
285 | call s:h('jsFuncCall',           { "fg": s:green, })
286 | call s:h('jsGlobalObjects',      { "fg": s:orange, })
287 | call s:h('jsGlobalNodeObjects',  { "fg": s:yellow, })
288 | call s:h('jsModuleAs',           { "fg": s:purple, })
289 | call s:h('jsNoise',              { "fg": s:pink, })
290 | call s:h('jsNull',               { "fg": s:orange, })
291 | call s:h('jsObjectProp',         { "fg": s:orange, })
292 | call s:h('jsTemplateBraces',     { "fg": s:orange, })
293 | call s:h('jsTemplateExpression', { "fg": s:orange, })
294 | call s:h('jsThis',               { "fg": s:orange, })
295 | call s:h('jsUndefined',          { "fg": s:orange, })
296 | 
297 | " Html
298 | call s:h("htmlTag",             { "fg": s:aqua })
299 | call s:h("htmlEndTag",          { "fg": s:aqua })
300 | call s:h("htmlTagName",         { "fg": s:pink })
301 | call s:h("htmlArg",             { "fg": s:green })
302 | call s:h("htmlSpecialChar",     { "fg": s:purple })
303 | call s:h("htmlh1",              { "fg": s:blue })
304 | call s:h("htmlh2",              { "fg": s:blue })
305 | call s:h("htmlh3",              { "fg": s:blue })
306 | call s:h("htmlh4",              { "fg": s:blue })
307 | call s:h("htmlh5",              { "fg": s:blue })
308 | call s:h("htmlh6",              { "fg": s:blue })
309 | 
310 | " PHP
311 | call s:h("phpIdentifier",       { "fg": s:orange })
312 | call s:h("phpRegion",           { "fg": s:green })
313 | call s:h("phpKeyword",          { "fg": s:aqua })
314 | call s:h("phpParent",           { "fg": s:white })
315 | 
316 | " Xml
317 | call s:h("xmlTag",              { "fg": s:pink })
318 | call s:h("xmlEndTag",           { "fg": s:pink })
319 | call s:h("xmlTagName",          { "fg": s:orange })
320 | call s:h("xmlAttrib",           { "fg": s:green })
321 | 
322 | " CSS
323 | call s:h("cssProp",             { "fg": s:aqua, "format": "italic" })
324 | call s:h("cssUIAttr",           { "fg": s:yellow })
325 | call s:h("cssUnitDecorators",   { "fg": s:yellow })
326 | call s:h("cssFunctionName",     { "fg": s:aqua })
327 | call s:h("cssColor",            { "fg": s:purple })
328 | call s:h("cssPseudoClassId",    { "fg": s:purple })
329 | call s:h("cssClassName",        { "fg": s:green })
330 | call s:h("cssValueLength",      { "fg": s:purple })
331 | call s:h("cssCommonAttr",       { "fg": s:pink })
332 | call s:h("cssBraces" ,          { "fg": s:white })
333 | call s:h("cssClassNameDot",     { "fg": s:pink })
334 | call s:h("cssURL",              { "fg": s:orange, "format": "underline,italic" })
335 | call s:h("cssAttributeSelector",{ "fg": s:orange })
336 | 
337 | " SCSS
338 | call s:h("scssAmpersand",       { "fg": s:pink })
339 | call s:h("scssAttribute",       { "fg": s:yellow })
340 | call s:h("scssDefinition",      { "fg": s:white })
341 | call s:h("scssInclude",         { "fg": s:pink })
342 | call s:h("scssVariable",        { "fg": s:orange })
343 | 
344 | " LESS
345 | call s:h("lessVariable",        { "fg": s:green })
346 | 
347 | " ruby
348 | call s:h("rubyInterpolationDelimiter",  {})
349 | call s:h("rubyInstanceVariable",        {})
350 | call s:h("rubyGlobalVariable",          {})
351 | call s:h("rubyClassVariable",           {})
352 | call s:h("rubyPseudoVariable",          {})
353 | call s:h("rubyFunction",                { "fg": s:green })
354 | call s:h("rubyStringDelimiter",         { "fg": s:yellow })
355 | call s:h("rubyRegexp",                  { "fg": s:yellow })
356 | call s:h("rubyRegexpDelimiter",         { "fg": s:yellow })
357 | call s:h("rubySymbol",                  { "fg": s:purple })
358 | call s:h("rubyEscape",                  { "fg": s:purple })
359 | call s:h("rubyInclude",                 { "fg": s:pink })
360 | call s:h("rubyOperator",                { "fg": s:pink })
361 | call s:h("rubyControl",                 { "fg": s:pink })
362 | call s:h("rubyClass",                   { "fg": s:pink })
363 | call s:h("rubyDefine",                  { "fg": s:pink })
364 | call s:h("rubyException",               { "fg": s:pink })
365 | call s:h("rubyRailsARAssociationMethod",{ "fg": s:orange })
366 | call s:h("rubyRailsARMethod",           { "fg": s:orange })
367 | call s:h("rubyRailsRenderMethod",       { "fg": s:orange })
368 | call s:h("rubyRailsMethod",             { "fg": s:orange })
369 | call s:h("rubyConstant",                { "fg": s:aqua })
370 | call s:h("rubyBlockArgument",           { "fg": s:orange })
371 | call s:h("rubyBlockParameter",          { "fg": s:orange })
372 | 
373 | " eruby
374 | call s:h("erubyDelimiter",              {})
375 | call s:h("erubyRailsMethod",            { "fg": s:aqua })
376 | 
377 | " c
378 | call s:h("cLabel",                      { "fg": s:pink })
379 | call s:h("cStructure",                  { "fg": s:pink })
380 | call s:h("cStorageClass",               { "fg": s:pink })
381 | call s:h("cInclude",                    { "fg": s:green })
382 | call s:h("cDefine",                     { "fg": s:green })
383 | 
384 | " Markdown
385 | call s:h("mkdDelimiter",                { "fg": s:blue })
386 | call s:h("mkdCode",                     { "fg": s:white })
387 | call s:h("mkdLink",                     { "fg": s:green })
388 | call s:h("mkdListItem",                 { "fg": s:orange })
389 | call s:h("mkdURL",                      { "fg": s:pink })
390 | 
391 | " Jinja
392 | call s:h("jinjaVarBlock",               { "fg": s:orange })
393 | call s:h("jinjaTagBlock",               { "fg": s:pink })
394 | 


--------------------------------------------------------------------------------
/colors/office-dark.vim:
--------------------------------------------------------------------------------
  1 | " office-dark, a vim colourscheme by nightsense
  2 | "
  3 | " generated with a theme template adapted from
  4 | " base16-vim (https://github.com/chriskempson/base16-vim)
  5 | " by Chris Kempson (http://chriskempson.com)
  6 | 
  7 | 
  8 | "=== SET COLOUR VARIABLES =====================================================
  9 | 
 10 | " GUI colours
 11 | let s:g0 = '2b2b29'
 12 | let s:g1 = '3b3b37'
 13 | let s:g2 = '75756e'
 14 | let s:g3 = '8a8a81'
 15 | let s:g4 = '9e9e95'
 16 | let s:g5 = 'b5b5aa'
 17 | let s:g6 = 'f0f0e1'
 18 | let s:g7 = 'fffff0'
 19 | let s:g8 = 'bf5858'
 20 | let s:g9 = 'b56f45'
 21 | let s:gA = 'ab8e38'
 22 | let s:gB = '508a50'
 23 | let s:gC = '458a8a'
 24 | let s:gD = '557b9e'
 25 | let s:gE = '8b6a9e'
 26 | let s:gF = 'ab6a7a'
 27 | 
 28 | " terminal colours
 29 | let s:t0 = '00'
 30 | let s:t3 = '08'
 31 | let s:t5 = '07'
 32 | let s:t7 = '15'
 33 | let s:t8 = '01'
 34 | let s:tA = '03'
 35 | let s:tB = '02'
 36 | let s:tC = '06'
 37 | let s:tD = '04'
 38 | let s:tE = '05'
 39 | let s:t1 = '10'
 40 | let s:t2 = '11'
 41 | let s:t4 = '12'
 42 | let s:t6 = '13'
 43 | let s:t9 = '09'
 44 | let s:tF = '14'
 45 | 
 46 | " neovim colours
 47 | if has('nvim')
 48 |   let g:terminal_color_0 =  '#2b2b29'
 49 |   let g:terminal_color_1 =  '#bf5858'
 50 |   let g:terminal_color_2 =  '#508a50'
 51 |   let g:terminal_color_3 =  '#ab8e38'
 52 |   let g:terminal_color_4 =  '#557b9e'
 53 |   let g:terminal_color_5 =  '#8b6a9e'
 54 |   let g:terminal_color_6 =  '#458a8a'
 55 |   let g:terminal_color_7 =  '#b5b5aa'
 56 |   let g:terminal_color_8 =  '#8a8a81'
 57 |   let g:terminal_color_9 =  '#b56f45'
 58 |   let g:terminal_color_10 = '#3b3b37'
 59 |   let g:terminal_color_11 = '#75756e'
 60 |   let g:terminal_color_12 = '#9e9e95'
 61 |   let g:terminal_color_13 = '#f0f0e1'
 62 |   let g:terminal_color_14 = '#ab6a7a'
 63 |   let g:terminal_color_15 = '#fffff0'
 64 | endif
 65 | 
 66 | 
 67 | "=== OTHER PREPARATION ========================================================
 68 | 
 69 | " run theme-setting script if using terminal vim
 70 | if filereadable(expand('~/.nightshell/office-dark'))
 71 |   if !has('gui_running')
 72 |     execute 'silent !/bin/sh $HOME/.nightshell/office-dark'
 73 |   endif
 74 | endif
 75 | 
 76 | " clear old theme
 77 | hi clear
 78 | syntax reset
 79 | 
 80 | " set new theme
 81 | set background=dark
 82 | augroup NightsenseThemeSet
 83 |    autocmd!
 84 |    autocmd CursorMoved * execute 'if !exists("colors_name") |
 85 |          \ colorscheme office-dark | endif'
 86 | augroup END
 87 | let colors_name = 'office-dark'
 88 | 
 89 | " highlighting function
 90 | fun! <sid>h(x, gf, gb, cf, cb, a, s)
 91 |   if a:gf != '' | exe 'hi ' . a:x . ' guifg=#'  . a:gf                  | endif
 92 |   if a:gb != '' | exe 'hi ' . a:x . ' guibg=#'  . a:gb                  | endif
 93 |   if a:cf != '' | exe 'hi ' . a:x . ' ctermfg=' . a:cf                  | endif
 94 |   if a:cb != '' | exe 'hi ' . a:x . ' ctermbg=' . a:cb                  | endif
 95 |   if a:a  != '' | exe 'hi ' . a:x . ' gui='     . a:a . ' cterm=' . a:a | endif
 96 |   if a:s  != '' | exe 'hi ' . a:x . ' guisp=#'  . a:s                   | endif
 97 | endfun
 98 | 
 99 | 
100 | "=== BASIC HIGHLIGHTING =======================================================
101 | 
102 | " cursor + status line + selected tab
103 | cal <sid>h('Cursor'           , s:g0 , s:g4 , s:t0 , s:t4 , 'none'      , ''  )
104 | cal <sid>h('StatusLine'       , s:g0 , s:g4 , s:t0 , s:t4 , 'none'      , ''  )
105 | cal <sid>h('StatusLineTerm'   , s:g0 , s:g4 , s:t0 , s:t4 , 'none'      , ''  )
106 | cal <sid>h('TabLineSel'       , s:g0 , s:g4 , s:t0 , s:t4 , 'none'      , ''  )
107 | cal <sid>h('TermCursor'       , s:g0 , s:g4 , s:t0 , s:t4 , 'none'      , ''  )
108 | 
109 | " line numbers
110 | cal <sid>h('CursorLineNr'     , s:g0 , s:g3 , s:t0 , s:t3 , 'none'      , ''  )
111 | cal <sid>h('LineNr'           , s:g4 , s:g1 , s:t4 , s:t1 , 'none'      , ''  )
112 | 
113 | " basic text
114 | cal <sid>h('Bold'             , ''   , ''   , ''   , ''   , 'bold'      , ''  )
115 | cal <sid>h('Directory'        , s:g5 , ''   , s:t5 , ''   , 'bold'      , ''  )
116 | cal <sid>h('Italic'           , ''   , ''   , ''   , ''   , 'italic'    , ''  )
117 | cal <sid>h('Normal'           , s:g5 , s:g0 , s:t5 , s:t0 , 'none'      , ''  )
118 | cal <sid>h('Underlined'       , s:g5 , ''   , s:t5 , ''   , 'underline' , ''  )
119 | 
120 | " commented-out text
121 | cal <sid>h('Comment'          , s:g3 , ''   , s:t3 , ''   , 'none'      , ''  )
122 | cal <sid>h('Conceal'          , s:g3 , ''   , s:t3 , ''   , 'none'      , ''  )
123 | cal <sid>h('EndOfBuffer'      , s:g3 , ''   , s:t3 , ''   , 'none'      , ''  )
124 | cal <sid>h('Ignore'           , s:g3 , ''   , s:t3 , ''   , 'none'      , ''  )
125 | cal <sid>h('NonText'          , s:g3 , ''   , s:t3 , ''   , 'none'      , ''  )
126 | 
127 | " highlighted background
128 | cal <sid>h('ColorColumn'      , ''   , s:g1 , ''   , s:t1 , 'none'      , ''  )
129 | cal <sid>h('CursorColumn'     , ''   , s:g1 , ''   , s:t1 , 'none'      , ''  )
130 | cal <sid>h('CursorLine'       , ''   , s:g1 , ''   , s:t1 , 'none'      , ''  )
131 | cal <sid>h('QuickFixLine'     , ''   , s:g1 , ''   , s:t1 , 'none'      , ''  )
132 | cal <sid>h('StatusLineNC'     , s:g5 , s:g1 , s:t5 , s:t1 , 'none'      , ''  )
133 | cal <sid>h('StatusLineTermNC' , s:g5 , s:g1 , s:t5 , s:t1 , 'none'      , ''  )
134 | cal <sid>h('TabLineFill'      , ''   , s:g1 , ''   , s:t1 , 'none'      , ''  )
135 | cal <sid>h('TermCursorNC'     , ''   , s:g1 , ''   , s:t1 , 'none'      , ''  )
136 | 
137 | " muted text on highlighted background
138 | cal <sid>h('DiffChange'       , s:g4 , s:g1 , s:t4 , s:t1 , 'none'      , ''  )
139 | cal <sid>h('FoldColumn'       , s:g4 , s:g1 , s:t4 , s:t1 , 'none'      , ''  )
140 | cal <sid>h('Folded'           , s:g4 , s:g1 , s:t4 , s:t1 , 'none'      , ''  )
141 | cal <sid>h('SignColumn'       , s:g4 , s:g1 , s:t4 , s:t1 , 'none'      , ''  )
142 | cal <sid>h('TabLine'          , s:g4 , s:g1 , s:t4 , s:t1 , 'none'      , ''  )
143 | cal <sid>h('VisualNOS'        , s:g4 , s:g1 , s:t4 , s:t1 , 'none'      , ''  )
144 | 
145 | " strongly highlighted background
146 | cal <sid>h('MatchParen'       , s:g6 , s:g2 , s:t6 , s:t2 , 'none'      , ''  )
147 | cal <sid>h('Pmenu'            , s:g6 , s:g2 , s:t6 , s:t2 , 'none'      , ''  )
148 | cal <sid>h('Visual'           , s:g6 , s:g2 , s:t6 , s:t2 , 'none'      , ''  )
149 | 
150 | " selected menu item
151 | cal <sid>h('PmenuSel'         , s:g0 , s:g5 , s:t0 , s:t5 , 'none'      , ''  )
152 | cal <sid>h('WildMenu'         , s:g0 , s:g6 , s:t0 , s:t6 , 'none'      , ''  )
153 | 
154 | " solid lines
155 | cal <sid>h('PmenuSbar'        , s:g1 , s:g1 , s:t1 , s:t1 , 'none'      , ''  )
156 | cal <sid>h('PmenuThumb'       , s:g4 , s:g4 , s:t4 , s:t4 , 'none'      , ''  )
157 | cal <sid>h('VertSplit'        , s:g2 , s:g2 , s:t2 , s:t2 , 'none'      , ''  )
158 | 
159 | 
160 | "=== ALERT/SYNTAX HIGHLIGHTING ================================================
161 | 
162 | " RED for warning elements
163 | cal <sid>h('DiffDelete'       , s:g8 , s:g0 , s:t8 , s:t0 , 'reverse'   , ''  )
164 | cal <sid>h('Error'            , s:g8 , s:g0 , s:t8 , s:t0 , 'reverse'   , ''  )
165 | cal <sid>h('ErrorMsg'         , s:g8 , s:g0 , s:t8 , s:t0 , 'none'      , ''  )
166 | cal <sid>h('SpellBad'         , ''   , ''   , s:t0 , s:t8 , 'undercurl' , s:g8)
167 | cal <sid>h('TooLong'          , s:g8 , ''   , s:t8 , ''   , 'none'      , ''  )
168 | cal <sid>h('WarningMsg'       , s:g8 , s:g0 , s:t8 , s:t0 , 'none'      , ''  )
169 | 
170 | " ORANGE for preliminary elements
171 | cal <sid>h('Define'           , s:g9 , ''   , s:t9 , ''   , 'none'      , ''  )
172 | cal <sid>h('IncSearch'        , s:g9 , s:g0 , s:t9 , s:t0 , 'reverse'   , ''  )
173 | cal <sid>h('Include'          , s:g9 , ''   , s:t9 , ''   , 'none'      , ''  )
174 | cal <sid>h('Macro'            , s:g9 , ''   , s:t9 , ''   , 'none'      , ''  )
175 | cal <sid>h('PreCondit'        , s:g9 , ''   , s:t9 , ''   , 'none'      , ''  )
176 | cal <sid>h('PreProc'          , s:g9 , ''   , s:t9 , ''   , 'none'      , ''  )
177 | cal <sid>h('SpellCap'         , ''   , ''   , s:t0 , s:t9 , 'undercurl' , s:g9)
178 | cal <sid>h('Title'            , s:g9 , ''   , s:t9 , ''   , 'none'      , ''  )
179 | 
180 | " YELLOW for highlighted elements
181 | cal <sid>h('DiffText'         , s:gA , s:g0 , s:tA , s:t0 , 'reverse'   , ''  )
182 | cal <sid>h('Search'           , s:gA , s:g0 , s:tA , s:t0 , 'reverse'   , ''  )
183 | cal <sid>h('Todo'             , s:gA , s:g0 , s:tA , s:t0 , 'reverse'   , ''  )
184 | 
185 | " GREEN for action elements
186 | cal <sid>h('Conditional'      , s:gB , ''   , s:tB , ''   , 'none'      , ''  )
187 | cal <sid>h('DiffAdd'          , s:gB , s:g0 , s:tB , s:t0 , 'reverse'   , ''  )
188 | cal <sid>h('Exception'        , s:gB , ''   , s:tB , ''   , 'none'      , ''  )
189 | cal <sid>h('Keyword'          , s:gB , ''   , s:tB , ''   , 'none'      , ''  )
190 | cal <sid>h('Label'            , s:gB , ''   , s:tB , ''   , 'none'      , ''  )
191 | cal <sid>h('ModeMsg'          , s:gB , ''   , s:tB , ''   , 'none'      , ''  )
192 | cal <sid>h('MoreMsg'          , s:gB , ''   , s:tB , ''   , 'none'      , ''  )
193 | cal <sid>h('Operator'         , s:gB , ''   , s:tB , ''   , 'none'      , ''  )
194 | cal <sid>h('Question'         , s:gB , ''   , s:tB , ''   , 'none'      , ''  )
195 | cal <sid>h('Repeat'           , s:gB , ''   , s:tB , ''   , 'none'      , ''  )
196 | cal <sid>h('Statement'        , s:gB , ''   , s:tB , ''   , 'none'      , ''  )
197 | 
198 | " TEAL for object types
199 | cal <sid>h('SpellLocal'       , ''   , ''   , s:t0 , s:tC , 'undercurl' , s:gC)
200 | cal <sid>h('StorageClass'     , s:gC , ''   , s:tC , ''   , 'none'      , ''  )
201 | cal <sid>h('Structure'        , s:gC , ''   , s:tC , ''   , 'none'      , ''  )
202 | cal <sid>h('Type'             , s:gC , ''   , s:tC , ''   , 'none'      , ''  )
203 | cal <sid>h('Typedef'          , s:gC , ''   , s:tC , ''   , 'none'      , ''  )
204 | 
205 | " BLUE for constants
206 | cal <sid>h('Boolean'          , s:gD , ''   , s:tD , ''   , 'none'      , ''  )
207 | cal <sid>h('Character'        , s:gD , ''   , s:tD , ''   , 'none'      , ''  )
208 | cal <sid>h('Constant'         , s:gD , ''   , s:tD , ''   , 'none'      , ''  )
209 | cal <sid>h('Float'            , s:gD , ''   , s:tD , ''   , 'none'      , ''  )
210 | cal <sid>h('Number'           , s:gD , ''   , s:tD , ''   , 'none'      , ''  )
211 | cal <sid>h('String'           , s:gD , ''   , s:tD , ''   , 'none'      , ''  )
212 | 
213 | " PURPLE for special text
214 | cal <sid>h('Debug'            , s:gE , ''   , s:tE , ''   , 'none'      , ''  )
215 | cal <sid>h('Delimiter'        , s:gE , ''   , s:tE , ''   , 'none'      , ''  )
216 | cal <sid>h('Special'          , s:gE , ''   , s:tE , ''   , 'none'      , ''  )
217 | cal <sid>h('SpecialChar'      , s:gE , ''   , s:tE , ''   , 'none'      , ''  )
218 | cal <sid>h('SpecialComment'   , s:gE , ''   , s:tE , ''   , 'none'      , ''  )
219 | cal <sid>h('SpecialKey'       , s:gE , ''   , s:tE , ''   , 'none'      , ''  )
220 | cal <sid>h('SpellRare'        , ''   , ''   , s:t0 , s:tE , 'undercurl' , s:gE)
221 | cal <sid>h('Tag'              , s:gE , ''   , s:tE , ''   , 'none'      , ''  )
222 | 
223 | " PINK for object names
224 | cal <sid>h('Function'         , s:gF , ''   , s:tF , ''   , 'none'      , ''  )
225 | cal <sid>h('Identifier'       , s:gF , ''   , s:tF , ''   , 'none'      , ''  )
226 | 
227 | 
228 | "=== OPTIONS ==================================================================
229 | 
230 | " disable highlighted CursorLineNr
231 | if exists('g:office_dark_CursorLineNr')
232 | if g:office_dark_CursorLineNr == 'off'
233 | cal <sid>h('CursorLineNr'     , s:g4 , s:g1 , s:t4 , s:t1 , 'none'      , ''  )
234 | endif
235 | endif
236 | 
237 | " disable LineNr background altogether
238 | if exists('g:office_dark_LineNr')
239 | if g:office_dark_LineNr == 'off'
240 | cal <sid>h('CursorLineNr'     , s:g4 , s:g0 , s:t4 , s:t0 , 'none'      , ''  )
241 | cal <sid>h('LineNr'           , s:g4 , s:g0 , s:t4 , s:t0 , 'none'      , ''  )
242 | endif
243 | endif
244 | 


--------------------------------------------------------------------------------
/colors/office-light.vim:
--------------------------------------------------------------------------------
  1 | " office-light, a vim colourscheme by nightsense
  2 | "
  3 | " generated with a theme template adapted from
  4 | " base16-vim (https://github.com/chriskempson/base16-vim)
  5 | " by Chris Kempson (http://chriskempson.com)
  6 | 
  7 | 
  8 | "=== SET COLOUR VARIABLES =====================================================
  9 | 
 10 | " GUI colours
 11 | let s:g0 = 'fffff0'
 12 | let s:g1 = 'f0f0e1'
 13 | let s:g2 = 'b5b5aa'
 14 | let s:g3 = '9e9e95'
 15 | let s:g4 = '8a8a81'
 16 | let s:g5 = '75756e'
 17 | let s:g6 = '3b3b37'
 18 | let s:g7 = '2b2b29'
 19 | let s:g8 = 'f55050'
 20 | let s:g9 = 'e06a26'
 21 | let s:gA = 'd4ac35'
 22 | let s:gB = '219e21'
 23 | let s:gC = '1b9e9e'
 24 | let s:gD = '468dd4'
 25 | let s:gE = 'a26fbf'
 26 | let s:gF = 'd46a84'
 27 | 
 28 | " terminal colours
 29 | let s:t0 = '00'
 30 | let s:t3 = '08'
 31 | let s:t5 = '07'
 32 | let s:t7 = '15'
 33 | let s:t8 = '01'
 34 | let s:tA = '03'
 35 | let s:tB = '02'
 36 | let s:tC = '06'
 37 | let s:tD = '04'
 38 | let s:tE = '05'
 39 | let s:t1 = '10'
 40 | let s:t2 = '11'
 41 | let s:t4 = '12'
 42 | let s:t6 = '13'
 43 | let s:t9 = '09'
 44 | let s:tF = '14'
 45 | 
 46 | " neovim colours
 47 | if has('nvim')
 48 |   let g:terminal_color_0 =  '#fffff0'
 49 |   let g:terminal_color_1 =  '#f55050'
 50 |   let g:terminal_color_2 =  '#219e21'
 51 |   let g:terminal_color_3 =  '#d4ac35'
 52 |   let g:terminal_color_4 =  '#468dd4'
 53 |   let g:terminal_color_5 =  '#a26fbf'
 54 |   let g:terminal_color_6 =  '#1b9e9e'
 55 |   let g:terminal_color_7 =  '#75756e'
 56 |   let g:terminal_color_8 =  '#9e9e95'
 57 |   let g:terminal_color_9 =  '#e06a26'
 58 |   let g:terminal_color_10 = '#f0f0e1'
 59 |   let g:terminal_color_11 = '#b5b5aa'
 60 |   let g:terminal_color_12 = '#8a8a81'
 61 |   let g:terminal_color_13 = '#3b3b37'
 62 |   let g:terminal_color_14 = '#d46a84'
 63 |   let g:terminal_color_15 = '#2b2b29'
 64 | endif
 65 | 
 66 | 
 67 | "=== OTHER PREPARATION ========================================================
 68 | 
 69 | " run theme-setting script if using terminal vim
 70 | if filereadable(expand('~/.nightshell/office-light'))
 71 |   if !has('gui_running')
 72 |     execute 'silent !/bin/sh $HOME/.nightshell/office-light'
 73 |   endif
 74 | endif
 75 | 
 76 | " clear old theme
 77 | hi clear
 78 | syntax reset
 79 | 
 80 | " set new theme
 81 | set background=light
 82 | augroup NightsenseThemeSet
 83 |    autocmd!
 84 |    autocmd CursorMoved * execute 'if !exists("colors_name") |
 85 |          \ colorscheme office-light | endif'
 86 | augroup END
 87 | let colors_name = 'office-light'
 88 | 
 89 | " highlighting function
 90 | fun! <sid>h(x, gf, gb, cf, cb, a, s)
 91 |   if a:gf != '' | exe 'hi ' . a:x . ' guifg=#'  . a:gf                  | endif
 92 |   if a:gb != '' | exe 'hi ' . a:x . ' guibg=#'  . a:gb                  | endif
 93 |   if a:cf != '' | exe 'hi ' . a:x . ' ctermfg=' . a:cf                  | endif
 94 |   if a:cb != '' | exe 'hi ' . a:x . ' ctermbg=' . a:cb                  | endif
 95 |   if a:a  != '' | exe 'hi ' . a:x . ' gui='     . a:a . ' cterm=' . a:a | endif
 96 |   if a:s  != '' | exe 'hi ' . a:x . ' guisp=#'  . a:s                   | endif
 97 | endfun
 98 | 
 99 | 
100 | "=== BASIC HIGHLIGHTING =======================================================
101 | 
102 | " cursor + status line + selected tab
103 | cal <sid>h('Cursor'           , s:g0 , s:g4 , s:t0 , s:t4 , 'none'      , ''  )
104 | cal <sid>h('StatusLine'       , s:g0 , s:g4 , s:t0 , s:t4 , 'none'      , ''  )
105 | cal <sid>h('StatusLineTerm'   , s:g0 , s:g4 , s:t0 , s:t4 , 'none'      , ''  )
106 | cal <sid>h('TabLineSel'       , s:g0 , s:g4 , s:t0 , s:t4 , 'none'      , ''  )
107 | cal <sid>h('TermCursor'       , s:g0 , s:g4 , s:t0 , s:t4 , 'none'      , ''  )
108 | 
109 | " line numbers
110 | cal <sid>h('CursorLineNr'     , s:g0 , s:g3 , s:t0 , s:t3 , 'none'      , ''  )
111 | cal <sid>h('LineNr'           , s:g4 , s:g1 , s:t4 , s:t1 , 'none'      , ''  )
112 | 
113 | " basic text
114 | cal <sid>h('Bold'             , ''   , ''   , ''   , ''   , 'bold'      , ''  )
115 | cal <sid>h('Directory'        , s:g5 , ''   , s:t5 , ''   , 'bold'      , ''  )
116 | cal <sid>h('Italic'           , ''   , ''   , ''   , ''   , 'italic'    , ''  )
117 | cal <sid>h('Normal'           , s:g5 , s:g0 , s:t5 , s:t0 , 'none'      , ''  )
118 | cal <sid>h('Underlined'       , s:g5 , ''   , s:t5 , ''   , 'underline' , ''  )
119 | 
120 | " commented-out text
121 | cal <sid>h('Comment'          , s:g3 , ''   , s:t3 , ''   , 'none'      , ''  )
122 | cal <sid>h('Conceal'          , s:g3 , ''   , s:t3 , ''   , 'none'      , ''  )
123 | cal <sid>h('EndOfBuffer'      , s:g3 , ''   , s:t3 , ''   , 'none'      , ''  )
124 | cal <sid>h('Ignore'           , s:g3 , ''   , s:t3 , ''   , 'none'      , ''  )
125 | cal <sid>h('NonText'          , s:g3 , ''   , s:t3 , ''   , 'none'      , ''  )
126 | 
127 | " highlighted background
128 | cal <sid>h('ColorColumn'      , ''   , s:g1 , ''   , s:t1 , 'none'      , ''  )
129 | cal <sid>h('CursorColumn'     , ''   , s:g1 , ''   , s:t1 , 'none'      , ''  )
130 | cal <sid>h('CursorLine'       , ''   , s:g1 , ''   , s:t1 , 'none'      , ''  )
131 | cal <sid>h('QuickFixLine'     , ''   , s:g1 , ''   , s:t1 , 'none'      , ''  )
132 | cal <sid>h('StatusLineNC'     , s:g5 , s:g1 , s:t5 , s:t1 , 'none'      , ''  )
133 | cal <sid>h('StatusLineTermNC' , s:g5 , s:g1 , s:t5 , s:t1 , 'none'      , ''  )
134 | cal <sid>h('TabLineFill'      , ''   , s:g1 , ''   , s:t1 , 'none'      , ''  )
135 | cal <sid>h('TermCursorNC'     , ''   , s:g1 , ''   , s:t1 , 'none'      , ''  )
136 | 
137 | " muted text on highlighted background
138 | cal <sid>h('DiffChange'       , s:g4 , s:g1 , s:t4 , s:t1 , 'none'      , ''  )
139 | cal <sid>h('FoldColumn'       , s:g4 , s:g1 , s:t4 , s:t1 , 'none'      , ''  )
140 | cal <sid>h('Folded'           , s:g4 , s:g1 , s:t4 , s:t1 , 'none'      , ''  )
141 | cal <sid>h('SignColumn'       , s:g4 , s:g1 , s:t4 , s:t1 , 'none'      , ''  )
142 | cal <sid>h('TabLine'          , s:g4 , s:g1 , s:t4 , s:t1 , 'none'      , ''  )
143 | cal <sid>h('VisualNOS'        , s:g4 , s:g1 , s:t4 , s:t1 , 'none'      , ''  )
144 | 
145 | " strongly highlighted background
146 | cal <sid>h('MatchParen'       , s:g6 , s:g2 , s:t6 , s:t2 , 'none'      , ''  )
147 | cal <sid>h('Pmenu'            , s:g6 , s:g2 , s:t6 , s:t2 , 'none'      , ''  )
148 | cal <sid>h('Visual'           , s:g6 , s:g2 , s:t6 , s:t2 , 'none'      , ''  )
149 | 
150 | " selected menu item
151 | cal <sid>h('PmenuSel'         , s:g0 , s:g5 , s:t0 , s:t5 , 'none'      , ''  )
152 | cal <sid>h('WildMenu'         , s:g0 , s:g6 , s:t0 , s:t6 , 'none'      , ''  )
153 | 
154 | " solid lines
155 | cal <sid>h('PmenuSbar'        , s:g1 , s:g1 , s:t1 , s:t1 , 'none'      , ''  )
156 | cal <sid>h('PmenuThumb'       , s:g4 , s:g4 , s:t4 , s:t4 , 'none'      , ''  )
157 | cal <sid>h('VertSplit'        , s:g2 , s:g2 , s:t2 , s:t2 , 'none'      , ''  )
158 | 
159 | 
160 | "=== ALERT/SYNTAX HIGHLIGHTING ================================================
161 | 
162 | " RED for warning elements
163 | cal <sid>h('DiffDelete'       , s:g8 , s:g0 , s:t8 , s:t0 , 'reverse'   , ''  )
164 | cal <sid>h('Error'            , s:g8 , s:g0 , s:t8 , s:t0 , 'reverse'   , ''  )
165 | cal <sid>h('ErrorMsg'         , s:g8 , s:g0 , s:t8 , s:t0 , 'none'      , ''  )
166 | cal <sid>h('SpellBad'         , ''   , ''   , s:t0 , s:t8 , 'undercurl' , s:g8)
167 | cal <sid>h('TooLong'          , s:g8 , ''   , s:t8 , ''   , 'none'      , ''  )
168 | cal <sid>h('WarningMsg'       , s:g8 , s:g0 , s:t8 , s:t0 , 'none'      , ''  )
169 | 
170 | " ORANGE for preliminary elements
171 | cal <sid>h('Define'           , s:g9 , ''   , s:t9 , ''   , 'none'      , ''  )
172 | cal <sid>h('IncSearch'        , s:g9 , s:g0 , s:t9 , s:t0 , 'reverse'   , ''  )
173 | cal <sid>h('Include'          , s:g9 , ''   , s:t9 , ''   , 'none'      , ''  )
174 | cal <sid>h('Macro'            , s:g9 , ''   , s:t9 , ''   , 'none'      , ''  )
175 | cal <sid>h('PreCondit'        , s:g9 , ''   , s:t9 , ''   , 'none'      , ''  )
176 | cal <sid>h('PreProc'          , s:g9 , ''   , s:t9 , ''   , 'none'      , ''  )
177 | cal <sid>h('SpellCap'         , ''   , ''   , s:t0 , s:t9 , 'undercurl' , s:g9)
178 | cal <sid>h('Title'            , s:g9 , ''   , s:t9 , ''   , 'none'      , ''  )
179 | 
180 | " YELLOW for highlighted elements
181 | cal <sid>h('DiffText'         , s:gA , s:g6 , s:tA , s:t6 , 'reverse'   , ''  )
182 | cal <sid>h('Search'           , s:gA , s:g6 , s:tA , s:t6 , 'reverse'   , ''  )
183 | cal <sid>h('Todo'             , s:gA , s:g6 , s:tA , s:t6 , 'reverse'   , ''  )
184 | 
185 | " GREEN for action elements
186 | cal <sid>h('Conditional'      , s:gB , ''   , s:tB , ''   , 'none'      , ''  )
187 | cal <sid>h('DiffAdd'          , s:gB , s:g0 , s:tB , s:t0 , 'reverse'   , ''  )
188 | cal <sid>h('Exception'        , s:gB , ''   , s:tB , ''   , 'none'      , ''  )
189 | cal <sid>h('Keyword'          , s:gB , ''   , s:tB , ''   , 'none'      , ''  )
190 | cal <sid>h('Label'            , s:gB , ''   , s:tB , ''   , 'none'      , ''  )
191 | cal <sid>h('ModeMsg'          , s:gB , ''   , s:tB , ''   , 'none'      , ''  )
192 | cal <sid>h('MoreMsg'          , s:gB , ''   , s:tB , ''   , 'none'      , ''  )
193 | cal <sid>h('Operator'         , s:gB , ''   , s:tB , ''   , 'none'      , ''  )
194 | cal <sid>h('Question'         , s:gB , ''   , s:tB , ''   , 'none'      , ''  )
195 | cal <sid>h('Repeat'           , s:gB , ''   , s:tB , ''   , 'none'      , ''  )
196 | cal <sid>h('Statement'        , s:gB , ''   , s:tB , ''   , 'none'      , ''  )
197 | 
198 | " TEAL for object types
199 | cal <sid>h('SpellLocal'       , ''   , ''   , s:t0 , s:tC , 'undercurl' , s:gC)
200 | cal <sid>h('StorageClass'     , s:gC , ''   , s:tC , ''   , 'none'      , ''  )
201 | cal <sid>h('Structure'        , s:gC , ''   , s:tC , ''   , 'none'      , ''  )
202 | cal <sid>h('Type'             , s:gC , ''   , s:tC , ''   , 'none'      , ''  )
203 | cal <sid>h('Typedef'          , s:gC , ''   , s:tC , ''   , 'none'      , ''  )
204 | 
205 | " BLUE for constants
206 | cal <sid>h('Boolean'          , s:gD , ''   , s:tD , ''   , 'none'      , ''  )
207 | cal <sid>h('Character'        , s:gD , ''   , s:tD , ''   , 'none'      , ''  )
208 | cal <sid>h('Constant'         , s:gD , ''   , s:tD , ''   , 'none'      , ''  )
209 | cal <sid>h('Float'            , s:gD , ''   , s:tD , ''   , 'none'      , ''  )
210 | cal <sid>h('Number'           , s:gD , ''   , s:tD , ''   , 'none'      , ''  )
211 | cal <sid>h('String'           , s:gD , ''   , s:tD , ''   , 'none'      , ''  )
212 | 
213 | " PURPLE for special text
214 | cal <sid>h('Debug'            , s:gE , ''   , s:tE , ''   , 'none'      , ''  )
215 | cal <sid>h('Delimiter'        , s:gE , ''   , s:tE , ''   , 'none'      , ''  )
216 | cal <sid>h('Special'          , s:gE , ''   , s:tE , ''   , 'none'      , ''  )
217 | cal <sid>h('SpecialChar'      , s:gE , ''   , s:tE , ''   , 'none'      , ''  )
218 | cal <sid>h('SpecialComment'   , s:gE , ''   , s:tE , ''   , 'none'      , ''  )
219 | cal <sid>h('SpecialKey'       , s:gE , ''   , s:tE , ''   , 'none'      , ''  )
220 | cal <sid>h('SpellRare'        , ''   , ''   , s:t0 , s:tE , 'undercurl' , s:gE)
221 | cal <sid>h('Tag'              , s:gE , ''   , s:tE , ''   , 'none'      , ''  )
222 | 
223 | " PINK for object names
224 | cal <sid>h('Function'         , s:gF , ''   , s:tF , ''   , 'none'      , ''  )
225 | cal <sid>h('Identifier'       , s:gF , ''   , s:tF , ''   , 'none'      , ''  )
226 | 
227 | 
228 | "=== OPTIONS ==================================================================
229 | 
230 | " disable highlighted CursorLineNr
231 | if exists('g:office_light_CursorLineNr')
232 | if g:office_light_CursorLineNr == 'off'
233 | cal <sid>h('CursorLineNr'     , s:g4 , s:g1 , s:t4 , s:t1 , 'none'      , ''  )
234 | endif
235 | endif
236 | 
237 | " disable LineNr background altogether
238 | if exists('g:office_light_LineNr')
239 | if g:office_light_LineNr == 'off'
240 | cal <sid>h('CursorLineNr'     , s:g4 , s:g0 , s:t4 , s:t0 , 'none'      , ''  )
241 | cal <sid>h('LineNr'           , s:g4 , s:g0 , s:t4 , s:t0 , 'none'      , ''  )
242 | endif
243 | endif
244 | 


--------------------------------------------------------------------------------
/colors/vrunchbang-dark.vim:
--------------------------------------------------------------------------------
  1 | " vrunchbang-dark, a vim colourscheme by nightsense
  2 | "
  3 | " generated with a theme template adapted from
  4 | " base16-vim (https://github.com/chriskempson/base16-vim)
  5 | " by Chris Kempson (http://chriskempson.com)
  6 | 
  7 | 
  8 | "=== SET COLOUR VARIABLES =====================================================
  9 | 
 10 | " GUI colours
 11 | let s:g0 = '2e3436'
 12 | let s:g1 = '3b4245'
 13 | let s:g2 = '485154'
 14 | let s:g3 = '707e82'
 15 | let s:g4 = '949494'
 16 | let s:g5 = 'bfbfbf'
 17 | let s:g6 = 'e0e0e0'
 18 | let s:g7 = 'ffffff'
 19 | let s:g8 = 'bf5858'
 20 | let s:g9 = 'b56f45'
 21 | let s:gA = 'ab8e38'
 22 | let s:gB = '508a50'
 23 | let s:gC = '458a8a'
 24 | let s:gD = '557b9e'
 25 | let s:gE = '8b6a9e'
 26 | let s:gF = 'ab6a7a'
 27 | 
 28 | " terminal colours
 29 | let s:t0 = '00'
 30 | let s:t3 = '08'
 31 | let s:t5 = '07'
 32 | let s:t7 = '15'
 33 | let s:t8 = '01'
 34 | let s:tA = '03'
 35 | let s:tB = '02'
 36 | let s:tC = '06'
 37 | let s:tD = '04'
 38 | let s:tE = '05'
 39 | let s:t1 = '10'
 40 | let s:t2 = '11'
 41 | let s:t4 = '12'
 42 | let s:t6 = '13'
 43 | let s:t9 = '09'
 44 | let s:tF = '14'
 45 | 
 46 | " neovim colours
 47 | if has('nvim')
 48 |   let g:terminal_color_0 =  '#2e3436'
 49 |   let g:terminal_color_1 =  '#bf5858'
 50 |   let g:terminal_color_2 =  '#508a50'
 51 |   let g:terminal_color_3 =  '#ab8e38'
 52 |   let g:terminal_color_4 =  '#557b9e'
 53 |   let g:terminal_color_5 =  '#8b6a9e'
 54 |   let g:terminal_color_6 =  '#458a8a'
 55 |   let g:terminal_color_7 =  '#bfbfbf'
 56 |   let g:terminal_color_8 =  '#707e82'
 57 |   let g:terminal_color_9 =  '#b56f45'
 58 |   let g:terminal_color_10 = '#3b4245'
 59 |   let g:terminal_color_11 = '#485154'
 60 |   let g:terminal_color_12 = '#949494'
 61 |   let g:terminal_color_13 = '#e0e0e0'
 62 |   let g:terminal_color_14 = '#ab6a7a'
 63 |   let g:terminal_color_15 = '#ffffff'
 64 | endif
 65 | 
 66 | 
 67 | "=== OTHER PREPARATION ========================================================
 68 | 
 69 | " run theme-setting script if using terminal vim
 70 | if filereadable(expand('~/.nightshell/vrunchbang-dark'))
 71 |   if !has('gui_running')
 72 |     execute 'silent !/bin/sh $HOME/.nightshell/vrunchbang-dark'
 73 |   endif
 74 | endif
 75 | 
 76 | " clear old theme
 77 | hi clear
 78 | syntax reset
 79 | 
 80 | " set new theme
 81 | set background=dark
 82 | augroup NightsenseThemeSet
 83 |    autocmd!
 84 |    autocmd CursorMoved * execute 'if !exists("colors_name") |
 85 |          \ colorscheme vrunchbang-dark | endif'
 86 | augroup END
 87 | let colors_name = 'vrunchbang-dark'
 88 | 
 89 | " highlighting function
 90 | fun! <sid>h(x, gf, gb, cf, cb, a, s)
 91 |   if a:gf != '' | exe 'hi ' . a:x . ' guifg=#'  . a:gf                  | endif
 92 |   if a:gb != '' | exe 'hi ' . a:x . ' guibg=#'  . a:gb                  | endif
 93 |   if a:cf != '' | exe 'hi ' . a:x . ' ctermfg=' . a:cf                  | endif
 94 |   if a:cb != '' | exe 'hi ' . a:x . ' ctermbg=' . a:cb                  | endif
 95 |   if a:a  != '' | exe 'hi ' . a:x . ' gui='     . a:a . ' cterm=' . a:a | endif
 96 |   if a:s  != '' | exe 'hi ' . a:x . ' guisp=#'  . a:s                   | endif
 97 | endfun
 98 | 
 99 | 
100 | "=== BASIC HIGHLIGHTING =======================================================
101 | 
102 | " cursor + status line + selected tab
103 | cal <sid>h('Cursor'           , s:g0 , s:g5 , s:t0 , s:t5 , 'none'      , ''  )
104 | cal <sid>h('StatusLine'       , s:g0 , s:g4 , s:t0 , s:t4 , 'none'      , ''  )
105 | cal <sid>h('StatusLineTerm'   , s:g0 , s:g4 , s:t0 , s:t4 , 'none'      , ''  )
106 | cal <sid>h('TabLineSel'       , s:g0 , s:g4 , s:t0 , s:t4 , 'none'      , ''  )
107 | cal <sid>h('TermCursor'       , s:g0 , s:g5 , s:t0 , s:t5 , 'none'      , ''  )
108 | 
109 | " line numbers
110 | cal <sid>h('CursorLineNr'     , s:g0 , s:g3 , s:t0 , s:t3 , 'none'      , ''  )
111 | cal <sid>h('LineNr'           , s:g4 , s:g1 , s:t4 , s:t1 , 'none'      , ''  )
112 | 
113 | " basic text
114 | cal <sid>h('Bold'             , ''   , ''   , ''   , ''   , 'bold'      , ''  )
115 | cal <sid>h('Directory'        , s:g5 , ''   , s:t5 , ''   , 'bold'      , ''  )
116 | cal <sid>h('Italic'           , ''   , ''   , ''   , ''   , 'italic'    , ''  )
117 | cal <sid>h('Normal'           , s:g5 , s:g0 , s:t5 , s:t0 , 'none'      , ''  )
118 | cal <sid>h('Underlined'       , s:g5 , ''   , s:t5 , ''   , 'underline' , ''  )
119 | 
120 | " commented-out text
121 | cal <sid>h('Comment'          , s:g3 , ''   , s:t3 , ''   , 'none'      , ''  )
122 | cal <sid>h('Conceal'          , s:g3 , ''   , s:t3 , ''   , 'none'      , ''  )
123 | cal <sid>h('EndOfBuffer'      , s:g3 , ''   , s:t3 , ''   , 'none'      , ''  )
124 | cal <sid>h('Ignore'           , s:g3 , ''   , s:t3 , ''   , 'none'      , ''  )
125 | cal <sid>h('NonText'          , s:g3 , ''   , s:t3 , ''   , 'none'      , ''  )
126 | 
127 | " highlighted background
128 | cal <sid>h('ColorColumn'      , ''   , s:g1 , ''   , s:t1 , 'none'      , ''  )
129 | cal <sid>h('CursorColumn'     , ''   , s:g1 , ''   , s:t1 , 'none'      , ''  )
130 | cal <sid>h('CursorLine'       , ''   , s:g1 , ''   , s:t1 , 'none'      , ''  )
131 | cal <sid>h('QuickFixLine'     , ''   , s:g1 , ''   , s:t1 , 'none'      , ''  )
132 | cal <sid>h('StatusLineNC'     , s:g5 , s:g1 , s:t5 , s:t1 , 'none'      , ''  )
133 | cal <sid>h('StatusLineTermNC' , s:g5 , s:g1 , s:t5 , s:t1 , 'none'      , ''  )
134 | cal <sid>h('TabLineFill'      , ''   , s:g1 , ''   , s:t1 , 'none'      , ''  )
135 | cal <sid>h('TermCursorNC'     , ''   , s:g1 , ''   , s:t1 , 'none'      , ''  )
136 | 
137 | " muted text on highlighted background
138 | cal <sid>h('DiffChange'       , s:g4 , s:g1 , s:t4 , s:t1 , 'none'      , ''  )
139 | cal <sid>h('FoldColumn'       , s:g4 , s:g1 , s:t4 , s:t1 , 'none'      , ''  )
140 | cal <sid>h('Folded'           , s:g4 , s:g1 , s:t4 , s:t1 , 'none'      , ''  )
141 | cal <sid>h('SignColumn'       , s:g4 , s:g1 , s:t4 , s:t1 , 'none'      , ''  )
142 | cal <sid>h('TabLine'          , s:g4 , s:g1 , s:t4 , s:t1 , 'none'      , ''  )
143 | cal <sid>h('VisualNOS'        , s:g4 , s:g1 , s:t4 , s:t1 , 'none'      , ''  )
144 | 
145 | " strongly highlighted background
146 | cal <sid>h('MatchParen'       , s:g6 , s:g2 , s:t6 , s:t2 , 'none'      , ''  )
147 | cal <sid>h('Pmenu'            , s:g6 , s:g2 , s:t6 , s:t2 , 'none'      , ''  )
148 | cal <sid>h('Visual'           , s:g6 , s:g2 , s:t6 , s:t2 , 'none'      , ''  )
149 | 
150 | " selected menu item
151 | cal <sid>h('PmenuSel'         , s:g0 , s:g5 , s:t0 , s:t5 , 'none'      , ''  )
152 | cal <sid>h('WildMenu'         , s:g0 , s:g6 , s:t0 , s:t6 , 'none'      , ''  )
153 | 
154 | " solid lines
155 | cal <sid>h('PmenuSbar'        , s:g1 , s:g1 , s:t1 , s:t1 , 'none'      , ''  )
156 | cal <sid>h('PmenuThumb'       , s:g4 , s:g4 , s:t4 , s:t4 , 'none'      , ''  )
157 | cal <sid>h('VertSplit'        , s:g2 , s:g2 , s:t2 , s:t2 , 'none'      , ''  )
158 | 
159 | 
160 | "=== ALERT/SYNTAX HIGHLIGHTING ================================================
161 | 
162 | " RED for warning elements
163 | cal <sid>h('DiffDelete'       , s:g8 , s:g0 , s:t8 , s:t0 , 'reverse'   , ''  )
164 | cal <sid>h('Error'            , s:g8 , s:g0 , s:t8 , s:t0 , 'reverse'   , ''  )
165 | cal <sid>h('ErrorMsg'         , s:g8 , s:g0 , s:t8 , s:t0 , 'none'      , ''  )
166 | cal <sid>h('SpellBad'         , ''   , ''   , s:t0 , s:t8 , 'undercurl' , s:g8)
167 | cal <sid>h('TooLong'          , s:g8 , ''   , s:t8 , ''   , 'none'      , ''  )
168 | cal <sid>h('WarningMsg'       , s:g8 , s:g0 , s:t8 , s:t0 , 'none'      , ''  )
169 | 
170 | " ORANGE for preliminary elements
171 | cal <sid>h('Define'           , s:g9 , ''   , s:t9 , ''   , 'none'      , ''  )
172 | cal <sid>h('IncSearch'        , s:g9 , s:g0 , s:t9 , s:t0 , 'reverse'   , ''  )
173 | cal <sid>h('Include'          , s:g9 , ''   , s:t9 , ''   , 'none'      , ''  )
174 | cal <sid>h('Macro'            , s:g9 , ''   , s:t9 , ''   , 'none'      , ''  )
175 | cal <sid>h('PreCondit'        , s:g9 , ''   , s:t9 , ''   , 'none'      , ''  )
176 | cal <sid>h('PreProc'          , s:g9 , ''   , s:t9 , ''   , 'none'      , ''  )
177 | cal <sid>h('SpellCap'         , ''   , ''   , s:t0 , s:t9 , 'undercurl' , s:g9)
178 | cal <sid>h('Title'            , s:g9 , ''   , s:t9 , ''   , 'none'      , ''  )
179 | 
180 | " YELLOW for highlighted elements
181 | cal <sid>h('DiffText'         , s:gA , s:g0 , s:tA , s:t0 , 'reverse'   , ''  )
182 | cal <sid>h('Search'           , s:gA , s:g0 , s:tA , s:t0 , 'reverse'   , ''  )
183 | cal <sid>h('Todo'             , s:gA , s:g0 , s:tA , s:t0 , 'reverse'   , ''  )
184 | 
185 | " GREEN for action elements
186 | cal <sid>h('Conditional'      , s:gB , ''   , s:tB , ''   , 'none'      , ''  )
187 | cal <sid>h('DiffAdd'          , s:gB , s:g0 , s:tB , s:t0 , 'reverse'   , ''  )
188 | cal <sid>h('Exception'        , s:gB , ''   , s:tB , ''   , 'none'      , ''  )
189 | cal <sid>h('Keyword'          , s:gB , ''   , s:tB , ''   , 'none'      , ''  )
190 | cal <sid>h('Label'            , s:gB , ''   , s:tB , ''   , 'none'      , ''  )
191 | cal <sid>h('ModeMsg'          , s:gB , ''   , s:tB , ''   , 'none'      , ''  )
192 | cal <sid>h('MoreMsg'          , s:gB , ''   , s:tB , ''   , 'none'      , ''  )
193 | cal <sid>h('Operator'         , s:gB , ''   , s:tB , ''   , 'none'      , ''  )
194 | cal <sid>h('Question'         , s:gB , ''   , s:tB , ''   , 'none'      , ''  )
195 | cal <sid>h('Repeat'           , s:gB , ''   , s:tB , ''   , 'none'      , ''  )
196 | cal <sid>h('Statement'        , s:gB , ''   , s:tB , ''   , 'none'      , ''  )
197 | 
198 | " TEAL for object types
199 | cal <sid>h('SpellLocal'       , ''   , ''   , s:t0 , s:tC , 'undercurl' , s:gC)
200 | cal <sid>h('StorageClass'     , s:gC , ''   , s:tC , ''   , 'none'      , ''  )
201 | cal <sid>h('Structure'        , s:gC , ''   , s:tC , ''   , 'none'      , ''  )
202 | cal <sid>h('Type'             , s:gC , ''   , s:tC , ''   , 'none'      , ''  )
203 | cal <sid>h('Typedef'          , s:gC , ''   , s:tC , ''   , 'none'      , ''  )
204 | 
205 | " BLUE for constants
206 | cal <sid>h('Boolean'          , s:gD , ''   , s:tD , ''   , 'none'      , ''  )
207 | cal <sid>h('Character'        , s:gD , ''   , s:tD , ''   , 'none'      , ''  )
208 | cal <sid>h('Constant'         , s:gD , ''   , s:tD , ''   , 'none'      , ''  )
209 | cal <sid>h('Float'            , s:gD , ''   , s:tD , ''   , 'none'      , ''  )
210 | cal <sid>h('Number'           , s:gD , ''   , s:tD , ''   , 'none'      , ''  )
211 | cal <sid>h('String'           , s:gD , ''   , s:tD , ''   , 'none'      , ''  )
212 | 
213 | " PURPLE for special text
214 | cal <sid>h('Debug'            , s:gE , ''   , s:tE , ''   , 'none'      , ''  )
215 | cal <sid>h('Delimiter'        , s:gE , ''   , s:tE , ''   , 'none'      , ''  )
216 | cal <sid>h('Special'          , s:gE , ''   , s:tE , ''   , 'none'      , ''  )
217 | cal <sid>h('SpecialChar'      , s:gE , ''   , s:tE , ''   , 'none'      , ''  )
218 | cal <sid>h('SpecialComment'   , s:gE , ''   , s:tE , ''   , 'none'      , ''  )
219 | cal <sid>h('SpecialKey'       , s:gE , ''   , s:tE , ''   , 'none'      , ''  )
220 | cal <sid>h('SpellRare'        , ''   , ''   , s:t0 , s:tE , 'undercurl' , s:gE)
221 | cal <sid>h('Tag'              , s:gE , ''   , s:tE , ''   , 'none'      , ''  )
222 | 
223 | " PINK for object names
224 | cal <sid>h('Function'         , s:gF , ''   , s:tF , ''   , 'none'      , ''  )
225 | cal <sid>h('Identifier'       , s:gF , ''   , s:tF , ''   , 'none'      , ''  )
226 | 
227 | 
228 | "=== OPTIONS ==================================================================
229 | 
230 | " disable highlighted CursorLineNr
231 | if exists('g:vrunchbang_dark_CursorLineNr')
232 | if g:vrunchbang_dark_CursorLineNr == 'off'
233 | cal <sid>h('CursorLineNr'     , s:g4 , s:g1 , s:t4 , s:t1 , 'none'      , ''  )
234 | endif
235 | endif
236 | 
237 | " disable LineNr background altogether
238 | if exists('g:vrunchbang_dark_LineNr')
239 | if g:vrunchbang_dark_LineNr == 'off'
240 | cal <sid>h('CursorLineNr'     , s:g4 , s:g0 , s:t4 , s:t0 , 'none'      , ''  )
241 | cal <sid>h('LineNr'           , s:g4 , s:g0 , s:t4 , s:t0 , 'none'      , ''  )
242 | endif
243 | endif
244 | 


--------------------------------------------------------------------------------
/colors/vrunchbang-light.vim:
--------------------------------------------------------------------------------
  1 | " vrunchbang-light, a vim colourscheme by nightsense
  2 | "
  3 | " generated with a theme template adapted from
  4 | " base16-vim (https://github.com/chriskempson/base16-vim)
  5 | " by Chris Kempson (http://chriskempson.com)
  6 | 
  7 | 
  8 | "=== SET COLOUR VARIABLES =====================================================
  9 | 
 10 | " GUI colours
 11 | let s:g0 = 'ffffff'
 12 | let s:g1 = 'e0e0e0'
 13 | let s:g2 = 'bfbfbf'
 14 | let s:g3 = '949494'
 15 | let s:g4 = '707e82'
 16 | let s:g5 = '485154'
 17 | let s:g6 = '3b4245'
 18 | let s:g7 = '2e3436'
 19 | let s:g8 = 'f55050'
 20 | let s:g9 = 'e06a26'
 21 | let s:gA = 'd4ac35'
 22 | let s:gB = '219e21'
 23 | let s:gC = '1b9e9e'
 24 | let s:gD = '468dd4'
 25 | let s:gE = 'a26fbf'
 26 | let s:gF = 'd46a84'
 27 | 
 28 | " terminal colours
 29 | let s:t0 = '00'
 30 | let s:t3 = '08'
 31 | let s:t5 = '07'
 32 | let s:t7 = '15'
 33 | let s:t8 = '01'
 34 | let s:tA = '03'
 35 | let s:tB = '02'
 36 | let s:tC = '06'
 37 | let s:tD = '04'
 38 | let s:tE = '05'
 39 | let s:t1 = '10'
 40 | let s:t2 = '11'
 41 | let s:t4 = '12'
 42 | let s:t6 = '13'
 43 | let s:t9 = '09'
 44 | let s:tF = '14'
 45 | 
 46 | " neovim colours
 47 | if has('nvim')
 48 |   let g:terminal_color_0 =  '#ffffff'
 49 |   let g:terminal_color_1 =  '#f55050'
 50 |   let g:terminal_color_2 =  '#219e21'
 51 |   let g:terminal_color_3 =  '#d4ac35'
 52 |   let g:terminal_color_4 =  '#468dd4'
 53 |   let g:terminal_color_5 =  '#a26fbf'
 54 |   let g:terminal_color_6 =  '#1b9e9e'
 55 |   let g:terminal_color_7 =  '#485154'
 56 |   let g:terminal_color_8 =  '#949494'
 57 |   let g:terminal_color_9 =  '#e06a26'
 58 |   let g:terminal_color_10 = '#e0e0e0'
 59 |   let g:terminal_color_11 = '#bfbfbf'
 60 |   let g:terminal_color_12 = '#707e82'
 61 |   let g:terminal_color_13 = '#3b4245'
 62 |   let g:terminal_color_14 = '#d46a84'
 63 |   let g:terminal_color_15 = '#2e3436'
 64 | endif
 65 | 
 66 | 
 67 | "=== OTHER PREPARATION ========================================================
 68 | 
 69 | " run theme-setting script if using terminal vim
 70 | if filereadable(expand('~/.nightshell/vrunchbang-light'))
 71 |   if !has('gui_running')
 72 |     execute 'silent !/bin/sh $HOME/.nightshell/vrunchbang-light'
 73 |   endif
 74 | endif
 75 | 
 76 | " clear old theme
 77 | hi clear
 78 | syntax reset
 79 | 
 80 | " set new theme
 81 | set background=light
 82 | augroup NightsenseThemeSet
 83 |    autocmd!
 84 |    autocmd CursorMoved * execute 'if !exists("colors_name") |
 85 |          \ colorscheme vrunchbang-light | endif'
 86 | augroup END
 87 | let colors_name = 'vrunchbang-light'
 88 | 
 89 | " highlighting function
 90 | fun! <sid>h(x, gf, gb, cf, cb, a, s)
 91 |   if a:gf != '' | exe 'hi ' . a:x . ' guifg=#'  . a:gf                  | endif
 92 |   if a:gb != '' | exe 'hi ' . a:x . ' guibg=#'  . a:gb                  | endif
 93 |   if a:cf != '' | exe 'hi ' . a:x . ' ctermfg=' . a:cf                  | endif
 94 |   if a:cb != '' | exe 'hi ' . a:x . ' ctermbg=' . a:cb                  | endif
 95 |   if a:a  != '' | exe 'hi ' . a:x . ' gui='     . a:a . ' cterm=' . a:a | endif
 96 |   if a:s  != '' | exe 'hi ' . a:x . ' guisp=#'  . a:s                   | endif
 97 | endfun
 98 | 
 99 | 
100 | "=== BASIC HIGHLIGHTING =======================================================
101 | 
102 | " cursor + status line + selected tab
103 | cal <sid>h('Cursor'           , s:g0 , s:g5 , s:t0 , s:t5 , 'none'      , ''  )
104 | cal <sid>h('StatusLine'       , s:g0 , s:g4 , s:t0 , s:t4 , 'none'      , ''  )
105 | cal <sid>h('StatusLineTerm'   , s:g0 , s:g4 , s:t0 , s:t4 , 'none'      , ''  )
106 | cal <sid>h('TabLineSel'       , s:g0 , s:g4 , s:t0 , s:t4 , 'none'      , ''  )
107 | cal <sid>h('TermCursor'       , s:g0 , s:g5 , s:t0 , s:t5 , 'none'      , ''  )
108 | 
109 | " line numbers
110 | cal <sid>h('CursorLineNr'     , s:g0 , s:g3 , s:t0 , s:t3 , 'none'      , ''  )
111 | cal <sid>h('LineNr'           , s:g4 , s:g1 , s:t4 , s:t1 , 'none'      , ''  )
112 | 
113 | " basic text
114 | cal <sid>h('Bold'             , ''   , ''   , ''   , ''   , 'bold'      , ''  )
115 | cal <sid>h('Directory'        , s:g5 , ''   , s:t5 , ''   , 'bold'      , ''  )
116 | cal <sid>h('Italic'           , ''   , ''   , ''   , ''   , 'italic'    , ''  )
117 | cal <sid>h('Normal'           , s:g5 , s:g0 , s:t5 , s:t0 , 'none'      , ''  )
118 | cal <sid>h('Underlined'       , s:g5 , ''   , s:t5 , ''   , 'underline' , ''  )
119 | 
120 | " commented-out text
121 | cal <sid>h('Comment'          , s:g3 , ''   , s:t3 , ''   , 'none'      , ''  )
122 | cal <sid>h('Conceal'          , s:g3 , ''   , s:t3 , ''   , 'none'      , ''  )
123 | cal <sid>h('EndOfBuffer'      , s:g3 , ''   , s:t3 , ''   , 'none'      , ''  )
124 | cal <sid>h('Ignore'           , s:g3 , ''   , s:t3 , ''   , 'none'      , ''  )
125 | cal <sid>h('NonText'          , s:g3 , ''   , s:t3 , ''   , 'none'      , ''  )
126 | 
127 | " highlighted background
128 | cal <sid>h('ColorColumn'      , ''   , s:g1 , ''   , s:t1 , 'none'      , ''  )
129 | cal <sid>h('CursorColumn'     , ''   , s:g1 , ''   , s:t1 , 'none'      , ''  )
130 | cal <sid>h('CursorLine'       , ''   , s:g1 , ''   , s:t1 , 'none'      , ''  )
131 | cal <sid>h('QuickFixLine'     , ''   , s:g1 , ''   , s:t1 , 'none'      , ''  )
132 | cal <sid>h('StatusLineNC'     , s:g5 , s:g1 , s:t5 , s:t1 , 'none'      , ''  )
133 | cal <sid>h('StatusLineTermNC' , s:g5 , s:g1 , s:t5 , s:t1 , 'none'      , ''  )
134 | cal <sid>h('TabLineFill'      , ''   , s:g1 , ''   , s:t1 , 'none'      , ''  )
135 | cal <sid>h('TermCursorNC'     , ''   , s:g1 , ''   , s:t1 , 'none'      , ''  )
136 | 
137 | " muted text on highlighted background
138 | cal <sid>h('DiffChange'       , s:g4 , s:g1 , s:t4 , s:t1 , 'none'      , ''  )
139 | cal <sid>h('FoldColumn'       , s:g4 , s:g1 , s:t4 , s:t1 , 'none'      , ''  )
140 | cal <sid>h('Folded'           , s:g4 , s:g1 , s:t4 , s:t1 , 'none'      , ''  )
141 | cal <sid>h('SignColumn'       , s:g4 , s:g1 , s:t4 , s:t1 , 'none'      , ''  )
142 | cal <sid>h('TabLine'          , s:g4 , s:g1 , s:t4 , s:t1 , 'none'      , ''  )
143 | cal <sid>h('VisualNOS'        , s:g4 , s:g1 , s:t4 , s:t1 , 'none'      , ''  )
144 | 
145 | " strongly highlighted background
146 | cal <sid>h('MatchParen'       , s:g6 , s:g2 , s:t6 , s:t2 , 'none'      , ''  )
147 | cal <sid>h('Pmenu'            , s:g6 , s:g2 , s:t6 , s:t2 , 'none'      , ''  )
148 | cal <sid>h('Visual'           , s:g6 , s:g2 , s:t6 , s:t2 , 'none'      , ''  )
149 | 
150 | " selected menu item
151 | cal <sid>h('PmenuSel'         , s:g0 , s:g5 , s:t0 , s:t5 , 'none'      , ''  )
152 | cal <sid>h('WildMenu'         , s:g0 , s:g6 , s:t0 , s:t6 , 'none'      , ''  )
153 | 
154 | " solid lines
155 | cal <sid>h('PmenuSbar'        , s:g1 , s:g1 , s:t1 , s:t1 , 'none'      , ''  )
156 | cal <sid>h('PmenuThumb'       , s:g4 , s:g4 , s:t4 , s:t4 , 'none'      , ''  )
157 | cal <sid>h('VertSplit'        , s:g2 , s:g2 , s:t2 , s:t2 , 'none'      , ''  )
158 | 
159 | 
160 | "=== ALERT/SYNTAX HIGHLIGHTING ================================================
161 | 
162 | " RED for warning elements
163 | cal <sid>h('DiffDelete'       , s:g8 , s:g0 , s:t8 , s:t0 , 'reverse'   , ''  )
164 | cal <sid>h('Error'            , s:g8 , s:g0 , s:t8 , s:t0 , 'reverse'   , ''  )
165 | cal <sid>h('ErrorMsg'         , s:g8 , s:g0 , s:t8 , s:t0 , 'none'      , ''  )
166 | cal <sid>h('SpellBad'         , ''   , ''   , s:t0 , s:t8 , 'undercurl' , s:g8)
167 | cal <sid>h('TooLong'          , s:g8 , ''   , s:t8 , ''   , 'none'      , ''  )
168 | cal <sid>h('WarningMsg'       , s:g8 , s:g0 , s:t8 , s:t0 , 'none'      , ''  )
169 | 
170 | " ORANGE for preliminary elements
171 | cal <sid>h('Define'           , s:g9 , ''   , s:t9 , ''   , 'none'      , ''  )
172 | cal <sid>h('IncSearch'        , s:g9 , s:g0 , s:t9 , s:t0 , 'reverse'   , ''  )
173 | cal <sid>h('Include'          , s:g9 , ''   , s:t9 , ''   , 'none'      , ''  )
174 | cal <sid>h('Macro'            , s:g9 , ''   , s:t9 , ''   , 'none'      , ''  )
175 | cal <sid>h('PreCondit'        , s:g9 , ''   , s:t9 , ''   , 'none'      , ''  )
176 | cal <sid>h('PreProc'          , s:g9 , ''   , s:t9 , ''   , 'none'      , ''  )
177 | cal <sid>h('SpellCap'         , ''   , ''   , s:t0 , s:t9 , 'undercurl' , s:g9)
178 | cal <sid>h('Title'            , s:g9 , ''   , s:t9 , ''   , 'none'      , ''  )
179 | 
180 | " YELLOW for highlighted elements
181 | cal <sid>h('DiffText'         , s:gA , s:g6 , s:tA , s:t6 , 'reverse'   , ''  )
182 | cal <sid>h('Search'           , s:gA , s:g6 , s:tA , s:t6 , 'reverse'   , ''  )
183 | cal <sid>h('Todo'             , s:gA , s:g6 , s:tA , s:t6 , 'reverse'   , ''  )
184 | 
185 | " GREEN for action elements
186 | cal <sid>h('Conditional'      , s:gB , ''   , s:tB , ''   , 'none'      , ''  )
187 | cal <sid>h('DiffAdd'          , s:gB , s:g0 , s:tB , s:t0 , 'reverse'   , ''  )
188 | cal <sid>h('Exception'        , s:gB , ''   , s:tB , ''   , 'none'      , ''  )
189 | cal <sid>h('Keyword'          , s:gB , ''   , s:tB , ''   , 'none'      , ''  )
190 | cal <sid>h('Label'            , s:gB , ''   , s:tB , ''   , 'none'      , ''  )
191 | cal <sid>h('ModeMsg'          , s:gB , ''   , s:tB , ''   , 'none'      , ''  )
192 | cal <sid>h('MoreMsg'          , s:gB , ''   , s:tB , ''   , 'none'      , ''  )
193 | cal <sid>h('Operator'         , s:gB , ''   , s:tB , ''   , 'none'      , ''  )
194 | cal <sid>h('Question'         , s:gB , ''   , s:tB , ''   , 'none'      , ''  )
195 | cal <sid>h('Repeat'           , s:gB , ''   , s:tB , ''   , 'none'      , ''  )
196 | cal <sid>h('Statement'        , s:gB , ''   , s:tB , ''   , 'none'      , ''  )
197 | 
198 | " TEAL for object types
199 | cal <sid>h('SpellLocal'       , ''   , ''   , s:t0 , s:tC , 'undercurl' , s:gC)
200 | cal <sid>h('StorageClass'     , s:gC , ''   , s:tC , ''   , 'none'      , ''  )
201 | cal <sid>h('Structure'        , s:gC , ''   , s:tC , ''   , 'none'      , ''  )
202 | cal <sid>h('Type'             , s:gC , ''   , s:tC , ''   , 'none'      , ''  )
203 | cal <sid>h('Typedef'          , s:gC , ''   , s:tC , ''   , 'none'      , ''  )
204 | 
205 | " BLUE for constants
206 | cal <sid>h('Boolean'          , s:gD , ''   , s:tD , ''   , 'none'      , ''  )
207 | cal <sid>h('Character'        , s:gD , ''   , s:tD , ''   , 'none'      , ''  )
208 | cal <sid>h('Constant'         , s:gD , ''   , s:tD , ''   , 'none'      , ''  )
209 | cal <sid>h('Float'            , s:gD , ''   , s:tD , ''   , 'none'      , ''  )
210 | cal <sid>h('Number'           , s:gD , ''   , s:tD , ''   , 'none'      , ''  )
211 | cal <sid>h('String'           , s:gD , ''   , s:tD , ''   , 'none'      , ''  )
212 | 
213 | " PURPLE for special text
214 | cal <sid>h('Debug'            , s:gE , ''   , s:tE , ''   , 'none'      , ''  )
215 | cal <sid>h('Delimiter'        , s:gE , ''   , s:tE , ''   , 'none'      , ''  )
216 | cal <sid>h('Special'          , s:gE , ''   , s:tE , ''   , 'none'      , ''  )
217 | cal <sid>h('SpecialChar'      , s:gE , ''   , s:tE , ''   , 'none'      , ''  )
218 | cal <sid>h('SpecialComment'   , s:gE , ''   , s:tE , ''   , 'none'      , ''  )
219 | cal <sid>h('SpecialKey'       , s:gE , ''   , s:tE , ''   , 'none'      , ''  )
220 | cal <sid>h('SpellRare'        , ''   , ''   , s:t0 , s:tE , 'undercurl' , s:gE)
221 | cal <sid>h('Tag'              , s:gE , ''   , s:tE , ''   , 'none'      , ''  )
222 | 
223 | " PINK for object names
224 | cal <sid>h('Function'         , s:gF , ''   , s:tF , ''   , 'none'      , ''  )
225 | cal <sid>h('Identifier'       , s:gF , ''   , s:tF , ''   , 'none'      , ''  )
226 | 
227 | 
228 | "=== OPTIONS ==================================================================
229 | 
230 | " disable highlighted CursorLineNr
231 | if exists('g:vrunchbang_light_CursorLineNr')
232 | if g:vrunchbang_light_CursorLineNr == 'off'
233 | cal <sid>h('CursorLineNr'     , s:g4 , s:g1 , s:t4 , s:t1 , 'none'      , ''  )
234 | endif
235 | endif
236 | 
237 | " disable LineNr background altogether
238 | if exists('g:vrunchbang_light_LineNr')
239 | if g:vrunchbang_light_LineNr == 'off'
240 | cal <sid>h('CursorLineNr'     , s:g4 , s:g0 , s:t4 , s:t0 , 'none'      , ''  )
241 | cal <sid>h('LineNr'           , s:g4 , s:g0 , s:t4 , s:t0 , 'none'      , ''  )
242 | endif
243 | endif
244 | 


--------------------------------------------------------------------------------
/img/putty-setting.PNG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dbdydgur2244/vim-setting/e83467f19b008bf3d5e04d9e358c8fa5a70a986a/img/putty-setting.PNG


--------------------------------------------------------------------------------
/vimrc:
--------------------------------------------------------------------------------
  1 | set nocompatible " 오리지날 VI와 호환하지 않음
  2 | filetype off
  3 | 
  4 | " set the runtime path to include Vundle and initialize
  5 | call plug#begin('~/.vim/plugged')
  6 | 
  7 | Plug 'scrooloose/nerdtree'
  8 | Plug 'vim-airline/vim-airline'
  9 | Plug 'vim-airline/vim-airline-themes'
 10 | Plug 'octol/vim-cpp-enhanced-highlight'
 11 | Plug 'vim-python/python-syntax'
 12 | Plug 'tpope/vim-fugitive'
 13 | Plug 'airblade/vim-gitgutter'
 14 | Plug 'ctrlpvim/ctrlp.vim'
 15 | Plug 'othree/html5.vim'
 16 | Plug 'scrooloose/nerdcommenter'
 17 | Plug 'junegunn/vim-easy-align'
 18 | Plug 'scrooloose/syntastic'
 19 | Plug 'nathanaelkane/vim-indent-guides'
 20 | Plug 'junegunn/seoul256.vim'
 21 | 
 22 | call plug#end()
 23 | 
 24 | filetype indent on "  파일 종류에 따른 구문강조
 25 | filetype plugin on
 26 | filetype plugin indent on
 27 | 
 28 | 
 29 | let mapleader = ","
 30 | 
 31 | 
 32 | " colorscheme office-dark
 33 | " let g:office_dark_CursorLineNr = 'off'
 34 | " let g:office_dark_LineNr = 'off'
 35 | 
 36 | " colorscheme forgotten-dark
 37 | " let g:forgotten_dark_LineNr = 'off'
 38 | " let g:forgotten_dark_LineNr = 'off'
 39 | 
 40 | 
 41 | " set background=dark
 42 | " set t_8f=^[[38;2;%lu;%lu;%lum
 43 | " set t_8b=^[[48;2;%lu;%lu;%lum
 44 | " colorscheme material-monokai
 45 | " let g:materialmonokai_subtle_spell=1
 46 | " let g:airline_theme='materialmonokai'
 47 | 
 48 | 
 49 | " colorscheme vrunchbang-dark
 50 | " let g:vrunchbang_dark_LineNr = 'off'
 51 | " let g:vrunchbang_light_LineNr = 'off'
 52 | 
 53 | 
 54 | " seoul256 (dark):
 55 | " "   Range:   233 (darkest) ~ 239 (lightest)
 56 | " "   Default: 237
 57 | let g:seoul256_background = 240
 58 | colo seoul256
 59 | 
 60 | 
 61 | set t_Co=256
 62 | 
 63 | " folding 관련
 64 | set foldmethod=syntax
 65 | set foldnestmax=100
 66 | set nofoldenable
 67 | set foldlevel=0
 68 | 
 69 | set number
 70 | set nolist " 
 71 | set textwidth=80
 72 | set ruler
 73 | set number
 74 | 
 75 | 
 76 | " indent 관련 옵션 
 77 | set autoindent  " 자동 들여쓰기
 78 | set cindent " C 프로그래밍용 자동 들여쓰기
 79 | set smartindent " 스마트한 들여쓰기
 80 | 
 81 | 
 82 | 
 83 | 
 84 | " 자동완성 관련 옵션
 85 | set showmatch " 매칭되는 괄호를 보여줌
 86 | set wmnu " tab 자동완성시 가능한 목록을 보여줌
 87 | 
 88 | " 파일/디렉토리명 자동완성 할 때 무시할 패턴
 89 | set wildignore=*.o,*.bak,.*.swap,*.pyc
 90 | set wildmenu " command-line 자동 완성 기능
 91 | 
 92 | " 화면 넘어가는 경우 한 라인을 여러줄로 표시
 93 | set wrap
 94 | set linebreak       " 라인을 끊을 때 단어 단위로 자릅니다.
 95 | set showbreak=+++\  " 윗 줄과 연결되는 줄은 '+++ ' 로 시작되어 알아볼 수 있게 합니다.
 96 | 
 97 | 
 98 | 
 99 | " Tab 관련 옵션
100 | set cindent
101 | set autoindent
102 | set softtabstop=4
103 | set expandtab " 탭대신 스페이스
104 | set ts=4 " Tab 너비
105 | set shiftwidth=4 " 자동 들여쓰기 4칸
106 | 
107 | 
108 | " 파일 인코딩 관련
109 | scriptencoding utf-8
110 | set encoding=utf-8
111 | 
112 | 
113 | " 검색 관련 옵션
114 | set nowrapscan " 
115 | set hlsearch " 검색어 강조, set hls 도 가능
116 | set ignorecase
117 | set smartcase " 대소문자 있으면 구분
118 | set incsearch " 키워드 입력시 점진적 검색
119 | 
120 | 
121 | set title " 제목을 표시
122 | set mouse=a
123 | set backspace=eol,start,indent "  줄의 끝, 시작, 들여쓰기에서 백스페이스시 이전줄로
124 | set history=1000 "  vi 편집기록 기억갯수 .viminfo에 기록
125 | 
126 | " 마지막으로 수정된 곳에 커서를 위치함
127 | " au BufReadPost *
128 | " \ if line("'\"") > 0 && line("'\"") <= line("$") |
129 | " \ exe "norm g`\"" |
130 | " \ endif
131 | 
132 | set statusline=\ %<%l:%v\ [%P]%=%a\ %h%m%r\ %F\
133 | 
134 | 
135 | " 구문 강조 사용
136 | if has("syntax")
137 |  syntax on
138 | endif
139 | 
140 | 
141 | " NERD Commenter
142 | " Add spaces after comment delimiters by default
143 | let g:NERDSpaceDelims = 1
144 | " Use compact syntax for prettified multi-line comments
145 | let g:NERDCompactSexyComs = 1
146 | " Align line-wise comment delimiters flush left instead of following code indentation
147 | let g:NERDDefaultAlign = 'left'
148 | " Set a language to use its alternate delimiters by default
149 | let g:NERDAltDelims_java = 1
150 | " Add your own custom formats or override the defaults
151 | let g:NERDCustomDelimiters = { 'c': { 'left': '/**','right': '*/' } }
152 | " Allow commenting and inverting empty lines (useful when commenting a region)
153 | let g:NERDCommentEmptyLines = 1
154 | " Enable trimming of trailing whitespace when uncommenting
155 | let g:NERDTrimTrailingWhitespace = 1
156 | " customize keymapping
157 | map <Leader>cc <plug>NERDComToggleComment
158 | map <Leader>c<space> <plug>NERDComComment
159 | 
160 | 
161 | " Syntastic
162 | set statusline+=%#warningmsg#
163 | set statusline+=%{SyntasticStatuslineFlag()}
164 | set statusline+=%*
165 | 
166 | let g:syntastic_always_populate_loc_list = 1
167 | let g:syntastic_auto_loc_list = 1
168 | let g:syntastic_check_on_wq = 0
169 | 
170 | let g:syntastic_cpp_compiler = 'g++'
171 | let g:syntastic_cpp_compiler_options = "-std=c++11 -Wall -Wextra -Wpedantic"
172 | nnoremap <silent> <C-d> :lclose<CR>:bdelete<CR>
173 | cabbrev <silent> bd <C-r>=(getcmdtype()==#':' && getcmdpos()==1 ? 'lclose\|bdelete' : 'bd')<CR>
174 | 
175 | let g:syntastic_mode_map = { 'mode': 'passive', 'active_filetypes': ['c', 'cpp', 'py'],'passive_filetypes': [] }
176 | noremap <C-w>e :SyntasticCheck<CR>
177 | noremap <C-w>f :SyntasticToggleMode<CR>
178 | 
179 | 
180 | " vim-cpp-enhanced-highlight 관련 세팅
181 | let g:cpp_class_scope_highlight = 1
182 | let g:cpp_class_decl_highlight = 1
183 | let g:cpp_member_variable_highlight = 1
184 | let c_no_curly_error=1
185 | 
186 | 
187 | " for vim-airline
188 | let g:airline#extensions#tabline#enabled = 1 " turn on buffer list
189 | let g:airline_theme='hybrid'
190 | set laststatus=2 " turn on bottom bar
191 | 
192 | " nerdtree
193 | autocmd StdinReadPre * let s:std_in=1
194 | autocmd VimEnter * if argc() == 0 && !exists("s:std_in") | NERDTree | endif
195 | let g:NERDTreeDirArrowExpandable = '▸'
196 | let g:NERDTreeDirArrowCollapsible = '▾'
197 | 
198 | 
199 | " ctrlp
200 | let g:ctrlp_custom_ignore = {
201 |   \ 'dir':  '\.git$\|public$\|log$\|tmp$\|vendor$',
202 |   \ 'file': '\v\.(exe|so|dll)$'
203 |   \ }
204 | 
205 | 
206 | " html5.vim configure
207 | " Disable event-handler attributes support:
208 | let g:html5_event_handler_attributes_complete = 0
209 | " Disable RDFa attributes support:
210 | let g:html5_rdfa_attributes_complete = 0
211 | " Disable microdata attributes support:
212 | let g:html5_microdata_attributes_complete = 0
213 | " Disable WAI-ARIA attribute support:
214 | let g:html5_aria_attributes_complete = 0
215 | 
216 | 
217 | " python syntax highlight
218 | let g:python_highlight_all = 1
219 | 
220 | 
221 | " Easy-align
222 | " Start interactive EasyAlign in visual mode (e.g. vipga)
223 | xmap ga <Plug>(EasyAlign)
224 | " Start interactive EasyAlign for a motion/text object (e.g. gaip)
225 | nmap ga <Plug>(EasyAlign)
226 | 
227 | 
228 | " vim-indent_guides
229 | let g:indent_guides_enable_on_vim_startup = 1
230 | let g:indent_guides_start_level = 2
231 | let g:indent_guides_guide_size = 1
232 | 
233 | 
234 | let g:indent_guides_auto_colors = 0
235 | autocmd VimEnter,Colorscheme * :hi IndentGuidesOdd  ctermbg=236
236 | autocmd VimEnter,Colorscheme * :hi IndentGuidesEven ctermbg=237
237 | 
238 | " if set background=dark
239 | " hi IndentGuidesOdd  ctermbg=black
240 | " hi IndentGuidesEven ctermbg=darkgrey
241 | 
242 | " if set background=light
243 | " hi IndentGuidesOdd  ctermbg=white
244 | " hi IndentGuidesEven ctermbg=lightgrey
245 | 
246 | 
247 | nnoremap <F2> :w
248 | map <F3> :NERDTreeToggle<cr>
249 | nnoremap <C-f> :NERDTreeFind<cr>
250 | 
251 | " buffer 관련 map
252 | noremap <silent> <C-left> :bprev<CR>
253 | noremap <silent> <C-h> :bprev<C<F2>R>
254 | noremap <silent> <C-right> :bnext<CR>
255 | noremap <silent> <C-l> :bnext<CR>
256 | 
257 | 
258 | nnoremap <C-h> <C-w>h
259 | nnoremap <C-l> <C-w>l
260 | nnoremap <C-j> <C-w>j
261 | nnoremap <C-k> <C-w>k
262 | 
263 | 


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