Hlavní navigace

Kite – polointeligentní automatické doplňování kódu založené na AI a ML

Pavel Tišnovský

Dnes se seznámíme s potenciálně velmi užitečným pomocníkem vývojářů. Jedná se o nástroj nazvaný Kite, jenž vylepšuje kontextovou nápovědu a automatické doplňování kódu na základě populárních technologií AI a ML.

Doba čtení: 20 minut

Sdílet

11. Odvození proměnné použité jako parametr při volání funkce či metody

12. Zobrazení podrobnější nápovědy

13. Copilot

14. Plugin Kite v textovém editoru Vim

15. Vim a Copilot

16. Závěr

17. Příloha: omnicompletion ve Vimu

18. Odkazy na Internetu

1. Kite – polointeligentní automatické doplňování kódu založené na AI a ML

V uplynulých (přibližně) pěti letech můžeme sledovat stále častější nasazování technologií AI (umělé inteligence) a ML (strojové učení) i do oblasti vývoje aplikací, popř. jejich testování. Jsou vyvíjeny například nástroje určené pro analýzu zdrojových kódů, poloautomatické hledání chyb, provádění penetračních testů atd. Zapomenout nesmíme ani na překladače, ať již na AOT (ahead-of-time), tak i JIT (just-of-time), do kterých se AI+ML taktéž pomalu zavádí. Ovšem některé z těchto nástrojů dokážou přímo pomáhat programátorům při vývoji a postupně tak nahradit či možná spíše doplnit klasické technologie typu IntelliSense. Mezi tento typ nástrojů patří i Kite, s nímž se ve stručnosti seznámíme v dnešním článku. Cílem současné verze nástroje Kite je především zajištění „inteligentního“ automatického doplňování kódu, dále zpřístupnění příkladů použití volané funkce či metody a v neposlední řadě taktéž zpřístupnění dokumentace, a to i v případě, že daná knihovna vůbec není nainstalována na počítači vývojáře.

Všechny zmíněné operace jsou v Kite implementovány právě s využitím dnes tak populárních (a někdy i dosti přeceňovaných) technologií AI a ML, tedy umělé inteligence a strojového učení. V tomto ohledu se Kite podobá například známějšímu nástroji Visual Studio IntelliCode, kterému bude věnován samostatný článek. V současnosti je většina funkcionality nabízené nástrojem Kite soustředěna okolo programovacího jazyka Python a v mnohem menší míře i okolo jazyka Go. Další programovací jazyky nejsou v současnosti podporovány, i když se do dalších verzí plánuje jejich alespoň částečná podpora.

Poznámka: při zmínce o strojovém učení a umělé inteligenci by se mohlo zdát, že Kite obsahuje nějakou technologii, která v určitém smyslu „rozumí“ zapisovanému algoritmu a bude tedy schopna provádět detekci či dokonce opravy chyb, popř. v tom nejfantastičtějším případě navrhne jiný algoritmus (typu – „vypadá to, že píšeš bubble sort, použij místo toho raději funkci qsort“). Ve skutečnosti tomu tak – alespoň v současné verzi Kite – vůbec není. Kite totiž pracuje na základě analýzy velkého množství dostupných zdrojových kódů získaných z různých zdrojů a na základě těchto kódů například dokáže setřídit seznam navrhovaných funkcí metod podle frekvence jejich použití jinými autory (samozřejmě bere v potaz i právě upravovaný projekt). Taktéž do jisté míry dokáže odhadnout, které proměnné budou použity jako parametry volaných funkcí/metod. Zde však možnosti AI implementované v Kite prozatím končí, což pochopitelně nevylučuje, že další verze budou sofistikovanější a možná bude použití Kite v budoucnosti připomínat nějakou formu párového programování.

2. Integrace Kite s IDE a programátorskými textovými editory

Nástroj Kite je možné v současnosti integrovat s několika programátorskými IDE, popř. s programátorskými textovými editory (ovšem rozdíly mezi IDE a „pouhými“ programátorskými editory se postupně stírají, což je dobře vidět například na projektu VS Code). Podporovány jsou tyto aplikace:

  1. Atom
  2. IntelliJ (pro kód psaný v Pythonu)
  3. PyCharm (bude fungovat i v GoLandu)
  4. Spyder
  5. Sublime Text
  6. Vim
  7. Visual Studio Code
