Skip to content

Instantly share code, notes, and snippets.

@storopoli

storopoli/.gitignore

Last active September 19, 2024 08:42
Show Gist options
  • Save storopoli/ff55e50f7292c4b1806f6c3469781722 to your computer and use it in GitHub Desktop.
Save storopoli/ff55e50f7292c4b1806f6c3469781722 to your computer and use it in GitHub Desktop.
Download ZIP
Minimal Neovim config
Raw
.gitignore
lazy-lock.json
Raw
init.lua
-------------------------------------------------------------------------------
-- DEPENDENCIES
-- neovim nodejs ripgrep fd fzf
-- LSPs: marksman rust-analyzer clangd taplo yaml-language-server
-- vscode-html-languageserver vscode-css-languageserver vscode-json-languageserver
-- pyright ruff lua-language-server typescript-language-server
-- bash-language-server tinymist
-- 33 Plugins
-- ~37ms startup
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
-- Options
-------------------------------------------------------------------------------
-- Set highlight on search
vim.o.hlsearch = false
vim.o.incsearch = true
vim.o.nu = true
vim.o.relativenumber = true
vim.o.tabstop = 4
vim.o.softtabstop = 4
vim.o.shiftwidth = 4
vim.o.expandtab = true
vim.o.hidden = true
vim.o.laststatus = 3
vim.o.winbar = "%=%m %f"
vim.o.mouse = "a"
-- Scrolling
vim.o.scrolloff = 8
vim.o.sidescrolloff = 8
-- Time in milliseconds to wait for a mapped sequence to complete
vim.o.timeoutlen = 500
vim.o.ttyfast = true
vim.o.wrap = false
vim.o.breakindent = true
-- Better undo history
vim.o.swapfile = false
vim.o.backup = false
vim.o.undodir = vim.fn.stdpath("data") .. "undo"
vim.o.undofile = true
vim.o.ignorecase = true
vim.o.smartcase = true
vim.o.updatetime = 500
vim.wo.signcolumn = "yes"
vim.o.colorcolumn = "80"
vim.o.splitbelow = true
vim.o.splitright = true
vim.o.list = true
vim.opt.listchars = { tab = "» ", trail = "·", nbsp = "␣" }
-- vim.o.winblend = 5
-- If enabled, Neovim will search for the following files in the current directory:
-- - .nvim.lua
-- - .nvimrc
-- - .exrc
-- Add files with `:trust`, remove with `:trust ++remove`
vim.o.exrc = true
-- NOTE: Must happen before plugins are required (otherwise wrong leader will be used)
vim.g.mapleader = " "
vim.g.maplocalleader = " "
-- Keymaps for better default experience
vim.keymap.set({ "n", "v" }, "<Space>", "<Nop>", { silent = true })
vim.keymap.set("n", "Q", "<nop>")
-- Better movement
vim.keymap.set("n", "J", "mzJ`z")
vim.keymap.set("n", "<C-d>", "<C-d>zz")
vim.keymap.set("n", "<C-u>", "<C-u>zz")
vim.keymap.set("n", "n", "nzzzv")
vim.keymap.set("n", "N", "Nzzzv")
-- Better indenting
vim.keymap.set("v", "<", "<gv")
vim.keymap.set("v", ">", ">gv")
-- Clear search with <ESC>
vim.keymap.set({ "i", "n" }, "<ESC>", "<CMD>noh<CR><esc>")
-- Clear search, diff update and redraw
-- taken from runtime/lua/_editor.lua
vim.keymap.set("n", "<leader>R", "<CMD>nohlsearch<Bar>diffupdate<Bar>normal! <C-L><CR>")
-- J/K to move up/down visual lines
vim.keymap.set("v", "J", ":m '>+1<CR>gv=gv")
vim.keymap.set("v", "K", ":m '<-2<CR>gv=gv")
-- Remap for dealing with word wrap
vim.keymap.set("n", "k", "v:count == 0 ? 'gk' : 'k'", { expr = true, silent = true })
vim.keymap.set("n", "j", "v:count == 0 ? 'gj' : 'j'", { expr = true, silent = true })
-- Move lines
vim.keymap.set("n", "<A-j>", "<CMD>m .+1<CR>==")
vim.keymap.set("n", "<A-k>", "<CMD>m .-2<CR>==")
vim.keymap.set("i", "<A-j>", "<ESC><CMD>m .+1<CR>==gi")
vim.keymap.set("i", "<A-k>", "<ESC><CMD>m .-2<CR>==gi")
vim.keymap.set("v", "<A-j>", ":m '>+1<CR>gv=gv")
vim.keymap.set("v", "<A-k>", ":m '<-2<CR>gv=gv")
-- Easy save
vim.keymap.set("n", "<leader>w", "<CMD>w<CR>", { silent = true })
-- Easy Quit
vim.keymap.set("n", "<leader>q", "<CMD>q<CR>", { silent = true })
vim.keymap.set("n", "<leader>Q", "<CMD>qa!<CR>", { silent = true })
-- Global Yank/Paste
vim.keymap.set({ "n", "v" }, "<leader>y", [["+y]], { noremap = true, silent = true })
vim.keymap.set("n", "<leader>Y", [["+Y]], { noremap = true, silent = true })
vim.keymap.set("x", "<leader>p", [["_dP]], { noremap = true, silent = true })
vim.keymap.set({ "n", "v" }, "<leader>d", [["_d]], { noremap = true, silent = true })
-- Location list
vim.keymap.set("n", "]q", "<cmd>cnext<CR>zz", { noremap = true, silent = true })
vim.keymap.set("n", "[q", "<cmd>cprev<CR>zz", { noremap = true, silent = true })
-- Highlight on Yank
local highlight_group = vim.api.nvim_create_augroup("YankHighlight", { clear = true })
vim.api.nvim_create_autocmd("TextYankPost", {
callback = function()
vim.highlight.on_yank()
end,
group = highlight_group,
pattern = "*",
})
-- Restore Cursors
local restore_group = vim.api.nvim_create_augroup("RestoreGroup", { clear = true })
vim.api.nvim_create_autocmd("BufRead", {
command = [[call setpos(".", getpos("'\""))]],
group = restore_group,
pattern = "*",
})
-- lazy.nvim
local lazypath = vim.fn.stdpath("data") .. "/lazy/lazy.nvim"
if not (vim.uv or vim.loop).fs_stat(lazypath) then
local lazyrepo = "https://github.com/folke/lazy.nvim.git"
local out = vim.fn.system({ "git", "clone", "--filter=blob:none", "--branch=stable", lazyrepo, lazypath })
if vim.v.shell_error ~= 0 then
vim.api.nvim_echo({
{ "Failed to clone lazy.nvim:\n", "ErrorMsg" },
{ out, "WarningMsg" },
{ "\nPress any key to exit..." },
}, true, {})
vim.fn.getchar()
os.exit(1)
end
end
vim.opt.rtp:prepend(lazypath)
-- Plugins
require("lazy").setup({
{
"ellisonleao/gruvbox.nvim",
lazy = false, -- make sure we load this during startup
priority = 1000, -- make sure to load this before all
config = function()
require("gruvbox").setup({
contrast_dark = "hard",
transparent_mode = true,
})
vim.o.termguicolors = true
vim.o.background = "dark"
vim.cmd.colorscheme("gruvbox")
end,
keys = {
{ "<leader>l", "<CMD>Lazy<CR>" },
},
},
{
"nvim-telescope/telescope.nvim",
branch = "0.1.x",
dependencies = {
"nvim-lua/plenary.nvim",
{
"nvim-telescope/telescope-fzf-native.nvim",
build = "make",
cond = function()
return vim.fn.executable("make") == 1
end,
},
"nvim-telescope/telescope-ui-select.nvim",
"nvim-telescope/telescope-file-browser.nvim",
},
keys = {
{ "<leader>.", "<CMD>Telescope oldfiles<CR>" },
{ "<leader><space>", "<CMD>Telescope buffers<CR>" },
{
"<leader>/",
function()
require("telescope.builtin").current_buffer_fuzzy_find(require("telescope.themes").get_dropdown({
winblend = 10,
previewer = false,
}))
end,
},
{
"<leader>s/",
function()
require("telescope.builtin").live_grep({
grep_open_files = true,
prompt_title = "Live Grep in Open Files",
})
end,
},
{ "<leader>sr", "<CMD>Telescope resume<CR>" },
{ "<leader>sf", "<CMD>Telescope git_files<CR>" },
{ "<leader>sF", "<CMD>Telescope find_files<CR>" },
{ "<leader>sB", "<CMD>Telescope file_browser<CR>" },
{ "<leader>sh", "<CMD>Telescope help_tags<CR>" },
{ "<leader>sw", "<CMD>Telescope grep_string<CR>" },
{ "<leader>sg", "<CMD>Telescope live_grep<CR>" },
{
"<leader>sd",
function()
require("telescope.builtin").diagnostics({
bufnr = 0,
})
end,
},
{ "<leader>sD", "<CMD>Telescope diagnostics<CR>" },
{ "<leader>sm", "<CMD>Telescope marks<CR>" },
{ "<leader>sc", "<CMD>Telescope git_bcommits<CR>" },
{ "<leader>sC", "<CMD>Telescope git_commits<CR>" },
{ "<leader>sb", "<CMD>Telescope git_branches<CR>" },
{ "<leader>st", "<CMD>Telescope git_status<CR>" },
{ "<leader>sT", "<CMD>Telescope git_stash<CR>" },
},
opts = {},
config = function()
require("telescope").setup({
defaults = {
mappings = {
i = {
["<C-n>"] = "move_selection_next",
["<C-p>"] = "move_selection_previous",
["<C-f>"] = function(...)
return require("telescope.actions").preview_scrolling_down(...)
end,
["<C-b>"] = function(...)
return require("telescope.actions").preview_scrolling_up(...)
end,
["<c-t>"] = require("trouble.sources.telescope").open,
},
n = {
["q"] = function(...)
return require("telescope.actions").close(...)
end,
["<c-t>"] = require("trouble.sources.telescope").open,
},
},
},
extensions = {
fzf = {
fuzzy = true, -- false will only do exact matching
override_generic_sorter = true, -- override the generic sorter
override_file_sorter = true, -- override the file sorter
case_mode = "smart_case", -- or "ignore_case" or "respect_case"
},
["ui-select"] = {
require("telescope.themes").get_dropdown(),
},
file_browser = {
hijack_netrw = true,
},
},
})
pcall(require("telescope").load_extension, "fzf")
pcall(require("telescope").load_extension, "ui-select")
pcall(require("telescope").load_extension, "file_browser")
end,
},
{
-- LSP Configuration & Plugins
"neovim/nvim-lspconfig",
version = false, -- last release is way too old
event = { "BufReadPost", "BufWritePost", "BufNewFile" },
dependencies = {
{
"j-hui/fidget.nvim", -- Status for LSP stuff
event = "LspAttach",
opts = {
notification = {
window = {
winblend = 0,
}
}
},
},
"hrsh7th/nvim-cmp", -- Autocompletion plugin
"hrsh7th/cmp-nvim-lsp", -- LSP source for nvim-cmp
"hrsh7th/cmp-cmdline", -- nvim-cmp source for cmdline
"hrsh7th/cmp-buffer", -- nvim-cmp source for buffer words
"hrsh7th/cmp-path", -- nvim-cmp source for filesystem paths
"petertriho/cmp-git", -- nvim-cmp source for git
-- Snippets
{
"L3MON4D3/LuaSnip",
build = (function()
-- Build Step is needed for regex support in snippets.
if vim.fn.has("win32") == 1 or vim.fn.executable("make") == 0 then
return
end
return "make install_jsregexp"
end)(),
dependencies = {
{
"rafamadriz/friendly-snippets",
config = function()
require("luasnip.loaders.from_vscode").lazy_load()
end,
},
},
},
"saadparwaiz1/cmp_luasnip",
-- Copilot
{
"zbirenbaum/copilot.lua",
cmd = "Copilot",
build = ":Copilot auth",
opts = {
suggestion = { enabled = false },
panel = { enabled = false },
filetypes = {
markdown = true,
help = true,
yaml = true,
},
},
keys = {
{
"<leader>cp",
function()
if require("copilot.client").is_disabled() then
vim.cmd("Copilot enable")
else
vim.cmd("Copilot disable")
end
end,
},
},
},
{
"zbirenbaum/copilot-cmp",
dependencies = "copilot.lua",
config = true,
},
},
config = function()
local lsp = require("lspconfig")
-- Global mappings.
-- See `:help vim.diagnostic.*` for documentation on any of the below functions
vim.keymap.set("n", "[d", vim.diagnostic.goto_prev)
vim.keymap.set("n", "]d", vim.diagnostic.goto_next)
vim.keymap.set("n", "<leader>e", vim.diagnostic.open_float)
vim.keymap.set("n", "<leader>k", vim.diagnostic.setloclist)
-- Use LspAttach autocommand to only map the following keys
-- after the language server attaches to the current buffer
vim.api.nvim_create_autocmd("LspAttach", {
group = vim.api.nvim_create_augroup("UserLspConfig", {}),
callback = function(ev)
-- Buffer local mappings.
-- See `:help vim.lsp.*` for documentation on any of the below functions
-- Code Actions
vim.keymap.set("n", "<leader>cr", vim.lsp.buf.rename)
vim.keymap.set("n", "<leader>ca", vim.lsp.buf.code_action)
-- Definitions
vim.keymap.set("n", "gd", vim.lsp.buf.definition)
vim.keymap.set("n", "gi", vim.lsp.buf.implementation)
vim.keymap.set("n", "gr", require("telescope.builtin").lsp_references)
vim.keymap.set("n", "<leader>ss", require("telescope.builtin").lsp_document_symbols)
vim.keymap.set("n", "<leader>sS", require("telescope.builtin").lsp_dynamic_workspace_symbols)
-- See `:help K` for why this keymap
vim.keymap.set("n", "K", vim.lsp.buf.hover)
-- vim.keymap.set("n", "<C-k>", vim.lsp.buf.signature_help)
-- Lesser used LSP functionality
vim.keymap.set("n", "gD", vim.lsp.buf.declaration)
vim.keymap.set("n", "<leader>D", vim.lsp.buf.type_definition)
-- Format
vim.keymap.set({ "n", "v" }, "<leader>f", function()
vim.lsp.buf.format({ async = true })
end)
-- The following autocommand is used to enable inlay hints in your
-- code, if the language server you are using supports them
local client = vim.lsp.get_client_by_id(ev.data.client_id)
if client and client.server_capabilities.inlayHintProvider and vim.lsp.inlay_hint then
-- Enable it by default
vim.lsp.inlay_hint.enable(true)
-- Set a keymap to toggle it
vim.keymap.set("n", "<leader>th", function()
vim.lsp.inlay_hint.enable(not vim.lsp.inlay_hint.is_enabled())
end)
end
end,
})
-- nvim-cmp supports additional completion capabilities, so broadcast that to servers
-- Add additional capabilities supported by nvim-cmp
local capabilities = require("cmp_nvim_lsp").default_capabilities()
capabilities = vim.tbl_deep_extend("force", capabilities, require("cmp_nvim_lsp").default_capabilities())
-- nvim-cmp setup
local cmp = require("cmp")
local luasnip = require("luasnip")
luasnip.config.setup({})
cmp.setup({
completion = {
completeopt = "menu,menuone,noinsert",
},
preselect = cmp.PreselectMode.Item,
snippet = {
expand = function(args)
luasnip.lsp_expand(args.body)
end,
},
mapping = cmp.mapping.preset.insert({
["<C-Space>"] = cmp.mapping.complete(),
["<C-e>"] = cmp.mapping.abort(),
["<C-n>"] = cmp.mapping.select_next_item(),
["<C-p>"] = cmp.mapping.select_prev_item(),
["<C-b>"] = cmp.mapping.scroll_docs(-4),
["<C-f>"] = cmp.mapping.scroll_docs(4),
["<C-y>"] = cmp.mapping.confirm({ select = true }),
["<C-l>"] = cmp.mapping(function()
if luasnip.expand_or_locally_jumpable() then
luasnip.expand_or_jump()
end
end, { "i", "s" }),
["<C-h>"] = cmp.mapping(function()
if luasnip.locally_jumpable(-1) then
luasnip.jump(-1)
end
end, { "i", "s" }),
}),
sources = {
{ name = "copilot", priority = 100 },
{ name = "snippets" },
{ name = "nvim_lsp" },
{ name = "path" },
},
})
-- Set configuration for specific filetype.
cmp.setup.filetype("gitcommit", {
sources = cmp.config.sources({
{ name = "git" },
{ name = "path" },
}, {
{ name = "buffer", keyword_length = 3 },
}),
})
-- Use buffer source for `/` and `?`
cmp.setup.cmdline({ "/", "?" }, {
mapping = cmp.mapping.preset.cmdline(),
sources = {
{ name = "buffer" },
},
})
-- Use path and cmdline source for `:` with TAB/Shift-TAB as autocomplete
cmp.setup.cmdline(":", {
mapping = cmp.mapping.preset.cmdline({
["<S-Tab>"] = cmp.mapping.select_prev_item(),
["<Tab>"] = cmp.mapping.select_next_item(),
}),
sources = cmp.config.sources({
{ name = "path" },
}, {
{ name = "cmdline" },
}),
})
require("cmp_git").setup()
-- If you want insert `(` after select function or method item
local cmp_autopairs = require("nvim-autopairs.completion.cmp")
cmp.event:on("confirm_done", cmp_autopairs.on_confirm_done())
-- LSPs
lsp.marksman.setup({ capabilities = capabilities }) -- requires marksman
lsp.tinymist.setup({ capabilities = capabilities }) -- requires tinymist-bin
lsp.ts_ls.setup({ capabilities = capabilities }) -- requires typescript-language-server
lsp.bashls.setup({ capabilities = capabilities }) -- requires bash-language-server
lsp.html.setup({ capabilities = capabilities }) -- requires vscode-html-languageserver
lsp.cssls.setup({ capabilities = capabilities }) -- requires vscode-css-languageserver
lsp.jsonls.setup({ capabilities = capabilities }) -- requires vscode-json-languageserver
lsp.rust_analyzer.setup({ -- requires rust-analyzer
capabilities = capabilities,
settings = {
["rust-analyzer"] = {
cargo = {
allFeatures = true,
},
},
},
})
lsp.clangd.setup({ capabilities = capabilities }) -- requires clangd
lsp.taplo.setup({ capabilities = capabilities }) -- requires taplo
lsp.yamlls.setup({ -- requires yaml-language-server
capabilities = capabilities,
settings = {
yamlls = {
schemas = {
["https=//raw.githubusercontent.com/compose-spec/compose-spec/master/schema/compose-spec.json"] =
"docker-compose.yaml",
["https=//json.schemastore.org/github-workflow.json"] = ".github/workflows/*.yaml",
["https=//json.schemastore.org/github-action.json"] = ".github/actions/*/action.yaml",
},
},
},
})
lsp.pyright.setup({ -- requires pyright
capabilities = capabilities,
settings = {
pyright = {
-- Using Ruff's import organizer
disableOrganizeImports = true,
},
python = {
analysis = {
-- Ignore all files for analysis to exclusively use Ruff for linting
ignore = { "*" },
},
},
},
})
lsp.ruff.setup({ -- requires ruff
capabilities = capabilities,
on_attach = function(client, _)
-- Disable hover in favor of Pyright
client.server_capabilities.hoverProvider = false
end,
})
lsp.lua_ls.setup({ -- requires lua-language-server
capabilities = capabilities,
settings = {
Lua = {
telemetry = { enable = false },
hint = { enable = true },
workspace = {
checkThirdParty = false,
-- Tells lua_ls where to find all the Lua files that you have loaded
-- for your neovim configuration.
library = {
vim.env.VIMRUNTIME,
"${3rd}/luv/library",
},
maxPreload = 10000,
preloadFileSize = 10000,
ignoreDir = {
".git",
".direnv",
"target",
".venv",
"node_modules",
},
},
completion = {
callSnippet = "Replace",
},
diagnostics = {
globals = { "vim" },
disable = { "missing-fields" },
},
},
},
})
end,
},
{
"nvim-treesitter/nvim-treesitter",
dependencies = { "nvim-treesitter/nvim-treesitter-textobjects" },
event = { "BufReadPost", "BufWritePost", "BufNewFile" },
build = ":TSUpdate",
main = "nvim-treesitter.configs", -- Sets main module to use for opts
opts = {
ensure_installed = {
"bash",
"c",
"css",
"cpp",
"html",
"javascript",
"jsdoc",
"json",
"lua",
"luadoc",
"luap",
"markdown",
"markdown_inline",
"python",
"query",
"regex",
"rust",
"tsx",
"typescript",
"toml",
"typst",
"vim",
"vimdoc",
"yaml",
"zig",
},
auto_install = true,
highlight = { enable = true },
indent = { enable = true, disable = { "python" } },
incremental_selection = {
enable = true,
keymaps = {
init_selection = "<C-space>",
node_incremental = "<C-space>",
scope_incremental = "<C-S>",
node_decremental = "<C-bs>",
},
},
textobjects = {
select = {
enable = true,
lookahead = true, -- Automatically jump forward to textobj, similar to targets.vim
keymaps = {
-- You can use the capture groups defined in textobjects.scm
["aa"] = "@parameter.outer",
["ia"] = "@parameter.inner",
["af"] = "@function.outer",
["if"] = "@function.inner",
["ac"] = "@class.outer",
["ic"] = "@class.inner",
},
},
move = {
enable = true,
set_jumps = true, -- whether to set jumps in the jumplist
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",
},
},
swap = {
enable = true,
swap_next = { ["<leader>a"] = "@parameter.inner" },
swap_previous = { ["<leader>A"] = "@parameter.inner" },
},
},
},
},
{
"nvim-treesitter/nvim-treesitter-context",
dependencies = "nvim-treesitter/nvim-treesitter",
event = { "BufReadPost", "BufWritePost", "BufNewFile" },
config = true,
keys = {
{
"[c",
function()
require("treesitter-context").go_to_context()
end,
desc = "Go to [C]context",
},
},
},
{
"folke/trouble.nvim", -- So much better than quickfix
cmd = { "Trouble" },
opts = {
modes = {
lsp = {
win = { position = "right" },
},
},
},
keys = {
{ "<leader>tt", "<CMD>Trouble diagnostics toggle<CR>" },
{
"[t",
function()
if require("trouble").is_open() then
require("trouble").prev({ skip_groups = true, jump = true })
else
local ok, err = pcall(vim.cmd.cprev)
if not ok then
vim.notify(err, vim.log.levels.ERROR)
end
end
end,
},
{
"]t",
function()
if require("trouble").is_open() then
require("trouble").next({ skip_groups = true, jump = true })
else
local ok, err = pcall(vim.cmd.cnext)
if not ok then
vim.notify(err, vim.log.levels.ERROR)
end
end
end,
},
},
},
-- Git related plugins
{
"lewis6991/gitsigns.nvim",
event = { "BufReadPre", "BufNewFile" },
config = function()
require("gitsigns").setup({
signs = {
add = { text = "+" },
change = { text = "~" },
delete = { text = "_" },
topdelete = { text = "‾" },
changedelete = { text = "~" },
},
on_attach = function(bufnr)
local gs = package.loaded.gitsigns
-- Navigation
vim.keymap.set("n", "]h", function()
if vim.wo.diff then
return "]c"
end
vim.schedule(function()
gs.next_hunk()
end)
return "<Ignore>"
end, { expr = true, buffer = bufnr })
vim.keymap.set("n", "[h", function()
if vim.wo.diff then
return "[c"
end
vim.schedule(function()
gs.prev_hunk()
end)
return "<Ignore>"
end, { expr = true, buffer = bufnr })
-- Actions
vim.keymap.set({ "n", "v" }, "<leader>hs", "<CMD>Gitsigns stage_hunk<CR>", { buffer = bufnr })
vim.keymap.set({ "n", "v" }, "<leader>hr", "<CMD>Gitsigns reset_hunk<CR>", { buffer = bufnr })
vim.keymap.set("n", "<leader>hS", gs.stage_buffer, { buffer = bufnr })
vim.keymap.set("n", "<leader>hu", gs.undo_stage_hunk, { buffer = bufnr })
vim.keymap.set("n", "<leader>hR", gs.reset_buffer, { buffer = bufnr })
vim.keymap.set("n", "<leader>hp", gs.preview_hunk, { buffer = bufnr })
vim.keymap.set("n", "<leader>hb", function()
gs.blame_line({ full = true })
end, { buffer = bufnr })
vim.keymap.set("n", "<leader>hB", gs.toggle_current_line_blame, { buffer = bufnr })
vim.keymap.set("n", "<leader>hd", gs.diffthis, { buffer = bufnr })
vim.keymap.set("n", "<leader>hD", function()
gs.diffthis("~")
end, { buffer = bufnr })
vim.keymap.set("n", "<leader>ht", gs.toggle_deleted, { buffer = bufnr })
-- Text object
vim.keymap.set({ "o", "x" }, "ih", "<CMD><C-U>Gitsigns select_hunk<CR>", { buffer = bufnr })
end,
})
end,
},
{
"tpope/vim-fugitive",
event = "VeryLazy",
keys = {
{ "<leader>gi", "<CMD>Git<CR>" },
-- Always rebase
{ "<leader>gp", "<CMD>Git pull --rebase <CR>" },
-- It allows me to easily set the branch I am pushing and any tracking
{ "<leader>gP", "<CMD>Git push -u origin <CR>" },
{ "<leader>gb", "<CMD>Git blame<CR>" },
-- Best diff tool
{ "<leader>gd", "<CMD>Gdiffsplit!<CR>" },
{ "gh", "<CMD>diffget //2<CR>" }, -- left
{ "gl", "<CMD>diffget //3<CR>" }, -- right
},
},
-- Markdown
{
"OXY2DEV/markview.nvim",
event = "VeryLazy",
ft = "markdown",
dependencies = {
"nvim-treesitter/nvim-treesitter",
"nvim-tree/nvim-web-devicons",
},
config = function()
require("markview").setup({
modes = { "n", "no", "c" },
hybrid_modes = { "n" },
callbacks = {
on_enable = function(_, win)
vim.wo[win].conceallevel = 2
vim.wo[win].concealcursor = "c"
end,
},
})
end,
},
-- Miscellaneous
"tpope/vim-sleuth", -- Detect tabstop and shiftwidth automatically
{ "numToStr/Comment.nvim", config = true, event = "VeryLazy" }, -- 'gc' to comment visual regions/lines
{ "windwp/nvim-autopairs", config = true }, -- Autopair stuff like ({["'
{
"kylechui/nvim-surround", -- Surround selections
dependencies = { "nvim-treesitter/nvim-treesitter" },
version = "*",
config = true,
},
{
"mbbill/undotree",
keys = {
{ "<leader>u", "<CMD>UndotreeToggle<CR>" },
},
},
})
-- The line beneath this is called `modeline`. See `:help modeline`
-- vim: ts=2 sts=2 sw=2 et
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment