.. post:: 14. October 2023 :tags: Editor, Shell, Language Server :author: Hubert Högl :language: de Der Helix Editor ================ (Update am 2024-10-24) Vor kurzem habe ich den "Helix" Editor https://helix-editor.com [1] entdeckt. Es ist ein Vim-ähnlicher, nicht-grafischer Editor der in Rust geschrieben ist. Man lädt einfach die ausführbare Datei herunter und schon ist der Editor startklar. Das Programm heisst ``hx``, in den Tutor geht es mit ``hx --tutor``. Alles was den Anfänger bei Vim erst mal vor grössere Rätsel stellt wie die ``.vimrc`` und die vielen Erweiterungsmöglichkeiten sind bei Helix nicht notwendig. Es gibt durchaus Anpassungsmöglichkeiten bei Helix, aber diese können übersichtlich und verständlich in den beiden TOML Dateien ``config.toml`` und ``languages.toml`` im Verzeichnis ``~/.config/helix`` erledigen werden (siehe [2]). Dieses Verzeichnis muss von Hand angelegt werden (``mkdir ~/.config/helix``). Meine Konfiguration unter ``~/.config/helix`` habe ich im folgenden Repo abgelegt (gerne Änderungen daran machen): .. code-block:: text https://gitlab.informatik.hs-augsburg.de/config/helix Das aktuelle Helix Binary ist unter ``_. zu finden. Aktuell ist das ``helix-24.07-x86_64-linux.tar.xz``. Nach dem Entpacken schiebt man ``hx`` z.B. in ``~/.local/bin/`` und das Runtime Verzeichnis ``runtime/`` in ``~/.config/helix/``. Auf der Release-Seite gibt es ausserdem Helix als AppImage, aktuell ``helix-24.07-x86_64.AppImage``. In dieser Datei ist auch die Runtime enthalten. Man muss die Datei nur mit ``chmod 755 helix-24.07-x86_64.AppImage`` ausführbar machen, nach Geschmack einen symbolischen Link ``hx`` drauf setzen, schon kann z.B. der Tutor mit ``hx --tutor`` aufgerufen werden. Im WSL2 Linux (Linux Subsystem von Windows) war noch folgende Umgebungsvariable nötig: ``export COLORTERM=truecolor``. Diese am besten dauerhaft in ``~/.bashrc`` setzen. Ein sehr starkes Argument für die Verwendung von Helix als Programmiereditor ist seine eingebaute Unterstützung für das "Language Server Protocol" (LSP) [3]. Mit dem Kommando .. code-block:: bash $ hx --health wird eine lange Liste aller unterstützten Sprachen ausgegeben, so dass gleich sichtbar ist wie der jeweilige Language Server heisst, ob er installiert ist und welche Features unterstützt werden. Im folgenden gebe ich kurz an, was ich zum Editieren von Code in Rust, C und Python tun musste. .. admonition:: Hinweis zu Tastenkürzeln Ein praktisches Tastenkürzel ist in Helix bei allen Sprachen ``gd`` (goto definition). Zurück geht es wieder mit ``Strg-o``. * "goto" Kürzel: https://docs.helix-editor.com/keymap.html#goto-mode * Alle Tastenkürzel: https://docs.helix-editor.com/keymap.html **Rust** Der Language Server für Rust heisst ``rust-analyzer``. Am besten holt man sich die aktuelle vorkompilierte Version von Github Releases und führt sie aus ``~/.local/bin/`` aus. Falls das Programm auch in ``~/.cargo/bin`` ist, dann sollte man es dort entfernen oder dafür sorgen, dass die aktuelle Version früher im Suchpfad (PATH) steht . Aufgerufen auf der Kommandozeile gibt er mit mit ``--version`` z.B. die Version aus .. code-block:: bash $ rust-analyzer --version rust-analyzer 0.3.2020-standalone Das ist schon alles was zu tun ist. Damit der Language Server "anspringt", muss man den Quelltext in einem Rust Crate editieren, es muss also ein Verzeichnis mit ``Cargo.toml`` und ``src/`` vorhanden sein. * Sourcecode: https://github.com/rust-lang/rust-analyzer * Releases: https://github.com/rust-lang/rust-analyzer/releases **C/C++** Es gibt mehrere C/C++ Language Server, z.B. ``clangd`` und ``ccls``. Aktuell verwende ich meist den ``clangd``. Es gibt ein Linux Paket, das einfach mit ``sudo apt install clangd`` installiert wird. Der Sprachserver funktioniert für "normale" Programme die nativ auf dem PC laufen als auch für crosskompilierte Embedded Programme, die z.B. die ``arm-none-eabi-gcc`` Toolchain verwenden. Folgende Konfiguration ist nötig: 1. In ``languages.toml``: .. code-block:: text [[language]] name = "c" auto-format = false language-servers = [ "clangd" ] [language-server.clangd] command = "clangd" config = { clangd.fallbackFlags = [ "-std=gnu11" ] } args = [] 2. In dem C/C++ Projekt muss es eine "Compilation Database" geben, in der Informationen zum Kompilieren des Projekts abgelegt werden. Zum Anlegen der Compilation Database gibt es Hilfsprogramme, z.B. ``compiledb`` oder ``bear``. Ich habe mich zunächst mal für ``compiledb`` entschieden. Da es ein Python Programm ist erfolgt die Installation mit ``pip install compiledb``. Falls das C/C++ Projekt mit einem Makefile zum Bauen ausgestattet ist, dann ist die Anwendung sehr einfach. Der Aufruf ``$ compiledb make`` legt die "Datenbank" in Form der Datei ``compile_commands.json`` an. Dazu wird das Projekt einmal unter der Herrschaft von ``compiledb`` kompiliert und der Output festgehalten. Bear liefert im wesentlichen die gleichen Ergebnisse, es wird mit ``sudo apt install bear`` installiert. Der Aufruf ist dann ``bear -- make``. Sollte ein Projekt mit CMake https://cmake.org organisiert sein, dann ist es sogar noch einfacher, da cmake bereits von sich aus eine Compilation Database erstellen kann. 3. Nun öffnet man Helix in dem Verzeichnis in dem auch ``compile_commands.json`` liegt und kann danach komfortabel Quelltextdateien editieren und darin navigieren. * clangd: ``_ * ccls: ``_ * compiledb: ``_ * bear: ``_ * Compilation Database: ``_ **Python** Der Sprachserver für Python heisst ``pylsp``, er wird mit .. code-block:: sh pip install -U python-lsp-server installiert. Mein Eintrag in ``languages.toml`` lautet: .. code-block:: text [[language]] name = "python" diagnostic-severity = "Warning" auto-format = true language-servers = [ "pylsp" ] [language-server.pylsp] command = "pylsp" args = [] --- Alle Spracheinstellungen sind unter https://docs.helix-editor.com/languages.html zusammengefasst. Links ----- [1] https://helix-editor.com [2] https://docs.helix-editor.com/configuration.html [3] https://microsoft.github.io/language-server-protocol ---