392 lines
12 KiB
Lua
392 lines
12 KiB
Lua
local helpers = require("helpers")
|
|
local map = helpers.map
|
|
local lsp_config_defaults = helpers.lsp_config_defaults
|
|
|
|
local M = {}
|
|
|
|
function M.hop()
|
|
require("hop").setup({ keys = "etovxqpdygfblzhckisuran" })
|
|
|
|
local hop_opts = "{ create_hl_autocmd = true }"
|
|
local hopword = [[<cmd>lua require'hop'.hint_words(]] .. hop_opts .. [[)<cr>]]
|
|
local hopline = [[<cmd>lua require'hop'.hint_lines_skip_whitespace(]] .. hop_opts .. [[)<cr>]]
|
|
|
|
map("n", "W", hopline, { silent = true })
|
|
map("v", "W", hopline, { silent = true })
|
|
map("n", "w", hopword, { silent = true })
|
|
map("v", "w", hopword, { silent = true })
|
|
end
|
|
|
|
function M.onedark()
|
|
require("onedark").setup({
|
|
style = "darker",
|
|
toggle_style_key = "<nop>",
|
|
})
|
|
require("onedark").load()
|
|
end
|
|
|
|
function M.fzf()
|
|
map("n", "<Leader>o", ":Files<CR>")
|
|
map("n", "<Leader>O", ":Files ~/<CR>")
|
|
map("n", "<Leader>p", ":Buffers<CR>")
|
|
map("n", "<Leader>h", ":Helptags<CR>")
|
|
map("n", "<Leader>H", ":Helptags <C-R><C-W><CR>")
|
|
map("n", "<Leader>;", ":History:<CR>")
|
|
map("n", "<Leader>c", ":Commands<CR>")
|
|
map("n", "<Leader>r", ":Rg <C-R><C-W><CR>")
|
|
map("n", "<Leader>R", ":Rg<CR>")
|
|
map("n", "<Leader>s", ":Lines<CR>")
|
|
map("n", "<Leader>gl", ":GFiles<CR>")
|
|
map("n", "<Leader>gs", ":GFiles?<CR>")
|
|
map("n", "<Leader>gc", ":Commits<CR>")
|
|
end
|
|
|
|
function M.fzf_checkout()
|
|
map("n", "<Leader>gb", ":GBranches<CR>")
|
|
end
|
|
|
|
function M.rnvimr()
|
|
map("n", "<Leader>f", [[:RnvimrToggle<CR>]])
|
|
end
|
|
|
|
function M.nvim_fzf()
|
|
require("fzf").default_options = {
|
|
--fzf_cli_args = " --height 100% --preview='bat --color=always --style=header,grid --line-range :300 {}' ",
|
|
fzf_cli_args = " --height 100% --preview='[[ -n \"$(command -v bat)\" ]] && bat --color=always --style=header,grid --line-range :300 {} || strings {+}' ",
|
|
}
|
|
end
|
|
|
|
function M.harpoon()
|
|
require("harpoon").setup({
|
|
global_settings = {
|
|
save_on_toggle = false,
|
|
save_on_change = true,
|
|
enter_on_sendcmd = false,
|
|
tmux_autoclose_windows = false,
|
|
excluded_filetypes = { "harpoon" },
|
|
},
|
|
})
|
|
end
|
|
|
|
function M.auto_session()
|
|
require("auto-session").setup({
|
|
log_level = "info",
|
|
auto_session_suppress_dirs = { "~/", "~/Projects" },
|
|
auto_session_use_git_branch = true,
|
|
})
|
|
end
|
|
|
|
function M.indent_blankline()
|
|
vim.opt.list = true
|
|
|
|
require("indent_blankline").setup({
|
|
space_char_blankline = " ",
|
|
show_current_context = true,
|
|
show_current_context_start = true,
|
|
})
|
|
end
|
|
|
|
function M.lualine()
|
|
require("lualine").setup({
|
|
options = { theme = "onedark", icons_enabled = true },
|
|
sections = {
|
|
lualine_a = { "mode" },
|
|
lualine_b = {
|
|
"FugitiveHead",
|
|
},
|
|
lualine_c = { "filename" },
|
|
lualine_x = {
|
|
"encoding",
|
|
"fileformat",
|
|
"filetype",
|
|
[[string.format("%d Lines", vim.fn.line('$'))]],
|
|
{
|
|
"diagnostics",
|
|
sources = { "nvim_diagnostic", "ale" },
|
|
},
|
|
},
|
|
lualine_y = {
|
|
"progress",
|
|
},
|
|
lualine_z = { "location" },
|
|
},
|
|
inactive_sections = {
|
|
lualine_a = {},
|
|
lualine_b = {},
|
|
lualine_c = { "filename" },
|
|
lualine_x = { "location" },
|
|
lualine_y = {},
|
|
lualine_z = {},
|
|
},
|
|
tabline = {
|
|
lualine_a = {
|
|
{
|
|
"buffers",
|
|
show_filename_only = false, -- shows shortened relative path when false
|
|
show_modified_status = true, -- shows indicator then bufder is modified
|
|
max_length = function()
|
|
return vim.o.columns * 5 / 6
|
|
end, -- maximum width of buffers component
|
|
filetype_names = {
|
|
TelescopePrompt = "Telescope",
|
|
dashboard = "Dashboard",
|
|
packer = "Packer",
|
|
fzf = "FZF",
|
|
alpha = "Alpha",
|
|
["lsp-installer"] = "LSP Installer",
|
|
}, -- shows specific buffer name for that filetype ( { `filetype` = `buffer_name`, ... } )
|
|
buffers_color = {
|
|
active = nil, -- color for active buffer
|
|
inactive = nil, -- color for inactive buffer
|
|
},
|
|
},
|
|
},
|
|
lualine_b = {},
|
|
lualine_c = {},
|
|
lualine_x = {},
|
|
lualine_y = {},
|
|
lualine_z = {
|
|
{
|
|
[[string.format("Tab %d/%d", vim.fn.tabpagenr(), vim.fn.tabpagenr('$'))]],
|
|
cond = function()
|
|
return vim.fn.tabpagenr("$") > 1
|
|
end,
|
|
},
|
|
{
|
|
[[harpoon_status()]],
|
|
cond = function()
|
|
return require("harpoon.mark").get_length() > 0
|
|
end,
|
|
},
|
|
},
|
|
},
|
|
extensions = {},
|
|
})
|
|
end
|
|
|
|
function M.nvim_treesitter()
|
|
local ts_visual_disable = { "typescript", "tsx", "html", "javascript" }
|
|
require("nvim-treesitter.configs").setup({
|
|
ensure_installed = "all",
|
|
highlight = {
|
|
enable = true,
|
|
disable = ts_visual_disable,
|
|
},
|
|
rainbow = {
|
|
enable = true,
|
|
disable = ts_visual_disable,
|
|
extended_mode = true, -- Also highlight non-bracket delimiters like html tags, boolean or table: lang -> boolean
|
|
max_file_lines = nil, -- Do not enable for files with more than n lines, int
|
|
-- colors = {}, -- table of hex strings
|
|
--termcolors = {},
|
|
},
|
|
})
|
|
|
|
local version = vim.version()
|
|
if version.api_level ~= 9 then
|
|
vim.opt.foldmethod = "expr"
|
|
vim.opt.foldexpr = "nvim_treesitter#foldexpr()"
|
|
end
|
|
end
|
|
|
|
function M.nvim_lspconfig()
|
|
vim.diagnostic.config({
|
|
virtual_text = true,
|
|
signs = true,
|
|
update_in_insert = false,
|
|
})
|
|
end
|
|
|
|
function M.nvim_lsp_installer()
|
|
local config = lsp_config_defaults()
|
|
local on_attach_tsserver = function(client, bufnr)
|
|
local ts_utils = require("nvim-lsp-ts-utils")
|
|
ts_utils.setup({
|
|
eslint_bin = "eslint_d",
|
|
eslint_enable_diagnostics = true,
|
|
eslint_enable_code_actions = true,
|
|
enable_import_on_completion = true,
|
|
filter_out_diagnostics_by_severity = {
|
|
"information",
|
|
"hint",
|
|
--"warning",
|
|
--"error",
|
|
},
|
|
})
|
|
ts_utils.setup_client(client)
|
|
|
|
-- no default maps, so you may want to define some here
|
|
local o = { silent = true }
|
|
vim.api.nvim_buf_set_keymap(bufnr, "n", "gs", ":TSLspOrganize<CR>", o)
|
|
vim.api.nvim_buf_set_keymap(bufnr, "n", "rN", ":TSLspRenameFile<CR>", o)
|
|
vim.api.nvim_buf_set_keymap(bufnr, "n", "gI", ":TSLspImportAll<CR>", o)
|
|
end
|
|
|
|
require("nvim-lsp-installer").on_server_ready(function(server)
|
|
--Enable (broadcasting) snippet capability for completion
|
|
local capabilities = vim.lsp.protocol.make_client_capabilities()
|
|
capabilities.textDocument.completion.completionItem.snippetSupport = true
|
|
|
|
local disable_diag = {
|
|
["textDocument/publishDiagnostics"] = function() end,
|
|
}
|
|
|
|
local on_attach_generic = function(client, bufnr)
|
|
-- Disables document formatting by lsp
|
|
client.server_capabilities.document_formatting = false
|
|
client.server_capabilities.document_range_formatting = false
|
|
|
|
config.on_attach(client, bufnr)
|
|
end
|
|
|
|
local opts = {
|
|
on_attach = on_attach_generic,
|
|
capabilities = capabilities,
|
|
flags = {
|
|
debounce_text_changes = 150,
|
|
},
|
|
settings = {
|
|
format = { enable = true },
|
|
},
|
|
root_dir = config.root_dir,
|
|
}
|
|
|
|
if server.name == "tsserver" then
|
|
opts.on_attach = function(...)
|
|
on_attach_tsserver(...)
|
|
on_attach_generic(...)
|
|
end
|
|
elseif server.name == "sumneko_lua" then
|
|
opts.settings.Lua = {
|
|
diagnostics = {
|
|
globals = {
|
|
"vim",
|
|
"awesome",
|
|
"client",
|
|
},
|
|
},
|
|
}
|
|
elseif server.name == "html" then
|
|
opts.filetypes = { "html", "htmldjango" }
|
|
elseif server.name == "tailwindcss" then
|
|
opts.init_options = {
|
|
userLanguages = {
|
|
htmldjango = "html",
|
|
},
|
|
}
|
|
end
|
|
|
|
server:setup(opts)
|
|
vim.cmd([[do User LspAttachBuffers]])
|
|
end)
|
|
|
|
local lsp_installer_servers = require("nvim-lsp-installer.servers")
|
|
local auto_servers = {
|
|
"sumneko_lua",
|
|
"tsserver",
|
|
"bashls",
|
|
"vimls",
|
|
"rust_analyzer",
|
|
"html",
|
|
"cssls",
|
|
"jsonls",
|
|
--"jedi_language_server",
|
|
"pylsp",
|
|
"svelte",
|
|
"tailwindcss",
|
|
"zls",
|
|
}
|
|
|
|
for _, s in ipairs(auto_servers) do
|
|
local ok, server = lsp_installer_servers.get_server(s)
|
|
if ok and not server:is_installed() then
|
|
server:install()
|
|
end
|
|
end
|
|
end
|
|
|
|
function M.null_ls()
|
|
local null_ls = require("null-ls")
|
|
local config = lsp_config_defaults()
|
|
|
|
-- ORDER IN TABLE DETERMINES EXECUTION ORDER
|
|
local sources = {
|
|
-- python
|
|
null_ls.builtins.diagnostics.flake8,
|
|
null_ls.builtins.diagnostics.mypy,
|
|
null_ls.builtins.formatting.black,
|
|
null_ls.builtins.formatting.isort,
|
|
-- js
|
|
null_ls.builtins.diagnostics.eslint,
|
|
null_ls.builtins.code_actions.eslint,
|
|
null_ls.builtins.formatting.prettier.with({
|
|
extra_filetypes = { "svelte" },
|
|
}),
|
|
-- lua
|
|
null_ls.builtins.formatting.stylua,
|
|
-- bash
|
|
null_ls.builtins.formatting.shfmt,
|
|
null_ls.builtins.diagnostics.shellcheck,
|
|
null_ls.builtins.code_actions.shellcheck,
|
|
-- cpp
|
|
null_ls.builtins.formatting.clang_format,
|
|
}
|
|
null_ls.setup({
|
|
sources = sources,
|
|
on_attach = config.on_attach,
|
|
root_dir = config.root_dir,
|
|
})
|
|
end
|
|
|
|
function M.nvim_autopairs()
|
|
require("nvim-autopairs").setup({ check_ts = true })
|
|
end
|
|
|
|
function M.nvim_cmp()
|
|
vim.opt.completeopt = "menuone,noselect"
|
|
|
|
local cmp_autopairs = require("nvim-autopairs.completion.cmp")
|
|
local cmp = require("cmp")
|
|
|
|
-- CMP NVIM ULTISNIP
|
|
local cmp_ultisnips_mappings = require("cmp_nvim_ultisnips.mappings")
|
|
local ultisnip = {
|
|
expand = function(args)
|
|
vim.fn["UltiSnips#Anon"](args.body)
|
|
end,
|
|
tab = cmp.mapping(function(fallback)
|
|
cmp_ultisnips_mappings.compose({ "select_next_item" })(fallback)
|
|
end, { "i", "s" }),
|
|
shift_tab = cmp.mapping(function(fallback)
|
|
cmp_ultisnips_mappings.compose({ "select_prev_item" })(fallback)
|
|
end, { "i", "s" }),
|
|
}
|
|
|
|
cmp.setup({
|
|
snippet = {
|
|
expand = ultisnip.expand,
|
|
},
|
|
mapping = {
|
|
["<C-p>"] = cmp.mapping.select_prev_item(),
|
|
["<C-n>"] = cmp.mapping.select_next_item(),
|
|
["<C-d>"] = cmp.mapping.scroll_docs(-4),
|
|
["<C-f>"] = cmp.mapping.scroll_docs(4),
|
|
["<C-Space>"] = cmp.mapping.complete(),
|
|
["<C-e>"] = cmp.mapping.close(),
|
|
["<CR>"] = cmp.mapping.confirm({
|
|
select = true,
|
|
}),
|
|
["<Tab>"] = ultisnip.tab,
|
|
["<S-Tab>"] = ultisnip.shift_tab,
|
|
},
|
|
sources = {
|
|
{ name = "nvim_lsp" },
|
|
{ name = "ultisnips" },
|
|
},
|
|
})
|
|
|
|
cmp.event:on("confirm_done", cmp_autopairs.on_confirm_done({ map_char = { tex = "" } }))
|
|
end
|
|
|
|
return M
|