Tvorba pluginů pro Vim s využitím programovacího jazyka Lua (dokončení)

Obsah

1. Tvorba pluginů pro Vim s využitím programovacího jazyka Lua (dokončení)

2. Ukázka dalších možností příkazu luado

3. První demonstrační příklad: základní varianta náhrad mezer za znaky <Tab>

4. Rozhraní pro manipulaci s buffery

5. Druhý demonstrační příklad: přidání hlavičky se jménem uživatele na začátek souboru a patičky s datem vzniku na konec souboru

6. Rozhraní pro základní manipulaci s okny

7. Třetí demonstrační příklad: zakomentování aktuálního řádku

8. Čtení aktuálního nastavení Vimu, bufferu či okna z Lua skriptu

9. Čtvrtý demonstrační příklad: vylepšený způsob zakomentování aktuálního řádku

10. Pátý demonstrační příklad: vylepšená varianta náhrad mezer za znaky <Tab>

11. Repositář s demonstračními příklady

12. Odkazy na Internetu

1. Tvorba pluginů pro Vim s využitím programovacího jazyka Lua (dokončení)

V první části článku pojednávajícího o tvorbě přídavných modulů (pluginů) určených pro textový editor Vim s využitím programovacího jazyka Lua jsme si řekli, jakým způsobem je realizováno rozhraní mezi Vimem a Luou, i jaké základní příkazy je možné ve Vimu použít ve chvíli, kdy je nutné vyhodnotit nějaký výraz naprogramovaný v jazyku Lua či kdy se má spustit nějaký rozsáhlejší skript. Připomeňme si, že test, zda konkrétní instance Vimu obsahuje rozhraní pro jazyk Lua či pro jiný podporovaný programovací jazyk, je vlastně velmi jednoduchý, protože je možné si nechat zobrazit výsledek volání standardní vimovské funkce has(), které se předá jméno vlastnosti, jejíž podporu chceme zjistit. Pokud je výsledkem volání funkce has() jednička, je daná vlastnost podporována, pokud se vrátí nula, vlastnosti podporována není (ve Vimu, resp. přesněji řečeno ve Vim Scriptu, se namísto pravdivostních hodnot true/false používají celá čísla, podobně jako například v céčku, navíc se u jména vlastnosti ignoruje velikost písmen):

:echo has("Lua")

Dále jsme si v předchozím článku řekli, že je možné relativně snadno zkombinovat Vim Script s programovacím jazykem Lua, a to především pomocí příkazu :lua, který lze použít jak pro volání jednotlivých příkazů (řádek po řádku):

lua x = 6
lua y = 7
lua print("The Answer to the Ultimate Question of Life, the Universe, and Everything: " .. x*y)

tak i pro spouštění rozsáhlejších skriptů, resp. přesněji řečeno bloků programového kódu:

lua << EOF
local x = 6
local y = 7
print("The Answer to the Ultimate Question of Life, the Universe, and Everything: " .. x*y)
EOF

Alternativně je též možné použít tečku jako implicitní ukončovač bloku kódu napsaného v jazyku Lua (v předchozím skriptu to byl identifikátor EOF):

lua <<
local x = 6
local y = 7
print("The Answer to the Ultimate Question of Life, the Universe, and Everything: " .. x*y)
.
" ^ tecka na zacatku predchoziho radku

Na závěr této kapitoly si ještě zrekapitulujme, které příkazy související s konektorem zajišťujícím komunikaci mezi programovacím jazykem Lua a Vimem je možné z Vimu volat (v příkazovém režimu):

2. Ukázka dalších možností příkazu luado

V tabulce zobrazené na konci předchozí kapitoly je napsáno, že příkaz :luado dokáže volat vybraný příkaz (napsaný v Lue) pro všechny řádky v aktivním bufferu, či alternativně pro vybrané řádky. Pojďme si tuto možnost otestovat na skriptu, v němž je deklarována funkce nazvaná addLineNumber. Tato funkce se pro každý řádek volá příkazem :luado, který této funkci předá dva parametry – obsah textového řádku a jeho číslo. Návratová hodnota funkce potom slouží k úpravě daného řádku v aktuálním bufferu:

