Vima nie trzeba chyba nikomu przedstawiać. Jest to jeden z najpopularniejszych edytorów konsolowych, o korzeniach tak starych, jak sam UNIX. Potężne narzędzie, dzięki któremu żonglerka tekstem, w ogromnej ilości formatów, staje się przyjemnym, a nie monotonnym zajęciem. Dlatego też, bez zbędnych wstępów teoretycznych, przejdziemy od razu do sedna, czyli do konfiguracji Vima.

Osobiście, w przeciągu ostatnich lat miałem okazje zetknąć się z wieloma edytorami tekstu, jednakże po zapoznaniu się z vimtutorem (man vimtutor), zaniechałem dalszych poszukiwań. Od trzech lat jest nim właśnie Vim.

Artykuł postanowiłem podzielić na część główną, w której przedstawię ogólne elementy konfiguracji środowiska typu IDE, oraz trzy poboczne, odnoszące się do konkretnych konfiguracji dla wybranych języków programowania: PHP, Python i C/C++.

Omawiana konfiguracja dotyczy wersji 7.1, lecz większość funkcji powinna działać na całej gałęzi 7.*. Przedstawię najciekawsze wtyczki z ich najistotniejszymi elementami, zainteresowanych czytelników odsyłam do zgłębiania dokumentacji.

Konfiguracja ogólna

Założyłem iż konfigurujemy Vima dla nowego użytkownika w systemie. Tak, by poprowadzić za rączkę przez kolejne etapy, nie pomijając niczego istotnego. Plik konfiguracyjny Vima, ładowany z katalogu domowego użytkownika, zwie się .vimrc. Domyślnie plik ten nie istnieje, ale nie będziemy tworzyli go od zera, zamiast tego skopiujemy go z już istniejącej konfiguracji (domyślnej w paczce z edytorem):

vim@ra:~$ pwd
/home/vim
vim@ra:~$ locate vimrc | grep vim | grep '\.vim$'
/usr/share/vim/vim71/gvimrc_example.vim
/usr/share/vim/vim71/vimrc_example.vim
vim@ra:~$ cp /usr/share/vim/vim71/vimrc_example.vim \\
.vimrc
vim@ra:~$

Potrzebna nam jeszcze prosta hierarchia katalogów, w której będziemy umieszczać wszystkie rozszerzenia Vima:

vim@ra:~$ mkdir .vim
vim@ra:~$ mkdir .vim/plugin
vim@ra:~$ mkdir .vim/doc
vim@ra:~$ mkdir .vim/after
vim@ra:~$ mkdir .vim/colors

MiniBufExplorer (minibufexpl.vim)

MiniBufExplorer jest bardzo użytecznym pluginem, bez którego nie wyobrażam sobie edycji wielu plików. Pomimo faktu, iż od wersji 7.0 edytor posiada zintegrowany mechanizm zakładek (tabów), to jednak MiniBufExplorer przy integracji z innymi pluginami wypiera domyślne tabowanie.

Ściągamy zatem plugin ze strony i wrzucamy go do naszego katalogu:

vim@ra:~$ wget http://www.vim.org/scripts/download_\\
script.php?src_id=3640 -O minibufexpl.vim
vim@ra:~$ mv minibufexpl.vim .vim/plugin/

MiniBufExplorer włącza się automatycznie przy edycji więcej niż jednego pliku na raz. Np.:

vim@ra:~$ vim a b

Jak widać, obszar roboczy podzielił się nam na dwa okna, z czego pierwsze od góry jest właśnie przeznaczone do listingu buforów. Do okienka możemy przejść w domyślny sposób poruszania się między oknami, czyli przez kombinacje klawiszy ctrl+w, a następnie kierunek – k (lub wpisując :MiniBufExplorer – wtedy okno explorera staje się aktywne). Po otwartych plikach możemy przeskakiwać Tabem, a wciskając Enter przechodzimy do edycji wybranego pliku. Dorzućmy drobną konfiguracje MiniBufEplorera do naszego pliku .vimrc:

let g:miniBufExplTabWrap = 5
map <C-b> :MiniBufExplorer<CR>
map <C-c> :CMiniBufExplorer<CR>
map < :bprev<CR>
map > :bnext<CR>
map b1 :b1<CR>
map b2 :b2<CR>
map b3 :b3<CR>
"...
map b30 :b30<CR>

