Micro: až překvapivě kvalitní textový editor

Některé z nich jsou až překvapivě kvalitní. Na stránkách Roota jsme se s některými těmito editory setkali. Jedná se o Kakoune (jenž ukázal, že i modální ovládání odvozené od editoru Vi se může dále vyvíjet) a především o textový editor Helix.

Ovšem zapomenout nesmíme ani na textové editory, které jsou sice určeny pro spuštění v terminálu (konzoli), ovšem jejich ovládání je do značné míry konzistentní s aplikacemi s grafickým uživatelským rozhraním (výběr textu klávesou Shift, klávesové zkratky pro kopii textu, pro operaci undo atd.). Jedním z těchto editorů je textový editor micro, jemuž se budeme věnovat v dnešním článku. Tento editor „klame tělem“, protože je snadno ovladatelný (nemodální), ovšem na stranu druhou nabízí i poměrně pokročilé operace, například využití multikurzoru, příkazovou řádku, ale dokonce i vestavěný emulátor terminálu (to do značné míry chybí v Helixu a vlastně i ve Vimu).

micro > nano > pico

Na tomto místě je možná vhodné vysvětlit, proč se vlastně editor micro (mimochodem: jeho jméno skutečně začíná malým písmenem) jmenuje micro. Jeho ideovým předchůdcem je totiž známý textový editor nazvaný GNU nano [10]. V současnosti se jedná o poměrně známou aplikaci, a to především z toho důvodu, že je standardní součástí instalace mnoha distribucí Linuxu, což zjednodušuje konfiguraci a administraci systému i těm uživatelům, kteří neznají či nechtějí používat Vim (resp. jeho minimální instalaci dostupnou i v základní instalaci pod jménem vi).

A samotný textový editor GNU nano vznikl jako náhrada za starší editor Pico, jenž byl sice součástí e-mailového klienta Pine, ovšem bylo ho možné použít i jako samostatnou aplikaci. Nicméně kvůli poněkud restriktivní licenci dvojice Pine+Pico se už před mnoha lety programátoři a distributoři Debianu rozhodli, že vytvoří sice podobně koncipovaný editor, ovšem s výhodnější licencí, jehož jméno – nano – je odvozeno od předpony soustavy SI (podobně jako Pico). A právě na tyto dva editory ideově navazuje i micro (další předpona SI).

První seznámení s editorem micro

Editor micro je možné do značné míry považovat za nemodální textový editor. To znamená, že stisk nějaké běžné alfanumerické klávesy zapíše příslušný znak do aktivního okna editoru – to zobrazuje buď text přečtený ze souboru zadaného na příkazové řádce, nebo se jedná o text, který se do souboru uloží později (například stiskem klávesy F2). Ve skutečnosti však i micro obsahuje ještě druhý režim, který se spouští klávesou Ctrl+E. Jedná se o režim příkazové řádky, kterému se budeme věnovat v osmé kapitole. Ovšem uživatel, který pouze potřebuje editovat nějaký konfigurační soubor či zapsat delší text a nevyžaduje tedy konfiguraci editoru ani režim s více okny, nemusí Ctrl+E vůbec využít. V takovém případě se micro chová velmi podobně, jako nano, pico či editor Joe, tedy jako skutečný nemodální textový editor, který od uživatele nevyžaduje žádné speciální znalosti ani trénink.

Editor micro je navíc i ve výchozím nastavení plně funkční, podporuje zvýraznění syntaxe, využívá myš atd. Opět se jedná o aplikaci základní filozofie (kterou se řídí i editor Helix): už po instalaci editoru by mělo být vše rozumně nastaveno, na druhou stranu musí mít profesionál možnost rekonfigurace (což má).

Základní klávesové zkratky

Základní klávesové zkratky editoru micro jsou zvoleny tak, aby nebyly příliš odlišné od zkratek používaných v aplikacích s grafickým uživatelským rozhraním. Nalezneme zde tedy klasické zkratky pro práci s vybraným textem Ctrl+X, Ctrl+C a Ctrl+V, práci s historií editace (undo/redo) Ctrl+Z, Ctrl+Y, ale i zkratky pro otevření a uložení souboru Ctrl+O a Ctrl+S nebo pro ukončení editoru či zavření okna Ctrl+Q. Na druhou stranu například GNU nano používá vlastní zkratky, které jsou kompatibilní jen s nano a částečně s editorem pico.

Na většině terminálů budou funkční i kurzorové šipky (pohyb kurzoru), Alt+šipky (pohyb na začátek a konec řádku popř. posun řádku nahoru a dolů – velmi návykové), ale i Shift+šipky (výběr textu). A mělo by být možné použít i další klávesy typu Home, End, PageUp a PageDown s běžným významem.

Zmiňme se ještě o klávesách F1-F10:

Podpora myši

Textový editor micro obsahuje podporu pro použití myši, čímž se přibližuje textovým editorům s plnohodnotným grafickým uživatelským rozhraním. Myš je možné využít pro výběr textu (dokonce je podporován posun v textovém okně, což se mi například nikdy nepodařilo nakonfigurovat ve Vimu), je podporováno kolečko myši pro scrolling, myší je možné měnit velikost oken atd. Práce s myší je tak velmi přirozená, na rozdíl od mnoha jiných aplikací s textovým uživatelským rozhraním (TUI), které sice myš taktéž (mnohdy) podporují, ale většinou jen „napůl“. Micro tedy uživateli dává na výběr – buď editor plně ovládat jen s využitím klávesnice, nebo (když je to zapotřebí) použít myš. Příkladem je již zmíněná změna velikosti oken, která se s využitím myši provádí zcela jednoduše a plně intuitivně.

