Come salvare e ripristinare più sessioni diverse in Vim?

A seconda del mio compito in Vim ho diverse schede aperte.

Come posso salvare sessioni diverse per un uso successivo?

Vuoi qualcosa di simile

:mksession ~/mysession.vim

Quindi in seguito puoi procurarti quel file vim e riavere la tua vecchia sessione:

:source ~/mysession.vim

o apri vim con l'opzione -S:

$ vim -S ~/mysession.vim

Potresti voler impostare queste opzioni di sessione nel tuo vimrc. Soprattutto le opzioni sono fastidiose quando hai cambiato il tuo vimrc dopo aver salvato la sessione.

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

Nota che: mksession non salverà le modifiche ai file che hai apportato. Ho fatto questo errore di chiusura di VIM dopo aver salvato la sessione supponendo che riprenderò da lì. Ma la prossima volta che ho aperto la sessione, le modifiche apportate ai file erano sparite.

Se usi NERDTree come esploratore / trattino di file, consiglierei il plugin xolox / vim-session invece del comando incorporato: mksession. Per qualche motivo: mksession non riesce a ripristinare i buffer NERDTree. Il tuo chilometraggio può variare, ma ho pensato di condividere la mia esperienza.

Se si desidera automatizzare il processo senza utilizzare alcun plug-in, è possibile utilizzare Vai via e tornare da Vim Tips Wiki .

Ogni volta che esci da Vim, salverà la sessione corrente ~/.vim/sessionse la ricaricherà nuovamente una volta aperta Vim. Si basa anche sul tuo percorso attuale, quindi se apri Vim da directory diverse avrai sessioni diverse, il che è abbastanza utile quando lavori su progetti diversi.

Basta modificare il ~/.vimrcfile e aggiungere quanto segue:

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

Anche per un principiante questo script è in qualche modo facile da capire e personalizzare.

Nota che questo script funziona correttamente solo per i sistemi Unix (MacOS / Linux), deve essere adattato per funzionare su Windows.

AGGIORNAMENTO: Aggiungendo il suggerimento di 0xc0de , è possibile sostituire la VimEnterriga per questi se si desidera che Vim carichi la sessione solo se non vengono forniti argomenti :

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

Esiste un plugin molto utile per questo compito vim-startify che gestisce molte altre cose come file aperti di recente ecc., Ha anche un'interfaccia molto semplice.

Lo sto usando da un paio di giorni e fino ad ora funziona perfettamente. Spero che ti aiuti.

Dato che questo è il primo successo su Google per me (e probabilmente altri) su come lavorare con le sessioni in Vim, ho deciso di aggiungere un po 'alla risposta di @mathielo su come renderlo automatico.

Mi piace il suo codice, ma l'aggiunta della soluzione "solo se senza args" sembra essere un po 'carente. Questa è la mia versione modificata:

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

La notevole modifica qui è l'override opzionale. Se apri Vim senza opzioni, si aprirà qualsiasi sessione esistente e sovrascriverà le modifiche apportate alla tua partenza. Se Vim è aperto con opzioni, verrà creata una nuova sessione solo se non esiste, ciò significa che è possibile aprire singoli file in una directory che ha una sessione senza sovrascriverla. Quindi puoi aprire Vim senza opzioni per eseguire invece la sessione. Se non esiste una sessione, ne crea una nuova.

C'è questo meraviglioso plugin chiamato vim-session . È molto potente. Per installarlo:

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

Ho mappato la sua funzionalità nel mio .vimrcfile in questo modo:

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

Ora in modalità normale basta digitare <leader>sse vedrai un comando come questo

:SaveSession 

Ora aggiungi il nome della tua sessione

 :SaveSession namesession

e questo è tutto.

Quando chiudi Vim e la riapri, fallo

 :OpenSession

e vedrai la tua sessione aperta.

C'è molta altra configurazione da aggiungere nel tuo .vimrcfile, vedi la documentazione per esempi:

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

C'è un buon tutorial su YouTube.

Personalmente ho appena finito il plugin Obsession di Tim Pope per consentire la definizione di a sessiondired evitare di digitare il percorso:

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

Grazie @mathielo Seguendo l'esempio di @mathielo, ho aggiunto la riga seguente a .vimrc per salvare la sessione attiva (se presente):

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

Se vuoi mettere più righe, devi usare endif:

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

Hai solo bisogno di salvare una nuova sessione in VIM con

:mks [Session filename]

e dopo iniziare con

$ vim -S [Session filename]

vim avvierà la sessione e non dovrai preoccuparti di salvare la sessione ogni volta che chiudi vim.

Se non hai una sessione attiva .vimrc non farà nulla. Come prima.

Questo è quello che stavo cercando! Grazie ancora @mathielo!

Se prevedi di avere solo 1 sessione per il progetto, fallo

:mks

che creerà un Session.vimfile nella directory corrente e quindi per aprire la sessione (dalla stessa directory):

vim -S

Se si modifica la sessione e si desidera salvarla:

:mks!

Questo salva la sessione, non i file stessi!

Se prevedi di avere più sessioni , preferisco salvarle in file nascosti nella directory del progetto:

:mks .session-name.vim

Per aprirlo (dalla stessa directory):

vim -S .session-name.vim

Salva sessione:

:mks! .session-name.vim

Poiché le sessioni vengono salvate in file nascosti, per visualizzarli non dimenticare -a

ls -a

Puoi memorizzare la sessione dove vuoi.

Ex:

:mksession! D:/session.ses

Ciò memorizza la sessione nell'unità D.

Questo può essere aperto digitando

:so D:/session.ses

in uno qualsiasi dei file vim.

Di seguito è l'unico conf. ha funzionato davvero per me. L'ho preso da qui , dove puoi anche prendere una versione più completa / complessa.

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

Per la gestione di più sessioni (su una base per directory / repository), di recente sono passato dal plug-in vim-session a vim-workspace . La gestione della sessione è relativamente semplice e funziona abbastanza bene.