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=";
      };
    };
    lsp-format = pkgs.vimUtils.buildVimPlugin {
      name = "lsp-format";
      src = pkgs.fetchFromGitHub {
        owner = "lukas-reineke";
        repo = "lsp-format.nvim";
        rev = "84e117b99bb2bc0d0c8122e2b256046f046f8aff";
        sha256 = "rs3NTZwWdsmBGXnrgUeVxUiNjbN/ULxJHifPYJD9mT4=";
      };
    };
    vim-tidal = pkgs.vimUtils.buildVimPluginFrom2Nix {
      name = "vim-tidal";
      src = pkgs.fetchgit {
        url = "https://github.com/tidalcycles/vim-tidal";
        # version 1.4.6
        rev = "52134979252757a5736ae09cb9fc6ae3cc04daef";
        sha256 = "1x64d8jdlcw16pcp19xb0krd1jfqhva4xsxif8xc11pyj52sxxlh";
      };
      postInstall = ''
        sed -i "s|  split term://tidal|  split term://$out/share/vim-plugins/vim-tidal/bin/tidal|g" $out/share/vim-plugins/vim-tidal/plugin/tidal.vim
        cat plugin/tidal.vim | grep "term:"
      '';
      dependencies = [ ];
    };
  };

  my-python-packages = python-packages: with python-packages; [
    tasklib
    pynvim
    six
    python-lsp-server
    pylsp-mypy
    python-lsp-black
    pylint
    black
    # other python packages you want
  ];
  python-with-my-packages = pkgs.python3.withPackages my-python-packages;
in
{
  environment.variables.EDITOR = "nvim";
  environment.shellAliases = {
    k = "cd ~/kitaab/vimwiki; vim -c :VimwikiIndex; cd $OLDPWD";
    kz = "cd ~/kitaab/vimwiki; vim -c :VimwikiIndex -c :ZettelNew; cd $OLDPWD";
  };
  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
            dashboard-nvim
            FTerm-nvim
            barbar-nvim

            # kitaab stuff
            vimwiki
            taskwiki
            vim-zettel

            # lsp stuff
            nvim-lint
            nvim-lspconfig
            nvim-cmp
            cmp-nvim-lsp
            cmp-treesitter
            nvim-lsp-ts-utils
            cmp-conjure
            cmp-buffer
            cmp-tabnine
            lspkind-nvim
            cmp-path
            cmp-spell
            nvim-autopairs
            cmp_luasnip
            luasnip
            lsp-format

            # 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>
          vmap <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")<CR>
          :inoremap <F5> <C-R>=strftime("%Y-%m-%d %H:%M")<CR>
          :inoremap <F4> <C-R>=strftime("%H:%M")<CR>

          " tidal nvim terminal
          " let g:tidal_target = "terminal"

          " 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 <silent> gT :BufferPrevious<CR>
          nnoremap <silent> gt :BufferNext<CR>
          nnoremap <silent> gj :BufferPick<CR>
          nnoremap <silent> gq :BufferClose<CR>

          " git
          nnoremap <leader>ga :G fetch --all
          nmap <leader>gs :G<CR>
          nmap <leader>gh :diffget //3<CR>
          nmap <leader>gl :diffget //2<CR>
          nmap <leader>gb :GBranches<CR>
          nnoremap <leader>gp :Git! push<CR>
          nnoremap <leader>gd :Gdiff<CR>
          nnoremap <space>gc :G commit -v -q %:p<CR>

          " kitaab
          map <leader>zs :ZettelSearch<CR>
          map <leader>zo :ZettelOpen<CR>
          map <leader>zn :ZettelNew<CR>
          map <leader>zd :VimwikiDiary<CR>
          map <leader>zf :Telescope oldfiles only_cwd=true<CR>
          map <leader>wt :VimwikiMakeTomorrowDiaryNote
          map <leader>wd :VimwikiMakeYesterdayDiaryNote
          let g:vimwiki_list = [{ 'path': '~/kitaab/vimwiki', 'auto_tags': 1, 'auto_diary_index': 1, 'auto_generate_links': 1 }]

          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>fm :DashboardJumpMark<CR>
          nnoremap <silent> <Leader>cn :DashboardNewFile<CR>
          autocmd FileType dashboard set showtabline=0 | autocmd WinLeave <buffer> set showtabline=2 

          " fzf
          " not sure we even use this
          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 require('telescope.builtin').lsp_implementation()<CR>
          nnoremap <leader>vsh :lua vim.lsp.buf.signature_help()<CR>
          nnoremap <leader>vrr :lua require('telescope.builtin').lsp_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 rim.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>
          nnoremap <leader>va :lua require('telescope.builtin').lsp_code_actions(require('telescope.themes').get_cursor())<cr>

          " lua config 
          lua <<EOF
          -- lsp config
          -- only show errors with virtual text
          -- vim.lsp.handlers["textDocument/publishDiagnostics"] = vim.lsp.with(
          --   vim.lsp.diagnostic.on_publish_diagnostics, {
          --     -- Enable virtual text, override spacing to 4
          --     virtual_text = {
          --       severity_limit = { "Error" }
          --     }
          --   })
          vim.g.diagnostics_active = true
          function _G.toggle_diagnostics()
            if vim.g.diagnostics_active then
              vim.g.diagnostics_active = false
              vim.lsp.diagnostic.clear(0)
              vim.lsp.handlers["textDocument/publishDiagnostics"] = function() end
            else
              vim.g.diagnostics_active = true
              vim.lsp.handlers["textDocument/publishDiagnostics"] = vim.lsp.with(
                vim.lsp.diagnostic.on_publish_diagnostics, {
                  virtual_text = true,
                  signs = true,
                  underline = true,
                  update_in_insert = false,
                }
              )
            end
          end

          vim.api.nvim_set_keymap('n', '<leader>vt', ':call v:lua.toggle_diagnostics()<CR>',  {noremap = true, silent = true})


          -- autopairs
          require('nvim-autopairs').setup{}

          -- Setup nvim-cmp.
          local has_words_before = function()
          	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

          local luasnip = require("luasnip")
          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 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" }),
          		},
          		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
          require("lsp-format").setup {}

          local capabilities = require('cmp_nvim_lsp').update_capabilities(vim.lsp.protocol.make_client_capabilities())
          require('lspconfig').clojure_lsp.setup {on_attach = require "lsp-format".on_attach}
          require('lspconfig').rnix.setup {on_attach = require "lsp-format".on_attach}
          require('lspconfig').pylsp.setup {on_attach = require "lsp-format".on_attach}
          require('lspconfig').terraform_lsp.setup {on_attach = require "lsp-format".on_attach}

          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'},
          }

          -- 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
        '';
      };
    }
    )
  ];
}