mirror of
https://github.com/junegunn/vim-plug.git
synced 2024-12-19 18:47:29 -07:00
e7704e6cb3
/cc @andreicristianpetcu plug#begin expands its path argument and converts it to the absolute path by default. However, it makes sense to use the unexpanded form in case of PlugSnapshot as described in https://github.com/junegunn/vim-plug/issues/97#issuecomment-57421483 For example, for the following cases, - call plug#begin('~/.vim/plugged') - call plug#begin('$HOME/.vim/plugged') PlugSnapshot will use the exact arguments, `~/.vim/plugged` or `$HOME/.vim/plugged`, instead of the absolute paths such as `/home/jg/.vim/plugged`.
1059 lines
29 KiB
Plaintext
1059 lines
29 KiB
Plaintext
Execute (Initialize test environment):
|
|
Save &rtp, g:plugs, g:plug_home, g:plug_window
|
|
|
|
let first_rtp = split(&rtp, ',')[0]
|
|
let last_rtp = split(&rtp, ',')[-1]
|
|
|
|
let vader = fnamemodify(globpath(&rtp, 'autoload/vader.vim'), ':h:h')
|
|
let plug = fnamemodify(globpath(&rtp, 'autoload/plug.vim'), ':h:h')
|
|
set rtp=$HOME/.vim,$VIM/vimfiles,$VIMRUNTIME,$VIM/vimfiles/after,$HOME/.vim/after
|
|
execute 'set rtp^='.vader
|
|
execute 'set rtp^='.plug
|
|
let basertp = &rtp
|
|
|
|
unlet! g:plugs g:plug_home g:plug_window
|
|
|
|
set t_Co=256
|
|
colo default
|
|
pclose
|
|
|
|
function! PlugStatusSorted()
|
|
PlugStatus
|
|
%y
|
|
q
|
|
normal! P
|
|
%sort
|
|
g/^$/d
|
|
endfunction
|
|
|
|
function! AssertExpect(bang, pat, cnt)
|
|
let op = a:bang ? '==#' : '=~#'
|
|
AssertEqual a:cnt, len(filter(getline(1, '$'), "v:val ".op." '".a:pat."'"))
|
|
endfunction
|
|
command! -nargs=+ -bang AssertExpect call AssertExpect('<bang>' == '!', <args>)
|
|
|
|
function! EnsureLoaded()
|
|
if has('vim_starting')
|
|
runtime! plugin/**/*.vim
|
|
endif
|
|
endfunction
|
|
|
|
Execute (Print Ruby version):
|
|
redir => out
|
|
silent ruby puts RUBY_VERSION
|
|
redir END
|
|
Log substitute(out, '\n', '', 'g')
|
|
|
|
Execute (plug#end() before plug#begin() should fail):
|
|
redir => out
|
|
AssertEqual 0, plug#end()
|
|
redir END
|
|
Assert stridx(out, 'Call plug#begin() first') >= 0
|
|
|
|
Execute (plug#begin() without path argument):
|
|
call plug#begin()
|
|
AssertEqual split(&rtp, ',')[0].'/plugged', g:plug_home
|
|
unlet g:plug_home
|
|
|
|
Execute (plug#begin() without path argument with empty &rtp):
|
|
let save_rtp = &rtp
|
|
set rtp=
|
|
redir => out
|
|
AssertEqual 0, plug#begin()
|
|
redir END
|
|
Assert stridx(out, 'Unable to determine plug home') >= 0
|
|
let &rtp = save_rtp
|
|
|
|
Execute (plug#begin(path)):
|
|
let temp_plugged = tempname()
|
|
call plug#begin(temp_plugged.'/')
|
|
Assert g:plug_home !~ '[/\\]$', 'Trailing / should be stripped from g:plug_home'
|
|
|
|
AssertEqual 0, len(g:plugs)
|
|
AssertEqual temp_plugged, g:plug_home
|
|
AssertEqual basertp, &rtp
|
|
|
|
Execute (Subsequent plug#begin() calls will reuse g:plug_home):
|
|
call plug#begin()
|
|
AssertEqual temp_plugged, g:plug_home
|
|
|
|
Execute (Test Plug command):
|
|
" Git repo with branch
|
|
Plug 'junegunn/seoul256.vim', 'yes-t_co'
|
|
AssertEqual 'https://git::@github.com/junegunn/seoul256.vim.git', g:plugs['seoul256.vim'].uri
|
|
AssertEqual join([temp_plugged, 'seoul256.vim/'], '/'), g:plugs['seoul256.vim'].dir
|
|
AssertEqual 'yes-t_co', g:plugs['seoul256.vim'].branch
|
|
|
|
Plug 'junegunn/seoul256.vim', { 'branch': 'no-t_co' } " Using branch option
|
|
AssertEqual 'no-t_co', g:plugs['seoul256.vim'].branch
|
|
|
|
" Git repo with tag
|
|
Plug 'junegunn/goyo.vim', '1.5.2'
|
|
AssertEqual 'https://git::@github.com/junegunn/goyo.vim.git', g:plugs['goyo.vim'].uri
|
|
AssertEqual join([temp_plugged, 'goyo.vim/'], '/'), g:plugs['goyo.vim'].dir
|
|
AssertEqual '1.5.2', g:plugs['goyo.vim'].branch
|
|
|
|
Plug 'junegunn/goyo.vim', { 'tag': '1.5.3' } " Using tag option
|
|
AssertEqual '1.5.3', g:plugs['goyo.vim'].branch
|
|
|
|
" Git URI
|
|
Plug 'https://bitbucket.org/junegunn/vim-emoji.git'
|
|
AssertEqual 'https://bitbucket.org/junegunn/vim-emoji.git', g:plugs['vim-emoji'].uri
|
|
AssertEqual 'master', g:plugs['vim-emoji'].branch
|
|
AssertEqual join([temp_plugged, 'vim-emoji/'], '/'), g:plugs['vim-emoji'].dir
|
|
|
|
" vim-scripts/
|
|
Plug 'beauty256'
|
|
AssertEqual 'https://git::@github.com/vim-scripts/beauty256.git', g:plugs.beauty256.uri
|
|
AssertEqual 'master', g:plugs.beauty256.branch
|
|
|
|
AssertEqual 4, len(g:plugs)
|
|
|
|
Execute (Plug command with dictionary option):
|
|
Log string(g:plugs)
|
|
Plug 'junegunn/seoul256.vim', { 'branch': 'no-t_co', 'rtp': '././' }
|
|
AssertEqual join([temp_plugged, 'seoul256.vim/'], '/'), g:plugs['seoul256.vim'].dir
|
|
AssertEqual '././', g:plugs['seoul256.vim'].rtp
|
|
|
|
Log string(g:plugs)
|
|
AssertEqual 4, len(g:plugs)
|
|
|
|
Execute (PlugStatus before installation):
|
|
PlugStatus
|
|
AssertExpect 'Not found', 4
|
|
q
|
|
|
|
Execute (PlugClean before installation):
|
|
PlugClean
|
|
AssertExpect 'Already clean', 1
|
|
q
|
|
|
|
Execute (plug#end() updates &rtp):
|
|
call plug#end()
|
|
Assert len(&rtp) > len(basertp)
|
|
AssertEqual first_rtp, split(&rtp, ',')[0]
|
|
AssertEqual last_rtp, split(&rtp, ',')[-1]
|
|
|
|
Execute (Yet, plugins are not available):
|
|
Assert empty(globpath(&rtp, 'autoload/emoji.vim'))
|
|
|
|
Execute (PlugInstall):
|
|
PlugInstall
|
|
q
|
|
|
|
Execute (Plugin available after installation):
|
|
Assert !empty(globpath(&rtp, 'autoload/emoji.vim'))
|
|
|
|
Execute (PlugClean after installation):
|
|
PlugClean
|
|
AssertExpect 'Already clean', 1
|
|
q
|
|
|
|
Execute (PlugStatus after installation):
|
|
PlugStatus
|
|
Log getline(1, '$')
|
|
AssertExpect 'OK', 4
|
|
q
|
|
|
|
Execute (Change tag of goyo.vim):
|
|
call plug#begin()
|
|
Plug 'junegunn/goyo.vim'
|
|
call plug#end()
|
|
|
|
Execute (PlugStatus):
|
|
call PlugStatusSorted()
|
|
|
|
Expect:
|
|
Invalid branch/tag: 1.5.3 (expected: master). Try PlugUpdate.
|
|
Finished. 1 error(s).
|
|
[=]
|
|
x goyo.vim:
|
|
|
|
Execute (PlugUpdate to set the right branch):
|
|
PlugUpdate
|
|
call PlugStatusSorted()
|
|
|
|
Expect:
|
|
- goyo.vim: OK
|
|
Finished. 0 error(s).
|
|
[=]
|
|
|
|
Execute (Change branch of seoul256.vim):
|
|
call plug#begin()
|
|
Plug 'junegunn/seoul256.vim'
|
|
Plug 'https://bitbucket.org/junegunn/vim-emoji.git'
|
|
call plug#end()
|
|
|
|
Execute (PlugStatus):
|
|
call PlugStatusSorted()
|
|
|
|
Expect:
|
|
Invalid branch/tag: no-t_co (expected: master). Try PlugUpdate.
|
|
- vim-emoji: OK
|
|
Finished. 1 error(s).
|
|
[==]
|
|
x seoul256.vim:
|
|
|
|
Execute (Change URI of seoul256.vim):
|
|
call plug#begin()
|
|
Plug 'junegunn.choi/seoul256.vim'
|
|
Plug 'https://bitbucket.org/junegunn/vim-emoji.git'
|
|
call plug#end()
|
|
|
|
Execute (PlugStatus):
|
|
call PlugStatusSorted()
|
|
|
|
Expect:
|
|
Expected: https://git::@github.com/junegunn.choi/seoul256.vim.git
|
|
Invalid URI: https://git::@github.com/junegunn/seoul256.vim.git
|
|
PlugClean required.
|
|
- vim-emoji: OK
|
|
Finished. 1 error(s).
|
|
[==]
|
|
x seoul256.vim:
|
|
|
|
# TODO: does not work due to inputsave()
|
|
# Do (PlugClean):
|
|
# :PlugClean\<Enter>y\<Enter>
|
|
# ggyG
|
|
# q
|
|
# PGdd
|
|
|
|
Execute (PlugClean! to remove seoul256.vim):
|
|
PlugClean!
|
|
" Three removed, emoji left
|
|
AssertExpect '^- ', 3
|
|
AssertExpect 'Removed', 1
|
|
Assert empty(globpath(&rtp, 'colors/seoul256.vim'))
|
|
Assert !empty(globpath(&rtp, 'autoload/emoji.vim'))
|
|
q
|
|
|
|
Execute (Change GIT URI of vim-emoji):
|
|
call plug#begin()
|
|
Plug 'junegunn/seoul256.vim'
|
|
Plug 'junegunn/vim-emoji'
|
|
call plug#end()
|
|
|
|
Execute (PlugStatus):
|
|
call PlugStatusSorted()
|
|
|
|
Expect:
|
|
Expected: https://git::@github.com/junegunn/vim-emoji.git
|
|
Invalid URI: https://bitbucket.org/junegunn/vim-emoji.git
|
|
Not found. Try PlugInstall.
|
|
PlugClean required.
|
|
Finished. 2 error(s).
|
|
[==]
|
|
x seoul256.vim:
|
|
x vim-emoji:
|
|
|
|
Execute (PlugClean! to remove vim-emoji):
|
|
PlugClean!
|
|
AssertExpect '^- ', 1
|
|
AssertExpect 'Removed', 1
|
|
Assert empty(globpath(&rtp, 'colors/seoul256.vim'))
|
|
Assert empty(globpath(&rtp, 'autoload/emoji.vim'))
|
|
q
|
|
|
|
Execute (PlugUpdate to install both again):
|
|
PlugUpdate
|
|
AssertExpect '^- [^:]*:', 2
|
|
Assert !empty(globpath(&rtp, 'colors/seoul256.vim')), 'seoul256.vim should be found'
|
|
Assert !empty(globpath(&rtp, 'autoload/emoji.vim')), 'vim-emoji should be found'
|
|
q
|
|
|
|
Execute (PlugUpdate only to find out plugins are up-to-date, D key to check):
|
|
PlugUpdate
|
|
AssertExpect 'Already up-to-date', 2
|
|
normal D
|
|
AssertEqual 'No updates.', getline(1)
|
|
q
|
|
|
|
Execute (PlugDiff - 'No updates.'):
|
|
PlugDiff
|
|
AssertEqual 'No updates.', getline(1)
|
|
q
|
|
|
|
Execute (Rollback recent updates, PlugUpdate, then PlugDiff):
|
|
for repo in ['seoul256.vim', 'vim-emoji']
|
|
call system(printf('cd %s/%s && git reset HEAD^^ --hard', g:plug_home, repo))
|
|
endfor
|
|
PlugUpdate
|
|
|
|
" Now we have updates
|
|
normal D
|
|
AssertEqual 'Last update:', getline(1)
|
|
|
|
" Preview commit
|
|
silent! wincmd P
|
|
AssertEqual 0, &previewwindow
|
|
|
|
" ]] motion
|
|
execute 'normal ]]'
|
|
let lnum = line('.')
|
|
AssertEqual 3, col('.')
|
|
|
|
" Open commit preview
|
|
execute "normal j\<cr>"
|
|
wincmd P
|
|
AssertEqual 1, &previewwindow
|
|
AssertEqual 'git', &filetype
|
|
|
|
" Back to plug window
|
|
wincmd p
|
|
|
|
" ]] motion
|
|
execute 'normal $]]'
|
|
AssertEqual lnum + 4, line('.')
|
|
AssertEqual 3, col('.')
|
|
|
|
" [[ motion
|
|
execute 'normal 0[['
|
|
AssertEqual lnum, line('.')
|
|
AssertEqual 3, col('.')
|
|
|
|
" X key to revert the update
|
|
AssertExpect '^- ', 2
|
|
execute "normal Xn\<cr>"
|
|
AssertExpect '^- ', 2
|
|
execute "normal Xy\<cr>"
|
|
AssertExpect '^- ', 1
|
|
|
|
" q will close preview window as well
|
|
normal q
|
|
|
|
" We no longer have preview window
|
|
silent! wincmd P
|
|
AssertEqual 0, &previewwindow
|
|
|
|
" q should not close preview window if it's already open
|
|
pedit
|
|
PlugDiff
|
|
AssertExpect '^- ', 1
|
|
execute "normal ]]j\<cr>"
|
|
normal q
|
|
|
|
silent! wincmd P
|
|
AssertEqual 1, &previewwindow
|
|
pclose
|
|
|
|
Execute (Plug window in a new tab):
|
|
PlugDiff
|
|
tab new new-tab
|
|
set buftype=nofile
|
|
PlugUpdate
|
|
normal D
|
|
AssertExpect '^- ', 1
|
|
normal q
|
|
AssertEqual 'new-tab', expand('%')
|
|
q
|
|
q
|
|
|
|
**********************************************************************
|
|
~ On-demand loading / Partial installation/update ~
|
|
**********************************************************************
|
|
|
|
Execute (Trying to execute on-demand commands when plugin is not installed):
|
|
call plug#begin()
|
|
Plug 'junegunn/vim-easy-align', { 'on': ['EasyAlign', 'LiveEasyAlign'] }
|
|
call plug#end()
|
|
|
|
Assert exists(':EasyAlign')
|
|
Assert exists(':LiveEasyAlign')
|
|
AssertThrows EasyAlign
|
|
AssertThrows LiveEasyAlign
|
|
Assert !exists(':EasyAlign')
|
|
Assert !exists(':LiveEasyAlign')
|
|
|
|
Execute (New set of plugins):
|
|
call plug#begin()
|
|
Plug 'junegunn/vim-fnr'
|
|
Plug 'junegunn/vim-pseudocl'
|
|
Plug 'junegunn/vim-easy-align', { 'on': 'EasyAlign' }
|
|
Plug 'junegunn/vim-redis', { 'for': 'redis' }
|
|
call plug#end()
|
|
|
|
Execute (Check commands):
|
|
Assert !exists(':FNR'), 'FNR command should not be found'
|
|
Assert !exists(':RedisExecute'), 'RedisExecute command should not be found'
|
|
|
|
Execute (Partial PlugInstall):
|
|
PlugInstall vim-fnr vim-easy-align
|
|
AssertExpect 'vim-fnr', 1
|
|
q
|
|
|
|
PlugInstall vim-fnr vim-easy-align 1
|
|
AssertExpect 'vim-fnr', 1
|
|
AssertExpect 'vim-easy-align', 1
|
|
AssertEqual first_rtp, split(&rtp, ',')[0]
|
|
AssertEqual last_rtp, split(&rtp, ',')[-1]
|
|
q
|
|
|
|
Given (Unaligned code):
|
|
a=1
|
|
aa=2
|
|
|
|
Execute (Check installed plugins):
|
|
call EnsureLoaded()
|
|
Assert exists(':FNR'), 'FNR command should be found'
|
|
Assert !exists(':RedisExecute'), 'RedisExecute command still should not be found'
|
|
|
|
Assert exists(':EasyAlign'), 'EasyAlign command should be found'
|
|
%EasyAlign=
|
|
|
|
Expect (Aligned code):
|
|
a = 1
|
|
aa = 2
|
|
|
|
Given:
|
|
Execute (Partial PlugUpdate):
|
|
PlugUpdate vim-redis
|
|
q
|
|
|
|
Execute (On-demand loading based on filetypes):
|
|
Assert !exists(':RedisExecute'), 'RedisExecute command still should not be found'
|
|
set ft=redis
|
|
Assert exists(':RedisExecute'), 'RedisExecute command is now found'
|
|
|
|
**********************************************************************
|
|
~ Local (unmanaged) plugins
|
|
**********************************************************************
|
|
|
|
Execute (Add unmanaged plugin):
|
|
let fzf = fnamemodify(g:vader_file, ':h') . '/fzf'
|
|
Log fzf
|
|
|
|
call plug#begin()
|
|
Plug fzf, { 'on': 'SomeCommand' }
|
|
call plug#end()
|
|
|
|
" Check uri field
|
|
Assert !has_key(g:plugs.fzf, 'uri'), 'Should not have uri field'
|
|
|
|
" Check dir field
|
|
AssertEqual fzf.'/', g:plugs.fzf.dir
|
|
|
|
" Trailing slashes and backslashes should be stripped
|
|
for suffix in ['///', '/\/\/']
|
|
call plug#begin()
|
|
Plug fzf.suffix, { 'on': 'SomeCommand' }
|
|
call plug#end()
|
|
|
|
" Check dir field
|
|
AssertEqual fzf.'/', g:plugs.fzf.dir
|
|
endfor
|
|
|
|
Execute (Plug block for following tests):
|
|
call plug#begin()
|
|
Plug 'junegunn/vim-easy-align'
|
|
Plug fzf, { 'on': 'SomeCommand' }
|
|
call plug#end()
|
|
" Remove plugins from previous tests
|
|
PlugClean!
|
|
|
|
Execute (PlugInstall will only install vim-easy-align):
|
|
PlugInstall
|
|
Log getline(1, '$')
|
|
AssertExpect 'fzf', 0
|
|
q
|
|
|
|
Execute (PlugUpdate will only update vim-easy-align):
|
|
PlugUpdate
|
|
Log getline(1, '$')
|
|
AssertExpect 'fzf', 0
|
|
q
|
|
|
|
Execute (PlugClean should not care about unmanaged plugins):
|
|
PlugClean
|
|
Log getline(1, '$')
|
|
AssertExpect 'fzf', 0
|
|
q
|
|
|
|
Execute (PlugStatus should point out that the plugin is missing):
|
|
PlugStatus
|
|
Log getline(1, '$')
|
|
AssertExpect 'x fzf', 1
|
|
AssertExpect 'Not found', 1
|
|
q
|
|
|
|
Execute (Deploy unmanaged plugin):
|
|
Assert !exists(':FZF'), ':FZF command should not exist'
|
|
call rename('fzf-staged', 'fzf')
|
|
|
|
Execute (PlugUpdate still should not care):
|
|
PlugUpdate
|
|
Log getline(1, '$')
|
|
AssertExpect 'fzf', 0
|
|
q
|
|
|
|
Execute (PlugStatus with no error):
|
|
PlugStatus
|
|
Log getline(1, '$')
|
|
AssertExpect 'x fzf', 0
|
|
AssertExpect 'Not found', 0
|
|
q
|
|
|
|
Execute (Check &rtp after SomeCommand):
|
|
Log &rtp
|
|
Assert &rtp !~ 'fzf'
|
|
silent! SomeCommand
|
|
Assert &rtp =~ 'fzf'
|
|
AssertEqual first_rtp, split(&rtp, ',')[0]
|
|
AssertEqual last_rtp, split(&rtp, ',')[-1]
|
|
|
|
Execute (Common parent):
|
|
call plug#begin()
|
|
Plug 'junegunn/vim-pseudocl'
|
|
Plug 'junegunn/vim-fnr'
|
|
Plug 'junegunn/vim-oblique'
|
|
call plug#end()
|
|
|
|
PlugInstall
|
|
Log getline(1, '$')
|
|
AssertExpect! '[===]', 1
|
|
q
|
|
|
|
**********************************************************************
|
|
~ Frozen plugins
|
|
**********************************************************************
|
|
|
|
Execute (Frozen plugin are not installed nor updated):
|
|
call plug#begin()
|
|
Plug 'junegunn/vim-easy-align', { 'frozen': 1 }
|
|
call plug#end()
|
|
|
|
redir => out
|
|
silent PlugInstall
|
|
redir END
|
|
Assert out =~ 'No plugin to install'
|
|
|
|
redir => out
|
|
silent PlugUpdate
|
|
redir END
|
|
Assert out =~ 'No plugin to update'
|
|
|
|
Execute (But you can still install it if the name is given as the argument):
|
|
PlugInstall vim-easy-align
|
|
Log getline(1, '$')
|
|
AssertEqual 1, len(filter(getline(1, '$'), 'v:val =~ "vim-easy-align"'))
|
|
q
|
|
|
|
PlugUpdate vim-easy-align
|
|
Log getline(1, '$')
|
|
AssertEqual 1, len(filter(getline(1, '$'), 'v:val =~ "vim-easy-align"'))
|
|
q
|
|
|
|
**********************************************************************
|
|
~ Retry
|
|
**********************************************************************
|
|
|
|
Execute (Retry failed tasks):
|
|
call plug#begin()
|
|
Plug 'junegunn/vim-easy-align'
|
|
Plug 'junegunn/aaaaaaaaaaaaaa'
|
|
call plug#end()
|
|
|
|
PlugInstall
|
|
Log getline(1, '$')
|
|
AssertExpect 'x aaa', 1
|
|
AssertExpect '- vim-easy-align', 1
|
|
normal R
|
|
Log getline(1, '$')
|
|
AssertExpect 'x aaa', 1
|
|
AssertExpect '- vim-easy-align', 0
|
|
AssertExpect! '[x]', 1
|
|
q
|
|
|
|
call plug#begin()
|
|
Plug 'junegunn/vim-easy-align'
|
|
Plug 'junegunn/aaaaaaaaaaaaaa'
|
|
Plug 'junegunn/bbbbbbbbbbbbbb'
|
|
Plug 'junegunn/cccccccccccccc'
|
|
call plug#end()
|
|
|
|
" Ruby installer
|
|
PlugUpdate
|
|
normal R
|
|
AssertExpect '- vim-easy-align', 0
|
|
AssertExpect! '[xxx]', 1
|
|
q
|
|
|
|
" Vim installer
|
|
PlugUpdate 1
|
|
normal R
|
|
AssertExpect '- vim-easy-align', 0
|
|
AssertExpect! '[xxx]', 1
|
|
q
|
|
|
|
**********************************************************************
|
|
~ Post-update hook (`do` option)
|
|
**********************************************************************
|
|
|
|
Execute (Cleanup):
|
|
call plug#begin()
|
|
call plug#end()
|
|
PlugClean!
|
|
|
|
Execute (On install):
|
|
call plug#begin()
|
|
Plug 'junegunn/vim-easy-align', { 'do': 'touch installed' }
|
|
Plug 'junegunn/vim-pseudocl'
|
|
call plug#end()
|
|
|
|
PlugInstall
|
|
q
|
|
|
|
Assert filereadable(g:plugs['vim-easy-align'].dir.'/installed'),
|
|
\ 'vim-easy-align/installed should exist'
|
|
Assert !filereadable(g:plugs['vim-pseudocl'].dir.'/installed'),
|
|
\ 'vim-pseudocl/installed should not exist'
|
|
|
|
Execute (On update):
|
|
call plug#begin()
|
|
Plug 'junegunn/vim-easy-align', { 'do': 'touch updated' }
|
|
Plug 'junegunn/vim-pseudocl', { 'do': 'touch updated' }
|
|
call plug#end()
|
|
|
|
" Reset for updates
|
|
call system('cd '.g:plugs['vim-pseudocl'].dir.' && git reset --hard HEAD^')
|
|
|
|
PlugUpdate
|
|
Log getline(1, '$')
|
|
q
|
|
|
|
Assert !filereadable(g:plugs['vim-easy-align'].dir.'/updated'),
|
|
\ 'vim-easy-align/updated should not exist'
|
|
Assert filereadable(g:plugs['vim-pseudocl'].dir.'/updated'),
|
|
\ 'vim-pseudocl/updated should exist'
|
|
|
|
Execute (When already installed):
|
|
call plug#begin()
|
|
Plug 'junegunn/vim-easy-align', { 'do': 'touch installed2' }
|
|
Plug 'junegunn/vim-pseudocl', { 'do': 'touch installed2' }
|
|
call plug#end()
|
|
|
|
PlugInstall
|
|
q
|
|
Assert !filereadable(g:plugs['vim-easy-align'].dir.'/installed2'),
|
|
\ 'vim-easy-align/installed2 should not exist'
|
|
Assert !filereadable(g:plugs['vim-pseudocl'].dir.'/installed2'),
|
|
\ 'vim-pseudocl/installed2 should not exist'
|
|
|
|
Execute (PlugInstall!):
|
|
PlugInstall!
|
|
q
|
|
Assert filereadable(g:plugs['vim-easy-align'].dir.'/installed2'),
|
|
\ 'vim-easy-align/installed2 should exist'
|
|
Assert filereadable(g:plugs['vim-pseudocl'].dir.'/installed2'),
|
|
\ 'vim-pseudocl/installed2 should exist'
|
|
|
|
Execute (When already updated):
|
|
call plug#begin()
|
|
Plug 'junegunn/vim-easy-align', { 'do': 'touch updated2' }
|
|
Plug 'junegunn/vim-pseudocl', { 'do': 'touch updated2' }
|
|
call plug#end()
|
|
|
|
PlugUpdate
|
|
q
|
|
Assert !filereadable(g:plugs['vim-easy-align'].dir.'/updated2'),
|
|
\ 'vim-easy-align/updated2 should not exist'
|
|
Assert !filereadable(g:plugs['vim-pseudocl'].dir.'/updated2'),
|
|
\ 'vim-pseudocl/updated2 should not exist'
|
|
|
|
Execute (PlugUpdate!):
|
|
PlugUpdate!
|
|
q
|
|
Assert filereadable(g:plugs['vim-easy-align'].dir.'/updated2'),
|
|
\ 'vim-easy-align/updated2 should exist'
|
|
Assert filereadable(g:plugs['vim-pseudocl'].dir.'/updated2'),
|
|
\ 'vim-pseudocl/updated2 should exist'
|
|
|
|
Execute (Using Funcref):
|
|
function! PlugUpdated(info)
|
|
call system('touch '. a:info.name . a:info.status . a:info.force . len(a:info))
|
|
endfunction
|
|
|
|
call plug#begin()
|
|
Plug 'junegunn/vim-easy-align', { 'do': function('PlugUpdated') }
|
|
Plug 'junegunn/vim-pseudocl', { 'do': function('PlugUpdated') }
|
|
call plug#end()
|
|
|
|
call system('cd '.g:plugs['vim-easy-align'].dir.' && git reset --hard HEAD^')
|
|
call system('rm -rf '.g:plugs['vim-pseudocl'].dir)
|
|
|
|
PlugUpdate
|
|
Log getline(1, '$')
|
|
q
|
|
Assert filereadable(g:plugs['vim-easy-align'].dir.'/vim-easy-alignupdated03'),
|
|
\ 'vim-easy-align/vim-easy-alignupdated03 should exist'
|
|
Assert filereadable(g:plugs['vim-pseudocl'].dir.'/vim-pseudoclinstalled03'),
|
|
\ 'vim-pseudocl/vim-pseudoclinstalled03 should exist'
|
|
|
|
call system('rm -rf '.g:plugs['vim-pseudocl'].dir)
|
|
PlugInstall!
|
|
q
|
|
Assert filereadable(g:plugs['vim-easy-align'].dir.'/vim-easy-alignunchanged13'),
|
|
\ 'vim-easy-align/vim-easy-alignunchanged13 should exist'
|
|
Assert filereadable(g:plugs['vim-pseudocl'].dir.'/vim-pseudoclinstalled13'),
|
|
\ 'vim-pseudocl/vim-pseudoclinstalled13 should exist'
|
|
|
|
call system('cd '.g:plugs['vim-easy-align'].dir.' && git reset --hard HEAD^')
|
|
PlugUpdate!
|
|
q
|
|
Assert filereadable(g:plugs['vim-easy-align'].dir.'/vim-easy-alignupdated13'),
|
|
\ 'vim-easy-align/vim-easy-alignupdated13 should exist'
|
|
Assert filereadable(g:plugs['vim-pseudocl'].dir.'/vim-pseudoclunchanged13'),
|
|
\ 'vim-pseudocl/vim-pseudoclunchanged13 should exist'
|
|
|
|
**********************************************************************
|
|
~ Overriding `dir`
|
|
**********************************************************************
|
|
|
|
Execute (Using custom dir):
|
|
Assert isdirectory(g:plugs['vim-easy-align'].dir)
|
|
|
|
call system('rm -rf '.$TMPDIR.'easy-align')
|
|
call plug#begin()
|
|
Plug 'junegunn/vim-easy-align', { 'dir': $TMPDIR.'easy-align' }
|
|
call plug#end()
|
|
AssertEqual $TMPDIR.'easy-align/', g:plugs['vim-easy-align'].dir
|
|
|
|
PlugClean!
|
|
Assert !isdirectory(g:plugs['vim-easy-align'].dir)
|
|
q
|
|
|
|
PlugInstall
|
|
q
|
|
Assert isdirectory(g:plugs['vim-easy-align'].dir)
|
|
|
|
**********************************************************************
|
|
~ On-demand loading load order
|
|
**********************************************************************
|
|
Before (Clear global vars):
|
|
let g:xxx = []
|
|
set rtp-=$PWD/temp/xxx/
|
|
set rtp-=$PWD/temp/xxx/after
|
|
|
|
Execute (Immediate loading):
|
|
call plug#begin()
|
|
Plug '$PWD/temp/xxx'
|
|
call plug#end()
|
|
|
|
" FIXME:
|
|
" Different result when Vader is run from commandline with `-c` option
|
|
Log g:xxx
|
|
if has('vim_starting')
|
|
AssertEqual ['xxx/ftdetect', 'xxx/after/ftdetect'], g:xxx
|
|
else
|
|
AssertEqual ['xxx/plugin', 'xxx/after/plugin', 'xxx/ftdetect', 'xxx/after/ftdetect'], g:xxx
|
|
endif
|
|
|
|
Execute (Command-based on-demand loading):
|
|
call plug#begin()
|
|
Plug '$PWD/temp/xxx', { 'on': 'XXX' }
|
|
call plug#end()
|
|
|
|
AssertEqual [], g:xxx
|
|
|
|
silent! XXX
|
|
AssertEqual ['xxx/ftdetect', 'xxx/after/ftdetect', 'xxx/plugin', 'xxx/after/plugin'], g:xxx
|
|
|
|
setf xxx
|
|
AssertEqual ['xxx/ftdetect', 'xxx/after/ftdetect', 'xxx/plugin', 'xxx/after/plugin', 'xxx/ftplugin', 'xxx/after/ftplugin', 'xxx/indent', 'xxx/after/indent', 'xxx/syntax', 'xxx/after/syntax'], g:xxx
|
|
|
|
Execute (Filetype-based on-demand loading):
|
|
call plug#begin()
|
|
Plug '$PWD/temp/xxx', { 'for': 'xxx' }
|
|
call plug#end()
|
|
|
|
AssertEqual ['xxx/ftdetect', 'xxx/after/ftdetect'], g:xxx
|
|
|
|
setf xxx
|
|
AssertEqual ['xxx/ftdetect', 'xxx/after/ftdetect', 'xxx/plugin', 'xxx/after/plugin', 'xxx/ftplugin', 'xxx/after/ftplugin', 'xxx/indent', 'xxx/after/indent', 'xxx/syntax', 'xxx/after/syntax'], g:xxx
|
|
|
|
Before:
|
|
|
|
**********************************************************************
|
|
~ plug#helptags()
|
|
**********************************************************************
|
|
|
|
Execute (plug#helptags):
|
|
silent! call delete(expand('$PWD/temp/xxx/doc/tags'))
|
|
Assert !filereadable(expand('$PWD/temp/xxx/doc/tags'))
|
|
AssertEqual 1, plug#helptags()
|
|
Assert filereadable(expand('$PWD/temp/xxx/doc/tags'))
|
|
|
|
**********************************************************************
|
|
~ Manual loading
|
|
**********************************************************************
|
|
|
|
Execute (plug#load - invalid arguments):
|
|
AssertEqual 0, plug#load()
|
|
AssertEqual 0, plug#load('non-existent-plugin')
|
|
AssertEqual 0, plug#load('non-existent-plugin', 'another-non-existent-plugin')
|
|
AssertEqual 1, plug#load('xxx')
|
|
AssertEqual 0, plug#load('xxx', 'non-existent-plugin')
|
|
AssertEqual 0, plug#load('non-existent-plugin', 'xxx')
|
|
|
|
Execute (on: []):
|
|
call plug#begin()
|
|
Plug 'junegunn/rust.vim', { 'on': [] }
|
|
call plug#end()
|
|
PlugInstall
|
|
q
|
|
|
|
Execute (PlugStatus reports (not loaded)):
|
|
PlugStatus
|
|
AssertExpect 'not loaded', 1
|
|
q
|
|
|
|
Execute (plug#load to load it):
|
|
tabnew test.rs
|
|
" Vader will switch tab to [Vader-workbench] after Log
|
|
" Log &filetype
|
|
AssertEqual 1, plug#load('rust.vim')
|
|
AssertEqual 'rust', &filetype
|
|
q
|
|
|
|
Execute (PlugStatus should not contain (not loaded)):
|
|
PlugStatus
|
|
AssertExpect 'not loaded', 0
|
|
q
|
|
|
|
Execute (Load plugin from PlugStatus screen with L key in normal mode):
|
|
call plug#begin()
|
|
Plug '$PWD/temp/yyy', { 'on': [] }
|
|
call plug#end()
|
|
|
|
PlugStatus
|
|
AssertExpect 'not loaded', 1
|
|
Assert !exists('g:yyy'), 'yyy not loaded'
|
|
/not loaded
|
|
normal L
|
|
AssertExpect 'not loaded', 0
|
|
Assert exists('g:yyy'), 'yyy loaded'
|
|
q
|
|
|
|
Execute (Load plugin from PlugStatus screen with L key in visual mode):
|
|
call plug#begin()
|
|
Plug '$PWD/temp/z1', { 'on': [] }
|
|
Plug '$PWD/temp/z2', { 'for': [] }
|
|
call plug#end()
|
|
|
|
PlugStatus
|
|
AssertExpect 'not loaded', 2
|
|
Assert !exists('g:z1'), 'z1 not loaded'
|
|
Assert !exists('g:z2'), 'z2 not loaded'
|
|
normal ggVGL
|
|
AssertExpect 'not loaded', 0
|
|
Assert exists('g:z1'), 'z1 loaded'
|
|
Assert exists('g:z2'), 'z2 loaded'
|
|
q
|
|
|
|
**********************************************************************
|
|
~ g:plug_window
|
|
**********************************************************************
|
|
Execute (Open plug window in a new tab):
|
|
" Without g:plug_window, plug window is open on the left split
|
|
let tabnr = tabpagenr()
|
|
PlugStatus
|
|
AssertEqual tabnr, tabpagenr()
|
|
AssertEqual 1, winnr()
|
|
|
|
" PlugStatus again inside the window should not change the view
|
|
normal S
|
|
AssertEqual tabnr, tabpagenr()
|
|
AssertEqual 1, winnr()
|
|
q
|
|
|
|
" Define g:plug_window so that plug window is open in a new tab
|
|
let g:plug_window = 'tabnew'
|
|
PlugStatus
|
|
AssertNotEqual tabnr, tabpagenr()
|
|
|
|
" PlugStatus again inside the window should not change the view
|
|
let tabnr = tabpagenr()
|
|
normal S
|
|
AssertEqual tabnr, tabpagenr()
|
|
q
|
|
unlet g:plug_window
|
|
|
|
**********************************************************************
|
|
~ g:plug_url_format
|
|
**********************************************************************
|
|
Execute (Using g:plug_url_format):
|
|
call plug#begin()
|
|
let g:plug_url_format = 'git@bitbucket.org:%s.git'
|
|
Plug 'junegunn/seoul256.vim'
|
|
let g:plug_url_format = 'git@bitsocket.org:%s.git'
|
|
Plug 'beauty256'
|
|
AssertEqual 'git@bitbucket.org:junegunn/seoul256.vim.git', g:plugs['seoul256.vim'].uri
|
|
AssertEqual 'git@bitsocket.org:vim-scripts/beauty256.git', g:plugs['beauty256'].uri
|
|
unlet g:plug_url_format
|
|
|
|
**********************************************************************
|
|
~ U
|
|
**********************************************************************
|
|
Execute (Plug block):
|
|
call plug#begin()
|
|
Plug 'junegunn/vim-easy-align'
|
|
Plug 'junegunn/vim-emoji'
|
|
call plug#end()
|
|
|
|
Execute (Update plugin with U key in normal mode):
|
|
PlugStatus
|
|
/emoji
|
|
normal U
|
|
Log getline(1, '$')
|
|
AssertExpect 'Updated', 1
|
|
AssertExpect 'vim-emoji', 1
|
|
AssertExpect 'vim-easy-align', 0
|
|
AssertExpect! '[=]', 1
|
|
|
|
" From PlugInstall screen
|
|
PlugInstall
|
|
/easy-align
|
|
normal U
|
|
AssertExpect 'Updated', 1
|
|
AssertExpect 'vim-emoji', 0
|
|
AssertExpect 'vim-easy-align', 1
|
|
AssertExpect! '[=]', 1
|
|
q
|
|
|
|
Execute (Update plugins with U key in visual mode):
|
|
silent! call system('rm -rf '.g:plugs['vim-easy-align'].dir)
|
|
|
|
PlugStatus
|
|
normal VGU
|
|
Log getline(1, '$')
|
|
AssertExpect 'Updated', 1
|
|
AssertExpect 'vim-emoji', 1
|
|
AssertExpect 'vim-easy-align', 1
|
|
AssertExpect! '[==]', 1
|
|
|
|
" From PlugUpdate screen
|
|
normal VGU
|
|
Log getline(1, '$')
|
|
AssertExpect 'Updated', 1
|
|
AssertExpect 'vim-emoji', 1
|
|
AssertExpect 'vim-easy-align', 1
|
|
AssertExpect! '[==]', 1
|
|
q
|
|
|
|
**********************************************************************
|
|
Execute (plug#begin should expand env vars):
|
|
AssertNotEqual '$HOME/.emacs/plugged', expand('$HOME/.emacs/plugged')
|
|
call plug#begin('$HOME/.emacs/plugged')
|
|
AssertEqual expand('$HOME/.emacs/plugged'), g:plug_home
|
|
|
|
**********************************************************************
|
|
Execute (Plug directory with comma):
|
|
call plug#begin(temp_plugged . '/p,l,u,g,g,e,d')
|
|
Plug 'junegunn/vim-emoji'
|
|
call plug#end()
|
|
Log &rtp
|
|
|
|
PlugInstall
|
|
q
|
|
let found = filter(split(globpath(&rtp, 'README.md'), '\n'), 'v:val =~ ","')
|
|
Log found
|
|
AssertEqual 1, len(found)
|
|
|
|
**********************************************************************
|
|
Execute (Strict load order):
|
|
let g:total_order = []
|
|
call plug#begin()
|
|
Plug '$PWD/temp/xxx'
|
|
Plug '$PWD/temp/yyy', { 'for': ['xxx'] }
|
|
call plug#end()
|
|
call EnsureLoaded()
|
|
setf xxx
|
|
Log 'Case 1: ' . &rtp
|
|
AssertEqual ['yyy/ftdetect', 'yyy/after/ftdetect', 'xxx/ftdetect', 'xxx/after/ftdetect'], g:total_order[0:3]
|
|
Assert index(g:total_order, 'xxx/plugin') < index(g:total_order, 'yyy/plugin')
|
|
Assert index(g:total_order, 'xxx/after/plugin') < index(g:total_order, 'yyy/after/plugin')
|
|
let len = len(split(&rtp, ','))
|
|
|
|
let g:total_order = []
|
|
call plug#begin()
|
|
Plug '$PWD/temp/xxx', { 'for': ['xxx'] }
|
|
Plug '$PWD/temp/yyy'
|
|
call plug#end()
|
|
call EnsureLoaded()
|
|
set rtp^=manually-prepended
|
|
set rtp+=manually-appended
|
|
setf xxx
|
|
Log 'Case 2: ' . &rtp
|
|
AssertEqual 'manually-prepended', split(&rtp, ',')[3]
|
|
AssertEqual 'manually-appended', split(&rtp, ',')[-4]
|
|
AssertEqual ['xxx/ftdetect', 'xxx/after/ftdetect', 'yyy/ftdetect', 'yyy/after/ftdetect'], g:total_order[0:3]
|
|
Assert index(g:total_order, 'yyy/plugin') < index(g:total_order, 'xxx/plugin')
|
|
Assert index(g:total_order, 'yyy/after/plugin') < index(g:total_order, 'xxx/after/plugin')
|
|
AssertEqual len + 2, len(split(&rtp, ','))
|
|
|
|
let g:total_order = []
|
|
call plug#begin()
|
|
Plug '$PWD/temp/xxx', { 'for': ['xxx'] }
|
|
Plug '$PWD/temp/yyy', { 'for': ['xxx'] }
|
|
call plug#end()
|
|
call EnsureLoaded()
|
|
setf xxx
|
|
Log 'Case 3: ' . &rtp
|
|
AssertEqual ['xxx/ftdetect', 'xxx/after/ftdetect', 'yyy/ftdetect', 'yyy/after/ftdetect'], g:total_order[0:3]
|
|
Assert index(g:total_order, 'xxx/plugin') < index(g:total_order, 'yyy/plugin')
|
|
Assert index(g:total_order, 'xxx/after/plugin') < index(g:total_order, 'yyy/after/plugin')
|
|
AssertEqual len + 2, len(split(&rtp, ','))
|
|
|
|
**********************************************************************
|
|
Execute (PlugClean should not try to remove unmanaged plugins inside g:plug_home):
|
|
call plug#begin('$PWD/temp')
|
|
Plug '$PWD/temp/xxx'
|
|
Plug '$PWD/temp/yyy'
|
|
call plug#end()
|
|
|
|
" Remove z1, z2
|
|
PlugClean!
|
|
AssertExpect '^- ', 2
|
|
AssertExpect 'Already clean', 0
|
|
|
|
PlugClean!
|
|
AssertExpect '^- ', 0
|
|
AssertExpect 'Already clean', 1
|
|
q
|
|
|
|
**********************************************************************
|
|
Execute (PlugSnapshot):
|
|
call plug#begin('$TMPDIR/plugged')
|
|
Plug 'junegunn/vim-emoji'
|
|
Plug 'junegunn/seoul256.vim'
|
|
call plug#end()
|
|
|
|
PlugInstall
|
|
PlugSnapshot
|
|
AssertEqual '#!/bin/bash', getline(1)
|
|
AssertEqual '# Generated by vim-plug', getline(2)
|
|
AssertEqual 'vim +PlugUpdate +qa', getline(5)
|
|
AssertEqual 'PLUG_HOME=$TMPDIR/plugged', getline(7)
|
|
AssertEqual 0, stridx(getline(9), 'cd $PLUG_HOME/seoul256.vim/ && git reset --hard')
|
|
AssertEqual 0, stridx(getline(10), 'cd $PLUG_HOME/vim-emoji/ && git reset --hard')
|
|
q
|
|
|
|
Execute (Cleanup):
|
|
silent! call system('rm -rf '.temp_plugged)
|
|
silent! call system('rm -rf '.temp_plugged)
|
|
silent! call rename('fzf', 'fzf-staged')
|
|
silent! unlet g:plugs
|
|
silent! unlet g:plug_home
|
|
silent! unlet g:plug_url_format
|
|
silent! unlet temp_plugged vader plug basertp save_rtp repo lnum fzf out tabnr found len
|
|
silent! delf PlugStatusSorted
|
|
silent! delf AssertExpect
|
|
silent! delf PlugUpdated
|
|
silent! delf EnsureLoaded
|
|
silent! delc AssertExpect
|
|
silent! unmap /
|
|
silent! unmap ?
|
|
|
|
Restore
|
|
|