Trabajo en varios grupos, cada uno de los cuales tiene sus propios estándares de tabulación / sangría / espaciado en C.

¿Hay alguna manera de tener configuraciones de VIM seleccionables separadas para cada uno? Cuando edito un archivo, ya sea:

• Hago algo como set group=1seleccionar una configuración
• Se usa un .vimrc local que vive en el directorio de trabajo para establecer la configuración automáticamente

En resumen

Hay algunas formas de hacer esto, de las cuales la mayoría se han sugerido, pero pensé en resumirlas con dos más:

• Vimrc por directorio: tiene la desventaja de que Vim debe iniciarse en el directorio correcto: si su proyecto está dentro ~/project1y lo tiene ~/project1/.vim.customy lo hacecd ~ ; vim project1/file.c , no se encontrarán las configuraciones personalizadas.
• Modelines: muy eficaz, pero tiene la desventaja de tener que agregarlos a todos los archivos (y recuerde agregarlos a los archivos nuevos)
• Autocomandos específicos del directorio: esto es muy efectivo
• Busque un encabezado específico en el archivo (ver más abajo): este es el que más he usado en el pasado cuando trabajaba para diferentes empresas o en proyectos con nombres claros
• Vimrc por directorio que se comprueba cuando se abre el archivo (ver más abajo). Otro bastante fácil de implementar, especialmente si el código de su proyecto está todo en un solo lugar.

Buscando un encabezado

En muchas organizaciones, hay un encabezado estándar (con un aviso de derechos de autor y el nombre del proyecto, etc.) en la parte superior de cada archivo fuente. Si este es el caso, puede hacer que Vim escanee automáticamente las primeras (por ejemplo) 10 líneas del archivo en busca de una palabra clave. Si lo encuentra, puede cambiar su configuración. Modifiqué esto para hacerlo más simple que el formulario que uso (que hace muchas otras cosas), pero cree un ~/.vim/after/filetype.vim(si aún no tiene uno) y agregue algo como esto:

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

Siempre que se abre un archivo de cualquier tipo y se establece el tipo de archivo (la au FileType *línea), ConfigureFiletypesse llama a la función. Esto verifica si el tipo de archivo está en la lista de tipos de archivos asociados con el grupo actual (GROUPNAME), en este caso 'c', 'cpp', 'vhdl' o 'c.doxygen'. Si es así, llama a CheckForGROUPNAMECode (), que lee las primeras 10 líneas del archivo y si contienen GROUPNAME, realiza alguna personalización. Además de configurar las pestañas de expansión o lo que sea, esto también cambia la barra de estado para mostrar claramente el nombre del grupo para que sepa que ha funcionado de un vistazo.

Comprobación de la configuración al abrir

Al igual que la sugerencia de JS Bangs, tener un archivo de configuración personalizado puede ser útil. Sin embargo, en lugar de cargarlo en vimrc, considere algo como esto, que verificará cuando se abra un archivo .c para un .vim.custom en el mismo directorio que el archivo .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

Tengo esto en $HOME/.vimrc:

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

Esto me permite poner un .vim.customarchivo en cada directorio para cargar comandos y opciones específicas para ese directorio. Si está trabajando en varios proyectos que tienen estructuras de directorios profundas, es posible que necesite algo más sofisticado (por ejemplo, subir por el árbol de directorios hasta .vim.customencontrar un), pero la misma idea básica funcionará.

ACTUALIZAR:

Ahora hago algo como esto para leer un .vimarchivo del mismo directorio que el archivo que estoy editando, independientemente del directorio actual.

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

También puede poner comandos automáticos en su .vimrcque configuran opciones específicas por ruta.

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

Complemento haciendo lo correcto: http://www.vim.org/scripts/script.php?script_id=441

“Este complemento busca archivos vimrc locales en el árbol del sistema de archivos del archivo abierto actualmente. De forma predeterminada, busca todos los archivos ".lvimrc" desde el directorio del archivo hasta el directorio raíz y los carga en orden inverso. El nombre de archivo y la cantidad de archivos cargados se pueden personalizar mediante variables globales ".

Suponiendo que sus compañeros desarrolladores no se quejarán de ello, siempre puede agregar configuraciones de vim a cada archivo en los comentarios.

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

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

Creé una herramienta de código abierto para este propósito. Olvídese de los encabezados, el escaneo, las configuraciones y los archivos vimrc locales.

Intenta nadar.

Nadar

swimes una herramienta rápida para cambiar archivos vimrc y crear alias convenientes. Aquí hay una breve lista de uso. Consulte el repositorio de Github para obtener un tutorial de gif e instrucciones de descarga:

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

Lee mas

https://github.com/dawsonbotsford/swim

