neovim

git clone https://github.com/jimeh/tmuxifier.git ~/.tmuxifier

neovim anstatt vim

Seit Langem höre und lese ich immer wieder von Neovim und wie begeistert die Leute davon sind. Neovim ist eigentlich wie früher Emacs – es ist ein eigenes Betriebssystem. ;)

In den letzten Monaten fiel dann wieder vermehrt der Name Neovim bei Kollegen und ITlern, mit denen man zusammenarbeitet. Die Konfigurationen, die ich so im Netz und von anderen gesehen habe, waren oft sehr groß. Damit war irgendwie alles möglich, aber die Konfiguration zu durchsteigen und zu verstehen, das ist oft fast unmöglich.

Durch Zufall bin ich im Netz dann über einen Post und kurz danach über ein Video von jemandem gestolpert, in dem er Neovim Schritt für Schritt einrichtet. Dabei hält er die Konfiguration, Tools und Co. sehr klein bzw. setzt nur wenige ein. Nur das Wichtigste wird verwendet und hauptsächlich so beschrieben, dass man erst einmal versteht, wie man Neovim und 1–2 Plugins einrichtet, um dann viele weitere Plugins installieren, verwalten und konfigurieren zu können.

neovim installieren

Installation von neovim mit homebrew

brew install nvim

Konfiguration

Alle Dateien meiner Config sind in einem Github Repo veröffentlicht. Wer direkt mit Neovim loslegen möchte, kann es einfach klonen und Neovim starten:

git clone https://github.com/ruedigerp/neovim-config ~/.config/nvim

Wer sich alle Plugins genauer anschauen, konfigurieren und verstehen möchte, kann einfach ab hier Schritt für Schritt durchgehen und nach jedem Schritt/Plugin testen.

Die Konfiguration von Neovim liegt im Home-Verzeichnis in .config/nvim. Als Erstes habe ich eine Datei init.lua erstellt und Lazy konfiguriert. Normalerweise sind in der Datei noch andere Sachen, wie z. B. die Leader-Taste, die auf Space gesetzt ist. Das konfiguriere ich später aber in einer anderen Datei.

Hier wird jetzt erst einmal nur Lazy konfiguriert, und anschließend legen wir noch im Verzeichnis lua weitere Dateien und Ordner an, in denen dann die anderen Sachen konfiguriert werden.

local lazypath = vim. fn.stdpath("data") .. "/lazy/lazy.nvim"
if not vim. loop.fs_stat(lazypath) then
    vim.fn.system({
    "git",
    "clone",
    "--filter=blob:none",
    "https://github.com/folke/lazy.nvim.git",
    "--branch=stable",     
    lazypath,
    })
end
vim.opt.rtp:prepend(lazypath)

local opt = {}     

require("vim-options")
require("lazy").setup("plugins")

Als nächstes wird im Verzeichnis .config/vim/lua/ die Datei vim-options.lua angelegt:

# Tab, Space und Co 
vim.cmd("set expandtab")
vim.cmd("set tabstop=2")
vim.cmd("set softtabstop=2")
vim.cmd("set shiftwidth=2")
vim.g.mapleader = " "

# Wechseln links, rechts, hoch und runter mit ctl + hjkl
# Hier kommt nachher noch ein Plugin zum Einsatz
vim.keymap.set( 'n', '<c-k>', ':wincmd k<CR>')
vim.keymap.set( 'n', '<c-j>', ':wincmd j<CR>')
vim.keymap.set( 'n', '<c-h>', ':wincmd h<CR>')
vim.keymap.set( 'n', '<c-l>', ':wincd l<CR>')

# Search und Zeilennummern 
vim.keymap.set( 'n', '<leader>h', ':nohlsearch<CR>')
vim.wo.number = true

Plugins in neovim

nvim-tmux-navigator

Wie im Kommentar oben erwähnt, benutze ich ein paar Plugins – darunter auch eins, um aus Neovim mit den oben konfigurierten Keymaps nicht nur innerhalb von Neovim wechseln zu können, sondern auch in andere Fenster innerhalb einer Tmux-Session. Aktuell könnte man zwar schon mit Tmux mehrere Fenster erstellen und mit der gleichen Konfiguration zwischen den Tmux-Fenstern hin- und herspringen. Ist jedoch in einem Fenster Neovim geöffnet, kommt man nicht mehr zurück in andere Tmux-Fenster.

