diff options
Diffstat (limited to 'lua/user')
| -rw-r--r-- | lua/user/keys.lua | 472 | ||||
| -rw-r--r-- | lua/user/mods.lua | 1065 | ||||
| -rw-r--r-- | lua/user/opts.lua | 351 | ||||
| -rw-r--r-- | lua/user/pack.lua | 403 | ||||
| -rw-r--r-- | lua/user/view.lua | 69 |
5 files changed, 0 insertions, 2360 deletions
diff --git a/lua/user/keys.lua b/lua/user/keys.lua deleted file mode 100644 index 87d852b..0000000 --- a/lua/user/keys.lua +++ /dev/null @@ -1,472 +0,0 @@ -local keymap = vim.keymap -local map = function(mode, l, r, opts) - opts = opts or {} - opts.silent = true - opts.noremap = true - keymap.set(mode, l, r, opts) -end -local term_opts = { noremap = true, silent = false } -local mods = require("user.mods") -local bufnr = vim.api.nvim_get_current_buf() - --- Semi-colon as leader key -vim.g.mapleader = ";" - --- "jk" and "kj" to exit insert-mode -map("i", "jk", "<esc>") - --- Jump to next match on line using `.` instead of `;` NOTE: commented out in favour of "ggandor/flit.nvim" ---map("n", ".", ";") - --- Repeat last command using `<Space>` instead of `.` NOTE: commented out in favour of "ggandor/flit.nvim" ---map("n", "<Space>", ".") - --- Reload nvim config -map("n", "<leader><CR>", - "<cmd>luafile ~/.config/nvim/init.lua<CR> | :echom ('Nvim config loading...') | :sl! | echo ('')<CR>") - ---------------- Extended Operations --------------- --- Conditional 'q' to quit on floating/quickfix/help windows otherwise still use it for macros --- TODO: Have a list of if available on system/packages, example "Zen Mode" to not work on it (quit Zen Mode) -map("n", "q", function() - local config = vim.api.nvim_win_get_config(0) - if config.relative ~= "" then -- is_floating_window? - return ":silent! close!<CR>" - elseif vim.o.buftype == "quickfix" then - return ":quit<CR>" - elseif vim.o.buftype == "help" then - return ":close<CR>" - else - return "q" - end -end, { expr = true, replace_keycodes = true }) - --- Edit new file -map("n", "<leader>;", [[:e <C-R>=expand("%:h")..'/'<CR>]], { noremap = true, silent = true, desc = "New file" }) - --- Write as sudo -map("c", "W", "exe 'w !sudo tee >/dev/null %:p:S' | setl nomod", { silent = true, desc = "Write as Sudo" }) - --- Combine buffers list with buffer name -map("n", "<Leader>b", ":buffers<CR>:buffer<Space>") - --- Buffer confirmation -map("n", "<leader>y", ":BufferPick<CR>") - --- Map buffer next, prev and delete to <leader>+(n/p/d) respectively and tab/s-tab -map("n", "<leader>n", ":bn<cr>") -map("n", "<leader>p", ":bp<cr>") -map("n", "<leader>d", ":bd<cr>") -map("n", "<TAB>", ":bnext<CR>") -map("n", "<S-TAB>", ":bprevious<CR>") - --- Delete file of current buffer -map("n", "<leader>rm", "<CMD>call delete(expand('%')) | bdelete!<CR>") - --- List marks -map("n", "<Leader>m", ":marks<CR>") - --- Messages -map("n", "<Leader>M", ":messages<CR>") - ---- Clear messages or just refresh/redraw the screen -map("n", "<leader>i", "<cmd>lua require('notify').dismiss()<CR>") - --- Unsets the 'last search pattern' register by hitting return ---map("n", "<CR>", "!silent :noh<CR><CR>") - --- Toggle set number -map("n", "<leader>$", ":NumbersToggle<CR>") -map("n", "<leader>%", ":NumbersOnOff<CR>") - --- Easier split navigations, just ctrl-j instead of ctrl-w then j -map("t", "<C-[>", "<C-\\><C-N>") -map("t", "<C-h>", "<C-\\><C-N><C-h>") -map("t", "<C-j>", "<C-\\><C-N><C-j>") -map("t", "<C-k>", "<C-\\><C-N><C-k>") -map("t", "<C-l>", "<C-\\><C-N><C-l>") - --- Split window -map("n", "<leader>-", ":split<CR>") -map("n", "<leader>\\", ":vsplit<CR>") -map("n", "<leader>c", "<C-w>c") - --- Resize Panes ---map('n', '<Leader>+', ':resize +5<CR>') ---map('n', '<Leader>-', ':resize -5<CR>') -map("n", "<Leader><", ":vertical resize +5<CR>") -map("n", "<Leader>>", ":vertical resize -5<CR>") -map("n", "<Leader>=", "<C-w>=") - --- Map Alt+(h/j/k/l) in insert(include terminal/command) mode to move directional -map({ "i", "t", "c" }, "<A-h>", "<left>") -map({ "i", "t", "c" }, "<A-j>", "<down>") -map({ "i", "t", "c" }, "<A-k>", "<up>") -map({ "i", "t", "c" }, "<A-l>", "<right>") - --- Create tab, edit and move between them -map("n", "<C-T>n", ":tabnew<CR>") -map("n", "<C-T>e", ":tabedit") -map("n", "<leader>[", ":tabprev<CR>") -map("n", "<leader>]", ":tabnext<CR>") - --- "Zoom" a split window into a tab and/or close it ---map("n", "<Leader>,", ":tabnew %<CR>") ---map("n", "<Leader>.", ":tabclose<CR>") - --- Vim TABs -map("n", "<leader>1", "1gt<CR>") -map("n", "<leader>2", "2gt<CR>") -map("n", "<leader>3", "3gt<CR>") -map("n", "<leader>4", "4gt<CR>") -map("n", "<leader>5", "5gt<CR>") -map("n", "<leader>6", "6gt<CR>") -map("n", "<leader>7", "7gt<CR>") -map("n", "<leader>8", "8gt<CR>") -map("n", "<leader>9", "9gt<CR>") -map("n", "<leader>0", "10gt<CR>") - --- Hitting ESC when inside a terminal to get into normal mode ---map("t", "<Esc>", [[<C-\><C-N>]]) - --- Move block (indentation) easily ---map("n", "<", "<<", term_opts) ---map("n", ">", ">>", term_opts) ---map("x", "<", "<gv", term_opts) ---map("x", ">", ">gv", term_opts) -map("v", "<", "<gv") -map("v", ">", ">gv") -map("n", "<", "<S-v><<esc>") -map("n", ">", "<S-v>><esc>") - --- Set alt+(j/k) to switch lines of texts or simply move them -map("n", "<A-k>", ':let save_a=@a<Cr><Up>"add"ap<Up>:let @a=save_a<Cr>') -map("n", "<A-j>", ':let save_a=@a<Cr>"add"ap:let @a=save_a<Cr>') - --- Toggle Diff -map("n", "<leader>df", "<Cmd>call utils#ToggleDiff()<CR>") - --- Toggle Verbose -map("n", "<leader>uvt", "<Cmd>call utils#VerboseToggle()<CR>") - --- Jump List -map("n", "<leader>j", "<Cmd>call utils#GotoJump()<CR>") - --- Rename file -map("n", "<leader>rf", "<Cmd>call utils#RenameFile()<CR>") - --- Map delete to Ctrl+l -map("i", "<C-l>", "<Del>") - --- Clear screen -map("n", "<leader><C-l>", "<Cmd>!clear<CR>") - --- Change file to an executable -map("n", "<Leader>x", - ":lua require('user.mods').Toggle_executable()<CR> | :echom ('Toggle executable')<CR> | :sl! | echo ('')<CR>") --- map("n", "<leader>x", ":!chmod +x %<CR>") - --- Paste without replace clipboard -map("v", "p", '"_dP') - --- Swap two pieces of text, use x to cut in visual mode, then use Ctrl-x in --- visual mode to select text to swap with ---map("v", "<C-X>", "<Esc>`.``gvP``P") - --- Change Working Directory to current project -map("n", "<leader>cd", ":cd %:p:h<CR>:pwd<CR>") - --- Open the current file in the default program (on Mac this should just be just `open`) -map("n", "<leader>o", ":!xdg-open %<cr><cr>") - --- URL handling -if vim.fn.has("mac") == 1 then - map("", "gx", '<Cmd>call jobstart(["open", expand("<cfile>")], {"detach": v:true})<CR>', {}) -elseif vim.fn.has("unix") == 1 then - map("", "gx", '<Cmd>call jobstart(["xdg-open", expand("<cfile>")], {"detach": v:true})<CR>', {}) -elseif vim.fn.has("wsl") == 1 then - map("", "gx", '<Cmd>call jobstart(["wslview", expand("<cfile>")], {"detach": v:true})<CR>', {}) -else - map[""].gx = { '<Cmd>lua print("Error: gx is not supported on this OS!")<CR>' } -end - --- Search and replace -map("v", "<leader>sr", 'y:%s/<C-r><C-r>"//g<Left><Left>c') - --- Substitute globally and locally in the selected region. -map("n", "<leader>s", ":%s//g<Left><Left>") -map("v", "<leader>s", ":s//g<Left><Left>") - --- Toggle completion -map("n", "<Leader>tc", ':lua require("user.mods").toggle_completion()<CR>') - --- Disable default completion. -map("i", "<C-n>", "<Nop>") -map("i", "<C-p>", "<Nop>") - --- Set line wrap -map("n", "<M-z>", function() - local wrap_status = vim.api.nvim_exec("set wrap ?", true) - - if wrap_status == "nowrap" then - vim.api.nvim_command("set wrap linebreak") - print("Wrap enabled") - else - vim.api.nvim_command("set wrap nowrap") - print("Wrap disabled") - end -end, { silent = true }) - --- Toggle between folds -map("n", "<Space>", "&foldlevel ? 'zM' : 'zR'", { expr = true }) - --- Use space to toggle fold ---map("n", "<Space>", "za") - --- Make a copy of current file ---vim.cmd([[ --- map <leader>s :up \| saveas! %:p:r-<C-R>=strftime("%y.%m.%d-%H:%M")<CR>-bak.<C-R>=expand("%:e")<CR> \| 3sleep \| e #<CR> ---]]) -map("n", "<leader>.b", ":!cp % %.backup<CR>") - --- Toggle transparency -map("n", "<leader>tb", ":call utils#Toggle_transparent_background()<CR>") - --- Toggle zoom -map("n", "<leader>z", ":call utils#ZoomToggle()<CR>") -map("n", "<C-w>z", "<C-w>|<C-w>_") - --- Toggle statusline -map("n", "<leader>sl", ":call utils#ToggleHiddenAll()<CR>") - --- Open last closed buffer -map("n", "<C-t>", ":call OpenLastClosed()<CR>") - ----------------- Plugin Operations ---------------- --- Packer -map("n", "<leader>Pc", "<cmd>PackerCompile<cr>") -map("n", "<leader>Pi", "<cmd>PackerInstall<cr>") -map("n", "<leader>Ps", "<cmd>PackerSync<cr>") -map("n", "<leader>PS", "<cmd>PackerStatus<cr>") -map("n", "<leader>Pu", "<cmd>PackerUpdate<cr>") - --- Tmux navigation (aserowy/tmux.nvim) -map("n", "<C-h>", "<CMD>NavigatorLeft<CR>") -map("n", "<C-l>", "<CMD>NavigatorRight<CR>") -map("n", "<C-k>", "<CMD>NavigatorUp<CR>") -map("n", "<C-j>", "<CMD>NavigatorDown<CR>") - --- ToggleTerm -map({ "n", "t" }, "<leader>tt", "<cmd>ToggleTerm<CR>") -map({ "n", "t" }, "<leader>th", "<cmd>lua Horizontal_term_toggle()<CR>") -map({ "n", "t" }, "<leader>tv", "<cmd>lua Vertical_term_toggle()<CR>") - --- LazyGit -map({ "n", "t" }, "<leader>gg", "<cmd>lua Lazygit_toggle()<CR>") - -map("n", "<leader>tg", "<cmd>lua Gh_dash()<CR>") - --- Fugitive git bindings -map("n", "<leader>gs", vim.cmd.Git) -map("n", "<leader>ga", ":Git add %:p<CR><CR>") ---map("n", "<leader>gs", ":Gstatus<CR>") -map("n", "<leader>gc", ":Gcommit -v -q<CR>") -map("n", "<leader>gt", ":Gcommit -v -q %:p<CR>") ---map("n", "<leader>gd", ":Gdiff<CR>") -map("n", "<leader>ge", ":Gedit<CR>") ---map("n", "<leader>gr", ":Gread<Cj>") -map("n", "<leader>gw", ":Gwrite<CR><CR>") -map("n", "<leader>gl", ":silent! Glog<CR>:bot copen<CR>") ---map("n", "<leader>gp", ":Ggrep<Space>") ---map("n", "<Leader>gp", ":Git push<CR>") ---map("n", "<Leader>gb", ":Gblame<CR>") -map("n", "<leader>gm", ":Gmove<Space>") ---map("n", "<leader>gb", ":Git branch<Space>") ---map("n", "<leader>go", ":Git checkout<Space>") ---map("n", "<leader>gps", ":Dispatch! git push<CR>") ---map("n", "<leader>gpl", ":Dispatch! git pull<CR>") - --- Telescope -map("n", "<leader>ff", ":cd %:p:h<CR>:pwd<CR><cmd>lua require('telescope.builtin').find_files()<cr>") -- find files with hidden option -map("n", "<leader>fF", ":cd %:p:h<CR>:pwd<CR><cmd>lua require('user.mods').findFilesInCwd()<CR>", - { noremap = true, silent = true, desc = "Find files in cwd" }) -map("n", "<leader>f.", function() - require("telescope.builtin").find_files({ hidden = true, no_ignore = true }) -end) -- find all files -map("n", "<leader>fg", "<cmd>lua require('telescope.builtin').live_grep()<cr>") -map("n", "<leader>fb", "<cmd>lua require('telescope.builtin').buffers()<cr>") -map("n", "<leader>fh", "<cmd>lua require('telescope.builtin').help_tags()<cr>") -map("n", "<leader>fc", "<cmd>lua require('telescope.builtin').commands()<cr>") -map("n", "<leader>cf", "<cmd>Telescope changed_files<cr>") -map("n", "<leader>fp", "<cmd>Telescope pickers<cr>") -map("n", "<leader>fd", "<cmd>lua require('telescope.builtin').diagnostics()<cr>") -map("n", "<leader>fk", "<cmd>lua require('telescope.builtin').keymaps()<cr>") -map("n", "<leader>fr", "<cmd>lua require('telescope.builtin').registers({})<CR>") -- registers picker -map("n", "<leader>fm", "<cmd>lua require('telescope').extensions.media_files.media_files({})<cr>") -- find media files -map("n", "<leader>fi", "<cmd>lua require('telescope').extensions.notify.notify({})<cr>") -- find notifications -map("n", "<Leader>fs", '<cmd>lua require("session-lens").search_session()<CR>') -map("n", "<leader>ffd", [[<Cmd>lua require'plugins.telescope'.find_dirs()<CR>]]) -- find dies -map("n", "<leader>ff.", [[<Cmd>lua require'plugins.telescope'.find_configs()<CR>]]) -- find configs -map("n", "<leader>ffs", [[<Cmd>lua require'plugins.telescope'.find_scripts()<CR>]]) -- find scripts -map("n", "<leader>ffw", [[<Cmd>lua require'plugins.telescope'.find_projects()<CR>]]) -- find projects -map("n", "<leader>ffb", [[<Cmd>lua require'plugins.telescope'.find_books()<CR>]]) -- find books -map("n", "<leader>ffn", [[<Cmd>lua require'plugins.telescope'.find_notes()<CR>]]) -- find notes -map("n", "<leader>fgn", [[<Cmd>lua require'plugins.telescope'.grep_notes()<CR>]]) -- search notes -map("n", "<Leader>frf", "<cmd>lua require('telescope').extensions.recent_files.pick()<CR>") -map("n", "<leader>ffc", "<cmd>lua require('telescope.builtin').current_buffer_fuzzy_find()<cr>") -map("n", "<Leader>f/", "<cmd>lua require('telescope').extensions.file_browser.file_browser()<CR>") ---map("n", "<leader>f/", "<cmd>lua require('plugins.telescope').curbuf()<cr>") -- find files with hidden option --- Map a shortcut to open the picker. - --- FZF -map("n", "<leader>fz", "<cmd>lua require('fzf-lua').files()<CR>") - --- Nvim-tree -map("n", "<leader>e", "<cmd>Rooter<CR>:NvimTreeToggle<CR>", {}) - --- Undotree -map("n", "<leader>u", vim.cmd.UndotreeToggle) - --- Markdown-preview -map("n", "<leader>md", "<Plug>MarkdownPreviewToggle") -map("n", "<leader>mg", "<CMD>Glow<CR>") - --- Autopairs -map("n", "<leader>ww", "<cmd>lua require('user.mods').Toggle_autopairs()<CR>") - --- Zen-mode toggle -map("n", "<leader>zm", "<CMD>ZenMode<CR> | :echom ('Zen Mode')<CR> | :sl! | echo ('')<CR>") - --- Vim-rooter -map("n", "<leader>ro", "<CMD>Rooter<CR> | :echom ('cd to root/project directory')<CR> | :sl! | echo ('')<CR>", term_opts) - --- Trouble (UI to show diagnostics) -map("n", "<leader>t", ":cd %:p:h<CR>:pwd<CR><CMD>TroubleToggle<CR>") -map("n", "<leader>tw", ":cd %:p:h<CR>:pwd<CR><CMD>TroubleToggle workspace_diagnostics<CR>") -map("n", "<leader>td", ":cd %:p:h<CR>:pwd<CR><CMD>TroubleToggle document_diagnostics<CR>") -map("n", "<leader>tq", ":cd %:p:h<CR>:pwd<CR><CMD>TroubleToggle quickfix<CR>") -map("n", "<leader>tl", ":cd %:p:h<CR>:pwd<CR><CMD>TroubleToggle loclist<CR>") -map("n", "gR", "<CMD>TroubleToggle lsp_references<CR>") - --- Null-ls -map("n", "<leader>ls", "<CMD>NullLsToggle<CR>") - --- Replacer -map("n", "<Leader>qr", ':lua require("replacer").run()<CR>') - --- Quickfix -map("n", "<leader>q", function() - if vim.fn.getqflist({ winid = 0 }).winid ~= 0 then - require("plugins.quickfix").close() - else - require("plugins.quickfix").open() - end -end, { desc = "Toggle quickfix window" }) - --- Move to the next and previous item in the quickfixlist -map("n", "]c", "<Cmd>cnext<CR>") -map("n", "[c", "<Cmd>cprevious<CR>") - --- Location list -map("n", "<leader>l", '<cmd>lua require("plugins.loclist").loclist_toggle()<CR>') - --- Dap (debugging) -local dap_ok, dap = pcall(require, "dap") -local dap_ui_ok, ui = pcall(require, "dapui") - -if not (dap_ok and dap_ui_ok) then - require("notify")("nvim-dap or dap-ui not installed!", "warning") - return -end - -vim.fn.sign_define("DapBreakpoint", { text = "๐" }) - --- Start debugging session -map("n", "<leader>ds", function() - dap.continue() - ui.toggle({}) - vim.api.nvim_feedkeys(vim.api.nvim_replace_termcodes("<C-w>=", false, true, true), "n", false) -- Spaces buffers evenly -end) - --- Set breakpoints, get variable values, step into/out of functions, etc. -map("n", "<leader>dC", dap.continue) --- map("n", "<leader>dC", dap.close) --- map("n", "<leader>dt", dap.terminate) -map("n", "<leader>dt", ui.toggle) -map("n", "<leader>dd", function() - dap.disconnect({ terminateDebuggee = true }) -end) -map("n", "<leader>dn", dap.step_over) -map("n", "<leader>di", dap.step_into) -map("n", "<leader>do", dap.step_out) -map("n", "<leader>db", dap.toggle_breakpoint) -map("n", "<leader>dB", function() - dap.clear_breakpoints() - require("notify")("Breakpoints cleared", "warn") -end) -map("n", "<leader>dl", require("dap.ui.widgets").hover) -map("n", "<leader>de", function() - require("dapui").float_element() -end, { desc = "Open Element" }) -map("n", "<leader>dq", function() - require("dapui").close() - require("dap").repl.close() - local session = require("dap").session() - if session then - require("dap").terminate() - end - require("nvim-dap-virtual-text").refresh() -end, { desc = "Terminate Debug" }) -map("n", "<leader>dc", function() - require("telescope").extensions.dap.commands() -end, { desc = "DAP-Telescope: Commands" }) ---vim.keymap.set("n", "<leader>B", ":lua require'dap'.set_breakpoint(vim.fn.input('Breakpoint condition: '))<CR>") ---vim.keymap.set("v", "<leader>B", ":lua require'dap'.set_breakpoint(vim.fn.input('Breakpoint condition: '))<CR>") ---vim.keymap.set("n", "<leader>lp", ":lua require'dap'.set_breakpoint(nil, nil, vim.fn.input('Log point message: '))<CR>") ---vim.keymap.set("n", "<leader>dr", ":lua require'dap'.repl.open()<CR>") - --- Close debugger and clear breakpoints ---map("n", "<leader>de", function() --- dap.clear_breakpoints() --- ui.toggle({}) --- dap.terminate() --- vim.api.nvim_feedkeys(vim.api.nvim_replace_termcodes("<C-w>=", false, true, true), "n", false) --- require("notify")("Debugger session ended", "warn") ---end) - --- Toggle Dashboard -map("n", "<leader><Space>", '<CMD>lua require("user.mods").toggle_dashboard()<CR>') - --- Lsp Lines toggle -map("", "<Leader>ll", require("lsp_lines").toggle, { desc = "Toggle lsp_lines" }) - --- SnipRun -map({ "n", "v" }, "<leader>r", "<Plug>SnipRun<CR>") - --- Codi -map("n", "<leader>co", '<CMD>lua require("user.mods").toggleCodi()<CR>') - --- Scratch buffer -map("n", "<leader>ss", '<CMD>lua require("user.mods").Scratch("float")<CR>') -map("n", "<leader>sh", '<CMD>lua require("user.mods").Scratch("horizontal")<CR>') -map("n", "<leader>sv", '<CMD>lua require("user.mods").Scratch("vertical")<CR>') - --- Hardtime -map("n", "<leader>H", '<CMD>lua require("plugins.hardtime").ToggleHardtime()<CR>') - --- Code Run -map("n", "<leader>rr", '<CMD>lua require("user.mods").toggleCodeRunner()<CR>') - --- Run executable file -map("n", "<leader>rx", - ":lua require('user.mods').RunCurrentFile()<CR>:echom 'Running executable file...'<CR>:sl!<CR>:echo ''<CR>") - --- Close all floating windows -map({ "n", "t", "c" }, "<leader>w", "<CMD>CloseFloatingWindows<CR>") - --- Vimtex -map("n", "<Leader>lc", ":VimtexCompile<cr>") -map("v", "<Leader>ls", ":VimtexCompileSelected<cr>") -map("n", "<Leader>li", ":VimtexInfo<cr>") -map("n", "<Leader>lt", ":VimtexTocToggle<cr>") -map("n", "<Leader>lv", ":VimtexView<cr>") diff --git a/lua/user/mods.lua b/lua/user/mods.lua deleted file mode 100644 index c20c687..0000000 --- a/lua/user/mods.lua +++ /dev/null @@ -1,1065 +0,0 @@ -local M = {} - ---- Shorten Function Names -local fn = vim.fn -function M.executable(name) - if fn.executable(name) > 0 then - return true - end - - return false -end - --------------------------------------------------- - ---- Check whether a feature exists in Nvim ---- @feat: string ---- the feature name, like `nvim-0.7` or `unix`. ---- return: bool -M.has = function(feat) - if fn.has(feat) == 1 then - return true - end - - return false -end - --------------------------------------------------- - --- Format on save -local format_augroup = vim.api.nvim_create_augroup("LspFormatting", {}) -require("null-ls").setup({ - -- you can reuse a shared lspconfig on_attach callback here - on_attach = function(client, bufnr) - if client.supports_method("textDocument/formatting") then - vim.api.nvim_clear_autocmds({ group = format_augroup, buffer = bufnr }) - vim.api.nvim_create_autocmd("BufWritePre", { - group = format_augroup, - buffer = bufnr, - callback = function() - -- on 0.8, you should use vim.lsp.buf.format({ bufnr = bufnr }) instead - --vim.lsp.buf.formatting_seq_sync() - vim.lsp.buf.format({ bufnr = bufnr }) - end, - }) - end - end, -}) - -vim.cmd([[autocmd BufWritePre <buffer> lua vim.lsp.buf.format()]]) ---vim.cmd [[autocmd BufWritePre * lua vim.lsp.buf.format()]] - --------------------------------------------------- - ----Determine if a value of any type is empty ----@param item any ----@return boolean? -function M.empty(item) - if not item then - return true - end - local item_type = type(item) - if item_type == "string" then - return item == "" - end - if item_type == "number" then - return item <= 0 - end - if item_type == "table" then - return vim.tbl_isempty(item) - end - return item ~= nil -end - --------------------------------------------------- - ---- Create a dir if it does not exist -function M.may_create_dir(dir) - local res = fn.isdirectory(dir) - - if res == 0 then - fn.mkdir(dir, "p") - end -end - --------------------------------------------------- - ---- Toggle cmp completion -vim.g.cmp_toggle_flag = false -- initialize -local normal_buftype = function() - return vim.api.nvim_buf_get_option(0, "buftype") ~= "prompt" -end -M.toggle_completion = function() - local ok, cmp = pcall(require, "cmp") - if ok then - local next_cmp_toggle_flag = not vim.g.cmp_toggle_flag - if next_cmp_toggle_flag then - print("completion on") - else - print("completion off") - end - cmp.setup({ - enabled = function() - vim.g.cmp_toggle_flag = next_cmp_toggle_flag - if next_cmp_toggle_flag then - return normal_buftype - else - return next_cmp_toggle_flag - end - end, - }) - else - print("completion not available") - end -end - --------------------------------------------------- - ---- Make sure using latest neovim version -function M.get_nvim_version() - local actual_ver = vim.version() - - local nvim_ver_str = string.format("%d.%d.%d", actual_ver.major, actual_ver.minor, actual_ver.patch) - return nvim_ver_str -end - -function M.add_pack(name) - local status, error = pcall(vim.cmd, "packadd " .. name) - - return status -end - --------------------------------------------------- - --- Define a global function to retrieve LSP clients based on Neovim version -function M.get_lsp_clients(bufnr) - local mods = require("user.mods") - --local expected_ver = '0.10.0' - local nvim_ver = mods.get_nvim_version() - - local version_major, version_minor = string.match(nvim_ver, "(%d+)%.(%d+)") - version_major = tonumber(version_major) - version_minor = tonumber(version_minor) - - if version_major > 0 or (version_major == 0 and version_minor >= 10) then - return vim.lsp.get_clients({ buffer = bufnr }) - else - return vim.lsp.buf_get_clients() - end -end - --------------------------------------------------- - ---- Toggle autopairs on/off (requires "windwp/nvim-autopairs") -function M.Toggle_autopairs() - local ok, autopairs = pcall(require, "nvim-autopairs") - if ok then - if autopairs.state.disabled then - autopairs.enable() - print("autopairs on") - else - autopairs.disable() - print("autopairs off") - end - else - print("autopairs not available") - end -end - --------------------------------------------------- - ---- Make vim-rooter message disappear after making it's changes ---vim.cmd([[ ---let timer = timer_start(1000, 'LogTrigger', {}) ---func! LogTrigger(timer) --- silent! ---endfunc ---]]) --- ---vim.cmd([[ ---function! ConfigureChDir() --- echo ('') ---endfunction ---" Call after vim-rooter changes the root dir ---autocmd User RooterChDir :sleep! | call LogTrigger(timer) | call ConfigureChDir() ---]]) - -function M.findFilesInCwd() - vim.cmd("let g:rooter_manual_only = 1") -- Toggle the rooter plugin - require("plugins.telescope").findhere() - vim.defer_fn(function() - vim.cmd("let g:rooter_manual_only = 0") -- Change back to automatic rooter - end, 100) -end - ---function M.findFilesInCwd() --- vim.cmd("let g:rooter_manual_only = 1") -- Toggle the rooter plugin --- require("plugins.telescope").findhere() --- --vim.cmd("let g:rooter_manual_only = 0") -- Change back to automatic rooter ---end - --------------------------------------------------- - --- Toggle the executable permission -function M.Toggle_executable() - local current_file = vim.fn.expand("%:p") - local executable = vim.fn.executable(current_file) == 1 - - if executable then - -- File is executable, unset the executable permission - vim.fn.system("chmod -x " .. current_file) - --print(current_file .. ' is no longer executable.') - print("No longer executable") - else - -- File is not executable, set the executable permission - vim.fn.system("chmod +x " .. current_file) - --print(current_file .. ' is now executable.') - print("Now executable") - end -end - --------------------------------------------------- - --- Set bare dotfiles repository git environment variables dynamically - --- Set git enviornment variables ---function M.Set_git_env_vars() --- local git_dir_job = vim.fn.jobstart({ "git", "rev-parse", "--git-dir" }) --- local command_status = vim.fn.jobwait({ git_dir_job })[1] --- if command_status > 0 then --- vim.env.GIT_DIR = vim.fn.expand("$HOME/.cfg") --- vim.env.GIT_WORK_TREE = vim.fn.expand("~") --- else --- vim.env.GIT_DIR = nil --- vim.env.GIT_WORK_TREE = nil --- end --- -- Launch terminal emulator with Git environment variables set --- --require("toggleterm").exec(string.format([[%s %s]], os.getenv("SHELL"), "-i")) ---end - ------- - -local prev_cwd = "" - -function M.Set_git_env_vars() - local cwd = vim.fn.getcwd() - if prev_cwd == "" then - -- First buffer being opened, set prev_cwd to cwd - prev_cwd = cwd - elseif cwd ~= prev_cwd then - -- Working directory has changed since last buffer was opened - prev_cwd = cwd - local git_dir_job = vim.fn.jobstart({ "git", "rev-parse", "--git-dir" }) - local command_status = vim.fn.jobwait({ git_dir_job })[1] - if command_status > 0 then - vim.env.GIT_DIR = vim.fn.expand("$HOME/.cfg") - vim.env.GIT_WORK_TREE = vim.fn.expand("~") - else - vim.env.GIT_DIR = nil - vim.env.GIT_WORK_TREE = nil - end - end -end - -vim.cmd([[augroup my_git_env_vars]]) -vim.cmd([[ autocmd!]]) -vim.cmd([[ autocmd BufEnter * lua require('user.mods').Set_git_env_vars()]]) -vim.cmd([[ autocmd VimEnter * lua require('user.mods').Set_git_env_vars()]]) -vim.cmd([[augroup END]]) - --------------------------------------------------- - ---- Update Tmux Status Vi-mode -function M.update_tmux_status() - -- Check if the current buffer has a man filetype - if vim.bo.filetype == "man" then - return - end - local mode = vim.api.nvim_eval("mode()") - -- Determine the mode name based on the mode value - local mode_name - if mode == "n" then - mode_name = "-- NORMAL --" - elseif mode == "i" or mode == "ic" then - mode_name = "-- INSERT --" - else - mode_name = "-- NORMAL --" --'-- COMMAND --' - end - - -- Write the mode name to the file - local file = io.open(os.getenv("HOME") .. "/.vi-mode", "w") - file:write(mode_name) - file:close() - if nvim_running then - -- Neovim is running, update the mode file and refresh tmux - VI_MODE = "" -- Clear VI_MODE to show Neovim mode - vim.cmd("silent !tmux refresh-client -S") - end - ---- Force tmux to update the status - vim.cmd("silent !tmux refresh-client -S") -end - -vim.cmd([[ - augroup TmuxStatus - autocmd! - autocmd InsertLeave,InsertEnter * lua require("user.mods").update_tmux_status() - autocmd VimEnter * lua require("user.mods").update_tmux_status() - autocmd BufEnter * lua require("user.mods").update_tmux_status() - autocmd ModeChanged * lua require("user.mods").update_tmux_status() - autocmd WinEnter,WinLeave * lua require("user.mods").update_tmux_status() - augroup END -]]) - --- Add autocmd for <esc> --- Add autocmd to check when tmux switches panes/windows ---autocmd InsertLeave,InsertEnter * lua require("user.mods").update_tmux_status() ---autocmd BufEnter * lua require("user.mods").update_tmux_status() ---autocmd WinEnter,WinLeave * lua require("user.mods").update_tmux_status() - ---autocmd WinEnter,WinLeave * lua require("user.mods").update_tmux_status() ---autocmd VimResized * lua require("user.mods").update_tmux_status() ---autocmd FocusGained * lua require("user.mods").update_tmux_status() ---autocmd FocusLost * lua require("user.mods").update_tmux_status() ---autocmd CmdwinEnter,CmdwinLeave * lua require("user.mods").update_tmux_status() - --------------------------------------------------- - --- function OpenEmulatorList() --- local emulatorsBuffer = vim.api.nvim_create_buf(false, true) --- vim.api.nvim_buf_set_lines(emulatorsBuffer, 0, 0, true, {"Some text"}) --- vim.api.nvim_open_win( --- emulatorsBuffer, --- false, --- { --- relative='win', row=3, col=3, width=12, height=3 --- } --- ) --- end --- --- vim.api.nvim_create_user_command('OpenEmulators', OpenEmulatorList, {}) - ---local api = vim.api ---local fn = vim.fn ---local cmd = vim.cmd --- ---local function bufremove(opts) --- local target_buf_id = api.nvim_get_current_buf() --- --- -- Do nothing if buffer is in modified state. --- if not opts.force and api.nvim_buf_get_option(target_buf_id, 'modified') then --- return false --- end --- --- -- Hide target buffer from all windows. --- vim.tbl_map(function(win_id) --- win_id = win_id or 0 --- --- local current_buf_id = api.nvim_win_get_buf(win_id) --- --- api.nvim_win_call(win_id, function() --- -- Try using alternate buffer --- local alt_buf_id = fn.bufnr('#') --- if alt_buf_id ~= current_buf_id and fn.buflisted(alt_buf_id) == 1 then --- api.nvim_win_set_buf(win_id, alt_buf_id) --- return --- end --- --- -- Try using previous buffer --- cmd('bprevious') --- if current_buf_id ~= api.nvim_win_get_buf(win_id) then --- return --- end --- --- -- Create new listed scratch buffer --- local new_buf = api.nvim_create_buf(true, true) --- api.nvim_win_set_buf(win_id, new_buf) --- end) --- --- return true --- end, fn.win_findbuf(target_buf_id)) --- --- cmd(string.format('bdelete%s %d', opts.force and '!' or '', target_buf_id)) ---end --- ----- Assign bufremove to a global variable ---_G.bufremove = bufremove - ---vim.cmd([[ --- augroup NvimTreeDelete --- autocmd! --- autocmd FileType NvimTree lua require('user.mods').enew_on_delete() --- augroup END ---]]) --- ---function M.enew_on_delete() --- if vim.bo.buftype == 'nofile' then --- vim.cmd('enew') --- end ---end - --- Update Neovim ---function M.Update_neovim() --- -- Run the commands to download and extract the latest version --- os.execute("curl -L -o nvim-linux64.tar.gz https://github.com/neovim/neovim/releases/latest/download/nvim-linux64.tar.gz") --- os.execute("tar xzvf nvim-linux64.tar.gz") --- -- Replace the existing Neovim installation with the new version --- os.execute("rm -rf $HOME/.local/bin/nvim") --- os.execute("mv nvim-linux64 $HOME/.local/bin/nvim") --- --- -- Clean up the downloaded file --- os.execute("rm nvim-linux64.tar.gz") --- --- -- Print a message to indicate the update is complete --- print("Neovim has been updated to the latest version.") ---end --- ----- Bind a keymap to the update_neovim function (optional) ---vim.api.nvim_set_keymap('n', '<leader>u', '<cmd> lua require("user.mods").Update_neovim()<CR>', { noremap = true, silent = true }) - --- Define a function to create a floating window and run the update process inside it -function M.Update_neovim() - -- Create a new floating window - local bufnr, winid = vim.api.nvim_create_buf(false, true) - vim.api.nvim_open_win(bufnr, true, { - relative = "editor", - width = 80, - height = 20, - row = 2, - col = 2, - style = "minimal", - border = "single", - }) - - -- Function to append a line to the buffer in the floating window - local function append_line(line) - vim.api.nvim_buf_set_option(bufnr, "modifiable", true) - vim.api.nvim_buf_set_lines(bufnr, -1, -1, false, { line }) - vim.api.nvim_buf_set_option(bufnr, "modifiable", false) - end - - -- Download the latest version of Neovim - append_line("Downloading the latest version of Neovim...") - os.execute( - "curl -L -o nvim-linux64.tar.gz https://github.com/neovim/neovim/releases/latest/download/nvim-linux64.tar.gz") - append_line("Download complete.") - - -- Extract the downloaded archive - append_line("Extracting the downloaded archive...") - os.execute("tar xzvf nvim-linux64.tar.gz") - append_line("Extraction complete.") - - -- Replace the existing Neovim installation with the new version - append_line("Replacing the existing Neovim installation...") - os.execute("rm -rf $HOME/nvim") - os.execute("mv nvim-linux64 $HOME/nvim") - append_line("Update complete.") - - -- Clean up the downloaded file - append_line("Cleaning up the downloaded file...") - os.execute("rm nvim-linux64.tar.gz") - append_line("Cleanup complete.") - - -- Close the floating window after a delay - vim.defer_fn(function() - vim.api.nvim_win_close(winid, true) - end, 5000) -- Adjust the delay as needed -end - --- Bind a keymap to the update_neovim function (optional) -vim.api.nvim_set_keymap("n", "<leader>U", '<cmd> lua require("user.mods").Update_neovim()<CR>', - { noremap = true, silent = true }) - --------------------------------------------------- - --- Fix or suppress closing nvim error message (/src/unix/core.c:147: uv_close: Assertion `!uv__is_closing(handle)' failed.) -vim.api.nvim_create_autocmd({ "VimLeave" }, { - callback = function() - vim.fn.jobstart("!notify-send 2>/dev/null &", { detach = true }) - end, -}) - --------------------------------------------------- - --- Rooter ---vim.cmd([[autocmd BufEnter * lua vim.cmd('Rooter')]]) - --------------------------------------------------- - --- Nvim-tree -local modifiedBufs = function(bufs) -- nvim-tree is also there in modified buffers so this function filter it out - local t = 0 - for k, v in pairs(bufs) do - if v.name:match("NvimTree_", "NvimTree1") == nil then - t = t + 1 - end - end - return t -end - --- Deleting current file opened behaviour -function M.DeleteCurrentBuffer() - local cbn = vim.api.nvim_get_current_buf() - local buffers = vim.fn.getbufinfo({ buflisted = true }) - local size = #buffers - local idx = 0 - - for n, e in ipairs(buffers) do - if e.bufnr == cbn then - idx = n - break -- Exit loop as soon as we find the buffer - end - end - - if idx == 0 then - return - end - - if idx == size then - vim.cmd("bprevious") - else - vim.cmd("bnext") - end - - vim.cmd("silent! bdelete " .. cbn) - - -- Open a new blank window - vim.cmd("silent! enew") -- Opens a new vertical split - -- OR - -- vim.cmd("new") -- Opens a new horizontal split - -- Delay before opening a new split - --vim.defer_fn(function() - -- vim.cmd("enew") -- Opens a new vertical split - --end, 100) -- Adjust the delay as needed (in milliseconds) - -- Delay before closing the nvim-tree window -end - -vim.cmd([[autocmd FileType NvimTree lua require("user.mods").DeleteCurrentBuffer()]]) - --- On :bd nvim-tree should behave as if it wasn't opened -vim.api.nvim_create_autocmd("BufEnter", { - nested = true, - callback = function() - -- Only 1 window with nvim-tree left: we probably closed a file buffer - if #vim.api.nvim_list_wins() == 1 and require("nvim-tree.utils").is_nvim_tree_buf() then - local api = require("nvim-tree.api") - -- Required to let the close event complete. An error is thrown without this. - vim.defer_fn(function() - -- close nvim-tree: will go to the last buffer used before closing - api.tree.toggle({ find_file = true, focus = true }) - -- re-open nivm-tree - api.tree.toggle({ find_file = true, focus = true }) - -- nvim-tree is still the active window. Go to the previous window. - vim.cmd("wincmd p") - end, 0) - end - end, -}) - --- Dismiss notifications when opening nvim-tree window -local function isNvimTreeOpen() - local win = vim.fn.win_findbuf(vim.fn.bufnr("NvimTree")) - return vim.fn.empty(win) == 0 -end - -function M.DisableNotify() - if isNvimTreeOpen() then - require("notify").dismiss() - end -end - -vim.cmd([[ - autocmd! WinEnter,WinLeave * lua require('user.mods').DisableNotify() -]]) - --------------------------------------------------- - --- Toggle Dashboard -function M.toggle_dashboard() - if vim.bo.filetype == "dashboard" then - vim.cmd("bdelete") - else - vim.cmd("Dashboard") - end -end - --------------------------------------------------- - --- Helper function to suppress errors -local function silent_execute(cmd) - vim.fn["serverlist"]() -- Required to prevent 'Press ENTER' prompt - local result = vim.fn.system(cmd .. " 2>/dev/null") - vim.fn["serverlist"]() - return result -end - --------------------------------------------------- - --- Toggle Codi --- Define a global variable to track Codi's state -local is_codi_open = false - -function M.toggleCodi() - if is_codi_open then - -- Close Codi - vim.cmd("Codi!") - is_codi_open = false - print("Codi off") - else - -- Open Codi - vim.cmd("Codi") - is_codi_open = true - print("Codi on") - end -end - --------------------------------------------------- - ----- Function to create or toggle a scratch buffer --- Define global variables to store the scratch buffer and window -local scratch_buf = nil -local scratch_win = nil - --- Other global variables -local scratch_date = os.date("%Y-%m-%d") -local scratch_dir = vim.fn.expand("~/notes/private") -local scratch_file = "scratch-" .. scratch_date .. ".md" - --- Function to close and delete a buffer -function CloseAndDeleteBuffer(bufnr) - if bufnr and vim.api.nvim_buf_is_valid(bufnr) then - vim.api.nvim_command("silent! bwipe " .. bufnr) - end -end - -function M.Scratch(Split_direction) - -- Check if the directory exists, and create it if it doesn't - if vim.fn.isdirectory(scratch_dir) == 0 then - vim.fn.mkdir(scratch_dir, "p") - end - - -- Determine the window type based on Split_direction - local current_window_type = "float" - if Split_direction == "float" then - current_window_type = "float" - elseif Split_direction == "vertical" then - current_window_type = "vertical" - elseif Split_direction == "horizontal" then - current_window_type = "horizontal" - end - - local file_path = scratch_dir .. "/" .. scratch_file - - if scratch_win and vim.api.nvim_win_is_valid(scratch_win) then - -- Window exists, save buffer to file and close it - WriteScratchBufferToFile(scratch_buf, file_path) - vim.cmd(":w!") - vim.api.nvim_win_close(scratch_win, true) - CloseAndDeleteBuffer(scratch_buf) - scratch_win = nil - scratch_buf = nil - else - if scratch_buf and vim.api.nvim_buf_is_valid(scratch_buf) then - -- Buffer exists, reuse it and open a new window - OpenScratchWindow(scratch_buf, current_window_type) - else - -- Buffer doesn't exist, create it and load the file if it exists - scratch_buf = OpenScratchBuffer(file_path) - OpenScratchWindow(scratch_buf, current_window_type) - end - end -end - --- Function to write buffer contents to a file -function WriteScratchBufferToFile(buf, file_path) - if buf and vim.api.nvim_buf_is_valid(buf) then - local lines = vim.api.nvim_buf_get_lines(buf, 0, -1, false) - local content = table.concat(lines, "\n") - local escaped_file_path = vim.fn.fnameescape(file_path) - - -- Write the buffer content to the file - local file = io.open(escaped_file_path, "w") - if file then - file:write(content) - file:close() - end - end -end - --- Function to create or open the scratch buffer -function OpenScratchBuffer(file_path) - local buf = vim.api.nvim_create_buf(true, false) - - -- Set the file name for the buffer - local escaped_file_path = vim.fn.fnameescape(file_path) - vim.api.nvim_buf_set_name(buf, escaped_file_path) - - -- Check if the file exists and load it if it does - if vim.fn.filereadable(file_path) == 1 then - local file_contents = vim.fn.readfile(file_path) - vim.api.nvim_buf_set_lines(buf, 0, -1, true, file_contents) - else - -- Insert initial content - vim.api.nvim_buf_set_lines(buf, 0, -1, true, { - "# Quick Notes - " .. scratch_date, - "--------------------------", - "", - }) - - -- Save the initial content to the file - vim.cmd(":w") - end - - return buf -end - --- Function to open the scratch buffer in a window -function OpenScratchWindow(buf, current_window_type) - if buf and vim.api.nvim_buf_is_valid(buf) then - if current_window_type == "float" then - local opts = { - relative = "win", - width = 120, - height = 10, - border = "single", - row = 20, - col = 20, - } - scratch_win = vim.api.nvim_open_win(buf, true, opts) - -- Go to the last line of the buffer - vim.api.nvim_win_set_cursor(scratch_win, { vim.api.nvim_buf_line_count(buf), 1 }) - elseif current_window_type == "vertical" then - vim.cmd("vsplit") - vim.api.nvim_win_set_buf(0, buf) - scratch_win = 0 - elseif current_window_type == "horizontal" then - vim.cmd("split") - vim.api.nvim_win_set_buf(0, buf) - scratch_win = 0 - end - end -end - --------------------------------------------------- - --- Intercept file open -local augroup = vim.api.nvim_create_augroup("user-autocmds", { clear = true }) -local intercept_file_open = true -vim.api.nvim_create_user_command("InterceptToggle", function() - intercept_file_open = not intercept_file_open - local intercept_state = "`Enabled`" - if not intercept_file_open then - intercept_state = "`Disabled`" - end - vim.notify("Intercept file open set to " .. intercept_state, vim.log.levels.INFO, { - title = "Intercept File Open", - ---@param win integer The window handle - on_open = function(win) - vim.api.nvim_buf_set_option(vim.api.nvim_win_get_buf(win), "filetype", "markdown") - end, - }) -end, { desc = "Toggles intercepting BufNew to open files in custom programs" }) - --- NOTE: Add "BufReadPre" to the autocmd events to also intercept files given on the command line, e.g. --- `nvim myfile.txt` -vim.api.nvim_create_autocmd({ "BufNew" }, { - group = augroup, - callback = function(args) - ---@type string - local path = args.match - ---@type integer - local bufnr = args.buf - - ---@type string? The file extension if detected - local extension = vim.fn.fnamemodify(path, ":e") - ---@type string? The filename if detected - local filename = vim.fn.fnamemodify(path, ":t") - - ---Open a given file path in a given program and remove the buffer for the file. - ---@param buf integer The buffer handle for the opening buffer - ---@param fpath string The file path given to the program - ---@param fname string The file name used in notifications - ---@param prog string The program to execute against the file path - local function open_in_prog(buf, fpath, fname, prog) - vim.notify(string.format("Opening `%s` in `%s`", fname, prog), vim.log.levels.INFO, { - title = "Open File in External Program", - ---@param win integer The window handle - on_open = function(win) - vim.api.nvim_buf_set_option(vim.api.nvim_win_get_buf(win), "filetype", "markdown") - end, - }) - local mods = require("user.mods") - local nvim_ver = mods.get_nvim_version() - - local version_major, version_minor = string.match(nvim_ver, "(%d+)%.(%d+)") - version_major = tonumber(version_major) - version_minor = tonumber(version_minor) - - if version_major > 0 or (version_major == 0 and version_minor >= 10) then - vim.system({ prog, fpath }, { detach = true }) - else - vim.fn.jobstart({ prog, fpath }, { detach = true }) - end - vim.api.nvim_buf_delete(buf, { force = true }) - end - - local extension_callbacks = { - ["pdf"] = function(buf, fpath, fname) - open_in_prog(buf, fpath, fname, "zathura") - end, - ["epub"] = function(buf, fpath, fname) - open_in_prog(buf, fpath, fname, "zathura") - end, - ["mobi"] = "pdf", - ["png"] = function(buf, fpath, fname) - open_in_prog(buf, fpath, fname, "vimiv") - end, - ["jpg"] = "png", - ["mp4"] = function(buf, fpath, fname) - open_in_prog(buf, fpath, fname, "vlc") - end, - ["gif"] = "mp4", - } - - ---Get the extension callback for a given extension. Will do a recursive lookup if an extension callback is actually - ---of type string to get the correct extension - ---@param ext string A file extension. Example: `png`. - ---@return fun(bufnr: integer, path: string, filename: string?) extension_callback The extension callback to invoke, expects a buffer handle, file path, and filename. - local function extension_lookup(ext) - local callback = extension_callbacks[ext] - if type(callback) == "string" then - callback = extension_lookup(callback) - end - return callback - end - - if extension ~= nil and not extension:match("^%s*$") and intercept_file_open then - local callback = extension_lookup(extension) - if type(callback) == "function" then - callback(bufnr, path, filename) - end - end - end, -}) - --------------------------------------------------- - --- Delete [No Name] buffers -vim.api.nvim_create_autocmd("BufHidden", { - desc = "Delete [No Name] buffers", - callback = function(event) - if event.file == "" and vim.bo[event.buf].buftype == "" and not vim.bo[event.buf].modified then - vim.schedule(function() - pcall(vim.api.nvim_buf_delete, event.buf, {}) - end) - end - end, -}) - --------------------------------------------------- - -local codeRunnerEnabled = false - -function M.toggleCodeRunner() - codeRunnerEnabled = not codeRunnerEnabled - if codeRunnerEnabled then - print("Code Runner enabled") - M.RunCode() -- Execute when enabled - else - print("Code Runner disabled") - -- Close the terminal window when disabled - local buffers = vim.fn.getbufinfo() - - for _, buf in ipairs(buffers) do - local type = vim.api.nvim_buf_get_option(buf.bufnr, "buftype") - if type == "terminal" then - vim.api.nvim_command("silent! bdelete " .. buf.bufnr) - end - end - end -end - -local function substitute(cmd) - cmd = cmd:gsub("%%", vim.fn.expand("%")) - cmd = cmd:gsub("$fileBase", vim.fn.expand("%:r")) - cmd = cmd:gsub("$filePath", vim.fn.expand("%:p")) - cmd = cmd:gsub("$file", vim.fn.expand("%")) - cmd = cmd:gsub("$dir", vim.fn.expand("%:p:h")) - cmd = cmd:gsub("#", vim.fn.expand("#")) - cmd = cmd:gsub("$altFile", vim.fn.expand("#")) - - return cmd -end - -function M.RunCode() - if not codeRunnerEnabled then - print("Code Runner is currently disabled. Toggle it on to execute code.") - return - end - local file_extension = vim.fn.expand("%:e") - local selected_cmd = "" - local supported_filetypes = { - html = { - default = "%", - }, - c = { - default = "gcc % -o $fileBase && ./$fileBase", - debug = "gcc -g % -o $fileBase && ./$fileBase", - }, - cs = { - default = "dotnet run", - }, - cpp = { - default = "g++ % -o $fileBase && ./$fileBase", - debug = "g++ -g % -o ./$fileBase", - competitive = "g++ -std=c++17 -Wall -DAL -O2 % -o $fileBase && $fileBase<input.txt", - }, - py = { - default = "python %", - }, - go = { - default = "go run %", - }, - java = { - default = "java %", - }, - js = { - default = "node %", - debug = "node --inspect %", - }, - lua = { - default = "lua %", - }, - ts = { - default = "tsc % && node $fileBase", - }, - rs = { - default = "rustc % && $fileBase", - }, - php = { - default = "php %", - }, - r = { - default = "Rscript %", - }, - jl = { - default = "julia %", - }, - rb = { - default = "ruby %", - }, - pl = { - default = "perl %", - }, - } - - local term_cmd = "bot 10 new | term " - local choices = {} - - -- Add 'default' as the first option if available - if supported_filetypes[file_extension]["default"] then - table.insert(choices, "default") - end - - -- Add 'debug' as the second option if available - if supported_filetypes[file_extension]["debug"] then - table.insert(choices, "debug") - end - - -- Add other available options - for key, _ in pairs(supported_filetypes[file_extension]) do - if key ~= "default" and key ~= "debug" then - table.insert(choices, key) - end - end - if #choices == 0 then - vim.notify("It doesn't contain any command", vim.log.levels.WARN, { title = "Code Runner" }) - elseif #choices == 1 then - selected_cmd = supported_filetypes[file_extension][choices[1]] - vim.cmd(term_cmd .. substitute(selected_cmd)) - else - vim.ui.select(choices, { - prompt = "Choose a command: ", - layout_config = { - height = 10, - width = 40, - prompt_position = "top", - -- other options as required - }, - }, function(choice) - selected_cmd = supported_filetypes[file_extension][choice] - if selected_cmd then - vim.cmd(term_cmd .. substitute(selected_cmd)) - end - end) - end - - if not supported_filetypes[file_extension] then - vim.notify("The filetype isn't included in the list", vim.log.levels.WARN, { title = "Code Runner" }) - end -end - --------------------------------------------------- - --- Run executable file -local interpreters = { - python = "python", - lua = "lua", - bash = "bash", - zsh = "zsh", - perl = "perl", - ruby = "ruby", - node = "node", - rust = "rust", - php = "php", -} - -function M.RunCurrentFile() - local file_path = vim.fn.expand("%:p") - local file = io.open(file_path, "r") - - if not file then - print("Error: Unable to open the file") - return - end - - local shebang = file:read() - file:close() - - local interpreter = shebang:match("#!%s*(.-)$") - if not interpreter then - print("Error: No shebang line found in the file") - return - end - - -- Remove leading spaces and any arguments, extracting the interpreter name - interpreter = interpreter:gsub("^%s*([^%s]+).*", "%1") - - local cmd = interpreters[interpreter] - - if not cmd then - cmd = interpreter -- Set the command to the interpreter directly - end - - -- Run the file using the determined interpreter - vim.fn.jobstart(cmd .. " " .. file_path, { - cwd = vim.fn.expand("%:p:h"), - }) -end - --------------------------------------------------- - --- Close all floating windows -vim.api.nvim_create_user_command("CloseFloatingWindows", function(opts) - for _, window_id in ipairs(vim.api.nvim_list_wins()) do - -- If window is floating - if vim.api.nvim_win_get_config(window_id).relative ~= "" then - -- Force close if called with ! - vim.api.nvim_win_close(window_id, opts.bang) - end - end -end, { bang = true, nargs = 0 }) - --------------------------------------------------- - --- ... -return M diff --git a/lua/user/opts.lua b/lua/user/opts.lua deleted file mode 100644 index cc8debc..0000000 --- a/lua/user/opts.lua +++ /dev/null @@ -1,351 +0,0 @@ ---[[ opts.lua ]] - --- Environment ---vim.opt.shell = "zsh" -- -vim.o.updatetime = 250 -vim.o.shell = '/bin/zsh' -vim.scriptencoding = 'utf-8' -- -vim.opt.encoding = 'utf-8' -- -vim.opt.fileencoding = 'utf-8' -- -vim.g.python3_host_prog = '/usr/bin/python3' -- -vim.g.loaded_python3_provider = 1 -- -vim.g.sh_noisk = 1 -- iskeyword word boundaries when editing a 'sh' file -vim.o.autochdir = true ---vim.o.writeany= true - --- Clipboard -vim.opt.clipboard:append({ 'unnamedplus' }) -- Install xclip or this will slowdown startup - --- Behaviour -vim.opt.backspace = { 'start', 'eol', 'indent' } -- Make backspace work as you would expect. -vim.opt.hidden = true -- Switch between buffers without having to save first. -vim.opt.splitbelow = true -- make split put the new buffer below the current buffer -vim.opt.splitright = true -- make vsplit put the new buffer on the right of the current buffer -vim.opt.scrolloff = 8 -- -vim.opt.sidescrolloff = 8 -- how many lines to scroll when using the scrollbar -vim.opt.autoread = true -- reload files if changed externally -vim.opt.display = 'lastline' -- Show as much as possible of the last line. -vim.opt.inccommand = 'split' -- -vim.opt.ttyfast = true -- Faster redrawing. -vim.opt.lazyredraw = false -- Only redraw when necessary -vim.opt.keywordprg = ':help' -- :help options -vim.opt.ruler = true -- -vim.opt.errorbells = false -- -vim.opt.list = true -- Show non-printable characters. -vim.opt.showmatch = true -- -vim.opt.matchtime = 3 -- -vim.opt.showbreak = 'โช ' -- -vim.opt.linebreak = true -- -vim.opt.exrc = true -- ---vim.opt.autochdir = true -- or use this to use <:e> to create a file in current directory -vim.opt.autoread = true -- if a file is changed outside of vim, automatically reload it without asking ---vim.opt.notimeout = true -- Timeout on keycodes and not mappings -vim.opt.ttimeout = true -- Makes terminal vim work sanely -vim.opt.ttimeoutlen = 10 -- ---vim.opt.timeoutlen = 100 -- time to wait for a mapped sequence to complete (in milliseconds) ---vim.cmd([[set diffopt = vertical = true]]) -- diffs are shown side-by-side not above/below - --- Indent/tab -vim.opt.breakindent = true -- -vim.opt.autoindent = true -- Indent according to previous line. -vim.opt.copyindent = true -- Copy indent from the previous line -vim.opt.smarttab = false -- -vim.opt.tabstop = 2 -- -vim.opt.expandtab = true -- Indent according to previous line. ---vim.opt.expandtab = true -- Use spaces instead of tabs. -vim.opt.softtabstop = 2 -- Tab key indents by 2 spaces. -vim.opt.shiftwidth = 2 -- >> indents by 2 spaces. -vim.opt.shiftround = true -- >> indents to next multiple of 'shiftwidth'. -vim.opt.smartindent = true -- smart indent - --- Column/statusline/Cl -vim.opt.number = true -- -vim.opt.title = true -- ---vim.opt.colorcolumn = "+1" -- -vim.opt.signcolumn = 'yes:1' -- always show the sign column ---vim.opt.signcolumn = "yes:" .. vim.o.numberwidth ---vim.opt.signcolumn = "number" ---vim.opt.signcolumn = "no" -- -vim.opt.laststatus = 3 -- " Always show statusline. -vim.opt.showmode = true -- Show current mode in command-line, example: -- INSERT -- mode -vim.opt.showcmd = true -- Show the command in the status bar -vim.opt.cmdheight = 1 -- ---vim.opt.cmdheight = 0 -- -vim.opt.report = 0 -- Always report changed lines. ---local autocmd = vim.api.nvim_create_autocmd ---autocmd("bufenter", { --- pattern = "*", --- callback = function() --- if vim.bo.ft ~= "terminal" then --- vim.opt.statusline = "%!v:lua.require'ui.statusline'.run()" --- else --- vim.opt.statusline = "%#normal# " --- end --- end, ---}) ----- With vertical splits, the statusline would still show up at the ----- bottom of the split. A quick fix is to just set the statusline ----- to empty whitespace (it can't be an empty string because then ----- it'll get replaced by the default stline). ---vim.opt.stl = " " - --- Backup/undo/swap -local prefix = vim.env.XDG_CONFIG_HOME or vim.fn.expand('~/.config') ---vim.opt.undodir = os.getenv("HOME") .. "/.vim/undodir" -vim.opt.undodir = { prefix .. '/nvim/tmp/.undo//' } -vim.opt.directory = { prefix .. '/nvim/tmp/.swp//' } -vim.opt.backupdir = { prefix .. '/nvim/tmp/.backup//' } -vim.opt.undofile = true -- -vim.opt.swapfile = true -- -vim.opt.backup = true -- ---vim.opt.backupcopy = --- Add timestamp as extension for backup files -vim.api.nvim_create_autocmd('BufWritePre', { - group = vim.api.nvim_create_augroup('timestamp_backupext', { clear = true }), - desc = 'Add timestamp to backup extension', - pattern = '*', - callback = function() - vim.opt.backupext = '-' .. vim.fn.strftime('%Y%m%d%H%M') - end, -}) - --- Format ---vim.opt.textwidth = 80 -- -vim.opt.isfname:append('@-@') -vim.cmd([[let &t_Cs = "\e[4:3m"]]) -- Undercurl -vim.cmd([[let &t_Ce = "\e[4:0m"]]) -- -vim.opt.path:append({ '**' }) -- Finding files - Search down into subfolder -vim.cmd('set whichwrap+=<,>,[,],h,l') -- -vim.cmd([[set iskeyword+=-]]) -- ---vim.cmd([[set formatoptions-=cro]]) -- TODO: this doesn't seem to work -vim.opt.formatoptions = vim.opt.formatoptions - - 't' -- wrap with text width - + 'c' -- wrap comments - + 'r' -- insert comment after enter - - 'o' -- insert comment after o/O - - 'q' -- allow formatting of comments with gq - - 'a' -- format paragraphs - + 'n' -- recognized numbered lists - - '2' -- use indent of second line for paragraph - + 'l' -- long lines are not broken - + 'j' -- remove comment when joining lines -vim.opt.wrapscan = true -- " Searches wrap around end-of-file. ---vim.wo.number = true -- ---vim.opt.wrap = false -- No Wrap lines ---vim.opt.foldmethod = 'manual' -- ---vim.opt.foldmethod = "expr" -- -vim.opt.foldmethod = 'manual' -vim.opt.foldlevel = 3 -vim.opt.confirm = false ---vim.opt.shortmess:append("sI") ---vim.opt.shortmess = "a" ---vim.opt.shortmess = "sI" ---vim.o.shortmess = vim.o.shortmess:gsub('s', '') -vim.opt.shortmess = table.concat({ -- Use abbreviations and short messages in command menu line. - 'f', -- Use "(3 of 5)" instead of "(file 3 of 5)". - 'i', -- Use "[noeol]" instead of "[Incomplete last line]". - 'l', -- Use "999L, 888C" instead of "999 lines, 888 characters". - 'm', -- Use "[+]" instead of "[Modified]". - 'n', -- Use "[New]" instead of "[New File]". - 'r', -- Use "[RO]" instead of "[readonly]". - 'w', -- Use "[w]", "[a]" instead of "written", "appended". - 'x', -- Use "[dos]", "[unix]", "[mac]" instead of "[dos format]", "[unix format]", "[mac format]". - 'o', -- Overwrite message for writing a file with subsequent message. - 'O', -- Message for reading a file overwrites any previous message. - 's', -- Disable "search hit BOTTOM, continuing at TOP" such messages. - 't', -- Truncate file message at the start if it is too long. - 'T', -- Truncate other messages in the middle if they are too long. - 'I', -- Don't give the :intro message when starting. - 'c', -- Don't give ins-completion-menu messages. - 'F', -- Don't give the file info when editing a file. -}) -vim.opt.fillchars = { - horiz = 'โ', - horizup = 'โด', - horizdown = 'โฌ', - vert = 'โ', - vertleft = 'โค', - vertright = 'โ', - verthoriz = 'โผ', - foldopen = '๏', - foldsep = 'โ', - foldclose = '๏
', - fold = 'โ', - eob = ' ', - --diff = "โ", - diff = 'โ', - msgsep = 'โ', - --msgsep = "โพ", -} -vim.opt.listchars = { tab = 'โธ ', trail = 'ยท' } -- ---vim.opt.fillchars:append({ eob = " " }) -- remove the ~ from end of buffer -vim.opt.modeline = true -- -vim.opt.modelines = 3 -- modelines (comments that set vim options on a per-file basis) ---vim.opt.modelineexpr = true ---vim.opt.nofoldenable = true -- turn folding off ---vim.opt.foldenable = false -- turn folding off -vim.o.showtabline = 2 - --- Highlights -vim.opt.incsearch = true -- Highlight while searching with / or ?. -vim.opt.hlsearch = true -- Keep matches highlighted. -vim.opt.ignorecase = true -- ignore case in search patterns UNLESS /C or capital in search -vim.opt.smartcase = true -- smart case -vim.opt.synmaxcol = 200 -- Only highlight the first 200 columns. ---vim.opt.winblend = 30 ---vim.opt.winblend = 5 -vim.opt.wildoptions = 'pum' -- ---vim.opt.pumblend = 5 -- -vim.opt.pumblend = 12 -- ---vim.opt.pumblend=15 -vim.opt.pumheight = 10 -- pop up menu height - --- Better Completion -vim.opt.complete = { '.', 'w', 'b', 'u', 't' } -- ---vim.opt.completeopt = { "longest,menuone,preview" } -- -vim.opt.completeopt = { 'menu', 'menuone', 'noselect' } ---vim.opt.completeopt = { "menuone", "noselect" } -- mostly just for cmp ---vim.opt.completeopt = { "menu", "menuone", "noselect" } -- - --- Wildmenu completion -- -vim.opt.wildmenu = true -- -vim.opt.wildmode = { 'list:longest' } -- -vim.opt.wildignore:append({ '.hg', '.git', '.svn' }) -- Version control -vim.opt.wildignore:append({ '*.aux', '*.out', '*.toc' }) -- LaTeX intermediate files -vim.opt.wildignore:append({ '*.jpg', '*.bmp', '*.gif', '*.png', '*.jpeg' }) -- binary images -vim.opt.wildignore:append({ '*.o', '*.obj', '*.exe', '*.dll', '*.manifest' }) -- compiled object files -vim.opt.wildignore:append({ '*.spl' }) -- compiled spelling word lists -vim.opt.wildignore:append({ '*.sw?' }) -- Vim swap files -vim.opt.wildignore:append({ '*.DS_Store' }) -- OSX bullshit -vim.opt.wildignore:append({ '*.luac' }) -- Lua byte code -vim.opt.wildignore:append({ 'migrations' }) -- Django migrations -vim.opt.wildignore:append({ '*.pyc' }) -- Python byte code -vim.opt.wildignore:append({ '*.orig' }) -- Merge resolution files -vim.opt.wildignore:append({ '*/node_modules/*' }) -- - --- Shada -vim.opt.shada = "!,'1000,f1,<1000,s100,:1000,/1000,h" - --- Sessions -vim.opt.sessionoptions = 'blank,buffers,curdir,folds,help,tabpages,winsize,winpos,terminal' ---vim.opt.sessionoptions = "curdir,folds,help,options,tabpages,winsize,winpos,terminal,globals" -- ---vim.opt.sessionoptions = "buffers,curdir,folds,help,tabpages,winsize,winpos,terminal" ---vim.opt.sessionoptions:remove({ "blank", "buffers", "globals" }) - --- Netrw file tree -vim.g.netrw_browse_split = 0 -vim.g.netrw_banner = 0 -vim.g.netrw_winsize = 25 - --- " Load indent files, to automatically do language-dependent indenting. ---vim.cmd([[ --- "filetype plugin indent on ---]]) -vim.cmd('filetype plugin on') -vim.cmd('filetype indent off') - --- Let clipboard register be + -vim.cmd([[ - let g:clipbrdDefaultReg = '+' -]]) - ---vim.cmd([[ --- "autocmd BufEnter * :syntax sync fromstart --- "syntax enable --- "set nocompatible --- "autocmd FileType lua set comments=s1:---,m:--,ex:-- ---]]) - --- Fast macros without lazyredraw -vim.cmd([[ - set re=0 - nnoremap @ <cmd>execute "noautocmd norm! " . v:count1 . "@" . getcharstr()<cr> - xnoremap @ :<C-U>execute "noautocmd '<,'>norm! " . v:count1 . "@" . getcharstr()<cr> -]]) - --- Stop annoying auto commenting on new lines -vim.cmd([[ - augroup annoying - au! - au BufEnter * set fo-=c fo-=r fo-=o - augroup end -]]) - --- Cursorline -vim.cmd([[ " Only show cursorline in the current window and in normal mode - augroup cline - au! - au WinLeave,InsertEnter * set nocursorline - au WinEnter,InsertLeave * set cursorline - augroup END -]]) -vim.opt.cursorline = true -- -vim.opt.guicursor = 'i:ver100,r:hor100' -- - --- Trailing whitespace -vim.cmd([[ " Only show in insert mode - augroup trailing - au! - au InsertEnter * :set listchars-=trail:โด - au InsertLeave * :set listchars+=trail:โด - augroup END -]]) - --- Line Return -vim.cmd([[ " Return to the same line when we reopen a file - augroup line_return - au! - au BufReadPost * - \ if line("'\"") > 0 && line("'\"") <= line("$") | - \ execute 'normal! g`"zvzz' | - \ endif - augroup END -]]) - --- Enable mouse scrollback -vim.cmd([[ - set mouse=a - tnoremap <Esc> <C-\><C-n> - tnoremap <c-b> <c-\><c-n> - function! ClearTerminal() - set scrollback=1 - let &g:scrollback=1 - echo &scrollback - call feedkeys("\i") - call feedkeys("clear\<CR>") - call feedkeys("\<C-\>\<C-n>") - call feedkeys("\i") - sleep 100m - let &scrollback=s:scroll_value - endfunction -]]) - --- Yank to clipboard in Termux -if vim.fn.has('termux') == 1 then - local Job = require('plenary.job') - vim.api.nvim_create_autocmd('TextYankPost', { - pattern = '*', - callback = function() - Job:new({ - command = 'termux-clipboard-set', - writer = vim.fn.getreg('@'), - }):start() - end, - }) -end - -function GetTermuxClipboard() - if vim.fn.has('termux') == 1 then - local sysclip = vim.fn.system('termux-clipboard-get') - if sysclip ~= '@' then - vim.fn.setreg('@', sysclip) - end - end - return '' -end - -if vim.fn.has('termux') == 1 then - vim.cmd('autocmd TextYankPost * call GetTermuxClipboard()') - vim.cmd('noremap <expr> p Paste("p")') - vim.cmd('noremap <expr> P Paste("P")') -end diff --git a/lua/user/pack.lua b/lua/user/pack.lua deleted file mode 100644 index 7ed86db..0000000 --- a/lua/user/pack.lua +++ /dev/null @@ -1,403 +0,0 @@ -local fn = vim.fn - --------------------------------------------------- - --- Automatically install packer -local install_path = fn.stdpath("data") .. "/site/pack/packer/start/packer.nvim" -if fn.empty(fn.glob(install_path)) > 0 then - PACKER_BOOTSTRAP = fn.system({ - "git", - "clone", - "--depth", - "1", - "https://github.com/wbthomason/packer.nvim", - install_path, - }) - print("Installing packer, please close and reopen Neovim...") - vim.cmd([[packadd packer.nvim]]) -end - --------------------------------------------------- - --- Autocommand that reloads neovim whenever you save this file -vim.cmd([[ - augroup packer_user_config - autocmd! - autocmd BufWritePost pack.lua source <afile> | PackerSync - augroup end -]]) - --------------------------------------------------- - --- Use a protected call so don't error out on first use -local status_ok, packer = pcall(require, "packer") -if not status_ok then - return -end - --------------------------------------------------- - --- Have packer use a popup window and set a maximum number of jobs -packer.init({ - auto_reload_compiled = true, - --max_jobs = 90, - display = { - open_fn = function() - return require("packer.util").float({ border = "rounded" }) - end, - }, -}) - --------------------------------------------------- - --- Install plugins here -return packer.startup(function(use) - -- Defaults - use("wbthomason/packer.nvim") -- Have packer manage itself (package manager) - use("nvim-lua/plenary.nvim") -- Useful lua functions used by lots of plugins - use("lewis6991/impatient.nvim") -- Faster loading/startup times - - -- Tree-sitter - use({ "nvim-treesitter/nvim-treesitter", run = ":TSUpdate" }) -- For language parsing, examples: highlighting, folding, jumping, refactoring... - use("nvim-treesitter/nvim-treesitter-refactor") -- Refactor module for nvim-treesitter - - -- lsp - use("williamboman/mason.nvim") -- Package manager to install and manage LSP servers, DAP servers, linters and formatters - use("neovim/nvim-lspconfig") -- Collection of LSP configs - use("williamboman/mason-lspconfig.nvim") -- Bridges mason.nvim with nvim-lspconfig to help use them together - use({ - "https://git.sr.ht/~whynothugo/lsp_lines.nvim", - config = function() - require("lsp_lines").setup() - end, - }) - use("rmagatti/goto-preview") - - -- Debugger - use("mfussenegger/nvim-dap") -- Debug Adapter Protocol client implementation for Neovim - use("rcarriga/nvim-dap-ui") -- UI for nvim-dap - --use { "rcarriga/nvim-dap-ui", requires = {"mfussenegger/nvim-dap"} } - use("theHamsta/nvim-dap-virtual-text") - use("gabrielpoca/replacer.nvim") - use("jayp0521/mason-nvim-dap.nvim") - --use({ - -- "jayp0521/mason-nvim-dap.nvim", - -- config = function() - -- require("mason-nvim-dap").setup({ - -- automatic_installation = true, - -- ensure_installed = { "python", "cppdbg", "codelldb" }, - -- }) - -- end, - --}) - - -- Linters/Formatters - use("mhartington/formatter.nvim") - use("jay-babu/mason-null-ls.nvim") - --use({"jayp0521/mason-null-ls.nvim", - -- config = function() - -- require('mason-null-ls.nvim').setup({ - -- automatic_setup = true, - -- }) - -- end - --}) - use({ - "jose-elias-alvarez/null-ls.nvim", -- Provides LSP: linters, formatters, diagnostics, code actions and etc... - requires = { "jay-babu/mason-null-ls.nvim" }, - }) - - -- Completion - use("hrsh7th/nvim-cmp") -- Completion engine plugin - use("hrsh7th/cmp-nvim-lsp") -- Completion source for nvim-lsp - use("hrsh7th/cmp-buffer") -- Completion source for content of current buffer - use("hrsh7th/cmp-path") -- Completion source for paths - use("hrsh7th/cmp-cmdline") -- Completion source for command-line - use("petertriho/cmp-git") -- Completion source for git - use("tamago324/cmp-zsh") -- Completion source for zsh - use("f3fora/cmp-spell") -- Completion source for spell-checking - use("hrsh7th/cmp-calc") -- Completion source for math calculation - use("saadparwaiz1/cmp_luasnip") -- Completion source for snippets, specifically for luasnip - use("hrsh7th/cmp-nvim-lsp-signature-help") -- Completion source for displaying function signatures with the current parameter emphasized - use("rcarriga/cmp-dap") - - -- Snippets - use("L3MON4D3/LuaSnip") -- Snippet engine - use("rafamadriz/friendly-snippets") -- Collection of snippets to use - - -- Git - use("tpope/vim-fugitive") -- - --use("dinhhuy258/git.nvim") -- For git blame & browse - use("kdheepak/lazygit.nvim") -- Terminal UI for git commands - use("lewis6991/gitsigns.nvim") -- Git decorations - - -- File explorer/fuzzy finder - use("kyazdani42/nvim-tree.lua") -- File explorer - use("ibhagwan/fzf-lua") -- Fuzzy finder - use("ThePrimeagen/harpoon") - --use("nvim-telescope/telescope.nvim") -- Fuzzy finder with lots of features/extendabilities - use({ - "nvim-telescope/telescope.nvim", - branch = "0.1.x", - --config = function() - -- require('plugins.telescope').setup() - --end, - requires = { - "nvim-lua/plenary.nvim", - "nvim-telescope/telescope-live-grep-args.nvim", - "nvim-telescope/telescope-file-browser.nvim", - { "nvim-telescope/telescope-fzf-native.nvim", run = "make" }, - }, - }) - use({ "nvim-telescope/telescope-fzf-native.nvim", run = "make" }) -- Support fzf syntax/algorithm - use("nvim-telescope/telescope-ui-select.nvim") -- - use("nvim-telescope/telescope-project.nvim") -- - use("nvim-telescope/telescope-media-files.nvim") -- - use("nvim-telescope/telescope-file-browser.nvim") -- - use({ "nvim-telescope/telescope-symbols.nvim", after = "telescope.nvim" }) -- Search emoji(s) and other symbols - use("nvim-telescope/telescope-dap.nvim") - use("axkirillov/telescope-changed-files") -- - use("smartpde/telescope-recent-files") - use("rmagatti/auto-session") - use("rmagatti/session-lens") - - -- UX - use("folke/neodev.nvim") - use({ - "numToStr/Navigator.nvim", -- Navigate between Tmux and Nvim - config = function() - require("Navigator").setup() - end, - }) - use({ "tpope/vim-eunuch", cmd = { "Rename", "Delete", "Mkdir" } }) -- Handy unix commands inside Vim (Rename, Move etc.) - --use("tpope/vim-obsession") -- - use("tpope/vim-unimpaired") -- - --use("tpope/vim-surround") -- - use({ - "kylechui/nvim-surround", - tag = "*", -- Use for stability; omit to use `main` branch for the latest features - }) - --use("vimpostor/vim-tpipeline") -- - --use("nathom/filetype.nvim") -- - use("mbbill/undotree") - use({ - "myusuf3/numbers.vim", -- - vim.cmd("let g:numbers_exclude = ['dashboard']"), - }) - use("windwp/nvim-autopairs") -- - use("numToStr/Comment.nvim") -- - use("akinsho/toggleterm.nvim") -- - use("tweekmonster/startuptime.vim") -- - use("qpkorr/vim-bufkill") - use({ - "ggandor/leap.nvim", -- - config = function() - require("leap").add_default_mappings() - --require("leap").set_default_keymaps() - --vim.keymap.set('n', '-', '<Plug>(leap-forward)', {}) - --vim.keymap.set('n', '_', '<Plug>(leap-backward)', {}) - end, - }) - use({ - "ggandor/flit.nvim", -- - config = function() - require("flit").setup() - end, - }) - use("folke/which-key.nvim") -- - use("folke/zen-mode.nvim") -- - use("romainl/vim-cool") -- - use("antoinemadec/FixCursorHold.nvim") -- - use({ - "folke/trouble.nvim", - requires = "nvim-tree/nvim-web-devicons", - }) - use({ - "airblade/vim-rooter", -- - --vim.cmd("let g:rooter_change_directory_for_non_project_files = ''"), - --vim.cmd("let g:rooter_change_directory_for_non_project_files = 'current'") - }) - use({ "michaelb/sniprun", run = "bash ./install.sh" }) - use({ "stevearc/overseer.nvim" }) - --use("vim-test/vim-test") -- - --use({ - -- "rcarriga/vim-ultest", -- - -- requires = { "vim-test/vim-test" }, - -- run = ":UpdateRemotePlugins", - -- config = function() - -- require("plugins.ultest") - -- end, - --}) - --use({"rcarriga/neotest", - -- config = function() - -- require("neotest").setup() - --end, - --}) - use({ - "nvim-neotest/neotest", - requires = { - { - "nvim-neotest/neotest-python", - "nvim-neotest/neotest-plenary", - "nvim-neotest/neotest-vim-test", - }, - }, - }) - use("kawre/leetcode.nvim") - use("m4xshen/hardtime.nvim") - use({ - "luckasRanarison/nvim-devdocs", - config = function() - require("nvim-devdocs").setup() - end, - }) - - -- Colorschemes - use("bluz71/vim-nightfly-guicolors") - use("ayu-theme/ayu-vim") - use("joshdick/onedark.vim") - use("NTBBloodbath/doom-one.nvim") - use("nyngwang/nvimgelion") - use("projekt0n/github-nvim-theme") - use("folke/tokyonight.nvim") - use("ribru17/bamboo.nvim") - - -- UI - use("kyazdani42/nvim-web-devicons") -- - use("onsails/lspkind-nvim") -- - use({ "kevinhwang91/nvim-ufo", requires = "kevinhwang91/promise-async" }) -- Fold code - use("lukas-reineke/indent-blankline.nvim") - use({ - "luukvbaal/statuscol.nvim", - config = function() - local builtin = require("statuscol.builtin") - require("statuscol").setup({ - relculright = true, - segments = { - { text = { builtin.foldfunc }, click = "v:lua.ScFa" }, - { text = { "%s" }, click = "v:lua.ScSa" }, - { text = { builtin.lnumfunc, " " }, click = "v:lua.ScLa" }, - }, - }) - end, - }) - use({ - "glepnir/dashboard-nvim", - --event = 'VimEnter', - requires = { "nvim-tree/nvim-web-devicons" }, - }) - use("rcarriga/nvim-notify") -- Notification plugin - use("karb94/neoscroll.nvim") -- Faster/smooth scrolling - --use("MunifTanjim/prettier.nvim") -- Prettier plugin for Neovim's built-in LSP client - use({ - "norcalli/nvim-colorizer.lua", -- colorize hexa and rgb strings - cmd = { "ColorizerToggle", "ColorizerAttachToBuffer" }, - config = function() - require("colorizer").setup({ - --'*'; - user_default_options = { - RGB = true, - RRGGBB = true, - names = false, - RRGGBBAA = false, - css = false, - css_fn = true, - mode = "foreground", - }, - }) - end, - }) - use("MunifTanjim/nui.nvim") - use({ - "j-hui/fidget.nvim", - tag = "legacy", - }) -- UI to show nvim-lsp progress - use("metakirby5/codi.vim") - use({ - "simrat39/symbols-outline.nvim", -- - config = function() - require("symbols-outline").setup({ - auto_close = true, - }) - end, - }) - use({ - "kosayoda/nvim-lightbulb", -- - requires = "antoinemadec/FixCursorHold.nvim", - }) - use({ - "SmiteshP/nvim-navic", -- Statusline/Winbar component that uses LSP to show current code context - requires = "neovim/nvim-lspconfig", - }) - use({ - "rebelot/heirline.nvim", -- Statusline that is highly configurable - --requires = 'kyazdani42/nvim-web-devicons', - --event = 'VimEnter', - }) - use({ - "samodostal/image.nvim", - config = function() - require("image").setup({}) - end, - }) - -- Language specific tools - use("simrat39/rust-tools.nvim") -- Rust tooling ecosystem - use({ - "saecki/crates.nvim", -- - requires = { "nvim-lua/plenary.nvim" }, - config = function() - require("crates").setup() - end, - }) - use({ - "akinsho/flutter-tools.nvim", - requires = { - "nvim-lua/plenary.nvim", - "stevearc/dressing.nvim", -- optional for vim.ui.select - }, - config = function() - require("flutter-tools").setup({ - debugger = { - enabled = true, - run_via_dap = true, - }, - }) - end, - }) - use({ - "iamcco/markdown-preview.nvim", -- Markdown Preview - run = function() - vim.fn["mkdp#util#install"]() - end, - vim.cmd("let g:mkdp_auto_close = 0"), - }) - use({ - "ellisonleao/glow.nvim", -- Markdown Preview - config = function() - local glow_path - - -- Check if glow exists in ~/.local/bin - if vim.fn.executable("~/.local/bin/glow") == 1 then - glow_path = "~/.local/bin/glow" - else - -- Fallback to /usr/bin/glow - glow_path = "/usr/bin/glow" - end - - require("glow").setup({ - style = "dark", - glow_path = glow_path, - }) - end, - }) - use({ - "lervag/vimtex", - }) - use("micangl/cmp-vimtex") - - -------------------------------------------------- - - -- Automatically set up your configuration after cloning packer.nvim - -- Put this at the end after all plugins - if PACKER_BOOTSTRAP then - require("packer").sync() - end -end) diff --git a/lua/user/view.lua b/lua/user/view.lua deleted file mode 100644 index 837fce4..0000000 --- a/lua/user/view.lua +++ /dev/null @@ -1,69 +0,0 @@ --- Colorscheme - --- Colors -vim.opt.termguicolors = true - --- Available colorschemes: --- [[ nightfly ayu onedark doom-one nvimgelion github_dark tokyonight bamboo ]] - -require('tokyonight').setup({ - style = 'night', - transparent = true, - transparent_sidebar = true, - dim_inactive = false, - styles = { - sidebars = 'transparent', - floats = 'transparent', - }, -}) - --- Define default color scheme -local default_colorscheme = 'tokyonight-night' -local fallback_colorscheme = 'desert' - --- Attempt to set the default color scheme -local status_ok, _ = pcall(vim.cmd, 'colorscheme ' .. default_colorscheme) - --- If the default color scheme is not found, use the fallback color scheme -if not status_ok then - vim.cmd('colorscheme ' .. fallback_colorscheme) -end - -vim.api.nvim_command('syntax on') -vim.api.nvim_command('highlight Normal guibg=NONE ctermbg=NONE') -vim.api.nvim_command('highlight NormalNC guibg=NONE') -vim.api.nvim_command('highlight NormalFloat guibg=NONE ctermbg=NONE') -vim.api.nvim_command('highlight Float guibg=NONE ctermbg=NONE') -vim.api.nvim_command('highlight NonText guibg=NONE ctermbg=NONE') -vim.api.nvim_command('highlight SignColumn guibg=NONE') -vim.api.nvim_command('highlight FoldColumn guibg=NONE') -vim.api.nvim_command('highlight CursorLineSign guibg=NONE ctermbg=NONE') -vim.api.nvim_command('highlight Title guibg=NONE gui=bold') -vim.api.nvim_command('highlight TabLine guibg=#333842 gui=bold') -vim.api.nvim_command('highlight TabLineSel guibg=#333842 gui=bold') -vim.api.nvim_command('highlight TabLineFill guibg=NONE gui=bold') -vim.api.nvim_command('highlight WinBar guibg=NONE ctermbg=NONE gui=bold') -vim.api.nvim_command('highlight WinBarNC guibg=NONE ctermbg=NONE') -vim.api.nvim_command('highlight LineNr guibg=NONE ctermbg=NONE') -vim.api.nvim_command('highlight WinSeparator guibg=NONE gui=bold ctermbg=NONE') -vim.api.nvim_command('highlight MsgSeparator guibg=NONE ctermbg=NONE') -vim.api.nvim_command('highlight EndOfBuffer guibg=NONE guifg=Normal') -vim.api.nvim_command('highlight Comment guibg=NONE ctermbg=NONE') -vim.api.nvim_command('highlight Winblend guibg=NONE ctermbg=NONE') -vim.api.nvim_command('highlight NormalFloat guibg=NONE ctermbg=NONE') -vim.api.nvim_command('highlight Pumblend guibg=NONE ctermbg=NONE') -vim.api.nvim_command('highlight WildMenu guibg=NONE ctermbg=NONE') -vim.api.nvim_command('highlight WarningMsg guibg=NONE ctermbg=NONE') -vim.api.nvim_command('highlight Pmenu guibg=NONE ctermbg=NONE') -vim.api.nvim_command('highlight PmenuSel guibg=NONE ctermbg=NONE') -vim.api.nvim_command('highlight PmenuThumb guibg=NONE ctermbg=NONE') -vim.api.nvim_command('highlight PmenuSbar guibg=NONE ctermbg=NONE') -vim.api.nvim_command('highlight PmenuExtra guibg=NONE ctermbg=NONE') -vim.api.nvim_command('highlight PmenuExtraSel guibg=NONE ctermbg=NONE') -vim.api.nvim_command('highlight MoreMsg guibg=NONE ctermbg=NONE') - --- Set different window separator colorscheme -vim.cmd([[ -au WinEnter * setl winhl=WinSeparator:WinSeparatorA -au WinLeave * setl winhl=WinSeparator:WinSeparator -]]) |