diff options
Diffstat (limited to 'lua')
34 files changed, 4138 insertions, 41 deletions
diff --git a/lua/plugins/autopairs.lua b/lua/plugins/autopairs.lua new file mode 100644 index 0000000..fc39d2e --- /dev/null +++ b/lua/plugins/autopairs.lua @@ -0,0 +1,43 @@ +-- 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, + }, + map = "<M-e>", + pairs_map = { +['<'] = '>', +}, + disable_filetype = { "TelescopePrompt", "spectre_panel" }, + disable_in_macro = true, + disable_in_visualblock = true, + enalbe_moveright = true, + enable_afterquote = true, -- add bracket pairs after quote + enable_check_bracket_line = true, --- check bracket in same line + enable_bracket_in_quote = true, -- + break_undo = true, -- switch for basic rule break undo sequence + fast_wrap = { + 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/plugins/cmp-gh-source.lua b/lua/plugins/cmp-gh-source.lua new file mode 100644 index 0000000..05bba55 --- /dev/null +++ b/lua/plugins/cmp-gh-source.lua @@ -0,0 +1,72 @@ +local ok, Job = pcall(require, "plenary.job") +if not ok then + return +end + +local source = {} + +source.new = function() + local self = setmetatable({ cache = {} }, { __index = source }) + + return self +end + +source.complete = function(self, _, callback) + local bufnr = vim.api.nvim_get_current_buf() + + -- This just makes sure that we only hit the GH API once per session. + -- + -- You could remove this if you wanted, but this just makes it so we're + -- good programming citizens. + if not self.cache[bufnr] then + Job + :new({ + -- Uses `gh` executable to request the issues from the remote repository. + "gh", + "issue", + "list", + "--limit", + "1000", + "--json", + "title,number,body", + + on_exit = function(job) + local result = job:result() + local ok, parsed = pcall(vim.json.decode, table.concat(result, "")) + if not ok then + vim.notify "Failed to parse gh result" + return + end + + local items = {} + for _, gh_item in ipairs(parsed) do + gh_item.body = string.gsub(gh_item.body or "", "\r", "") + + table.insert(items, { + label = string.format("#%s", gh_item.number), + documentation = { + kind = "markdown", + value = string.format("# %s\n\n%s", gh_item.title, gh_item.body), + }, + }) + end + + callback { items = items, isIncomplete = false } + self.cache[bufnr] = items + end, + }) + :start() + else + callback { items = self.cache[bufnr], isIncomplete = false } + end +end + +source.get_trigger_characters = function() + return { "#" } +end + +source.is_available = function() + return vim.bo.filetype == "gitcommit" +end + +require("cmp").register_source("gh_issues", source.new()) diff --git a/lua/plugins/cmp.lua b/lua/plugins/cmp.lua new file mode 100644 index 0000000..1ef2580 --- /dev/null +++ b/lua/plugins/cmp.lua @@ -0,0 +1,319 @@ + +-- Setup nvim-cmp. +vim.opt.completeopt = "menu,menuone,noselect" +--vim.g.completeopt = "menu,menuone,noselect,noinsert" +local cmp_status_ok, cmp = pcall(require, "cmp") +if not cmp_status_ok then + return +end +--local WIDE_HEIGHT = 40 + +local opts = { + -- whether to highlight the currently hovered symbol + -- disable if your cpu usage is higher than you want it + -- or you just hate the highlight + -- default: true + highlight_hovered_item = true, + show_guides = true, +} +require("symbols-outline").setup(opts) + + +--local snippets_paths = function() +-- local plugins = { "friendly-snippets" } +-- local paths = {} +-- local path +-- local root_path = vim.env.HOME .. "/.vim/plugged/" +-- for _, plug in ipairs(plugins) do +-- path = root_path .. plug +-- if vim.fn.isdirectory(path) ~= 0 then +-- table.insert(paths, path) +-- end +-- end +-- return paths +--end +-- +--require("luasnip.loaders.from_vscode").lazy_load({ +-- paths = snippets_paths(), +-- include = nil, -- Load all languages +-- exclude = {}, +--}) + +--require("luasnip.loaders.from_vscode").lazy_load() +local lspkind = require("lspkind") +local kind_icons = { + Text = "", + Method = "m", --"", + Function = "", + Constructor = "", --"⚙️", + Field = "", + Variable = "", + Class = "", + Interface = "", + Module = "", + Property = "", + Unit = "", + Value = "", + Enum = "", + Keyword = "", + Snippet = "", + Color = "", + File = "", + Reference = "", + Folder = "", + EnumMember = "", + Constant = "", + Struct = "", + Event = "", + Operator = "", + TypeParameter = "", +} +cmp.setup({ + snippet = { + --expand = function(args) + -- require("luasnip").lsp_expand(args.body) + --end, + expand = function(args) + local luasnip = require("luasnip") + if not luasnip then + return + end + luasnip.lsp_expand(args.body) + end, + }, + mapping = cmp.mapping.preset.insert({ +-- ["<CR>"] = cmp.mapping.confirm({ +-- behavior = cmp.ConfirmBehavior.Replace, +-- select = true, +-- }), + --["<C-k>"] = cmp.mapping(cmp.mapping.select_prev_item(), { 'i', 'c' }), + --["<C-j>"] = cmp.mapping(cmp.mapping.select_next_item(), { 'i', 'c' }), + ['<C-y>'] = cmp.mapping.confirm({ select = true }), + --["<C-e>"] = cmp.mapping.close(), + --['<C-e>'] = cmp.mapping({ + -- i = cmp.mapping.abort(), + -- c = cmp.mapping.close(), + --}), + ["<C-e>"] = cmp.mapping({ + i = function() + if cmp.visible() then + cmp.abort() + require("user.utils").toggle_completion() + require("notify")("completion off") + else + cmp.complete() + require("user.utils").toggle_completion() + require("notify")("completion on") + end + end, + }), + --["<CR>"] = cmp.mapping({ + -- i = function(fallback) + -- if cmp.visible() then + -- cmp.confirm({ behavior = cmp.ConfirmBehavior.Replace, select = false }) + -- require("user.utils").toggle_completion() + -- else + -- fallback() + -- end + -- end, + --}), + +-- ["<C-e>"] = cmp.mapping({ +-- i = function() +-- if cmp.visible() then +-- require("notify")("visible") +-- cmp.abort() +-- else +-- require("notify")("not visible") +-- cmp.complete() +-- end +-- end, +-- c = function() +-- if cmp.visible() then +-- require("notify")("visible") +-- cmp.close() +-- else +-- require("notify")("not visible") +-- cmp.complete() +-- end +-- end, +-- }), + --['<CR>'] = cmp.config.disable, + ["<C-u>"] = cmp.mapping.scroll_docs(-4), + ["<C-d>"] = cmp.mapping.scroll_docs(4), + ["<C-Space>"] = cmp.mapping.complete(), + --['<C-o>'] = function(fallback) + -- if cmp.visible() then + -- cmp.mapping.confirm({ select = true })(fallback) + -- else + -- cmp.mapping.complete()(fallback) + -- end + --end + }), + + sources = cmp.config.sources({ + --{ name = "nvim_lua" }, + { name = "luasnip" }, + --{ name = 'luasnip', option = { use_show_condition = false } }, + { name = "gh_issues" }, + { name = "nvim_lsp", max_item_count = 6 }, + { name = "nvim_lua" }, + --{ name = "luasnip" }, + --{ name = "luasnip", keyword_length = 4 }, + --{ name = "buffer", keyword_length = 3 }, + { name = "path" }, + { name = "buffer", max_item_count = 6 }, + --{ name = "buffer", option = { get_bufnrs = function() + -- return vim.api.nvim_list_bufs() + --end + --}}, + { name = "cmp_git"}, + --{ name = 'treesitter' }, + --{ name = "cmdline", keyword_pattern = [=[[^[:blank:]\!]*]=] }, --exclamation mark hangs a bit without this + --{name = 'luasnip', keyword_length = 2}, + }), + formatting = { + --formatting = { + --local icons = kind_icons + --format = function(entry, vim_item) + ----vim_item.kind = string.format("%s", kind_icons[vim_item.kind]) + ----vim_item.kind = lspkind.presets.default[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.kind = string.format("%s %s", icons[vim_item.kind], vim_item.kind) + --vim_item.menu = ({ + ----nvim_lsp = "LSP", + ----luasnip = "snip", + ----buffer = "buf", + ----path = "path", + ----cmdline = "cmd", + --buffer = "[buf]", + --nvim_lsp = "[LSP]", + --nvim_lua = "[api]", + --path = "[path]", + --luasnip = "[snip]", + --cmdline = "[cmd]", + --gh_issues = "[issues]", + --})[entry.source.name] + --return vim_item + --end, + format = lspkind.cmp_format { + with_text = true, + menu = { + nvim_lsp = "[LSP]", + luasnip = "[snip]", + buffer = "[buf]", + nvim_lua = "[api]", + path = "[path]", + gh_issues = "[issues]", + }, + }, + --}, + + -- + -- + --fields = { "abbr", "kind", "menu" }, + -- format = lspkind.cmp_format({ + -- mode = 'symbol_text', -- show only symbol annotations + -- maxwidth = 50, -- prevent the popup from showing more than provided characters (e.g 50 will not show more than 50 characters) + -- }) + --format = require('lspkind').cmp_format { + -- with_text = true, + -- menu = { + -- luasnip = "Snip", + -- buffer = "Buf", + -- nvim_lsp = "LSP", + -- path = "Path", + -- cmdline = "Cmd", + -- cmp_git = "Git", + -- }, + --}, + }, + --format = function(entry, vim_item) + -- -- Kind icons + -- --vim_item.kind = string.format("%s", kind_icons[vim_item.kind]) + -- vim_item.kind = lspkind.presets.default[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 = "Snip", + -- buffer = "Buf", + -- path = "Path", + -- cmdline = "Cmd", + -- })[entry.source.name] + -- return vim_item + --end, + confirm_opts = { + behavior = cmp.ConfirmBehavior.Replace, + select = false, + }, + + + event = {}, + + experimental = { + ghost_text = true, + hl_group = 'Nontext', + --native_menu = false, + }, + + view = { + entries = { name = 'custom', selection_order = 'top_down' }, + }, + + window = { + --completion = cmp.config.window.bordered(), + completion = { + border = { '', '', '', ' ', '', '', '', ' ' }, + --border = { "╭", "─", "╮", "│", "╯", "─", "╰", "│" }, + --border = { '', '', '', '', '', '', '', '' }, + --border = "CmpBorder", + winhighlight = 'Normal:Pmenu,FloatBorder:Pmenu,CursorLine:PmenuSel,Search:None', + --winhighlight = "Normal:CmpPmenu,CursorLine:PmenuSel,Search:None", + }, + --documentation = cmp.config.window.bordered(), + documentation = { + --max_height = math.floor(WIDE_HEIGHT * (WIDE_HEIGHT / vim.o.lines)), + --max_width = math.floor((WIDE_HEIGHT * 2) * (vim.o.columns / (WIDE_HEIGHT * 2 * 16 / 9))), + border = { '', '', '', ' ', '', '', '', ' ' }, + --border = { "╭", "─", "╮", "│", "╯", "─", "╰", "│" }, + winhighlight = 'FloatBorder:NormalFloat', + }, + }, +}) + + +cmp.setup.cmdline({ '/', '?' }, { + mapping = cmp.mapping.preset.cmdline(), + sources = { + { name = "buffer" }, + }, +}) + +cmp.setup.cmdline(":", { + mapping = { + ["<C-p>"] = cmp.mapping(cmp.mapping.select_prev_item(), { 'i', 'c' }), + ["<C-n>"] = cmp.mapping(cmp.mapping.select_next_item(), { 'i', 'c' }), + ["<C-y>"] = cmp.mapping(cmp.mapping.confirm({ select = true }), { 'i', 'c' }), + ["<C-e>"] = cmp.mapping(cmp.mapping.close(), { 'i', 'c' }), + ["<C-u>"] = cmp.mapping(cmp.mapping.scroll_docs(-4), { 'i', 'c' }), + ["<C-d>"] = cmp.mapping(cmp.mapping.scroll_docs(4), { 'i', 'c' }), + ["<C-Space>"] = cmp.mapping(cmp.mapping.complete(), { 'i', 'c' }), + --["<C-k>"] = cmp.mapping.select_prev_item(), + --["<C-j>"] = cmp.mapping.select_next_item(), + --['<C-y>'] = cmp.mapping.confirm({ select = true }), + --["<C-e>"] = cmp.mapping.close(), + ----['<CR>'] = cmp.config.disable, + --["<C-u>"] = cmp.mapping.scroll_docs(-4), + --["<C-d>"] = cmp.mapping.scroll_docs(4), + --["<C-Space>"] = cmp.mapping.complete(), + }, + + sources = cmp.config.sources({ + { name = "path" }, + }, { + --{ name = "cmdline" }, + { name = "cmdline", keyword_pattern = [=[[^[:blank:]\!]*]=], keyword_length = 3 }, + }) +}) + + diff --git a/lua/plugins/colorizer.lua b/lua/plugins/colorizer.lua new file mode 100644 index 0000000..14d25e2 --- /dev/null +++ b/lua/plugins/colorizer.lua @@ -0,0 +1,6 @@ +local status, colorizer = pcall(require, "colorizer") +if (not status) then return end + +colorizer.setup({ + '*'; +}) diff --git a/lua/plugins/colorscheme.lua b/lua/plugins/colorscheme.lua new file mode 100644 index 0000000..3ded54c --- /dev/null +++ b/lua/plugins/colorscheme.lua @@ -0,0 +1,33 @@ +-- Colorscheme +-- ayu gruvbox molokai onedark srcery everblush vscode edge nightfly doom-one +local colorscheme = "doom-one" +local status_ok, _ = pcall(vim.cmd, "colorscheme " .. colorscheme) +if not status_ok then + vim.notify("colorscheme " .. colorscheme .. " not found!") + return +end + +vim.api.nvim_command("syntax on") +vim.api.nvim_command("highlight Normal guibg=none") +vim.api.nvim_command("highlight SignColumn guibg=none") +vim.api.nvim_command("highlight TabLine guibg=#333842 gui=bold") +--vim.api.nvim_command("highlight TabLine guibg=none gui=bold") +--vim.api.nvim_command("highlight StatusLine guibg=#333842 gui=bold") +--vim.api.nvim_command("highlight StatusLine guibg=#333842 guifg=#d6d3ea gui=bold") +--vim.api.nvim_command("highlight StatusLine guibg=none gui=bold") +--vim.api.nvim_command("highlight TabLineNC guibg=none gui=bold") +--vim.api.nvim_command("highlight TabLineSel guibg=#bd93f9 gui=bold") +vim.api.nvim_command("highlight TabLineSel guibg=#333842 gui=bold") +vim.api.nvim_command("highlight TabLineFill guibg=none gui=bold") +vim.api.nvim_command("highlight WinBar guibg=none gui=bold") +vim.api.nvim_command("highlight NormalFloat guibg=none") +vim.api.nvim_command("highlight MsgSeparator guibg=none") +--vim.api.nvim_command("highlight PmenuSel guibg=none") +--vim.api.nvim_command("highlight winblend guibg=none") +--vim.api.nvim_command("highlight StatusLine guibg=none gui=bold") +--vim.api.nvim_command("highlight StatusLineNC guibg=none gui=bold") +--vim.api.nvim_command("highlight StatusLineNC guibg=none ctermfg=Cyan guifg=#80a0ff gui=bold") + +require("notify").setup({ + background_colour = "#000000", +}) diff --git a/lua/plugins/git.lua b/lua/plugins/git.lua new file mode 100644 index 0000000..963f7f9 --- /dev/null +++ b/lua/plugins/git.lua @@ -0,0 +1,11 @@ +local status, git = pcall(require, "git") +if (not status) then return end + +git.setup({ + keymaps = { + -- Open blame window + blame = "<Leader>gb", + -- Open file/folder in git repository + browse = "<Leader>go", + } +}) diff --git a/lua/plugins/gitsigns.lua b/lua/plugins/gitsigns.lua new file mode 100644 index 0000000..53d1a1e --- /dev/null +++ b/lua/plugins/gitsigns.lua @@ -0,0 +1 @@ +require('gitsigns').setup {} diff --git a/lua/plugins/heirline.lua b/lua/plugins/heirline.lua new file mode 100644 index 0000000..f17f523 --- /dev/null +++ b/lua/plugins/heirline.lua @@ -0,0 +1,1203 @@ +local conditions = require("heirline.conditions") +local utils = require("heirline.utils") + +local colors = { + --bg = "#23232e", + bg = nil, + nobg = nil, + white = "#f8f8f2", + black = "#000000", + darkgray = "#23232e", + gray = "#2d2b3a", + lightgray = "#d6d3ea", + pink = "#f92672", + green = "#50fa7b", + blue = "#39BAE6", + yellow = "#f1fa8c", + orange = "#ffb86c", + purple = "#BF40BF", + violet = "#7F00FF", + red = "#ff5555", + cyan = "#66d9eC", + diag = { + warn = utils.get_highlight("DiagnosticSignWarn").fg, + error = utils.get_highlight("DiagnosticSignError").fg, + hint = utils.get_highlight("DiagnosticSignHint").fg, + info = utils.get_highlight("DiagnosticSignInfo").fg, + }, + git = { + del = "#e95678", + add = "#a6e22e", + change = "#ae81ff", + }, +} + +require("heirline").load_colors(colors) + +local Align = { provider = "%=", hl = { bg = colors.bg } } +local Space = { provider = " ", hl = { bg = colors.bg } } +local Tab = { provider = " " } +local LeftSpace = { provider = "" } +local RightSpace = { provider = "" } +local RightSpace2 = { provider = "" } +local RightSpace3 = { provider = "" } +local Fill = { provider = "%=", hl = { bg = colors.nobg } } +local LeftSep = { provider = "" } +local RightSep = { provider = "" } + +local ViMode = { + init = function(self) + self.mode = vim.fn.mode(1) + if not self.once then + vim.cmd("au ModeChanged *:*o redrawstatus") + end + self.once = true + end, + static = { + mode_names = { + n = "NORMAL ", + no = "N·OPERATOR PENDING ", + nov = "N?", + noV = "N?", + ["no\22"] = "N? ", + niI = "Ni", + niR = "Nr", + niV = "Nv", + nt = "Nt", + v = "VISUAL ", + vs = "Vs", + V = "V·LINE ", + ["\22"] = "V·BLOCK ", + ["\22s"] = "V·BLOCK ", + s = "SELECT ", + S = "S·LINE ", + ["\19"] = "S·BLOCK ", + i = "INSERT ", + ix = "insert x ", + ic = "insert c ", + R = "REPLACE ", + Rc = "Rc", + Rx = "Rx", + Rv = "V·REPLACE ", + Rvc = "Rv", + Rvx = "Rv", + c = "COMMAND ", + cv = "VIM EX ", + ce = "EX ", + r = "PROMPT ", + rm = "MORE ", + ["r?"] = "CONFIRM ", + ["!"] = "SHELL ", + t = "TERMINAL ", + }, + }, + provider = function(self) + return " %2(" .. self.mode_names[self.mode] .. "%) " + end, + hl = function(self) + local color = self:mode_color() + return { fg = color, bold = true } + end, + update = { + "ModeChanged", + }, +} + +-- LSP +local LSPActive = { + condition = conditions.lsp_attached, + update = { "LspAttach", "LspDetach" }, + + provider = function() + local buf_clients = vim.lsp.buf_get_clients() + local buf_client_names = {} + + -- add client + for _, client in pairs(buf_clients) do + if client.name ~= "null-ls" then + table.insert(buf_client_names, client.name) + end + end + return "⚙️ " .. table.concat(buf_client_names, "") + end, + hl = { fg = colors.lightgray, bold = false }, +} + +-- Navic +local Navic = { + condition = require("nvim-navic").is_available, + static = { + -- create a type highlight map + type_hl = { + File = "Directory", + Module = "Include", + Namespace = "TSNamespace", + Package = "Include", + Class = "Struct", + Method = "Method", + Property = "TSProperty", + Field = "TSField", + Constructor = "TSConstructor ", + Enum = "TSField", + Interface = "Type", + Function = "Function", + Variable = "TSVariable", + Constant = "Constant", + String = "String", + Number = "Number", + Boolean = "Boolean", + Array = "TSField", + Object = "Type", + Key = "TSKeyword", + Null = "Comment", + EnumMember = "TSField", + Struct = "Struct", + Event = "Keyword", + Operator = "Operator", + TypeParameter = "Type", + }, + }, + init = function(self) + local data = require("nvim-navic").get_data() or {} + local children = {} + -- create a child for each level + for i, d in ipairs(data) do + local child = { + { + provider = d.icon, + hl = self.type_hl[d.type], + }, + { + provider = d.name, + -- highlight icon only or location name as well + -- hl = self.type_hl[d.type], + }, + } + -- add a separator only if needed + if #data > 1 and i < #data then + table.insert(child, { + provider = " > ", + hl = { fg = colors.white }, + }) + end + table.insert(children, child) + end + -- instantiate the new child, overwriting the previous one + self[1] = self:new(children, 1) + end, + hl = { fg = colors.white }, +} + +-- Diagnostics +local Diagnostics = { + + condition = conditions.has_diagnostics, + + static = { + error_icon = vim.fn.sign_getdefined("DiagnosticSignError")[1].text, + warn_icon = vim.fn.sign_getdefined("DiagnosticSignWarn")[1].text, + info_icon = vim.fn.sign_getdefined("DiagnosticSignInfo")[1].text, + hint_icon = vim.fn.sign_getdefined("DiagnosticSignHint")[1].text, + }, + + init = function(self) + self.errors = #vim.diagnostic.get(0, { severity = vim.diagnostic.severity.ERROR }) + self.warnings = #vim.diagnostic.get(0, { severity = vim.diagnostic.severity.WARN }) + self.hints = #vim.diagnostic.get(0, { severity = vim.diagnostic.severity.HINT }) + self.info = #vim.diagnostic.get(0, { severity = vim.diagnostic.severity.INFO }) + end, + + update = { "DiagnosticChanged", "BufEnter" }, + + { + provider = function(self) + -- 0 is just another output, we can decide to print it or not! + return self.errors > 0 and (self.error_icon .. self.errors .. " ") + end, + hl = { fg = colors.diag.error, bg = colors.bg }, + }, + { + provider = function(self) + return self.warnings > 0 and (self.warn_icon .. self.warnings .. " ") + end, + hl = { fg = colors.diag.warn, bg = colors.bg }, + }, + { + provider = function(self) + return self.info > 0 and (self.info_icon .. self.info .. " ") + end, + hl = { fg = colors.diag.info, bg = colors.bg }, + }, + { + provider = function(self) + return self.hints > 0 and (self.hint_icon .. self.hints) + end, + hl = { fg = colors.diag.hint, bg = colors.bg }, + }, + on_click = { + callback = function() + require("trouble").toggle({ mode = "document_diagnostics" }) + -- or + -- vim.diagnostic.setqflist() + end, + name = "heirline_diagnostics", + }, +} + +-- Git +-- For the ones who're not (too) afraid of changes! Uses gitsigns. +local Git = { + condition = conditions.is_git_repo, + + init = function(self) + self.status_dict = vim.b.gitsigns_status_dict + self.has_changes = self.status_dict.added ~= 0 or self.status_dict.removed ~= 0 or self.status_dict.changed ~= 0 + end, + --hl = { fg = "orange" }, + hl = { fg = colors.orange, bg = colors.bg }, + { -- git branch name + provider = function(self) + return " " .. self.status_dict.head + end, + --hl = { bold = true }, + hl = { bold = true, bg = colors.bg }, + }, + -- You could handle delimiters, icons and counts similar to Diagnostics + { + condition = function(self) + return self.has_changes + end, + --provider = "(" + provider = " ", + }, + { + provider = function(self) + local count = self.status_dict.added or 0 + --return count > 0 and ("+" .. count) + return count > 0 and (" " .. count) + end, + --hl = { fg = "git_add" }, + hl = { fg = colors.git.add, bg = colors.bg }, + }, + { + provider = function(self) + local count = self.status_dict.removed or 0 + --return count > 0 and ("-" .. count) + return count > 0 and (" " .. count) + end, + --hl = { fg = "git_del" }, + hl = { fg = colors.git.del, bg = colors.bg }, + }, + { + provider = function(self) + local count = self.status_dict.changed or 0 + --return count > 0 and ("~" .. count) + return count > 0 and (" 柳" .. count) + end, + --hl = { fg = "git_change" }, + hl = { fg = colors.git.change, bg = colors.bg }, + }, + --{ + -- condition = function(self) + -- return self.has_changes + -- end, + -- provider = ")", + --}, + on_click = { + callback = function() + -- If you want to use Fugitive: + -- vim.cmd("G") + + -- If you prefer Lazygit + -- use vim.defer_fn() if the callback requires + -- opening of a floating window + -- (this also applies to telescope) + vim.defer_fn(function() + vim.cmd("Lazygit") + end, 100) + end, + name = "heirline_git", + }, +} + +-- Debugger +-- Display informations from nvim-dap! +local DAPMessages = { + -- display the dap messages only on the debugged file + condition = function() + local session = require("dap").session() + if session then + local filename = vim.api.nvim_buf_get_name(0) + if session.config then + local progname = session.config.program + return filename == progname + end + end + return false + end, + provider = function() + return " " .. require("dap").status() + end, + hl = { fg = utils.get_highlight("Debug").fg }, + -- Debugger on_click: step-over, step-into, next, previous, stop buttons + -- coming soon! +} + +-- Tests +-- This requires the great ultest. +--local UltTest = { +-- condition = function() +-- return vim .api.nvim_call_function("ultest#is_test_file", {}) ~= 0 +-- end, +-- static = { +-- passed_icon = vim.fn.sign_getdefined("test_pass")[1].text, +-- failed_icon = vim.fn.sign_getdefined("test_fail")[1].text, +-- passed_hl = { fg = utils.get_highlight("UltestPass").fg }, +-- failed_hl = { fg = utils.get_highlight("UltestFail").fg }, +-- }, +-- init = function(self) +-- self.status = vim.api.nvim_call_function("ultest#status", {}) +-- end, +-- +-- -- again, if you'd like icons and numbers to be colored differently, +-- -- just split the component in two +-- { +-- provider = function(self) +-- return self.passed_icon .. self.status.passed .. " " +-- end, +-- hl = function(self) +-- return self.passed_hl +-- end, +-- }, +-- { +-- provider = function(self) +-- return self.failed_icon .. self.status.failed .. " " +-- end, +-- hl = function(self) +-- return self.failed_hl +-- end, +-- }, +-- { +-- provider = function(self) +-- return "of " .. self.status.tests - 1 +-- end, +-- }, +--} + +-- FileNameBlock: FileIcon, FileName and friends +local FileNameBlock = { + -- let's first set up some attributes needed by this component and it's children + init = function(self) + self.filename = vim.api.nvim_buf_get_name(0) + end, + --hl = { fg = utils.get_highlight("Statusline").fg, bold = true, bg = colors.bg }, + hl = { bg = colors.bg }, +} + +-- FileIcon, FileName, FileFlags and FileNameModifier +local FileIcon = { + init = function(self) + local filename = self.filename + local extension = vim.fn.fnamemodify(filename, ":e") + self.icon, self.icon_color = + require("nvim-web-devicons").get_icon_color(filename, extension, { default = true }) + end, + provider = function(self) + return self.icon and (self.icon .. " ") + end, + hl = function(self) + return { fg = self.icon_color, bg = colors.bg } + end, +} + +local FileName = { + provider = function(self) + -- first, trim the pattern relative to the current directory. For other + -- options, see :h filename-modifers + local filename = vim.fn.fnamemodify(self.filename, ":.") + if filename == "" then + return "No Name" + end + -- now, if the filename would occupy more than 1/4th of the available + -- space, we trim the file path to its initials + -- See Flexible Components section below for dynamic truncation + if not conditions.width_percent_below(#filename, 0.25) then + filename = vim.fn.pathshorten(filename) + end + return filename + end, + --hl = { fg = utils.get_highlight("Statusline").fg, bold = false, bg = colors.bg }, + hl = { fg = colors.white, bold = false, bg = colors.bg }, +} + +local FileFlags = { + { + provider = function() + if vim.bo.modified then + return " [+]" -- ±[+] + end + end, + hl = { fg = colors.green, bg = colors.bg }, + }, + { + provider = function() + if not vim.bo.modifiable or vim.bo.readonly then + return " " + end + end, + --hl = { fg = colors.orange }, + hl = { fg = colors.orange, bold = true, bg = colors.bg }, + }, +} + +local FileNameModifier = { + hl = function() + if vim.bo.modified then + return { fg = colors.green, bold = false, force = true } + end + end, +} + +-- FileType, FileEncoding and FileFormat +local FileType = { + provider = function() + return vim.bo.filetype + end, + hl = { fg = colors.white, bold = false, bg = colors.bg }, +} + +local FileEncoding = { + Space, + provider = function() + local enc = (vim.bo.fenc ~= "" and vim.bo.fenc) or vim.o.enc -- :h 'enc' + return enc:lower() + end, + --hl = { fg = utils.get_highlight("Statusline").fg, bold = true, bg = colors.bg }, + hl = { bg = colors.bg, bold = false }, +} + +local FileFormat = { + provider = function() + local fmt = vim.bo.fileformat + --return fmt ~= "unix" and fmt:upper() + return fmt ~= "unix" and fmt:lower() + end, + hl = { fg = utils.get_highlight("Statusline").fg, bold = true, bg = colors.bg }, +} + +-- FileSize and FileLastModified +local FileSize = { + provider = function() + -- stackoverflow, compute human readable file size + local suffix = { "b", "k", "M", "G", "T", "P", "E" } + local fsize = vim.fn.getfsize(vim.api.nvim_buf_get_name(0)) + fsize = (fsize < 0 and 0) or fsize + if fsize < 1024 then + return fsize .. suffix[1] + end + local i = math.floor((math.log(fsize) / math.log(1024))) + return string.format("%.2g%s", fsize / math.pow(1024, i), suffix[i + 1]) + end, + hl = { fg = utils.get_highlight("Statusline").fg, bold = true, bg = colors.bg }, +} + +local FileLastModified = { + -- did you know? Vim is full of functions! + provider = function() + local ftime = vim.fn.getftime(vim.api.nvim_buf_get_name(0)) + return (ftime > 0) and os.date("%c", ftime) + end, + hl = { fg = utils.get_highlight("Statusline").fg, bold = true, bg = colors.bg }, +} + +-- Spell +-- Add indicator when spell is set! +local Spell = { + condition = function() + return vim.wo.spell + end, + provider = " 暈", + hl = { bold = true, fg = colors.yellow }, +} + +local help_file_name = { + condition = function() + return vim.bo.filetype == "help" + end, + provider = function() + local filename = vim.api.nvim_buf_get_name(0) + return vim.fn.fnamemodify(filename, ":t") + end, + hl = { fg = colors.blue }, +} + +-- Cursor position: Ruler +--local Ruler = { + -- %l = current line number + -- %L = number of lines in the buffer + -- %c = column number + -- %P = percentage through file of displayed window + --provider = "%P %(%l/%L%):%c ", + --provider = "%3(%2l%):%c %P ", + --provider = "%7(%l/%3L%):%2c%P ", + --provider = "%3(%P%)", + --provider = "%7(%l/%3L%):%2c %P", + --provider = "%7 %p%% Ln %l, Col %c", + --provider = "%9( %P %2l/%L :%2c %)", + --provider = "%9(%2l%2( : %c%)/%L %P %)", + --provider = "%7(%l:%c/%L%) ", + --provider = "%6(%l:%1.5c/%L%) %P ", + --provider = "%6(%l:%1.5c/%L%) ", + --provider = "%3(%l:%1.5c/%L%) ", + --provider = "%7(%l/%3L%):%2c ", +-- provider = "%7(%l:%c%) ", + --provider = "%l:%c ", + --hl = { fg = utils.get_highlight("Statusline").fg, bold = true }, +-- hl = { fg = colors.darkgray, bold = true }, +--} +local leftruler = { Space, Align } +local rightruler = { Align, Space } +local cursor_location = { + --{ provider = "", hl = { fg = utils.get_highlight("StatusLine").bg, bold = true } }, +-- { provider = "%<%-05.10(%l:%c%)", hl = { fg = colors.darkgray, bold = true } }, +-- { provider = " ", hl = { fg = colors.darkgray, bold = true } }, + --{ provider = "%P %=%<%(%l,%c)" }, + --{ provider = " %w%-8.(%l,%c%)%>" }, + { provider = " %1(%4l:%-3(%c%) %)%*", hl = { fg = colors.black, bold = true } }, +} +local Ruler = { cursor_location } + + --utils.make_flexible_component( + -- 3, + -- { Ruler, hl = { fg = utils.get_highlight("statusline").bg, force = true } }, + -- { provider = "%<" } + --), +--local cursor_location = { +-- { provider = "%7(%l:%c%) ", hl = { bold = true } }, +-- { +-- provider = " ", +-- hl = function(self) +-- local color = self:mode_color() +-- return { fg = color, bold = true } +-- end, +-- }, +--} + +local WordCount = { + condition = function() + return conditions.buffer_matches({ + filetype = { + "markdown", + "txt", + "vimwiki", + }, + }) + end, + Space, + { + provider = function() + return "W:" .. vim.fn.wordcount().words + end, + }, +} + +-- Working Directory +local WorkDir = { + provider = function(self) + self.icon = (vim.fn.haslocaldir(0) == 1 and "l" or "g") .. " " .. " " + local cwd = vim.fn.getcwd(0) + self.cwd = vim.fn.fnamemodify(cwd, ":~") + end, + hl = { fg = colors.blue, bold = true, bg = colors.bg }, + + utils.make_flexible_component(1, { + -- evaluates to the full-lenth path + provider = function(self) + local trail = self.cwd:sub(-1) == "/" and "" or "/" + return self.icon .. self.cwd .. trail .. " " + end, + }, { + -- evaluates to the shortened path + provider = function(self) + local cwd = vim.fn.pathshorten(self.cwd) + local trail = self.cwd:sub(-1) == "/" and "" or "/" + return self.icon .. cwd .. trail .. " " + end, + }, { + -- evaluates to "", hiding the component + provider = "", + }), +} + +-- Snippets Indicator +-- This requires ultisnips +--local Snippets = { +-- -- check that we are in insert or select mode +-- condition = function() +-- return vim.tbl_contains({'s', 'i'}, vim.fn.mode()) +-- end, +-- provider = function() +-- local forward = (vim.fn["UltiSnips#CanJumpForwards"]() == 1) and "" or "" +-- local backward = (vim.fn["UltiSnips#CanJumpBackwards"]() == 1) and " " or "" +-- return backward .. forward +-- end, +-- hl = { fg = "red", bold = true }, +--} + +-- let's add the children to our FileNameBlock component +FileNameBlock = utils.insert( + FileNameBlock, + FileIcon, + utils.insert(FileNameModifier, FileName), -- a new table where FileName is a child of FileNameModifier + unpack(FileFlags), -- A small optimisation, since their parent does nothing + { provider = "%<" } -- this means that the statusline is cut here when there's not enough space +) + +local FileInfoBlock = { + -- let's first set up some attributes needed by this component and it's children + init = function(self) + self.filename = vim.api.nvim_buf_get_name(0) + end, +} + +FileInfoBlock = utils.insert( + FileInfoBlock, + Space, + FileIcon, + FileType, + { provider = "%<" } -- this means that the statusline is cut here when there's not enough space +) + +--ViMode = utils.surround({ "", "" }, function(self) +-- return self:mode_color() +--end, { ViMode, hl = { fg = utils.get_highlight("statusline").bg, force = true } }) +--local mysurroundedcomponent = { +--{provider='', hl = {...}}, +--{<your component>}, +--{provider = '>>>', hl = {...}} +--} +LeftSpace = utils.surround({ "", " " }, function(self) + return self:mode_color() +end, { LeftSpace, hl = { fg = utils.get_highlight("statusline").bg, force = true } }) + +RightSpace = utils.surround( + { "", "" }, + colors.gray, + { RightSpace, hl = { bg = utils.get_highlight("statusline").bg, force = true } } +) + +RightSpace2 = utils.surround( + { "█", "" }, + colors.darkgray, + { RightSpace2, hl = { fg = colors.darkgray, force = true } } +) + +RightSpace3 = utils.surround( + { "█", "" }, + utils.get_highlight("statusline").bg, + { RightSpace3, hl = { fg = colors.darkgray, force = true } } +) + +LSPActive = utils.surround({ "", "" }, function(self) + return self:mode_color() +end, { Space, LSPActive, hl = { bg = colors.darkgray, force = true } }) + +FileInfoBlock = utils.surround({ "", "" }, function(self) + return self:mode_color() +end, { FileInfoBlock, Space, hl = { bg = colors.gray, force = true } }) + +Ruler = utils.surround({ "", "" }, colors.gray, { Ruler, hl = { fg = colors.gray, force = true } }) + +local left = { + { ViMode, hl = { fg = utils.get_highlight("statusline").bg, force = true } }, + --{ LeftSep, hl = function(self) + -- return { fg = self.mode_colors[self.mode], bg = utils.get_highlight("statusline").bg, bold = true, } + -- end, + --}, + { LeftSpace, hl = { bg = utils.get_highlight("statusline").bg, force = true } }, + { FileNameBlock, hl = { bg = utils.get_highlight("statusline").bg, force = true } }, + { Space, hl = { bg = utils.get_highlight("statusline").bg, force = true } }, + { Git, hl = { bg = utils.get_highlight("statusline").bg, force = true } }, +} +local middle = { + { Align, hl = { bg = utils.get_highlight("statusline").bg, force = true } }, + { Navic, hl = { bg = utils.get_highlight("statusline").bg, force = true } }, + { DAPMessages, hl = { bg = utils.get_highlight("statusline").bg, force = true } }, + { Align, hl = { bg = utils.get_highlight("statusline").bg, force = true } }, +} +local right = { + { Diagnostics, hl = { bg = utils.get_highlight("statusline").bg, force = true } }, + { + RightSpace3, + hl = { bg = colors.darkgray, force = true }, + }, + { LSPActive, hl = { bg = colors.darkgray, force = true } }, + { RightSpace2, hl = { bg = colors.gray, force = true } }, + { FileInfoBlock, hl = { bg = colors.gray, force = true } }, + { RightSpace, hl = { fg = colors.gray, force = true } }, + --{ cursor_location, hl = { fg = utils.get_highlight("statusline").bg, force = true } }, + { Ruler, hl = { fg = utils.get_highlight("statusline").bg, force = true } }, + --utils.make_flexible_component( + -- 3, + -- { Ruler, hl = { fg = utils.get_highlight("statusline").bg, force = true } }, + -- { provider = "%<" } + --), +} +--local Align = { provider = "%=", hl = { bg = colors.bg } } + +local sections = { left, middle, right } +local DefaultStatusline = { sections } +--LSPActive, Space, LSPMessages, Space, UltTest, Space, FileType, Space, Ruler, Space, ScrollBar + +local InactiveStatusline = { + condition = conditions.is_not_active, + { FileType, hl = { bg = utils.get_highlight("statusline").bg, force = true } }, + { Space, hl = { bg = utils.get_highlight("statusline").bg, force = true } }, + { FileName, hl = { bg = utils.get_highlight("statusline").bg, force = true } }, + { Align, hl = { bg = utils.get_highlight("statusline").bg, force = true } }, +} + +local SpecialStatusline = { + condition = function() + return conditions.buffer_matches({ + buftype = { "nofile", "prompt", "help", "quickfix" }, + filetype = { "^git.*", "fugitive" }, + }) + end, + + --FileType, + --Space, + --Align, + { ViMode, hl = { fg = utils.get_highlight("statusline").bg, force = true } }, + { LeftSpace, hl = { bg = utils.get_highlight("statusline").bg, force = true } }, + { FileType, hl = { bg = utils.get_highlight("statusline").bg, force = true } }, + { Space, hl = { bg = utils.get_highlight("statusline").bg, force = true } }, + { Align, hl = { bg = utils.get_highlight("statusline").bg, force = true } }, + { RightSpace, hl = { fg = utils.get_highlight("statusline").bg, force = true } }, + { Ruler, hl = { fg = utils.get_highlight("statusline").bg, force = true } }, +} + +local TerminalStatusline = { + + condition = function() + return conditions.buffer_matches({ buftype = { "terminal" } }) + end, + + --hl = { bg = colors.red }, + + -- Quickly add a condition to the ViMode to only show it when buffer is active! + --{ condition = conditions.is_active, ViMode, Space }, + { ViMode, hl = { fg = utils.get_highlight("statusline").bg, force = true } }, + { LeftSpace, hl = { bg = utils.get_highlight("statusline").bg, force = true } }, + { FileType, hl = { bg = utils.get_highlight("statusline").bg, force = true } }, + { Space, hl = { bg = utils.get_highlight("statusline").bg, force = true } }, + { Align, hl = { bg = utils.get_highlight("statusline").bg, force = true } }, + { RightSpace, hl = { fg = utils.get_highlight("statusline").bg, force = true } }, + { Ruler, hl = { fg = utils.get_highlight("statusline").bg, force = true } }, + --FileType, + --Space, + --TerminalName, + --Align, +} + +local StatusLine = { + + --hl = function() + -- if conditions.is_active() then + -- return "StatusLine" + -- else + -- return "StatusLineNC" + -- end + --end, + static = { + mode_colors = { + n = colors.blue, + i = colors.green, + v = colors.purple, + V = colors.purple, + ["\22"] = colors.purple, + c = colors.orange, + s = colors.purple, + S = colors.purple, + ["\19"] = colors.purple, + R = colors.red, + r = colors.red, + ["!"] = colors.orange, + t = colors.orange, + }, + mode_color = function(self) + local mode = conditions.is_active() and vim.fn.mode() or "n" + return self.mode_colors[mode] + end, + hl = function(self) + local color = self:mode_color() -- here! + return { bg = color } + end, + }, + fallthrough = false, + + SpecialStatusline, + TerminalStatusline, + InactiveStatusline, + DefaultStatusline, +} + + +-- +--- WinBar +-- +local WinbarFileNameBlock = { + -- let's first set up some attributes needed by this component and it's children + init = function(self) + self.filename = vim.api.nvim_buf_get_name(0) + end, + hl = { bg = colors.bg }, +} + +--local WinbarFileName = { +-- provider = function(self) +-- -- self.filename will be defined later, just keep looking at the example! +-- local filename = self.filename +-- filename = filename == "" and "No Name" or vim.fn.fnamemodify(filename, ":t") +-- return filename +-- end, +-- hl = function() +-- return { fg = colors.gray, italic = true } +-- end, +--} +local WinbarFileName = { + provider = function(self) + -- first, trim the pattern relative to the current directory. For other + -- options, see :h filename-modifers + local filename = vim.fn.fnamemodify(self.filename, ":.") + if filename == "" then + return "No Name" + end + -- now, if the filename would occupy more than 1/4th of the available + -- space, we trim the file path to its initials + -- See Flexible Components section below for dynamic truncation + if not conditions.width_percent_below(#filename, 0.25) then + filename = vim.fn.pathshorten(filename) + end + return filename + end, + --hl = { fg = utils.get_highlight("Statusline").fg, bold = false, bg = colors.bg }, + hl = { fg = colors.gray, bold = false, bg = colors.bg }, +} + +WinbarFileNameBlock = utils.insert( + WinbarFileNameBlock, + FileIcon, + utils.insert(WinbarFileName), -- a new table where FileName is a child of FileNameModifier + unpack(FileFlags), -- A small optimisation, since their parent does nothing + { provider = "%<" } -- this means that the statusline is cut here when there's not enough space +) + +vim.api.nvim_create_autocmd("User", { + pattern = "HeirlineInitWinbar", + callback = function(args) + local buf = args.buf + local buftype = vim.tbl_contains({ "prompt", "nofile", "help", "quickfix" }, vim.bo[buf].buftype) + local filetype = vim.tbl_contains({ "gitcommit", "fugitive" }, vim.bo[buf].filetype) + if buftype or filetype then + vim.opt_local.winbar = nil + end + end, +}) + +On_click = { + -- get the window id of the window in which the component was evaluated + minwid = function() + return vim.api.nvim_get_current_win() + end, + callback = function(_, minwid) + -- winid is the window id of the window the component was clicked from + local winid = minwid + -- do something with the window id, e.g.: + local buf = vim.api.nvim_win_get_buf(winid) + -- ... + end, +} + +local CloseButton = { + condition = function(self) + return not vim.bo.modified + end, + -- a small performance improvement: + -- re register the component callback only on layout/buffer changes. + update = { "WinNew", "WinClosed", "BufEnter" }, + { provider = " " }, + { + provider = "", + hl = { fg = "gray" }, + On_click = { + minwid = function() + return vim.api.nvim_get_current_win() + end, + callback = function(_, minwid) + vim.api.nvim_win_close(minwid, true) + end, + name = "heirline_winbar_close_button", + }, + }, +} + +local Center = { + fallthrough = false, + { -- Hide the winbar for special buffers + condition = function() + return conditions.buffer_matches({ + buftype = { "nofile", "prompt", "help", "quickfix" }, + filetype = { "^git.*", "fugitive" }, + }) + end, + init = function() + vim.opt_local.winbar = nil + end, + }, + { -- A special winbar for terminals + condition = function() + return conditions.buffer_matches({ buftype = { "terminal" } }) + end, + FileType, + Space, + --TerminalName, + }, + { -- An inactive winbar for regular files + condition = function() + return not conditions.is_active() + end, + --utils.surround({ "", "" }, colors.nobg, { FileIcon, { WinbarFileName, hl = { fg = colors.gray } }, FileFlags } ), + utils.surround({ "", "" }, colors.nobg, { WinbarFileNameBlock } ), + }, + -- A winbar for regular files + utils.surround({ "", "" }, colors.nobg, { FileNameBlock }), +} + +--local WinBar = { Align, Center, Align } +local WinBar = { Space, Center } + + +-- TabLine +local TablineBufnr = { + provider = function(self) + return tostring(self.bufnr) .. "." + end, + hl = { fg = colors.white, bold = false }, +} + +-- we redefine the filename component, as we probably only want the tail and not the relative path +local TablineFileName = { + provider = function(self) + -- self.filename will be defined later, just keep looking at the example! + local filename = self.filename + filename = filename == "" and "No Name" or vim.fn.fnamemodify(filename, ":t") + return filename + end, + hl = function(self) + return { fg = colors.white, bold = self.is_active or self.is_visible, italic = true } + end, +} + +local TablineFileFlags = { + { + provider = function(self) + if vim.bo[self.bufnr].modified then + return " [+] " + end + end, + hl = { fg = colors.green }, + }, + { + provider = function(self) + if not vim.bo[self.bufnr].modifiable or vim.bo[self.bufnr].readonly then + return " " + end + end, + hl = { fg = "orange" }, + }, +} + +local TablineFileIcon = { + init = function(self) + local filename = self.filename + local extension = vim.fn.fnamemodify(filename, ":e") + self.icon, self.icon_color = + require("nvim-web-devicons").get_icon_color(filename, extension, { default = true }) + end, + provider = function(self) + return self.icon and (" " .. self.icon .. " ") + end, + hl = function(self) + return { fg = self.icon_color } + end, +} + +-- Here the filename block finally comes together +local TablineFileNameBlock = { + init = function(self) + self.filename = vim.api.nvim_buf_get_name(self.bufnr) + end, + hl = function(self) + if self.is_active then + return "TabLineSel" + -- why not? + --elseif not vim.api.nvim_buf_is_loaded(self.bufnr) then + --return { fg = "gray", bg = colors.bg } + else + return "TabLineFill" + end + end, + on_click = { + callback = function(_, minwid, _, button) + if button == "m" then -- close on mouse middle click + vim.api.nvim_buf_delete(minwid, { force = false }) + else + vim.api.nvim_win_set_buf(0, minwid) + end + end, + minwid = function(self) + return self.bufnr + end, + name = "heirline_tabline_buffer_callback", + }, + TablineBufnr, + TablineFileIcon, + TablineFileName, + TablineFileFlags, +} + +-- a nice "x" button to close the buffer +local TablineCloseButton = { + condition = function(self) + return not vim.api.nvim_buf_get_option(self.bufnr, "modified") + end, + { provider = " " }, + { + provider = " ", + --hl = { fg = "red", bg = colors.bg }, + hl = { fg = colors.red }, + on_click = { + callback = function(_, minwid) + vim.api.nvim_buf_delete(minwid, { force = false }) + end, + minwid = function(self) + return self.bufnr + end, + name = "heirline_tabline_close_buffer_callback", + }, + }, +} + +-- The final touch! +local TablineBufferBlock = utils.surround({ "", "" }, function(self) + --local TablineBufferBlock = utils.surround({ "█", "█" }, function(self) + if self.is_active then + return utils.get_highlight("TabLineSel").bg + else + return utils.get_highlight("TabLineFill").bg + end +end, { Tab, TablineFileNameBlock, TablineCloseButton }) + +local BufferLine = utils.make_buflist( + TablineBufferBlock, + { provider = " ", hl = { fg = colors.white } }, -- left truncation, optional (defaults to "<") + { provider = " ", hl = { fg = colors.white } } -- right trunctation, also optional (defaults to ...... yep, ">") + -- by the way, open a lot of buffers and try clicking them ;) +) +-- TabList +local Tabpage = { + provider = function(self) + return "%" .. self.tabnr .. "T " .. self.tabnr .. " %T" + end, + hl = function(self) + if not self.is_active then + return "TabLineFill" + else + return "TabLineSel" + end + end, +} + +local TabpageClose = { + provider = "%999X %X", + --hl = "TabLine", + hl = { fg = colors.red, bg = colors.bg }, +} + +local TabPages = { + -- only show this component if there's 2 or more tabpages + condition = function() + return #vim.api.nvim_list_tabpages() >= 2 + end, + { + provider = "%=", + }, + utils.make_tablist(Tabpage), + TabpageClose, +} + +-- TabLineOffset +local TabLineOffset = { + condition = function(self) + local win = vim.api.nvim_tabpage_list_wins(0)[1] + local bufnr = vim.api.nvim_win_get_buf(win) + self.winid = win + + if vim.api.nvim_buf_get_option(bufnr, "filetype") == "NvimTree" then + self.title = "NvimTree" + return true + end + end, + + provider = function(self) + local title = self.title + local width = vim.api.nvim_win_get_width(self.winid) + local pad = math.ceil((width - #title) / 2) + return string.rep(" ", pad) .. title .. string.rep(" ", pad) + end, + + hl = function(self) + if vim.api.nvim_get_current_win() == self.winid then + return "TablineSel" + else + return "TablineFill" + end + end, +} + +local TabLine = { + TabLineOffset, + BufferLine, + TabPages, +} + +require("heirline").setup(StatusLine, WinBar, TabLine) + +-- Yep, with heirline we're driving manual! +--vim.cmd([[au FileType * if index(['wipe', 'delete', 'unload'], &bufhidden) >= 0 | set nobuflisted | endif]]) +-- +--local function get_bufs() +-- return vim.tbl_filter(function(bufnr) +-- return vim.api.nvim_buf_is_loaded(bufnr) and vim.bo[bufnr].buflisted +-- end, vim.api.nvim_list_bufs()) +--end +-- +--local function goto_buf(index) +-- local bufs = get_bufs() +-- if index > #bufs then +-- index = #bufs +-- end +-- vim.api.nvim_win_set_buf(0, bufs[index]) +--end +-- +--local function addKey(key, index) +-- vim.keymap.set("", "<A-" .. key .. ">", function() +-- goto_buf(index) +-- end, { noremap = true, silent = true }) +--end +-- +--for i = 1, 9 do +-- addKey(i, i) +--end +--addKey("0", 10) diff --git a/lua/plugins/linecolor.lua b/lua/plugins/linecolor.lua new file mode 100644 index 0000000..37550dd --- /dev/null +++ b/lua/plugins/linecolor.lua @@ -0,0 +1,112 @@ +--local M = {} +--M.theme = function() +-- -- I know I could just set bg = nil but I'm leaving this here in case I want custom colors in the future +-- local colors = { +-- nobg = nil, +-- blue = "#87b0f9", +-- mauve = "#cba6f7", +-- red = "#f38ba8", +-- green = "#a6e3a1", +-- peach = "#fab387", +-- white = "#c6d0f5", +-- gray = "#a1a8c9", +-- black = "#1e1e2e", +-- } +-- return { +-- inactive = { +-- a = { fg = colors.blue, bg = colors.nobg, gui = "bold" }, +-- b = { fg = colors.white, bg = colors.black }, +-- c = { fg = colors.gray, bg = colors.nobg }, +-- }, +-- visual = { +-- a = { fg = colors.black, bg = colors.mauve, gui = "bold" }, +-- b = { fg = colors.mauve, bg = colors.nobg }, +-- c = { fg = colors.white, bg = colors.nobg }, +-- }, +-- replace = { +-- a = { fg = colors.black, bg = colors.red, gui = "bold" }, +-- b = { fg = colors.red, bg = colors.nobg }, +-- c = { fg = colors.white, bg = colors.nobg }, +-- }, +-- normal = { +-- a = { fg = colors.black, bg = colors.blue, gui = "bold" }, +-- b = { fg = colors.black, bg = colors.green }, +-- c = { fg = colors.white, bg = colors.black }, +-- }, +-- insert = { +-- a = { fg = colors.black, bg = colors.green, gui = "bold" }, +-- b = { fg = colors.teal, bg = colors.nobg }, +-- c = { fg = colors.white, bg = colors.nobg }, +-- }, +-- command = { +-- a = { fg = colors.black, bg = colors.peach, gui = "bold" }, +-- b = { fg = colors.peach, bg = colors.nobg }, +-- c = { fg = colors.white, bg = colors.nobg }, +-- }, +-- modified = { +-- a = { fg = colors.black, bg = colors.peach, gui = "bold" }, +-- b = { fg = colors.peach, bg = colors.peach }, +-- c = { fg = colors.white, bg = colors.peach }, +-- }, +-- } +--end +--return M +local M = {} +M.theme = function() + --local colors = { + -- darkgray = "#16161d", + -- gray = "#727169", + -- innerbg = nil, + -- outerbg = "#16161D", + -- normal = "#7e9cd8", + -- insert = "#98bb6c", + -- visual = "#ffa066", + -- replace = "#e46876", + -- command = "#e6c384", + --} + local colors = { + darkgray = "#16161d", + gray = "#727169", + innerbg = nil, + outerbg = "#16161D", + normal = "#39BAE6", + insert = "#AAD94C", + visual = "#FA8D3F", + replace = "#F07171", + command = "#F2AE49", + } + return { + inactive = { + a = { fg = colors.gray, bg = colors.outerbg, gui = "bold" }, + b = { fg = colors.gray, bg = colors.outerbg }, + c = { fg = colors.gray, bg = colors.innerbg }, + }, + visual = { + a = { fg = colors.darkgray, bg = colors.visual, gui = "bold" }, + b = { fg = colors.gray, bg = colors.outerbg }, + c = { fg = colors.gray, bg = colors.innerbg }, + }, + replace = { + a = { fg = colors.darkgray, bg = colors.replace, gui = "bold" }, + b = { fg = colors.gray, bg = colors.outerbg }, + c = { fg = colors.gray, bg = colors.innerbg }, + }, + normal = { + a = { fg = colors.darkgray, bg = colors.normal, gui = "bold" }, + b = { fg = colors.gray, bg = colors.outerbg }, + c = { fg = colors.gray, bg = colors.innerbg }, + y = { fg = colors.gray, bg = colors.outerbg }, + }, + insert = { + a = { fg = colors.darkgray, bg = colors.insert, gui = "bold" }, + b = { fg = colors.gray, bg = colors.outerbg }, + c = { fg = colors.gray, bg = colors.innerbg }, + }, + command = { + a = { fg = colors.darkgray, bg = colors.command, gui = "bold" }, + b = { fg = colors.gray, bg = colors.outerbg }, + c = { fg = colors.gray, bg = colors.innerbg }, + }, + } +end +return M diff --git a/lua/plugins/lsp-colors.lua b/lua/plugins/lsp-colors.lua new file mode 100644 index 0000000..1398123 --- /dev/null +++ b/lua/plugins/lsp-colors.lua @@ -0,0 +1,9 @@ +local status, colors = pcall(require, "lsp-colors") +if (not status) then return end + +colors.setup { + Error = "#db4b4b", + Warning = "#e0af68", + Information = "#0db9d7", + Hint = "#10B981" +} diff --git a/lua/plugins/lsp.lua b/lua/plugins/lsp.lua new file mode 100644 index 0000000..f39cc58 --- /dev/null +++ b/lua/plugins/lsp.lua @@ -0,0 +1,598 @@ + +local fn = vim.fn +local keymap = vim.keymap + +local utils = require("user.utils") + +local custom_attach = function(client, bufnr) + -- Enable completion triggered by <c-x><c-o> + vim.api.nvim_buf_set_option(bufnr, 'omnifunc', 'v:lua.vim.lsp.omnifunc') + + -- Mappings. + local map = function(mode, l, r, opts) + opts = opts or {} + opts.silent = true + opts.noremap = true + opts.buffer = bufnr + keymap.set(mode, l, r, opts) + end +--map("n", "gd", "<Cmd>Lspsaga lsp_finder<CR>") -- Press "o" to open the reference location +--map("n", "gp", "<Cmd>Lspsaga peek_definition<CR>") +-- --map("n", "gd", vim.lsp.buf.definition, { desc = "go to definition" }) + map("n", "<C-]>", vim.lsp.buf.definition) +-- map("n", "K", vim.lsp.buf.hover) +-- map("n", "<C-k>", vim.lsp.buf.signature_help) +-- map("n", "<leader>rn", vim.lsp.buf.rename, { desc = "varialble rename" }) +-- map("n", "gr", vim.lsp.buf.references, { desc = "show references" }) +-- map("n", "[d", vim.diagnostic.goto_prev, { desc = "previous diagnostic" }) +-- map("n", "]d", vim.diagnostic.goto_next, { desc = "next diagnostic" }) + map("n", "<leader>q", function() + vim.diagnostic.setqflist({ open = true }) + end, { desc = "put diagnostic to qf" }) +-- --map.('n', '<space>q', vim.diagnostic.setloclist) +-- map("n", "ga", vim.lsp.buf.code_action, { desc = "LSP code action" }) +-- map("n", "<leader>wa", vim.lsp.buf.add_workspace_folder, { desc = "add workspace folder" }) +-- map("n", "<leader>wr", vim.lsp.buf.remove_workspace_folder, { desc = "remove workspace folder" }) +-- map("n", "<leader>wl", function() +-- print(vim.inspect(vim.lsp.buf.list_workspace_folders())) +-- end, { desc = "list workspace folder" }) +-- map("n", "gs", "vim.lsp.buf.document_symbol()<cr>") +-- map("n", "gw", "vim.lsp.buf.workspace_symbol()<cr>", { desc = "list workspace folder" }) +-- --map("n", "gs", ":lua vim.lsp.buf.document_symbol()<cr>") +-- map("n", "gt", ":lua vim.lsp.buf.type_definition()<cr>") +-- map("n", "gD", ":lua vim.lsp.buf.declaration()<cr>") -- most lsp servers don't implement textDocument/Declaration, so gD is useless for now. +-- map("n", "gi", ":lua vim.lsp.buf.implementation()<cr>") + map("n", "go", ":lua vim.diagnostic.open_float()<cr>") +-- map("n", "gk", "<Cmd>Lspsaga diagnostic_jump_prev<CR>") +-- map("n", "gj", "<Cmd>Lspsaga diagnostic_jump_next<CR>") +--vim.api.nvim_set_keymap('n', '<leader>dd', '<cmd>lua vim.diagnostic.setloclist()<CR>', { noremap = true, silent = true }) + --nnoremap("gI", vim.lsp.buf.incoming_calls, opts) + -- + --nnoremap("<leader>cs", vim.lsp.buf.document_symbol, opts) + --nnoremap("<leader>cw", vim.lsp.buf.workspace_symbol, opts) + --nnoremap("<leader>rf", vim.lsp.buf.formatting, opts) + --require("which-key").register { + -- ["<leader>rf"] = "lsp: format buffer", + -- ["<leader>ca"] = "lsp: code action", + -- ["<leader>gd"] = "lsp: go to type definition", + -- ["gr"] = "lsp: references", + -- ["gi"] = "lsp: implementation", + -- ["gI"] = "lsp: incoming calls", + --} +--end +vim.g.diagnostics_visible = true +function _G.toggle_diagnostics() + if vim.g.diagnostics_visible then + vim.g.diagnostics_visible = false + vim.diagnostic.disable() + else + vim.g.diagnostics_visible = true + vim.diagnostic.enable() + end +end +map('n', '<Leader>m', ':call v:lua.toggle_diagnostics()<CR>') +--vim.g.diagnostics_active = true +--function _G.toggle_diagnostics() +-- if vim.g.diagnostics_active then +-- vim.g.diagnostics_active = false +-- vim.lsp.diagnostic.clear(0) +-- vim.cmd([[exe "normal ii\<Esc>x"]]) +-- vim.lsp.handlers["textDocument/publishDiagnostics"] = function() end +-- else +-- vim.g.diagnostics_active = true +-- vim.lsp.handlers["textDocument/publishDiagnostics"] = vim.lsp.with( +-- vim.lsp.diagnostic.on_publish_diagnostics, { +-- virtual_text = true, +-- signs = true, +-- underline = true, +-- update_in_insert = false, +-- } +-- ) +-- end +--end +-- +--map("n", "<leader>i", ":call v:lua.toggle_diagnostics()<CR>") + + + -- Set some key bindings conditional on server capabilities + if client.server_capabilities.documentFormattingProvider then + map("n", "<space>f", vim.lsp.buf.format, { desc = "format code" }) + end + + -- add rust specific keymappings + if client.name == "rust_analyzer" then + map("n", "<leader>rr", "<cmd>RustRunnables<CR>") + map("n", "<leader>ra", "<cmd>RustHoverAction<CR>") + end + +--For diagnostics for specific cursor position +--vim.api.nvim_create_autocmd("CursorHold", { +-- buffer = bufnr, +-- callback = function() +-- local opts = { +-- focusable = false, +-- close_events = { "BufLeave", "CursorMoved", "InsertEnter", "FocusLost" }, +-- border = 'rounded', +-- source = 'always', +-- prefix = ' ', +-- scope = 'cursor', +-- } +-- vim.diagnostic.open_float(nil, opts) +-- end +--}) + -- Diagnostic position +-- vim.api.nvim_create_autocmd("CursorHold", { +-- buffer = bufnr, +-- callback = function() +-- local float_opts = { +-- focusable = false, +-- close_events = { "BufLeave", "CursorMoved", "InsertEnter", "FocusLost" }, +-- border = "rounded", +-- source = "always", -- show source in diagnostic popup window +-- prefix = " ", +-- } +-- +-- if not vim.b.diagnostics_pos then +-- vim.b.diagnostics_pos = { nil, nil } +-- end +-- +-- local cursor_pos = vim.api.nvim_win_get_cursor(0) +-- if +-- (cursor_pos[1] ~= vim.b.diagnostics_pos[1] or cursor_pos[2] ~= vim.b.diagnostics_pos[2]) +-- and #vim.diagnostic.get() > 0 +-- then +-- vim.diagnostic.open_float(nil, float_opts) +-- end +-- +-- vim.b.diagnostics_pos = cursor_pos +-- end, +-- }) + + -- The below command will highlight the current variable and its usages in the buffer. + if client.server_capabilities.documentHighlightProvider then + vim.cmd([[ + hi! link LspReferenceRead Visual + hi! link LspReferenceText Visual + hi! link LspReferenceWrite Visual + augroup lsp_document_highlight + autocmd! * <buffer> + autocmd CursorHold <buffer> lua vim.lsp.buf.document_highlight() + autocmd CursorMoved <buffer> lua vim.lsp.buf.clear_references() + augroup END + ]]) + end + + if vim.g.logging_level == "debug" then + local msg = string.format("Language server %s started!", client.name) + vim.notify(msg, vim.log.levels.DEBUG, { title = "Server?" }) + end +end + +local capabilities = vim.lsp.protocol.make_client_capabilities() +capabilities = require("cmp_nvim_lsp").default_capabilities(capabilities) +capabilities.textDocument.completion.completionItem.snippetSupport = true +capabilities.offsetEncoding = { "utf-16" } + +local lspconfig = require("lspconfig") + +if utils.executable("pylsp") then + lspconfig.pylsp.setup({ + settings = { + pylsp = { + plugins = { + pylint = { enabled = true, executable = "pylint" }, + pyflakes = { enabled = false }, + pycodestyle = { enabled = false }, + jedi_completion = { fuzzy = true }, + pyls_isort = { enabled = true }, + pylsp_mypy = { enabled = true }, + }, + }, + }, + flags = { + debounce_text_changes = 200, + }, + capabilities = capabilities, + }) +else + vim.notify("pylsp not found!", vim.log.levels.WARN, { title = "Server?" }) +end + +-- if utils.executable('pyright') then +-- lspconfig.pyright.setup{ +-- on_attach = custom_attach, +-- capabilities = capabilities +-- } +-- else +-- vim.notify("pyright not found!", vim.log.levels.WARN, {title = 'Server?'}) +-- end + +if utils.executable("clangd") then + lspconfig.clangd.setup({ + on_attach = custom_attach, + capabilities = capabilities, + filetypes = { "c", "cpp", "cc" }, + flags = { + debounce_text_changes = 500, + }, + }) +else + vim.notify("clangd not found!", vim.log.levels.WARN, { title = "Server?" }) +end + +-- set up vim-language-server +if utils.executable("vim-language-server") then + lspconfig.vimls.setup({ + on_attach = custom_attach, + flags = { + debounce_text_changes = 500, + }, + capabilities = capabilities, + }) +else + vim.notify("vim-language-server not found!", vim.log.levels.WARN, { title = "Server?" }) +end + +-- set up bash-language-server +if utils.executable("bash-language-server") then + lspconfig.bashls.setup({ + on_attach = custom_attach, + capabilities = capabilities, + }) +end + +if utils.executable("lua-language-server") then + lspconfig.sumneko_lua.setup({ + on_attach = custom_attach, + settings = { + Lua = { + runtime = { + -- Tell the language server which version of Lua you're using (most likely LuaJIT in the case of Neovim) + version = "LuaJIT", + }, + diagnostics = { + -- Get the language server to recognize the `vim` global + globals = { "vim" }, + }, + workspace = { + -- Make the server aware of Neovim runtime files, + library = { + fn.stdpath("data") .. "/site/pack/packer/opt/emmylua-nvim", + fn.stdpath("config"), + }, + maxPreload = 2000, + preloadFileSize = 50000, + }, + }, + }, + capabilities = capabilities, + }) +end + + +if utils.executable("rust-language-server") then +require("lspconfig").rust_analyzer.setup{ + cmd = { "rustup", "run", "nightly", "rust-analyzer" }, + on_attach = custom_attach, + flags = { + debounce_text_changes = 500, + }, + --[[ + settings = { + rust = { + unstable_features = true, + build_on_save = false, + all_features = true, + }, + } + --]] +} +end + +--vim.diagnostic.config({ +-- virtual_text = false, +-- underline = true, +--}) +vim.diagnostic.config({ + underline = false, + signs = true, + virtual_text = false, + float = { + show_header = true, + source = 'if_many', + border = 'rounded', + focusable = false, + }, + update_in_insert = false, -- default to false + severity_sort = false, -- default to false +}) +-- Show line diagnostics automatically in hover window +--vim.o.updatetime = 250 +--vim.cmd [[autocmd CursorHold,CursorHoldI * lua vim.diagnostic.open_float(nil, {focusable = false,})]] +--vim.cmd ([[ noremap <leader>a :autocmd! CursorHold,CursorHoldI <CR>]]) + +--vim.cmd [[ noremap <leader>a :autocmd! CursorHold,CursorHoldI * lua vim.diagnostic.open_float(nil, {focusable = false,})<CR>]] +--local diagnostics_active = true +--local toggle_diagnostics = function() +-- diagnostics_active = not diagnostics_active +-- if diagnostics_active then +-- vim.o.updatetime = 250 +-- vim.cmd ([[autocmd! CursorHold,CursorHoldI <CR>]]) +-- --vim.diagnostic.open_float(nil, {focus=false}) +-- else +-- vim.o.updatetime = 250 +-- vim.cmd [[autocmd CursorHold,CursorHoldI * lua vim.diagnostic.open_float(nil, {focus=false})]] +-- --vim.diagnostic.hide() +-- --vim.diagnostic.disable() +-- end +--end +--vim.keymap.set("n", "<leader>a", toggle_diagnostics) + +--function LspDiagnosticsFocus() +-- vim.api.nvim_command('set eventignore=WinLeave') +-- vim.api.nvim_command('autocmd CursorMoved <buffer> ++once set eventignore=""') +-- vim.diagnostic.open_float(nil, {focusable = false, scope = 'line', close_events = {"CursorMoved", "CursorMovedI", "BufHidden", "InsertCharPre", "WinLeave"}}) +--end +--vim.api.nvim_set_keymap('', '<Leader>a', '<Cmd>lua LspDiagnosticsFocus()<CR>', {silent = true}) + --vim.o.updatetime = 250 + +-- vim.o.updatetime = 250 +----vim.o.updatetime = 250 +----vim.cmd [[autocmd CursorHold,CursorHoldI * lua vim.diagnostic.open_float(nil, {focusable = false,})]] +----local diagnostics_active = true +--local toggle_diagnostics = function() +-- --diagnostics_active = not diagnostics_active +-- --if diagnostics_active then +-- --if vim.diagnostic.open_float() == true then +-- if vim.api.nvim_exec([[autocmd CursorHold,CursorHoldI * lua vim.diagnostic.open_float(nil, {focus=false})]] +--, true) then +-- vim.api.nvim_exec([[autocmd! CursorHold,CursorHoldI ]] +--, true) +-- else +-- vim.o.updatetime = 250 +-- vim.api.nvim_exec([[autocmd CursorHold,CursorHoldI * lua vim.diagnostic.open_float(nil, {focus=false})]], true) +-- end +--end +--vim.keymap.set("n", "<leader>a", toggle_diagnostics) +-- +--vim.api.nvim_create_autocmd('CursorHold', { +-- vim.diagnostic.open_float(nil, {focus=false}) +-- +--}) + +vim.o.updatetime = 250 +vim.cmd[[ +augroup OpenFloat + autocmd CursorHold,CursorHoldI * lua vim.diagnostic.open_float(nil, {focusable = false,}) + +augroup END +]] +vim.cmd([[ +function! ToggleDiagnosticsOpenFloat() + " Switch the toggle variable + let g:DiagnosticsOpenFloat = !get(g:, 'DiagnosticsOpenFloat', 1) + + " Reset group + augroup OpenFloat + autocmd! + augroup END + + " Enable if toggled on + if g:DiagnosticsOpenFloat + augroup OpenFloat + autocmd! CursorHold,CursorHoldI * lua vim.diagnostic.open_float(nil, {focusable = false,}) print ("vim.diagnostic.open_float enabled . . .") + augroup END + endif +endfunction +nnoremap <leader>a :call ToggleDiagnosticsOpenFloat()<CR>\|:echom "vim.diagnostic.open_float disabled . . ."<CR> +]]) + +--vim.lsp.handlers["textDocument/hover"] = vim.lsp.with( +-- vim.lsp.handlers.hover, { +-- signs = true, +-- underline = false, +-- virtual_text = false, +-- show_diagnostic_autocmds = {'InsertLeave', 'TextChanged'}, +-- diagnostic_delay = 500 +-- }) +--vim.cmd [[autocmd CursorHold * lua vim.diagnostic.open_float(0, {scope="cursor", close_events = {"CursorMoved", "CursorMovedI", "BufHidden", "InsertCharPre", "WinLeave"}})]] + +--function LspDiagnosticsFocus() +-- vim.api.nvim_command('set eventignore=WinLeave') +-- vim.api.nvim_command('autocmd CursorMoved <buffer> ++once set eventignore=""') +-- vim.diagnostic.open_float(nil, {focusable = false, scope = 'line', close_events = {"CursorMoved", "CursorMovedI", "BufHidden", "InsertCharPre", "WinLeave"}}) +--end +--vim.api.nvim_set_keymap('', '<Leader>a', '<Cmd>lua LspDiagnosticsFocus()<CR>', {silent = true}) + +--local diagnostics_active = true +--map('n', '<leader>a', function() +-- diagnostics_active = not diagnostics_active +-- if diagnostics_active then +-- vim.diagnostic.show() +-- else +-- vim.diagnostic.hide() +-- end +--end) + +-- Global config for diagnostic +--vim.diagnostic.config({ +-- underline = false, +-- virtual_text = false, +-- signs = true, +-- severity_sort = true, +-- float = { +-- focusable = true, -- +-- style = "minimal", -- +-- --border = "rounded", +-- border = "shadow", +-- source = "always", +-- header = "", +-- prefix = "", +-- }, +--}) + +vim.lsp.handlers["textDocument/publishDiagnostics"] = vim.lsp.with(vim.lsp.diagnostic.on_publish_diagnostics, { + underline = true, + virtual_text = false, + signs = true, + update_in_insert = false, +}) + +--vim.lsp.buf.definition +vim.lsp.handlers["textDocument/hover"] = vim.lsp.with(vim.lsp.handlers.hover, { border = "rounded" }) + +--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" }) + +--local signs = { Error = " ", Warn = " ", Info = " ", Hint = " " } +--local signs = { Error = "✘", Warn = "▲", Info = "🛈 ", Hint = "⚑" } +local signs = { Error = "✘", Warn = "▲", Info = "", Hint = "⚑" } +for type, icon in pairs(signs) do + local hl = "DiagnosticSign" .. type + vim.fn.sign_define(hl, { text = icon, texthl = hl, numhl = "" }) +end + + +---- Location information about the last message printed. The format is +---- `(did print, buffer number, line number)`. +--local last_echo = { false, -1, -1 } +-- +---- The timer used for displaying a diagnostic in the commandline. +--local echo_timer = nil +-- +---- The timer after which to display a diagnostic in the commandline. +--local echo_timeout = 250 +-- +---- The highlight group to use for warning messages. +--local warning_hlgroup = 'WarningMsg' +-- +---- The highlight group to use for error messages. +--local error_hlgroup = 'ErrorMsg' +-- +---- If the first diagnostic line has fewer than this many characters, also add +---- the second line to it. +--local short_line_limit = 20 +-- +---- Shows the current line's diagnostics in a floating window. +--function show_line_diagnostics() +-- vim +-- .lsp +-- .diagnostic +-- .show_line_diagnostics({ severity_limit = 'Warning' }, vim.fn.bufnr('')) +--end +-- +---- Prints the first diagnostic for the current line. +--function echo_diagnostic() +-- if echo_timer then +-- echo_timer:stop() +-- end +-- +-- echo_timer = vim.defer_fn( +-- function() +-- local line = vim.fn.line('.') - 1 +-- local bufnr = vim.api.nvim_win_get_buf(0) +-- +-- if last_echo[1] and last_echo[2] == bufnr and last_echo[3] == line then +-- return +-- end +-- +-- local diags = vim +-- .lsp +-- .diagnostic +-- .get_line_diagnostics(bufnr, line, { severity_limit = 'Warning' }) +-- +-- if #diags == 0 then +-- -- If we previously echo'd a message, clear it out by echoing an empty +-- -- message. +-- if last_echo[1] then +-- last_echo = { false, -1, -1 } +-- +-- vim.api.nvim_command('echo ""') +-- end +-- +-- return +-- end +-- +-- last_echo = { true, bufnr, line } +-- +-- local diag = diags[1] +-- local width = vim.api.nvim_get_option('columns') - 15 +-- local lines = vim.split(diag.message, "\n") +-- local message = lines[1] +-- local trimmed = false +-- +-- if #lines > 1 and #message <= short_line_limit then +-- message = message .. ' ' .. lines[2] +-- end +-- +-- if width > 0 and #message >= width then +-- message = message:sub(1, width) .. '...' +-- end +-- +-- local kind = 'warning' +-- local hlgroup = warning_hlgroup +-- +-- if diag.severity == vim.lsp.protocol.DiagnosticSeverity.Error then +-- kind = 'error' +-- hlgroup = error_hlgroup +-- end +-- +-- local chunks = { +-- { kind .. ': ', hlgroup }, +-- { message } +-- } +-- +-- vim.api.nvim_echo(chunks, false, {}) +-- end, +-- echo_timeout +-- ) +--end +--vim.cmd([[ +-- autocmd CursorMoved * :lua echo_diagnostic() +--]]) +-- Highlight line number instead of having icons in sign column + +-- See the properties of the signs with sign list. + +--vim.cmd [[ +-- highlight! DiagnosticLineNrError guibg=#51202A guifg=#FF0000 gui=bold +-- highlight! DiagnosticLineNrWarn guibg=#51412A guifg=#FFA500 gui=bold +-- highlight! DiagnosticLineNrInfo guibg=#1E535D guifg=#00FFFF gui=bold +-- highlight! DiagnosticLineNrHint guibg=#1E205D guifg=#0000FF gui=bold +-- +-- sign define DiagnosticSignError text= texthl=DiagnosticSignError linehl= numhl=DiagnosticLineNrError +-- sign define DiagnosticSignWarn text= texthl=DiagnosticSignWarn linehl= numhl=DiagnosticLineNrWarn +-- sign define DiagnosticSignInfo text= texthl=DiagnosticSignInfo linehl= numhl=DiagnosticLineNrInfo +-- sign define DiagnosticSignHint text= texthl=DiagnosticSignHint linehl= numhl=DiagnosticLineNrHint +--]] + +-- Highlight symbol under cursor + +-- Add the following to your on_attach (this allows checking server capabilities to avoid calling invalid commands. + +--if client.resolved_capabilities.document_highlight then +-- vim.cmd [[ +-- hi! LspReferenceRead cterm=bold ctermbg=red guibg=LightYellow +-- hi! LspReferenceText cterm=bold ctermbg=red guibg=LightYellow +-- hi! LspReferenceWrite cterm=bold ctermbg=red guibg=LightYellow +-- ]] +-- vim.api.nvim_create_augroup('lsp_document_highlight', { +-- clear = false +-- }) +-- vim.api.nvim_clear_autocmds({ +-- buffer = bufnr, +-- group = 'lsp_document_highlight', +-- }) +-- vim.api.nvim_create_autocmd({ 'CursorHold', 'CursorHoldI' }, { +-- group = 'lsp_document_highlight', +-- buffer = bufnr, +-- callback = vim.lsp.buf.document_highlight, +-- }) +-- vim.api.nvim_create_autocmd('CursorMoved', { +-- group = 'lsp_document_highlight', +-- buffer = bufnr, +-- callback = vim.lsp.buf.clear_references, +-- }) +--end + diff --git a/lua/plugins/lspkind.lua b/lua/plugins/lspkind.lua new file mode 100644 index 0000000..72ca5c2 --- /dev/null +++ b/lua/plugins/lspkind.lua @@ -0,0 +1,47 @@ +local status, lspkind = pcall(require, "lspkind") +if (not status) then return end + +lspkind.init({ + -- enables text annotations + -- + -- default: true + mode = 'symbol', + + -- default symbol map + -- can be either 'default' (requires nerd-fonts font) or + -- 'codicons' for codicon preset (requires vscode-codicons font) + -- + -- default: 'default' + preset = 'codicons', + + -- override preset symbols + -- + -- default: {} + symbol_map = { + 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 = "" + }, +}) diff --git a/lua/plugins/lspsaga-22.10.23-13:08-bak.lua b/lua/plugins/lspsaga-22.10.23-13:08-bak.lua new file mode 100644 index 0000000..0bf1ec7 --- /dev/null +++ b/lua/plugins/lspsaga-22.10.23-13:08-bak.lua @@ -0,0 +1,145 @@ +require "lspsaga".init_lsp_saga { + -- "single" | "double" | "rounded" | "bold" | "plus" + border_style = "rounded", + --border_style = "single", + saga_winblend = 30, + move_in_saga = { next = '<C-n>', prev = '<C-p>' }, + --move_in_saga = { prev = "k", next = "j" }, + scroll_in_preview = { + scroll_down = "<C-d>", + scroll_up = "<C-u>", + }, + diagnostic_header = { " ", " ", " ", " " }, + -- add bracket or something with diagnostic source, just have 2 elements + -- use emoji lightbulb in default + code_action_icon = "", + --code_action_icon = "ﯦ ", + -- if true can press number to execute the codeaction in codeaction window + code_action_num_shortcut = true, + -- same as nvim-lightbulb but async + code_action_lightbulb = { + enable = false, + sign = false, + sign_priority = 20, -- + virtual_text = false, + }, + finder_icons = { + def = " ", + ref = " ", + link = " ", + }, + -- preview lines of lsp_finder and definition preview + max_preview_lines = 5, + definition_action_keys = { + edit = '<CR>', + vsplit = '<C-y>', + split = '<C-x>', + tabe = '<C-t>', + quit = '<ESC>', + }, + -- definition_preview_quit = '<ESC>', + -- finder_preview_hl_ns = 8, + finder_action_keys = { + open = { 'o', '<CR>' }, + vsplit = "v", + split = "s", + tabe = "t", + quit = "<ESC>", + scroll_down = "<C-j>", + scroll_up = "<C-k>", -- quit can be a table + }, + code_action_keys = { + quit = "<ESC>", + exec = "<CR>", + }, + rename_action_quit = "<ESC>", + rename_in_select = true, + symbol_in_winbar = { + enable = true, + --in_custom = false, + in_custom = true, + separator = ' ', + --show_file = false, + show_file = true, + click_support = false, + --click_support = false, + }, + --show_outline = { + -- win_position = 'right', + -- --set special filetype win that outline window split.like NvimTree neotree + -- -- defx, db_ui + -- min_with = '', + -- win_width = 40, + -- auto_enter = false, + -- auto_preview = true, + -- virt_text = 'x', + -- jump_key = 'l', + -- -- auto refresh when change buffer + -- auto_refresh = true, + --}, + custom_kind = { + File = { " " }, + Module = { " " }, + Namespace = { "ﱕ " }, + Package = { " " }, + Class = { "ﴯ " }, + Method = { "" }, + Property = { "ﰠ " }, + Field = { "ﰠ " }, + Constructor = { " " }, + Enum = { " " }, + Interface = { " " }, + Function = { " " }, + Variable = { " " }, + Constant = { " " }, + String = { " " }, + Number = { " " }, + Boolean = { " " }, + Array = { " " }, + Object = { " " }, + Key = { "- " }, + Null = { " " }, + EnumMember = { " " }, + Struct = { " " }, + Event = { " " }, + Operator = { " " }, + TypeParameter = { " " }, + TypeAlias = { " " }, + Parameter = { " " }, + StaticMethod = { " " }, + Macro = { "廓" }, + }, +} + + -- Mappings. +local map = vim.api.nvim_set_keymap +local opts = { noremap = true, silent = true } + +map("n", "gd", "<CMD>Lspsaga peek_definition<CR>", opts) +--map("n", "gp", "<Cmd>Lspsaga peek_definition<CR>", opts) +map("n", "gi", "<CMD>Lspsaga lsp_finder<CR>", opts) +map("n", "gh", "<CMD>Lspsaga hover_doc<CR>", opts) +map("n", "gs", "<CMD>Lspsaga signature_help<CR>", opts) +map("n", "ga", "<CMD>Lspsaga code_action<CR>", opts) +map("v", "ga", "<CMD><C-u>Lspsaga range_code_action<CR>", opts) +map("n", "gl", "<CMD>Lspsaga show_line_diagnostics<CR>", opts) +--map("n", "go", "<CMD>Lspsaga open_floaterm zsh<CR>", opts) +map("n", ";D", "<CMD>Lspsaga show_cursor_diagnostics<CR>", opts) +map("n", "<gr>", "<CMD>Lspsaga rename<CR>", opts) +map("n", "gk", "<CMD>Lspsaga diagnostic_jump_prev<CR>", opts) +map("n", "gj", "<CMD>Lspsaga diagnostic_jump_next<CR>", opts) +map("n", "[d", "<Cmd>lua vim.lsp.diagnostic.goto_prev()<CR>", opts) +map("n", "]d", "<Cmd>lua vim.lsp.diagnostic.goto_next()<CR>", opts) +map("t", "<ESC>", "<CMD>Lspsaga close_floaterm<CR>", opts) + +--vim.api.nvim_command("highlight LspFloatWinNormal guibg=none ") +--hi LspFloatWinNormal guibg=none + + +-- vim.api.nvim_create_autocmd("BufEnter", { +-- callback = function () +-- if #vim.api.nvim_list_wins() == 1 and vim.bo.filetype == "lspsagaoutline" then +-- vim.cmd "quit" +-- end +-- end +-- }) diff --git a/lua/plugins/lspsaga.lua b/lua/plugins/lspsaga.lua new file mode 100644 index 0000000..4161ce9 --- /dev/null +++ b/lua/plugins/lspsaga.lua @@ -0,0 +1,46 @@ +return function() + local saga = require "lspsaga" + + saga.init_lsp_saga { + use_saga_diagnostic_sign = false, + finder_action_keys = { + vsplit = "v", + split = "s", + quit = { "q", "<ESC>" }, + }, + code_action_icon = "💡", + code_action_prompt = { + enable = false, + sign = false, + virtual_text = false, + }, + } + + require("as.highlights").highlight("LspSagaLightbulb", { guifg = "NONE", guibg = "NONE" }) + +-- as.vnoremap("<leader>ca", ":<c-u>lua require('lspsaga.codeaction').range_code_action()<CR>") +-- as.inoremap("<c-k>", "<cmd>lua require('lspsaga.signaturehelp').signature_help()<CR>") +-- as.nnoremap("K", "<cmd>lua require('lspsaga.hover').render_hover_doc()<CR>") +-- -- scroll down hover doc +-- as.nnoremap("<C-f>", "<cmd>lua require('lspsaga.action').smart_scroll_with_saga(1)<CR>") +-- -- scroll up hover doc +-- as.nnoremap("<C-b>", "<cmd>lua require('lspsaga.action').smart_scroll_with_saga(-1)<CR>") + + require("which-key").register { + ["<leader>rn"] = { require("lspsaga.rename").rename, "lsp: rename" }, + ["<leader>ca"] = { require("lspsaga.codeaction").code_action, "lsp: code action" }, + ["gp"] = { require("lspsaga.provider").preview_definition, "lsp: preview definition" }, + ["gh"] = { require("lspsaga.provider").lsp_finder, "lsp: finder" }, + -- jump diagnostic + ["]c"] = { require("lspsaga.diagnostic").lsp_jump_diagnostic_prev, "lsp: previous diagnostic" }, + ["[c"] = { require("lspsaga.diagnostic").lsp_jump_diagnostic_next, "lsp: next diagnostic" }, + } + + -- augroup("LspSagaCursorCommands", { + -- { + -- events = { "CursorHold" }, + -- targets = { "*" }, + -- command = "lua require('lspsaga.diagnostic').show_cursor_diagnostics()", + -- }, + -- }) +end diff --git a/lua/plugins/lualine.lua b/lua/plugins/lualine.lua new file mode 100644 index 0000000..9d86e21 --- /dev/null +++ b/lua/plugins/lualine.lua @@ -0,0 +1,423 @@ +local lualine_status_ok, lualine = pcall(require, "lualine") +if not lualine_status_ok then + print("lualine.nvim is etiher broken or is not installed.") + return +end + +--local colors = require('tokyonight.colors').setup() +--local colors = { +--bg_dark = "#1f2335", +--bg = "#24283b", +--fg = "#c0caf5", +--fg_gutter = "#3b4261", +--green = "#a6e3a1", +--red = "#f38ba8", +--} + +--local colors = { +-- gray = '#23232e', +-- lightgray = '#5f6a8e', +-- orange = '#ffb86c', +-- purple = '#bd93f9', +-- red = '#ff5555', +-- yellow = '#f1fa8c', +-- green = '#50fa7b', +-- white = '#f8f8f2', +-- black = '#282a36', +--} +local colors = { + nobg = nil, + blue = "#87b0f9", + mauve = "#cba6f7", + red = "#f38ba8", + green = "#a6e3a1", + peach = "#fab387", + white = "#c6d0f5", + gray = "#a1a8c9", + black = "#1e1e2e", + innerbg = nil, + outerbg = "#16161D", +} +--require("lualine").setup({ +-- Your lua part of config goes here +require("lualine").setup({ + options = { + icons_enabled = true, + --theme = "auto", + theme = require("plugins.linecolor").theme(), + --theme = { + -- We are going to use lualine_c an lualine_x as left and + -- right section. Both are highlighte by c theme . So we + -- are just setting default looks o statusline + --normal = { c = { fg = colors.fg, bg = colors.bg } }, + --inactive = { c = { fg = colors.fg, bg = colors.bg } }, + --}, + component_separators = { left = "", right = "" }, + section_separators = { left = "", right = "" }, + --component_separators = { left = '|', right = '|'}, + --section_separators = { left = '', right = ''}, + disabled_filetypes = { + statusline = {}, + winbar = {}, + }, + ignore_focus = {}, + always_divide_middle = true, + globalstatus = true, + refresh = { + statusline = 1000, + tabline = 1000, + winbar = 1000, + }, + }, + sections = { + lualine_a = { "mode" }, + lualine_b = { + "branch", + { + "diff", + colored = true, + diff_color = { + added = "DiffAdd", + modified = "DiffChange", + removed = "DiffDelete", + }, + }, + { + "diagnostics", + + sources = { "nvim_lsp" }, + sections = { "error", "warn", "info" }, + + diagnostics_color = { + error = "DiagnosticError", + warn = "DiagnosticWarn", + info = "DiagnosticInfo", + }, + colored = true, + update_in_insert = false, + always_visible = false, + }, + }, + --lualine_b = { "branch", "diff", "diagnostics" }, + lualine_c = { + --{"filetype", padding={right=0}, icon_only = true, component_separators = {left = "", right = ""}}, + --{"filename", padding={left=0}, color = {gui = "bold,italic"}}, + --{ "filetype", + -- icon_only = true, + --}, + { + "filename", + --color = {gui = "bold,italic", fg = '#ffaa88', bg = 'nil' }, + --component_separators = {left = "", right = ""}, + }, + }, + lualine_x = { "encoding", "fileformat", "filetype" }, + --lualine_x = { + -- {"encoding", color = { bg = colors.black }, component_separators = {left = "", right = ""}}, + -- {"fileformat", color = { bg = colors.black }, component_separators = {left = "", right = ""}}, + -- {"filetype", color = { bg = colors.black }, component_separators = {left = "", right = ""}}, + --}, + lualine_y = { "progress" }, + lualine_z = { "location" }, + }, + inactive_sections = { + lualine_a = {}, + lualine_b = {}, + lualine_c = { "filename" }, + lualine_x = { "location" }, + lualine_y = {}, + lualine_z = {}, + }, + -- tabline = {}, + tabline = { + --lualine_a = { "mode" }, + --lualine_a = {custom_fname}, + lualine_a = { + { + "buffers", + show_filename_only = false, + show_modified_status = true, + mode = 4, + buffers_color = { + active = { bg = colors.nobg, fg = colors.black }, -- color for active buffer + --inactive = { bg = colors.white, fg = colors.fg_gutter }, -- color for inactive buffer + --active = { bg = colors.bg, fg = colors.white }, -- color for active buffer + --inactive = { bg = colors.bg_dark, fg = colors.fg_gutter }, -- color for inactive buffer + ----color = function() + ---- return { bg = vim.bo.modified and '#aa3355' or '#33aa88' } + ----end, + }, + symbols = { + modified = " ●", -- Text to show when the buffer is modified + alternate_file = "", -- Text to show to identify the alternate file + --directory = "", -- Text to show when the buffer is a directory + }, + max_length = vim.o.columns * 5 / 6, + --{{function() + -- local bg = 'hi! lualine_buffers_color' -- not modified + -- if vim.bo.modified then bg = '#c70039' -- unsaved + -- elseif not vim.bo.readonly then bg = 'hi! lualine_buffers_color' end -- readonly + -- vim.cmd('hi! lualine_buffers_color guibg='..bg) + --end, + --color = 'hi! lualine_buffers_color', + --}}, + }, + }, + lualine_b = {}, + lualine_c = {}, + lualine_x = {}, + lualine_y = {}, + lualine_z = {}, + --lualine_z = { "tabs" }, + }, + --tabline = { + -- lualine_a = { "mode" }, + -- lualine_b = { "buffers" }, + -- lualine_c = { "branch" }, + -- --lualine_c = { "branch", "diff", "diagnostics" }, + -- lualine_x = {}, + -- lualine_y = {}, + -- lualine_z = { "tabs" }, + --}, + --winbar = { + -- lualine_a = {}, + -- lualine_b = {}, + -- lualine_c = {'filename'}, + -- lualine_x = {}, + -- lualine_y = {}, + -- lualine_z = {} + --}, + --inactive_winbar = { + -- lualine_a = {}, + -- lualine_b = {}, + -- lualine_c = {}, + -- lualine_x = {}, + -- lualine_y = {}, + -- lualine_z = {} + --}, + winbar = {}, + inactive_winbar = {}, + --extensions = {}, + extensions = { "quickfix" }, +}) +--require("lualine").statusline() +--require("lualine").tabline() +--if not lualine_status_ok then +-- print("lualine.nvim is etiher broken or is not installed.") +-- return +--end +--local lualine_status_ok, lualine = pcall(require, "lualine") +--if not lualine_status_ok then +-- print("lualine.nvim is etiher broken or is not installed.") +-- return +--end +--local utils = require("heirline.utils") + +--local M = {} + +-- stylua: ignore start +--M.colours = {--{{{ +---- Color table for highlights +---- stylua: ignore +--local colors = { +-- bg = '#2E3440', +-- fg = '#E5E9F0', +-- yellow = '#EBCB8B', +-- cyan = '#88C0D0', +-- darkblue = '#5E81AC', +-- green = '#A3BE8C', +-- orange = '#D08770', +-- violet = '#B48EAD', +-- magenta = '#B48EAD', +-- blue = '#81A1C1', +-- red = '#BF616A', +--} +-- +--local conditions = { +-- buffer_not_empty = function() +-- return vim.fn.empty(vim.fn.expand("%:t")) ~= 1 +-- end, +-- hide_in_width = function() +-- return vim.fn.winwidth(0) > 80 +-- end, +-- check_git_workspace = function() +-- local filepath = vim.fn.expand("%:p:h") +-- local gitdir = vim.fn.finddir(".git", filepath .. ";") +-- return gitdir and #gitdir > 0 and #gitdir < #filepath +-- end, +--} + +-- Config +--local config = { +--require('lualine').setup { +-- options = { +-- -- Disable sections and component separators +-- component_separators = "", +-- section_separators = "", +-- theme = { +-- -- We are going to use lualine_c an lualine_x as left and +-- -- right section. Both are highlighte by c theme . So we +-- -- are just setting default looks o statusline +-- normal = { c = { fg = colors.fg, bg = colors.bg } }, +-- inactive = { c = { fg = colors.fg, bg = colors.bg } }, +-- }, +-- disabled_filetypes = { "NvimTree" }, +-- }, +-- sections = { +-- -- these are to remove the defaults +-- lualine_a = {}, +-- lualine_b = {}, +-- lualine_y = {}, +-- lualine_z = {}, +-- -- These will be filled later +-- lualine_c = {}, +-- lualine_x = {}, +-- }, +-- inactive_sections = { +-- -- these are to remove the defaults +-- lualine_a = {}, +-- lualine_b = {}, +-- lualine_y = {}, +-- lualine_z = {}, +-- lualine_c = {}, +-- lualine_x = {}, +-- }, +--} +-- +---- Inserts a component in lualine_c at left section +--local function ins_left(component) +-- table.insert(lualine.sections.lualine_c, component) +--end +-- +---- Inserts a component in lualine_x ot right section +--local function ins_right(component) +-- table.insert(lualine.sections.lualine_x, component) +--end +-- +--ins_left({ +-- function() +-- return "▊" +-- end, +-- color = { fg = colors.green }, -- Sets highlighting of component +-- padding = { left = 0, right = 1 }, -- We don't need space before this +--}) +-- +--ins_left({ +-- -- mode component +-- function() +-- return "" +-- end, +-- color = function() +-- -- auto change color according to neovims mode +-- local mode_color = { +-- n = colors.blue, +-- i = colors.green, +-- v = colors.violet, +-- ["�"] = colors.blue, +-- V = colors.blue, +-- c = colors.magenta, +-- no = colors.red, +-- s = colors.orange, +-- S = colors.orange, +-- ic = colors.yellow, +-- R = colors.violet, +-- Rv = colors.violet, +-- cv = colors.red, +-- ce = colors.red, +-- r = colors.cyan, +-- rm = colors.cyan, +-- ["r?"] = colors.cyan, +-- ["!"] = colors.red, +-- t = colors.red, +-- } +-- return { fg = mode_color[vim.fn.mode()] } +-- end, +-- padding = { right = 1 }, +--}) +-- +--ins_left({ +-- -- mode component +-- "mode", +-- color = function() +-- -- auto change color according to neovims mode +-- local mode_color = { +-- n = colors.red, +-- i = colors.green, +-- v = colors.violet, +-- ["�"] = colors.blue, +-- V = colors.blue, +-- c = colors.magenta, +-- no = colors.red, +-- s = colors.orange, +-- S = colors.orange, +-- ic = colors.yellow, +-- R = colors.violet, +-- Rv = colors.violet, +-- cv = colors.red, +-- ce = colors.red, +-- r = colors.cyan, +-- rm = colors.cyan, +-- ["r?"] = colors.cyan, +-- ["!"] = colors.red, +-- t = colors.red, +-- } +-- return { fg = mode_color[vim.fn.mode()] } +-- end, +-- padding = { right = 1 }, +--}) +-- +--ins_left({ +-- "branch", +-- icon = "", +-- color = { fg = colors.violet, gui = "bold" }, +--}) +-- +--ins_left({ +-- "filename", +-- cond = conditions.buffer_not_empty, +-- color = { fg = colors.aqua, gui = "bold" }, +--}) +-- +--ins_left({ +-- -- filesize component +-- "filesize", +-- cond = conditions.buffer_not_empty, +--}) +-- +---- Add components to right sections +--ins_right({ +-- "o:encoding", -- option component same as &encoding in viml +-- fmt = string.lower, -- I'm not sure why it's upper case either ;) +-- cond = conditions.hide_in_width, +-- color = { fg = colors.yellow }, +--}) +-- +--ins_right({ +-- "fileformat", +-- fmt = string.upper, +-- icons_enabled = true, -- I think icons are cool but Eviline doesn't have them. sigh +-- color = { fg = colors.fg, gui = "bold" }, +--}) +-- +--ins_right({ +-- "filetype", +--}) +-- +--ins_right({ "progress", color = { fg = colors.fg, gui = "bold" } }) +-- +--ins_right({ +-- "location", +--}) +-- +--ins_right({ +-- function() +-- return "▊" +-- end, +-- color = { fg = colors.green }, +-- padding = { left = 1 }, +--}) +--return M +-- Now don't forget to initialize lualine +--require("lualine").setup(config) +--require"lualine".setup(config) +--lualine.setup(config) diff --git a/lua/plugins/luasnip-22.10.23-12:54-bak.lua b/lua/plugins/luasnip-22.10.23-12:54-bak.lua new file mode 100644 index 0000000..08f49ee --- /dev/null +++ b/lua/plugins/luasnip-22.10.23-12:54-bak.lua @@ -0,0 +1,161 @@ +if vim.g.snippets ~= "luasnip" or not pcall(require, "luasnip") then + return +end +--local luasnip = require("luasnip") +local ls = require "luasnip" -- +local types = require "luasnip.util.types" -- +--local options = { +ls.config.set_config { + history = true, + updateevents = "TextChanged,TextChangedI", + -- Autosnippets: + enable_autosnippets = true, -- + ext_opts = { -- + [types.choiceNode] = { -- + active = { -- + virt_text = { { " « ", "NonTest" } }, -- + }, -- + }, -- + }, -- +} + +--local keymap = vim.keymap +local keymap = vim.api.nvim_set_keymap +--local keymap = vim.keymap.set +-- <c-j> is my jump backwards key. +-- this always moves to the previous item within the snippet + +--keymap({ "i", "s" }, "<C-j>", function() +-- if ls.jumpable(-1) then +-- ls.jump(-1) +-- end +--end, { silent = true }) + +-- <c-l> is selecting within a list of options. +-- This is useful for choice nodes (introduced in the forthcoming episode 2) +--keymap({"i"}, "<c-l>", function() +-- if ls.choice_active() then +-- ls.change_choice(1) +-- end +--end, { silent = true }) + + +--keymap("i", "<c-z>", require "luasnip.extras.select_choice") + +-- shorcut to source my luasnips file again, which will reload my snippets +--keymap("n", "<leader><leader>s", "<cmd>source ~/.config/nvim/lua/user/plugins/luasnip.lua<CR>") + +-- ls.parser.parse_snippet(<text>, <VS**** style snippet>) +--ls.snippets = { +-- all = { +-- -- Available in any filetype +-- ls.parser.parse_snippet("expand", "-- this is what was expanded!"), +--s.snippets = { +-- all = { +-- -- Available in any filetype +-- ls.parser.parse_snippet("expand", "-- this is what was expanded!"), +-- }, +-- lua = { +-- -- Lua specific snippets go here. +-- ls.parser.parse_snippet("lf", "local $1 = function($2)\n $0\nend") +-- }, +-- +--}) +local snip = ls.snippet +local node = ls.snippet_node +local text = ls.text_node +local insert = ls.insert_node +local func = ls.function_node +local choice = ls.choice_node +local dynamicn = ls.dynamic_node + +local date = function() return {os.date('%Y-%m-%d')} end + +ls.add_snippets(nil, { + all = { + --snip({ + -- trig = "date", + -- namr = "Date", + -- dscr = "Date in the form of YYYY-MM-DD", + --}, { + -- func(date, {}), + --}), + snip({ + trig = "meta", + namr = "Metadata", + dscr = "Yaml metadata format for markdown" +}, +{ + text({"---", + "title: "}), insert(1, "note_title"), text({"", + "author: "}), insert(2, "author"), text({"", + "date: "}), func(date, {}), text({"", + "categories: ["}), insert(3, ""), text({"]", + "lastmod: "}), func(date, {}), text({"", + "tags: ["}), insert(4), text({"]", + "comments: true", + "---", ""}), + insert(0) + }), + }}) +--keymap("i", "<C-j>", "<cmd>lua require'luasnip'.jump(1)<CR>", opts) +--keymap("s", "<C-j>", "<cmd>lua require'luasnip'.jump(1)<CR>", opts) +--keymap("i", "<C-k>", "<cmd>lua require'luasnip'.jump(-1)<CR>", opts) +--local opts = { noremap = true, silent = true } +--local keymap = vim.api.nvim_set_keymap +--local keymap = vim.keymap +--local term_opts = { noremap = true, silent = false } +-- local map = function(mode, l, r, opts) +-- opts = opts or {} +-- opts.silent = true +-- opts.noremap = true +-- keymap.set(mode, l, r, opts) +-- end + + + +--keymap("i", "<C-j>", "<Plug>luasnip-expand-or-jump * <Cmd>lua require'luasnip'.expand_or_jump()<CR>", opts) +--keymap("i", "<C-k>", "<Plug>luasnip-jump-prev * <Cmd>lua require'luasnip'.jump(-1)<CR>", opts) +--keymap("s", "<C-j>", "<Plug>luasnip-expand-or-jump * <Cmd>lua require'luasnip'.expand_or_jump()<CR>", opts) +--keymap("s", "<C-k>", "<Plug>luasnip-jump-prev * <Cmd>lua require'luasnip'.jump(-1)<CR>", opts) +--keymap("i", "<C-c>", "<Plug>luasnip-next-choice * <Cmd>lua require'luasnip'.change_choice(1)<CR>", opts) +--keymap("s", "<C-k>", "<cmd>lua require'luasnip'.jump(-1)<CR>", opts) +--map("i", "<C-j>", "<Plug>luasnip-expand-or-jump<CR>") + +--! <Plug>luasnip-expand-repeat * <Cmd>lua require'luasnip'.expand_repeat()<CR> +--! <Plug>luasnip-delete-check * <Cmd>lua require'luasnip'.unlink_current_if_deleted()<CR> +--i <Plug>luasnip-jump-prev * <Cmd>lua require'luasnip'.jump(-1)<CR> +--i <Plug>luasnip-jump-next * <Cmd>lua require'luasnip'.jump(1)<CR> +--i <Plug>luasnip-prev-choice * <Cmd>lua require'luasnip'.change_choice(-1)<CR> +--i <Plug>luasnip-next-choice * <Cmd>lua require'luasnip'.change_choice(1)<CR> +--i <Plug>luasnip-expand-snippet * <Cmd>lua require'luasnip'.expand()<CR> +--i <Plug>luasnip-expand-or-jump * <Cmd>lua require'luasnip'.expand_or_jump()<CR> + +--- + + + + + + + + + +--luasnip.config.set_config(options) +--require("luasnip.loaders.from_vscode").lazy_load() +--require("luasnip.loaders.from_vscode").lazy_load { paths = vim.g.luasnippets_path or "" } +-- +--vim.api.nvim_create_autocmd("InsertLeave", { +-- callback = function() +-- if +-- require("luasnip").session.current_nodes[vim.api.nvim_get_current_buf()] +-- and not require("luasnip").session.jump_active +-- then +-- require("luasnip").unlink_current() +-- end +-- end, +--}) + + + + diff --git a/lua/plugins/luasnip.lua b/lua/plugins/luasnip.lua new file mode 100644 index 0000000..de2177e --- /dev/null +++ b/lua/plugins/luasnip.lua @@ -0,0 +1,69 @@ +local ls = require "luasnip" -- + +require("luasnip.loaders.from_lua").load({ paths = "~/.config/nvim/snippets/" }) +--local options = { +ls.config.set_config { + history = true, + updateevents = "TextChanged,TextChangedI", + -- Autosnippets: + enable_autosnippets = true, -- + ext_opts = { -- + [require("luasnip.util.types").choiceNode] = { + active = { + virt_text = { { "«", "GruvboxOrange" } }, + }, + }, + }, +} + +--local keymap = vim.keymap +--local keymap = vim.api.nvim_set_keymap +local keymap = vim.keymap.set +--keymap('i', '<c-f>', 'luasnip#expand_or_jumpable() ? "<Plug>luasnip-expand-or-jump" : "<Tab>"', {expr = true, silent = true}) +keymap({ "i", "s"}, "<c-f>", function() + if ls.expand_or_jumpable() then + ls.expand() + end +end) + +keymap({ "i", "s"}, "<c-j>", function() + if ls.jumpable(1) then + ls.jump(1) + end +end) + +keymap({ "i", "s"}, "<c-k>", function() + if ls.jumpable(-1) then + ls.jump(-1) + end +end) + +keymap({ "i", "s"}, "<c-c>", function() + if ls.choice_active() then + ls.change_choice(1) + end +end) + +keymap({ "i", "s"}, "<a-c>", function() + if ls.choice_active() then + ls.change_choice(-1) + end +end) + +-- Character class Matching +-- %a letters (A-Z, a-z) +-- %c control characters (\n, \t, \r, ...) +-- %d digits (0-9) +-- %l lower-case letter (a-z) +-- %p punctuation characters (!, ?, &, ...) +-- %s space characters +-- %u upper-case letters +-- %w alphanumeric characters (A-Z, a-z, 0-9) +-- %x hexadecimal digits (\3, \4, ...) +-- %z the character with representation 0 +-- . Matches any character + + + + + diff --git a/lua/plugins/mason.lua b/lua/plugins/mason.lua new file mode 100644 index 0000000..69c61ba --- /dev/null +++ b/lua/plugins/mason.lua @@ -0,0 +1,27 @@ +local status, mason = pcall(require, "mason") +if (not status) then return end +local status2, lspconfig = pcall(require, "mason-lspconfig") +if (not status2) then return end + +mason.setup({ + +}) + +lspconfig.setup { + ensure_installed = { "sumneko_lua" }, +} +local keymap = vim.api.nvim_set_keymap +local opts = { noremap = true } + + +keymap('n', 'gd', ':lua vim.lsp.buf.definition()<cr>', opts) +keymap('n', 'gD', ':lua vim.lsp.buf.declaration()<cr>', opts) +keymap('n', 'gi', ':lua vim.lsp.buf.implementation()<cr>', opts) +keymap('n', 'gw', ':lua vim.lsp.buf.document_symbol()<cr>', opts) +keymap('n', 'gw', ':lua vim.lsp.buf.workspace_symbol()<cr>', opts) +keymap('n', 'gr', ':lua vim.lsp.buf.references()<cr>', opts) +keymap('n', 'gt', ':lua vim.lsp.buf.type_definition()<cr>', opts) +keymap('n', 'K', ':lua vim.lsp.buf.hover()<cr>', opts) +keymap('n', '<c-k>', ':lua vim.lsp.buf.signature_help()<cr>', opts) +keymap('n', '<leader>af', ':lua vim.lsp.buf.code_action()<cr>', opts) +keymap('n', '<leader>rn', ':lua vim.lsp.buf.rename()<cr>', opts) diff --git a/lua/plugins/modify-blend.lua b/lua/plugins/modify-blend.lua new file mode 100644 index 0000000..7c48815 --- /dev/null +++ b/lua/plugins/modify-blend.lua @@ -0,0 +1,40 @@ +local ui = vim.api.nvim_list_uis()[1] + +local bufnr = vim.api.nvim_create_buf(false, true) +local win = vim.api.nvim_open_win(bufnr, true, { + relative = "editor", + width = ui.width, + height = ui.height, + row = 10, + col = 10, + style = "minimal", +}) + +vim.api.nvim_win_set_option(win, "winblend", 1) + +local blend_start = 15 +local offset = 1 + +CANCEL = false +local timer = vim.loop.new_timer() +timer:start( + 0, + 50, + vim.schedule_wrap(function() + blend_start = blend_start + offset + + if blend_start > 90 then + offset = -1 + elseif blend_start < 10 then + offset = 1 + end + + if CANCEL or not vim.api.nvim_win_is_valid(win) then + timer:close() + timer:stop() + return + end + + vim.cmd([[highlight NormalFloat blend=]] .. tostring(blend_start)) + end) +) diff --git a/lua/plugins/neoscroll.lua b/lua/plugins/neoscroll.lua new file mode 100644 index 0000000..d122584 --- /dev/null +++ b/lua/plugins/neoscroll.lua @@ -0,0 +1,21 @@ +require("neoscroll").setup({ + easing_function = "quadratic", +}) + +local t = {} +-- Syntax: t[keys] = {function, {function arguments}} +-- Use the "sine" easing function +t["<C-u>"] = { "scroll", { "-vim.wo.scroll", "true", "20", [['cubic']] } } +t["<C-d>"] = { "scroll", { "vim.wo.scroll", "true", "20", [['cubic']] } } +-- Use the "circular" easing function +t["<C-b>"] = { "scroll", { "-vim.api.nvim_win_get_height(0)", "true", "50", [['cubic']] } } +t["<C-f>"] = { "scroll", { "vim.api.nvim_win_get_height(0)", "true", "50", [['cubic']] } } +-- Pass "nil" to disable the easing animation (constant scrolling speed) +t["<C-y>"] = { "scroll", { "-0.10", "false", "100", nil } } +t["<C-e>"] = { "scroll", { "0.10", "false", "100", nil } } +-- When no easing function is provided the default easing function (in this case "quadratic") will be used +t["zt"] = { "zt", { "10" } } +t["zz"] = { "zz", { "10" } } +t["zb"] = { "zb", { "10" } } + +require("neoscroll.config").set_mappings(t) diff --git a/lua/plugins/null-ls.lua b/lua/plugins/null-ls.lua new file mode 100644 index 0000000..7fc4377 --- /dev/null +++ b/lua/plugins/null-ls.lua @@ -0,0 +1,26 @@ +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 +-- }, +--}) +require("null-ls").setup({ + sources = { + require("null-ls").builtins.formatting.stylua, + require("null-ls").builtins.diagnostics.eslint, + require("null-ls").builtins.completion.spell, + }, +}) diff --git a/lua/plugins/nvim-tree.lua b/lua/plugins/nvim-tree.lua new file mode 100644 index 0000000..a1e10e0 --- /dev/null +++ b/lua/plugins/nvim-tree.lua @@ -0,0 +1,69 @@ +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 + +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, + --height = 30, + side = "left", + mappings = { + list = { + { key = { "l", "<CR>", "o" }, cb = tree_cb("edit") }, + { key = "h", cb = tree_cb("close_node") }, + { key = "v", cb = tree_cb("vsplit") }, + { key = "u", action = "dir_up" }, + }, + }, + }, +}) diff --git a/lua/plugins/prettier.lua b/lua/plugins/prettier.lua new file mode 100644 index 0000000..05d4665 --- /dev/null +++ b/lua/plugins/prettier.lua @@ -0,0 +1,19 @@ +local status, prettier = pcall(require, "prettier") +if (not status) then return end + +prettier.setup { + bin = 'prettierd', + filetypes = { + "c", + "lua", + "vim", + --"css", + --"javascript", + --"javascriptreact", + --"typescript", + --"typescriptreact", + --"json", + --"scss", + "less" + } +} diff --git a/lua/plugins/scripts/lsp-ext.lua b/lua/plugins/scripts/lsp-ext.lua new file mode 100644 index 0000000..c4378c6 --- /dev/null +++ b/lua/plugins/scripts/lsp-ext.lua @@ -0,0 +1,48 @@ +-- +-- lsp-ext.lua + + +M = {} + +function M.preview_location(location, context, before_context) + -- location may be LocationLink or Location (more useful for the former) + context = context or 15 + before_context = before_context or 0 + local uri = location.targetUri or location.uri + if uri == nil then + return + end + local bufnr = vim.uri_to_bufnr(uri) + if not vim.api.nvim_buf_is_loaded(bufnr) then + vim.fn.bufload(bufnr) + end + local range = location.targetRange or location.range + local contents = + vim.api.nvim_buf_get_lines(bufnr, range.start.line - before_context, range["end"].line + 1 + context, false) + local filetype = vim.api.nvim_buf_get_option(bufnr, "filetype") + return vim.lsp.util.open_floating_preview(contents, filetype) +end + +function M.preview_location_callback(_, method, result) + local context = 15 + if result == nil or vim.tbl_isempty(result) then + print("No location found: " .. method) + return nil + end + if vim.tbl_islist(result) then + M.floating_buf, M.floating_win = M.preview_location(result[1], context) + else + M.floating_buf, M.floating_win = M.preview_location(result, context) + end +end + +function M.peek_definition() + if vim.tbl_contains(vim.api.nvim_list_wins(), M.floating_win) then + vim.api.nvim_set_current_win(M.floating_win) + else + local params = vim.lsp.util.make_position_params() + return vim.lsp.buf_request(0, "textDocument/definition", params, M.preview_location_callback) + end +end + +return M diff --git a/lua/plugins/scripts/setcolors.lua b/lua/plugins/scripts/setcolors.lua new file mode 100644 index 0000000..605bc84 --- /dev/null +++ b/lua/plugins/scripts/setcolors.lua @@ -0,0 +1,121 @@ +vim.cmd([[ +" Change the color scheme from a list of color scheme names. +" Version 2010-09-12 from http://vim.wikia.com/wiki/VimTip341 +" Press key: +" F8 next scheme +" Shift-F8 previous scheme +" Alt-F8 random scheme +" Set the list of color schemes used by the above (default is 'all'): +" :SetColors all (all $VIMRUNTIME/colors/*.vim) +" :SetColors my (names built into script) +" :SetColors blue ayu ron (these schemes) +" :SetColors (display current scheme names) +" Set the current color scheme based on time of day: +" :SetColors now +if v:version < 700 || exists('loaded_setcolors') || &cp + finish +endif + +let loaded_setcolors = 1 +let s:mycolors = ['everblush', 'ayu', 'gruvbox', 'molokai', 'onedark', 'srcery'] " colorscheme names that we use to set color + +" Set list of color scheme names that we will use, except +" argument 'now' actually changes the current color scheme. +function! s:SetColors(args) + if len(a:args) == 0 + echo 'Current color scheme names:' + let i = 0 + while i < len(s:mycolors) + echo ' '.join(map(s:mycolors[i : i+4], 'printf("%-14s", v:val)')) + let i += 5 + endwhile + elseif a:args == 'all' + let paths = split(globpath(&runtimepath, 'colors/*.vim'), "\n") + let s:mycolors = uniq(sort(map(paths, 'fnamemodify(v:val, ":t:r")'))) + echo 'List of colors set from all installed color schemes' + elseif a:args == 'my' + let c1 = 'default srcery everblush' + let c2 = 'gruvbox onedark' + let c3 = 'ayu molokai' + let s:mycolors = split(c1.' '.c2.' '.c3) + echo 'List of colors set from built-in names' + elseif a:args == 'now' + call s:HourColor() + else + let s:mycolors = split(a:args) + echo 'List of colors set from argument (space-separated names)' + endif +endfunction + +command! -nargs=* SetColors call s:SetColors('<args>') + +" Set next/previous/random (how = 1/-1/0) color from our list of colors. +" The 'random' index is actually set from the current time in seconds. +" Global (no 's:') so can easily call from command line. +function! NextColor(how) + call s:NextColor(a:how, 1) +endfunction + +" Helper function for NextColor(), allows echoing of the color name to be +" disabled. +function! s:NextColor(how, echo_color) + if len(s:mycolors) == 0 + call s:SetColors('all') + endif + if exists('g:colors_name') + let current = index(s:mycolors, g:colors_name) + else + let current = -1 + endif + let missing = [] + let how = a:how + for i in range(len(s:mycolors)) + if how == 0 + let current = localtime() % len(s:mycolors) + let how = 1 " in case random color does not exist + else + let current += how + if !(0 <= current && current < len(s:mycolors)) + let current = (how>0 ? 0 : len(s:mycolors)-1) + endif + endif + try + execute 'colorscheme '.s:mycolors[current] + break + catch /E185:/ + call add(missing, s:mycolors[current]) + endtry + endfor + redraw + if len(missing) > 0 + echo 'Error: colorscheme not found:' join(missing) + endif + if (a:echo_color) + echo g:colors_name + endif +endfunction + +nnoremap <leader>cn :call NextColor(1)<CR> +nnoremap <leader>cp :call NextColor(-1)<CR> +nnoremap <leader>cc :call NextColor(0)<CR> + +" Set color scheme according to current time of day. +function! s:HourColor() + let hr = str2nr(strftime('%H')) + if hr <= 3 + let i = 0 + elseif hr <= 7 + let i = 1 + elseif hr <= 14 + let i = 2 + elseif hr <= 18 + let i = 3 + else + let i = 4 + endif + let nowcolors = 'srcery onedark molokai' + execute 'colorscheme '.split(nowcolors)[i] + redraw + echo g:colors_name +endfunction +]]) diff --git a/lua/plugins/scripts/toggleLsp.lua b/lua/plugins/scripts/toggleLsp.lua new file mode 100644 index 0000000..28af698 --- /dev/null +++ b/lua/plugins/scripts/toggleLsp.lua @@ -0,0 +1,40 @@ +local M = {} + +local check_function = function(bufnr, _) + local ok, result = pcall(vim.api.nvim_buf_get_var, bufnr, 'lsp_enabled') + -- No buffer local variable set, so just enable by default + if not ok then + return true + end + + return result +end + +vim.lsp.handlers["textDocument/publishDiagnostics"] = + vim.lsp.with(vim.lsp.diagnostic.on_publish_diagnostics, { + underline = check_function, + virtual_text = check_function, + signs = check_function + }) + +function M.Enable() + vim.b.lsp_enabled = true +end + +function M.Disable() + vim.b.lsp_enabled = false +end + +function M.Toggle() + if vim.b.lsp_enabled == false then + M.Enable() + else + M.Disable() + end +end + +vim.cmd [[ + command! -nargs=* ToggleLsp lua require'lsp.toggle'.Toggle() +]] + +return M diff --git a/lua/plugins/telescope.lua b/lua/plugins/telescope.lua new file mode 100644 index 0000000..db065d7 --- /dev/null +++ b/lua/plugins/telescope.lua @@ -0,0 +1,223 @@ +local status_ok, telescope = pcall(require, "telescope") +if not status_ok then + return +end +local actions = require("telescope.actions") +local builtin = require("telescope.builtin") + +local function telescope_buffer_dir() + return vim.fn.expand("%:p:h") +end + +telescope.load_extension("fzf") +telescope.load_extension("file_browser") +require("telescope").load_extension("file_browser") +local fb_actions = require("telescope").extensions.file_browser.actions +--telescope.load_extension('media_files') + +telescope.setup({ + defaults = { + -- + prompt_prefix = " ", + selection_caret = " ", + path_display = { "smart" }, + -- + mappings = { + i = { + ["<C-n>"] = actions.cycle_history_next, + ["<C-p>"] = actions.cycle_history_prev, + + ["<C-j>"] = actions.move_selection_next, + ["<C-k>"] = actions.move_selection_previous, + + ["<C-c>"] = actions.close, + + ["<Down>"] = actions.move_selection_next, + ["<Up>"] = actions.move_selection_previous, + + ["<CR>"] = actions.select_default, + ["<C-x>"] = actions.select_horizontal, + ["<C-y>"] = actions.select_vertical, + ["<C-t>"] = actions.select_tab, + + ["<C-u>"] = actions.preview_scrolling_up, + ["<C-d>"] = actions.preview_scrolling_down, + + ["<PageUp>"] = actions.results_scrolling_up, + ["<PageDown>"] = actions.results_scrolling_down, + + ["<Tab>"] = actions.toggle_selection + actions.move_selection_worse, + ["<S-Tab>"] = actions.toggle_selection + actions.move_selection_better, + ["<C-q>"] = actions.send_to_qflist + actions.open_qflist, + ["<M-q>"] = actions.send_selected_to_qflist + actions.open_qflist, + ["<C-l>"] = actions.complete_tag, + ["<C-_>"] = actions.which_key, -- keys from pressing <C-/> + }, + + n = { + ["<esc>"] = actions.close, + ["<CR>"] = actions.select_default, + ["<C-x>"] = actions.select_horizontal, + ["<C-v>"] = actions.select_vertical, + ["<C-t>"] = actions.select_tab, + + ["<Tab>"] = actions.toggle_selection + actions.move_selection_worse, + ["<S-Tab>"] = actions.toggle_selection + actions.move_selection_better, + ["<C-q>"] = actions.send_to_qflist + actions.open_qflist, + ["<M-q>"] = 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, + + ["<Down>"] = actions.move_selection_next, + ["<Up>"] = actions.move_selection_previous, + ["gg"] = actions.move_to_top, + ["G"] = actions.move_to_bottom, + + ["<C-u>"] = actions.preview_scrolling_up, + ["<C-d>"] = actions.preview_scrolling_down, + + ["<PageUp>"] = actions.results_scrolling_up, + ["<PageDown>"] = actions.results_scrolling_down, + + ["?"] = actions.which_key, + ["cd"] = function(prompt_bufnr) + local selection = require("telescope.actions.state").get_selected_entry() + local dir = vim.fn.fnamemodify(selection.path, ":p:h") + require("telescope.actions").close(prompt_bufnr) + -- Depending on what you want put `cd`, `lcd`, `tcd` + vim.cmd(string.format("silent lcd %s", dir)) + end, + }, + }, + }, + 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 + }, + extensions = { + file_browser = { + theme = "dropdown", + -- disables netrw and use telescope-file-browser in its place + hijack_netrw = true, + mappings = { + -- your custom insert mode mappings + ["i"] = { + ["<C-w>"] = function() + vim.cmd("normal vbd") + end, + }, + ["n"] = { + -- your custom normal mode mappings + ["N"] = fb_actions.create, + ["h"] = fb_actions.goto_parent_dir, + ["/"] = function() + vim.cmd("startinsert") + end, + }, + }, + }, + + media_files = { + -- filetypes whitelist + -- defaults to {"png", "jpg", "mp4", "webm", "pdf"} + filetypes = { "png", "webp", "jpg", "jpeg" }, + find_cmd = "rg", -- find command (defaults to `fd`) + }, + -- 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 + }, +}) + +telescope.load_extension("file_browser") + +--vim.keymap.set("n", ";f", function() +-- builtin.find_files({ +-- no_ignore = false, +-- hidden = true, +-- }) +--end) +vim.keymap.set("n", ";r", function() + builtin.live_grep() +end) +vim.keymap.set("n", "\\\\", function() + builtin.buffers() +end) +vim.keymap.set("n", ";t", function() + builtin.help_tags() +end) +vim.keymap.set("n", ";;", function() + builtin.resume() +end) +vim.keymap.set("n", ";e", function() + builtin.diagnostics() +end) +--vim.keymap.set("n", "sf", function() +-- telescope.extensions.file_browser.file_browser({ +-- path = "%:p:h", +-- cwd = telescope_buffer_dir(), +-- respect_gitignore = false, +-- hidden = true, +-- grouped = true, +-- previewer = false, +-- initial_mode = "normal", +-- layout_config = { height = 40 }, +-- }) +--end) + +local M = {} + +function M.reload() + local function get_module_name(s) + local module_name; + + module_name = s:gsub("%.lua", "") + module_name = module_name:gsub("%/", ".") + module_name = module_name:gsub("%.init", "") + + return module_name + end + + local prompt_title = "~ neovim modules ~" + + -- sets the path to the lua folder + local path = "~/.config/nvim/lua" + + local opts = { + prompt_title = prompt_title, + cwd = path, + + attach_mappings = function(_, map) + -- Adds a new map to ctrl+e. + map("i", "<c-e>", function(_) + -- these two a very self-explanatory + local entry = require("telescope.actions.state").get_selected_entry() + local name = get_module_name(entry.value) + + -- call the helper method to reload the module + -- and give some feedback + R(name) + P(name .. " RELOADED!!!") + end) + + return true + end + } + + -- call the builtin method to list files + require('telescope.builtin').find_files(opts) +end + +return M; + diff --git a/lua/plugins/toggleterm.lua b/lua/plugins/toggleterm.lua new file mode 100644 index 0000000..912729a --- /dev/null +++ b/lua/plugins/toggleterm.lua @@ -0,0 +1,90 @@ +local status_ok, toggleterm = pcall(require, "toggleterm") +if not status_ok then + return +end + +toggleterm.setup({ + size = function(term) + if term.direction == "horizontal" then + return 12 + elseif term.direction == "vertical" then + return vim.o.columns * 0.3 + end + end, + --size = 20, + open_mapping = [[<leader>to]], + hide_numbers = true, + shade_filetypes = {}, + shade_terminals = false, + shading_factor = 1, + start_in_insert = true, + insert_mappings = true, + persist_size = true, + direction = "float", + --direction = "vertical", + --direction = "horizontal", + close_on_exit = true, + shell = vim.o.shell, + highlights = { + -- highlights which map to a highlight group name and a table of it's values + -- NOTE: this is only a subset of values, any group placed here will be set for the terminal window split + Normal = { + background = "#000000", + }, + }, + float_opts = { + width = 70, + height = 15, + winblend = 3, + border = "curved", + --winblend = 0, + highlights = { + border = "Normal", + background = "Normal", + }, + }, +}) + +function _G.set_terminal_keymaps() + local opts = { noremap = true } + --local opts = {buffer = 0} + vim.api.nvim_buf_set_keymap(0, "t", "<esc>", [[<C-\><C-n>]], opts) + vim.api.nvim_buf_set_keymap(0, "t", "jj", [[<C-\><C-n>]], opts) + vim.api.nvim_buf_set_keymap(0, "t", "<C-h>", [[<C-\><C-n><C-W>h]], opts) + vim.api.nvim_buf_set_keymap(0, "t", "<C-j>", [[<C-\><C-n><C-W>j]], opts) + vim.api.nvim_buf_set_keymap(0, "t", "<C-k>", [[<C-\><C-n><C-W>k]], opts) + vim.api.nvim_buf_set_keymap(0, "t", "<C-l>", [[<C-\><C-n><C-W>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/plugins/treesitter.lua b/lua/plugins/treesitter.lua new file mode 100644 index 0000000..b081ca3 --- /dev/null +++ b/lua/plugins/treesitter.lua @@ -0,0 +1,34 @@ +local status, treesitter = pcall(require, "nvim-treesitter.configs") +if (not status) then return end + +treesitter.setup { + highlight = { + enable = true, + disable = {}, + }, + indent = { + enable = true, + disable = {}, + --disable = { "python", "css" } + }, + ensure_installed = { + "c", + "bash", + "lua", + "rust", + }, + --ensure_installed = "all", -- one of "all" or a list of languages + --ignore_install = { "" }, -- List of parsers to ignore installing + autotag = { + enable = true, + }, + efactor = { + highlight_definitions = { enable = true }, + highlight_current_scope = { enable = true } + } +} +--vim.opt.foldmethod = "expr" +--vim.opt.foldexpr = "nvim_treesitter#foldexpr()" + +--local parser_config = require "nvim-treesitter.parsers".get_parser_configs() +--parser_config.tsx.filetype_to_parsername = { "javascript", "typescript.tsx" } diff --git a/lua/plugins/web-devicons.lua b/lua/plugins/web-devicons.lua new file mode 100644 index 0000000..b8396bc --- /dev/null +++ b/lua/plugins/web-devicons.lua @@ -0,0 +1,12 @@ +local status, icons = pcall(require, "nvim-web-devicons") +if (not status) then return end + +icons.setup { + -- your personnal icons can go here (to override) + -- DevIcon will be appended to `name` + override = { + }, + -- globally enable default icons (default to false) + -- will get overriden by `get_icons` option + default = true +} diff --git a/lua/plugins/zen-mode.lua b/lua/plugins/zen-mode.lua new file mode 100644 index 0000000..7e52854 --- /dev/null +++ b/lua/plugins/zen-mode.lua @@ -0,0 +1,7 @@ +local status, zenMode = pcall(require, "zen-mode") +if (not status) then return end + +zenMode.setup { +} + +vim.keymap.set('n', '<C-w>o', '<cmd>ZenMode<cr>', { silent = true }) diff --git a/lua/user/keys.lua b/lua/user/keys.lua index 1a2994b..bc1f874 100644 --- a/lua/user/keys.lua +++ b/lua/user/keys.lua @@ -26,7 +26,7 @@ vim.g.mapleader = ";" --vim.g.maplocalleader = ";" -- "jj" to exit insert-mode -map("i", "jj", "<esc>") +map("i", "kk", "<esc>") -- save quickly --map("n", ";w", ":w<CR>", d("Save buffer")) @@ -40,16 +40,17 @@ map("i", "jj", "<esc>") --vim.api.nvim_set_keymap("n", "<leader><CR>", "<cmd>lua ReloadConfig()<CR>", { noremap = true, silent = false }) map("n", "<leader><CR>", "<cmd>luafile ~/.config/nvim/init.lua<CR>", print ("Nvim configuration reloaded")) --- + +map("n", "<Leader>tc", ":lua require('user.utils').toggle_completion()<CR>") -- vim.notify("Nvim configuration reloaded!", vim.log.levels.INFO) --vim.api.nvim_set_keymap('n', '<Leader>qr', '<cmd>:lua require("plugins.telescope").reload()<CR>', { noremap = true, silent = true }) --Easier split navigations, just ctrl-j instead of ctrl-w then j ---map("n", "<C-J>", "<C-W><C-J>") ---map("n", "<C-K>", "<C-W><C-K>") ---map("n", "<C-L>", "<C-W><C-L>") ---map("n", "<C-H>", "<C-W><C-H>") +map("n", "<C-J>", "<C-W><C-J>") +map("n", "<C-K>", "<C-W><C-K>") +map("n", "<C-L>", "<C-W><C-L>") +map("n", "<C-H>", "<C-W><C-H>") -- Combine buffers list with buffer name map("n", "<Leader>b", ":buffers<CR>:buffer<Space>") @@ -151,12 +152,12 @@ map("v", "p", '"_dP') -- Paste end of line --map("n", ",", "$p") -vim.cmd([[ - nmap , $p -]]) +--vim.cmd([[ +-- nmap , $p +--]]) -- Select entire buffer -map("v", "<aa>", "gg<S-v>G") +--map("v", "<aa>", "gg<S-v>G") -- Delete without changing the registers --map('n', 'x', '"_x') @@ -349,8 +350,8 @@ vim.cmd([[ --EasyAlign /--/ --:'<,'>Tabularize /-- -map("n", "<leader>,", ":hide<CR>") -map("n", "<leader>.", ":unhide<CR>") +--map("n", "<leader>,", ":hide<CR>") +--map("n", "<leader>.", ":unhide<CR>") --" Clean trailing whitespace --nnoremap <leader>ww mz:%s/\s\+$//<cr>:let @/=''<cr>`z diff --git a/lua/user/pack.lua b/lua/user/pack.lua index 55b52cd..05999eb 100644 --- a/lua/user/pack.lua +++ b/lua/user/pack.lua @@ -43,6 +43,7 @@ packer.init({ return packer.startup(function(use) use("wbthomason/packer.nvim") -- Have packer manage itself + use("lewis6991/impatient.nvim") use("nvim-lua/plenary.nvim") -- Useful lua functions used ny lots of plugins --use("jose-elias-alvarez/null-ls.nvim") @@ -175,7 +176,7 @@ return packer.startup(function(use) -- snippets --use("L3MON4D3/LuaSnip") --snippet engine - use({"L3MON4D3/LuaSnip", tag = "v<CurrentMajor>.*"}) + use("L3MON4D3/LuaSnip") use("rafamadriz/friendly-snippets") -- a bunch of snippets to use --use("github/copilot.vim") --use({ @@ -302,7 +303,7 @@ return packer.startup(function(use) -- Utilities use("nathom/filetype.nvim") - --use("christoomey/vim-tmux-navigator") + use("christoomey/vim-tmux-navigator") --use("preservim/vimux") use("myusuf3/numbers.vim") use("windwp/nvim-autopairs") @@ -310,20 +311,30 @@ return packer.startup(function(use) use("dinhhuy258/git.nvim") -- For git blame & browse use("kyazdani42/nvim-tree.lua") use("numToStr/Comment.nvim") - use("akinsho/toggleterm.nvim") + --use("akinsho/toggleterm.nvim") --use("godlygeek/tabular") --use("Vonr/align.nvim") --use("junegunn/vim-easy-align") --use("dstein64/vim-startuptime") use("tweekmonster/startuptime.vim") - use("lewis6991/impatient.nvim") -- use("luukvbaal/stabilize.nvim") - --use({ - -- "ggandor/leap.nvim", - -- config = function() - -- require("leap").set_default_keymaps() - -- end, - --}) + --use("rhysd/clever-f.vim") + --use("ggandor/lightspeed.nvim") -- use 'cl' and 'cc' instead of 's' and 'S' respectively + --use("ggandor/leap.nvim") + use({ + "ggandor/leap.nvim", + config = function() + require("leap").set_default_keymaps() + --vim.keymap.set('n', '-', '<Plug>(leap-forward)', {}) + --vim.keymap.set('n', '_', '<Plug>(leap-backward)', {}) + end, + }) + use({ "ggandor/flit.nvim", + config = function() + require("flit").setup() + end, + }) + --use("Shatur/neovim-session-manager") --use("rmagatti/auto-session") --use("rmagatti/session-lens") diff --git a/lua/user/utils.lua b/lua/user/utils.lua index ab1473f..3c6f89e 100644 --- a/lua/user/utils.lua +++ b/lua/user/utils.lua @@ -31,6 +31,35 @@ function M.may_create_dir(dir) end end +-- toggle cmp completion +vim.g.cmp_toggle_flag = false -- initialize +local normal_buftype = function() + return vim.api.nvim_buf_get_option(0, "buftype") ~= "prompt" +end +M.toggle_completion = function() + local ok, cmp = pcall(require, "cmp") + if ok then + local next_cmp_toggle_flag = not vim.g.cmp_toggle_flag + if next_cmp_toggle_flag then + print("completion on") + else + print("completion off") + end + cmp.setup({ + enabled = function() + vim.g.cmp_toggle_flag = next_cmp_toggle_flag + if next_cmp_toggle_flag then + return normal_buftype + else + return next_cmp_toggle_flag + end + end, + }) + else + print("completion not available") + end +end + function M.get_nvim_version() local actual_ver = vim.version() @@ -38,25 +67,6 @@ function M.get_nvim_version() return nvim_ver_str end ---- Generate random integers in the range [Low, High], inclusive, ---- adapted from https://stackoverflow.com/a/12739441/6064933 ---- @low: the lower value for this range ---- @high: the upper value for this range -function M.rand_int(low, high) - -- Use lua to generate random int, see also: https://stackoverflow.com/a/20157671/6064933 - math.randomseed(os.time()) - - return math.random(low, high) -end - ---- Select a random element from a sequence/list. ---- @seq: the sequence to choose an element -function M.rand_element(seq) - local idx = M.rand_int(1, #seq) - - return seq[idx] -end - function M.add_pack(name) local status, error = pcall(vim.cmd, "packadd " .. name) |