.. post:: 14. October 2023
   :tags: Editor, Shell, Language Server
   :author: Hubert Högl
   :language: de

Der Helix Editor
================

Vor kurzem habe ich den "Helix" Editor [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``. 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 kann man übersichtlich und verständlich in den beiden TOML Dateien  
``config.toml`` und ``languages.toml`` im Verzeichnis ``~/.config/helix`` 
erledigen (siehe [2]).

Zum Installieren von Helix holt man sich am besten die aktuelle vorkompilierte
Version von `<https://github.com/helix-editor/helix/releases>`_ und speichert
sie z.B. in ``~/.local/bin/``.

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 man 
gleich sieht, 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. 

**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. 

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**

Der C/C++ Language Server heisst ``ccls``. Es gibt ein Linux Paket, das man einfach 
mit ``sudo apt install ccls`` installieren kann.  Verwenden kann man ihn sowohl
für die Erstellung von nativen Programmen, als auch für die Programmierung von
Embedded Systems, die z.B. die ``arm-none-eabi-gcc`` Toolchain verwenden. 
Folgende Schritte sind nötig:

1. Es ist ein kleiner Abschnitt in der ``languages.toml`` notwendig:

   .. code-block:: text

      [[language]]
      # from https://github.com/helix-editor/helix/issues/5526
      name = "c"
      auto-format = false
      language-server = { command = "ccls", args = [] }

2. In dem C/C++ Projekt muss es eine "Compilation Database" geben.  Diese legt
   man an mit Programmen wie z.B. ``compiledb`` oder ``bear``.   Ich habe mich
   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. Man ruft ``$ compiledb make`` auf, danach ist die "Datenbank" in
   der Datei ``compile_commands.json``. 

3. Nun öffnet man Helix in dem Verzeichnis in dem auch ``compile_commands.json``
   liegt und kann danach komfortabel editieren.

* Sourcecode: `<https://github.com/MaskRay/ccls>`_
* compiledb: `<https://pypi.org/project/compiledb>`_
* bear: `<https://github.com/rizsotto/Bear>`_
* Compilation Database: `<https://clang.llvm.org/docs/JSONCompilationDatabase.html>`_


**Python**

Der Sprachserver für Python heisst ``pylsp``, man installiert ihn mit

.. code-block:: sh

   pip install -U python-lsp-server

Vermutlich bräuchte man gar keinen Zusatz in ``languages.toml``, ich habe
aus irgend einem Grund folgenden Abschnitt aufgenommen:


.. code-block:: text

   [[language]]
   name = "python"
   diagnostic-severity = "Warning"
   auto-format = true
   language-server = { command = "pylsp", args = [] }

Am besten man probiert es zunächst mal ohne diesen Abschnitt.

---

Ein praktisches Tastenkürzel ist in Helix bei allen Sprachen ``gd`` (goto
definition). Zurück springt man wieder mit ``Strg-o``.

Alle Tastenkürzel sind hier erklärt: `<https://docs.helix-editor.com/keymap.html>`_


Links 
-----

[1] https://helix-editor.com

[2] https://docs.helix-editor.com/configuration.html

[3] https://microsoft.github.io/language-server-protocol


---