Ontwikkel een Neovim Configuratie voor Geavanceerd Versiebeheer en Git-integratie
description
Met deze prompt kun je een krachtige Neovim-configuratie samenstellen die versiebeheer en Git direct in je editor integreert. Dit helpt je efficiënter te werken met branches, commits en merges zonder Neovim te verlaten. Het lost het probleem op van gefragmenteerde tools en versnelt je ontwikkelproces.
prompt
Help me een Neovim-configuratie te maken die geavanceerde ondersteuning voor versiebeheer en Git integreert. Ik wil functies zoals visuele Git-diffweergave, inline blame, en makkelijke branch- ...
try_prompt
generate_helper
disclaimerOnPageApi
tags
ai_answers
provider: openai
model: gpt-4.1-nano
Hier is een uitgebreide Neovim-configuratie in Lua die geavanceerde Git-ondersteuning biedt, inclusief visuele diff, inline blame en eenvoudige branch- en merge-activiteiten. Deze setup gebruikt populaire plugins en stelt handige keybindings in.
**Benodigdheden:**
- Neovim (minimaal versie 0.5)
- Plugin manager zoals `packer.nvim`
---
### Stap 1: Packer installeren (indien nog niet gedaan)
```lua
-- Plaats dit in je init.lua of een aparte plugin-configuratie
require('packer').startup(function()
-- Packer zelf
use 'wbthomason/packer.nvim'
-- Git integratie en visuele diff
use {
'lewis6991/gitsigns.nvim',
requires = { 'nvim-lua/plenary.nvim' }
}
use 'tpope/vim-fugitive' -- Git commando's
use 'TimUntersberger/neogit' -- uitgebreide Git UI
use 'sindrets/diffview.nvim' -- visuele diff view
-- Inline blame
use 'f-person/git-blame.nvim'
end)
```
### Stap 2: Plugins configureren
```lua
-- gitsigns instellen voor visuele diff en inline blame
require('gitsigns').setup {
on_attach = function(bufnr)
local gs = package.loaded.gitsigns
-- Keybindings voor gitsigns
local function map(mode, lhs, rhs, opts)
opts = opts or {}
opts.buffer = bufnr
vim.keymap.set(mode, lhs, rhs, opts)
end
-- Navigeren tussen hunk
map('n', ']h', function() if vim.wo.diff then return ']h' end; return gs.next_hunk() end, {expr=true})
map('n', '[h', function() if vim.wo.diff then return '[h' end; return gs.prev_hunk() end, {expr=true})
-- Blame voor huidige regel
map('n', '<leader>gb', gs.toggle_line_blame)
-- Hunk staging/unstaging
map('n', '<leader>gs', gs.stage_hunk)
map('n', '<leader>gu', gs.undo_stage_hunk)
map('n', '<leader>gr', gs.reset_hunk)
-- View diff in een aparte window
map('n', '<leader>gd', gs.diffthis)
-- Inline blame
require('git-blame').setup()
end
}
-- Neogit configureren
vim.api.nvim_set_keymap('n', '<leader>gs', '<cmd> lua require("neogit").open()<CR>', { noremap = true, silent = true })
-- Diffview gebruiken voor uitgebreide diff visualisaties
vim.api.nvim_set_keymap('n', '<leader>vd', '<cmd>DiffviewOpen<CR>', { noremap = true, silent = true })
-- Fugitive voor snelle Git-commando's
vim.api.nvim_set_keymap('n', '<leader>gf', ':Git<CR>', { noremap = true, silent = false })
```
---
### Stap 3: Belangrijke keybindings overzicht
| Toets | Functie | Plugin |
|----------------------|------------------------------------------|--------------------|
| `<leader>gs` | Open Neogit interface | neogit |
| `<leader>gf` | Open Git-functies (Fugitive) | fugitive |
| `<leader>vd` | Diffview openen | diffview.nvim |
| `<leader>gb` | Inline blame toggle | git-blame.nvim |
| `[h` / `]h` | Navigeren tussen hunken | gitsigns |
| `<leader>gs` | Hunk staged maken | gitsigns |
| `<leader>gu` | Hunk unstaged maken | gitsigns |
| `<leader>gd` | Diff van huidige bestand | gitsigns |
---
### Extra tips:
- **Python en Lua integratie:** Voor geavanceerde scripts kun je Lua gebruiken voor Neovim-configuratie en Python voor externe scripts of tooling.
- **Automatisering:** Overweeg autocommands voor automatisch weergeven van inline blame bij het openen van een buffer.
- **Thema en kleuren:** Pas de kleuren van diff en blame aan voor betere zichtbaarheid.
---
Met deze setup krijg je een krachtige, visuele en efficiënte Git-werkstroom in Neovim. Veel plezier met coderen!
provider: deepseek
model: deepseek-chat
Zeker! Hier is een complete Neovim-configuratie voor geavanceerde Git-ondersteuning, geoptimaliseerd voor Lua en Python ontwikkeling:
## Vereiste Plugins (lazy.nvim)
```lua
-- plugins/git.lua
return {
-- Git integratie
'tpope/vim-fugitive',
'tpope/vim-rhubarb',
-- Git signs in de gutter
{
'lewis6991/gitsigns.nvim',
opts = {
signs = {
add = { text = '│' },
change = { text = '│' },
delete = { text = '_' },
topdelete = { text = '‾' },
changedelete = { text = '~' },
untracked = { text = '┆' },
},
on_attach = function(bufnr)
local gs = package.loaded.gitsigns
-- Keybindings voor gitsigns
local map = function(mode, l, r, opts)
opts = opts or {}
opts.buffer = bufnr
vim.keymap.set(mode, l, r, opts)
end
-- Navigatie
map('n', ']c', function()
if vim.wo.diff then return ']c' end
vim.schedule(function() gs.next_hunk() end)
return '<Ignore>'
end, {expr=true})
map('n', '[c', function()
if vim.wo.diff then return '[c' end
vim.schedule(function() gs.prev_hunk() end)
return '<Ignore>'
end, {expr=true})
-- Acties
map({'n', 'v'}, '<leader>hs', gs.stage_hunk)
map({'n', 'v'}, '<leader>hr', gs.reset_hunk)
map('n', '<leader>hS', gs.stage_buffer)
map('n', '<leader>hu', gs.undo_stage_hunk)
map('n', '<leader>hR', gs.reset_buffer)
map('n', '<leader>hp', gs.preview_hunk)
map('n', '<leader>hb', function() gs.blame_line{full=true} end)
map('n', '<leader>tb', gs.toggle_current_line_blame)
map('n', '<leader>hd', gs.diffthis)
map('n', '<leader>hD', function() gs.diffthis('~') end)
map('n', '<leader>td', gs.toggle_deleted)
end,
},
},
-- Git blame inline
{
'f-person/git-blame.nvim',
config = function()
require('gitblame').setup({
enabled = false, -- Start uitgeschakeld
date_format = '%r'
})
end
},
-- Diffview voor betere diff weergave
{
'sindrets/diffview.nvim',
dependencies = 'nvim-lua/plenary.nvim'
},
-- Git conflict resolutie
{
'akinsho/git-conflict.nvim',
version = "*",
config = true
},
-- Branch management
{
'AlexvZyl/nordic.nvim',
config = function()
require('nordic').setup()
end
},
}
```
## Keybinding Configuratie
```lua
-- keymaps/git.lua
local map = vim.keymap.set
-- Fugitive commands
map('n', '<leader>gg', '<cmd>Git<CR>', { desc = 'Git status' })
map('n', '<leader>gc', '<cmd>Git commit<CR>', { desc = 'Git commit' })
map('n', '<leader>gp', '<cmd>Git push<CR>', { desc = 'Git push' })
map('n', '<leader>gP', '<cmd>Git pull<CR>', { desc = 'Git pull' })
map('n', '<leader>gb', '<cmd>Git blame<CR>', { desc = 'Git blame' })
map('n', '<leader>gd', '<cmd>Gdiffsplit<CR>', { desc = 'Git diff split' })
-- Diffview
map('n', '<leader>gv', '<cmd>DiffviewOpen<CR>', { desc = 'Diffview open' })
map('n', '<leader>gV', '<cmd>DiffviewClose<CR>', { desc = 'Diffview close' })
map('n', '<leader>gh', '<cmd>DiffviewFileHistory<CR>', { desc = 'File history' })
-- Branch management
map('n', '<leader>gB', '<cmd>Git branch<CR>', { desc = 'Git branches' })
map('n', '<leader>gm', '<cmd>Git merge<CR>', { desc = 'Git merge' })
-- Git blame toggle
map('n', '<leader>gt', '<cmd>GitBlameToggle<CR>', { desc = 'Toggle git blame' })
```
## Git-specifieke Instellingen
```lua
-- config/git.lua
-- Auto-commando's voor Git repositories
vim.api.nvim_create_autocmd('BufEnter', {
pattern = '*',
callback = function()
-- Alleen gitsigns activeren in Git repositories
if vim.fn.system('git rev-parse --is-inside-work-tree 2>/dev/null') then
require('gitsigns').attach()
end
end
})
-- Fugitive verbeteringen
vim.api.nvim_create_autocmd('FileType', {
pattern = 'fugitive',
callback = function()
-- Betere keymaps in fugitive buffer
vim.keymap.set('n', 'q', '<cmd>bd<CR>', { buffer = true })
vim.keymap.set('n', '<leader>p', '=", { buffer = true })
end
})
```
## Python-specifieke Git Configuratie
```lua
-- ftplugin/python.lua
-- Python-specifieke Git instellingen
local python_git_config = function()
-- Auto-detecteer virtual environment voor Git
if vim.fn.filereadable('requirements.txt') then
vim.b.git_should_ignore = '*.pyc,__pycache__/,*.egg-info/,build/,dist/'
end
end
vim.api.nvim_create_autocmd('FileType', {
pattern = 'python',
callback = python_git_config
})
```
## Lua Development Optimalisaties
```lua
-- ftplugin/lua.lua
-- Lua-specifieke Git configuratie
local lua_git_config = function()
-- Neovim config gerelateerde Git instellingen
vim.b.git_should_ignore = 'plugin/packer_compiled.lua'
end
vim.api.nvim_create_autocand('FileType', {
pattern = 'lua',
callback = lua_git_config
})
```
## Workflow Optimalisaties
```lua
-- init.lua (gedeelte)
-- Git workflow helpers
local M = {}
function M.setup_git_workflow()
-- Snelle stage & commit
vim.keymap.set('n', '<leader>gsc', function()
vim.cmd('Gitsigns stage_hunk')
vim.cmd('Git commit -v')
end, { desc = 'Stage hunk and commit' })
-- Snelle push na commit
vim.keymap.set('n', '<leader>gcp', function()
vim.cmd('Git commit -v')
vim.defer_fn(function()
vim.cmd('Git push')
end, 100)
end, { desc = 'Commit and push' })
end
return M
```
## Aanbevolen Gebruik:
1. **Visuele Diff**: Gebruik `<leader>gd` voor side-by-side diff of `<leader>gv` voor Diffview
2. **Inline Blame**: `<leader>tb` toggelt blame voor huidige regel
3. **Hunk Management**: Gebruik `]c`/`[c` om tussen hunks te navigeren
4. **Stage/Reset**: `<leader>hs`/`<leader>hr` voor hunk staging
5. **Branch Workflow**: `<leader>gB` voor branch management
Deze configuratie biedt een complete Git-ervaring in Neovim met optimale integratie voor Lua en Python ontwikkeling!