helm/profiles/nvim/nvim.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=";
				};
			};
	};

	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
			vale
			clj-kondo
			# Other LSPs or linters
	( 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
				csv-vim
				rainbow_parentheses-vim
				vim-surround
				vim-devicons
				nvim-web-devicons
				direnv-vim
				vim-peekaboo
				undotree
				telescope-nvim
				plenary-nvim
				lualine-nvim
				nvim-gps
				nvim-treesitter
				nvim-treesitter-context
				cmp-treesitter
				dashboard-nvim
				FTerm-nvim
        barbar-nvim

				# kitaab stuff
				vimwiki
				taskwiki
				vim-zettel

				# lsp stuff
				nvim-lint
				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 signcolumn=auto:4

			" 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>

      " barbar
      nnoremap <silet> gT :BufferPrevious<CR>
      nnoremap <silet> gt :BufferNext<CR>
      nnoremap <silet> gj :BufferPick<CR>
      nnoremap <silet> gc :BufferClose<CR>

			" git
			nnoremap <leader>ga :G fetch --all
			nmap <leader>gs :G<CR>
			nmap <leader>gh :diffget //3
			nmap <leader>gl :diffget //2
			nmap <leader>gc :GBranches<CR>
			nnoremap <leader>gp :G push<CR>

			" kitaab
			map <leader>zs :ZettelSearch<CR>
			map <leader>zo :ZettelOpen<CR>
			map <leader>zn :ZettelNew<CR>

			let g:mapleader="\<Space>"
			let g:dashboard_default_executive = 'telescope'
			nmap <Leader>ss :<C-u>SessionSave<CR>
			nmap <Leader>sl :<C-u>SessionLoad<CR>
			nnoremap <silent> <Leader>fh :DashboardFindHistory<CR>
			nnoremap <silent> <Leader>ff :DashboardFindFile<CR>
			nnoremap <silent> <Leader>fa :DashboardFindWord<CR>
			nnoremap <silent> <Leader>fm :DashboardJumpMark<CR>
			nnoremap <silent> <Leader>cn :DashboardNewFile<CR>
			nnoremap <silent> <Leader>tn :tabnew<CR>
			autocmd FileType dashboard set showtabline=0 | autocmd WinLeave <buffer> set showtabline=2 

			" fzf
			let g:fzf_layout = { 'window': { 'width': 0.8, 'height': 0.8 } }

			" 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>

			" lua config 
			lua <<EOF
-- autopairs
require('nvim-autopairs').setup{}

-- 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()	
				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 {}

require('gitsigns').setup { sign_priority=80 }

-- treesitter
require('nvim-treesitter.configs').setup { ensure_installed={'nix', 'clojure', 'python', 'typescript'}}

-- lualine
require('nvim-gps').setup {}
local gps = require('nvim-gps')
require('lualine').setup {
	sections = {
		lualine_c = {
				'filename', { gps.get_location, condition=gps.is_available },
		},
		lualine_y = {
			function()
				local msg = 'No Active Lsp'
				local buf_ft = vim.api.nvim_buf_get_option(0, 'filetype')
				local clients = vim.lsp.get_active_clients()
				if next(clients) == nil then
					return msg
				end
				for _, client in ipairs(clients) do
					local filetypes = client.config.filetypes
					if filetypes and vim.fn.index(filetypes, buf_ft) ~= -1 then
						return client.name
					end
				end
				return msg
			end
			},
	}
}

-- nvim-lint
require('lint').linters_by_ft = {
	markdown = {'vale'},
	clojure = {'clj-kondo'},
	python = {'black'}
}

-- f_term
local map = vim.api.nvim_set_keymap
local opts = { noremap = true, silent = true }
map('n', '<C-i>', '<CMD>lua require("FTerm").toggle()<CR>', opts)
map('t', '<A-i>', '<C-\\><C-n><CMD>lua require("FTerm").toggle()<CR>', opts)
EOF
				'';
			};
		}
	)];
}