Rozdělení plochy editoru do více oken

V textovém editoru micro je možné současně editovat větší množství souborů popř. jeden soubor, ale na různých místech. K tomu slouží především taby (lze jich otevřít prakticky libovolné množství a nezabírají žádnou plochu obrazovky) a taktéž okna (window). Práce s okny je snadná, protože potřebujeme pouze tři operace: horizontální či vertikální rozdělení aktivního okna a přepínaní mezi okny. Horizontální či vertikální rozdělení se provádí v příkazovém režimu:

Ctrl+E hsplit Enter
Ctrl+E vsplit Enter

Přepínání mezi okny se provádí snadno zapamatovatelnou klávesovou zkratkou Ctrl+W. Změnu velikosti oken lze provést myší a uzavření okna již známe – Ctrl+Q.

Multikurzor

Velmi užitečnou vlastností editoru micro je podpora pro vícenásobné kurzory (multikurzory). Práce s nimi je velmi jednoduchá a využije se například při editacích tabulek atd. Vícenásobný kurzor se vytvoří a popř. rozšíří na další řádky klávesovými zkratkami Alt+Shift+šipka nahoru/dolů. Tento kurzor tedy bude obsahovat několik kurzorů, které se nachází pod sebou (ovšem pokud například stiskneme klávesu End, bude multikurzor přesunut na konec všech řádků, které nemusí být stejně dlouhé). Jakákoli editační operace podporovaná textovým editorem, například vložení znaků, přepis znaků či jejich vymazání, se projeví na všech řádcích, ve kterých se multikurzor nachází. A navíc je možné multikurzorem pohybovat s využitím všech dostupných příkazů, včetně šipek, Home/End atd. Pokud budete potřebovat multikurzor odstranit a přepnout se do režimu s jediným kurzorem, postačuje stisknout klávesovou zkratku Alt+C.

Příkazová řádka

Již v předchozích kapitolách jsme se zmínili o příkazové řádce. Jedná se o režim editoru micro, ve kterém je možné zapisovat příkazy, které editor ihned vykoná. K těmto příkazům v základním nastavení neexistuje klávesová zkratka, ovšem v případě potřeby ji lze libovolnému příkazu přiřadit. Do příkazové řádky se lze přepnout klávesou Ctrl+E. Na příkazové řádce je plně podporováno automatické doplňování jména příkazu nebo jeho parametru klávesou Tab a kromě toho lze na příkazové řádce používat všechny klávesové zkratky pro editaci atd. (příkazová řádka se v tomto ohledu chová jako textový soubor s jediným řádkem). Podporovány jsou následující příkazy:

Spuštění externích příkazů přímo z editoru

V editoru micro najdeme i poměrně užitečnou, i když poněkud skrytou klávesovou zkratku Ctrl+B. Po jejím stisku se zobrazí příkazová řádka, ovšem ta je v mnoha ohledech odlišná od řádky popsané v předchozí kapitole. Na tuto příkazovou řádku lze zapsat libovolný příkaz, který je následně proveden shellem. Můžeme tedy použít příkazy typu ls, git add foo.py atd. atd. a to bez nutnosti přecházet do plnohodnotného emulátoru terminálu, o němž se zmíníme v navazující kapitole.

Vestavěný emulátor terminálu

Textový editor micro obsahuje i vestavěný emulátor terminálu. Ten se spouští příkazem term (tedy Ctrl+E term Enter). Terminál se otevře na místě aktivního textového okna. Pokud tedy budeme vyžadovat, aby byl na jedné polovině okna editoru zobrazen zdrojový kód a na druhé polovině terminál, postačuje okno rozdělit (Ctrl+E vsplit Enter), přepnout se do druhého okna a otevřít terminál:

Terminál se ukončí příkazem exit.

Úpravy vzhledu a chování textového editoru

V editoru micro je možné upravovat jeho vzhled i chování. To se provádí buď při startu editoru, protože nastavení lze provést na příkazovém řádku, nebo se v příkazovém režimu použije příkaz set, za nímž následuje identifikace vlastnosti, kterou potřebujeme změnit a poté i hodnota vlastnosti. Užitečné přitom je, že se toto nastavení „zapamatuje“ v konfiguračním souboru, takže po restartu editoru je obnoveno.

Příkladem nastavení je volba softwrap, která určuje, jakým způsobem se mají zobrazit textové řádky delší, než je velikost okna editoru:

Ctrl+E set softwrap true Enter

Podobným způsobem můžeme nastavit například velikost tabelační zarážky:

Ctrl+E set tabstop 8

Výběr barvového schématu

Nejjednodušší je výběr barvového schématu. Postačuje se přepnout do příkazového řádku klávesovou zkratkou Ctrl+E a napsat začátek příkazu:

set colorscheme

Následně je možné klávesou Tab zahájit výběr barvového schématu. Po stisku Enter se vybrané schéma ihned použije a navíc dojde i k uložení nastavení do souboru ./config/micro/settings.json. Ten může vypadat například následovně:

{
    "colorscheme": "darcula",
    "softwrap": true
}

Nastavení klávesových zkratek

Nastavení nových klávesových zkratek resp. změna existujících zkratek, se dá provést buď interaktivně nebo změnou konfiguračního souboru ~/.config/micro/settings.json. Modifikace konfiguračního souboru je dobře popsaná v nápovědě, v níž je ukázán i příklad vytvoření nové klávesové zkratky Ctrl+R:

{
    "Ctrl-r": "Redo"
}

Interaktivní nastavení či modifikace klávesových zkratek se provádí v příkazovém režimu (Ctrl+E) příkazem bind. Řekněme, že budeme chtít nadefinovat klávesové zkratky pro vertikální a horizontální rozdělení okna klávesami F8 a F9 (které nejsou obsazeny). To je v příkazovém režimu snadné:

bind "F8" command vsplit
bind "F9" command hsplit

Nové klávesové zkratky lze ihned využít, ovšem navíc jsou automaticky uloženy do souboru settings.json, který bude vypadat takto:

{
    "F8": "command:vsplit",
    "F9": "command:hsplit"
}

Nastavení chování pro různé typy souborů

Mnohdy je vyžadováno, aby editor zpracovával různé typy souborů (zdrojové kódy atd.) odlišným způsobem. I tuto možnost micro podporuje. Ukažme si typický příklad. Vyžadujeme, aby se při editaci zdrojových kódů jazyka Go používaly znaky tabulátoru (tedy aby nebyly převáděny/expandovány na mezery). Naproti tomu v Pythonu převádění na mezery vyžadujeme; konkrétně se bude tabulátor převádět na čtyři mezery. A v ostatních případech se spokojíme s expanzí tabulátoru na dvě mezery. Taková konfigurace může vypadat následovně:

{
    "ft:go": {
        "tabstospaces": false
    },
    "ft:python": {
        "tabsize": 4
    },
    "tabstospaces": true,
    "tabsize": 2
}

Jen pro zajímavost se podívejme na to, jak je definována syntaxe. Je to relativně jednoduché, zejména v porovnání s (například) Vimem, kde se stejná syntaxe (zde jazyka Go) definuje v souboru o dvojnásobné délce:

filetype: go
 
detect:
    filename: "\\.go$"
 
rules:
    # Conditionals and control flow
    - special: "\\b(break|case|continue|default|go|goto|range|return|println|fallthrough)\\b"
    - statement: "\\b(else|for|if|switch|select)\\b"
    - preproc: "\\b(package|import|const|var|type|struct|func|defer|iota|make|new|copy|len|cap|panic|append|close|delete|print|recover)\\b"
    - symbol.operator: "[-+/*=<>!~%&|^]|:="
 
      # Types
    - symbol: "(,|\\.)"
    - type: "\\b(u?int(8|16|32|64)?|float(32|64)|complex(64|128))\\b"
    - type: "\\b(uintptr|byte|rune|string|interface|bool|map|chan|error)\\b"
    - type.keyword: "\\b(struct)\\b"
    - constant.bool: "\\b(true|false|nil)\\b"
 
      # Brackets
    - symbol.brackets: "(\\{|\\})"
    - symbol.brackets: "(\\(|\\))"
    - symbol.brackets: "(\\[|\\])"
 
      # Numbers and strings
    - constant.number: "\\b([0-9]+|0x[0-9a-fA-F]*)\\b|'.'"
 
    - constant.string:
        start: "\""
        end: "\""
        skip: "\\\\."
        rules:
            - constant.specialChar: "%."
            - constant.specialChar: "\\\\[abfnrtv'\\\"\\\\]"
            - constant.specialChar: "\\\\([0-7]{3}|x[A-Fa-f0-9]{2}|u[A-Fa-f0-9]{4}|U[A-Fa-f0-9]{8})"
 
    - constant.string:
        start: "'"
        end: "'"
        skip: "\\\\."
        rules:
            - error: "..+"
            - constant.specialChar: "%."
            - constant.specialChar: "\\\\[abfnrtv'\\\"\\\\]"
            - constant.specialChar: "\\\\([0-7]{3}|x[A-Fa-f0-9]{2}|u[A-Fa-f0-9]{4}|U[A-Fa-f0-9]{8})"
 
    - constant.string:
        start: "`"
        end: "`"
        rules: []
 
    - comment:
        start: "//"
        end: "$"
        rules:
            - todo: "(TODO|XXX|FIXME):?"
 
    - comment:
        start: "/\\*"
        end: "\\*/"
        rules:
            - todo: "(TODO|XXX|FIXME):?"

Ukázka přídavného modulu naprogramovaného v jazyce Lua

Editor micro podporuje i rozšiřování funkcionality editoru s využitím přídavných modulů (pluginů), které jsou naprogramovány v jazyce Lua. Používá se tedy stejný jazyk, jaký je využit v Neovimu. Každý plugin je popsán v souboru ve formátu JSON, který obsahuje metainformace o pluginu, jeho jméno, licenci, odkaz na stažení atd.

Ukažme si, jak takový plugin vypadá. Pro jednoduchost se zaměříme na plugin, který po stisku klávesy F1 zjistí, jaký zdrojový kód se edituje (resp. v jakém jazyce je napsán) a zobrazí stručnou nápovědu (cheatsheet) k tomuto jazyku. Tento plugin se jmenuje přímočaře cheat a jeho metainformace vypadají následovně:

[{
  "Name": "cheat",
  "Description": "F1 for cheatsheet related to the type of file you're editing: Lua, Go, Python...",
  "Website": "https://terokarvinen.com/micro",
  "Tags": ["cheatsheet", "help", "docs", "Lua", "Go", "Python", "reference"],
  "License": "MIT license",
  "Versions": [
    {
      "Version": "0.0.4",
      "Url": "https://github.com/terokarvinen/micro-cheat/archive/v0.0.4.zip",
      "Require": {
        "micro": ">2.0.0"
      }
    },
    {
      "Version": "0.0.3",
      "Url": "https://github.com/terokarvinen/micro-cheat/archive/v0.0.3.zip",
      "Require": {
        "micro": ">2.0.0"
      }
    },
    {
      "Version": "0.0.2",
      "Url": "https://github.com/terokarvinen/micro-cheat/archive/v0.0.2.zip",
      "Require": {
        "micro": ">2.0.0"
      }
    },
    {
      "Version": "0.0.1",
      "Require": {
        "micro": ">2.0.0"
      }
    }
  ]
}]

Samotný zdrojový kód pluginu je skutečně napsán ve standardním jazyku Lua a je tudíž dobře čitelný i pro běžné uživatele (na rozdíl od poněkud kryptického VimScriptu nebo ELispu). Povšimněte si rozdělení kódu na inicializaci a vlastní realizaci nového příkazu:

-- micro-cheat copyright 2022 Tero Karvinen https://TeroKarvinen.com
 
-- Cheatsheets are copyrighted by their original authors
 
-- Cheatsheets from Devhints.io are copyright 2021 
-- Rico Sta. Cruz and contributors, received under the MIT license
 
local micro = import("micro")
local config = import("micro/config")
 
local cheatdir = config.ConfigDir.."/plug/cheat/cheatsheets/"
 
function init()
        -- runs once when micro starts
        config.MakeCommand("cheat", cheatCommand, config.NoComplete)
        config.TryBindKey("F1", "command:cheat", false)
end
 
function cheatCommand(bp)
        local filename = bp.Buf:GetName()
        local filetype = bp.Buf:FileType()
 
        if "Vagrantfile" == filename or "Dockerfile" == filename then
                filetype = filename:lower()
                micro.InfoBar():Message("Cheatsheet by file name: "..filename)
        elseif string.find(filename, "\.org$") then -- not detected by micro
                filetype = "org"
                micro.InfoBar():Message("Cheatsheet by file suffix: "..filename)
        elseif "unknown" ~= filetype then
                -- micro hopefully detected the filetype, the typical case
                micro.InfoBar():Message("Cheatsheet by file type: "..filetype)
        else
                micro.InfoBar():Message("Cheatsheet not found for type '"..filetype.."', filename '"..filename.."'")
                return
        end
 
        local cmd = "tab " .. cheatdir .. filetype .. ".md"
        bp:HandleCommand(cmd)
 
end

Nakonfigurovaný plugin dokáže po stisku klávesy F1 zobrazit tuto nápovědu:

Instalace a využití modulu

Plugin nazvaný cheat je oficiálně zaregistrován, což znamená, že jeho instalace je snadná (provede ji přímo editor):

$ micro --plugin install cheat
 
Downloading "cheat" (0.0.4) from "https://github.com/terokarvinen/micro-cheat/archive/v0.0.4.zip"
One or more plugins installed.

Plugin je po instalaci umístěn do adresářové struktury ~/.config/micro:

~/.config/micro$ tree -d
 
.
├── backups
├── buffers
└── plug
    └── cheat
        └── cheatsheets
 
6 directories

Plugin by měl být ihned funkční (i když v mém případě jsem musel upravit cestu k souborům s nápovědou):

Příloha A: balíčky využívané v editoru micro

Editor micro je naprogramován v jazyce Go a využívá několik Go balíčků, o nichž se v této příloze v krátkosti zmíníme.

Jeden z balíčků, které jsou v editoru micro použity, se jmenuje tcell. Tato knihovna umožňuje na libovolnou pozici terminálu vykreslit libovolný znak z Unicode a specifikovat u něj styl vykreslení (tučné písmo, kurzíva, podtržení, přeškrtnutí, blikání), barvu popředí, barvu pozadí a taktéž skupinu dalších znaků, které se postupně složí (představte si spojení háčku s písmenem). Taktéž je podporována změna stylu textového kurzoru, ovšem pouze za předpokladu, že tyto změny podporuje i vlastní emulátor terminálu. To pochopitelně není vše, protože terminál je vstupně-výstupním zařízením. Výstup již známe – je jím mřížka znaků. Vstupem je klávesnice a myš, popř. nějaká další operace vyvolaná například příkazem paste. V knihovně tcell se s těmito zařízeními pracuje tak, že stisk kláves, stisk tlačítek myši (ale i změna velikosti okna terminálu) generuje takzvanou událost, na kterou je možné reagovat.

Události se typicky zpracovávají v nekonečné smyčce (což není tak úplně pravda – z této smyčky se totiž vyskakuje při ukončování aplikace), v níž se postupně čte další událost z takzvané fronty událostí. Aplikace poté může na danou událost nějakým způsobem zareagovat. V kostře příkladu ukázané pod tímto odstavcem je ukázáno, jak se reaguje na dva typy událostí – změna velikosti okna terminálu a stisk nějaké klávesy. Povšimněte si, že událost nesoucí informaci o stisknuté klávese obsahuje jak kód klávesy (kurzorové šipky, Home, End, Esc atd.), tak i kód znaku v případě alfanumerického vstupu (terminál nám přitom nedokáže rozlišit například mezi Levý Shift+A, Pravý Shift+A nebo (Caps Lock) A – vždy dostaneme jen znak „A“):

for {
        screen.Show()
 
        event := screen.PollEvent()
 
        switch ev := event.(type) {
        case *tcell.EventResize:
                screen.Sync()
        case *tcell.EventKey:
                if ev.Key() == tcell.KeyEscape || ev.Key() == tcell.KeyCtrlC {
                        return
                } else if ev.Rune() == 'C' || ev.Rune() == 'c' {
                        screen.Clear()
                }
        }
}