-- Demonstracni priklad s ukazkou pouziti prikazu luado
-- Pavel Tisnovsky 2016
--
-- Nacteni prikladu do Vimu se provede prikazem:
-- :luafile add_line_number.lua
 
 
 
-- Funkce urcena pro pridani cisla radku na kazdy (vybrany)
-- radek v aktualnim bufferu
function addLineNumber(line, linenr)
    return linenr .. " " .. line
end
 
 
 
-- Namapovani volani funkce na klavesovou zkratku ,c
vim.command("map ,n :luado return addLineNumber(line, linenr)<cr>")

Poznámka: zdrojový kód tohoto demonstračního příkladu naleznete na adrese https://github.com/tisnik/pre­sentations/blob/master/vim/vim_lu­a/add_line_number.lua.

Vzhledem k tomu, že je volání příkazu :luado namapováno pomocí map na klávesovou zkratku ,n, lze čísla řádků do aktuálního bufferu přidat například takto:

Podívejme se nyní, jak operace vypadá v praxi:

Obrázek 1: Testovací soubor před spuštěním skriptu add_line_number.

Obrázek 2: Čísla řádků jsou přidána do celého bufferu klávesovou zkratkou ,n.

Obrázek 3: Výběr bloku.

Obrázek 4: Čísla řádků byla po příkazu ,n přidána pouze do vybraného bloku.

3. První demonstrační příklad: základní varianta náhrad mezer za znaky <Tab>

Dnešní první demonstrační příklad může posloužit k doplnění již existujícího příkazu :retab. Připomeňme si, že tento příkaz dokáže převést znaky <Tab> na počet mezer určený konfigurační volbou ts či tabstop, ovšem pouze v případě, že je současně nastavena konfigurační volba expandtab. Zpětný převod zajišťuje příkaz :retab! (s vykřičníkem na konci), ovšem pouze pokud není nastavena volba expandtab. Demonstrační příklad je velmi jednoduchý – dokáže nahradit čtyři mezery (což je prozatím konstanta, níže si příklad vylepšíme) za znak <Tab>, a to nezávisle na nastavení Vimu:

-- Demonstracni priklad s ukazkou pouziti prikazu luado
-- Pavel Tisnovsky 2016
--
-- Nacteni prikladu do Vimu se provede prikazem:
-- :luafile reretab1.lua
 
 
 
-- Funkce urcena pro nahrazeni ctyr mezer znakem <Tab>
function reretab(line, linenr)
    local tabstop = 4
    local spaces = string.rep(" ", tabstop)
    -- nahrazeni mezer za znaky <Tab>
    return string.gsub(line, spaces, "\t")
end
 
 
 
-- Namapovani volani funkce na klavesovou zkratku ,c
vim.command("map ,r :luado return reretab(line, linenr)<cr>")

Poznámka: zdrojový kód tohoto demonstračního příkladu naleznete na adrese https://github.com/tisnik/pre­sentations/blob/master/vim/vim_lu­a/reretab1.lua.

Poznámka 2: opět platí, že je možné provést náhradu pouze ve vybrané části bufferu, přičemž pro výběr lze využít bloky, čísla řádků, vyhledávání atd.

Opět se podívejme na způsob použití, který je zde velmi jednoduchý:

Obrázek 5: Původní zdrojový soubor, v němž se nepoužívají znaky <Tab>.

Obrázek 6: Po použití klávesové zkratky ,r se zdánlivě nic nestalo…

Obrázek 7: Zadáním volby :set list je odhaleno, že k náhradě skutečně došlo.

Otázka pro čtenáře: jakým způsobem byste upravili skript tak, aby došlo k náhradě jen na začátku řádku a nikoli už ve zbytku zdrojového kódu?

4. Rozhraní pro manipulaci s buffery

Příkaz :luado sice může být v mnoha případech užitečný, ovšem někdy je zapotřebí manipulovat s obsahem bufferu sofistikovanějším způsobem. Zde přichází na řadu volání funkce vim.buffer(), která vrátí objekt představující aktuální buffer, popř. buffer, jehož jméno je této funkci předáno. Pro jednoduchost prozatím uvažujme, že se funkci vim.buffer() nepředávají žádné parametry a vrátí se tedy objekt představující aktuální buffer, který uložíme do proměnné b. Tento objekt obsahuje několik vlastností a přetížených operátorů:

Taktéž je k dispozici několik metod, které se v jazyce Lua volají způsobem objekt:metoda, tedy s dvojtečkou (jde o pouhý syntaktický cukr):

Podívejme se nyní na některé možnosti, které nám nabízí vlastnosti a metody objektu typu buffer. Jedná se skutečně pouze o demonstrační příklady, jejichž užitečnost je mnohdy sporná, protože pro ně existuje jednodušší ekvivalent přímo ve Vimu, ovšem při psaní delších skriptů se mohou tyto příklady hodit:

Výpis počtu řádků v aktuálním bufferu:

:lua print(#vim.buffer())

Smazání prvního řádku v aktuálním bufferu:

:lua vim.buffer()[1]=nil

Smazání posledního řádku v aktuálním bufferu:

:lua vim.buffer()[#vim.buffer()]=nil

Výpis podrobnějších informací o bufferu (skript je nutné načíst příkazem :luafile):

local b = vim.buffer()
print("Buffer info:")
print("Short name: " .. b.name)
print("Long name:  " .. b.fname)
print("Lines:      " .. #b)
print("Buffer #:   " .. b.number)

5. Druhý demonstrační příklad: přidání hlavičky se jménem uživatele na začátek souboru a patičky s datem vzniku na konec souboru

Vzhledem k tomu, že skripty napsané v programovacím jazyku Lua mohou využívat všechny standardní moduly, které jsou společně s interpretrem Lua dodávány, můžeme funkce nabízené těmito moduly použít i při manipulaci s buffery. V následujícím demonstračním příkladu se po jeho zavolání příkazem :luafile insert_template.lua vloží na začátek aktuálního bufferu informace o uživateli, který buffer edituje a na konec bufferu se vloží aktuální datum, a to včetně (lokalizovaného) dne v týdnu. Pro získání informace o uživateli se použije standardní funkce os.getenv(„USER“), zformátované datum vrací funkce os.date(„%Y-%m-%d (%A)“. Povšimněte si, že pro vložení nových řádků na začátek (přesněji řečeno před začátek) bufferu se používá metoda buffer:insert(řetězec, 0) a pro vložení na konec (za konec) bufferu metoda buffer:insert(řetězec), což ostatně odpovídá informacím z předcházející kapitoly:

-- Demonstracni priklad s ukazkou manipulace s bufferem:
-- vlozeni informaci na zacatek i na konec bufferu.
-- Pavel Tisnovsky 2016
--
-- Nacteni prikladu do Vimu se provede prikazem:
-- :luafile insert_template
 
 
 
-- ziskame objekt predstavujici aktualni buffer
local b = vim.buffer()
 
 
-- pridani informaci na zacatek bufferu
b:insert("-------------------------------", 0)
b:insert("Edited by: " .. os.getenv("USER"), 0)
b:insert("-------------------------------", 0)
 
-- pridani informaci na konec bufferu
b:insert("Created at: " .. os.date("%Y-%m-%d (%A)"))

Poznámka: zdrojový kód tohoto demonstračního příkladu naleznete na adrese https://github.com/tisnik/pre­sentations/blob/master/vim/vim_lu­a/insert_template.lua.

Otestování funkčnosti:

Obrázek 8: Obsah bufferu před spuštěním skriptu.

Obrázek 9: Obsah bufferu po spuštění skriptu (povšimněte si, že programovací jazyk Lua a jeho funkce dodržují nastavení LOCALE).

6. Rozhraní pro základní manipulaci s okny

Podobně jako existuje objekt reprezentující buffer, který je získán funkcí vim.buffer() je možné získat i objekt typu window přečtený funkcí vim.window(). I u tohoto objektu máme k dispozici několik atributů a metod. Předpokládejme, že výsledek volání funkce vim.window() je uložen do proměnné o:

Příklad změny výšky okna na dvacet řádků:

lua vim.window().height=20

Výpis metod pro objekt w:

7. Třetí demonstrační příklad: zakomentování aktuálního řádku

Informace, se kterými jsme se seznámili v předchozích dvou kapitolách, nyní využijeme v dalším demonstračním příkladu, v němž je implementována funkce, která po svém zavolání zakomentuje ten řádek v aktuálním bufferu, na němž se nachází textový kurzor. Pro zakomentování byly (alespoň prozatím) zvoleny znaky //, což znamená, že příklad bude kompatibilní například s programovacími jazyky C (od C99), C++, C#, Java či JavaScript (pokryje tedy majoritu případů :-). Funkce pojmenovaná příhodně commentLine nejprve získá referenci na aktuální buffer, posléze referenci na okno spojené s tímto bufferem a nakonec s využitím těchto informací získá obsah toho řádku v bufferu, na němž se nachází textový kurzor. Následně se s využitím běžných řetězcových operací programovacího jazyka Lua vytvoří nový obsah tohoto řádku a posledním příkazem se modifikuje obsah aktuálního bufferu. Volání funkce commentLine je namapováno na klávesovou zkratku ,c (což lze samozřejmě snadno změnit):

-- Demonstracni priklad s ukazkou manipulace s okny a buffery.
-- Pavel Tisnovsky 2016
--
-- Nacteni prikladu do Vimu se provede prikazem:
-- :luafile comment_line_1.lua
 
 
 
-- Funkce urcena pro zakomentovani aktualniho radku
-- (bez detekce pouziteho programovaciho jazyka)
function commentLine()
    -- ziskame objekt predstavujici aktualni buffer
    local buffer = vim.buffer()
    -- ziskame objekt predstavujici aktualni okno a z nej
    -- vycteme cislo radku, na nemz se nachazi textovy kurzor
    local lineNumber = vim.window().line
    -- precteni puvodniho obsahu radku v bufferu
    local line = buffer[lineNumber]
    print("Changing the line #" .. lineNumber .. ": " .. line)
    line = "// " .. line
    -- modifikace radku v bufferu
    buffer[lineNumber] = line
end
 
 
 
-- Namapovani volani funkce na klavesovou zkratku ,c
vim.command("map ,c :lua commentLine()<cr>")

Poznámka: zdrojový kód tohoto demonstračního příkladu naleznete na adrese https://github.com/tisnik/pre­sentations/blob/master/vim/vim_lu­a/comment_line₁.lua.

Obrázek 10: Původní obsah bufferu.

Obrázek 11: Zakomentování některých řádků po stisku klávesové zkratky ,c.

8. Čtení aktuálního nastavení Vimu, bufferu či okna z Lua skriptu

V mnoha skriptech je nutné nějakým způsobem zjistit aktuální nastavení celého Vimu, nastavení namapovaná pro aktuální buffer či nastavení namapovaná pro aktuální okno. Připomeňme si, že konfigurační volby se nastavují příkazem :set, a to následujícím způsobem:

:set volba=hodnota

Poněkud komplikovanější je přečtení konfigurační volby. Ve Vim Scriptu k tomu slouží znak &, což znamená, že lze například napsat:

:echo &syntax
:echo &fileencoding
:echo &fileformat
:echo &lines

Ve skriptech napsaných v programovacím jazyce Lua se musíme spokojit s použitím funkce vim.eval(), které se předá jakýkoli výraz Vim Scriptu, který se spustí, vyhodnotí a jeho výsledek se vrátí zpět. Lze tedy například napsat:

:lua print(vim.eval("fileformat"))

9. Čtvrtý demonstrační příklad: vylepšený způsob zakomentování aktuálního řádku

Demonstrační příklad pro zakomentování aktuálního řádku, s nímž jsme se seznámili v sedmé kapitole, je možné vylepšit, a to takovým způsobem, že se na základě detekce programovacího jazyka použitého v aktuálně otevřeném bufferu použijí korektní znaky pro komentáře. Jak je však možné detekovat použitý programovací jazyk? Možností je více, ovšem pravděpodobně nejjednodušší bude přečtení nastavení konfigurační volby syntax, protože právě na základě této volby se textový editor Vim rozhodne, jakým způsobem se má obarvit obsah bufferu. Detekce syntaxe realizovaná Vimem (resp. přesněji řečeno skripty, které jsou součástí Vimu), sice není stoprocentní, ale pro naše účely a pro vybrané programovací jazyky je více než dostačující. Přečtení konfigurační volby syntax se v jazyku Lua provede příkazem:

local selectedSyntax = vim.eval("&syntax")

Na základě získané hodnoty se pak vybere vhodný znak či znaky použité pro jednořádkové komentáře z této tabulky:

Následuje výpis úplného zdrojového kódu demonstračního příkladu:

-- Demonstracni priklad s ukazkou manipulace s okny a buffery
-- i se ctenim aktualniho nastaveni
-- Pavel Tisnovsky 2016
--
-- Nacteni prikladu do Vimu se provede prikazem:
-- :luafile comment_line_2.lua
 
 
 
-- Funkce vracejici znaky urcene pro zakomentovani radku.
-- O ktere znaky se jedna, se zjisti na zaklade konfiguracni volby
-- "syntax"
function getCommentChars()
    local languages = {
        lua        = "--",
        c          = "//",
        cpp        = "//",
        java       = "//",
        javascript = "//",
        vim        = "\"",
        clojure    = ";",
        sh         = "#",
        python     = "#",
        basic      = "REM"}
    -- ziskani informace o aktualne nastavene syntaxi
    local selectedSyntax = vim.eval("&syntax")
    -- vraceni znaku z tabulky (popr. vraceni nil ve chvili,
    -- kdy je syntaxe neznama)
    return languages[selectedSyntax]
end
 
 
 
-- Funkce pro zakomentovani aktualniho radku
function commentLine()
    -- ziskame objekt predstavujici aktualni buffer
    local buffer = vim.buffer()
    -- ziskame objekt predstavujici aktualni okno a z nej
    -- vycteme cislo radku, na nemz se nachazi textovy kurzor
    local lineNumber = vim.window().line
    -- precteni puvodniho obsahu radku v bufferu
    local line = buffer[lineNumber]
    local commentChars = getCommentChars()
 
    -- pokud je znama syntaxe, provede se zakomentovani
    if commentChars then
        print("Changing the line #" .. lineNumber .. ": " .. line)
        line = commentChars .. " " .. line
        -- modifikace radku v bufferu
        buffer[lineNumber] = line
    end
end
 
 
 
-- Namapovani volani funkce na klavesovou zkratku ,c
vim.command("map ,c :lua commentLine()<cr>")

Poznámka: zdrojový kód tohoto demonstračního příkladu naleznete na adrese https://github.com/tisnik/pre­sentations/blob/master/vim/vim_lu­a/comment_line₂.lua.

Příklady použití:

Obrázek 12: Zdrojový kód psaný v Clojure před zakomentováním řádků.

Obrázek 13: Zdrojový kód psaný v Clojure po zakomentování řádků.

Obrázek 14: Zdrojový kód psaný v C před zakomentováním řádků.

Obrázek 15: Zdrojový kód psaný v C po zakomentování řádků.

Obrázek 16: Zdrojový kód psaný v Pythonu před zakomentováním řádků.

Obrázek 17: Zdrojový kód psaný v Pythonu po zakomentování řádků.

10. Pátý demonstrační příklad: vylepšená varianta náhrad mezer za znaky <Tab>

V dnešním pátém a současně i posledním demonstračním příkladu poněkud vylepšíme již popsaný příklad reretab1.lua. Vylepšení (i když ve skutečnosti jen velmi malé) spočívá v tom, že se za znaky <Tab> nenahrazují vždy čtyři sousední mezery, ale tolik mezer, kolik si uživatel nastavil v konfigurační volbě tabstop příkazem:

:set tabstop=počet_mezer

či zkráceně jen:

:set ts=počet_mezer

Pro přečtení numerické hodnoty uložené v této konfigurační volbě se používá volání funkce vim.eval(), s níž jsme se již seznámili:

vim.eval("&ts")

Vzhledem k tomu, že se nahrazení může provést na všech řádcích aktivního bufferu, lze pro zavolání skriptu použít příkaz :luado, což je zajištěno mapováním:

vim.command("map ,r :luado return reretab(line, linenr)<cr>")

Následuje výpis zdrojového kódu tohoto demonstračního příkladu:

-- Demonstracni priklad s ukazkou pouziti prikazu luado
-- Pavel Tisnovsky 2016
--
-- Nacteni prikladu do Vimu se provede prikazem:
-- :luafile reretab2.lua
 
 
 
-- Funkce urcena pro nahrazeni mezer znakem <Tab>
function reretab(line, linenr)
    -- volba tabstob ci ts obsahuje pocet mezer
    local tabstop = vim.eval("&ts")
    local spaces = string.rep(" ", tabstop)
    -- nahrazeni mezer za znaky <Tab>
    return string.gsub(line, spaces, "\t")
end
 
 
 
-- Namapovani volani funkce na klavesovou zkratku ,c
vim.command("map ,r :luado return reretab(line, linenr)<cr>")

Poznámka: zdrojový kód tohoto demonstračního příkladu naleznete na adrese https://github.com/tisnik/pre­sentations/blob/master/vim/vim_lu­a/reretab2.lua.

11. Repositář s demonstračními příklady

Všechny demonstrační příklady, s nimiž jsme se v dnešním článku seznámili, byly, podobně jako v předchozích částech tohoto seriálu, uloženy do Git repositáře umístěného na GitHubu (https://github.com/tisnik/pre­sentations):

12. Odkazy na Internetu

1. Seriál o programovacím jazyku Lua
   http://www.root.cz/serialy/pro­gramovaci-jazyk-lua/
2. Lua (programming language)
   http://en.wikipedia.org/wi­ki/Lua_(programming_langu­age)
3. Lua 5.2 sources
   http://www.lua.org/source/5.2/
4. Pyclewn installation notes
   http://pyclewn.sourceforge­.net/install.html
5. pip Installation
   https://pip.pypa.io/en/la­test/installing.html
6. Clewn
   http://clewn.sourceforge.net/
7. Clewn installation
   http://clewn.sourceforge.net/in­stall.html
8. Clewn – soubory
   http://sourceforge.net/pro­jects/clewn/files/OldFiles/
9. Writing Vim Plugins
   http://stevelosh.com/blog/2011/09/wri­ting-vim-plugins/
10. how to understand this vim script?
    http://stackoverflow.com/qu­estions/12625091/how-to-understand-this-vim-script
11. Novinky ve VIM 7: Skriptovací jazyk
    http://www.root.cz/vim-sedm-druha-cast/
12. DirDiff.vim : A plugin to diff and merge two directories recursively.
    http://www.vim.org/scripts/scrip­t.php?script_id=102
13. vim-dirdiff na GitHubu
    https://github.com/will133/vim-dirdiff
14. fakeclip : pseudo clipboard register for non-GUI version of Vim
    http://www.vim.org/scripts/scrip­t.php?script_id=2098
15. vim-fakeclip na GitHubu
    https://github.com/kana/vim-fakeclip
16. vim-fakeclip: Dokumentace
    http://kana.github.io/con­fig/vim/fakeclip.html
17. Vim Multiple Cursors na GitHubu
    https://github.com/terryma/vim-multiple-cursors
18. SLIME (Wikipedia)
    http://en.wikipedia.org/wiki/SLIME
19. vim-slime na GitHubu
    https://github.com/jpalardy/vim-slime
20. vi Editor Commands
    http://www.cs.rit.edu/~cslab/vi­.html#A1.4
21. vi Manual
    http://www.cs.fsu.edu/gene­ral/vimanual.html
22. Mastering the Vi Editor
    http://www.susnet.uk/mastering-the-vi-editor
23. Using undo branches
    http://vim.wikia.com/wiki/U­sing_undo_branches
24. Gundo
    http://sjl.bitbucket.org/gundo.vim/
25. Vim as a Python IDE, or Python IDE as Vim
    http://blog.jetbrains.com/pychar­m/2013/06/vim-as-a-python-ide-or-python-ide-as-vim/
26. histwin na GitHubu
    https://github.com/chrisbra/his­twin.vim
27. histwin.vim : Browse the undo tree
    http://www.vim.org/scripts/scrip­t.php?script_id=2932
28. undotree.vim : Display your undo history in a graph
    http://www.vim.org/scripts/scrip­t.php?script_id=4177
29. Surround
    http://www.bestofvim.com/plu­gin/surround/
30. SnipMate
    http://www.bestofvim.com/plu­gin/snipmate/
31. Getting a Clojure REPL in Vim With VimClojure, Nailgun, and Leiningen
    http://naleid.com/blog/2011/12/19/get­ting-a-clojure-repl-in-vim-with-vimclojure-nailgun-and-leiningen/
32. The NERD Commenter : A plugin that allows for easy commenting of code for many filetypes.
    http://www.vim.org/scripts/scrip­t.php?script_id=1218
33. NERD Commenter na GitHubu
    https://github.com/scroolo­ose/nerdcommenter
34. luarefvim : Lua reference manual
    http://www.vim.org/scripts/scrip­t.php?script_id=1291
35. lua.vim : Lua file type plug-in for the Vim text editor
    http://www.vim.org/scripts/scrip­t.php?script_id=3625
36. vim-lua-ftplugin
    https://github.com/xolox/vim-lua-ftplugin
37. Vi Improved
    https://wiki.python.org/moin/Vim
38. javacomplete : Omni Completion for JAVA
    http://www.vim.org/scripts/scrip­t.php?script_id=1785
39. SearchComplete
    http://www.vim.org/scripts/scrip­t.php?script_id=474
40. ShowMarks
    http://www.vim.org/scripts/scrip­t.php?script_id=152
41. ctrlp.vim
    https://github.com/kien/ctrlp.vim
42. ctrlp.vim
    http://kien.github.io/ctrlp.vim/
43. vim-signature
    https://github.com/kshenoy/vim-signature
44. Supertab
    http://www.vim.org/scripts/scrip­t.php?script_id=1643
45. Supertab (GitHub)
    https://github.com/ervandew/supertab
46. Vim Essential Plugin: NERD Tree
    http://code.tutsplus.com/tutorials/vim-essential-plugin-nerdtree–net-19692
47. The NERD tree: A tree explorer plugin for navigating the filesystem
    http://vim.sourceforge.net/scrip­ts/script.php?script_id=1658
48. NERD Tree Guide
    http://usevim.com/2012/07/18/ner­dtree/
49. vcscommand.vim : CVS/SVN/SVK/git/hg/bzr integration plugin
    http://www.vim.org/scripts/scrip­t.php?script_id=90
50. vcscommand na GitHubu
    https://github.com/vim-scripts/vcscommand.vim
51. Popis skriptu Vim Pathogen
    http://www.vim.org/scripts/scrip­t.php?script_id=2332
52. Posledníverze skriptu Vim Pathogen
    https://tpo.pe/pathogen.vim
53. Nejlepší pluginy pro Vim
    http://vimawesome.com/
54. Nejlepší pluginy pro Vim
    http://www.vim.org/scripts/scrip­t_search_results.php?order_by=ra­ting
55. Vim-airline na GitHubu
    https://github.com/bling/vim-airline
56. Vim-airline na www.vim.org
    http://www.vim.org/scripts/dow­nload_script.php?src_id=22726
57. Vim-fugitive na GitHubu
    https://github.com/tpope/vim-fugitive
58. Vim-fugitive na www.vim.org
    http://www.vim.org/scripts/scrip­t.php?script_id=2975
59. Textový editor Vim jako IDE (seriál)
    http://www.root.cz/clanky/textovy-editor-vim-jako-ide/
60. Building Vim
    http://vim.wikia.com/wiki/Bu­ilding_Vim
61. Getting the Vim source with Mercurial
    http://vim.wikia.com/wiki/Get­ting_the_Vim_source_with_Mer­curial
62. Vim Perl Interface
    http://vim.dindinx.net/vim7/html/if_per­l.txt.php
63. Vim Perl Support
    http://www.softpanorama.or­g/Editors/Vimorama/vim_per­l_support.shtml
64. VIM as Python IDE
    http://blog.dispatched.ch/2009/05/24/vim-as-python-ide/
65. Stack Overflow: VIM: Perl interface: passing a variable to Perl and reading a vim variable from Perl
    http://stackoverflow.com/qu­estions/4999902/vim-perl-interface-passing-a-variable-to-perl-and-reading-a-vim-variable-from
66. Stack Overflow: Getting started with vim scripting with Perl
    http://stackoverflow.com/qu­estions/2208618/getting-started-with-vim-scripting-with-perl
67. Python with a modular IDE (Vim)
    http://www.sontek.net/python-with-a-modular-ide-vim
68. Getting to VIM's Python interface
    http://zerokspot.com/weblog/2009/02/21/get­ting-to-know-vims-python-interface/
69. Pretty-formatting XML
    http://vim.wikia.com/wiki/Pretty-formatting_XML
70. Delete a pair of XML/HTML tags
    http://vim.wikia.com/wiki/De­lete_a_pair_of_XML/HTML_tags
71. Vim as XML Editor
    http://www.pinkjuice.com/how­to/vimxml/
72. xmledit: A filetype plugin to help edit XML, HTML, and SGML documents
    http://www.vim.org/scripts/scrip­t.php?script_id=301
73. Poslední vývojová verze makra xmledit
    http://github.com/sukima/xmledit/
74. vim.wikia: Display date-and-time on status line
    http://vim.wikia.com/wiki/Display_date-and-time_on_status_line
75. vim.wikia: Writing a valid statusline
    http://vim.wikia.com/wiki/Wri­ting_a_valid_statusline
76. vim.wikia: Statusline tab level ruler
    http://vim.wikia.com/wiki/Sta­tusline_tab_level_ruler
77. vim.wikia: Switching between different statuslines
    http://vim.wikia.com/wiki/Swit­ching_between_different_sta­tuslines
78. X Selections, Cut Buffers, and Kill Rings
    http://www.jwz.org/doc/x-cut-and-paste.html
79. Accessing the system clipboard
    http://vim.wikia.com/wiki/Ac­cessing_the_system_clipbo­ard
80. xcutsel(1) – Linux man page
    http://linux.die.net/man/1/xcutsel
81. snipMate : TextMate-style snippets for Vim
    http://www.vim.org/scripts/scrip­t.php?script_id=2540
82. msanders / snipmate.vim
    https://github.com/msander­s/snipmate.vim
83. snipMate.vim Introductory Screencast
    http://vimeo.com/3535418
84. Clewn home page
    http://clewn.sourceforge.net/
85. How to connect vim with gdb – using clewn
    http://chunhao.net/blog/how-to-connect-vim-with-gdb-using-clewn
86. yavdb : Yet Another (Generic) Vim Debugger Integration
    http://www.vim.org/scripts/scrip­t.php?script_id=1954
87. Vim home page
    http://www.vim.org/
88. vim (man page)
    http://www.linux-tutorial.info/modules.php?na­me=ManPage&sec=1&manpage=vim
89. Tutorial: Make Vim as Your C/C++ IDE Using c.vim Plugin
    http://www.thegeekstuff.com/2009/01/tu­torial-make-vim-as-your-cc-ide-using-cvim-plugin/
90. c.vim : C/C++ IDE
    http://vim.sourceforge.net/scrip­ts/script.php?script_id=213
91. c.vim : C/C++ IDE key mappings
    http://lug.fh-swf.de/vim/vim-c/c-hotkeys.pdf
92. Základní základy editoru Vim
    http://www.root.cz/clanky/zakladni-zaklady-editoru-vim/
93. Jak si přizpůsobit Vim
    http://www.root.cz/serialy/jak-si-prizpusobit-vim/
94. Taglist (plugin)
    http://www.vim.org/scripts/scrip­t.php?script_id=273
95. The NERD tree: A tree explorer plugin for navigating the filesystem
    http://www.vim.org/scripts/scrip­t.php?script_id=1658
96. JavaBrowser : Shows java file class, package in a tree as in IDEs. Java source browser.
    http://www.vim.org/scripts/scrip­t.php?script_id=588
97. snippetsEmu : An attempt to emulate TextMate's snippet expansion
    http://www.vim.org/scripts/scrip­t.php?script_id=1318
98. Vim plugins for developers
    http://www.linuxtoday.com/upload/vim-plugins-for-developers-140619094010.html