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

Pavel Tišnovský 12. 1. 2016

Ve druhé části článku o tvorbě pluginů pro textový editor Vim s využitím programovacího jazyka Lua dokončíme popis této zajímavé a užitečné problematiky. Zaměříme se především na popis dalších možností nabízených modulem vim, voláním funkcí naprogramovaných v jazyku Lua a další zajímavosti.

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):

# Příkaz ve Vimu Stručný popis příkazu
1 :lua spuštění a vyhodnocení jednoho příkazu či bloku příkazů naprogramovaných v jazyku Lua
2 :luafile spuštění celého skriptu naprogramovaného v jazyku Lua; parametrem tohoto příkazu je jméno souboru se skriptem
3 :luado umožňuje spouštět vybraný příkaz jazyka Lua, který je automaticky a postupně (iterativně) volán pro všechny řádky/vybrané řádky v aktivním bufferu

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:

Příkaz Význam
,n čísla řádků se přidají do celého bufferu
:10,$:luado return addLineNumber(line, linenr) přidání čísla řádků od desátého řádku do konce bufferu
:1,10:luado return addLineNumber(line, linenr) přidání čísla řádků na prvních deset řádků
:1,.:luado return addLineNumber(line, linenr) přidání čísla řádků od začátku bufferu až do aktuálního řádku
:1,.:luado return addLineNumber(line, linenr) přidání čísla řádků od začátku bufferu až do aktuálního řádku
:.-1,.+1:luado return addLineNumber(line, linenr) přidání čísla řádků pouze na tři sousední řádky
[visual],n nejzajímavější možnost: přidání čísla řádků pouze na vybraný blok

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ů:

# Vlastnost/operátor Význam
1 #b počet textových řádků v bufferu
2 b[n] vrátí n-tý řádek jako string
3 b[n]=„xxx“ nahradí obsah n-tého řádku novým obsahem
4 b.name krátké jméno bufferu (nelze měnit)
5 b.fname dlouhé jméno bufferu (taktéž nelze měnit)
6 b.number číslo bufferu v seznamu (opět nelze měnit)

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):

# Metoda Význam
1 b:next() vrátí další buffer v seznamu
2 b:previous() vrátí předchozí buffer v seznamu
3 b:isvalid() vrátí hodnotu true pro reálný Vim buffer
4 b:insert(text) vložení nového řádku za konec bufferu
5 b:insert(text,0) vložení nového řádku před začátek bufferu
6 b:insert(text,n) vložení nového řádku na n-tou pozici (1..#b)

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:

# Vlastnost/operátor Význam
1 w.buffer buffer asociovaný s oknem (nelze měnit)
2 w.line řádek, na němž se nachází kurzor (lze měnit)
3 w.col sloupec, na němž se nachází kurzor (lze měnit)
4 w.width šířka okna reprezentovaná ve znacích (lze měnit, pokud to má význam)
5 w.height výška okna reprezentovaná v řádcích (lze měnit, pokud to má význam)

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

lua vim.window().height=20

Výpis metod pro objekt w:

# Metoda Význam
1 w:next() vrátí další logicky navazující okno
2 w:previous() vrátí předchozí logicky navazující okno
3 w:isvalid() test, zda se jedná o reálné okno (Vim ještě okno udržuje)

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_line1.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:

# Hodnota syntax Programovací jazyk Komentář začíná
1 lua Lua --
2 c C //
3 cpp C++ //
4 java Java //
5 javascript JavaScript //
6 vim Vim Script "
7 clojure Clojure ;
8 sh Sh, BASH, … #"
9 python Python #"
10 basic BASIC REM

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_line2.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
Našli jste v článku chybu?
120na80.cz: Jsou opalovací krémy pro děti jiné?

Jsou opalovací krémy pro děti jiné?

DigiZone.cz: Náhrada za nevrácená zařízení?

Náhrada za nevrácená zařízení?

Vitalia.cz: 5 porcí ovoce a zeleniny: no ale jak na to?

5 porcí ovoce a zeleniny: no ale jak na to?

DigiZone.cz: Mobilní aplikace pro DVTV je tady

Mobilní aplikace pro DVTV je tady

DigiZone.cz: Skylink přidává kanály už teď

Skylink přidává kanály už teď

Lupa.cz: Jaké IoT tarify nabízejí mobilní operátoři?

Jaké IoT tarify nabízejí mobilní operátoři?

Vitalia.cz: Máte chutě? Nejezděte do světa, ale do Dobřichovic

Máte chutě? Nejezděte do světa, ale do Dobřichovic

Vitalia.cz: Ministři se přou o využívání antibiotik

Ministři se přou o využívání antibiotik

Root.cz: Nejvýkonnější počítač mají v Číně, podívejte se

Nejvýkonnější počítač mají v Číně, podívejte se

Měšec.cz: Od kdy musí studenti platit pojistné?

Od kdy musí studenti platit pojistné?

Lupa.cz: Text umírá, na webu zbude jen video

Text umírá, na webu zbude jen video

DigiZone.cz: Roční bonus pro Dvořáka schválen

Roční bonus pro Dvořáka schválen

DigiZone.cz: Nova: technické pauzy každé 1. pondělí

Nova: technické pauzy každé 1. pondělí

Lupa.cz: eIDAS je tu. O co přijdeme u elektronických podpisů?

eIDAS je tu. O co přijdeme u elektronických podpisů?

Podnikatel.cz: Eseróčko vs. živnost. Co vyhrává?

Eseróčko vs. živnost. Co vyhrává?

DigiZone.cz: TV Nova a její postoj k DVB-T2

TV Nova a její postoj k DVB-T2

Měšec.cz: Udali ho na nelegální software a přišla Policie

Udali ho na nelegální software a přišla Policie

Podnikatel.cz: Jeho dřevěné hodinky chtějí na všech kontinentech

Jeho dřevěné hodinky chtějí na všech kontinentech

Root.cz: Střílejte v obýváku, stačí kamera a projektor

Střílejte v obýváku, stačí kamera a projektor

Měšec.cz: Ceny PHM v Evropě. Finty na úspory

Ceny PHM v Evropě. Finty na úspory