dotfiles/nvimrc

" Prefer $HOME/.vim to $HOME/.config/nvim (for now):
set runtimepath^=~/.vim runtimepath+=~/.vim/after
let &packpath = &runtimepath

set background=dark
syntax on
filetype plugin indent on

let mapleader=','

" netrw
let g:netrw_banner = 0
let g:netrw_liststyle = 1
let g:netrw_list_hide = '^\.'
let g:netrw_winsize=25
map <leader>n <esc>:Lexplore<cr>

" fix helptags for opt/ plugins
" https://vi.stackexchange.com/questions/17210/generating-help-tags-for-packages-that-are-loaded-by-vim-8s-package-management
command! -nargs=0 -bar Helptags
    \  for p in glob('~/.vim/pack/git-plugins/opt/*', 1, 1)
    \|     exe 'packadd ' . fnamemodify(p, ':t')
    \| endfor
    \| helptags ALL

set shiftwidth=2
set shiftround
set tabstop=2
set expandtab
set smarttab
set splitbelow
set splitright
set encoding=utf-8
set hidden
set nowrap
set smartindent
set copyindent
set autoindent
set hlsearch
set showmatch
set wildmenu
set wildmode=list:full,full
set number
set norelativenumber
set ruler
set backspace=indent,eol,start
set ignorecase
set smartcase
set incsearch
set history=1000
set undolevels=1000
set title
set novisualbell
set noerrorbells
set nobackup
set noswapfile
set mouse=a
set mousemodel=popup_setpos
" https://github.com/tpope/vim-sensible/issues/78:
set lazyredraw
set timeoutlen=1000
set scrolloff=15
set dictionary=/usr/share/dict/words
" See :help thesaurus
set thesaurus=$HOME/Documents/thesaurus/thesaurus_pkg/thesaurus.txt
set shortmess+=I
set updatetime=250
set pastetoggle=<f2>
set pumheight=200
" Required for nvim-compe:
set complete-=i
set nrformats-=octal
set ttimeout
set ttimeoutlen=100
set formatoptions+=j
set autoread
" https://github.com/tpope/vim-sensible/issues/142:
set synmaxcol=500

" Enable 24-bit colours.
" https://github.com/alacritty/alacritty/issues/109#issuecomment-440353106
if exists('+termguicolors')
  let &t_8f="\<Esc>[38;2;%lu;%lu;%lum"
  let &t_8b="\<Esc>[48;2;%lu;%lu;%lum"
  set termguicolors
endif

" Colour scheme:
packadd! nord-vim " https://github.com/arcticicestudio/nord-vim.git
colorscheme nord

augroup vimrc
  autocmd!
  " Automatically load/save views on files.
  " https://vi.stackexchange.com/posts/13874/revisions
  autocmd BufWinLeave,BufLeave,BufWritePost,BufHidden,QuitPre ?* nested silent! mkview!
  autocmd BufWinEnter ?* silent! loadview
  " set cursor line highlight in insert mode.
  autocmd InsertEnter * set cul
  autocmd InsertLeavePre * set nocul
  " use tabs in .gitconfig
  autocmd BufEnter .gitconfig setlocal shiftwidth=2 tabstop=2 noexpandtab
  " Quickfix window is always full-width.
  " https://github.com/fatih/vim-go/issues/1757#issuecomment-565130503
  autocmd FileType qf if (getwininfo(win_getid())[0].loclist != 1) | wincmd J | endif
  " Remove trailing whitespace pre-save:
  autocmd FileType go,ruby,markdown,rust,python,markdown,lua autocmd BufWritePre <buffer> silent! %s/\s\+$//e
augroup end

" Don't remember the current directory for a given file:
set viewoptions-=curdir
set viewoptions-=options
set sessionoptions-=options

