1036 lines
38 KiB
Lua
1036 lines
38 KiB
Lua
-- 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("<cword>"))
|
|
elseif vim.fn["coc#rpc#ready"]() == 1 then
|
|
vim.fn.CocActionAsync("doHover")
|
|
else
|
|
vim.cmd("!" .. vim.o.keywordprg .. " " .. vim.fn.expand("<cword>"))
|
|
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",
|
|
"<Tab>",
|
|
'coc#pum#visible() ? coc#pum#next(1) : v:lua.check_back_space() ? "\\<Tab>" : coc#refresh()',
|
|
expr_opts
|
|
)
|
|
vim.keymap.set("i", "<S-Tab>", 'coc#pum#visible() ? coc#pum#prev(1) : "\\<C-h>"', expr_opts)
|
|
vim.keymap.set(
|
|
"i",
|
|
"<CR>",
|
|
'coc#pum#visible() ? coc#pum#confirm() : "\\<C-g>u\\<CR>\\<c-r>=coc#on_enter()\\<CR>"',
|
|
expr_opts
|
|
)
|
|
|
|
if vim.fn.has("nvim") == 1 then
|
|
vim.keymap.set("i", "<C-Space>", "coc#refresh()", expr_opts)
|
|
else
|
|
vim.keymap.set("i", "<C-@>", "coc#refresh()", expr_opts)
|
|
end
|
|
|
|
vim.keymap.set("n", "[g", "<Plug>(coc-diagnostic-prev)", { silent = true, remap = true })
|
|
vim.keymap.set("n", "]g", "<Plug>(coc-diagnostic-next)", { silent = true, remap = true })
|
|
|
|
vim.keymap.set("n", "gd", "<Plug>(coc-definition)", { silent = true, remap = true })
|
|
vim.keymap.set("n", "gy", "<Plug>(coc-type-definition)", { silent = true, remap = true })
|
|
vim.keymap.set("n", "gi", "<Plug>(coc-implementation)", { silent = true, remap = true })
|
|
vim.keymap.set("n", "gr", "<Plug>(coc-references)", { silent = true, remap = true })
|
|
|
|
vim.keymap.set("n", "<leader>rn", "<Plug>(coc-rename)", { remap = true })
|
|
vim.keymap.set("x", "<leader>f", "<Plug>(coc-format-selected)", { remap = true })
|
|
vim.keymap.set("n", "<leader>f", "<Plug>(coc-format-selected)", { remap = true })
|
|
|
|
vim.keymap.set("x", "<leader>a", "<Plug>(coc-codeaction-selected)", { remap = true })
|
|
vim.keymap.set("n", "<leader>a", "<Plug>(coc-codeaction-selected)", { remap = true })
|
|
vim.keymap.set("n", "<leader>ac", "<Plug>(coc-codeaction)", { remap = true })
|
|
vim.keymap.set("n", "<leader>qf", "<Plug>(coc-fix-current)", { remap = true })
|
|
|
|
vim.keymap.set("x", "if", "<Plug>(coc-funcobj-i)", { remap = true })
|
|
vim.keymap.set("o", "if", "<Plug>(coc-funcobj-i)", { remap = true })
|
|
vim.keymap.set("x", "af", "<Plug>(coc-funcobj-a)", { remap = true })
|
|
vim.keymap.set("o", "af", "<Plug>(coc-funcobj-a)", { remap = true })
|
|
vim.keymap.set("x", "ic", "<Plug>(coc-classobj-i)", { remap = true })
|
|
vim.keymap.set("o", "ic", "<Plug>(coc-classobj-i)", { remap = true })
|
|
vim.keymap.set("x", "ac", "<Plug>(coc-classobj-a)", { remap = true })
|
|
vim.keymap.set("o", "ac", "<Plug>(coc-classobj-a)", { remap = true })
|
|
|
|
vim.keymap.set("n", "<C-f>", 'coc#float#has_scroll() ? coc#float#scroll(1) : "\\<C-f>"', expr_nowait_opts)
|
|
vim.keymap.set("n", "<C-b>", 'coc#float#has_scroll() ? coc#float#scroll(0) : "\\<C-b>"', expr_nowait_opts)
|
|
vim.keymap.set(
|
|
"i",
|
|
"<C-f>",
|
|
'coc#float#has_scroll() ? "\\<c-r>=coc#float#scroll(1)\\<cr>" : "\\<Right>"',
|
|
expr_nowait_opts
|
|
)
|
|
vim.keymap.set(
|
|
"i",
|
|
"<C-b>",
|
|
'coc#float#has_scroll() ? "\\<c-r>=coc#float#scroll(0)\\<cr>" : "\\<Left>"',
|
|
expr_nowait_opts
|
|
)
|
|
vim.keymap.set("v", "<C-f>", 'coc#float#has_scroll() ? coc#float#scroll(1) : "\\<C-f>"', expr_nowait_opts)
|
|
vim.keymap.set("v", "<C-b>", 'coc#float#has_scroll() ? coc#float#scroll(0) : "\\<C-b>"', expr_nowait_opts)
|
|
|
|
vim.keymap.set("n", "<C-s>", "<Plug>(coc-range-select)", { silent = true, remap = true })
|
|
vim.keymap.set("x", "<C-s>", "<Plug>(coc-range-select)", { silent = true, remap = true })
|
|
|
|
vim.keymap.set("n", "<space>a", ":<C-u>CocList diagnostics<CR>", { silent = true, nowait = true })
|
|
vim.keymap.set("n", "<space>e", ":<C-u>CocList extensions<CR>", { silent = true, nowait = true })
|
|
vim.keymap.set("n", "<space>c", ":<C-u>CocList commands<CR>", { silent = true, nowait = true })
|
|
vim.keymap.set("n", "<space>o", ":<C-u>CocList outline<CR>", { silent = true, nowait = true })
|
|
vim.keymap.set("n", "<space>s", ":<C-u>CocList -I symbols<CR>", { silent = true, nowait = true })
|
|
vim.keymap.set("n", "<space>j", ":<C-u>CocNext<CR>", { silent = true, nowait = true })
|
|
vim.keymap.set("n", "<space>k", ":<C-u>CocPrev<CR>", { silent = true, nowait = true })
|
|
vim.keymap.set("n", "<space>p", ":<C-u>CocListResume<CR>", { silent = true, nowait = true })
|
|
|
|
vim.schedule(function()
|
|
vim.keymap.set("n", "K", "<Cmd>lua _G.show_docs()<CR>", { 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 = "<cr>",
|
|
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")'] = { "<c-t>" },
|
|
['AcceptSelection("t")'] = { "<cr>", "<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", "<Tab>", "<C-w>w", { noremap = true })
|
|
|
|
vim.keymap.set({ "n", "v" }, "<C-n>", ":NERDTreeTabsToggle<CR>", { remap = true })
|
|
|
|
vim.keymap.set({ "n", "v" }, "<F9>", "<Cmd>lua ToggleJSFormat(1)<CR>", { remap = true })
|
|
vim.keymap.set("n", "=j", ":%!python3 -m json.tool<CR>", { remap = true })
|
|
vim.keymap.set("n", "<F5>", ":let _s=@/<Bar>:%s/\\s\\+$//e<Bar>:let @/=_s<Bar>:nohl<CR>", { silent = true, noremap = true })
|
|
vim.keymap.set({ "n", "v" }, "<F3>", ":mksession! ~/.vim_session <CR>", { remap = true })
|
|
vim.keymap.set({ "n", "v" }, "<F4>", ":source ~/.vim_session <CR>", { remap = true })
|
|
vim.keymap.set("n", "<F6>", ":MundoToggle<CR>", { noremap = true })
|
|
|
|
vim.keymap.set("n", "<leader>d", '"_d', { noremap = true })
|
|
vim.keymap.set("v", "<leader>d", '"_d', { noremap = true })
|
|
|
|
vim.keymap.set("n", "<C-Up>", "[e", { remap = true })
|
|
vim.keymap.set("n", "<C-Down>", "]e", { remap = true })
|
|
vim.keymap.set("v", "<C-Up>", "[egv", { remap = true })
|
|
vim.keymap.set("v", "<C-Down>", "]egv", { remap = true })
|
|
vim.keymap.set("v", "<C-k>", "[egv", { remap = true })
|
|
vim.keymap.set("v", "<C-j>", "]egv", { remap = true })
|
|
vim.keymap.set("v", "#", ":s#^#\\##<CR>", { noremap = true })
|
|
vim.keymap.set("v", "-#", ":s#^\\###<CR>", { noremap = true })
|
|
|
|
vim.keymap.set("n", "<leader>ff", ":Rg<CR>", { noremap = true })
|
|
|
|
vim.keymap.set("v", "<leader>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" }, "<M-h>", "gT", { noremap = true })
|
|
vim.keymap.set({ "n", "v", "o" }, "<M-l>", "gt", { noremap = true })
|
|
|
|
vim.keymap.set("i", "˙", "<Esc>gTi", { noremap = true })
|
|
vim.keymap.set("i", "¬", "<Esc>gti", { noremap = true })
|
|
vim.keymap.set("i", "<M-h>", "<Esc>gTi", { noremap = true })
|
|
vim.keymap.set("i", "<M-l>", "<Esc>gti", { noremap = true })
|
|
|
|
vim.keymap.set("n", "riW", "ciW<C-r>0<Esc>", { noremap = true })
|
|
vim.keymap.set("n", "riw", "ciw<C-r>0<Esc>", { noremap = true })
|
|
|
|
vim.keymap.set("n", "K", ':grep! "\\b<C-R><C-W>\\b"<CR>:cw<CR>', { silent = true, noremap = true })
|
|
|
|
vim.keymap.set("n", "<leader><space>", ":Telescope find_files<CR>", { noremap = true })
|
|
vim.keymap.set("n", "<leader>fd", ":lua telescope_find_files_in_path()<CR>", { noremap = true })
|
|
vim.keymap.set("n", "<leader>fD", ":lua telescope_live_grep_in_path()<CR>", { noremap = true })
|
|
vim.keymap.set("n", "<leader>ft", ':lua telescope_find_files_in_path("./tests")<CR>', { noremap = true })
|
|
vim.keymap.set("n", "<leader>fT", ':lua telescope_live_grep_in_path("./tests")<CR>', { noremap = true })
|
|
vim.keymap.set("n", "<leader>fo", ":Telescope file_browser<CR>", { noremap = true })
|
|
vim.keymap.set("n", "<leader>fn", ":Telescope git_files<CR>", { noremap = true })
|
|
vim.keymap.set("n", "<leader>fg", ":Telescope git_branches<CR>", { noremap = true })
|
|
vim.keymap.set("n", "<leader>fb", ":Telescope buffers<CR>", { noremap = true })
|
|
vim.keymap.set("n", "<leader>fs", ":Telescope lsp_document_symbols<CR>", { noremap = true })
|
|
vim.keymap.set("n", "<leader>ff", ":Telescope live_grep<CR>", { noremap = true })
|
|
vim.keymap.set("n", "<leader>FF", ":Telescope grep_string<CR>", { noremap = true })
|
|
|
|
vim.keymap.set("n", "<Esc>", 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", "<leader>db", ":lua require'dap'.toggle_breakpoint()<CR>", { silent = true, noremap = true })
|
|
vim.keymap.set("n", "ø", ":lua require'dap'.step_out()<CR>", { silent = true, noremap = true })
|
|
vim.keymap.set("n", "˚", ":lua require'dap'.step_into()<CR>", { silent = true, noremap = true })
|
|
vim.keymap.set("n", "∆", ":lua require'dap'.step_over()<CR>", { silent = true, noremap = true })
|
|
vim.keymap.set("n", "<leader>ds", ":lua require'dap'.close()<CR>", { silent = true, noremap = true })
|
|
vim.keymap.set("n", "<leader>dn", ":lua require'dap'.continue()<CR>", { silent = true, noremap = true })
|
|
vim.keymap.set("n", "<leader>dk", ":lua require'dap'.up()<CR>", { silent = true, noremap = true })
|
|
vim.keymap.set("n", "<leader>dj", ":lua require'dap'.down()<CR>", { silent = true, noremap = true })
|
|
vim.keymap.set("n", "<leader>d_", ":lua require'dap'.disconnect();require'dap'.stop();require'dap'.run_last()<CR>", { silent = true, noremap = true })
|
|
vim.keymap.set("n", "<leader>dr", ":lua require'dap'.repl.toggle()<CR><C-w>l", { silent = true, noremap = true })
|
|
vim.keymap.set("n", "<leader>rc", ":lua require'dap'.run_to_cursor()<CR><C-w>l", { silent = true, noremap = true })
|
|
vim.keymap.set("n", "<leader>rb", ":lua require'dap'.reverse_continue()<CR><C-w>l", { silent = true, noremap = true })
|
|
vim.keymap.set("v", "<leader>di", ":lua require'dap.ui.variables'.visual_hover()<CR>", { silent = true, noremap = true })
|
|
vim.keymap.set("n", "<leader>d?", ":lua require'dap.ui.variables'.scopes()<CR>", { silent = true, noremap = true })
|
|
vim.keymap.set("n", "<leader>de", ":lua require'dap'.set_exception_breakpoints({\"all\"})<CR>", { silent = true, noremap = true })
|
|
vim.keymap.set("n", "<leader>da", ":lua require'debugHelper'.attach()<CR>", { silent = true, noremap = true })
|
|
vim.keymap.set("n", "<leader>dA", ":lua require'debugHelper'.attachToRemote()<CR>", { silent = true, noremap = true })
|
|
vim.keymap.set("n", "<leader>di", ":lua require'dap.ui.widgets'.hover()<CR>", { silent = true, noremap = true })
|
|
vim.keymap.set("n", "<leader>qq", ":q<CR>", { silent = true, noremap = true })
|
|
vim.keymap.set(
|
|
"n",
|
|
"<leader>d?",
|
|
":lua local widgets=require'dap.ui.widgets';widgets.centered_float(widgets.scopes)<CR>",
|
|
{ silent = true, noremap = true }
|
|
)
|
|
vim.keymap.set("n", "<leader>df", ":Telescope dap frames<CR>", { noremap = true })
|
|
vim.keymap.set("n", "<leader>dc", ":Telescope dap commands<CR>", { noremap = true })
|
|
vim.keymap.set("n", "<leader>dh", ":Telescope dap list_breakpoints<CR>", { noremap = true })
|
|
|
|
vim.keymap.set("n", "<leader>gg", ":Neogit<CR>", { noremap = true })
|
|
vim.keymap.set("n", "<leader>gd", ":DiffviewOpen<CR>", { noremap = true })
|
|
vim.keymap.set("n", "<leader>gD", ":DiffviewOpen main<CR>", { noremap = true })
|
|
vim.keymap.set("n", "<leader>gl", ":Neogit log<CR>", { noremap = true })
|
|
vim.keymap.set("n", "<leader>gp", ":Neogit push<CR>", { noremap = true })
|
|
|
|
vim.keymap.set("n", "<C-t>", ":Ttoggle<CR>", { noremap = true })
|
|
vim.keymap.set("i", "<C-t>", "<Esc>:Ttoggle<CR>", { noremap = true })
|
|
vim.keymap.set("t", "<C-t>", "<C-\\><C-n>:Ttoggle<CR>", { noremap = true })
|
|
vim.keymap.set("t", "<Esc>", "<C-\\><C-n>", { noremap = true })
|
|
|
|
vim.keymap.set("n", "<F1>", ":CocCommand java.debug.vimspector.start<CR>", { remap = true })
|
|
|
|
vim.keymap.set("n", "<leader>y", '"+y', { remap = true })
|
|
vim.keymap.set("v", "<leader>y", '"+y', { remap = true })
|
|
vim.keymap.set("n", "<leader>p", '"+p', { remap = true })
|
|
vim.keymap.set("v", "<leader>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", "<localleader>r", ":RescriptFormat<CR>", { silent = true, noremap = true, buffer = args.buf })
|
|
vim.keymap.set("n", "<localleader>t", ":RescriptTypeHint<CR>", { silent = true, noremap = true, buffer = args.buf })
|
|
vim.keymap.set("n", "<localleader>b", ":RescriptBuild<CR>", { silent = true, noremap = true, buffer = args.buf })
|
|
vim.keymap.set("n", "gd", ":RescriptJumpToDefinition<CR>", { 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", "<C-t>", ":MerlinTypeOf<CR>", { 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! <C-]>")
|
|
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 = "<Esc>[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("\<Esc>[?2004h")]])
|
|
vim.cmd([[let &t_EI .= v:lua.WrapForTmux("\<Esc>[?2004l")]])
|
|
end)
|
|
vim.keymap.set("i", "<Esc>[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")
|