Pracuję w kilku grupach, z których każda ma własne standardy tabulacji / wcięć / odstępów w C.

Czy istnieje sposób na stworzenie oddzielnych konfigurowalnych konfiguracji VIM dla każdego z nich, więc kiedy edytuję plik:

• Robię coś takiego jak set group=1wybranie konfiguracji
• lokalny plik .vimrc, który znajduje się w katalogu roboczym, jest używany do automatycznego ustawiania konfiguracji

W podsumowaniu

Jest na to kilka sposobów, z których większość została zaproponowana, ale pomyślałem, że podsumuję je dwoma dodatkowymi:

• Vimrc dla katalogu - ma tę wadę, że Vim musi być uruchamiany w odpowiednim katalogu: jeśli twój projekt jest w ~/project1i masz ~/project1/.vim.customi robisz cd ~ ; vim project1/file.c, niestandardowe ustawienia nie zostaną znalezione.
• Modelines - bardzo efektywne, ale ma tę wadę, że trzeba je dodawać do wszystkich plików (i pamiętać o dodawaniu ich do nowych plików)
• Autokomendy specyficzne dla katalogu - jest to bardzo efektywne
• Skanuj w poszukiwaniu określonego nagłówka w pliku (patrz poniżej) - jest to ten, z którego korzystałem najczęściej w przeszłości, pracując dla różnych firm lub nad wyraźnie nazwanymi projektami
• Vimrc dla katalogu, który jest sprawdzany, gdy plik jest otwierany (patrz poniżej). Kolejny dość łatwy do zaimplementowania, zwłaszcza jeśli kod projektu znajduje się w jednym miejscu.

Wyszukiwanie nagłówka

W wielu organizacjach na górze każdego pliku źródłowego znajduje się standardowy nagłówek (z informacją o prawach autorskich, nazwą projektu itp.). Jeśli tak jest, możesz zmusić Vima do automatycznego skanowania pierwszych (np.) 10 linii pliku w poszukiwaniu słowa kluczowego. Jeśli go znajdzie, może zmienić Twoje ustawienia. Zmodyfikowałem to, aby było prostsze niż formularz, którego używam (który robi wiele innych rzeczy), ale stwórz ~/.vim/after/filetype.vim(jeśli jeszcze go nie masz) i dodaj coś takiego:

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

Za każdym razem, gdy otwierany jest plik dowolnego typu i ustawiany jest typ pliku ( au FileType *linia), ConfigureFiletypeswywoływana jest funkcja. Sprawdza, czy typ pliku znajduje się na liście typów plików związanych z bieżącą grupą (NAZWA GRUPY), w tym przypadku „c”, „cpp”, „vhdl” lub „c.doxygen”. Jeśli tak, wywołuje CheckForGROUPNAMECode (), który odczytuje pierwsze 10 wierszy pliku i jeśli zawierają GROUPNAME, dokonuje pewnych dostosowań. Oprócz ustawiania zakładek rozwijanych lub czegokolwiek, zmienia to również pasek stanu, aby wyraźnie pokazywać nazwę grupy, dzięki czemu od razu wiesz, że działa.

Sprawdzanie konfiguracji podczas otwierania

Podobnie jak w przypadku sugestii JS Bangsa, posiadanie niestandardowego pliku konfiguracyjnego może być przydatne. Jednak zamiast ładować go do vimrc, rozważ coś takiego, które sprawdzi, kiedy plik .c zostanie otwarty dla pliku .vim.custom w tym samym katalogu co plik .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

Mam to w $HOME/.vimrc:

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

To pozwala mi umieścić .vim.customplik w każdym katalogu, aby załadować polecenia i opcje specyficzne dla tego katalogu. Jeśli pracujesz nad wieloma projektami, które mają głębokie struktury katalogów, możesz potrzebować czegoś bardziej wyrafinowanego (np. Przejść po drzewie katalogów, aż .vim.customzostanie znaleziony), ale ta sama podstawowa idea zadziała.

AKTUALIZACJA:

Robię teraz coś takiego, aby odczytać .vimplik z tego samego katalogu, co plik, który edytuję, niezależnie od tego, jaki jest bieżący katalog.

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

Można również umieścić autokomend w twoich .vimrcktóry zestaw opcji szczególnych na podstawie na ścieżce.

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

Wtyczka działająca właściwie: http://www.vim.org/scripts/script.php?script_id=441

„Ta wtyczka szuka lokalnych plików vimrc w drzewie systemu plików aktualnie otwartego pliku. Domyślnie wyszukuje wszystkie pliki „.lvimrc” od katalogu pliku do katalogu głównego i ładuje je w odwrotnej kolejności. Nazwę pliku i ilość wczytanych plików można dostosować za pomocą zmiennych globalnych ”.

Zakładając, że inni programiści nie będą na to narzekać, zawsze możesz dodać ustawienia Vima do każdego pliku w komentarzach.

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

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

Właśnie w tym celu stworzyłem narzędzie typu open source. Zapomnij o nagłówkach, skanowaniu, konfiguracjach i lokalnych plikach vimrc.

Spróbuj pływać.

Pływać

swimto szybkie narzędzie do przełączania plików vimrc i tworzenia wygodnych aliasów. Oto krótka lista zastosowań. Zobacz repozytorium Github, aby zapoznać się z gifem instruktażowym i instrukcjami pobierania:

Stosowanie

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

Czytaj więcej

https://github.com/dawsonbotsford/swim