Poznámka: pokud vám v seznamu chybí nějaký oblíbený editor či IDE (napadá mě v tomto případě zejména Emacs), můžete se autorům Kite ozvat, a to na stránce https://kite.com/letmeknow/. Totéž platí i o žádosti pro podporu jiného programovacího jazyka, než je Python, popř. Go.

Obrázek 1: Textový editor Emacs ve funkci integrovaného vývojového prostředí.

V dnešním článku si základní možnosti nabízené projektem Kite ukážeme na příkladu integrace s programátorskými editory Vim a Visual Studio Code nainstalovanými na Linuxu (konkrétně na Fedoře, ale v tomto ohledu žádné zásadní rozdíly ve fungování Kite nečekejte). Přitom Linux je sice projektem Kite oficiálně podporován, ovšem některé vlastnosti prozatím nejsou implementovány. Týká se to především možnosti spuštění interaktivního pomocníka programátora nazvaného Copilot pomocí ikony v nástrojovém pruhu.

3. Architektura projektu Kite

Architektura kterou používá nástroj Kite se v mnoha ohledech přibližuje architektuře, s níž jsme se již dříve seznámili v souvislosti s nástrojem Jedi. Konkrétně to znamená, že na pozadí je spuštěn proces nazvaný Kite engine, který implementuje veškerou logiku, spravuje data použitá při analýze apod. Přes k tomu určený plugin je Kite engine propojen s programátorským textovým editorem, popř. s integrovaným vývojovým prostředím. Samotné uživatelské rozhraní je již prakticky plně v režii editoru/IDE – to znamená, že způsob zobrazení menu s automatickým doplňováním, nápovědy atd. je závislý na možnostech daného editoru. Ovšem kromě toho lze prakticky nezávisle na editoru/IDE spustit takzvaného copilota, což je samostatně běžící desktopová aplikace s grafickým uživatelským rozhraním, která dokáže zprostředkovat nápovědu k mnoha (skutečně mnoha) knihovnám programovacího jazyka Python, příklady skutečného použití (získané ML modulem) atd. Copilot sice běží v samostatném okně, ovšem může sledovat programový kód zapisovaný uživatelem a ihned (bez nutnosti provádění dalších operací) zobrazit kontextovou nápovědu, což je – nutno říci – vysoce užitečná a současně i návykové chování.

Obrázek 2: Plugin jedi-vim komunikující se serverem Jedi používá podobnou architekturu jako Kite.

Poznámka: většina novějších pluginů pro programátorské textové editory, popř. IDE, je založena na protokolu LSP, s nímž jsme se seznámili v článku Použití Language Server Protocolu v textovém editoru Vim. Samotný protokol je založen na formátu JSON, přesněji řečeno na protokolu JSON-RPC. Při použití LSP je textový editor či IDE považován za klienta a language server pochopitelně vystupuje v roli serveru, který klientovi poskytuje tzv. „language service“. Nástroj Kite používá vlastní komunikační protokol, ovšem LSP lze použít jako zálohu (například takto byla řešena první verze pro integrované vývojové prostředí Spyder).

Obrázek 3: jedi-vim – zobrazení parametrů funkce se zvýrazněním právě zadávaného parametru.

4. Instalace nástroje Kite

Samotná instalace nástroje Kite je – zejména s ohledem na to, že se v ní řeší i integrace s editory a IDE – až překvapivě snadná. Vzhledem k tomu, že Kite s velkou pravděpodobností nenaleznete v repositáři vámi používané linuxové distribuce, je nutné nejdříve stáhnout instalační skript dostupný na adrese https://linux.kite.com/dls/li­nux/current:

$ wget -q https://linux.kite.com/dls/linux/current

a následně (po základním prozkoumání, co se uvnitř děje), tento skript spustit. Pokud v tomto ohledu bezmezně věříte autorům projektu Kite, lze vše provést jediným příkazem:

$ bash -c "$(wget -q -O - https://linux.kite.com/dls/linux/current)"