" Key mappings:
nnoremap j gj
nnoremap k gk
map <up> <nop>
map <down> <nop>
map <left> <nop>
map <right> <nop>
imap <up> <nop>
imap <down> <nop>
imap <left> <nop>
imap <right> <nop>
nmap ]q :cn<cr>
nmap [q :cp<cr>

nnoremap <silent> <leader>w :up<cr>
nnoremap <silent> <leader>/ :nohlsearch<cr>
nnoremap <silent> <leader><space> :nohlsearch<cr>
" Select just-pasted text:
nnoremap <silent> <leader>0 `[v`]
" Select just-pasted text and re-indent:
nnoremap <silent> <leader>) `[v`]=
nnoremap <silent> <leader>1 :set relativenumber!<cr>
nnoremap <silent> <leader>! :windo set norelativenumber<cr>
nnoremap <leader>m :marks<cr>
nnoremap <leader>v :vsplit<cr>
nnoremap <leader>s :split<cr>
nnoremap <leader>rp "_dd<bar>P
nnoremap <leader>dq ggVG"_d:wq<cr>

" abbrevs
iabbrev esdebug debugger; // eslint-disable-line no-debugger
iabbrev bashstrict set -euo pipefail<cr>IFS=$'\n\t'<cr>

lua <<EOF
function _G.dump(...)
  local objects = vim.tbl_map(vim.inspect, {...})
  print(unpack(objects))
  return ...
end

