856 lines
32 KiB
Nix
856 lines
32 KiB
Nix
{ config, lib, pkgs, inputs, ... }:
|
|
|
|
let cfg = config.modules.editor.vim;
|
|
in {
|
|
options.modules.editor.vim = { enable = lib.my.mkBoolOpt false; };
|
|
|
|
config = lib.mkIf cfg.enable {
|
|
home-manager.users.${config.user.name} = {
|
|
imports = [ inputs.nixvim.homeManagerModules.nixvim ];
|
|
programs.nixvim = {
|
|
enable = true;
|
|
package = pkgs.unstable.neovim-unwrapped;
|
|
vimAlias = true;
|
|
|
|
globals.mapleader = " ";
|
|
|
|
opts = {
|
|
# Keep visual indentation on wrapped lines
|
|
breakindent = true;
|
|
|
|
# Hide command line unless needed
|
|
cmdheight = 0;
|
|
|
|
# Insert mode completion options
|
|
completeopt = [ "menu" "menuone" "noselect" ];
|
|
|
|
# Raise a dialog asking if you wish to save the current file(s)
|
|
confirm = true;
|
|
|
|
# Copy previous indentation on autoindenting
|
|
copyindent = true;
|
|
|
|
# Highlight current line
|
|
cursorline = true;
|
|
|
|
# Enable linematch diff algorithm
|
|
diffopt.__raw = /*lua*/ ''
|
|
vim.list_extend(vim.opt.diffopt:get(), { "algorithm:histogram", "linematch:60" })
|
|
'';
|
|
|
|
# Expand <Tab> to spaces
|
|
expandtab = false;
|
|
|
|
# Disable `~` on nonexistent lines
|
|
fillchars = { eob = " "; };
|
|
|
|
# Enable fold with all code unfolded
|
|
foldcolumn = "1";
|
|
foldenable = true;
|
|
foldlevel = 99;
|
|
foldlevelstart = 99;
|
|
|
|
# Ignore case in search patterns
|
|
ignorecase = true;
|
|
|
|
# Show substitution preview in split window
|
|
inccommand = "split";
|
|
# Infer casing on word completion
|
|
infercase = true;
|
|
|
|
# Global statusline
|
|
laststatus = 3;
|
|
|
|
# Wrap lines at 'breakat'
|
|
linebreak = true;
|
|
|
|
# Enable list mode
|
|
list = true;
|
|
|
|
# Set custom strings for list mode
|
|
# - tabulations are shown as ‒▶
|
|
# - trailing spaces are shown as ·
|
|
# - multiple non-leading consecutive spaces are shown as bullets (·)
|
|
# - non-breakable spaces are shown as ⎕
|
|
listchars = "tab:» ,trail:·,multispace:·,lead: ,nbsp:␣";
|
|
|
|
# Enable mouse support
|
|
mouse = "a";
|
|
|
|
# Show line numbers
|
|
number = true;
|
|
|
|
# Preserve indentation as much as possible
|
|
preserveindent = true;
|
|
|
|
# Height of the popup menu
|
|
pumheight = 10;
|
|
|
|
# Display line numbers relative to current line
|
|
relativenumber = false;
|
|
|
|
# Number of spaces to use for indentation
|
|
shiftwidth = 2;
|
|
|
|
# Disable search count wrap and startup messages
|
|
shortmess.__raw = /*lua*/ ''
|
|
vim.tbl_deep_extend("force", vim.opt.shortmess:get(), { s = true, I = true })
|
|
'';
|
|
|
|
# Disable showing modes in command line
|
|
showmode = false;
|
|
|
|
# Show tabline when needed
|
|
showtabline = 1;
|
|
|
|
# Show signs column
|
|
signcolumn = "yes";
|
|
|
|
# Override ignorecase if search pattern contains uppercase characters
|
|
smartcase = true;
|
|
|
|
# Number of spaces input on <Tab>
|
|
softtabstop = 2;
|
|
|
|
# Open horizontal split below (:split)
|
|
splitbelow = true;
|
|
|
|
# Open vertical split to the right (:vsplit)
|
|
splitright = true;
|
|
|
|
# Number of spaces to represent a <Tab>
|
|
tabstop = 2;
|
|
|
|
# Enables 24-bit RGB color
|
|
termguicolors = true;
|
|
|
|
# Shorter timeout duration
|
|
timeoutlen = 500;
|
|
|
|
# Set window title to the filename
|
|
title = true;
|
|
|
|
# Save undo history to undo file (in $XDG_STATE_HOME/nvim/undo)
|
|
undofile = true;
|
|
|
|
viewoptions.__raw = /*lua*/ ''
|
|
vim.tbl_filter(function(val) return val ~= "curdir" end, vim.opt.viewoptions:get())
|
|
'';
|
|
|
|
# Enable virtual edit in visual block mode
|
|
# This has the effect of selecting empty cells beyond lines boundaries
|
|
virtualedit = "block";
|
|
|
|
# Disable line wrapping
|
|
wrap = false;
|
|
|
|
# Disable making a backup before overwriting a file
|
|
writebackup = false;
|
|
|
|
# Sync clipboard between OS and Neovim.
|
|
clipboard = "unnamedplus";
|
|
};
|
|
|
|
keymaps = [
|
|
# Search
|
|
{
|
|
key = "<leader><leader>";
|
|
action = "<CMD>Telescope fd layout_strategy=vertical<CR>";
|
|
}
|
|
{
|
|
key = "<leader>sh";
|
|
action = "<CMD>Telescope help_tags<CR>";
|
|
options.desc = "[S]earch [H]elp";
|
|
}
|
|
{
|
|
key = "<leader>sk";
|
|
action = "<CMD>Telescope keymaps<CR>";
|
|
options.desc = "[S]earch [K]eymaps";
|
|
}
|
|
{
|
|
key = "<leader>ss";
|
|
action = "<CMD>Telescope<CR>";
|
|
options.desc = "[S]earch [S]elect Telescope";
|
|
}
|
|
{
|
|
key = "<leader>/";
|
|
action = "<CMD>Telescope live_grep layout_strategy=vertical<CR>";
|
|
options.desc = "Search with rg";
|
|
}
|
|
{
|
|
key = "<leader>sR";
|
|
action = "<CMD>Telescope resume<CR>";
|
|
options.desc = "[S]earch [R]esume";
|
|
}
|
|
{
|
|
key = "<leader>cx";
|
|
action = "<CMD>Telescope diagnostics layout_strategy=vertical<CR>";
|
|
options.desc = "Search diagnostics";
|
|
}
|
|
# File
|
|
{
|
|
key = "<leader>fs";
|
|
action.__raw = /*lua*/''
|
|
function()
|
|
vim.lsp.buf.format()
|
|
vim.cmd.write()
|
|
end
|
|
'';
|
|
options.desc = "Format and save buffer";
|
|
}
|
|
{
|
|
mode = "n";
|
|
key = "<leader>fn";
|
|
action = "<CMD>enew<CR>";
|
|
options.desc = "New File";
|
|
}
|
|
# Project
|
|
{
|
|
key = "<leader>ps";
|
|
action = "<CMD>wa<CR>";
|
|
options.desc = "Save all buffers";
|
|
}
|
|
# Git
|
|
{
|
|
key = "<leader>gg";
|
|
action = "<CMD>Neogit<CR>";
|
|
}
|
|
# Buffers
|
|
{
|
|
key = "<leader>bb";
|
|
action = "<CMD>Telescope buffers layout_strategy=vertical<CR>";
|
|
}
|
|
{
|
|
key = "<leader>bn";
|
|
action = "<CMD>bnext<CR>";
|
|
options.desc = "Next buffer";
|
|
}
|
|
{
|
|
key = "<leader>bp";
|
|
action = "<CMD>bprev<CR>";
|
|
options.desc = "Previous buffer";
|
|
}
|
|
{
|
|
key = "<leader>bl";
|
|
action = "<CMD>e #<CR>";
|
|
options.desc = "Other buffer";
|
|
}
|
|
{
|
|
key = "<leader>bk";
|
|
action = "<CMD>bd<CR>";
|
|
options.desc = "Delete buffer and Window";
|
|
}
|
|
{
|
|
key = "<leader>bd";
|
|
action = "<CMD>bd<CR>";
|
|
options.desc = "Delete buffer and Window";
|
|
}
|
|
# Windows
|
|
{
|
|
mode = "n";
|
|
key = "<leader>ww";
|
|
action = "<C-w>p";
|
|
options = { desc = "Other Window"; remap = true; };
|
|
}
|
|
{
|
|
mode = "n";
|
|
key = "<leader>wd";
|
|
action = "<C-w>c";
|
|
options = { desc = "Delete Window"; remap = true; };
|
|
}
|
|
{
|
|
mode = "n";
|
|
key = "<leader>ws";
|
|
action = "<C-w>s";
|
|
options = { desc = "Split Window Below"; remap = true; };
|
|
}
|
|
{
|
|
mode = "n";
|
|
key = "<leader>wv";
|
|
action = "<C-w>v";
|
|
options = { desc = "Split Window Right"; remap = true; };
|
|
}
|
|
{
|
|
mode = "n";
|
|
key = "<c-j>";
|
|
action = "<C-w>j";
|
|
options = { desc = "Go to Lower Winddow"; remap = true; };
|
|
}
|
|
{
|
|
mode = "n";
|
|
key = "<leader>wj";
|
|
action = "<C-w>j";
|
|
options = { desc = "Go to Lower Winddow"; remap = true; };
|
|
}
|
|
{
|
|
mode = "n";
|
|
key = "<c-k>";
|
|
action = "<C-w>k";
|
|
options = { desc = "Go to Upper Winddow"; remap = true; };
|
|
}
|
|
{
|
|
mode = "n";
|
|
key = "<leader>wk";
|
|
action = "<C-w>k";
|
|
options = { desc = "Go to Upper Winddow"; remap = true; };
|
|
}
|
|
{
|
|
mode = "n";
|
|
key = "<c-l>";
|
|
action = "<C-w>l";
|
|
options = { desc = "Go to Right Winddow"; remap = true; };
|
|
}
|
|
# Move lines
|
|
{
|
|
mode = "n";
|
|
key = "<A-j>";
|
|
action = "<cmd>m .+1<cr>==";
|
|
options.desc = "Move Down";
|
|
}
|
|
{
|
|
mode = "n";
|
|
key = "<A-k>";
|
|
action = "<cmd>m .-2<cr>==";
|
|
options.desc = "Move Up";
|
|
}
|
|
{
|
|
mode = "i";
|
|
key = "<A-j>";
|
|
action = "<esc><cmd>m .+1<cr>==gi";
|
|
options.desc = "Move Down";
|
|
}
|
|
{
|
|
mode = "i";
|
|
key = "<A-k>";
|
|
action = "<esc><cmd>m .-2<cr>==gi";
|
|
options.desc = "Move Up";
|
|
}
|
|
{
|
|
mode = "v";
|
|
key = "<A-j>";
|
|
action = ":m '>+1<cr>gv=gv";
|
|
options.desc = "Move Down";
|
|
}
|
|
{
|
|
mode = "v";
|
|
key = "<A-k>";
|
|
action = ":m '<-2<cr>gv=gv";
|
|
options.desc = "Move Up";
|
|
}
|
|
# Better indenting
|
|
{
|
|
mode = "v";
|
|
key = "<";
|
|
action = "<gv";
|
|
}
|
|
{
|
|
mode = "v";
|
|
key = ">";
|
|
action = ">gv";
|
|
}
|
|
];
|
|
|
|
plugins = {
|
|
lazy = {
|
|
enable = true;
|
|
plugins = [
|
|
{
|
|
pkg = pkgs.vimPlugins.mini-nvim;
|
|
event = "VeryLazy";
|
|
opts.__raw = /*lua*/ ''
|
|
{
|
|
modes = { insert = true, command = true, terminal = false },
|
|
-- skip autopair when next character is one of these
|
|
skip_next = [=[[%w%%%'%[%"%.%`%$]]=],
|
|
-- skip autopair when the cursor is inside these treesitter nodes
|
|
skip_ts = { "string" },
|
|
-- skip autopair when next character is closing pair
|
|
-- and there are more closing pairs than opening pairs
|
|
skip_unbalanced = true,
|
|
-- better deal with markdown code blocks
|
|
markdown = true,
|
|
}
|
|
'';
|
|
config = /*lua*/ ''
|
|
function (_, opts)
|
|
local pairs = require("mini.pairs")
|
|
pairs.setup(opts)
|
|
local open = pairs.open
|
|
pairs.open = function(pair, neigh_pattern)
|
|
if vim.fn.getcmdline() ~= "" then
|
|
return open(pair, neigh_pattern)
|
|
end
|
|
local o, c = pair:sub(1, 1), pair:sub(2, 2)
|
|
local line = vim.api.nvim_get_current_line()
|
|
local cursor = vim.api.nvim_win_get_cursor(0)
|
|
local next = line:sub(cursor[2] + 1, cursor[2] + 1)
|
|
local before = line:sub(1, cursor[2])
|
|
if opts.markdown and o == "`" and vim.bo.filetype == "markdown" and before:match("^%s*``") then
|
|
return "`\n```" .. vim.api.nvim_replace_termcodes("<up>", true, true, true)
|
|
end
|
|
if opts.skip_next and next ~= "" and next:match(opts.skip_next) then
|
|
return o
|
|
end
|
|
if opts.skip_ts and #opts.skip_ts > 0 then
|
|
local ok, captures = pcall(vim.treesitter.get_captures_at_pos, 0, cursor[1] - 1, math.max(cursor[2] - 1, 0))
|
|
for _, capture in ipairs(ok and captures or {}) do
|
|
if vim.tbl_contains(opts.skip_ts, capture.capture) then
|
|
return o
|
|
end
|
|
end
|
|
end
|
|
if opts.skip_unbalanced and next == c and c ~= o then
|
|
local _, count_open = line:gsub(vim.pesc(pair:sub(1, 1)), "")
|
|
local _, count_close = line:gsub(vim.pesc(pair:sub(2, 2)), "")
|
|
if count_close > count_open then
|
|
return o
|
|
end
|
|
end
|
|
return open(pair, neigh_pattern)
|
|
end
|
|
end
|
|
'';
|
|
}
|
|
{
|
|
pkg = pkgs.vimPlugins.lualine-nvim;
|
|
event = "VeryLazy";
|
|
init = /*lua*/ ''
|
|
function()
|
|
vim.g.lualine_laststatus = vim.o.laststatus
|
|
if vim.fn.argc(-1) > 0 then
|
|
-- set an empty statusline till lualine loads
|
|
vim.o.statusline = " "
|
|
else
|
|
-- hide the statusline on the starter page
|
|
vim.o.laststatus = 0
|
|
end
|
|
end
|
|
'';
|
|
opts.__raw = /*lua*/ ''
|
|
{
|
|
options = {
|
|
icons_enabled = true,
|
|
}
|
|
}
|
|
'';
|
|
}
|
|
{
|
|
pkg = pkgs.unstable.vimPlugins.neogit;
|
|
dependencies = [ pkgs.vimPlugins.plenary-nvim pkgs.vimPlugins.diffview-nvim pkgs.vimPlugins.telescope-nvim ];
|
|
event = "VeryLazy";
|
|
config = true;
|
|
}
|
|
{
|
|
pkg = pkgs.vimPlugins.gitsigns-nvim;
|
|
opts.__raw = /*lua*/ ''
|
|
{
|
|
on_attach = function(buffer)
|
|
local gs = package.loaded.gitsigns
|
|
|
|
local function map(mode, l ,r, desc)
|
|
vim.keymap.set(mode, l, r, { buffer = buffer, desc = desc})
|
|
end
|
|
|
|
map("n", "<leader>h;", function()
|
|
if vim.wo.diff then
|
|
vim.cmd.normal({ "]c", bang = true })
|
|
else
|
|
gs.nav_hunk("next")
|
|
end
|
|
end, "Next Hunk")
|
|
map("n", "<leader>h,", function()
|
|
if vim.wo.diff then
|
|
vim.cmd.normal({ "[c", bang = true })
|
|
else
|
|
gs.nav_hunk("prev")
|
|
end
|
|
end, "Prev Hunk")
|
|
map({ "n", "v" }, "<leader>gs", gs.stage_hunk, "Stage Hunk")
|
|
map({ "n", "v" }, "<leader>gr", gs.reset_hunk, "Reset Hunk")
|
|
map("n", "<leader>gS", gs.stage_buffer, "Stage Buffer")
|
|
map("n", "<leader>gu", gs.undo_stage_hunk, "Undo Stage Hunk")
|
|
map("n", "<leader>gR", gs.reset_buffer, "Reset Buffer")
|
|
map("n", "<leader>gp", gs.preview_hunk_inline, "Preview Hunk Inline")
|
|
map("n", "<leader>gb", function() gs.blame_line({ full = true }) end, "Blame Line")
|
|
map("n", "<leader>gd", gs.diffthis, "Diff This")
|
|
map("n", "<leader>gD", function() gs.diffthis("~") end, "Diff This ~")
|
|
map('n', '<leader>tb', gs.toggle_current_line_blame, "Toggle current line blame")
|
|
map({ "o", "x" }, "ih", ":<C-U>Gitsigns select_hunk<CR>", "GitSigns Select Hunk")
|
|
end,
|
|
}
|
|
'';
|
|
}
|
|
{
|
|
pkg =
|
|
(pkgs.vimUtils.buildVimPlugin {
|
|
name = "yazi.nvim";
|
|
src = inputs.vim-yazi;
|
|
});
|
|
event = "VeryLazy";
|
|
keys.__raw = /*lua*/ ''
|
|
{
|
|
{ "<leader>.", function() require("yazi").yazi() end, desc = "Open file manager" },
|
|
{ "<bs>", desc = "Decrement Selection", mode = "x" },
|
|
}
|
|
'';
|
|
opts.__raw = /*lua*/ ''
|
|
{
|
|
open_for_directories = true,
|
|
}
|
|
'';
|
|
}
|
|
{
|
|
pkg = pkgs.unstable.vimPlugins.fidget-nvim;
|
|
opts.__raw = /*lua*/ ''
|
|
{
|
|
logger = { level = vim.log.levels.WARN },
|
|
notification = { filter = vim.log.levels.INFO },
|
|
}
|
|
'';
|
|
}
|
|
{
|
|
pkg = pkgs.unstable.vimPlugins.indent-blankline-nvim;
|
|
event = "VeryLazy";
|
|
main = "ibl";
|
|
opts = {
|
|
scope.enabled = false;
|
|
};
|
|
}
|
|
{
|
|
pkg = pkgs.unstable.vimPlugins.vim-sleuth;
|
|
}
|
|
{
|
|
pkg = pkgs.unstable.vimPlugins.comment-nvim;
|
|
}
|
|
{
|
|
pkg = pkgs.vimPlugins.leap-nvim;
|
|
config = /*lua*/ ''
|
|
function (_, opts)
|
|
local leap = require("leap")
|
|
for k, v in pairs(opts) do
|
|
leap.opts[k] = v
|
|
end
|
|
leap.add_default_mappings(true)
|
|
end
|
|
'';
|
|
}
|
|
{
|
|
pkg = pkgs.vimPlugins.telescope-nvim;
|
|
dependencies = [
|
|
pkgs.vimPlugins.plenary-nvim
|
|
pkgs.vimPlugins.nvim-web-devicons
|
|
pkgs.vimPlugins.telescope-ui-select-nvim
|
|
pkgs.vimPlugins.telescope-fzf-native-nvim
|
|
];
|
|
opts.__raw = /*lua*/ ''
|
|
{
|
|
defaults = {
|
|
layout_config = {
|
|
vertical = { width = 0.9 }
|
|
},
|
|
},
|
|
}
|
|
'';
|
|
}
|
|
{
|
|
pkg = pkgs.vimPlugins.nvim-treesitter.withAllGrammars;
|
|
lazy.__raw = "vim.fn.argc(-1) == 0";
|
|
init = /*lua*/ ''
|
|
function(plugin)
|
|
-- PERF: add nvim-treesitter queries to the rtp and it's custom query predicates early
|
|
-- This is needed because a bunch of plugins no longer `require("nvim-treesitter")`, which
|
|
-- no longer trigger the **nvim-treesitter** module to be loaded in time.
|
|
-- Luckily, the only things that those plugins need are the custom queries, which we make available
|
|
-- during startup.
|
|
require("lazy.core.loader").add_to_rtp(plugin)
|
|
require("nvim-treesitter.query_predicates")
|
|
end
|
|
'';
|
|
cmd = [ "TSUpdateSync" "TSUpdate" "TSInstall" ];
|
|
keys.__raw = /*lua*/ ''
|
|
{
|
|
{ "<c-space>", desc = "Increment Selection" },
|
|
{ "<bs>", desc = "Decrement Selection", mode = "x" },
|
|
}
|
|
'';
|
|
opts.__raw = /*lua*/ ''
|
|
{
|
|
highlight = { enable = true },
|
|
indent = { enable = true },
|
|
ensure_installed = "all",
|
|
parser_install_dir = vim.fs.joinpath(vim.fn.stdpath('data'), 'site'),
|
|
incremental_selection = {
|
|
enable = true,
|
|
keymaps = {
|
|
init_selection = "<C-space>",
|
|
node_incremental = "<C-space>",
|
|
scope_incremental = false,
|
|
node_decremental = "<bs>",
|
|
},
|
|
},
|
|
ignore_install = { "org" },
|
|
}
|
|
'';
|
|
config = /*lua*/ ''
|
|
function (_, opts)
|
|
require("nvim-treesitter.configs").setup(opts)
|
|
vim.opt.runtimepath:prepend(vim.fs.joinpath(vim.fn.stdpath('data'), 'site'))
|
|
end
|
|
'';
|
|
}
|
|
{
|
|
pkg = pkgs.unstable.vimPlugins.which-key-nvim;
|
|
event = "VimEnter";
|
|
config = /*lua*/ ''
|
|
function ()
|
|
require('which-key').setup()
|
|
require('which-key').register {
|
|
['<leader>b'] = { name = 'Buffer', _ = 'which_key_ignore' },
|
|
['<leader>c'] = { name = 'Code', _ = 'which_key_ignore' },
|
|
['<leader>d'] = { name = 'Document', _ = 'which_key_ignore' },
|
|
['<leader>f'] = { name = 'File', _ = 'which_key_ignore' },
|
|
['<leader>g'] = { name = 'Git', _ = 'which_key_ignore' },
|
|
['<leader>o'] = { name = 'Org', _ = 'which_key_ignore' },
|
|
['<leader>n'] = { name = 'Org-roam', _ = 'which_key_ignore' },
|
|
['<leader>p'] = { name = 'Project', _ = 'which_key_ignore' },
|
|
['<leader>r'] = { name = 'Rename', _ = 'which_key_ignore' },
|
|
['<leader>s'] = { name = 'Search', _ = 'which_key_ignore' },
|
|
['<leader>w'] = { name = 'Window', _ = 'which_key_ignore' },
|
|
['<leader>t'] = { name = 'Toggle', _ = 'which_key_ignore' },
|
|
}
|
|
end
|
|
'';
|
|
}
|
|
{
|
|
pkg = pkgs.vimPlugins.nvim-lspconfig;
|
|
config = /*lua*/ ''
|
|
function ()
|
|
vim.api.nvim_create_autocmd('LspAttach', {
|
|
group = vim.api.nvim_create_augroup('lsp-attach', { clear = true }),
|
|
callback = function(event)
|
|
local map = function(keys, func, desc)
|
|
vim.keymap.set('n', keys, func, { buffer = event.buf, desc = 'LSP: ' .. desc })
|
|
end
|
|
|
|
map('gd', require('telescope.builtin').lsp_definitions, 'Go to definition')
|
|
map('gr', require('telescope.builtin').lsp_references, 'Go to references')
|
|
map('gI', require('telescope.builtin').lsp_implementations, 'Goto implementation')
|
|
map('gD', vim.lsp.buf.declaration, 'Go to declaration')
|
|
map('gT', require('telescope.builtin').lsp_type_definitions, 'Type definition')
|
|
map('<leader>cD', require('telescope.builtin').lsp_document_symbols, 'Document symbols')
|
|
map('<leader>cw', require('telescope.builtin').lsp_dynamic_workspace_symbols, 'Workspace symbols ')
|
|
map('<leader>cd', vim.diagnostic.open_float, 'Line diagnostics')
|
|
map('<leader>c,', vim.diagnostic.goto_prev, 'Previous diagnostics')
|
|
map('<leader>c;', vim.diagnostic.goto_next, 'Next diagnostics')
|
|
map('<leader>cr', vim.lsp.buf.rename, 'Rename')
|
|
map('<leader>ca', vim.lsp.buf.code_action, 'Code action')
|
|
map('K', vim.lsp.buf.hover, 'Hover Documentation')
|
|
end
|
|
})
|
|
|
|
local has_cmp, cmp_nvim_lsp = pcall(require, "cmp_nvim_lsp")
|
|
local capabilities = vim.tbl_deep_extend(
|
|
"force",
|
|
{},
|
|
vim.lsp.protocol.make_client_capabilities(),
|
|
has_cmp and cmp_nvim_lsp.default_capabilities() or {}
|
|
)
|
|
|
|
local function setup(server, server_opts)
|
|
local server_opts_with_caps = vim.tbl_deep_extend("force", {
|
|
capabilities = vim.deepcopy(capabilities),
|
|
}, server_opts)
|
|
|
|
require("lspconfig")[server].setup(server_opts_with_caps)
|
|
end
|
|
|
|
setup("yamlls", {})
|
|
setup("typos_lsp", {
|
|
init_options = { diagnosticSeverity = "Hint" }
|
|
})
|
|
setup("tsserver", {})
|
|
setup("terraformls", {})
|
|
setup("sqls", {})
|
|
setup("nixd", {})
|
|
setup("marksman", {})
|
|
setup("lua_ls", {})
|
|
setup("jsonls", { cmd = { "${pkgs.vscode-langservers-extracted}/bin/vscode-json-language-server", "--stdio" } })
|
|
setup("html", { cmd = { "${pkgs.vscode-langservers-extracted}/bin/vscode-html-language-server", "--stdio" } })
|
|
setup("eslint", { cmd = { "${pkgs.vscode-langservers-extracted}/bin/vscode-eslint-language-server", "--stdio" } })
|
|
setup("dockerls", { cmd = { "${pkgs.dockerfile-language-server-nodejs}/bin/docker-langserver", "--stdio" } })
|
|
setup("docker_compose_language_service", {})
|
|
setup("cssls", { cmd = { "${pkgs.vscode-langservers-extracted}/bin/vscode-css-language-server", "--stdio" } })
|
|
setup("bashls", {})
|
|
setup("ansiblels", { cmd = { "${pkgs.ansible-language-server}/bin/ansible-language-server", "--stdio" } })
|
|
end
|
|
'';
|
|
}
|
|
{
|
|
pkg = pkgs.unstable.vimPlugins.nvim-metals;
|
|
dependencies = [ pkgs.vimPlugins.plenary-nvim ];
|
|
ft = [ "scala" "sbt" ];
|
|
opts.__raw = /*lua*/ ''
|
|
function()
|
|
local metals_config = require("metals").bare_config()
|
|
metals_config.on_attach = function(client, bufnr)
|
|
vim.keymap.set(
|
|
"n",
|
|
"<leader>me",
|
|
function() require("telescope").extensions.metals.commands() end,
|
|
{ noremap=true, silent=true, buffer = bufn, desc = "Metals commands"}
|
|
)
|
|
vim.keymap.set(
|
|
"n",
|
|
"<leader>co",
|
|
"<CMD>MetalsOrganizeImports<CR>",
|
|
{ noremap=true, silent=true, buffer = bufn, desc = "Organize imports"}
|
|
)
|
|
end
|
|
metals_config.init_options.statusBarProvider = "off"
|
|
metals_config.settings = {
|
|
showImplicitArguments = true,
|
|
}
|
|
return metals_config
|
|
end
|
|
'';
|
|
config = /*lua*/ ''
|
|
function (self, metals_config)
|
|
local nvim_metals_group = vim.api.nvim_create_augroup("nvim-metals", { clear = true })
|
|
vim.api.nvim_create_autocmd("FileType", {
|
|
pattern = self.ft,
|
|
callback = function()
|
|
require("metals").initialize_or_attach(metals_config)
|
|
end,
|
|
group = nvim_metals_group,
|
|
})
|
|
end
|
|
'';
|
|
}
|
|
{
|
|
pkg = pkgs.unstable.vimPlugins.nvim-cmp;
|
|
event = "InsertEnter";
|
|
dependencies = [
|
|
pkgs.unstable.vimPlugins.cmp-nvim-lsp
|
|
pkgs.unstable.vimPlugins.cmp-path
|
|
pkgs.unstable.vimPlugins.cmp-buffer
|
|
];
|
|
opts.__raw = /*lua*/ ''
|
|
function()
|
|
local cmp = require("cmp")
|
|
return {
|
|
mapping = {
|
|
["<C-Space>"] = cmp.mapping.complete(),
|
|
["<C-b>"] = cmp.mapping.scroll_docs(-4),
|
|
["<C-e>"] = cmp.mapping.close(),
|
|
["<C-f>"] = cmp.mapping.scroll_docs(4),
|
|
["<CR>"] = cmp.mapping.confirm({ select = true }),
|
|
["<C-y>"] = cmp.mapping.confirm({ select = true }),
|
|
["<S-Tab>"] = cmp.mapping(cmp.mapping.select_prev_item(), { "i", "s" }),
|
|
["<Tab>"] = cmp.mapping(cmp.mapping.select_next_item(), { "i", "s" }),
|
|
},
|
|
sources = {
|
|
{ name = "nvim_lsp" },
|
|
{ name = "path" },
|
|
{ name = "buffer" },
|
|
{ name = "orgmode" },
|
|
},
|
|
}
|
|
end
|
|
'';
|
|
}
|
|
{
|
|
pkg = pkgs.unstable.vimPlugins.nvim-spectre;
|
|
cmd = "Spectre";
|
|
opts = { open_cmd = "noswapfile vnew"; };
|
|
keys.__raw = /*lua*/ ''
|
|
{
|
|
{ "<leader>sr", function() require("spectre").open() end, desc = "Replace in Files (Spectre)" },
|
|
}
|
|
'';
|
|
}
|
|
|
|
# Disabled for now as it tries to write org grammar to its own directory in the nix store
|
|
# https://github.com/nvim-orgmode/orgmode/blob/95fb795a422f0455e03d13a3f83525f1d00793ad/lua/orgmode/utils/treesitter/install.lua#L9
|
|
# {
|
|
# pkg = pkgs.unstable.vimPlugins.orgmode;
|
|
# event = "VeryLazy";
|
|
# ft = [ "org" ];
|
|
# config = /*lua*/ ''
|
|
# function ()
|
|
# require('orgmode').setup({
|
|
# org_agend_files = '~/Nextcloud/Org/**/*',
|
|
# org_default_notes_file = '~/Nextcloud/Org/refile.org',
|
|
# })
|
|
# end
|
|
# '';
|
|
# }
|
|
# {
|
|
# pkg = (pkgs.vimUtils.buildVimPlugin {
|
|
# name = "org-roam.nvim";
|
|
# src = inputs.vim-org-roam;
|
|
# });
|
|
# dependencies = [ pkgs.unstable.vimPlugins.orgmode ];
|
|
# event = "VeryLazy";
|
|
# ft = [ "org" ];
|
|
# config = /*lua*/ ''
|
|
# function ()
|
|
# require('org-roam').setup({
|
|
# directory = '~/Nextcloud/OrgRoam',
|
|
# })
|
|
# end
|
|
# '';
|
|
# }
|
|
];
|
|
};
|
|
};
|
|
colorschemes.gruvbox = {
|
|
enable = true;
|
|
package = pkgs.unstable.vimPlugins.gruvbox-nvim;
|
|
settings = {
|
|
overrides = {
|
|
Include = { link = "GruvboxRed"; };
|
|
"@constructor" = { link = "GruvboxYellow"; };
|
|
"@function.builtin" = { link = "GruvboxFg1"; };
|
|
"@function.call" = { link = "GruvboxFg1"; };
|
|
"@function.macro" = { link = "GruvboxFg1"; };
|
|
"@function.method.call.scala" = { link = "GruvboxFg1"; };
|
|
"@method.call" = { link = "GruvboxFg1"; };
|
|
"@variable.member.scala" = { link = "GruvboxFg1"; };
|
|
"@lsp.type.type.scala" = { link = ""; };
|
|
"@lsp.type.method.scala" = { link = ""; };
|
|
"@lsp.type.modifier.scala" = { link = "GruvboxOrange"; };
|
|
"@lsp.type.typeParameter.scala" = { link = "GruvboxAqua"; };
|
|
|
|
"@lsp.type.type.nix" = { link = ""; };
|
|
"@lsp.type.method.nix" = { link = ""; };
|
|
"@lsp.type.macro.nix" = { link = ""; };
|
|
"@lsp.type.interface.nix" = { link = ""; };
|
|
};
|
|
};
|
|
};
|
|
};
|
|
|
|
home.packages = with pkgs.unstable; [
|
|
ripgrep
|
|
fd
|
|
nodejs
|
|
opentofu
|
|
nixfmt-rfc-style
|
|
nixpkgs-fmt
|
|
coursier
|
|
|
|
# LSP
|
|
yaml-language-server
|
|
typos-lsp
|
|
nodePackages.typescript-language-server
|
|
terraform-ls
|
|
sqls
|
|
nixd
|
|
marksman
|
|
lua-language-server
|
|
docker-compose-language-service
|
|
bash-language-server
|
|
];
|
|
};
|
|
};
|
|
}
|