Obrázek 4: Spuštění instalace příkazem vypsaným nad tímto screenshotem. Instalace se provádí pro aktivního uživatele, nikoli pro roota.

Poznámka: jak již naznačuje výzva (prompt) na příkazovém řádku, provádí se instalace pro aktivního uživatele, nikdy pro roota. Dokonce je instalace rootem zakázána (což je ostatně pro tento typ software jen dobře). K zadání hesla pro sudo budete vyzváni jen při změně konfigurace systému (sledován změn inodů), ovšem nejedná se o kritickou část – může být přeskočena.

Obrázek 5: Úpravu souboru /etc/sysctl.d je možné přeskočit – instalátor Kite tak ani na chvíli nedostane práva roota.

Kite používá lokální databázi s analyzovanými daty používanými při automatické nápovědě atd. I z tohoto důvodu je při instalaci vyžadováno přes půl gigabajtu diskového prostoru (další desítky megabajtů zaberou jednotlivé pluginy do textových editorů a IDE):

Running /home/ptisnovs/kite-installer install
[installer] no previous kite installation found
[installer] latest version is 2.20200310.0, downloading now...
[installer] Downloading Kite:   99.9% of 370MiB
[installer] verifying checksum
[installer] validating signature
[installer] installing version 2.20200310.0
[installer] installed ~/.config/autostart/kite-autostart.desktop
[installer] installed ~/.config/systemd/user/kite-updater.service
[installer] installed ~/.config/systemd/user/kite-updater.timer
[installer] installed ~/.local/share/applications/kite-copilot.desktop
[installer] installed ~/.local/share/applications/kite.desktop
[installer] installed ~/.local/share/icons/hicolor/128x128/apps/kite.png
[installer] installed ~/.local/share/kite/kited
[installer] installed ~/.local/share/kite/uninstall
[installer] installed ~/.local/share/kite/update
[installer] activating kite-updater systemd service
[installer] registering kite:// protocol handler
[installer] kite is installed! launching now! happy coding! :)
[installer] run /home/ptisnovs/.local/share/kite/kited
[installer]     or launch it using the Applications Menu
Removing kite-installer
Poznámka: kromě vlastního Kite engine se spouští i kite-updater zajišťující mj. zjišťování informací o nových verzích Kite a popř. instalaci nových verzí.

5. Dokončení grafické části instalace

Druhá část instalace, která plynule navazuje na část popsanou v předchozí kapitole, je již plně grafická a je postupně popsána na dalších screenshotech.

Obrázek 6: Vyplnění základních údajů a volba, že instalátor má detekovat všechny editory a IDE, které jsou podporovány.

Ve skutečnosti není zadání e-mailové adresy striktně vyžadováno a dokonce není nutné se nikam registrovat. Na rozdíl od předchozích verzí Kite se navíc zdrojové kódy analyzují přímo na počítači uživatele a nikam se neposílají.

Obrázek 7: Korektně se našly pouze dva podporované editory, do nichž bude vzápětí doinstalován příslušný plugin.

Pro odinstalaci nástroje Kite poslouží následující příkaz:

$ ./.local/share/kite/uninstall
Poznámka: je však nutné si uvědomit, že se výše uvedeným příkazem odstraní pouze „engine“ tohoto nástroje i Copilot. Pokud je již nainstalována integrace s nějakým IDE či programátorským textovým editorem, je nutné odinstalaci těchto částí provést explicitně – ve Vimu smazáním příslušných souborů „*kite*“ v podadresáři ~/.vim, v případě VS Code pak odinstalací přes panel „Extension“. Taktéž – pokud máte rádi pořádek na disku – můžete smazat celý adresář ~/.kite, který taktéž nebývá vyčištěn automaticky.

6. Plugin pro Visual Code Studio

Dále je vhodné do Visual Studia Code (což je jeden v tomto článku použitých programátorských editorů) doinstalovat ještě jeden plugin – Kite Python Autocomplete. Instalace je snadná, prakticky okamžitá a provede se přímo přes standardní panel „Extensions“ (dostupný na levém pruhu s ikonami):

Obrázek 8: Nalezení pluginu Kite Python Autocomplete.

