Como salvar e restaurar várias sessões diferentes no Vim?

Dependendo da minha tarefa no Vim, tenho várias guias abertas.

Como posso salvar sessões diferentes para uso posterior?

Você quer algo como

:mksession ~/mysession.vim

Depois, você poderá obter esse arquivo vim e voltará a sua sessão antiga:

:source ~/mysession.vim

ou abra o vim com a opção -S:

$ vim -S ~/mysession.vim

Você pode querer definir essas opções de sessão no seu vimrc. Especialmente opções é irritante quando você altera seu vimrc depois de salvar a sessão.

set ssop-=options    " do not store global and local values in a session
set ssop-=folds      " do not store folds

Observe que: mksession não salvará as alterações nos arquivos que você fez. Cometi o erro de fechar o vim depois de salvar a sessão, assumindo que vou retomar a partir daí. Mas da próxima vez que abri a sessão, as alterações feitas nos arquivos haviam desaparecido.

Se você usar o NERDTree como seu explorador de arquivos / traço, eu recomendaria o plug-in xolox / vim-session em vez do comando built-in: mksession. Por alguma razão,: mksession falha ao restaurar os buffers NERDTree. Sua milhagem pode variar, mas pensei em compartilhar minha experiência.

Se você deseja automatizar o processo sem usar nenhum plug-in, use Go away e volte do Vim Tips Wiki .

Cada vez que você sai do Vim, ele salva a sessão atual ~/.vim/sessionse a carrega novamente quando o Vim é aberto. Também é baseado no seu caminho atual; portanto, se você abrir o Vim a partir de diretórios diferentes, terá sessões diferentes, o que é bastante útil ao trabalhar em projetos diferentes.

Apenas edite seu ~/.vimrcarquivo e adicione o seguinte:

function! MakeSession()
  let b:sessiondir = $HOME . "/.vim/sessions" . getcwd()
  if (filewritable(b:sessiondir) != 2)
    exe 'silent !mkdir -p ' b:sessiondir
    redraw!
  endif
  let b:filename = b:sessiondir . '/session.vim'
  exe "mksession! " . b:filename
endfunction

function! LoadSession()
  let b:sessiondir = $HOME . "/.vim/sessions" . getcwd()
  let b:sessionfile = b:sessiondir . "/session.vim"
  if (filereadable(b:sessionfile))
    exe 'source ' b:sessionfile
  else
    echo "No session loaded."
  endif
endfunction

" Adding automatons for when entering or leaving Vim
au VimEnter * nested :call LoadSession()
au VimLeave * :call MakeSession()

Mesmo para iniciantes, esse script é um pouco fácil de entender e personalizar.

Observe que este script só funcionará corretamente para sistemas Unix (MacOS / Linux), ele precisa ser adaptado para funcionar no Windows.

ATUALIZAÇÃO: Adicionando a sugestão de 0xc0de , você pode substituir a VimEnterlinha por essas se desejar que o Vim carregue a sessão apenas se nenhum argumento for fornecido :

if(argc() == 0)
  au VimEnter * nested :call LoadSession()
endif

Existe um plugin muito útil para esta tarefa, o vim-startify, que lida com muitas outras coisas, como arquivos abertos recentemente, etc; também possui uma interface muito fácil.

Estou usando-o desde alguns dias e até agora está funcionando perfeitamente. Espero que ajude você.

Como esse é o primeiro hit do Google para mim (e provavelmente para outros) sobre como trabalhar com sessões no Vim, decidi adicionar um pouco à resposta do @ mathielo sobre como tornar isso automático.

Eu gosto do código dele, mas a adição da solução "only if without args" parecia um pouco ausente. Esta é a minha versão modificada:

function! MakeSession(overwrite)
  let b:sessiondir = $HOME . "/.vim/sessions" . getcwd()
  if (filewritable(b:sessiondir) != 2)
    exe 'silent !mkdir -p ' b:sessiondir
    redraw!
  endif
  let b:filename = b:sessiondir . '/session.vim'
  if a:overwrite == 0 && !empty(glob(b:filename))
    return
  endif
  exe "mksession! " . b:filename
endfunction

function! LoadSession()
  let b:sessiondir = $HOME . "/.vim/sessions" . getcwd()
  let b:sessionfile = b:sessiondir . "/session.vim"
  if (filereadable(b:sessionfile))
    exe 'source ' b:sessionfile
  else
    echo "No session loaded."
  endif
endfunction

" Adding automatons for when entering or leaving Vim
if(argc() == 0)
  au VimEnter * nested :call LoadSession()
  au VimLeave * :call MakeSession(1)
else
  au VimLeave * :call MakeSession(0)
endif

