Eu trabalho em vários grupos, cada um deles com seus próprios padrões de tabulação / recuo / espaçamento em C.

Existe uma maneira de ter configurações VIM selecionáveis ​​separadas para cada um, quando eu edito um arquivo:

• Eu faço algo como set group=1selecionar uma configuração
• um .vimrc local que reside no diretório de trabalho é usado para definir a configuração automaticamente

Em suma

Existem algumas maneiras de fazer isso, a maioria das quais foi sugerida, mas pensei em resumi-las com duas outras:

• Vimrc por diretório - tem a desvantagem de que o Vim deve ser iniciado no diretório certo: se o seu projeto estiver dentro ~/project1e você tiver ~/project1/.vim.custome fizer cd ~ ; vim project1/file.c, as configurações personalizadas não serão encontradas.
• Modelines - muito eficazes, mas tem a desvantagem de precisar adicioná-los a todos os arquivos (e lembre-se de adicioná-los a novos arquivos)
• Comandos automáticos específicos de diretório - isso é muito eficaz
• Procure um cabeçalho específico no arquivo (veja abaixo) - este é o que eu mais usei no passado, quando trabalhei para empresas diferentes ou em projetos claramente nomeados
• Vimrc por diretório que é verificado quando o arquivo é aberto (veja abaixo). Outro bastante fácil de implementar, especialmente se o código do seu projeto estiver todo em um só lugar.

Procurando um cabeçalho

Em muitas organizações, há um cabeçalho padrão (com um aviso de copyright e nome do projeto, etc.) no topo de cada arquivo fonte. Se for esse o caso, você pode fazer com que o Vim escaneie automaticamente as primeiras (por exemplo) 10 linhas do arquivo procurando por uma palavra-chave. Se o encontrar, ele pode alterar suas configurações. Eu modifiquei isso para torná-lo mais simples do que o formulário que uso (que faz muitas outras coisas), mas crie um ~/.vim/after/filetype.vim(se ainda não tiver um) e adicione algo assim:

au FileType * call <SID>ConfigureFiletypes(expand("<amatch>"))

" List of file types to customise
let s:GROUPNAMETypes = ['c', 'cpp', 'vhdl', 'c.doxygen']

func! <SID>CheckForGROUPNAMECode()
    " Check if any of the first ten lines contain "GROUPNAME".

    " Read the first ten lines into a variable
    let header = getline(1)
    for i in range(2, 10)
        let header = header . getline(i)
    endfor

    if header =~ '\<GROUPNAME\>'
        " Change the status line to make it clear which
        " group we're using
        setlocal statusline=%<%f\ (GROUPNAME)\ %h%m%r%=%-14.(%l,%c%V%)\ %P
        " Do other customisation here
        setlocal et
        " etc
    endif
endfunc

func! <SID>ConfigureFiletypes(filetype)
    if index(s:GROUPNAMETypes, a:filetype) != -1
        call <SID>CheckForGROUPNAMECode()
    endif
endfunc

Sempre que um arquivo de qualquer tipo é aberto e o tipo de arquivo é definido (a au FileType *linha), a ConfigureFiletypesfunção é chamada. Isso verifica se o tipo de arquivo está na lista de tipos de arquivo associados ao grupo atual (GROUPNAME), neste caso 'c', 'cpp', 'vhdl' ou 'c.doxygen'. Se for, ele chama CheckForGROUPNAMECode (), que lê as 10 primeiras linhas do arquivo e se elas contiverem GROUPNAME, faz alguma personalização. Além de definir tabelas de expansão ou qualquer outra coisa, isso também altera a barra de status para mostrar o nome do grupo claramente para que você saiba que funcionou imediatamente.

Verificando a configuração ao abrir

Muito parecido com a sugestão de JS Bangs, ter um arquivo de configuração personalizado pode ser útil. No entanto, em vez de carregá-lo no vimrc, considere algo assim, que verificará quando um arquivo .c for aberto para um .vim.custom no mesmo diretório do arquivo .c.

au BufNewFile,BufRead *.c call CheckForCustomConfiguration()

function! CheckForCustomConfiguration()
    " Check for .vim.custom in the directory containing the newly opened file
    let custom_config_file = expand('%:p:h') . '/.vim.custom'
    if filereadable(custom_config_file)
        exe 'source' custom_config_file
    endif
