Como vincular um conjunto de buffers a uma guia?

Quando preciso trabalhar em projetos diferentes ao mesmo tempo, tenho o seguinte fluxo de trabalho:

• Eu crio uma guia para cada projeto.
• Em cada guia, abro os arquivos que quero editar, o que gera vários buffers.
• Opcionalmente, se eu precisar ver dois (ou mais) arquivos ao mesmo tempo, crio janelas divididas para ter uma guia contendo janelas diferentes que mostram um buffer.

Para navegar entre os meus tampões Eu realmente não usam :lse :b [name or number of buffer]em vez disso, criou alguns mapeamentos convenientes, permitindo-me para alternar entre os buffers com :bnexte:bprevious

Essa maneira de trabalhar é muito boa, mas algo me incomoda: os buffers são compartilhados entre as guias.

Se eu abrir file1e file2em tab1e file3em tab2, em caso de tab1eu uso várias vezes :bnexteu vou ver file3neste guia que eu não quero. O fluxo de trabalho que eu gostaria de obter é o seguinte :

• Inicie o vim (eu tenho uma primeira guia com um buffer): $ vim foo
• Adicione um buffer a esta guia: :e bar
• Abra uma nova guia e mude para ela: :tabnew
• Abra um novo buffer nesta guia: :e baz
• Se eu permanecer neste buffer e permanecer :bnextou :bpreviouspermanecerá no bazbuffer (já que é o único nesta guia)
• Se eu for na guia anterior :tabpreviouse executar várias vezes :bnext, alternarei apenas entre fooe barbuffers, mas não verábaz

Então, aqui está a minha pergunta: É possível vincular um conjunto de buffers a uma guia e fazer com que o vim não permita o acesso a alguns buffers de outra guia além daquela em que eles devem estar?

Nota: Estou ciente de que usar :b [myBuffer]seria uma maneira de manter um buffer em uma guia, mas quando tenho 3 ou 4 arquivos para editar, sinto que sou muito mais rápido usando meus mapeamentos do que digitando o nome do buffer (mesmo que eu possa digite apenas alguns caracteres para corresponder ao nome do buffer) .

Não encontrei nenhum plugin por aí, mas você mesmo pode escrevê-lo. Você precisa aprender vimscript para isso. Acabei de implementar a funcionalidade que você pode alternar entre buffers em uma guia (nenhuma exclusão ainda). Você pode copiar isso no seu 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

Feche o seu vimrc e abra-o novamente. Para encontrar o próximo buffer, use

:call WindowBufManagerNext()

ou defina seu próprio comando ou mapeamento. Isso funcionará desde que você não feche ou exclua uma guia ou buffer. Também não funcionará para vários buffers. Seria necessário mais trabalho para adicionar esses recursos, mas é definitivamente factível.

Os buffers são globais e não há nada que você possa fazer sobre isso, exceto escrever sua própria camada de abstração no topo das guias, janelas e buffers. A resposta de philolo1 mostra uma abordagem razoável para o problema, mas você encontrará rapidamente os limites de uma "solução" e precisará duplicar muitos recursos internos, como :bufdoo arquivo alternativo…

"Argumentos", por outro lado, podem ser locais em uma janela, para que possam ser mais úteis no seu fluxo de trabalho do que "buffers" (no significado mais estrito da palavra):

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

Os argumentos não são tão flexíveis quanto os buffers, mas podem fornecer uma base mais confiável para o seu fluxo de trabalho.

Mas trabalhar em cada projeto em sua própria instância do Vim é, na minha opinião, a única solução prática.

Então, com algum atraso, acho que encontrei uma resposta satisfatória (pelo menos para mim!). Você precisará de dois plugins de Shougo:

• Shougo / Unite
• Shougo / tabpagebuffer

e um mapa de acesso rápido para usar em vez de :ls, para exibir (e selecionar) apenas buffers na guia atual .

Por exemplo, algo como:

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

Agora você pode percorrer a lista de buffers da guia atual ( j, k), selecionar um ( CR), cancelar ( q), entrar no modo "entrada" (inserir) para filtrar rapidamente a seleção de buffer digitando algumas letras ou até pressionar Tabpara abrir a lista de ações para o item selecionado atualmente (por exemplo, para abrir o buffer acima do ativo atual) - em resumo, você age da maneira genérica "Unir".

