Je travaille en plusieurs groupes, chacun ayant sa propre tabulation / indentation / espacement en C.

Existe-t-il un moyen d'avoir des configurations VIM sélectionnables distinctes pour chacune? Ainsi, lorsque je modifie un fichier, soit:

• Je fais quelque chose comme set group=1sélectionner une configuration
• un .vimrc local qui vit dans le répertoire de travail est utilisé pour définir la configuration automatiquement

En résumé

Il y a plusieurs façons de le faire, dont la plupart ont été suggérées, mais j'ai pensé les résumer avec deux autres:

• Par répertoire vimrc - a l'inconvénient que Vim doit être démarré dans le bon répertoire: si votre projet est dans ~/project1et que vous avez ~/project1/.vim.customet faitescd ~ ; vim project1/file.c , les paramètres personnalisés ne seront pas trouvés.
• Modelines - très efficaces, mais a l'inconvénient de devoir les ajouter à tous les fichiers (et n'oubliez pas de les ajouter aux nouveaux fichiers)
• Commandes automatiques spécifiques au répertoire - c'est très efficace
• Recherchez un en-tête spécifique dans le fichier (voir ci-dessous) - c'est celui que j'ai le plus utilisé dans le passé lorsque je travaillais pour différentes entreprises ou sur des projets clairement nommés
• Vimrc par répertoire qui est vérifié lorsque le fichier est ouvert (voir ci-dessous). Un autre assez facile à implémenter, surtout si le code de votre projet est au même endroit.

Recherche d'un en-tête