endfunction

Eu tenho isso em $HOME/.vimrc:

if filereadable(".vim.custom")
    so .vim.custom
endif

Isso me permite colocar um .vim.customarquivo em cada diretório para carregar comandos e opções específicas para aquele diretório. Se você estiver trabalhando em vários projetos que têm estruturas de diretório profundas, pode precisar de algo mais sofisticado (por exemplo, subir na árvore de diretórios até que um .vim.customseja encontrado), mas a mesma ideia básica funcionará.

ATUALIZAR:

Agora faço algo assim para ler um .vimarquivo do mesmo diretório que o arquivo que estou editando, independentemente de qual seja o diretório atual.

let b:thisdir=expand("%:p:h")
let b:vim=b:thisdir."/.vim"
if (filereadable(b:vim))
    execute "source ".b:vim
endif

Você também pode colocar comandos automáticos em seu computador , .vimrcque define opções específicas por caminho.

au BufRead,BufNewFile /path/to/project1/* setl sw=4 et
au BufRead,BufNewFile /path/to/project2/* setl sw=3 noet

Plugin fazendo a coisa certa: http://www.vim.org/scripts/script.php?script_id=441

“Este plugin procura por arquivos vimrc locais na árvore do sistema de arquivos do arquivo aberto atualmente. Por padrão, ele procura todos os arquivos ".lvimrc" do diretório do arquivo até o diretório raiz e os carrega na ordem inversa. O nome do arquivo e a quantidade de arquivos carregados são personalizáveis ​​por meio de variáveis ​​globais. ”

Assumindo que seus colegas desenvolvedores não reclamarão, você sempre pode adicionar configurações do vim a cada arquivo nos comentários.

/*
 * vim:ts=4:sw=4:expandtab:...
 */

