¿Cómo guardar y restaurar múltiples sesiones diferentes en Vim?

Dependiendo de mi tarea en Vim, tengo varias pestañas abiertas.

¿Cómo puedo guardar diferentes sesiones para su uso posterior?

Quieres algo como

:mksession ~/mysession.vim

Luego, puede obtener ese archivo vim y recuperará su sesión anterior:

:source ~/mysession.vim

o abra vim con la opción -S:

$ vim -S ~/mysession.vim

Es posible que desee establecer estas opciones de sesión en su vimrc. Especialmente las opciones son molestas cuando ha cambiado su vimrc después de haber guardado la sesión.

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

Tenga en cuenta que: mksession no guardará los cambios en los archivos que haya realizado. Cometí este error de cerrar vim después de guardar la sesión, suponiendo que comenzaré desde allí. Pero la próxima vez que abrí la sesión, los cambios que había realizado en los archivos habían desaparecido.

Si usa NERDTree como explorador / tablero de archivos, recomendaría el complemento xolox / vim-session en lugar del comando incorporado: mksession. Por alguna razón: mksession no puede restaurar los búferes NERDTree. Su millaje puede variar, pero pensé que compartiría mi experiencia.

Si desea automatizar el proceso sin usar ningún complemento, puede usar Go away y volver desde Vim Tips Wiki .

Cada vez que salga de Vim, guardará la sesión actual ~/.vim/sessionsy la volverá a cargar una vez que se abra Vim. También se basa en su ruta actual, por lo que si abre Vim desde diferentes directorios tendrá diferentes sesiones, lo que es bastante útil cuando trabaja en diferentes proyectos.

Simplemente edite su ~/.vimrcarchivo y agregue lo siguiente:

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

Incluso para un principiante, este script es algo fácil de entender y personalizar.

Tenga en cuenta que este script solo funcionará correctamente para sistemas Unix (MacOS / Linux), debe adaptarse para funcionar en Windows.

ACTUALIZACIÓN: agregando la sugerencia de 0xc0de , puede reemplazar la VimEnterlínea de estos si desea que Vim cargue la sesión solo si no se proporcionan argumentos :

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

Hay un complemento muy útil para esta tarea, vim-startify, que maneja muchas otras cosas, como archivos abiertos recientemente, etc. También tiene una interfaz muy fácil.

Lo uso desde hace un par de días y hasta ahora funciona perfectamente. Espero que te ayude.

Dado que este es el primer éxito en Google para mí (y probablemente para otros) sobre cómo trabajar con las sesiones en Vim, he decidido agregar un poco a la respuesta de @ mathielo sobre cómo hacer que esto sea automático.

Me gusta su código, pero la adición de la solución "solo si sin argumentos" parecía un poco escasa. Esta es mi versión 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

El cambio notable aquí es la anulación opcional. Si abre Vim sin opciones, se abrirá cualquier sesión existente y sobrescribirá los cambios realizados cuando salga. Si Vim se abre con opciones, solo creará una nueva sesión si no existe ninguna, esto significa que puede abrir archivos individuales en un directorio que tiene una sesión sin sobrescribirla. Luego puede abrir Vim sin opciones para ejecutar la sesión. Si no existe una sesión, se crea una nueva.

Existe este maravilloso complemento llamado vim-session . Es muy poderoso. Para instalarlo:

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

He mapeado su funcionalidad en mi .vimrcarchivo de esta manera:

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

Ahora en modo normal simplemente escriba <leader>ssy verá un comando como este

:SaveSession 

Ahora agregue el nombre de su sesión

 :SaveSession namesession

y eso es todo.

Cuando cierras Vim y lo vuelves a abrir, simplemente hazlo

 :OpenSession

y verás tu sesión abierta.

Hay muchas otras configuraciones para agregar en su .vimrcarchivo. Consulte la documentación para ver ejemplos:

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

Hay un buen tutorial en YouTube.

Personalmente, acabo de envolver el complemento Obsession de Tim Pope para permitir definir sessiondiray evitar escribir el camino:

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

Gracias @mathielo Siguiendo el ejemplo de @mathielo, agregué la siguiente línea a .vimrc para guardar la sesión activa (si la hubiera):

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

Si desea poner más líneas, debe usar endif:

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

Solo necesita guardar una nueva sesión en vim con

:mks [Session filename]

y después de comenzar con

$ vim -S [Session filename]

vim iniciará la sesión y no necesita preocuparse por guardar la sesión cada vez que cierre vim.

Si no tiene una sesión activa .vimrc no hará nada. Como antes.

Eso es lo que estaba buscando! Gracias de nuevo @mathielo!

Si planea tener solo 1 sesión para el proyecto, simplemente haga

:mks

que creará un Session.vimarchivo en el directorio actual y luego abrirá la sesión (desde el mismo directorio):

vim -S

Si cambia la sesión y desea guardarla:

:mks!

¡Esto salva la sesión, no los archivos en sí!

Si planea tener varias sesiones , prefiero guardarlas en archivos ocultos en el directorio del proyecto:

:mks .session-name.vim

Para abrirlo (desde el mismo directorio):

vim -S .session-name.vim

Guardar la sesión:

:mks! .session-name.vim

Como las sesiones se guardan en archivos ocultos, para verlas no olvides -a

ls -a

Puedes almacenar la sesión donde quieras.

Ex:

:mksession! D:/session.ses

Esto almacena la sesión en D drive.

Esto se puede abrir escribiendo

:so D:/session.ses

en cualquiera de los archivos vim.

A continuación se muestra la única conf. eso realmente funcionó para mí. Lo tomé de aquí , donde también puedes tomar una versión más completa / compleja.

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 administrar varias sesiones (por directorio / repositorio), recientemente cambié del complemento vim-session a vim-workspace . La gestión de su sesión es relativamente simple y funciona bastante bien.