Come associare un set di buffer a una scheda?

Quando devo lavorare su diversi progetti contemporaneamente ho il seguente flusso di lavoro:

• Creo una scheda per ogni progetto.
• In ogni scheda apro i file che voglio modificare, il che rende diversi buffer.
• Opzionalmente se ho bisogno di vedere due (o più) file contemporaneamente creo finestre divise, quindi ho una scheda contenente finestre diverse che mostra un buffer.

Per navigare tra i miei buffer non uso davvero :lse :b [name or number of buffer]invece ho creato alcuni comodi mapping che mi permettono di passare da un buffer all'altro con :bnexte:bprevious

Questo modo di lavorare è abbastanza buono ma qualcosa mi disturba: i buffer sono condivisi tra le schede.

Se apro file1e file2dentro tab1e file3dentro tab2, se in tab1uso più volte :bnextvedrò file3in questa scheda che non voglio. Il flusso di lavoro che vorrei ottenere è il folowing :

• Inizia vim (ho una prima scheda con un buffer): $ vim foo
• Aggiungi un buffer a questa scheda: :e bar
• Apri una nuova scheda e passa ad essa: :tabnew
• Apri un nuovo buffer in questa scheda: :e baz
• Se rimango in questo buffer e lo faccio :bnexto :bpreviousrimarrò nel bazbuffer (poiché è l'unico in questa scheda)
• Se vado nella scheda precedente :tabprevioused eseguo più volte :bnextpasserò solo da fooe barbuffer ma non vedròbaz

Quindi ecco la mia domanda: è possibile associare un set di buffer a una scheda e fare in modo che vim non consenta l'accesso ad alcuni buffer da un'altra scheda rispetto a quella in cui si intende trovarsi?

Nota: sono consapevole che l'utilizzo :b [myBuffer]sarebbe un modo per mantenere un buffer in una scheda, ma quando ho 3 o 4 file da modificare mi sembra di essere molto più veloce nell'usare i miei mapping piuttosto che digitare il nome del buffer (anche se posso digitare solo alcuni caratteri per abbinare il nome del buffer) .

Mhh, non ho trovato nessun plugin là fuori, ma potresti scriverlo da solo. Per questo devi imparare vimscript. Ho appena implementato la funzionalità che puoi passare da un buffer all'altro in una scheda (ancora nessuna cancellazione). Puoi copiarlo nel tuo vimrc:

if !exists("g:WindowBufManager") 
  let g:WindowBufManager= {}
endif

function! StoreBufTab()
  if !has_key(g:WindowBufManager, tabpagenr())
    let  g:WindowBufManager[tabpagenr()] = []
  endif

  " add the new buffer to our explorer
  if index(g:WindowBufManager[tabpagenr()], bufname("%")) == -1 && bufname("%") != ""
    call add (g:WindowBufManager[tabpagenr()],bufname("%"))
  endif
endfunction

function! WindowBufManagerNext() 
  " find the next index of the buffer
  let s = index(g:WindowBufManager[tabpagenr()], bufname("%"))
  if (s!= -1)
    let s = (s +1) % len(g:WindowBufManager[tabpagenr()])
    execute 'b ' . g:WindowBufManager[tabpagenr()][s]
  endif
endfunction

augroup WindowBufManagerGroup
  autocmd! BufEnter * call StoreBufTab()
augroup END

Chiudi il tuo vimrc e aprilo di nuovo. Per trovare il prossimo buffer basta usare

:call WindowBufManagerNext()

o definire il proprio comando o mappatura. Ciò funzionerà finché non si chiude o si elimina una scheda o un buffer. Inoltre non funzionerà per più buffer. Richiederebbe un po 'più di lavoro per aggiungere quelle funzionalità, ma è sicuramente fattibile.

I buffer sono globali e non c'è nulla che tu possa fare al riguardo tranne scrivere il tuo livello di astrazione in cima a pagine di tab, finestre e buffer. La risposta di philolo1 mostra un approccio ragionevole al problema, ma troverai rapidamente i limiti di tale "soluzione" e dovrai duplicare molte funzionalità integrate come :bufdoo il file alternativo ...

"Argomenti", d'altra parte, possono essere locali in una finestra in modo che possano essere più utili nel flusso di lavoro rispetto ai "buffer" (nel senso più stretto della parola):

$ vim file1 file2
:tabnew
:argl file3 file4 file5
:n
:n
gt
:n
gt
:N
and so on…

Gli argomenti non sono flessibili come i buffer, ma possono fornire una base più affidabile per il flusso di lavoro.

Ma lavorare su ciascun progetto nella propria istanza di Vim è a mio avviso l'unica soluzione pratica.

Quindi, con un certo ritardo, penso di aver trovato una risposta soddisfacente (almeno per me!). Ti serviranno due plugin di Shougo:

• Shougo / Unite
• Shougo / tabpagebuffer

e una mappa di accesso rapido da utilizzare invece di :ls, per visualizzare (e selezionare) solo i buffer dalla scheda corrente .

Ad esempio, qualcosa del tipo:

nnoremap <leader>b :<C-u>Unite buffer_tab -no-split<CR>

Ora è possibile spostarsi nell'elenco del buffer della scheda corrente ( j, k), selezionare uno ( CR), annullare ( q), accedere alla modalità "input" (inserire) per filtrare rapidamente la selezione del buffer digitando alcune lettere o anche premere Tabper aprire l'elenco delle azioni per l'elemento attualmente selezionato (ad es. per aprire il buffer sopra l'attuale attivo) - in breve, agisci nel modo generico "Unite".