(veja também :h unite_default_key_mappingse Unite a ajuda em geral).

E agora o truque final (ainda opcional). Com altercmd , você pode criar seu próprio lscomando habilitado por tabulação (com base na funcionalidade Unite acima):

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

... e toda vez que você pressionar :ls, o Vim executará seu comando.

Observe que você também não precisará :bnou :bp, já que os buffers da guia de visualização e seleção agora são o mesmo comando.

Não posso comentar porque minha conta é nova, desculpe-me por isso, mas ++++ 1 para ctrl-space.

Eu fui vendido no momento em que cheguei no meio da ajuda. Ctrlspace tem uma estrutura como esta:

workspaces --> contain tabs --> contain buffers

Portanto, você pode salvar um espaço de trabalho para cada projeto em que está trabalhando e carregá-lo imediatamente quando quiser. Isso significa que, sempre que você fechar o vim, poderá salvar todos os seus separadores de buffer e tabulação.

Você também pode nomear suas guias. Se isso não for suficiente, você também pode alterar com facilidade os diretórios de trabalho e criar marcadores para os diretórios usados ​​com freqüência.

Ele faz uma interface agradável com o nerdtree se você o usar (embora, honestamente, você provavelmente nem sinta que precisa dele depois de uma semana com o ctrlspace)

Considere este caso de uso:

Você tem um projeto. Envolve plantar árvores. Existem árvores de fruto e árvores de dinheiro. As árvores do dinheiro contêm dólares e centavos, enquanto as árvores frutíferas contêm maçãs e laranjas.

Neste exemplo, maçãs, laranjas, dólares e centavos são todos "tampões".

O Ctrlspace permite separar maçãs e laranjas em uma "guia", que você pode rotular como "fruta" - esse rótulo aparecerá na linha de tag na parte superior da sua janela. Da mesma forma, dólares e centavos entram na guia "dinheiro".

O espaço de trabalho "árvores" salva toda a configuração e permite acessá-la imediatamente sempre que você abrir o vim.

Agora que estou ciente de sua existência, não consigo imaginar fazer desenvolvimento orientado a objetos no vim sem esse plugin. Apenas no caso, aqui está o link: https://github.com/szw/vim-ctrlspace

Então, finalmente, decidi criar meu próprio plugin para resolver o meu problema, ele está disponível no github .

Eu usei a idéia do @ philolo1 e tentei concluí-la. No momento em que escrevo essa resposta, ainda é um trabalho em andamento.

EDIT Já não mantenho o plug-in conforme meu fluxo de trabalho evoluiu e percebi que a ligação de buffers a uma guia adiciona mais problemas do que resolve.

O plug-in vincula os buffers às guias: quando o usuário abre um buffer, ele é automaticamente "armazenado" na guia e não pode ser acessado a partir de outra guia.

A instalação deve ser "amigável ao gerenciador de plugins" (pelo menos funciona bem com o Vim-Plug e Vundle )

Algumas das principais características são:

• Manipular automaticamente a ligação de buffers (o usuário pode abri-los como antes)
• :NextBufe :PrevBufsubstitua :bne :bNmantenha um estado consistente das guias
• :ListBufpermite listar os buffers de maneira semelhante à :lsexceto que eles estão separados em guias e um sinal permite que o usuário veja facilmente em qual guia ele está atualmente.
• :ChangeBuf aceite um número de buffer ou um nome de buffer para alterar automaticamente o buffer e alterar a guia
• O fechamento de um buffer é feito com :CloseBuf
• O fechamento de uma guia é feito com :CloseTab

Para outras operações que o usuário deve ser capaz de usar o built-in características (como :tabopen, :tabnext, etc ...)

Para cada comando, alguns mapeamentos padrão são fornecidos e podem ser facilmente desabilitados adicionando let g:betterTabsVim_map_keys = 0ao seu .vimrc.

Também tentei criar um arquivo de ajuda explícito ( :h betterTabs.txt): ainda não está completo, mas os usuários devem encontrar o mínimo para usar o plugin.

Ainda tenho muitos testes a fazer para garantir que o plug-in não atrapalhe nenhum comportamento nativo.

Finalmente, se alguém quiser ajudar, é sempre possível criar problemas na página do github ou criar solicitações pull.

Confira este plugin. Parece-me que atende perfeitamente às suas necessidades. https://github.com/szw/vim-ctrlspace