Neovim: schnelle und einfache Konfiguration

Neovim (nvim) ist ein moderner Texteditor, der aus dem Editor Vim hervorgegangen ist. Vim selbst basiert auf vi (genauer auf STEVIE - ein Klon von vi), einem Editor, der seit 1976 auf den meisten UNIX-Systemen verfügbar ist.

Neovim ist ein Fork vom Vim. Sein Ziel ist es, Vim leichter erweiterbar und einfacher zu warten zu machen. Nvim bietet unter anderem einen eingebauten LSP-Client (Language Server Protocol), asynchrones I/O sowie einen Lua-Interpreter, mit dem man Plugins schreiben und den Editor konfigurieren kann.

Lua ist eine leistungsfähige, leichte Skriptsprache, die wir für die Konfiguration nutzen. Dies ist keine Lua-Programmier-Tutorial; für eine ausführliche Anleitung empfehle ich die offizielle Documentation oder anderen Quellen. Für unser Ziel sind jedoch keine besonderen Lua-Kenntnisse notwendig.

Grundeinstellung

Für die Konfiguration von Neovim verwenden wir den modernen Plugin-Manager lazy.nvim sowie den eingebauten LSP-Client.

Neovim sucht standardmäßig unsere Konfigurationsdatei im Verzeichnis ~/.config (unter Windows ~\AppData\Local\nvim). Die Struktur der Konfiguration kann wie folgt aussehen:

~/.config/nvim
├── init.lua
└── lua
   ├── config
   │   ├── lazy.lua
   │   └── lualine.lua
   ├── keymaps.lua
   ├── options.lua
   └── plugins.lua

Die init.lua ist die Datei, die die Initialisierungsbefehle enthält. In Vim hieß diese Datei vimrc. Man kann auch eine init.vim verwenden, wenn man Vimscript als Konfigurationsskriptsprache nutzen möchte, aber nicht beide. Alle anderen Dateien sind optional.

Für eine saubere Struktur erstelle ich den Ordner lua/ mit den Dateien keymaps.lua für benutzerdefinierte Tastaturbelegungen, options.lua für geänderte Standardoptionen und plugins.lua zum Laden der Plugins. Alle Dateien können in init.lua als Lua-Module require("<filename or pfad>") eingebunden werden.

Hinweis: Neovim durchsucht das Verzeichnis lua/ automatisch, daher muss man es in require() - Pfad nicht angeben.

Zum Beispiel sehen meine Einstellungen in der Datei options.lua so aus (alle Standardoptionen finden Sie in der Neovim Dokumentation):

local set = vim.opt

set.number = true
set.relativenumber = true
set.mouse = "a"
set.encoding = "utf-8"
set.swapfile = false
set.tabstop = 4
set.softtabstop = 4
set.shiftwidth = 4
set.expandtab = true
set.autoindent = true
set.scrolloff = 7
set.colorcolumn = "79"
set.cmdheight = 2
set.signcolumn = "yes"
set.cursorline = true
set.confirm = true

Ein kurzes Beispiel für die Datei keymaps.lua kann so aussehen:

local keyset = vim.keymap.set

-- jk to escape
keyset("i", "jk", "<Esc>")

-- n to next word
keyset("n", "n", "w", { noremap = true, silent = true })

-- ctrl+d to show diagnostic window
keyset("n", "<C-d>", vim.diagnostic.open_float, { desc = "Show diagnostic" })

-- ctrl+s saving
keyset("n", "<C-s>", ":w<CR>", { noremap = true, silent = true })
keyset("i", "<C-s>", "<Esc>:w<CR>i", { noremap = true, silent = true })
keyset("v", "<C-s>", "<Esc>:w<CR>gv", { noremap = true, silent = true })

Jetzt erstellen wir die datei für lazy.nvim, um den Plugin-Manager zu installieren und die Plugins zu laden. Den folgenden Code übernehmen wir aus der lazy.nvim Dokumentation und speichern ihn in config/lazy.lua:

