path: root/dotfiles/vim.lua

-- Options
----------

vim.o.undofile = true
vim.o.backup = true
vim.opt.backupdir:remove "."

vim.opt.shortmess:append "c"

vim.o.mouse = "a"

vim.o.ignorecase = true
vim.o.smartcase = true

vim.o.smartindent = true

-- tabstop and shiftwidth are also set locally by individual filetypes

vim.o.tabstop = 4
vim.o.shiftwidth = 4

vim.opt.shortmess:append "A"

vim.o.inccommand = "split"

vim.o.scrolloff = 1
vim.o.sidescrolloff = 5

vim.o.colorcolumn = "80"
vim.o.cursorline = true

vim.o.title = true

vim.opt.wildmode = { "longest:full", "full" }
vim.opt.completeopt = { "menu", "menuone", "preview", "noinsert", "noselect" }

-- Use ripgrep
vim.o.grepprg = vim.g.ripgrep_path .. " --vimgrep --smart-case"
vim.o.grepformat = "%f:%l:%c:%m," .. vim.o.grepformat

vim.o.termguicolors = true
vim.o.background = "dark"

vim.o.updatetime = 1000

-- Mode already shown by the status line
vim.o.showmode = false

vim.opt.listchars = {
	extends = ">",
	nbsp = "+",
	precedes = "<",
	tab = "  ",
	trail = "-",
}
vim.wo.list = true

-- Leaders
----------

vim.g.maplocalleader = ","
vim.g.mapleader = ";"

-- Misc
-------

-- From neovim#14420
-- Restores the position of previously opened files

-- Inspired by: https://github.com/ethanholz/nvim-lastplace