Also fangen wir mal an, die Plugins zu konfigurieren, und nehmen uns direkt dieses Plugin vor.

Im lua-Ordner erstellen wir einen Ordner plugins und darin die Datei nvim-tmux-navigator.lua:

christoomey/vim-tmux-navigator

return {
    "christoomey/vim-tmux-navigator",
    vim.keymap.set('n', 'C-h', ':TmuxNavigateLeft<CR>'),
    vim.keymap.set('n', 'C-j', ':TmuxNavigateDown<CR>'),
    vim.keymap.set('n', 'C-k', ':TmuxNavigateUp<CR>'),
    vim.keymap.set('n', 'C-l', ':TmuxNavigateRight<CR>'),
}

Öffnet man jetzt Neovim (nvim), sollte als Erstes ein Fenster von Lazy zu sehen sein, und alle konfigurierten Plugins werden installiert. Es sollte also jetzt zu sehen sein, dass ein Repo geklont wird und vim-tmux-navigator installiert ist.

Ist Neovim nun in einer Tmux-Session mit mehreren Fenstern geöffnet, kann man mit Ctrl + h, j, k, l durch alle Fenster navigieren – egal, ob es ein Neovim- oder ein Tmux-Fenster ist.

Weitere Puglins konfigurieren

Bei allen Plugins kann nach dem Anlegen der Datei und dem Kopieren der Konfiguration Neovim gespeichert, geschlossen und neu geöffnet werden. Dann wird das jeweilige Plugin installiert.

Wer nicht alles Schritt für Schritt machen möchte, kann einfach alles anlegen und Neovim erst zum Schluss neu starten. Lazy kümmert sich dann darum, alle Plugins zu installieren. Falls jedoch etwas nicht funktioniert, wird es schwieriger, den Fehler zu beheben. Daher würde ich empfehlen, erst einmal alles einzeln zu machen und dabei zu testen. Dann erst das nächste Plugin einrichten.

Daher richten wir jetzt als Erstes die Sidebar für Dateien ein. Man kann dann einfach in das Verzeichnis cd ~/.config/nvim wechseln und dort nvim starten. Wenn neo-tree installiert ist, kann man mit Ctrl + n die Dateiliste anzeigen und schnell zwischen den Dateien wechseln.

Dateien in der Sidebar

Neo-tree ist ein Neovim-Plugin, mit dem du das Dateisystem und andere baumartige Strukturen in jedem gewünschten Stil durchsuchen kannst, einschließlich Seitenleisten, schwebender Fenster, Netrw-Split-Style oder sogar alle gleichzeitig!

return {
    "nvim-neo-tree/neo-tree.nvim",
    branch = "v3.x",
    dependencies = {
        "nvim-lua/plenary.nvim",
        "nvim-tree/nvim-web-devicons",
        "MunifTanjim/nui.nvim",
    },
    config = function()
        require("neo-tree").setup({
        filesystem = {
            filtered_items = {
            visible = true, -- Zeige standardmäßig alle ausgeblendeten Dateien
            hide_dotfiles = false, -- Zeige .dotfiles wie .gitignore
            hide_gitignored = false, -- Zeige Dateien, die in der .gitignore stehen
            hide_by_name = { -- Optional: spezifische Dateien oder Ordner ausblenden
                -- "node_modules", "dist"
            },
            },
        },
        })

        -- Keymap für Neo-Tree
        vim.keymap.set('n', '<C-n>', ':Neotree filesystem reveal right<CR>', {} )
    end
}

Colorschema mit catppuccin

catppuccin/nvim

Funktionen • Unterstützt sowohl Vim als auch Neovim (benötigt Neovim >= 0.8 oder Vim >= 9, kompiliert mit Lua >= 5.1) • Hochgradig konfigurierbar mit 4 verschiedenen Varianten und der Möglichkeit, eigene zu erstellen! • Benutzerkonfiguration kompilieren für schnellste Startzeit • Integrationen mit LSP, Treesitter und zahlreichen Plugins • Unterstützung für viele andere Anwendungen

return {
    "catppuccin/nvim",
    -- lazy = false,
    name = "catppuccin",
    priority = 1000,
    config = function()
    -- require("catppuccin").setup()
    vim.cmd.colorscheme "catppuccin"
    end
}

Dashboard beim starten

