359 lines
9.4 KiB
Nix
359 lines
9.4 KiB
Nix
{ pkgs, ... }:
|
|
let
|
|
customPlugins = {
|
|
vim-zettel = pkgs.vimUtils.buildVimPlugin {
|
|
name = "vim-zettel";
|
|
src = pkgs.fetchFromGitHub {
|
|
owner = "michal-h21";
|
|
repo = "vim-zettel";
|
|
rev = "929d90eec62e6f693c2702d2b6f76a93f2f1689d";
|
|
sha256 = "1fzKmknfVlEYwqeXgbKITbb2/PJ023iJyMz6vak3qh4=";
|
|
};
|
|
};
|
|
vimwiki-dev = pkgs.vimUtils.buildVimPlugin {
|
|
name = "vimwiki-dev";
|
|
src = pkgs.fetchFromGitHub {
|
|
owner = "vimwiki";
|
|
repo = "vimwiki";
|
|
rev = "d035a3428c6343b4f218e51340ddf690ad8c57ee";
|
|
sha256 = "000000000000000000000000PJ023iJyMz6vak3qh4=";
|
|
};
|
|
};
|
|
};
|
|
|
|
my-python-packages = python-packages: with python-packages; [
|
|
tasklib
|
|
pynvim
|
|
six
|
|
python-lsp-server
|
|
pylsp-mypy
|
|
python-lsp-black
|
|
pylint
|
|
# other python packages you want
|
|
];
|
|
python-with-my-packages = pkgs.python3.withPackages my-python-packages;
|
|
in
|
|
{
|
|
environment.variables.EDITOR = "nvim";
|
|
environment.shellAliases = {
|
|
k = "vim -c :VimwikiIndex";
|
|
kz = "vim -c :VimwikiIndex -c :ZettelNew";
|
|
};
|
|
environment.systemPackages = with pkgs // customPlugins; [
|
|
nodejs
|
|
python-with-my-packages
|
|
clojure-lsp
|
|
rnix-lsp
|
|
terraform-lsp
|
|
# Other LSPs
|
|
( neovim.override {
|
|
vimAlias = true;
|
|
withPython3 = true;
|
|
extraPython3Packages = pkgs: with pkgs; [ tasklib six ];
|
|
configure = {
|
|
packages.myPlugins = with pkgs.vimPlugins; {
|
|
start = [
|
|
# general
|
|
vim-nix
|
|
fzf-vim
|
|
vim-elixir
|
|
emmet-vim
|
|
nerdtree
|
|
ayu-vim
|
|
goyo-vim
|
|
vim-sneak
|
|
csv-vim
|
|
rainbow_parentheses-vim
|
|
vim-surround
|
|
vim-devicons
|
|
nvim-web-devicons
|
|
direnv-vim
|
|
|
|
# kitaab stuff
|
|
vimwiki
|
|
taskwiki
|
|
vim-zettel
|
|
telescope-nvim
|
|
plenary-nvim
|
|
bufferline-nvim
|
|
|
|
# lsp stuff
|
|
ale
|
|
nvim-lspconfig
|
|
nvim-cmp
|
|
cmp-nvim-lsp
|
|
nvim-lsp-ts-utils
|
|
cmp-conjure
|
|
cmp-buffer
|
|
cmp-tabnine
|
|
lspkind-nvim
|
|
cmp-path
|
|
cmp-spell
|
|
nvim-autopairs
|
|
|
|
# git stuff
|
|
vim-fugitive
|
|
gitsigns-nvim
|
|
fzf-checkout-vim
|
|
|
|
# Clojure stuff
|
|
conjure
|
|
vim-sexp
|
|
vim-sexp-mappings-for-regular-people
|
|
# testing
|
|
#vim-processing
|
|
#vim-tidal
|
|
];
|
|
};
|
|
|
|
customRC = ''
|
|
set tabstop=2
|
|
set showmatch
|
|
set shiftwidth=2
|
|
set noexpandtab
|
|
set autoindent
|
|
set undofile
|
|
|
|
" set foldmethod=indent " fold based on indent
|
|
set number
|
|
set nocompatible
|
|
set relativenumber
|
|
set showtabline=2
|
|
set noexpandtab
|
|
set autowriteall
|
|
syntax on
|
|
set list lcs=tab:\|\
|
|
filetype plugin on
|
|
|
|
set termguicolors
|
|
let ayucolor="mirage"
|
|
colorscheme ayu
|
|
|
|
" set spell
|
|
set spelllang=en_gb
|
|
set ignorecase
|
|
set smartcase
|
|
set incsearch
|
|
" if hidden is not set, TextEdit might fail.
|
|
set hidden
|
|
" Some servers have issues with backup files, see #649
|
|
set nobackup
|
|
set nowritebackup
|
|
" Better display for messages
|
|
set cmdheight=2
|
|
" You will have bad experience for diagnostic messages when it's default 4000.
|
|
set updatetime=300
|
|
" don't give |ins-completion-menu| messages.
|
|
set shortmess+=c
|
|
" always show signcolumns
|
|
set signcolumn=yes
|
|
|
|
" window
|
|
nmap <leader>wh :topleft vnew<CR>
|
|
nmap <leader>wl :botright vnew<CR>
|
|
nmap <leader>wk :topleft new<CR>
|
|
nmap <leader>wj :botright new<CR>
|
|
|
|
" tabs
|
|
nmap <leader>rt :retab!<CR>
|
|
|
|
let mapleader = "\<Space>"
|
|
let maplocalleader = ","
|
|
|
|
" moving splits with vim movements.
|
|
:tnoremap <A-h> <C-\><C-N><C-w>h
|
|
:tnoremap <A-j> <C-\><C-N><C-w>j
|
|
:tnoremap <A-k> <C-\><C-N><C-w>k
|
|
:tnoremap <A-l> <C-\><C-N><C-w>l
|
|
:inoremap <A-h> <C-\><C-N><C-w>h
|
|
:inoremap <A-j> <C-\><C-N><C-w>j
|
|
:inoremap <A-k> <C-\><C-N><C-w>k
|
|
:inoremap <A-l> <C-\><C-N><C-w>l
|
|
:nnoremap <A-h> <leader>h
|
|
:nnoremap <A-j> <leader>j
|
|
:nnoremap <A-k> <leader>k
|
|
:nnoremap <A-l> <leader>l
|
|
:nnoremap <F5> "=strftime("%Y-%m-%d %H:%M:")
|
|
:inoremap <F5> <C-R>=strftime("%Y-%m-%d %H:%M:")
|
|
|
|
" telescope
|
|
" Find files using Telescope command-line sugar.
|
|
nnoremap <leader>ff <cmd>Telescope find_files<cr>
|
|
nnoremap <leader>fg <cmd>Telescope live_grep<cr>
|
|
nnoremap <leader>fb <cmd>Telescope buffers<cr>
|
|
nnoremap <leader>fh <cmd>Telescope help_tags<cr>
|
|
nnoremap <leader>ft <cmd>Telescope tags<cr>
|
|
|
|
" exit normal mode in terminal
|
|
:tnoremap <C-n> <C-\><C-n>
|
|
|
|
" Sexp in Conjure (since it's fennel)
|
|
" let g:sexp_filetypes = [ "fennel" ]
|
|
|
|
let g:rainbow_active = 0
|
|
autocmd BufReadPost,BufNewFile c,clj,cljs RainbowParenthesesToggleAll
|
|
|
|
" general commands
|
|
map <leader>t :NERDTreeToggle<CR>
|
|
map <leader>s :w<CR>
|
|
map <leader>q :wq<CR>
|
|
map <leader>r :RainbowParenthesesToggleAll<CR>
|
|
map <leader><BS> :noh<CR>
|
|
nnoremap Y y$
|
|
" center moving
|
|
nnoremap n nzzzv
|
|
nnoremap N Nzzzv
|
|
nnoremap J mzJ'z
|
|
" undo points
|
|
inoremap , ,<c-g>u
|
|
inoremap . .<c-g>u
|
|
inoremap ! !<c-g>u
|
|
inoremap ? ?<c-g>u
|
|
inoremap ( (<c-g>u
|
|
inoremap ) )<c-g>u
|
|
inoremap [ [<c-g>u
|
|
inoremap ] ]<c-g>u
|
|
inoremap { {<c-g>u
|
|
inoremap } }<c-g>u
|
|
" moving text
|
|
vnoremap J :m '>+1<CR>gv=gv
|
|
vnoremap K :m '>-2<CR>gv=gv
|
|
inoremap <c-j> <esc>:m .+1<CR>==
|
|
inoremap <c-k> <esc>:m .-2<CR>==
|
|
nnoremap <leader>j <esc>:m .+1<CR>==
|
|
nnoremap <leader>k <esc>:m .-2<CR>==
|
|
" Pasting
|
|
:map <leader>sy :!xclip -i<CR><CR>
|
|
:vmap <leader>sy "*y
|
|
:map <leader>sp :r!xclip -o<CR>
|
|
|
|
" git
|
|
nmap <leader>gd :SignifyDiff<CR>
|
|
map <leader>ghu :SignifyHunkUndo<CR>
|
|
nmap <leader>gl :SignifyList<CR>
|
|
nnoremap <leader>ga :G fetch --all
|
|
nmap <leader>gs :G<CR>
|
|
nmap <leader>gh :diffget //3
|
|
nmap <leader>gl :diffget //2
|
|
nmap <leader>gc :GCheckout<CR>
|
|
|
|
" kitaab
|
|
map <leader>zs :ZettelSearch<CR>
|
|
map <leader>zo :ZettelOpen<CR>
|
|
map <leader>zn :ZettelNew<CR>
|
|
|
|
" NERDTree
|
|
" open on directory
|
|
autocmd StdinReadPre * let s:std_in=1
|
|
|
|
" fzf
|
|
let g:fzf_layout = { 'window': { 'width': 0.8, 'height': 0.8 } }
|
|
|
|
" ALE
|
|
let g:ale_linters = {'clojure': ['clj-kondo'], 'python': ['black', 'pylint']}
|
|
|
|
" lsp commands
|
|
nnoremap <leader>vd :lua vim.lsp.buf.definition()<CR>
|
|
nnoremap <leader>vi :lua vim.lsp.buf.implementation()<CR>
|
|
nnoremap <leader>vsh :lua vim.lsp.buf.signature_help()<CR>
|
|
nnoremap <leader>vrr :lua vim.lsp.buf.references()<CR>
|
|
nnoremap <leader>vrn :lua vim.lsp.buf.rename()<CR>
|
|
nnoremap <leader>vh :lua vim.lsp.buf.hover()<CR>
|
|
nnoremap <leader>vca :lua vim.lsp.buf.code_action()<CR>
|
|
nnoremap <leader>vsd :lua vim.lsp.diagnostic.show_line_diagnostics(); vim.lsp.util.show_line_diagnostics()<CR>
|
|
nnoremap <leader>vn :lua vim.lsp.diagnostic.goto_next()<CR>
|
|
nnoremap <leader>vll :call LspLocationList()<CR>
|
|
|
|
"bufferline
|
|
" These commands will navigate through buffers in order regardless of which mode you are using
|
|
nnoremap <silent>[b :BufferLineCycleNext<CR>
|
|
nnoremap <silent>b] :BufferLineCyclePrev<CR>
|
|
|
|
" lua config
|
|
lua <<EOF
|
|
-- Setup nvim-cmp.
|
|
local cmp = require('cmp')
|
|
local cmp_autopairs = require('nvim-autopairs.completion.cmp')
|
|
local t = function(str)
|
|
return vim.api.nvim_replace_termcodes(str, true, true, true)
|
|
end
|
|
local check_back_space = function()
|
|
local col = vim.fn.col(".") - 1
|
|
return col == 0 or vim.fn.getline("."):sub(col, col):match("%s") ~= nil
|
|
end
|
|
cmp.setup {
|
|
formatting = {
|
|
format = function(entry, vim_item)
|
|
-- fancy icons and a name of kind
|
|
vim_item.kind = require("lspkind").presets.default[vim_item.kind] ..
|
|
" " .. vim_item.kind
|
|
-- set a name for each source
|
|
vim_item.menu = ({
|
|
buffer = "[Buffer]",
|
|
nvim_lsp = "[LSP]",
|
|
cmp_tabnine = "[TabNine]",
|
|
look = "[Look]",
|
|
path = "[Path]",
|
|
spell = "[Spell]",
|
|
calc = "[Calc]",
|
|
})[entry.source.name]
|
|
return vim_item
|
|
end
|
|
},
|
|
mapping = {
|
|
['<C-p>'] = cmp.mapping.select_prev_item(),
|
|
['<C-n>'] = cmp.mapping.select_next_item(),
|
|
['<C-d>'] = cmp.mapping.scroll_docs(-4),
|
|
['<C-f>'] = cmp.mapping.scroll_docs(4),
|
|
['<C-Space>'] = cmp.mapping.complete(),
|
|
['<C-e>'] = cmp.mapping.close(),
|
|
['<CR>'] = cmp.mapping.confirm({
|
|
behavior = cmp.ConfirmBehavior.Insert,
|
|
select = true
|
|
}),
|
|
["<Tab>"] = cmp.mapping(function(fallback)
|
|
if cmp.visible() then
|
|
cmp.select_next_item()
|
|
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()
|
|
else
|
|
fallback()
|
|
end
|
|
end, { "i", "s" }),
|
|
},
|
|
sources = {
|
|
{name = 'buffer'}, {name = 'nvim_lsp'},
|
|
{name = "look"}, {name = "path"},
|
|
{name = 'cmp_tabnine'}, {name = "calc"}, {name = "spell"},
|
|
{name = 'cmp-conjure'}
|
|
},
|
|
completion = {completeopt = 'menu,menuone,noinsert'}
|
|
}
|
|
cmp.event:on( 'confirm_done', cmp_autopairs.on_confirm_done({ map_char = { tex = ' ' } }))
|
|
-- TabNine cmp
|
|
local tabnine = require('cmp_tabnine.config')
|
|
tabnine:setup({max_lines = 1000, max_num_results = 20, sort = true})
|
|
|
|
-- Setup lspconfig.
|
|
local capabilities = require('cmp_nvim_lsp').update_capabilities(vim.lsp.protocol.make_client_capabilities())
|
|
-- require'lspconfig'clojure-lsp.setup {}
|
|
--require'lspconfig'rnix.setup {}
|
|
-- require'lspconfig'pylsp.setup {}
|
|
-- require'lspconfig'terraform_lsp.setup {}
|
|
|
|
-- Bufferline
|
|
require('bufferline').setup {}
|
|
EOF
|
|
'';
|
|
};
|
|
}
|
|
)];
|
|
}
|