Obrázek 12: Ukázka aplikace naprogramované v Go, která pro vstup a výstup na terminál používá knihovnu tcell – jednoduchý manažer úloh.

Editor micro dále podporuje práci s přídavnými moduly naprogramovanými v jazyku Lua. Vzhledem k tomu, že interpret skriptovacího jazyka Lua je navržen takovým způsobem, aby byl poměrně snadno implementovatelný, asi nebude větším překvapením, že jeho zdrojové kódy byly portovány i do programovacího jazyka Go. To znamená, že se jedná o novou „go-nativní“ implementaci interpretru Luy, která nevyžaduje, aby se z runtime jazyka Go volaly funkce z původní céčkovské knihovny. Touto problematikou jsme se sice prozatím do všech podrobností nezabývali, ovšem ve stručnosti lze říct, že kooperace mezi runtime jazyka Go a nativními céčkovými knihovnami může v praxi způsobovat problémy a není z pohledu programátorů zcela transparentní. Samotné vložení interpretru jazyka Lua do aplikace psané v Go je ovšem velmi snadné – programátor jen musí naimportovat příslušný balíček, inicializovat virtuální stroj jazyka Lua a spustit nějaký skript, jenž může být reprezentován řetězcem nebo může být načten ze souboru. Skript poté může volat předem vybrané funkce naprogramované v jazyku Go a naopak – z Go lze volat libovolnou funkci z Lua skriptu.

Editor micro z této nabídky interpretrů jazyka Lua používá balíček gopher-lua. S jeho základními vlastnostmi jsme se seznámili v samostatném článku.

Příloha B: alternativní textové editory

V článku o textových editorech pro Linux je vhodné zmínit i další alternativy. Vzhledem k tomu, že je micro určen pro práci v terminálu (konzoli), budou i dále popsané editory podporovat právě textovou konzoli.

Prvním celoobrazovkovým textovým editorem, který si v této kapitole ve stručnosti popíšeme, je aplikace, která se jmenuje e3. Již samotné pojmenování tohoto editoru naznačuje, že se jeho autor Albrecht Kleine snažil o vytvoření minimalistického nástroje, což se skutečně (alespoň podle mého názoru) povedlo. Textový editor e3 je totiž naprogramován v assembleru mikroprocesorů řady x86. Zdrojový kód původní verze e3 je uložen v jediném souboru s přibližně 6500 řádky optimalizovaného assembleru určeného pro překlad do 32bitového režimu (použít lze například známý assembler NASM). Pro 64bitový režim existuje jednoduchý skript, který zdrojový kód e3 jednoduše transformuje. Kromě toho existuje i šestnáctibitová verze editoru e3 určená pro systém DOS či pro šestnáctibitové (real mode) zavaděče a různé utility a současně i varianta e3 přepsaná do programovacího jazyka C, aby bylo možné tento editor používat například na počítačích vybavených mikroprocesory ARM, RISC V či MIPS. My se však v dalším textu budeme zabývat pouze originální 32bitovou a 64bitovou variantou e3 naprogramovanou v assembleru.

Binární obraz e3 je v porovnání s ostatními dále popisovanými textovými editory velmi malý – podle použitého režimu (32bit/64bit) je spustitelný soubor /usr/bin/e3 velký přibližně 13 či 17 kB a žádné další soubory nejsou pro práci s e3 zapotřebí. Textový editor e3 přitom nabízí uživatelům poměrně velké množství funkcí. Asi nejzajímavější je existence několika režimů práce editoru – ten totiž dokáže napodobit editor WordStar (spuštěno přes link e3ws), Emacs (spuštěno přes link e3em), Vi/Vim (spuštěno přes link e3vi) Pico/Nano (spuštěno přes link e3pi) či NEdit (Nirvana Editor) (spuštěno přes e3ne). Režimy je možné dokonce přepínat i za běhu editoru a součástí je i obrazovka s klávesovými zkratkami (to vše je samozřejmě uloženo ve zmíněných 13 či 17 kB). e3 nabízí dokonce i funkci „undo“, obsahuje kalkulačku (dokáže spočítat i složitý aritmetický výraz zapsaný v textu!) a – což je v našich podmínkách velmi důležité – podporuje plnohodnotný osmibitový vstup znaků.

Další textový editor, o němž se dnes zmíníme, se jmenuje Jed. Jméno tohoto nástroje vzniklo na základě iniciál jeho tvůrce Johna E. Davise. Tento textový editor, který má za sebou již mnoho let vývoje i poměrně úctyhodný seznam podporovaných operačních systémů (včetně Windows, DOSu, mnoha typů UNIXu a dokonce i VMS), již svým uživatelům nabízí mnohem větší množství funkcí, než oba předchozí textové editory. Zajímavé je, že kromě vlastních klávesových zkratek umožňuje emulaci práce v dalších textových editorech a procesorech, zejména EMACSu a WordStaru (přesněji řečeno emulaci práce v textových editorech emulujících WordStar :-). V Jedu lze taktéž souběžně pracovat s větším množstvím dokumentů, a to díky možnosti rozdělení plochy terminálu/konzole na několik oken (split windows). Uživatelům je k dispozici několik předpřipravených barevných schémat, včetně dvou schémat, která se snaží napodobit DOSová integrovaná vývojová prostředí Turbo Pascal, Turbo C či QBasic.