(vedi anche :h unite_default_key_mappingse aiuto Uniti in generale).

E ora per il trucco finale (ma facoltativo). Con altercmd è possibile creare il proprio lscomando abilitato per tabulazione (basato sulla funzionalità Unite sopra):

:command! LS Unite buffer_tab -no-split
:AlterCommand ls LS

... e ogni volta che premi :ls, Vim eseguirà invece il tuo comando.

Si noti che non sarà necessario :bno :bp, poiché la visualizzazione e la selezione dei buffer della scheda sono ora lo stesso comando.

Non posso commentare perché il mio account è nuovo, mi dispiace, ma ++++ 1 per ctrl-space.

Sono stato venduto quando sono arrivato a metà dell'aiuto. Ctrlspace ha una struttura come questa:

workspaces --> contain tabs --> contain buffers

Quindi, puoi salvare uno spazio di lavoro per ogni progetto su cui stai lavorando e caricarlo immediatamente quando vuoi. Ciò significa che ogni volta che chiudi vim puoi salvare tutti i buffer e le suddivisioni delle schede.

Puoi anche nominare le tue schede. Se ciò non bastasse, puoi anche cambiare facilmente le directory di lavoro e creare segnalibri per le directory che usi di frequente.

Si interfaccia bene con nerdtree se lo usi (anche se onestamente probabilmente non ti sentirai nemmeno di averne bisogno dopo una settimana con ctrlspace)

Considera questo caso d'uso:

Hai un progetto. Si tratta di piantare alberi. Ci sono alberi da frutto e alberi da soldi. Gli alberi da denaro contengono dollari e centesimi mentre gli alberi da frutto contengono mele e arance.

In questo esempio, mele, arance, dollari e centesimi sono tutti "buffer".

Ctrlspace ti consente di separare mele e arance in una "scheda" che puoi etichettare "frutta" - questa etichetta apparirà nella tag line nella parte superiore della finestra. Allo stesso modo, dollari e centesimi vanno in una scheda "soldi".

L'area di lavoro "alberi" salva l'intera configurazione e ti consente di accedervi immediatamente ogni volta che apri vim.

Ora che sono a conoscenza della sua esistenza, non riesco davvero a immaginare di fare uno sviluppo orientato agli oggetti in Vim senza questo plugin. Per ogni evenienza, ecco il link: https://github.com/szw/vim-ctrlspace

Quindi finalmente ho deciso di creare il mio plugin per risolvere il mio problema, è disponibile su Github .

Ho usato l'idea di @ philolo1 e ho provato a completarla, al momento sto scrivendo questa risposta che è ancora in fase di elaborazione.

EDIT Non mantengo più il plugin man mano che il mio flusso di lavoro si evolve e ho realizzato che i buffer di associazione a una scheda aggiungono più problemi di quanti ne risolva.

Il plug-in associa i buffer alle schede: quando l'utente apre un buffer, questo viene automaticamente "memorizzato" nella scheda e non è possibile accedervi da un'altra scheda.

L'installazione dovrebbe essere "plugin manager friendly" (almeno funziona bene con Vim-Plug e Vundle )

Alcune delle caratteristiche principali sono:

• Gestire automaticamente l'associazione dei buffer (l'utente può aprirli come prima)
• :NextBufe :PrevBufsostituire :bne :bNmantenere uno stato coerente delle schede
• :ListBufconsente di elencare i buffer in modo simile a :lstranne che sono separati in schede e un segno consente all'utente di vedere facilmente in quale scheda si trova attualmente.
• :ChangeBuf accetta un numero di buffer o un nome di buffer per cambiare automaticamente il buffer e cambiare la scheda
• La chiusura di un buffer viene eseguita con :CloseBuf
• La chiusura di una scheda è terminata con :CloseTab

Per le altre operazioni che l'utente deve essere in grado di utilizzare il built-in caratteristiche (come :tabopen, :tabnext, ecc ...)

Per ogni comando vengono forniti alcuni mapping predefiniti che possono essere facilmente disabilitati aggiungendo let g:betterTabsVim_map_keys = 0al tuo .vimrc.

Ho anche provato a creare un file di aiuto esplicito ( :h betterTabs.txt): non è ancora completo ma gli utenti dovrebbero trovare il minimo per utilizzare il plugin.

Ho ancora molti test da fare per essere sicuro che il plugin non dia fastidio a nessun comportamento nativo.

Infine, se qualcuno vuole aiutare, è sempre possibile creare problemi nella pagina github o creare richieste pull.

Dai un'occhiata a questo plugin. Mi sembra perfettamente adatto alle tue esigenze. https://github.com/szw/vim-ctrlspace