1529 lines
46 KiB
Lua
1529 lines
46 KiB
Lua
-- Mbess lefuturiste nvim config (2024-01-17) (sorry, not very well organized)
|
|
|
|
-- TODO: add lot of keybindings
|
|
--
|
|
-- Add keybinding to close a tab (all views in a tab neotree + buffer)
|
|
-- Investigate why it's taking so long to switch tabs in vim
|
|
-- Individually sort files by updated_at date inside each directory in nvim-neo-tree/neo-tree.nvim (recent files in each dir)
|
|
-- Debugger feature
|
|
-- Twig treesitter support
|
|
-- Change name of variable with LSP -> <leader>rn
|
|
-- PHP helpers?
|
|
-- Python helpers?
|
|
-- Tabs features? Or recent tabs? Quickly switch between tabs
|
|
-- Add shortcut to open symbol definition in new tab
|
|
|
|
local ensure_packer = function()
|
|
local fn = vim.fn
|
|
local install_path = fn.stdpath('data')..'/site/pack/packer/start/packer.nvim'
|
|
if fn.empty(fn.glob(install_path)) > 0 then
|
|
fn.system({'git', 'clone', '--depth', '1', 'https://github.com/wbthomason/packer.nvim', install_path})
|
|
vim.cmd [[packadd packer.nvim]]
|
|
return true
|
|
end
|
|
return false
|
|
end
|
|
|
|
function str2bool(str_inp)
|
|
return str_inp ~= nil and (str_inp == "1" or str_inp:lower() == "true" or str_inp:lower() == "yes")
|
|
end
|
|
|
|
local packer_bootstrap = ensure_packer()
|
|
|
|
-- disable some built-in
|
|
local disabled_built_ins = {
|
|
"netrw",
|
|
"netrwPlugin",
|
|
"netrwSettings",
|
|
"netrwFileHandlers",
|
|
-- "gzip",
|
|
-- "zip",
|
|
-- "zipPlugin",
|
|
-- "tar",
|
|
-- "tarPlugin",
|
|
"getscript",
|
|
"getscriptPlugin",
|
|
"vimball",
|
|
"vimballPlugin",
|
|
"2html_plugin",
|
|
"logipat",
|
|
"rrhelper",
|
|
-- "spellfile_plugin",
|
|
"matchit"
|
|
}
|
|
|
|
local user_log = function(message)
|
|
local log_file_path = '/home/mbess/.logs/neovim.log'
|
|
local log_file = io.open(log_file_path, "a")
|
|
io.output(log_file)
|
|
io.write(message.."\n")
|
|
io.close(log_file)
|
|
end
|
|
|
|
for _, plugin in pairs(disabled_built_ins) do
|
|
vim.g["loaded_" .. plugin] = 1
|
|
end
|
|
|
|
local opt = vim.opt
|
|
|
|
vim.cmd("set background=dark")
|
|
|
|
opt.guifont = "Fira Code"
|
|
opt.background = "dark"
|
|
opt.number = true
|
|
opt.relativenumber = true
|
|
opt.hidden = true
|
|
|
|
-- Hide default menu mode status (I have lualine so this is duplicated)
|
|
opt.showmode = false
|
|
|
|
-- Tabs options
|
|
opt.autoindent = true
|
|
opt.cindent = true
|
|
opt.wrap = true
|
|
|
|
opt.expandtab = true
|
|
opt.smartindent = true
|
|
|
|
opt.tabstop = 4
|
|
opt.softtabstop = 4
|
|
opt.shiftwidth = 4
|
|
|
|
opt.breakindent = true
|
|
opt.showbreak = string.rep(" ", 3) -- Make it so that long lines wrap smartly
|
|
opt.linebreak = true
|
|
|
|
--
|
|
|
|
opt.wildmenu = true
|
|
opt.updatetime = 50
|
|
opt.termguicolors = true
|
|
|
|
opt.signcolumn = 'yes'
|
|
opt.belloff = 'all'
|
|
|
|
-- Keep padding
|
|
opt.scrolloff = 10
|
|
|
|
-- Always ignore case when searching, unless there is a capital letter in the query
|
|
opt.ignorecase = true
|
|
opt.smartcase = true
|
|
|
|
opt.splitright = true
|
|
opt.splitbelow = true
|
|
|
|
-- Cool floating window popup menu for completion on command line
|
|
opt.pumblend = 17
|
|
opt.wildmode = "longest:full"
|
|
opt.wildoptions = "pum"
|
|
|
|
-- Ignore compiled files
|
|
opt.wildignore = "__pycache__"
|
|
opt.wildignore:append { "*.o", "*~", "*.pyc", "*pycache*" }
|
|
opt.wildignore:append "Cargo.lock"
|
|
|
|
opt.colorcolumn = "100"
|
|
|
|
-- Highlight on yank (copy). It will do a nice highlight blink of the thing you just copied.
|
|
-- use [[ ]] to do multi-line strings
|
|
vim.api.nvim_exec(
|
|
[[
|
|
augroup YankHighlight
|
|
autocmd!
|
|
autocmd TextYankPost * silent! lua vim.highlight.on_yank()
|
|
augroup end
|
|
]],
|
|
false
|
|
)
|
|
|
|
vim.g.mapleader = " "
|
|
|
|
-- Plugin list
|
|
-- Packer
|
|
require("packer").startup(function()
|
|
use("wbthomason/packer.nvim")
|
|
|
|
use("lewis6991/impatient.nvim")
|
|
|
|
use("nvim-lua/plenary.nvim")
|
|
use("nvim-lua/popup.nvim")
|
|
use {
|
|
"nvim-telescope/telescope.nvim",
|
|
config = function()
|
|
local actions = require('telescope.actions')
|
|
|
|
require('telescope').setup {
|
|
defaults = {
|
|
mappings = {
|
|
i = {
|
|
['<C-Down>'] = actions.cycle_history_next,
|
|
['<C-Up>'] = actions.cycle_history_prev
|
|
}
|
|
}
|
|
}
|
|
}
|
|
end
|
|
}
|
|
use {
|
|
"nvim-telescope/telescope-live-grep-args.nvim"
|
|
}
|
|
|
|
use {
|
|
-- neotree
|
|
"nvim-neo-tree/neo-tree.nvim",
|
|
branch = "v2.x",
|
|
requires = {
|
|
"nvim-lua/plenary.nvim",
|
|
"kyazdani42/nvim-web-devicons", -- not strictly required, but recommended
|
|
"MunifTanjim/nui.nvim",
|
|
},
|
|
config = function ()
|
|
require('neo-tree').setup({
|
|
enable_refresh_on_write = true,
|
|
|
|
filesystem = {
|
|
use_libuv_file_watcher = true,
|
|
window = {
|
|
mappings = {
|
|
["W"] = function (state)
|
|
local Node = state.tree:get_node()
|
|
print(node.name)
|
|
end
|
|
}
|
|
}
|
|
}
|
|
})
|
|
end
|
|
}
|
|
-- TODO: figure how to show an outline for only the first level element, limit the depth
|
|
-- have a choice of precision between the top levels components only and the deeper components
|
|
-- the basic choice is to hop between functions or methods in a file
|
|
use {
|
|
"simrat39/symbols-outline.nvim",
|
|
config = function ()
|
|
require("symbols-outline").setup({
|
|
autofold_depth = 1 -- not working?
|
|
})
|
|
end
|
|
-- commons shortcuts by default o, K, Ctrl+Space, r, a, h, l, W, E, R, ?
|
|
}
|
|
|
|
-- Language Server Protocol stuff
|
|
use("neovim/nvim-lspconfig")
|
|
use("hrsh7th/nvim-cmp")
|
|
use("hrsh7th/cmp-nvim-lsp")
|
|
use("hrsh7th/cmp-buffer")
|
|
use("hrsh7th/cmp-path")
|
|
use("ray-x/cmp-treesitter")
|
|
use("saadparwaiz1/cmp_luasnip")
|
|
-- use("WhoIsSethDaniel/toggle-lsp-diagnostics.nvim")
|
|
|
|
use {
|
|
"L3MON4D3/LuaSnip",
|
|
tag = "v1.2.1",
|
|
config = function ()
|
|
on_luasnip_load()
|
|
end
|
|
}
|
|
use("rafamadriz/friendly-snippets")
|
|
|
|
--use("williamboman/mason.nvim")
|
|
|
|
|
|
-- Tree sitter stuff
|
|
use {
|
|
"nvim-treesitter/nvim-treesitter",
|
|
-- commit = "26105050aae3a15dd85feaeb0439e253e31d5ceb", -- end of september
|
|
run = ":TSUpdate"
|
|
}
|
|
use("nvim-treesitter/playground")
|
|
-- add text objects like class, function
|
|
use {
|
|
"nvim-treesitter/nvim-treesitter-textobjects"
|
|
}
|
|
use {
|
|
"nvim-treesitter/nvim-treesitter-context",
|
|
config = function ()
|
|
require("treesitter-context").setup{
|
|
enable = true
|
|
}
|
|
end
|
|
}
|
|
use {
|
|
"JoosepAlviste/nvim-ts-context-commentstring",
|
|
config = function ()
|
|
require("nvim-treesitter.configs").setup{
|
|
context_commentstring = {enable = true}
|
|
}
|
|
end
|
|
}
|
|
-- use treesitter to auto add HTML tags
|
|
-- use {
|
|
-- 'windwp/nvim-ts-autotag',
|
|
-- config = function ()
|
|
-- require('nvim-ts-autotag').setup({
|
|
-- autotag = {
|
|
-- enable = false,
|
|
-- }
|
|
-- })
|
|
-- end
|
|
-- }
|
|
-- use treesitter to swap arguments
|
|
use {
|
|
'mizlan/iswap.nvim',
|
|
-- '~/workspace/iswap.nvim',
|
|
config = function ()
|
|
require('iswap').setup({
|
|
autoswap = true
|
|
})
|
|
end
|
|
}
|
|
-- Smart comments
|
|
use("tpope/vim-commentary")
|
|
|
|
-- Git integration
|
|
-- use("tpope/vim-fugitive")
|
|
use {
|
|
'TimUntersberger/neogit',
|
|
commit = "74c9e29b61780345d3ad9d7a4a4437607caead4a",
|
|
requires = 'nvim-lua/plenary.nvim',
|
|
config = function ()
|
|
require('neogit').setup{
|
|
disable_builtin_notifications = true,
|
|
disable_commit_confirmation = true
|
|
}
|
|
end
|
|
}
|
|
use {
|
|
'lewis6991/gitsigns.nvim',
|
|
config = function ()
|
|
require('gitsigns').setup()
|
|
end,
|
|
on_attach = function(bufnr)
|
|
end
|
|
}
|
|
|
|
-- Format
|
|
use("sbdchd/neoformat")
|
|
|
|
-- Resume issues found with LSP
|
|
use {
|
|
"folke/trouble.nvim",
|
|
requires = "kyazdani42/nvim-web-devicons",
|
|
config = function()
|
|
require("trouble").setup {}
|
|
end
|
|
}
|
|
|
|
use {
|
|
"windwp/nvim-autopairs",
|
|
config = function() require("nvim-autopairs").setup {} end
|
|
}
|
|
|
|
-- Enhanced increment and decrement
|
|
use("monaqa/dial.nvim")
|
|
|
|
-- Toggle helper
|
|
-- plugin to toggle boolean values
|
|
use {
|
|
"rmagatti/alternate-toggler"
|
|
}
|
|
|
|
-- Lua pad: REPL lua in neovim context
|
|
-- Useful to mess around with the lua API
|
|
use { 'rafcamlet/nvim-luapad', requires = "antoinemadec/FixCursorHold.nvim" }
|
|
|
|
-- Spell check helper
|
|
--
|
|
-- use("kamykn/spelunker.vim")
|
|
|
|
-- File navigation helper
|
|
use {
|
|
"ThePrimeagen/harpoon",
|
|
-- config = function()
|
|
-- require('harpoon').setup({
|
|
|
|
-- })
|
|
-- end
|
|
}
|
|
|
|
-- -- Colorscheme section
|
|
use {
|
|
"catppuccin/nvim",
|
|
as = "catppuccin",
|
|
config = function ()
|
|
end
|
|
}
|
|
use {
|
|
'kyazdani42/nvim-web-devicons',
|
|
config = function()
|
|
require'nvim-web-devicons'.setup {
|
|
-- your personnal icons can go here (to override)
|
|
-- you can specify color or cterm_color instead of specifying both of them
|
|
-- DevIcon will be appended to `name`
|
|
override = {
|
|
vue = {
|
|
icon = "",
|
|
color = "#428850",
|
|
cterm_color = "65",
|
|
name = "Vue"
|
|
}
|
|
};
|
|
-- globally enable default icons (default to false)
|
|
-- will get overriden by `get_icons` option
|
|
default = true;
|
|
}
|
|
end
|
|
}
|
|
|
|
-- Preview HTML colors
|
|
use("lilydjwg/colorizer")
|
|
|
|
-- Add Sticky Buffers
|
|
use {
|
|
"stevearc/stickybuf.nvim",
|
|
config = function()
|
|
require("stickybuf").setup()
|
|
end
|
|
}
|
|
|
|
-- add surround with 's'
|
|
use {
|
|
"ur4ltz/surround.nvim",
|
|
config = function()
|
|
require"surround".setup {mappings_style = "sandwich"}
|
|
end
|
|
}
|
|
|
|
use {
|
|
"tpope/vim-unimpaired"
|
|
}
|
|
|
|
use {
|
|
"tpope/vim-repeat"
|
|
}
|
|
|
|
-- In-buffer navigation
|
|
use {
|
|
"mfussenegger/nvim-treehopper"
|
|
}
|
|
use {
|
|
"phaazon/hop.nvim",
|
|
branch = 'v2',
|
|
config = function()
|
|
require'hop'.setup { keys = 'etovxqpdygfblzhckisuran' }
|
|
end
|
|
}
|
|
use {
|
|
"indianboy42/hop-extensions",
|
|
requires = {'phaazon/hop.nvim'}
|
|
}
|
|
|
|
-- Align things by comma
|
|
-- use : `:Tabularize /,`
|
|
-- It would be nicer if someone (me?) could develop a plugin that is based on treesitter and can automagically detect when it's a array, object etc.
|
|
use("godlygeek/tabular")
|
|
|
|
-- Ascii boxes
|
|
-- Diagramms
|
|
use("jbyuki/venn.nvim")
|
|
use("gyim/vim-boxdraw")
|
|
|
|
-- Old tab plugin
|
|
-- use {
|
|
-- 'romgrk/barbar.nvim',
|
|
-- requires = {'kyazdani42/nvim-web-devicons'}
|
|
-- }
|
|
|
|
-- Implement the editorconfig specification (format rules for each project)
|
|
use('editorconfig/editorconfig-vim')
|
|
|
|
-- Non-LSP Language config
|
|
-- Language specific config
|
|
|
|
-- Use emmet
|
|
use('mattn/emmet-vim')
|
|
|
|
-- Consider using https://github.com/danymat/neogen to easily create functions annotation (can support php docs)
|
|
-- use('lervag/vimtex') -- tex support is already here?
|
|
--
|
|
use "folke/lua-dev.nvim"
|
|
|
|
-- Trying to have gohtmltemplate Highlighting
|
|
use "fatih/vim-go"
|
|
|
|
use { 'mfussenegger/nvim-dap' }
|
|
|
|
use { "rcarriga/nvim-dap-ui", requires = {"mfussenegger/nvim-dap"} }
|
|
|
|
use {
|
|
'nvim-lualine/lualine.nvim',
|
|
requires = { 'kyazdani42/nvim-web-devicons', opt = true },
|
|
config = function ()
|
|
require('lualine').setup {
|
|
options = {
|
|
icons_enabled = true,
|
|
theme = 'auto',
|
|
component_separators = { left = '', right = ''},
|
|
section_separators = { left = '', right = ''},
|
|
disabled_filetypes = {
|
|
statusline = {},
|
|
winbar = {},
|
|
},
|
|
ignore_focus = {},
|
|
always_divide_middle = true,
|
|
globalstatus = false,
|
|
refresh = {
|
|
statusline = 1000,
|
|
tabline = 1000,
|
|
winbar = 1000,
|
|
}
|
|
},
|
|
sections = {
|
|
lualine_a = {'mode'},
|
|
lualine_b = {'branch', 'diff', 'diagnostics'},
|
|
lualine_c = {{'filename', path = 1}},
|
|
-- lualine_x = {'filetype'},
|
|
lualine_y = {'progress'},
|
|
lualine_z = {'location'}
|
|
},
|
|
inactive_sections = {
|
|
lualine_a = {},
|
|
lualine_b = {},
|
|
lualine_c = {'filename'},
|
|
lualine_x = {'location'},
|
|
lualine_y = {},
|
|
lualine_z = {}
|
|
},
|
|
tabline = {},
|
|
winbar = {},
|
|
inactive_winbar = {},
|
|
extensions = {}
|
|
}
|
|
end
|
|
}
|
|
|
|
-- Language specific plugins
|
|
use "aklt/plantuml-syntax"
|
|
|
|
use "tyru/open-browser.vim"
|
|
use "weirongxu/plantuml-previewer.vim"
|
|
|
|
-- allow to easily create new telescope pickers
|
|
-- useful to create ppq git recent files
|
|
use {
|
|
'axkirillov/easypick.nvim',
|
|
requires = 'nvim-telescope/telescope.nvim',
|
|
config = function ()
|
|
local easypick = require("easypick")
|
|
local base_branch = "master"
|
|
easypick.setup({
|
|
pickers = {
|
|
-- list recent updated files tracked by git
|
|
{
|
|
name = "recent_files",
|
|
-- don't use the uniq util with sort, to preserve the original sorting order
|
|
command = "git -c core.quotepath=off log --name-only --format='' | head -n 100 | awk '!seen[$0]++'",
|
|
previewer = easypick.previewers.default()
|
|
}
|
|
}
|
|
})
|
|
end
|
|
}
|
|
|
|
use {
|
|
'ethanholz/nvim-lastplace',
|
|
config = function ()
|
|
require'nvim-lastplace'.setup {
|
|
lastplace_ignore_buftype = {"quickfix", "nofile", "help"},
|
|
lastplace_ignore_filetype = {"gitcommit", "gitrebase", "svn", "hgcommit"},
|
|
lastplace_open_folds = true
|
|
}
|
|
end
|
|
}
|
|
|
|
-- markdown note plugins
|
|
use({
|
|
"iamcco/markdown-preview.nvim",
|
|
run = function() vim.fn["mkdp#util#install"]() end,
|
|
})
|
|
|
|
-- disable it for now bc it overrode shit in NeoTree
|
|
-- use({'jakewvincent/mkdnflow.nvim',
|
|
-- config = function()
|
|
-- require('mkdnflow').setup({
|
|
-- -- Config goes here; leave blank for defaults
|
|
-- })
|
|
-- end
|
|
-- })
|
|
|
|
|
|
-- new plugins
|
|
-- append new plugins here
|
|
|
|
if packer_bootstrap then
|
|
require('packer').sync()
|
|
end
|
|
|
|
end)
|
|
|
|
|
|
-- local map = vim.api.nvim_set_keymap
|
|
local map = vim.keymap.set
|
|
|
|
-- reload nvim config
|
|
map("n", "<Leader><Leader>r", "<cmd>source ~/.config/nvim/init.lua<CR>")
|
|
|
|
-- short cut to access system clipboard
|
|
map("n", "Y", '"+y')
|
|
map("v", "Y", '"+y')
|
|
|
|
-- handy little things
|
|
map("n", "<C-q>", "<Cmd>:q<CR>") -- close a single buffer
|
|
map("n", "<C-Q>", "<Cmd>:tabclose<CR>") -- close a whole tab (with Q uppercase)
|
|
map("n", "<C-s>", "<Cmd>:w<CR>")
|
|
|
|
-- back to last buffer
|
|
map("n", "<Leader>bb", "<C-^>")
|
|
|
|
-- No highlights
|
|
map("n", "<Leader>nh", "<Cmd>noh<CR>")
|
|
map("n", "<Leader><Leader>h", "<Cmd>noh<CR>")
|
|
|
|
-- Copy current buffer paths to system clipboard
|
|
map("n", "<Leader>yp", function() copy_rel_path_with_line() end)
|
|
map("n", "<Leader>ypr", function() copy_rel_path() end)
|
|
map("n", "<Leader>ypr", function() copy_rel_path_with_line() end)
|
|
map("n", "<Leader>ypa", function() copy_abs_path() end)
|
|
|
|
-- Open URL in browser (replace netrw-gx)
|
|
map("n", "gx", function()
|
|
print()
|
|
vim.fn.jobstart(
|
|
{"xdg-open", vim.fn.expand("<cfile>")},
|
|
{ on_stdout = print_stdout, detach = true }
|
|
)
|
|
end)
|
|
|
|
-- Insert date + time
|
|
map("n", "<Leader>dt", function()
|
|
local res = os.date("%Y-%m-%d %H:%M:%S")
|
|
vim.api.nvim_put({res}, "", true, false)
|
|
end)
|
|
|
|
-- Insert only day date
|
|
map("n", "<Leader>dd", function()
|
|
local res = os.date("%Y-%m-%d")
|
|
vim.api.nvim_put({res}, "", true, false)
|
|
end)
|
|
|
|
-- using netrw
|
|
-- map("n", "<Leader>tt", "<Cmd>Explore<CR>")
|
|
-- map("n", "<Leader>th", "<Cmd>Sexplore<CR>")
|
|
-- map("n", "<Leader>tv", "<Cmd>Vexplore<CR>")
|
|
|
|
-- launch neotree
|
|
map("n", "<Leader>tt", function() vim.api.nvim_command('Neotree') end)
|
|
-- focus file in tree
|
|
-- locate file, locate path, locate buffer in tree
|
|
map("n", "<Leader>tf", function() vim.api.nvim_command('Neotree reveal') end)
|
|
map("n", "<Leader>tb", function() vim.api.nvim_command('Neotree buffers') end)
|
|
|
|
-- launch neogit
|
|
map("n", "<Leader>ng", function() vim.api.nvim_command('Neogit') end)
|
|
|
|
-- launch neoformat
|
|
map("n", "<Leader>nf", function() vim.api.nvim_command('Neoformat') end)
|
|
|
|
-- launch troubles
|
|
map("n", "<Leader>tr", function() vim.api.nvim_command('Trouble') end)
|
|
|
|
|
|
-- in buffer navigation
|
|
-- map("v", "<C-h>", function() require('tsht').nodes() end)
|
|
-- map("n", "<C-h>", function() require('tsht').move({ side = "start" }) end)
|
|
|
|
-- Hop nvim keybindings (quick jumps)
|
|
-- Similar function can be triggered with Ctrl+BackSpace
|
|
map("n", "<Leader>H", function()
|
|
-- hop in all the buffer by word
|
|
require('hop').hint_words()
|
|
end)
|
|
map("n", "<Leader>hl", function()
|
|
-- hop to a line
|
|
require('hop').hint_lines_skip_whitespace()
|
|
end)
|
|
map("n", "<Leader>hv", function()
|
|
-- keep the position of the cursor column wise
|
|
require('hop').hint_vertical()
|
|
end)
|
|
map("n", "<Leader>hs", function()
|
|
require('hop-extensions').hint_textobjects()
|
|
end)
|
|
map("n", "<C-h>", function()
|
|
require('hop-extensions').hint_textobjects()
|
|
end)
|
|
|
|
-- Symbols outline
|
|
-- TODO: add a command variant to only show the top-level elements
|
|
map("n", "<Leader>so", function ()
|
|
vim.cmd("SymbolsOutline")
|
|
end)
|
|
|
|
-- map("n", "<Leader>sO", function ()
|
|
-- vim.cmd("SymbolsOutlineOpen")
|
|
-- end)
|
|
|
|
-- Harpoon
|
|
-- map("n", "<Leader>h", function() require("harpoon.ui").toggle_quick_menu() end)
|
|
-- map("n", "<Leader>a", function() require("harpoon.mark").add_file() end)
|
|
|
|
-- map("n", "<A-h>", function () require("harpoon.ui").nav_file(1) end)
|
|
-- map("n", "<A-j>", function () require("harpoon.ui").nav_file(2) end)
|
|
-- map("n", "<A-k>", function () require("harpoon.ui").nav_file(3) end)
|
|
-- map("n", "<A-l>", function () require("harpoon.ui").nav_file(4) end)
|
|
|
|
-- reserved for style file
|
|
-- map("n", "<A-s>", function () require("harpoon.ui").nav_file(1) end)
|
|
|
|
-- reserved for template file
|
|
|
|
-- reserved for controller file
|
|
-- map("n", "<A-s>", function () require("harpoon.ui").nav_file("Controller") end)
|
|
|
|
-- Dial: Improved increment
|
|
map("n", "<C-a>", require("dial.map").inc_normal(), {noremap = true})
|
|
map("n", "<C-x>", require("dial.map").dec_normal(), {noremap = true})
|
|
map("v", "<C-a>", require("dial.map").inc_visual(), {noremap = true})
|
|
map("v", "<C-x>", require("dial.map").dec_visual(), {noremap = true})
|
|
map("v", "g<C-a>", require("dial.map").inc_gvisual(), {noremap = true})
|
|
map("v", "g<C-x>", require("dial.map").dec_gvisual(), {noremap = true})
|
|
|
|
-- let g:at_custom_alternates = {'===': '!==', 'yes':'no'}
|
|
-- vim.cmd [[
|
|
-- let g:at_custom_alternates = {'===': '!==', 'yes': 'no'}
|
|
-- ]]
|
|
|
|
-- https://github.com/rmagatti/alternate-toggler/issues/6
|
|
vim.g.at_custom_alternates = {
|
|
['==='] = '!==',
|
|
['yes'] = 'no',
|
|
['open'] = 'close',
|
|
['always'] = 'never',
|
|
['allow'] = 'deny',
|
|
['before'] = 'after',
|
|
['let'] = 'var',
|
|
['public'] = 'private',
|
|
['begin'] = 'end'
|
|
}
|
|
|
|
map("n", "<Leader>ta", "<Cmd>:ToggleAlternate<CR>")
|
|
|
|
-- swap with
|
|
map("n", "<Leader>ss", function() vim.api.nvim_command('ISwap') end)
|
|
map("n", "<Leader>sw", function() vim.api.nvim_command('ISwapWith') end)
|
|
map("n", "<Leader>sl", function() vim.api.nvim_command('ISwapNodeWithLeft') end)
|
|
map("n", "<Leader>sr", function() vim.api.nvim_command('ISwapNodeWithRight') end)
|
|
|
|
-- Telescope binding
|
|
map("n", "<Leader>ff", function ()
|
|
require('telescope.builtin').find_files()
|
|
end)
|
|
|
|
-- Ctrl+P
|
|
map("n", "<C-p>", function ()
|
|
-- It would be great if we could enter regex pattern to match on files
|
|
require('telescope.builtin').find_files()
|
|
end)
|
|
|
|
-- TODO: find files with telescope but also search in the ignored files
|
|
-- map("n", "<C-P>", function ()
|
|
-- require('telescope.builtin').find_files()
|
|
-- end)
|
|
|
|
-- live grep keybind
|
|
map("n", "<Leader>fg", function ()
|
|
-- previously was:
|
|
-- require('telescope.builtin').live_grep()
|
|
--
|
|
-- arguments of ripgrep
|
|
|
|
-- use '"search" --type py' to search in python file only
|
|
-- or use '"search" -g "*.py"' to do glob search on file name
|
|
-- or use '"search" -g "!*.py"' to exclude file name pattern
|
|
|
|
-- another cool feature will be to do only search on a subdirectory (preferentially the current directory of neotree)
|
|
require('telescope').extensions.live_grep_args.live_grep_args()
|
|
end)
|
|
|
|
map("n", "<Leader>SS", function ()
|
|
require('telescope').extensions.live_grep_args.live_grep_args({search = "hello world"})
|
|
end)
|
|
|
|
map("n", "<Leader>fb", function ()
|
|
require('telescope.builtin').buffers()
|
|
end)
|
|
|
|
map("n", "<Leader>fh", function ()
|
|
require('telescope.builtin').help_tags()
|
|
end)
|
|
|
|
map("n", "<Leader>fs", function ()
|
|
require('telescope.builtin').lsp_workspace_symbols()
|
|
end)
|
|
|
|
map("n", "<Leader>fw", function ()
|
|
-- useful to quickly jump to ANY workspace symbols (also include random variables)
|
|
require('telescope.builtin').lsp_dynamic_workspace_symbols()
|
|
end)
|
|
|
|
map("n", "<Leader>fo", function ()
|
|
-- recent files history
|
|
require('telescope.builtin').oldfiles({only_cwd = true})
|
|
end)
|
|
|
|
map("n", "<Leader>fW", function ()
|
|
-- useful to quickly jump to major workspace symbols (class, functions, interfaces, etc...)
|
|
-- require('telescope.builtin').lsp_dynamic_workspace_symbols()
|
|
end)
|
|
|
|
-- Search for symbols accross project
|
|
-- map("n", "<Leader>fs", function ()
|
|
-- require('telescope.builtin').lsp()
|
|
-- end)
|
|
|
|
-- find recent files
|
|
map("n", "<Leader>fr", function ()
|
|
vim.api.nvim_command('Easypick recent_files')
|
|
end)
|
|
|
|
-- Treesitter config
|
|
require'nvim-treesitter.configs'.setup {
|
|
ensure_installed = "all",
|
|
sync_install = false,
|
|
|
|
highlight = {
|
|
enable = true,
|
|
additional_vim_regex_highlighting = false,
|
|
},
|
|
indent = {
|
|
enable = true
|
|
},
|
|
incremental_selection = {
|
|
enable = true,
|
|
keymaps = {
|
|
init_selection = "<C-n>",
|
|
node_incremental = "<C-n>",
|
|
scope_incremental = "<C-s>",
|
|
node_decremental = "<C-r>",
|
|
},
|
|
},
|
|
textobjects = {
|
|
select = {
|
|
enable = true,
|
|
|
|
-- Automatically jump forward to textobj, similar to targets.vim
|
|
lookahead = true,
|
|
|
|
keymaps = {
|
|
-- You can use the capture groups defined in textobjects.scm
|
|
["af"] = "@function.outer",
|
|
["if"] = "@function.inner",
|
|
["ac"] = "@class.outer",
|
|
["ic"] = "@class.inner",
|
|
["aa"] = "@block.outer",
|
|
["ii"] = "@block.inner",
|
|
["i,"] = '@parameter.inner',
|
|
["a,"] = '@parameter.outer',
|
|
},
|
|
-- You can choose the select mode (default is charwise 'v')
|
|
selection_modes = {
|
|
['@parameter.outer'] = 'v', -- charwise
|
|
['@function.outer'] = 'V', -- linewise
|
|
['@class.outer'] = '<c-v>', -- blockwise
|
|
},
|
|
-- Useful to include whitespace after a function for example (so the whitespace get deleted or copied and stick with the belonging block)
|
|
include_surrounding_whitespace = true,
|
|
},
|
|
move = {
|
|
enable = true,
|
|
set_jumps = true, -- whether to set jumps in the jumplist
|
|
goto_next_start = {
|
|
["]m"] = "@function.outer",
|
|
["]]"] = { query = "@class.outer", desc = "Next class start" },
|
|
--
|
|
-- You can use regex matching (i.e. lua pattern) and/or pass a list in a "query" key to group multiple queires.
|
|
["]o"] = "@loop.*",
|
|
-- ["]o"] = { query = { "@loop.inner", "@loop.outer" } }
|
|
--
|
|
-- You can pass a query group to use query from `queries/<lang>/<query_group>.scm file in your runtime path.
|
|
-- Below example nvim-treesitter's `locals.scm` and `folds.scm`. They also provide highlights.scm and indent.scm.
|
|
["]s"] = { query = "@scope", query_group = "locals", desc = "Next scope" },
|
|
["]z"] = { query = "@fold", query_group = "folds", desc = "Next fold" },
|
|
},
|
|
goto_next_end = {
|
|
["]M"] = "@function.outer",
|
|
["]["] = "@class.outer",
|
|
},
|
|
goto_previous_start = {
|
|
["[m"] = "@function.outer",
|
|
["[["] = "@class.outer",
|
|
},
|
|
goto_previous_end = {
|
|
["[M"] = "@function.outer",
|
|
["[]"] = "@class.outer",
|
|
},
|
|
-- Below will go to either the start or the end, whichever is closer.
|
|
-- Use if you want more granular movements
|
|
-- Make it even more gradual by adding multiple queries and regex.
|
|
goto_next = {
|
|
["]d"] = "@conditional.outer",
|
|
},
|
|
goto_previous = {
|
|
["[d"] = "@conditional.outer",
|
|
}
|
|
},
|
|
},
|
|
}
|
|
|
|
vim.opt.foldmethod = "expr"
|
|
vim.opt.foldexpr = "nvim_treesitter#foldexpr()"
|
|
vim.opt.foldlevelstart = 8
|
|
|
|
-- LSP Config
|
|
local nvim_lsp = require 'lspconfig'
|
|
|
|
-- TODO: fix auto-imports not working with rust
|
|
|
|
-- LSP Servers
|
|
-- docs: WHERE IS THE FING DOCS?
|
|
-- https://github.com/neovim/nvim-lspconfig/blob/master/doc/server_configurations.md
|
|
local servers = {'clangd', 'pyright', 'tsserver', 'gopls', 'volar', 'svelte' }
|
|
|
|
for _, lsp in ipairs(servers) do
|
|
nvim_lsp[lsp].setup {
|
|
on_attach = on_attach,
|
|
}
|
|
end
|
|
|
|
nvim_lsp['rust_analyzer'].setup{
|
|
on_attach = on_attach,
|
|
init_options = {
|
|
["rust-analyzer.checkOnSave.command"] = "clippy"
|
|
}
|
|
}
|
|
nvim_lsp.phpactor.setup{
|
|
on_attach = on_attach,
|
|
init_options = {
|
|
["language_server_phpstan.enabled"] = false,
|
|
["language_server_psalm.enabled"] = false,
|
|
}
|
|
}
|
|
nvim_lsp.svelte.setup{
|
|
init_options = {
|
|
["svelte.plugin.typescript.enable"] = false,
|
|
["svelte.plugin.typescript.diagnostics.enable"] = false,
|
|
}
|
|
}
|
|
|
|
nvim_lsp['hls'].setup{
|
|
filetypes = { 'haskell', 'lhaskell', 'cabal' }
|
|
}
|
|
|
|
local capabilities = vim.lsp.protocol.make_client_capabilities()
|
|
capabilities.textDocument.completion.completionItem.snippetSupport = true
|
|
|
|
nvim_lsp.cssls.setup{
|
|
capabilities = capabilities
|
|
}
|
|
|
|
|
|
local runtime_path = vim.split(package.path, ';')
|
|
table.insert(runtime_path, 'lua/?.lua')
|
|
table.insert(runtime_path, 'lua/?/init.lua')
|
|
|
|
-- Cmp config
|
|
local cmp = require'cmp'
|
|
|
|
cmp.setup({
|
|
snippet = {
|
|
-- REQUIRED - you must specify a snippet engine
|
|
expand = function(args)
|
|
-- vim.fn["vsnip#anonymous"](args.body) -- For `vsnip` users.
|
|
require('luasnip').lsp_expand(args.body) -- For `luasnip` users.
|
|
-- require('snippy').expand_snippet(args.body) -- For `snippy` users.
|
|
-- vim.fn["UltiSnips#Anon"](args.body) -- For `ultisnips` users.
|
|
end,
|
|
},
|
|
window = {
|
|
-- completion = cmp.config.window.bordered(),
|
|
-- documentation = cmp.config.window.bordered(),
|
|
},
|
|
mapping = cmp.mapping.preset.insert({
|
|
['<C-b>'] = cmp.mapping.scroll_docs(-4),
|
|
['<C-f>'] = cmp.mapping.scroll_docs(4),
|
|
['<C-Space>'] = cmp.mapping.complete(),
|
|
['<C-e>'] = cmp.mapping.abort(),
|
|
['<S-CR>'] = cmp.mapping.confirm({ select = true }), -- Accept currently selected item. Set `select` to `false` to only confirm explicitly selected items.
|
|
}),
|
|
sources = {
|
|
{ name = 'nvim_lsp', keyword_length = 4 },
|
|
{ name = 'nvim_lua', keyword_length = 4 },
|
|
|
|
{ name = 'path', keyword_length = 4 },
|
|
{ name = 'treesitter', keyword_length = 4 },
|
|
{ name = "luasnip", keyword_length = 4 },
|
|
{ name = "buffer", keyword_length = 5 },
|
|
},
|
|
experimental = {
|
|
-- I like the new menu better! Nice work hrsh7th
|
|
native_menu = false,
|
|
|
|
-- Let's play with this for a day or two
|
|
ghost_text = false,
|
|
},
|
|
sorting = {
|
|
-- TODO: Would be cool to add stuff like "See variable names before method names" in rust, or something like that.
|
|
comparators = {
|
|
cmp.config.compare.offset,
|
|
cmp.config.compare.exact,
|
|
cmp.config.compare.score,
|
|
|
|
-- copied from cmp-under, but I don't think I need the plugin for this.
|
|
-- I might add some more of my own.
|
|
function(entry1, entry2)
|
|
local _, entry1_under = entry1.completion_item.label:find "^_+"
|
|
local _, entry2_under = entry2.completion_item.label:find "^_+"
|
|
entry1_under = entry1_under or 0
|
|
entry2_under = entry2_under or 0
|
|
if entry1_under > entry2_under then
|
|
return false
|
|
elseif entry1_under < entry2_under then
|
|
return true
|
|
end
|
|
end,
|
|
|
|
cmp.config.compare.kind,
|
|
cmp.config.compare.sort_text,
|
|
cmp.config.compare.length,
|
|
cmp.config.compare.order,
|
|
},
|
|
},
|
|
-- sources = cmp.config.sources({
|
|
-- { name = 'nvim_lsp' },
|
|
-- -- { name = 'vsnip' }, -- For vsnip users.
|
|
-- -- { name = 'luasnip' }, -- For luasnip users.
|
|
-- -- { name = 'ultisnips' }, -- For ultisnips users.
|
|
-- -- { name = 'snippy' }, -- For snippy users.
|
|
-- }, {
|
|
-- {
|
|
-- name = 'buffer',
|
|
-- options = {
|
|
-- keyword_length = 5
|
|
-- }
|
|
-- },
|
|
-- })
|
|
})
|
|
|
|
-- Toggle diags
|
|
DiagnosticsConfig = vim.diagnostic.config()
|
|
DiagnosticsEnabled = true
|
|
function toggle_lsp_diag()
|
|
if not DiagnosticsEnabled then
|
|
vim.diagnostic.config(DiagnosticsConfig)
|
|
DiagnosticsEnabled = true
|
|
else
|
|
DiagnosticsConfig = vim.diagnostic.config()
|
|
vim.diagnostic.config({
|
|
virtual_text = false,
|
|
sign = false,
|
|
float = false,
|
|
update_in_insert = false,
|
|
severity_sort = false,
|
|
underline = false,
|
|
})
|
|
DiagnosticsEnabled = false
|
|
end
|
|
end
|
|
|
|
-- Language server keybindings
|
|
-- LSP keybindings
|
|
map("n", "gd", function ()
|
|
vim.lsp.buf.definition()
|
|
end)
|
|
|
|
map("n", "<Leader>od", function ()
|
|
-- open definition in a new tab
|
|
-- vim.lsp.buf.definition()
|
|
print("Open def in new tab")
|
|
-- vim.api.nvim_exec(
|
|
-- [[ normal <Ctrl+w>] ]],
|
|
-- -- [[normal dd]],
|
|
-- false
|
|
-- )
|
|
end)
|
|
|
|
map("n", "gD", function ()
|
|
vim.lsp.buf.declaration()
|
|
end)
|
|
|
|
-- go to implementation
|
|
map("n", "gi", function ()
|
|
vim.lsp.buf.implementation()
|
|
end)
|
|
|
|
-- go to usage
|
|
-- go to callers of a function
|
|
map("n", "<Leader>lc", function ()
|
|
vim.lsp.buf.incoming_calls()
|
|
end)
|
|
|
|
map("n", "gw", function ()
|
|
vim.lsp.buf.document_symbol()
|
|
end)
|
|
|
|
map("n", "gr", function ()
|
|
vim.lsp.buf.references()
|
|
end)
|
|
|
|
map("n", "<Leader>ld", function ()
|
|
vim.lsp.buf.type_definition()
|
|
end)
|
|
|
|
map("n", "K", function ()
|
|
vim.lsp.buf.hover()
|
|
end)
|
|
|
|
map("n", "<c-k>", function ()
|
|
vim.lsp.buf.signature_help()
|
|
end)
|
|
|
|
map("n", "<Leader>ac", function ()
|
|
vim.lsp.buf.code_action()
|
|
end)
|
|
|
|
-- Rename action
|
|
map("n", "<Leader>rn", function ()
|
|
vim.lsp.buf.rename()
|
|
end)
|
|
|
|
-- Show_line_diagnostics
|
|
map("n", "<Leader>di", function ()
|
|
vim.diagnostic.open_float()
|
|
end)
|
|
|
|
-- Format whole buffer with LSP
|
|
map("n", "<Leader>F", function ()
|
|
vim.lsp.buf.format { async = true }
|
|
end)
|
|
|
|
-- Toggle LSP diags
|
|
-- keywords: disable lsp
|
|
map("n", "<Leader>td", function() toggle_lsp_diag() end)
|
|
|
|
-- Tabs keymaps
|
|
|
|
-- -- Move to previous/next
|
|
-- map('n', '<A-,>', '<Cmd>BufferPrevious<CR>')
|
|
-- map('n', '<A-.>', '<Cmd>BufferNext<CR>')
|
|
-- -- Re-order to previous/next
|
|
-- map('n', '<A-<>', '<Cmd>BufferMovePrevious<CR>')
|
|
-- map('n', '<A->>', '<Cmd>BufferMoveNext<CR>')
|
|
-- -- Goto buffer in position...
|
|
-- map('n', '<A-1>', '<Cmd>BufferGoto 1<CR>')
|
|
-- map('n', '<A-2>', '<Cmd>BufferGoto 2<CR>')
|
|
-- map('n', '<A-3>', '<Cmd>BufferGoto 3<CR>')
|
|
-- map('n', '<A-4>', '<Cmd>BufferGoto 4<CR>')
|
|
-- map('n', '<A-5>', '<Cmd>BufferGoto 5<CR>')
|
|
-- map('n', '<A-6>', '<Cmd>BufferGoto 6<CR>')
|
|
-- map('n', '<A-7>', '<Cmd>BufferGoto 7<CR>')
|
|
-- map('n', '<A-8>', '<Cmd>BufferGoto 8<CR>')
|
|
-- map('n', '<A-9>', '<Cmd>BufferGoto 9<CR>')
|
|
-- map('n', '<A-0>', '<Cmd>BufferLast<CR>')
|
|
-- -- Pin/unpin buffer
|
|
-- map('n', '<A-p>', '<Cmd>BufferPin<CR>')
|
|
-- -- Close buffer
|
|
-- map('n', '<A-c>', '<Cmd>BufferClose<CR>')
|
|
-- -- Wipeout buffer
|
|
-- -- :BufferWipeout
|
|
-- -- Close commands
|
|
-- -- :BufferCloseAllButCurrent
|
|
-- -- :BufferCloseAllButPinned
|
|
-- -- :BufferCloseAllButCurrentOrPinned
|
|
-- -- :BufferCloseBuffersLeft
|
|
-- -- :BufferCloseBuffersRight
|
|
-- -- Magic buffer-picking mode
|
|
-- map('n', '<C-p>', '<Cmd>BufferPick<CR>')
|
|
-- -- Sort automatically by...
|
|
-- map('n', '<Space>bb', '<Cmd>BufferOrderByBufferNumber<CR>')
|
|
-- map('n', '<Space>bd', '<Cmd>BufferOrderByDirectory<CR>')
|
|
-- map('n', '<Space>bl', '<Cmd>BufferOrderByLanguage<CR>')
|
|
-- map('n', '<Space>bw', '<Cmd>BufferOrderByWindowNumber<CR>')
|
|
|
|
map("n", "<Leader>gh", "<Cmd>:lua print('this is a msg')<CR>")
|
|
|
|
vim.g.hook_cmp_toggle = true
|
|
|
|
|
|
-- LuaSnip config / Snippets
|
|
|
|
-- imap <silent><expr> <Tab> luasnip#expand_or_jumpable() ? '<Plug>luasnip-expand-or-jump' : '<Tab>'
|
|
-- " -1 for jumping backwards.
|
|
-- inoremap <silent> <S-Tab> <cmd>lua require'luasnip'.jump(-1)<Cr>
|
|
|
|
-- snoremap <silent> <Tab> <cmd>lua require('luasnip').jump(1)<Cr>
|
|
-- snoremap <silent> <S-Tab> <cmd>lua require('luasnip').jump(-1)<Cr>
|
|
|
|
-- " For changing choices in choiceNodes (not strictly necessary for a basic setup).
|
|
-- imap <silent><expr> <C-E> luasnip#choice_active() ? '<Plug>luasnip-next-choice' : '<C-E>'
|
|
-- smap <silent><expr> <C-E> luasnip#choice_active() ? '<Plug>luasnip-next-choice' : '<C-E>'
|
|
function on_luasnip_load()
|
|
local ls = require("luasnip")
|
|
|
|
ls.config.set_config({
|
|
history = true,
|
|
updateevents = "TextChanged,TextChangedI",
|
|
enable_autosnippets = true,
|
|
})
|
|
ls.filetype_extend("svelte", { "html" })
|
|
ls.filetype_extend("svelte", { "typescript" })
|
|
|
|
require("luasnip.loaders.from_vscode").lazy_load()
|
|
|
|
|
|
-- This replace the diagraph menu
|
|
vim.keymap.set({"i", "s"}, "<c-k>", function ()
|
|
if ls.expand_or_jumpable() then
|
|
ls.expand_or_jump()
|
|
end
|
|
end)
|
|
|
|
vim.keymap.set({"i", "s"}, "<c-j>", function ()
|
|
if ls.jumpable(-1) then
|
|
ls.jump(-1)
|
|
end
|
|
end)
|
|
|
|
vim.keymap.set("i", "<c-l>", function ()
|
|
if ls.choice_active() then
|
|
ls.change_choice()
|
|
end
|
|
end)
|
|
|
|
|
|
local events = require("luasnip.util.events")
|
|
local ai = require("luasnip.nodes.absolute_indexer")
|
|
local fmt = require("luasnip.extras.fmt").fmt
|
|
local extras = require("luasnip.extras")
|
|
local m = extras.m
|
|
local l = extras.l
|
|
local rep = extras.rep
|
|
local postfix = require("luasnip.extras.postfix").postfix
|
|
|
|
ls.add_snippets("all", {
|
|
ls.snippet("somefoobarlel", {
|
|
-- equivalent to "${1:cond} ? ${2:then} : ${3:else}"
|
|
ls.insert_node(1, "cond"), ls.text_node(" ? "), ls.insert_node(2, "then"), ls.text_node(" : "), ls.insert_node(3, "else")
|
|
}),
|
|
ls.snippet("lorem", {
|
|
ls.text_node("Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.")
|
|
})
|
|
})
|
|
|
|
ls.add_snippets("rust", {
|
|
ls.snippet("dbg", {
|
|
ls.text_node("dbg!("), ls.insert_node(1, "value"), ls.text_node(");")
|
|
})
|
|
})
|
|
|
|
function mysplit (inputstr, sep)
|
|
if sep == nil then
|
|
sep = "%s"
|
|
end
|
|
local t={}
|
|
for str in string.gmatch(inputstr, "([^"..sep.."]+)") do
|
|
table.insert(t, str)
|
|
end
|
|
return t
|
|
end
|
|
|
|
vim.api.nvim_create_user_command('SnipList', function ()
|
|
-- Will create a read only buffer and show the description of all the snippets
|
|
local res = vim.inspect(require'luasnip'.available())
|
|
|
|
if win and vim.api.nvim_win_is_valid(win) then
|
|
vim.api.nvim_set_current_win(win)
|
|
else
|
|
-- We open a new buffer
|
|
vim.api.nvim_command('botright vnew')
|
|
|
|
win = vim.api.nvim_get_current_win()
|
|
buf = vim.api.nvim_get_current_buf()
|
|
|
|
vim.api.nvim_buf_set_name(buf, "SnipList")
|
|
|
|
vim.api.nvim_buf_set_option(buf, 'buftype', 'nofile')
|
|
vim.api.nvim_buf_set_option(buf, 'swapfile', false)
|
|
vim.api.nvim_buf_set_option(buf, 'bufhidden', 'wipe')
|
|
|
|
vim.api.nvim_buf_set_option(buf, 'modifiable', true)
|
|
vim.api.nvim_buf_set_option(buf, 'filetype', 'lua')
|
|
-- Uncomment to disable numbers
|
|
-- vim.api.nvim_set_option_value('number', false, { scope = "local" })
|
|
-- vim.api.nvim_set_option_value('relativenumber', false, { scope = "local" })
|
|
|
|
-- We set the buffer content
|
|
vim.api.nvim_buf_set_lines(buf, 0, -1, false, mysplit(res, "\n"))
|
|
vim.api.nvim_buf_set_option(buf, 'modifiable', false)
|
|
end
|
|
|
|
end, {})
|
|
|
|
end
|
|
|
|
require("catppuccin").setup({
|
|
flavour = "mocha", -- redondant
|
|
color_overrides = {
|
|
all = {
|
|
}
|
|
},
|
|
custom_highlights = function(colors)
|
|
return {
|
|
["@constant.builtin"] = { fg = colors.peach, style = {} },
|
|
-- change the syntax highlighting of comments to make them easier to read and notice
|
|
-- I once read a blog post about how comments in code should be put in front and not hidden with some gray colorscheme
|
|
["@comment"] = { fg = colors.red, style = { "italic", "bold" } },
|
|
}
|
|
end
|
|
})
|
|
|
|
vim.cmd.colorscheme "catppuccin"
|
|
|
|
vim.api.nvim_exec(
|
|
[[
|
|
function! DetectGoHtmlTmpl()
|
|
if expand('%:e') == "html" && search("{{") != 0
|
|
set filetype=gohtmltmpl
|
|
endif
|
|
endfunction
|
|
|
|
augroup filetypedetect
|
|
au! BufRead,BufNewFile * call DetectGoHtmlTmpl()
|
|
augroup END
|
|
]], true
|
|
)
|
|
|
|
-- vim.g.gruvbox_contrast_dark = "hard"
|
|
|
|
-- little shortcut to insert new line without going into insert mode with Ctrl+Enter
|
|
map("n", "<C-Enter>", function ()
|
|
vim.api.nvim_put({"",""}, "", true, false)
|
|
end)
|
|
|
|
-- Tabs manipulations
|
|
map("n", "<Leader>T0", function() vim.api.nvim_command('tabm 0') end)
|
|
map("n", "<Leader>Ti", function() vim.api.nvim_command('tabm +1') end)
|
|
map("n", "<Leader>Td", function() vim.api.nvim_command('tabm -1') end)
|
|
|
|
-- Move after last tab
|
|
vim.api.nvim_create_user_command('MoveTabAtLastTab', function ()
|
|
local tabpages = vim.api.nvim_list_tabpages()
|
|
vim.api.nvim_command('tabm '..#tabpages)
|
|
end, {})
|
|
|
|
map("n", "<Leader>Te", function() vim.api.nvim_command('MoveTabAtLastTab') end)
|
|
|
|
-- Tabs/Tabspages navigation with alt
|
|
map("n", "<A-Left>", function () vim.api.nvim_command("tabp") end)
|
|
map("n", "<A-Right>", function () vim.api.nvim_command("tabn") end)
|
|
map("n", "<A-h>", function () vim.api.nvim_command("tabp") end)
|
|
|
|
-- Go to nth tab
|
|
local function jump_to_nth_tab(tab_position)
|
|
local tabpages = vim.api.nvim_list_tabpages()
|
|
if tab_position > #tabpages then
|
|
return
|
|
end
|
|
print(tab_position)
|
|
vim.api.nvim_set_current_tabpage(tabpages[tab_position])
|
|
end
|
|
|
|
local function jump_to_last_tab()
|
|
local tabpages = vim.api.nvim_list_tabpages()
|
|
print(#tabpages)
|
|
end
|
|
|
|
map("n", "<A-L>", function () jump_to_nth_tab(0) end)
|
|
map("n", "<A-H>", function () jump_to_last_tab() end)
|
|
map("n", "<A-0>", function () jump_to_nth_tab(10) end)
|
|
map("n", "<A-->", function () jump_to_nth_tab(11) end)
|
|
map("n", "<A-=>", function () jump_to_nth_tab(12) end)
|
|
for i = 1, 9 do
|
|
map("n", "<A-" .. i .. ">", function ()
|
|
jump_to_nth_tab(i)
|
|
end)
|
|
end
|
|
|
|
-- common utils function to accept user input from bottom status line
|
|
local function user_input(message)
|
|
vim.api.nvim_call_function("inputsave", {})
|
|
local val = vim.api.nvim_call_function("input", { message })
|
|
vim.api.nvim_call_function("inputrestore", {})
|
|
return val
|
|
end
|
|
|
|
-- Now a way to jump to specific tabs via file name match
|
|
map("n", "<A-j>", function ()
|
|
-- Ask user the file startup
|
|
user_res = user_input("TabJump: ")
|
|
|
|
pages = vim.api.nvim_list_tabpages()
|
|
if #pages == 1 then
|
|
return
|
|
end
|
|
|
|
for tab_pos in ipairs(pages) do
|
|
win = vim.api.nvim_tabpage_get_win(tab_pos)
|
|
buf = vim.api.nvim_win_get_buf(win)
|
|
file_path = vim.api.nvim_buf_get_name(buf)
|
|
res = mysplit(file_path, "/")
|
|
file_name = res[#res]
|
|
|
|
search_res = string.find(file_name, user_res)
|
|
if search_res then
|
|
vim.api.nvim_set_current_tabpage(tab_pos)
|
|
vim.api.nvim_echo({}, false, {})
|
|
return
|
|
end
|
|
end
|
|
vim.api.nvim_notify("TabJump: No match found", 0, {})
|
|
end)
|
|
|
|
-- Search helper
|
|
|
|
local function visual_selection_range()
|
|
local _, csrow, cscol, _ = unpack(vim.fn.getpos("'<"))
|
|
local _, cerow, cecol, _ = unpack(vim.fn.getpos("'>"))
|
|
if csrow < cerow or (csrow == cerow and cscol <= cecol) then
|
|
return csrow - 1, cscol - 1, cerow - 1, cecol
|
|
else
|
|
return cerow - 1, cecol - 1, csrow - 1, cscol
|
|
end
|
|
end
|
|
|
|
function get_current_selected()
|
|
local current_mode = vim.api.nvim_get_mode()['mode']
|
|
if (
|
|
current_mode == "v" or
|
|
current_mode == "V"
|
|
) then
|
|
local _, select_start_row, select_start_col, _ = unpack(vim.fn.getpos("'<"))
|
|
local _, select_end_row, select_end_col, _ = unpack(vim.fn.getpos("'>"))
|
|
|
|
-- get the range
|
|
-- print(select_start_row, select_start_col)
|
|
-- print(select_end_row, select_end_col)
|
|
selected_text = vim.api.nvim_buf_get_text(0, select_start_row-1, select_start_col-1, select_end_row-1, select_end_col-1, {})
|
|
if #selected_text == 0 then
|
|
return nil
|
|
end
|
|
return selected_text[1]
|
|
end
|
|
return nil
|
|
end
|
|
|
|
function copy_rel_path()
|
|
-- get full path: expand("%:p")
|
|
-- get relative path: expand("%")
|
|
-- vim.fn.setreg("+", vim.fn.expand("%"))
|
|
path = vim.fn.fnamemodify(vim.fn.expand("%"), ":~:.")
|
|
vim.fn.setreg("+", path)
|
|
print("Copied relative to system clipboard")
|
|
end
|
|
|
|
function copy_rel_path_with_line()
|
|
path = vim.fn.fnamemodify(vim.fn.expand("%"), ":~:.") .. ':' .. vim.fn.getpos('.')[2]
|
|
vim.fn.setreg("+", path)
|
|
end
|
|
|
|
function copy_abs_path()
|
|
vim.fn.setreg("+", vim.fn.expand("%:p"))
|
|
print("Copied absolute to system clipboard")
|
|
end
|
|
|
|
function copy_abs_path_with_line()
|
|
path = vim.fn.setreg("+", vim.fn.expand("%:p")) .. ':' .. vim.fn.getpos('.')[2]
|
|
|
|
vim.fn.setreg("+", path)
|
|
end
|
|
|
|
-- Search the term selected
|
|
function handle_search_selection()
|
|
print("handle search selection")
|
|
|
|
selected = get_current_selected()
|
|
if selected == nil then
|
|
return nil
|
|
end
|
|
|
|
vim.api.nvim_exec(
|
|
"normal! /lelhello",
|
|
false
|
|
)
|
|
end
|
|
|
|
map("n", "<Leader>S", handle_search_selection)
|
|
map("v", "<Leader>S", handle_search_selection)
|
|
|
|
-- Restrict the search to a range
|
|
-- map("n", "<Leader>S", function ()
|
|
|
|
-- end)
|
|
|
|
-- Handy Git signs shortcuts
|
|
map("n", "<Leader>gb", function() vim.api.nvim_command('Gitsigns blame_line') end)
|
|
map("n", "<Leader>gs", function() vim.api.nvim_command('Gitsigns stage_hunk') end)
|
|
map("n", "<Leader>gu", function() vim.api.nvim_command('Gitsigns undo_stage_hunk') end)
|
|
map("n", "<Leader>gd", function() vim.api.nvim_command('Gitsigns toggle_deleted') end)
|
|
map("n", "<Leader>gD", function() vim.api.nvim_command('Gitsigns diffthis') end)
|
|
map("n", "<Leader>gS", function() vim.api.nvim_command('Gitsigns stage_buffer') end)
|
|
map("n", "<Leader>ghr", function() vim.api.nvim_command('Gitsigns reset_hunk') end)
|
|
map("n", "<Leader>ghp", function() vim.api.nvim_command('Gitsigns preview_hunk') end)
|
|
|
|
vim.api.nvim_create_user_command('CopyRelPath', function () copy_rel_path() end, {})
|
|
vim.api.nvim_create_user_command('CopyAbsPath', copy_abs_path, {})
|
|
vim.api.nvim_create_user_command('CopyRelPathWithLine', copy_rel_path_with_line, {})
|
|
vim.api.nvim_create_user_command('CopyAbsPathWithLine', copy_abs_path_with_line, {})
|
|
|
|
vim.api.nvim_create_user_command('ReverseLinesOder', function ()
|
|
-- https://superuser.com/questions/189947/how-do-i-reverse-selected-lines-order-in-vim
|
|
-- step 1: select lines
|
|
-- 2: hit :
|
|
-- 3: type !tac
|
|
-- 4: profit
|
|
print("select lines : then !tac")
|
|
end, {})
|
|
|
|
-- PATCH: in order to address the message:
|
|
-- vim.treesitter.query.get_query() is deprecated, use vim.treesitter.query.get() instead. :help deprecated
|
|
-- This feature will be removed in Nvim version 0.10
|
|
local orig_notify = vim.notify
|
|
local filter_notify = function(text, level, opts)
|
|
-- more specific to this case
|
|
if type(text) == "string" and (string.find(text, "get_query", 1, true) or string.find(text, "get_node_text", 1, true)) then
|
|
-- for all deprecated and stack trace warnings
|
|
-- if type(text) == "string" and (string.find(text, ":help deprecated", 1, true) or string.find(text, "stack trace", 1, true)) then
|
|
return
|
|
end
|
|
orig_notify(text, level, opts)
|
|
end
|
|
vim.notify = filter_notify
|
|
|
|
-- Check for POPEQUER notebook env var
|
|
-- launch the popequer lua file
|
|
local popequer_enabled = str2bool(os.getenv("POPEQUER_ENABLED"))
|
|
if popequer_enabled then
|
|
require "popequer"
|
|
end
|
|
|
|
vim.cmd("set wrap")
|