Po wypróbowaniu wtyczki localvimrc zasugerowanej na poprzednim plakacie, bardzo lubię mieć nieograniczoną kontrolę nad projektami nad ustawieniami vima.

Domyślnie prosi o potwierdzenie przed załadowaniem pliku .lvimrc, ale jest ustawienie, które automatycznie ładuje pliki .lvimrc. Niektórzy mogą postrzegać to jako lukę w zabezpieczeniach, ale działa zgodnie z reklamą.

Zdecydowałem się na .gitignore pliki .lvimrc. Alternatywnie możesz je zarejestrować jako formę wspólnych ustawień (rozszerzenie zakładek / spacji, tabulatory, inne ustawienia specyficzne dla projektu).

Jak wspomniano na saniach użycie tej wtyczki jest najlepszą opcją, jaką widziałem i używam. jerseyboy skomentował, że zalecane narzędzie prosi o potwierdzenie przed załadowaniem (tj. po otwarciu każdego pliku). Aby tego uniknąć, ustaw jako główną .vimrclistę .lvimrcplików lokalnych :

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

Oto wariacja na temat jamessana

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

Często będę uruchamiał vi bez konkretnego pliku, do którego skaczę, więc umożliwia to warunkowe ładowanie konfiguracji w oparciu o bieżący katalog roboczy. Wadą jest to, że konfiguracja nie jest stosowana na podstawie pliku, ale poza katalogiem roboczym.

Pracuję w kilku grupach, z których każda ma własne standardy tabulacji / wcięć / odstępów w C.

Pracuję jednocześnie z różnymi rodzajami open source. Tworzenie oddzielnych .vimrcplików i ponowna konfiguracja standardów formatowania nie jest praktyczne . Ponad dziesięć lat temu w końcu zmęczyło mnie zajmowanie się konfiguracją edytora i napisałem program, autotabktóry go obsłużył.

Gdy autotabjest skonfigurowany z sugerowanym przez Vima, za każdym razem, gdy ładujesz plik do Vima, autotabjest na nim wywoływany, a dane wyjściowe ustawień Vima autotabsą przekazywane do :setpolecenia.

autotabodczytuje kilka tysięcy wierszy z pliku, analizuje je i określa ustawienia parametrów expandtab, tabstopi shiftwidth.

Sprawdza, czy plik używa twardych tabulatorów, czy tylko spacji do wcięcia, i oblicza rozmiar wcięcia. Jeśli plik jest wcięty za pomocą tabulatorów, oblicza właściwy rozmiar tabulatora na podstawie renderowania próbki pliku przy użyciu różnych rozmiarów tabulatorów i oceniając go zgodnie z heurystykami, takimi jak wyrównanie linii do linii elementów wewnętrznych.

Działa na tyle dobrze, że przestałem modyfikować algorytm lata temu. Jeśli coś się pomyli, dzieje się tak prawie zawsze, ponieważ plik ma problemy z formatowaniem, takie jak użycie wielu konwencji w tym samym czasie.

Jest także „agnostyczny” w stosunku do typu pliku i dobrze współpracuje z wieloma różnymi językami. Używam go nie tylko w C, ale także w skryptach powłoki, Lisp, Makefiles, HTML i co masz.

Zauważ, że nie obsługuje innych parametrów formatowania, które mogą być specyficzne dla projektu, na przykład w plikach C, niezależnie od tego, czy caseetykiety w switchinstrukcji są wcięte, czy nie, lub czy listy argumentów funkcji opakowanej są po prostu wcięte lub wyrównane do otwierający nawias listy argumentów. Vim ma ustawienia na tego typu rzeczy, więc program można w wiarygodny sposób rozszerzyć, aby analizował styl i wyświetlał te parametry.

Szukając głównie tego samego problemu, znalazłem również wtyczkę Sauce: http://www.vim.org/scripts/script.php?script_id=3992

Twierdzi:

Sauce to lekki menedżer wielu plików vimrc, którego można użyć do załadowania różnych ustawień dla różnych środowisk. Krótko mówiąc, możesz utrzymywać wiele różnych plików ustawień Vima i ładować tylko te, których potrzebujesz, kiedy ich potrzebujesz.

Uważam za szczególnie interesujące, że przechowuje całą konfigurację w swoim katalogu danych, zamiast oczekiwać, że użytkownik posypie pliki dotfiles w całym systemie plików. Często jest to raczej kwestia osobistego gustu.

Jednak jeszcze go nie przetestowałem.

Możesz użyć stow do przełączania konfiguracji (dowolne pliki dotfiles, nie tylko .vimrc)

Zainstaluj stow:

$ apt install stow

Utwórz wiele katalogów dla każdej konfiguracji:

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

Umieść .vimrcw nich różne :

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

Teraz możesz utworzyć instancję konfiguracji vim-golang za pomocą tego polecenia (powinno być uruchomione w katalogu dotfiles):

~$ cd ~/dotfiles

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

Teraz jest połączony:

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

Jeśli chcesz zmienić konfigurację, po prostu wykonaj stowto ponownie :

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

Więcej przeczytania tutaj: Zarządzanie plikami dotfiles za pomocą GNU stow

Zalety : całkiem proste, bez zależności od wtyczek vim, może być używane do zarządzania wszystkimi plikami dot, nie tylko .vimrc.

Wady : konfiguracje są niezależne od siebie, musisz zarządzać / aktualizować każdą z nich osobno (jeśli nie przełączasz / aktualizujesz konfiguracji zbyt często - to nie będzie problem).