Další alternativní, i když dnes už (i když neprávem) poněkud pozapomenutý textový editor, se jmenuje Joe, neboli plným jménem Joe's own editor podle svého původního autora Joea Allena. Tento textový editor je mezi mnoha uživateli populární, a to jak díky množství nabízených funkcí, tak i kvůli tomu, že se jedná o relativně snadno ovladatelnou aplikaci, která je ovšem široce konfigurovatelná. V základní instalaci je tento editor tvořen jediným spustitelným souborem joe, na nějž však odkazuje několik symlinků, například jstar, jmacs či jpico. Po spuštění těchto symlinků se editor Joe přepne do režimu emulace WordStaru, EMACSu popř. editoru Pico/GNU nano – dojde ke změně prakticky všech klávesových zkratek i obrazovek nápovědy. Mimochodem – jedna z předností editoru Joe spočívá v možnosti mít neustále zobrazeno okno s nápovědou, které je rozdělené do několika listů, mezi nimiž se lze snadno přepínat (to je vlastně rozšíření nápovědy editoru Pico či Nano).

Textový editor Joe svým uživatelům nabízí poměrně široké možnosti, například rozdělení plochy terminálu do většího množství oken (split windows), odsazení textu, obdélníkové bloky či automatické i manuální formátování odstavců. V nových verzích editoru Joe je implementována i podpora pro zvýraznění syntaxe či možnost záznamu a spouštění maker, která mohou být i dosti složitá. Zajímavá a užitečná je možnost filtrace vybraného textu jakoukoli zvolenou aplikací, ať již se jedná například o sort, grep, indent, fmt či například awk nebo sed (nabízených kombinací je skutečně nepřeberné množství). Pro programátory je připravena možnost spuštění překladu projektu, což sice není příliš překvapivé, zajímavá a v praxi velmi užitečná je však možnost automatického zpracování chybových zpráv překladače a popř. i skok na řádky ve zdrojovém kódu, v nichž byla nalezena chyba.

Konečně se dostáváme k poslednímu dnes popisovanému textovému editoru, kterým je MCEdit. Tento textový editor tvoří součást známého a oblíbeného souborového manažeru Midnight Commander, s nímž sdílí mnoho společných vlastností. Mezi tyto vlastnosti patří systém klasických roletových menu, možnost zobrazení řádku s popisem příkazů namapovaných na funkční klávesy F1-F10, integrovaná nápověda a v neposlední řadě i podpora pro práci s myší v terminálu (původní funkce myši je zachována při současném stisku klávesy Shift).

Typickou a mnoha uživateli preferovanou vlastností editoru MCEdit je namapování nejčastěji používaných příkazů na funkční klávesy: klávesa F2 je určena pro uložení textu, F3 slouží pro výběr textu do bloku (je to prakticky jediný modální příkaz), klávesy F5, F6 a F8 pro kopii, přesun resp. vymazání bloku, klávesa F10 editor ukončí atd. Mimochodem: v Midnight Commanderu jsou tři zmíněné funkční klávesy F5, F6, F8 použity pro kopii, přesun a mazání souborů, takže je zachována konzistence mezi těmito dvěma nástroji (a navíc je i zachována konzistence se stařičkým Norton Commanderem).

Příloha C: velikosti binárních souborů textových editorů zmíněných v dnešním článku

Pokud se podíváme na velikosti spustitelných souborů editorů zmíněných v předchozích kapitolách a porovnáme tyto velikosti, zjistíme, že editor micro je docela bumbrlíček (14 MB) a velikostí ho překonává pouze textový editor Helix (19 MB). Na druhé straně velikostního (objemového?) spektra leží e3 (pouhých 17 kB):

$ ls -lah /usr/bin/vim /usr/bin/micro /usr/bin/nano /usr/bin/joe /usr/bin/mc /usr/bin/pico /usr/bin/e3
 
-rwxr-xr-x. 1 root root 14M  Feb 18  2026 /usr/bin/micro
-rwxr-xr-x. 1 root root 19M  Oct  6  2025 /usr/bin/hx
-rwxr-xr-x. 1 root root 286K Apr 30 02:00 /usr/bin/nano
-rwxr-xr-x. 1 root root 742K Jan 16  2026 /usr/bin/pico
-rwxr-xr-x. 1 root root 739K Apr 23  2026 /usr/bin/joe
-rwxr-xr-x. 1 root root 4.6M Sep 18 02:00 /usr/bin/vim
-rwxr-xr-x. 1 root root 1.1M Jan 16  2026 /usr/bin/mc
-rwxr-xr-x. 1 root root 17K  Jan 16  2026 /usr/bin/e3

Ovšem samotná velikost spustitelného binárního souboru neříká vše. Ještě je dobré zjistit, jaké další sdílené knihovny jsou používány. Samotný editor micro využívá jen minimum těchto knihoven, protože všechny knihovny/balíčky Go jsou slinkovány staticky:

$ ldd /usr/bin/micro
 
        linux-vdso.so.1 (0x00007f17a8b0b000)
        libresolv.so.2 => /lib64/libresolv.so.2 (0x00007f17a8ad7000)
        libc.so.6 => /lib64/libc.so.6 (0x00007f17a5a07000)
        /lib64/ld-linux-x86-64.so.2 (0x00007f17a8b0d000)

Pro zajímavost se podívejme na další editory, které jsou typicky psány v jazyku C, Rustu (Helix) a assembleru (e3):

