Ve třetí a současně i poslední části článku o novinkách, které můžeme nalézt v osmé verzi populárního textového editoru Vim, dokončíme popis změn a rozšíření provedených ve skriptovacím engine Vimu a tedy i v jeho skriptovacím jazyku nazvaném VimScript. Jedná se především o podporu práce s formátem JSON, práci s takzvanými kanály (channels) a úlohami (jobs).
Obsah
1. Textový editor Vim 8 - dokončení popisu novinek ve skriptovacím engine
2. Práce s datovým formátem JSON
3. Demonstrační příklady: použití funkcí pro práci s formátem JSON
4. Převody hodnot mezi VimScriptem a formátem JSON
5. Použití seznamů (polí, vektorů)
6. Použití slovníků (hashů, asociativních polí)
7. Speciální hodnoty pro reprezentaci nekonečna a NaN při použití typu Float
8. Speciální hodnoty určené pro reprezentaci true, false a null ve formátu JSON
10. Vytvoření kanálu a přenos dat
13. Repositář s demonstračními příklady
1. Textový editor Vim 8 - dokončení popisu novinek ve skriptovacím engine
Ve druhé části článku o novinkách, které nalezneme v osmé verzi populárního textového editoru Vim, jsme se seznámili s některými změnami provedenými ve skriptovacím engine Vimu. S těmito změnami a vylepšeními se sice v naprosté většině případů přímo setkají pouze vývojáři pluginů, ovšem těžit z nich (alespoň nepřímo) mohou i všichni ostatní uživatelé textového editoru Vim, protože implementované změny a rozšíření (anonymní funkce, časovače, unikátní čísla oken, asynchronní spouštění programového kódu atd.) umožňují tvorbu složitějších pluginů pracujících asynchronně s operacemi prováděnými uživatelem. Připomeňme si, že minule byly popsány následující změny a vylepšení:
- Podpora pro použití unikátních čísel (identifikátorů) oken.
- Anonymní funkce a uzávěry (closures) ve VimScriptu.
- Reference na funkce (to sice ve skutečnosti není úplná novinka, ale úzce souvisí s předchozím bodem).
- Časovače a s nimi související asynchronně spouštěný kód.
Obrázek 1: Všechny demonstrační příklady budou funkční ve Vimu 8. Verzi Vimu zjistíte snadno – pokud se při spouštění tohoto textového editoru neotevře žádný soubor, zobrazí se toto hlášení.
V dnešním článku popis všech změn a rozšíření VimScriptu dokončíme, protože si postupně popíšeme a na demonstračních příkladech ukážeme tyto novinky:
- Použití datového formátu JSON
- Převody hodnot (jak skalárních, tak i strukturovaných) do JSONu a zpět
- Využití takzvaných kanálů (channels)
- Tvorba takzvaných úloh (jobs)
Obrázek 2: Druhá možnost zjištění verze Vimu spočívá ve spuštění příkazu :ver.
2. Práce s datovým formátem JSON
Na první pohled sice možná ne příliš výraznou, ale o to důležitější a užitečnější novinkou, je přidání čtyř nových funkcí do skriptovacího engine Vimu. Tyto čtyři funkce slouží pro převod datových struktur VimScriptu do JSON formátu a zpět. Proč je vlastně tato novinka tak důležitá? Souvisí totiž s další novou technologií, konkrétně s úlohami (jobs) a kanály (channels). Úlohy umožňují přesně definovaným způsobem vytvářet pluginy (i externí pluginy) s tím, že tyto pluginy mohou běžet asynchronně, tj. částečně nezávisle na samotném Vimu. Důležité je, že pluginy s Vimem komunikují právě přes JSON formát, což je pěkně navržené řešení, protože JSON je dnes podporovaný v prakticky všech relevantních programovacích jazycích, v nichž se externí pluginy většinou píšou (typicky se jedná o Python, ale lze použít i jazyk Lua apod.).
Skriptovací engine Vimu nabízí programátorům dvě funkce určené pro převod datových struktur do formátu JSON (encode) a dvě funkce určené pro parsování JSON dat do interních struktur VimScriptu (decode). Dvě varianty jsou implementovány z toho důvodu, že někdy je zapotřebí, aby byly klíče objektů (či slovníků) reprezentovány řetězci a jinde se může jednat o identifikátory bez uvozovek (záleží na konkrétní situaci):
| Funkce | Stručný popis |
|---|---|
| json_encode(výraz) | převod výrazu do JSON formátu, který se vrátí ve formě řetězce |
| json_decode(řetězec) | opak předchozí funkce, parsování řetězce s daty uloženými v JSON formátu do interních datových struktur VimScriptu |
| js_encode(výraz) | podobné funkci json_encode(), ovšem klíče nejsou umístěny v uvozovkách |
| js_decode(řetězec) | podobné funkci json_decode(), ovšem při parsingu se nevyžaduje, aby byly klíče umístěny v uvozovkách |
Poznámka: převod do JSON formátu se někdy nazývá serializace, zpětný převod pak pochopitelně deserializace.
Obrázek 3: Nápověda k funkcím js_decode() a js_encode().
3. Demonstrační příklady: použití funkcí pro práci s formátem JSON
Chování výše popsaných funkcí si můžeme velmi snadno otestovat. Pro jednoduchost si nejprve ukážeme, jakým způsobem se do formátu JSON (a zpět) převádí skalární datové typy, tj. zejména numerické hodnoty a řetězce. První příklad používá funkci json_encode():
" ---------------------------------------------
" Vim8 example script #8 - usage of json_encode()
" function for scalar values.
"
" How to use it:
" 1) start new Vim session
" 2) open this script in it
" 3) call :source %
" ---------------------------------------------
let integerNumber = 42
echo json_encode(integerNumber)
let realNumber = 3.0/2
echo json_encode(realNumber)
let booleanValueTrue = 1==1
echo json_encode(booleanValueTrue)
let booleanValueFalse = 1==2
echo json_encode(booleanValueFalse)
let greetings = "VimPerfect"
echo json_encode(greetings)
Obrázek 4: Výsledek po spuštění demonstračního příkladu json_encode_scalars.vim. Povšimněte si především toho, že výsledek výrazů 1==1 (pravda) a 1==2 (nepravda) se převede na celé číslo 0 či 1. Pokud skutečně budeme do JSON formátu zapisovat pravdivostní hodnoty "true" a "false", je nutné na straně VimScriptu použít speciální hodnoty zmíněné v osmé kapitole.
V případě použití funkce js_encode() bude výsledek totožný, protože chování této funkce se odlišuje především při práci se slovníky (dict) nazývanými také asociativní pole či objekty:
" ---------------------------------------------
" Vim8 example script #9 - usage of js_encode()
" function for scalar values.
"
" How to use it:
" 1) start new Vim session
" 2) open this script in it
" 3) call :source %
" ---------------------------------------------
let integerNumber = 42
echo js_encode(integerNumber)
let realNumber = 3.0/2
echo js_encode(realNumber)
let booleanValueTrue = 1==1
echo js_encode(booleanValueTrue)
let booleanValueFalse = 1==2
echo js_encode(booleanValueFalse)
let greetings = "VimPerfect"
echo js_encode(greetings)
Obrázek 5: Výsledek po spuštění demonstračního příkladu js_encode_scalars.vim.
Ve chvíli, kdy se nám nějakým způsobem podaří získat textový řetězec obsahující data v JSON formátu (může se jednat o obsah souboru, data přečtená z kanálu atd.), je parsing takového řetězce snadný. Lze použít funkci json_decode() či js_decode(). Podívejme se nejprve na výsledek použití první z těchto funkcí:
" ---------------------------------------------
" Vim8 example script #10 - usage of json_decode()
" function for scalar values.
"
" How to use it:
" 1) start new Vim session
" 2) open this script in it
" 3) call :source %
" ---------------------------------------------
let integerNumber = 42
let jsonValue = json_encode(integerNumber)
echo json_decode(jsonValue)
let realNumber = 3.0/2
let jsonValue = json_encode(realNumber)
echo json_decode(jsonValue)
let booleanValueTrue = 1==1
let jsonValue = json_encode(booleanValueTrue)
echo json_decode(jsonValue)
let booleanValueFalse = 1==2
let jsonValue = json_encode(booleanValueFalse)
echo json_decode(jsonValue)
let greetings = "VimPerfect"
let jsonValue = json_encode(greetings)
echo json_decode(jsonValue)
Obrázek 6: Výsledek po spuštění demonstračního příkladu json_decode_scalars.vim.
Použití funkce js_decode() je shodné s použitím výše zmíněné funkce json_decode():
" ---------------------------------------------
" Vim8 example script #11 - usage of js_decode()
" function for scalar values.
"
" How to use it:
" 1) start new Vim session
" 2) open this script in it
" 3) call :source %
" ---------------------------------------------
let integerNumber = 42
let jsonValue = json_encode(integerNumber)
echo js_decode(jsonValue)
let realNumber = 3.0/2
let jsonValue = json_encode(realNumber)
echo js_decode(jsonValue)
let booleanValueTrue = 1==1
let jsonValue = json_encode(booleanValueTrue)
echo js_decode(jsonValue)
let booleanValueFalse = 1==2
let jsonValue = json_encode(booleanValueFalse)
echo js_decode(jsonValue)
let greetings = "VimPerfect"
let jsonValue = json_encode(greetings)
echo js_decode(jsonValue)
Obrázek 7: Výsledek po spuštění demonstračního příkladu js_decode_scalars.vim.
4. Převody hodnot mezi VimScriptem a formátem JSON
Ve VimScriptu existuje celkem deset datových typů, přičemž pět z těchto typů do jisté míry koresponduje s typy používanými ve formátu JSON (Number, Float, String, List a Dictionary) a dva další typy (Boolean, None) lze taktéž do formátu JSON převést, pokud se ovšem dodrží určitá pravidla. Výše zmíněné čtyři funkce json_encode(), json_decode(), js_encode() a js_decode() provádí převody mezi jednotlivými typy (resp. mezi hodnotami různých typů) zcela automaticky, ovšem existuje několik potenciálně problematických výjimek, kterými se budeme zabývat v navazujících kapitolách. V následující tabulce jsou vypsány korespondující datové typy. Povšimněte si, že v JSON formátu se nerozlišuje mezi celými čísly a čísly s plovoucí řádovou čárkou, což do značné míry souvisí s původním návrhem tohoto formátu založeném na JavaScriptu:
| Typ ve VimScriptu | Převod do JSONu |
|---|---|
| Number | celé číslo, výjimky viz sedmou kapitolu |
| Float | číslo s desetinnou čárkou a/nebo exponentem |
| String | řetězec umístěný v uvozovkách |
| List | pole hodnot, viz pátou kapitolu |
| Dictionary | objekt (asociativní pole), viz šestou kapitolu |
| Funcref | nelze (teoreticky by se jednalo o serializaci kódu) |
| Boolean | True/False (viz kapitolu číslo 8) |
| None | Null (viz kapitolu číslo 8) |
| Job | nelze |
| Channel | nelze |
Obrázek 8: Prakticky vše o datových typech používaných ve VimScriptu se dozvíte po zadání příkazu :help variables.
5. Použití seznamů (polí, vektorů)
Převod mezi skalárními typy je ve většině běžných případů triviální, proto se podívejme, jakým způsobem je možné v JSON formátu reprezentovat složený datový typ. Prvním typem, s nímž se setká prakticky každý programátor používající VimScript, je seznam (list), který je ovšem někdy taktéž nazýván vektorem (vector) či polem (array), což ale není zcela přesné. V následujícím příkladu je do JSON formátu převeden seznam čísel, dále seznam řetězců a dvě matice reprezentované seznamem seznamů. Povšimněte si, že ve VimScriptu je nutné při zápisu výrazu či příkazu na více řádků použít zpětné lomítko na začátku (nikoli na konci!) řádku, což je dosti neobvyklé:
" ---------------------------------------------
" Vim8 example script #12 - usage of json_encode()
" function for vector (array) values.
"
" How to use it:
" 1) start new Vim session
" 2) open this script in it
" 3) call :source %
" ---------------------------------------------
let vector1 = [1, 2, 3]
echo json_encode(vector1)
let vector2 = ["Hello", "world", "!"]
echo json_encode(vector2)
let matrix1 = [[1,2,3], [4,5,6], [7,8,9]]
echo json_encode(matrix1)
let matrix2 = [[1,2,3],
\ [4,5,6],
\ [7,8,9]]
echo json_encode(matrix2)
Obrázek 9: Výsledek po spuštění demonstračního příkladu json_encode_vectors.vim.
Samozřejmě můžeme namísto funkce json_encode() použít funkci js_encode(), která ovšem vytvoří shodný výsledek (prozatím totiž nepracujeme se slovníky):
" ---------------------------------------------
" Vim8 example script #13 - usage of js_encode()
" function for vector (array) values.
"
" How to use it:
" 1) start new Vim session
" 2) open this script in it
" 3) call :source %
" ---------------------------------------------
let vector1 = [1, 2, 3]
echo js_encode(vector1)
let vector2 = ["Hello", "world", "!"]
echo js_encode(vector2)
let matrix1 = [[1,2,3], [4,5,6], [7,8,9]]
echo js_encode(matrix1)
let matrix2 = [[1,2,3],
\ [4,5,6],
\ [7,8,9]]
echo js_encode(matrix2)
Obrázek 10: Výsledek po spuštění demonstračního příkladu js_encode_vectors.vim.
6. Použití slovníků (hashů, asociativních polí)
Nejsložitější datovou strukturou, kterou je možné do JSON formátu uložit (serializovat), jsou takzvané slovníky (dictionary, dict), které jsou v jiných programovacích jazycích nazývány hashe či asociativní pole. Právě u slovníků se projeví rozdíl mezi funkcemi json_encode() a js_encode(), a to konkrétně při serializaci klíčů. Rozdíly jsou shrnuty v tabulce:
| Typ klíče | json_encode() | js_encode() |
|---|---|---|
| řetězec odpovídající názvu proměnné v JS | klíč je zapsán do uvozovek | klíč je zapsán bez uvozovek |
| jiný řetězec (s mezerou, pomlčkou...) | klíč je zapsán do uvozovek | klíč je zapsán do uvozovek |
| číslo | klíč je zapsán do uvozovek | klíč je zapsán do uvozovek |
| jiný typ (seznam...) | nelze použít | nelze použít |
Název proměnné v JavaScriptu musí začínat písmenem, podtržítkem či znakem dolaru a musí obsahovat čísla, písmena (nikoli jen ASCII, možnosti jsou zde větší), dolary či podtržítka.
V následujícím příkladu je ukázáno, jak je možné do JSON formátu ukládat slovníky, slovníky se seznamy (hodnoty) či naopak seznam slovníků:
" ---------------------------------------------
" Vim8 example script #14 - usage of json_encode()
" function for dictionaries.
"
" How to use it:
" 1) start new Vim session
" 2) open this script in it
" 3) call :source %
" ---------------------------------------------
let dict1 = {"first": 1, "second" : 2, "third" : 3}
echo json_encode(dict1)
let dict2 = {1 : "first", 2 : "second", 3 : "third"}
echo json_encode(dict2)
let dict3 = {"first" : [1,2,3], "second" : [4,5,6]}
echo json_encode(dict3)
let vectorOfDicts = [ {"first" : 1, "second" : 2}, {"another" : "dictionary"}]
echo json_encode(vectorOfDicts)
Obrázek 11: Výsledek po spuštění demonstračního příkladu json_encode_dict.vim.
Pokud budeme shodné datové struktury serializovat funkcí js_encode(), budou se klíče ukládat rozdílným způsobem, ale pouze pro ty řetězce, které odpovídají jménům proměnných v JavaScriptu:
" ---------------------------------------------
" Vim8 example script #15 - usage of js_encode()
" function for dictionaries.
"
" How to use it:
" 1) start new Vim session
" 2) open this script in it
" 3) call :source %
" ---------------------------------------------
let dict1 = {"first": 1, "second" : 2, "third" : 3}
echo js_encode(dict1)
let dict2 = {1 : "first", 2 : "second", 3 : "third"}
echo js_encode(dict2)
let dict3 = {"first" : [1,2,3], "second" : [4,5,6]}
echo js_encode(dict3)
let vectorOfDicts = [ {"first" : 1, "second" : 2}, {"another" : "dictionary"}]
echo js_encode(vectorOfDicts)
Obrázek 12: Výsledek po spuštění demonstračního příkladu js_encode_dict.vim.
7. Speciální hodnoty pro reprezentaci nekonečna a NaN při použití typu Float
Při ukládání (serializaci) dat do formátu JSON je v některých případech nutné korektně pracovat se speciálními hodnotami podporovanými typem Float (numerické hodnoty s plovoucí řádovou čárkou). Výsledkem některých aritmetických operací totiž může být kladné či záporné nekonečno, které se ve VimScriptu vypíše jako inf nebo -inf. Dokonce můžeme získat i hodnotu NaN (Not a Number), což je například výsledek dělení nuly nulou, výpočtem rozdílu dvou nekonečen, podílem nekonečen atd. Podívejme se nyní na to, jak s těmito speciálními hodnotami pracují funkce pro serializaci do JSON formátu. Předem upozorňuji na problematickou práci se záporným nekonečnem, které se do JSONu ukládá jako nekonečno kladné (!), i když echo negativeInfinity dokládá, že interně VimScript tuto hodnotu zpracovává korektně:
" ---------------------------------------------
" Vim8 example script #15 - usage of json_encode()
" function for special float values.
"
" How to use it:
" 1) start new Vim session
" 2) open this script in it
" 3) call :source %
" ---------------------------------------------
let positiveInfinity = 1.0/0
let negativeInfinity = -1.0/0
let NaN1 = 0.0/0
let NaN2 = 1 + NaN1
let NaN3 = positiveInfinity - positiveInfinity
let NaN4 = positiveInfinity / positiveInfinity
let originalList = [0, 0.0, 1, 1.0, positiveInfinity, negativeInfinity, NaN1, NaN2, NaN3, NaN4]
let jsonList = json_encode(originalList)
echo jsonList
Obrázek 13: Výsledek po spuštění demonstračního příkladu json_encode_float_values.vim. Povšimněte si, že i původně záporné nekonečno je reprezentováno jako „Infinity“.
8. Speciální hodnoty určené pro reprezentaci true, false a null ve formátu JSON
Mezi další tři speciální hodnoty, s nimiž je v některých případech nutné v JSON formátu pracovat, patří hodnoty true, false a null. Tyto hodnoty je nutné ve VimScriptu explicitně ošetřit, a to zejména z toho důvodu, že interně jsou pravdivostní hodnoty reprezentovány celými čísly: pravda je reprezentována hodnotou 1, nepravda hodnotou 0. To jsme ostatně viděli už v prvním demonstračním příkladu, v němž se výsledky výrazů 1==1 a 1==2 převedly na 1 a 0. Pro reprezentaci „skutečných“ pravdivostních hodnot ve formátu JSON slouží speciální hodnoty v:true a v:false. Totéž platí i pro null (tedy prázdnou hodnotu), kterou je nutné ve VimScriptu zapisovat buď jako v:null či jako v:none. Vše je patrné z následující dvojice demonstračního příkladu. Povšimněte si toho, že prázdný řetězec není považován za hodnotu null (některé starší JSON knihovny právě prázdné řetězce zpracovávaly špatně):
" ---------------------------------------------
" Vim8 example script #16 - usage of json_encode()
" function for special values.
"
" How to use it:
" 1) start new Vim session
" 2) open this script in it
" 3) call :source %
" ---------------------------------------------
let originalDictionary = {
\ "true1" : 1==1,
\ "true2" : v:true,
\ "false1" : 1==2,
\ "false2" : v:false,
\ "null1" : v:null,
\ "null2" : v:none,
\ "emptyString" : ""
\}
let jsonDictionary = json_encode(originalDictionary)
echo jsonDictionary
Obrázek 14: Výsledek po spuštění demonstračního příkladu json_encode_special_values.vim.
" ---------------------------------------------
" Vim8 example script #17 - usage of js_encode()
" function for special values.
"
" How to use it:
" 1) start new Vim session
" 2) open this script in it
" 3) call :source %
" ---------------------------------------------
let originalDictionary = {
\ "true1" : 1==1,
\ "true2" : v:true,
\ "false1" : 1==2,
\ "false2" : v:false,
\ "null1" : v:null,
\ "null2" : v:none,
\ "emptyString" : ""
\}
let jsonDictionary = js_encode(originalDictionary)
echo jsonDictionary
Obrázek 15: Výsledek po spuštění demonstračního příkladu js_encode_special_values.vim.
9. Kanály (channels)
Zcela novou technologií, s níž se můžeme setkat ve Vimu 8, je koncept takzvaných kanálů (channels). Kanály slouží ke komunikaci mezi Vimem (resp. přesněji řečeno mezi VimScriptem) a externími pluginy, které jsou spuštěny v samostatném procesu. Vim s těmito pluginy komunikuje buď s využitím socketů nebo pipe. Pro přenos dat se typicky používá formát JSON a proto jsou tak užitečné ty funkce, které jsme si popsali v předchozích kapitolách. Ve skutečnosti se mohou používat čtyři typy zpráv: RAW, NL, JSON a JS:
| Typ zprávy | Význam |
|---|---|
| RAW | obecný formát, s nímž Vim nijak speciálně nenakládá, pouze zprávu pošle či přijme |
| NL | každá textová zpráva je ukončena znakem pro konec řádku (NL) |
| JSON | formát JSON |
| JS | formát JSON s klíči odpovídajícími JavaScriptu |
Samotné pluginy mohou pracovat ve čtyřech režimech:
| Režim | Připojení | Popis |
|---|---|---|
| démon | socket | proces, ke kterému se může připojit více instancí Vimu |
| úloha (job) | socket nebo pipe | proces, ke kterému se připojuje jedna instance Vimu (ten ho typicky i spustí) |
| krátká úloha | socket nebo pipe | dtto jako předchozí, typicky však proces neběží po celou dobu existence Vimu |
| filtr | pipe | spouští se synchronně, Vim čeká na výsledek operace |
10. Vytvoření kanálu a přenos dat
Nový kanál určený pro komunikaci s démonem či úlohou (viz tabulka v předchozí kapitole), se vytváří funkcí ch_open(). Například pro démona lokálně běžícího na stejném počítači a poslouchajícího na portu 1234 se použije tento příkaz:
let channel1 = ch_open("localhost:1234")
Jakmile je kanál vytvořen, lze démonu poslat data funkcí ch_evalexpr(kanál, data):
ch_evalexpr(channel1, "Hello daemon")
Pokud démon vrátí nějakou zprávu, je tato zpráva vrácena jako výsledek funkce ch_evalexpr():
let response = ch_evalexpr(channel1, "Hello daemon")
echo response
Na konci skriptu je nutné kanál zavřít a uvolnit tak příslušný socket:
ch_close(channel1)
11. Demonstrační plugin
Při instalaci Vimu (či při jeho lokálním překladu) se mj. nainstaluje i demonstrační server, který můžeme použít pro otestování funkce kanálů. Tento server je dostupný v adresáři, který se vrátí zápisem :echo $VIMRUNTIME. Typicky jde o adresář /usr/share/vim/vim80 či /usr/local/share/vim/vim80/. V tomto adresáři nalezneme podadresář nazvaný tools se souborem demoserver.py. Tento soubor spusťte v samostatném terminálu, aby byly vidět jeho zprávy:
/usr/local/share/vim/vim80/tools/demoserver.py
Server loop running in thread: Thread-1
Listening on port 8765
Následně otevřeme propojení se serverem (démonem), a to přímo ve Vimu:
:let channel1=ch_open("localhost:8765")
Na straně serveru by se měla objevit zpráva:
=== socket opened ===
Nyní již můžeme serveru poslat nějaká data:
:call ch_evalexpr(channel1, "Hello daemon")
Server zprávu přijme a příslušně odpoví:
received: [1,"Hello daemon"]
sending [1, "what?"]
Nyní můžeme kanál uzavřít (ve skutečnosti však může být otevřen libovolně dlouhou dobu, pokud je to potřeba):
:call ch_close(channel1)
Na straně serveru by se měla objevit zpráva:
=== socket closed ===
Namísto tohoto jednoduchého serveru si můžeme představit mnohem složitější program, například jádro překladače, nástroje pro refaktoring kódu atd.
12. Úlohy (jobs)
Pro spuštění pluginů v samostatných procesech se používá nová funkce nazvaná job_start(). Tato funkce má jeden nepovinný parametr, kterým je příkaz pro spuštění (například cesta ke skriptu atd.). Nepovinným parametrem options je možné funkci job_start() předat způsob spuštění úlohy, například zda se mají pro komunikaci použít kanály či pipy, jak dlouho se má čekat na dokončení volání (timeout) atd. Jakmile je úloha spuštěna, lze její stav zjistit zavoláním funkce job_status() vracející řetězec „run“, „fail“ (nepodařil se start) nebo „dead“ (start se podařil, nicméně úloha již skončila). Explicitní ukončení úlohy zajišťuje funkce pojmenovaná jednoduše job_stop(), které lze navíc v Linuxu předat signál pro ukončení: „term“, „hup“, „quit“ apod. A to nejdůležitější na konec: pokud se úloha spustila, je možné získat komunikační kanál funkcí job_channel() a následně použít techniku popsanou v předchozích třech kapitolách.
13. Repositář s demonstračními příklady
Všechny v předchozích kapitolách popsané demonstrační skripty určené pro textový editor Vim verze 8 byly uloženy do Git repositáře dostupného na adrese https://github.com/tisnik/presentations. V následující tabulce naleznete na jednotlivé skripty přímé odkazy:
Poznámka: ani jeden z těchto skriptů nebude funkční v předchozích verzích Vimu!
14. Odkazy na Internetu
- Introducing JSON
http://json.org/ - NULL v JSON formátu
http://stackoverflow.com/questions/21120999/representing-null-in-json#21122019 - Vim – the editor
http://www.vim.org/ - Vim 8.0 is released
https://laravel-news.com/2016/09/vim-8-0-is-released/ - Vim: So long Pathogen, hello native package loading
https://shapeshed.com/vim-packages/ - :smile command was not backported! #5116
https://github.com/neovim/neovim/issues/5116 - Makejob
http://www.vim.org/scripts/script.php?script_id=5479 - Články o Vimu na Root.cz:
http://www.root.cz/n/vim/clanky/ - Vim sedm - první část
http://www.root.cz/clanky/vim-sedm-prvni-cast/ - vim (man page)
http://www.linux-tutorial.info/modules.php?name=ManPage&sec=1&manpage=vim - History of the Text Editor
http://vanstee.me/history-of-the-text-editor.html - Interview with Bill Joy
http://web.cecs.pdx.edu/~kirkenda/joy84.html - vi Editor Commands
http://www.cs.rit.edu/~cslab/vi.html#A1.4 - vi Manual
http://www.cs.fsu.edu/general/vimanual.html - Mastering the Vi Editor
http://www.susnet.uk/mastering-the-vi-editor - Vim as a Python IDE, or Python IDE as Vim
http://blog.jetbrains.com/pycharm/2013/06/vim-as-a-python-ide-or-python-ide-as-vim/ - Vi Improved
https://wiki.python.org/moin/Vim - Popis skriptu Vim Pathogen
http://www.vim.org/scripts/script.php?script_id=2332 - Posledníverze skriptu Vim Pathogen
https://tpo.pe/pathogen.vim - Nejlepší pluginy pro Vim
http://vimawesome.com/ - Nejlepší pluginy pro Vim
http://www.vim.org/scripts/script_search_results.php?order_by=rating - Building Vim
http://vim.wikia.com/wiki/Building_Vim - Vim plugins for developers
http://www.linuxtoday.com/upload/vim-plugins-for-developers-140619094010.html