local last_cursor_pos_augroup = vim.api.nvim_create_augroup("LastCursorPos", {})
vim.api.nvim_create_autocmd("BufReadPost", {
	group = last_cursor_pos_augroup,
	desc = "Restore the position of previously opened files",
	callback = function(opts)
		if vim.tbl_contains({ "quickfix", "nofile", "help" }, vim.bo.buftype) then
			return
		end

		if vim.tbl_contains({ "gitcommit", "gitrebase", "svn", "hgcommit" }, vim.bo.filetype) then
			return
		end

		-- If a line has already been specified on the command line, we are done
		--   nvim file +num
		if vim.fn.line "." > 1 then
			return
		end

		-- If the last line is set and the less than the last line in the buffer
		if vim.fn.line [['"]] > 0 and vim.fn.line [['"]] <= vim.fn.line "$" then
			if vim.fn.line "w$" == vim.fn.line "$" then
				-- if the last line in the current buffer is also the last line visible
				-- in this window
				vim.cmd [[normal! g`"]]
			elseif vim.fn.line "$" - vim.fn.line [['"]] > ((vim.fn.line "w$" - vim.fn.line "w0") / 2) - 1 then
				-- if we're not at the bottom of the file, center the cursor on the
				-- screen after we make the jump
				vim.cmd [[normal! g`"zz]]
			else
				-- otherwise, show as much context as we can by jumping to the end of
				-- the file and then to the mark. If we pressed zz here, there would be
				-- blank lines at the bottom of the screen. We intentionally leave the
				-- last line blank by pressing <c-e> so the user has a clue that they
				-- are near the end of the file.
				vim.cmd [[normal! G'"<c-e>]]
			end
		end
	end,
})

vim.api.nvim_create_autocmd("TextYankPost", {
	desc = "Highlight yanked text",
	callback = function(opts)
		vim.highlight.on_yank()
	end,
})

vim.g.tex_flavor = "latex"

vim.g.gruvbox_italic = 1
vim.cmd "colorscheme gruvbox"

-- Mappings
-----------

local mapopts = { noremap = true, silent = true }

vim.fn["camelcasemotion#CreateMotionMappings"] "<LocalLeader>"

vim.keymap.set("n", "yof", function()
	if vim.opt_local.formatoptions:get().a then
		vim.opt_local.formatoptions:remove "a"
		print ":setlocal formatoptions-=a"
	else
		vim.opt_local.formatoptions:append "a"
		print ":setlocal formatoptions+=a"
	end
end, mapopts)

-- Plugins
----------

-- Polyglot

vim.g.polyglot_disabled = {"sensible"}

-- Gitsigns

require("gitsigns").setup {
	keymaps = {
		noremap = true,
		buffer = true,
		silent = true,

		["n ]c"] = { expr = true, "&diff ? ']c' : '<cmd>lua require\"gitsigns\".next_hunk()<CR>'" },
		["n [c"] = { expr = true, "&diff ? '[c' : '<cmd>lua require\"gitsigns\".prev_hunk()<CR>'" },

		["n <leader>hs"] = '<cmd>lua require"gitsigns".stage_hunk()<CR>',
		["n <leader>hu"] = '<cmd>lua require"gitsigns".undo_stage_hunk()<CR>',
		["n <leader>hr"] = '<cmd>lua require"gitsigns".reset_hunk()<CR>',
		["n <leader>hR"] = '<cmd>lua require"gitsigns".reset_buffer()<CR>',
		["n <leader>hp"] = '<cmd>lua require"gitsigns".preview_hunk()<CR>',
		["n <leader>hb"] = '<cmd>lua require"gitsigns".blame_line()<CR>',

		-- Text objects
		["o ih"] = ':<C-U>lua require"gitsigns".select_hunk()<CR>',
		["x ih"] = ':<C-U>lua require"gitsigns".select_hunk()<CR>',
	},
}

-- Treesitter

require("nvim-treesitter.configs").setup {
	parser_install_dir = vim.fn.stdpath("data") .. "/site/parser/",
	highlight = {
		enable = true,
	},
	incremental_selection = {
		enable = true,
		keymaps = {
			init_selection = "gnn",
			node_incremental = "grn",
			scope_incremental = "grc",
			node_decremental = "grm",
		},
	},
	indent = {
		enable = true,
		disable = { "rust" },
	},
	matchup = {
		enable = true,
	},
	refactor = {
		highlight_definitions = { enable = true },
		navigation = { enable = true },
	},
	textobjects = {
		lsp_interop = {
			enable = true,
			border = "none",
			peek_definition_code = {
				["<leader>df"] = "@function.outer",
				["<leader>dF"] = "@class.outer",
			},
		},

		move = {
			enable = true,
			goto_next_start = {
				["]m"] = "@function.outer",
				["]]"] = "@class.outer",
			},
			goto_next_end = {
				["]M"] = "@function.outer",
				["]["] = "@class.outer",
			},
			goto_previous_start = {
				["[m"] = "@function.outer",
				["[["] = "@class.outer",
			},
			goto_previous_end = {
				["[M"] = "@function.outer",
				["[]"] = "@class.outer",
			},
		},

		select = {
			enable = true,
			keymaps = {
				-- You can use the capture groups defined in textobjects.scm
				["af"] = "@function.outer",
				["if"] = "@function.inner",

				["aF"] = "@call.outer",
				["iF"] = "@call.inner",

				["ac"] = "@class.outer",
				["ic"] = "@class.inner",

				["aC"] = "@comment.outer",
				["iC"] = "@comment.inner",

				["ab"] = "@block.outer",
				["ib"] = "@block.inner",

				["aa"] = "@parameter.outer",
				["ia"] = "@parameter.inner",
			},
		},

		swap = {
			enable = true,
			swap_next = {
				["<leader>a"] = "@parameter.inner",
			},
			swap_previous = {
				["<leader>A"] = "@parameter.inner",
			},
		},
	},
}

vim.o.foldmethod = "expr"
vim.o.foldexpr = "nvim_treesitter#foldexpr()"
vim.o.foldlevel = 99

vim.api.nvim_set_hl(0, "TSCurrentScope", {
	bg = vim.g.current_gruvbox_colors.dark0_soft[1],
})

vim.api.nvim_set_hl(0, "TSDefinition", {
	bg = vim.g.current_gruvbox_colors.faded_blue[1],
})

vim.api.nvim_set_hl(0, "TSDefinitionUsage", {
	bg = vim.g.current_gruvbox_colors.faded_aqua[1],
})

-- nvim-cmp

local cmp = require "cmp"

cmp.setup {
	snippet = {
		expand = function(args)
			vim.fn["vsnip#anonymous"](args.body)
		end,
	},
	mapping = cmp.mapping.preset.insert {
		["<CR>"] = cmp.mapping.confirm { select = false },
	},
	sources = cmp.config.sources({
		{ name = "nvim_lsp" },
		{ name = "vsnip" },
		{ name = "latex_symbols" },
		{ name = "calc" },
	}, {
		{ name = "path" },
		{ name = "treesitter" },
	}, {
		{ name = "tmux" },
		{ name = "spell" },
		-- Use \k for iskeyword because of UTF-8
		{ name = "buffer", option = { keyword_pattern = [[\k\+]] } },
	}),
}

-- cmp.setup.cmdline("/", {
-- 	sources = {
-- 		{ name = "buffer", option = { keyword_pattern = [[\k\+]] } },
-- 	},
-- 	mapping = cmp.mapping.preset.cmdline {},
-- })

-- cmp.setup.cmdline(":", {
-- 	sources = cmp.config.sources {
-- 		{ name = "cmdline" },
-- 	},
-- 	mapping = cmp.mapping.preset.cmdline {},
-- })

-- Telescope

require("telescope").setup {
	extensions = {
		file_browser = {
			path = "%:p:h",
			dir_icon = "D",
		},
		["ui-select"] = {
			require("telescope.themes").get_dropdown(),
		},
	},
}

require("telescope").load_extension "file_browser"
require("telescope").load_extension "ui-select"

local telescope_builtin = require "telescope.builtin"
local telescope_extensions = require("telescope").extensions

vim.keymap.set("n", "<leader>fb", telescope_builtin.buffers, mapopts)
vim.keymap.set("n", "<leader>ff", telescope_builtin.find_files, mapopts)
vim.keymap.set("n", "<leader>fg", telescope_builtin.live_grep, mapopts)
vim.keymap.set("n", "<leader>fh", telescope_builtin.help_tags, mapopts)
vim.keymap.set("n", "<leader>fo", telescope_builtin.oldfiles, mapopts)
vim.keymap.set("n", "<leader>fs", telescope_builtin.spell_suggest, mapopts)
vim.keymap.set("n", "<leader>ft", telescope_builtin.treesitter, mapopts)
vim.keymap.set("n", "-", telescope_extensions.file_browser.file_browser, mapopts)

-- Lualine

require("lualine").setup {
	options = {
		component_separators = "",
		icons_enabled = false,
		section_separators = "",
	},
	sections = {
		lualine_c = {
			"filename",
			{
				"lsp_progress",
				display_components = { "lsp_client_name", { "title", "percentage", "message" } },
			},
		},
	},
}

-- VSnip

vim.keymap.set("i", "<Tab>", "vsnip#jumpable(1) ? '<Plug>(vsnip-jump-next)' : '<Tab>'", { silent = true, expr = true })
vim.keymap.set("s", "<Tab>", "vsnip#jumpable(1) ? '<Plug>(vsnip-jump-next)' : '<Tab>'", { silent = true, expr = true })

vim.keymap.set(
	"i",
	"<S-Tab>",
	"vsnip#jumpable(-1) ? '<Plug>(vsnip-jump-prev)' : '<Tab>'",
	{ silent = true, expr = true }
)
vim.keymap.set(
	"s",
	"<S-Tab>",
	"vsnip#jumpable(-1) ? '<Plug>(vsnip-jump-prev)' : '<Tab>'",
	{ silent = true, expr = true }
)

-- OSCyank

-- Text yanked into the "t register gets copied using OSC52 escape sequences
-- (e.g. goes through SSH)
vim.api.nvim_create_autocmd("TextYankPost", {
	desc = "Setup for OSCYank",
	callback = function(opts)
		if vim.v.event.regname == "t" then
			vim.cmd [[OSCYankReg t]]
		end
	end,
})

-- Diffview

require("diffview").setup {
	use_icons = false,
	enhanced_diff_hl = true,
}

-- Notify

vim.cmd [[highlight link NotifyERRORBorder DiagnosticError]]
vim.cmd [[highlight link NotifyERRORIcon DiagnosticError]]
vim.cmd [[highlight link NotifyERRORTitle DiagnosticError]]

vim.cmd [[highlight link NotifyWARNBorder DiagnosticWarn]]
vim.cmd [[highlight link NotifyWARNIcon DiagnosticWarn]]
vim.cmd [[highlight link NotifyWARNTitle DiagnosticWarn]]

vim.cmd [[highlight link NotifyINFOBorder DiagnosticInfo]]
vim.cmd [[highlight link NotifyINFOIcon DiagnosticInfo]]
vim.cmd [[highlight link NotifyINFOTitle DiagnosticInfo]]

vim.cmd [[highlight link NotifyDEBUGBorder DiagnosticHint]]
vim.cmd [[highlight link NotifyDEBUGIcon DiagnosticHint]]
vim.cmd [[highlight link NotifyDEBUGTitle DiagnosticHint]]

vim.cmd [[highlight link NotifyDEBUGBorder GruvboxPurple]]
vim.cmd [[highlight link NotifyDEBUGIcon GruvboxPurple]]
vim.cmd [[highlight link NotifyDEBUGTitle GruvboxPurple]]

vim.notify = require "notify"

-- Comment

require("Comment").setup {}

-- Indent Blankline

vim.api.nvim_set_hl(0, "IndentBlanklineContextChar", {
	fg = vim.g.current_gruvbox_colors.aqua[1],
})

require("indent_blankline").setup {
	show_current_context = true,
	show_current_context_start = true,
}

-- Local config

function isModuleAvailable(name)
	if package.loaded[name] then
		return true
	else
		for _, searcher in ipairs(package.searchers or package.loaders) do
			local loader = searcher(name)
			if type(loader) == "function" then
				package.preload[name] = loader
				return true
			end
		end
		return false
	end
end

vim.opt.runtimepath:append "~/.config/nvim"

if isModuleAvailable "local_config" then
	require "local_config"
end