A mudança notável aqui é a substituição opcional. Se você abrir o Vim sem opções, ele abrirá qualquer sessão existente e substituirá as alterações feitas quando você sair. Se o Vim for aberto com opções, ele criará apenas uma nova sessão se não existir nenhuma, isso significa que você pode abrir arquivos únicos em um diretório que possui uma sessão sem substituí-lo. Em seguida, você pode abrir o Vim sem opções para executar a sessão. Se não houver uma sessão, ela criará uma nova.

Existe este maravilhoso plugin chamado vim-session . É muito poderoso. Para instalá-lo:

cd ~/.vim/bundle
git clone https://github.com/xolox/vim-session.git

Mapeei sua funcionalidade no meu .vimrcarquivo assim:

nnoremap <leader>so :OpenSession 
nnoremap <leader>ss :SaveSession 
nnoremap <leader>sd :DeleteSession<CR>
nnoremap <leader>sc :CloseSession<CR>

Agora, no modo normal, basta digitar <leader>sse você verá um comando como este

:SaveSession 

Agora adicione o nome da sua sessão

 :SaveSession namesession

e isso é tudo.

Quando você fecha o Vim e reabre, basta

 :OpenSession

e você verá sua sessão aberta.

Há muitas outras configurações para adicionar ao seu .vimrcarquivo. Consulte a documentação para obter exemplos:

let g:session_directory = "~/.vim/tmp/session"  // the directory must be created before the sessions will be saved there
let g:session_autoload = "no"                   // automatic reload sessions
let g:session_autosave = "no"                   // autosave
let g:session_command_aliases = 1

Há um bom tutorial no YouTube.

Pessoalmente, apenas envolvo o plug-in Obsession de Tim Pope para permitir a definição de um sessiondire evitar digitar o caminho:

let g:sessiondir = $HOME . ".vim/sessions"

command! -nargs=1 MkSession call MkSession(<f-args>)
function! MkSession(sessionfile)
  if !isdirectory(g:sessiondir)
    call mkdir(g:sessiondir, "p")
  endif
  exe 'Obsession' g:sessiondir . '/' . a:sessionfile
endfunction

command! -nargs=1 LoadSession call LoadSession(<f-args>)
function! LoadSession(sessionfile)

  let a:sessionpath = g:sessiondir . a:sessionfile
  if (filereadable(a:sessionpath))
    exe 'source ' a:sessionpath
  else
    echo "No session loaded."
  endif
endfunction

Thanks @mathielo Seguindo o exemplo de @mathielo, adicionei a linha abaixo ao .vimrc para salvar a sessão ativa (se houver):

au VimLeave * if this_session != "" | exe "mksession! ".this_session

Se você quiser colocar mais linhas, precisará usar endif:

au VimLeave * if v:this_session != ""
au VimLeave *   exe "mksession! ".this_session
au VimLeave * endif

Você só precisa salvar uma nova sessão no vim com

:mks [Session filename]

e depois de começar com

$ vim -S [Session filename]

O vim iniciará a sessão e você não precisa se preocupar em salvá-la toda vez que fechar o vim.

Se você não tiver uma sessão ativa, o .vimrc não fará nada. Como antes.

Era isso que eu estava procurando! Mais uma vez obrigado @mathielo!

Se você planeja ter apenas 1 sessão para o projeto, basta

:mks

que criará um Session.vimarquivo no diretório atual e abrirá a sessão (do mesmo diretório):

vim -S

Se você alterar a sessão e quiser salvá-la:

:mks!

Isso salva a sessão, não os arquivos em si!

Se você planeja ter várias sessões , prefiro salvá-las em arquivos ocultos no diretório do projeto:

:mks .session-name.vim

Para abri-lo (do mesmo diretório):

vim -S .session-name.vim

Salvar sessão:

:mks! .session-name.vim

Como as sessões são salvas em arquivos ocultos, para visualizá-las, não se esqueça -a

ls -a

Você pode armazenar a sessão onde quiser.

Ex:

:mksession! D:/session.ses

Isso armazena a sessão na unidade D.

Isso pode ser aberto digitando-se

:so D:/session.ses

em qualquer um dos arquivos vim.

Abaixo está o único conf. isso realmente funcionou para mim. Peguei a partir daqui , onde você também pode ter uma versão mais completa / complexa.

set viewoptions+=cursor,folds,slash,unix
set viewoptions-=options

augroup vimrc
    autocmd BufWritePost *
    \   if expand('%') != '' && &buftype !~ 'nofile'
    \|      mkview
    \|  endif
    autocmd BufRead *
    \   if expand('%') != '' && &buftype !~ 'nofile'
    \|      silent loadview
    \|  endif
augroup END

Para gerenciar várias sessões (por diretório / repositório), recentemente mudei do plug-in vim-session para o vim-workspace . Seu gerenciamento de sessões é relativamente simples e funciona muito bem.