Después de probar el complemento localvimrc sugerido por el póster anterior, me gusta mucho tener un control por proyecto no fútil sobre la configuración de vim.

Solicita confirmación antes de cargar un archivo .lvimrc de forma predeterminada, pero hay una configuración para cargar automáticamente archivos .lvimrc. Algunos pueden ver esto como un agujero de seguridad, pero funciona como se anuncia.

Elegí .gitignore los archivos .lvimrc. Alternativamente, puede registrarlos como una forma de configuración compartida (expansión de pestañas / espacios, topes de pestañas, otras configuraciones específicas del proyecto).

Como lo mencionó Sledge, el uso de ese complemento es la mejor opción que he visto y uso. jerseyboy comentó que la utilidad recomendó pedir confirmación antes de cargar (es decir, después de abrir cada archivo). Para evitar esto, simplemente configure en su principal .vimrcla lista de .lvimrcarchivos locales :

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

Aquí hay una variación de jamessan

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

Con frecuencia, ejecutaré vi sin un archivo específico al que estoy saltando, por lo que esto permite cargar la configuración de forma condicional en función del directorio de trabajo actual. La desventaja es que la configuración no se aplica según el archivo, sino fuera del directorio de trabajo.

Trabajo en varios grupos, cada uno de los cuales tiene sus propios estándares de tabulación / sangría / espaciado en C.

Trabajo con todo tipo de código abierto, todo al mismo tiempo. No es práctico crear .vimrcarchivos separados y reconfigurar los estándares de formato. Hace más de una década, finalmente me cansé de lidiar con la configuración del editor y escribí un programa llamadoautotab para manejarlo.

Cuando autotabse configura con Vim sugerido, cada vez que carga un archivo en Vim, autotabse invoca en él y la salida de configuración de Vim autotabse pasa a un :setcomando.

autotablee varios miles de líneas del archivo, las analiza y determina la configuración de los parámetros expandtab, tabstopy shiftwidth.

Averigua si el archivo usa pestañas rígidas o solo espacios para la sangría, y calcula el tamaño de la sangría. Si el archivo tiene sangría con pestañas, determina el tamaño de pestaña correcto, basándose en la representación de la muestra del archivo utilizando varios tamaños de pestaña y juzgándola de acuerdo con heurísticas como la alineación línea sobre línea de los elementos internos.

Funciona lo suficientemente bien como para dejar de ajustar el algoritmo hace años. Si se confunde, es casi siempre porque el archivo tiene problemas de formato, como el uso de varias convenciones al mismo tiempo.

También es "agnóstico" del tipo de archivo y funciona bien con una variedad de idiomas diferentes. Lo uso no solo en C, sino también en scripts de shell, Lisp, Makefiles, HTML y lo que sea.

Tenga en cuenta que no maneja otros parámetros de formato que pueden ser específicos del proyecto, como por ejemplo, en archivos C, si las caseetiquetas en una switchdeclaración tienen sangría o no, o si las listas de argumentos de funciones envueltas simplemente están sangradas o alineadas con el paréntesis de apertura de la lista de argumentos. Vim tiene configuraciones para ese tipo de cosas, por lo que el programa podría extenderse de manera plausible para analizar el estilo y generar esos parámetros.

Buscando principalmente el mismo problema, también encontré el complemento Sauce: http://www.vim.org/scripts/script.php?script_id=3992

Afirma:

Sauce es un administrador liviano para múltiples archivos vimrc, que se puede usar para cargar diferentes configuraciones para diferentes entornos. En resumen, puede mantener muchos archivos de configuración de vim diferentes y solo cargar los que necesita cuando los necesita.

Me parece particularmente interesante que mantenga la configuración en su directorio de datos en lugar de esperar que el usuario esparza dotfiles por todo el sistema de archivos. Esto, aunque a menudo es más bien una muestra de gusto personal.

Aunque todavía tengo que probarlo.

Puede usar stow para cambiar la configuración (cualquier archivo de punto, no solo .vimrc)

Instalar stow:

$ apt install stow

Cree varios directorios para cada configuración:

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

Ponga diferentes .vimrcen ellos:

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

Ahora puede crear una instancia de configuración de vim-golang con este comando (debe ejecutarse dentro del directorio dotfiles):

~$ cd ~/dotfiles

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

Ahora está vinculado:

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

Si necesita cambiar la configuración, simplemente responda stow:

~$ 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

Más información aquí: Gestión de archivos dot con GNU stow

Ventajas : bastante simple, sin dependencias de complementos vim, se puede usar para administrar todos los archivos de puntos, no solo .vimrc.

Contras : las configuraciones son independientes entre sí, debe administrar / actualizar cada una de ellas por separado (si no cambia / actualiza sus configuraciones con demasiada frecuencia, no será el problema).