Konfiguracja ta ustawia domyślny odstęp między otwartymi buforami na 5. Zmapowane zostały również kombinacje klawiszy ctrl+b i ctrl+c, pierwsza otwiera okno MiniBufExplorera, a druga je zamyka. Poza tym, wciskając < przechodzimy do poprzedniego bufora, a wciskając > do następnego. Poprzez wpisanie :b<numer> otwieramy bufor o określonym numerze. Oczywiście plugin umożliwia nam większe możliwości konfiguracyjne, dlatego odsyłam do źródła minibufexpl.vim, gdzie wszystko jest w przystępny sposób udokumentowane.

Project (project.vim)

Project jest pluginem, który daje nam możliwość swobodnej nawigacji po plikach projektu, czyli to, co każdy liczący się IDE powinien posiadać.

Pobieramy i rozpakowujemy paczkę:

vim@ra:~$ wget http://www.vim.org/scripts/download_\\
script.php?src_id=6273 -O project.tar.gz
vim@ra:~$ tar zxvf project.tar.gz -C .vim
plugin/project.vim
doc/project.txt
vim@ra:~$

Stwarzamy prostą strukturę quasi-projektu:

vim@ra:~$ mkdir my_project
vim@ra:~$ echo 'a' > my_project/a.txt
vim@ra:~$ echo 'b' > my_project/b.txt

Skrypt uruchamiamy przez polecenie :Project nazwa_pliku_z_projektem (opcjonalnie):

:Project

Aby utworzyć nowy projekt, wpisujemy ‘\C’ i wykonujemy następujące kroki:

• Enter the Name of the Entry: my_project – podajemy nazwę projektu,
• Enter the Absolute Directory to Load: /home/vim/my_project/ – ścieżka bezwzględna do projektu,
• Enter the CD parameter: <Enter> – pomijamy; jeśli argument ma wartość, to VIM ustawi aktualną ścieżkę podaną jako ten parametr, przy otwieraniu plików znajdujących się w tej sekcji,
• Enter the File Filter: *.txt – filter na pliki, filtry można łączyć, np. „.php\|*.js\|*.html”.

Mamy zatem gotowy projekt, który wygląda tak:

Po najechaniu na plik a.txt i wciśnięciu Entera w prawym oknie otworzy nam się zawartość tego pliku. Przechodzimy z powrotem do okna projektu (ctrl+w i następnie h) i otwieramy plik b.txt. Po wykonaniu tej operacji aktywuje nam się również MiniBufExplorer. Całość powinna wyglądać mniej więcej tak:

Project umożliwia grepowanie, zamykanie, otwieranie zgrupowanych plików. Daje nam także możliwość podpinania własnych poleceń pod skróty klawiszowe, np.:

:let g:proj_run1='!xterm -e "svn commit %f"'

Po najechaniu na plik z projektu (przy założeniu, że znajduje się on w repozytorium Subversion, oraz był modyfikowany), wciskając skrót ‘\1′ zostanie otwarte nowe okno z uruchomionym xtermem, które poprosi nas o opis zmian pliku, po zatwierdzeniu zostanie wykonany commit.

Oczywiście mamy możliwość minimalizacji i przywracania panelu projektu. Warto sobie to odpowiednio zmapować w ~/.vimrc, np. pod klawiszem F12:

nmap <silent> <F12> <Plug>ToggleProject

Plugin jak widać daje nam naprawdę dużo możliwości. Jedyną jego wadą jest brak odświeżania swojej struktury. Co prawda można tego dokonać ręcznie przez skrót \R, ale odświeży to nam jedynie liczbę plików, nowe podkatalogi zostaną zignorowane. Mimo wszystko, przy większych projektach Project strasznie ułatwia pracę w Vimie. Po pozostałą dokumentację odsyłam do helpa:

:help project

TagList (taglist.vim)

Kolejnym przydatnym pluginem jest TagList. Dodatek ten tworzy listę tagów (funkcje, klasy, zmienne itp.) na podstawie otwartych już plików.

Pobieramy zatem i instalujemy:

vim@ra:~$ wget http://www.vim.org/scripts/download_\\
script.php?src_id=7701 -O taglist.zip
vim@ra:~$ unzip taglist.zip -d .vim