$ ldd /usr/bin/nano
 
        linux-vdso.so.1 (0x00007fb110db6000)
        libmagic.so.1 => /lib64/libmagic.so.1 (0x00007fb110d20000)
        libncursesw.so.6 => /lib64/libncursesw.so.6 (0x00007fb110cde000)
        libtinfo.so.6 => /lib64/libtinfo.so.6 (0x00007fb110cb1000)
        libc.so.6 => /lib64/libc.so.6 (0x00007fb110ab8000)
        libm.so.6 => /lib64/libm.so.6 (0x00007fb1109a1000)
        libz.so.1 => /lib64/libz.so.1 (0x00007fb110977000)
        /lib64/ld-linux-x86-64.so.2 (0x00007fb110db8000)

$ ldd /usr/bin/pico
 
        linux-vdso.so.1 (0x00007f56f8c65000)
        libtinfo.so.6 => /lib64/libtinfo.so.6 (0x00007f56f8c17000)
        libc.so.6 => /lib64/libc.so.6 (0x00007f56f8a1e000)
        /lib64/ld-linux-x86-64.so.2 (0x00007f56f8c67000)

$ ldd /usr/bin/joe
 
        linux-vdso.so.1 (0x00007fe002092000)
        libm.so.6 => /lib64/libm.so.6 (0x00007fe001e7d000)
        libtinfo.so.6 => /lib64/libtinfo.so.6 (0x00007fe001e50000)
        libselinux.so.1 => /lib64/libselinux.so.1 (0x00007fe001e1c000)
        libc.so.6 => /lib64/libc.so.6 (0x00007fe001c23000)
        /lib64/ld-linux-x86-64.so.2 (0x00007fe002094000)
        libpcre2-8.so.0 => /lib64/libpcre2-8.so.0 (0x00007fe001b72000)
        libgcc_s.so.1 => /lib64/libgcc_s.so.1 (0x00007fe001b43000)

$ ldd /usr/bin/vim
 
        linux-vdso.so.1 (0x00007fa19c558000)
        libm.so.6 => /lib64/libm.so.6 (0x00007fa19bee9000)
        libselinux.so.1 => /lib64/libselinux.so.1 (0x00007fa19c503000)
        libtinfo.so.6 => /lib64/libtinfo.so.6 (0x00007fa19c4d6000)
        libsodium.so.26 => /lib64/libsodium.so.26 (0x00007fa19be71000)
        libacl.so.1 => /lib64/libacl.so.1 (0x00007fa19c4cb000)
        libgpm.so.2 => /lib64/libgpm.so.2 (0x00007fa19c4c2000)
        libc.so.6 => /lib64/libc.so.6 (0x00007fa19bc78000)
        /lib64/ld-linux-x86-64.so.2 (0x00007fa19c55a000)
        libpcre2-8.so.0 => /lib64/libpcre2-8.so.0 (0x00007fa19bbc7000)
        libgcc_s.so.1 => /lib64/libgcc_s.so.1 (0x00007fa19c493000)

Editor mcedit je přímo součástí Midnight Commanderu:

$ ldd /usr/bin/mc
 
        linux-vdso.so.1 (0x00007f48919cd000)
        libslang.so.2 => /lib64/libslang.so.2 (0x00007f4891400000)
        libgpm.so.2 => /lib64/libgpm.so.2 (0x00007f489185f000)
        libe2p.so.2 => /lib64/libe2p.so.2 (0x00007f4891854000)
        libglib-2.0.so.0 => /lib64/libglib-2.0.so.0 (0x00007f489129e000)
        libc.so.6 => /lib64/libc.so.6 (0x00007f48910a5000)
        libm.so.6 => /lib64/libm.so.6 (0x00007f489173d000)
        libpcre2-8.so.0 => /lib64/libpcre2-8.so.0 (0x00007f4890ff4000)
        /lib64/ld-linux-x86-64.so.2 (0x00007f48919cf000)

Helix je naprogramovaný v Rustu:

$ ldd /usr/bin/hx
 
        linux-vdso.so.1 (0x00007efce5720000)
        libgcc_s.so.1 => /lib64/libgcc_s.so.1 (0x00007efce56d2000)
        libm.so.6 => /lib64/libm.so.6 (0x00007efce42e9000)
        libc.so.6 => /lib64/libc.so.6 (0x00007efce40f0000)
        /lib64/ld-linux-x86-64.so.2 (0x00007efce5722000)

A konečně e3 neposkytuje informace o sdílených knihovnách:

$ ldd /usr/bin/e3
 
        not a dynamic executable

Odkazy na Internetu

1. micro: a modern and intuitive terminal-based text editor
   https://micro-editor.github.io/
2. Repositář textového editoru micro
   https://github.com/micro-editor/micro
3. Přídavné moduly pro textový editor micro
   https://micro-editor.github.io/plugins.html
4. Micro Text Editor Cheat Sheet by mynocksonmyfalcon
   https://cheatography.com/my­nocksonmyfalcon/cheat-sheets/micro-text-editor/
5. Micro Text Editor: Is It Any Good? – A Vim User's Perspective
   https://www.youtube.com/wat­ch?v=A5TsABTpZWo
6. Awesome Linux Tools: The „micro“ text editor
   https://www.youtube.com/wat­ch?v=kqCQLyrEZww
7. The BEST Text Editor on Linux? – Micro Text Editor
   https://www.youtube.com/watch?v=Jw9eJu-PY08
8. A „Fresh“ New Terminal Text Editor (Better Than Nano!)
   https://www.youtube.com/wat­ch?v=dspEVA8eoUg