Obrázek 9: Po nainstalování pluginu Kite Python Autocomplete – kontrola nainstalovaných pluginů a rozšíření Visual Studio Code.

Poznámka: Kite nevyžaduje žádné další pluginy, na druhou stranu s ostatními pluginy určenými pro jazyk Python nekoliduje (alespoň jsem na výraznější problém po několikadenním používání nenarazil).

7. Spuštění Vimu s pluginem pro Kite

Ještě si pro úplnost ukažme, jak vlastně vypadá první spuštění textového editoru Vim ihned poté, co byl nainstalován nástroj Kite. Žádné ruční zásahy do konfigurace Vimu nebyly a ani nemusely být provedeny, což je zvláštní, protože moje .vimrc má velikost přes padesát kilobajtů a instalace jiných pluginů si většinou žádá určité netriviální úpravy.

Obrázek 10: První informace o tom, že je Vim integrován s Kite. Výběrem možnosti 1 v zobrazeném menu se v novém tabu zobrazí podrobnější informace.

Obrázek 11: Podrobnější informace o propojení Vimu a Kite.

Poznámka: kupodivu není nápověda ke Kite zařazena do systému integrované nápovědy textového editoru Vim.

Dále je vhodné nastavit volby statusline a laststatus způsobem, který je ukázán níže (tato možnost není provedena automaticky):