int main(int argc, char **argv)
{
    ...

Criei uma ferramenta de código-fonte aberto exatamente para esse propósito. Esqueça os cabeçalhos, a varredura, as configurações e os arquivos vimrc locais.

Experimente nadar.

Nadar

swimé uma ferramenta rápida para alternar arquivos vimrc e criar aliases convenientes. Aqui está uma pequena lista de uso. Consulte o repositório do Github para obter um GIF de explicação e instruções de download:

Uso

swim add ~/dotfiles/myVimrc favorite    #Add new swim alias
swim ls                                 #Show available swim aliases
swim add https://raw.githubusercontent.com/dawsonbotsford/swim/master/exampleVimrcs/vimrcWikia.vim example
swim with favorite         #Set alias favorite as primary .vimrc
swim with main             #Set alias main as primary .vimrc

consulte Mais informação

https://github.com/dawsonbotsford/swim

Depois de experimentar o plug-in localvimrc sugerido pelo autor anterior, eu gosto muito de ter um controle não inútil por projeto sobre as configurações do vim.

Ele pede confirmação antes de carregar um arquivo .lvimrc por padrão, mas há uma configuração para carregar arquivos .lvimrc automaticamente. Alguns podem ver isso como uma falha de segurança, mas funciona como anunciado.

Eu escolhi .gitignore os arquivos .lvimrc. Alternativamente, você pode fazer o check-in como uma forma de configurações compartilhadas (expansão de tabulação / espaço, tabulações, outras configurações específicas do projeto).

Como mencionado por sledge, o uso desse plug-in é a melhor opção que já vi e uso. jerseyboy comentou que o utilitário recomendado pede confirmação antes de carregar (ou seja, depois de abrir cada arquivo). Para evitar isso, basta definir no seu principal .vimrca lista de .lvimrcarquivos locais :

let g:localvimrc_whitelist='/development/kernel/.lvimrc'

Aqui está uma variação de Jamessan's

function! ConditionalLoad()
    let cwd = getcwd()
    if getcwd() =~ $HOME . "/src/mobile"
        so $HOME/.vim.mobile
    endif
endfunction
autocmd VimEnter * call ConditionalLoad()

Freqüentemente irei lançar o vi sem um arquivo específico para o qual estou pulando, então isso permite carregar a configuração condicionalmente com base no diretório de trabalho atual. A desvantagem é que a configuração não é aplicada com base no arquivo, mas fora do diretório de trabalho.

Eu trabalho em vários grupos, cada um deles com seus próprios padrões de tabulação / recuo / espaçamento em C.

Trabalho com todos os tipos de código aberto, tudo ao mesmo tempo. Não é prático criar .vimrcarquivos separados e reconfigurar os padrões de formatação. Mais de uma década atrás, finalmente me cansei de lidar com a configuração do editor e escrevi um programa chamado autotabpara lidar com isso.

Quando autotabé configurado com o Vim sugerido, cada vez que você carrega um arquivo no Vim, autotabé invocado nele e a saída das configurações do Vim autotabé passada para um :setcomando.

autotablê vários milhares de linhas do arquivo, analisa-os e determina as configurações para os expandtab, tabstope shiftwidthparâmetros.

Ele descobre se o arquivo usa tabulações rígidas ou apenas espaços para indentação e descobre o tamanho da indentação. Se o arquivo for recuado com guias, ele descobrirá o tamanho correto da guia, com base na renderização da amostra do arquivo usando vários tamanhos de guia e julgando-o de acordo com heurísticas, como alinhamento linha sobre linha de elementos internos.

Funciona bem o suficiente para que eu pare de ajustar o algoritmo anos atrás. Se ficar confuso, quase sempre é porque o arquivo tem problemas de formatação, como o uso de várias convenções ao mesmo tempo.

Também é "agnóstico" quanto ao tipo de arquivo e funciona bem com uma variedade de idiomas diferentes. Eu o uso não apenas em C, mas em scripts de shell, Lisp, Makefiles, HTML e tudo o mais.

Observe que ele não lida com outros parâmetros de formatação que podem ser específicos do projeto, como, por exemplo, em arquivos C, se os caserótulos em uma switchinstrução são recuados ou não, ou se as listas de argumentos de funções agrupadas são simplesmente recuadas ou alinhadas ao abrindo parênteses da lista de argumentos. O Vim tem configurações para esse tipo de coisa e, portanto, o programa poderia ser estendido de forma plausível para analisar o estilo e gerar esses parâmetros.

Procurando principalmente pelo mesmo problema, também encontrei o plug-in Sauce: http://www.vim.org/scripts/script.php?script_id=3992

Afirma:

O molho é um gerenciador leve para vários arquivos vimrc, que pode ser usado para carregar configurações diferentes para ambientes diferentes. Resumindo, você pode manter muitos arquivos de configurações diferentes do vim e carregar apenas o (s) necessário (s) quando precisar deles.

Acho particularmente interessante que ele mantenha todas as configurações em seu diretório de dados, em vez de esperar que o usuário espalhe dotfiles por todo o sistema de arquivos. Embora muitas vezes seja uma questão de gosto pessoal.

Eu ainda tenho que testá-lo.

Você pode usar o stow para alternar a configuração (qualquer arquivo dot, não apenas .vimrc)

Instale stow:

$ apt install stow

Crie vários diretórios para cada configuração:

~$ ls -d ~/dotfiles/vim*
vim-all vim-webdev vim-go

Coloque diferentes .vimrcneles:

$ find ~/dotfiles -name .vimrc
/home/username/vim-golang/.vimrc
/home/username/vim-webdev/.vimrc
/home/username/vim-all/.vimrc

Agora você pode instanciar a configuração do vim-golang com este comando (deve ser executado dentro do diretório dotfiles):

~$ cd ~/dotfiles

dotfiles$ stow -v vim-golang
LINK: .vimrc => dotfiles/vim-golang/.vimrc

Agora está vinculado:

$ cd ~ && ls -l .vimrc 
.vimrc -> dotfiles/vim-golang/.vimrc

Se você precisar mudar de configuração, basta reiniciá- stowlo:

~$ cd dotfiles

dotfiles$ stow -v -D vim-golang
UNLINK: .vimrc

dotfiles$ stow -v vim-webdev
LINK: .vimrc => dotfiles/vim-webdev/.vimrc

$ cd ~ && ls -l .vimrc 
.vimrc -> dotfiles/vim-webdev/.vimrc

Leia mais aqui: Gerenciando arquivos dot com GNU stow

Prós : muito simples, sem dependências do plugin vim, pode ser usado para gerenciar todos os dotfiles, não apenas .vimrc.

Contras : as configurações são independentes umas das outras, você precisa gerenciar / atualizar cada uma delas separadamente (se você não alternar / atualizar as configurações com muita frequência - esse não será o problema).