383 lines
12 KiB
Nix
383 lines
12 KiB
Nix
{ pkgs, ... }:
|
|
{
|
|
programs.neovim = {
|
|
enable = true;
|
|
defaultEditor = true;
|
|
vimAlias = true;
|
|
withNodeJs = true;
|
|
withPython3 = true;
|
|
extraLuaConfig = ''
|
|
-- General Option
|
|
vim.g.mapleader = " "
|
|
vim.g.maplocalleader = " "
|
|
|
|
vim.opt.autoindent = true
|
|
vim.opt.background = 'dark'
|
|
vim.opt.backupdir = os.getenv("HOME") .. '/.local/tmp/nvim'
|
|
vim.opt.clipboard = 'unnamedplus' --Use system clipboard
|
|
vim.opt.colorcolumn = '80'
|
|
vim.opt.directory = os.getenv("HOME") .. '/.local/tmp/nvim'
|
|
vim.opt.expandtab = true
|
|
vim.opt.foldmethod = 'syntax'
|
|
vim.opt.gdefault = true -- search: all occurrences by default
|
|
vim.opt.hlsearch = true -- search: hightlight terms
|
|
vim.opt.ignorecase = true
|
|
vim.opt.incsearch = true
|
|
vim.opt.laststatus = 1
|
|
-- show special character
|
|
vim.opt.listchars = {tab = '→ ', trail = '␣', eol = '', extends = '…' }
|
|
|
|
vim.opt.signcolumn = "yes" -- alway show sign column
|
|
vim.opt.number = true
|
|
vim.opt.relativenumber = true
|
|
vim.opt.cursorline = true -- highlight current line
|
|
vim.opt.shiftwidth = 4
|
|
vim.opt.showmatch = true
|
|
vim.opt.smartcase = true -- search: try :to be smart about cases
|
|
vim.opt.smartindent = true
|
|
vim.opt.tabstop = 4
|
|
vim.opt.termguicolors = true -- 24 bits color support
|
|
vim.opt.wildmenu = true -- activate enhanced user menu
|
|
vim.opt.wildmode = 'lastused:full,list' -- enhance menu
|
|
vim.opt.pumheight = 10
|
|
vim.opt.pumwidth = 50
|
|
vim.opt.pumblend = 10
|
|
|
|
-- Options than need vim.cmd
|
|
-- vim.cmd('syntax on')
|
|
|
|
-- -- Code Fold
|
|
-- "Load and save view atomatocally (save and restore fold)
|
|
vim.cmd('au BufWinLeave *.* mkview')
|
|
vim.cmd('au BufWinEnter *.* silent! loadview')
|
|
|
|
|
|
-- Diagnostic settings
|
|
--
|
|
-- diagnostic windows must be float
|
|
vim.diagnostic.config {
|
|
virtual_text = false,
|
|
signs = true,
|
|
underline = true,
|
|
}
|
|
|
|
local signs = { Error = "", Warn = "", Hint = "", Info = "" }
|
|
for type, icon in pairs(signs) do
|
|
local hl = "DiagnosticSign" .. type
|
|
vim.fn.sign_define(hl, { text = icon, texthl = hl, numhl = hl })
|
|
end
|
|
|
|
-- You will likely want to reduce updatetime which affects CursorHold
|
|
-- note: this setting is global and should be set only once
|
|
vim.o.updatetime = 250
|
|
vim.cmd [[autocmd! CursorHold,CursorHoldI * lua vim.diagnostic.open_float(nil, {scope='cursor', header = "", prefix = "", focus=false})]]
|
|
|
|
-- Autotype
|
|
vim.cmd('au BufRead,BufNewFile *.md setlocal textwidth=80')
|
|
vim.cmd('au BufRead,BufNewFile *.tex setlocal textwidth=80')
|
|
vim.cmd('au BufRead,BufNewFile *.nix setlocal tabstop=2 shiftwidth=2 ')
|
|
vim.cmd('au BufNewFile,BufRead /tmp/neomutt* set tw=72 fo=awq comments+=nb:> noautoindent filetype=mail')
|
|
|
|
-- Ignore these filenames during enhanced command line completion.
|
|
vim.opt.wildignore = {
|
|
'*.bak',
|
|
'*.class',
|
|
'*.aux',
|
|
'*.out',
|
|
'*.toc',
|
|
'*.jpg',
|
|
'*.bmp',
|
|
'*.gif',
|
|
'*.png',
|
|
'*.luac',
|
|
'*.o',
|
|
'*.obj',
|
|
'*.exe',
|
|
'*.dll',
|
|
'*.manifest',
|
|
'*.pyc',
|
|
'*.spl',
|
|
'*.sw?'
|
|
}
|
|
|
|
-- Key biding
|
|
-- " ----------
|
|
local opts = { noremap = true, silent = true}
|
|
|
|
vim.api.nvim_set_keymap('n', '<leader>/', ':nohlsearch<CR>', opts)
|
|
|
|
-- Move tabs with \[ and \]
|
|
vim.api.nvim_set_keymap('n', '<Leader>]', ':tabnext<CR>', opts)
|
|
vim.api.nvim_set_keymap('n', '<Leader>[', ':tabprev<CR>', opts)
|
|
vim.api.nvim_set_keymap('n', '<leader>l', ':set list!<CR>', {silent = true})
|
|
'';
|
|
plugins = with pkgs.vimPlugins; [
|
|
{
|
|
plugin = nvim-autopairs;
|
|
type = "lua";
|
|
config = ''
|
|
local autopair = require("nvim-autopairs").setup {}
|
|
'';
|
|
}
|
|
{
|
|
plugin = nvim-base16;
|
|
type = "lua";
|
|
config = ''
|
|
vim.cmd.colorscheme 'base16-default-dark'
|
|
'';
|
|
}
|
|
{
|
|
plugin = nvim-cmp;
|
|
type = "lua";
|
|
config = ''
|
|
local has_words_before = function()
|
|
unpack = unpack or table.unpack
|
|
local line, col = unpack(vim.api.nvim_win_get_cursor(0))
|
|
return col ~= 0 and vim.api.nvim_buf_get_lines(
|
|
0,
|
|
line - 1,
|
|
line,
|
|
true
|
|
)[1]:sub(col, col):match('%s') == nil
|
|
end
|
|
-- Add additional capabilities supported by nvim-cmp
|
|
local capabilities = require('cmp_nvim_lsp').default_capabilities()
|
|
local luasnip = require("luasnip")
|
|
local kind_icons = {
|
|
Text = "",
|
|
Method = "",
|
|
Function = "",
|
|
Constructor = "",
|
|
Field = "",
|
|
Variable = "",
|
|
Class = "",
|
|
Interface = "",
|
|
Module = "",
|
|
Property = "",
|
|
Unit = "",
|
|
Value = "",
|
|
Enum = "",
|
|
Keyword = "",
|
|
Snippet = "",
|
|
Color = "",
|
|
File = "",
|
|
Reference = "",
|
|
Folder = "",
|
|
EnumMember = "",
|
|
Constant = "",
|
|
Struct = "",
|
|
Event = "",
|
|
Operator = "",
|
|
TypeParameter = "",
|
|
}
|
|
-- nvim-cmp setup
|
|
local cmp = require 'cmp'
|
|
cmp.setup {
|
|
mapping = {
|
|
["<Tab>"] = cmp.mapping(function(fallback)
|
|
if cmp.visible() then
|
|
cmp.select_next_item()
|
|
-- You could replace the expand_or_jumpable() calls with expand_or_locally_jumpable()
|
|
-- they way you will only jump inside the snippet region
|
|
elseif luasnip.expand_or_jumpable() then
|
|
luasnip.expand_or_jump()
|
|
elseif has_words_before() then
|
|
cmp.complete()
|
|
else
|
|
fallback()
|
|
end
|
|
end, { "i", "s" }),
|
|
|
|
["<S-Tab>"] = cmp.mapping(function(fallback)
|
|
if cmp.visible() then
|
|
cmp.select_prev_item()
|
|
elseif luasnip.jumpable(-1) then
|
|
luasnip.jump(-1)
|
|
else
|
|
fallback()
|
|
end
|
|
end, { "i", "s" }),
|
|
},
|
|
formatting = {
|
|
format = function(_, vim_item)
|
|
vim_item.kind = string.format('%s %s', kind_icons[vim_item.kind], vim_item.kind)
|
|
return vim_item
|
|
end,
|
|
},
|
|
sources = {
|
|
{ name = 'nvim_lsp' },
|
|
{ name = 'luasnip' },
|
|
{ name = 'path' },
|
|
{ name = 'buffer' },
|
|
},
|
|
}
|
|
'';
|
|
}
|
|
cmp-buffer
|
|
cmp-nvim-lsp
|
|
cmp-path
|
|
cmp-cmdline
|
|
cmp_luasnip
|
|
{
|
|
plugin = gitsigns-nvim;
|
|
type = "lua";
|
|
config = ''
|
|
require('gitsigns').setup {
|
|
on_attach = function(bufnr)
|
|
local gs = package.loaded.gitsigns
|
|
|
|
local function map(mode, l, r, opts)
|
|
opts = opts or {}
|
|
opts.buffer = bufnr
|
|
vim.keymap.set(mode, l, r, opts)
|
|
end
|
|
|
|
-- Navigation
|
|
map('n', '<leader>gn', function()
|
|
if vim.wo.diff then return ']c' end
|
|
vim.schedule(function() gs.next_hunk() end)
|
|
return '<Ignore>'
|
|
end, {expr=true})
|
|
|
|
map('n', '<leader>gN', function()
|
|
if vim.wo.diff then return '[c' end
|
|
vim.schedule(function() gs.prev_hunk() end)
|
|
return '<Ignore>'
|
|
end, {expr=true})
|
|
|
|
map('n', '<leader>gs', gs.stage_hunk)
|
|
map('n', '<leader>gr', gs.reset_hunk)
|
|
map('n', '<leader>gd', gs.diffthis)
|
|
map('n', '<leader>gd', function() gs.diffthis('~') end)
|
|
end
|
|
}
|
|
'';
|
|
}
|
|
indent-blankline-nvim
|
|
{
|
|
plugin = nvim-lspconfig;
|
|
type = "lua";
|
|
config = ''
|
|
local lspconfig = require('lspconfig')
|
|
'';
|
|
}
|
|
{
|
|
plugin = lualine-nvim;
|
|
type = "lua";
|
|
config = ''
|
|
|
|
require('lualine').setup {
|
|
options = {
|
|
icons_enabled = true,
|
|
theme = 'base16',
|
|
component_separators = { left = '|', right = '|'},
|
|
section_separators = { left = "", right = ""},
|
|
disabled_filetypes = {},
|
|
always_divide_middle = true,
|
|
globalstatus = true,
|
|
},
|
|
sections = {
|
|
lualine_a = {'mode'},
|
|
lualine_b = {'branch', 'diff', 'diagnostics'},
|
|
lualine_c = {'filename'},
|
|
lualine_x = {'encoding', 'fileformat', 'filetype'},
|
|
lualine_y = {'progress'},
|
|
lualine_z = {'location'}
|
|
},
|
|
inactive_sections = {
|
|
lualine_a = {},
|
|
lualine_b = {},
|
|
lualine_c = {'filename'},
|
|
lualine_x = {'location'},
|
|
lualine_y = {},
|
|
lualine_z = {}
|
|
},
|
|
tabline = {},
|
|
extensions = {}
|
|
}
|
|
'';
|
|
}
|
|
luasnip
|
|
mason-lspconfig-nvim
|
|
{
|
|
plugin = mason-nvim;
|
|
type = "lua";
|
|
config = ''
|
|
local mason = require("mason").setup{
|
|
ensure_installed= {
|
|
'shellcheck',
|
|
'shfmt'
|
|
}
|
|
}
|
|
local mason_lspconfig = require("mason-lspconfig").setup{
|
|
ensure_installed={
|
|
'ansiblels',
|
|
'bashls'
|
|
}
|
|
}
|
|
require("mason-lspconfig").setup_handlers({
|
|
-- The first entry (without a key) will be the default handler
|
|
-- and will be called for each installed server that doesn't have
|
|
-- a dedicated handler.
|
|
function (server_name) -- default handler (optional)
|
|
require("lspconfig")[server_name].setup {}
|
|
end,
|
|
-- Next, you can provide targeted overrides for specific servers.
|
|
})
|
|
'';
|
|
}
|
|
{
|
|
plugin = neo-tree-nvim;
|
|
type = "lua";
|
|
config = ''
|
|
local neotree = require 'neo-tree'
|
|
neotree.setup({
|
|
event_handlers = {
|
|
{
|
|
event = "file_opened",
|
|
handler = function(file_path)
|
|
-- auto close
|
|
require("neo-tree.command").execute({action = "close"})
|
|
end
|
|
},
|
|
}
|
|
})
|
|
vim.api.nvim_set_keymap('n', '<leader>fm',
|
|
':Neotree toggle<CR>',
|
|
{ table.unpack(opts), desc = 'Toggle NeoTree' }
|
|
)
|
|
'';
|
|
}
|
|
nui-nvim
|
|
plenary-nvim
|
|
{
|
|
plugin = (nvim-treesitter.withPlugins (p: [
|
|
p.bash p.c p.cmake p.dockerfile p.latex p.lua p.markdown
|
|
p.markdown_inline p.python p.vim p.yaml
|
|
])
|
|
);
|
|
type = "lua";
|
|
config = ''
|
|
-- Tree sitter
|
|
local ts = require 'nvim-treesitter.configs'
|
|
|
|
ts.setup {
|
|
sync_install = false,
|
|
highlight = {
|
|
enable = true,
|
|
additional_vim_regex_highlighting = false,
|
|
}
|
|
}
|
|
'';
|
|
}
|
|
{
|
|
plugin = which-key-nvim;
|
|
type = "lua";
|
|
config = ''
|
|
local wk = require 'which-key'
|
|
wk.register()
|
|
'';
|
|
}
|
|
];
|
|
};
|
|
}
|