9. The best simple text editor for Linux – Micro
   https://www.youtube.com/watch?v=O-4PSzgJMbI
10. GNU Nano editor
    https://www.nano-editor.org/
11. Kakoune: moderní textový editor s modálním ovládáním
    https://www.root.cz/clanky/kakoune-moderni-textovy-editor-s-modalnim-ovladanim/
12. Helix: nový modální textový editor inspirovaný Vimem a Kakoune
    https://www.root.cz/clanky/helix-novy-modalni-textovy-editor-inspirovany-vimem-a-kakoune/
13. Textový editor Helix ve funkci vývojového prostředí
    https://www.root.cz/clanky/textovy-editor-helix-ve-funkci-vyvojoveho-prostredi/
14. Textový editor Helix ve funkci vývojového prostředí (2. část)
    https://www.root.cz/clanky/textovy-editor-helix-ve-funkci-vyvojoveho-prostredi-2-cast/
15. Textový editor Helix ve funkci vývojového prostředí (3. část)
    https://www.root.cz/clanky/textovy-editor-helix-ve-funkci-vyvojoveho-prostredi-3-cast/
16. Představení Helixu
    https://helix-editor.com/
17. Helix: A post-modern modal text editor
    https://githubplus.com/helix-editor/helix
18. Helix na GitHubu
    https://github.com/helix-editor/helix
19. Helix: dokumentace
    https://docs.helix-editor.com/
20. Helix: troubleshooting
    https://github.com/helix-editor/helix/wiki/Troubleshooting
21. Klávesové zkratky Helixu
    https://docs.helix-editor.com/keymap.html
22. gopls
    https://www.getman.io/posts/gopls/
23. Kakoune: A Better Code Editor Heavily Inspired by Vim
    https://www.tecmint.com/kakoune-better-code-editor-for-linux/
24. Kakoune demo
    https://vimeo.com/82711574
25. 6 Best Vi/Vim-Inspired Code Editors for Linux
    https://www.tecmint.com/vi-vim-inspired-code-editors-for-linux/
26. Why Kakoune — The quest for a better code editor
    https://kakoune.org/why-kakoune/why-kakoune.html
27. Kakoune design
    https://github.com/mawww/ka­koune/blob/master/doc/desig­n.asciidoc
28. Kakoune (modální textový editor)
    http://kakoune.org/
29. Kakoune: Selections
    https://github.com/mawww/ka­koune/wiki/Selections
30. Migrating from Vim
    https://github.com/mawww/ka­koune/wiki/Migrating-from-Vim
31. kakoune-vertical-selections
    https://github.com/occivink/kakoune-vertical-selection
32. Langserver.org
    https://langserver.org/
33. Language Server Protocol
    https://microsoft.github.io/language-server-protocol/
34. Language Server Protocol Specification
    https://microsoft.github.io/language-server-protocol/specification
35. Implementations Language Servers
    https://microsoft.github.io/language-server-protocol/implementors/servers
36. JSON-RPC 2.0 Specification
    https://www.jsonrpc.org/specification
37. Why You Should Know the Language Server Protocol
    https://tomassetti.me/what-is-the-language-server-protocol/
38. Language Server Protocol: A Language Server For DOT With Visual Studio Code
    https://tomassetti.me/language-server-dot-visual-studio/
39. Python Language Server
    https://github.com/palantir/python-language-server
40. Jedi – an awesome autocompletion/static analysis library for Python
    https://github.com/davidhalter/jedi
41. What is lsp
    https://www.reddit.com/r/vim/com­ments/7lnhrt/which_lsp_plu­gin_should_i_use/
42. Evil (Emacs Wiki)
    https://www.emacswiki.org/emacs/Evil
43. Evil (na GitHubu)
    https://github.com/emacs-evil/evil
44. Evil (na stránkách repositáře MELPA)
    https://melpa.org/#/evil
45. Evil Mode: How I Switched From VIM to Emacs
    https://blog.jakuba.net/2014/06/23/e­vil-mode-how-to-switch-from-vim-to-emacs.html
46. Vrapper aneb spojení možností Vimu a Eclipse
    https://mojefedora.cz/vrapper-aneb-spojeni-moznosti-vimu-a-eclipse/
47. Vrapper aneb spojení možností Vimu a Eclipse (část 2: vyhledávání a nahrazování textu)
    https://mojefedora.cz/vrapper-aneb-spojeni-moznosti-vimu-a-eclipse-cast-2-vyhledavani-a-nahrazovani-textu/
48. Emacs/Evil-mode – A basic reference to using evil mode in Emacs
    http://www.aakarshnair.com/posts/emacs-evil-mode-cheatsheet
49. From Vim to Emacs+Evil chaotic migration guide
    https://juanjoalvarez.net/es/de­tail/2014/sep/19/vim-emacsevil-chaotic-migration-guide/
50. Introduction to evil-mode {video)
    https://www.youtube.com/wat­ch?v=PeVQwYUxYEg
51. Vim-style keybinding in Emacs/Evil-mode
    https://gist.github.com/tro­yp/6b4c9e1c8670200c04c16036805773d8
52. Evil-surround
    https://github.com/emacs-evil/evil-surround
53. Spacemacs
    http://spacemacs.org/
54. Neovim: literally the future of vim
    https://neovim.io/
55. AMP – A Vi/Vim Inspired Text Editor for Linux Terminal
    https://www.tecmint.com/amp-vi-vim-inspired-text-editor-for-linux/
56. micro-cheat – F1 cheatsheet for the language you're editing
    https://github.com/terokarvinen/micro-cheat