set statusline=%<%f\ %h%m%r%{kite#statusline()}%=%-14.(%l,%c%V%)\ %P
set laststatus=2  " always display the status line

Po nastavení těchto voleb (můžete si je přidat do .vimrc) bude zajištěno, že se na stavovém řádku, popř. na pravítku zobrazí mj. i stav Kite enginu. Je tak možné zjistit, zda je engine vůbec spuštěn, zda nezpracovává data o projektu (což může zpočátku nějakou dobu trvat) a kdy je engine plně připraven poskytovat (přes plugin editoru) všechny potřebné služby.

Poznámka: podrobnější informace o tom, jaké možnosti nabízí volby statusline a laststatus, naleznete v článku Textový editor Vim jako IDE (12.část: konfigurace pravítka a stavového řádku).

Způsob integrace s Vimem si podrobněji popíšeme v navazujících kapitolách.

Obrázek 12: Test, zda běží Kite engine. Tento test proveďte pokaždé, když se zdá, že plugin Kite z nějakého důvodu nefunguje.

8. Konfigurace pluginu Kite v textovém editoru Vim

Chování pluginu Kite v textovém editoru Vim je možné ovlivnit pomocí několika voleb. Jedná se o globální proměnné nastavované například přímo v souboru .vimrc:

# Volba Význam volby
1 g:kite_auto_complete povolení či zákaz automatického doplňování bez použití další klávesové zkratky
2 g:kite_snippets=0 povolení či zákaz zobrazení úryvků kódů (code snippets)
3 g:kite_tab_complete=1 rozhodnutí, zda se má pro automatické doplnění použít Tab nebo Ctrl-Y (výchozí volba)
4 g:kite_previous_placeholder=‚<C-K>‘ klávesové zkratky použité pro doplnění automaticky vygenerovaných úryvků kódů
5 g:kite_next_placeholder='<C-J>` klávesové zkratky použité pro doplnění automaticky vygenerovaných úryvků kódů
6 g:kite_documentation_continual=1 povolení automatického zobrazení dokumentace v Copilotovi bez nutnosti používat klávesovou zkratku K

Pro nepřímou interakci s nástrojem Kite by měly postačovat následující klávesové zkratky:

Klávesová zkratka Význam zkratky
<C-X><C-U> doplnění jména funkce, metody, třídy, balíčku atd.(omnicomplete)
<C-y> doplnění v režimu omnicomplete (viz volbu g:kite_tab_complete)
Tab doplnění v režimu omnicomplete (viz volbu g:kite_tab_complete)
K zobrazení informace o funkci/metodě/třídě v Copilotovi (ve výchozím nastavení se zobrazí manuálová stránka)
Poznámka: možnosti nabízené technologií omnicomplete jsou pro úplnost zmíněny doplňkové sedmnácté kapitole.

Obrázek 13: První spuštění Copilota.

9. Polointeligentní automatické doplňování kódu

Jedním z důvodů pro instalaci nástroje Kite je vylepšené automatické doplňování kódu, které nám může po delší práci připadat „polointeligentní“ (v kladném významu tohoto slova – tedy spíše inteligentní, než strojově stupidní), ovšem skutečně se jedná především o důsledek sběru velkého množství dat. Autoři Kite porovnávají automatické doplnění (resp. přesněji řečeno nabídku všech možností pro automatické doplnění) s PyCharmem a taktéž s výše zmíněným nástrojem Jedi. Nejdříve se na toto porovnání podívejme:

Obrázek 14: Porovnání nabídky identifikátorů PyCharmem, nástrojem Jedi a nástrojem Kite.
Zdroj: oficiální video o Kite

Můžeme zde vidět, že PyCharm (a s ním i mnoho dalších jednodušších doplňovačů) nabízí identifikátory v abecedním pořadí. Totéž platí o Jedi, v němž se ovšem identifikátory začínající podtržítkem a tedy většinou určené pro interní použití zobrazují až na konci. Naproti tomu Kite zpočátku nabízí identifikátory v takovém pořadí, v jakém jsou použity v reálných projektech. A pokud velikost aktuálně vyvíjeného projektu přesáhne určitou hodnotu, budou se nabízet identifikátory i na základě jejich použití v tomto projektu.

Poznámka: zdánlivě se jedná pouze o minimální vylepšení, ovšem v praxi může přinést jak velké časové úspory, tak i zlepšit povědomí o používané knihovně, protože Kite může nabízet i ty funkce/metody, které vývojář předtím neznal.

10. Ukázka doplňování jmen balíčků ve Visual Studio Code

Jak však vypadá ono zmíněné poloautomatické doplňování kódu v praxi? Podívejme se na několik příkladů:

Obrázek 15: Zdánlivě běžná nabídka balíčku pro import. Balíček Json je nejpoužívanější. Povšimněte si informace o tom, jaký modul menu zobrazuje.

Obrázek 16: Opět nabídka seřazená podle reálného použití modulů začínajících na „req“.

Obrázek 17: Modul Kite nabízí i zkrácenou verzi nápovědy k doplňovanému symbolu (zde názvu balíčku).

Obrázek 18: Toto už je zajímavější a užitečnější funkcionalita – nabídka nejpoužívanějšího podbalíčku, ovšem současně i pojmenování. A skutečně import matplotlib.pyplot as plt je používáno v mnoha projektech a dokonce i v oficiální dokumentaci. Projekt tedy bude používat všeobecně známé idiomy.

11. Odvození proměnné použité jako parametr při volání funkce či metody

Další užitečnou vlastností projektu Kite je schopnost v některých případech odvodit proměnnou, která má být použita jako parametr při volání funkce či metody (v Go je možné namísto proměnné použít i konstantu). Opět se podívejme, jak se tato vlastnost projeví při práci ve Visual Code Studiu:

Obrázek 19: Podle očekávání se po zápisu znaku „g“ nabídne nejpoužívanější funkce – get.

Obrázek 20: Zobrazení nápovědy k funkci get.

Obrázek 21: Nyní budeme chtít zavolat právě funkci get.

Obrázek 22: Nástroj Kite nám nabídne, že se má použít proměnná nazvaná stejně, jako výchozí parametr funkce get.

Obrázek 23: Podobně to funguje i ve složitějším případě u funkce s větším počtem parametrů.

Poznámka: v tomto případě se vlastně zkombinovaly dvě technologie – nabídka nejpoužívanějších parametrů a současně i spárování jmen parametrů se jmény dostupných (viditelných) proměnných.

Obrázek 24: Složitější příklad, tentokrát používající jména parametrů a nikoli jména proměnných.

12. Zobrazení podrobnější nápovědy

Další užitečnou funkcí nástroje Kite je zobrazení podrobnější nápovědy k importovanému balíčku, konstruované třídě, volané funkci či metodě. Opět si nejdříve toto chování ukážeme na příkladu Visual Code Studia:

Obrázek 25: Běžný pokus o zavolání nějaké funkce.

Obrázek 26: Zobrazení dokumentace k modulu, z něhož chceme funkci volat.

*** image ***

Obrázek 27: Další dokumentaci – plně formátovanou a s hypertextovými odkazy – lze zobrazit v Copilotovi, který je automaticky zobrazen přímo z editoru.

Obrázek 28: Tento modul nemám nainstalovaný, přesto k němu je možné zobrazit nápovědu.

Obrázek 29: Možnost zobrazení dokumentace k funkci, která se již ve zdrojovém kódu používá (přes kontextové menu).

13. Copilot

S Copilotem jsme se již setkali. Jedná se o samostatnou aplikaci s vlastním grafickým uživatelským rozhraním, která dokáže vyhledat a zobrazit dokumentaci k vybraným balíčkům, třídám, metodám a funkcím. I když se jedná o samostatnou aplikaci, lze ji spárovat s IDE či s programátorským textovým editorem, což jsme ostatně již viděli v předchozích kapitolách. Důležitá je volba follow cursor, díky níž může Copilot sledovat zapisovaný text a ihned reagovat změnou svého obsahu. Ideální je tedy mít Copilota zobrazeného na jedné straně monitoru (když už mnohdy musíme jako vývojáři používat monitory navržené pro zcela jiný segment trhu).

Obrázek 30: Grafické uživatelské rozhraní Copilota.

14. Plugin Kite v textovém editoru Vim

Nyní si můžeme ukázat, jak je nástroj Kite integrován se známým programátorským textovým editorem Vim. Již dopředu je vhodné říci, že z pohledu funkcí nabízených Kite se od sebe Vim a Visual Code Studio vlastně nijak zásadně neliší – jiné je jen ovládání a samozřejmě i vzhled.

Poznámka: jak je ze screenshotů patrné, používám GVim a nikoli konzolový Vim. Rozdíl je vlastně jen jediný – v GVimu se správně zobrazuje logo projektu Kite; jinak bych stejně dobře mohl použít i konzolový Vim.

Obrázek 31: Nabídka modulu pro import a současně i ukázka, jak import provádí jiní programátoři. Povšimněte si loga projektu Kite – jedná se o znak dvou trojúhelníků vzdáleně připomínajících draka.

Obrázek 32: Nabídka funkcí, pochopitelně opět setříděná podle toho, jak často jsou funkce používány.

Obrázek 33: Automatické doplňování parametrů volané funkce.

Obrázek 34: Automatické doplňování parametrů volané funkce.

15. Vim a Copilot

Vim/GVim/KVim je pochopitelně možné použít i s Copilotem, a to dvěma způsoby – buď se Copilot zobrazí po stisku klávesy K (namísto zobrazení manuálové stránky), nebo se bude zobrazovat nápověda k textu pod kurzorem (musí být povolena volba sledování kurzoru).

Obrázek 35: První zobrazení Copilota na „náhodném“ místě na obrazovce.

Obrázek 36: Umístění Copilota na okraj monitoru. Povšimněte si, že je zapnuta volba sledování kurzoru.

Obrázek 37: Nabídka nejčastěji volaných funkcí balíčku numpy + nápověda v Copilotovi

Obrázek 38: Nabídka nejčastěji volaných funkcí balíčku numpy + nápověda v Copilotovi

16. Závěr

V současnosti je nástroj Kite stabilní a poměrně dobře použitelný, i když se (zdaleka) nejedná o finální produkt. Oproti variantě, kdy se zdrojové kódy posílaly na analýzu na vzdálený stroj je lokální běh (podle mého názoru) vylepšením a samotná existence procesu kited je na běžném tři roky starém notebooku zcela bezproblémová, dokonce i při otevření většího projektu (zde je ovšem nutné při prvním otevření čekat na analýzu, a to jednotky až desítky sekund). V článku jsem se zaměřil na použití Kite společně s Pythonem, protože podpora pro Go prozatím není zdaleka tak propracovaná – podle mého názoru pro Go zatím nemá tento projekt větší význam, což se ovšem v budoucnosti pravděpodobně změní.

17. Příloha: omnicompletion ve Vimu

V příloze se zmíníme o velmi užitečné vlastnosti textového editoru Vim, která je nástrojem Kite využita. Jedná se o technologii nazvanou „omni completion“ (někdy se setkáme i s jednoslovným zápisem „omnicompletion“). Tato technologie, která se ve Vimu objevila až v jeho sedmé verzi, rozšiřuje možnosti automatického doplňování kódu (či obecně textu) o externí nástroje. Připomeňme si, že Vim nabízí ve vkládacím a přepisovacím režimu klávesovou zkratku Ctrl+P (previous) pro nalezení a doplnění slova nacházejícího se před kurzorem a taktéž zkratku Ctrl+N (next), která slouží ke stejnému účelu, ovšem hledá slovo pro doplnění v textu za kurzorem (pokud je k dispozici více možností, zobrazí se v kontextovém menu). V praxi tedy postačuje napsat jen začátek slova a stlačit Ctrl+P nebo Ctrl+N. Rozsah vyhledávání se specifikuje volbou complete popsanou zde a samozřejmě i ve vestavěné nápovědě.

Obrázek 39: Doplňování kódu nebo libovolného textu pomocí příkazů CTRL+P a CTRL+N zavolaných v režimu zápisu (insert mode).

Ovšem možnosti automatického doplňování kódu jsou ve skutečnosti daleko větší a textový editor Vim pro ně dokonce nabízí samostatný režim vyvolávaný z vkládacího či přepisovacího režimu klávesovou zkratkou Ctrl+X (právě z tohoto důvodu se tento režim nazývá ^X-mode nebo též CTRL-X mode). Po stlačení této klávesové zkratky se v příkazové řádce objeví řádkové menu s příkazy platnými pro režim doplňování:

Root obecný tip

Všechny dostupné příkazy jsou vypsány v tabulce níže:

# Příkaz Význam
1 Ctrl+X Ctrl+L nalezení a doplnění celého (shodného) řádku, užitečné především v případě editace některých typů konfiguračních souborů
2 Ctrl+X Ctrl+N doplnění slova, které se nalézá v aktuálně editovaném souboru
3 Ctrl+X Ctrl+K podobné Ctrl+N, ovšem slova se hledají v souborech specifikovaných pomocí konfiguračního parametru dictionary (jedná se o běžný textový soubor se seznamem slov)
4 Ctrl+X Ctrl+T podobné Ctrl+T, ovšem slova se hledají v souborech specifikovaných pomocí konfiguračního parametru thesaurus
5 Ctrl+X Ctrl+I podobné Ctrl+N, ovšem prohledávají se i všechny vkládané (included) soubory
6 Ctrl+X Ctrl+] vyhledávání v seznamu značek
7 Ctrl+X Ctrl+F doplnění názvu souboru a/nebo cesty, postačuje například zadat text ~/ za nímž následuje klávesová zkratka Ctrl+X Ctrl+F a zobrazí se výpis souborů v domácím adresáři
8 Ctrl+X Ctrl+D vyhledání definice makra a doplnění jména tohoto makra
9 Ctrl+X Ctrl+U zavolání funkce zadané v konfiguračním parametru completefunc, které se předá právě editovaný text
10 Ctrl+X Ctrl+O vyvolání funkce omni completion (dostupné od Vimu 7)

