From abc644bb39ce05f107002ad947aa9729fad2d770 Mon Sep 17 00:00:00 2001 From: Joey Yakimowich-Payne Date: Wed, 11 Feb 2026 07:40:15 -0700 Subject: [PATCH] Init.vim -> init.lua --- .config/nvim/init.lua | 1036 ++++++++++++++++++++++++++++++++++++++ .config/nvim/init.vim | 1116 ----------------------------------------- 2 files changed, 1036 insertions(+), 1116 deletions(-) create mode 100644 .config/nvim/init.lua delete mode 100644 .config/nvim/init.vim diff --git a/.config/nvim/init.lua b/.config/nvim/init.lua new file mode 100644 index 0000000..4705c71 --- /dev/null +++ b/.config/nvim/init.lua @@ -0,0 +1,1036 @@ +-- Leader keys (must be set before lazy setup) +vim.g.mapleader = " " +vim.g.maplocalleader = " " +vim.opt.termguicolors = true + +-- Bootstrap lazy.nvim +local lazypath = vim.fn.stdpath("data") .. "/lazy/lazy.nvim" +if not (vim.uv or vim.loop).fs_stat(lazypath) then + local lazyrepo = "https://github.com/folke/lazy.nvim.git" + local out = vim.fn.system({ "git", "clone", "--filter=blob:none", "--branch=stable", lazyrepo, lazypath }) + if vim.v.shell_error ~= 0 then + vim.api.nvim_echo({ + { "Failed to clone lazy.nvim:\n", "ErrorMsg" }, + { out, "WarningMsg" }, + { "\nPress any key to exit..." }, + }, true, {}) + vim.fn.getchar() + os.exit(1) + end +end +vim.opt.rtp:prepend(lazypath) + +-- Plugins +require("lazy").setup({ + { "rust-lang/rust.vim" }, + { "jyapayne/nim.vim" }, + { "tpope/vim-fugitive" }, + { "tpope/vim-unimpaired" }, + { "preservim/nerdtree" }, + { "Xuyuanp/nerdtree-git-plugin" }, + { "hynek/vim-python-pep8-indent" }, + { "pangloss/vim-javascript" }, + { "Glench/Vim-Jinja2-Syntax" }, + { "tpope/vim-haml" }, + { "hdima/python-syntax" }, + { "hail2u/vim-css3-syntax" }, + { "mxw/vim-jsx" }, + { "ryanoasis/vim-devicons" }, + { "johnstef99/vim-nerdtree-syntax-highlight" }, + { "jistr/vim-nerdtree-tabs" }, + { "mustache/vim-mustache-handlebars" }, + { "vim-scripts/errormarker.vim" }, + { "elixir-lang/vim-elixir" }, + { "jreybert/vim-largefile" }, + { "sbdchd/neoformat" }, + { "tikhomirov/vim-glsl" }, + { + "svermeulen/vim-easyclip", + init = function() + vim.g.EasyClipUseGlobalPasteToggle = 0 + vim.g.EasyClipShareYanks = 1 + vim.g.EasyClipShareYanksFile = ".easyclip" + vim.g.EasyClipShareYanksDir = vim.env.HOME + end, + }, + -- { "tpope/vim-obsession" }, + -- { "dhruvasagar/vim-prosession" }, + { "tmux-plugins/vim-tmux-focus-events" }, + { + "rmagatti/auto-session", + config = function() + require("auto-session").setup({ + auto_save_enabled = true, + auto_restore_enabled = true, + }) + end, + }, + { "vim-airline/vim-airline" }, + { "vim-airline/vim-airline-themes" }, + -- { "vim-syntastic/syntastic" }, + -- { "itchyny/lightline.vim" }, + { "morhetz/gruvbox" }, + { "tpope/vim-commentary" }, + { "w0rp/ale" }, + { "ctrlpvim/ctrlp.vim" }, + { "udalov/kotlin-vim" }, + { "simnalamburt/vim-mundo" }, + { "christoomey/vim-tmux-navigator" }, + { "tpope/vim-surround" }, + -- { "alaviss/nim.nvim" }, + { "prabirshrestha/asyncomplete.vim" }, + { "tpope/vim-repeat" }, + { "christoomey/vim-sort-motion" }, + { "christoomey/vim-system-copy" }, + { "michaeljsmith/vim-indent-object" }, + { "kana/vim-textobj-user" }, + { "kana/vim-textobj-line", dependencies = { "kana/vim-textobj-user" } }, + { "Julian/vim-textobj-brace", dependencies = { "kana/vim-textobj-user" } }, + { "bps/vim-textobj-python", dependencies = { "kana/vim-textobj-user" } }, + { "wellle/targets.vim" }, + { + "junegunn/fzf", + build = function() + vim.fn["fzf#install"]() + end, + }, + { "junegunn/fzf.vim" }, + { "jremmen/vim-ripgrep" }, + { "rescript-lang/vim-rescript" }, + { + "neoclide/coc.nvim", + branch = "master", + build = "yarn install --frozen-lockfile", + lazy = false, + config = function() + -- coc-settings.json path note: + -- If you reference vim-rescript server.js directly, update plugged path to lazy path: + -- ~/.local/share/nvim/lazy/vim-rescript/server/out/server.js + + _G.check_back_space = function() + local col = vim.fn.col(".") - 1 + return col == 0 or vim.fn.getline("."):sub(col, col):match("%s") ~= nil + end + + _G.show_docs = function() + if vim.tbl_contains({ "vim", "help" }, vim.bo.filetype) then + vim.cmd("h " .. vim.fn.expand("")) + elseif vim.fn["coc#rpc#ready"]() == 1 then + vim.fn.CocActionAsync("doHover") + else + vim.cmd("!" .. vim.o.keywordprg .. " " .. vim.fn.expand("")) + end + end + + local expr_opts = { expr = true, silent = true, noremap = true, replace_keycodes = false } + local expr_nowait_opts = { expr = true, silent = true, nowait = true, noremap = true, replace_keycodes = false } + + vim.keymap.set( + "i", + "", + 'coc#pum#visible() ? coc#pum#next(1) : v:lua.check_back_space() ? "\\" : coc#refresh()', + expr_opts + ) + vim.keymap.set("i", "", 'coc#pum#visible() ? coc#pum#prev(1) : "\\"', expr_opts) + vim.keymap.set( + "i", + "", + 'coc#pum#visible() ? coc#pum#confirm() : "\\u\\\\=coc#on_enter()\\"', + expr_opts + ) + + if vim.fn.has("nvim") == 1 then + vim.keymap.set("i", "", "coc#refresh()", expr_opts) + else + vim.keymap.set("i", "", "coc#refresh()", expr_opts) + end + + vim.keymap.set("n", "[g", "(coc-diagnostic-prev)", { silent = true, remap = true }) + vim.keymap.set("n", "]g", "(coc-diagnostic-next)", { silent = true, remap = true }) + + vim.keymap.set("n", "gd", "(coc-definition)", { silent = true, remap = true }) + vim.keymap.set("n", "gy", "(coc-type-definition)", { silent = true, remap = true }) + vim.keymap.set("n", "gi", "(coc-implementation)", { silent = true, remap = true }) + vim.keymap.set("n", "gr", "(coc-references)", { silent = true, remap = true }) + + vim.keymap.set("n", "rn", "(coc-rename)", { remap = true }) + vim.keymap.set("x", "f", "(coc-format-selected)", { remap = true }) + vim.keymap.set("n", "f", "(coc-format-selected)", { remap = true }) + + vim.keymap.set("x", "a", "(coc-codeaction-selected)", { remap = true }) + vim.keymap.set("n", "a", "(coc-codeaction-selected)", { remap = true }) + vim.keymap.set("n", "ac", "(coc-codeaction)", { remap = true }) + vim.keymap.set("n", "qf", "(coc-fix-current)", { remap = true }) + + vim.keymap.set("x", "if", "(coc-funcobj-i)", { remap = true }) + vim.keymap.set("o", "if", "(coc-funcobj-i)", { remap = true }) + vim.keymap.set("x", "af", "(coc-funcobj-a)", { remap = true }) + vim.keymap.set("o", "af", "(coc-funcobj-a)", { remap = true }) + vim.keymap.set("x", "ic", "(coc-classobj-i)", { remap = true }) + vim.keymap.set("o", "ic", "(coc-classobj-i)", { remap = true }) + vim.keymap.set("x", "ac", "(coc-classobj-a)", { remap = true }) + vim.keymap.set("o", "ac", "(coc-classobj-a)", { remap = true }) + + vim.keymap.set("n", "", 'coc#float#has_scroll() ? coc#float#scroll(1) : "\\"', expr_nowait_opts) + vim.keymap.set("n", "", 'coc#float#has_scroll() ? coc#float#scroll(0) : "\\"', expr_nowait_opts) + vim.keymap.set( + "i", + "", + 'coc#float#has_scroll() ? "\\=coc#float#scroll(1)\\" : "\\"', + expr_nowait_opts + ) + vim.keymap.set( + "i", + "", + 'coc#float#has_scroll() ? "\\=coc#float#scroll(0)\\" : "\\"', + expr_nowait_opts + ) + vim.keymap.set("v", "", 'coc#float#has_scroll() ? coc#float#scroll(1) : "\\"', expr_nowait_opts) + vim.keymap.set("v", "", 'coc#float#has_scroll() ? coc#float#scroll(0) : "\\"', expr_nowait_opts) + + vim.keymap.set("n", "", "(coc-range-select)", { silent = true, remap = true }) + vim.keymap.set("x", "", "(coc-range-select)", { silent = true, remap = true }) + + vim.keymap.set("n", "a", ":CocList diagnostics", { silent = true, nowait = true }) + vim.keymap.set("n", "e", ":CocList extensions", { silent = true, nowait = true }) + vim.keymap.set("n", "c", ":CocList commands", { silent = true, nowait = true }) + vim.keymap.set("n", "o", ":CocList outline", { silent = true, nowait = true }) + vim.keymap.set("n", "s", ":CocList -I symbols", { silent = true, nowait = true }) + vim.keymap.set("n", "j", ":CocNext", { silent = true, nowait = true }) + vim.keymap.set("n", "k", ":CocPrev", { silent = true, nowait = true }) + vim.keymap.set("n", "p", ":CocListResume", { silent = true, nowait = true }) + + vim.schedule(function() + vim.keymap.set("n", "K", "lua _G.show_docs()", { silent = true, noremap = true }) + end) + + vim.api.nvim_create_autocmd("CursorHold", { + callback = function() + vim.fn.CocActionAsync("highlight") + end, + }) + + local coc_group = vim.api.nvim_create_augroup("mygroup", { clear = true }) + vim.api.nvim_create_autocmd("FileType", { + group = coc_group, + pattern = { "typescript", "json" }, + command = "setlocal formatexpr=CocAction('formatSelected')", + }) + vim.api.nvim_create_autocmd("User", { + group = coc_group, + pattern = "CocJumpPlaceholder", + callback = function() + vim.fn.CocActionAsync("showSignatureHelp") + end, + }) + + vim.api.nvim_create_user_command("Format", function() + vim.fn.CocAction("format") + end, { nargs = 0 }) + + vim.api.nvim_create_user_command("Fold", function(opts) + if opts.args == "" then + vim.fn.CocAction("fold") + else + vim.fn.CocAction("fold", opts.args) + end + end, { nargs = "?" }) + + vim.api.nvim_create_user_command("OR", function() + vim.fn.CocAction("runCommand", "editor.action.organizeImport") + end, { nargs = 0 }) + + vim.o.statusline = "%{coc#status()}%{get(b:,'coc_current_function','')}" .. vim.o.statusline + end, + }, + { "kassio/neoterm" }, + { "reasonml-editor/vim-reason-plus" }, + { + "jyapayne/vim-code-dark", + lazy = false, + priority = 1000, + }, + -- { "jyapayne/vimspector" }, + { "nvim-lua/popup.nvim" }, + { "nvim-lua/plenary.nvim" }, + { + "nvim-telescope/telescope.nvim", + dependencies = { + "nvim-lua/plenary.nvim", + "nvim-lua/popup.nvim", + }, + config = function() + require("telescope").setup() + require("telescope").load_extension("dap") + end, + }, + { "kyazdani42/nvim-web-devicons" }, + { "ryanoasis/vim-devicons" }, + { + "TimUntersberger/neogit", + config = function() + require("neogit").setup({ + disable_commit_confirmation = true, + integrations = { + diffview = true, + }, + }) + end, + }, + { "sindrets/diffview.nvim", branch = "main" }, + { + "lewis6991/gitsigns.nvim", + branch = "main", + config = function() + require("gitsigns").setup({ word_diff = true }) + end, + }, + { "peterhoeg/vim-qml" }, + { + "mfussenegger/nvim-dap", + config = function() + local dap = require("dap") + + local function os_capture(cmd) + local f = assert(io.popen(cmd .. " 2>&1", "r")) + local s = assert(f:read("*a")) + f:close() + return s + end + + dap.adapters.lldb = { + type = "executable", + command = "/opt/homebrew/opt/llvm/bin/lldb-vscode", + name = "lldb", + } + + dap.configurations.nim = { + { + name = "Launch", + type = "lldb", + request = "launch", + program = function() + print("Compiling...") + local filename = vim.api.nvim_buf_get_name(0) + os_capture("nim c --debugger:native " .. filename) + print("Running...") + return filename:match("(.+)%..+$") + end, + cwd = "${workspaceFolder}", + stopOnEntry = false, + args = function() + return vim.fn.input("Args: ", "") + end, + runInTerminal = false, + }, + } + + require("dap-python").setup("/opt/homebrew/bin/python3") + + vim.fn.sign_define("DapBreakpoint", { text = "●", texthl = "ErrorMsg", linehl = "", numhl = "" }) + vim.fn.sign_define("DapBreakpointRejected", { text = "●", texthl = "LineNr", linehl = "", numhl = "" }) + vim.fn.sign_define("DapLogPoint", { text = "L", texthl = "", linehl = "", numhl = "" }) + vim.fn.sign_define("DapStopped", { text = "→", texthl = "WarningMsg", linehl = "debugPC", numhl = "" }) + end, + }, + { "posva/vim-vue" }, + -- { "rcarriga/nvim-dap-ui" }, + { + "nvim-treesitter/nvim-treesitter", + build = ":TSUpdate", + config = function() + require("nvim-treesitter.config").setup({ + ensure_installed = { "c", "lua", "vim", "vimdoc", "query", "markdown", "markdown_inline", "go" }, + sync_install = false, + auto_install = true, + ignore_install = {}, + highlight = { + enable = true, + disable = { "python", "nim" }, + additional_vim_regex_highlighting = false, + }, + playground = { + enable = true, + disable = {}, + updatetime = 25, + persist_queries = false, + keybindings = { + toggle_query_editor = "o", + toggle_hl_groups = "i", + toggle_injected_languages = "t", + toggle_anonymous_nodes = "a", + toggle_language_display = "I", + focus_language = "f", + unfocus_language = "F", + update = "R", + goto_node = "", + show_help = "?", + }, + }, + }) + end, + }, + -- { "nvim-treesitter/playground" }, + { "nvim-telescope/telescope-dap.nvim" }, + { "theHamsta/nvim-dap-virtual-text" }, + { "mfussenegger/nvim-dap-python" }, + { "KabbAmine/vCoolor.vim" }, + -- { "chrisbra/Colorizer" }, + { + "norcalli/nvim-colorizer.lua", + config = function() + require("colorizer").setup() + end, + }, + -- hologram.nvim is abandoned/experimental and crashes on buffer close + -- { "edluffy/hologram.nvim" }, + { "fatih/vim-go" }, + { "folke/trouble.nvim" }, + -- { "baabelfish/nvim-nim" }, +}) + +-- Options and globals +vim.o.sessionoptions = "blank,buffers,curdir,folds,help,tabpages,winsize,winpos,terminal,localoptions" + +vim.g.ale_shell = "/bin/bash" +vim.g.lsp_log_verbose = 1 +vim.g.lsp_log_file = vim.fn.expand("/tmp/vim-lsp.log") +vim.g["airline#extensions#ale#enabled"] = 1 +vim.g.syntastic_c_compiler_options = "-std=c99" +vim.g.pydiction_location = "/home/joey/.vim/bundle/pydiction/complete-dict" +vim.g.jsx_ext_required = 0 +vim.g.asyncrun_auto = "make" +vim.g.syntastic_enable_elixir_checker = 1 +vim.g.syntastic_elixir_checkers = { "elixir" } +vim.g.LargeFile = 20 +vim.g.airline_powerline_fonts = 1 +vim.g.airline_section_x = "" +vim.g.airline_section_y = "" +vim.g.airline_section_warning = "" +vim.g.airline_section_z = "%l/%L:%c" +vim.g.syntastic_check_on_wq = 0 +vim.g.python_highlight_space_errors = 0 +vim.g.NERDTreeDirArrowExpandable = "▸" +vim.g.NERDTreeDirArrowCollapsible = "▾" +vim.g.syntastic_javascript_checkers = { "eslint", "flow" } +vim.g.syntastic_java_checkers = {} +vim.g.neoformat_javascript_prettier = { + exe = "prettier", + args = { "--single-quote", "--trailing-comma all" }, +} +vim.g.toggleJSFormat = 0 +vim.g.ycm_autoclose_preview_window_after_completion = 1 +vim.g.ycm_min_num_of_chars_for_completion = 99 +vim.g["flow#enable"] = 0 +vim.g.ctrlp_custom_ignore = { + dir = [[\v[\/](\.git|node_modules|nimcache|\.sass-cache|bower_components|build|dist)$]], + file = [[\v\.(exe|so|dll|o)$]], + link = "", +} +vim.g.ctrlp_prompt_mappings = { + ['AcceptSelection("e")'] = { "" }, + ['AcceptSelection("t")'] = { "", "<2-LeftMouse>" }, +} +vim.g.gitsigns_head = "main" +vim.g.asyncomplete_auto_completeopt = 0 +vim.g.neoterm_default_mod = "vertical botright" +vim.g.neoterm_autoinsert = 1 +vim.g.neoterm_autoscroll = 1 +vim.g.neoterm_term_per_tab = 1 +vim.g.dap_virtual_text = true +vim.g.ale_linters = { java = {}, python = {}, typescript = {} } +vim.g.NVIM_TUI_ENABLE_CURSOR_SHAPE = 0 +vim.g.NVIM_TUI_ENABLE_TRUE_COLOR = 1 + +vim.env.NVIM_TUI_ENABLE_CURSOR_SHAPE = "0" +vim.env.NVIM_TUI_ENABLE_TRUE_COLOR = "1" + +vim.opt.inccommand = "nosplit" +vim.opt.guicursor = "n-v-c-sm:block,i-ci-ve:ver25,r-cr-o:hor20" +vim.opt.wildmenu = true +vim.opt.wildmode = "full" +vim.opt.smartindent = true +vim.opt.ruler = true +vim.opt.backspace = "2" +vim.opt.autowrite = true +vim.opt.smarttab = true +vim.opt.expandtab = true +vim.opt.history = 10000 +vim.opt.foldmethod = "indent" +vim.opt.foldlevel = 99 +vim.opt.laststatus = 2 +vim.opt.undofile = true +vim.opt.undodir = vim.env.HOME .. "/.vim/undo" +vim.opt.undolevels = 10000 +vim.opt.undoreload = 10000 +vim.opt.incsearch = true +vim.opt.mouse = "a" +vim.opt.tabstop = 4 +vim.opt.shiftwidth = 4 +vim.opt.clipboard = "unnamedplus" +vim.opt.timeoutlen = 1000 +vim.opt.ttimeoutlen = 0 +vim.opt.hidden = true +vim.opt.backup = false +vim.opt.writebackup = false +vim.opt.cmdheight = 1 +vim.opt.updatetime = 300 +vim.opt.shortmess:append("c") +if vim.fn.has("nvim-0.5.0") == 1 or vim.fn.has("patch-8.1.1564") == 1 then + vim.opt.signcolumn = "number" +else + vim.opt.signcolumn = "yes" +end +vim.opt.switchbuf:append({ "usetab", "newtab" }) +vim.opt.termguicolors = true +vim.opt.cursorline = true +vim.opt.cursorlineopt = "line" +vim.opt.showmode = false +vim.opt.background = "dark" +vim.opt.rtp:append("/usr/local/opt/fzf") + +if vim.fn.executable("ag") == 1 then + vim.opt.grepprg = "ag --nogroup --nocolor --vimgrep" + vim.g.ctrlp_user_command = 'ag %s -l --nocolor -g ""' + vim.g.ctrlp_use_caching = 0 +end + +if vim.g.autocommands_loaded == nil then + vim.g.autocommands_loaded = 1 +end + +vim.cmd("set t_Co=256") +vim.cmd("filetype plugin indent on") +vim.cmd("filetype on") +vim.cmd("syntax on") +vim.cmd("syntax enable") + +-- Keymaps +vim.keymap.set("n", "gm", "m", { noremap = true }) +vim.keymap.set("n", "", "w", { noremap = true }) + +vim.keymap.set({ "n", "v" }, "", ":NERDTreeTabsToggle", { remap = true }) + +vim.keymap.set({ "n", "v" }, "", "lua ToggleJSFormat(1)", { remap = true }) +vim.keymap.set("n", "=j", ":%!python3 -m json.tool", { remap = true }) +vim.keymap.set("n", "", ":let _s=@/:%s/\\s\\+$//e:let @/=_s:nohl", { silent = true, noremap = true }) +vim.keymap.set({ "n", "v" }, "", ":mksession! ~/.vim_session ", { remap = true }) +vim.keymap.set({ "n", "v" }, "", ":source ~/.vim_session ", { remap = true }) +vim.keymap.set("n", "", ":MundoToggle", { noremap = true }) + +vim.keymap.set("n", "d", '"_d', { noremap = true }) +vim.keymap.set("v", "d", '"_d', { noremap = true }) + +vim.keymap.set("n", "", "[e", { remap = true }) +vim.keymap.set("n", "", "]e", { remap = true }) +vim.keymap.set("v", "", "[egv", { remap = true }) +vim.keymap.set("v", "", "]egv", { remap = true }) +vim.keymap.set("v", "", "[egv", { remap = true }) +vim.keymap.set("v", "", "]egv", { remap = true }) +vim.keymap.set("v", "#", ":s#^#\\##", { noremap = true }) +vim.keymap.set("v", "-#", ":s#^\\###", { noremap = true }) + +vim.keymap.set("n", "ff", ":Rg", { noremap = true }) + +vim.keymap.set("v", "p", '"_dP', { noremap = true }) + +vim.keymap.set({ "n", "v", "o" }, "˙", "gT", { noremap = true }) +vim.keymap.set({ "n", "v", "o" }, "¬", "gt", { noremap = true }) +vim.keymap.set({ "n", "v", "o" }, "", "gT", { noremap = true }) +vim.keymap.set({ "n", "v", "o" }, "", "gt", { noremap = true }) + +vim.keymap.set("i", "˙", "gTi", { noremap = true }) +vim.keymap.set("i", "¬", "gti", { noremap = true }) +vim.keymap.set("i", "", "gTi", { noremap = true }) +vim.keymap.set("i", "", "gti", { noremap = true }) + +vim.keymap.set("n", "riW", "ciW0", { noremap = true }) +vim.keymap.set("n", "riw", "ciw0", { noremap = true }) + +vim.keymap.set("n", "K", ':grep! "\\b\\b":cw', { silent = true, noremap = true }) + +vim.keymap.set("n", "", ":Telescope find_files", { noremap = true }) +vim.keymap.set("n", "fd", ":lua telescope_find_files_in_path()", { noremap = true }) +vim.keymap.set("n", "fD", ":lua telescope_live_grep_in_path()", { noremap = true }) +vim.keymap.set("n", "ft", ':lua telescope_find_files_in_path("./tests")', { noremap = true }) +vim.keymap.set("n", "fT", ':lua telescope_live_grep_in_path("./tests")', { noremap = true }) +vim.keymap.set("n", "fo", ":Telescope file_browser", { noremap = true }) +vim.keymap.set("n", "fn", ":Telescope git_files", { noremap = true }) +vim.keymap.set("n", "fg", ":Telescope git_branches", { noremap = true }) +vim.keymap.set("n", "fb", ":Telescope buffers", { noremap = true }) +vim.keymap.set("n", "fs", ":Telescope lsp_document_symbols", { noremap = true }) +vim.keymap.set("n", "ff", ":Telescope live_grep", { noremap = true }) +vim.keymap.set("n", "FF", ":Telescope grep_string", { noremap = true }) + +vim.keymap.set("n", "", function() + for _, win in ipairs(vim.api.nvim_list_wins()) do + local config = vim.api.nvim_win_get_config(win) + if config.relative ~= "" then + vim.api.nvim_win_close(win, false) + end + end +end, { silent = true, noremap = true }) + +vim.keymap.set("n", "db", ":lua require'dap'.toggle_breakpoint()", { silent = true, noremap = true }) +vim.keymap.set("n", "ø", ":lua require'dap'.step_out()", { silent = true, noremap = true }) +vim.keymap.set("n", "˚", ":lua require'dap'.step_into()", { silent = true, noremap = true }) +vim.keymap.set("n", "∆", ":lua require'dap'.step_over()", { silent = true, noremap = true }) +vim.keymap.set("n", "ds", ":lua require'dap'.close()", { silent = true, noremap = true }) +vim.keymap.set("n", "dn", ":lua require'dap'.continue()", { silent = true, noremap = true }) +vim.keymap.set("n", "dk", ":lua require'dap'.up()", { silent = true, noremap = true }) +vim.keymap.set("n", "dj", ":lua require'dap'.down()", { silent = true, noremap = true }) +vim.keymap.set("n", "d_", ":lua require'dap'.disconnect();require'dap'.stop();require'dap'.run_last()", { silent = true, noremap = true }) +vim.keymap.set("n", "dr", ":lua require'dap'.repl.toggle()l", { silent = true, noremap = true }) +vim.keymap.set("n", "rc", ":lua require'dap'.run_to_cursor()l", { silent = true, noremap = true }) +vim.keymap.set("n", "rb", ":lua require'dap'.reverse_continue()l", { silent = true, noremap = true }) +vim.keymap.set("v", "di", ":lua require'dap.ui.variables'.visual_hover()", { silent = true, noremap = true }) +vim.keymap.set("n", "d?", ":lua require'dap.ui.variables'.scopes()", { silent = true, noremap = true }) +vim.keymap.set("n", "de", ":lua require'dap'.set_exception_breakpoints({\"all\"})", { silent = true, noremap = true }) +vim.keymap.set("n", "da", ":lua require'debugHelper'.attach()", { silent = true, noremap = true }) +vim.keymap.set("n", "dA", ":lua require'debugHelper'.attachToRemote()", { silent = true, noremap = true }) +vim.keymap.set("n", "di", ":lua require'dap.ui.widgets'.hover()", { silent = true, noremap = true }) +vim.keymap.set("n", "qq", ":q", { silent = true, noremap = true }) +vim.keymap.set( + "n", + "d?", + ":lua local widgets=require'dap.ui.widgets';widgets.centered_float(widgets.scopes)", + { silent = true, noremap = true } +) +vim.keymap.set("n", "df", ":Telescope dap frames", { noremap = true }) +vim.keymap.set("n", "dc", ":Telescope dap commands", { noremap = true }) +vim.keymap.set("n", "dh", ":Telescope dap list_breakpoints", { noremap = true }) + +vim.keymap.set("n", "gg", ":Neogit", { noremap = true }) +vim.keymap.set("n", "gd", ":DiffviewOpen", { noremap = true }) +vim.keymap.set("n", "gD", ":DiffviewOpen main", { noremap = true }) +vim.keymap.set("n", "gl", ":Neogit log", { noremap = true }) +vim.keymap.set("n", "gp", ":Neogit push", { noremap = true }) + +vim.keymap.set("n", "", ":Ttoggle", { noremap = true }) +vim.keymap.set("i", "", ":Ttoggle", { noremap = true }) +vim.keymap.set("t", "", ":Ttoggle", { noremap = true }) +vim.keymap.set("t", "", "", { noremap = true }) + +vim.keymap.set("n", "", ":CocCommand java.debug.vimspector.start", { remap = true }) + +vim.keymap.set("n", "y", '"+y', { remap = true }) +vim.keymap.set("v", "y", '"+y', { remap = true }) +vim.keymap.set("n", "p", '"+p', { remap = true }) +vim.keymap.set("v", "p", '"+p', { remap = true }) + +-- Autocommands +local binary_group = vim.api.nvim_create_augroup("Binary", { clear = true }) +vim.api.nvim_create_autocmd("BufReadPre", { + group = binary_group, + pattern = "*.bin", + command = "let &bin=1", +}) +vim.api.nvim_create_autocmd("BufReadPost", { + group = binary_group, + pattern = "*.bin", + command = "if &bin | %!xxd | endif", +}) +vim.api.nvim_create_autocmd("BufReadPost", { + group = binary_group, + pattern = "*.bin", + command = "set ft=xxd", +}) +vim.api.nvim_create_autocmd("BufWritePre", { + group = binary_group, + pattern = "*.bin", + command = "if &bin | %!xxd -r | endif", +}) +vim.api.nvim_create_autocmd("BufWritePost", { + group = binary_group, + pattern = "*.bin", + command = "if &bin | %!xxd | endif", +}) +vim.api.nvim_create_autocmd("BufWritePost", { + group = binary_group, + pattern = "*.bin", + command = "set nomod", +}) + +local ft_group = vim.api.nvim_create_augroup("FileTypeSettings", { clear = true }) +vim.api.nvim_create_autocmd("FileType", { + group = ft_group, + pattern = "javascript", + command = "setlocal ts=2 sw=2 expandtab", +}) +vim.api.nvim_create_autocmd("FileType", { + group = ft_group, + pattern = { "nim", "ts", "vue", "less", "css", "typescript" }, + command = "setlocal ts=2 sts=2 sw=2 expandtab", +}) +vim.api.nvim_create_autocmd("FileType", { + group = ft_group, + pattern = "python", + command = "setlocal nosmartindent", +}) + +vim.api.nvim_create_autocmd("BufEnter", { + pattern = "*", + command = 'if (winnr("$") == 1 && exists("b:NERDTree") && b:NERDTree.isTabTree()) | q | endif', +}) + +vim.api.nvim_create_autocmd({ "BufRead", "BufNewFile" }, { + pattern = { "*.py", "*.js", "*.jsx", "*.nim", "*.ml", "*.mli" }, + command = [[match OverLength /\%89v.\+/]], +}) +vim.api.nvim_create_autocmd({ "BufRead", "BufNewFile" }, { + pattern = { "*.py", "*.js", "*.jsx", "*.nim", "*.ml", "*.mli" }, + command = [[2match ExtraWhiteSpace /\s\+$\|\t/]], +}) +vim.api.nvim_create_autocmd("StdinReadPost", { + pattern = "*", + command = "set buftype=nofile", +}) + +vim.api.nvim_create_autocmd("CompleteDone", { + pattern = "*", + command = "if pumvisible() == 0 | pclose | endif", +}) + +vim.api.nvim_create_autocmd("BufReadPost", { + pattern = "*", + callback = function() + local last_pos = vim.fn.line([['"]]) + if last_pos > 0 then + if last_pos <= vim.fn.line("$") then + vim.cmd([[normal! g`"]]) + else + vim.cmd("normal! $") + end + end + end, +}) + +vim.api.nvim_create_autocmd({ "BufRead", "BufNewFile" }, { + pattern = "*.sass", + command = "set filetype=sass", +}) +vim.api.nvim_create_autocmd({ "BufRead", "BufNewFile" }, { + pattern = "*.shpaml", + command = "setfiletype shpaml", +}) + +local transparent_group = vim.api.nvim_create_augroup("TransparentUI", { clear = true }) +vim.api.nvim_create_autocmd("ColorScheme", { + group = transparent_group, + pattern = "*", + callback = function() + if _G.SetTransparent then + _G.SetTransparent() + end + end, +}) + +local extra_ws_group = vim.api.nvim_create_augroup("ExtraWhitespaceHi", { clear = true }) +vim.api.nvim_create_autocmd("ColorScheme", { + group = extra_ws_group, + pattern = "*", + command = "highlight ExtraWhitespace ctermbg=darkgreen guibg=darkgreen", +}) + +local rescript_group = vim.api.nvim_create_augroup("RescriptMappings", { clear = true }) +vim.api.nvim_create_autocmd("FileType", { + group = rescript_group, + pattern = "rescript", + callback = function(args) + vim.keymap.set("n", "r", ":RescriptFormat", { silent = true, noremap = true, buffer = args.buf }) + vim.keymap.set("n", "t", ":RescriptTypeHint", { silent = true, noremap = true, buffer = args.buf }) + vim.keymap.set("n", "b", ":RescriptBuild", { silent = true, noremap = true, buffer = args.buf }) + vim.keymap.set("n", "gd", ":RescriptJumpToDefinition", { silent = true, noremap = true, buffer = args.buf }) + end, +}) + +local ocaml_group = vim.api.nvim_create_augroup("OcamlMappings", { clear = true }) +vim.api.nvim_create_autocmd("FileType", { + group = ocaml_group, + pattern = "ocaml", + callback = function(args) + vim.keymap.set("n", "", ":MerlinTypeOf", { remap = true, buffer = args.buf }) + end, +}) + +vim.api.nvim_create_autocmd("FileType", { + pattern = "python", + callback = function() + vim.b.coc_root_patterns = { + ".git", + ".env", + "venv", + ".venv", + "setup.cfg", + "setup.py", + "pyrightconfig.json", + "env", + } + end, +}) + +vim.api.nvim_create_autocmd("FileType", { + pattern = "vue", + callback = function() + vim.b.coc_root_patterns = { + ".git", + ".env", + "package.json", + "tsconfig.json", + "jsconfig.json", + "vite.config.ts", + "vite.config.js", + "vue.config.js", + "nuxt.config.ts", + } + end, +}) + +vim.api.nvim_create_autocmd("FileType", { + pattern = "dap-repl", + callback = function() + require("dap.ext.autocompl").attach() + end, +}) + +-- User commands +vim.api.nvim_create_user_command("C", function() + vim.fn.setreg("/", "") +end, {}) + +vim.api.nvim_create_user_command("CC", "%s#_\\(\\l\\)#\\u\\1#g", {}) +vim.api.nvim_create_user_command("U", "%s#\\C\\(\\<\\u[a-z0-9]\\+\\|[a-z0-9]\\+\\)\\(\\u\\)#\\l\\1_\\l\\2#g", {}) + +vim.api.nvim_create_user_command("Make", function(opts) + local cmd = "AsyncRun" + if opts.bang then + cmd = cmd .. "!" + end + cmd = cmd .. " -program=make @" + if opts.args ~= "" then + cmd = cmd .. " " .. opts.args + end + vim.cmd(cmd) +end, { bang = true, nargs = "*", complete = "file" }) + +-- Custom functions +_G.ToggleJSFormat = function(...) + local argc = select("#", ...) + if argc == 1 then + vim.g.toggleJSFormat = 1 - vim.g.toggleJSFormat + end + + if vim.g.toggleJSFormat == 0 then + vim.cmd("autocmd!") + vim.cmd("autocmd BufWritePre *.js Neoformat") + vim.cmd("autocmd BufWritePre *.jsx Neoformat") + else + vim.cmd("autocmd!") + vim.cmd("autocmd BufWritePre *.js \"\"") + vim.cmd("autocmd BufWritePre *.jsx \"\"") + end +end + +_G.JumpToDef = function() + if vim.fn.exists("*GotoDefinition_" .. vim.bo.filetype) == 1 then + vim.cmd("call GotoDefinition_" .. vim.bo.filetype .. "()") + else + vim.cmd("normal! ") + end +end + +_G.WrapForTmux = function(s) + if vim.env.TMUX == nil then + return s + end + local tmux_start = "\27Ptmux;" + local tmux_end = "\27\\" + return tmux_start .. s:gsub("\27", "\27\27") .. tmux_end +end + +_G.XTermPasteBegin = function() + vim.opt.pastetoggle = "[201~" + vim.opt.paste = true + return "" +end + +_G.SynGroup = function() + local s = vim.fn.synID(vim.fn.line("."), vim.fn.col("."), 1) + print(vim.fn.synIDattr(s, "name") .. " -> " .. vim.fn.synIDattr(vim.fn.synIDtrans(s), "name")) +end + +_G.SetTransparent = function() + local groups = { + "Normal", + "NormalNC", + "SignColumn", + "EndOfBuffer", + "FoldColumn", + "LineNr", + "MsgArea", + "CursorLine", + "CursorLineNr", + "StatusLine", + "StatusLineNC", + "WinSeparator", + "VertSplit", + "NormalFloat", + "FloatBorder", + } + for _, g in ipairs(groups) do + vim.cmd("hi " .. g .. " ctermbg=NONE guibg=NONE") + end +end + +_G.telescope_find_files_in_path = function(path) + local _path = path or vim.fn.input("Dir: ", "", "dir") + require("telescope.builtin").find_files({ search_dirs = { _path } }) +end + +_G.telescope_live_grep_in_path = function(path) + local _path = path or vim.fn.input("Dir: ", "", "dir") + require("telescope.builtin").live_grep({ search_dirs = { _path } }) +end + +pcall(function() + vim.cmd([[let &t_SI .= v:lua.WrapForTmux("\[?2004h")]]) + vim.cmd([[let &t_EI .= v:lua.WrapForTmux("\[?2004l")]]) +end) +vim.keymap.set("i", "[200~", "v:lua.XTermPasteBegin()", { expr = true, noremap = true }) + +vim.b.current_syntax = "nim" +pcall(function() + vim.cmd("let &t_SI = \"\\e[5 q\"") + vim.cmd("let &t_EI = \"\\e[2 q\"") +end) + +-- Highlights +if vim.fn.exists("syntax_on") == 1 then + vim.cmd("syntax reset") +end + +local bg = "#000000" +local fg = "#ffffff" +local fg2 = "#ebebeb" +local fg3 = "#d6d6d6" +local fg4 = "#c2c2c2" +local bg2 = "#141414" +local bg3 = "#292929" +local bg4 = "#3d3d3d" +local keyword = "#a65a00" +local builtin = "#10a500" +local const = "#CC0000" +local comment = "#2d64a4" +local func = "#00a0e2" +local str = "#C40000" +local typec = "#3B9B00" +local ident = "#06989A" +local preproc = "#75507B" +local var = "#ffffff" +local warning = "#e81050" +local warning2 = "#e86310" +local parenbg = "#3a71c9" +local todo = "yellow" + +vim.cmd("hi Normal guifg=" .. fg .. " guibg=" .. bg) +vim.cmd("hi Cursor guifg=" .. bg .. " guibg=" .. fg) +vim.cmd("hi CursorLine guibg=" .. bg2) +vim.cmd("hi CursorColumn guibg=" .. bg2) +vim.cmd("hi ColorColumn guibg=" .. bg2) +vim.cmd("hi LineNr guifg=" .. fg2 .. " guibg=" .. bg2) +vim.cmd("hi VertSplit guifg=" .. fg3 .. " guibg=" .. bg3) +vim.cmd("hi MatchParen guifg=" .. fg .. " guibg=" .. parenbg .. " gui=none") +vim.cmd("hi Pmenu guifg=" .. fg .. " guibg=" .. bg2) +vim.cmd("hi PmenuSel guibg=" .. bg3) +vim.cmd("hi IncSearch guifg=" .. bg .. " guibg=" .. keyword) +vim.cmd("hi Directory guifg=" .. const) +vim.cmd("hi Folded guifg=" .. fg4 .. " guibg=" .. bg) + +vim.cmd("hi Boolean guifg=" .. const) +vim.cmd("hi Character guifg=" .. const) +vim.cmd("hi Comment guifg=" .. comment) +vim.cmd("hi Conditional guifg=" .. keyword) +vim.cmd("hi Constant guifg=" .. const) +vim.cmd("hi Define guifg=" .. keyword) +vim.cmd("hi DiffAdd guifg=#000000 guibg=#ddffdd gui=bold") +vim.cmd("hi DiffDelete guifg=#ff0000") +vim.cmd("hi DiffChange guibg=" .. bg2) +vim.cmd("hi DiffText guifg=#000000 guibg=#ddddff gui=bold") +vim.cmd("hi ErrorMsg guifg=" .. warning .. " guibg=" .. bg2 .. " gui=bold") +vim.cmd("hi WarningMsg guifg=" .. fg .. " guibg=" .. warning2) +vim.cmd("hi Float guifg=" .. const) +vim.cmd("hi Function guifg=" .. func) +vim.cmd("hi Identifier guifg=" .. ident .. " gui=italic") +vim.cmd("hi Keyword guifg=" .. keyword .. " gui=bold") +vim.cmd("hi Label guifg=" .. var) +vim.cmd("hi NonText guifg=" .. bg4 .. " guibg=" .. bg2) +vim.cmd("hi Number guifg=" .. const) +vim.cmd("hi Operater guifg=" .. keyword) +vim.cmd("hi PreProc guifg=" .. preproc) +vim.cmd("hi Special guifg=" .. preproc) +vim.cmd("hi SpecialKey guifg=" .. fg2 .. " guibg=" .. bg2) +vim.cmd("hi Statement guifg=" .. keyword) +vim.cmd("hi StorageClass guifg=" .. typec .. " gui=italic") +vim.cmd("hi String guifg=" .. str) +vim.cmd("hi Tag guifg=" .. keyword) +vim.cmd("hi Title guifg=" .. fg .. " gui=bold") +vim.cmd("hi Todo guibg=" .. todo .. " guifg=black gui=bold") +vim.cmd("hi Type guifg=" .. typec .. " gui=none") +vim.cmd("hi Underlined gui=underline") + +vim.cmd("hi rubyAttribute guifg=" .. builtin) +vim.cmd("hi rubyLocalVariableOrMethod guifg=" .. var) +vim.cmd("hi rubyGlobalVariable guifg=" .. var .. " gui=italic") +vim.cmd("hi rubyInstanceVariable guifg=" .. var) +vim.cmd("hi rubyKeyword guifg=" .. keyword) +vim.cmd("hi rubyKeywordAsMethod guifg=" .. keyword .. " gui=bold") +vim.cmd("hi rubyClassDeclaration guifg=" .. keyword .. " gui=bold") +vim.cmd("hi rubyClass guifg=" .. keyword .. " gui=bold") +vim.cmd("hi rubyNumber guifg=" .. const) + +vim.cmd("hi pythonBuiltinFunc guifg=" .. builtin) +vim.cmd("hi goBuiltins guifg=" .. builtin) +vim.cmd("hi jsBuiltins guifg=" .. builtin) +vim.cmd("hi jsFunction guifg=" .. keyword .. " gui=bold") +vim.cmd("hi jsGlobalObjects guifg=" .. typec) +vim.cmd("hi jsAssignmentExps guifg=" .. var) +vim.cmd("hi htmlLink guifg=" .. var .. " gui=underline") +vim.cmd("hi htmlStatement guifg=" .. keyword) +vim.cmd("hi htmlSpecialTagName guifg=" .. keyword) +vim.cmd("hi mkdCode guifg=" .. builtin) + +vim.cmd("highlight ExtraWhitespace ctermbg=darkgreen guibg=darkgreen") +vim.cmd("highlight ALEError ctermbg=red guibg=#700000") +vim.cmd("highlight ALEErrorSign ctermfg=none ctermbg=black guifg=red guibg=#212121") +vim.cmd("highlight ALEWarning ctermbg=yellow guibg=#504a08") +vim.cmd("highlight ALEWarningSign ctermfg=yellow ctermbg=none guibg=#212121 guifg=#ecd517") +vim.cmd("highlight SignColumn ctermbg=darkgrey guibg=#212121") +vim.cmd("highlight CocFadeOut ctermfg=lightgrey guifg=#8B8C92") +vim.cmd("highlight CocHintSign guifg=#647644 ctermfg=lightblue ctermbg=darkgrey guibg=#212121") +vim.cmd("highlight CocErrorSign guifg=red ctermfg=red ctermbg=darkgrey guibg=#212121") +vim.cmd("highlight CocInlayHint guifg=#3D7671 ctermfg=lightblue ctermbg=darkgrey guibg=none") +vim.cmd("highlight CocHighlightText ctermbg=lightblue guibg=#002c4b") + +vim.cmd("hi Normal ctermbg=none guibg=none") +vim.cmd("hi EndOfBuffer ctermbg=none guibg=none") +vim.cmd("hi NonText ctermbg=none guibg=none") +vim.cmd("hi LineNr ctermbg=none guibg=none") +vim.cmd("hi CursorLine guibg=NONE ctermbg=NONE gui=NONE cterm=NONE") + +vim.cmd("hi GitSignsAdd ctermfg=green ctermbg=none guibg=#212121 guifg=#32cd32 gui=bold cterm=bold") +vim.cmd("hi GitSignsDelete ctermfg=red ctermbg=none guibg=#212121 guifg=#ff6347 gui=bold cterm=bold") +vim.cmd("hi GitSignsChange ctermfg=blue ctermbg=none guibg=#212121 guifg=#1e90ff gui=bold cterm=bold") +vim.cmd("hi GitSignsAddInline ctermfg=none ctermbg=none guibg=#306C37 guifg=none gui=bold cterm=bold") +vim.cmd("hi GitSignsDeleteInline ctermfg=red ctermbg=none guibg=#740009 guifg=none gui=bold cterm=bold") +vim.cmd("hi GitSignsChangeInline ctermfg=blue ctermbg=none guibg=#0043AE guifg=none gui=bold cterm=bold") +vim.cmd("hi GitSignsAddLnInline ctermfg=green ctermbg=none guibg=#306C37 guifg=none gui=bold cterm=bold") +vim.cmd("hi GitSignsDeleteLnInline ctermfg=red ctermbg=none guibg=#740009 guifg=none gui=bold cterm=bold") +vim.cmd("hi GitSignsChangeLnInline ctermfg=blue ctermbg=none guibg=#0043AE guifg=none gui=bold cterm=bold") +vim.cmd("hi GitSignsAddVirtLnInline ctermfg=green ctermbg=none guibg=#306C37 guifg=none gui=bold cterm=bold") +vim.cmd("hi GitSignsDeleteVirtLnInline ctermfg=red ctermbg=none guibg=#740009 guifg=none gui=bold cterm=bold") +vim.cmd("hi GitSignsChangeVirtLnInline ctermfg=blue ctermbg=none guibg=#0043AE guifg=none gui=bold cterm=bold") + +-- Colorscheme application +pcall(vim.cmd, "colorscheme codedark") +_G.SetTransparent() +vim.cmd("hi CursorLine guibg=NONE ctermbg=NONE gui=bold,undercurl cterm=bold guisp=#777777") diff --git a/.config/nvim/init.vim b/.config/nvim/init.vim deleted file mode 100644 index 330f6fd..0000000 --- a/.config/nvim/init.vim +++ /dev/null @@ -1,1116 +0,0 @@ -lua << EOF - vim.o.sessionoptions="blank,buffers,curdir,folds,help,tabpages,winsize,winpos,terminal,localoptions" -EOF - -call plug#begin('~/.local/share/nvim/plugged') -Plug 'rust-lang/rust.vim' -Plug 'jyapayne/nim.vim' -Plug 'tpope/vim-fugitive' -Plug 'tpope/vim-unimpaired' -Plug 'preservim/nerdtree' | - \ Plug 'Xuyuanp/nerdtree-git-plugin' -Plug 'hynek/vim-python-pep8-indent' -Plug 'pangloss/vim-javascript' -Plug 'Glench/Vim-Jinja2-Syntax' -Plug 'tpope/vim-haml' -Plug 'hdima/python-syntax' -Plug 'hail2u/vim-css3-syntax' -Plug 'mxw/vim-jsx' -Plug 'ryanoasis/vim-devicons' -Plug 'johnstef99/vim-nerdtree-syntax-highlight' -Plug 'jistr/vim-nerdtree-tabs' -Plug 'mustache/vim-mustache-handlebars' -Plug 'vim-scripts/errormarker.vim' -Plug 'elixir-lang/vim-elixir' -Plug 'jreybert/vim-largefile' -Plug 'sbdchd/neoformat' -Plug 'tikhomirov/vim-glsl' -Plug 'svermeulen/vim-easyclip' -" Plug 'tpope/vim-obsession' -" Plug 'dhruvasagar/vim-prosession' -Plug 'tmux-plugins/vim-tmux-focus-events' -Plug 'rmagatti/auto-session' -Plug 'vim-airline/vim-airline' -Plug 'vim-airline/vim-airline-themes' -" Plug 'vim-syntastic/syntastic' -"Plug 'itchyny/lightline.vim' -Plug 'morhetz/gruvbox' -Plug 'tpope/vim-commentary' -Plug 'w0rp/ale' -Plug 'ctrlpvim/ctrlp.vim' -Plug 'udalov/kotlin-vim' -Plug 'simnalamburt/vim-mundo' -Plug 'christoomey/vim-tmux-navigator' -Plug 'tpope/vim-surround' -" Plug 'alaviss/nim.nvim' -Plug 'prabirshrestha/asyncomplete.vim' -Plug 'tpope/vim-repeat' -Plug 'christoomey/vim-sort-motion' -Plug 'christoomey/vim-system-copy' -Plug 'michaeljsmith/vim-indent-object' -Plug 'kana/vim-textobj-user' -Plug 'kana/vim-textobj-line' -Plug 'Julian/vim-textobj-brace' -Plug 'bps/vim-textobj-python' -Plug 'wellle/targets.vim' -Plug 'junegunn/fzf', { 'do': { -> fzf#install() } } -Plug 'junegunn/fzf.vim' -Plug 'jremmen/vim-ripgrep' -Plug 'rescript-lang/vim-rescript' -Plug 'neoclide/coc.nvim', {'branch': 'master', 'do': 'yarn install --frozen-lockfile'} -Plug 'kassio/neoterm' -Plug 'reasonml-editor/vim-reason-plus' -Plug 'jyapayne/vim-code-dark' -" Plug 'jyapayne/vimspector' -Plug 'nvim-lua/popup.nvim' -Plug 'nvim-lua/plenary.nvim' -Plug 'nvim-telescope/telescope.nvim' -Plug 'kyazdani42/nvim-web-devicons' -Plug 'ryanoasis/vim-devicons' -Plug 'TimUntersberger/neogit' -Plug 'sindrets/diffview.nvim', {'branch': 'main'} -Plug 'lewis6991/gitsigns.nvim', {'branch': 'main'} -Plug 'peterhoeg/vim-qml' -Plug 'mfussenegger/nvim-dap' -Plug 'posva/vim-vue' -" Plug 'rcarriga/nvim-dap-ui' -Plug 'nvim-treesitter/nvim-treesitter', {'do': ':TSUpdate'} -" Plug 'nvim-treesitter/playground' -Plug 'nvim-telescope/telescope-dap.nvim' -Plug 'theHamsta/nvim-dap-virtual-text' -Plug 'mfussenegger/nvim-dap-python' -Plug 'KabbAmine/vCoolor.vim' -" Plug 'chrisbra/Colorizer' -Plug 'norcalli/nvim-colorizer.lua' -Plug 'edluffy/hologram.nvim' -Plug 'fatih/vim-go' -Plug 'folke/trouble.nvim' - - -"Plug 'baabelfish/nvim-nim' -call plug#end() -let g:EasyClipUseGlobalPasteToggle = 0 - -" map [1;5A -" map [1;5B -" map [1;5C -" map [1;5D -nnoremap gm m -nnoremap w -let g:ale_shell="/bin/bash" -let g:lsp_log_verbose = 1 -let g:lsp_log_file = expand('/tmp/vim-lsp.log') - -" Live updating substitution! -set inccommand=nosplit -let g:airline#extensions#ale#enabled = 1 - -let mapleader = "\" -let maplocalleader = "\" - -let g:syntastic_c_compiler_options = "-std=c99" -set guicursor=v-c-sm:block,n-i-ci-ve:ver25,r-cr-o:hor20 - -" inoremap vmark ✓ - -augroup Binary - au! - au BufReadPre *.bin let &bin=1 - au BufReadPost *.bin if &bin | %!xxd - au BufReadPost *.bin set ft=xxd | endif - au BufWritePre *.bin if &bin | %!xxd -r - au BufWritePre *.bin endif - au BufWritePost *.bin if &bin | %!xxd - au BufWritePost *.bin set nomod | endif -augroup END - -set wildmenu -set wildmode=full -"set shell=bash -set smartindent -set ruler -set t_Co=256 - -set backspace=2 -set autowrite - -set smarttab - -set expandtab -set nocompatible -set history=10000 -set foldmethod=indent -set foldlevel=99 -let g:pydiction_location='/home/joey/.vim/bundle/pydiction/complete-dict' -let g:jsx_ext_required = 0 -let g:asyncrun_auto = "make" -let g:syntastic_enable_elixir_checker = 1 -let g:syntastic_elixir_checkers = ['elixir'] -let g:LargeFile = 20 -"set rtp+=/usr/local/lib/python2.7/dist-packages/powerline/bindings/vim/ -set laststatus=2 -let g:airline_powerline_fonts = 1 -let g:airline_section_x = '' -let g:airline_section_y = '' -let g:airline_section_warning = '' -let g:airline_section_z = '%l/%L:%c' - - -set undofile " Save undo's after file closes -set undodir=$HOME/.vim/undo " where to save undo histories -set undolevels=10000 -set undoreload=10000 " number of lines to save for undo -filetype plugin indent on -set incsearch -set guicursor= - -let $NVIM_TUI_ENABLE_CURSOR_SHAPE = 0 - -set mouse=a -set tabstop=4 -set shiftwidth=4 - -"set statusline+=%{SyntasticStatuslineFlag()} -"set statusline+=%* - -let g:syntastic_check_on_wq = 0 -let g:python_highlight_space_errors = 0 -let g:jsx_ext_required = 0 -"let g:airline#extensions#tabline#enabled = 1 - -autocmd Filetype javascript setlocal ts=2 sw=2 expandtab - -map :NERDTreeTabsToggle -autocmd bufenter * if (winnr("$") == 1 && exists("b:NERDTree") && b:NERDTree.isTabTree()) | q | endif -let g:NERDTreeDirArrowExpandable = '▸' -let g:NERDTreeDirArrowCollapsible = '▾' -autocmd Filetype nim setlocal ts=2 sts=2 sw=2 expandtab -autocmd Filetype ts setlocal ts=2 sts=2 sw=2 expandtab -autocmd Filetype vue setlocal ts=2 sts=2 sw=2 expandtab -autocmd Filetype less setlocal ts=2 sts=2 sw=2 expandtab -autocmd Filetype css setlocal ts=2 sts=2 sw=2 expandtab -let g:syntastic_javascript_checkers = ['eslint', 'flow'] -let g:syntastic_java_checkers = [] - -let g:neoformat_javascript_prettier = { - \ 'exe': 'prettier', - \ 'args': ['--single-quote', '--trailing-comma all'], - \ } - -let g:toggleJSFormat = 0 -function! ToggleJSFormat(...) - if a:0 == 1 "toggle behaviour - let g:toggleJSFormat = 1 - g:toggleJSFormat - endif - - if g:toggleJSFormat == 0 "normal action, do the hi - autocmd! - autocmd BufWritePre *.js Neoformat - autocmd BufWritePre *.jsx Neoformat - else - autocmd! - autocmd BufWritePre *.js "" - autocmd BufWritePre *.jsx "" - endif -endfunction - -map :call ToggleJSFormat(1) -"call ToggleJSFormat() - -" autocmd BufNew * if winnr('$') == 1 | tabmove99 | endif - -au! FileType python setl nosmartindent -au BufRead,BufNewFile *.py,*.js,*.jsx,*.nim,*.ml,*.mli match OverLength /\%89v.\+/ -au BufRead,BufNewFile *.py,*.js,*.jsx,*.nim,*.ml,*.mli 2match ExtraWhiteSpace /\s\+$\|\t/ -au StdinReadPost * set buftype=nofile -syntax on - -command C let @/="" -command CC :%s#_\(\l\)#\u\1#g -command U :%s#\C\(\<\u[a-z0-9]\+\|[a-z0-9]\+\)\(\u\)#\l\1_\l\2#g - -" clipboard mappings moved to end of file - -nmap =j :%!python3 -m json.tool - -if !exists("autocommands_loaded") - let autocommands_loaded = 1 - " autocmd BufRead,BufNewFile,FileReadPost *.py source ~/.vim/python -endif -au BufRead,BufNewFile *.shpaml setfiletype shpaml - -nnoremap :let _s=@/:%s/\s\+$//e:let @/=_s:nohl - -" This beauty remembers where you were the last time you edited the file, and returns to the same position. -au BufReadPost * if line("'\"") > 0|if line("'\"") <= line("$")|exe("norm '\"")|else|exe "norm $"|endif|endif -au BufRead,BufNewFile *.sass set filetype=sass - -map :mksession! ~/.vim_session -map :source ~/.vim_session - -" delete without yanking -nnoremap d "_d -vnoremap d "_d - -" Bubble single lines -nmap [e -nmap ]e -" Bubble multiple lines -vmap [egv -vmap ]egv - -" make escape key not delay -set timeoutlen=1000 ttimeoutlen=0 - -" nmap [e -" nmap ]e -vmap [egv -vmap ]egv - -vnoremap # :s#^#\## -vnoremap -# :s#^\### - -fun! JumpToDef() - if exists("*GotoDefinition_" . &filetype) - call GotoDefinition_{&filetype}() - else - exe "norm! \" - endif -endf - -" Jump to tag -" nn :call JumpToDef() -" ino :call JumpToDef()i - -"nn :Rg -nnoremap ff :Rg - -autocmd FileType ocaml nmap :MerlinTypeOf - -" replace currently selected text with default register -" without yanking it -vnoremap p "_dP -let g:ycm_autoclose_preview_window_after_completion = 1 -let g:ycm_min_num_of_chars_for_completion = 99 -let g:flow#enable = 0 - -command! -bang -nargs=* -complete=file Make AsyncRun -program=make @ - -let g:ctrlp_custom_ignore = { - \ 'dir': '\v[\/](\.git|node_modules|nimcache|\.sass-cache|bower_components|build|dist)$', - \ 'file': '\v\.(exe|so|dll|o)$', - \ 'link': '', - \ } -let g:ctrlp_prompt_mappings = { - \ 'AcceptSelection("e")': [''], - \ 'AcceptSelection("t")': ['', '<2-LeftMouse>'], - \ } - - -" noremap ˚ :tabr -" noremap ∆ :tabl -noremap ˙ gT -noremap ¬ gt - -noremap gT -noremap gt - - - -" inoremap ˚ :tabri -" inoremap ∆ :tabli -inoremap ˙ gTi -inoremap ¬ gti - -inoremap gTi -inoremap gti - -set clipboard=unnamedplus -let g:EasyClipShareYanks = 1 - - -"set statusline+=%#warningmsg# -"set statusline+=%{SyntasticStatuslineFlag()} -"set statusline+=%* - -"let g:syntastic_always_populate_loc_list = 1 -"let g:syntastic_auto_loc_list = 1 -"let g:syntastic_check_on_wq = 0 - - -let g:gitsigns_head = "main" - -" lewis6991/gitsigns.nvim -lua << EOF - require('gitsigns').setup({word_diff = true }) -EOF - -" let g:vimspector_install_gadgets = [ 'debugpy', 'vscode-cpptools', 'CodeLLDB' ] -" puremourning/vimspector - " fun! GotoWindow(id) - " :call win_gotoid(a:id) - " endfun - " func! AddToWatch() - " let word = expand("") - " call vimspector#AddWatch(word) - " endfunction - " let g:vimspector_base_dir = expand('$HOME/.config/vimspector-config') - " let g:vimspector_sidebar_width = 60 - " nnoremap da :call vimspector#Launch() - " nnoremap dc :call GotoWindow(g:vimspector_session_windows.code) - " nnoremap dv :call GotoWindow(g:vimspector_session_windows.variables) - " nnoremap dw :call GotoWindow(g:vimspector_session_windows.watches) - " nnoremap ds :call GotoWindow(g:vimspector_session_windows.stack_trace) - " nnoremap do :call GotoWindow(g:vimspector_session_windows.output) - " nnoremap di :call AddToWatch() - " nnoremap dx :call vimspector#Reset() - " nnoremap dX :call vimspector#ClearBreakpoints() - " nnoremap :call vimspector#StepOut() - " nnoremap :call vimspector#StepInto() - " nnoremap :call vimspector#StepOver() - " nnoremap d_ :call vimspector#Restart() - " nnoremap dn :call vimspector#Continue() - " nnoremap drc :call vimspector#RunToCursor() - " nnoremap dh :call vimspector#ToggleBreakpoint() - " nnoremap de :call vimspector#ToggleConditionalBreakpoint() - " let g:vimspector_sign_priority = { - " \ 'vimspectorBP': 998, - " \ 'vimspectorBPCond': 997, - " \ 'vimspectorBPDisabled': 996, - " \ 'vimspectorPC': 999, - " \ } - - -let $NVIM_TUI_ENABLE_TRUE_COLOR=1 -set termguicolors -lua require'colorizer'.setup() - -nnoremap :MundoToggle -nnoremap riW ciW0 -nnoremap riw ciw0 -let g:EasyClipShareYanks = 1 - -"let base16colorspace=256 -" set background=dark -"colorscheme base16-default-dark -" ## added by OPAM user-setup for vim / base ## 93ee63e278bdfc07d1139a748ed3fff2 ## you can edit, but keep this line -"let g:airline_theme='one' -set background=dark -syntax enable -"colorscheme one -"let ayucolor="dark" " for dark version of theme -"colorscheme ayu - -" Vim color file -" vimdefault -" Created by Joey with ThemeCreator (https://github.com/mswift42/themecreator) - - -if exists("syntax on") -syntax reset -endif - -set t_Co=256 -"let g:colors_name = "vimdefault" - - -" Define reusable colorvariables. -let s:bg="#000000" -let s:fg="#ffffff" -let s:fg2="#ebebeb" -let s:fg3="#d6d6d6" -let s:fg4="#c2c2c2" -let s:bg2="#141414" -let s:bg3="#292929" -let s:bg4="#3d3d3d" -let s:keyword="#a65a00" -let s:builtin="#10a500" -let s:const= "#CC0000" -let s:comment="#2d64a4" -let s:func="#00a0e2" -let s:str="#C40000" -let s:type="#3B9B00" -let s:ident="#06989A" -let s:preproc="#75507B" -let s:var="#ffffff" -let s:warning="#e81050" -let s:warning2="#e86310" -let s:parenbg="#3a71c9" -let s:todo="yellow" - - -exe 'hi Normal guifg='s:fg' guibg='s:bg -exe 'hi Cursor guifg='s:bg' guibg='s:fg -exe 'hi CursorLine guibg='s:bg2 -exe 'hi CursorColumn guibg='s:bg2 -exe 'hi ColorColumn guibg='s:bg2 -exe 'hi LineNr guifg='s:fg2' guibg='s:bg2 -exe 'hi VertSplit guifg='s:fg3' guibg='s:bg3 -exe 'hi MatchParen guifg='s:fg' guibg='s:parenbg' gui=none' -exe 'hi Pmenu guifg='s:fg' guibg='s:bg2 -exe 'hi PmenuSel guibg='s:bg3 -exe 'hi IncSearch guifg='s:bg' guibg='s:keyword -exe 'hi Directory guifg='s:const -exe 'hi Folded guifg='s:fg4' guibg='s:bg - -exe 'hi Boolean guifg='s:const -exe 'hi Character guifg='s:const -exe 'hi Comment guifg='s:comment -exe 'hi Conditional guifg='s:keyword -exe 'hi Constant guifg='s:const -exe 'hi Define guifg='s:keyword -exe 'hi DiffAdd guifg=#000000 guibg=#ddffdd gui=bold' -exe 'hi DiffDelete guifg=#ff0000' -exe 'hi DiffChange guibg='s:bg2 -exe 'hi DiffText guifg=#000000 guibg=#ddddff gui=bold' -exe 'hi ErrorMsg guifg='s:warning' guibg='s:bg2' gui=bold' -exe 'hi WarningMsg guifg='s:fg' guibg='s:warning2 -exe 'hi Float guifg='s:const -exe 'hi Function guifg='s:func -exe 'hi Identifier guifg='s:ident' gui=italic' -exe 'hi Keyword guifg='s:keyword' gui=bold' -exe 'hi Label guifg='s:var -exe 'hi NonText guifg='s:bg4' guibg='s:bg2 -exe 'hi Number guifg='s:const -exe 'hi Operater guifg='s:keyword -exe 'hi PreProc guifg='s:preproc -exe 'hi Special guifg='s:preproc -exe 'hi SpecialKey guifg='s:fg2' guibg='s:bg2 -exe 'hi Statement guifg='s:keyword -exe 'hi StorageClass guifg='s:type' gui=italic' -exe 'hi String guifg='s:str -exe 'hi Tag guifg='s:keyword -exe 'hi Title guifg='s:fg' gui=bold' -exe 'hi Todo guibg='s:todo' guifg=black gui=bold' -exe 'hi Type guifg='s:type' gui=none' -exe 'hi Underlined gui=underline' - -" Ruby Highlighting -exe 'hi rubyAttribute guifg='s:builtin -exe 'hi rubyLocalVariableOrMethod guifg='s:var -exe 'hi rubyGlobalVariable guifg='s:var' gui=italic' -exe 'hi rubyInstanceVariable guifg='s:var -exe 'hi rubyKeyword guifg='s:keyword -exe 'hi rubyKeywordAsMethod guifg='s:keyword' gui=bold' -exe 'hi rubyClassDeclaration guifg='s:keyword' gui=bold' -exe 'hi rubyClass guifg='s:keyword' gui=bold' -exe 'hi rubyNumber guifg='s:const - -" Python Highlighting -exe 'hi pythonBuiltinFunc guifg='s:builtin - -" Go Highlighting -exe 'hi goBuiltins guifg='s:builtin - -" Javascript Highlighting -exe 'hi jsBuiltins guifg='s:builtin -exe 'hi jsFunction guifg='s:keyword' gui=bold' -exe 'hi jsGlobalObjects guifg='s:type -exe 'hi jsAssignmentExps guifg='s:var - -" Html Highlighting -exe 'hi htmlLink guifg='s:var' gui=underline' -exe 'hi htmlStatement guifg='s:keyword -exe 'hi htmlSpecialTagName guifg='s:keyword - -" Markdown Highlighting -exe 'hi mkdCode guifg='s:builtin - - - -"inoremap pumvisible() ? "\" : "\" -autocmd! CompleteDone * if pumvisible() == 0 | pclose | endif -" set completeopt+=preview -set rtp+=/usr/local/opt/fzf -function! WrapForTmux(s) - if !exists('$TMUX') - return a:s - endif - - let tmux_start = "\Ptmux;" - let tmux_end = "\\\" - - return tmux_start . substitute(a:s, "\", "\\", 'g') . tmux_end -endfunction - -let &t_SI .= WrapForTmux("\[?2004h") -let &t_EI .= WrapForTmux("\[?2004l") - -function! XTermPasteBegin() - set pastetoggle=[201~ - set paste - return "" -endfunction - -inoremap [200~ XTermPasteBegin() - -" The Silver Searcher -if executable('ag') - " Use ag over grep - set grepprg=ag\ --nogroup\ --nocolor\ --vimgrep - - " Use ag in CtrlP for listing files. Lightning fast and respects .gitignore - let g:ctrlp_user_command = 'ag %s -l --nocolor -g ""' - - " ag is fast enough that CtrlP doesn't need to cache - let g:ctrlp_use_caching = 0 -endif - -" bind K to grep word under cursor -nnoremap K :grep! "\b\b":cw -set switchbuf+=usetab,newtab - - -autocmd FileType rescript nnoremap r :RescriptFormat -autocmd FileType rescript nnoremap t :RescriptTypeHint -autocmd FileType rescript nnoremap b :RescriptBuild -autocmd FileType rescript nnoremap gd :RescriptJumpToDefinition - -let g:asyncomplete_auto_completeopt=0 - -" Set internal encoding of vim, not needed on neovim, since coc.nvim using some -" unicode characters in the file autoload/float.vim -set encoding=utf-8 -set nobackup -set nowritebackup - -" TextEdit might fail if hidden is not set. -set hidden - -" Some servers have issues with backup files, see #649. -" set nobackup -" set nowritebackup - -" Give more space for displaying messages. -set cmdheight=1 - -" Having longer updatetime (default is 4000 ms = 4 s) leads to noticeable -" delays and poor user experience. -set updatetime=300 - -" Don't pass messages to |ins-completion-menu|. -set shortmess+=c - -" Always show the signcolumn, otherwise it would shift the text each time -" diagnostics appear/become resolved. -if has("nvim-0.5.0") || has("patch-8.1.1564") - " Recently vim can merge signcolumn and number column into one - set signcolumn=number -else - set signcolumn=yes -endif -au FileType python let b:coc_root_patterns = ['.git', '.env', 'venv', '.venv', 'setup.cfg', 'setup.py', 'pyrightconfig.json', 'env'] - -" Use tab for trigger completion with characters ahead and navigate. -" NOTE: There's always complete item selected by default, you may want to enable -" no select by `"suggest.noselect": true` in your configuration file. -" NOTE: Use command ':verbose imap ' to make sure tab is not mapped by -" other plugin before putting this into your config. -inoremap - \ coc#pum#visible() ? coc#pum#next(1) : - \ CheckBackspace() ? "\" : - \ coc#refresh() -inoremap coc#pum#visible() ? coc#pum#prev(1) : "\" - -" Make to accept selected completion item or notify coc.nvim to format -" u breaks current undo, please make your own choice. -inoremap coc#pum#visible() ? coc#pum#confirm() - \: "\u\\=coc#on_enter()\" - -function! CheckBackspace() abort - let col = col('.') - 1 - return !col || getline('.')[col - 1] =~# '\s' -endfunction - -" Use to trigger completion. -if has('nvim') - inoremap coc#refresh() -else - inoremap coc#refresh() -endif - - -" Use `[g` and `]g` to navigate diagnostics -" Use `:CocDiagnostics` to get all diagnostics of current buffer in location list. -nmap [g (coc-diagnostic-prev) -nmap ]g (coc-diagnostic-next) - -" GoTo code navigation. -nmap gd (coc-definition) -nmap gy (coc-type-definition) -nmap gi (coc-implementation) -nmap gr (coc-references) - -" Use K to show documentation in preview window. -nnoremap K :call show_documentation() - -function! s:show_documentation() - if (index(['vim','help'], &filetype) >= 0) - execute 'h '.expand('') - elseif (coc#rpc#ready()) - call CocActionAsync('doHover') - else - execute '!' . &keywordprg . " " . expand('') - endif -endfunction - -" Highlight the symbol and its references when holding the cursor. -autocmd CursorHold * silent call CocActionAsync('highlight') - -" Symbol renaming. -nmap rn (coc-rename) - -" Formatting selected code. -xmap f (coc-format-selected) -nmap f (coc-format-selected) - -augroup mygroup - autocmd! - " Setup formatexpr specified filetype(s). - autocmd FileType typescript,json setl formatexpr=CocAction('formatSelected') - " Update signature help on jump placeholder. - autocmd User CocJumpPlaceholder call CocActionAsync('showSignatureHelp') -augroup end - -" Applying codeAction to the selected region. -" Example: `aap` for current paragraph -xmap a (coc-codeaction-selected) -nmap a (coc-codeaction-selected) - -" Remap keys for applying codeAction to the current buffer. -nmap ac (coc-codeaction) -" Apply AutoFix to problem on the current line. -nmap qf (coc-fix-current) - -" Map function and class text objects -" NOTE: Requires 'textDocument.documentSymbol' support from the language server. -xmap if (coc-funcobj-i) -omap if (coc-funcobj-i) -xmap af (coc-funcobj-a) -omap af (coc-funcobj-a) -xmap ic (coc-classobj-i) -omap ic (coc-classobj-i) -xmap ac (coc-classobj-a) -omap ac (coc-classobj-a) - -" Remap and for scroll float windows/popups. -nnoremap coc#float#has_scroll() ? coc#float#scroll(1) : "\" -nnoremap coc#float#has_scroll() ? coc#float#scroll(0) : "\" -inoremap coc#float#has_scroll() ? "\=coc#float#scroll(1)\" : "\" -inoremap coc#float#has_scroll() ? "\=coc#float#scroll(0)\" : "\" -vnoremap coc#float#has_scroll() ? coc#float#scroll(1) : "\" -vnoremap coc#float#has_scroll() ? coc#float#scroll(0) : "\" - -" Use CTRL-S for selections ranges. -" Requires 'textDocument/selectionRange' support of language server. -nmap (coc-range-select) -xmap (coc-range-select) - -" Add `:Format` command to format current buffer. -command! -nargs=0 Format :call CocAction('format') - -" Add `:Fold` command to fold current buffer. -command! -nargs=? Fold :call CocAction('fold', ) - -" Add `:OR` command for organize imports of the current buffer. -command! -nargs=0 OR :call CocAction('runCommand', 'editor.action.organizeImport') - -" Add (Neo)Vim's native statusline support. -" NOTE: Please see `:h coc-status` for integrations with external plugins that -" provide custom statusline: lightline.vim, vim-airline. -set statusline^=%{coc#status()}%{get(b:,'coc_current_function','')} - -" Mappings for CoCList -" Show all diagnostics. -nnoremap a :CocList diagnostics -" Manage extensions. -nnoremap e :CocList extensions -" Show commands. -nnoremap c :CocList commands -" Find symbol of current document. -nnoremap o :CocList outline -" Search workspace symbols. -nnoremap s :CocList -I symbols -" Do default action for next item. -nnoremap j :CocNext -" Do default action for previous item. -nnoremap k :CocPrev -" Resume latest coc list. -nnoremap p :CocListResume - -" kassio/neoterm -let g:neoterm_default_mod = 'vertical botright' -" let g:neoterm_size = 100 -let g:neoterm_autoinsert = 1 -let g:neoterm_autoscroll = 1 -let g:neoterm_term_per_tab = 1 -nnoremap :Ttoggle -inoremap :Ttoggle -tnoremap :Ttoggle -tnoremap - -" color scheme -colorscheme codedark -set cursorline -filetype on -autocmd ColorScheme * highlight ExtraWhitespace ctermbg=darkgreen guibg=darkgreen - -highlight ExtraWhitespace ctermbg=darkgreen guibg=darkgreen -" highlight OverLength ctermbg=red ctermfg=black guibg=#592929 gui=bold - -highlight ALEError ctermbg=red guibg=#700000 -highlight ALEErrorSign ctermfg=none ctermbg=black guifg=red guibg=#212121 -highlight ALEWarning ctermbg=yellow guibg=#504a08 -highlight ALEWarningSign ctermfg=yellow ctermbg=none guibg=#212121 guifg=#ecd517 -highlight SignColumn ctermbg=darkgrey guibg=#212121 -" highlight TabLineFill guibg=none guifg=none gui=none -" highlight TabLineSel guibg=#353535 guifg=none -" highlight TabLine guibg=none guifg=none -highlight CocFadeOut ctermfg=lightgrey guifg=#8B8C92 -" highlight CocHintVirtualText guifg=blue ctermbg=none guibg=none -" highlight CocHintHighlight guifg=blue ctermbg=none guibg=none -highlight CocHintSign guifg=#647644 ctermfg=lightblue ctermbg=darkgrey guibg=#212121 -highlight CocErrorSign guifg=red ctermfg=red ctermbg=darkgrey guibg=#212121 -highlight CocInlayHint guifg=#3D7671 ctermfg=lightblue ctermbg=darkgrey guibg=none -highlight CocHighlightText ctermbg=lightblue guibg=#002c4b - - -hi Normal ctermbg=none guibg=none -hi EndOfBuffer ctermbg=none guibg=none -"hi SignColumn ctermbg=none guibg=none -hi NonText ctermbg=none guibg=none -hi LineNr ctermbg=none guibg=none -"hi CursorLine cterm=NONE ctermbg=black ctermfg=NONE guibg=black gui=NONE guifg=NONE -set noshowmode - -" let g:opamshare = substitute(system('opam var share'),'\n$','','''') -" execute "set rtp+=" . g:opamshare . "/merlin/vim" - -" ## added by OPAM user-setup for vim / base ## 93ee63e278bdfc07d1139a748ed3fff2 ## you can edit, but keep this line -" let s:opam_share_dir = system("opam config var share") -" let s:opam_share_dir = substitute(s:opam_share_dir, '[\r\n]*$', '', '') - -" let s:opam_configuration = {} - -" function! OpamConfOcpIndent() -" execute "set rtp^=" . s:opam_share_dir . "/ocp-indent/vim" -" endfunction -" let s:opam_configuration['ocp-indent'] = function('OpamConfOcpIndent') - -" function! OpamConfOcpIndex() -" execute "set rtp+=" . s:opam_share_dir . "/ocp-index/vim" -" endfunction -" let s:opam_configuration['ocp-index'] = function('OpamConfOcpIndex') - -" function! OpamConfMerlin() -" let l:dir = s:opam_share_dir . "/merlin/vim" -" execute "set rtp+=" . l:dir -" endfunction -" let s:opam_configuration['merlin'] = function('OpamConfMerlin') - -" let s:opam_packages = ["ocp-indent", "ocp-index", "merlin"] -" let s:opam_check_cmdline = ["opam list --installed --short --safe --color=never"] + s:opam_packages -" let s:opam_available_tools = split(system(join(s:opam_check_cmdline))) -" for tool in s:opam_packages -" " Respect package order (merlin should be after ocp-index) -" if count(s:opam_available_tools, tool) > 0 -" call s:opam_configuration[tool]() -" endif -" endfor - -" ## end of OPAM user-setup addition for vim / base ## keep this line -let g:ale_linters = {'java': [], 'python': [], 'typescript': []} - -" " for normal mode - the word under the cursor -" nmap di VimspectorBalloonEval -" " for visual mode, the visually selected text -" xmap di VimspectorBalloonEval -" let g:vimspector_enable_mappings = 'HUMAN' - -" nnoremap :GFiles - -" nvim-telescope/telescope.nvim - -lua << EOF -require('hologram').setup{ - auto_display = true -- WIP automatic markdown image display, may be prone to breaking -} -_G.telescope_find_files_in_path = function(path) - local _path = path or vim.fn.input("Dir: ", "", "dir") - require("telescope.builtin").find_files({search_dirs = {_path}}) -end -EOF - -lua << EOF -_G.telescope_live_grep_in_path = function(path) - local _path = path or vim.fn.input("Dir: ", "", "dir") - require("telescope.builtin").live_grep({search_dirs = {_path}}) -end -EOF - -lua << EOF -require'nvim-treesitter.config'.setup { - -- A list of parser names, or "all" (the four listed parsers should always be installed) - ensure_installed = { "c", "lua", "vim", "vimdoc", "query", "markdown", "markdown_inline", "go" }, - - -- Install parsers synchronously (only applied to `ensure_installed`) - sync_install = false, - - -- Automatically install missing parsers when entering buffer - -- Recommendation: set to false if you don't have `tree-sitter` CLI installed locally - auto_install = true, - - -- List of parsers to ignore installing (for "all") - ignore_install = { }, - - ---- If you need to change the installation directory of the parsers (see -> Advanced Setup) - -- parser_install_dir = "/some/path/to/store/parsers", -- Remember to run vim.opt.runtimepath:append("/some/path/to/store/parsers")! - - highlight = { - enable = true, - - -- NOTE: these are the names of the parsers and not the filetype. (for example if you want to - -- disable highlighting for the `tex` filetype, you need to include `latex` in this list as this is - -- the name of the parser) - -- list of language that will be disabled - disable = { "python", "nim" }, - - -- Setting this to true will run `:h syntax` and tree-sitter at the same time. - -- Set this to `true` if you depend on 'syntax' being enabled (like for indentation). - -- Using this option may slow down your editor, and you may see some duplicate highlights. - -- Instead of true it can also be a list of languages - additional_vim_regex_highlighting = false, - }, - playground = { - enable = true, - disable = {}, - updatetime = 25, -- Debounced time for highlighting nodes in the playground from source code - persist_queries = false, -- Whether the query persists across vim sessions - keybindings = { - toggle_query_editor = 'o', - toggle_hl_groups = 'i', - toggle_injected_languages = 't', - toggle_anonymous_nodes = 'a', - toggle_language_display = 'I', - focus_language = 'f', - unfocus_language = 'F', - update = 'R', - goto_node = '', - show_help = '?', - }, - } -} -require('auto-session').setup { - auto_save_enabled = true, - auto_restore_enabled = true -} -EOF - -let b:current_syntax = 'nim' - -nnoremap :Telescope find_files -nnoremap fd :lua telescope_find_files_in_path() -nnoremap fD :lua telescope_live_grep_in_path() -nnoremap ft :lua telescope_find_files_in_path("./tests") -nnoremap fT :lua telescope_live_grep_in_path("./tests") -" nnoremap ff :Telescope live_grep -nnoremap fo :Telescope file_browser -nnoremap fn :Telescope git_files -nnoremap fg :Telescope git_branches -nnoremap fb :Telescope buffers -nnoremap fs :Telescope lsp_document_symbols -nnoremap ff :Telescope live_grep -nnoremap FF :Telescope grep_string - -" mfussenegger/nvim-dap -lua << EOF -local dap = require('dap') - -function os.capture(cmd) - local f = assert(io.popen(cmd .. ' 2>&1', 'r')) - local s = assert(f:read('*a')) - f:close() - return s -end - -dap.adapters.lldb = { - type = 'executable', - command = '/opt/homebrew/opt/llvm/bin/lldb-vscode', -- adjust as needed - name = "lldb" -} -dap.configurations.nim = { - { - name = "Launch", - type = "lldb", - request = "launch", - program = function() - -- return vim.fn.input('Path to executable: ', vim.fn.getcwd() .. '/', 'file') - - print("Compiling...") - local filename = vim.api.nvim_buf_get_name(0) - local res = os.capture('nim c --debugger:native ' .. filename) - print("Running...") - return filename:match("(.+)%..+$"); - end, - cwd = '${workspaceFolder}', - stopOnEntry = false, - args = function() - return vim.fn.input('Args: ', '') - end, - -- if you change `runInTerminal` to true, you might need to change the yama/ptrace_scope setting: - -- - -- echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope - -- - -- Otherwise you might get the following error: - -- - -- Error on launch: Failed to attach to the target process - -- - -- But you should be aware of the implications: - -- https://www.kernel.org/doc/html/latest/admin-guide/LSM/Yama.html - runInTerminal = false - }, -} - -require('dap-python').setup('/opt/homebrew/bin/python3') - --- If you want to use this for rust and c, add something like this: - --- dap.configurations.c = dap.configurations.cpp --- dap.configurations.nim = dap.configurations.cpp - -vim.fn.sign_define('DapBreakpoint', {text='●', texthl='ErrorMsg', linehl='', numhl=''}) -vim.fn.sign_define('DapBreakpointRejected', {text='●', texthl='LineNr', linehl='', numhl=''}) -vim.fn.sign_define('DapLogPoint', {text='L', texthl='', linehl='', numhl=''}) -vim.fn.sign_define('DapStopped', {text='→', texthl='WarningMsg', linehl='debugPC', numhl=''}) -EOF - -function! SynGroup() - let l:s = synID(line('.'), col('.'), 1) - echo synIDattr(l:s, 'name') . ' -> ' . synIDattr(synIDtrans(l:s), 'name') -endfun - - -au FileType dap-repl lua require('dap.ext.autocompl').attach() - -nnoremap :lua for _, win in ipairs(vim.api.nvim_list_wins()) do local config = vim.api.nvim_win_get_config(win); if config.relative ~= "" then vim.api.nvim_win_close(win, false) end end -nnoremap db :lua require'dap'.toggle_breakpoint() -" option-o -nnoremap ø :lua require'dap'.step_out() -" option-K -nnoremap ˚ :lua require'dap'.step_into() -" option-J -nnoremap ∆ :lua require'dap'.step_over() -nnoremap ds :lua require'dap'.close() -nnoremap dn :lua require'dap'.continue() -nnoremap dk :lua require'dap'.up() -nnoremap dj :lua require'dap'.down() -nnoremap d_ :lua require'dap'.disconnect();require'dap'.stop();require'dap'.run_last() -nnoremap dr :lua require'dap'.repl.toggle()l -nnoremap rc :lua require'dap'.run_to_cursor()l -nnoremap rb :lua require'dap'.reverse_continue()l -"nnoremap di :lua require'dap.ui.variables'.hover() -vnoremap di :lua require'dap.ui.variables'.visual_hover() -nnoremap d? :lua require'dap.ui.variables'.scopes() -nnoremap de :lua require'dap'.set_exception_breakpoints({"all"}) -nnoremap da :lua require'debugHelper'.attach() -nnoremap dA :lua require'debugHelper'.attachToRemote() -nnoremap di :lua require'dap.ui.widgets'.hover() -nnoremap qq :q -nnoremap d? :lua local widgets=require'dap.ui.widgets';widgets.centered_float(widgets.scopes) - -" Plug 'nvim-telescope/telescope-dap.nvim' -lua << EOF -require('telescope').setup() -require('telescope').load_extension('dap') -EOF -nnoremap df :Telescope dap frames -nnoremap dc :Telescope dap commands -nnoremap dh :Telescope dap list_breakpoints - -" theHamsta/nvim-dap-virtual-text and mfussenegger/nvim-dap -let g:dap_virtual_text = v:true - -" TimUntersberger/neogit and sindrets/diffview.nvim -lua << EOF -require("neogit").setup { - disable_commit_confirmation = true, - integrations = { - diffview = true - } - } -EOF -nnoremap gg :Neogit -nnoremap gd :DiffviewOpen -nnoremap gD :DiffviewOpen main -nnoremap gl :Neogit log -nnoremap gp :Neogit push - - -hi GitSignsAdd ctermfg=green ctermbg=none guibg=#212121 guifg=#32cd32 gui=bold cterm=bold -hi GitSignsDelete ctermfg=red ctermbg=none guibg=#212121 guifg=#ff6347 gui=bold cterm=bold -hi GitSignsChange ctermfg=blue ctermbg=none guibg=#212121 guifg=#1e90ff gui=bold cterm=bold - -hi GitSignsAddInline ctermfg=none ctermbg=none guibg=#306C37 guifg=none gui=bold cterm=bold -hi GitSignsDeleteInline ctermfg=red ctermbg=none guibg=#740009 guifg=none gui=bold cterm=bold -hi GitSignsChangeInline ctermfg=blue ctermbg=none guibg=#0043AE guifg=none gui=bold cterm=bold - -hi GitSignsAddLnInline ctermfg=green ctermbg=none guibg=#306C37 guifg=none gui=bold cterm=bold -hi GitSignsDeleteLnInline ctermfg=red ctermbg=none guibg=#740009 guifg=none gui=bold cterm=bold -hi GitSignsChangeLnInline ctermfg=blue ctermbg=none guibg=#0043AE guifg=none gui=bold cterm=bold - -hi GitSignsAddVirtLnInline ctermfg=green ctermbg=none guibg=#306C37 guifg=none gui=bold cterm=bold -hi GitSignsDeleteVirtLnInline ctermfg=red ctermbg=none guibg=#740009 guifg=none gui=bold cterm=bold -hi GitSignsChangeVirtLnInline ctermfg=blue ctermbg=none guibg=#0043AE guifg=none gui=bold cterm=bold - -nmap :CocCommand java.debug.vimspector.start -" nnoremap :echo "hi<" . synIDattr(synID(line("."),col("."),1),"name") . '> trans<' -" \ . synIDattr(synID(line("."),col("."),0),"name") . "> lo<" -" \ . synIDattr(synIDtrans(synID(line("."),col("."),1)),"name") . ">" - - -" Nim: replace comment above with comment below -let @t = '/^proc ?^\_[\n]## V/\_[�kb�kb�kb^\_[\n\�kb]prc�kboc m/\.} pdd' -let &t_SI = "\e[5 q" -let &t_EI = "\e[2 q" - -au FileType vue let b:coc_root_patterns = ['.git', '.env', 'package.json', 'tsconfig.json', 'jsconfig.json', 'vite.config.ts', 'vite.config.js', 'vue.config.js', 'nuxt.config.ts'] - -autocmd Filetype typescript setlocal ts=2 sts=2 sw=2 expandtab -autocmd Filetype vue setlocal ts=2 sts=2 sw=2 expandtab - -" init.vim - -set termguicolors -set cursorline - -function! s:SetTransparent() abort - for g in [ - \ 'Normal', 'NormalNC', 'SignColumn', 'EndOfBuffer', 'FoldColumn', - \ 'LineNr', 'MsgArea', 'CursorLine', 'CursorLineNr', - \ 'StatusLine', 'StatusLineNC', 'WinSeparator', 'VertSplit', - \ 'NormalFloat', 'FloatBorder' - \ ] - execute 'hi ' . g . ' ctermbg=NONE guibg=NONE' - endfor -endfunction - -augroup TransparentUI - autocmd! - autocmd ColorScheme * call s:SetTransparent() -augroup END - -call s:SetTransparent() - -set cursorline -set cursorlineopt=line - -hi CursorLine guibg=NONE ctermbg=NONE gui=bold cterm=bold -" Bold + undercurl (very subtle if your terminal supports it) -set cursorline -set cursorlineopt=line -hi CursorLine guibg=NONE ctermbg=NONE gui=bold,undercurl cterm=bold guisp=#777777 - -nmap y "+y -vmap y "+y -nmap p "+p -vmap p "+p