function _G.insert_uuid()
  local uuid = vim.call("system", "uuidprint")
  local errcode = vim.v.shell_error
  if errcode ~= 0 then
    vim.api.nvim_err_writeln("uuidprint returned error code: " .. errcode)
    return
  end

  vim.call("setreg", "u", uuid)
  vim.api.nvim_command([[normal! "up]])
end

vim.api.nvim_set_keymap("n", "<leader>pu", [[:lua _G.insert_uuid()<cr>]], {noremap = true, silent = true})
vim.api.nvim_set_keymap("i", "<c-d><c-u>", [[<esc>:lua _G.insert_uuid()<cr>a]], {noremap = true, silent = true})

function _G.insert_jira_url()
  local url = vim.call("system", "jira")
  local errcode = vim.v.shell_error
  if errcode ~= 0 then
    vim.api.nvim_err_writeln("jira returned error code: " .. errcode)
    return
  end

  vim.call("setreg", "u", url)
  vim.api.nvim_command([[normal! "up]])
end

vim.api.nvim_set_keymap("n", "<leader>pj", [[:lua _G.insert_jira_url()<cr>]], {noremap = true, silent = true})
vim.api.nvim_set_keymap("i", "<c-d><c-j>", [[<esc>:lua _G.insert_jira_url()<cr>a]], {noremap = true, silent = true})

function _G.insert_iso8601_timestamp()
  local ts = vim.call("system", "echo -n $(date --iso-8601=seconds)")

  local errcode = vim.v.shell_error
  if errcode ~= 0 then
    vim.api.nvim_err_writeln("date returned error code: " .. errcode)
    return
  end

  vim.call("setreg", "u", ts)
  vim.api.nvim_command([[normal! "up]])
end


vim.api.nvim_set_keymap("n", "<leader>pt", [[:lua _G.insert_iso8601_timestamp()<cr>]], {noremap = true, silent = true})
vim.api.nvim_set_keymap("i", "<c-d><c-t>", [[<esc>:lua _G.insert_iso8601_timestamp()<cr>a]], {noremap = true, silent = true})

_G._test_cmd_to_wins = {}

_G._build_test_cmd = function()
  local bufnr = vim.call("bufnr", "%")
  local filetype = vim.call("getbufvar", bufnr, "&filetype")
  if filetype == "" then
    vim.api.nvim_err_writeln("cannot build test command for filetype:" .. filetype)
    return nil
  end

  local path = vim.call("expand", "%:p")

  -- TODO: allow line number to be passed
  -- TODO: check file exists before running command
  if filetype == "ruby" then
    if not path:find("_spec.rb") then
      path = path:gsub("/app/", "/spec/"):gsub([[.rb$]], "_spec.rb")
    end

    return "bundle exec rspec --format=progress --no-profile " .. path
  elseif filetype == "go" then
    return "go test -v " .. path:gsub("^(.*)/(.*go)$", "%1/...")
  else
    vim.api.nvim_err_writeln("filetype not supported: " .. filetype)
    return nil
  end
end

_G.run_tests = function()
  local cmd = _G._build_test_cmd()
  if cmd == nil then
    return
  end

  vim.api.nvim_command([[silent up]])

  local winid = _G._test_cmd_to_wins[cmd]
  local current_winid = vim.call("win_getid")
  if winid == nil or not vim.api.nvim_win_is_valid(winid) or winid == current_winid or not vim.call("win_gotoid", winid) == -1 then
    vim.api.nvim_command([[10split]])
    winid = vim.call("win_getid")
    _G._test_cmd_to_wins[cmd] = winid
  end

  local buf = vim.api.nvim_create_buf(false, true)
  vim.api.nvim_buf_set_option(buf, "bufhidden", "delete")
  vim.api.nvim_win_set_buf(winid, buf)

  vim.call("termopen", cmd)
  vim.api.nvim_command([[normal! G]])
  vim.api.nvim_command([[wincmd p]])
end

_G.focus_tests = function()
  local cmd = _G._build_test_cmd()
  if cmd == nil then
    return
  end

  local winid = _G._test_cmd_to_wins[cmd]
  if winid == nil or not vim.api.nvim_win_is_valid(winid) then
    return
  end

  vim.call("win_gotoid", winid)
  vim.api.nvim_command([[wincmd =]])
end

_G.close_tests = function()
  local current_winid = vim.api.nvim_get_current_win()
  for _, winid in pairs(_G._test_cmd_to_wins) do
    if current_winid == winid and vim.api.nvim_win_is_valid(winid) then
      vim.api.nvim_win_close(winid, false)
      return
    end
  end

  local cmd = _G._build_test_cmd()
  if cmd == nil then
    return
  end

  local winid = _G._test_cmd_to_wins[cmd]
  if winid == nil or not vim.api.nvim_win_is_valid(winid) then
    return
  end

  vim.api.nvim_win_close(winid, false)
end

_G.copy_test_cmd = function()
  local cmd = _G._build_test_cmd()
  if cmd == nil then
    return
  end

  vim.call("setreg", "+", cmd)
  print("Copied: " .. cmd)
end

vim.api.nvim_set_keymap("n", "<leader>cr", [[:lua _G.run_tests()<cr>]], {noremap = true, silent = true})
vim.api.nvim_set_keymap("n", "<leader>cf", [[:lua _G.focus_tests()<cr>]], {noremap = true, silent = true})
vim.api.nvim_set_keymap("n", "<leader>cq", [[:lua _G.close_tests()<cr>]], {noremap = true, silent = true})
vim.api.nvim_set_keymap("n", "<leader>cc", [[:lua _G.copy_test_cmd()<cr>]], {noremap = true, silent = true})
EOF

" Function to eat trailing character when applying iabbrevs.
" https://stackoverflow.com/questions/11858927/preventing-trailing-whitespace-when-using-vim-abbreviations
func! Eatchar(pat)
  let c = nr2char(getchar(0))
  return (c =~ a:pat) ? '' : c
endfunc

" Git mappings
"
" Copy Git permalink to clipboard for either current line or range
function! CopyGitURLToLineOrRange() range
  if a:firstline == a:lastline
    execute ".GBrowse!"
  else
    execute a:firstline . "," . a:lastline . "GBrowse!"
  endif
endfunction

function! OpenGitURLToLineOrRange() range
  if a:firstline == a:lastline
    execute ".GBrowse"
  else
    execute a:firstline . "," . a:lastline . "GBrowse"
  endif
endfunction

nnoremap <leader>as :Git<cr>
nnoremap <leader>ab :Git blame<cr>
nnoremap <leader>ac :Commits<cr>
nnoremap <leader>ah :GitGutterLineHighlightsToggle<cr>
nnoremap <leader>aY :call CopyGitURLToLineOrRange()<cr>
vnoremap <leader>aY :call CopyGitURLToLineOrRange()<cr>
nnoremap <leader>ao :call OpenGitURLToLineOrRange()<cr>
nnoremap <leader>ap :execute 'silent !ghpr <c-r><c-f>' \| redraw!<cr>

" echo filename of current buffer:
nmap <leader>fe :echom expand("%:p")<cr>
" yank filename of current buffer:
function! CopyToDefaultRegister()
  let @" = expand("%:p")
  echom expand("%:p")
endfunction
nmap <leader>fy :call CopyToDefaultRegister()<cr>
" and into + register:
function! CopyToSystemClipboard()
  let @* = expand("%:p")
  let @+ = expand("%:p")
  echom expand("%:p")
endfunction
nmap <leader>fY :call CopyToSystemClipboard()<cr>

" disable Ex mode
nnoremap Q <Nop>

function! ToggleQuickFix()
  if empty(filter(getwininfo(), 'v:val.quickfix'))
    copen
  else
    cclose
  endif
endfunction
nmap <silent> <leader>q :call ToggleQuickFix()<cr>
nmap <silent> <leader>l :lclose<cr>

" vim-markdown configuration:
let g:vim_markdown_conceal = 1

" fzf configuration:
let g:fzf_action = {
    \ 'ctrl-h': 'leftabove vsplit',
    \ 'ctrl-j': 'rightbelow split',
    \ 'ctrl-k': 'leftabove split',
    \ 'ctrl-l': 'rightbelow vsplit',
    \ 'ctrl-o': 'only | e',
    \ 'ctrl-s': 'split',
    \ 'ctrl-t': 'tab split',
    \ 'ctrl-v': 'vsplit',
  \ }
nmap <leader>t :GFiles<cr>
nmap <leader>T :Files<cr>
nmap <leader>b :Buffers<cr>
nmap <leader>rg :Rg<cr>

" Lightline configuration:
packadd! lightline.vim " https://github.com/itchyny/lightline.vim.git
set laststatus=2

function! LightlineLSPErrorText()
  let l:count = luaeval("vim.diagnostic.get(0, [[Error]])")
  if l:count == 0
    return ''
  endif
  return l:count . 'E'
endfunction

function! LightlineLSPWarningText()
  let l:count = luaeval("vim.diagnostic.get(0, [[Warning]])")
  if l:count == 0
    return ''
  endif
  return l:count . 'W'
endfunction

function! LightlineLSPInformationText()
  let l:count = luaeval("vim.diagnostic.get(0, [[Information]])")
  if l:count == 0
    return ''
  endif
  return l:count . 'I'
endfunction

let g:lightline = {
      \ 'colorscheme': 'seoul256',
      \ 'active': {
      \   'left': [ [ 'mode', 'paste' ],
      \             [ 'readonly', 'filename', 'modified' ],
      \             [ 'gitbranch' ], ['lsperror', 'lspwarn', 'lspinfo' ] ],
      \   'right': [ ['lineinfo'], ['percent'], ['filetype'], ['gobuild'] ],
      \ },
      \ 'component_function': {
      \   'gobuild': 'go#statusline#Show',
      \   'gitbranch': 'FugitiveStatusline',
      \ },
      \ 'component_expand': {
      \   'lsperror': 'LightlineLSPErrorText',
      \   'lspwarn': 'LightlineLSPWarningText',
      \   'lspinfo': 'LightlineLSPInformationText',
      \ },
      \ 'component_type': {
      \   'lsperror': 'error',
      \   'lspwarn': 'warning',
      \ },
      \ 'mode_map': {
      \   'n' : 'N',
      \   'i' : 'I',
      \   'R' : 'R',
      \   'v' : 'V',
      \   'V' : 'V-LINE',
      \   "\<C-v>": 'V-BLOCK',
      \   'c' : 'C',
      \   's' : 'S',
      \   'S' : 'S-LINE',
      \   "\<C-s>": 'S-BLOCK',
      \   't': 'TERM',
      \ },
\ }

" vim-gitgutter configuration
packadd! vim-gitgutter " https://github.com/airblade/vim-gitgutter.git
set signcolumn=yes
nmap ]h <Plug>(GitGutterNextHunk)
nmap [h <Plug>(GitGutterPrevHunk)
omap ih <Plug>(GitGutterTextObjectInnerPending)
omap ah <Plug>(GitGutterTextObjectOuterPending)
xmap ih <Plug>(GitGutterTextObjectInnerVisual)
xmap ah <Plug>(GitGutterTextObjectOuterVisual)

" vim-fugitive
packadd! vim-fugitive       " https://github.com/tpope/vim-fugitive.git

" vim-go
" Doesn't work in after/ftplugin/go.vim:
let g:go_def_mapping_enabled = 0
packadd! vim-go             " https://github.com/fatih/vim-go.git

" load internal plugins:
runtime macros/matchit.vim

" load other plugins:
packadd! rust.vim          " https://github.com/rust-lang/rust.vim.git
packadd! tmux-complete.vim " https://github.com/wellle/tmux-complete.vim.git
packadd! vim-commentary    " https://github.com/tpope/vim-commentary.git
packadd! vim-rails         " https://github.com/tpope/vim-rails.git
packadd! vim-jsx-pretty    " https://github.com/MaxMEllon/vim-jsx-pretty.git

" Requires both fzf.vim plugin to be manually installed:
" https://github.com/junegunn/fzf/blob/master/plugin/fzf.vim
" and also this separate plugin, which is loaded here:
packadd! fzf.vim           " https://github.com/junegunn/fzf.vim.git
packadd! vim-surround      " https://github.com/tpope/vim-surround.git
packadd! vim-rhubarb       " https://github.com/tpope/vim-rhubarb.git
packadd! editorconfig-vim  " https://github.com/editorconfig/editorconfig-vim.git
packadd! vim-wordmotion    " https://github.com/chaoren/vim-wordmotion.git

" formatter.nvim
packadd! formatter.nvim    " https://github.com/mhartington/formatter.nvim.git

lua <<EOF
-- return prettier configuration. If a frontend/ path exists in project root,
-- assume node_modules will be found there.
local prettier = function()
  local root_path = vim.fn.getcwd()
  local frontend_path = root_path .. "/frontend"
  local is_frontend = vim.fn.isdirectory(frontend_path) ~= 0
  local base_path = root_path
  if is_frontend then
    base_path = frontend_path
  end

  return {
    exe = base_path .. "/node_modules/.bin/prettier",
    args = {"--stdin-filepath", vim.api.nvim_buf_get_name(0), '--single-quote'},
    stdin = true
  }
end

require('formatter').setup({
  filetype = {
    javascript = { prettier },
    typescript = { prettier },
    typescriptreact = { prettier },
  }
})

vim.api.nvim_exec([[
augroup FormatAutogroup
  autocmd!
  autocmd BufWritePost *.js,*.ts,*.tsx silent FormatWrite
augroup END
]], true)

local bufnr = vim.call("bufnr", "%")
vim.api.nvim_buf_set_keymap(bufnr, 'n', '<leader>F', '<Cmd>silent Format<CR>', { noremap=true, silent=true })
EOF

" enable inline vim highlighting:
let g:vimsyn_embed= 'lPr'

" Treesitter

packadd! nvim-treesitter " https://github.com/nvim-treesitter/nvim-treesitter.git
packadd! nvim-treesitter-textobjects " https://github.com/nvim-treesitter/nvim-treesitter-textobjects.git
packadd! nvim-treesitter-refactor " https://github.com/nvim-treesitter/nvim-treesitter-refactor.git
packadd! nvim-treesitter-context " https://github.com/nvim-treesitter/nvim-treesitter-context.git
packadd! playground " https://github.com/nvim-treesitter/playground.git

lua <<EOF
require 'nvim-treesitter.configs'.setup {
  ensure_installed = "all",
  highlight = {
    enable = true, 
    disable = {"vim", "swift"},
    additional_vim_regex_highlighting = true,
  },
  incremental_selection = {
    enable = true,
  },
  indent = {
    -- enabling breaks autoindent:
    enable = false,
  },
  textobjects = {
    select = {
      enable = true,
      lookahead = true,
      keymaps = {
        ["ak"] = "@keyed_element.outer",
        ["av"] = "@keyed_element.inner",
        ["ia"] = "@parameter.inner",
        ["aa"] = "@parameter.outer",
        ["ac"] = "@comment.outer",
        ["at"] = "@statement.outer",
        ["ar"] = "@return",
        ["af"] = "@function.outer",
        ["if"] = "@function.inner",
      },
    },
    move = {
      enable = true,
      set_jumps = true,
      goto_next_start = {
        ["]a"] = "@parameter.inner",
        ["]f"] = "@function.outer",
        ["]F"] = "@function.inner",
      },
      goto_previous_start = {
        ["[a"] = "@parameter.inner",
        ["[f"] = "@function.outer",
        ["[F"] = "@function.inner",
      },
    },
    lsp_interop = {
      enable = true,
      peek_definition_code = {
        ["<leader>d"] = "@class.outer",
        ["<leader>d"] = "@function.outer",
      },
    },
  },
  refactor = {
    highlight_definitions = { enable = true },
    highlight_current_scope = { enable = false },
    smart_rename = {
      enable = true,
      keymaps = {
        smart_rename = "grr",
      },
    },
    navigation = {
      enable = true,
      keymaps = {
        -- goto_definition_lsp_fallback = "gd",
        goto_next_usage = "]r",
        goto_previous_usage = "[r",
      },
    },
  },
  playground = {
    enable = true,
    disable = {},
    updatetime = 25,
    persist_queries = false,
    keybindings = {
      toggle_query_editor = 'o',
      toggle_hl_groups = 'i',
      toggle_injected_languages = 't',
      toggle_anonymous_nodes = 'a',
      toggle_language_display = 'I',
      focus_language = 'f',
      unfocus_language = 'F',
      update = 'R',
      goto_node = '<cr>',
      show_help = '?',
    },
  }
}
EOF

lua <<EOF
require'treesitter-context'.setup{
  enable = true,
}
EOF

" copilot:

packadd! copilot.lua " https://github.com/zbirenbaum/copilot.lua.git

lua <<EOF
  vim.defer_fn(function()
    require('copilot').setup({
       panel = {
         enabled = false,
         auto_refresh = true,
       },
      suggestion = {
        enabled = false,
      },
    })
  end, 100)
EOF

" nvim-cmp:

packadd! nvim-cmp " https://github.com/hrsh7th/nvim-cmp.git
packadd! copilot-cmp " https://github.com/zbirenbaum/copilot-cmp.git
packadd! vim-vsnip " https://github.com/hrsh7th/vim-vsnip.git
packadd! cmp-vsnip " https://github.com/hrsh7th/cmp-vsnip.git
packadd! cmp-nvim-lsp " https://github.com/hrsh7th/cmp-nvim-lsp.git
packadd! cmp-buffer " https://github.com/hrsh7th/cmp-buffer.git
packadd! cmp-path " https://github.com/hrsh7th/cmp-path.git
packadd! cmp-calc " https://github.com/hrsh7th/cmp-calc

lua <<EOF
  local cmp = require('cmp')
  local cmp_buffer = require('cmp_buffer')

  cmp.setup({
    completion = {
      completeopt = 'menu,menuone,noinsert',
      keyword_length = 3,
    },
    snippet = {
      expand = function(args)
        vim.fn["vsnip#anonymous"](args.body)
      end,
    },
    mapping = {
      ['<C-u>'] = cmp.mapping.scroll_docs(-4),
      ['<C-d>'] = cmp.mapping.scroll_docs(4),
      ['<C-Space>'] = cmp.mapping.complete(),
      ['<C-e>'] = cmp.mapping.close(),
      ['<CR>'] = cmp.mapping.confirm({ select = true, behaviour = cmp.ConfirmBehavior.Replace }),
    },
    sources = cmp.config.sources({
      { name = 'copilot', keyword_length = 0 },
      { name = 'nvim_lsp' },
      { 
          name = 'buffer',
          option = {
            get_bufnrs = function()
              return vim.api.nvim_list_bufs()
            end
          },
      },
      { name = 'path' },
      { name = 'calc' },
    }),
    sorting = {
      comparators = {
        function(...) return cmp_buffer:compare_locality(...) end,
      }
    },
    view = {
      entries = 'native',
    },
    experimental = {
      ghost_text = true,
    },
  })
EOF

" LSP

packadd! nvim-lspconfig " https://github.com/neovim/nvim-lspconfig.git
packadd! lsp_signature.nvim " https://github.com/ray-x/lsp_signature.nvim.git
packadd! fzf-lsp.nvim " https://github.com/gfanto/fzf-lsp.nvim.git
packadd! lsp-colors.nvim " https://github.com/folke/lsp-colors.nvim.git

lua <<EOF
local nvim_lsp = require('lspconfig')
local on_attach = function(client, bufnr)
  -- nvim does not expose autocmd via Lua API yet:
  vim.api.nvim_exec([[autocmd User LspDiagnosticsChanged call lightline#update()]], false)

  local opts = { noremap=true, silent=false }
  vim.api.nvim_buf_set_keymap(bufnr, 'n', 'gd', '<Cmd>lua vim.lsp.buf.definition()<CR>', opts)
  vim.api.nvim_buf_set_keymap(bufnr, 'n', 'gD', '<Cmd>lua vim.lsp.buf.type_definition()<CR>', opts)
  vim.api.nvim_buf_set_keymap(bufnr, 'n', '<leader>gd', '<Cmd>lua vim.lsp.buf.definition()<CR>', opts)
  vim.api.nvim_buf_set_keymap(bufnr, 'n', '<leader>gD', '<Cmd>lua vim.lsp.buf.type_definition()<CR>', opts)
  vim.api.nvim_buf_set_keymap(bufnr, 'n', '<leader>e', '<Cmd>lua vim.lsp.buf.rename()<CR>', opts)
  vim.api.nvim_buf_set_keymap(bufnr, 'n', '<leader>r', '<Cmd>lua vim.lsp.buf.references()<CR>', opts)
  vim.api.nvim_buf_set_keymap(bufnr, 'n', '<leader>i', '<Cmd>lua vim.lsp.buf.implementation()<CR>', opts)
  vim.api.nvim_buf_set_keymap(bufnr, 'n', '<leader>ca', '<Cmd>lua vim.lsp.buf.code_action()<CR>', opts)
  vim.api.nvim_buf_set_keymap(bufnr, 'n', '<leader>ci', '<Cmd>lua vim.lsp.buf.incoming_calls()<CR>', opts)
  vim.api.nvim_buf_set_keymap(bufnr, 'n', '<leader>co', '<Cmd>lua vim.lsp.buf.outgoing_calls()<CR>', opts)
  vim.api.nvim_buf_set_keymap(bufnr, 'n', 'K', '<Cmd>lua vim.lsp.buf.hover()<CR>', opts)
  vim.api.nvim_buf_set_keymap(bufnr, 'n', ']e', '<Cmd>lua vim.diagnostic.goto_next({severity="Error"})<CR>', opts)
  vim.api.nvim_buf_set_keymap(bufnr, 'n', '[e', '<Cmd>lua vim.diagnostic.goto_prev({severity="Error"})<CR>', opts)
  vim.api.nvim_buf_set_keymap(bufnr, 'n', ']d', '<Cmd>lua vim.diagnostic.goto_next()<CR>', opts)
  vim.api.nvim_buf_set_keymap(bufnr, 'n', '[d', '<Cmd>lua vim.diagnostic.goto_prev()<CR>', opts)
  vim.api.nvim_buf_set_keymap(bufnr, 'n', 'cd', '<Cmd>lua vim.diagnostic.hide(nil, 0)<CR>', opts)

  -- fzf triggers:
  vim.api.nvim_buf_set_keymap(bufnr, 'n', '<leader>fr', '<Cmd>References<CR>', opts)
  vim.api.nvim_buf_set_keymap(bufnr, 'n', '<leader>fi', '<Cmd>Implementations<CR>', opts)
  vim.api.nvim_buf_set_keymap(bufnr, 'n', '<leader>fs', '<Cmd>DocumentSymbols<CR>', opts)
  vim.api.nvim_buf_set_keymap(bufnr, 'n', '<leader>fw', '<Cmd>WorkspaceSymbols<CR>', opts)
  vim.api.nvim_buf_set_keymap(bufnr, 'n', '<leader>fc', '<Cmd>CodeActions<CR>', opts)
  vim.api.nvim_buf_set_keymap(bufnr, 'n', '<leader>fci', '<Cmd>IncomingCalls<CR>', opts)
  vim.api.nvim_buf_set_keymap(bufnr, 'n', '<leader>fco', '<Cmd>OutgoingCalls<CR>', opts)

  require 'lsp_signature'.on_attach({
    hint_enable = false,
  })

  require 'copilot_cmp'.setup();
end

-- Go

local capabilities = require('cmp_nvim_lsp').default_capabilities()
capabilities.textDocument.completion.completionItem.snippetSupport = true
capabilities.textDocument.completion.completionItem.resolveSupport = {
  properties = {
    'documentation',
    'detail',
    'additionalTextEdits',
  }
}

nvim_lsp.gopls.setup{
  settings = {
    gopls = {
      staticcheck = true,
      -- Disalbing linksInHover may not be working as expected:
      linksInHover = false,
      usePlaceholders = true,
      analyses = {
        unusedparams = true,
        shadow = true,
        unusedwrite = true,
        unusedresult = true,
        nilness = true,
      },
    },
  },
  capabilities = capabilities,
  on_attach = on_attach,
}

-- Rust
nvim_lsp.rust_analyzer.setup{
  capabilities = capabilities,
  on_attach = on_attach,
    settings = {
        ["rust-analyzer"] = {
            imports = {
                granularity = {
                    group = "module",
                },
                prefix = "self",
            },
            cargo = {
                buildScripts = {
                    enable = true,
                },
            },
            procMacro = {
                enable = false,
            },
            diagnostics = {
              disabled = { "unresolved-proc-macro" },
            }
        }
    }
}

-- Ruby

nvim_lsp.solargraph.setup{
  on_attach = on_attach,
}

-- Typescript
-- https://jose-elias-alvarez.medium.com/configuring-neovims-lsp-client-for-typescript-development-5789d58ea9c

nvim_lsp.tsserver.setup{
  on_attach = on_attach,
}

local filetypes = {
  typescript = "eslint",
  typescriptreact = "eslint",
}

-- diagnosticls

local linters = {
  eslint = {
    sourceName = "eslint",
    -- fallback to global eslint if the local is not found?
    -- https://github.com/creativenull/diagnosticls-configs-nvim/blob/e7d6f7e99f6b416d2aeee89314bc46fc36df7b22/lua/diagnosticls-configs/fs.lua#L20
    command = "./node_modules/.bin/eslint",
    rootPatterns = {".eslintrc", ".eslintrc.js"},
    debounce = 100,
    args = {"--stdin", "--stdin-filename", "%filepath", "--format", "json"},
    parseJson = {
      errorsRoot = "[0].messages",
      line = "line",
      column = "column",
      endLine = "endLine",
      endColumn = "endColumn",
      message = "${message} [${ruleId}]",
      security = "severity"
    },
    securities = {[1] = "error", [2] = "warning"}
  }
}

nvim_lsp.diagnosticls.setup{
  on_attach = on_attach,
  filetypes = vim.tbl_keys(filetypes),
  init_options = {
    linters = linters,
    filetypes = filetypes,
  }
}

-- Lua

local lua_ls_root_path = os.getenv("HOME").."/dev/lua-language-server"
local lua_ls_binary = lua_ls_root_path.."/bin/lua-language-server"

local runtime_path = vim.split(package.path, ';')
table.insert(runtime_path, "lua/?.lua")
table.insert(runtime_path, "lua/?/init.lua")

nvim_lsp.lua_ls.setup {
  cmd = {lua_ls_binary, "-E", lua_ls_root_path .. "/main.lua"};
  settings = {
    Lua = {
      runtime = {
        version = 'LuaJIT',
        path = runtime_path,
      },
      diagnostics = {
        globals = {'vim'},
      },
      workspace = {
        library = vim.api.nvim_get_runtime_file("", true),
      },
      telemetry = {
        enable = false,
      },
    },
  },
  on_attach = on_attach,
}
EOF