Dans de nombreuses organisations, il y a un en-tête standard (avec un avis de droit d'auteur et un nom de projet, etc.) en haut de chaque fichier source. Si tel est le cas, vous pouvez demander à Vim de scanner automatiquement les 10 premières lignes (par exemple) du fichier à la recherche d'un mot-clé. S'il le trouve, il peut modifier vos paramètres. J'ai modifié cela pour le rendre plus simple que le formulaire que j'utilise (qui fait beaucoup d'autres choses), mais créez un ~/.vim/after/filetype.vim(si vous n'en avez pas encore) et ajoutez quelque chose comme ceci:

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

Chaque fois qu'un fichier de n'importe quel type est ouvert et que le type de fichier est défini (la au FileType *ligne), leConfigureFiletypes fonction est appelée. Cela vérifie si le type de fichier est dans la liste des types de fichiers associés au groupe actuel (GROUPNAME), dans ce cas «c», «cpp», «vhdl» ou «c.doxygen». Si tel est le cas, il appelle CheckForGROUPNAMECode (), qui lit les 10 premières lignes du fichier et si elles contiennent GROUPNAME, il effectue une certaine personnalisation. En plus de définir des onglets d'extension ou autre, cela modifie également la barre d'état pour afficher clairement le nom du groupe afin que vous sachiez que cela fonctionne en un coup d'œil.

Vérification de la configuration lors de l'ouverture

Tout comme la suggestion de JS Bangs, avoir un fichier de configuration personnalisé peut être utile. Cependant, au lieu de le charger dans vimrc, envisagez quelque chose comme ceci, qui vérifiera quand un fichier .c est ouvert pour un .vim.custom dans le même répertoire que le fichier .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

J'ai ceci dans $HOME/.vimrc:

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

Cela me permet de mettre un .vim.customfichier dans chaque répertoire pour charger des commandes et des options spécifiques à ce répertoire. Si vous travaillez sur plusieurs projets qui ont des structures de répertoires profondes, vous pourriez avoir besoin de quelque chose de plus sophistiqué (par exemple, remonter l'arborescence des répertoires jusqu'à ce que un .vim.customsoit trouvé), mais la même idée de base fonctionnera.

MISE À JOUR:

Je fais maintenant quelque chose comme ça pour lire un .vimfichier dans le même répertoire que le fichier que j'édite, quel que soit le répertoire actuel.

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

Vous pouvez également mettre des autocommandes dans votre .vimrcqui définissent des options spécifiques par chemin.

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

Plugin faisant ce qu'il faut: http://www.vim.org/scripts/script.php?script_id=441

«Ce plugin recherche les fichiers vimrc locaux dans l'arborescence du système de fichiers du fichier actuellement ouvert. Par défaut, il recherche tous les fichiers ".lvimrc" du répertoire du fichier jusqu'au répertoire racine et les charge dans l'ordre inverse. Le nom de fichier et la quantité de fichiers chargés sont personnalisables via des variables globales. »

En supposant que vos collègues développeurs ne s'en plaindront pas, vous pouvez toujours ajouter des paramètres vim à chaque fichier dans les commentaires.

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

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

J'ai créé un outil open-source à cette fin. Oubliez les en-têtes, l'analyse, les configurations et les fichiers vimrc locaux.

Essayez de nager.

Nager

swimest un outil rapide pour changer de fichier vimrc et créer des alias pratiques. Voici une courte liste d'utilisation. Voir le référentiel Github pour un gif pas à pas et des instructions de téléchargement:

Usage

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

Lire la suite

https://github.com/dawsonbotsford/swim

Après avoir essayé le plugin localvimrc suggéré par l'affiche précédente, j'aime beaucoup avoir un contrôle non futzy par projet sur les paramètres de vim.

Il demande une confirmation avant de charger un fichier .lvimrc par défaut, mais il existe un paramètre pour charger automatiquement les fichiers .lvimrc. Certains pourraient voir cela comme une faille de sécurité, mais cela fonctionne comme annoncé.

J'ai choisi de .gitignore les fichiers .lvimrc. Vous pouvez également les archiver sous forme de paramètres partagés (extension des onglets / espace, tabulations, autres paramètres spécifiques au projet).

Comme mentionné par sledge, l'utilisation de ce plug-in est la meilleure option que j'ai vue et utilisée. jerseyboy a commenté que l'utilitaire recommandé demande une confirmation avant le chargement (c'est-à-dire après l'ouverture de chaque fichier). Pour éviter cela, définissez simplement à votre main .vimrcla liste des .lvimrcfichiers locaux :

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

Voici une variante de jamessan

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

Je lancerai fréquemment vi sans fichier spécifique auquel je saute, ce qui permet de charger la configuration de manière conditionnelle en fonction du répertoire de travail actuel. L'inconvénient est que la configuration n'est pas appliquée en fonction du fichier mais hors du répertoire de travail.

Je travaille en plusieurs groupes, chacun ayant sa propre tabulation / indentation / espacement en C.

Je travaille avec toutes sortes d'open source, tous en même temps. Il n'est pas pratique de créer des .vimrcfichiers séparés et de reconfigurer les normes de formatage. Il y a plus d'une décennie, je me suis finalement lassé de gérer la configuration de l'éditeur et j'ai écrit un programme appeléautotab pour le gérer.

Quand autotabest configuré avec Vim suggéré, chaque fois que vous chargez un fichier dans Vim, il autotabest appelé dessus, et la sortie des paramètres Vim autotabest transmise à un:set commande.

autotablit plusieurs milliers de lignes du fichier, les analyse et détermine les paramètres des paramètres expandtab, tabstopet shiftwidth.

Il détermine si le fichier utilise des tabulations ou simplement des espaces pour l'indentation, et il détermine la taille de l'indentation. Si le fichier est indenté avec des tabulations, il détermine la bonne taille de tabulation, en fonction du rendu de l'échantillon de fichier à l'aide de différentes tailles de tabulation et en le jugeant en fonction d'heuristiques telles que l'alignement ligne sur ligne des éléments internes.

Cela fonctionne assez bien pour que j'ai arrêté de peaufiner l'algorithme il y a des années. Si cela devient confus, c'est presque toujours parce que le fichier a des problèmes de formatage, tels que l'utilisation de plusieurs conventions en même temps.

Il est également "indépendant" du type de fichier et fonctionne bien avec une variété de langues différentes. Je l'utilise non seulement sur C, mais sur des scripts shell, Lisp, Makefiles, HTML, et tout le reste.

Notez qu'il ne gère pas d'autres paramètres de mise en forme qui peuvent être spécifiques au projet, comme par exemple, dans les fichiers C, si les caseétiquettes d'une switchinstruction sont indentées ou non, ou si les listes d'arguments de fonction encapsulées sont simplement indentées ou alignées sur le parenthèse ouvrante de la liste d'arguments. Vim a des paramètres pour ce genre de chose, et donc le programme pourrait être plausiblement étendu pour analyser le style et afficher ces paramètres.

En recherchant essentiellement le même problème, j'ai également trouvé le plug-in Sauce: http://www.vim.org/scripts/script.php?script_id=3992

Il réclame:

Sauce est un gestionnaire léger pour plusieurs fichiers vimrc, qui peut être utilisé pour charger différents paramètres pour différents environnements. En bref, vous pouvez gérer de nombreux fichiers de paramètres vim différents et ne charger que ceux dont vous avez besoin lorsque vous en avez besoin.

Je trouve particulièrement intéressant qu'il garde toute la configuration dans son répertoire de données au lieu d'attendre de l'utilisateur qu'il saupoudre des fichiers dotfiles sur le système de fichiers. Ceci bien que souvent plutôt un mètre de goût personnel.

Je n'ai pas encore testé cela.

Vous pouvez utiliser stow pour changer de configuration (tous les fichiers dotfiles, pas seulement .vimrc)

Installer stow:

$ apt install stow

Créez plusieurs répertoires pour chaque configuration:

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

Mettez-y des éléments différents .vimrc:

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

Vous pouvez maintenant instancier la configuration de vim-golang avec cette commande (doit être exécutée dans le répertoire dotfiles):

~$ cd ~/dotfiles

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

Maintenant c'est lié:

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

Si vous avez besoin de changer de configuration, recommencez simplement 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

Pour en savoir plus, cliquez ici: Gérer les fichiers dotfiles avec GNU stow

Avantages : assez simple, pas de dépendances de plugin vim, peut être utilisé pour gérer tous les fichiers dotfiles, pas seulement .vimrc.

Inconvénients : les configurations sont indépendantes les unes des autres, vous devez gérer / mettre à jour chacune d'elles séparément (si vous ne changez pas / mettez à jour vos configurations trop souvent - ce ne sera pas le problème).