Ponieważ wykorzystujemy poprzednie pluginy, musimy skonfigurować TagList w taki sposób, by pojawiał nam się po prawej stronie (domyślnie znajduje się po lewej, gdzie aktualnie uruchamia się nam plugin Project), a zatem dopisujemy do naszego ~/.vimrc:

let Tlist_Use_Right_Window = 1

I tworzymy nowy projekt, niech będzie to szkielet programu w C:

vim@ra:~$ mkdir c_project
vim@ra:~$ echo -ne "#include <stdio.h>nnint main(void)n\\
{ntreturn 0;n}n" > c_project/prog.c

:Project c_project/.project

• Enter the Name of the Entry: c_project
• Enter the Absolute Directory to Load: /home/vim/c_project/
• Enter the CD parameter: <Enter>
• Enter the File Filter: *.c\|*.h

Z lewego menu otwieramy nasz plik prog.c i wykonujemy polecenie:

:Tlist

Po tych operacjach całość powinna prezentować się tak:

Prawda, że wygląda to nieźle? TagList automatycznie generuje listę tagów dla każdego otwartego pliku, dodatkowo zaznacza sekcję, w której aktualnie się znajdujemy. Naturalnie można poruszać się po tagach i wciskając Enter przechodzić do wybranego. Po resztę informacji odsyłam do helpa (:help taglist).

Jeśli korzysta się z obu pluginów – Project i TagList, obszar roboczy wyraźnie się kurczy. Możemy temu zaradzić dzięki kolejnemu pluginowi.

ZoomWin (zoomwin.vim)

vim@ra:~$ wget http://www.vim.org/scripts/download_\\
script.php?src_id=5537 -O ZoomWin.vim.gz
vim@ra:~$ gunzip -c ZoomWin.vim.gz > .vim/plugin\
/zoomwin.vim

Plugin bywa bardzo użyteczny. Wystarczy w aktywnym oknie wykonać polecenie:

:ZoomWin

Wybrane okno zostanie powiększone do maksymalnych rozmiarów. W naszym przypadku ukryje tym samym Project i TagList. Przy ponownym wykonaniu tego polecenia wszystkie okna wracają do poprzedniego stanu. ZoomWin jednak „gryzie” się z Project ze względu na mapowanie klawiszy, tak więc w pliku ~/.vim/plugin/ZoomWin.vim, w linii numer 22, zamieniamy z:

nmap <unique> <c-w>o  <Plug>ZoomWin

na:

nmap <unique> <c-o>  <Plug>ZoomWin

Dzięki temu powiększanie danego okna mamy przypisany do kombinacji ctrl+o (<C-o>).

VimCommander (vimcommander.vim)

W Vimie nie mogłoby zabraknąć menedżera plików. Jednak ten domyślny, file-manager nie nadaje się do pracy w środowisku typu IDE. Dlatego przedstawiam wam kolejny wspaniały dodatek – VimCommander.

Instalujemy:

vim@ra:~$ wget http://www.vim.org/scripts/download_\\
script.php?src_id=8019 -O .vim/plugin/vimcommander.vim

I od razu mapujemy w ~/.vimrc:

noremap <silent> <F11> :cal VimCommanderToggle()<CR>

Teraz możemy ponownie otworzyć wcześniejszy projekt my_project i jego dwa pliki a.txt oraz b.txt, a następnie, będąc w oknie edycyjnym, wcisnąć F11:

Wtyczka umożliwia nam kopiowanie pomiędzy panelami (F5), usuwanie plików (F8), a także tworzenie nowych (Shift+F4). Po ponownym wciśnięciu F11 VimCommander znika. Reszta dokumentacji znajduje się w samym skrypcie vimcommander.vim.

Vimball (vimballPlugin.vim)

Vimball jest skryptem, który pomaga w dystrybucji pluginów. Vimballem można tworzyć paczki z pluginami, bądź też je rozpakowywać. Nam jest potrzebna ta druga opcja ze względu na format dystrybucji kolejnego dodatku. Ściągamy i instalujemy:

vim@ra:~$ cd .vim
vim@ra:~/.vim$ wget http://www.vim.org/scripts/download_\\
script.php?src_id=8743 -O vimball.tar.gz
vim@ra:~/.vim$ tar zxvf vimball.tar.gz
vim@ra:~/.vim$ chmod a+r autoload/vimball.vim doc\\
/pi_vimball.txt plugin/vimballPlugin.vim
vim@ra:~/.vim$ rm vimball.tar.gz

Nie ma co tutaj się rozwodzić. Jeśli kogoś interesuje tworzenie pluginów, to odsyłam do strony domowej skryptu: Vimball.

SnippetsEmu (snippetsEmu.vim)

Na fali Ruby on Rails i railcastów, w których to główne skrzypce grał Mac Osowy TextMate, popularne ostatnio stały się snippety. Chodzi o proste szablony ułatwiające pisanie powtarzających się fragmentów kodu, np. klas w pythonie.

Więc do dzieła, instalujemy:

vim@ra:~$ wget http://www.vim.org/scripts/download_\\
script.php?src_id=8450 -O snippy_plugin.vba
vim@ra:~$ wget http://www.vim.org/scripts/download_\\
script.php?src_id=8443 -O snippy_bundles.vba

Następnie otwieramy (pojedynczo) pliki w Vimie i rozpakowujemy je przez polecenie ‘:source’:

vim@ra:~$ vim snippy_plugin.vba
:source snippy_plugin.vba
vim@ra:~$ vim snippy_bundles.vba
:source snippy_bundles.vba

W ten sposób w ~/.vim/plugin pojawił się nowy plik – snippetsEmu.vim, natomiast w ~/.vim/after/ftplugin kilka plików *_snippets.vim. Teraz możemy otworzyć przykładowy plik do edycji, niech to będzie test.py i sprawdzić, czy snippety działają.

Wpisujemy def i wciskamy Tab, a oto efekt:

W ten oto sposób kolejno wypełniamy pola, przechodząc do następnego przy użyciu klawisza Tab. Listę wszystkich dostępnych snippetów znaleźć można przeglądając pliki ~/.vim/after/ftplugin/*_snippets.vim.

Omni completion

Omni completion to wbudowany mechanizm autouzupełniania w Vimie od wersji 7.0. Wystarczy podczas edycji pliku użyć skrótu ctrl+x i następnie ctrl+o (<C-x><C-o>) aby uzyskać liste proponowanych elementów. Przykład dla plików z rozszerzeniem css:

czy też .html:

Wybieramy odpowiedni element z listy i wciskając Enter wstawiamy do tekstu. Osobiście nigdy z tego nie korzystałem, ale skoro to zintegrowany mechanizm to wnioskuje, że innym jest pomocny. Dodatkowo mamy również możliwość rozwinięcia listy słów użytych w otwartym pliku. Skrót klawiaturowy do takiej operacji to ctrl+x i ctrl+n (<C-x><C-n>).

Spell

Spell to mechanizm słownikowy do sprawdzania/autouzupełniania wyrazów. Domyślnie jest on wyłączony i posiada jedynie bazę słów angielskich. Dodajmy zatem polskie słownictwo:

vim@ra:~$ mkdir .vim/spell
vim@ra:~$ wget ftp://ftp.vim.org/pub/vim/runtime/spell\\
/pl.utf-8.spl -O .vim/spell/pl.utf-8.spl
vim@ra:~$ wget ftp://ftp.vim.org/pub/vim/runtime/spell\\
/pl.iso-8859-2.spl -O .vim/spell/pl.iso-8859-2.spl

Dopisujemy do ~/.vimrc linijkę ustawiającą język do sprawdzania (można ustawić kilka, kolejne języku wpisujemy po przecinku):

set spelllang=pl

Aby włączyć sprawdzenie pisowni, w Vimie wpisujemy:

:set spell

Oczywiście polecenie można sobie wygodnie zmapować, aczkolwiek osobiście dla sprawdzania pisowni nie mam ustawionego skrótu klawiaturowego, dlatego również tutaj na siłę nie będę go wprowadzać. Oto przykładowe zrzuty Vima z uruchomionym Spellem:

Tak wygląda tekst z błędami:

Przechodzimy do początku podświetlonego wyrazu (skrót [s cofa do poprzedniego błędnego wyrazu, a ]s do następnego) i w trybie poleceń wciskamy: z=

Wybieramy słowo, wciskamy Enter i błędne zostaje zastąpione prawidłowym.

Closetag (closetag.vim)

Closetag to bardzo użyteczny skrypt do domykania otwartych tagów XML-owych. Przydatne, jeśli sporo piszemy w kodzie XHTML czy też czystym kodzie XML.

Prosta instalacja:

vim@ra:~$ wget http://www.vim.org/scripts/download_\\
script.php?src_id=4318 -O .vim/plugin/closetag.vim

I dopisujemy do .vimrc linijkę, która uruchamia skrypt dla plików o rozszerzeniach .html, .xml oraz .xsl:

:au Filetype html,xml,xsl source ~/.vim/plugin/closetag.vim

W przypadku, gdy mamy następujący kod XHTML-a:

<div><span>
tekst

W trybie wprowadzania wystarczy wcisnąć dwukrotnie ctrl+_ (<C-_>) i oba otwarte tagi zostaną zamknięte.

IDE dla PHP

Lista powyższych skryptów tworzy całkiem rozbudowane środowisko dla programistów PHP (spełnia wszystkie moje oczekiwania), lecz można jeszcze wspomnieć o dwóch dodatkach:

• DBGp – plugin jest interaktywnym klientem xdebuga, czyli ZEND-owego debugera dedykowanego PHP, proces instalacji opisany jest na stronie: http://tech.blog.box.net/2007/06/20/how-to-debug-php-with-vim-and-xdebug-on-linux/
• phpDocumentor – plugin, tworzący automatycznie, według stałego schematu, dokumentacje w postaci komentarza dla funkcji, klas itp.

IDE dla Pythona

Pydiction (pydiction.vim)

Pydiction jest pluginem, który poszerza możliwości autouzupełniania pythona o funkcje różnych bibliotek.

Instalujemy:

vim@ra:~$ wget http://www.vim.org/scripts/download_\\
script.php?src_id=2668 -O .vim/pydiction-0.5.tar.gz
vim@ra:~$ cd .vim
vim@ra:~/.vim$ tar zxvf pydiction-0.5.tar.gz
pydiction-0.5/
pydiction-0.5/LICENSE.txt
pydiction-0.5/pydiction
pydiction-0.5/pydiction.py
pydiction-0.5/README
vim@ra:~/.vim$

Aby zacząć korzystać z autouzupełniania należy jeszcze dopisać następujące linijki do ~/.vimrc:

if has("autocmd")
autocmd FileType python set complete+=k/home/vim/.vim\\
/pydiction-0.5/pydiction isk+=.,(
endif " has("autocmd")

Teraz otwieramy przykładowy plik i sprawdzamy działanie. Po wpisaniu os.lis wciskamy kombinacje klawiszy ctrl+n (<C-n>) i otrzymujemy:

Oczywiście ścieżka do Pydiction musi być ustawiona na miejsce, w którym plugin został rozpakowany.

vdb (vdb.vim)

Vim posiada również pluginy umożliwiające interaktywne debugowanie różnych języków, w tym pythona. Aczkolwiek nigdy nie korzystałem z takiego rozwiązania, jednakże warto pokazać, że i jak to działa.

Instalujemy więc ów dodatek:

vim@ra:~$ wget http://www.vim.org/scripts/download_\\
script.php?src_id=8865 -O vdb-0.4.3.tar.gz
vim@ra:~$ tar zxvf vdb-0.4.3.tar.gz
COPYING
README
quick-start.txt
todo
vdb.vim
vim@ra:~$ mv vdb.vim .vim/plugin/
vim@ra:~$ wget http://www.vim.org/scripts/download_\\
script.php?src_id=8866 -O cpdb.py
vim@ra:~$ sudo mv cpdb.py /bin
vim@ra:~$ sudo chmod +x /bin/cpdb.py

Po napisaniu prostego skryptu i wywołaniu polecenia

:VDBShowConsole

Uruchamia się nam:

Sposób nawigacji opisany jest w pliku quick-start.txt, więc wszystkich tych, którzy zainteresowali się dodatkiem, odsyłam własnie do niego.

IDE dla C/C++

c.vim

c.vim jest rozbudowanym pluginem przeznaczonym dla środowiska C/C++. Dostarcza ogrom snippetów, skrótów klawiaturowych kompilujących, linkujących czy też uruchamiających programy. Vim wspiera make-a, dzięki czemu mamy możliwość interaktywnego śledzenia błędów.

Instalacja jest całkiem łatwa i nie powinna sprawić żadnych problemów:

vim@ra:~$ wget http://www.vim.org/scripts/download_\\
script.php?src_id=9146 -O .vim/cvim.zip
vim@ra:~$ cd .vim/
vim@ra:~/.vim$ unzip cvim.zip

W trybie tekstowym (_nie_ gVimowym) zapisujemy i kompilujemy program przez wpisanie \rc, a uruchamiamy skrótem \rr. Oczywiście istnieje całe mnóstwo innych skrótow i kombinacji, lecz nie będę ich tutaj teraz przybliżał. Po więcej informacji odsyłam do dokumentacji.

a.vim

a.vim to prosty plugin umożliwiający szybkie przejścia między plikami ze źródłem, a plikami nagłówkowymi (.c i .h) o tych samych nazwach.

Instalacja:

vim@ra:~$ wget http://www.vim.org/scripts/download_\\
script.php?src_id=7218 -O .vim/plugin/a.vim

Aby sprawdzić działanie wystarczy utworzyć dwa pliki, np. prog.c, prog.h, a następnie otworzyć prog.c. Po wpisaniu polecenia:

:A

Otworzony zostanie plik prog.h (o ile jeszcze nie został otwarty) i ustawiony jako aktywny bufor. Przy ponownym wpisaniu tego polecenia, aktywny staje się bufor z plikiem prog.c.

Dodatki

rails.vim

Z rosnącą popularnością RoRa musiał pojawić się w końcu także plugin do Vima ułątwiający obsługę tego frameworka. Plugin jest bardzo aktywnie rozwijany, mamy także możliwość obejrzenia krótkiego filmu ilustrującego możliwości tego dodatku:

• screencast
• strona domowa projektu
• rails.vim

Gorąco zachęcam do obejrzenia, prezentuje się naprawdę ciekawie.

vimshell

Vimshell to łata, która umożliwia uruchomienie shella wewnątrz Vima. Zasadniczo ten sam efekt można osiągnąć odpowiednio splitując screena. Zdaje się to potwierdzać fakt, iż ostatnie wydanie tej łaty było na wersję 7.0, więc projekt chyli się raczej ku końcowi. Niemniej można zobaczyć, że i coś takiego jest możliwe w naszym edytorze.

pida

Pida jest ciekawie zapowiadającym się projektem, tworzącym środowisko, do którego można zintegrować wybrany edytor, w tym także Vima. GUI prezentuje się bardzo dobrze, ale brakuje tutaj funkcji, która daje przewagę Vimowi nad innymi edytorami – błyskawicznej obsługi każdej akcji z poziomu klawiatury. Przez krótką chwilę bawiłem się tym edytorem i bez żalu powróciłem do „czystego” VIMa.

vimperator

Na zakończenie – vimperator. Ta dumnie brzmiąca nazwa to projekt, dzięki któremu mamy możliwość sterowania Firefoxem tak, jakby był on Vimowym edytorem. Nie wiem na ile jest to używalne, gdyż nie miałem czasu zapoznać się z tym geekowym projektem, ale jeśli mogę tym obsłużyć rozbudowane formularze bez dotknięcia myszki, to wchodzę w to. Jeśli ktoś wie czy jest to możliwe, to byłbym wdzięczny za jakiekolwiek informacje na ten temat.

Podsumowanie

Jak widać, Vim nie jest zwykłym edytorem. Nie jest również taki straszny, jak go malują. Stanowi za to potężne narzędzie, które znacznie przyspiesza i ułatwia nam pracę.

Osobiście, pomimo czasu jaki spędzam dziennie z tym edytorem, cały czas ucze się czegoś nowego. Vim posiada naprawdę ogrom możliwości, a funkcja dołączania pluginów zamazuje granice nieosiągalnego. Zachęcam gorąco do przejrzenia repozytorium pluginów na stronie projektu: http://www.vim.org/scripts/index.php.

W razie pytań, kontakt: p.bylina@gmail.com.

Bonus (filmiki)

• Vim Powa: Can Your Editor do This?
• vimteaser
• Vim7 as an IDE for Web applications

Skład: MiszczQ (Piotr Krzysztof Soboń)