local lazypath = vim.fn.stdpath("data") .. "/lazy/lazy.nvim"
if not (vim.uv or vim.loop).fs_stat(lazypath) then
  local lazyrepo = "https://github.com/folke/lazy.nvim.git"
  local out = vim.fn.system({ "git", "clone", "--filter=blob:none", "--branch=stable", lazyrepo, lazypath })
  if vim.v.shell_error ~= 0 then
    vim.api.nvim_echo({
      { "Failed to clone lazy.nvim:\n", "ErrorMsg" },
      { out, "WarningMsg" },
      { "\nPress any key to exit..." },
    }, true, {})
    vim.fn.getchar()
    os.exit(1)
  end
end
vim.opt.rtp:prepend(lazypath)

vim.g.mapleader = " "
vim.g.maplocalleader = "\\"

-- Setup lazy.nvim
require("lazy").setup({
  spec = {
    -- import your plugins
    { import = "plugins" },
  },
  install = { colorscheme = { "habamax" } },
  checker = { enabled = true },
})

Als Nächstes erstellen wir die Datei plugins.lua in unserem lua/-Ordner. Um Fehler zu vermeiden, fügen wir zunächst mit dem Befehl echo "return {}" >> plugins.lua eine leere Tabelle ein. Anschließend binden wir alle unsere Module in der init.lua ein:

require("options")
require("keymaps")
require("config.lazy")

Mit dem Befehl :checkhealth lazy können Sie überprüfen, ob alles korrekt eingerichtet wurde.

In plugins.lua fügen wir ein neues Plugin für ein Farbschema hinzu, um die Funktionsweise des Plugin-Managers zu demonstrieren. Ich verwende das Farbschema Brogrammer, das aus dem Sublime Texteditor portiert wurde. Als Kind habe ich sehr gern mit Lego gebaut, und die Farben von Brogrammer erinnern mich an Legosteine. Natürlich können Sie jedes andere Farbschema verwenden.

return {
    {
        "marciomazza/vim-brogrammer-theme",
        name = "brogrammer",
        lazy = false,
        priority = 1000,
        config = function()
            vim.cmd("colorscheme brogrammer")
        end,
    },
}

Nach dem Speichern der Datei sollte Neovim automatisch das Farbschema laden und alles wie erwartet funktioniert.

LSP

Jetzt richten wir das ein, was Neovim zu einem wirklich gut nutzbaren Editor macht.

Das Language Server Protocol (LSP) ist ein Kommunikationsprotokoll, das Funktionen wie Syntaxprüfung, Code-Hinweise, Autovervollständigung sowie Warnungen und Fehlermeldungen bereitstellt. Diese Funktionen unterscheiden Neovim grundlegend von einem einfachen Texteditor und nähern ihn einer integrierten Entwicklungsumgebung (IDE) an.

Es gibt mehrere Möglichkeiten, LSP in Neovim einzurichten. Wir betrachten ein paar davon. In beiden Fällen verwenden wir den integrierten LSP-Client von Nvim. Im lsp/ Verzeichnis des offiziellen Repositoriums von nvim-lspconfig findet man viele Konfigurationsdateien für unterschiedliche Programmiersprachen.

Ohne Plugins

Die erste Methode kommt ohne zusätzliche Plugins aus. Angenommen, wir möchten einen LSP-Server für unsere Lua-Module einrichten. Dafür verwenden wir den Lua Language Server . Installiert wird er über den Paketmanager des Betriebssystems, zum Beispiel mit Homebrew:

brew install lua-language-server

Alternativ kann er auch aus dem Quellcode kompiliert werden.

Danach kopieren wir die Datei lua_ls.lua aus dem Repository in unseren Ordner ~/.config/nvim/ und aktivieren den Server in init.lua:

vim.lsp.enable('lua_ls')

Mit dem Befehl :checkhealth vim.lsp können Sie überprüfen, welche LSP-Server erkannt wurden.

