Maak een Neovim-configuratie voor efficiënte documentatiegeneratie
description
Door gebruik te maken van deze configuratie bespaar je tijd op documentatietaken, zorg je voor consistentie in je documentatiestijl en genereer je gemakkelijk documentatie in verschillende formaten, wat de samenwerking en het begrip van je code verbetert.
prompt
try_prompt
Help me bij het ontwerpen van een Neovim-configuratie die het proces van het genereren van documentatie voor mijn code stroomlijnt. Ik wil functies opnemen zoals automatische documentatiegeneratie, integratie met documentatietools en ondersteuning voor ... more
generate_helper
...
tags
ai_answers
provider: openai
model: gpt-4.1-nano
Natuurlijk! Hier is een voorstel voor een Neovim-configuratie die het genereren van documentatie voor Python-code met Sphinx stroomlijnt, inclusief plugins, instellingen en sneltoetsen:
1. Plugins:
Gebruik bijvoorbeeld een plugin manager zoals 'packer.nvim'. Voeg de volgende plugins toe:
```lua
require('packer').startup(function()
-- Linter en code-analyse
use 'dense-analysis/ale' -- voor linting en code-analyse
-- Python ondersteuning
use 'nvim-treesitter/nvim-treesitter'
-- Documentatie genereren en integreren
use 'kkoomen/vim-sphinx' -- Sphinx syntax highlighting
-- Fuzzy finder voor snel navigeren
use 'nvim-telescope/telescope.nvim'
-- LSP voor Python
use 'neovim/nvim-lspconfig'
-- Automatische code formatting
use 'psf/black' -- via null-ls integratie
-- Snippets voor snelle documentatie
use 'hrsh7th/nvim-cmp'
use 'hrsh7th/cmp-nvim-lsp'
use 'L3MON4D3/LuaSnip'
end)
```
2. Instellingen:
Hier enkele belangrijke configuraties:
```lua
-- LSP-instellingen voor Python (met pyright)
local lspconfig = require('lspconfig')
lspconfig.pyright.setup{}
-- Autocompletion
local cmp = require'cmp'
cmp.setup({
snippet = {
expand = function(args)
require'luasnip'.lsp_expand(args.body)
end,
},
sources = {
{ name = 'nvim_lsp' },
},
})
-- Keybindings voor snel genereren van documentatie
vim.api.nvim_set_keymap('n', '<Leader>d', ':lua GenerateDoc()<CR>', { noremap = true, silent = true })
-- Functie om Sphinx-documentatie te genereren
function GenerateDoc()
-- Vraag het huidige bestand en klasse/methode
local filename = vim.fn.expand('%:p')
local cmd = 'sphinx-apidoc -o docs/ ' .. filename
vim.fn.jobstart(cmd, {detach = true})
print('Documentatie gegenereerd met sphinx-apidoc')
end
```
3. Sneltoetsen:
- `<Leader>d`: Genereert automatisch Sphinx API-documentatie voor het huidige bestand.
- `<Leader>g`: Bouwt de Sphinx-documentatie (via `make html`) in de `docs` directory.
- `<Leader>r`: Herstart LSP of linting.
4. Extra:
- Zorg dat je `sphinx-apidoc` en `make` hebt geïnstalleerd.
- Maak een basis Sphinx-project (`sphinx-quickstart`) in je `docs/` directory.
- Overweeg integratie met `null-ls.nvim` voor automatische code formatting met Black.
Voorbeeld voor Black integratie:
```lua
local null_ls = require("null-ls")
null_ls.setup({
sources = {
null_ls.builtins.formatting.black,
},
})
vim.api.nvim_set_keymap('n', '<Leader>f', ':lua vim.lsp.buf.formatting()<CR>', { noremap = true, silent = true })
```
Met deze setup kun je snel documentatie genereren, je code formatteren en je Sphinx-documentatie bijwerken, allemaal binnen Neovim.
provider: deepseek
model: deepseek-chat
Zeker! Hier is een complete Neovim-configuratie voor documentatiegeneratie met Sphinx voor Python:
## Vereiste Plugins (lazy.nvim)
```lua
-- plugins/documentatie.lua
return {
-- Sphinx integratie
{
"nvim-treesitter/nvim-treesitter",
opts = {
ensure_installed = { "python", "rst", "markdown" },
},
},
-- Documentatie generatie
{
"danymat/neogen",
dependencies = "nvim-treesitter/nvim-treesitter",
config = function()
require('neogen').setup({
snippet_engine = "luasnip"
})
end,
},
-- Sphinx syntax highlighting
{
"stsewd/rst.nvim",
dependencies = { "nvim-treesitter/nvim-treesitter" },
config = function()
require("rst").setup({})
end,
},
-- Terminal integratie voor Sphinx commands
{
"akinsho/toggleterm.nvim",
config = true,
},
-- File explorer voor documentatie structuur
{
"nvim-tree/nvim-tree.lua",
opts = {
view = {
width = 30,
},
},
},
}
```
## Basis Configuratie
```lua
-- lua/config/documentatie.lua
local M = {}
M.setup = function()
-- Neogen configuratie voor Python docstrings
local neogen = require('neogen')
-- Sphinx-specifieke template
neogen.setup({
enabled = true,
input_after_comment = true,
languages = {
python = {
template = {
annotation_convention = "google" -- Of "numpydoc" voor NumPy style
}
}
}
})
-- Sphinx project detectie
vim.api.nvim_create_autocmd({"BufEnter"}, {
pattern = {"*/docs/source/*.rst", "*/docs/conf.py"},
callback = function()
vim.bo.filetype = "rst"
end
})
end
return M
```
## Sneltoetsen en Keymaps
```lua
-- lua/keymaps/documentatie.lua
local keymap = vim.keymap.set
-- Documentatie generatie sneltoetsen
keymap("n", "<leader>dg", function()
require("neogen").generate()
end, { desc = "Generate documentation" })
keymap("n", "<leader>dc", function()
require("neogen").generate({ type = "class" })
end, { desc = "Generate class documentation" })
-- Sphinx commands
keymap("n", "<leader>sb", ":ToggleTerm direction=float cmd='sphinx-build docs/source docs/build'<CR>",
{ desc = "Build Sphinx documentation" })
keymap("n", "<leader>sa", ":ToggleTerm direction=float cmd='sphinx-autobuild docs/source docs/build'<CR>",
{ desc = "Auto-build Sphinx documentation" })
keymap("n", "<leader>st", ":e docs/source/index.rst<CR>",
{ desc = "Open Sphinx index" })
keymap("n", "<leader>sc", ":e docs/conf.py<CR>",
{ desc = "Open Sphinx config" })
-- Documentatie preview
keymap("n", "<leader>dp", ":ToggleTerm direction=float cmd='python -m http.server 8000 -d docs/build'<CR>",
{ desc = "Preview documentation" })
```
## Sphinx-specifieke Instellingen
```lua
-- ftplugin/python.lua
-- Python-specifieke documentatie instellingen
vim.bo.textwidth = 88 -- Black compatibel
vim.bo.shiftwidth = 4
vim.bo.tabstop = 4
-- Automatische docstring formatting
vim.api.nvim_create_autocmd("BufWritePre", {
pattern = "*.py",
callback = function()
if vim.fn.search('"""\\|\\''\\''\\''', 'nw') ~= 0 then
vim.cmd('normal! gggqG')
end
end
})
```
## Template voor Sphinx Documentatie
```lua
-- lua/templates/sphinx.lua
local M = {}
M.create_sphinx_project = function()
local base_dir = vim.fn.getcwd()
-- Create basic Sphinx structure
local dirs = {
"docs/source/_static",
"docs/source/_templates",
"docs/build"
}
for _, dir in ipairs(dirs) do
vim.fn.mkdir(dir, "p")
end
-- Create conf.py template
local conf_py = [[
project = 'Mijn Project'
copyright = '2024, Uw Naam'
author = 'Uw Naam'
extensions = [
'sphinx.ext.autodoc',
'sphinx.ext.napoleon',
'sphinx.ext.viewcode',
]
html_theme = 'sphinx_rtd_theme'
]]
-- Write files
vim.fn.writefile(vim.split(conf_py, "\n"), base_dir .. "/docs/source/conf.py")
print("Sphinx project aangemaakt in " .. base_dir .. "/docs")
end
return M
```
## Gebruiksaanwijzing
1. **Installatie**:
```bash
pip install sphinx sphinx-rtd-theme sphinx-autobuild
```
2. **Sphinx project initialiseren**:
```lua
:lua require("templates.sphinx").create_sphinx_project()
```
3. **Documentatie genereren**:
- Plaats cursor op functie/klasse
- Druk `<leader>dg` voor functie documentatie
- Druk `<leader>dc` voor klasse documentatie
4. **Build process**:
- `<leader>sb` - Eénmalige build
- `<leader>sa` - Auto-build bij wijzigingen
- `<leader>dp` - Live preview
## Aanvullende Tips
- Gebruik `:checkhealth` om plugin status te controleren
- Installeer `sphinx-autodoc-typehints` voor type hint ondersteuning
- Configureer Napoleon extension voor Google/NumPy docstring parsing
Deze configuratie biedt een complete workflow voor het genereren, beheren en previewen van Sphinx documentatie direct vanuit Neovim!