Comment enregistrer et restaurer plusieurs sessions différentes dans Vim?

Selon ma tâche dans Vim, plusieurs onglets sont ouverts.

Comment puis-je enregistrer différentes sessions pour une utilisation ultérieure?

Tu veux quelque chose comme

:mksession ~/mysession.vim

Ensuite, vous pourrez récupérer ce fichier vim et vous récupérerez votre ancienne session:

:source ~/mysession.vim

ou ouvrez vim avec l'option -S:

$ vim -S ~/mysession.vim

Vous voudrez peut-être définir ces options de session dans votre vimrc. Les options sont particulièrement ennuyeuses lorsque vous avez modifié votre vimrc après avoir enregistré la session.

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

Notez que: mksession n'enregistrera pas les modifications apportées aux fichiers que vous avez créés. J'ai fait cette erreur de fermer vim après avoir sauvegardé la session en supposant que je reprendrai à partir de là. Mais la prochaine fois que j'ai ouvert la session, les modifications que j'avais apportées aux fichiers avaient disparu.

Si vous utilisez NERDTree comme explorateur de fichiers / dash, je recommanderais le plugin xolox / vim-session au lieu de la commande intégrée: mksession. Pour une raison quelconque,: mksession ne parvient pas à restaurer les tampons NERDTree. Votre kilométrage peut varier, mais j'ai pensé partager mon expérience.

Si vous souhaitez automatiser le processus sans utiliser de plugins, vous pouvez utiliser Go away et revenir du wiki Vim Tips .

Chaque fois que vous quittez Vim, il enregistre la session en cours ~/.vim/sessionset la charge à nouveau une fois Vim ouvert. Il est également basé sur votre chemin actuel, donc si vous ouvrez Vim à partir de différents répertoires, vous aurez différentes sessions, ce qui est très utile lorsque vous travaillez sur différents projets.

Modifiez simplement votre ~/.vimrcfichier et ajoutez ce qui suit:

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

Même pour un débutant, ce script est quelque peu facile à comprendre et à personnaliser.

Veuillez noter que ce script ne fonctionnera correctement que pour les systèmes Unix (MacOS / Linux), il doit être adapté pour fonctionner sous Windows.

MISE À JOUR: En ajoutant la suggestion de 0xc0de , vous pouvez remplacer la VimEnterligne pour celles-ci si vous voulez que Vim charge la session uniquement si aucun argument n'est fourni :

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

Il existe un plugin très utile pour cette tâche vim-startify qui gère beaucoup d'autres choses comme les fichiers récemment ouverts, etc., il a également une interface très simple.

Je l'utilise depuis quelques jours et jusqu'à présent, il fonctionne parfaitement. J'espère que cela vous aide.

Comme c'est le premier hit sur Google pour moi (et probablement d'autres) pour savoir comment travailler avec des sessions dans Vim, j'ai décidé d'ajouter un peu à la réponse de @ mathielo sur la façon de rendre cela automatique.

J'aime son code, mais l'ajout de la solution "seulement si sans arguments" semblait un peu manquer. Ceci est ma version modifiée:

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

Le changement notable ici est le remplacement facultatif. Si vous ouvrez Vim sans options, il ouvrira toute session existante et écrasera les modifications apportées lorsque vous quitterez. Si Vim est ouvert avec des options, il ne créera une nouvelle session que s'il n'en existe pas, cela signifie que vous pouvez ouvrir des fichiers uniques dans un répertoire qui a une session sans l'écraser. Ensuite, vous pouvez ouvrir Vim sans options pour exécuter la session à la place. S'il n'existe pas de session, il en crée une nouvelle.

Il y a ce merveilleux plugin appelé vim-session . C'est très puissant. Pour l'installer:

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

J'ai mappé sa fonctionnalité dans mon .vimrcfichier comme ceci:

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

Maintenant, en mode normal, tapez simplement <leader>sset vous verrez une commande comme celle-ci

:SaveSession 

Ajoutez maintenant le nom de votre session

 :SaveSession namesession

et c'est tout.

Lorsque vous fermez Vim et que vous le rouvrez, faites-le

 :OpenSession

et vous verrez votre session ouverte.

Il y a beaucoup d'autres configurations à ajouter dans votre .vimrcfichier voir la documentation pour des exemples:

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

Il y a un bon tutoriel sur YouTube.

Personnellement, je passe simplement le plugin Obsession de Tim Pope pour permettre de définir un sessiondiret éviter de taper le chemin:

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

Merci @mathielo Exemple suivant de @mathielo, j'ai ajouté la ligne ci-dessous à .vimrc pour enregistrer la session active (le cas échéant):

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

Si vous voulez mettre plus de lignes, vous devez utiliser endif:

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

Il vous suffit de sauvegarder une nouvelle session dans vim avec

:mks [Session filename]

et après avoir commencé

$ vim -S [Session filename]

vim démarrera la session et vous n'avez pas à vous soucier d'enregistrer la session à chaque fois que vous fermez vim.

Si vous n'avez pas de session active .vimrc ne fera rien. Comme avant.

Voilà ce que je cherchais! Merci encore @mathielo!

Si vous prévoyez de n'avoir qu'une seule session pour le projet, faites-le

:mks

qui va créer un Session.vimfichier dans le répertoire courant, puis pour ouvrir la session (à partir du même répertoire):

vim -S

Si vous modifiez la session et souhaitez l'enregistrer:

:mks!

Cela enregistre la session, pas les fichiers eux-mêmes!

Si vous prévoyez d'avoir plusieurs sessions , je préfère les enregistrer dans des fichiers cachés dans le répertoire du projet:

:mks .session-name.vim

Pour l'ouvrir (à partir du même répertoire):

vim -S .session-name.vim

Sauvegarder la session:

:mks! .session-name.vim

Puisque les sessions sont enregistrées dans des fichiers cachés, pour les visualiser n'oubliez pas -a

ls -a

Vous pouvez stocker la session où vous le souhaitez.

Ex:

:mksession! D:/session.ses

Cela stocke la session dans le lecteur D.

Cela peut être ouvert en tapant

:so D:/session.ses

dans l'un des fichiers vim.

Ci-dessous est la seule conf. cela a vraiment fonctionné pour moi. Je l'ai pris d' ici , où vous pouvez également prendre une version plus complète / complexe.

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

Pour gérer plusieurs sessions (par répertoire / référentiel), je suis récemment passé du plugin vim-session à vim-workspace . Sa gestion de session est relativement simple et fonctionne plutôt bien.