Obrázek 40: Doplnění názvu souboru v pracovním adresáři pomocí příkazu CTRL+X CTRL+F.

18. Odkazy na Internetu

  1. Stránky projektu Kite
    https://kite.com/
  2. Kite Autocomplete Plugin for Vim
    https://kite.com/integrations/vim/
  3. Visual Studio IntelliCode
    https://visualstudio.micro­soft.com/services/intelli­code/
  4. Vote for Kite's Next Language
    https://kite.com/letmeknow/
  5. Pair programming
    https://en.wikipedia.org/wi­ki/Pair_programming
  6. Intelligent code completion
    https://en.wikipedia.org/wi­ki/Intelligent_code_comple­tion
  7. Atom: moderní textový editor
    https://www.root.cz/clanky/atom-moderni-textovy-editor/
  8. Atom: moderní textový editor (dokončení)
    https://www.root.cz/clanky/atom-moderni-textovy-editor-dokonceni/
  9. PyCharm
    https://www.jetbrains.com/pycharm/
  10. Stránky projektu Atom
    https://atom.io/
  11. Sublime Text
    https://www.sublimetext.com/
  12. Spyder
    https://www.spyder-ide.org/
  13. Vim
    https://www.vim.org/
  14. Visual Studio Code
    https://code.visualstudio.com/
  15. IDEA
    https://www.jetbrains.com/idea/
  16. Kite – Linux install issues
    https://help.kite.com/article/106-linux-install-issues
  17. The Kite Copilot
    https://kite.com/copilot/
  18. How Kite works
    https://help.kite.com/article/55-how-kite-works
  19. Knihovna Jedi: doplňování kódu a statická analýza kódu v Pythonu
    https://www.root.cz/clanky/knihovna-jedi-doplnovani-kodu-a-staticka-analyza-kodu-v-pythonu/
  20. Knihovna Jedi: doplňování kódu a statická analýza kódu v Pythonu (dokončení)
    https://www.root.cz/clanky/knihovna-jedi-doplnovani-kodu-a-staticka-analyza-kodu-v-pythonu-dokonceni/
  21. Visual Studio IntelliCode (na marketplace)
    https://marketplace.visual­studio.com/items?itemName=Vi­sualStudioExptTeam.VSInte­lliCode
  22. Použití Language Server Protocolu v textovém editoru Vim
    https://www.root.cz/clanky/pouziti-language-server-protocolu-v-textovem-editoru-vim/
  23. How to use the Copilot
    https://help.kite.com/article/63-using-the-copilot
  24. Kite Python Plugin for Vim/Neovim
    https://github.com/kiteco/plu­gins/tree/master/vim
  25. Textový editor Vim jako IDE (12.část: konfigurace pravítka a stavového řádku)
    https://www.root.cz/clanky/textovy-editor-vim-jako-ide-12-cast-konfigurace-pravitka-a-stavoveho-radku/
  26. Langserver.org
    https://langserver.org/
  27. Language Server Protocol
    https://microsoft.github.io/language-server-protocol/
  28. Language Server Protocol Specification
    https://microsoft.github.io/language-server-protocol/specification
  29. Implementations Language Servers
    https://microsoft.github.io/language-server-protocol/implementors/servers
  30. JSON-RPC 2.0 Specification
    https://www.jsonrpc.org/specification
  31. Why You Should Know the Language Server Protocol
    https://tomassetti.me/what-is-the-language-server-protocol/
  32. Language Server Protocol: A Language Server For DOT With Visual Studio Code
    https://tomassetti.me/language-server-dot-visual-studio/
  33. Python Language Server
    https://github.com/palantir/python-language-server
  34. Jedi – an awesome autocompletion/static analysis library for Python
    https://github.com/davidhalter/jedi
  35. What is lsp
    https://www.reddit.com/r/vim/com­ments/7lnhrt/which_lsp_plu­gin_should_i_use/
  36. Vim-lsp
    https://github.com/prabirshrestha/vim-lsp
  37. Using LSP & clangd in Vim
    https://jonasdevlieghere.com/vim-lsp-clangd/
  38. Seriál Textový editor Vim jako IDE
    https://www.root.cz/serialy/textovy-editor-vim-jako-ide/
  39. Seriál VIM na plný výkon
    https://www.root.cz/serialy/vim-na-plny-vykon/
  40. What about a Common Debug Protocol?
    https://kichwacoders.com/2017/07/28/what-about-a-common-debug-protocol/
  41. Example – Debug Adapter
    https://code.visualstudio­.com/docs/extensions/exam­ple-debuggers
  42. Konfigurační volba complete
    http://vimdoc.sourceforge­.net/htmldoc/options.html#‚com­plete‘
  43. Konfigurační volba completeopt
    http://vimdoc.sourceforge­.net/htmldoc/options.html#‚com­pleteopt‘
  44. Make Vim completion popup menu work just like in an IDE
    http://vim.wikia.com/wiki/Ma­ke_Vim_completion_popup_me­nu_work_just_like_in_an_I­DE