From c5a7054500d9a045e29e3d3cb00db67d518c15b5 Mon Sep 17 00:00:00 2001 From: cuqmbr Date: Fri, 14 Jul 2023 17:40:38 +0300 Subject: [PATCH] initial commit --- .gitignore | 1 + README.md | 48 +++++++++ ftplugin/cs.lua | 4 + ftplugin/lua.lua | 4 + init.lua | 22 ++++ lua/.luarc.json | 3 + lua/user/alpha.lua | 42 ++++++++ lua/user/autocommands.lua | 37 +++++++ lua/user/autopairs.lua | 33 ++++++ lua/user/bufferline.lua | 159 ++++++++++++++++++++++++++++ lua/user/cmp.lua | 131 +++++++++++++++++++++++ lua/user/colorscheme.lua | 19 ++++ lua/user/comment.lua | 8 ++ lua/user/dap.lua | 54 ++++++++++ lua/user/gitsigns.lua | 48 +++++++++ lua/user/impatient.lua | 6 ++ lua/user/indentline.lua | 70 +++++++++++++ lua/user/keymaps.lua | 69 ++++++++++++ lua/user/lsp/handlers.lua | 160 ++++++++++++++++++++++++++++ lua/user/lsp/init.lua | 8 ++ lua/user/lsp/mason.lua | 46 ++++++++ lua/user/lsp/null-ls.lua | 20 ++++ lua/user/lsp/settings/lua_ls.lua | 19 ++++ lua/user/lualine.lua | 93 +++++++++++++++++ lua/user/nvim-tree.lua | 137 ++++++++++++++++++++++++ lua/user/options.lua | 51 +++++++++ lua/user/plugins.lua | 98 +++++++++++++++++ lua/user/project.lua | 48 +++++++++ lua/user/telescope.lua | 99 ++++++++++++++++++ lua/user/toggleterm.lua | 70 +++++++++++++ lua/user/treesitter.lua | 26 +++++ lua/user/whichkey.lua | 174 +++++++++++++++++++++++++++++++ 32 files changed, 1807 insertions(+) create mode 100644 .gitignore create mode 100644 README.md create mode 100644 ftplugin/cs.lua create mode 100644 ftplugin/lua.lua create mode 100644 init.lua create mode 100644 lua/.luarc.json create mode 100644 lua/user/alpha.lua create mode 100644 lua/user/autocommands.lua create mode 100644 lua/user/autopairs.lua create mode 100644 lua/user/bufferline.lua create mode 100644 lua/user/cmp.lua create mode 100644 lua/user/colorscheme.lua create mode 100644 lua/user/comment.lua create mode 100644 lua/user/dap.lua create mode 100644 lua/user/gitsigns.lua create mode 100644 lua/user/impatient.lua create mode 100644 lua/user/indentline.lua create mode 100644 lua/user/keymaps.lua create mode 100644 lua/user/lsp/handlers.lua create mode 100644 lua/user/lsp/init.lua create mode 100644 lua/user/lsp/mason.lua create mode 100644 lua/user/lsp/null-ls.lua create mode 100644 lua/user/lsp/settings/lua_ls.lua create mode 100644 lua/user/lualine.lua create mode 100644 lua/user/nvim-tree.lua create mode 100644 lua/user/options.lua create mode 100644 lua/user/plugins.lua create mode 100644 lua/user/project.lua create mode 100644 lua/user/telescope.lua create mode 100644 lua/user/toggleterm.lua create mode 100644 lua/user/treesitter.lua create mode 100644 lua/user/whichkey.lua diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..8cb205e --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +plugin diff --git a/README.md b/README.md new file mode 100644 index 0000000..73cf9c8 --- /dev/null +++ b/README.md @@ -0,0 +1,48 @@ +![Config preview gif image](https://drive.google.com/uc?export=download&id=1ON08YBTFNIUIyREI90yLNOFmrO8WofnT) + +## Try out this config + +This config requires >= [Neovim v0.9.0](https://github.com/neovim/neovim/releases). + +Clone the repository into the correct location (make a backup your current `nvim` directory if you want to keep it). + +``` +git clone https://github.com/cuqmbr/nvim-config.git ~/.config/nvim +``` + +Run `nvim` in your terminal and wait for the plugins to be installed. Reopen nvim + +**NOTE**: [Mason](https://github.com/williamboman/mason.nvim) is used to install and manage [LSP](https://microsoft.github.io/language-server-protocol/) servers, [DAP](https://microsoft.github.io/debug-adapter-protocol/) servers, [linters](https://en.wikipedia.org/wiki/Lint_(software)), and [formatters](https://en.wikipedia.org/wiki/Prettyprint) via the `:Mason` command. + +**NOTE**: [Treesitter](https://github.com/nvim-treesitter/nvim-treesitter) is used to install and manager code highlighting. Refer to the project's [README](https://github.com/nvim-treesitter/nvim-treesitter#readme) to view installation instructions and list of supported languages + +This config assumes that you have Nerd Fonts v3.0.0 or higher. If you are using an older version then please update your [Nerd Fonts](https://github.com/ryanoasis/nerd-fonts) otherwise there will be missing or wrong glyphs + +## Get healthy + +Open `nvim` and enter the following: + +``` +:checkhealth +``` + +If you noticed that you don't have support for copy/paste also that python and node haven't been setup follow advice: + +Copy/paste fix: + +- On mac `pbcopy` should be builtin + +- On GNU/Linux install [xsel](https://vergenet.net/~conrad/software/xsel/) or [wl-clipboard](https://github.com/bugaevc/wl-clipboard) for X11 or Wayland accordingly + +Python and node Neovim support: + + ``` + pip install pynvim + ``` + + ``` + npm i -g neovim + ``` +--- + +**NOTE**: Make sure you have [node](https://nodejs.org/) and [python](https://www.python.org/) installed diff --git a/ftplugin/cs.lua b/ftplugin/cs.lua new file mode 100644 index 0000000..680568a --- /dev/null +++ b/ftplugin/cs.lua @@ -0,0 +1,4 @@ +vim.bo.tabstop = 4 -- size of a hard tabstop (ts). +vim.bo.shiftwidth = 4 -- size of an indentation (sw). +vim.bo.expandtab = true -- always uses spaces instead of tab characters (et). +vim.bo.softtabstop = 4 -- number of spaces a counts for. When 0, feature is off (sts). diff --git a/ftplugin/lua.lua b/ftplugin/lua.lua new file mode 100644 index 0000000..10c1efc --- /dev/null +++ b/ftplugin/lua.lua @@ -0,0 +1,4 @@ +vim.bo.tabstop = 2 -- size of a hard tabstop (ts). +vim.bo.shiftwidth = 2 -- size of an indentation (sw). +vim.bo.expandtab = true -- always uses spaces instead of tab characters (et). +vim.bo.softtabstop = 2 -- number of spaces a counts for. When 0, feature is off (sts). diff --git a/init.lua b/init.lua new file mode 100644 index 0000000..ccceb95 --- /dev/null +++ b/init.lua @@ -0,0 +1,22 @@ +require("user.options") +require("user.keymaps") +require("user.plugins") +require("user.colorscheme") +require("user.cmp") +require("user.lsp") +require("user.telescope") +require("user.gitsigns") +require("user.treesitter") +require("user.autopairs") +require("user.comment") +require("user.nvim-tree") +require("user.bufferline") +require("user.lualine") +require("user.toggleterm") +require("user.project") +require("user.impatient") +require("user.indentline") +require("user.alpha") +require("user.whichkey") +require("user.autocommands") +require("user.dap") diff --git a/lua/.luarc.json b/lua/.luarc.json new file mode 100644 index 0000000..23b9ee2 --- /dev/null +++ b/lua/.luarc.json @@ -0,0 +1,3 @@ +{ + "workspace.checkThirdParty": false +} \ No newline at end of file diff --git a/lua/user/alpha.lua b/lua/user/alpha.lua new file mode 100644 index 0000000..439b77c --- /dev/null +++ b/lua/user/alpha.lua @@ -0,0 +1,42 @@ +local status_ok, alpha = pcall(require, "alpha") +if not status_ok then + return +end + +local dashboard = require("alpha.themes.dashboard") +dashboard.section.header.val = { + [[ __ ]], + [[ ___ ___ ___ __ __ /\_\ ___ ___ ]], + [[ / _ `\ / __`\ / __`\/\ \/\ \\/\ \ / __` __`\ ]], + [[/\ \/\ \/\ __//\ \_\ \ \ \_/ |\ \ \/\ \/\ \/\ \ ]], + [[\ \_\ \_\ \____\ \____/\ \___/ \ \_\ \_\ \_\ \_\]], + [[ \/_/\/_/\/____/\/___/ \/__/ \/_/\/_/\/_/\/_/]], +} +dashboard.section.buttons.val = { + dashboard.button("f", " Find file", ":Telescope find_files "), + dashboard.button("e", " New file", ":ene startinsert "), + dashboard.button("p", " Find project", ":Telescope projects "), + dashboard.button("r", " Recently used files", ":Telescope oldfiles "), + dashboard.button("t", "󱎸 Find text", ":Telescope live_grep "), + dashboard.button("c", " Configuration", ":e $MYVIMRC "), + dashboard.button("q", " Quit Neovim", ":qa"), +} + +local function footer() +-- NOTE: requires the fortune-mod package to work + -- local handle = io.popen("fortune") + -- local fortune = handle:read("*a") + -- handle:close() + -- return fortune + return "cuqmbr's config" +end + +dashboard.section.footer.val = footer() + +dashboard.section.footer.opts.hl = "Type" +dashboard.section.header.opts.hl = "Include" +dashboard.section.buttons.opts.hl = "Keyword" + +dashboard.opts.opts.noautocmd = true +-- vim.cmd([[autocmd User AlphaReady echo 'ready']]) +alpha.setup(dashboard.opts) diff --git a/lua/user/autocommands.lua b/lua/user/autocommands.lua new file mode 100644 index 0000000..c438738 --- /dev/null +++ b/lua/user/autocommands.lua @@ -0,0 +1,37 @@ +vim.cmd [[ + augroup _general_settings + autocmd! + autocmd FileType qf,help,man,lspinfo nnoremap q :close + autocmd TextYankPost * silent!lua require('vim.highlight').on_yank({higroup = 'Visual', timeout = 200}) + autocmd BufWinEnter * :set formatoptions-=cro + autocmd FileType qf set nobuflisted + augroup end + + augroup _git + autocmd! + autocmd FileType gitcommit setlocal wrap + autocmd FileType gitcommit setlocal spell + augroup end + + augroup _markdown + autocmd! + autocmd FileType markdown setlocal wrap + autocmd FileType markdown setlocal spell + augroup end + + augroup _auto_resize + autocmd! + autocmd VimResized * tabdo wincmd = + augroup end + + augroup _alpha + autocmd! + autocmd User AlphaReady set showtabline=0 | autocmd BufUnload set showtabline=2 + augroup end +]] + +-- Autoformat +-- augroup _lsp +-- autocmd! +-- autocmd BufWritePre * lua vim.lsp.buf.formatting() +-- augroup end diff --git a/lua/user/autopairs.lua b/lua/user/autopairs.lua new file mode 100644 index 0000000..577e571 --- /dev/null +++ b/lua/user/autopairs.lua @@ -0,0 +1,33 @@ +-- Setup nvim-cmp. +local status_ok, npairs = pcall(require, "nvim-autopairs") +if not status_ok then + return +end + +npairs.setup { + check_ts = true, + ts_config = { + lua = { "string", "source" }, + javascript = { "string", "template_string" }, + java = false, + }, + disable_filetype = { "TelescopePrompt", "spectre_panel" }, + fast_wrap = { + map = "", + chars = { "{", "[", "(", '"', "'" }, + pattern = string.gsub([[ [%'%"%)%>%]%)%}%,] ]], "%s+", ""), + offset = 0, -- Offset from pattern match + end_key = "$", + keys = "qwertyuiopzxcvbnmasdfghjkl", + check_comma = true, + highlight = "PmenuSel", + highlight_grey = "LineNr", + }, +} + +local cmp_autopairs = require "nvim-autopairs.completion.cmp" +local cmp_status_ok, cmp = pcall(require, "cmp") +if not cmp_status_ok then + return +end +cmp.event:on("confirm_done", cmp_autopairs.on_confirm_done { map_char = { tex = "" } }) diff --git a/lua/user/bufferline.lua b/lua/user/bufferline.lua new file mode 100644 index 0000000..a5756d8 --- /dev/null +++ b/lua/user/bufferline.lua @@ -0,0 +1,159 @@ +local status_ok, bufferline = pcall(require, "bufferline") +if not status_ok then + return +end + +bufferline.setup { + options = { + numbers = "none", -- | "ordinal" | "buffer_id" | "both" | function({ ordinal, id, lower, raise }): string, + close_command = "Bdelete! %d", -- can be a string | function, see "Mouse actions" + right_mouse_command = "Bdelete! %d", -- can be a string | function, see "Mouse actions" + left_mouse_command = "buffer %d", -- can be a string | function, see "Mouse actions" + middle_mouse_command = nil, -- can be a string | function, see "Mouse actions" + -- NOTE: this plugin is designed with this icon in mind, + -- and so changing this is NOT recommended, this is intended + -- as an escape hatch for people who cannot bear it for whatever reason + indicator_icon = nil, + indicator = { style = "icon", icon = "▎"}, + buffer_close_icon = '', + modified_icon = "●", + close_icon = "", + left_trunc_marker = "", + right_trunc_marker = "", + --- name_formatter can be used to change the buffer's label in the bufferline. + --- Please note some names can/will break the + --- bufferline so use this at your discretion knowing that it has + --- some limitations that will *NOT* be fixed. + -- name_formatter = function(buf) -- buf contains a "name", "path" and "bufnr" + -- -- remove extension from markdown files for example + -- if buf.name:match('%.md') then + -- return vim.fn.fnamemodify(buf.name, ':t:r') + -- end + -- end, + max_name_length = 30, + max_prefix_length = 30, -- prefix used when a buffer is de-duplicated + tab_size = 21, + diagnostics = false, -- | "nvim_lsp" | "coc", + diagnostics_update_in_insert = false, + -- diagnostics_indicator = function(count, level, diagnostics_dict, context) + -- return "("..count..")" + -- end, + -- NOTE: this will be called a lot so don't do any heavy processing here + -- custom_filter = function(buf_number) + -- -- filter out filetypes you don't want to see + -- if vim.bo[buf_number].filetype ~= "" then + -- return true + -- end + -- -- filter out by buffer name + -- if vim.fn.bufname(buf_number) ~= "" then + -- return true + -- end + -- -- filter out based on arbitrary rules + -- -- e.g. filter out vim wiki buffer from tabline in your work repo + -- if vim.fn.getcwd() == "" and vim.bo[buf_number].filetype ~= "wiki" then + -- return true + -- end + -- end, + offsets = { { filetype = "NvimTree", text = "", padding = 1 } }, + show_buffer_icons = true, + show_buffer_close_icons = true, + show_close_icon = true, + show_tab_indicators = true, + persist_buffer_sort = true, -- whether or not custom sorted buffers should persist + -- can also be a table containing 2 custom separators + -- [focused and unfocused]. eg: { '|', '|' } + separator_style = "thin", -- | "thick" | "thin" | { 'any', 'any' }, + enforce_regular_tabs = true, + always_show_bufferline = true, + -- sort_by = 'id' | 'extension' | 'relative_directory' | 'directory' | 'tabs' | function(buffer_a, buffer_b) + -- -- add custom logic + -- return buffer_a.modified > buffer_b.modified + -- end + }, + highlights = { + fill = { + fg = { attribute = "fg", highlight = "Visual" }, + bg = { attribute = "bg", highlight = "TabLine" } + }, + background = { + fg = { attribute = "fg", highlight = "TabLine" }, + bg = { attribute = "bg", highlight = "TabLine" } + }, + buffer_selected = { + fg = { attribute = "fg", highlight = "TabLine" }, + bg = { attribute = "bg", highlight = "TabLine" } + }, + buffer_visible = { + fg = { attribute = "fg", highlight = "TabLine" }, + bg = { attribute = "bg", highlight = "TabLine" } + }, + close_button = { + fg = { attribute = "fg", highlight = "TabLine" }, + bg = { attribute = "bg", highlight = "TabLine" } + }, + close_button_visible = { + fg = { attribute = "fg", highlight = "TabLine" }, + bg = { attribute = "bg", highlight = "TabLine" } + }, + close_button_selected = { + fg = {attribute = "fg", highlight = "TabLineSel" }, + bg ={attribute = "bg", highlight = "TabLineSel" } + }, + tab_selected = { + fg = { attribute = "fg", highlight = "Normal" }, + bg = { attribute = "bg", highlight = "Normal" } + }, + tab = { + fg = { attribute = "fg", highlight = "TabLine" }, + bg = { attribute = "bg", highlight = "TabLine" } + }, + tab_close = { + fg = { attribute = "fg", highlight = "LspDiagnosticsDefaultError" }, + fg = { attribute = "fg", highlight = "TabLineSel" }, + bg = { attribute = "bg", highlight = "Normal" } + }, + duplicate_selected = { + fg = { attribute = "fg", highlight = "TabLineSel" }, + bg = { attribute = "bg", highlight = "TabLineSel" }, + underline = true, + }, + duplicate_visible = { + fg = { attribute = "fg", highlight = "TabLine" }, + bg = { attribute = "bg", highlight = "TabLine" }, + underline = true, + }, + duplicate = { + fg = { attribute = "fg", highlight = "TabLine" }, + bg = { attribute = "bg", highlight = "TabLine" }, + underline = true, + }, + modified = { + fg = { attribute = "fg", highlight = "TabLine" }, + bg = { attribute = "bg", highlight = "TabLine" } + }, + modified_selected = { + fg = { attribute = "fg", highlight = "Normal" }, + bg = { attribute = "bg", highlight = "Normal" } + }, + modified_visible = { + fg = { attribute = "fg", highlight = "TabLine" }, + bg = { attribute = "bg", highlight = "TabLine" } + }, + separator = { + fg = { attribute = "bg", highlight = "TabLine" }, + bg = { attribute = "bg", highlight = "TabLine" } + }, + separator_selected = { + fg = { attribute = "bg", highlight = "Normal" }, + bg = { attribute = "bg", highlight = "Normal" } + }, + separator_visible = { + fg = {attribute="bg", highlight="TabLine" }, + bg = {attribute="bg", highlight="TabLine" } + }, + indicator_selected = { + fg = { attribute = "fg", highlight = "LspDiagnosticsDefaultHint" }, + bg = { attribute = "bg", highlight = "Normal" } + }, + }, +} diff --git a/lua/user/cmp.lua b/lua/user/cmp.lua new file mode 100644 index 0000000..e057a64 --- /dev/null +++ b/lua/user/cmp.lua @@ -0,0 +1,131 @@ +local cmp_status_ok, cmp = pcall(require, "cmp") +if not cmp_status_ok then + return +end + +local snip_status_ok, luasnip = pcall(require, "luasnip") +if not snip_status_ok then + return +end + +require("luasnip/loaders/from_vscode").lazy_load() + +local check_backspace = function() + local col = vim.fn.col "." - 1 + return col == 0 or vim.fn.getline("."):sub(col, col):match "%s" +end + +local kind_icons = { + Text = "󰉿", + Method = "󰆧", + Function = "󰊕", + Constructor = "", + Field = " ", + Variable = "󰀫", + Class = "󰠱", + Interface = "", + Module = "", + Property = "󰜢", + Unit = "󰑭", + Value = "󰎠", + Enum = "", + Keyword = "󰌋", + Snippet = "", + Color = "󰏘", + File = "󰈙", + Reference = "", + Folder = "󰉋", + EnumMember = "", + Constant = "󰏿", + Struct = "", + Event = "", + Operator = "󰆕", + TypeParameter = " ", + Misc = " ", +} +-- find more here: https://www.nerdfonts.com/cheat-sheet + +cmp.setup { + snippet = { + expand = function(args) + luasnip.lsp_expand(args.body) -- For `luasnip` users. + end, + }, + mapping = { + [""] = cmp.mapping.select_prev_item(), + [""] = cmp.mapping.select_next_item(), + [""] = cmp.mapping(cmp.mapping.scroll_docs(-1), { "i", "c" }), + [""] = cmp.mapping(cmp.mapping.scroll_docs(1), { "i", "c" }), + [""] = cmp.mapping(cmp.mapping.complete(), { "i", "c" }), + [""] = cmp.config.disable, -- Specify `cmp.config.disable` if you want to remove the default `` mapping. + [""] = cmp.mapping { + i = cmp.mapping.abort(), + c = cmp.mapping.close(), + }, + -- Accept currently selected item. If none selected, `select` first item. + -- Set `select` to `false` to only confirm explicitly selected items. + [""] = cmp.mapping.confirm { select = true }, + [""] = cmp.mapping(function(fallback) + if cmp.visible() then + cmp.select_next_item() + elseif luasnip.expandable() then + luasnip.expand() + elseif luasnip.expand_or_jumpable() then + luasnip.expand_or_jump() + elseif check_backspace() then + fallback() + else + fallback() + end + end, { + "i", + "s", + }), + [""] = cmp.mapping(function(fallback) + if cmp.visible() then + cmp.select_prev_item() + elseif luasnip.jumpable(-1) then + luasnip.jump(-1) + else + fallback() + end + end, { + "i", + "s", + }), + }, + formatting = { + fields = { "kind", "abbr", "menu" }, + format = function(entry, vim_item) + -- Kind icons + vim_item.kind = string.format("%s", kind_icons[vim_item.kind]) + -- vim_item.kind = string.format('%s %s', kind_icons[vim_item.kind], vim_item.kind) -- This concatonates the icons with the name of the item kind + vim_item.menu = ({ + nvim_lsp = "[LSP]", + luasnip = "[Snippet]", + buffer = "[Buffer]", + path = "[Path]", + })[entry.source.name] + return vim_item + end, + }, + sources = { + { name = "nvim_lsp" }, + -- { name = "luasnip" }, + { name = "buffer" }, + { name = "path" }, + }, + confirm_opts = { + behavior = cmp.ConfirmBehavior.Replace, + select = false, + }, + window = { + documentation = { + border = { "╭", "─", "╮", "│", "╯", "─", "╰", "│" }, + }, + }, + experimental = { + ghost_text = true, + native_menu = false, + }, +} diff --git a/lua/user/colorscheme.lua b/lua/user/colorscheme.lua new file mode 100644 index 0000000..837a901 --- /dev/null +++ b/lua/user/colorscheme.lua @@ -0,0 +1,19 @@ +local colorscheme = "vscode" + +local vim_cmd_status_ok, _ = pcall(vim.cmd, "colorscheme " .. colorscheme) +if not vim_cmd_status_ok then + return +end + +local vscode_status_ok, vscode_theme = pcall(require, "vscode") +if not vscode_status_ok then + return +end + +vscode_theme.setup { + style = "dark", -- Alternatively set style in setup + transparent = false, -- Enable transparent background + italic_comments = true, -- Enable italic comment + disable_nvimtree_bg = false, -- Disable nvim-tree background color +} +vscode_theme.load() diff --git a/lua/user/comment.lua b/lua/user/comment.lua new file mode 100644 index 0000000..2c1c217 --- /dev/null +++ b/lua/user/comment.lua @@ -0,0 +1,8 @@ +local status_ok, comment = pcall(require, "Comment") +if not status_ok then + return +end + +comment.setup { + pre_hook = require('ts_context_commentstring.integrations.comment_nvim').create_pre_hook(), +} diff --git a/lua/user/dap.lua b/lua/user/dap.lua new file mode 100644 index 0000000..fac8796 --- /dev/null +++ b/lua/user/dap.lua @@ -0,0 +1,54 @@ +local dap_status_ok, dap = pcall(require, "dap") +if not dap_status_ok then + return +end + +-- .NET + +dap.adapters.coreclr = { + type = 'executable', + command = '/home/cuqmbr/.local/bin/netcoredbg/netcoredbg', + args = {'--interpreter=vscode'} +} + +dap.configurations.cs = { + { + type = "coreclr", + name = "launch - netcoredbg", + request = "launch", + program = function() + return vim.fn.input('Path to dll', vim.fn.getcwd(), 'file') + end, + }, +} + +-- DapUI + +local dapui_status_ok, dapui = pcall(require, "dapui") +if not dapui_status_ok then + return +end + +dapui.setup() + +dap.listeners.after.event_initialized["dapui_config"] = function() + dapui.open() +end +dap.listeners.before.event_terminated["dapui_config"] = function() + dapui.close() +end +dap.listeners.before.event_exited["dapui_config"] = function() + dapui.close() +end + +-- Keymaps + +vim.keymap.set("n", "", ":lua require('dap').continue()") +vim.keymap.set("n", "", ":lua require('dap').step_over()") +vim.keymap.set("n", "", ":lua require('dap').step_into()") +vim.keymap.set("n", "", ":lua require('dap').step_out()") +vim.keymap.set("n", "db", ":lua require('dap').toggle_breakpoint()") +vim.keymap.set("n", "dB", ":lua require('dap').set_breakpoint(vim.fn.input('Breakpoint condition: '))") +vim.keymap.set("n", "lp", ":lua require('dap').set_breakpoint(nil, nil, vim.fn.input('Log point message: '))") +vim.keymap.set("n", "dr", ":lua require('dap').repl.open()") +vim.keymap.set("n", "dl", ":lua require('dap').run_last()") diff --git a/lua/user/gitsigns.lua b/lua/user/gitsigns.lua new file mode 100644 index 0000000..6d16a2b --- /dev/null +++ b/lua/user/gitsigns.lua @@ -0,0 +1,48 @@ +local status_ok, gitsigns = pcall(require, "gitsigns") +if not status_ok then + return +end + +gitsigns.setup { + signs = { + add = { hl = "GitSignsAdd", text = " ", numhl = "GitSignsAddNr", linehl = "GitSignsAddLn" }, + change = { hl = "GitSignsChange", text = " ", numhl = "GitSignsChangeNr", linehl = "GitSignsChangeLn" }, + delete = { hl = "GitSignsDelete", text = " ", numhl = "GitSignsDeleteNr", linehl = "GitSignsDeleteLn" }, + topdelete = { hl = "GitSignsDelete", text = "󱅁 ", numhl = "GitSignsDeleteNr", linehl = "GitSignsDeleteLn" }, + changedelete = { hl = "GitSignsChange", text = "󰍷 ", numhl = "GitSignsChangeNr", linehl = "GitSignsChangeLn" }, + }, + signcolumn = true, -- Toggle with `:Gitsigns toggle_signs` + numhl = false, -- Toggle with `:Gitsigns toggle_numhl` + linehl = false, -- Toggle with `:Gitsigns toggle_linehl` + word_diff = false, -- Toggle with `:Gitsigns toggle_word_diff` + watch_gitdir = { + interval = 1000, + follow_files = true, + }, + attach_to_untracked = true, + current_line_blame = false, -- Toggle with `:Gitsigns toggle_current_line_blame` + current_line_blame_opts = { + virt_text = true, + virt_text_pos = "eol", -- 'eol' | 'overlay' | 'right_align' + delay = 1000, + ignore_whitespace = false, + }, + current_line_blame_formatter_opts = { + relative_time = false, + }, + sign_priority = 6, + update_debounce = 100, + status_formatter = nil, -- Use default + max_file_length = 40000, + preview_config = { + -- Options passed to nvim_open_win + border = "single", + style = "minimal", + relative = "cursor", + row = 0, + col = 1, + }, + yadm = { + enable = false, + }, +} diff --git a/lua/user/impatient.lua b/lua/user/impatient.lua new file mode 100644 index 0000000..84419e0 --- /dev/null +++ b/lua/user/impatient.lua @@ -0,0 +1,6 @@ +local status_ok, impatient = pcall(require, "impatient") +if not status_ok then + return +end + +impatient.enable_profile() diff --git a/lua/user/indentline.lua b/lua/user/indentline.lua new file mode 100644 index 0000000..fdf5870 --- /dev/null +++ b/lua/user/indentline.lua @@ -0,0 +1,70 @@ +local status_ok, indent_blankline = pcall(require, "indent_blankline") +if not status_ok then + return +end + +vim.g.indent_blankline_buftype_exclude = { "terminal", "nofile" } +vim.g.indent_blankline_filetype_exclude = { + "help", + "startify", + "dashboard", + "packer", + "neogitstatus", + "NvimTree", + "Trouble", +} +vim.g.indentLine_enabled = 1 +-- vim.g.indent_blankline_char = "│" +vim.g.indent_blankline_char = "▏" +-- vim.g.indent_blankline_char = "▎" +vim.g.indent_blankline_show_trailing_blankline_indent = false +vim.g.indent_blankline_show_first_indent_level = true +vim.g.indent_blankline_use_treesitter = true +vim.g.indent_blankline_show_current_context = true +vim.g.indent_blankline_context_patterns = { + "class", + "return", + "function", + "method", + "^if", + "^while", + "jsx_element", + "^for", + "^object", + "^table", + "block", + "arguments", + "if_statement", + "else_clause", + "jsx_element", + "jsx_self_closing_element", + "try_statement", + "catch_clause", + "import_statement", + "operation_type", +} +-- HACK: work-around for https://github.com/lukas-reineke/indent-blankline.nvim/issues/59 +vim.wo.colorcolumn = "99999" + +-- vim.cmd [[highlight IndentBlanklineIndent1 guifg=#E06C75 gui=nocombine]] +-- vim.cmd [[highlight IndentBlanklineIndent2 guifg=#E5C07B gui=nocombine]] +-- vim.cmd [[highlight IndentBlanklineIndent3 guifg=#98C379 gui=nocombine]] +-- vim.cmd [[highlight IndentBlanklineIndent4 guifg=#56B6C2 gui=nocombine]] +-- vim.cmd [[highlight IndentBlanklineIndent5 guifg=#61AFEF gui=nocombine]] +-- vim.cmd [[highlight IndentBlanklineIndent6 guifg=#C678DD gui=nocombine]] +-- vim.opt.list = true +-- vim.opt.listchars:append "space:⋅" +-- vim.opt.listchars:append "space:" +-- vim.opt.listchars:append "eol:↴" + +indent_blankline.setup({ + -- show_end_of_line = true, + -- space_char_blankline = " ", + show_current_context = true, + -- show_current_context_start = true, + -- char_highlight_list = { + -- "IndentBlanklineIndent1", + -- "IndentBlanklineIndent2", + -- "IndentBlanklineIndent3", + -- }, +}) diff --git a/lua/user/keymaps.lua b/lua/user/keymaps.lua new file mode 100644 index 0000000..bf36018 --- /dev/null +++ b/lua/user/keymaps.lua @@ -0,0 +1,69 @@ +local opts = { noremap = true, silent = true } + +local term_opts = { silent = true } + +-- Shorten function name +local keymap = vim.keymap.set + +--Remap space as leader key +keymap("", "", "", opts) +vim.g.mapleader = " " +vim.g.maplocalleader = " " + +-- Modes +-- normal_mode = "n", +-- insert_mode = "i", +-- visual_mode = "v", +-- visual_block_mode = "x", +-- term_mode = "t", +-- command_mode = "c", + +-- Normal -- +-- Better window navigation +keymap("n", "", "h", opts) +keymap("n", "", "j", opts) +keymap("n", "", "k", opts) +keymap("n", "", "l", opts) + +-- Resize with arrows +keymap("n", "", ":resize +2", opts) +keymap("n", "", ":resize -2", opts) +keymap("n", "", ":vertical resize +2", opts) +keymap("n", "", ":vertical resize -2", opts) + +-- Navigate buffers +keymap("n", "", ":bnext", opts) +keymap("n", "", ":bprevious", opts) + +-- Move text up and down +keymap("n", "", ":m .+1==", opts) +keymap("n", "", ":m .-2==", opts) + +-- Insert -- +-- Press jk fast to exit insert mode +keymap("i", "jk", "", opts) +keymap("i", "kj", "", opts) + +-- Visual -- +-- Stay in indent mode +keymap("v", "<", "", ">gv^", opts) + +-- Move text up and down +keymap("v", "", ":m '>+1gv=gv", opts) +keymap("v", "", ":m '<-2gv=gv", opts) +keymap("v", "p", '"_dP', opts) + +-- Visual Block -- +-- Move text up and down +keymap("x", "J", ":m '>+1gv=gv", opts) +keymap("x", "K", ":m '<-2gv=gv", opts) +keymap("x", "", ":m '>+1gv=gv", opts) +keymap("x", "", ":m '<-2gv=gv", opts) + +-- Terminal -- +-- Better terminal navigation +-- kkeymap("t", "", "h", term_opts) +-- kkeymap("t", "", "j", term_opts) +-- keymap("t", "", "k", term_opts) +-- keymap("t", "", "l", term_opts) diff --git a/lua/user/lsp/handlers.lua b/lua/user/lsp/handlers.lua new file mode 100644 index 0000000..f39836d --- /dev/null +++ b/lua/user/lsp/handlers.lua @@ -0,0 +1,160 @@ +local M = {} + +local status_cmp_ok, cmp_nvim_lsp = pcall(require, "cmp_nvim_lsp") +if not status_cmp_ok then + return +end + +M.capabilities = vim.lsp.protocol.make_client_capabilities() +M.capabilities.textDocument.completion.completionItem.snippetSupport = true +M.capabilities = cmp_nvim_lsp.default_capabilities(M.capabilities) + +M.setup = function() + local signs = { + { name = "DiagnosticSignError", text = "" }, + { name = "DiagnosticSignWarn", text = "" }, + { name = "DiagnosticSignHint", text = "" }, + { name = "DiagnosticSignInfo", text = "" }, + } + + for _, sign in ipairs(signs) do + vim.fn.sign_define(sign.name, { texthl = sign.name, text = sign.text, numhl = "" }) + end + + local config = { + virtual_text = false, -- disable virtual text + signs = { + active = signs, -- show signs + }, + update_in_insert = true, + underline = true, + severity_sort = true, + float = { + focusable = true, + style = "minimal", + border = "rounded", + source = "always", + header = "", + prefix = "", + }, + } + + vim.diagnostic.config(config) + + vim.lsp.handlers["textDocument/hover"] = vim.lsp.with(vim.lsp.handlers.hover, { + border = "rounded", + }) + + vim.lsp.handlers["textDocument/signatureHelp"] = vim.lsp.with(vim.lsp.handlers.signature_help, { + border = "rounded", + }) +end + +local function lsp_keymaps(bufnr) + local opts = { noremap = true, silent = true } + local keymap = vim.api.nvim_buf_set_keymap + keymap(bufnr, "n", "gD", "lua vim.lsp.buf.declaration()", opts) + keymap(bufnr, "n", "gd", "lua vim.lsp.buf.definition()", opts) + keymap(bufnr, "n", "K", "lua vim.lsp.buf.hover()", opts) + keymap(bufnr, "n", "gI", "lua vim.lsp.buf.implementation()", opts) + keymap(bufnr, "n", "gr", "lua vim.lsp.buf.references()", opts) + keymap(bufnr, "n", "gl", "lua vim.diagnostic.open_float()", opts) + keymap(bufnr, "n", "lf", "lua vim.lsp.buf.format{ async = true }", opts) + keymap(bufnr, "n", "li", "LspInfo", opts) + keymap(bufnr, "n", "lI", "LspInstallInfo", opts) + keymap(bufnr, "n", "la", "lua vim.lsp.buf.code_action()", opts) + keymap(bufnr, "n", "lj", "lua vim.diagnostic.goto_next({buffer=0})", opts) + keymap(bufnr, "n", "lk", "lua vim.diagnostic.goto_prev({buffer=0})", opts) + keymap(bufnr, "n", "lr", "lua vim.lsp.buf.rename()", opts) + keymap(bufnr, "n", "ls", "lua vim.lsp.buf.signature_help()", opts) + keymap(bufnr, "n", "lq", "lua vim.diagnostic.setloclist()", opts) +end + +M.on_attach = function(client, bufnr) + + if client.name == "omnisharp" then + client.server_capabilities.semanticTokensProvider = { + full = vim.empty_dict(), + legend = { + tokenModifiers = { "static_symbol" }, + tokenTypes = { + "comment", + "excluded_code", + "identifier", + "keyword", + "keyword_control", + "number", + "operator", + "operator_overloaded", + "preprocessor_keyword", + "string", + "whitespace", + "text", + "static_symbol", + "preprocessor_text", + "punctuation", + "string_verbatim", + "string_escape_character", + "class_name", + "delegate_name", + "enum_name", + "interface_name", + "module_name", + "struct_name", + "type_parameter_name", + "field_name", + "enum_member_name", + "constant_name", + "local_name", + "parameter_name", + "method_name", + "extension_method_name", + "property_name", + "event_name", + "namespace_name", + "label_name", + "xml_doc_comment_attribute_name", + "xml_doc_comment_attribute_quotes", + "xml_doc_comment_attribute_value", + "xml_doc_comment_cdata_section", + "xml_doc_comment_comment", + "xml_doc_comment_delimiter", + "xml_doc_comment_entity_reference", + "xml_doc_comment_name", + "xml_doc_comment_processing_instruction", + "xml_doc_comment_text", + "xml_literal_attribute_name", + "xml_literal_attribute_quotes", + "xml_literal_attribute_value", + "xml_literal_cdata_section", + "xml_literal_comment", + "xml_literal_delimiter", + "xml_literal_embedded_expression", + "xml_literal_entity_reference", + "xml_literal_name", + "xml_literal_processing_instruction", + "xml_literal_text", + "regex_comment", + "regex_character_class", + "regex_anchor", + "regex_quantifier", + "regex_grouping", + "regex_alternation", + "regex_text", + "regex_self_escaped_character", + "regex_other_escape", + }, + }, + range = true, + } + end + + lsp_keymaps(bufnr) + local status_ok, illuminate = pcall(require, "illuminate") + if not status_ok then + return + end + illuminate.on_attach(client) +end + +return M diff --git a/lua/user/lsp/init.lua b/lua/user/lsp/init.lua new file mode 100644 index 0000000..6eb3f5f --- /dev/null +++ b/lua/user/lsp/init.lua @@ -0,0 +1,8 @@ +local status_ok, _ = pcall(require, "lspconfig") +if not status_ok then + return +end + +require("user.lsp.mason") +require("user.lsp.handlers").setup() +require("user.lsp.null-ls") diff --git a/lua/user/lsp/mason.lua b/lua/user/lsp/mason.lua new file mode 100644 index 0000000..b47c2bc --- /dev/null +++ b/lua/user/lsp/mason.lua @@ -0,0 +1,46 @@ +local servers = { + "lua_ls", + "omnisharp", +} + +local settings = { + ui = { + border = "none", + icons = { + package_installed = "◍", + package_pending = "◍", + package_uninstalled = "◍", + }, + }, + log_level = vim.log.levels.INFO, + max_concurrent_installers = 4, +} + +require("mason").setup(settings) +require("mason-lspconfig").setup({ + -- ensure_installed = servers, + -- automatic_installation = true +}) + +local lspconfig_status_ok, lspconfig = pcall(require, "lspconfig") +if not lspconfig_status_ok then + return +end + +local opts = {} + +for _, server in pairs(servers) do + opts = { + on_attach = require("user.lsp.handlers").on_attach, + capabilities = require("user.lsp.handlers").capabilities + } + + server = vim.split(server, "@")[1] + + local require_ok, conf_opts = pcall(require, "user.lsp.settings." .. server) + if require_ok then + opts = vim.tbl_deep_extend("force", conf_opts, opts) + end + + lspconfig[server].setup(opts) +end diff --git a/lua/user/lsp/null-ls.lua b/lua/user/lsp/null-ls.lua new file mode 100644 index 0000000..d32571a --- /dev/null +++ b/lua/user/lsp/null-ls.lua @@ -0,0 +1,20 @@ +local null_ls_status_ok, null_ls = pcall(require, "null-ls") +if not null_ls_status_ok then + return +end + +-- https://github.com/jose-elias-alvarez/null-ls.nvim/tree/main/lua/null-ls/builtins/formatting +local formatting = null_ls.builtins.formatting +-- https://github.com/jose-elias-alvarez/null-ls.nvim/tree/main/lua/null-ls/builtins/diagnostics +local diagnostics = null_ls.builtins.diagnostics + +null_ls.setup({ + debug = false, + sources = { + -- formatting.prettier.with({ extra_args = { "--no-semi", "--single-quote", "--jsx-single-quote" } }), + -- formatting.black.with({ extra_args = { "--fast" } }), + -- formatting.stylua, + -- diagnostics.flake8 + formatting.astyle + }, +}) diff --git a/lua/user/lsp/settings/lua_ls.lua b/lua/user/lsp/settings/lua_ls.lua new file mode 100644 index 0000000..17f0abe --- /dev/null +++ b/lua/user/lsp/settings/lua_ls.lua @@ -0,0 +1,19 @@ +return { + settings = { + Lua = { + runtime = { + version = "LuaJIT", -- Tell the language server which version of Lua you"re using (most likely LuaJIT in the case of Neovim) + }, + diagnostics = { + globals = { "vim" }, -- Get the language server to recognize the `vim` global + }, + workspace = { + library = vim.api.nvim_get_runtime_file("", true), -- Make the server aware of Neovim runtime files + }, + -- Do not send telemetry data containing a randomized but unique identifier + telemetry = { + enable = false, + }, + }, + }, +} diff --git a/lua/user/lualine.lua b/lua/user/lualine.lua new file mode 100644 index 0000000..3318ecd --- /dev/null +++ b/lua/user/lualine.lua @@ -0,0 +1,93 @@ +local status_ok, lualine = pcall(require, "lualine") +if not status_ok then + return +end + +local hide_in_width = function() + return vim.fn.winwidth(0) > 80 +end + +local diagnostics = { + "diagnostics", + sources = { "nvim_diagnostic" }, + sections = { "error", "warn" }, + symbols = { error = " ", warn = " " }, + colored = false, + update_in_insert = false, + always_visible = true, +} + +local diff = { + "diff", + colored = false, + symbols = { added = " ", modified = " ", removed = " " }, -- changes diff symbols + cond = hide_in_width +} + +local mode = { + "mode", + fmt = function(str) + return "-- " .. str .. " --" + end, +} + +local filetype = { + "filetype", + icons_enabled = false, + icon = nil, +} + +local branch = { + "branch", + icons_enabled = true, + icon = "", +} + +local location = { + "location", + padding = 0, +} + +-- cool function for progress +local progress = function() + local current_line = vim.fn.line(".") + local total_lines = vim.fn.line("$") + local chars = { "__", "▁▁", "▂▂", "▃▃", "▄▄", "▅▅", "▆▆", "▇▇", "██" } + local line_ratio = current_line / total_lines + local index = math.ceil(line_ratio * #chars) + return chars[index] +end + +local spaces = function() + return "spaces: " .. vim.api.nvim_buf_get_option(0, "shiftwidth") +end + +lualine.setup({ + options = { + icons_enabled = true, + theme = "auto", + component_separators = { left = "", right = "" }, + section_separators = { left = "", right = "" }, + disabled_filetypes = { "alpha", "dashboard", "NvimTree", "Outline" }, + always_divide_middle = true, + }, + sections = { + lualine_a = { branch, diagnostics }, + lualine_b = { mode }, + lualine_c = {}, + -- lualine_x = { "encoding", "fileformat", "filetype" }, + lualine_x = { diff, spaces, "encoding", filetype }, + lualine_y = { location }, + lualine_z = { progress }, + }, + inactive_sections = { + lualine_a = {}, + lualine_b = {}, + lualine_c = { "filename" }, + lualine_x = { "location" }, + lualine_y = {}, + lualine_z = {}, + }, + tabline = {}, + extensions = {}, +}) diff --git a/lua/user/nvim-tree.lua b/lua/user/nvim-tree.lua new file mode 100644 index 0000000..e0bffac --- /dev/null +++ b/lua/user/nvim-tree.lua @@ -0,0 +1,137 @@ +local status_ok, nvim_tree = pcall(require, "nvim-tree") +if not status_ok then + return +end + +local config_status_ok, nvim_tree_config = pcall(require, "nvim-tree.config") +if not config_status_ok then + return +end + +local tree_cb = nvim_tree_config.nvim_tree_callback + +-- https://github.com/nvim-tree/nvim-tree.lua/wiki/Migrating-To-on_attach for assistance in migrating. +local function on_attach(bufnr) + local api = require('nvim-tree.api') + + local function opts(desc) + return { desc = 'nvim-tree: ' .. desc, buffer = bufnr, noremap = true, silent = true, nowait = true } + end + + -- Default mappings. Feel free to modify or remove as you wish. + -- + -- BEGIN_DEFAULT_ON_ATTACH + vim.keymap.set('n', '', api.tree.change_root_to_node, opts('CD')) + vim.keymap.set('n', '', api.node.open.replace_tree_buffer, opts('Open: In Place')) + vim.keymap.set('n', '', api.node.show_info_popup, opts('Info')) + vim.keymap.set('n', '', api.fs.rename_sub, opts('Rename: Omit Filename')) + vim.keymap.set('n', '', api.node.open.tab, opts('Open: New Tab')) + vim.keymap.set('n', '', api.node.open.vertical, opts('Open: Vertical Split')) + vim.keymap.set('n', '', api.node.open.horizontal, opts('Open: Horizontal Split')) + vim.keymap.set('n', '', api.node.navigate.parent_close, opts('Close Directory')) + vim.keymap.set('n', '', api.node.open.edit, opts('Open')) + vim.keymap.set('n', '', api.node.open.preview, opts('Open Preview')) + vim.keymap.set('n', '>', api.node.navigate.sibling.next, opts('Next Sibling')) + vim.keymap.set('n', '<', api.node.navigate.sibling.prev, opts('Previous Sibling')) + vim.keymap.set('n', '.', api.node.run.cmd, opts('Run Command')) + vim.keymap.set('n', '-', api.tree.change_root_to_parent, opts('Up')) + vim.keymap.set('n', 'a', api.fs.create, opts('Create')) + vim.keymap.set('n', 'bd', api.marks.bulk.delete, opts('Delete Bookmarked')) + vim.keymap.set('n', 'bmv', api.marks.bulk.move, opts('Move Bookmarked')) + vim.keymap.set('n', 'B', api.tree.toggle_no_buffer_filter, opts('Toggle No Buffer')) + vim.keymap.set('n', 'c', api.fs.copy.node, opts('Copy')) + vim.keymap.set('n', 'C', api.tree.toggle_git_clean_filter, opts('Toggle Git Clean')) + vim.keymap.set('n', '[c', api.node.navigate.git.prev, opts('Prev Git')) + vim.keymap.set('n', ']c', api.node.navigate.git.next, opts('Next Git')) + vim.keymap.set('n', 'd', api.fs.remove, opts('Delete')) + vim.keymap.set('n', 'D', api.fs.trash, opts('Trash')) + vim.keymap.set('n', 'E', api.tree.expand_all, opts('Expand All')) + vim.keymap.set('n', 'e', api.fs.rename_basename, opts('Rename: Basename')) + vim.keymap.set('n', ']e', api.node.navigate.diagnostics.next, opts('Next Diagnostic')) + vim.keymap.set('n', '[e', api.node.navigate.diagnostics.prev, opts('Prev Diagnostic')) + vim.keymap.set('n', 'F', api.live_filter.clear, opts('Clean Filter')) + vim.keymap.set('n', 'f', api.live_filter.start, opts('Filter')) + vim.keymap.set('n', 'g?', api.tree.toggle_help, opts('Help')) + vim.keymap.set('n', 'gy', api.fs.copy.absolute_path, opts('Copy Absolute Path')) + vim.keymap.set('n', 'H', api.tree.toggle_hidden_filter, opts('Toggle Dotfiles')) + vim.keymap.set('n', 'I', api.tree.toggle_gitignore_filter, opts('Toggle Git Ignore')) + vim.keymap.set('n', 'J', api.node.navigate.sibling.last, opts('Last Sibling')) + vim.keymap.set('n', 'K', api.node.navigate.sibling.first, opts('First Sibling')) + vim.keymap.set('n', 'm', api.marks.toggle, opts('Toggle Bookmark')) + vim.keymap.set('n', 'o', api.node.open.edit, opts('Open')) + vim.keymap.set('n', 'O', api.node.open.no_window_picker, opts('Open: No Window Picker')) + vim.keymap.set('n', 'p', api.fs.paste, opts('Paste')) + vim.keymap.set('n', 'P', api.node.navigate.parent, opts('Parent Directory')) + vim.keymap.set('n', 'q', api.tree.close, opts('Close')) + vim.keymap.set('n', 'r', api.fs.rename, opts('Rename')) + vim.keymap.set('n', 'R', api.tree.reload, opts('Refresh')) + vim.keymap.set('n', 's', api.node.run.system, opts('Run System')) + vim.keymap.set('n', 'S', api.tree.search_node, opts('Search')) + vim.keymap.set('n', 'U', api.tree.toggle_custom_filter, opts('Toggle Hidden')) + vim.keymap.set('n', 'W', api.tree.collapse_all, opts('Collapse')) + vim.keymap.set('n', 'x', api.fs.cut, opts('Cut')) + vim.keymap.set('n', 'y', api.fs.copy.filename, opts('Copy Name')) + vim.keymap.set('n', 'Y', api.fs.copy.relative_path, opts('Copy Relative Path')) + vim.keymap.set('n', '<2-LeftMouse>', api.node.open.edit, opts('Open')) + vim.keymap.set('n', '<2-RightMouse>', api.tree.change_root_to_node, opts('CD')) + -- END_DEFAULT_ON_ATTACH + + -- Mappings migrated from view.mappings.list + -- + -- You will need to insert "your code goes here" for any mappings with a custom action_cb + vim.keymap.set('n', 'l', api.node.open.edit, opts('Open')) + vim.keymap.set('n', '', api.node.open.edit, opts('Open')) + vim.keymap.set('n', 'o', api.node.open.edit, opts('Open')) + vim.keymap.set('n', 'h', api.node.navigate.parent_close, opts('Close Directory')) + vim.keymap.set('n', 'v', api.node.open.vertical, opts('Open: Vertical Split')) +end + +nvim_tree.setup { + update_focused_file = { + enable = true, + update_cwd = true, + }, + renderer = { + root_folder_modifier = ":t", + icons = { + glyphs = { + default = "", + symlink = "", + folder = { + arrow_open = "", + arrow_closed = "", + default = "", + open = "", + empty = "", + empty_open = "", + symlink = "", + symlink_open = "", + }, + git = { + unstaged = "", + staged = "S", + unmerged = "", + renamed = "➜", + untracked = "U", + deleted = "", + ignored = "◌", + }, + }, + }, + }, + diagnostics = { + enable = true, + show_on_dirs = true, + icons = { + hint = "", + info = "", + warning = "", + error = "", + }, + }, + view = { + width = 30, + side = "left" + }, + on_attach = on_attach +} diff --git a/lua/user/options.lua b/lua/user/options.lua new file mode 100644 index 0000000..3dec50b --- /dev/null +++ b/lua/user/options.lua @@ -0,0 +1,51 @@ +local options = { + backup = false, -- creates a backup file + clipboard = "unnamedplus", -- allows neovim to access the system clipboard + cmdheight = 1, -- more space in the neovim command line for displaying messages + completeopt = { "menuone", "noselect" }, -- mostly just for cmp + conceallevel = 0, -- so that `` is visible in markdown files + fileencoding = "utf-8", -- the encoding written to a file + hlsearch = true, -- highlight all matches on previous search pattern + ignorecase = true, -- ignore case in search patterns + mouse = "a", -- allow the mouse to be used in neovim + pumheight = 10, -- pop up menu height + showmode = false, -- we don't need to see things like -- INSERT -- anymore + showtabline = 2, -- always show tabs + smartcase = true, -- smart case + smartindent = true, -- make indenting smarter again + splitbelow = true, -- force all horizontal splits to go below current window + splitright = true, -- force all vertical splits to go to the right of current window + swapfile = false, -- creates a swapfile + -- termguicolors = true, -- set term gui colors (most terminals support this) + timeoutlen = 300, -- time to wait for a mapped sequence to complete (in milliseconds) + undofile = true, -- enable persistent undo + updatetime = 300, -- faster completion (4000ms default) + writebackup = false, -- if a file is being edited by another program (or was written to file while editing with another program), it is not allowed to be edited + expandtab = true, -- convert tabs to spaces + shiftwidth = 4, -- the number of spaces inserted for each indentation + tabstop = 4, -- insert 4 spaces for a tab + softtabstop = 4, -- number of spaces a counts for. When 0, feature is off (sts). + cursorline = true, -- highlight the current line + number = true, -- set numbered lines + relativenumber = true, -- set relative numbered lines + numberwidth = 4, -- set number column width to 2 {default 4} + + signcolumn = "yes", -- always show the sign column, otherwise it would shift the text each time + wrap = true, -- display lines as one long line + linebreak = true, -- companion to wrap, don't split words + scrolloff = 8, -- minimal number of screen lines to keep above and below the cursor + sidescrolloff = 8, -- minimal number of screen columns either side of cursor if wrap is `false` + guifont = "monospace:h17", -- the font used in graphical neovim applications + whichwrap = "bs<>[]hl", -- which "horizontal" keys are allowed to travel to prev/next line +} + +for k, v in pairs(options) do + vim.opt[k] = v +end + +-- vim.opt.shortmess = "ilmnrx" -- flags to shorten vim messages, see :help 'shortmess' +vim.opt.shortmess:append "c" -- don't give |ins-completion-menu| messages +vim.opt.iskeyword:append "-" -- hyphenated words recognized by searches +vim.opt.formatoptions:remove({ "c", "r", "o" }) -- don't insert the current comment leader automatically for auto-wrapping comments using 'textwidth', hitting in insert mode, or hitting 'o' or 'O' in normal mode. +vim.opt.runtimepath:remove("/usr/share/vim/vimfiles") -- separate vim plugins from neovim in case vim still in use + diff --git a/lua/user/plugins.lua b/lua/user/plugins.lua new file mode 100644 index 0000000..ea953e3 --- /dev/null +++ b/lua/user/plugins.lua @@ -0,0 +1,98 @@ +-- Automatically install packerplug +local ensure_packer = function() + local fn = vim.fn + local install_path = fn.stdpath("data").."/site/pack/packer/start/packer.nvim" + if fn.empty(fn.glob(install_path)) > 0 then + fn.system({ "git", "clone", "--depth", "1", "https://github.com/wbthomason/packer.nvim", install_path }) + print("Installing packer close and reopen Neovim...") + vim.cmd [[packadd packer.nvim]] + return true + end + return false +end + +local packer_bootstrap = ensure_packer() + +-- Autocommand that reloads neovim whenever you save the plugins.lua file +vim.cmd([[ + augroup packer_user_config + autocmd! + autocmd BufWritePost plugins.lua source | PackerSync + augroup end +]]) + +-- Use a protected call so we don't error out on first use +local status_ok, packer = pcall(require, "packer") +if not status_ok then + return +end + +-- Have packer use a popup window +packer.init({ + display = { + open_fn = function() + return require("packer.util").float({ border = "rounded" }) + end, + }, +}) + +-- Install your plugins here +return packer.startup(function(use) + use "wbthomason/packer.nvim" -- Have packer manage itself + use "nvim-lua/plenary.nvim" -- Useful lua functions used by lots of plugins + use "windwp/nvim-autopairs" -- Autopairs, integrates with both cmp and treesitter + use "numToStr/Comment.nvim" + use "kyazdani42/nvim-tree.lua" + use "akinsho/bufferline.nvim" + use "moll/vim-bbye" + use { "nvim-lualine/lualine.nvim", requires = { "nvim-tree/nvim-web-devicons" } } + use "akinsho/toggleterm.nvim" + use "ahmedkhalf/project.nvim" + use "lewis6991/impatient.nvim" + use "lukas-reineke/indent-blankline.nvim" + use "goolord/alpha-nvim" + use "folke/which-key.nvim" + use { "iamcco/markdown-preview.nvim", run = function() vim.fn["mkdp#util#install"]() end } + + -- Colorschemes + use "folke/tokyonight.nvim" + use "lunarvim/darkplus.nvim" + use "Mofiqul/vscode.nvim" + + -- Cmp + use "hrsh7th/nvim-cmp" -- The completion plugin + use "hrsh7th/cmp-buffer" -- buffer completions + use "hrsh7th/cmp-path" -- path completions + use "saadparwaiz1/cmp_luasnip" -- snippet completions + use "hrsh7th/cmp-nvim-lsp" + use "hrsh7th/cmp-nvim-lua" + + -- Snippets + use "L3MON4D3/LuaSnip" --snippet engine + use "rafamadriz/friendly-snippets" -- a bunch of snippets to use + + -- LSP + use "neovim/nvim-lspconfig" -- enable LSP + use "williamboman/mason.nvim" -- simple to use language server installer + use "williamboman/mason-lspconfig.nvim" + use "jose-elias-alvarez/null-ls.nvim" -- for formatters and linters + use "RRethy/vim-illuminate" + + -- DAP + use { "rcarriga/nvim-dap-ui", requires = { "mfussenegger/nvim-dap" } } + + -- Telescope + use "nvim-telescope/telescope.nvim" + + -- Treesitter + use { "nvim-treesitter/nvim-treesitter", requires = { "JoosepAlviste/nvim-ts-context-commentstring", commit = "4d3a68c41a53add8804f471fcc49bb398fe8de08" } } + + -- Git + use "lewis6991/gitsigns.nvim" + + -- Automatically set up your configuration after cloning packer.nvim + -- Put this at the end after all plugins + if packer_bootstrap then + require("packer").sync() + end +end) diff --git a/lua/user/project.lua b/lua/user/project.lua new file mode 100644 index 0000000..27a1329 --- /dev/null +++ b/lua/user/project.lua @@ -0,0 +1,48 @@ +local status_ok, project = pcall(require, "project_nvim") +if not status_ok then + return +end +project.setup({ + ---@usage set to false to disable project.nvim. + --- This is on by default since it's currently the expected behavior. + active = true, + + on_config_done = nil, + + ---@usage set to true to disable setting the current-woriking directory + --- Manual mode doesn't automatically change your root directory, so you have + --- the option to manually do so using `:ProjectRoot` command. + manual_mode = false, + + ---@usage Methods of detecting the root directory + --- Allowed values: **"lsp"** uses the native neovim lsp + --- **"pattern"** uses vim-rooter like glob pattern matching. Here + --- order matters: if one is not detected, the other is used as fallback. You + --- can also delete or rearangne the detection methods. + -- detection_methods = { "lsp", "pattern" }, -- NOTE: lsp detection will get annoying with multiple langs in one project + detection_methods = { "pattern" }, + + ---@usage patterns used to detect root dir, when **"pattern"** is in detection_methods + patterns = { ".git", "_darcs", ".hg", ".bzr", ".svn", "Makefile", "package.json" }, + + ---@ Show hidden files in telescope when searching for files in a project + show_hidden = false, + + ---@usage When set to false, you will get a message when project.nvim changes your directory. + -- When set to false, you will get a message when project.nvim changes your directory. + silent_chdir = true, + + ---@usage list of lsp client names to ignore when using **lsp** detection. eg: { "efm", ... } + ignore_lsp = {}, + + ---@type string + ---@usage path to store the project history for use in telescope + datapath = vim.fn.stdpath("data"), +}) + +local tele_status_ok, telescope = pcall(require, "telescope") +if not tele_status_ok then + return +end + +telescope.load_extension('projects') diff --git a/lua/user/telescope.lua b/lua/user/telescope.lua new file mode 100644 index 0000000..54b83a9 --- /dev/null +++ b/lua/user/telescope.lua @@ -0,0 +1,99 @@ +local status_ok, telescope = pcall(require, "telescope") +if not status_ok then + return +end + +local actions = require "telescope.actions" + +telescope.setup { + defaults = { + + prompt_prefix = " ", + selection_caret = " ", + path_display = { "smart" }, + + mappings = { + i = { + [""] = actions.cycle_history_next, + [""] = actions.cycle_history_prev, + + [""] = actions.move_selection_next, + [""] = actions.move_selection_previous, + + [""] = actions.close, + + [""] = actions.move_selection_next, + [""] = actions.move_selection_previous, + + [""] = actions.select_default, + [""] = actions.select_horizontal, + [""] = actions.select_vertical, + [""] = actions.select_tab, + + [""] = actions.preview_scrolling_up, + [""] = actions.preview_scrolling_down, + + [""] = actions.results_scrolling_up, + [""] = actions.results_scrolling_down, + + [""] = actions.toggle_selection + actions.move_selection_worse, + [""] = actions.toggle_selection + actions.move_selection_better, + [""] = actions.send_to_qflist + actions.open_qflist, + [""] = actions.send_selected_to_qflist + actions.open_qflist, + [""] = actions.complete_tag, + [""] = actions.which_key, -- keys from pressing + }, + + n = { + [""] = actions.close, + [""] = actions.select_default, + [""] = actions.select_horizontal, + [""] = actions.select_vertical, + [""] = actions.select_tab, + + [""] = actions.toggle_selection + actions.move_selection_worse, + [""] = actions.toggle_selection + actions.move_selection_better, + [""] = actions.send_to_qflist + actions.open_qflist, + [""] = actions.send_selected_to_qflist + actions.open_qflist, + + ["j"] = actions.move_selection_next, + ["k"] = actions.move_selection_previous, + ["H"] = actions.move_to_top, + ["M"] = actions.move_to_middle, + ["L"] = actions.move_to_bottom, + + [""] = actions.move_selection_next, + [""] = actions.move_selection_previous, + ["gg"] = actions.move_to_top, + ["G"] = actions.move_to_bottom, + + [""] = actions.preview_scrolling_up, + [""] = actions.preview_scrolling_down, + + [""] = actions.results_scrolling_up, + [""] = actions.results_scrolling_down, + + ["?"] = actions.which_key, + }, + }, + }, + pickers = { + -- Default configuration for builtin pickers goes here: + -- picker_name = { + -- picker_config_key = value, + -- ... + -- } + -- Now the picker_config_key will be applied every time you call this + -- builtin picker + planets = { + show_pluto = true, + }, + }, + extensions = { + -- Your extension configuration goes here: + -- extension_name = { + -- extension_config_key = value, + -- } + -- please take a look at the readme of the extension you want to configure + }, +} diff --git a/lua/user/toggleterm.lua b/lua/user/toggleterm.lua new file mode 100644 index 0000000..1678b57 --- /dev/null +++ b/lua/user/toggleterm.lua @@ -0,0 +1,70 @@ +local status_ok, toggleterm = pcall(require, "toggleterm") +if not status_ok then + return +end + +toggleterm.setup({ + size = 20, + open_mapping = [[]], + hide_numbers = true, + shade_filetypes = {}, + shade_terminals = true, + shading_factor = 2, + start_in_insert = true, + insert_mappings = true, + persist_size = true, + direction = "horizontal", + close_on_exit = true, + shell = vim.o.shell, + float_opts = { + border = "curved", + winblend = 0, + highlights = { + border = "Normal", + background = "Normal", + }, + }, +}) + +function _G.set_terminal_keymaps() + local opts = {noremap = true} + vim.api.nvim_buf_set_keymap(0, 't', '', [[]], opts) + vim.api.nvim_buf_set_keymap(0, 't', 'jk', [[]], opts) + vim.api.nvim_buf_set_keymap(0, 't', '', [[h]], opts) + vim.api.nvim_buf_set_keymap(0, 't', '', [[j]], opts) + vim.api.nvim_buf_set_keymap(0, 't', '', [[k]], opts) + vim.api.nvim_buf_set_keymap(0, 't', '', [[l]], opts) +end + +vim.cmd('autocmd! TermOpen term://* lua set_terminal_keymaps()') + +local Terminal = require("toggleterm.terminal").Terminal +local lazygit = Terminal:new({ cmd = "lazygit", hidden = true }) + +function _LAZYGIT_TOGGLE() + lazygit:toggle() +end + +local node = Terminal:new({ cmd = "node", hidden = true }) + +function _NODE_TOGGLE() + node:toggle() +end + +local ncdu = Terminal:new({ cmd = "ncdu", hidden = true }) + +function _NCDU_TOGGLE() + ncdu:toggle() +end + +local htop = Terminal:new({ cmd = "htop", hidden = true }) + +function _HTOP_TOGGLE() + htop:toggle() +end + +local python = Terminal:new({ cmd = "python", hidden = true }) + +function _PYTHON_TOGGLE() + python:toggle() +end diff --git a/lua/user/treesitter.lua b/lua/user/treesitter.lua new file mode 100644 index 0000000..0f28e2f --- /dev/null +++ b/lua/user/treesitter.lua @@ -0,0 +1,26 @@ +local status_ok, configs = pcall(require, "nvim-treesitter.configs") +if not status_ok then + return +end + +configs.setup { + -- ensure_installed = { "maintained" }, -- put the language you want in this array + -- ensure_installed = "c_sharp", -- one of "all" or a list of languages + ignore_install = { "" }, -- List of parsers to ignore installing + sync_install = false, -- install languages synchronously (only applied to `ensure_installed`) + highlight = { + enable = true, -- false will disable the whole extension + --disable = { "css" }, -- list of language that will be disabled + }, + autopairs = { + enable = true, + }, + indent = { + enable = true, + disable = { "python", "css" } + }, + -- context_commentstring = { + -- enable = true, + -- enable_autocmd = false, + -- } +} diff --git a/lua/user/whichkey.lua b/lua/user/whichkey.lua new file mode 100644 index 0000000..0832841 --- /dev/null +++ b/lua/user/whichkey.lua @@ -0,0 +1,174 @@ +local status_ok, which_key = pcall(require, "which-key") +if not status_ok then + return +end + +local setup = { + plugins = { + marks = true, -- shows a list of your marks on ' and ` + registers = true, -- shows your registers on " in NORMAL or in INSERT mode + spelling = { + enabled = true, -- enabling this will show WhichKey when pressing z= to select spelling suggestions + suggestions = 20, -- how many suggestions should be shown in the list? + }, + -- the presets plugin, adds help for a bunch of default keybindings in Neovim + -- No actual key bindings are created + presets = { + operators = false, -- adds help for operators like d, y, ... and registers them for motion / text object completion + motions = true, -- adds help for motions + text_objects = true, -- help for text objects triggered after entering an operator + windows = true, -- default bindings on + nav = true, -- misc bindings to work with windows + z = true, -- bindings for folds, spelling and others prefixed with z + g = true, -- bindings for prefixed with g + }, + }, + -- add operators that will trigger motion and text object completion + -- to enable all native operators, set the preset / operators plugin above + -- operators = { gc = "Comments" }, + key_labels = { + -- override the label used to display some keys. It doesn't effect WK in any other way. + -- For example: + -- [""] = "SPC", + -- [""] = "RET", + -- [""] = "TAB", + }, + icons = { + breadcrumb = "»", -- symbol used in the command line area that shows your active key combo + separator = "➜", -- symbol used between a key and it's label + group = "+", -- symbol prepended to a group + }, + popup_mappings = { + scroll_down = "", -- binding to scroll down inside the popup + scroll_up = "", -- binding to scroll up inside the popup + }, + window = { + border = "rounded", -- none, single, double, shadow + position = "bottom", -- bottom, top + margin = { 1, 0, 1, 0 }, -- extra window margin [top, right, bottom, left] + padding = { 2, 2, 2, 2 }, -- extra window padding [top, right, bottom, left] + winblend = 0, + }, + layout = { + height = { min = 4, max = 25 }, -- min and max height of the columns + width = { min = 20, max = 50 }, -- min and max width of the columns + spacing = 3, -- spacing between columns + align = "left", -- align columns left, center or right + }, + ignore_missing = true, -- enable this to hide mappings for which you didn't specify a label + hidden = { "", "", "", "", "call", "lua", "^:", "^ " }, -- hide mapping boilerplate + show_help = true, -- show help message on the command line when the popup is visible + triggers = "auto", -- automatically setup triggers + -- triggers = {""} -- or specify a list manually + triggers_blacklist = { + -- list of mode / prefixes that should never be hooked by WhichKey + -- this is mostly relevant for key maps that start with a native binding + -- most people should not need to change this + i = { "j", "k" }, + v = { "j", "k" }, + }, +} + +local opts = { + mode = "n", -- NORMAL mode + prefix = "", + buffer = nil, -- Global mappings. Specify a buffer number for buffer local mappings + silent = true, -- use `silent` when creating keymaps + noremap = true, -- use `noremap` when creating keymaps + nowait = true, -- use `nowait` when creating keymaps +} + +local mappings = { + ["a"] = { "Alpha", "Alpha" }, + ["b"] = { + "lua require('telescope.builtin').buffers(require('telescope.themes').get_dropdown{previewer = false})", + "Buffers", + }, + ["e"] = { "NvimTreeToggle", "Explorer" }, + ["w"] = { "w!", "Save" }, + ["q"] = { "q!", "Quit" }, + ["c"] = { "Bdelete!", "Close Buffer" }, + ["h"] = { "nohlsearch", "No Highlight" }, + ["f"] = { + "lua require('telescope.builtin').find_files(require('telescope.themes').get_dropdown{previewer = false})", + "Find files", + }, + ["m"] = { "MarkdownPreviewToggle", "Toggle markdow previewer" }, + ["F"] = { "Telescope live_grep theme=ivy", "Find Text" }, + ["P"] = { "lua require('telescope').extensions.projects.projects()", "Projects" }, + p = { + name = "Packer", + c = { "PackerCompile", "Compile" }, + i = { "PackerInstall", "Install" }, + s = { "PackerSync", "Sync" }, + S = { "PackerStatus", "Status" }, + u = { "PackerUpdate", "Update" }, + }, + g = { + name = "Git", + g = { "lua _LAZYGIT_TOGGLE()", "Lazygit" }, + j = { "lua require('gitsigns').next_hunk()", "Next Hunk" }, + k = { "lua require('gitsigns').prev_hunk()", "Prev Hunk" }, + l = { "lua require('gitsigns').blame_line()", "Blame" }, + p = { "lua require('gitsigns').preview_hunk()", "Preview Hunk" }, + r = { "lua require('gitsigns').reset_hunk()", "Reset Hunk" }, + R = { "lua require('gitsigns').reset_buffer()", "Reset Buffer" }, + s = { "lua require('gitsigns').stage_hunk()", "Stage Hunk" }, + u = { "lua require('gitsigns').undo_stage_hunk()", "Undo Stage Hunk", }, + o = { "Telescope git_status", "Open changed file" }, + b = { "Telescope git_branches", "Checkout branch" }, + c = { "Telescope git_commits", "Checkout commit" }, + d = { "Gitsigns diffthis HEAD", "Diff", }, + }, + l = { + name = "LSP", + a = { "lua vim.lsp.buf.code_action()", "Code Action" }, + d = { "Telescope diagnostics bufnr=0", "Document Diagnostics", }, + w = { "Telescope diagnostics", "Workspace Diagnostics", }, + f = { "lua vim.lsp.buf.format{async=true}", "Format" }, + i = { "LspInfo", "Info" }, + I = { "LspInstallInfo", "Installer Info" }, + j = { "lua vim.lsp.diagnostic.goto_next()", "Next Diagnostic", }, + k = { "lua vim.lsp.diagnostic.goto_prev()", "Prev Diagnostic", }, + l = { "lua vim.lsp.codelens.run()", "CodeLens Action" }, + q = { "lua vim.diagnostic.setloclist()", "Quickfix" }, + r = { "lua vim.lsp.buf.rename()", "Rename" }, + s = { "Telescope lsp_document_symbols", "Document Symbols" }, + S = { "Telescope lsp_dynamic_workspace_symbols", "Workspace Symbols", }, + }, + s = { + name = "Search", + b = { "Telescope git_branches", "Checkout branch" }, + c = { "Telescope colorscheme", "Colorscheme" }, + h = { "Telescope help_tags", "Find Help" }, + M = { "Telescope man_pages", "Man Pages" }, + r = { "Telescope oldfiles", "Open Recent File" }, + R = { "Telescope registers", "Registers" }, + k = { "Telescope keymaps", "Keymaps" }, + C = { "Telescope commands", "Commands" }, + }, + + t = { + name = "Terminal", + n = { "lua _NODE_TOGGLE()", "Node" }, + u = { "lua _NCDU_TOGGLE()", "NCDU" }, + t = { "lua _HTOP_TOGGLE()", "Htop" }, + p = { "lua _PYTHON_TOGGLE()", "Python" }, + f = { "ToggleTerm direction=float", "Float" }, + h = { "ToggleTerm size=10 direction=horizontal", "Horizontal" }, + v = { "ToggleTerm size=80 direction=vertical", "Vertical" }, + }, + d = { + name = "Debugging", + c = { "lua require('dap').continue()", "Start/Continue (F5)" }, + o = { "lua require('dap').step_over()", "Step Over (F10)" }, + ["["] = { "lua require('dap').step_out()", "Step Out (F12)" }, + ["]"] = { "lua require('dap').step_into()", "Step Into (F11)" }, + b = { "lua require('dap').toggle_breakpoint()", "Toggle Braekpoint" }, + B = { "lua require('dap').set_breakpoint(vim.fn.input('Breakpoint condition: '))", "Set Breakpoint with Condition" }, + u = { "lua require('dapui').toggle()", "Toggle UI" } + } +} + +which_key.setup(setup) +which_key.register(mappings, opts)