Damit das Pop-up-Fenster erscheint, drucken Sie die Tastenkombination Ctrl + n im Einfügemodus:

Für diagnostische Hinweise aktivieren wir in der options.lua die Anzeige von virtuellem Text:

vim.diagnostic.config({ virtual_text = true })

Mason Plugin

Zweiter Weg beinhaltet automatische Installierung der LSP-Clients mit dem mason.nvim Plugin. Zuerst erweitern wir die Datei plugins.lua um nvim-lspconfig als Quelle der LSP-Konfigurationen. Dazu fügen wir die Abhängigkeiten mason.nvim, mason-lspconfig.nvim (das eine Brücke zwischen mason.nvim und nvim-lspconfig darstellt) sowie mason-tool-installer.nvim hinzu, das für die Installation und Aktualisierung der Werkzeuge sorgt. mason-lspconfig.nvim ermöglicht es außerdem, LSP-Server automatisch zu installieren. Ich bevorzuge diese Methode, weil sie sehr bequem ist.

{
    "neovim/nvim-lspconfig",
    dependencies = {
        { "mason-org/mason.nvim", opts = {} },
        {"mason-org/mason-lspconfig.nvim", opts = {} },
        "WhoIsSethDaniel/mason-tool-installer.nvim",
    },
    config = function()
        require("mason-tool-installer").setup({
            ensure_installed = { "lua_ls" },        
        })
    end,
},

Jetzt üben wir ein bisschen und schauen, wie LSP funktioniert und noch nützlich werden kann. Ich zeige ein Paar Beispiele, in denen ich die Programmsprache Python benutzen werde. Ich nehme pyright, das sehr oft als standardmäßig Python-LSP ist. Alles was brauche ich, es in der Datei plugins.lua zur Variable ensure_installed zuschreiben.

...
    ensure_installed = { "lua_ls", "pyright" }, 
...

Danach schaffen wir hello.py für den Test mit dem solchen Inhalt:

def hello(name):
    return "Hello " + name

if __name__ == "__main__":
    student = "Bob"
    hello(student)

Wenn möchte ich z.B. die Definition der Funktion finden, kann ich die Tastenkombination gd auf hello(student) drucken und der Cursor springt auf die erste Zeile def hello(name):. Oder ich möchte aus den Funktionsaufruf was in der Variable student befindet, dann taste ich K (Shift + k):

Dieses Verhalten können Sie in der Ihre Datei keymaps.lua ändern, z.B.:

-- Example: basic LSP keymaps
vim.keymap.set("n", "gd", vim.lsp.buf.definition)
vim.keymap.set("n", "K", vim.lsp.buf.hover)

Fazit

Hunderte Möglichkeiten und Alternativen gibt es, um Ihr Neovim zu konfigurieren und in ein mächtiges Werkzeug zu verwandeln. Wir betrachteten nur ein winziger Bruchteil davon hier. Alle andere können Sie im Internet finden. Zum Anfang kann ich kickstart.nvim empfehlen. Meine vollständige Konfiguration finden Sie in meinem Github. Die Konfigurierung von Neovim ist ein echtes Kaninchenloch und bringt viel Spaß mit. Experimentieren Sie bitte.

Quellen und weiterführende Links

Neovim & Dokumentation

• Offizielle Neovim-Website
• Neovim Dokumentation (Optionen)
• Neovim LSP-Client Dokumentation

Plugin-Manager & Plugins

• lazy.nvim – Plugin-Manager
• nvim-lspconfig – LSP-Konfigurationen
• mason.nvim – LSP/DAP/Tool-Installer
• mason-lspconfig.nvim
• mason-tool-installer.nvim

Programming Language Servers

• Lua Language Server
• Pyright – Python LSP

Farben & Themes

• Brogrammer Colorscheme

Weitere nützliche Starter-Konfigurationen

• kickstart.nvim – Minimalbeispiel für Einsteiger

Meine Neovim-Konfiguration

• GitHub (dotfiles)