Jak zapisać i przywrócić wiele różnych sesji w Vimie?

W zależności od zadania w Vimie mam kilka otwartych kart.

Jak mogę zapisać różne sesje do późniejszego wykorzystania?

Chcesz coś takiego

:mksession ~/mysession.vim

Następnie możesz pobrać ten plik vim i odzyskać starą sesję:

:source ~/mysession.vim

lub otwórz vim z opcją -S:

$ vim -S ~/mysession.vim

Możesz ustawić te opcje sesji w swoim vimrc. Szczególnie denerwujące są opcje, gdy zmieniłeś vimrc po zapisaniu sesji.

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

Zauważ, że: mksession nie zapisze zmian w żadnym utworzonym pliku. Popełniłem ten błąd zamykając vima po zapisaniu sesji, zakładając, że zacznę od tego. Ale kiedy następnym razem otworzyłem sesję, zmiany, które wprowadziłem do plików, zniknęły.

Jeśli używasz NERDTree jako eksploratora plików / dash, poleciłbym wtyczkę xolox / vim-session zamiast wbudowanej komendy: mksession. Z jakiegoś powodu: mksession nie przywraca buforów NERDTree. Twój przebieg może się różnić, ale pomyślałem, że podzielę się moim doświadczeniem.

Jeśli chcesz zautomatyzować proces bez korzystania z żadnych wtyczek, możesz skorzystać z funkcji Przejdź i wróć z Wiki Vim Tips .

Za każdym razem, gdy wyjdziesz z Vima, zapisze bieżącą sesję ~/.vim/sessionsi załaduje ją ponownie po otwarciu Vima. Opiera się również na twojej bieżącej ścieżce, więc jeśli otworzysz Vima z różnych katalogów, będziesz miał różne sesje, co jest bardzo przydatne podczas pracy nad różnymi projektami.

Po prostu edytuj ~/.vimrcplik i dodaj:

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()

Nawet dla początkujących ten skrypt jest dość łatwy do zrozumienia i dostosowania.

Uwaga: ten skrypt będzie działał poprawnie tylko w systemach Unix (MacOS / Linux), należy go dostosować do pracy w systemie Windows.

AKTUALIZACJA: Dodając sugestię 0xc0de , możesz zastąpić VimEnterwiersz tymi, jeśli chcesz, aby Vim ładował sesję tylko wtedy, gdy nie podano argumentów :

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

Istnieje bardzo przydatna wtyczka do tego zadania vim-startify, która obsługuje wiele innych rzeczy, takich jak ostatnio otwierane pliki itp. Ma również bardzo łatwy interfejs.

Używam go od kilku dni i do tej pory działa idealnie. Mam nadzieję, że to ci pomoże.

Ponieważ jest to dla mnie (i prawdopodobnie innych) pierwsze trafienie w Google dotyczące pracy z sesjami w Vimie, postanowiłem dodać trochę do odpowiedzi @ mathielo na temat tego, jak to zrobić automatycznie.

Podobał mi się jego kod, ale trochę brakowało dodania rozwiązania „tylko jeśli bez argumentów”. To jest moja zmodyfikowana wersja:

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

Istotną zmianą tutaj jest opcjonalne zastąpienie. Jeśli otworzysz Vima bez opcji, otworzy on każdą istniejącą sesję i zastąpi zmiany dokonane podczas wychodzenia. Jeśli Vim zostanie otwarty z opcjami, utworzy nową sesję tylko wtedy, gdy żadna nie istnieje, oznacza to, że możesz otwierać pojedyncze pliki w katalogu, który ma sesję bez nadpisywania. Następnie możesz otworzyć Vima bez opcji, aby zamiast tego uruchomić sesję. Jeśli sesja nie istnieje, tworzona jest nowa.

Jest taka cudowna sesja wywołania wtyczki vim-session . Jest bardzo potężny. Aby zainstalować:

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

Zamapowałem jego funkcjonalność w moim .vimrcpliku w następujący sposób:

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

Teraz w trybie normalnym po prostu wpisz, <leader>ssa zobaczysz takie polecenie

:SaveSession 

Teraz dodaj nazwę swojej sesji

 :SaveSession namesession

i to wszystko.

Kiedy zamkniesz Vima i otworzysz go ponownie, po prostu zrób to

 :OpenSession

i zobaczysz swoją sesję otwartą.

Istnieje wiele innych konfiguracji do dodania w .vimrcpliku, patrz przykłady w dokumentacji:

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

Jest dobry tutorial YouTube .

Osobiście po prostu owijam wtyczkę Obsesji Tima Pope'a, aby umożliwić zdefiniowanie sessiondiri unikanie wpisywania ścieżki:

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

Dzięki @mathielo Zgodnie z przykładem z @mathielo dodałem poniższy wiersz do .vimrc, aby zapisać aktywną sesję (jeśli istnieje):

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

Jeśli chcesz wstawić więcej linii, musisz użyć endif:

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

Musisz tylko zapisać nową sesję w vimie

:mks [Session filename]

i po rozpoczęciu z

$ vim -S [Session filename]

vim rozpocznie sesję i nie musisz się martwić, aby zapisać sesję za każdym razem, gdy zamkniesz vima.

Jeśli nie masz aktywnej sesji .vimrc nic nie zrobi. Jak wcześniej.

Właśnie tego szukałem! Jeszcze raz dziękuję @mathielo!

Jeśli planujesz mieć tylko 1 sesję dla projektu, po prostu zrób

:mks

który utworzy Session.vimplik w bieżącym katalogu, a następnie otworzy sesję (z tego samego katalogu):

vim -S

Jeśli zmienisz sesję i chcesz ją zapisać:

:mks!

To oszczędza sesję, a nie same pliki!

Jeśli planujesz mieć wiele sesji , wolę zapisać je w ukrytych plikach w katalogu projektu:

:mks .session-name.vim

Aby go otworzyć (z tego samego katalogu):

vim -S .session-name.vim

Zapisz sesję:

:mks! .session-name.vim

Ponieważ sesje są zapisywane w ukrytych plikach, aby je wyświetlić, nie zapomnij -a

ls -a

Możesz przechowywać sesję w dowolnym miejscu.

Dawny:

:mksession! D:/session.ses

Spowoduje to zapisanie sesji na dysku D.

Można to otworzyć, pisząc

:so D:/session.ses

w dowolnym pliku vim.

Poniżej znajduje się jedyny conf. to naprawdę dla mnie zadziałało. Wziąłem go stąd , gdzie możesz również wziąć bardziej kompletną / złożoną wersję.

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

Aby zarządzać wieloma sesjami (na podstawie katalogu / repo), niedawno przełączyłem się z wtyczki vim-session na vim-workspace . Zarządzanie sesjami jest stosunkowo proste i działa całkiem dobrze.