nvimdev/dashboard-nvim Fancy and Blazing Fast start screen plugin of neovim

return {
    'nvimdev/dashboard-nvim',
    event = 'VimEnter',
    config = function()
        require('dashboard').setup {
        -- config
        }
    end,
    dependencies = { {'nvim-tree/nvim-web-devicons'}}
}

Neovim statusline

A blazing fast and easy to configure Neovim statusline written in Lua. nvim-lualine/lualine.nvim

return {
    "nvim-lualine/lualine.nvim",
    config = function()
        require('lualine').setup({
        options = {
            theme = 'dracula'
        }
        })
    end
}

Fuzzy-Finder

telescope.nvim ist ein hochgradig erweiterbarer Fuzzy-Finder für Listen. Es basiert auf den neuesten großartigen Funktionen des Neovim-Kerns. Telescope ist auf Modularität ausgerichtet und ermöglicht eine einfache Anpassung.

return {
    {
        'nvim-telescope/telescope.nvim',
        tag = '0.1.8',
        dependencies = { 'nvim-lua/plenary.nvim' },
        config = function()
        local builtin = require("telescope.builtin")
        local telescope = require("telescope")

        -- Telescope setup
        telescope.setup({
            defaults = {
            hidden = true, -- Aktiviert die Anzeige von versteckten Dateien
            file_ignore_patterns = { "%.git/" },
            respect_gitignore = true,
            }
        })

        -- Keybindings
        vim.keymap.set('n', '<C-p>', function()
            builtin.find_files({ hidden = true }) -- Versteckte Dateien für `find_files` anzeigen
        end, {})

        -- vim.keymap.set('n', '<leader>fg', builtin.live_grep, {})
        vim.keymap.set('n', '<leader>fg', function()
            builtin.live_grep({ no_ignore = false }) -- Respektiere .gitignore
        end, {})
        end
    },
    {
        "nvim-telescope/telescope-ui-select.nvim",
        config = function()
        require("telescope").setup ({
            extensions = {
            ["ui-select"] = {
                require("telescope.themes").get_dropdown {
                }
            }
            }
        })
        require("telescope").load_extension("ui-select")
        end
    },
}

Treesitter

Das Ziel von nvim-treesitter ist es, sowohl eine einfache und benutzerfreundliche Schnittstelle für Tree-sitter in Neovim bereitzustellen als auch grundlegende Funktionen wie etwa Syntaxhervorhebung darauf basierend anzubieten.

return {
    "nvim-treesitter/nvim-treesitter",
    build = ":TSUpdate",
    config = function()
        local config = require ("nvim-treesitter.configs")
        config. setup ({
        ensure_installed = {"lua", "javascript", "go", "dockerfile", "helm", "ssh_config", "terraform",
    "tmux", "toml", "yaml"},
        highlight = { enable = true },
        indent = { enable = true },
        })
    end
}

LSP und Vim-Tests

Ich habe noch zwei weitere Plugins. Und zwar vim-test, um Code-Tests auszuführen, die man direkt in Neovim starten kann. Dabei wird jedoch ein Buffer in Neovim geöffnet, und wenn man größere Ausgaben hat, sieht man diese zwar, aber man kann sie nicht in den Hintergrund schieben, den Code anschauen und dann wieder zur Ausgabe zurückwechseln. Die Ausgabe des Tests ist dann weg.

vim-test sorgt dafür, dass ein zweites Fenster in der Tmux-Session geöffnet wird, welches offen bleibt und zwischen dem Code- und dem Test-Fenster gewechselt werden kann. So können alle Fehler nach und nach behoben werden.

Das zweite Plugin ist für LSP: nvim-lspconfig. nvim-lspconfig ist ein „datenbasiertes“ Repository, das grundlegende, standardmäßige Neovim-LSP-Client-Konfigurationen für verschiedene LSP-Server bereitstellt. So werden Fehler im Code direkt angezeigt, wie man es von Visual Studio und Co. kennt. Auch das Springen zu Definitionen, Anzeigen von Hilfen usw. ist damit möglich.

Die beiden Plugins werde ich später noch einmal ausführlicher beschreiben, da ich sie aktuell selbst noch teste und teilweise noch einrichte und konfiguriere. Für LSP müssen lokal passende LSP-Server für die entsprechenden Programmiersprachen installiert sein.

Das wird dann besser ein eigener Post.